cli: Fix build when libxml2 is absent

Also added a note to the top of cli-xml-output.c, explaining the style of coding to followed when adding code to it. Change-Id: I7f90a9c075adb49a9e071771d136b6f01ea68d11 BUG: 882780 Signed-off-by: Kaushal M <kaushal@redhat.com> Reviewed-on: http://review.gluster.org/4256 Tested-by: Gluster Build System <jenkins@build.gluster.com> Reviewed-by: Anand Avati <avati@redhat.com>
author: Kaushal M <kaushal@redhat.com> 2012-12-03 12:12:57 +0530
committer: Anand Avati <avati@redhat.com> 2012-12-03 01:01:12 -0800
commit: 3cade0a1e9dfc641e5b6db2f044af9f50ff604d6 (patch)
tree: 83bcbe86136322fe45d499120afec0a9a8341117 /cli
parent: f1ddc077a31671ff547efa205d86c1b8ebd3797a (diff)
1 files changed, 29 insertions, 0 deletions
diff --git a/cli/src/cli-xml-output.c b/cli/src/cli-xml-output.c
index 3e8bbdd4fbf..938f8dce18a 100644
--- a/cli/src/cli-xml-output.c
+++ b/cli/src/cli-xml-output.c
@@ -14,6 +14,33 @@
 #include "compat.h"
 #include "syscall.h"
 
+/*
+ * IMPORTANT NOTE:
+ * All exported functions in this file which use libxml need use a
+ * #if (HAVE_LIB_XML), #else, #endif
+ * For eg,
+ *      int exported_func () {
+ *              #if (HAVE_LIB_XML)
+ *                      <Stuff using libxml>
+ *              #else
+ *                      return 0;
+ *              #endif
+ *      }
+ *
+ *  All other functions, which are called internally within this file need to be
+ *  within #if (HAVE_LIB_XML), #endif statements
+ *  For eg,
+ *      #if (HAVE_LIB_XML)
+ *      int internal_func ()
+ *      {
+ *      }
+ *      #endif
+ *
+ *  Following the above formate ensures that all xml related code is compliled
+ *  only when libxml2 is present, and also keeps the rest of the codebase free
+ *  of #if (HAVE_LIB_XML)
+ */
+
 
 #if (HAVE_LIB_XML)
 
@@ -3169,6 +3196,7 @@ out:
 #endif
 }
 
+#if (HAVE_LIB_XML)
 int
 cli_xml_output_vol_gsync_status (dict_t *dict, xmlTextWriterPtr writer)
 {
@@ -3244,6 +3272,7 @@ out:
         gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret);
         return ret;
 }
+#endif
 
 int
 cli_xml_output_vol_gsync (dict_t *dict, int op_ret, int op_errno,
diff --git a/api/examples/glfsxmp.c b/api/examples/glfsxmp.c
index 9bfb1d2a81f..9d96eea1d87 100644
--- a/api/examples/glfsxmp.c
+++ b/api/examples/glfsxmp.c
@@ -6,1593 +6,1633 @@
 #include <string.h>
 #include <time.h>
 
-
 int
-test_dirops (glfs_t *fs)
+test_dirops(glfs_t *fs)
 {
-        glfs_fd_t *fd = NULL;
-        char buf[512];
-        struct dirent *entry = NULL;
-
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "/: %s\n", strerror (errno));
-                return -1;
-        }
-
-        fprintf (stderr, "Entries:\n");
-        while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) {
-                fprintf (stderr, "%s: %lu\n", entry->d_name, glfs_telldir (fd));
-        }
-
-        glfs_closedir (fd);
-        return 0;
+    glfs_fd_t *fd = NULL;
+    char buf[512];
+    struct dirent *entry = NULL;
+
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(stderr, "Entries:\n");
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        fprintf(stderr, "%s: %lu\n", entry->d_name, glfs_telldir(fd));
+    }
+
+    glfs_closedir(fd);
+    return 0;
 }
 
-
 int
-test_xattr (glfs_t *fs)
+test_xattr(glfs_t *fs)
 {
-        char *filename = "/filename2";
-        char buf[512];
-        char *ptr;
-        int ret;
-
-        ret = glfs_setxattr (fs, filename, "user.testkey", "testval", 8, 0);
-        fprintf (stderr, "setxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-
-        ret = glfs_setxattr (fs, filename, "user.testkey2", "testval", 8, 0);
-        fprintf (stderr, "setxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-
-        ret = glfs_listxattr (fs, filename, buf, 512);
-        fprintf (stderr, "listxattr(%s): %d (%s)\n", filename, ret,
-                 strerror (errno));
-        if (ret < 0)
-                return -1;
-
-        for (ptr = buf; ptr < buf + ret; ptr++) {
-                printf ("key=%s\n", ptr);
-                ptr += strlen (ptr);
-        }
-
-        return 0;
-}
-
-
-int
-test_chdir (glfs_t *fs)
-{
-        int ret = -1;
-        char *topdir = "/topdir";
-        char *linkdir = "/linkdir";
-        char *subdir = "./subdir";
-        char *respath = NULL;
-        char pathbuf[4096];
-
-        ret = glfs_mkdir (fs, topdir, 0755);
-        if (ret) {
-                fprintf (stderr, "mkdir(%s): %s\n", topdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
-
-        ret = glfs_symlink (fs, topdir, linkdir);
-        if (ret) {
-                fprintf (stderr, "symlink(%s, %s): %s\n", topdir, linkdir, strerror (errno));
-                return -1;
-        }
+    char *filename = "/filename2";
+    char buf[512];
+    char *ptr;
+    int ret;
 
-        ret = glfs_chdir (fs, linkdir);
-        if (ret) {
-                fprintf (stderr, "chdir(%s): %s\n", linkdir, strerror (errno));
-                return -1;
-        }
+    ret = glfs_setxattr(fs, filename, "user.testkey", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
 
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
+    ret = glfs_setxattr(fs, filename, "user.testkey2", "testval", 8, 0);
+    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
 
-        respath = glfs_realpath (fs, subdir, pathbuf);
-        if (respath) {
-                fprintf (stderr, "realpath(%s) worked unexpectedly: %s\n", subdir, respath);
-                return -1;
-        }
+    ret = glfs_listxattr(fs, filename, buf, 512);
+    fprintf(stderr, "listxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
+    if (ret < 0)
+        return -1;
 
-        ret = glfs_mkdir (fs, subdir, 0755);
-        if (ret) {
-                fprintf (stderr, "mkdir(%s): %s\n", subdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_realpath (fs, subdir, pathbuf);
-        if (!respath) {
-                fprintf (stderr, "realpath(%s): %s\n", subdir, strerror (errno));
-        } else {
-                fprintf (stdout, "realpath(%s) = %s\n", subdir, respath);
-        }
+    for (ptr = buf; ptr < buf + ret; ptr++) {
+        printf("key=%s\n", ptr);
+        ptr += strlen(ptr);
+    }
 
-        ret = glfs_chdir (fs, subdir);
-        if (ret) {
-                fprintf (stderr, "chdir(%s): %s\n", subdir, strerror (errno));
-                return -1;
-        }
-
-        respath = glfs_getcwd (fs, pathbuf, 4096);
-        fprintf (stdout, "getcwd() = %s\n", respath);
-
-        respath = glfs_realpath (fs, "/linkdir/subdir", pathbuf);
-        if (!respath) {
-                fprintf (stderr, "realpath(/linkdir/subdir): %s\n", strerror (errno));
-        } else {
-                fprintf (stdout, "realpath(/linkdir/subdir) = %s\n", respath);
-        }
+    return 0;
+}
 
-        return 0;
+int
+test_chdir(glfs_t *fs)
+{
+    int ret = -1;
+    char *topdir = "/topdir";
+    char *linkdir = "/linkdir";
+    char *subdir = "./subdir";
+    char *respath = NULL;
+    char pathbuf[4096];
+
+    ret = glfs_mkdir(fs, topdir, 0755);
+    if (ret) {
+        fprintf(stderr, "mkdir(%s): %s\n", topdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    ret = glfs_symlink(fs, topdir, linkdir);
+    if (ret) {
+        fprintf(stderr, "symlink(%s, %s): %s\n", topdir, linkdir,
+                strerror(errno));
+        return -1;
+    }
+
+    ret = glfs_chdir(fs, linkdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", linkdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (respath) {
+        fprintf(stderr, "realpath(%s) worked unexpectedly: %s\n", subdir,
+                respath);
+        return -1;
+    }
+
+    ret = glfs_mkdir(fs, subdir, 0755);
+    if (ret) {
+        fprintf(stderr, "mkdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_realpath(fs, subdir, pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(%s): %s\n", subdir, strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(%s) = %s\n", subdir, respath);
+    }
+
+    ret = glfs_chdir(fs, subdir);
+    if (ret) {
+        fprintf(stderr, "chdir(%s): %s\n", subdir, strerror(errno));
+        return -1;
+    }
+
+    respath = glfs_getcwd(fs, pathbuf, 4096);
+    fprintf(stdout, "getcwd() = %s\n", respath);
+
+    respath = glfs_realpath(fs, "/linkdir/subdir", pathbuf);
+    if (!respath) {
+        fprintf(stderr, "realpath(/linkdir/subdir): %s\n", strerror(errno));
+    } else {
+        fprintf(stdout, "realpath(/linkdir/subdir) = %s\n", respath);
+    }
+
+    return 0;
 }
 
 #ifdef DEBUG
 static void
-peek_stat (struct stat *sb)
+peek_stat(struct stat *sb)
 {
-        printf ("Dumping stat information:\n");
-        printf ("File type:                ");
-
-        switch (sb->st_mode & S_IFMT) {
-                case S_IFBLK:  printf ("block device\n");            break;
-                case S_IFCHR:  printf ("character device\n");        break;
-                case S_IFDIR:  printf ("directory\n");               break;
-                case S_IFIFO:  printf ("FIFO/pipe\n");               break;
-                case S_IFLNK:  printf ("symlink\n");                 break;
-                case S_IFREG:  printf ("regular file\n");            break;
-                case S_IFSOCK: printf ("socket\n");                  break;
-                default:       printf ("unknown?\n");                break;
-        }
-
-        printf ("I-node number:            %ld\n", (long) sb->st_ino);
-
-        printf ("Mode:                     %lo (octal)\n",
-                (unsigned long) sb->st_mode);
-
-        printf ("Link count:               %ld\n", (long) sb->st_nlink);
-        printf ("Ownership:                UID=%ld   GID=%ld\n",
-                (long) sb->st_uid, (long) sb->st_gid);
-
-        printf ("Preferred I/O block size: %ld bytes\n",
-                (long) sb->st_blksize);
-        printf ("File size:                %lld bytes\n",
-                (long long) sb->st_size);
-        printf ("Blocks allocated:         %lld\n",
-                (long long) sb->st_blocks);
-
-        printf ("Last status change:       %s", ctime(&sb->st_ctime));
-        printf ("Last file access:         %s", ctime(&sb->st_atime));
-        printf ("Last file modification:   %s", ctime(&sb->st_mtime));
-
-        return;
+    printf("Dumping stat information:\n");
+    printf("File type:                ");
+
+    switch (sb->st_mode & S_IFMT) {
+        case S_IFBLK:
+            printf("block device\n");
+            break;
+        case S_IFCHR:
+            printf("character device\n");
+            break;
+        case S_IFDIR:
+            printf("directory\n");
+            break;
+        case S_IFIFO:
+            printf("FIFO/pipe\n");
+            break;
+        case S_IFLNK:
+            printf("symlink\n");
+            break;
+        case S_IFREG:
+            printf("regular file\n");
+            break;
+        case S_IFSOCK:
+            printf("socket\n");
+            break;
+        default:
+            printf("unknown?\n");
+            break;
+    }
+
+    printf("I-node number:            %ld\n", (long)sb->st_ino);
+
+    printf("Mode:                     %lo (octal)\n",
+           (unsigned long)sb->st_mode);
+
+    printf("Link count:               %ld\n", (long)sb->st_nlink);
+    printf("Ownership:                UID=%ld   GID=%ld\n", (long)sb->st_uid,
+           (long)sb->st_gid);
+
+    printf("Preferred I/O block size: %ld bytes\n", (long)sb->st_blksize);
+    printf("File size:                %lld bytes\n", (long long)sb->st_size);
+    printf("Blocks allocated:         %lld\n", (long long)sb->st_blocks);
+
+    printf("Last status change:       %s", ctime(&sb->st_ctime));
+    printf("Last file access:         %s", ctime(&sb->st_atime));
+    printf("Last file modification:   %s", ctime(&sb->st_mtime));
+
+    return;
 }
 
 static void
-peek_handle (unsigned char *glid)
+peek_handle(unsigned char *glid)
 {
-        int i;
+    int i;
 
-        for (i = 0; i < GFAPI_HANDLE_LENGTH; i++)
-        {
-                printf (":%02x:", glid[i]);
-        }
-        printf ("\n");
+    for (i = 0; i < GFAPI_HANDLE_LENGTH; i++) {
+        printf(":%02x:", glid[i]);
+    }
+    printf("\n");
 }
-#else /* DEBUG */
+#else  /* DEBUG */
 static void
-peek_stat (struct stat *sb)
+peek_stat(struct stat *sb)
 {
-        return;
+    return;
 }
 
 static void
-peek_handle (unsigned char *id)
+peek_handle(unsigned char *id)
 {
-        return;
+    return;
 }
 #endif /* DEBUG */
 
-glfs_t    *fs = NULL;
-char      *full_parent_name = "/testdir", *parent_name = "testdir";
+glfs_t *fs = NULL;
+char *full_parent_name = "/testdir", *parent_name = "testdir";
 
 void
-test_h_unlink (void)
+test_h_unlink(void)
 {
-        char               *my_dir = "unlinkdir";
-        char               *my_file = "file.txt";
-        char               *my_subdir = "dir1";
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
-                           *subdir = NULL, *subleaf = NULL;
-        struct stat         sb;
-        int                 ret;
-
-        printf ("glfs_h_unlink tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        subdir = glfs_h_mkdir (fs, dir, my_subdir, 0644, &sb);
-        if (subdir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_subdir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        subleaf = glfs_h_creat (fs, subdir, my_file, O_CREAT, 0644, &sb);
-        if (subleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non empty directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
-                         my_subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink regular file */
-        ret = glfs_h_unlink (fs, subdir, my_file);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_file, subdir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_subdir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink regular file */
-        ret = glfs_h_unlink (fs, dir, my_file);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non-existent regular file */
-        ret = glfs_h_unlink (fs, dir, my_file);
-        if ((ret && errno != ENOENT) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking non-existent %s: invalid errno ,%d, %s\n",
-                         my_file, ret, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink non-existent directory */
-        ret = glfs_h_unlink (fs, dir, my_subdir);
-        if ((ret && errno != ENOENT) || (ret == 0)) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking non-existent %s:  invalid errno ,%d, %s\n",
-                         my_subdir, ret, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        /* unlink directory */
-        ret = glfs_h_unlink (fs, parent, my_dir);
-        if (ret) {
-                fprintf (stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_unlink tests: PASSED\n");
+    char *my_dir = "unlinkdir";
+    char *my_file = "file.txt";
+    char *my_subdir = "dir1";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
+                       *subdir = NULL, *subleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_unlink tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0644, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subdir = glfs_h_mkdir(fs, dir, my_subdir, 0644, &sb);
+    if (subdir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    subleaf = glfs_h_creat(fs, subdir, my_file, O_CREAT, 0644, &sb);
+    if (subleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non empty directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
+                my_subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, subdir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, subdir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_subdir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent regular file */
+    ret = glfs_h_unlink(fs, dir, my_file);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s: invalid errno "
+                ",%d, %s\n",
+                my_file, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink non-existent directory */
+    ret = glfs_h_unlink(fs, dir, my_subdir);
+    if ((ret && errno != ENOENT) || (ret == 0)) {
+        fprintf(stderr,
+                "glfs_h_unlink: error unlinking non-existent %s:  invalid "
+                "errno ,%d, %s\n",
+                my_subdir, ret, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    /* unlink directory */
+    ret = glfs_h_unlink(fs, parent, my_dir);
+    if (ret) {
+        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
+                my_dir, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_unlink tests: PASSED\n");
 
 out:
-        if (dir)
-                glfs_h_close (dir);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (subdir)
-                glfs_h_close (subdir);
-        if (subleaf)
-                glfs_h_close (subleaf);
-        if (parent)
-                glfs_h_close (parent);
-
-        return;
+    if (dir)
+        glfs_h_close(dir);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (subdir)
+        glfs_h_close(subdir);
+    if (subleaf)
+        glfs_h_close(subleaf);
+    if (parent)
+        glfs_h_close(parent);
+
+    return;
 }
 
 void
-test_h_getsetattrs (void)
+test_h_getsetattrs(void)
 {
-        char               *my_dir = "attrdir";
-        char               *my_file = "attrfile.txt";
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
-        struct stat         sb, retsb;
-        int                 ret, valid;
-        struct timespec     timestamp;
-
-        printf("glfs_h_getattrs and setattrs tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, dir, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dir, strerror (errno));
-                printf ("glfs_h_unlink tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = glfs_h_getattrs (fs, dir, &retsb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&retsb);
-        /* TODO: Compare stat information */
-
-        retsb.st_mode = 00666;
-        retsb.st_uid = 1000;
-        retsb.st_gid = 1001;
-        ret = clock_gettime (CLOCK_REALTIME, &timestamp);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        retsb.st_atim = timestamp;
-        retsb.st_mtim = timestamp;
-        valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
-        GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
-        peek_stat (&retsb);
-
-        ret = glfs_h_setattrs (fs, dir, &retsb, valid);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_setattrs: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-
-        memset(&retsb, 0, sizeof (struct stat));
-        ret = glfs_h_stat (fs, dir, &retsb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_stat: error %s: from (%p),%s\n",
-                         my_dir, dir, strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&retsb);
-
-        printf ("glfs_h_getattrs and setattrs tests: PASSED\n");
+    char *my_dir = "attrdir";
+    char *my_file = "attrfile.txt";
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb, retsb;
+    int ret, valid;
+    struct timespec timestamp;
+
+    printf("glfs_h_getattrs and setattrs tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0644, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dir, strerror(errno));
+        printf("glfs_h_unlink tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_getattrs(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+    /* TODO: Compare stat information */
+
+    retsb.st_mode = 00666;
+    retsb.st_uid = 1000;
+    retsb.st_gid = 1001;
+    ret = clock_gettime(CLOCK_REALTIME, &timestamp);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    retsb.st_atim = timestamp;
+    retsb.st_mtim = timestamp;
+    valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
+            GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
+    peek_stat(&retsb);
+
+    ret = glfs_h_setattrs(fs, dir, &retsb, valid);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_setattrs: error %s: from (%p),%s\n", my_dir,
+                dir, strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    memset(&retsb, 0, sizeof(struct stat));
+    ret = glfs_h_stat(fs, dir, &retsb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_stat: error %s: from (%p),%s\n", my_dir, dir,
+                strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&retsb);
+
+    printf("glfs_h_getattrs and setattrs tests: PASSED\n");
 out:
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dir)
-                glfs_h_close (dir);
-
-        return;
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dir)
+        glfs_h_close(dir);
+
+    return;
 }
 
 void
-test_h_truncate (void)
+test_h_truncate(void)
 {
-        char               *my_dir = "truncatedir";
-        char               *my_file = "file.txt";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
-        struct stat         sb;
-        glfs_fd_t          *fd = NULL;
-        char                buf[32];
-        off_t               offset = 0;
-        int                 ret = 0;
-
-        printf("glfs_h_truncate tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         my_file, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        memcpy (buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, buf, 32, 0);
-
-        /* run tests */
-        /* truncate lower */
-        offset = 30;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        /* truncate higher */
-        offset = 32;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        /* truncate equal */
-        offset = 30;
-        ret = glfs_h_truncate (fs, leaf, offset);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        ret = glfs_h_getattrs (fs, leaf, &sb);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_getattrs: error for %s (%p),%s\n",
-                         my_file, leaf, strerror (errno));
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-        if (sb.st_size != offset) {
-                fprintf (stderr, "glfs_h_truncate: post size mismatch\n");
-                printf ("glfs_h_truncate tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_truncate tests: PASSED\n");
+    char *my_dir = "truncatedir";
+    char *my_file = "file.txt";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
+    struct stat sb;
+    glfs_fd_t *fd = NULL;
+    char buf[32];
+    off_t offset = 0;
+    int ret = 0;
+
+    printf("glfs_h_truncate tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0644, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n", my_file,
+                strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    memcpy(buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, buf, 32, 0);
+
+    /* run tests */
+    /* truncate lower */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate higher */
+    offset = 32;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    /* truncate equal */
+    offset = 30;
+    ret = glfs_h_truncate(fs, leaf, offset);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    ret = glfs_h_getattrs(fs, leaf, &sb);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
+                leaf, strerror(errno));
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+    if (sb.st_size != offset) {
+        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
+        printf("glfs_h_truncate tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_truncate tests: PASSED\n");
 out:
-        if (fd)
-                glfs_close (fd);
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-
-        return;
+    if (fd)
+        glfs_close(fd);
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return;
 }
 
 void
-test_h_links (void)
+test_h_links(void)
 {
-        char               *my_dir = "linkdir";
-        char               *my_file = "file.txt";
-        char               *my_symlnk = "slnk.txt";
-        char               *my_lnk = "lnk.txt";
-        char               *linksrc_dir = "dir1";
-        char               *linktgt_dir = "dir2";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
-        struct glfs_object *ln1 = NULL;
-        struct stat         sb;
-        int                 ret;
-        char               *buf = NULL;
-
-        printf("glfs_h_link(s) tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirsrc = glfs_h_mkdir (fs, parent, linksrc_dir, 0644, &sb);
-        if (dirsrc == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         linksrc_dir, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirtgt = glfs_h_mkdir (fs, parent, linktgt_dir, 0644, &sb);
-        if (dirtgt == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         linktgt_dir, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
-        if (dleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dirsrc, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* run tests */
-        /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
-        ln1 = glfs_h_symlink (fs, parent, my_symlnk, "./file.txt", &sb);
-        if (ln1 == NULL) {
-                fprintf (stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
-                         my_symlnk, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        buf = calloc (1024, sizeof(char));
-        if (buf == NULL) {
-                fprintf (stderr, "Error allocating memory\n");
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-
-        ret = glfs_h_readlink (fs, ln1, buf, 1024);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
-                         my_symlnk, ln1, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        if (!(strncmp (buf, my_symlnk, strlen (my_symlnk)))) {
-                fprintf (stderr, "glfs_h_readlink: error mismatch in link name: actual %s: retrieved %s\n",
-                         my_symlnk, buf);
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-
-        /* link: /testdir/linkdir/file.txt to ./lnk.txt */
-        ret = glfs_h_link (fs, leaf, parent, my_lnk);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
-                         my_lnk, parent, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        /* TODO: Should write content to a file and read from the link */
-
-        /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
-        ret = glfs_h_link (fs, dleaf, dirtgt, my_lnk);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
-                         my_lnk, dirtgt, strerror (errno));
-                printf ("glfs_h_link(s) tests: FAILED\n");
-                goto out;
-        }
-        /* TODO: Should write content to a file and read from the link */
-
-        printf ("glfs_h_link(s) tests: PASSED\n");
+    char *my_dir = "linkdir";
+    char *my_file = "file.txt";
+    char *my_symlnk = "slnk.txt";
+    char *my_lnk = "lnk.txt";
+    char *linksrc_dir = "dir1";
+    char *linktgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct glfs_object *ln1 = NULL;
+    struct stat sb;
+    int ret;
+    char *buf = NULL;
+
+    printf("glfs_h_link(s) tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0644, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, linksrc_dir, 0644, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linksrc_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, linktgt_dir, 0644, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                linktgt_dir, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
+    ln1 = glfs_h_symlink(fs, parent, my_symlnk, "./file.txt", &sb);
+    if (ln1 == NULL) {
+        fprintf(stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
+                my_symlnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    buf = calloc(1024, sizeof(char));
+    if (buf == NULL) {
+        fprintf(stderr, "Error allocating memory\n");
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    ret = glfs_h_readlink(fs, ln1, buf, 1024);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
+                my_symlnk, ln1, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    if (!(strncmp(buf, my_symlnk, strlen(my_symlnk)))) {
+        fprintf(stderr,
+                "glfs_h_readlink: error mismatch in link name: actual %s: "
+                "retrieved %s\n",
+                my_symlnk, buf);
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+
+    /* link: /testdir/linkdir/file.txt to ./lnk.txt */
+    ret = glfs_h_link(fs, leaf, parent, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, parent, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
+    ret = glfs_h_link(fs, dleaf, dirtgt, my_lnk);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
+                my_lnk, dirtgt, strerror(errno));
+        printf("glfs_h_link(s) tests: FAILED\n");
+        goto out;
+    }
+    /* TODO: Should write content to a file and read from the link */
+
+    printf("glfs_h_link(s) tests: PASSED\n");
 
 out:
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dirsrc)
-                glfs_h_close (dirsrc);
-        if (dirtgt)
-                glfs_h_close (dirtgt);
-        if (dleaf)
-                glfs_h_close (dleaf);
-        if (ln1)
-                glfs_h_close (ln1);
-        if (buf)
-                free (buf);
-
-        return;
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+    if (ln1)
+        glfs_h_close(ln1);
+    if (buf)
+        free(buf);
+
+    return;
 }
 
 void
-test_h_rename (void)
+test_h_rename(void)
 {
-        char               *my_dir = "renamedir";
-        char               *my_file = "file.txt";
-        char               *src_dir = "dir1";
-        char               *tgt_dir = "dir2";
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
-        struct stat         sb;
-        int                 ret;
-
-        printf("glfs_h_rename tests: In Progress\n");
-
-        /* Prepare tests */
-        root = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_mkdir (fs, root, my_dir, 0644, &sb);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, root, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, my_file, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirsrc = glfs_h_mkdir (fs, parent, src_dir, 0644, &sb);
-        if (dirsrc == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         src_dir, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dirtgt = glfs_h_mkdir (fs, parent, tgt_dir, 0644, &sb);
-        if (dirtgt == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         tgt_dir, parent, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        dleaf = glfs_h_creat (fs, dirsrc, my_file, O_CREAT, 0644, &sb);
-        if (dleaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                         my_file, dirsrc, strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* run tests */
-        /* Rename file.txt -> file1.txt */
-        ret = glfs_h_rename (fs, parent, "file.txt", parent, "file1.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "file.txt", "file1.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir1/file.txt -> file.txt */
-        ret = glfs_h_rename (fs, dirsrc, "file.txt", parent, "file.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
-                         src_dir, "file.txt", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename file1.txt -> file.txt (exists) */
-        ret = glfs_h_rename (fs, parent, "file1.txt", parent, "file.txt");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "file.txt", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir1 -> dir3 */
-        ret = glfs_h_rename (fs, parent, "dir1", parent, "dir3");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "dir1", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir2 ->dir3 (exists) */
-        ret = glfs_h_rename (fs, parent, "dir2", parent, "dir3");
-        if (ret != 0) {
-                fprintf (stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
-                         "dir2", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename file.txt -> dir3 (fail) */
-        ret = glfs_h_rename (fs, parent, "file.txt", parent, "dir3");
-        if (ret == 0) {
-                fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
-                         "file.txt", "dir3", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        /* rename dir3 -> file.txt (fail) */
-        ret = glfs_h_rename (fs, parent, "dir3", parent, "file.txt");
-        if (ret == 0) {
-                fprintf (stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
-                         "dir3", "file.txt", strerror (errno));
-                printf ("glfs_h_rename tests: FAILED\n");
-                goto out;
-        }
-
-        printf ("glfs_h_rename tests: PASSED\n");
+    char *my_dir = "renamedir";
+    char *my_file = "file.txt";
+    char *src_dir = "dir1";
+    char *tgt_dir = "dir2";
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
+                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
+    struct stat sb;
+    int ret;
+
+    printf("glfs_h_rename tests: In Progress\n");
+
+    /* Prepare tests */
+    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_mkdir(fs, root, my_dir, 0644, &sb);
+    if (parent == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, root, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirsrc = glfs_h_mkdir(fs, parent, src_dir, 0644, &sb);
+    if (dirsrc == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                src_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dirtgt = glfs_h_mkdir(fs, parent, tgt_dir, 0644, &sb);
+    if (dirtgt == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                tgt_dir, parent, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
+    if (dleaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                my_file, dirsrc, strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* run tests */
+    /* Rename file.txt -> file1.txt */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "file1.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file1.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1/file.txt -> file.txt */
+    ret = glfs_h_rename(fs, dirsrc, "file.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
+                src_dir, "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file1.txt -> file.txt (exists) */
+    ret = glfs_h_rename(fs, parent, "file1.txt", parent, "file.txt");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
+                "file.txt", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir1 -> dir3 */
+    ret = glfs_h_rename(fs, parent, "dir1", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir1",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir2 ->dir3 (exists) */
+    ret = glfs_h_rename(fs, parent, "dir2", parent, "dir3");
+    if (ret != 0) {
+        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir2",
+                "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename file.txt -> dir3 (fail) */
+    ret = glfs_h_rename(fs, parent, "file.txt", parent, "dir3");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "file.txt", "dir3", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    /* rename dir3 -> file.txt (fail) */
+    ret = glfs_h_rename(fs, parent, "dir3", parent, "file.txt");
+    if (ret == 0) {
+        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
+                "dir3", "file.txt", strerror(errno));
+        printf("glfs_h_rename tests: FAILED\n");
+        goto out;
+    }
+
+    printf("glfs_h_rename tests: PASSED\n");
 
 out:
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-        if (dirsrc)
-                glfs_h_close (dirsrc);
-        if (dirtgt)
-                glfs_h_close (dirtgt);
-        if (dleaf)
-                glfs_h_close (dleaf);
-
-        return;
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+    if (dirsrc)
+        glfs_h_close(dirsrc);
+    if (dirtgt)
+        glfs_h_close(dirtgt);
+    if (dleaf)
+        glfs_h_close(dleaf);
+
+    return;
 }
 
 void
-assimilatetime (struct timespec *ts, struct timespec ts_st,
-                struct timespec ts_ed)
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
 {
-        if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
-                ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
-        } else {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
-                ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
-        }
-
-        if (ts->tv_nsec > 1000000000) {
-                ts->tv_nsec = ts->tv_nsec - 1000000000;
-                ts->tv_sec += 1;
-        }
-
-        return;
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
 }
 
 #define MAX_FILES_CREATE 10
-#define MAXPATHNAME      512
+#define MAXPATHNAME 512
 void
-test_h_performance (void)
+test_h_performance(void)
 {
-        char               *my_dir = "perftest",
-                           *full_dir_path="/testdir/perftest";
-        char               *my_file = "file_", my_file_name[MAXPATHNAME];
-        struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
-        struct stat         sb;
-        int                 ret, i;
-        struct glfs_fd     *fd;
-        struct timespec     c_ts = {0, 0}, c_ts_st, c_ts_ed;
-        struct timespec     o_ts = {0, 0}, o_ts_st, o_ts_ed;
-
-        printf("glfs_h_performance tests: In Progress\n");
-
-        /* Prepare tests */
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, NULL, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-
-        dir = glfs_h_mkdir (fs, parent, my_dir, 0644, &sb);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* create performance */
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+    char *my_dir = "perftest", *full_dir_path = "/testdir/perftest";
+    char *my_file = "file_", my_file_name[MAXPATHNAME];
+    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
+    struct stat sb;
+    int ret, i;
+    struct glfs_fd *fd;
+    struct timespec c_ts = {0, 0}, c_ts_st, c_ts_ed;
+    struct timespec o_ts = {0, 0}, o_ts_st, o_ts_ed;
+
+    printf("glfs_h_performance tests: In Progress\n");
+
+    /* Prepare tests */
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, NULL, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+
+    dir = glfs_h_mkdir(fs, parent, my_dir, 0644, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
+                my_dir, parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* create performance */
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
         }
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s%d", my_file, i);
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                leaf = glfs_h_lookupat (fs, dir, my_file_name, &sb, 0);
-                if (leaf != NULL) {
-                        fprintf (stderr, "glfs_h_lookup: exists %s\n",
-                                 my_file_name);
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                leaf = glfs_h_creat (fs, dir, my_file_name, O_CREAT, 0644, &sb);
-                if (leaf == NULL) {
-                        fprintf (stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
-                                 my_file, dir, strerror (errno));
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                assimilatetime (&c_ts, c_ts_st, c_ts_ed);
-                glfs_h_close (leaf); leaf = NULL;
+        leaf = glfs_h_lookupat(fs, dir, my_file_name, &sb, 0);
+        if (leaf != NULL) {
+            fprintf(stderr, "glfs_h_lookup: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+        leaf = glfs_h_creat(fs, dir, my_file_name, O_CREAT, 0644, &sb);
+        if (leaf == NULL) {
+            fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        assimilatetime (&o_ts, o_ts_st, o_ts_ed);
-
-        printf ("Creation performance (handle based):\n\t# empty files:%d\n",
-                MAX_FILES_CREATE);
-        printf ("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                o_ts.tv_sec, o_ts.tv_nsec);
-        printf ("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                c_ts.tv_sec, c_ts.tv_nsec);
-
-        /* create using path */
-        c_ts.tv_sec = o_ts.tv_sec = 0;
-        c_ts.tv_nsec = o_ts.tv_nsec = 0;
-
-        sprintf (my_file_name, "%s1", full_dir_path);
-        ret = glfs_mkdir (fs, my_file_name, 0644);
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
         if (ret != 0) {
-                fprintf (stderr, "glfs_mkdir: error creating %s: from (%p),%s\n",
-                         my_dir, parent, strerror (errno));
-                printf ("glfs_h_performance tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_st);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_h_close(leaf);
+        leaf = NULL;
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (handle based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
+
+    /* create using path */
+    c_ts.tv_sec = o_ts.tv_sec = 0;
+    c_ts.tv_nsec = o_ts.tv_nsec = 0;
+
+    sprintf(my_file_name, "%s1", full_dir_path);
+    ret = glfs_mkdir(fs, my_file_name, 0644);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_mkdir: error creating %s: from (%p),%s\n", my_dir,
+                parent, strerror(errno));
+        printf("glfs_h_performance tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
+
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
         }
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_st);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = glfs_stat (fs, my_file_name, &sb);
-                if (ret == 0) {
-                        fprintf (stderr, "glfs_stat: exists %s\n",
-                                 my_file_name);
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                fd = glfs_creat (fs, my_file_name, O_CREAT, 0644);
-                if (fd == NULL) {
-                        fprintf (stderr, "glfs_creat: error creating %s: from (%p),%s\n",
-                                 my_file, dir, strerror (errno));
-                        printf ("glfs_h_performance tests: FAILED\n");
-                        goto out;
-                }
-
-                ret = clock_gettime (CLOCK_REALTIME, &c_ts_ed);
-                if(ret != 0) {
-                        fprintf (stderr, "clock_gettime: error %s\n",
-                                 strerror (errno));
-                        printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                        goto out;
-                }
-
-                assimilatetime (&c_ts, c_ts_st, c_ts_ed);
-                glfs_close (fd);
+        ret = glfs_stat(fs, my_file_name, &sb);
+        if (ret == 0) {
+            fprintf(stderr, "glfs_stat: exists %s\n", my_file_name);
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        ret = clock_gettime (CLOCK_REALTIME, &o_ts_ed);
-        if(ret != 0) {
-                fprintf (stderr, "clock_gettime: error %s\n", strerror (errno));
-                printf ("glfs_h_getattrs and setattrs tests: FAILED\n");
-                goto out;
+        fd = glfs_creat(fs, my_file_name, O_CREAT, 0644);
+        if (fd == NULL) {
+            fprintf(stderr, "glfs_creat: error creating %s: from (%p),%s\n",
+                    my_file, dir, strerror(errno));
+            printf("glfs_h_performance tests: FAILED\n");
+            goto out;
         }
 
-        assimilatetime (&o_ts, o_ts_st, o_ts_ed);
-
-        printf ("Creation performance (path based):\n\t# empty files:%d\n",
-                MAX_FILES_CREATE);
-        printf ("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                o_ts.tv_sec, o_ts.tv_nsec);
-        printf ("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                c_ts.tv_sec, c_ts.tv_nsec);
+        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
+        if (ret != 0) {
+            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+            goto out;
+        }
+
+        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
+        glfs_close(fd);
+    }
+
+    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
+    if (ret != 0) {
+        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
+        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
+        goto out;
+    }
+
+    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
+
+    printf("Creation performance (path based):\n\t# empty files:%d\n",
+           MAX_FILES_CREATE);
+    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
+           o_ts.tv_nsec);
+    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           c_ts.tv_sec, c_ts.tv_nsec);
 out:
-        return;
+    return;
 }
 
 int
-test_handleops (int argc, char *argv[])
+test_handleops(int argc, char *argv[])
 {
-        int                 ret = 0;
-        glfs_fd_t          *fd = NULL;
-        struct stat         sb = {0, };
-        struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
-                           *tmp = NULL;
-        char                readbuf[32], writebuf[32];
-        unsigned char       leaf_handle[GFAPI_HANDLE_LENGTH];
-
-        char *full_leaf_name = "/testdir/testfile.txt",
-             *leaf_name = "testfile.txt",
-             *relative_leaf_name = "testdir/testfile.txt";
-        char *leaf_name1 = "testfile1.txt";
-        char *full_newparent_name = "/testdir/dir1",
-             *newparent_name = "dir1";
-        char *full_newnod_name = "/testdir/nod1",
-             *newnod_name = "nod1";
-
-        /* Initialize test area */
-        ret = glfs_mkdir (fs, full_parent_name, 0644);
-        if (ret != 0 && errno != EEXIST) {
-                fprintf (stderr, "%s: (%p) %s\n", full_parent_name, fd,
-                        strerror (errno));
-                printf ("Test initialization failed on volume %s\n", argv[1]);
-                goto out;
-        }
-        else if (ret != 0) {
-                printf ("Found test directory %s to be existing\n",
-                        full_parent_name);
-                printf ("Cleanup test directory and restart tests\n");
-                goto out;
-        }
-
-        fd = glfs_creat (fs, full_leaf_name, O_CREAT, 0644);
-        if (fd == NULL) {
-                fprintf (stderr, "%s: (%p) %s\n", full_leaf_name, fd,
-                        strerror (errno));
-                printf ("Test initialization failed on volume %s\n", argv[1]);
-                goto out;
-        }
-        glfs_close (fd);
-
-        printf ("Initialized the test area, within volume %s\n", argv[1]);
-
-        /* Handle based APIs test area */
-
-        /* glfs_lookupat test */
-        printf ("glfs_h_lookupat tests: In Progress\n");
-        /* start at root of the volume */
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         "/", NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* lookup a parent within root */
-        parent = glfs_h_lookupat (fs, root, parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         parent_name, root, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* lookup a leaf/child within the parent */
-        leaf = glfs_h_lookupat (fs, parent, leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         leaf_name, parent, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (root); root = NULL;
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        /* check absolute paths */
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         "/", NULL, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_lookupat (fs, NULL, full_leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_leaf_name, parent, strerror (errno));
-                printf ("glfs_h_lookupat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (leaf); leaf = NULL;
-
-        /* check multiple component paths */
-        leaf = glfs_h_lookupat (fs, root, relative_leaf_name, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         relative_leaf_name, parent, strerror (errno));
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* reset */
-        glfs_h_close (root); root = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        /* check symlinks in path */
-
-        /* TODO: -ve test cases */
-        /* parent invalid
-        * path invalid
-        * path does not exist after some components
-        * no parent, but relative path
-        * parent and full path? -ve?
-        */
-
-        printf ("glfs_h_lookupat tests: PASSED\n");
-
-        /* glfs_openat test */
-        printf ("glfs_h_open tests: In Progress\n");
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_open tests: FAILED\n");
-                goto out;
-        }
-
-        /* test read/write based on fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, writebuf, 32, 0);
-
-        glfs_lseek (fd, 0, SEEK_SET);
-
-        ret = glfs_read (fd, readbuf, 32, 0);
-        if (memcmp (readbuf, writebuf, 32)) {
-                printf ("Failed to read what I wrote: %s %s\n", readbuf,
-                        writebuf);
-                glfs_close (fd);
-                printf ("glfs_h_open tests: FAILED\n");
-                goto out;
-        }
-
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_close (fd);
-
-        printf ("glfs_h_open tests: PASSED\n");
-
-        /* Create tests */
-        printf ("glfs_h_creat tests: In Progress\n");
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
-                         leaf_name1, parent, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_creat (fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644,
-                            &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_creat: existing file, leaf = (%p), errno = %s\n",
-                        leaf, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
-
-        tmp = glfs_h_creat (fs, root, parent_name, O_CREAT, 0644, &sb);
-        if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
-                fprintf (stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
-                        leaf, strerror (errno));
-                printf ("glfs_h_creat tests: FAILED\n");
-                if (tmp != NULL) {
-                        glfs_h_close (tmp); tmp = NULL;
-                }
-        }
-
-        /* TODO: Other combinations and -ve cases as applicable */
-        printf ("glfs_h_creat tests: PASSED\n");
-
-        /* extract handle and create from handle test */
-        printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: In Progress\n");
-        /* TODO: Change the lookup to create below for a GIFD recovery failure,
-         * that needs to be fixed */
-        leaf = glfs_h_lookupat (fs, parent, leaf_name1, &sb, 0);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         leaf_name1, parent, strerror (errno));
-                printf ("glfs_h_extract_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        ret = glfs_h_extract_handle (leaf, leaf_handle,
-                                             GFAPI_HANDLE_LENGTH);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_extract_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_handle (leaf_handle);
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_create_from_handle (fs, leaf_handle, GFAPI_HANDLE_LENGTH,
-                                          &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
-                         leaf_name1, leaf_handle, strerror (errno));
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        fd = glfs_h_open (fs, leaf, O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_h_open: error on open of %s: %s\n",
-                         full_leaf_name, strerror (errno));
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                goto out;
-        }
-
-        /* test read/write based on fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-        ret = glfs_write (fd, writebuf, 32, 0);
-
-        glfs_lseek (fd, 0, SEEK_SET);
-
-        ret = glfs_read (fd, readbuf, 32, 0);
-        if (memcmp (readbuf, writebuf, 32)) {
-                printf ("Failed to read what I wrote: %s %s\n", writebuf,
-                        writebuf);
-                printf ("glfs_h_create_from_handle tests: FAILED\n");
-                glfs_close (fd);
-                goto out;
-        }
-
-        glfs_close (fd);
-        glfs_h_close (leaf); leaf = NULL;
-        glfs_h_close (parent); parent = NULL;
-
-        printf ("glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
-
-        /* Mkdir tests */
-        printf ("glfs_h_mkdir tests: In Progress\n");
-
-        ret = glfs_rmdir (fs, full_newparent_name);
-        if (ret && errno != ENOENT) {
-                fprintf (stderr, "glfs_rmdir: Failed for %s: %s\n",
-                         full_newparent_name, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
-
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
-                         newparent_name, parent, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_mkdir (fs, parent, newparent_name, 0644, &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
-                         leaf, strerror (errno));
-                printf ("glfs_h_mkdir tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
-
-        glfs_h_close (parent); parent = NULL;
-
-        printf ("glfs_h_mkdir tests: PASSED\n");
-
-        /* Mknod tests */
-        printf ("glfs_h_mknod tests: In Progress\n");
-        ret = glfs_unlink (fs, full_newnod_name);
-        if (ret && errno != ENOENT) {
-                fprintf (stderr, "glfs_unlink: Failed for %s: %s\n",
-                         full_newnod_name, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
-
-        parent = glfs_h_lookupat (fs, NULL, full_parent_name, &sb, 0);
-        if (parent == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
-                         full_parent_name, root, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        leaf = glfs_h_mknod (fs, parent, newnod_name, S_IFIFO, 0, &sb);
-        if (leaf == NULL) {
-                fprintf (stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
-                         newnod_name, parent, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                goto out;
-        }
-        peek_stat (&sb);
-
-        /* TODO: create op on a FIFO node hangs, need to check and fix
-        tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
-        if (tmp != NULL || errno != EINVAL) {
-                fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno = %s\n",
-                        tmp, strerror (errno));
-                printf ("glfs_h_creat/mknod tests: FAILED\n");
-                if (tmp != NULL) {
-                        glfs_h_close(tmp); tmp = NULL;
-                }
-        } */
-
-        glfs_h_close (leaf); leaf = NULL;
-
-        leaf = glfs_h_mknod (fs, parent, newnod_name, 0644, 0, &sb);
-        if (leaf != NULL || errno != EEXIST) {
-                fprintf (stderr, "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n",
-                         leaf, strerror (errno));
-                printf ("glfs_h_mknod tests: FAILED\n");
-                if (leaf != NULL) {
-                        glfs_h_close (leaf); leaf = NULL;
-                }
-        }
-
-        glfs_h_close (parent); parent = NULL;
-
-        printf ("glfs_h_mknod tests: PASSED\n");
-
-        /* unlink tests */
-        test_h_unlink ();
-
-        /* TODO: opendir tests */
-
-        /* getattr tests */
-        test_h_getsetattrs ();
-
-        /* TODO: setattr tests */
-
-        /* truncate tests */
-        test_h_truncate();
-
-        /* link tests */
-        test_h_links ();
-
-        /* rename tests */
-        test_h_rename ();
-
-        /* performance tests */
-        test_h_performance ();
-
-        /* END: New APIs test area */
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    struct stat sb = {
+        0,
+    };
+    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL, *tmp = NULL;
+    char readbuf[32], writebuf[32];
+    unsigned char leaf_handle[GFAPI_HANDLE_LENGTH];
+
+    char *full_leaf_name = "/testdir/testfile.txt", *leaf_name = "testfile.txt",
+         *relative_leaf_name = "testdir/testfile.txt";
+    char *leaf_name1 = "testfile1.txt";
+    char *full_newparent_name = "/testdir/dir1", *newparent_name = "dir1";
+    char *full_newnod_name = "/testdir/nod1", *newnod_name = "nod1";
+
+    /* Initialize test area */
+    ret = glfs_mkdir(fs, full_parent_name, 0644);
+    if (ret != 0 && errno != EEXIST) {
+        fprintf(stderr, "%s: (%p) %s\n", full_parent_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    } else if (ret != 0) {
+        printf("Found test directory %s to be existing\n", full_parent_name);
+        printf("Cleanup test directory and restart tests\n");
+        goto out;
+    }
+
+    fd = glfs_creat(fs, full_leaf_name, O_CREAT, 0644);
+    if (fd == NULL) {
+        fprintf(stderr, "%s: (%p) %s\n", full_leaf_name, fd, strerror(errno));
+        printf("Test initialization failed on volume %s\n", argv[1]);
+        goto out;
+    }
+    glfs_close(fd);
+
+    printf("Initialized the test area, within volume %s\n", argv[1]);
+
+    /* Handle based APIs test area */
+
+    /* glfs_lookupat test */
+    printf("glfs_h_lookupat tests: In Progress\n");
+    /* start at root of the volume */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a parent within root */
+    parent = glfs_h_lookupat(fs, root, parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* lookup a leaf/child within the parent */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check absolute paths */
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
+                NULL, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_lookupat(fs, NULL, full_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_leaf_name, parent, strerror(errno));
+        printf("glfs_h_lookupat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    /* check multiple component paths */
+    leaf = glfs_h_lookupat(fs, root, relative_leaf_name, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                relative_leaf_name, parent, strerror(errno));
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* reset */
+    glfs_h_close(root);
+    root = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    /* check symlinks in path */
+
+    /* TODO: -ve test cases */
+    /* parent invalid
+     * path invalid
+     * path does not exist after some components
+     * no parent, but relative path
+     * parent and full path? -ve?
+     */
+
+    printf("glfs_h_lookupat tests: PASSED\n");
+
+    /* glfs_openat test */
+    printf("glfs_h_open tests: In Progress\n");
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 0, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", readbuf, writebuf);
+        glfs_close(fd);
+        printf("glfs_h_open tests: FAILED\n");
+        goto out;
+    }
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_close(fd);
+
+    printf("glfs_h_open tests: PASSED\n");
+
+    /* Create tests */
+    printf("glfs_h_creat tests: In Progress\n");
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_creat: existing file, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    tmp = glfs_h_creat(fs, root, parent_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
+        fprintf(stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_creat tests: FAILED\n");
+        if (tmp != NULL) {
+            glfs_h_close(tmp);
+            tmp = NULL;
+        }
+    }
+
+    /* TODO: Other combinations and -ve cases as applicable */
+    printf("glfs_h_creat tests: PASSED\n");
+
+    /* extract handle and create from handle test */
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: In "
+        "Progress\n");
+    /* TODO: Change the lookup to create below for a GIFD recovery failure,
+     * that needs to be fixed */
+    leaf = glfs_h_lookupat(fs, parent, leaf_name1, &sb, 0);
+    if (leaf == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                leaf_name1, parent, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    ret = glfs_h_extract_handle(leaf, leaf_handle, GFAPI_HANDLE_LENGTH);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_extract_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_handle(leaf_handle);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_create_from_handle(fs, leaf_handle, GFAPI_HANDLE_LENGTH, &sb);
+    if (leaf == NULL) {
+        fprintf(
+            stderr,
+            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+            leaf_name1, leaf_handle, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    fd = glfs_h_open(fs, leaf, O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
+                full_leaf_name, strerror(errno));
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        goto out;
+    }
+
+    /* test read/write based on fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+    ret = glfs_write(fd, writebuf, 32, 0);
+
+    glfs_lseek(fd, 0, SEEK_SET);
+
+    ret = glfs_read(fd, readbuf, 32, 0);
+    if (memcmp(readbuf, writebuf, 32)) {
+        printf("Failed to read what I wrote: %s %s\n", writebuf, writebuf);
+        printf("glfs_h_create_from_handle tests: FAILED\n");
+        glfs_close(fd);
+        goto out;
+    }
+
+    glfs_close(fd);
+    glfs_h_close(leaf);
+    leaf = NULL;
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf(
+        "glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
+
+    /* Mkdir tests */
+    printf("glfs_h_mkdir tests: In Progress\n");
+
+    ret = glfs_rmdir(fs, full_newparent_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_rmdir: Failed for %s: %s\n", full_newparent_name,
+                strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0644, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newparent_name, parent, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0644, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
+                leaf, strerror(errno));
+        printf("glfs_h_mkdir tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mkdir tests: PASSED\n");
+
+    /* Mknod tests */
+    printf("glfs_h_mknod tests: In Progress\n");
+    ret = glfs_unlink(fs, full_newnod_name);
+    if (ret && errno != ENOENT) {
+        fprintf(stderr, "glfs_unlink: Failed for %s: %s\n", full_newnod_name,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+
+    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
+    if (parent == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
+                full_parent_name, root, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, S_IFIFO, 0, &sb);
+    if (leaf == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
+                newnod_name, parent, strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        goto out;
+    }
+    peek_stat(&sb);
+
+    /* TODO: create op on a FIFO node hangs, need to check and fix
+    tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
+    if (tmp != NULL || errno != EINVAL) {
+            fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno =
+    %s\n", tmp, strerror (errno)); printf ("glfs_h_creat/mknod tests:
+    FAILED\n"); if (tmp != NULL) { glfs_h_close(tmp); tmp = NULL;
+            }
+    } */
+
+    glfs_h_close(leaf);
+    leaf = NULL;
+
+    leaf = glfs_h_mknod(fs, parent, newnod_name, 0644, 0, &sb);
+    if (leaf != NULL || errno != EEXIST) {
+        fprintf(stderr,
+                "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n", leaf,
+                strerror(errno));
+        printf("glfs_h_mknod tests: FAILED\n");
+        if (leaf != NULL) {
+            glfs_h_close(leaf);
+            leaf = NULL;
+        }
+    }
+
+    glfs_h_close(parent);
+    parent = NULL;
+
+    printf("glfs_h_mknod tests: PASSED\n");
+
+    /* unlink tests */
+    test_h_unlink();
+
+    /* TODO: opendir tests */
+
+    /* getattr tests */
+    test_h_getsetattrs();
+
+    /* TODO: setattr tests */
+
+    /* truncate tests */
+    test_h_truncate();
+
+    /* link tests */
+    test_h_links();
+
+    /* rename tests */
+    test_h_rename();
+
+    /* performance tests */
+    test_h_performance();
+
+    /* END: New APIs test area */
 
 out:
-        /* Cleanup glfs handles */
-        if (root)
-                glfs_h_close (root);
-        if (parent)
-                glfs_h_close (parent);
-        if (leaf)
-                glfs_h_close (leaf);
-
-        return ret;
+    /* Cleanup glfs handles */
+    if (root)
+        glfs_h_close(root);
+    if (parent)
+        glfs_h_close(parent);
+    if (leaf)
+        glfs_h_close(leaf);
+
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs2 = NULL;
-        int        ret = 0;
-        glfs_fd_t *fd = NULL;
-        glfs_fd_t *fd2 = NULL;
-        struct stat sb = {0, };
-        char       readbuf[32];
-        char       writebuf[32];
-
-        char      *filename = "/filename2";
-
-        if (argc != 3) {
-                printf ("Expect following args\n\t%s <volname> <hostname>\n", argv[0]);
-                return -1;
-        }
+    glfs_t *fs2 = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    struct stat sb = {
+        0,
+    };
+    char readbuf[32];
+    char writebuf[32];
 
-        fs = glfs_new (argv[1]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    char *filename = "/filename2";
 
-//      ret = glfs_set_volfile (fs, "/tmp/posix.vol");
+    if (argc != 3) {
+        printf("Expect following args\n\t%s <volname> <hostname>\n", argv[0]);
+        return -1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[2], 24007);
+    fs = glfs_new(argv[1]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-//      ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
+    //      ret = glfs_set_volfile (fs, "/tmp/posix.vol");
 
-        ret = glfs_set_logging (fs, "/dev/stderr", 7);
+    ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
 
-        ret = glfs_init (fs);
+    //      ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
 
-        fprintf (stderr, "glfs_init: returned %d\n", ret);
+    ret = glfs_set_logging(fs, "/dev/stderr", 7);
 
-        sleep (2);
+    ret = glfs_init(fs);
 
-        fs2 = glfs_new (argv[1]);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fprintf(stderr, "glfs_init: returned %d\n", ret);
 
+    sleep(2);
 
-//      ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
+    fs2 = glfs_new(argv[1]);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", argv[2], 24007);
+    //      ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
 
-        ret = glfs_set_logging (fs2, "/dev/stderr", 7);
+    ret = glfs_set_volfile_server(fs2, "tcp", argv[2], 24007);
 
-        ret = glfs_init (fs2);
+    ret = glfs_set_logging(fs2, "/dev/stderr", 7);
 
-        fprintf (stderr, "glfs_init: returned %d\n", ret);
+    ret = glfs_init(fs2);
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    fprintf(stderr, "glfs_init: returned %d\n", ret);
 
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        fd2 = glfs_open (fs2, filename, O_RDWR);
-        fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    fprintf(stderr, "%s: (%p) %s\n", filename, fd, strerror(errno));
 
-        sprintf (writebuf, "hi there\n");
-        ret = glfs_write (fd, writebuf, 32, 0);
+    fd2 = glfs_open(fs2, filename, O_RDWR);
+    fprintf(stderr, "%s: (%p) %s\n", filename, fd, strerror(errno));
 
-        glfs_lseek (fd2, 0, SEEK_SET);
+    sprintf(writebuf, "hi there\n");
+    ret = glfs_write(fd, writebuf, 32, 0);
 
-        ret = glfs_read (fd2, readbuf, 32, 0);
+    glfs_lseek(fd2, 0, SEEK_SET);
 
-        printf ("read %d, %s", ret, readbuf);
+    ret = glfs_read(fd2, readbuf, 32, 0);
 
-        glfs_close (fd);
-        glfs_close (fd2);
+    printf("read %d, %s", ret, readbuf);
 
-        filename = "/filename3";
-        ret = glfs_mknod (fs, filename, S_IFIFO, 0);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    glfs_close(fd);
+    glfs_close(fd2);
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    filename = "/filename3";
+    ret = glfs_mknod(fs, filename, S_IFIFO, 0);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        ret = glfs_rename (fs, filename, "/filename4");
-        fprintf (stderr, "rename(%s): (%d) %s\n", filename, ret,
-                 strerror (errno));
+    ret = glfs_rename(fs, filename, "/filename4");
+    fprintf(stderr, "rename(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-        ret = glfs_unlink (fs, "/filename4");
-        fprintf (stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
-                 strerror (errno));
+    ret = glfs_unlink(fs, "/filename4");
+    fprintf(stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
+            strerror(errno));
 
-        filename = "/dirname2";
-        ret = glfs_mkdir (fs, filename, 0);
-        fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
+    filename = "/dirname2";
+    ret = glfs_mkdir(fs, filename, 0);
+    fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
 
-        ret = glfs_lstat (fs, filename, &sb);
-        fprintf (stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror (errno));
+    ret = glfs_lstat(fs, filename, &sb);
+    fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-        ret = glfs_rmdir (fs, filename);
-        fprintf (stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror (errno));
+    ret = glfs_rmdir(fs, filename);
+    fprintf(stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror(errno));
 
-        test_dirops (fs);
+    test_dirops(fs);
 
-        test_xattr (fs);
+    test_xattr(fs);
 
-        test_chdir (fs);
+    test_chdir(fs);
 
-        test_handleops (argc, argv);
-        // done
+    test_handleops(argc, argv);
+    // done
 
-        glfs_fini (fs);
-        glfs_fini (fs2);
+    glfs_fini(fs);
+    glfs_fini(fs2);
 
-        return ret;
+    return ret;
 }
diff --git a/api/src/glfs-fops.c b/api/src/glfs-fops.c
index 611cb14d9eb..f6786845a4f 100644
--- a/api/src/glfs-fops.c
+++ b/api/src/glfs-fops.c
@@ -33,23 +33,23 @@
 
 #define READDIRBUF_SIZE (sizeof(struct dirent) + GF_NAME_MAX + 1)
 
-typedef void (*glfs_io_cbk34) (glfs_fd_t *fd, ssize_t ret, void *data);
+typedef void (*glfs_io_cbk34)(glfs_fd_t *fd, ssize_t ret, void *data);
 
 /*
  * This function will mark glfd for deletion and decrement its refcount.
  */
 int
-glfs_mark_glfd_for_deletion (struct glfs_fd *glfd)
+glfs_mark_glfd_for_deletion(struct glfs_fd *glfd)
 {
-        LOCK (&glfd->lock);
-        {
-                glfd->state = GLFD_CLOSE;
-        }
-        UNLOCK (&glfd->lock);
+    LOCK(&glfd->lock);
+    {
+        glfd->state = GLFD_CLOSE;
+    }
+    UNLOCK(&glfd->lock);
 
-        GF_REF_PUT (glfd);
+    GF_REF_PUT(glfd);
 
-        return 0;
+    return 0;
 }
 
 /* This function is useful for all async fops. There is chance that glfd is
@@ -60,33 +60,33 @@ glfs_mark_glfd_for_deletion (struct glfs_fd *glfd)
  * _gf_false.
  */
 gf_boolean_t
-glfs_is_glfd_still_valid (struct glfs_fd *glfd)
+glfs_is_glfd_still_valid(struct glfs_fd *glfd)
 {
-        gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        LOCK (&glfd->lock);
-        {
-                if (glfd->state != GLFD_CLOSE)
-                        ret = _gf_true;
-        }
-        UNLOCK (&glfd->lock);
+    LOCK(&glfd->lock);
+    {
+        if (glfd->state != GLFD_CLOSE)
+            ret = _gf_true;
+    }
+    UNLOCK(&glfd->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-glfd_set_state_bind (struct glfs_fd *glfd)
+glfd_set_state_bind(struct glfs_fd *glfd)
 {
-        LOCK (&glfd->lock);
-        {
-                glfd->state = GLFD_OPEN;
-        }
-        UNLOCK (&glfd->lock);
+    LOCK(&glfd->lock);
+    {
+        glfd->state = GLFD_OPEN;
+    }
+    UNLOCK(&glfd->lock);
 
-        fd_bind (glfd->fd);
-        glfs_fd_bind (glfd);
+    fd_bind(glfd->fd);
+    glfs_fd_bind(glfd);
 
-        return;
+    return;
 }
 
 /*
@@ -97,4528 +97,4581 @@ glfd_set_state_bind (struct glfs_fd *glfd)
  * maintained by gfapi.
  */
 int
-glfs_get_upcall_cache_invalidation (struct gf_upcall *to_up_data,
-                                    struct gf_upcall *from_up_data)
+glfs_get_upcall_cache_invalidation(struct gf_upcall *to_up_data,
+                                   struct gf_upcall *from_up_data)
 {
+    struct gf_upcall_cache_invalidation *ca_data = NULL;
+    struct gf_upcall_cache_invalidation *f_ca_data = NULL;
+    int ret = -1;
 
-        struct gf_upcall_cache_invalidation *ca_data = NULL;
-        struct gf_upcall_cache_invalidation *f_ca_data = NULL;
-        int                                 ret      = -1;
+    GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, to_up_data, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, from_up_data, out);
+    f_ca_data = from_up_data->data;
+    GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out);
 
-        f_ca_data = from_up_data->data;
-        GF_VALIDATE_OR_GOTO (THIS->name, f_ca_data, out);
+    ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
 
-        ca_data = GF_CALLOC (1, sizeof(*ca_data),
-                            glfs_mt_upcall_entry_t);
+    if (!ca_data) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED,
+               "Upcall entry allocation failed.");
+        goto out;
+    }
 
-        if (!ca_data) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
-
-        to_up_data->data = ca_data;
+    to_up_data->data = ca_data;
 
-        ca_data->flags      = f_ca_data->flags;
-        ca_data->expire_time_attr = f_ca_data->expire_time_attr;
-        ca_data->stat       = f_ca_data->stat;
-        ca_data->p_stat     = f_ca_data->p_stat;
-        ca_data->oldp_stat  = f_ca_data->oldp_stat;
+    ca_data->flags = f_ca_data->flags;
+    ca_data->expire_time_attr = f_ca_data->expire_time_attr;
+    ca_data->stat = f_ca_data->stat;
+    ca_data->p_stat = f_ca_data->p_stat;
+    ca_data->oldp_stat = f_ca_data->oldp_stat;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfs_get_upcall_lease (struct gf_upcall *to_up_data,
-                             struct gf_upcall *from_up_data)
+glfs_get_upcall_lease(struct gf_upcall *to_up_data,
+                      struct gf_upcall *from_up_data)
 {
+    struct gf_upcall_recall_lease *ca_data = NULL;
+    struct gf_upcall_recall_lease *f_ca_data = NULL;
+    int ret = -1;
 
-        struct gf_upcall_recall_lease *ca_data = NULL;
-        struct gf_upcall_recall_lease *f_ca_data = NULL;
-        int                                 ret      = -1;
+    GF_VALIDATE_OR_GOTO(THIS->name, to_up_data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, from_up_data, out);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, to_up_data, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, from_up_data, out);
+    f_ca_data = from_up_data->data;
+    GF_VALIDATE_OR_GOTO(THIS->name, f_ca_data, out);
 
-        f_ca_data = from_up_data->data;
-        GF_VALIDATE_OR_GOTO (THIS->name, f_ca_data, out);
+    ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
 
-        ca_data = GF_CALLOC (1, sizeof(*ca_data),
-                            glfs_mt_upcall_entry_t);
+    if (!ca_data) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED,
+               "Upcall entry allocation failed.");
+        goto out;
+    }
 
-        if (!ca_data) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    to_up_data->data = ca_data;
 
-        to_up_data->data = ca_data;
+    ca_data->lease_type = f_ca_data->lease_type;
+    gf_uuid_copy(ca_data->tid, f_ca_data->tid);
+    ca_data->dict = f_ca_data->dict;
 
-        ca_data->lease_type   = f_ca_data->lease_type;
-        gf_uuid_copy (ca_data->tid, f_ca_data->tid);
-        ca_data->dict       = f_ca_data->dict;
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 int
-glfs_loc_link (loc_t *loc, struct iatt *iatt)
+glfs_loc_link(loc_t *loc, struct iatt *iatt)
 {
-	int ret = -1;
-        inode_t *old_inode = NULL;
-        uint64_t ctx_value = LOOKUP_NOT_NEEDED;
-
-	if (!loc->inode) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = -1;
+    inode_t *old_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
 
-        old_inode = loc->inode;
-
-        /* If the inode already exists in the cache, the inode
-         * returned here points to the existing one. We need
-         * to update loc.inode accordingly.
-         */
-	loc->inode = inode_link (loc->inode, loc->parent, loc->name, iatt);
-	if (loc->inode) {
-                inode_ctx_set (loc->inode, THIS, &ctx_value);
-		inode_lookup (loc->inode);
-                inode_unref (old_inode);
-		ret = 0;
-	} else {
-		ret = -1;
-	}
+    if (!loc->inode) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    old_inode = loc->inode;
+
+    /* If the inode already exists in the cache, the inode
+     * returned here points to the existing one. We need
+     * to update loc.inode accordingly.
+     */
+    loc->inode = inode_link(loc->inode, loc->parent, loc->name, iatt);
+    if (loc->inode) {
+        inode_ctx_set(loc->inode, THIS, &ctx_value);
+        inode_lookup(loc->inode);
+        inode_unref(old_inode);
+        ret = 0;
+    } else {
+        ret = -1;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 void
-glfs_iatt_to_stat (struct glfs *fs, struct iatt *iatt, struct stat *stat)
+glfs_iatt_to_stat(struct glfs *fs, struct iatt *iatt, struct stat *stat)
 {
-	iatt_to_stat (iatt, stat);
-	stat->st_dev = fs->dev_id;
+    iatt_to_stat(iatt, stat);
+    stat->st_dev = fs->dev_id;
 }
 
-
 int
-glfs_loc_unlink (loc_t *loc)
+glfs_loc_unlink(loc_t *loc)
 {
-	inode_unlink (loc->inode, loc->parent, loc->name);
+    inode_unlink(loc->inode, loc->parent, loc->name);
 
-	/* since glfs_h_* objects hold a reference to inode
-	 * it is safe to keep lookup count to '0' */
-	if (!inode_has_dentry (loc->inode))
-		inode_forget (loc->inode, 0);
+    /* since glfs_h_* objects hold a reference to inode
+     * it is safe to keep lookup count to '0' */
+    if (!inode_has_dentry(loc->inode))
+        inode_forget(loc->inode, 0);
 
-	return 0;
+    return 0;
 }
 
-
 struct glfs_fd *
-pub_glfs_open (struct glfs *fs, const char *path, int flags)
-{
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-        dict_t          *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
+pub_glfs_open(struct glfs *fs, const char *path, int flags)
+{
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
 
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret)
-		goto out;
-
-	if (IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
-
-	if (!IA_ISREG (iatt.ia_type)) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-        glfd->fd->flags = flags;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	ret = syncop_open (subvol, &loc, flags, glfd->fd, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (ret)
+        goto out;
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    if (IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    if (!IA_ISREG(iatt.ia_type)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_open(subvol, &loc, flags, glfd->fd, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	if (ret && glfd) {
-                GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd_set_state_bind (glfd);
-	}
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_open, 3.4.0);
 
 int
-pub_glfs_close (struct glfs_fd *glfd)
-{
-	xlator_t  *subvol = NULL;
-	int        ret = -1;
-	fd_t      *fd = NULL;
-	struct glfs *fs = NULL;
-        dict_t    *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-	subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        if (glfd->lk_owner.len != 0) {
-                ret = syncopctx_setfslkowner (&glfd->lk_owner);
-                if (ret)
-                        goto out;
-        }
-        ret = get_fop_attr_thrd_key (&fop_attr);
+pub_glfs_close(struct glfs_fd *glfd)
+{
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    fd_t *fd = NULL;
+    struct glfs *fs = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    if (glfd->lk_owner.len != 0) {
+        ret = syncopctx_setfslkowner(&glfd->lk_owner);
         if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_flush (subvol, fd, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+            goto out;
+    }
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_flush(subvol, fd, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	fs = glfd->fs;
+    fs = glfd->fs;
 
-        if (fd)
-                fd_unref (fd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
+    glfs_mark_glfd_for_deletion(glfd);
+    glfs_subvol_done(fs, subvol);
 
-        glfs_mark_glfd_for_deletion (glfd);
-	glfs_subvol_done (fs, subvol);
-
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_close, 3.4.0);
 
-
 int
-pub_glfs_lstat (struct glfs *fs, const char *path, struct stat *stat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_lstat(struct glfs *fs, const char *path, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (fs, &iatt, stat);
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lstat, 3.4.0);
 
-
 int
-pub_glfs_stat (struct glfs *fs, const char *path, struct stat *stat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_stat(struct glfs *fs, const char *path, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (fs, &iatt, stat);
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_stat, 3.4.0);
 
-
 int
-pub_glfs_fstat (struct glfs_fd *glfd, struct stat *stat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	struct iatt      iatt = {0, };
-	fd_t            *fd = NULL;
+pub_glfs_fstat(struct glfs_fd *glfd, struct stat *stat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fstat(subvol, fd, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0 && stat)
+        glfs_iatt_to_stat(glfd->fs, &iatt, stat);
+out:
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        GF_REF_GET (glfd);
+    __GLFS_EXIT_FS;
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+invalid_fs:
+    return ret;
+}
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0);
 
-	ret = syncop_fstat (subvol, fd, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+struct glfs_fd *
+pub_glfs_creat(struct glfs *fs, const char *path, int flags, mode_t mode)
+{
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    /* This must be glfs_resolve() and NOT glfs_lresolve().
+       That is because open("name", O_CREAT) where "name"
+       is a danging symlink must create the dangling
+       destination.
+    */
+retry:
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	if (ret == 0 && stat)
-		glfs_iatt_to_stat (glfd->fs, &iatt, stat);
-out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-        __GLFS_EXIT_FS;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-invalid_fs:
-	return ret;
-}
+    if (loc.inode) {
+        if (flags & O_EXCL) {
+            ret = -1;
+            errno = EEXIST;
+            goto out;
+        }
 
-GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fstat, 3.4.0);
+        if (IA_ISDIR(iatt.ia_type)) {
+            ret = -1;
+            errno = EISDIR;
+            goto out;
+        }
 
+        if (!IA_ISREG(iatt.ia_type)) {
+            ret = -1;
+            errno = EINVAL;
+            goto out;
+        }
+    }
+
+    if (ret == -1 && errno == ENOENT) {
+        loc.inode = inode_new(loc.parent->table);
+        if (!loc.inode) {
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
+        }
+    }
 
-struct glfs_fd *
-pub_glfs_creat (struct glfs *fs, const char *path, int flags, mode_t mode)
-{
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
-
-	/* This must be glfs_resolve() and NOT glfs_lresolve().
-	   That is because open("name", O_CREAT) where "name"
-	   is a danging symlink must create the dangling
-	   destination.
-	*/
-retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
-
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
-
-	if (loc.inode) {
-		if (flags & O_EXCL) {
-			ret = -1;
-			errno = EEXIST;
-			goto out;
-		}
-
-		if (IA_ISDIR (iatt.ia_type)) {
-			ret = -1;
-			errno = EISDIR;
-			goto out;
-		}
-
-		if (!IA_ISREG (iatt.ia_type)) {
-			ret = -1;
-			errno = EINVAL;
-			goto out;
-		}
-	}
-
-	if (ret == -1 && errno == ENOENT) {
-		loc.inode = inode_new (loc.parent->table);
-		if (!loc.inode) {
-			ret = -1;
-			errno = ENOMEM;
-			goto out;
-		}
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-        glfd->fd->flags = flags;
-
-        if (get_fop_attr_thrd_key (&xattr_req))
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-	if (ret == 0) {
-		ret = syncop_open (subvol, &loc, flags, glfd->fd, xattr_req, NULL);
-                DECODE_SYNCOP_ERR (ret);
-	} else {
-		ret = syncop_create (subvol, &loc, flags, mode, glfd->fd,
-				     &iatt, xattr_req, NULL);
-                DECODE_SYNCOP_ERR (ret);
-	}
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    if (get_fop_attr_thrd_key(&xattr_req))
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+    if (ret == 0) {
+        ret = syncop_open(subvol, &loc, flags, glfd->fd, xattr_req, NULL);
+        DECODE_SYNCOP_ERR(ret);
+    } else {
+        ret = syncop_create(subvol, &loc, flags, mode, glfd->fd, &iatt,
+                            xattr_req, NULL);
+        DECODE_SYNCOP_ERR(ret);
+    }
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
+
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	if (ret && glfd) {
-                GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd_set_state_bind (glfd);
-	}
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_creat, 3.4.0);
 
 #ifdef HAVE_SEEK_HOLE
 static int
-glfs_seek (struct glfs_fd *glfd, off_t offset, int whence)
+glfs_seek(struct glfs_fd *glfd, off_t offset, int whence)
 {
-        int               ret             = -1;
-        xlator_t         *subvol          = NULL;
-        fd_t             *fd              = NULL;
-        gf_seek_what_t    what            = 0;
-        off_t             off             = -1;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    gf_seek_what_t what = 0;
+    off_t off = -1;
 
-        switch (whence) {
+    switch (whence) {
         case SEEK_DATA:
-                what = GF_SEEK_DATA;
-                break;
+            what = GF_SEEK_DATA;
+            break;
         case SEEK_HOLE:
-                what = GF_SEEK_HOLE;
-                break;
+            what = GF_SEEK_HOLE;
+            break;
         default:
-                /* other SEEK_* do not make sense, all operations get an offset
-                 * and the position in the fd is not tracked */
-                errno = EINVAL;
-                goto out;
-        }
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto done;
-        }
-
-        ret = syncop_seek (subvol, fd, offset, what, NULL, &off);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret != -1)
-                glfd->offset = off;
+            /* other SEEK_* do not make sense, all operations get an offset
+             * and the position in the fd is not tracked */
+            errno = EINVAL;
+            goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto done;
+    }
+
+    ret = syncop_seek(subvol, fd, offset, what, NULL, &off);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret != -1)
+        glfd->offset = off;
 
 done:
-        if (fd)
-                fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-        glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
 out:
-        return ret;
+    return ret;
 }
 #endif
 
 off_t
-pub_glfs_lseek (struct glfs_fd *glfd, off_t offset, int whence)
-{
-	struct stat sb  = {0, };
-	int         ret = -1;
-        off_t       off = -1;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	switch (whence) {
-	case SEEK_SET:
-		glfd->offset = offset;
-                ret = 0;
-		break;
-	case SEEK_CUR:
-		glfd->offset += offset;
-                ret = 0;
-		break;
-	case SEEK_END:
-		ret = pub_glfs_fstat (glfd, &sb);
-		if (ret) {
-			/* seek cannot fail :O */
-			break;
-		}
-		glfd->offset = sb.st_size + offset;
-		break;
+pub_glfs_lseek(struct glfs_fd *glfd, off_t offset, int whence)
+{
+    struct stat sb = {
+        0,
+    };
+    int ret = -1;
+    off_t off = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    switch (whence) {
+        case SEEK_SET:
+            glfd->offset = offset;
+            ret = 0;
+            break;
+        case SEEK_CUR:
+            glfd->offset += offset;
+            ret = 0;
+            break;
+        case SEEK_END:
+            ret = pub_glfs_fstat(glfd, &sb);
+            if (ret) {
+                /* seek cannot fail :O */
+                break;
+            }
+            glfd->offset = sb.st_size + offset;
+            break;
 #ifdef HAVE_SEEK_HOLE
         case SEEK_DATA:
         case SEEK_HOLE:
-                ret = glfs_seek (glfd, offset, whence);
-                break;
+            ret = glfs_seek(glfd, offset, whence);
+            break;
 #endif
         default:
-                errno = EINVAL;
-	}
+            errno = EINVAL;
+    }
 
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        if (ret != -1)
-                off = glfd->offset;
+    if (ret != -1)
+        off = glfd->offset;
 
-        return off;
+    return off;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lseek, 3.4.0);
 
-
 static ssize_t
-glfs_preadv_common (struct glfs_fd *glfd, const struct iovec *iovec,
-                    int iovcnt, off_t offset, int flags, struct stat *poststat)
-{
-	xlator_t       *subvol = NULL;
-	ssize_t         ret = -1;
-	ssize_t         size = -1;
-	struct iovec   *iov = NULL;
-	int             cnt = 0;
-	struct iobref  *iobref = NULL;
-	fd_t           *fd = NULL;
-        struct iatt     iatt = {0, };
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	size = iov_length (iovec, iovcnt);
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+glfs_preadv_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                   off_t offset, int flags, struct stat *poststat)
+{
+    xlator_t *subvol = NULL;
+    ssize_t ret = -1;
+    ssize_t size = -1;
+    struct iovec *iov = NULL;
+    int cnt = 0;
+    struct iobref *iobref = NULL;
+    fd_t *fd = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
 
-	ret = syncop_readv (subvol, fd, size, offset, 0, &iov, &cnt, &iobref,
-                            &iatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    size = iov_length(iovec, iovcnt);
 
-        if (ret >= 0 && poststat)
-                glfs_iatt_to_stat (glfd->fs, &iatt, poststat);
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-	if (ret <= 0)
-		goto out;
+    ret = syncop_readv(subvol, fd, size, offset, 0, &iov, &cnt, &iobref, &iatt,
+                       fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	size = iov_copy (iovec, iovcnt, iov, cnt); /* FIXME!!! */
+    if (ret >= 0 && poststat)
+        glfs_iatt_to_stat(glfd->fs, &iatt, poststat);
 
-	glfd->offset = (offset + size);
+    if (ret <= 0)
+        goto out;
 
-	ret = size;
+    size = iov_copy(iovec, iovcnt, iov, cnt); /* FIXME!!! */
+
+    glfd->offset = (offset + size);
+
+    ret = size;
 out:
-        if (iov)
-                GF_FREE (iov);
-        if (iobref)
-                iobref_unref (iobref);
+    if (iov)
+        GF_FREE(iov);
+    if (iobref)
+        iobref_unref(iobref);
 
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 ssize_t
-pub_glfs_preadv (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                 off_t offset, int flags)
+pub_glfs_preadv(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                off_t offset, int flags)
 {
-        return glfs_preadv_common (glfd, iovec, iovcnt, offset, flags, NULL);
+    return glfs_preadv_common(glfd, iovec, iovcnt, offset, flags, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv, 3.4.0);
 
-
 ssize_t
-pub_glfs_read (struct glfs_fd *glfd, void *buf, size_t count, int flags)
+pub_glfs_read(struct glfs_fd *glfd, void *buf, size_t count, int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_preadv (glfd, &iov, 1, glfd->offset, flags);
+    ret = pub_glfs_preadv(glfd, &iov, 1, glfd->offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read, 3.4.0);
 
-
 ssize_t
-pub_glfs_pread34 (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-                  int flags)
+pub_glfs_pread34(struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
+                 int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_preadv (glfd, &iov, 1, offset, flags);
+    ret = pub_glfs_preadv(glfd, &iov, 1, offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_pread34, glfs_pread, 3.4.0);
 
-
 ssize_t
-pub_glfs_pread (struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
-                int flags, struct stat *poststat)
+pub_glfs_pread(struct glfs_fd *glfd, void *buf, size_t count, off_t offset,
+               int flags, struct stat *poststat)
 {
-        struct iovec iov = {0, };
-        ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        iov.iov_base = buf;
-        iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        ret = glfs_preadv_common (glfd, &iov, 1, offset, flags, poststat);
+    ret = glfs_preadv_common(glfd, &iov, 1, offset, flags, poststat);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread, future);
 
-
 ssize_t
-pub_glfs_readv (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                int flags)
+pub_glfs_readv(struct glfs_fd *glfd, const struct iovec *iov, int count,
+               int flags)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = pub_glfs_preadv (glfd, iov, count, glfd->offset, flags);
+    ret = pub_glfs_preadv(glfd, iov, count, glfd->offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv, 3.4.0);
 
-
 struct glfs_io {
-	struct glfs_fd      *glfd;
-	int                  op;
-	off_t                offset;
-	struct iovec        *iov;
-	int                  count;
-	int                  flags;
-	gf_boolean_t         oldcb;
-	union {
-		glfs_io_cbk34      fn34;
-		glfs_io_cbk        fn;
-	};
-	void                *data;
+    struct glfs_fd *glfd;
+    int op;
+    off_t offset;
+    struct iovec *iov;
+    int count;
+    int flags;
+    gf_boolean_t oldcb;
+    union {
+        glfs_io_cbk34 fn34;
+        glfs_io_cbk fn;
+    };
+    void *data;
 };
 
-
 static int
-glfs_io_async_cbk (int op_ret, int op_errno, call_frame_t *frame,
-                   void *cookie, struct iovec *iovec, int count,
-                   struct iatt *prebuf, struct iatt *postbuf)
-{
-        struct glfs_io *gio = NULL;
-        xlator_t       *subvol = NULL;
-        struct glfs    *fs = NULL;
-        struct glfs_fd *glfd = NULL;
-        int             ret  = -1;
-        struct stat     prestat = {}, *prestatp = NULL;
-        struct stat     poststat = {}, *poststatp = NULL;
-
-        GF_VALIDATE_OR_GOTO ("gfapi", frame, inval);
-        GF_VALIDATE_OR_GOTO ("gfapi", cookie, inval);
-
-        gio = frame->local;
-        frame->local = NULL;
-        subvol = cookie;
-        glfd = gio->glfd;
-        fs = glfd->fs;
-
-        if (!glfs_is_glfd_still_valid (glfd))
-                goto err;
-
-        if (op_ret <= 0) {
-                goto out;
-        } else if (gio->op == GF_FOP_READ) {
-                if (!iovec) {
-                        op_ret = -1;
-                        op_errno = EINVAL;
-                        goto out;
-                }
-
-                op_ret = iov_copy (gio->iov, gio->count, iovec, count);
-                glfd->offset = gio->offset + op_ret;
-        } else if (gio->op == GF_FOP_WRITE) {
-                glfd->offset = gio->offset + gio->iov->iov_len;
+glfs_io_async_cbk(int op_ret, int op_errno, call_frame_t *frame, void *cookie,
+                  struct iovec *iovec, int count, struct iatt *prebuf,
+                  struct iatt *postbuf)
+{
+    struct glfs_io *gio = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs *fs = NULL;
+    struct glfs_fd *glfd = NULL;
+    int ret = -1;
+    struct stat prestat = {}, *prestatp = NULL;
+    struct stat poststat = {}, *poststatp = NULL;
+
+    GF_VALIDATE_OR_GOTO("gfapi", frame, inval);
+    GF_VALIDATE_OR_GOTO("gfapi", cookie, inval);
+
+    gio = frame->local;
+    frame->local = NULL;
+    subvol = cookie;
+    glfd = gio->glfd;
+    fs = glfd->fs;
+
+    if (!glfs_is_glfd_still_valid(glfd))
+        goto err;
+
+    if (op_ret <= 0) {
+        goto out;
+    } else if (gio->op == GF_FOP_READ) {
+        if (!iovec) {
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto out;
         }
 
-out:
-        errno = op_errno;
-        if (gio->oldcb) {
-                gio->fn34 (gio->glfd, op_ret, gio->data);
-        } else {
-                if (prebuf) {
-                       prestatp = &prestat;
-                       glfs_iatt_to_stat (fs, prebuf, prestatp);
-                }
-
-                if (postbuf) {
-                       poststatp = &poststat;
-                       glfs_iatt_to_stat (fs, postbuf, poststatp);
-                }
+        op_ret = iov_copy(gio->iov, gio->count, iovec, count);
+        glfd->offset = gio->offset + op_ret;
+    } else if (gio->op == GF_FOP_WRITE) {
+        glfd->offset = gio->offset + gio->iov->iov_len;
+    }
 
-                gio->fn (gio->glfd, op_ret, prestatp, poststatp, gio->data);
+out:
+    errno = op_errno;
+    if (gio->oldcb) {
+        gio->fn34(gio->glfd, op_ret, gio->data);
+    } else {
+        if (prebuf) {
+            prestatp = &prestat;
+            glfs_iatt_to_stat(fs, prebuf, prestatp);
         }
-err:
-        fd_unref (glfd->fd);
-        /* Since the async operation is complete
-         * release the ref taken during the start
-         * of async operation
-         */
-        GF_REF_PUT (glfd);
 
-        GF_FREE (gio->iov);
-        GF_FREE (gio);
-        STACK_DESTROY (frame->root);
-        glfs_subvol_done (fs, subvol);
+        if (postbuf) {
+            poststatp = &poststat;
+            glfs_iatt_to_stat(fs, postbuf, poststatp);
+        }
 
-        ret = 0;
+        gio->fn(gio->glfd, op_ret, prestatp, poststatp, gio->data);
+    }
+err:
+    fd_unref(glfd->fd);
+    /* Since the async operation is complete
+     * release the ref taken during the start
+     * of async operation
+     */
+    GF_REF_PUT(glfd);
+
+    GF_FREE(gio->iov);
+    GF_FREE(gio);
+    STACK_DESTROY(frame->root);
+    glfs_subvol_done(fs, subvol);
+
+    ret = 0;
 inval:
-        return ret;
+    return ret;
 }
 
 static int
-glfs_preadv_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, struct iovec *iovec,
-                       int count, struct iatt *stbuf, struct iobref *iobref,
-                       dict_t *xdata)
+glfs_preadv_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, struct iovec *iovec, int count,
+                      struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, iovec, count,
-                           NULL, stbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, iovec, count, NULL,
+                      stbuf);
 
-	return 0;
+    return 0;
 }
 
-
 static int
-glfs_preadv_async_common (struct glfs_fd *glfd, const struct iovec *iovec,
-                          int count, off_t offset, int flags,
-                          gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+glfs_preadv_async_common(struct glfs_fd *glfd, const struct iovec *iovec,
+                         int count, off_t offset, int flags, gf_boolean_t oldcb,
+                         glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = 0;
-	call_frame_t   *frame = NULL;
-	xlator_t       *subvol = NULL;
-	struct glfs    *fs = NULL;
-	fd_t           *fd = NULL;
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	fs = glfd->fs;
-
-	frame = syncop_create_frame (THIS);
-	if (!frame) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->iov = iov_dup (iovec, count);
-	if (!gio->iov) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_READ;
-	gio->glfd   = glfd;
-	gio->count  = count;
-	gio->offset = offset;
-	gio->flags  = flags;
-	gio->oldcb  = oldcb;
-	gio->fn     = fn;
-	gio->data   = data;
-
-	frame->local = gio;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	STACK_WIND_COOKIE (frame, glfs_preadv_async_cbk, subvol, subvol,
-			   subvol->fops->readv, fd, iov_length (iovec, count),
-			   offset, flags, fop_attr);
+    struct glfs_io *gio = NULL;
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs *fs = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    fs = glfd->fs;
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->iov = iov_dup(iovec, count);
+    if (!gio->iov) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_READ;
+    gio->glfd = glfd;
+    gio->count = count;
+    gio->offset = offset;
+    gio->flags = flags;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_preadv_async_cbk, subvol, subvol,
+                      subvol->fops->readv, fd, iov_length(iovec, count), offset,
+                      flags, fop_attr);
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                if (gio) {
-                        GF_FREE (gio->iov);
-                        GF_FREE (gio);
-                }
-                if (frame) {
-                        STACK_DESTROY (frame->root);
-                }
-		glfs_subvol_done (fs, subvol);
-	}
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        if (gio) {
+            GF_FREE(gio->iov);
+            GF_FREE(gio);
+        }
+        if (frame) {
+            STACK_DESTROY(frame->root);
+        }
+        glfs_subvol_done(fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
 int
-pub_glfs_preadv_async34 (struct glfs_fd *glfd, const struct iovec *iovec,
-                         int count, off_t offset, int flags, glfs_io_cbk34 fn,
-                         void *data)
+pub_glfs_preadv_async34(struct glfs_fd *glfd, const struct iovec *iovec,
+                        int count, off_t offset, int flags, glfs_io_cbk34 fn,
+                        void *data)
 {
-       return glfs_preadv_async_common (glfd, iovec, count, offset, flags,
-                                        _gf_true, (void *)fn, data);
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags, _gf_true,
+                                    (void *)fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_preadv_async34, glfs_preadv_async, 3.4.0);
 
-
 int
-pub_glfs_preadv_async (struct glfs_fd *glfd, const struct iovec *iovec,
-                       int count, off_t offset, int flags, glfs_io_cbk fn,
-                       void *data)
+pub_glfs_preadv_async(struct glfs_fd *glfd, const struct iovec *iovec,
+                      int count, off_t offset, int flags, glfs_io_cbk fn,
+                      void *data)
 {
-       return glfs_preadv_async_common (glfd, iovec, count, offset, flags,
-                                        _gf_false, fn, data);
+    return glfs_preadv_async_common(glfd, iovec, count, offset, flags,
+                                    _gf_false, fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_preadv_async, future);
 
-
 int
-pub_glfs_read_async34 (struct glfs_fd *glfd, void *buf, size_t count, int flags,
-                       glfs_io_cbk34 fn, void *data)
+pub_glfs_read_async34(struct glfs_fd *glfd, void *buf, size_t count, int flags,
+                      glfs_io_cbk34 fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                        _gf_true, (void *)fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags, _gf_true,
+                                   (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_read_async34, glfs_read_async, 3.4.0);
 
-
 int
-pub_glfs_read_async (struct glfs_fd *glfd, void *buf, size_t count, int flags,
-                     glfs_io_cbk fn, void *data)
+pub_glfs_read_async(struct glfs_fd *glfd, void *buf, size_t count, int flags,
+                    glfs_io_cbk fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = glfs_preadv_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                        _gf_false, fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                   _gf_false, fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_read_async, future);
 
-
 int
-pub_glfs_pread_async34 (struct glfs_fd *glfd, void *buf, size_t count,
-                        off_t offset, int flags, glfs_io_cbk34 fn, void *data)
+pub_glfs_pread_async34(struct glfs_fd *glfd, void *buf, size_t count,
+                       off_t offset, int flags, glfs_io_cbk34 fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = buf;
-	iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-	ret = glfs_preadv_async_common (glfd, &iov, 1, offset, flags,
-                                        _gf_true, (void *)fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                   (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_pread_async34, glfs_pread_async, 3.4.0);
 
-
 int
-pub_glfs_pread_async (struct glfs_fd *glfd, void *buf, size_t count,
-                      off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pread_async(struct glfs_fd *glfd, void *buf, size_t count,
+                     off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
-        struct iovec iov = {0, };
-        ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        iov.iov_base = buf;
-        iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        ret = glfs_preadv_async_common (glfd, &iov, 1, offset, flags,
-                                        _gf_false, fn, data);
+    ret = glfs_preadv_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                   data);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pread_async, future);
 
-
 int
-pub_glfs_readv_async34 (struct glfs_fd *glfd, const struct iovec *iov,
-                        int count, int flags, glfs_io_cbk34 fn, void *data)
+pub_glfs_readv_async34(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                       int flags, glfs_io_cbk34 fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags,
-                                        _gf_true, (void *)fn, data);
-	return ret;
+    ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags,
+                                   _gf_true, (void *)fn, data);
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_readv_async34, glfs_readv_async, 3.4.0);
 
-
 int
-pub_glfs_readv_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                      int flags, glfs_io_cbk fn, void *data)
+pub_glfs_readv_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                     int flags, glfs_io_cbk fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_preadv_async_common (glfd, iov, count, glfd->offset, flags,
-                                        _gf_false, fn, data);
-	return ret;
+    ret = glfs_preadv_async_common(glfd, iov, count, glfd->offset, flags,
+                                   _gf_false, fn, data);
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readv_async, future);
 
 static ssize_t
-glfs_pwritev_common (struct glfs_fd *glfd, const struct iovec *iovec,
-                     int iovcnt, off_t offset, int flags,
-                     struct stat *prestat, struct stat *poststat)
-{
-	xlator_t       *subvol = NULL;
-	int             ret = -1;
-	struct iobref  *iobref = NULL;
-	struct iobuf   *iobuf = NULL;
-	struct iovec    iov = {0, };
-	fd_t           *fd = NULL;
-        struct iatt     preiatt = {0, }, postiatt = {0, };
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = iobuf_copy (subvol->ctx->iobuf_pool, iovec, iovcnt, &iobref,
-                          &iobuf, &iov);
-        if (ret)
-                goto out;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags,
-                             &preiatt, &postiatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
-
-	if (ret <= 0)
-		goto out;
-
-	glfd->offset = (offset + iov.iov_len);
+glfs_pwritev_common(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                    off_t offset, int flags, struct stat *prestat,
+                    struct stat *poststat)
+{
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iovec iov = {
+        0,
+    };
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, iovcnt, &iobref, &iobuf,
+                     &iov);
+    if (ret)
+        goto out;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, &preiatt,
+                        &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_stat(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_stat(glfd->fs, &postiatt, poststat);
+    }
+
+    if (ret <= 0)
+        goto out;
+
+    glfd->offset = (offset + iov.iov_len);
 out:
-        if (iobuf)
-                iobuf_unref (iobuf);
-        if (iobref)
-                iobref_unref (iobref);
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    if (iobref)
+        iobref_unref(iobref);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 ssize_t
-pub_glfs_pwritev (struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
-                  off_t offset, int flags)
+pub_glfs_pwritev(struct glfs_fd *glfd, const struct iovec *iovec, int iovcnt,
+                 off_t offset, int flags)
 {
-        return glfs_pwritev_common (glfd, iovec, iovcnt, offset, flags,
-                                    NULL, NULL);
+    return glfs_pwritev_common(glfd, iovec, iovcnt, offset, flags, NULL, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev, 3.4.0);
 
-
 ssize_t
-pub_glfs_write (struct glfs_fd *glfd, const void *buf, size_t count, int flags)
+pub_glfs_write(struct glfs_fd *glfd, const void *buf, size_t count, int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_pwritev (glfd, &iov, 1, glfd->offset, flags);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, glfd->offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write, 3.4.0);
 
-
 ssize_t
-pub_glfs_writev (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                 int flags)
+pub_glfs_writev(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                int flags)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = pub_glfs_pwritev (glfd, iov, count, glfd->offset, flags);
+    ret = pub_glfs_pwritev(glfd, iov, count, glfd->offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev, 3.4.0);
 
-
 ssize_t
-pub_glfs_pwrite34 (struct glfs_fd *glfd, const void *buf, size_t count,
-                   off_t offset, int flags)
+pub_glfs_pwrite34(struct glfs_fd *glfd, const void *buf, size_t count,
+                  off_t offset, int flags)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = pub_glfs_pwritev (glfd, &iov, 1, offset, flags);
+    ret = pub_glfs_pwritev(glfd, &iov, 1, offset, flags);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_pwrite34, glfs_pwrite, 3.4.0);
 
 ssize_t
-pub_glfs_pwrite (struct glfs_fd *glfd, const void *buf, size_t count,
-                 off_t offset, int flags, struct stat *prestat,
-                 struct stat *poststat)
+pub_glfs_pwrite(struct glfs_fd *glfd, const void *buf, size_t count,
+                off_t offset, int flags, struct stat *prestat,
+                struct stat *poststat)
 {
-        struct iovec iov = {0, };
-        ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_pwritev_common (glfd, &iov, 1, offset, flags,
-                                   prestat, poststat);
+    ret = glfs_pwritev_common(glfd, &iov, 1, offset, flags, prestat, poststat);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite, future);
 
-extern glfs_t *pub_glfs_from_glfd (glfs_fd_t *);
-
+extern glfs_t *
+pub_glfs_from_glfd(glfs_fd_t *);
 
 static int
-glfs_pwritev_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+glfs_pwritev_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0,
-                           prebuf, postbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
 static int
-glfs_pwritev_async_common (struct glfs_fd *glfd, const struct iovec *iovec,
-                           int count, off_t offset, int flags,
-                           gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+glfs_pwritev_async_common(struct glfs_fd *glfd, const struct iovec *iovec,
+                          int count, off_t offset, int flags,
+                          gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-        struct iobref  *iobref = NULL;
-        struct iobuf   *iobuf = NULL;
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gio->op     = GF_FOP_WRITE;
-        gio->glfd   = glfd;
-        gio->offset = offset;
-        gio->flags  = flags;
-        gio->oldcb  = oldcb;
-        gio->fn     = fn;
-        gio->data   = data;
-        gio->count  = 1;
-        gio->iov = GF_CALLOC (gio->count, sizeof (*(gio->iov)),
-                              gf_common_mt_iovec);
-        if (!gio->iov) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        ret = iobuf_copy (subvol->ctx->iobuf_pool, iovec, count, &iobref,
-                          &iobuf, gio->iov);
-        if (ret)
-                goto out;
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        frame->local = gio;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        STACK_WIND_COOKIE (frame, glfs_pwritev_async_cbk, subvol, subvol,
-                           subvol->fops->writev, fd, gio->iov,
-                           gio->count, offset, flags, iobref, fop_attr);
-
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_WRITE;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->flags = flags;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+    gio->count = 1;
+    gio->iov = GF_CALLOC(gio->count, sizeof(*(gio->iov)), gf_common_mt_iovec);
+    if (!gio->iov) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = iobuf_copy(subvol->ctx->iobuf_pool, iovec, count, &iobref, &iobuf,
+                     gio->iov);
+    if (ret)
+        goto out;
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_pwritev_async_cbk, subvol, subvol,
+                      subvol->fops->writev, fd, gio->iov, gio->count, offset,
+                      flags, iobref, fop_attr);
+
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                /*
-                 * If there is any error condition check after the frame
-                 * creation, we have to destroy the frame root.
-                 */
-                glfs_subvol_done (glfd->fs, subvol);
-        }
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        /*
+         * If there is any error condition check after the frame
+         * creation, we have to destroy the frame root.
+         */
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    if (iobref)
+        iobref_unref(iobref);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_pwritev_async34 (struct glfs_fd *glfd, const struct iovec *iovec,
-                          int count, off_t offset, int flags, glfs_io_cbk34 fn,
-                          void *data)
+pub_glfs_pwritev_async34(struct glfs_fd *glfd, const struct iovec *iovec,
+                         int count, off_t offset, int flags, glfs_io_cbk34 fn,
+                         void *data)
 {
-        return glfs_pwritev_async_common (glfd, iovec, count, offset, flags,
-                                          _gf_true, (void *)fn, data);
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_true, (void *)fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_pwritev_async34, glfs_pwritev_async, 3.4.0);
 
-
 int
-pub_glfs_pwritev_async (struct glfs_fd *glfd, const struct iovec *iovec,
-                        int count, off_t offset, int flags, glfs_io_cbk fn,
-                        void *data)
+pub_glfs_pwritev_async(struct glfs_fd *glfd, const struct iovec *iovec,
+                       int count, off_t offset, int flags, glfs_io_cbk fn,
+                       void *data)
 {
-        return glfs_pwritev_async_common (glfd, iovec, count, offset, flags,
-                                          _gf_false, fn, data);
+    return glfs_pwritev_async_common(glfd, iovec, count, offset, flags,
+                                     _gf_false, fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwritev_async, future);
 
-
 int
-pub_glfs_write_async34 (struct glfs_fd *glfd, const void *buf, size_t count,
-                        int flags, glfs_io_cbk34 fn, void *data)
+pub_glfs_write_async34(struct glfs_fd *glfd, const void *buf, size_t count,
+                       int flags, glfs_io_cbk34 fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                         _gf_true, (void *)fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                    _gf_true, (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_write_async34, glfs_write_async, 3.4.0);
 
-
 int
-pub_glfs_write_async (struct glfs_fd *glfd, const void *buf, size_t count,
-                      int flags, glfs_io_cbk fn, void *data)
+pub_glfs_write_async(struct glfs_fd *glfd, const void *buf, size_t count,
+                     int flags, glfs_io_cbk fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, glfd->offset, flags,
-                                         _gf_false, fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, glfd->offset, flags,
+                                    _gf_false, fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_write_async, future);
 
-
 int
-pub_glfs_pwrite_async34 (struct glfs_fd *glfd, const void *buf, int count,
-                         off_t offset, int flags, glfs_io_cbk34 fn, void *data)
+pub_glfs_pwrite_async34(struct glfs_fd *glfd, const void *buf, int count,
+                        off_t offset, int flags, glfs_io_cbk34 fn, void *data)
 {
-	struct iovec iov = {0, };
-	ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-	iov.iov_base = (void *) buf;
-	iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-	ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags,
-                                         _gf_true, (void *)fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_true,
+                                    (void *)fn, data);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_pwrite_async34, glfs_pwrite_async, 3.4.0);
 
-
 int
-pub_glfs_pwrite_async (struct glfs_fd *glfd, const void *buf, int count,
-                       off_t offset, int flags, glfs_io_cbk fn, void *data)
+pub_glfs_pwrite_async(struct glfs_fd *glfd, const void *buf, int count,
+                      off_t offset, int flags, glfs_io_cbk fn, void *data)
 {
-        struct iovec iov = {0, };
-        ssize_t      ret = 0;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_pwritev_async_common (glfd, &iov, 1, offset, flags,
-                                         _gf_false, fn, data);
+    ret = glfs_pwritev_async_common(glfd, &iov, 1, offset, flags, _gf_false, fn,
+                                    data);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_pwrite_async, future);
 
-
 int
-pub_glfs_writev_async34 (struct glfs_fd *glfd, const struct iovec *iov,
-                         int count, int flags, glfs_io_cbk34 fn, void *data)
+pub_glfs_writev_async34(struct glfs_fd *glfd, const struct iovec *iov,
+                        int count, int flags, glfs_io_cbk34 fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags,
-                                         _gf_true, (void *)fn, data);
-	return ret;
+    ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags,
+                                    _gf_true, (void *)fn, data);
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_writev_async34, glfs_writev_async, 3.4.0);
 
-
 int
-pub_glfs_writev_async (struct glfs_fd *glfd, const struct iovec *iov, int count,
-                       int flags, glfs_io_cbk fn, void *data)
+pub_glfs_writev_async(struct glfs_fd *glfd, const struct iovec *iov, int count,
+                      int flags, glfs_io_cbk fn, void *data)
 {
-	ssize_t      ret = 0;
+    ssize_t ret = 0;
 
-	ret = glfs_pwritev_async_common (glfd, iov, count, glfd->offset, flags,
-                                         _gf_false, fn, data);
-	return ret;
+    ret = glfs_pwritev_async_common(glfd, iov, count, glfd->offset, flags,
+                                    _gf_false, fn, data);
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_writev_async, future);
 
-
 static int
-glfs_fsync_common (struct glfs_fd *glfd, struct stat *prestat,
-                   struct stat *poststat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-        struct iatt      preiatt = {0, }, postiatt = {0, };
-        dict_t          *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_fsync (subvol, fd, 0, &preiatt, &postiatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+glfs_fsync_common(struct glfs_fd *glfd, struct stat *prestat,
+                  struct stat *poststat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fsync(subvol, fd, 0, &preiatt, &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_stat(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_stat(glfd->fs, &postiatt, poststat);
+    }
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_fsync34 (struct glfs_fd *glfd)
+pub_glfs_fsync34(struct glfs_fd *glfd)
 {
-	return glfs_fsync_common (glfd, NULL, NULL);
+    return glfs_fsync_common(glfd, NULL, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_fsync34, glfs_fsync, 3.4.0);
 
-
 int
-pub_glfs_fsync (struct glfs_fd *glfd, struct stat *prestat,
-                struct stat *poststat)
+pub_glfs_fsync(struct glfs_fd *glfd, struct stat *prestat,
+               struct stat *poststat)
 {
-	return glfs_fsync_common (glfd, prestat, poststat);
+    return glfs_fsync_common(glfd, prestat, poststat);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync, future);
 
-
 static int
-glfs_fsync_async_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret,
-                      int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+glfs_fsync_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0,
-                           prebuf, postbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
 static int
-glfs_fsync_async_common (struct glfs_fd *glfd, gf_boolean_t oldcb,
-                         glfs_io_cbk fn, void *data, int dataonly)
-{
-	struct glfs_io *gio = NULL;
-	int             ret = 0;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                ret = -1;
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-	gio->op     = GF_FOP_FSYNC;
-	gio->glfd   = glfd;
-	gio->flags  = dataonly;
-	gio->oldcb  = oldcb;
-	gio->fn     = fn;
-	gio->data   = data;
-
-        frame->local = gio;
-
-        STACK_WIND_COOKIE (frame, glfs_fsync_async_cbk, subvol, subvol,
-                           subvol->fops->fsync, fd, dataonly, NULL);
+glfs_fsync_async_common(struct glfs_fd *glfd, gf_boolean_t oldcb,
+                        glfs_io_cbk fn, void *data, int dataonly)
+{
+    struct glfs_io *gio = NULL;
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    gio->op = GF_FOP_FSYNC;
+    gio->glfd = glfd;
+    gio->flags = dataonly;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    STACK_WIND_COOKIE(frame, glfs_fsync_async_cbk, subvol, subvol,
+                      subvol->fops->fsync, fd, dataonly, NULL);
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_fsync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
+pub_glfs_fsync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        ret = glfs_fsync_async_common (glfd, _gf_true, (void *)fn, data, 0);
+    ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 0);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_fsync_async34, glfs_fsync_async, 3.4.0);
 
-
 int
-pub_glfs_fsync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fsync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        ret = glfs_fsync_async_common (glfd, _gf_false, fn, data, 0);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 0);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsync_async, future);
 
-
 static int
-glfs_fdatasync_common (struct glfs_fd *glfd, struct stat *prestat,
-                       struct stat *poststat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-        struct iatt      preiatt = {0, }, postiatt = {0, };
-        dict_t          *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_fsync (subvol, fd, 1, &preiatt, &postiatt, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+glfs_fdatasync_common(struct glfs_fd *glfd, struct stat *prestat,
+                      struct stat *poststat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fsync(subvol, fd, 1, &preiatt, &postiatt, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_stat(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_stat(glfd->fs, &postiatt, poststat);
+    }
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_fdatasync34 (struct glfs_fd *glfd)
+pub_glfs_fdatasync34(struct glfs_fd *glfd)
 {
-        return glfs_fdatasync_common (glfd, NULL, NULL);
+    return glfs_fdatasync_common(glfd, NULL, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_fdatasync34, glfs_fdatasync, 3.4.0);
 
-
 int
-pub_glfs_fdatasync (struct glfs_fd *glfd, struct stat *prestat,
-                    struct stat *poststat)
+pub_glfs_fdatasync(struct glfs_fd *glfd, struct stat *prestat,
+                   struct stat *poststat)
 {
-       return glfs_fdatasync_common (glfd, prestat, poststat);
+    return glfs_fdatasync_common(glfd, prestat, poststat);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync, future);
 
-
 int
-pub_glfs_fdatasync_async34 (struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
+pub_glfs_fdatasync_async34(struct glfs_fd *glfd, glfs_io_cbk34 fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-	ret = glfs_fsync_async_common (glfd, _gf_true, (void *)fn, data, 1);
+    ret = glfs_fsync_async_common(glfd, _gf_true, (void *)fn, data, 1);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_fdatasync_async34, glfs_fdatasync_async, 3.4.0);
 
-
 int
-pub_glfs_fdatasync_async (struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
+pub_glfs_fdatasync_async(struct glfs_fd *glfd, glfs_io_cbk fn, void *data)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-	ret = glfs_fsync_async_common (glfd, _gf_false, fn, data, 1);
+    ret = glfs_fsync_async_common(glfd, _gf_false, fn, data, 1);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fdatasync_async, future);
 
-
 static int
-glfs_ftruncate_common (struct glfs_fd *glfd, off_t offset,
-                       struct stat *prestat, struct stat *poststat)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-        struct iatt      preiatt = {0, }, postiatt = {0, };
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_ftruncate (subvol, fd, offset, &preiatt, &postiatt,
-                                fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret >= 0) {
-                if (prestat)
-                        glfs_iatt_to_stat (glfd->fs, &preiatt, prestat);
-                if (poststat)
-                        glfs_iatt_to_stat (glfd->fs, &postiatt, poststat);
-        }
+glfs_ftruncate_common(struct glfs_fd *glfd, off_t offset, struct stat *prestat,
+                      struct stat *poststat)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct iatt preiatt =
+                    {
+                        0,
+                    },
+                postiatt = {
+                    0,
+                };
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_ftruncate(subvol, fd, offset, &preiatt, &postiatt, fop_attr,
+                           NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret >= 0) {
+        if (prestat)
+            glfs_iatt_to_stat(glfd->fs, &preiatt, prestat);
+        if (poststat)
+            glfs_iatt_to_stat(glfd->fs, &postiatt, poststat);
+    }
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_ftruncate34 (struct glfs_fd *glfd, off_t offset)
+pub_glfs_ftruncate34(struct glfs_fd *glfd, off_t offset)
 {
-        return glfs_ftruncate_common (glfd, offset, NULL, NULL);
+    return glfs_ftruncate_common(glfd, offset, NULL, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_ftruncate34, glfs_ftruncate, 3.4.0);
 
-
 int
-pub_glfs_ftruncate (struct glfs_fd *glfd, off_t offset, struct stat *prestat,
-                    struct stat *poststat)
+pub_glfs_ftruncate(struct glfs_fd *glfd, off_t offset, struct stat *prestat,
+                   struct stat *poststat)
 {
-        return glfs_ftruncate_common (glfd, offset, prestat, poststat);
+    return glfs_ftruncate_common(glfd, offset, prestat, poststat);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate, future);
 
-
 int
-pub_glfs_truncate (struct glfs *fs, const char *path, off_t length)
-{
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-        int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+pub_glfs_truncate(struct glfs *fs, const char *path, off_t length)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-        ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-        ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = syncop_truncate (subvol, &loc, length, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_truncate(subvol, &loc, length, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_truncate, 3.7.15);
 
-
 static int
-glfs_ftruncate_async_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iatt *prebuf, struct iatt *postbuf,
-                          dict_t *xdata)
+glfs_ftruncate_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0,
-                           prebuf, postbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, prebuf,
+                      postbuf);
 
-        return 0;
+    return 0;
 }
 
 static int
-glfs_ftruncate_async_common (struct glfs_fd *glfd, off_t offset,
-                             gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+glfs_ftruncate_async_common(struct glfs_fd *glfd, off_t offset,
+                            gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_FTRUNCATE;
-	gio->glfd   = glfd;
-	gio->offset = offset;
-	gio->oldcb  = oldcb;
-	gio->fn     = fn;
-	gio->data   = data;
-
-        frame->local = gio;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        STACK_WIND_COOKIE (frame, glfs_ftruncate_async_cbk, subvol, subvol,
-                           subvol->fops->ftruncate, fd, offset, fop_attr);
-
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_FTRUNCATE;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_ftruncate_async_cbk, subvol, subvol,
+                      subvol->fops->ftruncate, fd, offset, fop_attr);
+
+    ret = 0;
 
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_ftruncate_async34 (struct glfs_fd *glfd, off_t offset,
-                            glfs_io_cbk34 fn, void *data)
+pub_glfs_ftruncate_async34(struct glfs_fd *glfd, off_t offset, glfs_io_cbk34 fn,
+                           void *data)
 {
-        return glfs_ftruncate_async_common (glfd, offset, _gf_true,
-                                            (void *)fn, data);
+    return glfs_ftruncate_async_common(glfd, offset, _gf_true, (void *)fn,
+                                       data);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_ftruncate_async34, glfs_ftruncate_async, 3.4.0);
 
-
 int
-pub_glfs_ftruncate_async (struct glfs_fd *glfd, off_t offset,
-                          glfs_io_cbk fn, void *data)
+pub_glfs_ftruncate_async(struct glfs_fd *glfd, off_t offset, glfs_io_cbk fn,
+                         void *data)
 {
-        return glfs_ftruncate_async_common (glfd, offset, _gf_false, fn, data);
+    return glfs_ftruncate_async_common(glfd, offset, _gf_false, fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_ftruncate_async, future);
 
-
 int
-pub_glfs_access (struct glfs *fs, const char *path, int mode)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_access(struct glfs *fs, const char *path, int mode)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_access (subvol, &loc, mode, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_access(subvol, &loc, mode, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_access, 3.4.0);
 
-
 int
-pub_glfs_symlink (struct glfs *fs, const char *data, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_symlink(struct glfs *fs, const char *data, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_symlink, 3.4.0);
 
-
 int
-pub_glfs_readlink (struct glfs *fs, const char *path, char *buf, size_t bufsiz)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-	char            *linkval = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_readlink(struct glfs *fs, const char *path, char *buf, size_t bufsiz)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+    char *linkval = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type != IA_IFLNK) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    if (iatt.ia_type != IA_IFLNK) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret > 0) {
-		memcpy (buf, linkval, ret);
-		GF_FREE (linkval);
-	}
+    ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret > 0) {
+        memcpy(buf, linkval, ret);
+        GF_FREE(linkval);
+    }
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readlink, 3.4.0);
 
-
 int
-pub_glfs_mknod (struct glfs *fs, const char *path, mode_t mode, dev_t dev)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_mknod(struct glfs *fs, const char *path, mode_t mode, dev_t dev)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mknod, 3.4.0);
 
-
 int
-pub_glfs_mkdir (struct glfs *fs, const char *path, mode_t mode)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	uuid_t           gfid;
-	dict_t          *xattr_req = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gf_uuid_generate (gfid);
-	ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+pub_glfs_mkdir(struct glfs *fs, const char *path, mode_t mode)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (loc.inode) {
-		errno = EEXIST;
-		ret = -1;
-		goto out;
-	}
+    if (loc.inode) {
+        errno = EEXIST;
+        ret = -1;
+        goto out;
+    }
 
-	if (ret == -1 && errno != ENOENT)
-		/* Any other type of error is fatal */
-		goto out;
+    if (ret == -1 && errno != ENOENT)
+        /* Any other type of error is fatal */
+        goto out;
 
-	if (ret == -1 && errno == ENOENT && !loc.parent)
-		/* The parent directory or an ancestor even
-		   higher does not exist
-		*/
-		goto out;
+    if (ret == -1 && errno == ENOENT && !loc.parent)
+        /* The parent directory or an ancestor even
+           higher does not exist
+        */
+        goto out;
 
-	/* ret == -1 && errno == ENOENT */
-	loc.inode = inode_new (loc.parent->table);
-	if (!loc.inode) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    /* ret == -1 && errno == ENOENT */
+    loc.inode = inode_new(loc.parent->table);
+    if (!loc.inode) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_link (&loc, &iatt);
+    if (ret == 0)
+        ret = glfs_loc_link(&loc, &iatt);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_mkdir, 3.4.0);
 
-
 int
-pub_glfs_unlink (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_unlink(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type == IA_IFDIR) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
+    if (iatt.ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
 
-        /* TODO: Add leaseid */
-	ret = syncop_unlink (subvol, &loc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* TODO: Add leaseid */
+    ret = syncop_unlink(subvol, &loc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unlink, 3.4.0);
 
-
 int
-pub_glfs_rmdir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_rmdir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (iatt.ia_type != IA_IFDIR) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
+    if (iatt.ia_type != IA_IFDIR) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
 
-	ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rmdir, 3.4.0);
 
-
 int
-pub_glfs_rename (struct glfs *fs, const char *oldpath, const char *newpath)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            oldloc = {0, };
-	loc_t            newloc = {0, };
-	struct iatt      oldiatt = {0, };
-	struct iatt      newiatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_rename(struct glfs *fs, const char *oldpath, const char *newpath)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval);
+    ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &oldloc, retry);
+    ESTALE_RETRY(ret, errno, reval, &oldloc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 retrynew:
-	ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &newloc, retrynew);
-
-	if (ret && errno != ENOENT && newloc.parent)
-		goto out;
-
-	if (newiatt.ia_type != IA_INVAL) {
-                if ((oldiatt.ia_type == IA_IFDIR) !=
-                    (newiatt.ia_type == IA_IFDIR)) {
-                       /* Either both old and new must be dirs,
-                        * or both must be non-dirs. Else, fail.
-                        */
-                       ret = -1;
-                       errno = EISDIR;
-                       goto out;
-                }
+    ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &newloc, retrynew);
+
+    if (ret && errno != ENOENT && newloc.parent)
+        goto out;
+
+    if (newiatt.ia_type != IA_INVAL) {
+        if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) {
+            /* Either both old and new must be dirs,
+             * or both must be non-dirs. Else, fail.
+             */
+            ret = -1;
+            errno = EISDIR;
+            goto out;
+        }
+    }
+
+    /* TODO: - check if new or old is a prefix of the other, and fail EINVAL
+     *       - Add leaseid */
+
+    ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == -1 && errno == ESTALE) {
+        if (reval < DEFAULT_REVAL_COUNT) {
+            reval++;
+            loc_wipe(&oldloc);
+            loc_wipe(&newloc);
+            goto retry;
         }
+    }
 
-	/* TODO: - check if new or old is a prefix of the other, and fail EINVAL
-         *       - Add leaseid */
-
-	ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret == -1 && errno == ESTALE) {
-		if (reval < DEFAULT_REVAL_COUNT) {
-			reval++;
-			loc_wipe (&oldloc);
-			loc_wipe (&newloc);
-			goto retry;
-		}
-	}
-
-	if (ret == 0) {
-		inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
-			      newloc.parent, newloc.name, oldloc.inode,
-			      &oldiatt);
-
-		if (newloc.inode && !inode_has_dentry (newloc.inode))
-			inode_forget (newloc.inode, 0);
-	}
+    if (ret == 0) {
+        inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name,
+                     newloc.parent, newloc.name, oldloc.inode, &oldiatt);
+
+        if (newloc.inode && !inode_has_dentry(newloc.inode))
+            inode_forget(newloc.inode, 0);
+    }
 out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_rename, 3.4.0);
 
-
 int
-pub_glfs_link (struct glfs *fs, const char *oldpath, const char *newpath)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            oldloc = {0, };
-	loc_t            newloc = {0, };
-	struct iatt      oldiatt = {0, };
-	struct iatt      newiatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_link(struct glfs *fs, const char *oldpath, const char *newpath)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_lresolve (fs, subvol, oldpath, &oldloc, &oldiatt, reval);
+    ret = glfs_lresolve(fs, subvol, oldpath, &oldloc, &oldiatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &oldloc, retry);
+    ESTALE_RETRY(ret, errno, reval, &oldloc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 retrynew:
-	ret = glfs_lresolve (fs, subvol, newpath, &newloc, &newiatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &newloc, retrynew);
-
-	if (ret == 0) {
-		ret = -1;
-		errno = EEXIST;
-		goto out;
-	}
-
-	if (oldiatt.ia_type == IA_IFDIR) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
-
-        /* Filling the inode of the hard link to be same as that of the
-           original file
-        */
-	if (newloc.inode) {
-		inode_unref (newloc.inode);
-		newloc.inode = NULL;
-	}
-        newloc.inode = inode_ref (oldloc.inode);
-
-	ret = syncop_link (subvol, &oldloc, &newloc, &newiatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret == -1 && errno == ESTALE) {
-		loc_wipe (&oldloc);
-		loc_wipe (&newloc);
-		if (reval--)
-			goto retry;
-	}
-
-	if (ret == 0)
-		ret = glfs_loc_link (&newloc, &newiatt);
+    ret = glfs_lresolve(fs, subvol, newpath, &newloc, &newiatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &newloc, retrynew);
+
+    if (ret == 0) {
+        ret = -1;
+        errno = EEXIST;
+        goto out;
+    }
+
+    if (oldiatt.ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    /* Filling the inode of the hard link to be same as that of the
+       original file
+    */
+    if (newloc.inode) {
+        inode_unref(newloc.inode);
+        newloc.inode = NULL;
+    }
+    newloc.inode = inode_ref(oldloc.inode);
+
+    ret = syncop_link(subvol, &oldloc, &newloc, &newiatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == -1 && errno == ESTALE) {
+        loc_wipe(&oldloc);
+        loc_wipe(&newloc);
+        if (reval--)
+            goto retry;
+    }
+
+    if (ret == 0)
+        ret = glfs_loc_link(&newloc, &newiatt);
 out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_link, 3.4.0);
 
-
 struct glfs_fd *
-pub_glfs_opendir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
-
-	INIT_LIST_HEAD (&glfd->entries);
+pub_glfs_opendir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    INIT_LIST_HEAD(&glfd->entries);
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
-
-	if (ret)
-		goto out;
-
-	if (!IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
-
-	if (glfd->fd) {
-		/* Retry. Safe to touch glfd->fd as we
-		   still have not glfs_fd_bind() yet.
-		*/
-		fd_unref (glfd->fd);
-		glfd->fd = NULL;
-	}
-
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
+
+    if (ret)
+        goto out;
+
+    if (!IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
+
+    if (glfd->fd) {
+        /* Retry. Safe to touch glfd->fd as we
+           still have not glfs_fd_bind() yet.
+        */
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
+
+    glfd->fd = fd_create(loc.inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (ret && glfd) {
-		GF_REF_PUT (glfd);
-		glfd = NULL;
-	} else if (glfd) {
-                glfd_set_state_bind (glfd);
-	}
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return glfd;
+    return glfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_opendir, 3.4.0);
 
-
 int
-pub_glfs_closedir (struct glfs_fd *glfd)
+pub_glfs_closedir(struct glfs_fd *glfd)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-	gf_dirent_free (list_entry (&glfd->entries, gf_dirent_t, list));
+    gf_dirent_free(list_entry(&glfd->entries, gf_dirent_t, list));
 
-        glfs_mark_glfd_for_deletion (glfd);
+    glfs_mark_glfd_for_deletion(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        ret = 0;
+    ret = 0;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_closedir, 3.4.0);
 
-
 long
-pub_glfs_telldir (struct glfs_fd *fd)
+pub_glfs_telldir(struct glfs_fd *fd)
 {
-	return fd->offset;
+    return fd->offset;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_telldir, 3.4.0);
 
-
 void
-pub_glfs_seekdir (struct glfs_fd *fd, long offset)
+pub_glfs_seekdir(struct glfs_fd *fd, long offset)
 {
-	gf_dirent_t *entry = NULL;
-	gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-	if (fd->offset == offset)
-		return;
+    if (fd->offset == offset)
+        return;
 
-	fd->offset = offset;
-	fd->next = NULL;
+    fd->offset = offset;
+    fd->next = NULL;
 
-	list_for_each_entry_safe (entry, tmp, &fd->entries, list) {
-		if (entry->d_off != offset)
-			continue;
+    list_for_each_entry_safe(entry, tmp, &fd->entries, list)
+    {
+        if (entry->d_off != offset)
+            continue;
 
-		if (&tmp->list != &fd->entries) {
-			/* found! */
-			fd->next = tmp;
-			return;
-		}
-	}
-	/* could not find entry at requested offset in the cache.
-	   next readdir_r() will result in glfd_entry_refresh()
-	*/
+        if (&tmp->list != &fd->entries) {
+            /* found! */
+            fd->next = tmp;
+            return;
+        }
+    }
+    /* could not find entry at requested offset in the cache.
+       next readdir_r() will result in glfd_entry_refresh()
+    */
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_seekdir, 3.4.0);
 
 static int
-glfs_discard_async_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this, int32_t op_ret,
-                        int32_t op_errno, struct iatt *preop_stbuf,
-                        struct iatt *postop_stbuf, dict_t *xdata)
+glfs_discard_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno,
+                       struct iatt *preop_stbuf, struct iatt *postop_stbuf,
+                       dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0,
-                           preop_stbuf, postop_stbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        return 0;
+    return 0;
 }
 
 static int
-glfs_discard_async_common (struct glfs_fd *glfd, off_t offset, size_t len,
-                           gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+glfs_discard_async_common(struct glfs_fd *glfd, off_t offset, size_t len,
+                          gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-	struct glfs_io *gio = NULL;
-	int             ret = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-	gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-	if (!gio) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	gio->op     = GF_FOP_DISCARD;
-	gio->glfd   = glfd;
-	gio->offset = offset;
-	gio->count  = len;
-	gio->oldcb  = oldcb;
-	gio->fn     = fn;
-	gio->data   = data;
-
-        frame->local = gio;
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        STACK_WIND_COOKIE (frame, glfs_discard_async_cbk, subvol, subvol,
-                           subvol->fops->discard, fd, offset, len, fop_attr);
-
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_DISCARD;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->count = len;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_discard_async_cbk, subvol, subvol,
+                      subvol->fops->discard, fd, offset, len, fop_attr);
+
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 int
-pub_glfs_discard_async35 (struct glfs_fd *glfd, off_t offset, size_t len,
-                          glfs_io_cbk34 fn, void *data)
+pub_glfs_discard_async35(struct glfs_fd *glfd, off_t offset, size_t len,
+                         glfs_io_cbk34 fn, void *data)
 {
-        return glfs_discard_async_common (glfd, offset, len, _gf_true,
-                                          (void *)fn, data);
+    return glfs_discard_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                     data);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_discard_async35, glfs_discard_async, 3.5.0);
 
-
 int
-pub_glfs_discard_async (struct glfs_fd *glfd, off_t offset, size_t len,
-                        glfs_io_cbk fn, void *data)
+pub_glfs_discard_async(struct glfs_fd *glfd, off_t offset, size_t len,
+                       glfs_io_cbk fn, void *data)
 {
-        return glfs_discard_async_common (glfd, offset, len, _gf_false, fn,
-                                          data);
+    return glfs_discard_async_common(glfd, offset, len, _gf_false, fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard_async, future);
 
-
 static int
-glfs_zerofill_async_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret,
-                         int32_t op_errno, struct iatt *preop_stbuf,
-                         struct iatt *postop_stbuf, dict_t *xdata)
+glfs_zerofill_async_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        struct iatt *preop_stbuf, struct iatt *postop_stbuf,
+                        dict_t *xdata)
 {
-        glfs_io_async_cbk (op_ret, op_errno, frame, cookie, NULL, 0,
-                           preop_stbuf, postop_stbuf);
+    glfs_io_async_cbk(op_ret, op_errno, frame, cookie, NULL, 0, preop_stbuf,
+                      postop_stbuf);
 
-        return 0;
+    return 0;
 }
 
-
 static int
-glfs_zerofill_async_common (struct glfs_fd *glfd, off_t offset, off_t len,
-                            gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
+glfs_zerofill_async_common(struct glfs_fd *glfd, off_t offset, off_t len,
+                           gf_boolean_t oldcb, glfs_io_cbk fn, void *data)
 {
-        struct glfs_io *gio  = NULL;
-        int             ret  = -1;
-        call_frame_t   *frame = NULL;
-        xlator_t       *subvol = NULL;
-        fd_t           *fd = NULL;
-        dict_t         *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        /* Need to take explicit ref so that the fd
-         * is not destroyed before the fop is complete
-         */
-        GF_REF_GET (glfd);
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
-
-        frame = syncop_create_frame (THIS);
-        if (!frame) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gio = GF_CALLOC (1, sizeof (*gio), glfs_mt_glfs_io_t);
-        if (!gio) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gio->op     = GF_FOP_ZEROFILL;
-        gio->glfd   = glfd;
-        gio->offset = offset;
-        gio->count  = len;
-	gio->oldcb  = oldcb;
-        gio->fn     = fn;
-        gio->data   = data;
-
-        frame->local = gio;
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        STACK_WIND_COOKIE (frame, glfs_zerofill_async_cbk, subvol, subvol,
-                           subvol->fops->zerofill, fd, offset, len, fop_attr);
-        ret = 0;
+    struct glfs_io *gio = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    /* Need to take explicit ref so that the fd
+     * is not destroyed before the fop is complete
+     */
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    frame = syncop_create_frame(THIS);
+    if (!frame) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio = GF_CALLOC(1, sizeof(*gio), glfs_mt_glfs_io_t);
+    if (!gio) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gio->op = GF_FOP_ZEROFILL;
+    gio->glfd = glfd;
+    gio->offset = offset;
+    gio->count = len;
+    gio->oldcb = oldcb;
+    gio->fn = fn;
+    gio->data = data;
+
+    frame->local = gio;
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    STACK_WIND_COOKIE(frame, glfs_zerofill_async_cbk, subvol, subvol,
+                      subvol->fops->zerofill, fd, offset, len, fop_attr);
+    ret = 0;
 out:
-        if (ret) {
-                if (fd)
-                        fd_unref (fd);
-                if (glfd)
-                        GF_REF_PUT (glfd);
-                GF_FREE (gio);
-                if (frame)
-                        STACK_DESTROY (frame->root);
-                glfs_subvol_done (glfd->fs, subvol);
-        }
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (ret) {
+        if (fd)
+            fd_unref(fd);
+        if (glfd)
+            GF_REF_PUT(glfd);
+        GF_FREE(gio);
+        if (frame)
+            STACK_DESTROY(frame->root);
+        glfs_subvol_done(glfd->fs, subvol);
+    }
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 int
-pub_glfs_zerofill_async35 (struct glfs_fd *glfd, off_t offset, off_t len,
-                           glfs_io_cbk34 fn, void *data)
+pub_glfs_zerofill_async35(struct glfs_fd *glfd, off_t offset, off_t len,
+                          glfs_io_cbk34 fn, void *data)
 {
-        return glfs_zerofill_async_common (glfd, offset, len, _gf_true,
-                                           (void *)fn, data);
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_true, (void *)fn,
+                                      data);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_zerofill_async35, glfs_zerofill_async, 3.5.0);
 
-
 int
-pub_glfs_zerofill_async (struct glfs_fd *glfd, off_t offset, off_t len,
-                         glfs_io_cbk fn, void *data)
+pub_glfs_zerofill_async(struct glfs_fd *glfd, off_t offset, off_t len,
+                        glfs_io_cbk fn, void *data)
 {
-        return glfs_zerofill_async_common (glfd, offset, len, _gf_false,
-                                           fn, data);
+    return glfs_zerofill_async_common(glfd, offset, len, _gf_false, fn, data);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill_async, future);
 
-
 void
-gf_dirent_to_dirent (gf_dirent_t *gf_dirent, struct dirent *dirent)
+gf_dirent_to_dirent(gf_dirent_t *gf_dirent, struct dirent *dirent)
 {
-	dirent->d_ino = gf_dirent->d_ino;
+    dirent->d_ino = gf_dirent->d_ino;
 
 #ifdef _DIRENT_HAVE_D_OFF
-	dirent->d_off = gf_dirent->d_off;
+    dirent->d_off = gf_dirent->d_off;
 #endif
 
 #ifdef _DIRENT_HAVE_D_TYPE
-	dirent->d_type = gf_dirent->d_type;
+    dirent->d_type = gf_dirent->d_type;
 #endif
 
 #ifdef _DIRENT_HAVE_D_NAMLEN
-	dirent->d_namlen = strlen (gf_dirent->d_name);
+    dirent->d_namlen = strlen(gf_dirent->d_name);
 #endif
 
-        snprintf (dirent->d_name, NAME_MAX, "%s", gf_dirent->d_name);
+    snprintf(dirent->d_name, NAME_MAX, "%s", gf_dirent->d_name);
 }
 
-
 int
-glfd_entry_refresh (struct glfs_fd *glfd, int plus)
-{
-	xlator_t        *subvol = NULL;
-	gf_dirent_t      entries;
-	gf_dirent_t      old;
-        gf_dirent_t     *entry = NULL;
-	int              ret = -1;
-	fd_t            *fd = NULL;
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	if (fd->inode->ia_type != IA_IFDIR) {
-		ret = -1;
-		errno = EBADF;
-		goto out;
-	}
-
-	INIT_LIST_HEAD (&entries.list);
-	INIT_LIST_HEAD (&old.list);
-
-	if (plus)
-		ret = syncop_readdirp (subvol, fd, 131072, glfd->offset,
-				       &entries, NULL, NULL);
-	else
-		ret = syncop_readdir (subvol, fd, 131072, glfd->offset,
-				      &entries, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret >= 0) {
-		if (plus) {
-                        list_for_each_entry (entry, &entries.list, list) {
-                                if (!entry->inode &&
-                                    !IA_ISDIR (entry->d_stat.ia_type)) {
-                                        /* entry->inode for directories will be
-                                         * always set to null to force a lookup
-                                         * on the dentry. Also we will have
-                                         * proper stat if directory present on
-                                         * hashed subvolume.
-                                         */
-                                        gf_fill_iatt_for_dirent (entry,
-                                                                 fd->inode,
-                                                                 subvol);
-                                }
-                        }
-
-			gf_link_inodes_from_dirent (THIS, fd->inode, &entries);
+glfd_entry_refresh(struct glfs_fd *glfd, int plus)
+{
+    xlator_t *subvol = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t old;
+    gf_dirent_t *entry = NULL;
+    int ret = -1;
+    fd_t *fd = NULL;
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    if (fd->inode->ia_type != IA_IFDIR) {
+        ret = -1;
+        errno = EBADF;
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&entries.list);
+    INIT_LIST_HEAD(&old.list);
+
+    if (plus)
+        ret = syncop_readdirp(subvol, fd, 131072, glfd->offset, &entries, NULL,
+                              NULL);
+    else
+        ret = syncop_readdir(subvol, fd, 131072, glfd->offset, &entries, NULL,
+                             NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret >= 0) {
+        if (plus) {
+            list_for_each_entry(entry, &entries.list, list)
+            {
+                if (!entry->inode && !IA_ISDIR(entry->d_stat.ia_type)) {
+                    /* entry->inode for directories will be
+                     * always set to null to force a lookup
+                     * on the dentry. Also we will have
+                     * proper stat if directory present on
+                     * hashed subvolume.
+                     */
+                    gf_fill_iatt_for_dirent(entry, fd->inode, subvol);
                 }
+            }
 
-		list_splice_init (&glfd->entries, &old.list);
-		list_splice_init (&entries.list, &glfd->entries);
+            gf_link_inodes_from_dirent(THIS, fd->inode, &entries);
+        }
 
-		/* spurious errno is dangerous for glfd_entry_next() */
-		errno = 0;
-	}
+        list_splice_init(&glfd->entries, &old.list);
+        list_splice_init(&entries.list, &glfd->entries);
 
+        /* spurious errno is dangerous for glfd_entry_next() */
+        errno = 0;
+    }
 
-	if (ret > 0)
-		glfd->next = list_entry (glfd->entries.next, gf_dirent_t, list);
+    if (ret > 0)
+        glfd->next = list_entry(glfd->entries.next, gf_dirent_t, list);
 
-	gf_dirent_free (&old);
+    gf_dirent_free(&old);
 out:
-	if (fd)
-		fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-	return ret;
+    return ret;
 }
 
-
 gf_dirent_t *
-glfd_entry_next (struct glfs_fd *glfd, int plus)
+glfd_entry_next(struct glfs_fd *glfd, int plus)
 {
-	gf_dirent_t     *entry = NULL;
-	int              ret = -1;
+    gf_dirent_t *entry = NULL;
+    int ret = -1;
 
-	if (!glfd->offset || !glfd->next) {
-		ret = glfd_entry_refresh (glfd, plus);
-		if (ret < 0)
-			return NULL;
-	}
+    if (!glfd->offset || !glfd->next) {
+        ret = glfd_entry_refresh(glfd, plus);
+        if (ret < 0)
+            return NULL;
+    }
 
-	entry = glfd->next;
-	if (!entry)
-		return NULL;
+    entry = glfd->next;
+    if (!entry)
+        return NULL;
 
-	if (&entry->next->list == &glfd->entries)
-		glfd->next = NULL;
-	else
-		glfd->next = entry->next;
+    if (&entry->next->list == &glfd->entries)
+        glfd->next = NULL;
+    else
+        glfd->next = entry->next;
 
-	glfd->offset = entry->d_off;
+    glfd->offset = entry->d_off;
 
-	return entry;
+    return entry;
 }
 
-
 struct dirent *
-glfs_readdirbuf_get (struct glfs_fd *glfd)
+glfs_readdirbuf_get(struct glfs_fd *glfd)
 {
-        struct dirent *buf = NULL;
+    struct dirent *buf = NULL;
 
-        LOCK (&glfd->fd->lock);
-        {
-                buf = glfd->readdirbuf;
-                if (buf) {
-                        memset (buf, 0, READDIRBUF_SIZE);
-                        goto unlock;
-                }
-
-                buf = GF_CALLOC (1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t);
-                if (!buf) {
-                        errno = ENOMEM;
-                        goto unlock;
-                }
+    LOCK(&glfd->fd->lock);
+    {
+        buf = glfd->readdirbuf;
+        if (buf) {
+            memset(buf, 0, READDIRBUF_SIZE);
+            goto unlock;
+        }
 
-                glfd->readdirbuf = buf;
+        buf = GF_CALLOC(1, READDIRBUF_SIZE, glfs_mt_readdirbuf_t);
+        if (!buf) {
+            errno = ENOMEM;
+            goto unlock;
         }
+
+        glfd->readdirbuf = buf;
+    }
 unlock:
-        UNLOCK (&glfd->fd->lock);
+    UNLOCK(&glfd->fd->lock);
 
-        return buf;
+    return buf;
 }
 
-
 int
-pub_glfs_readdirplus_r (struct glfs_fd *glfd, struct stat *stat,
-                        struct dirent *ext, struct dirent **res)
+pub_glfs_readdirplus_r(struct glfs_fd *glfd, struct stat *stat,
+                       struct dirent *ext, struct dirent **res)
 {
-	int              ret = 0;
-	gf_dirent_t     *entry = NULL;
-	struct dirent   *buf = NULL;
+    int ret = 0;
+    gf_dirent_t *entry = NULL;
+    struct dirent *buf = NULL;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-	errno = 0;
+    errno = 0;
 
-	if (ext)
-		buf = ext;
-	else
-		buf = glfs_readdirbuf_get (glfd);
+    if (ext)
+        buf = ext;
+    else
+        buf = glfs_readdirbuf_get(glfd);
 
-	if (!buf) {
-		errno = ENOMEM;
-                ret = -1;
-                goto out;
-	}
+    if (!buf) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-	entry = glfd_entry_next (glfd, !!stat);
-	if (errno)
-		ret = -1;
+    entry = glfd_entry_next(glfd, !!stat);
+    if (errno)
+        ret = -1;
 
-	if (res) {
-		if (entry)
-			*res = buf;
-		else
-			*res = NULL;
-	}
+    if (res) {
+        if (entry)
+            *res = buf;
+        else
+            *res = NULL;
+    }
 
-	if (entry) {
-		gf_dirent_to_dirent (entry, buf);
-		if (stat)
-			glfs_iatt_to_stat (glfd->fs, &entry->d_stat, stat);
-	}
+    if (entry) {
+        gf_dirent_to_dirent(entry, buf);
+        if (stat)
+            glfs_iatt_to_stat(glfd->fs, &entry->d_stat, stat);
+    }
 
 out:
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus_r, 3.4.0);
 
-
 int
-pub_glfs_readdir_r (struct glfs_fd *glfd, struct dirent *buf,
-                    struct dirent **res)
+pub_glfs_readdir_r(struct glfs_fd *glfd, struct dirent *buf,
+                   struct dirent **res)
 {
-	return pub_glfs_readdirplus_r (glfd, 0, buf, res);
+    return pub_glfs_readdirplus_r(glfd, 0, buf, res);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir_r, 3.4.0);
 
-
 struct dirent *
-pub_glfs_readdirplus (struct glfs_fd *glfd, struct stat *stat)
+pub_glfs_readdirplus(struct glfs_fd *glfd, struct stat *stat)
 {
-        struct dirent *res = NULL;
-        int ret = -1;
+    struct dirent *res = NULL;
+    int ret = -1;
 
-        ret = pub_glfs_readdirplus_r (glfd, stat, NULL, &res);
-        if (ret)
-                return NULL;
+    ret = pub_glfs_readdirplus_r(glfd, stat, NULL, &res);
+    if (ret)
+        return NULL;
 
-        return res;
+    return res;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdirplus, 3.5.0);
 
-
 struct dirent *
-pub_glfs_readdir (struct glfs_fd *glfd)
+pub_glfs_readdir(struct glfs_fd *glfd)
 {
-        return pub_glfs_readdirplus (glfd, NULL);
+    return pub_glfs_readdirplus(glfd, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_readdir, 3.5.0);
 
-
 int
-pub_glfs_statvfs (struct glfs *fs, const char *path, struct statvfs *buf)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_statvfs(struct glfs *fs, const char *path, struct statvfs *buf)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_statfs (subvol, &loc, buf, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_statfs(subvol, &loc, buf, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_statvfs, 3.4.0);
 
-
 int
-glfs_setattr (struct glfs *fs, const char *path, struct iatt *iatt,
-	      int valid, int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      riatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_setattr(struct glfs *fs, const char *path, struct iatt *iatt, int valid,
+             int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt riatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &riatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &riatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &riatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &riatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-        /* TODO : Add leaseid */
-	ret = syncop_setattr (subvol, &loc, iatt, valid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* TODO : Add leaseid */
+    ret = syncop_setattr(subvol, &loc, iatt, valid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_fsetattr (struct glfs_fd *glfd, struct iatt *iatt, int valid)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        /* TODO : Add leaseid */
-	ret = syncop_fsetattr (subvol, fd, iatt, valid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+glfs_fsetattr(struct glfs_fd *glfd, struct iatt *iatt, int valid)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    /* TODO : Add leaseid */
+    ret = syncop_fsetattr(subvol, fd, iatt, valid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_chmod (struct glfs *fs, const char *path, mode_t mode)
+pub_glfs_chmod(struct glfs *fs, const char *path, mode_t mode)
 {
-	int              ret = -1;
-	struct iatt      iatt = {0, };
-	int              valid = 0;
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    int valid = 0;
 
-	iatt.ia_prot = ia_prot_from_st_mode (mode);
-	valid = GF_SET_ATTR_MODE;
+    iatt.ia_prot = ia_prot_from_st_mode(mode);
+    valid = GF_SET_ATTR_MODE;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    ret = glfs_setattr(fs, path, &iatt, valid, 1);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chmod, 3.4.0);
 
-
 int
-pub_glfs_fchmod (struct glfs_fd *glfd, mode_t mode)
+pub_glfs_fchmod(struct glfs_fd *glfd, mode_t mode)
 {
-	int              ret = -1;
-	struct iatt      iatt = {0, };
-	int              valid = 0;
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    int valid = 0;
 
-	iatt.ia_prot = ia_prot_from_st_mode (mode);
-	valid = GF_SET_ATTR_MODE;
+    iatt.ia_prot = ia_prot_from_st_mode(mode);
+    valid = GF_SET_ATTR_MODE;
 
-	ret = glfs_fsetattr (glfd, &iatt, valid);
+    ret = glfs_fsetattr(glfd, &iatt, valid);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchmod, 3.4.0);
 
-
 int
-pub_glfs_chown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_chown(struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-                iatt.ia_uid = uid;
-                valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        iatt.ia_uid = uid;
+        valid = GF_SET_ATTR_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        iatt.ia_gid = gid;
+        valid = valid | GF_SET_ATTR_GID;
+    }
 
-        if (valid)
-	        ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    if (valid)
+        ret = glfs_setattr(fs, path, &iatt, valid, 1);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chown, 3.4.0);
 
-
 int
-pub_glfs_lchown (struct glfs *fs, const char *path, uid_t uid, gid_t gid)
+pub_glfs_lchown(struct glfs *fs, const char *path, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-	        iatt.ia_uid = uid;
-	        valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        iatt.ia_uid = uid;
+        valid = GF_SET_ATTR_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        iatt.ia_gid = gid;
+        valid = valid | GF_SET_ATTR_GID;
+    }
 
-        if (valid)
-	        ret = glfs_setattr (fs, path, &iatt, valid, 0);
+    if (valid)
+        ret = glfs_setattr(fs, path, &iatt, valid, 0);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lchown, 3.4.0);
 
-
 int
-pub_glfs_fchown (struct glfs_fd *glfd, uid_t uid, gid_t gid)
+pub_glfs_fchown(struct glfs_fd *glfd, uid_t uid, gid_t gid)
 {
-	int              ret = 0;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = 0;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-        if (uid != (uid_t) -1) {
-                iatt.ia_uid = uid;
-                valid = GF_SET_ATTR_UID;
-        }
+    if (uid != (uid_t)-1) {
+        iatt.ia_uid = uid;
+        valid = GF_SET_ATTR_UID;
+    }
 
-        if (gid != (uid_t) -1) {
-                iatt.ia_gid = gid;
-                valid = valid | GF_SET_ATTR_GID;
-        }
+    if (gid != (uid_t)-1) {
+        iatt.ia_gid = gid;
+        valid = valid | GF_SET_ATTR_GID;
+    }
 
-        if (valid)
-	        ret = glfs_fsetattr (glfd, &iatt, valid);
+    if (valid)
+        ret = glfs_fsetattr(glfd, &iatt, valid);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchown, 3.4.0);
 
-
 int
-pub_glfs_utimens (struct glfs *fs, const char *path,
-                  const struct timespec times[2])
+pub_glfs_utimens(struct glfs *fs, const char *path,
+                 const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    iatt.ia_atime = times[0].tv_sec;
+    iatt.ia_atime_nsec = times[0].tv_nsec;
+    iatt.ia_mtime = times[1].tv_sec;
+    iatt.ia_mtime_nsec = times[1].tv_nsec;
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 1);
+    ret = glfs_setattr(fs, path, &iatt, valid, 1);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_utimens, 3.4.0);
 
-
 int
-pub_glfs_lutimens (struct glfs *fs, const char *path,
-                   const struct timespec times[2])
+pub_glfs_lutimens(struct glfs *fs, const char *path,
+                  const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    iatt.ia_atime = times[0].tv_sec;
+    iatt.ia_atime_nsec = times[0].tv_nsec;
+    iatt.ia_mtime = times[1].tv_sec;
+    iatt.ia_mtime_nsec = times[1].tv_nsec;
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
 
-	ret = glfs_setattr (fs, path, &iatt, valid, 0);
+    ret = glfs_setattr(fs, path, &iatt, valid, 0);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lutimens, 3.4.0);
 
-
 int
-pub_glfs_futimens (struct glfs_fd *glfd, const struct timespec times[2])
+pub_glfs_futimens(struct glfs_fd *glfd, const struct timespec times[2])
 {
-	int              ret = -1;
-	int              valid = 0;
-	struct iatt      iatt = {0, };
+    int ret = -1;
+    int valid = 0;
+    struct iatt iatt = {
+        0,
+    };
 
-	iatt.ia_atime = times[0].tv_sec;
-	iatt.ia_atime_nsec = times[0].tv_nsec;
-	iatt.ia_mtime = times[1].tv_sec;
-	iatt.ia_mtime_nsec = times[1].tv_nsec;
+    iatt.ia_atime = times[0].tv_sec;
+    iatt.ia_atime_nsec = times[0].tv_nsec;
+    iatt.ia_mtime = times[1].tv_sec;
+    iatt.ia_mtime_nsec = times[1].tv_nsec;
 
-	valid = GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME;
+    valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
 
-	ret = glfs_fsetattr (glfd, &iatt, valid);
+    ret = glfs_fsetattr(glfd, &iatt, valid);
 
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_futimens, 3.4.0);
 
-
 int
-glfs_getxattr_process (void *value, size_t size, dict_t *xattr,
-		       const char *name)
-{
-	data_t *data = NULL;
-	int     ret = -1;
-
-	data = dict_get (xattr, (char *)name);
-	if (!data) {
-		errno = ENODATA;
-		ret = -1;
-		goto out;
-	}
-
-	ret = data->len;
-	if (!value || !size)
-		goto out;
-
-	if (size < ret) {
-		ret = -1;
-		errno = ERANGE;
-		goto out;
-	}
-
-	memcpy (value, data->data, ret);
-out:
-	return ret;
-}
-
-
-ssize_t
-glfs_getxattr_common (struct glfs *fs, const char *path, const char *name,
-		      void *value, size_t size, int follow)
+glfs_getxattr_process(void *value, size_t size, dict_t *xattr, const char *name)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
+    data_t *data = NULL;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    data = dict_get(xattr, (char *)name);
+    if (!data) {
+        errno = ENODATA;
+        ret = -1;
+        goto out;
+    }
 
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
+    ret = data->len;
+    if (!value || !size)
+        goto out;
 
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
+    if (size < ret) {
+        ret = -1;
+        errno = ERANGE;
+        goto out;
+    }
+
+    memcpy(value, data->data, ret);
+out:
+    return ret;
+}
 
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+ssize_t
+glfs_getxattr_common(struct glfs *fs, const char *path, const char *name,
+                     void *value, size_t size, int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_getxattr (subvol, &loc, &xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_getxattr(subvol, &loc, &xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = glfs_getxattr_process (value, size, xattr, name);
+    ret = glfs_getxattr_process(value, size, xattr, name);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 ssize_t
-pub_glfs_getxattr (struct glfs *fs, const char *path, const char *name,
-                   void *value, size_t size)
+pub_glfs_getxattr(struct glfs *fs, const char *path, const char *name,
+                  void *value, size_t size)
 {
-	return glfs_getxattr_common (fs, path, name, value, size, 1);
+    return glfs_getxattr_common(fs, path, name, value, size, 1);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getxattr, 3.4.0);
 
-
 ssize_t
-pub_glfs_lgetxattr (struct glfs *fs, const char *path, const char *name,
-                    void *value, size_t size)
+pub_glfs_lgetxattr(struct glfs *fs, const char *path, const char *name,
+                   void *value, size_t size)
 {
-	return glfs_getxattr_common (fs, path, name, value, size, 0);
+    return glfs_getxattr_common(fs, path, name, value, size, 0);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lgetxattr, 3.4.0);
 
-
 ssize_t
-pub_glfs_fgetxattr (struct glfs_fd *glfd, const char *name, void *value,
-                    size_t size)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fgetxattr (subvol, fd, &xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	ret = glfs_getxattr_process (value, size, xattr, name);
+pub_glfs_fgetxattr(struct glfs_fd *glfd, const char *name, void *value,
+                   size_t size)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fgetxattr(subvol, fd, &xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    ret = glfs_getxattr_process(value, size, xattr, name);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (xattr)
-                dict_unref (xattr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fgetxattr, 3.4.0);
 
-
 int
-glfs_listxattr_process (void *value, size_t size, dict_t *xattr)
+glfs_listxattr_process(void *value, size_t size, dict_t *xattr)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (!xattr)
-		goto out;
+    if (!xattr)
+        goto out;
 
-	ret = dict_keys_join (NULL, 0, xattr, NULL);
+    ret = dict_keys_join(NULL, 0, xattr, NULL);
 
-        if (!value || !size)
-                goto out;
+    if (!value || !size)
+        goto out;
 
-	if (size < ret) {
-		ret = -1;
-		errno = ERANGE;
-	} else {
-		dict_keys_join (value, size, xattr, NULL);
-	}
+    if (size < ret) {
+        ret = -1;
+        errno = ERANGE;
+    } else {
+        dict_keys_join(value, size, xattr, NULL);
+    }
 
 out:
-	return ret;
+    return ret;
 }
 
-
 ssize_t
-glfs_listxattr_common (struct glfs *fs, const char *path, void *value,
-		       size_t size, int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_listxattr_common(struct glfs *fs, const char *path, void *value,
+                      size_t size, int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_getxattr (subvol, &loc, &xattr, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_getxattr(subvol, &loc, &xattr, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = glfs_listxattr_process (value, size, xattr);
+    ret = glfs_listxattr_process(value, size, xattr);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 ssize_t
-pub_glfs_listxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_listxattr(struct glfs *fs, const char *path, void *value, size_t size)
 {
-	return glfs_listxattr_common (fs, path, value, size, 1);
+    return glfs_listxattr_common(fs, path, value, size, 1);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_listxattr, 3.4.0);
 
-
 ssize_t
-pub_glfs_llistxattr (struct glfs *fs, const char *path, void *value, size_t size)
+pub_glfs_llistxattr(struct glfs *fs, const char *path, void *value, size_t size)
 {
-	return glfs_listxattr_common (fs, path, value, size, 0);
+    return glfs_listxattr_common(fs, path, value, size, 0);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_llistxattr, 3.4.0);
 
-
 ssize_t
-pub_glfs_flistxattr (struct glfs_fd *glfd, void *value, size_t size)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	ret = syncop_fgetxattr (subvol, fd, &xattr, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	ret = glfs_listxattr_process (value, size, xattr);
+pub_glfs_flistxattr(struct glfs_fd *glfd, void *value, size_t size)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = syncop_fgetxattr(subvol, fd, &xattr, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    ret = glfs_listxattr_process(value, size, xattr);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (xattr)
-                dict_unref (xattr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_flistxattr, 3.4.0);
 
 int
-glfs_setxattr_common (struct glfs *fs, const char *path, const char *name,
-		      const void *value, size_t size, int flags, int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	dict_t          *xattr = NULL;
-	int              reval = 0;
-        void            *value_cp = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_setxattr_common(struct glfs *fs, const char *path, const char *name,
+                     const void *value, size_t size, int flags, int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int reval = 0;
+    void *value_cp = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
 
-	xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-	if (!xattr) {
-                GF_FREE (value_cp);
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
 
-	ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-	loc_wipe (&loc);
-	if (xattr)
-		dict_unref (xattr);
+    loc_wipe(&loc);
+    if (xattr)
+        dict_unref(xattr);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_setxattr (struct glfs *fs, const char *path, const char *name,
-                   const void *value, size_t size, int flags)
+pub_glfs_setxattr(struct glfs *fs, const char *path, const char *name,
+                  const void *value, size_t size, int flags)
 {
-	return glfs_setxattr_common (fs, path, name, value, size, flags, 1);
+    return glfs_setxattr_common(fs, path, name, value, size, flags, 1);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setxattr, 3.4.0);
 
-
 int
-pub_glfs_lsetxattr (struct glfs *fs, const char *path, const char *name,
-                    const void *value, size_t size, int flags)
+pub_glfs_lsetxattr(struct glfs *fs, const char *path, const char *name,
+                   const void *value, size_t size, int flags)
 {
-	return glfs_setxattr_common (fs, path, name, value, size, flags, 0);
+    return glfs_setxattr_common(fs, path, name, value, size, flags, 0);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lsetxattr, 3.4.0);
 
-
 int
-pub_glfs_fsetxattr (struct glfs_fd *glfd, const char *name, const void *value,
-                    size_t size, int flags)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	dict_t          *xattr = NULL;
-	fd_t            *fd = NULL;
-        void            *value_cp = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        if (!name || *name == '\0') {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                ret = -1;
-                errno = ENAMETOOLONG;
-                goto out;
-        }
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
-
-	xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-	if (!xattr) {
-                GF_FREE (value_cp);
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	ret = syncop_fsetxattr (subvol, fd, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+pub_glfs_fsetxattr(struct glfs_fd *glfd, const char *name, const void *value,
+                   size_t size, int flags)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    fd_t *fd = NULL;
+    void *value_cp = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!name || *name == '\0') {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        ret = -1;
+        errno = ENAMETOOLONG;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
+
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_fsetxattr(subvol, fd, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (xattr)
-		dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fsetxattr, 3.4.0);
 
-
 int
-glfs_removexattr_common (struct glfs *fs, const char *path, const char *name,
-			 int follow)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+glfs_removexattr_common(struct glfs *fs, const char *path, const char *name,
+                        int follow)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	if (follow)
-		ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
-	else
-		ret = glfs_lresolve (fs, subvol, path, &loc, &iatt, reval);
+    if (follow)
+        ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
+    else
+        ret = glfs_lresolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	ret = syncop_removexattr (subvol, &loc, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_removexattr(subvol, &loc, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_removexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_removexattr(struct glfs *fs, const char *path, const char *name)
 {
-	return glfs_removexattr_common (fs, path, name, 1);
+    return glfs_removexattr_common(fs, path, name, 1);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_removexattr, 3.4.0);
 
-
 int
-pub_glfs_lremovexattr (struct glfs *fs, const char *path, const char *name)
+pub_glfs_lremovexattr(struct glfs *fs, const char *path, const char *name)
 {
-	return glfs_removexattr_common (fs, path, name, 0);
+    return glfs_removexattr_common(fs, path, name, 0);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lremovexattr, 3.4.0);
 
-
 int
-pub_glfs_fremovexattr (struct glfs_fd *glfd, const char *name)
+pub_glfs_fremovexattr(struct glfs_fd *glfd, const char *name)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t            *fd = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
 
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
 
-	ret = syncop_fremovexattr (subvol, fd, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_fremovexattr(subvol, fd, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fremovexattr, 3.4.0);
 
-
 int
-pub_glfs_fallocate (struct glfs_fd *glfd, int keep_size, off_t offset, size_t len)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t		*fd = NULL;
-        dict_t          *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_fallocate (subvol, fd, keep_size, offset, len, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+pub_glfs_fallocate(struct glfs_fd *glfd, int keep_size, off_t offset,
+                   size_t len)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_fallocate(subvol, fd, keep_size, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fallocate, 3.5.0);
 
-
 int
-pub_glfs_discard (struct glfs_fd *glfd, off_t offset, size_t len)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	fd_t		*fd = NULL;
-        dict_t          *fop_attr = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-	ret = syncop_discard (subvol, fd, offset, len, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+pub_glfs_discard(struct glfs_fd *glfd, off_t offset, size_t len)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_discard(subvol, fd, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	if (fd)
-		fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_discard, 3.5.0);
 
-
 int
-pub_glfs_zerofill (struct glfs_fd *glfd, off_t offset, off_t len)
+pub_glfs_zerofill(struct glfs_fd *glfd, off_t offset, off_t len)
 {
-        int               ret             = -1;
-        xlator_t         *subvol          = NULL;
-        fd_t             *fd              = NULL;
-        dict_t           *fop_attr         = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    dict_t *fop_attr = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                errno = EBADFD;
-                goto out;
-        }
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
 
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-        ret = syncop_zerofill (subvol, fd, offset, len, fop_attr, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_zerofill(subvol, fd, offset, len, fop_attr, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        if (fd)
-                fd_unref(fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
-        if (fop_attr)
-                dict_unref (fop_attr);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-        glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_zerofill, 3.5.0);
 
-
 int
-pub_glfs_chdir (struct glfs *fs, const char *path)
-{
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+pub_glfs_chdir(struct glfs *fs, const char *path)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (!IA_ISDIR (iatt.ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
+    if (!IA_ISDIR(iatt.ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
 
-	glfs_cwd_set (fs, loc.inode);
+    glfs_cwd_set(fs, loc.inode);
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_chdir, 3.4.0);
 
-
 int
-pub_glfs_fchdir (struct glfs_fd *glfd)
-{
-	int       ret = -1;
-	inode_t  *inode = NULL;
-	xlator_t *subvol = NULL;
-	fd_t     *fd = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	subvol = glfs_active_subvol (glfd->fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-	if (!fd) {
-		ret = -1;
-		errno = EBADFD;
-		goto out;
-	}
-
-	inode = fd->inode;
-
-	if (!IA_ISDIR (inode->ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
-
-	glfs_cwd_set (glfd->fs, inode);
-	ret = 0;
+pub_glfs_fchdir(struct glfs_fd *glfd)
+{
+    int ret = -1;
+    inode_t *inode = NULL;
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    inode = fd->inode;
+
+    if (!IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
+
+    glfs_cwd_set(glfd->fs, inode);
+    ret = 0;
 out:
-	if (fd)
-		fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0);
@@ -4626,680 +4679,673 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fchdir, 3.4.0);
 static gf_boolean_t warn_realpath = _gf_true; /* log once */
 
 static char *
-glfs_realpath_common (struct glfs *fs, const char *path, char *resolved_path,
-                      gf_boolean_t warn_deprecated)
-{
-	int              ret = -1;
-	char            *retpath = NULL;
-	char            *allocpath = NULL;
-	xlator_t        *subvol = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              reval = 0;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	if (resolved_path)
-		retpath = resolved_path;
-        else if (warn_deprecated) {
-                retpath = allocpath = malloc (PATH_MAX + 1);
-                if (warn_realpath) {
-                        warn_realpath = _gf_false;
-                        gf_log (THIS->name, GF_LOG_WARNING, "this application "
-                                "is compiled against an old version of "
-                                "libgfapi, it should use glfs_free() to "
-                                "release the path returned by "
-                                "glfs_realpath()");
-                }
-        } else {
-                retpath = allocpath = GLFS_CALLOC (1, PATH_MAX + 1, NULL,
-                                                   glfs_mt_realpath_t);
+glfs_realpath_common(struct glfs *fs, const char *path, char *resolved_path,
+                     gf_boolean_t warn_deprecated)
+{
+    int ret = -1;
+    char *retpath = NULL;
+    char *allocpath = NULL;
+    xlator_t *subvol = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int reval = 0;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (resolved_path)
+        retpath = resolved_path;
+    else if (warn_deprecated) {
+        retpath = allocpath = malloc(PATH_MAX + 1);
+        if (warn_realpath) {
+            warn_realpath = _gf_false;
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "this application "
+                   "is compiled against an old version of "
+                   "libgfapi, it should use glfs_free() to "
+                   "release the path returned by "
+                   "glfs_realpath()");
         }
-
-	if (!retpath) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    } else {
+        retpath = allocpath = GLFS_CALLOC(1, PATH_MAX + 1, NULL,
+                                          glfs_mt_realpath_t);
+    }
+
+    if (!retpath) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 retry:
-	ret = glfs_resolve (fs, subvol, path, &loc, &iatt, reval);
+    ret = glfs_resolve(fs, subvol, path, &loc, &iatt, reval);
 
-	ESTALE_RETRY (ret, errno, reval, &loc, retry);
+    ESTALE_RETRY(ret, errno, reval, &loc, retry);
 
-	if (ret)
-		goto out;
+    if (ret)
+        goto out;
 
-	if (loc.path) {
-                snprintf (retpath, PATH_MAX, "%s", loc.path);
-	}
+    if (loc.path) {
+        snprintf(retpath, PATH_MAX, "%s", loc.path);
+    }
 
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	if (ret == -1) {
-                if (warn_deprecated && allocpath)
-                        free (allocpath);
-                else if (allocpath)
-                        GLFS_FREE (allocpath);
-                retpath = NULL;
-	}
+    if (ret == -1) {
+        if (warn_deprecated && allocpath)
+            free(allocpath);
+        else if (allocpath)
+            GLFS_FREE(allocpath);
+        retpath = NULL;
+    }
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return retpath;
+    return retpath;
 }
 
-
 char *
-pub_glfs_realpath34 (struct glfs *fs, const char *path, char *resolved_path)
+pub_glfs_realpath34(struct glfs *fs, const char *path, char *resolved_path)
 {
-        return glfs_realpath_common (fs, path, resolved_path, _gf_true);
+    return glfs_realpath_common(fs, path, resolved_path, _gf_true);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_realpath34, glfs_realpath, 3.4.0);
 
 char *
-pub_glfs_realpath (struct glfs *fs, const char *path, char *resolved_path)
+pub_glfs_realpath(struct glfs *fs, const char *path, char *resolved_path)
 {
-        return glfs_realpath_common (fs, path, resolved_path, _gf_false);
+    return glfs_realpath_common(fs, path, resolved_path, _gf_false);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_realpath, 3.7.17);
 
-
 char *
-pub_glfs_getcwd (struct glfs *fs, char *buf, size_t n)
-{
-	int              ret = -1;
-	inode_t         *inode = NULL;
-	char            *path = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-	if (!buf || n < 2) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	inode = glfs_cwd_get (fs);
-
-	if (!inode) {
-		strncpy (buf, "/", n);
-		ret = 0;
-		goto out;
-	}
-
-	ret = inode_path (inode, 0, &path);
-	if (n <= ret) {
-		ret = -1;
-		errno = ERANGE;
-		goto out;
-	}
-
-	strncpy (buf, path, n);
-	ret = 0;
+pub_glfs_getcwd(struct glfs *fs, char *buf, size_t n)
+{
+    int ret = -1;
+    inode_t *inode = NULL;
+    char *path = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (!buf || n < 2) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    inode = glfs_cwd_get(fs);
+
+    if (!inode) {
+        strncpy(buf, "/", n);
+        ret = 0;
+        goto out;
+    }
+
+    ret = inode_path(inode, 0, &path);
+    if (n <= ret) {
+        ret = -1;
+        errno = ERANGE;
+        goto out;
+    }
+
+    strncpy(buf, path, n);
+    ret = 0;
 out:
-	GF_FREE (path);
+    GF_FREE(path);
 
-	if (inode)
-		inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	if (ret < 0)
-		return NULL;
+    if (ret < 0)
+        return NULL;
 
-	return buf;
+    return buf;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_getcwd, 3.4.0);
 
-
 static void
-gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock)
+gf_flock_to_flock(struct gf_flock *gf_flock, struct flock *flock)
 {
-	flock->l_type   = gf_flock->l_type;
-	flock->l_whence = gf_flock->l_whence;
-	flock->l_start  = gf_flock->l_start;
-	flock->l_len    = gf_flock->l_len;
-	flock->l_pid    = gf_flock->l_pid;
+    flock->l_type = gf_flock->l_type;
+    flock->l_whence = gf_flock->l_whence;
+    flock->l_start = gf_flock->l_start;
+    flock->l_len = gf_flock->l_len;
+    flock->l_pid = gf_flock->l_pid;
 }
 
-
 static void
-gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock)
+gf_flock_from_flock(struct gf_flock *gf_flock, struct flock *flock)
 {
-	gf_flock->l_type   = flock->l_type;
-	gf_flock->l_whence = flock->l_whence;
-	gf_flock->l_start  = flock->l_start;
-	gf_flock->l_len    = flock->l_len;
-	gf_flock->l_pid    = flock->l_pid;
+    gf_flock->l_type = flock->l_type;
+    gf_flock->l_whence = flock->l_whence;
+    gf_flock->l_start = flock->l_start;
+    gf_flock->l_len = flock->l_len;
+    gf_flock->l_pid = flock->l_pid;
 }
 
 static int
-glfs_lock_common (struct glfs_fd *glfd, int cmd, struct flock *flock,
-                  dict_t *xdata)
-{
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        struct gf_flock  gf_flock = {0, };
-        struct gf_flock  saved_flock = {0, };
-        fd_t            *fd = NULL;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        if (!flock) {
-                errno = EINVAL;
-                goto out;
-        }
+glfs_lock_common(struct glfs_fd *glfd, int cmd, struct flock *flock,
+                 dict_t *xdata)
+{
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    struct gf_flock gf_flock = {
+        0,
+    };
+    struct gf_flock saved_flock = {
+        0,
+    };
+    fd_t *fd = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    if (!flock) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    GF_REF_GET(glfd);
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    /* Generate glusterfs flock structure from client flock
+     * structure to be processed by server */
+    gf_flock_from_flock(&gf_flock, flock);
+
+    /* Keep another copy of flock for split/merge of locks
+     * at client side */
+    gf_flock_from_flock(&saved_flock, flock);
+
+    if (glfd->lk_owner.len != 0) {
+        ret = syncopctx_setfslkowner(&glfd->lk_owner);
 
-        GF_REF_GET (glfd);
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
-                ret = -1;
-                errno = EBADFD;
-                goto out;
-        }
-
-        /* Generate glusterfs flock structure from client flock
-         * structure to be processed by server */
-        gf_flock_from_flock (&gf_flock, flock);
+        if (ret)
+            goto out;
+    }
 
-        /* Keep another copy of flock for split/merge of locks
-         * at client side */
-        gf_flock_from_flock (&saved_flock, flock);
+    ret = get_fop_attr_thrd_key(&xdata);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
 
-        if (glfd->lk_owner.len != 0) {
-                ret = syncopctx_setfslkowner (&glfd->lk_owner);
+    ret = syncop_lk(subvol, fd, cmd, &gf_flock, xdata, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-                if (ret)
-                        goto out;
-        }
+    /* Convert back from gf_flock to flock as expected by application */
+    gf_flock_to_flock(&gf_flock, flock);
 
-        ret = get_fop_attr_thrd_key (&xdata);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
-
-        ret = syncop_lk (subvol, fd, cmd, &gf_flock, xdata, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* Convert back from gf_flock to flock as expected by application */
-        gf_flock_to_flock (&gf_flock, flock);
-
-        if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) {
-                ret = fd_lk_insert_and_merge (fd, cmd, &saved_flock);
-                if (ret) {
-                        gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                API_MSG_LOCK_INSERT_MERGE_FAILED,
-                                "Lock insertion and splitting/merging failed "
-                                "on gfid %s", uuid_utoa (fd->inode->gfid));
-                        ret = 0;
-                }
+    if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) {
+        ret = fd_lk_insert_and_merge(fd, cmd, &saved_flock);
+        if (ret) {
+            gf_msg(THIS->name, GF_LOG_ERROR, 0,
+                   API_MSG_LOCK_INSERT_MERGE_FAILED,
+                   "Lock insertion and splitting/merging failed "
+                   "on gfid %s",
+                   uuid_utoa(fd->inode->gfid));
+            ret = 0;
         }
+    }
 
 out:
-        if (fd)
-                fd_unref (fd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        glfs_subvol_done (glfd->fs, subvol);
+    glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 int
-pub_glfs_file_lock (struct glfs_fd *glfd, int cmd, struct flock *flock,
-                    glfs_lock_mode_t lk_mode)
-{
-        int              ret            = -1;
-        dict_t          *xdata_in       = NULL;
-
-        if (lk_mode == GLFS_LK_MANDATORY) {
-                /* Create a new dictionary */
-                xdata_in = dict_new ();
-                if (xdata_in == NULL) {
-                        ret = -1;
-                        errno = ENOMEM;
-                        goto out;
-                }
+pub_glfs_file_lock(struct glfs_fd *glfd, int cmd, struct flock *flock,
+                   glfs_lock_mode_t lk_mode)
+{
+    int ret = -1;
+    dict_t *xdata_in = NULL;
+
+    if (lk_mode == GLFS_LK_MANDATORY) {
+        /* Create a new dictionary */
+        xdata_in = dict_new();
+        if (xdata_in == NULL) {
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
+        }
 
-                /* Set GF_LK_MANDATORY internally within dictionary to map
-                 * GLFS_LK_MANDATORY */
-                ret = dict_set_uint32 (xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY);
-                if (ret) {
-                        gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                API_MSG_SETTING_LOCK_TYPE_FAILED,
-                                "Setting lock type failed");
-                        ret = -1;
-                        errno = ENOMEM;
-                        goto out;
-                }
+        /* Set GF_LK_MANDATORY internally within dictionary to map
+         * GLFS_LK_MANDATORY */
+        ret = dict_set_uint32(xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY);
+        if (ret) {
+            gf_msg(THIS->name, GF_LOG_ERROR, 0,
+                   API_MSG_SETTING_LOCK_TYPE_FAILED,
+                   "Setting lock type failed");
+            ret = -1;
+            errno = ENOMEM;
+            goto out;
         }
+    }
 
-        ret = glfs_lock_common (glfd, cmd, flock, xdata_in);
+    ret = glfs_lock_common(glfd, cmd, flock, xdata_in);
 out:
-        if (xdata_in)
-                dict_unref (xdata_in);
+    if (xdata_in)
+        dict_unref(xdata_in);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_file_lock, 4.0.0);
 
 int
-pub_glfs_posix_lock (struct glfs_fd *glfd, int cmd, struct flock *flock)
+pub_glfs_posix_lock(struct glfs_fd *glfd, int cmd, struct flock *flock)
 {
-        return glfs_lock_common (glfd, cmd, flock, NULL);
+    return glfs_lock_common(glfd, cmd, flock, NULL);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_posix_lock, 3.4.0);
 
 int
-pub_glfs_fd_set_lkowner (struct glfs_fd *glfd, void *data, int len)
+pub_glfs_fd_set_lkowner(struct glfs_fd *glfd, void *data, int len)
 {
-        int ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        if (!GF_REF_GET (glfd)) {
-                goto invalid_fs;
-        }
+    if (!GF_REF_GET(glfd)) {
+        goto invalid_fs;
+    }
 
-        GF_VALIDATE_OR_GOTO (THIS->name, data, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, data, out);
 
-        if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) {
-                errno = EINVAL;
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "Invalid lk_owner len (%d)", len);
-                goto out;
-        }
+    if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) {
+        errno = EINVAL;
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
+               "Invalid lk_owner len (%d)", len);
+        goto out;
+    }
 
-        glfd->lk_owner.len = len;
+    glfd->lk_owner.len = len;
 
-        memcpy (glfd->lk_owner.data, data, len);
+    memcpy(glfd->lk_owner.data, data, len);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fd_set_lkowner, 3.10.7);
 
 struct glfs_fd *
-pub_glfs_dup (struct glfs_fd *glfd)
-{
-	xlator_t  *subvol = NULL;
-	fd_t      *fd = NULL;
-	struct glfs_fd *dupfd = NULL;
-	struct glfs *fs = NULL;
-
-        DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-	fs = glfd->fs;
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		errno = EIO;
-		goto out;
-	}
-
-	fd = glfs_resolve_fd (fs, subvol, glfd);
-	if (!fd) {
-		errno = EBADFD;
-		goto out;
-	}
-
-	dupfd = glfs_fd_new (fs);
-	if (!dupfd) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	dupfd->fd = fd_ref (fd);
-        dupfd->state = glfd->state;
+pub_glfs_dup(struct glfs_fd *glfd)
+{
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct glfs_fd *dupfd = NULL;
+    struct glfs *fs = NULL;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    fs = glfd->fs;
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(fs, subvol, glfd);
+    if (!fd) {
+        errno = EBADFD;
+        goto out;
+    }
+
+    dupfd = glfs_fd_new(fs);
+    if (!dupfd) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    dupfd->fd = fd_ref(fd);
+    dupfd->state = glfd->state;
 out:
-	if (fd)
-		fd_unref (fd);
-	if (dupfd)
-		glfs_fd_bind (dupfd);
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (fd)
+        fd_unref(fd);
+    if (dupfd)
+        glfs_fd_bind(dupfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return dupfd;
+    return dupfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_dup, 3.4.0);
 
 static void
-glfs_enqueue_upcall_data (struct glfs *fs, struct gf_upcall *upcall_data)
+glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
 {
-        int ret = -1;
-        upcall_entry *u_list = NULL;
+    int ret = -1;
+    upcall_entry *u_list = NULL;
 
-        if (!fs || !upcall_data)
-                goto out;
+    if (!fs || !upcall_data)
+        goto out;
 
-        u_list = GF_CALLOC (1, sizeof(*u_list),
-                            glfs_mt_upcall_entry_t);
+    u_list = GF_CALLOC(1, sizeof(*u_list), glfs_mt_upcall_entry_t);
 
-        if (!u_list) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    if (!u_list) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
+               "Upcall entry allocation failed.");
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&u_list->upcall_list);
+    INIT_LIST_HEAD(&u_list->upcall_list);
 
-        gf_uuid_copy (u_list->upcall_data.gfid, upcall_data->gfid);
-        u_list->upcall_data.event_type = upcall_data->event_type;
+    gf_uuid_copy(u_list->upcall_data.gfid, upcall_data->gfid);
+    u_list->upcall_data.event_type = upcall_data->event_type;
 
-        switch (upcall_data->event_type) {
+    switch (upcall_data->event_type) {
         case GF_UPCALL_CACHE_INVALIDATION:
-                ret = glfs_get_upcall_cache_invalidation (&u_list->upcall_data,
-                                                          upcall_data);
-                break;
+            ret = glfs_get_upcall_cache_invalidation(&u_list->upcall_data,
+                                                     upcall_data);
+            break;
         case GF_UPCALL_RECALL_LEASE:
-                ret = glfs_get_upcall_lease (&u_list->upcall_data,
-                                                   upcall_data);
-                break;
+            ret = glfs_get_upcall_lease(&u_list->upcall_data, upcall_data);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall entry validation failed.");
-                goto out;
-        }
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY,
+               "Upcall entry validation failed.");
+        goto out;
+    }
 
-        pthread_mutex_lock (&fs->upcall_list_mutex);
-        {
-                list_add_tail (&u_list->upcall_list,
-                               &fs->upcall_list);
-        }
-        pthread_mutex_unlock (&fs->upcall_list_mutex);
+    pthread_mutex_lock(&fs->upcall_list_mutex);
+    {
+        list_add_tail(&u_list->upcall_list, &fs->upcall_list);
+    }
+    pthread_mutex_unlock(&fs->upcall_list_mutex);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret && u_list) {
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE(u_list);
-        }
+    if (ret && u_list) {
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    }
 }
 
 static void
-glfs_free_upcall_lease (void *to_free)
+glfs_free_upcall_lease(void *to_free)
 {
-        struct glfs_upcall_lease *arg = to_free;
+    struct glfs_upcall_lease *arg = to_free;
 
-        if (!arg)
-                return;
+    if (!arg)
+        return;
 
-        if (arg->object)
-                glfs_h_close (arg->object);
+    if (arg->object)
+        glfs_h_close(arg->object);
 
-        GF_FREE (arg);
+    GF_FREE(arg);
 }
 
 int
-glfs_recall_lease_fd (struct glfs *fs,
-                      struct gf_upcall *up_data)
-{
-        struct gf_upcall_recall_lease *recall_lease = NULL;
-        xlator_t                      *subvol       = NULL;
-        int                            ret          = 0;
-        inode_t                       *inode        = NULL;
-        struct glfs_fd                *glfd         = NULL;
-        struct glfs_fd                *tmp          = NULL;
-        struct list_head               glfd_list    = { 0, };
-        fd_t                          *fd           = NULL;
-        uint64_t                       value        = 0;
-        struct glfs_lease              lease        = {0, };
-
-        GF_VALIDATE_OR_GOTO ("gfapi", up_data, out);
-        GF_VALIDATE_OR_GOTO ("gfapi", fs, out);
-
-        recall_lease = up_data->data;
-        GF_VALIDATE_OR_GOTO ("gfapi", recall_lease, out);
-
-        INIT_LIST_HEAD(&glfd_list);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        gf_msg_debug (THIS->name, 0,
-                      "Recall lease received for gfid:%s",
-                      uuid_utoa(up_data->gfid));
-
-
-        inode = inode_find (subvol->itable, up_data->gfid);
-        if (!inode) {
-                ret = -1;
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INODE_FIND_FAILED,
-                        "Unable to find inode entry for gfid:%s graph id:%d",
-                        uuid_utoa(up_data->gfid), subvol->graph->id);
-                goto out;
+glfs_recall_lease_fd(struct glfs *fs, struct gf_upcall *up_data)
+{
+    struct gf_upcall_recall_lease *recall_lease = NULL;
+    xlator_t *subvol = NULL;
+    int ret = 0;
+    inode_t *inode = NULL;
+    struct glfs_fd *glfd = NULL;
+    struct glfs_fd *tmp = NULL;
+    struct list_head glfd_list = {
+        0,
+    };
+    fd_t *fd = NULL;
+    uint64_t value = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("gfapi", up_data, out);
+    GF_VALIDATE_OR_GOTO("gfapi", fs, out);
+
+    recall_lease = up_data->data;
+    GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out);
+
+    INIT_LIST_HEAD(&glfd_list);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s",
+                 uuid_utoa(up_data->gfid));
+
+    inode = inode_find(subvol->itable, up_data->gfid);
+    if (!inode) {
+        ret = -1;
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INODE_FIND_FAILED,
+               "Unable to find inode entry for gfid:%s graph id:%d",
+               uuid_utoa(up_data->gfid), subvol->graph->id);
+        goto out;
+    }
+
+    LOCK(&inode->lock);
+    {
+        list_for_each_entry(fd, &inode->fd_list, inode_list)
+        {
+            ret = fd_ctx_get(fd, subvol, &value);
+            glfd = (struct glfs_fd *)value;
+            if (glfd) {
+                gf_msg_trace(THIS->name, 0, "glfd (%p) has held lease", glfd);
+                GF_REF_GET(glfd);
+                list_add_tail(&glfd->list, &glfd_list);
+            }
         }
+    }
+    UNLOCK(&inode->lock);
 
-        LOCK (&inode->lock);
+    list_for_each_entry_safe(glfd, tmp, &glfd_list, list)
+    {
+        LOCK(&glfd->lock);
         {
-                list_for_each_entry (fd, &inode->fd_list, inode_list) {
-                        ret = fd_ctx_get (fd, subvol, &value);
-                        glfd = (struct glfs_fd *) value;
-                        if (glfd) {
-                                gf_msg_trace (THIS->name, 0,
-                                              "glfd (%p) has held lease", glfd);
-                                GF_REF_GET (glfd);
-                                list_add_tail (&glfd->list, &glfd_list);
-                        }
-                }
+            if (glfd->state != GLFD_CLOSE) {
+                gf_msg_trace(THIS->name, 0,
+                             "glfd (%p) has held lease, "
+                             "calling recall cbk",
+                             glfd);
+                glfd->cbk(lease, glfd->cookie);
+            }
         }
-        UNLOCK (&inode->lock);
-
-        list_for_each_entry_safe (glfd, tmp, &glfd_list, list) {
-                LOCK (&glfd->lock);
-                {
-                        if (glfd->state != GLFD_CLOSE) {
-                                gf_msg_trace (THIS->name, 0,
-                                              "glfd (%p) has held lease, "
-                                              "calling recall cbk", glfd);
-                                glfd->cbk (lease, glfd->cookie);
-                        }
-                }
-                UNLOCK (&glfd->lock);
+        UNLOCK(&glfd->lock);
 
-                list_del_init (&glfd->list);
-                GF_REF_PUT (glfd);
-        }
+        list_del_init(&glfd->list);
+        GF_REF_PUT(glfd);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfs_recall_lease_upcall (struct glfs *fs,
-                          struct glfs_upcall *up_arg,
-                          struct gf_upcall *up_data)
-{
-        struct gf_upcall_recall_lease *recall_lease = NULL;
-        struct glfs_object                  *object       = NULL;
-        xlator_t                      *subvol       = NULL;
-        int                            ret          = -1;
-        struct glfs_upcall_lease      *up_lease_arg = NULL;
-
-        GF_VALIDATE_OR_GOTO ("gfapi", up_data, out);
-        GF_VALIDATE_OR_GOTO ("gfapi", fs, out);
-
-        recall_lease = up_data->data;
-        GF_VALIDATE_OR_GOTO ("gfapi", recall_lease, out);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        gf_msg_debug (THIS->name, 0,
-                      "Recall lease received for gfid:%s",
-                      uuid_utoa(up_data->gfid));
-
-        object = glfs_h_find_handle (fs, up_data->gfid,
-                                     GFAPI_HANDLE_LENGTH);
-        if (!object) {
-                /* The reason handle creation will fail is because we
-                 * couldn't find the inode in the gfapi inode table.
-                 *
-                 * But since application would have taken inode_ref, the
-                 * only case when this can happen is when it has closed
-                 * the handle and hence will no more be interested in
-                 * the upcall for this particular gfid.
-                 */
-                gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_CREATE_HANDLE_FAILED,
-                        "handle creation of %s failed",
-                         uuid_utoa (up_data->gfid));
-                errno = ESTALE;
-                goto out;
-        }
-
-        up_lease_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_lease),
-                                  glfs_mt_upcall_inode_t);
-        up_lease_arg->object = object;
+glfs_recall_lease_upcall(struct glfs *fs, struct glfs_upcall *up_arg,
+                         struct gf_upcall *up_data)
+{
+    struct gf_upcall_recall_lease *recall_lease = NULL;
+    struct glfs_object *object = NULL;
+    xlator_t *subvol = NULL;
+    int ret = -1;
+    struct glfs_upcall_lease *up_lease_arg = NULL;
+
+    GF_VALIDATE_OR_GOTO("gfapi", up_data, out);
+    GF_VALIDATE_OR_GOTO("gfapi", fs, out);
+
+    recall_lease = up_data->data;
+    GF_VALIDATE_OR_GOTO("gfapi", recall_lease, out);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    gf_msg_debug(THIS->name, 0, "Recall lease received for gfid:%s",
+                 uuid_utoa(up_data->gfid));
+
+    object = glfs_h_find_handle(fs, up_data->gfid, GFAPI_HANDLE_LENGTH);
+    if (!object) {
+        /* The reason handle creation will fail is because we
+         * couldn't find the inode in the gfapi inode table.
+         *
+         * But since application would have taken inode_ref, the
+         * only case when this can happen is when it has closed
+         * the handle and hence will no more be interested in
+         * the upcall for this particular gfid.
+         */
+        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+               "handle creation of %s failed", uuid_utoa(up_data->gfid));
+        errno = ESTALE;
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("glfs_recall_lease",
-                             up_lease_arg, out);
+    up_lease_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_lease),
+                             glfs_mt_upcall_inode_t);
+    up_lease_arg->object = object;
 
+    GF_VALIDATE_OR_GOTO("glfs_recall_lease", up_lease_arg, out);
 
-        up_lease_arg->lease_type = recall_lease->lease_type;
+    up_lease_arg->lease_type = recall_lease->lease_type;
 
-        up_arg->reason = GF_UPCALL_RECALL_LEASE;
-        up_arg->event = up_lease_arg;
-        up_arg->free_event = glfs_free_upcall_lease;
+    up_arg->reason = GF_UPCALL_RECALL_LEASE;
+    up_arg->event = up_lease_arg;
+    up_arg->free_event = glfs_free_upcall_lease;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret) {
-                /* Close p_object and oldp_object as well if being referenced.*/
-                if (object)
-                        glfs_h_close (object);
+    if (ret) {
+        /* Close p_object and oldp_object as well if being referenced.*/
+        if (object)
+            glfs_h_close(object);
 
-                /* Set reason to prevent applications from using ->event */
-                up_arg->reason = GF_UPCALL_EVENT_NULL;
-        }
-        return ret;
+        /* Set reason to prevent applications from using ->event */
+        up_arg->reason = GF_UPCALL_EVENT_NULL;
+    }
+    return ret;
 }
 
 static void
-glfs_cbk_upcall_data (struct glfs *fs, struct gf_upcall *upcall_data)
+glfs_cbk_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
 {
-        int ret = -1;
-        struct glfs_upcall *up_arg = NULL;
+    int ret = -1;
+    struct glfs_upcall *up_arg = NULL;
 
-        if (!fs || !upcall_data)
-                goto out;
+    if (!fs || !upcall_data)
+        goto out;
 
-        if (!(fs->upcall_events & upcall_data->event_type)) {
-                /* ignore events which application hasn't registered*/
-                goto out;
-        }
+    if (!(fs->upcall_events & upcall_data->event_type)) {
+        /* ignore events which application hasn't registered*/
+        goto out;
+    }
 
-        up_arg = GLFS_CALLOC (1, sizeof (struct gf_upcall),
-                              glfs_release_upcall,
-                              glfs_mt_upcall_entry_t);
-        if (!up_arg) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-                        "Upcall entry allocation failed.");
-                goto out;
-        }
+    up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall), glfs_release_upcall,
+                         glfs_mt_upcall_entry_t);
+    if (!up_arg) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
+               "Upcall entry allocation failed.");
+        goto out;
+    }
 
-        switch (upcall_data->event_type) {
+    switch (upcall_data->event_type) {
         case GF_UPCALL_CACHE_INVALIDATION:
-                ret = glfs_h_poll_cache_invalidation (fs, up_arg, upcall_data);
-                break;
+            ret = glfs_h_poll_cache_invalidation(fs, up_arg, upcall_data);
+            break;
         case GF_UPCALL_RECALL_LEASE:
-                ret = glfs_recall_lease_upcall (fs, up_arg, upcall_data);
-                break;
+            ret = glfs_recall_lease_upcall(fs, up_arg, upcall_data);
+            break;
         default:
-                errno = EINVAL;
-        }
-
-        if (!ret && (up_arg->reason != GLFS_UPCALL_EVENT_NULL)) {
-                /* It could so happen that the file which got
-                 * upcall notification may have got deleted by
-                 * the same client. In such cases up_arg->reason
-                 * is set to GLFS_UPCALL_EVENT_NULL. No need to
-                 * send upcall then */
-                (fs->up_cbk) (up_arg, fs->up_data);
-        } else if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) {
-                gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall_EVENT_NULL received. Skipping it.");
-                goto out;
-        } else {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        API_MSG_INVALID_ENTRY,
-                        "Upcall entry validation failed.");
-                goto out;
-        }
-
-        /* application takes care of calling glfs_free on up_arg post
-         * their processing */
-        ret = 0;
+            errno = EINVAL;
+    }
+
+    if (!ret && (up_arg->reason != GLFS_UPCALL_EVENT_NULL)) {
+        /* It could so happen that the file which got
+         * upcall notification may have got deleted by
+         * the same client. In such cases up_arg->reason
+         * is set to GLFS_UPCALL_EVENT_NULL. No need to
+         * send upcall then */
+        (fs->up_cbk)(up_arg, fs->up_data);
+    } else if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) {
+        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_INVALID_ENTRY,
+               "Upcall_EVENT_NULL received. Skipping it.");
+        goto out;
+    } else {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY,
+               "Upcall entry validation failed.");
+        goto out;
+    }
+
+    /* application takes care of calling glfs_free on up_arg post
+     * their processing */
+    ret = 0;
 
 out:
-        if (ret && up_arg) {
-                GLFS_FREE (up_arg);
-        }
+    if (ret && up_arg) {
+        GLFS_FREE(up_arg);
+    }
 
-        return;
+    return;
 }
 
 /*
@@ -5317,251 +5363,254 @@ out:
  * to be read/polled by the applications.
  */
 void
-priv_glfs_process_upcall_event (struct glfs *fs, void *data)
+priv_glfs_process_upcall_event(struct glfs *fs, void *data)
 {
-        glusterfs_ctx_t    *ctx            = NULL;
-        struct gf_upcall   *upcall_data    = NULL;
-
-        DECLARE_OLD_THIS;
-
-        gf_msg_debug (THIS->name, 0,
-                      "Upcall gfapi callback is called");
+    glusterfs_ctx_t *ctx = NULL;
+    struct gf_upcall *upcall_data = NULL;
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, err);
+    DECLARE_OLD_THIS;
 
-        if (!data)
-                goto out;
-
-        /* Unlike in I/O path, "glfs_fini" would not have freed
-         * 'fs' by the time we take lock as it waits for all epoll
-         * threads to exit including this
-         */
-        pthread_mutex_lock (&fs->mutex);
-        {
-                ctx = fs->ctx;
-
-                /* if we're not interested in upcalls (anymore), skip them */
-                if (ctx->cleanup_started || !fs->cache_upcalls) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto out;
-                }
+    gf_msg_debug(THIS->name, 0, "Upcall gfapi callback is called");
 
-                fs->pin_refcnt++;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+    __GLFS_ENTRY_VALIDATE_FS(fs, err);
 
-        upcall_data = (struct gf_upcall *)data;
+    if (!data)
+        goto out;
 
-        gf_msg_trace (THIS->name, 0, "Upcall gfapi gfid = %s" ,
-                      (char *)(upcall_data->gfid));
+    /* Unlike in I/O path, "glfs_fini" would not have freed
+     * 'fs' by the time we take lock as it waits for all epoll
+     * threads to exit including this
+     */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        ctx = fs->ctx;
 
-        /* *
-         * TODO: RECALL LEASE for each glfd
-         *
-         * In case of RECALL_LEASE, we could associate separate
-         * cbk function for each glfd either by
-         * - extending pub_glfs_lease to accept new args (recall_cbk_fn, cookie)
-         * - or by defining new API "glfs_register_recall_cbk_fn (glfd, recall_cbk_fn, cookie)
-         * . In such cases, flag it and instead of calling below upcall functions, define
-         * a new one to go through the glfd list and invoke each of theirs recall_cbk_fn.
-         * */
-
-        if (fs->up_cbk) { /* upcall cbk registered */
-                (void) glfs_cbk_upcall_data (fs, upcall_data);
-        } else {
-                (void) glfs_enqueue_upcall_data (fs, upcall_data);
+        /* if we're not interested in upcalls (anymore), skip them */
+        if (ctx->cleanup_started || !fs->cache_upcalls) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto out;
         }
 
-        pthread_mutex_lock (&fs->mutex);
-        {
-                fs->pin_refcnt--;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+        fs->pin_refcnt++;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    upcall_data = (struct gf_upcall *)data;
+
+    gf_msg_trace(THIS->name, 0, "Upcall gfapi gfid = %s",
+                 (char *)(upcall_data->gfid));
+
+    /* *
+     * TODO: RECALL LEASE for each glfd
+     *
+     * In case of RECALL_LEASE, we could associate separate
+     * cbk function for each glfd either by
+     * - extending pub_glfs_lease to accept new args (recall_cbk_fn, cookie)
+     * - or by defining new API "glfs_register_recall_cbk_fn (glfd,
+     * recall_cbk_fn, cookie) . In such cases, flag it and instead of calling
+     * below upcall functions, define a new one to go through the glfd list and
+     * invoke each of theirs recall_cbk_fn.
+     * */
+
+    if (fs->up_cbk) { /* upcall cbk registered */
+        (void)glfs_cbk_upcall_data(fs, upcall_data);
+    } else {
+        (void)glfs_enqueue_upcall_data(fs, upcall_data);
+    }
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->pin_refcnt--;
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 err:
-        return;
+    return;
 }
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_process_upcall_event, 3.7.0);
 
 ssize_t
-glfs_anonymous_pwritev (struct glfs *fs, struct glfs_object *object,
-                        const struct iovec *iovec, int iovcnt,
-                        off_t offset, int flags)
-{
-        xlator_t        *subvol = NULL;
-        struct iobref   *iobref = NULL;
-        struct iobuf    *iobuf  = NULL;
-        struct iovec    iov     = {0, };
-        inode_t         *inode  = NULL;
-        fd_t            *fd     = NULL;
-        int             ret     = -1;
-        size_t          size    = -1;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
-
-        fd = fd_anonymous (inode);
-        if (!fd) {
-                ret = -1;
-                gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                errno = ENOMEM;
-                goto out;
-        }
-
-        size = iov_length (iovec, iovcnt);
-
-        iobuf = iobuf_get2 (subvol->ctx->iobuf_pool, size);
-        if (!iobuf) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                iobuf_unref (iobuf);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        ret = iobref_add (iobref, iobuf);
-        if (ret) {
-                iobuf_unref (iobuf);
-                iobref_unref (iobref);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        iov_unload (iobuf_ptr (iobuf), iovec, iovcnt);
-
-        iov.iov_base = iobuf_ptr (iobuf);
-        iov.iov_len = size;
-
-        /* TODO : set leaseid */
-        ret = syncop_writev (subvol, fd, &iov, 1, offset, iobref, flags,
-                             NULL, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        iobuf_unref (iobuf);
-        iobref_unref (iobref);
-
-        if (ret <= 0)
-                goto out;
+glfs_anonymous_pwritev(struct glfs *fs, struct glfs_object *object,
+                       const struct iovec *iovec, int iovcnt, off_t offset,
+                       int flags)
+{
+    xlator_t *subvol = NULL;
+    struct iobref *iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iovec iov = {
+        0,
+    };
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    int ret = -1;
+    size_t size = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    fd = fd_anonymous(inode);
+    if (!fd) {
+        ret = -1;
+        gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
+               "Allocating anonymous fd failed");
+        errno = ENOMEM;
+        goto out;
+    }
+
+    size = iov_length(iovec, iovcnt);
+
+    iobuf = iobuf_get2(subvol->ctx->iobuf_pool, size);
+    if (!iobuf) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    iobref = iobref_new();
+    if (!iobref) {
+        iobuf_unref(iobuf);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = iobref_add(iobref, iobuf);
+    if (ret) {
+        iobuf_unref(iobuf);
+        iobref_unref(iobref);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    iov_unload(iobuf_ptr(iobuf), iovec, iovcnt);
+
+    iov.iov_base = iobuf_ptr(iobuf);
+    iov.iov_len = size;
+
+    /* TODO : set leaseid */
+    ret = syncop_writev(subvol, fd, &iov, 1, offset, iobref, flags, NULL, NULL,
+                        NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    iobuf_unref(iobuf);
+    iobref_unref(iobref);
+
+    if (ret <= 0)
+        goto out;
 
 out:
 
-        if (fd)
-                fd_unref(fd);
+    if (fd)
+        fd_unref(fd);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 ssize_t
-glfs_anonymous_preadv (struct glfs *fs,  struct glfs_object *object,
-                       const struct iovec *iovec, int iovcnt,
-                       off_t offset, int flags)
-{
-        xlator_t        *subvol = NULL;
-        struct iovec    *iov    = NULL;
-        struct iobref   *iobref = NULL;
-        inode_t         *inode  = NULL;
-        fd_t            *fd     = NULL;
-        int             cnt     = 0;
-        ssize_t         ret     = -1;
-        ssize_t         size    = -1;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
-
-        fd = fd_anonymous (inode);
-        if (!fd) {
-                ret = -1;
-                gf_msg ("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-                        "Allocating anonymous fd failed");
-                errno = ENOMEM;
-                goto out;
-        }
-
-        size = iov_length (iovec, iovcnt);
-
-        /* TODO : set leaseid */
-	ret = syncop_readv (subvol, fd, size, offset, flags, &iov, &cnt,
-                            &iobref, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-        if (ret <= 0)
-                goto out;
-
-        size = iov_copy (iovec, iovcnt, iov, cnt);
-
-        ret = size;
+glfs_anonymous_preadv(struct glfs *fs, struct glfs_object *object,
+                      const struct iovec *iovec, int iovcnt, off_t offset,
+                      int flags)
+{
+    xlator_t *subvol = NULL;
+    struct iovec *iov = NULL;
+    struct iobref *iobref = NULL;
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    int cnt = 0;
+    ssize_t ret = -1;
+    ssize_t size = -1;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    fd = fd_anonymous(inode);
+    if (!fd) {
+        ret = -1;
+        gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
+               "Allocating anonymous fd failed");
+        errno = ENOMEM;
+        goto out;
+    }
+
+    size = iov_length(iovec, iovcnt);
+
+    /* TODO : set leaseid */
+    ret = syncop_readv(subvol, fd, size, offset, flags, &iov, &cnt, &iobref,
+                       NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret <= 0)
+        goto out;
+
+    size = iov_copy(iovec, iovcnt, iov, cnt);
+
+    ret = size;
 out:
-        if (iov)
-                GF_FREE (iov);
-        if (iobref)
-                iobref_unref (iobref);
-        if (fd)
-                fd_unref(fd);
+    if (iov)
+        GF_FREE(iov);
+    if (iobref)
+        iobref_unref(iobref);
+    if (fd)
+        fd_unref(fd);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
-static void glfs_release_xreaddirp_stat (void *ptr)
+static void
+glfs_release_xreaddirp_stat(void *ptr)
 {
-        struct glfs_xreaddirp_stat *to_free = ptr;
+    struct glfs_xreaddirp_stat *to_free = ptr;
 
-        if (to_free->object)
-                glfs_h_close (to_free->object);
+    if (to_free->object)
+        glfs_h_close(to_free->object);
 }
 
 /*
@@ -5569,253 +5618,248 @@ static void glfs_release_xreaddirp_stat (void *ptr)
  * xstat along with dirents.
  */
 int
-pub_glfs_xreaddirplus_r (struct glfs_fd *glfd, uint32_t flags,
-                         struct glfs_xreaddirp_stat **xstat_p,
-                         struct dirent *ext,
-                         struct dirent **res)
+pub_glfs_xreaddirplus_r(struct glfs_fd *glfd, uint32_t flags,
+                        struct glfs_xreaddirp_stat **xstat_p,
+                        struct dirent *ext, struct dirent **res)
 {
-        int              ret = -1;
-        gf_dirent_t     *entry = NULL;
-        struct dirent   *buf = NULL;
-        struct glfs_xreaddirp_stat *xstat = NULL;
+    int ret = -1;
+    gf_dirent_t *entry = NULL;
+    struct dirent *buf = NULL;
+    struct glfs_xreaddirp_stat *xstat = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
 
-        GF_REF_GET (glfd);
+    GF_REF_GET(glfd);
 
-        GF_VALIDATE_OR_GOTO (THIS->name, xstat_p, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, res, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, xstat_p, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, res, out);
 
-        errno = 0;
+    errno = 0;
 
-        if (ext)
-                buf = ext;
-        else
-                buf = glfs_readdirbuf_get (glfd);
+    if (ext)
+        buf = ext;
+    else
+        buf = glfs_readdirbuf_get(glfd);
 
-        if (!buf)
-                goto out;
+    if (!buf)
+        goto out;
 
-        xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
-                            glfs_release_xreaddirp_stat,
-                            glfs_mt_xreaddirp_stat_t);
+    xstat = GLFS_CALLOC(1, sizeof(struct glfs_xreaddirp_stat),
+                        glfs_release_xreaddirp_stat, glfs_mt_xreaddirp_stat_t);
 
-        if (!xstat)
-                goto out;
+    if (!xstat)
+        goto out;
 
-        /* this is readdirplus operation */
-        entry = glfd_entry_next (glfd, 1);
+    /* this is readdirplus operation */
+    entry = glfd_entry_next(glfd, 1);
 
-        /* XXX: Ideally when we reach EOD, errno should have been
-         * set to ENOENT. But that doesn't seem to be the case.
-         *
-         * The only way to confirm if its EOD at this point is that
-         * errno == 0 and entry == NULL
-         */
-        if (errno)
-                goto out;
-
-        if (!entry) {
-                /* reached EOD, ret = 0  */
-                ret = 0;
-                *res = NULL;
-                *xstat_p = NULL;
-
-                /* free xstat as applications shall not be using it */
-                GLFS_FREE (xstat);
-
-                goto out;
-        }
+    /* XXX: Ideally when we reach EOD, errno should have been
+     * set to ENOENT. But that doesn't seem to be the case.
+     *
+     * The only way to confirm if its EOD at this point is that
+     * errno == 0 and entry == NULL
+     */
+    if (errno)
+        goto out;
 
-        *res = buf;
-        gf_dirent_to_dirent (entry, buf);
-
-        if (flags & GFAPI_XREADDIRP_STAT) {
-                glfs_iatt_to_stat (glfd->fs, &entry->d_stat, &xstat->st);
-                xstat->flags_handled |= GFAPI_XREADDIRP_STAT;
-        }
-
-        if ((flags & GFAPI_XREADDIRP_HANDLE) &&
-                /* skip . and .. */
-                strcmp(buf->d_name, ".")
-                     && strcmp(buf->d_name, "..")) {
-
-                /* Now create object.
-                 * We can use "glfs_h_find_handle" as well as inodes would have
-                 * already got linked as part of 'gf_link_inodes_from_dirent' */
-                xstat->object = glfs_h_create_from_handle (glfd->fs,
-                                                        entry->d_stat.ia_gfid,
-                                                        GFAPI_HANDLE_LENGTH,
-                                                        NULL);
-
-                if (xstat->object) { /* success */
-                        /* note: xstat->object->inode->ref is taken
-                         * This shall be unref'ed when application does
-                         * glfs_free(xstat) */
-                        xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE;
-                }
+    if (!entry) {
+        /* reached EOD, ret = 0  */
+        ret = 0;
+        *res = NULL;
+        *xstat_p = NULL;
+
+        /* free xstat as applications shall not be using it */
+        GLFS_FREE(xstat);
+
+        goto out;
+    }
+
+    *res = buf;
+    gf_dirent_to_dirent(entry, buf);
+
+    if (flags & GFAPI_XREADDIRP_STAT) {
+        glfs_iatt_to_stat(glfd->fs, &entry->d_stat, &xstat->st);
+        xstat->flags_handled |= GFAPI_XREADDIRP_STAT;
+    }
+
+    if ((flags & GFAPI_XREADDIRP_HANDLE) &&
+        /* skip . and .. */
+        strcmp(buf->d_name, ".") && strcmp(buf->d_name, "..")) {
+        /* Now create object.
+         * We can use "glfs_h_find_handle" as well as inodes would have
+         * already got linked as part of 'gf_link_inodes_from_dirent' */
+        xstat->object = glfs_h_create_from_handle(
+            glfd->fs, entry->d_stat.ia_gfid, GFAPI_HANDLE_LENGTH, NULL);
+
+        if (xstat->object) { /* success */
+            /* note: xstat->object->inode->ref is taken
+             * This shall be unref'ed when application does
+             * glfs_free(xstat) */
+            xstat->flags_handled |= GFAPI_XREADDIRP_HANDLE;
         }
+    }
 
-        ret = xstat->flags_handled;
-        *xstat_p = xstat;
+    ret = xstat->flags_handled;
+    *xstat_p = xstat;
 
-        gf_msg_debug (THIS->name, 0,
-                      "xreaddirp- requested_flags (%x) , processed_flags (%x)",
-                      flags, xstat->flags_handled);
+    gf_msg_debug(THIS->name, 0,
+                 "xreaddirp- requested_flags (%x) , processed_flags (%x)",
+                 flags, xstat->flags_handled);
 
 out:
-        GF_REF_PUT (glfd);
+    GF_REF_PUT(glfd);
 
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        API_MSG_XREADDIRP_R_FAILED,
-                        "glfs_x_readdirp_r failed - reason (%s)",
-                        strerror(errno));
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED,
+               "glfs_x_readdirp_r failed - reason (%s)", strerror(errno));
 
-                if (xstat)
-                        GLFS_FREE (xstat);
-        }
+        if (xstat)
+            GLFS_FREE(xstat);
+    }
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        return ret;
+    return ret;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_r, 3.11.0);
 
-struct stat*
-pub_glfs_xreaddirplus_get_stat (struct glfs_xreaddirp_stat *xstat)
+struct stat *
+pub_glfs_xreaddirplus_get_stat(struct glfs_xreaddirp_stat *xstat)
 {
-        GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_stat", xstat, out);
+    GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_stat", xstat, out);
 
-        if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT)
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "GFAPI_XREADDIRP_STAT is not set. Flags"
-                        "handled for xstat(%p) are (%x)",
-                        xstat, xstat->flags_handled);
-        return &xstat->st;
+    if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT)
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
+               "GFAPI_XREADDIRP_STAT is not set. Flags"
+               "handled for xstat(%p) are (%x)",
+               xstat, xstat->flags_handled);
+    return &xstat->st;
 
 out:
-        return NULL;
+    return NULL;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_stat, 3.11.0);
 
 void
-gf_lease_to_glfs_lease (struct gf_lease *gf_lease, struct glfs_lease *lease)
+gf_lease_to_glfs_lease(struct gf_lease *gf_lease, struct glfs_lease *lease)
 {
-        lease->cmd = gf_lease->cmd;
-        lease->lease_type = gf_lease->lease_type;
-        memcpy (lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
+    lease->cmd = gf_lease->cmd;
+    lease->lease_type = gf_lease->lease_type;
+    memcpy(lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE);
 }
 
 void
-glfs_lease_to_gf_lease (struct glfs_lease *lease, struct gf_lease *gf_lease)
+glfs_lease_to_gf_lease(struct glfs_lease *lease, struct gf_lease *gf_lease)
 {
-        gf_lease->cmd = lease->cmd;
-        gf_lease->lease_type = lease->lease_type;
-        memcpy (gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE);
+    gf_lease->cmd = lease->cmd;
+    gf_lease->lease_type = lease->lease_type;
+    memcpy(gf_lease->lease_id, lease->lease_id, LEASE_ID_SIZE);
 }
 
 int
-pub_glfs_lease (struct glfs_fd *glfd, struct glfs_lease *lease,
-                glfs_recall_cbk fn, void *data)
-{
-        int              ret = -1;
-        loc_t            loc = {0, };
-        xlator_t        *subvol = NULL;
-        fd_t            *fd = NULL;
-        struct gf_lease  gf_lease = {0, };
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FD (glfd, invalid_fs);
-
-        GF_REF_GET (glfd);
-
-        if (!is_valid_lease_id (lease->lease_id)) {
+pub_glfs_lease(struct glfs_fd *glfd, struct glfs_lease *lease,
+               glfs_recall_cbk fn, void *data)
+{
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    xlator_t *subvol = NULL;
+    fd_t *fd = NULL;
+    struct gf_lease gf_lease = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FD(glfd, invalid_fs);
+
+    GF_REF_GET(glfd);
+
+    if (!is_valid_lease_id(lease->lease_id)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    subvol = glfs_active_subvol(glfd->fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    fd = glfs_resolve_fd(glfd->fs, subvol, glfd);
+    if (!fd) {
+        ret = -1;
+        errno = EBADFD;
+        goto out;
+    }
+
+    switch (lease->lease_type) {
+        case GLFS_RD_LEASE:
+            if ((fd->flags != O_RDONLY) && !(fd->flags & O_RDWR)) {
                 ret = -1;
                 errno = EINVAL;
                 goto out;
-        }
-
-        subvol = glfs_active_subvol (glfd->fs);
-        if (!subvol) {
+            }
+            break;
+        case GLFS_RW_LEASE:
+            if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) {
                 ret = -1;
-                errno = EIO;
+                errno = EINVAL;
                 goto out;
-        }
-
-        fd = glfs_resolve_fd (glfd->fs, subvol, glfd);
-        if (!fd) {
+            }
+            break;
+        default:
+            if (lease->cmd != GLFS_GET_LEASE) {
                 ret = -1;
-                errno = EBADFD;
+                errno = EINVAL;
                 goto out;
-        }
-
-        switch (lease->lease_type) {
-        case GLFS_RD_LEASE:
-                if ((fd->flags != O_RDONLY) && !(fd->flags & O_RDWR)) {
-                        ret = -1;
-                        errno = EINVAL;
-                        goto out;
-                }
-                break;
-        case GLFS_RW_LEASE:
-                if (!((fd->flags & O_WRONLY) || (fd->flags & O_RDWR))) {
-                        ret = -1;
-                        errno = EINVAL;
-                        goto out;
-                }
-                break;
-        default:
-                if (lease->cmd != GLFS_GET_LEASE) {
-                        ret = -1;
-                        errno = EINVAL;
-                        goto out;
-                }
-                break;
-        }
+            }
+            break;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (fd->inode, loc, out);
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(fd->inode, loc, out);
 
-        glfs_lease_to_gf_lease (lease, &gf_lease);
+    glfs_lease_to_gf_lease(lease, &gf_lease);
 
-        ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        gf_lease_to_glfs_lease (&gf_lease, lease);
+    gf_lease_to_glfs_lease(&gf_lease, lease);
 
-        /* TODO: Add leases for client replay
-        if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW))
-                fd_lk_insert_and_merge (fd, cmd, &saved_flock);
-        */
-        if (ret == 0) {
-                   ret = fd_ctx_set (glfd->fd, subvol, (uint64_t)(long)glfd);
-                   if (ret) {
-                           gf_msg (subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED,
-                                           "Setting fd ctx failed for fd(%p)", glfd->fd);
-                           goto out;
-                   }
-                   glfd->cbk = fn;
-                   glfd->cookie = data;
+    /* TODO: Add leases for client replay
+    if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW))
+            fd_lk_insert_and_merge (fd, cmd, &saved_flock);
+    */
+    if (ret == 0) {
+        ret = fd_ctx_set(glfd->fd, subvol, (uint64_t)(long)glfd);
+        if (ret) {
+            gf_msg(subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED,
+                   "Setting fd ctx failed for fd(%p)", glfd->fd);
+            goto out;
         }
+        glfd->cbk = fn;
+        glfd->cookie = data;
+    }
 
 out:
 
-        if (glfd)
-                GF_REF_PUT (glfd);
+    if (glfd)
+        GF_REF_PUT(glfd);
 
-        if (subvol)
-                glfs_subvol_done (glfd->fs, subvol);
+    if (subvol)
+        glfs_subvol_done(glfd->fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_lease, 4.0.0);
diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c
index 343fc384ddf..7e9f4c5c915 100644
--- a/api/src/glfs-handleops.c
+++ b/api/src/glfs-handleops.c
@@ -8,7 +8,6 @@
  *  cases as published by the Free Software Foundation.
  */
 
-
 #include "glfs-internal.h"
 #include "glfs-mem-types.h"
 #include "syncop.h"
@@ -17,1809 +16,1844 @@
 #include "gfapi-messages.h"
 
 int
-glfs_listxattr_process (void *value, size_t size, dict_t *xattr);
+glfs_listxattr_process(void *value, size_t size, dict_t *xattr);
 
 static void
-glfs_iatt_from_stat (struct stat *stat, int valid, struct iatt *iatt,
-                     int *glvalid)
+glfs_iatt_from_stat(struct stat *stat, int valid, struct iatt *iatt,
+                    int *glvalid)
 {
-        /* validate in args */
-        if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
-                errno = EINVAL;
-                return;
-        }
-
-        *glvalid = 0;
-
-        if (valid & GFAPI_SET_ATTR_MODE) {
-                iatt->ia_prot = ia_prot_from_st_mode (stat->st_mode);
-                *glvalid |= GF_SET_ATTR_MODE;
-        }
-
-        if (valid & GFAPI_SET_ATTR_UID) {
-                iatt->ia_uid = stat->st_uid;
-                *glvalid |= GF_SET_ATTR_UID;
-        }
-
-        if (valid & GFAPI_SET_ATTR_GID) {
-                iatt->ia_gid = stat->st_gid;
-                *glvalid |= GF_SET_ATTR_GID;
-        }
-
-        if (valid & GFAPI_SET_ATTR_ATIME) {
-                iatt->ia_atime = stat->st_atime;
-                iatt->ia_atime_nsec = ST_ATIM_NSEC (stat);
-                *glvalid |= GF_SET_ATTR_ATIME;
-        }
-
-        if (valid & GFAPI_SET_ATTR_MTIME) {
-                iatt->ia_mtime = stat->st_mtime;
-                iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat);
-                *glvalid |= GF_SET_ATTR_MTIME;
-        }
-
+    /* validate in args */
+    if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
+        errno = EINVAL;
         return;
+    }
+
+    *glvalid = 0;
+
+    if (valid & GFAPI_SET_ATTR_MODE) {
+        iatt->ia_prot = ia_prot_from_st_mode(stat->st_mode);
+        *glvalid |= GF_SET_ATTR_MODE;
+    }
+
+    if (valid & GFAPI_SET_ATTR_UID) {
+        iatt->ia_uid = stat->st_uid;
+        *glvalid |= GF_SET_ATTR_UID;
+    }
+
+    if (valid & GFAPI_SET_ATTR_GID) {
+        iatt->ia_gid = stat->st_gid;
+        *glvalid |= GF_SET_ATTR_GID;
+    }
+
+    if (valid & GFAPI_SET_ATTR_ATIME) {
+        iatt->ia_atime = stat->st_atime;
+        iatt->ia_atime_nsec = ST_ATIM_NSEC(stat);
+        *glvalid |= GF_SET_ATTR_ATIME;
+    }
+
+    if (valid & GFAPI_SET_ATTR_MTIME) {
+        iatt->ia_mtime = stat->st_mtime;
+        iatt->ia_mtime_nsec = ST_MTIM_NSEC(stat);
+        *glvalid |= GF_SET_ATTR_MTIME;
+    }
+
+    return;
 }
 
 struct glfs_object *
-pub_glfs_h_lookupat (struct glfs *fs, struct glfs_object *parent,
-                     const char *path, struct stat *stat, int follow)
+pub_glfs_h_lookupat(struct glfs *fs, struct glfs_object *parent,
+                    const char *path, struct stat *stat, int follow)
 {
-        int                      ret = 0;
-        xlator_t                *subvol = NULL;
-        inode_t                 *inode = NULL;
-        struct iatt              iatt = {0, };
-        struct glfs_object      *object = NULL;
-        loc_t                    loc = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if (path == NULL) {
-                errno = EINVAL;
-                return NULL;
-        }
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    struct glfs_object *object = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if (path == NULL) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        if (parent) {
-                inode = glfs_resolve_inode (fs, subvol, parent);
-                if (!inode) {
-                        errno = ESTALE;
-                        goto out;
-                }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    if (parent) {
+        inode = glfs_resolve_inode(fs, subvol, parent);
+        if (!inode) {
+            errno = ESTALE;
+            goto out;
         }
+    }
 
-        /* fop/op */
-        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, &iatt,
-                                    follow, 0);
+    /* fop/op */
+    ret = glfs_resolve_at(fs, subvol, inode, path, &loc, &iatt, follow, 0);
 
-        /* populate out args */
-        if (!ret) {
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+    /* populate out args */
+    if (!ret) {
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lookupat, 3.7.4);
 
 struct glfs_object *
-pub_glfs_h_lookupat34 (struct glfs *fs, struct glfs_object *parent,
-                       const char *path, struct stat *stat)
+pub_glfs_h_lookupat34(struct glfs *fs, struct glfs_object *parent,
+                      const char *path, struct stat *stat)
 {
-        return pub_glfs_h_lookupat (fs, parent, path, stat, 0);
+    return pub_glfs_h_lookupat(fs, parent, path, stat, 0);
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_h_lookupat34, glfs_h_lookupat, 3.4.2);
 
 int
-pub_glfs_h_statfs (struct glfs *fs, struct glfs_object *object,
-                   struct statvfs *statvfs)
+pub_glfs_h_statfs(struct glfs *fs, struct glfs_object *object,
+                  struct statvfs *statvfs)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL || statvfs == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL || statvfs == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    /* fop/op */
+    ret = syncop_statfs(subvol, &loc, statvfs, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* fop/op */
-        ret = syncop_statfs (subvol, &loc, statvfs, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
 out:
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_statfs, 3.7.0);
 
 int
-pub_glfs_h_stat (struct glfs *fs, struct glfs_object *object, struct stat *stat)
+pub_glfs_h_stat(struct glfs *fs, struct glfs_object *object, struct stat *stat)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_stat (subvol, &loc, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (!ret && stat) {
-                glfs_iatt_to_stat (fs, &iatt, stat);
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (!ret && stat) {
+        glfs_iatt_to_stat(fs, &iatt, stat);
+    }
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_stat, 3.4.2);
 
-
 int
-pub_glfs_h_getattrs (struct glfs *fs, struct glfs_object *object,
-                     struct stat *stat)
+pub_glfs_h_getattrs(struct glfs *fs, struct glfs_object *object,
+                    struct stat *stat)
 {
-        int                      ret = -1;
-        xlator_t                *subvol = NULL;
-        inode_t                 *inode = NULL;
-        struct iatt              iatt = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        ret = 0;
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                ret = 0;
-                errno = ESTALE;
-                goto out;
-        }
+    /* fop/op */
+    ret = glfs_resolve_base(fs, subvol, inode, &iatt);
 
-        /* fop/op */
-        ret = glfs_resolve_base (fs, subvol, inode, &iatt);
-
-        /* populate out args */
-        if (!ret && stat) {
-                glfs_iatt_to_stat (fs, &iatt, stat);
-        }
+    /* populate out args */
+    if (!ret && stat) {
+        glfs_iatt_to_stat(fs, &iatt, stat);
+    }
 
 out:
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getattrs, 3.4.2);
 
-
 int
-glfs_h_getxattrs_common (struct glfs *fs, struct glfs_object *object,
-                         dict_t **xattr, const char *name,
-                         gf_boolean_t is_listxattr)
+glfs_h_getxattrs_common(struct glfs *fs, struct glfs_object *object,
+                        dict_t **xattr, const char *name,
+                        gf_boolean_t is_listxattr)
 {
-        int                 ret = 0;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (!is_listxattr) {
-                if (!name || *name == '\0') {
-                        errno = EINVAL;
-                        return -1;
-                }
-
-                if (strlen(name) > GF_XATTR_NAME_MAX) {
-                        errno = ENAMETOOLONG;
-                        return -1;
-                }
-        }
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
+    if (!is_listxattr) {
+        if (!name || *name == '\0') {
+            errno = EINVAL;
+            return -1;
         }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        ret = syncop_getxattr (subvol, &loc, xattr, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+        if (strlen(name) > GF_XATTR_NAME_MAX) {
+            errno = ENAMETOOLONG;
+            return -1;
+        }
+    }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    ret = syncop_getxattr(subvol, &loc, xattr, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object,
-                      const char *name, void *value, size_t size)
+pub_glfs_h_getxattrs(struct glfs *fs, struct glfs_object *object,
+                     const char *name, void *value, size_t size)
 {
-        int                    ret   = -1;
-        dict_t                *xattr = NULL;
+    int ret = -1;
+    dict_t *xattr = NULL;
 
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        ret = glfs_h_getxattrs_common (fs, object, &xattr, name,
-                                       (name == NULL));
-        if (ret)
-                goto out;
+    ret = glfs_h_getxattrs_common(fs, object, &xattr, name, (name == NULL));
+    if (ret)
+        goto out;
 
-        /* If @name is NULL, means get all the xattrs (i.e listxattr). */
-        if (name)
-                ret = glfs_getxattr_process (value, size, xattr, name);
-        else
-                ret = glfs_listxattr_process (value, size, xattr);
+    /* If @name is NULL, means get all the xattrs (i.e listxattr). */
+    if (name)
+        ret = glfs_getxattr_process(value, size, xattr, name);
+    else
+        ret = glfs_listxattr_process(value, size, xattr);
 
 out:
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_getxattrs, 3.5.1);
 
 int
-pub_glfs_h_setattrs (struct glfs *fs, struct glfs_object *object,
-                     struct stat *stat, int valid)
+pub_glfs_h_setattrs(struct glfs *fs, struct glfs_object *object,
+                    struct stat *stat, int valid)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        struct iatt      iatt = {0, };
-        int              glvalid = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* map valid masks from in args */
-        glfs_iatt_from_stat (stat, valid, &iatt, &glvalid);
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    int glvalid = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* map valid masks from in args */
+    glfs_iatt_from_stat(stat, valid, &iatt, &glvalid);
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_setattr(subvol, &loc, &iatt, glvalid, 0, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setattrs, 3.4.2);
 
-
 int
-pub_glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object,
-                      const char *name, const void *value, size_t size,
-                      int flags)
+pub_glfs_h_setxattrs(struct glfs *fs, struct glfs_object *object,
+                     const char *name, const void *value, size_t size,
+                     int flags)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        dict_t          *xattr = NULL;
-        void            *value_cp = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) ||
-                 (name == NULL) || (value == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (!name || *name == '\0') {
-                errno = EINVAL;
-                return -1;
-        }
-
-        if (strlen(name) > GF_XATTR_NAME_MAX) {
-                errno = ENAMETOOLONG;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        value_cp = gf_memdup (value, size);
-        GF_CHECK_ALLOC_AND_LOG (subvol->name, value_cp, ret, "Failed to"
-                                " duplicate setxattr value", out);
-
-        xattr = dict_for_key_value (name, value_cp, size, _gf_false);
-        if (!xattr) {
-                GF_FREE (value_cp);
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    void *value_cp = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (name == NULL) || (value == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    if (!name || *name == '\0') {
+        errno = EINVAL;
+        return -1;
+    }
 
-        /* fop/op */
-        ret = syncop_setxattr (subvol, &loc, xattr, flags, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    if (strlen(name) > GF_XATTR_NAME_MAX) {
+        errno = ENAMETOOLONG;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    value_cp = gf_memdup(value, size);
+    GF_CHECK_ALLOC_AND_LOG(subvol->name, value_cp, ret,
+                           "Failed to"
+                           " duplicate setxattr value",
+                           out);
+
+    xattr = dict_for_key_value(name, value_cp, size, _gf_false);
+    if (!xattr) {
+        GF_FREE(value_cp);
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_setxattr(subvol, &loc, xattr, flags, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_setxattrs, 3.5.0);
 
-
 int
-pub_glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object,
-                         const char *name)
+pub_glfs_h_removexattrs(struct glfs *fs, struct glfs_object *object,
+                        const char *name)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL) || (name == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL) || (name == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_removexattr (subvol, &loc, name, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_removexattr(subvol, &loc, name, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_removexattrs, 3.5.1);
 
-
 struct glfs_fd *
-pub_glfs_h_open (struct glfs *fs, struct glfs_object *object, int flags)
+pub_glfs_h_open(struct glfs *fs, struct glfs_object *object, int flags)
 {
-        int              ret = -1;
-        struct glfs_fd  *glfd = NULL;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        dict_t          *fop_attr = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* check types to open */
-        if (IA_ISDIR (inode->ia_type)) {
-                ret = -1;
-                errno = EISDIR;
-                goto out;
-        }
-
-        if (!IA_ISREG (inode->ia_type)) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        glfd = glfs_fd_new (fs);
-        if (!glfd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        glfd->fd = fd_create (inode, getpid());
-        if (!glfd->fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-        glfd->fd->flags = flags;
-
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = get_fop_attr_thrd_key (&fop_attr);
-        if (ret)
-                gf_msg_debug ("gfapi", 0, "Getting leaseid from thread failed");
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *fop_attr = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* check types to open */
+    if (IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    if (!IA_ISREG(inode->ia_type)) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    glfd->fd = fd_create(inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    glfd->fd->flags = flags;
+
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = get_fop_attr_thrd_key(&fop_attr);
+    if (ret)
+        gf_msg_debug("gfapi", 0, "Getting leaseid from thread failed");
+
+    ret = syncop_open(subvol, &loc, flags, glfd->fd, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    glfd->fd->flags = flags;
 
-        ret = syncop_open (subvol, &loc, flags, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+out:
+    loc_wipe(&loc);
 
-        glfd->fd->flags = flags;
+    if (inode)
+        inode_unref(inode);
+    if (fop_attr)
+        dict_unref(fop_attr);
 
-out:
-        loc_wipe (&loc);
-
-        if (inode)
-                inode_unref (inode);
-        if (fop_attr)
-                dict_unref (fop_attr);
-
-        if (ret && glfd) {
-                GF_REF_PUT (glfd);
-                glfd = NULL;
-        } else if (glfd) {
-                glfd_set_state_bind (glfd);
-        }
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return glfd;
+    return glfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_open, 3.4.2);
 
-
 struct glfs_object *
-pub_glfs_h_creat (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  int flags, mode_t mode, struct stat *stat)
+pub_glfs_h_creat(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 int flags, mode_t mode, struct stat *stat)
 {
-        int                 ret = -1;
-        fd_t               *fd = NULL;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                ret = -1;
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-        fd = fd_create (loc.inode, getpid());
-        if (!fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    fd_t *fd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        ret = -1;
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    fd = fd_create(loc.inode, getpid());
+    if (!fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+    fd->flags = flags;
+
+    /* fop/op */
+    ret = syncop_create(subvol, &loc, flags, mode, fd, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
-        fd->flags = flags;
-
-        /* fop/op */
-        ret = syncop_create (subvol, &loc, flags, mode, fd, &iatt,
-                             xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
 
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        if (ret && object != NULL) {
-                /* Release the held reference */
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        /* Release the held reference */
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        if (fd)
-                fd_unref(fd);
+    if (fd)
+        fd_unref(fd);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_creat, 3.4.2);
 
-
 struct glfs_object *
-pub_glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  mode_t mode, struct stat *stat)
+pub_glfs_h_mkdir(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 mode_t mode, struct stat *stat)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    /* fop/op */
+    ret = syncop_mkdir(subvol, &loc, mode, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-        /* fop/op */
-        ret = syncop_mkdir (subvol, &loc, mode, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if ( ret == 0 )  {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
-
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        if (ret && object != NULL) {
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mkdir, 3.4.2);
 
-
 struct glfs_object *
-pub_glfs_h_mknod (struct glfs *fs, struct glfs_object *parent, const char *path,
-                  mode_t mode, dev_t dev, struct stat *stat)
+pub_glfs_h_mknod(struct glfs *fs, struct glfs_object *parent, const char *path,
+                 mode_t mode, dev_t dev, struct stat *stat)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, path);
+
+    /* fop/op */
+    ret = syncop_mknod(subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-        /* fop/op */
-        ret = syncop_mknod (subvol, &loc, mode, dev, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
-
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 out:
-        if (ret && object != NULL) {
-                glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_mknod, 3.4.2);
 
-
 int
-pub_glfs_h_unlink (struct glfs *fs, struct glfs_object *parent, const char *path)
+pub_glfs_h_unlink(struct glfs *fs, struct glfs_object *parent, const char *path)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if ( !subvol ) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, NULL, 0 , 0);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, inode, path, &loc, NULL, 0, 0);
+    if (ret != 0) {
+        goto out;
+    }
+
+    if (!IA_ISDIR(loc.inode->ia_type)) {
+        ret = syncop_unlink(subvol, &loc, NULL, NULL);
+        DECODE_SYNCOP_ERR(ret);
         if (ret != 0) {
-                goto out;
+            goto out;
         }
-
-        if (!IA_ISDIR(loc.inode->ia_type)) {
-                ret = syncop_unlink (subvol, &loc, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-                if (ret != 0) {
-                        goto out;
-                }
-        } else {
-                ret = syncop_rmdir (subvol, &loc, 0, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-                if (ret != 0) {
-                        goto out;
-                }
+    } else {
+        ret = syncop_rmdir(subvol, &loc, 0, NULL, NULL);
+        DECODE_SYNCOP_ERR(ret);
+        if (ret != 0) {
+            goto out;
         }
+    }
 
-        if (ret == 0)
-                ret = glfs_loc_unlink (&loc);
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_unlink, 3.4.2);
 
-
 struct glfs_fd *
-pub_glfs_h_opendir (struct glfs *fs, struct glfs_object *object)
+pub_glfs_h_opendir(struct glfs *fs, struct glfs_object *object)
 {
-        int              ret = -1;
-        struct glfs_fd  *glfd = NULL;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        if (!IA_ISDIR (inode->ia_type)) {
-                ret = -1;
-                errno = ENOTDIR;
-                goto out;
-        }
-
-        glfd = glfs_fd_new (fs);
-        if (!glfd)
-                goto out;
-
-        INIT_LIST_HEAD (&glfd->entries);
-
-        glfd->fd = fd_create (inode, getpid());
-        if (!glfd->fd) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        GLFS_LOC_FILL_INODE (inode, loc, out);
-
-        /* fop/op */
-        ret = syncop_opendir (subvol, &loc, glfd->fd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    int ret = -1;
+    struct glfs_fd *glfd = NULL;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    if (!IA_ISDIR(inode->ia_type)) {
+        ret = -1;
+        errno = ENOTDIR;
+        goto out;
+    }
+
+    glfd = glfs_fd_new(fs);
+    if (!glfd)
+        goto out;
+
+    INIT_LIST_HEAD(&glfd->entries);
+
+    glfd->fd = fd_create(inode, getpid());
+    if (!glfd->fd) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_INODE(inode, loc, out);
+
+    /* fop/op */
+    ret = syncop_opendir(subvol, &loc, glfd->fd, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (ret && glfd) {
-                GF_REF_PUT (glfd);
-                glfd = NULL;
-        } else if (glfd) {
-                glfd_set_state_bind (glfd);
-        }
+    if (ret && glfd) {
+        GF_REF_PUT(glfd);
+        glfd = NULL;
+    } else if (glfd) {
+        glfd_set_state_bind(glfd);
+    }
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return glfd;
+    return glfd;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_opendir, 3.4.2);
 
-
 int
-pub_glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask)
+pub_glfs_h_access(struct glfs *fs, struct glfs_object *object, int mask)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-
-	DECLARE_OLD_THIS;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return ret;
-	}
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return ret;
+    }
 
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-	GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-	/* fop/op */
+    /* fop/op */
 
-	ret = syncop_access (subvol, &loc, mask, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_access(subvol, &loc, mask, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-	loc_wipe (&loc);
-
-	if (inode)
-		inode_unref (inode);
+    loc_wipe(&loc);
 
+    if (inode)
+        inode_unref(inode);
 
-	glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_access, 3.6.0);
 
-
 ssize_t
-pub_glfs_h_extract_handle (struct glfs_object *object, unsigned char *handle,
-                           int len)
+pub_glfs_h_extract_handle(struct glfs_object *object, unsigned char *handle,
+                          int len)
 {
-        ssize_t ret = -1;
+    ssize_t ret = -1;
 
-        /* validate in args */
-        if (object == NULL) {
-                errno = EINVAL;
-                goto out;
-        }
+    /* validate in args */
+    if (object == NULL) {
+        errno = EINVAL;
+        goto out;
+    }
 
-        if (!handle || !len) {
-                ret = GFAPI_HANDLE_LENGTH;
-                goto out;
-        }
+    if (!handle || !len) {
+        ret = GFAPI_HANDLE_LENGTH;
+        goto out;
+    }
 
-        if (len < GFAPI_HANDLE_LENGTH)
-        {
-                errno = ERANGE;
-                goto out;
-        }
+    if (len < GFAPI_HANDLE_LENGTH) {
+        errno = ERANGE;
+        goto out;
+    }
 
-        memcpy (handle, object->gfid, GFAPI_HANDLE_LENGTH);
+    memcpy(handle, object->gfid, GFAPI_HANDLE_LENGTH);
 
-        ret = GFAPI_HANDLE_LENGTH;
+    ret = GFAPI_HANDLE_LENGTH;
 
 out:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_extract_handle, 3.4.2);
 
-
 struct glfs_object *
-pub_glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len,
-                               struct stat *stat)
+pub_glfs_h_create_from_handle(struct glfs *fs, unsigned char *handle, int len,
+                              struct stat *stat)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        struct iatt         iatt = {0, };
-        inode_t            *newinode = NULL;
-        xlator_t           *subvol = NULL;
-        struct glfs_object *object = NULL;
-        uint64_t            ctx_value = LOOKUP_NOT_NEEDED;
-        gf_boolean_t        lookup_needed = _gf_false;
-
-        /* validate in args */
-        if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
-                errno = EINVAL;
-                return NULL;
-        }
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *newinode = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs_object *object = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+    gf_boolean_t lookup_needed = _gf_false;
+
+    /* validate in args */
+    if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH);
-
-        /* make sure the gfid received is valid */
-        GF_VALIDATE_OR_GOTO ("glfs_h_create_from_handle",
-                             !(gf_uuid_is_null (loc.gfid)), out);
-
-        newinode = inode_find (subvol->itable, loc.gfid);
-        if (newinode) {
-                if (!stat)  /* No need of lookup */
-                        goto found;
-
-                lookup_needed = inode_needs_lookup (newinode, THIS);
-                if (lookup_needed) {
-                        loc.inode = newinode;
-                } else {
-                        /* populate loc */
-                        GLFS_LOC_FILL_INODE (newinode, loc, fill_out);
-
-                        /* fop/op */
-                        ret = syncop_stat (subvol, &loc, &iatt, NULL, NULL);
-                        DECODE_SYNCOP_ERR (ret);
-
-                        if (ret) {
-fill_out:
-                                /* Drop the reference hold in inode_find */
-                                inode_unref (newinode);
-                                goto out;
-                        }
-
-                        glfs_iatt_to_stat (fs, &iatt, stat);
-                        goto found;
-                }
-        } else {
-                loc.inode = inode_new (subvol->itable);
-                if (!loc.inode) {
-                        errno = ENOMEM;
-                        goto out;
-                }
-        }
+    memcpy(loc.gfid, handle, GFAPI_HANDLE_LENGTH);
 
-        ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
-        if (ret) {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-                        "inode refresh of %s failed: %s",
-                        uuid_utoa (loc.gfid), strerror (errno));
-                goto out;
-        }
+    /* make sure the gfid received is valid */
+    GF_VALIDATE_OR_GOTO("glfs_h_create_from_handle",
+                        !(gf_uuid_is_null(loc.gfid)), out);
 
-        newinode = inode_link (loc.inode, 0, 0, &iatt);
-        if (newinode) {
-                if (newinode == loc.inode) {
-                        inode_ctx_set (newinode, THIS, &ctx_value);
-                }
-                inode_lookup (newinode);
-        } else {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed", uuid_utoa (loc.gfid));
-                goto out;
-        }
+    newinode = inode_find(subvol->itable, loc.gfid);
+    if (newinode) {
+        if (!stat) /* No need of lookup */
+            goto found;
 
-        /* populate stat */
-        if (stat)
-                glfs_iatt_to_stat (fs, &iatt, stat);
+        lookup_needed = inode_needs_lookup(newinode, THIS);
+        if (lookup_needed) {
+            loc.inode = newinode;
+        } else {
+            /* populate loc */
+            GLFS_LOC_FILL_INODE(newinode, loc, fill_out);
+
+            /* fop/op */
+            ret = syncop_stat(subvol, &loc, &iatt, NULL, NULL);
+            DECODE_SYNCOP_ERR(ret);
+
+            if (ret) {
+            fill_out:
+                /* Drop the reference hold in inode_find */
+                inode_unref(newinode);
+                goto out;
+            }
+
+            glfs_iatt_to_stat(fs, &iatt, stat);
+            goto found;
+        }
+    } else {
+        loc.inode = inode_new(subvol->itable);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret) {
+        gf_msg(subvol->name, GF_LOG_WARNING, errno,
+               API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s",
+               uuid_utoa(loc.gfid), strerror(errno));
+        goto out;
+    }
+
+    newinode = inode_link(loc.inode, 0, 0, &iatt);
+    if (newinode) {
+        if (newinode == loc.inode) {
+            inode_ctx_set(newinode, THIS, &ctx_value);
+        }
+        inode_lookup(newinode);
+    } else {
+        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+               "inode linking of %s failed", uuid_utoa(loc.gfid));
+        goto out;
+    }
+
+    /* populate stat */
+    if (stat)
+        glfs_iatt_to_stat(fs, &iatt, stat);
 
 found:
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-        /* populate the return object */
-        object->inode = newinode;
-        gf_uuid_copy (object->gfid, object->inode->gfid);
+    /* populate the return object */
+    object->inode = newinode;
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
 out:
-        /* TODO: Check where the inode ref is being held? */
-        loc_wipe (&loc);
+    /* TODO: Check where the inode ref is being held? */
+    loc_wipe(&loc);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_create_from_handle, 3.4.2);
 
-
 int
-pub_glfs_h_close (struct glfs_object *object)
+pub_glfs_h_close(struct glfs_object *object)
 {
-        /* since glfs_h_* objects hold a reference to inode
-         * it is safe to keep lookup count to '0' */
-        inode_forget (object->inode, 0);
-        inode_unref (object->inode);
-        GF_FREE (object);
+    /* since glfs_h_* objects hold a reference to inode
+     * it is safe to keep lookup count to '0' */
+    inode_forget(object->inode, 0);
+    inode_unref(object->inode);
+    GF_FREE(object);
 
-        return 0;
+    return 0;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_close, 3.4.2);
 
-
 int
-pub_glfs_h_truncate (struct glfs *fs, struct glfs_object *object, off_t offset)
+pub_glfs_h_truncate(struct glfs *fs, struct glfs_object *object, off_t offset)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if (object == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* validate in args */
-        if (object == NULL) {
-                errno = EINVAL;
-                return -1;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_truncate (subvol, &loc, (off_t)offset, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_truncate(subvol, &loc, (off_t)offset, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* populate out args */
-        if (ret == 0)
-                ret = glfs_loc_unlink (&loc);
+    /* populate out args */
+    if (ret == 0)
+        ret = glfs_loc_unlink(&loc);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_truncate, 3.4.2);
 
-
 struct glfs_object *
-pub_glfs_h_symlink (struct glfs *fs, struct glfs_object *parent,
-                    const char *name, const char *data, struct stat *stat)
+pub_glfs_h_symlink(struct glfs *fs, struct glfs_object *parent,
+                   const char *name, const char *data, struct stat *stat)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        loc_t               loc = {0, };
-        struct iatt         iatt = {0, };
-        uuid_t              gfid;
-        dict_t             *xattr_req = NULL;
-        struct glfs_object *object = NULL;
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((parent == NULL) || (name == NULL) ||
-                (data == NULL)) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, parent);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        gf_uuid_generate (gfid);
-        ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    struct glfs_object *object = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((parent == NULL) || (name == NULL) || (data == NULL)) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, parent);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_generate(gfid);
+    ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_PINODE(inode, loc, ret, errno, out, name);
+
+    /* fop/op */
+    ret = syncop_symlink(subvol, &loc, data, &iatt, xattr_req, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    /* populate out args */
+    if (ret == 0) {
+        ret = glfs_loc_link(&loc, &iatt);
+        if (ret != 0) {
+            goto out;
         }
 
-        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, name);
-
-        /* fop/op */
-        ret = syncop_symlink (subvol, &loc, data, &iatt, xattr_req, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        /* populate out args */
-        if (ret == 0) {
-                ret = glfs_loc_link (&loc, &iatt);
-                if (ret != 0) {
-                        goto out;
-                }
-
-                if (stat)
-                        glfs_iatt_to_stat (fs, &iatt, stat);
+        if (stat)
+            glfs_iatt_to_stat(fs, &iatt, stat);
 
-                ret = glfs_create_object (&loc, &object);
-        }
+        ret = glfs_create_object(&loc, &object);
+    }
 
 out:
-        if (ret && object != NULL) {
-                pub_glfs_h_close (object);
-                object = NULL;
-        }
+    if (ret && object != NULL) {
+        pub_glfs_h_close(object);
+        object = NULL;
+    }
 
-        loc_wipe(&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
+    return object;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_symlink, 3.4.2);
 
-
 int
-pub_glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf,
-                     size_t bufsiz)
+pub_glfs_h_readlink(struct glfs *fs, struct glfs_object *object, char *buf,
+                    size_t bufsiz)
 {
-        loc_t               loc = {0, };
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        char               *linkval = NULL;
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((object == NULL) || (buf == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    char *linkval = NULL;
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((object == NULL) || (buf == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        /* fop/op */
-        ret = syncop_readlink (subvol, &loc, &linkval, bufsiz, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    /* fop/op */
+    ret = syncop_readlink(subvol, &loc, &linkval, bufsiz, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        /* populate out args */
-        if (ret > 0)
-                memcpy (buf, linkval, ret);
+    /* populate out args */
+    if (ret > 0)
+        memcpy(buf, linkval, ret);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (linkval)
-                GF_FREE (linkval);
+    if (linkval)
+        GF_FREE(linkval);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_readlink, 3.4.2);
 
-
 int
-pub_glfs_h_link (struct glfs *fs, struct glfs_object *linksrc,
-             struct glfs_object *parent, const char *name)
+pub_glfs_h_link(struct glfs *fs, struct glfs_object *linksrc,
+                struct glfs_object *parent, const char *name)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *inode = NULL;
-        inode_t            *pinode = NULL;
-        loc_t               oldloc = {0, };
-        loc_t               newloc = {0, };
-        struct iatt         iatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((linksrc == NULL) || (parent == NULL) ||
-                (name == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, linksrc);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        if (inode->ia_type == IA_IFDIR) {
-                ret = -1;
-                errno = EISDIR;
-                goto out;
-        }
-
-        GLFS_LOC_FILL_INODE (inode, oldloc, out);
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        pinode = glfs_resolve_inode (fs, subvol, parent);
-        if (!pinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        /* setup newloc based on parent */
-        newloc.parent = inode_ref (pinode);
-        newloc.name = name;
-        ret = glfs_loc_touchup (&newloc);
-        if (ret != 0) {
-                errno = EINVAL;
-                goto out;
-        }
-
-        /* Filling the inode of the hard link to be same as that of the
-         * original file
-         */
-        newloc.inode = inode_ref (inode);
-
-        /* fop/op */
-        ret = syncop_link (subvol, &oldloc, &newloc, &iatt, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret == 0)
-                ret = glfs_loc_link (&newloc, &iatt);
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    inode_t *pinode = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((linksrc == NULL) || (parent == NULL) || (name == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, linksrc);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    if (inode->ia_type == IA_IFDIR) {
+        ret = -1;
+        errno = EISDIR;
+        goto out;
+    }
+
+    GLFS_LOC_FILL_INODE(inode, oldloc, out);
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    pinode = glfs_resolve_inode(fs, subvol, parent);
+    if (!pinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    /* setup newloc based on parent */
+    newloc.parent = inode_ref(pinode);
+    newloc.name = name;
+    ret = glfs_loc_touchup(&newloc);
+    if (ret != 0) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    /* Filling the inode of the hard link to be same as that of the
+     * original file
+     */
+    newloc.inode = inode_ref(inode);
+
+    /* fop/op */
+    ret = syncop_link(subvol, &oldloc, &newloc, &iatt, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0)
+        ret = glfs_loc_link(&newloc, &iatt);
 out:
-        loc_wipe (&oldloc);
-        loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        if (pinode)
-                inode_unref (pinode);
+    if (pinode)
+        inode_unref(pinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_link, 3.4.2);
 
-
 int
-pub_glfs_h_rename (struct glfs *fs, struct glfs_object *olddir,
-                   const char *oldname, struct glfs_object *newdir,
-                   const char *newname)
+pub_glfs_h_rename(struct glfs *fs, struct glfs_object *olddir,
+                  const char *oldname, struct glfs_object *newdir,
+                  const char *newname)
 {
-        int                 ret = -1;
-        xlator_t           *subvol = NULL;
-        inode_t            *oldpinode = NULL;
-        inode_t            *newpinode = NULL;
-        loc_t               oldloc = {0, };
-        loc_t               newloc = {0, };
-        struct iatt         oldiatt = {0, };
-        struct iatt         newiatt = {0, };
-
-        DECLARE_OLD_THIS;
-
-        /* validate in args */
-        if ((olddir == NULL) || (oldname == NULL) ||
-                (newdir == NULL) || (newname == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if ( !subvol ) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        oldpinode = glfs_resolve_inode (fs, subvol, olddir);
-        if (!oldpinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, oldpinode, oldname, &oldloc,
-                                    &oldiatt, 0 , 0);
-        if (ret != 0) {
-                goto out;
-        }
-
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        newpinode = glfs_resolve_inode (fs, subvol, newdir);
-        if (!newpinode) {
-                errno = ESTALE;
-                goto out;
-        }
-
-        ret = glfs_resolve_at (fs, subvol, newpinode, newname, &newloc,
-                                    &newiatt, 0, 0);
-
-        if (ret && errno != ENOENT && newloc.parent)
-                goto out;
-
-        if (newiatt.ia_type != IA_INVAL) {
-                if ((oldiatt.ia_type == IA_IFDIR) !=
-                        (newiatt.ia_type == IA_IFDIR)) {
-                        /* Either both old and new must be dirs,
-                         * or both must be non-dirs. Else, fail.
-                         */
-                        ret = -1;
-                        errno = EEXIST;
-                        goto out;
-                }
-        }
-
-        /* TODO: check if new or old is a prefix of the other, and fail EINVAL */
-
-        ret = syncop_rename (subvol, &oldloc, &newloc, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-        if (ret == 0) {
-                inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
-                              newloc.parent, newloc.name, oldloc.inode,
-                              &oldiatt);
-
-                if (newloc.inode && !inode_has_dentry (newloc.inode))
-                        inode_forget (newloc.inode, 0);
-
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *oldpinode = NULL;
+    inode_t *newpinode = NULL;
+    loc_t oldloc = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+    struct iatt oldiatt = {
+        0,
+    };
+    struct iatt newiatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+
+    /* validate in args */
+    if ((olddir == NULL) || (oldname == NULL) || (newdir == NULL) ||
+        (newname == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    oldpinode = glfs_resolve_inode(fs, subvol, olddir);
+    if (!oldpinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, oldpinode, oldname, &oldloc, &oldiatt, 0,
+                          0);
+    if (ret != 0) {
+        goto out;
+    }
+
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    newpinode = glfs_resolve_inode(fs, subvol, newdir);
+    if (!newpinode) {
+        errno = ESTALE;
+        goto out;
+    }
+
+    ret = glfs_resolve_at(fs, subvol, newpinode, newname, &newloc, &newiatt, 0,
+                          0);
+
+    if (ret && errno != ENOENT && newloc.parent)
+        goto out;
+
+    if (newiatt.ia_type != IA_INVAL) {
+        if ((oldiatt.ia_type == IA_IFDIR) != (newiatt.ia_type == IA_IFDIR)) {
+            /* Either both old and new must be dirs,
+             * or both must be non-dirs. Else, fail.
+             */
+            ret = -1;
+            errno = EEXIST;
+            goto out;
+        }
+    }
+
+    /* TODO: check if new or old is a prefix of the other, and fail EINVAL */
+
+    ret = syncop_rename(subvol, &oldloc, &newloc, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret == 0) {
+        inode_rename(oldloc.parent->table, oldloc.parent, oldloc.name,
+                     newloc.parent, newloc.name, oldloc.inode, &oldiatt);
+
+        if (newloc.inode && !inode_has_dentry(newloc.inode))
+            inode_forget(newloc.inode, 0);
+    }
 
 out:
-        loc_wipe (&oldloc);
-        loc_wipe (&newloc);
+    loc_wipe(&oldloc);
+    loc_wipe(&newloc);
 
-        if (oldpinode)
-                inode_unref (oldpinode);
+    if (oldpinode)
+        inode_unref(oldpinode);
 
-        if (newpinode)
-                inode_unref (newpinode);
+    if (newpinode)
+        inode_unref(newpinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2);
@@ -1829,199 +1863,186 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_rename, 3.4.2);
  * the inode table. If yes create and return the corresponding glfs_object.
  */
 struct glfs_object *
-glfs_h_find_handle (struct glfs *fs, unsigned char *handle, int len)
+glfs_h_find_handle(struct glfs *fs, unsigned char *handle, int len)
 {
-        inode_t            *newinode = NULL;
-        xlator_t           *subvol = NULL;
-        struct glfs_object *object = NULL;
-        uuid_t gfid;
-
-        /* validate in args */
-        if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
-                errno = EINVAL;
-                return NULL;
-        }
+    inode_t *newinode = NULL;
+    xlator_t *subvol = NULL;
+    struct glfs_object *object = NULL;
+    uuid_t gfid;
+
+    /* validate in args */
+    if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto out;
+    }
 
-        memcpy (gfid, handle, GFAPI_HANDLE_LENGTH);
+    memcpy(gfid, handle, GFAPI_HANDLE_LENGTH);
 
-        /* make sure the gfid received is valid */
-        GF_VALIDATE_OR_GOTO ("glfs_h_find_handle",
-                             !(gf_uuid_is_null (gfid)), out);
+    /* make sure the gfid received is valid */
+    GF_VALIDATE_OR_GOTO("glfs_h_find_handle", !(gf_uuid_is_null(gfid)), out);
 
-        newinode = inode_find (subvol->itable, gfid);
-        if (!newinode) {
-                goto out;
-        }
+    newinode = inode_find(subvol->itable, gfid);
+    if (!newinode) {
+        goto out;
+    }
 
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                goto out;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        goto out;
+    }
 
-        /* populate the return object. The ref taken here
-         * is un'refed when the application does glfs_h_close() */
-        object->inode = inode_ref(newinode);
-        gf_uuid_copy (object->gfid, object->inode->gfid);
+    /* populate the return object. The ref taken here
+     * is un'refed when the application does glfs_h_close() */
+    object->inode = inode_ref(newinode);
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
 out:
-        /* inode_find takes a reference. Unref it. */
-        if (newinode)
-                inode_unref (newinode);
+    /* inode_find takes a reference. Unref it. */
+    if (newinode)
+        inode_unref(newinode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return object;
-
+    return object;
 }
 
 static void
-glfs_free_upcall_inode (void *to_free)
+glfs_free_upcall_inode(void *to_free)
 {
-        struct glfs_upcall_inode *arg = to_free;
+    struct glfs_upcall_inode *arg = to_free;
 
-        if (!arg)
-                return;
+    if (!arg)
+        return;
 
-        if (arg->object)
-                glfs_h_close (arg->object);
-        if (arg->p_object)
-                glfs_h_close (arg->p_object);
-        if (arg->oldp_object)
-                glfs_h_close (arg->oldp_object);
+    if (arg->object)
+        glfs_h_close(arg->object);
+    if (arg->p_object)
+        glfs_h_close(arg->p_object);
+    if (arg->oldp_object)
+        glfs_h_close(arg->oldp_object);
 
-        GF_FREE (arg);
+    GF_FREE(arg);
 }
 
 int
-glfs_h_poll_cache_invalidation (struct glfs *fs,
-                                struct glfs_upcall *up_arg,
-                                struct gf_upcall *upcall_data)
+glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
+                               struct gf_upcall *upcall_data)
 {
-        int                                 ret           = -1;
-        struct glfs_object                  *p_object     = NULL;
-        struct glfs_object                  *oldp_object  = NULL;
-        struct glfs_object                  *object       = NULL;
-        struct gf_upcall_cache_invalidation *ca_data      = NULL;
-        struct glfs_upcall_inode            *up_inode_arg = NULL;
-
-        ca_data = upcall_data->data;
-        GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation",
-                             ca_data, out);
-
-        object = glfs_h_find_handle (fs, upcall_data->gfid,
-                                     GFAPI_HANDLE_LENGTH);
-        if (!object) {
-                /* The reason handle creation will fail is because we
-                 * couldn't find the inode in the gfapi inode table.
-                 *
-                 * But since application would have taken inode_ref, the
-                 * only case when this can happen is when it has closed
-                 * the handle and hence will no more be interested in
-                 * the upcall for this particular gfid.
-                 */
-                gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                        API_MSG_CREATE_HANDLE_FAILED,
-                        "handle creation of %s failed",
-                         uuid_utoa (upcall_data->gfid));
-                errno = ESTALE;
-                goto out;
-        }
-
-        up_inode_arg = GF_CALLOC (1, sizeof (struct glfs_upcall_inode),
-                                  glfs_mt_upcall_inode_t);
-        GF_VALIDATE_OR_GOTO ("glfs_h_poll_cache_invalidation",
-                             up_inode_arg, out);
-
-        up_inode_arg->object = object;
-        up_inode_arg->flags = ca_data->flags;
-        up_inode_arg->expire_time_attr = ca_data->expire_time_attr;
-
-        /* XXX: Update stat as well in case of UP_*_TIMES.
-         * This will be addressed as part of INODE_UPDATE */
-        if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) {
-                glfs_iatt_to_stat (fs, &ca_data->stat, &up_inode_arg->buf);
-        }
-
-        if (ca_data->flags & GFAPI_UP_PARENT_TIMES) {
-                p_object = glfs_h_find_handle (fs,
-                                               ca_data->p_stat.ia_gfid,
-                                               GFAPI_HANDLE_LENGTH);
-                if (!p_object) {
-                        gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                                API_MSG_CREATE_HANDLE_FAILED,
-                                "handle creation of %s failed",
-                                 uuid_utoa (ca_data->p_stat.ia_gfid));
-                        errno = ESTALE;
-                        goto out;
-                }
-
-                glfs_iatt_to_stat (fs, &ca_data->p_stat, &up_inode_arg->p_buf);
-        }
-        up_inode_arg->p_object = p_object;
-
-        /* In case of RENAME, update old parent as well */
-        if (ca_data->flags & GFAPI_UP_RENAME) {
-                oldp_object = glfs_h_find_handle (fs,
-                                                  ca_data->oldp_stat.ia_gfid,
-                                                  GFAPI_HANDLE_LENGTH);
-                if (!oldp_object) {
-                        gf_msg (THIS->name, GF_LOG_DEBUG, errno,
-                                API_MSG_CREATE_HANDLE_FAILED,
-                                "handle creation of %s failed",
-                                 uuid_utoa (ca_data->oldp_stat.ia_gfid));
-                        errno = ESTALE;
-                        /* By the time we receive upcall old parent_dir may
-                         * have got removed. We still need to send upcall
-                         * for the file/dir and current parent handles. */
-                        up_inode_arg->oldp_object = NULL;
-                        ret = 0;
-                }
-
-                glfs_iatt_to_stat (fs, &ca_data->oldp_stat,
-                                   &up_inode_arg->oldp_buf);
-        }
-        up_inode_arg->oldp_object = oldp_object;
-
-        up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE;
-        up_arg->event = up_inode_arg;
-        up_arg->free_event = glfs_free_upcall_inode;
-
-        ret = 0;
+    int ret = -1;
+    struct glfs_object *p_object = NULL;
+    struct glfs_object *oldp_object = NULL;
+    struct glfs_object *object = NULL;
+    struct gf_upcall_cache_invalidation *ca_data = NULL;
+    struct glfs_upcall_inode *up_inode_arg = NULL;
+
+    ca_data = upcall_data->data;
+    GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", ca_data, out);
+
+    object = glfs_h_find_handle(fs, upcall_data->gfid, GFAPI_HANDLE_LENGTH);
+    if (!object) {
+        /* The reason handle creation will fail is because we
+         * couldn't find the inode in the gfapi inode table.
+         *
+         * But since application would have taken inode_ref, the
+         * only case when this can happen is when it has closed
+         * the handle and hence will no more be interested in
+         * the upcall for this particular gfid.
+         */
+        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+               "handle creation of %s failed", uuid_utoa(upcall_data->gfid));
+        errno = ESTALE;
+        goto out;
+    }
+
+    up_inode_arg = GF_CALLOC(1, sizeof(struct glfs_upcall_inode),
+                             glfs_mt_upcall_inode_t);
+    GF_VALIDATE_OR_GOTO("glfs_h_poll_cache_invalidation", up_inode_arg, out);
+
+    up_inode_arg->object = object;
+    up_inode_arg->flags = ca_data->flags;
+    up_inode_arg->expire_time_attr = ca_data->expire_time_attr;
+
+    /* XXX: Update stat as well in case of UP_*_TIMES.
+     * This will be addressed as part of INODE_UPDATE */
+    if (ca_data->flags & GFAPI_INODE_UPDATE_FLAGS) {
+        glfs_iatt_to_stat(fs, &ca_data->stat, &up_inode_arg->buf);
+    }
+
+    if (ca_data->flags & GFAPI_UP_PARENT_TIMES) {
+        p_object = glfs_h_find_handle(fs, ca_data->p_stat.ia_gfid,
+                                      GFAPI_HANDLE_LENGTH);
+        if (!p_object) {
+            gf_msg(THIS->name, GF_LOG_DEBUG, errno,
+                   API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed",
+                   uuid_utoa(ca_data->p_stat.ia_gfid));
+            errno = ESTALE;
+            goto out;
+        }
+
+        glfs_iatt_to_stat(fs, &ca_data->p_stat, &up_inode_arg->p_buf);
+    }
+    up_inode_arg->p_object = p_object;
+
+    /* In case of RENAME, update old parent as well */
+    if (ca_data->flags & GFAPI_UP_RENAME) {
+        oldp_object = glfs_h_find_handle(fs, ca_data->oldp_stat.ia_gfid,
+                                         GFAPI_HANDLE_LENGTH);
+        if (!oldp_object) {
+            gf_msg(THIS->name, GF_LOG_DEBUG, errno,
+                   API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed",
+                   uuid_utoa(ca_data->oldp_stat.ia_gfid));
+            errno = ESTALE;
+            /* By the time we receive upcall old parent_dir may
+             * have got removed. We still need to send upcall
+             * for the file/dir and current parent handles. */
+            up_inode_arg->oldp_object = NULL;
+            ret = 0;
+        }
+
+        glfs_iatt_to_stat(fs, &ca_data->oldp_stat, &up_inode_arg->oldp_buf);
+    }
+    up_inode_arg->oldp_object = oldp_object;
+
+    up_arg->reason = GLFS_UPCALL_INODE_INVALIDATE;
+    up_arg->event = up_inode_arg;
+    up_arg->free_event = glfs_free_upcall_inode;
+
+    ret = 0;
 
 out:
-        if (ret) {
-                /* Close p_object and oldp_object as well if being referenced.*/
-                if (object)
-                        glfs_h_close (object);
-
-                /* Set reason to prevent applications from using ->event */
-                up_arg->reason = GLFS_UPCALL_EVENT_NULL;
-                GF_FREE (up_inode_arg);
-        }
-        return ret;
+    if (ret) {
+        /* Close p_object and oldp_object as well if being referenced.*/
+        if (object)
+            glfs_h_close(object);
+
+        /* Set reason to prevent applications from using ->event */
+        up_arg->reason = GLFS_UPCALL_EVENT_NULL;
+        GF_FREE(up_inode_arg);
+    }
+    return ret;
 }
 
-void glfs_release_upcall (void *ptr)
+void
+glfs_release_upcall(void *ptr)
 {
-        struct glfs_upcall *to_free = ptr;
+    struct glfs_upcall *to_free = ptr;
 
-        if (to_free->event)
-                to_free->free_event (to_free->event);
+    if (to_free->event)
+        to_free->free_event(to_free->event);
 }
 
 /*
@@ -2045,123 +2066,120 @@ void glfs_release_upcall (void *ptr)
  * cannot be freed while in this routine.
  */
 int
-pub_glfs_h_poll_upcall (struct glfs *fs, struct glfs_upcall **up_arg)
+pub_glfs_h_poll_upcall(struct glfs *fs, struct glfs_upcall **up_arg)
 {
-        upcall_entry       *u_list         = NULL;
-        upcall_entry       *tmp            = NULL;
-        xlator_t           *subvol         = NULL;
-        glusterfs_ctx_t    *ctx            = NULL;
-        int                 ret            = -1;
-        struct gf_upcall   *upcall_data    = NULL;
-
-        DECLARE_OLD_THIS;
-
-        if (!up_arg) {
-                errno = EINVAL;
-                goto err;
-        }
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, err);
-
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                errno = EIO;
-                goto restore;
-        }
-
-        /* Ideally applications should stop polling before calling
-         * 'glfs_fini'. Yet cross check if cleanup has started. */
-        pthread_mutex_lock (&fs->mutex);
+    upcall_entry *u_list = NULL;
+    upcall_entry *tmp = NULL;
+    xlator_t *subvol = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = -1;
+    struct gf_upcall *upcall_data = NULL;
+
+    DECLARE_OLD_THIS;
+
+    if (!up_arg) {
+        errno = EINVAL;
+        goto err;
+    }
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, err);
+
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        errno = EIO;
+        goto restore;
+    }
+
+    /* Ideally applications should stop polling before calling
+     * 'glfs_fini'. Yet cross check if cleanup has started. */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        ctx = fs->ctx;
+
+        if (ctx->cleanup_started) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto out;
+        }
+
+        fs->pin_refcnt++;
+
+        /* once we call this function, the applications seems to be
+         * interested in events, enable caching them */
+        fs->cache_upcalls = _gf_true;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    pthread_mutex_lock(&fs->upcall_list_mutex);
+    {
+        list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list)
         {
-                ctx = fs->ctx;
-
-                if (ctx->cleanup_started) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto out;
+            list_del_init(&u_list->upcall_list);
+            upcall_data = &u_list->upcall_data;
+            break;
+        }
+    }
+    /* No other thread can delete this entry. So unlock it */
+    pthread_mutex_unlock(&fs->upcall_list_mutex);
+
+    if (upcall_data) {
+        switch (upcall_data->event_type) {
+            case GF_UPCALL_CACHE_INVALIDATION:
+                *up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall),
+                                      glfs_release_upcall,
+                                      glfs_mt_upcall_entry_t);
+                if (!*up_arg) {
+                    errno = ENOMEM;
+                    break; /* goto free u_list */
                 }
 
-                fs->pin_refcnt++;
-
-                /* once we call this function, the applications seems to be
-                 * interested in events, enable caching them */
-                fs->cache_upcalls = _gf_true;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+                /* XXX: Need to revisit this to support
+                 * GLFS_UPCALL_INODE_UPDATE if required. */
+                ret = glfs_h_poll_cache_invalidation(fs, *up_arg, upcall_data);
+                if (ret || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) {
+                    /* It could so happen that the file which got
+                     * upcall notification may have got deleted by
+                     * the same client. Irrespective of the error,
+                     * return with an error or success+ENOENT. */
+                    if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL)
+                        errno = ENOENT;
 
-        pthread_mutex_lock (&fs->upcall_list_mutex);
-        {
-                list_for_each_entry_safe (u_list, tmp,
-                                          &fs->upcall_list,
-                                          upcall_list) {
-                        list_del_init (&u_list->upcall_list);
-                        upcall_data = &u_list->upcall_data;
-                        break;
+                    GLFS_FREE(*up_arg);
+                    *up_arg = NULL;
                 }
-        }
-        /* No other thread can delete this entry. So unlock it */
-        pthread_mutex_unlock (&fs->upcall_list_mutex);
-
-        if (upcall_data) {
-                switch (upcall_data->event_type) {
-                case GF_UPCALL_CACHE_INVALIDATION:
-                        *up_arg = GLFS_CALLOC (1, sizeof (struct gf_upcall),
-                                               glfs_release_upcall,
-                                               glfs_mt_upcall_entry_t);
-                        if (!*up_arg) {
-                                errno = ENOMEM;
-                                break; /* goto free u_list */
-                        }
-
-                        /* XXX: Need to revisit this to support
-                         * GLFS_UPCALL_INODE_UPDATE if required. */
-                        ret = glfs_h_poll_cache_invalidation (fs, *up_arg,
-                                                              upcall_data);
-                        if (ret
-                            || (*up_arg)->reason == GLFS_UPCALL_EVENT_NULL) {
-                                /* It could so happen that the file which got
-                                 * upcall notification may have got deleted by
-                                 * the same client. Irrespective of the error,
-                                 * return with an error or success+ENOENT. */
-                                if ((*up_arg)->reason == GLFS_UPCALL_EVENT_NULL)
-                                        errno = ENOENT;
-
-                                GLFS_FREE (*up_arg);
-                                *up_arg = NULL;
-                        }
-                        break;
-                case GF_UPCALL_RECALL_LEASE:
-                        gf_log ("glfs_h_poll_upcall", GF_LOG_DEBUG,
-                                "UPCALL_RECALL_LEASE is not implemented yet");
-                /* fallthrough till we support leases */
-                case GF_UPCALL_EVENT_NULL:
+                break;
+            case GF_UPCALL_RECALL_LEASE:
+                gf_log("glfs_h_poll_upcall", GF_LOG_DEBUG,
+                       "UPCALL_RECALL_LEASE is not implemented yet");
+            /* fallthrough till we support leases */
+            case GF_UPCALL_EVENT_NULL:
                 /* no 'default:' label, to force handling all upcall events */
-                        errno = ENOENT;
-                        break;
-                }
-
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE (u_list);
-        } else {
-                /* fs->upcall_list was empty, no upcall events cached */
                 errno = ENOENT;
+                break;
         }
 
-        ret = 0;
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    } else {
+        /* fs->upcall_list was empty, no upcall events cached */
+        errno = ENOENT;
+    }
+
+    ret = 0;
 
 out:
-        pthread_mutex_lock (&fs->mutex);
-        {
-                fs->pin_refcnt--;
-        }
-        pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->pin_refcnt--;
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
 restore:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 err:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_poll_upcall, 3.7.16);
@@ -2180,72 +2198,70 @@ static gf_boolean_t log_upcall370 = _gf_true; /* log once */
  * WARNING: this function will be removed in the future.
  */
 int
-pub_glfs_h_poll_upcall370 (struct glfs *fs, struct glfs_callback_arg *up_arg)
+pub_glfs_h_poll_upcall370(struct glfs *fs, struct glfs_callback_arg *up_arg)
 {
-        struct glfs_upcall    *upcall        = NULL;
-        int                    ret           = -1;
-
-        if (log_upcall370) {
-                log_upcall370 = _gf_false;
-                gf_log (THIS->name, GF_LOG_WARNING, "this application is "
-                        "compiled against an old version of libgfapi, it "
-                        "should use glfs_free() to release the structure "
-                        "returned by glfs_h_poll_upcall() - for more details, "
-                        "see http://review.gluster.org/14701");
-        }
+    struct glfs_upcall *upcall = NULL;
+    int ret = -1;
+
+    if (log_upcall370) {
+        log_upcall370 = _gf_false;
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "this application is "
+               "compiled against an old version of libgfapi, it "
+               "should use glfs_free() to release the structure "
+               "returned by glfs_h_poll_upcall() - for more details, "
+               "see http://review.gluster.org/14701");
+    }
+
+    ret = pub_glfs_h_poll_upcall(fs, &upcall);
+    if (ret == 0) {
+        up_arg->fs = fs;
+        if (errno == ENOENT || upcall->event == NULL) {
+            up_arg->reason = GLFS_UPCALL_EVENT_NULL;
+            goto out;
+        }
+
+        up_arg->reason = upcall->reason;
+
+        if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) {
+            struct glfs_callback_inode_arg *cb_inode = NULL;
+            struct glfs_upcall_inode *up_inode = NULL;
+
+            cb_inode = GF_CALLOC(1, sizeof(struct glfs_callback_inode_arg),
+                                 glfs_mt_upcall_inode_t);
+            if (!cb_inode) {
+                errno = ENOMEM;
+                ret = -1;
+                goto out;
+            }
 
-        ret = pub_glfs_h_poll_upcall (fs, &upcall);
-        if (ret == 0) {
-                up_arg->fs = fs;
-                if (errno == ENOENT || upcall->event == NULL) {
-                        up_arg->reason = GLFS_UPCALL_EVENT_NULL;
-                        goto out;
-                }
+            up_inode = upcall->event;
 
-                up_arg->reason = upcall->reason;
-
-                if (upcall->reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                        struct glfs_callback_inode_arg *cb_inode = NULL;
-                        struct glfs_upcall_inode       *up_inode = NULL;
-
-                        cb_inode = GF_CALLOC (1,
-                                              sizeof (struct glfs_callback_inode_arg),
-                                              glfs_mt_upcall_inode_t);
-                        if (!cb_inode) {
-                                errno = ENOMEM;
-                                ret = -1;
-                                goto out;
-                        }
-
-                        up_inode = upcall->event;
-
-                        /* copy attributes one by one, the memory layout might
-                         * be different between the old glfs_callback_inode_arg
-                         * and new glfs_upcall_inode */
-                        cb_inode->object = up_inode->object;
-                        cb_inode->flags = up_inode->flags;
-                        memcpy (&cb_inode->buf, &up_inode->buf,
-                                sizeof (struct stat));
-                        cb_inode->expire_time_attr = up_inode->expire_time_attr;
-                        cb_inode->p_object = up_inode->p_object;
-                        memcpy (&cb_inode->p_buf, &up_inode->p_buf,
-                                sizeof (struct stat));
-                        cb_inode->oldp_object = up_inode->oldp_object;
-                        memcpy (&cb_inode->oldp_buf, &up_inode->oldp_buf,
-                                sizeof (struct stat));
-
-                        up_arg->event_arg = cb_inode;
-                }
+            /* copy attributes one by one, the memory layout might
+             * be different between the old glfs_callback_inode_arg
+             * and new glfs_upcall_inode */
+            cb_inode->object = up_inode->object;
+            cb_inode->flags = up_inode->flags;
+            memcpy(&cb_inode->buf, &up_inode->buf, sizeof(struct stat));
+            cb_inode->expire_time_attr = up_inode->expire_time_attr;
+            cb_inode->p_object = up_inode->p_object;
+            memcpy(&cb_inode->p_buf, &up_inode->p_buf, sizeof(struct stat));
+            cb_inode->oldp_object = up_inode->oldp_object;
+            memcpy(&cb_inode->oldp_buf, &up_inode->oldp_buf,
+                   sizeof(struct stat));
+
+            up_arg->event_arg = cb_inode;
         }
+    }
 
 out:
-        if (upcall) {
-                /* we can not use glfs_free() here, objects need to stay */
-                GF_FREE (upcall->event);
-                GF_FREE (upcall);
-        }
+    if (upcall) {
+        /* we can not use glfs_free() here, objects need to stay */
+        GF_FREE(upcall->event);
+        GF_FREE(upcall);
+    }
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0);
@@ -2255,123 +2271,121 @@ GFAPI_SYMVER_PUBLIC(glfs_h_poll_upcall370, glfs_h_poll_upcall, 3.7.0);
 #include <acl/libacl.h>
 
 int
-pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type, const acl_t acl)
+pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type, const acl_t acl)
 {
-        int ret = -1;
-        char *acl_s = NULL;
-        const char *acl_key = NULL;
-        struct glfs_object *new_object = NULL;
+    int ret = -1;
+    char *acl_s = NULL;
+    const char *acl_key = NULL;
+    struct glfs_object *new_object = NULL;
 
-        DECLARE_OLD_THIS;
+    DECLARE_OLD_THIS;
 
-        if (!object || !acl) {
-                errno = EINVAL;
-                return ret;
-        }
+    if (!object || !acl) {
+        errno = EINVAL;
+        return ret;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        acl_key = gf_posix_acl_get_key (type);
-        if (!acl_key)
-                goto out;
+    acl_key = gf_posix_acl_get_key(type);
+    if (!acl_key)
+        goto out;
 
-        acl_s = acl_to_any_text (acl, NULL, ',',
-                                 TEXT_ABBREVIATE | TEXT_NUMERIC_IDS);
-        if (!acl_s)
-                goto out;
+    acl_s = acl_to_any_text(acl, NULL, ',', TEXT_ABBREVIATE | TEXT_NUMERIC_IDS);
+    if (!acl_s)
+        goto out;
 
-        if (IA_ISLNK (object->inode->ia_type)) {
-                new_object = glfs_h_resolve_symlink (fs, object);
-                if (new_object == NULL)
-                        goto out;
-        } else
-                new_object = object;
+    if (IA_ISLNK(object->inode->ia_type)) {
+        new_object = glfs_h_resolve_symlink(fs, object);
+        if (new_object == NULL)
+            goto out;
+    } else
+        new_object = object;
 
-        ret = pub_glfs_h_setxattrs (fs, new_object, acl_key, acl_s,
-                                    strlen (acl_s) + 1, 0);
+    ret = pub_glfs_h_setxattrs(fs, new_object, acl_key, acl_s,
+                               strlen(acl_s) + 1, 0);
 
-        acl_free (acl_s);
+    acl_free(acl_s);
 
 out:
-        if (IA_ISLNK (object->inode->ia_type) && new_object)
-                glfs_h_close (new_object);
+    if (IA_ISLNK(object->inode->ia_type) && new_object)
+        glfs_h_close(new_object);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 acl_t
-pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type)
+pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type)
 {
-        int                 ret = 0;
-        acl_t acl = NULL;
-        char *acl_s = NULL;
-        dict_t *xattr = NULL;
-        const char *acl_key = NULL;
-        struct glfs_object *new_object = NULL;
-
-        DECLARE_OLD_THIS;
-
-        if (!object) {
-                errno = EINVAL;
-                return NULL;
-        }
+    int ret = 0;
+    acl_t acl = NULL;
+    char *acl_s = NULL;
+    dict_t *xattr = NULL;
+    const char *acl_key = NULL;
+    struct glfs_object *new_object = NULL;
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
 
-        acl_key = gf_posix_acl_get_key (type);
-        if (!acl_key)
-                goto out;
+    if (!object) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        if (IA_ISLNK (object->inode->ia_type)) {
-                new_object = glfs_h_resolve_symlink (fs, object);
-                if (new_object == NULL)
-                        goto out;
-        } else
-                new_object = object;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        ret = glfs_h_getxattrs_common (fs, new_object, &xattr, acl_key,
-                                       _gf_false);
-        if (ret)
-                goto out;
+    acl_key = gf_posix_acl_get_key(type);
+    if (!acl_key)
+        goto out;
 
-        ret = dict_get_str (xattr, (char *)acl_key, &acl_s);
-        if (ret)
-                goto out;
+    if (IA_ISLNK(object->inode->ia_type)) {
+        new_object = glfs_h_resolve_symlink(fs, object);
+        if (new_object == NULL)
+            goto out;
+    } else
+        new_object = object;
 
-        acl = acl_from_text (acl_s);
+    ret = glfs_h_getxattrs_common(fs, new_object, &xattr, acl_key, _gf_false);
+    if (ret)
+        goto out;
+
+    ret = dict_get_str(xattr, (char *)acl_key, &acl_s);
+    if (ret)
+        goto out;
+
+    acl = acl_from_text(acl_s);
 
 out:
-        if (xattr)
-                dict_unref(xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        if (IA_ISLNK (object->inode->ia_type) && new_object)
-                glfs_h_close (new_object);
+    if (IA_ISLNK(object->inode->ia_type) && new_object)
+        glfs_h_close(new_object);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return acl;
+    return acl;
 }
 #else /* !HAVE_ACL_LIBACL_H */
 acl_t
-pub_glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type)
+pub_glfs_h_acl_get(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type)
 {
-        errno = ENOTSUP;
-        return NULL;
+    errno = ENOTSUP;
+    return NULL;
 }
 
 int
-pub_glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                    const acl_type_t type, const acl_t acl)
+pub_glfs_h_acl_set(struct glfs *fs, struct glfs_object *object,
+                   const acl_type_t type, const acl_t acl)
 {
-        errno = ENOTSUP;
-        return -1;
+    errno = ENOTSUP;
+    return -1;
 }
 #endif
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_set, 3.7.0);
@@ -2379,153 +2393,158 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_acl_get, 3.7.0);
 
 /* The API to perform read using anonymous fd */
 ssize_t
-pub_glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object,
-                           const void *buf, size_t count, off_t offset)
+pub_glfs_h_anonymous_read(struct glfs *fs, struct glfs_object *object,
+                          const void *buf, size_t count, off_t offset)
 {
-        struct iovec    iov     = {0, };
-        ssize_t         ret     = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_anonymous_preadv (fs, object, &iov, 1, offset, 0);
+    ret = glfs_anonymous_preadv(fs, object, &iov, 1, offset, 0);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_read, 3.7.0);
 
 /* The API to perform write using anonymous fd */
 ssize_t
-pub_glfs_h_anonymous_write (struct glfs *fs, struct glfs_object *object,
-                            const void *buf, size_t count, off_t offset)
+pub_glfs_h_anonymous_write(struct glfs *fs, struct glfs_object *object,
+                           const void *buf, size_t count, off_t offset)
 {
-        struct iovec iov        = {0, };
-        ssize_t      ret        = 0;
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    struct iovec iov = {
+        0,
+    };
+    ssize_t ret = 0;
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        iov.iov_base = (void *) buf;
-        iov.iov_len = count;
+    iov.iov_base = (void *)buf;
+    iov.iov_len = count;
 
-        ret = glfs_anonymous_pwritev (fs, object, &iov, 1, offset, 0);
+    ret = glfs_anonymous_pwritev(fs, object, &iov, 1, offset, 0);
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_anonymous_write, 3.7.0);
 
-struct glfs_object*
-pub_glfs_object_copy (struct glfs_object *src)
+struct glfs_object *
+pub_glfs_object_copy(struct glfs_object *src)
 {
-        struct glfs_object *object = NULL;
+    struct glfs_object *object = NULL;
 
-        GF_VALIDATE_OR_GOTO ("glfs_dup_object", src, out);
+    GF_VALIDATE_OR_GOTO("glfs_dup_object", src, out);
 
-        object = GF_CALLOC (1, sizeof(struct glfs_object),
-                            glfs_mt_glfs_object_t);
-        if (object == NULL) {
-                errno = ENOMEM;
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                         API_MSG_CREATE_HANDLE_FAILED,
-                        "glfs_dup_object for gfid-%s failed",
-                        uuid_utoa (src->inode->gfid));
-                return NULL;
-        }
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_CREATE_HANDLE_FAILED,
+               "glfs_dup_object for gfid-%s failed",
+               uuid_utoa(src->inode->gfid));
+        return NULL;
+    }
 
-        object->inode = inode_ref (src->inode);
-        gf_uuid_copy (object->gfid, src->inode->gfid);
+    object->inode = inode_ref(src->inode);
+    gf_uuid_copy(object->gfid, src->inode->gfid);
 
 out:
-        return object;
+    return object;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_object_copy, 3.11.0);
 
-struct glfs_object*
-pub_glfs_xreaddirplus_get_object (struct glfs_xreaddirp_stat *xstat)
+struct glfs_object *
+pub_glfs_xreaddirplus_get_object(struct glfs_xreaddirp_stat *xstat)
 {
-        GF_VALIDATE_OR_GOTO ("glfs_xreaddirplus_get_object", xstat, out);
+    GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_object", xstat, out);
 
-        if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE))
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_INVALID_ARG,
-                        "GFAPI_XREADDIRP_HANDLE is not set. Flags"
-                        "handled for xstat(%p) are (%x)",
-                        xstat, xstat->flags_handled);
+    if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE))
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
+               "GFAPI_XREADDIRP_HANDLE is not set. Flags"
+               "handled for xstat(%p) are (%x)",
+               xstat, xstat->flags_handled);
 
-        return xstat->object;
+    return xstat->object;
 
 out:
-        return NULL;
+    return NULL;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_xreaddirplus_get_object, 3.11.0);
 
 int
-pub_glfs_h_lease (struct glfs *fs, struct glfs_object *object,
-                  struct glfs_lease *lease)
+pub_glfs_h_lease(struct glfs *fs, struct glfs_object *object,
+                 struct glfs_lease *lease)
 {
-        int              ret = -1;
-        xlator_t        *subvol = NULL;
-        inode_t         *inode = NULL;
-        loc_t            loc = {0, };
-        struct gf_lease  gf_lease = {0, };
-
-        /* validate in args */
-        if ((fs == NULL) || (object == NULL)) {
-                errno = EINVAL;
-                return -1;
-        }
+    int ret = -1;
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct gf_lease gf_lease = {
+        0,
+    };
+
+    /* validate in args */
+    if ((fs == NULL) || (object == NULL)) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* get the active volume */
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
+    /* get the active volume */
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-        /* get/refresh the in arg objects inode in correlation to the xlator */
-        inode = glfs_resolve_inode (fs, subvol, object);
-        if (!inode) {
-                errno = ESTALE;
-                goto out;
-        }
+    /* get/refresh the in arg objects inode in correlation to the xlator */
+    inode = glfs_resolve_inode(fs, subvol, object);
+    if (!inode) {
+        errno = ESTALE;
+        goto out;
+    }
 
-        /* populate loc */
-        GLFS_LOC_FILL_INODE (inode, loc, out);
+    /* populate loc */
+    GLFS_LOC_FILL_INODE(inode, loc, out);
 
-        glfs_lease_to_gf_lease (lease, &gf_lease);
+    glfs_lease_to_gf_lease(lease, &gf_lease);
 
-        ret = syncop_lease (subvol, &loc, &gf_lease, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_lease(subvol, &loc, &gf_lease, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 
-        gf_lease_to_glfs_lease (&gf_lease, lease);
+    gf_lease_to_glfs_lease(&gf_lease, lease);
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        glfs_subvol_done (fs, subvol);
+    glfs_subvol_done(fs, subvol);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_h_lease, 4.0.0);
diff --git a/api/src/glfs-master.c b/api/src/glfs-master.c
index 9648bbbc03a..969095a8224 100644
--- a/api/src/glfs-master.c
+++ b/api/src/glfs-master.c
@@ -22,166 +22,153 @@
 #include "glfs-mem-types.h"
 #include "gfapi-messages.h"
 
-
 int
-graph_setup (struct glfs *fs, glusterfs_graph_t *graph)
+graph_setup(struct glfs *fs, glusterfs_graph_t *graph)
 {
-	xlator_t      *new_subvol = NULL;
-	xlator_t      *old_subvol = NULL;
-	inode_table_t *itable = NULL;
-	int            ret = -1;
-
-	new_subvol = graph->top;
-
-	/* This is called in a bottom-up context, it should specifically
-	   NOT be glfs_lock()
-	*/
-	pthread_mutex_lock (&fs->mutex);
-	{
-		if (new_subvol->switched ||
-		    new_subvol == fs->active_subvol ||
-		    new_subvol == fs->next_subvol ||
-                    new_subvol == fs->mip_subvol) {
-			/* Spurious CHILD_UP event on old graph */
-			ret = 0;
-			goto unlock;
-		}
-
-		if (!new_subvol->itable) {
-			itable = inode_table_new (131072, new_subvol);
-			if (!itable) {
-				errno = ENOMEM;
-				ret = -1;
-				goto unlock;
-			}
-
-			new_subvol->itable = itable;
-		}
-
-		old_subvol = fs->next_subvol;
-		fs->next_subvol = new_subvol;
-		fs->next_subvol->winds++; /* first ref */
-		ret = 0;
-	}
+    xlator_t *new_subvol = NULL;
+    xlator_t *old_subvol = NULL;
+    inode_table_t *itable = NULL;
+    int ret = -1;
+
+    new_subvol = graph->top;
+
+    /* This is called in a bottom-up context, it should specifically
+       NOT be glfs_lock()
+    */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        if (new_subvol->switched || new_subvol == fs->active_subvol ||
+            new_subvol == fs->next_subvol || new_subvol == fs->mip_subvol) {
+            /* Spurious CHILD_UP event on old graph */
+            ret = 0;
+            goto unlock;
+        }
+
+        if (!new_subvol->itable) {
+            itable = inode_table_new(131072, new_subvol);
+            if (!itable) {
+                errno = ENOMEM;
+                ret = -1;
+                goto unlock;
+            }
+
+            new_subvol->itable = itable;
+        }
+
+        old_subvol = fs->next_subvol;
+        fs->next_subvol = new_subvol;
+        fs->next_subvol->winds++; /* first ref */
+        ret = 0;
+    }
 unlock:
-	pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_unlock(&fs->mutex);
 
-	if (old_subvol)
-		/* wasn't picked up so far, skip */
-		glfs_subvol_done (fs, old_subvol);
+    if (old_subvol)
+        /* wasn't picked up so far, skip */
+        glfs_subvol_done(fs, old_subvol);
 
-	return ret;
+    return ret;
 }
 
-
 int
-notify (xlator_t *this, int event, void *data, ...)
+notify(xlator_t *this, int event, void *data, ...)
 {
-	glusterfs_graph_t   *graph = NULL;
-	struct glfs	    *fs = NULL;
-
-	graph = data;
-	fs = this->private;
-
-	switch (event) {
-	case GF_EVENT_GRAPH_NEW:
-		gf_msg (this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
-                        "New graph %s (%d) coming up",
-			uuid_utoa ((unsigned char *)graph->graph_uuid),
-			graph->id);
-		break;
-	case GF_EVENT_CHILD_UP:
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        graph->used = 1;
-                }
-                pthread_mutex_unlock (&fs->mutex);
-		graph_setup (fs, graph);
-		glfs_init_done (fs, 0);
-		break;
-	case GF_EVENT_CHILD_DOWN:
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        graph->used = 0;
-                        pthread_cond_broadcast (&fs->child_down_cond);
-                }
-                pthread_mutex_unlock (&fs->mutex);
-		glfs_init_done (fs, 1);
-		break;
-	case GF_EVENT_CHILD_CONNECTING:
-		break;
+    glusterfs_graph_t *graph = NULL;
+    struct glfs *fs = NULL;
+
+    graph = data;
+    fs = this->private;
+
+    switch (event) {
+        case GF_EVENT_GRAPH_NEW:
+            gf_msg(this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
+                   "New graph %s (%d) coming up",
+                   uuid_utoa((unsigned char *)graph->graph_uuid), graph->id);
+            break;
+        case GF_EVENT_CHILD_UP:
+            pthread_mutex_lock(&fs->mutex);
+            {
+                graph->used = 1;
+            }
+            pthread_mutex_unlock(&fs->mutex);
+            graph_setup(fs, graph);
+            glfs_init_done(fs, 0);
+            break;
+        case GF_EVENT_CHILD_DOWN:
+            pthread_mutex_lock(&fs->mutex);
+            {
+                graph->used = 0;
+                pthread_cond_broadcast(&fs->child_down_cond);
+            }
+            pthread_mutex_unlock(&fs->mutex);
+            glfs_init_done(fs, 1);
+            break;
+        case GF_EVENT_CHILD_CONNECTING:
+            break;
         case GF_EVENT_UPCALL:
-                glfs_process_upcall_event (fs, data);
-                break;
-	default:
-		gf_msg_debug (this->name, 0, "got notify event %d", event);
-		break;
-	}
-
-	return 0;
+            glfs_process_upcall_event(fs, data);
+            break;
+        default:
+            gf_msg_debug(this->name, 0, "got notify event %d", event);
+            break;
+    }
+
+    return 0;
 }
 
-
 int
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (!this)
-		return ret;
+    if (!this)
+        return ret;
 
-	ret = xlator_mem_acct_init (this, glfs_mt_end + 1);
-	if (ret) {
-		gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        API_MSG_MEM_ACCT_INIT_FAILED, "Failed to initialise "
-                        "memory accounting");
-		return ret;
-	}
+    ret = xlator_mem_acct_init(this, glfs_mt_end + 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+               "Failed to initialise "
+               "memory accounting");
+        return ret;
+    }
 
-	return 0;
+    return 0;
 }
 
-
 int
-init (xlator_t *this)
+init(xlator_t *this)
 {
-	return 0;
+    return 0;
 }
 
-
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-
 }
 
 /* place-holder fops */
 int
-glfs_forget (xlator_t *this, inode_t *inode)
+glfs_forget(xlator_t *this, inode_t *inode)
 {
-	return 0;
+    return 0;
 }
 
 int
-glfs_release (xlator_t *this, fd_t *fd)
+glfs_release(xlator_t *this, fd_t *fd)
 {
-	return 0;
+    return 0;
 }
 
 int
-glfs_releasedir (xlator_t *this, fd_t *fd)
+glfs_releasedir(xlator_t *this, fd_t *fd)
 {
-	return 0;
+    return 0;
 }
 
 struct xlator_dumpops dumpops;
 
-
 struct xlator_fops fops;
 
-
-struct xlator_cbks cbks = {
-	.forget	    = glfs_forget,
-	.release    = glfs_release,
-	.releasedir = glfs_releasedir
-};
+struct xlator_cbks cbks = {.forget = glfs_forget,
+                           .release = glfs_release,
+                           .releasedir = glfs_releasedir};
diff --git a/api/src/glfs-mgmt.c b/api/src/glfs-mgmt.c
index fac903b805a..87b62173689 100644
--- a/api/src/glfs-mgmt.c
+++ b/api/src/glfs-mgmt.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -38,1063 +37,1034 @@
 #include "gfapi-messages.h"
 #include "syscall.h"
 
-int glfs_volfile_fetch (struct glfs *fs);
-int32_t glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
-                                  struct glfs *fs);
+int
+glfs_volfile_fetch(struct glfs *fs);
+int32_t
+glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs);
 
 int
-glfs_process_volfp (struct glfs *fs, FILE *fp)
+glfs_process_volfp(struct glfs *fs, FILE *fp)
 {
-	glusterfs_graph_t  *graph = NULL;
-	int		    ret = -1;
-	xlator_t	   *trav = NULL;
-	glusterfs_ctx_t	   *ctx = NULL;
-
-	ctx = fs->ctx;
-	graph = glusterfs_graph_construct (fp);
-	if (!graph) {
-		gf_msg ("glfs", GF_LOG_ERROR, errno,
-                        API_MSG_GRAPH_CONSTRUCT_FAILED,
-                        "failed to construct the graph");
-		goto out;
-	}
-
-	for (trav = graph->first; trav; trav = trav->next) {
-		if (strcmp (trav->type, "mount/api") == 0) {
-			gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                                API_MSG_API_XLATOR_ERROR,
-				"api master xlator cannot be specified "
-				"in volume file");
-			goto out;
-		}
-	}
-
-	ret = glusterfs_graph_prepare (graph, ctx, fs->volname);
-	if (ret) {
-		glusterfs_graph_destroy (graph);
-		goto out;
-	}
-
-	ret = glusterfs_graph_activate (graph, ctx);
-
-	if (ret) {
-		glusterfs_graph_destroy (graph);
-		goto out;
-	}
-
-        gf_log_dump_graph (fp, graph);
-
-	ret = 0;
+    glusterfs_graph_t *graph = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = fs->ctx;
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_GRAPH_CONSTRUCT_FAILED,
+               "failed to construct the graph");
+        goto out;
+    }
+
+    for (trav = graph->first; trav; trav = trav->next) {
+        if (strcmp(trav->type, "mount/api") == 0) {
+            gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_API_XLATOR_ERROR,
+                   "api master xlator cannot be specified "
+                   "in volume file");
+            goto out;
+        }
+    }
+
+    ret = glusterfs_graph_prepare(graph, ctx, fs->volname);
+    if (ret) {
+        glusterfs_graph_destroy(graph);
+        goto out;
+    }
+
+    ret = glusterfs_graph_activate(graph, ctx);
+
+    if (ret) {
+        glusterfs_graph_destroy(graph);
+        goto out;
+    }
+
+    gf_log_dump_graph(fp, graph);
+
+    ret = 0;
 out:
-	if (fp)
-		fclose (fp);
+    if (fp)
+        fclose(fp);
 
-	if (!ctx->active) {
-		ret = -1;
-	}
+    if (!ctx->active) {
+        ret = -1;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-	struct glfs *fs = NULL;
-	xlator_t    *this = NULL;
+    struct glfs *fs = NULL;
+    xlator_t *this = NULL;
 
-	this = mydata;
-	fs = this->private;
+    this = mydata;
+    fs = this->private;
 
-	glfs_volfile_fetch (fs);
+    glfs_volfile_fetch(fs);
 
-	return 0;
+    return 0;
 }
 
-
 int
-mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-	return 0;
+    return 0;
 }
 
 static int
-mgmt_cbk_statedump (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_statedump(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        struct glfs      *fs          = NULL;
-        xlator_t         *this        = NULL;
-        gf_statedump      target_pid  = {0, };
-        struct iovec     *iov         = NULL;
-        int               ret         = -1;
-
-        this = mydata;
-        if (!this) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL mydata");
-                errno = EINVAL;
-                goto out;
-        }
-
-        fs = this->private;
-        if (!fs) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL glfs");
-                errno = EINVAL;
-                goto out;
-        }
-
-        iov = (struct iovec *)data;
-        if (!iov) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED, "NULL iovec data");
-                errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &target_pid,
-                              (xdrproc_t)xdr_gf_statedump);
+    struct glfs *fs = NULL;
+    xlator_t *this = NULL;
+    gf_statedump target_pid = {
+        0,
+    };
+    struct iovec *iov = NULL;
+    int ret = -1;
+
+    this = mydata;
+    if (!this) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
+               "NULL mydata");
+        errno = EINVAL;
+        goto out;
+    }
+
+    fs = this->private;
+    if (!fs) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
+               "NULL glfs");
+        errno = EINVAL;
+        goto out;
+    }
+
+    iov = (struct iovec *)data;
+    if (!iov) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
+               "NULL iovec data");
+        errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &target_pid, (xdrproc_t)xdr_gf_statedump);
+    if (ret < 0) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
+               "Failed to decode xdr response for GF_CBK_STATEDUMP");
+        goto out;
+    }
+
+    gf_msg_trace("glfs", 0, "statedump requested for pid: %d", target_pid.pid);
+
+    if ((uint64_t)getpid() == target_pid.pid) {
+        gf_msg_debug("glfs", 0, "Taking statedump for pid: %d", target_pid.pid);
+
+        ret = glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
         if (ret < 0) {
-                gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
-                        API_MSG_STATEDUMP_FAILED,
-                        "Failed to decode xdr response for GF_CBK_STATEDUMP");
-                goto out;
-        }
-
-        gf_msg_trace ("glfs", 0, "statedump requested for pid: %d",
-                      target_pid.pid);
-
-        if ((uint64_t)getpid() == target_pid.pid) {
-                gf_msg_debug ("glfs", 0, "Taking statedump for pid: %d",
-                              target_pid.pid);
-
-                ret = glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP);
-                if (ret < 0) {
-                        gf_msg ("glfs", GF_LOG_INFO, 0,
-                                API_MSG_STATEDUMP_FAILED,
-                                "statedump failed");
-                }
+            gf_msg("glfs", GF_LOG_INFO, 0, API_MSG_STATEDUMP_FAILED,
+                   "statedump failed");
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
-	[GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec },
-	[GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
-				 mgmt_cbk_event},
-        [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_statedump},
+    [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec},
+    [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
+                             mgmt_cbk_event},
+    [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_statedump},
 };
 
-
 struct rpcclnt_cb_program mgmt_cbk_prog = {
-	.progname  = "GlusterFS Callback",
-	.prognum   = GLUSTER_CBK_PROGRAM,
-	.progver   = GLUSTER_CBK_VERSION,
-	.actors	   = mgmt_cbk_actors,
-	.numactors = GF_CBK_MAXVALUE,
+    .progname = "GlusterFS Callback",
+    .prognum = GLUSTER_CBK_PROGRAM,
+    .progver = GLUSTER_CBK_VERSION,
+    .actors = mgmt_cbk_actors,
+    .numactors = GF_CBK_MAXVALUE,
 };
 
 char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
-	[GF_HNDSK_NULL]		= "NULL",
-	[GF_HNDSK_SETVOLUME]	= "SETVOLUME",
-	[GF_HNDSK_GETSPEC]	= "GETSPEC",
-	[GF_HNDSK_PING]		= "PING",
-	[GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
-        [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO",
+    [GF_HNDSK_NULL] = "NULL",
+    [GF_HNDSK_SETVOLUME] = "SETVOLUME",
+    [GF_HNDSK_GETSPEC] = "GETSPEC",
+    [GF_HNDSK_PING] = "PING",
+    [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
+    [GF_HNDSK_GET_VOLUME_INFO] = "GETVOLUMEINFO",
 };
 
 rpc_clnt_prog_t clnt_handshake_prog = {
-	.progname  = "GlusterFS Handshake",
-	.prognum   = GLUSTER_HNDSK_PROGRAM,
-	.progver   = GLUSTER_HNDSK_VERSION,
-	.procnames = clnt_handshake_procs,
+    .progname = "GlusterFS Handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
+    .procnames = clnt_handshake_procs,
 };
 
-
 int
-mgmt_submit_request (void *req, call_frame_t *frame,
-		     glusterfs_ctx_t *ctx,
-		     rpc_clnt_prog_t *prog, int procnum,
-		     fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx,
+                    rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbkfn,
+                    xdrproc_t xdrproc)
 {
-	int			ret	    = -1;
-	int			count	   = 0;
-	struct iovec		iov	    = {0, };
-	struct iobuf		*iobuf = NULL;
-	struct iobref		*iobref = NULL;
-	ssize_t			xdr_size = 0;
-
-	iobref = iobref_new ();
-	if (!iobref) {
-		goto out;
-	}
-
-	if (req) {
-		xdr_size = xdr_sizeof (xdrproc, req);
-
-		iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-		if (!iobuf) {
-			goto out;
-		};
-
-		iobref_add (iobref, iobuf);
-
-		iov.iov_base = iobuf->ptr;
-		iov.iov_len  = iobuf_pagesize (iobuf);
-
-		/* Create the xdr payload */
-		ret = xdr_serialize_generic (iov, req, xdrproc);
-		if (ret == -1) {
-			gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                API_MSG_XDR_PAYLOAD_FAILED,
-				"failed to create XDR payload");
-			goto out;
-		}
-		iov.iov_len = ret;
-		count = 1;
-	}
-
-	/* Send the msg */
-	ret = rpc_clnt_submit (ctx->mgmt, prog, procnum, cbkfn,
-			       &iov, count,
-			       NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+
+        iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_pagesize(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_XDR_PAYLOAD_FAILED,
+                   "failed to create XDR payload");
+            goto out;
+        }
+        iov.iov_len = ret;
+        count = 1;
+    }
+
+    /* Send the msg */
+    ret = rpc_clnt_submit(ctx->mgmt, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
 
 out:
-	if (iobref)
-		iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-	if (iobuf)
-		iobuf_unref (iobuf);
-	return ret;
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 /*
  * Callback routine for 'GF_HNDSK_GET_VOLUME_INFO' rpc request
  */
 int
-mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
+mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        int                        ret                  = 0;
-        char                       *volume_id_str       = NULL;
-        dict_t                     *dict                = NULL;
-        char                       key[1024]            = {0};
-        gf_get_volume_info_rsp     rsp                  = {0,};
-        call_frame_t               *frame               = NULL;
-        glusterfs_ctx_t            *ctx                 = NULL;
-        struct glfs                *fs                  = NULL;
-        struct syncargs            *args;
-
-        frame = myframe;
-        ctx = frame->this->ctx;
-        args = frame->local;
-
-        if (!ctx) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "NULL context");
-                errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        fs = ((xlator_t *)ctx->master)->private;
-
-        if (-1 == req->rpc_status) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY,
-                        "GET_VOLUME_INFO RPC call is not successful");
-                errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
-
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                        API_MSG_XDR_RESPONSE_DECODE_FAILED,
-                        "Failed to decode xdr response for GET_VOLUME_INFO");
-                goto out;
-        }
-
-        gf_msg_debug (frame->this->name, 0, "Received resp to GET_VOLUME_INFO "
-                      "RPC: %d", rsp.op_ret);
-
-        if (rsp.op_ret == -1) {
-                errno = rsp.op_errno;
-                ret = -1;
-                goto out;
-        }
-
-        if (!rsp.dict.dict_len) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "Response received for "
-                        "GET_VOLUME_INFO RPC call is not valid");
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "volume_id");
-        ret = dict_get_str (dict, key, &volume_id_str);
-        if (ret) {
-                errno = EINVAL;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    char *volume_id_str = NULL;
+    dict_t *dict = NULL;
+    char key[1024] = {0};
+    gf_get_volume_info_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    struct glfs *fs = NULL;
+    struct syncargs *args;
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+    args = frame->local;
+
+    if (!ctx) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "NULL context");
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    if (-1 == req->rpc_status) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "GET_VOLUME_INFO RPC call is not successful");
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
+
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, 0,
+               API_MSG_XDR_RESPONSE_DECODE_FAILED,
+               "Failed to decode xdr response for GET_VOLUME_INFO");
+        goto out;
+    }
+
+    gf_msg_debug(frame->this->name, 0,
+                 "Received resp to GET_VOLUME_INFO "
+                 "RPC: %d",
+                 rsp.op_ret);
+
+    if (rsp.op_ret == -1) {
+        errno = rsp.op_errno;
+        ret = -1;
+        goto out;
+    }
+
+    if (!rsp.dict.dict_len) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "Response received for "
+               "GET_VOLUME_INFO RPC call is not valid");
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "volume_id");
+    ret = dict_get_str(dict, key, &volume_id_str);
+    if (ret) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (volume_id_str) {
-                gf_msg_debug (frame->this->name, 0,
-                              "Volume Id: %s", volume_id_str);
-                pthread_mutex_lock (&fs->mutex);
-                gf_uuid_parse (volume_id_str, fs->vol_uuid);
-                pthread_mutex_unlock (&fs->mutex);
-        }
+    if (volume_id_str) {
+        gf_msg_debug(frame->this->name, 0, "Volume Id: %s", volume_id_str);
+        pthread_mutex_lock(&fs->mutex);
+        gf_uuid_parse(volume_id_str, fs->vol_uuid);
+        pthread_mutex_unlock(&fs->mutex);
+    }
 
-        if (ret) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, errno,
-                        API_MSG_GET_VOLINFO_CBK_FAILED, "In GET_VOLUME_INFO "
-                        "cbk, received error: %s", strerror(errno));
-        }
+    if (ret) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, errno,
+               API_MSG_GET_VOLINFO_CBK_FAILED,
+               "In GET_VOLUME_INFO "
+               "cbk, received error: %s",
+               strerror(errno));
+    }
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
+    if (rsp.dict.dict_val)
+        free(rsp.dict.dict_val);
 
-        if (rsp.op_errstr)
-                free (rsp.op_errstr);
+    if (rsp.op_errstr)
+        free(rsp.op_errstr);
 
-        gf_msg_debug (frame->this->name, 0, "Returning: %d", ret);
+    gf_msg_debug(frame->this->name, 0, "Returning: %d", ret);
 
-        __wake (args);
+    __wake(args);
 
-        return ret;
+    return ret;
 }
 
 int
-pub_glfs_get_volumeid (struct glfs *fs, char *volid, size_t size)
+pub_glfs_get_volumeid(struct glfs *fs, char *volid, size_t size)
 {
-        /* TODO: Define a global macro to store UUID size */
-        size_t uuid_size = 16;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        pthread_mutex_lock (&fs->mutex);
-        {
-                /* check if the volume uuid is initialized */
-                if (!gf_uuid_is_null (fs->vol_uuid)) {
-                        pthread_mutex_unlock (&fs->mutex);
-                        goto done;
-                }
+    /* TODO: Define a global macro to store UUID size */
+    size_t uuid_size = 16;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        /* check if the volume uuid is initialized */
+        if (!gf_uuid_is_null(fs->vol_uuid)) {
+            pthread_mutex_unlock(&fs->mutex);
+            goto done;
         }
-        pthread_mutex_unlock (&fs->mutex);
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
-        /* Need to fetch volume_uuid */
-        glfs_get_volume_info (fs);
+    /* Need to fetch volume_uuid */
+    glfs_get_volume_info(fs);
 
-        if (gf_uuid_is_null (fs->vol_uuid)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_FETCH_VOLUUID_FAILED, "Unable to fetch "
-                        "volume UUID");
-                goto out;
-        }
+    if (gf_uuid_is_null(fs->vol_uuid)) {
+        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_FETCH_VOLUUID_FAILED,
+               "Unable to fetch "
+               "volume UUID");
+        goto out;
+    }
 
 done:
-        if (!volid || !size) {
-                gf_msg_debug (THIS->name, 0, "volumeid/size is null");
-                __GLFS_EXIT_FS;
-                return uuid_size;
-        }
+    if (!volid || !size) {
+        gf_msg_debug(THIS->name, 0, "volumeid/size is null");
+        __GLFS_EXIT_FS;
+        return uuid_size;
+    }
 
-        if (size < uuid_size) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE,
-                        "Insufficient size passed");
-                errno = ERANGE;
-                goto out;
-        }
+    if (size < uuid_size) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE,
+               "Insufficient size passed");
+        errno = ERANGE;
+        goto out;
+    }
 
-        memcpy (volid, fs->vol_uuid, uuid_size);
+    memcpy(volid, fs->vol_uuid, uuid_size);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        return uuid_size;
+    return uuid_size;
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return -1;
+    return -1;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volumeid, 3.5.0);
 
 int
-glfs_get_volume_info (struct glfs *fs)
+glfs_get_volume_info(struct glfs *fs)
 {
-        call_frame_t     *frame = NULL;
-        glusterfs_ctx_t  *ctx   = NULL;
-        struct syncargs  args   = {0, };
-        int              ret    = 0;
-
-        ctx = fs->ctx;
-        frame = create_frame (THIS, ctx->pool);
-        if (!frame) {
-                gf_msg ("glfs", GF_LOG_ERROR, ENOMEM,
-                        API_MSG_FRAME_CREAT_FAILED,
-                        "failed to create the frame");
-                ret = -1;
-                goto out;
-        }
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    struct syncargs args = {
+        0,
+    };
+    int ret = 0;
 
-        frame->local = &args;
+    ctx = fs->ctx;
+    frame = create_frame(THIS, ctx->pool);
+    if (!frame) {
+        gf_msg("glfs", GF_LOG_ERROR, ENOMEM, API_MSG_FRAME_CREAT_FAILED,
+               "failed to create the frame");
+        ret = -1;
+        goto out;
+    }
 
-        __yawn ((&args));
+    frame->local = &args;
 
-        ret = glfs_get_volume_info_rpc (frame, THIS, fs);
-        if (ret)
-                goto out;
+    __yawn((&args));
 
-        __yield ((&args));
+    ret = glfs_get_volume_info_rpc(frame, THIS, fs);
+    if (ret)
+        goto out;
 
-        frame->local = NULL;
-        STACK_DESTROY (frame->root);
+    __yield((&args));
+
+    frame->local = NULL;
+    STACK_DESTROY(frame->root);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
-                          struct glfs *fs)
+glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs)
 {
-        gf_get_volume_info_req  req       = {{0,}};
-        int                     ret       = 0;
-        glusterfs_ctx_t         *ctx      = NULL;
-        dict_t                  *dict     = NULL;
-        int32_t                 flags     = 0;
-
-        if (!frame || !this || !fs) {
-                ret = -1;
-                goto out;
-        }
-
-        ctx = fs->ctx;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        if (fs->volname) {
-                ret = dict_set_str (dict, "volname", fs->volname);
-                if (ret)
-                        goto out;
-        }
-
-        // Set the flags for the fields which we are interested in
-        flags = (int32_t)GF_GET_VOLUME_UUID; //ctx->flags;
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED, "failed to set flags");
-                goto out;
-        }
-
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-
-
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_GET_VOLUME_INFO,
-                                   mgmt_get_volinfo_cbk,
-                                   (xdrproc_t)xdr_gf_get_volume_info_req);
+    gf_get_volume_info_req req = {{
+        0,
+    }};
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+    int32_t flags = 0;
+
+    if (!frame || !this || !fs) {
+        ret = -1;
+        goto out;
+    }
+
+    ctx = fs->ctx;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    if (fs->volname) {
+        ret = dict_set_str(dict, "volname", fs->volname);
+        if (ret)
+            goto out;
+    }
+
+    // Set the flags for the fields which we are interested in
+    flags = (int32_t)GF_GET_VOLUME_UUID;  // ctx->flags;
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+               "failed to set flags");
+        goto out;
+    }
+
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GET_VOLUME_INFO, mgmt_get_volinfo_cbk,
+                              (xdrproc_t)xdr_gf_get_volume_info_req);
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 static int
-glusterfs_oldvolfile_update (struct glfs *fs, char *volfile, ssize_t size)
+glusterfs_oldvolfile_update(struct glfs *fs, char *volfile, ssize_t size)
 {
-	int ret = -1;
-
-        pthread_mutex_lock (&fs->mutex);
-
-	fs->oldvollen = size;
-	if (!fs->oldvolfile) {
-		fs->oldvolfile = CALLOC (1, size+1);
-	} else {
-		fs->oldvolfile = REALLOC (fs->oldvolfile, size+1);
-	}
-
-	if (!fs->oldvolfile) {
-		fs->oldvollen = 0;
-	} else {
-		memcpy (fs->oldvolfile, volfile, size);
-		fs->oldvollen = size;
-		ret = 0;
-	}
+    int ret = -1;
+
+    pthread_mutex_lock(&fs->mutex);
+
+    fs->oldvollen = size;
+    if (!fs->oldvolfile) {
+        fs->oldvolfile = CALLOC(1, size + 1);
+    } else {
+        fs->oldvolfile = REALLOC(fs->oldvolfile, size + 1);
+    }
+
+    if (!fs->oldvolfile) {
+        fs->oldvollen = 0;
+    } else {
+        memcpy(fs->oldvolfile, volfile, size);
+        fs->oldvollen = size;
+        ret = 0;
+    }
 
-        pthread_mutex_unlock (&fs->mutex);
+    pthread_mutex_unlock(&fs->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
+glfs_mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-	gf_getspec_rsp		 rsp   = {0,};
-	call_frame_t		*frame = NULL;
-	glusterfs_ctx_t		*ctx = NULL;
-	int			 ret   = 0;
-	ssize_t			 size = 0;
-	FILE			*tmpfp = NULL;
-	int			 need_retry = 0;
-	struct glfs		*fs = NULL;
-        dict_t                  *dict = NULL;
-        char                    *servers_list = NULL;
-        int                      tmp_fd = -1;
-        char                     template[] = "/tmp/gfapi.volfile.XXXXXX";
-
-	frame = myframe;
-	ctx = frame->this->ctx;
-
-	if (!ctx) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY, "NULL context");
-		errno = EINVAL;
-		ret = -1;
-		goto out;
-	}
-
-	fs = ((xlator_t *)ctx->master)->private;
-
-	if (-1 == req->rpc_status) {
-		ret = -1;
-		need_retry = 1;
-		goto out;
-	}
-
-	ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-	if (ret < 0) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                        API_MSG_XDR_DECODE_FAILED, "XDR decoding error");
-		ret   = -1;
-		goto out;
-	}
-
-	if (-1 == rsp.op_ret) {
-		gf_msg (frame->this->name, GF_LOG_ERROR, rsp.op_errno,
-                        API_MSG_GET_VOLFILE_FAILED,
-			"failed to get the 'volume file' from server");
-		ret = -1;
-		errno = rsp.op_errno;
-		goto out;
-	}
-
-        if (!rsp.xdata.xdata_len) {
-                goto volfile;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.xdata.xdata_val, rsp.xdata.xdata_len,
-                                &dict);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to unserialize xdata to dictionary");
-                goto out;
-        }
-        dict->extra_stdfree = rsp.xdata.xdata_val;
-
-        /* glusterd2 only */
-        ret = dict_get_str (dict, "servers-list", &servers_list);
-        if (ret) {
-                goto volfile;
-        }
-
-        gf_log (frame->this->name, GF_LOG_INFO,
-                "Received list of available volfile servers: %s",
-                servers_list);
-
-        ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed (%s) to process servers list: %s",
-                        strerror (errno), servers_list);
-        }
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    ssize_t size = 0;
+    FILE *tmpfp = NULL;
+    int need_retry = 0;
+    struct glfs *fs = NULL;
+    dict_t *dict = NULL;
+    char *servers_list = NULL;
+    int tmp_fd = -1;
+    char template[] = "/tmp/gfapi.volfile.XXXXXX";
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+
+    if (!ctx) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "NULL context");
+        errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        need_retry = 1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, 0, API_MSG_XDR_DECODE_FAILED,
+               "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_msg(frame->this->name, GF_LOG_ERROR, rsp.op_errno,
+               API_MSG_GET_VOLFILE_FAILED,
+               "failed to get the 'volume file' from server");
+        ret = -1;
+        errno = rsp.op_errno;
+        goto out;
+    }
+
+    if (!rsp.xdata.xdata_len) {
+        goto volfile;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.xdata.xdata_val, rsp.xdata.xdata_len, &dict);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to unserialize xdata to dictionary");
+        goto out;
+    }
+    dict->extra_stdfree = rsp.xdata.xdata_val;
+
+    /* glusterd2 only */
+    ret = dict_get_str(dict, "servers-list", &servers_list);
+    if (ret) {
+        goto volfile;
+    }
+
+    gf_log(frame->this->name, GF_LOG_INFO,
+           "Received list of available volfile servers: %s", servers_list);
+
+    ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed (%s) to process servers list: %s", strerror(errno),
+               servers_list);
+    }
 
 volfile:
-	ret = 0;
-	size = rsp.op_ret;
-
-	if ((size == fs->oldvollen) &&
-	    (memcmp (fs->oldvolfile, rsp.spec, size) == 0)) {
-		gf_msg (frame->this->name, GF_LOG_INFO, 0,
-                        API_MSG_VOLFILE_INFO,
-			"No change in volfile, continuing");
-		goto out;
-	}
-
-        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-        tmp_fd = mkstemp (template);
-        if (-1 == tmp_fd) {
-                ret = -1;
-                goto out;
-        }
-
-        /* Calling unlink so that when the file is closed or program
-         * terminates the temporary file is deleted.
-         */
-        ret = sys_unlink (template);
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
-                        "Unable to delete file: %s", template);
-                ret = 0;
+    ret = 0;
+    size = rsp.op_ret;
+
+    if ((size == fs->oldvollen) &&
+        (memcmp(fs->oldvolfile, rsp.spec, size) == 0)) {
+        gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
+               "No change in volfile, continuing");
+        goto out;
+    }
+
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    tmp_fd = mkstemp(template);
+    if (-1 == tmp_fd) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Calling unlink so that when the file is closed or program
+     * terminates the temporary file is deleted.
+     */
+    ret = sys_unlink(template);
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
+               "Unable to delete file: %s", template);
+        ret = 0;
+    }
+
+    tmpfp = fdopen(tmp_fd, "w+b");
+    if (!tmpfp) {
+        ret = -1;
+        goto out;
+    }
+
+    fwrite(rsp.spec, size, 1, tmpfp);
+    fflush(tmpfp);
+    if (ferror(tmpfp)) {
+        ret = -1;
+        goto out;
+    }
+
+    /*  Check if only options have changed. No need to reload the
+     *  volfile if topology hasn't changed.
+     *  glusterfs_volfile_reconfigure returns 3 possible return states
+     *  return 0	     =======> reconfiguration of options has succeeded
+     *  return 1	     =======> the graph has to be reconstructed and all the
+     * xlators should be inited return -1(or -ve) =======> Some Internal Error
+     * occurred during the operation
+     */
+
+    ret = gf_volfile_reconfigure(fs->oldvollen, tmpfp, fs->ctx, fs->oldvolfile);
+    if (ret == 0) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "No need to re-load "
+                     "volfile, reconfigure done");
+        ret = glusterfs_oldvolfile_update(fs, rsp.spec, size);
+        goto out;
+    }
+
+    if (ret < 0) {
+        gf_msg_debug("glusterfsd-mgmt", 0, "Reconfigure failed !!");
+        goto out;
+    }
+
+    ret = glfs_process_volfp(fs, tmpfp);
+    /* tmpfp closed */
+    tmpfp = NULL;
+    tmp_fd = -1;
+    if (ret)
+        goto out;
+
+    ret = glusterfs_oldvolfile_update(fs, rsp.spec, size);
+out:
+    STACK_DESTROY(frame->root);
+
+    if (rsp.spec)
+        free(rsp.spec);
+
+    if (dict)
+        dict_unref(dict);
+
+    // Stop if server is running at an unsupported op-version
+    if (ENOTSUP == ret) {
+        gf_msg("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION,
+               "Server is operating at an op-version which is not "
+               "supported");
+        errno = ENOTSUP;
+        glfs_init_done(fs, -1);
+    }
+
+    if (ret && ctx && !ctx->active) {
+        /* Do it only for the first time */
+        /* Failed to get the volume file, something wrong,
+           restart the process */
+        gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "failed to fetch volume file (key:%s)",
+               ctx->cmd_args.volfile_id);
+        if (!need_retry) {
+            if (!errno)
+                errno = EINVAL;
+            glfs_init_done(fs, -1);
         }
+    }
 
-        tmpfp = fdopen (tmp_fd, "w+b");
-        if (!tmpfp) {
-                ret = -1;
-                goto out;
-        }
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
 
-	fwrite (rsp.spec, size, 1, tmpfp);
-	fflush (tmpfp);
-	if (ferror (tmpfp)) {
-		ret = -1;
-		goto out;
-	}
-
-	/*  Check if only options have changed. No need to reload the
-	*  volfile if topology hasn't changed.
-	*  glusterfs_volfile_reconfigure returns 3 possible return states
-	*  return 0	     =======> reconfiguration of options has succeeded
-	*  return 1	     =======> the graph has to be reconstructed and all the xlators should be inited
-	*  return -1(or -ve) =======> Some Internal Error occurred during the operation
-	*/
-
-        ret = gf_volfile_reconfigure (fs->oldvollen, tmpfp, fs->ctx,
-                                      fs->oldvolfile);
-	if (ret == 0) {
-		gf_msg_debug ("glusterfsd-mgmt", 0, "No need to re-load "
-                              "volfile, reconfigure done");
-		ret = glusterfs_oldvolfile_update (fs, rsp.spec, size);
-		goto out;
-	}
-
-	if (ret < 0) {
-		gf_msg_debug ("glusterfsd-mgmt", 0, "Reconfigure failed !!");
-		goto out;
-	}
-
-	ret = glfs_process_volfp (fs, tmpfp);
-	/* tmpfp closed */
-	tmpfp = NULL;
-        tmp_fd = -1;
-	if (ret)
-		goto out;
-
-	ret = glusterfs_oldvolfile_update (fs, rsp.spec, size);
-out:
-	STACK_DESTROY (frame->root);
-
-	if (rsp.spec)
-		free (rsp.spec);
-
-        if (dict)
-                dict_unref (dict);
-
-	// Stop if server is running at an unsupported op-version
-	if (ENOTSUP == ret) {
-		gf_msg ("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION,
-                        "Server is operating at an op-version which is not "
-                        "supported");
-		errno = ENOTSUP;
-		glfs_init_done (fs, -1);
-	}
-
-	if (ret && ctx && !ctx->active) {
-		/* Do it only for the first time */
-		/* Failed to get the volume file, something wrong,
-		   restart the process */
-		gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
-                        API_MSG_INVALID_ENTRY,
-			"failed to fetch volume file (key:%s)",
-			ctx->cmd_args.volfile_id);
-		if (!need_retry) {
-			if (!errno)
-				errno = EINVAL;
-			glfs_init_done (fs, -1);
-		}
-	}
-
-	if (tmpfp)
-		fclose (tmpfp);
-        else if (tmp_fd != -1)
-                sys_close (tmp_fd);
-
-	return 0;
+    return 0;
 }
 
-
 int
-glfs_volfile_fetch (struct glfs *fs)
+glfs_volfile_fetch(struct glfs *fs)
 {
-	cmd_args_t	 *cmd_args = NULL;
-	gf_getspec_req	  req = {0, };
-	int		  ret = 0;
-	call_frame_t	 *frame = NULL;
-	glusterfs_ctx_t	 *ctx = NULL;
-        dict_t           *dict = NULL;
-
-	ctx = fs->ctx;
-	cmd_args = &ctx->cmd_args;
-
-	frame = create_frame (THIS, ctx->pool);
-
-	req.key = cmd_args->volfile_id;
-	req.flags = 0;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED,
-                        "Failed to set min-op-version in request dict");
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
-                        API_MSG_DICT_SET_FAILED,
-                        "Failed to set max-op-version in request dict");
-                goto out;
-        }
-
-        /* Ask for a list of volfile (glusterd2 only) servers */
-        if (GF_CLIENT_PROCESS == ctx->process_mode) {
-                req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
-        }
-
-        ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                        API_MSG_DICT_SERIALIZE_FAILED,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
-
-	ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-				   GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk,
-				   (xdrproc_t)xdr_gf_getspec_req);
+    cmd_args_t *cmd_args = NULL;
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+
+    ctx = fs->ctx;
+    cmd_args = &ctx->cmd_args;
+
+    frame = create_frame(THIS, ctx->pool);
+
+    req.key = cmd_args->volfile_id;
+    req.flags = 0;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+               "Failed to set min-op-version in request dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+               "Failed to set max-op-version in request dict");
+        goto out;
+    }
+
+    /* Ask for a list of volfile (glusterd2 only) servers */
+    if (GF_CLIENT_PROCESS == ctx->process_mode) {
+        req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
+    }
+
+    ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, API_MSG_DICT_SERIALIZE_FAILED,
+               "Failed to serialize dictionary");
+        goto out;
+    }
+
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GETSPEC, glfs_mgmt_getspec_cbk,
+                              (xdrproc_t)xdr_gf_getspec_req);
 out:
-        if (req.xdata.xdata_val)
-                GF_FREE(req.xdata.xdata_val);
-        if (dict)
-                dict_unref (dict);
+    if (req.xdata.xdata_val)
+        GF_FREE(req.xdata.xdata_val);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-		 void *data)
+mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                void *data)
 {
-	xlator_t	*this = NULL;
-	glusterfs_ctx_t *ctx = NULL;
-        server_cmdline_t *server = NULL;
-        rpc_transport_t  *rpc_trans = NULL;
-	struct glfs	 *fs = NULL;
-	int		 ret = 0;
-	struct dnscache6 *dnscache = NULL;
-
-	this = mydata;
-        rpc_trans = rpc->conn.trans;
-
-	ctx = this->ctx;
-	if (!ctx)
-		goto out;
-
-	fs = ((xlator_t *)ctx->master)->private;
-
-	switch (event) {
-	case RPC_CLNT_DISCONNECT:
-		if (!ctx->active) {
-                        if (rpc_trans->connect_failed)
-                                gf_msg ("glfs-mgmt", GF_LOG_ERROR, 0,
-                                        API_MSG_REMOTE_HOST_CONN_FAILED,
-                                        "failed to connect to remote-host: %s",
-                                        ctx->cmd_args.volfile_server);
-                        else
-                                gf_msg ("glfs-mgmt", GF_LOG_INFO, 0,
-                                        API_MSG_REMOTE_HOST_CONN_FAILED,
-                                        "disconnected from remote-host: %s",
-                                        ctx->cmd_args.volfile_server);
-
-                        if (!rpc->disabled) {
-                                /*
-                                 * Check if dnscache is exhausted for current server
-                                 * and continue until cache is exhausted
-                                 */
-                                dnscache = rpc_trans->dnscache;
-                                if (dnscache && dnscache->next) {
-                                        break;
-                                }
-                        }
-                        server = ctx->cmd_args.curr_server;
-                        if (server->list.next == &ctx->cmd_args.volfile_servers) {
-                                errno = ENOTCONN;
-                                gf_msg ("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
-                                        API_MSG_VOLFILE_SERVER_EXHAUST,
-                                        "Exhausted all volfile servers");
-                                glfs_init_done (fs, -1);
-                                break;
-                        }
-                        server = list_entry (server->list.next, typeof(*server),
-                                             list);
-                        ctx->cmd_args.curr_server = server;
-                        ctx->cmd_args.volfile_server_port = server->port;
-                        ctx->cmd_args.volfile_server = server->volfile_server;
-                        ctx->cmd_args.volfile_server_transport = server->transport;
-
-                        ret = dict_set_str (rpc_trans->options,
-                                            "transport-type",
-                                            server->transport);
-                        if (ret != 0) {
-                                gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                                        API_MSG_DICT_SET_FAILED,
-                                        "failed to set transport-type: %s",
-                                        server->transport);
-                                errno = ENOTCONN;
-                                glfs_init_done (fs, -1);
-                                break;
-                        }
-
-                        if (strcmp(server->transport, "unix") == 0) {
-                                ret = dict_set_str (rpc_trans->options,
-                                                    "transport.socket.connect-path",
-                                                    server->volfile_server);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set socket.connect-path: %s",
-                                                server->volfile_server);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-                                /* delete the remote-host and remote-port keys
-                                 * in case they were set while looping through
-                                 * list of volfile servers previously
-                                 */
-                                dict_del (rpc_trans->options, "remote-host");
-                                dict_del (rpc_trans->options, "remote-port");
-                        } else {
-                                ret = dict_set_int32 (rpc_trans->options,
-                                                      "remote-port",
-                                                      server->port);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set remote-port: %d",
-                                                server->port);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-
-                                ret = dict_set_str (rpc_trans->options,
-                                                    "remote-host",
-                                                    server->volfile_server);
-                                if (ret != 0) {
-                                        gf_msg ("glfs-mgmt", GF_LOG_ERROR,
-                                                ENOTCONN,
-                                                API_MSG_DICT_SET_FAILED,
-                                                "failed to set remote-host: %s",
-                                                server->volfile_server);
-                                        errno = ENOTCONN;
-                                        glfs_init_done (fs, -1);
-                                        break;
-                                }
-                                /* delete the "transport.socket.connect-path"
-                                 * key in case if it was set while looping
-                                 * through list of volfile servers previously
-                                 */
-                                dict_del (rpc_trans->options,
-                                          "transport.socket.connect-path");
-                        }
-
-                        gf_msg ("glfs-mgmt", GF_LOG_INFO, 0,
-                                API_MSG_VOLFILE_CONNECTING,
-                                "connecting to next volfile server %s"
-                                " at port %d with transport: %s",
-                                server->volfile_server, server->port,
-                                server->transport);
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    server_cmdline_t *server = NULL;
+    rpc_transport_t *rpc_trans = NULL;
+    struct glfs *fs = NULL;
+    int ret = 0;
+    struct dnscache6 *dnscache = NULL;
+
+    this = mydata;
+    rpc_trans = rpc->conn.trans;
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto out;
+
+    fs = ((xlator_t *)ctx->master)->private;
+
+    switch (event) {
+        case RPC_CLNT_DISCONNECT:
+            if (!ctx->active) {
+                if (rpc_trans->connect_failed)
+                    gf_msg("glfs-mgmt", GF_LOG_ERROR, 0,
+                           API_MSG_REMOTE_HOST_CONN_FAILED,
+                           "failed to connect to remote-host: %s",
+                           ctx->cmd_args.volfile_server);
+                else
+                    gf_msg("glfs-mgmt", GF_LOG_INFO, 0,
+                           API_MSG_REMOTE_HOST_CONN_FAILED,
+                           "disconnected from remote-host: %s",
+                           ctx->cmd_args.volfile_server);
+
+                if (!rpc->disabled) {
+                    /*
+                     * Check if dnscache is exhausted for current server
+                     * and continue until cache is exhausted
+                     */
+                    dnscache = rpc_trans->dnscache;
+                    if (dnscache && dnscache->next) {
+                        break;
+                    }
                 }
-                break;
-	case RPC_CLNT_CONNECT:
-		ret = glfs_volfile_fetch (fs);
-		if (ret && (ctx->active == NULL)) {
-			/* Do it only for the first time */
-			/* Exit the process.. there are some wrong options */
-			gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-				"failed to fetch volume file (key:%s)",
-                                ctx->cmd_args.volfile_id);
-                        errno = EINVAL;
-                        glfs_init_done (fs, -1);
+                server = ctx->cmd_args.curr_server;
+                if (server->list.next == &ctx->cmd_args.volfile_servers) {
+                    errno = ENOTCONN;
+                    gf_msg("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
+                           API_MSG_VOLFILE_SERVER_EXHAUST,
+                           "Exhausted all volfile servers");
+                    glfs_init_done(fs, -1);
+                    break;
+                }
+                server = list_entry(server->list.next, typeof(*server), list);
+                ctx->cmd_args.curr_server = server;
+                ctx->cmd_args.volfile_server_port = server->port;
+                ctx->cmd_args.volfile_server = server->volfile_server;
+                ctx->cmd_args.volfile_server_transport = server->transport;
+
+                ret = dict_set_str(rpc_trans->options, "transport-type",
+                                   server->transport);
+                if (ret != 0) {
+                    gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                           API_MSG_DICT_SET_FAILED,
+                           "failed to set transport-type: %s",
+                           server->transport);
+                    errno = ENOTCONN;
+                    glfs_init_done(fs, -1);
+                    break;
                 }
 
-                break;
-	default:
-		break;
-	}
+                if (strcmp(server->transport, "unix") == 0) {
+                    ret = dict_set_str(rpc_trans->options,
+                                       "transport.socket.connect-path",
+                                       server->volfile_server);
+                    if (ret != 0) {
+                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                               API_MSG_DICT_SET_FAILED,
+                               "failed to set socket.connect-path: %s",
+                               server->volfile_server);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+                    /* delete the remote-host and remote-port keys
+                     * in case they were set while looping through
+                     * list of volfile servers previously
+                     */
+                    dict_del(rpc_trans->options, "remote-host");
+                    dict_del(rpc_trans->options, "remote-port");
+                } else {
+                    ret = dict_set_int32(rpc_trans->options, "remote-port",
+                                         server->port);
+                    if (ret != 0) {
+                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                               API_MSG_DICT_SET_FAILED,
+                               "failed to set remote-port: %d", server->port);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+
+                    ret = dict_set_str(rpc_trans->options, "remote-host",
+                                       server->volfile_server);
+                    if (ret != 0) {
+                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                               API_MSG_DICT_SET_FAILED,
+                               "failed to set remote-host: %s",
+                               server->volfile_server);
+                        errno = ENOTCONN;
+                        glfs_init_done(fs, -1);
+                        break;
+                    }
+                    /* delete the "transport.socket.connect-path"
+                     * key in case if it was set while looping
+                     * through list of volfile servers previously
+                     */
+                    dict_del(rpc_trans->options,
+                             "transport.socket.connect-path");
+                }
+
+                gf_msg("glfs-mgmt", GF_LOG_INFO, 0, API_MSG_VOLFILE_CONNECTING,
+                       "connecting to next volfile server %s"
+                       " at port %d with transport: %s",
+                       server->volfile_server, server->port, server->transport);
+            }
+            break;
+        case RPC_CLNT_CONNECT:
+            ret = glfs_volfile_fetch(fs);
+            if (ret && (ctx->active == NULL)) {
+                /* Do it only for the first time */
+                /* Exit the process.. there are some wrong options */
+                gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+                       "failed to fetch volume file (key:%s)",
+                       ctx->cmd_args.volfile_id);
+                errno = EINVAL;
+                glfs_init_done(fs, -1);
+            }
+
+            break;
+        default:
+            break;
+    }
 out:
-	return 0;
+    return 0;
 }
 
-
 int
-glusterfs_mgmt_notify (int32_t op, void *data, ...)
+glusterfs_mgmt_notify(int32_t op, void *data, ...)
 {
-	int ret = 0;
+    int ret = 0;
 
-	switch (op)
-	{
-		case GF_EN_DEFRAG_STATUS:
-			break;
+    switch (op) {
+        case GF_EN_DEFRAG_STATUS:
+            break;
 
-		default:
-			break;
-	}
+        default:
+            break;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_mgmt_init (struct glfs *fs)
+glfs_mgmt_init(struct glfs *fs)
 {
-	cmd_args_t		*cmd_args = NULL;
-	struct rpc_clnt		*rpc = NULL;
-	dict_t			*options = NULL;
-	int			ret = -1;
-	int			port = GF_DEFAULT_BASE_PORT;
-	char			*host = NULL;
-	glusterfs_ctx_t		*ctx = NULL;
-
-	ctx = fs->ctx;
-	cmd_args = &ctx->cmd_args;
-
-	if (ctx->mgmt)
-		return 0;
-
-	if (cmd_args->volfile_server_port)
-		port = cmd_args->volfile_server_port;
-
-	if (cmd_args->volfile_server) {
-		host = cmd_args->volfile_server;
-        } else if (cmd_args->volfile_server_transport &&
-                   !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                host = DEFAULT_GLUSTERD_SOCKFILE;
-        } else {
-                host = "localhost";
-        }
-
-        if (cmd_args->volfile_server_transport &&
-            !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                ret = rpc_transport_unix_options_build (&options, host, 0);
-        } else {
-                ret = rpc_transport_inet_options_build (&options, host, port);
-        }
-
-	if (ret)
-		goto out;
-
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
-                ctx->secure_mgmt = 1;
-                ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-
-	rpc = rpc_clnt_new (options, THIS, THIS->name, 8);
-	if (!rpc) {
-		ret = -1;
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_CREATE_RPC_CLIENT_FAILED,
-			"failed to create rpc clnt");
-		goto out;
-	}
-
-	ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS);
-	if (ret) {
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_REG_NOTIFY_FUNC_FAILED,
-			"failed to register notify function");
-		goto out;
-	}
-
-	ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS);
-	if (ret) {
-		gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        API_MSG_REG_CBK_FUNC_FAILED,
-			"failed to register callback function");
-		goto out;
-	}
-
-	ctx->notify = glusterfs_mgmt_notify;
-
-	/* This value should be set before doing the 'rpc_clnt_start()' as
-	   the notify function uses this variable */
-	ctx->mgmt = rpc;
-
-	ret = rpc_clnt_start (rpc);
+    cmd_args_t *cmd_args = NULL;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = GF_DEFAULT_BASE_PORT;
+    char *host = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = fs->ctx;
+    cmd_args = &ctx->cmd_args;
+
+    if (ctx->mgmt)
+        return 0;
+
+    if (cmd_args->volfile_server_port)
+        port = cmd_args->volfile_server_port;
+
+    if (cmd_args->volfile_server) {
+        host = cmd_args->volfile_server;
+    } else if (cmd_args->volfile_server_transport &&
+               !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        host = DEFAULT_GLUSTERD_SOCKFILE;
+    } else {
+        host = "localhost";
+    }
+
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        ret = rpc_transport_unix_options_build(&options, host, 0);
+    } else {
+        ret = rpc_transport_inet_options_build(&options, host, port);
+    }
+
+    if (ret)
+        goto out;
+
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        ctx->secure_mgmt = 1;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+
+    rpc = rpc_clnt_new(options, THIS, THIS->name, 8);
+    if (!rpc) {
+        ret = -1;
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_CREATE_RPC_CLIENT_FAILED,
+               "failed to create rpc clnt");
+        goto out;
+    }
+
+    ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_NOTIFY_FUNC_FAILED,
+               "failed to register notify function");
+        goto out;
+    }
+
+    ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_CBK_FUNC_FAILED,
+               "failed to register callback function");
+        goto out;
+    }
+
+    ctx->notify = glusterfs_mgmt_notify;
+
+    /* This value should be set before doing the 'rpc_clnt_start()' as
+       the notify function uses this variable */
+    ctx->mgmt = rpc;
+
+    ret = rpc_clnt_start(rpc);
 out:
-	return ret;
+    return ret;
 }
diff --git a/api/src/glfs-resolve.c b/api/src/glfs-resolve.c
index 0c4b9651bd4..34794b605e4 100644
--- a/api/src/glfs-resolve.c
+++ b/api/src/glfs-resolve.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
@@ -28,46 +27,47 @@
 #include "inode.h"
 #include "glfs-internal.h"
 
-#define graphid_str(subvol) (uuid_utoa((unsigned char *)subvol->graph->graph_uuid))
+#define graphid_str(subvol)                                                    \
+    (uuid_utoa((unsigned char *)subvol->graph->graph_uuid))
 int
-glfs_first_lookup_safe (xlator_t *subvol)
+glfs_first_lookup_safe(xlator_t *subvol)
 {
-	loc_t  loc = {0, };
-	int    ret = -1;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
 
-	loc.inode = subvol->itable->root;
-	memset (loc.gfid, 0, 16);
-	loc.gfid[15] = 1;
-	loc.path = "/";
-	loc.name = "";
+    loc.inode = subvol->itable->root;
+    memset(loc.gfid, 0, 16);
+    loc.gfid[15] = 1;
+    loc.path = "/";
+    loc.name = "";
 
-	ret = syncop_lookup (subvol, &loc, 0, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_lookup(subvol, &loc, 0, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
 
-	gf_msg_debug (subvol->name, 0, "first lookup complete %d", ret);
+    gf_msg_debug(subvol->name, 0, "first lookup complete %d", ret);
 
-	return ret;
+    return ret;
 }
 
-
 int
-__glfs_first_lookup (struct glfs *fs, xlator_t *subvol)
+__glfs_first_lookup(struct glfs *fs, xlator_t *subvol)
 {
-	int ret = -1;
-
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		ret = glfs_first_lookup_safe (subvol);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
-
-	return ret;
+    int ret = -1;
+
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        ret = glfs_first_lookup_safe(subvol);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
+
+    return ret;
 }
 
-
 /**
  * We have to check if need_lookup flag is set in both old and the new inodes.
  * If its set in oldinode, then directly go ahead and do an explicit lookup.
@@ -76,842 +76,819 @@ __glfs_first_lookup (struct glfs *fs, xlator_t *subvol)
  * below xlators can set their respective contexts.
  */
 inode_t *
-glfs_refresh_inode_safe (xlator_t *subvol, inode_t *oldinode,
-                         gf_boolean_t need_lookup)
+glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
+                        gf_boolean_t need_lookup)
 {
-	loc_t        loc = {0, };
-	int          ret = -1;
-	struct iatt  iatt = {0, };
-	inode_t     *newinode = NULL;
-        gf_boolean_t lookup_needed = _gf_false;
-        uint64_t     ctx_value = LOOKUP_NOT_NEEDED;
-
-
-	if (!oldinode)
-		return NULL;
-
-	if (!need_lookup && oldinode->table->xl == subvol)
-		return inode_ref (oldinode);
-
-	newinode = inode_find (subvol->itable, oldinode->gfid);
-	if (!need_lookup && newinode) {
-
-                lookup_needed = inode_needs_lookup (newinode, THIS);
-                if (!lookup_needed)
-                        return newinode;
-        }
-
-	gf_uuid_copy (loc.gfid, oldinode->gfid);
-        if (!newinode)
-                loc.inode = inode_new (subvol->itable);
-        else
-                loc.inode = newinode;
-
-	if (!loc.inode)
-		return NULL;
-
-	ret = syncop_lookup (subvol, &loc, &iatt, 0, 0, 0);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret) {
-		gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-			"inode refresh of %s failed: %s",
-			uuid_utoa (oldinode->gfid), strerror (errno));
-		loc_wipe (&loc);
-		return NULL;
-	}
-
-	newinode = inode_link (loc.inode, 0, 0, &iatt);
-        if (newinode) {
-                if (newinode == loc.inode)
-                        inode_ctx_set (newinode, THIS, &ctx_value);
-                inode_lookup (newinode);
-        } else {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed",
-                        uuid_utoa ((unsigned char *)&iatt.ia_gfid));
-        }
-
-	loc_wipe (&loc);
-
-	return newinode;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *newinode = NULL;
+    gf_boolean_t lookup_needed = _gf_false;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    if (!oldinode)
+        return NULL;
+
+    if (!need_lookup && oldinode->table->xl == subvol)
+        return inode_ref(oldinode);
+
+    newinode = inode_find(subvol->itable, oldinode->gfid);
+    if (!need_lookup && newinode) {
+        lookup_needed = inode_needs_lookup(newinode, THIS);
+        if (!lookup_needed)
+            return newinode;
+    }
+
+    gf_uuid_copy(loc.gfid, oldinode->gfid);
+    if (!newinode)
+        loc.inode = inode_new(subvol->itable);
+    else
+        loc.inode = newinode;
+
+    if (!loc.inode)
+        return NULL;
+
+    ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret) {
+        gf_msg(subvol->name, GF_LOG_WARNING, errno,
+               API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s",
+               uuid_utoa(oldinode->gfid), strerror(errno));
+        loc_wipe(&loc);
+        return NULL;
+    }
+
+    newinode = inode_link(loc.inode, 0, 0, &iatt);
+    if (newinode) {
+        if (newinode == loc.inode)
+            inode_ctx_set(newinode, THIS, &ctx_value);
+        inode_lookup(newinode);
+    } else {
+        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+               "inode linking of %s failed",
+               uuid_utoa((unsigned char *)&iatt.ia_gfid));
+    }
+
+    loc_wipe(&loc);
+
+    return newinode;
 }
 
-
 inode_t *
-__glfs_refresh_inode (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-                      gf_boolean_t need_lookup)
+__glfs_refresh_inode(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                     gf_boolean_t need_lookup)
 {
-	inode_t *newinode = NULL;
-
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		newinode = glfs_refresh_inode_safe (subvol, inode, need_lookup);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
-
-	return newinode;
+    inode_t *newinode = NULL;
+
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        newinode = glfs_refresh_inode_safe(subvol, inode, need_lookup);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
+
+    return newinode;
 }
 
 int
-priv_glfs_loc_touchup (loc_t *loc)
+priv_glfs_loc_touchup(loc_t *loc)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        ret = loc_touchup (loc, loc->name);
-        if (ret < 0) {
-                errno = -ret;
-                ret = -1;
-        }
+    ret = loc_touchup(loc, loc->name);
+    if (ret < 0) {
+        errno = -ret;
+        ret = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0);
 
 int
-glfs_resolve_symlink (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-		      char **lpath)
+glfs_resolve_symlink(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                     char **lpath)
 {
-	loc_t  loc = {0, };
-	char  *path = NULL;
-	char  *rpath = NULL;
-	int    ret = -1;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-	ret = inode_path (inode, NULL, &rpath);
-	if (ret < 0)
-		goto out;
-	loc.path = rpath;
-
-	ret = syncop_readlink (subvol, &loc, &path, 4096, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-
-	if (ret < 0)
-		goto out;
-
-	if (lpath)
-		*lpath = path;
+    loc_t loc = {
+        0,
+    };
+    char *path = NULL;
+    char *rpath = NULL;
+    int ret = -1;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    ret = inode_path(inode, NULL, &rpath);
+    if (ret < 0)
+        goto out;
+    loc.path = rpath;
+
+    ret = syncop_readlink(subvol, &loc, &path, 4096, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+
+    if (ret < 0)
+        goto out;
+
+    if (lpath)
+        *lpath = path;
 out:
-	loc_wipe (&loc);
-	return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
-
 int
-glfs_resolve_base (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-		   struct iatt *iatt)
+glfs_resolve_base(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                  struct iatt *iatt)
 {
-	loc_t       loc = {0, };
-	int         ret = -1;
-	char       *path = NULL;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	ret = inode_path (loc.inode, NULL, &path);
-	loc.path = path;
-	if (ret < 0)
-		goto out;
-
-	ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    ret = inode_path(loc.inode, NULL, &path);
+    loc.path = path;
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return ret;
+    return ret;
 }
 /*
  * This function can be used to call named lookup on root.
  * If you use glfs_resolve_base, that will be a nameless lookup.
  */
 static int
-glfs_resolve_root (struct glfs *fs, xlator_t *subvol, inode_t *inode,
-                   struct iatt *iatt)
+glfs_resolve_root(struct glfs *fs, xlator_t *subvol, inode_t *inode,
+                  struct iatt *iatt)
 {
-        loc_t       loc = {0, };
-        int         ret = -1;
-        char       *path = NULL;
-
-        loc.inode = inode_ref (inode);
-
-        ret = inode_path (loc.inode, ".", &path);
-        loc.path = path;
-        loc.name = ".";
-        /* Having a value in loc.name will help to bypass md-cache check for
-         * nameless lookup.
-         * TODO: Re-visit on nameless lookup and md-cache.
-         * Github issue : https://github.com/gluster/glusterfs/issues/232
-         */
-        loc.parent = inode_ref (inode);
-        if (ret < 0)
-                goto out;
-
-        ret = syncop_lookup (subvol, &loc, iatt, NULL, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+
+    loc.inode = inode_ref(inode);
+
+    ret = inode_path(loc.inode, ".", &path);
+    loc.path = path;
+    loc.name = ".";
+    /* Having a value in loc.name will help to bypass md-cache check for
+     * nameless lookup.
+     * TODO: Re-visit on nameless lookup and md-cache.
+     * Github issue : https://github.com/gluster/glusterfs/issues/232
+     */
+    loc.parent = inode_ref(inode);
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, iatt, NULL, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 inode_t *
-glfs_resolve_component (struct glfs *fs, xlator_t *subvol, inode_t *parent,
-			const char *component, struct iatt *iatt,
-			int force_lookup)
+glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
+                       const char *component, struct iatt *iatt,
+                       int force_lookup)
 {
-	loc_t        loc = {0, };
-	inode_t     *inode = NULL;
-        inode_t     *temp_parent = NULL;
-	int          reval = 0;
-	int          ret = -1;
-	int          glret = -1;
-	struct iatt  ciatt = {0, };
-	uuid_t       gfid;
-	dict_t      *xattr_req = NULL;
-        uint64_t     ctx_value = LOOKUP_NOT_NEEDED;
-
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, parent->gfid);
-
-        if (__is_root_gfid (parent->gfid) &&
-            ((strcmp (component, ".") == 0) ||
-             (strcmp (component, "..") == 0) ||
-             (strcmp (component, "") == 0))) {
-                if (!force_lookup) {
-                        inode = inode_ref (parent);
-                } else {
-                        ret = glfs_resolve_root (fs, subvol, parent, &ciatt);
-                        if (!ret)
-                                inode = inode_ref (parent);
-                }
-                goto found;
+    loc_t loc = {
+        0,
+    };
+    inode_t *inode = NULL;
+    inode_t *temp_parent = NULL;
+    int reval = 0;
+    int ret = -1;
+    int glret = -1;
+    struct iatt ciatt = {
+        0,
+    };
+    uuid_t gfid;
+    dict_t *xattr_req = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+
+    if (__is_root_gfid(parent->gfid) &&
+        ((strcmp(component, ".") == 0) || (strcmp(component, "..") == 0) ||
+         (strcmp(component, "") == 0))) {
+        if (!force_lookup) {
+            inode = inode_ref(parent);
+        } else {
+            ret = glfs_resolve_root(fs, subvol, parent, &ciatt);
+            if (!ret)
+                inode = inode_ref(parent);
+        }
+        goto found;
+    }
+    /* *
+     * if the component name is either "." or "..", it will try to
+     * resolve that if inode has a proper parent (named lookup).
+     *
+     * Below condition works like this
+     *
+     * Example 1 :
+     * Path /out_dir/dir/in_dir/.
+     *     In put values :
+     *         parent = in_dir
+     *         component : "."
+     *
+     *      Out put values:
+     *         parent : dir
+     *         component : "in_dir"
+     *
+     * Example 2 :
+     * Path /out_dir/dir/in_dir/..
+     *     In put values :
+     *         parent = in_dir
+     *         component : ".."
+     *
+     *     Out put values:
+     *         parent : output_dir
+     *         component : "dir"
+     *
+     * In case of nameless lookup, both "." and ".." retained
+     */
+
+    if (strcmp(component, ".") == 0) {
+        loc.inode = inode_ref(parent);
+        temp_parent = inode_parent(loc.inode, 0, 0);
+        if (temp_parent) {
+            inode_unref(loc.parent);
+            loc.parent = temp_parent;
+            inode_find_directory_name(loc.inode, &loc.name);
         }
-        /* *
-        * if the component name is either "." or "..", it will try to
-        * resolve that if inode has a proper parent (named lookup).
-        *
-        * Below condition works like this
-        *
-        * Example 1 :
-        * Path /out_dir/dir/in_dir/.
-        *     In put values :
-        *         parent = in_dir
-        *         component : "."
-        *
-        *      Out put values:
-        *         parent : dir
-        *         component : "in_dir"
-        *
-        * Example 2 :
-        * Path /out_dir/dir/in_dir/..
-        *     In put values :
-        *         parent = in_dir
-        *         component : ".."
-        *
-        *     Out put values:
-        *         parent : output_dir
-        *         component : "dir"
-        *
-        * In case of nameless lookup, both "." and ".." retained
-        */
 
-        if (strcmp (component, ".") == 0) {
-                loc.inode = inode_ref (parent);
-                temp_parent = inode_parent (loc.inode, 0, 0);
-                if (temp_parent) {
-                        inode_unref (loc.parent);
-                        loc.parent = temp_parent;
-                        inode_find_directory_name (loc.inode, &loc.name);
-                }
+    } else if (strcmp(component, "..") == 0) {
+        loc.inode = inode_parent(parent, 0, 0);
+        if (loc.inode) {
+            temp_parent = inode_parent(loc.inode, 0, 0);
+            if (temp_parent) {
+                inode_unref(loc.parent);
+                loc.parent = temp_parent;
+                inode_find_directory_name(loc.inode, &loc.name);
+            } else if (__is_root_gfid(loc.inode->gfid)) {
+                inode_unref(loc.parent);
+                loc.parent = inode_ref(loc.inode);
+                loc.name = "";
+            } else {
+                inode_unref(loc.inode);
+                loc.inode = NULL;
+            }
+        }
+    } else
+        loc.inode = inode_grep(parent->table, parent, component);
 
-        } else if (strcmp (component, "..") == 0) {
-                loc.inode = inode_parent (parent, 0, 0);
-                if (loc.inode) {
-                        temp_parent = inode_parent (loc.inode, 0, 0);
-                        if (temp_parent) {
-                                inode_unref (loc.parent);
-                                loc.parent = temp_parent;
-                                inode_find_directory_name (loc.inode, &loc.name);
-                        } else if (__is_root_gfid (loc.inode->gfid)) {
-                                inode_unref (loc.parent);
-                                loc.parent = inode_ref (loc.inode);
-                                loc.name = "";
-                        } else {
-                                inode_unref (loc.inode);
-                                loc.inode = NULL;
-                        }
+    if (!loc.name)
+        loc.name = component;
 
-                }
-        } else
-                loc.inode = inode_grep (parent->table, parent, component);
-
-        if (!loc.name)
-                loc.name = component;
-
-	if (loc.inode) {
-		gf_uuid_copy (loc.gfid, loc.inode->gfid);
-		reval = 1;
-
-                if (!(force_lookup || inode_needs_lookup (loc.inode, THIS))) {
-			inode = inode_ref (loc.inode);
-			goto found;
-		}
-	} else {
-		gf_uuid_generate (gfid);
-		loc.inode = inode_new (parent->table);
-                if (!loc.inode) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+    if (loc.inode) {
+        gf_uuid_copy(loc.gfid, loc.inode->gfid);
+        reval = 1;
 
-                xattr_req = dict_new ();
-                if (!xattr_req) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+        if (!(force_lookup || inode_needs_lookup(loc.inode, THIS))) {
+            inode = inode_ref(loc.inode);
+            goto found;
+        }
+    } else {
+        gf_uuid_generate(gfid);
+        loc.inode = inode_new(parent->table);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-                ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-                if (ret) {
-                        errno = ENOMEM;
-                        goto out;
-                }
+        xattr_req = dict_new();
+        if (!xattr_req) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-	}
-
-	glret = priv_glfs_loc_touchup (&loc);
-	if (glret < 0) {
-		ret = -1;
-		goto out;
-	}
-
-        ret = syncop_lookup (subvol, &loc, &ciatt, NULL, xattr_req, NULL);
-        if (ret && reval) {
-                /*
-                 * A stale mapping might exist for a dentry/inode that has been
-                 * removed from another client.
-                 */
-                if (-ret == ENOENT) {
-                        inode_unlink(loc.inode, loc.parent,
-                                     loc.name);
-                        if (!inode_has_dentry (loc.inode))
-                                inode_forget (loc.inode, 0);
-                }
+        ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+        if (ret) {
+            errno = ENOMEM;
+            goto out;
+        }
+    }
+
+    glret = priv_glfs_loc_touchup(&loc);
+    if (glret < 0) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL);
+    if (ret && reval) {
+        /*
+         * A stale mapping might exist for a dentry/inode that has been
+         * removed from another client.
+         */
+        if (-ret == ENOENT) {
+            inode_unlink(loc.inode, loc.parent, loc.name);
+            if (!inode_has_dentry(loc.inode))
+                inode_forget(loc.inode, 0);
+        }
 
-		inode_unref (loc.inode);
-	        gf_uuid_clear (loc.gfid);
-		loc.inode = inode_new (parent->table);
-		if (!loc.inode) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		xattr_req = dict_new ();
-		if (!xattr_req) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		gf_uuid_generate (gfid);
-
-		ret = dict_set_gfuuid (xattr_req, "gfid-req", gfid, true);
-		if (ret) {
-			errno = ENOMEM;
-			goto out;
-		}
-
-		ret = syncop_lookup (subvol, &loc, &ciatt, NULL,
-				     xattr_req, NULL);
-	}
-        DECODE_SYNCOP_ERR (ret);
-	if (ret)
-		goto out;
-
-	inode = inode_link (loc.inode, loc.parent, component, &ciatt);
+        inode_unref(loc.inode);
+        gf_uuid_clear(loc.gfid);
+        loc.inode = inode_new(parent->table);
+        if (!loc.inode) {
+            errno = ENOMEM;
+            goto out;
+        }
 
-        if (!inode) {
-                gf_msg (subvol->name, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_LINK_FAILED,
-                        "inode linking of %s failed",
-                        uuid_utoa ((unsigned char *)&ciatt.ia_gfid));
-                goto out;
-        } else if (inode == loc.inode)
-                inode_ctx_set (inode, THIS, &ctx_value);
-found:
-	if (inode) {
-                ciatt.ia_type = inode->ia_type;
-		inode_lookup (inode);
+        xattr_req = dict_new();
+        if (!xattr_req) {
+            errno = ENOMEM;
+            goto out;
+        }
+
+        gf_uuid_generate(gfid);
+
+        ret = dict_set_gfuuid(xattr_req, "gfid-req", gfid, true);
+        if (ret) {
+            errno = ENOMEM;
+            goto out;
         }
-	if (iatt)
-		*iatt = ciatt;
+
+        ret = syncop_lookup(subvol, &loc, &ciatt, NULL, xattr_req, NULL);
+    }
+    DECODE_SYNCOP_ERR(ret);
+    if (ret)
+        goto out;
+
+    inode = inode_link(loc.inode, loc.parent, component, &ciatt);
+
+    if (!inode) {
+        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+               "inode linking of %s failed",
+               uuid_utoa((unsigned char *)&ciatt.ia_gfid));
+        goto out;
+    } else if (inode == loc.inode)
+        inode_ctx_set(inode, THIS, &ctx_value);
+found:
+    if (inode) {
+        ciatt.ia_type = inode->ia_type;
+        inode_lookup(inode);
+    }
+    if (iatt)
+        *iatt = ciatt;
 out:
-	if (xattr_req)
-		dict_unref (xattr_req);
-	loc_wipe (&loc);
+    if (xattr_req)
+        dict_unref(xattr_req);
+    loc_wipe(&loc);
 
-	return inode;
+    return inode;
 }
 
-
 int
-priv_glfs_resolve_at (struct glfs *fs, xlator_t *subvol, inode_t *at,
-		 const char *origpath, loc_t *loc, struct iatt *iatt,
-		 int follow, int reval)
+priv_glfs_resolve_at(struct glfs *fs, xlator_t *subvol, inode_t *at,
+                     const char *origpath, loc_t *loc, struct iatt *iatt,
+                     int follow, int reval)
 {
-	inode_t    *inode = NULL;
-	inode_t    *parent = NULL;
-	char       *saveptr = NULL;
-	char       *path = NULL;
-	char       *component = NULL;
-	char       *next_component = NULL;
-	int         ret = -1;
-	struct iatt ciatt = {0, };
-
-	DECLARE_OLD_THIS;
-	__GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
-
-        if (origpath[0] == '\0') {
-                errno = EINVAL;
-                goto invalid_fs;
+    inode_t *inode = NULL;
+    inode_t *parent = NULL;
+    char *saveptr = NULL;
+    char *path = NULL;
+    char *component = NULL;
+    char *next_component = NULL;
+    int ret = -1;
+    struct iatt ciatt = {
+        0,
+    };
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    if (origpath[0] == '\0') {
+        errno = EINVAL;
+        goto invalid_fs;
+    }
+
+    parent = NULL;
+    if (at && origpath[0] != '/') {
+        /* A relative resolution of a path which starts with '/'
+           is equal to an absolute path resolution.
+        */
+        inode = inode_ref(at);
+    } else {
+        inode = inode_ref(subvol->itable->root);
+
+        if (strcmp(origpath, "/") == 0)
+            glfs_resolve_root(fs, subvol, inode, &ciatt);
+    }
+
+    path = gf_strdup(origpath);
+    if (!path)
+        goto invalid_fs;
+
+    for (component = strtok_r(path, "/", &saveptr); component;
+         component = next_component) {
+        next_component = strtok_r(NULL, "/", &saveptr);
+
+        if (parent)
+            inode_unref(parent);
+        parent = inode;
+        inode = glfs_resolve_component(fs, subvol, parent, component, &ciatt,
+                                       /* force hard lookup on the last
+                                          component, as the caller
+                                          wants proper iatt filled
+                                       */
+                                       (reval || (!next_component && iatt)));
+        if (!inode) {
+            ret = -1;
+            break;
         }
 
-	parent = NULL;
-	if (at && origpath[0] != '/') {
-		/* A relative resolution of a path which starts with '/'
-		   is equal to an absolute path resolution.
-		*/
-		inode = inode_ref (at);
-	} else {
-		inode = inode_ref (subvol->itable->root);
-
-		if (strcmp (origpath, "/") == 0)
-                        glfs_resolve_root (fs, subvol, inode, &ciatt);
-	}
-
-        path = gf_strdup (origpath);
-	if (!path)
-		goto invalid_fs;
-
-	for (component = strtok_r (path, "/", &saveptr);
-	     component; component = next_component) {
-
-		next_component = strtok_r (NULL, "/", &saveptr);
-
-		if (parent)
-			inode_unref (parent);
-		parent = inode;
-		inode = glfs_resolve_component (fs, subvol, parent,
-						component, &ciatt,
-						/* force hard lookup on the last
-						   component, as the caller
-						   wants proper iatt filled
-						*/
-						(reval || (!next_component &&
-						iatt)));
-		if (!inode) {
-                        ret = -1;
-			break;
+        if (IA_ISLNK(ciatt.ia_type) && (next_component || follow)) {
+            /* If the component is not the last piece,
+               then following it is necessary even if
+               not requested by the caller
+            */
+            char *lpath = NULL;
+            loc_t sym_loc = {
+                0,
+            };
+
+            if (follow > GLFS_SYMLINK_MAX_FOLLOW) {
+                errno = ELOOP;
+                ret = -1;
+                if (inode) {
+                    inode_unref(inode);
+                    inode = NULL;
                 }
+                break;
+            }
+
+            ret = glfs_resolve_symlink(fs, subvol, inode, &lpath);
+            inode_unref(inode);
+            inode = NULL;
+            if (ret < 0)
+                break;
+
+            ret = priv_glfs_resolve_at(fs, subvol, parent, lpath, &sym_loc,
+                                       /* followed iatt becomes the
+                                          component iatt
+                                       */
+                                       &ciatt,
+                                       /* always recurisvely follow while
+                                          following symlink
+                                       */
+                                       follow + 1, reval);
+            if (ret == 0)
+                inode = inode_ref(sym_loc.inode);
+            loc_wipe(&sym_loc);
+            GF_FREE(lpath);
+        }
 
-		if (IA_ISLNK (ciatt.ia_type) && (next_component || follow)) {
-			/* If the component is not the last piece,
-			   then following it is necessary even if
-			   not requested by the caller
-			*/
-			char *lpath = NULL;
-			loc_t sym_loc = {0,};
-
-			if (follow > GLFS_SYMLINK_MAX_FOLLOW) {
-				errno = ELOOP;
-				ret = -1;
-				if (inode) {
-					inode_unref (inode);
-					inode = NULL;
-				}
-				break;
-			}
-
-			ret = glfs_resolve_symlink (fs, subvol, inode, &lpath);
-			inode_unref (inode);
-			inode = NULL;
-			if (ret < 0)
-				break;
-
-			ret = priv_glfs_resolve_at (fs, subvol, parent, lpath,
-					       &sym_loc,
-					       /* followed iatt becomes the
-						  component iatt
-					       */
-					       &ciatt,
-					       /* always recurisvely follow while
-						  following symlink
-					       */
-					       follow + 1, reval);
-			if (ret == 0)
-				inode = inode_ref (sym_loc.inode);
-			loc_wipe (&sym_loc);
-			GF_FREE (lpath);
-		}
-
-		if (!next_component)
-			break;
-
-		if (!IA_ISDIR (ciatt.ia_type)) {
-			/* next_component exists and this component is
-			   not a directory
-			*/
-			inode_unref (inode);
-			inode = NULL;
-			ret = -1;
-			errno = ENOTDIR;
-			break;
-		}
-	}
-
-	if (parent && next_component)
-		/* resolution failed mid-way */
-		goto out;
-
-	/* At this point, all components up to the last parent directory
-	   have been resolved successfully (@parent). Resolution of basename
-	   might have failed (@inode) if at all.
-	*/
-
-	loc->parent = parent;
-	if (parent) {
-		gf_uuid_copy (loc->pargfid, parent->gfid);
-		loc->name = component;
-	}
-
-	loc->inode = inode;
-	if (inode) {
-		gf_uuid_copy (loc->gfid, inode->gfid);
-		if (iatt)
-			*iatt = ciatt;
-		ret = 0;
-	}
-
-        if (priv_glfs_loc_touchup (loc) < 0) {
-                ret = -1;
+        if (!next_component)
+            break;
+
+        if (!IA_ISDIR(ciatt.ia_type)) {
+            /* next_component exists and this component is
+               not a directory
+            */
+            inode_unref(inode);
+            inode = NULL;
+            ret = -1;
+            errno = ENOTDIR;
+            break;
         }
+    }
+
+    if (parent && next_component)
+        /* resolution failed mid-way */
+        goto out;
+
+    /* At this point, all components up to the last parent directory
+       have been resolved successfully (@parent). Resolution of basename
+       might have failed (@inode) if at all.
+    */
+
+    loc->parent = parent;
+    if (parent) {
+        gf_uuid_copy(loc->pargfid, parent->gfid);
+        loc->name = component;
+    }
+
+    loc->inode = inode;
+    if (inode) {
+        gf_uuid_copy(loc->gfid, inode->gfid);
+        if (iatt)
+            *iatt = ciatt;
+        ret = 0;
+    }
+
+    if (priv_glfs_loc_touchup(loc) < 0) {
+        ret = -1;
+    }
 out:
-	GF_FREE (path);
-        __GLFS_EXIT_FS;
+    GF_FREE(path);
+    __GLFS_EXIT_FS;
 
-	/* do NOT loc_wipe here as only last component might be missing */
+    /* do NOT loc_wipe here as only last component might be missing */
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0);
 
-
 int
-glfs_resolve_path (struct glfs *fs, xlator_t *subvol, const char *origpath,
-		   loc_t *loc, struct iatt *iatt, int follow, int reval)
+glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath,
+                  loc_t *loc, struct iatt *iatt, int follow, int reval)
 {
-	int ret = -1;
-	inode_t *cwd = NULL;
-
-	if (origpath[0] == '/')
-		return priv_glfs_resolve_at (fs, subvol, NULL, origpath, loc,
-                                             iatt, follow, reval);
-
-	cwd = glfs_cwd_get (fs);
-        if (NULL == cwd) {
-                gf_msg (subvol->name, GF_LOG_WARNING, EIO,
-                        API_MSG_GET_CWD_FAILED, "Failed to get cwd");
-                errno = EIO;
-                goto out;
-        }
+    int ret = -1;
+    inode_t *cwd = NULL;
 
-	ret = priv_glfs_resolve_at (fs, subvol, cwd, origpath, loc, iatt,
+    if (origpath[0] == '/')
+        return priv_glfs_resolve_at(fs, subvol, NULL, origpath, loc, iatt,
                                     follow, reval);
-	if (cwd)
-		inode_unref (cwd);
+
+    cwd = glfs_cwd_get(fs);
+    if (NULL == cwd) {
+        gf_msg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
+               "Failed to get cwd");
+        errno = EIO;
+        goto out;
+    }
+
+    ret = priv_glfs_resolve_at(fs, subvol, cwd, origpath, loc, iatt, follow,
+                               reval);
+    if (cwd)
+        inode_unref(cwd);
 
 out:
-	return ret;
+    return ret;
 }
 
-
 int
-priv_glfs_resolve (struct glfs *fs, xlator_t *subvol, const char *origpath,
-	      loc_t *loc, struct iatt *iatt, int reval)
+priv_glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
+                  loc_t *loc, struct iatt *iatt, int reval)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 1, reval);
+    ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 1, reval);
 
-	return ret;
+    return ret;
 }
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0);
 
 int
-glfs_lresolve (struct glfs *fs, xlator_t *subvol, const char *origpath,
-	       loc_t *loc, struct iatt *iatt, int reval)
+glfs_lresolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
+              loc_t *loc, struct iatt *iatt, int reval)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = glfs_resolve_path (fs, subvol, origpath, loc, iatt, 0, reval);
+    ret = glfs_resolve_path(fs, subvol, origpath, loc, iatt, 0, reval);
 
-	return ret;
+    return ret;
 }
 
-
 int
-glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
-			    xlator_t *newsubvol, fd_t *newfd)
+glfs_migrate_fd_locks_safe(struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
+                           xlator_t *newsubvol, fd_t *newfd)
 {
-	dict_t *lockinfo = NULL;
-	int ret = 0;
-	char uuid1[64];
-
-	if (!oldfd->lk_ctx || fd_lk_ctx_empty (oldfd->lk_ctx))
-		return 0;
-
-	newfd->lk_ctx = fd_lk_ctx_ref (oldfd->lk_ctx);
-
-	ret = syncop_fgetxattr (oldsubvol, oldfd, &lockinfo,
-				GF_XATTR_LOCKINFO_KEY, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret < 0) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_FGETXATTR_FAILED,
-			"fgetxattr (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (oldfd->inode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (oldsubvol), oldsubvol->graph->id);
-		goto out;
-	}
-
-	if (!dict_get (lockinfo, GF_XATTR_LOCKINFO_KEY)) {
-		gf_msg (fs->volname, GF_LOG_WARNING, 0,
-                        API_MSG_LOCKINFO_KEY_MISSING,
-			"missing lockinfo key (%s) on graph %s (%d)",
-			uuid_utoa_r (oldfd->inode->gfid, uuid1),
-			graphid_str (oldsubvol), oldsubvol->graph->id);
-		goto out;
-	}
-
-	ret = syncop_fsetxattr (newsubvol, newfd, lockinfo, 0, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	if (ret < 0) {
-		gf_msg (fs->volname, GF_LOG_WARNING, 0,
-                        API_MSG_FSETXATTR_FAILED,
-			"fsetxattr (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newfd->inode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
+    dict_t *lockinfo = NULL;
+    int ret = 0;
+    char uuid1[64];
+
+    if (!oldfd->lk_ctx || fd_lk_ctx_empty(oldfd->lk_ctx))
+        return 0;
+
+    newfd->lk_ctx = fd_lk_ctx_ref(oldfd->lk_ctx);
+
+    ret = syncop_fgetxattr(oldsubvol, oldfd, &lockinfo, GF_XATTR_LOCKINFO_KEY,
+                           NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret < 0) {
+        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
+               "fgetxattr (%s) failed (%s) on graph %s (%d)",
+               uuid_utoa_r(oldfd->inode->gfid, uuid1), strerror(errno),
+               graphid_str(oldsubvol), oldsubvol->graph->id);
+        goto out;
+    }
+
+    if (!dict_get(lockinfo, GF_XATTR_LOCKINFO_KEY)) {
+        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
+               "missing lockinfo key (%s) on graph %s (%d)",
+               uuid_utoa_r(oldfd->inode->gfid, uuid1), graphid_str(oldsubvol),
+               oldsubvol->graph->id);
+        goto out;
+    }
+
+    ret = syncop_fsetxattr(newsubvol, newfd, lockinfo, 0, NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret < 0) {
+        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
+               "fsetxattr (%s) failed (%s) on graph %s (%d)",
+               uuid_utoa_r(newfd->inode->gfid, uuid1), strerror(errno),
+               graphid_str(newsubvol), newsubvol->graph->id);
+        goto out;
+    }
 out:
-	if (lockinfo)
-		dict_unref (lockinfo);
-	return ret;
+    if (lockinfo)
+        dict_unref(lockinfo);
+    return ret;
 }
 
-
 fd_t *
-glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
+glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
 {
-	fd_t *newfd = NULL;
-	inode_t *oldinode = NULL;
-	inode_t *newinode = NULL;
-	xlator_t *oldsubvol = NULL;
-	int ret = -1;
-	loc_t loc = {0, };
-	char uuid1[64];
-
-
-	oldinode = oldfd->inode;
-	oldsubvol = oldinode->table->xl;
-
-	if (oldsubvol == newsubvol)
-		return fd_ref (oldfd);
-
-	if (!oldsubvol->switched) {
-		ret = syncop_fsync (oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL);
-                DECODE_SYNCOP_ERR (ret);
-		if (ret) {
-			gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                                API_MSG_FSYNC_FAILED, "fsync() failed "
-                                "(%s) on %s graph %s (%d)", strerror (errno),
-				uuid_utoa_r (oldfd->inode->gfid, uuid1),
-				graphid_str (oldsubvol), oldsubvol->graph->id);
-		}
-	}
-
-	newinode = glfs_refresh_inode_safe (newsubvol, oldinode, _gf_false);
-	if (!newinode) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_INODE_REFRESH_FAILED,
-			"inode (%s) refresh failed (%s) on graph %s (%d)",
-			uuid_utoa_r (oldinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	newfd = fd_create (newinode, getpid());
-	if (!newfd) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_FDCREATE_FAILED,
-			"fd_create (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	loc.inode = inode_ref (newinode);
-
-        ret = inode_path (oldfd->inode, NULL, (char **)&loc.path);
-        if (ret < 0) {
-                gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
-                        "inode_path failed");
-                goto out;
+    fd_t *newfd = NULL;
+    inode_t *oldinode = NULL;
+    inode_t *newinode = NULL;
+    xlator_t *oldsubvol = NULL;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    char uuid1[64];
+
+    oldinode = oldfd->inode;
+    oldsubvol = oldinode->table->xl;
+
+    if (oldsubvol == newsubvol)
+        return fd_ref(oldfd);
+
+    if (!oldsubvol->switched) {
+        ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL);
+        DECODE_SYNCOP_ERR(ret);
+        if (ret) {
+            gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
+                   "fsync() failed "
+                   "(%s) on %s graph %s (%d)",
+                   strerror(errno), uuid_utoa_r(oldfd->inode->gfid, uuid1),
+                   graphid_str(oldsubvol), oldsubvol->graph->id);
         }
-
-        gf_uuid_copy (loc.gfid, oldinode->gfid);
-
-
-	if (IA_ISDIR (oldinode->ia_type))
-		ret = syncop_opendir (newsubvol, &loc, newfd, NULL, NULL);
-	else
-		ret = syncop_open (newsubvol, &loc,
-				   oldfd->flags & ~(O_TRUNC|O_EXCL|O_CREAT),
-				   newfd, NULL, NULL);
-        DECODE_SYNCOP_ERR (ret);
-	loc_wipe (&loc);
-
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_SYNCOP_OPEN_FAILED,
-			"syncop_open%s (%s) failed (%s) on graph %s (%d)",
-			IA_ISDIR (oldinode->ia_type) ? "dir" : "",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-	ret = glfs_migrate_fd_locks_safe (fs, oldsubvol, oldfd, newsubvol,
-					  newfd);
-
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_WARNING, errno,
-                        API_MSG_LOCK_MIGRATE_FAILED,
-			"lock migration (%s) failed (%s) on graph %s (%d)",
-			uuid_utoa_r (newinode->gfid, uuid1),
-			strerror (errno),
-			graphid_str (newsubvol), newsubvol->graph->id);
-		goto out;
-	}
-
-        newfd->flags = oldfd->flags;
-	fd_bind (newfd);
+    }
+
+    newinode = glfs_refresh_inode_safe(newsubvol, oldinode, _gf_false);
+    if (!newinode) {
+        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_INODE_REFRESH_FAILED,
+               "inode (%s) refresh failed (%s) on graph %s (%d)",
+               uuid_utoa_r(oldinode->gfid, uuid1), strerror(errno),
+               graphid_str(newsubvol), newsubvol->graph->id);
+        goto out;
+    }
+
+    newfd = fd_create(newinode, getpid());
+    if (!newfd) {
+        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FDCREATE_FAILED,
+               "fd_create (%s) failed (%s) on graph %s (%d)",
+               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
+               graphid_str(newsubvol), newsubvol->graph->id);
+        goto out;
+    }
+
+    loc.inode = inode_ref(newinode);
+
+    ret = inode_path(oldfd->inode, NULL, (char **)&loc.path);
+    if (ret < 0) {
+        gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
+               "inode_path failed");
+        goto out;
+    }
+
+    gf_uuid_copy(loc.gfid, oldinode->gfid);
+
+    if (IA_ISDIR(oldinode->ia_type))
+        ret = syncop_opendir(newsubvol, &loc, newfd, NULL, NULL);
+    else
+        ret = syncop_open(newsubvol, &loc,
+                          oldfd->flags & ~(O_TRUNC | O_EXCL | O_CREAT), newfd,
+                          NULL, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    loc_wipe(&loc);
+
+    if (ret) {
+        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
+               "syncop_open%s (%s) failed (%s) on graph %s (%d)",
+               IA_ISDIR(oldinode->ia_type) ? "dir" : "",
+               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
+               graphid_str(newsubvol), newsubvol->graph->id);
+        goto out;
+    }
+
+    ret = glfs_migrate_fd_locks_safe(fs, oldsubvol, oldfd, newsubvol, newfd);
+
+    if (ret) {
+        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
+               "lock migration (%s) failed (%s) on graph %s (%d)",
+               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
+               graphid_str(newsubvol), newsubvol->graph->id);
+        goto out;
+    }
+
+    newfd->flags = oldfd->flags;
+    fd_bind(newfd);
 out:
-	if (newinode)
-		inode_unref (newinode);
+    if (newinode)
+        inode_unref(newinode);
 
-	if (ret) {
-		fd_unref (newfd);
-		newfd = NULL;
-	}
+    if (ret) {
+        fd_unref(newfd);
+        newfd = NULL;
+    }
 
-	return newfd;
+    return newfd;
 }
 
-
 fd_t *
-__glfs_migrate_fd (struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd)
+__glfs_migrate_fd(struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd)
 {
-	fd_t *oldfd = NULL;
-	fd_t *newfd = NULL;
+    fd_t *oldfd = NULL;
+    fd_t *newfd = NULL;
 
-	oldfd = glfd->fd;
+    oldfd = glfd->fd;
 
-	fs->migration_in_progress = 1;
-	pthread_mutex_unlock (&fs->mutex);
-	{
-		newfd = glfs_migrate_fd_safe (fs, newsubvol, oldfd);
-	}
-	pthread_mutex_lock (&fs->mutex);
-	fs->migration_in_progress = 0;
-	pthread_cond_broadcast (&fs->cond);
+    fs->migration_in_progress = 1;
+    pthread_mutex_unlock(&fs->mutex);
+    {
+        newfd = glfs_migrate_fd_safe(fs, newsubvol, oldfd);
+    }
+    pthread_mutex_lock(&fs->mutex);
+    fs->migration_in_progress = 0;
+    pthread_cond_broadcast(&fs->cond);
 
-	return newfd;
+    return newfd;
 }
 
-
 fd_t *
-__glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
+__glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
 {
-	fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-	if (glfd->fd->inode->table->xl == subvol)
-		return fd_ref (glfd->fd);
+    if (glfd->fd->inode->table->xl == subvol)
+        return fd_ref(glfd->fd);
 
-	fd = __glfs_migrate_fd (fs, subvol, glfd);
-	if (!fd)
-		return NULL;
+    fd = __glfs_migrate_fd(fs, subvol, glfd);
+    if (!fd)
+        return NULL;
 
-	if (subvol == fs->active_subvol) {
-		fd_unref (glfd->fd);
-		glfd->fd = fd_ref (fd);
-	}
+    if (subvol == fs->active_subvol) {
+        fd_unref(glfd->fd);
+        glfd->fd = fd_ref(fd);
+    }
 
-	return fd;
+    return fd;
 }
 
-
 fd_t *
-glfs_resolve_fd (struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
+glfs_resolve_fd(struct glfs *fs, xlator_t *subvol, struct glfs_fd *glfd)
 {
-	fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		fd = __glfs_resolve_fd (fs, subvol, glfd);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        fd = __glfs_resolve_fd(fs, subvol, glfd);
+    }
+    glfs_unlock(fs);
 
-	return fd;
+    return fd;
 }
 
-
 void
-__glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol)
+__glfs_migrate_openfds(struct glfs *fs, xlator_t *subvol)
 {
-	struct glfs_fd *glfd = NULL;
-	fd_t *fd = NULL;
-
-	list_for_each_entry (glfd, &fs->openfds, openfds) {
-		if (gf_uuid_is_null (glfd->fd->inode->gfid)) {
-			gf_msg (fs->volname, GF_LOG_INFO, 0,
-                                API_MSG_OPENFD_SKIPPED,
-				"skipping openfd %p/%p in graph %s (%d)",
-				glfd, glfd->fd,	graphid_str(subvol),
-				subvol->graph->id);
-			/* create in progress, defer */
-			continue;
-		}
-
-		fd = __glfs_migrate_fd (fs, subvol, glfd);
-		if (fd) {
-			fd_unref (glfd->fd);
-			glfd->fd = fd;
-		}
-	}
-}
+    struct glfs_fd *glfd = NULL;
+    fd_t *fd = NULL;
+
+    list_for_each_entry(glfd, &fs->openfds, openfds)
+    {
+        if (gf_uuid_is_null(glfd->fd->inode->gfid)) {
+            gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
+                   "skipping openfd %p/%p in graph %s (%d)", glfd, glfd->fd,
+                   graphid_str(subvol), subvol->graph->id);
+            /* create in progress, defer */
+            continue;
+        }
 
+        fd = __glfs_migrate_fd(fs, subvol, glfd);
+        if (fd) {
+            fd_unref(glfd->fd);
+            glfd->fd = fd;
+        }
+    }
+}
 
 /* Note that though it appears that this function executes under fs->mutex,
  * it is not fully executed under fs->mutex. i.e. there are functions like
@@ -921,290 +898,284 @@ __glfs_migrate_openfds (struct glfs *fs, xlator_t *subvol)
  * function need not have the same value by the end of the function.
  */
 xlator_t *
-__glfs_active_subvol (struct glfs *fs)
+__glfs_active_subvol(struct glfs *fs)
 {
-	xlator_t      *new_subvol = NULL;
-	int            ret = -1;
-	inode_t       *new_cwd = NULL;
-
-	if (!fs->next_subvol)
-		return fs->active_subvol;
-
-	new_subvol = fs->mip_subvol = fs->next_subvol;
-        fs->next_subvol = NULL;
-
-	ret = __glfs_first_lookup (fs, new_subvol);
-	if (ret) {
-		gf_msg (fs->volname, GF_LOG_INFO, errno,
-                        API_MSG_FIRST_LOOKUP_GRAPH_FAILED,
-			"first lookup on graph %s (%d) failed (%s)",
-			graphid_str (new_subvol), new_subvol->graph->id,
-			strerror (errno));
-		return NULL;
-	}
-
-	if (fs->cwd) {
-		new_cwd = __glfs_refresh_inode (fs, new_subvol, fs->cwd,
-                                                _gf_false);
-
-		if (!new_cwd) {
-			char buf1[64];
-			gf_msg (fs->volname, GF_LOG_INFO, errno,
-                                API_MSG_CWD_GRAPH_REF_FAILED,
-				"cwd refresh of %s graph %s (%d) failed (%s)",
-				uuid_utoa_r (fs->cwd->gfid, buf1),
-				graphid_str (new_subvol),
-				new_subvol->graph->id, strerror (errno));
-			return NULL;
-		}
-	}
-
-	__glfs_migrate_openfds (fs, new_subvol);
-        /* TODO: Migrate the fds and inodes which have leases to the new graph (issue #350)*/
-
-	/* switching @active_subvol and @cwd
-	   should be atomic
-	*/
-	fs->old_subvol = fs->active_subvol;
-	fs->active_subvol = fs->mip_subvol;
-	fs->mip_subvol = NULL;
-
-	if (new_cwd) {
-		__glfs_cwd_set (fs, new_cwd);
-		inode_unref (new_cwd);
-	}
-
-	gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH,
-                "switched to graph %s (%d)",
-		graphid_str (new_subvol), new_subvol->graph->id);
-
-	return new_subvol;
-}
+    xlator_t *new_subvol = NULL;
+    int ret = -1;
+    inode_t *new_cwd = NULL;
+
+    if (!fs->next_subvol)
+        return fs->active_subvol;
+
+    new_subvol = fs->mip_subvol = fs->next_subvol;
+    fs->next_subvol = NULL;
+
+    ret = __glfs_first_lookup(fs, new_subvol);
+    if (ret) {
+        gf_msg(fs->volname, GF_LOG_INFO, errno,
+               API_MSG_FIRST_LOOKUP_GRAPH_FAILED,
+               "first lookup on graph %s (%d) failed (%s)",
+               graphid_str(new_subvol), new_subvol->graph->id, strerror(errno));
+        return NULL;
+    }
+
+    if (fs->cwd) {
+        new_cwd = __glfs_refresh_inode(fs, new_subvol, fs->cwd, _gf_false);
+
+        if (!new_cwd) {
+            char buf1[64];
+            gf_msg(fs->volname, GF_LOG_INFO, errno,
+                   API_MSG_CWD_GRAPH_REF_FAILED,
+                   "cwd refresh of %s graph %s (%d) failed (%s)",
+                   uuid_utoa_r(fs->cwd->gfid, buf1), graphid_str(new_subvol),
+                   new_subvol->graph->id, strerror(errno));
+            return NULL;
+        }
+    }
 
+    __glfs_migrate_openfds(fs, new_subvol);
+    /* TODO: Migrate the fds and inodes which have leases to the new graph
+     * (issue #350)*/
 
-void
-priv_glfs_subvol_done (struct glfs *fs, xlator_t *subvol)
-{
-	int ref = 0;
-	xlator_t *active_subvol = NULL;
+    /* switching @active_subvol and @cwd
+       should be atomic
+    */
+    fs->old_subvol = fs->active_subvol;
+    fs->active_subvol = fs->mip_subvol;
+    fs->mip_subvol = NULL;
 
-	if (!subvol)
-		return;
+    if (new_cwd) {
+        __glfs_cwd_set(fs, new_cwd);
+        inode_unref(new_cwd);
+    }
 
-        /* For decrementing subvol->wind ref count we need not check/wait for
-         * migration-in-progress flag.
-         * Also glfs_subvol_done is called in call-back path therefore waiting
-         * for migration-in-progress flag can lead to dead-lock.
-         */
-        glfs_lock (fs, _gf_false);
-	{
-		ref = (--subvol->winds);
-		active_subvol = fs->active_subvol;
-	}
-        glfs_unlock (fs);
-
-	if (ref == 0) {
-		assert (subvol != active_subvol);
-		xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, NULL);
-	}
+    gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH,
+           "switched to graph %s (%d)", graphid_str(new_subvol),
+           new_subvol->graph->id);
+
+    return new_subvol;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0);
+void
+priv_glfs_subvol_done(struct glfs *fs, xlator_t *subvol)
+{
+    int ref = 0;
+    xlator_t *active_subvol = NULL;
+
+    if (!subvol)
+        return;
+
+    /* For decrementing subvol->wind ref count we need not check/wait for
+     * migration-in-progress flag.
+     * Also glfs_subvol_done is called in call-back path therefore waiting
+     * for migration-in-progress flag can lead to dead-lock.
+     */
+    glfs_lock(fs, _gf_false);
+    {
+        ref = (--subvol->winds);
+        active_subvol = fs->active_subvol;
+    }
+    glfs_unlock(fs);
+
+    if (ref == 0) {
+        assert(subvol != active_subvol);
+        xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, NULL);
+    }
+}
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0);
 
 xlator_t *
-priv_glfs_active_subvol (struct glfs *fs)
+priv_glfs_active_subvol(struct glfs *fs)
 {
-	xlator_t      *subvol = NULL;
-	xlator_t      *old_subvol = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *old_subvol = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		subvol = __glfs_active_subvol (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        subvol = __glfs_active_subvol(fs);
 
-		if (subvol)
-			subvol->winds++;
+        if (subvol)
+            subvol->winds++;
 
-		if (fs->old_subvol) {
-			old_subvol = fs->old_subvol;
-			fs->old_subvol = NULL;
-			old_subvol->switched = 1;
-		}
-	}
-	glfs_unlock (fs);
+        if (fs->old_subvol) {
+            old_subvol = fs->old_subvol;
+            fs->old_subvol = NULL;
+            old_subvol->switched = 1;
+        }
+    }
+    glfs_unlock(fs);
 
-	if (old_subvol)
-		priv_glfs_subvol_done (fs, old_subvol);
+    if (old_subvol)
+        priv_glfs_subvol_done(fs, old_subvol);
 
-	return subvol;
+    return subvol;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0);
 
 int
-__glfs_cwd_set (struct glfs *fs, inode_t *inode)
+__glfs_cwd_set(struct glfs *fs, inode_t *inode)
 {
-	if (inode->table->xl != fs->active_subvol) {
-		inode = __glfs_refresh_inode (fs, fs->active_subvol, inode,
-                                              _gf_false);
-		if (!inode)
-			return -1;
-	} else {
-		inode_ref (inode);
-	}
+    if (inode->table->xl != fs->active_subvol) {
+        inode = __glfs_refresh_inode(fs, fs->active_subvol, inode, _gf_false);
+        if (!inode)
+            return -1;
+    } else {
+        inode_ref(inode);
+    }
 
-	if (fs->cwd)
-		inode_unref (fs->cwd);
+    if (fs->cwd)
+        inode_unref(fs->cwd);
 
-	fs->cwd = inode;
+    fs->cwd = inode;
 
-	return 0;
+    return 0;
 }
 
-
 int
-glfs_cwd_set (struct glfs *fs, inode_t *inode)
+glfs_cwd_set(struct glfs *fs, inode_t *inode)
 {
-	int ret = 0;
+    int ret = 0;
 
-        glfs_lock (fs, _gf_true);
-	{
-		ret = __glfs_cwd_set (fs, inode);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        ret = __glfs_cwd_set(fs, inode);
+    }
+    glfs_unlock(fs);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-__glfs_cwd_get (struct glfs *fs)
+__glfs_cwd_get(struct glfs *fs)
 {
-	inode_t *cwd = NULL;
+    inode_t *cwd = NULL;
 
-	if (!fs->cwd)
-		return NULL;
+    if (!fs->cwd)
+        return NULL;
 
-	if (fs->cwd->table->xl == fs->active_subvol) {
-		cwd = inode_ref (fs->cwd);
-		return cwd;
-	}
+    if (fs->cwd->table->xl == fs->active_subvol) {
+        cwd = inode_ref(fs->cwd);
+        return cwd;
+    }
 
-	cwd = __glfs_refresh_inode (fs, fs->active_subvol, fs->cwd, _gf_false);
+    cwd = __glfs_refresh_inode(fs, fs->active_subvol, fs->cwd, _gf_false);
 
-	return cwd;
+    return cwd;
 }
 
 inode_t *
-glfs_cwd_get (struct glfs *fs)
+glfs_cwd_get(struct glfs *fs)
 {
-	inode_t *cwd = NULL;
+    inode_t *cwd = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		cwd = __glfs_cwd_get (fs);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        cwd = __glfs_cwd_get(fs);
+    }
+    glfs_unlock(fs);
 
-	return cwd;
+    return cwd;
 }
 
 inode_t *
-__glfs_resolve_inode (struct glfs *fs, xlator_t *subvol,
-		    struct glfs_object *object)
+__glfs_resolve_inode(struct glfs *fs, xlator_t *subvol,
+                     struct glfs_object *object)
 {
-	inode_t *inode = NULL;
-        gf_boolean_t lookup_needed = _gf_false;
+    inode_t *inode = NULL;
+    gf_boolean_t lookup_needed = _gf_false;
 
-        lookup_needed = inode_needs_lookup (object->inode, THIS);
+    lookup_needed = inode_needs_lookup(object->inode, THIS);
 
-	if (!lookup_needed && object->inode->table->xl == subvol)
-		return inode_ref (object->inode);
+    if (!lookup_needed && object->inode->table->xl == subvol)
+        return inode_ref(object->inode);
 
-	inode = __glfs_refresh_inode (fs, fs->active_subvol,
-                                      object->inode, lookup_needed);
-	if (!inode)
-		return NULL;
+    inode = __glfs_refresh_inode(fs, fs->active_subvol, object->inode,
+                                 lookup_needed);
+    if (!inode)
+        return NULL;
 
-	if (subvol == fs->active_subvol) {
-		inode_unref (object->inode);
-		object->inode = inode_ref (inode);
-	}
+    if (subvol == fs->active_subvol) {
+        inode_unref(object->inode);
+        object->inode = inode_ref(inode);
+    }
 
-	return inode;
+    return inode;
 }
 
 inode_t *
-glfs_resolve_inode (struct glfs *fs, xlator_t *subvol,
-		    struct glfs_object *object)
+glfs_resolve_inode(struct glfs *fs, xlator_t *subvol,
+                   struct glfs_object *object)
 {
-	inode_t *inode = NULL;
+    inode_t *inode = NULL;
 
-        glfs_lock (fs, _gf_true);
-	{
-		inode = __glfs_resolve_inode(fs, subvol, object);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        inode = __glfs_resolve_inode(fs, subvol, object);
+    }
+    glfs_unlock(fs);
 
-	return inode;
+    return inode;
 }
 
 int
-glfs_create_object (loc_t *loc, struct glfs_object **retobject)
+glfs_create_object(loc_t *loc, struct glfs_object **retobject)
 {
-	struct glfs_object *object = NULL;
+    struct glfs_object *object = NULL;
 
-	object = GF_CALLOC (1, sizeof(struct glfs_object),
-			    glfs_mt_glfs_object_t);
-	if (object == NULL) {
-		errno = ENOMEM;
-		return -1;
-	}
+    object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
+    if (object == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
 
-	object->inode = loc->inode;
-	gf_uuid_copy (object->gfid, object->inode->gfid);
+    object->inode = loc->inode;
+    gf_uuid_copy(object->gfid, object->inode->gfid);
 
-	/* we hold the reference */
-	loc->inode = NULL;
+    /* we hold the reference */
+    loc->inode = NULL;
 
-	*retobject = object;
+    *retobject = object;
 
-	return 0;
+    return 0;
 }
 
 struct glfs_object *
-glfs_h_resolve_symlink (struct glfs *fs, struct glfs_object *object)
+glfs_h_resolve_symlink(struct glfs *fs, struct glfs_object *object)
 {
-
-        xlator_t                *subvol         = NULL;
-        loc_t                   sym_loc         = {0,};
-        struct iatt             iatt            = {0,};
-        char                    *lpath          = NULL;
-        int                     ret             = 0;
-        struct glfs_object      *target_object  = NULL;
-
-        subvol = glfs_active_subvol (fs);
-        if (!subvol) {
-                ret = -1;
-                errno = EIO;
-                goto out;
-        }
-
-        ret = glfs_resolve_symlink (fs, subvol, object->inode, &lpath);
-        if (ret < 0)
-                goto out;
-
-        ret = glfs_resolve_at (fs, subvol, NULL, lpath,
-                               &sym_loc, &iatt,
-                              /* always recurisvely follow while
-                                following symlink
-                              */
-                               1, 0);
-        if (ret == 0)
-                ret = glfs_create_object (&sym_loc, &target_object);
+    xlator_t *subvol = NULL;
+    loc_t sym_loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    char *lpath = NULL;
+    int ret = 0;
+    struct glfs_object *target_object = NULL;
+
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
+
+    ret = glfs_resolve_symlink(fs, subvol, object->inode, &lpath);
+    if (ret < 0)
+        goto out;
+
+    ret = glfs_resolve_at(fs, subvol, NULL, lpath, &sym_loc, &iatt,
+                          /* always recurisvely follow while
+                            following symlink
+                          */
+                          1, 0);
+    if (ret == 0)
+        ret = glfs_create_object(&sym_loc, &target_object);
 
 out:
-        loc_wipe (&sym_loc);
-        GF_FREE (lpath);
-        return target_object;
+    loc_wipe(&sym_loc);
+    GF_FREE(lpath);
+    return target_object;
 }
diff --git a/api/src/glfs.c b/api/src/glfs.c
index 8ae3af61edb..d21cb8b334f 100644
--- a/api/src/glfs.c
+++ b/api/src/glfs.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /*
   TODO:
   - set proper pid/lk_owner to call frames (currently buried in syncop)
@@ -51,444 +50,422 @@
 #include "glfs.h"
 #include "glfs-internal.h"
 
-
 static gf_boolean_t
-vol_assigned (cmd_args_t *args)
+vol_assigned(cmd_args_t *args)
 {
-	return args->volfile || args->volfile_server;
+    return args->volfile || args->volfile_server;
 }
 
-
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-	call_pool_t   *pool = NULL;
-	int	       ret = -1;
-
-	if (!ctx) {
-		goto err;
-        }
-
-        ret = xlator_mem_acct_init (THIS, glfs_mt_end + 1);
-        if (ret != 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                        API_MSG_MEM_ACCT_INIT_FAILED,
-                        "Memory accounting init failed");
-                return ret;
-        }
-
-        /* reset ret to -1 so that we don't need to explicitly
-         * set it in all error paths before "goto err"
-         */
+    call_pool_t *pool = NULL;
+    int ret = -1;
 
-        ret = -1;
+    if (!ctx) {
+        goto err;
+    }
 
-	ctx->process_uuid = generate_glusterfs_ctx_id ();
-	if (!ctx->process_uuid) {
-		goto err;
-	}
-
-	ctx->page_size	= 128 * GF_UNIT_KB;
-
-	ctx->iobuf_pool = iobuf_pool_new ();
-	if (!ctx->iobuf_pool) {
-		goto err;
-	}
-
-	ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-	if (!ctx->event_pool) {
-		goto err;
-	}
-
-	ctx->env = syncenv_new (0, 0, 0);
-	if (!ctx->env) {
-		goto err;
-	}
-
-	pool = GF_CALLOC (1, sizeof (call_pool_t),
-			  glfs_mt_call_pool_t);
-	if (!pool) {
-		goto err;
-	}
-
-	/* frame_mem_pool size 112 * 4k */
-	pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096);
-	if (!pool->frame_mem_pool) {
-		goto err;
-	}
-	/* stack_mem_pool size 256 * 1024 */
-	pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024);
-	if (!pool->stack_mem_pool) {
-		goto err;
-	}
-
-	ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
-	if (!ctx->stub_mem_pool) {
-		goto err;
-	}
-
-	ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
-	if (!ctx->dict_pool)
-		goto err;
-
-	ctx->dict_pair_pool = mem_pool_new (data_pair_t,
-					    GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
-	if (!ctx->dict_pair_pool)
-		goto err;
-
-	ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
-	if (!ctx->dict_data_pool)
-		goto err;
-
-        ctx->logbuf_pool = mem_pool_new (log_buf_t,
-                                         GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
-        if (!ctx->logbuf_pool)
-                goto err;
-
-	INIT_LIST_HEAD (&pool->all_frames);
-	INIT_LIST_HEAD (&ctx->cmd_args.xlator_options);
-        INIT_LIST_HEAD (&ctx->cmd_args.volfile_servers);
-
-	LOCK_INIT (&pool->lock);
-	ctx->pool = pool;
-
-	ret = 0;
+    ret = xlator_mem_acct_init(THIS, glfs_mt_end + 1);
+    if (ret != 0) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+               "Memory accounting init failed");
+        return ret;
+    }
+
+    /* reset ret to -1 so that we don't need to explicitly
+     * set it in all error paths before "goto err"
+     */
+
+    ret = -1;
+
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid) {
+        goto err;
+    }
+
+    ctx->page_size = 128 * GF_UNIT_KB;
+
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool) {
+        goto err;
+    }
+
+    ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                     STARTING_EVENT_THREADS);
+    if (!ctx->event_pool) {
+        goto err;
+    }
+
+    ctx->env = syncenv_new(0, 0, 0);
+    if (!ctx->env) {
+        goto err;
+    }
+
+    pool = GF_CALLOC(1, sizeof(call_pool_t), glfs_mt_call_pool_t);
+    if (!pool) {
+        goto err;
+    }
+
+    /* frame_mem_pool size 112 * 4k */
+    pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096);
+    if (!pool->frame_mem_pool) {
+        goto err;
+    }
+    /* stack_mem_pool size 256 * 1024 */
+    pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024);
+    if (!pool->stack_mem_pool) {
+        goto err;
+    }
+
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024);
+    if (!ctx->stub_mem_pool) {
+        goto err;
+    }
+
+    ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
+    if (!ctx->dict_pool)
+        goto err;
+
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t,
+                                       GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
+    if (!ctx->dict_pair_pool)
+        goto err;
+
+    ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
+    if (!ctx->dict_data_pool)
+        goto err;
+
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
+    if (!ctx->logbuf_pool)
+        goto err;
+
+    INIT_LIST_HEAD(&pool->all_frames);
+    INIT_LIST_HEAD(&ctx->cmd_args.xlator_options);
+    INIT_LIST_HEAD(&ctx->cmd_args.volfile_servers);
+
+    LOCK_INIT(&pool->lock);
+    ctx->pool = pool;
+
+    ret = 0;
 err:
-	if (ret && pool) {
-		if (pool->frame_mem_pool)
-			mem_pool_destroy (pool->frame_mem_pool);
-		if (pool->stack_mem_pool)
-			mem_pool_destroy (pool->stack_mem_pool);
-		GF_FREE (pool);
-	}
-
-	if (ret && ctx) {
-		if (ctx->stub_mem_pool)
-			mem_pool_destroy (ctx->stub_mem_pool);
-		if (ctx->dict_pool)
-			mem_pool_destroy (ctx->dict_pool);
-		if (ctx->dict_data_pool)
-			mem_pool_destroy (ctx->dict_data_pool);
-		if (ctx->dict_pair_pool)
-			mem_pool_destroy (ctx->dict_pair_pool);
-                if (ctx->logbuf_pool)
-                        mem_pool_destroy (ctx->logbuf_pool);
-	}
-
-	return ret;
-}
+    if (ret && pool) {
+        if (pool->frame_mem_pool)
+            mem_pool_destroy(pool->frame_mem_pool);
+        if (pool->stack_mem_pool)
+            mem_pool_destroy(pool->stack_mem_pool);
+        GF_FREE(pool);
+    }
+
+    if (ret && ctx) {
+        if (ctx->stub_mem_pool)
+            mem_pool_destroy(ctx->stub_mem_pool);
+        if (ctx->dict_pool)
+            mem_pool_destroy(ctx->dict_pool);
+        if (ctx->dict_data_pool)
+            mem_pool_destroy(ctx->dict_data_pool);
+        if (ctx->dict_pair_pool)
+            mem_pool_destroy(ctx->dict_pair_pool);
+        if (ctx->logbuf_pool)
+            mem_pool_destroy(ctx->logbuf_pool);
+    }
 
+    return ret;
+}
 
 static int
-create_master (struct glfs *fs)
+create_master(struct glfs *fs)
 {
-	int		 ret = 0;
-	xlator_t	*master = NULL;
-
-	master = GF_CALLOC (1, sizeof (*master),
-			    glfs_mt_xlator_t);
-	if (!master)
-		goto err;
-
-	master->name = gf_strdup ("gfapi");
-	if (!master->name)
-		goto err;
-
-	if (xlator_set_type (master, "mount/api") == -1) {
-		gf_msg ("glfs", GF_LOG_ERROR, 0,
-                        API_MSG_MASTER_XLATOR_INIT_FAILED, "master xlator "
-                        "for %s initialization failed", fs->volname);
-		goto err;
-	}
-
-	master->ctx	 = fs->ctx;
-	master->private	 = fs;
-	master->options	 = get_new_dict ();
-	if (!master->options)
-		goto err;
-
-
-	ret = xlator_init (master);
-	if (ret) {
-		gf_msg ("glfs", GF_LOG_ERROR, 0,
-                        API_MSG_GFAPI_XLATOR_INIT_FAILED,
-			"failed to initialize gfapi translator");
-		goto err;
-	}
-
-	fs->ctx->master = master;
-	THIS = master;
-
-	return 0;
+    int ret = 0;
+    xlator_t *master = NULL;
+
+    master = GF_CALLOC(1, sizeof(*master), glfs_mt_xlator_t);
+    if (!master)
+        goto err;
+
+    master->name = gf_strdup("gfapi");
+    if (!master->name)
+        goto err;
+
+    if (xlator_set_type(master, "mount/api") == -1) {
+        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED,
+               "master xlator "
+               "for %s initialization failed",
+               fs->volname);
+        goto err;
+    }
+
+    master->ctx = fs->ctx;
+    master->private = fs;
+    master->options = get_new_dict();
+    if (!master->options)
+        goto err;
+
+    ret = xlator_init(master);
+    if (ret) {
+        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,
+               "failed to initialize gfapi translator");
+        goto err;
+    }
+
+    fs->ctx->master = master;
+    THIS = master;
+
+    return 0;
 
 err:
-	if (master) {
-		xlator_destroy (master);
-	}
+    if (master) {
+        xlator_destroy(master);
+    }
 
-	return -1;
+    return -1;
 }
 
-
 static FILE *
-get_volfp (struct glfs *fs)
+get_volfp(struct glfs *fs)
 {
-	cmd_args_t  *cmd_args = NULL;
-	FILE	    *specfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    FILE *specfp = NULL;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
-		gf_msg ("glfs", GF_LOG_ERROR, errno,
-                        API_MSG_VOLFILE_OPEN_FAILED,
-			"volume file %s open failed: %s",
-			cmd_args->volfile,
-			strerror (errno));
-		return NULL;
-	}
+    if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {
+        gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED,
+               "volume file %s open failed: %s", cmd_args->volfile,
+               strerror(errno));
+        return NULL;
+    }
 
-	gf_msg_debug ("glfs", 0, "loading volume file %s", cmd_args->volfile);
+    gf_msg_debug("glfs", 0, "loading volume file %s", cmd_args->volfile);
 
-	return specfp;
+    return specfp;
 }
 
-
 int
-glfs_volumes_init (struct glfs *fs)
+glfs_volumes_init(struct glfs *fs)
 {
-	FILE		   *fp = NULL;
-	cmd_args_t	   *cmd_args = NULL;
-	int		    ret = 0;
+    FILE *fp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if (!vol_assigned (cmd_args))
-		return -1;
+    if (!vol_assigned(cmd_args))
+        return -1;
 
-	if (cmd_args->volfile_server) {
-		ret = glfs_mgmt_init (fs);
-		goto out;
-	}
+    if (cmd_args->volfile_server) {
+        ret = glfs_mgmt_init(fs);
+        goto out;
+    }
 
-	fp = get_volfp (fs);
+    fp = get_volfp(fs);
 
-	if (!fp) {
-		gf_msg ("glfs", GF_LOG_ERROR, ENOENT,
-                        API_MSG_VOL_SPEC_FILE_ERROR,
-			"Cannot reach volume specification file");
-		ret = -1;
-		goto out;
-	}
+    if (!fp) {
+        gf_msg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR,
+               "Cannot reach volume specification file");
+        ret = -1;
+        goto out;
+    }
 
-	ret = glfs_process_volfp (fs, fp);
-	if (ret)
-		goto out;
+    ret = glfs_process_volfp(fs, fp);
+    if (ret)
+        goto out;
 
 out:
-	return ret;
+    return ret;
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////
 
-
 int
-pub_glfs_set_xlator_option (struct glfs *fs, const char *xlator,
-                            const char *key, const char *value)
+pub_glfs_set_xlator_option(struct glfs *fs, const char *xlator, const char *key,
+                           const char *value)
 {
-	xlator_cmdline_option_t *option = NULL;
+    xlator_cmdline_option_t *option = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	option = GF_CALLOC (1, sizeof (*option),
-			    glfs_mt_xlator_cmdline_option_t);
-	if (!option)
-		goto enomem;
+    option = GF_CALLOC(1, sizeof(*option), glfs_mt_xlator_cmdline_option_t);
+    if (!option)
+        goto enomem;
 
-	INIT_LIST_HEAD (&option->cmd_args);
+    INIT_LIST_HEAD(&option->cmd_args);
 
-	option->volume = gf_strdup (xlator);
-	if (!option->volume)
-		goto enomem;
-	option->key = gf_strdup (key);
-	if (!option->key)
-		goto enomem;
-	option->value = gf_strdup (value);
-	if (!option->value)
-		goto enomem;
+    option->volume = gf_strdup(xlator);
+    if (!option->volume)
+        goto enomem;
+    option->key = gf_strdup(key);
+    if (!option->key)
+        goto enomem;
+    option->value = gf_strdup(value);
+    if (!option->value)
+        goto enomem;
 
-	list_add (&option->cmd_args, &fs->ctx->cmd_args.xlator_options);
+    list_add(&option->cmd_args, &fs->ctx->cmd_args.xlator_options);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-	return 0;
+    return 0;
 enomem:
-	errno = ENOMEM;
+    errno = ENOMEM;
 
-	if (!option) {
-                __GLFS_EXIT_FS;
-		return -1;
-        }
+    if (!option) {
+        __GLFS_EXIT_FS;
+        return -1;
+    }
 
-	GF_FREE (option->volume);
-	GF_FREE (option->key);
-	GF_FREE (option->value);
-	GF_FREE (option);
+    GF_FREE(option->volume);
+    GF_FREE(option->key);
+    GF_FREE(option->value);
+    GF_FREE(option);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-	return -1;
+    return -1;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_xlator_option, 3.4.0);
 
-
 int
-pub_glfs_unset_volfile_server (struct glfs *fs, const char *transport,
-                               const char *host, const int port)
+pub_glfs_unset_volfile_server(struct glfs *fs, const char *transport,
+                              const char *host, const int port)
 {
-        cmd_args_t       *cmd_args = NULL;
-        server_cmdline_t *server = NULL;
-        server_cmdline_t *tmp = NULL;
-        char             *transport_val = NULL;
-        int               port_val = 0;
-        int               ret = -1;
-
-        if (!fs || !host) {
-                errno = EINVAL;
-                return ret;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        cmd_args = &fs->ctx->cmd_args;
-
-        if (transport) {
-                transport_val = gf_strdup (transport);
-        } else {
-                transport_val = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT);
-        }
-
-        if (!transport_val) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (port) {
-                port_val = port;
-        } else {
-                port_val = GF_DEFAULT_BASE_PORT;
-        }
-
-        list_for_each_entry_safe (server, tmp,
-                                  &cmd_args->curr_server->list,
-                                  list) {
-                if ((!strcmp(server->volfile_server, host) &&
-                     !strcmp(server->transport, transport_val) &&
-                     (server->port == port_val))) {
-                        list_del (&server->list);
-                        ret = 0;
-                        goto out;
-                }
+    cmd_args_t *cmd_args = NULL;
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+    char *transport_val = NULL;
+    int port_val = 0;
+    int ret = -1;
+
+    if (!fs || !host) {
+        errno = EINVAL;
+        return ret;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    cmd_args = &fs->ctx->cmd_args;
+
+    if (transport) {
+        transport_val = gf_strdup(transport);
+    } else {
+        transport_val = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+    }
+
+    if (!transport_val) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (port) {
+        port_val = port;
+    } else {
+        port_val = GF_DEFAULT_BASE_PORT;
+    }
+
+    list_for_each_entry_safe(server, tmp, &cmd_args->curr_server->list, list)
+    {
+        if ((!strcmp(server->volfile_server, host) &&
+             !strcmp(server->transport, transport_val) &&
+             (server->port == port_val))) {
+            list_del(&server->list);
+            ret = 0;
+            goto out;
         }
+    }
 
 out:
-        GF_FREE (transport_val);
-        __GLFS_EXIT_FS;
+    GF_FREE(transport_val);
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unset_volfile_server, 3.5.1);
 
-
 int
-pub_glfs_set_volfile_server (struct glfs *fs, const char *transport,
-                             const char *host, int port)
+pub_glfs_set_volfile_server(struct glfs *fs, const char *transport,
+                            const char *host, int port)
 {
-        cmd_args_t            *cmd_args = NULL;
-        int                    ret = -1;
-        char                  *server_host = NULL;
-        char                  *server_transport = NULL;
-
-        if (!fs || !host) {
-                errno = EINVAL;
-                return ret;
-        }
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+    char *server_host = NULL;
+    char *server_transport = NULL;
 
-        cmd_args = &fs->ctx->cmd_args;
-        cmd_args->max_connect_attempts = 1;
-
-        server_host = gf_strdup (host);
-        if (!server_host) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (transport) {
-                /* volfile fetch support over tcp|unix only */
-                if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) {
-                        server_transport = gf_strdup (transport);
-                } else if (!strcmp(transport, "rdma")) {
-                        server_transport =
-                                gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT);
-                        gf_msg ("glfs", GF_LOG_WARNING, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-                                "transport RDMA is deprecated, "
-                                "falling back to tcp");
-                } else {
-                        gf_msg ("glfs", GF_LOG_TRACE, EINVAL,
-                                API_MSG_INVALID_ENTRY,
-                                "transport %s is not supported, "
-                                "possible values tcp|unix",
-                                transport);
-                        goto out;
-                }
+    if (!fs || !host) {
+        errno = EINVAL;
+        return ret;
+    }
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    cmd_args = &fs->ctx->cmd_args;
+    cmd_args->max_connect_attempts = 1;
+
+    server_host = gf_strdup(host);
+    if (!server_host) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (transport) {
+        /* volfile fetch support over tcp|unix only */
+        if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) {
+            server_transport = gf_strdup(transport);
+        } else if (!strcmp(transport, "rdma")) {
+            server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+            gf_msg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_INVALID_ENTRY,
+                   "transport RDMA is deprecated, "
+                   "falling back to tcp");
         } else {
-                server_transport = gf_strdup (GF_DEFAULT_VOLFILE_TRANSPORT);
-        }
-
-        if (!server_transport) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        if (!port) {
-                port = GF_DEFAULT_BASE_PORT;
-        }
-
-        if (!strcmp(server_transport, "unix")) {
-                port = 0;
-        }
-
-        ret = gf_set_volfile_server_common(cmd_args, server_host,
-                                           server_transport, port);
-        if (ret) {
-                gf_log ("glfs", GF_LOG_ERROR,
-                        "failed to set volfile server: %s", strerror (errno));
+            gf_msg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_INVALID_ENTRY,
+                   "transport %s is not supported, "
+                   "possible values tcp|unix",
+                   transport);
+            goto out;
         }
+    } else {
+        server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
+    }
+
+    if (!server_transport) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    if (!port) {
+        port = GF_DEFAULT_BASE_PORT;
+    }
+
+    if (!strcmp(server_transport, "unix")) {
+        port = 0;
+    }
+
+    ret = gf_set_volfile_server_common(cmd_args, server_host, server_transport,
+                                       port);
+    if (ret) {
+        gf_log("glfs", GF_LOG_ERROR, "failed to set volfile server: %s",
+               strerror(errno));
+    }
 
 out:
-        if (server_host) {
-                GF_FREE (server_host);
-        }
+    if (server_host) {
+        GF_FREE(server_host);
+    }
 
-        if (server_transport) {
-                GF_FREE (server_transport);
-        }
+    if (server_transport) {
+        GF_FREE(server_transport);
+    }
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0);
@@ -497,294 +474,288 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0);
  * Used to free the arguments allocated by glfs_set_volfile_server()
  */
 static void
-glfs_free_volfile_servers (cmd_args_t *cmd_args)
+glfs_free_volfile_servers(cmd_args_t *cmd_args)
 {
-        server_cmdline_t *server = NULL;
-        server_cmdline_t *tmp = NULL;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, cmd_args, out);
-
-        list_for_each_entry_safe (server, tmp, &cmd_args->volfile_servers,
-                                  list) {
-                list_del_init (&server->list);
-                GF_FREE (server->volfile_server);
-                GF_FREE (server->transport);
-                GF_FREE (server);
-        }
-        cmd_args->curr_server = NULL;
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out);
+
+    list_for_each_entry_safe(server, tmp, &cmd_args->volfile_servers, list)
+    {
+        list_del_init(&server->list);
+        GF_FREE(server->volfile_server);
+        GF_FREE(server->transport);
+        GF_FREE(server);
+    }
+    cmd_args->curr_server = NULL;
 out:
-        return;
+    return;
 }
 
 static void
-glfs_free_xlator_options (cmd_args_t *cmd_args)
+glfs_free_xlator_options(cmd_args_t *cmd_args)
 {
-        xlator_cmdline_option_t *xo     = NULL;
-        xlator_cmdline_option_t *tmp_xo = NULL;
-
-        if (!&(cmd_args->xlator_options))
-                return;
-
-        list_for_each_entry_safe (xo, tmp_xo, &cmd_args->xlator_options,
-                                  cmd_args) {
-                list_del_init (&xo->cmd_args);
-                GF_FREE (xo->volume);
-                GF_FREE (xo->key);
-                GF_FREE (xo->value);
-                GF_FREE (xo);
-        }
+    xlator_cmdline_option_t *xo = NULL;
+    xlator_cmdline_option_t *tmp_xo = NULL;
+
+    if (!&(cmd_args->xlator_options))
+        return;
+
+    list_for_each_entry_safe(xo, tmp_xo, &cmd_args->xlator_options, cmd_args)
+    {
+        list_del_init(&xo->cmd_args);
+        GF_FREE(xo->volume);
+        GF_FREE(xo->key);
+        GF_FREE(xo->value);
+        GF_FREE(xo);
+    }
 }
 
 int
-pub_glfs_setfsuid (uid_t fsuid)
+pub_glfs_setfsuid(uid_t fsuid)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsuid (&fsuid);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsuid(&fsuid);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsuid, 3.4.2);
 
-
 int
-pub_glfs_setfsgid (gid_t fsgid)
+pub_glfs_setfsgid(gid_t fsgid)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgid (&fsgid);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgid(&fsgid);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2);
 
-
 int
-pub_glfs_setfsgroups (size_t size, const gid_t *list)
+pub_glfs_setfsgroups(size_t size, const gid_t *list)
 {
-         /* TODO:
-         * - Set the THIS and restore it appropriately
-         */
-	return syncopctx_setfsgroups(size, list);
+    /* TODO:
+     * - Set the THIS and restore it appropriately
+     */
+    return syncopctx_setfsgroups(size, list);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2);
 
 int
-pub_glfs_setfsleaseid (glfs_leaseid_t leaseid)
+pub_glfs_setfsleaseid(glfs_leaseid_t leaseid)
 {
-        int           ret     = -1;
-        char         *gleaseid = NULL;
+    int ret = -1;
+    char *gleaseid = NULL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, leaseid, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, leaseid, out);
 
-        gleaseid = gf_leaseid_get();
-        if (gleaseid) {
-                memcpy (gleaseid, leaseid, LEASE_ID_SIZE);
-                ret = 0;
-        }
+    gleaseid = gf_leaseid_get();
+    if (gleaseid) {
+        memcpy(gleaseid, leaseid, LEASE_ID_SIZE);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0);
 
 int
-get_fop_attr_glfd (dict_t **fop_attr, struct glfs_fd *glfd)
+get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd)
 {
-        char *leaseid            = NULL;
-        int   ret                = 0;
-        gf_boolean_t dict_create = _gf_false;
-
-        leaseid = GF_MALLOC (LEASE_ID_SIZE, gf_common_mt_char);
-        GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out);
-        memcpy (leaseid, glfd->lease_id, LEASE_ID_SIZE);
-        if (*fop_attr == NULL) {
-                *fop_attr = dict_new ();
-                dict_create = _gf_true;
-        }
-        GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
-        ret = dict_set_static_bin (*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);
+    char *leaseid = NULL;
+    int ret = 0;
+    gf_boolean_t dict_create = _gf_false;
+
+    leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char);
+    GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out);
+    memcpy(leaseid, glfd->lease_id, LEASE_ID_SIZE);
+    if (*fop_attr == NULL) {
+        *fop_attr = dict_new();
+        dict_create = _gf_true;
+    }
+    GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
+    ret = dict_set_static_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);
 out:
-        if (ret) {
-                GF_FREE (leaseid);
-                if (dict_create) {
-                        if (*fop_attr)
-                                dict_unref (*fop_attr);
-                        *fop_attr = NULL;
-                }
+    if (ret) {
+        GF_FREE(leaseid);
+        if (dict_create) {
+            if (*fop_attr)
+                dict_unref(*fop_attr);
+            *fop_attr = NULL;
         }
-        return ret;
+    }
+    return ret;
 }
 
 int
-set_fop_attr_glfd (struct glfs_fd *glfd)
+set_fop_attr_glfd(struct glfs_fd *glfd)
 {
-        char     *lease_id = NULL;
-        int       ret      = -1;
+    char *lease_id = NULL;
+    int ret = -1;
 
-        lease_id = gf_existing_leaseid ();
-        if (lease_id) {
-                memcpy (glfd->lease_id, lease_id, LEASE_ID_SIZE);
-                ret = 0;
-        }
-        return ret;
+    lease_id = gf_existing_leaseid();
+    if (lease_id) {
+        memcpy(glfd->lease_id, lease_id, LEASE_ID_SIZE);
+        ret = 0;
+    }
+    return ret;
 }
 
 int
-get_fop_attr_thrd_key (dict_t **fop_attr)
+get_fop_attr_thrd_key(dict_t **fop_attr)
 {
-        char     *lease_id       = NULL;
-        int       ret            = 0;
-        gf_boolean_t dict_create = _gf_false;
-
-        lease_id = gf_existing_leaseid ();
-        if (lease_id) {
-                if (*fop_attr == NULL) {
-                        *fop_attr = dict_new ();
-                        dict_create = _gf_true;
-                }
-                GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
-                ret = dict_set_bin (*fop_attr, "lease-id", gf_strdup (lease_id),
-                                    LEASE_ID_SIZE);
+    char *lease_id = NULL;
+    int ret = 0;
+    gf_boolean_t dict_create = _gf_false;
+
+    lease_id = gf_existing_leaseid();
+    if (lease_id) {
+        if (*fop_attr == NULL) {
+            *fop_attr = dict_new();
+            dict_create = _gf_true;
         }
+        GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);
+        ret = dict_set_bin(*fop_attr, "lease-id", gf_strdup(lease_id),
+                           LEASE_ID_SIZE);
+    }
 
 out:
-        if (ret && dict_create) {
-                if (*fop_attr)
-                        dict_unref (*fop_attr);
-                *fop_attr = NULL;
-        }
-        return ret;
+    if (ret && dict_create) {
+        if (*fop_attr)
+            dict_unref(*fop_attr);
+        *fop_attr = NULL;
+    }
+    return ret;
 }
 
 void
-unset_fop_attr (dict_t **fop_attr)
+unset_fop_attr(dict_t **fop_attr)
 {
-        char     *lease_id = NULL;
-        lease_id = gf_existing_leaseid ();
-        if (lease_id)
-                memset (lease_id, 0, LEASE_ID_SIZE);
-        if (*fop_attr) {
-                dict_unref (*fop_attr);
-                *fop_attr = NULL;
-        }
+    char *lease_id = NULL;
+    lease_id = gf_existing_leaseid();
+    if (lease_id)
+        memset(lease_id, 0, LEASE_ID_SIZE);
+    if (*fop_attr) {
+        dict_unref(*fop_attr);
+        *fop_attr = NULL;
+    }
 }
 struct glfs *
-pub_glfs_from_glfd (struct glfs_fd *glfd)
+pub_glfs_from_glfd(struct glfs_fd *glfd)
 {
-	return glfd->fs;
+    return glfd->fs;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0);
 
 static void
-glfs_fd_destroy (struct glfs_fd *glfd)
+glfs_fd_destroy(struct glfs_fd *glfd)
 {
-        if (!glfd)
-                return;
+    if (!glfd)
+        return;
 
-        glfs_lock (glfd->fs, _gf_true);
-        {
-                list_del_init (&glfd->openfds);
-        }
-        glfs_unlock (glfd->fs);
+    glfs_lock(glfd->fs, _gf_true);
+    {
+        list_del_init(&glfd->openfds);
+    }
+    glfs_unlock(glfd->fs);
 
-        if (glfd->fd) {
-                fd_unref (glfd->fd);
-                glfd->fd = NULL;
-        }
+    if (glfd->fd) {
+        fd_unref(glfd->fd);
+        glfd->fd = NULL;
+    }
 
-        GF_FREE (glfd->readdirbuf);
+    GF_FREE(glfd->readdirbuf);
 
-        GF_FREE (glfd);
+    GF_FREE(glfd);
 }
 
-
 struct glfs_fd *
-glfs_fd_new (struct glfs *fs)
+glfs_fd_new(struct glfs *fs)
 {
-	struct glfs_fd  *glfd = NULL;
+    struct glfs_fd *glfd = NULL;
 
-	glfd = GF_CALLOC (1, sizeof (*glfd), glfs_mt_glfs_fd_t);
-	if (!glfd)
-		return NULL;
+    glfd = GF_CALLOC(1, sizeof(*glfd), glfs_mt_glfs_fd_t);
+    if (!glfd)
+        return NULL;
 
-	glfd->fs = fs;
+    glfd->fs = fs;
 
-	INIT_LIST_HEAD (&glfd->openfds);
+    INIT_LIST_HEAD(&glfd->openfds);
 
-        GF_REF_INIT (glfd, glfs_fd_destroy);
+    GF_REF_INIT(glfd, glfs_fd_destroy);
 
-	return glfd;
+    return glfd;
 }
 
-
 void
-glfs_fd_bind (struct glfs_fd *glfd)
+glfs_fd_bind(struct glfs_fd *glfd)
 {
-	struct glfs *fs = NULL;
+    struct glfs *fs = NULL;
 
-	fs = glfd->fs;
+    fs = glfd->fs;
 
-        glfs_lock (fs, _gf_true);
-	{
-		list_add_tail (&glfd->openfds, &fs->openfds);
-	}
-	glfs_unlock (fs);
+    glfs_lock(fs, _gf_true);
+    {
+        list_add_tail(&glfd->openfds, &fs->openfds);
+    }
+    glfs_unlock(fs);
 }
 
-
 static void *
-glfs_poller (void *data)
+glfs_poller(void *data)
 {
-	struct glfs  *fs = NULL;
+    struct glfs *fs = NULL;
 
-	fs = data;
+    fs = data;
 
-	event_dispatch (fs->ctx->event_pool);
+    event_dispatch(fs->ctx->event_pool);
 
-	return NULL;
+    return NULL;
 }
 
 static struct glfs *
-glfs_new_fs (const char *volname)
+glfs_new_fs(const char *volname)
 {
-        struct glfs     *fs             = NULL;
+    struct glfs *fs = NULL;
 
-        fs = CALLOC (1, sizeof (*fs));
-        if (!fs)
-                return NULL;
+    fs = CALLOC(1, sizeof(*fs));
+    if (!fs)
+        return NULL;
 
-        INIT_LIST_HEAD (&fs->openfds);
-        INIT_LIST_HEAD (&fs->upcall_list);
+    INIT_LIST_HEAD(&fs->openfds);
+    INIT_LIST_HEAD(&fs->upcall_list);
 
-        PTHREAD_MUTEX_INIT (&fs->mutex, NULL, fs->pthread_flags,
-                            GLFS_INIT_MUTEX, err);
+    PTHREAD_MUTEX_INIT(&fs->mutex, NULL, fs->pthread_flags, GLFS_INIT_MUTEX,
+                       err);
 
-        PTHREAD_COND_INIT (&fs->cond, NULL, fs->pthread_flags,
-                           GLFS_INIT_COND, err);
+    PTHREAD_COND_INIT(&fs->cond, NULL, fs->pthread_flags, GLFS_INIT_COND, err);
 
-        PTHREAD_COND_INIT (&fs->child_down_cond, NULL, fs->pthread_flags,
-                           GLFS_INIT_COND_CHILD, err);
+    PTHREAD_COND_INIT(&fs->child_down_cond, NULL, fs->pthread_flags,
+                      GLFS_INIT_COND_CHILD, err);
 
-        PTHREAD_MUTEX_INIT (&fs->upcall_list_mutex, NULL, fs->pthread_flags,
-                            GLFS_INIT_MUTEX_UPCALL, err);
+    PTHREAD_MUTEX_INIT(&fs->upcall_list_mutex, NULL, fs->pthread_flags,
+                       GLFS_INIT_MUTEX_UPCALL, err);
 
-        fs->volname = strdup (volname);
-        if (!fs->volname)
-                goto err;
+    fs->volname = strdup(volname);
+    if (!fs->volname)
+        goto err;
 
-        fs->pin_refcnt = 0;
-        fs->upcall_events = 0;
-        fs->up_cbk = NULL;
-        fs->up_data = NULL;
+    fs->pin_refcnt = 0;
+    fs->upcall_events = 0;
+    fs->up_cbk = NULL;
+    fs->up_data = NULL;
 
-        return fs;
+    return fs;
 
 err:
-        glfs_free_from_ctx (fs);
-        return NULL;
+    glfs_free_from_ctx(fs);
+    return NULL;
 }
 
 extern xlator_t global_xlator;
@@ -792,785 +763,769 @@ extern glusterfs_ctx_t *global_ctx;
 extern pthread_mutex_t global_ctx_mutex;
 
 static int
-glfs_init_global_ctx ()
+glfs_init_global_ctx()
 {
-        int              ret = 0;
-        glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
 
-        pthread_mutex_lock (&global_ctx_mutex);
-        {
-                if (global_xlator.ctx)
-                        goto unlock;
+    pthread_mutex_lock(&global_ctx_mutex);
+    {
+        if (global_xlator.ctx)
+            goto unlock;
 
-                ctx = glusterfs_ctx_new ();
-                if (!ctx) {
-                        ret = -1;
-                        goto unlock;
-                }
+        ctx = glusterfs_ctx_new();
+        if (!ctx) {
+            ret = -1;
+            goto unlock;
+        }
 
-                gf_log_globals_init (ctx, GF_LOG_NONE);
+        gf_log_globals_init(ctx, GF_LOG_NONE);
 
-                global_ctx = ctx;
-                global_xlator.ctx = global_ctx;
+        global_ctx = ctx;
+        global_xlator.ctx = global_ctx;
 
-                ret = glusterfs_ctx_defaults_init (ctx);
-                if (ret) {
-                        global_ctx = NULL;
-                        global_xlator.ctx = NULL;
-                        goto unlock;
-                }
+        ret = glusterfs_ctx_defaults_init(ctx);
+        if (ret) {
+            global_ctx = NULL;
+            global_xlator.ctx = NULL;
+            goto unlock;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&global_ctx_mutex);
+    pthread_mutex_unlock(&global_ctx_mutex);
 
-        if (ret)
-                FREE (ctx);
+    if (ret)
+        FREE(ctx);
 
-        return ret;
+    return ret;
 }
 
-
 struct glfs *
-pub_glfs_new (const char *volname)
+pub_glfs_new(const char *volname)
 {
-	struct glfs     *fs             = NULL;
-	int              ret            = -1;
-	glusterfs_ctx_t *ctx            = NULL;
-        xlator_t        *old_THIS       = NULL;
-        char            pname[16]       = "";
-        char            msg[32]         = "";
-
-        if (!volname) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        /*
-         * Do this as soon as possible in case something else depends on
-         * pool allocations.
-         */
-        mem_pools_init_early ();
-        mem_pools_init_late ();
+    struct glfs *fs = NULL;
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *old_THIS = NULL;
+    char pname[16] = "";
+    char msg[32] = "";
+
+    if (!volname) {
+        errno = EINVAL;
+        return NULL;
+    }
 
-        fs = glfs_new_fs (volname);
-        if (!fs)
-                goto out;
+    /*
+     * Do this as soon as possible in case something else depends on
+     * pool allocations.
+     */
+    mem_pools_init_early();
+    mem_pools_init_late();
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                goto out;
+    fs = glfs_new_fs(volname);
+    if (!fs)
+        goto out;
 
-        /* first globals init, for gf_mem_acct_enable_set () */
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        goto out;
 
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                goto out;
+    /* first globals init, for gf_mem_acct_enable_set () */
 
-        old_THIS = THIS;
-        ret = glfs_init_global_ctx ();
-        if (ret)
-                goto out;
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        goto out;
 
-        /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */
+    old_THIS = THIS;
+    ret = glfs_init_global_ctx();
+    if (ret)
+        goto out;
 
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
+    /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */
 
-        fs->ctx = ctx;
-        fs->ctx->process_mode = GF_CLIENT_PROCESS;
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        ret = glfs_set_logging (fs, "/dev/null", 0);
-        if (ret)
-                goto out;
+    fs->ctx = ctx;
+    fs->ctx->process_mode = GF_CLIENT_PROCESS;
 
-        fs->ctx->cmd_args.volfile_id = gf_strdup (volname);
-        if (!(fs->ctx->cmd_args.volfile_id)) {
-                ret = -1;
-                goto out;
-        }
+    ret = glfs_set_logging(fs, "/dev/null", 0);
+    if (ret)
+        goto out;
 
+    fs->ctx->cmd_args.volfile_id = gf_strdup(volname);
+    if (!(fs->ctx->cmd_args.volfile_id)) {
         ret = -1;
+        goto out;
+    }
+
+    ret = -1;
 #ifdef GF_LINUX_HOST_OS
-        ret = prctl (PR_GET_NAME, (unsigned long) pname, 0, 0, 0);
+    ret = prctl(PR_GET_NAME, (unsigned long)pname, 0, 0, 0);
 #endif
-        if (ret)
-                fs->ctx->cmd_args.process_name = gf_strdup ("gfapi");
-        else {
-                snprintf (msg, sizeof(msg), "gfapi.%s", pname);
-                fs->ctx->cmd_args.process_name = gf_strdup (msg);
-        }
-        ret = 0;
+    if (ret)
+        fs->ctx->cmd_args.process_name = gf_strdup("gfapi");
+    else {
+        snprintf(msg, sizeof(msg), "gfapi.%s", pname);
+        fs->ctx->cmd_args.process_name = gf_strdup(msg);
+    }
+    ret = 0;
 
 out:
-        if (ret) {
-                if (fs) {
-                        glfs_fini (fs);
-                        fs = NULL;
-                } else {
-                        /* glfs_fini() calls mem_pools_fini() too */
-                        mem_pools_fini ();
-                }
+    if (ret) {
+        if (fs) {
+            glfs_fini(fs);
+            fs = NULL;
+        } else {
+            /* glfs_fini() calls mem_pools_fini() too */
+            mem_pools_fini();
         }
+    }
 
-        if (old_THIS)
-                THIS = old_THIS;
+    if (old_THIS)
+        THIS = old_THIS;
 
-        return fs;
+    return fs;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_new, 3.4.0);
 
-
 struct glfs *
-priv_glfs_new_from_ctx (glusterfs_ctx_t *ctx)
+priv_glfs_new_from_ctx(glusterfs_ctx_t *ctx)
 {
-        struct glfs    *fs = NULL;
+    struct glfs *fs = NULL;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        fs = glfs_new_fs ("");
-        if (!fs)
-                goto out;
+    fs = glfs_new_fs("");
+    if (!fs)
+        goto out;
 
-        fs->ctx = ctx;
+    fs->ctx = ctx;
 
 out:
-        return fs;
+    return fs;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_new_from_ctx, 3.7.0);
 
-
 void
-priv_glfs_free_from_ctx (struct glfs *fs)
+priv_glfs_free_from_ctx(struct glfs *fs)
 {
-        upcall_entry       *u_list   = NULL;
-        upcall_entry       *tmp      = NULL;
-
-        if (!fs)
-                return;
-
-        /* cleanup upcall structures */
-        list_for_each_entry_safe (u_list, tmp,
-                                  &fs->upcall_list,
-                                  upcall_list) {
-                list_del_init (&u_list->upcall_list);
-                GF_FREE (u_list->upcall_data.data);
-                GF_FREE (u_list);
-        }
+    upcall_entry *u_list = NULL;
+    upcall_entry *tmp = NULL;
+
+    if (!fs)
+        return;
 
-        PTHREAD_MUTEX_DESTROY (&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX);
+    /* cleanup upcall structures */
+    list_for_each_entry_safe(u_list, tmp, &fs->upcall_list, upcall_list)
+    {
+        list_del_init(&u_list->upcall_list);
+        GF_FREE(u_list->upcall_data.data);
+        GF_FREE(u_list);
+    }
 
-        PTHREAD_COND_DESTROY (&fs->cond, fs->pthread_flags, GLFS_INIT_COND);
+    PTHREAD_MUTEX_DESTROY(&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX);
 
-        PTHREAD_COND_DESTROY (&fs->child_down_cond, fs->pthread_flags,
-                              GLFS_INIT_COND_CHILD);
+    PTHREAD_COND_DESTROY(&fs->cond, fs->pthread_flags, GLFS_INIT_COND);
 
-        PTHREAD_MUTEX_DESTROY (&fs->upcall_list_mutex, fs->pthread_flags,
-                               GLFS_INIT_MUTEX_UPCALL);
+    PTHREAD_COND_DESTROY(&fs->child_down_cond, fs->pthread_flags,
+                         GLFS_INIT_COND_CHILD);
 
-        if (fs->oldvolfile)
-                FREE (fs->oldvolfile);
+    PTHREAD_MUTEX_DESTROY(&fs->upcall_list_mutex, fs->pthread_flags,
+                          GLFS_INIT_MUTEX_UPCALL);
 
-        FREE (fs->volname);
+    if (fs->oldvolfile)
+        FREE(fs->oldvolfile);
 
-        FREE (fs);
+    FREE(fs->volname);
+
+    FREE(fs);
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_free_from_ctx, 3.7.0);
 
-
 int
-pub_glfs_set_volfile (struct glfs *fs, const char *volfile)
+pub_glfs_set_volfile(struct glfs *fs, const char *volfile)
 {
-	cmd_args_t  *cmd_args = NULL;
+    cmd_args_t *cmd_args = NULL;
 
-	cmd_args = &fs->ctx->cmd_args;
+    cmd_args = &fs->ctx->cmd_args;
 
-	if (vol_assigned (cmd_args))
-		return -1;
+    if (vol_assigned(cmd_args))
+        return -1;
 
-	cmd_args->volfile = gf_strdup (volfile);
-        if (!cmd_args->volfile)
-                return -1;
-	return 0;
+    cmd_args->volfile = gf_strdup(volfile);
+    if (!cmd_args->volfile)
+        return -1;
+    return 0;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile, 3.4.0);
 
-
 int
-pub_glfs_set_logging (struct glfs *fs, const char *logfile, int loglevel)
+pub_glfs_set_logging(struct glfs *fs, const char *logfile, int loglevel)
 {
-        int              ret     = -1;
-        char            *tmplog  = NULL;
+    int ret = -1;
+    char *tmplog = NULL;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        if (!logfile) {
-                ret = gf_set_log_file_path (&fs->ctx->cmd_args, fs->ctx);
-                if (ret)
-                        goto out;
-                tmplog = fs->ctx->cmd_args.log_file;
-        } else {
-                tmplog = (char *)logfile;
-        }
+    if (!logfile) {
+        ret = gf_set_log_file_path(&fs->ctx->cmd_args, fs->ctx);
+        if (ret)
+            goto out;
+        tmplog = fs->ctx->cmd_args.log_file;
+    } else {
+        tmplog = (char *)logfile;
+    }
 
-        /* finish log set parameters before init */
-        if (loglevel >= 0)
-                gf_log_set_loglevel (fs->ctx, loglevel);
+    /* finish log set parameters before init */
+    if (loglevel >= 0)
+        gf_log_set_loglevel(fs->ctx, loglevel);
 
-        ret = gf_log_init (fs->ctx, tmplog, NULL);
-        if (ret)
-                goto out;
+    ret = gf_log_init(fs->ctx, tmplog, NULL);
+    if (ret)
+        goto out;
 
-        ret = gf_log_inject_timer_event (fs->ctx);
-        if (ret)
-                goto out;
+    ret = gf_log_inject_timer_event(fs->ctx);
+    if (ret)
+        goto out;
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_logging, 3.4.0);
 
-
 int
-glfs_init_wait (struct glfs *fs)
+glfs_init_wait(struct glfs *fs)
 {
-	int   ret = -1;
-
-	/* Always a top-down call, use glfs_lock() */
-        glfs_lock (fs, _gf_true);
-	{
-		while (!fs->init)
-			pthread_cond_wait (&fs->cond,
-					   &fs->mutex);
-		ret = fs->ret;
-		errno = fs->err;
-	}
-	glfs_unlock (fs);
-
-	return ret;
+    int ret = -1;
+
+    /* Always a top-down call, use glfs_lock() */
+    glfs_lock(fs, _gf_true);
+    {
+        while (!fs->init)
+            pthread_cond_wait(&fs->cond, &fs->mutex);
+        ret = fs->ret;
+        errno = fs->err;
+    }
+    glfs_unlock(fs);
+
+    return ret;
 }
 
-
 void
-priv_glfs_init_done (struct glfs *fs, int ret)
+priv_glfs_init_done(struct glfs *fs, int ret)
 {
-	glfs_init_cbk init_cbk;
-
-	if (!fs) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL,
-			"fs is NULL");
-		goto out;
-	}
-
-	init_cbk = fs->init_cbk;
-
-	/* Always a bottom-up call, use mutex_lock() */
-	pthread_mutex_lock (&fs->mutex);
-	{
-		fs->init = 1;
-		fs->ret = ret;
-		fs->err = errno;
-
-		if (!init_cbk)
-			pthread_cond_broadcast (&fs->cond);
-	}
-	pthread_mutex_unlock (&fs->mutex);
-
-	if (init_cbk)
-		init_cbk (fs, ret);
+    glfs_init_cbk init_cbk;
+
+    if (!fs) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL,
+               "fs is NULL");
+        goto out;
+    }
+
+    init_cbk = fs->init_cbk;
+
+    /* Always a bottom-up call, use mutex_lock() */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs->init = 1;
+        fs->ret = ret;
+        fs->err = errno;
+
+        if (!init_cbk)
+            pthread_cond_broadcast(&fs->cond);
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    if (init_cbk)
+        init_cbk(fs, ret);
 out:
-	return;
+    return;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_init_done, 3.4.0);
 
-
 int
-glfs_init_common (struct glfs *fs)
+glfs_init_common(struct glfs *fs)
 {
-	int  ret = -1;
+    int ret = -1;
 
-	ret = create_master (fs);
-	if (ret)
-		return ret;
+    ret = create_master(fs);
+    if (ret)
+        return ret;
 
-	ret = gf_thread_create (&fs->poller, NULL, glfs_poller, fs, "glfspoll");
-	if (ret)
-		return ret;
+    ret = gf_thread_create(&fs->poller, NULL, glfs_poller, fs, "glfspoll");
+    if (ret)
+        return ret;
 
-	ret = glfs_volumes_init (fs);
-	if (ret)
-		return ret;
+    ret = glfs_volumes_init(fs);
+    if (ret)
+        return ret;
 
-	fs->dev_id = gf_dm_hashfn (fs->volname, strlen (fs->volname));
-	return ret;
+    fs->dev_id = gf_dm_hashfn(fs->volname, strlen(fs->volname));
+    return ret;
 }
 
-
 int
-glfs_init_async (struct glfs *fs, glfs_init_cbk cbk)
+glfs_init_async(struct glfs *fs, glfs_init_cbk cbk)
 {
-	int  ret = -1;
+    int ret = -1;
 
-	if (!fs || !fs->ctx) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-			"fs is not properly initialized.");
-		errno = EINVAL;
-		return ret;
-	}
+    if (!fs || !fs->ctx) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "fs is not properly initialized.");
+        errno = EINVAL;
+        return ret;
+    }
 
-	fs->init_cbk = cbk;
+    fs->init_cbk = cbk;
 
-	ret = glfs_init_common (fs);
+    ret = glfs_init_common(fs);
 
-	return ret;
+    return ret;
 }
 
-
 int
-pub_glfs_init (struct glfs *fs)
+pub_glfs_init(struct glfs *fs)
 {
-	int  ret = -1;
+    int ret = -1;
 
-        DECLARE_OLD_THIS;
+    DECLARE_OLD_THIS;
 
-	if (!fs || !fs->ctx) {
-		gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-			"fs is not properly initialized.");
-		errno = EINVAL;
-		return ret;
-	}
+    if (!fs || !fs->ctx) {
+        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
+               "fs is not properly initialized.");
+        errno = EINVAL;
+        return ret;
+    }
 
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	ret = glfs_init_common (fs);
-	if (ret)
-		goto out;
+    ret = glfs_init_common(fs);
+    if (ret)
+        goto out;
 
-	ret = glfs_init_wait (fs);
+    ret = glfs_init_wait(fs);
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
-        /* Set the initial current working directory to "/" */
-        if (ret >= 0) {
-                ret = glfs_chdir (fs, "/");
-        }
+    /* Set the initial current working directory to "/" */
+    if (ret >= 0) {
+        ret = glfs_chdir(fs, "/");
+    }
 
 invalid_fs:
-	return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_init, 3.4.0);
 
 static int
-glusterfs_ctx_destroy (glusterfs_ctx_t *ctx)
+glusterfs_ctx_destroy(glusterfs_ctx_t *ctx)
 {
-        call_pool_t       *pool            = NULL;
-        int               ret              = 0;
-        glusterfs_graph_t *trav_graph      = NULL;
-        glusterfs_graph_t *tmp             = NULL;
-
-        if (ctx == NULL)
-                return 0;
-
-        if (ctx->cmd_args.curr_server)
-                glfs_free_volfile_servers (&ctx->cmd_args);
-
-        glfs_free_xlator_options (&ctx->cmd_args);
-
-        /* For all the graphs, crawl through the xlator_t structs and free
-         * all its members except for the mem_acct member,
-         * as GF_FREE will be referencing it.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                xlator_tree_free_members (trav_graph->first);
-        }
-
-        /* Free the memory pool */
-        if (ctx->stub_mem_pool)
-                mem_pool_destroy (ctx->stub_mem_pool);
-        if (ctx->dict_pool)
-                mem_pool_destroy (ctx->dict_pool);
-        if (ctx->dict_data_pool)
-                mem_pool_destroy (ctx->dict_data_pool);
-        if (ctx->dict_pair_pool)
-                mem_pool_destroy (ctx->dict_pair_pool);
-        if (ctx->logbuf_pool)
-                mem_pool_destroy (ctx->logbuf_pool);
-
-        pool = ctx->pool;
-        if (pool) {
-                if (pool->frame_mem_pool)
-                        mem_pool_destroy (pool->frame_mem_pool);
-                if (pool->stack_mem_pool)
-                        mem_pool_destroy (pool->stack_mem_pool);
-                LOCK_DESTROY (&pool->lock);
-                GF_FREE (pool);
-        }
-
-        /* Free the event pool */
-        ret = event_pool_destroy (ctx->event_pool);
-
-        /* Free the iobuf pool */
-        iobuf_pool_destroy (ctx->iobuf_pool);
-
-        GF_FREE (ctx->process_uuid);
-        GF_FREE (ctx->cmd_args.volfile_id);
-        GF_FREE (ctx->cmd_args.process_name);
-
-        LOCK_DESTROY (&ctx->lock);
-        pthread_mutex_destroy (&ctx->notify_lock);
-        pthread_cond_destroy (&ctx->notify_cond);
-
-        /* Free all the graph structs and its containing xlator_t structs
-         * from this point there should be no reference to GF_FREE/GF_CALLOC
-         * as it will try to access mem_acct and the below function would
-         * have freed the same.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                glusterfs_graph_destroy_residual (trav_graph);
-        }
-
-        FREE (ctx);
-
-        return ret;
+    call_pool_t *pool = NULL;
+    int ret = 0;
+    glusterfs_graph_t *trav_graph = NULL;
+    glusterfs_graph_t *tmp = NULL;
+
+    if (ctx == NULL)
+        return 0;
+
+    if (ctx->cmd_args.curr_server)
+        glfs_free_volfile_servers(&ctx->cmd_args);
+
+    glfs_free_xlator_options(&ctx->cmd_args);
+
+    /* For all the graphs, crawl through the xlator_t structs and free
+     * all its members except for the mem_acct member,
+     * as GF_FREE will be referencing it.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        xlator_tree_free_members(trav_graph->first);
+    }
+
+    /* Free the memory pool */
+    if (ctx->stub_mem_pool)
+        mem_pool_destroy(ctx->stub_mem_pool);
+    if (ctx->dict_pool)
+        mem_pool_destroy(ctx->dict_pool);
+    if (ctx->dict_data_pool)
+        mem_pool_destroy(ctx->dict_data_pool);
+    if (ctx->dict_pair_pool)
+        mem_pool_destroy(ctx->dict_pair_pool);
+    if (ctx->logbuf_pool)
+        mem_pool_destroy(ctx->logbuf_pool);
+
+    pool = ctx->pool;
+    if (pool) {
+        if (pool->frame_mem_pool)
+            mem_pool_destroy(pool->frame_mem_pool);
+        if (pool->stack_mem_pool)
+            mem_pool_destroy(pool->stack_mem_pool);
+        LOCK_DESTROY(&pool->lock);
+        GF_FREE(pool);
+    }
+
+    /* Free the event pool */
+    ret = event_pool_destroy(ctx->event_pool);
+
+    /* Free the iobuf pool */
+    iobuf_pool_destroy(ctx->iobuf_pool);
+
+    GF_FREE(ctx->process_uuid);
+    GF_FREE(ctx->cmd_args.volfile_id);
+    GF_FREE(ctx->cmd_args.process_name);
+
+    LOCK_DESTROY(&ctx->lock);
+    pthread_mutex_destroy(&ctx->notify_lock);
+    pthread_cond_destroy(&ctx->notify_cond);
+
+    /* Free all the graph structs and its containing xlator_t structs
+     * from this point there should be no reference to GF_FREE/GF_CALLOC
+     * as it will try to access mem_acct and the below function would
+     * have freed the same.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        glusterfs_graph_destroy_residual(trav_graph);
+    }
+
+    FREE(ctx);
+
+    return ret;
 }
 
 int
-pub_glfs_fini (struct glfs *fs)
+pub_glfs_fini(struct glfs *fs)
 {
-        int                ret = -1;
-        int                countdown = 100;
-        xlator_t           *subvol = NULL;
-        glusterfs_ctx_t    *ctx = NULL;
-        glusterfs_graph_t  *graph = NULL;
-        call_pool_t        *call_pool = NULL;
-        int                fs_init = 0;
-        int                err = -1;
-
-        DECLARE_OLD_THIS;
-
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        ctx = fs->ctx;
-        if (!ctx) {
-                goto free_fs;
-        }
-
-        if (ctx->mgmt) {
-                rpc_clnt_disable (ctx->mgmt);
-                rpc_clnt_unref (ctx->mgmt);
-                ctx->mgmt = NULL;
-        }
-
-        call_pool = fs->ctx->pool;
-
-        while (countdown--) {
-                /* give some time for background frames to finish */
-                pthread_mutex_lock (&fs->mutex);
-                {
-                        /* Do we need to increase countdown? */
-                        if ((!call_pool->cnt) && (!fs->pin_refcnt)) {
-                                gf_msg_trace ("glfs", 0,
-                                        "call_pool_cnt - %"PRId64","
-                                        "pin_refcnt - %d",
-                                        call_pool->cnt, fs->pin_refcnt);
-
-                                ctx->cleanup_started = 1;
-                                pthread_mutex_unlock (&fs->mutex);
-                                break;
-                        }
-                }
-                pthread_mutex_unlock (&fs->mutex);
-                usleep (100000);
-        }
-
-        /* leaked frames may exist, we ignore */
-
-        /*We deem glfs_fini as successful if there are no pending frames in the call
-         *pool*/
-        ret = (call_pool->cnt == 0)? 0: -1;
-
-        pthread_mutex_lock (&fs->mutex);
+    int ret = -1;
+    int countdown = 100;
+    xlator_t *subvol = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *graph = NULL;
+    call_pool_t *call_pool = NULL;
+    int fs_init = 0;
+    int err = -1;
+
+    DECLARE_OLD_THIS;
+
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    ctx = fs->ctx;
+    if (!ctx) {
+        goto free_fs;
+    }
+
+    if (ctx->mgmt) {
+        rpc_clnt_disable(ctx->mgmt);
+        rpc_clnt_unref(ctx->mgmt);
+        ctx->mgmt = NULL;
+    }
+
+    call_pool = fs->ctx->pool;
+
+    while (countdown--) {
+        /* give some time for background frames to finish */
+        pthread_mutex_lock(&fs->mutex);
         {
-                fs_init = fs->init;
+            /* Do we need to increase countdown? */
+            if ((!call_pool->cnt) && (!fs->pin_refcnt)) {
+                gf_msg_trace("glfs", 0,
+                             "call_pool_cnt - %" PRId64
+                             ","
+                             "pin_refcnt - %d",
+                             call_pool->cnt, fs->pin_refcnt);
+
+                ctx->cleanup_started = 1;
+                pthread_mutex_unlock(&fs->mutex);
+                break;
+            }
         }
-        pthread_mutex_unlock (&fs->mutex);
-
-        if (fs_init != 0) {
-                subvol = glfs_active_subvol (fs);
-                if (subvol) {
-                        /* PARENT_DOWN within glfs_subvol_done() is issued
-                           only on graph switch (new graph should activiate
-                           and decrement the extra @winds count taken in
-                           glfs_graph_setup()
-
-                           Since we are explicitly destroying,
-                           PARENT_DOWN is necessary
-                        */
-                        xlator_notify (subvol, GF_EVENT_PARENT_DOWN, subvol, 0);
-                        /* Here we wait for GF_EVENT_CHILD_DOWN before exiting,
-                           in case of asynchrnous cleanup
-                        */
-                        graph = subvol->graph;
-                        err = pthread_mutex_lock (&fs->mutex);
-                        if (err != 0) {
-                                gf_msg ("glfs", GF_LOG_ERROR, err,
-                                        API_MSG_FSMUTEX_LOCK_FAILED,
-                                        "pthread lock on glfs mutex, "
-                                        "returned error: (%s)", strerror (err));
-                                goto fail;
-                        }
-                        /* check and wait for CHILD_DOWN for active subvol*/
-                        {
-                                while (graph->used) {
-                                        err = pthread_cond_wait (&fs->child_down_cond,
-                                                                 &fs->mutex);
-                                        if (err != 0)
-                                                gf_msg ("glfs", GF_LOG_INFO, err,
-                                                        API_MSG_COND_WAIT_FAILED,
-                                                        "%s cond wait failed %s",
-                                                        subvol->name,
-                                                        strerror (err));
-                                }
-                        }
-
-                        err = pthread_mutex_unlock (&fs->mutex);
-                        if (err != 0) {
-                                gf_msg ("glfs", GF_LOG_ERROR, err,
-                                        API_MSG_FSMUTEX_UNLOCK_FAILED,
-                                        "pthread unlock on glfs mutex, "
-                                        "returned error: (%s)", strerror (err));
-                                goto fail;
-                        }
+        pthread_mutex_unlock(&fs->mutex);
+        usleep(100000);
+    }
+
+    /* leaked frames may exist, we ignore */
+
+    /*We deem glfs_fini as successful if there are no pending frames in the call
+     *pool*/
+    ret = (call_pool->cnt == 0) ? 0 : -1;
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        fs_init = fs->init;
+    }
+    pthread_mutex_unlock(&fs->mutex);
+
+    if (fs_init != 0) {
+        subvol = glfs_active_subvol(fs);
+        if (subvol) {
+            /* PARENT_DOWN within glfs_subvol_done() is issued
+               only on graph switch (new graph should activiate
+               and decrement the extra @winds count taken in
+               glfs_graph_setup()
+
+               Since we are explicitly destroying,
+               PARENT_DOWN is necessary
+            */
+            xlator_notify(subvol, GF_EVENT_PARENT_DOWN, subvol, 0);
+            /* Here we wait for GF_EVENT_CHILD_DOWN before exiting,
+               in case of asynchrnous cleanup
+            */
+            graph = subvol->graph;
+            err = pthread_mutex_lock(&fs->mutex);
+            if (err != 0) {
+                gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_LOCK_FAILED,
+                       "pthread lock on glfs mutex, "
+                       "returned error: (%s)",
+                       strerror(err));
+                goto fail;
+            }
+            /* check and wait for CHILD_DOWN for active subvol*/
+            {
+                while (graph->used) {
+                    err = pthread_cond_wait(&fs->child_down_cond, &fs->mutex);
+                    if (err != 0)
+                        gf_msg("glfs", GF_LOG_INFO, err,
+                               API_MSG_COND_WAIT_FAILED,
+                               "%s cond wait failed %s", subvol->name,
+                               strerror(err));
                 }
-                glfs_subvol_done (fs, subvol);
-        }
-
-        ctx->cleanup_started = 1;
-
-        if (fs_init != 0) {
-                /* Destroy all the inode tables of all the graphs.
-                 * NOTE:
-                 * - inode objects should be destroyed before calling fini()
-                 *   of each xlator, as fini() and forget() of the xlators
-                 *   can share few common locks or data structures, calling
-                 *   fini first might destroy those required by forget
-                 *   ( eg: in quick-read)
-                 * - The call to inode_table_destroy_all is not required when
-                 *   the cleanup during graph switch is implemented to perform
-                 *   inode table destroy.
-                 */
-                inode_table_destroy_all (ctx);
-
-                /* Call fini() of all the xlators in the active graph
-                 * NOTE:
-                 * - xlator fini() should be called before destroying any of
-                 *   the threads. (eg: fini() in protocol-client uses timer
-                 *   thread) */
-                glusterfs_graph_deactivate (ctx->active);
-
-                /* Join the syncenv_processor threads and cleanup
-                 * syncenv resources*/
-                syncenv_destroy (ctx->env);
-
-                /* Join the poller thread */
-                if (event_dispatch_destroy (ctx->event_pool) < 0)
-                        ret = -1;
+            }
+
+            err = pthread_mutex_unlock(&fs->mutex);
+            if (err != 0) {
+                gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_UNLOCK_FAILED,
+                       "pthread unlock on glfs mutex, "
+                       "returned error: (%s)",
+                       strerror(err));
+                goto fail;
+            }
         }
-
-        /* log infra has to be brought down before destroying
-         * timer registry, as logging uses timer infra
+        glfs_subvol_done(fs, subvol);
+    }
+
+    ctx->cleanup_started = 1;
+
+    if (fs_init != 0) {
+        /* Destroy all the inode tables of all the graphs.
+         * NOTE:
+         * - inode objects should be destroyed before calling fini()
+         *   of each xlator, as fini() and forget() of the xlators
+         *   can share few common locks or data structures, calling
+         *   fini first might destroy those required by forget
+         *   ( eg: in quick-read)
+         * - The call to inode_table_destroy_all is not required when
+         *   the cleanup during graph switch is implemented to perform
+         *   inode table destroy.
          */
-        if (gf_log_fini (ctx) != 0)
-                ret = -1;
+        inode_table_destroy_all(ctx);
+
+        /* Call fini() of all the xlators in the active graph
+         * NOTE:
+         * - xlator fini() should be called before destroying any of
+         *   the threads. (eg: fini() in protocol-client uses timer
+         *   thread) */
+        glusterfs_graph_deactivate(ctx->active);
+
+        /* Join the syncenv_processor threads and cleanup
+         * syncenv resources*/
+        syncenv_destroy(ctx->env);
+
+        /* Join the poller thread */
+        if (event_dispatch_destroy(ctx->event_pool) < 0)
+            ret = -1;
+    }
+
+    /* log infra has to be brought down before destroying
+     * timer registry, as logging uses timer infra
+     */
+    if (gf_log_fini(ctx) != 0)
+        ret = -1;
 
-        /* Join the timer thread */
-        if (fs_init != 0) {
-                gf_timer_registry_destroy (ctx);
-        }
+    /* Join the timer thread */
+    if (fs_init != 0) {
+        gf_timer_registry_destroy(ctx);
+    }
 
-        /* Destroy the context and the global pools */
-        if (glusterfs_ctx_destroy (ctx) != 0)
-                ret = -1;
+    /* Destroy the context and the global pools */
+    if (glusterfs_ctx_destroy(ctx) != 0)
+        ret = -1;
 
 free_fs:
-        glfs_free_from_ctx (fs);
+    glfs_free_from_ctx(fs);
 
-        /*
-         * Do this as late as possible in case anything else has (or
-         * grows) a dependency on mem-pool allocations.
-         */
-        mem_pools_fini ();
+    /*
+     * Do this as late as possible in case anything else has (or
+     * grows) a dependency on mem-pool allocations.
+     */
+    mem_pools_fini();
 
 fail:
-        if (!ret)
-                ret = err;
+    if (!ret)
+        ret = err;
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_fini, 3.4.0);
 
-
 ssize_t
-pub_glfs_get_volfile (struct glfs *fs, void *buf, size_t len)
+pub_glfs_get_volfile(struct glfs *fs, void *buf, size_t len)
 {
-        ssize_t         res = -1;
+    ssize_t res = -1;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        glfs_lock(fs, _gf_true);
-        if (len >= fs->oldvollen) {
-                gf_msg_trace ("glfs", 0, "copying %zu to %p", len, buf);
-                memcpy(buf,fs->oldvolfile,len);
-                res = len;
-        }
-        else {
-                res = len - fs->oldvollen;
-                gf_msg_trace ("glfs", 0, "buffer is %zd too short", -res);
-        }
-        glfs_unlock(fs);
+    glfs_lock(fs, _gf_true);
+    if (len >= fs->oldvollen) {
+        gf_msg_trace("glfs", 0, "copying %zu to %p", len, buf);
+        memcpy(buf, fs->oldvolfile, len);
+        res = len;
+    } else {
+        res = len - fs->oldvollen;
+        gf_msg_trace("glfs", 0, "buffer is %zd too short", -res);
+    }
+    glfs_unlock(fs);
 
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return res;
+    return res;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_get_volfile, 3.6.0);
 
 int
-priv_glfs_ipc (struct glfs *fs, int opcode, void *xd_in, void **xd_out)
+priv_glfs_ipc(struct glfs *fs, int opcode, void *xd_in, void **xd_out)
 {
-	xlator_t        *subvol = NULL;
-        int             ret = -1;
+    xlator_t *subvol = NULL;
+    int ret = -1;
 
-	DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
+    subvol = glfs_active_subvol(fs);
+    if (!subvol) {
+        ret = -1;
+        errno = EIO;
+        goto out;
+    }
 
-	ret = syncop_ipc (subvol, opcode, (dict_t *) xd_in, (dict_t **) xd_out);
-        DECODE_SYNCOP_ERR (ret);
+    ret = syncop_ipc(subvol, opcode, (dict_t *)xd_in, (dict_t **)xd_out);
+    DECODE_SYNCOP_ERR(ret);
 
 out:
-        glfs_subvol_done (fs, subvol);
-        __GLFS_EXIT_FS;
+    glfs_subvol_done(fs, subvol);
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_ipc, 3.12.0);
 
-
 void
-pub_glfs_free (void *ptr)
+pub_glfs_free(void *ptr)
 {
-        GLFS_FREE (ptr);
+    GLFS_FREE(ptr);
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_free, 3.7.16);
 
-
-struct glfs*
-pub_glfs_upcall_get_fs (struct glfs_upcall *arg)
+struct glfs *
+pub_glfs_upcall_get_fs(struct glfs_upcall *arg)
 {
-        return arg->fs;
+    return arg->fs;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_fs, 3.7.16);
 
 enum glfs_upcall_reason
-pub_glfs_upcall_get_reason (struct glfs_upcall *arg)
+pub_glfs_upcall_get_reason(struct glfs_upcall *arg)
 {
-        return arg->reason;
+    return arg->reason;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_reason, 3.7.16);
 
-void*
-pub_glfs_upcall_get_event (struct glfs_upcall *arg)
+void *
+pub_glfs_upcall_get_event(struct glfs_upcall *arg)
 {
-        return arg->event;
+    return arg->event;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_get_event, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_object (struct glfs_upcall_inode *arg)
+struct glfs_object *
+pub_glfs_upcall_inode_get_object(struct glfs_upcall_inode *arg)
 {
-        return arg->object;
+    return arg->object;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_object, 3.7.16);
 
 uint64_t
-pub_glfs_upcall_inode_get_flags (struct glfs_upcall_inode *arg)
+pub_glfs_upcall_inode_get_flags(struct glfs_upcall_inode *arg)
 {
-        return arg->flags;
+    return arg->flags;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_flags, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_stat (struct glfs_upcall_inode *arg)
+struct stat *
+pub_glfs_upcall_inode_get_stat(struct glfs_upcall_inode *arg)
 {
-        return &arg->buf;
+    return &arg->buf;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_stat, 3.7.16);
 
 uint64_t
-pub_glfs_upcall_inode_get_expire (struct glfs_upcall_inode *arg)
+pub_glfs_upcall_inode_get_expire(struct glfs_upcall_inode *arg)
 {
-        return arg->expire_time_attr;
+    return arg->expire_time_attr;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_expire, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_pobject (struct glfs_upcall_inode *arg)
+struct glfs_object *
+pub_glfs_upcall_inode_get_pobject(struct glfs_upcall_inode *arg)
 {
-        return arg->p_object;
+    return arg->p_object;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pobject, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_pstat (struct glfs_upcall_inode *arg)
+struct stat *
+pub_glfs_upcall_inode_get_pstat(struct glfs_upcall_inode *arg)
 {
-        return &arg->p_buf;
+    return &arg->p_buf;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_pstat, 3.7.16);
 
-struct glfs_object*
-pub_glfs_upcall_inode_get_oldpobject (struct glfs_upcall_inode *arg)
+struct glfs_object *
+pub_glfs_upcall_inode_get_oldpobject(struct glfs_upcall_inode *arg)
 {
-        return arg->oldp_object;
+    return arg->oldp_object;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpobject, 3.7.16);
 
-struct stat*
-pub_glfs_upcall_inode_get_oldpstat (struct glfs_upcall_inode *arg)
+struct stat *
+pub_glfs_upcall_inode_get_oldpstat(struct glfs_upcall_inode *arg)
 {
-        return &arg->oldp_buf;
+    return &arg->oldp_buf;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_inode_get_oldpstat, 3.7.16);
 
-
 /*struct glfs_object*
 pub_glfs_upcall_lease_get_object (struct glfs_upcall_recall_inode *arg)
 {
@@ -1581,169 +1536,166 @@ GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_object, 4.0.0);
 */
 
 uint32_t
-pub_glfs_upcall_lease_get_lease_type (struct glfs_upcall_lease *arg)
+pub_glfs_upcall_lease_get_lease_type(struct glfs_upcall_lease *arg)
 {
-        return arg->lease_type;
+    return arg->lease_type;
 }
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_lease_get_lease_type, 4.0.0);
 
 /* definitions of the GLFS_SYSRQ_* chars are in glfs.h */
 static struct glfs_sysrq_help {
-        char  sysrq;
-        char *msg;
-} glfs_sysrq_help[] = {
-        { GLFS_SYSRQ_HELP,      "(H)elp" },
-        { GLFS_SYSRQ_STATEDUMP, "(S)tatedump" },
-        { 0,                    NULL }
-};
+    char sysrq;
+    char *msg;
+} glfs_sysrq_help[] = {{GLFS_SYSRQ_HELP, "(H)elp"},
+                       {GLFS_SYSRQ_STATEDUMP, "(S)tatedump"},
+                       {0, NULL}};
 
 int
-pub_glfs_sysrq (struct glfs *fs, char sysrq)
+pub_glfs_sysrq(struct glfs *fs, char sysrq)
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        int               ret = 0;
-        int               msg_len;
-        char              msg[1024] = {0,}; /* should not exceed 1024 chars */
-
-        if (!fs || !fs->ctx) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    int msg_len;
+    char msg[1024] = {
+        0,
+    }; /* should not exceed 1024 chars */
+
+    if (!fs || !fs->ctx) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-        ctx = fs->ctx;
+    ctx = fs->ctx;
 
-        switch (sysrq) {
-        case GLFS_SYSRQ_HELP:
-        {
-                struct glfs_sysrq_help *usage = NULL;
-
-                for (usage = glfs_sysrq_help; usage->sysrq; usage++) {
-                        msg_len = strlen(msg);
-                        snprintf (msg + msg_len, /* append to msg */
-                                  sizeof (msg) - msg_len - 2,
-                                  /* - 2 for the " " + terminating \0 */
-                                  " %s", usage->msg);
-                }
+    switch (sysrq) {
+        case GLFS_SYSRQ_HELP: {
+            struct glfs_sysrq_help *usage = NULL;
 
-                /* not really an 'error', but make sure it gets logged */
-                gf_log ("glfs", GF_LOG_ERROR, "available events: %s", msg);
+            for (usage = glfs_sysrq_help; usage->sysrq; usage++) {
+                msg_len = strlen(msg);
+                snprintf(msg + msg_len, /* append to msg */
+                         sizeof(msg) - msg_len - 2,
+                         /* - 2 for the " " + terminating \0 */
+                         " %s", usage->msg);
+            }
 
-                break;
+            /* not really an 'error', but make sure it gets logged */
+            gf_log("glfs", GF_LOG_ERROR, "available events: %s", msg);
+
+            break;
         }
         case GLFS_SYSRQ_STATEDUMP:
-                gf_proc_dump_info (SIGUSR1, ctx);
-                break;
+            gf_proc_dump_info(SIGUSR1, ctx);
+            break;
         default:
-                gf_msg ("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY,
-                        "'%c' is not a valid sysrq", sysrq);
-                errno = ENOTSUP;
-                ret = -1;
-        }
+            gf_msg("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY,
+                   "'%c' is not a valid sysrq", sysrq);
+            errno = ENOTSUP;
+            ret = -1;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_sysrq, 3.10.0);
 
 int
-pub_glfs_upcall_register (struct glfs *fs, uint32_t event_list,
-                          glfs_upcall_cbk cbk, void *data)
+pub_glfs_upcall_register(struct glfs *fs, uint32_t event_list,
+                         glfs_upcall_cbk cbk, void *data)
 {
-        int ret = 0;
-
-        /* list of supported upcall events */
-        uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE;
+    int ret = 0;
 
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
+    /* list of supported upcall events */
+    uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, cbk, out);
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
 
-        /* Event list should be either GLFS_EVENT_ANY
-         * or list of supported individual events (up_events)
-         */
-        if ((event_list != GLFS_EVENT_ANY) &&
-            (event_list & ~up_events)) {
-                errno = EINVAL;
-                ret = -1;
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-                        "invalid event_list (0x%08x)", event_list);
-                goto out;
-        }
+    GF_VALIDATE_OR_GOTO(THIS->name, cbk, out);
 
-        /* in case other thread does unregister */
-        pthread_mutex_lock (&fs->mutex);
-        {
-                if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
-                        /* @todo: Check if features.cache-invalidation is
-                         * enabled.
-                         */
-                        fs->upcall_events |=  GF_UPCALL_CACHE_INVALIDATION;
-                        ret |= GF_UPCALL_CACHE_INVALIDATION;
-                } else if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
-                        fs->upcall_events |=  GF_UPCALL_RECALL_LEASE;
-                        ret |= GF_UPCALL_RECALL_LEASE;
-                }
-                /* Override cbk function if existing */
-                fs->up_cbk = cbk;
-                fs->up_data = data;
-                fs->cache_upcalls = _gf_true;
+    /* Event list should be either GLFS_EVENT_ANY
+     * or list of supported individual events (up_events)
+     */
+    if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
+        errno = EINVAL;
+        ret = -1;
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
+               "invalid event_list (0x%08x)", event_list);
+        goto out;
+    }
+
+    /* in case other thread does unregister */
+    pthread_mutex_lock(&fs->mutex);
+    {
+        if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
+            /* @todo: Check if features.cache-invalidation is
+             * enabled.
+             */
+            fs->upcall_events |= GF_UPCALL_CACHE_INVALIDATION;
+            ret |= GF_UPCALL_CACHE_INVALIDATION;
+        } else if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
+            fs->upcall_events |= GF_UPCALL_RECALL_LEASE;
+            ret |= GF_UPCALL_RECALL_LEASE;
         }
-        pthread_mutex_unlock (&fs->mutex);
+        /* Override cbk function if existing */
+        fs->up_cbk = cbk;
+        fs->up_data = data;
+        fs->cache_upcalls = _gf_true;
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_register, 3.13.0);
 
 int
-pub_glfs_upcall_unregister (struct glfs *fs, uint32_t event_list)
+pub_glfs_upcall_unregister(struct glfs *fs, uint32_t event_list)
 {
-        int ret = 0;
-        /* list of supported upcall events */
-        uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE;
-
-        DECLARE_OLD_THIS;
-        __GLFS_ENTRY_VALIDATE_FS (fs, invalid_fs);
-
-        /* Event list should be either GLFS_EVENT_ANY
-         * or list of supported individual events (up_events)
-         */
-        if ((event_list != GLFS_EVENT_ANY) &&
-            (event_list & ~up_events)) {
-                errno = EINVAL;
-                ret = -1;
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-                        "invalid event_list (0x%08x)", event_list);
-                goto out;
+    int ret = 0;
+    /* list of supported upcall events */
+    uint32_t up_events = GLFS_EVENT_INODE_INVALIDATE;
+
+    DECLARE_OLD_THIS;
+    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);
+
+    /* Event list should be either GLFS_EVENT_ANY
+     * or list of supported individual events (up_events)
+     */
+    if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
+        errno = EINVAL;
+        ret = -1;
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
+               "invalid event_list (0x%08x)", event_list);
+        goto out;
+    }
+
+    pthread_mutex_lock(&fs->mutex);
+    {
+        if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
+            fs->upcall_events &= ~GF_UPCALL_CACHE_INVALIDATION;
+            ret |= GF_UPCALL_CACHE_INVALIDATION;
         }
 
-        pthread_mutex_lock (&fs->mutex);
-        {
-                if (event_list & GLFS_EVENT_INODE_INVALIDATE) {
-                        fs->upcall_events &=  ~GF_UPCALL_CACHE_INVALIDATION;
-                        ret |= GF_UPCALL_CACHE_INVALIDATION;
-                }
-
-                /* If there are no upcall events registered, reset cbk */
-                if (fs->upcall_events == 0) {
-                        fs->up_cbk = NULL;
-                        fs->up_data = NULL;
-                        fs->cache_upcalls = _gf_false;
-                }
+        /* If there are no upcall events registered, reset cbk */
+        if (fs->upcall_events == 0) {
+            fs->up_cbk = NULL;
+            fs->up_data = NULL;
+            fs->cache_upcalls = _gf_false;
         }
-        pthread_mutex_unlock (&fs->mutex);
+    }
+    pthread_mutex_unlock(&fs->mutex);
 
 out:
-        __GLFS_EXIT_FS;
+    __GLFS_EXIT_FS;
 
 invalid_fs:
-        return ret;
+    return ret;
 }
 
 GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_upcall_unregister, 3.13.0);
diff --git a/cli/src/cli-cmd-global.c b/cli/src/cli-cmd-global.c
index 3c8ae227ca7..e1bedf13542 100644
--- a/cli/src/cli-cmd-global.c
+++ b/cli/src/cli-cmd-global.c
@@ -30,111 +30,109 @@
 extern rpc_clnt_prog_t *cli_rpc_prog;
 
 int
-cli_cmd_global_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
+cli_cmd_global_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
 int
-cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount);
+cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount);
 
 struct cli_cmd global_cmds[] = {
-        { "global help",
-           cli_cmd_global_help_cbk,
-           "list global commands",
-        },
-        { "get-state [<daemon>] [[odir </path/to/output/dir/>] "
-          "[file <filename>]] [detail|volumeoptions]",
-          cli_cmd_get_state_cbk,
-          "Get local state representation of mentioned daemon",
-        },
-        {NULL,  NULL,  NULL}
-};
+    {
+        "global help",
+        cli_cmd_global_help_cbk,
+        "list global commands",
+    },
+    {
+        "get-state [<daemon>] [[odir </path/to/output/dir/>] "
+        "[file <filename>]] [detail|volumeoptions]",
+        cli_cmd_get_state_cbk,
+        "Get local state representation of mentioned daemon",
+    },
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_global_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount)
+cli_cmd_global_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *global_cmd = NULL;
-        int                   count     = 0;
-
-        cmd = GF_MALLOC (sizeof (global_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, global_cmds, sizeof (global_cmds));
-        count = (sizeof (global_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
-
-        cli_out ("\ngluster global commands");
-        cli_out ("========================\n");
-        for (global_cmd = cmd; global_cmd->pattern; global_cmd++)
-                if (_gf_false == global_cmd->disable)
-                        cli_out ("%s - %s", global_cmd->pattern,
-                                 global_cmd->desc);
-
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *global_cmd = NULL;
+    int count = 0;
+
+    cmd = GF_MALLOC(sizeof(global_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, global_cmds, sizeof(global_cmds));
+    count = (sizeof(global_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
+
+    cli_out("\ngluster global commands");
+    cli_out("========================\n");
+    for (global_cmd = cmd; global_cmd->pattern; global_cmd++)
+        if (_gf_false == global_cmd->disable)
+            cli_out("%s - %s", global_cmd->pattern, global_cmd->desc);
+
+    cli_out("\n");
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_global_register (struct cli_state *state)
+cli_cmd_global_register(struct cli_state *state)
 {
-        int ret = 0;
-        struct cli_cmd *cmd =  NULL;
-        for (cmd = global_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                        if (ret)
-                                goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+    for (cmd = global_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
-
+    return ret;
 }
 
 int
-cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                     sent        =   0;
-        int                     parse_error =   0;
-        int                     ret         =  -1;
-        rpc_clnt_procedure_t    *proc       =  NULL;
-        call_frame_t            *frame      =  NULL;
-        dict_t                  *options    =  NULL;
-        cli_local_t             *local      =  NULL;
-        char                    *op_errstr  =  NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        ret = cli_cmd_get_state_parse (state, words, wordcount, &options,
-                                       &op_errstr);
-
-        if (ret) {
-                if (op_errstr) {
-                        cli_err ("%s", op_errstr);
-                        cli_usage_out (word->pattern);
-                        GF_FREE (op_errstr);
-                } else
-                        cli_usage_out (word->pattern);
-
-                parse_error = 1;
-                goto out;
-        }
-
-        CLI_LOCAL_INIT (local, words, frame, options);
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_STATE];
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    int sent = 0;
+    int parse_error = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    char *op_errstr = NULL;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    ret = cli_cmd_get_state_parse(state, words, wordcount, &options,
+                                  &op_errstr);
+
+    if (ret) {
+        if (op_errstr) {
+            cli_err("%s", op_errstr);
+            cli_usage_out(word->pattern);
+            GF_FREE(op_errstr);
+        } else
+            cli_usage_out(word->pattern);
+
+        parse_error = 1;
+        goto out;
+    }
+
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_STATE];
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Getting daemon state failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Getting daemon state failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
-
diff --git a/cli/src/cli-cmd-misc.c b/cli/src/cli-cmd-misc.c
index c887515af85..04dd2efc220 100644
--- a/cli/src/cli-cmd-misc.c
+++ b/cli/src/cli-cmd-misc.c
@@ -35,107 +35,98 @@ extern struct cli_cmd global_cmds[];
 struct cli_cmd cli_misc_cmds[];
 
 int
-cli_cmd_quit_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_quit_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                 const char **words, int wordcount)
 {
-        exit (0);
+    exit(0);
 }
 
-
 static gf_boolean_t
-cli_is_help_command (const char *pattern)
+cli_is_help_command(const char *pattern)
 {
-        /* FixFixFix
-         * This is not the best way to determine whether
-         * this is a help command
-         */
-        if (strstr (pattern, "help"))
-                return _gf_true;
-
-        return _gf_false;
+    /* FixFixFix
+     * This is not the best way to determine whether
+     * this is a help command
+     */
+    if (strstr(pattern, "help"))
+        return _gf_true;
+
+    return _gf_false;
 }
 
-
 int
-cli_cmd_display_help (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount)
+cli_cmd_display_help(struct cli_state *state, struct cli_cmd_word *in_word,
+                     const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd[] = {cli_misc_cmds, cli_probe_cmds,
-                                        volume_cmds, bitrot_cmds, quota_cmds,
+    struct cli_cmd *cmd[] = {
+        cli_misc_cmds,
+        cli_probe_cmds,
+        volume_cmds,
+        bitrot_cmds,
+        quota_cmds,
 #if !defined(__NetBSD__)
-                                        tier_cmds,
+        tier_cmds,
 #endif
-                                        snapshot_cmds, global_cmds, NULL};
-        struct cli_cmd        *cmd_ind      = NULL;
-        int                    i            = 0;
-        gf_boolean_t           list_all     = _gf_false;
-
-         /* cli_system_cmds commands for internal usage
-           they are not exposed
-         */
-
-        /* If "help all" */
-        if (wordcount == 2)
-                list_all = _gf_true;
-
-        for (i = 0; cmd[i] != NULL; i++) {
-                for (cmd_ind = cmd[i]; cmd_ind->pattern; cmd_ind++) {
-                        if ((_gf_false == cmd_ind->disable) &&
-                            cli_is_help_command (cmd_ind->pattern)) {
-                                if (list_all && (cmd_ind->cbk)) {
-                                        cmd_ind->cbk (state, in_word, words,
-                                                      wordcount);
-                                } else {
-                                        cli_out (" %-25s- %s", cmd_ind->pattern,
-                                                 cmd_ind->desc);
-                                }
-                        }
+        snapshot_cmds,
+        global_cmds,
+        NULL
+    };
+    struct cli_cmd *cmd_ind = NULL;
+    int i = 0;
+    gf_boolean_t list_all = _gf_false;
+
+    /* cli_system_cmds commands for internal usage
+      they are not exposed
+    */
+
+    /* If "help all" */
+    if (wordcount == 2)
+        list_all = _gf_true;
+
+    for (i = 0; cmd[i] != NULL; i++) {
+        for (cmd_ind = cmd[i]; cmd_ind->pattern; cmd_ind++) {
+            if ((_gf_false == cmd_ind->disable) &&
+                cli_is_help_command(cmd_ind->pattern)) {
+                if (list_all && (cmd_ind->cbk)) {
+                    cmd_ind->cbk(state, in_word, words, wordcount);
+                } else {
+                    cli_out(" %-25s- %s", cmd_ind->pattern, cmd_ind->desc);
                 }
+            }
         }
+    }
 
-        cli_out ("\n");
-        return 0;
+    cli_out("\n");
+    return 0;
 }
 
-
 struct cli_cmd cli_help_cmds[] = {
-        { "help [all]",
-           cli_cmd_display_help,
-           "display help for command classes"},
-
-        { NULL, NULL, NULL }
-};
-
+    {"help [all]", cli_cmd_display_help, "display help for command classes"},
 
-struct cli_cmd cli_misc_cmds[] = {
-        { "quit",
-          cli_cmd_quit_cbk,
-          "quit"},
-        { "exit",
-          cli_cmd_quit_cbk,
-          "exit"},
+    {NULL, NULL, NULL}};
 
-        { NULL, NULL, NULL }
-};
+struct cli_cmd cli_misc_cmds[] = {{"quit", cli_cmd_quit_cbk, "quit"},
+                                  {"exit", cli_cmd_quit_cbk, "exit"},
 
+                                  {NULL, NULL, NULL}};
 
 int
-cli_cmd_misc_register (struct cli_state *state)
+cli_cmd_misc_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_misc_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
-
-        for (cmd = cli_help_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+
+    for (cmd = cli_misc_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
+
+    for (cmd = cli_help_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c
index 48d6ebd64a7..3f9056b5d9e 100644
--- a/cli/src/cli-cmd-parser.c
+++ b/cli/src/cli-cmd-parser.c
@@ -27,2726 +27,2794 @@
 #define MAX_SNAP_DESCRIPTION_LEN 1024
 
 struct snap_config_opt_vals_ snap_confopt_vals[] = {
-        {.op_name        = "snap-max-hard-limit",
-         .question       = "Changing snapshot-max-hard-limit "
-                           "will limit the creation of new snapshots "
-                           "if they exceed the new limit.\n"
-                           "Do you want to continue?"
-        },
-        {.op_name        = "snap-max-soft-limit",
-         .question       = "If Auto-delete is enabled, snap-max-soft-limit will"
-                           " trigger deletion of oldest snapshot, on the "
-                           "creation of new snapshot, when the "
-                           "snap-max-soft-limit is reached.\n"
-                           "Do you want to change the snap-max-soft-limit?"
-        },
-        {.op_name        = "both",
-        .question        = "Changing snapshot-max-hard-limit "
-                           "will limit the creation of new snapshots "
-                           "if they exceed the new snapshot-max-hard-limit.\n"
-                           "If Auto-delete is enabled, snap-max-soft-limit will"
-                           " trigger deletion of oldest snapshot, on the "
-                           "creation of new snapshot, when the "
-                           "snap-max-soft-limit is reached.\n"
-                           "Do you want to continue?"
-        },
-        {.op_name        = NULL,
-        }
-};
+    {.op_name = "snap-max-hard-limit",
+     .question = "Changing snapshot-max-hard-limit "
+                 "will limit the creation of new snapshots "
+                 "if they exceed the new limit.\n"
+                 "Do you want to continue?"},
+    {.op_name = "snap-max-soft-limit",
+     .question = "If Auto-delete is enabled, snap-max-soft-limit will"
+                 " trigger deletion of oldest snapshot, on the "
+                 "creation of new snapshot, when the "
+                 "snap-max-soft-limit is reached.\n"
+                 "Do you want to change the snap-max-soft-limit?"},
+    {.op_name = "both",
+     .question = "Changing snapshot-max-hard-limit "
+                 "will limit the creation of new snapshots "
+                 "if they exceed the new snapshot-max-hard-limit.\n"
+                 "If Auto-delete is enabled, snap-max-soft-limit will"
+                 " trigger deletion of oldest snapshot, on the "
+                 "creation of new snapshot, when the "
+                 "snap-max-soft-limit is reached.\n"
+                 "Do you want to continue?"},
+    {
+        .op_name = NULL,
+    }};
 
 enum cli_snap_config_set_types {
-        GF_SNAP_CONFIG_SET_HARD = 0,
-        GF_SNAP_CONFIG_SET_SOFT = 1,
-        GF_SNAP_CONFIG_SET_BOTH = 2,
+    GF_SNAP_CONFIG_SET_HARD = 0,
+    GF_SNAP_CONFIG_SET_SOFT = 1,
+    GF_SNAP_CONFIG_SET_BOTH = 2,
 };
 typedef enum cli_snap_config_set_types cli_snap_config_set_types;
 
 typedef struct _cli_brick {
-        struct list_head  list;
-        const char       *name;
-        int32_t           len;
+    struct list_head list;
+    const char *name;
+    int32_t len;
 } cli_brick_t;
 
 int
-cli_cmd_validate_volume (char *volname);
+cli_cmd_validate_volume(char *volname);
 
 static const char *
-id_sel (void *wcon)
+id_sel(void *wcon)
 {
-        return (const char *)wcon;
+    return (const char *)wcon;
 }
 
 static char *
-str_getunamb (const char *tok, char **opwords)
+str_getunamb(const char *tok, char **opwords)
 {
-        return (char *)cli_getunamb (tok, (void **)opwords, id_sel);
+    return (char *)cli_getunamb(tok, (void **)opwords, id_sel);
 }
 
 int32_t
-cli_cmd_bricks_parse (const char **words, int wordcount, int brick_index,
-                      char **bricks, int *brick_count)
+cli_cmd_bricks_parse(const char **words, int wordcount, int brick_index,
+                     char **bricks, int *brick_count)
 {
-        int                         ret = 0;
-        char                 *delimiter = NULL;
-        char                 *host_name = NULL;
-        char                  *tmp_host = NULL;
-        char                *bricks_str = NULL;
-        int                         len = 0;
-        int              brick_list_len = 1; /* For initial space */
-        struct list_head     brick_list = { 0, };
-        cli_brick_t              *brick = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (wordcount);
-        GF_ASSERT (bricks);
-        GF_ASSERT (brick_index > 0);
-        GF_ASSERT (brick_index < wordcount);
-
-        INIT_LIST_HEAD(&brick_list);
-
-        while (brick_index < wordcount) {
-                if (validate_brick_name ((char *)words[brick_index])) {
-                        cli_err ("Wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[brick_index]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        delimiter = strrchr (words[brick_index], ':');
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-
-                tmp_host = gf_strdup ((char *)words[brick_index]);
-                if (!tmp_host) {
-                        gf_log ("cli", GF_LOG_ERROR, "Out of memory");
-                        ret = -1;
-                        goto out;
-                }
-                get_host_name (tmp_host, &host_name);
-                if (!host_name) {
-                        ret = -1;
-                        gf_log("cli",GF_LOG_ERROR, "Unable to allocate "
-                               "memory");
-                        GF_FREE (tmp_host);
-                        goto out;
-                }
-
-                if (!(strcmp (host_name, "localhost") &&
-                      strcmp (host_name, "127.0.0.1") &&
-                      strncmp (host_name, "0.", 2))) {
-                        cli_err ("Please provide a valid hostname/ip other "
-                                 "than localhost, 127.0.0.1 or loopback "
-                                 "address (0.0.0.0 to 0.255.255.255).");
-                        ret = -1;
-                        GF_FREE (tmp_host);
-                        goto out;
-                }
-                if (!valid_internet_address (host_name, _gf_false)) {
-                        cli_err ("internet address '%s' does not conform to "
-                                 "standards", host_name);
-                }
-                GF_FREE (tmp_host);
-                list_for_each_entry(brick, &brick_list, list) {
-                        if (strcmp(brick->name, words[brick_index]) == 0) {
-                                ret = -1;
-                                cli_err("Found duplicate exports %s",
-                                        words[brick_index]);
-                                goto out;
-                        }
-                }
-
-                brick = GF_MALLOC(sizeof(cli_brick_t), gf_common_list_node);
-                if (brick == NULL) {
-                        ret = -1;
-                        gf_log("cli", GF_LOG_ERROR, "Out of memory");
-                        goto out;
-                }
-                len = strlen(words[brick_index]);
-                brick->name = words[brick_index];
-                brick->len = len;
-                list_add_tail(&brick->list, &brick_list);
-
-                brick_list_len += len + 1; /* Brick name + space */
-                ++(*brick_count);
-                ++brick_index;
-        }
-
-        /* If brick count is not valid exit here */
-        if (!*brick_count) {
-                cli_err ("No bricks specified");
-                ret = -1;
+    int ret = 0;
+    char *delimiter = NULL;
+    char *host_name = NULL;
+    char *tmp_host = NULL;
+    char *bricks_str = NULL;
+    int len = 0;
+    int brick_list_len = 1; /* For initial space */
+    struct list_head brick_list = {
+        0,
+    };
+    cli_brick_t *brick = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(wordcount);
+    GF_ASSERT(bricks);
+    GF_ASSERT(brick_index > 0);
+    GF_ASSERT(brick_index < wordcount);
+
+    INIT_LIST_HEAD(&brick_list);
+
+    while (brick_index < wordcount) {
+        if (validate_brick_name((char *)words[brick_index])) {
+            cli_err(
+                "Wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[brick_index]);
+            ret = -1;
+            goto out;
+        } else {
+            delimiter = strrchr(words[brick_index], ':');
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
                 goto out;
         }
 
-        brick_list_len++; /* For terminating null char */
-
-        bricks_str = GF_MALLOC(brick_list_len, gf_common_mt_char);
-        if (bricks_str == NULL) {
+        tmp_host = gf_strdup((char *)words[brick_index]);
+        if (!tmp_host) {
+            gf_log("cli", GF_LOG_ERROR, "Out of memory");
+            ret = -1;
+            goto out;
+        }
+        get_host_name(tmp_host, &host_name);
+        if (!host_name) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to allocate "
+                   "memory");
+            GF_FREE(tmp_host);
+            goto out;
+        }
+
+        if (!(strcmp(host_name, "localhost") &&
+              strcmp(host_name, "127.0.0.1") && strncmp(host_name, "0.", 2))) {
+            cli_err(
+                "Please provide a valid hostname/ip other "
+                "than localhost, 127.0.0.1 or loopback "
+                "address (0.0.0.0 to 0.255.255.255).");
+            ret = -1;
+            GF_FREE(tmp_host);
+            goto out;
+        }
+        if (!valid_internet_address(host_name, _gf_false)) {
+            cli_err(
+                "internet address '%s' does not conform to "
+                "standards",
+                host_name);
+        }
+        GF_FREE(tmp_host);
+        list_for_each_entry(brick, &brick_list, list)
+        {
+            if (strcmp(brick->name, words[brick_index]) == 0) {
                 ret = -1;
-                gf_log("cli", GF_LOG_ERROR, "Out of memory");
+                cli_err("Found duplicate exports %s", words[brick_index]);
                 goto out;
+            }
         }
-        *bricks = bricks_str;
-        *bricks_str = ' ';
-        bricks_str++;
-        while (!list_empty(&brick_list)) {
-                brick = list_first_entry(&brick_list, cli_brick_t, list);
-                list_del_init(&brick->list);
-                memcpy(bricks_str, brick->name, brick->len);
-                bricks_str[brick->len] = ' ';
-                bricks_str += brick->len + 1;
-                GF_FREE(brick);
+
+        brick = GF_MALLOC(sizeof(cli_brick_t), gf_common_list_node);
+        if (brick == NULL) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Out of memory");
+            goto out;
         }
-        *bricks_str = 0;
+        len = strlen(words[brick_index]);
+        brick->name = words[brick_index];
+        brick->len = len;
+        list_add_tail(&brick->list, &brick_list);
+
+        brick_list_len += len + 1; /* Brick name + space */
+        ++(*brick_count);
+        ++brick_index;
+    }
+
+    /* If brick count is not valid exit here */
+    if (!*brick_count) {
+        cli_err("No bricks specified");
+        ret = -1;
+        goto out;
+    }
+
+    brick_list_len++; /* For terminating null char */
+
+    bricks_str = GF_MALLOC(brick_list_len, gf_common_mt_char);
+    if (bricks_str == NULL) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        goto out;
+    }
+    *bricks = bricks_str;
+    *bricks_str = ' ';
+    bricks_str++;
+    while (!list_empty(&brick_list)) {
+        brick = list_first_entry(&brick_list, cli_brick_t, list);
+        list_del_init(&brick->list);
+        memcpy(bricks_str, brick->name, brick->len);
+        bricks_str[brick->len] = ' ';
+        bricks_str += brick->len + 1;
+        GF_FREE(brick);
+    }
+    *bricks_str = 0;
 
 out:
-        while (!list_empty(&brick_list)) {
-                brick = list_first_entry(&brick_list, cli_brick_t, list);
-                list_del_init(&brick->list);
-                GF_FREE(brick);
-        }
+    while (!list_empty(&brick_list)) {
+        brick = list_first_entry(&brick_list, cli_brick_t, list);
+        list_del_init(&brick->list);
+        GF_FREE(brick);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_create_disperse_check (struct cli_state *state, int *disperse,
-                               int *redundancy, int *data, int count)
+cli_cmd_create_disperse_check(struct cli_state *state, int *disperse,
+                              int *redundancy, int *data, int count)
 {
-        int i = 0;
-        int tmp = 0;
-        gf_answer_t answer = GF_ANSWER_NO;
-        char question[128];
-
-        const char *question1 = "There isn't an optimal redundancy value "
-                                "for this configuration. Do you want to "
-                                "create the volume with redundancy 1 ?";
-
-        const char *question2 = "The optimal redundancy for this "
-                                "configuration is %d. Do you want to create "
-                                "the volume with this value ?";
-
-        const char *question3 = "This configuration is not optimal on most "
-                                "workloads. Do you want to use it ?";
-
-        const char *question4 = "Redundancy for this configuration is %d. "
-                                "Do you want to create "
-                                "the volume with this value ?";
-
-        if (*data > 0) {
-                if (*disperse > 0 && *redundancy > 0) {
-                        if (*disperse != (*data + *redundancy)) {
-                                cli_err ("Disperse count(%d) should be equal "
-                                         "to sum of disperse-data count(%d) and "
-                                         "redundancy count(%d)", *disperse,
-                                         *data, *redundancy);
-                                return -1;
-                        }
-                } else if (*redundancy > 0) {
-                        *disperse = *data + *redundancy;
-                } else if (*disperse > 0) {
-                        *redundancy = *disperse - *data;
-                } else {
-                        if ((count - *data) >= *data) {
-                                cli_err ("Please provide redundancy count "
-                                         "along with disperse-data count");
-                                return -1;
-                        } else {
-                                sprintf (question, question4, count - *data);
-                                answer = cli_cmd_get_confirmation (state,
-                                                                   question);
-                                if (answer == GF_ANSWER_NO)
-                                        return -1;
-                                *redundancy = count - *data;
-                                *disperse = count;
-                        }
-                }
+    int i = 0;
+    int tmp = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    char question[128];
+
+    const char *question1 =
+        "There isn't an optimal redundancy value "
+        "for this configuration. Do you want to "
+        "create the volume with redundancy 1 ?";
+
+    const char *question2 =
+        "The optimal redundancy for this "
+        "configuration is %d. Do you want to create "
+        "the volume with this value ?";
+
+    const char *question3 =
+        "This configuration is not optimal on most "
+        "workloads. Do you want to use it ?";
+
+    const char *question4 =
+        "Redundancy for this configuration is %d. "
+        "Do you want to create "
+        "the volume with this value ?";
+
+    if (*data > 0) {
+        if (*disperse > 0 && *redundancy > 0) {
+            if (*disperse != (*data + *redundancy)) {
+                cli_err(
+                    "Disperse count(%d) should be equal "
+                    "to sum of disperse-data count(%d) and "
+                    "redundancy count(%d)",
+                    *disperse, *data, *redundancy);
+                return -1;
+            }
+        } else if (*redundancy > 0) {
+            *disperse = *data + *redundancy;
+        } else if (*disperse > 0) {
+            *redundancy = *disperse - *data;
+        } else {
+            if ((count - *data) >= *data) {
+                cli_err(
+                    "Please provide redundancy count "
+                    "along with disperse-data count");
+                return -1;
+            } else {
+                sprintf(question, question4, count - *data);
+                answer = cli_cmd_get_confirmation(state, question);
+                if (answer == GF_ANSWER_NO)
+                    return -1;
+                *redundancy = count - *data;
+                *disperse = count;
+            }
         }
+    }
 
-        if (*disperse <= 0) {
-                if (count < 3) {
-                        cli_err ("number of bricks must be greater "
-                                 "than 2");
+    if (*disperse <= 0) {
+        if (count < 3) {
+            cli_err(
+                "number of bricks must be greater "
+                "than 2");
 
-                        return -1;
-                }
-                *disperse = count;
+            return -1;
         }
+        *disperse = count;
+    }
 
-        if (*redundancy == -1) {
-                tmp = *disperse - 1;
-                for (i = tmp / 2;
-                     (i > 0) && ((tmp & -tmp) != tmp);
-                     i--, tmp--);
-
-                if (i == 0) {
-                        answer = cli_cmd_get_confirmation(state, question1);
-                        if (answer == GF_ANSWER_NO)
-                                return -1;
+    if (*redundancy == -1) {
+        tmp = *disperse - 1;
+        for (i = tmp / 2; (i > 0) && ((tmp & -tmp) != tmp); i--, tmp--)
+            ;
 
-                        *redundancy = 1;
-                }
-                else
-                {
-                        *redundancy = *disperse - tmp;
-                        if (*redundancy > 1) {
-                                sprintf(question, question2, *redundancy);
-                                answer = cli_cmd_get_confirmation(state,
-                                                                  question);
-                                if (answer == GF_ANSWER_NO)
-                                        return -1;
-                        }
-                }
+        if (i == 0) {
+            answer = cli_cmd_get_confirmation(state, question1);
+            if (answer == GF_ANSWER_NO)
+                return -1;
 
-                tmp = 0;
+            *redundancy = 1;
         } else {
-                tmp = *disperse - *redundancy;
+            *redundancy = *disperse - tmp;
+            if (*redundancy > 1) {
+                sprintf(question, question2, *redundancy);
+                answer = cli_cmd_get_confirmation(state, question);
+                if (answer == GF_ANSWER_NO)
+                    return -1;
+            }
         }
 
-        if (*redundancy > (*disperse - 1) / 2) {
-                cli_err ("redundancy must be less than %d for a "
-                         "disperse %d volume",
-                         (*disperse + 1) / 2, *disperse);
+        tmp = 0;
+    } else {
+        tmp = *disperse - *redundancy;
+    }
 
-                return -1;
-        }
+    if (*redundancy > (*disperse - 1) / 2) {
+        cli_err(
+            "redundancy must be less than %d for a "
+            "disperse %d volume",
+            (*disperse + 1) / 2, *disperse);
 
-        if ((tmp & -tmp) != tmp) {
-                answer = cli_cmd_get_confirmation(state, question3);
-                if (answer == GF_ANSWER_NO)
-                        return -1;
-        }
+        return -1;
+    }
 
-        return 0;
+    if ((tmp & -tmp) != tmp) {
+        answer = cli_cmd_get_confirmation(state, question3);
+        if (answer == GF_ANSWER_NO)
+            return -1;
+    }
+
+    return 0;
 }
 
 static int32_t
-cli_validate_disperse_volume (char *word, gf1_cluster_type type,
-                              const char **words, int32_t wordcount,
-                              int32_t index, int32_t *disperse_count,
-                              int32_t *redundancy_count,
-                              int32_t *data_count)
+cli_validate_disperse_volume(char *word, gf1_cluster_type type,
+                             const char **words, int32_t wordcount,
+                             int32_t index, int32_t *disperse_count,
+                             int32_t *redundancy_count, int32_t *data_count)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        switch (type) {
+    switch (type) {
         case GF_CLUSTER_TYPE_NONE:
         case GF_CLUSTER_TYPE_DISPERSE:
-                if (strcmp (word, "disperse") == 0) {
-                        if (*disperse_count >= 0) {
-                                cli_err ("disperse option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index + 1], disperse_count);
-                        if (ret == -1 && errno == EINVAL) {
-                                *disperse_count = 0;
-                                ret = 1;
-                        } else if (ret == -1) {
-                                goto out;
-                        } else {
-                                if (*disperse_count < 3) {
-                                        cli_err ("disperse count must "
-                                                 "be greater than 2");
-                                        goto out;
-                                }
-                                ret = 2;
-                        }
-                } else if (strcmp (word, "disperse-data") == 0) {
-                        if (*data_count >= 0) {
-                                cli_err ("disperse-data option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index+1], data_count);
-                        if (ret == -1 || *data_count < 2) {
-                                cli_err ("disperse-data must be greater than 1");
-                                goto out;
-                        }
-                        ret = 2;
-                } else if (strcmp (word, "redundancy") == 0) {
-                        if (*redundancy_count >= 0) {
-                                cli_err ("redundancy option given twice");
-                                goto out;
-                        }
-                        if (wordcount < (index+2)) {
-                                goto out;
-                        }
-                        ret = gf_string2int (words[index+1], redundancy_count);
-                        if (ret == -1 || *redundancy_count < 1) {
-                                cli_err ("redundancy must be greater than 0");
-                                goto out;
-                        }
-                        ret = 2;
-                }
-                break;
+            if (strcmp(word, "disperse") == 0) {
+                if (*disperse_count >= 0) {
+                    cli_err("disperse option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], disperse_count);
+                if (ret == -1 && errno == EINVAL) {
+                    *disperse_count = 0;
+                    ret = 1;
+                } else if (ret == -1) {
+                    goto out;
+                } else {
+                    if (*disperse_count < 3) {
+                        cli_err(
+                            "disperse count must "
+                            "be greater than 2");
+                        goto out;
+                    }
+                    ret = 2;
+                }
+            } else if (strcmp(word, "disperse-data") == 0) {
+                if (*data_count >= 0) {
+                    cli_err("disperse-data option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], data_count);
+                if (ret == -1 || *data_count < 2) {
+                    cli_err("disperse-data must be greater than 1");
+                    goto out;
+                }
+                ret = 2;
+            } else if (strcmp(word, "redundancy") == 0) {
+                if (*redundancy_count >= 0) {
+                    cli_err("redundancy option given twice");
+                    goto out;
+                }
+                if (wordcount < (index + 2)) {
+                    goto out;
+                }
+                ret = gf_string2int(words[index + 1], redundancy_count);
+                if (ret == -1 || *redundancy_count < 1) {
+                    cli_err("redundancy must be greater than 0");
+                    goto out;
+                }
+                ret = 2;
+            }
+            break;
         case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                cli_err ("striped-replicated-dispersed volume "
-                         "is not supported");
-                goto out;
+            cli_err(
+                "striped-replicated-dispersed volume "
+                "is not supported");
+            goto out;
         case GF_CLUSTER_TYPE_TIER:
-                cli_err ("tier-dispersed volume is not "
-                         "supported");
-                goto out;
+            cli_err(
+                "tier-dispersed volume is not "
+                "supported");
+            goto out;
         case GF_CLUSTER_TYPE_STRIPE:
-                cli_err ("striped-dispersed volume is not "
-                         "supported");
-                goto out;
+            cli_err(
+                "striped-dispersed volume is not "
+                "supported");
+            goto out;
         case GF_CLUSTER_TYPE_REPLICATE:
-                cli_err ("replicated-dispersed volume is not "
-                         "supported");
-                goto out;
+            cli_err(
+                "replicated-dispersed volume is not "
+                "supported");
+            goto out;
         default:
-                cli_err ("Invalid type given");
-                break;
-        }
+            cli_err("Invalid type given");
+            break;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_validate_volname (const char *volname)
+cli_validate_volname(const char *volname)
 {
-        int32_t            ret                       = -1;
-        int32_t            i                         = -1;
-        int                volname_len;
-        static const char * const invalid_volnames[] = {
-                                      "volume", "type", "subvolumes", "option",
-                                      "end-volume", "all", "volume_not_in_ring",
-                                      "description", "force",
-                                      "snap-max-hard-limit",
-                                      "snap-max-soft-limit", "auto-delete",
-                                      "activate-on-create", NULL};
-
-        if (volname[0] == '-')
-                goto out;
-
-        for (i = 0; invalid_volnames[i]; i++) {
-                if (!strcmp (volname, invalid_volnames[i])) {
-                        cli_err ("\"%s\" cannot be the name of a volume.",
-                                 volname);
-                        goto out;
-                }
-        }
+    int32_t ret = -1;
+    int32_t i = -1;
+    int volname_len;
+    static const char *const invalid_volnames[] = {"volume",
+                                                   "type",
+                                                   "subvolumes",
+                                                   "option",
+                                                   "end-volume",
+                                                   "all",
+                                                   "volume_not_in_ring",
+                                                   "description",
+                                                   "force",
+                                                   "snap-max-hard-limit",
+                                                   "snap-max-soft-limit",
+                                                   "auto-delete",
+                                                   "activate-on-create",
+                                                   NULL};
 
-        if (strchr (volname, '/'))
-                goto out;
+    if (volname[0] == '-')
+        goto out;
 
-        volname_len = strlen (volname);
-        if (volname_len > GD_VOLUME_NAME_MAX) {
-                cli_err("Volume name exceeds %d characters.",
-                        GD_VOLUME_NAME_MAX);
-                goto out;
+    for (i = 0; invalid_volnames[i]; i++) {
+        if (!strcmp(volname, invalid_volnames[i])) {
+            cli_err("\"%s\" cannot be the name of a volume.", volname);
+            goto out;
         }
+    }
 
-        for (i = 0; i < volname_len; i++) {
-                if (!isalnum (volname[i]) && (volname[i] != '_') &&
-                   (volname[i] != '-')) {
-                        cli_err ("Volume name should not contain \"%c\""
-                                 " character.\nVolume names can only"
-                                 "contain alphanumeric, '-' and '_' "
-                                 "characters.", volname[i]);
-                        goto out;
-                }
-        }
+    if (strchr(volname, '/'))
+        goto out;
 
-        ret = 0;
+    volname_len = strlen(volname);
+    if (volname_len > GD_VOLUME_NAME_MAX) {
+        cli_err("Volume name exceeds %d characters.", GD_VOLUME_NAME_MAX);
+        goto out;
+    }
+
+    for (i = 0; i < volname_len; i++) {
+        if (!isalnum(volname[i]) && (volname[i] != '_') &&
+            (volname[i] != '-')) {
+            cli_err(
+                "Volume name should not contain \"%c\""
+                " character.\nVolume names can only"
+                "contain alphanumeric, '-' and '_' "
+                "characters.",
+                volname[i]);
+            goto out;
+        }
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_create_parse (struct cli_state *state, const char **words,
-                             int wordcount, dict_t **options, char **brick_list)
+cli_cmd_volume_create_parse(struct cli_state *state, const char **words,
+                            int wordcount, dict_t **options, char **brick_list)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
-        gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
-        int     sub_count = 1;
-        int     brick_index = 0;
-        char    *trans_type = NULL;
-        int32_t index = 0;
-        char    *bricks = NULL;
-        int32_t brick_count = 0;
-        char    *opwords[] = { "replica", "stripe", "transport", "disperse",
-                               "redundancy", "disperse-data", "arbiter", NULL };
-
-        char    *w = NULL;
-        int      op_count = 0;
-        int32_t  replica_count = 1;
-        int32_t  arbiter_count = 0;
-        int32_t  stripe_count = 1;
-        int32_t  disperse_count = -1;
-        int32_t  redundancy_count = -1;
-        int32_t  disperse_data_count = -1;
-        gf_boolean_t is_force = _gf_false;
-        int wc = wordcount;
-        gf_answer_t answer = GF_ANSWER_NO;
-        const char *question = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
+    int sub_count = 1;
+    int brick_index = 0;
+    char *trans_type = NULL;
+    int32_t index = 0;
+    char *bricks = NULL;
+    int32_t brick_count = 0;
+    char *opwords[] = {"replica",    "stripe",        "transport", "disperse",
+                       "redundancy", "disperse-data", "arbiter",   NULL};
+
+    char *w = NULL;
+    int op_count = 0;
+    int32_t replica_count = 1;
+    int32_t arbiter_count = 0;
+    int32_t stripe_count = 1;
+    int32_t disperse_count = -1;
+    int32_t redundancy_count = -1;
+    int32_t disperse_data_count = -1;
+    gf_boolean_t is_force = _gf_false;
+    int wc = wordcount;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    if (wordcount < 3)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        if (wordcount < 4) {
-                ret = -1;
-                goto out;
-        }
+    if (wordcount < 4) {
+        ret = -1;
+        goto out;
+    }
 
-        type = GF_CLUSTER_TYPE_NONE;
-        index = 3;
+    type = GF_CLUSTER_TYPE_NONE;
+    index = 3;
 
-        while (op_count < 3) {
+    while (op_count < 3) {
+        ret = -1;
+        w = str_getunamb(words[index], opwords);
+        if (!w) {
+            break;
+        } else if ((strcmp(w, "replica")) == 0) {
+            switch (type) {
+                case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
+                case GF_CLUSTER_TYPE_REPLICATE:
+                    cli_err("replica option given twice");
+                    goto out;
+                case GF_CLUSTER_TYPE_NONE:
+                    type = GF_CLUSTER_TYPE_REPLICATE;
+                    break;
+                case GF_CLUSTER_TYPE_STRIPE:
+                    type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
+                    break;
+                case GF_CLUSTER_TYPE_TIER:
+                    cli_err(
+                        "replicated-tiered volume is not "
+                        "supported");
+                    goto out;
+                    break;
+                case GF_CLUSTER_TYPE_DISPERSE:
+                    cli_err(
+                        "replicated-dispersed volume is not "
+                        "supported");
+                    goto out;
+                default:
+                    cli_err("Invalid type given");
+                    goto out;
+            }
+
+            if (wordcount < (index + 2)) {
                 ret = -1;
-                w = str_getunamb (words[index], opwords);
-                if (!w) {
-                        break;
-                } else if ((strcmp (w, "replica")) == 0) {
-                        switch (type) {
-                        case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                        case GF_CLUSTER_TYPE_REPLICATE:
-                                cli_err ("replica option given twice");
-                                goto out;
-                        case GF_CLUSTER_TYPE_NONE:
-                                type = GF_CLUSTER_TYPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_STRIPE:
-                                type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_TIER:
-                                cli_err ("replicated-tiered volume is not "
-                                         "supported");
-                                goto out;
-                                break;
-                        case GF_CLUSTER_TYPE_DISPERSE:
-                                cli_err ("replicated-dispersed volume is not "
-                                         "supported");
-                                goto out;
-                        default:
-                                cli_err ("Invalid type given");
-                                goto out;
-                        }
-
-                        if (wordcount < (index+2)) {
-                                ret = -1;
-                                goto out;
-                        }
-
-                        replica_count = strtol (words[index+1], NULL, 0);
-                        if (replica_count < 2) {
-                                cli_err ("replica count should be greater"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        index += 2;
-                        if (words[index]) {
-                                if (!strcmp (words[index], "arbiter")) {
-                                        ret = gf_string2int (words[index+1],
-                                                             &arbiter_count);
-                                        if ((ret == -1) || (arbiter_count != 1)) {
-                                                cli_err ("For arbiter "
-                                                         "configuration, "
-                                                         "replica count must be"
-                                                         " 2 and arbiter count "
-                                                         "must be 1. The 3rd "
-                                                         "brick of the replica "
-                                                         "will be the arbiter");
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                        ret = dict_set_int32 (dict, "arbiter-count",
-                                                              arbiter_count);
-                                        if (ret)
-                                                goto out;
-                                        index += 2;
-                                }
-                        }
-
-                        /* Do this to keep glusterd happy with sending
-                           "replica 3 arbiter 1" options to server */
-                        if ((arbiter_count == 1) && (replica_count == 2))
-                                replica_count += arbiter_count;
-
-                        if (replica_count == 2) {
-                                if (strcmp (words[wordcount - 1], "force")) {
-                                        question = "Replica 2 volumes are prone"
-                                                   " to split-brain. Use "
-                                                   "Arbiter or Replica 3 to "
-                                                   "avoid this. See: "
-                                                   "http://docs.gluster.org/en/latest/Administrator%20Guide/Split%20brain%20and%20ways%20to%20deal%20with%20it/."
-                                                   "\nDo you still want to "
-                                                   "continue?\n";
-                                        answer = cli_cmd_get_confirmation (state,
-                                                 question);
-                                        if (GF_ANSWER_NO == answer) {
-                                                gf_log ("cli", GF_LOG_ERROR,
-                                                        "Volume create "
-                                                        "cancelled, exiting");
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-                        }
-                        ret = dict_set_int32 (dict, "replica-count", replica_count);
-                        if (ret)
-                                goto out;
-
-                } else if ((strcmp (w, "stripe")) == 0) {
-                        switch (type) {
-                        case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
-                        case GF_CLUSTER_TYPE_STRIPE:
-                                cli_err ("stripe option given twice");
-                                goto out;
-                        case GF_CLUSTER_TYPE_NONE:
-                                type = GF_CLUSTER_TYPE_STRIPE;
-                                break;
-                        case GF_CLUSTER_TYPE_REPLICATE:
-                                type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
-                                break;
-                        case GF_CLUSTER_TYPE_DISPERSE:
-                                cli_err ("striped-dispersed volume is not "
-                                         "supported");
-                                goto out;
-                        case GF_CLUSTER_TYPE_TIER:
-                                cli_err ("striped-tier volume is not "
-                                         "supported");
-                                goto out;
-                        default:
-                                cli_err ("Invalid type given");
-                                goto out;
-                        }
-                        if (wordcount < (index + 2)) {
-                                ret = -1;
-                                goto out;
-                        }
-                        stripe_count = strtol (words[index+1], NULL, 0);
-                        if (stripe_count < 2) {
-                                cli_err ("stripe count should be greater"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_int32 (dict, "stripe-count", stripe_count);
-                        if (ret)
-                                goto out;
-
-                        index += 2;
+                goto out;
+            }
 
-                } else if ((strcmp (w, "transport")) == 0) {
-                        if (trans_type) {
-                                cli_err ("'transport' option given more"
-                                         " than one time");
-                                goto out;
-                        }
-                        if ((strcasecmp (words[index+1], "tcp") == 0)) {
-                                trans_type = gf_strdup ("tcp");
-                        } else if ((strcasecmp (words[index+1], "rdma") == 0)) {
-                                trans_type = gf_strdup ("rdma");
-                        } else if ((strcasecmp (words[index+1], "tcp,rdma") == 0) ||
-                                   (strcasecmp (words[index+1], "rdma,tcp") == 0)) {
-                                trans_type = gf_strdup ("tcp,rdma");
-                        } else {
-                                gf_log ("", GF_LOG_ERROR, "incorrect transport"
-                                        " protocol specified");
-                                ret = -1;
-                                goto out;
-                        }
-                        index += 2;
-
-                } else if ((strcmp (w, "disperse") == 0) ||
-                           (strcmp (w, "redundancy") == 0) ||
-                           (strcmp (w, "disperse-data") == 0)) {
-                        ret = cli_validate_disperse_volume (w, type, words,
-                                      wordcount, index, &disperse_count,
-                                      &redundancy_count, &disperse_data_count);
-                        if (ret < 0)
-                                goto out;
-                        index += ret;
-                        type = GF_CLUSTER_TYPE_DISPERSE;
-                } else if ((strcmp (w, "arbiter") == 0)) {
-                        cli_err ("arbiter option must be preceded by replica "
-                                 "option.");
+            replica_count = strtol(words[index + 1], NULL, 0);
+            if (replica_count < 2) {
+                cli_err(
+                    "replica count should be greater"
+                    " than 1");
+                ret = -1;
+                goto out;
+            }
+
+            index += 2;
+            if (words[index]) {
+                if (!strcmp(words[index], "arbiter")) {
+                    ret = gf_string2int(words[index + 1], &arbiter_count);
+                    if ((ret == -1) || (arbiter_count != 1)) {
+                        cli_err(
+                            "For arbiter "
+                            "configuration, "
+                            "replica count must be"
+                            " 2 and arbiter count "
+                            "must be 1. The 3rd "
+                            "brick of the replica "
+                            "will be the arbiter");
                         ret = -1;
                         goto out;
-                } else {
-                        GF_ASSERT (!"opword mismatch");
+                    }
+                    ret = dict_set_int32(dict, "arbiter-count", arbiter_count);
+                    if (ret)
+                        goto out;
+                    index += 2;
+                }
+            }
+
+            /* Do this to keep glusterd happy with sending
+               "replica 3 arbiter 1" options to server */
+            if ((arbiter_count == 1) && (replica_count == 2))
+                replica_count += arbiter_count;
+
+            if (replica_count == 2) {
+                if (strcmp(words[wordcount - 1], "force")) {
+                    question =
+                        "Replica 2 volumes are prone"
+                        " to split-brain. Use "
+                        "Arbiter or Replica 3 to "
+                        "avoid this. See: "
+                        "http://docs.gluster.org/en/latest/"
+                        "Administrator%20Guide/"
+                        "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                        "\nDo you still want to "
+                        "continue?\n";
+                    answer = cli_cmd_get_confirmation(state, question);
+                    if (GF_ANSWER_NO == answer) {
+                        gf_log("cli", GF_LOG_ERROR,
+                               "Volume create "
+                               "cancelled, exiting");
                         ret = -1;
                         goto out;
-                }
-                op_count++;
-        }
-
-        if (!trans_type)
-                trans_type = gf_strdup ("tcp");
-
-        if (index >= wordcount) {
+                    }
+                }
+            }
+            ret = dict_set_int32(dict, "replica-count", replica_count);
+            if (ret)
+                goto out;
+
+        } else if ((strcmp(w, "stripe")) == 0) {
+            switch (type) {
+                case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
+                case GF_CLUSTER_TYPE_STRIPE:
+                    cli_err("stripe option given twice");
+                    goto out;
+                case GF_CLUSTER_TYPE_NONE:
+                    type = GF_CLUSTER_TYPE_STRIPE;
+                    break;
+                case GF_CLUSTER_TYPE_REPLICATE:
+                    type = GF_CLUSTER_TYPE_STRIPE_REPLICATE;
+                    break;
+                case GF_CLUSTER_TYPE_DISPERSE:
+                    cli_err(
+                        "striped-dispersed volume is not "
+                        "supported");
+                    goto out;
+                case GF_CLUSTER_TYPE_TIER:
+                    cli_err(
+                        "striped-tier volume is not "
+                        "supported");
+                    goto out;
+                default:
+                    cli_err("Invalid type given");
+                    goto out;
+            }
+            if (wordcount < (index + 2)) {
+                ret = -1;
+                goto out;
+            }
+            stripe_count = strtol(words[index + 1], NULL, 0);
+            if (stripe_count < 2) {
+                cli_err(
+                    "stripe count should be greater"
+                    " than 1");
                 ret = -1;
                 goto out;
+            }
+            ret = dict_set_int32(dict, "stripe-count", stripe_count);
+            if (ret)
+                goto out;
+
+            index += 2;
+
+        } else if ((strcmp(w, "transport")) == 0) {
+            if (trans_type) {
+                cli_err(
+                    "'transport' option given more"
+                    " than one time");
+                goto out;
+            }
+            if ((strcasecmp(words[index + 1], "tcp") == 0)) {
+                trans_type = gf_strdup("tcp");
+            } else if ((strcasecmp(words[index + 1], "rdma") == 0)) {
+                trans_type = gf_strdup("rdma");
+            } else if ((strcasecmp(words[index + 1], "tcp,rdma") == 0) ||
+                       (strcasecmp(words[index + 1], "rdma,tcp") == 0)) {
+                trans_type = gf_strdup("tcp,rdma");
+            } else {
+                gf_log("", GF_LOG_ERROR,
+                       "incorrect transport"
+                       " protocol specified");
+                ret = -1;
+                goto out;
+            }
+            index += 2;
+
+        } else if ((strcmp(w, "disperse") == 0) ||
+                   (strcmp(w, "redundancy") == 0) ||
+                   (strcmp(w, "disperse-data") == 0)) {
+            ret = cli_validate_disperse_volume(
+                w, type, words, wordcount, index, &disperse_count,
+                &redundancy_count, &disperse_data_count);
+            if (ret < 0)
+                goto out;
+            index += ret;
+            type = GF_CLUSTER_TYPE_DISPERSE;
+        } else if ((strcmp(w, "arbiter") == 0)) {
+            cli_err(
+                "arbiter option must be preceded by replica "
+                "option.");
+            ret = -1;
+            goto out;
+        } else {
+            GF_ASSERT(!"opword mismatch");
+            ret = -1;
+            goto out;
         }
+        op_count++;
+    }
 
-        brick_index = index;
-
-        if (strcmp (words[wordcount - 1], "force") == 0) {
-                is_force = _gf_true;
-                wc = wordcount - 1;
-        }
+    if (!trans_type)
+        trans_type = gf_strdup("tcp");
 
-        ret = cli_cmd_bricks_parse (words, wc, brick_index, &bricks,
-                                    &brick_count);
-        if (ret)
-                goto out;
+    if (index >= wordcount) {
+        ret = -1;
+        goto out;
+    }
 
-        if (type == GF_CLUSTER_TYPE_DISPERSE) {
-                ret = cli_cmd_create_disperse_check (state, &disperse_count,
-                                                     &redundancy_count,
-                                                     &disperse_data_count,
-                                                     brick_count);
-                if (!ret)
-                        ret = dict_set_int32 (dict, "disperse-count",
-                                              disperse_count);
-                if (!ret)
-                        ret = dict_set_int32 (dict, "redundancy-count",
-                                              redundancy_count);
-                if (ret)
-                        goto out;
+    brick_index = index;
 
-                sub_count = disperse_count;
-        } else
-                sub_count = stripe_count * replica_count;
-
-        if (brick_count % sub_count) {
-                if (type == GF_CLUSTER_TYPE_STRIPE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "stripe count");
-                else if (type == GF_CLUSTER_TYPE_REPLICATE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "replica count");
-                else if (type == GF_CLUSTER_TYPE_DISPERSE)
-                        cli_err ("number of bricks is not a multiple of "
-                                 "disperse count");
-                else
-                        cli_err ("number of bricks given doesn't match "
-                                 "required count");
+    if (strcmp(words[wordcount - 1], "force") == 0) {
+        is_force = _gf_true;
+        wc = wordcount - 1;
+    }
 
-                ret = -1;
-                goto out;
-        }
+    ret = cli_cmd_bricks_parse(words, wc, brick_index, &bricks, &brick_count);
+    if (ret)
+        goto out;
 
-        /* Everything is parsed fine. start setting info in dict */
-        ret = dict_set_str (dict, "volname", volname);
+    if (type == GF_CLUSTER_TYPE_DISPERSE) {
+        ret = cli_cmd_create_disperse_check(state, &disperse_count,
+                                            &redundancy_count,
+                                            &disperse_data_count, brick_count);
+        if (!ret)
+            ret = dict_set_int32(dict, "disperse-count", disperse_count);
+        if (!ret)
+            ret = dict_set_int32(dict, "redundancy-count", redundancy_count);
         if (ret)
-                goto out;
+            goto out;
+
+        sub_count = disperse_count;
+    } else
+        sub_count = stripe_count * replica_count;
+
+    if (brick_count % sub_count) {
+        if (type == GF_CLUSTER_TYPE_STRIPE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "stripe count");
+        else if (type == GF_CLUSTER_TYPE_REPLICATE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "replica count");
+        else if (type == GF_CLUSTER_TYPE_DISPERSE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "disperse count");
+        else
+            cli_err(
+                "number of bricks given doesn't match "
+                "required count");
 
-        ret = dict_set_int32 (dict, "type", type);
-        if (ret)
-                goto out;
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_dynstr (dict, "transport", trans_type);
-        if (ret)
-                goto out;
-        trans_type = NULL;
+    /* Everything is parsed fine. start setting info in dict */
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        ret = dict_set_dynstr (dict, "bricks", bricks);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "type", type);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "count", brick_count);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(dict, "transport", trans_type);
+    if (ret)
+        goto out;
+    trans_type = NULL;
 
-        ret = dict_set_int32 (dict, "force", is_force);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(dict, "bricks", bricks);
+    if (ret)
+        goto out;
 
-        *options = dict;
-        *brick_list = bricks;
+    ret = dict_set_int32(dict, "count", brick_count);
+    if (ret)
+        goto out;
+
+    ret = dict_set_int32(dict, "force", is_force);
+    if (ret)
+        goto out;
+
+    *options = dict;
+    *brick_list = bricks;
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse create volume CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse create volume CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        GF_FREE (trans_type);
+    GF_FREE(trans_type);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_reset_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_volume_reset_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict)
-                goto out;
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    if (wordcount < 3)
+        goto out;
 
-        if (wordcount > 5)
-                goto out;
+    if (wordcount > 5)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (wordcount == 3) {
-                ret = dict_set_str (dict, "key", "all");
-                if (ret)
-                        goto out;
-        }
+    if (wordcount == 3) {
+        ret = dict_set_str(dict, "key", "all");
+        if (ret)
+            goto out;
+    }
 
-        if (wordcount >= 4) {
-                if (!strcmp ("force", (char*)words[3])) {
-                        ret = dict_set_int32 (dict, "force", 1);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "key", "all");
-                        if (ret)
-                                goto out;
-                } else {
-                        ret = dict_set_str (dict, "key", (char *)words[3]);
-                        if (ret)
-                                goto out;
-                }
+    if (wordcount >= 4) {
+        if (!strcmp("force", (char *)words[3])) {
+            ret = dict_set_int32(dict, "force", 1);
+            if (ret)
+                goto out;
+            ret = dict_set_str(dict, "key", "all");
+            if (ret)
+                goto out;
+        } else {
+            ret = dict_set_str(dict, "key", (char *)words[3]);
+            if (ret)
+                goto out;
         }
+    }
 
-        if (wordcount == 5) {
-                if (strcmp ("force", (char*)words[4])) {
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = dict_set_int32 (dict, "force", 1);
-                        if (ret)
-                                goto out;
-                }
+    if (wordcount == 5) {
+        if (strcmp("force", (char *)words[4])) {
+            ret = -1;
+            goto out;
+        } else {
+            ret = dict_set_int32(dict, "force", 1);
+            if (ret)
+                goto out;
         }
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
+    if (ret && dict) {
+        dict_unref(dict);
+    }
 
-                return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_get_state_parse (struct cli_state *state,
-                         const char **words, int wordcount,
-                         dict_t **options, char **op_errstr)
+cli_cmd_get_state_parse(struct cli_state *state, const char **words,
+                        int wordcount, dict_t **options, char **op_errstr)
 {
-        dict_t    *dict                 = NULL;
-        int        ret                  = -1;
-        char      *odir                 = NULL;
-        char      *filename             = NULL;
-        char      *daemon_name          = NULL;
-        int        count                = 0;
-        uint32_t   cmd                  = 0;
-
-        GF_VALIDATE_OR_GOTO ("cli", options, out);
-        GF_VALIDATE_OR_GOTO ("cli", words, out);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (wordcount < 1 || wordcount > 7) {
-                *op_errstr = gf_strdup ("Problem parsing arguments."
-                                        " Check usage.");
-                goto out;
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *odir = NULL;
+    char *filename = NULL;
+    char *daemon_name = NULL;
+    int count = 0;
+    uint32_t cmd = 0;
+
+    GF_VALIDATE_OR_GOTO("cli", options, out);
+    GF_VALIDATE_OR_GOTO("cli", words, out);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount >= 1) {
-                gf_asprintf (&daemon_name, "%s", "glusterd");
-
-                for (count = 1; count < wordcount; count++) {
-                        if (strcmp (words[count], "odir") == 0 ||
-                                        strcmp (words[count], "file") == 0) {
-                                if (strcmp (words[count], "odir") == 0) {
-                                        if (++count < wordcount) {
-                                                odir = (char *) words[count];
-                                                continue;
-                                        } else {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                } else if (strcmp (words[count], "file") == 0) {
-                                        if (++count < wordcount) {
-                                                filename = (char *) words[count];
-                                                continue;
-                                        } else {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-                        } else {
-                                if (count > 1) {
-                                        if (count == wordcount-1) {
-                                                if (strcmp (words[count],
-                                                            "detail") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_DETAIL;
-                                                        continue;
-                                                } else if (strcmp (words[count],
-                                                                   "volumeoptions") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_VOLOPTS;
-                                                        continue;
-                                                }
-                                        } else {
-                                                *op_errstr = gf_strdup ("Problem"
-                                                        " parsing arguments. "
-                                                        "Check usage.");
-                                                ret = -1;
-                                                goto out;
-                                        }
-
-                                }
-                                if (strcmp (words[count], "glusterd") == 0) {
-                                        continue;
-                                } else {
-                                        if (count == wordcount-1) {
-                                                if (strcmp (words[count],
-                                                            "detail") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_DETAIL;
-                                                        continue;
-                                                } else if (strcmp (words[count],
-                                                                   "volumeoptions") == 0) {
-                                                        cmd = GF_CLI_GET_STATE_VOLOPTS;
-                                                        continue;
-                                                }
-                                        }
-
-                                        *op_errstr = gf_strdup ("glusterd is "
-                                                 "the only supported daemon.");
-                                        ret = -1;
-                                        goto out;
-                                }
+    if (wordcount < 1 || wordcount > 7) {
+        *op_errstr = gf_strdup(
+            "Problem parsing arguments."
+            " Check usage.");
+        goto out;
+    }
+
+    if (wordcount >= 1) {
+        gf_asprintf(&daemon_name, "%s", "glusterd");
+
+        for (count = 1; count < wordcount; count++) {
+            if (strcmp(words[count], "odir") == 0 ||
+                strcmp(words[count], "file") == 0) {
+                if (strcmp(words[count], "odir") == 0) {
+                    if (++count < wordcount) {
+                        odir = (char *)words[count];
+                        continue;
+                    } else {
+                        ret = -1;
+                        goto out;
+                    }
+                } else if (strcmp(words[count], "file") == 0) {
+                    if (++count < wordcount) {
+                        filename = (char *)words[count];
+                        continue;
+                    } else {
+                        ret = -1;
+                        goto out;
+                    }
+                }
+            } else {
+                if (count > 1) {
+                    if (count == wordcount - 1) {
+                        if (strcmp(words[count], "detail") == 0) {
+                            cmd = GF_CLI_GET_STATE_DETAIL;
+                            continue;
+                        } else if (strcmp(words[count], "volumeoptions") == 0) {
+                            cmd = GF_CLI_GET_STATE_VOLOPTS;
+                            continue;
                         }
-                }
-
-                ret = dict_set_dynstr (dict, "daemon", daemon_name);
-                if (ret) {
-                        *op_errstr = gf_strdup ("Command failed. Please check "
-                                                " log file for more details.");
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "Setting daemon name to dictionary failed");
+                    } else {
+                        *op_errstr = gf_strdup(
+                            "Problem"
+                            " parsing arguments. "
+                            "Check usage.");
+                        ret = -1;
                         goto out;
+                    }
                 }
-                daemon_name = NULL;
-
-                if (odir) {
-                        ret = dict_set_str (dict, "odir", odir);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more details.");
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Setting output directory to"
-                                        "dictionary failed");
-                                goto out;
+                if (strcmp(words[count], "glusterd") == 0) {
+                    continue;
+                } else {
+                    if (count == wordcount - 1) {
+                        if (strcmp(words[count], "detail") == 0) {
+                            cmd = GF_CLI_GET_STATE_DETAIL;
+                            continue;
+                        } else if (strcmp(words[count], "volumeoptions") == 0) {
+                            cmd = GF_CLI_GET_STATE_VOLOPTS;
+                            continue;
                         }
-                }
+                    }
 
-                if (filename) {
-                        ret = dict_set_str (dict, "filename", filename);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more  details.");
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Setting filename to dictionary failed");
-                                goto out;
-                        }
-                }
-
-                if (cmd) {
-                        ret = dict_set_uint32 (dict, "getstate-cmd", cmd);
-                        if (ret) {
-                                *op_errstr = gf_strdup ("Command failed. Please"
-                                                        " check log file for"
-                                                        " more details.");
-                                gf_log (THIS->name, GF_LOG_ERROR, "Setting "
-                                        "get-state command type to dictionary "
-                                        "failed");
-                                goto out;
-                        }
+                    *op_errstr = gf_strdup(
+                        "glusterd is "
+                        "the only supported daemon.");
+                    ret = -1;
+                    goto out;
                 }
+            }
         }
 
- out:
-        if (dict)
-                *options = dict;
+        ret = dict_set_dynstr(dict, "daemon", daemon_name);
+        if (ret) {
+            *op_errstr = gf_strdup(
+                "Command failed. Please check "
+                " log file for more details.");
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "Setting daemon name to dictionary failed");
+            goto out;
+        }
+        daemon_name = NULL;
+
+        if (odir) {
+            ret = dict_set_str(dict, "odir", odir);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting output directory to"
+                       "dictionary failed");
+                goto out;
+            }
+        }
+
+        if (filename) {
+            ret = dict_set_str(dict, "filename", filename);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more  details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting filename to dictionary failed");
+                goto out;
+            }
+        }
+
+        if (cmd) {
+            ret = dict_set_uint32(dict, "getstate-cmd", cmd);
+            if (ret) {
+                *op_errstr = gf_strdup(
+                    "Command failed. Please"
+                    " check log file for"
+                    " more details.");
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Setting "
+                       "get-state command type to dictionary "
+                       "failed");
+                goto out;
+            }
+        }
+    }
 
-        if (ret && dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        *options = dict;
 
-        GF_FREE(daemon_name);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    GF_FREE(daemon_name);
+
+    return ret;
 }
 
 int32_t
-cli_cmd_inode_quota_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_inode_quota_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t          *dict    = NULL;
-        char            *volname = NULL;
-        int              ret     = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "dict_new failed");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "dict_new failed");
+        goto out;
+    }
 
-        if (wordcount != 4)
-                goto out;
+    if (wordcount != 4)
+        goto out;
 
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret < 0)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret < 0)
+        goto out;
 
-        if (strcmp (words[3], "enable") != 0) {
-                cli_out ("Invalid quota option : %s", words[3]);
-                ret = -1;
-                goto out;
-        }
+    if (strcmp(words[3], "enable") != 0) {
+        cli_out("Invalid quota option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "type",
-                              GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS);
-        if (ret < 0)
-                goto out;
+    ret = dict_set_int32(dict, "type", GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS);
+    if (ret < 0)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 out:
-        if (ret < 0) {
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret < 0) {
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_quota_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_quota_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t          *dict    = NULL;
-        char            *volname = NULL;
-        int              ret     = -1;
-        int              i       = -1;
-        char             key[20] = {0, };
-        int64_t          value   = 0;
-        gf_quota_type    type    = GF_QUOTA_OPTION_TYPE_NONE;
-        char           *opwords[] = { "enable", "disable", "limit-usage",
-                                      "remove", "list", "alert-time",
-                                      "soft-timeout", "hard-timeout",
-                                      "default-soft-limit", "limit-objects",
-                                      "list-objects", "remove-objects", NULL};
-        char            *w       = NULL;
-        uint32_t         time    = 0;
-        double           percent = 0;
-        char            *end_ptr = NULL;
-        int64_t          limit   = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "dict_new failed");
-                goto out;
-        }
-
-        if (wordcount < 4) {
-
-                if ((wordcount == 3) && !(strcmp (words[2], "help"))) {
-                        ret = 1;
-                }
-                goto out;
-        }
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int i = -1;
+    char key[20] = {
+        0,
+    };
+    int64_t value = 0;
+    gf_quota_type type = GF_QUOTA_OPTION_TYPE_NONE;
+    char *opwords[] = {"enable",
+                       "disable",
+                       "limit-usage",
+                       "remove",
+                       "list",
+                       "alert-time",
+                       "soft-timeout",
+                       "hard-timeout",
+                       "default-soft-limit",
+                       "limit-objects",
+                       "list-objects",
+                       "remove-objects",
+                       NULL};
+    char *w = NULL;
+    uint32_t time = 0;
+    double percent = 0;
+    char *end_ptr = NULL;
+    int64_t limit = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "dict_new failed");
+        goto out;
+    }
 
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
+    if (wordcount < 4) {
+        if ((wordcount == 3) && !(strcmp(words[2], "help"))) {
+            ret = 1;
         }
+        goto out;
+    }
 
-        /* Validate the volume name here itself */
-        if (cli_validate_volname (volname) < 0)
-                goto out;
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret < 0)
-                goto out;
+    /* Validate the volume name here itself */
+    if (cli_validate_volname(volname) < 0)
+        goto out;
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                cli_out ("Invalid quota option : %s", words[3]);
-                ret = - 1;
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret < 0)
+        goto out;
 
-        if (strcmp (w, "enable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_QUOTA_OPTION_TYPE_ENABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        cli_out("Invalid quota option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
 
-        if (strcmp (w, "disable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_QUOTA_OPTION_TYPE_DISABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    if (strcmp(w, "enable") == 0) {
+        if (wordcount == 4) {
+            type = GF_QUOTA_OPTION_TYPE_ENABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (strcmp (w, "limit-usage") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIMIT_USAGE;
-        } else if (strcmp (w, "limit-objects") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS;
+    if (strcmp(w, "disable") == 0) {
+        if (wordcount == 4) {
+            type = GF_QUOTA_OPTION_TYPE_DISABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE ||
-            type == GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS) {
+    if (strcmp(w, "limit-usage") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIMIT_USAGE;
+    } else if (strcmp(w, "limit-objects") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS;
+    }
 
-                if (wordcount < 6 || wordcount > 7) {
-                        ret = -1;
-                        goto out;
-                }
+    if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE ||
+        type == GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS) {
+        if (wordcount < 6 || wordcount > 7) {
+            ret = -1;
+            goto out;
+        }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret)
-                        goto out;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret)
+            goto out;
+
+        if (!words[5]) {
+            cli_err("Please enter the limit value to be set");
+            ret = -1;
+            goto out;
+        }
+
+        if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE) {
+            ret = gf_string2bytesize_int64(words[5], &value);
+            if (ret != 0 || value <= 0) {
+                if (errno == ERANGE || value <= 0) {
+                    ret = -1;
+                    cli_err(
+                        "Please enter an integer "
+                        "value in the range of "
+                        "(1 - %" PRId64 ")",
+                        INT64_MAX);
+                } else
+                    cli_err(
+                        "Please enter a correct "
+                        "value");
+                goto out;
+            }
+        } else {
+            errno = 0;
+            limit = strtol(words[5], &end_ptr, 10);
+            if (errno == ERANGE || errno == EINVAL || limit <= 0 ||
+                strcmp(end_ptr, "") != 0) {
+                ret = -1;
+                cli_err(
+                    "Please enter an integer value in "
+                    "the range 1 - %" PRId64,
+                    INT64_MAX);
+                goto out;
+            }
+        }
 
-                if (!words[5]) {
-                        cli_err ("Please enter the limit value to be set");
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "hard-limit", (char *)words[5]);
+        if (ret < 0)
+            goto out;
 
-                if (type == GF_QUOTA_OPTION_TYPE_LIMIT_USAGE) {
-                        ret = gf_string2bytesize_int64 (words[5], &value);
-                        if (ret != 0 || value <= 0) {
-                                if (errno == ERANGE || value <= 0) {
-                                        ret = -1;
-                                        cli_err ("Please enter an integer "
-                                                 "value in the range of "
-                                                 "(1 - %"PRId64 ")",
-                                                 INT64_MAX);
-                                } else
-                                        cli_err ("Please enter a correct "
-                                                 "value");
-                                goto out;
-                        }
-                } else {
-                        errno = 0;
-                        limit = strtol (words[5], &end_ptr, 10);
-                        if (errno == ERANGE || errno == EINVAL || limit <= 0
-                                            || strcmp (end_ptr, "") != 0) {
-                                ret = -1;
-                                cli_err ("Please enter an integer value in "
-                                         "the range 1 - %"PRId64, INT64_MAX);
-                                goto out;
-                        }
-                }
+        if (wordcount == 7) {
+            ret = gf_string2percent(words[6], &percent);
+            if (ret != 0 || percent > 100) {
+                ret = -1;
+                cli_err(
+                    "Please enter a correct value "
+                    "in the range of 0 to 100");
+                goto out;
+            }
 
-                ret  = dict_set_str (dict, "hard-limit", (char *) words[5]);
-                if (ret < 0)
-                        goto out;
+            ret = dict_set_str(dict, "soft-limit", (char *)words[6]);
+            if (ret < 0)
+                goto out;
+        }
 
-                if (wordcount == 7) {
+        goto set_type;
+    }
 
-                        ret = gf_string2percent (words[6], &percent);
-                        if (ret != 0 || percent > 100) {
-                                ret = -1;
-                                cli_err ("Please enter a correct value "
-                                         "in the range of 0 to 100");
-                                goto out;
-                        }
+    if (strcmp(w, "remove") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
 
-                        ret = dict_set_str (dict, "soft-limit",
-                                            (char *) words[6]);
-                        if (ret < 0)
-                                goto out;
-                }
+        type = GF_QUOTA_OPTION_TYPE_REMOVE;
 
-                goto set_type;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "remove") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                type = GF_QUOTA_OPTION_TYPE_REMOVE;
+    if (strcmp(w, "remove-objects") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
 
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        if (words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "remove-objects") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-
-                type = GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS;
+        ret = dict_set_str(dict, "path", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                if (words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+    if (strcmp(w, "list") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIST;
 
-                ret = dict_set_str (dict, "path", (char *) words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        if (words[4] && words[4][0] != '/') {
+            cli_err("Please enter absolute path");
+            ret = -1;
+            goto out;
         }
 
-        if (strcmp (w, "list") == 0) {
+        i = 4;
+        while (i < wordcount) {
+            snprintf(key, 20, "path%d", i - 4);
 
-                type = GF_QUOTA_OPTION_TYPE_LIST;
+            ret = dict_set_str(dict, key, (char *)words[i++]);
+            if (ret < 0)
+                goto out;
+        }
 
-                if (words[4] && words[4][0] != '/') {
-                        cli_err ("Please enter absolute path");
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_int32(dict, "count", i - 4);
+        if (ret < 0)
+            goto out;
 
-                i = 4;
-                while (i < wordcount) {
-                        snprintf (key, 20, "path%d", i-4);
+        goto set_type;
+    }
 
-                        ret = dict_set_str (dict, key, (char *) words [i++]);
-                        if (ret < 0)
-                                goto out;
-                }
+    if (strcmp(w, "list-objects") == 0) {
+        type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
 
-                ret = dict_set_int32 (dict, "count", i - 4);
-                if (ret < 0)
-                        goto out;
+        i = 4;
+        while (i < wordcount) {
+            snprintf(key, 20, "path%d", i - 4);
 
-                goto set_type;
+            ret = dict_set_str(dict, key, (char *)words[i++]);
+            if (ret < 0) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to set "
+                       "quota patch in request dictionary");
+                goto out;
+            }
         }
 
-        if (strcmp (w, "list-objects") == 0) {
-                type = GF_QUOTA_OPTION_TYPE_LIST_OBJECTS;
-
-                i = 4;
-                while (i < wordcount) {
-                        snprintf (key, 20, "path%d", i-4);
-
-                        ret = dict_set_str (dict, key, (char *) words[i++]);
-                        if (ret < 0) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                        "quota patch in request dictionary");
-                                goto out;
-                        }
-                }
-
-                ret = dict_set_int32 (dict, "count", i - 4);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set quota "
-                                "limit count in request dictionary");
-                        goto out;
-                }
-
-                goto set_type;
+        ret = dict_set_int32(dict, "count", i - 4);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set quota "
+                   "limit count in request dictionary");
+            goto out;
         }
 
-        if (strcmp (w, "alert-time") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_ALERT_TIME;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "alert-time") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_ALERT_TIME;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
 
-        if (strcmp (w, "soft-timeout") == 0) {
-                if (wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT;
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "soft-timeout") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
 
-        if (strcmp (w, "hard-timeout") == 0) {
-                if(wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT;
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
 
-                ret = gf_string2time (words[4], &time);
-                if (ret) {
-                        cli_err ("Invalid argument %s. Please enter a valid "
-                                 "string", words[4]);
-                        goto out;
-                }
+    if (strcmp(w, "hard-timeout") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
+        }
+        type = GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
+        ret = gf_string2time(words[4], &time);
+        if (ret) {
+            cli_err(
+                "Invalid argument %s. Please enter a valid "
+                "string",
+                words[4]);
+            goto out;
         }
-        if (strcmp (w, "default-soft-limit") == 0) {
-                if(wordcount != 5) {
-                        ret = -1;
-                        goto out;
-                }
-                type = GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT;
 
-                ret = dict_set_str (dict, "value", (char *)words[4]);
-                if (ret < 0)
-                        goto out;
-                goto set_type;
-        } else {
-                GF_ASSERT (!"opword mismatch");
+        ret = dict_set_str(dict, "value", (char *)words[4]);
+        if (ret < 0)
+            goto out;
+        goto set_type;
+    }
+    if (strcmp(w, "default-soft-limit") == 0) {
+        if (wordcount != 5) {
+            ret = -1;
+            goto out;
         }
+        type = GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT;
 
-set_type:
-        ret = dict_set_int32 (dict, "type", type);
+        ret = dict_set_str(dict, "value", (char *)words[4]);
         if (ret < 0)
-                goto out;
+            goto out;
+        goto set_type;
+    } else {
+        GF_ASSERT(!"opword mismatch");
+    }
 
-        *options = dict;
+set_type:
+    ret = dict_set_int32(dict, "type", type);
+    if (ret < 0)
+        goto out;
+
+    *options = dict;
 out:
-        if (ret < 0) {
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret < 0) {
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-cli_is_key_spl (char *key)
+cli_is_key_spl(char *key)
 {
-        return (strcmp (key, "group") == 0);
+    return (strcmp(key, "group") == 0);
 }
 
 static int32_t
 cli_add_key_group_value(dict_t *dict, const char *name, const char *value,
                         int32_t id, char **op_errstr)
 {
-        char         *key  = NULL;
-        char         *data = NULL;
-        int32_t       ret  = -1;
+    char *key = NULL;
+    char *data = NULL;
+    int32_t ret = -1;
 
-        ret = gf_asprintf(&key, "%s%d", name, id);
-        if (ret < 0) {
-                goto out;
-        }
-        data = gf_strdup(value);
-        if (data == NULL) {
-                goto out;
-        }
+    ret = gf_asprintf(&key, "%s%d", name, id);
+    if (ret < 0) {
+        goto out;
+    }
+    data = gf_strdup(value);
+    if (data == NULL) {
+        goto out;
+    }
 
-        ret = dict_set_dynstr(dict, key, data);
-        if (ret == 0) {
-                data = NULL;
-        }
+    ret = dict_set_dynstr(dict, key, data);
+    if (ret == 0) {
+        data = NULL;
+    }
 
 out:
-        GF_FREE(key);
-        GF_FREE(data);
+    GF_FREE(key);
+    GF_FREE(data);
 
-        if ((ret != 0) && (op_errstr != NULL)) {
-                *op_errstr = gf_strdup("Failed to allocate memory");
-        }
+    if ((ret != 0) && (op_errstr != NULL)) {
+        *op_errstr = gf_strdup("Failed to allocate memory");
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-cli_add_key_group (dict_t *dict, char *key, char *value, char **op_errstr)
+cli_add_key_group(dict_t *dict, char *key, char *value, char **op_errstr)
 {
-        int             ret = -1;
-        int             opt_count = 0;
-        char            *saveptr = NULL;
-        char            *tok_key = NULL;
-        char            *tok_val = NULL;
-        char            *tagpath = NULL;
-        char            line[PATH_MAX + 256] = {0,};
-        FILE            *fp = NULL;
-
-        ret = gf_asprintf (&tagpath, "%s/groups/%s",
-                           GLUSTERD_DEFAULT_WORKDIR, value);
-        if (ret == -1) {
-                tagpath = NULL;
-                goto out;
-        }
-
-        fp = fopen (tagpath, "r");
-        if (!fp) {
-                ret = -1;
-                if (op_errstr) {
-                        gf_asprintf(op_errstr, "Unable to open file '%s'. "
-                                               "Error: %s",
-                                    tagpath, strerror(errno));
-                }
-                goto out;
-        }
-
-        opt_count = 0;
-        while (fgets(line, sizeof(line), fp) != NULL) {
-                if (strlen(line) >= sizeof(line) - 1) {
-                        ret = -1;
-                        if (op_errstr != NULL) {
-                                *op_errstr = gf_strdup("Line too long");
-                        }
-                        goto out;
-                }
-                opt_count++;
-                tok_key = strtok_r (line, "=", &saveptr);
-                tok_val = strtok_r (NULL, "\r\n", &saveptr);
-                if (!tok_key || !tok_val) {
-                        ret = -1;
-                        if (op_errstr) {
-                                gf_asprintf(op_errstr, "'%s' file format "
-                                                       "not valid.",
-                                            tagpath);
-                        }
-                        goto out;
-                }
+    int ret = -1;
+    int opt_count = 0;
+    char *saveptr = NULL;
+    char *tok_key = NULL;
+    char *tok_val = NULL;
+    char *tagpath = NULL;
+    char line[PATH_MAX + 256] = {
+        0,
+    };
+    FILE *fp = NULL;
+
+    ret = gf_asprintf(&tagpath, "%s/groups/%s", GLUSTERD_DEFAULT_WORKDIR,
+                      value);
+    if (ret == -1) {
+        tagpath = NULL;
+        goto out;
+    }
 
-                ret = cli_add_key_group_value(dict, "key", tok_key, opt_count,
-                                              op_errstr);
-                if (ret != 0) {
-                        goto out;
-                }
-                ret = cli_add_key_group_value(dict, "value", tok_val,
-                                              opt_count, op_errstr);
-                if (ret != 0) {
-                        goto out;
-                }
+    fp = fopen(tagpath, "r");
+    if (!fp) {
+        ret = -1;
+        if (op_errstr) {
+            gf_asprintf(op_errstr,
+                        "Unable to open file '%s'. "
+                        "Error: %s",
+                        tagpath, strerror(errno));
         }
-
-        if (!opt_count) {
-                ret = -1;
-                if (op_errstr) {
-                        gf_asprintf(op_errstr, "'%s' file format not valid.",
-                                    tagpath);
-                }
-                goto out;
+        goto out;
+    }
+
+    opt_count = 0;
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (strlen(line) >= sizeof(line) - 1) {
+            ret = -1;
+            if (op_errstr != NULL) {
+                *op_errstr = gf_strdup("Line too long");
+            }
+            goto out;
+        }
+        opt_count++;
+        tok_key = strtok_r(line, "=", &saveptr);
+        tok_val = strtok_r(NULL, "\r\n", &saveptr);
+        if (!tok_key || !tok_val) {
+            ret = -1;
+            if (op_errstr) {
+                gf_asprintf(op_errstr,
+                            "'%s' file format "
+                            "not valid.",
+                            tagpath);
+            }
+            goto out;
+        }
+
+        ret = cli_add_key_group_value(dict, "key", tok_key, opt_count,
+                                      op_errstr);
+        if (ret != 0) {
+            goto out;
+        }
+        ret = cli_add_key_group_value(dict, "value", tok_val, opt_count,
+                                      op_errstr);
+        if (ret != 0) {
+            goto out;
+        }
+    }
+
+    if (!opt_count) {
+        ret = -1;
+        if (op_errstr) {
+            gf_asprintf(op_errstr, "'%s' file format not valid.", tagpath);
         }
-        ret = dict_set_int32 (dict, "count", opt_count);
+        goto out;
+    }
+    ret = dict_set_int32(dict, "count", opt_count);
 out:
 
-        GF_FREE (tagpath);
+    GF_FREE(tagpath);
 
-        if (fp)
-                fclose (fp);
+    if (fp)
+        fclose(fp);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_set_parse (struct cli_state *state, const char **words,
-                          int wordcount, dict_t **options, char **op_errstr)
+cli_cmd_volume_set_parse(struct cli_state *state, const char **words,
+                         int wordcount, dict_t **options, char **op_errstr)
 {
-        dict_t                 *dict      = NULL;
-        char                   *volname   = NULL;
-        int                     ret       = -1;
-        int                     count     = 0;
-        char                   *key       = NULL;
-        char                   *value     = NULL;
-        int                     i         = 0;
-        char                    str[50]   = {0,};
-        const char             *question  = NULL;
-        gf_answer_t             answer    = GF_ANSWER_NO;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
-
-        if (wordcount < 3)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int count = 0;
+    char *key = NULL;
+    char *value = NULL;
+    int i = 0;
+    char str[50] = {
+        0,
+    };
+    const char *question = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[2];
+    if (wordcount < 3)
+        goto out;
 
-        GF_ASSERT (volname);
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
+    GF_ASSERT(volname);
 
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (!strcmp (volname, "all")) {
-                ret = dict_set_str (dict, "globalname", "All");
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "dict set on global key failed.");
-                        goto out;
-                }
+    if (ret)
+        goto out;
 
-                ret = dict_set_int32 (dict, "hold_global_locks", _gf_true);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "dict set on global key failed.");
-                        goto out;
-                }
+    if (!strcmp(volname, "all")) {
+        ret = dict_set_str(dict, "globalname", "All");
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR, "dict set on global key failed.");
+            goto out;
         }
 
-        if ((!strcmp (volname, "help") || !strcmp (volname, "help-xml"))
-            && wordcount == 3 ) {
-                ret = dict_set_str (dict, volname, volname);
-                if (ret)
-                        goto out;
+        ret = dict_set_int32(dict, "hold_global_locks", _gf_true);
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR, "dict set on global key failed.");
+            goto out;
+        }
+    }
 
-        } else if (wordcount < 5) {
-                ret = -1;
-                goto out;
+    if ((!strcmp(volname, "help") || !strcmp(volname, "help-xml")) &&
+        wordcount == 3) {
+        ret = dict_set_str(dict, volname, volname);
+        if (ret)
+            goto out;
 
-        } else if (wordcount == 5  && cli_is_key_spl ((char *)words[3])) {
-                key = (char *) words[3];
-                value = (char *) words[4];
-                if ( !key || !value) {
-                        ret = -1;
-                        goto out;
-                }
+    } else if (wordcount < 5) {
+        ret = -1;
+        goto out;
 
-                ret = gf_strip_whitespace (value, strlen (value));
-                if (ret == -1)
-                        goto out;
+    } else if (wordcount == 5 && cli_is_key_spl((char *)words[3])) {
+        key = (char *)words[3];
+        value = (char *)words[4];
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
 
-                if (strlen (value) == 0) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = gf_strip_whitespace(value, strlen(value));
+        if (ret == -1)
+            goto out;
 
-                ret = cli_add_key_group (dict, key, value, op_errstr);
-                if (ret == 0)
-                        *options = dict;
-                goto out;
+        if (strlen(value) == 0) {
+            ret = -1;
+            goto out;
         }
 
-        for (i = 3; i < wordcount; i+=2) {
-
-                key = (char *) words[i];
-                value = (char *) words[i+1];
+        ret = cli_add_key_group(dict, key, value, op_errstr);
+        if (ret == 0)
+            *options = dict;
+        goto out;
+    }
 
-                if ( !key || !value) {
-                        ret = -1;
-                        goto out;
-                }
+    for (i = 3; i < wordcount; i += 2) {
+        key = (char *)words[i];
+        value = (char *)words[i + 1];
 
-                count++;
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
 
-                if (fnmatch ("user.*", key, FNM_NOESCAPE) != 0) {
-                        ret = gf_strip_whitespace (value, strlen (value));
-                        if (ret == -1)
-                                goto out;
-                }
+        count++;
 
-                if (strlen (value) == 0) {
-                        ret = -1;
-                        goto out;
-                }
+        if (fnmatch("user.*", key, FNM_NOESCAPE) != 0) {
+            ret = gf_strip_whitespace(value, strlen(value));
+            if (ret == -1)
+                goto out;
+        }
 
-                if (cli_is_key_spl (key)) {
-                        ret = -1;
-                        goto out;
-                }
+        if (strlen(value) == 0) {
+            ret = -1;
+            goto out;
+        }
 
-                sprintf (str, "key%d", count);
-                ret = dict_set_str (dict, str, key);
-                if (ret)
-                        goto out;
+        if (cli_is_key_spl(key)) {
+            ret = -1;
+            goto out;
+        }
 
-                sprintf (str, "value%d", count);
-                ret = dict_set_str (dict, str, value);
+        sprintf(str, "key%d", count);
+        ret = dict_set_str(dict, str, key);
+        if (ret)
+            goto out;
 
-                if (ret)
-                        goto out;
+        sprintf(str, "value%d", count);
+        ret = dict_set_str(dict, str, value);
 
-                if ((!strcmp (key, "cluster.enable-shared-storage")) &&
-                    (!strcmp (value, "disable"))) {
-                        question = "Disabling cluster.enable-shared-storage "
-                                   "will delete the shared storage volume"
-                                   "(gluster_shared_storage), which is used "
-                                   "by snapshot scheduler, geo-replication "
-                                   "and NFS-Ganesha. Do you still want to "
-                                   "continue?";
-                        answer = cli_cmd_get_confirmation (state, question);
-                        if (GF_ANSWER_NO == answer) {
-                                gf_log ("cli", GF_LOG_ERROR, "Operation "
-                                        "cancelled, exiting");
-                                *op_errstr = gf_strdup ("Aborted by user.");
-                                ret = -1;
-                                goto out;
-                        }
-                }
-                if ((!strcmp (key, "nfs.disable")) &&
-                            (!strcmp (value, "off"))) {
-                        question = "Gluster NFS is being deprecated in favor "
-                                   "of NFS-Ganesha Enter \"yes\" to continue "
-                                   "using Gluster NFS";
-                        answer = cli_cmd_get_confirmation (state, question);
-                        if (GF_ANSWER_NO == answer) {
-                                gf_log ("cli", GF_LOG_ERROR, "Operation "
-                                        "cancelled, exiting");
-                                *op_errstr = gf_strdup ("Aborted by user.");
-                                ret = -1;
-                                goto out;
-                        }
-                }
+        if (ret)
+            goto out;
+
+        if ((!strcmp(key, "cluster.enable-shared-storage")) &&
+            (!strcmp(value, "disable"))) {
+            question =
+                "Disabling cluster.enable-shared-storage "
+                "will delete the shared storage volume"
+                "(gluster_shared_storage), which is used "
+                "by snapshot scheduler, geo-replication "
+                "and NFS-Ganesha. Do you still want to "
+                "continue?";
+            answer = cli_cmd_get_confirmation(state, question);
+            if (GF_ANSWER_NO == answer) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Operation "
+                       "cancelled, exiting");
+                *op_errstr = gf_strdup("Aborted by user.");
+                ret = -1;
+                goto out;
+            }
+        }
+        if ((!strcmp(key, "nfs.disable")) && (!strcmp(value, "off"))) {
+            question =
+                "Gluster NFS is being deprecated in favor "
+                "of NFS-Ganesha Enter \"yes\" to continue "
+                "using Gluster NFS";
+            answer = cli_cmd_get_confirmation(state, question);
+            if (GF_ANSWER_NO == answer) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Operation "
+                       "cancelled, exiting");
+                *op_errstr = gf_strdup("Aborted by user.");
+                ret = -1;
+                goto out;
+            }
         }
+    }
 
-        ret = dict_set_int32 (dict, "count", wordcount-3);
+    ret = dict_set_int32(dict, "count", wordcount - 3);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_add_brick_parse (struct cli_state *state, const char **words,
-                                int wordcount, dict_t **options, int *ret_type)
+cli_cmd_volume_add_brick_parse(struct cli_state *state, const char **words,
+                               int wordcount, dict_t **options, int *ret_type)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
-        int     brick_count = 0, brick_index = 0;
-        char    *bricks = NULL;
-        char    *opwords_cl[] = { "replica", "stripe", NULL };
-        gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
-        int     count = 1;
-        int     arbiter_count = 0;
-        char    *w = NULL;
-        int     index;
-        gf_boolean_t is_force = _gf_false;
-        int wc = wordcount;
-        gf_answer_t answer = GF_ANSWER_NO;
-        const char *question = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-
-        if (!dict)
-                goto out;
-
-        if (wordcount < 3)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int brick_count = 0, brick_index = 0;
+    char *bricks = NULL;
+    char *opwords_cl[] = {"replica", "stripe", NULL};
+    gf1_cluster_type type = GF_CLUSTER_TYPE_NONE;
+    int count = 1;
+    int arbiter_count = 0;
+    char *w = NULL;
+    int index;
+    gf_boolean_t is_force = _gf_false;
+    int wc = wordcount;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[2];
+    if (wordcount < 3)
+        goto out;
 
-        GF_ASSERT (volname);
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
+    GF_ASSERT(volname);
 
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (wordcount < 4) {
-                ret = -1;
-                goto out;
-        }
-        if (wordcount < 6) {
-                /* seems no options are given, go directly to the parse_brick */
-                brick_index = 3;
-                type = GF_CLUSTER_TYPE_NONE;
-                goto parse_bricks;
-        }
+    if (ret)
+        goto out;
 
-        w = str_getunamb (words[3], opwords_cl);
-        if (!w) {
-                type = GF_CLUSTER_TYPE_NONE;
-                index = 3;
-        } else if ((strcmp (w, "replica")) == 0) {
-                type = GF_CLUSTER_TYPE_REPLICATE;
-                count = strtol (words[4], NULL, 0);
-                if (!count || (count < 2)) {
-                        cli_err ("replica count should be greater than 1");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_int32 (dict, "replica-count", count);
-                if (ret)
-                        goto out;
-                index = 5;
-                if (words[index] && !strcmp (words[index], "arbiter")) {
-                        arbiter_count = strtol (words[6], NULL, 0);
-                        if (arbiter_count != 1 || count != 3) {
-                                cli_err ("For arbiter configuration, replica "
-                                         "count must be 3 and arbiter count "
-                                         "must be 1. The 3rd brick of the "
-                                         "replica will be the arbiter");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_int32 (dict, "arbiter-count",
-                                              arbiter_count);
-                        if (ret)
-                                goto out;
-                        index = 7;
-                }
+    if (wordcount < 4) {
+        ret = -1;
+        goto out;
+    }
+    if (wordcount < 6) {
+        /* seems no options are given, go directly to the parse_brick */
+        brick_index = 3;
+        type = GF_CLUSTER_TYPE_NONE;
+        goto parse_bricks;
+    }
 
-                if (count == 2) {
-                        if (strcmp (words[wordcount - 1], "force")) {
-                                question = "Replica 2 volumes are prone to "
-                                           "split-brain. Use Arbiter or "
-                                           "Replica 3 to avaoid this. See: "
-                                           "http://docs.gluster.org/en/latest/Administrator%20Guide/Split%20brain%20and%20ways%20to%20deal%20with%20it/."
-                                           "\nDo you still want to continue?\n";
-                                answer = cli_cmd_get_confirmation (state,
-                                                                   question);
-                                if (GF_ANSWER_NO == answer) {
-                                        gf_log ("cli", GF_LOG_ERROR, "Add brick"
-                                                " cancelled, exiting");
-                                        ret = -1;
-                                        goto out;
-                                }
-                        }
-                }
-        } else if ((strcmp (w, "stripe")) == 0) {
-                type = GF_CLUSTER_TYPE_STRIPE;
-                count = strtol (words[4], NULL, 0);
-                if (!count || (count < 2)) {
-                        cli_err ("stripe count should be greater than 1");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_int32 (dict, "stripe-count", count);
-                if (ret)
-                        goto out;
-                index = 5;
-        } else {
-                GF_ASSERT (!"opword mismatch");
+    w = str_getunamb(words[3], opwords_cl);
+    if (!w) {
+        type = GF_CLUSTER_TYPE_NONE;
+        index = 3;
+    } else if ((strcmp(w, "replica")) == 0) {
+        type = GF_CLUSTER_TYPE_REPLICATE;
+        count = strtol(words[4], NULL, 0);
+        if (!count || (count < 2)) {
+            cli_err("replica count should be greater than 1");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_int32(dict, "replica-count", count);
+        if (ret)
+            goto out;
+        index = 5;
+        if (words[index] && !strcmp(words[index], "arbiter")) {
+            arbiter_count = strtol(words[6], NULL, 0);
+            if (arbiter_count != 1 || count != 3) {
+                cli_err(
+                    "For arbiter configuration, replica "
+                    "count must be 3 and arbiter count "
+                    "must be 1. The 3rd brick of the "
+                    "replica will be the arbiter");
                 ret = -1;
                 goto out;
+            }
+            ret = dict_set_int32(dict, "arbiter-count", arbiter_count);
+            if (ret)
+                goto out;
+            index = 7;
         }
 
-        brick_index = index;
+        if (count == 2) {
+            if (strcmp(words[wordcount - 1], "force")) {
+                question =
+                    "Replica 2 volumes are prone to "
+                    "split-brain. Use Arbiter or "
+                    "Replica 3 to avaoid this. See: "
+                    "http://docs.gluster.org/en/latest/Administrator%20Guide/"
+                    "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                    "\nDo you still want to continue?\n";
+                answer = cli_cmd_get_confirmation(state, question);
+                if (GF_ANSWER_NO == answer) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Add brick"
+                           " cancelled, exiting");
+                    ret = -1;
+                    goto out;
+                }
+            }
+        }
+    } else if ((strcmp(w, "stripe")) == 0) {
+        type = GF_CLUSTER_TYPE_STRIPE;
+        count = strtol(words[4], NULL, 0);
+        if (!count || (count < 2)) {
+            cli_err("stripe count should be greater than 1");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_int32(dict, "stripe-count", count);
+        if (ret)
+            goto out;
+        index = 5;
+    } else {
+        GF_ASSERT(!"opword mismatch");
+        ret = -1;
+        goto out;
+    }
+
+    brick_index = index;
 
 parse_bricks:
 
-        if (strcmp (words[wordcount - 1], "force") == 0) {
-                is_force = _gf_true;
-                wc = wordcount - 1;
-        }
+    if (strcmp(words[wordcount - 1], "force") == 0) {
+        is_force = _gf_true;
+        wc = wordcount - 1;
+    }
 
-        ret = cli_cmd_bricks_parse (words, wc, brick_index, &bricks,
-                                    &brick_count);
-        if (ret)
-                goto out;
+    ret = cli_cmd_bricks_parse(words, wc, brick_index, &bricks, &brick_count);
+    if (ret)
+        goto out;
 
-        ret = dict_set_dynstr (dict, "bricks", bricks);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(dict, "bricks", bricks);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "count", brick_count);
+    ret = dict_set_int32(dict, "count", brick_count);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "force", is_force);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "force", is_force);
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret_type)
-                *ret_type = type;
+    if (ret_type)
+        *ret_type = type;
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse add-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse add-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_tier_parse (const char **words, int wordcount,
-                           dict_t **options)
+cli_cmd_volume_tier_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict    = NULL;
-        char    *volname = NULL;
-        int      ret     = -1;
-        int32_t  command = GF_DEFRAG_CMD_NONE;
-        int32_t  is_force    = 0;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    int32_t command = GF_DEFRAG_CMD_NONE;
+    int32_t is_force = 0;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict)
-                goto out;
+    if (!dict)
+        goto out;
 
-        if (!(wordcount == 4 || wordcount == 5)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                ret = -1;
-                goto out;
-        }
+    if (!(wordcount == 4 || wordcount == 5)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        ret = -1;
+        goto out;
+    }
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        ret = cli_cmd_validate_volume (volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to validate volume name");
-                goto out;
-        }
+    ret = cli_cmd_validate_volume(volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to validate volume name");
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        volname = (char *)words[2];
-        if (wordcount == 4) {
-                if (!strcmp(words[3], "status"))
-                        command = GF_DEFRAG_CMD_STATUS_TIER;
-                else if (!strcmp(words[3], "start"))
-                        command = GF_DEFRAG_CMD_START_TIER;
-                else if (!strcmp(words[3], "stop"))
-                        command = GF_DEFRAG_CMD_STOP_TIER;
-                else {
-                        ret = -1;
-                        goto out;
-                }
-        } else if (wordcount == 5) {
-                if ((!strcmp (words[3], "start")) &&
-                    (!strcmp (words[4], "force"))) {
-                        command = GF_DEFRAG_CMD_START_TIER;
-                        is_force = 1;
-                        ret = dict_set_int32 (dict, "force", is_force);
-                        if (ret)
-                                goto out;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    volname = (char *)words[2];
+    if (wordcount == 4) {
+        if (!strcmp(words[3], "status"))
+            command = GF_DEFRAG_CMD_STATUS_TIER;
+        else if (!strcmp(words[3], "start"))
+            command = GF_DEFRAG_CMD_START_TIER;
+        else if (!strcmp(words[3], "stop"))
+            command = GF_DEFRAG_CMD_STOP_TIER;
+        else {
+            ret = -1;
+            goto out;
+        }
+    } else if (wordcount == 5) {
+        if ((!strcmp(words[3], "start")) && (!strcmp(words[4], "force"))) {
+            command = GF_DEFRAG_CMD_START_TIER;
+            is_force = 1;
+            ret = dict_set_int32(dict, "force", is_force);
+            if (ret)
+                goto out;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        ret = dict_set_int32 (dict, "rebalance-command", command);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "rebalance-command", command);
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 out:
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse tier CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse tier CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_detach_tier_parse (const char **words, int wordcount,
-                                  dict_t **options, int *question)
+cli_cmd_volume_detach_tier_parse(const char **words, int wordcount,
+                                 dict_t **options, int *question)
 {
-        int      ret = -1;
-        char    *word = NULL;
-        dict_t  *dict = NULL;
-        int32_t  command = GF_DEFRAG_CMD_NONE;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    int ret = -1;
+    char *word = NULL;
+    dict_t *dict = NULL;
+    int32_t command = GF_DEFRAG_CMD_NONE;
 
-        if (wordcount == 3 && !strcmp ((char *)words[2], "help")) {
-                return -1;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount != 4) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        word = (char *)words[3];
+    if (wordcount == 3 && !strcmp((char *)words[2], "help")) {
+        return -1;
+    }
 
+    if (wordcount != 4) {
         ret = -1;
+        goto out;
+    }
+
+    word = (char *)words[3];
+
+    ret = -1;
+
+    if (!strcmp(word, "start")) {
+        command = GF_DEFRAG_CMD_DETACH_START;
+    } else if (!strcmp(word, "commit")) {
+        *question = 1;
+        command = GF_DEFRAG_CMD_DETACH_COMMIT;
+    } else if (!strcmp(word, "force")) {
+        *question = 1;
+        command = GF_DEFRAG_CMD_DETACH_COMMIT_FORCE;
+    } else if (!strcmp(word, "stop"))
+        command = GF_DEFRAG_CMD_DETACH_STOP;
+    else if (!strcmp(word, "status"))
+        command = GF_DEFRAG_CMD_DETACH_STATUS;
+    else
+        goto out;
 
-        if (!strcmp(word, "start")) {
-                command = GF_DEFRAG_CMD_DETACH_START;
-        } else if (!strcmp(word, "commit")) {
-                *question = 1;
-                command = GF_DEFRAG_CMD_DETACH_COMMIT;
-        } else if (!strcmp(word, "force")) {
-                *question = 1;
-                command = GF_DEFRAG_CMD_DETACH_COMMIT_FORCE;
-        } else if (!strcmp(word, "stop"))
-                command = GF_DEFRAG_CMD_DETACH_STOP;
-        else if (!strcmp(word, "status"))
-                command = GF_DEFRAG_CMD_DETACH_STATUS;
-        else
-                goto out;
-
-        ret = dict_set_int32 (dict, "command", command);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "command", command);
+    if (ret)
+        goto out;
 
-        *options = dict;
-        ret = 0;
+    *options = dict;
+    ret = 0;
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse detach tier CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse detach tier CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_remove_brick_parse (struct cli_state *state, const char **words,
-                                   int wordcount, dict_t **options,
-                                   int *question, int *brick_count,
-                                   int32_t *comm)
+cli_cmd_volume_remove_brick_parse(struct cli_state *state, const char **words,
+                                  int wordcount, dict_t **options,
+                                  int *question, int *brick_count,
+                                  int32_t *comm)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *delimiter = NULL;
-        int     ret = -1;
-        char    key[50];
-        int     brick_index = 0;
-        int32_t tmp_index = 0;
-        int32_t j = 0;
-        char    *tmp_brick = NULL;
-        char    *tmp_brick1 = NULL;
-        char    *type_opword[] = { "replica", NULL };
-        char    *opwords[] = { "start", "commit", "stop", "status",
-                               "force", NULL };
-        char    *w = NULL;
-        int32_t  command = GF_OP_CMD_NONE;
-        long     count = 0;
-        gf_answer_t answer = GF_ANSWER_NO;
-        const char *ques = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        if (wordcount < 5)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *delimiter = NULL;
+    int ret = -1;
+    char key[50];
+    int brick_index = 0;
+    int32_t tmp_index = 0;
+    int32_t j = 0;
+    char *tmp_brick = NULL;
+    char *tmp_brick1 = NULL;
+    char *type_opword[] = {"replica", NULL};
+    char *opwords[] = {"start", "commit", "stop", "status", "force", NULL};
+    char *w = NULL;
+    int32_t command = GF_OP_CMD_NONE;
+    long count = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *ques = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    if (wordcount < 5)
+        goto out;
 
-        volname = (char *)words[2];
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        GF_ASSERT (volname);
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    GF_ASSERT(volname);
 
-        brick_index = 3;
-        w = str_getunamb (words[3], type_opword);
-        if (w && !strcmp ("replica", w)) {
-                if (wordcount < 6) {
-                        ret = -1;
-                        goto out;
-                }
-                count = strtol (words[4], NULL, 0);
-                if (count < 1) {
-                        cli_err ("replica count should be greater than 0 in "
-                                 "case of remove-brick");
-                        ret = -1;
-                        goto out;
-                }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-                if (count == 2) {
-                        if (strcmp (words[wordcount - 1], "force")) {
-                                ques = "Replica 2 volumes are prone to "
-                                       "split-brain. Use Arbiter or Replica 3 "
-                                       "to avaoid this. See: "
-                                       "http://docs.gluster.org/en/latest/Administrator%20Guide/Split%20brain%20and%20ways%20to%20deal%20with%20it/."
-                                       "\nDo you still want to continue?\n";
-                                answer = cli_cmd_get_confirmation (state,
-                                                                   ques);
-                                if (GF_ANSWER_NO == answer) {
-                                        gf_log ("cli", GF_LOG_ERROR, "Remove "
-                                                "brick cancelled, exiting");
-                                        ret = -1;
-                                        goto out;
-                                }
-                        }
+    brick_index = 3;
+    w = str_getunamb(words[3], type_opword);
+    if (w && !strcmp("replica", w)) {
+        if (wordcount < 6) {
+            ret = -1;
+            goto out;
+        }
+        count = strtol(words[4], NULL, 0);
+        if (count < 1) {
+            cli_err(
+                "replica count should be greater than 0 in "
+                "case of remove-brick");
+            ret = -1;
+            goto out;
+        }
+
+        if (count == 2) {
+            if (strcmp(words[wordcount - 1], "force")) {
+                ques =
+                    "Replica 2 volumes are prone to "
+                    "split-brain. Use Arbiter or Replica 3 "
+                    "to avaoid this. See: "
+                    "http://docs.gluster.org/en/latest/Administrator%20Guide/"
+                    "Split%20brain%20and%20ways%20to%20deal%20with%20it/."
+                    "\nDo you still want to continue?\n";
+                answer = cli_cmd_get_confirmation(state, ques);
+                if (GF_ANSWER_NO == answer) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Remove "
+                           "brick cancelled, exiting");
+                    ret = -1;
+                    goto out;
                 }
-
-                ret = dict_set_int32 (dict, "replica-count", count);
-                if (ret)
-                        goto out;
-                brick_index = 5;
-        } else if (w) {
-                GF_ASSERT (!"opword mismatch");
+            }
         }
 
-        w = str_getunamb (words[wordcount - 1], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
+        ret = dict_set_int32(dict, "replica-count", count);
+        if (ret)
+            goto out;
+        brick_index = 5;
+    } else if (w) {
+        GF_ASSERT(!"opword mismatch");
+    }
+
+    w = str_getunamb(words[wordcount - 1], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    } else {
+        /* handled this option */
+        wordcount--;
+        if (!strcmp("start", w)) {
+            command = GF_OP_CMD_START;
+            if (question)
+                *question = 1;
+        } else if (!strcmp("commit", w)) {
+            command = GF_OP_CMD_COMMIT;
+        } else if (!strcmp("stop", w)) {
+            command = GF_OP_CMD_STOP;
+        } else if (!strcmp("status", w)) {
+            command = GF_OP_CMD_STATUS;
+        } else if (!strcmp("force", w)) {
+            command = GF_OP_CMD_COMMIT_FORCE;
+            if (question)
+                *question = 1;
         } else {
-                /* handled this option */
-                wordcount--;
-                if (!strcmp ("start", w)) {
-                        command = GF_OP_CMD_START;
-                        if (question)
-                                *question = 1;
-                } else if (!strcmp ("commit", w)) {
-                        command = GF_OP_CMD_COMMIT;
-                } else if (!strcmp ("stop", w)) {
-                        command = GF_OP_CMD_STOP;
-                } else if (!strcmp ("status", w)) {
-                        command = GF_OP_CMD_STATUS;
-                } else if (!strcmp ("force", w)) {
-                        command = GF_OP_CMD_COMMIT_FORCE;
-                        if (question)
-                                *question = 1;
-                } else {
-                        GF_ASSERT (!"opword mismatch");
-                        ret = -1;
-                        goto out;
-                }
+            GF_ASSERT(!"opword mismatch");
+            ret = -1;
+            goto out;
         }
+    }
 
-        ret = dict_set_int32 (dict, "command", command);
-        if (ret)
-                gf_log ("cli", GF_LOG_INFO, "failed to set 'command' %d",
-                        command);
-
+    ret = dict_set_int32(dict, "command", command);
+    if (ret)
+        gf_log("cli", GF_LOG_INFO, "failed to set 'command' %d", command);
 
-        tmp_index = brick_index;
-        tmp_brick = GF_MALLOC(2048 * sizeof(*tmp_brick), gf_common_mt_char);
+    tmp_index = brick_index;
+    tmp_brick = GF_MALLOC(2048 * sizeof(*tmp_brick), gf_common_mt_char);
 
-        if (!tmp_brick) {
-                gf_log ("",GF_LOG_ERROR,"cli_cmd_volume_remove_brick_parse: "
-                        "Unable to get memory");
-                ret = -1;
-                goto out;
-        }
+    if (!tmp_brick) {
+        gf_log("", GF_LOG_ERROR,
+               "cli_cmd_volume_remove_brick_parse: "
+               "Unable to get memory");
+        ret = -1;
+        goto out;
+    }
 
-        tmp_brick1 = GF_MALLOC(2048 * sizeof(*tmp_brick1), gf_common_mt_char);
+    tmp_brick1 = GF_MALLOC(2048 * sizeof(*tmp_brick1), gf_common_mt_char);
 
-        if (!tmp_brick1) {
-                gf_log ("",GF_LOG_ERROR,"cli_cmd_volume_remove_brick_parse: "
-                        "Unable to get memory");
+    if (!tmp_brick1) {
+        gf_log("", GF_LOG_ERROR,
+               "cli_cmd_volume_remove_brick_parse: "
+               "Unable to get memory");
+        ret = -1;
+        goto out;
+    }
+
+    while (brick_index < wordcount) {
+        if (validate_brick_name((char *)words[brick_index])) {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[brick_index]);
+            ret = -1;
+            goto out;
+        } else {
+            delimiter = strrchr(words[brick_index], ':');
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
+        }
+
+        j = tmp_index;
+        strcpy(tmp_brick, words[brick_index]);
+        while (j < brick_index) {
+            strcpy(tmp_brick1, words[j]);
+            if (!(strcmp(tmp_brick, tmp_brick1))) {
+                gf_log("", GF_LOG_ERROR,
+                       "Duplicate bricks"
+                       " found %s",
+                       words[brick_index]);
+                cli_err("Duplicate bricks found %s", words[brick_index]);
                 ret = -1;
                 goto out;
+            }
+            j++;
         }
+        snprintf(key, 50, "brick%d", ++(*brick_count));
+        ret = dict_set_str(dict, key, (char *)words[brick_index++]);
 
-        while (brick_index < wordcount) {
-                if (validate_brick_name ((char *)words[brick_index])) {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[brick_index]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        delimiter = strrchr(words[brick_index], ':');
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-
-                j = tmp_index;
-                strcpy(tmp_brick, words[brick_index]);
-                while ( j < brick_index) {
-                        strcpy(tmp_brick1, words[j]);
-                        if (!(strcmp (tmp_brick, tmp_brick1))) {
-                                gf_log("",GF_LOG_ERROR, "Duplicate bricks"
-                                       " found %s", words[brick_index]);
-                                cli_err("Duplicate bricks found %s",
-                                        words[brick_index]);
-                                ret = -1;
-                                goto out;
-                        }
-                        j++;
-                }
-                snprintf (key, 50, "brick%d", ++(*brick_count));
-                ret = dict_set_str (dict, key, (char *)words[brick_index++]);
-
-                if (ret)
-                        goto out;
-        }
+        if (ret)
+            goto out;
+    }
 
-        if (command != GF_OP_CMD_STATUS && command != GF_OP_CMD_STOP) {
-                ret = dict_set_int32 (dict, "count", *brick_count);
-                if (ret)
-                        goto out;
-        }
+    if (command != GF_OP_CMD_STATUS && command != GF_OP_CMD_STOP) {
+        ret = dict_set_int32(dict, "count", *brick_count);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse remove-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse remove-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        GF_FREE (tmp_brick);
-        GF_FREE (tmp_brick1);
+    GF_FREE(tmp_brick);
+    GF_FREE(tmp_brick1);
 
-        *comm = command;
+    *comm = command;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_brick_op_validate_bricks (const char **words, dict_t *dict,
-				  int src, int dst)
+cli_cmd_brick_op_validate_bricks(const char **words, dict_t *dict, int src,
+                                 int dst)
 {
-        int             ret = -1;
-        char            *delimiter  = NULL;
-
-        if (validate_brick_name ((char *)words[src])) {
-                cli_err ("wrong brick type: %s, use "
-                         "<HOSTNAME>:<export-dir-abs-path>", words[3]);
-                ret = -1;
-                goto out;
-        } else {
-                delimiter = strrchr ((char *)words[src], '/');
-                ret = gf_canonicalize_path (delimiter);
-                if (ret)
-                        goto out;
-        }
-
-        ret = dict_set_str (dict, "src-brick", (char *)words[src]);
+    int ret = -1;
+    char *delimiter = NULL;
+
+    if (validate_brick_name((char *)words[src])) {
+        cli_err(
+            "wrong brick type: %s, use "
+            "<HOSTNAME>:<export-dir-abs-path>",
+            words[3]);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr((char *)words[src], '/');
+        ret = gf_canonicalize_path(delimiter);
         if (ret)
-                goto out;
+            goto out;
+    }
 
-        if (dst == -1) {
-                ret = 0;
-                goto out;
-        }
+    ret = dict_set_str(dict, "src-brick", (char *)words[src]);
+    if (ret)
+        goto out;
 
-        if (validate_brick_name ((char *)words[dst])) {
-                cli_err ("wrong brick type: %s, use "
-                         "<HOSTNAME>:<export-dir-abs-path>", words[dst]);
-                ret = -1;
-                goto out;
-        } else {
-                delimiter = strrchr ((char *)words[dst], '/');
-                ret = gf_canonicalize_path (delimiter);
-                if (ret)
-                        goto out;
-        }
+    if (dst == -1) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "dst-brick", (char *)words[dst]);
+    if (validate_brick_name((char *)words[dst])) {
+        cli_err(
+            "wrong brick type: %s, use "
+            "<HOSTNAME>:<export-dir-abs-path>",
+            words[dst]);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr((char *)words[dst], '/');
+        ret = gf_canonicalize_path(delimiter);
         if (ret)
-                goto out;
-        ret = 0;
+            goto out;
+    }
+
+    ret = dict_set_str(dict, "dst-brick", (char *)words[dst]);
+    if (ret)
+        goto out;
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_reset_brick_parse (const char **words, int wordcount,
-                                  dict_t **options)
+cli_cmd_volume_reset_brick_parse(const char **words, int wordcount,
+                                 dict_t **options)
 {
-        int                   ret        = -1;
-        char                 *volname    = NULL;
-        dict_t               *dict       = NULL;
-
-        if (wordcount < 5 || wordcount > 7)
-                goto out;
-
-        dict = dict_new ();
+    int ret = -1;
+    char *volname = NULL;
+    dict_t *dict = NULL;
 
-        if (!dict)
-                goto out;
+    if (wordcount < 5 || wordcount > 7)
+        goto out;
 
-        volname = (char *)words[2];
+    dict = dict_new();
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    if (!dict)
+        goto out;
 
-        if (wordcount == 5) {
-                if (strcmp (words[4], "start")) {
-                        cli_err ("Invalid option '%s' for reset-brick. Please "
-                                 "enter valid reset-brick command", words[4]);
-                        ret = -1;
-                        goto out;
-                }
+    volname = (char *)words[2];
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, -1);
-                if (ret)
-                        goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-                ret = dict_set_str (dict, "operation", "GF_RESET_OP_START");
-                if (ret)
-                        goto out;
-        } else if (wordcount == 6) {
-                if (strcmp (words[5], "commit")) {
-                        cli_err ("Invalid option '%s' for reset-brick. Please "
-                                 "enter valid reset-brick command", words[5]);
-                        ret = -1;
-                        goto out;
-                }
+    if (wordcount == 5) {
+        if (strcmp(words[4], "start")) {
+            cli_err(
+                "Invalid option '%s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[4]);
+            ret = -1;
+            goto out;
+        }
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-                if (ret)
-                        goto out;
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, -1);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "operation", "GF_RESET_OP_COMMIT");
-                if (ret)
-                        goto out;
-        } else if (wordcount == 7) {
-                if (strcmp (words[5], "commit") || strcmp (words[6], "force")) {
-                        cli_err ("Invalid option '%s %s' for reset-brick. Please "
-                                 "enter valid reset-brick command",
-                                  words[5], words[6]);
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_START");
+        if (ret)
+            goto out;
+    } else if (wordcount == 6) {
+        if (strcmp(words[5], "commit")) {
+            cli_err(
+                "Invalid option '%s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[5]);
+            ret = -1;
+            goto out;
+        }
+
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+        if (ret)
+            goto out;
 
-                ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-                if (ret)
-                        goto out;
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_COMMIT");
+        if (ret)
+            goto out;
+    } else if (wordcount == 7) {
+        if (strcmp(words[5], "commit") || strcmp(words[6], "force")) {
+            cli_err(
+                "Invalid option '%s %s' for reset-brick. Please "
+                "enter valid reset-brick command",
+                words[5], words[6]);
+            ret = -1;
+            goto out;
+        }
+
+        ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "operation",
-                                    "GF_RESET_OP_COMMIT_FORCE");
-                if (ret)
-                        goto out;
-        }
+        ret = dict_set_str(dict, "operation", "GF_RESET_OP_COMMIT_FORCE");
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unable to parse reset-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
-                                    dict_t **options)
+cli_cmd_volume_replace_brick_parse(const char **words, int wordcount,
+                                   dict_t **options)
 {
-        int                   ret        = -1;
-        char                 *volname    = NULL;
-        dict_t               *dict       = NULL;
+    int ret = -1;
+    char *volname = NULL;
+    dict_t *dict = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        if (wordcount != 7) {
-                ret = -1;
-                goto out;
-        }
+    if (wordcount != 7) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to allocate dictionary");
-                goto out;
-        }
+    if (!dict) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to allocate dictionary");
+        goto out;
+    }
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        GF_ASSERT (volname);
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_brick_op_validate_bricks (words, dict, 3, 4);
-        if (ret)
-                goto out;
+    ret = cli_cmd_brick_op_validate_bricks(words, dict, 3, 4);
+    if (ret)
+        goto out;
 
-        /* commit force option */
-        if (strcmp ("commit", words[5]) || strcmp ("force", words[6])) {
-                cli_err ("Invalid option '%s' '%s' for replace-brick. Please "
-                         "enter valid replace-brick command", words[5],
-                         words[6]);
-                ret = -1;
-                goto out;
-        }
+    /* commit force option */
+    if (strcmp("commit", words[5]) || strcmp("force", words[6])) {
+        cli_err(
+            "Invalid option '%s' '%s' for replace-brick. Please "
+            "enter valid replace-brick command",
+            words[5], words[6]);
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "operation", "GF_REPLACE_OP_COMMIT_FORCE");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "operation", "GF_REPLACE_OP_COMMIT_FORCE");
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse reset-brick CLI");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_filename_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_filename_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[3];
-        GF_ASSERT (volname);
+    volname = (char *)words[3];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        str = (char *)words[4];
-        if (strchr (str, ':')) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
-                /* Path */
-                str = (char *)words[5];
-                ret = dict_set_str (dict, "path", str);
-                if (ret)
-                        goto out;
+    str = (char *)words[4];
+    if (strchr(str, ':')) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
         } else {
-                ret = dict_set_str (dict, "path", str);
-                if (ret)
-                        goto out;
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+        /* Path */
+        str = (char *)words[5];
+        ret = dict_set_str(dict, "path", str);
+        if (ret)
+            goto out;
+    } else {
+        ret = dict_set_str(dict, "path", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_level_parse (const char **words, int worcount, dict_t **options)
+cli_cmd_log_level_parse(const char **words, int worcount, dict_t **options)
 {
-        dict_t *dict            = NULL;
-        int     ret             = -1;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        /*
-         * loglevel command format:
-         *  > volume log level <VOL> <XLATOR[*]> <LOGLEVEL>
-         *  > volume log level colon-o posix WARNING
-         *  > volume log level colon-o replicate* DEBUG
-         *  > volume log level coon-o * TRACE
-         */
-
-        GF_ASSERT ((strncmp(words[0], "volume", 6) == 0));
-        GF_ASSERT ((strncmp(words[1], "log", 3) == 0));
-        GF_ASSERT ((strncmp(words[2], "level", 5) == 0));
-
-        ret = glusterd_check_log_level(words[5]);
-        if (ret == -1) {
-                cli_err("Invalid log level [%s] specified", words[5]);
-                cli_err("Valid values for loglevel: (DEBUG|WARNING|ERROR"
-                        "|CRITICAL|NONE|TRACE)");
-                goto out;
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    /*
+     * loglevel command format:
+     *  > volume log level <VOL> <XLATOR[*]> <LOGLEVEL>
+     *  > volume log level colon-o posix WARNING
+     *  > volume log level colon-o replicate* DEBUG
+     *  > volume log level coon-o * TRACE
+     */
+
+    GF_ASSERT((strncmp(words[0], "volume", 6) == 0));
+    GF_ASSERT((strncmp(words[1], "log", 3) == 0));
+    GF_ASSERT((strncmp(words[2], "level", 5) == 0));
+
+    ret = glusterd_check_log_level(words[5]);
+    if (ret == -1) {
+        cli_err("Invalid log level [%s] specified", words[5]);
+        cli_err(
+            "Valid values for loglevel: (DEBUG|WARNING|ERROR"
+            "|CRITICAL|NONE|TRACE)");
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        GF_ASSERT(words[3]);
-        GF_ASSERT(words[4]);
+    GF_ASSERT(words[3]);
+    GF_ASSERT(words[4]);
 
-        ret = dict_set_str (dict, "volname", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "xlator", (char *)words[4]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "xlator", (char *)words[4]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "loglevel", (char *)words[5]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "loglevel", (char *)words[5]);
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
- out:
-        if (ret && dict)
-                dict_unref (dict);
+out:
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_locate_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_locate_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[3];
-        GF_ASSERT (volname);
+    volname = (char *)words[3];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (words[4]) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                str = (char *)words[4];
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
+    if (words[4]) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
+        } else {
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        str = (char *)words[4];
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_log_rotate_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_log_rotate_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        char    *str = NULL;
-        int     ret = -1;
-        char    *delimiter = NULL;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *str = NULL;
+    int ret = -1;
+    char *delimiter = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp ("rotate", words[3]) == 0)
-                volname = (char *)words[2];
-        else if (strcmp ("rotate", words[2]) == 0)
-                volname = (char *)words[3];
-        GF_ASSERT (volname);
+    if (strcmp("rotate", words[3]) == 0)
+        volname = (char *)words[2];
+    else if (strcmp("rotate", words[2]) == 0)
+        volname = (char *)words[3];
+    GF_ASSERT(volname);
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        if (words[4]) {
-                delimiter = strchr (words[4], ':');
-                if (!delimiter || delimiter == words[4]
-                    || *(delimiter+1) != '/') {
-                        cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                 "<export-dir-abs-path>", words[4]);
-                        ret = -1;
-                        goto out;
-                } else {
-                        ret = gf_canonicalize_path (delimiter + 1);
-                        if (ret)
-                                goto out;
-                }
-                str = (char *)words[4];
-                ret = dict_set_str (dict, "brick", str);
-                if (ret)
-                        goto out;
+    if (words[4]) {
+        delimiter = strchr(words[4], ':');
+        if (!delimiter || delimiter == words[4] || *(delimiter + 1) != '/') {
+            cli_err(
+                "wrong brick type: %s, use <HOSTNAME>:"
+                "<export-dir-abs-path>",
+                words[4]);
+            ret = -1;
+            goto out;
+        } else {
+            ret = gf_canonicalize_path(delimiter + 1);
+            if (ret)
+                goto out;
         }
+        str = (char *)words[4];
+        ret = dict_set_str(dict, "brick", str);
+        if (ret)
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-gsyncd_url_check (const char *w)
+gsyncd_url_check(const char *w)
 {
-        return !!strpbrk (w, ":/");
+    return !!strpbrk(w, ":/");
 }
 
 static gf_boolean_t
-gsyncd_glob_check (const char *w)
+gsyncd_glob_check(const char *w)
 {
-        return !!strpbrk (w, "*?[");
+    return !!strpbrk(w, "*?[");
 }
 
 static int
-config_parse (const char **words, int wordcount, dict_t *dict,
-              unsigned cmdi, unsigned glob)
+config_parse(const char **words, int wordcount, dict_t *dict, unsigned cmdi,
+             unsigned glob)
 {
-        int32_t            ret     = -1;
-        int32_t            i       = -1;
-        char               *append_str = NULL;
-        size_t             append_len = 0;
-        char               *subop = NULL;
-        char               *ret_chkpt = NULL;
-        struct tm           checkpoint_time;
-        char                chkpt_buf[20] = "";
-
-        switch ((wordcount - 1) - cmdi) {
+    int32_t ret = -1;
+    int32_t i = -1;
+    char *append_str = NULL;
+    size_t append_len = 0;
+    char *subop = NULL;
+    char *ret_chkpt = NULL;
+    struct tm checkpoint_time;
+    char chkpt_buf[20] = "";
+
+    switch ((wordcount - 1) - cmdi) {
         case 0:
-                subop = gf_strdup ("get-all");
-                break;
+            subop = gf_strdup("get-all");
+            break;
         case 1:
-                if (words[cmdi + 1][0] == '!') {
-                        (words[cmdi + 1])++;
-                        if (gf_asprintf (&subop, "del%s",
-                                         glob ? "-glob" : "") == -1)
-                                subop = NULL;
-                } else
-                        subop = gf_strdup ("get");
+            if (words[cmdi + 1][0] == '!') {
+                (words[cmdi + 1])++;
+                if (gf_asprintf(&subop, "del%s", glob ? "-glob" : "") == -1)
+                    subop = NULL;
+            } else
+                subop = gf_strdup("get");
 
-                ret = dict_set_str (dict, "op_name", ((char *)words[cmdi + 1]));
-                if (ret < 0)
-                        goto out;
-                break;
+            ret = dict_set_str(dict, "op_name", ((char *)words[cmdi + 1]));
+            if (ret < 0)
+                goto out;
+            break;
         default:
-                if (gf_asprintf (&subop, "set%s", glob ? "-glob" : "") == -1)
-                        subop = NULL;
+            if (gf_asprintf(&subop, "set%s", glob ? "-glob" : "") == -1)
+                subop = NULL;
 
-                ret = dict_set_str (dict, "op_name", ((char *)words[cmdi + 1]));
-                if (ret < 0)
-                        goto out;
+            ret = dict_set_str(dict, "op_name", ((char *)words[cmdi + 1]));
+            if (ret < 0)
+                goto out;
 
-                /* join the varargs by spaces to get the op_value */
+            /* join the varargs by spaces to get the op_value */
 
-                for (i = cmdi + 2; i < wordcount; i++)
-                        append_len += (strlen (words[i]) + 1);
-                /* trailing strcat will add two bytes, make space for that */
-                append_len++;
+            for (i = cmdi + 2; i < wordcount; i++)
+                append_len += (strlen(words[i]) + 1);
+            /* trailing strcat will add two bytes, make space for that */
+            append_len++;
 
-                append_str = GF_MALLOC (append_len, cli_mt_append_str);
-                if (!append_str) {
-                        ret = -1;
-                        goto out;
-                }
+            append_str = GF_MALLOC(append_len, cli_mt_append_str);
+            if (!append_str) {
+                ret = -1;
+                goto out;
+            }
+
+            for (i = cmdi + 2; i < wordcount; i++) {
+                strcat(append_str, words[i]);
+                strcat(append_str, " ");
+            }
+            append_str[append_len - 2] = '\0';
+            /* "checkpoint now" is special: we resolve that "now" */
+            if ((strcmp(words[cmdi + 1], "checkpoint") == 0) &&
+                (strcmp(append_str, "now") == 0)) {
+                struct timeval tv = {
+                    0,
+                };
+
+                ret = gettimeofday(&tv, NULL);
+                if (ret == -1)
+                    goto out;
 
-                for (i = cmdi + 2; i < wordcount; i++) {
-                        strcat (append_str, words[i]);
-                        strcat (append_str, " ");
-                }
-                append_str[append_len - 2] = '\0';
-                /* "checkpoint now" is special: we resolve that "now" */
-                if ((strcmp (words[cmdi + 1], "checkpoint") == 0) &&
-                    (strcmp (append_str, "now") == 0)) {
-                        struct timeval tv = {0,};
-
-                        ret = gettimeofday (&tv, NULL);
-                        if (ret == -1)
-                                goto out;
-
-                        GF_FREE (append_str);
-                        append_str = GF_MALLOC (300, cli_mt_append_str);
-                        if (!append_str) {
-                                ret = -1;
-                                goto out;
-                        }
-                        snprintf (append_str, 300, "%" GF_PRI_SECOND,
-                                  tv.tv_sec);
-                } else if ((strcmp (words[cmdi + 1], "checkpoint") == 0) &&
-                           (strcmp (append_str, "now") != 0)) {
-                        memset(&checkpoint_time, 0, sizeof(struct tm));
-                        ret_chkpt = strptime(append_str, "%Y-%m-%d %H:%M:%S",
-                                             &checkpoint_time);
-
-                        if (ret_chkpt == NULL) {
-                                ret = -1;
-                                cli_err ("Invalid Checkpoint label. Use format "
-                                         "\"Y-m-d H:M:S\", Example: 2016-10-25 15:30:45");
-                                goto out;
-                        }
-                        GF_FREE (append_str);
-                        append_str = GF_MALLOC (300, cli_mt_append_str);
-                        if (!append_str) {
-                                ret = -1;
-                                goto out;
-                        }
-                        strftime (chkpt_buf, sizeof(chkpt_buf), "%s",
-                                  &checkpoint_time);
-                        snprintf (append_str, 300, "%s", chkpt_buf);
+                GF_FREE(append_str);
+                append_str = GF_MALLOC(300, cli_mt_append_str);
+                if (!append_str) {
+                    ret = -1;
+                    goto out;
+                }
+                snprintf(append_str, 300, "%" GF_PRI_SECOND, tv.tv_sec);
+            } else if ((strcmp(words[cmdi + 1], "checkpoint") == 0) &&
+                       (strcmp(append_str, "now") != 0)) {
+                memset(&checkpoint_time, 0, sizeof(struct tm));
+                ret_chkpt = strptime(append_str, "%Y-%m-%d %H:%M:%S",
+                                     &checkpoint_time);
+
+                if (ret_chkpt == NULL) {
+                    ret = -1;
+                    cli_err(
+                        "Invalid Checkpoint label. Use format "
+                        "\"Y-m-d H:M:S\", Example: 2016-10-25 15:30:45");
+                    goto out;
+                }
+                GF_FREE(append_str);
+                append_str = GF_MALLOC(300, cli_mt_append_str);
+                if (!append_str) {
+                    ret = -1;
+                    goto out;
                 }
+                strftime(chkpt_buf, sizeof(chkpt_buf), "%s", &checkpoint_time);
+                snprintf(append_str, 300, "%s", chkpt_buf);
+            }
 
-                ret = dict_set_dynstr (dict, "op_value", append_str);
-                if (ret != 0) {
-                        goto out;
-                }
-                append_str = NULL;
-        }
+            ret = dict_set_dynstr(dict, "op_value", append_str);
+            if (ret != 0) {
+                goto out;
+            }
+            append_str = NULL;
+    }
 
-        ret = -1;
-        if (subop) {
-                ret = dict_set_dynstr (dict, "subop", subop);
-                if (!ret)
-                      subop = NULL;
-        }
+    ret = -1;
+    if (subop) {
+        ret = dict_set_dynstr(dict, "subop", subop);
+        if (!ret)
+            subop = NULL;
+    }
 
 out:
-        GF_FREE (append_str);
-        GF_FREE (subop);
+    GF_FREE(append_str);
+    GF_FREE(subop);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 /* ssh_port_parse: Parses and validates when ssh_port is given.
@@ -2755,1529 +2823,1493 @@ out:
  */
 
 static int32_t
-parse_ssh_port (const char **words, int wordcount, dict_t *dict,
-                unsigned *cmdi, int ssh_index, char *type) {
-
-        int        ret         = 0;
-        char      *end_ptr     = NULL;
-        int64_t    limit       = 0;
-
-        if (!strcmp ((char *)words[ssh_index], "ssh-port")) {
-                if (strcmp ((char *)words[ssh_index-1], "create")) {
-                        ret = -1;
-                        goto out;
-                }
-                (*cmdi)++;
-                limit = strtol (words[ssh_index+1], &end_ptr, 10);
-                if (errno == ERANGE || errno == EINVAL || limit <= 0
-                                    || strcmp (end_ptr, "") != 0) {
-                        ret = -1;
-                        cli_err ("Please enter an integer value for ssh_port ");
-                        goto out;
-                }
+parse_ssh_port(const char **words, int wordcount, dict_t *dict, unsigned *cmdi,
+               int ssh_index, char *type)
+{
+    int ret = 0;
+    char *end_ptr = NULL;
+    int64_t limit = 0;
 
-                ret = dict_set_int32 (dict, "ssh_port", limit);
-                if (ret)
-                        goto out;
-                (*cmdi)++;
-        } else if (strcmp ((char *)words[ssh_index+1], "create")) {
-                ret = -1;
-                goto out;
+    if (!strcmp((char *)words[ssh_index], "ssh-port")) {
+        if (strcmp((char *)words[ssh_index - 1], "create")) {
+            ret = -1;
+            goto out;
+        }
+        (*cmdi)++;
+        limit = strtol(words[ssh_index + 1], &end_ptr, 10);
+        if (errno == ERANGE || errno == EINVAL || limit <= 0 ||
+            strcmp(end_ptr, "") != 0) {
+            ret = -1;
+            cli_err("Please enter an integer value for ssh_port ");
+            goto out;
         }
 
-        ret = dict_set_int32 (dict, type, 1);
+        ret = dict_set_int32(dict, "ssh_port", limit);
         if (ret)
-                goto out;
+            goto out;
         (*cmdi)++;
+    } else if (strcmp((char *)words[ssh_index + 1], "create")) {
+        ret = -1;
+        goto out;
+    }
 
- out:
-        return ret;
+    ret = dict_set_int32(dict, type, 1);
+    if (ret)
+        goto out;
+    (*cmdi)++;
+
+out:
+    return ret;
 }
 
 static int32_t
-force_push_pem_no_verify_parse (const char **words, int wordcount,
-                      dict_t *dict, unsigned *cmdi)
+force_push_pem_no_verify_parse(const char **words, int wordcount, dict_t *dict,
+                               unsigned *cmdi)
 {
-        int32_t            ret     = 0;
-
-        if (!strcmp ((char *)words[wordcount-1], "force")) {
-                if ((strcmp ((char *)words[wordcount-2], "start")) &&
-                    (strcmp ((char *)words[wordcount-2], "stop")) &&
-                    (strcmp ((char *)words[wordcount-2], "create")) &&
-                    (strcmp ((char *)words[wordcount-2], "no-verify")) &&
-                    (strcmp ((char *)words[wordcount-2], "push-pem")) &&
-                    (strcmp ((char *)words[wordcount-2], "pause")) &&
-                    (strcmp ((char *)words[wordcount-2], "resume"))) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_uint32 (dict, "force",
-                                       _gf_true);
-                if (ret)
-                        goto out;
-                (*cmdi)++;
-
-                if (!strcmp ((char *)words[wordcount-2], "push-pem")) {
-                        ret = parse_ssh_port (words, wordcount, dict, cmdi,
-                                              wordcount-4, "push_pem");
-                        if (ret)
-                                goto out;
-                } else if (!strcmp ((char *)words[wordcount-2], "no-verify")) {
-                        ret = parse_ssh_port (words, wordcount, dict, cmdi,
-                                              wordcount-4, "no_verify");
-                        if (ret)
-                                goto out;
-                }
-        } else if (!strcmp ((char *)words[wordcount-1], "push-pem")) {
-                ret = parse_ssh_port (words, wordcount, dict, cmdi, wordcount-3,
-                                      "push_pem");
-                if (ret)
-                        goto out;
-        } else if (!strcmp ((char *)words[wordcount-1], "no-verify")) {
-                ret = parse_ssh_port (words, wordcount, dict, cmdi, wordcount-3,
-                                      "no_verify");
-                if (ret)
-                        goto out;
+    int32_t ret = 0;
+
+    if (!strcmp((char *)words[wordcount - 1], "force")) {
+        if ((strcmp((char *)words[wordcount - 2], "start")) &&
+            (strcmp((char *)words[wordcount - 2], "stop")) &&
+            (strcmp((char *)words[wordcount - 2], "create")) &&
+            (strcmp((char *)words[wordcount - 2], "no-verify")) &&
+            (strcmp((char *)words[wordcount - 2], "push-pem")) &&
+            (strcmp((char *)words[wordcount - 2], "pause")) &&
+            (strcmp((char *)words[wordcount - 2], "resume"))) {
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_uint32(dict, "force", _gf_true);
+        if (ret)
+            goto out;
+        (*cmdi)++;
+
+        if (!strcmp((char *)words[wordcount - 2], "push-pem")) {
+            ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 4,
+                                 "push_pem");
+            if (ret)
+                goto out;
+        } else if (!strcmp((char *)words[wordcount - 2], "no-verify")) {
+            ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 4,
+                                 "no_verify");
+            if (ret)
+                goto out;
         }
+    } else if (!strcmp((char *)words[wordcount - 1], "push-pem")) {
+        ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 3,
+                             "push_pem");
+        if (ret)
+            goto out;
+    } else if (!strcmp((char *)words[wordcount - 1], "no-verify")) {
+        ret = parse_ssh_port(words, wordcount, dict, cmdi, wordcount - 3,
+                             "no_verify");
+        if (ret)
+            goto out;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
-
 int32_t
-cli_cmd_gsync_set_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_gsync_set_parse(const char **words, int wordcount, dict_t **options)
 {
-        int32_t            ret     = -1;
-        dict_t             *dict   = NULL;
-        gf1_cli_gsync_set  type    = GF_GSYNC_OPTION_TYPE_NONE;
-        int                i       = 0;
-        unsigned           masteri = 0;
-        unsigned           slavei  = 0;
-        unsigned           glob    = 0;
-        unsigned           cmdi    = 0;
-        char               *opwords[] = { "create", "status", "start", "stop",
-                                          "config", "force", "delete",
-                                          "ssh-port", "no-verify", "push-pem",
-                                          "detail", "pause", "resume", NULL };
-        char               *w = NULL;
-        char               *save_ptr   = NULL;
-        char               *slave_temp = NULL;
-        char               *token      = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        /* new syntax:
-         *
-         * volume geo-replication $m $s create [[ssh-port n] [[no-verify] | [push-pem]]] [force]
-         * volume geo-replication [$m [$s]] status [detail]
-         * volume geo-replication [$m] $s config [[!]$opt [$val]]
-         * volume geo-replication $m $s start|stop [force]
-         * volume geo-replication $m $s delete [reset-sync-time]
-         * volume geo-replication $m $s pause [force]
-         * volume geo-replication $m $s resume [force]
-         */
+    int32_t ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_gsync_set type = GF_GSYNC_OPTION_TYPE_NONE;
+    int i = 0;
+    unsigned masteri = 0;
+    unsigned slavei = 0;
+    unsigned glob = 0;
+    unsigned cmdi = 0;
+    char *opwords[] = {"create", "status", "start",    "stop",      "config",
+                       "force",  "delete", "ssh-port", "no-verify", "push-pem",
+                       "detail", "pause",  "resume",   NULL};
+    char *w = NULL;
+    char *save_ptr = NULL;
+    char *slave_temp = NULL;
+    char *token = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount < 3)
-                goto out;
+    /* new syntax:
+     *
+     * volume geo-replication $m $s create [[ssh-port n] [[no-verify] |
+     * [push-pem]]] [force] volume geo-replication [$m [$s]] status [detail]
+     * volume geo-replication [$m] $s config [[!]$opt [$val]]
+     * volume geo-replication $m $s start|stop [force]
+     * volume geo-replication $m $s delete [reset-sync-time]
+     * volume geo-replication $m $s pause [force]
+     * volume geo-replication $m $s resume [force]
+     */
+
+    if (wordcount < 3)
+        goto out;
 
-        for (i = 2; i <= 3 && i < wordcount - 1; i++) {
-                if (gsyncd_glob_check (words[i]))
-                        glob = i;
-                if (gsyncd_url_check (words[i])) {
-                        slavei = i;
-                        break;
-                }
+    for (i = 2; i <= 3 && i < wordcount - 1; i++) {
+        if (gsyncd_glob_check(words[i]))
+            glob = i;
+        if (gsyncd_url_check(words[i])) {
+            slavei = i;
+            break;
         }
+    }
 
-        if (glob && !slavei)
-                /* glob is allowed only for config, thus it implies there is a
-                 * slave argument; but that might have not been recognized on
-                 * the first scan as it's url characteristics has been covered
-                 * by the glob syntax.
-                 *
-                 * In this case, the slave is perforce the last glob-word -- the
-                 * upcoming one is neither glob, nor url, so it's definitely not
-                 * the slave.
-                 */
-                slavei = glob;
-        if (slavei) {
-                cmdi = slavei + 1;
-                if (slavei == 3)
-                        masteri = 2;
-        } else if (i <= 4) {
-                if (strtail ("detail", (char *)words[wordcount-1])) {
-                        cmdi = wordcount - 2;
-                        if (i == 4)
-                                masteri = 2;
-                } else {
-                        /* no $s, can only be status cmd
-                         * (with either a single $m before it or nothing)
-                         * -- these conditions imply that i <= 3 after
-                         * the iteration and that i is the successor of
-                         * the (0 or 1 length) sequence of $m-s.
-                         */
-                        cmdi = i;
-                        if (i == 3)
-                                masteri = 2;
-                }
-        } else
-                goto out;
-
-        /* now check if input really complies syntax
-         * (in a somewhat redundant way, in favor
-         * transparent soundness)
+    if (glob && !slavei)
+        /* glob is allowed only for config, thus it implies there is a
+         * slave argument; but that might have not been recognized on
+         * the first scan as it's url characteristics has been covered
+         * by the glob syntax.
+         *
+         * In this case, the slave is perforce the last glob-word -- the
+         * upcoming one is neither glob, nor url, so it's definitely not
+         * the slave.
          */
+        slavei = glob;
+    if (slavei) {
+        cmdi = slavei + 1;
+        if (slavei == 3)
+            masteri = 2;
+    } else if (i <= 4) {
+        if (strtail("detail", (char *)words[wordcount - 1])) {
+            cmdi = wordcount - 2;
+            if (i == 4)
+                masteri = 2;
+        } else {
+            /* no $s, can only be status cmd
+             * (with either a single $m before it or nothing)
+             * -- these conditions imply that i <= 3 after
+             * the iteration and that i is the successor of
+             * the (0 or 1 length) sequence of $m-s.
+             */
+            cmdi = i;
+            if (i == 3)
+                masteri = 2;
+        }
+    } else
+        goto out;
 
-        if (masteri && gsyncd_url_check (words[masteri]))
-                goto out;
-        if (slavei && !glob && !gsyncd_url_check (words[slavei]))
-                goto out;
-
-        w = str_getunamb (words[cmdi], opwords);
-        if (!w)
-                goto out;
-
-        if (strcmp (w, "create") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_CREATE;
-
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "status") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_STATUS;
-
-                if (slavei && !masteri)
-                        goto out;
-        } else if (strcmp (w, "config") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_CONFIG;
-
-                if (!slavei)
-                        goto out;
-        } else if (strcmp (w, "start") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_START;
-
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "stop") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_STOP;
+    /* now check if input really complies syntax
+     * (in a somewhat redundant way, in favor
+     * transparent soundness)
+     */
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "delete") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_DELETE;
+    if (masteri && gsyncd_url_check(words[masteri]))
+        goto out;
+    if (slavei && !glob && !gsyncd_url_check(words[slavei]))
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "pause") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_PAUSE;
+    w = str_getunamb(words[cmdi], opwords);
+    if (!w)
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else if (strcmp (w, "resume") == 0) {
-                type = GF_GSYNC_OPTION_TYPE_RESUME;
+    if (strcmp(w, "create") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_CREATE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "status") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_STATUS;
+
+        if (slavei && !masteri)
+            goto out;
+    } else if (strcmp(w, "config") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_CONFIG;
+
+        if (!slavei)
+            goto out;
+    } else if (strcmp(w, "start") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_START;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "stop") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_STOP;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "delete") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_DELETE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "pause") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_PAUSE;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else if (strcmp(w, "resume") == 0) {
+        type = GF_GSYNC_OPTION_TYPE_RESUME;
+
+        if (!masteri || !slavei)
+            goto out;
+    } else
+        GF_ASSERT(!"opword mismatch");
+
+    ret = force_push_pem_no_verify_parse(words, wordcount, dict, &cmdi);
+    if (ret)
+        goto out;
 
-                if (!masteri || !slavei)
-                        goto out;
-        } else
-                GF_ASSERT (!"opword mismatch");
+    if (strtail("detail", (char *)words[wordcount - 1])) {
+        if (!strtail("status", (char *)words[wordcount - 2])) {
+            ret = -1;
+            goto out;
+        }
 
-        ret = force_push_pem_no_verify_parse (words, wordcount, dict, &cmdi);
+        ret = dict_set_uint32(dict, "status-detail", _gf_true);
         if (ret)
-                goto out;
-
-        if (strtail ("detail", (char *)words[wordcount-1])) {
-                if (!strtail ("status", (char *)words[wordcount-2])) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_set_uint32 (dict, "status-detail", _gf_true);
-                if (ret)
-                        goto out;
-                cmdi++;
-        }
+            goto out;
+        cmdi++;
+    }
 
-        if (type == GF_GSYNC_OPTION_TYPE_DELETE &&
-            !strcmp ((char *)words[wordcount-1], "reset-sync-time")) {
-                if (strcmp ((char *)words[wordcount-2], "delete")) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_uint32 (dict, "reset-sync-time", _gf_true);
-                if (ret)
-                        goto out;
-                cmdi++;
+    if (type == GF_GSYNC_OPTION_TYPE_DELETE &&
+        !strcmp((char *)words[wordcount - 1], "reset-sync-time")) {
+        if (strcmp((char *)words[wordcount - 2], "delete")) {
+            ret = -1;
+            goto out;
         }
+        ret = dict_set_uint32(dict, "reset-sync-time", _gf_true);
+        if (ret)
+            goto out;
+        cmdi++;
+    }
 
-        if (type != GF_GSYNC_OPTION_TYPE_CONFIG &&
-            (cmdi < wordcount - 1 || glob))
-                goto out;
+    if (type != GF_GSYNC_OPTION_TYPE_CONFIG && (cmdi < wordcount - 1 || glob))
+        goto out;
 
-        /* If got so far, input is valid, assemble the message */
+    /* If got so far, input is valid, assemble the message */
 
-        ret = 0;
+    ret = 0;
 
-        if (masteri) {
-                ret = dict_set_str (dict, "master", (char *)words[masteri]);
-                if (!ret)
-                        ret = dict_set_str (dict, "volname",
-                                            (char *)words[masteri]);
-        }
-        if (!ret && slavei) {
-                /* If geo-rep is created with root user using the syntax
-                 * gluster vol geo-rep <mastervol> root@<slavehost> ...
-                 * pass down only <slavehost> else pass as it is.
-                 */
-                slave_temp = gf_strdup (words[slavei]);
-                if (slave_temp == NULL) {
-                        ret = -1;
-                        goto out;
-                }
-                token = strtok_r (slave_temp, "@", &save_ptr);
-                if (token && !strcmp (token, "root")) {
-                        ret = dict_set_str (dict, "slave",
-                                            (char *)words[slavei]+5);
-                } else {
-                        ret = dict_set_str (dict, "slave",
-                                            (char *)words[slavei]);
-                }
-        }
+    if (masteri) {
+        ret = dict_set_str(dict, "master", (char *)words[masteri]);
         if (!ret)
-                ret = dict_set_int32 (dict, "type", type);
-        if (!ret && type == GF_GSYNC_OPTION_TYPE_CONFIG)
-                ret = config_parse (words, wordcount, dict, cmdi, glob);
+            ret = dict_set_str(dict, "volname", (char *)words[masteri]);
+    }
+    if (!ret && slavei) {
+        /* If geo-rep is created with root user using the syntax
+         * gluster vol geo-rep <mastervol> root@<slavehost> ...
+         * pass down only <slavehost> else pass as it is.
+         */
+        slave_temp = gf_strdup(words[slavei]);
+        if (slave_temp == NULL) {
+            ret = -1;
+            goto out;
+        }
+        token = strtok_r(slave_temp, "@", &save_ptr);
+        if (token && !strcmp(token, "root")) {
+            ret = dict_set_str(dict, "slave", (char *)words[slavei] + 5);
+        } else {
+            ret = dict_set_str(dict, "slave", (char *)words[slavei]);
+        }
+    }
+    if (!ret)
+        ret = dict_set_int32(dict, "type", type);
+    if (!ret && type == GF_GSYNC_OPTION_TYPE_CONFIG)
+        ret = config_parse(words, wordcount, dict, cmdi, glob);
 
 out:
-        if (slave_temp)
-                GF_FREE (slave_temp);
-        if (ret) {
-                if (dict)
-                        dict_unref (dict);
-        } else
-                *options = dict;
-
+    if (slave_temp)
+        GF_FREE(slave_temp);
+    if (ret) {
+        if (dict)
+            dict_unref(dict);
+    } else
+        *options = dict;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_profile_parse (const char **words, int wordcount,
-                              dict_t **options)
+cli_cmd_volume_profile_parse(const char **words, int wordcount,
+                             dict_t **options)
 {
-        dict_t              *dict       = NULL;
-        char                *volname    = NULL;
-        int                 ret         = -1;
-        gf1_cli_stats_op    op          = GF_CLI_STATS_NONE;
-        gf1_cli_info_op     info_op     = GF_CLI_INFO_NONE;
-        gf_boolean_t        is_peek     = _gf_false;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int ret = -1;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    gf1_cli_info_op info_op = GF_CLI_INFO_NONE;
+    gf_boolean_t is_peek = _gf_false;
 
-        char      *opwords[] = { "start", "stop", "info", NULL };
-        char      *w = NULL;
+    char *opwords[] = {"start", "stop", "info", NULL};
+    char *w = NULL;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount < 4)
-                goto out;
+    if (wordcount < 4)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
-        }
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    }
 
-        if ((strcmp (w, "start") == 0 || strcmp (w, "stop") == 0) &&
-            wordcount > 5)
-                goto out;
+    if ((strcmp(w, "start") == 0 || strcmp(w, "stop") == 0) && wordcount > 5)
+        goto out;
 
-        if (strcmp (w, "info") == 0 && wordcount > 7)
-                goto out;
+    if (strcmp(w, "info") == 0 && wordcount > 7)
+        goto out;
 
-        if (strcmp (w, "start") == 0) {
-                op = GF_CLI_STATS_START;
-        } else if (strcmp (w, "stop") == 0) {
-                op = GF_CLI_STATS_STOP;
-        } else if (strcmp (w, "info") == 0) {
-                op = GF_CLI_STATS_INFO;
-                info_op = GF_CLI_INFO_ALL;
-                if (wordcount > 4) {
-                        if (strcmp (words[4], "incremental") == 0) {
-                                info_op = GF_CLI_INFO_INCREMENTAL;
-                                if (wordcount > 5 &&
-                                    strcmp (words[5], "peek") == 0) {
-                                        is_peek = _gf_true;
-                                }
-                        } else if (strcmp (words[4], "cumulative") == 0) {
-                                info_op = GF_CLI_INFO_CUMULATIVE;
-                        } else if (strcmp (words[4], "clear") == 0) {
-                                info_op = GF_CLI_INFO_CLEAR;
-                        } else if (strcmp (words[4], "peek") == 0) {
-                                is_peek = _gf_true;
-                        }
-                }
-        } else
-                GF_ASSERT (!"opword mismatch");
+    if (strcmp(w, "start") == 0) {
+        op = GF_CLI_STATS_START;
+    } else if (strcmp(w, "stop") == 0) {
+        op = GF_CLI_STATS_STOP;
+    } else if (strcmp(w, "info") == 0) {
+        op = GF_CLI_STATS_INFO;
+        info_op = GF_CLI_INFO_ALL;
+        if (wordcount > 4) {
+            if (strcmp(words[4], "incremental") == 0) {
+                info_op = GF_CLI_INFO_INCREMENTAL;
+                if (wordcount > 5 && strcmp(words[5], "peek") == 0) {
+                    is_peek = _gf_true;
+                }
+            } else if (strcmp(words[4], "cumulative") == 0) {
+                info_op = GF_CLI_INFO_CUMULATIVE;
+            } else if (strcmp(words[4], "clear") == 0) {
+                info_op = GF_CLI_INFO_CLEAR;
+            } else if (strcmp(words[4], "peek") == 0) {
+                is_peek = _gf_true;
+            }
+        }
+    } else
+        GF_ASSERT(!"opword mismatch");
+
+    ret = dict_set_int32(dict, "op", (int32_t)op);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "op", (int32_t)op);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "info-op", (int32_t)info_op);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "info-op", (int32_t)info_op);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(dict, "peek", is_peek);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "peek", is_peek);
+    if (!strcmp(words[wordcount - 1], "nfs")) {
+        ret = dict_set_int32(dict, "nfs", _gf_true);
         if (ret)
-                goto out;
-
-        if (!strcmp (words[wordcount - 1], "nfs")) {
-                ret = dict_set_int32 (dict, "nfs", _gf_true);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 out:
-        if (ret && dict)
-                dict_unref (dict);
-        return ret;
+    if (ret && dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int32_t
-cli_cmd_volume_top_parse (const char **words, int wordcount,
-                              dict_t **options)
+cli_cmd_volume_top_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t  *dict           = NULL;
-        char    *volname        = NULL;
-        char    *value          = NULL;
-        char    *key            = NULL;
-        int      ret            = -1;
-        gf1_cli_stats_op op = GF_CLI_STATS_NONE;
-        gf1_cli_top_op    top_op = GF_CLI_TOP_NONE;
-        int32_t  list_cnt       = -1;
-        int      index          = 0;
-        int      perf           = 0;
-        int32_t  blk_size       = 0;
-        int      count          = 0;
-        gf_boolean_t nfs        = _gf_false;
-        char    *delimiter      = NULL;
-        char    *opwords[]      = { "open", "read", "write", "opendir",
-                                    "readdir", "read-perf", "write-perf",
-                                    "clear", NULL };
-        char    *w = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    char *value = NULL;
+    char *key = NULL;
+    int ret = -1;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    gf1_cli_top_op top_op = GF_CLI_TOP_NONE;
+    int32_t list_cnt = -1;
+    int index = 0;
+    int perf = 0;
+    int32_t blk_size = 0;
+    int count = 0;
+    gf_boolean_t nfs = _gf_false;
+    char *delimiter = NULL;
+    char *opwords[] = {"open",      "read",       "write", "opendir", "readdir",
+                       "read-perf", "write-perf", "clear", NULL};
+    char *w = NULL;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount < 4)
-                goto out;
+    if (wordcount < 4)
+        goto out;
 
-        volname = (char *)words[2];
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret)
+        goto out;
 
-        op = GF_CLI_STATS_TOP;
-        ret = dict_set_int32 (dict, "op", (int32_t)op);
-        if (ret)
-                goto out;
+    op = GF_CLI_STATS_TOP;
+    ret = dict_set_int32(dict, "op", (int32_t)op);
+    if (ret)
+        goto out;
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                ret = -1;
-                goto out;
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        ret = -1;
+        goto out;
+    }
+    if (strcmp(w, "open") == 0) {
+        top_op = GF_CLI_TOP_OPEN;
+    } else if (strcmp(w, "read") == 0) {
+        top_op = GF_CLI_TOP_READ;
+    } else if (strcmp(w, "write") == 0) {
+        top_op = GF_CLI_TOP_WRITE;
+    } else if (strcmp(w, "opendir") == 0) {
+        top_op = GF_CLI_TOP_OPENDIR;
+    } else if (strcmp(w, "readdir") == 0) {
+        top_op = GF_CLI_TOP_READDIR;
+    } else if (strcmp(w, "read-perf") == 0) {
+        top_op = GF_CLI_TOP_READ_PERF;
+        perf = 1;
+    } else if (strcmp(w, "write-perf") == 0) {
+        top_op = GF_CLI_TOP_WRITE_PERF;
+        perf = 1;
+    } else if (strcmp(w, "clear") == 0) {
+        ret = dict_set_int32(dict, "clear-stats", 1);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not set clear-stats in dict");
+            goto out;
         }
-        if (strcmp (w, "open") == 0) {
-                top_op = GF_CLI_TOP_OPEN;
-        } else if (strcmp (w, "read") == 0) {
-                top_op = GF_CLI_TOP_READ;
-        } else if (strcmp (w, "write") == 0) {
-                top_op = GF_CLI_TOP_WRITE;
-        } else if (strcmp (w, "opendir") == 0) {
-                top_op = GF_CLI_TOP_OPENDIR;
-        } else if (strcmp (w, "readdir") == 0) {
-                top_op = GF_CLI_TOP_READDIR;
-        } else if (strcmp (w, "read-perf") == 0) {
-                top_op = GF_CLI_TOP_READ_PERF;
-                perf = 1;
-        } else if (strcmp (w, "write-perf") == 0) {
-                top_op = GF_CLI_TOP_WRITE_PERF;
-                perf = 1;
-        } else if (strcmp (w, "clear") == 0) {
-                ret = dict_set_int32 (dict, "clear-stats", 1);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not set clear-stats in dict");
-                        goto out;
-                }
-        } else
-                GF_ASSERT (!"opword mismatch");
-        ret = dict_set_int32 (dict, "top-op", (int32_t)top_op);
+    } else
+        GF_ASSERT(!"opword mismatch");
+    ret = dict_set_int32(dict, "top-op", (int32_t)top_op);
+    if (ret)
+        goto out;
+
+    if ((wordcount > 4) && !strcmp(words[4], "nfs")) {
+        nfs = _gf_true;
+        ret = dict_set_int32(dict, "nfs", nfs);
         if (ret)
+            goto out;
+        index = 5;
+    } else {
+        index = 4;
+    }
+
+    for (; index < wordcount; index += 2) {
+        key = (char *)words[index];
+        value = (char *)words[index + 1];
+
+        if (!key || !value) {
+            ret = -1;
+            goto out;
+        }
+        if (!strcmp(key, "brick")) {
+            delimiter = strchr(value, ':');
+            if (!delimiter || delimiter == value || *(delimiter + 1) != '/') {
+                cli_err(
+                    "wrong brick type: %s, use <HOSTNAME>:"
+                    "<export-dir-abs-path>",
+                    value);
+                ret = -1;
                 goto out;
-
-        if ((wordcount > 4) && !strcmp (words[4], "nfs")) {
-                nfs = _gf_true;
-                ret = dict_set_int32 (dict, "nfs", nfs);
+            } else {
+                ret = gf_canonicalize_path(delimiter + 1);
                 if (ret)
-                        goto out;
-                index = 5;
-        } else {
-                index = 4;
-        }
-
-        for (; index < wordcount; index+=2) {
-
-                key = (char *) words[index];
-                value = (char *) words[index+1];
-
-                if (!key || !value) {
-                        ret = -1;
-                        goto out;
-                }
-                if (!strcmp (key, "brick")) {
-                        delimiter = strchr (value, ':');
-                        if (!delimiter || delimiter == value
-                            || *(delimiter+1) != '/') {
-                                cli_err ("wrong brick type: %s, use <HOSTNAME>:"
-                                         "<export-dir-abs-path>", value);
-                                ret = -1;
-                                goto out;
-                        } else {
-                                ret = gf_canonicalize_path (delimiter + 1);
-                                if (ret)
-                                        goto out;
-                        }
-                        ret = dict_set_str (dict, "brick", value);
-
-                } else if (!strcmp (key, "list-cnt")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                list_cnt = atoi (value);
-                        if (ret || (list_cnt < 0) || (list_cnt > 100)) {
-                                cli_err ("list-cnt should be between 0 to 100");
-                                ret = -1;
-                                goto out;
-                        }
-                } else if (perf && !nfs && !strcmp (key, "bs")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                blk_size = atoi (value);
-                        if (ret || (blk_size <= 0)) {
-                                if (blk_size < 0)
-                                        cli_err ("block size is an invalid"
-                                                 " number");
-                                else
-                                        cli_err ("block size should be an "
-                                                 "integer greater than zero");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_uint32 (dict, "blk-size",
-                                                        (uint32_t)blk_size);
-                } else if (perf && !nfs && !strcmp (key, "count")) {
-                        ret = gf_is_str_int (value);
-                        if (!ret)
-                                count = atoi(value);
-                        if (ret || (count <= 0)) {
-                                if (count < 0)
-                                        cli_err ("count is an invalid number");
-                                else
-                                        cli_err ("count should be an integer "
-                                                 "greater than zero");
-
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dict_set_uint32 (dict, "blk-cnt", count);
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-                if (ret) {
-                        gf_log ("", GF_LOG_WARNING, "Dict set failed for "
-                                "key %s", key);
-                        goto out;
-                }
-        }
-        if (list_cnt == -1)
-                list_cnt = 100;
-        ret = dict_set_int32 (dict, "list-cnt", list_cnt);
-        if (ret) {
-                gf_log ("", GF_LOG_WARNING, "Dict set failed for list_cnt");
+                    goto out;
+            }
+            ret = dict_set_str(dict, "brick", value);
+
+        } else if (!strcmp(key, "list-cnt")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                list_cnt = atoi(value);
+            if (ret || (list_cnt < 0) || (list_cnt > 100)) {
+                cli_err("list-cnt should be between 0 to 100");
+                ret = -1;
                 goto out;
-        }
-
-        if ((blk_size > 0) ^ (count > 0)) {
-                cli_err ("Need to give both 'bs' and 'count'");
+            }
+        } else if (perf && !nfs && !strcmp(key, "bs")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                blk_size = atoi(value);
+            if (ret || (blk_size <= 0)) {
+                if (blk_size < 0)
+                    cli_err(
+                        "block size is an invalid"
+                        " number");
+                else
+                    cli_err(
+                        "block size should be an "
+                        "integer greater than zero");
                 ret = -1;
                 goto out;
-        } else if (((uint64_t)blk_size * count) > (10 * GF_UNIT_GB)) {
-                cli_err ("'bs * count' value %"PRIu64" is greater than "
-                         "maximum allowed value of 10GB",
-                         ((uint64_t)blk_size * count));
+            }
+            ret = dict_set_uint32(dict, "blk-size", (uint32_t)blk_size);
+        } else if (perf && !nfs && !strcmp(key, "count")) {
+            ret = gf_is_str_int(value);
+            if (!ret)
+                count = atoi(value);
+            if (ret || (count <= 0)) {
+                if (count < 0)
+                    cli_err("count is an invalid number");
+                else
+                    cli_err(
+                        "count should be an integer "
+                        "greater than zero");
+
                 ret = -1;
                 goto out;
+            }
+            ret = dict_set_uint32(dict, "blk-cnt", count);
+        } else {
+            ret = -1;
+            goto out;
         }
+        if (ret) {
+            gf_log("", GF_LOG_WARNING,
+                   "Dict set failed for "
+                   "key %s",
+                   key);
+            goto out;
+        }
+    }
+    if (list_cnt == -1)
+        list_cnt = 100;
+    ret = dict_set_int32(dict, "list-cnt", list_cnt);
+    if (ret) {
+        gf_log("", GF_LOG_WARNING, "Dict set failed for list_cnt");
+        goto out;
+    }
 
-        *options = dict;
+    if ((blk_size > 0) ^ (count > 0)) {
+        cli_err("Need to give both 'bs' and 'count'");
+        ret = -1;
+        goto out;
+    } else if (((uint64_t)blk_size * count) > (10 * GF_UNIT_GB)) {
+        cli_err("'bs * count' value %" PRIu64
+                " is greater than "
+                "maximum allowed value of 10GB",
+                ((uint64_t)blk_size * count));
+        ret = -1;
+        goto out;
+    }
+
+    *options = dict;
 out:
-        if (ret && dict)
-                dict_unref (dict);
-        return ret;
+    if (ret && dict)
+        dict_unref(dict);
+    return ret;
 }
 
 uint32_t
-cli_cmd_get_statusop (const char *arg)
+cli_cmd_get_statusop(const char *arg)
 {
-        int        i         = 0;
-        uint32_t   ret       = GF_CLI_STATUS_NONE;
-        char      *w         = NULL;
-        char      *opwords[] = {"detail", "mem", "clients", "fd",
-                                "inode", "callpool", "tasks", "client-list",
-                                NULL};
-        struct {
-                char      *opname;
-                uint32_t   opcode;
-        } optable[] = {
-                { "detail",   GF_CLI_STATUS_DETAIL   },
-                { "mem",      GF_CLI_STATUS_MEM      },
-                { "clients",  GF_CLI_STATUS_CLIENTS  },
-                { "fd",       GF_CLI_STATUS_FD       },
-                { "inode",    GF_CLI_STATUS_INODE    },
-                { "callpool", GF_CLI_STATUS_CALLPOOL },
-                { "tasks",    GF_CLI_STATUS_TASKS    },
-                { "client-list",  GF_CLI_STATUS_CLIENT_LIST },
-                { NULL }
-        };
-
-        w = str_getunamb (arg, opwords);
-        if (!w) {
-                gf_log ("cli", GF_LOG_DEBUG,
-                        "Not a status op  %s", arg);
-                goto out;
-        }
+    int i = 0;
+    uint32_t ret = GF_CLI_STATUS_NONE;
+    char *w = NULL;
+    char *opwords[] = {"detail",   "mem",   "clients",     "fd", "inode",
+                       "callpool", "tasks", "client-list", NULL};
+    struct {
+        char *opname;
+        uint32_t opcode;
+    } optable[] = {{"detail", GF_CLI_STATUS_DETAIL},
+                   {"mem", GF_CLI_STATUS_MEM},
+                   {"clients", GF_CLI_STATUS_CLIENTS},
+                   {"fd", GF_CLI_STATUS_FD},
+                   {"inode", GF_CLI_STATUS_INODE},
+                   {"callpool", GF_CLI_STATUS_CALLPOOL},
+                   {"tasks", GF_CLI_STATUS_TASKS},
+                   {"client-list", GF_CLI_STATUS_CLIENT_LIST},
+                   {NULL}};
+
+    w = str_getunamb(arg, opwords);
+    if (!w) {
+        gf_log("cli", GF_LOG_DEBUG, "Not a status op  %s", arg);
+        goto out;
+    }
 
-        for (i = 0; optable[i].opname; i++) {
-                if (!strcmp (w, optable[i].opname)) {
-                        ret = optable[i].opcode;
-                        break;
-                }
+    for (i = 0; optable[i].opname; i++) {
+        if (!strcmp(w, optable[i].opname)) {
+            ret = optable[i].opcode;
+            break;
         }
+    }
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 int
-cli_cmd_volume_status_parse (const char **words, int wordcount,
-                             dict_t **options)
+cli_cmd_volume_status_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t    *dict            = NULL;
-        int        ret             = -1;
-        uint32_t   cmd             = 0;
+    dict_t *dict = NULL;
+    int ret = -1;
+    uint32_t cmd = 0;
 
-        GF_ASSERT (options);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        switch (wordcount) {
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
+    switch (wordcount) {
         case 2:
-                cmd = GF_CLI_STATUS_ALL;
-                ret = 0;
-                break;
+            cmd = GF_CLI_STATUS_ALL;
+            ret = 0;
+            break;
 
         case 3:
-                if (!strcmp (words[2], "all")) {
-                        cmd = GF_CLI_STATUS_ALL;
-                        ret = 0;
+            if (!strcmp(words[2], "all")) {
+                cmd = GF_CLI_STATUS_ALL;
+                ret = 0;
 
-                } else {
-                        cmd = GF_CLI_STATUS_VOL;
-                        ret = dict_set_str (dict, "volname", (char *)words[2]);
-                }
+            } else {
+                cmd = GF_CLI_STATUS_VOL;
+                ret = dict_set_str(dict, "volname", (char *)words[2]);
+            }
 
-                break;
+            break;
 
         case 4:
-                cmd = cli_cmd_get_statusop (words[3]);
-
-                if (!strcmp (words[2], "all")) {
-                        if (cmd == GF_CLI_STATUS_NONE) {
-                                cli_err ("%s is not a valid status option",
-                                         words[3]);
-                                ret = -1;
-                                goto out;
-                        }
-                        cmd |= GF_CLI_STATUS_ALL;
-                        ret  = 0;
-
-                } else {
-                        ret = dict_set_str (dict, "volname",
-                                            (char *)words[2]);
-                        if (ret)
-                                goto out;
-
-                        if (cmd == GF_CLI_STATUS_NONE) {
-                                if (!strcmp (words[3], "nfs")) {
-                                        cmd |= GF_CLI_STATUS_NFS;
-                                } else if (!strcmp (words[3], "shd")) {
-                                        cmd |= GF_CLI_STATUS_SHD;
-                                } else if (!strcmp (words[3], "quotad")) {
-                                        cmd |= GF_CLI_STATUS_QUOTAD;
-                                } else if (!strcmp (words[3], "snapd")) {
-                                        cmd |= GF_CLI_STATUS_SNAPD;
-                                } else if (!strcmp (words[3], "tierd")) {
-                                        cmd |= GF_CLI_STATUS_TIERD;
-                                } else if (!strcmp (words[3], "bitd")) {
-                                        cmd |= GF_CLI_STATUS_BITD;
-                                } else if (!strcmp (words[3], "scrub")) {
-                                        cmd |= GF_CLI_STATUS_SCRUB;
-                                } else {
-                                        cmd = GF_CLI_STATUS_BRICK;
-                                        ret = dict_set_str (dict, "brick",
-                                                            (char *)words[3]);
-                                }
-
-                        } else {
-                                cmd |= GF_CLI_STATUS_VOL;
-                                ret  = 0;
-                        }
-                }
-
-                break;
-
-        case 5:
-                if (!strcmp (words[2], "all")) {
-                        cli_err ("Cannot specify brick/nfs for \"all\"");
-                        ret = -1;
-                        goto out;
-                }
+            cmd = cli_cmd_get_statusop(words[3]);
 
-                cmd = cli_cmd_get_statusop (words[4]);
+            if (!strcmp(words[2], "all")) {
                 if (cmd == GF_CLI_STATUS_NONE) {
-                        cli_err ("%s is not a valid status option",
-                                 words[4]);
-                        ret = -1;
-                        goto out;
+                    cli_err("%s is not a valid status option", words[3]);
+                    ret = -1;
+                    goto out;
                 }
+                cmd |= GF_CLI_STATUS_ALL;
+                ret = 0;
 
-
-                ret = dict_set_str (dict, "volname", (char *)words[2]);
+            } else {
+                ret = dict_set_str(dict, "volname", (char *)words[2]);
                 if (ret)
-                        goto out;
+                    goto out;
 
-                if (!strcmp (words[3], "nfs")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Detail/FD/Tasks status not available"
-                                         " for NFS Servers");
-                                ret = -1;
-                                goto out;
-                        }
+                if (cmd == GF_CLI_STATUS_NONE) {
+                    if (!strcmp(words[3], "nfs")) {
                         cmd |= GF_CLI_STATUS_NFS;
-                } else if (!strcmp (words[3], "shd")){
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Detail/FD/Clients/Tasks status not "
-                                         "available for Self-heal Daemons");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "shd")) {
                         cmd |= GF_CLI_STATUS_SHD;
-                } else if (!strcmp (words[3], "quotad")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for Quota Daemon");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "quotad")) {
                         cmd |= GF_CLI_STATUS_QUOTAD;
-                } else if  (!strcmp (words[3], "snapd")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for snap daemon");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "snapd")) {
                         cmd |= GF_CLI_STATUS_SNAPD;
-                } else if  (!strcmp (words[3], "tierd")) {
-                        if (cmd == GF_CLI_STATUS_FD ||
-                            cmd == GF_CLI_STATUS_CLIENTS ||
-                            cmd == GF_CLI_STATUS_DETAIL ||
-                            cmd == GF_CLI_STATUS_INODE) {
-                                cli_err ("Detail/FD/Clients/Inode status not "
-                                         "available for tier daemon");
-                                ret = -1;
-                                goto out;
-                        }
+                    } else if (!strcmp(words[3], "tierd")) {
                         cmd |= GF_CLI_STATUS_TIERD;
+                    } else if (!strcmp(words[3], "bitd")) {
+                        cmd |= GF_CLI_STATUS_BITD;
+                    } else if (!strcmp(words[3], "scrub")) {
+                        cmd |= GF_CLI_STATUS_SCRUB;
+                    } else {
+                        cmd = GF_CLI_STATUS_BRICK;
+                        ret = dict_set_str(dict, "brick", (char *)words[3]);
+                    }
+
                 } else {
-                        if (cmd == GF_CLI_STATUS_TASKS) {
-                                cli_err ("Tasks status not available for "
-                                         "bricks");
-                                ret = -1;
-                                goto out;
-                        }
-                        cmd |= GF_CLI_STATUS_BRICK;
-                        ret = dict_set_str (dict, "brick", (char *)words[3]);
+                    cmd |= GF_CLI_STATUS_VOL;
+                    ret = 0;
                 }
-                break;
+            }
 
-        default:
-                goto out;
-        }
+            break;
 
-        if (ret)
+        case 5:
+            if (!strcmp(words[2], "all")) {
+                cli_err("Cannot specify brick/nfs for \"all\"");
+                ret = -1;
                 goto out;
+            }
 
-        ret = dict_set_int32 (dict, "cmd", cmd);
-        if (ret)
+            cmd = cli_cmd_get_statusop(words[4]);
+            if (cmd == GF_CLI_STATUS_NONE) {
+                cli_err("%s is not a valid status option", words[4]);
+                ret = -1;
                 goto out;
+            }
+
+            ret = dict_set_str(dict, "volname", (char *)words[2]);
+            if (ret)
+                goto out;
+
+            if (!strcmp(words[3], "nfs")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_DETAIL ||
+                    cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Detail/FD/Tasks status not available"
+                        " for NFS Servers");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_NFS;
+            } else if (!strcmp(words[3], "shd")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Detail/FD/Clients/Tasks status not "
+                        "available for Self-heal Daemons");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_SHD;
+            } else if (!strcmp(words[3], "quotad")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_INODE) {
+                    cli_err(
+                        "Detail/FD/Clients/Inode status not "
+                        "available for Quota Daemon");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_QUOTAD;
+            } else if (!strcmp(words[3], "snapd")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_INODE) {
+                    cli_err(
+                        "Detail/FD/Clients/Inode status not "
+                        "available for snap daemon");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_SNAPD;
+            } else if (!strcmp(words[3], "tierd")) {
+                if (cmd == GF_CLI_STATUS_FD || cmd == GF_CLI_STATUS_CLIENTS ||
+                    cmd == GF_CLI_STATUS_DETAIL || cmd == GF_CLI_STATUS_INODE) {
+                    cli_err(
+                        "Detail/FD/Clients/Inode status not "
+                        "available for tier daemon");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_TIERD;
+            } else {
+                if (cmd == GF_CLI_STATUS_TASKS) {
+                    cli_err(
+                        "Tasks status not available for "
+                        "bricks");
+                    ret = -1;
+                    goto out;
+                }
+                cmd |= GF_CLI_STATUS_BRICK;
+                ret = dict_set_str(dict, "brick", (char *)words[3]);
+            }
+            break;
 
-        *options = dict;
+        default:
+            goto out;
+    }
+
+    if (ret)
+        goto out;
+
+    ret = dict_set_int32(dict, "cmd", cmd);
+    if (ret)
+        goto out;
 
- out:
-        if (ret && dict)
-                dict_unref (dict);
+    *options = dict;
 
-        return ret;
+out:
+    if (ret && dict)
+        dict_unref(dict);
+
+    return ret;
 }
 
 gf_boolean_t
-cli_cmd_validate_dumpoption (const char *arg, char **option)
+cli_cmd_validate_dumpoption(const char *arg, char **option)
 {
-        char    *opwords[] = {"all", "nfs", "mem", "iobuf", "callpool", "priv",
-                              "fd", "inode", "history", "inodectx", "fdctx",
-                              "quotad", NULL};
-        char    *w = NULL;
-
-        w = str_getunamb (arg, opwords);
-        if (!w) {
-                gf_log ("cli", GF_LOG_DEBUG, "Unknown statedump option  %s",
-                        arg);
-                return _gf_false;
-        }
-        *option = w;
-        return _gf_true;
+    char *opwords[] = {"all",   "nfs",    "mem",   "iobuf",   "callpool",
+                       "priv",  "fd",     "inode", "history", "inodectx",
+                       "fdctx", "quotad", NULL};
+    char *w = NULL;
+
+    w = str_getunamb(arg, opwords);
+    if (!w) {
+        gf_log("cli", GF_LOG_DEBUG, "Unknown statedump option  %s", arg);
+        return _gf_false;
+    }
+    *option = w;
+    return _gf_true;
 }
 
 int
-cli_cmd_volume_statedump_options_parse (const char **words, int wordcount,
-                                        dict_t **options)
+cli_cmd_volume_statedump_options_parse(const char **words, int wordcount,
+                                       dict_t **options)
 {
-        int     ret = 0;
-        int     i = 0;
-        dict_t  *dict = NULL;
-        int     option_cnt = 0;
-        char    *option = NULL;
-        char    *option_str = NULL;
-        char    *tmp_str = NULL;
-        char    *tmp = NULL;
-        char    *ip_addr = NULL;
-        char    *pid = NULL;
-
-        if ((wordcount >= 5) && ((strcmp (words[3], "client")) == 0)) {
-                tmp = gf_strdup(words[4]);
-                if (!tmp) {
-                        ret = -1;
-                        goto out;
-                }
-                ip_addr = strtok(tmp, ":");
-                pid = strtok(NULL, ":");
-                if (valid_internet_address (ip_addr, _gf_true)
-                   && pid && gf_valid_pid (pid, strlen(pid))) {
-                        ret = gf_asprintf(&option_str, "%s %s %s", words[3],
-                                          ip_addr, pid);
-                        if (ret < 0) {
-                                goto out;
-                        }
-                        option_cnt = 3;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    int ret = 0;
+    int i = 0;
+    dict_t *dict = NULL;
+    int option_cnt = 0;
+    char *option = NULL;
+    char *option_str = NULL;
+    char *tmp_str = NULL;
+    char *tmp = NULL;
+    char *ip_addr = NULL;
+    char *pid = NULL;
+
+    if ((wordcount >= 5) && ((strcmp(words[3], "client")) == 0)) {
+        tmp = gf_strdup(words[4]);
+        if (!tmp) {
+            ret = -1;
+            goto out;
+        }
+        ip_addr = strtok(tmp, ":");
+        pid = strtok(NULL, ":");
+        if (valid_internet_address(ip_addr, _gf_true) && pid &&
+            gf_valid_pid(pid, strlen(pid))) {
+            ret = gf_asprintf(&option_str, "%s %s %s", words[3], ip_addr, pid);
+            if (ret < 0) {
+                goto out;
+            }
+            option_cnt = 3;
         } else {
-                for (i = 3; i < wordcount; i++, option_cnt++) {
-                        if (!cli_cmd_validate_dumpoption (words[i], &option)) {
-                                ret = -1;
-                                goto out;
-                        }
-                        tmp_str = option_str;
-                        option_str = NULL;
-                        ret = gf_asprintf(&option_str, "%s%s ",
-                                          tmp_str ? tmp_str : "", option);
-                        GF_FREE(tmp_str);
-                        if (ret < 0) {
-                                goto out;
-                        }
-                }
-                if (option_str &&
-                    (strstr (option_str, "nfs")) &&
-                     strstr (option_str, "quotad")) {
-                        ret = -1;
-                        goto out;
-                }
+            ret = -1;
+            goto out;
         }
-
-        dict = dict_new ();
-        if (!dict) {
+    } else {
+        for (i = 3; i < wordcount; i++, option_cnt++) {
+            if (!cli_cmd_validate_dumpoption(words[i], &option)) {
                 ret = -1;
                 goto out;
+            }
+            tmp_str = option_str;
+            option_str = NULL;
+            ret = gf_asprintf(&option_str, "%s%s ", tmp_str ? tmp_str : "",
+                              option);
+            GF_FREE(tmp_str);
+            if (ret < 0) {
+                goto out;
+            }
+        }
+        if (option_str && (strstr(option_str, "nfs")) &&
+            strstr(option_str, "quotad")) {
+            ret = -1;
+            goto out;
         }
+    }
 
-        /* dynamic string in dict is freed up when dict is freed up, and hence
-        if option_str is NULL pass in an duplicate empty string to the same */
-        ret = dict_set_dynstr (dict, "options",
-                               (option_str ? option_str : gf_strdup("")));
-        if (ret)
-                goto out;
-        option_str = NULL;
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "option_cnt", option_cnt);
-        if (ret)
-                goto out;
+    /* dynamic string in dict is freed up when dict is freed up, and hence
+    if option_str is NULL pass in an duplicate empty string to the same */
+    ret = dict_set_dynstr(dict, "options",
+                          (option_str ? option_str : gf_strdup("")));
+    if (ret)
+        goto out;
+    option_str = NULL;
 
-        *options = dict;
+    ret = dict_set_int32(dict, "option_cnt", option_cnt);
+    if (ret)
+        goto out;
+
+    *options = dict;
 out:
-        GF_FREE (tmp);
-        GF_FREE (option_str);
-        if (ret && dict)
-                dict_unref (dict);
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "Error parsing dumpoptions");
-        return ret;
+    GF_FREE(tmp);
+    GF_FREE(option_str);
+    if (ret && dict)
+        dict_unref(dict);
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "Error parsing dumpoptions");
+    return ret;
 }
 
 int
-cli_cmd_volume_clrlks_opts_parse (const char **words, int wordcount,
-                                  dict_t **options)
+cli_cmd_volume_clrlks_opts_parse(const char **words, int wordcount,
+                                 dict_t **options)
 {
-        int     ret = -1;
-        int     i = 0;
-        dict_t  *dict = NULL;
-        char    *kind_opts[4] = {"blocked", "granted", "all", NULL};
-        char    *types[4] = {"inode", "entry", "posix", NULL};
-        char    *free_ptr = NULL;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    int ret = -1;
+    int i = 0;
+    dict_t *dict = NULL;
+    char *kind_opts[4] = {"blocked", "granted", "all", NULL};
+    char *types[4] = {"inode", "entry", "posix", NULL};
+    char *free_ptr = NULL;
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp (words[4], "kind"))
-                goto out;
+    if (strcmp(words[4], "kind"))
+        goto out;
 
-        for (i = 0; kind_opts[i]; i++) {
-               if (!strcmp (words[5], kind_opts[i])) {
-                       free_ptr = gf_strdup (words[5]);
-                       ret = dict_set_dynstr (dict, "kind", free_ptr);
-                       if (ret)
-                               goto out;
-                       free_ptr = NULL;
-                       break;
-               }
-        }
-        if (i == 3)
+    for (i = 0; kind_opts[i]; i++) {
+        if (!strcmp(words[5], kind_opts[i])) {
+            free_ptr = gf_strdup(words[5]);
+            ret = dict_set_dynstr(dict, "kind", free_ptr);
+            if (ret)
                 goto out;
+            free_ptr = NULL;
+            break;
+        }
+    }
+    if (i == 3)
+        goto out;
 
-        ret = -1;
-        for (i = 0; types[i]; i++) {
-               if (!strcmp (words[6], types[i])) {
-                       free_ptr = gf_strdup (words[6]);
-                       ret = dict_set_dynstr (dict, "type", free_ptr);
-                       if (ret)
-                               goto out;
-                       free_ptr = NULL;
-                       break;
-               }
-        }
-        if (i == 3)
+    ret = -1;
+    for (i = 0; types[i]; i++) {
+        if (!strcmp(words[6], types[i])) {
+            free_ptr = gf_strdup(words[6]);
+            ret = dict_set_dynstr(dict, "type", free_ptr);
+            if (ret)
                 goto out;
-
-        if (wordcount == 8) {
-                free_ptr = gf_strdup (words[7]);
-                ret = dict_set_dynstr (dict, "opts", free_ptr);
-                if (ret)
-                        goto out;
-                free_ptr = NULL;
+            free_ptr = NULL;
+            break;
         }
+    }
+    if (i == 3)
+        goto out;
 
-        ret = 0;
-        *options = dict;
+    if (wordcount == 8) {
+        free_ptr = gf_strdup(words[7]);
+        ret = dict_set_dynstr(dict, "opts", free_ptr);
+        if (ret)
+            goto out;
+        free_ptr = NULL;
+    }
+
+    ret = 0;
+    *options = dict;
 out:
-       if (ret) {
-               GF_FREE (free_ptr);
-               dict_unref (dict);
-       }
+    if (ret) {
+        GF_FREE(free_ptr);
+        dict_unref(dict);
+    }
 
-       return ret;
+    return ret;
 }
 
 static int
-extract_hostname_path_from_token (const char *tmp_words, char **hostname,
-                                  char **path)
+extract_hostname_path_from_token(const char *tmp_words, char **hostname,
+                                 char **path)
 {
-        int ret = 0;
-        char *delimiter = NULL;
-        char *tmp_host = NULL;
-        char *host_name = NULL;
-        char *words = NULL;
-        int str_len = 0;
-        *hostname = NULL;
-        *path = NULL;
-
-        str_len = strlen (tmp_words) + 1;
-        words = GF_MALLOC (str_len, gf_common_mt_char);
-        if (!words){
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    char *delimiter = NULL;
+    char *tmp_host = NULL;
+    char *host_name = NULL;
+    char *words = NULL;
+    int str_len = 0;
+    *hostname = NULL;
+    *path = NULL;
+
+    str_len = strlen(tmp_words) + 1;
+    words = GF_MALLOC(str_len, gf_common_mt_char);
+    if (!words) {
+        ret = -1;
+        goto out;
+    }
 
-        snprintf (words, str_len, "%s", tmp_words);
+    snprintf(words, str_len, "%s", tmp_words);
 
-        if (validate_brick_name (words)) {
-                cli_err ("Wrong brick type: %s, use <HOSTNAME>:"
-                        "<export-dir-abs-path>", words);
-                ret = -1;
-                goto out;
+    if (validate_brick_name(words)) {
+        cli_err(
+            "Wrong brick type: %s, use <HOSTNAME>:"
+            "<export-dir-abs-path>",
+            words);
+        ret = -1;
+        goto out;
+    } else {
+        delimiter = strrchr(words, ':');
+        ret = gf_canonicalize_path(delimiter + 1);
+        if (ret) {
+            goto out;
         } else {
-                delimiter = strrchr (words, ':');
-                ret = gf_canonicalize_path (delimiter + 1);
-                if (ret) {
-                        goto out;
-                } else {
-                        str_len = strlen (delimiter + 1) + 1;
-                        *path = GF_MALLOC (str_len,
-                                           gf_common_mt_char);
-                        if (!*path) {
-                           ret = -1;
-                                goto out;
-
-                        }
-                        snprintf (*path, str_len, "%s", delimiter +1);
-                }
-        }
-
-        tmp_host = gf_strdup (words);
-        if (!tmp_host) {
-                gf_log ("cli", GF_LOG_ERROR, "Out of memory");
-                ret = -1;
-                goto out;
-        }
-        get_host_name (tmp_host, &host_name);
-        if (!host_name) {
-                ret = -1;
-                gf_log("cli",GF_LOG_ERROR, "Unable to allocate "
-                        "memory");
-                goto out;
-        }
-        if (!(strcmp (host_name, "localhost") &&
-            strcmp (host_name, "127.0.0.1") &&
-            strncmp (host_name, "0.", 2))) {
-                cli_err ("Please provide a valid hostname/ip other "
-                         "than localhost, 127.0.0.1 or loopback "
-                         "address (0.0.0.0 to 0.255.255.255).");
-                ret = -1;
-                goto out;
-        }
-        if (!valid_internet_address (host_name, _gf_false)) {
-                cli_err ("internet address '%s' does not conform to "
-                          "standards", host_name);
+            str_len = strlen(delimiter + 1) + 1;
+            *path = GF_MALLOC(str_len, gf_common_mt_char);
+            if (!*path) {
                 ret = -1;
                 goto out;
+            }
+            snprintf(*path, str_len, "%s", delimiter + 1);
         }
+    }
 
-        str_len = strlen (host_name) + 1;
-        *hostname = GF_MALLOC (str_len, gf_common_mt_char);
-        if (!*hostname) {
-                ret = -1;
-                goto out;
-        }
-        snprintf (*hostname, str_len, "%s", host_name);
-        ret = 0;
+    tmp_host = gf_strdup(words);
+    if (!tmp_host) {
+        gf_log("cli", GF_LOG_ERROR, "Out of memory");
+        ret = -1;
+        goto out;
+    }
+    get_host_name(tmp_host, &host_name);
+    if (!host_name) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to allocate "
+               "memory");
+        goto out;
+    }
+    if (!(strcmp(host_name, "localhost") && strcmp(host_name, "127.0.0.1") &&
+          strncmp(host_name, "0.", 2))) {
+        cli_err(
+            "Please provide a valid hostname/ip other "
+            "than localhost, 127.0.0.1 or loopback "
+            "address (0.0.0.0 to 0.255.255.255).");
+        ret = -1;
+        goto out;
+    }
+    if (!valid_internet_address(host_name, _gf_false)) {
+        cli_err(
+            "internet address '%s' does not conform to "
+            "standards",
+            host_name);
+        ret = -1;
+        goto out;
+    }
+
+    str_len = strlen(host_name) + 1;
+    *hostname = GF_MALLOC(str_len, gf_common_mt_char);
+    if (!*hostname) {
+        ret = -1;
+        goto out;
+    }
+    snprintf(*hostname, str_len, "%s", host_name);
+    ret = 0;
 
 out:
-        GF_FREE (words);
-        GF_FREE (tmp_host);
-        return ret;
+    GF_FREE(words);
+    GF_FREE(tmp_host);
+    return ret;
 }
 
 static int
-set_hostname_path_in_dict (const char *token, dict_t *dict, int heal_op)
+set_hostname_path_in_dict(const char *token, dict_t *dict, int heal_op)
 {
-        char *hostname = NULL;
-        char *path     = NULL;
-        int   ret      = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int ret = 0;
 
-        ret = extract_hostname_path_from_token (token, &hostname, &path);
-        if (ret)
-                goto out;
+    ret = extract_hostname_path_from_token(token, &hostname, &path);
+    if (ret)
+        goto out;
 
-        switch (heal_op) {
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_set_dynstr (dict, "heal-source-hostname",
-                                       hostname);
-                if (ret)
-                        goto out;
-                hostname = NULL;
-                ret = dict_set_dynstr (dict, "heal-source-brickpath",
-                                       path);
-                if (ret) {
-                        goto out;
-                }
-                path = NULL;
-                break;
+            ret = dict_set_dynstr(dict, "heal-source-hostname", hostname);
+            if (ret)
+                goto out;
+            hostname = NULL;
+            ret = dict_set_dynstr(dict, "heal-source-brickpath", path);
+            if (ret) {
+                goto out;
+            }
+            path = NULL;
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                ret = dict_set_dynstr (dict, "per-replica-cmd-hostname",
-                                       hostname);
-                if (ret)
-                        goto out;
-                hostname = NULL;
-                ret = dict_set_dynstr (dict, "per-replica-cmd-path",
-                                       path);
-                if (ret) {
-                        goto out;
-                }
-                path = NULL;
-                break;
+            ret = dict_set_dynstr(dict, "per-replica-cmd-hostname", hostname);
+            if (ret)
+                goto out;
+            hostname = NULL;
+            ret = dict_set_dynstr(dict, "per-replica-cmd-path", path);
+            if (ret) {
+                goto out;
+            }
+            path = NULL;
+            break;
         default:
-                ret = -1;
-                break;
-        }
+            ret = -1;
+            break;
+    }
 
 out:
-        GF_FREE(hostname);
-        GF_FREE(path);
-        return ret;
+    GF_FREE(hostname);
+    GF_FREE(path);
+    return ret;
 }
 
 static int
-heal_command_type_get (const char *command)
+heal_command_type_get(const char *command)
 {
-        int     i = 0;
-        /* subcommands are set as NULL */
-        char    *heal_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
-                [GF_SHD_OP_INVALID]                            = NULL,
-                [GF_SHD_OP_HEAL_INDEX]                         = NULL,
-                [GF_SHD_OP_HEAL_FULL]                          = "full",
-                [GF_SHD_OP_INDEX_SUMMARY]                      = "info",
-                [GF_SHD_OP_HEALED_FILES]                       = NULL,
-                [GF_SHD_OP_HEAL_FAILED_FILES]                  = NULL,
-                [GF_SHD_OP_SPLIT_BRAIN_FILES]                  = NULL,
-                [GF_SHD_OP_STATISTICS]                         = "statistics",
-                [GF_SHD_OP_STATISTICS_HEAL_COUNT]              = NULL,
-                [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA]  = NULL,
-                [GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE]       = NULL,
-                [GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK]             = NULL,
-                [GF_SHD_OP_HEAL_ENABLE]                        = "enable",
-                [GF_SHD_OP_HEAL_DISABLE]                       = "disable",
-        };
-
-        for (i = 0; i <= GF_SHD_OP_HEAL_DISABLE; i++) {
-                if (heal_cmds[i] && (strcmp (heal_cmds[i], command) == 0))
-                        return i;
-        }
-
-        return GF_SHD_OP_INVALID;
+    int i = 0;
+    /* subcommands are set as NULL */
+    char *heal_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
+        [GF_SHD_OP_INVALID] = NULL,
+        [GF_SHD_OP_HEAL_INDEX] = NULL,
+        [GF_SHD_OP_HEAL_FULL] = "full",
+        [GF_SHD_OP_INDEX_SUMMARY] = "info",
+        [GF_SHD_OP_HEALED_FILES] = NULL,
+        [GF_SHD_OP_HEAL_FAILED_FILES] = NULL,
+        [GF_SHD_OP_SPLIT_BRAIN_FILES] = NULL,
+        [GF_SHD_OP_STATISTICS] = "statistics",
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT] = NULL,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = NULL,
+        [GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE] = NULL,
+        [GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK] = NULL,
+        [GF_SHD_OP_HEAL_ENABLE] = "enable",
+        [GF_SHD_OP_HEAL_DISABLE] = "disable",
+    };
+
+    for (i = 0; i <= GF_SHD_OP_HEAL_DISABLE; i++) {
+        if (heal_cmds[i] && (strcmp(heal_cmds[i], command) == 0))
+            return i;
+    }
+
+    return GF_SHD_OP_INVALID;
 }
 
 int
-cli_cmd_volume_heal_options_parse (const char **words, int wordcount,
-                                   dict_t **options)
+cli_cmd_volume_heal_options_parse(const char **words, int wordcount,
+                                  dict_t **options)
 {
-        int     ret = 0;
-        dict_t  *dict = NULL;
-        gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        ret = dict_set_str (dict, "volname", (char *) words[2]);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set volname");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set volname");
+        goto out;
+    }
 
-        if (wordcount == 3) {
-                ret = dict_set_int32 (dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
-                goto done;
+    if (wordcount == 3) {
+        ret = dict_set_int32(dict, "heal-op", GF_SHD_OP_HEAL_INDEX);
+        goto done;
+    }
+
+    if (wordcount == 4) {
+        op = heal_command_type_get(words[3]);
+        if (op == GF_SHD_OP_INVALID) {
+            ret = -1;
+            goto out;
         }
 
-        if (wordcount == 4) {
-                op = heal_command_type_get (words[3]);
-                if (op == GF_SHD_OP_INVALID) {
-                        ret = -1;
-                        goto out;
-                }
+        ret = dict_set_int32(dict, "heal-op", op);
+        goto done;
+    }
 
-                ret = dict_set_int32 (dict, "heal-op", op);
-                goto done;
+    if (wordcount == 5) {
+        if (strcmp(words[3], "info") && strcmp(words[3], "statistics") &&
+            strcmp(words[3], "granular-entry-heal")) {
+            ret = -1;
+            goto out;
         }
 
-        if (wordcount == 5) {
-                if (strcmp (words[3], "info") &&
-                    strcmp (words[3], "statistics") &&
-                    strcmp (words[3], "granular-entry-heal")) {
-                        ret = -1;
-                        goto out;
-                }
-
-                if (!strcmp (words[3], "info")) {
-                        if (!strcmp (words[4], "split-brain")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                                   GF_SHD_OP_SPLIT_BRAIN_FILES);
-                                goto done;
-                        }
-                        if (!strcmp (words[4], "summary")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                                   GF_SHD_OP_HEAL_SUMMARY);
-                                goto done;
-                        }
-                }
+        if (!strcmp(words[3], "info")) {
+            if (!strcmp(words[4], "split-brain")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_SPLIT_BRAIN_FILES);
+                goto done;
+            }
+            if (!strcmp(words[4], "summary")) {
+                ret = dict_set_int32(dict, "heal-op", GF_SHD_OP_HEAL_SUMMARY);
+                goto done;
+            }
+        }
 
-                if (!strcmp (words[3], "statistics")) {
-                        if (!strcmp (words[4], "heal-count")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                               GF_SHD_OP_STATISTICS_HEAL_COUNT);
-                                goto done;
-                        }
-                }
+        if (!strcmp(words[3], "statistics")) {
+            if (!strcmp(words[4], "heal-count")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_STATISTICS_HEAL_COUNT);
+                goto done;
+            }
+        }
 
-                if (!strcmp (words[3], "granular-entry-heal")) {
-                        if (!strcmp (words[4], "enable")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                          GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE);
-                                goto done;
-                        } else if (!strcmp (words[4], "disable")) {
-                                ret = dict_set_int32 (dict, "heal-op",
-                                         GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE);
-                                goto done;
-                        }
-                }
+        if (!strcmp(words[3], "granular-entry-heal")) {
+            if (!strcmp(words[4], "enable")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE);
+                goto done;
+            } else if (!strcmp(words[4], "disable")) {
+                ret = dict_set_int32(dict, "heal-op",
+                                     GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE);
+                goto done;
+            }
+        }
 
-                ret = -1;
+        ret = -1;
+        goto out;
+    }
+    if (wordcount == 6) {
+        if (strcmp(words[3], "split-brain")) {
+            ret = -1;
+            goto out;
+        }
+        if (!strcmp(words[4], "bigger-file")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE);
+            if (ret)
                 goto out;
+            ret = dict_set_str(dict, "file", (char *)words[5]);
+            if (ret)
+                goto out;
+            goto done;
         }
-        if (wordcount == 6) {
-                if (strcmp (words[3], "split-brain")) {
-                        ret = -1;
-                        goto out;
-                }
-                if (!strcmp (words[4], "bigger-file")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                        GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file", (char *)words[5]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                if (!strcmp (words[4], "latest-mtime")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                       GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file", (char *)words[5]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                if (!strcmp (words[4], "source-brick")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        ret = set_hostname_path_in_dict (words[5], dict,
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
-                ret = -1;
+        if (!strcmp(words[4], "latest-mtime")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME);
+            if (ret)
                 goto out;
+            ret = dict_set_str(dict, "file", (char *)words[5]);
+            if (ret)
+                goto out;
+            goto done;
         }
-        if (wordcount == 7) {
-                if (!strcmp (words[3], "statistics")
-                    && !strcmp (words[4], "heal-count")
-                    && !strcmp (words[5], "replica")) {
-
-                        ret = dict_set_int32 (dict, "heal-op",
-                                   GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
-                        if (ret)
-                                goto out;
-                        ret = set_hostname_path_in_dict (words[6], dict,
-                                   GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
-                        if (ret)
-                                goto out;
-                        goto done;
-
-                }
-                if (!strcmp (words[3], "split-brain") &&
-                    !strcmp (words[4], "source-brick")) {
-                        ret = dict_set_int32 (dict, "heal-op",
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        ret = set_hostname_path_in_dict (words[5], dict,
-                                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-                        if (ret)
-                                goto out;
-                        ret = dict_set_str (dict, "file",
-                                            (char *) words[6]);
-                        if (ret)
-                                goto out;
-                        goto done;
-                }
+        if (!strcmp(words[4], "source-brick")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
+                goto out;
+            ret = set_hostname_path_in_dict(words[5], dict,
+                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
+                goto out;
+            goto done;
         }
         ret = -1;
         goto out;
+    }
+    if (wordcount == 7) {
+        if (!strcmp(words[3], "statistics") &&
+            !strcmp(words[4], "heal-count") && !strcmp(words[5], "replica")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
+            if (ret)
+                goto out;
+            ret = set_hostname_path_in_dict(
+                words[6], dict, GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA);
+            if (ret)
+                goto out;
+            goto done;
+        }
+        if (!strcmp(words[3], "split-brain") &&
+            !strcmp(words[4], "source-brick")) {
+            ret = dict_set_int32(dict, "heal-op",
+                                 GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            ret = set_hostname_path_in_dict(words[5], dict,
+                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+            if (ret)
+                goto out;
+            ret = dict_set_str(dict, "file", (char *)words[6]);
+            if (ret)
+                goto out;
+            goto done;
+        }
+    }
+    ret = -1;
+    goto out;
 done:
-        *options = dict;
+    *options = dict;
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-                *options = NULL;
-        }
+    if (ret && dict) {
+        dict_unref(dict);
+        *options = NULL;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_old_tier_parse (const char **words, int wordcount,
-                             dict_t **options)
+cli_cmd_volume_old_tier_parse(const char **words, int wordcount,
+                              dict_t **options)
 {
-        dict_t                 *dict = NULL;
-        int                      ret = -1;
-        char                *volname = NULL;
-        gf_cli_defrag_type       cmd = 0;
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *volname = NULL;
+    gf_cli_defrag_type cmd = 0;
 
-        GF_ASSERT (words);
-        GF_ASSERT (options);
+    GF_ASSERT(words);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount != 4)
-                goto out;
+    if (wordcount != 4)
+        goto out;
 
-        if ((strcmp (words[1], "tier") == 0) &&
-            (strcmp (words[3], "start") == 0)) {
-                cmd = GF_DEFRAG_CMD_START_TIER;
-        } else
-                goto out;
+    if ((strcmp(words[1], "tier") == 0) && (strcmp(words[3], "start") == 0)) {
+        cmd = GF_DEFRAG_CMD_START_TIER;
+    } else
+        goto out;
 
-        volname = (char *) words[2];
+    volname = (char *)words[2];
 
-        ret = dict_set_str (dict, "volname", volname);
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
+    ret = dict_set_int32(dict, "rebalance-command", (int32_t)cmd);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_defrag_parse (const char **words, int wordcount,
-                             dict_t **options)
+cli_cmd_volume_defrag_parse(const char **words, int wordcount, dict_t **options)
 {
-        dict_t                 *dict = NULL;
-        int                      ret = -1;
-        char                *option  = NULL;
-        char                *volname = NULL;
-        char                *command = NULL;
-        gf_cli_defrag_type       cmd = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        if (!((wordcount == 4) || (wordcount == 5)))
-                goto out;
-
-        if (wordcount == 4) {
-                if (strcmp (words[3], "start") && strcmp (words[3], "stop") &&
-                    strcmp (words[3], "status"))
-                            goto out;
-        } else {
-                if (strcmp (words[3], "fix-layout") &&
-                    strcmp (words[3], "start"))
-                        goto out;
-        }
-
-        volname = (char *) words[2];
-
-        if (wordcount == 4) {
-                command = (char *) words[3];
-        }
-        if (wordcount == 5) {
-               if ((strcmp (words[3], "fix-layout") ||
-                    strcmp (words[4], "start")) &&
-                    (strcmp (words[3], "start") ||
-                    strcmp (words[4], "force"))) {
-                        ret = -1;
-                        goto out;
-                }
-                command = (char *) words[3];
-                option = (char *) words[4];
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
+    char *option = NULL;
+    char *volname = NULL;
+    char *command = NULL;
+    gf_cli_defrag_type cmd = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (strcmp (command, "start") == 0) {
-                cmd = GF_DEFRAG_CMD_START;
-                if (option && strcmp (option, "force") == 0) {
-                                cmd = GF_DEFRAG_CMD_START_FORCE;
-                        }
-                goto done;
-        }
+    if (!((wordcount == 4) || (wordcount == 5)))
+        goto out;
 
-        if (strcmp (command, "fix-layout") == 0) {
-                cmd = GF_DEFRAG_CMD_START_LAYOUT_FIX;
-                goto done;
-        }
-        if (strcmp (command, "stop") == 0) {
-                cmd = GF_DEFRAG_CMD_STOP;
-                goto done;
-        }
-        if (strcmp (command, "status") == 0) {
-                cmd = GF_DEFRAG_CMD_STATUS;
-        }
+    if (wordcount == 4) {
+        if (strcmp(words[3], "start") && strcmp(words[3], "stop") &&
+            strcmp(words[3], "status"))
+            goto out;
+    } else {
+        if (strcmp(words[3], "fix-layout") && strcmp(words[3], "start"))
+            goto out;
+    }
+
+    volname = (char *)words[2];
+
+    if (wordcount == 4) {
+        command = (char *)words[3];
+    }
+    if (wordcount == 5) {
+        if ((strcmp(words[3], "fix-layout") || strcmp(words[4], "start")) &&
+            (strcmp(words[3], "start") || strcmp(words[4], "force"))) {
+            ret = -1;
+            goto out;
+        }
+        command = (char *)words[3];
+        option = (char *)words[4];
+    }
+
+    if (strcmp(command, "start") == 0) {
+        cmd = GF_DEFRAG_CMD_START;
+        if (option && strcmp(option, "force") == 0) {
+            cmd = GF_DEFRAG_CMD_START_FORCE;
+        }
+        goto done;
+    }
+
+    if (strcmp(command, "fix-layout") == 0) {
+        cmd = GF_DEFRAG_CMD_START_LAYOUT_FIX;
+        goto done;
+    }
+    if (strcmp(command, "stop") == 0) {
+        cmd = GF_DEFRAG_CMD_STOP;
+        goto done;
+    }
+    if (strcmp(command, "status") == 0) {
+        cmd = GF_DEFRAG_CMD_STATUS;
+    }
 
 done:
-        ret = dict_set_str (dict, "volname", volname);
+    ret = dict_set_str(dict, "volname", volname);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
+    ret = dict_set_int32(dict, "rebalance-command", (int32_t)cmd);
 
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set dict");
-                goto out;
-        }
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set dict");
+        goto out;
+    }
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_snap_create_desc_parse (dict_t *dict, const char **words,
-                            size_t wordcount, int32_t desc_opt_loc)
+cli_snap_create_desc_parse(dict_t *dict, const char **words, size_t wordcount,
+                           int32_t desc_opt_loc)
 {
-        int32_t        ret      = -1;
-        char          *desc     = NULL;
-        int32_t        desc_len = 0;
-        int            len;
-
-        desc = GF_MALLOC (MAX_SNAP_DESCRIPTION_LEN + 1,
-                          gf_common_mt_char);
-        if (!desc) {
-                ret = -1;
-                goto out;
-        }
-
-
-        len = strlen (words[desc_opt_loc]);
-        if (len >= MAX_SNAP_DESCRIPTION_LEN) {
-                cli_out ("snapshot create: description truncated: "
-                         "Description provided is longer than 1024 characters");
-                desc_len = MAX_SNAP_DESCRIPTION_LEN;
-        } else {
-                desc_len = len;
-        }
+    int32_t ret = -1;
+    char *desc = NULL;
+    int32_t desc_len = 0;
+    int len;
 
-        snprintf (desc, desc_len + 1, "%s", words[desc_opt_loc]);
-        /* Calculating the size of the description as given by the user */
-
-        ret = dict_set_dynstr (dict, "description", desc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap "
-                        "description");
-                goto out;
-        }
+    desc = GF_MALLOC(MAX_SNAP_DESCRIPTION_LEN + 1, gf_common_mt_char);
+    if (!desc) {
+        ret = -1;
+        goto out;
+    }
+
+    len = strlen(words[desc_opt_loc]);
+    if (len >= MAX_SNAP_DESCRIPTION_LEN) {
+        cli_out(
+            "snapshot create: description truncated: "
+            "Description provided is longer than 1024 characters");
+        desc_len = MAX_SNAP_DESCRIPTION_LEN;
+    } else {
+        desc_len = len;
+    }
+
+    snprintf(desc, desc_len + 1, "%s", words[desc_opt_loc]);
+    /* Calculating the size of the description as given by the user */
+
+    ret = dict_set_dynstr(dict, "description", desc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to save snap "
+               "description");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && desc)
-                GF_FREE (desc);
+    if (ret && desc)
+        GF_FREE(desc);
 
-        return ret;
+    return ret;
 }
 
 /* Function to check whether the Volume name is repeated */
 int
-cli_check_if_volname_repeated (const char **words, unsigned int start_index,
-                           uint64_t cur_index) {
-        uint64_t        i       =       -1;
-        int             ret     =        0;
+cli_check_if_volname_repeated(const char **words, unsigned int start_index,
+                              uint64_t cur_index)
+{
+    uint64_t i = -1;
+    int ret = 0;
 
-        GF_ASSERT (words);
+    GF_ASSERT(words);
 
-        for (i = start_index ; i < cur_index ; i++) {
-                if (strcmp (words[i], words[cur_index]) == 0) {
-                        ret = -1;
-                        goto out;
-                }
+    for (i = start_index; i < cur_index; i++) {
+        if (strcmp(words[i], words[cur_index]) == 0) {
+            ret = -1;
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot clone <clonename> <snapname>
@@ -4289,72 +4321,77 @@ out:
  *                 0 on success
  */
 int
-cli_snap_clone_parse (dict_t *dict, const char **words, int wordcount) {
-        uint64_t        i               =       0;
-        int             ret             =       -1;
-        char            *clonename      =       NULL;
-        unsigned int    cmdi            =       2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot clone)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount == cmdi + 1) {
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Invalid number of  words for snap clone command");
-                goto out;
-        }
-
-        if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
-                cli_err ("snapshot clone: failed: clonename cannot exceed "
-                         "255 characters.");
-                gf_log ("cli", GF_LOG_ERROR, "Clone name too long");
-
-                goto out;
-        }
-
-        clonename = (char *) words[cmdi];
-        for (i = 0 ; i < strlen (clonename); i++) {
-                /* Following volume name convention */
-                if (!isalnum (clonename[i]) && (clonename[i] != '_'
-                                           && (clonename[i] != '-'))) {
-                        /* TODO : Is this message enough?? */
-                        cli_err ("Clonename can contain only alphanumeric, "
-                                 "\"-\" and \"_\" characters");
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (dict, "volcount", 1);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save volcount");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "clonename", (char *)words[cmdi]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save clone "
-                        "name(%s)", (char *)words[cmdi]);
-                goto out;
-        }
+cli_snap_clone_parse(dict_t *dict, const char **words, int wordcount)
+{
+    uint64_t i = 0;
+    int ret = -1;
+    char *clonename = NULL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot clone)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if (wordcount == cmdi + 1) {
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR,
+               "Invalid number of  words for snap clone command");
+        goto out;
+    }
 
-        /* Filling snap name in the dictionary */
-        ret = dict_set_str (dict, "snapname", (char *)words[cmdi+1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not "
-                        "save snap name(%s)", (char *)words[cmdi+1]);
-                goto out;
-        }
+    if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
+        cli_err(
+            "snapshot clone: failed: clonename cannot exceed "
+            "255 characters.");
+        gf_log("cli", GF_LOG_ERROR, "Clone name too long");
 
+        goto out;
+    }
+
+    clonename = (char *)words[cmdi];
+    for (i = 0; i < strlen(clonename); i++) {
+        /* Following volume name convention */
+        if (!isalnum(clonename[i]) &&
+            (clonename[i] != '_' && (clonename[i] != '-'))) {
+            /* TODO : Is this message enough?? */
+            cli_err(
+                "Clonename can contain only alphanumeric, "
+                "\"-\" and \"_\" characters");
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "volcount", 1);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save volcount");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "clonename", (char *)words[cmdi]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save clone "
+               "name(%s)",
+               (char *)words[cmdi]);
+        goto out;
+    }
+
+    /* Filling snap name in the dictionary */
+    ret = dict_set_str(dict, "snapname", (char *)words[cmdi + 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not "
+               "save snap name(%s)",
+               (char *)words[cmdi + 1]);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* snapshot create <snapname> <vol-name(s)> [description <description>]
  *                                           [force]
  * @arg-0, dict     : Request Dictionary to be sent to server side.
@@ -4365,172 +4402,181 @@ out:
  *                 0 on success
  */
 int
-cli_snap_create_parse (dict_t *dict, const char **words, int wordcount) {
-        uint64_t        i               =       0;
-        int             ret             =       -1;
-        uint64_t        volcount        =       0;
-        char            key[PATH_MAX]   =       "";
-        char            *snapname       =       NULL;
-        unsigned int    cmdi            =       2;
-        int             flags           =       0;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot create)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount <= cmdi + 1) {
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Too less words for snap create command");
-                goto out;
-        }
+cli_snap_create_parse(dict_t *dict, const char **words, int wordcount)
+{
+    uint64_t i = 0;
+    int ret = -1;
+    uint64_t volcount = 0;
+    char key[PATH_MAX] = "";
+    char *snapname = NULL;
+    unsigned int cmdi = 2;
+    int flags = 0;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot create)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if (wordcount <= cmdi + 1) {
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR, "Too less words for snap create command");
+        goto out;
+    }
 
-        if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
-                cli_err ("snapshot create: failed: snapname cannot exceed "
-                         "255 characters.");
-                gf_log ("cli", GF_LOG_ERROR, "Snapname too long");
+    if (strlen(words[cmdi]) >= GLUSTERD_MAX_SNAP_NAME) {
+        cli_err(
+            "snapshot create: failed: snapname cannot exceed "
+            "255 characters.");
+        gf_log("cli", GF_LOG_ERROR, "Snapname too long");
 
-                goto out;
+        goto out;
+    }
+
+    snapname = (char *)words[cmdi];
+    for (i = 0; i < strlen(snapname); i++) {
+        /* Following volume name convention */
+        if (!isalnum(snapname[i]) &&
+            (snapname[i] != '_' && (snapname[i] != '-'))) {
+            /* TODO : Is this message enough?? */
+            cli_err(
+                "Snapname can contain only alphanumeric, "
+                "\"-\" and \"_\" characters");
+            goto out;
+        }
+    }
+
+    ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save snap "
+               "name(%s)",
+               (char *)words[cmdi]);
+        goto out;
+    }
+
+    /* Filling volume name in the dictionary */
+    for (i = cmdi + 1;
+         i < wordcount && (strcmp(words[i], "description")) != 0 &&
+         (strcmp(words[i], "force") != 0) &&
+         (strcmp(words[i], "no-timestamp") != 0);
+         i++) {
+        volcount++;
+        /* volume index starts from 1 */
+        ret = snprintf(key, sizeof(key), "volname%" PRIu64, volcount);
+        if (ret < 0) {
+            goto out;
         }
 
-        snapname = (char *) words[cmdi];
-        for (i = 0 ; i < strlen (snapname); i++) {
-                /* Following volume name convention */
-                if (!isalnum (snapname[i]) && (snapname[i] != '_'
-                                           && (snapname[i] != '-'))) {
-                        /* TODO : Is this message enough?? */
-                        cli_err ("Snapname can contain only alphanumeric, "
-                                 "\"-\" and \"_\" characters");
-                        goto out;
-                }
+        ret = dict_set_str(dict, key, (char *)words[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not "
+                   "save volume name(%s)",
+                   (char *)words[i]);
+            goto out;
         }
 
-        ret = dict_set_str (dict, "snapname", (char *)words[cmdi]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save snap "
-                        "name(%s)", (char *)words[cmdi]);
-                goto out;
+        if (i >= cmdi + 2) {
+            ret = -1;
+            cli_err(
+                "Creating multiple volume snapshot is not "
+                "supported as of now");
+            goto out;
         }
+        /* TODO : remove this above condition check once
+         * multiple volume snapshot is supported */
+    }
 
-        /* Filling volume name in the dictionary */
-        for (i = cmdi + 1 ; i < wordcount
-                            && (strcmp (words[i], "description")) != 0
-                            && (strcmp (words[i], "force") != 0)
-                            && (strcmp (words[i], "no-timestamp") != 0);
-                            i++) {
-                volcount++;
-                /* volume index starts from 1 */
-                ret = snprintf (key, sizeof (key), "volname%"PRIu64, volcount);
-                if (ret < 0) {
-                        goto out;
-                }
+    if (volcount == 0) {
+        ret = -1;
+        cli_err("Please provide the volume name");
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-                ret = dict_set_str (dict, key, (char *)words[i]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                "save volume name(%s)", (char *)words[i]);
-                        goto out;
-                }
+    ret = dict_set_int32(dict, "volcount", volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save volcount");
+        goto out;
+    }
+
+    /* Verify how we got out of "for" loop,
+     * if it is by reaching wordcount limit then goto "out",
+     * because we need not parse for "description","force" and
+     * "no-timestamp" after this.
+     */
+    if (i == wordcount) {
+        goto out;
+    }
 
-                if (i >= cmdi + 2) {
-                        ret = -1;
-                        cli_err("Creating multiple volume snapshot is not "
-                                "supported as of now");
-                        goto out;
-                }
-                /* TODO : remove this above condition check once
-                 * multiple volume snapshot is supported */
+    if (strcmp(words[i], "no-timestamp") == 0) {
+        ret = dict_set_str(dict, "no-timestamp", "true");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "time-stamp option");
         }
+        if (i == (wordcount - 1))
+            goto out;
+        i++;
+    }
 
-        if (volcount == 0) {
-                ret = -1;
-                cli_err ("Please provide the volume name");
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+    if ((strcmp(words[i], "description")) == 0) {
+        ++i;
+        if (i > (wordcount - 1)) {
+            ret = -1;
+            cli_err("Please provide a description");
+            gf_log("cli", GF_LOG_ERROR, "Description not provided");
+            goto out;
         }
 
-        ret = dict_set_int32 (dict, "volcount", volcount);
+        ret = cli_snap_create_desc_parse(dict, words, wordcount, i);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save volcount");
-                goto out;
-        }
-
-        /* Verify how we got out of "for" loop,
-         * if it is by reaching wordcount limit then goto "out",
-         * because we need not parse for "description","force" and
-         * "no-timestamp" after this.
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save snap "
+                   "description");
+            goto out;
+        }
+
+        if (i == (wordcount - 1))
+            goto out;
+        i++;
+        /* point the index to next word.
+         * As description might be follwed by force option.
+         * Before that, check if wordcount limit is reached
          */
-        if (i == wordcount) {
-                goto out;
-        }
-
-        if (strcmp (words[i], "no-timestamp") == 0) {
-                ret = dict_set_str (dict, "no-timestamp", "true");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "time-stamp option");
-                }
-                if (i == (wordcount-1))
-                        goto out;
-                i++;
-        }
-
-        if ((strcmp (words[i], "description")) == 0) {
-                ++i;
-                if (i > (wordcount - 1)) {
-                        ret = -1;
-                        cli_err ("Please provide a description");
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Description not provided");
-                        goto out;
-                }
-
-                ret = cli_snap_create_desc_parse(dict, words, wordcount, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save snap "
-                                "description");
-                        goto out;
-                }
-
-                if (i == (wordcount - 1))
-                        goto out;
-                i++;
-                /* point the index to next word.
-                 * As description might be follwed by force option.
-                 * Before that, check if wordcount limit is reached
-                 */
-        }
+    }
 
-        if (strcmp (words[i], "force") == 0) {
-                flags = GF_CLI_FLAG_OP_FORCE;
+    if (strcmp(words[i], "force") == 0) {
+        flags = GF_CLI_FLAG_OP_FORCE;
 
-        } else {
-                ret = -1;
-                cli_err ("Invalid Syntax.");
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    } else {
+        ret = -1;
+        cli_err("Invalid Syntax.");
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        /* Check if the command has anything after "force" keyword */
-        if (++i < wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    /* Check if the command has anything after "force" keyword */
+    if (++i < wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if(ret == 0) {
-                /*Adding force flag in either of the case i.e force set
-                 * or unset*/
-                ret = dict_set_int32 (dict, "flags", flags);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "snap force option");
-                }
+    if (ret == 0) {
+        /*Adding force flag in either of the case i.e force set
+         * or unset*/
+        ret = dict_set_int32(dict, "flags", flags);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "snap force option");
         }
-        return ret;
+    }
+    return ret;
 }
 
 /* snapshot list [volname]
@@ -4542,30 +4588,30 @@ out:
  *                 0 on success
  */
 int
-cli_snap_list_parse (dict_t *dict, const char **words, int wordcount) {
-        int             ret     =       -1;
+cli_snap_list_parse(dict_t *dict, const char **words, int wordcount)
+{
+    int ret = -1;
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        if (wordcount < 2 || wordcount > 3) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if (wordcount < 2 || wordcount > 3) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (wordcount == 2) {
-                ret = 0;
-                goto out;
-        }
+    if (wordcount == 2) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to save volname in dictionary");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save volname in dictionary");
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot info [(snapname |  volume <volname>)]
@@ -4577,87 +4623,88 @@ out:
  *                 0 on success
  */
 int
-cli_snap_info_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_info_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int32_t cmd = GF_SNAP_INFO_TYPE_ALL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot info)*/
 
-        int             ret             =       -1;
-        int32_t         cmd             =       GF_SNAP_INFO_TYPE_ALL;
-        unsigned int    cmdi            =        2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot info)*/
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    if (wordcount > 4 || wordcount < cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid syntax");
+        goto out;
+    }
 
-        if (wordcount > 4 || wordcount < cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid syntax");
-                goto out;
-        }
+    if (wordcount == cmdi) {
+        ret = 0;
+        goto out;
+    }
 
-        if (wordcount == cmdi) {
-                ret = 0;
-                goto out;
+    /* If 3rd word is not "volume", then it must
+     * be snapname.
+     */
+    if (strcmp(words[cmdi], "volume") != 0) {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to save "
+                   "snapname %s",
+                   words[cmdi]);
+            goto out;
         }
 
-        /* If 3rd word is not "volume", then it must
-         * be snapname.
+        /* Once snap name is parsed, if we encounter any other
+         * word then fail it. Invalid Syntax.
+         * example : snapshot info <snapname> word
          */
-        if (strcmp (words[cmdi], "volume") != 0) {
-                ret = dict_set_str (dict, "snapname",
-                                   (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to save "
-                                "snapname %s", words[cmdi]);
-                        goto out;
-                }
-
-                /* Once snap name is parsed, if we encounter any other
-                 * word then fail it. Invalid Syntax.
-                 * example : snapshot info <snapname> word
-                 */
-                if ((cmdi + 1) != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                cmd = GF_SNAP_INFO_TYPE_SNAP;
-                ret = 0;
-                goto out;
-                /* No need to continue the parsing once we
-                 * get the snapname
-                 */
+        if ((cmdi + 1) != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        /* If 3rd word is "volume", then check if next word
-         * is present. As, "snapshot info volume" is an
-         * invalid command.
+        cmd = GF_SNAP_INFO_TYPE_SNAP;
+        ret = 0;
+        goto out;
+        /* No need to continue the parsing once we
+         * get the snapname
          */
-        if ((cmdi + 1) == wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words[wordcount - 1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                        "volume name %s", words[wordcount - 1]);
-                goto out;
-        }
-        cmd = GF_SNAP_INFO_TYPE_VOL;
+    /* If 3rd word is "volume", then check if next word
+     * is present. As, "snapshot info volume" is an
+     * invalid command.
+     */
+    if ((cmdi + 1) == wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", (char *)words[wordcount - 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save "
+               "volume name %s",
+               words[wordcount - 1]);
+        goto out;
+    }
+    cmd = GF_SNAP_INFO_TYPE_VOL;
 out:
-        if (ret == 0) {
-                ret = dict_set_int32 (dict, "sub-cmd", cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "type of snapshot info");
-                }
+    if (ret == 0) {
+        ret = dict_set_int32(dict, "sub-cmd", cmd);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "type of snapshot info");
         }
-        return ret;
+    }
+    return ret;
 }
 
-
-
 /* snapshot restore <snapname>
  * @arg-0, dict     : Request Dictionary to be sent to server side.
  * @arg-1, words    : Contains individual words of CLI command.
@@ -4667,42 +4714,43 @@ out:
  *                 0 on success
  */
 int
-cli_snap_restore_parse (dict_t *dict, const char **words, int wordcount,
-                        struct cli_state *state)
+cli_snap_restore_parse(dict_t *dict, const char **words, int wordcount,
+                       struct cli_state *state)
 {
+    int ret = -1;
+    const char *question = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
 
-        int             ret             =       -1;
-        const char      *question       =       NULL;
-        gf_answer_t     answer          =       GF_ANSWER_NO;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if (wordcount != 3) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        question = "Restore operation will replace the "
-                   "original volume with the snapshotted volume. "
-                   "Do you still want to continue?";
+    if (wordcount != 3) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 1;
-                gf_log ("cli", GF_LOG_ERROR, "User cancelled a snapshot "
-                        "restore operation for snap %s", (char *)words[2]);
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
+
+    question =
+        "Restore operation will replace the "
+        "original volume with the snapshotted volume. "
+        "Do you still want to continue?";
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 1;
+        gf_log("cli", GF_LOG_ERROR,
+               "User cancelled a snapshot "
+               "restore operation for snap %s",
+               (char *)words[2]);
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot activate <snapname> [force]
@@ -4714,43 +4762,41 @@ out:
  *                 0 on success
  */
 int
-cli_snap_activate_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_activate_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int flags = 0;
 
-        int ret = -1;
-        int flags = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        if ((wordcount < 3) || (wordcount > 4)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if ((wordcount < 3) || (wordcount > 4)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
 
-        if (wordcount == 4) {
-                if (!strcmp("force", (char *)words[3])) {
-                        flags = GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid option");
-                        ret = -1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save force option");
-                goto out;
-        }
+    if (wordcount == 4) {
+        if (!strcmp("force", (char *)words[3])) {
+            flags = GF_CLI_FLAG_OP_FORCE;
+        } else {
+            gf_log("cli", GF_LOG_ERROR, "Invalid option");
+            ret = -1;
+            goto out;
+        }
+    }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save force option");
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot deactivate <snapname>
@@ -4763,42 +4809,41 @@ out:
  *                 1 if user cancelled the request
  */
 int
-cli_snap_deactivate_parse (dict_t *dict, const char **words, int wordcount,
-                        struct cli_state *state)
+cli_snap_deactivate_parse(dict_t *dict, const char **words, int wordcount,
+                          struct cli_state *state)
 {
+    int ret = -1;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question =
+        "Deactivating snap will make its "
+        "data inaccessible. Do you want to "
+        "continue?";
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+
+    if ((wordcount != 3)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        int             ret             = -1;
-        gf_answer_t     answer          = GF_ANSWER_NO;
-        const char     *question        = "Deactivating snap will make its "
-                                          "data inaccessible. Do you want to "
-                                          "continue?";
-
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-
-        if ((wordcount != 3)) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "snapname", (char *)words[2]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to save snap-name %s",
-                        words[2]);
-                goto out;
-        }
-
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 1;
-                gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot deactivate operation");
-                goto out;
-        }
+    ret = dict_set_str(dict, "snapname", (char *)words[2]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to save snap-name %s", words[2]);
+        goto out;
+    }
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 1;
+        gf_log("cli", GF_LOG_DEBUG,
+               "User cancelled "
+               "snapshot deactivate operation");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot delete (all | snapname | volume <volname>)
@@ -4811,78 +4856,84 @@ out:
  *                 1 if user cancel the operation
  */
 int
-cli_snap_delete_parse (dict_t *dict, const char **words, int wordcount,
-                       struct cli_state *state) {
-
-        int             ret             =       -1;
-        const char      *question       =       NULL;
-        int32_t         cmd             =       -1;
-        unsigned int    cmdi            =       2;
-        gf_answer_t     answer          =       GF_ANSWER_NO;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+cli_snap_delete_parse(dict_t *dict, const char **words, int wordcount,
+                      struct cli_state *state)
+{
+    int ret = -1;
+    const char *question = NULL;
+    int32_t cmd = -1;
+    unsigned int cmdi = 2;
+    gf_answer_t answer = GF_ANSWER_NO;
 
-        if (wordcount > 4 || wordcount <= cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        question = "Deleting snap will erase all the information about "
-                   "the snap. Do you still want to continue?";
+    if (wordcount > 4 || wordcount <= cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (strcmp (words [cmdi], "all") == 0) {
-                ret = 0;
-                cmd = GF_SNAP_DELETE_TYPE_ALL;
-        } else if (strcmp (words [cmdi], "volume") == 0) {
-                if (++cmdi == wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+    question =
+        "Deleting snap will erase all the information about "
+        "the snap. Do you still want to continue?";
 
-                ret = dict_set_str (dict, "volname",
-                                    (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                                "volume name %s", words[wordcount - 1]);
-                        goto out;
-                }
-                cmd = GF_SNAP_DELETE_TYPE_VOL;
-        } else {
-                ret = dict_set_str (dict, "snapname", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to save "
-                                "snapname %s", words[2]);
-                        goto out;
-                }
-                cmd = GF_SNAP_DELETE_TYPE_SNAP;
+    if (strcmp(words[cmdi], "all") == 0) {
+        ret = 0;
+        cmd = GF_SNAP_DELETE_TYPE_ALL;
+    } else if (strcmp(words[cmdi], "volume") == 0) {
+        if (++cmdi == wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        if ((cmdi + 1) != wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+        ret = dict_set_str(dict, "volname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save "
+                   "volume name %s",
+                   words[wordcount - 1]);
+            goto out;
+        }
+        cmd = GF_SNAP_DELETE_TYPE_VOL;
+    } else {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to save "
+                   "snapname %s",
+                   words[2]);
+            goto out;
         }
+        cmd = GF_SNAP_DELETE_TYPE_SNAP;
+    }
 
-        if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 1;
-                        gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                                "snapshot delete operation for snap %s",
-                                (char *)words[2]);
-                        goto out;
-                }
-        }
+    if ((cmdi + 1) != wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "sub-cmd", cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save "
-                        "type of snapshot delete");
-        }
+    if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 1;
+            gf_log("cli", GF_LOG_DEBUG,
+                   "User cancelled "
+                   "snapshot delete operation for snap %s",
+                   (char *)words[2]);
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "sub-cmd", cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save "
+               "type of snapshot delete");
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* snapshot status [(snapname | volume <volname>)]
@@ -4894,132 +4945,138 @@ out:
  *                 0 on success
  */
 int
-cli_snap_status_parse (dict_t *dict, const char **words, int wordcount)
+cli_snap_status_parse(dict_t *dict, const char **words, int wordcount)
 {
+    int ret = -1;
+    int32_t cmd = GF_SNAP_STATUS_TYPE_ALL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot status)*/
 
-        int             ret  =        -1;
-        int32_t         cmd  =       GF_SNAP_STATUS_TYPE_ALL;
-        unsigned int    cmdi =        2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot status)*/
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
 
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
+    if (wordcount > 4 || wordcount < cmdi) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        if (wordcount > 4 || wordcount < cmdi) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+    if (wordcount == cmdi) {
+        ret = 0;
+        goto out;
+    }
 
-        if (wordcount == cmdi) {
-                ret = 0;
-                goto out;
+    /* if 3rd word is not "volume", then it must be "snapname"
+     */
+    if (strcmp(words[cmdi], "volume") != 0) {
+        ret = dict_set_str(dict, "snapname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Count not save "
+                   "snap name %s",
+                   words[cmdi]);
+            goto out;
         }
 
-        /* if 3rd word is not "volume", then it must be "snapname"
-        */
-        if (strcmp (words[cmdi], "volume") != 0) {
-                ret = dict_set_str (dict, "snapname",
-                                   (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Count not save "
-                                "snap name %s", words[cmdi]);
-                        goto out;
-                }
-
-                if ((cmdi + 1) != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                ret = 0;
-                cmd = GF_SNAP_STATUS_TYPE_SNAP;
-                goto out;
+        if ((cmdi + 1) != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
 
-        /* If 3rd word is "volume", then check if next word is present.
-         * As, "snapshot info volume" is an invalid command
-         */
-        if ((cmdi + 1) == wordcount) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
-        }
+        ret = 0;
+        cmd = GF_SNAP_STATUS_TYPE_SNAP;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", (char *)words [wordcount - 1]);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Count not save "
-                        "volume name %s", words[wordcount - 1]);
-                goto out;
-        }
-        cmd = GF_SNAP_STATUS_TYPE_VOL;
+    /* If 3rd word is "volume", then check if next word is present.
+     * As, "snapshot info volume" is an invalid command
+     */
+    if ((cmdi + 1) == wordcount) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", (char *)words[wordcount - 1]);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Count not save "
+               "volume name %s",
+               words[wordcount - 1]);
+        goto out;
+    }
+    cmd = GF_SNAP_STATUS_TYPE_VOL;
 
 out:
-        if (ret == 0) {
-                ret = dict_set_int32 (dict, "sub-cmd", cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not save cmd "
-                                "of snapshot status");
-                }
+    if (ret == 0) {
+        ret = dict_set_int32(dict, "sub-cmd", cmd);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not save cmd "
+                   "of snapshot status");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 /* return value:
  *      -1  in case of failure.
  *       0  in case of success.
  */
 int32_t
-cli_snap_config_limit_parse (const char **words, dict_t *dict,
-                             unsigned int wordcount, unsigned int index,
-                             char *key)
+cli_snap_config_limit_parse(const char **words, dict_t *dict,
+                            unsigned int wordcount, unsigned int index,
+                            char *key)
 {
-        int             ret             = -1;
-        int             limit           = 0;
-        char            *end_ptr        = NULL;
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-        GF_ASSERT (key);
+    int ret = -1;
+    int limit = 0;
+    char *end_ptr = NULL;
 
-        if (index >= wordcount) {
-                ret = -1;
-                cli_err ("Please provide a value for %s.", key);
-                gf_log ("cli", GF_LOG_ERROR, "Value not provided for %s", key);
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+    GF_ASSERT(key);
 
-        limit = strtol (words[index], &end_ptr, 10);
+    if (index >= wordcount) {
+        ret = -1;
+        cli_err("Please provide a value for %s.", key);
+        gf_log("cli", GF_LOG_ERROR, "Value not provided for %s", key);
+        goto out;
+    }
 
-        if (limit <= 0 || strcmp (end_ptr, "") != 0) {
-                ret = -1;
-                cli_err("Please enter an integer value "
-                        "greater than zero for %s", key);
-                goto out;
-        }
+    limit = strtol(words[index], &end_ptr, 10);
 
-        ret = dict_set_int32 (dict, key, limit);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set "
-                        "%s in dictionary", key);
-                goto out;
-        }
+    if (limit <= 0 || strcmp(end_ptr, "") != 0) {
+        ret = -1;
+        cli_err(
+            "Please enter an integer value "
+            "greater than zero for %s",
+            key);
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, key, limit);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not set "
+               "%s in dictionary",
+               key);
+        goto out;
+    }
 
-        ret = dict_set_dynstr_with_alloc (dict, "globalname", "All");
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set global key");
-                goto out;
-        }
-        ret = dict_set_int32 (dict, "hold_global_locks", _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not set global locks");
-                goto out;
-        }
+    ret = dict_set_dynstr_with_alloc(dict, "globalname", "All");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not set global key");
+        goto out;
+    }
+    ret = dict_set_int32(dict, "hold_global_locks", _gf_true);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not set global locks");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /* function cli_snap_config_parse
@@ -5035,775 +5092,787 @@ out:
   NOTE : snap-max-soft-limit can only be set for system.
 */
 int32_t
-cli_snap_config_parse (const char **words, int wordcount, dict_t *dict,
-                       struct cli_state *state)
+cli_snap_config_parse(const char **words, int wordcount, dict_t *dict,
+                      struct cli_state *state)
 {
-        int                            ret                 = -1;
-        gf_answer_t                    answer              = GF_ANSWER_NO;
-        gf_boolean_t                   vol_presence        = _gf_false;
-        struct snap_config_opt_vals_  *conf_vals           = NULL;
-        int8_t                         hard_limit          = 0;
-        int8_t                         soft_limit          = 0;
-        int8_t                         config_type         = -1;
-        const char                    *question            = NULL;
-        unsigned int                   cmdi                = 2;
-        /* cmdi is command index, here cmdi is "2" (gluster snapshot config)*/
-
-        GF_ASSERT (words);
-        GF_ASSERT (dict);
-        GF_ASSERT (state);
-
-        if ((wordcount < 2) || (wordcount > 7)) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Invalid wordcount(%d)", wordcount);
-                goto out;
-        }
+    int ret = -1;
+    gf_answer_t answer = GF_ANSWER_NO;
+    gf_boolean_t vol_presence = _gf_false;
+    struct snap_config_opt_vals_ *conf_vals = NULL;
+    int8_t hard_limit = 0;
+    int8_t soft_limit = 0;
+    int8_t config_type = -1;
+    const char *question = NULL;
+    unsigned int cmdi = 2;
+    /* cmdi is command index, here cmdi is "2" (gluster snapshot config)*/
+
+    GF_ASSERT(words);
+    GF_ASSERT(dict);
+    GF_ASSERT(state);
+
+    if ((wordcount < 2) || (wordcount > 7)) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid wordcount(%d)", wordcount);
+        goto out;
+    }
 
-        if (wordcount == 2) {
-                config_type = GF_SNAP_CONFIG_DISPLAY;
-                ret = 0;
-                goto set;
+    if (wordcount == 2) {
+        config_type = GF_SNAP_CONFIG_DISPLAY;
+        ret = 0;
+        goto set;
+    }
+
+    /* auto-delete cannot be a volume name */
+    /* Check whether the 3rd word is volname */
+    if (strcmp(words[cmdi], "snap-max-hard-limit") != 0 &&
+        strcmp(words[cmdi], "snap-max-soft-limit") != 0 &&
+        strcmp(words[cmdi], "auto-delete") != 0 &&
+        strcmp(words[cmdi], "activate-on-create") != 0) {
+        ret = dict_set_str(dict, "volname", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to set volname");
+            goto out;
         }
+        cmdi++;
+        vol_presence = _gf_true;
 
-        /* auto-delete cannot be a volume name */
-        /* Check whether the 3rd word is volname */
-        if (strcmp (words[cmdi], "snap-max-hard-limit") != 0
-             && strcmp (words[cmdi], "snap-max-soft-limit") != 0
-             && strcmp (words[cmdi], "auto-delete") != 0
-             && strcmp (words[cmdi], "activate-on-create") != 0) {
-                ret = dict_set_str (dict, "volname", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set volname");
-                        goto out;
-                }
-                cmdi++;
-                vol_presence = _gf_true;
-
-                if (cmdi == wordcount) {
-                        config_type = GF_SNAP_CONFIG_DISPLAY;
-                        ret = 0;
-                        goto set;
-                }
+        if (cmdi == wordcount) {
+            config_type = GF_SNAP_CONFIG_DISPLAY;
+            ret = 0;
+            goto set;
         }
+    }
 
-        config_type = GF_SNAP_CONFIG_TYPE_SET;
+    config_type = GF_SNAP_CONFIG_TYPE_SET;
 
-        if (strcmp (words[cmdi], "snap-max-hard-limit") == 0) {
-                ret = cli_snap_config_limit_parse (words, dict, wordcount,
-                                                ++cmdi, "snap-max-hard-limit");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse snap "
-                                "config hard limit");
-                        goto out;
-                }
-                hard_limit = 1;
-
-                if (++cmdi == wordcount) {
-                        ret = 0;
-                        goto set;
-                }
+    if (strcmp(words[cmdi], "snap-max-hard-limit") == 0) {
+        ret = cli_snap_config_limit_parse(words, dict, wordcount, ++cmdi,
+                                          "snap-max-hard-limit");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to parse snap "
+                   "config hard limit");
+            goto out;
         }
+        hard_limit = 1;
 
-        if (strcmp (words[cmdi], "snap-max-soft-limit") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("Soft limit cannot be set to individual "
-                                  "volumes.");
-                        gf_log ("cli", GF_LOG_ERROR, "Soft limit cannot be "
-                                "set to volumes");
-                        goto out;
-                }
-
-                ret = cli_snap_config_limit_parse (words, dict, wordcount,
-                                                ++cmdi, "snap-max-soft-limit");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse snap "
-                                "config soft limit");
-                        goto out;
-                }
-
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-                soft_limit = 1;
+        if (++cmdi == wordcount) {
+            ret = 0;
+            goto set;
         }
+    }
 
-        if (hard_limit || soft_limit)
-                goto set;
+    if (strcmp(words[cmdi], "snap-max-soft-limit") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "Soft limit cannot be set to individual "
+                "volumes.");
+            gf_log("cli", GF_LOG_ERROR,
+                   "Soft limit cannot be "
+                   "set to volumes");
+            goto out;
+        }
 
-        if (strcmp(words[cmdi], "auto-delete") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("As of now, auto-delete option cannot be set "
-                                "to volumes");
-                        gf_log ("cli", GF_LOG_ERROR, "auto-delete option "
-                                "cannot be set to volumes");
-                        goto out;
-                }
+        ret = cli_snap_config_limit_parse(words, dict, wordcount, ++cmdi,
+                                          "snap-max-soft-limit");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to parse snap "
+                   "config soft limit");
+            goto out;
+        }
 
-                if (++cmdi >= wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+        soft_limit = 1;
+    }
 
-                ret = dict_set_str (dict, "auto-delete", (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                "value of auto-delete in request "
-                                "dictionary");
-                        goto out;
-                }
+    if (hard_limit || soft_limit)
+        goto set;
 
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-        } else if (strcmp(words[cmdi], "activate-on-create") == 0) {
-                if (vol_presence == 1) {
-                        ret = -1;
-                        cli_err ("As of now, activate-on-create option "
-                                 "cannot be set to volumes");
-                        gf_log ("cli", GF_LOG_ERROR, "activate-on-create "
-                                "option cannot be set to volumes");
-                        goto out;
-                }
+    if (strcmp(words[cmdi], "auto-delete") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "As of now, auto-delete option cannot be set "
+                "to volumes");
+            gf_log("cli", GF_LOG_ERROR,
+                   "auto-delete option "
+                   "cannot be set to volumes");
+            goto out;
+        }
 
-                if (++cmdi >= wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+        if (++cmdi >= wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
 
-                ret = dict_set_str (dict, "snap-activate-on-create",
-                                    (char *)words[cmdi]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set value "
-                                "of activate-on-create in request dictionary");
-                        goto out;
-                }
+        ret = dict_set_str(dict, "auto-delete", (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set "
+                   "value of auto-delete in request "
+                   "dictionary");
+            goto out;
+        }
+
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+    } else if (strcmp(words[cmdi], "activate-on-create") == 0) {
+        if (vol_presence == 1) {
+            ret = -1;
+            cli_err(
+                "As of now, activate-on-create option "
+                "cannot be set to volumes");
+            gf_log("cli", GF_LOG_ERROR,
+                   "activate-on-create "
+                   "option cannot be set to volumes");
+            goto out;
+        }
+
+        if (++cmdi >= wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
+        }
+
+        ret = dict_set_str(dict, "snap-activate-on-create",
+                           (char *)words[cmdi]);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set value "
+                   "of activate-on-create in request dictionary");
+            goto out;
+        }
 
-                if (++cmdi != wordcount) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-        } else {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                goto out;
+        if (++cmdi != wordcount) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+            goto out;
         }
+    } else {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+        goto out;
+    }
 
-        ret = 0; /* Success */
+    ret = 0; /* Success */
 
 set:
-        ret = dict_set_int32 (dict, "config-command", config_type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to set "
-                        "config-command");
-                goto out;
-        }
+    ret = dict_set_int32(dict, "config-command", config_type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Unable to set "
+               "config-command");
+        goto out;
+    }
 
-        if (config_type == GF_SNAP_CONFIG_TYPE_SET &&
-           (hard_limit || soft_limit)) {
-                conf_vals = snap_confopt_vals;
-                if (hard_limit && soft_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_BOTH].question;
-                } else if (soft_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_SOFT].question;
-                } else if (hard_limit) {
-                        question = conf_vals[GF_SNAP_CONFIG_SET_HARD].question;
-                }
+    if (config_type == GF_SNAP_CONFIG_TYPE_SET && (hard_limit || soft_limit)) {
+        conf_vals = snap_confopt_vals;
+        if (hard_limit && soft_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_BOTH].question;
+        } else if (soft_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_SOFT].question;
+        } else if (hard_limit) {
+            question = conf_vals[GF_SNAP_CONFIG_SET_HARD].question;
+        }
 
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 1;
-                        gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot config operation");
-                }
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 1;
+            gf_log("cli", GF_LOG_DEBUG,
+                   "User cancelled "
+                   "snapshot config operation");
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-validate_op_name (const char *op, const char *opname, char **opwords) {
-        int     ret     =       -1;
-        int     i       =       0;
+validate_op_name(const char *op, const char *opname, char **opwords)
+{
+    int ret = -1;
+    int i = 0;
 
-        GF_ASSERT (opname);
-        GF_ASSERT (opwords);
+    GF_ASSERT(opname);
+    GF_ASSERT(opwords);
 
-        for (i = 0 ; opwords[i] != NULL; i++) {
-                if (strcmp (opwords[i], opname) == 0) {
-                        cli_out ("\"%s\" cannot be a %s", opname, op);
-                        goto out;
-                }
+    for (i = 0; opwords[i] != NULL; i++) {
+        if (strcmp(opwords[i], opname) == 0) {
+            cli_out("\"%s\" cannot be a %s", opname, op);
+            goto out;
         }
-        ret = 0;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_snapshot_parse (const char **words, int wordcount, dict_t **options,
-                        struct cli_state *state)
+cli_cmd_snapshot_parse(const char **words, int wordcount, dict_t **options,
+                       struct cli_state *state)
 {
-        int32_t            ret        = -1;
-        dict_t             *dict      = NULL;
-        gf1_cli_snapshot   type       = GF_SNAP_OPTION_TYPE_NONE;
-        char               *w         = NULL;
-        char               *opwords[] = {"create", "delete", "restore",
-                                        "activate", "deactivate", "list",
-                                        "status", "config", "info", "clone",
-                                        NULL};
-        char               *invalid_snapnames[] = {"description", "force",
-                                                  "volume", "all", NULL};
-        char               *invalid_volnames[]  = {"volume", "type",
-                                                   "subvolumes", "option",
-                                                   "end-volume", "all",
-                                                   "volume_not_in_ring",
-                                                   "description", "force",
-                                                   "snap-max-hard-limit",
-                                                   "snap-max-soft-limit",
-                                                   "auto-delete",
-                                                   "activate-on-create", NULL};
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-        GF_ASSERT (state);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    int32_t ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_snapshot type = GF_SNAP_OPTION_TYPE_NONE;
+    char *w = NULL;
+    char *opwords[] = {"create",     "delete", "restore", "activate",
+                       "deactivate", "list",   "status",  "config",
+                       "info",       "clone",  NULL};
+    char *invalid_snapnames[] = {"description", "force", "volume", "all", NULL};
+    char *invalid_volnames[] = {"volume",
+                                "type",
+                                "subvolumes",
+                                "option",
+                                "end-volume",
+                                "all",
+                                "volume_not_in_ring",
+                                "description",
+                                "force",
+                                "snap-max-hard-limit",
+                                "snap-max-soft-limit",
+                                "auto-delete",
+                                "activate-on-create",
+                                NULL};
 
-        /* Lowest wordcount possible */
-        if (wordcount < 2) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Invalid command: Not enough arguments");
-                goto out;
-        }
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+    GF_ASSERT(state);
 
-        w = str_getunamb (words[1], opwords);
-        if (!w) {
-                /* Checks if the operation is a valid operation */
-                gf_log ("", GF_LOG_ERROR, "Opword Mismatch");
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (!strcmp (w, "create")) {
-                type = GF_SNAP_OPTION_TYPE_CREATE;
-        } else if (!strcmp (w, "list")) {
-                type = GF_SNAP_OPTION_TYPE_LIST;
-        } else if (!strcmp (w, "info")) {
-                type = GF_SNAP_OPTION_TYPE_INFO;
-        } else if (!strcmp (w, "delete")) {
-                type = GF_SNAP_OPTION_TYPE_DELETE;
-        } else if (!strcmp (w, "config")) {
-                type = GF_SNAP_OPTION_TYPE_CONFIG;
-        } else if (!strcmp (w, "restore")) {
-                type = GF_SNAP_OPTION_TYPE_RESTORE;
-        } else if (!strcmp (w, "status")) {
-                type = GF_SNAP_OPTION_TYPE_STATUS;
-        } else if (!strcmp (w, "activate")) {
-                type = GF_SNAP_OPTION_TYPE_ACTIVATE;
-        } else if (!strcmp (w, "deactivate")) {
-                type = GF_SNAP_OPTION_TYPE_DEACTIVATE;
-        } else if (!strcmp(w, "clone")) {
-                type = GF_SNAP_OPTION_TYPE_CLONE;
-        }
-
-        if (type != GF_SNAP_OPTION_TYPE_CONFIG &&
-            type != GF_SNAP_OPTION_TYPE_STATUS) {
-                ret = dict_set_int32 (dict, "hold_snap_locks", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to set hold-snap-locks value "
-                                "as _gf_true");
-                        goto out;
-                }
-        }
+    /* Lowest wordcount possible */
+    if (wordcount < 2) {
+        gf_log("", GF_LOG_ERROR, "Invalid command: Not enough arguments");
+        goto out;
+    }
 
-        /* Following commands does not require volume locks  */
-        if (type == GF_SNAP_OPTION_TYPE_STATUS ||
-            type == GF_SNAP_OPTION_TYPE_ACTIVATE ||
-            type == GF_SNAP_OPTION_TYPE_DEACTIVATE) {
-                ret = dict_set_int32 (dict, "hold_vol_locks", _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Setting volume lock "
-                                "flag failed");
-                        goto out;
-                }
+    w = str_getunamb(words[1], opwords);
+    if (!w) {
+        /* Checks if the operation is a valid operation */
+        gf_log("", GF_LOG_ERROR, "Opword Mismatch");
+        goto out;
+    }
+
+    if (!strcmp(w, "create")) {
+        type = GF_SNAP_OPTION_TYPE_CREATE;
+    } else if (!strcmp(w, "list")) {
+        type = GF_SNAP_OPTION_TYPE_LIST;
+    } else if (!strcmp(w, "info")) {
+        type = GF_SNAP_OPTION_TYPE_INFO;
+    } else if (!strcmp(w, "delete")) {
+        type = GF_SNAP_OPTION_TYPE_DELETE;
+    } else if (!strcmp(w, "config")) {
+        type = GF_SNAP_OPTION_TYPE_CONFIG;
+    } else if (!strcmp(w, "restore")) {
+        type = GF_SNAP_OPTION_TYPE_RESTORE;
+    } else if (!strcmp(w, "status")) {
+        type = GF_SNAP_OPTION_TYPE_STATUS;
+    } else if (!strcmp(w, "activate")) {
+        type = GF_SNAP_OPTION_TYPE_ACTIVATE;
+    } else if (!strcmp(w, "deactivate")) {
+        type = GF_SNAP_OPTION_TYPE_DEACTIVATE;
+    } else if (!strcmp(w, "clone")) {
+        type = GF_SNAP_OPTION_TYPE_CLONE;
+    }
+
+    if (type != GF_SNAP_OPTION_TYPE_CONFIG &&
+        type != GF_SNAP_OPTION_TYPE_STATUS) {
+        ret = dict_set_int32(dict, "hold_snap_locks", _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to set hold-snap-locks value "
+                   "as _gf_true");
+            goto out;
+        }
+    }
+
+    /* Following commands does not require volume locks  */
+    if (type == GF_SNAP_OPTION_TYPE_STATUS ||
+        type == GF_SNAP_OPTION_TYPE_ACTIVATE ||
+        type == GF_SNAP_OPTION_TYPE_DEACTIVATE) {
+        ret = dict_set_int32(dict, "hold_vol_locks", _gf_false);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Setting volume lock "
+                   "flag failed");
+            goto out;
         }
+    }
 
-        /* Check which op is intended */
-        switch (type) {
+    /* Check which op is intended */
+    switch (type) {
         case GF_SNAP_OPTION_TYPE_CREATE:
-                /* Syntax :
-                 * gluster snapshot create <snapname> <vol-name(s)>
-                 *                         [no-timestamp]
-                 *                         [description <description>]
-                 *                         [force]
-                 */
-                /* In cases where the snapname is not given then
-                 * parsing fails & snapname cannot be "description",
-                 * "force" and "volume", that check is made here
-                 */
-                if (wordcount == 2){
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
+            /* Syntax :
+             * gluster snapshot create <snapname> <vol-name(s)>
+             *                         [no-timestamp]
+             *                         [description <description>]
+             *                         [force]
+             */
+            /* In cases where the snapname is not given then
+             * parsing fails & snapname cannot be "description",
+             * "force" and "volume", that check is made here
+             */
+            if (wordcount == 2) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+                goto out;
+            }
 
-                ret = validate_op_name ("snapname", words[2],
-                                        invalid_snapnames);
-                if (ret) {
-                        goto out;
-                }
+            ret = validate_op_name("snapname", words[2], invalid_snapnames);
+            if (ret) {
+                goto out;
+            }
 
-                ret = cli_snap_create_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "create command parsing failed.");
-                        goto out;
-                }
-                break;
+            ret = cli_snap_create_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "create command parsing failed.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_CLONE:
-                /* Syntax :
-                 * gluster snapshot clone <clonename> <snapname>
-                 */
-                /* In cases where the clonename is not given then
-                 * parsing fails & snapname cannot be "description",
-                 * "force" and "volume", that check is made here
-                 */
-                if (wordcount == 2) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Invalid Syntax");
-                        goto out;
-                }
-
-                ret = validate_op_name ("clonename", words[2],
-                                        invalid_volnames);
-                if (ret) {
-                        goto out;
-                }
+            /* Syntax :
+             * gluster snapshot clone <clonename> <snapname>
+             */
+            /* In cases where the clonename is not given then
+             * parsing fails & snapname cannot be "description",
+             * "force" and "volume", that check is made here
+             */
+            if (wordcount == 2) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR, "Invalid Syntax");
+                goto out;
+            }
 
-                ret = cli_snap_clone_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "clone command parsing failed.");
-                        goto out;
-                }
-                break;
+            ret = validate_op_name("clonename", words[2], invalid_volnames);
+            if (ret) {
+                goto out;
+            }
 
+            ret = cli_snap_clone_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "clone command parsing failed.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_INFO:
-                /* Syntax :
-                 * gluster snapshot info [(snapname] | [vol <volname>)]
-                 */
-                ret = cli_snap_info_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "snapshot info command");
-                        goto out;
-                }
-                break;
+            /* Syntax :
+             * gluster snapshot info [(snapname] | [vol <volname>)]
+             */
+            ret = cli_snap_info_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot info command");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_LIST:
-                /* Syntax :
-                 * gluster snaphsot list [volname]
-                 */
+            /* Syntax :
+             * gluster snaphsot list [volname]
+             */
 
-                ret = cli_snap_list_parse (dict, words, wordcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "snapshot list command");
-                        goto out;
-                }
-                break;
+            ret = cli_snap_list_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot list command");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_DELETE:
-                /* Syntax :
-                 * snapshot delete (all | snapname | volume <volname>)
-                 */
-                ret = cli_snap_delete_parse (dict, words, wordcount, state);
-                if (ret) {
-                        /* A positive ret value means user cancelled
-                        * the command */
-                        if (ret < 0) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "snapshot delete command");
-                        }
-                        goto out;
+            /* Syntax :
+             * snapshot delete (all | snapname | volume <volname>)
+             */
+            ret = cli_snap_delete_parse(dict, words, wordcount, state);
+            if (ret) {
+                /* A positive ret value means user cancelled
+                 * the command */
+                if (ret < 0) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Failed to parse "
+                           "snapshot delete command");
                 }
-                break;
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_CONFIG:
-                /* snapshot config [volname]  [snap-max-hard-limit <count>]
-                 *                            [snap-max-soft-limit <percent>] */
-                ret = cli_snap_config_parse (words, wordcount, dict, state);
-                if (ret) {
-                        if (ret < 0)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "config command parsing failed.");
-                        goto out;
-                }
+            /* snapshot config [volname]  [snap-max-hard-limit <count>]
+             *                            [snap-max-soft-limit <percent>] */
+            ret = cli_snap_config_parse(words, wordcount, dict, state);
+            if (ret) {
+                if (ret < 0)
+                    gf_log("cli", GF_LOG_ERROR,
+                           "config command parsing failed.");
+                goto out;
+            }
 
-                ret = dict_set_int32 (dict, "type", GF_SNAP_OPTION_TYPE_CONFIG);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to set "
-                                "config type");
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        case GF_SNAP_OPTION_TYPE_STATUS:
-                {
-                        /* Syntax :
-                         * gluster snapshot status [(snapname |
-                         *                         volume <volname>)]
-                         */
-                        ret = cli_snap_status_parse (dict, words, wordcount);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "snapshot status command");
-                                goto out;
-                        }
-                        break;
-                }
+            ret = dict_set_int32(dict, "type", GF_SNAP_OPTION_TYPE_CONFIG);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Unable to set "
+                       "config type");
+                ret = -1;
+                goto out;
+            }
+            break;
+
+        case GF_SNAP_OPTION_TYPE_STATUS: {
+            /* Syntax :
+             * gluster snapshot status [(snapname |
+             *                         volume <volname>)]
+             */
+            ret = cli_snap_status_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "snapshot status command");
+                goto out;
+            }
+            break;
+        }
 
         case GF_SNAP_OPTION_TYPE_RESTORE:
-                /* Syntax:
-                 * snapshot restore <snapname>
-                 */
-                ret = cli_snap_restore_parse (dict, words, wordcount, state);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                "restore command");
-                        goto out;
+            /* Syntax:
+             * snapshot restore <snapname>
+             */
+            ret = cli_snap_restore_parse(dict, words, wordcount, state);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "restore command");
+                goto out;
+            }
+            break;
+
+        case GF_SNAP_OPTION_TYPE_ACTIVATE:
+            /* Syntax:
+             * snapshot activate <snapname> [force]
+             */
+            ret = cli_snap_activate_parse(dict, words, wordcount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to parse "
+                       "start command");
+                goto out;
+            }
+            break;
+        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
+            /* Syntax:
+             * snapshot deactivate <snapname>
+             */
+            ret = cli_snap_deactivate_parse(dict, words, wordcount, state);
+            if (ret) {
+                /* A positive ret value means user cancelled
+                 * the command */
+                if (ret < 0) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Failed to parse deactivate "
+                           "command");
                 }
-                break;
-
-                case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                        /* Syntax:
-                        * snapshot activate <snapname> [force]
-                        */
-                        ret = cli_snap_activate_parse (dict, words, wordcount);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to parse "
-                                        "start command");
-                                goto out;
-                        }
-                        break;
-                case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                        /* Syntax:
-                        * snapshot deactivate <snapname>
-                        */
-                        ret = cli_snap_deactivate_parse (dict, words, wordcount,
-                                state);
-                        if (ret) {
-                                /* A positive ret value means user cancelled
-                                 * the command */
-                                if (ret < 0) {
-                                        gf_log ("cli", GF_LOG_ERROR,
-                                                "Failed to parse deactivate "
-                                                "command");
-                                }
-                                goto out;
-                        }
-                        break;
+                goto out;
+            }
+            break;
 
         default:
-                gf_log ("", GF_LOG_ERROR, "Opword Mismatch");
-                goto out;
-        }
+            gf_log("", GF_LOG_ERROR, "Opword Mismatch");
+            goto out;
+    }
 
-        ret = dict_set_int32 (dict, "type", type);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Failed to set type.");
-                goto out;
-        }
-        /* If you got so far, input is valid */
-        ret = 0;
+    ret = dict_set_int32(dict, "type", type);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Failed to set type.");
+        goto out;
+    }
+    /* If you got so far, input is valid */
+    ret = 0;
 out:
-        if (ret) {
-                if (dict)
-                        dict_unref (dict);
-        } else
-                *options = dict;
+    if (ret) {
+        if (dict)
+            dict_unref(dict);
+    } else
+        *options = dict;
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_validate_volume (char *volname)
+cli_cmd_validate_volume(char *volname)
 {
-        int       i        =  0;
-        int       ret      = -1;
-        int       volname_len;
+    int i = 0;
+    int ret = -1;
+    int volname_len;
 
+    if (volname[0] == '-')
+        return ret;
 
-        if (volname[0] == '-')
-                return ret;
+    if (!strcmp(volname, "all")) {
+        cli_err("\"all\" cannot be the name of a volume.");
+        return ret;
+    }
 
-        if (!strcmp (volname, "all")) {
-                cli_err ("\"all\" cannot be the name of a volume.");
-                return ret;
-        }
+    if (strchr(volname, '/')) {
+        cli_err("Volume name should not contain \"/\" character.");
+        return ret;
+    }
 
-        if (strchr (volname, '/')) {
-                cli_err ("Volume name should not contain \"/\" character.");
-                return ret;
-        }
+    volname_len = strlen(volname);
+    if (volname_len > GD_VOLUME_NAME_MAX) {
+        cli_err("Volname can not exceed %d characters.", GD_VOLUME_NAME_MAX);
+        return ret;
+    }
 
-        volname_len = strlen (volname);
-        if (volname_len > GD_VOLUME_NAME_MAX) {
-                cli_err ("Volname can not exceed %d characters.",
-                        GD_VOLUME_NAME_MAX);
-                return ret;
+    for (i = 0; i < volname_len; i++)
+        if (!isalnum(volname[i]) && (volname[i] != '_') &&
+            (volname[i] != '-')) {
+            cli_err(
+                "Volume name should not contain \"%c\""
+                " character.\nVolume names can only"
+                "contain alphanumeric, '-' and '_' "
+                "characters.",
+                volname[i]);
+            return ret;
         }
 
-        for (i = 0; i < volname_len ; i++)
-                if (!isalnum (volname[i]) && (volname[i] != '_') &&
-                    (volname[i] != '-')) {
-                        cli_err ("Volume name should not contain \"%c\""
-                                 " character.\nVolume names can only"
-                                 "contain alphanumeric, '-' and '_' "
-                                 "characters.", volname[i]);
-                        return ret;
-                }
-
-        ret = 0;
+    ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_bitrot_parse (const char **words, int wordcount, dict_t **options)
+cli_cmd_bitrot_parse(const char **words, int wordcount, dict_t **options)
 {
-        int32_t            ret                    = -1;
-        char               *w                     = NULL;
-        char               *volname               = NULL;
-        char               *opwords[]             = {"enable", "disable",
-                                                     "scrub-throttle",
-                                                     "scrub-frequency", "scrub",
-                                                     "signing-time", NULL};
-        char               *scrub_throt_values[]  = {"lazy", "normal",
-                                                     "aggressive", NULL};
-        char               *scrub_freq_values[]   = {"hourly",
-                                                     "daily", "weekly",
-                                                     "biweekly", "monthly",
-                                                     "minute",  NULL};
-        char               *scrub_values[]        = {"pause", "resume",
-                                                     "status", "ondemand",
-                                                     NULL};
-        dict_t             *dict                  = NULL;
-        gf_bitrot_type     type                   = GF_BITROT_OPTION_TYPE_NONE;
-        int32_t            expiry_time            = 0;
-
-        GF_ASSERT (words);
-        GF_ASSERT (options);
-
-
-        /* Hack to print out bitrot help properly */
-        if ((wordcount == 3) && !(strcmp (words[2], "help"))) {
-                ret = 1;
-                return ret;
-        }
-
-        if (wordcount < 4 || wordcount > 5) {
-                gf_log ("cli", GF_LOG_ERROR, "Invalid syntax");
-                goto out;
-        }
+    int32_t ret = -1;
+    char *w = NULL;
+    char *volname = NULL;
+    char *opwords[] = {
+        "enable",       "disable", "scrub-throttle", "scrub-frequency", "scrub",
+        "signing-time", NULL};
+    char *scrub_throt_values[] = {"lazy", "normal", "aggressive", NULL};
+    char *scrub_freq_values[] = {"hourly",  "daily",  "weekly", "biweekly",
+                                 "monthly", "minute", NULL};
+    char *scrub_values[] = {"pause", "resume", "status", "ondemand", NULL};
+    dict_t *dict = NULL;
+    gf_bitrot_type type = GF_BITROT_OPTION_TYPE_NONE;
+    int32_t expiry_time = 0;
+
+    GF_ASSERT(words);
+    GF_ASSERT(options);
+
+    /* Hack to print out bitrot help properly */
+    if ((wordcount == 3) && !(strcmp(words[2], "help"))) {
+        ret = 1;
+        return ret;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    if (wordcount < 4 || wordcount > 5) {
+        gf_log("cli", GF_LOG_ERROR, "Invalid syntax");
+        goto out;
+    }
 
-        volname = (char *)words[2];
-        if (!volname) {
-                ret = -1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        ret = cli_cmd_validate_volume (volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to validate volume name");
-                goto out;
-        }
+    volname = (char *)words[2];
+    if (!volname) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                cli_out ("Failed to set volume name in dictionary ");
-                goto out;
-        }
+    ret = cli_cmd_validate_volume(volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to validate volume name");
+        goto out;
+    }
 
-        w = str_getunamb (words[3], opwords);
-        if (!w) {
-                cli_out ("Invalid bit rot option : %s", words[3]);
-                ret = -1;
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        cli_out("Failed to set volume name in dictionary ");
+        goto out;
+    }
 
-        if (strcmp (w, "enable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_BITROT_OPTION_TYPE_ENABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    w = str_getunamb(words[3], opwords);
+    if (!w) {
+        cli_out("Invalid bit rot option : %s", words[3]);
+        ret = -1;
+        goto out;
+    }
 
-        if (strcmp (w, "disable") == 0) {
-                if (wordcount == 4) {
-                        type = GF_BITROT_OPTION_TYPE_DISABLE;
-                        ret = 0;
-                        goto set_type;
-                } else {
-                        ret = -1;
-                        goto out;
-                }
+    if (strcmp(w, "enable") == 0) {
+        if (wordcount == 4) {
+            type = GF_BITROT_OPTION_TYPE_ENABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (!strcmp (w, "scrub-throttle")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub-throttle value for bitrot "
-                                 "option");
-                        ret = -1;
-                        goto out;
-                } else {
-                        w = str_getunamb (words[4], scrub_throt_values);
-                        if (!w) {
-                                cli_err ("Invalid scrub-throttle option for "
-                                         "bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                type = GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE;
-                                ret =  dict_set_str (dict,
-                                                     "scrub-throttle-value",
-                                                     (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set scrub-throttle "
-                                                 "value in the dict");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
+    if (strcmp(w, "disable") == 0) {
+        if (wordcount == 4) {
+            type = GF_BITROT_OPTION_TYPE_DISABLE;
+            ret = 0;
+            goto set_type;
+        } else {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    if (!strcmp(w, "scrub-throttle")) {
+        if (!words[4]) {
+            cli_err(
+                "Missing scrub-throttle value for bitrot "
+                "option");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_throt_values);
+            if (!w) {
+                cli_err(
+                    "Invalid scrub-throttle option for "
+                    "bitrot");
+                ret = -1;
+                goto out;
+            } else {
+                type = GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE;
+                ret = dict_set_str(dict, "scrub-throttle-value",
+                                   (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set scrub-throttle "
+                        "value in the dict");
+                    goto out;
                 }
+                goto set_type;
+            }
         }
+    }
 
-        if (!strcmp (words[3], "scrub-frequency")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub-frequency value");
-                        ret = -1;
-                        goto out;
-                } else {
-                        w = str_getunamb (words[4], scrub_freq_values);
-                        if (!w) {
-                                cli_err ("Invalid frequency option for bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                type = GF_BITROT_OPTION_TYPE_SCRUB_FREQ;
-                                ret = dict_set_str (dict,
-                                                    "scrub-frequency-value",
-                                                    (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set dict for "
-                                                 "bitrot");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
+    if (!strcmp(words[3], "scrub-frequency")) {
+        if (!words[4]) {
+            cli_err("Missing scrub-frequency value");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_freq_values);
+            if (!w) {
+                cli_err("Invalid frequency option for bitrot");
+                ret = -1;
+                goto out;
+            } else {
+                type = GF_BITROT_OPTION_TYPE_SCRUB_FREQ;
+                ret = dict_set_str(dict, "scrub-frequency-value",
+                                   (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set dict for "
+                        "bitrot");
+                    goto out;
                 }
+                goto set_type;
+            }
         }
+    }
 
-        if (!strcmp (words[3], "scrub")) {
-                if (!words[4]) {
-                        cli_err ("Missing scrub value for bitrot option");
-                        ret = -1;
-                        goto out;
+    if (!strcmp(words[3], "scrub")) {
+        if (!words[4]) {
+            cli_err("Missing scrub value for bitrot option");
+            ret = -1;
+            goto out;
+        } else {
+            w = str_getunamb(words[4], scrub_values);
+            if (!w) {
+                cli_err("Invalid scrub option for bitrot");
+                ret = -1;
+                goto out;
+            } else {
+                if (strcmp(words[4], "status") == 0) {
+                    type = GF_BITROT_CMD_SCRUB_STATUS;
+                } else if (strcmp(words[4], "ondemand") == 0) {
+                    type = GF_BITROT_CMD_SCRUB_ONDEMAND;
                 } else {
-                        w = str_getunamb (words[4], scrub_values);
-                        if (!w) {
-                                cli_err ("Invalid scrub option for bitrot");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                if (strcmp (words[4], "status") == 0) {
-                                        type = GF_BITROT_CMD_SCRUB_STATUS;
-                                } else if (strcmp (words[4], "ondemand") == 0) {
-                                        type = GF_BITROT_CMD_SCRUB_ONDEMAND;
-                                } else {
-                                        type = GF_BITROT_OPTION_TYPE_SCRUB;
-                                }
-                                ret =  dict_set_str (dict, "scrub-value",
-                                                    (char *) words[4]);
-                                if (ret) {
-                                        cli_out ("Failed to set dict for "
-                                                 "bitrot");
-                                        goto out;
-                                }
-                                goto set_type;
-                        }
+                    type = GF_BITROT_OPTION_TYPE_SCRUB;
                 }
+                ret = dict_set_str(dict, "scrub-value", (char *)words[4]);
+                if (ret) {
+                    cli_out(
+                        "Failed to set dict for "
+                        "bitrot");
+                    goto out;
+                }
+                goto set_type;
+            }
         }
+    }
 
-        if (!strcmp (words[3], "signing-time")) {
-                if (!words[4]) {
-                        cli_err ("Missing signing-time value for bitrot "
-                                 "option");
-                        ret = -1;
-                        goto out;
-                } else {
-                        type = GF_BITROT_OPTION_TYPE_EXPIRY_TIME;
-
-                        expiry_time = strtol (words[4], NULL, 0);
-                        if (expiry_time < 1) {
-                                cli_err ("Expiry time  value should not be less"
-                                         " than 1");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = dict_set_uint32 (dict, "expiry-time",
-                                               (unsigned int) expiry_time);
-                        if (ret) {
-                                cli_out ("Failed to set dict for bitrot");
-                                goto out;
-                        }
-                        goto set_type;
-                }
+    if (!strcmp(words[3], "signing-time")) {
+        if (!words[4]) {
+            cli_err(
+                "Missing signing-time value for bitrot "
+                "option");
+            ret = -1;
+            goto out;
         } else {
-                cli_err ("Invalid option %s for bitrot. Please enter valid "
-                         "bitrot option", words[3]);
+            type = GF_BITROT_OPTION_TYPE_EXPIRY_TIME;
+
+            expiry_time = strtol(words[4], NULL, 0);
+            if (expiry_time < 1) {
+                cli_err(
+                    "Expiry time  value should not be less"
+                    " than 1");
                 ret = -1;
                 goto out;
+            }
+
+            ret = dict_set_uint32(dict, "expiry-time",
+                                  (unsigned int)expiry_time);
+            if (ret) {
+                cli_out("Failed to set dict for bitrot");
+                goto out;
+            }
+            goto set_type;
         }
+    } else {
+        cli_err(
+            "Invalid option %s for bitrot. Please enter valid "
+            "bitrot option",
+            words[3]);
+        ret = -1;
+        goto out;
+    }
 
 set_type:
-        ret = dict_set_int32 (dict, "type", type);
-        if (ret < 0)
-                goto out;
+    ret = dict_set_int32(dict, "type", type);
+    if (ret < 0)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 
 out:
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to parse bitrot command");
-                if (dict)
-                        dict_unref (dict);
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to parse bitrot command");
+        if (dict)
+            dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-peer.c b/cli/src/cli-cmd-peer.c
index a50ea7c66b5..e0a38904a81 100644
--- a/cli/src/cli-cmd-peer.c
+++ b/cli/src/cli-cmd-peer.c
@@ -24,292 +24,282 @@ extern struct rpc_clnt *global_rpc;
 
 extern rpc_clnt_prog_t *cli_rpc_prog;
 
-int cli_cmd_peer_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+int
+cli_cmd_peer_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                       const char **words, int wordcount);
 
 int
-cli_cmd_peer_probe_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_peer_probe_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        if (!(wordcount == 3)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROBE];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_set_str (dict, "hostname", (char *)words[2]);
-        if (ret)
-                goto out;
-
-        ret = valid_internet_address ((char *) words[2], _gf_false);
-        if (ret == 1) {
-                ret = 0;
-        } else {
-                cli_out ("%s is an invalid address", words[2]);
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                ret = -1;
-                goto out;
-        }
-/*        if (words[3]) {
-                ret = dict_set_str (dict, "port", (char *)words[3]);
-                if (ret)
-                        goto out;
-        }
-*/
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (!(wordcount == 3)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROBE];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret)
+        goto out;
+
+    ret = valid_internet_address((char *)words[2], _gf_false);
+    if (ret == 1) {
+        ret = 0;
+    } else {
+        cli_out("%s is an invalid address", words[2]);
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        ret = -1;
+        goto out;
+    }
+    /*        if (words[3]) {
+                    ret = dict_set_str (dict, "port", (char *)words[3]);
+                    if (ret)
+                            goto out;
+            }
+    */
+
+    CLI_LOCAL_INIT(local, words, frame, dict);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer probe failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer probe failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_PEER_ATTACH, "host=%s", (char *)words[2]);
-        }
+    if (ret == 0) {
+        gf_event(EVENT_PEER_ATTACH, "host=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmd_peer_deprobe_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_peer_deprobe_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                   ret   = -1;
-        rpc_clnt_procedure_t *proc  = NULL;
-        call_frame_t         *frame = NULL;
-        dict_t               *dict  = NULL;
-        int                  flags = 0;
-        int                  sent = 0;
-        int                  parse_error = 0;
-        cli_local_t          *local = NULL;
-
-        if ((wordcount < 3) || (wordcount > 4)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int flags = 0;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if ((wordcount < 3) || (wordcount > 4)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEPROBE];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret)
+        goto out;
+
+    /*        if (words[3]) {
+                    ret = dict_set_str (dict, "port", (char *)words[3]);
+                    if (ret)
+                            goto out;
+            }
+    */
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3]))
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
         }
+    }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEPROBE];
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-
-        ret = dict_set_str (dict, "hostname", (char *)words[2]);
-        if (ret)
-                goto out;
-
-/*        if (words[3]) {
-                ret = dict_set_str (dict, "port", (char *)words[3]);
-                if (ret)
-                        goto out;
-        }
-*/
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3]))
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer detach failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer detach failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_PEER_DETACH, "host=%s", (char *)words[2]);
-        }
+    if (ret == 0) {
+        gf_event(EVENT_PEER_DETACH, "host=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_peer_status_cbk (struct cli_state *state, struct cli_cmd_word *word,
+cli_cmd_peer_status_cbk(struct cli_state *state, struct cli_cmd_word *word,
                         const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, (void *)GF_CLI_LIST_PEERS);
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, (void *)GF_CLI_LIST_PEERS);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Peer status failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Peer status failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_pool_list_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_pool_list_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_FRIENDS];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS,
-                                (void *)GF_CLI_LIST_POOL_NODES);
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, (void *)GF_CLI_LIST_POOL_NODES);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_err ("pool list: command execution failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_err("pool list: command execution failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 struct cli_cmd cli_probe_cmds[] = {
-        { "peer probe { <HOSTNAME> | <IP-address> }",
-          cli_cmd_peer_probe_cbk,
-          "probe peer specified by <HOSTNAME>"},
+    {"peer probe { <HOSTNAME> | <IP-address> }", cli_cmd_peer_probe_cbk,
+     "probe peer specified by <HOSTNAME>"},
 
-        { "peer detach { <HOSTNAME> | <IP-address> } [force]",
-          cli_cmd_peer_deprobe_cbk,
-          "detach peer specified by <HOSTNAME>"},
+    {"peer detach { <HOSTNAME> | <IP-address> } [force]",
+     cli_cmd_peer_deprobe_cbk, "detach peer specified by <HOSTNAME>"},
 
-        { "peer status",
-          cli_cmd_peer_status_cbk,
-          "list status of peers"},
+    {"peer status", cli_cmd_peer_status_cbk, "list status of peers"},
 
-	{ "peer help",
-           cli_cmd_peer_help_cbk,
-           "display help for peer commands"},
+    {"peer help", cli_cmd_peer_help_cbk, "display help for peer commands"},
 
-        { "pool list",
-          cli_cmd_pool_list_cbk,
-          "list all the nodes in the pool (including localhost)"},
+    {"pool list", cli_cmd_pool_list_cbk,
+     "list all the nodes in the pool (including localhost)"},
 
-        { NULL, NULL, NULL }
-};
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_peer_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_peer_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                       const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *probe_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *probe_cmd = NULL;
+    int count = 0;
 
-        cli_out ("\ngluster peer commands");
-        cli_out ("======================\n");
+    cli_out("\ngluster peer commands");
+    cli_out("======================\n");
 
-        cmd = GF_MALLOC (sizeof (cli_probe_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, cli_probe_cmds, sizeof (cli_probe_cmds));
-        count = (sizeof (cli_probe_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(cli_probe_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, cli_probe_cmds, sizeof(cli_probe_cmds));
+    count = (sizeof(cli_probe_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        for (probe_cmd = cmd; probe_cmd->pattern; probe_cmd++)
-                cli_out ("%s - %s", probe_cmd->pattern, probe_cmd->desc);
+    for (probe_cmd = cmd; probe_cmd->pattern; probe_cmd++)
+        cli_out("%s - %s", probe_cmd->pattern, probe_cmd->desc);
 
-        GF_FREE (cmd);
+    GF_FREE(cmd);
 
-        cli_out ("\n");
-        return 0;
+    cli_out("\n");
+    return 0;
 }
 
 int
-cli_cmd_probe_register (struct cli_state *state)
+cli_cmd_probe_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_probe_cmds; cmd->pattern; cmd++) {
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = cli_probe_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-snapshot.c b/cli/src/cli-cmd-snapshot.c
index 64cbd42ce5a..814ab82f6eb 100644
--- a/cli/src/cli-cmd-snapshot.c
+++ b/cli/src/cli-cmd-snapshot.c
@@ -20,146 +20,118 @@
 extern rpc_clnt_prog_t *cli_rpc_prog;
 
 int
-cli_cmd_snapshot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                           const char **words, int wordcount);
+cli_cmd_snapshot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                          const char **words, int wordcount);
 
 int
-cli_cmd_snapshot_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_snapshot_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                      ret       = 0;
-        int                      parse_err = 0;
-        dict_t                  *options   = NULL;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        call_frame_t            *frame     = NULL;
-        cli_local_t             *local     = NULL;
-
-        proc = &cli_rpc_prog->proctable [GLUSTER_CLI_SNAP];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (frame == NULL) {
-                ret = -1;
-                goto out;
+    int ret = 0;
+    int parse_err = 0;
+    dict_t *options = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SNAP];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (frame == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    /* Parses the command entered by the user */
+    ret = cli_cmd_snapshot_parse(words, wordcount, &options, state);
+    if (ret) {
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+        } else {
+            /* User might have cancelled the snapshot operation */
+            ret = 0;
         }
+        goto out;
+    }
 
-        /* Parses the command entered by the user */
-        ret = cli_cmd_snapshot_parse (words, wordcount, &options, state);
-        if (ret) {
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                } else {
-                        /* User might have cancelled the snapshot operation */
-                        ret = 0;
-                }
-                goto out;
-        }
-
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret && parse_err == 0)
-                cli_out ("Snapshot command failed");
+    if (ret && parse_err == 0)
+        cli_out("Snapshot command failed");
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 struct cli_cmd snapshot_cmds[] = {
-        { "snapshot help",
-          cli_cmd_snapshot_help_cbk,
-          "display help for snapshot commands"
-        },
-        { "snapshot create <snapname> <volname> [no-timestamp] "
-                "[description <description>] [force]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Create."
-        },
-        { "snapshot clone <clonename> <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Clone."
-        },
-        { "snapshot restore <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Restore."
-        },
-        { "snapshot status [(snapname | volume <volname>)]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Status."
-        },
-        { "snapshot info [(snapname | volume <volname>)]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Info."
-        },
-        { "snapshot list [volname]",
-          cli_cmd_snapshot_cbk,
-          "Snapshot List."
-        },
-        {"snapshot config [volname] ([snap-max-hard-limit <count>] "
-         "[snap-max-soft-limit <percent>]) "
-         "| ([auto-delete <enable|disable>])"
-         "| ([activate-on-create <enable|disable>])",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Config."
-        },
-        {"snapshot delete (all | snapname | volume <volname>)",
-          cli_cmd_snapshot_cbk,
-          "Snapshot Delete."
-        },
-        {"snapshot activate <snapname> [force]",
-          cli_cmd_snapshot_cbk,
-          "Activate snapshot volume."
-        },
-        {"snapshot deactivate <snapname>",
-          cli_cmd_snapshot_cbk,
-          "Deactivate snapshot volume."
-        },
-        { NULL, NULL, NULL }
-};
+    {"snapshot help", cli_cmd_snapshot_help_cbk,
+     "display help for snapshot commands"},
+    {"snapshot create <snapname> <volname> [no-timestamp] "
+     "[description <description>] [force]",
+     cli_cmd_snapshot_cbk, "Snapshot Create."},
+    {"snapshot clone <clonename> <snapname>", cli_cmd_snapshot_cbk,
+     "Snapshot Clone."},
+    {"snapshot restore <snapname>", cli_cmd_snapshot_cbk, "Snapshot Restore."},
+    {"snapshot status [(snapname | volume <volname>)]", cli_cmd_snapshot_cbk,
+     "Snapshot Status."},
+    {"snapshot info [(snapname | volume <volname>)]", cli_cmd_snapshot_cbk,
+     "Snapshot Info."},
+    {"snapshot list [volname]", cli_cmd_snapshot_cbk, "Snapshot List."},
+    {"snapshot config [volname] ([snap-max-hard-limit <count>] "
+     "[snap-max-soft-limit <percent>]) "
+     "| ([auto-delete <enable|disable>])"
+     "| ([activate-on-create <enable|disable>])",
+     cli_cmd_snapshot_cbk, "Snapshot Config."},
+    {"snapshot delete (all | snapname | volume <volname>)",
+     cli_cmd_snapshot_cbk, "Snapshot Delete."},
+    {"snapshot activate <snapname> [force]", cli_cmd_snapshot_cbk,
+     "Activate snapshot volume."},
+    {"snapshot deactivate <snapname>", cli_cmd_snapshot_cbk,
+     "Deactivate snapshot volume."},
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_snapshot_help_cbk (struct cli_state *state,
-                           struct cli_cmd_word *in_word,
-                           const char **words,
-                           int wordcount)
+cli_cmd_snapshot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                          const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd      = NULL;
-        struct cli_cmd        *snap_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *snap_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_MALLOC (sizeof (snapshot_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, snapshot_cmds, sizeof (snapshot_cmds));
-        count = (sizeof (snapshot_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(snapshot_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, snapshot_cmds, sizeof(snapshot_cmds));
+    count = (sizeof(snapshot_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster snapshot commands");
-        cli_out ("=========================\n");
+    cli_out("\ngluster snapshot commands");
+    cli_out("=========================\n");
 
-        for (snap_cmd = cmd; snap_cmd->pattern; snap_cmd++)
-                if (_gf_false == snap_cmd->disable)
-                        cli_out ("%s - %s", snap_cmd->pattern, snap_cmd->desc);
-        cli_out ("\n");
+    for (snap_cmd = cmd; snap_cmd->pattern; snap_cmd++)
+        if (_gf_false == snap_cmd->disable)
+            cli_out("%s - %s", snap_cmd->pattern, snap_cmd->desc);
+    cli_out("\n");
 
-        GF_FREE (cmd);
-        return 0;
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_snapshot_register (struct cli_state *state)
+cli_cmd_snapshot_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = snapshot_cmds; cmd->pattern; cmd++) {
-
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
+
+    for (cmd = snapshot_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-system.c b/cli/src/cli-cmd-system.c
index 995e1b1ad5c..96b229582fb 100644
--- a/cli/src/cli-cmd-system.c
+++ b/cli/src/cli-cmd-system.c
@@ -18,604 +18,587 @@
 #include "cli-mem-types.h"
 #include "protocol-common.h"
 
-
 extern struct rpc_clnt *global_rpc;
 
 extern rpc_clnt_prog_t *cli_rpc_prog;
 
-int cli_cmd_system_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                             const char **words, int wordcount);
+int
+cli_cmd_system_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
 
-int cli_cmd_copy_file_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount);
+int
+cli_cmd_copy_file_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount);
 
-int cli_cmd_sys_exec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount);
+int
+cli_cmd_sys_exec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount);
 
 int
-cli_cmd_getspec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                     const char **words, int wordcount)
+cli_cmd_getspec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volid", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "volid", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETSPEC];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETSPEC];
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (!proc && ret) {
-                if (dict)
-                        dict_unref (dict);
-                if (wordcount > 1)
-                        cli_out ("Fetching spec for volume %s failed",
-                                 (char *)words[2]);
-        }
+    if (!proc && ret) {
+        if (dict)
+            dict_unref(dict);
+        if (wordcount > 1)
+            cli_out("Fetching spec for volume %s failed", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_pmap_b2p_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                 const char **words, int wordcount)
+cli_cmd_pmap_b2p_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "brick", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "brick", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PMAP_PORTBYBRICK];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PMAP_PORTBYBRICK];
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (!proc && ret) {
-                if (dict)
-                        dict_unref (dict);
-                if (wordcount > 1)
-                        cli_out ("Fetching spec for volume %s failed",
-                                 (char *)words[3]);
-        }
+    if (!proc && ret) {
+        if (dict)
+            dict_unref(dict);
+        if (wordcount > 1)
+            cli_out("Fetching spec for volume %s failed", (char *)words[3]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_fsm_log_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                     const char **words, int wordcount)
+cli_cmd_fsm_log_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                    const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        char                            *name = "";
-
-        if ((wordcount != 4) && (wordcount != 3)) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        if (wordcount == 4)
-                name = (char*)words[3];
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_FSM_LOG];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, (void*)name);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *name = "";
+
+    if ((wordcount != 4) && (wordcount != 3)) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    if (wordcount == 4)
+        name = (char *)words[3];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_FSM_LOG];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, (void *)name);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_getwd_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_getwd_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-
-        if (wordcount != 2) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETWD];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, NULL);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+
+    if (wordcount != 2) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GETWD];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, NULL);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static dict_t *
-make_seq_dict (int argc, char **argv)
+make_seq_dict(int argc, char **argv)
 {
-        char index[] = "4294967296"; // 1<<32
-        int i        = 0;
-        int ret      = 0;
-        dict_t *dict = dict_new ();
-
-        if (!dict)
-                return NULL;
-
-        for (i = 0; i < argc; i++) {
-                snprintf(index, sizeof(index), "%d", i);
-                ret = dict_set_str (dict, index, argv[i]);
-                if (ret == -1)
-                        break;
-        }
-
-        if (ret) {
-                dict_unref (dict);
-                dict = NULL;
-        }
-
-        return dict;
+    char index[] = "4294967296";  // 1<<32
+    int i = 0;
+    int ret = 0;
+    dict_t *dict = dict_new();
+
+    if (!dict)
+        return NULL;
+
+    for (i = 0; i < argc; i++) {
+        snprintf(index, sizeof(index), "%d", i);
+        ret = dict_set_str(dict, index, argv[i]);
+        if (ret == -1)
+            break;
+    }
+
+    if (ret) {
+        dict_unref(dict);
+        dict = NULL;
+    }
+
+    return dict;
 }
 
 int
-cli_cmd_mount_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_mount_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame        = NULL;
-        int ret                    = -1;
-        dict_t *dict               = NULL;
-        void *dataa[]              = {NULL, NULL};
-
-        if (wordcount < 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = make_seq_dict (wordcount - 3, (char **)words + 3);
-        if (!dict)
-                goto out;
-
-        dataa[0] = (void *)words[2];
-        dataa[1] = dict;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_MOUNT];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, dataa);
-        }
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    dict_t *dict = NULL;
+    void *dataa[] = {NULL, NULL};
+
+    if (wordcount < 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = make_seq_dict(wordcount - 3, (char **)words + 3);
+    if (!dict)
+        goto out;
+
+    dataa[0] = (void *)words[2];
+    dataa[1] = dict;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_MOUNT];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, dataa);
+    }
 
- out:
-        if (dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        dict_unref(dict);
 
-        if (!proc && ret)
-                cli_out ("Mount command failed");
+    if (!proc && ret)
+        cli_out("Mount command failed");
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_umount_cbk (struct cli_state *state, struct cli_cmd_word *word,
+cli_cmd_umount_cbk(struct cli_state *state, struct cli_cmd_word *word,
                    const char **words, int wordcount)
 {
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame        = NULL;
-        int ret                    = -1;
-        dict_t *dict               = NULL;
-
-        if (!(wordcount == 3 ||
-              (wordcount == 4 && strcmp (words[3], "lazy") == 0))) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_set_str (dict, "path", (char *)words[2]);
-        if (ret != 0)
-                goto out;
-        ret = dict_set_int32 (dict, "lazy", wordcount == 4);
-        if (ret != 0)
-                goto out;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UMOUNT];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                ret = proc->fn (frame, THIS, dict);
-        }
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    dict_t *dict = NULL;
+
+    if (!(wordcount == 3 ||
+          (wordcount == 4 && strcmp(words[3], "lazy") == 0))) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_set_str(dict, "path", (char *)words[2]);
+    if (ret != 0)
+        goto out;
+    ret = dict_set_int32(dict, "lazy", wordcount == 4);
+    if (ret != 0)
+        goto out;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UMOUNT];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        ret = proc->fn(frame, THIS, dict);
+    }
 
- out:
-        if (dict)
-                dict_unref (dict);
+out:
+    if (dict)
+        dict_unref(dict);
 
-        if (!proc && ret)
-                cli_out ("Umount command failed");
+    if (!proc && ret)
+        cli_out("Umount command failed");
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_uuid_get_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_uuid_get_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        int                     ret = -1;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict  = NULL;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        cli_local_t             *local = NULL;
-        xlator_t                *this  = NULL;
-
-        this = THIS;
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_GET];
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        CLI_LOCAL_INIT (local, words, frame, dict);
-        if (proc->fn)
-                ret = proc->fn (frame, this, dict);
+    int ret = -1;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_GET];
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    CLI_LOCAL_INIT(local, words, frame, dict);
+    if (proc->fn)
+        ret = proc->fn(frame, this, dict);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("uuid get failed");
-        }
-
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("uuid get failed");
+    }
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_uuid_reset_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_uuid_reset_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        char                    *question = NULL;
-        cli_local_t             *local = NULL;
-        dict_t                  *dict  = NULL;
-        xlator_t                *this  = NULL;
-
-        question = "Resetting uuid changes the uuid of local glusterd. "
-                   "Do you want to continue?";
-
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_RESET];
-
-        this = THIS;
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-        CLI_LOCAL_INIT (local, words, frame, dict);
-        answer = cli_cmd_get_confirmation (state, question);
-
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
-
-        //send NULL as argument since no dictionary is sent to glusterd
-        if (proc->fn) {
-                ret = proc->fn (frame, this, dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    char *question = NULL;
+    cli_local_t *local = NULL;
+    dict_t *dict = NULL;
+    xlator_t *this = NULL;
+
+    question =
+        "Resetting uuid changes the uuid of local glusterd. "
+        "Do you want to continue?";
+
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_UUID_RESET];
+
+    this = THIS;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+    CLI_LOCAL_INIT(local, words, frame, dict);
+    answer = cli_cmd_get_confirmation(state, question);
+
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
+
+    // send NULL as argument since no dictionary is sent to glusterd
+    if (proc->fn) {
+        ret = proc->fn(frame, this, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("uuid reset failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("uuid reset failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 struct cli_cmd cli_system_cmds[] = {
-        { "system:: getspec <VOLNAME>",
-          cli_cmd_getspec_cbk,
-          "fetch the volume file for the volume <VOLNAME>"},
+    {"system:: getspec <VOLNAME>", cli_cmd_getspec_cbk,
+     "fetch the volume file for the volume <VOLNAME>"},
 
-        { "system:: portmap brick2port <BRICK>",
-          cli_cmd_pmap_b2p_cbk,
-          "query which port <BRICK> listens on"},
+    {"system:: portmap brick2port <BRICK>", cli_cmd_pmap_b2p_cbk,
+     "query which port <BRICK> listens on"},
 
-        { "system:: fsm log [<peer-name>]",
-          cli_cmd_fsm_log_cbk,
-          "display fsm transitions"},
+    {"system:: fsm log [<peer-name>]", cli_cmd_fsm_log_cbk,
+     "display fsm transitions"},
 
-        { "system:: getwd",
-          cli_cmd_getwd_cbk,
-          "query glusterd work directory"},
+    {"system:: getwd", cli_cmd_getwd_cbk, "query glusterd work directory"},
 
-        { "system:: mount <label> <args...>",
-          cli_cmd_mount_cbk,
-          "request a mount"},
+    {"system:: mount <label> <args...>", cli_cmd_mount_cbk, "request a mount"},
 
-        { "system:: umount <path> [lazy]",
-          cli_cmd_umount_cbk,
-          "request an umount"},
+    {"system:: umount <path> [lazy]", cli_cmd_umount_cbk, "request an umount"},
 
-        { "system:: uuid get",
-          cli_cmd_uuid_get_cbk,
-          "get uuid of glusterd"},
+    {"system:: uuid get", cli_cmd_uuid_get_cbk, "get uuid of glusterd"},
 
-        { "system:: uuid reset",
-          cli_cmd_uuid_reset_cbk,
-          "reset the uuid of glusterd"},
+    {"system:: uuid reset", cli_cmd_uuid_reset_cbk,
+     "reset the uuid of glusterd"},
 
-        { "system:: help",
-           cli_cmd_system_help_cbk,
-           "display help for system commands"},
+    {"system:: help", cli_cmd_system_help_cbk,
+     "display help for system commands"},
 
-        { "system:: copy file [<filename>]",
-           cli_cmd_copy_file_cbk,
-           "Copy file from current node's $working_dir to "
-           "$working_dir of all cluster nodes"},
+    {"system:: copy file [<filename>]", cli_cmd_copy_file_cbk,
+     "Copy file from current node's $working_dir to "
+     "$working_dir of all cluster nodes"},
 
-        { "system:: execute <command> <args>",
-           cli_cmd_sys_exec_cbk,
-           "Execute the command on all the nodes "
-           "in the cluster and display their output."},
+    {"system:: execute <command> <args>", cli_cmd_sys_exec_cbk,
+     "Execute the command on all the nodes "
+     "in the cluster and display their output."},
 
-        { NULL, NULL, NULL }
-};
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_sys_exec_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                      const char **words, int wordcount)
+cli_cmd_sys_exec_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                     const char **words, int wordcount)
 {
-        char                   cmd_arg_name[PATH_MAX] = "";
-        char                  *command                = NULL;
-        char                  *saveptr                = NULL;
-        char                  *tmp                    = NULL;
-        int                    ret                    = -1;
-        int                    i                      = -1;
-        int                    cmd_args_count         = 0;
-        int                    in_cmd_args_count      = 0;
-        rpc_clnt_procedure_t  *proc                   = NULL;
-        call_frame_t          *frame                  = NULL;
-        dict_t                *dict                   = NULL;
-        cli_local_t           *local                  = NULL;
-
-        if (wordcount < 3) {
-                cli_usage_out (word->pattern);
+    char cmd_arg_name[PATH_MAX] = "";
+    char *command = NULL;
+    char *saveptr = NULL;
+    char *tmp = NULL;
+    int ret = -1;
+    int i = -1;
+    int cmd_args_count = 0;
+    int in_cmd_args_count = 0;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+
+    if (wordcount < 3) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    command = strtok_r((char *)words[2], " ", &saveptr);
+    if (command == NULL) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to parse command");
+        goto out;
+    }
+    do {
+        tmp = strtok_r(NULL, " ", &saveptr);
+        if (tmp) {
+            in_cmd_args_count++;
+            snprintf(cmd_arg_name, sizeof(cmd_arg_name), "cmd_arg_%d",
+                     in_cmd_args_count);
+            ret = dict_set_str(dict, cmd_arg_name, tmp);
+            if (ret) {
+                gf_log("", GF_LOG_ERROR,
+                       "Unable to set "
+                       "%s in dict",
+                       cmd_arg_name);
                 goto out;
+            }
         }
+    } while (tmp);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    cmd_args_count = wordcount - 3;
 
-        command = strtok_r ((char *)words[2], " ", &saveptr);
-        if (command == NULL) {
-                gf_log("cli", GF_LOG_ERROR, "Failed to parse command");
-                goto out;
-        }
-        do {
-                tmp = strtok_r (NULL, " ", &saveptr);
-                if (tmp) {
-                        in_cmd_args_count++;
-                        snprintf (cmd_arg_name, sizeof(cmd_arg_name),
-                                  "cmd_arg_%d", in_cmd_args_count);
-                        ret = dict_set_str (dict, cmd_arg_name, tmp);
-                        if (ret) {
-                                gf_log ("", GF_LOG_ERROR, "Unable to set "
-                                        "%s in dict", cmd_arg_name);
-                                goto out;
-                        }
-                }
-        } while (tmp);
-
-        cmd_args_count = wordcount - 3;
-
-        ret = dict_set_str (dict, "command", command);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to set command in dict");
-                goto out;
-        }
+    ret = dict_set_str(dict, "command", command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set command in dict");
+        goto out;
+    }
 
-        for (i=1; i <= cmd_args_count; i++) {
-                in_cmd_args_count++;
-                snprintf (cmd_arg_name, sizeof(cmd_arg_name),
-                          "cmd_arg_%d", in_cmd_args_count);
-                ret = dict_set_str (dict, cmd_arg_name,
-                                    (char *)words[2+i]);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Unable to set %s in dict",
-                               cmd_arg_name);
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (dict, "cmd_args_count", in_cmd_args_count);
+    for (i = 1; i <= cmd_args_count; i++) {
+        in_cmd_args_count++;
+        snprintf(cmd_arg_name, sizeof(cmd_arg_name), "cmd_arg_%d",
+                 in_cmd_args_count);
+        ret = dict_set_str(dict, cmd_arg_name, (char *)words[2 + i]);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Unable to set cmd_args_count in dict");
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "volname", "N/A");
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to set volname in dict");
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYS_EXEC];
-        if (proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                CLI_LOCAL_INIT (local, words, frame, dict);
-                ret = proc->fn (frame, THIS, (void*)dict);
-
-                /* proc->fn is processed synchronously, which means that the
-                 * execution flow won't return here until the operation is
-                 * fully processed, including any related callback. For this
-                 * reason, it's safe to destroy the stack here, since no one
-                 * can still be using it. Additionally, it's not easy to move
-                 * the stack destroy to the callback executed after completion
-                 * of the operation because there are multiple things than can
-                 * fail even before having queued the callback, so we would
-                 * still need to destroy the stack if proc->fn returns an
-                 * error. */
-                CLI_STACK_DESTROY(frame);
-                dict = NULL;
-        }
+            gf_log("", GF_LOG_ERROR, "Unable to set %s in dict", cmd_arg_name);
+            goto out;
+        }
+    }
+
+    ret = dict_set_int32(dict, "cmd_args_count", in_cmd_args_count);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set cmd_args_count in dict");
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "volname", "N/A");
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to set volname in dict");
+        goto out;
+    }
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYS_EXEC];
+    if (proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        CLI_LOCAL_INIT(local, words, frame, dict);
+        ret = proc->fn(frame, THIS, (void *)dict);
+
+        /* proc->fn is processed synchronously, which means that the
+         * execution flow won't return here until the operation is
+         * fully processed, including any related callback. For this
+         * reason, it's safe to destroy the stack here, since no one
+         * can still be using it. Additionally, it's not easy to move
+         * the stack destroy to the callback executed after completion
+         * of the operation because there are multiple things than can
+         * fail even before having queued the callback, so we would
+         * still need to destroy the stack if proc->fn returns an
+         * error. */
+        CLI_STACK_DESTROY(frame);
+        dict = NULL;
+    }
 out:
-        if (dict != NULL) {
-                dict_unref(dict);
-        }
+    if (dict != NULL) {
+        dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_copy_file_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                       const char **words, int wordcount)
+cli_cmd_copy_file_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                      const char **words, int wordcount)
 {
-        int                    ret      = -1;
-        rpc_clnt_procedure_t  *proc     = NULL;
-        call_frame_t          *frame    = NULL;
-        char                  *filename = "";
-        dict_t                *dict     = NULL;
-        cli_local_t           *local    = NULL;
-
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        filename = (char*)words[3];
-        ret = dict_set_str (dict, "source", filename);
-        if (ret)
-                 gf_log ("", GF_LOG_ERROR, "Unable to set filename in dict");
-
-        ret = dict_set_str (dict, "volname", "N/A");
-        if (ret)
-                 gf_log ("", GF_LOG_ERROR, "Unable to set volname in dict");
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_COPY_FILE];
-        if (proc && proc->fn) {
-                frame = create_frame (THIS, THIS->ctx->pool);
-                if (!frame)
-                        goto out;
-                CLI_LOCAL_INIT (local, words, frame, dict);
-                ret = proc->fn (frame, THIS, (void*)dict);
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *filename = "";
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    filename = (char *)words[3];
+    ret = dict_set_str(dict, "source", filename);
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "Unable to set filename in dict");
+
+    ret = dict_set_str(dict, "volname", "N/A");
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "Unable to set volname in dict");
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_COPY_FILE];
+    if (proc && proc->fn) {
+        frame = create_frame(THIS, THIS->ctx->pool);
+        if (!frame)
+            goto out;
+        CLI_LOCAL_INIT(local, words, frame, dict);
+        ret = proc->fn(frame, THIS, (void *)dict);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_system_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_system_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd = NULL;
-        struct cli_cmd        *system_cmd = NULL;
-        int                   count     = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *system_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_MALLOC (sizeof (cli_system_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, cli_system_cmds, sizeof (cli_system_cmds));
-        count = (sizeof (cli_system_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(cli_system_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, cli_system_cmds, sizeof(cli_system_cmds));
+    count = (sizeof(cli_system_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        for (system_cmd = cmd; system_cmd->pattern; system_cmd++)
-                cli_out ("%s - %s", system_cmd->pattern, system_cmd->desc);
+    for (system_cmd = cmd; system_cmd->pattern; system_cmd++)
+        cli_out("%s - %s", system_cmd->pattern, system_cmd->desc);
 
-        GF_FREE (cmd);
-        return 0;
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_system_register (struct cli_state *state)
+cli_cmd_system_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
-
-        for (cmd = cli_system_cmds; cmd->pattern; cmd++) {
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = cli_system_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd-volume.c b/cli/src/cli-cmd-volume.c
index 3d075a326bf..ab17729d182 100644
--- a/cli/src/cli-cmd-volume.c
+++ b/cli/src/cli-cmd-volume.c
@@ -35,1433 +35,1431 @@ extern rpc_clnt_prog_t *cli_rpc_prog;
 extern rpc_clnt_prog_t cli_quotad_clnt;
 
 int
-cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
-
-int
-cli_cmd_bitrot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount);
+cli_cmd_volume_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount);
 
 int
-cli_cmd_quota_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_bitrot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                         const char **words, int wordcount);
 
 int
-cli_cmd_tier_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
+cli_cmd_quota_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
                        const char **words, int wordcount);
 
 int
-cli_cmd_volume_info_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
-{
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        cli_cmd_volume_get_ctx_t        ctx = {0,};
-        cli_local_t                     *local = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
+cli_cmd_tier_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                      const char **words, int wordcount);
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+int
+cli_cmd_volume_info_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
+{
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_cmd_volume_get_ctx_t ctx = {
+        0,
+    };
+    cli_local_t *local = NULL;
+    int sent = 0;
+    int parse_error = 0;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if ((wordcount == 2)  || (wordcount == 3 &&
-                                  !strcmp (words[2], "all"))) {
-                ctx.flags = GF_CLI_GET_NEXT_VOLUME;
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME];
-        } else if (wordcount == 3) {
-                ctx.flags = GF_CLI_GET_VOLUME;
-                ctx.volname = (char *)words[2];
-                if (strlen (ctx.volname) > GD_VOLUME_NAME_MAX) {
-                        cli_out ("Invalid volume name");
-                        goto out;
-                }
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
-        } else {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                return -1;
+    if ((wordcount == 2) || (wordcount == 3 && !strcmp(words[2], "all"))) {
+        ctx.flags = GF_CLI_GET_NEXT_VOLUME;
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME];
+    } else if (wordcount == 3) {
+        ctx.flags = GF_CLI_GET_VOLUME;
+        ctx.volname = (char *)words[2];
+        if (strlen(ctx.volname) > GD_VOLUME_NAME_MAX) {
+            cli_out("Invalid volume name");
+            goto out;
         }
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
+    } else {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        return -1;
+    }
 
-        local = cli_local_get ();
+    local = cli_local_get();
 
-        if (!local)
-                goto out;
+    if (!local)
+        goto out;
 
-        local->get_vol.flags = ctx.flags;
-        if (ctx.volname)
-                local->get_vol.volname = gf_strdup (ctx.volname);
+    local->get_vol.flags = ctx.flags;
+    if (ctx.volname)
+        local->get_vol.volname = gf_strdup(ctx.volname);
 
-        frame->local = local;
+    frame->local = local;
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, &ctx);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, &ctx);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Getting Volume information failed!");
-        }
-
-        CLI_STACK_DESTROY (frame);
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Getting Volume information failed!");
+    }
 
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_sync_volume_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
+cli_cmd_sync_volume_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        cli_local_t             *local = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        const char              *question = "Sync volume may make data "
-                                            "inaccessible while the sync "
-                                            "is in progress. Do you want "
-                                            "to continue?";
-
-        if ((wordcount < 3) || (wordcount > 4)) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question =
+        "Sync volume may make data "
+        "inaccessible while the sync "
+        "is in progress. Do you want "
+        "to continue?";
+
+    if ((wordcount < 3) || (wordcount > 4)) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if ((wordcount == 3) || !strcmp(words[3], "all")) {
-                ret = dict_set_int32 (dict, "flags", (int32_t)
-                                      GF_CLI_SYNC_ALL);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "failed to set"
-                                "flag");
-                        goto out;
-                }
-        } else {
-                ret = dict_set_str (dict, "volname", (char *) words[3]);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "failed to set "
-                                "volume");
-                        goto out;
-                }
+    if ((wordcount == 3) || !strcmp(words[3], "all")) {
+        ret = dict_set_int32(dict, "flags", (int32_t)GF_CLI_SYNC_ALL);
+        if (ret) {
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set"
+                   "flag");
+            goto out;
         }
-
-        ret = dict_set_str (dict, "hostname", (char *) words[2]);
+    } else {
+        ret = dict_set_str(dict, "volname", (char *)words[3]);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to set hostname");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set "
+                   "volume");
+            goto out;
         }
+    }
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT)) {
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
+    ret = dict_set_str(dict, "hostname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to set hostname");
+        goto out;
+    }
+
+    if (!(state->mode & GLUSTER_MODE_SCRIPT)) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume sync failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume sync failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_create_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_create_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        char                    *trans_type = NULL;
-        char                    *bricks = NULL;
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    char *trans_type = NULL;
+    char *bricks = NULL;
+
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_create_parse (state, words, wordcount, &options,
-                                           &bricks);
+    ret = cli_cmd_volume_create_parse(state, words, wordcount, &options,
+                                      &bricks);
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = dict_get_str (options, "transport", &trans_type);
-        if (ret) {
-                gf_log("cli", GF_LOG_ERROR, "Unable to get transport type");
-                goto out;
-        }
+    ret = dict_get_str(options, "transport", &trans_type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get transport type");
+        goto out;
+    }
 
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set force "
+                   "option");
+            goto out;
         }
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume create failed");
-        }
-
-        if (ret == 0) {
-                gf_event (EVENT_VOLUME_CREATE, "name=%s;bricks=%s",
-                          (char *)words[2], bricks);
-        }
-
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume create failed");
+    }
+
+    if (ret == 0) {
+        gf_event(EVENT_VOLUME_CREATE, "name=%s;bricks=%s", (char *)words[2],
+                 bricks);
+    }
+
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
 int
-cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_delete_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *volname = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        const char              *question = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        dict_t                  *dict = NULL;
-
-        question = "Deleting volume will erase all information about the volume. "
-                   "Do you want to continue?";
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DELETE_VOLUME];
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    char *volname = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    const char *question = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    dict_t *dict = NULL;
+
+    question =
+        "Deleting volume will erase all information about the volume. "
+        "Do you want to continue?";
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DELETE_VOLUME];
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (wordcount != 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        volname = (char *)words[2];
+    if (wordcount != 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING, "dict set failed");
-                goto out;
-        }
+    volname = (char *)words[2];
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Deleting the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
-        }
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "dict set failed");
+        goto out;
+    }
+
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Deleting the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+    }
+
+    answer = cli_cmd_get_confirmation(state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
 
-        answer = cli_cmd_get_confirmation (state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume delete failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume delete failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0 && GF_ANSWER_YES == answer) {
-                gf_event (EVENT_VOLUME_DELETE, "name=%s", (char *)words[2]);
-        }
+    if (ret == 0 && GF_ANSWER_YES == answer) {
+        gf_event(EVENT_VOLUME_DELETE, "name=%s", (char *)words[2]);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_start_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        int                     flags = 0;
-        cli_local_t             *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    int flags = 0;
+    cli_local_t *local = NULL;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (wordcount < 3 || wordcount > 4) {
-               cli_usage_out (word->pattern);
-                parse_error = 1;
-               goto out;
-        }
+    if (wordcount < 3 || wordcount > 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict) {
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        goto out;
+    }
 
-        if (!words[2])
-                goto out;
+    if (!words[2])
+        goto out;
 
-        ret = dict_set_str (dict, "volname", (char *)words[2]);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "dict set failed");
-                goto out;
-        }
+    ret = dict_set_str(dict, "volname", (char *)words[2]);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3])) {
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
-        }
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                 gf_log (THIS->name, GF_LOG_ERROR,
-                         "dict set failed");
-                 goto out;
-        }
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3])) {
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        } else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
+        }
+    }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume start failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume start failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0) {
-                gf_event (EVENT_VOLUME_START, "name=%s;force=%d",
-                          (char *)words[2], (flags & GF_CLI_FLAG_OP_FORCE));
-        }
+    if (ret == 0) {
+        gf_event(EVENT_VOLUME_START, "name=%s;force=%d", (char *)words[2],
+                 (flags & GF_CLI_FLAG_OP_FORCE));
+    }
 
-        return ret;
+    return ret;
 }
 
 gf_answer_t
-cli_cmd_get_confirmation (struct cli_state *state, const char *question)
+cli_cmd_get_confirmation(struct cli_state *state, const char *question)
 {
-        char                    answer[5] = {'\0', };
-        int                     flush = '\0';
-        size_t			len;
+    char answer[5] = {
+        '\0',
+    };
+    int flush = '\0';
+    size_t len;
 
-        if (state->mode & GLUSTER_MODE_SCRIPT)
-                return GF_ANSWER_YES;
+    if (state->mode & GLUSTER_MODE_SCRIPT)
+        return GF_ANSWER_YES;
 
-	printf ("%s (y/n) ", question);
+    printf("%s (y/n) ", question);
 
-        if (fgets (answer, 4, stdin) == NULL) {
-                cli_out("gluster cli read error");
-                goto out;
-        }
+    if (fgets(answer, 4, stdin) == NULL) {
+        cli_out("gluster cli read error");
+        goto out;
+    }
 
-	len = strlen (answer);
+    len = strlen(answer);
 
-	if (len && answer [len - 1] == '\n'){
-		answer [--len] = '\0';
-	} else {
-		do{
-			flush = getchar ();
-		}while (flush != '\n');
-	}
+    if (len && answer[len - 1] == '\n') {
+        answer[--len] = '\0';
+    } else {
+        do {
+            flush = getchar();
+        } while (flush != '\n');
+    }
 
-	if (len > 3)
-		goto out;
+    if (len > 3)
+        goto out;
 
-	if (!strcasecmp (answer, "y") || !strcasecmp (answer, "yes"))
-		return GF_ANSWER_YES;
+    if (!strcasecmp(answer, "y") || !strcasecmp(answer, "yes"))
+        return GF_ANSWER_YES;
 
-	else if (!strcasecmp (answer, "n") || !strcasecmp (answer, "no"))
-		return GF_ANSWER_NO;
+    else if (!strcasecmp(answer, "n") || !strcasecmp(answer, "no"))
+        return GF_ANSWER_NO;
 
 out:
-	cli_out ("Invalid input, please enter y/n");
+    cli_out("Invalid input, please enter y/n");
 
-	return GF_ANSWER_NO;
+    return GF_ANSWER_NO;
 }
 
 int
-cli_cmd_volume_stop_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_stop_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     flags   = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *dict = NULL;
-        char                    *volname = NULL;
-        cli_local_t             *local = NULL;
-
-        const char *question = "Stopping volume will make its data inaccessible. "
-                               "Do you want to continue?";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if (wordcount < 3 || wordcount > 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        volname = (char*) words[2];
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int flags = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    cli_local_t *local = NULL;
+
+    const char *question =
+        "Stopping volume will make its data inaccessible. "
+        "Do you want to continue?";
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        dict = dict_new ();
-        ret = dict_set_str (dict, "volname", volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "dict set failed");
-                goto out;
-        }
+    if (wordcount < 3 || wordcount > 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Stopping the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
-        }
+    volname = (char *)words[2];
 
-        if (wordcount == 4) {
-                if (!strcmp("force", words[3])) {
-                        flags |= GF_CLI_FLAG_OP_FORCE;
-                } else {
-                        ret = -1;
-                        cli_usage_out (word->pattern);
-                        parse_error = 1;
-                        goto out;
-                }
+    dict = dict_new();
+    ret = dict_set_str(dict, "volname", volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
+
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Stopping the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+    }
+
+    if (wordcount == 4) {
+        if (!strcmp("force", words[3])) {
+            flags |= GF_CLI_FLAG_OP_FORCE;
+        } else {
+            ret = -1;
+            cli_usage_out(word->pattern);
+            parse_error = 1;
+            goto out;
         }
+    }
 
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "dict set failed");
-                goto out;
-        }
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "dict set failed");
+        goto out;
+    }
 
-        answer = cli_cmd_get_confirmation (state, question);
+    answer = cli_cmd_get_confirmation(state, question);
 
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                goto out;
-        }
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STOP_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STOP_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume stop on '%s' failed", volname);
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume stop on '%s' failed", volname);
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        if (ret == 0 && GF_ANSWER_YES == answer) {
-                gf_event (EVENT_VOLUME_STOP, "name=%s;force=%d",
-                          (char *)words[2], (flags & GF_CLI_FLAG_OP_FORCE));
-        }
+    if (ret == 0 && GF_ANSWER_YES == answer) {
+        gf_event(EVENT_VOLUME_STOP, "name=%s;force=%d", (char *)words[2],
+                 (flags & GF_CLI_FLAG_OP_FORCE));
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmd_volume_rename_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_rename_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, "old-volname", (char *)words[2]);
+    ret = dict_set_str(dict, "old-volname", (char *)words[2]);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "new-volname", (char *)words[3]);
+    ret = dict_set_str(dict, "new-volname", (char *)words[3]);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RENAME_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RENAME_VOLUME];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume rename on '%s' failed", (char *)words[2]);
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume rename on '%s' failed", (char *)words[2]);
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_defrag_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                           const char **words, int wordcount)
+cli_cmd_volume_defrag_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                   ret     = -1;
-        rpc_clnt_procedure_t *proc    = NULL;
-        call_frame_t         *frame   = NULL;
-        dict_t               *dict = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t          *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 #if (USE_EVENTS)
-        eventtypes_t         event = EVENT_LAST;
+    eventtypes_t event = EVENT_LAST;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_defrag_parse (words, wordcount, &dict);
+    ret = cli_cmd_volume_defrag_parse(words, wordcount, &dict);
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-        }
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEFRAG_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEFRAG_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, dict);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, dict);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume rebalance failed");
-        } else {
-
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume rebalance failed");
+    } else {
 #if (USE_EVENTS)
-                if (!(strcmp (words[wordcount-1], "start")) ||
-                        !(strcmp (words[wordcount-1], "force")))  {
-                        event = EVENT_VOLUME_REBALANCE_START;
-                } else if (!strcmp (words[wordcount-1], "stop")) {
-                        event = EVENT_VOLUME_REBALANCE_STOP;
-                }
+        if (!(strcmp(words[wordcount - 1], "start")) ||
+            !(strcmp(words[wordcount - 1], "force"))) {
+            event = EVENT_VOLUME_REBALANCE_START;
+        } else if (!strcmp(words[wordcount - 1], "stop")) {
+            event = EVENT_VOLUME_REBALANCE_STOP;
+        }
 
-                if (event != EVENT_LAST)
-                        gf_event (event, "volume=%s", (char *)words[2]);
+        if (event != EVENT_LAST)
+            gf_event(event, "volume=%s", (char *)words[2]);
 #endif
-        }
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_reset_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_reset_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                         const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
 #if (USE_EVENTS)
-        int                      ret1    = -1;
-        char                    *tmp_opt = NULL;
+    int ret1 = -1;
+    char *tmp_opt = NULL;
 #endif
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_reset_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    ret = cli_cmd_volume_reset_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume reset failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume reset failed");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                ret1 = dict_get_str (options, "key", &tmp_opt);
-                if (ret1)
-                        tmp_opt = "";
-
-                gf_event (EVENT_VOLUME_RESET, "name=%s;option=%s",
-                          (char *)words[2],
-                          tmp_opt);
-        }
+    if (ret == 0) {
+        ret1 = dict_get_str(options, "key", &tmp_opt);
+        if (ret1)
+            tmp_opt = "";
+
+        gf_event(EVENT_VOLUME_RESET, "name=%s;option=%s", (char *)words[2],
+                 tmp_opt);
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_profile_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_profile_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                           const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
+    int sent = 0;
+    int parse_error = 0;
 
-        int                     ret      = -1;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
 
-        ret = cli_cmd_volume_profile_parse (words, wordcount, &options);
+    ret = cli_cmd_volume_profile_parse(words, wordcount, &options);
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROFILE_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROFILE_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume profile failed");
-        }
-
-        CLI_STACK_DESTROY (frame);
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume profile failed");
+    }
 
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_volume_set_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     sent = 0;
-        int                     parse_error = 0;
+    int sent = 0;
+    int parse_error = 0;
 
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        cli_local_t             *local = NULL;
-        char                    *op_errstr = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    char *op_errstr = NULL;
 
 #if (USE_EVENTS)
-        int                      ret1          = -1;
-        int                      i             = 1;
-        char                     dict_key[50]  = {0,};
-        char                    *tmp_opt       = NULL;
-        char                    *opts_str      = NULL;
-        int                      num_options   = 0;
+    int ret1 = -1;
+    int i = 1;
+    char dict_key[50] = {
+        0,
+    };
+    char *tmp_opt = NULL;
+    char *opts_str = NULL;
+    int num_options = 0;
 #endif
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SET_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SET_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_set_parse (state, words, wordcount,
-                                        &options, &op_errstr);
-        if (ret) {
-                if (op_errstr) {
-                    cli_err ("%s", op_errstr);
-                    GF_FREE (op_errstr);
-                } else
-                    cli_usage_out (word->pattern);
+    ret = cli_cmd_volume_set_parse(state, words, wordcount, &options,
+                                   &op_errstr);
+    if (ret) {
+        if (op_errstr) {
+            cli_err("%s", op_errstr);
+            GF_FREE(op_errstr);
+        } else
+            cli_usage_out(word->pattern);
 
-                parse_error = 1;
-                goto out;
-        }
+        parse_error = 1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume set failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume set failed");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0 && strcmp(words[2], "help") != 0) {
-                ret1 = dict_get_int32 (options, "count", &num_options);
-                if (ret1)
-                        num_options = 0;
-                else
-                        num_options = num_options/2;
+    if (ret == 0 && strcmp(words[2], "help") != 0) {
+        ret1 = dict_get_int32(options, "count", &num_options);
+        if (ret1)
+            num_options = 0;
+        else
+            num_options = num_options / 2;
 
-                /* Initialize opts_str */
-                opts_str = gf_strdup ("");
+        /* Initialize opts_str */
+        opts_str = gf_strdup("");
 
-                /* Prepare String in format options=KEY1,VALUE1,KEY2,VALUE2 */
-                for (i = 1; i <= num_options; i++) {
-                        sprintf (dict_key, "key%d", i);
-                        ret1 = dict_get_str (options, dict_key, &tmp_opt);
-                        if (ret1)
-                                tmp_opt = "";
+        /* Prepare String in format options=KEY1,VALUE1,KEY2,VALUE2 */
+        for (i = 1; i <= num_options; i++) {
+            sprintf(dict_key, "key%d", i);
+            ret1 = dict_get_str(options, dict_key, &tmp_opt);
+            if (ret1)
+                tmp_opt = "";
 
-                        gf_asprintf (&opts_str, "%s,%s", opts_str, tmp_opt);
+            gf_asprintf(&opts_str, "%s,%s", opts_str, tmp_opt);
 
-                        sprintf (dict_key, "value%d", i);
-                        ret1 = dict_get_str (options, dict_key, &tmp_opt);
-                        if (ret1)
-                                tmp_opt = "";
+            sprintf(dict_key, "value%d", i);
+            ret1 = dict_get_str(options, dict_key, &tmp_opt);
+            if (ret1)
+                tmp_opt = "";
 
-                        gf_asprintf (&opts_str, "%s,%s", opts_str, tmp_opt);
-                }
+            gf_asprintf(&opts_str, "%s,%s", opts_str, tmp_opt);
+        }
 
-                gf_event (EVENT_VOLUME_SET, "name=%s;options=%s",
-                          (char *)words[2],
-                          opts_str);
+        gf_event(EVENT_VOLUME_SET, "name=%s;options=%s", (char *)words[2],
+                 opts_str);
 
-                /* Allocated by gf_strdup and gf_asprintf */
-                GF_FREE (opts_str);
-        }
+        /* Allocated by gf_strdup and gf_asprintf */
+        GF_FREE(opts_str);
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
-static
-int
-cli_event_remove_brick_str (dict_t *options, char **event_str,
-                            eventtypes_t *event)
+static int
+cli_event_remove_brick_str(dict_t *options, char **event_str,
+                           eventtypes_t *event)
 {
-        int           ret             = -1;
-        char          *bricklist      = NULL;
-        char          *brick          = NULL;
-        char          *volname        = NULL;
-        char           key[256]       = {0,};
-        const char    *eventstrformat = "volume=%s;bricks=%s";
-        int32_t        command        = 0;
-        int32_t        i              = 1;
-        int32_t        count          = 0;
-        int32_t        eventstrlen    = 1;
-        int            bricklen      = 0;
-        char          *tmp_ptr        = NULL;
-
-        if (!options || !event_str || !event)
-                goto out;
+    int ret = -1;
+    char *bricklist = NULL;
+    char *brick = NULL;
+    char *volname = NULL;
+    char key[256] = {
+        0,
+    };
+    const char *eventstrformat = "volume=%s;bricks=%s";
+    int32_t command = 0;
+    int32_t i = 1;
+    int32_t count = 0;
+    int32_t eventstrlen = 1;
+    int bricklen = 0;
+    char *tmp_ptr = NULL;
+
+    if (!options || !event_str || !event)
+        goto out;
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret || !volname) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch volname");
-                ret = -1;
-                goto out;
-        }
-        /* Get the list of bricks for the event */
-        ret = dict_get_int32 (options, "command", &command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch command");
-                ret = -1;
-                goto out;
-        }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret || !volname) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch volname");
+        ret = -1;
+        goto out;
+    }
+    /* Get the list of bricks for the event */
+    ret = dict_get_int32(options, "command", &command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch command");
+        ret = -1;
+        goto out;
+    }
 
-        switch (command) {
+    switch (command) {
         case GF_OP_CMD_START:
-                *event = EVENT_VOLUME_REMOVE_BRICK_START;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_START;
+            break;
         case GF_OP_CMD_COMMIT:
-                *event = EVENT_VOLUME_REMOVE_BRICK_COMMIT;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_COMMIT;
+            break;
         case GF_OP_CMD_COMMIT_FORCE:
-                *event = EVENT_VOLUME_REMOVE_BRICK_FORCE;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_FORCE;
+            break;
         case GF_OP_CMD_STOP:
-                *event = EVENT_VOLUME_REMOVE_BRICK_STOP;
-                break;
+            *event = EVENT_VOLUME_REMOVE_BRICK_STOP;
+            break;
         default:
-                *event = EVENT_LAST;
-                break;
-        }
+            *event = EVENT_LAST;
+            break;
+    }
 
-        ret = -1;
+    ret = -1;
 
-        if (*event == EVENT_LAST) {
-                goto out;
-        }
+    if (*event == EVENT_LAST) {
+        goto out;
+    }
 
-        /* I could just get this from words[] but this is cleaner in case the
-         * format changes  */
-        while (i) {
-                snprintf (key, sizeof (key), "brick%d", i);
-                ret = dict_get_str (options, key, &brick);
-                if (ret) {
-                        break;
-                }
-                eventstrlen += strlen (brick) + 1;
-                i++;
+    /* I could just get this from words[] but this is cleaner in case the
+     * format changes  */
+    while (i) {
+        snprintf(key, sizeof(key), "brick%d", i);
+        ret = dict_get_str(options, key, &brick);
+        if (ret) {
+            break;
         }
+        eventstrlen += strlen(brick) + 1;
+        i++;
+    }
 
-        count = --i;
+    count = --i;
 
-        eventstrlen += 1;
+    eventstrlen += 1;
 
-        bricklist = GF_CALLOC (eventstrlen, sizeof (char), gf_common_mt_char);
-        if (!bricklist) {
-                goto out;
-        }
+    bricklist = GF_CALLOC(eventstrlen, sizeof(char), gf_common_mt_char);
+    if (!bricklist) {
+        goto out;
+    }
 
-        tmp_ptr = bricklist;
+    tmp_ptr = bricklist;
 
-        i = 1;
-        while (i <= count) {
-                snprintf (key, sizeof (key), "brick%d", i);
-                ret = dict_get_str (options, key, &brick);
-                if (ret) {
-                        break;
-                }
-                snprintf (tmp_ptr, eventstrlen, "%s ", brick);
-                bricklen = strlen (brick);
-                eventstrlen -= (bricklen + 1);
-                tmp_ptr += (bricklen + 1);
-                i++;
+    i = 1;
+    while (i <= count) {
+        snprintf(key, sizeof(key), "brick%d", i);
+        ret = dict_get_str(options, key, &brick);
+        if (ret) {
+            break;
         }
+        snprintf(tmp_ptr, eventstrlen, "%s ", brick);
+        bricklen = strlen(brick);
+        eventstrlen -= (bricklen + 1);
+        tmp_ptr += (bricklen + 1);
+        i++;
+    }
 
-        if (!ret) {
-                gf_asprintf (event_str, eventstrformat, volname,
-                             bricklist);
-        } else {
-                gf_asprintf (event_str, eventstrformat, volname,
-                             "<unavailable>");
-        }
+    if (!ret) {
+        gf_asprintf(event_str, eventstrformat, volname, bricklist);
+    } else {
+        gf_asprintf(event_str, eventstrformat, volname, "<unavailable>");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (bricklist);
-        return ret;
+    GF_FREE(bricklist);
+    return ret;
 }
 
-
 int
-cli_cmd_volume_add_brick_cbk (struct cli_state *state,
-                              struct cli_cmd_word *word, const char **words,
-                              int wordcount)
+cli_cmd_volume_add_brick_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    cli_local_t *local = NULL;
 
 #if (USE_EVENTS)
-        char                    *event_str = NULL;
-        char                    *bricks = NULL;
-        const char              *eventstrformat = "volume=%s;bricks=%s";
+    char *event_str = NULL;
+    char *bricks = NULL;
+    const char *eventstrformat = "volume=%s;bricks=%s";
 #endif
 
-        const char *question = "Changing the 'stripe count' of the volume is "
-                "not a supported feature. In some cases it may result in data "
-                "loss on the volume. Also there may be issues with regular "
-                "filesystem operations on the volume after the change. Do you "
-                "really want to continue with 'stripe' count option ? ";
+    const char *question =
+        "Changing the 'stripe count' of the volume is "
+        "not a supported feature. In some cases it may result in data "
+        "loss on the volume. Also there may be issues with regular "
+        "filesystem operations on the volume after the change. Do you "
+        "really want to continue with 'stripe' count option ? ";
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_add_brick_parse (state, words, wordcount, &options,
-                                              0);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    ret = cli_cmd_volume_add_brick_parse(state, words, wordcount, &options, 0);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        /* TODO: there are challenges in supporting changing of
-           stripe-count, until it is properly supported give warning to user */
-        if (dict_get (options, "stripe-count")) {
-                answer = cli_cmd_get_confirmation (state, question);
+    /* TODO: there are challenges in supporting changing of
+       stripe-count, until it is properly supported give warning to user */
+    if (dict_get(options, "stripe-count")) {
+        answer = cli_cmd_get_confirmation(state, question);
 
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
 #if (USE_EVENTS)
-        /* Get the list of bricks for the event */
+    /* Get the list of bricks for the event */
 
-        ret = dict_get_str (options, "bricks", &bricks);
+    ret = dict_get_str(options, "bricks", &bricks);
 
-        if (!ret) {
-                gf_asprintf (&event_str, eventstrformat, (char *)words[2],
-                            &bricks[1] /*Skip leading space*/);
-        } else {
-                gf_asprintf (&event_str, eventstrformat, (char *)words[2],
-                            "<unavailable>");
-        }
+    if (!ret) {
+        gf_asprintf(&event_str, eventstrformat, (char *)words[2],
+                    &bricks[1] /*Skip leading space*/);
+    } else {
+        gf_asprintf(&event_str, eventstrformat, (char *)words[2],
+                    "<unavailable>");
+    }
 #endif
 
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set force "
+                   "option");
+            goto out;
         }
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_BRICK];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume add-brick failed");
-        } else {
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume add-brick failed");
+    } else {
 #if (USE_EVENTS)
-                gf_event (EVENT_VOLUME_ADD_BRICK, "%s", event_str);
+        gf_event(EVENT_VOLUME_ADD_BRICK, "%s", event_str);
 #endif
-        }
+    }
 #if (USE_EVENTS)
-        GF_FREE(event_str);
+    GF_FREE(event_str);
 #endif
 
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_tier_validate_replica_type (dict_t *dict, int type)
+cli_tier_validate_replica_type(dict_t *dict, int type)
 {
+    int brick_count = -1;
+    int replica_count = 1;
+    int ret = -1;
 
-        int             brick_count             = -1;
-        int             replica_count           = 1;
-        int             ret                     = -1;
-
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get brick count");
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "replica-count", &replica_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_DEBUG, "Failed to get replica count. "
-                        "Defaulting to one");
-                replica_count = 1;
-        }
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get brick count");
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "replica-count", &replica_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG,
+               "Failed to get replica count. "
+               "Defaulting to one");
+        replica_count = 1;
+    }
+
+    /*
+     * Change the calculation of sub_count once attach-tier support
+     * disperse volume.
+     * sub_count = disperse_count for disperse volume
+     * */
+
+    if (brick_count % replica_count) {
+        if (type == GF_CLUSTER_TYPE_REPLICATE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "replica count");
+        else if (type == GF_CLUSTER_TYPE_DISPERSE)
+            cli_err(
+                "number of bricks is not a multiple of "
+                "disperse count");
+        else
+            cli_err(
+                "number of bricks given doesn't match "
+                "required count");
 
-        /*
-         * Change the calculation of sub_count once attach-tier support
-         * disperse volume.
-         * sub_count = disperse_count for disperse volume
-         * */
-
-
-        if (brick_count % replica_count) {
-             if (type == GF_CLUSTER_TYPE_REPLICATE)
-                     cli_err ("number of bricks is not a multiple of "
-                              "replica count");
-             else if (type == GF_CLUSTER_TYPE_DISPERSE)
-                     cli_err ("number of bricks is not a multiple of "
-                              "disperse count");
-             else
-                     cli_err ("number of bricks given doesn't match "
-                              "required count");
-
-             ret = -1;
-             goto out;
-     }
-        ret = 0;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-do_cli_cmd_volume_attach_tier (struct cli_state *state,
-                                struct cli_cmd_word *word, const char **words,
-                                int wordcount)
+do_cli_cmd_volume_attach_tier(struct cli_state *state,
+                              struct cli_cmd_word *word, const char **words,
+                              int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-        int                     type = 0;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+    int type = 0;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_add_brick_parse (state, words, wordcount, &options,
-                                              &type);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    ret = cli_cmd_volume_add_brick_parse(state, words, wordcount, &options,
+                                         &type);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    /*
+     * Merge this check when attach-tier has it's own cli parse function.
+     */
+    ret = cli_tier_validate_replica_type(options, type);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        /*
-         * Merge this check when attach-tier has it's own cli parse function.
-         */
-        ret = cli_tier_validate_replica_type (options, type);
+    if (state->mode & GLUSTER_MODE_WIGNORE) {
+        ret = dict_set_int32(options, "force", _gf_true);
         if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set force "
+                   "option");
+            goto out;
         }
+    }
 
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force "
-                                "option");
-                        goto out;
-                }
-        }
-
-        ret = dict_set_int32 (options, "attach-tier", 1);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "attach-tier", 1);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options, "hot-type", type);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "hot-type", type);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_TIER_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_TIER_BRICK];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("attach-tier failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("attach-tier failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-do_cli_cmd_volume_detach_tier (struct cli_state *state,
+do_cli_cmd_volume_detach_tier(struct cli_state *state,
                               struct cli_cmd_word *word, const char **words,
                               int wordcount, gf_boolean_t *aborted)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        cli_local_t             *local = NULL;
-        int                     need_question = 0;
-
-        const char *question = "Removing tier can result in data loss. "
-                               "Do you want to Continue?";
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    gf_answer_t answer = GF_ANSWER_NO;
+    cli_local_t *local = NULL;
+    int need_question = 0;
+
+    const char *question =
+        "Removing tier can result in data loss. "
+        "Do you want to Continue?";
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_detach_tier_parse(words, wordcount, &options,
-                                               &need_question);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    ret = cli_cmd_volume_detach_tier_parse(words, wordcount, &options,
+                                           &need_question);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (options, "force", 1);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "force", 1);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options, "count", 0);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "count", 0);
+    if (ret)
+        goto out;
 
-        *aborted = _gf_false;
+    *aborted = _gf_false;
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
-                /* we need to ask question only in case of 'commit or force' */
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        *aborted = _gf_true;
-                        goto out;
-                }
+    if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
+        /* we need to ask question only in case of 'commit or force' */
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            *aborted = _gf_true;
+            goto out;
         }
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_TIER_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_TIER_BRICK];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume detach tier failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume detach tier failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_tier_cbk (struct cli_state *state,
-                         struct cli_cmd_word *word, const char **words,
-                         int wordcount)
+cli_cmd_volume_tier_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                      ret     = -1;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        cli_local_t             *local   = NULL;
-        int                      i       = 0;
-        eventtypes_t            event    = EVENT_LAST;
-        gf_boolean_t            aborted  = _gf_false;
-        gf_answer_t             answer   = GF_ANSWER_NO;
-
-        const char *detach_question = "gluster volume detach-tier <VOLNAME> "
-                               "<start|stop|status|commit|force> is "
-                               "deprecated. Use the new command \'"
-                               "gluster volume tier <VOLNAME> detach <start|"
-                               "stop|status|commit|force>\'\n"
-                               "Do you want to Continue?";
-
-        const char *attach_question = "gluster volume attach-tier <VOLNAME> "
-                               "[<replica COUNT>] <NEW-BRICK>... is "
-                               "deprecated. Use the new command \'"
-                               "gluster volume tier <VOLNAME> attach [<replica"
-                               " COUNT>] <NEW-BRICK>... [force]\'\n"
-                               "Do you want to Continue?";
-
-
-        if (wordcount < 4) {
-                if (wordcount == 3 && !strcmp(words[2], "help")) {
-                        cli_cmd_tier_help_cbk (state, word, words, wordcount);
-                        ret = 0;
-                } else {
-                        cli_usage_out (word->pattern);
-                }
-                goto out;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    cli_local_t *local = NULL;
+    int i = 0;
+    eventtypes_t event = EVENT_LAST;
+    gf_boolean_t aborted = _gf_false;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    const char *detach_question =
+        "gluster volume detach-tier <VOLNAME> "
+        "<start|stop|status|commit|force> is "
+        "deprecated. Use the new command \'"
+        "gluster volume tier <VOLNAME> detach <start|"
+        "stop|status|commit|force>\'\n"
+        "Do you want to Continue?";
+
+    const char *attach_question =
+        "gluster volume attach-tier <VOLNAME> "
+        "[<replica COUNT>] <NEW-BRICK>... is "
+        "deprecated. Use the new command \'"
+        "gluster volume tier <VOLNAME> attach [<replica"
+        " COUNT>] <NEW-BRICK>... [force]\'\n"
+        "Do you want to Continue?";
+
+    if (wordcount < 4) {
+        if (wordcount == 3 && !strcmp(words[2], "help")) {
+            cli_cmd_tier_help_cbk(state, word, words, wordcount);
+            ret = 0;
+        } else {
+            cli_usage_out(word->pattern);
         }
+        goto out;
+    }
 
-        if (!strcmp(words[1], "detach-tier")) {
-                /* we need to ask question when older command is used */
-                answer = cli_cmd_get_confirmation (state, detach_question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-                ret = do_cli_cmd_volume_detach_tier (state, word,
-                                                     words, wordcount,
-                                                     &aborted);
-                goto out;
-        } else if (!strcmp(words[3], "detach")) {
-                for (i = 3; i < wordcount; i++)
-                        words[i] = words[i+1];
-
-                ret = do_cli_cmd_volume_detach_tier (state, word,
-                                                     words, wordcount-1,
-                                                     &aborted);
-                if (!aborted) {
-                        if (!strcmp (words[wordcount-2], "commit")) {
-                                event = EVENT_TIER_DETACH_COMMIT;
-                        } else if (!strcmp (words[wordcount-2], "start")) {
-                                event = EVENT_TIER_DETACH_START;
-                        } else if (!strcmp (words[wordcount-2], "stop")) {
-                                event = EVENT_TIER_DETACH_STOP;
-                        } else if (!strcmp (words[wordcount-2], "force")) {
-                                event = EVENT_TIER_DETACH_FORCE;
-                        }
-                }
-                goto out;
-
-        } else if (!strcmp(words[1], "attach-tier")) {
-                /* we need to ask question when the older command is used */
-                answer = cli_cmd_get_confirmation (state, attach_question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-                ret = do_cli_cmd_volume_attach_tier (state, word,
-                                                     words, wordcount);
-                goto out;
-        } else if (!strcmp(words[3], "attach")) {
-                for (i = 3; i < wordcount; i++)
-                        words[i] = words[i+1];
-
-                ret = do_cli_cmd_volume_attach_tier (state, word,
-                                                     words, wordcount-1);
-                if (!strcmp (words[wordcount-2], "force")) {
-                        event = EVENT_TIER_ATTACH_FORCE;
-                } else {
-                        event = EVENT_TIER_ATTACH;
-                }
-                goto out;
+    if (!strcmp(words[1], "detach-tier")) {
+        /* we need to ask question when older command is used */
+        answer = cli_cmd_get_confirmation(state, detach_question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+        ret = do_cli_cmd_volume_detach_tier(state, word, words, wordcount,
+                                            &aborted);
+        goto out;
+    } else if (!strcmp(words[3], "detach")) {
+        for (i = 3; i < wordcount; i++)
+            words[i] = words[i + 1];
+
+        ret = do_cli_cmd_volume_detach_tier(state, word, words, wordcount - 1,
+                                            &aborted);
+        if (!aborted) {
+            if (!strcmp(words[wordcount - 2], "commit")) {
+                event = EVENT_TIER_DETACH_COMMIT;
+            } else if (!strcmp(words[wordcount - 2], "start")) {
+                event = EVENT_TIER_DETACH_START;
+            } else if (!strcmp(words[wordcount - 2], "stop")) {
+                event = EVENT_TIER_DETACH_STOP;
+            } else if (!strcmp(words[wordcount - 2], "force")) {
+                event = EVENT_TIER_DETACH_FORCE;
+            }
+        }
+        goto out;
 
-        ret = cli_cmd_volume_tier_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                goto out;
+    } else if (!strcmp(words[1], "attach-tier")) {
+        /* we need to ask question when the older command is used */
+        answer = cli_cmd_get_confirmation(state, attach_question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+        ret = do_cli_cmd_volume_attach_tier(state, word, words, wordcount);
+        goto out;
+    } else if (!strcmp(words[3], "attach")) {
+        for (i = 3; i < wordcount; i++)
+            words[i] = words[i + 1];
 
-        if (!strcmp (words[wordcount-1], "start")) {
-                event = EVENT_TIER_START;
+        ret = do_cli_cmd_volume_attach_tier(state, word, words, wordcount - 1);
+        if (!strcmp(words[wordcount - 2], "force")) {
+            event = EVENT_TIER_ATTACH_FORCE;
         } else {
-                if (!strcmp (words[wordcount-2], "start") &&
-                    !strcmp (words[wordcount-1], "force")) {
-                        event = EVENT_TIER_START_FORCE;
-                }
+            event = EVENT_TIER_ATTACH;
         }
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TIER];
+    ret = cli_cmd_volume_tier_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    if (!strcmp(words[wordcount - 1], "start")) {
+        event = EVENT_TIER_START;
+    } else {
+        if (!strcmp(words[wordcount - 2], "start") &&
+            !strcmp(words[wordcount - 1], "force")) {
+            event = EVENT_TIER_START_FORCE;
+        }
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TIER];
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
+
+    CLI_LOCAL_INIT(local, words, frame, options);
+
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_out ("Tier command failed");
-        } else {
-                if (event != EVENT_LAST) {
-                        gf_event (event, "vol=%s", words[2]);
-                }
+    if (ret) {
+        cli_out("Tier command failed");
+    } else {
+        if (event != EVENT_LAST) {
+            gf_event(event, "vol=%s", words[2]);
         }
-        if (options)
-                dict_unref (options);
+    }
+    if (options)
+        dict_unref(options);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_get_soft_limit (dict_t *options, const char **words, dict_t *xdata)
+cli_get_soft_limit(dict_t *options, const char **words, dict_t *xdata)
 {
-        call_frame_t            *frame          = NULL;
-        cli_local_t             *local          = NULL;
-        rpc_clnt_procedure_t    *proc           = NULL;
-        char                    *default_sl     = NULL;
-        char                    *default_sl_dup = NULL;
-        int                      ret  = -1;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
-
-        //We need a ref on @options to prevent CLI_STACK_DESTROY
-        //from destroying it prematurely.
-        dict_ref (options);
-        CLI_LOCAL_INIT (local, words, frame, options);
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
-        ret = proc->fn (frame, THIS, options);
-
-        ret = dict_get_str (options, "default-soft-limit", &default_sl);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get default soft limit");
-                goto out;
-        }
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    char *default_sl = NULL;
+    char *default_sl_dup = NULL;
+    int ret = -1;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
+
+    // We need a ref on @options to prevent CLI_STACK_DESTROY
+    // from destroying it prematurely.
+    dict_ref(options);
+    CLI_LOCAL_INIT(local, words, frame, options);
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
+    ret = proc->fn(frame, THIS, options);
+
+    ret = dict_get_str(options, "default-soft-limit", &default_sl);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get default soft limit");
+        goto out;
+    }
 
-        default_sl_dup = gf_strdup (default_sl);
-        if (!default_sl_dup) {
-                ret = -1;
-                goto out;
-        }
+    default_sl_dup = gf_strdup(default_sl);
+    if (!default_sl_dup) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_dynstr (xdata, "default-soft-limit", default_sl_dup);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set default soft limit");
-                GF_FREE (default_sl_dup);
-                goto out;
-        }
+    ret = dict_set_dynstr(xdata, "default-soft-limit", default_sl_dup);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set default soft limit");
+        GF_FREE(default_sl_dup);
+        goto out;
+    }
 
 out:
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 /* Checks if at least one limit has been set on the volume
@@ -1469,1743 +1467,1728 @@ out:
  * Returns true if at least one limit is set. Returns false otherwise.
  */
 gf_boolean_t
-_limits_set_on_volume (char *volname, int type) {
-        gf_boolean_t    limits_set                = _gf_false;
-        int             ret                       = -1;
-        char            quota_conf_file[PATH_MAX] = {0,};
-        int             fd                        = -1;
-        char            buf[16]                   = {0,};
-        float           version                   = 0.0f;
-        char            gfid_type_stored          = 0;
-        char            gfid_type                 = 0;
-
-        /* TODO: fix hardcoding; Need to perform an RPC call to glusterd
-         * to fetch working directory
-         */
-        snprintf (quota_conf_file, sizeof quota_conf_file,
-                  "%s/vols/%s/quota.conf",
-                  GLUSTERD_DEFAULT_WORKDIR,
-                  volname);
-        fd = open (quota_conf_file, O_RDONLY);
-        if (fd == -1)
-                goto out;
+_limits_set_on_volume(char *volname, int type)
+{
+    gf_boolean_t limits_set = _gf_false;
+    int ret = -1;
+    char quota_conf_file[PATH_MAX] = {
+        0,
+    };
+    int fd = -1;
+    char buf[16] = {
+        0,
+    };
+    float version = 0.0f;
+    char gfid_type_stored = 0;
+    char gfid_type = 0;
+
+    /* TODO: fix hardcoding; Need to perform an RPC call to glusterd
+     * to fetch working directory
+     */
+    snprintf(quota_conf_file, sizeof quota_conf_file, "%s/vols/%s/quota.conf",
+             GLUSTERD_DEFAULT_WORKDIR, volname);
+    fd = open(quota_conf_file, O_RDONLY);
+    if (fd == -1)
+        goto out;
 
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                gfid_type = GF_QUOTA_CONF_TYPE_USAGE;
-        else
-                gfid_type = GF_QUOTA_CONF_TYPE_OBJECTS;
-
-        /* Try to read at least one gfid  of type 'gfid_type' */
-        while (1) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type_stored,
-                                            version);
-                if (ret <= 0)
-                        break;
-
-                if (gfid_type_stored == gfid_type) {
-                        limits_set = _gf_true;
-                        break;
-                }
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        gfid_type = GF_QUOTA_CONF_TYPE_USAGE;
+    else
+        gfid_type = GF_QUOTA_CONF_TYPE_OBJECTS;
+
+    /* Try to read at least one gfid  of type 'gfid_type' */
+    while (1) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type_stored, version);
+        if (ret <= 0)
+            break;
+
+        if (gfid_type_stored == gfid_type) {
+            limits_set = _gf_true;
+            break;
         }
+    }
 out:
-        if (fd != -1)
-                sys_close (fd);
+    if (fd != -1)
+        sys_close(fd);
 
-        return limits_set;
+    return limits_set;
 }
 
 int
-cli_cmd_quota_handle_list_all (const char **words, dict_t *options)
+cli_cmd_quota_handle_list_all(const char **words, dict_t *options)
 {
-        int                      all_failed = 1;
-        int                      count      = 0;
-        int                      ret        = -1;
-        rpc_clnt_procedure_t    *proc       = NULL;
-        cli_local_t             *local      = NULL;
-        call_frame_t            *frame      = NULL;
-        dict_t                  *xdata      = NULL;
-        char                    *gfid_str   = NULL;
-        char                    *volname    = NULL;
-        char                    *volname_dup = NULL;
-        unsigned char            buf[16]   = {0};
-        int                      fd        = -1;
-        char                     quota_conf_file[PATH_MAX] = {0};
-        gf_boolean_t             xml_err_flag   = _gf_false;
-        char                     err_str[NAME_MAX] = {0,};
-        int32_t                  type       = 0;
-        char                     gfid_type  = 0;
-        float                    version    = 0.0f;
-        int32_t                  max_count  = 0;
-
-        xdata = dict_new ();
-        if (!xdata) {
-                ret = -1;
-                goto out;
-        }
+    int all_failed = 1;
+    int count = 0;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *xdata = NULL;
+    char *gfid_str = NULL;
+    char *volname = NULL;
+    char *volname_dup = NULL;
+    unsigned char buf[16] = {0};
+    int fd = -1;
+    char quota_conf_file[PATH_MAX] = {0};
+    gf_boolean_t xml_err_flag = _gf_false;
+    char err_str[NAME_MAX] = {
+        0,
+    };
+    int32_t type = 0;
+    char gfid_type = 0;
+    float version = 0.0f;
+    int32_t max_count = 0;
+
+    xdata = dict_new();
+    if (!xdata) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto out;
-        }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+        goto out;
+    }
 
-        ret = dict_get_int32 (options, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota option type");
-                goto out;
-        }
+    ret = dict_get_int32(options, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get quota option type");
+        goto out;
+    }
 
-        ret = dict_set_int32 (xdata, "type", type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set type in xdata");
-                goto out;
-        }
+    ret = dict_set_int32(xdata, "type", type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set type in xdata");
+        goto out;
+    }
 
-        ret = cli_get_soft_limit (options, words, xdata);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch default "
-                        "soft-limit");
-                goto out;
+    ret = cli_get_soft_limit(options, words, xdata);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to fetch default "
+               "soft-limit");
+        goto out;
+    }
+
+    /* Check if at least one limit is set on volume. No need to check for
+     * quota enabled as cli_get_soft_limit() handles that
+     */
+    if (!_limits_set_on_volume(volname, type)) {
+        snprintf(err_str, sizeof(err_str),
+                 "No%s quota configured on"
+                 " volume %s",
+                 (type == GF_QUOTA_OPTION_TYPE_LIST) ? "" : " inode", volname);
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            xml_err_flag = _gf_true;
+        } else {
+            cli_out("quota: %s", err_str);
         }
+        ret = 0;
+        goto out;
+    }
 
-        /* Check if at least one limit is set on volume. No need to check for
-         * quota enabled as cli_get_soft_limit() handles that
-         */
-        if (!_limits_set_on_volume (volname, type)) {
-                snprintf (err_str, sizeof (err_str), "No%s quota configured on"
-                          " volume %s",
-                          (type == GF_QUOTA_OPTION_TYPE_LIST) ? "" : " inode",
-                          volname);
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        xml_err_flag = _gf_true;
-                } else {
-                        cli_out ("quota: %s", err_str);
-                }
-                ret = 0;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
+    volname_dup = gf_strdup(volname);
+    if (!volname_dup) {
+        ret = -1;
+        goto out;
+    }
 
-        volname_dup = gf_strdup (volname);
-        if (!volname_dup) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_set_dynstr(xdata, "volume-uuid", volname_dup);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set volume-uuid");
+        GF_FREE(volname_dup);
+        goto out;
+    }
+
+    // TODO: fix hardcoding; Need to perform an RPC call to glusterd
+    // to fetch working directory
+    snprintf(quota_conf_file, sizeof quota_conf_file, "%s/vols/%s/quota.conf",
+             GLUSTERD_DEFAULT_WORKDIR, volname);
+    fd = open(quota_conf_file, O_RDONLY);
+    if (fd == -1) {
+        // This may because no limits were yet set on the volume
+        gf_log("cli", GF_LOG_TRACE,
+               "Unable to open "
+               "quota.conf");
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_dynstr (xdata, "volume-uuid", volname_dup);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set volume-uuid");
-                GF_FREE (volname_dup);
-                goto out;
-        }
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        //TODO: fix hardcoding; Need to perform an RPC call to glusterd
-        //to fetch working directory
-        snprintf (quota_conf_file, sizeof quota_conf_file,
-                  "%s/vols/%s/quota.conf",
-                  GLUSTERD_DEFAULT_WORKDIR,
-                  volname);
-        fd = open (quota_conf_file, O_RDONLY);
-        if (fd == -1) {
-                //This may because no limits were yet set on the volume
-                gf_log ("cli", GF_LOG_TRACE, "Unable to open "
-                        "quota.conf");
-                ret = 0;
-                goto out;
-         }
+    CLI_LOCAL_INIT(local, words, frame, xdata);
+    proc = &cli_quotad_clnt.proctable[GF_AGGREGATOR_GETLIMIT];
 
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
+    gfid_str = GF_CALLOC(1, gf_common_mt_char, 64);
+    if (!gfid_str) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, xdata);
-        proc = &cli_quotad_clnt.proctable[GF_AGGREGATOR_GETLIMIT];
+    for (count = 0;; count++) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type, version);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            gf_log(THIS->name, GF_LOG_CRITICAL,
+                   "Quota "
+                   "configuration store may be corrupt.");
+            goto out;
+        }
+
+        if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
+             gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
+            (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
+             gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
+            continue;
+
+        max_count++;
+    }
+    ret = dict_set_int32(xdata, "max_count", max_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to set max_count");
+        goto out;
+    }
+
+    ret = sys_lseek(fd, 0L, SEEK_SET);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to move offset to "
+               "the beginning: %s",
+               strerror(errno));
+        goto out;
+    }
+    ret = quota_conf_read_version(fd, &version);
+    if (ret)
+        goto out;
 
-        gfid_str = GF_CALLOC (1, gf_common_mt_char, 64);
-        if (!gfid_str) {
-                ret = -1;
-                goto out;
+    for (count = 0;; count++) {
+        ret = quota_conf_read_gfid(fd, buf, &gfid_type, version);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            gf_log(THIS->name, GF_LOG_CRITICAL,
+                   "Quota "
+                   "configuration store may be corrupt.");
+            goto out;
         }
 
-        for (count = 0;; count++) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type, version);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        gf_log (THIS->name, GF_LOG_CRITICAL, "Quota "
-                                "configuration store may be corrupt.");
-                        goto out;
-                }
-
-                if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
-                    (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
-                        continue;
+        if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
+             gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
+            (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
+             gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
+            continue;
 
-                max_count++;
-        }
-        ret = dict_set_int32 (xdata, "max_count", max_count);
+        uuid_utoa_r(buf, gfid_str);
+        ret = dict_set_str(xdata, "gfid", gfid_str);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set max_count");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to set gfid");
+            goto out;
         }
 
-        ret = sys_lseek (fd, 0L, SEEK_SET);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to move offset to "
-                        "the beginning: %s", strerror (errno));
-                goto out;
+        ret = proc->fn(frame, THIS, xdata);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to get quota "
+                   "limits for %s",
+                   uuid_utoa((unsigned char *)buf));
         }
-        ret = quota_conf_read_version (fd, &version);
-        if (ret)
-                goto out;
 
-        for (count = 0;; count++) {
-                ret = quota_conf_read_gfid (fd, buf, &gfid_type, version);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        gf_log (THIS->name, GF_LOG_CRITICAL, "Quota "
-                                "configuration store may be corrupt.");
-                        goto out;
-                }
+        dict_del(xdata, "gfid");
+        all_failed = all_failed && ret;
+    }
 
-                if ((type == GF_QUOTA_OPTION_TYPE_LIST &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_OBJECTS) ||
-                    (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS &&
-                     gfid_type == GF_QUOTA_CONF_TYPE_USAGE))
-                        continue;
-
-                uuid_utoa_r (buf, gfid_str);
-                ret = dict_set_str (xdata, "gfid", gfid_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set gfid");
-                        goto out;
-                }
-
-                ret = proc->fn (frame, THIS, xdata);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get quota "
-                                "limits for %s", uuid_utoa ((unsigned char*)buf));
-                }
-
-                dict_del (xdata, "gfid");
-                all_failed = all_failed && ret;
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_quota_limit_list_end (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error in printing "
-                                "xml output");
-                        goto out;
-                }
-        }
-
-        if (count > 0) {
-                ret = all_failed? -1: 0;
-        } else {
-                ret = 0;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_quota_limit_list_end(local);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error in printing "
+                   "xml output");
+            goto out;
         }
+    }
 
+    if (count > 0) {
+        ret = all_failed ? -1 : 0;
+    } else {
+        ret = 0;
+    }
 
 out:
-        if (xml_err_flag) {
-                ret = cli_xml_output_str ("volQuota", NULL, -1, 0, err_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting in "
-                                "xml format");
-                }
-        }
-
-        if (fd != -1) {
-                sys_close (fd);
-        }
-
-        GF_FREE (gfid_str);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch and display quota"
-                        " limits");
-        }
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (xml_err_flag) {
+        ret = cli_xml_output_str("volQuota", NULL, -1, 0, err_str);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error outputting in "
+                   "xml format");
+        }
+    }
+
+    if (fd != -1) {
+        sys_close(fd);
+    }
+
+    GF_FREE(gfid_str);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not fetch and display quota"
+               " limits");
+    }
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
-
 int
-cli_cmd_bitrot_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                    const char **words, int wordcount)
+cli_cmd_bitrot_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                   const char **words, int wordcount)
 {
-
-        int                     ret        = -1;
-        int                     parse_err  = 0;
-        call_frame_t            *frame     = NULL;
-        dict_t                  *options   = NULL;
-        cli_local_t             *local     = NULL;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        int                     sent       = 0;
+    int ret = -1;
+    int parse_err = 0;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    cli_local_t *local = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    int sent = 0;
 #if (USE_EVENTS)
-        int                     cmd_type        = -1;
-        int                     ret1            = -1;
-        int                     event_type      = -1;
-        char                    *tmp            = NULL;
-        char                    *events_str     = NULL;
+    int cmd_type = -1;
+    int ret1 = -1;
+    int event_type = -1;
+    char *tmp = NULL;
+    char *events_str = NULL;
 #endif
 
-        ret = cli_cmd_bitrot_parse (words, wordcount, &options);
-        if (ret < 0) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    ret = cli_cmd_bitrot_parse(words, wordcount, &options);
+    if (ret < 0) {
+        cli_usage_out(word->pattern);
+        parse_err = 1;
+        goto out;
+    }
 
-        if (ret == 1) {
-                /* this is 'volume bitrot help' */
-                cli_cmd_bitrot_help_cbk (state, word, words, wordcount);
-                ret = 0;
-                goto out2;
-        }
+    if (ret == 1) {
+        /* this is 'volume bitrot help' */
+        cli_cmd_bitrot_help_cbk(state, word, words, wordcount);
+        ret = 0;
+        goto out2;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BITROT];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BITROT];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_err == 0))
-                    cli_err ("Bit rot command failed. Please check the cli "
-                             "logs for more details");
-
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_err == 0))
+            cli_err(
+                "Bit rot command failed. Please check the cli "
+                "logs for more details");
+    }
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                ret1 = dict_get_int32 (options, "type", &cmd_type);
+    if (ret == 0) {
+        ret1 = dict_get_int32(options, "type", &cmd_type);
+        if (ret1)
+            cmd_type = -1;
+        else {
+            ret1 = dict_get_str(options, "volname", &tmp);
+            if (ret1)
+                tmp = "";
+            gf_asprintf(&events_str, "name=%s", tmp);
+        }
+
+        switch (cmd_type) {
+            case GF_BITROT_OPTION_TYPE_ENABLE:
+                event_type = EVENT_BITROT_ENABLE;
+                break;
+            case GF_BITROT_OPTION_TYPE_DISABLE:
+                event_type = EVENT_BITROT_DISABLE;
+                break;
+            case GF_BITROT_CMD_SCRUB_ONDEMAND:
+                event_type = EVENT_BITROT_SCRUB_ONDEMAND;
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
+                event_type = EVENT_BITROT_SCRUB_THROTTLE;
+                ret1 = dict_get_str(options, "scrub-throttle-value", &tmp);
                 if (ret1)
-                        cmd_type = -1;
-                else {
-                        ret1 = dict_get_str (options, "volname", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "name=%s", tmp);
-                }
-
-                switch (cmd_type) {
-                case GF_BITROT_OPTION_TYPE_ENABLE:
-                        event_type = EVENT_BITROT_ENABLE;
-                        break;
-                case GF_BITROT_OPTION_TYPE_DISABLE:
-                        event_type = EVENT_BITROT_DISABLE;
-                        break;
-                case GF_BITROT_CMD_SCRUB_ONDEMAND:
-                        event_type = EVENT_BITROT_SCRUB_ONDEMAND;
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
-                        event_type = EVENT_BITROT_SCRUB_THROTTLE;
-                        ret1 = dict_get_str (options, "scrub-throttle-value",
-                                             &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
-                        event_type = EVENT_BITROT_SCRUB_FREQ;
-                        ret1 = dict_get_str (options, "scrub-frequency-value",
-                                             &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                case GF_BITROT_OPTION_TYPE_SCRUB:
-                        event_type = EVENT_BITROT_SCRUB_OPTION;
-                        ret1 = dict_get_str (options, "scrub-value", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%s;value=%s", events_str,
-                                     tmp);
-                        break;
-                default:
-                        break;
-                }
+                    tmp = "";
+                gf_asprintf(&events_str, "%s;value=%s", events_str, tmp);
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
+                event_type = EVENT_BITROT_SCRUB_FREQ;
+                ret1 = dict_get_str(options, "scrub-frequency-value", &tmp);
+                if (ret1)
+                    tmp = "";
+                gf_asprintf(&events_str, "%s;value=%s", events_str, tmp);
+                break;
+            case GF_BITROT_OPTION_TYPE_SCRUB:
+                event_type = EVENT_BITROT_SCRUB_OPTION;
+                ret1 = dict_get_str(options, "scrub-value", &tmp);
+                if (ret1)
+                    tmp = "";
+                gf_asprintf(&events_str, "%s;value=%s", events_str, tmp);
+                break;
+            default:
+                break;
+        }
 
-                if (event_type > -1)
-                        gf_event (event_type, "%s", events_str);
+        if (event_type > -1)
+            gf_event(event_type, "%s", events_str);
 
-                if (events_str)
-                        GF_FREE (events_str);
-        }
+        if (events_str)
+            GF_FREE(events_str);
+    }
 #endif
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 out2:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_quota_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                   const char **words, int wordcount)
+cli_cmd_quota_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                  const char **words, int wordcount)
 {
-
-        int                      ret       = 0;
-        int                      parse_err = 0;
-        int32_t                  type      = 0;
-        rpc_clnt_procedure_t    *proc      = NULL;
-        call_frame_t            *frame     = NULL;
-        dict_t                  *options   = NULL;
-        gf_answer_t              answer    = GF_ANSWER_NO;
-        cli_local_t             *local     = NULL;
-        int                      sent      = 0;
-        char                    *volname   = NULL;
-        const char *question = "Disabling quota will delete all the quota "
-                               "configuration. Do you want to continue?";
-
-        //parse **words into options dictionary
-        if (strcmp (words[1], "inode-quota") == 0) {
-                ret = cli_cmd_inode_quota_parse (words, wordcount, &options);
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                        goto out;
-                }
-        } else {
-                ret = cli_cmd_quota_parse (words, wordcount, &options);
-
-                if (ret == 1) {
-                        cli_cmd_quota_help_cbk (state, word, words, wordcount);
-                        ret = 0;
-                        goto out;
-                }
-                if (ret < 0) {
-                        cli_usage_out (word->pattern);
-                        parse_err = 1;
-                        goto out;
-                }
+    int ret = 0;
+    int parse_err = 0;
+    int32_t type = 0;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    cli_local_t *local = NULL;
+    int sent = 0;
+    char *volname = NULL;
+    const char *question =
+        "Disabling quota will delete all the quota "
+        "configuration. Do you want to continue?";
+
+    // parse **words into options dictionary
+    if (strcmp(words[1], "inode-quota") == 0) {
+        ret = cli_cmd_inode_quota_parse(words, wordcount, &options);
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+            goto out;
         }
+    } else {
+        ret = cli_cmd_quota_parse(words, wordcount, &options);
 
-        ret = dict_get_int32 (options, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get opcode");
-                goto out;
+        if (ret == 1) {
+            cli_cmd_quota_help_cbk(state, word, words, wordcount);
+            ret = 0;
+            goto out;
+        }
+        if (ret < 0) {
+            cli_usage_out(word->pattern);
+            parse_err = 1;
+            goto out;
         }
+    }
 
-        //handle quota-disable and quota-list-all different from others
-        switch (type) {
+    ret = dict_get_int32(options, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get opcode");
+        goto out;
+    }
+
+    // handle quota-disable and quota-list-all different from others
+    switch (type) {
         case GF_QUOTA_OPTION_TYPE_DISABLE:
-                answer = cli_cmd_get_confirmation (state, question);
-                if (answer == GF_ANSWER_NO)
-                        goto out;
-                break;
+            answer = cli_cmd_get_confirmation(state, question);
+            if (answer == GF_ANSWER_NO)
+                goto out;
+            break;
         case GF_QUOTA_OPTION_TYPE_LIST:
         case GF_QUOTA_OPTION_TYPE_LIST_OBJECTS:
-                if (wordcount != 4)
-                        break;
-                ret = cli_cmd_quota_handle_list_all (words, options);
-                goto out;
-        default:
+            if (wordcount != 4)
                 break;
-        }
+            ret = cli_cmd_quota_handle_list_all(words, options);
+            goto out;
+        default:
+            break;
+    }
 
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto out;
-        }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                ret = -1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        ret = -1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
+    CLI_LOCAL_INIT(local, words, frame, options);
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if (sent == 0 && parse_err == 0)
-                        cli_out ("Quota command failed. Please check the cli "
-                                 "logs for more details");
-        }
-
-        /* Events for Quota */
-         if (ret == 0) {
-                switch (type) {
-                case GF_QUOTA_OPTION_TYPE_ENABLE:
-                        gf_event (EVENT_QUOTA_ENABLE, "volume=%s", volname);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_DISABLE:
-                        gf_event (EVENT_QUOTA_DISABLE, "volume=%s", volname);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_LIMIT_USAGE:
-                        gf_event (EVENT_QUOTA_SET_USAGE_LIMIT, "volume=%s;"
-                                  "path=%s;limit=%s", volname, words[4],
-                                  words[5]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS:
-                        gf_event (EVENT_QUOTA_SET_OBJECTS_LIMIT, "volume=%s;"
-                                  "path=%s;limit=%s", volname, words[4],
-                                  words[5]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_REMOVE:
-                        gf_event (EVENT_QUOTA_REMOVE_USAGE_LIMIT, "volume=%s;"
-                                  "path=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS:
-                        gf_event (EVENT_QUOTA_REMOVE_OBJECTS_LIMIT,
-                                  "volume=%s;" "path=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_ALERT_TIME:
-                        gf_event (EVENT_QUOTA_ALERT_TIME, "volume=%s;time=%s",
-                                  volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT:
-                        gf_event (EVENT_QUOTA_SOFT_TIMEOUT, "volume=%s;"
-                                  "soft-timeout=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT:
-                        gf_event (EVENT_QUOTA_HARD_TIMEOUT, "volume=%s;"
-                                  "hard-timeout=%s", volname, words[4]);
-                        break;
-                case GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT:
-                        gf_event (EVENT_QUOTA_DEFAULT_SOFT_LIMIT, "volume=%s;"
-                                  "default-soft-limit=%s", volname, words[4]);
-                        break;
-                }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if (sent == 0 && parse_err == 0)
+            cli_out(
+                "Quota command failed. Please check the cli "
+                "logs for more details");
+    }
+
+    /* Events for Quota */
+    if (ret == 0) {
+        switch (type) {
+            case GF_QUOTA_OPTION_TYPE_ENABLE:
+                gf_event(EVENT_QUOTA_ENABLE, "volume=%s", volname);
+                break;
+            case GF_QUOTA_OPTION_TYPE_DISABLE:
+                gf_event(EVENT_QUOTA_DISABLE, "volume=%s", volname);
+                break;
+            case GF_QUOTA_OPTION_TYPE_LIMIT_USAGE:
+                gf_event(EVENT_QUOTA_SET_USAGE_LIMIT,
+                         "volume=%s;"
+                         "path=%s;limit=%s",
+                         volname, words[4], words[5]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS:
+                gf_event(EVENT_QUOTA_SET_OBJECTS_LIMIT,
+                         "volume=%s;"
+                         "path=%s;limit=%s",
+                         volname, words[4], words[5]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_REMOVE:
+                gf_event(EVENT_QUOTA_REMOVE_USAGE_LIMIT,
+                         "volume=%s;"
+                         "path=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS:
+                gf_event(EVENT_QUOTA_REMOVE_OBJECTS_LIMIT,
+                         "volume=%s;"
+                         "path=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_ALERT_TIME:
+                gf_event(EVENT_QUOTA_ALERT_TIME, "volume=%s;time=%s", volname,
+                         words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT:
+                gf_event(EVENT_QUOTA_SOFT_TIMEOUT,
+                         "volume=%s;"
+                         "soft-timeout=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT:
+                gf_event(EVENT_QUOTA_HARD_TIMEOUT,
+                         "volume=%s;"
+                         "hard-timeout=%s",
+                         volname, words[4]);
+                break;
+            case GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT:
+                gf_event(EVENT_QUOTA_DEFAULT_SOFT_LIMIT,
+                         "volume=%s;"
+                         "default-soft-limit=%s",
+                         volname, words[4]);
+                break;
         }
+    }
 
-
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-cli_cmd_volume_remove_brick_cbk (struct cli_state *state,
-                                 struct cli_cmd_word *word, const char **words,
-                                 int wordcount)
+cli_cmd_volume_remove_brick_cbk(struct cli_state *state,
+                                struct cli_cmd_word *word, const char **words,
+                                int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        gf_answer_t             answer = GF_ANSWER_NO;
-        int                     brick_count = 0;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        int                     need_question = 0;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+    int brick_count = 0;
+    int sent = 0;
+    int parse_error = 0;
+    int need_question = 0;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
 #if (USE_EVENTS)
-        eventtypes_t            event = EVENT_LAST;
-        char                    *event_str = NULL;
-        int                     event_ret = -1;
+    eventtypes_t event = EVENT_LAST;
+    char *event_str = NULL;
+    int event_ret = -1;
 #endif
-        int32_t                 command = GF_OP_CMD_NONE;
-        char                    *question = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int32_t command = GF_OP_CMD_NONE;
+    char *question = NULL;
 
-        ret = cli_cmd_volume_remove_brick_parse (state, words, wordcount,
-                                                 &options, &need_question,
-                                                 &brick_count, &command);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-        if (command == GF_OP_CMD_COMMIT_FORCE) {
-                question = "Remove-brick force will not migrate files from the "
-                           "removed bricks, so they will no longer be available"
-                           " on the volume.\nDo you want to continue?";
-        } else if (command == GF_OP_CMD_START) {
-                question = "Running remove-brick with cluster.force-migration"
-                           " enabled can result in data corruption. It is safer"
-                           " to disable this option so that files that receive "
-                           "writes during migration are not migrated.\nFiles "
-                           "that are not migrated can then be manually copied "
-                           "after the remove-brick commit operation.\nDo you "
-                           "want to continue with your current "
-                           "cluster.force-migration settings?";
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (!brick_count) {
-                cli_err ("No bricks specified");
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_get_str (options, "volname", &volname);
-        if (ret || !volname) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch volname");
-                ret = -1;
-                goto out;
-        }
+    ret = cli_cmd_volume_remove_brick_parse(state, words, wordcount, &options,
+                                            &need_question, &brick_count,
+                                            &command);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    if (command == GF_OP_CMD_COMMIT_FORCE) {
+        question =
+            "Remove-brick force will not migrate files from the "
+            "removed bricks, so they will no longer be available"
+            " on the volume.\nDo you want to continue?";
+    } else if (command == GF_OP_CMD_START) {
+        question =
+            "Running remove-brick with cluster.force-migration"
+            " enabled can result in data corruption. It is safer"
+            " to disable this option so that files that receive "
+            "writes during migration are not migrated.\nFiles "
+            "that are not migrated can then be manually copied "
+            "after the remove-brick commit operation.\nDo you "
+            "want to continue with your current "
+            "cluster.force-migration settings?";
+    }
+
+    if (!brick_count) {
+        cli_err("No bricks specified");
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_get_str(options, "volname", &volname);
+    if (ret || !volname) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch volname");
+        ret = -1;
+        goto out;
+    }
 
 #if (USE_EVENTS)
-        event_ret = cli_event_remove_brick_str (options, &event_str, &event);
+    event_ret = cli_event_remove_brick_str(options, &event_str, &event);
 #endif
 
-        if (!strcmp (volname, GLUSTER_SHARED_STORAGE)) {
-                question = "Removing brick from the shared storage volume"
-                           "(gluster_shared_storage), will affect features "
-                           "like snapshot scheduler, geo-replication "
-                           "and NFS-Ganesha. Do you still want to "
-                           "continue?";
-                need_question = _gf_true;
+    if (!strcmp(volname, GLUSTER_SHARED_STORAGE)) {
+        question =
+            "Removing brick from the shared storage volume"
+            "(gluster_shared_storage), will affect features "
+            "like snapshot scheduler, geo-replication "
+            "and NFS-Ganesha. Do you still want to "
+            "continue?";
+        need_question = _gf_true;
+    }
+
+    if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
+        answer = cli_cmd_get_confirmation(state, question);
+        if (GF_ANSWER_NO == answer) {
+            ret = 0;
+            goto out;
         }
+    }
 
-        if (!(state->mode & GLUSTER_MODE_SCRIPT) && need_question) {
-                answer = cli_cmd_get_confirmation (state, question);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_BRICK];
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_BRICK];
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        CLI_LOCAL_INIT (local, words, frame, options);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume remove-brick failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume remove-brick failed");
+    }
 #if (USE_EVENTS)
-        if (!ret && !event_ret)
-                gf_event (event, "%s", event_str);
-        if (event_str)
-                GF_FREE (event_str);
+    if (!ret && !event_ret)
+        gf_event(event, "%s", event_str);
+    if (event_str)
+        GF_FREE(event_str);
 
 #endif
 
-        CLI_STACK_DESTROY (frame);
-
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
 int
-cli_cmd_volume_reset_brick_cbk (struct cli_state *state,
-                                struct cli_cmd_word *word,
-                                const char **words,
-                                int wordcount)
+cli_cmd_volume_reset_brick_cbk(struct cli_state *state,
+                               struct cli_cmd_word *word, const char **words,
+                               int wordcount)
 {
-        int                      ret          = -1;
-        rpc_clnt_procedure_t    *proc         = NULL;
-        call_frame_t            *frame        = NULL;
-        dict_t                  *options      = NULL;
-        int                      sent         = 0;
-        int                      parse_error  = 0;
-        cli_local_t             *local        = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_BRICK];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
+    ret = cli_cmd_volume_reset_brick_parse(words, wordcount, &options);
 
-        ret = cli_cmd_volume_reset_brick_parse (words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
+    if (state->mode & GLUSTER_MODE_WIGNORE_PARTITION) {
+        ret = dict_set_int32(options, "ignore-partition", _gf_true);
         if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to set ignore-"
+                   "partition option");
+            goto out;
         }
+    }
 
-        if (state->mode & GLUSTER_MODE_WIGNORE_PARTITION) {
-                ret = dict_set_int32 (options, "ignore-partition", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set ignore-"
-                                "partition option");
-                        goto out;
-                }
-        }
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        CLI_LOCAL_INIT (local, words, frame, options);
-
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume reset-brick failed");
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume reset-brick failed");
+    } else {
+        if (wordcount > 5) {
+            gf_event(EVENT_BRICK_RESET_COMMIT,
+                     "Volume=%s;source-brick=%s;"
+                     "destination-brick=%s",
+                     (char *)words[2], (char *)words[3], (char *)words[4]);
         } else {
-                if (wordcount > 5) {
-                        gf_event (EVENT_BRICK_RESET_COMMIT,
-                                  "Volume=%s;source-brick=%s;"
-                                  "destination-brick=%s",
-                                  (char *)words[2], (char *)words[3],
-                                  (char *)words[4]);
-                } else {
-                        gf_event (EVENT_BRICK_RESET_START,
-                                  "Volume=%s;source-brick=%s",
-                                  (char *)words[2], (char *)words[3]);
-                }
+            gf_event(EVENT_BRICK_RESET_START, "Volume=%s;source-brick=%s",
+                     (char *)words[2], (char *)words[3]);
         }
-        CLI_STACK_DESTROY (frame);
+    }
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_replace_brick_cbk (struct cli_state *state,
-                                  struct cli_cmd_word *word,
-                                  const char **words,
-                                  int wordcount)
+cli_cmd_volume_replace_brick_cbk(struct cli_state *state,
+                                 struct cli_cmd_word *word, const char **words,
+                                 int wordcount)
 {
-        int                      ret          = -1;
-        rpc_clnt_procedure_t    *proc         = NULL;
-        call_frame_t            *frame        = NULL;
-        dict_t                  *options = NULL;
-        int                      sent = 0;
-        int                      parse_error = 0;
-        cli_local_t             *local = NULL;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
 
 #ifdef GF_SOLARIS_HOST_OS
-        cli_out ("Command not supported on Solaris");
-        goto out;
+    cli_out("Command not supported on Solaris");
+    goto out;
 #endif
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REPLACE_BRICK];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REPLACE_BRICK];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_volume_replace_brick_parse (words, wordcount, &options);
+    ret = cli_cmd_volume_replace_brick_parse(words, wordcount, &options);
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume replace-brick failed");
-        } else {
-                gf_event (EVENT_BRICK_REPLACE,
-                          "Volume=%s;source-brick=%s;destination-brick=%s",
-                          (char *)words[2], (char *)words[3], (char *)words[4]);
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume replace-brick failed");
+    } else {
+        gf_event(EVENT_BRICK_REPLACE,
+                 "Volume=%s;source-brick=%s;destination-brick=%s",
+                 (char *)words[2], (char *)words[3], (char *)words[4]);
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
-
 int
-cli_cmd_volume_set_transport_cbk (struct cli_state *state,
-                                  struct cli_cmd_word *word,
-                                  const char **words, int wordcount)
+cli_cmd_volume_set_transport_cbk(struct cli_state *state,
+                                 struct cli_cmd_word *word, const char **words,
+                                 int wordcount)
 {
-        cli_cmd_broadcast_response (0);
-        return 0;
+    cli_cmd_broadcast_response(0);
+    return 0;
 }
 
 int
-cli_cmd_volume_top_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_top_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    ret = cli_cmd_volume_top_parse(words, wordcount, &options);
+
+    if (ret) {
+        parse_error = 1;
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        int                     ret      = -1;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        dict_t                  *options = NULL;
-        int                     sent     = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        ret = cli_cmd_volume_top_parse (words, wordcount, &options);
-
-        if (ret) {
-                parse_error = 1;
-                cli_usage_out (word->pattern);
-                goto out;
-        }
-
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TOP_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TOP_VOLUME];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume top failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume top failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    CLI_STACK_DESTROY(frame);
 
+    return ret;
 }
 
-
 int
-cli_cmd_log_rotate_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_log_rotate_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                       const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        cli_local_t             *local = NULL;
-
-        if (!((wordcount == 4) || (wordcount == 5))) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    if (!((wordcount == 4) || (wordcount == 5))) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (!((strcmp ("rotate", words[2]) == 0) ||
-              (strcmp ("rotate", words[3]) == 0))) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (!((strcmp("rotate", words[2]) == 0) ||
+          (strcmp("rotate", words[3]) == 0))) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LOG_ROTATE];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LOG_ROTATE];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = cli_cmd_log_rotate_parse (words, wordcount, &options);
-        if (ret)
-                goto out;
+    ret = cli_cmd_log_rotate_parse(words, wordcount, &options);
+    if (ret)
+        goto out;
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume log rotate failed");
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume log rotate failed");
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
 #if (SYNCDAEMON_COMPILE)
 static int
-cli_check_gsync_present ()
+cli_check_gsync_present()
 {
-        char                buff[PATH_MAX] = {0, };
-        runner_t            runner = {0,};
-        char                *ptr = NULL;
-        int                 ret = 0;
-
-        ret = setenv ("_GLUSTERD_CALLED_", "1", 1);
-        if (-1 == ret) {
-                gf_log ("", GF_LOG_WARNING, "setenv syscall failed, hence could"
-                        "not assert if geo-replication is installed");
-                goto out;
-        }
-
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "--version", NULL);
-        runner_redir (&runner, STDOUT_FILENO, RUN_PIPE);
-        ret = runner_start (&runner);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_INFO, "geo-replication not installed");
-                goto out;
-        }
+    char buff[PATH_MAX] = {
+        0,
+    };
+    runner_t runner = {
+        0,
+    };
+    char *ptr = NULL;
+    int ret = 0;
+
+    ret = setenv("_GLUSTERD_CALLED_", "1", 1);
+    if (-1 == ret) {
+        gf_log("", GF_LOG_WARNING,
+               "setenv syscall failed, hence could"
+               "not assert if geo-replication is installed");
+        goto out;
+    }
+
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "--version", NULL);
+    runner_redir(&runner, STDOUT_FILENO, RUN_PIPE);
+    ret = runner_start(&runner);
+    if (ret == -1) {
+        gf_log("", GF_LOG_INFO, "geo-replication not installed");
+        goto out;
+    }
 
-        ptr = fgets(buff, sizeof(buff), runner_chio (&runner, STDOUT_FILENO));
-        if (ptr) {
-                if (!strstr (buff, "gsyncd")) {
-                        ret  = -1;
-                        goto out;
-                }
-        } else {
-                ret = -1;
-                goto out;
+    ptr = fgets(buff, sizeof(buff), runner_chio(&runner, STDOUT_FILENO));
+    if (ptr) {
+        if (!strstr(buff, "gsyncd")) {
+            ret = -1;
+            goto out;
         }
+    } else {
+        ret = -1;
+        goto out;
+    }
 
-        ret = runner_end (&runner);
+    ret = runner_end(&runner);
 
-        if (ret)
-                gf_log ("", GF_LOG_ERROR, "geo-replication not installed");
+    if (ret)
+        gf_log("", GF_LOG_ERROR, "geo-replication not installed");
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret ? -1 : 0;
-
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret ? -1 : 0;
 }
 
 void
-cli_cmd_check_gsync_exists_cbk (struct cli_cmd *this)
+cli_cmd_check_gsync_exists_cbk(struct cli_cmd *this)
 {
+    int ret = 0;
 
-        int             ret = 0;
-
-        ret = cli_check_gsync_present ();
-        if (ret)
-                this->disable = _gf_true;
-
+    ret = cli_check_gsync_present();
+    if (ret)
+        this->disable = _gf_true;
 }
 #endif
 
 int
-cli_cmd_volume_gsync_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount)
+cli_cmd_volume_gsync_set_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                      ret     = 0;
-        int                      parse_err = 0;
-        dict_t                  *options = NULL;
-        rpc_clnt_procedure_t    *proc    = NULL;
-        call_frame_t            *frame   = NULL;
-        cli_local_t             *local   = NULL;
+    int ret = 0;
+    int parse_err = 0;
+    dict_t *options = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
 #if (USE_EVENTS)
-        int                      ret1       = -1;
-        int                      cmd_type   = -1;
-        int                      tmpi       = 0;
-        char                    *tmp        = NULL;
-        char                    *events_str = NULL;
-        int                      event_type = -1;
+    int ret1 = -1;
+    int cmd_type = -1;
+    int tmpi = 0;
+    char *tmp = NULL;
+    char *events_str = NULL;
+    int event_type = -1;
 #endif
 
-        proc = &cli_rpc_prog->proctable [GLUSTER_CLI_GSYNC_SET];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GSYNC_SET];
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (frame == NULL) {
-                ret = -1;
-                goto out;
-        }
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (frame == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_gsync_set_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    ret = cli_cmd_gsync_set_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_err = 1;
+        goto out;
+    }
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret && parse_err == 0)
-                cli_out (GEOREP" command failed");
+    if (ret && parse_err == 0)
+        cli_out(GEOREP " command failed");
 
 #if (USE_EVENTS)
-        if (ret == 0) {
-                events_str = gf_strdup ("");
-
-                /* Type of Geo-rep Action - Create, Start etc */
-                ret1 = dict_get_int32 (options, "type", &cmd_type);
+    if (ret == 0) {
+        events_str = gf_strdup("");
+
+        /* Type of Geo-rep Action - Create, Start etc */
+        ret1 = dict_get_int32(options, "type", &cmd_type);
+        if (ret1)
+            cmd_type = -1;
+
+        /* Only capture Events for modification commands */
+        switch (cmd_type) {
+            case GF_GSYNC_OPTION_TYPE_CREATE:
+                event_type = EVENT_GEOREP_CREATE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_START:
+                event_type = EVENT_GEOREP_START;
+                break;
+            case GF_GSYNC_OPTION_TYPE_STOP:
+                event_type = EVENT_GEOREP_STOP;
+                break;
+            case GF_GSYNC_OPTION_TYPE_PAUSE:
+                event_type = EVENT_GEOREP_PAUSE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_RESUME:
+                event_type = EVENT_GEOREP_RESUME;
+                break;
+            case GF_GSYNC_OPTION_TYPE_DELETE:
+                event_type = EVENT_GEOREP_DELETE;
+                break;
+            case GF_GSYNC_OPTION_TYPE_CONFIG:
+                ret1 = dict_get_str(options, "subop", &tmp);
                 if (ret1)
-                        cmd_type = -1;
-
-                /* Only capture Events for modification commands */
-                switch (cmd_type) {
-                case GF_GSYNC_OPTION_TYPE_CREATE:
-                        event_type = EVENT_GEOREP_CREATE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_START:
-                        event_type = EVENT_GEOREP_START;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_STOP:
-                        event_type = EVENT_GEOREP_STOP;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_PAUSE:
-                        event_type = EVENT_GEOREP_PAUSE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_RESUME:
-                        event_type = EVENT_GEOREP_RESUME;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_DELETE:
-                        event_type = EVENT_GEOREP_DELETE;
-                        break;
-                case GF_GSYNC_OPTION_TYPE_CONFIG:
-                        ret1 = dict_get_str (options, "subop", &tmp);
-                        if (ret1)
-                                tmp = "";
-
-                        /* For Config Set additionally capture key and value */
-                        /* For Config Reset capture key */
-                        if (strcmp (tmp, "set") == 0) {
-                                event_type = EVENT_GEOREP_CONFIG_SET;
-
-                                ret1 = dict_get_str (options, "op_name", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%soption=%s;",
-                                             events_str, tmp);
-
-                                ret1 = dict_get_str (options, "op_value", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%svalue=%s;",
-                                             events_str, tmp);
-                        } else if (strcmp (tmp, "del") == 0) {
-                                event_type = EVENT_GEOREP_CONFIG_RESET;
-
-                                ret1 = dict_get_str (options, "op_name", &tmp);
-                                if (ret1)
-                                        tmp = "";
-
-                                gf_asprintf (&events_str, "%soption=%s;",
-                                             events_str, tmp);
-                        }
-                        break;
-                default:
-                        break;
-                }
+                    tmp = "";
 
-                if (event_type > -1) {
-                        /* Capture all optional arguments used */
-                        ret1 = dict_get_int32 (options, "force", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sforce=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "push_pem", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%spush_pem=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "no_verify", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sno_verify=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "ssh_port", &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str, "%sssh_port=%d;",
-                                             events_str, tmpi);
-
-                        ret1 = dict_get_int32 (options, "reset-sync-time",
-                                               &tmpi);
-                        if (ret1 == 0)
-                                gf_asprintf (&events_str,
-                                             "%sreset_sync_time=%d;",
-                                             events_str, tmpi);
-
-                        /* Capture Master and Slave Info */
-                        ret1 = dict_get_str (options, "master", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%smaster=%s;",
-                                     events_str, tmp);
-
-                        ret1 = dict_get_str (options, "slave", &tmp);
-                        if (ret1)
-                                tmp = "";
-                        gf_asprintf (&events_str, "%sslave=%s",
-                                     events_str, tmp);
-
-                        gf_event (event_type, "%s", events_str);
-                }
+                /* For Config Set additionally capture key and value */
+                /* For Config Reset capture key */
+                if (strcmp(tmp, "set") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_SET;
 
-                /* Allocated by gf_strdup and gf_asprintf */
-                GF_FREE (events_str);
-        }
-#endif
+                    ret1 = dict_get_str(options, "op_name", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-        CLI_STACK_DESTROY (frame);
+                    gf_asprintf(&events_str, "%soption=%s;", events_str, tmp);
 
-        return ret;
-}
+                    ret1 = dict_get_str(options, "op_value", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-int
-cli_cmd_volume_status_cbk (struct cli_state *state,
-                           struct cli_cmd_word *word,
-                           const char **words, int wordcount)
-{
-        int                   ret         = -1;
-        rpc_clnt_procedure_t *proc        = NULL;
-        call_frame_t         *frame       = NULL;
-        dict_t               *dict        = NULL;
-        uint32_t              cmd         = 0;
-        cli_local_t          *local       = NULL;
+                    gf_asprintf(&events_str, "%svalue=%s;", events_str, tmp);
+                } else if (strcmp(tmp, "del") == 0) {
+                    event_type = EVENT_GEOREP_CONFIG_RESET;
 
-        ret = cli_cmd_volume_status_parse (words, wordcount, &dict);
+                    ret1 = dict_get_str(options, "op_name", &tmp);
+                    if (ret1)
+                        tmp = "";
 
-        if (ret) {
-                cli_usage_out (word->pattern);
-                goto out;
+                    gf_asprintf(&events_str, "%soption=%s;", events_str, tmp);
+                }
+                break;
+            default:
+                break;
         }
 
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
-
-        if (!(cmd & GF_CLI_STATUS_ALL)) {
-                /* for one volume or brick */
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_VOLUME];
-        } else {
-                /* volume status all or all detail */
-                proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_ALL];
-        }
+        if (event_type > -1) {
+            /* Capture all optional arguments used */
+            ret1 = dict_get_int32(options, "force", &tmpi);
+            if (ret1 == 0)
+                gf_asprintf(&events_str, "%sforce=%d;", events_str, tmpi);
 
-        if (!proc->fn)
-                goto out;
+            ret1 = dict_get_int32(options, "push_pem", &tmpi);
+            if (ret1 == 0)
+                gf_asprintf(&events_str, "%spush_pem=%d;", events_str, tmpi);
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+            ret1 = dict_get_int32(options, "no_verify", &tmpi);
+            if (ret1 == 0)
+                gf_asprintf(&events_str, "%sno_verify=%d;", events_str, tmpi);
 
-        CLI_LOCAL_INIT (local, words, frame, dict);
+            ret1 = dict_get_int32(options, "ssh_port", &tmpi);
+            if (ret1 == 0)
+                gf_asprintf(&events_str, "%sssh_port=%d;", events_str, tmpi);
 
-        ret = proc->fn (frame, THIS, dict);
+            ret1 = dict_get_int32(options, "reset-sync-time", &tmpi);
+            if (ret1 == 0)
+                gf_asprintf(&events_str, "%sreset_sync_time=%d;", events_str,
+                            tmpi);
 
-out:
-        CLI_STACK_DESTROY (frame);
+            /* Capture Master and Slave Info */
+            ret1 = dict_get_str(options, "master", &tmp);
+            if (ret1)
+                tmp = "";
+            gf_asprintf(&events_str, "%smaster=%s;", events_str, tmp);
 
-        return ret;
-}
+            ret1 = dict_get_str(options, "slave", &tmp);
+            if (ret1)
+                tmp = "";
+            gf_asprintf(&events_str, "%sslave=%s", events_str, tmp);
 
+            gf_event(event_type, "%s", events_str);
+        }
 
-int
-cli_get_detail_status (dict_t *dict, int i, cli_volume_status_t *status)
-{
-        uint64_t                   free            = 0;
-        uint64_t                   total           = 0;
-        char                       key[1024]       = {0};
-        int                        ret             = 0;
+        /* Allocated by gf_strdup and gf_asprintf */
+        GF_FREE(events_str);
+    }
+#endif
 
-        snprintf (key, sizeof (key), "brick%d.free", i);
-        ret = dict_get_uint64 (dict, key, &free);
+    CLI_STACK_DESTROY(frame);
 
-        status->free = gf_uint64_2human_readable (free);
-        if (!status->free)
-                goto out;
+    return ret;
+}
 
-        snprintf (key, sizeof (key), "brick%d.total", i);
-        ret = dict_get_uint64 (dict, key, &total);
+int
+cli_cmd_volume_status_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
+{
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    uint32_t cmd = 0;
+    cli_local_t *local = NULL;
 
-        status->total = gf_uint64_2human_readable (total);
-        if (!status->total)
-                goto out;
+    ret = cli_cmd_volume_status_parse(words, wordcount, &dict);
 
-        snprintf (key, sizeof (key), "brick%d.device", i);
-        ret = dict_get_str (dict, key, &(status->device));
-        if (ret)
-                status->device = NULL;
+    if (ret) {
+        cli_usage_out(word->pattern);
+        goto out;
+    }
 
-        snprintf (key, sizeof (key), "brick%d.block_size", i);
-        ret = dict_get_uint64 (dict, key, &(status->block_size));
-        if (ret) {
-                ret = 0;
-                status->block_size = 0;
-        }
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "brick%d.mnt_options", i);
-        ret = dict_get_str (dict, key, &(status->mount_options));
-        if (ret)
-                status->mount_options = NULL;
+    if (!(cmd & GF_CLI_STATUS_ALL)) {
+        /* for one volume or brick */
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_VOLUME];
+    } else {
+        /* volume status all or all detail */
+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_ALL];
+    }
 
-        snprintf (key, sizeof (key), "brick%d.fs_name", i);
-        ret = dict_get_str (dict, key, &(status->fs_name));
-        if (ret) {
-                ret = 0;
-                status->fs_name = NULL;
-        }
+    if (!proc->fn)
+        goto out;
 
-        snprintf (key, sizeof (key), "brick%d.inode_size", i);
-        ret = dict_get_str (dict, key, &(status->inode_size));
-        if (ret)
-                status->inode_size = NULL;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        snprintf (key, sizeof (key), "brick%d.total_inodes", i);
-        ret = dict_get_uint64 (dict, key,
-                        &(status->total_inodes));
-        if (ret)
-                status->total_inodes = 0;
+    CLI_LOCAL_INIT(local, words, frame, dict);
 
-        snprintf (key, sizeof (key), "brick%d.free_inodes", i);
-        ret = dict_get_uint64 (dict, key, &(status->free_inodes));
-        if (ret) {
-                ret = 0;
-                status->free_inodes = 0;
-        }
+    ret = proc->fn(frame, THIS, dict);
 
+out:
+    CLI_STACK_DESTROY(frame);
 
- out:
-        return ret;
+    return ret;
 }
 
-void
-cli_print_detailed_status (cli_volume_status_t *status)
+int
+cli_get_detail_status(dict_t *dict, int i, cli_volume_status_t *status)
 {
-        cli_out ("%-20s : %-20s", "Brick", status->brick);
+    uint64_t free = 0;
+    uint64_t total = 0;
+    char key[1024] = {0};
+    int ret = 0;
 
-        if (status->online) {
-                cli_out ("%-20s : %-20d", "TCP Port", status->port);
-                cli_out ("%-20s : %-20d", "RDMA Port", status->rdma_port);
-        } else {
-                cli_out ("%-20s : %-20s", "TCP Port", "N/A");
-                cli_out ("%-20s : %-20s", "RDMA Port", "N/A");
-        }
+    snprintf(key, sizeof(key), "brick%d.free", i);
+    ret = dict_get_uint64(dict, key, &free);
 
-        cli_out ("%-20s : %-20c", "Online", (status->online) ? 'Y' : 'N');
-        cli_out ("%-20s : %-20s", "Pid", status->pid_str);
+    status->free = gf_uint64_2human_readable(free);
+    if (!status->free)
+        goto out;
 
-        if (status->fs_name)
-                cli_out ("%-20s : %-20s", "File System", status->fs_name);
-        else
-                cli_out ("%-20s : %-20s", "File System", "N/A");
+    snprintf(key, sizeof(key), "brick%d.total", i);
+    ret = dict_get_uint64(dict, key, &total);
 
-        if (status->device)
-                cli_out ("%-20s : %-20s", "Device", status->device);
-        else
-                cli_out ("%-20s : %-20s", "Device", "N/A");
+    status->total = gf_uint64_2human_readable(total);
+    if (!status->total)
+        goto out;
 
-        if (status->mount_options) {
-                cli_out ("%-20s : %-20s", "Mount Options",
-                         status->mount_options);
-        } else {
-                cli_out ("%-20s : %-20s", "Mount Options", "N/A");
-        }
+    snprintf(key, sizeof(key), "brick%d.device", i);
+    ret = dict_get_str(dict, key, &(status->device));
+    if (ret)
+        status->device = NULL;
 
-        if (status->inode_size) {
-                cli_out ("%-20s : %-20s", "Inode Size",
-                         status->inode_size);
-        } else {
-                cli_out ("%-20s : %-20s", "Inode Size", "N/A");
-        }
-        if (status->free)
-                cli_out ("%-20s : %-20s", "Disk Space Free", status->free);
-        else
-                cli_out ("%-20s : %-20s", "Disk Space Free", "N/A");
+    snprintf(key, sizeof(key), "brick%d.block_size", i);
+    ret = dict_get_uint64(dict, key, &(status->block_size));
+    if (ret) {
+        ret = 0;
+        status->block_size = 0;
+    }
 
-        if (status->total)
-                cli_out ("%-20s : %-20s", "Total Disk Space", status->total);
-        else
-                cli_out ("%-20s : %-20s", "Total Disk Space", "N/A");
+    snprintf(key, sizeof(key), "brick%d.mnt_options", i);
+    ret = dict_get_str(dict, key, &(status->mount_options));
+    if (ret)
+        status->mount_options = NULL;
 
+    snprintf(key, sizeof(key), "brick%d.fs_name", i);
+    ret = dict_get_str(dict, key, &(status->fs_name));
+    if (ret) {
+        ret = 0;
+        status->fs_name = NULL;
+    }
+
+    snprintf(key, sizeof(key), "brick%d.inode_size", i);
+    ret = dict_get_str(dict, key, &(status->inode_size));
+    if (ret)
+        status->inode_size = NULL;
+
+    snprintf(key, sizeof(key), "brick%d.total_inodes", i);
+    ret = dict_get_uint64(dict, key, &(status->total_inodes));
+    if (ret)
+        status->total_inodes = 0;
+
+    snprintf(key, sizeof(key), "brick%d.free_inodes", i);
+    ret = dict_get_uint64(dict, key, &(status->free_inodes));
+    if (ret) {
+        ret = 0;
+        status->free_inodes = 0;
+    }
 
-        if (status->total_inodes) {
-                cli_out ("%-20s : %-20"GF_PRI_INODE, "Inode Count",
-                         status->total_inodes);
-        } else {
-                cli_out ("%-20s : %-20s", "Inode Count", "N/A");
-        }
+out:
+    return ret;
+}
 
-        if (status->free_inodes) {
-                cli_out ("%-20s : %-20"GF_PRI_INODE, "Free Inodes",
-                         status->free_inodes);
-        } else {
-                cli_out ("%-20s : %-20s", "Free Inodes", "N/A");
-        }
+void
+cli_print_detailed_status(cli_volume_status_t *status)
+{
+    cli_out("%-20s : %-20s", "Brick", status->brick);
+
+    if (status->online) {
+        cli_out("%-20s : %-20d", "TCP Port", status->port);
+        cli_out("%-20s : %-20d", "RDMA Port", status->rdma_port);
+    } else {
+        cli_out("%-20s : %-20s", "TCP Port", "N/A");
+        cli_out("%-20s : %-20s", "RDMA Port", "N/A");
+    }
+
+    cli_out("%-20s : %-20c", "Online", (status->online) ? 'Y' : 'N');
+    cli_out("%-20s : %-20s", "Pid", status->pid_str);
+
+    if (status->fs_name)
+        cli_out("%-20s : %-20s", "File System", status->fs_name);
+    else
+        cli_out("%-20s : %-20s", "File System", "N/A");
+
+    if (status->device)
+        cli_out("%-20s : %-20s", "Device", status->device);
+    else
+        cli_out("%-20s : %-20s", "Device", "N/A");
+
+    if (status->mount_options) {
+        cli_out("%-20s : %-20s", "Mount Options", status->mount_options);
+    } else {
+        cli_out("%-20s : %-20s", "Mount Options", "N/A");
+    }
+
+    if (status->inode_size) {
+        cli_out("%-20s : %-20s", "Inode Size", status->inode_size);
+    } else {
+        cli_out("%-20s : %-20s", "Inode Size", "N/A");
+    }
+    if (status->free)
+        cli_out("%-20s : %-20s", "Disk Space Free", status->free);
+    else
+        cli_out("%-20s : %-20s", "Disk Space Free", "N/A");
+
+    if (status->total)
+        cli_out("%-20s : %-20s", "Total Disk Space", status->total);
+    else
+        cli_out("%-20s : %-20s", "Total Disk Space", "N/A");
+
+    if (status->total_inodes) {
+        cli_out("%-20s : %-20" GF_PRI_INODE, "Inode Count",
+                status->total_inodes);
+    } else {
+        cli_out("%-20s : %-20s", "Inode Count", "N/A");
+    }
+
+    if (status->free_inodes) {
+        cli_out("%-20s : %-20" GF_PRI_INODE, "Free Inodes",
+                status->free_inodes);
+    } else {
+        cli_out("%-20s : %-20s", "Free Inodes", "N/A");
+    }
 }
 
 int
-cli_print_brick_status (cli_volume_status_t *status)
+cli_print_brick_status(cli_volume_status_t *status)
 {
-        int  fieldlen = CLI_VOL_STATUS_BRICK_LEN;
-        int  bricklen = 0;
-        char *p = NULL;
-        int  num_spaces = 0;
-
-        p = status->brick;
-        bricklen = strlen (p);
-        while (bricklen > 0) {
-                if (bricklen > fieldlen) {
-                        cli_out ("%.*s", fieldlen, p);
-                        p += fieldlen;
-                        bricklen -= fieldlen;
-                } else {
-                        num_spaces = (fieldlen - bricklen) + 1;
-                        printf ("%s", p);
-                        while (num_spaces-- != 0)
-                                printf (" ");
-                        if (status->port || status->rdma_port) {
-                                if (status->online)
-                                        cli_out ("%-10d%-11d%-8c%-5s",
-                                                 status->port,
-                                                 status->rdma_port,
-                                                 status->online?'Y':'N',
-                                                 status->pid_str);
-                                else
-                                        cli_out ("%-10s%-11s%-8c%-5s",
-                                                 "N/A",
-                                                 "N/A",
-                                                 status->online?'Y':'N',
-                                                 status->pid_str);
-                        }
-                        else
-                                cli_out ("%-10s%-11s%-8c%-5s",
-                                         "N/A", "N/A", status->online?'Y':'N',
-                                         status->pid_str);
-                        bricklen = 0;
-                }
+    int fieldlen = CLI_VOL_STATUS_BRICK_LEN;
+    int bricklen = 0;
+    char *p = NULL;
+    int num_spaces = 0;
+
+    p = status->brick;
+    bricklen = strlen(p);
+    while (bricklen > 0) {
+        if (bricklen > fieldlen) {
+            cli_out("%.*s", fieldlen, p);
+            p += fieldlen;
+            bricklen -= fieldlen;
+        } else {
+            num_spaces = (fieldlen - bricklen) + 1;
+            printf("%s", p);
+            while (num_spaces-- != 0)
+                printf(" ");
+            if (status->port || status->rdma_port) {
+                if (status->online)
+                    cli_out("%-10d%-11d%-8c%-5s", status->port,
+                            status->rdma_port, status->online ? 'Y' : 'N',
+                            status->pid_str);
+                else
+                    cli_out("%-10s%-11s%-8c%-5s", "N/A", "N/A",
+                            status->online ? 'Y' : 'N', status->pid_str);
+            } else
+                cli_out("%-10s%-11s%-8c%-5s", "N/A", "N/A",
+                        status->online ? 'Y' : 'N', status->pid_str);
+            bricklen = 0;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-#define NEEDS_GLFS_HEAL(op) ((op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) || \
-                             (op == GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME) ||\
-                             (op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) ||      \
-                             (op == GF_SHD_OP_INDEX_SUMMARY) ||               \
-                             (op == GF_SHD_OP_SPLIT_BRAIN_FILES) ||           \
-                             (op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) || \
-                             (op == GF_SHD_OP_HEAL_SUMMARY))
+#define NEEDS_GLFS_HEAL(op)                                                    \
+    ((op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) ||                         \
+     (op == GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME) ||                        \
+     (op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) ||                               \
+     (op == GF_SHD_OP_INDEX_SUMMARY) || (op == GF_SHD_OP_SPLIT_BRAIN_FILES) || \
+     (op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||                           \
+     (op == GF_SHD_OP_HEAL_SUMMARY))
 
 int
-cli_launch_glfs_heal (int heal_op, dict_t *options)
+cli_launch_glfs_heal(int heal_op, dict_t *options)
 {
-        char      buff[PATH_MAX] = {0};
-        runner_t  runner         = {0};
-        char      *filename      = NULL;
-        char      *hostname      = NULL;
-        char      *path          = NULL;
-        char      *volname       = NULL;
-        char      *out           = NULL;
-        int        ret           = 0;
-
-        runinit (&runner);
-        ret = dict_get_str (options, "volname", &volname);
-        runner_add_args (&runner, SBIN_DIR"/glfsheal", volname, NULL);
-        runner_redir (&runner, STDOUT_FILENO, RUN_PIPE);
-
-        switch (heal_op) {
+    char buff[PATH_MAX] = {0};
+    runner_t runner = {0};
+    char *filename = NULL;
+    char *hostname = NULL;
+    char *path = NULL;
+    char *volname = NULL;
+    char *out = NULL;
+    int ret = 0;
+
+    runinit(&runner);
+    ret = dict_get_str(options, "volname", &volname);
+    runner_add_args(&runner, SBIN_DIR "/glfsheal", volname, NULL);
+    runner_redir(&runner, STDOUT_FILENO, RUN_PIPE);
+
+    switch (heal_op) {
         case GF_SHD_OP_INDEX_SUMMARY:
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        runner_add_args (&runner, "xml", NULL);
-                }
-                break;
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "xml", NULL);
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                ret = dict_get_str (options, "file", &filename);
-                runner_add_args (&runner, "bigger-file", filename, NULL);
-                break;
+            ret = dict_get_str(options, "file", &filename);
+            runner_add_args(&runner, "bigger-file", filename, NULL);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                ret = dict_get_str (options, "file", &filename);
-                runner_add_args (&runner, "latest-mtime", filename, NULL);
-                break;
+            ret = dict_get_str(options, "file", &filename);
+            runner_add_args(&runner, "latest-mtime", filename, NULL);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (options, "heal-source-hostname",
-                                    &hostname);
-                ret = dict_get_str (options, "heal-source-brickpath",
-                                    &path);
-                runner_add_args (&runner, "source-brick", NULL);
-                runner_argprintf (&runner, "%s:%s", hostname, path);
-                if (dict_get_str (options, "file", &filename) == 0)
-                        runner_argprintf (&runner, filename);
-                break;
+            ret = dict_get_str(options, "heal-source-hostname", &hostname);
+            ret = dict_get_str(options, "heal-source-brickpath", &path);
+            runner_add_args(&runner, "source-brick", NULL);
+            runner_argprintf(&runner, "%s:%s", hostname, path);
+            if (dict_get_str(options, "file", &filename) == 0)
+                runner_argprintf(&runner, filename);
+            break;
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-                runner_add_args (&runner, "split-brain-info", NULL);
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        runner_add_args (&runner, "xml", NULL);
-                }
-                break;
+            runner_add_args(&runner, "split-brain-info", NULL);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "xml", NULL);
+            }
+            break;
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
-                runner_add_args (&runner, "granular-entry-heal-op", NULL);
-                break;
+            runner_add_args(&runner, "granular-entry-heal-op", NULL);
+            break;
         case GF_SHD_OP_HEAL_SUMMARY:
-                runner_add_args (&runner, "info-summary", NULL);
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        runner_add_args (&runner, "xml", NULL);
-                }
-                break;
+            runner_add_args(&runner, "info-summary", NULL);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                runner_add_args(&runner, "xml", NULL);
+            }
+            break;
         default:
-                ret = -1;
-                goto out;
-        }
-        ret = runner_start (&runner);
-        if (ret == -1)
-                goto out;
-        while ((out = fgets (buff, sizeof(buff),
-                             runner_chio (&runner, STDOUT_FILENO)))) {
-                printf ("%s", out);
-        }
-        ret = runner_end (&runner);
+            ret = -1;
+            goto out;
+    }
+    ret = runner_start(&runner);
+    if (ret == -1)
+        goto out;
+    while ((
+        out = fgets(buff, sizeof(buff), runner_chio(&runner, STDOUT_FILENO)))) {
+        printf("%s", out);
+    }
+    ret = runner_end(&runner);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_heal_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                          const char **words, int wordcount)
+cli_cmd_volume_heal_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
-        dict_t                  *options = NULL;
-        xlator_t                *this = NULL;
-        cli_local_t             *local = NULL;
-        int                     heal_op = 0;
-
-        this = THIS;
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    dict_t *options = NULL;
+    xlator_t *this = NULL;
+    cli_local_t *local = NULL;
+    int heal_op = 0;
+
+    this = THIS;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (wordcount < 3) {
-               cli_usage_out (word->pattern);
-               parse_error = 1;
-               goto out;
-        }
+    if (wordcount < 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        ret = cli_cmd_volume_heal_options_parse (words, wordcount, &options);
-        if (ret) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-        ret = dict_get_int32 (options, "heal-op", &heal_op);
+    ret = cli_cmd_volume_heal_options_parse(words, wordcount, &options);
+    if (ret) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+    ret = dict_get_int32(options, "heal-op", &heal_op);
+    if (ret < 0)
+        goto out;
+    if (NEEDS_GLFS_HEAL(heal_op)) {
+        ret = cli_launch_glfs_heal(heal_op, options);
         if (ret < 0)
-                goto out;
-        if (NEEDS_GLFS_HEAL (heal_op)) {
-                ret = cli_launch_glfs_heal (heal_op, options);
-                if (ret < 0)
-                        goto out;
-                if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                        goto out;
-        }
+            goto out;
+        if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+            goto out;
+    }
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_HEAL_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_HEAL_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0) &&
-                    !(global_state->mode & GLUSTER_MODE_XML)) {
-                        cli_out ("Volume heal failed.");
-                }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0) &&
+            !(global_state->mode & GLUSTER_MODE_XML)) {
+            cli_out("Volume heal failed.");
         }
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_statedump_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                              const char **words, int wordcount)
+cli_cmd_volume_statedump_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                             const char **words, int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        dict_t                          *options = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-        cli_local_t                     *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (wordcount < 3) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (wordcount < 3) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        if (wordcount >= 3) {
-               ret = cli_cmd_volume_statedump_options_parse (words, wordcount,
-                                                              &options);
-               if (ret) {
-                       parse_error = 1;
-                       gf_log ("cli", GF_LOG_ERROR, "Error parsing "
-                               "statedump options");
-                       cli_out ("Error parsing options");
-                       cli_usage_out (word->pattern);
-               }
+    if (wordcount >= 3) {
+        ret = cli_cmd_volume_statedump_options_parse(words, wordcount,
+                                                     &options);
+        if (ret) {
+            parse_error = 1;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Error parsing "
+                   "statedump options");
+            cli_out("Error parsing options");
+            cli_usage_out(word->pattern);
         }
+    }
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATEDUMP_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATEDUMP_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume statedump failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume statedump failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_list_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                         const char **words, int wordcount)
+cli_cmd_volume_list_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                        const char **words, int wordcount)
 {
-        int                     ret = -1;
-        call_frame_t            *frame = NULL;
-        rpc_clnt_procedure_t    *proc = NULL;
-        int                     sent = 0;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    rpc_clnt_procedure_t *proc = NULL;
+    int sent = 0;
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_VOLUME];
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, NULL);
-        }
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_VOLUME];
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, NULL);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if (sent == 0)
-                        cli_out ("Volume list failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if (sent == 0)
+            cli_out("Volume list failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_clearlocks_cbk (struct cli_state *state,
-                               struct cli_cmd_word *word,
-                               const char **words, int wordcount)
+cli_cmd_volume_clearlocks_cbk(struct cli_state *state,
+                              struct cli_cmd_word *word, const char **words,
+                              int wordcount)
 {
-        int                             ret = -1;
-        rpc_clnt_procedure_t            *proc = NULL;
-        call_frame_t                    *frame = NULL;
-        dict_t                          *options = NULL;
-        int                             sent = 0;
-        int                             parse_error = 0;
-        cli_local_t                     *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
-
-        if (wordcount < 7 || wordcount > 8) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
-
-       ret = cli_cmd_volume_clrlks_opts_parse (words, wordcount, &options);
-       if (ret) {
-               parse_error = 1;
-               gf_log ("cli", GF_LOG_ERROR, "Error parsing "
-                       "clear-locks options");
-               cli_out ("Error parsing options");
-               cli_usage_out (word->pattern);
-       }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    if (wordcount < 7 || wordcount > 8) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
+
+    ret = cli_cmd_volume_clrlks_opts_parse(words, wordcount, &options);
+    if (ret) {
+        parse_error = 1;
+        gf_log("cli", GF_LOG_ERROR,
+               "Error parsing "
+               "clear-locks options");
+        cli_out("Error parsing options");
+        cli_usage_out(word->pattern);
+    }
+
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "path", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "path", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CLRLOCKS_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CLRLOCKS_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn) {
-                ret = proc->fn (frame, THIS, options);
-        }
+    if (proc->fn) {
+        ret = proc->fn(frame, THIS, options);
+    }
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_out ("Volume clear-locks failed");
-        }
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_out("Volume clear-locks failed");
+    }
 
-        CLI_STACK_DESTROY (frame);
+    CLI_STACK_DESTROY(frame);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_volume_barrier_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                            const char **words, int wordcount)
+cli_cmd_volume_barrier_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                           const char **words, int wordcount)
 {
-        int ret = -1;
-        rpc_clnt_procedure_t *proc = NULL;
-        call_frame_t *frame = NULL;
-        dict_t *options = NULL;
-        int sent = 0;
-        int parse_error = 0;
-        cli_local_t *local = NULL;
-
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_error = 0;
+    cli_local_t *local = NULL;
+
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_error = 1;
-                goto out;
-        }
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_error = 1;
+        goto out;
+    }
 
-        options = dict_new();
-        if (!options) {
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str(options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    options = dict_new();
+    if (!options) {
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "barrier", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "barrier", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BARRIER_VOLUME];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BARRIER_VOLUME];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_error == 0))
-                        cli_err ("Volume barrier failed");
-        }
-        CLI_STACK_DESTROY (frame);
-
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_error == 0))
+            cli_err("Volume barrier failed");
+    }
+    CLI_STACK_DESTROY(frame);
+
+    return ret;
 }
 
 int
-cli_cmd_volume_getopt_cbk (struct cli_state *state, struct cli_cmd_word *word,
-                        const char **words, int wordcount)
+cli_cmd_volume_getopt_cbk(struct cli_state *state, struct cli_cmd_word *word,
+                          const char **words, int wordcount)
 {
-        int                   ret       = -1;
-        rpc_clnt_procedure_t *proc      = NULL;
-        call_frame_t         *frame     = NULL;
-        dict_t               *options   = NULL;
-        int                   sent      = 0;
-        int                   parse_err = 0;
-        cli_local_t          *local     = NULL;
-
-        if (wordcount != 4) {
-                cli_usage_out (word->pattern);
-                parse_err = 1;
-                goto out;
-        }
+    int ret = -1;
+    rpc_clnt_procedure_t *proc = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *options = NULL;
+    int sent = 0;
+    int parse_err = 0;
+    cli_local_t *local = NULL;
+
+    if (wordcount != 4) {
+        cli_usage_out(word->pattern);
+        parse_err = 1;
+        goto out;
+    }
 
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame)
+        goto out;
 
-        options = dict_new ();
-        if (!options)
-                goto out;
+    options = dict_new();
+    if (!options)
+        goto out;
 
-        ret = dict_set_str (options, "volname", (char *)words[2]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "volname", (char *)words[2]);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "key", (char *)words[3]);
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "key", (char *)words[3]);
+    if (ret)
+        goto out;
 
-        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOL_OPT];
+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOL_OPT];
 
-        CLI_LOCAL_INIT (local, words, frame, options);
+    CLI_LOCAL_INIT(local, words, frame, options);
 
-        if (proc->fn)
-                ret = proc->fn (frame, THIS, options);
+    if (proc->fn)
+        ret = proc->fn(frame, THIS, options);
 
 out:
-        if (ret) {
-                cli_cmd_sent_status_get (&sent);
-                if ((sent == 0) && (parse_err == 0))
-                        cli_err ("Volume get option failed");
-        }
-        CLI_STACK_DESTROY (frame);
-        return ret;
+    if (ret) {
+        cli_cmd_sent_status_get(&sent);
+        if ((sent == 0) && (parse_err == 0))
+            cli_err("Volume get option failed");
+    }
+    CLI_STACK_DESTROY(frame);
+    return ret;
 }
 
-
 /* This is a bit of a hack to display the help. The current bitrot cmd
  * format does not work well when registering the cmds.
  * Ideally the should have been of the form
@@ -3214,430 +3197,372 @@ out:
 
 struct cli_cmd bitrot_cmds[] = {
 
-        {"volume bitrot help",
-         cli_cmd_bitrot_help_cbk,
-         "display help for volume bitrot commands"
-        },
-
-        {"volume bitrot <VOLNAME> {enable|disable}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Enable/disable bitrot for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub-throttle {lazy|normal|aggressive}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Set the speed of the scrubber for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub-frequency {hourly|daily|weekly|biweekly"
-         "|monthly}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Set the frequency of the scrubber for volume <VOLNAME>"
-        },
-
-        {"volume bitrot <VOLNAME> scrub {pause|resume|status|ondemand}",
-         NULL, /*cli_cmd_bitrot_cbk,*/
-         "Pause/resume the scrubber for <VOLNAME>. Status displays the status of "
-         "the scrubber. ondemand starts the scrubber immediately."
-        },
-
-        {"volume bitrot <VOLNAME> {enable|disable}\n"
-         "volume bitrot <volname> scrub-throttle {lazy|normal|aggressive}\n"
-         "volume bitrot <volname> scrub-frequency {hourly|daily|weekly|biweekly"
-         "|monthly}\n"
-         "volume bitrot <volname> scrub {pause|resume|status|ondemand}",
-         cli_cmd_bitrot_cbk,
-         NULL
-        },
-
-        { NULL, NULL, NULL }
-};
+    {"volume bitrot help", cli_cmd_bitrot_help_cbk,
+     "display help for volume bitrot commands"},
+
+    {"volume bitrot <VOLNAME> {enable|disable}", NULL, /*cli_cmd_bitrot_cbk,*/
+     "Enable/disable bitrot for volume <VOLNAME>"},
+
+    {"volume bitrot <VOLNAME> scrub-throttle {lazy|normal|aggressive}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Set the speed of the scrubber for volume <VOLNAME>"},
+
+    {"volume bitrot <VOLNAME> scrub-frequency {hourly|daily|weekly|biweekly"
+     "|monthly}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Set the frequency of the scrubber for volume <VOLNAME>"},
 
+    {"volume bitrot <VOLNAME> scrub {pause|resume|status|ondemand}",
+     NULL, /*cli_cmd_bitrot_cbk,*/
+     "Pause/resume the scrubber for <VOLNAME>. Status displays the status of "
+     "the scrubber. ondemand starts the scrubber immediately."},
+
+    {"volume bitrot <VOLNAME> {enable|disable}\n"
+     "volume bitrot <volname> scrub-throttle {lazy|normal|aggressive}\n"
+     "volume bitrot <volname> scrub-frequency {hourly|daily|weekly|biweekly"
+     "|monthly}\n"
+     "volume bitrot <volname> scrub {pause|resume|status|ondemand}",
+     cli_cmd_bitrot_cbk, NULL},
+
+    {NULL, NULL, NULL}};
 
 struct cli_cmd quota_cmds[] = {
 
-        /* Quota commands */
-        {"volume quota help",
-         cli_cmd_quota_help_cbk,
-         "display help for volume quota commands"
-        },
-
-        {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
-         "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
-         "default-soft-limit <percent>}",
-         cli_cmd_quota_cbk,
-         "Enable/disable and configure quota for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}",
-         cli_cmd_quota_cbk,
-         "Set maximum size for <path> for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}",
-         cli_cmd_quota_cbk,
-         "Set the maximum number of entries allowed in <path> for <VOLNAME>"
-        },
-
-        {"volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
-         cli_cmd_quota_cbk,
-         "Set quota timeout for <VOLNAME>"
-        },
-
-        { "volume inode-quota <VOLNAME> enable",
-          cli_cmd_quota_cbk,
-          "Enable/disable inode-quota for <VOLNAME>"
-        },
-
-        { "volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
-          "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
-          "default-soft-limit <percent>}\n"
-          "volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}\n"
-          "volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}\n"
-          "volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
-          cli_cmd_quota_cbk,
-          NULL
-        },
-
-        { NULL, NULL, NULL }
-};
+    /* Quota commands */
+    {"volume quota help", cli_cmd_quota_help_cbk,
+     "display help for volume quota commands"},
+
+    {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
+     "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
+     "default-soft-limit <percent>}",
+     cli_cmd_quota_cbk, "Enable/disable and configure quota for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}",
+     cli_cmd_quota_cbk, "Set maximum size for <path> for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}",
+     cli_cmd_quota_cbk,
+     "Set the maximum number of entries allowed in <path> for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
+     cli_cmd_quota_cbk, "Set quota timeout for <VOLNAME>"},
+
+    {"volume inode-quota <VOLNAME> enable", cli_cmd_quota_cbk,
+     "Enable/disable inode-quota for <VOLNAME>"},
+
+    {"volume quota <VOLNAME> {enable|disable|list [<path> ...]| "
+     "list-objects [<path> ...] | remove <path>| remove-objects <path> | "
+     "default-soft-limit <percent>}\n"
+     "volume quota <VOLNAME> {limit-usage <path> <size> [<percent>]}\n"
+     "volume quota <VOLNAME> {limit-objects <path> <number> [<percent>]}\n"
+     "volume quota <VOLNAME> {alert-time|soft-timeout|hard-timeout} {<time>}",
+     cli_cmd_quota_cbk, NULL},
+
+    {NULL, NULL, NULL}};
 
 struct cli_cmd tier_cmds[] = {
 
-        { "volume tier help",
-          cli_cmd_tier_help_cbk,
-          "display help for volume tier commands"},
+    {"volume tier help", cli_cmd_tier_help_cbk,
+     "display help for volume tier commands"},
 
-        { "volume tier <VOLNAME> status",
-          cli_cmd_volume_tier_cbk,
-          "Display tier status for <VOLNAME>"},
+    {"volume tier <VOLNAME> status", cli_cmd_volume_tier_cbk,
+     "Display tier status for <VOLNAME>"},
 
-        { "volume tier <VOLNAME> start [force]",
-          cli_cmd_volume_tier_cbk,
-          "Start the tier service for <VOLNAME>"},
+    {"volume tier <VOLNAME> start [force]", cli_cmd_volume_tier_cbk,
+     "Start the tier service for <VOLNAME>"},
 
-        { "volume tier <VOLNAME> stop [force]",
-          cli_cmd_volume_tier_cbk,
-          "Stop the tier service for <VOLNAME>"},
+    {"volume tier <VOLNAME> stop [force]", cli_cmd_volume_tier_cbk,
+     "Stop the tier service for <VOLNAME>"},
 
-        { "volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]",
-          cli_cmd_volume_tier_cbk,
-          "Attach a hot tier to <VOLNAME>"},
+    {"volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]",
+     cli_cmd_volume_tier_cbk, "Attach a hot tier to <VOLNAME>"},
 
-        { "volume tier <VOLNAME> detach <start|stop|status|commit|[force]>",
-          cli_cmd_volume_tier_cbk,
-          "Detach the hot tier from <VOLNAME>"},
+    {"volume tier <VOLNAME> detach <start|stop|status|commit|[force]>",
+     cli_cmd_volume_tier_cbk, "Detach the hot tier from <VOLNAME>"},
 
-        { "volume attach-tier <VOLNAME> [<replica COUNT>] <NEW-BRICK>...",
-          cli_cmd_volume_tier_cbk,
-          "NOTE: this is old syntax, will be deprecated in next release. "
-          "Please use gluster volume tier <vol> attach "
-          "[<replica COUNT>] <NEW-BRICK>..."},
+    {"volume attach-tier <VOLNAME> [<replica COUNT>] <NEW-BRICK>...",
+     cli_cmd_volume_tier_cbk,
+     "NOTE: this is old syntax, will be deprecated in next release. "
+     "Please use gluster volume tier <vol> attach "
+     "[<replica COUNT>] <NEW-BRICK>..."},
 
-        { "volume detach-tier <VOLNAME> "
-          "<start|stop|status|commit|force>",
-          cli_cmd_volume_tier_cbk,
-          "NOTE: this is old syntax, will be deprecated in next release. "
-          "Please use gluster volume tier <vol> detach "
-          "{start|stop|commit} [force]"},
+    {"volume detach-tier <VOLNAME> "
+     "<start|stop|status|commit|force>",
+     cli_cmd_volume_tier_cbk,
+     "NOTE: this is old syntax, will be deprecated in next release. "
+     "Please use gluster volume tier <vol> detach "
+     "{start|stop|commit} [force]"},
 
-        { "volume tier <VOLNAME> status\n"
-          "volume tier <VOLNAME> start [force]\n"
-          "volume tier <VOLNAME> stop\n"
-          "volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]\n"
-          "volume tier <VOLNAME> detach <start|stop|status|commit|[force]>\n",
-          cli_cmd_volume_tier_cbk,
-          NULL },
+    {"volume tier <VOLNAME> status\n"
+     "volume tier <VOLNAME> start [force]\n"
+     "volume tier <VOLNAME> stop\n"
+     "volume tier <VOLNAME> attach [<replica COUNT>] <NEW-BRICK>... [force]\n"
+     "volume tier <VOLNAME> detach <start|stop|status|commit|[force]>\n",
+     cli_cmd_volume_tier_cbk, NULL},
 
-        {NULL, NULL, NULL}
+    {NULL, NULL, NULL}
 
-        };
+};
 
 struct cli_cmd volume_cmds[] = {
-        { "volume help",
-          cli_cmd_volume_help_cbk,
-          "display help for volume commands"},
-
-        { "volume info [all|<VOLNAME>]",
-          cli_cmd_volume_info_cbk,
-          "list information of all volumes"},
-
-        { "volume create <NEW-VOLNAME> [stripe <COUNT>] "
-          "[replica <COUNT> [arbiter <COUNT>]] "
-          "[disperse [<COUNT>]] [disperse-data <COUNT>] [redundancy <COUNT>] "
-          "[transport <tcp|rdma|tcp,rdma>] <NEW-BRICK>"
+    {"volume help", cli_cmd_volume_help_cbk,
+     "display help for volume commands"},
+
+    {"volume info [all|<VOLNAME>]", cli_cmd_volume_info_cbk,
+     "list information of all volumes"},
+
+    {"volume create <NEW-VOLNAME> [stripe <COUNT>] "
+     "[replica <COUNT> [arbiter <COUNT>]] "
+     "[disperse [<COUNT>]] [disperse-data <COUNT>] [redundancy <COUNT>] "
+     "[transport <tcp|rdma|tcp,rdma>] <NEW-BRICK>"
 #ifdef HAVE_BD_XLATOR
-          "?<vg_name>"
+     "?<vg_name>"
 #endif
-          "... [force]",
-
-          cli_cmd_volume_create_cbk,
-          "create a new volume of specified type with mentioned bricks"},
+     "... [force]",
 
-        { "volume delete <VOLNAME>",
-          cli_cmd_volume_delete_cbk,
-          "delete volume specified by <VOLNAME>"},
+     cli_cmd_volume_create_cbk,
+     "create a new volume of specified type with mentioned bricks"},
 
-        { "volume start <VOLNAME> [force]",
-          cli_cmd_volume_start_cbk,
-          "start volume specified by <VOLNAME>"},
+    {"volume delete <VOLNAME>", cli_cmd_volume_delete_cbk,
+     "delete volume specified by <VOLNAME>"},
 
-        { "volume stop <VOLNAME> [force]",
-          cli_cmd_volume_stop_cbk,
-          "stop volume specified by <VOLNAME>"},
+    {"volume start <VOLNAME> [force]", cli_cmd_volume_start_cbk,
+     "start volume specified by <VOLNAME>"},
 
-        /*{ "volume rename <VOLNAME> <NEW-VOLNAME>",
-          cli_cmd_volume_rename_cbk,
-          "rename volume <VOLNAME> to <NEW-VOLNAME>"},*/
+    {"volume stop <VOLNAME> [force]", cli_cmd_volume_stop_cbk,
+     "stop volume specified by <VOLNAME>"},
 
-        { "volume add-brick <VOLNAME> [<stripe|replica> <COUNT> "
-          "[arbiter <COUNT>]] <NEW-BRICK> ... [force]",
-          cli_cmd_volume_add_brick_cbk,
-          "add brick to volume <VOLNAME>"},
+    /*{ "volume rename <VOLNAME> <NEW-VOLNAME>",
+      cli_cmd_volume_rename_cbk,
+      "rename volume <VOLNAME> to <NEW-VOLNAME>"},*/
 
-        { "volume remove-brick <VOLNAME> [replica <COUNT>] <BRICK> ..."
-          " <start|stop|status|commit|force>",
-          cli_cmd_volume_remove_brick_cbk,
-          "remove brick from volume <VOLNAME>"},
+    {"volume add-brick <VOLNAME> [<stripe|replica> <COUNT> "
+     "[arbiter <COUNT>]] <NEW-BRICK> ... [force]",
+     cli_cmd_volume_add_brick_cbk, "add brick to volume <VOLNAME>"},
 
-        { "volume rebalance <VOLNAME> {{fix-layout start} | {start [force]|stop|status}}",
-          cli_cmd_volume_defrag_cbk,
-          "rebalance operations"},
+    {"volume remove-brick <VOLNAME> [replica <COUNT>] <BRICK> ..."
+     " <start|stop|status|commit|force>",
+     cli_cmd_volume_remove_brick_cbk, "remove brick from volume <VOLNAME>"},
 
-        { "volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> "
-          "{commit force}",
-          cli_cmd_volume_replace_brick_cbk,
-          "replace-brick operations"},
+    {"volume rebalance <VOLNAME> {{fix-layout start} | {start "
+     "[force]|stop|status}}",
+     cli_cmd_volume_defrag_cbk, "rebalance operations"},
 
-        /*{ "volume set-transport <VOLNAME> <TRANSPORT-TYPE> [<TRANSPORT-TYPE>] ...",
-          cli_cmd_volume_set_transport_cbk,
-          "set transport type for volume <VOLNAME>"},*/
+    {"volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> "
+     "{commit force}",
+     cli_cmd_volume_replace_brick_cbk, "replace-brick operations"},
 
-        { "volume set <VOLNAME> <KEY> <VALUE>",
-          cli_cmd_volume_set_cbk,
-         "set options for volume <VOLNAME>"},
+    /*{ "volume set-transport <VOLNAME> <TRANSPORT-TYPE> [<TRANSPORT-TYPE>]
+      ...", cli_cmd_volume_set_transport_cbk, "set transport type for volume
+      <VOLNAME>"},*/
 
+    {"volume set <VOLNAME> <KEY> <VALUE>", cli_cmd_volume_set_cbk,
+     "set options for volume <VOLNAME>"},
 
-        { "volume log <VOLNAME> rotate [BRICK]",
-          cli_cmd_log_rotate_cbk,
-         "rotate the log file for corresponding volume/brick"},
+    {"volume log <VOLNAME> rotate [BRICK]", cli_cmd_log_rotate_cbk,
+     "rotate the log file for corresponding volume/brick"},
 
-        { "volume log rotate <VOLNAME> [BRICK]",
-          cli_cmd_log_rotate_cbk,
-         "rotate the log file for corresponding volume/brick"
-         " NOTE: This is an old syntax, will be deprecated from next release."},
+    {"volume log rotate <VOLNAME> [BRICK]", cli_cmd_log_rotate_cbk,
+     "rotate the log file for corresponding volume/brick"
+     " NOTE: This is an old syntax, will be deprecated from next release."},
 
-        { "volume sync <HOSTNAME> [all|<VOLNAME>]",
-          cli_cmd_sync_volume_cbk,
-         "sync the volume information from a peer"},
+    {"volume sync <HOSTNAME> [all|<VOLNAME>]", cli_cmd_sync_volume_cbk,
+     "sync the volume information from a peer"},
 
-         { "volume reset <VOLNAME> [option] [force]",
-         cli_cmd_volume_reset_cbk,
-         "reset all the reconfigured options"},
+    {"volume reset <VOLNAME> [option] [force]", cli_cmd_volume_reset_cbk,
+     "reset all the reconfigured options"},
 
 #if (SYNCDAEMON_COMPILE)
-        {"volume "GEOREP" [<VOLNAME>] [<SLAVE-URL>] {create [[ssh-port n] [[no-verify]|[push-pem]]] [force]"
-         "|start [force]|stop [force]|pause [force]|resume [force]|config|status [detail]|delete [reset-sync-time]} [options...]",
-         cli_cmd_volume_gsync_set_cbk,
-         "Geo-sync operations",
-         cli_cmd_check_gsync_exists_cbk},
+    {"volume " GEOREP " [<VOLNAME>] [<SLAVE-URL>] {create [[ssh-port n] "
+                      "[[no-verify]|[push-pem]]] [force]"
+     "|start [force]|stop [force]|pause [force]|resume [force]|config|status "
+     "[detail]|delete [reset-sync-time]} [options...]",
+     cli_cmd_volume_gsync_set_cbk, "Geo-sync operations",
+     cli_cmd_check_gsync_exists_cbk},
 #endif
 
-         { "volume profile <VOLNAME> {start|info [peek|incremental [peek]|cumulative|clear]|stop} [nfs]",
-           cli_cmd_volume_profile_cbk,
-           "volume profile operations"},
-
-         { "volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick <brick>] [list-cnt <value>] |\n"
-           "volume top <VOLNAME> {read-perf|write-perf} [bs <size> count <count>] [brick <brick>] [list-cnt <value>]",
-           cli_cmd_volume_top_cbk,
-           "volume top operations"},
-
-        { "volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad|tierd]]"
-          " [detail|clients|mem|inode|fd|callpool|tasks|client-list]",
-          cli_cmd_volume_status_cbk,
-          "display status of all or specified volume(s)/brick"},
-
-        { "volume heal <VOLNAME> [enable | disable | full |"
-          "statistics [heal-count [replica <HOSTNAME:BRICKNAME>]] |"
-          "info [summary | split-brain] |"
-          "split-brain {bigger-file <FILE> | latest-mtime <FILE> |"
-                       "source-brick <HOSTNAME:BRICKNAME> [<FILE>]} |"
-          "granular-entry-heal {enable | disable}]",
-          cli_cmd_volume_heal_cbk,
-          "self-heal commands on volume specified by <VOLNAME>"},
-
-        {"volume statedump <VOLNAME> [[nfs|quotad] [all|mem|iobuf|callpool|"
-         "priv|fd|inode|history]... | [client <hostname:process-id>]]",
-         cli_cmd_volume_statedump_cbk,
-         "perform statedump on bricks"},
-
-        {"volume list",
-         cli_cmd_volume_list_cbk,
-         "list all volumes in cluster"},
-
-        {"volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}"
-          "{inode [range]|entry [basename]|posix [range]}",
-          cli_cmd_volume_clearlocks_cbk,
-          "Clear locks held on path"
-        },
-        {"volume barrier <VOLNAME> {enable|disable}",
-         cli_cmd_volume_barrier_cbk,
-         "Barrier/unbarrier file operations on a volume"
-        },
-        {"volume get <VOLNAME|all> <key|all>",
-         cli_cmd_volume_getopt_cbk,
-         "Get the value of the all options or given option for volume <VOLNAME>"
-         " or all option. gluster volume get all all is to get all global "
-         "options"
-        },
-
-        { "volume reset-brick <VOLNAME> <SOURCE-BRICK> {{start} |"
-          " {<NEW-BRICK> commit}}",
-          cli_cmd_volume_reset_brick_cbk,
-          "reset-brick operations"},
-
-
-        { NULL, NULL, NULL }
-};
+    {"volume profile <VOLNAME> {start|info [peek|incremental "
+     "[peek]|cumulative|clear]|stop} [nfs]",
+     cli_cmd_volume_profile_cbk, "volume profile operations"},
+
+    {"volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick "
+     "<brick>] [list-cnt <value>] |\n"
+     "volume top <VOLNAME> {read-perf|write-perf} [bs <size> count <count>] "
+     "[brick <brick>] [list-cnt <value>]",
+     cli_cmd_volume_top_cbk, "volume top operations"},
+
+    {"volume status [all | <VOLNAME> [nfs|shd|<BRICK>|quotad|tierd]]"
+     " [detail|clients|mem|inode|fd|callpool|tasks|client-list]",
+     cli_cmd_volume_status_cbk,
+     "display status of all or specified volume(s)/brick"},
+
+    {"volume heal <VOLNAME> [enable | disable | full |"
+     "statistics [heal-count [replica <HOSTNAME:BRICKNAME>]] |"
+     "info [summary | split-brain] |"
+     "split-brain {bigger-file <FILE> | latest-mtime <FILE> |"
+     "source-brick <HOSTNAME:BRICKNAME> [<FILE>]} |"
+     "granular-entry-heal {enable | disable}]",
+     cli_cmd_volume_heal_cbk,
+     "self-heal commands on volume specified by <VOLNAME>"},
+
+    {"volume statedump <VOLNAME> [[nfs|quotad] [all|mem|iobuf|callpool|"
+     "priv|fd|inode|history]... | [client <hostname:process-id>]]",
+     cli_cmd_volume_statedump_cbk, "perform statedump on bricks"},
+
+    {"volume list", cli_cmd_volume_list_cbk, "list all volumes in cluster"},
+
+    {"volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}"
+     "{inode [range]|entry [basename]|posix [range]}",
+     cli_cmd_volume_clearlocks_cbk, "Clear locks held on path"},
+    {"volume barrier <VOLNAME> {enable|disable}", cli_cmd_volume_barrier_cbk,
+     "Barrier/unbarrier file operations on a volume"},
+    {"volume get <VOLNAME|all> <key|all>", cli_cmd_volume_getopt_cbk,
+     "Get the value of the all options or given option for volume <VOLNAME>"
+     " or all option. gluster volume get all all is to get all global "
+     "options"},
+
+    {"volume reset-brick <VOLNAME> <SOURCE-BRICK> {{start} |"
+     " {<NEW-BRICK> commit}}",
+     cli_cmd_volume_reset_brick_cbk, "reset-brick operations"},
+
+    {NULL, NULL, NULL}};
 
 int
-cli_cmd_quota_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                        const char **words, int wordcount)
+cli_cmd_quota_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                       const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *quota_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *quota_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_MALLOC (sizeof (quota_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, quota_cmds, sizeof (quota_cmds));
-        count = (sizeof (quota_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(quota_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, quota_cmds, sizeof(quota_cmds));
+    count = (sizeof(quota_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster quota commands");
-        cli_out ("=======================\n");
+    cli_out("\ngluster quota commands");
+    cli_out("=======================\n");
 
-        for (quota_cmd = cmd; quota_cmd->pattern; quota_cmd++)
-                if ((_gf_false == quota_cmd->disable) && (quota_cmd->desc))
-                        cli_out ("%s - %s", quota_cmd->pattern,
-                                 quota_cmd->desc);
+    for (quota_cmd = cmd; quota_cmd->pattern; quota_cmd++)
+        if ((_gf_false == quota_cmd->disable) && (quota_cmd->desc))
+            cli_out("%s - %s", quota_cmd->pattern, quota_cmd->desc);
 
-        cli_out ("\n");
-        GF_FREE (cmd);
+    cli_out("\n");
+    GF_FREE(cmd);
 
-        return 0;
+    return 0;
 }
 
 int
-cli_cmd_bitrot_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_bitrot_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *bitrot_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *bitrot_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_MALLOC (sizeof (bitrot_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, bitrot_cmds, sizeof (bitrot_cmds));
-        count = (sizeof (bitrot_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(bitrot_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, bitrot_cmds, sizeof(bitrot_cmds));
+    count = (sizeof(bitrot_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster bitrot commands");
-        cli_out ("========================\n");
+    cli_out("\ngluster bitrot commands");
+    cli_out("========================\n");
 
-        for (bitrot_cmd = cmd; bitrot_cmd->pattern; bitrot_cmd++)
-                if ((_gf_false == bitrot_cmd->disable) && (bitrot_cmd->desc))
-                        cli_out ("%s - %s", bitrot_cmd->pattern,
-                                 bitrot_cmd->desc);
+    for (bitrot_cmd = cmd; bitrot_cmd->pattern; bitrot_cmd++)
+        if ((_gf_false == bitrot_cmd->disable) && (bitrot_cmd->desc))
+            cli_out("%s - %s", bitrot_cmd->pattern, bitrot_cmd->desc);
 
-        cli_out ("\n");
-        GF_FREE (cmd);
+    cli_out("\n");
+    GF_FREE(cmd);
 
-        return 0;
+    return 0;
 }
 
 int
-cli_cmd_tier_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                       const char **words, int wordcount)
+cli_cmd_tier_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                      const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *tier_cmd = NULL;
-        int                   count    = 0;
-
-        cmd = GF_MALLOC (sizeof (tier_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, tier_cmds, sizeof (tier_cmds));
-        count = (sizeof (tier_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
-
-        cli_out ("\ngluster tier commands");
-        cli_out ("======================\n");
-
-        for (tier_cmd = cmd; tier_cmd->pattern; tier_cmd++) {
-                if ((_gf_false == tier_cmd->disable) && tier_cmd->desc) {
-                        cli_out ("%s - %s", tier_cmd->pattern, tier_cmd->desc);
-                }
-        }
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *tier_cmd = NULL;
+    int count = 0;
+
+    cmd = GF_MALLOC(sizeof(tier_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, tier_cmds, sizeof(tier_cmds));
+    count = (sizeof(tier_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
+
+    cli_out("\ngluster tier commands");
+    cli_out("======================\n");
+
+    for (tier_cmd = cmd; tier_cmd->pattern; tier_cmd++) {
+        if ((_gf_false == tier_cmd->disable) && tier_cmd->desc) {
+            cli_out("%s - %s", tier_cmd->pattern, tier_cmd->desc);
+        }
+    }
+    cli_out("\n");
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                         const char **words, int wordcount)
+cli_cmd_volume_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                        const char **words, int wordcount)
 {
-        struct cli_cmd        *cmd     = NULL;
-        struct cli_cmd        *vol_cmd = NULL;
-        int                   count    = 0;
+    struct cli_cmd *cmd = NULL;
+    struct cli_cmd *vol_cmd = NULL;
+    int count = 0;
 
-        cmd = GF_MALLOC (sizeof (volume_cmds), cli_mt_cli_cmd);
-        memcpy (cmd, volume_cmds, sizeof (volume_cmds));
-        count = (sizeof (volume_cmds) / sizeof (struct cli_cmd));
-        cli_cmd_sort (cmd, count);
+    cmd = GF_MALLOC(sizeof(volume_cmds), cli_mt_cli_cmd);
+    memcpy(cmd, volume_cmds, sizeof(volume_cmds));
+    count = (sizeof(volume_cmds) / sizeof(struct cli_cmd));
+    cli_cmd_sort(cmd, count);
 
-        cli_out ("\ngluster volume commands");
-        cli_out ("========================\n");
+    cli_out("\ngluster volume commands");
+    cli_out("========================\n");
 
-        for (vol_cmd = cmd; vol_cmd->pattern; vol_cmd++)
-                if (_gf_false == vol_cmd->disable)
-                        cli_out ("%s - %s", vol_cmd->pattern, vol_cmd->desc);
+    for (vol_cmd = cmd; vol_cmd->pattern; vol_cmd++)
+        if (_gf_false == vol_cmd->disable)
+            cli_out("%s - %s", vol_cmd->pattern, vol_cmd->desc);
 
-        cli_out ("\n");
-        GF_FREE (cmd);
-        return 0;
+    cli_out("\n");
+    GF_FREE(cmd);
+    return 0;
 }
 
 int
-cli_cmd_volume_register (struct cli_state *state)
+cli_cmd_volume_register(struct cli_state *state)
 {
-        int  ret = 0;
-        struct cli_cmd *cmd = NULL;
+    int ret = 0;
+    struct cli_cmd *cmd = NULL;
 
-        for (cmd = volume_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = volume_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
-        for (cmd = bitrot_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = bitrot_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
-        for (cmd = quota_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = quota_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
 #if !defined(__NetBSD__)
-        for (cmd = tier_cmds; cmd->pattern; cmd++) {
-                ret = cli_cmd_register (&state->tree, cmd);
-                if (ret)
-                        goto out;
-        }
+    for (cmd = tier_cmds; cmd->pattern; cmd++) {
+        ret = cli_cmd_register(&state->tree, cmd);
+        if (ret)
+            goto out;
+    }
 
 #endif
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/cli/src/cli-cmd.c b/cli/src/cli-cmd.c
index 236009b449e..396cabebbbe 100644
--- a/cli/src/cli-cmd.c
+++ b/cli/src/cli-cmd.c
@@ -22,395 +22,390 @@
 
 static int cmd_done;
 static int cmd_sent;
-static pthread_cond_t      cond  = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t     cond_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t      conn  = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t     conn_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t conn = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t conn_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-int    cli_op_ret = 0;
-int    connected = 0;
+int cli_op_ret = 0;
+int connected = 0;
 
-int cli_cmd_log_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
-                      const char **words, int wordcount);
+int
+cli_cmd_log_help_cbk(struct cli_state *state, struct cli_cmd_word *in_word,
+                     const char **words, int wordcount);
 
 static unsigned
-cli_cmd_needs_connection (struct cli_cmd_word *word)
+cli_cmd_needs_connection(struct cli_cmd_word *word)
 {
-        if (!strcasecmp ("quit", word->word))
-                return 0;
+    if (!strcasecmp("quit", word->word))
+        return 0;
 
-        if (!strcasecmp ("help", word->word))
-                return 0;
+    if (!strcasecmp("help", word->word))
+        return 0;
 
-        if (!strcasecmp ("getwd", word->word))
-                return 1;
+    if (!strcasecmp("getwd", word->word))
+        return 1;
 
-        if (!strcasecmp ("exit", word->word))
-                return 0;
+    if (!strcasecmp("exit", word->word))
+        return 0;
 
-        return cli_default_conn_timeout;
+    return cli_default_conn_timeout;
 }
 
 int
-cli_cmd_status_reset (void)
+cli_cmd_status_reset(void)
 {
-        int ret = 0;
-
-        ret = cli_cmd_lock ();
-        {
-                if (ret == 0) {
-                        cmd_sent = 0;
-                        cmd_done = 0;
-                }
-        }
-        ret = cli_cmd_unlock ();
-        return ret;
+    int ret = 0;
 
+    ret = cli_cmd_lock();
+    {
+        if (ret == 0) {
+            cmd_sent = 0;
+            cmd_done = 0;
+        }
+    }
+    ret = cli_cmd_unlock();
+    return ret;
 }
 
 int
-cli_cmd_sent_status_get (int *status)
+cli_cmd_sent_status_get(int *status)
 {
-        int ret = 0;
-        GF_ASSERT (status);
-
-        ret = cli_cmd_lock ();
-        {
-                if (ret == 0)
-                        *status = cmd_sent;
-        }
-        ret = cli_cmd_unlock ();
-        return ret;
+    int ret = 0;
+    GF_ASSERT(status);
+
+    ret = cli_cmd_lock();
+    {
+        if (ret == 0)
+            *status = cmd_sent;
+    }
+    ret = cli_cmd_unlock();
+    return ret;
 }
 
 int
-cli_cmd_process (struct cli_state *state, int argc, char **argv)
+cli_cmd_process(struct cli_state *state, int argc, char **argv)
 {
-        int                  ret = 0;
-        struct cli_cmd_word *word = NULL;
-        struct cli_cmd_word *next = NULL;
-        int                  i = 0;
+    int ret = 0;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
+    int i = 0;
 
-        word = &state->tree.root;
+    word = &state->tree.root;
 
-        if (!argc)
-                return 0;
+    if (!argc)
+        return 0;
 
-        for (i = 0; i < argc; i++) {
-                next = cli_cmd_nextword (word, argv[i]);
+    for (i = 0; i < argc; i++) {
+        next = cli_cmd_nextword(word, argv[i]);
 
-                word = next;
-                if (!word)
-                        break;
+        word = next;
+        if (!word)
+            break;
 
-                if (word->cbkfn)
-                        break;
-        }
+        if (word->cbkfn)
+            break;
+    }
 
-        if (!word) {
-                cli_out ("unrecognized word: %s (position %d)",
-                         argv[i], i);
-                return -1;
-        }
+    if (!word) {
+        cli_out("unrecognized word: %s (position %d)", argv[i], i);
+        return -1;
+    }
 
-        if (!word->cbkfn) {
-                cli_out ("unrecognized command");
-                return -1;
-        }
+    if (!word->cbkfn) {
+        cli_out("unrecognized command");
+        return -1;
+    }
 
-	if ( strcmp (word->word,"help")==0 )
-		goto callback;
+    if (strcmp(word->word, "help") == 0)
+        goto callback;
 
-        state->await_connected = cli_cmd_needs_connection (word);
+    state->await_connected = cli_cmd_needs_connection(word);
 
-        ret = cli_cmd_await_connected (state->await_connected);
-        if (ret) {
-                cli_out ("Connection failed. Please check if gluster "
-                          "daemon is operational.");
-                gf_log ("", GF_LOG_INFO, "Exiting with: %d", ret);
-                exit (ret);
-        }
+    ret = cli_cmd_await_connected(state->await_connected);
+    if (ret) {
+        cli_out(
+            "Connection failed. Please check if gluster "
+            "daemon is operational.");
+        gf_log("", GF_LOG_INFO, "Exiting with: %d", ret);
+        exit(ret);
+    }
 
 callback:
-        ret = word->cbkfn (state, word, (const char **)argv, argc);
-        (void) cli_cmd_status_reset ();
-        return ret;
+    ret = word->cbkfn(state, word, (const char **)argv, argc);
+    (void)cli_cmd_status_reset();
+    return ret;
 }
 
 int
-cli_cmd_input_token_count (const char *text)
+cli_cmd_input_token_count(const char *text)
 {
-        int          count = 0;
-        const char  *trav = NULL;
-        int          is_spc = 1;
-
-        for (trav = text; *trav; trav++) {
-                if (*trav == ' ') {
-                        is_spc = 1;
-                } else {
-                        if (is_spc) {
-                                count++;
-                                is_spc = 0;
-                        }
-                }
+    int count = 0;
+    const char *trav = NULL;
+    int is_spc = 1;
+
+    for (trav = text; *trav; trav++) {
+        if (*trav == ' ') {
+            is_spc = 1;
+        } else {
+            if (is_spc) {
+                count++;
+                is_spc = 0;
+            }
         }
+    }
 
-        return count;
+    return count;
 }
 
-
 int
-cli_cmd_process_line (struct cli_state *state, const char *text)
+cli_cmd_process_line(struct cli_state *state, const char *text)
 {
-        int     count = 0;
-        char  **tokens = NULL;
-        char  **tokenp = NULL;
-        char   *token = NULL;
-        char   *copy = NULL;
-        char   *saveptr = NULL;
-        int     i = 0;
-        int     ret = -1;
-
-        count = cli_cmd_input_token_count (text);
-
-        tokens = calloc (count + 1, sizeof (*tokens));
-        if (!tokens)
-                return -1;
-
-        copy = strdup (text);
-        if (!copy)
-                goto out;
-
-        tokenp = tokens;
-
-        for (token = strtok_r (copy, " \t\r\n", &saveptr); token;
-             token = strtok_r (NULL, " \t\r\n", &saveptr)) {
-                *tokenp = strdup (token);
-
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-
-        }
-
-        ret = cli_cmd_process (state, count, tokens);
+    int count = 0;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char *copy = NULL;
+    char *saveptr = NULL;
+    int i = 0;
+    int ret = -1;
+
+    count = cli_cmd_input_token_count(text);
+
+    tokens = calloc(count + 1, sizeof(*tokens));
+    if (!tokens)
+        return -1;
+
+    copy = strdup(text);
+    if (!copy)
+        goto out;
+
+    tokenp = tokens;
+
+    for (token = strtok_r(copy, " \t\r\n", &saveptr); token;
+         token = strtok_r(NULL, " \t\r\n", &saveptr)) {
+        *tokenp = strdup(token);
+
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
+
+    ret = cli_cmd_process(state, count, tokens);
 out:
-        free (copy);
+    free(copy);
 
-        if (tokens)
-                cli_cmd_tokens_destroy (tokens);
+    if (tokens)
+        cli_cmd_tokens_destroy(tokens);
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmds_register (struct cli_state *state)
+cli_cmds_register(struct cli_state *state)
 {
-        int  ret = 0;
-
-        ret = cli_cmd_volume_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_probe_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_system_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_misc_register (state);
-        if (ret)
-                goto out;
-
-        ret = cli_cmd_snapshot_register (state);
-        if (ret)
-                goto out;
-        ret = cli_cmd_global_register (state);
-        if (ret)
-                goto out;
+    int ret = 0;
+
+    ret = cli_cmd_volume_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_probe_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_system_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_misc_register(state);
+    if (ret)
+        goto out;
+
+    ret = cli_cmd_snapshot_register(state);
+    if (ret)
+        goto out;
+    ret = cli_cmd_global_register(state);
+    if (ret)
+        goto out;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_cmd_cond_init ()
+cli_cmd_cond_init()
 {
+    pthread_mutex_init(&cond_mutex, NULL);
+    pthread_cond_init(&cond, NULL);
 
-       pthread_mutex_init (&cond_mutex, NULL);
-       pthread_cond_init (&cond, NULL);
+    pthread_mutex_init(&conn_mutex, NULL);
+    pthread_cond_init(&conn, NULL);
 
-       pthread_mutex_init (&conn_mutex, NULL);
-       pthread_cond_init (&conn, NULL);
-
-       return 0;
+    return 0;
 }
 
 int
-cli_cmd_lock ()
+cli_cmd_lock()
 {
-       pthread_mutex_lock (&cond_mutex);
-       return 0;
+    pthread_mutex_lock(&cond_mutex);
+    return 0;
 }
 
 int
-cli_cmd_unlock ()
+cli_cmd_unlock()
 {
-        pthread_mutex_unlock (&cond_mutex);
-        return 0;
+    pthread_mutex_unlock(&cond_mutex);
+    return 0;
 }
 
 static void
-seconds_from_now (unsigned secs, struct timespec *ts)
+seconds_from_now(unsigned secs, struct timespec *ts)
 {
-        struct timeval tv = {0,};
+    struct timeval tv = {
+        0,
+    };
 
-        gettimeofday (&tv, NULL);
+    gettimeofday(&tv, NULL);
 
-        ts->tv_sec = tv.tv_sec + secs;
-        ts->tv_nsec = tv.tv_usec * 1000;
+    ts->tv_sec = tv.tv_sec + secs;
+    ts->tv_nsec = tv.tv_usec * 1000;
 }
 
 int
-cli_cmd_await_response (unsigned time)
+cli_cmd_await_response(unsigned time)
 {
-        struct  timespec        ts = {0,};
-        int                     ret = 0;
+    struct timespec ts = {
+        0,
+    };
+    int ret = 0;
 
-        cli_op_ret = -1;
+    cli_op_ret = -1;
 
-        seconds_from_now (time, &ts);
-        while (!cmd_done && !ret) {
-                ret = pthread_cond_timedwait (&cond, &cond_mutex,
-                                        &ts);
-        }
+    seconds_from_now(time, &ts);
+    while (!cmd_done && !ret) {
+        ret = pthread_cond_timedwait(&cond, &cond_mutex, &ts);
+    }
 
-        if (!cmd_done) {
-                if (ret == ETIMEDOUT)
-                        cli_out ("Error : Request timed out");
-                else
-                        cli_out ("Error : Command returned with error code:%d",
-                                 ret);
-        }
-        cmd_done = 0;
+    if (!cmd_done) {
+        if (ret == ETIMEDOUT)
+            cli_out("Error : Request timed out");
+        else
+            cli_out("Error : Command returned with error code:%d", ret);
+    }
+    cmd_done = 0;
 
-        return cli_op_ret;
+    return cli_op_ret;
 }
 
 /* This function must be called _only_ after all actions associated with
  * command processing is complete. Otherwise, gluster process may exit before
  * reporting results to stdout/stderr. */
 int
-cli_cmd_broadcast_response (int32_t status)
+cli_cmd_broadcast_response(int32_t status)
 {
-
-        pthread_mutex_lock (&cond_mutex);
-        {
-                if (!cmd_sent)
-                        goto out;
-                cmd_done = 1;
-                cli_op_ret = status;
-                pthread_cond_broadcast (&cond);
-        }
-
+    pthread_mutex_lock(&cond_mutex);
+    {
+        if (!cmd_sent)
+            goto out;
+        cmd_done = 1;
+        cli_op_ret = status;
+        pthread_cond_broadcast(&cond);
+    }
 
 out:
-        pthread_mutex_unlock (&cond_mutex);
-        return 0;
+    pthread_mutex_unlock(&cond_mutex);
+    return 0;
 }
 
 int32_t
-cli_cmd_await_connected (unsigned conn_timo)
+cli_cmd_await_connected(unsigned conn_timo)
 {
-        int32_t                 ret = 0;
-        struct  timespec        ts = {0,};
-
-        if (!conn_timo)
-                return 0;
-
-        pthread_mutex_lock (&conn_mutex);
-        {
-                seconds_from_now (conn_timo, &ts);
-                while (!connected && !ret) {
-                        ret = pthread_cond_timedwait (&conn, &conn_mutex,
-                                                      &ts);
-                }
-        }
-        pthread_mutex_unlock (&conn_mutex);
+    int32_t ret = 0;
+    struct timespec ts = {
+        0,
+    };
 
+    if (!conn_timo)
+        return 0;
+
+    pthread_mutex_lock(&conn_mutex);
+    {
+        seconds_from_now(conn_timo, &ts);
+        while (!connected && !ret) {
+            ret = pthread_cond_timedwait(&conn, &conn_mutex, &ts);
+        }
+    }
+    pthread_mutex_unlock(&conn_mutex);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-cli_cmd_broadcast_connected ()
+cli_cmd_broadcast_connected()
 {
-        pthread_mutex_lock (&conn_mutex);
-        {
-                connected = 1;
-                pthread_cond_broadcast (&conn);
-        }
+    pthread_mutex_lock(&conn_mutex);
+    {
+        connected = 1;
+        pthread_cond_broadcast(&conn);
+    }
 
-        pthread_mutex_unlock (&conn_mutex);
+    pthread_mutex_unlock(&conn_mutex);
 
-        return 0;
+    return 0;
 }
 
 int
-cli_cmd_submit (struct rpc_clnt* rpc, void *req, call_frame_t *frame,
-                rpc_clnt_prog_t *prog,
-                int procnum, struct iobref *iobref,
-                xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+cli_cmd_submit(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+               rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+               xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
 {
-        int             ret = -1;
-        unsigned        timeout = 0;
+    int ret = -1;
+    unsigned timeout = 0;
 
-        if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||
-            (GLUSTER_CLI_HEAL_VOLUME == procnum))
-                timeout = cli_ten_minutes_timeout;
-        else
-                timeout = cli_default_conn_timeout;
+    if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||
+        (GLUSTER_CLI_HEAL_VOLUME == procnum))
+        timeout = cli_ten_minutes_timeout;
+    else
+        timeout = cli_default_conn_timeout;
 
-        cli_cmd_lock ();
-        cmd_sent = 0;
-        ret = cli_submit_request (rpc, req, frame, prog,
-                                  procnum, NULL, this, cbkfn, xdrproc);
+    cli_cmd_lock();
+    cmd_sent = 0;
+    ret = cli_submit_request(rpc, req, frame, prog, procnum, NULL, this, cbkfn,
+                             xdrproc);
 
-        if (!ret) {
-                cmd_sent = 1;
-                ret = cli_cmd_await_response (timeout);
-        }
+    if (!ret) {
+        cmd_sent = 1;
+        ret = cli_cmd_await_response(timeout);
+    }
 
-        cli_cmd_unlock ();
+    cli_cmd_unlock();
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_cmd_pattern_cmp (void *a, void *b)
+cli_cmd_pattern_cmp(void *a, void *b)
 {
-        struct cli_cmd *ia = NULL;
-        struct cli_cmd *ib = NULL;
-        int            ret = 0;
-
-        ia = a;
-        ib = b;
-        if (strcmp (ia->pattern, ib->pattern) > 0)
-                ret = 1;
-        else if (strcmp (ia->pattern, ib->pattern) < 0)
-                ret = -1;
-        else
-                ret = 0;
-        return ret;
+    struct cli_cmd *ia = NULL;
+    struct cli_cmd *ib = NULL;
+    int ret = 0;
+
+    ia = a;
+    ib = b;
+    if (strcmp(ia->pattern, ib->pattern) > 0)
+        ret = 1;
+    else if (strcmp(ia->pattern, ib->pattern) < 0)
+        ret = -1;
+    else
+        ret = 0;
+    return ret;
 }
 
 void
-cli_cmd_sort (struct cli_cmd *cmd, int count)
+cli_cmd_sort(struct cli_cmd *cmd, int count)
 {
-        gf_array_insertionsort (cmd, 1, count - 2, sizeof(struct cli_cmd),
-                                cli_cmd_pattern_cmp);
+    gf_array_insertionsort(cmd, 1, count - 2, sizeof(struct cli_cmd),
+                           cli_cmd_pattern_cmp);
 }
diff --git a/cli/src/cli-quotad-client.c b/cli/src/cli-quotad-client.c
index 5be9c80c858..fbd2c0391ab 100644
--- a/cli/src/cli-quotad-client.c
+++ b/cli/src/cli-quotad-client.c
@@ -14,136 +14,131 @@ extern struct rpc_clnt global_quotad_rpc;
 extern struct rpc_clnt_program cli_quotad_clnt;
 
 int
-cli_quotad_submit_request (void *req, call_frame_t *frame,
-                           rpc_clnt_prog_t *prog,
-                           int procnum, struct iobref *iobref,
-                           xlator_t *this, fop_cbk_fn_t cbkfn,
-                           xdrproc_t xdrproc)
+cli_quotad_submit_request(void *req, call_frame_t *frame, rpc_clnt_prog_t *prog,
+                          int procnum, struct iobref *iobref, xlator_t *this,
+                          fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
 {
-        int           ret        = -1;
-        int           count      = 0;
-        struct iovec  iov        = {0, };
-        struct iobuf *iobuf      = NULL;
-        char          new_iobref = 0;
-        ssize_t       xdr_size   = 0;
-
-        GF_ASSERT (this);
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-                iobuf = iobuf_get2 (this->ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                if (!iobref) {
-                        iobref = iobref_new ();
-                        if (!iobref) {
-                                goto out;
-                        }
-
-                        new_iobref = 1;
-                }
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_size (iobuf);
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    char new_iobref = 0;
+    ssize_t xdr_size = 0;
+
+    GF_ASSERT(this);
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+        iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        if (!iobref) {
+            iobref = iobref_new();
+            if (!iobref) {
+                goto out;
+            }
+
+            new_iobref = 1;
+        }
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_size(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            goto out;
         }
+        iov.iov_len = ret;
+        count = 1;
+    }
 
-        /* Send the msg */
-        ret = rpc_clnt_submit (&global_quotad_rpc, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
-        ret = 0;
+    /* Send the msg */
+    ret = rpc_clnt_submit(&global_quotad_rpc, prog, procnum, cbkfn, &iov, count,
+                          NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    ret = 0;
 
 out:
-        if (new_iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (new_iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_quotad_notify (struct rpc_clnt *rpc, void *mydata,
-                   rpc_clnt_event_t event, void *data)
+cli_quotad_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                  void *data)
 {
-        xlator_t                *this = NULL;
-        int                     ret = 0;
+    xlator_t *this = NULL;
+    int ret = 0;
 
-        this = mydata;
+    this = mydata;
 
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
-                break;
+    switch (event) {
+        case RPC_CLNT_CONNECT: {
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
+            break;
         }
 
-        case RPC_CLNT_DISCONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
-                break;
+        case RPC_CLNT_DISCONNECT: {
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
+            break;
         }
 
         default:
-                gf_log (this->name, GF_LOG_TRACE,
-                        "got some other RPC event %d", event);
-                ret = 0;
-                break;
-        }
+            gf_log(this->name, GF_LOG_TRACE, "got some other RPC event %d",
+                   event);
+            ret = 0;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 struct rpc_clnt *
-cli_quotad_clnt_init (xlator_t *this, dict_t *options)
+cli_quotad_clnt_init(xlator_t *this, dict_t *options)
 {
-        struct rpc_clnt *rpc  = NULL;
-        int              ret  = -1;
-
+    struct rpc_clnt *rpc = NULL;
+    int ret = -1;
 
-        ret = dict_set_str (options, "transport.address-family", "unix");
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "transport.address-family", "unix");
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (options, "transport.socket.connect-path",
-                            "/var/run/gluster/quotad.socket");
-        if (ret)
-                goto out;
+    ret = dict_set_str(options, "transport.socket.connect-path",
+                       "/var/run/gluster/quotad.socket");
+    if (ret)
+        goto out;
 
-        rpc = rpc_clnt_new (options, this, this->name, 16);
-        if (!rpc)
-                goto out;
+    rpc = rpc_clnt_new(options, this, this->name, 16);
+    if (!rpc)
+        goto out;
 
-        ret = rpc_clnt_register_notify (rpc, cli_quotad_notify, this);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "failed to register notify");
-                goto out;
-        }
+    ret = rpc_clnt_register_notify(rpc, cli_quotad_notify, this);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "failed to register notify");
+        goto out;
+    }
 
-        rpc_clnt_start (rpc);
+    rpc_clnt_start(rpc);
 out:
-        if (ret) {
-                if (rpc)
-                        rpc_clnt_unref (rpc);
-                rpc = NULL;
-        }
+    if (ret) {
+        if (rpc)
+            rpc_clnt_unref(rpc);
+        rpc = NULL;
+    }
 
-        return rpc;
+    return rpc;
 }
-
diff --git a/cli/src/cli-rl.c b/cli/src/cli-rl.c
index 4ddb2ab149f..dd0993b8646 100644
--- a/cli/src/cli-rl.c
+++ b/cli/src/cli-rl.c
@@ -27,392 +27,374 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 
-
 int
-cli_rl_out (struct cli_state *state, const char *fmt, va_list ap)
+cli_rl_out(struct cli_state *state, const char *fmt, va_list ap)
 {
-        int tmp_rl_point = rl_point;
-        int            n = rl_end;
-        int            ret = 0;
+    int tmp_rl_point = rl_point;
+    int n = rl_end;
+    int ret = 0;
 
-        if (rl_end >= 0 ) {
-                rl_kill_text (0, rl_end);
-                rl_redisplay ();
-        }
+    if (rl_end >= 0) {
+        rl_kill_text(0, rl_end);
+        rl_redisplay();
+    }
 
-        printf ("\r%*s\r", (int)strlen (state->prompt), "");
+    printf("\r%*s\r", (int)strlen(state->prompt), "");
 
-        ret = vprintf (fmt, ap);
+    ret = vprintf(fmt, ap);
 
-        printf ("\n");
-        fflush(stdout);
+    printf("\n");
+    fflush(stdout);
 
-        if (n) {
-                rl_do_undo ();
-                rl_point = tmp_rl_point;
-                rl_reset_line_state ();
-        }
+    if (n) {
+        rl_do_undo();
+        rl_point = tmp_rl_point;
+        rl_reset_line_state();
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-cli_rl_err (struct cli_state *state, const char *fmt, va_list ap)
+cli_rl_err(struct cli_state *state, const char *fmt, va_list ap)
 {
-        int tmp_rl_point = rl_point;
-        int            n = rl_end;
-        int            ret = 0;
+    int tmp_rl_point = rl_point;
+    int n = rl_end;
+    int ret = 0;
 
-        if (rl_end >= 0 ) {
-                rl_kill_text (0, rl_end);
-                rl_redisplay ();
-        }
+    if (rl_end >= 0) {
+        rl_kill_text(0, rl_end);
+        rl_redisplay();
+    }
 
-        fprintf (stderr, "\r%*s\r", (int)strlen (state->prompt), "");
+    fprintf(stderr, "\r%*s\r", (int)strlen(state->prompt), "");
 
-        ret = vfprintf (stderr, fmt, ap);
+    ret = vfprintf(stderr, fmt, ap);
 
-        fprintf (stderr, "\n");
-        fflush(stderr);
+    fprintf(stderr, "\n");
+    fflush(stderr);
 
-        if (n) {
-                rl_do_undo ();
-                rl_point = tmp_rl_point;
-                rl_reset_line_state ();
-        }
+    if (n) {
+        rl_do_undo();
+        rl_point = tmp_rl_point;
+        rl_reset_line_state();
+    }
 
-        return ret;
+    return ret;
 }
 
-
 void
-cli_rl_process_line (char *line)
+cli_rl_process_line(char *line)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
+    struct cli_state *state = NULL;
+    int ret = 0;
 
-        state = global_state;
+    state = global_state;
 
-        state->rl_processing = 1;
-        {
-                ret = cli_cmd_process_line (state, line);
-                if (ret)
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "failed to process line");
-
-                add_history (line);
-        }
-        state->rl_processing = 0;
+    state->rl_processing = 1;
+    {
+        ret = cli_cmd_process_line(state, line);
+        if (ret)
+            gf_log(THIS->name, GF_LOG_WARNING, "failed to process line");
 
+        add_history(line);
+    }
+    state->rl_processing = 0;
 }
 
-
 int
-cli_rl_stdin (int fd, int idx, int gen, void *data,
-              int poll_out, int poll_in, int poll_err)
+cli_rl_stdin(int fd, int idx, int gen, void *data, int poll_out, int poll_in,
+             int poll_err)
 {
-        struct cli_state *state = NULL;
+    struct cli_state *state = NULL;
 
-        state = data;
+    state = data;
 
-        rl_callback_read_char ();
+    rl_callback_read_char();
 
-        event_handled (state->ctx->event_pool, fd, idx, gen);
+    event_handled(state->ctx->event_pool, fd, idx, gen);
 
-        return 0;
+    return 0;
 }
 
-
 char *
-cli_rl_autocomplete_entry (const char *text, int times)
+cli_rl_autocomplete_entry(const char *text, int times)
 {
-        struct cli_state  *state = NULL;
-        char              *retp = NULL;
+    struct cli_state *state = NULL;
+    char *retp = NULL;
 
-        state = global_state;
+    state = global_state;
 
-        if (!state->matchesp)
-                return NULL;
+    if (!state->matchesp)
+        return NULL;
 
-        retp = *state->matchesp;
+    retp = *state->matchesp;
 
-        state->matchesp++;
+    state->matchesp++;
 
-        return retp ? strdup (retp) : NULL;
+    return retp ? strdup(retp) : NULL;
 }
 
-
 int
-cli_rl_token_count (const char *text)
+cli_rl_token_count(const char *text)
 {
-        int          count = 0;
-        const char  *trav = NULL;
-        int          is_spc = 1;
-
-        for (trav = text; *trav; trav++) {
-                if (*trav == ' ') {
-                        is_spc = 1;
-                } else {
-                        if (is_spc) {
-                                count++;
-                                is_spc = 0;
-                        }
-                }
+    int count = 0;
+    const char *trav = NULL;
+    int is_spc = 1;
+
+    for (trav = text; *trav; trav++) {
+        if (*trav == ' ') {
+            is_spc = 1;
+        } else {
+            if (is_spc) {
+                count++;
+                is_spc = 0;
+            }
         }
+    }
 
-        if (is_spc)
-                /* what needs to be autocompleted is a full
-                   new word, and not extend the last word
-                */
-                count++;
+    if (is_spc)
+        /* what needs to be autocompleted is a full
+           new word, and not extend the last word
+        */
+        count++;
 
-        return count;
+    return count;
 }
 
-
 char **
-cli_rl_tokenize (const char *text)
+cli_rl_tokenize(const char *text)
 {
-        int     count = 0;
-        char  **tokens = NULL;
-        char  **tokenp = NULL;
-        char   *token = NULL;
-        char   *copy = NULL;
-        char   *saveptr = NULL;
-        int     i = 0;
-
-        count = cli_rl_token_count (text);
-
-        tokens = calloc (count + 1, sizeof (*tokens));
-        if (!tokens)
-                return NULL;
-
-        copy = strdup (text);
-        if (!copy)
-                goto out;
-
-        tokenp = tokens;
-
-        for (token = strtok_r (copy, " \t\r\n", &saveptr); token;
-             token = strtok_r (NULL, " \t\r\n", &saveptr)) {
-                *tokenp = strdup (token);
-
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-
-        }
+    int count = 0;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char *copy = NULL;
+    char *saveptr = NULL;
+    int i = 0;
+
+    count = cli_rl_token_count(text);
+
+    tokens = calloc(count + 1, sizeof(*tokens));
+    if (!tokens)
+        return NULL;
 
-        if (i < count) {
-                /* symbolize that what needs to be autocompleted is
-                   the full set of possible nextwords, and not extend
-                   the last word
-                */
-                *tokenp = strdup ("");
-                if (!*tokenp)
-                        goto out;
-                tokenp++;
-                i++;
-        }
+    copy = strdup(text);
+    if (!copy)
+        goto out;
+
+    tokenp = tokens;
+
+    for (token = strtok_r(copy, " \t\r\n", &saveptr); token;
+         token = strtok_r(NULL, " \t\r\n", &saveptr)) {
+        *tokenp = strdup(token);
+
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
+
+    if (i < count) {
+        /* symbolize that what needs to be autocompleted is
+           the full set of possible nextwords, and not extend
+           the last word
+        */
+        *tokenp = strdup("");
+        if (!*tokenp)
+            goto out;
+        tokenp++;
+        i++;
+    }
 
 out:
-        free (copy);
+    free(copy);
 
-        if (i < count) {
-                cli_cmd_tokens_destroy (tokens);
-                tokens = NULL;
-        }
+    if (i < count) {
+        cli_cmd_tokens_destroy(tokens);
+        tokens = NULL;
+    }
 
-        return tokens;
+    return tokens;
 }
 
-
 char **
-cli_rl_get_matches (struct cli_state *state, struct cli_cmd_word *word,
-                    const char *text)
+cli_rl_get_matches(struct cli_state *state, struct cli_cmd_word *word,
+                   const char *text)
 {
-        char                 **matches = NULL;
-        char                 **matchesp = NULL;
-        struct cli_cmd_word  **next = NULL;
-        int                    count = 0;
-        int                    len = 0;
+    char **matches = NULL;
+    char **matchesp = NULL;
+    struct cli_cmd_word **next = NULL;
+    int count = 0;
+    int len = 0;
 
-        len = strlen (text);
+    len = strlen(text);
 
-        if (!word->nextwords)
-                return NULL;
+    if (!word->nextwords)
+        return NULL;
 
-        for (next = word->nextwords; *next; next++)
-                count++;
+    for (next = word->nextwords; *next; next++)
+        count++;
 
-        matches = calloc (count + 1, sizeof (*matches));
-        matchesp = matches;
+    matches = calloc(count + 1, sizeof(*matches));
+    matchesp = matches;
 
-        for (next = word->nextwords; *next; next++) {
-                if ((*next)->match) {
-                        continue;
-                }
+    for (next = word->nextwords; *next; next++) {
+        if ((*next)->match) {
+            continue;
+        }
 
-                if (strncmp ((*next)->word, text, len) == 0) {
-                        *matchesp = strdup ((*next)->word);
-                        matchesp++;
-                }
+        if (strncmp((*next)->word, text, len) == 0) {
+            *matchesp = strdup((*next)->word);
+            matchesp++;
         }
+    }
 
-        return matches;
+    return matches;
 }
 
-
 int
-cli_rl_autocomplete_prepare (struct cli_state *state, const char *text)
+cli_rl_autocomplete_prepare(struct cli_state *state, const char *text)
 {
-        struct cli_cmd_word   *word = NULL;
-        struct cli_cmd_word   *next = NULL;
-        char                 **tokens = NULL;
-        char                 **tokenp = NULL;
-        char                  *token = NULL;
-        char                 **matches = NULL;
-
-        tokens = cli_rl_tokenize (text);
-        if (!tokens)
-                return 0;
-
-        word = &state->tree.root;
-
-        for (tokenp = tokens; (token = *tokenp); tokenp++) {
-                if (!*(tokenp+1)) {
-                        /* last word */
-                        break;
-                }
-
-                next = cli_cmd_nextword (word, token);
-                word = next;
-                if (!word)
-                        break;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
+    char **tokens = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    char **matches = NULL;
+
+    tokens = cli_rl_tokenize(text);
+    if (!tokens)
+        return 0;
+
+    word = &state->tree.root;
+
+    for (tokenp = tokens; (token = *tokenp); tokenp++) {
+        if (!*(tokenp + 1)) {
+            /* last word */
+            break;
         }
 
+        next = cli_cmd_nextword(word, token);
+        word = next;
         if (!word)
-                goto out;
+            break;
+    }
+
+    if (!word)
+        goto out;
 
-        if (!token)
-                return 0;
-        matches = cli_rl_get_matches (state, word, token);
+    if (!token)
+        return 0;
+    matches = cli_rl_get_matches(state, word, token);
 
-        state->matches = matches;
-        state->matchesp = matches;
+    state->matches = matches;
+    state->matchesp = matches;
 
 out:
-        cli_cmd_tokens_destroy (tokens);
-        return 0;
+    cli_cmd_tokens_destroy(tokens);
+    return 0;
 }
 
-
 int
-cli_rl_autocomplete_cleanup (struct cli_state *state)
+cli_rl_autocomplete_cleanup(struct cli_state *state)
 {
-        if (state->matches)
-                cli_cmd_tokens_destroy (state->matches);
+    if (state->matches)
+        cli_cmd_tokens_destroy(state->matches);
 
-        state->matches = NULL;
-        state->matchesp = NULL;
+    state->matches = NULL;
+    state->matchesp = NULL;
 
-        return 0;
+    return 0;
 }
 
-
 char **
-cli_rl_autocomplete (const char *text, int start, int end)
+cli_rl_autocomplete(const char *text, int start, int end)
 {
-        struct cli_state  *state = NULL;
-        char             **matches = NULL;
-        char               save = 0;
+    struct cli_state *state = NULL;
+    char **matches = NULL;
+    char save = 0;
 
-        state = global_state;
+    state = global_state;
 
-        /* hack to make the autocompletion code neater */
-        /* fake it as though the cursor is at the end of line */
+    /* hack to make the autocompletion code neater */
+    /* fake it as though the cursor is at the end of line */
 
-        save = rl_line_buffer[rl_point];
-        rl_line_buffer[rl_point] = 0;
+    save = rl_line_buffer[rl_point];
+    rl_line_buffer[rl_point] = 0;
 
-        cli_rl_autocomplete_prepare (state, rl_line_buffer);
+    cli_rl_autocomplete_prepare(state, rl_line_buffer);
 
-        matches = rl_completion_matches (text, cli_rl_autocomplete_entry);
+    matches = rl_completion_matches(text, cli_rl_autocomplete_entry);
 
-        cli_rl_autocomplete_cleanup (state);
+    cli_rl_autocomplete_cleanup(state);
 
-        rl_line_buffer[rl_point] = save;
+    rl_line_buffer[rl_point] = save;
 
-        return matches;
+    return matches;
 }
 
-
 static char *
-complete_none (const char *txt, int times)
+complete_none(const char *txt, int times)
 {
-        return NULL;
+    return NULL;
 }
 
-
 void *
-cli_rl_input (void *_data)
+cli_rl_input(void *_data)
 {
-        struct cli_state *state = NULL;
-        char             *line = NULL;
+    struct cli_state *state = NULL;
+    char *line = NULL;
 
-        state = _data;
+    state = _data;
 
-        for (;;) {
-                line = readline (state->prompt);
-                if (!line)
-                        exit(0);  //break;
+    for (;;) {
+        line = readline(state->prompt);
+        if (!line)
+            exit(0);  // break;
 
-                if (*line)
-                        cli_rl_process_line (line);
+        if (*line)
+            cli_rl_process_line(line);
 
-                free (line);
-        }
+        free(line);
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 int
-cli_rl_enable (struct cli_state *state)
+cli_rl_enable(struct cli_state *state)
 {
-        int ret = 0;
-
-        rl_pre_input_hook = NULL;
-        rl_attempted_completion_function = cli_rl_autocomplete;
-        rl_completion_entry_function = complete_none;
-
-        if (!state->rl_async) {
-                ret = pthread_create (&state->input, NULL,
-                                      cli_rl_input, state);
-                if (ret == 0)
-                        state->rl_enabled = 1;
-                goto out;
-        }
+    int ret = 0;
 
-        ret = event_register (state->ctx->event_pool, 0, cli_rl_stdin, state,
-                              1, 0);
-        if (ret == -1)
-                goto out;
+    rl_pre_input_hook = NULL;
+    rl_attempted_completion_function = cli_rl_autocomplete;
+    rl_completion_entry_function = complete_none;
 
-        state->rl_enabled = 1;
-        rl_callback_handler_install (state->prompt, cli_rl_process_line);
+    if (!state->rl_async) {
+        ret = pthread_create(&state->input, NULL, cli_rl_input, state);
+        if (ret == 0)
+            state->rl_enabled = 1;
+        goto out;
+    }
+
+    ret = event_register(state->ctx->event_pool, 0, cli_rl_stdin, state, 1, 0);
+    if (ret == -1)
+        goto out;
+
+    state->rl_enabled = 1;
+    rl_callback_handler_install(state->prompt, cli_rl_process_line);
 
 out:
-        return state->rl_enabled;
+    return state->rl_enabled;
 }
 
 #else /* HAVE_READLINE */
 
 int
-cli_rl_enable (struct cli_state *state)
+cli_rl_enable(struct cli_state *state)
 {
-        return 0;
+    return 0;
 }
 
 #endif /* HAVE_READLINE */
diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c
index 40bd64b983c..fea74667e05 100644
--- a/cli/src/cli-rpc-ops.c
+++ b/cli/src/cli-rpc-ops.c
@@ -14,14 +14,14 @@
  */
 #define VOL_TOP_PERF_FILENAME_DEF_WIDTH 47
 #define VOL_TOP_PERF_FILENAME_ALT_WIDTH 44
-#define VOL_TOP_PERF_SPEED_WIDTH        4
-#define VOL_TOP_PERF_TIME_WIDTH         26
+#define VOL_TOP_PERF_SPEED_WIDTH 4
+#define VOL_TOP_PERF_TIME_WIDTH 26
 
 #define INDENT_MAIN_HEAD "%-25s %s "
 
 /* Do not show estimates if greater than this number */
-#define REBAL_ESTIMATE_SEC_UPPER_LIMIT    (60*24*3600)
-#define REBAL_ESTIMATE_START_TIME         600
+#define REBAL_ESTIMATE_SEC_UPPER_LIMIT (60 * 24 * 3600)
+#define REBAL_ESTIMATE_START_TIME 600
 
 #include "cli.h"
 #include "compat-errno.h"
@@ -46,26 +46,22 @@
 #include "quota-common-utils.h"
 #include "events.h"
 
-enum gf_task_types {
-        GF_TASK_TYPE_REBALANCE,
-        GF_TASK_TYPE_REMOVE_BRICK
-};
+enum gf_task_types { GF_TASK_TYPE_REBALANCE, GF_TASK_TYPE_REMOVE_BRICK };
 
 extern struct rpc_clnt *global_quotad_rpc;
 extern rpc_clnt_prog_t cli_quotad_clnt;
 extern rpc_clnt_prog_t *cli_rpc_prog;
-extern int              cli_op_ret;
-extern int              connected;
+extern int cli_op_ret;
+extern int connected;
 
 int32_t
-gf_cli_remove_brick (call_frame_t *frame, xlator_t *this,
-                     void *data);
-
+gf_cli_remove_brick(call_frame_t *frame, xlator_t *this, void *data);
 
-char *cli_vol_status_str[] = {"Created",
-                              "Started",
-                              "Stopped",
-                             };
+char *cli_vol_status_str[] = {
+    "Created",
+    "Started",
+    "Stopped",
+};
 
 char *cli_vol_task_status_str[] = {"not started",
                                    "in progress",
@@ -76,9670 +72,9631 @@ char *cli_vol_task_status_str[] = {"not started",
                                    "fix-layout stopped",
                                    "fix-layout completed",
                                    "fix-layout failed",
-                                   "unknown"
-};
+                                   "unknown"};
 
 int32_t
-gf_cli_snapshot (call_frame_t *frame, xlator_t *this, void *data);
+gf_cli_snapshot(call_frame_t *frame, xlator_t *this, void *data);
 
 int32_t
-gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
-                      void *data);
+gf_cli_get_volume(call_frame_t *frame, xlator_t *this, void *data);
 
 int
-cli_to_glusterd (gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
-                 xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
-                 rpc_clnt_prog_t *prog, struct iobref *iobref);
+cli_to_glusterd(gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
+                xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
+                rpc_clnt_prog_t *prog, struct iobref *iobref);
 
 int
-add_cli_cmd_timeout_to_dict (dict_t *dict);
+add_cli_cmd_timeout_to_dict(dict_t *dict);
 
 rpc_clnt_prog_t cli_handshake_prog = {
-        .progname  = "cli handshake",
-        .prognum   = GLUSTER_HNDSK_PROGRAM,
-        .progver   = GLUSTER_HNDSK_VERSION,
+    .progname = "cli handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
 };
 
 rpc_clnt_prog_t cli_pmap_prog = {
-        .progname   = "cli portmap",
-        .prognum    = GLUSTER_PMAP_PROGRAM,
-        .progver    = GLUSTER_PMAP_VERSION,
+    .progname = "cli portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
 };
 
 int
-gf_cli_probe_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
-{
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        char                  msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
-
-        if (rsp.op_errstr && (strlen (rsp.op_errstr) > 0)) {
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                if (rsp.op_ret)
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
-        }
+gf_cli_probe_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to probe");
+
+    if (rsp.op_errstr && (strlen(rsp.op_errstr) > 0)) {
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        if (rsp.op_ret)
+            gf_log("cli", GF_LOG_ERROR, "%s", msg);
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str (NULL,
-                                          (rsp.op_ret)? NULL : msg,
-                                          rsp.op_ret, rsp.op_errno,
-                                          (rsp.op_ret)? msg : NULL);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str(NULL, (rsp.op_ret) ? NULL : msg, rsp.op_ret,
+                                 rsp.op_errno, (rsp.op_ret) ? msg : NULL);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("peer probe: success. %s", msg);
-        else
-                cli_err ("peer probe: failed: %s", msg);
+    if (!rsp.op_ret)
+        cli_out("peer probe: success. %s", msg);
+    else
+        cli_err("peer probe: failed: %s", msg);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_deprobe_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
-{
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        char              msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to deprobe");
-
-        if (rsp.op_ret) {
-                if (strlen (rsp.op_errstr) > 0) {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                        gf_log ("cli", GF_LOG_ERROR, "%s", rsp.op_errstr);
-                }
-        } else {
-                snprintf (msg, sizeof (msg), "success");
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str (NULL,
-                                          (rsp.op_ret)? NULL : msg,
-                                          rsp.op_ret, rsp.op_errno,
-                                          (rsp.op_ret)? msg : NULL);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_deprobe_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to deprobe");
+
+    if (rsp.op_ret) {
+        if (strlen(rsp.op_errstr) > 0) {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            gf_log("cli", GF_LOG_ERROR, "%s", rsp.op_errstr);
+        }
+    } else {
+        snprintf(msg, sizeof(msg), "success");
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str(NULL, (rsp.op_ret) ? NULL : msg, rsp.op_ret,
+                                 rsp.op_errno, (rsp.op_ret) ? msg : NULL);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("peer detach: %s", msg);
-        else
-                cli_err ("peer detach: failed: %s", msg);
+    if (!rsp.op_ret)
+        cli_out("peer detach: %s", msg);
+    else
+        cli_err("peer detach: failed: %s", msg);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_output_peer_hostnames (dict_t *dict, int count, char *prefix)
-{
-        int ret = -1;
-        char key[256] = {0,};
-        int i = 0;
-        char *hostname = NULL;
-
-        cli_out ("Other names:");
-        /* Starting from friend.hostname1, as friend.hostname0 will be the same
-         * as friend.hostname
-         */
-        for (i = 1; i < count; i++) {
-                snprintf (key, sizeof (key), "%s.hostname%d", prefix, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        break;
-                cli_out ("%s", hostname);
-                hostname = NULL;
-        }
+gf_cli_output_peer_hostnames(dict_t *dict, int count, char *prefix)
+{
+    int ret = -1;
+    char key[256] = {
+        0,
+    };
+    int i = 0;
+    char *hostname = NULL;
+
+    cli_out("Other names:");
+    /* Starting from friend.hostname1, as friend.hostname0 will be the same
+     * as friend.hostname
+     */
+    for (i = 1; i < count; i++) {
+        snprintf(key, sizeof(key), "%s.hostname%d", prefix, i);
+        ret = dict_get_str(dict, key, &hostname);
+        if (ret)
+            break;
+        cli_out("%s", hostname);
+        hostname = NULL;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_output_peer_status (dict_t *dict, int count)
-{
-        int                        ret   = -1;
-        char                       *uuid_buf = NULL;
-        char                       *hostname_buf = NULL;
-        int32_t                    i = 1;
-        char                       key[256] = {0,};
-        char                       *state = NULL;
-        int32_t                    connected = 0;
-        char                       *connected_str = NULL;
-        int                        hostname_count = 0;
-
-        cli_out ("Number of Peers: %d", count);
-        i = 1;
-        while ( i <= count) {
-                snprintf (key, 256, "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid_buf);
-                if (ret)
-                        goto out;
-
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+gf_cli_output_peer_status(dict_t *dict, int count)
+{
+    int ret = -1;
+    char *uuid_buf = NULL;
+    char *hostname_buf = NULL;
+    int32_t i = 1;
+    char key[256] = {
+        0,
+    };
+    char *state = NULL;
+    int32_t connected = 0;
+    char *connected_str = NULL;
+    int hostname_count = 0;
+
+    cli_out("Number of Peers: %d", count);
+    i = 1;
+    while (i <= count) {
+        snprintf(key, 256, "friend%d.uuid", i);
+        ret = dict_get_str(dict, key, &uuid_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
-                if (connected)
-                        connected_str = "Connected";
-                else
-                        connected_str = "Disconnected";
+        snprintf(key, 256, "friend%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname_buf);
+        if (ret)
+            goto out;
 
+        snprintf(key, 256, "friend%d.connected", i);
+        ret = dict_get_int32(dict, key, &connected);
+        if (ret)
+            goto out;
+        if (connected)
+            connected_str = "Connected";
+        else
+            connected_str = "Disconnected";
 
-                snprintf (key, 256, "friend%d.state", i);
-                ret = dict_get_str (dict, key, &state);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "friend%d.state", i);
+        ret = dict_get_str(dict, key, &state);
+        if (ret)
+            goto out;
 
-                cli_out ("\nHostname: %s\nUuid: %s\nState: %s (%s)",
-                         hostname_buf, uuid_buf, state, connected_str);
+        cli_out("\nHostname: %s\nUuid: %s\nState: %s (%s)", hostname_buf,
+                uuid_buf, state, connected_str);
 
-                snprintf (key, sizeof (key), "friend%d.hostname_count", i);
-                ret = dict_get_int32 (dict, key, &hostname_count);
-                /* Print other addresses only if there are more than 1.
-                 */
-                if ((ret == 0) && (hostname_count > 1)) {
-                        snprintf (key, sizeof (key), "friend%d", i);
-                        ret = gf_cli_output_peer_hostnames (dict,
-                                                            hostname_count,
-                                                            key);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_WARNING,
-                                        "error outputting peer other names");
-                                goto out;
-                        }
-                }
-                i++;
+        snprintf(key, sizeof(key), "friend%d.hostname_count", i);
+        ret = dict_get_int32(dict, key, &hostname_count);
+        /* Print other addresses only if there are more than 1.
+         */
+        if ((ret == 0) && (hostname_count > 1)) {
+            snprintf(key, sizeof(key), "friend%d", i);
+            ret = gf_cli_output_peer_hostnames(dict, hostname_count, key);
+            if (ret) {
+                gf_log("cli", GF_LOG_WARNING,
+                       "error outputting peer other names");
+                goto out;
+            }
         }
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_output_pool_list (dict_t *dict, int count)
-{
-        int                         ret           = -1;
-        char                       *uuid_buf      = NULL;
-        char                       *hostname_buf  = NULL;
-        int32_t                     hostname_len  = 8; /*min len 8 chars*/
-        int32_t                     i             = 1;
-        char                        key[256]      = {0,};
-        int32_t                     connected     = 0;
-        char                       *connected_str = NULL;
-
-        if (count <= 0)
-                goto out;
-
-        while (i <= count) {
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+gf_cli_output_pool_list(dict_t *dict, int count)
+{
+    int ret = -1;
+    char *uuid_buf = NULL;
+    char *hostname_buf = NULL;
+    int32_t hostname_len = 8; /*min len 8 chars*/
+    int32_t i = 1;
+    char key[256] = {
+        0,
+    };
+    int32_t connected = 0;
+    char *connected_str = NULL;
+
+    if (count <= 0)
+        goto out;
+
+    while (i <= count) {
+        snprintf(key, 256, "friend%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname_buf);
+        if (ret)
+            goto out;
 
-                ret = strlen(hostname_buf);
-                if (ret > hostname_len)
-                        hostname_len = ret;
+        ret = strlen(hostname_buf);
+        if (ret > hostname_len)
+            hostname_len = ret;
 
-                i++;
-        }
+        i++;
+    }
 
-        cli_out ("UUID\t\t\t\t\t%-*s\tState", hostname_len, "Hostname");
+    cli_out("UUID\t\t\t\t\t%-*s\tState", hostname_len, "Hostname");
 
-        i = 1;
-        while ( i <= count) {
-                snprintf (key, 256, "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid_buf);
-                if (ret)
-                        goto out;
+    i = 1;
+    while (i <= count) {
+        snprintf(key, 256, "friend%d.uuid", i);
+        ret = dict_get_str(dict, key, &uuid_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname_buf);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "friend%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname_buf);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
-                if (connected)
-                        connected_str = "Connected";
-                else
-                        connected_str = "Disconnected";
+        snprintf(key, 256, "friend%d.connected", i);
+        ret = dict_get_int32(dict, key, &connected);
+        if (ret)
+            goto out;
+        if (connected)
+            connected_str = "Connected";
+        else
+            connected_str = "Disconnected";
 
-                cli_out ("%s\t%-*s\t%s ", uuid_buf, hostname_len, hostname_buf,
-                         connected_str);
-                i++;
-        }
+        cli_out("%s\t%-*s\t%s ", uuid_buf, hostname_len, hostname_buf,
+                connected_str);
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* function pointer for gf_cli_output_{pool_list,peer_status} */
-typedef int (*cli_friend_output_fn) (dict_t*, int);
+typedef int (*cli_friend_output_fn)(dict_t *, int);
 
 int
-gf_cli_list_friends_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_list_friends_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf1_cli_peer_list_rsp      rsp   = {0,};
-        int                        ret   = -1;
-        dict_t                    *dict = NULL;
-        char                       msg[1024] = {0,};
-        char                      *cmd = NULL;
-        cli_friend_output_fn       friend_output_fn;
-        call_frame_t              *frame = NULL;
-        unsigned long              flags = 0;
+    gf1_cli_peer_list_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *cmd = NULL;
+    cli_friend_output_fn friend_output_fn;
+    call_frame_t *frame = NULL;
+    unsigned long flags = 0;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        frame = myframe;
+    frame = myframe;
 
-        flags = (long)frame->local;
+    flags = (long)frame->local;
 
-        if (flags == GF_CLI_LIST_POOL_NODES) {
-                cmd = "pool list";
-                friend_output_fn = &gf_cli_output_pool_list;
-        } else {
-                cmd = "peer status";
-                friend_output_fn = &gf_cli_output_peer_status;
-        }
+    if (flags == GF_CLI_LIST_POOL_NODES) {
+        cmd = "pool list";
+        friend_output_fn = &gf_cli_output_pool_list;
+    } else {
+        cmd = "peer status";
+        friend_output_fn = &gf_cli_output_peer_status;
+    }
 
-        /* 'free' the flags set by gf_cli_list_friends */
-        frame->local = NULL;
+    /* 'free' the flags set by gf_cli_list_friends */
+    frame->local = NULL;
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_peer_list_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                //rsp.op_ret   = -1;
-                //rsp.op_errno = EINVAL;
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_peer_list_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        // rsp.op_ret   = -1;
+        // rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to list: %d", rsp.op_ret);
+
+    if (!rsp.op_ret) {
+        if (!rsp.friends.friends_len) {
+            snprintf(msg, sizeof(msg), "%s: No peers present", cmd);
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                                 msg);
+                if (ret)
+                    gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
                 goto out;
+            }
+            cli_err("%s", msg);
+            ret = 0;
+            goto out;
         }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to list: %d",
-                rsp.op_ret);
-
-        if (!rsp.op_ret) {
-
-                if (!rsp.friends.friends_len) {
-                        snprintf (msg, sizeof (msg),
-                                  "%s: No peers present", cmd);
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                ret = cli_xml_output_peer_status (dict,
-                                                                  rsp.op_ret,
-                                                                  rsp.op_errno,
-                                                                  msg);
-                                if (ret)
-                                        gf_log ("cli", GF_LOG_ERROR,
-                                                "Error outputting to xml");
-                                goto out;
-                        }
-                        cli_err ("%s", msg);
-                        ret = 0;
-                        goto out;
-                }
-
-                dict = dict_new ();
+        dict = dict_new();
 
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
 
-                ret = dict_unserialize (rsp.friends.friends_val,
-                                        rsp.friends.friends_len,
-                                        &dict);
+        ret = dict_unserialize(rsp.friends.friends_val, rsp.friends.friends_len,
+                               &dict);
 
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR,
-                                        "Unable to allocate memory");
-                        goto out;
-                }
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "Unable to allocate memory");
+            goto out;
+        }
 
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_peer_status (dict, rsp.op_ret,
-                                                          rsp.op_errno, msg);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        goto out;
-                }
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                             msg);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+            goto out;
+        }
 
-                ret = dict_get_int32 (dict, "count", &count);
-                if (ret) {
-                        goto out;
-                }
+        ret = dict_get_int32(dict, "count", &count);
+        if (ret) {
+            goto out;
+        }
 
-                ret = friend_output_fn (dict, count);
-                if (ret) {
-                        goto out;
-                }
+        ret = friend_output_fn(dict, count);
+        if (ret) {
+            goto out;
+        }
+    } else {
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_peer_status(dict, rsp.op_ret, rsp.op_errno,
+                                             NULL);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
         } else {
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_peer_status (dict, rsp.op_ret,
-                                                          rsp.op_errno, NULL);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                } else {
-                        ret = -1;
-                }
-                goto out;
+            ret = -1;
         }
+        goto out;
+    }
 
-
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret)
-                cli_err ("%s: failed", cmd);
+    if (ret)
+        cli_err("%s: failed", cmd);
 
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_get_state_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
-{
-        gf_cli_rsp           rsp            = {0,};
-        int                  ret            = -1;
-        dict_t               *dict          = NULL;
-        char                 *daemon_name   = NULL;
-        char                 *ofilepath     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+gf_cli_get_state_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *daemon_name = NULL;
+    char *ofilepath = NULL;
+
+    GF_VALIDATE_OR_GOTO("cli", myframe, out);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("Failed to get daemon state: %s", rsp.op_errstr);
+        else
+            cli_err(
+                "Failed to get daemon state. Check glusterd"
+                " log file for more details");
+    } else {
+        ret = dict_get_str(dict, "daemon", &daemon_name);
         if (ret)
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get daemon name");
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("Failed to get daemon state: %s", rsp.op_errstr);
-                else
-                        cli_err ("Failed to get daemon state. Check glusterd"
-                                 " log file for more details");
-        } else {
-                ret = dict_get_str (dict, "daemon", &daemon_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get daemon name");
-
-                ret = dict_get_str (dict, "ofilepath", &ofilepath);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get filepath");
+        ret = dict_get_str(dict, "ofilepath", &ofilepath);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get filepath");
 
-                if (daemon_name && ofilepath)
-                        cli_out ("%s state dumped to %s",
-                                 daemon_name, ofilepath);
-        }
+        if (daemon_name && ofilepath)
+            cli_out("%s state dumped to %s", daemon_name, ofilepath);
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        return ret;
+    return ret;
 }
 
 void
-cli_out_options ( char *substr, char *optstr, char *valstr)
+cli_out_options(char *substr, char *optstr, char *valstr)
 {
-        char                    *ptr1 = NULL;
-        char                    *ptr2 = NULL;
+    char *ptr1 = NULL;
+    char *ptr2 = NULL;
 
-        ptr1 = substr;
-        ptr2 = optstr;
+    ptr1 = substr;
+    ptr2 = optstr;
 
-        while (ptr1)
-        {
- /* Avoiding segmentation fault. */
-                if (!ptr2)
-                        return;
-                if (*ptr1 != *ptr2)
-                        break;
-                ptr1++;
-                ptr2++;
-        }
+    while (ptr1) {
+        /* Avoiding segmentation fault. */
+        if (!ptr2)
+            return;
+        if (*ptr1 != *ptr2)
+            break;
+        ptr1++;
+        ptr2++;
+    }
 
-        if (*ptr2 == '\0')
-                return;
-        cli_out ("%s: %s",ptr2 , valstr);
+    if (*ptr2 == '\0')
+        return;
+    cli_out("%s: %s", ptr2, valstr);
 }
 
 static int
-_gf_cli_output_volinfo_opts (dict_t *d, char *k,
-                             data_t *v, void *tmp)
-{
-        int     ret   = 0;
-        char   *key   = NULL;
-        char   *ptr   = NULL;
-        data_t *value = NULL;
-
-        key = tmp;
-
-        ptr = strstr (k, "option.");
-        if (ptr) {
-                value = v;
-                if (!value) {
-                        ret = -1;
-                        goto out;
-                }
-                cli_out_options (key, k, v->data);
+_gf_cli_output_volinfo_opts(dict_t *d, char *k, data_t *v, void *tmp)
+{
+    int ret = 0;
+    char *key = NULL;
+    char *ptr = NULL;
+    data_t *value = NULL;
+
+    key = tmp;
+
+    ptr = strstr(k, "option.");
+    if (ptr) {
+        value = v;
+        if (!value) {
+            ret = -1;
+            goto out;
         }
+        cli_out_options(key, k, v->data);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-print_brick_details (dict_t *dict, int volcount, int start_index,
-                     int end_index, int replica_count)
-{
-        char           key[1024]   = {0,};
-        int            index       = start_index;
-        int            isArbiter   = 0;
-        int            ret         = -1;
-        char          *brick       = NULL;
+print_brick_details(dict_t *dict, int volcount, int start_index, int end_index,
+                    int replica_count)
+{
+    char key[1024] = {
+        0,
+    };
+    int index = start_index;
+    int isArbiter = 0;
+    int ret = -1;
+    char *brick = NULL;
 #ifdef HAVE_BD_XLATOR
-        char          *caps        = NULL;
+    char *caps = NULL;
 #endif
 
-        while (index <= end_index) {
-                snprintf (key, 1024, "volume%d.brick%d", volcount, index);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof (key), "volume%d.brick%d.isArbiter",
-                          volcount, index);
-                if (dict_get (dict, key))
-                        isArbiter = 1;
-                else
-                        isArbiter = 0;
+    while (index <= end_index) {
+        snprintf(key, 1024, "volume%d.brick%d", volcount, index);
+        ret = dict_get_str(dict, key, &brick);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof(key), "volume%d.brick%d.isArbiter", volcount,
+                 index);
+        if (dict_get(dict, key))
+            isArbiter = 1;
+        else
+            isArbiter = 0;
 
-                if (isArbiter)
-                        cli_out ("Brick%d: %s (arbiter)", index, brick);
-                else
-                        cli_out ("Brick%d: %s", index, brick);
+        if (isArbiter)
+            cli_out("Brick%d: %s (arbiter)", index, brick);
+        else
+            cli_out("Brick%d: %s", index, brick);
 #ifdef HAVE_BD_XLATOR
-                snprintf (key, 1024, "volume%d.vg%d", volcount, index);
-                ret = dict_get_str (dict, key, &caps);
-                if (!ret)
-                        cli_out ("Brick%d VG: %s", index, caps);
+        snprintf(key, 1024, "volume%d.vg%d", volcount, index);
+        ret = dict_get_str(dict, key, &caps);
+        if (!ret)
+            cli_out("Brick%d VG: %s", index, caps);
 #endif
-                index++;
-        }
-        ret = 0;
+        index++;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 void
-gf_cli_print_number_of_bricks (int type, int brick_count, int dist_count,
-                               int stripe_count, int replica_count,
-                               int disperse_count, int redundancy_count,
-                               int arbiter_count)
-{
-       if (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE) {
-               if (arbiter_count == 0) {
-                       cli_out ("Number of Bricks: %d x %d x %d = %d",
-                                (brick_count / dist_count),
-                                stripe_count,
-                                replica_count,
-                                brick_count);
-               } else {
-                       cli_out ("Number of Bricks: %d x %d x (%d + %d) = %d",
-                                (brick_count / dist_count),
-                                stripe_count, replica_count - arbiter_count,
-                                arbiter_count, brick_count);
-               }
-       } else if (type == GF_CLUSTER_TYPE_NONE ||
-                  type == GF_CLUSTER_TYPE_TIER) {
-               cli_out ("Number of Bricks: %d", brick_count);
-       } else if (type == GF_CLUSTER_TYPE_DISPERSE) {
-               cli_out ("Number of Bricks: %d x (%d + %d) = %d",
-                        (brick_count / dist_count),
-                        disperse_count - redundancy_count,
-                        redundancy_count, brick_count);
-       } else {
-               /* For both replicate and stripe, dist_count is
-                  good enough */
-               if (arbiter_count == 0) {
-                       cli_out ("Number of Bricks: %d x %d = %d",
-                                (brick_count / dist_count),
-                                dist_count, brick_count);
-               } else {
-                       cli_out ("Number of Bricks: %d x (%d + %d) = %d",
-                                (brick_count / dist_count),
-                                dist_count - arbiter_count, arbiter_count,
-                                brick_count);
-               }
-       }
-
+gf_cli_print_number_of_bricks(int type, int brick_count, int dist_count,
+                              int stripe_count, int replica_count,
+                              int disperse_count, int redundancy_count,
+                              int arbiter_count)
+{
+    if (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE) {
+        if (arbiter_count == 0) {
+            cli_out("Number of Bricks: %d x %d x %d = %d",
+                    (brick_count / dist_count), stripe_count, replica_count,
+                    brick_count);
+        } else {
+            cli_out("Number of Bricks: %d x %d x (%d + %d) = %d",
+                    (brick_count / dist_count), stripe_count,
+                    replica_count - arbiter_count, arbiter_count, brick_count);
+        }
+    } else if (type == GF_CLUSTER_TYPE_NONE || type == GF_CLUSTER_TYPE_TIER) {
+        cli_out("Number of Bricks: %d", brick_count);
+    } else if (type == GF_CLUSTER_TYPE_DISPERSE) {
+        cli_out("Number of Bricks: %d x (%d + %d) = %d",
+                (brick_count / dist_count), disperse_count - redundancy_count,
+                redundancy_count, brick_count);
+    } else {
+        /* For both replicate and stripe, dist_count is
+           good enough */
+        if (arbiter_count == 0) {
+            cli_out("Number of Bricks: %d x %d = %d",
+                    (brick_count / dist_count), dist_count, brick_count);
+        } else {
+            cli_out("Number of Bricks: %d x (%d + %d) = %d",
+                    (brick_count / dist_count), dist_count - arbiter_count,
+                    arbiter_count, brick_count);
+        }
+    }
 }
 
 int
-gf_cli_print_tier_info (dict_t *dict, int i, int brick_count)
-{
-
-        int                  hot_brick_count        = -1;
-        int                  cold_type              = 0;
-        int                  cold_brick_count       = 0;
-        int                  cold_replica_count     = 0;
-        int                  cold_arbiter_count     = 0;
-        int                  cold_disperse_count    = 0;
-        int                  cold_redundancy_count  = 0;
-        int                  cold_dist_count        = 0;
-        int                  hot_type               = 0;
-        int                  hot_replica_count      = 0;
-        int                  hot_dist_count         = 0;
-        int                  ret                    = -1;
-        int                  vol_type               = -1;
-        char                 key[256]               = {0,};
-
-        GF_ASSERT (dict);
-
-        snprintf (key, sizeof (key), "volume%d.cold_brick_count", i);
-        ret = dict_get_int32 (dict, key, &cold_brick_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_type", i);
-        ret = dict_get_int32 (dict, key, &cold_type);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_dist_count", i);
-        ret = dict_get_int32 (dict, key, &cold_dist_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_replica_count", i);
-        ret = dict_get_int32 (dict, key, &cold_replica_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_arbiter_count", i);
-        ret = dict_get_int32 (dict, key, &cold_arbiter_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.cold_disperse_count", i);
-        ret = dict_get_int32 (dict, key, &cold_disperse_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key),
-                  "volume%d.cold_redundancy_count", i);
-        ret = dict_get_int32 (dict, key,
-                              &cold_redundancy_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.hot_brick_count", i);
-        ret = dict_get_int32 (dict, key, &hot_brick_count);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "volume%d.hot_type", i);
-        ret = dict_get_int32 (dict, key, &hot_type);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof (key), "volume%d.hot_replica_count", i);
-        ret = dict_get_int32 (dict, key, &hot_replica_count);
-        if (ret)
-                goto out;
-
-        cli_out ("Hot Tier :");
-        hot_dist_count = (hot_replica_count ?
-                          hot_replica_count : 1);
-
-        vol_type = get_vol_type (hot_type, hot_dist_count, hot_brick_count);
-        cli_out ("Hot Tier Type : %s",
-                 vol_type_str[vol_type]);
-
-        gf_cli_print_number_of_bricks (hot_type,
-                        hot_brick_count, hot_dist_count, 0,
-                        hot_replica_count, 0, 0, 0);
-
-        ret = print_brick_details (dict, i, 1, hot_brick_count,
-                                   hot_replica_count);
-        if (ret)
-                goto out;
-
-        cli_out ("Cold Tier:");
-
-        vol_type = get_vol_type (cold_type, cold_dist_count, cold_brick_count);
-        cli_out ("Cold Tier Type : %s",
-                        vol_type_str[vol_type]);
-
-        gf_cli_print_number_of_bricks (cold_type,
-                cold_brick_count,
-                cold_dist_count, 0, cold_replica_count,
-                cold_disperse_count, cold_redundancy_count, cold_arbiter_count);
-
-        ret = print_brick_details (dict, i, hot_brick_count+1,
-                                   brick_count, cold_replica_count);
-        if (ret)
-                goto out;
-out:
-        return ret;
+gf_cli_print_tier_info(dict_t *dict, int i, int brick_count)
+{
+    int hot_brick_count = -1;
+    int cold_type = 0;
+    int cold_brick_count = 0;
+    int cold_replica_count = 0;
+    int cold_arbiter_count = 0;
+    int cold_disperse_count = 0;
+    int cold_redundancy_count = 0;
+    int cold_dist_count = 0;
+    int hot_type = 0;
+    int hot_replica_count = 0;
+    int hot_dist_count = 0;
+    int ret = -1;
+    int vol_type = -1;
+    char key[256] = {
+        0,
+    };
+
+    GF_ASSERT(dict);
+
+    snprintf(key, sizeof(key), "volume%d.cold_brick_count", i);
+    ret = dict_get_int32(dict, key, &cold_brick_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_type", i);
+    ret = dict_get_int32(dict, key, &cold_type);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_dist_count", i);
+    ret = dict_get_int32(dict, key, &cold_dist_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_replica_count", i);
+    ret = dict_get_int32(dict, key, &cold_replica_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_arbiter_count", i);
+    ret = dict_get_int32(dict, key, &cold_arbiter_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_disperse_count", i);
+    ret = dict_get_int32(dict, key, &cold_disperse_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.cold_redundancy_count", i);
+    ret = dict_get_int32(dict, key, &cold_redundancy_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.hot_brick_count", i);
+    ret = dict_get_int32(dict, key, &hot_brick_count);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "volume%d.hot_type", i);
+    ret = dict_get_int32(dict, key, &hot_type);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof(key), "volume%d.hot_replica_count", i);
+    ret = dict_get_int32(dict, key, &hot_replica_count);
+    if (ret)
+        goto out;
+
+    cli_out("Hot Tier :");
+    hot_dist_count = (hot_replica_count ? hot_replica_count : 1);
+
+    vol_type = get_vol_type(hot_type, hot_dist_count, hot_brick_count);
+    cli_out("Hot Tier Type : %s", vol_type_str[vol_type]);
+
+    gf_cli_print_number_of_bricks(hot_type, hot_brick_count, hot_dist_count, 0,
+                                  hot_replica_count, 0, 0, 0);
+
+    ret = print_brick_details(dict, i, 1, hot_brick_count, hot_replica_count);
+    if (ret)
+        goto out;
+
+    cli_out("Cold Tier:");
+
+    vol_type = get_vol_type(cold_type, cold_dist_count, cold_brick_count);
+    cli_out("Cold Tier Type : %s", vol_type_str[vol_type]);
+
+    gf_cli_print_number_of_bricks(cold_type, cold_brick_count, cold_dist_count,
+                                  0, cold_replica_count, cold_disperse_count,
+                                  cold_redundancy_count, cold_arbiter_count);
+
+    ret = print_brick_details(dict, i, hot_brick_count + 1, brick_count,
+                              cold_replica_count);
+    if (ret)
+        goto out;
+out:
+    return ret;
 }
 
 int
-gf_cli_get_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
-{
-        int                        ret                  = -1;
-        int                        opt_count            = 0;
-        int32_t                    i                    = 0;
-        int32_t                    j                    = 1;
-        int32_t                    status               = 0;
-        int32_t                    type                 = 0;
-        int32_t                    brick_count          = 0;
-        int32_t                    dist_count           = 0;
-        int32_t                    stripe_count         = 0;
-        int32_t                    replica_count        = 0;
-        int32_t                    disperse_count       = 0;
-        int32_t                    redundancy_count     = 0;
-        int32_t                    arbiter_count        = 0;
-        int32_t                    snap_count           = 0;
-        int32_t                    vol_type             = 0;
-        int32_t                    transport            = 0;
-        char                      *volume_id_str        = NULL;
-        char                      *volname              = NULL;
-        dict_t                    *dict                 = NULL;
-        cli_local_t               *local                = NULL;
-        char                       key[1024]            = {0};
-        char                       err_str[2048]        = {0};
-        gf_cli_rsp                 rsp                  = {0};
-        char                      *caps __attribute__((unused)) = NULL;
-        int                        k __attribute__((unused)) = 0;
-        call_frame_t              *frame                = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
+gf_cli_get_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    int ret = -1;
+    int opt_count = 0;
+    int32_t i = 0;
+    int32_t j = 1;
+    int32_t status = 0;
+    int32_t type = 0;
+    int32_t brick_count = 0;
+    int32_t dist_count = 0;
+    int32_t stripe_count = 0;
+    int32_t replica_count = 0;
+    int32_t disperse_count = 0;
+    int32_t redundancy_count = 0;
+    int32_t arbiter_count = 0;
+    int32_t snap_count = 0;
+    int32_t vol_type = 0;
+    int32_t transport = 0;
+    char *volume_id_str = NULL;
+    char *volname = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
+    char key[1024] = {0};
+    char err_str[2048] = {0};
+    gf_cli_rsp rsp = {0};
+    char *caps __attribute__((unused)) = NULL;
+    int k __attribute__((unused)) = 0;
+    call_frame_t *frame = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to get vol: %d", rsp.op_ret);
+
+    if (!rsp.dict.dict_len) {
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+        cli_err("No volumes present");
+        ret = 0;
+        goto out;
+    }
 
-        frame = myframe;
+    dict = dict_new();
 
-        GF_ASSERT (frame->local);
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        local = frame->local;
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to allocate memory");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to get vol: %d",
-                rsp.op_ret);
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
 
-        if (!rsp.dict.dict_len) {
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-                cli_err ("No volumes present");
+    if (!count) {
+        switch (local->get_vol.flags) {
+            case GF_CLI_GET_NEXT_VOLUME:
+                GF_FREE(local->get_vol.volname);
+                local->get_vol.volname = NULL;
                 ret = 0;
                 goto out;
-        }
-
-        dict = dict_new ();
 
-        if (!dict) {
+            case GF_CLI_GET_VOLUME:
+                snprintf(err_str, sizeof(err_str), "Volume %s does not exist",
+                         local->get_vol.volname);
                 ret = -1;
-                goto out;
+                if (!(global_state->mode & GLUSTER_MODE_XML))
+                    goto out;
         }
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unable to allocate memory");
-                goto out;
-        }
+    if (rsp.op_ret) {
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
+xml_output:
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        /* For GET_NEXT_VOLUME output is already begun in
+         * and will also end in gf_cli_get_next_volume()
+         */
+        if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
+            ret = cli_xml_output_vol_info_begin(local, rsp.op_ret, rsp.op_errno,
+                                                rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
                 goto out;
-
-        if (!count) {
-                switch (local->get_vol.flags) {
-
-                case GF_CLI_GET_NEXT_VOLUME:
-                        GF_FREE (local->get_vol.volname);
-                        local->get_vol.volname = NULL;
-                        ret = 0;
-                        goto out;
-
-                case GF_CLI_GET_VOLUME:
-                        snprintf (err_str, sizeof (err_str),
-                                  "Volume %s does not exist",
-                                  local->get_vol.volname);
-                        ret = -1;
-                        if (!(global_state->mode & GLUSTER_MODE_XML))
-                                goto out;
-                }
+            }
         }
 
-        if (rsp.op_ret) {
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-                ret = -1;
+        if (dict) {
+            ret = cli_xml_output_vol_info(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
                 goto out;
+            }
         }
 
-xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                /* For GET_NEXT_VOLUME output is already begun in
-                 * and will also end in gf_cli_get_next_volume()
-                 */
-                if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
-                        ret = cli_xml_output_vol_info_begin
-                                (local, rsp.op_ret, rsp.op_errno,
-                                 rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto out;
-                        }
-                }
-
-                if (dict) {
-                        ret = cli_xml_output_vol_info (local, dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto out;
-                        }
-                }
-
-                if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
-                        ret = cli_xml_output_vol_info_end (local);
-                        if (ret)
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                }
-                goto out;
+        if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
+            ret = cli_xml_output_vol_info_end(local);
+            if (ret)
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
         }
+        goto out;
+    }
 
-        while ( i < count) {
-                cli_out (" ");
-                snprintf (key, 256, "volume%d.name", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
+    while (i < count) {
+        cli_out(" ");
+        snprintf(key, 256, "volume%d.name", i);
+        ret = dict_get_str(dict, key, &volname);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.type", i);
-                ret = dict_get_int32 (dict, key, &type);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.type", i);
+        ret = dict_get_int32(dict, key, &type);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.brick_count", i);
-                ret = dict_get_int32 (dict, key, &brick_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.brick_count", i);
+        ret = dict_get_int32(dict, key, &brick_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.dist_count", i);
-                ret = dict_get_int32 (dict, key, &dist_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.dist_count", i);
+        ret = dict_get_int32(dict, key, &dist_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.stripe_count", i);
-                ret = dict_get_int32 (dict, key, &stripe_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.stripe_count", i);
+        ret = dict_get_int32(dict, key, &stripe_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.replica_count", i);
-                ret = dict_get_int32 (dict, key, &replica_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.replica_count", i);
+        ret = dict_get_int32(dict, key, &replica_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.disperse_count", i);
-                ret = dict_get_int32 (dict, key, &disperse_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.disperse_count", i);
+        ret = dict_get_int32(dict, key, &disperse_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.redundancy_count", i);
-                ret = dict_get_int32 (dict, key, &redundancy_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.redundancy_count", i);
+        ret = dict_get_int32(dict, key, &redundancy_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof(key), "volume%d.arbiter_count", i);
-                ret = dict_get_int32 (dict, key, &arbiter_count);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "volume%d.arbiter_count", i);
+        ret = dict_get_int32(dict, key, &arbiter_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.transport", i);
-                ret = dict_get_int32 (dict, key, &transport);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.transport", i);
+        ret = dict_get_int32(dict, key, &transport);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.volume_id", i);
-                ret = dict_get_str (dict, key, &volume_id_str);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.volume_id", i);
+        ret = dict_get_str(dict, key, &volume_id_str);
+        if (ret)
+            goto out;
 
-                snprintf (key, 256, "volume%d.snap_count", i);
-                ret = dict_get_int32 (dict, key, &snap_count);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.snap_count", i);
+        ret = dict_get_int32(dict, key, &snap_count);
+        if (ret)
+            goto out;
 
-                // Distributed (stripe/replicate/stripe-replica) setups
-                vol_type = get_vol_type (type, dist_count, brick_count);
+        // Distributed (stripe/replicate/stripe-replica) setups
+        vol_type = get_vol_type(type, dist_count, brick_count);
 
-                cli_out ("Volume Name: %s", volname);
-                cli_out ("Type: %s", vol_type_str[vol_type]);
-                cli_out ("Volume ID: %s", volume_id_str);
-                cli_out ("Status: %s", cli_vol_status_str[status]);
-                cli_out ("Snapshot Count: %d", snap_count);
+        cli_out("Volume Name: %s", volname);
+        cli_out("Type: %s", vol_type_str[vol_type]);
+        cli_out("Volume ID: %s", volume_id_str);
+        cli_out("Status: %s", cli_vol_status_str[status]);
+        cli_out("Snapshot Count: %d", snap_count);
 
 #ifdef HAVE_BD_XLATOR
-                k = 0;
-                snprintf (key, sizeof (key), "volume%d.xlator%d", i, k);
-                ret = dict_get_str (dict, key, &caps);
-                if (ret)
-                        goto next;
-                do {
-                        j = 0;
-                        cli_out ("Xlator %d: %s", k + 1, caps);
-                        do {
-                                snprintf (key, sizeof (key),
-                                          "volume%d.xlator%d.caps%d",
-                                          i, k, j++);
-                                ret = dict_get_str (dict, key, &caps);
-                                if (ret)
-                                        break;
-                                cli_out ("Capability %d: %s", j, caps);
-                        } while (1);
-
-                        snprintf (key, sizeof (key),
-                                  "volume%d.xlator%d", i, ++k);
-                        ret = dict_get_str (dict, key, &caps);
-                        if (ret)
-                                break;
-                } while (1);
-
-next:
-#endif
-                gf_cli_print_number_of_bricks (type, brick_count,
-                                dist_count, stripe_count, replica_count,
-                                disperse_count, redundancy_count,
-                                arbiter_count);
+        k = 0;
+        snprintf(key, sizeof(key), "volume%d.xlator%d", i, k);
+        ret = dict_get_str(dict, key, &caps);
+        if (ret)
+            goto next;
+        do {
+            j = 0;
+            cli_out("Xlator %d: %s", k + 1, caps);
+            do {
+                snprintf(key, sizeof(key), "volume%d.xlator%d.caps%d", i, k,
+                         j++);
+                ret = dict_get_str(dict, key, &caps);
+                if (ret)
+                    break;
+                cli_out("Capability %d: %s", j, caps);
+            } while (1);
+
+            snprintf(key, sizeof(key), "volume%d.xlator%d", i, ++k);
+            ret = dict_get_str(dict, key, &caps);
+            if (ret)
+                break;
+        } while (1);
 
-                cli_out ("Transport-type: %s",
-                         ((transport == 0)?"tcp":
-                          (transport == 1)?"rdma":
-                          "tcp,rdma"));
-                j = 1;
+    next:
+#endif
+        gf_cli_print_number_of_bricks(
+            type, brick_count, dist_count, stripe_count, replica_count,
+            disperse_count, redundancy_count, arbiter_count);
 
-                GF_FREE (local->get_vol.volname);
-                local->get_vol.volname = gf_strdup (volname);
+        cli_out("Transport-type: %s",
+                ((transport == 0) ? "tcp"
+                                  : (transport == 1) ? "rdma" : "tcp,rdma"));
+        j = 1;
 
-                if (type == GF_CLUSTER_TYPE_TIER) {
-                        ret = gf_cli_print_tier_info (dict, i, brick_count);
-                        if (ret)
-                                goto out;
+        GF_FREE(local->get_vol.volname);
+        local->get_vol.volname = gf_strdup(volname);
 
-                } else {
-                        cli_out ("Bricks:");
-                        ret = print_brick_details (dict, i, j, brick_count,
-                                                  replica_count);
-                        if (ret)
-                                goto out;
-                }
+        if (type == GF_CLUSTER_TYPE_TIER) {
+            ret = gf_cli_print_tier_info(dict, i, brick_count);
+            if (ret)
+                goto out;
 
-                snprintf (key, 256, "volume%d.opt_count",i);
-                ret = dict_get_int32 (dict, key, &opt_count);
-                if (ret)
-                        goto out;
+        } else {
+            cli_out("Bricks:");
+            ret = print_brick_details(dict, i, j, brick_count, replica_count);
+            if (ret)
+                goto out;
+        }
 
-                if (!opt_count)
-                        goto out;
+        snprintf(key, 256, "volume%d.opt_count", i);
+        ret = dict_get_int32(dict, key, &opt_count);
+        if (ret)
+            goto out;
 
-                cli_out ("Options Reconfigured:");
+        if (!opt_count)
+            goto out;
 
-                snprintf (key, 256, "volume%d.option.",i);
+        cli_out("Options Reconfigured:");
 
-                ret = dict_foreach (dict, _gf_cli_output_volinfo_opts, key);
-                if (ret)
-                        goto out;
+        snprintf(key, 256, "volume%d.option.", i);
 
-                i++;
-        }
+        ret = dict_foreach(dict, _gf_cli_output_volinfo_opts, key);
+        if (ret)
+            goto out;
 
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret)
-                cli_err ("%s", err_str);
+    if (ret)
+        cli_err("%s", err_str);
 
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
+    free(rsp.dict.dict_val);
 
-        free (rsp.op_errstr);
+    free(rsp.op_errstr);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning: %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning: %d", ret);
+    return ret;
 }
 
 int
-gf_cli_create_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_create_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp       = {0,};
-        int                     ret       = -1;
-        cli_local_t             *local    = NULL;
-        char                    *volname  = NULL;
-        dict_t                  *rsp_dict = NULL;
-        call_frame_t            *frame    = NULL;
-
-        GF_ASSERT (myframe);
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    dict_t *rsp_dict = NULL;
+    call_frame_t *frame = NULL;
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    GF_ASSERT(myframe);
 
-        frame = myframe;
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        GF_ASSERT (frame->local);
+    frame = myframe;
 
-        local = frame->local;
+    GF_ASSERT(frame->local);
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    local = frame->local;
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to create volume");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret)
-                goto out;
+    gf_log("cli", GF_LOG_INFO, "Received resp to create volume");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-                ret = cli_xml_output_vol_create (rsp_dict, rsp.op_ret,
-                                                 rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed rsp_dict unserialization");
                 goto out;
+            }
         }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume create: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume create: %s: failed", volname);
-        else
-                cli_out ("volume create: %s: success: "
-                         "please start the volume to access data", volname);
+        ret = cli_xml_output_vol_create(rsp_dict, rsp.op_ret, rsp.op_errno,
+                                        rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume create: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume create: %s: failed", volname);
+    else
+        cli_out(
+            "volume create: %s: success: "
+            "please start the volume to access data",
+            volname);
+
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+    return ret;
 }
 
 int
-gf_cli_delete_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_delete_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *rsp_dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict get failed");
-                goto out;
-        }
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict get failed");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to delete volume");
+    gf_log("cli", GF_LOG_INFO, "Received resp to delete volume");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
-
-                ret = cli_xml_output_generic_volume ("volDelete", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed rsp_dict unserialization");
                 goto out;
+            }
         }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume delete: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume delete: %s: failed", volname);
-        else
-                cli_out ("volume delete: %s: success", volname);
+        ret = cli_xml_output_generic_volume("volDelete", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume delete: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume delete: %s: failed", volname);
+    else
+        cli_out("volume delete: %s: success", volname);
+
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, "Returning with %d", ret);
+    return ret;
 }
 
 int
-gf_cli3_1_uuid_get_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
-{
-        char                    *uuid_str = NULL;
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        frame->local = NULL;
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to uuid get");
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to unserialize "
-                        "response for uuid get");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "uuid", &uuid_str);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get uuid "
-                        "from dictionary");
-                goto out;
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_dict ("uuidGenerate", dict, rsp.op_ret,
-                                           rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, "") == 0)
-                        cli_err ("Get uuid was unsuccessful");
-                else
-                        cli_err ("%s", rsp.op_errstr);
+gf_cli3_1_uuid_get_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    char *uuid_str = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    frame->local = NULL;
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to uuid get");
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to unserialize "
+               "response for uuid get");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "uuid", &uuid_str);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get uuid "
+               "from dictionary");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_dict("uuidGenerate", dict, rsp.op_ret,
+                                  rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        } else {
-                cli_out ("UUID: %s", uuid_str);
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, "") == 0)
+            cli_err("Get uuid was unsuccessful");
+        else
+            cli_err("%s", rsp.op_errstr);
 
-        }
-        ret = rsp.op_ret;
+    } else {
+        cli_out("UUID: %s", uuid_str);
+    }
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        cli_local_wipe (local);
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    cli_local_wipe(local);
+    if (rsp.dict.dict_val)
+        free(rsp.dict.dict_val);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, "Returning with %d", ret);
+    return ret;
 }
 
 int
-gf_cli3_1_uuid_reset_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli3_1_uuid_reset_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        frame->local = NULL;
+    frame->local = NULL;
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to uuid reset");
+    gf_log("cli", GF_LOG_INFO, "Received resp to uuid reset");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_dict ("uuidReset", NULL, rsp.op_ret,
-                                           rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_dict("uuidReset", NULL, rsp.op_ret, rsp.op_errno,
+                                  rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("%s", rsp.op_errstr);
-        else
-                cli_out ("resetting the peer uuid has been %s",
-                         (rsp.op_ret) ? "unsuccessful": "successful");
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("%s", rsp.op_errstr);
+    else
+        cli_out("resetting the peer uuid has been %s",
+                (rsp.op_ret) ? "unsuccessful" : "successful");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        cli_local_wipe (local);
-        if (rsp.dict.dict_val)
-                free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    cli_local_wipe(local);
+    if (rsp.dict.dict_val)
+        free(rsp.dict.dict_val);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, "Returning with %d", ret);
+    return ret;
 }
 
 int
-gf_cli_start_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_start_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *rsp_dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "dict get failed");
-                goto out;
-        }
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "dict get failed");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to start volume");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
+    gf_log("cli", GF_LOG_INFO, "Received resp to start volume");
 
-                ret = cli_xml_output_generic_volume ("volStart", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed rsp_dict unserialization");
                 goto out;
+            }
         }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume start: %s: failed: %s", volname,
-                         rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume start: %s: failed", volname);
-        else
-                cli_out ("volume start: %s: success", volname);
+        ret = cli_xml_output_generic_volume("volStart", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume start: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume start: %s: failed", volname);
+    else
+        cli_out("volume start: %s: success", volname);
+
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+    return ret;
 }
 
 int
-gf_cli_stop_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_stop_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
 {
-        gf_cli_rsp            rsp   = {0,};
-        int                   ret   = -1;
-        cli_local_t           *local = NULL;
-        char                  *volname = NULL;
-        call_frame_t          *frame = NULL;
-        dict_t                *rsp_dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *rsp_dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        frame = myframe;
+    frame = myframe;
 
-        GF_ASSERT (frame->local);
+    GF_ASSERT(frame->local);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Unable to get volname from dict");
-                goto out;
-        }
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Unable to get volname from dict");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to stop volume");
+    gf_log("cli", GF_LOG_INFO, "Received resp to stop volume");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (rsp.op_ret == 0) {
-                        rsp_dict = dict_new ();
-                        ret = dict_unserialize (rsp.dict.dict_val,
-                                                rsp.dict.dict_len,
-                                                &rsp_dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Failed rsp_dict unserialization");
-                                goto out;
-                        }
-                }
-
-                ret = cli_xml_output_generic_volume ("volStop", rsp_dict,
-                                                     rsp.op_ret, rsp.op_errno,
-                                                     rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (rsp.op_ret == 0) {
+            rsp_dict = dict_new();
+            ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len,
+                                   &rsp_dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed rsp_dict unserialization");
                 goto out;
+            }
         }
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                cli_err ("volume stop: %s: failed: %s", volname, rsp.op_errstr);
-        else if (rsp.op_ret)
-                cli_err ("volume stop: %s: failed", volname);
-        else
-                cli_out ("volume stop: %s: success", volname);
+        ret = cli_xml_output_generic_volume("volStop", rsp_dict, rsp.op_ret,
+                                            rsp.op_errno, rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        ret = rsp.op_ret;
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        cli_err("volume stop: %s: failed: %s", volname, rsp.op_errstr);
+    else if (rsp.op_ret)
+        cli_err("volume stop: %s: failed", volname);
+    else
+        cli_out("volume stop: %s: success", volname);
+
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.op_errstr);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_print_rebalance_status (dict_t *dict, enum gf_task_types task_type,
-                               gf_boolean_t is_tier)
-{
-        int                ret            = -1;
-        int                count          = 0;
-        int                i              = 1;
-        char               key[256]       = {0,};
-        gf_defrag_status_t status_rcd     = GF_DEFRAG_STATUS_NOT_STARTED;
-        uint64_t           files          = 0;
-        uint64_t           size           = 0;
-        uint64_t           lookup         = 0;
-        char               *node_name     = NULL;
-        uint64_t           failures       = 0;
-        uint64_t           skipped        = 0;
-        double             elapsed        = 0;
-        char               *status_str    = NULL;
-        char               *size_str      = NULL;
-        int32_t            hrs            = 0;
-        uint32_t           min            = 0;
-        uint32_t           sec            = 0;
-        gf_boolean_t       down           = _gf_false;
-        gf_boolean_t       fix_layout     = _gf_false;
-        uint64_t           max_time       = 0;
-        uint64_t           max_elapsed    = 0;
-        uint64_t           time_left      = 0;
-        gf_boolean_t       show_estimates = _gf_false;
-
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "status-1");
-
-        ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, 1);
-                gf_log ("cli", GF_LOG_TRACE, "failed to get status");
-                goto out;
-        }
-
-        /* Fix layout will be sent to all nodes for the volume
-           so every status should be of type
-           GF_DEFRAG_STATUS_LAYOUT_FIX*
-        */
-
-        if ((task_type == GF_TASK_TYPE_REBALANCE)
-           && (status_rcd >= GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED)) {
-                fix_layout = _gf_true;
-        }
-
-        if (fix_layout) {
-                cli_out ("%35s %41s %27s", "Node", "status",
-                         "run time in h:m:s");
-                cli_out ("%35s %41s %27s", "---------", "-----------",
-                         "------------");
-        } else {
-                cli_out ("%40s %16s %13s %13s %13s %13s %20s %18s",
-                         "Node", "Rebalanced-files", "size", "scanned",
-                         "failures", "skipped", "status", "run time in"
-                         " h:m:s");
-                cli_out ("%40s %16s %13s %13s %13s %13s %20s %18s",
-                         "---------", "-----------", "-----------",
-                         "-----------", "-----------", "-----------",
-                         "------------", "--------------");
-        }
-
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name = NULL;
-                files = 0;
-                size = 0;
-                lookup = 0;
-                skipped = 0;
-                status_str = NULL;
-                elapsed = 0;
-                time_left = 0;
-
-                /* Check if status is NOT_STARTED, and continue early */
-                snprintf (key, sizeof (key), "status-%d", i);
-
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-                if (ret == -ENOENT) {
-                        gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, i);
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get status");
-                        gf_log ("cli", GF_LOG_ERROR, "node down and has failed"
-                                " to set dict");
-                        down = _gf_true;
-                        continue;
-                        /* skip this node if value not available*/
-                } else if (ret) {
-                        gf_log ("cli", GF_LOG_TRACE, "count %d %d", count, i);
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get status");
-                        continue;
-                        /* skip this node if value not available*/
-                }
-
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
-
-                if (GF_DEFRAG_STATUS_STARTED == status_rcd)
-                        show_estimates = _gf_true;
-
-                snprintf (key, 256, "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+gf_cli_print_rebalance_status(dict_t *dict, enum gf_task_types task_type,
+                              gf_boolean_t is_tier)
+{
+    int ret = -1;
+    int count = 0;
+    int i = 1;
+    char key[256] = {
+        0,
+    };
+    gf_defrag_status_t status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookup = 0;
+    char *node_name = NULL;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    double elapsed = 0;
+    char *status_str = NULL;
+    char *size_str = NULL;
+    int32_t hrs = 0;
+    uint32_t min = 0;
+    uint32_t sec = 0;
+    gf_boolean_t down = _gf_false;
+    gf_boolean_t fix_layout = _gf_false;
+    uint64_t max_time = 0;
+    uint64_t max_elapsed = 0;
+    uint64_t time_left = 0;
+    gf_boolean_t show_estimates = _gf_false;
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "count not set");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "status-1");
+
+    ret = dict_get_int32(dict, key, (int32_t *)&status_rcd);
+    if (ret) {
+        gf_log("cli", GF_LOG_TRACE, "count %d %d", count, 1);
+        gf_log("cli", GF_LOG_TRACE, "failed to get status");
+        goto out;
+    }
+
+    /* Fix layout will be sent to all nodes for the volume
+       so every status should be of type
+       GF_DEFRAG_STATUS_LAYOUT_FIX*
+    */
+
+    if ((task_type == GF_TASK_TYPE_REBALANCE) &&
+        (status_rcd >= GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED)) {
+        fix_layout = _gf_true;
+    }
+
+    if (fix_layout) {
+        cli_out("%35s %41s %27s", "Node", "status", "run time in h:m:s");
+        cli_out("%35s %41s %27s", "---------", "-----------", "------------");
+    } else {
+        cli_out("%40s %16s %13s %13s %13s %13s %20s %18s", "Node",
+                "Rebalanced-files", "size", "scanned", "failures", "skipped",
+                "status",
+                "run time in"
+                " h:m:s");
+        cli_out("%40s %16s %13s %13s %13s %13s %20s %18s", "---------",
+                "-----------", "-----------", "-----------", "-----------",
+                "-----------", "------------", "--------------");
+    }
+
+    for (i = 1; i <= count; i++) {
+        /* Reset the variables to prevent carryover of values */
+        node_name = NULL;
+        files = 0;
+        size = 0;
+        lookup = 0;
+        skipped = 0;
+        status_str = NULL;
+        elapsed = 0;
+        time_left = 0;
+
+        /* Check if status is NOT_STARTED, and continue early */
+        snprintf(key, sizeof(key), "status-%d", i);
+
+        ret = dict_get_int32(dict, key, (int32_t *)&status_rcd);
+        if (ret == -ENOENT) {
+            gf_log("cli", GF_LOG_TRACE, "count %d %d", count, i);
+            gf_log("cli", GF_LOG_TRACE, "failed to get status");
+            gf_log("cli", GF_LOG_ERROR,
+                   "node down and has failed"
+                   " to set dict");
+            down = _gf_true;
+            continue;
+            /* skip this node if value not available*/
+        } else if (ret) {
+            gf_log("cli", GF_LOG_TRACE, "count %d %d", count, i);
+            gf_log("cli", GF_LOG_TRACE, "failed to get status");
+            continue;
+            /* skip this node if value not available*/
+        }
+
+        if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
+            continue;
+
+        if (GF_DEFRAG_STATUS_STARTED == status_rcd)
+            show_estimates = _gf_true;
+
+        snprintf(key, 256, "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get node-name");
 
-                snprintf (key, sizeof (key), "files-%d", i);
-                ret = dict_get_uint64 (dict, key, &files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get file count");
+        snprintf(key, sizeof(key), "files-%d", i);
+        ret = dict_get_uint64(dict, key, &files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get file count");
 
-                snprintf (key, sizeof (key), "size-%d", i);
-                ret = dict_get_uint64 (dict, key, &size);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get size of xfer");
+        snprintf(key, sizeof(key), "size-%d", i);
+        ret = dict_get_uint64(dict, key, &size);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get size of xfer");
 
-                snprintf (key, sizeof (key), "lookups-%d", i);
-                ret = dict_get_uint64 (dict, key, &lookup);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get lookedup file count");
+        snprintf(key, sizeof(key), "lookups-%d", i);
+        ret = dict_get_uint64(dict, key, &lookup);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get lookedup file count");
 
-                snprintf (key, sizeof (key), "failures-%d", i);
-                ret = dict_get_uint64 (dict, key, &failures);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get failures count");
+        snprintf(key, sizeof(key), "failures-%d", i);
+        ret = dict_get_uint64(dict, key, &failures);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get failures count");
 
-                snprintf (key, sizeof (key), "skipped-%d", i);
-                ret = dict_get_uint64 (dict, key, &skipped);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get skipped count");
+        snprintf(key, sizeof(key), "skipped-%d", i);
+        ret = dict_get_uint64(dict, key, &skipped);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get skipped count");
 
-                /* For remove-brick include skipped count into failure count*/
-                if (task_type != GF_TASK_TYPE_REBALANCE) {
-                        failures += skipped;
-                        skipped = 0;
-                }
+        /* For remove-brick include skipped count into failure count*/
+        if (task_type != GF_TASK_TYPE_REBALANCE) {
+            failures += skipped;
+            skipped = 0;
+        }
 
-                snprintf (key, sizeof (key), "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get run-time");
+        snprintf(key, sizeof(key), "run-time-%d", i);
+        ret = dict_get_double(dict, key, &elapsed);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get run-time");
 
-                snprintf (key, sizeof (key), "time-left-%d", i);
-                ret = dict_get_uint64 (dict, key, &time_left);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get time left");
+        snprintf(key, sizeof(key), "time-left-%d", i);
+        ret = dict_get_uint64(dict, key, &time_left);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get time left");
 
-                if (elapsed > max_elapsed)
-                        max_elapsed = elapsed;
+        if (elapsed > max_elapsed)
+            max_elapsed = elapsed;
 
-                if (time_left > max_time)
-                        max_time = time_left;
+        if (time_left > max_time)
+            max_time = time_left;
 
-                /* Check for array bound */
-                if (status_rcd >= GF_DEFRAG_STATUS_MAX)
-                        status_rcd = GF_DEFRAG_STATUS_MAX;
+        /* Check for array bound */
+        if (status_rcd >= GF_DEFRAG_STATUS_MAX)
+            status_rcd = GF_DEFRAG_STATUS_MAX;
 
-                status_str = cli_vol_task_status_str[status_rcd];
-                size_str = gf_uint64_2human_readable(size);
-                hrs = elapsed / 3600;
-                min = ((uint64_t) elapsed % 3600) / 60;
-                sec = ((uint64_t) elapsed % 3600) % 60;
+        status_str = cli_vol_task_status_str[status_rcd];
+        size_str = gf_uint64_2human_readable(size);
+        hrs = elapsed / 3600;
+        min = ((uint64_t)elapsed % 3600) / 60;
+        sec = ((uint64_t)elapsed % 3600) % 60;
 
-                if (fix_layout) {
-                        cli_out ("%35s %50s %8d:%d:%d", node_name, status_str,
-                                 hrs, min, sec);
-                } else {
-                        if (size_str) {
-                                cli_out ("%40s %16"PRIu64 " %13s" " %13"PRIu64
-                                          " %13" PRIu64" %13"PRIu64 " %20s "
-                                         "%8d:%02d:%02d", node_name, files,
-                                         size_str, lookup, failures, skipped,
-                                         status_str, hrs, min, sec);
-                        } else {
-                                cli_out ("%40s %16"PRIu64 " %13"PRIu64 " %13"
-                                         PRIu64 " %13"PRIu64" %13"PRIu64 " %20s"
-                                         " %8d:%02d:%02d", node_name, files,
-                                         size, lookup, failures, skipped,
-                                         status_str, hrs, min, sec);
-                        }
-                }
-                GF_FREE(size_str);
-        }
-        if (is_tier && down)
-                cli_out ("WARNING: glusterd might be down on one or more nodes."
-                         " Please check the nodes that are down using \'gluster"
-                         " peer status\' and start the glusterd on those nodes,"
-                         " else tier detach commit might fail!");
-
-        /* Max time will be non-zero if rebalance is still running */
-        if (max_time) {
-                hrs = max_time / 3600;
-                min = (max_time % 3600) / 60;
-                sec = (max_time % 3600) % 60;
-
-                if (hrs < REBAL_ESTIMATE_SEC_UPPER_LIMIT) {
-                        cli_out ("Estimated time left for rebalance to "
-                                 "complete : %8d:%02d:%02d", hrs, min, sec);
-                } else {
-                        cli_out ("Estimated time left for rebalance to "
-                                 "complete : > 2 months. Please try again "
-                                 "later.");
-                }
+        if (fix_layout) {
+            cli_out("%35s %50s %8d:%d:%d", node_name, status_str, hrs, min,
+                    sec);
         } else {
-                /* Rebalance will return 0 if it could not calculate the
-                 * estimates or if it is complete.
-                 */
-                if (!show_estimates) {
-                        goto out;
-                }
-                if (max_elapsed <= REBAL_ESTIMATE_START_TIME) {
-                        cli_out ("The estimated time for rebalance to complete "
-                                 "will be unavailable for the first 10 "
-                                 "minutes.");
-                } else {
-                        cli_out ("Rebalance estimated time unavailable. Please "
-                                 "try again later.");
-                }
+            if (size_str) {
+                cli_out("%40s %16" PRIu64
+                        " %13s"
+                        " %13" PRIu64 " %13" PRIu64 " %13" PRIu64
+                        " %20s "
+                        "%8d:%02d:%02d",
+                        node_name, files, size_str, lookup, failures, skipped,
+                        status_str, hrs, min, sec);
+            } else {
+                cli_out("%40s %16" PRIu64 " %13" PRIu64 " %13" PRIu64
+                        " %13" PRIu64 " %13" PRIu64
+                        " %20s"
+                        " %8d:%02d:%02d",
+                        node_name, files, size, lookup, failures, skipped,
+                        status_str, hrs, min, sec);
+            }
+        }
+        GF_FREE(size_str);
+    }
+    if (is_tier && down)
+        cli_out(
+            "WARNING: glusterd might be down on one or more nodes."
+            " Please check the nodes that are down using \'gluster"
+            " peer status\' and start the glusterd on those nodes,"
+            " else tier detach commit might fail!");
+
+    /* Max time will be non-zero if rebalance is still running */
+    if (max_time) {
+        hrs = max_time / 3600;
+        min = (max_time % 3600) / 60;
+        sec = (max_time % 3600) % 60;
+
+        if (hrs < REBAL_ESTIMATE_SEC_UPPER_LIMIT) {
+            cli_out(
+                "Estimated time left for rebalance to "
+                "complete : %8d:%02d:%02d",
+                hrs, min, sec);
+        } else {
+            cli_out(
+                "Estimated time left for rebalance to "
+                "complete : > 2 months. Please try again "
+                "later.");
+        }
+    } else {
+        /* Rebalance will return 0 if it could not calculate the
+         * estimates or if it is complete.
+         */
+        if (!show_estimates) {
+            goto out;
+        }
+        if (max_elapsed <= REBAL_ESTIMATE_START_TIME) {
+            cli_out(
+                "The estimated time for rebalance to complete "
+                "will be unavailable for the first 10 "
+                "minutes.");
+        } else {
+            cli_out(
+                "Rebalance estimated time unavailable. Please "
+                "try again later.");
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_print_tier_status (dict_t *dict, enum gf_task_types task_type)
-{
-        int                ret          = -1;
-        int                count        = 0;
-        int                i            = 1;
-        uint64_t           promoted     = 0;
-        uint64_t           demoted      = 0;
-        char               key[256]     = {0,};
-        char               *node_name   = NULL;
-        gf_defrag_status_t status_rcd   = GF_DEFRAG_STATUS_NOT_STARTED;
-        char               *status_str  = NULL;
-        gf_boolean_t       down         = _gf_false;
-        double             elapsed      = 0;
-        int                hrs          = 0;
-        int                min          = 0;
-        int                sec          = 0;
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
-        }
-
-        cli_out ("%-20s %-20s %-20s %-20s %-20s", "Node", "Promoted files",
-                 "Demoted files", "Status", "run time in h:m:s");
-        cli_out ("%-20s %-20s %-20s %-20s %-20s", "---------", "---------",
-                 "---------", "---------", "---------");
-
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name = NULL;
-                promoted = 0;
-                demoted = 0;
-
-                /* Check if status is NOT_STARTED, and continue early */
-                snprintf (key, sizeof (key), "status-%d", i);
-
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
-                if (ret == -ENOENT) {
-                        gf_log ("cli", GF_LOG_TRACE, "count: %d, %d,"
-                                "failed to get status", count, i);
-                        gf_log ("cli", GF_LOG_ERROR, "node down and has failed"
-                                " to set dict");
-                        down = _gf_true;
-                        continue;
-                        /*skipping this node as value unavailable*/
-                } else if (ret) {
-                        gf_log ("cli", GF_LOG_TRACE, "count: %d, %d,"
-                                "failed to get status", count, i);
-                        continue;
-                }
-
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
-
-                snprintf (key, sizeof (key), "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+gf_cli_print_tier_status(dict_t *dict, enum gf_task_types task_type)
+{
+    int ret = -1;
+    int count = 0;
+    int i = 1;
+    uint64_t promoted = 0;
+    uint64_t demoted = 0;
+    char key[256] = {
+        0,
+    };
+    char *node_name = NULL;
+    gf_defrag_status_t status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
+    char *status_str = NULL;
+    gf_boolean_t down = _gf_false;
+    double elapsed = 0;
+    int hrs = 0;
+    int min = 0;
+    int sec = 0;
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "count not set");
+        goto out;
+    }
+
+    cli_out("%-20s %-20s %-20s %-20s %-20s", "Node", "Promoted files",
+            "Demoted files", "Status", "run time in h:m:s");
+    cli_out("%-20s %-20s %-20s %-20s %-20s", "---------", "---------",
+            "---------", "---------", "---------");
+
+    for (i = 1; i <= count; i++) {
+        /* Reset the variables to prevent carryover of values */
+        node_name = NULL;
+        promoted = 0;
+        demoted = 0;
+
+        /* Check if status is NOT_STARTED, and continue early */
+        snprintf(key, sizeof(key), "status-%d", i);
+
+        ret = dict_get_int32(dict, key, (int32_t *)&status_rcd);
+        if (ret == -ENOENT) {
+            gf_log("cli", GF_LOG_TRACE,
+                   "count: %d, %d,"
+                   "failed to get status",
+                   count, i);
+            gf_log("cli", GF_LOG_ERROR,
+                   "node down and has failed"
+                   " to set dict");
+            down = _gf_true;
+            continue;
+            /*skipping this node as value unavailable*/
+        } else if (ret) {
+            gf_log("cli", GF_LOG_TRACE,
+                   "count: %d, %d,"
+                   "failed to get status",
+                   count, i);
+            continue;
+        }
+
+        if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
+            continue;
+
+        snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get node-name");
 
-                snprintf (key, sizeof (key), "promoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &promoted);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get promoted count");
+        snprintf(key, sizeof(key), "promoted-%d", i);
+        ret = dict_get_uint64(dict, key, &promoted);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get promoted count");
 
-                snprintf (key, sizeof (key), "demoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &demoted);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE,
-                                "failed to get demoted count");
+        snprintf(key, sizeof(key), "demoted-%d", i);
+        ret = dict_get_uint64(dict, key, &demoted);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get demoted count");
 
-                snprintf (key, sizeof (key), "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get run-time");
+        snprintf(key, sizeof(key), "run-time-%d", i);
+        ret = dict_get_double(dict, key, &elapsed);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get run-time");
 
-                /* Check for array bound */
-                if (status_rcd >= GF_DEFRAG_STATUS_MAX)
-                        status_rcd = GF_DEFRAG_STATUS_MAX;
+        /* Check for array bound */
+        if (status_rcd >= GF_DEFRAG_STATUS_MAX)
+            status_rcd = GF_DEFRAG_STATUS_MAX;
 
-                hrs = elapsed / 3600;
-                min = ((int) elapsed % 3600) / 60;
-                sec = ((int) elapsed % 3600) % 60;
+        hrs = elapsed / 3600;
+        min = ((int)elapsed % 3600) / 60;
+        sec = ((int)elapsed % 3600) % 60;
 
-                status_str = cli_vol_task_status_str[status_rcd];
-                cli_out ("%-20s %-20"PRIu64" %-20"PRIu64" %-20s"
-                         " %d:%d:%d", node_name, promoted, demoted,
-                         status_str, hrs, min, sec);
-        }
-        if (down)
-                cli_out ("WARNING: glusterd might be down on one or more nodes."
-                         " Please check the nodes that are down using \'gluster"
-                         " peer status\' and start the glusterd on those nodes.");
+        status_str = cli_vol_task_status_str[status_rcd];
+        cli_out("%-20s %-20" PRIu64 " %-20" PRIu64
+                " %-20s"
+                " %d:%d:%d",
+                node_name, promoted, demoted, status_str, hrs, min, sec);
+    }
+    if (down)
+        cli_out(
+            "WARNING: glusterd might be down on one or more nodes."
+            " Please check the nodes that are down using \'gluster"
+            " peer status\' and start the glusterd on those nodes.");
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_defrag_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp   rsp          = {0,};
-        cli_local_t  *local       = NULL;
-        char         *volname     = NULL;
-        call_frame_t *frame       = NULL;
-        int          cmd          = 0;
-        int          ret          = -1;
-        dict_t       *dict        = NULL;
-        char         msg[1024]    = {0,};
-        char         *task_id_str = NULL;
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        GF_ASSERT (myframe);
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
+gf_cli_defrag_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    int cmd = 0;
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *task_id_str = NULL;
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    GF_ASSERT(myframe);
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "Failed to get volname");
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "rebalance-command", (int32_t *)&cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get command");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+            gf_log("glusterd", GF_LOG_ERROR,
+                   "failed to "
+                   "unserialize req-buffer to dictionary");
+            goto out;
         }
+    }
 
-        ret = dict_get_str (local->dict, "volname", &volname);
+    if (!((cmd == GF_DEFRAG_CMD_STOP) || (cmd == GF_DEFRAG_CMD_STATUS) ||
+          (cmd == GF_DEFRAG_CMD_STATUS_TIER)) &&
+        !(global_state->mode & GLUSTER_MODE_XML)) {
+        ret = dict_get_str(dict, GF_REBALANCE_TID_KEY, &task_id_str);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to get volname");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "rebalance-command",
-                              (int32_t *)&cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to get command");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("glusterd", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
-        }
-
-        if (!((cmd == GF_DEFRAG_CMD_STOP) ||
-              (cmd == GF_DEFRAG_CMD_STATUS) ||
-              (cmd == GF_DEFRAG_CMD_STATUS_TIER)) &&
-             !(global_state->mode & GLUSTER_MODE_XML)) {
-                ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "failed to get %s from dict",
-                                GF_REBALANCE_TID_KEY);
-                        goto out;
-                }
-                if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                } else {
-                         if (!rsp.op_ret) {
-                                /* append errstr in the cli msg for successful
-                                 * case since unlock failures can be highlighted
-                                 * event though rebalance command was successful
-                                 */
-                                 if (cmd == GF_DEFRAG_CMD_START_TIER) {
-                                         snprintf (msg, sizeof (msg), "Tier "
-                                                  "start is successful on %s.",
-                                                  volname);
-                                 } else if (cmd == GF_DEFRAG_CMD_STOP_TIER) {
-                                         snprintf (msg, sizeof (msg), "Tier "
-                                                  "daemon stopped "
-                                                  "on %s.", volname);
-                                 } else {
-                                         snprintf (msg, sizeof (msg),
-                                                  "Rebalance on %s has been "
-                                                  "started successfully. Use "
-                                                  "rebalance status command to"
-                                                  " check status of the "
-                                                  "rebalance process.\nID: %s",
-                                                  volname, task_id_str);
-                                 }
-                         } else {
-                                snprintf (msg, sizeof (msg),
-                                          "Starting rebalance on volume %s has "
-                                          "been unsuccessful.", volname);
-                        }
-                }
-                goto done;
-        }
-
-        if (cmd == GF_DEFRAG_CMD_STOP) {
-                if (rsp.op_ret == -1) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg),
-                                          "%s", rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg),
-                                          "rebalance volume %s stop failed",
-                                          volname);
-                        goto done;
-                } else {
-                        /* append errstr in the cli msg for successful case
-                         * since unlock failures can be highlighted event though
-                         * rebalance command was successful */
-                        snprintf (msg, sizeof (msg),
-                                  "rebalance process may be in the middle of a "
-                                  "file migration.\nThe process will be fully "
-                                  "stopped once the migration of the file is "
-                                  "complete.\nPlease check rebalance process "
-                                  "for completion before doing any further "
-                                  "brick related tasks on the volume.\n%s",
-                                  rsp.op_errstr);
-                }
+            gf_log("cli", GF_LOG_WARNING, "failed to get %s from dict",
+                   GF_REBALANCE_TID_KEY);
+            goto out;
         }
-        if (cmd == GF_DEFRAG_CMD_STATUS || cmd == GF_DEFRAG_CMD_STATUS_TIER) {
-                if (rsp.op_ret == -1) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg),
-                                          "%s", rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg),
-                                          "Failed to get the status of "
-                                          "rebalance process");
-                        goto done;
+        if (rsp.op_ret && strcmp(rsp.op_errstr, "")) {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        } else {
+            if (!rsp.op_ret) {
+                /* append errstr in the cli msg for successful
+                 * case since unlock failures can be highlighted
+                 * event though rebalance command was successful
+                 */
+                if (cmd == GF_DEFRAG_CMD_START_TIER) {
+                    snprintf(msg, sizeof(msg),
+                             "Tier "
+                             "start is successful on %s.",
+                             volname);
+                } else if (cmd == GF_DEFRAG_CMD_STOP_TIER) {
+                    snprintf(msg, sizeof(msg),
+                             "Tier "
+                             "daemon stopped "
+                             "on %s.",
+                             volname);
                 } else {
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                }
+                    snprintf(msg, sizeof(msg),
+                             "Rebalance on %s has been "
+                             "started successfully. Use "
+                             "rebalance status command to"
+                             " check status of the "
+                             "rebalance process.\nID: %s",
+                             volname, task_id_str);
+                }
+            } else {
+                snprintf(msg, sizeof(msg),
+                         "Starting rebalance on volume %s has "
+                         "been unsuccessful.",
+                         volname);
+            }
+        }
+        goto done;
+    }
+
+    if (cmd == GF_DEFRAG_CMD_STOP) {
+        if (rsp.op_ret == -1) {
+            if (strcmp(rsp.op_errstr, ""))
+                snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            else
+                snprintf(msg, sizeof(msg), "rebalance volume %s stop failed",
+                         volname);
+            goto done;
+        } else {
+            /* append errstr in the cli msg for successful case
+             * since unlock failures can be highlighted event though
+             * rebalance command was successful */
+            snprintf(msg, sizeof(msg),
+                     "rebalance process may be in the middle of a "
+                     "file migration.\nThe process will be fully "
+                     "stopped once the migration of the file is "
+                     "complete.\nPlease check rebalance process "
+                     "for completion before doing any further "
+                     "brick related tasks on the volume.\n%s",
+                     rsp.op_errstr);
+        }
+    }
+    if (cmd == GF_DEFRAG_CMD_STATUS || cmd == GF_DEFRAG_CMD_STATUS_TIER) {
+        if (rsp.op_ret == -1) {
+            if (strcmp(rsp.op_errstr, ""))
+                snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+            else
+                snprintf(msg, sizeof(msg),
+                         "Failed to get the status of "
+                         "rebalance process");
+            goto done;
+        } else {
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
         }
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_rebalance (cmd, dict, rsp.op_ret,
-                                                    rsp.op_errno,
-                                                    rsp.op_errstr);
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_rebalance(cmd, dict, rsp.op_ret, rsp.op_errno,
+                                           rsp.op_errstr);
+        goto out;
+    }
 
-        if (cmd == GF_DEFRAG_CMD_STATUS_TIER)
-                ret = gf_cli_print_tier_status (dict, GF_TASK_TYPE_REBALANCE);
-        else if (cmd == GF_DEFRAG_CMD_DETACH_STATUS)
-                ret = gf_cli_print_rebalance_status (dict,
-                                                     GF_TASK_TYPE_REBALANCE,
-                                                     _gf_true);
-        else
-                ret = gf_cli_print_rebalance_status (dict,
-                                                     GF_TASK_TYPE_REBALANCE,
-                                                     _gf_false);
+    if (cmd == GF_DEFRAG_CMD_STATUS_TIER)
+        ret = gf_cli_print_tier_status(dict, GF_TASK_TYPE_REBALANCE);
+    else if (cmd == GF_DEFRAG_CMD_DETACH_STATUS)
+        ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REBALANCE,
+                                            _gf_true);
+    else
+        ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REBALANCE,
+                                            _gf_false);
 
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to print rebalance status");
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "Failed to print rebalance status");
 
 done:
-        if (global_state->mode & GLUSTER_MODE_XML)
-                cli_xml_output_str ("volRebalance", msg,
-                                    rsp.op_ret, rsp.op_errno,
-                                    rsp.op_errstr);
-        else {
-                if (rsp.op_ret)
-
-                        if (cmd == GF_DEFRAG_CMD_START_TIER || cmd ==
-                            GF_DEFRAG_CMD_STATUS_TIER) {
-                                cli_err ("Tiering Migration Functionality: %s:"
-                                         " failed%s%s", volname,
-                                         strlen (msg) ? ": " : "", msg);
-                        } else
-                                cli_err ("volume rebalance: %s: failed%s%s",
-                                         volname, strlen (msg) ? ": " : "",
-                                         msg);
-                else
-                        if (cmd == GF_DEFRAG_CMD_START_TIER || cmd ==
-                            GF_DEFRAG_CMD_STATUS_TIER) {
-                                cli_out ("Tiering Migration Functionality: %s:"
-                                         " success%s%s", volname,
-                                         strlen (msg) ? ": " : "", msg);
-                        } else
-                                cli_out ("volume rebalance: %s: success%s%s",
-                                         volname, strlen (msg) ? ": " : "",
-                                         msg);
-        }
-        ret = rsp.op_ret;
+    if (global_state->mode & GLUSTER_MODE_XML)
+        cli_xml_output_str("volRebalance", msg, rsp.op_ret, rsp.op_errno,
+                           rsp.op_errstr);
+    else {
+        if (rsp.op_ret)
 
-out:
-        free (rsp.op_errstr); //malloced by xdr
-        free (rsp.dict.dict_val); //malloced by xdr
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+            if (cmd == GF_DEFRAG_CMD_START_TIER ||
+                cmd == GF_DEFRAG_CMD_STATUS_TIER) {
+                cli_err(
+                    "Tiering Migration Functionality: %s:"
+                    " failed%s%s",
+                    volname, strlen(msg) ? ": " : "", msg);
+            } else
+                cli_err("volume rebalance: %s: failed%s%s", volname,
+                        strlen(msg) ? ": " : "", msg);
+        else if (cmd == GF_DEFRAG_CMD_START_TIER ||
+                 cmd == GF_DEFRAG_CMD_STATUS_TIER) {
+            cli_out(
+                "Tiering Migration Functionality: %s:"
+                " success%s%s",
+                volname, strlen(msg) ? ": " : "", msg);
+        } else
+            cli_out("volume rebalance: %s: success%s%s", volname,
+                    strlen(msg) ? ": " : "", msg);
+    }
+    ret = rsp.op_ret;
+
+out:
+    free(rsp.op_errstr);      // malloced by xdr
+    free(rsp.dict.dict_val);  // malloced by xdr
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_rename_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        char                    msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
+gf_cli_rename_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to probe");
+    snprintf(msg, sizeof(msg), "Rename volume %s",
+             (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volRename", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
-        snprintf (msg, sizeof (msg), "Rename volume %s",
-                  (rsp.op_ret) ? "unsuccessful": "successful");
+    if (rsp.op_ret)
+        cli_err("volume rename: failed");
+    else
+        cli_out("volume rename: success");
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volRename", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret)
-                cli_err ("volume rename: failed");
-        else
-                cli_out ("volume rename: success");
-
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_reset_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli_reset_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
-        gf_cli_rsp           rsp   = {0,};
-        int                  ret   = -1;
-        char                 msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to reset");
-
-        if (strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "reset volume %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volReset", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to reset");
+
+    if (strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "reset volume %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volReset", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume reset: failed: %s", msg);
-        else
-                cli_out ("volume reset: success: %s", msg);
+    if (rsp.op_ret)
+        cli_err("volume reset: failed: %s", msg);
+    else
+        cli_out("volume reset: success: %s", msg);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 char *
-is_server_debug_xlator (void *myframe)
-{
-        call_frame_t         *frame        = NULL;
-        cli_local_t          *local        = NULL;
-        char                 **words       = NULL;
-        char                 *key          = NULL;
-        char                 *value        = NULL;
-        char                 *debug_xlator = NULL;
-
-        frame = myframe;
-        local = frame->local;
-        words = (char **)local->words;
-
-        while (*words != NULL) {
-                if (strstr (*words, "trace") == NULL &&
-                    strstr (*words, "error-gen") == NULL) {
-                        words++;
-                        continue;
-                }
-
-                key = *words;
+is_server_debug_xlator(void *myframe)
+{
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    char **words = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char *debug_xlator = NULL;
+
+    frame = myframe;
+    local = frame->local;
+    words = (char **)local->words;
+
+    while (*words != NULL) {
+        if (strstr(*words, "trace") == NULL &&
+            strstr(*words, "error-gen") == NULL) {
+            words++;
+            continue;
+        }
+
+        key = *words;
+        words++;
+        value = *words;
+        if (value == NULL)
+            break;
+        if (strstr(value, "client")) {
+            words++;
+            continue;
+        } else {
+            if (!(strstr(value, "posix") || strstr(value, "acl") ||
+                  strstr(value, "locks") || strstr(value, "io-threads") ||
+                  strstr(value, "marker") || strstr(value, "index"))) {
                 words++;
-                value = *words;
-                if (value == NULL)
-                        break;
-                if (strstr (value, "client")) {
-                        words++;
-                        continue;
-                } else {
-                        if (!(strstr (value, "posix") || strstr (value, "acl")
-                              || strstr (value, "locks") ||
-                              strstr (value, "io-threads") ||
-                              strstr (value, "marker") ||
-                              strstr (value, "index"))) {
-                                words++;
-                                continue;
-                        } else {
-                                debug_xlator = gf_strdup (key);
-                                break;
-                        }
-                }
+                continue;
+            } else {
+                debug_xlator = gf_strdup(key);
+                break;
+            }
         }
+    }
 
-        return debug_xlator;
+    return debug_xlator;
 }
 
 int
-gf_cli_set_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp           rsp   = {0,};
-        int                  ret   = -1;
-        dict_t               *dict = NULL;
-        char                 *help_str = NULL;
-        char                 msg[1024] = {0,};
-        char                 *debug_xlator = NULL;
-        char                 tmp_str[512] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to set");
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "failed to unserialize volume set respone dict");
-                goto out;
-        }
-
-        /* For brick processes graph change does not happen on the fly.
-         * The process has to be restarted. So this is a check from the
-         * volume set option such that if debug xlators such as trace/errorgen
-         * are provided in the set command, warn the user.
-         */
-        debug_xlator = is_server_debug_xlator (myframe);
-
-        if (dict_get_str (dict, "help-str", &help_str) && !msg[0])
-                snprintf (msg, sizeof (msg), "Set volume %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-        if (rsp.op_ret == 0 && debug_xlator) {
-                snprintf (tmp_str, sizeof (tmp_str), "\n%s translator has been "
-                          "added to the server volume file. Please restart the"
-                          " volume for enabling the translator", debug_xlator);
-        }
-
-        if ((global_state->mode & GLUSTER_MODE_XML) && (help_str == NULL)) {
-                ret = cli_xml_output_str ("volSet", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_set_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *help_str = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *debug_xlator = NULL;
+    char tmp_str[512] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to set");
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "failed to unserialize volume set respone dict");
+        goto out;
+    }
+
+    /* For brick processes graph change does not happen on the fly.
+     * The process has to be restarted. So this is a check from the
+     * volume set option such that if debug xlators such as trace/errorgen
+     * are provided in the set command, warn the user.
+     */
+    debug_xlator = is_server_debug_xlator(myframe);
+
+    if (dict_get_str(dict, "help-str", &help_str) && !msg[0])
+        snprintf(msg, sizeof(msg), "Set volume %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+    if (rsp.op_ret == 0 && debug_xlator) {
+        snprintf(tmp_str, sizeof(tmp_str),
+                 "\n%s translator has been "
+                 "added to the server volume file. Please restart the"
+                 " volume for enabling the translator",
+                 debug_xlator);
+    }
+
+    if ((global_state->mode & GLUSTER_MODE_XML) && (help_str == NULL)) {
+        ret = cli_xml_output_str("volSet", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("volume set: failed: %s", rsp.op_errstr);
-                else
-                        cli_err ("volume set: failed");
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("volume set: failed: %s", rsp.op_errstr);
+        else
+            cli_err("volume set: failed");
+    } else {
+        if (help_str == NULL) {
+            if (debug_xlator == NULL)
+                cli_out("volume set: success");
+            else
+                cli_out("volume set: success%s", tmp_str);
         } else {
-                if (help_str == NULL) {
-                        if (debug_xlator == NULL)
-                                cli_out ("volume set: success");
-                        else
-                                cli_out ("volume set: success%s", tmp_str);
-                }else {
-                        cli_out ("%s", help_str);
-                }
+            cli_out("%s", help_str);
         }
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        GF_FREE (debug_xlator);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    GF_FREE(debug_xlator);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_add_tier_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                           int count, void *myframe)
-{
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to attach tier");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Attach tier %s",
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAttachTier", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_add_tier_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("cli", myframe, out);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to attach tier");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Attach tier %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volAttachTier", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume attach-tier: failed: %s", msg);
-        else
-                cli_out ("volume attach-tier: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume attach-tier: failed: %s", msg);
+    else
+        cli_out("volume attach-tier: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+    return ret;
 }
 
 int
-gf_cli_attach_tier_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("cli", myframe, out);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to attach tier");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Attach tier %s",
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAttachTier", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_attach_tier_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("cli", myframe, out);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to attach tier");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Attach tier %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volAttachTier", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume attach-tier: failed: %s", msg);
-        else
-                cli_out ("volume attach-tier: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume attach-tier: failed: %s", msg);
+    else
+        cli_out("volume attach-tier: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+    return ret;
 }
 
 int
-gf_cli_remove_tier_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-
-        gf_cli_rsp                      rsp   = {0,};
-        int                             ret   = -1;
-        char                            msg[1024] = {0,};
-        char                           *cmd_str = "unknown";
-        cli_local_t                    *local = NULL;
-        call_frame_t                   *frame = NULL;
-        char                           *task_id_str = NULL;
-        dict_t                         *rsp_dict = NULL;
-        int32_t                         command = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", &command);
+gf_cli_remove_tier_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                             void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+    char *cmd_str = "unknown";
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *task_id_str = NULL;
+    dict_t *rsp_dict = NULL;
+    int32_t command = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "command", &command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "failed to get command");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        rsp_dict = dict_new();
+        if (!rsp_dict) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret) {
-                 gf_log ("", GF_LOG_ERROR, "failed to get command");
-                 goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to unserialize rsp_dict");
+            goto out;
         }
+    }
 
-
-        if (rsp.dict.dict_len) {
-                rsp_dict = dict_new ();
-                if (!rsp_dict) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                        &rsp_dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to unserialize rsp_dict");
-                        goto out;
-                }
-        }
-
-        switch (command) {
+    switch (command) {
         case GF_DEFRAG_CMD_DETACH_START:
-                cmd_str = "start";
-
-                ret = dict_get_str (rsp_dict, GF_REMOVE_BRICK_TID_KEY,
-                                    &task_id_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "remove-brick-id is not present in dict");
-                }
-                break;
+            cmd_str = "start";
+
+            ret = dict_get_str(rsp_dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "remove-brick-id is not present in dict");
+            }
+            break;
         case GF_DEFRAG_CMD_DETACH_COMMIT:
-                cmd_str = "commit";
-                break;
+            cmd_str = "commit";
+            break;
         case GF_DEFRAG_CMD_DETACH_COMMIT_FORCE:
-                cmd_str = "commit force";
-                break;
+            cmd_str = "commit force";
+            break;
         case GF_DEFRAG_CMD_DETACH_STOP:
-                cmd_str = "stop";
-                break;
+            cmd_str = "stop";
+            break;
         case GF_DEFRAG_CMD_DETACH_STATUS:
-                cmd_str = "status";
-                break;
+            cmd_str = "status";
+            break;
 
         default:
-                cmd_str = "unknown";
-                break;
-        }
+            cmd_str = "unknown";
+            break;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to detach tier");
+    gf_log("cli", GF_LOG_INFO, "Received resp to detach tier");
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Detach tier %s %s", cmd_str,
-                          (rsp.op_ret) ? "unsuccessful" : "successful");
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Detach tier %s %s", cmd_str,
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
 
-        ret = rsp.op_ret;
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                _gf_true, rsp_dict,
-                                rsp.op_ret, rsp.op_errno,
-                                msg, "volDetachTier");
+    ret = rsp.op_ret;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_remove_brick_detach_tier(
+            _gf_true, rsp_dict, rsp.op_ret, rsp.op_errno, msg, "volDetachTier");
 
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        } else {
-                if (rsp.op_ret) {
-                        if (strcmp (rsp.op_errstr, ""))
-                                snprintf (msg, sizeof (msg), "volume tier "
-                                          "detach %s: failed: %s", cmd_str,
-                                          rsp.op_errstr);
-                        else
-                                snprintf (msg, sizeof (msg), "volume tier "
-                                          "detach %s: failed", cmd_str);
-
-                        cli_err ("%s", msg);
-                        goto out;
-
-                } else {
-                        cli_out ("volume detach tier %s: success", cmd_str);
-                        if (GF_DEFRAG_CMD_DETACH_START == command &&
-                            task_id_str != NULL)
-                                cli_out ("ID: %s", task_id_str);
-                        if (GF_DEFRAG_CMD_DETACH_COMMIT == command)
-                                cli_out ("Check the detached bricks to ensure "
-                                         "all files are migrated.\nIf files "
-                                         "with data are found on the brick "
-                                         "path, copy them via a gluster mount "
-                                         "point before re-purposing the "
-                                         "removed brick. ");
-                }
-        }
-        if (command == GF_DEFRAG_CMD_DETACH_STOP ||
-            command == GF_DEFRAG_CMD_DETACH_STATUS)
-                ret = gf_cli_print_rebalance_status (rsp_dict,
-                                GF_TASK_TYPE_REMOVE_BRICK, _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                                "rebalance status");
-                goto out;
-        }
-
-        if ((command == GF_DEFRAG_CMD_DETACH_STOP) && (rsp.op_ret == 0)) {
-                cli_out ("'detach tier' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check detach tier process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
-        ret = rsp.op_ret;
-
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    } else {
+        if (rsp.op_ret) {
+            if (strcmp(rsp.op_errstr, ""))
+                snprintf(msg, sizeof(msg),
+                         "volume tier "
+                         "detach %s: failed: %s",
+                         cmd_str, rsp.op_errstr);
+            else
+                snprintf(msg, sizeof(msg),
+                         "volume tier "
+                         "detach %s: failed",
+                         cmd_str);
+
+            cli_err("%s", msg);
+            goto out;
 
-        return ret;
+        } else {
+            cli_out("volume detach tier %s: success", cmd_str);
+            if (GF_DEFRAG_CMD_DETACH_START == command && task_id_str != NULL)
+                cli_out("ID: %s", task_id_str);
+            if (GF_DEFRAG_CMD_DETACH_COMMIT == command)
+                cli_out(
+                    "Check the detached bricks to ensure "
+                    "all files are migrated.\nIf files "
+                    "with data are found on the brick "
+                    "path, copy them via a gluster mount "
+                    "point before re-purposing the "
+                    "removed brick. ");
+        }
+    }
+    if (command == GF_DEFRAG_CMD_DETACH_STOP ||
+        command == GF_DEFRAG_CMD_DETACH_STATUS)
+        ret = gf_cli_print_rebalance_status(rsp_dict, GF_TASK_TYPE_REMOVE_BRICK,
+                                            _gf_true);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to print remove-brick "
+               "rebalance status");
+        goto out;
+    }
+
+    if ((command == GF_DEFRAG_CMD_DETACH_STOP) && (rsp.op_ret == 0)) {
+        cli_out(
+            "'detach tier' process may be in the middle of a "
+            "file migration.\nThe process will be fully stopped "
+            "once the migration of the file is complete.\nPlease "
+            "check detach tier process for completion before "
+            "doing any further brick related tasks on the "
+            "volume.");
+    }
+    ret = rsp.op_ret;
+
+out:
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+
+    return ret;
 }
 
 int
-gf_cli_detach_tier_status_cbk (struct rpc_req *req, struct iovec *iov,
-                                 int count, void *myframe)
-{
-        gf_cli_rsp               rsp     = {0,};
-        int                      ret     = -1;
-        dict_t                  *dict    = NULL;
-        char                     msg[1024] = {0,};
-        int32_t                  command = 0;
-        gf1_op_commands          cmd = GF_OP_CMD_NONE;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *cmd_str = "unknown";
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+gf_cli_detach_tier_status_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                              void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    int32_t command = 0;
+    gf1_op_commands cmd = GF_OP_CMD_NONE;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *cmd_str = "unknown";
 
-        frame = myframe;
+    GF_ASSERT(myframe);
 
-        GF_ASSERT (frame->local);
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        local = frame->local;
+    frame = myframe;
 
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    GF_ASSERT(frame->local);
 
-        ret = dict_get_int32 (local->dict, "command", &command);
-        if (ret)
-                goto out;
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "command", &command);
+    if (ret)
+        goto out;
 
-        cmd = command;
+    cmd = command;
 
-        switch (cmd) {
+    switch (cmd) {
         case GF_OP_CMD_STOP_DETACH_TIER:
-                cmd_str = "stop";
-                break;
+            cmd_str = "stop";
+            break;
         case GF_OP_CMD_STATUS:
-                cmd_str = "status";
-                break;
+            cmd_str = "status";
+            break;
         default:
-                break;
-        }
-
-        ret = rsp.op_ret;
-        if (rsp.op_ret == -1) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume tier detach %s: "
-                                  "failed: %s", cmd_str, rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume tier detach %s: "
-                                  "failed", cmd_str);
+            break;
+    }
+
+    ret = rsp.op_ret;
+    if (rsp.op_ret == -1) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg),
+                     "volume tier detach %s: "
+                     "failed: %s",
+                     cmd_str, rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg),
+                     "volume tier detach %s: "
+                     "failed",
+                     cmd_str);
 
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-                cli_err ("%s", msg);
-                goto out;
-        }
+        cli_err("%s", msg);
+        goto out;
+    }
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        strncpy (msg, "failed to unserialize req-buffer to "
-                                 "dictionary", sizeof (msg));
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+        if (ret < 0) {
+            strncpy(msg,
+                    "failed to unserialize req-buffer to "
+                    "dictionary",
+                    sizeof(msg));
 
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                rsp.op_ret = -1;
-                                goto xml_output;
-                        }
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                rsp.op_ret = -1;
+                goto xml_output;
+            }
 
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR, "%s", msg);
+            goto out;
         }
+    }
 xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr,
-                                                               "volDetachTier");
-                } else {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier
-                                                               (_gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               msg,
-                                                               "volDetachTier");
-                }
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (strcmp(rsp.op_errstr, "")) {
+            ret = cli_xml_output_vol_remove_brick_detach_tier(
+                _gf_true, dict, rsp.op_ret, rsp.op_errno, rsp.op_errstr,
+                "volDetachTier");
+        } else {
+            ret = cli_xml_output_vol_remove_brick_detach_tier(
+                _gf_true, dict, rsp.op_ret, rsp.op_errno, msg, "volDetachTier");
+        }
+        goto out;
+    }
+
+    ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REMOVE_BRICK,
+                                        _gf_true);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to print remove-brick "
+               "rebalance status");
+        goto out;
+    }
+
+    if ((cmd == GF_OP_CMD_STOP_DETACH_TIER) && (rsp.op_ret == 0)) {
+        cli_out(
+            "'detach tier' process may be in the middle of a "
+            "file migration.\nThe process will be fully stopped "
+            "once the migration of the file is complete.\nPlease "
+            "check detach tier process for completion before "
+            "doing any further brick related tasks on the "
+            "volume.");
+    }
+
+out:
+    free(rsp.dict.dict_val); /* malloced by xdr */
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
+}
 
-        ret = gf_cli_print_rebalance_status (dict, GF_TASK_TYPE_REMOVE_BRICK,
-                                             _gf_true);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                        "rebalance status");
-                goto out;
-        }
+int
+gf_cli_add_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to add brick");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Add Brick %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volAddBrick", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if ((cmd == GF_OP_CMD_STOP_DETACH_TIER) && (rsp.op_ret == 0)) {
-                cli_out ("'detach tier' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check detach tier process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
+    if (rsp.op_ret)
+        cli_err("volume add-brick: failed: %s", rsp.op_errstr);
+    else
+        cli_out("volume add-brick: success");
+    ret = rsp.op_ret;
 
 out:
-        free (rsp.dict.dict_val); /* malloced by xdr */
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
+    return ret;
 }
 
-
 int
-gf_cli_add_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
+gf_cli3_remove_brick_status_cbk(struct rpc_req *req, struct iovec *iov,
+                                int count, void *myframe)
 {
-        gf_cli_rsp                  rsp   = {0,};
-        int                         ret   = -1;
-        char                        msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to add brick");
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    int32_t command = 0;
+    gf1_op_commands cmd = GF_OP_CMD_NONE;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *cmd_str = "unknown";
 
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Add Brick %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
+    GF_ASSERT(myframe);
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volAddBrick", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume add-brick: failed: %s", rsp.op_errstr);
-        else
-                cli_out ("volume add-brick: success");
-        ret = rsp.op_ret;
+    frame = myframe;
 
-out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
-        return ret;
-}
+    GF_ASSERT(frame->local);
 
-int
-gf_cli3_remove_brick_status_cbk (struct rpc_req *req, struct iovec *iov,
-                                 int count, void *myframe)
-{
-        gf_cli_rsp               rsp     = {0,};
-        int                      ret     = -1;
-        dict_t                  *dict    = NULL;
-        char                     msg[1024] = {0,};
-        int32_t                  command = 0;
-        gf1_op_commands          cmd = GF_OP_CMD_NONE;
-        cli_local_t             *local = NULL;
-        call_frame_t            *frame = NULL;
-        char                    *cmd_str = "unknown";
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    local = frame->local;
 
-        frame = myframe;
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        GF_ASSERT (frame->local);
+    ret = dict_get_int32(local->dict, "command", &command);
+    if (ret)
+        goto out;
 
-        local = frame->local;
+    cmd = command;
 
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", &command);
-        if (ret)
-                goto out;
-
-        cmd = command;
-
-        switch (cmd) {
+    switch (cmd) {
         case GF_OP_CMD_STOP:
-                cmd_str = "stop";
-                break;
+            cmd_str = "stop";
+            break;
         case GF_OP_CMD_STATUS:
-                cmd_str = "status";
-                break;
+            cmd_str = "status";
+            break;
         default:
-                break;
-        }
+            break;
+    }
+
+    ret = rsp.op_ret;
+    if (rsp.op_ret == -1) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg),
+                     "volume remove-brick %s: "
+                     "failed: %s",
+                     cmd_str, rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg),
+                     "volume remove-brick %s: "
+                     "failed",
+                     cmd_str);
 
-        ret = rsp.op_ret;
-        if (rsp.op_ret == -1) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume remove-brick %s: "
-                                  "failed: %s", cmd_str, rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume remove-brick %s: "
-                                  "failed", cmd_str);
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
+        cli_err("%s", msg);
+        goto out;
+    }
 
-                cli_err ("%s", msg);
-                goto out;
-        }
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        strncpy (msg, "failed to unserialize req-buffer to "
-                                 "dictionary", sizeof (msg));
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+        if (ret < 0) {
+            strncpy(msg,
+                    "failed to unserialize req-buffer to "
+                    "dictionary",
+                    sizeof(msg));
 
-                        if (global_state->mode & GLUSTER_MODE_XML) {
-                                rsp.op_ret = -1;
-                                goto xml_output;
-                        }
+            if (global_state->mode & GLUSTER_MODE_XML) {
+                rsp.op_ret = -1;
+                goto xml_output;
+            }
 
-                        gf_log ("cli", GF_LOG_ERROR, "%s", msg);
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR, "%s", msg);
+            goto out;
         }
+    }
 
 xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr,
-                                                               "volRemoveBrick");
-                } else {
-                        ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                               _gf_true, dict,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               msg,
-                                                               "volRemoveBrick");
-                }
-                goto out;
-        }
-
-        ret = gf_cli_print_rebalance_status (dict, GF_TASK_TYPE_REMOVE_BRICK,
-                                             _gf_false);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to print remove-brick "
-                        "rebalance status");
-                goto out;
-        }
-
-        if ((cmd == GF_OP_CMD_STOP) && (rsp.op_ret == 0)) {
-                cli_out ("'remove-brick' process may be in the middle of a "
-                         "file migration.\nThe process will be fully stopped "
-                         "once the migration of the file is complete.\nPlease "
-                         "check remove-brick process for completion before "
-                         "doing any further brick related tasks on the "
-                         "volume.");
-        }
-
-out:
-        free (rsp.dict.dict_val); //malloced by xdr
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (strcmp(rsp.op_errstr, "")) {
+            ret = cli_xml_output_vol_remove_brick_detach_tier(
+                _gf_true, dict, rsp.op_ret, rsp.op_errno, rsp.op_errstr,
+                "volRemoveBrick");
+        } else {
+            ret = cli_xml_output_vol_remove_brick_detach_tier(
+                _gf_true, dict, rsp.op_ret, rsp.op_errno, msg,
+                "volRemoveBrick");
+        }
+        goto out;
+    }
+
+    ret = gf_cli_print_rebalance_status(dict, GF_TASK_TYPE_REMOVE_BRICK,
+                                        _gf_false);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to print remove-brick "
+               "rebalance status");
+        goto out;
+    }
+
+    if ((cmd == GF_OP_CMD_STOP) && (rsp.op_ret == 0)) {
+        cli_out(
+            "'remove-brick' process may be in the middle of a "
+            "file migration.\nThe process will be fully stopped "
+            "once the migration of the file is complete.\nPlease "
+            "check remove-brick process for completion before "
+            "doing any further brick related tasks on the "
+            "volume.");
+    }
+
+out:
+    free(rsp.dict.dict_val);  // malloced by xdr
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-
 int
-gf_cli_remove_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                      rsp   = {0,};
-        int                             ret   = -1;
-        char                            msg[1024] = {0,};
-        gf1_op_commands                 cmd = GF_OP_CMD_NONE;
-        char                           *cmd_str = "unknown";
-        cli_local_t                    *local = NULL;
-        call_frame_t                   *frame = NULL;
-        char                           *task_id_str = NULL;
-        dict_t                         *rsp_dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "command", (int32_t *)&cmd);
+gf_cli_remove_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+    gf1_op_commands cmd = GF_OP_CMD_NONE;
+    char *cmd_str = "unknown";
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *task_id_str = NULL;
+    dict_t *rsp_dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "command", (int32_t *)&cmd);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "failed to get command");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        rsp_dict = dict_new();
+        if (!rsp_dict) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret) {
-                 gf_log ("", GF_LOG_ERROR, "failed to get command");
-                 goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                rsp_dict = dict_new ();
-                if (!rsp_dict) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
-                                        &rsp_dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to unserialize rsp_dict");
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR, "Failed to unserialize rsp_dict");
+            goto out;
         }
+    }
 
-        switch (cmd) {
+    switch (cmd) {
         case GF_OP_CMD_DETACH_START:
         case GF_OP_CMD_START:
-                cmd_str = "start";
-
-                ret = dict_get_str (rsp_dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "remove-brick-id is not present in dict");
-                }
-                break;
+            cmd_str = "start";
+
+            ret = dict_get_str(rsp_dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "remove-brick-id is not present in dict");
+            }
+            break;
         case GF_OP_CMD_COMMIT:
-                cmd_str = "commit";
-                break;
+            cmd_str = "commit";
+            break;
         case GF_OP_CMD_COMMIT_FORCE:
-                cmd_str = "commit force";
-                break;
+            cmd_str = "commit force";
+            break;
         default:
-                cmd_str = "unknown";
-                break;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to remove brick");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Remove Brick %s %s", cmd_str,
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_remove_brick_detach_tier (
-                                                       _gf_false, rsp_dict,
-                                                       rsp.op_ret, rsp.op_errno,
-                                                       msg, "volRemoveBrick");
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+            cmd_str = "unknown";
+            break;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to remove brick");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Remove Brick %s %s", cmd_str,
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_remove_brick_detach_tier(
+            _gf_false, rsp_dict, rsp.op_ret, rsp.op_errno, msg,
+            "volRemoveBrick");
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret) {
-                cli_err ("volume remove-brick %s: failed: %s", cmd_str,
-                         msg);
-        } else {
-                cli_out ("volume remove-brick %s: success", cmd_str);
-                if (GF_OP_CMD_START == cmd && task_id_str != NULL)
-                        cli_out ("ID: %s", task_id_str);
-                if (GF_OP_CMD_COMMIT == cmd)
-                        cli_out ("Check the removed bricks to ensure all files "
-                                 "are migrated.\nIf files with data are "
-                                 "found on the brick path, copy them via a "
-                                 "gluster mount point before re-purposing the "
-                                 "removed brick. ");
-        }
+    if (rsp.op_ret) {
+        cli_err("volume remove-brick %s: failed: %s", cmd_str, msg);
+    } else {
+        cli_out("volume remove-brick %s: success", cmd_str);
+        if (GF_OP_CMD_START == cmd && task_id_str != NULL)
+            cli_out("ID: %s", task_id_str);
+        if (GF_OP_CMD_COMMIT == cmd)
+            cli_out(
+                "Check the removed bricks to ensure all files "
+                "are migrated.\nIf files with data are "
+                "found on the brick path, copy them via a "
+                "gluster mount point before re-purposing the "
+                "removed brick. ");
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_reset_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
-{
-        gf_cli_rsp                       rsp              = {0,};
-        int                              ret              = -1;
-        cli_local_t                     *local            = NULL;
-        call_frame_t                    *frame            = NULL;
-        char                            *rb_operation_str = NULL;
-        dict_t                          *rsp_dict         = NULL;
-        char                             msg[1024]        = {0,};
-        char                            *reset_op         = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+gf_cli_reset_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *rb_operation_str = NULL;
+    dict_t *rsp_dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *reset_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_str(local->dict, "operation", &reset_op);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict_get on operation failed");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        rsp_dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_str (local->dict, "operation", &reset_op);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                rsp_dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &rsp_dict);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                                "unserialize rsp buffer to dictionary");
-                        goto out;
-                }
-        }
-
-        if (strcmp (reset_op, "GF_RESET_OP_START") &&
-            strcmp (reset_op, "GF_RESET_OP_COMMIT") &&
-            strcmp (reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
-                rb_operation_str = gf_strdup ("Unknown operation");
-                ret = -1;
-                goto out;
-        }
-
-        if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
-                rb_operation_str = gf_strdup (rsp.op_errstr);
-        } else {
-                if (!strcmp (reset_op, "GF_RESET_OP_START")) {
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "start "
-                                                              "operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "start "
-                                                              "operation "
-                                                              "successful");
-                } else if (!strcmp (reset_op, "GF_RESET_OP_COMMIT")) {
-
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "operation "
-                                                              "successful");
-                } else if (!strcmp (reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
-
-                        if (rsp.op_ret)
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "force operation "
-                                                              "failed");
-                        else
-                                rb_operation_str = gf_strdup ("reset-brick "
-                                                              "commit "
-                                                              "force operation "
-                                                              "successful");
-                }
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to reset brick");
-        snprintf (msg, sizeof (msg), "%s",
-                  rb_operation_str ? rb_operation_str : "Unknown operation");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_replace_brick (rsp_dict,
-                                                        rsp.op_ret,
-                                                        rsp.op_errno, msg);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+            gf_log(frame->this->name, GF_LOG_ERROR,
+                   "failed to "
+                   "unserialize rsp buffer to dictionary");
+            goto out;
+        }
+    }
+
+    if (strcmp(reset_op, "GF_RESET_OP_START") &&
+        strcmp(reset_op, "GF_RESET_OP_COMMIT") &&
+        strcmp(reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
+        rb_operation_str = gf_strdup("Unknown operation");
+        ret = -1;
+        goto out;
+    }
+
+    if (rsp.op_ret && (strcmp(rsp.op_errstr, ""))) {
+        rb_operation_str = gf_strdup(rsp.op_errstr);
+    } else {
+        if (!strcmp(reset_op, "GF_RESET_OP_START")) {
+            if (rsp.op_ret)
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "start "
+                    "operation "
+                    "failed");
+            else
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "start "
+                    "operation "
+                    "successful");
+        } else if (!strcmp(reset_op, "GF_RESET_OP_COMMIT")) {
+            if (rsp.op_ret)
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "commit "
+                    "operation "
+                    "failed");
+            else
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "commit "
+                    "operation "
+                    "successful");
+        } else if (!strcmp(reset_op, "GF_RESET_OP_COMMIT_FORCE")) {
+            if (rsp.op_ret)
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "commit "
+                    "force operation "
+                    "failed");
+            else
+                rb_operation_str = gf_strdup(
+                    "reset-brick "
+                    "commit "
+                    "force operation "
+                    "successful");
+        }
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to reset brick");
+    snprintf(msg, sizeof(msg), "%s",
+             rb_operation_str ? rb_operation_str : "Unknown operation");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_replace_brick(rsp_dict, rsp.op_ret,
+                                               rsp.op_errno, msg);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume reset-brick: failed: %s", msg);
-        else
-                cli_out ("volume reset-brick: success: %s", msg);
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume reset-brick: failed: %s", msg);
+    else
+        cli_out("volume reset-brick: success: %s", msg);
+    ret = rsp.op_ret;
 
 out:
-        if (frame)
-                frame->local = NULL;
+    if (frame)
+        frame->local = NULL;
 
-        if (local)
-                cli_local_wipe (local);
+    if (local)
+        cli_local_wipe(local);
 
-        if (rb_operation_str)
-                GF_FREE (rb_operation_str);
+    if (rb_operation_str)
+        GF_FREE(rb_operation_str);
 
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
 int
-gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp                       rsp              = {0,};
-        int                              ret              = -1;
-        cli_local_t                     *local            = NULL;
-        call_frame_t                    *frame            = NULL;
-        char                            *rb_operation_str = NULL;
-        dict_t                          *rsp_dict         = NULL;
-        char                             msg[1024]        = {0,};
-        char                            *replace_op       = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+gf_cli_replace_brick_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    char *rb_operation_str = NULL;
+    dict_t *rsp_dict = NULL;
+    char msg[1024] = {
+        0,
+    };
+    char *replace_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_str(local->dict, "operation", &replace_op);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "dict_get on operation failed");
+        goto out;
+    }
+
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        rsp_dict = dict_new();
+
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &rsp_dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_str (local->dict, "operation", &replace_op);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                rsp_dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &rsp_dict);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                                "unserialize rsp buffer to dictionary");
-                        goto out;
-                }
-        }
-
-        if (!strcmp (replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
-
-                if (rsp.op_ret || ret)
-                        rb_operation_str = gf_strdup ("replace-brick commit "
-                                                      "force operation failed");
-                else
-                        rb_operation_str = gf_strdup ("replace-brick commit "
-                                                      "force operation "
-                                                      "successful");
-        } else {
-                gf_log (frame->this->name, GF_LOG_DEBUG, "Unknown operation");
-        }
-
-        if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
-                rb_operation_str = gf_strdup (rsp.op_errstr);
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to replace brick");
-        snprintf (msg, sizeof (msg), "%s",
-                  rb_operation_str ? rb_operation_str : "Unknown operation");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_replace_brick (rsp_dict,
-                                                        rsp.op_ret,
-                                                        rsp.op_errno, msg);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret)
-                cli_err ("volume replace-brick: failed: %s", msg);
+            gf_log(frame->this->name, GF_LOG_ERROR,
+                   "failed to "
+                   "unserialize rsp buffer to dictionary");
+            goto out;
+        }
+    }
+
+    if (!strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
+        if (rsp.op_ret || ret)
+            rb_operation_str = gf_strdup(
+                "replace-brick commit "
+                "force operation failed");
         else
-                cli_out ("volume replace-brick: success: %s", msg);
-        ret = rsp.op_ret;
+            rb_operation_str = gf_strdup(
+                "replace-brick commit "
+                "force operation "
+                "successful");
+    } else {
+        gf_log(frame->this->name, GF_LOG_DEBUG, "Unknown operation");
+    }
+
+    if (rsp.op_ret && (strcmp(rsp.op_errstr, ""))) {
+        rb_operation_str = gf_strdup(rsp.op_errstr);
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to replace brick");
+    snprintf(msg, sizeof(msg), "%s",
+             rb_operation_str ? rb_operation_str : "Unknown operation");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_replace_brick(rsp_dict, rsp.op_ret,
+                                               rsp.op_errno, msg);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
+
+    if (rsp.op_ret)
+        cli_err("volume replace-brick: failed: %s", msg);
+    else
+        cli_out("volume replace-brick: success: %s", msg);
+    ret = rsp.op_ret;
 
 out:
-        if (frame)
-                frame->local = NULL;
+    if (frame)
+        frame->local = NULL;
 
-        if (local)
-                cli_local_wipe (local);
+    if (local)
+        cli_local_wipe(local);
 
-        if (rb_operation_str)
-                GF_FREE (rb_operation_str);
+    if (rb_operation_str)
+        GF_FREE(rb_operation_str);
 
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-gf_cli_log_rotate_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
-{
-        gf_cli_rsp             rsp   = {0,};
-        int                    ret   = -1;
-        char                   msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to log rotate");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "log rotate %s",
-                          (rsp.op_ret) ? "unsuccessful": "successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volLogRotate", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_log_rotate_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to log rotate");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "log rotate %s",
+                 (rsp.op_ret) ? "unsuccessful" : "successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volLogRotate", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume log-rotate: failed: %s", msg);
-        else
-                cli_out ("volume log-rotate: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume log-rotate: failed: %s", msg);
+    else
+        cli_out("volume log-rotate: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_sync_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                           int count, void *myframe)
-{
-        gf_cli_rsp                     rsp   = {0,};
-        int                            ret   = -1;
-        char                           msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to sync");
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
-                snprintf (msg, sizeof (msg), "volume sync: failed: %s",
-                          rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "volume sync: %s",
-                          (rsp.op_ret) ? "failed": "success");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volSync", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_sync_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to sync");
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, ""))
+        snprintf(msg, sizeof(msg), "volume sync: failed: %s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "volume sync: %s",
+                 (rsp.op_ret) ? "failed" : "success");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volSync", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("%s", msg);
-        else
-                cli_out ("%s", msg);
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("%s", msg);
+    else
+        cli_out("%s", msg);
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 static int
-print_quota_list_usage_output (cli_local_t *local, char *path, int64_t avail,
-                               char *sl_str, quota_limits_t *limits,
-                               quota_meta_t *used_space, gf_boolean_t sl,
-                               gf_boolean_t hl, double sl_num,
-                               gf_boolean_t limit_set)
-{
-        int32_t         ret          = -1;
-        char           *used_str     = NULL;
-        char           *avail_str    = NULL;
-        char           *hl_str       = NULL;
-        char           *sl_val       = NULL;
-
-        used_str = gf_uint64_2human_readable (used_space->size);
-
-        if (limit_set) {
-                hl_str = gf_uint64_2human_readable (limits->hl);
-                avail_str = gf_uint64_2human_readable (avail);
-
-                sl_val = gf_uint64_2human_readable (sl_num);
-        }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_quota_xml_output (local, path, limits->hl,
-                                            sl_str, sl_num, used_space->size,
-                                            avail, sl ? "Yes" : "No",
-                                            hl ? "Yes" : "No", limit_set);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "output in xml format for quota "
-                                "list command");
-                }
-                goto out;
-        }
-
-        if (limit_set) {
-                if (!used_str) {
-                        cli_out ("%-40s %7s %7s(%s) %8"PRIu64 "%9"PRIu64""
-                                 "%15s %18s", path, hl_str, sl_str, sl_val,
-                                 used_space->size, avail,
-                                 sl ? "Yes" : "No", hl ? "Yes" : "No");
-                } else {
-                        cli_out ("%-40s %7s %7s(%s) %8s %7s %15s %20s",
-                                 path, hl_str, sl_str, sl_val, used_str,
-                                 avail_str, sl ? "Yes" : "No",
-                                 hl ? "Yes" : "No");
-                }
+print_quota_list_usage_output(cli_local_t *local, char *path, int64_t avail,
+                              char *sl_str, quota_limits_t *limits,
+                              quota_meta_t *used_space, gf_boolean_t sl,
+                              gf_boolean_t hl, double sl_num,
+                              gf_boolean_t limit_set)
+{
+    int32_t ret = -1;
+    char *used_str = NULL;
+    char *avail_str = NULL;
+    char *hl_str = NULL;
+    char *sl_val = NULL;
+
+    used_str = gf_uint64_2human_readable(used_space->size);
+
+    if (limit_set) {
+        hl_str = gf_uint64_2human_readable(limits->hl);
+        avail_str = gf_uint64_2human_readable(avail);
+
+        sl_val = gf_uint64_2human_readable(sl_num);
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_quota_xml_output(local, path, limits->hl, sl_str, sl_num,
+                                   used_space->size, avail, sl ? "Yes" : "No",
+                                   hl ? "Yes" : "No", limit_set);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to "
+                   "output in xml format for quota "
+                   "list command");
+        }
+        goto out;
+    }
+
+    if (limit_set) {
+        if (!used_str) {
+            cli_out("%-40s %7s %7s(%s) %8" PRIu64 "%9" PRIu64
+                    ""
+                    "%15s %18s",
+                    path, hl_str, sl_str, sl_val, used_space->size, avail,
+                    sl ? "Yes" : "No", hl ? "Yes" : "No");
         } else {
-                        cli_out ("%-36s %10s %10s %14s %9s %15s %18s",
-                                 path, "N/A", "N/A", used_str, "N/A",
-                                 "N/A", "N/A");
+            cli_out("%-40s %7s %7s(%s) %8s %7s %15s %20s", path, hl_str, sl_str,
+                    sl_val, used_str, avail_str, sl ? "Yes" : "No",
+                    hl ? "Yes" : "No");
         }
+    } else {
+        cli_out("%-36s %10s %10s %14s %9s %15s %18s", path, "N/A", "N/A",
+                used_str, "N/A", "N/A", "N/A");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (hl_str);
-        GF_FREE (used_str);
-        GF_FREE (avail_str);
-        GF_FREE (sl_val);
+    GF_FREE(hl_str);
+    GF_FREE(used_str);
+    GF_FREE(avail_str);
+    GF_FREE(sl_val);
 
-        return ret;
+    return ret;
 }
 
 static int
-print_quota_list_object_output (cli_local_t *local, char *path, int64_t avail,
+print_quota_list_object_output(cli_local_t *local, char *path, int64_t avail,
                                char *sl_str, quota_limits_t *limits,
                                quota_meta_t *used_space, gf_boolean_t sl,
                                gf_boolean_t hl, double sl_num,
                                gf_boolean_t limit_set)
 {
-        int32_t         ret       = -1;
-        int64_t         sl_val    = sl_num;
+    int32_t ret = -1;
+    int64_t sl_val = sl_num;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_quota_object_xml_output (local, path, sl_str, sl_val,
-                                                   limits, used_space, avail,
-                                                   sl ? "Yes" : "No",
-                                                   hl ? "Yes" : "No",
-                                                   limit_set);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "output in xml format for quota "
-                                "list command");
-                }
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_quota_object_xml_output(local, path, sl_str, sl_val, limits,
+                                          used_space, avail, sl ? "Yes" : "No",
+                                          hl ? "Yes" : "No", limit_set);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to "
+                   "output in xml format for quota "
+                   "list command");
         }
+        goto out;
+    }
 
-        if (limit_set) {
-                cli_out ("%-40s %9"PRIu64" %9s(%"PRId64") %10"PRIu64""
-                         "%10"PRIu64" %11"PRIu64" %15s %20s",
-                         path, limits->hl, sl_str, sl_val,
-                         used_space->file_count, used_space->dir_count,
-                         avail, sl ? "Yes" : "No", hl ? "Yes" : "No");
-        } else {
-                cli_out ("%-40s %9s %9s %10"PRIu64" %10"PRIu64" %11s %15s %20s",
-                         path, "N/A", "N/A", used_space->file_count,
-                         used_space->dir_count, "N/A", "N/A", "N/A");
-        }
-        ret = 0;
+    if (limit_set) {
+        cli_out("%-40s %9" PRIu64 " %9s(%" PRId64 ") %10" PRIu64
+                ""
+                "%10" PRIu64 " %11" PRIu64 " %15s %20s",
+                path, limits->hl, sl_str, sl_val, used_space->file_count,
+                used_space->dir_count, avail, sl ? "Yes" : "No",
+                hl ? "Yes" : "No");
+    } else {
+        cli_out("%-40s %9s %9s %10" PRIu64 " %10" PRIu64 " %11s %15s %20s",
+                path, "N/A", "N/A", used_space->file_count,
+                used_space->dir_count, "N/A", "N/A", "N/A");
+    }
+    ret = 0;
 
 out:
 
-        return ret;
+    return ret;
 }
 
 static int
-print_quota_list_output (cli_local_t *local, char *path, char *default_sl,
-                         quota_limits_t *limits, quota_meta_t *used_space,
-                         int type, gf_boolean_t limit_set)
-{
-        int64_t         avail            = 0;
-        char            percent_str[20]  = {0};
-        char           *sl_final         = NULL;
-        int             ret              = -1;
-        double          sl_num           = 0;
-        gf_boolean_t    sl               = _gf_false;
-        gf_boolean_t    hl               = _gf_false;
-        int64_t         used_size        = 0;
-
-        GF_ASSERT (local);
-        GF_ASSERT (path);
-
-        if (limit_set) {
-                if (limits->sl < 0) {
-                        ret = gf_string2percent (default_sl, &sl_num);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "could not convert default soft limit"
-                                        " to percent");
-                                goto out;
-                        }
-                        sl_num = (sl_num * limits->hl) / 100;
-                        sl_final = default_sl;
-                } else {
-                        sl_num = (limits->sl * limits->hl) / 100;
-                        snprintf (percent_str, sizeof (percent_str), "%"PRIu64"%%",
-                                        limits->sl);
-                        sl_final = percent_str;
-                }
-                if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                        used_size = used_space->size;
-                else
-                        used_size = used_space->file_count + used_space->dir_count;
-
-                if (limits->hl > used_size) {
-                        avail = limits->hl - used_size;
-                        hl = _gf_false;
-                        if (used_size > sl_num)
-                                sl = _gf_true;
-                        else
-                                sl = _gf_false;
-                } else {
-                        avail = 0;
-                        hl = sl = _gf_true;
-                }
+print_quota_list_output(cli_local_t *local, char *path, char *default_sl,
+                        quota_limits_t *limits, quota_meta_t *used_space,
+                        int type, gf_boolean_t limit_set)
+{
+    int64_t avail = 0;
+    char percent_str[20] = {0};
+    char *sl_final = NULL;
+    int ret = -1;
+    double sl_num = 0;
+    gf_boolean_t sl = _gf_false;
+    gf_boolean_t hl = _gf_false;
+    int64_t used_size = 0;
+
+    GF_ASSERT(local);
+    GF_ASSERT(path);
+
+    if (limit_set) {
+        if (limits->sl < 0) {
+            ret = gf_string2percent(default_sl, &sl_num);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "could not convert default soft limit"
+                       " to percent");
+                goto out;
+            }
+            sl_num = (sl_num * limits->hl) / 100;
+            sl_final = default_sl;
+        } else {
+            sl_num = (limits->sl * limits->hl) / 100;
+            snprintf(percent_str, sizeof(percent_str), "%" PRIu64 "%%",
+                     limits->sl);
+            sl_final = percent_str;
         }
-
         if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                ret = print_quota_list_usage_output (local, path, avail,
-                                                     sl_final, limits,
-                                                     used_space, sl, hl,
-                                                     sl_num, limit_set);
+            used_size = used_space->size;
         else
-                ret = print_quota_list_object_output (local, path, avail,
-                                                      sl_final, limits,
-                                                      used_space, sl, hl,
-                                                      sl_num, limit_set);
+            used_size = used_space->file_count + used_space->dir_count;
+
+        if (limits->hl > used_size) {
+            avail = limits->hl - used_size;
+            hl = _gf_false;
+            if (used_size > sl_num)
+                sl = _gf_true;
+            else
+                sl = _gf_false;
+        } else {
+            avail = 0;
+            hl = sl = _gf_true;
+        }
+    }
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        ret = print_quota_list_usage_output(local, path, avail, sl_final,
+                                            limits, used_space, sl, hl, sl_num,
+                                            limit_set);
+    else
+        ret = print_quota_list_object_output(local, path, avail, sl_final,
+                                             limits, used_space, sl, hl, sl_num,
+                                             limit_set);
 out:
-        return ret;
+    return ret;
 }
 
 static int
-print_quota_list_from_mountdir (cli_local_t *local, char *mountdir,
-                                char *default_sl, char *path, int type)
-{
-        int             ret              = -1;
-        ssize_t         xattr_size       = 0;
-        quota_limits_t  limits           = {0,};
-        quota_meta_t    used_space       = {0,};
-        char           *key              = NULL;
-        gf_boolean_t    limit_set        = _gf_true;
-
-        GF_ASSERT (local);
-        GF_ASSERT (mountdir);
-        GF_ASSERT (path);
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                key = QUOTA_LIMIT_KEY;
-        else
-                key = QUOTA_LIMIT_OBJECTS_KEY;
-
-
-        ret = sys_lgetxattr (mountdir, key, (void *)&limits, sizeof (limits));
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get the xattr %s "
-                        "on %s. Reason : %s", key, mountdir, strerror (errno));
-
-                switch (errno) {
+print_quota_list_from_mountdir(cli_local_t *local, char *mountdir,
+                               char *default_sl, char *path, int type)
+{
+    int ret = -1;
+    ssize_t xattr_size = 0;
+    quota_limits_t limits = {
+        0,
+    };
+    quota_meta_t used_space = {
+        0,
+    };
+    char *key = NULL;
+    gf_boolean_t limit_set = _gf_true;
+
+    GF_ASSERT(local);
+    GF_ASSERT(mountdir);
+    GF_ASSERT(path);
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        key = QUOTA_LIMIT_KEY;
+    else
+        key = QUOTA_LIMIT_OBJECTS_KEY;
+
+    ret = sys_lgetxattr(mountdir, key, (void *)&limits, sizeof(limits));
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get the xattr %s "
+               "on %s. Reason : %s",
+               key, mountdir, strerror(errno));
+
+        switch (errno) {
 #if defined(ENODATA)
-                case ENODATA:
+            case ENODATA:
 #endif
 #if defined(ENOATTR) && (ENOATTR != ENODATA)
-                case ENOATTR:
+            case ENOATTR:
 #endif
-                        /* If it's an ENOATTR, quota/inode-quota is
-                         * configured(limit is set at least for one directory).
-                         * The user is trying to issue 'list/list-objects'
-                         * command for a directory on which quota limit is
-                         * not set and we are showing the used-space in case
-                         * of list-usage and showing (dir_count, file_count)
-                         * in case of list-objects. Other labels are
-                         * shown "N/A".
-                         */
-
-                        limit_set = _gf_false;
-                        goto enoattr;
-                        break;
-
-                default:
-                        cli_err ("%-40s %s", path, strerror (errno));
-                        break;
-                }
+                /* If it's an ENOATTR, quota/inode-quota is
+                 * configured(limit is set at least for one directory).
+                 * The user is trying to issue 'list/list-objects'
+                 * command for a directory on which quota limit is
+                 * not set and we are showing the used-space in case
+                 * of list-usage and showing (dir_count, file_count)
+                 * in case of list-objects. Other labels are
+                 * shown "N/A".
+                 */
 
-                goto out;
+                limit_set = _gf_false;
+                goto enoattr;
+                break;
+
+            default:
+                cli_err("%-40s %s", path, strerror(errno));
+                break;
         }
 
-        limits.hl = ntoh64 (limits.hl);
-        limits.sl = ntoh64 (limits.sl);
+        goto out;
+    }
+
+    limits.hl = ntoh64(limits.hl);
+    limits.sl = ntoh64(limits.sl);
 
 enoattr:
-        xattr_size = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY, NULL, 0);
-        if (xattr_size < (sizeof (int64_t) * 2) &&
-            type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS) {
-                ret = -1;
+    xattr_size = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, NULL, 0);
+    if (xattr_size < (sizeof(int64_t) * 2) &&
+        type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS) {
+        ret = -1;
 
-                /* This can happen when glusterfs is upgraded from 3.6 to 3.7
-                 * and the xattr healing is not completed.
-                 */
-        } else if (xattr_size > (sizeof (int64_t) * 2)) {
-                ret = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY,
-                                     &used_space, sizeof (used_space));
-        } else if (xattr_size > 0) {
-                /* This is for compatibility.
-                 * Older version had only file usage
-                 */
-                ret = sys_lgetxattr (mountdir, QUOTA_SIZE_KEY,
-                             &(used_space.size), sizeof (used_space.size));
-                used_space.file_count = 0;
-                used_space.dir_count = 0;
-        } else {
-                ret = -1;
-        }
+        /* This can happen when glusterfs is upgraded from 3.6 to 3.7
+         * and the xattr healing is not completed.
+         */
+    } else if (xattr_size > (sizeof(int64_t) * 2)) {
+        ret = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, &used_space,
+                            sizeof(used_space));
+    } else if (xattr_size > 0) {
+        /* This is for compatibility.
+         * Older version had only file usage
+         */
+        ret = sys_lgetxattr(mountdir, QUOTA_SIZE_KEY, &(used_space.size),
+                            sizeof(used_space.size));
+        used_space.file_count = 0;
+        used_space.dir_count = 0;
+    } else {
+        ret = -1;
+    }
 
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota size "
-                        "on path %s: %s", mountdir, strerror (errno));
-                print_quota_list_empty (path, type);
-                goto out;
-        }
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get quota size "
+               "on path %s: %s",
+               mountdir, strerror(errno));
+        print_quota_list_empty(path, type);
+        goto out;
+    }
 
-        used_space.size = ntoh64 (used_space.size);
-        used_space.file_count = ntoh64 (used_space.file_count);
-        used_space.dir_count = ntoh64 (used_space.dir_count);
+    used_space.size = ntoh64(used_space.size);
+    used_space.file_count = ntoh64(used_space.file_count);
+    used_space.dir_count = ntoh64(used_space.dir_count);
 
-        ret = print_quota_list_output (local, path, default_sl, &limits,
-                                       &used_space, type, limit_set);
+    ret = print_quota_list_output(local, path, default_sl, &limits, &used_space,
+                                  type, limit_set);
 out:
-        return ret;
+    return ret;
 }
 
 int
-gluster_remove_auxiliary_mount (char *volname)
+gluster_remove_auxiliary_mount(char *volname)
 {
-        int       ret                = -1;
-        char      mountdir[PATH_MAX] = {0,};
-        xlator_t  *this               = NULL;
+    int ret = -1;
+    char mountdir[PATH_MAX] = {
+        0,
+    };
+    xlator_t *this = NULL;
 
-        this = THIS;
-        GF_ASSERT (this);
+    this = THIS;
+    GF_ASSERT(this);
 
-        GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH (mountdir, volname, "/");
-        ret = gf_umount_lazy (this->name, mountdir, 1);
-        if (ret) {
-                gf_log("cli", GF_LOG_ERROR, "umount on %s failed, "
-                        "reason : %s", mountdir, strerror (errno));
-        }
+    GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(mountdir, volname, "/");
+    ret = gf_umount_lazy(this->name, mountdir, 1);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "umount on %s failed, "
+               "reason : %s",
+               mountdir, strerror(errno));
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_print_limit_list_from_dict (cli_local_t *local, char *volname,
-                                   dict_t *dict, char *default_sl, int count,
-                                   int op_ret, int op_errno, char *op_errstr)
-{
-        int             ret                     = -1;
-        int             i                       = 0;
-        char            key[1024]               = {0,};
-        char            mountdir[PATH_MAX]      = {0,};
-        char            *path                   = NULL;
-        int             type                    = -1;
-
-        if (!dict|| count <= 0)
-                goto out;
-
-        ret = dict_get_int32 (dict, "type", &type);
+gf_cli_print_limit_list_from_dict(cli_local_t *local, char *volname,
+                                  dict_t *dict, char *default_sl, int count,
+                                  int op_ret, int op_errno, char *op_errstr)
+{
+    int ret = -1;
+    int i = 0;
+    char key[1024] = {
+        0,
+    };
+    char mountdir[PATH_MAX] = {
+        0,
+    };
+    char *path = NULL;
+    int type = -1;
+
+    if (!dict || count <= 0)
+        goto out;
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get quota type");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_quota_limit_list_begin(local, op_ret, op_errno,
+                                                        op_errstr);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get quota type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Error outputting xml begin");
+            goto out;
         }
+    } else {
+        print_quota_list_header(type);
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_quota_limit_list_begin
-                                (local, op_ret, op_errno, op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting xml begin");
-                        goto out;
-                }
-        } else {
-                print_quota_list_header (type);
-        }
-
-        while (count--) {
-                snprintf (key, sizeof (key), "path%d", i++);
-
-                ret = dict_get_str (dict, key, &path);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_DEBUG, "Path not present in limit"
-                                " list");
-                        continue;
-                }
+    while (count--) {
+        snprintf(key, sizeof(key), "path%d", i++);
 
-                ret = gf_canonicalize_path (path);
-                if (ret)
-                        goto out;
-                GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH (mountdir, volname, path);
-                ret = print_quota_list_from_mountdir (local, mountdir,
-                                                      default_sl, path, type);
+        ret = dict_get_str(dict, key, &path);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_DEBUG,
+                   "Path not present in limit"
+                   " list");
+            continue;
         }
 
+        ret = gf_canonicalize_path(path);
+        if (ret)
+            goto out;
+        GLUSTERD_GET_QUOTA_LIST_MOUNT_PATH(mountdir, volname, path);
+        ret = print_quota_list_from_mountdir(local, mountdir, default_sl, path,
+                                             type);
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
 int
-print_quota_list_from_quotad (call_frame_t *frame, dict_t *rsp_dict)
-{
-        char             *path          = NULL;
-        char             *default_sl    = NULL;
-        int              ret            = -1;
-        cli_local_t     *local          = NULL;
-        dict_t          *gd_rsp_dict    = NULL;
-        quota_meta_t     used_space     = {0, };
-        quota_limits_t   limits         = {0, };
-        quota_limits_t  *size_limits    = NULL;
-        int32_t          type           = 0;
-        int32_t          success_count  = 0;
-
-        GF_ASSERT (frame);
-
-        local = frame->local;
-        gd_rsp_dict = local->dict;
-
-        ret = dict_get_int32 (rsp_dict, "type", &type);
+print_quota_list_from_quotad(call_frame_t *frame, dict_t *rsp_dict)
+{
+    char *path = NULL;
+    char *default_sl = NULL;
+    int ret = -1;
+    cli_local_t *local = NULL;
+    dict_t *gd_rsp_dict = NULL;
+    quota_meta_t used_space = {
+        0,
+    };
+    quota_limits_t limits = {
+        0,
+    };
+    quota_limits_t *size_limits = NULL;
+    int32_t type = 0;
+    int32_t success_count = 0;
+
+    GF_ASSERT(frame);
+
+    local = frame->local;
+    gd_rsp_dict = local->dict;
+
+    ret = dict_get_int32(rsp_dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get type");
+        goto out;
+    }
+
+    ret = dict_get_str(rsp_dict, GET_ANCESTRY_PATH_KEY, &path);
+    if (ret) {
+        gf_log("cli", GF_LOG_WARNING,
+               "path key is not present "
+               "in dict");
+        goto out;
+    }
+
+    ret = dict_get_str(gd_rsp_dict, "default-soft-limit", &default_sl);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to "
+               "get default soft limit");
+        goto out;
+    }
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST) {
+        ret = dict_get_bin(rsp_dict, QUOTA_LIMIT_KEY, (void **)&size_limits);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get type");
-                goto out;
-        }
-
-        ret = dict_get_str (rsp_dict, GET_ANCESTRY_PATH_KEY, &path);
-        if (ret) {
-                gf_log ("cli", GF_LOG_WARNING, "path key is not present "
-                        "in dict");
-                goto out;
+            gf_log("cli", GF_LOG_WARNING, "limit key not present in dict on %s",
+                   path);
+            goto out;
         }
-
-        ret = dict_get_str (gd_rsp_dict, "default-soft-limit", &default_sl);
+    } else {
+        ret = dict_get_bin(rsp_dict, QUOTA_LIMIT_OBJECTS_KEY,
+                           (void **)&size_limits);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
-                        "get default soft limit");
-                goto out;
-        }
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST) {
-                ret = dict_get_bin (rsp_dict, QUOTA_LIMIT_KEY,
-                                    (void **)&size_limits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "limit key not present in dict on %s",
-                                path);
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_WARNING,
+                   "object limit key not present in dict on %s", path);
+            goto out;
+        }
+    }
+
+    limits.hl = ntoh64(size_limits->hl);
+    limits.sl = ntoh64(size_limits->sl);
+
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        ret = quota_dict_get_meta(rsp_dict, QUOTA_SIZE_KEY, &used_space);
+    else
+        ret = quota_dict_get_inode_meta(rsp_dict, QUOTA_SIZE_KEY, &used_space);
+
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_WARNING, "size key not present in dict");
+        print_quota_list_empty(path, type);
+        goto out;
+    }
+
+    LOCK(&local->lock);
+    {
+        ret = dict_get_int32(gd_rsp_dict, "quota-list-success-count",
+                             &success_count);
+        if (ret)
+            success_count = 0;
+
+        ret = dict_set_int32(gd_rsp_dict, "quota-list-success-count",
+                             success_count + 1);
+    }
+    UNLOCK(&local->lock);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to set "
+               "quota-list-success-count in dict");
+        goto out;
+    }
+
+    if (success_count == 0) {
+        if (!(global_state->mode & GLUSTER_MODE_XML)) {
+            print_quota_list_header(type);
         } else {
-                ret = dict_get_bin (rsp_dict, QUOTA_LIMIT_OBJECTS_KEY,
-                                   (void **)&size_limits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING,
-                                "object limit key not present in dict on %s",
-                                path);
-                        goto out;
-                }
-        }
-
-        limits.hl = ntoh64 (size_limits->hl);
-        limits.sl = ntoh64 (size_limits->sl);
-
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                ret = quota_dict_get_meta (rsp_dict, QUOTA_SIZE_KEY,
-                                           &used_space);
-        else
-                ret = quota_dict_get_inode_meta (rsp_dict, QUOTA_SIZE_KEY,
-                                                 &used_space);
-
-        if (ret < 0) {
-                gf_log ("cli", GF_LOG_WARNING,
-                        "size key not present in dict");
-                print_quota_list_empty (path, type);
-                goto out;
-        }
-
-        LOCK (&local->lock);
-        {
-                ret = dict_get_int32 (gd_rsp_dict, "quota-list-success-count",
-                                      &success_count);
-                if (ret)
-                        success_count = 0;
-
-                ret = dict_set_int32 (gd_rsp_dict,
-                                      "quota-list-success-count",
-                                      success_count + 1);
-        }
-        UNLOCK (&local->lock);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                        "quota-list-success-count in dict");
+            ret = cli_xml_output_vol_quota_limit_list_begin(local, 0, 0, NULL);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Error in "
+                       "printing xml output");
                 goto out;
+            }
         }
+    }
 
-        if (success_count == 0) {
-                if (!(global_state->mode & GLUSTER_MODE_XML)) {
-                        print_quota_list_header (type);
-                } else {
-                        ret = cli_xml_output_vol_quota_limit_list_begin
-                                (local, 0, 0, NULL);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Error in "
-                                        "printing xml output");
-                                goto out;
-                        }
-                }
-        }
-
-        ret = print_quota_list_output (local, path, default_sl, &limits,
-                                       &used_space, type, _gf_true);
+    ret = print_quota_list_output(local, path, default_sl, &limits, &used_space,
+                                  type, _gf_true);
 out:
-        return ret;
+    return ret;
 }
 
-void*
-cli_cmd_broadcast_response_detached (void *opaque)
+void *
+cli_cmd_broadcast_response_detached(void *opaque)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        ret = (intptr_t) opaque;
-        cli_cmd_broadcast_response (ret);
+    ret = (intptr_t)opaque;
+    cli_cmd_broadcast_response(ret);
 
-        return NULL;
+    return NULL;
 }
 
 int32_t
-cli_quota_compare_path (struct list_head *list1,
-                        struct list_head *list2)
+cli_quota_compare_path(struct list_head *list1, struct list_head *list2)
 {
-        struct list_node  *node1  = NULL;
-        struct list_node  *node2  = NULL;
-        dict_t            *dict1  = NULL;
-        dict_t            *dict2  = NULL;
-        char              *path1  = NULL;
-        char              *path2  = NULL;
-        int                ret    = 0;
+    struct list_node *node1 = NULL;
+    struct list_node *node2 = NULL;
+    dict_t *dict1 = NULL;
+    dict_t *dict2 = NULL;
+    char *path1 = NULL;
+    char *path2 = NULL;
+    int ret = 0;
 
-        node1 = list_entry (list1, struct list_node, list);
-        node2 = list_entry (list2, struct list_node, list);
+    node1 = list_entry(list1, struct list_node, list);
+    node2 = list_entry(list2, struct list_node, list);
 
-        dict1 = node1->ptr;
-        dict2 = node2->ptr;
+    dict1 = node1->ptr;
+    dict2 = node2->ptr;
 
-        ret = dict_get_str (dict1, GET_ANCESTRY_PATH_KEY, &path1);
-        if (ret < 0)
-                return 0;
+    ret = dict_get_str(dict1, GET_ANCESTRY_PATH_KEY, &path1);
+    if (ret < 0)
+        return 0;
 
-        ret = dict_get_str (dict2, GET_ANCESTRY_PATH_KEY, &path2);
-        if (ret < 0)
-                return 0;
+    ret = dict_get_str(dict2, GET_ANCESTRY_PATH_KEY, &path2);
+    if (ret < 0)
+        return 0;
 
-        return strcmp (path1, path2);
+    return strcmp(path1, path2);
 }
 
 int
-cli_quotad_getlimit_cbk (struct rpc_req *req, struct iovec *iov,
-                          int count, void *myframe)
+cli_quotad_getlimit_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
 {
     /*TODO: we need to gather the path, hard-limit, soft-limit and used space*/
-        gf_cli_rsp         rsp         = {0,};
-        int                ret         = -1;
-        dict_t            *dict        = NULL;
-        struct list_node  *node        = NULL;
-        struct list_node  *tmpnode     = NULL;
-        call_frame_t      *frame       = NULL;
-        cli_local_t       *local       = NULL;
-        int32_t            list_count  = 0;
-        pthread_t          th_id       = {0, };
-        int32_t            max_count   = 0;
-
-        GF_ASSERT (myframe);
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        LOCK (&local->lock);
-        {
-                ret = dict_get_int32 (local->dict, "quota-list-count",
-                                      &list_count);
-                if (ret)
-                        list_count = 0;
-
-                list_count++;
-                ret = dict_set_int32 (local->dict, "quota-list-count",
-                                      list_count);
-        }
-        UNLOCK (&local->lock);
-
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                        "quota-list-count in dict");
-                goto out;
-        }
-
-        if (-1 == req->rpc_status) {
-                if (list_count == 0)
-                        cli_err ("Connection failed. Please check if quota "
-                                 "daemon is operational.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                ret = -1;
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("quota command failed : %s", rsp.op_errstr);
-                else
-                        cli_err ("quota command : failed");
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
-
-                node = list_node_add_order (dict, &local->dict_list,
-                                            cli_quota_compare_path);
-                if (node == NULL) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to add node to the list");
-                        dict_unref (dict);
-                        goto out;
-                }
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    struct list_node *node = NULL;
+    struct list_node *tmpnode = NULL;
+    call_frame_t *frame = NULL;
+    cli_local_t *local = NULL;
+    int32_t list_count = 0;
+    pthread_t th_id = {
+        0,
+    };
+    int32_t max_count = 0;
+
+    GF_ASSERT(myframe);
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    LOCK(&local->lock);
+    {
+        ret = dict_get_int32(local->dict, "quota-list-count", &list_count);
+        if (ret)
+            list_count = 0;
+
+        list_count++;
+        ret = dict_set_int32(local->dict, "quota-list-count", list_count);
+    }
+    UNLOCK(&local->lock);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to set "
+               "quota-list-count in dict");
+        goto out;
+    }
+
+    if (-1 == req->rpc_status) {
+        if (list_count == 0)
+            cli_err(
+                "Connection failed. Please check if quota "
+                "daemon is operational.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("quota command failed : %s", rsp.op_errstr);
+        else
+            cli_err("quota command : failed");
+        goto out;
+    }
 
-       }
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-        ret = dict_get_int32 (local->dict, "max_count",
-                              &max_count);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "failed to get max_count");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "failed to "
+                   "unserialize req-buffer to dictionary");
+            goto out;
         }
 
-        if (list_count == max_count) {
-                list_for_each_entry_safe (node, tmpnode,
-                                          &local->dict_list, list) {
-                        dict = node->ptr;
-                        print_quota_list_from_quotad (frame, dict);
-                        list_node_del (node);
-                        dict_unref (dict);
-                }
+        node = list_node_add_order(dict, &local->dict_list,
+                                   cli_quota_compare_path);
+        if (node == NULL) {
+            gf_log("cli", GF_LOG_ERROR, "failed to add node to the list");
+            dict_unref(dict);
+            goto out;
         }
+    }
 
+    ret = dict_get_int32(local->dict, "max_count", &max_count);
+    if (ret < 0) {
+        gf_log("cli", GF_LOG_ERROR, "failed to get max_count");
+        goto out;
+    }
 
+    if (list_count == max_count) {
+        list_for_each_entry_safe(node, tmpnode, &local->dict_list, list)
+        {
+            dict = node->ptr;
+            print_quota_list_from_quotad(frame, dict);
+            list_node_del(node);
+            dict_unref(dict);
+        }
+    }
+
+out:
+    /* Bad Fix: CLI holds the lock to process a command.
+     * When processing quota list command, below sequence of steps executed
+     * in the same thread and causing deadlock
+     *
+     * 1) CLI holds the lock
+     * 2) Send rpc_clnt_submit request to quotad for quota usage
+     * 3) If quotad is down, rpc_clnt_submit invokes cbk function with error
+     * 4) cbk function cli_quotad_getlimit_cbk invokes
+     *    cli_cmd_broadcast_response which tries to hold lock to broadcast
+     *    the results and hangs, because same thread has already holding
+     *    the lock
+     *
+     * Broadcasting response in a separate thread which is not a
+     * good fix. This needs to be re-visted with better solution
+     */
+    if (ret == -1) {
+        ret = pthread_create(&th_id, NULL, cli_cmd_broadcast_response_detached,
+                             (void *)-1);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR,
+                   "pthread_create failed: "
+                   "%s",
+                   strerror(errno));
+    } else {
+        cli_cmd_broadcast_response(ret);
+    }
 
-out:
-        /* Bad Fix: CLI holds the lock to process a command.
-         * When processing quota list command, below sequence of steps executed
-         * in the same thread and causing deadlock
-         *
-         * 1) CLI holds the lock
-         * 2) Send rpc_clnt_submit request to quotad for quota usage
-         * 3) If quotad is down, rpc_clnt_submit invokes cbk function with error
-         * 4) cbk function cli_quotad_getlimit_cbk invokes
-         *    cli_cmd_broadcast_response which tries to hold lock to broadcast
-         *    the results and hangs, because same thread has already holding
-         *    the lock
-         *
-         * Broadcasting response in a separate thread which is not a
-         * good fix. This needs to be re-visted with better solution
-         */
-        if (ret == -1) {
-                ret = pthread_create (&th_id, NULL,
-                                cli_cmd_broadcast_response_detached,
-                                (void *)-1);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "pthread_create failed: "
-                                "%s", strerror (errno));
-        } else {
-                cli_cmd_broadcast_response (ret);
-        }
-
-        free (rsp.dict.dict_val);
-        return ret;
+    free(rsp.dict.dict_val);
+    return ret;
 }
 
 int
-cli_quotad_getlimit (call_frame_t *frame, xlator_t *this, void *data)
+cli_quotad_getlimit(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req          req = {{0,}};
-        int                 ret = 0;
-        dict_t             *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
-        ret = add_cli_cmd_timeout_to_dict (dict);
+    dict = data;
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to serialize the data");
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, "failed to serialize the data");
 
-                goto out;
-        }
+        goto out;
+    }
 
-        ret = cli_cmd_submit (global_quotad_rpc, &req, frame, &cli_quotad_clnt,
-                              GF_AGGREGATOR_GETLIMIT, NULL,
-                              this, cli_quotad_getlimit_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(global_quotad_rpc, &req, frame, &cli_quotad_clnt,
+                         GF_AGGREGATOR_GETLIMIT, NULL, this,
+                         cli_quotad_getlimit_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 void
-gf_cli_quota_list (cli_local_t *local, char *volname, dict_t *dict,
-                   char *default_sl, int count, int op_ret,
-                   int op_errno, char *op_errstr)
+gf_cli_quota_list(cli_local_t *local, char *volname, dict_t *dict,
+                  char *default_sl, int count, int op_ret, int op_errno,
+                  char *op_errstr)
 {
-        GF_VALIDATE_OR_GOTO ("cli", volname, out);
+    GF_VALIDATE_OR_GOTO("cli", volname, out);
 
-        if (!connected)
-                goto out;
+    if (!connected)
+        goto out;
 
-        if (count > 0)
-                gf_cli_print_limit_list_from_dict (local, volname, dict,
-                                                   default_sl, count, op_ret,
-                                                   op_errno, op_errstr);
+    if (count > 0)
+        gf_cli_print_limit_list_from_dict(local, volname, dict, default_sl,
+                                          count, op_ret, op_errno, op_errstr);
 out:
-        return;
+    return;
 }
 
 int
-gf_cli_quota_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        gf_cli_rsp         rsp         = {0,};
-        int                ret         = -1;
-        dict_t            *dict        = NULL;
-        char              *volname     = NULL;
-        int32_t            type        = 0;
-        call_frame_t      *frame       = NULL;
-        char              *default_sl  = NULL;
-        cli_local_t       *local       = NULL;
-        char              *default_sl_dup  = NULL;
-        int32_t            entry_count      = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
+gf_cli_quota_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int32_t type = 0;
+    call_frame_t *frame = NULL;
+    char *default_sl = NULL;
+    cli_local_t *local = NULL;
+    char *default_sl_dup = NULL;
+    int32_t entry_count = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
+
+        if (strcmp(rsp.op_errstr, "")) {
+            cli_err("quota command failed : %s", rsp.op_errstr);
+            if (rsp.op_ret == -ENOENT)
+                cli_err(
+                    "please enter the path relative to "
+                    "the volume");
+        } else {
+            cli_err("quota command : failed");
         }
 
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
+        goto out;
+    }
 
-        local = frame->local;
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
         if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                ret = -1;
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-
-                if (strcmp (rsp.op_errstr, "")) {
-                        cli_err ("quota command failed : %s", rsp.op_errstr);
-                        if (rsp.op_ret == -ENOENT)
-                                cli_err ("please enter the path relative to "
-                                         "the volume");
-                } else {
-                        cli_err ("quota command : failed");
-                }
-
-                goto out;
-        }
-
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict  = dict_new ();
-
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "failed to "
-                                "unserialize req-buffer to dictionary");
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR,
+                   "failed to "
+                   "unserialize req-buffer to dictionary");
+            goto out;
+        }
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to quota command");
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get volname");
+
+    ret = dict_get_str(dict, "default-soft-limit", &default_sl);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE,
+               "failed to get "
+               "default soft limit");
+
+    // default-soft-limit is part of rsp_dict only iff we sent
+    // GLUSTER_CLI_QUOTA with type being GF_QUOTA_OPTION_TYPE_LIST
+    if (default_sl) {
+        default_sl_dup = gf_strdup(default_sl);
+        if (!default_sl_dup) {
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_dynstr(local->dict, "default-soft-limit",
+                              default_sl_dup);
+        if (ret) {
+            gf_log(frame->this->name, GF_LOG_TRACE,
+                   "failed to set default soft limit");
+            GF_FREE(default_sl_dup);
         }
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to quota command");
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE, "failed to get type");
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get volname");
+    ret = dict_get_int32(dict, "count", &entry_count);
+    if (ret)
+        gf_log(frame->this->name, GF_LOG_TRACE, "failed to get count");
 
-        ret = dict_get_str (dict, "default-soft-limit", &default_sl);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE, "failed to get "
-                        "default soft limit");
-
-        // default-soft-limit is part of rsp_dict only iff we sent
-        // GLUSTER_CLI_QUOTA with type being GF_QUOTA_OPTION_TYPE_LIST
-        if (default_sl) {
-                default_sl_dup = gf_strdup (default_sl);
-                if (!default_sl_dup) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_dynstr (local->dict, "default-soft-limit",
-                                       default_sl_dup);
-                if (ret) {
-                        gf_log (frame->this->name, GF_LOG_TRACE,
-                                "failed to set default soft limit");
-                        GF_FREE (default_sl_dup);
-                }
-        }
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE,
-                        "failed to get type");
-
-        ret = dict_get_int32 (dict, "count", &entry_count);
-        if (ret)
-                gf_log (frame->this->name, GF_LOG_TRACE, "failed to get count");
+    if ((type == GF_QUOTA_OPTION_TYPE_LIST) ||
+        (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
+        gf_cli_quota_list(local, volname, dict, default_sl, entry_count,
+                          rsp.op_ret, rsp.op_errno, rsp.op_errstr);
 
-        if ((type == GF_QUOTA_OPTION_TYPE_LIST)
-            || (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
-                gf_cli_quota_list (local, volname, dict, default_sl,
-                                   entry_count, rsp.op_ret,
-                                   rsp.op_errno, rsp.op_errstr);
-
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_vol_quota_limit_list_end (local);
-                        if (ret < 0) {
-                                ret = -1;
-                                gf_log ("cli", GF_LOG_ERROR, "Error in printing"
-                                       " xml output");
-                        }
-                        goto out;
-                }
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            ret = cli_xml_output_vol_quota_limit_list_end(local);
+            if (ret < 0) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR,
+                       "Error in printing"
+                       " xml output");
+            }
+            goto out;
         }
+    }
 
 xml_output:
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volQuota", NULL, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volQuota", NULL, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (!rsp.op_ret && type != GF_QUOTA_OPTION_TYPE_LIST
-                        && type != GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)
-                cli_out ("volume quota : success");
+    if (!rsp.op_ret && type != GF_QUOTA_OPTION_TYPE_LIST &&
+        type != GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)
+        cli_out("volume quota : success");
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 out:
 
-        if ((type == GF_QUOTA_OPTION_TYPE_LIST)
-            || (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
-                gluster_remove_auxiliary_mount (volname);
-        }
+    if ((type == GF_QUOTA_OPTION_TYPE_LIST) ||
+        (type == GF_QUOTA_OPTION_TYPE_LIST_OBJECTS)) {
+        gluster_remove_auxiliary_mount(volname);
+    }
 
-        cli_cmd_broadcast_response (ret);
-        if (dict)
-                dict_unref (dict);
+    cli_cmd_broadcast_response(ret);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_getspec_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
+gf_cli_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
 {
-        gf_getspec_rsp          rsp   = {0,};
-        int                     ret   = -1;
-        char                   *spec  = NULL;
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *spec = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "getspec failed");
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "getspec failed");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to getspec");
+    gf_log("cli", GF_LOG_INFO, "Received resp to getspec");
 
-        spec = GF_MALLOC (rsp.op_ret + 1, cli_mt_char);
-        if (!spec) {
-                gf_log("", GF_LOG_ERROR, "out of memory");
-                goto out;
-        }
-        memcpy (spec, rsp.spec, rsp.op_ret);
-        spec[rsp.op_ret] = '\0';
-        cli_out ("%s", spec);
-        GF_FREE (spec);
+    spec = GF_MALLOC(rsp.op_ret + 1, cli_mt_char);
+    if (!spec) {
+        gf_log("", GF_LOG_ERROR, "out of memory");
+        goto out;
+    }
+    memcpy(spec, rsp.spec, rsp.op_ret);
+    spec[rsp.op_ret] = '\0';
+    cli_out("%s", spec);
+    GF_FREE(spec);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_pmap_b2p_cbk (struct rpc_req *req, struct iovec *iov,
-                        int count, void *myframe)
+gf_cli_pmap_b2p_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
 {
-        pmap_port_by_brick_rsp rsp = {0,};
-        int                     ret   = -1;
-        char                   *spec  = NULL;
+    pmap_port_by_brick_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *spec = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_port_by_brick_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_port_by_brick_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "pump_b2p failed");
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "pump_b2p failed");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to pmap b2p");
+    gf_log("cli", GF_LOG_INFO, "Received resp to pmap b2p");
 
-        cli_out ("%d", rsp.port);
-        GF_FREE (spec);
+    cli_out("%d", rsp.port);
+    GF_FREE(spec);
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
-
 int32_t
-gf_cli_probe (call_frame_t *frame, xlator_t *this,
-                 void *data)
+gf_cli_probe(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req         req      = {{0,},};
-        int                ret      = 0;
-        dict_t            *dict     = NULL;
-        int                port     = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_int32 (dict, "port", &port);
-        if (ret) {
-                ret = dict_set_int32 (dict, "port", CLI_GLUSTERD_PORT);
-                if (ret)
-                        goto out;
-        }
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    int port = 0;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_int32(dict, "port", &port);
+    if (ret) {
+        ret = dict_set_int32(dict, "port", CLI_GLUSTERD_PORT);
+        if (ret)
+            goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_probe_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROBE, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_probe_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_PROBE,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_deprobe (call_frame_t *frame, xlator_t *this,
-                   void *data)
+gf_cli_deprobe(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req           req      = {{0,},};
-        int                  ret      = 0;
-        dict_t              *dict     = NULL;
-        int                  port     = 0;
-        int                  flags    = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-        ret = dict_get_int32 (dict, "port", &port);
-        if (ret) {
-                ret = dict_set_int32 (dict, "port", CLI_GLUSTERD_PORT);
-                if (ret)
-                        goto out;
-        }
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    int port = 0;
+    int flags = 0;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+    ret = dict_get_int32(dict, "port", &port);
+    if (ret) {
+        ret = dict_set_int32(dict, "port", CLI_GLUSTERD_PORT);
+        if (ret)
+            goto out;
+    }
 
-        ret = dict_get_int32 (dict, "flags", &flags);
-        if (ret) {
-                ret = dict_set_int32 (dict, "flags", 0);
-                if (ret)
-                        goto out;
-        }
+    ret = dict_get_int32(dict, "flags", &flags);
+    if (ret) {
+        ret = dict_set_int32(dict, "flags", 0);
+        if (ret)
+            goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_deprobe_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                              GLUSTER_CLI_DEPROBE, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_deprobe_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_DEPROBE,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_list_friends (call_frame_t *frame, xlator_t *this,
-                     void *data)
+gf_cli_list_friends(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_peer_list_req   req = {0,};
-        int                     ret = 0;
-        unsigned long           flags = 0;
+    gf1_cli_peer_list_req req = {
+        0,
+    };
+    int ret = 0;
+    unsigned long flags = 0;
 
-        if (!frame || !this) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this) {
+        ret = -1;
+        goto out;
+    }
 
-        GF_ASSERT (frame->local == NULL);
+    GF_ASSERT(frame->local == NULL);
 
-        flags = (long)data;
-        req.flags = flags;
-        frame->local = (void*)flags;
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_LIST_FRIENDS, NULL,
-                              this, gf_cli_list_friends_cbk,
-                              (xdrproc_t) xdr_gf1_cli_peer_list_req);
+    flags = (long)data;
+    req.flags = flags;
+    frame->local = (void *)flags;
+    ret = cli_cmd_submit(
+        NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_LIST_FRIENDS, NULL, this,
+        gf_cli_list_friends_cbk, (xdrproc_t)xdr_gf1_cli_peer_list_req);
 
 out:
-        if (ret && frame) {
-                /*
-                 * If everything goes fine, gf_cli_list_friends_cbk()
-                 * [invoked through cli_cmd_submit()]resets the
-                 * frame->local to NULL. In case cli_cmd_submit()
-                 * fails in between, RESET frame->local here.
-                 */
-                frame->local = NULL;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (ret && frame) {
+        /*
+         * If everything goes fine, gf_cli_list_friends_cbk()
+         * [invoked through cli_cmd_submit()]resets the
+         * frame->local to NULL. In case cli_cmd_submit()
+         * fails in between, RESET frame->local here.
+         */
+        frame->local = NULL;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli_get_state (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_get_state(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,},};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {
+        {
+            0,
+        },
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_get_state_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_GET_STATE, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_get_state_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_GET_STATE, this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_get_next_volume (call_frame_t *frame, xlator_t *this,
-                           void *data)
+gf_cli_get_next_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
+    int ret = 0;
+    cli_cmd_volume_get_ctx_t *ctx = NULL;
+    cli_local_t *local = NULL;
 
-        int                             ret = 0;
-        cli_cmd_volume_get_ctx_t        *ctx = NULL;
-        cli_local_t                     *local = NULL;
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    ctx = data;
+    local = frame->local;
 
-        ctx = data;
-        local = frame->local;
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_info_begin (local, 0, 0, "");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-                        goto out;
-                }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_info_begin(local, 0, 0, "");
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+            goto out;
         }
+    }
 
-        ret = gf_cli_get_volume (frame, this, data);
-
+    ret = gf_cli_get_volume(frame, this, data);
 
-        if (!local || !local->get_vol.volname) {
-                if ((global_state->mode & GLUSTER_MODE_XML))
-                        goto end_xml;
+    if (!local || !local->get_vol.volname) {
+        if ((global_state->mode & GLUSTER_MODE_XML))
+            goto end_xml;
 
-                cli_err ("No volumes present");
-                goto out;
-        }
+        cli_err("No volumes present");
+        goto out;
+    }
 
+    ctx->volname = local->get_vol.volname;
 
+    while (ctx->volname) {
+        ret = gf_cli_get_volume(frame, this, ctx);
+        if (ret)
+            goto out;
         ctx->volname = local->get_vol.volname;
-
-        while (ctx->volname) {
-                ret = gf_cli_get_volume (frame, this, ctx);
-                if (ret)
-                        goto out;
-                ctx->volname = local->get_vol.volname;
-        }
+    }
 
 end_xml:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_info_end (local);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_info_end(local);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
-                      void *data)
+gf_cli_get_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        cli_cmd_volume_get_ctx_t        *ctx = NULL;
-        dict_t                          *dict = NULL;
-        int32_t                         flags = 0;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    cli_cmd_volume_get_ctx_t *ctx = NULL;
+    dict_t *dict = NULL;
+    int32_t flags = 0;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        ctx = data;
+    ctx = data;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        if (ctx->volname) {
-                ret = dict_set_str (dict, "volname", ctx->volname);
-                if (ret)
-                        goto out;
-        }
+    if (ctx->volname) {
+        ret = dict_set_str(dict, "volname", ctx->volname);
+        if (ret)
+            goto out;
+    }
 
-        flags = ctx->flags;
-        ret = dict_set_int32 (dict, "flags", flags);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to set flags");
-                goto out;
-        }
+    flags = ctx->flags;
+    ret = dict_set_int32(dict, "flags", flags);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to set flags");
+        goto out;
+    }
 
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to serialize dict");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to serialize dict");
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_GET_VOLUME, NULL,
-                              this, gf_cli_get_volume_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_GET_VOLUME, NULL, this,
+                         gf_cli_get_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli3_1_uuid_get (call_frame_t *frame, xlator_t *this,
-                      void *data)
+gf_cli3_1_uuid_get(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        dict_t                          *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
-        ret = cli_to_glusterd (&req, frame, gf_cli3_1_uuid_get_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_UUID_GET, this, cli_rpc_prog,
-                               NULL);
+    dict = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli3_1_uuid_get_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_UUID_GET,
+                          this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli3_1_uuid_reset (call_frame_t *frame, xlator_t *this,
-                      void *data)
+gf_cli3_1_uuid_reset(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        int                             ret = 0;
-        dict_t                          *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
-        ret = cli_to_glusterd (&req, frame, gf_cli3_1_uuid_reset_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_UUID_RESET, this, cli_rpc_prog,
-                               NULL);
+    dict = data;
+    ret = cli_to_glusterd(&req, frame, gf_cli3_1_uuid_reset_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_UUID_RESET, this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli_create_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_create_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_create_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_create_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_delete_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_delete_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_delete_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_DELETE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_delete_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_DELETE_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_start_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_start_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_start_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_START_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_start_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_START_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_stop_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_stop_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req             req = {{0,}};
-        int                    ret = 0;
-        dict_t                 *dict = data;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = data;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_stop_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_STOP_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_stop_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_STOP_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_defrag_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_defrag_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req     =  {{0,}};
-        int                     ret     = 0;
-        dict_t                 *dict    = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_defrag_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_DEFRAG_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_defrag_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_DEFRAG_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_rename_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_rename_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to serialize the data");
+    dict = data;
 
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, "failed to serialize the data");
 
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_RENAME_VOLUME, NULL,
-                              this, gf_cli_rename_volume_cbk,
-                              (xdrproc_t) xdr_gf_cli_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_RENAME_VOLUME, NULL, this,
+                         gf_cli_rename_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_reset_volume (call_frame_t *frame, xlator_t *this,
-                        void *data)
+gf_cli_reset_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_reset_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_RESET_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_reset_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_RESET_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli_set_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_set_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_set_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SET_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_set_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_SET_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_add_brick (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_add_brick(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req =  {{0,} };
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-        char                    *volname = NULL;
-        int32_t                 count = 0;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    char *volname = NULL;
+    int32_t count = 0;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "volname", &volname);
+    ret = dict_get_str(dict, "volname", &volname);
 
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
-                goto out;
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_add_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ADD_BRICK, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_add_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_ADD_BRICK, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_tier (call_frame_t *frame, xlator_t *this,
-             void *data)
+gf_cli_tier(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                     ret = 0;
-        int32_t                 command = 0;
-        gf_cli_req              req =  { {0,} };
-        dict_t                  *dict = NULL;
+    int ret = 0;
+    int32_t command = 0;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
-        dict = data;
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+    dict = data;
 
-        ret = dict_get_int32 (dict, "rebalance-command", &command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get rebalance-command");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "rebalance-command", &command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get rebalance-command");
+        goto out;
+    }
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_defrag_volume_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, dict,
-                                GLUSTER_CLI_TIER, this, cli_rpc_prog,
-                                NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_defrag_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_TIER,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_add_tier_brick (call_frame_t *frame, xlator_t *this,
-                       void *data)
+gf_cli_add_tier_brick(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req             = { {0,} };
-        int                     ret             = 0;
-        dict_t                  *dict           = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_add_tier_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ADD_TIER_BRICK, this,
-                               cli_rpc_prog, NULL);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to send request to "
-                        "glusterd");
-                goto out;
-        }
+    ret = cli_to_glusterd(&req, frame, gf_cli_add_tier_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_ADD_TIER_BRICK, this, cli_rpc_prog, NULL);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to send request to "
+               "glusterd");
+        goto out;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-
 int32_t
-gf_cli_attach_tier (call_frame_t *frame, xlator_t *this,
-                    void *data)
-{
-        gf_cli_req              req             =  {{0,} };
-        int                     ret             = 0;
-        dict_t                  *dict           = NULL;
-        dict_t                  *newdict        = NULL;
-        char                    *tierwords[]    = {"volume", "tier", "",
-                                                   "start", NULL};
-        const char              **words         = (const char **)tierwords;
-        char                    *volname        = NULL;
-        cli_local_t             *local          = NULL;
-        cli_local_t             *oldlocal       = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_attach_tier_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_ATTACH_TIER, this,
-                               cli_rpc_prog, NULL);
-        if (ret)
-                goto out;
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume name");
-                goto notify_cli;
-        }
-
-        words[2] = volname;
-        ret = cli_cmd_volume_old_tier_parse ((const char **)words,
-                                             4, &newdict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to parse tier start "
-                        "command");
-                goto notify_cli;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Sending tier start");
-
-        oldlocal = frame->local;
-        CLI_LOCAL_INIT (local, words, frame, newdict);
-        ret = gf_cli_tier (frame, this, newdict);
-        frame->local = oldlocal;
-        cli_local_wipe (local);
+gf_cli_attach_tier(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    dict_t *newdict = NULL;
+    char *tierwords[] = {"volume", "tier", "", "start", NULL};
+    const char **words = (const char **)tierwords;
+    char *volname = NULL;
+    cli_local_t *local = NULL;
+    cli_local_t *oldlocal = NULL;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = cli_to_glusterd(&req, frame, gf_cli_attach_tier_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_ATTACH_TIER, this, cli_rpc_prog, NULL);
+    if (ret)
+        goto out;
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+        goto notify_cli;
+    }
+
+    words[2] = volname;
+    ret = cli_cmd_volume_old_tier_parse((const char **)words, 4, &newdict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to parse tier start "
+               "command");
+        goto notify_cli;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Sending tier start");
+
+    oldlocal = frame->local;
+    CLI_LOCAL_INIT(local, words, frame, newdict);
+    ret = gf_cli_tier(frame, this, newdict);
+    frame->local = oldlocal;
+    cli_local_wipe(local);
 
 notify_cli:
-        if (ret) {
-                cli_out ("Failed to run tier start. Please execute tier start "
-                         "command explicitly");
-                cli_out ("Usage : gluster volume tier <volname> start");
-        }
+    if (ret) {
+        cli_out(
+            "Failed to run tier start. Please execute tier start "
+            "command explicitly");
+        cli_out("Usage : gluster volume tier <volname> start");
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_remove_tier_brick (call_frame_t *frame, xlator_t *this,
-                    void *data)
+gf_cli_remove_tier_brick(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                status_req = { {0,} };
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
-        int32_t                   command = 0;
-        char                     *volname = NULL;
+    gf_cli_req status_req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    int32_t command = 0;
+    char *volname = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 (dict, "command", &command);
-        if (ret)
-                goto out;
+    ret = dict_get_int32(dict, "command", &command);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (dict, "rebalance-command", (int32_t) command);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                                "Failed to set dict");
-                goto out;
-        }
+    ret = dict_set_int32(dict, "rebalance-command", (int32_t)command);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to set dict");
+        goto out;
+    }
 
-        ret = cli_to_glusterd (&status_req, frame,
-                        gf_cli_remove_tier_brick_cbk,
-                        (xdrproc_t) xdr_gf_cli_req, dict,
-                        GLUSTER_CLI_TIER, this,
-                        cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&status_req, frame, gf_cli_remove_tier_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_TIER,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (status_req.dict.dict_val);
+    GF_FREE(status_req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_remove_brick (call_frame_t *frame, xlator_t *this,
-                     void *data)
-{
-        gf_cli_req                req =  {{0,}};;
-        gf_cli_req                status_req =  {{0,}};;
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
-        int32_t                   command = 0;
-        char                     *volname = NULL;
-        int32_t                   cmd = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "command", &command);
-        if (ret)
-                goto out;
-
-        if ((command != GF_OP_CMD_STATUS) &&
-            (command != GF_OP_CMD_STOP)) {
-
-
-                ret = cli_to_glusterd (&req, frame, gf_cli_remove_brick_cbk,
-                                       (xdrproc_t) xdr_gf_cli_req, dict,
-                                       GLUSTER_CLI_REMOVE_BRICK, this,
-                                       cli_rpc_prog, NULL);
-        } else {
-                /* Need rebalance status to be sent :-) */
-                if (command == GF_OP_CMD_STATUS)
-                        cmd |= GF_DEFRAG_CMD_STATUS;
-                else
-                        cmd |= GF_DEFRAG_CMD_STOP;
-
-                ret = dict_set_int32 (dict, "rebalance-command", (int32_t) cmd);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Failed to set dict");
-                        goto out;
-                }
+gf_cli_remove_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    ;
+    gf_cli_req status_req = {{
+        0,
+    }};
+    ;
+    int ret = 0;
+    dict_t *dict = NULL;
+    int32_t command = 0;
+    char *volname = NULL;
+    int32_t cmd = 0;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "command", &command);
+    if (ret)
+        goto out;
+
+    if ((command != GF_OP_CMD_STATUS) && (command != GF_OP_CMD_STOP)) {
+        ret = cli_to_glusterd(
+            &req, frame, gf_cli_remove_brick_cbk, (xdrproc_t)xdr_gf_cli_req,
+            dict, GLUSTER_CLI_REMOVE_BRICK, this, cli_rpc_prog, NULL);
+    } else {
+        /* Need rebalance status to be sent :-) */
+        if (command == GF_OP_CMD_STATUS)
+            cmd |= GF_DEFRAG_CMD_STATUS;
+        else
+            cmd |= GF_DEFRAG_CMD_STOP;
 
-                ret = cli_to_glusterd (&status_req, frame,
-                                       gf_cli3_remove_brick_status_cbk,
-                                       (xdrproc_t) xdr_gf_cli_req, dict,
-                                       GLUSTER_CLI_DEFRAG_VOLUME, this,
-                                       cli_rpc_prog, NULL);
+        ret = dict_set_int32(dict, "rebalance-command", (int32_t)cmd);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR, "Failed to set dict");
+            goto out;
+        }
 
-                }
+        ret = cli_to_glusterd(
+            &status_req, frame, gf_cli3_remove_brick_status_cbk,
+            (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_DEFRAG_VOLUME, this,
+            cli_rpc_prog, NULL);
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        GF_FREE (status_req.dict.dict_val);
+    GF_FREE(status_req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_reset_brick (call_frame_t *frame, xlator_t *this, void *data)
-{
-        gf_cli_req                  req        =  { {0,} };
-        int                         ret        = 0;
-        dict_t                     *dict       = NULL;
-        char                       *dst_brick  = NULL;
-        char                       *src_brick  = NULL;
-        char                       *volname    = NULL;
-        char                       *op         = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "operation", &op);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
+gf_cli_reset_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    char *dst_brick = NULL;
+    char *src_brick = NULL;
+    char *volname = NULL;
+    char *op = NULL;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_str(dict, "operation", &op);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on operation failed");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on volname failed");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "src-brick", &src_brick);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on src-brick failed");
+        goto out;
+    }
+
+    if (!strcmp(op, "GF_RESET_OP_COMMIT") ||
+        !strcmp(op, "GF_RESET_OP_COMMIT_FORCE")) {
+        ret = dict_get_str(dict, "dst-brick", &dst_brick);
         if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on volname failed");
-                goto out;
+            gf_log(this->name, GF_LOG_DEBUG, "dict_get on dst-brick failed");
+            goto out;
         }
+    }
 
-        ret = dict_get_str (dict, "src-brick", &src_brick);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on src-brick failed");
-                goto out;
-        }
+    gf_log(this->name, GF_LOG_DEBUG, "Received command reset-brick %s on %s.",
+           op, src_brick);
 
-        if (!strcmp (op, "GF_RESET_OP_COMMIT") ||
-            !strcmp (op, "GF_RESET_OP_COMMIT_FORCE")) {
-                ret = dict_get_str (dict, "dst-brick", &dst_brick);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "dict_get on dst-brick failed");
-                        goto out;
-                }
-        }
-
-        gf_log (this->name, GF_LOG_DEBUG,
-                "Received command reset-brick %s on %s.", op, src_brick);
-
-        ret = cli_to_glusterd (&req, frame, gf_cli_reset_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_RESET_BRICK, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_reset_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_RESET_BRICK, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_replace_brick (call_frame_t *frame, xlator_t *this,
-                      void *data)
-{
-        gf_cli_req                  req        =  {{0,}};
-        int                         ret        = 0;
-        dict_t                     *dict       = NULL;
-        char                       *src_brick  = NULL;
-        char                       *dst_brick  = NULL;
-        char                       *volname    = NULL;
-        int32_t                     op         = 0;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+gf_cli_replace_brick(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
+    char *src_brick = NULL;
+    char *dst_brick = NULL;
+    char *volname = NULL;
+    int32_t op = 0;
 
-        dict = data;
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "operation", &op);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on volname failed");
-                goto out;
-        }
+    dict = data;
 
-        ret = dict_get_str (dict, "src-brick", &src_brick);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on src-brick failed");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "operation", &op);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on operation failed");
+        goto out;
+    }
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on volname failed");
+        goto out;
+    }
 
-        ret = dict_get_str (dict, "dst-brick", &dst_brick);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "dict_get on dst-brick failed");
-                goto out;
-        }
+    ret = dict_get_str(dict, "src-brick", &src_brick);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on src-brick failed");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "dst-brick", &dst_brick);
+    if (ret) {
+        gf_log(this->name, GF_LOG_DEBUG, "dict_get on dst-brick failed");
+        goto out;
+    }
 
-        gf_log (this->name, GF_LOG_DEBUG,
-                "Received command replace-brick %s with "
-                "%s with operation=%d", src_brick,
-                dst_brick, op);
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Received command replace-brick %s with "
+           "%s with operation=%d",
+           src_brick, dst_brick, op);
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_replace_brick_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_REPLACE_BRICK, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_replace_brick_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_REPLACE_BRICK, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-gf_cli_log_rotate (call_frame_t *frame, xlator_t *this,
-                      void *data)
+gf_cli_log_rotate(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                req = {{0,}};
-        int                       ret = 0;
-        dict_t                   *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_log_rotate_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_LOG_ROTATE, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_log_rotate_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_LOG_ROTATE, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_sync_volume (call_frame_t *frame, xlator_t *this,
-                       void *data)
+gf_cli_sync_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int               ret = 0;
-        gf_cli_req        req = {{0,}};
-        dict_t            *dict = NULL;
+    int ret = 0;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_sync_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SYNC_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_sync_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_SYNC_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        GF_FREE (req.dict.dict_val);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_getspec (call_frame_t *frame, xlator_t *this,
-                         void *data)
-{
-        gf_getspec_req          req = {0,};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
-        dict_t                  *op_dict = NULL;
-
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = data;
-
-        ret = dict_get_str (dict, "volid", &req.key);
-        if (ret)
-                goto out;
-
-        op_dict = dict_new ();
-        if (!op_dict) {
-                ret = -1;
-                goto out;
-        }
-
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (op_dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version"
-                        " in request dict");
-                goto out;
-        }
-
-        ret = dict_set_int32 (op_dict, "max-op-version", GD_OP_VERSION_MAX);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version"
-                        " in request dict");
-                goto out;
-        }
-
-        ret = dict_allocate_and_serialize (op_dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
-
-        ret = cli_cmd_submit (NULL, &req, frame, &cli_handshake_prog,
-                              GF_HNDSK_GETSPEC, NULL,
-                              this, gf_cli_getspec_cbk,
-                              (xdrproc_t) xdr_gf_getspec_req);
-
-out:
-        if (op_dict) {
-                dict_unref(op_dict);
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-
-        return ret;
+gf_cli_getspec(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
+    dict_t *op_dict = NULL;
+
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
+
+    dict = data;
+
+    ret = dict_get_str(dict, "volid", &req.key);
+    if (ret)
+        goto out;
+
+    op_dict = dict_new();
+    if (!op_dict) {
+        ret = -1;
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32(op_dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set min-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(op_dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set max-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    ret = dict_allocate_and_serialize(op_dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to serialize dictionary");
+        goto out;
+    }
+
+    ret = cli_cmd_submit(NULL, &req, frame, &cli_handshake_prog,
+                         GF_HNDSK_GETSPEC, NULL, this, gf_cli_getspec_cbk,
+                         (xdrproc_t)xdr_gf_getspec_req);
+
+out:
+    if (op_dict) {
+        dict_unref(op_dict);
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+
+    return ret;
 }
 
 int32_t
-gf_cli_quota (call_frame_t *frame, xlator_t *this,
-                 void *data)
+gf_cli_quota(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req          req = {{0,}};
-        int                 ret = 0;
-        dict_t             *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_quota_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_QUOTA, this, cli_rpc_prog, NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_quota_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_QUOTA,
+                          this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_pmap_b2p (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_pmap_b2p(call_frame_t *frame, xlator_t *this, void *data)
 {
-        pmap_port_by_brick_req  req = {0,};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    pmap_port_by_brick_req req = {
+        0,
+    };
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "brick", &req.brick);
-        if (ret)
-                goto out;
+    ret = dict_get_str(dict, "brick", &req.brick);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_submit (NULL, &req, frame, &cli_pmap_prog,
-                              GF_PMAP_PORTBYBRICK, NULL,
-                              this, gf_cli_pmap_b2p_cbk,
-                              (xdrproc_t) xdr_pmap_port_by_brick_req);
+    ret = cli_cmd_submit(NULL, &req, frame, &cli_pmap_prog, GF_PMAP_PORTBYBRICK,
+                         NULL, this, gf_cli_pmap_b2p_cbk,
+                         (xdrproc_t)xdr_pmap_port_by_brick_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_fsm_log_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
-{
-        gf1_cli_fsm_log_rsp        rsp   = {0,};
-        int                        ret   = -1;
-        dict_t                     *dict = NULL;
-        int                        tr_count = 0;
-        char                       key[256] = {0};
-        int                        i = 0;
-        char                       *old_state = NULL;
-        char                       *new_state = NULL;
-        char                       *event = NULL;
-        char                       *time = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_fsm_log_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("%s", rsp.op_errstr);
-                cli_err ("fsm log unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.fsm_log.fsm_log_val,
-                                rsp.fsm_log.fsm_log_len,
-                                &dict);
-
-        if (ret) {
-                cli_err ("bad response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "count", &tr_count);
-        if (tr_count)
-                cli_out("number of transitions: %d", tr_count);
-        else
-                cli_err("No transitions");
-        for (i = 0; i < tr_count; i++) {
-                snprintf (key, sizeof (key), "log%d-old-state", i);
-                ret = dict_get_str (dict, key, &old_state);
-                if (ret)
-                        goto out;
+gf_cli_fsm_log_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                   void *myframe)
+{
+    gf1_cli_fsm_log_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    int tr_count = 0;
+    char key[256] = {0};
+    int i = 0;
+    char *old_state = NULL;
+    char *new_state = NULL;
+    char *event = NULL;
+    char *time = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_fsm_log_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("%s", rsp.op_errstr);
+        cli_err("fsm log unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.fsm_log.fsm_log_val, rsp.fsm_log.fsm_log_len,
+                           &dict);
+
+    if (ret) {
+        cli_err("bad response");
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "count", &tr_count);
+    if (tr_count)
+        cli_out("number of transitions: %d", tr_count);
+    else
+        cli_err("No transitions");
+    for (i = 0; i < tr_count; i++) {
+        snprintf(key, sizeof(key), "log%d-old-state", i);
+        ret = dict_get_str(dict, key, &old_state);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "log%d-event", i);
-                ret = dict_get_str (dict, key, &event);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "log%d-event", i);
+        ret = dict_get_str(dict, key, &event);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "log%d-new-state", i);
-                ret = dict_get_str (dict, key, &new_state);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "log%d-new-state", i);
+        ret = dict_get_str(dict, key, &new_state);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "log%d-time", i);
-                ret = dict_get_str (dict, key, &time);
-                if (ret)
-                        goto out;
-                cli_out ("Old State: [%s]\n"
-                         "New State: [%s]\n"
-                         "Event    : [%s]\n"
-                         "timestamp: [%s]\n", old_state, new_state, event, time);
-        }
+        snprintf(key, sizeof(key), "log%d-time", i);
+        ret = dict_get_str(dict, key, &time);
+        if (ret)
+            goto out;
+        cli_out(
+            "Old State: [%s]\n"
+            "New State: [%s]\n"
+            "Event    : [%s]\n"
+            "timestamp: [%s]\n",
+            old_state, new_state, event, time);
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_fsm_log (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_fsm_log(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                        ret = -1;
-        gf1_cli_fsm_log_req        req = {0,};
+    int ret = -1;
+    gf1_cli_fsm_log_req req = {
+        0,
+    };
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (!frame || !this || !data)
-                goto out;
-        req.name = data;
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_FSM_LOG, NULL,
-                              this, gf_cli_fsm_log_cbk,
-                              (xdrproc_t) xdr_gf1_cli_fsm_log_req);
+    if (!frame || !this || !data)
+        goto out;
+    req.name = data;
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_FSM_LOG,
+                         NULL, this, gf_cli_fsm_log_cbk,
+                         (xdrproc_t)xdr_gf1_cli_fsm_log_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_gsync_config_command (dict_t *dict)
-{
-        runner_t runner     = {0,};
-        char *subop         = NULL;
-        char *gwd           = NULL;
-        char *slave         = NULL;
-        char *confpath      = NULL;
-        char *master        = NULL;
-        char *op_name       = NULL;
-        int   ret           = -1;
-        char  conf_path[PATH_MAX] = "";
-
-        if (dict_get_str (dict, "subop", &subop) != 0)
-                return -1;
-
-        if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
-                cli_out (GEOREP" config updated successfully");
-                return 0;
-        }
-
-        if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
-            dict_get_str (dict, "slave", &slave) != 0)
-                return -1;
-
-        if (dict_get_str (dict, "master", &master) != 0)
-                master = NULL;
-        if (dict_get_str (dict, "op_name", &op_name) != 0)
-                op_name = NULL;
-
-        ret = dict_get_str (dict, "conf_path", &confpath);
-        if (ret || !confpath) {
-                ret = snprintf (conf_path, sizeof(conf_path) - 1,
-                                "%s/"GEOREP"/gsyncd_template.conf", gwd);
-                conf_path[ret] = '\0';
-                confpath = conf_path;
-        }
-
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "-c", NULL);
-        runner_argprintf (&runner, "%s", confpath);
-        runner_argprintf (&runner, "--iprefix=%s", DATADIR);
-        if (master)
-                runner_argprintf (&runner, ":%s", master);
-        runner_add_arg (&runner, slave);
-        runner_argprintf (&runner, "--config-%s", subop);
-        if (op_name)
-                runner_add_arg (&runner, op_name);
-
-        return runner_run (&runner);
+gf_cli_gsync_config_command(dict_t *dict)
+{
+    runner_t runner = {
+        0,
+    };
+    char *subop = NULL;
+    char *gwd = NULL;
+    char *slave = NULL;
+    char *confpath = NULL;
+    char *master = NULL;
+    char *op_name = NULL;
+    int ret = -1;
+    char conf_path[PATH_MAX] = "";
+
+    if (dict_get_str(dict, "subop", &subop) != 0)
+        return -1;
+
+    if (strcmp(subop, "get") != 0 && strcmp(subop, "get-all") != 0) {
+        cli_out(GEOREP " config updated successfully");
+        return 0;
+    }
+
+    if (dict_get_str(dict, "glusterd_workdir", &gwd) != 0 ||
+        dict_get_str(dict, "slave", &slave) != 0)
+        return -1;
+
+    if (dict_get_str(dict, "master", &master) != 0)
+        master = NULL;
+    if (dict_get_str(dict, "op_name", &op_name) != 0)
+        op_name = NULL;
+
+    ret = dict_get_str(dict, "conf_path", &confpath);
+    if (ret || !confpath) {
+        ret = snprintf(conf_path, sizeof(conf_path) - 1,
+                       "%s/" GEOREP "/gsyncd_template.conf", gwd);
+        conf_path[ret] = '\0';
+        confpath = conf_path;
+    }
+
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "-c", NULL);
+    runner_argprintf(&runner, "%s", confpath);
+    runner_argprintf(&runner, "--iprefix=%s", DATADIR);
+    if (master)
+        runner_argprintf(&runner, ":%s", master);
+    runner_add_arg(&runner, slave);
+    runner_argprintf(&runner, "--config-%s", subop);
+    if (op_name)
+        runner_add_arg(&runner, op_name);
+
+    return runner_run(&runner);
 }
 
-
 int
-gf_cli_print_status (char **title_values,
-                     gf_gsync_status_t **sts_vals,
-                     int *spacing, int gsync_count,
-                     int number_of_fields, int is_detail)
-{
-        int     i                        = 0;
-        int     j                        = 0;
-        int     ret                      = 0;
-        int     status_fields            = 8; /* Indexed at 0 */
-        int     total_spacing            = 0;
-        char  **output_values            = NULL;
-        char   *tmp                      = NULL;
-        char   *hyphens                  = NULL;
-
-        /* calculating spacing for hyphens */
-        for (i = 0; i < number_of_fields; i++) {
-                /* Suppressing detail output for status */
-                if ((!is_detail) && (i > status_fields)) {
-                       /* Suppressing detailed output for
-                        * status */
-                        continue;
-                }
-                spacing[i] += 3; /* Adding extra space to
-                                    distinguish between fields */
-                total_spacing += spacing[i];
-        }
-        total_spacing += 4; /* For the spacing between the fields */
-
-        /* char pointers for each field */
-        output_values = GF_CALLOC (number_of_fields, sizeof (char *),
-                                   gf_common_mt_char);
-        if (!output_values) {
-                ret = -1;
-                goto out;
-        }
-        for (i = 0; i < number_of_fields; i++) {
-                output_values[i] = GF_CALLOC (spacing[i] + 1, sizeof (char),
-                                              gf_common_mt_char);
-                if (!output_values[i]) {
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        hyphens = GF_CALLOC (total_spacing + 1, sizeof (char),
-                             gf_common_mt_char);
-        if (!hyphens) {
+gf_cli_print_status(char **title_values, gf_gsync_status_t **sts_vals,
+                    int *spacing, int gsync_count, int number_of_fields,
+                    int is_detail)
+{
+    int i = 0;
+    int j = 0;
+    int ret = 0;
+    int status_fields = 8; /* Indexed at 0 */
+    int total_spacing = 0;
+    char **output_values = NULL;
+    char *tmp = NULL;
+    char *hyphens = NULL;
+
+    /* calculating spacing for hyphens */
+    for (i = 0; i < number_of_fields; i++) {
+        /* Suppressing detail output for status */
+        if ((!is_detail) && (i > status_fields)) {
+            /* Suppressing detailed output for
+             * status */
+            continue;
+        }
+        spacing[i] += 3; /* Adding extra space to
+                            distinguish between fields */
+        total_spacing += spacing[i];
+    }
+    total_spacing += 4; /* For the spacing between the fields */
+
+    /* char pointers for each field */
+    output_values = GF_CALLOC(number_of_fields, sizeof(char *),
+                              gf_common_mt_char);
+    if (!output_values) {
+        ret = -1;
+        goto out;
+    }
+    for (i = 0; i < number_of_fields; i++) {
+        output_values[i] = GF_CALLOC(spacing[i] + 1, sizeof(char),
+                                     gf_common_mt_char);
+        if (!output_values[i]) {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    hyphens = GF_CALLOC(total_spacing + 1, sizeof(char), gf_common_mt_char);
+    if (!hyphens) {
+        ret = -1;
+        goto out;
+    }
+
+    cli_out(" ");
+
+    /* setting the title "NODE", "MASTER", etc. from title_values[]
+       and printing the same */
+    for (j = 0; j < number_of_fields; j++) {
+        if ((!is_detail) && (j > status_fields)) {
+            /* Suppressing detailed output for
+             * status */
+            output_values[j][0] = '\0';
+            continue;
+        }
+        memset(output_values[j], ' ', spacing[j]);
+        memcpy(output_values[j], title_values[j], strlen(title_values[j]));
+        output_values[j][spacing[j]] = '\0';
+    }
+    cli_out("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s", output_values[0],
+            output_values[1], output_values[2], output_values[3],
+            output_values[4], output_values[5], output_values[6],
+            output_values[7], output_values[8], output_values[9],
+            output_values[10], output_values[11], output_values[12],
+            output_values[13], output_values[14], output_values[15]);
+
+    /* setting and printing the hyphens */
+    memset(hyphens, '-', total_spacing);
+    hyphens[total_spacing] = '\0';
+    cli_out("%s", hyphens);
+
+    for (i = 0; i < gsync_count; i++) {
+        for (j = 0; j < number_of_fields; j++) {
+            if ((!is_detail) && (j > status_fields)) {
+                /* Suppressing detailed output for
+                 * status */
+                output_values[j][0] = '\0';
+                continue;
+            }
+            tmp = get_struct_variable(j, sts_vals[i]);
+            if (!tmp) {
+                gf_log("", GF_LOG_ERROR, "struct member empty.");
                 ret = -1;
                 goto out;
+            }
+            memset(output_values[j], ' ', spacing[j]);
+            memcpy(output_values[j], tmp, strlen(tmp));
+            output_values[j][spacing[j]] = '\0';
         }
 
-        cli_out (" ");
-
-        /* setting the title "NODE", "MASTER", etc. from title_values[]
-           and printing the same */
-        for (j = 0; j < number_of_fields; j++) {
-                if ((!is_detail) && (j > status_fields)) {
-                       /* Suppressing detailed output for
-                        * status */
-                       output_values[j][0] = '\0';
-                       continue;
-                }
-                memset (output_values[j], ' ', spacing[j]);
-                memcpy (output_values[j], title_values[j],
-                        strlen(title_values[j]));
-                output_values[j][spacing[j]] = '\0';
-        }
-        cli_out ("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
-                 output_values[0], output_values[1],
-                 output_values[2], output_values[3],
-                 output_values[4], output_values[5],
-                 output_values[6], output_values[7],
-                 output_values[8], output_values[9],
-                 output_values[10], output_values[11],
-                 output_values[12], output_values[13],
-                 output_values[14], output_values[15]);
-
-        /* setting and printing the hyphens */
-        memset (hyphens, '-', total_spacing);
-        hyphens[total_spacing] = '\0';
-        cli_out ("%s", hyphens);
-
-        for (i = 0; i < gsync_count; i++) {
-                for (j = 0; j < number_of_fields; j++) {
-                        if ((!is_detail) && (j > status_fields)) {
-                                /* Suppressing detailed output for
-                                 * status */
-                                output_values[j][0] = '\0';
-                                continue;
-                        }
-                        tmp = get_struct_variable(j, sts_vals[i]);
-                        if (!tmp) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-                        memset (output_values[j], ' ', spacing[j]);
-                        memcpy (output_values[j], tmp, strlen (tmp));
-                        output_values[j][spacing[j]] = '\0';
-                }
-
-                cli_out ("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
-                         output_values[0], output_values[1],
-                         output_values[2], output_values[3],
-                         output_values[4], output_values[5],
-                         output_values[6], output_values[7],
-                         output_values[8], output_values[9],
-                         output_values[10], output_values[11],
-                         output_values[12], output_values[13],
-                         output_values[14], output_values[15]);
-        }
+        cli_out("%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
+                output_values[0], output_values[1], output_values[2],
+                output_values[3], output_values[4], output_values[5],
+                output_values[6], output_values[7], output_values[8],
+                output_values[9], output_values[10], output_values[11],
+                output_values[12], output_values[13], output_values[14],
+                output_values[15]);
+    }
 
 out:
-        if (output_values) {
-                for (i = 0; i < number_of_fields; i++) {
-                        if (output_values[i])
-                                GF_FREE (output_values[i]);
-                }
-                GF_FREE (output_values);
+    if (output_values) {
+        for (i = 0; i < number_of_fields; i++) {
+            if (output_values[i])
+                GF_FREE(output_values[i]);
         }
+        GF_FREE(output_values);
+    }
 
-        if (hyphens)
-                GF_FREE (hyphens);
+    if (hyphens)
+        GF_FREE(hyphens);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_gsync_status_t_comparator (const void *p, const void *q)
+gf_gsync_status_t_comparator(const void *p, const void *q)
 {
-        char *slavekey1 = NULL;
-        char *slavekey2 = NULL;
-
-        slavekey1 = get_struct_variable (20, (*(gf_gsync_status_t **)p));
-        slavekey2 = get_struct_variable (20, (*(gf_gsync_status_t **)q));
-        if (!slavekey1 || !slavekey2) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "struct member empty.");
-                return 0;
-        }
-
-        return strcmp (slavekey1, slavekey2);
-}
-
-int
-gf_cli_read_status_data (dict_t *dict,
-                         gf_gsync_status_t **sts_vals,
-                         int *spacing, int gsync_count,
-                         int number_of_fields)
-{
-        char   *tmp                    = NULL;
-        char    sts_val_name[PATH_MAX] = "";
-        int     ret                    = 0;
-        int     i                      = 0;
-        int     j                      = 0;
-
-        /* Storing per node status info in each object */
-        for (i = 0; i < gsync_count; i++) {
-                snprintf (sts_val_name, sizeof(sts_val_name), "status_value%d", i);
-
-                /* Fetching the values from dict, and calculating
-                   the max length for each field */
-                ret = dict_get_bin (dict, sts_val_name, (void **)&(sts_vals[i]));
-                if (ret)
-                        goto out;
-
-                for (j = 0; j < number_of_fields; j++) {
-                        tmp = get_struct_variable(j, sts_vals[i]);
-                        if (!tmp) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-                        if (strlen (tmp) > spacing[j])
-                                spacing[j] = strlen (tmp);
-                }
-        }
+    char *slavekey1 = NULL;
+    char *slavekey2 = NULL;
 
-        /* Sort based on Session Slave */
-        qsort(sts_vals, gsync_count,
-              sizeof(gf_gsync_status_t *),
-              gf_gsync_status_t_comparator);
+    slavekey1 = get_struct_variable(20, (*(gf_gsync_status_t **)p));
+    slavekey2 = get_struct_variable(20, (*(gf_gsync_status_t **)q));
+    if (!slavekey1 || !slavekey2) {
+        gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+        return 0;
+    }
 
-out:
-        return ret;
+    return strcmp(slavekey1, slavekey2);
 }
 
 int
-gf_cli_gsync_status_output (dict_t *dict, gf_boolean_t is_detail)
-{
-        int                     gsync_count    = 0;
-        int                     i              = 0;
-        int                     ret            = 0;
-        int                     spacing[16]    = {0};
-        int                     num_of_fields  = 16;
-        char                    errmsg[1024]   = "";
-        char                   *master         = NULL;
-        char                   *slave          = NULL;
-        char                   *title_values[] = {"MASTER NODE", "MASTER VOL",
-                                                  "MASTER BRICK", "SLAVE USER",
-                                                  "SLAVE", "SLAVE NODE",
-                                                  "STATUS", "CRAWL STATUS",
-                                                  "LAST_SYNCED", "ENTRY",
-                                                  "DATA", "META", "FAILURES",
-                                                  "CHECKPOINT TIME",
-                                                  "CHECKPOINT COMPLETED",
-                                                  "CHECKPOINT COMPLETION TIME"};
-        gf_gsync_status_t     **sts_vals       = NULL;
-
-        /* Checks if any session is active or not */
-        ret = dict_get_int32 (dict, "gsync-count", &gsync_count);
-        if (ret) {
-                ret = dict_get_str (dict, "master", &master);
-
-                ret = dict_get_str (dict, "slave", &slave);
-
-                if (master) {
-                        if (slave)
-                                snprintf (errmsg, sizeof(errmsg), "No active "
-                                          "geo-replication sessions between %s"
-                                          " and %s", master, slave);
-                        else
-                                snprintf (errmsg, sizeof(errmsg), "No active "
-                                          "geo-replication sessions for %s",
-                                          master);
-                } else
-                        snprintf (errmsg, sizeof(errmsg), "No active "
-                                  "geo-replication sessions");
-
-                gf_log ("cli", GF_LOG_INFO, "%s", errmsg);
-                cli_out ("%s", errmsg);
-                ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < num_of_fields; i++)
-                spacing[i] = strlen(title_values[i]);
+gf_cli_read_status_data(dict_t *dict, gf_gsync_status_t **sts_vals,
+                        int *spacing, int gsync_count, int number_of_fields)
+{
+    char *tmp = NULL;
+    char sts_val_name[PATH_MAX] = "";
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+
+    /* Storing per node status info in each object */
+    for (i = 0; i < gsync_count; i++) {
+        snprintf(sts_val_name, sizeof(sts_val_name), "status_value%d", i);
+
+        /* Fetching the values from dict, and calculating
+           the max length for each field */
+        ret = dict_get_bin(dict, sts_val_name, (void **)&(sts_vals[i]));
+        if (ret)
+            goto out;
 
-        /* gsync_count = number of nodes reporting output.
-           each sts_val object will store output of each
-           node */
-        sts_vals = GF_MALLOC (gsync_count * sizeof (gf_gsync_status_t *),
-                              gf_common_mt_char);
-        if (!sts_vals) {
+        for (j = 0; j < number_of_fields; j++) {
+            tmp = get_struct_variable(j, sts_vals[i]);
+            if (!tmp) {
+                gf_log("", GF_LOG_ERROR, "struct member empty.");
                 ret = -1;
                 goto out;
+            }
+            if (strlen(tmp) > spacing[j])
+                spacing[j] = strlen(tmp);
         }
-        for (i = 0; i < gsync_count; i++) {
-                sts_vals[i] = GF_CALLOC (1, sizeof (gf_gsync_status_t),
-                                         gf_common_mt_char);
-                if (!sts_vals[i]) {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    }
 
-        ret = gf_cli_read_status_data (dict, sts_vals, spacing,
-                                       gsync_count, num_of_fields);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to read status data");
-                goto out;
-        }
-
-        ret = gf_cli_print_status (title_values, sts_vals, spacing, gsync_count,
-                                   num_of_fields, is_detail);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to print status output");
-                goto out;
-        }
+    /* Sort based on Session Slave */
+    qsort(sts_vals, gsync_count, sizeof(gf_gsync_status_t *),
+          gf_gsync_status_t_comparator);
 
 out:
-        if (sts_vals)
-                GF_FREE (sts_vals);
+    return ret;
+}
 
-        return ret;
+int
+gf_cli_gsync_status_output(dict_t *dict, gf_boolean_t is_detail)
+{
+    int gsync_count = 0;
+    int i = 0;
+    int ret = 0;
+    int spacing[16] = {0};
+    int num_of_fields = 16;
+    char errmsg[1024] = "";
+    char *master = NULL;
+    char *slave = NULL;
+    char *title_values[] = {"MASTER NODE",
+                            "MASTER VOL",
+                            "MASTER BRICK",
+                            "SLAVE USER",
+                            "SLAVE",
+                            "SLAVE NODE",
+                            "STATUS",
+                            "CRAWL STATUS",
+                            "LAST_SYNCED",
+                            "ENTRY",
+                            "DATA",
+                            "META",
+                            "FAILURES",
+                            "CHECKPOINT TIME",
+                            "CHECKPOINT COMPLETED",
+                            "CHECKPOINT COMPLETION TIME"};
+    gf_gsync_status_t **sts_vals = NULL;
+
+    /* Checks if any session is active or not */
+    ret = dict_get_int32(dict, "gsync-count", &gsync_count);
+    if (ret) {
+        ret = dict_get_str(dict, "master", &master);
+
+        ret = dict_get_str(dict, "slave", &slave);
+
+        if (master) {
+            if (slave)
+                snprintf(errmsg, sizeof(errmsg),
+                         "No active "
+                         "geo-replication sessions between %s"
+                         " and %s",
+                         master, slave);
+            else
+                snprintf(errmsg, sizeof(errmsg),
+                         "No active "
+                         "geo-replication sessions for %s",
+                         master);
+        } else
+            snprintf(errmsg, sizeof(errmsg),
+                     "No active "
+                     "geo-replication sessions");
+
+        gf_log("cli", GF_LOG_INFO, "%s", errmsg);
+        cli_out("%s", errmsg);
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < num_of_fields; i++)
+        spacing[i] = strlen(title_values[i]);
+
+    /* gsync_count = number of nodes reporting output.
+       each sts_val object will store output of each
+       node */
+    sts_vals = GF_MALLOC(gsync_count * sizeof(gf_gsync_status_t *),
+                         gf_common_mt_char);
+    if (!sts_vals) {
+        ret = -1;
+        goto out;
+    }
+    for (i = 0; i < gsync_count; i++) {
+        sts_vals[i] = GF_CALLOC(1, sizeof(gf_gsync_status_t),
+                                gf_common_mt_char);
+        if (!sts_vals[i]) {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    ret = gf_cli_read_status_data(dict, sts_vals, spacing, gsync_count,
+                                  num_of_fields);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to read status data");
+        goto out;
+    }
+
+    ret = gf_cli_print_status(title_values, sts_vals, spacing, gsync_count,
+                              num_of_fields, is_detail);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to print status output");
+        goto out;
+    }
+
+out:
+    if (sts_vals)
+        GF_FREE(sts_vals);
+
+    return ret;
 }
 
 static int32_t
-write_contents_to_common_pem_file (dict_t *dict, int output_count)
-{
-        char            *workdir                   = NULL;
-        char             common_pem_file[PATH_MAX] = "";
-        char            *output                    = NULL;
-        char             output_name[PATH_MAX]     = "";
-        int              bytes_written             = 0;
-        int              fd                        = -1;
-        int              ret                       = -1;
-        int              i                         = -1;
-
-        ret = dict_get_str (dict, "glusterd_workdir", &workdir);
-        if (ret || !workdir) {
-                gf_log ("", GF_LOG_ERROR, "Unable to fetch workdir");
+write_contents_to_common_pem_file(dict_t *dict, int output_count)
+{
+    char *workdir = NULL;
+    char common_pem_file[PATH_MAX] = "";
+    char *output = NULL;
+    char output_name[PATH_MAX] = "";
+    int bytes_written = 0;
+    int fd = -1;
+    int ret = -1;
+    int i = -1;
+
+    ret = dict_get_str(dict, "glusterd_workdir", &workdir);
+    if (ret || !workdir) {
+        gf_log("", GF_LOG_ERROR, "Unable to fetch workdir");
+        ret = -1;
+        goto out;
+    }
+
+    snprintf(common_pem_file, sizeof(common_pem_file),
+             "%s/geo-replication/common_secret.pem.pub", workdir);
+
+    sys_unlink(common_pem_file);
+
+    fd = open(common_pem_file, O_WRONLY | O_CREAT, 0600);
+    if (fd == -1) {
+        gf_log("", GF_LOG_ERROR,
+               "Failed to open %s"
+               " Error : %s",
+               common_pem_file, strerror(errno));
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 1; i <= output_count; i++) {
+        snprintf(output_name, sizeof(output_name), "output_%d", i);
+        ret = dict_get_str(dict, output_name, &output);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "Failed to get %s.", output_name);
+            cli_out("Unable to fetch output.");
+        }
+        if (output) {
+            bytes_written = sys_write(fd, output, strlen(output));
+            if (bytes_written != strlen(output)) {
+                gf_log("", GF_LOG_ERROR,
+                       "Failed to write "
+                       "to %s",
+                       common_pem_file);
                 ret = -1;
                 goto out;
-        }
-
-        snprintf (common_pem_file, sizeof(common_pem_file),
-                  "%s/geo-replication/common_secret.pem.pub",
-                  workdir);
-
-        sys_unlink (common_pem_file);
-
-        fd = open (common_pem_file, O_WRONLY | O_CREAT, 0600);
-        if (fd == -1) {
-                gf_log ("", GF_LOG_ERROR, "Failed to open %s"
-                        " Error : %s", common_pem_file,
-                        strerror (errno));
+            }
+            /* Adding the new line character */
+            bytes_written = sys_write(fd, "\n", 1);
+            if (bytes_written != 1) {
+                gf_log("", GF_LOG_ERROR, "Failed to add new line char");
                 ret = -1;
                 goto out;
+            }
+            output = NULL;
         }
+    }
 
-        for (i = 1; i <= output_count; i++) {
-                snprintf (output_name, sizeof (output_name),
-                          "output_%d", i);
-                ret = dict_get_str (dict, output_name, &output);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Failed to get %s.",
-                                output_name);
-                        cli_out ("Unable to fetch output.");
-                }
-                if (output) {
-                        bytes_written = sys_write (fd, output, strlen(output));
-                        if (bytes_written != strlen(output)) {
-                                gf_log ("", GF_LOG_ERROR, "Failed to write "
-                                        "to %s", common_pem_file);
-                                ret = -1;
-                                goto out;
-                        }
-                        /* Adding the new line character */
-                        bytes_written = sys_write (fd, "\n", 1);
-                        if (bytes_written != 1) {
-                                gf_log ("", GF_LOG_ERROR,
-                                        "Failed to add new line char");
-                                ret = -1;
-                                goto out;
-                        }
-                        output = NULL;
-                }
-        }
-
-        cli_out ("Common secret pub file present at %s", common_pem_file);
-        ret = 0;
+    cli_out("Common secret pub file present at %s", common_pem_file);
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-gf_cli_sys_exec_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        int                     ret     = -1;
-        int                     output_count     = -1;
-        int                     i     = -1;
-        char                   *output  = NULL;
-        char                   *command = NULL;
-        char                    output_name[PATH_MAX] = "";
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-       }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+gf_cli_sys_exec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+    int ret = -1;
+    int output_count = -1;
+    int i = -1;
+    char *output = NULL;
+    char *command = NULL;
+    char output_name[PATH_MAX] = "";
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret) {
+        cli_err("%s", rsp.op_errstr ? rsp.op_errstr : "Command failed.");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        if (ret)
-                goto out;
+    ret = dict_get_int32(dict, "output_count", &output_count);
+    if (ret) {
+        cli_out("Command executed successfully.");
+        ret = 0;
+        goto out;
+    }
 
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         "Command failed.");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    ret = dict_get_str(dict, "command", &command);
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to get command from dict");
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "output_count", &output_count);
-        if (ret) {
-                cli_out ("Command executed successfully.");
-                ret = 0;
-                goto out;
-        }
+    if (!strcmp(command, "gsec_create")) {
+        ret = write_contents_to_common_pem_file(dict, output_count);
+        if (!ret)
+            goto out;
+    }
 
-        ret = dict_get_str (dict, "command", &command);
+    for (i = 1; i <= output_count; i++) {
+        snprintf(output_name, sizeof(output_name), "output_%d", i);
+        ret = dict_get_str(dict, output_name, &output);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                        "Unable to get command from dict");
-                goto out;
+            gf_log("", GF_LOG_ERROR, "Failed to get %s.", output_name);
+            cli_out("Unable to fetch output.");
         }
-
-        if (!strcmp (command, "gsec_create")) {
-                ret = write_contents_to_common_pem_file (dict, output_count);
-                if (!ret)
-                        goto out;
+        if (output) {
+            cli_out("%s", output);
+            output = NULL;
         }
+    }
 
-        for (i = 1; i <= output_count; i++) {
-                snprintf (output_name, sizeof (output_name),
-                          "output_%d", i);
-                ret = dict_get_str (dict, output_name, &output);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Failed to get %s.",
-                                output_name);
-                        cli_out ("Unable to fetch output.");
-                }
-                if (output) {
-                        cli_out ("%s", output);
-                        output = NULL;
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_copy_file_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
+gf_cli_copy_file_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        int                     ret     = -1;
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (req->rpc_status == -1) {
-                goto out;
-        }
+    if (req->rpc_status == -1) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-       }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        dict = dict_new ();
+    dict = dict_new();
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-       if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         "Copy unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (rsp.op_ret) {
+        cli_err("%s", rsp.op_errstr ? rsp.op_errstr : "Copy unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        cli_out ("Successfully copied file.");
+    cli_out("Successfully copied file.");
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_gsync_set_cbk (struct rpc_req *req, struct iovec *iov,
-                         int count, void *myframe)
-{
-        int                     ret     = -1;
-        gf_cli_rsp              rsp     = {0, };
-        dict_t                  *dict   = NULL;
-        char                    *gsync_status = NULL;
-        char                    *master = NULL;
-        char                    *slave  = NULL;
-        int32_t                  type   = 0;
-        gf_boolean_t             status_detail = _gf_false;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-
+gf_cli_gsync_set_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *gsync_status = NULL;
+    char *master = NULL;
+    char *slave = NULL;
+    int32_t type = 0;
+    gf_boolean_t status_detail = _gf_false;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_gsync(dict, rsp.op_ret, rsp.op_errno,
+                                       rsp.op_errstr);
         if (ret)
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_gsync (dict, rsp.op_ret, rsp.op_errno,
-                                                rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
-                         GEOREP" command unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "gsync-status", &gsync_status);
-        if (!ret)
-                cli_out ("%s", gsync_status);
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "failed to get type");
-                goto out;
-        }
-
-        switch (type) {
-                case GF_GSYNC_OPTION_TYPE_START:
-                case GF_GSYNC_OPTION_TYPE_STOP:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-
-                        cli_out ("%s " GEOREP " session between %s & %s"
-                                 " has been successful",
-                                 type == GF_GSYNC_OPTION_TYPE_START ?
-                                  "Starting" : "Stopping",
-                                 master, slave);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_PAUSE:
-                case GF_GSYNC_OPTION_TYPE_RESUME:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-
-                        cli_out ("%s " GEOREP " session between %s & %s"
-                                 " has been successful",
-                                 type == GF_GSYNC_OPTION_TYPE_PAUSE ?
-                                  "Pausing" : "Resuming",
-                                 master, slave);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_CONFIG:
-                        ret = gf_cli_gsync_config_command (dict);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_STATUS:
-                        status_detail = dict_get_str_boolean (dict,
-                                                              "status-detail",
-                                                              _gf_false);
-                        ret = gf_cli_gsync_status_output (dict, status_detail);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_DELETE:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-                        cli_out ("Deleting " GEOREP " session between %s & %s"
-                                 " has been successful", master, slave);
-                break;
-
-                case GF_GSYNC_OPTION_TYPE_CREATE:
-                        if (dict_get_str (dict, "master", &master) != 0)
-                                master = "???";
-                        if (dict_get_str (dict, "slave", &slave) != 0)
-                                slave = "???";
-                        cli_out ("Creating " GEOREP " session between %s & %s"
-                                 " has been successful", master, slave);
-                break;
+    if (rsp.op_ret) {
+        cli_err("%s",
+                rsp.op_errstr ? rsp.op_errstr : GEOREP " command unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "gsync-status", &gsync_status);
+    if (!ret)
+        cli_out("%s", gsync_status);
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "failed to get type");
+        goto out;
+    }
+
+    switch (type) {
+        case GF_GSYNC_OPTION_TYPE_START:
+        case GF_GSYNC_OPTION_TYPE_STOP:
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
+
+            cli_out(
+                "%s " GEOREP
+                " session between %s & %s"
+                " has been successful",
+                type == GF_GSYNC_OPTION_TYPE_START ? "Starting" : "Stopping",
+                master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_PAUSE:
+        case GF_GSYNC_OPTION_TYPE_RESUME:
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
+
+            cli_out("%s " GEOREP
+                    " session between %s & %s"
+                    " has been successful",
+                    type == GF_GSYNC_OPTION_TYPE_PAUSE ? "Pausing" : "Resuming",
+                    master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_CONFIG:
+            ret = gf_cli_gsync_config_command(dict);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_STATUS:
+            status_detail = dict_get_str_boolean(dict, "status-detail",
+                                                 _gf_false);
+            ret = gf_cli_gsync_status_output(dict, status_detail);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_DELETE:
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
+            cli_out("Deleting " GEOREP
+                    " session between %s & %s"
+                    " has been successful",
+                    master, slave);
+            break;
+
+        case GF_GSYNC_OPTION_TYPE_CREATE:
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
+            cli_out("Creating " GEOREP
+                    " session between %s & %s"
+                    " has been successful",
+                    master, slave);
+            break;
 
-                default:
-                        cli_out (GEOREP" command executed successfully");
-        }
+        default:
+            cli_out(GEOREP " command executed successfully");
+    }
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
+    free(rsp.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_sys_exec (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_sys_exec(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid data");
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid data");
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_sys_exec_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_SYS_EXEC, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_sys_exec_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_SYS_EXEC,
+                          this, cli_rpc_prog, NULL);
 out:
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_copy_file (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_copy_file(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "Invalid data");
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR, "Invalid data");
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_copy_file_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_COPY_FILE, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_copy_file_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_COPY_FILE, this, cli_rpc_prog, NULL);
 out:
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_gsync_set (call_frame_t *frame, xlator_t *this,
-                     void *data)
+gf_cli_gsync_set(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret    = 0;
-        dict_t                  *dict   = NULL;
-        gf_cli_req               req = {{0,}};
+    int ret = 0;
+    dict_t *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        if (!frame || !this || !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_gsync_set_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_GSYNC_SET, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_gsync_set_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_GSYNC_SET, this, cli_rpc_prog, NULL);
 
 out:
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_profile_info_percentage_cmp (void *a, void *b)
-{
-        cli_profile_info_t *ia = NULL;
-        cli_profile_info_t *ib = NULL;
-        int                ret = 0;
-
-        ia = a;
-        ib = b;
-        if (ia->percentage_avg_latency < ib->percentage_avg_latency)
-                ret = -1;
-        else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
-                ret = 1;
-        else
-                ret = 0;
-        return ret;
+cli_profile_info_percentage_cmp(void *a, void *b)
+{
+    cli_profile_info_t *ia = NULL;
+    cli_profile_info_t *ib = NULL;
+    int ret = 0;
+
+    ia = a;
+    ib = b;
+    if (ia->percentage_avg_latency < ib->percentage_avg_latency)
+        ret = -1;
+    else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
+        ret = 1;
+    else
+        ret = 0;
+    return ret;
 }
 
-
 void
-cmd_profile_volume_brick_out (dict_t *dict, int count, int interval)
-{
-        char                    key[256] = {0};
-        int                     i = 0;
-        uint64_t                sec = 0;
-        uint64_t                r_count = 0;
-        uint64_t                w_count = 0;
-        uint64_t                rb_counts[32] = {0};
-        uint64_t                wb_counts[32] = {0};
-        cli_profile_info_t      profile_info[GF_FOP_MAXVALUE] = {{0}};
-        cli_profile_info_t      upcall_info[GF_UPCALL_FLAGS_MAXVALUE] = {{0},};
-        char                    output[128] = {0};
-        int                     per_line = 0;
-        char                    read_blocks[128] = {0};
-        char                    write_blocks[128] = {0};
-        int                     index = 0;
-        int                     is_header_printed = 0;
-        int                     ret = 0;
-        double                  total_percentage_latency = 0;
-
-        for (i = 0; i < 32; i++) {
-                snprintf (key, sizeof (key), "%d-%d-read-%d", count,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &rb_counts[i]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
+cmd_profile_volume_brick_out(dict_t *dict, int count, int interval)
+{
+    char key[256] = {0};
+    int i = 0;
+    uint64_t sec = 0;
+    uint64_t r_count = 0;
+    uint64_t w_count = 0;
+    uint64_t rb_counts[32] = {0};
+    uint64_t wb_counts[32] = {0};
+    cli_profile_info_t profile_info[GF_FOP_MAXVALUE] = {{0}};
+    cli_profile_info_t upcall_info[GF_UPCALL_FLAGS_MAXVALUE] = {
+        {0},
+    };
+    char output[128] = {0};
+    int per_line = 0;
+    char read_blocks[128] = {0};
+    char write_blocks[128] = {0};
+    int index = 0;
+    int is_header_printed = 0;
+    int ret = 0;
+    double total_percentage_latency = 0;
+
+    for (i = 0; i < 32; i++) {
+        snprintf(key, sizeof(key), "%d-%d-read-%d", count, interval, (1 << i));
+        ret = dict_get_uint64(dict, key, &rb_counts[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+    }
 
-        for (i = 0; i < 32; i++) {
-                snprintf (key, sizeof (key), "%d-%d-write-%d", count, interval,
-                          (1<<i));
-                ret = dict_get_uint64 (dict, key, &wb_counts[i]);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
+    for (i = 0; i < 32; i++) {
+        snprintf(key, sizeof(key), "%d-%d-write-%d", count, interval, (1 << i));
+        ret = dict_get_uint64(dict, key, &wb_counts[i]);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+    }
 
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                snprintf (key, sizeof (key), "%d-%d-%d-upcall-hits", count,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &upcall_info[i].fop_hits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-                upcall_info[i].fop_name = (char *)gf_upcall_list[i];
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-upcall-hits", count, interval, i);
+        ret = dict_get_uint64(dict, key, &upcall_info[i].fop_hits);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+        upcall_info[i].fop_name = (char *)gf_upcall_list[i];
+    }
 
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                snprintf (key, sizeof (key), "%d-%d-%d-hits", count,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &profile_info[i].fop_hits);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-
-                snprintf (key, sizeof (key), "%d-%d-%d-avglatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].avg_latency);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-
-                snprintf (key, sizeof (key), "%d-%d-%d-minlatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].min_latency);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-
-                snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", count,
-                          interval, i);
-                ret = dict_get_double (dict, key, &profile_info[i].max_latency);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get %s from dict", key);
-                }
-                profile_info[i].fop_name = (char *)gf_fop_list[i];
-
-                total_percentage_latency +=
-                       (profile_info[i].fop_hits * profile_info[i].avg_latency);
-        }
-        if (total_percentage_latency) {
-                for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                        profile_info[i].percentage_avg_latency = 100 * (
-                     (profile_info[i].avg_latency* profile_info[i].fop_hits) /
-                                total_percentage_latency);
-                }
-                gf_array_insertionsort (profile_info, 1, GF_FOP_MAXVALUE - 1,
-                                    sizeof (cli_profile_info_t),
-                                    cli_profile_info_percentage_cmp);
-        }
-        snprintf (key, sizeof (key), "%d-%d-duration", count, interval);
-        ret = dict_get_uint64 (dict, key, &sec);
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-hits", count, interval, i);
+        ret = dict_get_uint64(dict, key, &profile_info[i].fop_hits);
         if (ret) {
-                gf_log ("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        snprintf (key, sizeof (key), "%d-%d-total-read", count, interval);
-        ret = dict_get_uint64 (dict, key, &r_count);
+        snprintf(key, sizeof(key), "%d-%d-%d-avglatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].avg_latency);
         if (ret) {
-                gf_log ("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        snprintf (key, sizeof (key), "%d-%d-total-write", count, interval);
-        ret = dict_get_uint64 (dict, key, &w_count);
+        snprintf(key, sizeof(key), "%d-%d-%d-minlatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].min_latency);
         if (ret) {
-                gf_log ("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
 
-        if (interval == -1)
-                cli_out ("Cumulative Stats:");
-        else
-                cli_out ("Interval %d Stats:", interval);
-        snprintf (output, sizeof (output), "%14s", "Block Size:");
-        snprintf (read_blocks, sizeof (read_blocks), "%14s", "No. of Reads:");
-        snprintf (write_blocks, sizeof (write_blocks), "%14s", "No. of Writes:");
-        index = 14;
-        for (i = 0; i < 32; i++) {
-                if ((rb_counts[i] == 0) && (wb_counts[i] == 0))
-                        continue;
-                per_line++;
-                snprintf (output+index, sizeof (output)-index, "%19db+ ", (1<<i));
-                if (rb_counts[i]) {
-                        snprintf (read_blocks+index, sizeof (read_blocks)-index,
-                                  "%21"PRId64" ", rb_counts[i]);
-                } else {
-                        snprintf (read_blocks+index, sizeof (read_blocks)-index,
-                                  "%21s ", "0");
-                }
-                if (wb_counts[i]) {
-                        snprintf (write_blocks+index, sizeof (write_blocks)-index,
-                                  "%21"PRId64" ", wb_counts[i]);
-                } else {
-                        snprintf (write_blocks+index, sizeof (write_blocks)-index,
-                                  "%21s ", "0");
-                }
-                index += 22;
-                if (per_line == 3) {
-                        cli_out ("%s", output);
-                        cli_out ("%s", read_blocks);
-                        cli_out ("%s", write_blocks);
-                        cli_out (" ");
-                        per_line = 0;
-                        snprintf (output, sizeof (output), "%14s", "Block Size:");
-                        snprintf (read_blocks, sizeof (read_blocks), "%14s",
-                                  "No. of Reads:");
-                        snprintf (write_blocks, sizeof (write_blocks), "%14s",
-                                  "No. of Writes:");
-                        index = 14;
-                }
+        snprintf(key, sizeof(key), "%d-%d-%d-maxlatency", count, interval, i);
+        ret = dict_get_double(dict, key, &profile_info[i].max_latency);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
         }
+        profile_info[i].fop_name = (char *)gf_fop_list[i];
 
-        if (per_line != 0) {
-                cli_out ("%s", output);
-                cli_out ("%s", read_blocks);
-                cli_out ("%s", write_blocks);
-        }
+        total_percentage_latency += (profile_info[i].fop_hits *
+                                     profile_info[i].avg_latency);
+    }
+    if (total_percentage_latency) {
         for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                if (profile_info[i].fop_hits == 0)
-                        continue;
-                if (is_header_printed == 0) {
-                        cli_out ("%10s %13s %13s %13s %14s %11s", "%-latency",
-                                 "Avg-latency", "Min-Latency", "Max-Latency",
-                                 "No. of calls", "Fop");
-                        cli_out ("%10s %13s %13s %13s %14s %11s", "---------",
-                                 "-----------", "-----------", "-----------",
-                                 "------------", "----");
-                        is_header_printed = 1;
-                }
-                if (profile_info[i].fop_hits) {
-                        cli_out ("%10.2lf %10.2lf us %10.2lf us %10.2lf us"
-                                 " %14"PRId64" %11s",
-                                 profile_info[i].percentage_avg_latency,
-                                 profile_info[i].avg_latency,
-                                 profile_info[i].min_latency,
-                                 profile_info[i].max_latency,
-                                 profile_info[i].fop_hits,
-                                 profile_info[i].fop_name);
-                }
-        }
-
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                if (upcall_info[i].fop_hits == 0)
-                        continue;
-                if (upcall_info[i].fop_hits) {
-                        cli_out ("%10.2lf %10.2lf us %10.2lf us %10.2lf us"
-                                 " %14"PRId64" %11s",
-                                 upcall_info[i].percentage_avg_latency,
-                                 upcall_info[i].avg_latency,
-                                 upcall_info[i].min_latency,
-                                 upcall_info[i].max_latency,
-                                 upcall_info[i].fop_hits,
-                                 upcall_info[i].fop_name);
-                }
+            profile_info[i]
+                .percentage_avg_latency = 100 * ((profile_info[i].avg_latency *
+                                                  profile_info[i].fop_hits) /
+                                                 total_percentage_latency);
+        }
+        gf_array_insertionsort(profile_info, 1, GF_FOP_MAXVALUE - 1,
+                               sizeof(cli_profile_info_t),
+                               cli_profile_info_percentage_cmp);
+    }
+    snprintf(key, sizeof(key), "%d-%d-duration", count, interval);
+    ret = dict_get_uint64(dict, key, &sec);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    snprintf(key, sizeof(key), "%d-%d-total-read", count, interval);
+    ret = dict_get_uint64(dict, key, &r_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    snprintf(key, sizeof(key), "%d-%d-total-write", count, interval);
+    ret = dict_get_uint64(dict, key, &w_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_DEBUG, "failed to get %s from dict", key);
+    }
+
+    if (interval == -1)
+        cli_out("Cumulative Stats:");
+    else
+        cli_out("Interval %d Stats:", interval);
+    snprintf(output, sizeof(output), "%14s", "Block Size:");
+    snprintf(read_blocks, sizeof(read_blocks), "%14s", "No. of Reads:");
+    snprintf(write_blocks, sizeof(write_blocks), "%14s", "No. of Writes:");
+    index = 14;
+    for (i = 0; i < 32; i++) {
+        if ((rb_counts[i] == 0) && (wb_counts[i] == 0))
+            continue;
+        per_line++;
+        snprintf(output + index, sizeof(output) - index, "%19db+ ", (1 << i));
+        if (rb_counts[i]) {
+            snprintf(read_blocks + index, sizeof(read_blocks) - index,
+                     "%21" PRId64 " ", rb_counts[i]);
+        } else {
+            snprintf(read_blocks + index, sizeof(read_blocks) - index, "%21s ",
+                     "0");
         }
-
-        cli_out (" ");
-        cli_out ("%12s: %"PRId64" seconds", "Duration", sec);
-        cli_out ("%12s: %"PRId64" bytes", "Data Read", r_count);
-        cli_out ("%12s: %"PRId64" bytes", "Data Written", w_count);
-        cli_out (" ");
+        if (wb_counts[i]) {
+            snprintf(write_blocks + index, sizeof(write_blocks) - index,
+                     "%21" PRId64 " ", wb_counts[i]);
+        } else {
+            snprintf(write_blocks + index, sizeof(write_blocks) - index,
+                     "%21s ", "0");
+        }
+        index += 22;
+        if (per_line == 3) {
+            cli_out("%s", output);
+            cli_out("%s", read_blocks);
+            cli_out("%s", write_blocks);
+            cli_out(" ");
+            per_line = 0;
+            snprintf(output, sizeof(output), "%14s", "Block Size:");
+            snprintf(read_blocks, sizeof(read_blocks), "%14s", "No. of Reads:");
+            snprintf(write_blocks, sizeof(write_blocks), "%14s",
+                     "No. of Writes:");
+            index = 14;
+        }
+    }
+
+    if (per_line != 0) {
+        cli_out("%s", output);
+        cli_out("%s", read_blocks);
+        cli_out("%s", write_blocks);
+    }
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        if (profile_info[i].fop_hits == 0)
+            continue;
+        if (is_header_printed == 0) {
+            cli_out("%10s %13s %13s %13s %14s %11s", "%-latency", "Avg-latency",
+                    "Min-Latency", "Max-Latency", "No. of calls", "Fop");
+            cli_out("%10s %13s %13s %13s %14s %11s", "---------", "-----------",
+                    "-----------", "-----------", "------------", "----");
+            is_header_printed = 1;
+        }
+        if (profile_info[i].fop_hits) {
+            cli_out(
+                "%10.2lf %10.2lf us %10.2lf us %10.2lf us"
+                " %14" PRId64 " %11s",
+                profile_info[i].percentage_avg_latency,
+                profile_info[i].avg_latency, profile_info[i].min_latency,
+                profile_info[i].max_latency, profile_info[i].fop_hits,
+                profile_info[i].fop_name);
+        }
+    }
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        if (upcall_info[i].fop_hits == 0)
+            continue;
+        if (upcall_info[i].fop_hits) {
+            cli_out(
+                "%10.2lf %10.2lf us %10.2lf us %10.2lf us"
+                " %14" PRId64 " %11s",
+                upcall_info[i].percentage_avg_latency,
+                upcall_info[i].avg_latency, upcall_info[i].min_latency,
+                upcall_info[i].max_latency, upcall_info[i].fop_hits,
+                upcall_info[i].fop_name);
+        }
+    }
+
+    cli_out(" ");
+    cli_out("%12s: %" PRId64 " seconds", "Duration", sec);
+    cli_out("%12s: %" PRId64 " bytes", "Data Read", r_count);
+    cli_out("%12s: %" PRId64 " bytes", "Data Written", w_count);
+    cli_out(" ");
 }
 
 int32_t
-gf_cli_profile_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                              int count, void *myframe)
-{
-        gf_cli_rsp                        rsp   = {0,};
-        int                               ret   = -1;
-        dict_t                            *dict = NULL;
-        gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
-        char                              key[256] = {0};
-        int                               interval = 0;
-        int                               i = 1;
-        int32_t                           brick_count = 0;
-        char                              *volname = NULL;
-        char                              *brick = NULL;
-        char                              str[1024] = {0,};
-        int                               stats_cleared = 0;
-        gf1_cli_info_op                   info_op = GF_CLI_INFO_NONE;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
+gf_cli_profile_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    char key[256] = {0};
+    int interval = 0;
+    int i = 1;
+    int32_t brick_count = 0;
+    char *volname = NULL;
+    char *brick = NULL;
+    char str[1024] = {
+        0,
+    };
+    int stats_cleared = 0;
+    gf1_cli_info_op info_op = GF_CLI_INFO_NONE;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to profile");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to allocate memory");
+        goto out;
+    } else {
+        dict->extra_stdfree = rsp.dict.dict_val;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_profile(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "op", (int32_t *)&op);
+    if (ret)
+        goto out;
+
+    if (rsp.op_ret && strcmp(rsp.op_errstr, "")) {
+        cli_err("%s", rsp.op_errstr);
+    } else {
+        switch (op) {
+            case GF_CLI_STATS_START:
+                cli_out("Starting volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
+            case GF_CLI_STATS_STOP:
+                cli_out("Stopping volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
+            case GF_CLI_STATS_INFO:
+                break;
+            default:
+                cli_out("volume profile on %s has been %s ", volname,
+                        (rsp.op_ret) ? "unsuccessful" : "successful");
+                break;
         }
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to profile");
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    if (rsp.op_ret) {
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        dict = dict_new ();
+    if (GF_CLI_STATS_INFO != op) {
+        ret = 0;
+        goto out;
+    }
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    ret = dict_get_int32(dict, "info-op", (int32_t *)&info_op);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
+    if (!brick_count) {
+        cli_err("All bricks of volume %s are down.", volname);
+        goto out;
+    }
 
+    while (i <= brick_count) {
+        snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_str(dict, key, &brick);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
-        } else {
-                dict->extra_stdfree = rsp.dict.dict_val;
+            gf_log("cli", GF_LOG_ERROR, "Couldn't get brick name");
+            goto out;
         }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_profile (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+        ret = dict_get_str_boolean(dict, "nfs", _gf_false);
 
-        ret = dict_get_str (dict, "volname", &volname);
         if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "op", (int32_t*)&op);
-        if (ret)
-                goto out;
-
-        if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
-                cli_err ("%s", rsp.op_errstr);
+            snprintf(str, sizeof(str), "NFS Server : %s", brick);
+        else
+            snprintf(str, sizeof(str), "Brick: %s", brick);
+        cli_out("%s", str);
+        memset(str, '-', strlen(str));
+        cli_out("%s", str);
+
+        if (GF_CLI_INFO_CLEAR == info_op) {
+            snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32(dict, key, &stats_cleared);
+            if (ret)
+                goto out;
+            cli_out(stats_cleared ? "Cleared stats."
+                                  : "Failed to clear stats.");
         } else {
-                switch (op) {
-                case GF_CLI_STATS_START:
-                        cli_out ("Starting volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                case GF_CLI_STATS_STOP:
-                        cli_out ("Stopping volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                case GF_CLI_STATS_INFO:
-                        break;
-                default:
-                        cli_out ("volume profile on %s has been %s ",
-                                 volname,
-                                 (rsp.op_ret) ? "unsuccessful": "successful");
-                        break;
-                }
-        }
-
-        if (rsp.op_ret) {
-                ret = rsp.op_ret;
-                goto out;
-        }
+            snprintf(key, sizeof(key), "%d-cumulative", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0)
+                cmd_profile_volume_brick_out(dict, i, interval);
 
-        if (GF_CLI_STATS_INFO != op) {
-                ret = 0;
-                goto out;
+            snprintf(key, sizeof(key), "%d-interval", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0)
+                cmd_profile_volume_brick_out(dict, i, interval);
         }
-
-        ret = dict_get_int32 (dict, "info-op", (int32_t*)&info_op);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-
-        if (!brick_count) {
-                cli_err ("All bricks of volume %s are down.", volname);
-                goto out;
-        }
-
-        while (i <= brick_count) {
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Couldn't get brick name");
-                        goto out;
-                }
-
-                ret = dict_get_str_boolean (dict, "nfs", _gf_false);
-
-                if (ret)
-                        snprintf (str, sizeof (str), "NFS Server : %s", brick);
-                else
-                        snprintf (str, sizeof (str), "Brick: %s", brick);
-                cli_out ("%s", str);
-                memset (str, '-', strlen (str));
-                cli_out ("%s", str);
-
-                if (GF_CLI_INFO_CLEAR == info_op) {
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-                        cli_out (stats_cleared ? "Cleared stats." :
-                                                 "Failed to clear stats.");
-                } else {
-                        snprintf (key, sizeof (key), "%d-cumulative", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0)
-                                cmd_profile_volume_brick_out (dict, i,
-                                                              interval);
-
-                        snprintf (key, sizeof (key), "%d-interval", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0)
-                                cmd_profile_volume_brick_out (dict, i,
-                                                              interval);
-                }
-                i++;
-        }
-        ret = rsp.op_ret;
+        i++;
+    }
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (rsp.op_errstr);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(rsp.op_errstr);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_profile_volume (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_profile_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                        ret   = -1;
-        gf_cli_req                 req   = {{0,}};
-        dict_t                     *dict = NULL;
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
+    if (!frame || !this || !data)
+        goto out;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_profile_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_profile_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_top_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                              int count, void *myframe)
-{
-        gf_cli_rsp                        rsp   = {0,};
-        int                               ret   = -1;
-        dict_t                           *dict = NULL;
-        gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
-        char                              key[256] = {0};
-        int                               i = 0;
-        int32_t                           brick_count = 0;
-        char                              brick[1024];
-        int32_t                           members = 0;
-        char                             *filename;
-        char                             *bricks;
-        uint64_t                          value = 0;
-        int32_t                           j = 0;
-        gf1_cli_top_op                    top_op = GF_CLI_TOP_NONE;
-        uint64_t                          nr_open = 0;
-        uint64_t                          max_nr_open = 0;
-        double                            throughput = 0;
-        double                            time = 0;
-        int32_t                           time_sec = 0;
-        long int                          time_usec = 0;
-        char                              timestr[256] = {0, };
-        char                             *openfd_str = NULL;
-        gf_boolean_t                      nfs = _gf_false;
-        gf_boolean_t                      clear_stats = _gf_false;
-        int                               stats_cleared = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+gf_cli_top_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    gf1_cli_stats_op op = GF_CLI_STATS_NONE;
+    char key[256] = {0};
+    int i = 0;
+    int32_t brick_count = 0;
+    char brick[1024];
+    int32_t members = 0;
+    char *filename;
+    char *bricks;
+    uint64_t value = 0;
+    int32_t j = 0;
+    gf1_cli_top_op top_op = GF_CLI_TOP_NONE;
+    uint64_t nr_open = 0;
+    uint64_t max_nr_open = 0;
+    double throughput = 0;
+    double time = 0;
+    int32_t time_sec = 0;
+    long int time_usec = 0;
+    char timestr[256] = {
+        0,
+    };
+    char *openfd_str = NULL;
+    gf_boolean_t nfs = _gf_false;
+    gf_boolean_t clear_stats = _gf_false;
+    int stats_cleared = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to top");
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("%s", rsp.op_errstr);
+        cli_err("volume top unsuccessful");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to top");
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    dict = dict_new();
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("%s", rsp.op_errstr);
-                cli_err ("volume top unsuccessful");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = dict_new ();
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to allocate memory");
+        goto out;
+    }
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
+    ret = dict_get_int32(dict, "op", (int32_t *)&op);
 
+    if (op != GF_CLI_STATS_TOP) {
+        ret = 0;
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_top(dict, rsp.op_ret, rsp.op_errno,
+                                     rsp.op_errstr);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
         }
+        goto out;
+    }
 
-        ret = dict_get_int32 (dict, "op", (int32_t*)&op);
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof(key), "%d-top-op", 1);
+    ret = dict_get_int32(dict, key, (int32_t *)&top_op);
+    if (ret)
+        goto out;
 
-        if (op != GF_CLI_STATS_TOP) {
-                ret = 0;
+    clear_stats = dict_get_str_boolean(dict, "clear-stats", _gf_false);
+
+    while (i < brick_count) {
+        i++;
+        snprintf(brick, sizeof(brick), "%d-brick", i);
+        ret = dict_get_str(dict, brick, &bricks);
+        if (ret)
+            goto out;
+
+        nfs = dict_get_str_boolean(dict, "nfs", _gf_false);
+
+        if (clear_stats) {
+            snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32(dict, key, &stats_cleared);
+            if (ret)
                 goto out;
+            cli_out(stats_cleared ? "Cleared stats for %s %s"
+                                  : "Failed to clear stats for %s %s",
+                    nfs ? "NFS server on" : "brick", bricks);
+            continue;
         }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_top (dict, rsp.op_ret,
-                                              rsp.op_errno,
-                                              rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+        if (nfs)
+            cli_out("NFS Server : %s", bricks);
+        else
+            cli_out("Brick: %s", bricks);
+
+        snprintf(key, sizeof(key), "%d-members", i);
+        ret = dict_get_int32(dict, key, &members);
+
+        switch (top_op) {
+            case GF_CLI_TOP_OPEN:
+                snprintf(key, sizeof(key), "%d-current-open", i);
+                ret = dict_get_uint64(dict, key, &nr_open);
+                if (ret)
+                    break;
+                snprintf(key, sizeof(key), "%d-max-open", i);
+                ret = dict_get_uint64(dict, key, &max_nr_open);
+                if (ret)
+                    goto out;
+                snprintf(key, sizeof(key), "%d-max-openfd-time", i);
+                ret = dict_get_str(dict, key, &openfd_str);
+                if (ret)
+                    goto out;
+                cli_out("Current open fds: %" PRIu64
+                        ", Max open"
+                        " fds: %" PRIu64 ", Max openfd time: %s",
+                        nr_open, max_nr_open, openfd_str);
+            case GF_CLI_TOP_READ:
+            case GF_CLI_TOP_WRITE:
+            case GF_CLI_TOP_OPENDIR:
+            case GF_CLI_TOP_READDIR:
+                if (!members) {
+                    continue;
+                }
+                cli_out("Count\t\tfilename\n=======================");
+                break;
+            case GF_CLI_TOP_READ_PERF:
+            case GF_CLI_TOP_WRITE_PERF:
+                snprintf(key, sizeof(key), "%d-throughput", i);
+                ret = dict_get_double(dict, key, &throughput);
+                if (!ret) {
+                    snprintf(key, sizeof(key), "%d-time", i);
+                    ret = dict_get_double(dict, key, &time);
                 }
+                if (!ret)
+                    cli_out("Throughput %.2f MBps time %.4f secs", throughput,
+                            time / 1e6);
+
+                if (!members) {
+                    continue;
+                }
+                cli_out("%*s %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH, "MBps",
+                        VOL_TOP_PERF_FILENAME_DEF_WIDTH, "Filename",
+                        VOL_TOP_PERF_TIME_WIDTH, "Time");
+                cli_out("%*s %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH,
+                        "====", VOL_TOP_PERF_FILENAME_DEF_WIDTH,
+                        "========", VOL_TOP_PERF_TIME_WIDTH, "====");
+                break;
+            default:
                 goto out;
         }
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof (key), "%d-top-op", 1);
-        ret = dict_get_int32 (dict, key, (int32_t*)&top_op);
-        if (ret)
-                goto out;
-
-        clear_stats = dict_get_str_boolean (dict, "clear-stats", _gf_false);
-
-        while (i < brick_count) {
-                i++;
-                snprintf (brick, sizeof (brick), "%d-brick", i);
-                ret = dict_get_str (dict, brick, &bricks);
-                if (ret)
-                        goto out;
-
-                nfs = dict_get_str_boolean (dict, "nfs", _gf_false);
-
-                if (clear_stats) {
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-                        cli_out (stats_cleared ? "Cleared stats for %s %s" :
-                                 "Failed to clear stats for %s %s",
-                                 nfs ? "NFS server on" : "brick", bricks);
-                        continue;
-                }
-
-                if (nfs)
-                        cli_out ("NFS Server : %s", bricks);
+        for (j = 1; j <= members; j++) {
+            snprintf(key, sizeof(key), "%d-filename-%d", i, j);
+            ret = dict_get_str(dict, key, &filename);
+            if (ret)
+                break;
+            snprintf(key, sizeof(key), "%d-value-%d", i, j);
+            ret = dict_get_uint64(dict, key, &value);
+            if (ret)
+                goto out;
+            if (top_op == GF_CLI_TOP_READ_PERF ||
+                top_op == GF_CLI_TOP_WRITE_PERF) {
+                snprintf(key, sizeof(key), "%d-time-sec-%d", i, j);
+                ret = dict_get_int32(dict, key, (int32_t *)&time_sec);
+                if (ret)
+                    goto out;
+                snprintf(key, sizeof(key), "%d-time-usec-%d", i, j);
+                ret = dict_get_int32(dict, key, (int32_t *)&time_usec);
+                if (ret)
+                    goto out;
+                gf_time_fmt(timestr, sizeof timestr, time_sec, gf_timefmt_FT);
+                snprintf(timestr + strlen(timestr),
+                         sizeof timestr - strlen(timestr), ".%ld", time_usec);
+                if (strlen(filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH)
+                    cli_out("%*" PRIu64 " %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH,
+                            value, VOL_TOP_PERF_FILENAME_DEF_WIDTH, filename,
+                            VOL_TOP_PERF_TIME_WIDTH, timestr);
                 else
-                        cli_out ("Brick: %s", bricks);
-
-                snprintf(key, sizeof (key), "%d-members", i);
-                ret = dict_get_int32 (dict, key, &members);
-
-                switch (top_op) {
-                case GF_CLI_TOP_OPEN:
-                        snprintf (key, sizeof (key), "%d-current-open", i);
-                        ret = dict_get_uint64 (dict, key, &nr_open);
-                        if (ret)
-                                break;
-                        snprintf (key, sizeof (key), "%d-max-open", i);
-                        ret = dict_get_uint64 (dict, key, &max_nr_open);
-                        if (ret)
-                                goto out;
-                        snprintf (key, sizeof (key), "%d-max-openfd-time", i);
-                        ret = dict_get_str (dict, key, &openfd_str);
-                        if (ret)
-                                goto out;
-                        cli_out ("Current open fds: %"PRIu64", Max open"
-                                " fds: %"PRIu64", Max openfd time: %s", nr_open,
-                                 max_nr_open, openfd_str);
-                case GF_CLI_TOP_READ:
-                case GF_CLI_TOP_WRITE:
-                case GF_CLI_TOP_OPENDIR:
-                case GF_CLI_TOP_READDIR:
-                        if (!members) {
-                                continue;
-                        }
-                        cli_out ("Count\t\tfilename\n=======================");
-                        break;
-                case GF_CLI_TOP_READ_PERF:
-                case GF_CLI_TOP_WRITE_PERF:
-                        snprintf (key, sizeof (key), "%d-throughput", i);
-                        ret = dict_get_double (dict, key, &throughput);
-                        if (!ret) {
-                                snprintf (key, sizeof (key), "%d-time", i);
-                                ret = dict_get_double (dict, key, &time);
-                        }
-                        if (!ret)
-                                cli_out ("Throughput %.2f MBps time %.4f secs", throughput,
-                                          time / 1e6);
-
-                        if (!members) {
-                                continue;
-                        }
-                        cli_out ("%*s %-*s %-*s",
-                                 VOL_TOP_PERF_SPEED_WIDTH, "MBps",
-                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH, "Filename",
-                                 VOL_TOP_PERF_TIME_WIDTH, "Time");
-                        cli_out ("%*s %-*s %-*s",
-                                 VOL_TOP_PERF_SPEED_WIDTH, "====",
-                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH, "========",
-                                 VOL_TOP_PERF_TIME_WIDTH, "====");
-                        break;
-                default:
-                        goto out;
-                }
-
-                for (j = 1; j <= members; j++) {
-                        snprintf (key, sizeof (key), "%d-filename-%d", i, j);
-                        ret = dict_get_str (dict, key, &filename);
-                        if (ret)
-                                break;
-                        snprintf (key, sizeof (key), "%d-value-%d", i, j);
-                        ret = dict_get_uint64 (dict, key, &value);
-                        if (ret)
-                                goto out;
-                        if ( top_op == GF_CLI_TOP_READ_PERF ||
-                                top_op == GF_CLI_TOP_WRITE_PERF) {
-                                snprintf (key, sizeof (key), "%d-time-sec-%d", i, j);
-                                ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
-                                if (ret)
-                                        goto out;
-                                snprintf (key, sizeof (key), "%d-time-usec-%d", i, j);
-                                ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
-                                if (ret)
-                                        goto out;
-                                gf_time_fmt (timestr, sizeof timestr,
-                                             time_sec, gf_timefmt_FT);
-                                snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                                  ".%ld", time_usec);
-                                if (strlen (filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH)
-                                        cli_out ("%*"PRIu64" %-*s %-*s",
-                                                 VOL_TOP_PERF_SPEED_WIDTH,
-                                                 value,
-                                                 VOL_TOP_PERF_FILENAME_DEF_WIDTH,
-                                                 filename,
-                                                 VOL_TOP_PERF_TIME_WIDTH,
-                                                 timestr);
-                                else
-                                        cli_out ("%*"PRIu64" ...%-*s %-*s",
-                                                 VOL_TOP_PERF_SPEED_WIDTH,
-                                                 value,
-                                                 VOL_TOP_PERF_FILENAME_ALT_WIDTH ,
-                                                 filename + strlen (filename) -
-                                                 VOL_TOP_PERF_FILENAME_ALT_WIDTH,
-                                                 VOL_TOP_PERF_TIME_WIDTH,
-                                                 timestr);
-                        } else {
-                                cli_out ("%"PRIu64"\t\t%s", value, filename);
-                        }
-                }
+                    cli_out("%*" PRIu64 " ...%-*s %-*s",
+                            VOL_TOP_PERF_SPEED_WIDTH, value,
+                            VOL_TOP_PERF_FILENAME_ALT_WIDTH,
+                            filename + strlen(filename) -
+                                VOL_TOP_PERF_FILENAME_ALT_WIDTH,
+                            VOL_TOP_PERF_TIME_WIDTH, timestr);
+            } else {
+                cli_out("%" PRIu64 "\t\t%s", value, filename);
+            }
         }
-        ret = rsp.op_ret;
+    }
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
-        return ret;
+    free(rsp.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_top_volume (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_top_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                        ret   = -1;
-        gf_cli_req                 req   = {{0,}};
-        dict_t                     *dict = NULL;
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *dict = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
-        GF_ASSERT (data);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
+    GF_ASSERT(data);
 
-        if (!frame || !this || !data)
-                goto out;
-        dict = data;
+    if (!frame || !this || !data)
+        goto out;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_top_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_top_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
-
 int
-gf_cli_getwd_cbk (struct rpc_req *req, struct iovec *iov,
-                       int count, void *myframe)
+gf_cli_getwd_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf1_cli_getwd_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_getwd_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_getwd_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_getwd_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        if (rsp.op_ret == -1) {
-                cli_err ("getwd failed");
-                ret = rsp.op_ret;
-                goto out;
-        }
+    if (rsp.op_ret == -1) {
+        cli_err("getwd failed");
+        ret = rsp.op_ret;
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to getwd");
+    gf_log("cli", GF_LOG_INFO, "Received resp to getwd");
 
-        cli_out ("%s", rsp.wd);
+    cli_out("%s", rsp.wd);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_getwd (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_getwd(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int                      ret = -1;
-        gf1_cli_getwd_req        req = {0,};
+    int ret = -1;
+    gf1_cli_getwd_req req = {
+        0,
+    };
 
-        GF_ASSERT (frame);
-        GF_ASSERT (this);
+    GF_ASSERT(frame);
+    GF_ASSERT(this);
 
-        if (!frame || !this)
-                goto out;
+    if (!frame || !this)
+        goto out;
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_GETWD, NULL,
-                              this, gf_cli_getwd_cbk,
-                              (xdrproc_t) xdr_gf1_cli_getwd_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_GETWD,
+                         NULL, this, gf_cli_getwd_cbk,
+                         (xdrproc_t)xdr_gf1_cli_getwd_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 void
-cli_print_volume_status_mempool (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        int32_t         mempool_count = 0;
-        char            *name = NULL;
-        int32_t         hotcount = 0;
-        int32_t         coldcount = 0;
-        uint64_t        paddedsizeof = 0;
-        uint64_t        alloccount = 0;
-        int32_t         maxalloc = 0;
-        uint64_t        pool_misses = 0;
-        int32_t         maxstdalloc = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
-
-        snprintf (key, sizeof (key), "%s.mempool-count",prefix);
-        ret = dict_get_int32 (dict, key, &mempool_count);
+cli_print_volume_status_mempool(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    int32_t mempool_count = 0;
+    char *name = NULL;
+    int32_t hotcount = 0;
+    int32_t coldcount = 0;
+    uint64_t paddedsizeof = 0;
+    uint64_t alloccount = 0;
+    int32_t maxalloc = 0;
+    uint64_t pool_misses = 0;
+    int32_t maxstdalloc = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.mempool-count", prefix);
+    ret = dict_get_int32(dict, key, &mempool_count);
+    if (ret)
+        goto out;
+
+    cli_out("Mempool Stats\n-------------");
+    cli_out("%-30s %9s %9s %12s %10s %8s %8s %12s", "Name", "HotCount",
+            "ColdCount", "PaddedSizeof", "AllocCount", "MaxAlloc", "Misses",
+            "Max-StdAlloc");
+    cli_out("%-30s %9s %9s %12s %10s %8s %8s %12s", "----", "--------",
+            "---------", "------------", "----------", "--------", "--------",
+            "------------");
+
+    for (i = 0; i < mempool_count; i++) {
+        snprintf(key, sizeof(key), "%s.pool%d.name", prefix, i);
+        ret = dict_get_str(dict, key, &name);
         if (ret)
-                goto out;
+            goto out;
 
-        cli_out ("Mempool Stats\n-------------");
-        cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "Name", "HotCount",
-                 "ColdCount", "PaddedSizeof", "AllocCount", "MaxAlloc",
-                 "Misses", "Max-StdAlloc");
-        cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "----", "--------",
-                 "---------", "------------", "----------",
-                 "--------", "--------", "------------");
-
-        for (i = 0; i < mempool_count; i++) {
-                snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
-                ret = dict_get_str (dict, key, &name);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &hotcount);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.hotcount", prefix, i);
+        ret = dict_get_int32(dict, key, &hotcount);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &coldcount);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.coldcount", prefix, i);
+        ret = dict_get_int32(dict, key, &coldcount);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
-                          prefix, i);
-                ret = dict_get_uint64 (dict, key, &paddedsizeof);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.paddedsizeof", prefix, i);
+        ret = dict_get_uint64(dict, key, &paddedsizeof);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.alloccount", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.max_alloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxalloc);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxstdalloc);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.max-stdalloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxstdalloc);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
-                ret = dict_get_uint64 (dict, key, &pool_misses);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.pool%d.pool-misses", prefix, i);
+        ret = dict_get_uint64(dict, key, &pool_misses);
+        if (ret)
+            goto out;
 
-                cli_out ("%-30s %9d %9d %12"PRIu64" %10"PRIu64" %8d %8"PRIu64
-                         " %12d", name, hotcount, coldcount, paddedsizeof,
-                         alloccount, maxalloc, pool_misses, maxstdalloc);
-        }
+        cli_out("%-30s %9d %9d %12" PRIu64 " %10" PRIu64 " %8d %8" PRIu64
+                " %12d",
+                name, hotcount, coldcount, paddedsizeof, alloccount, maxalloc,
+                pool_misses, maxstdalloc);
+    }
 
 out:
-        return;
-
+    return;
 }
 
 void
-cli_print_volume_status_mem (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        char            key[1024] = {0,};
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        int             val = 0;
-        int             i = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
+cli_print_volume_status_mem(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    char key[1024] = {
+        0,
+    };
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    int val = 0;
+    int i = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Memory status for volume : %s", volname);
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        cli_out ("Memory status for volume : %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+            continue;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
-
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        continue;
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        continue;
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
-
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
-
-                cli_out ("Mallinfo\n--------");
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.arena", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d","Arena", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d","Ordblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d","Smblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if(ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Hblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Hblkhd", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Usmblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Fsmblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Uordblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Fordblks", val);
-
-                snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", i);
-                ret = dict_get_int32 (dict, key, &val);
-                if (ret)
-                        goto out;
-                cli_out ("%-8s : %d", "Keepcost", val);
+            continue;
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-                cli_out (" ");
-                snprintf (key, sizeof (key), "brick%d", i);
-                cli_print_volume_status_mempool (dict, key);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (ret)
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
         }
-out:
-        cli_out ("----------------------------------------------\n");
-        return;
-}
 
-void
-cli_print_volume_status_client_list (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret                     = -1;
-        char            *volname                = NULL;
-        int             client_count            = 0;
-        int             current_count           = 0;
-        char            key[1024]               = {0,};
-        int             i                       = 0;
-        int             total                   = 0;
-        char            *name                   = NULL;
-        gf_boolean_t    is_fuse_done            = _gf_false;
-        gf_boolean_t    is_gfapi_done           = _gf_false;
-        gf_boolean_t    is_tierd_done           = _gf_false;
-        gf_boolean_t    is_rebalance_done       = _gf_false;
-        gf_boolean_t    is_glustershd_done      = _gf_false;
-        gf_boolean_t    is_quotad_done          = _gf_false;
-        gf_boolean_t    is_snapd_done           = _gf_false;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("Client connections for volume %s", volname);
+        cli_out("Mallinfo\n--------");
 
-        ret = dict_get_int32 (dict, "client-count", &client_count);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.arena", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Arena", val);
 
-                cli_out ("%-48s %15s", "Name", "count");
-                cli_out ("%-48s %15s", "-----", "------");
-                for (i = 0; i < client_count; i++) {
-                        name = NULL;
-                        snprintf (key, sizeof (key),
-                                        "client%d.name", i);
-                        ret = dict_get_str (dict, key, &name);
-
-                        if (!strncmp (name, "fuse", 4)) {
-                                if (!is_fuse_done) {
-                                        is_fuse_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "fuse-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strncmp (name, "gfapi", 5)) {
-                                if (!is_gfapi_done) {
-                                        is_gfapi_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "gfapi-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "tierd")) {
-                                if (!is_tierd_done) {
-                                        is_tierd_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "tierd-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "rebalance")) {
-                                if (!is_rebalance_done) {
-                                        is_rebalance_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "rebalance-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "glustershd")) {
-                                if (!is_glustershd_done) {
-                                        is_glustershd_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "glustershd-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "quotad")) {
-                                if (!is_quotad_done) {
-                                        is_quotad_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "quotad-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        } else if (!strcmp(name, "snapd")) {
-                                if (!is_snapd_done) {
-                                        is_snapd_done = _gf_true;
-                                        ret = dict_get_int32 (dict,
-                                                        "snapd-count",
-                                                        &current_count);
-                                        if (ret)
-                                                goto out;
-                                        total = total + current_count;
-                                        goto print;
-                                }
-                                continue;
-                        }
-
-print:
-                cli_out ("%-48s %15d", name, current_count);
-
-        }
-out:
-                cli_out ("\ntotal clients for volume %s : %d ", volname, total);
-                cli_out ("-----------------------------------------------------------------\n");
-        return;
-}
-
-void
-cli_print_volume_status_clients (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             client_count = 0;
-        char            *clientname = NULL;
-        uint64_t        bytesread = 0;
-        uint64_t        byteswrite = 0;
-        uint32_t        opversion = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.ordblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
-        cli_out ("Client connections for volume %s", volname);
+            goto out;
+        cli_out("%-8s : %d", "Ordblks", val);
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.smblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+            goto out;
+        cli_out("%-8s : %d", "Smblks", val);
+
+        snprintf(key, sizeof(key), "brick%d.mallinfo.hblks", i);
+        ret = dict_get_int32(dict, key, &val);
         if (ret)
-                goto out;
+            goto out;
+        cli_out("%-8s : %d", "Hblks", val);
 
-        index_max = brick_index_max + other_count;
+        snprintf(key, sizeof(key), "brick%d.mallinfo.hblkhd", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Hblkhd", val);
 
-        for (i = 0; i <= index_max; i++) {
-                hostname = NULL;
-                path = NULL;
-                online = -1;
-                client_count = 0;
-                clientname = NULL;
-                bytesread = 0;
-                byteswrite = 0;
+        snprintf(key, sizeof(key), "brick%d.mallinfo.usmblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Usmblks", val);
 
-                cli_out ("----------------------------------------------");
+        snprintf(key, sizeof(key), "brick%d.mallinfo.fsmblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Fsmblks", val);
 
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.uordblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Uordblks", val);
 
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
+        snprintf(key, sizeof(key), "brick%d.mallinfo.fordblks", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Fordblks", val);
 
-                if (hostname && path) {
-                        if (notbrick)
-                                cli_out ("%s : %s", hostname, path);
-                        else
-                                cli_out ("Brick : %s:%s", hostname, path);
-                }
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+        snprintf(key, sizeof(key), "brick%d.mallinfo.keepcost", i);
+        ret = dict_get_int32(dict, key, &val);
+        if (ret)
+            goto out;
+        cli_out("%-8s : %d", "Keepcost", val);
 
-                snprintf (key, sizeof (key), "brick%d.clientcount", i);
-                ret = dict_get_int32 (dict, key, &client_count);
-
-                if (hostname && path)
-                        cli_out ("Clients connected : %d", client_count);
-                if (client_count == 0)
-                        continue;
-
-                cli_out ("%-48s %15s %15s %15s", "Hostname", "BytesRead",
-                         "BytesWritten", "OpVersion");
-                cli_out ("%-48s %15s %15s %15s", "--------", "---------",
-                         "------------", "---------");
-                for (j =0; j < client_count; j++) {
-                        snprintf (key, sizeof (key),
-                                  "brick%d.client%d.hostname", i, j);
-                        ret = dict_get_str (dict, key, &clientname);
-
-                        snprintf (key, sizeof (key),
-                                  "brick%d.client%d.bytesread", i, j);
-                        ret = dict_get_uint64 (dict, key, &bytesread);
-
-                        snprintf (key, sizeof (key),
-                                 "brick%d.client%d.byteswrite", i, j);
-                        ret = dict_get_uint64 (dict, key, &byteswrite);
-
-                        snprintf (key, sizeof (key),
-                                 "brick%d.client%d.opversion", i, j);
-                        ret = dict_get_uint32 (dict, key, &opversion);
-
-                        cli_out ("%-48s %15"PRIu64" %15"PRIu64" %15"PRIu32,
-                                  clientname, bytesread, byteswrite,
-                                  opversion);
-                }
-        }
+        cli_out(" ");
+        snprintf(key, sizeof(key), "brick%d", i);
+        cli_print_volume_status_mempool(dict, key);
+    }
 out:
-        cli_out ("----------------------------------------------\n");
-        return;
+    cli_out("----------------------------------------------\n");
+    return;
 }
 
 void
-cli_print_volume_status_inode_entry (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        char            *gfid = NULL;
-        uint64_t        nlookup = 0;
-        uint32_t        ref = 0;
-        int             ia_type = 0;
-        char            inode_type;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
-
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_get_str (dict, key, &gfid);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_get_uint64 (dict, key, &nlookup);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_get_uint32 (dict, key, &ref);
-        if (ret)
-                goto out;
+cli_print_volume_status_client_list(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int client_count = 0;
+    int current_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int total = 0;
+    char *name = NULL;
+    gf_boolean_t is_fuse_done = _gf_false;
+    gf_boolean_t is_gfapi_done = _gf_false;
+    gf_boolean_t is_tierd_done = _gf_false;
+    gf_boolean_t is_rebalance_done = _gf_false;
+    gf_boolean_t is_glustershd_done = _gf_false;
+    gf_boolean_t is_quotad_done = _gf_false;
+    gf_boolean_t is_snapd_done = _gf_false;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Client connections for volume %s", volname);
+
+    ret = dict_get_int32(dict, "client-count", &client_count);
+    if (ret)
+        goto out;
+
+    cli_out("%-48s %15s", "Name", "count");
+    cli_out("%-48s %15s", "-----", "------");
+    for (i = 0; i < client_count; i++) {
+        name = NULL;
+        snprintf(key, sizeof(key), "client%d.name", i);
+        ret = dict_get_str(dict, key, &name);
+
+        if (!strncmp(name, "fuse", 4)) {
+            if (!is_fuse_done) {
+                is_fuse_done = _gf_true;
+                ret = dict_get_int32(dict, "fuse-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strncmp(name, "gfapi", 5)) {
+            if (!is_gfapi_done) {
+                is_gfapi_done = _gf_true;
+                ret = dict_get_int32(dict, "gfapi-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "tierd")) {
+            if (!is_tierd_done) {
+                is_tierd_done = _gf_true;
+                ret = dict_get_int32(dict, "tierd-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "rebalance")) {
+            if (!is_rebalance_done) {
+                is_rebalance_done = _gf_true;
+                ret = dict_get_int32(dict, "rebalance-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "glustershd")) {
+            if (!is_glustershd_done) {
+                is_glustershd_done = _gf_true;
+                ret = dict_get_int32(dict, "glustershd-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "quotad")) {
+            if (!is_quotad_done) {
+                is_quotad_done = _gf_true;
+                ret = dict_get_int32(dict, "quotad-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        } else if (!strcmp(name, "snapd")) {
+            if (!is_snapd_done) {
+                is_snapd_done = _gf_true;
+                ret = dict_get_int32(dict, "snapd-count", &current_count);
+                if (ret)
+                    goto out;
+                total = total + current_count;
+                goto print;
+            }
+            continue;
+        }
+
+    print:
+        cli_out("%-48s %15d", name, current_count);
+    }
+out:
+    cli_out("\ntotal clients for volume %s : %d ", volname, total);
+    cli_out(
+        "-----------------------------------------------------------------\n");
+    return;
+}
 
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_get_int32 (dict, key, &ia_type);
-        if (ret)
-                goto out;
+void
+cli_print_volume_status_clients(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int client_count = 0;
+    char *clientname = NULL;
+    uint64_t bytesread = 0;
+    uint64_t byteswrite = 0;
+    uint32_t opversion = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Client connections for volume %s", volname);
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        hostname = NULL;
+        path = NULL;
+        online = -1;
+        client_count = 0;
+        clientname = NULL;
+        bytesread = 0;
+        byteswrite = 0;
+
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
+
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
+
+        if (hostname && path) {
+            if (notbrick)
+                cli_out("%s : %s", hostname, path);
+            else
+                cli_out("Brick : %s:%s", hostname, path);
+        }
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
+        }
+
+        snprintf(key, sizeof(key), "brick%d.clientcount", i);
+        ret = dict_get_int32(dict, key, &client_count);
+
+        if (hostname && path)
+            cli_out("Clients connected : %d", client_count);
+        if (client_count == 0)
+            continue;
+
+        cli_out("%-48s %15s %15s %15s", "Hostname", "BytesRead", "BytesWritten",
+                "OpVersion");
+        cli_out("%-48s %15s %15s %15s", "--------", "---------", "------------",
+                "---------");
+        for (j = 0; j < client_count; j++) {
+            snprintf(key, sizeof(key), "brick%d.client%d.hostname", i, j);
+            ret = dict_get_str(dict, key, &clientname);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.bytesread", i, j);
+            ret = dict_get_uint64(dict, key, &bytesread);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.byteswrite", i, j);
+            ret = dict_get_uint64(dict, key, &byteswrite);
+
+            snprintf(key, sizeof(key), "brick%d.client%d.opversion", i, j);
+            ret = dict_get_uint32(dict, key, &opversion);
+
+            cli_out("%-48s %15" PRIu64 " %15" PRIu64 " %15" PRIu32, clientname,
+                    bytesread, byteswrite, opversion);
+        }
+    }
+out:
+    cli_out("----------------------------------------------\n");
+    return;
+}
 
-        switch (ia_type) {
+void
+cli_print_volume_status_inode_entry(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    char *gfid = NULL;
+    uint64_t nlookup = 0;
+    uint32_t ref = 0;
+    int ia_type = 0;
+    char inode_type;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_get_str(dict, key, &gfid);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    ret = dict_get_uint64(dict, key, &nlookup);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_get_uint32(dict, key, &ref);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_get_int32(dict, key, &ia_type);
+    if (ret)
+        goto out;
+
+    switch (ia_type) {
         case IA_IFREG:
-                inode_type = 'R';
-                break;
+            inode_type = 'R';
+            break;
         case IA_IFDIR:
-                inode_type = 'D';
-                break;
+            inode_type = 'D';
+            break;
         case IA_IFLNK:
-                inode_type = 'L';
-                break;
+            inode_type = 'L';
+            break;
         case IA_IFBLK:
-                inode_type = 'B';
-                break;
+            inode_type = 'B';
+            break;
         case IA_IFCHR:
-                inode_type = 'C';
-                break;
+            inode_type = 'C';
+            break;
         case IA_IFIFO:
-                inode_type = 'F';
-                break;
+            inode_type = 'F';
+            break;
         case IA_IFSOCK:
-                inode_type = 'S';
-                break;
+            inode_type = 'S';
+            break;
         default:
-                inode_type = 'I';
-                break;
-        }
+            inode_type = 'I';
+            break;
+    }
 
-        cli_out ("%-40s %14"PRIu64" %14"PRIu32" %9c",
-                 gfid, nlookup, ref, inode_type);
+    cli_out("%-40s %14" PRIu64 " %14" PRIu32 " %9c", gfid, nlookup, ref,
+            inode_type);
 
 out:
-        return;
-
+    return;
 }
 
 void
-cli_print_volume_status_itables (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        uint32_t        active_size = 0;
-        uint32_t        lru_size = 0;
-        uint32_t        purge_size = 0;
-        int             i =0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
+cli_print_volume_status_itables(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    uint32_t active_size = 0;
+    uint32_t lru_size = 0;
+    uint32_t purge_size = 0;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.active_size", prefix);
+    ret = dict_get_uint32(dict, key, &active_size);
+    if (ret)
+        goto out;
+    if (active_size != 0) {
+        cli_out("Active inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < active_size; i++) {
+        snprintf(key, sizeof(key), "%s.active%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+    cli_out(" ");
+
+    snprintf(key, sizeof(key), "%s.lru_size", prefix);
+    ret = dict_get_uint32(dict, key, &lru_size);
+    if (ret)
+        goto out;
+    if (lru_size != 0) {
+        cli_out("LRU inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < lru_size; i++) {
+        snprintf(key, sizeof(key), "%s.lru%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+    cli_out(" ");
+
+    snprintf(key, sizeof(key), "%s.purge_size", prefix);
+    ret = dict_get_uint32(dict, key, &purge_size);
+    if (ret)
+        goto out;
+    if (purge_size != 0) {
+        cli_out("Purged inodes:");
+        cli_out("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref", "IA type");
+        cli_out("%-40s %14s %14s %9s", "----", "-------", "---", "-------");
+    }
+    for (i = 0; i < purge_size; i++) {
+        snprintf(key, sizeof(key), "%s.purge%d", prefix, i);
+        cli_print_volume_status_inode_entry(dict, key);
+    }
+
+out:
+    return;
+}
 
-        snprintf (key, sizeof (key), "%s.active_size", prefix);
-        ret = dict_get_uint32 (dict, key, &active_size);
+void
+cli_print_volume_status_inode(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Inode tables for volume %s", volname);
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        if (active_size != 0) {
-                cli_out ("Active inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < active_size; i++) {
-                snprintf (key, sizeof (key), "%s.active%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
-        cli_out (" ");
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
+        if (ret)
+            goto out;
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-        snprintf (key, sizeof (key), "%s.lru_size", prefix);
-        ret = dict_get_uint32 (dict, key, &lru_size);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
         if (ret)
-                goto out;
-        if (lru_size != 0) {
-                cli_out ("LRU inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < lru_size; i++) {
-                snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
         }
-        cli_out (" ");
 
-        snprintf (key, sizeof (key), "%s.purge_size", prefix);
-        ret = dict_get_uint32 (dict, key, &purge_size);
+        snprintf(key, sizeof(key), "brick%d.conncount", i);
+        ret = dict_get_int32(dict, key, &conn_count);
         if (ret)
-                goto out;
-        if (purge_size != 0) {
-                cli_out ("Purged inodes:");
-                cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
-                         "IA type");
-                cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
-                         "-------");
-        }
-        for (i = 0; i < purge_size; i++) {
-                snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
-                cli_print_volume_status_inode_entry (dict, key);
-        }
+            goto out;
+
+        for (j = 0; j < conn_count; j++) {
+            if (conn_count > 1)
+                cli_out("Connection %d:", j + 1);
 
+            snprintf(key, sizeof(key), "brick%d.conn%d.itable", i, j);
+            cli_print_volume_status_itables(dict, key);
+            cli_out(" ");
+        }
+    }
 out:
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
 void
-cli_print_volume_status_inode (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
+cli_print_volume_status_fdtable(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int refcount = 0;
+    uint32_t maxfds = 0;
+    int firstfree = 0;
+    int openfds = 0;
+    int fd_pid = 0;
+    int fd_refcount = 0;
+    int fd_flags = 0;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &refcount);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.maxfds", prefix);
+    ret = dict_get_uint32(dict, key, &maxfds);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.firstfree", prefix);
+    ret = dict_get_int32(dict, key, &firstfree);
+    if (ret)
+        goto out;
+
+    cli_out("RefCount = %d  MaxFDs = %d  FirstFree = %d", refcount, maxfds,
+            firstfree);
+
+    snprintf(key, sizeof(key), "%s.openfds", prefix);
+    ret = dict_get_int32(dict, key, &openfds);
+    if (ret)
+        goto out;
+    if (0 == openfds) {
+        cli_err("No open fds");
+        goto out;
+    }
+
+    cli_out("%-19s %-19s %-19s %-19s", "FD Entry", "PID", "RefCount", "Flags");
+    cli_out("%-19s %-19s %-19s %-19s", "--------", "---", "--------", "-----");
+
+    for (i = 0; i < maxfds; i++) {
+        snprintf(key, sizeof(key), "%s.fdentry%d.pid", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_pid);
         if (ret)
-                goto out;
-        cli_out ("Inode tables for volume %s", volname);
+            continue;
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+        snprintf(key, sizeof(key), "%s.fdentry%d.refcount", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_refcount);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
+            continue;
 
-        for ( i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
-
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
-
-                snprintf (key, sizeof (key), "brick%d.conncount", i);
-                ret = dict_get_int32 (dict, key, &conn_count);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "%s.fdentry%d.flags", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_flags);
+        if (ret)
+            continue;
 
-                for (j = 0; j < conn_count; j++) {
-                        if (conn_count > 1)
-                                cli_out ("Connection %d:", j+1);
+        cli_out("%-19d %-19d %-19d %-19d", i, fd_pid, fd_refcount, fd_flags);
+    }
 
-                        snprintf (key, sizeof (key), "brick%d.conn%d.itable",
-                                  i, j);
-                        cli_print_volume_status_itables (dict, key);
-                        cli_out (" ");
-                }
-        }
 out:
-        cli_out ("----------------------------------------------");
-        return;
+    return;
 }
 
 void
-cli_print_volume_status_fdtable (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             refcount = 0;
-        uint32_t        maxfds = 0;
-        int             firstfree = 0;
-        int             openfds = 0;
-        int             fd_pid = 0;
-        int             fd_refcount = 0;
-        int             fd_flags = 0;
-        int             i = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix);
-
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &refcount);
+cli_print_volume_status_fd(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("FD tables for volume %s", volname);
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%s.maxfds", prefix);
-        ret = dict_get_uint32 (dict, key, &maxfds);
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%s.firstfree", prefix);
-        ret = dict_get_int32 (dict, key, &firstfree);
-        if (ret)
-                goto out;
+            goto out;
 
-        cli_out ("RefCount = %d  MaxFDs = %d  FirstFree = %d",
-                 refcount, maxfds, firstfree);
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-        snprintf (key, sizeof (key), "%s.openfds", prefix);
-        ret = dict_get_int32 (dict, key, &openfds);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
         if (ret)
-                goto out;
-        if (0 == openfds) {
-                cli_err ("No open fds");
-                goto out;
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
         }
 
-        cli_out ("%-19s %-19s %-19s %-19s", "FD Entry", "PID",
-                 "RefCount", "Flags");
-        cli_out ("%-19s %-19s %-19s %-19s", "--------", "---",
-                 "--------", "-----");
-
-        for (i = 0; i < maxfds ; i++) {
-                snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_pid);
-                if (ret)
-                        continue;
-
-                snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
-                          prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_refcount);
-                if (ret)
-                        continue;
+        snprintf(key, sizeof(key), "brick%d.conncount", i);
+        ret = dict_get_int32(dict, key, &conn_count);
+        if (ret)
+            goto out;
 
-                snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_flags);
-                if (ret)
-                        continue;
+        for (j = 0; j < conn_count; j++) {
+            cli_out("Connection %d:", j + 1);
 
-                cli_out ("%-19d %-19d %-19d %-19d", i, fd_pid, fd_refcount,
-                         fd_flags);
+            snprintf(key, sizeof(key), "brick%d.conn%d.fdtable", i, j);
+            cli_print_volume_status_fdtable(dict, key);
+            cli_out(" ");
         }
-
+    }
 out:
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
 void
-cli_print_volume_status_fd (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("FD tables for volume %s", volname);
+cli_print_volume_status_call_frame(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int ref_count = 0;
+    char *translator = 0;
+    int complete = 0;
+    char *parent = NULL;
+    char *wind_from = NULL;
+    char *wind_to = NULL;
+    char *unwind_from = NULL;
+    char *unwind_to = NULL;
+
+    if (!dict || !prefix)
+        return;
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &ref_count);
+    if (ret)
+        return;
 
-        index_max = brick_index_max + other_count;
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_get_str(dict, key, &translator);
+    if (ret)
+        return;
 
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_get_int32(dict, key, &complete);
+    if (ret)
+        return;
 
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
+    cli_out("  Ref Count   = %d", ref_count);
+    cli_out("  Translator  = %s", translator);
+    cli_out("  Completed   = %s", (complete ? "Yes" : "No"));
 
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
+    snprintf(key, sizeof(key), "%s.parent", prefix);
+    ret = dict_get_str(dict, key, &parent);
+    if (!ret)
+        cli_out("  Parent      = %s", parent);
 
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
+    snprintf(key, sizeof(key), "%s.windfrom", prefix);
+    ret = dict_get_str(dict, key, &wind_from);
+    if (!ret)
+        cli_out("  Wind From   = %s", wind_from);
 
-                snprintf (key, sizeof (key), "brick%d.conncount", i);
-                ret = dict_get_int32 (dict, key, &conn_count);
-                if (ret)
-                        goto out;
+    snprintf(key, sizeof(key), "%s.windto", prefix);
+    ret = dict_get_str(dict, key, &wind_to);
+    if (!ret)
+        cli_out("  Wind To     = %s", wind_to);
 
-                for (j = 0; j < conn_count; j++) {
-                        cli_out ("Connection %d:", j+1);
+    snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+    ret = dict_get_str(dict, key, &unwind_from);
+    if (!ret)
+        cli_out("  Unwind From = %s", unwind_from);
 
-                        snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
-                                  i, j);
-                        cli_print_volume_status_fdtable (dict, key);
-                        cli_out (" ");
-                }
-        }
-out:
-        cli_out ("----------------------------------------------");
-        return;
+    snprintf(key, sizeof(key), "%s.unwindto", prefix);
+    ret = dict_get_str(dict, key, &unwind_to);
+    if (!ret)
+        cli_out("  Unwind To   = %s", unwind_to);
 }
 
 void
-cli_print_volume_status_call_frame (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             ref_count = 0;
-        char            *translator = 0;
-        int             complete = 0;
-        char            *parent = NULL;
-        char            *wind_from = NULL;
-        char            *wind_to = NULL;
-        char            *unwind_from = NULL;
-        char            *unwind_to = NULL;
+cli_print_volume_status_call_stack(dict_t *dict, char *prefix)
+{
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int uid = 0;
+    int gid = 0;
+    int pid = 0;
+    uint64_t unique = 0;
+    // char            *op = NULL;
+    int count = 0;
+    int i = 0;
+
+    if (!dict || !prefix)
+        return;
 
-        if (!dict || !prefix)
-                return;
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_get_int32(dict, key, &uid);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &ref_count);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_get_int32(dict, key, &gid);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_get_str (dict, key, &translator);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_get_int32 (dict, key, &complete);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_get_uint64(dict, key, &unique);
+    if (ret)
+        return;
 
-        cli_out ("  Ref Count   = %d", ref_count);
-        cli_out ("  Translator  = %s", translator);
-        cli_out ("  Completed   = %s", (complete ? "Yes" : "No"));
+    /*
+    snprintf (key, sizeof (key), "%s.op", prefix);
+    ret = dict_get_str (dict, key, &op);
+    if (ret)
+            return;
+    */
 
-        snprintf (key, sizeof (key), "%s.parent", prefix);
-        ret = dict_get_str (dict, key, &parent);
-        if (!ret)
-                cli_out ("  Parent      = %s", parent);
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &count);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.windfrom", prefix);
-        ret = dict_get_str (dict, key, &wind_from);
-        if (!ret)
-                cli_out ("  Wind From   = %s", wind_from);
+    cli_out(" UID    : %d", uid);
+    cli_out(" GID    : %d", gid);
+    cli_out(" PID    : %d", pid);
+    cli_out(" Unique : %" PRIu64, unique);
+    // cli_out ("\tOp     : %s", op);
+    cli_out(" Frames : %d", count);
 
-        snprintf (key, sizeof (key), "%s.windto", prefix);
-        ret = dict_get_str (dict, key, &wind_to);
-        if (!ret)
-                cli_out ("  Wind To     = %s", wind_to);
+    for (i = 0; i < count; i++) {
+        cli_out(" Frame %d", i + 1);
 
-        snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-        ret = dict_get_str (dict, key, &unwind_from);
-        if (!ret)
-                cli_out ("  Unwind From = %s", unwind_from);
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        cli_print_volume_status_call_frame(dict, key);
+    }
 
-        snprintf (key, sizeof (key), "%s.unwindto", prefix);
-        ret = dict_get_str (dict, key, &unwind_to);
-        if (!ret)
-                cli_out ("  Unwind To   = %s", unwind_to);
+    cli_out(" ");
 }
 
 void
-cli_print_volume_status_call_stack (dict_t *dict, char *prefix)
-{
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             uid = 0;
-        int             gid = 0;
-        int             pid = 0;
-        uint64_t        unique = 0;
-        //char            *op = NULL;
-        int             count = 0;
-        int             i = 0;
-
-        if (!dict || !prefix)
-                return;
-
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_get_int32 (dict, key, &uid);
-        if (ret)
-                return;
-
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_get_int32 (dict, key, &gid);
+cli_print_volume_status_callpool(dict_t *dict, gf_boolean_t notbrick)
+{
+    int ret = -1;
+    char *volname = NULL;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    char *hostname = NULL;
+    char *path = NULL;
+    int online = -1;
+    int call_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    cli_out("Pending calls for volume %s", volname);
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    for (i = 0; i <= index_max; i++) {
+        cli_out("----------------------------------------------");
+
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                return;
-
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                return;
-
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_get_uint64 (dict, key, &unique);
+            goto out;
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                return;
-
-        /*
-        snprintf (key, sizeof (key), "%s.op", prefix);
-        ret = dict_get_str (dict, key, &op);
-        if (ret)
-                return;
-        */
+            goto out;
 
+        if (notbrick)
+            cli_out("%s : %s", hostname, path);
+        else
+            cli_out("Brick : %s:%s", hostname, path);
 
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &count);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &online);
         if (ret)
-                return;
-
-        cli_out (" UID    : %d", uid);
-        cli_out (" GID    : %d", gid);
-        cli_out (" PID    : %d", pid);
-        cli_out (" Unique : %"PRIu64, unique);
-        //cli_out ("\tOp     : %s", op);
-        cli_out (" Frames : %d", count);
-
-        for (i = 0; i < count; i++) {
-                cli_out (" Frame %d", i+1);
-
-                snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
-                cli_print_volume_status_call_frame (dict, key);
+            goto out;
+        if (!online) {
+            if (notbrick)
+                cli_out("%s is offline", hostname);
+            else
+                cli_out("Brick is offline");
+            continue;
         }
 
-        cli_out (" ");
-}
-
-void
-cli_print_volume_status_callpool (dict_t *dict, gf_boolean_t notbrick)
-{
-        int             ret = -1;
-        char            *volname = NULL;
-        int             brick_index_max = -1;
-        int             other_count = 0;
-        int             index_max = 0;
-        char            *hostname = NULL;
-        char            *path = NULL;
-        int             online = -1;
-        int             call_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-        int             j = 0;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        cli_out ("Pending calls for volume %s", volname);
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+        snprintf(key, sizeof(key), "brick%d.callpool.count", i);
+        ret = dict_get_int32(dict, key, &call_count);
         if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
+            goto out;
+        cli_out("Pending calls: %d", call_count);
 
-        index_max = brick_index_max + other_count;
+        if (0 == call_count)
+            continue;
 
-        for (i = 0; i <= index_max; i++) {
-                cli_out ("----------------------------------------------");
+        for (j = 0; j < call_count; j++) {
+            cli_out("Call Stack%d", j + 1);
 
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        goto out;
-
-                if (notbrick)
-                        cli_out ("%s : %s", hostname, path);
-                else
-                        cli_out ("Brick : %s:%s", hostname, path);
-
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &online);
-                if (ret)
-                        goto out;
-                if (!online) {
-                        if (notbrick)
-                                cli_out ("%s is offline", hostname);
-                        else
-                                cli_out ("Brick is offline");
-                        continue;
-                }
-
-                snprintf (key, sizeof (key), "brick%d.callpool.count", i);
-                ret = dict_get_int32 (dict, key, &call_count);
-                if (ret)
-                        goto out;
-                cli_out ("Pending calls: %d", call_count);
-
-                if (0 == call_count)
-                        continue;
-
-                for (j = 0; j < call_count; j++) {
-                        cli_out ("Call Stack%d", j+1);
-
-                        snprintf (key, sizeof (key),
-                                  "brick%d.callpool.stack%d", i, j);
-                        cli_print_volume_status_call_stack (dict, key);
-                }
+            snprintf(key, sizeof(key), "brick%d.callpool.stack%d", i, j);
+            cli_print_volume_status_call_stack(dict, key);
         }
+    }
 
 out:
-        cli_out ("----------------------------------------------");
-        return;
+    cli_out("----------------------------------------------");
+    return;
 }
 
 static void
-cli_print_volume_status_tasks (dict_t *dict)
-{
-        int             ret         = -1;
-        int             i           = 0;
-        int             j           = 0;
-        int             count       = 0;
-        int             task_count  = 0;
-        int             status      = 0;
-        char           *op          = NULL;
-        char           *task_id_str = NULL;
-        char           *volname     = NULL;
-        char            key[64]     = {0,};
-        char            task[32]    = {0,};
-        char           *brick       = NULL;
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "tasks", &task_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get tasks count");
-                return;
-        }
+cli_print_volume_status_tasks(dict_t *dict)
+{
+    int ret = -1;
+    int i = 0;
+    int j = 0;
+    int count = 0;
+    int task_count = 0;
+    int status = 0;
+    char *op = NULL;
+    char *task_id_str = NULL;
+    char *volname = NULL;
+    char key[64] = {
+        0,
+    };
+    char task[32] = {
+        0,
+    };
+    char *brick = NULL;
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "tasks", &task_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get tasks count");
+        return;
+    }
 
-        cli_out ("Task Status of Volume %s", volname);
-        cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
+    cli_out("Task Status of Volume %s", volname);
+    cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
 
-        if (task_count == 0) {
-                cli_out ("There are no active volume tasks");
-                cli_out (" ");
-                return;
-        }
+    if (task_count == 0) {
+        cli_out("There are no active volume tasks");
+        cli_out(" ");
+        return;
+    }
 
-        for (i = 0; i < task_count; i++) {
-                snprintf (key, sizeof (key), "task%d.type", i);
-                ret = dict_get_str(dict, key, &op);
-                if (ret)
-                        return;
-                cli_out ("%-20s : %-20s", "Task", op);
+    for (i = 0; i < task_count; i++) {
+        snprintf(key, sizeof(key), "task%d.type", i);
+        ret = dict_get_str(dict, key, &op);
+        if (ret)
+            return;
+        cli_out("%-20s : %-20s", "Task", op);
 
-                snprintf (key, sizeof (key), "task%d.id", i);
-                ret = dict_get_str (dict, key, &task_id_str);
-                if (ret)
-                        return;
-                cli_out ("%-20s : %-20s", "ID", task_id_str);
+        snprintf(key, sizeof(key), "task%d.id", i);
+        ret = dict_get_str(dict, key, &task_id_str);
+        if (ret)
+            return;
+        cli_out("%-20s : %-20s", "ID", task_id_str);
 
-                snprintf (key, sizeof (key), "task%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        return;
+        snprintf(key, sizeof(key), "task%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            return;
 
-                snprintf (task, sizeof (task), "task%d", i);
+        snprintf(task, sizeof(task), "task%d", i);
 
-                if (!strcmp (op, "Remove brick")) {
-                        snprintf (key, sizeof (key), "%s.count", task);
-                        ret = dict_get_int32 (dict, key, &count);
-                        if (ret)
-                                goto out;
+        if (!strcmp(op, "Remove brick")) {
+            snprintf(key, sizeof(key), "%s.count", task);
+            ret = dict_get_int32(dict, key, &count);
+            if (ret)
+                goto out;
 
-                        cli_out ("%-20s", "Removed bricks:");
+            cli_out("%-20s", "Removed bricks:");
 
-                        for (j = 1; j <= count; j++) {
-                                snprintf (key, sizeof (key),"%s.brick%d",
-                                          task, j);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
+            for (j = 1; j <= count; j++) {
+                snprintf(key, sizeof(key), "%s.brick%d", task, j);
+                ret = dict_get_str(dict, key, &brick);
+                if (ret)
+                    goto out;
 
-                                cli_out ("%-20s", brick);
-                        }
-                }
-                cli_out ("%-20s : %-20s", "Status",
-                         cli_vol_task_status_str[status]);
-                cli_out (" ");
+                cli_out("%-20s", brick);
+            }
         }
+        cli_out("%-20s : %-20s", "Status", cli_vol_task_status_str[status]);
+        cli_out(" ");
+    }
 
 out:
-        return;
+    return;
 }
 
 static int
-gf_cli_status_cbk (struct rpc_req *req, struct iovec *iov,
-                      int count, void *myframe)
-{
-        int                             ret             = -1;
-        int                             brick_index_max = -1;
-        int                             other_count     = 0;
-        int                             index_max       = 0;
-        int                             i               = 0;
-        int                             type            = -1;
-        int                             hot_brick_count = -1;
-        int                             pid             = -1;
-        uint32_t                        cmd             = 0;
-        gf_boolean_t                    notbrick        = _gf_false;
-        char                            key[1024]       = {0,};
-        char                           *hostname        = NULL;
-        char                           *path            = NULL;
-        char                           *volname         = NULL;
-        dict_t                         *dict            = NULL;
-        gf_cli_rsp                      rsp             = {0,};
-        cli_volume_status_t             status          = {0};
-        cli_local_t                    *local           = NULL;
-        gf_boolean_t                    wipe_local      = _gf_false;
-        char                            msg[1024]       = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to status cmd");
-
-        local = ((call_frame_t *) myframe)->local;
+gf_cli_status_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
+{
+    int ret = -1;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    int i = 0;
+    int type = -1;
+    int hot_brick_count = -1;
+    int pid = -1;
+    uint32_t cmd = 0;
+    gf_boolean_t notbrick = _gf_false;
+    char key[1024] = {
+        0,
+    };
+    char *hostname = NULL;
+    char *path = NULL;
+    char *volname = NULL;
+    dict_t *dict = NULL;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    cli_volume_status_t status = {0};
+    cli_local_t *local = NULL;
+    gf_boolean_t wipe_local = _gf_false;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_DEBUG, "Received response to status cmd");
+
+    local = ((call_frame_t *)myframe)->local;
+    if (!local) {
+        local = cli_local_get();
         if (!local) {
-                local = cli_local_get ();
-                if (!local) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get local");
-                        goto out;
-                }
-                wipe_local = _gf_true;
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get local");
+            goto out;
         }
+        wipe_local = _gf_true;
+    }
 
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "Unable to obtain volume "
-                                  "status information.");
-
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        if (!local->all)
-                                cli_xml_output_str ("volStatus", msg,
-                                                    rsp.op_ret, rsp.op_errno,
-                                                    rsp.op_errstr);
-                        ret = 0;
-                        goto out;
-                }
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg),
+                     "Unable to obtain volume "
+                     "status information.");
 
-                cli_err ("%s", msg);
-                if (local && local->all) {
-                        ret = 0;
-                        cli_out (" ");
-                } else
-                        ret = -1;
+        if (global_state->mode & GLUSTER_MODE_XML) {
+            if (!local->all)
+                cli_xml_output_str("volStatus", msg, rsp.op_ret, rsp.op_errno,
+                                   rsp.op_errstr);
+            ret = 0;
+            goto out;
+        }
+
+        cli_err("%s", msg);
+        if (local && local->all) {
+            ret = 0;
+            cli_out(" ");
+        } else
+            ret = -1;
+
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret)
+        goto out;
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
+
+    if ((cmd & GF_CLI_STATUS_ALL)) {
+        if (local && local->dict) {
+            dict_ref(dict);
+            ret = dict_set_static_ptr(local->dict, "rsp-dict", dict);
+            ret = 0;
+        } else {
+            gf_log("cli", GF_LOG_ERROR, "local not found");
+            ret = -1;
+        }
+        goto out;
+    }
+
+    if ((cmd & GF_CLI_STATUS_NFS) || (cmd & GF_CLI_STATUS_SHD) ||
+        (cmd & GF_CLI_STATUS_QUOTAD) || (cmd & GF_CLI_STATUS_SNAPD) ||
+        (cmd & GF_CLI_STATUS_BITD) || (cmd & GF_CLI_STATUS_SCRUB) ||
+        (cmd & GF_CLI_STATUS_TIERD))
+        notbrick = _gf_true;
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        if (!local->all) {
+            ret = cli_xml_output_vol_status_begin(local, rsp.op_ret,
+                                                  rsp.op_errno, rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+                goto xml_end;
+            }
+        }
+        if (cmd & GF_CLI_STATUS_TASKS) {
+            ret = cli_xml_output_vol_status_tasks_detail(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Error outputting "
+                       "to xml");
+                goto xml_end;
+            }
+        } else {
+            ret = cli_xml_output_vol_status(local, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+                goto xml_end;
+            }
+        }
+
+    xml_end:
+        if (!local->all) {
+            ret = cli_xml_output_vol_status_end(local);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+            }
+        }
+        goto out;
+    }
+
+    status.brick = GF_MALLOC(PATH_MAX + 256, gf_common_mt_strdup);
+    if (!status.brick) {
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            cli_print_volume_status_mem(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CLIENTS:
+            cli_print_volume_status_clients(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CLIENT_LIST:
+            cli_print_volume_status_client_list(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_INODE:
+            cli_print_volume_status_inode(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_FD:
+            cli_print_volume_status_fd(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_CALLPOOL:
+            cli_print_volume_status_callpool(dict, notbrick);
+            goto cont;
+            break;
+        case GF_CLI_STATUS_TASKS:
+            cli_print_volume_status_tasks(dict);
+            goto cont;
+            break;
+        default:
+            break;
+    }
 
-                goto out;
-        }
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
 
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-        if (ret)
-                goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
 
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
+    index_max = brick_index_max + other_count;
 
-        if ((cmd & GF_CLI_STATUS_ALL)) {
-                if (local && local->dict) {
-                        dict_ref (dict);
-                        ret = dict_set_static_ptr (local->dict, "rsp-dict", dict);
-                        ret = 0;
-                } else {
-                        gf_log ("cli", GF_LOG_ERROR, "local not found");
-                        ret = -1;
-                }
-                goto out;
-        }
-
-        if ((cmd & GF_CLI_STATUS_NFS) || (cmd & GF_CLI_STATUS_SHD) ||
-            (cmd & GF_CLI_STATUS_QUOTAD) || (cmd & GF_CLI_STATUS_SNAPD) ||
-            (cmd & GF_CLI_STATUS_BITD) || (cmd & GF_CLI_STATUS_SCRUB) ||
-            (cmd & GF_CLI_STATUS_TIERD))
-                notbrick = _gf_true;
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret)
+        goto out;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                if (!local->all) {
-                        ret = cli_xml_output_vol_status_begin (local,
-                                                               rsp.op_ret,
-                                                               rsp.op_errno,
-                                                               rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto xml_end;
-                        }
-                }
-                if (cmd & GF_CLI_STATUS_TASKS) {
-                        ret = cli_xml_output_vol_status_tasks_detail (local,
-                                                                      dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,"Error outputting "
-                                        "to xml");
-                                goto xml_end;
-                        }
-                } else {
-                        ret = cli_xml_output_vol_status (local, dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                                goto xml_end;
-                        }
-                }
+    ret = dict_get_int32(dict, "hot_brick_count", &hot_brick_count);
+    if (ret)
+        goto out;
 
-xml_end:
-                if (!local->all) {
-                        ret = cli_xml_output_vol_status_end (local);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        }
-                }
-                goto out;
-        }
+    cli_out("Status of volume: %s", volname);
 
-        status.brick = GF_MALLOC (PATH_MAX + 256, gf_common_mt_strdup);
-        if (!status.brick) {
-                errno   = ENOMEM;
-                ret     = -1;
-                goto out;
+    if ((cmd & GF_CLI_STATUS_DETAIL) == 0) {
+        cli_out("%-*s %s  %s  %s  %s", CLI_VOL_STATUS_BRICK_LEN,
+                "Gluster process", "TCP Port", "RDMA Port", "Online", "Pid");
+        cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
+    }
+    if (type == GF_CLUSTER_TYPE_TIER) {
+        cli_out("Hot Bricks:");
+    }
+    for (i = 0; i <= index_max; i++) {
+        if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
+            cli_out("Cold Bricks:");
         }
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        cli_print_volume_status_mem (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_CLIENTS:
-                        cli_print_volume_status_clients (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_CLIENT_LIST:
-                        cli_print_volume_status_client_list (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_INODE:
-                        cli_print_volume_status_inode (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_FD:
-                        cli_print_volume_status_fd (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_CALLPOOL:
-                        cli_print_volume_status_callpool (dict, notbrick);
-                        goto cont;
-                        break;
-                case GF_CLI_STATUS_TASKS:
-                        cli_print_volume_status_tasks (dict);
-                        goto cont;
-                        break;
-                default:
-                        break;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
+        status.rdma_port = 0;
 
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
+        snprintf(key, sizeof(key), "brick%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
+            continue;
 
-        ret = dict_get_int32 (dict, "other-count", &other_count);
+        snprintf(key, sizeof(key), "brick%d.path", i);
+        ret = dict_get_str(dict, key, &path);
         if (ret)
-                goto out;
+            continue;
 
-        index_max = brick_index_max + other_count;
+        /* Brick/not-brick is handled separately here as all
+         * types of nodes are contained in the default output
+         */
+        memset(status.brick, 0, PATH_MAX + 255);
+        if (!strcmp(hostname, "NFS Server") ||
+            !strcmp(hostname, "Self-heal Daemon") ||
+            !strcmp(hostname, "Quota Daemon") ||
+            !strcmp(hostname, "Snapshot Daemon") ||
+            !strcmp(hostname, "Scrubber Daemon") ||
+            !strcmp(hostname, "Bitrot Daemon") ||
+            !strcmp(hostname, "Tier Daemon"))
+            snprintf(status.brick, PATH_MAX + 255, "%s on %s", hostname, path);
+        else {
+            snprintf(key, sizeof(key), "brick%d.rdma_port", i);
+            ret = dict_get_int32(dict, key, &(status.rdma_port));
+            if (ret)
+                continue;
+            snprintf(status.brick, PATH_MAX + 255, "Brick %s:%s", hostname,
+                     path);
+        }
 
-        ret = dict_get_int32 (dict, "type", &type);
+        snprintf(key, sizeof(key), "brick%d.port", i);
+        ret = dict_get_int32(dict, key, &(status.port));
         if (ret)
-                goto out;
+            continue;
 
-        ret = dict_get_int32 (dict, "hot_brick_count", &hot_brick_count);
+        snprintf(key, sizeof(key), "brick%d.status", i);
+        ret = dict_get_int32(dict, key, &(status.online));
         if (ret)
-                goto out;
-
-        cli_out ("Status of volume: %s", volname);
-
-        if ((cmd & GF_CLI_STATUS_DETAIL) == 0) {
-                cli_out ("%-*s %s  %s  %s  %s", CLI_VOL_STATUS_BRICK_LEN,
-                         "Gluster process", "TCP Port", "RDMA Port",
-                         "Online", "Pid");
-                cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
-        }
-        if (type == GF_CLUSTER_TYPE_TIER) {
-                cli_out ("Hot Bricks:");
-        }
-        for (i = 0; i <= index_max; i++) {
-
-                if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
-                        cli_out ("Cold Bricks:");
-                }
-                status.rdma_port = 0;
-
-                snprintf (key, sizeof (key), "brick%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        continue;
-
-                snprintf (key, sizeof (key), "brick%d.path", i);
-                ret = dict_get_str (dict, key, &path);
-                if (ret)
-                        continue;
-
-                /* Brick/not-brick is handled separately here as all
-                 * types of nodes are contained in the default output
-                 */
-                memset (status.brick, 0, PATH_MAX + 255);
-                if (!strcmp (hostname, "NFS Server") ||
-                    !strcmp (hostname, "Self-heal Daemon") ||
-                    !strcmp (hostname, "Quota Daemon") ||
-                    !strcmp (hostname, "Snapshot Daemon") ||
-                    !strcmp (hostname, "Scrubber Daemon") ||
-                    !strcmp (hostname, "Bitrot Daemon") ||
-                    !strcmp (hostname, "Tier Daemon"))
-                        snprintf (status.brick, PATH_MAX + 255, "%s on %s",
-                                  hostname, path);
-                else {
-                        snprintf (key, sizeof (key), "brick%d.rdma_port", i);
-                        ret = dict_get_int32 (dict, key, &(status.rdma_port));
-                        if (ret)
-                                continue;
-                        snprintf (status.brick, PATH_MAX + 255, "Brick %s:%s",
-                                  hostname, path);
-                }
+            continue;
 
-                snprintf (key, sizeof (key), "brick%d.port", i);
-                ret = dict_get_int32 (dict, key, &(status.port));
-                if (ret)
-                        continue;
-
-                snprintf (key, sizeof (key), "brick%d.status", i);
-                ret = dict_get_int32 (dict, key, &(status.online));
-                if (ret)
-                        continue;
-
-                snprintf (key, sizeof (key), "brick%d.pid", i);
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret)
-                        continue;
-                if (pid == -1)
-                        ret = gf_asprintf (&(status.pid_str), "%s", "N/A");
-                else
-                        ret = gf_asprintf (&(status.pid_str), "%d", pid);
-
-                if (ret == -1)
-                        goto out;
+        snprintf(key, sizeof(key), "brick%d.pid", i);
+        ret = dict_get_int32(dict, key, &pid);
+        if (ret)
+            continue;
+        if (pid == -1)
+            ret = gf_asprintf(&(status.pid_str), "%s", "N/A");
+        else
+            ret = gf_asprintf(&(status.pid_str), "%d", pid);
 
-                if ((cmd & GF_CLI_STATUS_DETAIL)) {
-                        ret = cli_get_detail_status (dict, i, &status);
-                        if (ret)
-                                goto out;
-                        cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
-                        cli_print_detailed_status (&status);
-                } else {
-                        cli_print_brick_status (&status);
-                }
+        if (ret == -1)
+            goto out;
 
+        if ((cmd & GF_CLI_STATUS_DETAIL)) {
+            ret = cli_get_detail_status(dict, i, &status);
+            if (ret)
+                goto out;
+            cli_print_line(CLI_BRICK_STATUS_LINE_LEN);
+            cli_print_detailed_status(&status);
+        } else {
+            cli_print_brick_status(&status);
         }
-        cli_out (" ");
+    }
+    cli_out(" ");
 
-        if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE)
-                cli_print_volume_status_tasks (dict);
+    if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE)
+        cli_print_volume_status_tasks(dict);
 cont:
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        GF_FREE (status.brick);
-        if (local && wipe_local) {
-                cli_local_wipe (local);
-        }
+    if (dict)
+        dict_unref(dict);
+    GF_FREE(status.brick);
+    if (local && wipe_local) {
+        cli_local_wipe(local);
+    }
 
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_status_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_status_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req  = {{0,}};
-        int                             ret  = -1;
-        dict_t                         *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = -1;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_status_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_STATUS_VOLUME, this, cli_rpc_prog,
-                               NULL);
- out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning: %d", ret);
-        return ret;
+    ret = cli_to_glusterd(&req, frame, gf_cli_status_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_STATUS_VOLUME, this, cli_rpc_prog, NULL);
+out:
+    gf_log("cli", GF_LOG_DEBUG, "Returning: %d", ret);
+    return ret;
 }
 
 int
-gf_cli_status_volume_all (call_frame_t *frame, xlator_t *this, void *data)
-{
-        int              i            = 0;
-        int              ret          = -1;
-        int              vol_count    = -1;
-        uint32_t         cmd          = 0;
-        char             key[1024]    = {0};
-        char            *volname      = NULL;
-        void            *vol_dict     = NULL;
-        dict_t          *dict         = NULL;
-        cli_local_t     *local        = NULL;
-
-        if (!frame)
-                goto out;
+gf_cli_status_volume_all(call_frame_t *frame, xlator_t *this, void *data)
+{
+    int i = 0;
+    int ret = -1;
+    int vol_count = -1;
+    uint32_t cmd = 0;
+    char key[1024] = {0};
+    char *volname = NULL;
+    void *vol_dict = NULL;
+    dict_t *dict = NULL;
+    cli_local_t *local = NULL;
 
-        if (!frame->local)
-                goto out;
+    if (!frame)
+        goto out;
 
-        local = frame->local;
+    if (!frame->local)
+        goto out;
 
-        ret = dict_get_uint32 (local->dict, "cmd", &cmd);
-        if (ret)
-                goto out;
+    local = frame->local;
 
-        local->all = _gf_true;
+    ret = dict_get_uint32(local->dict, "cmd", &cmd);
+    if (ret)
+        goto out;
 
-        ret = gf_cli_status_volume (frame, this, data);
+    local->all = _gf_true;
 
-        if (ret)
-                goto out;
+    ret = gf_cli_status_volume(frame, this, data);
 
-        ret = dict_get_ptr (local->dict, "rsp-dict", &vol_dict);
-        if (ret)
-                goto out;
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 ((dict_t *)vol_dict, "vol_count", &vol_count);
-        if (ret) {
-                cli_err ("Failed to get names of volumes");
-                goto out;
-        }
+    ret = dict_get_ptr(local->dict, "rsp-dict", &vol_dict);
+    if (ret)
+        goto out;
 
-        /* remove the "all" flag in cmd */
-        cmd &= ~GF_CLI_STATUS_ALL;
-        cmd |= GF_CLI_STATUS_VOL;
+    ret = dict_get_int32((dict_t *)vol_dict, "vol_count", &vol_count);
+    if (ret) {
+        cli_err("Failed to get names of volumes");
+        goto out;
+    }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                //TODO: Pass proper op_* values
-                ret = cli_xml_output_vol_status_begin (local, 0,0, NULL);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                        goto xml_end;
-                }
-        }
+    /* remove the "all" flag in cmd */
+    cmd &= ~GF_CLI_STATUS_ALL;
+    cmd |= GF_CLI_STATUS_VOL;
 
-        if (vol_count == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
-                cli_err ("No volumes present");
-                ret = 0;
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        // TODO: Pass proper op_* values
+        ret = cli_xml_output_vol_status_begin(local, 0, 0, NULL);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+            goto xml_end;
         }
+    }
 
-        for (i = 0; i < vol_count; i++) {
+    if (vol_count == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_err("No volumes present");
+        ret = 0;
+        goto out;
+    }
 
-                dict = dict_new ();
-                if (!dict)
-                        goto out;
+    for (i = 0; i < vol_count; i++) {
+        dict = dict_new();
+        if (!dict)
+            goto out;
 
-                snprintf (key, sizeof (key), "vol%d", i);
-                ret = dict_get_str (vol_dict, key, &volname);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "vol%d", i);
+        ret = dict_get_str(vol_dict, key, &volname);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (dict, "volname", volname);
-                if (ret)
-                        goto out;
+        ret = dict_set_str(dict, "volname", volname);
+        if (ret)
+            goto out;
 
-                ret = dict_set_uint32 (dict, "cmd", cmd);
-                if (ret)
-                        goto out;
+        ret = dict_set_uint32(dict, "cmd", cmd);
+        if (ret)
+            goto out;
 
-                ret = gf_cli_status_volume (frame, this, dict);
-                if (ret)
-                        goto out;
+        ret = gf_cli_status_volume(frame, this, dict);
+        if (ret)
+            goto out;
 
-                dict_unref (dict);
-        }
+        dict_unref(dict);
+    }
 
 xml_end:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_status_end (local);
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_status_end(local);
+    }
 
- out:
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "status all failed");
+out:
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "status all failed");
 
-        if (vol_dict)
-                dict_unref (vol_dict);
+    if (vol_dict)
+        dict_unref(vol_dict);
 
-        if (ret && dict)
-                dict_unref (dict);
+    if (ret && dict)
+        dict_unref(dict);
 
-        if (local)
-                cli_local_wipe (local);
+    if (local)
+        cli_local_wipe(local);
 
-        if (frame)
-                frame->local = NULL;
+    if (frame)
+        frame->local = NULL;
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_cli_mount_cbk (struct rpc_req *req, struct iovec *iov,
-                  int count, void *myframe)
+gf_cli_mount_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf1_cli_mount_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_mount_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_mount_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_mount_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
+    gf_log("cli", GF_LOG_INFO, "Received resp to mount");
 
-        if (rsp.op_ret == 0) {
-                ret = 0;
-                cli_out ("%s", rsp.path);
-        } else {
-                /* weird sounding but easy to parse... */
-                cli_err ("%d : failed with this errno (%s)",
-                         rsp.op_errno, strerror (rsp.op_errno));
-                ret = -1;
-        }
+    if (rsp.op_ret == 0) {
+        ret = 0;
+        cli_out("%s", rsp.path);
+    } else {
+        /* weird sounding but easy to parse... */
+        cli_err("%d : failed with this errno (%s)", rsp.op_errno,
+                strerror(rsp.op_errno));
+        ret = -1;
+    }
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_mount (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_mount(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_mount_req  req  = {0,};
-        int                ret  = -1;
-        void            **dataa = data;
-        char             *label = NULL;
-        dict_t            *dict = NULL;
+    gf1_cli_mount_req req = {
+        0,
+    };
+    int ret = -1;
+    void **dataa = data;
+    char *label = NULL;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        label = dataa[0];
-        dict  = dataa[1];
+    label = dataa[0];
+    dict = dataa[1];
 
-        req.label = label;
-        ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                           &req.dict.dict_len);
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    req.label = label;
+    ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                      &req.dict.dict_len);
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_MOUNT, NULL,
-                              this, gf_cli_mount_cbk,
-                              (xdrproc_t)xdr_gf1_cli_mount_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_MOUNT,
+                         NULL, this, gf_cli_mount_cbk,
+                         (xdrproc_t)xdr_gf1_cli_mount_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 static int
-gf_cli_umount_cbk (struct rpc_req *req, struct iovec *iov,
-                   int count, void *myframe)
+gf_cli_umount_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
 {
-        gf1_cli_umount_rsp rsp   = {0,};
-        int               ret   = -1;
+    gf1_cli_umount_rsp rsp = {
+        0,
+    };
+    int ret = -1;
 
-        GF_ASSERT (myframe);
+    GF_ASSERT(myframe);
 
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_umount_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf1_cli_umount_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
 
-        gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
+    gf_log("cli", GF_LOG_INFO, "Received resp to mount");
 
-        if (rsp.op_ret == 0)
-                ret = 0;
-        else {
-                cli_err ("umount failed");
-                ret = -1;
-        }
+    if (rsp.op_ret == 0)
+        ret = 0;
+    else {
+        cli_err("umount failed");
+        ret = -1;
+    }
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_umount (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_umount(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf1_cli_umount_req  req  = {0,};
-        int                ret  = -1;
-        dict_t            *dict = NULL;
+    gf1_cli_umount_req req = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        dict = data;
+    dict = data;
 
-        ret = dict_get_str (dict, "path", &req.path);
-        if (ret == 0)
-                ret = dict_get_int32 (dict, "lazy", &req.lazy);
+    ret = dict_get_str(dict, "path", &req.path);
+    if (ret == 0)
+        ret = dict_get_int32(dict, "lazy", &req.lazy);
 
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_UMOUNT, NULL,
-                              this, gf_cli_umount_cbk,
-                              (xdrproc_t)xdr_gf1_cli_umount_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog, GLUSTER_CLI_UMOUNT,
+                         NULL, this, gf_cli_umount_cbk,
+                         (xdrproc_t)xdr_gf1_cli_umount_req);
 
- out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+out:
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 void
-cmd_heal_volume_statistics_out (dict_t *dict, int  brick)
-{
-
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char            *hostname = NULL;
-        uint64_t        i = 0;
-        uint64_t        healed_count = 0;
-        uint64_t        split_brain_count = 0;
-        uint64_t        heal_failed_count = 0;
-        char            *start_time_str = NULL;
-        char            *end_time_str = NULL;
-        char            *crawl_type = NULL;
-        int             progress = -1;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
+cmd_heal_volume_statistics_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[256] = {0};
+    char *hostname = NULL;
+    uint64_t i = 0;
+    uint64_t healed_count = 0;
+    uint64_t split_brain_count = 0;
+    uint64_t heal_failed_count = 0;
+    char *start_time_str = NULL;
+    char *end_time_str = NULL;
+    char *crawl_type = NULL;
+    int progress = -1;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    cli_out("------------------------------------------------");
+    cli_out("\nCrawl statistics for brick no %d", brick);
+    cli_out("Hostname of brick %s", hostname);
+
+    snprintf(key, sizeof key, "statistics-%d-count", brick);
+    ret = dict_get_uint64(dict, key, &num_entries);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < num_entries; i++) {
+        snprintf(key, sizeof key, "statistics_crawl_type-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_str(dict, key, &crawl_type);
         if (ret)
-                goto out;
-        cli_out ("------------------------------------------------");
-        cli_out ("\nCrawl statistics for brick no %d", brick);
-        cli_out ("Hostname of brick %s", hostname);
+            goto out;
 
-        snprintf (key, sizeof key, "statistics-%d-count", brick);
-        ret = dict_get_uint64 (dict, key, &num_entries);
+        snprintf(key, sizeof key, "statistics_healed_cnt-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_uint64(dict, key, &healed_count);
         if (ret)
-                goto out;
-
-        for (i = 0; i < num_entries; i++)
-        {
-                snprintf (key, sizeof key, "statistics_crawl_type-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key, &crawl_type);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof key, "statistics_healed_cnt-%d-%"PRIu64,
-                          brick,i);
-                ret = dict_get_uint64 (dict, key, &healed_count);
-                if (ret)
-                        goto out;
-
-                snprintf (key, sizeof key, "statistics_sb_cnt-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_uint64 (dict, key, &split_brain_count);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_heal_failed_cnt-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_uint64 (dict, key, &heal_failed_count);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_strt_time-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key,  &start_time_str);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_end_time-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_str (dict, key, &end_time_str);
-                if (ret)
-                        goto out;
-                snprintf (key, sizeof key, "statistics_inprogress-%d-%"PRIu64,
-                          brick, i);
-                ret = dict_get_int32 (dict, key, &progress);
-                if (ret)
-                        goto out;
+            goto out;
 
-                cli_out ("\nStarting time of crawl: %s", start_time_str);
-                if (progress == 1)
-                        cli_out ("Crawl is in progress");
-                else
-                        cli_out ("Ending time of crawl: %s", end_time_str);
-
-                cli_out ("Type of crawl: %s", crawl_type);
-                cli_out ("No. of entries healed: %"PRIu64,
-                         healed_count);
-                cli_out ("No. of entries in split-brain: %"PRIu64,
-                        split_brain_count);
-                cli_out ("No. of heal failed entries: %"PRIu64,
-                         heal_failed_count);
+        snprintf(key, sizeof key, "statistics_sb_cnt-%d-%" PRIu64, brick, i);
+        ret = dict_get_uint64(dict, key, &split_brain_count);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_heal_failed_cnt-%d-%" PRIu64,
+                 brick, i);
+        ret = dict_get_uint64(dict, key, &heal_failed_count);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_strt_time-%d-%" PRIu64, brick, i);
+        ret = dict_get_str(dict, key, &start_time_str);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_end_time-%d-%" PRIu64, brick, i);
+        ret = dict_get_str(dict, key, &end_time_str);
+        if (ret)
+            goto out;
+        snprintf(key, sizeof key, "statistics_inprogress-%d-%" PRIu64, brick,
+                 i);
+        ret = dict_get_int32(dict, key, &progress);
+        if (ret)
+            goto out;
 
-        }
+        cli_out("\nStarting time of crawl: %s", start_time_str);
+        if (progress == 1)
+            cli_out("Crawl is in progress");
+        else
+            cli_out("Ending time of crawl: %s", end_time_str);
 
+        cli_out("Type of crawl: %s", crawl_type);
+        cli_out("No. of entries healed: %" PRIu64, healed_count);
+        cli_out("No. of entries in split-brain: %" PRIu64, split_brain_count);
+        cli_out("No. of heal failed entries: %" PRIu64, heal_failed_count);
+    }
 
 out:
-        return;
+    return;
 }
 
 void
-cmd_heal_volume_brick_out (dict_t *dict, int brick)
-{
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char           *hostname = NULL;
-        char           *path = NULL;
-        char           *status = NULL;
-        uint64_t        i = 0;
-        uint32_t        time = 0;
-        char            timestr[32] = {0};
-        char            *shd_status = NULL;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
-        if (ret)
-                goto out;
-        snprintf (key, sizeof key, "%d-path", brick);
-        ret = dict_get_str (dict, key, &path);
-        if (ret)
-                goto out;
-        cli_out ("\nBrick %s:%s", hostname, path);
-
-        snprintf (key, sizeof key, "%d-status", brick);
-        ret = dict_get_str (dict, key, &status);
-        if (status && strlen (status))
-                cli_out ("Status: %s", status);
-
-        snprintf (key, sizeof key, "%d-shd-status",brick);
-        ret = dict_get_str (dict, key, &shd_status);
-
-        if (!shd_status) {
-                snprintf (key, sizeof key, "%d-count", brick);
-                ret = dict_get_uint64 (dict, key, &num_entries);
-                cli_out ("Number of entries: %"PRIu64, num_entries);
-
-
-                for (i = 0; i < num_entries; i++) {
-                        snprintf (key, sizeof key, "%d-%"PRIu64, brick, i);
-                        ret = dict_get_str (dict, key, &path);
-                        if (ret)
-                                continue;
-                        time = 0;
-                        snprintf (key, sizeof key, "%d-%"PRIu64"-time",
-                                  brick, i);
-                        ret = dict_get_uint32 (dict, key, &time);
-                        if (ret || !time) {
-                                cli_out ("%s", path);
-                        } else {
-                                gf_time_fmt (timestr, sizeof timestr,
-                                             time, gf_timefmt_FT);
-                                if (i == 0) {
-                                cli_out ("at                    path on brick");
-                                cli_out ("-----------------------------------");
-                                }
-                                cli_out ("%s %s", timestr, path);
-                        }
-                }
-        }
-
-out:
-        return;
+cmd_heal_volume_brick_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[256] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *status = NULL;
+    uint64_t i = 0;
+    uint32_t time = 0;
+    char timestr[32] = {0};
+    char *shd_status = NULL;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof key, "%d-path", brick);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    cli_out("\nBrick %s:%s", hostname, path);
+
+    snprintf(key, sizeof key, "%d-status", brick);
+    ret = dict_get_str(dict, key, &status);
+    if (status && strlen(status))
+        cli_out("Status: %s", status);
+
+    snprintf(key, sizeof key, "%d-shd-status", brick);
+    ret = dict_get_str(dict, key, &shd_status);
+
+    if (!shd_status) {
+        snprintf(key, sizeof key, "%d-count", brick);
+        ret = dict_get_uint64(dict, key, &num_entries);
+        cli_out("Number of entries: %" PRIu64, num_entries);
+
+        for (i = 0; i < num_entries; i++) {
+            snprintf(key, sizeof key, "%d-%" PRIu64, brick, i);
+            ret = dict_get_str(dict, key, &path);
+            if (ret)
+                continue;
+            time = 0;
+            snprintf(key, sizeof key, "%d-%" PRIu64 "-time", brick, i);
+            ret = dict_get_uint32(dict, key, &time);
+            if (ret || !time) {
+                cli_out("%s", path);
+            } else {
+                gf_time_fmt(timestr, sizeof timestr, time, gf_timefmt_FT);
+                if (i == 0) {
+                    cli_out("at                    path on brick");
+                    cli_out("-----------------------------------");
+                }
+                cli_out("%s %s", timestr, path);
+            }
+        }
+    }
+
+out:
+    return;
 }
 
-
 void
-cmd_heal_volume_statistics_heal_count_out (dict_t *dict, int brick)
-{
-        uint64_t        num_entries = 0;
-        int             ret = 0;
-        char            key[256] = {0};
-        char           *hostname = NULL;
-        char           *path = NULL;
-        char           *status = NULL;
-        char            *shd_status = NULL;
-
-        snprintf (key, sizeof key, "%d-hostname", brick);
-        ret = dict_get_str (dict, key, &hostname);
+cmd_heal_volume_statistics_heal_count_out(dict_t *dict, int brick)
+{
+    uint64_t num_entries = 0;
+    int ret = 0;
+    char key[256] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *status = NULL;
+    char *shd_status = NULL;
+
+    snprintf(key, sizeof key, "%d-hostname", brick);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret)
+        goto out;
+    snprintf(key, sizeof key, "%d-path", brick);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    cli_out("\nBrick %s:%s", hostname, path);
+
+    snprintf(key, sizeof key, "%d-status", brick);
+    ret = dict_get_str(dict, key, &status);
+    if (status && strlen(status))
+        cli_out("Status: %s", status);
+
+    snprintf(key, sizeof key, "%d-shd-status", brick);
+    ret = dict_get_str(dict, key, &shd_status);
+
+    if (!shd_status) {
+        snprintf(key, sizeof key, "%d-hardlinks", brick);
+        ret = dict_get_uint64(dict, key, &num_entries);
         if (ret)
-                goto out;
-        snprintf (key, sizeof key, "%d-path", brick);
-        ret = dict_get_str (dict, key, &path);
-        if (ret)
-                goto out;
-        cli_out ("\nBrick %s:%s", hostname, path);
-
-        snprintf (key, sizeof key, "%d-status", brick);
-        ret = dict_get_str (dict, key, &status);
-        if (status && strlen (status))
-                cli_out ("Status: %s", status);
-
-        snprintf (key, sizeof key, "%d-shd-status",brick);
-        ret = dict_get_str (dict, key, &shd_status);
-
-        if(!shd_status)
-        {
-                snprintf (key, sizeof key, "%d-hardlinks", brick);
-                ret = dict_get_uint64 (dict, key, &num_entries);
-                if (ret)
-                        cli_out ("No gathered input for this brick");
-                else
-                        cli_out ("Number of entries: %"PRIu64, num_entries);
-
-
-        }
+            cli_out("No gathered input for this brick");
+        else
+            cli_out("Number of entries: %" PRIu64, num_entries);
+    }
 
 out:
-        return;
+    return;
 }
 
 int
-gf_is_cli_heal_get_command (gf_xl_afr_op_t heal_op)
-{
-        /* If the command is get command value is 1 otherwise 0, for
-           invalid commands -1 */
-        int    get_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
-                       [GF_SHD_OP_INVALID] = -1,
-                       [GF_SHD_OP_HEAL_INDEX] = 0,
-                       [GF_SHD_OP_HEAL_FULL] = 0,
-                       [GF_SHD_OP_INDEX_SUMMARY] = 1,
-                       [GF_SHD_OP_HEALED_FILES] = 1,
-                       [GF_SHD_OP_HEAL_FAILED_FILES] = 1,
-                       [GF_SHD_OP_SPLIT_BRAIN_FILES] = 1,
-                       [GF_SHD_OP_STATISTICS] = 1,
-                       [GF_SHD_OP_STATISTICS_HEAL_COUNT] = 1,
-                       [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = 1,
-                       [GF_SHD_OP_HEAL_ENABLE] = 0,
-                       [GF_SHD_OP_HEAL_DISABLE] = 0,
-                };
-
-        if (heal_op > GF_SHD_OP_INVALID && heal_op <= GF_SHD_OP_HEAL_DISABLE)
-                return get_cmds[heal_op] == 1;
-        return _gf_false;
+gf_is_cli_heal_get_command(gf_xl_afr_op_t heal_op)
+{
+    /* If the command is get command value is 1 otherwise 0, for
+       invalid commands -1 */
+    int get_cmds[GF_SHD_OP_HEAL_DISABLE + 1] = {
+        [GF_SHD_OP_INVALID] = -1,
+        [GF_SHD_OP_HEAL_INDEX] = 0,
+        [GF_SHD_OP_HEAL_FULL] = 0,
+        [GF_SHD_OP_INDEX_SUMMARY] = 1,
+        [GF_SHD_OP_HEALED_FILES] = 1,
+        [GF_SHD_OP_HEAL_FAILED_FILES] = 1,
+        [GF_SHD_OP_SPLIT_BRAIN_FILES] = 1,
+        [GF_SHD_OP_STATISTICS] = 1,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT] = 1,
+        [GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA] = 1,
+        [GF_SHD_OP_HEAL_ENABLE] = 0,
+        [GF_SHD_OP_HEAL_DISABLE] = 0,
+    };
+
+    if (heal_op > GF_SHD_OP_INVALID && heal_op <= GF_SHD_OP_HEAL_DISABLE)
+        return get_cmds[heal_op] == 1;
+    return _gf_false;
 }
 
 int
-gf_cli_heal_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                             int count, void *myframe)
-{
-        gf_cli_rsp              rsp   = {0,};
-        int                     ret   = -1;
-        cli_local_t             *local = NULL;
-        char                    *volname = NULL;
-        call_frame_t            *frame = NULL;
-        dict_t                  *dict = NULL;
-        int                     brick_count = 0;
-        int                     i = 0;
-        gf_xl_afr_op_t          heal_op = GF_SHD_OP_INVALID;
-        char                    *operation = NULL;
-        char                    *substr = NULL;
-        char                    *heal_op_str = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        GF_ASSERT (frame->local);
-
-        local = frame->local;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "heal-op", (int32_t *)&heal_op);
-//TODO: Proper XML output
-//#if (HAVE_LIB_XML)
-//        if (global_state->mode & GLUSTER_MODE_XML) {
-//                ret = cli_xml_output_dict ("volHeal", dict, rsp.op_ret,
-//                                           rsp.op_errno, rsp.op_errstr);
-//                if (ret)
-//                        gf_log ("cli", GF_LOG_ERROR,
-//                                "Error outputting to xml");
-//                goto out;
-//        }
-//#endif
-
-        ret = dict_get_str (local->dict, "volname", &volname);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to get volname");
-                goto out;
-        }
-
-        gf_log ("cli", GF_LOG_INFO, "Received resp to heal volume");
-
-        operation = "Gathering ";
-        substr = "";
-        switch (heal_op) {
-        case    GF_SHD_OP_HEAL_INDEX:
-                operation   = "Launching heal operation ";
-                heal_op_str = "to perform index self heal";
-                substr      = "\nUse heal info commands to check"
-                              " status.";
-                break;
-        case    GF_SHD_OP_HEAL_FULL:
-                operation   = "Launching heal operation ";
-                heal_op_str = "to perform full self heal";
-                substr      = "\nUse heal info commands to check"
-                              " status.";
-                break;
-        case    GF_SHD_OP_INDEX_SUMMARY:
-                heal_op_str = "list of entries to be healed";
-                break;
-        case    GF_SHD_OP_HEALED_FILES:
-                heal_op_str = "list of healed entries";
-                break;
-        case    GF_SHD_OP_HEAL_FAILED_FILES:
-                heal_op_str = "list of heal failed entries";
-                break;
-        case    GF_SHD_OP_SPLIT_BRAIN_FILES:
-                heal_op_str = "list of split brain entries";
-                break;
-        case    GF_SHD_OP_STATISTICS:
-                heal_op_str =  "crawl statistics";
-                break;
-        case    GF_SHD_OP_STATISTICS_HEAL_COUNT:
-                heal_op_str = "count of entries to be healed";
-                break;
-        case    GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                heal_op_str = "count of entries to be healed per replica";
-                break;
+gf_cli_heal_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    cli_local_t *local = NULL;
+    char *volname = NULL;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+    int brick_count = 0;
+    int i = 0;
+    gf_xl_afr_op_t heal_op = GF_SHD_OP_INVALID;
+    char *operation = NULL;
+    char *substr = NULL;
+    char *heal_op_str = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    GF_ASSERT(frame->local);
+
+    local = frame->local;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "heal-op", (int32_t *)&heal_op);
+    // TODO: Proper XML output
+    //#if (HAVE_LIB_XML)
+    //        if (global_state->mode & GLUSTER_MODE_XML) {
+    //                ret = cli_xml_output_dict ("volHeal", dict, rsp.op_ret,
+    //                                           rsp.op_errno, rsp.op_errstr);
+    //                if (ret)
+    //                        gf_log ("cli", GF_LOG_ERROR,
+    //                                "Error outputting to xml");
+    //                goto out;
+    //        }
+    //#endif
+
+    ret = dict_get_str(local->dict, "volname", &volname);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get volname");
+        goto out;
+    }
+
+    gf_log("cli", GF_LOG_INFO, "Received resp to heal volume");
+
+    operation = "Gathering ";
+    substr = "";
+    switch (heal_op) {
+        case GF_SHD_OP_HEAL_INDEX:
+            operation = "Launching heal operation ";
+            heal_op_str = "to perform index self heal";
+            substr =
+                "\nUse heal info commands to check"
+                " status.";
+            break;
+        case GF_SHD_OP_HEAL_FULL:
+            operation = "Launching heal operation ";
+            heal_op_str = "to perform full self heal";
+            substr =
+                "\nUse heal info commands to check"
+                " status.";
+            break;
+        case GF_SHD_OP_INDEX_SUMMARY:
+            heal_op_str = "list of entries to be healed";
+            break;
+        case GF_SHD_OP_HEALED_FILES:
+            heal_op_str = "list of healed entries";
+            break;
+        case GF_SHD_OP_HEAL_FAILED_FILES:
+            heal_op_str = "list of heal failed entries";
+            break;
+        case GF_SHD_OP_SPLIT_BRAIN_FILES:
+            heal_op_str = "list of split brain entries";
+            break;
+        case GF_SHD_OP_STATISTICS:
+            heal_op_str = "crawl statistics";
+            break;
+        case GF_SHD_OP_STATISTICS_HEAL_COUNT:
+            heal_op_str = "count of entries to be healed";
+            break;
+        case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
+            heal_op_str = "count of entries to be healed per replica";
+            break;
         /* The below 4 cases are never hit; they're coded only to make
          * compiler warnings go away.*/
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-        case    GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-        case    GF_SHD_OP_HEAL_SUMMARY:
-                break;
-
-        case    GF_SHD_OP_INVALID:
-                heal_op_str = "invalid heal op";
-                break;
-        case    GF_SHD_OP_HEAL_ENABLE:
-                operation   = "";
-                heal_op_str = "Enable heal";
-                break;
-        case    GF_SHD_OP_HEAL_DISABLE:
-                operation   = "";
-                heal_op_str = "Disable heal";
-                break;
-        case    GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
-                operation   = "";
-                heal_op_str = "Enable granular entry heal";
-                break;
-        case    GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
-                operation   = "";
-                heal_op_str = "Disable granular entry heal";
-                break;
-        }
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, "")) {
-                        cli_err ("%s%s on volume %s has been unsuccessful:",
-                                 operation, heal_op_str, volname);
-                        cli_err ("%s", rsp.op_errstr);
-                }
-                ret = rsp.op_ret;
-                goto out;
-        } else {
-                cli_out ("%s%s on volume %s has been successful %s", operation,
-                         heal_op_str, volname, substr);
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
+        case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
+        case GF_SHD_OP_HEAL_SUMMARY:
+            break;
+
+        case GF_SHD_OP_INVALID:
+            heal_op_str = "invalid heal op";
+            break;
+        case GF_SHD_OP_HEAL_ENABLE:
+            operation = "";
+            heal_op_str = "Enable heal";
+            break;
+        case GF_SHD_OP_HEAL_DISABLE:
+            operation = "";
+            heal_op_str = "Disable heal";
+            break;
+        case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
+            operation = "";
+            heal_op_str = "Enable granular entry heal";
+            break;
+        case GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE:
+            operation = "";
+            heal_op_str = "Disable granular entry heal";
+            break;
+    }
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, "")) {
+            cli_err("%s%s on volume %s has been unsuccessful:", operation,
+                    heal_op_str, volname);
+            cli_err("%s", rsp.op_errstr);
         }
-
         ret = rsp.op_ret;
-        if (!gf_is_cli_heal_get_command (heal_op))
-                goto out;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val,
-                                rsp.dict.dict_len,
-                                &dict);
-
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                                "Unable to allocate memory");
-                goto out;
-        } else {
-                dict->extra_stdfree = rsp.dict.dict_val;
-        }
-        ret = dict_get_int32 (dict, "count", &brick_count);
-        if (ret)
-                goto out;
-
-        if (!brick_count) {
-                cli_err ("All bricks of volume %s are down.", volname);
-                goto out;
-        }
-
-        switch (heal_op) {
+        goto out;
+    } else {
+        cli_out("%s%s on volume %s has been successful %s", operation,
+                heal_op_str, volname, substr);
+    }
+
+    ret = rsp.op_ret;
+    if (!gf_is_cli_heal_get_command(heal_op))
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret) {
+        gf_log("", GF_LOG_ERROR, "Unable to allocate memory");
+        goto out;
+    } else {
+        dict->extra_stdfree = rsp.dict.dict_val;
+    }
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+
+    if (!brick_count) {
+        cli_err("All bricks of volume %s are down.", volname);
+        goto out;
+    }
+
+    switch (heal_op) {
         case GF_SHD_OP_STATISTICS:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_statistics_out (dict, i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_statistics_out(dict, i);
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT:
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_statistics_heal_count_out (dict,
-                                                                   i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_statistics_heal_count_out(dict, i);
+            break;
         case GF_SHD_OP_INDEX_SUMMARY:
         case GF_SHD_OP_HEALED_FILES:
         case GF_SHD_OP_HEAL_FAILED_FILES:
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-                for (i = 0; i < brick_count; i++)
-                        cmd_heal_volume_brick_out (dict, i);
-                break;
+            for (i = 0; i < brick_count; i++)
+                cmd_heal_volume_brick_out(dict, i);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        free (rsp.op_errstr);
-        if (dict)
-                dict_unref (dict);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    free(rsp.op_errstr);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int32_t
-gf_cli_heal_volume (call_frame_t *frame, xlator_t *this,
-                         void *data)
+gf_cli_heal_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req              req = {{0,}};
-        int                     ret = 0;
-        dict_t                  *dict = NULL;
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = 0;
+    dict_t *dict = NULL;
 
-        if (!frame || !this ||  !data) {
-                ret = -1;
-                goto out;
-        }
+    if (!frame || !this || !data) {
+        ret = -1;
+        goto out;
+    }
 
-        dict = data;
+    dict = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_heal_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, dict,
-                               GLUSTER_CLI_HEAL_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_heal_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, dict,
+                          GLUSTER_CLI_HEAL_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_statedump_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                int count, void *myframe)
-{
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-        char                            msg[1024] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to statedump");
-        if (rsp.op_ret)
-                snprintf (msg, sizeof(msg), "%s", rsp.op_errstr);
-        else
-                snprintf (msg, sizeof (msg), "Volume statedump successful");
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_str ("volStatedump", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+gf_cli_statedump_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                            void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char msg[1024] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to statedump");
+    if (rsp.op_ret)
+        snprintf(msg, sizeof(msg), "%s", rsp.op_errstr);
+    else
+        snprintf(msg, sizeof(msg), "Volume statedump successful");
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_str("volStatedump", msg, rsp.op_ret, rsp.op_errno,
+                                 rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (rsp.op_ret)
-                cli_err ("volume statedump: failed: %s", msg);
-        else
-                cli_out ("volume statedump: success");
-        ret = rsp.op_ret;
+    if (rsp.op_ret)
+        cli_err("volume statedump: failed: %s", msg);
+    else
+        cli_out("volume statedump: success");
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_statedump_volume (call_frame_t *frame, xlator_t *this,
-                            void *data)
+gf_cli_statedump_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_statedump_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(
+        &req, frame, gf_cli_statedump_volume_cbk, (xdrproc_t)xdr_gf_cli_req,
+        options, GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog, NULL);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_list_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                int count, void *myframe)
-{
-        int             ret = -1;
-        gf_cli_rsp      rsp = {0,};
-        dict_t          *dict = NULL;
-        int             vol_count = 0;;
-        char            *volname = NULL;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+gf_cli_list_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    int vol_count = 0;
+    ;
+    char *volname = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to allocate memory");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_list(dict, rsp.op_ret, rsp.op_errno,
+                                      rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
+
+    if (rsp.op_ret)
+        cli_err("%s", rsp.op_errstr);
+    else {
+        ret = dict_get_int32(dict, "count", &vol_count);
+        if (ret)
+            goto out;
 
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to allocate memory");
-                goto out;
+        if (vol_count == 0) {
+            cli_err("No volumes present in cluster");
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_list (dict, rsp.op_ret, rsp.op_errno,
-                                               rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
+        for (i = 0; i < vol_count; i++) {
+            snprintf(key, sizeof(key), "volume%d", i);
+            ret = dict_get_str(dict, key, &volname);
+            if (ret)
                 goto out;
+            cli_out("%s", volname);
         }
+    }
 
-        if (rsp.op_ret)
-                cli_err ("%s", rsp.op_errstr);
-        else {
-                ret = dict_get_int32 (dict, "count", &vol_count);
-                if (ret)
-                        goto out;
-
-                if (vol_count == 0) {
-                        cli_err ("No volumes present in cluster");
-                        goto out;
-                }
-                for (i = 0; i < vol_count; i++) {
-                        snprintf (key, sizeof (key), "volume%d", i);
-                        ret = dict_get_str (dict, key, &volname);
-                        if (ret)
-                                goto out;
-                        cli_out ("%s", volname);
-                }
-        }
-
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_list_volume (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_list_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        int             ret = -1;
-        gf_cli_req      req = {{0,}};
+    int ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
 
-        if (!frame || !this)
-                goto out;
+    if (!frame || !this)
+        goto out;
 
-        ret = cli_cmd_submit (NULL, &req, frame, cli_rpc_prog,
-                              GLUSTER_CLI_LIST_VOLUME, NULL,
-                              this, gf_cli_list_volume_cbk,
-                              (xdrproc_t)xdr_gf_cli_req);
+    ret = cli_cmd_submit(NULL, &req, frame, cli_rpc_prog,
+                         GLUSTER_CLI_LIST_VOLUME, NULL, this,
+                         gf_cli_list_volume_cbk, (xdrproc_t)xdr_gf_cli_req);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_cli_clearlocks_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                  int count, void *myframe)
-{
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-        char                            *lk_summary = NULL;
-        char                            *volname = NULL;
-        dict_t                          *dict = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp,
-                              (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
+gf_cli_clearlocks_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                             void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    char *lk_summary = NULL;
+    char *volname = NULL;
+    dict_t *dict = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to clear-locks");
+
+    if (rsp.op_ret) {
+        cli_err("Volume clear-locks unsuccessful");
+        cli_err("%s", rsp.op_errstr);
+
+    } else {
+        if (!rsp.dict.dict_len) {
+            cli_err("Possibly no locks cleared");
+            ret = 0;
+            goto out;
         }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to clear-locks");
-
-        if (rsp.op_ret) {
-                cli_err ("Volume clear-locks unsuccessful");
-                cli_err ("%s", rsp.op_errstr);
-
-        } else {
-                if (!rsp.dict.dict_len) {
-                        cli_err ("Possibly no locks cleared");
-                        ret = 0;
-                        goto out;
-                }
 
-                dict = dict_new ();
+        dict = dict_new();
 
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
+        if (!dict) {
+            ret = -1;
+            goto out;
+        }
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to serialize response dictionary");
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get volname "
-                                "from dictionary");
-                        goto out;
-                }
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to serialize response dictionary");
+            goto out;
+        }
 
-                ret = dict_get_str (dict, "lk-summary", &lk_summary);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get lock "
-                                "summary from dictionary");
-                        goto out;
-                }
-                cli_out ("Volume clear-locks successful");
-                cli_out ("%s", lk_summary);
+        ret = dict_get_str(dict, "volname", &volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to get volname "
+                   "from dictionary");
+            goto out;
+        }
 
+        ret = dict_get_str(dict, "lk-summary", &lk_summary);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to get lock "
+                   "summary from dictionary");
+            goto out;
         }
+        cli_out("Volume clear-locks successful");
+        cli_out("%s", lk_summary);
+    }
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int32_t
-gf_cli_clearlocks_volume (call_frame_t *frame, xlator_t *this,
-                             void *data)
+gf_cli_clearlocks_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_clearlocks_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_CLRLOCKS_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(
+        &req, frame, gf_cli_clearlocks_volume_cbk, (xdrproc_t)xdr_gf_cli_req,
+        options, GLUSTER_CLI_CLRLOCKS_VOLUME, this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-cli_snapshot_remove_reply (gf_cli_rsp *rsp, dict_t *dict, call_frame_t *frame)
+cli_snapshot_remove_reply(gf_cli_rsp *rsp, dict_t *dict, call_frame_t *frame)
 {
-        int32_t         ret             = -1;
-        char            *snap_name      = NULL;
-        int32_t         delete_cmd      = -1;
-        cli_local_t     *local          = NULL;
+    int32_t ret = -1;
+    char *snap_name = NULL;
+    int32_t delete_cmd = -1;
+    cli_local_t *local = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (rsp);
-        GF_ASSERT (dict);
+    GF_ASSERT(frame);
+    GF_ASSERT(rsp);
+    GF_ASSERT(dict);
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = dict_get_int32 (dict, "sub-cmd", &delete_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get sub-cmd");
-                goto end;
-        }
+    ret = dict_get_int32(dict, "sub-cmd", &delete_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get sub-cmd");
+        goto end;
+    }
 
-        if ((global_state->mode & GLUSTER_MODE_XML) &&
-            (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
-                ret = cli_xml_output_snap_delete_begin (local, rsp->op_ret,
-                                                        rsp->op_errno,
-                                                        rsp->op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for delete");
-                        goto end;
-                }
+    if ((global_state->mode & GLUSTER_MODE_XML) &&
+        (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
+        ret = cli_xml_output_snap_delete_begin(local, rsp->op_ret,
+                                               rsp->op_errno, rsp->op_errstr);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for delete");
+            goto end;
+        }
+    }
+
+    if (rsp->op_ret && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_err("snapshot delete: failed: %s",
+                rsp->op_errstr ? rsp->op_errstr
+                               : "Please check log file for details");
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL ||
+        delete_cmd == GF_SNAP_DELETE_TYPE_VOL) {
+        local = ((call_frame_t *)frame)->local;
+        if (!local) {
+            ret = -1;
+            gf_log("cli", GF_LOG_ERROR, "frame->local is NULL");
+            goto out;
         }
 
+        /* During first call back of snapshot delete of type
+         * ALL and VOL, We will get the snapcount and snapnames.
+         * Hence to make the subsequent rpc calls for individual
+         * snapshot delete, We need to save it in local dictionary.
+         */
+        dict_copy(dict, local->dict);
+        ret = 0;
+        goto out;
+    }
 
-        if (rsp->op_ret && !(global_state->mode & GLUSTER_MODE_XML)) {
-                        cli_err ("snapshot delete: failed: %s",
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                 "Please check log file for details");
-                ret = rsp->op_ret;
-                goto out;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_delete(local, dict, rsp);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot delete command");
+            goto out;
         }
-
-        if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL ||
-            delete_cmd == GF_SNAP_DELETE_TYPE_VOL) {
-                local = ((call_frame_t *) frame) -> local;
-                if (!local) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "frame->local is NULL");
-                        goto out;
-                }
-
-                /* During first call back of snapshot delete of type
-                 * ALL and VOL, We will get the snapcount and snapnames.
-                 * Hence to make the subsequent rpc calls for individual
-                 * snapshot delete, We need to save it in local dictionary.
-                 */
-                dict_copy (dict, local->dict);
-                ret = 0;
-                goto out;
+        /* Error out in case of the op already failed */
+        if (rsp->op_ret) {
+            ret = rsp->op_ret;
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_delete (local, dict, rsp);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot delete command");
-                        goto out;
-                }
-                /* Error out in case of the op already failed */
-                if (rsp->op_ret) {
-                        ret = rsp->op_ret;
-                        goto out;
-                }
-        } else {
-                ret = dict_get_str (dict, "snapname", &snap_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snapname");
-                        goto out;
-                }
-
-                cli_out ("snapshot delete: %s: snap removed successfully",
-                         snap_name);
+    } else {
+        ret = dict_get_str(dict, "snapname", &snap_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to get snapname");
+            goto out;
         }
-        ret = 0;
+
+        cli_out("snapshot delete: %s: snap removed successfully", snap_name);
+    }
+    ret = 0;
 
 out:
-        if ((global_state->mode & GLUSTER_MODE_XML) &&
-            (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
-                ret = cli_xml_output_snap_delete_end (local);
-        }
+    if ((global_state->mode & GLUSTER_MODE_XML) &&
+        (delete_cmd == GF_SNAP_DELETE_TYPE_SNAP)) {
+        ret = cli_xml_output_snap_delete_end(local);
+    }
 end:
-        return ret;
+    return ret;
 }
 
 int
-cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp)
-{
-        char                buf[PATH_MAX]        = "";
-        char               *volname              = NULL;
-        int                 ret                  = -1;
-        int                 config_command       = 0;
-        uint64_t            value                = 0;
-        uint64_t            hard_limit           = 0;
-        uint64_t            soft_limit           = 0;
-        uint64_t            i                    = 0;
-        uint64_t            voldisplaycount      = 0;
-        char               *auto_delete          = NULL;
-        char               *snap_activate        = NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (rsp);
+cli_snapshot_config_display(dict_t *dict, gf_cli_rsp *rsp)
+{
+    char buf[PATH_MAX] = "";
+    char *volname = NULL;
+    int ret = -1;
+    int config_command = 0;
+    uint64_t value = 0;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    uint64_t i = 0;
+    uint64_t voldisplaycount = 0;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(rsp);
+
+    if (rsp->op_ret) {
+        cli_err("Snapshot Config : failed: %s",
+                rsp->op_errstr ? rsp->op_errstr
+                               : "Please check log file for details");
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "config-command", &config_command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    /* Ignore the error, as volname is optional */
+
+    if (!volname) {
+        volname = "System";
+    }
+
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+    /* Ignore the error, as the key specified is optional */
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+
+    ret = dict_get_str(dict, "auto-delete", &auto_delete);
+
+    ret = dict_get_str(dict, "snap-activate-on-create", &snap_activate);
+
+    if (!hard_limit && !soft_limit &&
+        config_command != GF_SNAP_CONFIG_DISPLAY && !auto_delete &&
+        !snap_activate) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "Could not fetch config-key");
+        goto out;
+    }
+
+    switch (config_command) {
+        case GF_SNAP_CONFIG_TYPE_SET:
+            if (hard_limit && soft_limit) {
+                cli_out(
+                    "snapshot config: snap-max-hard-limit "
+                    "& snap-max-soft-limit for system set "
+                    "successfully");
+            } else if (hard_limit) {
+                cli_out(
+                    "snapshot config: snap-max-hard-limit "
+                    "for %s set successfully",
+                    volname);
+            } else if (soft_limit) {
+                cli_out(
+                    "snapshot config: snap-max-soft-limit "
+                    "for %s set successfully",
+                    volname);
+            } else if (auto_delete) {
+                cli_out(
+                    "snapshot config: auto-delete "
+                    "successfully set");
+            } else if (snap_activate) {
+                cli_out(
+                    "snapshot config: activate-on-create "
+                    "successfully set");
+            }
+            break;
 
-        if (rsp->op_ret) {
-                cli_err ("Snapshot Config : failed: %s",
-                         rsp->op_errstr ? rsp->op_errstr :
-                         "Please check log file for details");
-                ret = rsp->op_ret;
+        case GF_SNAP_CONFIG_DISPLAY:
+            cli_out("\nSnapshot System Configuration:");
+            ret = dict_get_uint64(dict, "snap-max-hard-limit", &value);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Could not fetch "
+                       "snap_max_hard_limit for %s",
+                       volname);
+                ret = -1;
                 goto out;
-        }
+            }
+            cli_out("snap-max-hard-limit : %" PRIu64, value);
 
-        ret = dict_get_int32 (dict, "config-command", &config_command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch config type");
+            ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Could not fetch "
+                       "snap-max-soft-limit for %s",
+                       volname);
+                ret = -1;
                 goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        /* Ignore the error, as volname is optional */
+            }
+            cli_out("snap-max-soft-limit : %" PRIu64 "%%", soft_limit);
 
-        if (!volname) {
-                volname = "System";
-        }
+            cli_out("auto-delete : %s", auto_delete);
 
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &hard_limit);
-        /* Ignore the error, as the key specified is optional */
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &soft_limit);
+            cli_out("activate-on-create : %s\n", snap_activate);
 
-        ret = dict_get_str (dict, "auto-delete", &auto_delete);
+            cli_out("Snapshot Volume Configuration:");
 
-        ret = dict_get_str (dict, "snap-activate-on-create", &snap_activate);
-
-        if (!hard_limit && !soft_limit
-                        && config_command != GF_SNAP_CONFIG_DISPLAY
-                        && !auto_delete && !snap_activate) {
+            ret = dict_get_uint64(dict, "voldisplaycount", &voldisplaycount);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not fetch voldisplaycount");
                 ret = -1;
-                gf_log(THIS->name, GF_LOG_ERROR,
-                       "Could not fetch config-key");
                 goto out;
-        }
-
-        switch (config_command) {
-        case GF_SNAP_CONFIG_TYPE_SET:
-                if (hard_limit && soft_limit) {
-                        cli_out ("snapshot config: snap-max-hard-limit "
-                                "& snap-max-soft-limit for system set "
-                                 "successfully");
-                } else if (hard_limit) {
-                        cli_out ("snapshot config: snap-max-hard-limit "
-                                 "for %s set successfully",
-                                 volname);
-                } else if (soft_limit) {
-                        cli_out ("snapshot config: snap-max-soft-limit "
-                                 "for %s set successfully",
-                                 volname);
-                } else if (auto_delete) {
-                        cli_out ("snapshot config: auto-delete "
-                                 "successfully set");
-                } else if (snap_activate) {
-                        cli_out ("snapshot config: activate-on-create "
-                                 "successfully set");
-                }
-                break;
+            }
 
-        case GF_SNAP_CONFIG_DISPLAY:
-                cli_out ("\nSnapshot System Configuration:");
-                ret = dict_get_uint64 (dict, "snap-max-hard-limit",
-                                       &value);
+            for (i = 0; i < voldisplaycount; i++) {
+                snprintf(buf, sizeof(buf), "volume%" PRIu64 "-volname", i);
+                ret = dict_get_str(dict, buf, &volname);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                "snap_max_hard_limit for %s", volname);
-                        ret = -1;
-                        goto out;
-                }
-                cli_out ("snap-max-hard-limit : %"PRIu64, value);
-
-                ret = dict_get_uint64 (dict, "snap-max-soft-limit",
-                                       &soft_limit);
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Could not fetch "
+                           " %s",
+                           buf);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("\nVolume : %s", volname);
+
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-snap-max-hard-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                               "snap-max-soft-limit for %s", volname);
-                        ret = -1;
-                        goto out;
-                }
-                cli_out ("snap-max-soft-limit : %"PRIu64"%%",
-                         soft_limit);
-
-                cli_out ("auto-delete : %s", auto_delete);
-
-                cli_out ("activate-on-create : %s\n", snap_activate);
-
-                cli_out ("Snapshot Volume Configuration:");
-
-                ret = dict_get_uint64 (dict, "voldisplaycount",
-                                       &voldisplaycount);
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Could not fetch "
+                           " %s",
+                           buf);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("snap-max-hard-limit : %" PRIu64, value);
+
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-active-hard-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                               "Could not fetch voldisplaycount");
-                        ret = -1;
-                        goto out;
-                }
-
-                for (i = 0; i < voldisplaycount; i++) {
-                        snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i);
-                        ret = dict_get_str (dict, buf, &volname);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("\nVolume : %s", volname);
-
-                        snprintf (buf, sizeof(buf),
-                                  "volume%"PRIu64"-snap-max-hard-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("snap-max-hard-limit : %"PRIu64, value);
-
-                        snprintf (buf, sizeof(buf),
-                                  "volume%"PRIu64"-active-hard-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                 gf_log ("cli", GF_LOG_ERROR, "Could not fetch"
-                                        " effective snap_max_hard_limit for "
-                                        "%s", volname);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("Effective snap-max-hard-limit : %"PRIu64,
-                                 value);
-
-                        snprintf (buf, sizeof(buf),
-                                      "volume%"PRIu64"-snap-max-soft-limit", i);
-                        ret = dict_get_uint64 (dict, buf, &value);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                       " %s", buf);
-                                ret = -1;
-                                goto out;
-                        }
-                        cli_out ("Effective snap-max-soft-limit : %"PRIu64" "
-                                 "(%"PRIu64"%%)", value, soft_limit);
-                }
-                break;
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Could not fetch"
+                           " effective snap_max_hard_limit for "
+                           "%s",
+                           volname);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("Effective snap-max-hard-limit : %" PRIu64, value);
+
+                snprintf(buf, sizeof(buf),
+                         "volume%" PRIu64 "-snap-max-soft-limit", i);
+                ret = dict_get_uint64(dict, buf, &value);
+                if (ret) {
+                    gf_log("cli", GF_LOG_ERROR,
+                           "Could not fetch "
+                           " %s",
+                           buf);
+                    ret = -1;
+                    goto out;
+                }
+                cli_out("Effective snap-max-soft-limit : %" PRIu64
+                        " "
+                        "(%" PRIu64 "%%)",
+                        value, soft_limit);
+            }
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function is used to print the volume related information
@@ -9749,91 +9706,86 @@ out:
  * arg - 1, prefix str : snaplist.snap{0..}.vol{0..}.*
  */
 int
-cli_get_each_volinfo_in_snap (dict_t *dict, char *keyprefix,
-                              gf_boolean_t snap_driven) {
-        char             key[PATH_MAX]  =  "";
-        char            *get_buffer     =  NULL;
-        int              value          =  0;
-        int              ret            = -1;
-        char             indent[5]      = "\t";
-        char            *volname        =  NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        if (snap_driven) {
-                ret = snprintf (key, sizeof (key), "%s.volname", keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &get_buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                        "Snap Volume Name", ":", get_buffer);
-
-                ret = snprintf (key, sizeof (key),
-                                "%s.origin-volname", keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
+cli_get_each_volinfo_in_snap(dict_t *dict, char *keyprefix,
+                             gf_boolean_t snap_driven)
+{
+    char key[PATH_MAX] = "";
+    char *get_buffer = NULL;
+    int value = 0;
+    int ret = -1;
+    char indent[5] = "\t";
+    char *volname = NULL;
 
-                ret = dict_get_str (dict, key, &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_WARNING, "Failed to get %s", key);
-                        cli_out ("%-12s", "Origin:");
-                }
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                        "Origin Volume name", ":", volname);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
 
+    if (snap_driven) {
+        ret = snprintf(key, sizeof(key), "%s.volname", keyprefix);
+        if (ret < 0) {
+            goto out;
+        }
 
-                ret = snprintf (key, sizeof (key), "%s.snapcount",
-                                keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
+        ret = dict_get_str(dict, key, &get_buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
+        }
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snap Volume Name", ":",
+                get_buffer);
 
-                ret = dict_get_int32 (dict, key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s%s %s      %s %d", indent, "Snaps taken for",
-                        volname, ":", value);
+        ret = snprintf(key, sizeof(key), "%s.origin-volname", keyprefix);
+        if (ret < 0) {
+            goto out;
+        }
 
-                ret = snprintf (key, sizeof (key), "%s.snaps-available",
-                                keyprefix);
-                if (ret < 0) {
-                        goto out;
-                }
+        ret = dict_get_str(dict, key, &volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_WARNING, "Failed to get %s", key);
+            cli_out("%-12s", "Origin:");
+        }
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Origin Volume name", ":",
+                volname);
 
-                ret = dict_get_int32 (dict, key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                        goto out;
-                }
-                cli_out ("%s%s %s  %s %d", indent, "Snaps available for",
-                         volname, ":", value);
+        ret = snprintf(key, sizeof(key), "%s.snapcount", keyprefix);
+        if (ret < 0) {
+            goto out;
         }
 
+        ret = dict_get_int32(dict, key, &value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
+        }
+        cli_out("%s%s %s      %s %d", indent, "Snaps taken for", volname, ":",
+                value);
 
-        ret = snprintf (key, sizeof (key), "%s.vol-status", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.snaps-available", keyprefix);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_int32(dict, key, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+            goto out;
         }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Status",
-                 ":", get_buffer);
+        cli_out("%s%s %s  %s %d", indent, "Snaps available for", volname, ":",
+                value);
+    }
+
+    ret = snprintf(key, sizeof(key), "%s.vol-status", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Status", ":", get_buffer);
 out:
-        return ret;
+    return ret;
 }
 
 /* This function is used to print snap related information
@@ -9841,924 +9793,890 @@ out:
  * arg - 1, prefix_str : snaplist.snap{0..}.*
  */
 int
-cli_get_volinfo_in_snap (dict_t *dict, char *keyprefix) {
+cli_get_volinfo_in_snap(dict_t *dict, char *keyprefix)
+{
+    char key[PATH_MAX] = "";
+    int i = 0;
+    int volcount = 0;
+    int ret = -1;
 
-        char            key[PATH_MAX]   = "";
-        int             i               = 0;
-        int             volcount        = 0;
-        int             ret             = -1;
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
 
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
+    ret = snprintf(key, sizeof(key), "%s.vol-count", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
 
-        ret = snprintf (key, sizeof (key), "%s.vol-count", keyprefix);
+    ret = dict_get_int32(dict, key, &volcount);
+    for (i = 1; i <= volcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
-
-        ret = dict_get_int32 (dict, key, &volcount);
-        for (i = 1 ; i <= volcount ; i++) {
-                ret = snprintf (key, sizeof (key),
-                                "%s.vol%d", keyprefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_volinfo_in_snap (dict, key, _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not list "
-                                "details of volume in a snap");
-                        goto out;
-                }
-                cli_out (" ");
+        ret = cli_get_each_volinfo_in_snap(dict, key, _gf_true);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not list "
+                   "details of volume in a snap");
+            goto out;
         }
+        cli_out(" ");
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_get_each_snap_info (dict_t *dict, char *prefix_str,
-                        gf_boolean_t snap_driven) {
-        char            key_buffer[PATH_MAX] = "";
-        char           *get_buffer           = NULL;
-        int             ret                  = -1;
-        char            indent[5]            = "";
-
-        GF_ASSERT (dict);
-        GF_ASSERT (prefix_str);
-
-        if (!snap_driven)
-                strcat (indent, "\t");
-
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snapname",
-                        prefix_str);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ",
-                        key_buffer);
-                goto out;
-        }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Snapshot",
-                ":", get_buffer);
-
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-id",
-                        prefix_str);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
+cli_get_each_snap_info(dict_t *dict, char *prefix_str, gf_boolean_t snap_driven)
+{
+    char key_buffer[PATH_MAX] = "";
+    char *get_buffer = NULL;
+    int ret = -1;
+    char indent[5] = "";
+
+    GF_ASSERT(dict);
+    GF_ASSERT(prefix_str);
+
+    if (!snap_driven)
+        strcat(indent, "\t");
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snapname", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ", key_buffer);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snapshot", ":", get_buffer);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-id", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ", key_buffer);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Snap UUID", ":", get_buffer);
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-desc", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (!ret) {
+        /* Ignore error for description */
+        cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Description", ":",
+                get_buffer);
+    }
+
+    ret = snprintf(key_buffer, sizeof(key_buffer), "%s.snap-time", prefix_str);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key_buffer, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
+               prefix_str);
+        goto out;
+    }
+    cli_out("%s" INDENT_MAIN_HEAD "%s", indent, "Created", ":", get_buffer);
+
+    if (snap_driven) {
+        cli_out("%-12s", "Snap Volumes:\n");
+        ret = cli_get_volinfo_in_snap(dict, prefix_str);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ",
-                        key_buffer);
-                goto out;
-        }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Snap UUID",
-                ":", get_buffer);
-
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-desc",
-                        prefix_str);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
-        if (!ret) {
-                /* Ignore error for description */
-                cli_out ("%s" INDENT_MAIN_HEAD "%s", indent,
-                         "Description", ":", get_buffer);
-        }
-
-        ret = snprintf (key_buffer, sizeof (key_buffer), "%s.snap-time",
-                        prefix_str);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = dict_get_str (dict, key_buffer, &get_buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
-                        prefix_str);
-                goto out;
-        }
-        cli_out ("%s" INDENT_MAIN_HEAD "%s", indent, "Created",
-                ":", get_buffer);
-
-        if (snap_driven) {
-                cli_out ("%-12s", "Snap Volumes:\n");
-                ret = cli_get_volinfo_in_snap (dict, prefix_str);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to list details "
-                                "of the snaps");
-                        goto out;
-                }
+            gf_log("cli", GF_LOG_ERROR,
+                   "Unable to list details "
+                   "of the snaps");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /* This is a generic function to print snap related information.
  * arg - 0, dict : Response Dictionary
  */
 int
-cli_call_snapshot_info (dict_t *dict, gf_boolean_t bool_snap_driven) {
-        int             snap_count       =  0;
-        char            key[PATH_MAX]    =  "";
-        int             ret              =  -1;
-        int             i                =   0;
+cli_call_snapshot_info(dict_t *dict, gf_boolean_t bool_snap_driven)
+{
+    int snap_count = 0;
+    char key[PATH_MAX] = "";
+    int ret = -1;
+    int i = 0;
 
-        GF_ASSERT (dict);
+    GF_ASSERT(dict);
 
-        ret = dict_get_int32 (dict, "snapcount", &snap_count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapcount");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "snapcount", &snap_count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapcount");
+        goto out;
+    }
 
-        if (snap_count == 0) {
-                cli_out ("No snapshots present");
-        }
+    if (snap_count == 0) {
+        cli_out("No snapshots present");
+    }
 
-        for (i = 1 ; i <= snap_count ; i++) {
-                ret = snprintf (key, sizeof (key), "snap%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_snap_info (dict, key, bool_snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to print snap details");
-                        goto out;
-                }
+    for (i = 1; i <= snap_count; i++) {
+        ret = snprintf(key, sizeof(key), "snap%d", i);
+        if (ret < 0) {
+            goto out;
+        }
+        ret = cli_get_each_snap_info(dict, key, bool_snap_driven);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to print snap details");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_get_snaps_in_volume (dict_t *dict) {
-        int      ret             =  -1;
-        int      i               =  0;
-        int      count           =  0;
-        int      avail           =  0;
-        char     key[PATH_MAX]   =  "";
-        char    *get_buffer      =  NULL;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_str (dict, "origin-volname", &get_buffer);
+cli_get_snaps_in_volume(dict_t *dict)
+{
+    int ret = -1;
+    int i = 0;
+    int count = 0;
+    int avail = 0;
+    char key[PATH_MAX] = "";
+    char *get_buffer = NULL;
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_str(dict, "origin-volname", &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch origin-volname");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%s", "Volume Name", ":", get_buffer);
+
+    ret = dict_get_int32(dict, "snapcount", &avail);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snapcount");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%d", "Snaps Taken", ":", avail);
+
+    ret = dict_get_int32(dict, "snaps-available", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snaps-available");
+        goto out;
+    }
+    cli_out(INDENT_MAIN_HEAD "%d", "Snaps Available", ":", count);
+
+    for (i = 1; i <= avail; i++) {
+        snprintf(key, sizeof(key), "snap%d", i);
+        ret = cli_get_each_snap_info(dict, key, _gf_false);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch origin-volname");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Unable to print snap details");
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%s", "Volume Name", ":", get_buffer);
 
-        ret = dict_get_int32 (dict, "snapcount", &avail);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snapcount");
-                goto out;
+        ret = snprintf(key, sizeof(key), "snap%d.vol1", i);
+        if (ret < 0) {
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%d", "Snaps Taken", ":", avail);
-
-        ret = dict_get_int32 (dict, "snaps-available", &count);
+        ret = cli_get_each_volinfo_in_snap(dict, key, _gf_false);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snaps-available");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not get volume "
+                   "related information");
+            goto out;
         }
-        cli_out (INDENT_MAIN_HEAD "%d", "Snaps Available", ":", count);
-
-        for (i = 1 ; i <= avail ; i++) {
-                snprintf (key, sizeof (key), "snap%d", i);
-                ret = cli_get_each_snap_info (dict, key, _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to print snap details");
-                        goto out;
-                }
-
-                ret = snprintf (key, sizeof (key), "snap%d.vol1", i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = cli_get_each_volinfo_in_snap (dict, key, _gf_false);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get volume "
-                                "related information");
-                        goto out;
-                }
 
-                cli_out (" ");
-        }
+        cli_out(" ");
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_snapshot_list (dict_t *dict) {
-        int     snapcount       =       0;
-        char    key[PATH_MAX]   =       "";
-        int     ret             =       -1;
-        int     i               =       0;
-        char    *get_buffer     =       NULL;
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch snap count");
-                goto out;
-        }
-
-        if (snapcount == 0) {
-                cli_out ("No snapshots present");
-        }
-
-        for (i = 1 ; i <= snapcount ; i++) {
-                ret = snprintf (key, sizeof (key), "snapname%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
+cli_snapshot_list(dict_t *dict)
+{
+    int snapcount = 0;
+    char key[PATH_MAX] = "";
+    int ret = -1;
+    int i = 0;
+    char *get_buffer = NULL;
 
-                ret = dict_get_str (dict, key, &get_buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                } else {
-                        cli_out ("%s", get_buffer);
-                }
-        }
-out:
-        return ret;
-}
+    GF_ASSERT(dict);
 
-int
-cli_get_snap_volume_status (dict_t *dict, char *key_prefix)
-{
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        char            *buffer         =       NULL;
-        int             brickcount      =       0;
-        int             i               =       0;
-        int             pid             =       0;
+    ret = dict_get_int32(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch snap count");
+        goto out;
+    }
 
-        GF_ASSERT (dict);
-        GF_ASSERT (key_prefix);
+    if (snapcount == 0) {
+        cli_out("No snapshots present");
+    }
 
-        ret = snprintf (key, sizeof (key), "%s.brickcount", key_prefix);
+    for (i = 1; i <= snapcount; i++) {
+        ret = snprintf(key, sizeof(key), "snapname%d", i);
         if (ret < 0) {
-                goto out;
-        }
-        ret = dict_get_int32 (dict, key, &brickcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
-                goto out;
+            goto out;
         }
 
-        for (i = 0 ; i < brickcount ; i++) {
-                ret = snprintf (key, sizeof (key), "%s.brick%d.path",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Path");
-                        continue;
-                }
-                cli_out ("\n\t%-17s %s   %s", "Brick Path", ":", buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.vgname",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Volume Group");
-                        cli_out ("\t%-17s %s   %s", "Volume Group", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Volume Group", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.status",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Running");
-                        cli_out ("\t%-17s %s   %s", "Brick Running", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Brick Running", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.pid",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get pid");
-                        cli_out ("\t%-17s %s   %s", "Brick PID", ":", "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %d", "Brick PID", ":", pid);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.data",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Data Percent");
-                        cli_out ("\t%-17s %s   %s", "Data Percentage", ":",
-                                 "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "Data Percentage", ":",
-                                 buffer);
-
-                ret = snprintf (key, sizeof (key), "%s.brick%d.lvsize",
-                                key_prefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO, "Unable to get LV Size");
-                        cli_out ("\t%-17s %s   %s", "LV Size", ":", "N/A");
-                } else
-                        cli_out ("\t%-17s %s   %s", "LV Size", ":", buffer);
-
+        ret = dict_get_str(dict, key, &get_buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
+        } else {
+            cli_out("%s", get_buffer);
         }
-
-        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-cli_get_single_snap_status (dict_t *dict, char *keyprefix)
-{
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        int             i               =       0;
-        int             volcount        =       0;
-        char            *get_buffer     =       NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        ret = snprintf (key, sizeof (key), "%s.snapname", keyprefix);
+cli_get_snap_volume_status(dict_t *dict, char *key_prefix)
+{
+    int ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+    int brickcount = 0;
+    int i = 0;
+    int pid = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(key_prefix);
+
+    ret = snprintf(key, sizeof(key), "%s.brickcount", key_prefix);
+    if (ret < 0) {
+        goto out;
+    }
+    ret = dict_get_int32(dict, key, &brickcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
+        goto out;
+    }
+
+    for (i = 0; i < brickcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.brick%d.path", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapname");
-                goto out;
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Path");
+            continue;
         }
-        cli_out ("\nSnap Name : %s", get_buffer);
+        cli_out("\n\t%-17s %s   %s", "Brick Path", ":", buffer);
 
-        ret = snprintf (key, sizeof (key), "%s.uuid", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.vgname", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &get_buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snap UUID");
-                goto out;
-        }
-        cli_out ("Snap UUID : %s", get_buffer);
+            gf_log("cli", GF_LOG_INFO, "Unable to get Volume Group");
+            cli_out("\t%-17s %s   %s", "Volume Group", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Volume Group", ":", buffer);
 
-        ret = snprintf (key, sizeof (key), "%s.volcount", keyprefix);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.status", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_int32 (dict, key, &volcount);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get volume count");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Running");
+            cli_out("\t%-17s %s   %s", "Brick Running", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Brick Running", ":", buffer);
 
-        for (i = 0 ; i < volcount ; i++) {
-                ret = snprintf (key, sizeof (key), "%s.vol%d", keyprefix, i);
-                if (ret < 0) {
-                        goto out;
-                }
-
-                ret = cli_get_snap_volume_status (dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not get snap volume status");
-                        goto out;
-                }
+        ret = snprintf(key, sizeof(key), "%s.brick%d.pid", key_prefix, i);
+        if (ret < 0) {
+            goto out;
         }
-out:
-        return ret;
-}
-
-int32_t
-cli_populate_req_dict_for_delete (dict_t *snap_dict, dict_t *dict, size_t index)
-{
-        int32_t         ret             = -1;
-        char            key[PATH_MAX]   = "";
-        char            *buffer         = NULL;
-
-        GF_ASSERT (snap_dict);
-        GF_ASSERT (dict);
 
-        ret = dict_set_int32 (snap_dict, "sub-cmd",
-                              GF_SNAP_DELETE_TYPE_ITER);
+        ret = dict_get_int32(dict, key, &pid);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save command "
-                        "type in snap dictionary");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get pid");
+            cli_out("\t%-17s %s   %s", "Brick PID", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %d", "Brick PID", ":", pid);
 
-        ret = snprintf (key, sizeof (key), "snapname%zu", index);
+        ret = snprintf(key, sizeof(key), "%s.brick%d.data", key_prefix, i);
         if (ret < 0) {
-                goto out;
+            goto out;
         }
 
-        ret = dict_get_str (dict, key, &buffer);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapname");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get Data Percent");
+            cli_out("\t%-17s %s   %s", "Data Percentage", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "Data Percentage", ":", buffer);
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "snapname", buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to save snapname");
-                goto out;
+        ret = snprintf(key, sizeof(key), "%s.brick%d.lvsize", key_prefix, i);
+        if (ret < 0) {
+            goto out;
         }
-
-        ret = dict_set_int32 (snap_dict, "type", GF_SNAP_OPTION_TYPE_DELETE);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to save command type");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get LV Size");
+            cli_out("\t%-17s %s   %s", "LV Size", ":", "N/A");
+        } else
+            cli_out("\t%-17s %s   %s", "LV Size", ":", buffer);
+    }
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "cmd-str",
-                                       "snapshot delete");
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command string as delete");
-                goto out;
-        }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_populate_req_dict_for_status (dict_t *snap_dict, dict_t *dict, int index)
-{
-        int             ret             =       -1;
-        char            key[PATH_MAX]   =       "";
-        char            *buffer         =       NULL;
-
-        GF_ASSERT (snap_dict);
-        GF_ASSERT (dict);
-
-        ret = dict_set_uint32 (snap_dict, "sub-cmd",
-                               GF_SNAP_STATUS_TYPE_ITER);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save command "
-                        "type in snap dict");
-                goto out;
+cli_get_single_snap_status(dict_t *dict, char *keyprefix)
+{
+    int ret = -1;
+    char key[PATH_MAX] = "";
+    int i = 0;
+    int volcount = 0;
+    char *get_buffer = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    ret = snprintf(key, sizeof(key), "%s.snapname", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapname");
+        goto out;
+    }
+    cli_out("\nSnap Name : %s", get_buffer);
+
+    ret = snprintf(key, sizeof(key), "%s.uuid", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &get_buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snap UUID");
+        goto out;
+    }
+    cli_out("Snap UUID : %s", get_buffer);
+
+    ret = snprintf(key, sizeof(key), "%s.volcount", keyprefix);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, key, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get volume count");
+        goto out;
+    }
+
+    for (i = 0; i < volcount; i++) {
+        ret = snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
+        if (ret < 0) {
+            goto out;
         }
 
-        ret = snprintf (key, sizeof (key), "status.snap%d.snapname", index);
-         if (ret < 0) {
-                 goto out;
-         }
-
-        ret = dict_get_str (dict, key, &buffer);
+        ret = cli_get_snap_volume_status(dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get snapname");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snap volume status");
+            goto out;
         }
+    }
+out:
+    return ret;
+}
 
-        ret = dict_set_str (snap_dict, "snapname", buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not save snapname "
-                        "in snap dict");
-                goto out;
-
-        }
+int32_t
+cli_populate_req_dict_for_delete(dict_t *snap_dict, dict_t *dict, size_t index)
+{
+    int32_t ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+
+    GF_ASSERT(snap_dict);
+    GF_ASSERT(dict);
+
+    ret = dict_set_int32(snap_dict, "sub-cmd", GF_SNAP_DELETE_TYPE_ITER);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save command "
+               "type in snap dictionary");
+        goto out;
+    }
+
+    ret = snprintf(key, sizeof(key), "snapname%zu", index);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapname");
+        goto out;
+    }
+
+    ret = dict_set_dynstr_with_alloc(snap_dict, "snapname", buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save snapname");
+        goto out;
+    }
+
+    ret = dict_set_int32(snap_dict, "type", GF_SNAP_OPTION_TYPE_DELETE);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to save command type");
+        goto out;
+    }
+
+    ret = dict_set_dynstr_with_alloc(snap_dict, "cmd-str", "snapshot delete");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command string as delete");
+        goto out;
+    }
+out:
+    return ret;
+}
 
-        ret = dict_set_int32 (snap_dict, "type", GF_SNAP_OPTION_TYPE_STATUS);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command type");
-                goto out;
-        }
+int
+cli_populate_req_dict_for_status(dict_t *snap_dict, dict_t *dict, int index)
+{
+    int ret = -1;
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+
+    GF_ASSERT(snap_dict);
+    GF_ASSERT(dict);
+
+    ret = dict_set_uint32(snap_dict, "sub-cmd", GF_SNAP_STATUS_TYPE_ITER);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save command "
+               "type in snap dict");
+        goto out;
+    }
+
+    ret = snprintf(key, sizeof(key), "status.snap%d.snapname", index);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get snapname");
+        goto out;
+    }
+
+    ret = dict_set_str(snap_dict, "snapname", buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not save snapname "
+               "in snap dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(snap_dict, "type", GF_SNAP_OPTION_TYPE_STATUS);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command type");
+        goto out;
+    }
+
+    ret = dict_set_dynstr_with_alloc(snap_dict, "cmd-str", "snapshot status");
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not save command string as status");
+        goto out;
+    }
+
+    ret = dict_set_int32(snap_dict, "hold_vol_locks", _gf_false);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Setting volume lock flag failed");
+        goto out;
+    }
+
+out:
+    return ret;
+}
 
-        ret = dict_set_dynstr_with_alloc (snap_dict, "cmd-str",
-                                       "snapshot status");
+int
+cli_snapshot_status(dict_t *dict, gf_cli_rsp *rsp, call_frame_t *frame)
+{
+    char key[PATH_MAX] = "";
+    int ret = -1;
+    int status_cmd = -1;
+    cli_local_t *local = NULL;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(rsp);
+    GF_ASSERT(frame);
+
+    local = ((call_frame_t *)frame)->local;
+    if (!local) {
+        gf_log("cli", GF_LOG_ERROR, "frame->local is NULL");
+        goto out;
+    }
+
+    if (rsp->op_ret) {
+        if (rsp->op_errstr) {
+            ret = dict_set_dynstr_with_alloc(local->dict, "op_err_str",
+                                             rsp->op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to set "
+                       "op_errstr in local dictionary");
+                goto out;
+            }
+        }
+        ret = rsp->op_ret;
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "sub-cmd", &status_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch status type");
+        goto out;
+    }
+
+    if ((status_cmd != GF_SNAP_STATUS_TYPE_SNAP) &&
+        (status_cmd != GF_SNAP_STATUS_TYPE_ITER)) {
+        dict_copy(dict, local->dict);
+        goto out;
+    }
+
+    ret = snprintf(key, sizeof(key), "status.snap0");
+    if (ret < 0) {
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_status_single_snap(local, dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not save command string as status");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot status");
+            goto out;
         }
-
-        ret = dict_set_int32 (snap_dict, "hold_vol_locks", _gf_false);
+    } else {
+        ret = cli_get_single_snap_status(dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Setting volume lock flag failed");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not fetch "
+                   "status of snap");
+            goto out;
         }
+    }
 
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_snapshot_status (dict_t *dict, gf_cli_rsp *rsp,
-                             call_frame_t *frame)
-{
-        char            key[PATH_MAX]   =       "";
-        int             ret             =       -1;
-        int             status_cmd      =       -1;
-        cli_local_t     *local          =       NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (rsp);
-        GF_ASSERT (frame);
-
-        local = ((call_frame_t *) frame) -> local;
-        if (!local) {
-                gf_log ("cli", GF_LOG_ERROR, "frame->local is NULL");
-                goto out;
-        }
-
-        if (rsp->op_ret) {
-                if (rsp->op_errstr) {
-                        ret = dict_set_dynstr_with_alloc (local->dict,
-                                                          "op_err_str",
-                                                          rsp->op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to set "
-                                        "op_errstr in local dictionary");
-                                goto out;
-                        }
-                }
-                ret = rsp->op_ret;
-                goto out;
-        }
-
-        ret = dict_get_int32 (dict, "sub-cmd", &status_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch status type");
+gf_cli_generate_snapshot_event(gf_cli_rsp *rsp, dict_t *dict, int32_t type,
+                               char *snap_name, char *volname, char *snap_uuid,
+                               char *clone_name)
+{
+    int ret = -1;
+    int config_command = 0;
+    int32_t delete_cmd = -1;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+    char msg[PATH_MAX] = {
+        0,
+    };
+    char option[512] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
+    GF_VALIDATE_OR_GOTO("cli", rsp, out);
+
+    switch (type) {
+        case GF_SNAP_OPTION_TYPE_CREATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
                 goto out;
-        }
+            }
 
-        if ((status_cmd != GF_SNAP_STATUS_TYPE_SNAP) &&
-            (status_cmd != GF_SNAP_STATUS_TYPE_ITER)) {
-                dict_copy (dict, local->dict);
+            if (!volname) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
                 goto out;
-        }
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CREATE_FAILED,
+                         "snapshot_name=%s;volume_name=%s;error=%s", snap_name,
+                         volname,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-        ret = snprintf (key, sizeof (key), "status.snap0");
-        if (ret < 0) {
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
                 goto out;
-        }
+            }
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_status_single_snap (local, dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot status");
-                        goto out;
-                }
-        } else {
-                ret = cli_get_single_snap_status (dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch "
-                                "status of snap");
-                        goto out;
-                }
-        }
+            gf_event(EVENT_SNAPSHOT_CREATED,
+                     "snapshot_name=%s;"
+                     "volume_name=%s;snapshot_uuid=%s",
+                     snap_name, volname, snap_uuid);
 
-        ret = 0;
-out:
-        return ret;
-}
-
-int
-gf_cli_generate_snapshot_event (gf_cli_rsp *rsp, dict_t *dict,
-                                int32_t type, char *snap_name,
-                                char *volname, char *snap_uuid,
-                                char *clone_name)
-{
-        int         ret               = -1;
-        int         config_command    = 0;
-        int32_t     delete_cmd        = -1;
-        uint64_t    hard_limit        = 0;
-        uint64_t    soft_limit        = 0;
-        char       *auto_delete       = NULL;
-        char       *snap_activate     = NULL;
-        char        msg[PATH_MAX]     = {0, };
-        char        option[512]       = {0, };
-
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-        GF_VALIDATE_OR_GOTO ("cli", rsp, out);
-
-        switch (type) {
-        case GF_SNAP_OPTION_TYPE_CREATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
-
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get volume name");
-                        goto out;
-                }
-
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CREATE_FAILED,
-                                  "snapshot_name=%s;volume_name=%s;error=%s",
-                                  snap_name, volname,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
-
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_CREATED, "snapshot_name=%s;"
-                          "volume_name=%s;snapshot_uuid=%s", snap_name,
-                          volname, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_ACTIVATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_ACTIVATE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_ACTIVATE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_ACTIVATED,
+                     "snapshot_name=%s;"
+                     "snapshot_uuid=%s",
+                     snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_ACTIVATED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_DEACTIVATE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_DEACTIVATE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_DEACTIVATED,
+                     "snapshot_name=%s;"
+                     "snapshot_uuid=%s",
+                     snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_DEACTIVATED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_RESTORE:
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_RESTORE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_RESTORE:
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_RESTORE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            if (!volname) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volname");
+                goto out;
+            }
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            gf_event(EVENT_SNAPSHOT_RESTORED,
+                     "snapshot_name=%s;"
+                     "snapshot_uuid=%s;volume_name=%s",
+                     snap_name, snap_uuid, volname);
 
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get volname");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_RESTORED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s;volume_name=%s",
-                          snap_name, snap_uuid, volname);
+        case GF_SNAP_OPTION_TYPE_DELETE:
+            ret = dict_get_int32(dict, "sub-cmd", &delete_cmd);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not get sub-cmd");
+                goto out;
+            }
 
+            /*
+             * Need not generate any event (success or failure) for delete *
+             * all, as it will trigger individual delete for all snapshots *
+             */
+            if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL) {
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_DELETE:
-                ret = dict_get_int32 (dict, "sub-cmd", &delete_cmd);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get sub-cmd");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                /*
-                 * Need not generate any event (success or failure) for delete *
-                 * all, as it will trigger individual delete for all snapshots *
-                 */
-                if (delete_cmd == GF_SNAP_DELETE_TYPE_ALL) {
-                        ret = 0;
-                        break;
-                }
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_DELETE_FAILED,
+                         "snapshot_name=%s;error=%s", snap_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_DELETE_FAILED,
-                                  "snapshot_name=%s;error=%s", snap_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            gf_event(EVENT_SNAPSHOT_DELETED,
+                     "snapshot_name=%s;"
+                     "snapshot_uuid=%s",
+                     snap_name, snap_uuid);
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+            ret = 0;
+            break;
 
-                gf_event (EVENT_SNAPSHOT_DELETED, "snapshot_name=%s;"
-                          "snapshot_uuid=%s", snap_name, snap_uuid);
+        case GF_SNAP_OPTION_TYPE_CLONE:
+            if (!clone_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+                goto out;
+            }
+
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snapname name");
+                goto out;
+            }
 
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CLONE_FAILED,
+                         "snapshot_name=%s;clone_name=%s;"
+                         "error=%s",
+                         snap_name, clone_name,
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_CLONE:
-                if (!clone_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get clone name");
-                        goto out;
-                }
+            if (!snap_uuid) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snapname name");
-                        goto out;
-                }
+            gf_event(EVENT_SNAPSHOT_CLONED,
+                     "snapshot_name=%s;"
+                     "clone_name=%s;clone_uuid=%s",
+                     snap_name, clone_name, snap_uuid);
 
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CLONE_FAILED,
-                                  "snapshot_name=%s;clone_name=%s;"
-                                  "error=%s", snap_name, clone_name,
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            ret = 0;
+            break;
 
-                if (!snap_uuid) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                        goto out;
-                }
+        case GF_SNAP_OPTION_TYPE_CONFIG:
+            if (rsp->op_ret != 0) {
+                gf_event(EVENT_SNAPSHOT_CONFIG_UPDATE_FAILED, "error=%s",
+                         rsp->op_errstr ? rsp->op_errstr
+                                        : "Please check log file for details");
+                ret = 0;
+                break;
+            }
 
-                gf_event (EVENT_SNAPSHOT_CLONED, "snapshot_name=%s;"
-                          "clone_name=%s;clone_uuid=%s",
-                          snap_name, clone_name, snap_uuid);
+            ret = dict_get_int32(dict, "config-command", &config_command);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+                goto out;
+            }
 
+            if (config_command == GF_SNAP_CONFIG_DISPLAY) {
                 ret = 0;
                 break;
+            }
 
-        case GF_SNAP_OPTION_TYPE_CONFIG:
-                if (rsp->op_ret != 0) {
-                        gf_event (EVENT_SNAPSHOT_CONFIG_UPDATE_FAILED,
-                                  "error=%s",
-                                  rsp->op_errstr ? rsp->op_errstr :
-                                  "Please check log file for details");
-                        ret = 0;
-                        break;
-                }
+            /* These are optional parameters therefore ignore the error */
+            ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+            ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+            ret = dict_get_str(dict, "auto-delete", &auto_delete);
+            ret = dict_get_str(dict, "snap-activate-on-create", &snap_activate);
 
-                ret = dict_get_int32 (dict, "config-command", &config_command);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Could not fetch config type");
-                        goto out;
-                }
-
-                if (config_command == GF_SNAP_CONFIG_DISPLAY) {
-                        ret = 0;
-                        break;
-                }
+            if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
+                ret = -1;
+                gf_log("cli", GF_LOG_ERROR,
+                       "At least one option from "
+                       "snap-max-hard-limit, snap-max-soft-limit, "
+                       "auto-delete and snap-activate-on-create "
+                       "should be set");
+                goto out;
+            }
 
-                /* These are optional parameters therefore ignore the error */
-                ret = dict_get_uint64 (dict, "snap-max-hard-limit",
-                                       &hard_limit);
-                ret = dict_get_uint64 (dict, "snap-max-soft-limit",
-                                       &soft_limit);
-                ret = dict_get_str (dict, "auto-delete",
-                                    &auto_delete);
-                ret = dict_get_str (dict, "snap-activate-on-create",
-                                    &snap_activate);
-
-                if (!hard_limit && !soft_limit &&
-                    !auto_delete && !snap_activate) {
-                        ret = -1;
-                        gf_log ("cli", GF_LOG_ERROR, "At least one option from "
-                                "snap-max-hard-limit, snap-max-soft-limit, "
-                                "auto-delete and snap-activate-on-create "
-                                "should be set");
-                        goto out;
-                }
+            volname = NULL;
+            ret = dict_get_str(dict, "volname", &volname);
 
-                volname = NULL;
-                ret = dict_get_str (dict, "volname", &volname);
-
-                if (hard_limit || soft_limit) {
-                        snprintf (option, sizeof(option), "%s=%"PRIu64,
-                                  hard_limit ? "hard_limit" : "soft_limit",
-                                  hard_limit ? hard_limit:soft_limit);
-                } else if (auto_delete || snap_activate) {
-                        snprintf (option, sizeof(option), "%s=%s",
-                                  auto_delete ? "auto-delete" : "snap-activate",
-                                  auto_delete ? auto_delete:snap_activate);
-                }
+            if (hard_limit || soft_limit) {
+                snprintf(option, sizeof(option), "%s=%" PRIu64,
+                         hard_limit ? "hard_limit" : "soft_limit",
+                         hard_limit ? hard_limit : soft_limit);
+            } else if (auto_delete || snap_activate) {
+                snprintf(option, sizeof(option), "%s=%s",
+                         auto_delete ? "auto-delete" : "snap-activate",
+                         auto_delete ? auto_delete : snap_activate);
+            }
 
-                snprintf (msg, sizeof(msg), "config_type=%s;%s",
-                          volname?"volume_config":"system_config", option);
+            snprintf(msg, sizeof(msg), "config_type=%s;%s",
+                     volname ? "volume_config" : "system_config", option);
 
-                gf_event (EVENT_SNAPSHOT_CONFIG_UPDATED, "%s", msg);
+            gf_event(EVENT_SNAPSHOT_CONFIG_UPDATED, "%s", msg);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         default:
-                gf_log ("cli", GF_LOG_WARNING,
-                        "Cannot generate event for unknown type.");
-                ret = 0;
-                goto out;
-        }
+            gf_log("cli", GF_LOG_WARNING,
+                   "Cannot generate event for unknown type.");
+            ret = 0;
+            goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /*
@@ -10766,1415 +10684,1463 @@ out:
  * repeating the same code again and again.               *
  */
 int
-gf_cli_snapshot_get_data_from_dict (dict_t *dict, char **snap_name,
-                                    char **volname, char **snap_uuid,
-                                    int8_t *soft_limit_flag,
-                                    char **clone_name)
+gf_cli_snapshot_get_data_from_dict(dict_t *dict, char **snap_name,
+                                   char **volname, char **snap_uuid,
+                                   int8_t *soft_limit_flag, char **clone_name)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
 
-        if (snap_name) {
-                ret = dict_get_str (dict, "snapname", snap_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get snapname from dict");
-                }
+    if (snap_name) {
+        ret = dict_get_str(dict, "snapname", snap_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get snapname from dict");
         }
+    }
 
-        if (volname) {
-                ret = dict_get_str (dict, "volname1", volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get volname1 from dict");
-                }
+    if (volname) {
+        ret = dict_get_str(dict, "volname1", volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get volname1 from dict");
         }
+    }
 
-        if (snap_uuid) {
-                ret = dict_get_str (dict, "snapuuid", snap_uuid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get snapuuid from dict");
-                }
+    if (snap_uuid) {
+        ret = dict_get_str(dict, "snapuuid", snap_uuid);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get snapuuid from dict");
         }
+    }
 
-        if (soft_limit_flag) {
-                ret = dict_get_int8 (dict, "soft-limit-reach",
-                                     soft_limit_flag);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get soft-limit-reach from dict");
-                }
+    if (soft_limit_flag) {
+        ret = dict_get_int8(dict, "soft-limit-reach", soft_limit_flag);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG,
+                   "failed to get soft-limit-reach from dict");
         }
+    }
 
-        if (clone_name) {
-                ret = dict_get_str (dict, "clonename", clone_name);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_DEBUG,
-                                "failed to get clonename from dict");
-                }
+    if (clone_name) {
+        ret = dict_get_str(dict, "clonename", clone_name);
+        if (ret) {
+            gf_log("cli", GF_LOG_DEBUG, "failed to get clonename from dict");
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_cli_snapshot_cbk (struct rpc_req *req, struct iovec *iov,
-                     int count, void *myframe)
-{
-        int                   ret                      = -1;
-        gf_cli_rsp            rsp                      = {0, };
-        dict_t               *dict                     = NULL;
-        char                 *snap_name                = NULL;
-        char                 *clone_name               = NULL;
-        int32_t               type                     =  0;
-        call_frame_t         *frame                    = NULL;
-        gf_boolean_t         snap_driven               = _gf_false;
-        int8_t               soft_limit_flag           = -1;
-        char                 *volname                  = NULL;
-        char                 *snap_uuid                = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        frame = myframe;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
+gf_cli_snapshot_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+    int ret = -1;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *snap_name = NULL;
+    char *clone_name = NULL;
+    int32_t type = 0;
+    call_frame_t *frame = NULL;
+    gf_boolean_t snap_driven = _gf_false;
+    int8_t soft_limit_flag = -1;
+    char *volname = NULL;
+    char *snap_uuid = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    frame = myframe;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "failed to get type");
+        goto out;
+    }
+
+    ret = gf_cli_snapshot_get_data_from_dict(
+        dict, &snap_name, &volname, &snap_uuid, &soft_limit_flag, &clone_name);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch data from dict.");
+        goto out;
+    }
 
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-
-        if (ret)
-                goto out;
+#if (USE_EVENTS)
+    ret = gf_cli_generate_snapshot_event(&rsp, dict, type, snap_name, volname,
+                                         snap_uuid, clone_name);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to generate snapshot event");
+        goto out;
+    }
+#endif
 
-        ret = dict_get_int32 (dict, "type", &type);
+    /* Snapshot status and delete command is handled separately */
+    if (global_state->mode & GLUSTER_MODE_XML &&
+        GF_SNAP_OPTION_TYPE_STATUS != type &&
+        GF_SNAP_OPTION_TYPE_DELETE != type) {
+        ret = cli_xml_output_snapshot(type, dict, rsp.op_ret, rsp.op_errno,
+                                      rsp.op_errstr);
         if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "failed to get type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
         }
 
-        ret = gf_cli_snapshot_get_data_from_dict (dict, &snap_name, &volname,
-                                                  &snap_uuid, &soft_limit_flag,
-                                                  &clone_name);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch data from dict.");
-                goto out;
-        }
+        goto out;
+    }
 
-#if (USE_EVENTS)
-        ret = gf_cli_generate_snapshot_event (&rsp, dict, type, snap_name,
-                                              volname, snap_uuid, clone_name);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed to generate snapshot event");
+    switch (type) {
+        case GF_SNAP_OPTION_TYPE_CREATE:
+            if (rsp.op_ret) {
+                cli_err("snapshot create: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
                 goto out;
-        }
-#endif
-
-        /* Snapshot status and delete command is handled separately */
-        if (global_state->mode & GLUSTER_MODE_XML &&
-            GF_SNAP_OPTION_TYPE_STATUS != type &&
-            GF_SNAP_OPTION_TYPE_DELETE != type) {
-                ret = cli_xml_output_snapshot (type, dict, rsp.op_ret,
-                                               rsp.op_errno, rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
-                }
+            }
 
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
                 goto out;
-        }
+            }
 
-        switch (type) {
-        case GF_SNAP_OPTION_TYPE_CREATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot create: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
-
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
-
-                if (!volname) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get volume name");
-                        goto out;
-                }
+            if (!volname) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get volume name");
+                goto out;
+            }
 
-                cli_out ("snapshot create: success: Snap %s created "
-                                        "successfully", snap_name);
+            cli_out(
+                "snapshot create: success: Snap %s created "
+                "successfully",
+                snap_name);
 
-                if (soft_limit_flag == 1) {
-                        cli_out ("Warning: Soft-limit of volume (%s) is "
-                                "reached. Snapshot creation is not possible "
-                                "once hard-limit is reached.", volname);
-                }
-                ret = 0;
-                break;
+            if (soft_limit_flag == 1) {
+                cli_out(
+                    "Warning: Soft-limit of volume (%s) is "
+                    "reached. Snapshot creation is not possible "
+                    "once hard-limit is reached.",
+                    volname);
+            }
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_CLONE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot clone: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot clone: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!clone_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get clone name");
-                        goto out;
-                }
+            if (!clone_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snapname name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snapname name");
+                goto out;
+            }
 
-                cli_out ("snapshot clone: success: Clone %s created "
-                                        "successfully", clone_name);
+            cli_out(
+                "snapshot clone: success: Clone %s created "
+                "successfully",
+                clone_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_RESTORE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot restore: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot restore: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot restore: %s: Snap restored "
-                                 "successfully", snap_name);
+            cli_out(
+                "Snapshot restore: %s: Snap restored "
+                "successfully",
+                snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case GF_SNAP_OPTION_TYPE_ACTIVATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot activate: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot activate: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot activate: %s: Snap activated "
-                                 "successfully", snap_name);
+            cli_out(
+                "Snapshot activate: %s: Snap activated "
+                "successfully",
+                snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                if (rsp.op_ret) {
-                        cli_err("snapshot deactivate: failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                 "Please check log file for details");
-                                 ret = rsp.op_ret;
-                                 goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("snapshot deactivate: failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                if (!snap_name) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to get snap name");
-                        goto out;
-                }
+            if (!snap_name) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+                goto out;
+            }
 
-                cli_out ("Snapshot deactivate: %s: Snap deactivated "
-                                 "successfully", snap_name);
+            cli_out(
+                "Snapshot deactivate: %s: Snap deactivated "
+                "successfully",
+                snap_name);
 
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case GF_SNAP_OPTION_TYPE_INFO:
-                if (rsp.op_ret) {
-                        cli_err ("Snapshot info : failed: %s",
-                                  rsp.op_errstr ? rsp.op_errstr :
-                                  "Please check log file for details");
-                        ret = rsp.op_ret;
-                        goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("Snapshot info : failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                snap_driven = dict_get_str_boolean (dict, "snap-driven",
-                                                    _gf_false);
-                if (snap_driven == _gf_true) {
-                        ret = cli_call_snapshot_info  (dict, snap_driven);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Snapshot info failed");
-                                goto out;
-                        }
-                } else if (snap_driven == _gf_false) {
-                        ret = cli_get_snaps_in_volume (dict);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Snapshot info failed");
-                                goto out;
-                        }
+            snap_driven = dict_get_str_boolean(dict, "snap-driven", _gf_false);
+            if (snap_driven == _gf_true) {
+                ret = cli_call_snapshot_info(dict, snap_driven);
+                if (ret) {
+                    gf_log("cli", GF_LOG_ERROR, "Snapshot info failed");
+                    goto out;
                 }
-                break;
-
-        case GF_SNAP_OPTION_TYPE_CONFIG:
-                ret = cli_snapshot_config_display (dict, &rsp);
+            } else if (snap_driven == _gf_false) {
+                ret = cli_get_snaps_in_volume(dict);
                 if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot config output.");
-                        goto out;
+                    gf_log("cli", GF_LOG_ERROR, "Snapshot info failed");
+                    goto out;
                 }
-                break;
+            }
+            break;
+
+        case GF_SNAP_OPTION_TYPE_CONFIG:
+            ret = cli_snapshot_config_display(dict, &rsp);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to display "
+                       "snapshot config output.");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_LIST:
-                if (rsp.op_ret) {
-                        cli_err ("Snapshot list : failed: %s",
-                                 rsp.op_errstr ? rsp.op_errstr :
-                                "Please check log file for details");
-                        ret = rsp.op_ret;
-                        goto out;
-                }
+            if (rsp.op_ret) {
+                cli_err("Snapshot list : failed: %s",
+                        rsp.op_errstr ? rsp.op_errstr
+                                      : "Please check log file for details");
+                ret = rsp.op_ret;
+                goto out;
+            }
 
-                ret = cli_snapshot_list (dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot list");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_list(dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to display "
+                       "snapshot list");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_DELETE:
-                ret = cli_snapshot_remove_reply (&rsp, dict, frame);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Failed to delete snap");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_remove_reply(&rsp, dict, frame);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Failed to delete snap");
+                goto out;
+            }
+            break;
 
         case GF_SNAP_OPTION_TYPE_STATUS:
-                ret = cli_snapshot_status (dict, &rsp, frame);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to display "
-                                "snapshot status output.");
-                        goto out;
-                }
-                break;
+            ret = cli_snapshot_status(dict, &rsp, frame);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to display "
+                       "snapshot status output.");
+                goto out;
+            }
+            break;
 
         default:
-                cli_err ("Unknown command executed");
-                ret = -1;
-                goto out;
-        }
+            cli_err("Unknown command executed");
+            ret = -1;
+            goto out;
+    }
 out:
-        if (dict)
-                dict_unref (dict);
-        cli_cmd_broadcast_response (ret);
+    if (dict)
+        dict_unref(dict);
+    cli_cmd_broadcast_response(ret);
 
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_snapshot_for_delete (call_frame_t *frame, xlator_t *this,
-                            void *data)
-{
-        gf_cli_req      req                     = {{0,}};
-        int32_t         ret                     = -1;
-        int32_t         cmd                     = -1;
-        cli_local_t     *local                  = NULL;
-        dict_t          *snap_dict              = NULL;
-        int32_t         snapcount               = 0;
-        int             i                       = 0;
-        char            question[PATH_MAX]      = "";
-        char            *volname                = NULL;
-        gf_answer_t     answer                  = GF_ANSWER_NO;
-
-        GF_VALIDATE_OR_GOTO ("cli", frame,  out);
-        GF_VALIDATE_OR_GOTO ("cli", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("cli", this, out);
-        GF_VALIDATE_OR_GOTO ("cli", data, out);
-
-        local = frame->local;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                goto out;
-        }
-
-        /* No need multiple RPCs for individual snapshot delete*/
-        if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "snapcount",
-                              &snapcount);
+gf_cli_snapshot_for_delete(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int32_t ret = -1;
+    int32_t cmd = -1;
+    cli_local_t *local = NULL;
+    dict_t *snap_dict = NULL;
+    int32_t snapcount = 0;
+    int i = 0;
+    char question[PATH_MAX] = "";
+    char *volname = NULL;
+    gf_answer_t answer = GF_ANSWER_NO;
+
+    GF_VALIDATE_OR_GOTO("cli", frame, out);
+    GF_VALIDATE_OR_GOTO("cli", frame->local, out);
+    GF_VALIDATE_OR_GOTO("cli", this, out);
+    GF_VALIDATE_OR_GOTO("cli", data, out);
+
+    local = frame->local;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "sub-cmd");
+        goto out;
+    }
+
+    /* No need multiple RPCs for individual snapshot delete*/
+    if (cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not get "
+               "snapcount");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+#ifdef HAVE_LIB_XML
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"snapCount", "%d", snapcount);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get "
-                        "snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to write "
+                   "xml element \"snapCount\"");
+            goto out;
         }
-
-        if (global_state->mode & GLUSTER_MODE_XML) {
-#ifdef HAVE_LIB_XML
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                (xmlChar *)"snapCount",
-                                                "%d", snapcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to write "
-                                "xml element \"snapCount\"");
-                        goto out;
-                }
 #endif /* HAVE_LIB_XML */
-        } else if (snapcount == 0) {
-                cli_out ("No snapshots present");
-                goto out;
+    } else if (snapcount == 0) {
+        cli_out("No snapshots present");
+        goto out;
+    }
+
+    if (cmd == GF_SNAP_DELETE_TYPE_ALL) {
+        snprintf(question, sizeof(question),
+                 "System contains %d "
+                 "snapshot(s).\nDo you still "
+                 "want to continue and delete them? ",
+                 snapcount);
+    } else {
+        ret = dict_get_str(local->dict, "volname", &volname);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to fetch "
+                   "volname from local dictionary");
+            goto out;
         }
 
-        if (cmd == GF_SNAP_DELETE_TYPE_ALL) {
-                snprintf (question, sizeof (question), "System contains %d "
-                          "snapshot(s).\nDo you still "
-                          "want to continue and delete them? ",
-                           snapcount);
-        } else {
-                ret = dict_get_str (local->dict, "volname", &volname);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to fetch "
-                                "volname from local dictionary");
-                        goto out;
-                }
+        snprintf(question, sizeof(question),
+                 "Volume (%s) contains "
+                 "%d snapshot(s).\nDo you still want to "
+                 "continue and delete them? ",
+                 volname, snapcount);
+    }
 
-                snprintf (question, sizeof (question), "Volume (%s) contains "
-                          "%d snapshot(s).\nDo you still want to "
-                           "continue and delete them? ", volname,
-                           snapcount);
-        }
-
-        answer = cli_cmd_get_confirmation (global_state, question);
-        if (GF_ANSWER_NO == answer) {
-                ret = 0;
-                gf_log ("cli", GF_LOG_DEBUG, "User cancelled "
-                        "snapshot delete operation for snap delete");
-                goto out;
-        }
+    answer = cli_cmd_get_confirmation(global_state, question);
+    if (GF_ANSWER_NO == answer) {
+        ret = 0;
+        gf_log("cli", GF_LOG_DEBUG,
+               "User cancelled "
+               "snapshot delete operation for snap delete");
+        goto out;
+    }
 
-        for (i = 1 ; i <= snapcount ; i++) {
-                ret = -1;
+    for (i = 1; i <= snapcount; i++) {
+        ret = -1;
 
-                snap_dict = dict_new();
-                if (!snap_dict)
-                        goto out;
+        snap_dict = dict_new();
+        if (!snap_dict)
+            goto out;
 
-                ret = cli_populate_req_dict_for_delete (snap_dict,
-                                                       local->dict, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                "populate snap request dictionary");
-                        goto out;
-                }
+        ret = cli_populate_req_dict_for_delete(snap_dict, local->dict, i);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not "
+                   "populate snap request dictionary");
+            goto out;
+        }
 
-                ret = cli_to_glusterd (&req, frame,
-                                gf_cli_snapshot_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, snap_dict,
-                                GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                                NULL);
-                if (ret) {
-                        /* Fail the operation if deleting one of the
-                         * snapshots is failed
-                         */
-                        gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd "
-                                "for snapshot delete failed");
-                        goto out;
-                }
-                dict_unref (snap_dict);
-                snap_dict = NULL;
+        ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                              (xdrproc_t)xdr_gf_cli_req, snap_dict,
+                              GLUSTER_CLI_SNAP, this, cli_rpc_prog, NULL);
+        if (ret) {
+            /* Fail the operation if deleting one of the
+             * snapshots is failed
+             */
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli_to_glusterd "
+                   "for snapshot delete failed");
+            goto out;
         }
+        dict_unref(snap_dict);
+        snap_dict = NULL;
+    }
 
 out:
-        if (snap_dict)
-                dict_unref (snap_dict);
+    if (snap_dict)
+        dict_unref(snap_dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_snapshot_for_status (call_frame_t *frame, xlator_t *this,
-                            void *data)
-{
-
-        gf_cli_req        req           = {{0,}};
-        int               ret           = -1;
-        int32_t           cmd           = -1;
-        cli_local_t      *local         = NULL;
-        dict_t           *snap_dict     = NULL;
-        int              snapcount      =  0;
-        int              i              =  0;
+gf_cli_snapshot_for_status(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    int ret = -1;
+    int32_t cmd = -1;
+    cli_local_t *local = NULL;
+    dict_t *snap_dict = NULL;
+    int snapcount = 0;
+    int i = 0;
+
+    GF_VALIDATE_OR_GOTO("cli", frame, out);
+    GF_VALIDATE_OR_GOTO("cli", frame->local, out);
+    GF_VALIDATE_OR_GOTO("cli", this, out);
+    GF_VALIDATE_OR_GOTO("cli", data, out);
+
+    local = frame->local;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
+        goto out;
+    }
+
+    /* Snapshot status of single snap (i.e. GF_SNAP_STATUS_TYPE_SNAP)
+     * is already handled. Therefore we can return from here.
+     * If want to get status of all snaps in the system or volume then
+     * we should get them one by one.*/
+    if ((cmd == GF_SNAP_STATUS_TYPE_SNAP) ||
+        (cmd == GF_SNAP_STATUS_TYPE_ITER)) {
+        ret = 0;
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("cli", frame, out);
-        GF_VALIDATE_OR_GOTO ("cli", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("cli", this, out);
-        GF_VALIDATE_OR_GOTO ("cli", data, out);
+    ret = dict_get_int32(local->dict, "status.snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not get snapcount");
+        goto out;
+    }
 
-        local = frame->local;
+    if (snapcount == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
+        cli_out("No snapshots present");
+    }
 
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
-                goto out;
-        }
+    for (i = 0; i < snapcount; i++) {
+        ret = -1;
 
-        /* Snapshot status of single snap (i.e. GF_SNAP_STATUS_TYPE_SNAP)
-         * is already handled. Therefore we can return from here.
-         * If want to get status of all snaps in the system or volume then
-         * we should get them one by one.*/
-        if ((cmd == GF_SNAP_STATUS_TYPE_SNAP) ||
-            (cmd == GF_SNAP_STATUS_TYPE_ITER)) {
-                ret = 0;
-                goto out;
-        }
+        snap_dict = dict_new();
+        if (!snap_dict)
+            goto out;
 
-        ret = dict_get_int32 (local->dict, "status.snapcount", &snapcount);
+        ret = cli_populate_req_dict_for_status(snap_dict, local->dict, i);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not get snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not "
+                   "populate snap request dictionary");
+            goto out;
         }
 
-        if (snapcount == 0 && !(global_state->mode & GLUSTER_MODE_XML)) {
-                cli_out ("No snapshots present");
-        }
+        ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                              (xdrproc_t)xdr_gf_cli_req, snap_dict,
+                              GLUSTER_CLI_SNAP, this, cli_rpc_prog, NULL);
 
-        for (i = 0 ; i < snapcount; i++) {
-                ret = -1;
-
-                snap_dict = dict_new();
-                if (!snap_dict)
-                        goto out;
-
-                ret = cli_populate_req_dict_for_status (snap_dict,
-                                local->dict, i);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not "
-                                        "populate snap request dictionary");
-                        goto out;
-                }
-
-                ret = cli_to_glusterd (&req, frame,
-                                gf_cli_snapshot_cbk,
-                                (xdrproc_t) xdr_gf_cli_req, snap_dict,
-                                GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                                NULL);
-
-                /* Ignore the return value and error for snapshot
-                 * status of type "ALL" or "VOL"
-                 *
-                 * Scenario : There might be case where status command
-                 * and delete command might be issued at the same time.
-                 * In that case when status tried to fetch detail of
-                 * snap which has been deleted by concurrent command,
-                 * then it will show snapshot not present. Which will
-                 * not be appropriate.
-                 */
-                if (ret &&
-                    (cmd != GF_SNAP_STATUS_TYPE_ALL &&
-                     cmd != GF_SNAP_STATUS_TYPE_VOL)) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "cli_to_glusterd for snapshot status failed");
-                        goto out;
-                }
-                dict_unref (snap_dict);
-                snap_dict = NULL;
+        /* Ignore the return value and error for snapshot
+         * status of type "ALL" or "VOL"
+         *
+         * Scenario : There might be case where status command
+         * and delete command might be issued at the same time.
+         * In that case when status tried to fetch detail of
+         * snap which has been deleted by concurrent command,
+         * then it will show snapshot not present. Which will
+         * not be appropriate.
+         */
+        if (ret && (cmd != GF_SNAP_STATUS_TYPE_ALL &&
+                    cmd != GF_SNAP_STATUS_TYPE_VOL)) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli_to_glusterd for snapshot status failed");
+            goto out;
         }
+        dict_unref(snap_dict);
+        snap_dict = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (snap_dict)
-                dict_unref (snap_dict);
+    if (snap_dict)
+        dict_unref(snap_dict);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_snapshot (call_frame_t *frame, xlator_t *this,
-                 void *data)
-{
-        gf_cli_req        req           = {{0,}};
-        dict_t           *options       = NULL;
-        int               ret           = -1;
-        int               tmp_ret       = -1;
-        cli_local_t      *local         = NULL;
-        char             *err_str       = NULL;
-        int              type           =  -1;
-
-        if (!frame || !this || !data)
-                goto out;
-
-        if (!frame->local)
-                goto out;
+gf_cli_snapshot(call_frame_t *frame, xlator_t *this, void *data)
+{
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
+    int tmp_ret = -1;
+    cli_local_t *local = NULL;
+    char *err_str = NULL;
+    int type = -1;
 
-        local = frame->local;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    if (!frame->local)
+        goto out;
 
-        ret = dict_get_int32 (local->dict, "type", &type);
+    local = frame->local;
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_begin_composite_op (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to begin "
-                                "snapshot xml composite op");
-                        goto out;
-                }
-        }
+    options = data;
 
+    ret = dict_get_int32(local->dict, "type", &type);
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_snapshot_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_SNAP, this, cli_rpc_prog,
-                               NULL);
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_begin_composite_op(local);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd for "
-                        "snapshot failed");
-                goto xmlend;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to begin "
+                   "snapshot xml composite op");
+            goto out;
+        }
+    }
+
+    ret = cli_to_glusterd(&req, frame, gf_cli_snapshot_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options, GLUSTER_CLI_SNAP,
+                          this, cli_rpc_prog, NULL);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "cli_to_glusterd for "
+               "snapshot failed");
+        goto xmlend;
+    }
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type) {
+        ret = gf_cli_snapshot_for_status(frame, this, data);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli to glusterd "
+                   "for snapshot status command failed");
         }
 
-        if (GF_SNAP_OPTION_TYPE_STATUS == type) {
-                ret = gf_cli_snapshot_for_status (frame, this, data);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "cli to glusterd "
-                                "for snapshot status command failed");
-                }
+        goto xmlend;
+    }
 
-                goto xmlend;
+    if (GF_SNAP_OPTION_TYPE_DELETE == type) {
+        ret = gf_cli_snapshot_for_delete(frame, this, data);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "cli to glusterd "
+                   "for snapshot delete command failed");
         }
 
-        if (GF_SNAP_OPTION_TYPE_DELETE == type) {
-                ret = gf_cli_snapshot_for_delete (frame, this, data);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "cli to glusterd "
-                                "for snapshot delete command failed");
-                }
+        goto xmlend;
+    }
 
-                goto xmlend;
-        }
-
-        ret = 0;
+    ret = 0;
 
 xmlend:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_snapshot_end_composite_op (local);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to end "
-                                "snapshot xml composite op");
-                        goto out;
-                }
-        }
-out:
-        if (ret && local && GF_SNAP_OPTION_TYPE_STATUS == type) {
-                tmp_ret = dict_get_str (local->dict, "op_err_str", &err_str);
-                if (tmp_ret || !err_str) {
-                        cli_err ("Snapshot Status : failed: %s", "Please "
-                                 "check log file for details");
-                } else {
-                        cli_err ("Snapshot Status : failed: %s", err_str);
-                        dict_del (local->dict, "op_err_str");
-                }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_snapshot_end_composite_op(local);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to end "
+                   "snapshot xml composite op");
+            goto out;
+        }
+    }
+out:
+    if (ret && local && GF_SNAP_OPTION_TYPE_STATUS == type) {
+        tmp_ret = dict_get_str(local->dict, "op_err_str", &err_str);
+        if (tmp_ret || !err_str) {
+            cli_err("Snapshot Status : failed: %s",
+                    "Please "
+                    "check log file for details");
+        } else {
+            cli_err("Snapshot Status : failed: %s", err_str);
+            dict_del(local->dict, "op_err_str");
         }
+    }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                /* XML mode handles its own error */
-                ret = 0;
-        }
-        return ret;
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        /* XML mode handles its own error */
+        ret = 0;
+    }
+    return ret;
 }
 
 int32_t
-gf_cli_barrier_volume_cbk (struct rpc_req *req, struct iovec *iov,
-                                  int count, void *myframe)
-{
-        gf_cli_rsp                      rsp = {0,};
-        int                             ret = -1;
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to barrier");
-
-        if (rsp.op_ret) {
-                if (rsp.op_errstr && (strlen (rsp.op_errstr) > 1)) {
-                        cli_err ("volume barrier: command unsuccessful : %s",
-                                 rsp.op_errstr);
-                } else {
-                        cli_err ("volume barrier: command unsuccessful");
-                }
+gf_cli_barrier_volume_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to barrier");
+
+    if (rsp.op_ret) {
+        if (rsp.op_errstr && (strlen(rsp.op_errstr) > 1)) {
+            cli_err("volume barrier: command unsuccessful : %s", rsp.op_errstr);
         } else {
-                cli_out ("volume barrier: command successful");
+            cli_err("volume barrier: command unsuccessful");
         }
-        ret = rsp.op_ret;
+    } else {
+        cli_out("volume barrier: command successful");
+    }
+    ret = rsp.op_ret;
 
 out:
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    free(rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_barrier_volume (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_barrier_volume(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req                      req = {{0,}};
-        dict_t                          *options = NULL;
-        int                             ret = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_barrier_volume_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_BARRIER_VOLUME, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_barrier_volume_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_BARRIER_VOLUME, this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int32_t
-gf_cli_get_vol_opt_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        gf_cli_rsp   rsp  = {0,};
-        int          ret  = -1;
-        dict_t      *dict = NULL;
-        char        *key  = NULL;
-        char        *value = NULL;
-        char         msg[1024] = {0,};
-        int          i     = 0;
-        char         dict_key[50] = {0,};
-
-        GF_ASSERT (myframe);
-
-        if (-1 == req->rpc_status)
-                goto out;
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-        gf_log ("cli", GF_LOG_DEBUG, "Received response to get volume option");
-
-        if (rsp.op_ret) {
-                if (strcmp (rsp.op_errstr, ""))
-                        snprintf (msg, sizeof (msg), "volume get option: "
-                                  "failed: %s", rsp.op_errstr);
-                else
-                        snprintf (msg, sizeof (msg), "volume get option: "
-                                  "failed");
-
-                if (global_state->mode & GLUSTER_MODE_XML) {
-                        ret = cli_xml_output_str ("volGetopts", msg, rsp.op_ret,
-                                          rsp.op_errno, rsp.op_errstr);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "Error outputting to xml");
-                        }
-                } else {
-                        cli_err ("%s", msg);
-                }
-                ret = rsp.op_ret;
-                goto out_nolog;
-        }
-        dict = dict_new ();
-
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Failed rsp_dict unserialization");
-                goto out;
-        }
+gf_cli_get_vol_opt_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+    gf_cli_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char msg[1024] = {
+        0,
+    };
+    int i = 0;
+    char dict_key[50] = {
+        0,
+    };
+
+    GF_ASSERT(myframe);
+
+    if (-1 == req->rpc_status)
+        goto out;
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+    gf_log("cli", GF_LOG_DEBUG, "Received response to get volume option");
+
+    if (rsp.op_ret) {
+        if (strcmp(rsp.op_errstr, ""))
+            snprintf(msg, sizeof(msg),
+                     "volume get option: "
+                     "failed: %s",
+                     rsp.op_errstr);
+        else
+            snprintf(msg, sizeof(msg),
+                     "volume get option: "
+                     "failed");
 
         if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_getopts (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "xml output generation "
-                                "failed");
-                        ret = 0;
-                }
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "warning", &value);
-        if (!ret) {
-                cli_out ("%s", value);
+            ret = cli_xml_output_str("volGetopts", msg, rsp.op_ret,
+                                     rsp.op_errno, rsp.op_errstr);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+            }
+        } else {
+            cli_err("%s", msg);
         }
-
-        ret = dict_get_int32 (dict, "count", &count);
+        ret = rsp.op_ret;
+        goto out_nolog;
+    }
+    dict = dict_new();
+
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed rsp_dict unserialization");
+        goto out;
+    }
+
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_getopts(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to retrieve count "
-                        "from the dictionary");
-                goto out;
-        }
-
-        if (count <= 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Value of count :%d is "
-                        "invalid", count);
-                ret = -1;
-                goto out;
-        }
-
-        cli_out ("%-40s%-40s", "Option", "Value");
-        cli_out ("%-40s%-40s", "------", "-----");
-        for (i=1; i<=count; i++) {
-                snprintf (dict_key, sizeof dict_key, "key%d", i);
-                ret = dict_get_str (dict, dict_key, &key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to"
-                                " retrieve %s from the "
-                                "dictionary", dict_key);
-                        goto out;
-                }
-                snprintf (dict_key, sizeof dict_key, "value%d", i);
-                ret = dict_get_str (dict, dict_key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "retrieve key value for %s from"
-                                "the dictionary", dict_key);
-                        goto out;
-                }
-                cli_out ("%-40s%-40s", key, value);
+            gf_log("cli", GF_LOG_ERROR,
+                   "xml output generation "
+                   "failed");
+            ret = 0;
+        }
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "warning", &value);
+    if (!ret) {
+        cli_out("%s", value);
+    }
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to retrieve count "
+               "from the dictionary");
+        goto out;
+    }
+
+    if (count <= 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Value of count :%d is "
+               "invalid",
+               count);
+        ret = -1;
+        goto out;
+    }
+
+    cli_out("%-40s%-40s", "Option", "Value");
+    cli_out("%-40s%-40s", "------", "-----");
+    for (i = 1; i <= count; i++) {
+        snprintf(dict_key, sizeof dict_key, "key%d", i);
+        ret = dict_get_str(dict, dict_key, &key);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to"
+                   " retrieve %s from the "
+                   "dictionary",
+                   dict_key);
+            goto out;
+        }
+        snprintf(dict_key, sizeof dict_key, "value%d", i);
+        ret = dict_get_str(dict, dict_key, &value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to "
+                   "retrieve key value for %s from"
+                   "the dictionary",
+                   dict_key);
+            goto out;
         }
+        cli_out("%-40s%-40s", key, value);
+    }
 
 out:
-        if (ret) {
-                cli_out ("volume get option failed. Check the cli/glusterd log "
-                         "file for more details");
-        }
+    if (ret) {
+        cli_out(
+            "volume get option failed. Check the cli/glusterd log "
+            "file for more details");
+    }
 
 out_nolog:
-        if (dict)
-                dict_unref (dict);
-        free (rsp.op_errstr);
-        free (rsp.dict.dict_val);
-        cli_cmd_broadcast_response (ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    cli_cmd_broadcast_response(ret);
+    return ret;
 }
 
 int
-gf_cli_get_vol_opt (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_get_vol_opt(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req  req     = {{0,}};
-        dict_t     *options = NULL;
-        int         ret     = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_get_vol_opt_cbk,
-                               (xdrproc_t)xdr_gf_cli_req, options,
-                               GLUSTER_CLI_GET_VOL_OPT, this, cli_rpc_prog,
-                               NULL);
+    ret = cli_to_glusterd(&req, frame, gf_cli_get_vol_opt_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_GET_VOL_OPT, this, cli_rpc_prog, NULL);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 int
-add_cli_cmd_timeout_to_dict (dict_t *dict)
+add_cli_cmd_timeout_to_dict(dict_t *dict)
 {
-        int      ret     = 0;
+    int ret = 0;
 
-        if (cli_default_conn_timeout > 120) {
-                ret = dict_set_uint32 (dict, "timeout", cli_default_conn_timeout);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO, "Failed to save"
-                                "timeout to dict");
-                }
+    if (cli_default_conn_timeout > 120) {
+        ret = dict_set_uint32(dict, "timeout", cli_default_conn_timeout);
+        if (ret) {
+            gf_log("cli", GF_LOG_INFO,
+                   "Failed to save"
+                   "timeout to dict");
         }
-        return ret;
+    }
+    return ret;
 }
 
 int
-cli_to_glusterd (gf_cli_req *req, call_frame_t *frame,
-                 fop_cbk_fn_t cbkfn, xdrproc_t xdrproc, dict_t *dict,
-                 int procnum, xlator_t *this, rpc_clnt_prog_t *prog,
-                 struct iobref *iobref)
-{
-        int                ret = 0;
-        size_t             len = 0;
-        char               *cmd = NULL;
-        int                i = 0;
-        const char         **words = NULL;
-        cli_local_t        *local = NULL;
-
-        if (!this || !frame || !dict) {
-                ret = -1;
-                goto out;
-        }
+cli_to_glusterd(gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
+                xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
+                rpc_clnt_prog_t *prog, struct iobref *iobref)
+{
+    int ret = 0;
+    size_t len = 0;
+    char *cmd = NULL;
+    int i = 0;
+    const char **words = NULL;
+    cli_local_t *local = NULL;
 
-        if (!frame->local) {
-                ret = -1;
-                goto out;
-        }
+    if (!this || !frame || !dict) {
+        ret = -1;
+        goto out;
+    }
 
-        local = frame->local;
+    if (!frame->local) {
+        ret = -1;
+        goto out;
+    }
 
-        if (!local->words) {
-                ret = -1;
-                goto out;
-        }
+    local = frame->local;
 
-        words = local->words;
+    if (!local->words) {
+        ret = -1;
+        goto out;
+    }
 
-        while (words[i])
-                len += strlen (words[i++]) + 1;
+    words = local->words;
 
-        cmd = GF_CALLOC (1, len, gf_common_mt_char);
+    while (words[i])
+        len += strlen(words[i++]) + 1;
 
-        if (!cmd) {
-                ret = -1;
-                goto out;
-        }
+    cmd = GF_CALLOC(1, len, gf_common_mt_char);
 
-        for (i = 0; words[i]; i++) {
-                strncat (cmd, words[i], len - 1);
-                if (words[i+1] != NULL)
-                        strncat (cmd, " ", len - 1);
-        }
+    if (!cmd) {
+        ret = -1;
+        goto out;
+    }
 
-        cmd [len - 1] = '\0';
+    for (i = 0; words[i]; i++) {
+        strncat(cmd, words[i], len - 1);
+        if (words[i + 1] != NULL)
+            strncat(cmd, " ", len - 1);
+    }
 
-        ret = dict_set_dynstr (dict, "cmd-str", cmd);
-        if (ret)
-                goto out;
+    cmd[len - 1] = '\0';
 
-        ret = add_cli_cmd_timeout_to_dict (dict);
+    ret = dict_set_dynstr(dict, "cmd-str", cmd);
+    if (ret)
+        goto out;
 
-        ret = dict_allocate_and_serialize (dict, &(req->dict).dict_val,
-                                           &(req->dict).dict_len);
+    ret = add_cli_cmd_timeout_to_dict(dict);
 
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "failed to get serialized length of dict");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &(req->dict).dict_val,
+                                      &(req->dict).dict_len);
 
-        ret = cli_cmd_submit (NULL, req, frame, prog, procnum, iobref, this,
-                              cbkfn, (xdrproc_t) xdrproc);
-out:
-        return ret;
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "failed to get serialized length of dict");
+        goto out;
+    }
 
+    ret = cli_cmd_submit(NULL, req, frame, prog, procnum, iobref, this, cbkfn,
+                         (xdrproc_t)xdrproc);
+out:
+    return ret;
 }
 
 int
-gf_cli_print_bitrot_scrub_status (dict_t *dict)
-{
-        int            i                = 1;
-        int            j                = 0;
-        int            ret              = -1;
-        int            count            = 0;
-        char           key[256]         = {0,};
-        char           *volname         = NULL;
-        char           *node_name       = NULL;
-        char           *scrub_freq      = NULL;
-        char           *state_scrub     = NULL;
-        char           *scrub_impact    = NULL;
-        char           *bad_file_str    = NULL;
-        char           *scrub_log_file  = NULL;
-        char           *bitrot_log_file = NULL;
-        uint64_t       scrub_files      = 0;
-        uint64_t       unsigned_files   = 0;
-        uint64_t       scrub_time       = 0;
-        uint64_t       days             = 0;
-        uint64_t       hours            = 0;
-        uint64_t       minutes          = 0;
-        uint64_t       seconds          = 0;
-        char          *last_scrub       = NULL;
-        uint64_t       error_count      = 0;
-        int8_t         scrub_running    = 0;
-        char          *scrub_state_op   = NULL;
-
-
-        ret = dict_get_str (dict, "volname", &volname);
+gf_cli_print_bitrot_scrub_status(dict_t *dict)
+{
+    int i = 1;
+    int j = 0;
+    int ret = -1;
+    int count = 0;
+    char key[256] = {
+        0,
+    };
+    char *volname = NULL;
+    char *node_name = NULL;
+    char *scrub_freq = NULL;
+    char *state_scrub = NULL;
+    char *scrub_impact = NULL;
+    char *bad_file_str = NULL;
+    char *scrub_log_file = NULL;
+    char *bitrot_log_file = NULL;
+    uint64_t scrub_files = 0;
+    uint64_t unsigned_files = 0;
+    uint64_t scrub_time = 0;
+    uint64_t days = 0;
+    uint64_t hours = 0;
+    uint64_t minutes = 0;
+    uint64_t seconds = 0;
+    char *last_scrub = NULL;
+    uint64_t error_count = 0;
+    int8_t scrub_running = 0;
+    char *scrub_state_op = NULL;
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get volume name");
+
+    ret = dict_get_str(dict, "features.scrub", &state_scrub);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrub state value");
+
+    ret = dict_get_str(dict, "features.scrub-throttle", &scrub_impact);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE,
+               "failed to get scrub impact "
+               "value");
+
+    ret = dict_get_str(dict, "features.scrub-freq", &scrub_freq);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get scrub -freq value");
+
+    ret = dict_get_str(dict, "bitrot_log_file", &bitrot_log_file);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE,
+               "failed to get bitrot log file "
+               "location");
+
+    ret = dict_get_str(dict, "scrub_log_file", &scrub_log_file);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE,
+               "failed to get scrubber log file "
+               "location");
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "count not get count value from"
+               " dictionary");
+        goto out;
+    }
+
+    for (i = 1; i <= count; i++) {
+        snprintf(key, 256, "scrub-running-%d", i);
+        ret = dict_get_int8(dict, key, &scrub_running);
         if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get volume name");
-
-        ret = dict_get_str (dict, "features.scrub", &state_scrub);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub state value");
-
-        ret = dict_get_str (dict, "features.scrub-throttle", &scrub_impact);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub impact "
-                        "value");
-
-        ret = dict_get_str (dict, "features.scrub-freq", &scrub_freq);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrub -freq value");
-
-        ret = dict_get_str (dict, "bitrot_log_file", &bitrot_log_file);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get bitrot log file "
-                        "location");
-
-        ret = dict_get_str (dict, "scrub_log_file", &scrub_log_file);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get scrubber log file "
-                        "location");
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get scrubbed "
+                   "files");
+        if (scrub_running)
+            break;
+    }
 
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not get count value from"
-                        " dictionary");
-                goto out;
-        }
+    if (scrub_running)
+        gf_asprintf(&scrub_state_op, "%s (In Progress)", state_scrub);
+    else
+        gf_asprintf(&scrub_state_op, "%s (Idle)", state_scrub);
 
-        for (i = 1; i <= count; i++) {
-                snprintf (key, 256, "scrub-running-%d", i);
-                ret = dict_get_int8 (dict, key, &scrub_running);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get scrubbed "
-                                "files");
-                if (scrub_running)
-                        break;
-        }
+    cli_out("\n%s: %s\n", "Volume name ", volname);
 
-        if (scrub_running)
-                gf_asprintf (&scrub_state_op, "%s (In Progress)", state_scrub);
-        else
-                gf_asprintf (&scrub_state_op, "%s (Idle)", state_scrub);
+    cli_out("%s: %s\n", "State of scrub", scrub_state_op);
 
-        cli_out ("\n%s: %s\n", "Volume name ", volname);
+    cli_out("%s: %s\n", "Scrub impact", scrub_impact);
 
-        cli_out ("%s: %s\n", "State of scrub", scrub_state_op);
+    cli_out("%s: %s\n", "Scrub frequency", scrub_freq);
 
-        cli_out ("%s: %s\n", "Scrub impact", scrub_impact);
+    cli_out("%s: %s\n", "Bitrot error log location", bitrot_log_file);
 
-        cli_out ("%s: %s\n", "Scrub frequency", scrub_freq);
+    cli_out("%s: %s\n", "Scrubber error log location", scrub_log_file);
 
-        cli_out ("%s: %s\n", "Bitrot error log location", bitrot_log_file);
+    for (i = 1; i <= count; i++) {
+        /* Reset the variables to prevent carryover of values */
+        node_name = NULL;
+        last_scrub = NULL;
+        scrub_time = 0;
+        days = 0;
+        hours = 0;
+        minutes = 0;
+        seconds = 0;
+        error_count = 0;
+        scrub_files = 0;
+        unsigned_files = 0;
 
-        cli_out ("%s: %s\n", "Scrubber error log location", scrub_log_file);
+        snprintf(key, 256, "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE, "failed to get node-name");
 
+        snprintf(key, 256, "scrubbed-files-%d", i);
+        ret = dict_get_uint64(dict, key, &scrub_files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get scrubbed "
+                   "files");
 
-        for (i = 1; i <= count; i++) {
-                /* Reset the variables to prevent carryover of values */
-                node_name       = NULL;
-                last_scrub      = NULL;
-                scrub_time      = 0;
-                days            = 0;
-                hours           = 0;
-                minutes         = 0;
-                seconds         = 0;
-                error_count     = 0;
-                scrub_files     = 0;
-                unsigned_files  = 0;
+        snprintf(key, 256, "unsigned-files-%d", i);
+        ret = dict_get_uint64(dict, key, &unsigned_files);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get unsigned "
+                   "files");
 
-                snprintf (key, 256, "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get node-name");
+        snprintf(key, 256, "scrub-duration-%d", i);
+        ret = dict_get_uint64(dict, key, &scrub_time);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get last scrub "
+                   "duration");
 
-                snprintf (key, 256, "scrubbed-files-%d", i);
-                ret = dict_get_uint64 (dict, key, &scrub_files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get scrubbed "
-                                "files");
+        snprintf(key, 256, "last-scrub-time-%d", i);
+        ret = dict_get_str(dict, key, &last_scrub);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get last scrub"
+                   " time");
+        snprintf(key, 256, "error-count-%d", i);
+        ret = dict_get_uint64(dict, key, &error_count);
+        if (ret)
+            gf_log("cli", GF_LOG_TRACE,
+                   "failed to get error "
+                   "count");
 
-                snprintf (key, 256, "unsigned-files-%d", i);
-                ret = dict_get_uint64 (dict, key, &unsigned_files);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get unsigned "
-                                "files");
+        cli_out("\n%s\n",
+                "=========================================="
+                "===============");
 
-                snprintf (key, 256, "scrub-duration-%d", i);
-                ret = dict_get_uint64 (dict, key, &scrub_time);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get last scrub "
-                                "duration");
+        cli_out("%s: %s\n", "Node", node_name);
 
-                snprintf (key, 256, "last-scrub-time-%d", i);
-                ret = dict_get_str (dict, key, &last_scrub);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get last scrub"
-                                " time");
-                snprintf (key, 256, "error-count-%d", i);
-                ret = dict_get_uint64 (dict, key, &error_count);
-                if (ret)
-                        gf_log ("cli", GF_LOG_TRACE, "failed to get error "
-                                "count");
+        cli_out("%s: %" PRIu64 "\n", "Number of Scrubbed files", scrub_files);
 
-                cli_out ("\n%s\n", "=========================================="
-                         "===============");
+        cli_out("%s: %" PRIu64 "\n", "Number of Skipped files", unsigned_files);
 
-                cli_out ("%s: %s\n", "Node", node_name);
+        if ((!last_scrub) || !strcmp(last_scrub, ""))
+            cli_out("%s: %s\n", "Last completed scrub time",
+                    "Scrubber pending to complete.");
+        else
+            cli_out("%s: %s\n", "Last completed scrub time", last_scrub);
 
-                cli_out ("%s: %"PRIu64 "\n", "Number of Scrubbed files",
-                          scrub_files);
+        /* Printing last scrub duration time in human readable form*/
+        seconds = scrub_time % 60;
+        minutes = (scrub_time / 60) % 60;
+        hours = (scrub_time / 3600) % 24;
+        days = scrub_time / 86400;
+        cli_out("%s: %" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
+                "Duration of last scrub (D:M:H:M:S)", days, hours, minutes,
+                seconds);
 
-                cli_out ("%s: %"PRIu64 "\n", "Number of Skipped files",
-                          unsigned_files);
+        cli_out("%s: %" PRIu64 "\n", "Error count", error_count);
 
-                if ((!last_scrub) || !strcmp (last_scrub, ""))
-                        cli_out ("%s: %s\n", "Last completed scrub time",
-                                 "Scrubber pending to complete.");
-                else
-                        cli_out ("%s: %s\n", "Last completed scrub time",
-                                 last_scrub);
-
-                /* Printing last scrub duration time in human readable form*/
-                seconds    = scrub_time%60;
-                minutes    = (scrub_time/60)%60;
-                hours      = (scrub_time/3600)%24;
-                days       = scrub_time/86400;
-                cli_out ("%s: %"PRIu64 ":%"PRIu64 ":%"PRIu64 ":%"PRIu64 "\n",
-                         "Duration of last scrub (D:M:H:M:S)",
-                         days, hours, minutes, seconds);
-
-                cli_out ("%s: %"PRIu64 "\n", "Error count", error_count);
-
-                if (error_count) {
-                        cli_out ("%s:\n", "Corrupted object's [GFID]");
-                        /* Printing list of bad file's (Corrupted object's)*/
-                        for (j = 0; j < error_count; j++) {
-                                snprintf (key, 256, "quarantine-%d-%d", j, i);
-                                ret = dict_get_str (dict, key, &bad_file_str);
-                                if (!ret) {
-                                        cli_out ("%s\n", bad_file_str);
-                                }
-                        }
+        if (error_count) {
+            cli_out("%s:\n", "Corrupted object's [GFID]");
+            /* Printing list of bad file's (Corrupted object's)*/
+            for (j = 0; j < error_count; j++) {
+                snprintf(key, 256, "quarantine-%d-%d", j, i);
+                ret = dict_get_str(dict, key, &bad_file_str);
+                if (!ret) {
+                    cli_out("%s\n", bad_file_str);
                 }
+            }
         }
-        cli_out ("%s\n", "=========================================="
-                 "===============");
+    }
+    cli_out("%s\n",
+            "=========================================="
+            "===============");
 
 out:
-        GF_FREE (scrub_state_op);
-        return 0;
+    GF_FREE(scrub_state_op);
+    return 0;
 }
 
 int
-gf_cli_bitrot_cbk (struct rpc_req *req, struct iovec *iov,
-                   int count, void *myframe)
-{
-        int                  ret                       = -1;
-        int                  type                      = 0;
-        gf_cli_rsp           rsp                       = {0, };
-        dict_t               *dict                     = NULL;
-        char                 *scrub_cmd                = NULL;
-        char                 *volname                  = NULL;
-        char                 *cmd_str                  = NULL;
-        char                 *cmd_op                   = NULL;
-
-        GF_ASSERT (myframe);
-
-        if (req->rpc_status == -1) {
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
-        if (ret < 0) {
-                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,
-                        "Failed to decode xdr response");
-                goto out;
-        }
-
-        if (rsp.op_ret) {
-                ret = -1;
-                if (global_state->mode & GLUSTER_MODE_XML)
-                        goto xml_output;
-
-                if (strcmp (rsp.op_errstr, ""))
-                        cli_err ("Bitrot command failed : %s", rsp.op_errstr);
-                else
-                        cli_err ("Bitrot command : failed");
-
-                goto out;
-        }
+gf_cli_bitrot_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
+{
+    int ret = -1;
+    int type = 0;
+    gf_cli_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *scrub_cmd = NULL;
+    char *volname = NULL;
+    char *cmd_str = NULL;
+    char *cmd_op = NULL;
+
+    GF_ASSERT(myframe);
+
+    if (req->rpc_status == -1) {
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
+    if (ret < 0) {
+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,
+               "Failed to decode xdr response");
+        goto out;
+    }
+
+    if (rsp.op_ret) {
+        ret = -1;
+        if (global_state->mode & GLUSTER_MODE_XML)
+            goto xml_output;
 
-        if (rsp.dict.dict_len) {
-                /* Unserialize the dictionary */
-                dict = dict_new ();
+        if (strcmp(rsp.op_errstr, ""))
+            cli_err("Bitrot command failed : %s", rsp.op_errstr);
+        else
+            cli_err("Bitrot command : failed");
 
-                if (!dict) {
-                        ret = -1;
-                        goto out;
-                }
+        goto out;
+    }
 
-                ret = dict_unserialize (rsp.dict.dict_val,
-                                        rsp.dict.dict_len,
-                                        &dict);
+    if (rsp.dict.dict_len) {
+        /* Unserialize the dictionary */
+        dict = dict_new();
 
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "failed to unserialize "
-                                "req-buffer to dictionary");
-                        goto out;
-                }
+        if (!dict) {
+            ret = -1;
+            goto out;
         }
 
-        gf_log ("cli", GF_LOG_DEBUG, "Received resp to bit rot command");
+        ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);
 
-        ret = dict_get_int32 (dict, "type", &type);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get command type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "failed to unserialize "
+                   "req-buffer to dictionary");
+            goto out;
         }
+    }
 
-        /* Ignoring the error, as using dict val for cli output only */
-        ret = dict_get_str (dict, "scrub-value", &scrub_cmd);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "Failed to get scrub command");
+    gf_log("cli", GF_LOG_DEBUG, "Received resp to bit rot command");
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get volume name");
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get command type");
+        goto out;
+    }
 
-        ret = dict_get_str (dict, "cmd-str", &cmd_str);
-        if (ret)
-                gf_log ("cli", GF_LOG_TRACE, "failed to get command string");
+    /* Ignoring the error, as using dict val for cli output only */
+    ret = dict_get_str(dict, "scrub-value", &scrub_cmd);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "Failed to get scrub command");
 
-        if (cmd_str)
-                cmd_op = strrchr(cmd_str, ' ') + 1;
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get volume name");
 
-        if ((type == GF_BITROT_CMD_SCRUB_STATUS) &&
-             !(global_state->mode & GLUSTER_MODE_XML)) {
-                ret = gf_cli_print_bitrot_scrub_status (dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to print bitrot "
-                                "scrub status");
-                }
-                goto out;
-        }
+    ret = dict_get_str(dict, "cmd-str", &cmd_str);
+    if (ret)
+        gf_log("cli", GF_LOG_TRACE, "failed to get command string");
 
-        switch (type) {
-        case  GF_BITROT_OPTION_TYPE_ENABLE:
-                cli_out("volume bitrot: success bitrot enabled "
-                        "for volume %s", volname);
-                ret = 0;
-                goto out;
+    if (cmd_str)
+        cmd_op = strrchr(cmd_str, ' ') + 1;
+
+    if ((type == GF_BITROT_CMD_SCRUB_STATUS) &&
+        !(global_state->mode & GLUSTER_MODE_XML)) {
+        ret = gf_cli_print_bitrot_scrub_status(dict);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to print bitrot "
+                   "scrub status");
+        }
+        goto out;
+    }
+
+    switch (type) {
+        case GF_BITROT_OPTION_TYPE_ENABLE:
+            cli_out(
+                "volume bitrot: success bitrot enabled "
+                "for volume %s",
+                volname);
+            ret = 0;
+            goto out;
         case GF_BITROT_OPTION_TYPE_DISABLE:
-                cli_out("volume bitrot: success bitrot disabled "
-                        "for volume %s", volname);
-                ret = 0;
-                goto out;
+            cli_out(
+                "volume bitrot: success bitrot disabled "
+                "for volume %s",
+                volname);
+            ret = 0;
+            goto out;
         case GF_BITROT_CMD_SCRUB_ONDEMAND:
-                cli_out("volume bitrot: scrubber started ondemand "
-                        "for volume %s", volname);
-                ret = 0;
-                goto out;
+            cli_out(
+                "volume bitrot: scrubber started ondemand "
+                "for volume %s",
+                volname);
+            ret = 0;
+            goto out;
         case GF_BITROT_OPTION_TYPE_SCRUB:
-                if (!strncmp ("pause", scrub_cmd, sizeof ("pause")))
-                        cli_out("volume bitrot: scrubber paused "
-                                "for volume %s", volname);
-                if (!strncmp ("resume", scrub_cmd, sizeof ("resume")))
-                        cli_out("volume bitrot: scrubber resumed "
-                                "for volume %s", volname);
-                ret = 0;
-                goto out;
+            if (!strncmp("pause", scrub_cmd, sizeof("pause")))
+                cli_out(
+                    "volume bitrot: scrubber paused "
+                    "for volume %s",
+                    volname);
+            if (!strncmp("resume", scrub_cmd, sizeof("resume")))
+                cli_out(
+                    "volume bitrot: scrubber resumed "
+                    "for volume %s",
+                    volname);
+            ret = 0;
+            goto out;
         case GF_BITROT_OPTION_TYPE_SCRUB_FREQ:
-                cli_out("volume bitrot: scrub-frequency is set to %s "
-                        "successfully for volume %s", cmd_op, volname);
-                ret = 0;
-                goto out;
+            cli_out(
+                "volume bitrot: scrub-frequency is set to %s "
+                "successfully for volume %s",
+                cmd_op, volname);
+            ret = 0;
+            goto out;
         case GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE:
-                cli_out("volume bitrot: scrub-throttle is set to %s "
-                        "successfully for volume %s", cmd_op, volname);
-                ret = 0;
-                goto out;
-        }
+            cli_out(
+                "volume bitrot: scrub-throttle is set to %s "
+                "successfully for volume %s",
+                cmd_op, volname);
+            ret = 0;
+            goto out;
+    }
 
 xml_output:
-        if (global_state->mode & GLUSTER_MODE_XML) {
-                ret = cli_xml_output_vol_profile (dict, rsp.op_ret,
-                                                  rsp.op_errno,
-                                                  rsp.op_errstr);
-                if (ret)
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Error outputting to xml");
-                goto out;
-        }
+    if (global_state->mode & GLUSTER_MODE_XML) {
+        ret = cli_xml_output_vol_profile(dict, rsp.op_ret, rsp.op_errno,
+                                         rsp.op_errstr);
+        if (ret)
+            gf_log("cli", GF_LOG_ERROR, "Error outputting to xml");
+        goto out;
+    }
 
-        if (!rsp.op_ret)
-                cli_out ("volume bitrot: success");
+    if (!rsp.op_ret)
+        cli_out("volume bitrot: success");
 
-        ret = rsp.op_ret;
+    ret = rsp.op_ret;
 
 out:
-        if (dict)
-            dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        free (rsp.dict.dict_val);
-        free (rsp.op_errstr);
+    free(rsp.dict.dict_val);
+    free(rsp.op_errstr);
 
-        cli_cmd_broadcast_response (ret);
+    cli_cmd_broadcast_response(ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_cli_bitrot (call_frame_t *frame, xlator_t *this, void *data)
+gf_cli_bitrot(call_frame_t *frame, xlator_t *this, void *data)
 {
-        gf_cli_req        req           = { {0,} };
-        dict_t           *options       = NULL;
-        int               ret           = -1;
+    gf_cli_req req = {{
+        0,
+    }};
+    dict_t *options = NULL;
+    int ret = -1;
 
-        if (!frame || !this || !data)
-                goto out;
+    if (!frame || !this || !data)
+        goto out;
 
-        options = data;
+    options = data;
 
-        ret = cli_to_glusterd (&req, frame, gf_cli_bitrot_cbk,
-                               (xdrproc_t) xdr_gf_cli_req, options,
-                               GLUSTER_CLI_BITROT, this, cli_rpc_prog,
-                               NULL);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "cli_to_glusterd for "
-                        "bitrot failed");
-                goto out;
-        }
+    ret = cli_to_glusterd(&req, frame, gf_cli_bitrot_cbk,
+                          (xdrproc_t)xdr_gf_cli_req, options,
+                          GLUSTER_CLI_BITROT, this, cli_rpc_prog, NULL);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "cli_to_glusterd for "
+               "bitrot failed");
+        goto out;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
 
-        GF_FREE (req.dict.dict_val);
+    GF_FREE(req.dict.dict_val);
 
-        return ret;
+    return ret;
 }
 
 struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {
-        [GLUSTER_CLI_NULL]             = {"NULL", NULL },
-        [GLUSTER_CLI_PROBE]            = {"PROBE_QUERY", gf_cli_probe},
-        [GLUSTER_CLI_DEPROBE]          = {"DEPROBE_QUERY", gf_cli_deprobe},
-        [GLUSTER_CLI_LIST_FRIENDS]     = {"LIST_FRIENDS", gf_cli_list_friends},
-        [GLUSTER_CLI_UUID_RESET]       = {"UUID_RESET", gf_cli3_1_uuid_reset},
-        [GLUSTER_CLI_UUID_GET]         = {"UUID_GET", gf_cli3_1_uuid_get},
-        [GLUSTER_CLI_CREATE_VOLUME]    = {"CREATE_VOLUME", gf_cli_create_volume},
-        [GLUSTER_CLI_DELETE_VOLUME]    = {"DELETE_VOLUME", gf_cli_delete_volume},
-        [GLUSTER_CLI_START_VOLUME]     = {"START_VOLUME", gf_cli_start_volume},
-        [GLUSTER_CLI_STOP_VOLUME]      = {"STOP_VOLUME", gf_cli_stop_volume},
-        [GLUSTER_CLI_RENAME_VOLUME]    = {"RENAME_VOLUME", gf_cli_rename_volume},
-        [GLUSTER_CLI_DEFRAG_VOLUME]    = {"DEFRAG_VOLUME", gf_cli_defrag_volume},
-        [GLUSTER_CLI_GET_VOLUME]       = {"GET_VOLUME", gf_cli_get_volume},
-        [GLUSTER_CLI_GET_NEXT_VOLUME]  = {"GET_NEXT_VOLUME", gf_cli_get_next_volume},
-        [GLUSTER_CLI_SET_VOLUME]       = {"SET_VOLUME", gf_cli_set_volume},
-        [GLUSTER_CLI_ADD_BRICK]        = {"ADD_BRICK", gf_cli_add_brick},
-        [GLUSTER_CLI_REMOVE_BRICK]     = {"REMOVE_BRICK", gf_cli_remove_brick},
-        [GLUSTER_CLI_REPLACE_BRICK]    = {"REPLACE_BRICK", gf_cli_replace_brick},
-        [GLUSTER_CLI_LOG_ROTATE]       = {"LOG ROTATE", gf_cli_log_rotate},
-        [GLUSTER_CLI_GETSPEC]          = {"GETSPEC", gf_cli_getspec},
-        [GLUSTER_CLI_PMAP_PORTBYBRICK] = {"PMAP PORTBYBRICK", gf_cli_pmap_b2p},
-        [GLUSTER_CLI_SYNC_VOLUME]      = {"SYNC_VOLUME", gf_cli_sync_volume},
-        [GLUSTER_CLI_RESET_VOLUME]     = {"RESET_VOLUME", gf_cli_reset_volume},
-        [GLUSTER_CLI_FSM_LOG]          = {"FSM_LOG", gf_cli_fsm_log},
-        [GLUSTER_CLI_GSYNC_SET]        = {"GSYNC_SET", gf_cli_gsync_set},
-        [GLUSTER_CLI_PROFILE_VOLUME]   = {"PROFILE_VOLUME", gf_cli_profile_volume},
-        [GLUSTER_CLI_QUOTA]            = {"QUOTA", gf_cli_quota},
-        [GLUSTER_CLI_TOP_VOLUME]       = {"TOP_VOLUME", gf_cli_top_volume},
-        [GLUSTER_CLI_GETWD]            = {"GETWD", gf_cli_getwd},
-        [GLUSTER_CLI_STATUS_VOLUME]    = {"STATUS_VOLUME", gf_cli_status_volume},
-        [GLUSTER_CLI_STATUS_ALL]       = {"STATUS_ALL", gf_cli_status_volume_all},
-        [GLUSTER_CLI_MOUNT]            = {"MOUNT", gf_cli_mount},
-        [GLUSTER_CLI_UMOUNT]           = {"UMOUNT", gf_cli_umount},
-        [GLUSTER_CLI_HEAL_VOLUME]      = {"HEAL_VOLUME", gf_cli_heal_volume},
-        [GLUSTER_CLI_STATEDUMP_VOLUME] = {"STATEDUMP_VOLUME", gf_cli_statedump_volume},
-        [GLUSTER_CLI_LIST_VOLUME]      = {"LIST_VOLUME", gf_cli_list_volume},
-        [GLUSTER_CLI_CLRLOCKS_VOLUME]  = {"CLEARLOCKS_VOLUME", gf_cli_clearlocks_volume},
-        [GLUSTER_CLI_COPY_FILE]        = {"COPY_FILE", gf_cli_copy_file},
-        [GLUSTER_CLI_SYS_EXEC]         = {"SYS_EXEC", gf_cli_sys_exec},
-        [GLUSTER_CLI_SNAP]             = {"SNAP", gf_cli_snapshot},
-        [GLUSTER_CLI_BARRIER_VOLUME]   = {"BARRIER VOLUME", gf_cli_barrier_volume},
-        [GLUSTER_CLI_GET_VOL_OPT]      = {"GET_VOL_OPT", gf_cli_get_vol_opt},
-        [GLUSTER_CLI_BITROT]           = {"BITROT", gf_cli_bitrot},
-        [GLUSTER_CLI_ATTACH_TIER]      = {"ATTACH_TIER", gf_cli_attach_tier},
-        [GLUSTER_CLI_TIER]             = {"TIER", gf_cli_tier},
-        [GLUSTER_CLI_GET_STATE]        = {"GET_STATE", gf_cli_get_state},
-        [GLUSTER_CLI_RESET_BRICK]      = {"RESET_BRICK", gf_cli_reset_brick},
-        [GLUSTER_CLI_REMOVE_TIER_BRICK] = {"DETACH_TIER", gf_cli_remove_tier_brick},
-        [GLUSTER_CLI_ADD_TIER_BRICK]   = {"ADD_TIER_BRICK", gf_cli_add_tier_brick}
-};
+    [GLUSTER_CLI_NULL] = {"NULL", NULL},
+    [GLUSTER_CLI_PROBE] = {"PROBE_QUERY", gf_cli_probe},
+    [GLUSTER_CLI_DEPROBE] = {"DEPROBE_QUERY", gf_cli_deprobe},
+    [GLUSTER_CLI_LIST_FRIENDS] = {"LIST_FRIENDS", gf_cli_list_friends},
+    [GLUSTER_CLI_UUID_RESET] = {"UUID_RESET", gf_cli3_1_uuid_reset},
+    [GLUSTER_CLI_UUID_GET] = {"UUID_GET", gf_cli3_1_uuid_get},
+    [GLUSTER_CLI_CREATE_VOLUME] = {"CREATE_VOLUME", gf_cli_create_volume},
+    [GLUSTER_CLI_DELETE_VOLUME] = {"DELETE_VOLUME", gf_cli_delete_volume},
+    [GLUSTER_CLI_START_VOLUME] = {"START_VOLUME", gf_cli_start_volume},
+    [GLUSTER_CLI_STOP_VOLUME] = {"STOP_VOLUME", gf_cli_stop_volume},
+    [GLUSTER_CLI_RENAME_VOLUME] = {"RENAME_VOLUME", gf_cli_rename_volume},
+    [GLUSTER_CLI_DEFRAG_VOLUME] = {"DEFRAG_VOLUME", gf_cli_defrag_volume},
+    [GLUSTER_CLI_GET_VOLUME] = {"GET_VOLUME", gf_cli_get_volume},
+    [GLUSTER_CLI_GET_NEXT_VOLUME] = {"GET_NEXT_VOLUME", gf_cli_get_next_volume},
+    [GLUSTER_CLI_SET_VOLUME] = {"SET_VOLUME", gf_cli_set_volume},
+    [GLUSTER_CLI_ADD_BRICK] = {"ADD_BRICK", gf_cli_add_brick},
+    [GLUSTER_CLI_REMOVE_BRICK] = {"REMOVE_BRICK", gf_cli_remove_brick},
+    [GLUSTER_CLI_REPLACE_BRICK] = {"REPLACE_BRICK", gf_cli_replace_brick},
+    [GLUSTER_CLI_LOG_ROTATE] = {"LOG ROTATE", gf_cli_log_rotate},
+    [GLUSTER_CLI_GETSPEC] = {"GETSPEC", gf_cli_getspec},
+    [GLUSTER_CLI_PMAP_PORTBYBRICK] = {"PMAP PORTBYBRICK", gf_cli_pmap_b2p},
+    [GLUSTER_CLI_SYNC_VOLUME] = {"SYNC_VOLUME", gf_cli_sync_volume},
+    [GLUSTER_CLI_RESET_VOLUME] = {"RESET_VOLUME", gf_cli_reset_volume},
+    [GLUSTER_CLI_FSM_LOG] = {"FSM_LOG", gf_cli_fsm_log},
+    [GLUSTER_CLI_GSYNC_SET] = {"GSYNC_SET", gf_cli_gsync_set},
+    [GLUSTER_CLI_PROFILE_VOLUME] = {"PROFILE_VOLUME", gf_cli_profile_volume},
+    [GLUSTER_CLI_QUOTA] = {"QUOTA", gf_cli_quota},
+    [GLUSTER_CLI_TOP_VOLUME] = {"TOP_VOLUME", gf_cli_top_volume},
+    [GLUSTER_CLI_GETWD] = {"GETWD", gf_cli_getwd},
+    [GLUSTER_CLI_STATUS_VOLUME] = {"STATUS_VOLUME", gf_cli_status_volume},
+    [GLUSTER_CLI_STATUS_ALL] = {"STATUS_ALL", gf_cli_status_volume_all},
+    [GLUSTER_CLI_MOUNT] = {"MOUNT", gf_cli_mount},
+    [GLUSTER_CLI_UMOUNT] = {"UMOUNT", gf_cli_umount},
+    [GLUSTER_CLI_HEAL_VOLUME] = {"HEAL_VOLUME", gf_cli_heal_volume},
+    [GLUSTER_CLI_STATEDUMP_VOLUME] = {"STATEDUMP_VOLUME",
+                                      gf_cli_statedump_volume},
+    [GLUSTER_CLI_LIST_VOLUME] = {"LIST_VOLUME", gf_cli_list_volume},
+    [GLUSTER_CLI_CLRLOCKS_VOLUME] = {"CLEARLOCKS_VOLUME",
+                                     gf_cli_clearlocks_volume},
+    [GLUSTER_CLI_COPY_FILE] = {"COPY_FILE", gf_cli_copy_file},
+    [GLUSTER_CLI_SYS_EXEC] = {"SYS_EXEC", gf_cli_sys_exec},
+    [GLUSTER_CLI_SNAP] = {"SNAP", gf_cli_snapshot},
+    [GLUSTER_CLI_BARRIER_VOLUME] = {"BARRIER VOLUME", gf_cli_barrier_volume},
+    [GLUSTER_CLI_GET_VOL_OPT] = {"GET_VOL_OPT", gf_cli_get_vol_opt},
+    [GLUSTER_CLI_BITROT] = {"BITROT", gf_cli_bitrot},
+    [GLUSTER_CLI_ATTACH_TIER] = {"ATTACH_TIER", gf_cli_attach_tier},
+    [GLUSTER_CLI_TIER] = {"TIER", gf_cli_tier},
+    [GLUSTER_CLI_GET_STATE] = {"GET_STATE", gf_cli_get_state},
+    [GLUSTER_CLI_RESET_BRICK] = {"RESET_BRICK", gf_cli_reset_brick},
+    [GLUSTER_CLI_REMOVE_TIER_BRICK] = {"DETACH_TIER", gf_cli_remove_tier_brick},
+    [GLUSTER_CLI_ADD_TIER_BRICK] = {"ADD_TIER_BRICK", gf_cli_add_tier_brick}};
 
 struct rpc_clnt_program cli_prog = {
-        .progname  = "Gluster CLI",
-        .prognum   = GLUSTER_CLI_PROGRAM,
-        .progver   = GLUSTER_CLI_VERSION,
-        .numproc   = GLUSTER_CLI_MAXVALUE,
-        .proctable = gluster_cli_actors,
+    .progname = "Gluster CLI",
+    .prognum = GLUSTER_CLI_PROGRAM,
+    .progver = GLUSTER_CLI_VERSION,
+    .numproc = GLUSTER_CLI_MAXVALUE,
+    .proctable = gluster_cli_actors,
 };
 
 struct rpc_clnt_procedure cli_quotad_procs[GF_AGGREGATOR_MAXVALUE] = {
-        [GF_AGGREGATOR_NULL]     = {"NULL", NULL},
-        [GF_AGGREGATOR_LOOKUP]   = {"LOOKUP", NULL},
-        [GF_AGGREGATOR_GETLIMIT]   = {"GETLIMIT", cli_quotad_getlimit},
+    [GF_AGGREGATOR_NULL] = {"NULL", NULL},
+    [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", NULL},
+    [GF_AGGREGATOR_GETLIMIT] = {"GETLIMIT", cli_quotad_getlimit},
 };
 
 struct rpc_clnt_program cli_quotad_clnt = {
-        .progname  = "CLI Quotad client",
-        .prognum   = GLUSTER_AGGREGATOR_PROGRAM,
-        .progver   = GLUSTER_AGGREGATOR_VERSION,
-        .numproc   = GF_AGGREGATOR_MAXVALUE,
-        .proctable = cli_quotad_procs,
+    .progname = "CLI Quotad client",
+    .prognum = GLUSTER_AGGREGATOR_PROGRAM,
+    .progver = GLUSTER_AGGREGATOR_VERSION,
+    .numproc = GF_AGGREGATOR_MAXVALUE,
+    .proctable = cli_quotad_procs,
 };
diff --git a/cli/src/cli-xml-output.c b/cli/src/cli-xml-output.c
index fd42192162b..5dbf37e3d5d 100644
--- a/cli/src/cli-xml-output.c
+++ b/cli/src/cli-xml-output.c
@@ -15,10 +15,7 @@
 #include "syscall.h"
 #include "upcall-utils.h"
 
-enum gf_task_types {
-    GF_TASK_TYPE_REBALANCE,
-    GF_TASK_TYPE_REMOVE_BRICK
-};
+enum gf_task_types { GF_TASK_TYPE_REBALANCE, GF_TASK_TYPE_REMOVE_BRICK };
 
 /*
  * IMPORTANT NOTE:
@@ -47,4337 +44,4156 @@ enum gf_task_types {
  *  of #if (HAVE_LIB_XML)
  */
 
-
 #if (HAVE_LIB_XML)
 
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 
-#define XML_RET_CHECK_AND_GOTO(ret, label)      do {            \
-                if (ret < 0) {                                  \
-                        ret = -1;                               \
-                        goto label;                             \
-                }                                               \
-                else                                            \
-                        ret = 0;                                \
-        }while (0)                                              \
+#define XML_RET_CHECK_AND_GOTO(ret, label)                                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        } else                                                                 \
+            ret = 0;                                                           \
+    } while (0)
 
 int
-cli_begin_xml_output (xmlTextWriterPtr *writer, xmlDocPtr *doc)
+cli_begin_xml_output(xmlTextWriterPtr *writer, xmlDocPtr *doc)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        *writer = xmlNewTextWriterDoc (doc, 0);
-        if (writer == NULL) {
-                ret = -1;
-                goto out;
-        }
+    *writer = xmlNewTextWriterDoc(doc, 0);
+    if (writer == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xmlTextWriterStartDocument (*writer, "1.0", "UTF-8", "yes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartDocument(*writer, "1.0", "UTF-8", "yes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <cliOutput> */
-        ret = xmlTextWriterStartElement (*writer, (xmlChar *)"cliOutput");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <cliOutput> */
+    ret = xmlTextWriterStartElement(*writer, (xmlChar *)"cliOutput");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_end_xml_output (xmlTextWriterPtr writer, xmlDocPtr doc)
+cli_end_xml_output(xmlTextWriterPtr writer, xmlDocPtr doc)
 {
-        int             ret = -1;
-
-        /* </cliOutput> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
 
-        ret = xmlTextWriterEndDocument (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </cliOutput> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterEndDocument(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Dump xml document to stdout and pretty format it */
-        xmlSaveFormatFileEnc ("-", doc, "UTF-8", 1);
+    /* Dump xml document to stdout and pretty format it */
+    xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
 
-        xmlFreeTextWriter (writer);
-        xmlFreeDoc (doc);
+    xmlFreeTextWriter(writer);
+    xmlFreeDoc(doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_common (xmlTextWriterPtr writer, int op_ret, int op_errno,
-                       char *op_errstr)
+cli_xml_output_common(xmlTextWriterPtr writer, int op_ret, int op_errno,
+                      char *op_errstr)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opRet",
-                                               "%d", op_ret);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opRet", "%d",
+                                          op_ret);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opErrno",
-                                               "%d", op_errno);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrno", "%d",
+                                          op_errno);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (op_errstr)
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opErrstr",
-                                                       "%s", op_errstr);
-        else
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opErrstr",
-                                                       "%s", "");
+    if (op_errstr)
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrstr",
+                                              "%s", op_errstr);
+    else
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opErrstr",
+                                              "%s", "");
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_str (char *op, char *str, int op_ret, int op_errno,
-                    char *op_errstr)
+cli_xml_output_str(char *op, char *str, int op_ret, int op_errno,
+                   char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        if (op) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"cliOp",
-                                                       "%s", op);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (op) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"cliOp", "%s",
+                                              op);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (str) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"output",
-                                                       "%s", str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (str) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"output", "%s",
+                                              str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_data_pair (dict_t *this, char *key, data_t *value,
-                          void *data)
+cli_xml_output_data_pair(dict_t *this, char *key, data_t *value, void *data)
 {
-        int                     ret = -1;
-        xmlTextWriterPtr        *writer = NULL;
+    int ret = -1;
+    xmlTextWriterPtr *writer = NULL;
 
-        writer = (xmlTextWriterPtr *)data;
+    writer = (xmlTextWriterPtr *)data;
 
-        ret = xmlTextWriterWriteFormatElement (*writer, (xmlChar *)key,
-                                               "%s", value->data);
+    ret = xmlTextWriterWriteFormatElement(*writer, (xmlChar *)key, "%s",
+                                          value->data);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        return ret;
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_dict ( char *op, dict_t *dict, int op_ret, int op_errno,
-                      char *op_errstr)
+cli_xml_output_dict(char *op, dict_t *dict, int op_ret, int op_errno,
+                    char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        /* <"op"> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <"op"> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (dict)
-                dict_foreach (dict, cli_xml_output_data_pair, &writer);
+    if (dict)
+        dict_foreach(dict, cli_xml_output_data_pair, &writer);
 
-        /* </"op"> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </"op"> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_status_common (xmlTextWriterPtr writer, dict_t *dict,
-                                  int   brick_index, int *online,
-                                  gf_boolean_t *node_present)
+cli_xml_output_vol_status_common(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index, int *online,
+                                 gf_boolean_t *node_present)
 {
-        int             ret             = -1;
-        char            *hostname       = NULL;
-        char            *path           = NULL;
-        char            *uuid           = NULL;
-        int             port            = 0;
-        int             rdma_port       = 0;
-        int             status          = 0;
-        int             pid             = 0;
-        char            key[1024]       = {0,};
-
-        snprintf (key, sizeof (key), "brick%d.hostname", brick_index);
-        ret = dict_get_str (dict, key, &hostname);
-        if (ret) {
-                *node_present = _gf_false;
-                goto out;
+    int ret = -1;
+    char *hostname = NULL;
+    char *path = NULL;
+    char *uuid = NULL;
+    int port = 0;
+    int rdma_port = 0;
+    int status = 0;
+    int pid = 0;
+    char key[1024] = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "brick%d.hostname", brick_index);
+    ret = dict_get_str(dict, key, &hostname);
+    if (ret) {
+        *node_present = _gf_false;
+        goto out;
+    }
+    *node_present = _gf_true;
+
+    /* <node>
+     * will be closed in the calling function cli_xml_output_vol_status()*/
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"node");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname", "%s",
+                                          hostname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.path", brick_index);
+    ret = dict_get_str(dict, key, &path);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"path", "%s",
+                                          path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.peerid", brick_index);
+    ret = dict_get_str(dict, key, &uuid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"peerid", "%s",
+                                          uuid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.status", brick_index);
+    ret = dict_get_int32(dict, key, &status);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                          status);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    *online = status;
+
+    snprintf(key, sizeof(key), "brick%d.port", brick_index);
+    ret = dict_get_int32(dict, key, &port);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "brick%d.rdma_port", brick_index);
+    ret = dict_get_int32(dict, key, &rdma_port);
+
+    /* If the process is either offline or doesn't provide a port (shd)
+     * port = "N/A"
+     * else print the port number of the process.
+     */
+
+    /*
+     * Tag 'port' can be removed once console management is started
+     * to support new tag ports.
+     */
+
+    if (*online == 1 && port != 0)
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"port", "%d",
+                                              port);
+    else
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"port", "%s",
+                                              "N/A");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"ports");
+    if (*online == 1 && (port != 0 || rdma_port != 0)) {
+        if (port) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp",
+                                                  "%d", port);
+        } else {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp",
+                                                  "%s", "N/A");
         }
-        *node_present = _gf_true;
-
-        /* <node>
-         * will be closed in the calling function cli_xml_output_vol_status()*/
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hostname",
-                                               "%s", hostname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.path", brick_index);
-        ret = dict_get_str (dict, key, &path);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.peerid", brick_index);
-        ret = dict_get_str (dict, key, &uuid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"peerid",
-                                               "%s", uuid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.status", brick_index);
-        ret = dict_get_int32 (dict, key, &status);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"status",
-                                               "%d", status);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        *online = status;
-
-        snprintf (key, sizeof (key), "brick%d.port", brick_index);
-        ret = dict_get_int32 (dict, key, &port);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "brick%d.rdma_port", brick_index);
-        ret = dict_get_int32 (dict, key, &rdma_port);
-
-        /* If the process is either offline or doesn't provide a port (shd)
-         * port = "N/A"
-         * else print the port number of the process.
-         */
-
-        /*
-         * Tag 'port' can be removed once console management is started
-         * to support new tag ports.
-         */
-
-        if (*online == 1 && port != 0)
-                 ret = xmlTextWriterWriteFormatElement (writer,
-                                                    (xmlChar *)"port",
-                                                        "%d", port);
-         else
-                 ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)"port",
-                                                        "%s", "N/A");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"ports");
-        if (*online == 1 && (port != 0 || rdma_port != 0)) {
-
-                if (port) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%d", port);
-                } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%s", "N/A");
-                }
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                if (rdma_port) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%d", rdma_port);
-                } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%s", "N/A");
-                }
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        if (rdma_port) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma",
+                                                  "%d", rdma_port);
         } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"tcp",
-                                                       "%s", "N/A");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"rdma",
-                                                       "%s", "N/A");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma",
+                                                  "%s", "N/A");
         }
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"tcp", "%s",
+                                              "N/A");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"rdma", "%s",
+                                              "N/A");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.pid", brick_index);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
-                                               "%d", pid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    snprintf(key, sizeof(key), "brick%d.pid", brick_index);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d", pid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_detail (xmlTextWriterPtr writer, dict_t *dict,
-                                  int brick_index)
-{
-        int             ret = -1;
-        uint64_t        size_total = 0;
-        uint64_t        size_free = 0;
-        char            *device = NULL;
-        uint64_t        block_size = 0;
-        char            *mnt_options = NULL;
-        char            *fs_name = NULL;
-        char            *inode_size = NULL;
-        uint64_t        inodes_total = 0;
-        uint64_t        inodes_free = 0;
-        char            key[1024] = {0,};
-
-        snprintf (key, sizeof (key), "brick%d.total", brick_index);
-        ret = dict_get_uint64 (dict, key, &size_total);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"sizeTotal",
-                                                       "%"PRIu64, size_total);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.free", brick_index);
-        ret = dict_get_uint64 (dict, key, &size_free);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"sizeFree",
-                                                       "%"PRIu64, size_free);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.device", brick_index);
-        ret = dict_get_str (dict, key, &device);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"device",
-                                                       "%s", device);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.block_size", brick_index);
-        ret = dict_get_uint64 (dict, key, &block_size);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"blockSize",
-                                                       "%"PRIu64, block_size);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.mnt_options", brick_index);
-        ret = dict_get_str (dict, key, &mnt_options);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"mntOptions",
-                                                       "%s", mnt_options);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.fs_name", brick_index);
-        ret = dict_get_str (dict, key, &fs_name);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"fsName",
-                                                       "%s", fs_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.inode_size", brick_index);
-        ret = dict_get_str (dict, key, &inode_size);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodeSize",
-                                                       "%s", fs_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.total_inodes", brick_index);
-        ret = dict_get_uint64 (dict, key, &inodes_total);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodesTotal",
-                                                       "%"PRIu64, inodes_total);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        snprintf (key, sizeof (key), "brick%d.free_inodes", brick_index);
-        ret = dict_get_uint64 (dict, key, &inodes_free);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"inodesFree",
-                                                       "%"PRIu64, inodes_free);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        } else {
-		ret = 0;
-        }
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
-
-int
-cli_xml_output_vol_status_mempool (xmlTextWriterPtr writer, dict_t *dict,
-                                   char *prefix)
+cli_xml_output_vol_status_detail(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index)
 {
-        int             ret = -1;
-        int             mempool_count = 0;
-        char            *name = NULL;
-        int             hotcount = 0;
-        int             coldcount = 0;
-        uint64_t        paddedsizeof = 0;
-        uint64_t        alloccount = 0;
-        int             maxalloc = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <mempool> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"mempool");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.mempool-count", prefix);
-        ret = dict_get_int32 (dict, key, &mempool_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", mempool_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < mempool_count; i++) {
-                /* <pool> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"pool");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
-                ret = dict_get_str (dict, key, &name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &hotcount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hotCount",
-                                                       "%d", hotcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
-                ret = dict_get_int32 (dict, key, &coldcount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"coldCount",
-                                                       "%d", coldcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
-                          prefix, i);
-                ret = dict_get_uint64 (dict, key, &paddedsizeof);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"padddedSizeOf", "%"PRIu64,
-                         paddedsizeof);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"allocCount",
-                                                       "%"PRIu64, alloccount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"maxAlloc",
-                                                       "%d", maxalloc);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
-                ret = dict_get_uint64 (dict, key, &alloccount);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"poolMisses",
-                                                       "%"PRIu64, alloccount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
-                ret = dict_get_int32 (dict, key, &maxalloc);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"maxStdAlloc",
-                                                       "%d", maxalloc);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-                /* </pool> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        /* </mempool> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t size_total = 0;
+    uint64_t size_free = 0;
+    char *device = NULL;
+    uint64_t block_size = 0;
+    char *mnt_options = NULL;
+    char *fs_name = NULL;
+    char *inode_size = NULL;
+    uint64_t inodes_total = 0;
+    uint64_t inodes_free = 0;
+    char key[1024] = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "brick%d.total", brick_index);
+    ret = dict_get_uint64(dict, key, &size_total);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"sizeTotal",
+                                              "%" PRIu64, size_total);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.free", brick_index);
+    ret = dict_get_uint64(dict, key, &size_free);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"sizeFree",
+                                              "%" PRIu64, size_free);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.device", brick_index);
+    ret = dict_get_str(dict, key, &device);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"device", "%s",
+                                              device);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.block_size", brick_index);
+    ret = dict_get_uint64(dict, key, &block_size);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"blockSize",
+                                              "%" PRIu64, block_size);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.mnt_options", brick_index);
+    ret = dict_get_str(dict, key, &mnt_options);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"mntOptions",
+                                              "%s", mnt_options);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.fs_name", brick_index);
+    ret = dict_get_str(dict, key, &fs_name);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fsName", "%s",
+                                              fs_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.inode_size", brick_index);
+    ret = dict_get_str(dict, key, &inode_size);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodeSize",
+                                              "%s", fs_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.total_inodes", brick_index);
+    ret = dict_get_uint64(dict, key, &inodes_total);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodesTotal",
+                                              "%" PRIu64, inodes_total);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    snprintf(key, sizeof(key), "brick%d.free_inodes", brick_index);
+    ret = dict_get_uint64(dict, key, &inodes_free);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"inodesFree",
+                                              "%" PRIu64, inodes_free);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    } else {
+        ret = 0;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_mem (xmlTextWriterPtr writer, dict_t *dict,
-                               int brick_index)
+cli_xml_output_vol_status_mempool(xmlTextWriterPtr writer, dict_t *dict,
+                                  char *prefix)
 {
-        int             ret = -1;
-        int             arena = 0;
-        int             ordblks = 0;
-        int             smblks = 0;
-        int             hblks = 0;
-        int             hblkhd = 0;
-        int             usmblks = 0;
-        int             fsmblks = 0;
-        int             uordblks = 0;
-        int             fordblks = 0;
-        int             keepcost = 0;
-        char            key[1024] = {0,};
-
-        /* <memStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"memStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <mallinfo> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"mallinfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.mallinfo.arena", brick_index);
-        ret = dict_get_int32 (dict, key, &arena);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"arena",
-                                               "%d", arena);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &ordblks);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ordblks",
-                                               "%d", ordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int mempool_count = 0;
+    char *name = NULL;
+    int hotcount = 0;
+    int coldcount = 0;
+    uint64_t paddedsizeof = 0;
+    uint64_t alloccount = 0;
+    int maxalloc = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <mempool> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"mempool");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.mempool-count", prefix);
+    ret = dict_get_int32(dict, key, &mempool_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          mempool_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < mempool_count; i++) {
+        /* <pool> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"pool");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", brick_index);
-        ret = dict_get_int32 (dict, key, &smblks);
+        snprintf(key, sizeof(key), "%s.pool%d.name", prefix, i);
+        ret = dict_get_str(dict, key, &name);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"smblks",
-                                               "%d", smblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", brick_index);
-        ret = dict_get_int32 (dict, key, &hblks);
+        snprintf(key, sizeof(key), "%s.pool%d.hotcount", prefix, i);
+        ret = dict_get_int32(dict, key, &hotcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblks",
-                                               "%d", hblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hotCount",
+                                              "%d", hotcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", brick_index);
-        ret = dict_get_int32 (dict, key, &hblkhd);
+        snprintf(key, sizeof(key), "%s.pool%d.coldcount", prefix, i);
+        ret = dict_get_int32(dict, key, &coldcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblkhd",
-                                               "%d", hblkhd);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"coldCount",
+                                              "%d", coldcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", brick_index);
-        ret = dict_get_int32 (dict, key, &usmblks);
+        snprintf(key, sizeof(key), "%s.pool%d.paddedsizeof", prefix, i);
+        ret = dict_get_uint64(dict, key, &paddedsizeof);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"usmblks",
-                                               "%d", usmblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"padddedSizeOf", "%" PRIu64, paddedsizeof);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", brick_index);
-        ret = dict_get_int32 (dict, key, &fsmblks);
+        snprintf(key, sizeof(key), "%s.pool%d.alloccount", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fsmblks",
-                                               "%d", fsmblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"allocCount",
+                                              "%" PRIu64, alloccount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &uordblks);
+        snprintf(key, sizeof(key), "%s.pool%d.max_alloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxalloc);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uordblks",
-                                               "%d", uordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxAlloc",
+                                              "%d", maxalloc);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", brick_index);
-        ret = dict_get_int32 (dict, key, &fordblks);
+        snprintf(key, sizeof(key), "%s.pool%d.pool-misses", prefix, i);
+        ret = dict_get_uint64(dict, key, &alloccount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fordblks",
-                                               "%d", fordblks);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"poolMisses",
+                                              "%" PRIu64, alloccount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", brick_index);
-        ret = dict_get_int32 (dict, key, &keepcost);
+        snprintf(key, sizeof(key), "%s.pool%d.max-stdalloc", prefix, i);
+        ret = dict_get_int32(dict, key, &maxalloc);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"keepcost",
-                                               "%d", keepcost);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </mallinfo> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxStdAlloc",
+                                              "%d", maxalloc);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d", brick_index);
-        ret = cli_xml_output_vol_status_mempool (writer, dict, key);
-        if (ret)
-                goto out;
+        /* </pool> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </memStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </mempool> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_clients (xmlTextWriterPtr writer, dict_t *dict,
-                                   int brick_index)
+cli_xml_output_vol_status_mem(xmlTextWriterPtr writer, dict_t *dict,
+                              int brick_index)
 {
-        int             ret = -1;
-        int             client_count = 0;
-        char            *hostname = NULL;
-        uint64_t        bytes_read = 0;
-        uint64_t        bytes_write = 0;
-        uint32_t        opversion = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <clientsStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"clientsStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.clientcount", brick_index);
-        ret = dict_get_int32 (dict, key, &client_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"clientCount",
-                                               "%d", client_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < client_count; i++) {
-                /* <client> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"client");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.client%d.hostname",
-                          brick_index, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hostname",
-                                                       "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.client%d.bytesread",
-                          brick_index, i);
-                ret = dict_get_uint64 (dict, key, &bytes_read);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"bytesRead",
-                                                       "%"PRIu64, bytes_read);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.client%d.byteswrite",
-                          brick_index, i);
-                ret = dict_get_uint64 (dict, key, &bytes_write);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"bytesWrite",
-                                                       "%"PRIu64, bytes_write);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.client%d.opversion",
-                          brick_index, i);
-                ret = dict_get_uint32 (dict, key, &opversion);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"opVersion",
-                                                       "%"PRIu32, opversion);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </client> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    int ret = -1;
+    int arena = 0;
+    int ordblks = 0;
+    int smblks = 0;
+    int hblks = 0;
+    int hblkhd = 0;
+    int usmblks = 0;
+    int fsmblks = 0;
+    int uordblks = 0;
+    int fordblks = 0;
+    int keepcost = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <memStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"memStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <mallinfo> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"mallinfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.arena", brick_index);
+    ret = dict_get_int32(dict, key, &arena);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"arena", "%d",
+                                          arena);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.ordblks", brick_index);
+    ret = dict_get_int32(dict, key, &ordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"ordblks", "%d",
+                                          ordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.smblks", brick_index);
+    ret = dict_get_int32(dict, key, &smblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"smblks", "%d",
+                                          smblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.hblks", brick_index);
+    ret = dict_get_int32(dict, key, &hblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hblks", "%d",
+                                          hblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.hblkhd", brick_index);
+    ret = dict_get_int32(dict, key, &hblkhd);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hblkhd", "%d",
+                                          hblkhd);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.usmblks", brick_index);
+    ret = dict_get_int32(dict, key, &usmblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"usmblks", "%d",
+                                          usmblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.fsmblks", brick_index);
+    ret = dict_get_int32(dict, key, &fsmblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fsmblks", "%d",
+                                          fsmblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.uordblks", brick_index);
+    ret = dict_get_int32(dict, key, &uordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uordblks", "%d",
+                                          uordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.fordblks", brick_index);
+    ret = dict_get_int32(dict, key, &fordblks);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"fordblks", "%d",
+                                          fordblks);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.mallinfo.keepcost", brick_index);
+    ret = dict_get_int32(dict, key, &keepcost);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"keepcost", "%d",
+                                          keepcost);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </mallinfo> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d", brick_index);
+    ret = cli_xml_output_vol_status_mempool(writer, dict, key);
+    if (ret)
+        goto out;
+
+    /* </memStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </clientsStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_inode_entry (xmlTextWriterPtr writer, dict_t *dict,
-                                       char *prefix)
+cli_xml_output_vol_status_clients(xmlTextWriterPtr writer, dict_t *dict,
+                                  int brick_index)
 {
-        int             ret = -1;
-        char            *gfid = NULL;
-        uint64_t        nlookup = 0;
-        uint32_t        ref = 0;
-        int             ia_type = 0;
-        char            key[1024] = {0,};
-
-        /* <inode> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"inode");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_get_str (dict, key, &gfid);
+    int ret = -1;
+    int client_count = 0;
+    char *hostname = NULL;
+    uint64_t bytes_read = 0;
+    uint64_t bytes_write = 0;
+    uint32_t opversion = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <clientsStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"clientsStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.clientcount", brick_index);
+    ret = dict_get_int32(dict, key, &client_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"clientCount",
+                                          "%d", client_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < client_count; i++) {
+        /* <client> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"client");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "brick%d.client%d.hostname", brick_index, i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gfid",
-                                               "%s", gfid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_get_uint64 (dict, key, &nlookup);
+        snprintf(key, sizeof(key), "brick%d.client%d.bytesread", brick_index,
+                 i);
+        ret = dict_get_uint64(dict, key, &bytes_read);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nLookup",
-                                               "%"PRIu64, nlookup);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"bytesRead",
+                                              "%" PRIu64, bytes_read);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_get_uint32 (dict, key, &ref);
+        snprintf(key, sizeof(key), "brick%d.client%d.byteswrite", brick_index,
+                 i);
+        ret = dict_get_uint64(dict, key, &bytes_write);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ref",
-                                               "%"PRIu32, ref);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"bytesWrite",
+                                              "%" PRIu64, bytes_write);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_get_int32 (dict, key, &ia_type);
+        snprintf(key, sizeof(key), "brick%d.client%d.opversion", brick_index,
+                 i);
+        ret = dict_get_uint32(dict, key, &opversion);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"iaType",
-                                               "%d", ia_type);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"opVersion",
+                                              "%" PRIu32, opversion);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </inode> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </client> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
+    /* </clientsStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_itable (xmlTextWriterPtr writer, dict_t *dict,
-                                  char *prefix)
+cli_xml_output_vol_status_inode_entry(xmlTextWriterPtr writer, dict_t *dict,
+                                      char *prefix)
 {
-        int             ret = -1;
-        uint32_t        active_size = 0;
-        uint32_t        lru_size = 0;
-        uint32_t        purge_size = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        snprintf (key, sizeof (key), "%s.active_size", prefix);
-        ret = dict_get_uint32 (dict, key, &active_size);
-        if (ret)
+    int ret = -1;
+    char *gfid = NULL;
+    uint64_t nlookup = 0;
+    uint32_t ref = 0;
+    int ia_type = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <inode> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"inode");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_get_str(dict, key, &gfid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"gfid", "%s",
+                                          gfid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    ret = dict_get_uint64(dict, key, &nlookup);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nLookup",
+                                          "%" PRIu64, nlookup);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_get_uint32(dict, key, &ref);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"ref", "%" PRIu32,
+                                          ref);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_get_int32(dict, key, &ia_type);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"iaType", "%d",
+                                          ia_type);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </inode> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+out:
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
+}
+
+int
+cli_xml_output_vol_status_itable(xmlTextWriterPtr writer, dict_t *dict,
+                                 char *prefix)
+{
+    int ret = -1;
+    uint32_t active_size = 0;
+    uint32_t lru_size = 0;
+    uint32_t purge_size = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    snprintf(key, sizeof(key), "%s.active_size", prefix);
+    ret = dict_get_uint32(dict, key, &active_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"activeSize",
+                                          "%" PRIu32, active_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (active_size != 0) {
+        /* <active> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"active");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        for (i = 0; i < active_size; i++) {
+            snprintf(key, sizeof(key), "%s.active%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"activeSize",
-                                               "%"PRIu32, active_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (active_size != 0) {
-                /* <active> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"active");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < active_size; i++) {
-                        snprintf (key, sizeof (key), "%s.active%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </active> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </active> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    snprintf(key, sizeof(key), "%s.lru_size", prefix);
+    ret = dict_get_uint32(dict, key, &lru_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lruSize",
+                                          "%" PRIu32, lru_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (lru_size != 0) {
+        /* <lru> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"lru");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.lru_size", prefix);
-        ret = dict_get_uint32 (dict, key, &lru_size);
-        if (ret)
+        for (i = 0; i < lru_size; i++) {
+            snprintf(key, sizeof(key), "%s.lru%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"lruSize",
-                                               "%"PRIu32, lru_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (lru_size != 0) {
-                /* <lru> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"lru");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < lru_size; i++) {
-                        snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </lru> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </lru> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    snprintf(key, sizeof(key), "%s.purge_size", prefix);
+    ret = dict_get_uint32(dict, key, &purge_size);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"purgeSize",
+                                          "%" PRIu32, purge_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    if (purge_size != 0) {
+        /* <purge> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"purge");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.purge_size", prefix);
-        ret = dict_get_uint32 (dict, key, &purge_size);
-        if (ret)
+        for (i = 0; i < purge_size; i++) {
+            snprintf(key, sizeof(key), "%s.purge%d", prefix, i);
+            ret = cli_xml_output_vol_status_inode_entry(writer, dict, key);
+            if (ret)
                 goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"purgeSize",
-                                               "%"PRIu32, purge_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        if (purge_size != 0) {
-                /* <purge> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"purge");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (i = 0; i < purge_size; i++) {
-                        snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
-                        ret = cli_xml_output_vol_status_inode_entry
-                                (writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
-                /* </purge> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
         }
+        /* </purge> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_inode (xmlTextWriterPtr writer, dict_t *dict,
-                                 int brick_index)
+cli_xml_output_vol_status_inode(xmlTextWriterPtr writer, dict_t *dict,
+                                int brick_index)
 {
-        int             ret = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <inodeStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"inodeStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <inodeStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"inodeStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.conncount", brick_index);
+    ret = dict_get_int32(dict, key, &conn_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connections",
+                                          "%d", conn_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < conn_count; i++) {
+        /* <connection> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"connection");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
-        ret = dict_get_int32 (dict, key, &conn_count);
+        snprintf(key, sizeof(key), "brick%d.conn%d.itable", brick_index, i);
+        ret = cli_xml_output_vol_status_itable(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
-                                               "%d", conn_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < conn_count; i++) {
-                /* <connection> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"connection");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.conn%d.itable",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_itable (writer, dict, key);
-                if (ret)
-                        goto out;
+            goto out;
 
-                /* </connection> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </connection> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </inodeStatus> */
-        ret= xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </inodeStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_fdtable (xmlTextWriterPtr writer, dict_t *dict,
-                                   char *prefix)
+cli_xml_output_vol_status_fdtable(xmlTextWriterPtr writer, dict_t *dict,
+                                  char *prefix)
 {
-        int             ret = -1;
-        int             refcount = 0;
-        uint32_t        maxfds = 0;
-        int             firstfree = 0;
-        int             openfds = 0;
-        int             fd_pid = 0;
-        int             fd_refcount = 0;
-        int             fd_flags = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <fdTable> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdTable");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &refcount);
+    int ret = -1;
+    int refcount = 0;
+    uint32_t maxfds = 0;
+    int firstfree = 0;
+    int openfds = 0;
+    int fd_pid = 0;
+    int fd_refcount = 0;
+    int fd_flags = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <fdTable> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fdTable");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &refcount);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount", "%d",
+                                          refcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.maxfds", prefix);
+    ret = dict_get_uint32(dict, key, &maxfds);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxFds",
+                                          "%" PRIu32, maxfds);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.firstfree", prefix);
+    ret = dict_get_int32(dict, key, &firstfree);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"firstFree", "%d",
+                                          firstfree);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.openfds", prefix);
+    ret = dict_get_int32(dict, key, &openfds);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"openFds", "%d",
+                                          openfds);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < maxfds; i++) {
+        snprintf(key, sizeof(key), "%s.fdentry%d.pid", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_pid);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
-                                               "%d", refcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        snprintf (key, sizeof (key), "%s.maxfds", prefix);
-        ret = dict_get_uint32 (dict, key, &maxfds);
+        snprintf(key, sizeof(key), "%s.fdentry%d.refcount", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_refcount);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"maxFds",
-                                               "%"PRIu32, maxfds);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        snprintf (key, sizeof (key), "%s.firstfree", prefix);
-        ret = dict_get_int32 (dict, key, &firstfree);
+        snprintf(key, sizeof(key), "%s.fdentry%d.flags", prefix, i);
+        ret = dict_get_int32(dict, key, &fd_flags);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"firstFree",
-                                               "%d", firstfree);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            continue;
 
-        snprintf (key, sizeof (key), "%s.openfds", prefix);
-        ret = dict_get_int32 (dict, key, &openfds);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"openFds",
-                                               "%d", openfds);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <fd> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fd");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < maxfds; i++) {
-                snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_pid);
-                if (ret)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"entry", "%d",
+                                              i + 1);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
-                          prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_refcount);
-                if (ret)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d",
+                                              fd_pid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
-                ret = dict_get_int32 (dict, key, &fd_flags);
-                if (ret)
-                        continue;
-
-                /* <fd> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fd");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"entry",
-                                                       "%d", i+1);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"pid",
-                                                       "%d", fd_pid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"refCount",
-                                                       "%d", fd_refcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"flags",
-                                                       "%d", fd_flags);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </fd> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount",
+                                              "%d", fd_refcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"flags", "%d",
+                                              fd_flags);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        /* </fd> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </fdTable> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </fdTable> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_fd (xmlTextWriterPtr writer, dict_t *dict,
-                              int brick_index)
+cli_xml_output_vol_status_fd(xmlTextWriterPtr writer, dict_t *dict,
+                             int brick_index)
 {
-        int             ret = -1;
-        int             conn_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <fdStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int conn_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <fdStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fdStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.conncount", brick_index);
+    ret = dict_get_int32(dict, key, &conn_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connections",
+                                          "%d", conn_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < conn_count; i++) {
+        /* <connection> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"connection");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
-        ret = dict_get_int32 (dict, key, &conn_count);
+        snprintf(key, sizeof(key), "brick%d.conn%d.fdtable", brick_index, i);
+        ret = cli_xml_output_vol_status_fdtable(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
-                                               "%d", conn_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < conn_count; i++) {
-                /* <connection> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"connection");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_fdtable (writer, dict, key);
-                if (ret)
-                        goto out;
+            goto out;
 
-                /* </connection> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </connection> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </fdStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </fdStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callframe (xmlTextWriterPtr writer, dict_t *dict,
-                                     char *prefix)
+cli_xml_output_vol_status_callframe(xmlTextWriterPtr writer, dict_t *dict,
+                                    char *prefix)
 {
-        int             ret = -1;
-        int             ref_count = 0;
-        char            *translator = NULL;
-        int             complete = 0;
-        char            *parent = NULL;
-        char            *wind_from = NULL;
-        char            *wind_to = NULL;
-        char            *unwind_from = NULL;
-        char            *unwind_to = NULL;
-        char            key[1024] = {0,};
-
-        /* <callFrame> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callFrame");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_get_int32 (dict, key, &ref_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
-                                               "%d", ref_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_get_str (dict, key, &translator);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"translator",
-                                               "%s", translator);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_get_int32 (dict, key, &complete);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"complete",
-                                               "%d", complete);
-        XML_RET_CHECK_AND_GOTO (ret ,out);
-
-        snprintf (key, sizeof (key), "%s.parent", prefix);
-        ret = dict_get_str (dict, key, &parent);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"parent",
-                                                       "%s", parent);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    int ret = -1;
+    int ref_count = 0;
+    char *translator = NULL;
+    int complete = 0;
+    char *parent = NULL;
+    char *wind_from = NULL;
+    char *wind_to = NULL;
+    char *unwind_from = NULL;
+    char *unwind_to = NULL;
+    char key[1024] = {
+        0,
+    };
+
+    /* <callFrame> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callFrame");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_get_int32(dict, key, &ref_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"refCount", "%d",
+                                          ref_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_get_str(dict, key, &translator);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"translator", "%s",
+                                          translator);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_get_int32(dict, key, &complete);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"complete", "%d",
+                                          complete);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.parent", prefix);
+    ret = dict_get_str(dict, key, &parent);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"parent", "%s",
+                                              parent);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        snprintf (key, sizeof (key), "%s.windfrom", prefix);
-        ret = dict_get_str (dict, key, &wind_from);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"windFrom",
-                                                       "%s", wind_from);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.windfrom", prefix);
+    ret = dict_get_str(dict, key, &wind_from);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"windFrom",
+                                              "%s", wind_from);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        snprintf (key, sizeof (key), "%s.windto", prefix);
-        ret = dict_get_str (dict, key, &wind_to);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"windTo",
-                                                       "%s", wind_to);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.windto", prefix);
+    ret = dict_get_str(dict, key, &wind_to);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"windTo", "%s",
+                                              wind_to);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-        ret = dict_get_str (dict, key, &unwind_from);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"unwindFrom",
-                                                       "%s", unwind_from);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+    ret = dict_get_str(dict, key, &unwind_from);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unwindFrom",
+                                              "%s", unwind_from);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        snprintf (key, sizeof (key), "%s.unwindto", prefix);
-        ret = dict_get_str (dict, key, &unwind_to);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"unwindTo",
-                                                       "%s", unwind_to);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    snprintf(key, sizeof(key), "%s.unwindto", prefix);
+    ret = dict_get_str(dict, key, &unwind_to);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unwindTo",
+                                              "%s", unwind_to);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </callFrame> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callFrame> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callstack (xmlTextWriterPtr writer, dict_t *dict,
-                                     char *prefix)
+cli_xml_output_vol_status_callstack(xmlTextWriterPtr writer, dict_t *dict,
+                                    char *prefix)
 {
-        int             ret = -1;
-        int             uid = 0;
-        int             gid = 0;
-        int             pid = 0;
-        uint64_t        unique = 0;
-        int             frame_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <callStack> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callStack");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_get_int32 (dict, key, &uid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uid",
-                                               "%d", uid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_get_int32 (dict, key, &gid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gid",
-                                               "%d", gid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_get_int32 (dict, key, &pid);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
-                                               "%d", pid);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_get_uint64 (dict, key, &unique);
+    int ret = -1;
+    int uid = 0;
+    int gid = 0;
+    int pid = 0;
+    uint64_t unique = 0;
+    int frame_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <callStack> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callStack");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_get_int32(dict, key, &uid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uid", "%d", uid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_get_int32(dict, key, &gid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"gid", "%d", gid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_get_int32(dict, key, &pid);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid", "%d", pid);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_get_uint64(dict, key, &unique);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"unique",
+                                          "%" PRIu64, unique);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &frame_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"frameCount", "%d",
+                                          frame_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < frame_count; i++) {
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        ret = cli_xml_output_vol_status_callframe(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"unique",
-                                               "%"PRIu64, unique);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &frame_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"frameCount",
-                                               "%d", frame_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < frame_count; i++) {
-                snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
-                ret = cli_xml_output_vol_status_callframe (writer, dict,
-                                                           key);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        /* </callStack> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callStack> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_callpool (xmlTextWriterPtr writer, dict_t *dict,
-                                    int brick_index)
+cli_xml_output_vol_status_callpool(xmlTextWriterPtr writer, dict_t *dict,
+                                   int brick_index)
 {
-        int             ret = -1;
-        int             call_count = 0;
-        char            key[1024] = {0,};
-        int             i = 0;
-
-        /* <callpoolStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"callpoolStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "brick%d.callpool.count", brick_index);
-        ret = dict_get_int32 (dict, key, &call_count);
+    int ret = -1;
+    int call_count = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <callpoolStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"callpoolStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "brick%d.callpool.count", brick_index);
+    ret = dict_get_int32(dict, key, &call_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          call_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < call_count; i++) {
+        snprintf(key, sizeof(key), "brick%d.callpool.stack%d", brick_index, i);
+        ret = cli_xml_output_vol_status_callstack(writer, dict, key);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", call_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < call_count; i++) {
-                snprintf (key, sizeof (key), "brick%d.callpool.stack%d",
-                          brick_index, i);
-                ret = cli_xml_output_vol_status_callstack (writer, dict,
-                                                           key);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        /* </callpoolStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </callpoolStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                 char *op_errstr)
+cli_xml_output_vol_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "volStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volumes> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volumes> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volumes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_status_end (cli_local_t *local)
+cli_xml_output_vol_status_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        /* </volumes> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volumes> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </volStatus> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </volStatus> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_remove_brick_task_params (xmlTextWriterPtr writer, dict_t *dict,
-                                         char *prefix)
+cli_xml_output_remove_brick_task_params(xmlTextWriterPtr writer, dict_t *dict,
+                                        char *prefix)
 {
-        int             ret = -1;
-        char            key[1024] = {0,};
-        int             count = 0;
-        int             i = 0;
-        char            *brick = NULL;
-
-        /* <params> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"params");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_get_int32 (dict, key, &count);
+    int ret = -1;
+    char key[1024] = {
+        0,
+    };
+    int count = 0;
+    int i = 0;
+    char *brick = NULL;
+
+    /* <params> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"params");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_get_int32(dict, key, &count);
+    if (ret)
+        goto out;
+
+    for (i = 1; i <= count; i++) {
+        snprintf(key, sizeof(key), "%s.brick%d", prefix, i);
+        ret = dict_get_str(dict, key, &brick);
         if (ret)
-                goto out;
-
-        for (i = 1; i <= count; i++) {
-                snprintf (key, sizeof (key), "%s.brick%d", prefix, i);
-                ret = dict_get_str (dict, key, &brick);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"brick",
-                                                       "%s", brick);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                brick = NULL;
-        }
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brick", "%s",
+                                              brick);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        brick = NULL;
+    }
 
-        /* </param> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </param> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
-        int                     ret = -1;
-        char                    *task_type = NULL;
-        char                    *task_id_str = NULL;
-        int                     status = 0;
-        int                     tasks = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-
-        /* <tasks> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"tasks");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "tasks", &tasks);
-        if (ret)
-                goto out;
+cli_xml_output_vol_status_tasks(cli_local_t *local, dict_t *dict)
+{
+    int ret = -1;
+    char *task_type = NULL;
+    char *task_id_str = NULL;
+    int status = 0;
+    int tasks = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    /* <tasks> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"tasks");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "tasks", &tasks);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < tasks; i++) {
+        /* <task> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"task");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < tasks; i++) {
-                /* <task> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"task");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d.type", i);
+        ret = dict_get_str(dict, key, &task_type);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%s", task_type);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "task%d.type", i);
-                ret = dict_get_str (dict, key, &task_type);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"type",
-                                                       "%s", task_type);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d.id", i);
+        ret = dict_get_str(dict, key, &task_id_str);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "task%d.id", i);
-                ret = dict_get_str (dict, key, &task_id_str);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"status", "%d", status);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "task%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s",
-                                             cli_vol_task_status_str[status]);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "task%d", i);
-                if (!strcmp (task_type, "Remove brick")) {
-                        ret = cli_xml_output_remove_brick_task_params
-                                (local->writer, dict, key);
-                        if (ret)
-                                goto out;
-                }
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"statusStr", "%s",
+                                              cli_vol_task_status_str[status]);
 
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </task> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "task%d", i);
+        if (!strcmp(task_type, "Remove brick")) {
+            ret = cli_xml_output_remove_brick_task_params(local->writer, dict,
+                                                          key);
+            if (ret)
+                goto out;
         }
 
-        /* </tasks> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </task> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </tasks> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 #endif
 
 int
-cli_xml_output_vol_status_tasks_detail (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_status_tasks_detail(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int    ret     = -1;
-        char  *volname = NULL;
+    int ret = -1;
+    char *volname = NULL;
 
-        /*<volume>*/
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /*<volume>*/
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"volName", "%s",
-                                               volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"volName",
+                                          "%s", volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_vol_status_tasks (local, dict);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_vol_status_tasks(local, dict);
+    if (ret)
+        goto out;
 
-        /* </volume> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volume> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_status (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_status(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        char                    *volname = NULL;
-        int                     brick_count = 0;
-        int                     brick_index_max = -1;
-        int                     other_count = 0;
-        int                     index_max = 0;
-        uint32_t                cmd = GF_CLI_STATUS_NONE;
-        int                     online = 0;
-        gf_boolean_t            node_present = _gf_true;
-        int                     i;
-        int                     type            = -1;
-        int                     hot_brick_count = -1;
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"volName", "%s",
-                                               volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &brick_count);
+    int ret = -1;
+    char *volname = NULL;
+    int brick_count = 0;
+    int brick_index_max = -1;
+    int other_count = 0;
+    int index_max = 0;
+    uint32_t cmd = GF_CLI_STATUS_NONE;
+    int online = 0;
+    gf_boolean_t node_present = _gf_true;
+    int i;
+    int type = -1;
+    int hot_brick_count = -1;
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"volName",
+                                          "%s", volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"nodeCount",
+                                          "%d", brick_count);
+
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret)
+        goto out;
+
+    ret = dict_get_int32(dict, "brick-index-max", &brick_index_max);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(dict, "other-count", &other_count);
+    if (ret)
+        goto out;
+
+    index_max = brick_index_max + other_count;
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret)
+        goto out;
+
+    if (type == GF_CLUSTER_TYPE_TIER) {
+        ret = dict_get_int32(dict, "hot_brick_count", &hot_brick_count);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"nodeCount", "%d",
-                                               brick_count);
-
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
 
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret)
-                goto out;
-
-        ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (dict, "other-count", &other_count);
-        if (ret)
-                goto out;
-
-        index_max = brick_index_max + other_count;
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret)
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"hotBricks");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    for (i = 0; i <= index_max; i++) {
+        if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
+            /* </hotBricks>*/
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            ret = xmlTextWriterStartElement(local->writer,
+                                            (xmlChar *)"coldBricks");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
+        ret = cli_xml_output_vol_status_common(local->writer, dict, i, &online,
+                                               &node_present);
+        if (ret) {
+            if (node_present)
                 goto out;
-
-        if (type == GF_CLUSTER_TYPE_TIER) {
-                ret = dict_get_int32 (dict, "hot_brick_count",
-                                      &hot_brick_count);
-                if (ret)
-                        goto out;
-
-                ret = xmlTextWriterStartElement
-                        (local->writer, (xmlChar *)"hotBricks");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
+            else
+                continue;
         }
-        for (i = 0; i <= index_max; i++) {
 
-                if (type == GF_CLUSTER_TYPE_TIER && i == hot_brick_count) {
+        switch (cmd & GF_CLI_STATUS_MASK) {
+            case GF_CLI_STATUS_DETAIL:
+                ret = cli_xml_output_vol_status_detail(local->writer, dict, i);
+                if (ret)
+                    goto out;
+                break;
 
-                        /* </hotBricks>*/
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        ret = xmlTextWriterStartElement (local->writer,
-                                        (xmlChar *)"coldBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
-                ret = cli_xml_output_vol_status_common (local->writer, dict, i,
-                                                        &online, &node_present);
-                if (ret) {
-                        if (node_present)
-                                goto out;
-                        else
-                                continue;
+            case GF_CLI_STATUS_MEM:
+                if (online) {
+                    ret = cli_xml_output_vol_status_mem(local->writer, dict, i);
+                    if (ret)
+                        goto out;
                 }
+                break;
 
-                switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_DETAIL:
-                        ret = cli_xml_output_vol_status_detail (local->writer,
-                                                                dict, i);
-                        if (ret)
-                                goto out;
-                        break;
-
-                case GF_CLI_STATUS_MEM:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_mem
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_clients
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_inode
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_fd
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        if (online) {
-                                ret = cli_xml_output_vol_status_callpool
-                                        (local->writer, dict, i);
-                                if (ret)
-                                        goto out;
-                        }
-                        break;
-                default:
-                        break;
+            case GF_CLI_STATUS_CLIENTS:
+                if (online) {
+                    ret = cli_xml_output_vol_status_clients(local->writer, dict,
+                                                            i);
+                    if (ret)
+                        goto out;
+                }
+                break;
 
+            case GF_CLI_STATUS_INODE:
+                if (online) {
+                    ret = cli_xml_output_vol_status_inode(local->writer, dict,
+                                                          i);
+                    if (ret)
+                        goto out;
                 }
+                break;
 
-                /* </node>  was opened in cli_xml_output_vol_status_common()*/
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            case GF_CLI_STATUS_FD:
+                if (online) {
+                    ret = cli_xml_output_vol_status_fd(local->writer, dict, i);
+                    if (ret)
+                        goto out;
+                }
+                break;
 
-                /* </coldBricks>*/
-                if (type == GF_CLUSTER_TYPE_TIER && i == brick_index_max) {
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+            case GF_CLI_STATUS_CALLPOOL:
+                if (online) {
+                    ret = cli_xml_output_vol_status_callpool(local->writer,
+                                                             dict, i);
+                    if (ret)
+                        goto out;
                 }
+                break;
+            default:
+                break;
         }
 
-        /* Tasks are only present when a normal volume status call is done on a
-         * single volume or on all volumes
-         */
-        if (((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE) &&
-            (cmd & (GF_CLI_STATUS_VOL|GF_CLI_STATUS_ALL))) {
-                ret = cli_xml_output_vol_status_tasks (local, dict);
-                if (ret)
-                        goto out;
+        /* </node>  was opened in cli_xml_output_vol_status_common()*/
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        /* </coldBricks>*/
+        if (type == GF_CLUSTER_TYPE_TIER && i == brick_index_max) {
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
         }
+    }
 
-        /* </volume> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* Tasks are only present when a normal volume status call is done on a
+     * single volume or on all volumes
+     */
+    if (((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE) &&
+        (cmd & (GF_CLI_STATUS_VOL | GF_CLI_STATUS_ALL))) {
+        ret = cli_xml_output_vol_status_tasks(local, dict);
+        if (ret)
+            goto out;
+    }
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_top_rw_perf (xmlTextWriterPtr writer, dict_t *dict,
-                                int brick_index, int member_index)
+cli_xml_output_vol_top_rw_perf(xmlTextWriterPtr writer, dict_t *dict,
+                               int brick_index, int member_index)
 {
-        int        ret = -1;
-        char      *filename = NULL;
-        uint64_t   throughput = 0;
-        long int   time_sec = 0;
-        long int   time_usec = 0;
-        char       timestr[256] = {0,};
-        char       key[1024] = {0,};
-        int        len;
-
-        /* <file> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
-                  member_index);
-        ret = dict_get_str (dict, key, &filename);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
-                                               "%s", filename);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
-        ret = dict_get_uint64 (dict, key, &throughput);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%"PRIu64, throughput);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-time-sec-%d", brick_index,
-                  member_index);
-        ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%d-time-usec-%d", brick_index,
-                  member_index);
-        ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
-        if (ret)
-                goto out;
-
-        gf_time_fmt (timestr, sizeof timestr, time_sec, gf_timefmt_FT);
-        len = strlen (timestr);
-        snprintf (timestr + len,
-                  sizeof (timestr) - len,
-                  ".%"GF_PRI_SUSECONDS, time_usec);
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"time",
-                                               "%s", timestr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </file> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *filename = NULL;
+    uint64_t throughput = 0;
+    long int time_sec = 0;
+    long int time_usec = 0;
+    char timestr[256] = {
+        0,
+    };
+    char key[1024] = {
+        0,
+    };
+    int len;
+
+    /* <file> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-filename-%d", brick_index, member_index);
+    ret = dict_get_str(dict, key, &filename);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"filename", "%s",
+                                          filename);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-value-%d", brick_index, member_index);
+    ret = dict_get_uint64(dict, key, &throughput);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count",
+                                          "%" PRIu64, throughput);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-time-sec-%d", brick_index, member_index);
+    ret = dict_get_int32(dict, key, (int32_t *)&time_sec);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%d-time-usec-%d", brick_index, member_index);
+    ret = dict_get_int32(dict, key, (int32_t *)&time_usec);
+    if (ret)
+        goto out;
+
+    gf_time_fmt(timestr, sizeof timestr, time_sec, gf_timefmt_FT);
+    len = strlen(timestr);
+    snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SUSECONDS,
+             time_usec);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"time", "%s",
+                                          timestr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </file> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_top_other (xmlTextWriterPtr writer, dict_t *dict,
-                                int brick_index, int member_index)
+cli_xml_output_vol_top_other(xmlTextWriterPtr writer, dict_t *dict,
+                             int brick_index, int member_index)
 {
-        int             ret = -1;
-        char            *filename = NULL;
-        uint64_t        count = 0;
-        char            key[1024] = {0,};
-
-        /* <file> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
-                  member_index);
-        ret = dict_get_str (dict, key, &filename);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
-                                               "%s", filename);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
-        ret = dict_get_uint64 (dict, key, &count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%"PRIu64, count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </file> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *filename = NULL;
+    uint64_t count = 0;
+    char key[1024] = {
+        0,
+    };
+
+    /* <file> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-filename-%d", brick_index, member_index);
+    ret = dict_get_str(dict, key, &filename);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"filename", "%s",
+                                          filename);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-value-%d", brick_index, member_index);
+    ret = dict_get_uint64(dict, key, &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count",
+                                          "%" PRIu64, count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </file> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_top (dict_t *dict, int op_ret, int op_errno,
-                        char *op_errstr)
+cli_xml_output_vol_top(dict_t *dict, int op_ret, int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     brick_count = 0;
-        int                     top_op = GF_CLI_TOP_NONE;
-        char                    *brick_name = NULL;
-        int                     members = 0;
-        uint64_t                current_open = 0;
-        uint64_t                max_open = 0;
-        char                    *max_open_time = NULL;
-        double                  throughput = 0.0;
-        double                  time_taken = 0.0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     j = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <volTop> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volTop");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int brick_count = 0;
+    int top_op = GF_CLI_TOP_NONE;
+    char *brick_name = NULL;
+    int members = 0;
+    uint64_t current_open = 0;
+    uint64_t max_open = 0;
+    char *max_open_time = NULL;
+    double throughput = 0.0;
+    double time_taken = 0.0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volTop> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volTop");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brick_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "1-top-op", &top_op);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"topOp", "%d",
+                                          top_op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    while (i < brick_count) {
+        i++;
+
+        /* <brick> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
+        snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_str(dict, key, &brick_name);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
-                                               "%d", brick_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              brick_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "1-top-op", &top_op);
+        snprintf(key, sizeof(key), "%d-members", i);
+        ret = dict_get_int32(dict, key, &members);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"topOp",
-                                               "%d", top_op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        while (i < brick_count) {
-                i++;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"members",
+                                              "%d", members);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <brick> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        switch (top_op) {
+            case GF_CLI_TOP_OPEN:
+                snprintf(key, sizeof(key), "%d-current-open", i);
+                ret = dict_get_uint64(dict, key, &current_open);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"currentOpen", "%" PRIu64, current_open);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick_name);
+                snprintf(key, sizeof(key), "%d-max-open", i);
+                ret = dict_get_uint64(dict, key, &max_open);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", brick_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"maxOpen", "%" PRIu64, max_open);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key , sizeof (key), "%d-members", i);
-                ret = dict_get_int32 (dict, key, &members);
+                snprintf(key, sizeof(key), "%d-max-openfd-time", i);
+                ret = dict_get_str(dict, key, &max_open_time);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"members",
-                                                       "%d", members);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                switch (top_op) {
-                case GF_CLI_TOP_OPEN:
-                        snprintf (key, sizeof (key), "%d-current-open", i);
-                        ret = dict_get_uint64 (dict, key, &current_open);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"currentOpen", "%"PRIu64,
-                                 current_open);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        snprintf (key, sizeof (key), "%d-max-open", i);
-                        ret = dict_get_uint64 (dict, key, &max_open);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"maxOpen", "%"PRIu64,
-                                 max_open);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        snprintf (key, sizeof (key), "%d-max-openfd-time", i);
-                        ret = dict_get_str (dict, key, &max_open_time);
-                        if (ret)
-                                goto out;
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"maxOpenTime", "%s",
-                                 max_open_time);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                case GF_CLI_TOP_READ:
-                case GF_CLI_TOP_WRITE:
-                case GF_CLI_TOP_OPENDIR:
-                case GF_CLI_TOP_READDIR:
-
-                        break;
-
-                case GF_CLI_TOP_READ_PERF:
-                case GF_CLI_TOP_WRITE_PERF:
-                        snprintf (key, sizeof (key), "%d-throughput", i);
-                        ret = dict_get_double (dict, key, &throughput);
-                        if (!ret) {
-                                snprintf (key, sizeof (key), "%d-time", i);
-                                ret = dict_get_double (dict, key, &time_taken);
-                        }
-
-                        if (!ret) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (writer, (xmlChar *)"throughput",
-                                         "%f", throughput);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (writer, (xmlChar *)"timeTaken",
-                                         "%f", time_taken);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-
-                        break;
-
-                default:
-                        ret = -1;
-                        goto out;
+                    goto out;
+                ret = xmlTextWriterWriteFormatElement(
+                    writer, (xmlChar *)"maxOpenTime", "%s", max_open_time);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+            case GF_CLI_TOP_READ:
+            case GF_CLI_TOP_WRITE:
+            case GF_CLI_TOP_OPENDIR:
+            case GF_CLI_TOP_READDIR:
+
+                break;
+
+            case GF_CLI_TOP_READ_PERF:
+            case GF_CLI_TOP_WRITE_PERF:
+                snprintf(key, sizeof(key), "%d-throughput", i);
+                ret = dict_get_double(dict, key, &throughput);
+                if (!ret) {
+                    snprintf(key, sizeof(key), "%d-time", i);
+                    ret = dict_get_double(dict, key, &time_taken);
                 }
 
-                for (j = 1; j <= members; j++) {
-                        if (top_op == GF_CLI_TOP_READ_PERF ||
-                            top_op == GF_CLI_TOP_WRITE_PERF) {
-                                ret = cli_xml_output_vol_top_rw_perf
-                                        (writer, dict, i, j);
-                        } else {
-                                ret = cli_xml_output_vol_top_other
-                                        (writer, dict, i, j);
-                        }
-                        if (ret)
-                                goto out;
+                if (!ret) {
+                    ret = xmlTextWriterWriteFormatElement(
+                        writer, (xmlChar *)"throughput", "%f", throughput);
+                    XML_RET_CHECK_AND_GOTO(ret, out);
+
+                    ret = xmlTextWriterWriteFormatElement(
+                        writer, (xmlChar *)"timeTaken", "%f", time_taken);
+                    XML_RET_CHECK_AND_GOTO(ret, out);
                 }
 
+                break;
 
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            default:
+                ret = -1;
+                goto out;
         }
 
-        /* </volTop> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        ret = cli_end_xml_output (writer, doc);
+        for (j = 1; j <= members; j++) {
+            if (top_op == GF_CLI_TOP_READ_PERF ||
+                top_op == GF_CLI_TOP_WRITE_PERF) {
+                ret = cli_xml_output_vol_top_rw_perf(writer, dict, i, j);
+            } else {
+                ret = cli_xml_output_vol_top_other(writer, dict, i, j);
+            }
+            if (ret)
+                goto out;
+        }
+
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </volTop> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_profile_stats (xmlTextWriterPtr writer, dict_t *dict,
-                                  int brick_index, int interval)
+cli_xml_output_vol_profile_stats(xmlTextWriterPtr writer, dict_t *dict,
+                                 int brick_index, int interval)
 {
-        int                     ret = -1;
-        uint64_t                read_count = 0;
-        uint64_t                write_count = 0;
-        uint64_t                hits = 0;
-        double                  avg_latency = 0.0;
-        double                  max_latency = 0.0;
-        double                  min_latency = 0.0;
-        uint64_t                duration = 0;
-        uint64_t                total_read = 0;
-        uint64_t                total_write = 0;
-        char                    key[1024] = {0};
-        int                     i = 0;
-
-        /* <cumulativeStats> || <intervalStats> */
-        if (interval == -1)
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"cumulativeStats");
-        else
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"intervalStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <blockStats> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"blockStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < 32; i++) {
-                /* <block> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"block");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"size", "%"PRIu32, (1 << i));
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%d-%d-read-%d", brick_index,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &read_count);
-                if (ret)
-                        read_count = 0;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"reads", "%"PRIu64, read_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%d-%d-write-%d", brick_index,
-                          interval, (1 << i));
-                ret = dict_get_uint64 (dict, key, &write_count);
-                if (ret)
-                        write_count = 0;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"writes", "%"PRIu64, write_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </block> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        /* </blockStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <fopStats> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"fopStats");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                snprintf (key, sizeof (key), "%d-%d-%d-hits", brick_index,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &hits);
-                if (ret)
-                        goto cont;
+    int ret = -1;
+    uint64_t read_count = 0;
+    uint64_t write_count = 0;
+    uint64_t hits = 0;
+    double avg_latency = 0.0;
+    double max_latency = 0.0;
+    double min_latency = 0.0;
+    uint64_t duration = 0;
+    uint64_t total_read = 0;
+    uint64_t total_write = 0;
+    char key[1024] = {0};
+    int i = 0;
+
+    /* <cumulativeStats> || <intervalStats> */
+    if (interval == -1)
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"cumulativeStats");
+    else
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"intervalStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <blockStats> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"blockStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < 32; i++) {
+        /* <block> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"block");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%d-%d-%d-avglatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &avg_latency);
-                if (ret)
-                        goto cont;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size",
+                                              "%" PRIu32, (1 << i));
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%d-%d-%d-minlatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &min_latency);
-                if (ret)
-                        goto cont;
+        snprintf(key, sizeof(key), "%d-%d-read-%d", brick_index, interval,
+                 (1 << i));
+        ret = dict_get_uint64(dict, key, &read_count);
+        if (ret)
+            read_count = 0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"reads",
+                                              "%" PRIu64, read_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", brick_index,
-                          interval, i);
-                ret = dict_get_double (dict, key, &max_latency);
-                if (ret)
-                        goto cont;
+        snprintf(key, sizeof(key), "%d-%d-write-%d", brick_index, interval,
+                 (1 << i));
+        ret = dict_get_uint64(dict, key, &write_count);
+        if (ret)
+            write_count = 0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"writes",
+                                              "%" PRIu64, write_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <fop> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fop");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </block> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"name","%s", gf_fop_list[i]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </blockStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hits", "%"PRIu64, hits);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <fopStats> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"fopStats");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"avgLatency", "%f", avg_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        snprintf(key, sizeof(key), "%d-%d-%d-hits", brick_index, interval, i);
+        ret = dict_get_uint64(dict, key, &hits);
+        if (ret)
+            goto cont;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"minLatency", "%f", min_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-avglatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &avg_latency);
+        if (ret)
+            goto cont;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"maxLatency", "%f", max_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-minlatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &min_latency);
+        if (ret)
+            goto cont;
 
-                /* </fop> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%d-%d-%d-maxlatency", brick_index, interval,
+                 i);
+        ret = dict_get_double(dict, key, &max_latency);
+        if (ret)
+            goto cont;
 
-cont:
-                hits = 0;
-                avg_latency = 0.0;
-                min_latency = 0.0;
-                max_latency = 0.0;
-        }
+        /* <fop> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fop");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                hits = 0;
-                avg_latency = 0.0;
-                min_latency = 0.0;
-                max_latency = 0.0;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              gf_fop_list[i]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "%d-%d-%d-upcall-hits", brick_index,
-                          interval, i);
-                ret = dict_get_uint64 (dict, key, &hits);
-                if (ret)
-                        continue;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hits",
+                                              "%" PRIu64, hits);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <fop> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"fop");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"avgLatency",
+                                              "%f", avg_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"name", "%s", gf_fop_list[i]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"minLatency",
+                                              "%f", min_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hits", "%"PRIu64, hits);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxLatency",
+                                              "%f", max_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"avgLatency", "%f", avg_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </fop> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"minLatency", "%f", min_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    cont:
+        hits = 0;
+        avg_latency = 0.0;
+        min_latency = 0.0;
+        max_latency = 0.0;
+    }
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        hits = 0;
+        avg_latency = 0.0;
+        min_latency = 0.0;
+        max_latency = 0.0;
+
+        snprintf(key, sizeof(key), "%d-%d-%d-upcall-hits", brick_index,
+                 interval, i);
+        ret = dict_get_uint64(dict, key, &hits);
+        if (ret)
+            continue;
 
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"maxLatency", "%f", max_latency);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <fop> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"fop");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </fop> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              gf_fop_list[i]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </fopStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hits",
+                                              "%" PRIu64, hits);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%d-%d-duration", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &duration);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"duration",
-                                               "%"PRIu64, duration);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"avgLatency",
+                                              "%f", avg_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%d-%d-total-read", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &total_read);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalRead",
-                                               "%"PRIu64, total_read);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"minLatency",
+                                              "%f", min_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%d-%d-total-write", brick_index, interval);
-        ret = dict_get_uint64 (dict, key, &total_write);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalWrite",
-                                               "%"PRIu64, total_write);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"maxLatency",
+                                              "%f", max_latency);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </cumulativeStats> || </intervalStats> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </fop> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* </fopStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-duration", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &duration);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"duration",
+                                          "%" PRIu64, duration);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-total-read", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &total_read);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"totalRead",
+                                          "%" PRIu64, total_read);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%d-%d-total-write", brick_index, interval);
+    ret = dict_get_uint64(dict, key, &total_write);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"totalWrite",
+                                          "%" PRIu64, total_write);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </cumulativeStats> || </intervalStats> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_profile (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_vol_profile(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        int                     op = GF_CLI_STATS_NONE;
-        int                     info_op = GF_CLI_INFO_NONE;
-        int                     brick_count = 0;
-        char                    *brick_name = NULL;
-        int                     interval = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     stats_cleared = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <volProfile> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volProfile");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"volname",
-                                               "%s", volname);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "op", &op);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"profileOp",
-                                               "%d", op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (GF_CLI_STATS_INFO != op)
-                goto cont;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    int op = GF_CLI_STATS_NONE;
+    int info_op = GF_CLI_INFO_NONE;
+    int brick_count = 0;
+    char *brick_name = NULL;
+    int interval = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int stats_cleared = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volProfile> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volProfile");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volname", "%s",
+                                          volname);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "op", &op);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"profileOp", "%d",
+                                          op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    if (GF_CLI_STATS_INFO != op)
+        goto cont;
+
+    ret = dict_get_int32(dict, "count", &brick_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brick_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "info-op", &info_op);
+    if (ret)
+        goto out;
+
+    while (i < brick_count) {
+        i++;
+
+        /* <brick> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &brick_count);
+        snprintf(key, sizeof(key), "%d-brick", i);
+        ret = dict_get_str(dict, key, &brick_name);
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
-                                               "%d", brick_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickName",
+                                              "%s", brick_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "info-op", &info_op);
-        if (ret)
+        if (GF_CLI_INFO_CLEAR == info_op) {
+            snprintf(key, sizeof(key), "%d-stats-cleared", i);
+            ret = dict_get_int32(dict, key, &stats_cleared);
+            if (ret)
                 goto out;
 
-        while (i < brick_count) {
-                i++;
-
-                /* <brick> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%d-brick", i);
-                ret = dict_get_str (dict, key, &brick_name);
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"clearStats", "%s",
+                stats_cleared ? "Cleared stats." : "Failed to clear stats.");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        } else {
+            snprintf(key, sizeof(key), "%d-cumulative", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0) {
+                ret = cli_xml_output_vol_profile_stats(writer, dict, i,
+                                                       interval);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"brickName", "%s", brick_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                if (GF_CLI_INFO_CLEAR == info_op) {
-                        snprintf (key, sizeof (key), "%d-stats-cleared", i);
-                        ret = dict_get_int32 (dict, key, &stats_cleared);
-                        if (ret)
-                                goto out;
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"clearStats", "%s",
-                                stats_cleared ? "Cleared stats." :
-                                                 "Failed to clear stats.");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                } else {
-                        snprintf (key, sizeof (key), "%d-cumulative", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0) {
-                                ret = cli_xml_output_vol_profile_stats
-                                        (writer, dict, i, interval);
-                                if (ret)
-                                        goto out;
-                        }
-
-                        snprintf (key, sizeof (key), "%d-interval", i);
-                        ret = dict_get_int32 (dict, key, &interval);
-                        if (ret == 0) {
-                                ret = cli_xml_output_vol_profile_stats
-                                        (writer, dict, i, interval);
-                                if (ret)
-                                        goto out;
-                        }
-                }
-
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+            }
+
+            snprintf(key, sizeof(key), "%d-interval", i);
+            ret = dict_get_int32(dict, key, &interval);
+            if (ret == 0) {
+                ret = cli_xml_output_vol_profile_stats(writer, dict, i,
+                                                       interval);
+                if (ret)
+                    goto out;
+            }
         }
 
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
 cont:
-        /* </volProfile> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volProfile> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_list (dict_t *dict, int op_ret, int op_errno,
-                         char *op_errstr)
+cli_xml_output_vol_list(dict_t *dict, int op_ret, int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     count = 0;
-        char                    *volname = NULL;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int count = 0;
+    char *volname = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volList> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volList");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < count; i++) {
+        snprintf(key, sizeof(key), "volume%d", i);
+        ret = dict_get_str(dict, key, &volname);
         if (ret)
-                goto out;
-
-        /* <volList> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volList");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < count; i++) {
-                snprintf (key, sizeof (key), "volume%d", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"volume",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volume", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </volList> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volList> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_info_option (xmlTextWriterPtr writer, char *substr,
-                                char *optstr, char *valstr)
+cli_xml_output_vol_info_option(xmlTextWriterPtr writer, char *substr,
+                               char *optstr, char *valstr)
 {
-        int             ret = -1;
-        char            *ptr1 = NULL;
-        char            *ptr2 = NULL;
-
-        ptr1 = substr;
-        ptr2 = optstr;
-
-        while (ptr1) {
-                if (*ptr1 != *ptr2)
-                        break;
-                ptr1++;
-                ptr2++;
-                if (!*ptr1)
-                        break;
-                if (!*ptr2)
-                        break;
-        }
-        if (*ptr2 == '\0')
-                goto out;
-
-        /* <option> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"option");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"name",
-                                               "%s", ptr2);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"value",
-                                               "%s", valstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </option> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    char *ptr1 = NULL;
+    char *ptr2 = NULL;
+
+    ptr1 = substr;
+    ptr2 = optstr;
+
+    while (ptr1) {
+        if (*ptr1 != *ptr2)
+            break;
+        ptr1++;
+        ptr2++;
+        if (!*ptr1)
+            break;
+        if (!*ptr2)
+            break;
+    }
+    if (*ptr2 == '\0')
+        goto out;
+
+    /* <option> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"option");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          ptr2);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"value", "%s",
+                                          valstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </option> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 struct tmp_xml_option_logger {
-        char *key;
-        xmlTextWriterPtr writer;
+    char *key;
+    xmlTextWriterPtr writer;
 };
 
 static int
-_output_vol_info_option (dict_t *d, char *k, data_t *v,
-                         void *data)
+_output_vol_info_option(dict_t *d, char *k, data_t *v, void *data)
 {
-        int                           ret   = 0;
-        char                         *ptr   = NULL;
-        struct tmp_xml_option_logger *tmp   = NULL;
+    int ret = 0;
+    char *ptr = NULL;
+    struct tmp_xml_option_logger *tmp = NULL;
 
-        tmp = data;
+    tmp = data;
 
-        ptr = strstr (k, "option.");
-        if (!ptr)
-                goto out;
+    ptr = strstr(k, "option.");
+    if (!ptr)
+        goto out;
 
-        if (!v) {
-                ret = -1;
-                goto out;
-        }
-        ret = cli_xml_output_vol_info_option (tmp->writer, tmp->key, k,
-                                              v->data);
+    if (!v) {
+        ret = -1;
+        goto out;
+    }
+    ret = cli_xml_output_vol_info_option(tmp->writer, tmp->key, k, v->data);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_output_vol_info_options (xmlTextWriterPtr writer, dict_t *dict,
-                                 char *prefix)
+cli_xml_output_vol_info_options(xmlTextWriterPtr writer, dict_t *dict,
+                                char *prefix)
 {
-        int             ret = -1;
-        int             opt_count = 0;
-        char            key[1024] = {0,};
-        struct tmp_xml_option_logger tmp = {0,};
-
-        snprintf (key, sizeof (key), "%s.opt_count", prefix);
-        ret = dict_get_int32 (dict, key, &opt_count);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"optCount",
-                                               "%d", opt_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <options> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"options");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        snprintf (key, sizeof (key), "%s.option.", prefix);
-
-        tmp.key = key;
-        tmp.writer = writer;
-        ret = dict_foreach (dict, _output_vol_info_option, &tmp);
-        if (ret)
-                goto out;
-
-        /* </options> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int opt_count = 0;
+    char key[1024] = {
+        0,
+    };
+    struct tmp_xml_option_logger tmp = {
+        0,
+    };
+
+    snprintf(key, sizeof(key), "%s.opt_count", prefix);
+    ret = dict_get_int32(dict, key, &opt_count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"optCount", "%d",
+                                          opt_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <options> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"options");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    snprintf(key, sizeof(key), "%s.option.", prefix);
+
+    tmp.key = key;
+    tmp.writer = writer;
+    ret = dict_foreach(dict, _output_vol_info_option, &tmp);
+    if (ret)
+        goto out;
+
+    /* </options> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_info (cli_local_t *local, dict_t *dict)
+cli_xml_output_vol_info(cli_local_t *local, dict_t *dict)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = 0;
-        int                     count = 0;
-        char                    *volname = NULL;
-        char                    *volume_id = NULL;
-        char                    *uuid = NULL;
-        int                     type = 0;
-        int                     status = 0;
-        int                     brick_count = 0;
-        int                     dist_count = 0;
-        int                     stripe_count = 0;
-        int                     replica_count = 0;
-        int                     arbiter_count = 0;
-        int                     snap_count    = 0;
-        int                     isArbiter = 0;
-        int                     disperse_count = 0;
-        int                     redundancy_count = 0;
-        int                     transport = 0;
-        char                    *brick = NULL;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     j = 1;
-        char                    *caps __attribute__((unused)) = NULL;
-        int                     k __attribute__((unused)) = 0;
-        int                     index = 1;
-        int                     tier_vol_type          = 0;
-        /* hot dist count is always zero so need for it to be
-         * included in the array.*/
-        int                     hot_dist_count         = 0;
-        values                  c                      = 0;
-        char                    *keys[MAX]              = {
-                [COLD_BRICK_COUNT]      = "volume%d.cold_brick_count",
-                [COLD_TYPE]             = "volume%d.cold_type",
-                [COLD_DIST_COUNT]       = "volume%d.cold_dist_count",
-                [COLD_REPLICA_COUNT]    = "volume%d.cold_replica_count",
-                [COLD_ARBITER_COUNT]    = "volume%d.cold_arbiter_count",
-                [COLD_DISPERSE_COUNT]   = "volume%d.cold_disperse_count",
-                [COLD_REDUNDANCY_COUNT] = "volume%d.cold_redundancy_count",
-                [HOT_BRICK_COUNT]       = "volume%d.hot_brick_count",
-                [HOT_TYPE]              = "volume%d.hot_type",
-                [HOT_REPLICA_COUNT]     = "volume%d.hot_replica_count"};
-        int                     value[MAX]             = {};
-
-
-        ret = dict_get_int32 (dict, "count", &count);
+    int ret = 0;
+    int count = 0;
+    char *volname = NULL;
+    char *volume_id = NULL;
+    char *uuid = NULL;
+    int type = 0;
+    int status = 0;
+    int brick_count = 0;
+    int dist_count = 0;
+    int stripe_count = 0;
+    int replica_count = 0;
+    int arbiter_count = 0;
+    int snap_count = 0;
+    int isArbiter = 0;
+    int disperse_count = 0;
+    int redundancy_count = 0;
+    int transport = 0;
+    char *brick = NULL;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int j = 1;
+    char *caps __attribute__((unused)) = NULL;
+    int k __attribute__((unused)) = 0;
+    int index = 1;
+    int tier_vol_type = 0;
+    /* hot dist count is always zero so need for it to be
+     * included in the array.*/
+    int hot_dist_count = 0;
+    values c = 0;
+    char *keys[MAX] = {
+        [COLD_BRICK_COUNT] = "volume%d.cold_brick_count",
+        [COLD_TYPE] = "volume%d.cold_type",
+        [COLD_DIST_COUNT] = "volume%d.cold_dist_count",
+        [COLD_REPLICA_COUNT] = "volume%d.cold_replica_count",
+        [COLD_ARBITER_COUNT] = "volume%d.cold_arbiter_count",
+        [COLD_DISPERSE_COUNT] = "volume%d.cold_disperse_count",
+        [COLD_REDUNDANCY_COUNT] = "volume%d.cold_redundancy_count",
+        [HOT_BRICK_COUNT] = "volume%d.hot_brick_count",
+        [HOT_TYPE] = "volume%d.hot_type",
+        [HOT_REPLICA_COUNT] = "volume%d.hot_replica_count"};
+    int value[MAX] = {};
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+
+    for (i = 0; i < count; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.name", i);
+        ret = dict_get_str(dict, key, &volname);
         if (ret)
-                goto out;
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"name",
+                                              "%s", volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 0; i < count; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.volume_id", i);
+        ret = dict_get_str(dict, key, &volume_id);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"id",
+                                              "%s", volume_id);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.name", i);
-                ret = dict_get_str (dict, key, &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.status", i);
+        ret = dict_get_int32(dict, key, &status);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"status", "%d", status);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.volume_id", i);
-                ret = dict_get_str (dict, key, &volume_id);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", volume_id);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"statusStr", "%s",
+                                              cli_vol_status_str[status]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.status", i);
-                ret = dict_get_int32 (dict, key, &status);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret =xmlTextWriterWriteFormatElement
-                        (local->writer, (xmlChar *)"statusStr", "%s",
-                         cli_vol_status_str[status]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "volume%d.snap_count", i);
-                ret = dict_get_int32 (dict, key, &snap_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                     (xmlChar *)"snapshotCount",
-                                                     "%d", snap_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.snap_count", i);
+        ret = dict_get_int32(dict, key, &snap_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"snapshotCount", "%d", snap_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
+        snprintf(key, sizeof(key), "volume%d.brick_count", i);
+        ret = dict_get_int32(dict, key, &brick_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"brickCount", "%d", brick_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.brick_count", i);
-                ret = dict_get_int32 (dict, key, &brick_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"brickCount",
-                                                       "%d", brick_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.dist_count", i);
+        ret = dict_get_int32(dict, key, &dist_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"distCount", "%d", dist_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.dist_count", i);
-                ret = dict_get_int32 (dict, key, &dist_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"distCount",
-                                                       "%d", dist_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.stripe_count", i);
+        ret = dict_get_int32(dict, key, &stripe_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"stripeCount", "%d", stripe_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.stripe_count", i);
-                ret = dict_get_int32 (dict, key, &stripe_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"stripeCount",
-                                                       "%d", stripe_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.replica_count", i);
+        ret = dict_get_int32(dict, key, &replica_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"replicaCount", "%d", replica_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.replica_count", i);
-                ret = dict_get_int32 (dict, key, &replica_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"replicaCount",
-                                                       "%d", replica_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.arbiter_count", i);
+        ret = dict_get_int32(dict, key, &arbiter_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"arbiterCount", "%d", arbiter_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.arbiter_count", i);
-                ret = dict_get_int32 (dict, key, &arbiter_count);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                      (xmlChar *)"arbiterCount",
-                                                      "%d", arbiter_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "volume%d.disperse_count", i);
+        ret = dict_get_int32(dict, key, &disperse_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"disperseCount", "%d", disperse_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.redundancy_count", i);
+        ret = dict_get_int32(dict, key, &redundancy_count);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(local->writer,
+                                              (xmlChar *)"redundancyCount",
+                                              "%d", redundancy_count);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.type", i);
+        ret = dict_get_int32(dict, key, &type);
+        if (ret)
+            goto out;
+        /* For Distributed-(stripe,replicate,stipe-replicate,disperse)
+           types
+         */
+        type = get_vol_type(type, dist_count, brick_count);
+
+        ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"type",
+                                              "%d", type);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"typeStr", "%s", vol_type_str[type]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d.transport", i);
+        ret = dict_get_int32(dict, key, &transport);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(
+            local->writer, (xmlChar *)"transport", "%d", transport);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+#ifdef HAVE_BD_XLATOR
+        /* <xlators> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"xlators");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        for (k = 0;; k++) {
+            snprintf(key, sizeof(key), "volume%d.xlator%d", i, k);
+            ret = dict_get_str(dict, key, &caps);
+            if (ret)
+                break;
+
+            /* <xlator> */
+            ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"xlator");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"name", "%s", caps);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.disperse_count", i);
-                ret = dict_get_int32 (dict, key, &disperse_count);
+            /* <capabilities> */
+            ret = xmlTextWriterStartElement(local->writer,
+                                            (xmlChar *)"capabilities");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            j = 0;
+            for (j = 0;; j++) {
+                snprintf(key, sizeof(key), "volume%d.xlator%d.caps%d", i, k, j);
+                ret = dict_get_str(dict, key, &caps);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"disperseCount",
-                                                       "%d", disperse_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    break;
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"capability", "%s", caps);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            }
+            /* </capabilities> */
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            /* </xlator> */
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
+        ret = xmlTextWriterFullEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        /* </xlators> */
+#endif
+        j = 1;
+
+        /* <bricks> */
+        ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"bricks");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "volume%d.redundancy_count", i);
-                ret = dict_get_int32 (dict, key, &redundancy_count);
+        if (type == GF_CLUSTER_TYPE_TIER) {
+            /*the values for hot stripe, disperse and redundancy
+             * should not be looped in here as they are zero
+             * always */
+            for (c = COLD_BRICK_COUNT; c < MAX; c++) {
+                snprintf(key, 256, keys[c], i);
+                ret = dict_get_int32(dict, key, &value[c]);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"redundancyCount",
-                                                       "%d", redundancy_count);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+            }
+
+            hot_dist_count = (value[HOT_REPLICA_COUNT]
+                                  ? value[HOT_REPLICA_COUNT]
+                                  : 1);
+
+            tier_vol_type = get_vol_type(value[HOT_TYPE], hot_dist_count,
+                                         value[HOT_BRICK_COUNT]);
 
-                snprintf (key, sizeof (key), "volume%d.type", i);
-                ret = dict_get_int32 (dict, key, &type);
+            if ((value[HOT_TYPE] != GF_CLUSTER_TYPE_TIER) &&
+                (value[HOT_TYPE] > 0) &&
+                (hot_dist_count < value[HOT_BRICK_COUNT]))
+                tier_vol_type = value[HOT_TYPE] + GF_CLUSTER_TYPE_MAX - 1;
+
+            ret = xmlTextWriterStartElement(local->writer,
+                                            (xmlChar *)"hotBricks");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"hotBrickType", "%s",
+                vol_type_str[tier_vol_type]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"hotreplicaCount", "%d",
+                value[HOT_REPLICA_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(local->writer,
+                                                  (xmlChar *)"hotbrickCount",
+                                                  "%d", value[HOT_BRICK_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            if (value[HOT_TYPE] == GF_CLUSTER_TYPE_NONE ||
+                value[HOT_TYPE] == GF_CLUSTER_TYPE_TIER) {
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"numberOfBricks", "%d",
+                    value[HOT_BRICK_COUNT]);
+            } else {
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"numberOfBricks", "%d x %d = %d",
+                    (value[HOT_BRICK_COUNT] / hot_dist_count), hot_dist_count,
+                    value[HOT_BRICK_COUNT]);
+            }
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            while (index <= value[HOT_BRICK_COUNT]) {
+                snprintf(key, 1024, "volume%d.brick%d", i, index);
+                ret = dict_get_str(dict, key, &brick);
                 if (ret)
-                        goto out;
-                /* For Distributed-(stripe,replicate,stipe-replicate,disperse)
-                   types
-                 */
-                type = get_vol_type (type, dist_count, brick_count);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"type",
-                                                       "%d", type);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"typeStr",
-                                                       "%s",
-                                                       vol_type_str[type]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "volume%d.transport", i);
-                ret = dict_get_int32 (dict, key, &transport);
+                    goto out;
+
+                ret = xmlTextWriterStartElement(local->writer,
+                                                (xmlChar *)"brick");
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                snprintf(key, sizeof(key), "volume%d.brick%d.uuid", i, index);
+                ret = dict_get_str(dict, key, &uuid);
                 if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                       (xmlChar *)"transport",
-                                                       "%d", transport);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+                    goto out;
+                ret = xmlTextWriterWriteFormatAttribute(
+                    local->writer, (xmlChar *)"uuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-#ifdef HAVE_BD_XLATOR
-                /* <xlators> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"xlators");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                for (k = 0; ; k++) {
-                        snprintf (key, sizeof (key),"volume%d.xlator%d", i, k);
-                        ret = dict_get_str (dict, key, &caps);
-                        if (ret)
-                                break;
-
-                        /* <xlator> */
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)"xlator");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"name", "%s", caps);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        /* <capabilities> */
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "capabilities");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        j = 0;
-                        for (j = 0; ;j++) {
-                                snprintf (key, sizeof (key),
-                                          "volume%d.xlator%d.caps%d", i, k, j);
-                                ret = dict_get_str (dict, key, &caps);
-                                if (ret)
-                                        break;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"capability",
-                                         "%s", caps);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-                        /* </capabilities> */
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        /* </xlator> */
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
-                ret = xmlTextWriterFullEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                /* </xlators> */
-#endif
-                j = 1;
-
-                /* <bricks> */
-                ret = xmlTextWriterStartElement (local->writer,
-                                                 (xmlChar *)"bricks");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                if (type == GF_CLUSTER_TYPE_TIER) {
-                        /*the values for hot stripe, disperse and redundancy
-                         * should not be looped in here as they are zero
-                         * always */
-                        for (c = COLD_BRICK_COUNT; c < MAX; c++) {
-
-                                snprintf (key, 256, keys[c], i);
-                                ret = dict_get_int32 (dict, key, &value[c]);
-                                if (ret)
-                                        goto out;
-                        }
-
-                        hot_dist_count = (value[HOT_REPLICA_COUNT] ?
-                                          value[HOT_REPLICA_COUNT] : 1);
-
-                        tier_vol_type = get_vol_type (value[HOT_TYPE],
-                                                      hot_dist_count,
-                                                      value[HOT_BRICK_COUNT]);
-
-                        if ((value[HOT_TYPE] != GF_CLUSTER_TYPE_TIER) &&
-                            (value[HOT_TYPE] > 0) &&
-                            (hot_dist_count < value[HOT_BRICK_COUNT]))
-                                tier_vol_type = value[HOT_TYPE] +
-                                        GF_CLUSTER_TYPE_MAX - 1;
-
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "hotBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"hotBrickType",
-                                 "%s", vol_type_str[tier_vol_type]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"hotreplicaCount",
-                                                    "%d",
-                                                    value[HOT_REPLICA_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"hotbrickCount",
-                                                    "%d",
-                                                    value[HOT_BRICK_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        if (value[HOT_TYPE] == GF_CLUSTER_TYPE_NONE ||
-                                        value[HOT_TYPE] ==
-                                        GF_CLUSTER_TYPE_TIER) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d", value[HOT_BRICK_COUNT]);
-                        } else {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d x %d = %d",
-                                         (value[HOT_BRICK_COUNT] /
-                                          hot_dist_count),
-                                         hot_dist_count,
-                                         value[HOT_BRICK_COUNT]);
-                        }
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        while (index <= value[HOT_BRICK_COUNT]) {
-                                snprintf (key, 1024, "volume%d.brick%d", i,
-                                          index);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, index);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                index++;
-                        }
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        tier_vol_type = get_vol_type (value[COLD_TYPE],
-                                                      value[COLD_DIST_COUNT],
-                                                      value[COLD_BRICK_COUNT]);
-
-                        ret = xmlTextWriterStartElement (local->writer,
-                                                         (xmlChar *)
-                                                         "coldBricks");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement
-                                (local->writer, (xmlChar *)"coldBrickType",
-                                 "%s", vol_type_str[tier_vol_type]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                        (xmlChar *)"coldreplicaCount",
-                                        "%d", value[COLD_REPLICA_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                        (xmlChar *)"coldarbiterCount",
-                                        "%d", value[COLD_ARBITER_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                                   (xmlChar *)"coldbrickCount",
-                                                    "%d",
-                                                    value[COLD_BRICK_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"colddisperseCount",
-                                              "%d", value[COLD_DISPERSE_COUNT]);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        if (value[COLD_TYPE] == GF_CLUSTER_TYPE_NONE ||
-                                        value[COLD_TYPE] ==
-                                        GF_CLUSTER_TYPE_TIER) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d", value[COLD_BRICK_COUNT]);
-                        } else if (value[COLD_TYPE] ==
-                                        GF_CLUSTER_TYPE_DISPERSE) {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         " %d x (%d + %d) = %d",
-                                         (value[COLD_BRICK_COUNT] /
-                                          value[COLD_DIST_COUNT]),
-                                         value[COLD_DISPERSE_COUNT] -
-                                         value[COLD_REDUNDANCY_COUNT],
-                                         value[COLD_REDUNDANCY_COUNT],
-                                         value[COLD_BRICK_COUNT]);
-                        } else {
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer,
-                                         (xmlChar *)"numberOfBricks",
-                                         "%d x %d = %d",
-                                         (value[COLD_BRICK_COUNT] /
-                                          value[COLD_DIST_COUNT]),
+                ret = xmlTextWriterWriteFormatString(local->writer, "%s",
+                                                     brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"name", "%s", brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"hostUuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterEndElement(local->writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                index++;
+            }
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            tier_vol_type = get_vol_type(value[COLD_TYPE],
                                          value[COLD_DIST_COUNT],
                                          value[COLD_BRICK_COUNT]);
-                        }
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        index = value[HOT_BRICK_COUNT] + 1;
-
-                        while (index <= brick_count) {
-                                snprintf (key, 1024, "volume%d.brick%d", i,
-                                          index);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, index);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.isArbiter", i,
-                                          index);
-                                if (dict_get (dict, key))
-                                        isArbiter = 1;
-                                else
-                                        isArbiter = 0;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"isArbiter",
-                                         "%d", isArbiter);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                index++;
-                        }
-                        ret = xmlTextWriterEndElement (local->writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                } else {
-                        while (j <= brick_count) {
-                                ret = xmlTextWriterStartElement
-                                        (local->writer, (xmlChar *)"brick");
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.uuid", i, j);
-                                ret = dict_get_str (dict, key, &uuid);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatAttribute
-                                        (local->writer, (xmlChar *)"uuid", "%s",
-                                         uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d", i, j);
-                                ret = dict_get_str (dict, key, &brick);
-                                if (ret)
-                                        goto out;
-                                ret = xmlTextWriterWriteFormatString
-                                        (local->writer, "%s", brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"name", "%s",
-                                         brick);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"hostUuid",
-                                         "%s", uuid);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                snprintf (key, sizeof (key),
-                                          "volume%d.brick%d.isArbiter", i, j);
-                                if (dict_get (dict, key))
-                                        isArbiter = 1;
-                                else
-                                        isArbiter = 0;
-                                ret = xmlTextWriterWriteFormatElement
-                                        (local->writer, (xmlChar *)"isArbiter",
-                                         "%d", isArbiter);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                /* </brick> */
-                                ret = xmlTextWriterEndElement (local->writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                                j++;
-                        }
-                }
-                /* </bricks> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
 
-                snprintf (key, sizeof (key), "volume%d", i);
-                ret = cli_xml_output_vol_info_options (local->writer, dict,
-                                                       key);
+            ret = xmlTextWriterStartElement(local->writer,
+                                            (xmlChar *)"coldBricks");
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"coldBrickType", "%s",
+                vol_type_str[tier_vol_type]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"coldreplicaCount", "%d",
+                value[COLD_REPLICA_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"coldarbiterCount", "%d",
+                value[COLD_ARBITER_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"coldbrickCount", "%d",
+                value[COLD_BRICK_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterWriteFormatElement(
+                local->writer, (xmlChar *)"colddisperseCount", "%d",
+                value[COLD_DISPERSE_COUNT]);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            if (value[COLD_TYPE] == GF_CLUSTER_TYPE_NONE ||
+                value[COLD_TYPE] == GF_CLUSTER_TYPE_TIER) {
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"numberOfBricks", "%d",
+                    value[COLD_BRICK_COUNT]);
+            } else if (value[COLD_TYPE] == GF_CLUSTER_TYPE_DISPERSE) {
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"numberOfBricks",
+                    " %d x (%d + %d) = %d",
+                    (value[COLD_BRICK_COUNT] / value[COLD_DIST_COUNT]),
+                    value[COLD_DISPERSE_COUNT] - value[COLD_REDUNDANCY_COUNT],
+                    value[COLD_REDUNDANCY_COUNT], value[COLD_BRICK_COUNT]);
+            } else {
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"numberOfBricks", "%d x %d = %d",
+                    (value[COLD_BRICK_COUNT] / value[COLD_DIST_COUNT]),
+                    value[COLD_DIST_COUNT], value[COLD_BRICK_COUNT]);
+            }
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            index = value[HOT_BRICK_COUNT] + 1;
+
+            while (index <= brick_count) {
+                snprintf(key, 1024, "volume%d.brick%d", i, index);
+                ret = dict_get_str(dict, key, &brick);
                 if (ret)
-                        goto out;
+                    goto out;
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (local->writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+                ret = xmlTextWriterStartElement(local->writer,
+                                                (xmlChar *)"brick");
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                snprintf(key, sizeof(key), "volume%d.brick%d.uuid", i, index);
+                ret = dict_get_str(dict, key, &uuid);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatAttribute(
+                    local->writer, (xmlChar *)"uuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatString(local->writer, "%s",
+                                                     brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"name", "%s", brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"hostUuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                snprintf(key, sizeof(key), "volume%d.brick%d.isArbiter", i,
+                         index);
+                if (dict_get(dict, key))
+                    isArbiter = 1;
+                else
+                    isArbiter = 0;
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"isArbiter", "%d", isArbiter);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterEndElement(local->writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                index++;
+            }
+            ret = xmlTextWriterEndElement(local->writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+        } else {
+            while (j <= brick_count) {
+                ret = xmlTextWriterStartElement(local->writer,
+                                                (xmlChar *)"brick");
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (volname) {
-                GF_FREE (local->get_vol.volname);
-                local->get_vol.volname = gf_strdup (volname);
-                local->vol_count += count;
+                snprintf(key, sizeof(key), "volume%d.brick%d.uuid", i, j);
+                ret = dict_get_str(dict, key, &uuid);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatAttribute(
+                    local->writer, (xmlChar *)"uuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                snprintf(key, sizeof(key), "volume%d.brick%d", i, j);
+                ret = dict_get_str(dict, key, &brick);
+                if (ret)
+                    goto out;
+                ret = xmlTextWriterWriteFormatString(local->writer, "%s",
+                                                     brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"name", "%s", brick);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"hostUuid", "%s", uuid);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                snprintf(key, sizeof(key), "volume%d.brick%d.isArbiter", i, j);
+                if (dict_get(dict, key))
+                    isArbiter = 1;
+                else
+                    isArbiter = 0;
+                ret = xmlTextWriterWriteFormatElement(
+                    local->writer, (xmlChar *)"isArbiter", "%d", isArbiter);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                /* </brick> */
+                ret = xmlTextWriterEndElement(local->writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+
+                j++;
+            }
         }
+        /* </bricks> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "volume%d", i);
+        ret = cli_xml_output_vol_info_options(local->writer, dict, key);
+        if (ret)
+            goto out;
+
+        /* </volume> */
+        ret = xmlTextWriterEndElement(local->writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    if (volname) {
+        GF_FREE(local->get_vol.volname);
+        local->get_vol.volname = gf_strdup(volname);
+        local->vol_count += count;
+    }
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_info_begin (cli_local_t *local, int op_ret, int op_errno,
-                               char *op_errstr)
+cli_xml_output_vol_info_begin(cli_local_t *local, int op_ret, int op_errno,
+                              char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        /* <volInfo> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volInfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volInfo> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volInfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <volumes> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <volumes> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volumes");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Init vol count */
-        local->vol_count = 0;
+    /* Init vol count */
+    local->vol_count = 0;
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_info_end (cli_local_t *local)
+cli_xml_output_vol_info_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int             ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"count",
-                                               "%d", local->vol_count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-        /* </volumes> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"count",
+                                          "%d", local->vol_count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </volumes> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </volInfo> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volInfo> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_quota_limit_list_end (cli_local_t *local)
+cli_xml_output_vol_quota_limit_list_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_quota_limit_list_begin (cli_local_t *local, int op_ret,
-                                           int op_errno, char *op_errstr)
+cli_xml_output_vol_quota_limit_list_begin(cli_local_t *local, int op_ret,
+                                          int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    if (ret)
+        goto out;
 
-        /* <volQuota> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volQuota");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
+    /* <volQuota> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"volQuota");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 static int
-cli_xml_output_peer_hostnames (xmlTextWriterPtr writer, dict_t *dict,
-                               const char *prefix, int count)
+cli_xml_output_peer_hostnames(xmlTextWriterPtr writer, dict_t *dict,
+                              const char *prefix, int count)
 {
-        int   ret       = -1;
-        int   i         = 0;
-        char *hostname  = NULL;
-        char  key[1024] = {0,};
-
-        /* <hostnames> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"hostnames");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i = 0; i < count; i++) {
-                snprintf (key, sizeof (key), "%s.hostname%d", prefix, i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement
-                        (writer, (xmlChar *)"hostname", "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                hostname = NULL;
-        }
+    int ret = -1;
+    int i = 0;
+    char *hostname = NULL;
+    char key[1024] = {
+        0,
+    };
+
+    /* <hostnames> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"hostnames");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 0; i < count; i++) {
+        snprintf(key, sizeof(key), "%s.hostname%d", prefix, i);
+        ret = dict_get_str(dict, key, &hostname);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        hostname = NULL;
+    }
 
-        /* </hostnames> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </hostnames> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_peer_status (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_peer_status(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        int                     count = 0;
-        char                    *uuid = NULL;
-        char                    *hostname = NULL;
-        int                     connected = 0;
-        int                     state_id = 0;
-        char                    *state_str = NULL;
-        int                     hostname_count = 0;
-        int                     i = 1;
-        char                    key[1024] = {0,};
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    int count = 0;
+    char *uuid = NULL;
+    char *hostname = NULL;
+    int connected = 0;
+    int state_id = 0;
+    char *state_str = NULL;
+    int hostname_count = 0;
+    int i = 1;
+    char key[1024] = {
+        0,
+    };
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <peerStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"peerStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    if (!dict)
+        goto cont;
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+
+    while (i <= count) {
+        /* <peer> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"peer");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+        snprintf(key, sizeof(key), "friend%d.uuid", i);
+        ret = dict_get_str(dict, key, &uuid);
         if (ret)
-                goto out;
+            goto out;
 
-        /* <peerStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"peerStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (!dict)
-                goto cont;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                              uuid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "count", &count);
+        snprintf(key, sizeof(key), "friend%d.hostname", i);
+        ret = dict_get_str(dict, key, &hostname);
         if (ret)
-                goto out;
+            goto out;
 
-        while (i <= count) {
-                /* <peer> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"peer");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "friend%d.uuid", i);
-                ret = dict_get_str (dict, key, &uuid);
-                if (ret)
-                        goto out;
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"uuid",
-                                                       "%s", uuid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "friend%d.hostname", i);
-                ret = dict_get_str (dict, key, &hostname);
-                if (ret)
-                        goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hostname",
+                                              "%s", hostname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"hostname",
-                                                       "%s", hostname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "friend%d.hostname_count", i);
-                ret = dict_get_int32 (dict, key, &hostname_count);
-                if ((ret == 0) && (hostname_count > 0)) {
-                        snprintf (key, sizeof (key), "friend%d", i);
-                        ret = cli_xml_output_peer_hostnames (writer, dict, key,
-                                                             hostname_count);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+        snprintf(key, sizeof(key), "friend%d.hostname_count", i);
+        ret = dict_get_int32(dict, key, &hostname_count);
+        if ((ret == 0) && (hostname_count > 0)) {
+            snprintf(key, sizeof(key), "friend%d", i);
+            ret = cli_xml_output_peer_hostnames(writer, dict, key,
+                                                hostname_count);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                snprintf (key, sizeof (key), "friend%d.connected", i);
-                ret = dict_get_int32 (dict, key, &connected);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "friend%d.connected", i);
+        ret = dict_get_int32(dict, key, &connected);
+        if (ret)
+            goto out;
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"connected",
-                                                       "%d", connected);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"connected",
+                                              "%d", connected);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "friend%d.stateId", i);
-                ret = dict_get_int32 (dict, key, &state_id);
-                if (!ret) {
-                        /* ignore */
+        snprintf(key, sizeof(key), "friend%d.stateId", i);
+        ret = dict_get_int32(dict, key, &state_id);
+        if (!ret) {
+            /* ignore */
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                           (xmlChar *)"state", "%d", state_id);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"state",
+                                                  "%d", state_id);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                snprintf (key, sizeof (key), "friend%d.state", i);
-                ret = dict_get_str (dict, key, &state_str);
-                if (!ret) {
-                        /* ignore */
+        snprintf(key, sizeof(key), "friend%d.state", i);
+        ret = dict_get_str(dict, key, &state_str);
+        if (!ret) {
+            /* ignore */
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                       (xmlChar *)"stateStr", "%s", state_str);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"stateStr",
+                                                  "%s", state_str);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                /* </peer> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </peer> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                i++;
-        }
+        i++;
+    }
 
 cont:
-        /* </peerStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </peerStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 /* Used for rebalance stop/status, remove-brick status */
 int
-cli_xml_output_vol_rebalance_status (xmlTextWriterPtr writer, dict_t *dict,
-                                     enum gf_task_types task_type)
+cli_xml_output_vol_rebalance_status(xmlTextWriterPtr writer, dict_t *dict,
+                                    enum gf_task_types task_type)
 {
-        int                     ret = -1;
-        int                     count = 0;
-        char                    *node_name = NULL;
-        char                    *node_uuid = NULL;
-        uint64_t                files = 0;
-        uint64_t                size = 0;
-        uint64_t                lookups = 0;
-        int                     status_rcd = 0;
-        uint64_t                failures = 0;
-        uint64_t                skipped = 0;
-        uint64_t                total_files = 0;
-        uint64_t                total_size = 0;
-        uint64_t                total_lookups = 0;
-        uint64_t                total_failures = 0;
-        uint64_t                total_skipped = 0;
-        char                    key[1024] = {0,};
-        int                     i = 0;
-        int                     overall_status = -1;
-        double                  elapsed = 0;
-        double                  overall_elapsed = 0;
-
-        if (!dict) {
-                ret = 0;
-                goto out;
-        }
+    int ret = -1;
+    int count = 0;
+    char *node_name = NULL;
+    char *node_uuid = NULL;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookups = 0;
+    int status_rcd = 0;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    uint64_t total_files = 0;
+    uint64_t total_size = 0;
+    uint64_t total_lookups = 0;
+    uint64_t total_failures = 0;
+    uint64_t total_skipped = 0;
+    char key[1024] = {
+        0,
+    };
+    int i = 0;
+    int overall_status = -1;
+    double elapsed = 0;
+    double overall_elapsed = 0;
+
+    if (!dict) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret)
+        goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeCount", "%d",
+                                          count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    while (i < count) {
+        i++;
+        /* Getting status early, to skip nodes that don't have the
+         * rebalance process started
+         */
+        snprintf(key, sizeof(key), "status-%d", i);
+        ret = dict_get_int32(dict, key, &status_rcd);
 
-        ret = dict_get_int32 (dict, "count", &count);
+        /* If glusterd is down it fails to get the status, try
+         getting status from other nodes */
         if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        while (i < count) {
-                i++;
-                /* Getting status early, to skip nodes that don't have the
-                 * rebalance process started
-                 */
-                snprintf (key, sizeof (key), "status-%d", i);
-                ret = dict_get_int32 (dict, key, &status_rcd);
-
-                /* If glusterd is down it fails to get the status, try
-                 getting status from other nodes */
-                if (ret)
-                    continue;
-                if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
-                        continue;
+            continue;
+        if (GF_DEFRAG_STATUS_NOT_STARTED == status_rcd)
+            continue;
 
-                /* <node> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <node> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"node");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"nodeName",
-                                                       "%s", node_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeName",
+                                              "%s", node_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "node-uuid-%d", i);
-                ret = dict_get_str (dict, key, &node_uuid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"id",
-                                                       "%s", node_uuid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "node-uuid-%d", i);
+        ret = dict_get_str(dict, key, &node_uuid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              node_uuid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "files-%d", i);
-                ret = dict_get_uint64 (dict, key, &files);
-                if (ret)
-                        goto out;
-                total_files += files;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"files",
-                                                       "%"PRIu64, files);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "size-%d", i);
-                ret = dict_get_uint64 (dict, key, &size);
-                if (ret)
-                        goto out;
-                total_size += size;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"size",
-                                                       "%"PRIu64,size);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "lookups-%d", i);
-                ret = dict_get_uint64 (dict, key, &lookups);
-                if (ret)
-                        goto out;
-                total_lookups += lookups;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"lookups",
-                                                       "%"PRIu64, lookups);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "failures-%d", i);
-                ret = dict_get_uint64 (dict, key, &failures);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "files-%d", i);
+        ret = dict_get_uint64(dict, key, &files);
+        if (ret)
+            goto out;
+        total_files += files;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"files",
+                                              "%" PRIu64, files);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "skipped-%d", i);
+        snprintf(key, sizeof(key), "size-%d", i);
+        ret = dict_get_uint64(dict, key, &size);
+        if (ret)
+            goto out;
+        total_size += size;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size",
+                                              "%" PRIu64, size);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_uint64 (dict, key, &skipped);
-                if (ret)
-                        goto out;
+        snprintf(key, sizeof(key), "lookups-%d", i);
+        ret = dict_get_uint64(dict, key, &lookups);
+        if (ret)
+            goto out;
+        total_lookups += lookups;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lookups",
+                                              "%" PRIu64, lookups);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                if (task_type == GF_TASK_TYPE_REMOVE_BRICK) {
-                        failures += skipped;
-                        skipped = 0;
-                }
+        snprintf(key, sizeof(key), "failures-%d", i);
+        ret = dict_get_uint64(dict, key, &failures);
+        if (ret)
+            goto out;
 
-                total_failures += failures;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"failures",
-                                               "%"PRIu64, failures);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "skipped-%d", i);
 
-                total_skipped += skipped;
+        ret = dict_get_uint64(dict, key, &skipped);
+        if (ret)
+            goto out;
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *)"skipped",
-                                               "%"PRIu64, skipped);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        if (task_type == GF_TASK_TYPE_REMOVE_BRICK) {
+            failures += skipped;
+            skipped = 0;
+        }
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status_rcd);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        total_failures += failures;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"failures",
+                                              "%" PRIu64, failures);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s",
-                                         cli_vol_task_status_str[status_rcd]);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        total_skipped += skipped;
 
-                snprintf (key, sizeof (key), "run-time-%d", i);
-                ret = dict_get_double (dict, key, &elapsed);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"runtime",
-                                                       "%.2f", elapsed);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"skipped",
+                                              "%" PRIu64, skipped);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                if (elapsed > overall_elapsed) {
-                    overall_elapsed = elapsed;
-                }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                              status_rcd);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* Rebalance has 5 states,
-                 * NOT_STARTED, STARTED, STOPPED, COMPLETE, FAILED
-                 * The precedence used to determine the aggregate status is as
-                 * below,
-                 * STARTED > FAILED > STOPPED > COMPLETE > NOT_STARTED
-                 */
-                /* TODO: Move this to a common place utilities that both CLI and
-                 * glusterd need.
-                 * Till then if the below algorithm is changed, change it in
-                 * glusterd_volume_status_aggregate_tasks_status in
-                 * glusterd-utils.c
-                 */
-
-                if (-1 == overall_status)
-                        overall_status = status_rcd;
-                int rank[] = {
-                        [GF_DEFRAG_STATUS_STARTED] = 1,
-                        [GF_DEFRAG_STATUS_FAILED] = 2,
-                        [GF_DEFRAG_STATUS_STOPPED] = 3,
-                        [GF_DEFRAG_STATUS_COMPLETE] = 4,
-                        [GF_DEFRAG_STATUS_NOT_STARTED] = 5
-                };
-                if (rank[status_rcd] <= rank[overall_status])
-                        overall_status = status_rcd;
-
-                /* </node> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"statusStr", "%s",
+            cli_vol_task_status_str[status_rcd]);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "run-time-%d", i);
+        ret = dict_get_double(dict, key, &elapsed);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"runtime",
+                                              "%.2f", elapsed);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        if (elapsed > overall_elapsed) {
+            overall_elapsed = elapsed;
         }
 
-        /* Aggregate status */
-        /* <aggregate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"aggregate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        /* Rebalance has 5 states,
+         * NOT_STARTED, STARTED, STOPPED, COMPLETE, FAILED
+         * The precedence used to determine the aggregate status is as
+         * below,
+         * STARTED > FAILED > STOPPED > COMPLETE > NOT_STARTED
+         */
+        /* TODO: Move this to a common place utilities that both CLI and
+         * glusterd need.
+         * Till then if the below algorithm is changed, change it in
+         * glusterd_volume_status_aggregate_tasks_status in
+         * glusterd-utils.c
+         */
+
+        if (-1 == overall_status)
+            overall_status = status_rcd;
+        int rank[] = {[GF_DEFRAG_STATUS_STARTED] = 1,
+                      [GF_DEFRAG_STATUS_FAILED] = 2,
+                      [GF_DEFRAG_STATUS_STOPPED] = 3,
+                      [GF_DEFRAG_STATUS_COMPLETE] = 4,
+                      [GF_DEFRAG_STATUS_NOT_STARTED] = 5};
+        if (rank[status_rcd] <= rank[overall_status])
+            overall_status = status_rcd;
+
+        /* </node> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
+    /* Aggregate status */
+    /* <aggregate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"aggregate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"files",
-                                               "%"PRIu64, total_files);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"files",
+                                          "%" PRIu64, total_files);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"size",
-                                               "%"PRIu64, total_size);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"size", "%" PRIu64,
+                                          total_size);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"lookups",
-                                               "%"PRIu64, total_lookups);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lookups",
+                                          "%" PRIu64, total_lookups);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"failures",
-                                               "%"PRIu64, total_failures);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"failures",
+                                          "%" PRIu64, total_failures);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"skipped",
-                                               "%"PRIu64, total_skipped);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"skipped",
+                                          "%" PRIu64, total_skipped);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"status",
-                                               "%d", overall_status);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%d",
+                                          overall_status);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"statusStr",
-                                               "%s",
-                                      cli_vol_task_status_str[overall_status]);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        writer, (xmlChar *)"statusStr", "%s",
+        cli_vol_task_status_str[overall_status]);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"runtime",
-                                               "%.2f", overall_elapsed);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"runtime", "%.2f",
+                                          overall_elapsed);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </aggregate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </aggregate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-cli_xml_output_vol_tier_status (xmlTextWriterPtr writer, dict_t *dict,
-                enum gf_task_types task_type)
+cli_xml_output_vol_tier_status(xmlTextWriterPtr writer, dict_t *dict,
+                               enum gf_task_types task_type)
 {
-        int                     ret = -1;
-        int                     count = 0;
-        char                    *node_name = NULL;
-        char                    *status_str  = NULL;
-        uint64_t                promoted     = 0;
-        uint64_t                demoted      = 0;
-        int                     i = 1;
-        char                    key[1024] = {0,};
-        gf_defrag_status_t      status_rcd   = GF_DEFRAG_STATUS_NOT_STARTED;
-
-
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-
-        ret = dict_get_int32 (dict, "count", &count);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "count not set");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
-                                               "%d", count);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        while (i <= count) {
-                promoted = 0;
-                node_name = NULL;
-                demoted = 0;
-
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int count = 0;
+    char *node_name = NULL;
+    char *status_str = NULL;
+    uint64_t promoted = 0;
+    uint64_t demoted = 0;
+    int i = 1;
+    char key[1024] = {
+        0,
+    };
+    gf_defrag_status_t status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
+
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "count not set");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeCount", "%d",
+                                          count);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    while (i <= count) {
+        promoted = 0;
+        node_name = NULL;
+        demoted = 0;
+
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"node");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "node-name-%d", i);
-                ret = dict_get_str (dict, key, &node_name);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"nodeName",
-                                                       "%s", node_name);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "node-name-%d", i);
+        ret = dict_get_str(dict, key, &node_name);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"nodeName",
+                                              "%s", node_name);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "promoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &promoted);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
+        snprintf(key, sizeof(key), "promoted-%d", i);
+        ret = dict_get_uint64(dict, key, &promoted);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement (writer,
                                                        (xmlChar *)"promoted"
                                                        "Files", "%"PRIu64,
                                                        promoted);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                snprintf (key, sizeof (key), "demoted-%d", i);
-                ret = dict_get_uint64 (dict, key, &demoted);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
+        snprintf(key, sizeof(key), "demoted-%d", i);
+        ret = dict_get_uint64(dict, key, &demoted);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement (writer,
                                                        (xmlChar *)"demoted"
                                                        "Files", "%"PRIu64,
                                                        demoted);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "status-%d", i);
-                ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                status_str = cli_vol_task_status_str[status_rcd];
+        snprintf(key, sizeof(key), "status-%d", i);
+        ret = dict_get_int32(dict, key, (int32_t *)&status_rcd);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"statusStr",
-                                                       "%s", status_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        status_str = cli_vol_task_status_str[status_rcd];
 
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"statusStr",
+                                              "%s", status_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                i++;
-        }
+        i++;
+    }
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_rebalance (gf_cli_defrag_type op, dict_t *dict, int op_ret,
-                              int op_errno, char *op_errstr)
+cli_xml_output_vol_rebalance(gf_cli_defrag_type op, dict_t *dict, int op_ret,
+                             int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *task_id_str = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *task_id_str = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <volRebalance> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volRebalance");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, GF_REBALANCE_TID_KEY, &task_id_str);
+    if (ret == 0) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"task-id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"op", "%d", op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    if (GF_DEFRAG_CMD_STATUS_TIER == op) {
+        ret = cli_xml_output_vol_tier_status(writer, dict,
+                                             GF_TASK_TYPE_REBALANCE);
         if (ret)
-                goto out;
-
-        /* <volRebalance> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volRebalance");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);
-        if (ret == 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"task-id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"op",
-                                               "%d", op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (GF_DEFRAG_CMD_STATUS_TIER == op) {
-                ret = cli_xml_output_vol_tier_status (writer,
-                                dict, GF_TASK_TYPE_REBALANCE);
-                if (ret)
-                        goto out;
-                }
-        if ((GF_DEFRAG_CMD_STOP == op) || (GF_DEFRAG_CMD_STATUS == op)) {
-
-                ret = cli_xml_output_vol_rebalance_status (writer, dict,
-                                                      GF_TASK_TYPE_REBALANCE);
-                if (ret)
-                        goto out;
-        }
-
-        /* </volRebalance> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+    }
+    if ((GF_DEFRAG_CMD_STOP == op) || (GF_DEFRAG_CMD_STATUS == op)) {
+        ret = cli_xml_output_vol_rebalance_status(writer, dict,
+                                                  GF_TASK_TYPE_REBALANCE);
+        if (ret)
+            goto out;
+    }
 
+    /* </volRebalance> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_remove_brick_detach_tier (gf_boolean_t status_op,
-                                             dict_t *dict, int op_ret,
-                                             int op_errno, char *op_errstr,
-                                             const char *op)
+cli_xml_output_vol_remove_brick_detach_tier(gf_boolean_t status_op,
+                                            dict_t *dict, int op_ret,
+                                            int op_errno, char *op_errstr,
+                                            const char *op)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *task_id_str = NULL;
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *task_id_str = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
+    if (ret == 0) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"task-id",
+                                              "%s", task_id_str);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+    if (status_op) {
+        ret = cli_xml_output_vol_rebalance_status(writer, dict,
+                                                  GF_TASK_TYPE_REMOVE_BRICK);
         if (ret)
-                goto out;
+            goto out;
+    }
 
-        ret = xmlTextWriterStartElement (writer, (xmlChar *) op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
-        if (ret == 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"task-id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        if (status_op) {
-                ret = cli_xml_output_vol_rebalance_status (writer, dict,
-                                                   GF_TASK_TYPE_REMOVE_BRICK);
-                if (ret)
-                        goto out;
-        }
-
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_replace_brick (dict_t *dict,
-                                  int op_ret, int op_errno, char *op_errstr)
+cli_xml_output_vol_replace_brick(dict_t *dict, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_vol_create (dict_t *dict, int op_ret, int op_errno,
-                           char *op_errstr)
+cli_xml_output_vol_create(dict_t *dict, int op_ret, int op_errno,
+                          char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        char                    *volid = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    char *volid = NULL;
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    if (dict) {
+        /* <volCreate> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volCreate");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
+        ret = dict_get_str(dict, "volname", &volname);
         if (ret)
-                goto out;
-
-        if (dict) {
-                /* <volCreate> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"volCreate");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "volume-id", &volid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
-                                                       "%s", volid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "volume-id", &volid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              volid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volCreate> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </volCreate> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_generic_volume (char *op, dict_t *dict, int op_ret, int op_errno,
-                               char *op_errstr)
+cli_xml_output_generic_volume(char *op, dict_t *dict, int op_ret, int op_errno,
+                              char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *volname = NULL;
-        char                    *volid = NULL;
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *volname = NULL;
+    char *volid = NULL;
 
-        GF_ASSERT (op);
+    GF_ASSERT(op);
 
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
 
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
 
-        if (dict) {
-                /* <"op"> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    if (dict) {
+        /* <"op"> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)op);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "volname", &volname);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "name",
-                                                       "%s", volname);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "volname", &volname);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = dict_get_str (dict, "vol-id", &volid);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
-                                                       "%s", volid);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = dict_get_str(dict, "vol-id", &volid);
+        if (ret)
+            goto out;
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"id", "%s",
+                                              volid);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </"op"> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </"op"> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 #if (HAVE_LIB_XML)
 int
-_output_gsync_config (FILE *fp, xmlTextWriterPtr writer, char *op_name)
+_output_gsync_config(FILE *fp, xmlTextWriterPtr writer, char *op_name)
 {
-        char  resbuf[256 + PATH_MAX] = {0,};
-        char *ptr                    = NULL;
-        char *v                      = NULL;
-        int   blen                   = sizeof(resbuf);
-        int   ret                    = 0;
-
-        for (;;) {
-                ptr = fgets (resbuf, blen, fp);
-                if (!ptr)
-                        break;
-
-                v = resbuf + strlen (resbuf) - 1;
-                while (isspace (*v)) {
-                        /* strip trailing space */
-                        *v-- = '\0';
-                }
-                if (v == resbuf) {
-                        /* skip empty line */
-                        continue;
-                }
+    char resbuf[256 + PATH_MAX] = {
+        0,
+    };
+    char *ptr = NULL;
+    char *v = NULL;
+    int blen = sizeof(resbuf);
+    int ret = 0;
+
+    for (;;) {
+        ptr = fgets(resbuf, blen, fp);
+        if (!ptr)
+            break;
 
-                if (op_name!= NULL){
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)op_name,
-                                                        "%s", resbuf);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        goto out;
-                }
+        v = resbuf + strlen(resbuf) - 1;
+        while (isspace(*v)) {
+            /* strip trailing space */
+            *v-- = '\0';
+        }
+        if (v == resbuf) {
+            /* skip empty line */
+            continue;
+        }
 
-                v = strchr (resbuf, ':');
-                if (!v) {
-                        ret = -1;
-                        goto out;
-                }
-                *v++ = '\0';
-                while (isspace (*v))
-                        v++;
-                v = gf_strdup (v);
-                if (!v) {
-                        ret = -1;
-                        goto out;
-                }
+        if (op_name != NULL) {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)op_name,
+                                                  "%s", resbuf);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            goto out;
+        }
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)resbuf,
-                                                       "%s", v);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        v = strchr(resbuf, ':');
+        if (!v) {
+            ret = -1;
+            goto out;
         }
+        *v++ = '\0';
+        while (isspace(*v))
+            v++;
+        v = gf_strdup(v);
+        if (!v) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)resbuf, "%s",
+                                              v);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-get_gsync_config (runner_t *runner,
-                  int (*op_conf)(FILE *fp,
-                              xmlTextWriterPtr writer,
-                              char *op_name),
-                  xmlTextWriterPtr writer, char *op_name)
+get_gsync_config(runner_t *runner,
+                 int (*op_conf)(FILE *fp, xmlTextWriterPtr writer,
+                                char *op_name),
+                 xmlTextWriterPtr writer, char *op_name)
 {
-        int ret = 0;
+    int ret = 0;
 
-        runner_redir (runner, STDOUT_FILENO, RUN_PIPE);
-        if (runner_start (runner) != 0) {
-                gf_log ("cli", GF_LOG_ERROR, "spawning child failed");
-                return -1;
-        }
+    runner_redir(runner, STDOUT_FILENO, RUN_PIPE);
+    if (runner_start(runner) != 0) {
+        gf_log("cli", GF_LOG_ERROR, "spawning child failed");
+        return -1;
+    }
 
-        ret = op_conf (runner_chio (runner, STDOUT_FILENO), writer, op_name);
+    ret = op_conf(runner_chio(runner, STDOUT_FILENO), writer, op_name);
 
-        ret |= runner_end (runner);
-        if (ret)
-                gf_log ("cli", GF_LOG_ERROR, "reading data from child failed");
+    ret |= runner_end(runner);
+    if (ret)
+        gf_log("cli", GF_LOG_ERROR, "reading data from child failed");
 
-        return ret ? -1 : 0;
+    return ret ? -1 : 0;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_generate_gsync_config (dict_t *dict, xmlTextWriterPtr writer)
+cli_xml_generate_gsync_config(dict_t *dict, xmlTextWriterPtr writer)
 {
-        runner_t runner           = {0,};
-        char *subop               = NULL;
-        char *gwd                 = NULL;
-        char *slave               = NULL;
-        char *confpath            = NULL;
-        char *master              = NULL;
-        char *op_name             = NULL;
-        int   ret                 = -1;
-        char  conf_path[PATH_MAX] = "";
-
-        if (dict_get_str (dict, "subop", &subop) != 0) {
-                ret = -1;
-                goto out;
-        }
-
-        if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                 (xmlChar *)"message",
-                                 "%s",GEOREP" config updated successfully" );
-                XML_RET_CHECK_AND_GOTO (ret, out);
-                ret = 0;
-                goto out;
-        }
+    runner_t runner = {
+        0,
+    };
+    char *subop = NULL;
+    char *gwd = NULL;
+    char *slave = NULL;
+    char *confpath = NULL;
+    char *master = NULL;
+    char *op_name = NULL;
+    int ret = -1;
+    char conf_path[PATH_MAX] = "";
+
+    if (dict_get_str(dict, "subop", &subop) != 0) {
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(subop, "get") != 0 && strcmp(subop, "get-all") != 0) {
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"message", "%s",
+            GEOREP " config updated successfully");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+        ret = 0;
+        goto out;
+    }
 
-        if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
-            dict_get_str (dict, "slave", &slave) != 0) {
-                ret = -1;
-                goto out;
-        }
+    if (dict_get_str(dict, "glusterd_workdir", &gwd) != 0 ||
+        dict_get_str(dict, "slave", &slave) != 0) {
+        ret = -1;
+        goto out;
+    }
 
-        if (dict_get_str (dict, "master", &master) != 0)
-                master = NULL;
+    if (dict_get_str(dict, "master", &master) != 0)
+        master = NULL;
 
-        if (dict_get_str (dict, "op_name", &op_name) != 0)
-                op_name = NULL;
+    if (dict_get_str(dict, "op_name", &op_name) != 0)
+        op_name = NULL;
 
-        ret = dict_get_str (dict, "conf_path", &confpath);
-        if (!confpath) {
-                ret = snprintf (conf_path, sizeof (conf_path) - 1,
-                                "%s/"GEOREP"/gsyncd_template.conf", gwd);
-                conf_path[ret] = '\0';
-                confpath = conf_path;
-        }
+    ret = dict_get_str(dict, "conf_path", &confpath);
+    if (!confpath) {
+        ret = snprintf(conf_path, sizeof(conf_path) - 1,
+                       "%s/" GEOREP "/gsyncd_template.conf", gwd);
+        conf_path[ret] = '\0';
+        confpath = conf_path;
+    }
 
-        runinit (&runner);
-        runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "-c", NULL);
-        runner_argprintf (&runner, "%s", confpath);
-        runner_argprintf (&runner, "--iprefix=%s", DATADIR);
+    runinit(&runner);
+    runner_add_args(&runner, GSYNCD_PREFIX "/gsyncd", "-c", NULL);
+    runner_argprintf(&runner, "%s", confpath);
+    runner_argprintf(&runner, "--iprefix=%s", DATADIR);
 
-        if (master)
-                runner_argprintf (&runner, ":%s", master);
+    if (master)
+        runner_argprintf(&runner, ":%s", master);
 
-        runner_add_arg (&runner, slave);
-        runner_argprintf (&runner, "--config-%s", subop);
+    runner_add_arg(&runner, slave);
+    runner_argprintf(&runner, "--config-%s", subop);
 
-        if (op_name)
-                runner_add_arg (&runner, op_name);
+    if (op_name)
+        runner_add_arg(&runner, op_name);
 
-        ret =  get_gsync_config (&runner, _output_gsync_config,
-                                 writer, op_name);
+    ret = get_gsync_config(&runner, _output_gsync_config, writer, op_name);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 #if (HAVE_LIB_XML)
 int
-cli_xml_output_vol_gsync_status (dict_t *dict,
-                                 xmlTextWriterPtr writer)
+cli_xml_output_vol_gsync_status(dict_t *dict, xmlTextWriterPtr writer)
 {
-        int                  ret                         = -1;
-        int                  i                           = 1;
-        int                  j                           = 0;
-        int                  count                       = 0;
-        const int            number_of_fields            = 20;
-        int                  closed                      = 1;
-        int                  session_closed              = 1;
-        gf_gsync_status_t  **status_values               = NULL;
-        char                 status_value_name[PATH_MAX] = "";
-        char                *tmp                         = NULL;
-        char                *volume                      = NULL;
-        char                *volume_next                 = NULL;
-        char                *slave                       = NULL;
-        char                *slave_next                  = NULL;
-        char                *title_values[]              = {"master_node",
-                                                            "",
-                                                            "master_brick",
-                                                            "slave_user",
-                                                            "slave",
-                                                            "slave_node",
-                                                            "status",
-                                                            "crawl_status",
-                                                            /* last_synced */
-                                                            "",
-                                                            "entry",
-                                                            "data",
-                                                            "meta",
-                                                            "failures",
-                                                           /* checkpoint_time */
-                                                            "",
-                                                         "checkpoint_completed",
-                                               /* checkpoint_completion_time */
-                                                            "",
-                                                            "master_node_uuid",
-                                                           /* last_synced_utc */
-                                                            "last_synced",
-                                                       /* checkpoint_time_utc */
-                                                            "checkpoint_time",
-                                            /* checkpoint_completion_time_utc */
-                                                 "checkpoint_completion_time"};
-
-        GF_ASSERT (dict);
-
-        ret = dict_get_int32 (dict, "gsync-count", &count);
-        if (ret)
-                goto out;
-
-        status_values = GF_MALLOC (count * sizeof (gf_gsync_status_t *),
+    int ret = -1;
+    int i = 1;
+    int j = 0;
+    int count = 0;
+    const int number_of_fields = 20;
+    int closed = 1;
+    int session_closed = 1;
+    gf_gsync_status_t **status_values = NULL;
+    char status_value_name[PATH_MAX] = "";
+    char *tmp = NULL;
+    char *volume = NULL;
+    char *volume_next = NULL;
+    char *slave = NULL;
+    char *slave_next = NULL;
+    char *title_values[] = {"master_node", "", "master_brick", "slave_user",
+                            "slave", "slave_node", "status", "crawl_status",
+                            /* last_synced */
+                            "", "entry", "data", "meta", "failures",
+                            /* checkpoint_time */
+                            "", "checkpoint_completed",
+                            /* checkpoint_completion_time */
+                            "", "master_node_uuid",
+                            /* last_synced_utc */
+                            "last_synced",
+                            /* checkpoint_time_utc */
+                            "checkpoint_time",
+                            /* checkpoint_completion_time_utc */
+                            "checkpoint_completion_time"};
+
+    GF_ASSERT(dict);
+
+    ret = dict_get_int32(dict, "gsync-count", &count);
+    if (ret)
+        goto out;
+
+    status_values = GF_MALLOC(count * sizeof(gf_gsync_status_t *),
                               gf_common_mt_char);
-        if (!status_values) {
-                ret = -1;
-                goto out;
-        }
+    if (!status_values) {
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0; i < count; i++) {
-                status_values[i] = GF_CALLOC (1, sizeof (gf_gsync_status_t),
-                                         gf_common_mt_char);
-                if (!status_values[i]) {
-                        ret = -1;
-                        goto out;
-                }
+    for (i = 0; i < count; i++) {
+        status_values[i] = GF_CALLOC(1, sizeof(gf_gsync_status_t),
+                                     gf_common_mt_char);
+        if (!status_values[i]) {
+            ret = -1;
+            goto out;
+        }
 
-                snprintf (status_value_name, sizeof (status_value_name),
-                          "status_value%d", i);
+        snprintf(status_value_name, sizeof(status_value_name), "status_value%d",
+                 i);
 
-                ret = dict_get_bin (dict, status_value_name,
-                                    (void **)&(status_values[i]));
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "struct member empty.");
-                        goto out;
-                }
+        ret = dict_get_bin(dict, status_value_name,
+                           (void **)&(status_values[i]));
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+            goto out;
         }
+    }
 
-        qsort(status_values, count, sizeof (gf_gsync_status_t *),
-              gf_gsync_status_t_comparator);
-
-        for (i = 0; i < count; i++) {
-                if (closed) {
-                        ret = xmlTextWriterStartElement (writer,
-                                                         (xmlChar *)"volume");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        tmp = get_struct_variable (1, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                        (xmlChar *)"name",
-                                                        "%s",tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        ret = xmlTextWriterStartElement (writer,
-                                                    (xmlChar *)"sessions");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-
-                        closed = 0;
-                }
+    qsort(status_values, count, sizeof(gf_gsync_status_t *),
+          gf_gsync_status_t_comparator);
 
-                if (session_closed) {
-                        ret = xmlTextWriterStartElement (writer,
-                                                         (xmlChar *)"session");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+    for (i = 0; i < count; i++) {
+        if (closed) {
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        session_closed = 0;
+            tmp = get_struct_variable(1, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                        tmp = get_struct_variable (21, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name",
+                                                  "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterWriteFormatElement
-                                (writer, (xmlChar *)"session_slave", "%s", tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"sessions");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"pair");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            closed = 0;
+        }
 
-                for (j = 0; j < number_of_fields; j++) {
-                        /* XML ignore fields */
-                        if (strcmp(title_values[j], "") == 0)
-                                continue;
+        if (session_closed) {
+            ret = xmlTextWriterStartElement(writer, (xmlChar *)"session");
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        tmp = get_struct_variable (j, status_values[i]);
-                        if (!tmp) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+            session_closed = 0;
 
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                  (xmlChar *)title_values[j],
-                                                  "%s", tmp);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+            tmp = get_struct_variable(21, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"session_slave", "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                if (i+1 < count) {
-                        slave = get_struct_variable (20, status_values[i]);
-                        slave_next = get_struct_variable (20,
-                                                          status_values[i+1]);
-                        volume = get_struct_variable (1, status_values[i]);
-                        volume_next = get_struct_variable (1,
-                                                           status_values[i+1]);
-                        if (!slave || !slave_next || !volume || !volume_next) {
-                                gf_log ("cli", GF_LOG_ERROR,
-                                        "struct member empty.");
-                                ret = -1;
-                                goto out;
-                        }
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"pair");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        if (strcmp (volume, volume_next)!=0) {
-                                closed = 1;
-                                session_closed = 1;
+        for (j = 0; j < number_of_fields; j++) {
+            /* XML ignore fields */
+            if (strcmp(title_values[j], "") == 0)
+                continue;
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
+            tmp = get_struct_variable(j, status_values[i]);
+            if (!tmp) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)title_values[j], "%s", tmp);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+        }
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        } else if (strcmp (slave, slave_next)!=0) {
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                                session_closed = 1;
+        if (i + 1 < count) {
+            slave = get_struct_variable(20, status_values[i]);
+            slave_next = get_struct_variable(20, status_values[i + 1]);
+            volume = get_struct_variable(1, status_values[i]);
+            volume_next = get_struct_variable(1, status_values[i + 1]);
+            if (!slave || !slave_next || !volume || !volume_next) {
+                gf_log("cli", GF_LOG_ERROR, "struct member empty.");
+                ret = -1;
+                goto out;
+            }
 
-                                ret = xmlTextWriterEndElement (writer);
-                                XML_RET_CHECK_AND_GOTO (ret, out);
-                        }
-                } else {
+            if (strcmp(volume, volume_next) != 0) {
+                closed = 1;
+                session_closed = 1;
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            } else if (strcmp(slave, slave_next) != 0) {
+                session_closed = 1;
+
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            }
+        } else {
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
         }
+    }
 out:
-        gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 #endif
 
 int
-cli_xml_output_vol_gsync (dict_t *dict, int op_ret, int op_errno,
-                          char *op_errstr)
+cli_xml_output_vol_gsync(dict_t *dict, int op_ret, int op_errno,
+                         char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *master = NULL;
-        char                    *slave = NULL;
-        int                     type = 0;
-
-        GF_ASSERT (dict);
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        /* <geoRep> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"geoRep");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get type");
-                goto out;
-        }
-
-        switch (type) {
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *master = NULL;
+    char *slave = NULL;
+    int type = 0;
+
+    GF_ASSERT(dict);
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    /* <geoRep> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"geoRep");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get type");
+        goto out;
+    }
+
+    switch (type) {
         case GF_GSYNC_OPTION_TYPE_START:
         case GF_GSYNC_OPTION_TYPE_STOP:
         case GF_GSYNC_OPTION_TYPE_PAUSE:
         case GF_GSYNC_OPTION_TYPE_RESUME:
         case GF_GSYNC_OPTION_TYPE_CREATE:
         case GF_GSYNC_OPTION_TYPE_DELETE:
-                if (dict_get_str (dict, "master", &master) != 0)
-                        master = "???";
-                if (dict_get_str (dict, "slave", &slave) != 0)
-                        slave = "???";
+            if (dict_get_str(dict, "master", &master) != 0)
+                master = "???";
+            if (dict_get_str(dict, "slave", &slave) != 0)
+                slave = "???";
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"master",
-                                                       "%s", master);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"master",
+                                                  "%s", master);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"slave",
-                                                       "%s", slave);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"slave",
+                                                  "%s", slave);
+            XML_RET_CHECK_AND_GOTO(ret, out);
 
-                break;
+            break;
 
         case GF_GSYNC_OPTION_TYPE_CONFIG:
-                if (op_ret == 0) {
-                        ret = xmlTextWriterStartElement (writer, (xmlChar *)"config");
-                        XML_RET_CHECK_AND_GOTO (ret, out);
+            if (op_ret == 0) {
+                ret = xmlTextWriterStartElement(writer, (xmlChar *)"config");
+                XML_RET_CHECK_AND_GOTO(ret, out);
 
-                        ret = cli_xml_generate_gsync_config (dict, writer);
-                        if (ret)
-                                goto out;
+                ret = cli_xml_generate_gsync_config(dict, writer);
+                if (ret)
+                    goto out;
 
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+                ret = xmlTextWriterEndElement(writer);
+                XML_RET_CHECK_AND_GOTO(ret, out);
+            }
 
-                break;
+            break;
         case GF_GSYNC_OPTION_TYPE_STATUS:
-                ret = cli_xml_output_vol_gsync_status (dict, writer);
-                break;
+            ret = cli_xml_output_vol_gsync_status(dict, writer);
+            break;
         default:
-                ret = 0;
-                break;
-        }
+            ret = 0;
+            break;
+    }
 
-        /* </geoRep> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </geoRep> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (writer, doc);
+    ret = cli_end_xml_output(writer, doc);
 out:
-        gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
@@ -4391,54 +4207,54 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_create (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_create(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapCreate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapCreate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapCreate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapCreate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapCreate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapCreate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot clone output in xml format.
@@ -4450,57 +4266,55 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_clone (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_clone(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("cli", writer, out);
-        GF_VALIDATE_OR_GOTO ("cli", doc, out);
-        GF_VALIDATE_OR_GOTO ("cli", dict, out);
-
-        /* <CloneCreate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"CloneCreate");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "clonename", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get clone name");
-                goto out;
-        }
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get clone uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </CloneCreate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_VALIDATE_OR_GOTO("cli", writer, out);
+    GF_VALIDATE_OR_GOTO("cli", doc, out);
+    GF_VALIDATE_OR_GOTO("cli", dict, out);
+
+    /* <CloneCreate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"CloneCreate");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "clonename", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get clone name");
+        goto out;
+    }
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get clone uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </CloneCreate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* This function will generate snapshot restore output in xml format.
  *
  * @param writer        xmlTextWriterPtr
@@ -4510,84 +4324,83 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_restore (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_restore(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        char   *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapRestore> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapRestore");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get vol name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "volid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get volume id");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapRestore> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapRestore> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapRestore");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get vol name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "volid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get volume id");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapRestore> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot list output in xml format.
@@ -4599,57 +4412,57 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_list (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_list(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        int     i               = 0;
-        int     snapcount       = 0;
-        char   *str_value       = NULL;
-        char    key[PATH_MAX]   = "";
+    int ret = -1;
+    int i = 0;
+    int snapcount = 0;
+    char *str_value = NULL;
+    char key[PATH_MAX] = "";
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
 
-        /* <snapList> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapList");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapList> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapList");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapcount");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapcount");
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "count",
-                                               "%d", snapcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          snapcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        for (i = 1; i <= snapcount; ++i) {
-                ret = snprintf (key, sizeof (key), "snapname%d", i);
-                if (ret < 0) {
-                        goto out;
-                }
+    for (i = 1; i <= snapcount; ++i) {
+        ret = snprintf(key, sizeof(key), "snapname%d", i);
+        if (ret < 0) {
+            goto out;
+        }
 
-                ret = dict_get_str (dict, key, &str_value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                } else {
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *)"snapshot", "%s", str_value);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                }
+        ret = dict_get_str(dict, key, &str_value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
+        } else {
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapshot",
+                                                  "%s", str_value);
+            XML_RET_CHECK_AND_GOTO(ret, out);
         }
+    }
 
-        /* </snapList> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapList> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate xml output for origin volume
@@ -4663,66 +4476,66 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_orig_vol (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix)
+cli_xml_snapshot_info_orig_vol(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix)
 {
-        int     ret             = -1;
-        int     value           = 0;
-        char   *buffer          = NULL;
-        char    key [PATH_MAX]  = "";
+    int ret = -1;
+    int value = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
 
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
 
-        /* <originVolume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"originVolume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <originVolume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"originVolume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%sorigin-volname", keyprefix);
+    snprintf(key, sizeof(key), "%sorigin-volname", keyprefix);
 
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_WARNING, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_WARNING, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%ssnapcount", keyprefix);
+    snprintf(key, sizeof(key), "%ssnapcount", keyprefix);
 
-        ret = dict_get_int32 (dict, key, &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_int32(dict, key, &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "snapCount",
-                                               "%d", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapCount", "%d",
+                                          value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%ssnaps-available", keyprefix);
+    snprintf(key, sizeof(key), "%ssnaps-available", keyprefix);
 
-        ret = dict_get_int32 (dict, key, &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
+    ret = dict_get_int32(dict, key, &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "snapRemaining", "%d", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"snapRemaining",
+                                          "%d", value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </originVolume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </originVolume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate xml output of snapshot volume info.
@@ -4737,66 +4550,67 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_snap_vol (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix,
-                                gf_boolean_t snap_driven)
+cli_xml_snapshot_info_snap_vol(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix,
+                               gf_boolean_t snap_driven)
 {
-        char            key [PATH_MAX]          = "";
-        char           *buffer                  = NULL;
-        int             ret                     = -1;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-
-        /* <snapVolume> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapVolume");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.volname", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
+    char key[PATH_MAX] = "";
+    char *buffer = NULL;
+    int ret = -1;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+
+    /* <snapVolume> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapVolume");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.volname", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.vol-status", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get %s", key);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* If the command is snap_driven then we need to show origin volume
+     * info. Else this is shown in the start of info display.*/
+    if (snap_driven) {
+        snprintf(key, sizeof(key), "%s.", keyprefix);
+        ret = cli_xml_snapshot_info_orig_vol(writer, doc, dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot's origin volume");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.vol-status", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get %s", key);
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "status",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* If the command is snap_driven then we need to show origin volume
-         * info. Else this is shown in the start of info display.*/
-        if (snap_driven) {
-                snprintf (key, sizeof (key), "%s.", keyprefix);
-                ret = cli_xml_snapshot_info_orig_vol (writer, doc, dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot's origin volume");
-                        goto out;
-                }
-        }
+    /* </snapVolume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapVolume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot info of individual snapshot
@@ -4812,112 +4626,104 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info_per_snap (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, char *keyprefix,
-                                gf_boolean_t snap_driven)
+cli_xml_snapshot_info_per_snap(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, char *keyprefix,
+                               gf_boolean_t snap_driven)
 {
-        char            key_buffer[PATH_MAX]    = "";
-        char           *buffer                  = NULL;
-        int             volcount                = 0;
-        int             ret                     = -1;
-        int             i                       = 0;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snapname",
-                  keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
+    char key_buffer[PATH_MAX] = "";
+    char *buffer = NULL;
+    int volcount = 0;
+    int ret = -1;
+    int i = 0;
+
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key_buffer, sizeof(key_buffer), "%s.snapname", keyprefix);
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ", key_buffer);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key_buffer, sizeof(key_buffer), "%s.snap-id", keyprefix);
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ", key_buffer);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key_buffer, sizeof(key_buffer), "%s.snap-desc", keyprefix);
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (!ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description",
+                                              "%s", buffer);
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description",
+                                              "%s", "");
+    }
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key_buffer, sizeof(key_buffer), "%s.snap-time", keyprefix);
+
+    ret = dict_get_str(dict, key_buffer, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ", keyprefix);
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"createTime", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key_buffer, sizeof(key_buffer), "%s.vol-count", keyprefix);
+    ret = dict_get_int32(dict, key_buffer, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Fail to get snap vol count");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volCount", "%d",
+                                          volcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, key_buffer, &volcount);
+    /* Display info of each snapshot volume */
+    for (i = 1; i <= volcount; i++) {
+        snprintf(key_buffer, sizeof(key_buffer), "%s.vol%d", keyprefix, i);
+
+        ret = cli_xml_snapshot_info_snap_vol(writer, doc, dict, key_buffer,
+                                             snap_driven);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snapname %s ",
-                        key_buffer);
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not list "
+                   "details of volume in a snap");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-id", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-id %s ",
-                                key_buffer);
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-desc", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (!ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "description",
-                                                "%s", buffer);
-        } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "description",
-                                                "%s", "");
-        }
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.snap-time", keyprefix);
-
-        ret = dict_get_str (dict, key_buffer, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to fetch snap-time %s ",
-                                keyprefix);
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *) "createTime",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key_buffer, sizeof (key_buffer), "%s.vol-count", keyprefix);
-        ret = dict_get_int32 (dict, key_buffer, &volcount);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Fail to get snap vol count");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                                               (xmlChar *) "volCount",
-                                               "%d", volcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, key_buffer, &volcount);
-        /* Display info of each snapshot volume */
-        for (i = 1 ; i <= volcount ; i++) {
-                snprintf (key_buffer, sizeof (key_buffer), "%s.vol%d",
-                          keyprefix, i);
-
-                ret = cli_xml_snapshot_info_snap_vol (writer, doc, dict,
-                                                      key_buffer, snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not list "
-                                        "details of volume in a snap");
-                        goto out;
-                }
-        }
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot info output in xml format.
@@ -4929,73 +4735,74 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_info (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_info(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int             ret             = -1;
-        int             i               = 0;
-        int             snapcount       = 0;
-        char            key [PATH_MAX]  = "";
-        gf_boolean_t    snap_driven     = _gf_false;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapInfo> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapInfo");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snap_driven = dict_get_str_boolean (dict, "snap-driven", _gf_false);
-
-        /* If the approach is volume based then we should display origin volume
-         * information first followed by per snap info*/
-        if (!snap_driven) {
-                ret = cli_xml_snapshot_info_orig_vol (writer, doc, dict, "");
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot's origin volume");
-                        goto out;
-                }
-        }
-
-        ret = dict_get_int32 (dict, "snapcount", &snapcount);
+    int ret = -1;
+    int i = 0;
+    int snapcount = 0;
+    char key[PATH_MAX] = "";
+    gf_boolean_t snap_driven = _gf_false;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapInfo> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapInfo");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snap_driven = dict_get_str_boolean(dict, "snap-driven", _gf_false);
+
+    /* If the approach is volume based then we should display origin volume
+     * information first followed by per snap info*/
+    if (!snap_driven) {
+        ret = cli_xml_snapshot_info_orig_vol(writer, doc, dict, "");
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to create "
+                   "xml output for snapshot's origin volume");
+            goto out;
         }
+    }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "count",
-                                               "%d", snapcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = dict_get_int32(dict, "snapcount", &snapcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snapcount");
+        goto out;
+    }
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          snapcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* Get snapshot info of individual snapshots */
-        for (i = 1; i <= snapcount; ++i) {
-                snprintf (key, sizeof (key), "snap%d", i);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = cli_xml_snapshot_info_per_snap (writer, doc, dict,
-                                                      key, snap_driven);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get %s ", key);
-                        goto out;
-                }
+    /* Get snapshot info of individual snapshots */
+    for (i = 1; i <= snapcount; ++i) {
+        snprintf(key, sizeof(key), "snap%d", i);
+
+        ret = cli_xml_snapshot_info_per_snap(writer, doc, dict, key,
+                                             snap_driven);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Could not get %s ", key);
+            goto out;
         }
+    }
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapInfo> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapInfo> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status of individual
@@ -5009,139 +4816,133 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_volume_status (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                dict_t *dict, const char *keyprefix)
+cli_xml_snapshot_volume_status(xmlTextWriterPtr writer, xmlDocPtr doc,
+                               dict_t *dict, const char *keyprefix)
 {
-        int     ret             = -1;
-        int     brickcount      = 0;
-        int     i               = 0;
-        int     pid             = 0;
-        char   *buffer          = NULL;
-        char    key[PATH_MAX]   = "";
+    int ret = -1;
+    int brickcount = 0;
+    int i = 0;
+    int pid = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    snprintf(key, sizeof(key), "%s.brickcount", keyprefix);
+
+    ret = dict_get_int32(dict, key, &brickcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"brickCount", "%d",
+                                          brickcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* Get status of every brick belonging to the snapshot volume */
+    for (i = 0; i < brickcount; i++) {
+        /* <snapInfo> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"brick");
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "%s.brick%d.path", keyprefix, i);
+
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Brick Path");
+            /*
+             * If path itself is not present, then end *
+             * this brick's status and continue to the *
+             * brick                                   *
+             */
+            ret = xmlTextWriterEndElement(writer);
+            XML_RET_CHECK_AND_GOTO(ret, out);
+            continue;
+        }
+
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"path", "%s",
+                                              buffer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "%s.brick%d.vgname", keyprefix, i);
+
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Volume Group");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"volumeGroup", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"volumeGroup", "%s", buffer);
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.brickcount", keyprefix);
+        snprintf(key, sizeof(key), "%s.brick%d.status", keyprefix, i);
 
-        ret = dict_get_int32 (dict, key, &brickcount);
+        ret = dict_get_str(dict, key, &buffer);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to fetch brickcount");
-                goto out;
-        }
+            gf_log("cli", GF_LOG_INFO, "Unable to get Brick Running");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"brick_running", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"brick_running", "%s", buffer);
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "brickCount",
-                                               "%d", brickcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* Get status of every brick belonging to the snapshot volume */
-        for (i = 0 ; i < brickcount ; i++) {
-                /* <snapInfo> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.path", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to get Brick Path");
-                        /*
-                         * If path itself is not present, then end *
-                         * this brick's status and continue to the *
-                         * brick                                   *
-                         */
-                        ret = xmlTextWriterEndElement (writer);
-                        XML_RET_CHECK_AND_GOTO (ret, out);
-                        continue;
-                }
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *) "path", "%s", buffer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.vgname",
-                          keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                "Unable to get Volume Group");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                              (xmlChar *) "volumeGroup", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                       (xmlChar *) "volumeGroup", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.status", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO,
-                                "Unable to get Brick Running");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                            (xmlChar *) "brick_running", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                     (xmlChar *) "brick_running", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.pid", keyprefix, i);
-
-                ret = dict_get_int32 (dict, key, &pid);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_INFO, "Unable to get pid");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                      (xmlChar *) "pid", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                  (xmlChar *) "pid", "%d", pid);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.data", keyprefix, i);
-
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                        "Unable to get Data Percent");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                          (xmlChar *) "data_percentage", "N/A");
-                } else
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                   (xmlChar *) "data_percentage", "%s", buffer);
-
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.brick%d.lvsize",
-                          keyprefix, i);
-                ret = dict_get_str (dict, key, &buffer);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Unable to get LV Size");
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                                 (xmlChar *) "lvSize", "N/A");
-                } else {
-                        /* Truncate any newline character */
-                        buffer = strtok (buffer, "\n");
-
-                        ret = xmlTextWriterWriteFormatElement (writer,
-                                          (xmlChar *) "lvSize", "%s", buffer);
-                }
+        snprintf(key, sizeof(key), "%s.brick%d.pid", keyprefix, i);
+
+        ret = dict_get_int32(dict, key, &pid);
+        if (ret) {
+            gf_log("cli", GF_LOG_INFO, "Unable to get pid");
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid",
+                                                  "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"pid",
+                                                  "%d", pid);
 
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                /* </brick> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        snprintf(key, sizeof(key), "%s.brick%d.data", keyprefix, i);
+
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get Data Percent");
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"data_percentage", "N/A");
+        } else
+            ret = xmlTextWriterWriteFormatElement(
+                writer, (xmlChar *)"data_percentage", "%s", buffer);
+
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        snprintf(key, sizeof(key), "%s.brick%d.lvsize", keyprefix, i);
+        ret = dict_get_str(dict, key, &buffer);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR, "Unable to get LV Size");
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lvSize",
+                                                  "N/A");
+        } else {
+            /* Truncate any newline character */
+            buffer = strtok(buffer, "\n");
+
+            ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"lvSize",
+                                                  "%s", buffer);
         }
 
+        XML_RET_CHECK_AND_GOTO(ret, out);
+
+        /* </brick> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status of individual
@@ -5154,87 +4955,85 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_status_per_snap (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                  dict_t *dict, const char *keyprefix)
+cli_xml_snapshot_status_per_snap(xmlTextWriterPtr writer, xmlDocPtr doc,
+                                 dict_t *dict, const char *keyprefix)
 {
-        int     ret             = -1;
-        int     volcount        = 0;
-        int     i               = 0;
-        char   *buffer          = NULL;
-        char    key [PATH_MAX]  = "";
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-        GF_ASSERT (keyprefix);
-
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.snapname", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snapname");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.uuid", keyprefix);
-
-        ret = dict_get_str (dict, key, &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get snap UUID");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    int volcount = 0;
+    int i = 0;
+    char *buffer = NULL;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+    GF_ASSERT(keyprefix);
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.snapname", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snapname");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.uuid", keyprefix);
+
+    ret = dict_get_str(dict, key, &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get snap UUID");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    snprintf(key, sizeof(key), "%s.volcount", keyprefix);
+
+    ret = dict_get_int32(dict, key, &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Unable to get volume count");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"volCount", "%d",
+                                          volcount);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* Get snapshot status of individual snapshot volume */
+    for (i = 0; i < volcount; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        snprintf (key, sizeof (key), "%s.volcount", keyprefix);
+        snprintf(key, sizeof(key), "%s.vol%d", keyprefix, i);
 
-        ret = dict_get_int32 (dict, key, &volcount);
+        ret = cli_xml_snapshot_volume_status(writer, doc, dict, key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Unable to get volume count");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snap volume status");
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "volCount",
-                                               "%d", volcount);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* Get snapshot status of individual snapshot volume */
-        for (i = 0 ; i < volcount ; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (key, sizeof (key), "%s.vol%d", keyprefix, i);
-
-                ret = cli_xml_snapshot_volume_status (writer, doc,
-                                                             dict, key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR,
-                                        "Could not get snap volume status");
-                        goto out;
-                }
-
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        /* </volume> */
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot status output in xml format.
@@ -5246,64 +5045,63 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_status (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_status(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int     ret             = -1;
-        int     snapcount       = 0;
-        int     i               = 0;
-        int     status_cmd      = 0;
-        char    key [PATH_MAX]  = "";
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "sub-cmd", &status_cmd);
+    int ret = -1;
+    int snapcount = 0;
+    int i = 0;
+    int status_cmd = 0;
+    char key[PATH_MAX] = "";
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "sub-cmd", &status_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch status type");
+        goto out;
+    }
+
+    if ((GF_SNAP_STATUS_TYPE_SNAP == status_cmd) ||
+        (GF_SNAP_STATUS_TYPE_ITER == status_cmd)) {
+        snapcount = 1;
+    } else {
+        ret = dict_get_int32(dict, "status.snapcount", &snapcount);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch status type");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not get snapcount");
+            goto out;
         }
 
-        if ((GF_SNAP_STATUS_TYPE_SNAP == status_cmd) ||
-            (GF_SNAP_STATUS_TYPE_ITER == status_cmd)) {
-                snapcount = 1;
-        } else {
-                ret = dict_get_int32 (dict, "status.snapcount", &snapcount);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not get snapcount");
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "count",
-                                                       "%d", snapcount);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                              snapcount);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        for (i = 0 ; i < snapcount; i++) {
-                snprintf (key, sizeof (key), "status.snap%d", i);
+    for (i = 0; i < snapcount; i++) {
+        snprintf(key, sizeof(key), "status.snap%d", i);
 
-                ret = cli_xml_snapshot_status_per_snap (writer, doc,
-                                                               dict, key);
-                if (ret < 0) {
-                        gf_log ("cli", GF_LOG_ERROR, "failed to create xml "
-                                "output for snapshot status");
-                        goto out;
-                }
+        ret = cli_xml_snapshot_status_per_snap(writer, doc, dict, key);
+        if (ret < 0) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "failed to create xml "
+                   "output for snapshot status");
+            goto out;
         }
+    }
 
-        /* </snapStatus> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapStatus> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config show output in xml format.
@@ -5315,153 +5113,149 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config_show (xmlTextWriterPtr writer,
-                              xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_config_show(xmlTextWriterPtr writer, xmlDocPtr doc,
+                             dict_t *dict)
 {
-        int             ret             = -1;
-        uint64_t        i               = 0;
-        uint64_t        value           = 0;
-        uint64_t        volcount        = 0;
-        char            buf[PATH_MAX]   = "";
-        char           *str_value       = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <systemConfig> */
-        ret = xmlTextWriterStartElement (writer,
-                        (xmlChar *)"systemConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "snap-max-hard-limit");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "hardLimit", "%"PRIu64, value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t i = 0;
+    uint64_t value = 0;
+    uint64_t volcount = 0;
+    char buf[PATH_MAX] = "";
+    char *str_value = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <systemConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"systemConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "snap-max-hard-limit");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hardLimit",
+                                          "%" PRIu64, value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "snap-max-soft-limit");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"softLimit",
+                                          "%" PRIu64 "%%", value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "auto-delete", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch auto-delete");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"autoDelete", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snap-activate-on-create", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Could not fetch snap-activate-on-create-delete");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"activateOnCreate",
+                                          "%s", str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </systemConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <volumeConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volumeConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_uint64(dict, "voldisplaycount", &volcount);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch volcount");
+        goto out;
+    }
+
+    /* Get config of all the volumes */
+    for (i = 0; i < volcount; i++) {
+        /* <volume> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volume");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-volname", i);
+        ret = dict_get_str(dict, buf, &str_value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "snap-max-soft-limit");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "softLimit",
-                        "%"PRIu64"%%", value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              str_value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "auto-delete", &str_value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-snap-max-hard-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch auto-delete");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "autoDelete", "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"hardLimit",
+                                              "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_str (dict, "snap-activate-on-create", &str_value);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-active-hard-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Could not fetch snap-activate-on-create-delete");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR,
+                   "Could not fetch"
+                   " effective snap_max_hard_limit for "
+                   "%s",
+                   str_value);
+            goto out;
         }
 
-        ret = xmlTextWriterWriteFormatElement (writer,
-                        (xmlChar *) "activateOnCreate", "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </systemConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <volumeConfig> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volumeConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"effectiveHardLimit", "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_uint64 (dict, "voldisplaycount", &volcount);
+        snprintf(buf, sizeof(buf), "volume%" PRIu64 "-snap-max-soft-limit", i);
+        ret = dict_get_uint64(dict, buf, &value);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch volcount");
-                goto out;
+            gf_log("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
+            goto out;
         }
 
-        /* Get config of all the volumes */
-        for (i = 0; i < volcount; i++) {
-                /* <volume> */
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i);
-                ret = dict_get_str (dict, buf, &str_value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "name", "%s", str_value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-snap-max-hard-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "hardLimit", "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-active-hard-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch"
-                                " effective snap_max_hard_limit for "
-                                "%s", str_value);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "effectiveHardLimit",
-                                "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                snprintf (buf, sizeof(buf),
-                                "volume%"PRIu64"-snap-max-soft-limit", i);
-                ret = dict_get_uint64 (dict, buf, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Could not fetch %s", buf);
-                        goto out;
-                }
-
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                        (xmlChar *) "softLimit",
-                                        "%"PRIu64, value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                /* </volume> */
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"softLimit",
+                                              "%" PRIu64, value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
         /* </volume> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        ret = 0;
+    /* </volume> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config set output in xml format.
@@ -5473,87 +5267,84 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config_set (xmlTextWriterPtr writer, xmlDocPtr doc,
-                             dict_t *dict)
+cli_xml_snapshot_config_set(xmlTextWriterPtr writer, xmlDocPtr doc,
+                            dict_t *dict)
 {
-        int             ret             = -1;
-        uint64_t        hard_limit      = 0;
-        uint64_t        soft_limit      = 0;
-        char           *volname         = NULL;
-        char           *auto_delete     = NULL;
-        char           *snap_activate   = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* This is optional parameter therefore ignore the error */
-        ret = dict_get_uint64 (dict, "snap-max-hard-limit", &hard_limit);
-        /* This is optional parameter therefore ignore the error */
-        ret = dict_get_uint64 (dict, "snap-max-soft-limit", &soft_limit);
-        ret = dict_get_str (dict, "auto-delete", &auto_delete);
-        ret = dict_get_str (dict, "snap-activate-on-create", &snap_activate);
-
-        if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
-                ret = -1;
-                gf_log ("cli", GF_LOG_ERROR, "At least one option from "
-                        "snap-max-hard-limit, snap-max-soft-limit, auto-delete"
-                        " and snap-activate-on-create should be set");
-                goto out;
-        }
-
-        /* Ignore the error, as volname is optional */
-        ret = dict_get_str (dict, "volname", &volname);
-
-        if (NULL == volname) {
-                /* <systemConfig> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"systemConfig");
-        } else {
-                /* <volumeConfig> */
-                ret = xmlTextWriterStartElement (writer,
-                                                 (xmlChar *)"volumeConfig");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+    uint64_t hard_limit = 0;
+    uint64_t soft_limit = 0;
+    char *volname = NULL;
+    char *auto_delete = NULL;
+    char *snap_activate = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* This is optional parameter therefore ignore the error */
+    ret = dict_get_uint64(dict, "snap-max-hard-limit", &hard_limit);
+    /* This is optional parameter therefore ignore the error */
+    ret = dict_get_uint64(dict, "snap-max-soft-limit", &soft_limit);
+    ret = dict_get_str(dict, "auto-delete", &auto_delete);
+    ret = dict_get_str(dict, "snap-activate-on-create", &snap_activate);
+
+    if (!hard_limit && !soft_limit && !auto_delete && !snap_activate) {
+        ret = -1;
+        gf_log("cli", GF_LOG_ERROR,
+               "At least one option from "
+               "snap-max-hard-limit, snap-max-soft-limit, auto-delete"
+               " and snap-activate-on-create should be set");
+        goto out;
+    }
+
+    /* Ignore the error, as volname is optional */
+    ret = dict_get_str(dict, "volname", &volname);
+
+    if (NULL == volname) {
+        /* <systemConfig> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"systemConfig");
+    } else {
+        /* <volumeConfig> */
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"volumeConfig");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "name", "%s", volname);
-        }
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                              volname);
+    }
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        if (hard_limit) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                (xmlChar *) "newHardLimit",
-                                                "%"PRIu64, hard_limit);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (hard_limit) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"newHardLimit",
+                                              "%" PRIu64, hard_limit);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (soft_limit) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "newSoftLimit",
-                                "%"PRIu64, soft_limit);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (soft_limit) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"newSoftLimit",
+                                              "%" PRIu64, soft_limit);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (auto_delete) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                (xmlChar *) "autoDelete", "%s", auto_delete);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (auto_delete) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"autoDelete",
+                                              "%s", auto_delete);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        if (snap_activate) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                           (xmlChar *) "activateOnCreate", "%s", snap_activate);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
+    if (snap_activate) {
+        ret = xmlTextWriterWriteFormatElement(
+            writer, (xmlChar *)"activateOnCreate", "%s", snap_activate);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
 
-        /* </volumeConfig> or </systemConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </volumeConfig> or </systemConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot config output in xml format.
@@ -5565,58 +5356,60 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_config (xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
+cli_xml_snapshot_config(xmlTextWriterPtr writer, xmlDocPtr doc, dict_t *dict)
 {
-        int             ret             = -1;
-        int             config_command  = 0;
+    int ret = -1;
+    int config_command = 0;
 
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
 
-        /* <snapConfig> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapConfig");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapConfig> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapConfig");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (dict, "config-command", &config_command);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Could not fetch config type");
-                goto out;
-        }
+    ret = dict_get_int32(dict, "config-command", &config_command);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Could not fetch config type");
+        goto out;
+    }
 
-        switch (config_command) {
+    switch (config_command) {
         case GF_SNAP_CONFIG_TYPE_SET:
-                ret = cli_xml_snapshot_config_set (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create xml "
-                                "output for snapshot config set command");
-                        goto out;
-                }
+            ret = cli_xml_snapshot_config_set(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create xml "
+                       "output for snapshot config set command");
+                goto out;
+            }
 
-                break;
+            break;
         case GF_SNAP_CONFIG_DISPLAY:
-                ret = cli_xml_snapshot_config_show (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create xml "
-                                "output for snapshot config show command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_config_show(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create xml "
+                       "output for snapshot config show command");
+                goto out;
+            }
+            break;
         default:
-                gf_log ("cli", GF_LOG_ERROR, "Unknown config command :%d",
-                        config_command);
-                ret = -1;
-                goto out;
-        }
+            gf_log("cli", GF_LOG_ERROR, "Unknown config command :%d",
+                   config_command);
+            ret = -1;
+            goto out;
+    }
 
-        /* </snapConfig> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapConfig> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 /* This function will generate snapshot activate or
@@ -5629,67 +5422,66 @@ out:
  * @return 0 on success and -1 on failure
  */
 static int
-cli_xml_snapshot_activate_deactivate (xmlTextWriterPtr writer, xmlDocPtr doc,
-                                      dict_t *dict, int cmd)
+cli_xml_snapshot_activate_deactivate(xmlTextWriterPtr writer, xmlDocPtr doc,
+                                     dict_t *dict, int cmd)
 {
-        int     ret     = -1;
-        char   *buffer  = NULL;
-        char   *tag     = NULL;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        if (GF_SNAP_OPTION_TYPE_ACTIVATE == cmd) {
-                tag = "snapActivate";
-        } else if (GF_SNAP_OPTION_TYPE_DEACTIVATE == cmd) {
-                tag = "snapDeactivate";
-        } else {
-                gf_log ("cli", GF_LOG_ERROR, "invalid command %d", cmd);
-                goto out;
-        }
-
-        /* <snapActivate> or <snapDeactivate> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)tag);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapuuid", &buffer);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto out;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", buffer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        /* </snapActivate> or </snapDeactivate> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = 0;
+    int ret = -1;
+    char *buffer = NULL;
+    char *tag = NULL;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    if (GF_SNAP_OPTION_TYPE_ACTIVATE == cmd) {
+        tag = "snapActivate";
+    } else if (GF_SNAP_OPTION_TYPE_DEACTIVATE == cmd) {
+        tag = "snapDeactivate";
+    } else {
+        gf_log("cli", GF_LOG_ERROR, "invalid command %d", cmd);
+        goto out;
+    }
+
+    /* <snapActivate> or <snapDeactivate> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)tag);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapuuid", &buffer);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto out;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          buffer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    /* </snapActivate> or </snapDeactivate> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 #endif /* HAVE_LIB_XML */
 
@@ -5703,190 +5495,183 @@ out:
  * @return 0 on success and -1 on failure
  */
 int
-cli_xml_snapshot_delete (cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp)
+cli_xml_snapshot_delete(cli_local_t *local, dict_t *dict, gf_cli_rsp *rsp)
 {
-        int     ret             = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        char   *str_value       = NULL;
-        xmlTextWriterPtr writer = local->writer;
-        xmlDocPtr doc           = local->doc;
-
-        GF_ASSERT (writer);
-        GF_ASSERT (doc);
-        GF_ASSERT (dict);
-
-        /* <snapshot> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"snapshot");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, "snapname", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap name");
-                goto xmlend;
-        }
-
-        if (!rsp->op_ret) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "status",
-                                                       "Success");
-        } else {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *) "status",
-                                                       "Failure");
-                XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-                ret = cli_xml_output_common (writer, rsp->op_ret,
-                                             rsp->op_errno,
-                                             rsp->op_errstr);
-        }
-        XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "name",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, xmlend);
-
-        ret = dict_get_str (dict, "snapuuid", &str_value);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snap uuid");
-                goto xmlend;
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *) "uuid",
-                                               "%s", str_value);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    char *str_value = NULL;
+    xmlTextWriterPtr writer = local->writer;
+    xmlDocPtr doc = local->doc;
+
+    GF_ASSERT(writer);
+    GF_ASSERT(doc);
+    GF_ASSERT(dict);
+
+    /* <snapshot> */
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"snapshot");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_str(dict, "snapname", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap name");
+        goto xmlend;
+    }
+
+    if (!rsp->op_ret) {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status",
+                                              "Success");
+    } else {
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"status",
+                                              "Failure");
+        XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+        ret = cli_xml_output_common(writer, rsp->op_ret, rsp->op_errno,
+                                    rsp->op_errstr);
+    }
+    XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, xmlend);
+
+    ret = dict_get_str(dict, "snapuuid", &str_value);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get snap uuid");
+        goto xmlend;
+    }
+
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"uuid", "%s",
+                                          str_value);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 xmlend:
-        /* </snapshot> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshot> */
+    ret = xmlTextWriterEndElement(writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 #endif /* HAVE_LIB_XML */
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_output_snap_status_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr)
+cli_xml_output_snap_status_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                     op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "snapStatus");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapStatus");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_status_end (cli_local_t *local)
+cli_xml_output_snap_status_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapStatus> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </snapStatus> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_delete_begin (cli_local_t *local, int op_ret, int op_errno,
-                                  char *op_errstr)
+cli_xml_output_snap_delete_begin(cli_local_t *local, int op_ret, int op_errno,
+                                 char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int ret = -1;
-        int delete_cmd = -1;
+    int ret = -1;
+    int delete_cmd = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        ret = cli_begin_xml_output (&(local->writer), &(local->doc));
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_begin_xml_output(&(local->writer), &(local->doc));
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = dict_get_int32 (local->dict, "sub-cmd", &delete_cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
-                goto out;
-        }
+    ret = dict_get_int32(local->dict, "sub-cmd", &delete_cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Failed to get sub-cmd");
+        goto out;
+    }
 
-        ret = cli_xml_output_common (local->writer, op_ret, op_errno,
-                                             op_errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = cli_xml_output_common(local->writer, op_ret, op_errno, op_errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapStatus> */
-        ret = xmlTextWriterStartElement (local->writer,
-                                         (xmlChar *) "snapDelete");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapStatus> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapDelete");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* <snapshots> */
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"snapshots");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* <snapshots> */
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"snapshots");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_xml_output_snap_delete_end (cli_local_t *local)
+cli_xml_output_snap_delete_end(cli_local_t *local)
 {
 #if (HAVE_LIB_XML)
-        int     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (local);
+    GF_ASSERT(local);
 
-        /* </snapshots> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    /* </snapshots> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        /* </snapDelete> */
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO(ret, out);
+    /* </snapDelete> */
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = cli_end_xml_output (local->writer, local->doc);
+    ret = cli_end_xml_output(local->writer, local->doc);
 out:
-        gf_log ("cli", GF_LOG_TRACE, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_TRACE, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 /* This function will generate xml output for all the snapshot commands
@@ -5900,493 +5685,484 @@ out:
  * @return 0 on success and -1 on failure
  */
 int
-cli_xml_output_snapshot (int cmd_type, dict_t *dict, int op_ret,
-                         int op_errno, char *op_errstr)
+cli_xml_output_snapshot(int cmd_type, dict_t *dict, int op_ret, int op_errno,
+                        char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     ret     = -1;
-        xmlTextWriterPtr        writer  = NULL;
-        xmlDocPtr               doc     = NULL;
-
-        GF_ASSERT (dict);
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml begin block");
-                goto out;
-        }
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml common block");
-                goto out;
-        }
-
-        /* In case of command failure just printing the error message is good
-         * enough */
-        if (0 != op_ret) {
-                goto end;
-        }
-
-        switch (cmd_type) {
+    int ret = -1;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+
+    GF_ASSERT(dict);
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml begin block");
+        goto out;
+    }
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml common block");
+        goto out;
+    }
+
+    /* In case of command failure just printing the error message is good
+     * enough */
+    if (0 != op_ret) {
+        goto end;
+    }
+
+    switch (cmd_type) {
         case GF_SNAP_OPTION_TYPE_CREATE:
-                ret = cli_xml_snapshot_create (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot create command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_create(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot create command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_CLONE:
-                ret = cli_xml_snapshot_clone (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot clone command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_clone(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot clone command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_RESTORE:
-                ret = cli_xml_snapshot_restore (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot restore command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_restore(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot restore command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_LIST:
-                ret = cli_xml_snapshot_list (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot list command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_list(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot list command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_STATUS:
-                ret = cli_xml_snapshot_status (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create"
-                                "xml output for snapshot status command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_status(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create"
+                       "xml output for snapshot status command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_INFO:
-                ret = cli_xml_snapshot_info (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot info command");
-                        goto out;
-                }
-                break;
+            ret = cli_xml_snapshot_info(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot info command");
+                goto out;
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_ACTIVATE:
         case GF_SNAP_OPTION_TYPE_DEACTIVATE:
-                ret = cli_xml_snapshot_activate_deactivate (writer, doc,
-                                                            dict, cmd_type);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot config command");
-                }
-                break;
+            ret = cli_xml_snapshot_activate_deactivate(writer, doc, dict,
+                                                       cmd_type);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot config command");
+            }
+            break;
         case GF_SNAP_OPTION_TYPE_CONFIG:
-                ret = cli_xml_snapshot_config (writer, doc, dict);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to create "
-                                "xml output for snapshot config command");
-                }
-                break;
+            ret = cli_xml_snapshot_config(writer, doc, dict);
+            if (ret) {
+                gf_log("cli", GF_LOG_ERROR,
+                       "Failed to create "
+                       "xml output for snapshot config command");
+            }
+            break;
         default:
-                gf_log ("cli", GF_LOG_ERROR,
-                        "Unexpected snapshot command: %d", cmd_type);
-                goto out;
-        }
+            gf_log("cli", GF_LOG_ERROR, "Unexpected snapshot command: %d",
+                   cmd_type);
+            goto out;
+    }
 
 end:
-        ret = cli_end_xml_output (writer, doc);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to output "
-                        "xml end block");
-                goto out;
-        }
-
-        ret = 0;
+    ret = cli_end_xml_output(writer, doc);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to output "
+               "xml end block");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_xml_snapshot_begin_composite_op (cli_local_t *local)
+cli_xml_snapshot_begin_composite_op(cli_local_t *local)
 {
-        int ret         = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        int cmd         = -1;
-        int type        =  -1;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                ret = 0;
-                goto out;
-        }
-
-        if (cmd == GF_SNAP_STATUS_TYPE_ITER ||
-            cmd == GF_SNAP_DELETE_TYPE_SNAP){
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapshot "
-                        "command type from dictionary");
-                goto out;
-        }
-
-        if (GF_SNAP_OPTION_TYPE_STATUS == type)
-                ret = cli_xml_output_snap_status_begin (local, 0, 0, NULL);
-        else if (GF_SNAP_OPTION_TYPE_DELETE == type)
-                ret = cli_xml_output_snap_delete_begin (local, 0, 0, NULL);
+    int cmd = -1;
+    int type = -1;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "sub-cmd");
+        ret = 0;
+        goto out;
+    }
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Error creating xml output");
-                goto out;
-        }
+    if (cmd == GF_SNAP_STATUS_TYPE_ITER || cmd == GF_SNAP_DELETE_TYPE_SNAP) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get snapshot "
+               "command type from dictionary");
+        goto out;
+    }
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type)
+        ret = cli_xml_output_snap_status_begin(local, 0, 0, NULL);
+    else if (GF_SNAP_OPTION_TYPE_DELETE == type)
+        ret = cli_xml_output_snap_delete_begin(local, 0, 0, NULL);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "Error creating xml output");
+        goto out;
+    }
 
 #endif /* HAVE_LIB_XML */
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_snapshot_end_composite_op (cli_local_t *local)
+cli_xml_snapshot_end_composite_op(cli_local_t *local)
 {
-        int ret         = -1;
+    int ret = -1;
 #ifdef HAVE_LIB_XML
-        int cmd         = -1;
-        int type        = -1;
-
-        ret = dict_get_int32 (local->dict, "sub-cmd", &cmd);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                        "sub-cmd");
-                ret = 0;
-                goto out;
-        }
-
-        if (cmd == GF_SNAP_STATUS_TYPE_ITER ||
-            cmd == GF_SNAP_DELETE_TYPE_SNAP){
-                ret = 0;
-                goto out;
-        }
-
-        ret = dict_get_int32 (local->dict, "type", &type);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to get snapshot "
-                        "command type from dictionary");
-                goto out;
-        }
-
-        if (GF_SNAP_OPTION_TYPE_STATUS == type)
-                ret = cli_xml_output_snap_status_end (local);
-        else if (GF_SNAP_OPTION_TYPE_DELETE == type)
-                ret = cli_xml_output_snap_delete_end (local);
+    int cmd = -1;
+    int type = -1;
+
+    ret = dict_get_int32(local->dict, "sub-cmd", &cmd);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get "
+               "sub-cmd");
+        ret = 0;
+        goto out;
+    }
 
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Error creating xml "
-                                "output");
-                goto out;
-        }
-#endif /* HAVE_LIB_XML */
+    if (cmd == GF_SNAP_STATUS_TYPE_ITER || cmd == GF_SNAP_DELETE_TYPE_SNAP) {
         ret = 0;
+        goto out;
+    }
+
+    ret = dict_get_int32(local->dict, "type", &type);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to get snapshot "
+               "command type from dictionary");
+        goto out;
+    }
+
+    if (GF_SNAP_OPTION_TYPE_STATUS == type)
+        ret = cli_xml_output_snap_status_end(local);
+    else if (GF_SNAP_OPTION_TYPE_DELETE == type)
+        ret = cli_xml_output_snap_delete_end(local);
+
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Error creating xml "
+               "output");
+        goto out;
+    }
+#endif /* HAVE_LIB_XML */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-cli_xml_snapshot_status_single_snap (cli_local_t *local, dict_t *dict,
-                                     char *key)
+cli_xml_snapshot_status_single_snap(cli_local_t *local, dict_t *dict, char *key)
 {
 #if (HAVE_LIB_XML)
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("cli", (local != NULL), out);
-        GF_VALIDATE_OR_GOTO ("cli", (dict != NULL), out);
-        GF_VALIDATE_OR_GOTO ("cli", (key != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (local != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (dict != NULL), out);
+    GF_VALIDATE_OR_GOTO("cli", (key != NULL), out);
 
-        ret = cli_xml_snapshot_status_per_snap (local->writer, local->doc, dict,
-                                                key);
+    ret = cli_xml_snapshot_status_per_snap(local->writer, local->doc, dict,
+                                           key);
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_xml_output_vol_getopts (dict_t *dict, int op_ret, int op_errno,
-                            char *op_errstr)
+cli_xml_output_vol_getopts(dict_t *dict, int op_ret, int op_errno,
+                           char *op_errstr)
 {
 #if (HAVE_LIB_XML)
-        int                     i = 0;
-        int                     ret = -1;
-        int                     count = 0;
-        xmlTextWriterPtr        writer = NULL;
-        xmlDocPtr               doc = NULL;
-        char                    *key = NULL;
-        char                    *value = NULL;
-        char                    dict_key[50] = {0,};
-
-        ret = cli_begin_xml_output (&writer, &doc);
-        if (ret)
-                goto out;
-
-        ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
-        if (ret)
-                goto out;
-
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volGetopts");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_int32 (dict, "count", &count);
+    int i = 0;
+    int ret = -1;
+    int count = 0;
+    xmlTextWriterPtr writer = NULL;
+    xmlDocPtr doc = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char dict_key[50] = {
+        0,
+    };
+
+    ret = cli_begin_xml_output(&writer, &doc);
+    if (ret)
+        goto out;
+
+    ret = cli_xml_output_common(writer, op_ret, op_errno, op_errstr);
+    if (ret)
+        goto out;
+
+    ret = xmlTextWriterStartElement(writer, (xmlChar *)"volGetopts");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = dict_get_int32(dict, "count", &count);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Failed to retrieve count "
+               "from the dictionary");
+        goto out;
+    }
+    if (count <= 0) {
+        gf_log("cli", GF_LOG_ERROR,
+               "Value of count :%d is "
+               "invalid",
+               count);
+        ret = -1;
+        goto out;
+    }
+    ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"count", "%d",
+                                          count);
+
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    for (i = 1; i <= count; i++) {
+        sprintf(dict_key, "key%d", i);
+        ret = dict_get_str(dict, dict_key, &key);
         if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "Failed to retrieve count "
-                        "from the dictionary");
-                goto out;
-        }
-        if (count <= 0) {
-                gf_log ("cli", GF_LOG_ERROR, "Value of count :%d is "
-                        "invalid", count);
-                ret = -1;
-                goto out;
-        }
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
-                                               "%d", count);
-
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        for (i=1; i<=count; i++) {
-                sprintf (dict_key, "key%d", i);
-                ret = dict_get_str (dict, dict_key, &key);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to"
-                                " retrieve %s from the "
-                                "dictionary", dict_key);
-                        goto out;
-                }
-                sprintf (dict_key, "value%d", i);
-                ret = dict_get_str (dict, dict_key, &value);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to "
-                                "retrieve key value for %s from"
-                                "the dictionary", dict_key);
-                        goto out;
-                }
-                ret = xmlTextWriterStartElement (writer, (xmlChar *)"Opt");
-                XML_RET_CHECK_AND_GOTO (ret, out);
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to"
+                   " retrieve %s from the "
+                   "dictionary",
+                   dict_key);
+            goto out;
+        }
+        sprintf(dict_key, "value%d", i);
+        ret = dict_get_str(dict, dict_key, &value);
+        if (ret) {
+            gf_log("cli", GF_LOG_ERROR,
+                   "Failed to "
+                   "retrieve key value for %s from"
+                   "the dictionary",
+                   dict_key);
+            goto out;
+        }
+        ret = xmlTextWriterStartElement(writer, (xmlChar *)"Opt");
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"Option",
-                                                       "%s", key);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"Option", "%s",
+                                              key);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"Value",
-                                                       "%s", value);
-                XML_RET_CHECK_AND_GOTO (ret, out);
+        ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"Value", "%s",
+                                              value);
+        XML_RET_CHECK_AND_GOTO(ret, out);
 
-                ret = xmlTextWriterEndElement (writer);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-        ret = cli_end_xml_output (writer, doc);
+        ret = xmlTextWriterEndElement(writer);
+        XML_RET_CHECK_AND_GOTO(ret, out);
+    }
+    ret = cli_end_xml_output(writer, doc);
 
 out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_quota_list_xml_error (cli_local_t *local, char *path,
-                          char *errstr)
+cli_quota_list_xml_error(cli_local_t *local, char *path, char *errstr)
 {
 #if (HAVE_LIB_XML)
-        int     ret     =       -1;
+    int ret = -1;
 
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"errstr",
-                                               "%s", errstr);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"errstr",
+                                          "%s", errstr);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int
-cli_quota_xml_output (cli_local_t *local, char *path, int64_t hl_str,
-                      char *sl_final, int64_t sl_num, int64_t used,
-                      int64_t avail, char *sl, char *hl,
-                      gf_boolean_t limit_set)
+cli_quota_xml_output(cli_local_t *local, char *path, int64_t hl_str,
+                     char *sl_final, int64_t sl_num, int64_t used,
+                     int64_t avail, char *sl, char *hl, gf_boolean_t limit_set)
 {
 #if (HAVE_LIB_XML)
-        int     ret             = -1;
-
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"path",
-                                               "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hard_limit",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, hl_str);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_percent",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl_final);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_value",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, sl_num);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"used_space",
-                                               "%"PRId64, used);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"avail_space",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, avail);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                              (xmlChar *)"sl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
+
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hard_limit", !limit_set ? "N/A" : "%" PRId64,
+        hl_str);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"soft_limit_percent",
+                                          !limit_set ? "N/A" : "%s", sl_final);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"soft_limit_value",
+        !limit_set ? "N/A" : "%" PRId64, sl_num);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"used_space", "%" PRId64, used);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"avail_space",
+        !limit_set ? "N/A" : "%" PRId64, avail);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"sl_exceeded", !limit_set ? "N/A" : "%s", sl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hl_exceeded", !limit_set ? "N/A" : "%s", hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
+
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
 
 int
-cli_quota_object_xml_output (cli_local_t *local, char *path, char *sl_str,
-                             int64_t sl_val, quota_limits_t *limits,
-                             quota_meta_t *used_space, int64_t avail,
-                             char *sl, char *hl, gf_boolean_t limit_set)
+cli_quota_object_xml_output(cli_local_t *local, char *path, char *sl_str,
+                            int64_t sl_val, quota_limits_t *limits,
+                            quota_meta_t *used_space, int64_t avail, char *sl,
+                            char *hl, gf_boolean_t limit_set)
 {
 #if (HAVE_LIB_XML)
-        int     ret             = -1;
-
-        ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"limit");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"path",
-                                              "%s", path);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    int ret = -1;
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hard_limit",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, limits->hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterStartElement(local->writer, (xmlChar *)"limit");
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_percent",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl_str);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"path",
+                                          "%s", path);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"soft_limit_value",
-                                               !limit_set ? "N/A" :
-                                               "%"PRIu64, sl_val);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hard_limit", !limit_set ? "N/A" : "%" PRId64,
+        limits->hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"file_count",
-                                               "%"PRId64,
-                                               used_space->file_count);
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"soft_limit_percent",
+                                          !limit_set ? "N/A" : "%s", sl_str);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"soft_limit_value",
+        !limit_set ? "N/A" : "%" PRIu64, sl_val);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"dir_count",
-                                               "%"PRIu64,
-                                               used_space->dir_count);
+    ret = xmlTextWriterWriteFormatElement(local->writer,
+                                          (xmlChar *)"file_count", "%" PRId64,
+                                          used_space->file_count);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"dir_count",
+                                          "%" PRIu64, used_space->dir_count);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"available",
-                                               !limit_set ? "N/A" :
-                                               "%"PRId64, avail);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(local->writer, (xmlChar *)"available",
+                                          !limit_set ? "N/A" : "%" PRId64,
+                                          avail);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"sl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", sl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterWriteFormatElement (local->writer,
-                                               (xmlChar *)"hl_exceeded",
-                                               !limit_set ? "N/A" :
-                                               "%s", hl);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"sl_exceeded", !limit_set ? "N/A" : "%s", sl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
+    ret = xmlTextWriterWriteFormatElement(
+        local->writer, (xmlChar *)"hl_exceeded", !limit_set ? "N/A" : "%s", hl);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
-        ret = xmlTextWriterEndElement (local->writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
+    ret = xmlTextWriterEndElement(local->writer);
+    XML_RET_CHECK_AND_GOTO(ret, out);
 
 out:
-        return ret;
+    return ret;
 #else
-        return 0;
+    return 0;
 #endif /* HAVE_LIB_XML */
 }
diff --git a/cli/src/cli.c b/cli/src/cli.c
index 025f72c9748..39a0984a134 100644
--- a/cli/src/cli.c
+++ b/cli/src/cli.c
@@ -64,16 +64,17 @@
 extern int connected;
 /* using argp for command line parsing */
 
-const char *argp_program_version = ""                                         \
-        PACKAGE_NAME" "PACKAGE_VERSION                                        \
-        "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n"          \
-        "Copyright (c) 2006-2016 Red Hat, Inc. "                              \
-        "<https://www.gluster.org/>\n"                                        \
-        "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"                      \
-        "It is licensed to you under your choice of the GNU Lesser\n"         \
-        "General Public License, version 3 or any later version (LGPLv3\n"    \
-        "or later), or the GNU General Public License, version 2 (GPLv2),\n"  \
-        "in all cases as published by the Free Software Foundation.";
+const char *argp_program_version =
+    "" PACKAGE_NAME " " PACKAGE_VERSION
+    "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION
+    "\n"
+    "Copyright (c) 2006-2016 Red Hat, Inc. "
+    "<https://www.gluster.org/>\n"
+    "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"
+    "It is licensed to you under your choice of the GNU Lesser\n"
+    "General Public License, version 3 or any later version (LGPLv3\n"
+    "or later), or the GNU General Public License, version 2 (GPLv2),\n"
+    "in all cases as published by the Free Software Foundation.";
 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 
 struct rpc_clnt *global_quotad_rpc;
@@ -81,231 +82,228 @@ struct rpc_clnt *global_rpc;
 
 rpc_clnt_prog_t *cli_rpc_prog;
 
-
 extern struct rpc_clnt_program cli_prog;
 
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t    *cmd_args = NULL;
-        struct rlimit  lim = {0, };
-        call_pool_t   *pool = NULL;
-        int            ret         = -1;
-
-        ret = xlator_mem_acct_init (THIS, cli_mt_end);
-        if (ret != 0) {
-                return ret;
-        }
+    cmd_args_t *cmd_args = NULL;
+    struct rlimit lim = {
+        0,
+    };
+    call_pool_t *pool = NULL;
+    int ret = -1;
+
+    ret = xlator_mem_acct_init(THIS, cli_mt_end);
+    if (ret != 0) {
+        return ret;
+    }
 
-        ctx->process_uuid = generate_glusterfs_ctx_id ();
-        if (!ctx->process_uuid)
-                return -1;
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid)
+        return -1;
 
-        ctx->page_size  = 128 * GF_UNIT_KB;
+    ctx->page_size = 128 * GF_UNIT_KB;
 
-        ctx->iobuf_pool = iobuf_pool_new ();
-        if (!ctx->iobuf_pool)
-                return -1;
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool)
+        return -1;
 
-        ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-        if (!ctx->event_pool)
-                return -1;
+    ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                     STARTING_EVENT_THREADS);
+    if (!ctx->event_pool)
+        return -1;
 
-        pool = GF_CALLOC (1, sizeof (call_pool_t),
-                          cli_mt_call_pool_t);
-        if (!pool)
-                return -1;
+    pool = GF_CALLOC(1, sizeof(call_pool_t), cli_mt_call_pool_t);
+    if (!pool)
+        return -1;
 
-        /* frame_mem_pool size 112 * 64 */
-        pool->frame_mem_pool = mem_pool_new (call_frame_t, 32);
-        if (!pool->frame_mem_pool)
-                return -1;
+    /* frame_mem_pool size 112 * 64 */
+    pool->frame_mem_pool = mem_pool_new(call_frame_t, 32);
+    if (!pool->frame_mem_pool)
+        return -1;
 
-        /* stack_mem_pool size 256 * 128 */
-        pool->stack_mem_pool = mem_pool_new (call_stack_t, 16);
+    /* stack_mem_pool size 256 * 128 */
+    pool->stack_mem_pool = mem_pool_new(call_stack_t, 16);
 
-        if (!pool->stack_mem_pool)
-                return -1;
+    if (!pool->stack_mem_pool)
+        return -1;
 
-        ctx->stub_mem_pool = mem_pool_new (call_stub_t, 16);
-        if (!ctx->stub_mem_pool)
-                return -1;
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 16);
+    if (!ctx->stub_mem_pool)
+        return -1;
 
-        ctx->dict_pool = mem_pool_new (dict_t, 32);
-        if (!ctx->dict_pool)
-                return -1;
+    ctx->dict_pool = mem_pool_new(dict_t, 32);
+    if (!ctx->dict_pool)
+        return -1;
 
-        ctx->dict_pair_pool = mem_pool_new (data_pair_t, 512);
-        if (!ctx->dict_pair_pool)
-                return -1;
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t, 512);
+    if (!ctx->dict_pair_pool)
+        return -1;
 
-        ctx->dict_data_pool = mem_pool_new (data_t, 512);
-        if (!ctx->dict_data_pool)
-                return -1;
+    ctx->dict_data_pool = mem_pool_new(data_t, 512);
+    if (!ctx->dict_data_pool)
+        return -1;
 
-        ctx->logbuf_pool = mem_pool_new (log_buf_t, 256);
-        if (!ctx->logbuf_pool)
-                return -1;
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, 256);
+    if (!ctx->logbuf_pool)
+        return -1;
 
-        INIT_LIST_HEAD (&pool->all_frames);
-        LOCK_INIT (&pool->lock);
-        ctx->pool = pool;
+    INIT_LIST_HEAD(&pool->all_frames);
+    LOCK_INIT(&pool->lock);
+    ctx->pool = pool;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        INIT_LIST_HEAD (&cmd_args->xlator_options);
+    INIT_LIST_HEAD(&cmd_args->xlator_options);
 
-        lim.rlim_cur = RLIM_INFINITY;
-        lim.rlim_max = RLIM_INFINITY;
-        setrlimit (RLIMIT_CORE, &lim);
+    lim.rlim_cur = RLIM_INFINITY;
+    lim.rlim_max = RLIM_INFINITY;
+    setrlimit(RLIMIT_CORE, &lim);
 
-        return 0;
+    return 0;
 }
 
-
 static int
-logging_init (glusterfs_ctx_t *ctx, struct cli_state *state)
+logging_init(glusterfs_ctx_t *ctx, struct cli_state *state)
 {
-        char *log_file = state->log_file ? state->log_file :
-                         DEFAULT_CLI_LOG_FILE_DIRECTORY "/cli.log";
-
-        /* passing ident as NULL means to use default ident for syslog */
-        if (gf_log_init (ctx, log_file, NULL) == -1) {
-                fprintf (stderr, "ERROR: failed to open logfile %s\n",
-                         log_file);
-                return -1;
-        }
+    char *log_file = state->log_file ? state->log_file
+                                     : DEFAULT_CLI_LOG_FILE_DIRECTORY
+                         "/cli.log";
 
-        /* CLI should not have something to DEBUG after the release,
-           hence defaulting to INFO loglevel */
-        gf_log_set_loglevel (ctx, (state->log_level == GF_LOG_NONE) ?
-                             GF_LOG_INFO : state->log_level);
+    /* passing ident as NULL means to use default ident for syslog */
+    if (gf_log_init(ctx, log_file, NULL) == -1) {
+        fprintf(stderr, "ERROR: failed to open logfile %s\n", log_file);
+        return -1;
+    }
 
-        return 0;
+    /* CLI should not have something to DEBUG after the release,
+       hence defaulting to INFO loglevel */
+    gf_log_set_loglevel(ctx, (state->log_level == GF_LOG_NONE)
+                                 ? GF_LOG_INFO
+                                 : state->log_level);
+
+    return 0;
 }
 
 int
-cli_submit_request (struct rpc_clnt *rpc, void *req, call_frame_t *frame,
-                    rpc_clnt_prog_t *prog,
-                    int procnum, struct iobref *iobref,
-                    xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+cli_submit_request(struct rpc_clnt *rpc, void *req, call_frame_t *frame,
+                   rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref,
+                   xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
 {
-        int                     ret         = -1;
-        int                     count      = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf = NULL;
-        char                    new_iobref = 0;
-        ssize_t                 xdr_size   = 0;
-
-        GF_ASSERT (this);
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-                iobuf = iobuf_get2 (this->ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                if (!iobref) {
-                        iobref = iobref_new ();
-                        if (!iobref) {
-                                goto out;
-                        }
-
-                        new_iobref = 1;
-                }
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_size (iobuf);
-
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    char new_iobref = 0;
+    ssize_t xdr_size = 0;
+
+    GF_ASSERT(this);
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+        iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        if (!iobref) {
+            iobref = iobref_new();
+            if (!iobref) {
+                goto out;
+            }
+
+            new_iobref = 1;
+        }
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_size(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            goto out;
         }
+        iov.iov_len = ret;
+        count = 1;
+    }
 
-        if (!rpc)
-                rpc = global_rpc;
-        /* Send the msg */
-        ret = rpc_clnt_submit (rpc, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
-        ret = 0;
+    if (!rpc)
+        rpc = global_rpc;
+    /* Send the msg */
+    ret = rpc_clnt_submit(rpc, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
+    ret = 0;
 
 out:
-        if (new_iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    if (new_iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 int
-cli_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-                void *data)
+cli_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+               void *data)
 {
-        xlator_t                *this = NULL;
-        int                     ret = 0;
-
-        this = mydata;
+    xlator_t *this = NULL;
+    int ret = 0;
 
-        switch (event) {
-        case RPC_CLNT_CONNECT:
-        {
+    this = mydata;
 
-                cli_cmd_broadcast_connected ();
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
-               break;
+    switch (event) {
+        case RPC_CLNT_CONNECT: {
+            cli_cmd_broadcast_connected();
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT");
+            break;
         }
 
-        case RPC_CLNT_DISCONNECT:
-        {
-                gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
-                connected = 0;
-                if (!global_state->prompt && global_state->await_connected) {
-                        ret = 1;
-                        cli_out ("Connection failed. Please check if gluster "
-                                  "daemon is operational.");
-                        exit (ret);
-                }
-                break;
+        case RPC_CLNT_DISCONNECT: {
+            gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT");
+            connected = 0;
+            if (!global_state->prompt && global_state->await_connected) {
+                ret = 1;
+                cli_out(
+                    "Connection failed. Please check if gluster "
+                    "daemon is operational.");
+                exit(ret);
+            }
+            break;
         }
 
         default:
-                gf_log (this->name, GF_LOG_TRACE,
-                        "got some other RPC event %d", event);
-                ret = 0;
-                break;
-        }
+            gf_log(this->name, GF_LOG_TRACE, "got some other RPC event %d",
+                   event);
+            ret = 0;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-is_valid_int (char *str)
+is_valid_int(char *str)
 {
-        if (*str == '-')
-                ++str;
+    if (*str == '-')
+        ++str;
 
-        /* Handle empty string or just "-".*/
-        if (!*str)
-                return _gf_false;
+    /* Handle empty string or just "-".*/
+    if (!*str)
+        return _gf_false;
 
-        /* Check for non-digit chars in the rest of the string */
-        while (*str) {
-                if (!isdigit(*str))
-                        return _gf_false;
+    /* Check for non-digit chars in the rest of the string */
+    while (*str) {
+        if (!isdigit(*str))
+            return _gf_false;
         else
-                ++str;
-        }
-        return _gf_true;
+            ++str;
+    }
+    return _gf_true;
 }
 
 /*
@@ -315,527 +313,528 @@ is_valid_int (char *str)
  *     -2: parsing issue (avoid unknown option error)
  */
 int
-cli_opt_parse (char *opt, struct cli_state *state)
+cli_opt_parse(char *opt, struct cli_state *state)
 {
-        char            *oarg           = NULL;
-        gf_boolean_t    secure_mgmt_tmp = 0;
+    char *oarg = NULL;
+    gf_boolean_t secure_mgmt_tmp = 0;
 
-        if (strcmp (opt, "") == 0)
-                return 1;
+    if (strcmp(opt, "") == 0)
+        return 1;
 
-        if (strcmp (opt, "version") == 0) {
-                cli_out ("%s", argp_program_version);
-                exit (0);
-        }
+    if (strcmp(opt, "version") == 0) {
+        cli_out("%s", argp_program_version);
+        exit(0);
+    }
 
-        if (strcmp (opt, "print-logdir") == 0) {
-                cli_out ("%s", DEFAULT_LOG_FILE_DIRECTORY);
-                exit (0);
-        }
+    if (strcmp(opt, "print-logdir") == 0) {
+        cli_out("%s", DEFAULT_LOG_FILE_DIRECTORY);
+        exit(0);
+    }
 
-        if (strcmp (opt, "print-statedumpdir") == 0) {
-                cli_out ("%s", DEFAULT_VAR_RUN_DIRECTORY);
-                exit (0);
-        }
+    if (strcmp(opt, "print-statedumpdir") == 0) {
+        cli_out("%s", DEFAULT_VAR_RUN_DIRECTORY);
+        exit(0);
+    }
 
-        if (strcmp (opt, "xml") == 0) {
+    if (strcmp(opt, "xml") == 0) {
 #if (HAVE_LIB_XML)
-                state->mode |= GLUSTER_MODE_XML;
+        state->mode |= GLUSTER_MODE_XML;
 #else
-                cli_err ("XML output not supported. Ignoring '--xml' option");
+        cli_err("XML output not supported. Ignoring '--xml' option");
 #endif
-                return 0;
-        }
-
-        if (strcmp (opt, "wignore-partition") == 0) {
-                state->mode |= GLUSTER_MODE_WIGNORE_PARTITION;
-                return 0;
-        }
-
-        if (strcmp (opt, "wignore") == 0) {
-                state->mode |= GLUSTER_MODE_WIGNORE;
-                return 0;
-        }
+        return 0;
+    }
 
-        oarg = strtail (opt, "mode=");
-        if (oarg) {
-                if (strcmp (oarg, "script") == 0) {
-                        state->mode |= GLUSTER_MODE_SCRIPT;
-                        return 0;
-                }
+    if (strcmp(opt, "wignore-partition") == 0) {
+        state->mode |= GLUSTER_MODE_WIGNORE_PARTITION;
+        return 0;
+    }
 
-                if (strcmp (oarg, "interactive") == 0)
-                        return 0;
+    if (strcmp(opt, "wignore") == 0) {
+        state->mode |= GLUSTER_MODE_WIGNORE;
+        return 0;
+    }
 
-                return -1;
+    oarg = strtail(opt, "mode=");
+    if (oarg) {
+        if (strcmp(oarg, "script") == 0) {
+            state->mode |= GLUSTER_MODE_SCRIPT;
+            return 0;
         }
 
-        oarg = strtail (opt, "remote-host=");
-        if (oarg) {
-                state->remote_host = oarg;
-                return 0;
-        }
+        if (strcmp(oarg, "interactive") == 0)
+            return 0;
 
-        oarg = strtail (opt, "log-file=");
-        if (oarg) {
-                state->log_file = oarg;
-                return 0;
-        }
-        oarg = strtail (opt, "timeout=");
-        if (oarg) {
-                if (!is_valid_int (oarg) || atoi(oarg) <= 0) {
-                        cli_err ("timeout value should be a positive integer");
-                        return -2; /* -2 instead of -1 to avoid unknown option
-                                      error */
-                }
-                cli_default_conn_timeout = atoi(oarg);
-                return 0;
-        }
+        return -1;
+    }
 
-        oarg = strtail (opt, "log-level=");
-        if (oarg) {
-                int log_level = glusterd_check_log_level(oarg);
-                if (log_level == -1)
-                        return -1;
-                state->log_level = (gf_loglevel_t) log_level;
-                return 0;
-        }
+    oarg = strtail(opt, "remote-host=");
+    if (oarg) {
+        state->remote_host = oarg;
+        return 0;
+    }
 
-        oarg = strtail (opt, "glusterd-sock=");
-        if (oarg) {
-                state->glusterd_sock = oarg;
-                return 0;
-        }
+    oarg = strtail(opt, "log-file=");
+    if (oarg) {
+        state->log_file = oarg;
+        return 0;
+    }
+    oarg = strtail(opt, "timeout=");
+    if (oarg) {
+        if (!is_valid_int(oarg) || atoi(oarg) <= 0) {
+            cli_err("timeout value should be a positive integer");
+            return -2; /* -2 instead of -1 to avoid unknown option
+                          error */
+        }
+        cli_default_conn_timeout = atoi(oarg);
+        return 0;
+    }
+
+    oarg = strtail(opt, "log-level=");
+    if (oarg) {
+        int log_level = glusterd_check_log_level(oarg);
+        if (log_level == -1)
+            return -1;
+        state->log_level = (gf_loglevel_t)log_level;
+        return 0;
+    }
+
+    oarg = strtail(opt, "glusterd-sock=");
+    if (oarg) {
+        state->glusterd_sock = oarg;
+        return 0;
+    }
 
-        oarg = strtail (opt, "secure-mgmt=");
-        if (oarg) {
-                if (gf_string2boolean(oarg,&secure_mgmt_tmp) == 0) {
-                        if (secure_mgmt_tmp) {
-                                /* See declaration for why this is an int. */
-                                state->ctx->secure_mgmt = 1;
-                        }
-                }
-                else {
-                        cli_err ("invalid secure-mgmt value (ignored)");
-                }
-                return 0;
+    oarg = strtail(opt, "secure-mgmt=");
+    if (oarg) {
+        if (gf_string2boolean(oarg, &secure_mgmt_tmp) == 0) {
+            if (secure_mgmt_tmp) {
+                /* See declaration for why this is an int. */
+                state->ctx->secure_mgmt = 1;
+            }
+        } else {
+            cli_err("invalid secure-mgmt value (ignored)");
         }
+        return 0;
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-parse_cmdline (int argc, char *argv[], struct cli_state *state)
+parse_cmdline(int argc, char *argv[], struct cli_state *state)
 {
-        int                 ret            = 0;
-        int                 i              = 0;
-        int                 j              = 0;
-        char               *opt            = NULL;
-        gf_boolean_t       geo_rep_config  = _gf_false;
-
-        state->argc=argc-1;
-        state->argv=&argv[1];
-
-        /* Do this first so that an option can override. */
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
-                state->ctx->secure_mgmt = 1;
-                state->ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-
-        if (state->argc > GEO_REP_CMD_CONFIG_INDEX &&
-            strtail (state->argv[GEO_REP_CMD_INDEX], "geo") &&
-            strtail (state->argv[GEO_REP_CMD_CONFIG_INDEX], "co"))
-                geo_rep_config = _gf_true;
-
-        for (i = 0; i < state->argc; i++) {
-                opt = strtail (state->argv[i], "--");
-                if (opt && !geo_rep_config) {
-                        ret = cli_opt_parse (opt, state);
-                        if (ret == -1) {
-                                cli_out ("unrecognized option --%s", opt);
-                                return ret;
-                        } else if (ret == -2) {
-                                return ret;
-                        }
-                        for (j = i; j < state->argc - 1; j++)
-                                state->argv[j] = state->argv[j + 1];
-                        state->argc--;
-                        /* argv shifted, next check should be at i again */
-                        i--;
-                        if (ret == 1) {
-                                /* end of cli options */
-                                ret = 0;
-                                break;
-                        }
-                }
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+    char *opt = NULL;
+    gf_boolean_t geo_rep_config = _gf_false;
+
+    state->argc = argc - 1;
+    state->argv = &argv[1];
+
+    /* Do this first so that an option can override. */
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        state->ctx->secure_mgmt = 1;
+        state->ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+
+    if (state->argc > GEO_REP_CMD_CONFIG_INDEX &&
+        strtail(state->argv[GEO_REP_CMD_INDEX], "geo") &&
+        strtail(state->argv[GEO_REP_CMD_CONFIG_INDEX], "co"))
+        geo_rep_config = _gf_true;
+
+    for (i = 0; i < state->argc; i++) {
+        opt = strtail(state->argv[i], "--");
+        if (opt && !geo_rep_config) {
+            ret = cli_opt_parse(opt, state);
+            if (ret == -1) {
+                cli_out("unrecognized option --%s", opt);
+                return ret;
+            } else if (ret == -2) {
+                return ret;
+            }
+            for (j = i; j < state->argc - 1; j++)
+                state->argv[j] = state->argv[j + 1];
+            state->argc--;
+            /* argv shifted, next check should be at i again */
+            i--;
+            if (ret == 1) {
+                /* end of cli options */
+                ret = 0;
+                break;
+            }
         }
+    }
 
-        state->argv[state->argc] = NULL;
+    state->argv[state->argc] = NULL;
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_cmd_tree_init (struct cli_cmd_tree *tree)
+cli_cmd_tree_init(struct cli_cmd_tree *tree)
 {
-        struct cli_cmd_word  *root = NULL;
-        int                   ret = 0;
+    struct cli_cmd_word *root = NULL;
+    int ret = 0;
 
-        root = &tree->root;
-        root->tree = tree;
+    root = &tree->root;
+    root->tree = tree;
 
-        return ret;
+    return ret;
 }
 
-
 int
-cli_state_init (struct cli_state *state)
+cli_state_init(struct cli_state *state)
 {
-        struct cli_cmd_tree  *tree = NULL;
-        int                   ret = 0;
-
+    struct cli_cmd_tree *tree = NULL;
+    int ret = 0;
 
-        state->log_level = GF_LOG_NONE;
+    state->log_level = GF_LOG_NONE;
 
-        tree = &state->tree;
-        tree->state = state;
+    tree = &state->tree;
+    tree->state = state;
 
-        ret = cli_cmd_tree_init (tree);
+    ret = cli_cmd_tree_init(tree);
 
-        return ret;
+    return ret;
 }
 
 int
-cli_usage_out (const char *usage)
+cli_usage_out(const char *usage)
 {
-        GF_ASSERT (usage);
+    GF_ASSERT(usage);
 
-        if (!usage || usage[0] == '\0')
-                return -1;
+    if (!usage || usage[0] == '\0')
+        return -1;
 
-        cli_err ("\nUsage:\n%s\n", usage);
-        return 0;
+    cli_err("\nUsage:\n%s\n", usage);
+    return 0;
 }
 
 int
-_cli_err (const char *fmt, ...)
+_cli_err(const char *fmt, ...)
 {
-        va_list           ap;
-        int               ret = 0;
+    va_list ap;
+    int ret = 0;
 #ifdef HAVE_READLINE
-        struct cli_state *state = global_state;
+    struct cli_state *state = global_state;
 #endif
 
-        va_start (ap, fmt);
+    va_start(ap, fmt);
 
 #ifdef HAVE_READLINE
-        if (state->rl_enabled && !state->rl_processing) {
-                ret = cli_rl_err (state, fmt, ap);
-                va_end (ap);
-                return ret;
-        }
+    if (state->rl_enabled && !state->rl_processing) {
+        ret = cli_rl_err(state, fmt, ap);
+        va_end(ap);
+        return ret;
+    }
 #endif
 
-        ret = vfprintf (stderr, fmt, ap);
-        fprintf (stderr, "\n");
-        va_end (ap);
+    ret = vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
-
 int
-_cli_out (const char *fmt, ...)
+_cli_out(const char *fmt, ...)
 {
-        va_list           ap;
-        int               ret = 0;
+    va_list ap;
+    int ret = 0;
 #ifdef HAVE_READLINE
-        struct cli_state *state = global_state;
+    struct cli_state *state = global_state;
 #endif
 
-        va_start (ap, fmt);
+    va_start(ap, fmt);
 #ifdef HAVE_READLINE
-        if (state->rl_enabled && !state->rl_processing) {
-                ret = cli_rl_out (state, fmt, ap);
-                va_end (ap);
-                return ret;
-        }
+    if (state->rl_enabled && !state->rl_processing) {
+        ret = cli_rl_out(state, fmt, ap);
+        va_end(ap);
+        return ret;
+    }
 #endif
 
-        ret = vprintf (fmt, ap);
-        printf ("\n");
-        va_end (ap);
+    ret = vprintf(fmt, ap);
+    printf("\n");
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 struct rpc_clnt *
-cli_quotad_clnt_rpc_init (void)
+cli_quotad_clnt_rpc_init(void)
 {
-        struct rpc_clnt *rpc = NULL;
-        dict_t          *rpc_opts = NULL;
-        int             ret = -1;
-
-        rpc_opts = dict_new ();
-        if (!rpc_opts) {
-                        ret = -1;
-                        goto out;
-                }
-
-        ret = dict_set_str (rpc_opts, "transport.address-family", "unix");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (rpc_opts, "transport-type", "socket");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (rpc_opts, "transport.socket.connect-path",
-                                            "/var/run/gluster/quotad.socket");
-        if (ret)
-                goto out;
-
-        rpc = cli_quotad_clnt_init (THIS, rpc_opts);
-        if (!rpc)
-                goto out;
-
-        global_quotad_rpc = rpc;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *rpc_opts = NULL;
+    int ret = -1;
+
+    rpc_opts = dict_new();
+    if (!rpc_opts) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_str(rpc_opts, "transport.address-family", "unix");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(rpc_opts, "transport-type", "socket");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(rpc_opts, "transport.socket.connect-path",
+                       "/var/run/gluster/quotad.socket");
+    if (ret)
+        goto out;
+
+    rpc = cli_quotad_clnt_init(THIS, rpc_opts);
+    if (!rpc)
+        goto out;
+
+    global_quotad_rpc = rpc;
 out:
-        if (ret) {
-                if (rpc_opts)
-                        dict_unref(rpc_opts);
-        }
-        return rpc;
+    if (ret) {
+        if (rpc_opts)
+            dict_unref(rpc_opts);
+    }
+    return rpc;
 }
 
 struct rpc_clnt *
-cli_rpc_init (struct cli_state *state)
+cli_rpc_init(struct cli_state *state)
 {
-        struct rpc_clnt         *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
-        int                     port = CLI_GLUSTERD_PORT;
-        xlator_t                *this = NULL;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = CLI_GLUSTERD_PORT;
+    xlator_t *this = NULL;
 #ifdef IPV6_DEFAULT
-        char                    *addr_family = "inet6";
+    char *addr_family = "inet6";
 #else
-        char                    *addr_family = "inet";
+    char *addr_family = "inet";
 #endif
 
-        this = THIS;
-        cli_rpc_prog = &cli_prog;
-        options = dict_new ();
-        if (!options)
-                goto out;
-
-        /* Connect to glusterd using the specified method, giving preference
-         * to a unix socket connection.  If nothing is specified, connect to
-         * the default glusterd socket.
-         */
-        if (state->glusterd_sock) {
-                gf_log ("cli", GF_LOG_INFO, "Connecting to glusterd using "
-                        "sockfile %s", state->glusterd_sock);
-                ret = rpc_transport_unix_options_build (&options,
-                                                        state->glusterd_sock,
-                                                        0);
-                if (ret)
-                        goto out;
-        }
-        else if (state->remote_host) {
-                gf_log ("cli", GF_LOG_INFO, "Connecting to remote glusterd at "
-                        "%s", state->remote_host);
-                ret = dict_set_str (options, "remote-host", state->remote_host);
-                if (ret)
-                        goto out;
+    this = THIS;
+    cli_rpc_prog = &cli_prog;
+    options = dict_new();
+    if (!options)
+        goto out;
+
+    /* Connect to glusterd using the specified method, giving preference
+     * to a unix socket connection.  If nothing is specified, connect to
+     * the default glusterd socket.
+     */
+    if (state->glusterd_sock) {
+        gf_log("cli", GF_LOG_INFO,
+               "Connecting to glusterd using "
+               "sockfile %s",
+               state->glusterd_sock);
+        ret = rpc_transport_unix_options_build(&options, state->glusterd_sock,
+                                               0);
+        if (ret)
+            goto out;
+    } else if (state->remote_host) {
+        gf_log("cli", GF_LOG_INFO,
+               "Connecting to remote glusterd at "
+               "%s",
+               state->remote_host);
+        ret = dict_set_str(options, "remote-host", state->remote_host);
+        if (ret)
+            goto out;
 
-                if (state->remote_port)
-                        port = state->remote_port;
+        if (state->remote_port)
+            port = state->remote_port;
 
-                ret = dict_set_int32 (options, "remote-port", port);
-                if (ret)
-                        goto out;
+        ret = dict_set_int32(options, "remote-port", port);
+        if (ret)
+            goto out;
 
-                ret = dict_set_str (options, "transport.address-family",
-                                        addr_family);
+        ret = dict_set_str(options, "transport.address-family", addr_family);
 
-                if (ret)
-                        goto out;
-        }
-        else {
-                gf_log ("cli", GF_LOG_DEBUG, "Connecting to glusterd using "
-                        "default socket");
-                ret = rpc_transport_unix_options_build
-                        (&options, DEFAULT_GLUSTERD_SOCKFILE, 0);
-                if (ret)
-                        goto out;
-        }
+        if (ret)
+            goto out;
+    } else {
+        gf_log("cli", GF_LOG_DEBUG,
+               "Connecting to glusterd using "
+               "default socket");
+        ret = rpc_transport_unix_options_build(&options,
+                                               DEFAULT_GLUSTERD_SOCKFILE, 0);
+        if (ret)
+            goto out;
+    }
 
-        rpc = rpc_clnt_new (options, this, this->name, 16);
-        if (!rpc)
-                goto out;
+    rpc = rpc_clnt_new(options, this, this->name, 16);
+    if (!rpc)
+        goto out;
 
-        ret = rpc_clnt_register_notify (rpc, cli_rpc_notify, this);
-        if (ret) {
-                gf_log ("cli", GF_LOG_ERROR, "failed to register notify");
-                goto out;
-        }
+    ret = rpc_clnt_register_notify(rpc, cli_rpc_notify, this);
+    if (ret) {
+        gf_log("cli", GF_LOG_ERROR, "failed to register notify");
+        goto out;
+    }
 
-        ret = rpc_clnt_start (rpc);
+    ret = rpc_clnt_start(rpc);
 out:
-        if (ret) {
-                if (rpc)
-                        rpc_clnt_unref (rpc);
-                rpc = NULL;
-        }
-        return rpc;
+    if (ret) {
+        if (rpc)
+            rpc_clnt_unref(rpc);
+        rpc = NULL;
+    }
+    return rpc;
 }
 
 cli_local_t *
-cli_local_get ()
+cli_local_get()
 {
-        cli_local_t     *local = NULL;
+    cli_local_t *local = NULL;
 
-        local = GF_CALLOC (1, sizeof (*local), cli_mt_cli_local_t);
-        LOCK_INIT (&local->lock);
-        INIT_LIST_HEAD (&local->dict_list);
+    local = GF_CALLOC(1, sizeof(*local), cli_mt_cli_local_t);
+    LOCK_INIT(&local->lock);
+    INIT_LIST_HEAD(&local->dict_list);
 
-        return local;
+    return local;
 }
 
 void
-cli_local_wipe (cli_local_t *local)
+cli_local_wipe(cli_local_t *local)
 {
-        if (local) {
-                GF_FREE (local->get_vol.volname);
-                if (local->dict)
-                        dict_unref (local->dict);
-                GF_FREE (local);
-        }
-
-        return;
+    if (local) {
+        GF_FREE(local->get_vol.volname);
+        if (local->dict)
+            dict_unref(local->dict);
+        GF_FREE(local);
+    }
+
+    return;
 }
 
 struct cli_state *global_state;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        struct cli_state   state = {0, };
-        int                ret = -1;
-        glusterfs_ctx_t   *ctx = NULL;
+    struct cli_state state = {
+        0,
+    };
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
 
-       mem_pools_init_early ();
-       mem_pools_init_late ();
+    mem_pools_init_early();
+    mem_pools_init_late();
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return ENOMEM;
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return ENOMEM;
 
 #ifdef DEBUG
-        gf_mem_acct_enable_set (ctx);
+    gf_mem_acct_enable_set(ctx);
 #endif
 
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                return ret;
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        return ret;
 
-	THIS->ctx = ctx;
+    THIS->ctx = ctx;
 
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        cli_default_conn_timeout = 120;
-        cli_ten_minutes_timeout = 600;
+    cli_default_conn_timeout = 120;
+    cli_ten_minutes_timeout = 600;
 
-        ret = cli_state_init (&state);
-        if (ret)
-                goto out;
+    ret = cli_state_init(&state);
+    if (ret)
+        goto out;
 
-        state.ctx = ctx;
-        global_state = &state;
+    state.ctx = ctx;
+    global_state = &state;
 
-        ret = parse_cmdline (argc, argv, &state);
-        if (ret)
-                goto out;
+    ret = parse_cmdline(argc, argv, &state);
+    if (ret)
+        goto out;
 
-        ret = logging_init (ctx, &state);
-        if (ret)
-                goto out;
+    ret = logging_init(ctx, &state);
+    if (ret)
+        goto out;
 
-        gf_log ("cli", GF_LOG_INFO, "Started running %s with version %s",
-                argv[0], PACKAGE_VERSION);
+    gf_log("cli", GF_LOG_INFO, "Started running %s with version %s", argv[0],
+           PACKAGE_VERSION);
 
-        global_rpc = cli_rpc_init (&state);
-        if (!global_rpc)
-                goto out;
+    global_rpc = cli_rpc_init(&state);
+    if (!global_rpc)
+        goto out;
 
-        global_quotad_rpc = cli_quotad_clnt_rpc_init ();
-        if (!global_quotad_rpc)
-                goto out;
+    global_quotad_rpc = cli_quotad_clnt_rpc_init();
+    if (!global_quotad_rpc)
+        goto out;
 
-        ret = cli_cmds_register (&state);
-        if (ret)
-                goto out;
+    ret = cli_cmds_register(&state);
+    if (ret)
+        goto out;
 
-        ret = cli_cmd_cond_init ();
-        if (ret)
-                goto out;
+    ret = cli_cmd_cond_init();
+    if (ret)
+        goto out;
 
-        ret = cli_input_init (&state);
-        if (ret)
-                goto out;
+    ret = cli_input_init(&state);
+    if (ret)
+        goto out;
 
-        ret = event_dispatch (ctx->event_pool);
+    ret = event_dispatch(ctx->event_pool);
 
 out:
-//        glusterfs_ctx_destroy (ctx);
+    //        glusterfs_ctx_destroy (ctx);
 
-        mem_pools_fini ();
+    mem_pools_fini();
 
-        return ret;
+    return ret;
 }
 
 void
-cli_print_line (int len)
+cli_print_line(int len)
 {
-        GF_ASSERT (len > 0);
+    GF_ASSERT(len > 0);
 
-        while (len--)
-                printf ("-");
+    while (len--)
+        printf("-");
 
-        printf ("\n");
+    printf("\n");
 }
 
 void
-print_quota_list_header (int type)
+print_quota_list_header(int type)
 {
-        if (type == GF_QUOTA_OPTION_TYPE_LIST) {
-                cli_out ("                  Path                   Hard-limit "
-                         " Soft-limit      Used  Available  Soft-limit "
-                         "exceeded? Hard-limit exceeded?");
-                cli_out ("-----------------------------------------------------"
-                         "-----------------------------------------------------"
-                         "---------------------");
-        } else {
-                cli_out ("                  Path                   Hard-limit  "
-                         " Soft-limit      Files       Dirs     Available  "
-                         "Soft-limit exceeded? Hard-limit exceeded?");
-                cli_out ("-----------------------------------------------------"
-                         "-----------------------------------------------------"
-                         "-------------------------------------");
-        }
+    if (type == GF_QUOTA_OPTION_TYPE_LIST) {
+        cli_out(
+            "                  Path                   Hard-limit "
+            " Soft-limit      Used  Available  Soft-limit "
+            "exceeded? Hard-limit exceeded?");
+        cli_out(
+            "-----------------------------------------------------"
+            "-----------------------------------------------------"
+            "---------------------");
+    } else {
+        cli_out(
+            "                  Path                   Hard-limit  "
+            " Soft-limit      Files       Dirs     Available  "
+            "Soft-limit exceeded? Hard-limit exceeded?");
+        cli_out(
+            "-----------------------------------------------------"
+            "-----------------------------------------------------"
+            "-------------------------------------");
+    }
 }
 
 void
-print_quota_list_empty (char *path, int type)
+print_quota_list_empty(char *path, int type)
 {
-        if (type == GF_QUOTA_OPTION_TYPE_LIST)
-                cli_out ("%-40s %7s %9s %10s %7s %15s %20s", path,
-                         "N/A", "N/A", "N/A", "N/A", "N/A", "N/A");
-        else
-                cli_out ("%-40s %9s %9s %12s %10s %10s %15s %20s", path,
-                         "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A");
+    if (type == GF_QUOTA_OPTION_TYPE_LIST)
+        cli_out("%-40s %7s %9s %10s %7s %15s %20s", path, "N/A", "N/A", "N/A",
+                "N/A", "N/A", "N/A");
+    else
+        cli_out("%-40s %9s %9s %12s %10s %10s %15s %20s", path, "N/A", "N/A",
+                "N/A", "N/A", "N/A", "N/A", "N/A");
 }
-
diff --git a/cli/src/input.c b/cli/src/input.c
index 10fc39cd6b4..0583f648f95 100644
--- a/cli/src/input.c
+++ b/cli/src/input.c
@@ -19,74 +19,72 @@
 #define CMDBUFSIZ 1024
 
 void *
-cli_batch (void *d)
+cli_batch(void *d)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
+    struct cli_state *state = NULL;
+    int ret = 0;
 
-        state = d;
+    state = d;
 
-        ret = cli_cmd_process (state, state->argc, state->argv);
+    ret = cli_cmd_process(state, state->argc, state->argv);
 
-        gf_log ("", GF_LOG_INFO, "Exiting with: %d", ret);
-        exit (-ret);
+    gf_log("", GF_LOG_INFO, "Exiting with: %d", ret);
+    exit(-ret);
 
-        return NULL;
+    return NULL;
 }
 
-
 void *
-cli_input (void *d)
+cli_input(void *d)
 {
-        struct cli_state *state = NULL;
-        int               ret = 0;
-        char              cmdbuf[CMDBUFSIZ];
-        char             *cmd = NULL;
-        size_t            len = 0;
-
-        state = d;
-
-        for (;;) {
-                printf ("%s", state->prompt);
-
-                cmd = fgets (cmdbuf, CMDBUFSIZ, stdin);
-                if (!cmd)
-                        break;
-                len = strlen(cmd);
-                if (len > 0 && cmd[len - 1] == '\n') //strip trailing \n
-                        cmd[len - 1] = '\0';
-                ret = cli_cmd_process_line (state, cmd);
-                if (ret != 0 && state->mode & GLUSTER_MODE_ERR_FATAL)
-                        break;
-        }
-
-        exit (-ret);
-
-        return NULL;
+    struct cli_state *state = NULL;
+    int ret = 0;
+    char cmdbuf[CMDBUFSIZ];
+    char *cmd = NULL;
+    size_t len = 0;
+
+    state = d;
+
+    for (;;) {
+        printf("%s", state->prompt);
+
+        cmd = fgets(cmdbuf, CMDBUFSIZ, stdin);
+        if (!cmd)
+            break;
+        len = strlen(cmd);
+        if (len > 0 && cmd[len - 1] == '\n')  // strip trailing \n
+            cmd[len - 1] = '\0';
+        ret = cli_cmd_process_line(state, cmd);
+        if (ret != 0 && state->mode & GLUSTER_MODE_ERR_FATAL)
+            break;
+    }
+
+    exit(-ret);
+
+    return NULL;
 }
 
-
 int
-cli_input_init (struct cli_state *state)
+cli_input_init(struct cli_state *state)
 {
-        int  ret = 0;
+    int ret = 0;
 
-        if (state->argc) {
-                ret = pthread_create (&state->input, NULL, cli_batch, state);
-                return ret;
-        }
+    if (state->argc) {
+        ret = pthread_create(&state->input, NULL, cli_batch, state);
+        return ret;
+    }
 
-        if (isatty (STDIN_FILENO)) {
-                state->prompt = "gluster> ";
+    if (isatty(STDIN_FILENO)) {
+        state->prompt = "gluster> ";
 
-                cli_rl_enable (state);
-        } else {
-                state->prompt = "";
-                state->mode |= GLUSTER_MODE_SCRIPT | GLUSTER_MODE_ERR_FATAL;
-        }
+        cli_rl_enable(state);
+    } else {
+        state->prompt = "";
+        state->mode |= GLUSTER_MODE_SCRIPT | GLUSTER_MODE_ERR_FATAL;
+    }
 
-        if (!state->rl_enabled)
-                ret = pthread_create (&state->input, NULL, cli_input, state);
+    if (!state->rl_enabled)
+        ret = pthread_create(&state->input, NULL, cli_input, state);
 
-        return ret;
+    return ret;
 }
diff --git a/cli/src/registry.c b/cli/src/registry.c
index 1adf7d6e572..85f7686ade1 100644
--- a/cli/src/registry.c
+++ b/cli/src/registry.c
@@ -15,20 +15,18 @@
 #include "cli.h"
 #include "cli-cmd.h"
 
-
 static int
-__is_spc (int ch)
+__is_spc(int ch)
 {
-        if (ch == ' ')
-                return 1;
-        return 0;
+    if (ch == ' ')
+        return 1;
+    return 0;
 }
 
-
 static int
-__is_div (int ch)
+__is_div(int ch)
 {
-        switch (ch) {
+    switch (ch) {
         case '(':
         case ')':
         case '<':
@@ -38,369 +36,356 @@ __is_div (int ch)
         case '{':
         case '}':
         case '|':
-                return 1;
-        }
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-__is_word (const char *word)
+__is_word(const char *word)
 {
-        return (!__is_div (*word) && !__is_spc (*word));
+    return (!__is_div(*word) && !__is_spc(*word));
 }
 
-
 int
-counter_char (int ch)
+counter_char(int ch)
 {
-        switch (ch) {
+    switch (ch) {
         case '(':
-                return ')';
+            return ')';
         case '<':
-                return '>';
+            return '>';
         case '[':
-                return ']';
+            return ']';
         case '{':
-                return '}';
-        }
+            return '}';
+    }
 
-        return -1;
+    return -1;
 }
 
-
 const char *
-__is_template_balanced (const char *template)
+__is_template_balanced(const char *template)
 {
-        const char *trav = NULL;
-        int   ch = 0;
-
-        trav = template;
-
-        while (*trav) {
-                ch = *trav;
-
-                switch (ch) {
-                case '<':
-                case '(':
-                case '[':
-                        trav = __is_template_balanced (trav+1);
-                        if (!trav)
-                                return NULL;
-                        if (*trav != counter_char (ch))
-                                return NULL;
-                        break;
-                case '>':
-                case ')':
-                case ']':
-                        return trav;
-                }
+    const char *trav = NULL;
+    int ch = 0;
 
-                trav++;
+    trav = template;
+
+    while (*trav) {
+        ch = *trav;
+
+        switch (ch) {
+            case '<':
+            case '(':
+            case '[':
+                trav = __is_template_balanced(trav + 1);
+                if (!trav)
+                    return NULL;
+                if (*trav != counter_char(ch))
+                    return NULL;
+                break;
+            case '>':
+            case ')':
+            case ']':
+                return trav;
         }
 
-        return trav;
-}
+        trav++;
+    }
 
+    return trav;
+}
 
 int
-is_template_balanced (const char *template)
+is_template_balanced(const char *template)
 {
-        const char *trav = NULL;
+    const char *trav = NULL;
 
-        trav = __is_template_balanced (template);
-        if (!trav || *trav)
-                return -1;
+    trav = __is_template_balanced(template);
+    if (!trav || *trav)
+        return -1;
 
-        return 0;
+    return 0;
 }
 
-
 int
-cli_cmd_token_count (const char *template)
+cli_cmd_token_count(const char *template)
 {
-        int         count = 0;
-        const char *trav = NULL;
-        int         is_alnum = 0;
-
-        for (trav = template; *trav; trav++) {
-                switch (*trav) {
-                case '<':
-                case '>':
-                case '(':
-                case ')':
-                case '[':
-                case ']':
-                case '{':
-                case '}':
-                case '|':
-                        count++;
-                        /* fall through */
-                case ' ':
-                        is_alnum = 0;
-                        break;
-                default:
-                        if (!is_alnum) {
-                                is_alnum = 1;
-                                count++;
-                        }
+    int count = 0;
+    const char *trav = NULL;
+    int is_alnum = 0;
+
+    for (trav = template; *trav; trav++) {
+        switch (*trav) {
+            case '<':
+            case '>':
+            case '(':
+            case ')':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '|':
+                count++;
+                /* fall through */
+            case ' ':
+                is_alnum = 0;
+                break;
+            default:
+                if (!is_alnum) {
+                    is_alnum = 1;
+                    count++;
                 }
         }
+    }
 
-        return count + 1;
+    return count + 1;
 }
 
-
 void
-cli_cmd_tokens_destroy (char **tokens)
+cli_cmd_tokens_destroy(char **tokens)
 {
-        char **tokenp = NULL;
+    char **tokenp = NULL;
 
-        if (!tokens)
-                return;
+    if (!tokens)
+        return;
 
-        tokenp = tokens;
-        while (*tokenp) {
-                free (*tokenp);
-                tokenp++;
-        }
+    tokenp = tokens;
+    while (*tokenp) {
+        free(*tokenp);
+        tokenp++;
+    }
 
-        free (tokens);
+    free(tokens);
 }
 
-
 int
-cli_cmd_tokens_fill (char **tokens, const char *template)
+cli_cmd_tokens_fill(char **tokens, const char *template)
 {
-        const char  *trav = NULL;
-        char       **tokenp = NULL;
-        char        *token = NULL;
-        int          ret = 0;
-        int          ch = 0;
+    const char *trav = NULL;
+    char **tokenp = NULL;
+    char *token = NULL;
+    int ret = 0;
+    int ch = 0;
 
-        tokenp = tokens;
+    tokenp = tokens;
 
-        for (trav = template; *trav; trav++) {
-                ch = *trav;
+    for (trav = template; *trav; trav++) {
+        ch = *trav;
 
-                if (__is_spc (ch))
-                        continue;
+        if (__is_spc(ch))
+            continue;
 
-                if (__is_div (ch)) {
-                        token = calloc (2, 1);
-                        if (!token)
-                                return -1;
-                        token[0] = ch;
+        if (__is_div(ch)) {
+            token = calloc(2, 1);
+            if (!token)
+                return -1;
+            token[0] = ch;
 
-                        *tokenp = token;
-                        tokenp++;
+            *tokenp = token;
+            tokenp++;
 
-                        continue;
-                }
+            continue;
+        }
 
-                token = strdup (trav);
-                *tokenp = token;
-                tokenp++;
+        token = strdup(trav);
+        *tokenp = token;
+        tokenp++;
 
-                for (token++; *token; token++) {
-                        if (__is_spc (*token) || __is_div (*token)) {
-                                *token = 0;
-                                break;
-                        }
-                        trav++;
-                }
+        for (token++; *token; token++) {
+            if (__is_spc(*token) || __is_div(*token)) {
+                *token = 0;
+                break;
+            }
+            trav++;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 char **
-cli_cmd_tokenize (const char *template)
+cli_cmd_tokenize(const char *template)
 {
-        char **tokens = NULL;
-        int    ret = 0;
-        int    count = 0;
+    char **tokens = NULL;
+    int ret = 0;
+    int count = 0;
 
-        ret = is_template_balanced (template);
-        if (ret)
-                return NULL;
+    ret = is_template_balanced(template);
+    if (ret)
+        return NULL;
 
-        count = cli_cmd_token_count (template);
-        if (count <= 0)
-                return NULL;
+    count = cli_cmd_token_count(template);
+    if (count <= 0)
+        return NULL;
 
-        tokens = calloc (count + 1, sizeof (char *));
-        if (!tokens)
-                return NULL;
+    tokens = calloc(count + 1, sizeof(char *));
+    if (!tokens)
+        return NULL;
 
-        ret = cli_cmd_tokens_fill (tokens, template);
-        if (ret)
-                goto err;
+    ret = cli_cmd_tokens_fill(tokens, template);
+    if (ret)
+        goto err;
 
-        return tokens;
+    return tokens;
 err:
-        cli_cmd_tokens_destroy (tokens);
-        return NULL;
+    cli_cmd_tokens_destroy(tokens);
+    return NULL;
 }
 
 void *
-cli_getunamb (const char *tok, void **choices, cli_selector_t sel)
+cli_getunamb(const char *tok, void **choices, cli_selector_t sel)
 {
-        void  **wcon = NULL;
-        char      *w = NULL;
-        unsigned  mn = 0;
-        void    *ret = NULL;
-
-        if (!choices || !tok || !*tok)
-                return NULL;
-
-        for (wcon = choices; *wcon; wcon++) {
-                w = strtail ((char *)sel (*wcon), tok);
-                if (!w)
-                        /* no match */
-                        continue;
-                if (!*w)
-                        /* exact match */
-                        return *wcon;
-
-                ret = *wcon;
-                mn++;
-        }
+    void **wcon = NULL;
+    char *w = NULL;
+    unsigned mn = 0;
+    void *ret = NULL;
 
-#ifdef FORCE_MATCH_EXACT
+    if (!choices || !tok || !*tok)
         return NULL;
+
+    for (wcon = choices; *wcon; wcon++) {
+        w = strtail((char *)sel(*wcon), tok);
+        if (!w)
+            /* no match */
+            continue;
+        if (!*w)
+            /* exact match */
+            return *wcon;
+
+        ret = *wcon;
+        mn++;
+    }
+
+#ifdef FORCE_MATCH_EXACT
+    return NULL;
 #else
-        return (mn == 1) ? ret : NULL;
+    return (mn == 1) ? ret : NULL;
 #endif
 }
 
 static const char *
-sel_cmd_word (void *wcon)
+sel_cmd_word(void *wcon)
 {
-        return ((struct cli_cmd_word *)wcon)->word;
+    return ((struct cli_cmd_word *)wcon)->word;
 }
 
 struct cli_cmd_word *
-cli_cmd_nextword (struct cli_cmd_word *word, const char *token)
+cli_cmd_nextword(struct cli_cmd_word *word, const char *token)
 {
-        return (struct cli_cmd_word *)cli_getunamb (token,
-                                                    (void **)word->nextwords,
-                                                    sel_cmd_word);
+    return (struct cli_cmd_word *)cli_getunamb(token, (void **)word->nextwords,
+                                               sel_cmd_word);
 }
 
-
 struct cli_cmd_word *
-cli_cmd_newword (struct cli_cmd_word *word, const char *token)
+cli_cmd_newword(struct cli_cmd_word *word, const char *token)
 {
-        struct cli_cmd_word **nextwords = NULL;
-        struct cli_cmd_word  *nextword = NULL;
+    struct cli_cmd_word **nextwords = NULL;
+    struct cli_cmd_word *nextword = NULL;
 
-        nextwords = realloc (word->nextwords,
-                             (word->nextwords_cnt + 2) * sizeof (*nextwords));
-        if (!nextwords)
-                return NULL;
+    nextwords = realloc(word->nextwords,
+                        (word->nextwords_cnt + 2) * sizeof(*nextwords));
+    if (!nextwords)
+        return NULL;
 
-        word->nextwords = nextwords;
+    word->nextwords = nextwords;
 
-        nextword = calloc (1, sizeof (*nextword));
-        if (!nextword)
-                return NULL;
+    nextword = calloc(1, sizeof(*nextword));
+    if (!nextword)
+        return NULL;
 
-        nextword->word = strdup (token);
-        if (!nextword->word) {
-                free (nextword);
-                return NULL;
-        }
+    nextword->word = strdup(token);
+    if (!nextword->word) {
+        free(nextword);
+        return NULL;
+    }
 
-        nextword->tree = word->tree;
-        nextwords[word->nextwords_cnt++] = nextword;
-        nextwords[word->nextwords_cnt] = NULL;
+    nextword->tree = word->tree;
+    nextwords[word->nextwords_cnt++] = nextword;
+    nextwords[word->nextwords_cnt] = NULL;
 
-        return nextword;
+    return nextword;
 }
 
-
 int
-cli_cmd_ingest (struct cli_cmd_tree *tree, char **tokens, cli_cmd_cbk_t *cbkfn,
-                const char *desc, const char *pattern)
+cli_cmd_ingest(struct cli_cmd_tree *tree, char **tokens, cli_cmd_cbk_t *cbkfn,
+               const char *desc, const char *pattern)
 {
-        int                    ret = 0;
-        char                 **tokenp = NULL;
-        char                  *token = NULL;
-        struct cli_cmd_word   *word = NULL;
-        struct cli_cmd_word   *next = NULL;
-
-        word = &tree->root;
+    int ret = 0;
+    char **tokenp = NULL;
+    char *token = NULL;
+    struct cli_cmd_word *word = NULL;
+    struct cli_cmd_word *next = NULL;
 
-        for (tokenp = tokens; (token = *tokenp); tokenp++) {
-                if (!__is_word (token))
-                        break;
+    word = &tree->root;
 
-                next = cli_cmd_nextword (word, token);
-                if (!next)
-                        next = cli_cmd_newword (word, token);
+    for (tokenp = tokens; (token = *tokenp); tokenp++) {
+        if (!__is_word(token))
+            break;
 
-                word = next;
-                if (!word)
-                        break;
-        }
+        next = cli_cmd_nextword(word, token);
+        if (!next)
+            next = cli_cmd_newword(word, token);
 
+        word = next;
         if (!word)
-                return -1;
+            break;
+    }
 
-        if (word->cbkfn) {
-                /* warning - command already registered */
-        }
+    if (!word)
+        return -1;
 
-        word->cbkfn = cbkfn;
-        word->desc  = desc;
-        word->pattern = pattern;
+    if (word->cbkfn) {
+        /* warning - command already registered */
+    }
 
-        /* end of static strings in command template */
+    word->cbkfn = cbkfn;
+    word->desc = desc;
+    word->pattern = pattern;
 
-        /* TODO: autocompletion beyond this point is just "nice to have" */
+    /* end of static strings in command template */
 
-        return ret;
-}
+    /* TODO: autocompletion beyond this point is just "nice to have" */
 
+    return ret;
+}
 
 int
-cli_cmd_register (struct cli_cmd_tree *tree, struct cli_cmd *cmd)
+cli_cmd_register(struct cli_cmd_tree *tree, struct cli_cmd *cmd)
 {
-        char **tokens = NULL;
-        int    ret = 0;
+    char **tokens = NULL;
+    int ret = 0;
 
-        GF_ASSERT (cmd);
+    GF_ASSERT(cmd);
 
-        if (cmd->reg_cbk)
-                cmd->reg_cbk (cmd);
+    if (cmd->reg_cbk)
+        cmd->reg_cbk(cmd);
 
-        if (cmd->disable) {
-                ret = 0;
-                goto out;
-        }
+    if (cmd->disable) {
+        ret = 0;
+        goto out;
+    }
 
-        tokens = cli_cmd_tokenize (cmd->pattern);
-        if (!tokens) {
-                ret = -1;
-                goto out;
-        }
+    tokens = cli_cmd_tokenize(cmd->pattern);
+    if (!tokens) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = cli_cmd_ingest (tree, tokens, cmd->cbk, cmd->desc, cmd->pattern);
-        if (ret) {
-                ret = -1;
-                goto out;
-        }
+    ret = cli_cmd_ingest(tree, tokens, cmd->cbk, cmd->desc, cmd->pattern);
+    if (ret) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (tokens)
-                cli_cmd_tokens_destroy (tokens);
+    if (tokens)
+        cli_cmd_tokens_destroy(tokens);
 
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
-
diff --git a/extras/benchmarking/glfs-bm.c b/extras/benchmarking/glfs-bm.c
index dc717f33c16..f7f5873f84d 100644
--- a/extras/benchmarking/glfs-bm.c
+++ b/extras/benchmarking/glfs-bm.c
@@ -25,365 +25,338 @@
 #include <sys/time.h>
 
 struct state {
-        char need_op_write:1;
-        char need_op_read:1;
+    char need_op_write : 1;
+    char need_op_read : 1;
 
-        char need_iface_fileio:1;
-        char need_iface_xattr:1;
+    char need_iface_fileio : 1;
+    char need_iface_xattr : 1;
 
-        char need_mode_posix:1;
+    char need_mode_posix : 1;
 
-        char prefix[512];
-        long int count;
+    char prefix[512];
+    long int count;
 
-        size_t block_size;
+    size_t block_size;
 
-        char *specfile;
+    char *specfile;
 
-        long int io_size;
+    long int io_size;
 };
 
-
-#define MEASURE(func, arg) measure (func, #func, arg)
-
+#define MEASURE(func, arg) measure(func, #func, arg)
 
 void
-tv_difference (struct timeval *tv_stop,
-               struct timeval *tv_start,
-               struct timeval *tv_diff)
+tv_difference(struct timeval *tv_stop, struct timeval *tv_start,
+              struct timeval *tv_diff)
 {
-        if (tv_stop->tv_usec < tv_start->tv_usec) {
-                tv_diff->tv_usec = (tv_stop->tv_usec + 1000000) - tv_start->tv_usec;
-                tv_diff->tv_sec = (tv_stop->tv_sec - 1 - tv_start->tv_sec);
-        } else {
-                tv_diff->tv_usec = tv_stop->tv_usec - tv_start->tv_usec;
-                tv_diff->tv_sec = tv_stop->tv_sec - tv_start->tv_sec;
-        }
+    if (tv_stop->tv_usec < tv_start->tv_usec) {
+        tv_diff->tv_usec = (tv_stop->tv_usec + 1000000) - tv_start->tv_usec;
+        tv_diff->tv_sec = (tv_stop->tv_sec - 1 - tv_start->tv_sec);
+    } else {
+        tv_diff->tv_usec = tv_stop->tv_usec - tv_start->tv_usec;
+        tv_diff->tv_sec = tv_stop->tv_sec - tv_start->tv_sec;
+    }
 }
 
-
 void
-measure (int (*func)(struct state *state),
-         char *func_name, struct state *state)
+measure(int (*func)(struct state *state), char *func_name, struct state *state)
 {
-        struct timeval tv_start, tv_stop, tv_diff;
-        state->io_size = 0;
-        long int count;
+    struct timeval tv_start, tv_stop, tv_diff;
+    state->io_size = 0;
+    long int count;
 
-        gettimeofday (&tv_start, NULL);
-        count = func (state);
-        gettimeofday (&tv_stop, NULL);
+    gettimeofday(&tv_start, NULL);
+    count = func(state);
+    gettimeofday(&tv_stop, NULL);
 
-        tv_difference (&tv_stop, &tv_start, &tv_diff);
+    tv_difference(&tv_stop, &tv_start, &tv_diff);
 
-        fprintf (stdout, "%s: count=%ld, size=%ld, time=%ld:%ld\n",
-                 func_name, count, state->io_size,
-                 tv_diff.tv_sec, tv_diff.tv_usec);
+    fprintf(stdout, "%s: count=%ld, size=%ld, time=%ld:%ld\n", func_name, count,
+            state->io_size, tv_diff.tv_sec, tv_diff.tv_usec);
 }
 
-
 static error_t
-parse_opts (int key, char *arg,
-            struct argp_state *_state)
+parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        struct state *state = _state->input;
+    struct state *state = _state->input;
 
-        switch (key)
-        {
+    switch (key) {
         case 'o':
-                if (strcasecmp (arg, "read") == 0) {
-                        state->need_op_write = 0;
-                        state->need_op_read = 1;
-                } else if (strcasecmp (arg, "write") == 0) {
-                        state->need_op_write = 1;
-                        state->need_op_read = 0;
-                } else if (strcasecmp (arg, "both") == 0) {
-                        state->need_op_write = 1;
-                        state->need_op_read = 1;
-                } else {
-                        fprintf (stderr, "unknown op: %s\n", arg);
-                        return -1;
-                }
-                break;
+            if (strcasecmp(arg, "read") == 0) {
+                state->need_op_write = 0;
+                state->need_op_read = 1;
+            } else if (strcasecmp(arg, "write") == 0) {
+                state->need_op_write = 1;
+                state->need_op_read = 0;
+            } else if (strcasecmp(arg, "both") == 0) {
+                state->need_op_write = 1;
+                state->need_op_read = 1;
+            } else {
+                fprintf(stderr, "unknown op: %s\n", arg);
+                return -1;
+            }
+            break;
         case 'i':
-                if (strcasecmp (arg, "fileio") == 0) {
-                        state->need_iface_fileio = 1;
-                        state->need_iface_xattr = 0;
-                } else if (strcasecmp (arg, "xattr") == 0) {
-                        state->need_iface_fileio = 0;
-                        state->need_iface_xattr = 1;
-                } else if (strcasecmp (arg, "both") == 0) {
-                        state->need_iface_fileio = 1;
-                        state->need_iface_xattr = 1;
-                } else {
-                        fprintf (stderr, "unknown interface: %s\n", arg);
-                        return -1;
-                }
-                break;
-        case 'b':
-        {
-                size_t block_size = atoi (arg);
-                if (!block_size) {
-                        fprintf (stderr, "incorrect size: %s\n", arg);
-                        return -1;
-                }
-                state->block_size = block_size;
-        }
-        break;
+            if (strcasecmp(arg, "fileio") == 0) {
+                state->need_iface_fileio = 1;
+                state->need_iface_xattr = 0;
+            } else if (strcasecmp(arg, "xattr") == 0) {
+                state->need_iface_fileio = 0;
+                state->need_iface_xattr = 1;
+            } else if (strcasecmp(arg, "both") == 0) {
+                state->need_iface_fileio = 1;
+                state->need_iface_xattr = 1;
+            } else {
+                fprintf(stderr, "unknown interface: %s\n", arg);
+                return -1;
+            }
+            break;
+        case 'b': {
+            size_t block_size = atoi(arg);
+            if (!block_size) {
+                fprintf(stderr, "incorrect size: %s\n", arg);
+                return -1;
+            }
+            state->block_size = block_size;
+        } break;
         case 's':
-                state->specfile = strdup (arg);
-                break;
+            state->specfile = strdup(arg);
+            break;
         case 'p':
-                fprintf (stderr, "using prefix: %s\n", arg);
-                strncpy (state->prefix, arg, 512);
-                break;
-        case 'c':
-        {
-                long count = atol (arg);
-                if (!count) {
-                        fprintf (stderr, "incorrect count: %s\n", arg);
-                        return -1;
-                }
-                state->count = count;
-        }
-        break;
+            fprintf(stderr, "using prefix: %s\n", arg);
+            strncpy(state->prefix, arg, 512);
+            break;
+        case 'c': {
+            long count = atol(arg);
+            if (!count) {
+                fprintf(stderr, "incorrect count: %s\n", arg);
+                return -1;
+            }
+            state->count = count;
+        } break;
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
-        }
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-do_mode_posix_iface_fileio_write (struct state *state)
+do_mode_posix_iface_fileio_write(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-
-        for (i=0; i<state->count; i++) {
-                int fd = -1;
-                char filename[512];
-
-                sprintf (filename, "%s.%06ld", state->prefix, i);
-
-                fd = open (filename, O_CREAT|O_WRONLY, 00600);
-                if (fd == -1) {
-                        fprintf (stderr, "open(%s) => %s\n", filename, strerror (errno));
-                        break;
-                }
-                ret = write (fd, block, state->block_size);
-                if (ret != state->block_size) {
-                        fprintf (stderr, "write (%s) => %d/%s\n", filename, ret,
-                                 strerror (errno));
-                        close (fd);
-                        break;
-                }
-                close (fd);
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+
+    for (i = 0; i < state->count; i++) {
+        int fd = -1;
+        char filename[512];
+
+        sprintf(filename, "%s.%06ld", state->prefix, i);
+
+        fd = open(filename, O_CREAT | O_WRONLY, 00600);
+        if (fd == -1) {
+            fprintf(stderr, "open(%s) => %s\n", filename, strerror(errno));
+            break;
+        }
+        ret = write(fd, block, state->block_size);
+        if (ret != state->block_size) {
+            fprintf(stderr, "write (%s) => %d/%s\n", filename, ret,
+                    strerror(errno));
+            close(fd);
+            break;
         }
+        close(fd);
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_fileio_read (struct state *state)
+do_mode_posix_iface_fileio_read(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-
-        for (i=0; i<state->count; i++) {
-                int fd = -1;
-                char filename[512];
-
-                sprintf (filename, "%s.%06ld", state->prefix, i);
-
-                fd = open (filename, O_RDONLY);
-                if (fd == -1) {
-                        fprintf (stderr, "open(%s) => %s\n", filename, strerror (errno));
-                        break;
-                }
-                ret = read (fd, block, state->block_size);
-                if (ret == -1) {
-                        fprintf (stderr, "read(%s) => %d/%s\n", filename, ret, strerror (errno));
-                        close (fd);
-                        break;
-                }
-                close (fd);
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+
+    for (i = 0; i < state->count; i++) {
+        int fd = -1;
+        char filename[512];
+
+        sprintf(filename, "%s.%06ld", state->prefix, i);
+
+        fd = open(filename, O_RDONLY);
+        if (fd == -1) {
+            fprintf(stderr, "open(%s) => %s\n", filename, strerror(errno));
+            break;
         }
+        ret = read(fd, block, state->block_size);
+        if (ret == -1) {
+            fprintf(stderr, "read(%s) => %d/%s\n", filename, ret,
+                    strerror(errno));
+            close(fd);
+            break;
+        }
+        close(fd);
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_fileio (struct state *state)
+do_mode_posix_iface_fileio(struct state *state)
 {
-        if (state->need_op_write)
-                MEASURE (do_mode_posix_iface_fileio_write, state);
+    if (state->need_op_write)
+        MEASURE(do_mode_posix_iface_fileio_write, state);
 
-        if (state->need_op_read)
-                MEASURE (do_mode_posix_iface_fileio_read, state);
+    if (state->need_op_read)
+        MEASURE(do_mode_posix_iface_fileio_read, state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-do_mode_posix_iface_xattr_write (struct state *state)
+do_mode_posix_iface_xattr_write(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-        char *dname = NULL, *dirc = NULL;
-        char *bname = NULL, *basec = NULL;
-
-        dirc = strdup (state->prefix);
-        basec = strdup (state->prefix);
-        dname = dirname (dirc);
-        bname = basename (basec);
-
-        for (i=0; i<state->count; i++) {
-                char key[512];
-
-                sprintf (key, "glusterfs.file.%s.%06ld", bname, i);
-
-                ret = lsetxattr (dname, key, block, state->block_size, 0);
-
-                if (ret != 0) {
-                        fprintf (stderr, "lsetxattr (%s, %s, %p) => %s\n",
-                                 dname, key, block, strerror (errno));
-                        break;
-                }
-                state->io_size += state->block_size;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+    char *dname = NULL, *dirc = NULL;
+    char *bname = NULL, *basec = NULL;
+
+    dirc = strdup(state->prefix);
+    basec = strdup(state->prefix);
+    dname = dirname(dirc);
+    bname = basename(basec);
+
+    for (i = 0; i < state->count; i++) {
+        char key[512];
+
+        sprintf(key, "glusterfs.file.%s.%06ld", bname, i);
+
+        ret = lsetxattr(dname, key, block, state->block_size, 0);
+
+        if (ret != 0) {
+            fprintf(stderr, "lsetxattr (%s, %s, %p) => %s\n", dname, key, block,
+                    strerror(errno));
+            break;
         }
+        state->io_size += state->block_size;
+    }
 
-        free (dirc);
-        free (basec);
+    free(dirc);
+    free(basec);
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_xattr_read (struct state *state)
+do_mode_posix_iface_xattr_read(struct state *state)
 {
-        long int i;
-        int ret = -1;
-        char block[state->block_size];
-        char *dname = NULL, *dirc = NULL;
-        char *bname = NULL, *basec = NULL;
-
-        dirc = strdup (state->prefix);
-        basec = strdup (state->prefix);
-        dname = dirname (dirc);
-        bname = basename (basec);
-
-        for (i=0; i<state->count; i++) {
-                char key[512];
-
-                sprintf (key, "glusterfs.file.%s.%06ld", bname, i);
-
-                ret = lgetxattr (dname, key, block, state->block_size);
-
-                if (ret < 0) {
-                        fprintf (stderr, "lgetxattr (%s, %s, %p) => %s\n",
-                                 dname, key, block, strerror (errno));
-                        break;
-                }
-                state->io_size += ret;
+    long int i;
+    int ret = -1;
+    char block[state->block_size];
+    char *dname = NULL, *dirc = NULL;
+    char *bname = NULL, *basec = NULL;
+
+    dirc = strdup(state->prefix);
+    basec = strdup(state->prefix);
+    dname = dirname(dirc);
+    bname = basename(basec);
+
+    for (i = 0; i < state->count; i++) {
+        char key[512];
+
+        sprintf(key, "glusterfs.file.%s.%06ld", bname, i);
+
+        ret = lgetxattr(dname, key, block, state->block_size);
+
+        if (ret < 0) {
+            fprintf(stderr, "lgetxattr (%s, %s, %p) => %s\n", dname, key, block,
+                    strerror(errno));
+            break;
         }
+        state->io_size += ret;
+    }
 
-        return i;
+    return i;
 }
 
-
 int
-do_mode_posix_iface_xattr (struct state *state)
+do_mode_posix_iface_xattr(struct state *state)
 {
-        if (state->need_op_write)
-                MEASURE (do_mode_posix_iface_xattr_write, state);
+    if (state->need_op_write)
+        MEASURE(do_mode_posix_iface_xattr_write, state);
 
-        if (state->need_op_read)
-                MEASURE (do_mode_posix_iface_xattr_read, state);
+    if (state->need_op_read)
+        MEASURE(do_mode_posix_iface_xattr_read, state);
 
-        return 0;
+    return 0;
 }
 
 int
-do_mode_posix (struct state *state)
+do_mode_posix(struct state *state)
 {
-        if (state->need_iface_fileio)
-                do_mode_posix_iface_fileio (state);
+    if (state->need_iface_fileio)
+        do_mode_posix_iface_fileio(state);
 
-        if (state->need_iface_xattr)
-                do_mode_posix_iface_xattr (state);
+    if (state->need_iface_xattr)
+        do_mode_posix_iface_xattr(state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-do_actions (struct state *state)
+do_actions(struct state *state)
 {
-        if (state->need_mode_posix)
-                do_mode_posix (state);
+    if (state->need_mode_posix)
+        do_mode_posix(state);
 
-        return 0;
+    return 0;
 }
 
 static struct argp_option options[] = {
-        {"op", 'o', "OPERATIONS", 0,
-         "WRITE|READ|BOTH - defaults to BOTH"},
-        {"iface", 'i', "INTERFACE", 0,
-         "FILEIO|XATTR|BOTH - defaults to FILEIO"},
-        {"block", 'b', "BLOCKSIZE", 0,
-         "<NUM> - defaults to 4096"},
-        {"specfile", 's', "SPECFILE", 0,
-         "absolute path to specfile"},
-        {"prefix", 'p', "PREFIX", 0,
-         "filename prefix"},
-        {"count", 'c', "COUNT", 0,
-         "number of files"},
-        {0, 0, 0, 0, 0}
-};
+    {"op", 'o', "OPERATIONS", 0, "WRITE|READ|BOTH - defaults to BOTH"},
+    {"iface", 'i', "INTERFACE", 0, "FILEIO|XATTR|BOTH - defaults to FILEIO"},
+    {"block", 'b', "BLOCKSIZE", 0, "<NUM> - defaults to 4096"},
+    {"specfile", 's', "SPECFILE", 0, "absolute path to specfile"},
+    {"prefix", 'p', "PREFIX", 0, "filename prefix"},
+    {"count", 'c', "COUNT", 0, "number of files"},
+    {0, 0, 0, 0, 0}};
 
-static struct argp argp = {
-        options,
-        parse_opts,
-        "tool",
-        "tool to benchmark small file performance"
-};
+static struct argp argp = {options, parse_opts, "tool",
+                           "tool to benchmark small file performance"};
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        struct state state = {0, };
+    struct state state = {
+        0,
+    };
 
-        state.need_op_write = 1;
-        state.need_op_read = 1;
+    state.need_op_write = 1;
+    state.need_op_read = 1;
 
-        state.need_iface_fileio = 1;
-        state.need_iface_xattr = 0;
+    state.need_iface_fileio = 1;
+    state.need_iface_xattr = 0;
 
-        state.need_mode_posix = 1;
+    state.need_mode_posix = 1;
 
-        state.block_size = 4096;
+    state.block_size = 4096;
 
-        strcpy (state.prefix, "tmpfile");
-        state.count = 1048576;
+    strcpy(state.prefix, "tmpfile");
+    state.count = 1048576;
 
-        if (argp_parse (&argp, argc, argv, 0, 0, &state) != 0) {
-                fprintf (stderr, "argp_parse() failed\n");
-                return 1;
-        }
+    if (argp_parse(&argp, argc, argv, 0, 0, &state) != 0) {
+        fprintf(stderr, "argp_parse() failed\n");
+        return 1;
+    }
 
-        do_actions (&state);
+    do_actions(&state);
 
-        return 0;
+    return 0;
 }
diff --git a/extras/benchmarking/rdd.c b/extras/benchmarking/rdd.c
index a667c6a1d65..efc9d342a37 100644
--- a/extras/benchmarking/rdd.c
+++ b/extras/benchmarking/rdd.c
@@ -20,633 +20,586 @@
 
 #define TWO_POWER(power) (2UL << (power))
 
-#define RDD_INTEGER_VALUE ((TWO_POWER ((sizeof (int) * 8))) - 1)
+#define RDD_INTEGER_VALUE ((TWO_POWER((sizeof(int) * 8))) - 1)
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX 108
 #endif
 
 #define UNIT_KB 1024ULL
-#define UNIT_MB UNIT_KB*1024ULL
-#define UNIT_GB UNIT_MB*1024ULL
-#define UNIT_TB UNIT_GB*1024ULL
-#define UNIT_PB UNIT_TB*1024ULL
+#define UNIT_MB UNIT_KB * 1024ULL
+#define UNIT_GB UNIT_MB * 1024ULL
+#define UNIT_TB UNIT_GB * 1024ULL
+#define UNIT_PB UNIT_TB * 1024ULL
 
-#define UNIT_KB_STRING    "KB"
-#define UNIT_MB_STRING    "MB"
-#define UNIT_GB_STRING    "GB"
-#define UNIT_TB_STRING    "TB"
-#define UNIT_PB_STRING    "PB"
+#define UNIT_KB_STRING "KB"
+#define UNIT_MB_STRING "MB"
+#define UNIT_GB_STRING "GB"
+#define UNIT_TB_STRING "TB"
+#define UNIT_PB_STRING "PB"
 
 struct rdd_file {
-        char path[UNIX_PATH_MAX];
-        struct stat st;
-        int fd;
+    char path[UNIX_PATH_MAX];
+    struct stat st;
+    int fd;
 };
 
 struct rdd_config {
-        long iters;
-        long max_ops_per_seq;
-        size_t max_bs;
-        size_t min_bs;
-        int thread_count;
-        pthread_t *threads;
-        pthread_barrier_t barrier;
-        pthread_mutex_t lock;
-        struct rdd_file in_file;
-        struct rdd_file out_file;
-        ssize_t file_size;
+    long iters;
+    long max_ops_per_seq;
+    size_t max_bs;
+    size_t min_bs;
+    int thread_count;
+    pthread_t *threads;
+    pthread_barrier_t barrier;
+    pthread_mutex_t lock;
+    struct rdd_file in_file;
+    struct rdd_file out_file;
+    ssize_t file_size;
 };
 static struct rdd_config rdd_config;
 
 enum rdd_keys {
-        RDD_MIN_BS_KEY = 1,
-        RDD_MAX_BS_KEY,
+    RDD_MIN_BS_KEY = 1,
+    RDD_MAX_BS_KEY,
 };
 
 static error_t
-rdd_parse_opts (int key, char *arg,
-                struct argp_state *_state)
+rdd_parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        switch (key) {
-        case 'o':
-        {
-                int len = 0;
-                len = strlen (arg);
-                if (len > UNIX_PATH_MAX) {
-                        fprintf (stderr, "output file name too long (%s)\n",
-                                 arg);
-                        return -1;
-                }
-
-                strncpy (rdd_config.out_file.path, arg, len);
-        }
-        break;
-
-        case 'i':
-        {
-                int len = 0;
-                len = strlen (arg);
-                if (len > UNIX_PATH_MAX) {
-                        fprintf (stderr, "input file name too long (%s)\n",
-                                 arg);
-                        return -1;
-                }
-
-                strncpy (rdd_config.in_file.path, arg, len);
-                rdd_config.in_file.path[len] = '\0';
-        }
-        break;
-
-        case 'f':
-        {
-                char *tmp = NULL;
-                unsigned long long fs = 0;
-                if (string2bytesize (arg, &fs) == -1) {
-                        fprintf (stderr, "invalid argument for file size "
-                                 "(%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.file_size = fs;
-        }
-        break;
-
-        case RDD_MIN_BS_KEY:
-        {
-                char *tmp = NULL;
-                long bs = 0;
-                bs = strtol (arg, &tmp, 10);
-                if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for minimum block"
-                                 "size (%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.min_bs = bs;
-        }
-        break;
-
-        case RDD_MAX_BS_KEY:
-        {
-                char *tmp = NULL;
-                long bs = 0;
-                bs = strtol (arg, &tmp, 10);
-                if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for maximum block"
-                                 "size (%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.max_bs = bs;
-        }
-        break;
-
-        case 'r':
-        {
-                char *tmp = NULL;
-                long iters = 0;
-                iters = strtol (arg, &tmp, 10);
-                if ((iters == LONG_MAX) ||
-                    (iters == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for iterations"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
-
-                rdd_config.iters = iters;
-        }
-        break;
-
-        case 'm':
-        {
-                char *tmp = NULL;
-                long max_ops = 0;
-                max_ops = strtol (arg, &tmp, 10);
-                if ((max_ops == LONG_MAX) ||
-                    (max_ops == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for max-ops"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
+    switch (key) {
+        case 'o': {
+            int len = 0;
+            len = strlen(arg);
+            if (len > UNIX_PATH_MAX) {
+                fprintf(stderr, "output file name too long (%s)\n", arg);
+                return -1;
+            }
 
-                rdd_config.max_ops_per_seq = max_ops;
-        }
-        break;
+            strncpy(rdd_config.out_file.path, arg, len);
+        } break;
 
-        case 't':
-        {
-                char *tmp = NULL;
-                long threads = 0;
-                threads = strtol (arg, &tmp, 10);
-                if ((threads == LONG_MAX) ||
-                    (threads == LONG_MIN) ||
-                    (tmp && *tmp)) {
-                        fprintf (stderr, "invalid argument for thread count"
-                                 "(%s)\n", arg);
-                        return -1;
-                }
+        case 'i': {
+            int len = 0;
+            len = strlen(arg);
+            if (len > UNIX_PATH_MAX) {
+                fprintf(stderr, "input file name too long (%s)\n", arg);
+                return -1;
+            }
+
+            strncpy(rdd_config.in_file.path, arg, len);
+            rdd_config.in_file.path[len] = '\0';
+        } break;
+
+        case 'f': {
+            char *tmp = NULL;
+            unsigned long long fs = 0;
+            if (string2bytesize(arg, &fs) == -1) {
+                fprintf(stderr,
+                        "invalid argument for file size "
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.file_size = fs;
+        } break;
+
+        case RDD_MIN_BS_KEY: {
+            char *tmp = NULL;
+            long bs = 0;
+            bs = strtol(arg, &tmp, 10);
+            if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for minimum block"
+                        "size (%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.min_bs = bs;
+        } break;
+
+        case RDD_MAX_BS_KEY: {
+            char *tmp = NULL;
+            long bs = 0;
+            bs = strtol(arg, &tmp, 10);
+            if ((bs == LONG_MAX) || (bs == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for maximum block"
+                        "size (%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.max_bs = bs;
+        } break;
+
+        case 'r': {
+            char *tmp = NULL;
+            long iters = 0;
+            iters = strtol(arg, &tmp, 10);
+            if ((iters == LONG_MAX) || (iters == LONG_MIN) || (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for iterations"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.iters = iters;
+        } break;
+
+        case 'm': {
+            char *tmp = NULL;
+            long max_ops = 0;
+            max_ops = strtol(arg, &tmp, 10);
+            if ((max_ops == LONG_MAX) || (max_ops == LONG_MIN) ||
+                (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for max-ops"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
+
+            rdd_config.max_ops_per_seq = max_ops;
+        } break;
+
+        case 't': {
+            char *tmp = NULL;
+            long threads = 0;
+            threads = strtol(arg, &tmp, 10);
+            if ((threads == LONG_MAX) || (threads == LONG_MIN) ||
+                (tmp && *tmp)) {
+                fprintf(stderr,
+                        "invalid argument for thread count"
+                        "(%s)\n",
+                        arg);
+                return -1;
+            }
 
-                rdd_config.thread_count = threads;
-        }
-        break;
+            rdd_config.thread_count = threads;
+        } break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
+            break;
         case ARGP_KEY_END:
-                if (_state->argc == 1) {
-                        argp_usage (_state);
-                }
+            if (_state->argc == 1) {
+                argp_usage(_state);
+            }
+    }
 
-        }
-
-        return 0;
+    return 0;
 }
 
 int
-string2bytesize (const char *str, unsigned long long *n)
+string2bytesize(const char *str, unsigned long long *n)
 {
-        unsigned long long value = 0ULL;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL)
-        {
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++)
-        {
-                if (isspace (*s))
-                {
-                        continue;
-                }
-                if (*s == '-')
-                {
-                        return -1;
-                }
-                break;
+    unsigned long long value = 0ULL;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+
+    if (str == NULL || n == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s)) {
+            continue;
         }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoull (str, &tail, 10);
-
-        if (errno == ERANGE || errno == EINVAL)
-        {
-                return -1;
+        if (*s == '-') {
+            return -1;
         }
-
-        if (errno == 0)
-        {
-                errno = old_errno;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoull(str, &tail, 10);
+
+    if (errno == ERANGE || errno == EINVAL) {
+        return -1;
+    }
+
+    if (errno == 0) {
+        errno = old_errno;
+    }
+
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, UNIT_KB_STRING) == 0) {
+            value *= UNIT_KB;
+        } else if (strcasecmp(tail, UNIT_MB_STRING) == 0) {
+            value *= UNIT_MB;
+        } else if (strcasecmp(tail, UNIT_GB_STRING) == 0) {
+            value *= UNIT_GB;
+        } else if (strcasecmp(tail, UNIT_TB_STRING) == 0) {
+            value *= UNIT_TB;
+        } else if (strcasecmp(tail, UNIT_PB_STRING) == 0) {
+            value *= UNIT_PB;
         }
 
-        if (tail[0] != '\0')
-        {
-                if (strcasecmp (tail, UNIT_KB_STRING) == 0)
-                {
-                        value *= UNIT_KB;
-                }
-                else if (strcasecmp (tail, UNIT_MB_STRING) == 0)
-                {
-                        value *= UNIT_MB;
-                }
-                else if (strcasecmp (tail, UNIT_GB_STRING) == 0)
-                {
-                        value *= UNIT_GB;
-                }
-                else if (strcasecmp (tail, UNIT_TB_STRING) == 0)
-                {
-                        value *= UNIT_TB;
-                }
-                else if (strcasecmp (tail, UNIT_PB_STRING) == 0)
-                {
-                        value *= UNIT_PB;
-                }
-
-                else
-                {
-                        return -1;
-                }
+        else {
+            return -1;
         }
+    }
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static struct argp_option rdd_options[] = {
-        {"if", 'i', "INPUT_FILE", 0, "input-file"},
-        {"of", 'o', "OUTPUT_FILE", 0, "output-file"},
-        {"threads", 't', "COUNT", 0, "number of threads to spawn (defaults to 2)"},
-        {"min-bs", RDD_MIN_BS_KEY, "MIN_BLOCK_SIZE", 0,
-         "Minimum block size in bytes (defaults to 1024)"},
-        {"max-bs", RDD_MAX_BS_KEY, "MAX_BLOCK_SIZE", 0,
-         "Maximum block size in bytes (defaults to 4096)"},
-        {"iters", 'r', "ITERS", 0,
-         "Number of read-write sequences (defaults to 1000000)"},
-        {"max-ops", 'm', "MAXOPS", 0,
-         "maximum number of read-writes to be performed in a sequence (defaults to 1)"},
-        {"file-size", 'f', "FILESIZE", 0,
-         "the size of the file which will be created and upon it I/O will be done"
-         " (defaults to 100MB"},
-        {0, 0, 0, 0, 0}
-};
+    {"if", 'i', "INPUT_FILE", 0, "input-file"},
+    {"of", 'o', "OUTPUT_FILE", 0, "output-file"},
+    {"threads", 't', "COUNT", 0, "number of threads to spawn (defaults to 2)"},
+    {"min-bs", RDD_MIN_BS_KEY, "MIN_BLOCK_SIZE", 0,
+     "Minimum block size in bytes (defaults to 1024)"},
+    {"max-bs", RDD_MAX_BS_KEY, "MAX_BLOCK_SIZE", 0,
+     "Maximum block size in bytes (defaults to 4096)"},
+    {"iters", 'r', "ITERS", 0,
+     "Number of read-write sequences (defaults to 1000000)"},
+    {"max-ops", 'm', "MAXOPS", 0,
+     "maximum number of read-writes to be performed in a sequence (defaults to "
+     "1)"},
+    {"file-size", 'f', "FILESIZE", 0,
+     "the size of the file which will be created and upon it I/O will be done"
+     " (defaults to 100MB"},
+    {0, 0, 0, 0, 0}};
 
 static struct argp argp = {
-  rdd_options,
-  rdd_parse_opts,
-  "",
-  "random dd - tool to do a sequence of random block-sized continuous"
-  "read writes starting at a random offset"
-};
-
+    rdd_options, rdd_parse_opts, "",
+    "random dd - tool to do a sequence of random block-sized continuous"
+    "read writes starting at a random offset"};
 
 static void
-rdd_default_config (void)
+rdd_default_config(void)
 {
-        char *tmp_path = "rdd.in";
-
-        rdd_config.thread_count = 2;
-        rdd_config.iters = 1000000;
-        rdd_config.max_bs = 4096;
-        rdd_config.min_bs = 1024;
-        rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
-        rdd_config.max_ops_per_seq = 1;
-        strncpy (rdd_config.in_file.path, tmp_path, strlen (tmp_path));
-        rdd_config.file_size = 104857600;
-
-        return;
+    char *tmp_path = "rdd.in";
+
+    rdd_config.thread_count = 2;
+    rdd_config.iters = 1000000;
+    rdd_config.max_bs = 4096;
+    rdd_config.min_bs = 1024;
+    rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
+    rdd_config.max_ops_per_seq = 1;
+    strncpy(rdd_config.in_file.path, tmp_path, strlen(tmp_path));
+    rdd_config.file_size = 104857600;
+
+    return;
 }
 
-
 static char
-rdd_valid_config (void)
+rdd_valid_config(void)
 {
-        char ret = 1;
-        int fd = -1;
+    char ret = 1;
+    int fd = -1;
 
-        fd = open (rdd_config.in_file.path, O_RDONLY);
-        if (fd == -1 && (errno != ENOENT)) {
-                fprintf (stderr, "open: (%s)", strerror (errno));
-                ret = 0;
-                goto out;
-        }
-        close (fd);
-
-        if (rdd_config.min_bs > rdd_config.max_bs) {
-                fprintf (stderr, "minimum blocksize %ld is greater than the "
-                         "maximum blocksize %ld", rdd_config.min_bs,
-                         rdd_config.max_bs);
-                ret = 0;
-                goto out;
-        }
+    fd = open(rdd_config.in_file.path, O_RDONLY);
+    if (fd == -1 && (errno != ENOENT)) {
+        fprintf(stderr, "open: (%s)", strerror(errno));
+        ret = 0;
+        goto out;
+    }
+    close(fd);
+
+    if (rdd_config.min_bs > rdd_config.max_bs) {
+        fprintf(stderr,
+                "minimum blocksize %ld is greater than the "
+                "maximum blocksize %ld",
+                rdd_config.min_bs, rdd_config.max_bs);
+        ret = 0;
+        goto out;
+    }
 
-        if (strlen (rdd_config.out_file.path) == 0) {
-                sprintf (rdd_config.out_file.path, "%s.rddout",
-                         rdd_config.in_file.path);
-        }
+    if (strlen(rdd_config.out_file.path) == 0) {
+        sprintf(rdd_config.out_file.path, "%s.rddout", rdd_config.in_file.path);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static void *
-rdd_read_write (void *arg)
+rdd_read_write(void *arg)
 {
-        int i = 0, ret = 0;
-        size_t bs = 0;
-        off_t offset = 0;
-        long rand = 0;
-        long max_ops = 0;
-        char *buf = NULL;
-
-        buf = calloc (1, rdd_config.max_bs);
-        if (!buf) {
-                fprintf (stderr, "calloc failed (%s)\n", strerror (errno));
+    int i = 0, ret = 0;
+    size_t bs = 0;
+    off_t offset = 0;
+    long rand = 0;
+    long max_ops = 0;
+    char *buf = NULL;
+
+    buf = calloc(1, rdd_config.max_bs);
+    if (!buf) {
+        fprintf(stderr, "calloc failed (%s)\n", strerror(errno));
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < rdd_config.iters; i++) {
+        pthread_mutex_lock(&rdd_config.lock);
+        {
+            int bytes = 0;
+            rand = random();
+
+            if (rdd_config.min_bs == rdd_config.max_bs) {
+                bs = rdd_config.max_bs;
+            } else {
+                bs = rdd_config.min_bs +
+                     (rand % (rdd_config.max_bs - rdd_config.min_bs));
+            }
+
+            offset = rand % rdd_config.in_file.st.st_size;
+            max_ops = rand % rdd_config.max_ops_per_seq;
+            if (!max_ops) {
+                max_ops++;
+            }
+
+            ret = lseek(rdd_config.in_file.fd, offset, SEEK_SET);
+            if (ret != offset) {
+                fprintf(stderr, "lseek failed (%s)\n", strerror(errno));
                 ret = -1;
-                goto out;
-        }
+                goto unlock;
+            }
 
-        for (i = 0; i < rdd_config.iters; i++)
-        {
-                pthread_mutex_lock (&rdd_config.lock);
-                {
-                        int bytes = 0;
-                        rand = random ();
-
-                        if (rdd_config.min_bs == rdd_config.max_bs) {
-                                bs = rdd_config.max_bs;
-                        } else {
-                                bs = rdd_config.min_bs +
-                                        (rand %
-                                         (rdd_config.max_bs -
-                                          rdd_config.min_bs));
-                        }
-
-                        offset = rand % rdd_config.in_file.st.st_size;
-                        max_ops = rand % rdd_config.max_ops_per_seq;
-                        if (!max_ops) {
-                                max_ops ++;
-                        }
-
-                        ret = lseek (rdd_config.in_file.fd, offset, SEEK_SET);
-                        if (ret != offset) {
-                                fprintf (stderr, "lseek failed (%s)\n",
-                                         strerror (errno));
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        ret = lseek (rdd_config.out_file.fd, offset, SEEK_SET);
-                        if (ret != offset) {
-                                fprintf (stderr, "lseek failed (%s)\n",
-                                         strerror (errno));
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        while (max_ops--)
-                        {
-                                bytes = read (rdd_config.in_file.fd, buf, bs);
-                                if (!bytes) {
-                                        break;
-                                }
-
-                                if (bytes == -1) {
-                                        fprintf (stderr, "read failed (%s)\n",
-                                                 strerror (errno));
-                                        ret = -1;
-                                        goto unlock;
-                                }
-
-                                if (write (rdd_config.out_file.fd, buf, bytes)
-                                    != bytes) {
-                                        fprintf (stderr, "write failed (%s)\n",
-                                                 strerror (errno));
-                                        ret = -1;
-                                        goto unlock;
-                                }
-                        }
+            ret = lseek(rdd_config.out_file.fd, offset, SEEK_SET);
+            if (ret != offset) {
+                fprintf(stderr, "lseek failed (%s)\n", strerror(errno));
+                ret = -1;
+                goto unlock;
+            }
+
+            while (max_ops--) {
+                bytes = read(rdd_config.in_file.fd, buf, bs);
+                if (!bytes) {
+                    break;
                 }
-        unlock:
-                pthread_mutex_unlock (&rdd_config.lock);
-                if (ret == -1) {
-                        goto out;
+
+                if (bytes == -1) {
+                    fprintf(stderr, "read failed (%s)\n", strerror(errno));
+                    ret = -1;
+                    goto unlock;
+                }
+
+                if (write(rdd_config.out_file.fd, buf, bytes) != bytes) {
+                    fprintf(stderr, "write failed (%s)\n", strerror(errno));
+                    ret = -1;
+                    goto unlock;
                 }
-                ret = 0;
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&rdd_config.lock);
+        if (ret == -1) {
+            goto out;
+        }
+        ret = 0;
+    }
 out:
-        free (buf);
-        pthread_barrier_wait (&rdd_config.barrier);
+    free(buf);
+    pthread_barrier_wait(&rdd_config.barrier);
 
-        return NULL;
+    return NULL;
 }
 
 static void
-cleanup (void)
+cleanup(void)
 {
-        close (rdd_config.in_file.fd);
-        close (rdd_config.out_file.fd);
-        rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
+    close(rdd_config.in_file.fd);
+    close(rdd_config.out_file.fd);
+    rdd_config.in_file.fd = rdd_config.out_file.fd = -1;
 }
 
 static int
-check_and_create (void)
+check_and_create(void)
 {
-        int ret = -1;
-        char buf[4096] = {0,};
-        struct stat stbuf = {0,};
-        int  fd[2] = {-1,};
-        size_t  total_size = -1;
-
-        total_size = rdd_config.file_size;
-
-        ret = stat (rdd_config.in_file.path, &stbuf);
-        if (ret == -1 && (errno != ENOENT))
+    int ret = -1;
+    char buf[4096] = {
+        0,
+    };
+    struct stat stbuf = {
+        0,
+    };
+    int fd[2] = {
+        -1,
+    };
+    size_t total_size = -1;
+
+    total_size = rdd_config.file_size;
+
+    ret = stat(rdd_config.in_file.path, &stbuf);
+    if (ret == -1 && (errno != ENOENT))
+        goto out;
+
+    fd[1] = open(rdd_config.in_file.path, O_CREAT | O_WRONLY | O_TRUNC);
+    if (fd[1] == -1)
+        goto out;
+
+    fd[0] = open("/dev/urandom", O_RDONLY);
+    if (fd[0] == -1)
+        goto out;
+
+    while (total_size > 0) {
+        if (total_size >= 4096) {
+            ret = read(fd[0], buf, 4096);
+            if (ret == -1)
                 goto out;
-
-        fd[1] = open (rdd_config.in_file.path, O_CREAT | O_WRONLY | O_TRUNC);
-        if (fd[1] == -1)
+            ret = write(fd[1], buf, 4096);
+            if (ret == -1)
                 goto out;
-
-        fd[0] = open ("/dev/urandom", O_RDONLY);
-        if (fd[0] == -1)
+            total_size = total_size - 4096;
+        } else {
+            ret = read(fd[0], buf, total_size);
+            if (ret == -1)
                 goto out;
-
-        while (total_size > 0) {
-                if (total_size >= 4096) {
-                        ret = read (fd[0], buf, 4096);
-                        if (ret == -1)
-                                goto out;
-                        ret = write (fd[1], buf, 4096);
-                        if (ret == -1)
-                                goto out;
-                        total_size = total_size - 4096;
-                } else {
-                        ret = read (fd[0], buf, total_size);
-                        if (ret == -1)
-                                goto out;
-                        ret = write (fd[1], buf, total_size);
-                        if (ret == -1)
-                                goto out;
-                        total_size = total_size - total_size;
-                }
-
+            ret = write(fd[1], buf, total_size);
+            if (ret == -1)
+                goto out;
+            total_size = total_size - total_size;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd[0] > 0)
-                close (fd[0]);
-        if (fd[1] > 0)
-                close (fd[1]);
-        return ret;
+    if (fd[0] > 0)
+        close(fd[0]);
+    if (fd[1] > 0)
+        close(fd[1]);
+    return ret;
 }
 
 static int
-rdd_spawn_threads (void)
+rdd_spawn_threads(void)
 {
-        int i = 0, ret = -1, fd = -1;
-        char buf[4096];
-
-        ret = check_and_create ();
-        if (ret == -1)
-                goto out;
-
-        fd = open (rdd_config.in_file.path, O_RDONLY);
-        if (fd < 0) {
-                fprintf (stderr, "cannot open %s (%s)\n",
-                         rdd_config.in_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        ret = fstat (fd, &rdd_config.in_file.st);
-        if (ret != 0) {
-                close (fd);
-                fprintf (stderr, "cannot stat %s (%s)\n",
-                         rdd_config.in_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        rdd_config.in_file.fd = fd;
-
-        fd = open (rdd_config.out_file.path, O_WRONLY | O_CREAT | O_TRUNC,
-                   S_IRWXU | S_IROTH);
-        if (fd < 0) {
-                close (rdd_config.in_file.fd);
-                rdd_config.in_file.fd = -1;
-                fprintf (stderr, "cannot open %s (%s)\n",
-                         rdd_config.out_file.path, strerror (errno));
-                ret = -1;
-                goto out;
-        }
-        rdd_config.out_file.fd = fd;
-
-        while ((ret = read (rdd_config.in_file.fd, buf, 4096)) > 0) {
-                if (write (rdd_config.out_file.fd, buf, ret) != ret) {
-                        fprintf (stderr, "write failed (%s)\n",
-                                 strerror (errno));
-                        cleanup ();
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        rdd_config.threads = calloc (rdd_config.thread_count,
-                                     sizeof (pthread_t));
-        if (rdd_config.threads == NULL) {
-                fprintf (stderr, "calloc() failed (%s)\n", strerror (errno));
-
-                ret = -1;
-                cleanup ();
-                goto out;
-        }
-
-        ret = pthread_barrier_init (&rdd_config.barrier, NULL,
-                                    rdd_config.thread_count + 1);
-        if (ret != 0) {
-                fprintf (stderr, "pthread_barrier_init() failed (%s)\n",
-                         strerror (ret));
-
-                free (rdd_config.threads);
-                cleanup ();
-                ret = -1;
-                goto out;
+    int i = 0, ret = -1, fd = -1;
+    char buf[4096];
+
+    ret = check_and_create();
+    if (ret == -1)
+        goto out;
+
+    fd = open(rdd_config.in_file.path, O_RDONLY);
+    if (fd < 0) {
+        fprintf(stderr, "cannot open %s (%s)\n", rdd_config.in_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    ret = fstat(fd, &rdd_config.in_file.st);
+    if (ret != 0) {
+        close(fd);
+        fprintf(stderr, "cannot stat %s (%s)\n", rdd_config.in_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    rdd_config.in_file.fd = fd;
+
+    fd = open(rdd_config.out_file.path, O_WRONLY | O_CREAT | O_TRUNC,
+              S_IRWXU | S_IROTH);
+    if (fd < 0) {
+        close(rdd_config.in_file.fd);
+        rdd_config.in_file.fd = -1;
+        fprintf(stderr, "cannot open %s (%s)\n", rdd_config.out_file.path,
+                strerror(errno));
+        ret = -1;
+        goto out;
+    }
+    rdd_config.out_file.fd = fd;
+
+    while ((ret = read(rdd_config.in_file.fd, buf, 4096)) > 0) {
+        if (write(rdd_config.out_file.fd, buf, ret) != ret) {
+            fprintf(stderr, "write failed (%s)\n", strerror(errno));
+            cleanup();
+            ret = -1;
+            goto out;
         }
-
-        ret = pthread_mutex_init (&rdd_config.lock, NULL);
+    }
+
+    rdd_config.threads = calloc(rdd_config.thread_count, sizeof(pthread_t));
+    if (rdd_config.threads == NULL) {
+        fprintf(stderr, "calloc() failed (%s)\n", strerror(errno));
+
+        ret = -1;
+        cleanup();
+        goto out;
+    }
+
+    ret = pthread_barrier_init(&rdd_config.barrier, NULL,
+                               rdd_config.thread_count + 1);
+    if (ret != 0) {
+        fprintf(stderr, "pthread_barrier_init() failed (%s)\n", strerror(ret));
+
+        free(rdd_config.threads);
+        cleanup();
+        ret = -1;
+        goto out;
+    }
+
+    ret = pthread_mutex_init(&rdd_config.lock, NULL);
+    if (ret != 0) {
+        fprintf(stderr, "pthread_mutex_init() failed (%s)\n", strerror(ret));
+
+        free(rdd_config.threads);
+        pthread_barrier_destroy(&rdd_config.barrier);
+        cleanup();
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < rdd_config.thread_count; i++) {
+        ret = pthread_create(&rdd_config.threads[i], NULL, rdd_read_write,
+                             NULL);
         if (ret != 0) {
-                fprintf (stderr, "pthread_mutex_init() failed (%s)\n",
-                         strerror (ret));
-
-                free (rdd_config.threads);
-                pthread_barrier_destroy (&rdd_config.barrier);
-                cleanup ();
-                ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < rdd_config.thread_count; i++)
-        {
-                ret = pthread_create (&rdd_config.threads[i], NULL,
-                                      rdd_read_write, NULL);
-                if (ret != 0) {
-                        fprintf (stderr, "pthread_create failed (%s)\n",
-                                 strerror (errno));
-                        exit (1);
-                }
+            fprintf(stderr, "pthread_create failed (%s)\n", strerror(errno));
+            exit(1);
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static void
-rdd_wait_for_completion (void)
+rdd_wait_for_completion(void)
 {
-        pthread_barrier_wait (&rdd_config.barrier);
+    pthread_barrier_wait(&rdd_config.barrier);
 }
 
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int ret = -1;
+    int ret = -1;
 
-        rdd_default_config ();
+    rdd_default_config();
 
-        ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "%s: argp_parse() failed\n", argv[0]);
-                goto err;
-        }
+    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "%s: argp_parse() failed\n", argv[0]);
+        goto err;
+    }
 
-        if (!rdd_valid_config ()) {
-                ret = -1;
-                fprintf (stderr, "%s: configuration validation failed\n",
-                         argv[0]);
-                goto err;
-        }
+    if (!rdd_valid_config()) {
+        ret = -1;
+        fprintf(stderr, "%s: configuration validation failed\n", argv[0]);
+        goto err;
+    }
 
-        ret = rdd_spawn_threads ();
-        if (ret != 0) {
-                fprintf (stderr, "%s: spawning threads failed\n", argv[0]);
-                goto err;
-        }
+    ret = rdd_spawn_threads();
+    if (ret != 0) {
+        fprintf(stderr, "%s: spawning threads failed\n", argv[0]);
+        goto err;
+    }
 
-        rdd_wait_for_completion ();
+    rdd_wait_for_completion();
 
 err:
-        return ret;
+    return ret;
 }
diff --git a/extras/create_new_xlator/new-xlator-tmpl.c b/extras/create_new_xlator/new-xlator-tmpl.c
index 474144c1c81..caa10b374d1 100644
--- a/extras/create_new_xlator/new-xlator-tmpl.c
+++ b/extras/create_new_xlator/new-xlator-tmpl.c
@@ -1,37 +1,32 @@
 #pragma fragment CBK_TEMPLATE
-int32_t
-@FOP_PREFIX@_@NAME@_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-        int32_t op_ret, int32_t op_errno, @UNWIND_PARAMS@)
+int32_t @FOP_PREFIX @_ @NAME
+    @_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+          int32_t op_errno, @UNWIND_PARAMS @)
 {
-        STACK_UNWIND_STRICT (@NAME@, frame, op_ret, op_errno,
-                             @UNWIND_ARGS@);
-        return 0;
+    STACK_UNWIND_STRICT(@NAME @, frame, op_ret, op_errno, @UNWIND_ARGS @);
+    return 0;
 }
 
 #pragma fragment COMMENT
-If you are generating the leaf xlators, remove the STACK_WIND
-and replace the @ERROR_ARGS@ to @UNWIND_ARGS@ if necessary
+If you are generating the leaf xlators, remove the STACK_WIND and replace the
+    @ERROR_ARGS @to @UNWIND_ARGS @ if necessary
 
 #pragma fragment FOP_TEMPLATE
-int32_t
-@FOP_PREFIX@_@NAME@ (call_frame_t *frame, xlator_t *this,
-        @WIND_PARAMS@)
+        int32_t @FOP_PREFIX @_ @NAME
+    @(call_frame_t *frame, xlator_t *this, @WIND_PARAMS @)
 {
-        STACK_WIND (frame, @FOP_PREFIX@_@NAME@_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->@NAME@,
-                    @WIND_ARGS@);
-        return 0;
+    STACK_WIND(frame, @FOP_PREFIX @_ @NAME @_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->@NAME @, @WIND_ARGS @);
+    return 0;
 err:
-        STACK_UNWIND_STRICT (@NAME@, frame, -1, errno,
-                             @ERROR_ARGS@);
-        return 0;
+    STACK_UNWIND_STRICT(@NAME @, frame, -1, errno, @ERROR_ARGS @);
+    return 0;
 }
 
 #pragma fragment FUNC_TEMPLATE
-@RET_TYPE@
-@FOP_PREFIX@_@NAME@ (@FUNC_PARAMS@)
+@RET_TYPE @ @FOP_PREFIX @_ @NAME @(@FUNC_PARAMS @)
 {
-        return @RET_VAR@;
+    return @RET_VAR @;
 }
 
 #pragma fragment CP
@@ -50,77 +45,71 @@ err:
 
 #pragma fragment XLATOR_METHODS
 
-static int32_t
-@FOP_PREFIX@_init (xlator_t *this)
+static int32_t @FOP_PREFIX @_init(xlator_t *this)
 {
-        return 0;
+    return 0;
 }
 
-static void
-@FOP_PREFIX@_fini (xlator_t *this)
+static void @FOP_PREFIX @_fini(xlator_t *this)
 {
-        return;
+    return;
 }
 
-static int32_t
-@FOP_PREFIX@_reconfigure (xlator_t *this, dict_t *dict)
+static int32_t @FOP_PREFIX @_reconfigure(xlator_t *this, dict_t *dict)
 {
-        return 0;
+    return 0;
 }
 
-static int
-@FOP_PREFIX@_notify (xlator_t *this, int event, void *data, ...)
+static int @FOP_PREFIX @_notify(xlator_t *this, int event, void *data, ...)
 {
-        return default_notify (this, event, data);
+    return default_notify(this, event, data);
 }
 
-static int32_t
-@FOP_PREFIX@_mem_acct_init (xlator_t *this)
+static int32_t @FOP_PREFIX @_mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_@FOP_PREFIX@_mt_end + 1);
-        return ret;
+    ret = xlator_mem_acct_init(this, gf_ @FOP_PREFIX @_mt_end + 1);
+    return ret;
 }
 
-static int32_t
-@FOP_PREFIX@_dump_metrics (xlator_t *this, int fd)
+static int32_t @FOP_PREFIX @_dump_metrics(xlator_t *this, int fd)
 {
-        return 0;
+    return 0;
 }
 
-struct volume_options @FOP_PREFIX@_options[] = {
-        /*{ .key  = {""},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "",
-          .op_version = {GD_OP_VERSION_},
-          .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT,
-          .tags = {""},
-          .description = "",
-          .category = GF_EXPERIMENTAL,
-        },
-        { .key = {NULL} },
-        */
+struct volume_options @FOP_PREFIX @_options[] = {
+    /*{ .key  = {""},
+      .type = GF_OPTION_TYPE_BOOL,
+      .default_value = "",
+      .op_version = {GD_OP_VERSION_},
+      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT,
+      .tags = {""},
+      .description = "",
+      .category = GF_EXPERIMENTAL,
+    },
+    { .key = {NULL} },
+    */
 };
 
 xlator_api_t xlator_api = {
-        .init          = @FOP_PREFIX@_init,
-        .fini          = @FOP_PREFIX@_fini,
-        .notify        = @FOP_PREFIX@_notify,
-        .reconfigure   = @FOP_PREFIX@_reconfigure,
-        .mem_acct_init = @FOP_PREFIX@_mem_acct_init,
-        .dump_metrics  = @FOP_PREFIX@_dump_metrics,
-        .op_version    = {GD_OP_VERSION_},
-        .dumpops       = &@FOP_PREFIX@_dumpops,
-        .fops          = &@FOP_PREFIX@_fops,
-        .cbks          = &@FOP_PREFIX@_cbks,
-        .options       = @FOP_PREFIX@_options,
-        .identifier    = "@XL_NAME@",
-        .category      = GF_EXPERIMENTAL,
+    .init = @FOP_PREFIX @_init,
+    .fini = @FOP_PREFIX @_fini,
+    .notify = @FOP_PREFIX @_notify,
+    .reconfigure = @FOP_PREFIX @_reconfigure,
+    .mem_acct_init = @FOP_PREFIX @_mem_acct_init,
+    .dump_metrics = @FOP_PREFIX @_dump_metrics,
+    .op_version = {GD_OP_VERSION_},
+    .dumpops = &@FOP_PREFIX @_dumpops,
+    .fops = &@FOP_PREFIX @_fops,
+    .cbks = &@FOP_PREFIX @_cbks,
+    .options = @FOP_PREFIX @_options,
+    .identifier = "@XL_NAME@",
+    .category = GF_EXPERIMENTAL,
 };
 #pragma fragment HEADER_FMT
-#ifndef __@HFL_NAME@_H__
-#define __@HFL_NAME@_H__
+#ifndef __ @HFL_NAME @_H__
+#define __ @HFL_NAME @_H__
 
 #include "@XL_NAME@-mem-types.h"
 #include "@XL_NAME@-messages.h"
@@ -131,21 +120,21 @@ xlator_api_t xlator_api = {
 #endif /* __@HFL_NAME@_H__ */
 
 #pragma fragment MEM_HEADER_FMT
-#ifndef __@HFL_NAME@_H__
-#define __@HFL_NAME@_H__
+#ifndef __ @HFL_NAME @_H__
+#define __ @HFL_NAME @_H__
 
 #include "mem-types.h"
 
 enum gf_mdc_mem_types_ {
-        gf_@FOP_PREFIX@_mt_   = gf_common_mt_end + 1,
-        gf_@FOP_PREFIX@_mt_end
+    gf_ @FOP_PREFIX @_mt_ = gf_common_mt_end + 1,
+    gf_ @FOP_PREFIX @_mt_end
 };
 
 #endif /* __@HFL_NAME@_H__ */
 
 #pragma fragment MSG_HEADER_FMT
-#ifndef __@HFL_NAME@_H__
-#define __@HFL_NAME@_H__
+#ifndef __ @HFL_NAME @_H__
+#define __ @HFL_NAME @_H__
 
 #include "glfs-message-id.h"
 
@@ -159,8 +148,6 @@ enum gf_mdc_mem_types_ {
  * glfs-message-id.h.
  */
 
-GLFS_MSGID(@FOP_PREFIX@,
-        @FOP_PREFIX@_MSG_NO_MEMORY
-);
+GLFS_MSGID(@FOP_PREFIX @, @FOP_PREFIX @_MSG_NO_MEMORY);
 
 #endif /* __@HFL_NAME@_H__ */
diff --git a/extras/geo-rep/gsync-sync-gfid.c b/extras/geo-rep/gsync-sync-gfid.c
index 4f4fde94e40..b0c5d31ba0b 100644
--- a/extras/geo-rep/gsync-sync-gfid.c
+++ b/extras/geo-rep/gsync-sync-gfid.c
@@ -15,96 +15,95 @@
 #endif
 
 #ifndef GF_FUSE_AUX_GFID_HEAL
-#define GF_FUSE_AUX_GFID_HEAL    "glusterfs.gfid.heal"
+#define GF_FUSE_AUX_GFID_HEAL "glusterfs.gfid.heal"
 #endif
 
-#define GLFS_LINE_MAX           (PATH_MAX + (2 * UUID_CANONICAL_FORM_LEN))
+#define GLFS_LINE_MAX (PATH_MAX + (2 * UUID_CANONICAL_FORM_LEN))
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char *file                = NULL;
-        char *tmp = NULL;
-        char *tmp1 = NULL;
-        char *parent_dir = NULL;
-        char *gfid                = NULL;
-        char *bname = NULL;
-        int   ret                 = -1;
-        int   len                 = 0;
-        FILE *fp                  = NULL;
-        char  line[GLFS_LINE_MAX] = {0,};
-        char *path = NULL;
-        void  *blob               = NULL;
-        void  *tmp_blob               = NULL;
-
-        if (argc != 2) {
-                /* each line in the file has the following format
-                 * uuid-in-canonical-form path-relative-to-gluster-mount.
-                 * Both uuid and relative path are from master mount.
-                 */
-                fprintf (stderr, "usage: %s <file-of-paths-to-be-synced>\n",
-                         argv[0]);
-                goto out;
+    char *file = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *parent_dir = NULL;
+    char *gfid = NULL;
+    char *bname = NULL;
+    int ret = -1;
+    int len = 0;
+    FILE *fp = NULL;
+    char line[GLFS_LINE_MAX] = {
+        0,
+    };
+    char *path = NULL;
+    void *blob = NULL;
+    void *tmp_blob = NULL;
+
+    if (argc != 2) {
+        /* each line in the file has the following format
+         * uuid-in-canonical-form path-relative-to-gluster-mount.
+         * Both uuid and relative path are from master mount.
+         */
+        fprintf(stderr, "usage: %s <file-of-paths-to-be-synced>\n", argv[0]);
+        goto out;
+    }
+
+    file = argv[1];
+
+    fp = fopen(file, "r");
+    if (fp == NULL) {
+        fprintf(stderr, "cannot open %s for reading (%s)\n", file,
+                strerror(errno));
+        goto out;
+    }
+
+    while (fgets(line, GLFS_LINE_MAX, fp) != NULL) {
+        tmp = line;
+        path = gfid = line;
+
+        path += UUID_CANONICAL_FORM_LEN + 1;
+
+        while (isspace(*path))
+            path++;
+
+        len = strlen(line);
+        if ((len < GLFS_LINE_MAX) && (line[len - 1] == '\n'))
+            line[len - 1] = '\0';
+
+        line[UUID_CANONICAL_FORM_LEN] = '\0';
+
+        tmp = strdup(path);
+        tmp1 = strdup(path);
+        parent_dir = dirname(tmp);
+        bname = basename(tmp1);
+
+        /* gfid + '\0' + bname + '\0' */
+        len = UUID_CANONICAL_FORM_LEN + 1 + strlen(bname) + 1;
+
+        blob = malloc(len);
+
+        memcpy(blob, gfid, UUID_CANONICAL_FORM_LEN);
+
+        tmp_blob = blob + UUID_CANONICAL_FORM_LEN + 1;
+
+        memcpy(tmp_blob, bname, strlen(bname));
+
+        ret = sys_lsetxattr(parent_dir, GF_FUSE_AUX_GFID_HEAL, blob, len, 0);
+        if (ret < 0) {
+            fprintf(stderr, "setxattr on %s/%s failed (%s)\n", parent_dir,
+                    bname, strerror(errno));
         }
+        memset(line, 0, GLFS_LINE_MAX);
 
-        file = argv[1];
+        free(blob);
+        free(tmp);
+        free(tmp1);
+        blob = NULL;
+    }
 
-        fp = fopen (file, "r");
-        if (fp == NULL) {
-                fprintf (stderr, "cannot open %s for reading (%s)\n",
-                         file, strerror (errno));
-                goto out;
-        }
-
-        while (fgets (line, GLFS_LINE_MAX, fp) != NULL) {
-                tmp = line;
-                path = gfid = line;
-
-                path += UUID_CANONICAL_FORM_LEN + 1;
-
-                while(isspace (*path))
-                        path++;
-
-                len = strlen (line);
-                if ((len < GLFS_LINE_MAX) &&
-                    (line[len - 1] == '\n'))
-                        line[len - 1] = '\0';
-
-                line[UUID_CANONICAL_FORM_LEN] = '\0';
-
-                tmp = strdup (path);
-                tmp1 = strdup (path);
-                parent_dir = dirname (tmp);
-                bname = basename (tmp1);
-
-                /* gfid + '\0' + bname + '\0' */
-                len = UUID_CANONICAL_FORM_LEN + 1 + strlen (bname) + 1;
-
-                blob = malloc (len);
-
-                memcpy (blob, gfid, UUID_CANONICAL_FORM_LEN);
-
-                tmp_blob = blob + UUID_CANONICAL_FORM_LEN + 1;
-
-                memcpy (tmp_blob, bname, strlen (bname));
-
-                ret = sys_lsetxattr (parent_dir, GF_FUSE_AUX_GFID_HEAL, 
-                                blob, len, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "setxattr on %s/%s failed (%s)\n",
-                                 parent_dir, bname, strerror (errno));
-                }
-                memset (line, 0, GLFS_LINE_MAX);
-
-                free (blob);
-                free (tmp); free (tmp1);
-                blob = NULL;
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        if (fp)
-                fclose(fp);
-        return ret;
+    if (fp)
+        fclose(fp);
+    return ret;
 }
-
diff --git a/extras/stripe-merge.c b/extras/stripe-merge.c
index 332690eea66..e013a6e6e8a 100644
--- a/extras/stripe-merge.c
+++ b/extras/stripe-merge.c
@@ -40,33 +40,33 @@
 #define INVALID_MODE UINT32_MAX
 
 struct file_stripe_info {
-	int stripe_count;
-	int stripe_size;
-	int coalesce;
-	mode_t mode;
-	int fd[0];
+    int stripe_count;
+    int stripe_size;
+    int coalesce;
+    mode_t mode;
+    int fd[0];
 };
 
-static int close_files(struct file_stripe_info *);
+static int
+close_files(struct file_stripe_info *);
 
-static struct
-file_stripe_info *alloc_file_stripe_info(int count)
+static struct file_stripe_info *
+alloc_file_stripe_info(int count)
 {
-	int i;
-	struct file_stripe_info *finfo;
+    int i;
+    struct file_stripe_info *finfo;
 
-	finfo = calloc(1, sizeof(struct file_stripe_info) +
-		(sizeof(int) * count));
-	if (!finfo)
-		return NULL;
+    finfo = calloc(1, sizeof(struct file_stripe_info) + (sizeof(int) * count));
+    if (!finfo)
+        return NULL;
 
-	for (i = 0; i < count; i++)
-		finfo->fd[i] = INVALID_FD;
+    for (i = 0; i < count; i++)
+        finfo->fd[i] = INVALID_FD;
 
-	finfo->mode = INVALID_MODE;
-	finfo->coalesce = INVALID_FD;
+    finfo->mode = INVALID_MODE;
+    finfo->coalesce = INVALID_FD;
 
-	return finfo;
+    return finfo;
 }
 
 /*
@@ -77,39 +77,39 @@ file_stripe_info *alloc_file_stripe_info(int count)
 static int
 get_stripe_attr_name(const char *path, const char *pattern, char **attrname)
 {
-	char attrbuf[4096];
-	char *ptr, *match = NULL;
-	int len, r, match_count = 0;
-
-	if (!path || !pattern || !attrname)
-		return -1;
-
-	len = listxattr(path, attrbuf, sizeof(attrbuf));
-	if (len < 0)
-		return len;
-
-	ptr = attrbuf;
-	while (ptr) {
-		r = fnmatch(pattern, ptr, 0);
-		if (!r) {
-			if (!match)
-				match = ptr;
-			match_count++;
-		} else if (r != FNM_NOMATCH) {
-			return -1;
-		}
-
-		len -= strlen(ptr) + 1;
-		if (len > 0)
-			ptr += strlen(ptr) + 1;
-		else
-			ptr = NULL;
-	}
-
-	if (match)
-		*attrname = strdup(match);
-
-	return match_count;
+    char attrbuf[4096];
+    char *ptr, *match = NULL;
+    int len, r, match_count = 0;
+
+    if (!path || !pattern || !attrname)
+        return -1;
+
+    len = listxattr(path, attrbuf, sizeof(attrbuf));
+    if (len < 0)
+        return len;
+
+    ptr = attrbuf;
+    while (ptr) {
+        r = fnmatch(pattern, ptr, 0);
+        if (!r) {
+            if (!match)
+                match = ptr;
+            match_count++;
+        } else if (r != FNM_NOMATCH) {
+            return -1;
+        }
+
+        len -= strlen(ptr) + 1;
+        if (len > 0)
+            ptr += strlen(ptr) + 1;
+        else
+            ptr = NULL;
+    }
+
+    if (match)
+        *attrname = strdup(match);
+
+    return match_count;
 }
 
 /*
@@ -118,19 +118,19 @@ get_stripe_attr_name(const char *path, const char *pattern, char **attrname)
 static int
 get_stripe_attr_val(const char *path, const char *attr, int *val)
 {
-	char attrbuf[4096];
-	int len;
+    char attrbuf[4096];
+    int len;
 
-	if (!path || !attr || !val)
-		return -1;
+    if (!path || !attr || !val)
+        return -1;
 
-	len = getxattr(path, attr, attrbuf, sizeof(attrbuf));
-	if (len < 0)
-		return len;
+    len = getxattr(path, attr, attrbuf, sizeof(attrbuf));
+    if (len < 0)
+        return len;
 
-	*val = atoi(attrbuf);
+    *val = atoi(attrbuf);
 
-	return 0;
+    return 0;
 }
 
 /*
@@ -145,29 +145,31 @@ get_stripe_attr_val(const char *path, const char *attr, int *val)
 static int
 get_attr(const char *path, const char *pattern, char **buf, int *val)
 {
-	int count = 1;
-
-	if (!buf)
-		return -1;
-
-	if (!*buf) {
-		count = get_stripe_attr_name(path, pattern, buf);
-		if (count > 1) {
-			/* pattern isn't good enough */
-			fprintf(stderr, "ERROR: duplicate attributes found "
-				"matching pattern: %s\n", pattern);
-			free(*buf);
-			*buf = NULL;
-			return count;
-		} else if (count < 1) {
-			return count;
-		}
-	}
-
-	if (get_stripe_attr_val(path, *buf, val) < 0)
-		return -1;
-
-	return count;
+    int count = 1;
+
+    if (!buf)
+        return -1;
+
+    if (!*buf) {
+        count = get_stripe_attr_name(path, pattern, buf);
+        if (count > 1) {
+            /* pattern isn't good enough */
+            fprintf(stderr,
+                    "ERROR: duplicate attributes found "
+                    "matching pattern: %s\n",
+                    pattern);
+            free(*buf);
+            *buf = NULL;
+            return count;
+        } else if (count < 1) {
+            return count;
+        }
+    }
+
+    if (get_stripe_attr_val(path, *buf, val) < 0)
+        return -1;
+
+    return count;
 }
 
 /*
@@ -178,164 +180,168 @@ get_attr(const char *path, const char *pattern, char **buf, int *val)
  * print a warning if any files are missing. We proceed without error in the
  * latter case to support partial recovery.
  */
-static struct
-file_stripe_info *validate_and_open_files(char *paths[], int count)
+static struct file_stripe_info *
+validate_and_open_files(char *paths[], int count)
 {
-	int i, val, tmp;
-	struct stat sbuf;
-	char *stripe_count_attr = NULL;
-	char *stripe_size_attr = NULL;
-	char *stripe_index_attr = NULL;
-	char *stripe_coalesce_attr = NULL;
-	struct file_stripe_info *finfo = NULL;
-
-	for (i = 0; i < count; i++) {
-		if (!paths[i])
-			goto err;
-
-		/*
-		 * Check the stripe count first so we can allocate the info
-		 * struct with the appropriate number of fds.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_COUNT,
-				&stripe_count_attr, &val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_COUNT);
-			goto err;
-		}
-		if (!finfo) {
-			finfo = alloc_file_stripe_info(val);
-			if (!finfo)
-				goto err;
-
-			if (val != count)
-				fprintf(stderr, "WARNING: %s: stripe-count "
-					"(%d) != file count (%d). Result may "
-					"be incomplete.\n", paths[i], val,
-					count);
-
-			finfo->stripe_count = val;
-		} else if (val != finfo->stripe_count) {
-			fprintf(stderr, "ERROR %s: invalid stripe count: %d "
-				"(expected %d)\n", paths[i], val,
-				finfo->stripe_count);
-			goto err;
-		}
-
-		/*
-		 * Get and validate the chunk size.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_SIZE, &stripe_size_attr,
-				&val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_SIZE);
-			goto err;
-		}
-
-		if (!finfo->stripe_size) {
-			finfo->stripe_size = val;
-		} else if (val != finfo->stripe_size) {
-			fprintf(stderr, "ERROR: %s: invalid stripe size: %d "
-				"(expected %d)\n", paths[i], val,
-				finfo->stripe_size);
-			goto err;
-		}
-
-		/*
-		 * stripe-coalesce is a backward compatible attribute. If the
-		 * attribute does not exist, assume a value of zero for the
-		 * traditional stripe format.
-		 */
-		tmp = get_attr(paths[i], ATTRNAME_STRIPE_COALESCE,
-				&stripe_coalesce_attr, &val);
-		if (!tmp) {
-			val = 0;
-		} else if (tmp != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_COALESCE);
-			goto err;
-		}
-
-		if (finfo->coalesce == INVALID_FD) {
-			finfo->coalesce = val;
-		} else if (val != finfo->coalesce) {
-			fprintf(stderr, "ERROR: %s: invalid coalesce flag\n",
-				paths[i]);
-			goto err;
-		}
-
-		/*
-		 * Get/validate the stripe index and open the file in the
-		 * appropriate fd slot.
-		 */
-		if (get_attr(paths[i], ATTRNAME_STRIPE_INDEX,
-				&stripe_index_attr, &val) != 1) {
-			fprintf(stderr, "ERROR: %s: attribute: '%s'\n",
-				paths[i], ATTRNAME_STRIPE_INDEX);
-			goto err;
-		}
-		if (finfo->fd[val] != INVALID_FD) {
-			fprintf(stderr, "ERROR: %s: duplicate stripe index: "
-				"%d\n", paths[i], val);
-			goto err;
-		}
-
-		finfo->fd[val] = open(paths[i], O_RDONLY);
-		if (finfo->fd[val] < 0)
-			goto err;
-
-		/*
-		 * Get the creation mode for the file.
-		 */
-		if (fstat(finfo->fd[val], &sbuf) < 0)
-			goto err;
-		if (finfo->mode == INVALID_MODE) {
-			finfo->mode = sbuf.st_mode;
-		} else if (sbuf.st_mode != finfo->mode) {
-			fprintf(stderr, "ERROR: %s: invalid mode\n", paths[i]);
-			goto err;
-		}
-	}
-
-	free(stripe_count_attr);
-	free(stripe_size_attr);
-	free(stripe_index_attr);
-	free(stripe_coalesce_attr);
-
-	return finfo;
+    int i, val, tmp;
+    struct stat sbuf;
+    char *stripe_count_attr = NULL;
+    char *stripe_size_attr = NULL;
+    char *stripe_index_attr = NULL;
+    char *stripe_coalesce_attr = NULL;
+    struct file_stripe_info *finfo = NULL;
+
+    for (i = 0; i < count; i++) {
+        if (!paths[i])
+            goto err;
+
+        /*
+         * Check the stripe count first so we can allocate the info
+         * struct with the appropriate number of fds.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_COUNT, &stripe_count_attr,
+                     &val) != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_COUNT);
+            goto err;
+        }
+        if (!finfo) {
+            finfo = alloc_file_stripe_info(val);
+            if (!finfo)
+                goto err;
+
+            if (val != count)
+                fprintf(stderr,
+                        "WARNING: %s: stripe-count "
+                        "(%d) != file count (%d). Result may "
+                        "be incomplete.\n",
+                        paths[i], val, count);
+
+            finfo->stripe_count = val;
+        } else if (val != finfo->stripe_count) {
+            fprintf(stderr,
+                    "ERROR %s: invalid stripe count: %d "
+                    "(expected %d)\n",
+                    paths[i], val, finfo->stripe_count);
+            goto err;
+        }
+
+        /*
+         * Get and validate the chunk size.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_SIZE, &stripe_size_attr, &val) !=
+            1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_SIZE);
+            goto err;
+        }
+
+        if (!finfo->stripe_size) {
+            finfo->stripe_size = val;
+        } else if (val != finfo->stripe_size) {
+            fprintf(stderr,
+                    "ERROR: %s: invalid stripe size: %d "
+                    "(expected %d)\n",
+                    paths[i], val, finfo->stripe_size);
+            goto err;
+        }
+
+        /*
+         * stripe-coalesce is a backward compatible attribute. If the
+         * attribute does not exist, assume a value of zero for the
+         * traditional stripe format.
+         */
+        tmp = get_attr(paths[i], ATTRNAME_STRIPE_COALESCE,
+                       &stripe_coalesce_attr, &val);
+        if (!tmp) {
+            val = 0;
+        } else if (tmp != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_COALESCE);
+            goto err;
+        }
+
+        if (finfo->coalesce == INVALID_FD) {
+            finfo->coalesce = val;
+        } else if (val != finfo->coalesce) {
+            fprintf(stderr, "ERROR: %s: invalid coalesce flag\n", paths[i]);
+            goto err;
+        }
+
+        /*
+         * Get/validate the stripe index and open the file in the
+         * appropriate fd slot.
+         */
+        if (get_attr(paths[i], ATTRNAME_STRIPE_INDEX, &stripe_index_attr,
+                     &val) != 1) {
+            fprintf(stderr, "ERROR: %s: attribute: '%s'\n", paths[i],
+                    ATTRNAME_STRIPE_INDEX);
+            goto err;
+        }
+        if (finfo->fd[val] != INVALID_FD) {
+            fprintf(stderr,
+                    "ERROR: %s: duplicate stripe index: "
+                    "%d\n",
+                    paths[i], val);
+            goto err;
+        }
+
+        finfo->fd[val] = open(paths[i], O_RDONLY);
+        if (finfo->fd[val] < 0)
+            goto err;
+
+        /*
+         * Get the creation mode for the file.
+         */
+        if (fstat(finfo->fd[val], &sbuf) < 0)
+            goto err;
+        if (finfo->mode == INVALID_MODE) {
+            finfo->mode = sbuf.st_mode;
+        } else if (sbuf.st_mode != finfo->mode) {
+            fprintf(stderr, "ERROR: %s: invalid mode\n", paths[i]);
+            goto err;
+        }
+    }
+
+    free(stripe_count_attr);
+    free(stripe_size_attr);
+    free(stripe_index_attr);
+    free(stripe_coalesce_attr);
+
+    return finfo;
 err:
 
-	free(stripe_count_attr);
-	free(stripe_size_attr);
-	free(stripe_index_attr);
-	free(stripe_coalesce_attr);
+    free(stripe_count_attr);
+    free(stripe_size_attr);
+    free(stripe_index_attr);
+    free(stripe_coalesce_attr);
 
-	if (finfo) {
-		close_files(finfo);
-		free(finfo);
-	}
+    if (finfo) {
+        close_files(finfo);
+        free(finfo);
+    }
 
-	return NULL;
+    return NULL;
 }
 
 static int
 close_files(struct file_stripe_info *finfo)
 {
-	int i, ret;
+    int i, ret;
 
-	if (!finfo)
-		return -1;
+    if (!finfo)
+        return -1;
 
-	for (i = 0; i < finfo->stripe_count; i++) {
-		if (finfo->fd[i] == INVALID_FD)
-			continue;
+    for (i = 0; i < finfo->stripe_count; i++) {
+        if (finfo->fd[i] == INVALID_FD)
+            continue;
 
-		ret = close(finfo->fd[i]);
-		if (ret < 0)
-			return ret;
-	}
+        ret = close(finfo->fd[i]);
+        if (ret < 0)
+            return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 /*
@@ -351,43 +357,43 @@ close_files(struct file_stripe_info *finfo)
 static int
 generate_file_coalesce(int target, struct file_stripe_info *finfo)
 {
-	char *buf;
-	int ret = 0;
-	int r, w, i;
-
-	buf = malloc(finfo->stripe_size);
-	if (!buf)
-		return -1;
-
-	i = 0;
-	while (1) {
-		if (finfo->fd[i] == INVALID_FD) {
-			if (lseek(target, finfo->stripe_size, SEEK_CUR) < 0)
-				break;
-
-			i = (i + 1) % finfo->stripe_count;
-			continue;
-		}
-
-		r = read(finfo->fd[i], buf, finfo->stripe_size);
-		if (r < 0) {
-			ret = r;
-			break;
-		}
-		if (!r)
-			break;
-
-		w = write(target, buf, r);
-		if (w < 0) {
-			ret = w;
-			break;
-		}
-
-		i = (i + 1) % finfo->stripe_count;
-	}
-
-	free(buf);
-	return ret;
+    char *buf;
+    int ret = 0;
+    int r, w, i;
+
+    buf = malloc(finfo->stripe_size);
+    if (!buf)
+        return -1;
+
+    i = 0;
+    while (1) {
+        if (finfo->fd[i] == INVALID_FD) {
+            if (lseek(target, finfo->stripe_size, SEEK_CUR) < 0)
+                break;
+
+            i = (i + 1) % finfo->stripe_count;
+            continue;
+        }
+
+        r = read(finfo->fd[i], buf, finfo->stripe_size);
+        if (r < 0) {
+            ret = r;
+            break;
+        }
+        if (!r)
+            break;
+
+        w = write(target, buf, r);
+        if (w < 0) {
+            ret = w;
+            break;
+        }
+
+        i = (i + 1) % finfo->stripe_count;
+    }
+
+    free(buf);
+    return ret;
 }
 
 /*
@@ -398,97 +404,100 @@ generate_file_coalesce(int target, struct file_stripe_info *finfo)
 static int
 generate_file_traditional(int target, struct file_stripe_info *finfo)
 {
-	int i, j, max_ret, ret;
-	char buf[finfo->stripe_count][4096];
-
-	do {
-		char newbuf[4096] = {0, };
-
-		max_ret = 0;
-		for (i = 0; i < finfo->stripe_count; i++) {
-			memset(buf[i], 0, 4096);
-			ret = read(finfo->fd[i], buf[i], 4096);
-			if (ret > max_ret)
-				max_ret = ret;
-		}
-		for (i = 0; i < max_ret; i++)
-			for (j = 0; j < finfo->stripe_count; j++)
-				newbuf[i] |= buf[j][i];
-			write(target, newbuf, max_ret);
-	} while (max_ret);
-
-	return 0;
+    int i, j, max_ret, ret;
+    char buf[finfo->stripe_count][4096];
+
+    do {
+        char newbuf[4096] = {
+            0,
+        };
+
+        max_ret = 0;
+        for (i = 0; i < finfo->stripe_count; i++) {
+            memset(buf[i], 0, 4096);
+            ret = read(finfo->fd[i], buf[i], 4096);
+            if (ret > max_ret)
+                max_ret = ret;
+        }
+        for (i = 0; i < max_ret; i++)
+            for (j = 0; j < finfo->stripe_count; j++)
+                newbuf[i] |= buf[j][i];
+        write(target, newbuf, max_ret);
+    } while (max_ret);
+
+    return 0;
 }
 
 static int
 generate_file(int target, struct file_stripe_info *finfo)
 {
-	if (finfo->coalesce)
-		return generate_file_coalesce(target, finfo);
+    if (finfo->coalesce)
+        return generate_file_coalesce(target, finfo);
 
-	return generate_file_traditional(target, finfo);
+    return generate_file_traditional(target, finfo);
 }
 
 static void
 usage(char *name)
 {
-	fprintf(stderr, "Usage: %s [-o <outputfile>] <inputfile1> "
-		"<inputfile2> ...\n", name);
+    fprintf(stderr,
+            "Usage: %s [-o <outputfile>] <inputfile1> "
+            "<inputfile2> ...\n",
+            name);
 }
 
 int
 main(int argc, char *argv[])
 {
-	int file_count, opt;
-	char *opath = NULL;
-	int targetfd;
-	struct file_stripe_info *finfo;
-
-	while ((opt = getopt(argc, argv, "o:")) != -1) {
-		switch (opt) {
-		case 'o':
-			opath = optarg;
-			break;
-		default:
-			usage(argv[0]);
-			return -1;
-		}
-	}
-
-	file_count = argc - optind;
-
-	if (!opath || !file_count) {
-		usage(argv[0]);
-		return -1;
-	}
-
-	finfo = validate_and_open_files(&argv[optind], file_count);
-	if (!finfo)
-		goto err;
-
-	targetfd = open(opath, O_RDWR|O_CREAT, finfo->mode);
-	if (targetfd < 0)
-		goto err;
-
-	if (generate_file(targetfd, finfo) < 0)
-		goto err;
-
-	if (fsync(targetfd) < 0)
-		fprintf(stderr, "ERROR: %s\n", strerror(errno));
-	if (close(targetfd) < 0)
-		fprintf(stderr, "ERROR: %s\n", strerror(errno));
-
-	close_files(finfo);
-	free(finfo);
-
-	return 0;
+    int file_count, opt;
+    char *opath = NULL;
+    int targetfd;
+    struct file_stripe_info *finfo;
+
+    while ((opt = getopt(argc, argv, "o:")) != -1) {
+        switch (opt) {
+            case 'o':
+                opath = optarg;
+                break;
+            default:
+                usage(argv[0]);
+                return -1;
+        }
+    }
+
+    file_count = argc - optind;
+
+    if (!opath || !file_count) {
+        usage(argv[0]);
+        return -1;
+    }
+
+    finfo = validate_and_open_files(&argv[optind], file_count);
+    if (!finfo)
+        goto err;
+
+    targetfd = open(opath, O_RDWR | O_CREAT, finfo->mode);
+    if (targetfd < 0)
+        goto err;
+
+    if (generate_file(targetfd, finfo) < 0)
+        goto err;
+
+    if (fsync(targetfd) < 0)
+        fprintf(stderr, "ERROR: %s\n", strerror(errno));
+    if (close(targetfd) < 0)
+        fprintf(stderr, "ERROR: %s\n", strerror(errno));
+
+    close_files(finfo);
+    free(finfo);
+
+    return 0;
 
 err:
-	if (finfo) {
-		close_files(finfo);
-		free(finfo);
-	}
+    if (finfo) {
+        close_files(finfo);
+        free(finfo);
+    }
 
-	return -1;
+    return -1;
 }
-
diff --git a/extras/test/ld-preload-test/ld-preload-lib.c b/extras/test/ld-preload-test/ld-preload-lib.c
index 181b5c1e9c7..d120c053a69 100644
--- a/extras/test/ld-preload-test/ld-preload-lib.c
+++ b/extras/test/ld-preload-test/ld-preload-lib.c
@@ -40,596 +40,576 @@
 /* Err number that is assigned to errno so that test application can
  * verify that the function was intercepted correctly.
  */
-#define PRELOAD_ERRNO_VERF      6449
-#define set_errno()             (errno = PRELOAD_ERRNO_VERF)
+#define PRELOAD_ERRNO_VERF 6449
+#define set_errno() (errno = PRELOAD_ERRNO_VERF)
 
 void
-intercept (char *call, int tabs)
+intercept(char *call, int tabs)
 {
-        while (tabs > 0) {
-                fprintf (stdout, "\t");
-                --tabs;
-        }
+    while (tabs > 0) {
+        fprintf(stdout, "\t");
+        --tabs;
+    }
 
-        fprintf (stdout, "Intercepted by %s", call);
+    fprintf(stdout, "Intercepted by %s", call);
 }
 
 int
-creat64 (const char *pathname, mode_t mode)
+creat64(const char *pathname, mode_t mode)
 {
-        intercept ("creat64", 2);
-        set_errno ();
-        return -1;
+    intercept("creat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-creat (const char *pathname, mode_t mode)
+creat(const char *pathname, mode_t mode)
 {
-        intercept ("creat", 2);
-        set_errno ();
-        return -1;
+    intercept("creat", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-close (int fd)
+close(int fd)
 {
-        intercept ("close", 2);
-        set_errno ();
-        return -1;
+    intercept("close", 2);
+    set_errno();
+    return -1;
 }
 
 int
-open64 (const char *pathname, int flags, ...)
+open64(const char *pathname, int flags, ...)
 {
-        intercept ("open64", 2);
-        set_errno ();
-        return -1;
+    intercept("open64", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-open (const char *pathname, int flags, ...)
+open(const char *pathname, int flags, ...)
 {
-        intercept ("open", 2);
-        set_errno ();
-        return -1;
+    intercept("open", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-read (int fd, void *buf, size_t count)
+read(int fd, void *buf, size_t count)
 {
-        intercept ("read", 2);
-        set_errno ();
-        return -1;
+    intercept("read", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-readv (int fd, const struct iovec *vector, int count)
+readv(int fd, const struct iovec *vector, int count)
 {
-        intercept ("readv", 2);
-        set_errno ();
-        return -1;
+    intercept("readv", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pread (int fd, void *buf, size_t count, unsigned long offset)
+pread(int fd, void *buf, size_t count, unsigned long offset)
 {
-        intercept ("pread", 2);
-        set_errno ();
-        return -1;
+    intercept("pread", 2);
+    set_errno();
+    return -1;
 }
 
-
 ssize_t
-pread64 (int fd, void *buf, size_t count, uint64_t offset)
+pread64(int fd, void *buf, size_t count, uint64_t offset)
 {
-        intercept ("pread64", 2);
-        set_errno ();
-        return -1;
+    intercept("pread64", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-write (int fd, const void *buf, size_t count)
+write(int fd, const void *buf, size_t count)
 {
-        intercept ("write", 2);
-        set_errno ();
-        return -1;
+    intercept("write", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-writev (int fd, const struct iovec *vector, int count)
+writev(int fd, const struct iovec *vector, int count)
 {
-        intercept ("writev", 2);
-        set_errno ();
-        return -1;
+    intercept("writev", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pwrite (int fd, const void *buf, size_t count, unsigned long offset)
+pwrite(int fd, const void *buf, size_t count, unsigned long offset)
 {
-        intercept ("pwrite", 2);
-        set_errno ();
-        return -1;
+    intercept("pwrite", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-pwrite64 (int fd, const void *buf, size_t count, uint64_t offset)
+pwrite64(int fd, const void *buf, size_t count, uint64_t offset)
 {
-        intercept ("pwrite64", 2);
-        set_errno ();
-        return -1;
+    intercept("pwrite64", 2);
+    set_errno();
+    return -1;
 }
 
-
 off_t
-lseek (int fildes, unsigned long offset, int whence)
+lseek(int fildes, unsigned long offset, int whence)
 {
-        intercept ("lseek", 2);
-        set_errno ();
-        return -1;
+    intercept("lseek", 2);
+    set_errno();
+    return -1;
 }
 
 off_t
-lseek64 (int fildes, uint64_t offset, int whence)
+lseek64(int fildes, uint64_t offset, int whence)
 {
-        intercept ("lseek64", 2);
-        set_errno ();
-        return -1;
+    intercept("lseek64", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-dup (int fd)
+dup(int fd)
 {
-        intercept ("dup", 2);
-        set_errno ();
-        return -1;
+    intercept("dup", 2);
+    set_errno();
+    return -1;
 }
 
 int
-dup2 (int oldfd, int newfd)
+dup2(int oldfd, int newfd)
 {
-        intercept ("dup2", 2);
-        set_errno ();
-        return -1;
+    intercept("dup2", 2);
+    set_errno();
+    return -1;
 }
 
 int
-mkdir (const char *pathname, mode_t mode)
+mkdir(const char *pathname, mode_t mode)
 {
-        intercept ("mkdir", 2);
-        set_errno ();
-        return -1;
+    intercept("mkdir", 2);
+    set_errno();
+    return -1;
 }
 
 int
-rmdir (const char *pathname)
+rmdir(const char *pathname)
 {
-        intercept ("rmdir", 2);
-        set_errno ();
-        return -1;
+    intercept("rmdir", 2);
+    set_errno();
+    return -1;
 }
 
 int
-chmod (const char *pathname, mode_t mode)
+chmod(const char *pathname, mode_t mode)
 {
-        intercept ("chmod", 2);
-        set_errno ();
-        return -1;
+    intercept("chmod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-chown (const char *pathname, uid_t owner, gid_t group)
+chown(const char *pathname, uid_t owner, gid_t group)
 {
-        intercept ("chown", 2);
-        set_errno ();
-        return -1;
+    intercept("chown", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fchmod (int fd, mode_t mode)
+fchmod(int fd, mode_t mode)
 {
-        intercept ("fchmod", 2);
-        set_errno ();
-        return -1;
+    intercept("fchmod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fchown (int fd, uid_t uid, gid_t gid)
+fchown(int fd, uid_t uid, gid_t gid)
 {
-        intercept ("fchown", 2);
-        set_errno ();
-        return -1;
+    intercept("fchown", 2);
+    set_errno();
+    return -1;
 }
 
-int fsync (int fd)
+int
+fsync(int fd)
 {
-        intercept ("fsync", 2);
-        set_errno ();
-        return -1;
+    intercept("fsync", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-ftruncate (int fd, off_t length)
+ftruncate(int fd, off_t length)
 {
-        intercept ("ftruncate", 1);
-        set_errno ();
-        return -1;
+    intercept("ftruncate", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-ftruncate64 (int fd, off_t length)
+ftruncate64(int fd, off_t length)
 {
-        intercept ("ftruncate64", 1);
-        set_errno ();
-        return -1;
+    intercept("ftruncate64", 1);
+    set_errno();
+    return -1;
 }
 
 int
-link (const char *oldpath, const char *newname)
+link(const char *oldpath, const char *newname)
 {
-        intercept ("link", 2);
-        set_errno ();
-        return -1;
+    intercept("link", 2);
+    set_errno();
+    return -1;
 }
 
 int
-rename (const char *oldpath, const char *newpath)
+rename(const char *oldpath, const char *newpath)
 {
-        intercept ("rename", 2);
-        set_errno ();
-        return -1;
+    intercept("rename", 2);
+    set_errno();
+    return -1;
 }
 
 int
-utimes (const char *path, const struct timeval times[2])
+utimes(const char *path, const struct timeval times[2])
 {
-        intercept ("utimes", 2);
-        set_errno ();
-        return -1;
+    intercept("utimes", 2);
+    set_errno();
+    return -1;
 }
 
 int
-futimes (int fd, const struct timeval times[2])
+futimes(int fd, const struct timeval times[2])
 {
-        intercept ("futimes", 2);
-        set_errno ();
-        return -1;
+    intercept("futimes", 2);
+    set_errno();
+    return -1;
 }
 
 int
-utime (const char *path, const struct utimbuf *buf)
+utime(const char *path, const struct utimbuf *buf)
 {
-        intercept ("utime", 2);
-        set_errno ();
-        return -1;
+    intercept("utime", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-mknod (const char *path, mode_t mode, dev_t dev)
+mknod(const char *path, mode_t mode, dev_t dev)
 {
-        intercept ("mknod", 2);
-        set_errno ();
-        return -1;
+    intercept("mknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__xmknod (int ver, const char *path, mode_t mode, dev_t *dev)
+__xmknod(int ver, const char *path, mode_t mode, dev_t *dev)
 {
-        intercept ("__xmknod", 2);
-        set_errno ();
-        return -1;
+    intercept("__xmknod", 2);
+    set_errno();
+    return -1;
 }
 
 int
-mkfifo (const char *path, mode_t mode)
+mkfifo(const char *path, mode_t mode)
 {
-        intercept ("mkfifo", 2);
-        set_errno ();
-        return -1;
+    intercept("mkfifo", 2);
+    set_errno();
+    return -1;
 }
 
 int
-unlink (const char *path)
+unlink(const char *path)
 {
-        intercept ("unlink", 2);
-        set_errno ();
-        return -1;
+    intercept("unlink", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-symlink (const char *oldpath, const char *newpath)
+symlink(const char *oldpath, const char *newpath)
 {
-        intercept ("symlink", 2);
-        set_errno ();
-        return -1;
+    intercept("symlink", 2);
+    set_errno();
+    return -1;
 }
 
 int
-readlink (const char *path, char *buf, size_t bufsize)
+readlink(const char *path, char *buf, size_t bufsize)
 {
-        intercept ("readlink", 1);
-        set_errno ();
-        return -1;
+    intercept("readlink", 1);
+    set_errno();
+    return -1;
 }
 
-
 char *
-realpath (const char *path, char *resolved)
+realpath(const char *path, char *resolved)
 {
-        intercept ("realpath", 1);
-        set_errno ();
-        return NULL;
+    intercept("realpath", 1);
+    set_errno();
+    return NULL;
 }
 
-
 DIR *
-opendir (const char *path)
+opendir(const char *path)
 {
-        intercept ("opendir", 2);
-        set_errno ();
-        return NULL;
+    intercept("opendir", 2);
+    set_errno();
+    return NULL;
 }
 
-
 struct dirent *
-readdir (DIR *dir)
+readdir(DIR *dir)
 {
-        intercept ("readdir\t", 2);
-        set_errno ();
-        return NULL;
+    intercept("readdir\t", 2);
+    set_errno();
+    return NULL;
 }
 
 struct dirent *
-readdir64 (DIR *dir)
+readdir64(DIR *dir)
 {
-        intercept ("readdir64", 2);
-        set_errno ();
-        return NULL;
+    intercept("readdir64", 2);
+    set_errno();
+    return NULL;
 }
 
-
 int
-readdir_r (DIR *dir, struct dirent *entry, struct dirent **result)
+readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
 {
-        intercept ("readdir_r", 1);
-        set_errno ();
-        return -1;
+    intercept("readdir_r", 1);
+    set_errno();
+    return -1;
 }
 
 int
-readdir64_r (DIR *dir, struct dirent *entry, struct dirent **result)
+readdir64_r(DIR *dir, struct dirent *entry, struct dirent **result)
 {
-        intercept ("readdir64_r", 1);
-        set_errno ();
-        return -1;
+    intercept("readdir64_r", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-closedir (DIR *dh)
+closedir(DIR *dh)
 {
-        intercept ("closedir", 1);
-        set_errno ();
-        return -1;
+    intercept("closedir", 1);
+    set_errno();
+    return -1;
 }
 
 int
-__xstat (int ver, const char *path, struct stat *buf)
+__xstat(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__xstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__xstat\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-__xstat64 (int ver, const char *path, struct stat *buf)
+__xstat64(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__xstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__xstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-stat (const char *path, struct stat *buf)
+stat(const char *path, struct stat *buf)
 {
-        intercept ("stat", 2);
-        set_errno ();
-        return -1;
+    intercept("stat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-stat64 (const char *path, struct stat *buf)
+stat64(const char *path, struct stat *buf)
 {
-        intercept ("stat64", 2);
-        set_errno ();
-        return -1;
+    intercept("stat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__fxstat (int ver, int fd, struct stat *buf)
+__fxstat(int ver, int fd, struct stat *buf)
 {
-        intercept ("__fxstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__fxstat\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-__fxstat64 (int ver, int fd, struct stat *buf)
+__fxstat64(int ver, int fd, struct stat *buf)
 {
-        intercept ("__fxstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__fxstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fstat (int fd, struct stat *buf)
+fstat(int fd, struct stat *buf)
 {
-        intercept ("fstat", 2);
-        set_errno ();
-        return -1;
+    intercept("fstat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-fstat64 (int fd , struct stat *buf)
+fstat64(int fd, struct stat *buf)
 {
-        intercept ("fstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("fstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__lxstat (int ver, const char *path, struct stat *buf)
+__lxstat(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__lxstat\t", 2);
-        set_errno ();
-        return -1;
+    intercept("__lxstat\t", 2);
+    set_errno();
+    return -1;
 }
 
 int
-__lxstat64 (int ver, const char *path, struct stat *buf)
+__lxstat64(int ver, const char *path, struct stat *buf)
 {
-        intercept ("__lxstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("__lxstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lstat (const char *path, struct stat *buf)
+lstat(const char *path, struct stat *buf)
 {
-        intercept ("lstat", 2);
-        set_errno ();
-        return -1;
+    intercept("lstat", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lstat64 (const char *path, struct stat *buf)
+lstat64(const char *path, struct stat *buf)
 {
-        intercept ("lstat64", 2);
-        set_errno ();
-        return -1;
+    intercept("lstat64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-statfs (const char *path, struct statfs *buf)
+statfs(const char *path, struct statfs *buf)
 {
-        intercept ("statfs", 2);
-        set_errno ();
-        return -1;
+    intercept("statfs", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-statfs64 (const char *path, struct statfs *buf)
+statfs64(const char *path, struct statfs *buf)
 {
-        intercept ("statfs64", 2);
-        set_errno ();
-        return -1;
+    intercept("statfs64", 2);
+    set_errno();
+    return -1;
 }
 
 int
-statvfs (const char *path, struct statvfs *buf)
+statvfs(const char *path, struct statvfs *buf)
 {
-        intercept ("statvfs\t", 2);
-        set_errno ();
-        return -1;
+    intercept("statvfs\t", 2);
+    set_errno();
+    return -1;
 }
 
-
 int
-statvfs64 (const char *path, struct statvfs *buf)
+statvfs64(const char *path, struct statvfs *buf)
 {
-        intercept ("statvfs64", 2);
-        set_errno ();
-        return -1;
+    intercept("statvfs64", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-getxattr (const char *path, const char *name, void *value, size_t size)
+getxattr(const char *path, const char *name, void *value, size_t size)
 {
-        intercept ("getxattr", 1);
-        set_errno ();
-        return -1;
+    intercept("getxattr", 1);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-lgetxattr (const char *path, const char *name, void *value, size_t size)
+lgetxattr(const char *path, const char *name, void *value, size_t size)
 {
-        intercept ("lgetxattr", 1);
-        set_errno ();
-        return -1;
+    intercept("lgetxattr", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-remove (const char* path)
+remove(const char *path)
 {
-        intercept ("remove", 2);
-        set_errno ();
-        return -1;
+    intercept("remove", 2);
+    set_errno();
+    return -1;
 }
 
 int
-lchown (const char *path, uid_t owner, gid_t group)
+lchown(const char *path, uid_t owner, gid_t group)
 {
-        intercept ("lchown", 2);
-        set_errno ();
-        return -1;
+    intercept("lchown", 2);
+    set_errno();
+    return -1;
 }
 
 void
-rewinddir (DIR *dirp)
+rewinddir(DIR *dirp)
 {
-        intercept ("rewinddir", 1);
-        set_errno ();
-        return;
+    intercept("rewinddir", 1);
+    set_errno();
+    return;
 }
 
 void
-seekdir (DIR *dirp, off_t offset)
+seekdir(DIR *dirp, off_t offset)
 {
-        intercept ("seekdir", 2);
-        set_errno ();
-        return;
+    intercept("seekdir", 2);
+    set_errno();
+    return;
 }
 
 off_t
-telldir (DIR *dirp)
+telldir(DIR *dirp)
 {
-        intercept ("telldir", 2);
-        set_errno ();
-        return -1;
+    intercept("telldir", 2);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-sendfile (int out_fd, int in_fd, off_t *offset, size_t count)
+sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
 {
-        intercept ("sendfile\t", 1);
-        set_errno ();
-        return -1;
+    intercept("sendfile\t", 1);
+    set_errno();
+    return -1;
 }
 
 ssize_t
-sendfile64 (int out_fd, int in_fd, off_t *offset, size_t count)
+sendfile64(int out_fd, int in_fd, off_t *offset, size_t count)
 {
-        intercept ("sendfile64", 1);
-        set_errno ();
-        return -1;
+    intercept("sendfile64", 1);
+    set_errno();
+    return -1;
 }
 
-
 int
-fcntl (int fd, int cmd, ...)
+fcntl(int fd, int cmd, ...)
 {
-        intercept ("fcntl", 2);
-        set_errno ();
-        return -1;
+    intercept("fcntl", 2);
+    set_errno();
+    return -1;
 }
-
diff --git a/extras/test/ld-preload-test/ld-preload-test.c b/extras/test/ld-preload-test/ld-preload-test.c
index 46e3e0e4172..54dde8c7d54 100644
--- a/extras/test/ld-preload-test/ld-preload-test.c
+++ b/extras/test/ld-preload-test/ld-preload-test.c
@@ -49,319 +49,310 @@
 #include <sys/xattr.h>
 #include <sys/sendfile.h>
 
-
-#define PRELOAD_ERRNO_VERF      6449
+#define PRELOAD_ERRNO_VERF 6449
 void
 check_err(int ret, char *call, int tabs)
 {
-        while (tabs > 0) {
-                fprintf (stdout, "\t");
-                --tabs;
-        }
-        if (ret != -1) {
-                fprintf (stdout, "Not intercepted: %s\n", call);
-                return;
-        }
-
-        if (errno != PRELOAD_ERRNO_VERF) {
-                fprintf (stdout, "Not intercepted: %s: err: %s\n", call,
-                         strerror (errno));
-                return;
-        }
+    while (tabs > 0) {
+        fprintf(stdout, "\t");
+        --tabs;
+    }
+    if (ret != -1) {
+        fprintf(stdout, "Not intercepted: %s\n", call);
+        return;
+    }
 
-        fprintf (stdout, "Intercept verified: %s\n", call);
+    if (errno != PRELOAD_ERRNO_VERF) {
+        fprintf(stdout, "Not intercepted: %s: err: %s\n", call,
+                strerror(errno));
         return;
+    }
+
+    fprintf(stdout, "Intercept verified: %s\n", call);
+    return;
 }
 
 void
-usage (FILE *fp)
+usage(FILE *fp)
 {
-        fprintf (fp, "Usage: ld-preload-test <Options>\n");
-        fprintf (fp, "Options\n");
-        fprintf (fp, "\t--path\t\tPathname is used as the file/directory"
-                     " created for the test.\n");
-
+    fprintf(fp, "Usage: ld-preload-test <Options>\n");
+    fprintf(fp, "Options\n");
+    fprintf(fp,
+            "\t--path\t\tPathname is used as the file/directory"
+            " created for the test.\n");
 }
 
-
 int
-run_file_tests (char *testfile)
+run_file_tests(char *testfile)
 {
-        int             ret = -1;
-        struct stat     buf;
+    int ret = -1;
+    struct stat buf;
 
-        assert (testfile);
-        fprintf (stdout, "Testing creat");
-        ret = creat (testfile, S_IRWXU);
-        check_err (ret, "creat", 2);
+    assert(testfile);
+    fprintf(stdout, "Testing creat");
+    ret = creat(testfile, S_IRWXU);
+    check_err(ret, "creat", 2);
 
-        fprintf (stdout, "Testing close");
-        ret = close (ret);
-        check_err (ret, "close", 2);
+    fprintf(stdout, "Testing close");
+    ret = close(ret);
+    check_err(ret, "close", 2);
 
-        fprintf (stdout, "Testing open");
-        ret = open (testfile, O_RDONLY);
-        check_err (ret, "open", 2);
+    fprintf(stdout, "Testing open");
+    ret = open(testfile, O_RDONLY);
+    check_err(ret, "open", 2);
 
-        fprintf (stdout, "Testing read");
-        ret = read (0, NULL, 0);
-        check_err (ret, "read", 2);
+    fprintf(stdout, "Testing read");
+    ret = read(0, NULL, 0);
+    check_err(ret, "read", 2);
 
-        fprintf (stdout, "Testing readv");
-        ret = readv (0, NULL, 0);
-        check_err (ret, "readv", 2);
+    fprintf(stdout, "Testing readv");
+    ret = readv(0, NULL, 0);
+    check_err(ret, "readv", 2);
 
-        fprintf (stdout, "Testing pread");
-        ret = pread (0, NULL, 0, 0);
-        check_err (ret, "pread", 2);
+    fprintf(stdout, "Testing pread");
+    ret = pread(0, NULL, 0, 0);
+    check_err(ret, "pread", 2);
 
-        fprintf (stdout, "Testing write");
-        ret = write (0, NULL, 0);
-        check_err (ret, "write", 2);
+    fprintf(stdout, "Testing write");
+    ret = write(0, NULL, 0);
+    check_err(ret, "write", 2);
 
-        fprintf (stdout, "Testing writev");
-        ret = writev (0, NULL, 0);
-        check_err (ret, "writev", 2);
+    fprintf(stdout, "Testing writev");
+    ret = writev(0, NULL, 0);
+    check_err(ret, "writev", 2);
 
-        fprintf (stdout, "Testing pwrite");
-        ret = pwrite (0, NULL, 0, 0);
-        check_err (ret, "pwrite", 2);
+    fprintf(stdout, "Testing pwrite");
+    ret = pwrite(0, NULL, 0, 0);
+    check_err(ret, "pwrite", 2);
 
-        fprintf (stdout, "Testing lseek");
-        ret = lseek (0, 0, 0);
-        check_err (ret, "lseek", 2);
+    fprintf(stdout, "Testing lseek");
+    ret = lseek(0, 0, 0);
+    check_err(ret, "lseek", 2);
 
-        fprintf (stdout, "Testing dup");
-        ret = dup (0);
-        check_err (ret, "dup", 2);
+    fprintf(stdout, "Testing dup");
+    ret = dup(0);
+    check_err(ret, "dup", 2);
 
-        fprintf (stdout, "Testing dup2");
-        ret = dup2 (0, 0);
-        check_err (ret, "dup2", 2);
+    fprintf(stdout, "Testing dup2");
+    ret = dup2(0, 0);
+    check_err(ret, "dup2", 2);
 
-        fprintf (stdout, "Testing fchmod");
-        ret = fchmod (0, 0);
-        check_err (ret, "fchmod", 2);
+    fprintf(stdout, "Testing fchmod");
+    ret = fchmod(0, 0);
+    check_err(ret, "fchmod", 2);
 
-        fprintf (stdout, "Testing fchown");
-        ret = fchown (0, 0, 0);
-        check_err (ret, "fchown", 2);
+    fprintf(stdout, "Testing fchown");
+    ret = fchown(0, 0, 0);
+    check_err(ret, "fchown", 2);
 
-        fprintf (stdout, "Testing fsync");
-        ret = fsync (0);
-        check_err (ret, "fsync", 2);
+    fprintf(stdout, "Testing fsync");
+    ret = fsync(0);
+    check_err(ret, "fsync", 2);
 
-        fprintf (stdout, "Testing ftruncate");
-        ret = ftruncate (0, 0);
-        check_err (ret, "ftruncate", 1);
+    fprintf(stdout, "Testing ftruncate");
+    ret = ftruncate(0, 0);
+    check_err(ret, "ftruncate", 1);
 
-        fprintf (stdout, "Testing fstat");
-        ret = fstat (0, &buf);
-        check_err (ret, "fstat", 1);
+    fprintf(stdout, "Testing fstat");
+    ret = fstat(0, &buf);
+    check_err(ret, "fstat", 1);
 
-        fprintf (stdout, "Testing sendfile");
-        ret = sendfile (0, 0, NULL, 0);
-        check_err (ret, "sendfile", 1);
+    fprintf(stdout, "Testing sendfile");
+    ret = sendfile(0, 0, NULL, 0);
+    check_err(ret, "sendfile", 1);
 
-        fprintf (stdout, "Testing fcntl");
-        ret = fcntl (0, 0, NULL);
-        check_err (ret, "fcntl", 2);
+    fprintf(stdout, "Testing fcntl");
+    ret = fcntl(0, 0, NULL);
+    check_err(ret, "fcntl", 2);
 
-        fprintf (stdout, "Testing close");
-        ret = close (ret);
-        check_err (ret, "close", 2);
+    fprintf(stdout, "Testing close");
+    ret = close(ret);
+    check_err(ret, "close", 2);
 
-        fprintf (stdout, "Testing remove");
-        ret = remove (testfile);
-        check_err (ret, "remove", 2);
+    fprintf(stdout, "Testing remove");
+    ret = remove(testfile);
+    check_err(ret, "remove", 2);
 
-        return ret;
+    return ret;
 }
 
-
 int
-run_attr_tests (char *testfile)
+run_attr_tests(char *testfile)
 {
-        int             ret = -1;
-        char            *res = NULL;
-        struct stat     buf;
-        struct statfs   sbuf;
-        struct statvfs  svbuf;
-
-        assert (testfile);
-
-        fprintf (stdout, "Testing chmod");
-        ret = chmod (testfile, 0);
-        check_err (ret, "chmod", 2);
-
-        fprintf (stdout, "Testing chown");
-        ret = chown (testfile, 0, 0);
-        check_err (ret, "chown", 2);
-
-        fprintf (stdout, "Testing link");
-        ret = link (testfile, testfile);
-        check_err (ret, "link", 2);
-
-        fprintf (stdout, "Testing rename");
-        ret = rename (testfile, testfile);
-        check_err (ret, "rename", 2);
-
-        fprintf (stdout, "Testing utimes");
-        ret = utimes (testfile, NULL);
-        check_err (ret, "utimes", 2);
-
-        fprintf (stdout, "Testing utime");
-        ret = utime (testfile, NULL);
-        check_err (ret, "utime", 2);
-
-        fprintf (stdout, "Testing unlink");
-        ret = unlink (testfile);
-        check_err (ret, "unlink", 2);
-
-        fprintf (stdout, "Testing symlink");
-        ret = symlink (testfile, testfile);
-        check_err (ret, "symlink", 2);
-
-        fprintf (stdout, "Testing readlink");
-        ret = readlink (testfile, testfile, 0);
-        check_err (ret, "readlink", 2);
-
-        fprintf (stdout, "Testing realpath");
-        ret = 0;
-        res = realpath ((const char *)testfile, testfile);
-        if (!res)
-                ret = -1;
-        check_err (ret, "realpath", 2);
-
-        fprintf (stdout, "Testing stat");
-        ret = stat (testfile, &buf);
-        check_err (ret, "stat", 1);
-
-        fprintf (stdout, "Testing lstat");
-        ret = lstat (testfile, &buf);
-        check_err (ret, "lstat", 1);
-
-        fprintf (stdout, "Testing statfs");
-        ret = statfs (testfile, &sbuf);
-        check_err (ret, "statfs", 2);
-
-        fprintf (stdout, "Testing statvfs");
-        ret = statvfs (testfile, &svbuf);
-        check_err (ret, "statvfs", 1);
-
-        fprintf (stdout, "Testing getxattr");
-        ret = getxattr (testfile, NULL, NULL, 0);
-        check_err (ret, "getxattr", 2);
-
-        fprintf (stdout, "Testing lgetxattr");
-        ret = lgetxattr (testfile, NULL, NULL, 0);
-        check_err (ret, "lgetxattr", 1);
-
-        fprintf (stdout, "Testing lchown");
-        ret = lchown (testfile, 0, 0);
-        check_err (ret, "lchown", 2);
-        return 0;
+    int ret = -1;
+    char *res = NULL;
+    struct stat buf;
+    struct statfs sbuf;
+    struct statvfs svbuf;
+
+    assert(testfile);
+
+    fprintf(stdout, "Testing chmod");
+    ret = chmod(testfile, 0);
+    check_err(ret, "chmod", 2);
+
+    fprintf(stdout, "Testing chown");
+    ret = chown(testfile, 0, 0);
+    check_err(ret, "chown", 2);
+
+    fprintf(stdout, "Testing link");
+    ret = link(testfile, testfile);
+    check_err(ret, "link", 2);
+
+    fprintf(stdout, "Testing rename");
+    ret = rename(testfile, testfile);
+    check_err(ret, "rename", 2);
+
+    fprintf(stdout, "Testing utimes");
+    ret = utimes(testfile, NULL);
+    check_err(ret, "utimes", 2);
+
+    fprintf(stdout, "Testing utime");
+    ret = utime(testfile, NULL);
+    check_err(ret, "utime", 2);
+
+    fprintf(stdout, "Testing unlink");
+    ret = unlink(testfile);
+    check_err(ret, "unlink", 2);
+
+    fprintf(stdout, "Testing symlink");
+    ret = symlink(testfile, testfile);
+    check_err(ret, "symlink", 2);
+
+    fprintf(stdout, "Testing readlink");
+    ret = readlink(testfile, testfile, 0);
+    check_err(ret, "readlink", 2);
+
+    fprintf(stdout, "Testing realpath");
+    ret = 0;
+    res = realpath((const char *)testfile, testfile);
+    if (!res)
+        ret = -1;
+    check_err(ret, "realpath", 2);
+
+    fprintf(stdout, "Testing stat");
+    ret = stat(testfile, &buf);
+    check_err(ret, "stat", 1);
+
+    fprintf(stdout, "Testing lstat");
+    ret = lstat(testfile, &buf);
+    check_err(ret, "lstat", 1);
+
+    fprintf(stdout, "Testing statfs");
+    ret = statfs(testfile, &sbuf);
+    check_err(ret, "statfs", 2);
+
+    fprintf(stdout, "Testing statvfs");
+    ret = statvfs(testfile, &svbuf);
+    check_err(ret, "statvfs", 1);
+
+    fprintf(stdout, "Testing getxattr");
+    ret = getxattr(testfile, NULL, NULL, 0);
+    check_err(ret, "getxattr", 2);
+
+    fprintf(stdout, "Testing lgetxattr");
+    ret = lgetxattr(testfile, NULL, NULL, 0);
+    check_err(ret, "lgetxattr", 1);
+
+    fprintf(stdout, "Testing lchown");
+    ret = lchown(testfile, 0, 0);
+    check_err(ret, "lchown", 2);
+    return 0;
 }
 
-
 int
-run_dev_tests (char *testfile)
+run_dev_tests(char *testfile)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        assert (testfile);
+    assert(testfile);
 
-        fprintf (stdout, "Testing mknod");
-        ret = mknod (testfile, 0, 0);
-        check_err (ret, "mknod", 2);
+    fprintf(stdout, "Testing mknod");
+    ret = mknod(testfile, 0, 0);
+    check_err(ret, "mknod", 2);
 
-        fprintf (stdout, "Testing mkfifo");
-        ret = mkfifo (testfile, 0);
-        check_err (ret, "mkfifo", 2);
-        return 0;
+    fprintf(stdout, "Testing mkfifo");
+    ret = mkfifo(testfile, 0);
+    check_err(ret, "mkfifo", 2);
+    return 0;
 }
 
 int
-run_dir_tests (char *testpath)
+run_dir_tests(char *testpath)
 {
-        int             ret = -1;
-        DIR             *dh = NULL;
-        struct dirent   *dire = NULL;
-
-        assert (testpath);
-
-        fprintf (stdout, "Testing mkdir");
-        ret = mkdir (testpath, 0);
-        check_err (ret, "mkdir", 2);
-
-        fprintf (stdout, "Testing rmdir");
-        ret = rmdir (testpath);
-        check_err (ret, "rmdir", 2);
-
-        fprintf (stdout, "Testing opendir");
-        ret = 0;
-        dh = opendir (testpath);
-        if (!dh)
-                ret = -1;
-        check_err (ret, "opendir", 2);
-
-        fprintf (stdout, "Testing readdir");
-        ret = 0;
-        dire = readdir (dh);
-        if (!dire)
-                ret = -1;
-        check_err (ret, "readdir", 1);
-
-        fprintf (stdout, "Testing readdir_r");
-        ret = readdir_r (dh, dire, &dire);
-        check_err (ret, "readdir_r", 1);
-
-        fprintf (stdout, "Testing rewinddir");
-        rewinddir (dh);
-        check_err (-1, "rewinddir", 1);
-
-        fprintf (stdout, "Testing seekdir");
-        seekdir (dh, 0);
-        check_err (-1, "seekdir", 2);
-
-        fprintf (stdout, "Testing telldir");
-        ret = telldir (dh);
-        check_err (ret, "telldir", 2);
-
-        fprintf (stdout, "Testing closedir");
-        ret = closedir (dh);
-        check_err (ret, "closedir", 2);
-        return 0;
+    int ret = -1;
+    DIR *dh = NULL;
+    struct dirent *dire = NULL;
+
+    assert(testpath);
+
+    fprintf(stdout, "Testing mkdir");
+    ret = mkdir(testpath, 0);
+    check_err(ret, "mkdir", 2);
+
+    fprintf(stdout, "Testing rmdir");
+    ret = rmdir(testpath);
+    check_err(ret, "rmdir", 2);
+
+    fprintf(stdout, "Testing opendir");
+    ret = 0;
+    dh = opendir(testpath);
+    if (!dh)
+        ret = -1;
+    check_err(ret, "opendir", 2);
+
+    fprintf(stdout, "Testing readdir");
+    ret = 0;
+    dire = readdir(dh);
+    if (!dire)
+        ret = -1;
+    check_err(ret, "readdir", 1);
+
+    fprintf(stdout, "Testing readdir_r");
+    ret = readdir_r(dh, dire, &dire);
+    check_err(ret, "readdir_r", 1);
+
+    fprintf(stdout, "Testing rewinddir");
+    rewinddir(dh);
+    check_err(-1, "rewinddir", 1);
+
+    fprintf(stdout, "Testing seekdir");
+    seekdir(dh, 0);
+    check_err(-1, "seekdir", 2);
+
+    fprintf(stdout, "Testing telldir");
+    ret = telldir(dh);
+    check_err(ret, "telldir", 2);
+
+    fprintf(stdout, "Testing closedir");
+    ret = closedir(dh);
+    check_err(ret, "closedir", 2);
+    return 0;
 }
 
-
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char            *testpath = NULL;
-        int             x = 0;
-
-        for (;x < argc; ++x) {
-                if (strcmp (argv[x], "--path") == 0) {
-                        testpath = argv[x+1];
-                        continue;
-                }
+    char *testpath = NULL;
+    int x = 0;
 
+    for (; x < argc; ++x) {
+        if (strcmp(argv[x], "--path") == 0) {
+            testpath = argv[x + 1];
+            continue;
         }
+    }
 
-        if (!testpath) {
-                fprintf (stderr, "--path not specified\n");
-                usage (stderr);
-                return -1;
-        }
+    if (!testpath) {
+        fprintf(stderr, "--path not specified\n");
+        usage(stderr);
+        return -1;
+    }
 
-        run_file_tests (testpath);
-        run_dir_tests (testpath);
-        run_attr_tests (testpath);
-        run_dev_tests (testpath);
+    run_file_tests(testpath);
+    run_dir_tests(testpath);
+    run_attr_tests(testpath);
+    run_dev_tests(testpath);
 
-        return 0;
+    return 0;
 }
-
-
diff --git a/extras/test/open-fd-tests.c b/extras/test/open-fd-tests.c
index ab902697228..509952b4180 100644
--- a/extras/test/open-fd-tests.c
+++ b/extras/test/open-fd-tests.c
@@ -9,56 +9,59 @@
 #include <string.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          ret      = -1;
-        int          fd       = 0;
-        char        *filename = NULL;
-        int          loop     = 0;
-        struct stat  stbuf    = {0,};
-        char         string[1024] = {0,};
+    int ret = -1;
+    int fd = 0;
+    char *filename = NULL;
+    int loop = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char string[1024] = {
+        0,
+    };
 
-        if (argc > 1)
-                filename = argv[1];
+    if (argc > 1)
+        filename = argv[1];
 
-        if (!filename)
-                filename = "temp-fd-test-file";
+    if (!filename)
+        filename = "temp-fd-test-file";
 
-        fd = open (filename, O_RDWR|O_CREAT|O_TRUNC);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        while (loop < 1000) {
-                /* Use it as a mechanism to test time delays */
-                memset (string, 0, 1024);
-                scanf ("%s", string);
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
 
-                ret = write (fd, string, strlen (string));
-                if (ret != strlen (string)) {
-                        fprintf (stderr, "write failed : %s (%s %d)\n",
-                                 strerror (errno), string, loop);
-                        goto out;
-                }
+    while (loop < 1000) {
+        /* Use it as a mechanism to test time delays */
+        memset(string, 0, 1024);
+        scanf("%s", string);
 
-                ret = write (fd, "\n", 1);
-                if (ret != 1) {
-                        fprintf (stderr, "write failed : %s (%d)\n",
-                                 strerror (errno), loop);
-                        goto out;
-                }
+        ret = write(fd, string, strlen(string));
+        if (ret != strlen(string)) {
+            fprintf(stderr, "write failed : %s (%s %d)\n", strerror(errno),
+                    string, loop);
+            goto out;
+        }
 
-                loop++;
+        ret = write(fd, "\n", 1);
+        if (ret != 1) {
+            fprintf(stderr, "write failed : %s (%d)\n", strerror(errno), loop);
+            goto out;
         }
 
-        fprintf (stdout, "finishing the test after %d loops\n", loop);
+        loop++;
+    }
+
+    fprintf(stdout, "finishing the test after %d loops\n", loop);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/extras/test/test-ffop.c b/extras/test/test-ffop.c
index 67c6a0fb33d..1d9c125db67 100644
--- a/extras/test/test-ffop.c
+++ b/extras/test/test-ffop.c
@@ -8,772 +8,820 @@
 #include <string.h>
 #include <dirent.h>
 
-int fd_based_fops_1 (char *filename); //for fd based fops after unlink
-int fd_based_fops_2 (char *filename); //for fd based fops before unlink
-int dup_fd_based_fops (char *filename); // fops based on fd after dup
-int path_based_fops (char *filename); //for fops based on path
-int dir_based_fops (char *filename); // for fops which operate on directory
-int link_based_fops (char *filename); //for fops which operate in link files (symlinks)
-int test_open_modes (char *filename); // to test open syscall with open modes available.
-int generic_open_read_write (char *filename, int flag); // generic function which does open write and read.
+int
+fd_based_fops_1(char *filename);  // for fd based fops after unlink
+int
+fd_based_fops_2(char *filename);  // for fd based fops before unlink
+int
+dup_fd_based_fops(char *filename);  // fops based on fd after dup
+int
+path_based_fops(char *filename);  // for fops based on path
+int
+dir_based_fops(char *filename);  // for fops which operate on directory
+int
+link_based_fops(
+    char *filename);  // for fops which operate in link files (symlinks)
+int
+test_open_modes(
+    char *filename);  // to test open syscall with open modes available.
+int
+generic_open_read_write(
+    char *filename,
+    int flag);  // generic function which does open write and read.
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret           = -1;
-        char  filename[255] = {0,};
-
-        if (argc > 1)
-                strcpy(filename, argv[1]);
-        else
-                strcpy(filename, "temp-xattr-test-file");
-
-        ret = fd_based_fops_1 (strcat(filename, "_1"));
-        if (ret < 0)
-                fprintf (stderr, "fd based file operation 1 failed\n");
-        else
-                fprintf (stdout, "fd based file operation 1 passed\n");
-
-        ret = fd_based_fops_2 (strcat(filename, "_2"));
-        if (ret < 0)
-                fprintf (stderr, "fd based file operation 2 failed\n");
-        else
-                fprintf (stdout, "fd based file operation 2 passed\n");
-
-        ret = dup_fd_based_fops (strcat (filename, "_3"));
-        if (ret < 0)
-                fprintf (stderr, "dup fd based file operation failed\n");
-        else
-                fprintf (stdout, "dup fd based file operation passed\n");
-
-        ret = path_based_fops (strcat (filename, "_4"));
-        if (ret < 0)
-                fprintf (stderr, "path based file operation failed\n");
-        else
-                fprintf (stdout, "path based file operation passed\n");
-
-        ret = dir_based_fops (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "directory based file operation failed\n");
-        else
-                fprintf (stdout, "directory based file operation passed\n");
-
-        ret = link_based_fops (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "link based file operation failed\n");
-        else
-                fprintf (stdout, "link based file operation passed\n");
-
-        ret = test_open_modes (strcat (filename, "_5"));
-        if (ret < 0)
-                fprintf (stderr, "testing modes of 'open' call failed\n");
-        else
-                fprintf (stdout, "testing modes of 'open' call passed\n");
+    int ret = -1;
+    char filename[255] = {
+        0,
+    };
+
+    if (argc > 1)
+        strcpy(filename, argv[1]);
+    else
+        strcpy(filename, "temp-xattr-test-file");
+
+    ret = fd_based_fops_1(strcat(filename, "_1"));
+    if (ret < 0)
+        fprintf(stderr, "fd based file operation 1 failed\n");
+    else
+        fprintf(stdout, "fd based file operation 1 passed\n");
+
+    ret = fd_based_fops_2(strcat(filename, "_2"));
+    if (ret < 0)
+        fprintf(stderr, "fd based file operation 2 failed\n");
+    else
+        fprintf(stdout, "fd based file operation 2 passed\n");
+
+    ret = dup_fd_based_fops(strcat(filename, "_3"));
+    if (ret < 0)
+        fprintf(stderr, "dup fd based file operation failed\n");
+    else
+        fprintf(stdout, "dup fd based file operation passed\n");
+
+    ret = path_based_fops(strcat(filename, "_4"));
+    if (ret < 0)
+        fprintf(stderr, "path based file operation failed\n");
+    else
+        fprintf(stdout, "path based file operation passed\n");
+
+    ret = dir_based_fops(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "directory based file operation failed\n");
+    else
+        fprintf(stdout, "directory based file operation passed\n");
+
+    ret = link_based_fops(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "link based file operation failed\n");
+    else
+        fprintf(stdout, "link based file operation passed\n");
+
+    ret = test_open_modes(strcat(filename, "_5"));
+    if (ret < 0)
+        fprintf(stderr, "testing modes of 'open' call failed\n");
+    else
+        fprintf(stdout, "testing modes of 'open' call passed\n");
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_based_fops_1 (char *filename)
+fd_based_fops_1(char *filename)
 {
-        int         fd        = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (fd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (fd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
+    int fd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        return ret;
+    return ret;
 }
 
-
 int
-fd_based_fops_2 (char *filename)
+fd_based_fops_2(char *filename)
 {
-        int         fd    = 0;
-        int         ret   = -1;
-        struct stat stbuf = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = ftruncate (fd, 0);
-
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (wstr, "This is my second string\n");
-        ret = write (fd, wstr, strlen (wstr));
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (fd, rstr, strlen (wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
+    int fd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = ftruncate(fd, 0);
+
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(wstr, "This is my second string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
 
 out:
-        if (fd)
-                close (fd);
-        unlink (filename);
+    if (fd)
+        close(fd);
+    unlink(filename);
 
-        return ret;
+    return ret;
 }
 
 int
-path_based_fops (char *filename)
+path_based_fops(char *filename)
 {
-        int         ret              = -1;
-        int         fd               = 0;
-        struct stat stbuf            = {0,};
-        char        newfilename[255] = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = truncate (filename, 0);
-        if (ret < 0) {
-                fprintf (stderr, "truncate failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = stat (filename, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chmod (filename, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chown (filename, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chown failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = listxattr (filename, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = removexattr (filename, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = access (filename, R_OK|W_OK);
-        if (ret < 0) {
-                fprintf (stderr, "access failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newfilename, filename);
-        strcat(newfilename, "_new");
-        ret = rename (filename, newfilename);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                goto out;
-        }
-        unlink (newfilename);
+    int ret = -1;
+    int fd = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char newfilename[255] = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = truncate(filename, 0);
+    if (ret < 0) {
+        fprintf(stderr, "truncate failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = stat(filename, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chmod(filename, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chown(filename, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chown failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = listxattr(filename, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = removexattr(filename, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = access(filename, R_OK | W_OK);
+    if (ret < 0) {
+        fprintf(stderr, "access failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newfilename, filename);
+    strcat(newfilename, "_new");
+    ret = rename(filename, newfilename);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        goto out;
+    }
+    unlink(newfilename);
 
 out:
-        if (fd)
-                close (fd);
+    if (fd)
+        close(fd);
 
-        unlink (filename);
-        return ret;
+    unlink(filename);
+    return ret;
 }
 
 int
-dup_fd_based_fops (char *filename)
+dup_fd_based_fops(char *filename)
 {
-        int         fd        = 0;
-        int         newfd     = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        newfd = dup (fd);
-        if (newfd < 0) {
-                ret = -1;
-                fprintf (stderr, "dup failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        close (fd);
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (newfd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lseek (newfd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = read (newfd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                ret = -1;
-                fprintf (stderr, "read returning junk\n");
-                goto out;
-        }
-
-        ret = ftruncate (newfd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fstat (newfd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchmod (newfd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fchown (newfd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fdatasync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = flistxattr (newfd, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = fremovexattr (newfd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
+    int fd = 0;
+    int newfd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    newfd = dup(fd);
+    if (newfd < 0) {
+        ret = -1;
+        fprintf(stderr, "dup failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    close(fd);
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(newfd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lseek(newfd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = read(newfd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        ret = -1;
+        fprintf(stderr, "read returning junk\n");
+        goto out;
+    }
+
+    ret = ftruncate(newfd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fstat(newfd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchmod(newfd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fchown(newfd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fdatasync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = flistxattr(newfd, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = fremovexattr(newfd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (newfd)
-                close (newfd);
-        ret = unlink (filename);
-        if (ret < 0)
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
+    if (newfd)
+        close(newfd);
+    ret = unlink(filename);
+    if (ret < 0)
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
 
-        return ret;
+    return ret;
 }
 
 int
-dir_based_fops (char *dirname)
+dir_based_fops(char *dirname)
 {
-        int            ret           = -1;
-        DIR           *dp            = NULL;
-        char           buff[255]     = {0,};
-        struct dirent *dbuff         = {0,};
-        struct stat    stbuff        = {0,};
-        char           newdname[255] = {0,};
-        char          *cwd           = NULL;
-
-        ret = mkdir (dirname, 0755);
-        if (ret < 0) {
-                fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        dp = opendir (dirname);
-        if (dp == NULL) {
-                fprintf (stderr, "opendir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        dbuff = readdir (dp);
-        if (NULL == dbuff) {
-                fprintf (stderr, "readdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = closedir (dp);
-        if (ret < 0) {
-                fprintf (stderr, "closedir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = stat (dirname, &stbuff);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chmod (dirname, 0744);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = chown (dirname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = listxattr (dirname, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = removexattr (dirname, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "/../");
-        ret = chdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "chdir failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        cwd = getcwd (buff, 255);
-        if (NULL == cwd) {
-                fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "new");
-        ret = rename (dirname, newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = rmdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
-                return ret;
-        }
+    int ret = -1;
+    DIR *dp = NULL;
+    char buff[255] = {
+        0,
+    };
+    struct dirent *dbuff = {
+        0,
+    };
+    struct stat stbuff = {
+        0,
+    };
+    char newdname[255] = {
+        0,
+    };
+    char *cwd = NULL;
+
+    ret = mkdir(dirname, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    dp = opendir(dirname);
+    if (dp == NULL) {
+        fprintf(stderr, "opendir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    dbuff = readdir(dp);
+    if (NULL == dbuff) {
+        fprintf(stderr, "readdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = closedir(dp);
+    if (ret < 0) {
+        fprintf(stderr, "closedir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = stat(dirname, &stbuff);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chmod(dirname, 0744);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = chown(dirname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = listxattr(dirname, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = getxattr(dirname, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = removexattr(dirname, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "/../");
+    ret = chdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "chdir failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    cwd = getcwd(buff, 255);
+    if (NULL == cwd) {
+        fprintf(stderr, "getcwd failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "new");
+    ret = rename(dirname, newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = rmdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rmdir failed: %s\n", strerror(errno));
+        return ret;
+    }
 
 out:
-        rmdir (dirname);
-        return ret;
+    rmdir(dirname);
+    return ret;
 }
 
 int
-link_based_fops (char *filename)
+link_based_fops(char *filename)
 {
-        int         ret           = -1;
-        int         fd            = 0;
-        char        newname[255]  = {0,};
-        char        linkname[255] = {0,};
-        struct stat lstbuf        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (newname, filename);
-        strcat (newname, "_hlink");
-        ret = link (filename, newname);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        strcpy (linkname, filename);
-        strcat (linkname, "_slink");
-        ret = symlink (newname, linkname);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lstat (linkname, &lstbuf);
-        if (ret < 0) {
-                fprintf (stderr, "lstbuf failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lchown (linkname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "lchown failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = llistxattr (linkname, NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "llistxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
-        ret = lremovexattr (linkname, "trusted.lxattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno));
-                goto out;
-        }
-
+    int ret = -1;
+    int fd = 0;
+    char newname[255] = {
+        0,
+    };
+    char linkname[255] = {
+        0,
+    };
+    struct stat lstbuf = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(newname, filename);
+    strcat(newname, "_hlink");
+    ret = link(filename, newname);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    strcpy(linkname, filename);
+    strcat(linkname, "_slink");
+    ret = symlink(newname, linkname);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lstat(linkname, &lstbuf);
+    if (ret < 0) {
+        fprintf(stderr, "lstbuf failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lchown(linkname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "lchown failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = llistxattr(linkname, NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "llistxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = lremovexattr(linkname, "trusted.lxattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno));
+        goto out;
+    }
 
 out:
-        if (fd)
-                close(fd);
-        unlink (linkname);
-        unlink (newname);
+    if (fd)
+        close(fd);
+    unlink(linkname);
+    unlink(newname);
 }
 
 int
-test_open_modes (char *filename)
+test_open_modes(char *filename)
 {
-        int ret = -1;
-
-        ret = generic_open_read_write (filename, O_CREAT|O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n");
-               goto out;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR failed\n");
-               goto out;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDONLY);
-        if (ret != 0) {
-                fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n");
-                goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_WRONLY failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDWR);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDWR failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDONLY);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDONLY failed\n");
-               goto out;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY);
-        if (3 != ret) {
-               fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n");
-               goto out;
-        }
+    int ret = -1;
+
+    ret = generic_open_read_write(filename, O_CREAT | O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n");
+        goto out;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR failed\n");
+        goto out;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDONLY);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_WRONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDWR);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDWR failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDONLY);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDONLY failed\n");
+        goto out;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY);
+    if (3 != ret) {
+        fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n");
+        goto out;
+    }
 
 #if 0 /* undefined behaviour, unable to reliably test */
         ret = creat (filename, 0644);
@@ -785,84 +833,88 @@ test_open_modes (char *filename)
         }
 #endif
 
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
-               goto out;
-        }
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
+        goto out;
+    }
 
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_CREAT|O_EXCL);
-        if (0 != ret) {
-                fprintf (stderr, "flag O_CREAT|O_EXCL failed\n");
-                goto out;
-        }
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_CREAT | O_EXCL);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_EXCL failed\n");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-int generic_open_read_write (char *filename, int flag)
+int
+generic_open_read_write(char *filename, int flag)
 {
-        int  fd          = 0;
-        int  ret         = -1;
-        char wstring[50] = {0,};
-        char rstring[50] = {0,};
-
-        fd = open (filename, flag);
-        if (fd < 0) {
-                if (flag == O_CREAT|O_EXCL && errno == EEXIST) {
-                        unlink (filename);
-                        return 0;
-                }
-                else {
-                        fd = 0;
-                        fprintf (stderr, "open failed: %s\n", strerror (errno));
-                        return 1;
-                }
-        }
-
-        strcpy (wstring, "My string to write\n");
-        ret = write (fd, wstring, strlen(wstring));
-        if (ret <= 0) {
-                if (errno != EBADF) {
-                        fprintf (stderr, "write failed: %s\n", strerror (errno));
-                        close (fd);
-                        unlink(filename);
-                        return 2;
-                }
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                close (fd);
-                unlink(filename);
-                return 4;
-        }
-
-        ret = read (fd, rstring, strlen(wstring));
-        if (ret < 0) {
-                close (fd);
-                unlink (filename);
-                return 3;
-        }
-
-        /* Compare the rstring with wstring. But we do not want to return
-         * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
-         * O_TRUNC|O_RDONLY. Because in that case we are not writing
-         * anything to the file.*/
-
-        ret = memcmp (wstring, rstring, strlen (wstring));
-        if (0 != ret  && !(flag == O_CREAT|O_RDONLY || flag == O_RDONLY ||\
-            flag == O_TRUNC|O_RDONLY)) {
-                fprintf (stderr, "read is returning junk\n");
-                close (fd);
-                unlink (filename);
-                return 4;
-        }
-
-        close (fd);
-        unlink (filename);
-        return 0;
+    int fd = 0;
+    int ret = -1;
+    char wstring[50] = {
+        0,
+    };
+    char rstring[50] = {
+        0,
+    };
+
+    fd = open(filename, flag);
+    if (fd < 0) {
+        if (flag == O_CREAT | O_EXCL && errno == EEXIST) {
+            unlink(filename);
+            return 0;
+        } else {
+            fd = 0;
+            fprintf(stderr, "open failed: %s\n", strerror(errno));
+            return 1;
+        }
+    }
+
+    strcpy(wstring, "My string to write\n");
+    ret = write(fd, wstring, strlen(wstring));
+    if (ret <= 0) {
+        if (errno != EBADF) {
+            fprintf(stderr, "write failed: %s\n", strerror(errno));
+            close(fd);
+            unlink(filename);
+            return 2;
+        }
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return 4;
+    }
+
+    ret = read(fd, rstring, strlen(wstring));
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return 3;
+    }
+
+    /* Compare the rstring with wstring. But we do not want to return
+     * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
+     * O_TRUNC|O_RDONLY. Because in that case we are not writing
+     * anything to the file.*/
+
+    ret = memcmp(wstring, rstring, strlen(wstring));
+    if (0 != ret && !(flag == O_CREAT | O_RDONLY || flag == O_RDONLY ||
+                      flag == O_TRUNC | O_RDONLY)) {
+        fprintf(stderr, "read is returning junk\n");
+        close(fd);
+        unlink(filename);
+        return 4;
+    }
+
+    close(fd);
+    unlink(filename);
+    return 0;
 }
diff --git a/geo-replication/src/gsyncd.c b/geo-replication/src/gsyncd.c
index df2ee35b037..77af6628d14 100644
--- a/geo-replication/src/gsyncd.c
+++ b/geo-replication/src/gsyncd.c
@@ -42,359 +42,362 @@
 int restricted = 0;
 
 static int
-duplexpand (void **buf, size_t tsiz, size_t *len)
+duplexpand(void **buf, size_t tsiz, size_t *len)
 {
-        size_t osiz = tsiz * *len;
-        char *p = realloc (*buf, osiz << 1);
-        if (!p) {
-                free(*buf);
-                return -1;
-        }
+    size_t osiz = tsiz * *len;
+    char *p = realloc(*buf, osiz << 1);
+    if (!p) {
+        free(*buf);
+        return -1;
+    }
 
-        memset (p + osiz, 0, osiz);
-        *buf = p;
-        *len <<= 1;
+    memset(p + osiz, 0, osiz);
+    *buf = p;
+    *len <<= 1;
 
-        return 0;
+    return 0;
 }
 
 static int
-str2argv (char *str, char ***argv)
+str2argv(char *str, char ***argv)
 {
-        char *p         = NULL;
-        char *savetok   = NULL;
-        char *temp      = NULL;
-        char *temp1     = NULL;
-        int argc        = 0;
-        size_t argv_len = 32;
-        int ret         = 0;
-        int i           = 0;
-
-        assert (str);
-        temp = str = strdup (str);
-        if (!str)
+    char *p = NULL;
+    char *savetok = NULL;
+    char *temp = NULL;
+    char *temp1 = NULL;
+    int argc = 0;
+    size_t argv_len = 32;
+    int ret = 0;
+    int i = 0;
+
+    assert(str);
+    temp = str = strdup(str);
+    if (!str)
+        goto error;
+
+    *argv = calloc(argv_len, sizeof(**argv));
+    if (!*argv)
+        goto error;
+
+    while ((p = strtok_r(str, " ", &savetok))) {
+        str = NULL;
+
+        argc++;
+        if (argc == argv_len) {
+            ret = duplexpand((void *)argv, sizeof(**argv), &argv_len);
+            if (ret == -1)
                 goto error;
-
-        *argv = calloc (argv_len, sizeof (**argv));
-        if (!*argv)
-                goto error;
-
-        while ((p = strtok_r (str, " ", &savetok))) {
-                str = NULL;
-
-                argc++;
-                if (argc == argv_len) {
-                        ret = duplexpand ((void *)argv,
-                                          sizeof (**argv),
-                                          &argv_len);
-                        if (ret == -1)
-                                goto error;
-                }
-                temp1 = strdup (p);
-                if (!temp1)
-                        goto error;
-                (*argv)[argc - 1] = temp1;
         }
-
-        free(temp);
-        return argc;
-
- error:
-        fprintf (stderr, "out of memory\n");
-        free(temp);
-        for (i = 0; i < argc - 1; i++)
-                free((*argv)[i]);
-        free(*argv);
-        return -1;
+        temp1 = strdup(p);
+        if (!temp1)
+            goto error;
+        (*argv)[argc - 1] = temp1;
+    }
+
+    free(temp);
+    return argc;
+
+error:
+    fprintf(stderr, "out of memory\n");
+    free(temp);
+    for (i = 0; i < argc - 1; i++)
+        free((*argv)[i]);
+    free(*argv);
+    return -1;
 }
 
 static int
-invoke_gsyncd (int argc, char **argv)
+invoke_gsyncd(int argc, char **argv)
 {
-        int i                      = 0;
-        int j                      = 0;
-        char *nargv[argc + 4];
-        char *python = NULL;
+    int i = 0;
+    int j = 0;
+    char *nargv[argc + 4];
+    char *python = NULL;
 
-        if (chdir ("/") == -1)
-                goto error;
+    if (chdir("/") == -1)
+        goto error;
 
-        j = 0;
-        python = getenv("PYTHON");
-        if(!python)
-                python = PYTHON;
-        nargv[j++] = python;
-        nargv[j++] = GSYNCD_PREFIX"/python/syncdaemon/"GSYNCD_PY;
-        for (i = 1; i < argc; i++)
-                nargv[j++] = argv[i];
+    j = 0;
+    python = getenv("PYTHON");
+    if (!python)
+        python = PYTHON;
+    nargv[j++] = python;
+    nargv[j++] = GSYNCD_PREFIX "/python/syncdaemon/" GSYNCD_PY;
+    for (i = 1; i < argc; i++)
+        nargv[j++] = argv[i];
 
-        nargv[j++] = NULL;
+    nargv[j++] = NULL;
 
-        execvp (python, nargv);
+    execvp(python, nargv);
 
-        fprintf (stderr, "exec of '%s' failed\n", python);
-        return 127;
+    fprintf(stderr, "exec of '%s' failed\n", python);
+    return 127;
 
- error:
-        fprintf (stderr, "gsyncd initializaion failed\n");
-        return 1;
+error:
+    fprintf(stderr, "gsyncd initializaion failed\n");
+    return 1;
 }
 
-
 static int
-find_gsyncd (pid_t pid, pid_t ppid, char *name, void *data)
+find_gsyncd(pid_t pid, pid_t ppid, char *name, void *data)
 {
-        char buf[NAME_MAX * 2] = {0,};
-        char path[PATH_MAX]    = {0,};
-        char *p                = NULL;
-        int zeros              = 0;
-        int ret                = 0;
-        int fd                 = -1;
-        pid_t *pida            = (pid_t *)data;
-
-        if (ppid != pida[0])
-                return 0;
-
-        snprintf (path, sizeof path, PROC"/%d/cmdline", pid);
-        fd = open (path, O_RDONLY);
-        if (fd == -1)
-                return 0;
-        ret = sys_read (fd, buf, sizeof (buf));
-        sys_close (fd);
-        if (ret == -1)
-                return 0;
-        for (zeros = 0, p = buf; zeros < 2 && p < buf + ret; p++)
-                zeros += !*p;
-
-        ret = 0;
-        switch (zeros) {
+    char buf[NAME_MAX * 2] = {
+        0,
+    };
+    char path[PATH_MAX] = {
+        0,
+    };
+    char *p = NULL;
+    int zeros = 0;
+    int ret = 0;
+    int fd = -1;
+    pid_t *pida = (pid_t *)data;
+
+    if (ppid != pida[0])
+        return 0;
+
+    snprintf(path, sizeof path, PROC "/%d/cmdline", pid);
+    fd = open(path, O_RDONLY);
+    if (fd == -1)
+        return 0;
+    ret = sys_read(fd, buf, sizeof(buf));
+    sys_close(fd);
+    if (ret == -1)
+        return 0;
+    for (zeros = 0, p = buf; zeros < 2 && p < buf + ret; p++)
+        zeros += !*p;
+
+    ret = 0;
+    switch (zeros) {
         case 2:
-                if ((strcmp (basename (buf), basename (PYTHON)) ||
-                     strcmp (basename (buf + strlen (buf) + 1), GSYNCD_PY)) == 0) {
-                        ret = 1;
-                        break;
-                }
-                /* fallthrough */
+            if ((strcmp(basename(buf), basename(PYTHON)) ||
+                 strcmp(basename(buf + strlen(buf) + 1), GSYNCD_PY)) == 0) {
+                ret = 1;
+                break;
+            }
+            /* fallthrough */
         case 1:
-                if (strcmp (basename (buf), GSYNCD_PY) == 0)
-                        ret = 1;
-        }
-
-        if (ret == 1) {
-                if (pida[1] != -1) {
-                        fprintf (stderr, GSYNCD_PY" sibling is not unique");
-                        return -1;
-                }
-                pida[1] = pid;
+            if (strcmp(basename(buf), GSYNCD_PY) == 0)
+                ret = 1;
+    }
+
+    if (ret == 1) {
+        if (pida[1] != -1) {
+            fprintf(stderr, GSYNCD_PY " sibling is not unique");
+            return -1;
         }
+        pida[1] = pid;
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-invoke_rsync (int argc, char **argv)
+invoke_rsync(int argc, char **argv)
 {
-        int i                  = 0;
-        char path[PATH_MAX]    = {0,};
-        pid_t pid              = -1;
-        pid_t ppid             = -1;
-        pid_t pida[]           = {-1, -1};
-        char *name             = NULL;
-        char buf[PATH_MAX + 1] = {0,};
-        int ret                = 0;
-
-        assert (argv[argc] == NULL);
-
-        if (argc < 2 || strcmp (argv[1], "--server") != 0)
-                goto error;
-
-        for (i = 2; i < argc && argv[i][0] == '-'; i++);
-
-        if (!(i == argc - 2 && strcmp (argv[i], ".") == 0 && argv[i + 1][0] == '/')) {
-                fprintf (stderr, "need an rsync invocation without protected args\n");
-                goto error;
+    int i = 0;
+    char path[PATH_MAX] = {
+        0,
+    };
+    pid_t pid = -1;
+    pid_t ppid = -1;
+    pid_t pida[] = {-1, -1};
+    char *name = NULL;
+    char buf[PATH_MAX + 1] = {
+        0,
+    };
+    int ret = 0;
+
+    assert(argv[argc] == NULL);
+
+    if (argc < 2 || strcmp(argv[1], "--server") != 0)
+        goto error;
+
+    for (i = 2; i < argc && argv[i][0] == '-'; i++)
+        ;
+
+    if (!(i == argc - 2 && strcmp(argv[i], ".") == 0 &&
+          argv[i + 1][0] == '/')) {
+        fprintf(stderr, "need an rsync invocation without protected args\n");
+        goto error;
+    }
+
+    /* look up sshd we are spawned from */
+    for (pid = getpid();; pid = ppid) {
+        ppid = pidinfo(pid, &name);
+        if (ppid < 0) {
+            fprintf(stderr, "sshd ancestor not found\n");
+            goto error;
         }
-
-        /* look up sshd we are spawned from */
-        for (pid = getpid () ;; pid = ppid) {
-                ppid = pidinfo (pid, &name);
-                if (ppid < 0) {
-                        fprintf (stderr, "sshd ancestor not found\n");
-                        goto error;
-                }
-                if (strcmp (name, "sshd") == 0) {
-                        GF_FREE (name);
-                        break;
-                }
-                GF_FREE (name);
+        if (strcmp(name, "sshd") == 0) {
+            GF_FREE(name);
+            break;
         }
-        /* look up "ssh-sibling" gsyncd */
-        pida[0] = pid;
-        ret = prociter (find_gsyncd, pida);
-        if (ret == -1 || pida[1] == -1) {
-                fprintf (stderr, "gsyncd sibling not found\n");
-                goto error;
-        }
-        /* check if rsync target matches gsyncd target */
-        snprintf (path, sizeof path, PROC"/%d/cwd", pida[1]);
-        ret = sys_readlink (path, buf, sizeof (buf));
-        if (ret == -1 || ret == sizeof (buf))
-                goto error;
-        if (strcmp (argv[argc - 1], "/") == 0 /* root dir cannot be a target */ ||
-            (strcmp (argv[argc - 1], path) /* match against gluster target */ &&
-             strcmp (argv[argc - 1], buf) /* match against file target */) != 0) {
-                fprintf (stderr, "rsync target does not match "GEOREP" session\n");
-                goto error;
-        }
-
-        argv[0] = RSYNC;
-
-        execvp (RSYNC, argv);
-
-        fprintf (stderr, "exec of "RSYNC" failed\n");
-        return 127;
-
- error:
-        fprintf (stderr, "disallowed "RSYNC" invocation\n");
-        return 1;
+        GF_FREE(name);
+    }
+    /* look up "ssh-sibling" gsyncd */
+    pida[0] = pid;
+    ret = prociter(find_gsyncd, pida);
+    if (ret == -1 || pida[1] == -1) {
+        fprintf(stderr, "gsyncd sibling not found\n");
+        goto error;
+    }
+    /* check if rsync target matches gsyncd target */
+    snprintf(path, sizeof path, PROC "/%d/cwd", pida[1]);
+    ret = sys_readlink(path, buf, sizeof(buf));
+    if (ret == -1 || ret == sizeof(buf))
+        goto error;
+    if (strcmp(argv[argc - 1], "/") == 0 /* root dir cannot be a target */ ||
+        (strcmp(argv[argc - 1], path) /* match against gluster target */ &&
+         strcmp(argv[argc - 1], buf) /* match against file target */) != 0) {
+        fprintf(stderr, "rsync target does not match " GEOREP " session\n");
+        goto error;
+    }
+
+    argv[0] = RSYNC;
+
+    execvp(RSYNC, argv);
+
+    fprintf(stderr, "exec of " RSYNC " failed\n");
+    return 127;
+
+error:
+    fprintf(stderr, "disallowed " RSYNC " invocation\n");
+    return 1;
 }
 
 static int
-invoke_gluster (int argc, char **argv)
+invoke_gluster(int argc, char **argv)
 {
-        int i = 0;
-        int j = 0;
-        int optsover = 0;
-        char *ov = NULL;
-
-        for (i = 1; i < argc; i++) {
-                ov = strtail (argv[i], "--");
-                if (ov && !optsover) {
-                        if (*ov == '\0')
-                                optsover = 1;
-                        continue;
-                }
-                switch (++j) {
-                case 1:
-                        if (strcmp (argv[i], "volume") != 0)
-                                goto error;
-                        break;
-                case 2:
-                        if (strcmp (argv[i], "info") != 0)
-                                goto error;
-                        break;
-                case 3:
-                        break;
-                default:
-                        goto error;
-                }
+    int i = 0;
+    int j = 0;
+    int optsover = 0;
+    char *ov = NULL;
+
+    for (i = 1; i < argc; i++) {
+        ov = strtail(argv[i], "--");
+        if (ov && !optsover) {
+            if (*ov == '\0')
+                optsover = 1;
+            continue;
+        }
+        switch (++j) {
+            case 1:
+                if (strcmp(argv[i], "volume") != 0)
+                    goto error;
+                break;
+            case 2:
+                if (strcmp(argv[i], "info") != 0)
+                    goto error;
+                break;
+            case 3:
+                break;
+            default:
+                goto error;
         }
+    }
 
-        argv[0] = "gluster";
-        execvp (SBIN_DIR"/gluster", argv);
-        fprintf (stderr, "exec of gluster failed\n");
-        return 127;
+    argv[0] = "gluster";
+    execvp(SBIN_DIR "/gluster", argv);
+    fprintf(stderr, "exec of gluster failed\n");
+    return 127;
 
- error:
-        fprintf (stderr, "disallowed gluster invocation\n");
-        return 1;
+error:
+    fprintf(stderr, "disallowed gluster invocation\n");
+    return 1;
 }
 
 struct invocable {
-        char *name;
-        int (*invoker) (int argc, char **argv);
+    char *name;
+    int (*invoker)(int argc, char **argv);
 };
 
-struct invocable invocables[] = {
-        { "rsync",   invoke_rsync  },
-        { "gsyncd",  invoke_gsyncd },
-        { "gluster", invoke_gluster },
-        { NULL, NULL}
-};
+struct invocable invocables[] = {{"rsync", invoke_rsync},
+                                 {"gsyncd", invoke_gsyncd},
+                                 {"gluster", invoke_gluster},
+                                 {NULL, NULL}};
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int               ret   = -1;
-        char             *evas  = NULL;
-        struct invocable *i     = NULL;
-        char             *b     = NULL;
-        char             *sargv = NULL;
-        int               j     = 0;
+    int ret = -1;
+    char *evas = NULL;
+    struct invocable *i = NULL;
+    char *b = NULL;
+    char *sargv = NULL;
+    int j = 0;
 
 #ifdef USE_LIBGLUSTERFS
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return ENOMEM;
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return ENOMEM;
 
-        if (glusterfs_globals_init (ctx))
-                return 1;
+    if (glusterfs_globals_init(ctx))
+        return 1;
 
-        THIS->ctx = ctx;
-        ret = default_mem_acct_init (THIS);
-        if (ret) {
-                fprintf (stderr, "internal error: mem accounting failed\n");
-                return 1;
-        }
+    THIS->ctx = ctx;
+    ret = default_mem_acct_init(THIS);
+    if (ret) {
+        fprintf(stderr, "internal error: mem accounting failed\n");
+        return 1;
+    }
 #endif
 
-        evas = getenv (_GLUSTERD_CALLED_);
-        if (evas && strcmp (evas, "1") == 0)
-                /* OK, we know glusterd called us, no need to look for further config
-                 *...although this conclusion should not inherit to our children
-                 */
-                unsetenv (_GLUSTERD_CALLED_);
-        else {
-                /* we regard all gsyncd invocations unsafe
-                 * that do not come from glusterd and
-                 * therefore restrict it
-                 */
-                restricted = 1;
-
-                if (!getenv (_GSYNCD_DISPATCHED_)) {
-                        evas = getenv ("SSH_ORIGINAL_COMMAND");
-                        if (evas)
-                                sargv = evas;
-                        else {
-                                evas = getenv ("SHELL");
-                                if (evas && strcmp (basename (evas), "gsyncd") == 0 &&
-                                    argc == 3 && strcmp (argv[1], "-c") == 0)
-                                        sargv = argv[2];
-                        }
-                }
-
+    evas = getenv(_GLUSTERD_CALLED_);
+    if (evas && strcmp(evas, "1") == 0)
+        /* OK, we know glusterd called us, no need to look for further config
+         *...although this conclusion should not inherit to our children
+         */
+        unsetenv(_GLUSTERD_CALLED_);
+    else {
+        /* we regard all gsyncd invocations unsafe
+         * that do not come from glusterd and
+         * therefore restrict it
+         */
+        restricted = 1;
+
+        if (!getenv(_GSYNCD_DISPATCHED_)) {
+            evas = getenv("SSH_ORIGINAL_COMMAND");
+            if (evas)
+                sargv = evas;
+            else {
+                evas = getenv("SHELL");
+                if (evas && strcmp(basename(evas), "gsyncd") == 0 &&
+                    argc == 3 && strcmp(argv[1], "-c") == 0)
+                    sargv = argv[2];
+            }
         }
+    }
 
-        if (!(sargv && restricted))
-                return invoke_gsyncd (argc, argv);
+    if (!(sargv && restricted))
+        return invoke_gsyncd(argc, argv);
 
-        argc = str2argv (sargv, &argv);
+    argc = str2argv(sargv, &argv);
 
-        if (argc == -1) {
-                fprintf (stderr, "internal error\n");
-                return 1;
-        }
-
-        if (setenv (_GSYNCD_DISPATCHED_, "1", 1) == -1) {
-                fprintf (stderr, "internal error\n");
-                goto out;
-        }
+    if (argc == -1) {
+        fprintf(stderr, "internal error\n");
+        return 1;
+    }
 
+    if (setenv(_GSYNCD_DISPATCHED_, "1", 1) == -1) {
+        fprintf(stderr, "internal error\n");
+        goto out;
+    }
 
-        b = basename (argv[0]);
-        for (i = invocables; i->name; i++) {
-                if (strcmp (b, i->name) == 0)
-                        return i->invoker (argc, argv);
-        }
+    b = basename(argv[0]);
+    for (i = invocables; i->name; i++) {
+        if (strcmp(b, i->name) == 0)
+            return i->invoker(argc, argv);
+    }
 
-        fprintf (stderr, "invoking %s in restricted SSH session is not allowed\n",
-                 b);
+    fprintf(stderr, "invoking %s in restricted SSH session is not allowed\n",
+            b);
 
 out:
-        for (j = 1; j < argc; j++)
-                free(argv[j]);
-        free(argv);
-        return 1;
+    for (j = 1; j < argc; j++)
+        free(argv[j]);
+    free(argv);
+    return 1;
 }
diff --git a/geo-replication/src/procdiggy.c b/geo-replication/src/procdiggy.c
index 4fb6a2405e4..05c1e1edc68 100644
--- a/geo-replication/src/procdiggy.c
+++ b/geo-replication/src/procdiggy.c
@@ -20,107 +20,115 @@
 #include "procdiggy.h"
 
 pid_t
-pidinfo (pid_t pid, char **name)
+pidinfo(pid_t pid, char **name)
 {
-        char buf[NAME_MAX * 2] = {0,};
-        FILE *f                = NULL;
-        char path[PATH_MAX]    = {0,};
-        char *p                = NULL;
-        int ret                = 0;
-
-        snprintf (path, sizeof path, PROC"/%d/status", pid);
-
-        f = fopen (path, "r");
-        if (!f)
-                return -1;
-
-        if (name)
-                *name = NULL;
-        for (;;) {
-                size_t len;
-                memset (buf, 0, sizeof (buf));
-                if (fgets (buf, sizeof (buf), f) == NULL ||
-                    (len = strlen (buf)) == 0 ||
-                    buf[len - 1] != '\n') {
-                        pid = -1;
-                        goto out;
-                }
-                buf[len - 1] = '\0';
-
-                if (name && !*name) {
-                        p = strtail (buf, "Name:");
-                        if (p) {
-                                while (isspace (*++p));
-                                *name = gf_strdup (p);
-                                if (!*name) {
-                                        pid = -2;
-                                        goto out;
-                                }
-                                continue;
-                        }
+    char buf[NAME_MAX * 2] = {
+        0,
+    };
+    FILE *f = NULL;
+    char path[PATH_MAX] = {
+        0,
+    };
+    char *p = NULL;
+    int ret = 0;
+
+    snprintf(path, sizeof path, PROC "/%d/status", pid);
+
+    f = fopen(path, "r");
+    if (!f)
+        return -1;
+
+    if (name)
+        *name = NULL;
+    for (;;) {
+        size_t len;
+        memset(buf, 0, sizeof(buf));
+        if (fgets(buf, sizeof(buf), f) == NULL || (len = strlen(buf)) == 0 ||
+            buf[len - 1] != '\n') {
+            pid = -1;
+            goto out;
+        }
+        buf[len - 1] = '\0';
+
+        if (name && !*name) {
+            p = strtail(buf, "Name:");
+            if (p) {
+                while (isspace(*++p))
+                    ;
+                *name = gf_strdup(p);
+                if (!*name) {
+                    pid = -2;
+                    goto out;
                 }
-
-                p = strtail (buf, "PPid:");
-                if (p)
-                        break;
+                continue;
+            }
         }
 
-        while (isspace (*++p));
-        ret = gf_string2int (p, &pid);
-        if (ret == -1)
-                pid = -1;
-
- out:
-        fclose (f);
-        if (pid == -1  && name && *name)
-                GF_FREE (*name);
-        if (pid == -2)
-                fprintf (stderr, "out of memory\n");
-        return pid;
+        p = strtail(buf, "PPid:");
+        if (p)
+            break;
+    }
+
+    while (isspace(*++p))
+        ;
+    ret = gf_string2int(p, &pid);
+    if (ret == -1)
+        pid = -1;
+
+out:
+    fclose(f);
+    if (pid == -1 && name && *name)
+        GF_FREE(*name);
+    if (pid == -2)
+        fprintf(stderr, "out of memory\n");
+    return pid;
 }
 
 int
-prociter (int (*proch) (pid_t pid, pid_t ppid, char *tmpname, void *data),
-          void *data)
+prociter(int (*proch)(pid_t pid, pid_t ppid, char *tmpname, void *data),
+         void *data)
 {
-        char *name        = NULL;
-        DIR *d            = NULL;
-        struct dirent *de = NULL;
-        struct dirent scratch[2] = {{0,},};
-        pid_t pid         = -1;
-        pid_t ppid        = -1;
-        int ret           = 0;
-
-        d = sys_opendir (PROC);
-        if (!d)
-                return -1;
-
-        for (;;) {
-                errno = 0;
-                de = sys_readdir (d, scratch);
-                if (!de || errno != 0)
-                        break;
-
-                if (gf_string2int (de->d_name, &pid) != -1 && pid >= 0) {
-                        ppid = pidinfo (pid, &name);
-                        switch (ppid) {
-                        case -1:
-                                continue;
-                        case -2:
-                                break;
-                        }
-                        ret = proch (pid, ppid, name, data);
-                        GF_FREE (name);
-                        if (ret)
-                                break;
-                }
-        }
-        sys_closedir (d);
-        if (!de && errno) {
-                fprintf (stderr, "failed to traverse "PROC" (%s)\n",
-                         strerror (errno));
-                ret = -1;
+    char *name = NULL;
+    DIR *d = NULL;
+    struct dirent *de = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    pid_t pid = -1;
+    pid_t ppid = -1;
+    int ret = 0;
+
+    d = sys_opendir(PROC);
+    if (!d)
+        return -1;
+
+    for (;;) {
+        errno = 0;
+        de = sys_readdir(d, scratch);
+        if (!de || errno != 0)
+            break;
+
+        if (gf_string2int(de->d_name, &pid) != -1 && pid >= 0) {
+            ppid = pidinfo(pid, &name);
+            switch (ppid) {
+                case -1:
+                    continue;
+                case -2:
+                    break;
+            }
+            ret = proch(pid, ppid, name, data);
+            GF_FREE(name);
+            if (ret)
+                break;
         }
-
-        return ret;
+    }
+    sys_closedir(d);
+    if (!de && errno) {
+        fprintf(stderr, "failed to traverse " PROC " (%s)\n", strerror(errno));
+        ret = -1;
+    }
+
+    return ret;
 }
diff --git a/glusterfsd/src/gf_attach.c b/glusterfsd/src/gf_attach.c
index 1c1106c06f6..07ec0ed0686 100644
--- a/glusterfsd/src/gf_attach.c
+++ b/glusterfsd/src/gf_attach.c
@@ -25,189 +25,186 @@ int done = 0;
 int rpc_status;
 
 struct rpc_clnt_procedure gf_attach_actors[GLUSTERD_BRICK_MAXVALUE] = {
-        [GLUSTERD_BRICK_NULL] = {"NULL", NULL },
-        [GLUSTERD_BRICK_OP]   = {"BRICK_OP", NULL },
+    [GLUSTERD_BRICK_NULL] = {"NULL", NULL},
+    [GLUSTERD_BRICK_OP] = {"BRICK_OP", NULL},
 };
 
 struct rpc_clnt_program gf_attach_prog = {
-        .progname  = "brick operations",
-        .prognum   = GD_BRICK_PROGRAM,
-        .progver   = GD_BRICK_VERSION,
-        .proctable = gf_attach_actors,
-        .numproc   = GLUSTERD_BRICK_MAXVALUE,
+    .progname = "brick operations",
+    .prognum = GD_BRICK_PROGRAM,
+    .progver = GD_BRICK_VERSION,
+    .proctable = gf_attach_actors,
+    .numproc = GLUSTERD_BRICK_MAXVALUE,
 };
 
 int32_t
-my_callback (struct rpc_req *req, struct iovec *iov, int count, void *frame)
+my_callback(struct rpc_req *req, struct iovec *iov, int count, void *frame)
 {
-        rpc_status = req->rpc_status;
-        done = 1;
-        return 0;
+    rpc_status = req->rpc_status;
+    done = 1;
+    return 0;
 }
 
 /* copied from gd_syncop_submit_request */
 int
-send_brick_req (xlator_t *this, struct rpc_clnt *rpc, char *path, int op)
+send_brick_req(xlator_t *this, struct rpc_clnt *rpc, char *path, int op)
 {
-        int            ret      = -1;
-        struct iobuf  *iobuf    = NULL;
-        struct iobref *iobref   = NULL;
-        struct iovec   iov      = {0, };
-        ssize_t        req_size = 0;
-        call_frame_t  *frame    = NULL;
-        gd1_mgmt_brick_op_req   brick_req;
-        void                    *req = &brick_req;
-        int                     i;
-
-        brick_req.op = op;
-        brick_req.name = path;
-        brick_req.input.input_val = NULL;
-        brick_req.input.input_len = 0;
-
-        req_size = xdr_sizeof ((xdrproc_t)xdr_gd1_mgmt_brick_op_req, req);
-        iobuf = iobuf_get2 (rpc->ctx->iobuf_pool, req_size);
-        if (!iobuf)
-                goto out;
-
-        iobref = iobref_new ();
-        if (!iobref)
-                goto out;
-
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
-
-        iobref_add (iobref, iobuf);
-
-        iov.iov_base = iobuf->ptr;
-        iov.iov_len  = iobuf_pagesize (iobuf);
-
-        /* Create the xdr payload */
-        ret = xdr_serialize_generic (iov, req,
-                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret == -1)
-                goto out;
-
-        iov.iov_len = ret;
-
-        for (i = 0; i < 60; ++i) {
-                if (rpc->conn.connected) {
-                        break;
-                }
-                sleep (1);
+    int ret = -1;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec iov = {
+        0,
+    };
+    ssize_t req_size = 0;
+    call_frame_t *frame = NULL;
+    gd1_mgmt_brick_op_req brick_req;
+    void *req = &brick_req;
+    int i;
+
+    brick_req.op = op;
+    brick_req.name = path;
+    brick_req.input.input_val = NULL;
+    brick_req.input.input_len = 0;
+
+    req_size = xdr_sizeof((xdrproc_t)xdr_gd1_mgmt_brick_op_req, req);
+    iobuf = iobuf_get2(rpc->ctx->iobuf_pool, req_size);
+    if (!iobuf)
+        goto out;
+
+    iobref = iobref_new();
+    if (!iobref)
+        goto out;
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
+
+    iobref_add(iobref, iobuf);
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    /* Create the xdr payload */
+    ret = xdr_serialize_generic(iov, req, (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret == -1)
+        goto out;
+
+    iov.iov_len = ret;
+
+    for (i = 0; i < 60; ++i) {
+        if (rpc->conn.connected) {
+            break;
         }
-
-        /* Send the msg */
-        ret = rpc_clnt_submit (rpc, &gf_attach_prog, op,
-                               my_callback, &iov, 1, NULL, 0, iobref, frame,
-                               NULL, 0, NULL, 0, NULL);
-        if (!ret) {
-                for (i = 0; !done && (i < 120); ++i) {
-                        sleep (1);
-                }
+        sleep(1);
+    }
+
+    /* Send the msg */
+    ret = rpc_clnt_submit(rpc, &gf_attach_prog, op, my_callback, &iov, 1, NULL,
+                          0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    if (!ret) {
+        for (i = 0; !done && (i < 120); ++i) {
+            sleep(1);
         }
+    }
 
 out:
 
-        iobref_unref (iobref);
-        iobuf_unref (iobuf);
-        if (frame)
-                STACK_DESTROY (frame->root);
+    iobref_unref(iobref);
+    iobuf_unref(iobuf);
+    if (frame)
+        STACK_DESTROY(frame->root);
 
-        if (rpc_status != 0) {
-                fprintf (stderr, "got error %d on RPC\n", rpc_status);
-                return EXIT_FAILURE;
-        }
+    if (rpc_status != 0) {
+        fprintf(stderr, "got error %d on RPC\n", rpc_status);
+        return EXIT_FAILURE;
+    }
 
-        printf ("OK\n");
-        return EXIT_SUCCESS;
+    printf("OK\n");
+    return EXIT_SUCCESS;
 }
 
 int
-usage (char *prog)
+usage(char *prog)
 {
-        fprintf (stderr, "Usage: %s uds_path volfile_path (to attach)\n",
-                 prog);
-        fprintf (stderr, "       %s -d uds_path brick_path (to detach)\n",
-                 prog);
+    fprintf(stderr, "Usage: %s uds_path volfile_path (to attach)\n", prog);
+    fprintf(stderr, "       %s -d uds_path brick_path (to detach)\n", prog);
 
-        return EXIT_FAILURE;
+    return EXIT_FAILURE;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                  *fs;
-        struct rpc_clnt         *rpc;
-        dict_t                  *options;
-        int                     ret;
-        int                     op = GLUSTERD_BRICK_ATTACH;
-
-        for (;;) {
-                switch (getopt (argc, argv, "d")) {
-                case 'd':
-                        op = GLUSTERD_BRICK_TERMINATE;
-                        break;
-                case -1:
-                        goto done_parsing;
-                default:
-                        return usage (argv[0]);
-                }
+    glfs_t *fs;
+    struct rpc_clnt *rpc;
+    dict_t *options;
+    int ret;
+    int op = GLUSTERD_BRICK_ATTACH;
+
+    for (;;) {
+        switch (getopt(argc, argv, "d")) {
+            case 'd':
+                op = GLUSTERD_BRICK_TERMINATE;
+                break;
+            case -1:
+                goto done_parsing;
+            default:
+                return usage(argv[0]);
         }
+    }
 done_parsing:
-        if (optind != (argc - 2)) {
-                return usage (argv[0]);
-        }
+    if (optind != (argc - 2)) {
+        return usage(argv[0]);
+    }
 
-        fs = glfs_new ("gf-attach");
-        if (!fs) {
-                fprintf (stderr, "glfs_new failed\n");
-                return EXIT_FAILURE;
-        }
+    fs = glfs_new("gf-attach");
+    if (!fs) {
+        fprintf(stderr, "glfs_new failed\n");
+        return EXIT_FAILURE;
+    }
 
-        (void) glfs_set_logging (fs, "/dev/stderr", 7);
-        /*
-         * This will actually fail because we haven't defined a volume, but
-         * it will do enough initialization to get us going.
-         */
-        (void) glfs_init (fs);
+    (void)glfs_set_logging(fs, "/dev/stderr", 7);
+    /*
+     * This will actually fail because we haven't defined a volume, but
+     * it will do enough initialization to get us going.
+     */
+    (void)glfs_init(fs);
 
-        options = dict_new();
-        if (!options) {
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret != 0) {
-                fprintf (stderr, "failed to set transport type\n");
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport.address-family", "unix");
-        if (ret != 0) {
-                fprintf (stderr, "failed to set address family\n");
-                return EXIT_FAILURE;
-        }
-        ret = dict_set_str (options, "transport.socket.connect-path",
-                            argv[optind]);
-        if (ret != 0) {
-                fprintf (stderr, "failed to set connect path\n");
-                return EXIT_FAILURE;
-        }
+    options = dict_new();
+    if (!options) {
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret != 0) {
+        fprintf(stderr, "failed to set transport type\n");
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport.address-family", "unix");
+    if (ret != 0) {
+        fprintf(stderr, "failed to set address family\n");
+        return EXIT_FAILURE;
+    }
+    ret = dict_set_str(options, "transport.socket.connect-path", argv[optind]);
+    if (ret != 0) {
+        fprintf(stderr, "failed to set connect path\n");
+        return EXIT_FAILURE;
+    }
 
-        rpc = rpc_clnt_new (options, fs->ctx->master, "gf-attach-rpc", 0);
-        if (!rpc) {
-                fprintf (stderr, "rpc_clnt_new failed\n");
-                return EXIT_FAILURE;
-        }
+    rpc = rpc_clnt_new(options, fs->ctx->master, "gf-attach-rpc", 0);
+    if (!rpc) {
+        fprintf(stderr, "rpc_clnt_new failed\n");
+        return EXIT_FAILURE;
+    }
 
-        if (rpc_clnt_register_notify (rpc, NULL, NULL) != 0) {
-                fprintf (stderr, "rpc_clnt_register_notify failed\n");
-                return EXIT_FAILURE;
-        }
+    if (rpc_clnt_register_notify(rpc, NULL, NULL) != 0) {
+        fprintf(stderr, "rpc_clnt_register_notify failed\n");
+        return EXIT_FAILURE;
+    }
 
-        if (rpc_clnt_start(rpc) != 0) {
-                fprintf (stderr, "rpc_clnt_start failed\n");
-                return EXIT_FAILURE;
-        }
+    if (rpc_clnt_start(rpc) != 0) {
+        fprintf(stderr, "rpc_clnt_start failed\n");
+        return EXIT_FAILURE;
+    }
 
-        return send_brick_req (fs->ctx->master, rpc, argv[optind+1], op);
+    return send_brick_req(fs->ctx->master, rpc, argv[optind + 1], op);
 }
diff --git a/glusterfsd/src/glusterfsd-mgmt.c b/glusterfsd/src/glusterfsd-mgmt.c
index f7b1f367f97..88c9934e58e 100644
--- a/glusterfsd/src/glusterfsd-mgmt.c
+++ b/glusterfsd/src/glusterfsd-mgmt.c
@@ -38,2812 +38,2825 @@
 static gf_boolean_t is_mgmt_rpc_reconnect = _gf_false;
 int need_emancipate = 0;
 
-int glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx);
-int glusterfs_volfile_fetch (glusterfs_ctx_t *ctx);
-int glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp);
-int glusterfs_graph_unknown_options (glusterfs_graph_t *graph);
-int emancipate(glusterfs_ctx_t *ctx, int ret);
+int
+glusterfs_mgmt_pmap_signin(glusterfs_ctx_t *ctx);
+int
+glusterfs_volfile_fetch(glusterfs_ctx_t *ctx);
+int
+glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp);
+int
+glusterfs_graph_unknown_options(glusterfs_graph_t *graph);
+int
+emancipate(glusterfs_ctx_t *ctx, int ret);
 
 int
-mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = glusterfsd_ctx;
-        gf_log ("mgmt", GF_LOG_INFO, "Volume file changed");
+    ctx = glusterfsd_ctx;
+    gf_log("mgmt", GF_LOG_INFO, "Volume file changed");
 
-        glusterfs_volfile_fetch (ctx);
-        return 0;
+    glusterfs_volfile_fetch(ctx);
+    return 0;
 }
 
-
 int
-mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data)
+mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data)
 {
-        return 0;
+    return 0;
 }
 
 struct iobuf *
-glusterfs_serialize_reply (rpcsvc_request_t *req, void *arg,
-                           struct iovec *outmsg, xdrproc_t xdrproc)
+glusterfs_serialize_reply(rpcsvc_request_t *req, void *arg,
+                          struct iovec *outmsg, xdrproc_t xdrproc)
 {
-        struct iobuf            *iob = NULL;
-        ssize_t                  retlen = -1;
-        ssize_t                  xdr_size = 0;
-
-        /* First, get the io buffer into which the reply in arg will
-         * be serialized.
-         */
-        xdr_size = xdr_sizeof (xdrproc, arg);
-        iob = iobuf_get2 (req->svc->ctx->iobuf_pool, xdr_size);
-        if (!iob) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to get iobuf");
-                goto ret;
-        }
-
-        iobuf_to_iovec (iob, outmsg);
-        /* Use the given serializer to translate the give C structure in arg
-         * to XDR format which will be written into the buffer in outmsg.
-         */
-        /* retlen is used to received the error since size_t is unsigned and we
-         * need -1 for error notification during encoding.
-         */
-        retlen = xdr_serialize_generic (*outmsg, arg, xdrproc);
-        if (retlen == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to encode message");
-                goto ret;
-        }
-
-        outmsg->iov_len = retlen;
+    struct iobuf *iob = NULL;
+    ssize_t retlen = -1;
+    ssize_t xdr_size = 0;
+
+    /* First, get the io buffer into which the reply in arg will
+     * be serialized.
+     */
+    xdr_size = xdr_sizeof(xdrproc, arg);
+    iob = iobuf_get2(req->svc->ctx->iobuf_pool, xdr_size);
+    if (!iob) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to get iobuf");
+        goto ret;
+    }
+
+    iobuf_to_iovec(iob, outmsg);
+    /* Use the given serializer to translate the give C structure in arg
+     * to XDR format which will be written into the buffer in outmsg.
+     */
+    /* retlen is used to received the error since size_t is unsigned and we
+     * need -1 for error notification during encoding.
+     */
+    retlen = xdr_serialize_generic(*outmsg, arg, xdrproc);
+    if (retlen == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to encode message");
+        goto ret;
+    }
+
+    outmsg->iov_len = retlen;
 ret:
-        if (retlen == -1) {
-                iob = NULL;
-        }
+    if (retlen == -1) {
+        iob = NULL;
+    }
 
-        return iob;
+    return iob;
 }
 
 int
-glusterfs_submit_reply (rpcsvc_request_t *req, void *arg,
-                        struct iovec *payload, int payloadcount,
-                        struct iobref *iobref, xdrproc_t xdrproc)
+glusterfs_submit_reply(rpcsvc_request_t *req, void *arg, struct iovec *payload,
+                       int payloadcount, struct iobref *iobref,
+                       xdrproc_t xdrproc)
 {
-        struct iobuf           *iob        = NULL;
-        int                     ret        = -1;
-        struct iovec            rsp        = {0,};
-        char                    new_iobref = 0;
-
-        if (!req) {
-                GF_ASSERT (req);
-                goto out;
-        }
-
+    struct iobuf *iob = NULL;
+    int ret = -1;
+    struct iovec rsp = {
+        0,
+    };
+    char new_iobref = 0;
+
+    if (!req) {
+        GF_ASSERT(req);
+        goto out;
+    }
+
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "out of memory");
-                        goto out;
-                }
-
-                new_iobref = 1;
+            gf_log(THIS->name, GF_LOG_ERROR, "out of memory");
+            goto out;
         }
 
-        iob = glusterfs_serialize_reply (req, arg, &rsp, xdrproc);
-        if (!iob) {
-                gf_log_callingfn (THIS->name, GF_LOG_ERROR, "Failed to serialize reply");
-        } else {
-                iobref_add (iobref, iob);
-        }
+        new_iobref = 1;
+    }
 
-        ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount,
-                                     iobref);
+    iob = glusterfs_serialize_reply(req, arg, &rsp, xdrproc);
+    if (!iob) {
+        gf_log_callingfn(THIS->name, GF_LOG_ERROR, "Failed to serialize reply");
+    } else {
+        iobref_add(iobref, iob);
+    }
 
-        /* Now that we've done our job of handing the message to the RPC layer
-         * we can safely unref the iob in the hope that RPC layer must have
-         * ref'ed the iob on receiving into the txlist.
-         */
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Reply submission failed");
-                goto out;
-        }
+    ret = rpcsvc_submit_generic(req, &rsp, 1, payload, payloadcount, iobref);
 
-        ret = 0;
+    /* Now that we've done our job of handing the message to the RPC layer
+     * we can safely unref the iob in the hope that RPC layer must have
+     * ref'ed the iob on receiving into the txlist.
+     */
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Reply submission failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (iob)
-                iobuf_unref (iob);
+    if (iob)
+        iobuf_unref(iob);
 
-        if (new_iobref && iobref)
-                iobref_unref (iobref);
+    if (new_iobref && iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_terminate_response_send (rpcsvc_request_t *req, int op_ret)
+glusterfs_terminate_response_send(rpcsvc_request_t *req, int op_ret)
 {
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        dict_t                  *dict = NULL;
-        int                     ret = 0;
-
-        rsp.op_ret = op_ret;
-        rsp.op_errno = 0;
-        rsp.op_errstr = "";
-        dict = dict_new ();
-
-        if (dict)
-                ret = dict_allocate_and_serialize (dict, &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-
-        if (ret == 0)
-                ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                              (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    int ret = 0;
+
+    rsp.op_ret = op_ret;
+    rsp.op_errno = 0;
+    rsp.op_errstr = "";
+    dict = dict_new();
+
+    if (dict)
+        ret = dict_allocate_and_serialize(dict, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+
+    if (ret == 0)
+        ret = glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
-        GF_FREE (rsp.output.output_val);
-        if (dict)
-                dict_unref (dict);
-        return ret;
+    GF_FREE(rsp.output.output_val);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int
-glusterfs_handle_terminate (rpcsvc_request_t *req)
+glusterfs_handle_terminate(rpcsvc_request_t *req)
 {
-        gd1_mgmt_brick_op_req   xlator_req            = {0,};
-        ssize_t                 ret;
-        glusterfs_ctx_t         *ctx                  = NULL;
-        xlator_t                *top                  = NULL;
-        xlator_t                *victim               = NULL;
-        xlator_t                *tvictim              = NULL;
-        xlator_list_t           **trav_p              = NULL;
-        gf_boolean_t            lockflag              = _gf_false;
-        gf_boolean_t            still_bricks_attached = _gf_false;
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                return -1;
-        }
-        ctx = glusterfsd_ctx;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                /* Find the xlator_list_t that points to our victim. */
-                if (glusterfsd_ctx->active) {
-                        top = glusterfsd_ctx->active->first;
-                        for (trav_p = &top->children; *trav_p;
-                                                    trav_p = &(*trav_p)->next) {
-                                victim = (*trav_p)->xlator;
-                                if (!victim->cleanup_starting && strcmp (victim->name, xlator_req.name) == 0) {
-                                        break;
-                                }
-                        }
-                }
-
-                if (!top)
-                        goto err;
-
-        }
-        if (!*trav_p) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "can't terminate %s - not found",
-                          xlator_req.name);
-                /*
-                 * Used to be -ENOENT.  However, the caller asked us to
-                 * make sure it's down and if it's already down that's
-                 * good enough.
-                 */
-                glusterfs_terminate_response_send (req, 0);
-                goto err;
-        }
-
-        glusterfs_terminate_response_send (req, 0);
-        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
-                tvictim = (*trav_p)->xlator;
-                if (!tvictim->cleanup_starting &&
-                    !strcmp (tvictim->name, xlator_req.name)) {
-                        continue;
-                }
-                if (!tvictim->cleanup_starting) {
-                        still_bricks_attached = _gf_true;
-                        break;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    ssize_t ret;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *top = NULL;
+    xlator_t *victim = NULL;
+    xlator_t *tvictim = NULL;
+    xlator_list_t **trav_p = NULL;
+    gf_boolean_t lockflag = _gf_false;
+    gf_boolean_t still_bricks_attached = _gf_false;
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ctx = glusterfsd_ctx;
+
+    LOCK(&ctx->volfile_lock);
+    {
+        /* Find the xlator_list_t that points to our victim. */
+        if (glusterfsd_ctx->active) {
+            top = glusterfsd_ctx->active->first;
+            for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+                victim = (*trav_p)->xlator;
+                if (!victim->cleanup_starting &&
+                    strcmp(victim->name, xlator_req.name) == 0) {
+                    break;
                 }
+            }
         }
-        if (!still_bricks_attached) {
-                gf_log (THIS->name, GF_LOG_INFO,
-                        "terminating after loss of last child %s",
-                        xlator_req.name);
-                rpc_clnt_mgmt_pmap_signout (glusterfsd_ctx, xlator_req.name);
-                kill (getpid(), SIGTERM);
-        } else {
-                /* TODO cleanup sequence needs to be done properly for
-                   Quota and Changelog
-                */
-                if (victim->cleanup_starting)
-                        goto err;
-
-                rpc_clnt_mgmt_pmap_signout (glusterfsd_ctx, xlator_req.name);
-                victim->cleanup_starting = 1;
-
-                UNLOCK (&ctx->volfile_lock);
-                lockflag = _gf_true;
 
-                gf_log (THIS->name, GF_LOG_INFO, "detaching not-only"
-                         " child %s", xlator_req.name);
-                top->notify (top, GF_EVENT_CLEANUP, victim);
-
-        }
+        if (!top)
+            goto err;
+    }
+    if (!*trav_p) {
+        gf_log(THIS->name, GF_LOG_ERROR, "can't terminate %s - not found",
+               xlator_req.name);
+        /*
+         * Used to be -ENOENT.  However, the caller asked us to
+         * make sure it's down and if it's already down that's
+         * good enough.
+         */
+        glusterfs_terminate_response_send(req, 0);
+        goto err;
+    }
+
+    glusterfs_terminate_response_send(req, 0);
+    for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+        tvictim = (*trav_p)->xlator;
+        if (!tvictim->cleanup_starting &&
+            !strcmp(tvictim->name, xlator_req.name)) {
+            continue;
+        }
+        if (!tvictim->cleanup_starting) {
+            still_bricks_attached = _gf_true;
+            break;
+        }
+    }
+    if (!still_bricks_attached) {
+        gf_log(THIS->name, GF_LOG_INFO,
+               "terminating after loss of last child %s", xlator_req.name);
+        rpc_clnt_mgmt_pmap_signout(glusterfsd_ctx, xlator_req.name);
+        kill(getpid(), SIGTERM);
+    } else {
+        /* TODO cleanup sequence needs to be done properly for
+           Quota and Changelog
+        */
+        if (victim->cleanup_starting)
+            goto err;
+
+        rpc_clnt_mgmt_pmap_signout(glusterfsd_ctx, xlator_req.name);
+        victim->cleanup_starting = 1;
+
+        UNLOCK(&ctx->volfile_lock);
+        lockflag = _gf_true;
+
+        gf_log(THIS->name, GF_LOG_INFO,
+               "detaching not-only"
+               " child %s",
+               xlator_req.name);
+        top->notify(top, GF_EVENT_CLEANUP, victim);
+    }
 err:
-        if (!lockflag)
-                UNLOCK (&ctx->volfile_lock);
-        free (xlator_req.name);
-        xlator_req.name = NULL;
-        return 0;
+    if (!lockflag)
+        UNLOCK(&ctx->volfile_lock);
+    free(xlator_req.name);
+    xlator_req.name = NULL;
+    return 0;
 }
 
 int
-glusterfs_translator_info_response_send (rpcsvc_request_t *req, int ret,
-                                         char *msg, dict_t *output)
+glusterfs_translator_info_response_send(rpcsvc_request_t *req, int ret,
+                                        char *msg, dict_t *output)
 {
-        gd1_mgmt_brick_op_rsp    rsp = {0,};
-        gf_boolean_t             free_ptr = _gf_false;
-        GF_ASSERT (req);
-
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg && msg[0])
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        ret = -1;
-        if (output) {
-                ret = dict_allocate_and_serialize (output,
-                                                   &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-        }
-        if (!ret)
-                free_ptr = _gf_true;
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    gf_boolean_t free_ptr = _gf_false;
+    GF_ASSERT(req);
+
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg && msg[0])
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
-        if (free_ptr)
-                GF_FREE (rsp.output.output_val);
-        return ret;
+    ret = -1;
+    if (output) {
+        ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+    }
+    if (!ret)
+        free_ptr = _gf_true;
+
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
+    if (free_ptr)
+        GF_FREE(rsp.output.output_val);
+    return ret;
 }
 
 int
-glusterfs_xlator_op_response_send (rpcsvc_request_t *req, int op_ret,
-                                   char *msg, dict_t *output)
+glusterfs_xlator_op_response_send(rpcsvc_request_t *req, int op_ret, char *msg,
+                                  dict_t *output)
 {
-        gd1_mgmt_brick_op_rsp    rsp = {0,};
-        int                      ret = -1;
-        gf_boolean_t             free_ptr = _gf_false;
-        GF_ASSERT (req);
-
-        rsp.op_ret = op_ret;
-        rsp.op_errno = 0;
-        if (op_ret && msg && msg[0])
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    int ret = -1;
+    gf_boolean_t free_ptr = _gf_false;
+    GF_ASSERT(req);
+
+    rsp.op_ret = op_ret;
+    rsp.op_errno = 0;
+    if (op_ret && msg && msg[0])
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        if (output) {
-                ret = dict_allocate_and_serialize (output,
-                                                   &rsp.output.output_val,
-                                                   &rsp.output.output_len);
-        }
-        if (!ret)
-                free_ptr = _gf_true;
+    if (output) {
+        ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                          &rsp.output.output_len);
+    }
+    if (!ret)
+        free_ptr = _gf_true;
 
-        ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                     (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                                 (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
-        if (free_ptr)
-                GF_FREE (rsp.output.output_val);
+    if (free_ptr)
+        GF_FREE(rsp.output.output_val);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_handle_translator_info_get (rpcsvc_request_t *req)
+glusterfs_handle_translator_info_get(rpcsvc_request_t *req)
 {
-        int32_t                 ret     = -1;
-        gd1_mgmt_brick_op_req   xlator_req = {0,};
-        dict_t                  *dict    = NULL;
-        xlator_t                *this = NULL;
-        gf1_cli_top_op          top_op = 0;
-        uint32_t                blk_size = 0;
-        uint32_t                blk_count = 0;
-        double                  time = 0;
-        double                  throughput = 0;
-        xlator_t                *any = NULL;
-        xlator_t                *xlator = NULL;
-        glusterfs_graph_t       *active = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        char                    msg[2048] = {0,};
-        dict_t                  *output = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *this = NULL;
+    gf1_cli_top_op top_op = 0;
+    uint32_t blk_size = 0;
+    uint32_t blk_count = 0;
+    double time = 0;
+    double throughput = 0;
+    xlator_t *any = NULL;
+    xlator_t *xlator = NULL;
+    glusterfs_graph_t *active = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char msg[2048] = {
+        0,
+    };
+    dict_t *output = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_int32(dict, "top-op", (int32_t *)&top_op);
+    if ((!ret) &&
+        (GF_CLI_TOP_READ_PERF == top_op || GF_CLI_TOP_WRITE_PERF == top_op)) {
+        ret = dict_get_uint32(dict, "blk-size", &blk_size);
+        if (ret)
+            goto cont;
+        ret = dict_get_uint32(dict, "blk-cnt", &blk_count);
+        if (ret)
+            goto cont;
 
-        ret = dict_get_int32 (dict, "top-op", (int32_t *)&top_op);
-        if ((!ret) && (GF_CLI_TOP_READ_PERF == top_op ||
-            GF_CLI_TOP_WRITE_PERF == top_op)) {
-                ret = dict_get_uint32 (dict, "blk-size", &blk_size);
-                if (ret)
-                        goto cont;
-                ret = dict_get_uint32 (dict, "blk-cnt", &blk_count);
-                if (ret)
-                        goto cont;
-
-                if (GF_CLI_TOP_READ_PERF == top_op) {
-                        ret = glusterfs_volume_top_read_perf
-                                (blk_size, blk_count, xlator_req.name,
-                                 &throughput, &time);
-                } else if ( GF_CLI_TOP_WRITE_PERF == top_op) {
-                        ret = glusterfs_volume_top_write_perf
-                                (blk_size, blk_count, xlator_req.name,
-                                 &throughput, &time);
-                }
-                ret = dict_set_double (dict, "time", time);
-                if (ret)
-                        goto cont;
-                ret = dict_set_double (dict, "throughput", throughput);
-                if (ret)
-                        goto cont;
+        if (GF_CLI_TOP_READ_PERF == top_op) {
+            ret = glusterfs_volume_top_read_perf(
+                blk_size, blk_count, xlator_req.name, &throughput, &time);
+        } else if (GF_CLI_TOP_WRITE_PERF == top_op) {
+            ret = glusterfs_volume_top_write_perf(
+                blk_size, blk_count, xlator_req.name, &throughput, &time);
         }
+        ret = dict_set_double(dict, "time", time);
+        if (ret)
+            goto cont;
+        ret = dict_set_double(dict, "throughput", throughput);
+        if (ret)
+            goto cont;
+    }
 cont:
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        any = active->first;
-
-        xlator = get_xlator_by_name (any, xlator_req.name);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
-        }
-
-        /*
-         * Searching by name will only get us to the decompounder translator,
-         * but we really want io-stats.  Since we know the exact relationship
-         * between these two, it's easy to get from one to the other.
-         *
-         * TBD: should this even be notify, or something else?
-         */
-        xlator = FIRST_CHILD(xlator);
-
-        output = dict_new ();
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_INFO, dict, output);
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    any = active->first;
+
+    xlator = get_xlator_by_name(any, xlator_req.name);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
+
+    /*
+     * Searching by name will only get us to the decompounder translator,
+     * but we really want io-stats.  Since we know the exact relationship
+     * between these two, it's easy to get from one to the other.
+     *
+     * TBD: should this even be notify, or something else?
+     */
+    xlator = FIRST_CHILD(xlator);
+
+    output = dict_new();
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_INFO, dict, output);
 
 out:
-        ret = glusterfs_translator_info_response_send (req, ret, msg, output);
-
-        free (xlator_req.name);
-        free (xlator_req.input.input_val);
-        if (output)
-                dict_unref (output);
-        if (dict)
-                dict_unref (dict);
-        return ret;
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
+
+    free(xlator_req.name);
+    free(xlator_req.input.input_val);
+    if (output)
+        dict_unref(output);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int
-glusterfs_volume_top_write_perf (uint32_t blk_size, uint32_t blk_count,
-                                 char *brick_path, double *throughput,
-                                 double *time)
+glusterfs_volume_top_write_perf(uint32_t blk_size, uint32_t blk_count,
+                                char *brick_path, double *throughput,
+                                double *time)
 {
-        int32_t                 fd = -1;
-        int32_t                 input_fd = -1;
-        char                    export_path[PATH_MAX] = {0,};
-        char                    *buf = NULL;
-        int32_t                 iter = 0;
-        int32_t                 ret = -1;
-        uint64_t                total_blks = 0;
-        struct timeval          begin, end = {0,};
-
-        GF_ASSERT (brick_path);
-        GF_ASSERT (throughput);
-        GF_ASSERT (time);
-        if (!(blk_size > 0) || ! (blk_count > 0))
-                goto out;
-
-        snprintf (export_path, sizeof (export_path), "%s/%s",
-                  brick_path, ".gf-tmp-stats-perf");
-
-        fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU);
-        if (-1 == fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open tmp file");
-                goto out;
-        }
-
-        buf = GF_MALLOC (blk_size * sizeof(*buf), gf_common_mt_char);
-        if (!buf) {
-                ret = -1;
-                goto out;
-        }
+    int32_t fd = -1;
+    int32_t input_fd = -1;
+    char export_path[PATH_MAX] = {
+        0,
+    };
+    char *buf = NULL;
+    int32_t iter = 0;
+    int32_t ret = -1;
+    uint64_t total_blks = 0;
+    struct timeval begin, end = {
+                              0,
+                          };
+
+    GF_ASSERT(brick_path);
+    GF_ASSERT(throughput);
+    GF_ASSERT(time);
+    if (!(blk_size > 0) || !(blk_count > 0))
+        goto out;
+
+    snprintf(export_path, sizeof(export_path), "%s/%s", brick_path,
+             ".gf-tmp-stats-perf");
+
+    fd = open(export_path, O_CREAT | O_RDWR, S_IRWXU);
+    if (-1 == fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open tmp file");
+        goto out;
+    }
 
-        input_fd = open ("/dev/zero", O_RDONLY);
-        if (-1 == input_fd) {
-                ret = -1;
-                gf_log ("glusterd",GF_LOG_ERROR, "Unable to open input file");
-                goto out;
-        }
+    buf = GF_MALLOC(blk_size * sizeof(*buf), gf_common_mt_char);
+    if (!buf) {
+        ret = -1;
+        goto out;
+    }
 
-        gettimeofday (&begin, NULL);
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (input_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                total_blks += ret;
-        }
-        ret = 0;
-        if (total_blks != ((uint64_t)blk_size * blk_count)) {
-                gf_log ("glusterd", GF_LOG_WARNING, "Error in write");
-                ret = -1;
-                goto out;
-        }
+    input_fd = open("/dev/zero", O_RDONLY);
+    if (-1 == input_fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Unable to open input file");
+        goto out;
+    }
+
+    gettimeofday(&begin, NULL);
+    for (iter = 0; iter < blk_count; iter++) {
+        ret = sys_read(input_fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        ret = sys_write(fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        total_blks += ret;
+    }
+    ret = 0;
+    if (total_blks != ((uint64_t)blk_size * blk_count)) {
+        gf_log("glusterd", GF_LOG_WARNING, "Error in write");
+        ret = -1;
+        goto out;
+    }
 
-        gettimeofday (&end, NULL);
-        *time = (end.tv_sec - begin.tv_sec) * 1e6
-                     + (end.tv_usec - begin.tv_usec);
-        *throughput = total_blks / *time;
-        gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs "
-                "bytes written %"PRId64, *throughput, *time, total_blks);
+    gettimeofday(&end, NULL);
+    *time = (end.tv_sec - begin.tv_sec) * 1e6 + (end.tv_usec - begin.tv_usec);
+    *throughput = total_blks / *time;
+    gf_log("glusterd", GF_LOG_INFO,
+           "Throughput %.2f Mbps time %.2f secs "
+           "bytes written %" PRId64,
+           *throughput, *time, total_blks);
 
 out:
-        if (fd >= 0)
-                sys_close (fd);
-        if (input_fd >= 0)
-                sys_close (input_fd);
-        GF_FREE (buf);
-        sys_unlink (export_path);
-
-        return ret;
+    if (fd >= 0)
+        sys_close(fd);
+    if (input_fd >= 0)
+        sys_close(input_fd);
+    GF_FREE(buf);
+    sys_unlink(export_path);
+
+    return ret;
 }
 
 int
-glusterfs_volume_top_read_perf (uint32_t blk_size, uint32_t blk_count,
-                                char *brick_path, double *throughput,
-                                double *time)
+glusterfs_volume_top_read_perf(uint32_t blk_size, uint32_t blk_count,
+                               char *brick_path, double *throughput,
+                               double *time)
 {
-        int32_t                 fd = -1;
-        int32_t                 input_fd = -1;
-        int32_t                 output_fd = -1;
-        char                    export_path[PATH_MAX] = {0,};
-        char                    *buf = NULL;
-        int32_t                 iter = 0;
-        int32_t                 ret = -1;
-        uint64_t                total_blks = 0;
-        struct timeval          begin, end = {0,};
-
-        GF_ASSERT (brick_path);
-        GF_ASSERT (throughput);
-        GF_ASSERT (time);
-        if (!(blk_size > 0) || ! (blk_count > 0))
-                goto out;
-
-        snprintf (export_path, sizeof (export_path), "%s/%s",
-                  brick_path, ".gf-tmp-stats-perf");
-        fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU);
-        if (-1 == fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open tmp file");
-                goto out;
-        }
-
-        buf = GF_MALLOC (blk_size * sizeof(*buf), gf_common_mt_char);
-        if (!buf) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not allocate memory");
-                goto out;
-        }
-
-        input_fd = open ("/dev/zero", O_RDONLY);
-        if (-1 == input_fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open input file");
-                goto out;
-        }
-
-        output_fd = open ("/dev/null", O_RDWR);
-        if (-1 == output_fd) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_ERROR, "Could not open output file");
-                goto out;
-        }
+    int32_t fd = -1;
+    int32_t input_fd = -1;
+    int32_t output_fd = -1;
+    char export_path[PATH_MAX] = {
+        0,
+    };
+    char *buf = NULL;
+    int32_t iter = 0;
+    int32_t ret = -1;
+    uint64_t total_blks = 0;
+    struct timeval begin, end = {
+                              0,
+                          };
+
+    GF_ASSERT(brick_path);
+    GF_ASSERT(throughput);
+    GF_ASSERT(time);
+    if (!(blk_size > 0) || !(blk_count > 0))
+        goto out;
+
+    snprintf(export_path, sizeof(export_path), "%s/%s", brick_path,
+             ".gf-tmp-stats-perf");
+    fd = open(export_path, O_CREAT | O_RDWR, S_IRWXU);
+    if (-1 == fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open tmp file");
+        goto out;
+    }
 
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (input_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-        }
+    buf = GF_MALLOC(blk_size * sizeof(*buf), gf_common_mt_char);
+    if (!buf) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not allocate memory");
+        goto out;
+    }
 
-        ret = sys_fsync (fd);
-        if (ret) {
-                gf_log ("glusterd", GF_LOG_ERROR, "could not flush cache");
-                goto out;
-        }
-        ret = sys_lseek (fd, 0L, 0);
-        if (ret != 0) {
-                gf_log ("glusterd", GF_LOG_ERROR,
-                        "could not seek back to start");
-                ret = -1;
-                goto out;
-        }
-        gettimeofday (&begin, NULL);
-        for (iter = 0; iter < blk_count; iter++) {
-                ret = sys_read (fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = sys_write (output_fd, buf, blk_size);
-                if (ret != blk_size) {
-                        ret = -1;
-                        goto out;
-                }
-                total_blks += ret;
-        }
-        ret = 0;
-        if (total_blks != ((uint64_t)blk_size * blk_count)) {
-                ret = -1;
-                gf_log ("glusterd", GF_LOG_WARNING, "Error in read");
-                goto out;
-        }
+    input_fd = open("/dev/zero", O_RDONLY);
+    if (-1 == input_fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open input file");
+        goto out;
+    }
 
-        gettimeofday (&end, NULL);
-        *time = (end.tv_sec - begin.tv_sec) * 1e6
-                + (end.tv_usec - begin.tv_usec);
-        *throughput = total_blks / *time;
-        gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs "
-                "bytes read %"PRId64, *throughput, *time, total_blks);
+    output_fd = open("/dev/null", O_RDWR);
+    if (-1 == output_fd) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_ERROR, "Could not open output file");
+        goto out;
+    }
+
+    for (iter = 0; iter < blk_count; iter++) {
+        ret = sys_read(input_fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        ret = sys_write(fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+    }
+
+    ret = sys_fsync(fd);
+    if (ret) {
+        gf_log("glusterd", GF_LOG_ERROR, "could not flush cache");
+        goto out;
+    }
+    ret = sys_lseek(fd, 0L, 0);
+    if (ret != 0) {
+        gf_log("glusterd", GF_LOG_ERROR, "could not seek back to start");
+        ret = -1;
+        goto out;
+    }
+    gettimeofday(&begin, NULL);
+    for (iter = 0; iter < blk_count; iter++) {
+        ret = sys_read(fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        ret = sys_write(output_fd, buf, blk_size);
+        if (ret != blk_size) {
+            ret = -1;
+            goto out;
+        }
+        total_blks += ret;
+    }
+    ret = 0;
+    if (total_blks != ((uint64_t)blk_size * blk_count)) {
+        ret = -1;
+        gf_log("glusterd", GF_LOG_WARNING, "Error in read");
+        goto out;
+    }
+
+    gettimeofday(&end, NULL);
+    *time = (end.tv_sec - begin.tv_sec) * 1e6 + (end.tv_usec - begin.tv_usec);
+    *throughput = total_blks / *time;
+    gf_log("glusterd", GF_LOG_INFO,
+           "Throughput %.2f Mbps time %.2f secs "
+           "bytes read %" PRId64,
+           *throughput, *time, total_blks);
 
 out:
-        if (fd >= 0)
-                sys_close (fd);
-        if (input_fd >= 0)
-                sys_close (input_fd);
-        if (output_fd >= 0)
-                sys_close (output_fd);
-        GF_FREE (buf);
-        sys_unlink (export_path);
-
-        return ret;
+    if (fd >= 0)
+        sys_close(fd);
+    if (input_fd >= 0)
+        sys_close(input_fd);
+    if (output_fd >= 0)
+        sys_close(output_fd);
+    GF_FREE(buf);
+    sys_unlink(export_path);
+
+    return ret;
 }
 
 int
-glusterfs_handle_translator_op (rpcsvc_request_t *req)
+glusterfs_handle_translator_op(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        int32_t                  op_ret  = 0;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *input    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     key[2048] = {0};
-        char                    *xname = NULL;
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-        int                      i = 0;
-        int                      count = 0;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        active = ctx->active;
-        if (!active) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, EAGAIN, glusterfsd_msg_38,
-                        "Not processing brick-op no. %d since volume graph is "
-                        "not yet active.", xlator_req.op);
-                goto out;
-        }
-        any = active->first;
-        input = dict_new ();
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &input);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        } else {
-                input->extra_stdfree = xlator_req.input.input_val;
-        }
-
-        ret = dict_get_int32 (input, "count", &count);
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
+    int32_t ret = -1;
+    int32_t op_ret = 0;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *input = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char key[2048] = {0};
+    char *xname = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+    int i = 0;
+    int count = 0;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    active = ctx->active;
+    if (!active) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, EAGAIN, glusterfsd_msg_38,
+               "Not processing brick-op no. %d since volume graph is "
+               "not yet active.",
+               xlator_req.op);
+        goto out;
+    }
+    any = active->first;
+    input = dict_new();
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &input);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    } else {
+        input->extra_stdfree = xlator_req.input.input_val;
+    }
+
+    ret = dict_get_int32(input, "count", &count);
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0; i < count; i++)  {
-                snprintf (key, sizeof (key), "xl-%d", i);
-                ret = dict_get_str (input, key, &xname);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "Couldn't get "
-                                "xlator %s ", key);
-                        goto out;
-                }
-                xlator = xlator_search_by_name (any, xname);
-                if (!xlator) {
-                        gf_log (this->name, GF_LOG_ERROR, "xlator %s is not "
-                                "loaded", xname);
-                        goto out;
-                }
-        }
-        for (i = 0; i < count; i++)  {
-                snprintf (key, sizeof (key), "xl-%d", i);
-                ret = dict_get_str (input, key, &xname);
-                xlator = xlator_search_by_name (any, xname);
-                XLATOR_NOTIFY (ret, xlator, GF_EVENT_TRANSLATOR_OP, input, output);
-                /* If notify fails for an xlator we need to capture it but
-                 * continue with the loop. */
-                if (ret)
-                        op_ret = -1;
+    for (i = 0; i < count; i++) {
+        snprintf(key, sizeof(key), "xl-%d", i);
+        ret = dict_get_str(input, key, &xname);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Couldn't get "
+                   "xlator %s ",
+                   key);
+            goto out;
         }
-        ret = op_ret;
+        xlator = xlator_search_by_name(any, xname);
+        if (!xlator) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "xlator %s is not "
+                   "loaded",
+                   xname);
+            goto out;
+        }
+    }
+    for (i = 0; i < count; i++) {
+        snprintf(key, sizeof(key), "xl-%d", i);
+        ret = dict_get_str(input, key, &xname);
+        xlator = xlator_search_by_name(any, xname);
+        XLATOR_NOTIFY(ret, xlator, GF_EVENT_TRANSLATOR_OP, input, output);
+        /* If notify fails for an xlator we need to capture it but
+         * continue with the loop. */
+        if (ret)
+            op_ret = -1;
+    }
+    ret = op_ret;
 out:
-        glusterfs_xlator_op_response_send (req, ret, "", output);
-        if (input)
-                dict_unref (input);
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
-
-        return 0;
+    glusterfs_xlator_op_response_send(req, ret, "", output);
+    if (input)
+        dict_unref(input);
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return 0;
 }
 
 int
-glusterfs_handle_bitrot (rpcsvc_request_t *req)
+glusterfs_handle_bitrot(rpcsvc_request_t *req)
 {
-        int32_t                  ret          = -1;
-        gd1_mgmt_brick_op_req    xlator_req   = {0,};
-        dict_t                   *input       = NULL;
-        dict_t                   *output      = NULL;
-        xlator_t                 *any         = NULL;
-        xlator_t                 *this        = NULL;
-        xlator_t                 *xlator      = NULL;
-        char                     msg[2048]    = {0,};
-        char                     xname[1024]  = {0,};
-        glusterfs_ctx_t          *ctx         = NULL;
-        glusterfs_graph_t        *active      = NULL;
-        char                     *scrub_opt   = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-
-        if (ret < 0) {
-                /*failed to decode msg;*/
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        any = active->first;
-
-        input = dict_new ();
-        if (!input)
-                goto out;
-
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &input);
-
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_35,
-                        "rpc req buffer unserialization failed.");
-                goto out;
-        }
-
-        /* Send scrubber request to bitrot xlator */
-        snprintf (xname, sizeof (xname), "%s-bit-rot-0", xlator_req.name);
-        xlator = xlator_search_by_name (any, xname);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded", xname);
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_36,
-                        "problem in xlator loading.");
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_get_str (input, "scrub-value", &scrub_opt);
-        if (ret) {
-                snprintf (msg, sizeof (msg), "Failed to get scrub value");
-                gf_msg (this->name, GF_LOG_ERROR, 0, glusterfsd_msg_37,
-                        "failed to get dict value");
-                ret = -1;
-                goto out;
-        }
-
-        if (!strncmp (scrub_opt, "status", SLEN ("status"))) {
-                ret = xlator->notify (xlator, GF_EVENT_SCRUB_STATUS, input,
-                                      output);
-        } else if (!strncmp (scrub_opt, "ondemand", SLEN ("ondemand"))) {
-                ret = xlator->notify (xlator, GF_EVENT_SCRUB_ONDEMAND, input,
-                                      output);
-                if (ret == -2) {
-                        snprintf (msg, sizeof (msg), "Scrubber is in "
-                                  "Pause/Inactive/Running state");
-                        ret = -1;
-                        goto out;
-                }
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *input = NULL;
+    dict_t *output = NULL;
+    xlator_t *any = NULL;
+    xlator_t *this = NULL;
+    xlator_t *xlator = NULL;
+    char msg[2048] = {
+        0,
+    };
+    char xname[1024] = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    char *scrub_opt = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+
+    input = dict_new();
+    if (!input)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &input);
+
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_35,
+               "rpc req buffer unserialization failed.");
+        goto out;
+    }
+
+    /* Send scrubber request to bitrot xlator */
+    snprintf(xname, sizeof(xname), "%s-bit-rot-0", xlator_req.name);
+    xlator = xlator_search_by_name(any, xname);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xname);
+        gf_msg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_36,
+               "problem in xlator loading.");
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_str(input, "scrub-value", &scrub_opt);
+    if (ret) {
+        snprintf(msg, sizeof(msg), "Failed to get scrub value");
+        gf_msg(this->name, GF_LOG_ERROR, 0, glusterfsd_msg_37,
+               "failed to get dict value");
+        ret = -1;
+        goto out;
+    }
+
+    if (!strncmp(scrub_opt, "status", SLEN("status"))) {
+        ret = xlator->notify(xlator, GF_EVENT_SCRUB_STATUS, input, output);
+    } else if (!strncmp(scrub_opt, "ondemand", SLEN("ondemand"))) {
+        ret = xlator->notify(xlator, GF_EVENT_SCRUB_ONDEMAND, input, output);
+        if (ret == -2) {
+            snprintf(msg, sizeof(msg),
+                     "Scrubber is in "
+                     "Pause/Inactive/Running state");
+            ret = -1;
+            goto out;
+        }
+    }
 out:
-        glusterfs_translator_info_response_send (req, ret, msg, output);
+    glusterfs_translator_info_response_send(req, ret, msg, output);
 
-        if (input)
-                dict_unref (input);
-        free (xlator_req.input.input_val); /*malloced by xdr*/
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name);
+    if (input)
+        dict_unref(input);
+    free(xlator_req.input.input_val); /*malloced by xdr*/
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_handle_attach (rpcsvc_request_t *req)
+glusterfs_handle_attach(rpcsvc_request_t *req)
 {
-        int32_t                 ret             = -1;
-        gd1_mgmt_brick_op_req   xlator_req      = {0,};
-        xlator_t                *this           = NULL;
-        xlator_t                *nextchild      = NULL;
-        glusterfs_graph_t       *newgraph       = NULL;
-        glusterfs_ctx_t         *ctx            = NULL;
-        xlator_t                *srv_xl         = NULL;
-        server_conf_t           *srv_conf       = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ctx = this->ctx;
-        if (!ctx->cmd_args.volfile_id) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "No volfile-id provided, erroring out");
-                return -1;
-        }
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-
-        if (ret < 0) {
-                /*failed to decode msg;*/
-                req->rpc_err = GARBAGE_ARGS;
-                return -1;
-        }
-        ret = 0;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                if (this->ctx->active) {
-                        gf_log (this->name, GF_LOG_INFO,
-                                "got attach for %s", xlator_req.name);
-                        ret = glusterfs_graph_attach (this->ctx->active,
-                                              xlator_req.name, &newgraph);
-                        if (!ret && (newgraph && newgraph->first)) {
-                                nextchild = newgraph->first;
-                                ret = xlator_notify (nextchild,
-                                                     GF_EVENT_PARENT_UP,
-                                                     nextchild);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                0,
-                                                LG_MSG_EVENT_NOTIFY_FAILED,
-                                                "Parent up notification "
-                                                "failed for %s ",
-                                                nextchild->name);
-                                        goto out;
-                                }
-                                /* we need a protocol/server xlator as
-                                 * nextchild
-                                 */
-                                srv_xl = this->ctx->active->first;
-                                srv_conf = (server_conf_t *)srv_xl->private;
-                                rpcsvc_autoscale_threads (this->ctx,
-                                                          srv_conf->rpc, 1);
-                        }
-                } else {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "got attach for %s but no active graph",
-                                xlator_req.name);
-                }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    xlator_t *this = NULL;
+    xlator_t *nextchild = NULL;
+    glusterfs_graph_t *newgraph = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *srv_xl = NULL;
+    server_conf_t *srv_conf = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = this->ctx;
+    if (!ctx->cmd_args.volfile_id) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "No volfile-id provided, erroring out");
+        return -1;
+    }
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ret = 0;
+
+    LOCK(&ctx->volfile_lock);
+    {
+        if (this->ctx->active) {
+            gf_log(this->name, GF_LOG_INFO, "got attach for %s",
+                   xlator_req.name);
+            ret = glusterfs_graph_attach(this->ctx->active, xlator_req.name,
+                                         &newgraph);
+            if (!ret && (newgraph && newgraph->first)) {
+                nextchild = newgraph->first;
+                ret = xlator_notify(nextchild, GF_EVENT_PARENT_UP, nextchild);
                 if (ret) {
-                        ret = -1;
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           LG_MSG_EVENT_NOTIFY_FAILED,
+                           "Parent up notification "
+                           "failed for %s ",
+                           nextchild->name);
+                    goto out;
                 }
+                /* we need a protocol/server xlator as
+                 * nextchild
+                 */
+                srv_xl = this->ctx->active->first;
+                srv_conf = (server_conf_t *)srv_xl->private;
+                rpcsvc_autoscale_threads(this->ctx, srv_conf->rpc, 1);
+            }
+        } else {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "got attach for %s but no active graph", xlator_req.name);
+        }
+        if (ret) {
+            ret = -1;
+        }
 
-                glusterfs_translator_info_response_send (req, ret, NULL, NULL);
+        glusterfs_translator_info_response_send(req, ret, NULL, NULL);
 
-out:
-                UNLOCK (&ctx->volfile_lock);
-        }
-        free (xlator_req.input.input_val);
-        free (xlator_req.name);
+    out:
+        UNLOCK(&ctx->volfile_lock);
+    }
+    free(xlator_req.input.input_val);
+    free(xlator_req.name);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_handle_dump_metrics (rpcsvc_request_t *req)
+glusterfs_handle_dump_metrics(rpcsvc_request_t *req)
 {
-        int32_t                 ret             = -1;
-        gd1_mgmt_brick_op_req   xlator_req      = {0,};
-        xlator_t                *this           = NULL;
-        glusterfs_ctx_t         *ctx            = NULL;
-        char  *filepath = NULL;
-        int    fd  = -1;
-        struct stat statbuf = {0,};
-        char *msg = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-
-        if (ret < 0) {
-                /*failed to decode msg;*/
-                req->rpc_err = GARBAGE_ARGS;
-                return -1;
-        }
-        ret = -1;
-        ctx = this->ctx;
-
-        /* Infra for monitoring */
-        filepath = gf_monitor_metrics (ctx);
-        if (!filepath)
-                goto out;
-
-        fd = sys_open (filepath, O_RDONLY, 0);
-        if (fd < 0)
-                goto out;
-
-        if (sys_fstat (fd, &statbuf) < 0)
-                goto out;
-
-        if (statbuf.st_size > GF_UNIT_MB) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        LG_MSG_NO_MEMORY,
-                        "Allocated size exceeds expectation: "
-                        "reconsider logic (%"GF_PRI_SIZET")",
-                        statbuf.st_size);
-        }
-        msg = GF_CALLOC (1, (statbuf.st_size + 1), gf_common_mt_char);
-        if (!msg)
-                goto out;
-
-        ret = sys_read (fd, msg, statbuf.st_size);
-        if (ret < 0)
-                goto out;
-
-        /* Send all the data in errstr, instead of dictionary for now */
-        glusterfs_translator_info_response_send (req, 0, msg, NULL);
-
-        ret = 0;
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char *filepath = NULL;
+    int fd = -1;
+    struct stat statbuf = {
+        0,
+    };
+    char *msg = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+
+    if (ret < 0) {
+        /*failed to decode msg;*/
+        req->rpc_err = GARBAGE_ARGS;
+        return -1;
+    }
+    ret = -1;
+    ctx = this->ctx;
+
+    /* Infra for monitoring */
+    filepath = gf_monitor_metrics(ctx);
+    if (!filepath)
+        goto out;
+
+    fd = sys_open(filepath, O_RDONLY, 0);
+    if (fd < 0)
+        goto out;
+
+    if (sys_fstat(fd, &statbuf) < 0)
+        goto out;
+
+    if (statbuf.st_size > GF_UNIT_MB) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+               "Allocated size exceeds expectation: "
+               "reconsider logic (%" GF_PRI_SIZET ")",
+               statbuf.st_size);
+    }
+    msg = GF_CALLOC(1, (statbuf.st_size + 1), gf_common_mt_char);
+    if (!msg)
+        goto out;
+
+    ret = sys_read(fd, msg, statbuf.st_size);
+    if (ret < 0)
+        goto out;
+
+    /* Send all the data in errstr, instead of dictionary for now */
+    glusterfs_translator_info_response_send(req, 0, msg, NULL);
+
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        GF_FREE (msg);
-        GF_FREE (filepath);
+    GF_FREE(msg);
+    GF_FREE(filepath);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_handle_defrag (rpcsvc_request_t *req)
+glusterfs_handle_defrag(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *dict    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     msg[2048] = {0};
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        any = active->first;
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
-        xlator = xlator_search_by_name (any, xlator_req.name);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char msg[2048] = {0};
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+    xlator = xlator_search_by_name(any, xlator_req.name);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xlator->notify (xlator, GF_EVENT_VOLUME_DEFRAG, dict, output);
+    ret = xlator->notify(xlator, GF_EVENT_VOLUME_DEFRAG, dict, output);
 
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
 out:
-        if (dict)
-                dict_unref (dict);
-        free (xlator_req.input.input_val); // malloced by xdr
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
-
-        return ret;
-
+    if (dict)
+        dict_unref(dict);
+    free(xlator_req.input.input_val);  // malloced by xdr
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return ret;
 }
 int
-glusterfs_handle_brick_status (rpcsvc_request_t *req)
+glusterfs_handle_brick_status(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   brick_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *this = NULL;
-        xlator_t                *server_xl = NULL;
-        xlator_t                *brick_xl = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *output = NULL;
-        char                    *xname = NULL;
-        uint32_t                cmd = 0;
-        char                    *msg = NULL;
-        char                    *brickname = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ret = xdr_to_generic (req->msg[0], &brick_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (brick_req.input.input_val,
-                                brick_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "req-buffer to dictionary");
-                goto out;
-        }
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Couldn't get status op");
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req brick_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+    xlator_t *server_xl = NULL;
+    xlator_t *brick_xl = NULL;
+    dict_t *dict = NULL;
+    dict_t *output = NULL;
+    char *xname = NULL;
+    uint32_t cmd = 0;
+    char *msg = NULL;
+    char *brickname = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ret = xdr_to_generic(req->msg[0], &brick_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(brick_req.input.input_val, brick_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "req-buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Couldn't get status op");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "brick-name", &brickname);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Couldn't get brickname from"
+               " dict");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    if (ctx == NULL) {
+        gf_log(this->name, GF_LOG_ERROR, "ctx returned NULL");
+        ret = -1;
+        goto out;
+    }
+    if (ctx->active == NULL) {
+        gf_log(this->name, GF_LOG_ERROR, "ctx->active returned NULL");
+        ret = -1;
+        goto out;
+    }
+    active = ctx->active;
+    if (ctx->active->first == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "ctx->active->first "
+               "returned NULL");
+        ret = -1;
+        goto out;
+    }
+    server_xl = active->first;
 
-        ret = dict_get_str (dict, "brick-name", &brickname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Couldn't get brickname from"
-                        " dict");
-                goto out;
-        }
+    brick_xl = get_xlator_by_name(server_xl, brickname);
+    if (!brick_xl) {
+        gf_log(this->name, GF_LOG_ERROR, "xlator %s is not loaded", xname);
+        ret = -1;
+        goto out;
+    }
+
+    output = dict_new();
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            ret = 0;
+            gf_proc_dump_mem_info_to_dict(output);
+            gf_proc_dump_mempool_info_to_dict(ctx, output);
+            break;
+
+        case GF_CLI_STATUS_CLIENTS:
+        case GF_CLI_STATUS_CLIENT_LIST:
+            ret = server_xl->dumpops->priv_to_dict(server_xl, output,
+                                                   brickname);
+            break;
+
+        case GF_CLI_STATUS_INODE:
+            ret = server_xl->dumpops->inode_to_dict(brick_xl, output);
+            break;
+
+        case GF_CLI_STATUS_FD:
+            ret = server_xl->dumpops->fd_to_dict(brick_xl, output);
+            break;
+
+        case GF_CLI_STATUS_CALLPOOL:
+            ret = 0;
+            gf_proc_dump_pending_frames_to_dict(ctx->pool, output);
+            break;
 
-        ctx = glusterfsd_ctx;
-        if (ctx == NULL) {
-                gf_log (this->name, GF_LOG_ERROR, "ctx returned NULL");
-                ret = -1;
-                goto out;
-        }
-        if (ctx->active == NULL) {
-                gf_log (this->name, GF_LOG_ERROR, "ctx->active returned NULL");
-                ret = -1;
-                goto out;
-        }
-        active = ctx->active;
-        if (ctx->active->first == NULL) {
-                gf_log (this->name, GF_LOG_ERROR, "ctx->active->first "
-                        "returned NULL");
-                ret = -1;
-                goto out;
-        }
-        server_xl = active->first;
+        default:
+            ret = -1;
+            msg = gf_strdup("Unknown status op");
+            break;
+    }
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg)
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        brick_xl = get_xlator_by_name (server_xl, brickname);
-        if (!brick_xl) {
-                gf_log (this->name, GF_LOG_ERROR, "xlator %s is not loaded",
-                        xname);
-                ret = -1;
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        output = dict_new ();
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        ret = 0;
-                        gf_proc_dump_mem_info_to_dict (output);
-                        gf_proc_dump_mempool_info_to_dict (ctx, output);
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                case GF_CLI_STATUS_CLIENT_LIST:
-                        ret = server_xl->dumpops->priv_to_dict (server_xl,
-                                        output, brickname);
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        ret = server_xl->dumpops->inode_to_dict (brick_xl,
-                                                                 output);
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        ret = server_xl->dumpops->fd_to_dict (brick_xl, output);
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        ret = 0;
-                        gf_proc_dump_pending_frames_to_dict (ctx->pool, output);
-                        break;
-
-                default:
-                        ret = -1;
-                        msg = gf_strdup ("Unknown status op");
-                        break;
-        }
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg)
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
-
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
-
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        if (output)
-                dict_unref (output);
-        free (brick_req.input.input_val);
-        GF_FREE (xname);
-        GF_FREE (msg);
-        GF_FREE (rsp.output.output_val);
-
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    if (output)
+        dict_unref(output);
+    free(brick_req.input.input_val);
+    GF_FREE(xname);
+    GF_FREE(msg);
+    GF_FREE(rsp.output.output_val);
+
+    return ret;
 }
 
-
 int
-glusterfs_handle_node_status (rpcsvc_request_t *req)
+glusterfs_handle_node_status(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   node_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *any = NULL;
-        xlator_t                *node = NULL;
-        xlator_t                *subvol = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *output = NULL;
-        char                    *volname = NULL;
-        char                    *node_name = NULL;
-        char                    *subvol_name = NULL;
-        uint32_t                cmd = 0;
-        char                    *msg = NULL;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic (req->msg[0], &node_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (node_req.input.input_val,
-                                node_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "req buffer to dictionary");
-                goto out;
-        }
-
-        ret = dict_get_uint32 (dict, "cmd", &cmd);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get status op");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req node_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *any = NULL;
+    xlator_t *node = NULL;
+    xlator_t *subvol = NULL;
+    dict_t *dict = NULL;
+    dict_t *output = NULL;
+    char *volname = NULL;
+    char *node_name = NULL;
+    char *subvol_name = NULL;
+    uint32_t cmd = 0;
+    char *msg = NULL;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &node_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(node_req.input.input_val, node_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "req buffer to dictionary");
+        goto out;
+    }
+
+    ret = dict_get_uint32(dict, "cmd", &cmd);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get status op");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get volname");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    any = active->first;
+
+    if ((cmd & GF_CLI_STATUS_NFS) != 0)
+        ret = gf_asprintf(&node_name, "%s", "nfs-server");
+    else if ((cmd & GF_CLI_STATUS_SHD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "glustershd");
+    else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "quotad");
+    else if ((cmd & GF_CLI_STATUS_BITD) != 0)
+        ret = gf_asprintf(&node_name, "%s", "bitd");
+    else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
+        ret = gf_asprintf(&node_name, "%s", "scrubber");
+
+    else {
+        ret = -1;
+        goto out;
+    }
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to set node xlator name");
+        goto out;
+    }
+
+    node = xlator_search_by_name(any, node_name);
+    if (!node) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded", node_name);
+        goto out;
+    }
+
+    if ((cmd & GF_CLI_STATUS_NFS) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_SHD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s-replicate-0", volname);
+    else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_BITD) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
+        ret = gf_asprintf(&subvol_name, "%s", volname);
+    else {
+        ret = -1;
+        goto out;
+    }
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to set node xlator name");
+        goto out;
+    }
+
+    subvol = xlator_search_by_name(node, subvol_name);
+    if (!subvol) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               subvol_name);
+        goto out;
+    }
+
+    output = dict_new();
+    switch (cmd & GF_CLI_STATUS_MASK) {
+        case GF_CLI_STATUS_MEM:
+            ret = 0;
+            gf_proc_dump_mem_info_to_dict(output);
+            gf_proc_dump_mempool_info_to_dict(ctx, output);
+            break;
+
+        case GF_CLI_STATUS_CLIENTS:
+            // clients not availbale for SHD
+            if ((cmd & GF_CLI_STATUS_SHD) != 0)
+                break;
 
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        any = active->first;
-
-        if ((cmd & GF_CLI_STATUS_NFS) != 0)
-                ret = gf_asprintf (&node_name, "%s", "nfs-server");
-        else if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "glustershd");
-        else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "quotad");
-        else if ((cmd & GF_CLI_STATUS_BITD) != 0)
-                ret = gf_asprintf (&node_name, "%s", "bitd");
-        else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
-                ret = gf_asprintf (&node_name, "%s", "scrubber");
-
-        else {
-                ret = -1;
-                goto out;
-        }
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to set node xlator name");
+            ret = dict_set_str(output, "volname", volname);
+            if (ret) {
+                gf_log(THIS->name, GF_LOG_ERROR,
+                       "Error setting volname to dict");
                 goto out;
-        }
+            }
+            ret = node->dumpops->priv_to_dict(node, output, NULL);
+            break;
 
-        node = xlator_search_by_name (any, node_name);
-        if (!node) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        node_name);
-                goto out;
-        }
+        case GF_CLI_STATUS_INODE:
+            ret = 0;
+            inode_table_dump_to_dict(subvol->itable, "conn0", output);
+            ret = dict_set_int32(output, "conncount", 1);
+            break;
 
-        if ((cmd & GF_CLI_STATUS_NFS) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s-replicate-0", volname);
-        else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_BITD) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else if ((cmd & GF_CLI_STATUS_SCRUB) != 0)
-                ret = gf_asprintf (&subvol_name, "%s", volname);
-        else {
-                ret = -1;
-                goto out;
-        }
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to set node xlator name");
-                goto out;
-        }
+        case GF_CLI_STATUS_FD:
+            // cannot find fd-tables in nfs-server graph
+            // TODO: finish once found
+            break;
 
-        subvol = xlator_search_by_name (node, subvol_name);
-        if (!subvol) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        subvol_name);
-                goto out;
-        }
+        case GF_CLI_STATUS_CALLPOOL:
+            ret = 0;
+            gf_proc_dump_pending_frames_to_dict(ctx->pool, output);
+            break;
 
-        output = dict_new ();
-        switch (cmd & GF_CLI_STATUS_MASK) {
-                case GF_CLI_STATUS_MEM:
-                        ret = 0;
-                        gf_proc_dump_mem_info_to_dict (output);
-                        gf_proc_dump_mempool_info_to_dict (ctx, output);
-                        break;
-
-                case GF_CLI_STATUS_CLIENTS:
-                        // clients not availbale for SHD
-                        if ((cmd & GF_CLI_STATUS_SHD) != 0)
-                                break;
-
-                        ret = dict_set_str (output, "volname", volname);
-                        if (ret) {
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Error setting volname to dict");
-                                goto out;
-                        }
-                        ret = node->dumpops->priv_to_dict (node, output, NULL);
-                        break;
-
-                case GF_CLI_STATUS_INODE:
-                        ret = 0;
-                        inode_table_dump_to_dict (subvol->itable, "conn0",
-                                                  output);
-                        ret = dict_set_int32 (output, "conncount", 1);
-                        break;
-
-                case GF_CLI_STATUS_FD:
-                        // cannot find fd-tables in nfs-server graph
-                        // TODO: finish once found
-                        break;
-
-                case GF_CLI_STATUS_CALLPOOL:
-                        ret = 0;
-                        gf_proc_dump_pending_frames_to_dict (ctx->pool, output);
-                        break;
-
-                default:
-                        ret = -1;
-                        msg = gf_strdup ("Unknown status op");
-                        gf_log (THIS->name, GF_LOG_ERROR, "%s", msg);
-                        break;
-        }
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        if (ret && msg)
-                rsp.op_errstr = msg;
-        else
-                rsp.op_errstr = "";
+        default:
+            ret = -1;
+            msg = gf_strdup("Unknown status op");
+            gf_log(THIS->name, GF_LOG_ERROR, "%s", msg);
+            break;
+    }
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    if (ret && msg)
+        rsp.op_errstr = msg;
+    else
+        rsp.op_errstr = "";
 
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (node_req.input.input_val);
-        GF_FREE (msg);
-        GF_FREE (rsp.output.output_val);
-        GF_FREE (node_name);
-        GF_FREE (subvol_name);
-
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    if (dict)
+        dict_unref(dict);
+    free(node_req.input.input_val);
+    GF_FREE(msg);
+    GF_FREE(rsp.output.output_val);
+    GF_FREE(node_name);
+    GF_FREE(subvol_name);
+
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_nfs_profile (rpcsvc_request_t *req)
+glusterfs_handle_nfs_profile(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        gd1_mgmt_brick_op_req   nfs_req = {0,};
-        gd1_mgmt_brick_op_rsp   rsp = {0,};
-        dict_t                  *dict = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        glusterfs_graph_t       *active = NULL;
-        xlator_t                *any = NULL;
-        xlator_t                *nfs = NULL;
-        xlator_t                *subvol = NULL;
-        char                    *volname = NULL;
-        dict_t                  *output = NULL;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic (req->msg[0], &nfs_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        dict = dict_new ();
-        ret = dict_unserialize (nfs_req.input.input_val,
-                                nfs_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to "
-                        "unserialize req-buffer to dict");
-                goto out;
-        }
-
-        ret = dict_get_str (dict, "volname", &volname);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get volname");
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        any = active->first;
-
-        // is this needed?
-        // are problems possible by searching for subvol directly from "any"?
-        nfs = xlator_search_by_name (any, "nfs-server");
-        if (!nfs) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "xlator nfs-server is "
-                        "not loaded");
-                goto out;
-        }
-
-        subvol = xlator_search_by_name (nfs, volname);
-        if (!subvol) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "xlator %s is no loaded",
-                        volname);
-                goto out;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req nfs_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp rsp = {
+        0,
+    };
+    dict_t *dict = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *any = NULL;
+    xlator_t *nfs = NULL;
+    xlator_t *subvol = NULL;
+    char *volname = NULL;
+    dict_t *output = NULL;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &nfs_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    dict = dict_new();
+    ret = dict_unserialize(nfs_req.input.input_val, nfs_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to "
+               "unserialize req-buffer to dict");
+        goto out;
+    }
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Couldn't get volname");
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    any = active->first;
+
+    // is this needed?
+    // are problems possible by searching for subvol directly from "any"?
+    nfs = xlator_search_by_name(any, "nfs-server");
+    if (!nfs) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "xlator nfs-server is "
+               "not loaded");
+        goto out;
+    }
+
+    subvol = xlator_search_by_name(nfs, volname);
+    if (!subvol) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "xlator %s is no loaded", volname);
+        goto out;
+    }
 
-        output = dict_new ();
-        ret = subvol->notify (subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
+    output = dict_new();
+    ret = subvol->notify(subvol, GF_EVENT_TRANSLATOR_INFO, dict, output);
 
-        rsp.op_ret = ret;
-        rsp.op_errno = 0;
-        rsp.op_errstr = "";
+    rsp.op_ret = ret;
+    rsp.op_errno = 0;
+    rsp.op_errstr = "";
 
-        ret = dict_allocate_and_serialize (output, &rsp.output.output_val,
-                                           &rsp.output.output_len);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize output dict to rsp");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(output, &rsp.output.output_val,
+                                      &rsp.output.output_len);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to serialize output dict to rsp");
+        goto out;
+    }
 
-        glusterfs_submit_reply (req, &rsp, NULL, 0, NULL,
-                                (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
-        ret = 0;
+    glusterfs_submit_reply(req, &rsp, NULL, 0, NULL,
+                           (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = 0;
 
 out:
-        free (nfs_req.input.input_val);
-        if (dict)
-                dict_unref (dict);
-        if (output)
-                dict_unref (output);
-        GF_FREE (rsp.output.output_val);
-
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    free(nfs_req.input.input_val);
+    if (dict)
+        dict_unref(dict);
+    if (output)
+        dict_unref(output);
+    GF_FREE(rsp.output.output_val);
+
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_volume_barrier_op (rpcsvc_request_t *req)
+glusterfs_handle_volume_barrier_op(rpcsvc_request_t *req)
 {
-        int32_t                  ret     = -1;
-        gd1_mgmt_brick_op_req    xlator_req = {0,};
-        dict_t                   *dict    = NULL;
-        xlator_t                 *xlator = NULL;
-        xlator_t                 *any = NULL;
-        dict_t                   *output = NULL;
-        char                     msg[2048] = {0};
-        glusterfs_ctx_t          *ctx = NULL;
-        glusterfs_graph_t        *active = NULL;
-        xlator_t                 *this = NULL;
-
-        GF_ASSERT (req);
-        this = THIS;
-        GF_ASSERT (this);
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-
-        active = ctx->active;
-        if (!active) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        any = active->first;
-        ret = xdr_to_generic (req->msg[0], &xlator_req,
-                              (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                //failed to decode msg;
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        ret = dict_unserialize (xlator_req.input.input_val,
-                                xlator_req.input.input_len,
-                                &dict);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to "
-                        "unserialize req-buffer to dictionary");
-                goto out;
-        }
-        xlator = xlator_search_by_name (any, xlator_req.name);
-        if (!xlator) {
-                snprintf (msg, sizeof (msg), "xlator %s is not loaded",
-                          xlator_req.name);
-                goto out;
-        }
-
-        output = dict_new ();
-        if (!output) {
-                ret = -1;
-                goto out;
-        }
+    int32_t ret = -1;
+    gd1_mgmt_brick_op_req xlator_req = {
+        0,
+    };
+    dict_t *dict = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *any = NULL;
+    dict_t *output = NULL;
+    char msg[2048] = {0};
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *this = NULL;
+
+    GF_ASSERT(req);
+    this = THIS;
+    GF_ASSERT(this);
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+
+    active = ctx->active;
+    if (!active) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    any = active->first;
+    ret = xdr_to_generic(req->msg[0], &xlator_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        // failed to decode msg;
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    ret = dict_unserialize(xlator_req.input.input_val,
+                           xlator_req.input.input_len, &dict);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to "
+               "unserialize req-buffer to dictionary");
+        goto out;
+    }
+    xlator = xlator_search_by_name(any, xlator_req.name);
+    if (!xlator) {
+        snprintf(msg, sizeof(msg), "xlator %s is not loaded", xlator_req.name);
+        goto out;
+    }
+
+    output = dict_new();
+    if (!output) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xlator->notify (xlator, GF_EVENT_VOLUME_BARRIER_OP,
-                              dict, output);
+    ret = xlator->notify(xlator, GF_EVENT_VOLUME_BARRIER_OP, dict, output);
 
-        ret = glusterfs_translator_info_response_send (req, ret,
-                                                       msg, output);
+    ret = glusterfs_translator_info_response_send(req, ret, msg, output);
 out:
-        if (dict)
-                dict_unref (dict);
-        free (xlator_req.input.input_val); // malloced by xdr
-        if (output)
-                dict_unref (output);
-        free (xlator_req.name); //malloced by xdr
-
-        return ret;
-
+    if (dict)
+        dict_unref(dict);
+    free(xlator_req.input.input_val);  // malloced by xdr
+    if (output)
+        dict_unref(output);
+    free(xlator_req.name);  // malloced by xdr
+
+    return ret;
 }
 
 int
-glusterfs_handle_barrier (rpcsvc_request_t *req)
+glusterfs_handle_barrier(rpcsvc_request_t *req)
 {
-        int                     ret         = -1;
-        gd1_mgmt_brick_op_req   brick_req   = {0,};
-        gd1_mgmt_brick_op_rsp   brick_rsp   = {0,};
-        glusterfs_ctx_t         *ctx        = NULL;
-        glusterfs_graph_t       *active     = NULL;
-        xlator_t                *top        = NULL;
-        xlator_t                *xlator     = NULL;
-        xlator_t                *old_THIS   = NULL;
-        dict_t                  *dict       = NULL;
-        gf_boolean_t            barrier     = _gf_true;
-        gf_boolean_t            barrier_err = _gf_false;
-        xlator_list_t           *trav;
-
-        GF_ASSERT (req);
-
-        ret = xdr_to_generic(req->msg[0], &brick_req,
-                             (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
-        if (ret < 0) {
-                req->rpc_err = GARBAGE_ARGS;
-                goto out;
-        }
-
-        ctx = glusterfsd_ctx;
-        GF_ASSERT (ctx);
-        active = ctx->active;
-        top = active->first;
-
-        for (trav = top->children; trav; trav = trav->next) {
-                if (strcmp (trav->xlator->name, brick_req.name) == 0) {
-                        break;
-                }
-        }
-        if (!trav) {
-                ret = -1;
-                goto out;
-        }
-        top = trav->xlator;
-
-        dict = dict_new();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_unserialize(brick_req.input.input_val,
-                               brick_req.input.input_len, &dict);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to unserialize "
-                        "request dictionary");
-                goto out;
-        }
-
-        brick_rsp.op_ret = 0;
-        brick_rsp.op_errstr = ""; // initing to prevent serilaztion failures
-        old_THIS = THIS;
-
-        /* Send barrier request to the barrier xlator */
-        xlator = get_xlator_by_type (top, "features/barrier");
-        if (!xlator) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        "features/barrier");
-                goto out;
-        }
-
-        THIS = xlator;
-        // TODO: Extend this to accept return of errnos
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_OP, dict);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "barrier notify failed");
-                brick_rsp.op_ret = ret;
-                brick_rsp.op_errstr = gf_strdup ("Failed to reconfigure "
-                                                 "barrier.");
-                /* This is to invoke changelog-barrier disable if barrier
-                 * disable fails and don't invoke if barrier enable fails.
-                 */
-                barrier = dict_get_str_boolean (dict, "barrier", _gf_true);
-                if (barrier)
-                        goto submit_reply;
-                else
-                        barrier_err = _gf_true;
-        }
+    int ret = -1;
+    gd1_mgmt_brick_op_req brick_req = {
+        0,
+    };
+    gd1_mgmt_brick_op_rsp brick_rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    glusterfs_graph_t *active = NULL;
+    xlator_t *top = NULL;
+    xlator_t *xlator = NULL;
+    xlator_t *old_THIS = NULL;
+    dict_t *dict = NULL;
+    gf_boolean_t barrier = _gf_true;
+    gf_boolean_t barrier_err = _gf_false;
+    xlator_list_t *trav;
+
+    GF_ASSERT(req);
+
+    ret = xdr_to_generic(req->msg[0], &brick_req,
+                         (xdrproc_t)xdr_gd1_mgmt_brick_op_req);
+    if (ret < 0) {
+        req->rpc_err = GARBAGE_ARGS;
+        goto out;
+    }
+
+    ctx = glusterfsd_ctx;
+    GF_ASSERT(ctx);
+    active = ctx->active;
+    top = active->first;
+
+    for (trav = top->children; trav; trav = trav->next) {
+        if (strcmp(trav->xlator->name, brick_req.name) == 0) {
+            break;
+        }
+    }
+    if (!trav) {
+        ret = -1;
+        goto out;
+    }
+    top = trav->xlator;
 
-        /* Reset THIS so that we have it correct in case of an error below
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_unserialize(brick_req.input.input_val, brick_req.input.input_len,
+                           &dict);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to unserialize "
+               "request dictionary");
+        goto out;
+    }
+
+    brick_rsp.op_ret = 0;
+    brick_rsp.op_errstr = "";  // initing to prevent serilaztion failures
+    old_THIS = THIS;
+
+    /* Send barrier request to the barrier xlator */
+    xlator = get_xlator_by_type(top, "features/barrier");
+    if (!xlator) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               "features/barrier");
+        goto out;
+    }
+
+    THIS = xlator;
+    // TODO: Extend this to accept return of errnos
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_OP, dict);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "barrier notify failed");
+        brick_rsp.op_ret = ret;
+        brick_rsp.op_errstr = gf_strdup(
+            "Failed to reconfigure "
+            "barrier.");
+        /* This is to invoke changelog-barrier disable if barrier
+         * disable fails and don't invoke if barrier enable fails.
          */
-        THIS = old_THIS;
-
-        /* Send barrier request to changelog as well */
-        xlator = get_xlator_by_type (top, "features/changelog");
-        if (!xlator) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
-                        "features/changelog");
-                goto out;
-        }
+        barrier = dict_get_str_boolean(dict, "barrier", _gf_true);
+        if (barrier)
+            goto submit_reply;
+        else
+            barrier_err = _gf_true;
+    }
 
-        THIS = xlator;
-        ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_OP, dict);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "changelog notify failed");
-                brick_rsp.op_ret = ret;
-                brick_rsp.op_errstr = gf_strdup ("changelog notify failed");
-                goto submit_reply;
-        }
+    /* Reset THIS so that we have it correct in case of an error below
+     */
+    THIS = old_THIS;
 
-        if (barrier_err)
-                ret = -1;
+    /* Send barrier request to changelog as well */
+    xlator = get_xlator_by_type(top, "features/changelog");
+    if (!xlator) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_ERROR, "%s xlator is not loaded",
+               "features/changelog");
+        goto out;
+    }
+
+    THIS = xlator;
+    ret = xlator->notify(xlator, GF_EVENT_TRANSLATOR_OP, dict);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR, "changelog notify failed");
+        brick_rsp.op_ret = ret;
+        brick_rsp.op_errstr = gf_strdup("changelog notify failed");
+        goto submit_reply;
+    }
+
+    if (barrier_err)
+        ret = -1;
 
 submit_reply:
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        ret = glusterfs_submit_reply (req, &brick_rsp, NULL, 0, NULL,
-                                      (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
+    ret = glusterfs_submit_reply(req, &brick_rsp, NULL, 0, NULL,
+                                 (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
 
 out:
-        if (dict)
-                dict_unref (dict);
-        free (brick_req.input.input_val);
+    if (dict)
+        dict_unref(dict);
+    free(brick_req.input.input_val);
 
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
+    gf_log(THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
+    return ret;
 }
 
 int
-glusterfs_handle_rpc_msg (rpcsvc_request_t *req)
+glusterfs_handle_rpc_msg(rpcsvc_request_t *req)
 {
-        int ret = -1;
-        /* for now, nothing */
-        return ret;
+    int ret = -1;
+    /* for now, nothing */
+    return ret;
 }
 
 rpcclnt_cb_actor_t mgmt_cbk_actors[GF_CBK_MAXVALUE] = {
-        [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec },
-        [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
-                                 mgmt_cbk_event},
-        [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_event},
+    [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec},
+    [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY,
+                             mgmt_cbk_event},
+    [GF_CBK_STATEDUMP] = {"STATEDUMP", GF_CBK_STATEDUMP, mgmt_cbk_event},
 };
 
-
 struct rpcclnt_cb_program mgmt_cbk_prog = {
-        .progname  = "GlusterFS Callback",
-        .prognum   = GLUSTER_CBK_PROGRAM,
-        .progver   = GLUSTER_CBK_VERSION,
-        .actors    = mgmt_cbk_actors,
-        .numactors = GF_CBK_MAXVALUE,
+    .progname = "GlusterFS Callback",
+    .prognum = GLUSTER_CBK_PROGRAM,
+    .progver = GLUSTER_CBK_VERSION,
+    .actors = mgmt_cbk_actors,
+    .numactors = GF_CBK_MAXVALUE,
 };
 
 char *clnt_pmap_procs[GF_PMAP_MAXVALUE] = {
-        [GF_PMAP_NULL]        = "NULL",
-        [GF_PMAP_PORTBYBRICK] = "PORTBYBRICK",
-        [GF_PMAP_BRICKBYPORT] = "BRICKBYPORT",
-        [GF_PMAP_SIGNIN]      = "SIGNIN",
-        [GF_PMAP_SIGNOUT]     = "SIGNOUT",
-        [GF_PMAP_SIGNUP]      = "SIGNUP",       /* DEPRECATED - DON'T USE! */
+    [GF_PMAP_NULL] = "NULL",
+    [GF_PMAP_PORTBYBRICK] = "PORTBYBRICK",
+    [GF_PMAP_BRICKBYPORT] = "BRICKBYPORT",
+    [GF_PMAP_SIGNIN] = "SIGNIN",
+    [GF_PMAP_SIGNOUT] = "SIGNOUT",
+    [GF_PMAP_SIGNUP] = "SIGNUP", /* DEPRECATED - DON'T USE! */
 };
 
-
 rpc_clnt_prog_t clnt_pmap_prog = {
-        .progname  = "Gluster Portmap",
-        .prognum   = GLUSTER_PMAP_PROGRAM,
-        .progver   = GLUSTER_PMAP_VERSION,
-        .procnames = clnt_pmap_procs,
+    .progname = "Gluster Portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
+    .procnames = clnt_pmap_procs,
 };
 
 char *clnt_handshake_procs[GF_HNDSK_MAXVALUE] = {
-        [GF_HNDSK_NULL]         = "NULL",
-        [GF_HNDSK_SETVOLUME]    = "SETVOLUME",
-        [GF_HNDSK_GETSPEC]      = "GETSPEC",
-        [GF_HNDSK_PING]         = "PING",
-        [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
+    [GF_HNDSK_NULL] = "NULL",
+    [GF_HNDSK_SETVOLUME] = "SETVOLUME",
+    [GF_HNDSK_GETSPEC] = "GETSPEC",
+    [GF_HNDSK_PING] = "PING",
+    [GF_HNDSK_EVENT_NOTIFY] = "EVENTNOTIFY",
 };
 
 rpc_clnt_prog_t clnt_handshake_prog = {
-        .progname  = "GlusterFS Handshake",
-        .prognum   = GLUSTER_HNDSK_PROGRAM,
-        .progver   = GLUSTER_HNDSK_VERSION,
-        .procnames = clnt_handshake_procs,
+    .progname = "GlusterFS Handshake",
+    .prognum = GLUSTER_HNDSK_PROGRAM,
+    .progver = GLUSTER_HNDSK_VERSION,
+    .procnames = clnt_handshake_procs,
 };
 
 rpcsvc_actor_t glusterfs_actors[GLUSTERD_BRICK_MAXVALUE] = {
-        [GLUSTERD_BRICK_NULL]          = {"NULL",
-                                          GLUSTERD_BRICK_NULL,
-                                          glusterfs_handle_rpc_msg,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_TERMINATE]     = {"TERMINATE",
-                                          GLUSTERD_BRICK_TERMINATE,
-                                          glusterfs_handle_terminate,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_INFO]   = {"TRANSLATOR INFO",
-                                          GLUSTERD_BRICK_XLATOR_INFO,
-                                          glusterfs_handle_translator_info_get,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_OP]     = {"TRANSLATOR OP",
-                                          GLUSTERD_BRICK_XLATOR_OP,
-                                          glusterfs_handle_translator_op,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_STATUS]        = {"STATUS",
-                                          GLUSTERD_BRICK_STATUS,
-                                          glusterfs_handle_brick_status,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_XLATOR_DEFRAG] = {"TRANSLATOR DEFRAG",
-                                          GLUSTERD_BRICK_XLATOR_DEFRAG,
-                                          glusterfs_handle_defrag,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_PROFILE]        = {"NFS PROFILE",
-                                          GLUSTERD_NODE_PROFILE,
-                                          glusterfs_handle_nfs_profile,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_STATUS]         = {"NFS STATUS",
-                                          GLUSTERD_NODE_STATUS,
-                                          glusterfs_handle_node_status,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_VOLUME_BARRIER_OP]   = {"VOLUME BARRIER OP",
-                                          GLUSTERD_VOLUME_BARRIER_OP,
-                                          glusterfs_handle_volume_barrier_op,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_BARRIER]       = {"BARRIER",
-                                          GLUSTERD_BRICK_BARRIER,
-                                          glusterfs_handle_barrier,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_NODE_BITROT]         = {"BITROT",
-                                          GLUSTERD_NODE_BITROT,
-                                          glusterfs_handle_bitrot,
-                                          NULL, 0, DRC_NA},
-        [GLUSTERD_BRICK_ATTACH]        = {"ATTACH",
-                                          GLUSTERD_BRICK_ATTACH,
-                                          glusterfs_handle_attach,
-                                          NULL, 0, DRC_NA},
-
-        [GLUSTERD_DUMP_METRICS]        = {"DUMP METRICS",
-                                          GLUSTERD_DUMP_METRICS,
-                                          glusterfs_handle_dump_metrics,
-                                          NULL, 0, DRC_NA},
+    [GLUSTERD_BRICK_NULL] = {"NULL", GLUSTERD_BRICK_NULL,
+                             glusterfs_handle_rpc_msg, NULL, 0, DRC_NA},
+    [GLUSTERD_BRICK_TERMINATE] = {"TERMINATE", GLUSTERD_BRICK_TERMINATE,
+                                  glusterfs_handle_terminate, NULL, 0, DRC_NA},
+    [GLUSTERD_BRICK_XLATOR_INFO] = {"TRANSLATOR INFO",
+                                    GLUSTERD_BRICK_XLATOR_INFO,
+                                    glusterfs_handle_translator_info_get, NULL,
+                                    0, DRC_NA},
+    [GLUSTERD_BRICK_XLATOR_OP] = {"TRANSLATOR OP", GLUSTERD_BRICK_XLATOR_OP,
+                                  glusterfs_handle_translator_op, NULL, 0,
+                                  DRC_NA},
+    [GLUSTERD_BRICK_STATUS] = {"STATUS", GLUSTERD_BRICK_STATUS,
+                               glusterfs_handle_brick_status, NULL, 0, DRC_NA},
+    [GLUSTERD_BRICK_XLATOR_DEFRAG] = {"TRANSLATOR DEFRAG",
+                                      GLUSTERD_BRICK_XLATOR_DEFRAG,
+                                      glusterfs_handle_defrag, NULL, 0, DRC_NA},
+    [GLUSTERD_NODE_PROFILE] = {"NFS PROFILE", GLUSTERD_NODE_PROFILE,
+                               glusterfs_handle_nfs_profile, NULL, 0, DRC_NA},
+    [GLUSTERD_NODE_STATUS] = {"NFS STATUS", GLUSTERD_NODE_STATUS,
+                              glusterfs_handle_node_status, NULL, 0, DRC_NA},
+    [GLUSTERD_VOLUME_BARRIER_OP] = {"VOLUME BARRIER OP",
+                                    GLUSTERD_VOLUME_BARRIER_OP,
+                                    glusterfs_handle_volume_barrier_op, NULL, 0,
+                                    DRC_NA},
+    [GLUSTERD_BRICK_BARRIER] = {"BARRIER", GLUSTERD_BRICK_BARRIER,
+                                glusterfs_handle_barrier, NULL, 0, DRC_NA},
+    [GLUSTERD_NODE_BITROT] = {"BITROT", GLUSTERD_NODE_BITROT,
+                              glusterfs_handle_bitrot, NULL, 0, DRC_NA},
+    [GLUSTERD_BRICK_ATTACH] = {"ATTACH", GLUSTERD_BRICK_ATTACH,
+                               glusterfs_handle_attach, NULL, 0, DRC_NA},
+
+    [GLUSTERD_DUMP_METRICS] = {"DUMP METRICS", GLUSTERD_DUMP_METRICS,
+                               glusterfs_handle_dump_metrics, NULL, 0, DRC_NA},
 };
 
 struct rpcsvc_program glusterfs_mop_prog = {
-        .progname  = "Gluster Brick operations",
-        .prognum   = GD_BRICK_PROGRAM,
-        .progver   = GD_BRICK_VERSION,
-        .actors    = glusterfs_actors,
-        .numactors = GLUSTERD_BRICK_MAXVALUE,
-	.synctask  = _gf_true,
+    .progname = "Gluster Brick operations",
+    .prognum = GD_BRICK_PROGRAM,
+    .progver = GD_BRICK_VERSION,
+    .actors = glusterfs_actors,
+    .numactors = GLUSTERD_BRICK_MAXVALUE,
+    .synctask = _gf_true,
 };
 
 int
-mgmt_submit_request (void *req, call_frame_t *frame,
-                     glusterfs_ctx_t *ctx,
-                     rpc_clnt_prog_t *prog, int procnum,
-                     fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
+mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx,
+                    rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbkfn,
+                    xdrproc_t xdrproc)
 {
-        int                     ret         = -1;
-        int                     count      = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf = NULL;
-        struct iobref           *iobref = NULL;
-        ssize_t                 xdr_size = 0;
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                goto out;
-        }
-
-        if (req) {
-                xdr_size = xdr_sizeof (xdrproc, req);
-
-                iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-                if (!iobuf) {
-                        goto out;
-                };
-
-                iobref_add (iobref, iobuf);
-
-                iov.iov_base = iobuf->ptr;
-                iov.iov_len  = iobuf_pagesize (iobuf);
-
-                /* Create the xdr payload */
-                ret = xdr_serialize_generic (iov, req, xdrproc);
-                if (ret == -1) {
-                        gf_log (THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
-                        goto out;
-                }
-                iov.iov_len = ret;
-                count = 1;
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    if (req) {
+        xdr_size = xdr_sizeof(xdrproc, req);
+
+        iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+        if (!iobuf) {
+            goto out;
+        };
+
+        iobref_add(iobref, iobuf);
+
+        iov.iov_base = iobuf->ptr;
+        iov.iov_len = iobuf_pagesize(iobuf);
+
+        /* Create the xdr payload */
+        ret = xdr_serialize_generic(iov, req, xdrproc);
+        if (ret == -1) {
+            gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+            goto out;
         }
+        iov.iov_len = ret;
+        count = 1;
+    }
 
-        /* Send the msg */
-        ret = rpc_clnt_submit (ctx->mgmt, prog, procnum, cbkfn,
-                               &iov, count,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    /* Send the msg */
+    ret = rpc_clnt_submit(ctx->mgmt, prog, procnum, cbkfn, &iov, count, NULL, 0,
+                          iobref, frame, NULL, 0, NULL, 0, NULL);
 
 out:
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
 
 int
-mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                  void *myframe)
+mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
 {
-        gf_getspec_rsp           rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        int                      ret   = 0, locked = 0;
-        ssize_t                  size = 0;
-        FILE                    *tmpfp = NULL;
-        char                    *volfile_id = NULL;
-        gf_volfile_t            *volfile_obj = NULL;
-        gf_volfile_t            *volfile_tmp = NULL;
-        char                     sha256_hash[SHA256_DIGEST_LENGTH] = {0, };
-        dict_t                  *dict = NULL;
-        char                    *servers_list = NULL;
-        int                      tmp_fd = -1;
-        char                     template[] = "/tmp/glfs.volfile.XXXXXX";
-
-        frame = myframe;
-        ctx = frame->this->ctx;
-
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the 'volume file' from server");
-                ret = rsp.op_errno;
-                goto out;
-        }
-
-        if (!rsp.xdata.xdata_len) {
-                goto volfile;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        ret = dict_unserialize (rsp.xdata.xdata_val, rsp.xdata.xdata_len,
-                                &dict);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to unserialize xdata to dictionary");
-                goto out;
-        }
-        dict->extra_stdfree = rsp.xdata.xdata_val;
-
-        /* glusterd2 only */
-        ret = dict_get_str (dict, "servers-list", &servers_list);
-        if (ret) {
-                goto volfile;
-        }
-
-        gf_log (frame->this->name, GF_LOG_INFO,
-                "Received list of available volfile servers: %s",
-                servers_list);
+    gf_getspec_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0, locked = 0;
+    ssize_t size = 0;
+    FILE *tmpfp = NULL;
+    char *volfile_id = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+    gf_volfile_t *volfile_tmp = NULL;
+    char sha256_hash[SHA256_DIGEST_LENGTH] = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *servers_list = NULL;
+    int tmp_fd = -1;
+    char template[] = "/tmp/glfs.volfile.XXXXXX";
+
+    frame = myframe;
+    ctx = frame->this->ctx;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
-        if (ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Failed (%s) to process servers list: %s",
-                        strerror (errno), servers_list);
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the 'volume file' from server");
+        ret = rsp.op_errno;
+        goto out;
+    }
+
+    if (!rsp.xdata.xdata_len) {
+        goto volfile;
+    }
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_unserialize(rsp.xdata.xdata_val, rsp.xdata.xdata_len, &dict);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to unserialize xdata to dictionary");
+        goto out;
+    }
+    dict->extra_stdfree = rsp.xdata.xdata_val;
+
+    /* glusterd2 only */
+    ret = dict_get_str(dict, "servers-list", &servers_list);
+    if (ret) {
+        goto volfile;
+    }
+
+    gf_log(frame->this->name, GF_LOG_INFO,
+           "Received list of available volfile servers: %s", servers_list);
+
+    ret = gf_process_getspec_servers_list(&ctx->cmd_args, servers_list);
+    if (ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Failed (%s) to process servers list: %s", strerror(errno),
+               servers_list);
+    }
 
 volfile:
-        ret = 0;
-        size = rsp.op_ret;
-
-        glusterfs_compute_sha256 ((const unsigned char *) rsp.spec, size,
-                                  sha256_hash);
-
-        volfile_id = frame->local;
-
-        LOCK (&ctx->volfile_lock);
-        {
-                locked = 1;
-
-                list_for_each_entry (volfile_obj,  &ctx->volfile_list,
-                                     volfile_list) {
-                        if (!strcmp (volfile_id, volfile_obj->vol_id)) {
-                                if (!memcmp (sha256_hash,
-                                      volfile_obj->volfile_checksum,
-                                      sizeof (volfile_obj->volfile_checksum))) {
-                                        gf_log (frame->this->name, GF_LOG_INFO,
-                                                "No change in volfile,"
-                                                "continuing");
-                                        goto out;
-                               }
-                               volfile_tmp = volfile_obj;
-                               break;
-                        }
-                }
+    ret = 0;
+    size = rsp.op_ret;
 
-                /* coverity[secure_temp] mkstemp uses 0600 as the mode */
-                tmp_fd = mkstemp (template);
-                if (-1 == tmp_fd) {
-                        gf_msg (frame->this->name, GF_LOG_ERROR, 0,
-                                glusterfsd_msg_39,
-                                "Unable to create temporary file: %s",
-                                template);
-                        ret = -1;
-                        goto out;
-                }
+    glusterfs_compute_sha256((const unsigned char *)rsp.spec, size,
+                             sha256_hash);
 
-                /* Calling unlink so that when the file is closed or program
-                 * terminates the temporary file is deleted.
-                 */
-                ret = sys_unlink (template);
-                if (ret < 0) {
-                        gf_msg (frame->this->name, GF_LOG_INFO, 0,
-                                glusterfsd_msg_39,
-                                "Unable to delete temporary file: %s",
-                                template);
-                        ret = 0;
-                }
+    volfile_id = frame->local;
 
-                tmpfp = fdopen (tmp_fd, "w+b");
-                if (!tmpfp) {
-                        ret = -1;
-                        goto out;
-                }
+    LOCK(&ctx->volfile_lock);
+    {
+        locked = 1;
 
-                fwrite (rsp.spec, size, 1, tmpfp);
-                fflush (tmpfp);
-                if (ferror (tmpfp)) {
-                        ret = -1;
-                        goto out;
-                }
-
-                /*  Check if only options have changed. No need to reload the
-                 *  volfile if topology hasn't changed.
-                 *  glusterfs_volfile_reconfigure returns 3 possible return states
-                 *  return 0          =======> reconfiguration of options has succeeded
-                 *  return 1          =======> the graph has to be reconstructed and all the xlators should be inited
-                 *  return -1(or -ve) =======> Some Internal Error occurred during the operation
-                 */
-
-                ret = glusterfs_volfile_reconfigure (tmpfp, ctx);
-                if (ret == 0) {
-                        gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG,
-                                "No need to re-load volfile, reconfigure done");
-                        if (!volfile_tmp) {
-                                ret = -1;
-                                gf_log ("mgmt", GF_LOG_ERROR, "Graph "
-                                        "reconfigure succeeded with out having "
-                                        "checksum.");
-                                goto out;
-                        }
-                        memcpy (volfile_tmp->volfile_checksum, sha256_hash,
-                                sizeof (volfile_tmp->volfile_checksum));
-                        goto out;
+        list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list)
+        {
+            if (!strcmp(volfile_id, volfile_obj->vol_id)) {
+                if (!memcmp(sha256_hash, volfile_obj->volfile_checksum,
+                            sizeof(volfile_obj->volfile_checksum))) {
+                    gf_log(frame->this->name, GF_LOG_INFO,
+                           "No change in volfile,"
+                           "continuing");
+                    goto out;
                 }
+                volfile_tmp = volfile_obj;
+                break;
+            }
+        }
 
-                if (ret < 0) {
-                        gf_log ("glusterfsd-mgmt",
-                                GF_LOG_DEBUG, "Reconfigure failed !!");
-                        goto out;
-                }
+        /* coverity[secure_temp] mkstemp uses 0600 as the mode */
+        tmp_fd = mkstemp(template);
+        if (-1 == tmp_fd) {
+            gf_msg(frame->this->name, GF_LOG_ERROR, 0, glusterfsd_msg_39,
+                   "Unable to create temporary file: %s", template);
+            ret = -1;
+            goto out;
+        }
 
-                ret = glusterfs_process_volfp (ctx, tmpfp);
-                /* tmpfp closed */
-                tmpfp = NULL;
-                tmp_fd = -1;
-                if (ret)
-                        goto out;
-
-                if (!volfile_tmp) {
-                        volfile_tmp = GF_CALLOC (1, sizeof (gf_volfile_t),
-                                                 gf_common_volfile_t);
-                        if (!volfile_tmp) {
-                                ret = -1;
-                                goto out;
-                        }
-
-                        INIT_LIST_HEAD (&volfile_tmp->volfile_list);
-                        list_add (&volfile_tmp->volfile_list,
-                                  &ctx->volfile_list);
-                        snprintf (volfile_tmp->vol_id,
-                                  sizeof (volfile_tmp->vol_id), "%s",
-                                  volfile_id);
-                }
-                memcpy (volfile_tmp->volfile_checksum, sha256_hash,
-                        sizeof (volfile_tmp->volfile_checksum));
+        /* Calling unlink so that when the file is closed or program
+         * terminates the temporary file is deleted.
+         */
+        ret = sys_unlink(template);
+        if (ret < 0) {
+            gf_msg(frame->this->name, GF_LOG_INFO, 0, glusterfsd_msg_39,
+                   "Unable to delete temporary file: %s", template);
+            ret = 0;
         }
-        UNLOCK (&ctx->volfile_lock);
 
-        locked = 0;
+        tmpfp = fdopen(tmp_fd, "w+b");
+        if (!tmpfp) {
+            ret = -1;
+            goto out;
+        }
 
-        if (!is_mgmt_rpc_reconnect) {
-                need_emancipate = 1;
-                glusterfs_mgmt_pmap_signin (ctx);
-                is_mgmt_rpc_reconnect =  _gf_true;
+        fwrite(rsp.spec, size, 1, tmpfp);
+        fflush(tmpfp);
+        if (ferror(tmpfp)) {
+            ret = -1;
+            goto out;
         }
 
-out:
+        /*  Check if only options have changed. No need to reload the
+         *  volfile if topology hasn't changed.
+         *  glusterfs_volfile_reconfigure returns 3 possible return states
+         *  return 0          =======> reconfiguration of options has succeeded
+         *  return 1          =======> the graph has to be reconstructed and all
+         * the xlators should be inited return -1(or -ve) =======> Some Internal
+         * Error occurred during the operation
+         */
 
-        if (locked)
-                UNLOCK (&ctx->volfile_lock);
+        ret = glusterfs_volfile_reconfigure(tmpfp, ctx);
+        if (ret == 0) {
+            gf_log("glusterfsd-mgmt", GF_LOG_DEBUG,
+                   "No need to re-load volfile, reconfigure done");
+            if (!volfile_tmp) {
+                ret = -1;
+                gf_log("mgmt", GF_LOG_ERROR,
+                       "Graph "
+                       "reconfigure succeeded with out having "
+                       "checksum.");
+                goto out;
+            }
+            memcpy(volfile_tmp->volfile_checksum, sha256_hash,
+                   sizeof(volfile_tmp->volfile_checksum));
+            goto out;
+        }
 
-        GF_FREE (frame->local);
-        frame->local = NULL;
-        STACK_DESTROY (frame->root);
+        if (ret < 0) {
+            gf_log("glusterfsd-mgmt", GF_LOG_DEBUG, "Reconfigure failed !!");
+            goto out;
+        }
 
-        free (rsp.spec);
+        ret = glusterfs_process_volfp(ctx, tmpfp);
+        /* tmpfp closed */
+        tmpfp = NULL;
+        tmp_fd = -1;
+        if (ret)
+            goto out;
 
-        if (dict)
-                dict_unref (dict);
+        if (!volfile_tmp) {
+            volfile_tmp = GF_CALLOC(1, sizeof(gf_volfile_t),
+                                    gf_common_volfile_t);
+            if (!volfile_tmp) {
+                ret = -1;
+                goto out;
+            }
 
-        // Stop if server is running at an unsupported op-version
-        if (ENOTSUP == ret) {
-                gf_log ("mgmt", GF_LOG_ERROR, "Server is operating at an "
-                        "op-version which is not supported");
-                cleanup_and_exit (0);
+            INIT_LIST_HEAD(&volfile_tmp->volfile_list);
+            list_add(&volfile_tmp->volfile_list, &ctx->volfile_list);
+            snprintf(volfile_tmp->vol_id, sizeof(volfile_tmp->vol_id), "%s",
+                     volfile_id);
         }
+        memcpy(volfile_tmp->volfile_checksum, sha256_hash,
+               sizeof(volfile_tmp->volfile_checksum));
+    }
+    UNLOCK(&ctx->volfile_lock);
 
-        if (ret && ctx && !ctx->active) {
-                /* Do it only for the first time */
-                /* Failed to get the volume file, something wrong,
-                   restart the process */
-                gf_log ("mgmt", GF_LOG_ERROR,
-                        "failed to fetch volume file (key:%s)",
-                        ctx->cmd_args.volfile_id);
-                cleanup_and_exit (0);
-        }
+    locked = 0;
 
+    if (!is_mgmt_rpc_reconnect) {
+        need_emancipate = 1;
+        glusterfs_mgmt_pmap_signin(ctx);
+        is_mgmt_rpc_reconnect = _gf_true;
+    }
 
-        if (tmpfp)
-                fclose (tmpfp);
-        else if (tmp_fd != -1)
-                sys_close (tmp_fd);
+out:
 
-        return 0;
+    if (locked)
+        UNLOCK(&ctx->volfile_lock);
+
+    GF_FREE(frame->local);
+    frame->local = NULL;
+    STACK_DESTROY(frame->root);
+
+    free(rsp.spec);
+
+    if (dict)
+        dict_unref(dict);
+
+    // Stop if server is running at an unsupported op-version
+    if (ENOTSUP == ret) {
+        gf_log("mgmt", GF_LOG_ERROR,
+               "Server is operating at an "
+               "op-version which is not supported");
+        cleanup_and_exit(0);
+    }
+
+    if (ret && ctx && !ctx->active) {
+        /* Do it only for the first time */
+        /* Failed to get the volume file, something wrong,
+           restart the process */
+        gf_log("mgmt", GF_LOG_ERROR, "failed to fetch volume file (key:%s)",
+               ctx->cmd_args.volfile_id);
+        cleanup_and_exit(0);
+    }
+
+    if (tmpfp)
+        fclose(tmpfp);
+    else if (tmp_fd != -1)
+        sys_close(tmp_fd);
+
+    return 0;
 }
 
-
 static int
-glusterfs_volfile_fetch_one (glusterfs_ctx_t *ctx, char *volfile_id)
+glusterfs_volfile_fetch_one(glusterfs_ctx_t *ctx, char *volfile_id)
 {
-        cmd_args_t       *cmd_args = NULL;
-        gf_getspec_req    req = {0, };
-        int               ret = 0;
-        call_frame_t     *frame = NULL;
-        dict_t           *dict = NULL;
-
-        cmd_args = &ctx->cmd_args;
+    cmd_args_t *cmd_args = NULL;
+    gf_getspec_req req = {
+        0,
+    };
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    dict_t *dict = NULL;
+
+    cmd_args = &ctx->cmd_args;
+    if (!volfile_id) {
+        volfile_id = ctx->cmd_args.volfile_id;
         if (!volfile_id) {
-                volfile_id = ctx->cmd_args.volfile_id;
-                if (!volfile_id) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "No volfile-id provided, erroring out");
-                        return -1;
-                }
-        }
-
-        frame = create_frame (THIS, ctx->pool);
-
-        req.key = volfile_id;
-        req.flags = 0;
-        /*
-         * We are only storing one variable in local, hence using the same
-         * variable. If multiple local variable is required, create a struct.
-         */
-        frame->local = gf_strdup (volfile_id);
-        if (!frame->local) {
-                ret = -1;
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
-
-        // Set the supported min and max op-versions, so glusterd can make a
-        // decision
-        ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version"
-                        " in request dict");
-                goto out;
-        }
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "No volfile-id provided, erroring out");
+            return -1;
+        }
+    }
+
+    frame = create_frame(THIS, ctx->pool);
+
+    req.key = volfile_id;
+    req.flags = 0;
+    /*
+     * We are only storing one variable in local, hence using the same
+     * variable. If multiple local variable is required, create a struct.
+     */
+    frame->local = gf_strdup(volfile_id);
+    if (!frame->local) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX);
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    // Set the supported min and max op-versions, so glusterd can make a
+    // decision
+    ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set min-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "Failed to set max-op-version"
+               " in request dict");
+        goto out;
+    }
+
+    /* Ask for a list of volfile (glusterd2 only) servers */
+    if (GF_CLIENT_PROCESS == ctx->process_mode) {
+        req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
+    }
+
+    if (cmd_args->brick_name) {
+        ret = dict_set_dynstr_with_alloc(dict, "brick_name",
+                                         cmd_args->brick_name);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version"
-                        " in request dict");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "Failed to set brick_name in request dict");
+            goto out;
         }
+    }
 
-        /* Ask for a list of volfile (glusterd2 only) servers */
-        if (GF_CLIENT_PROCESS == ctx->process_mode) {
-                req.flags = req.flags | GF_GETSPEC_FLAG_SERVERS_LIST;
-        }
-
-        if (cmd_args->brick_name) {
-                ret = dict_set_dynstr_with_alloc (dict, "brick_name",
-                                                  cmd_args->brick_name);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "Failed to set brick_name in request dict");
-                        goto out;
-                }
-        }
-
-        ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val,
-                                           &req.xdata.xdata_len);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "Failed to serialize dictionary");
-                goto out;
-        }
+    ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val,
+                                      &req.xdata.xdata_len);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Failed to serialize dictionary");
+        goto out;
+    }
 
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_GETSPEC, mgmt_getspec_cbk,
-                                   (xdrproc_t)xdr_gf_getspec_req);
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_GETSPEC, mgmt_getspec_cbk,
+                              (xdrproc_t)xdr_gf_getspec_req);
 
 out:
-        GF_FREE (req.xdata.xdata_val);
-        if (dict)
-                dict_unref (dict);
-        if (ret && frame) {
-                /* Free the frame->local fast, because we have not used memget
-                 */
-                GF_FREE (frame->local);
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
-        }
+    GF_FREE(req.xdata.xdata_val);
+    if (dict)
+        dict_unref(dict);
+    if (ret && frame) {
+        /* Free the frame->local fast, because we have not used memget
+         */
+        GF_FREE(frame->local);
+        frame->local = NULL;
+        STACK_DESTROY(frame->root);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_volfile_fetch (glusterfs_ctx_t *ctx)
+glusterfs_volfile_fetch(glusterfs_ctx_t *ctx)
 {
-        xlator_t        *server_xl      = NULL;
-        xlator_list_t   *trav;
-        int             ret;
+    xlator_t *server_xl = NULL;
+    xlator_list_t *trav;
+    int ret;
 
-        LOCK (&ctx->volfile_lock);
-        {
-                if (ctx->active) {
-                        server_xl = ctx->active->first;
-                        if (strcmp (server_xl->type, "protocol/server") != 0) {
-                                server_xl = NULL;
-                        }
-                }
-                if (!server_xl) {
-                        /* Startup (ctx->active not set) or non-server. */
-                        UNLOCK (&ctx->volfile_lock);
-                        return glusterfs_volfile_fetch_one
-                                (ctx, ctx->cmd_args.volfile_id);
-                }
+    LOCK(&ctx->volfile_lock);
+    {
+        if (ctx->active) {
+            server_xl = ctx->active->first;
+            if (strcmp(server_xl->type, "protocol/server") != 0) {
+                server_xl = NULL;
+            }
+        }
+        if (!server_xl) {
+            /* Startup (ctx->active not set) or non-server. */
+            UNLOCK(&ctx->volfile_lock);
+            return glusterfs_volfile_fetch_one(ctx, ctx->cmd_args.volfile_id);
+        }
 
-                ret = 0;
-                for (trav = server_xl->children; trav; trav = trav->next) {
-                        ret |= glusterfs_volfile_fetch_one
-                                (ctx, trav->xlator->volfile_id);
-                }
+        ret = 0;
+        for (trav = server_xl->children; trav; trav = trav->next) {
+            ret |= glusterfs_volfile_fetch_one(ctx, trav->xlator->volfile_id);
         }
-        UNLOCK (&ctx->volfile_lock);
-        return ret;
+    }
+    UNLOCK(&ctx->volfile_lock);
+    return ret;
 }
 
-
 int32_t
-mgmt_event_notify_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                  void *myframe)
+mgmt_event_notify_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-        gf_event_notify_rsp      rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        int                      ret   = 0;
+    gf_event_notify_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        frame = myframe;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
 
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the rsp from server");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the rsp from server");
+        ret = -1;
+        goto out;
+    }
 out:
-        free (rsp.dict.dict_val); //malloced by xdr
-        return ret;
-
+    free(rsp.dict.dict_val);  // malloced by xdr
+    return ret;
 }
 
 int32_t
-glusterfs_rebalance_event_notify_cbk (struct rpc_req *req, struct iovec *iov,
-                                      int count, void *myframe)
+glusterfs_rebalance_event_notify_cbk(struct rpc_req *req, struct iovec *iov,
+                                     int count, void *myframe)
 {
-        gf_event_notify_rsp      rsp   = {0,};
-        call_frame_t            *frame = NULL;
-        int                      ret   = 0;
+    gf_event_notify_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        frame = myframe;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to get the rsp from server");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to get the rsp from server");
+        ret = -1;
+        goto out;
+    }
 
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
-                ret   = -1;
-                goto out;
-        }
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decoding error");
+        ret = -1;
+        goto out;
+    }
 
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "Received error (%s) from server",
-                        strerror (rsp.op_errno));
-                ret = -1;
-                goto out;
-        }
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "Received error (%s) from server", strerror(rsp.op_errno));
+        ret = -1;
+        goto out;
+    }
 out:
-        free (rsp.dict.dict_val); //malloced by xdr
+    free(rsp.dict.dict_val);  // malloced by xdr
 
-        if (frame) {
-                STACK_DESTROY (frame->root);
-        }
-
-        return ret;
+    if (frame) {
+        STACK_DESTROY(frame->root);
+    }
 
+    return ret;
 }
 
 int32_t
-glusterfs_rebalance_event_notify (dict_t *dict)
+glusterfs_rebalance_event_notify(dict_t *dict)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        gf_event_notify_req      req = {0,};
-        int32_t                  ret = -1;
-        cmd_args_t              *cmd_args = NULL;
-        call_frame_t            *frame = NULL;
-
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_event_notify_req req = {
+        0,
+    };
+    int32_t ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    call_frame_t *frame = NULL;
 
-        frame = create_frame (THIS, ctx->pool);
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
 
-        req.op = GF_EN_DEFRAG_STATUS;
+    frame = create_frame(THIS, ctx->pool);
 
-        if (dict) {
-                ret = dict_set_str (dict, "volname", cmd_args->volfile_id);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "failed to set volname");
-                }
-                ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
-                                                   &req.dict.dict_len);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "failed to serialize dict");
-                }
+    req.op = GF_EN_DEFRAG_STATUS;
 
+    if (dict) {
+        ret = dict_set_str(dict, "volname", cmd_args->volfile_id);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "failed to set volname");
+        }
+        ret = dict_allocate_and_serialize(dict, &req.dict.dict_val,
+                                          &req.dict.dict_len);
+        if (ret) {
+            gf_log("", GF_LOG_ERROR, "failed to serialize dict");
         }
+    }
 
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog,
-                                   GF_HNDSK_EVENT_NOTIFY,
-                                   glusterfs_rebalance_event_notify_cbk,
-                                   (xdrproc_t)xdr_gf_event_notify_req);
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_handshake_prog,
+                              GF_HNDSK_EVENT_NOTIFY,
+                              glusterfs_rebalance_event_notify_cbk,
+                              (xdrproc_t)xdr_gf_event_notify_req);
 
-        GF_FREE (req.dict.dict_val);
-        return ret;
+    GF_FREE(req.dict.dict_val);
+    return ret;
 }
 
 static int
-mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
-                 void *data)
+mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
+                void *data)
 {
-        xlator_t         *this = NULL;
-        glusterfs_ctx_t  *ctx = NULL;
-        int              ret = 0;
-        server_cmdline_t *server = NULL;
-        rpc_transport_t  *rpc_trans = NULL;
-        int              need_term = 0;
-        int              emval = 0;
-        static           int log_ctr1;
-        static           int log_ctr2;
-        struct dnscache6 *dnscache = NULL;
-
-        this = mydata;
-        rpc_trans = rpc->conn.trans;
-        ctx = this->ctx;
-
-        switch (event) {
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = 0;
+    server_cmdline_t *server = NULL;
+    rpc_transport_t *rpc_trans = NULL;
+    int need_term = 0;
+    int emval = 0;
+    static int log_ctr1;
+    static int log_ctr2;
+    struct dnscache6 *dnscache = NULL;
+
+    this = mydata;
+    rpc_trans = rpc->conn.trans;
+    ctx = this->ctx;
+
+    switch (event) {
         case RPC_CLNT_DISCONNECT:
-                if (rpc_trans->connect_failed) {
-                        GF_LOG_OCCASIONALLY (log_ctr1, "glusterfsd-mgmt",
-                                             GF_LOG_ERROR,
-                                             "failed to connect to remote-"
-                                             "host: %s",
-                                             ctx->cmd_args.volfile_server);
-                } else {
-                        GF_LOG_OCCASIONALLY (log_ctr1, "glusterfsd-mgmt",
-                                             GF_LOG_INFO,
-                                             "disconnected from remote-"
-                                             "host: %s",
-                                             ctx->cmd_args.volfile_server);
-                }
-
-                if (!rpc->disabled) {
-                        /*
-                         * Check if dnscache is exhausted for current server
-                         * and continue until cache is exhausted
-                         */
-                        dnscache = rpc_trans->dnscache;
-                        if (dnscache && dnscache->next) {
-                                break;
-                        }
+            if (rpc_trans->connect_failed) {
+                GF_LOG_OCCASIONALLY(log_ctr1, "glusterfsd-mgmt", GF_LOG_ERROR,
+                                    "failed to connect to remote-"
+                                    "host: %s",
+                                    ctx->cmd_args.volfile_server);
+            } else {
+                GF_LOG_OCCASIONALLY(log_ctr1, "glusterfsd-mgmt", GF_LOG_INFO,
+                                    "disconnected from remote-"
+                                    "host: %s",
+                                    ctx->cmd_args.volfile_server);
+            }
+
+            if (!rpc->disabled) {
+                /*
+                 * Check if dnscache is exhausted for current server
+                 * and continue until cache is exhausted
+                 */
+                dnscache = rpc_trans->dnscache;
+                if (dnscache && dnscache->next) {
+                    break;
                 }
-                server = ctx->cmd_args.curr_server;
-                if (server->list.next == &ctx->cmd_args.volfile_servers) {
-                        if (!ctx->active) {
-                                need_term = 1;
-                        }
-                        emval = ENOTCONN;
-                        GF_LOG_OCCASIONALLY (log_ctr2, "glusterfsd-mgmt",
-                                             GF_LOG_INFO,
-                                             "Exhausted all volfile servers");
-                        break;
+            }
+            server = ctx->cmd_args.curr_server;
+            if (server->list.next == &ctx->cmd_args.volfile_servers) {
+                if (!ctx->active) {
+                    need_term = 1;
                 }
-                server = list_entry (server->list.next, typeof(*server), list);
-                ctx->cmd_args.curr_server = server;
-                ctx->cmd_args.volfile_server = server->volfile_server;
-
-                ret = dict_set_str (rpc_trans->options, "remote-host",
-                                    server->volfile_server);
-                if (ret != 0) {
-                        gf_log ("glusterfsd-mgmt", GF_LOG_ERROR,
-                                "failed to set remote-host: %s",
-                                server->volfile_server);
-                        if (!ctx->active) {
-                                need_term = 1;
-                        }
-                        emval = ENOTCONN;
-                        break;
+                emval = ENOTCONN;
+                GF_LOG_OCCASIONALLY(log_ctr2, "glusterfsd-mgmt", GF_LOG_INFO,
+                                    "Exhausted all volfile servers");
+                break;
+            }
+            server = list_entry(server->list.next, typeof(*server), list);
+            ctx->cmd_args.curr_server = server;
+            ctx->cmd_args.volfile_server = server->volfile_server;
+
+            ret = dict_set_str(rpc_trans->options, "remote-host",
+                               server->volfile_server);
+            if (ret != 0) {
+                gf_log("glusterfsd-mgmt", GF_LOG_ERROR,
+                       "failed to set remote-host: %s", server->volfile_server);
+                if (!ctx->active) {
+                    need_term = 1;
                 }
-                gf_log ("glusterfsd-mgmt", GF_LOG_INFO,
-                        "connecting to next volfile server %s",
-                        server->volfile_server);
+                emval = ENOTCONN;
                 break;
+            }
+            gf_log("glusterfsd-mgmt", GF_LOG_INFO,
+                   "connecting to next volfile server %s",
+                   server->volfile_server);
+            break;
         case RPC_CLNT_CONNECT:
-                ret = glusterfs_volfile_fetch (ctx);
-                if (ret) {
-                        emval = ret;
-                        if (!ctx->active) {
-                                need_term = 1;
-                                gf_log ("glusterfsd-mgmt", GF_LOG_ERROR,
-                                        "failed to fetch volume file (key:%s)",
-                                        ctx->cmd_args.volfile_id);
-                                break;
-
-                        }
+            ret = glusterfs_volfile_fetch(ctx);
+            if (ret) {
+                emval = ret;
+                if (!ctx->active) {
+                    need_term = 1;
+                    gf_log("glusterfsd-mgmt", GF_LOG_ERROR,
+                           "failed to fetch volume file (key:%s)",
+                           ctx->cmd_args.volfile_id);
+                    break;
                 }
+            }
 
-                if (is_mgmt_rpc_reconnect)
-                        glusterfs_mgmt_pmap_signin (ctx);
+            if (is_mgmt_rpc_reconnect)
+                glusterfs_mgmt_pmap_signin(ctx);
 
-                break;
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        if (need_term) {
-                emancipate (ctx, emval);
-                cleanup_and_exit (1);
-        }
+    if (need_term) {
+        emancipate(ctx, emval);
+        cleanup_and_exit(1);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_rpcsvc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
-                     void *data)
+glusterfs_rpcsvc_notify(rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
+                        void *data)
 {
-        if (!xl || !data) {
-                goto out;
-        }
+    if (!xl || !data) {
+        goto out;
+    }
 
-        switch (event) {
-        case RPCSVC_EVENT_ACCEPT:
-        {
-                break;
+    switch (event) {
+        case RPCSVC_EVENT_ACCEPT: {
+            break;
         }
-        case RPCSVC_EVENT_DISCONNECT:
-        {
-                break;
+        case RPCSVC_EVENT_DISCONNECT: {
+            break;
         }
 
         default:
-                break;
-        }
+            break;
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_listener_init (glusterfs_ctx_t *ctx)
+glusterfs_listener_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t              *cmd_args = NULL;
-        rpcsvc_t                *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    rpcsvc_t *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (ctx->listener)
-                return 0;
+    if (ctx->listener)
+        return 0;
 
-        if (!cmd_args->sock_file)
-                return 0;
+    if (!cmd_args->sock_file)
+        return 0;
 
-        ret = rpcsvc_transport_unix_options_build (&options,
-                                                   cmd_args->sock_file);
-        if (ret)
-                goto out;
+    ret = rpcsvc_transport_unix_options_build(&options, cmd_args->sock_file);
+    if (ret)
+        goto out;
 
-        rpc = rpcsvc_init (THIS, ctx, options, 8);
-        if (rpc == NULL) {
-                goto out;
-        }
+    rpc = rpcsvc_init(THIS, ctx, options, 8);
+    if (rpc == NULL) {
+        goto out;
+    }
 
-        ret = rpcsvc_register_notify (rpc, glusterfs_rpcsvc_notify, THIS);
-        if (ret) {
-                goto out;
-        }
+    ret = rpcsvc_register_notify(rpc, glusterfs_rpcsvc_notify, THIS);
+    if (ret) {
+        goto out;
+    }
 
-        ret = rpcsvc_create_listeners (rpc, options, "glusterfsd");
-        if (ret < 1) {
-                goto out;
-        }
+    ret = rpcsvc_create_listeners(rpc, options, "glusterfsd");
+    if (ret < 1) {
+        goto out;
+    }
 
-        ret = rpcsvc_program_register (rpc, &glusterfs_mop_prog, _gf_false);
-        if (ret) {
-                goto out;
-        }
+    ret = rpcsvc_program_register(rpc, &glusterfs_mop_prog, _gf_false);
+    if (ret) {
+        goto out;
+    }
 
-        ctx->listener = rpc;
+    ctx->listener = rpc;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_listener_stop (glusterfs_ctx_t *ctx)
+glusterfs_listener_stop(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t              *cmd_args = NULL;
-        rpcsvc_t                *rpc = NULL;
-        rpcsvc_listener_t       *listener = NULL;
-        rpcsvc_listener_t       *next = NULL;
-        int                     ret = 0;
-        xlator_t                *this = NULL;
+    cmd_args_t *cmd_args = NULL;
+    rpcsvc_t *rpc = NULL;
+    rpcsvc_listener_t *listener = NULL;
+    rpcsvc_listener_t *next = NULL;
+    int ret = 0;
+    xlator_t *this = NULL;
 
-        GF_ASSERT (ctx);
+    GF_ASSERT(ctx);
 
-        rpc = ctx->listener;
-        ctx->listener = NULL;
+    rpc = ctx->listener;
+    ctx->listener = NULL;
 
-        (void) rpcsvc_program_unregister(rpc, &glusterfs_mop_prog);
+    (void)rpcsvc_program_unregister(rpc, &glusterfs_mop_prog);
 
-        list_for_each_entry_safe (listener, next, &rpc->listeners, list) {
-                rpcsvc_listener_destroy (listener);
-        }
+    list_for_each_entry_safe(listener, next, &rpc->listeners, list)
+    {
+        rpcsvc_listener_destroy(listener);
+    }
 
-        (void) rpcsvc_unregister_notify (rpc, glusterfs_rpcsvc_notify, THIS);
+    (void)rpcsvc_unregister_notify(rpc, glusterfs_rpcsvc_notify, THIS);
 
-        GF_FREE (rpc);
+    GF_FREE(rpc);
 
-        cmd_args = &ctx->cmd_args;
-        if (cmd_args->sock_file) {
-                ret = sys_unlink (cmd_args->sock_file);
-                if (ret && (ENOENT == errno)) {
-                        ret = 0;
-                }
+    cmd_args = &ctx->cmd_args;
+    if (cmd_args->sock_file) {
+        ret = sys_unlink(cmd_args->sock_file);
+        if (ret && (ENOENT == errno)) {
+            ret = 0;
         }
+    }
 
-        if (ret) {
-                this = THIS;
-                gf_log (this->name, GF_LOG_ERROR, "Failed to unlink listener "
-                        "socket %s, error: %s", cmd_args->sock_file,
-                        strerror (errno));
-        }
-        return ret;
+    if (ret) {
+        this = THIS;
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to unlink listener "
+               "socket %s, error: %s",
+               cmd_args->sock_file, strerror(errno));
+    }
+    return ret;
 }
 
 int
-glusterfs_mgmt_notify (int32_t op, void *data, ...)
+glusterfs_mgmt_notify(int32_t op, void *data, ...)
 {
-        int ret = 0;
-        switch (op)
-        {
-                case GF_EN_DEFRAG_STATUS:
-                        ret = glusterfs_rebalance_event_notify ((dict_t*) data);
-                        break;
+    int ret = 0;
+    switch (op) {
+        case GF_EN_DEFRAG_STATUS:
+            ret = glusterfs_rebalance_event_notify((dict_t *)data);
+            break;
 
-                default:
-                        gf_log ("", GF_LOG_ERROR, "Invalid op");
-                        break;
-        }
+        default:
+            gf_log("", GF_LOG_ERROR, "Invalid op");
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_mgmt_init (glusterfs_ctx_t *ctx)
+glusterfs_mgmt_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t              *cmd_args = NULL;
-        struct rpc_clnt         *rpc = NULL;
-        dict_t                  *options = NULL;
-        int                     ret = -1;
-        int                     port = GF_DEFAULT_BASE_PORT;
-        char                    *host = NULL;
+    cmd_args_t *cmd_args = NULL;
+    struct rpc_clnt *rpc = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    int port = GF_DEFAULT_BASE_PORT;
+    char *host = NULL;
 
-        cmd_args = &ctx->cmd_args;
-        GF_VALIDATE_OR_GOTO (THIS->name, cmd_args->volfile_server, out);
+    cmd_args = &ctx->cmd_args;
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args->volfile_server, out);
 
-        if (ctx->mgmt)
-                return 0;
-
-        LOCK_INIT (&ctx->volfile_lock);
-
-        if (cmd_args->volfile_server_port)
-                port = cmd_args->volfile_server_port;
-
-        host = cmd_args->volfile_server;
+    if (ctx->mgmt)
+        return 0;
 
-        if (cmd_args->volfile_server_transport &&
-            !strcmp (cmd_args->volfile_server_transport, "unix")) {
-                ret = rpc_transport_unix_options_build (&options, host, 0);
-        } else {
-                ret = rpc_transport_inet_options_build (&options, host, port);
-        }
-        if (ret)
-                goto out;
+    LOCK_INIT(&ctx->volfile_lock);
 
-        /* Explicitly turn on encrypted transport. */
-        if (ctx->secure_mgmt) {
-                ret = dict_set_dynstr_with_alloc
-                        (options, "transport.socket.ssl-enabled", "yes");
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR,
-                                "failed to set 'transport.socket.ssl-enabled' "
-                                "in options dict");
-                        goto out;
+    if (cmd_args->volfile_server_port)
+        port = cmd_args->volfile_server_port;
 
-                }
+    host = cmd_args->volfile_server;
 
-                ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "unix")) {
+        ret = rpc_transport_unix_options_build(&options, host, 0);
+    } else {
+        ret = rpc_transport_inet_options_build(&options, host, port);
+    }
+    if (ret)
+        goto out;
 
-        rpc = rpc_clnt_new (options, THIS, THIS->name, 8);
-        if (!rpc) {
-                ret = -1;
-                gf_log (THIS->name, GF_LOG_WARNING, "failed to create rpc clnt");
-                goto out;
-        }
-
-        ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS);
+    /* Explicitly turn on encrypted transport. */
+    if (ctx->secure_mgmt) {
+        ret = dict_set_dynstr_with_alloc(options,
+                                         "transport.socket.ssl-enabled", "yes");
         if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to register notify function");
-                goto out;
+            gf_log(THIS->name, GF_LOG_ERROR,
+                   "failed to set 'transport.socket.ssl-enabled' "
+                   "in options dict");
+            goto out;
         }
 
-        ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to register callback function");
-                goto out;
-        }
-
-        ctx->notify = glusterfs_mgmt_notify;
-
-        /* This value should be set before doing the 'rpc_clnt_start()' as
-           the notify function uses this variable */
-        ctx->mgmt = rpc;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
 
-        ret = rpc_clnt_start (rpc);
+    rpc = rpc_clnt_new(options, THIS, THIS->name, 8);
+    if (!rpc) {
+        ret = -1;
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create rpc clnt");
+        goto out;
+    }
+
+    ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to register notify function");
+        goto out;
+    }
+
+    ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to register callback function");
+        goto out;
+    }
+
+    ctx->notify = glusterfs_mgmt_notify;
+
+    /* This value should be set before doing the 'rpc_clnt_start()' as
+       the notify function uses this variable */
+    ctx->mgmt = rpc;
+
+    ret = rpc_clnt_start(rpc);
 out:
-        return ret;
+    return ret;
 }
 
 static int
-mgmt_pmap_signin2_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
+mgmt_pmap_signin2_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-        pmap_signin_rsp  rsp   = {0,};
-        glusterfs_ctx_t *ctx   = NULL;
-        call_frame_t    *frame = NULL;
-        int              ret   = 0;
+    pmap_signin_rsp rsp = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    call_frame_t *frame = NULL;
+    int ret = 0;
 
-        ctx = glusterfsd_ctx;
-        frame = myframe;
+    ctx = glusterfsd_ctx;
+    frame = myframe;
 
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decode error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                ret = -1;
-                goto out;
-        }
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decode error");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (need_emancipate)
-                emancipate (ctx, ret);
-
-        STACK_DESTROY (frame->root);
-        return 0;
+    if (need_emancipate)
+        emancipate(ctx, ret);
 
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static int
-mgmt_pmap_signin_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
+mgmt_pmap_signin_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
 {
-        pmap_signin_rsp  rsp   = {0,};
-        call_frame_t    *frame = NULL;
-        int              ret   = 0;
-        int              emancipate_ret  = -1;
-        pmap_signin_req  pmap_req = {0, };
-        cmd_args_t      *cmd_args = NULL;
-        glusterfs_ctx_t *ctx      = NULL;
-        char             brick_name[PATH_MAX] = {0,};
-
-        frame = myframe;
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
-
-
-        if (-1 == req->rpc_status) {
-                ret = -1;
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
-        if (ret < 0) {
-                gf_log (frame->this->name, GF_LOG_ERROR, "XDR decode error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (frame->this->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                ret = -1;
-                goto out;
-        }
+    pmap_signin_rsp rsp = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    int ret = 0;
+    int emancipate_ret = -1;
+    pmap_signin_req pmap_req = {
+        0,
+    };
+    cmd_args_t *cmd_args = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+
+    frame = myframe;
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
+
+    if (-1 == req->rpc_status) {
+        ret = -1;
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signin_rsp);
+    if (ret < 0) {
+        gf_log(frame->this->name, GF_LOG_ERROR, "XDR decode error");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(frame->this->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        ret = -1;
+        goto out;
+    }
 
-        if (!cmd_args->brick_port2) {
-                /* We are done with signin process */
-                emancipate_ret = 0;
-                goto out;
-        }
+    if (!cmd_args->brick_port2) {
+        /* We are done with signin process */
+        emancipate_ret = 0;
+        goto out;
+    }
 
-        snprintf (brick_name, PATH_MAX, "%s.rdma", cmd_args->brick_name);
-        pmap_req.port  = cmd_args->brick_port2;
-        pmap_req.brick = brick_name;
+    snprintf(brick_name, PATH_MAX, "%s.rdma", cmd_args->brick_name);
+    pmap_req.port = cmd_args->brick_port2;
+    pmap_req.brick = brick_name;
 
-        ret = mgmt_submit_request (&pmap_req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNIN, mgmt_pmap_signin2_cbk,
-                                   (xdrproc_t)xdr_pmap_signin_req);
-        if (ret)
-                goto out;
+    ret = mgmt_submit_request(&pmap_req, frame, ctx, &clnt_pmap_prog,
+                              GF_PMAP_SIGNIN, mgmt_pmap_signin2_cbk,
+                              (xdrproc_t)xdr_pmap_signin_req);
+    if (ret)
+        goto out;
 
-        return 0;
+    return 0;
 
 out:
-        if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
-                emancipate (ctx, emancipate_ret);
+    if (need_emancipate && (ret < 0 || !cmd_args->brick_port2))
+        emancipate(ctx, emancipate_ret);
 
-        STACK_DESTROY (frame->root);
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 int
-glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx)
+glusterfs_mgmt_pmap_signin(glusterfs_ctx_t *ctx)
 {
-        call_frame_t     *frame                 = NULL;
-        pmap_signin_req   req                   = {0, };
-        int               ret                   = -1;
-        int               emancipate_ret        = -1;
-        cmd_args_t       *cmd_args              = NULL;
-        char              brick_name[PATH_MAX]  = {0,};
-
-        frame = create_frame (THIS, ctx->pool);
-        cmd_args = &ctx->cmd_args;
-
-        if (!cmd_args->brick_port || !cmd_args->brick_name) {
-                gf_log ("fsd-mgmt", GF_LOG_DEBUG,
-                        "portmapper signin arguments not given");
-                emancipate_ret = 0;
-                goto out;
-        }
-
-        if (cmd_args->volfile_server_transport &&
-                      !strcmp(cmd_args->volfile_server_transport, "rdma")) {
-                snprintf (brick_name, sizeof(brick_name), "%s.rdma",
-                          cmd_args->brick_name);
-                req.brick = brick_name;
-        } else
-                req.brick = cmd_args->brick_name;
-
-        req.port  = cmd_args->brick_port;
-
-        ret = mgmt_submit_request (&req, frame, ctx, &clnt_pmap_prog,
-                                   GF_PMAP_SIGNIN, mgmt_pmap_signin_cbk,
-                                   (xdrproc_t)xdr_pmap_signin_req);
+    call_frame_t *frame = NULL;
+    pmap_signin_req req = {
+        0,
+    };
+    int ret = -1;
+    int emancipate_ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+
+    frame = create_frame(THIS, ctx->pool);
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args->brick_port || !cmd_args->brick_name) {
+        gf_log("fsd-mgmt", GF_LOG_DEBUG,
+               "portmapper signin arguments not given");
+        emancipate_ret = 0;
+        goto out;
+    }
+
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "rdma")) {
+        snprintf(brick_name, sizeof(brick_name), "%s.rdma",
+                 cmd_args->brick_name);
+        req.brick = brick_name;
+    } else
+        req.brick = cmd_args->brick_name;
+
+    req.port = cmd_args->brick_port;
+
+    ret = mgmt_submit_request(&req, frame, ctx, &clnt_pmap_prog, GF_PMAP_SIGNIN,
+                              mgmt_pmap_signin_cbk,
+                              (xdrproc_t)xdr_pmap_signin_req);
 
 out:
-        if (need_emancipate && ret < 0)
-                emancipate (ctx, emancipate_ret);
-        return ret;
+    if (need_emancipate && ret < 0)
+        emancipate(ctx, emancipate_ret);
+    return ret;
 }
-
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
index f374a2af22f..6e61a66c6d1 100644
--- a/glusterfsd/src/glusterfsd.c
+++ b/glusterfsd/src/glusterfsd.c
@@ -37,9 +37,9 @@
 #include <linux/oom.h>
 #else
 #define OOM_SCORE_ADJ_MIN (-1000)
-#define OOM_SCORE_ADJ_MAX   1000
-#define OOM_DISABLE       (-17)
-#define OOM_ADJUST_MAX      15
+#define OOM_SCORE_ADJ_MAX 1000
+#define OOM_DISABLE (-17)
+#define OOM_ADJUST_MAX 15
 #endif
 #endif
 
@@ -80,1485 +80,1445 @@
 
 #include "daemon.h"
 
-
 /* using argp for command line parsing */
 static char gf_doc[] = "";
-static char argp_doc[] = "--volfile-server=SERVER [MOUNT-POINT]\n"       \
-        "--volfile=VOLFILE [MOUNT-POINT]";
-const char *argp_program_version = ""                                         \
-        PACKAGE_NAME" "PACKAGE_VERSION                                        \
-        "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n"          \
-        "Copyright (c) 2006-2016 Red Hat, Inc. "                              \
-        "<https://www.gluster.org/>\n"                                        \
-        "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"                      \
-        "It is licensed to you under your choice of the GNU Lesser\n"         \
-        "General Public License, version 3 or any later version (LGPLv3\n"    \
-        "or later), or the GNU General Public License, version 2 (GPLv2),\n"  \
-        "in all cases as published by the Free Software Foundation.";
+static char argp_doc[] =
+    "--volfile-server=SERVER [MOUNT-POINT]\n"
+    "--volfile=VOLFILE [MOUNT-POINT]";
+const char *argp_program_version =
+    "" PACKAGE_NAME " " PACKAGE_VERSION
+    "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION
+    "\n"
+    "Copyright (c) 2006-2016 Red Hat, Inc. "
+    "<https://www.gluster.org/>\n"
+    "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"
+    "It is licensed to you under your choice of the GNU Lesser\n"
+    "General Public License, version 3 or any later version (LGPLv3\n"
+    "or later), or the GNU General Public License, version 2 (GPLv2),\n"
+    "in all cases as published by the Free Software Foundation.";
 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 
-static error_t parse_opts (int32_t key, char *arg, struct argp_state *_state);
+static error_t
+parse_opts(int32_t key, char *arg, struct argp_state *_state);
 
 static struct argp_option gf_options[] = {
-        {0, 0, 0, 0, "Basic options:"},
-        {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
-         "Server to get the volume file from. Unix domain socket path when "
-         "transport type 'unix'. This option overrides --volfile option"},
-        {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
-         "File to use as VOLUME_FILE"},
-        {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
-         "File to use as VOLUME FILE"},
-
-        {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
-         "Logging severity.  Valid options are DEBUG, INFO, WARNING, ERROR, "
-         "CRITICAL, TRACE and NONE [default: INFO]"},
-        {"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
-         "File to use for logging [default: "
-         DEFAULT_LOG_FILE_DIRECTORY "/" PACKAGE_NAME ".log" "]"},
-        {"logger", ARGP_LOGGER, "LOGGER", 0, "Set which logging sub-system to "
-        "log to, valid options are: gluster-log and syslog, "
-        "[default: \"gluster-log\"]"},
-        {"log-format", ARGP_LOG_FORMAT, "LOG-FORMAT", 0, "Set log format, valid"
-         " options are: no-msg-id and with-msg-id, [default: \"with-msg-id\"]"},
-        {"log-buf-size", ARGP_LOG_BUF_SIZE, "LOG-BUF-SIZE", 0, "Set logging "
-         "buffer size, [default: 5]"},
-        {"log-flush-timeout", ARGP_LOG_FLUSH_TIMEOUT, "LOG-FLUSH-TIMEOUT", 0,
-         "Set log flush timeout, [default: 2 minutes]"},
-
-        {0, 0, 0, 0, "Advanced Options:"},
-        {"volfile-server-port", ARGP_VOLFILE_SERVER_PORT_KEY, "PORT", 0,
-         "Listening port number of volfile server"},
-        {"volfile-server-transport", ARGP_VOLFILE_SERVER_TRANSPORT_KEY,
-         "TRANSPORT", 0,
-         "Transport type to get volfile from server [default: socket]"},
-        {"volfile-id", ARGP_VOLFILE_ID_KEY, "KEY", 0,
-         "'key' of the volfile to be fetched from server"},
-        {"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0,
-         "File to use as pid file"},
-        {"socket-file", ARGP_SOCK_FILE_KEY, "SOCKFILE", 0,
-         "File to use as unix-socket"},
-        {"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0,
-         "Run in foreground"},
-        {"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
-         "Run ID for the process, used by scripts to keep track of process "
-         "they started, defaults to none"},
-        {"debug", ARGP_DEBUG_KEY, 0, 0,
-         "Run in debug mode.  This option sets --no-daemon, --log-level "
-         "to DEBUG and --log-file to console"},
-        {"volume-name", ARGP_VOLUME_NAME_KEY, "XLATOR-NAME", 0,
-         "Translator name to be used for MOUNT-POINT [default: top most volume "
-         "definition in VOLFILE]"},
-        {"xlator-option", ARGP_XLATOR_OPTION_KEY,"XLATOR-NAME.OPTION=VALUE", 0,
-         "Add/override an option for a translator in volume file with specified"
-         " value"},
-        {"read-only", ARGP_READ_ONLY_KEY, 0, 0,
-         "Mount the filesystem in 'read-only' mode"},
-        {"acl", ARGP_ACL_KEY, 0, 0,
-         "Mount the filesystem with POSIX ACL support"},
-        {"selinux", ARGP_SELINUX_KEY, 0, 0,
-         "Enable SELinux label (extended attributes) support on inodes"},
-        {"capability", ARGP_CAPABILITY_KEY, 0, 0,
-         "Enable Capability (extended attributes) support on inodes"},
-        {"subdir-mount", ARGP_SUBDIR_MOUNT_KEY, "SUBDIR-PATH", 0,
-         "Mount subdirectory given [default: NULL]"},
-
-        {"print-netgroups", ARGP_PRINT_NETGROUPS, "NETGROUP-FILE", 0,
-         "Validate the netgroups file and print it out"},
-        {"print-exports", ARGP_PRINT_EXPORTS, "EXPORTS-FILE", 0,
-        "Validate the exports file and print it out"},
-        {"print-xlatordir", ARGP_PRINT_XLATORDIR_KEY, 0, OPTION_ARG_OPTIONAL,
-         "Print xlator directory path"},
-        {"print-statedumpdir", ARGP_PRINT_STATEDUMPDIR_KEY, 0,
-          OPTION_ARG_OPTIONAL,
-         "Print directory path in which statedumps shall be generated"},
-        {"print-logdir", ARGP_PRINT_LOGDIR_KEY, 0, OPTION_ARG_OPTIONAL,
-         "Print path of default log directory"},
-        {"print-libexecdir", ARGP_PRINT_LIBEXECDIR_KEY, 0, OPTION_ARG_OPTIONAL,
-         "Print path of default libexec directory"},
-
-        {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS, "0",
-         OPTION_HIDDEN, "Maximum number of attempts to fetch the volfile"},
-        {"aux-gfid-mount", ARGP_AUX_GFID_MOUNT_KEY, 0, 0,
-         "Enable access to filesystem through gfid directly"},
-        {"enable-ino32", ARGP_INODE32_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Use 32-bit inodes when mounting to workaround broken applications"
-         "that don't support 64-bit inodes"},
-        {"worm", ARGP_WORM_KEY, 0, 0,
-         "Mount the filesystem in 'worm' mode"},
-        {"mac-compat", ARGP_MAC_COMPAT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Provide stubs for attributes needed for seamless operation on Macs "
+    {0, 0, 0, 0, "Basic options:"},
+    {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
+     "Server to get the volume file from. Unix domain socket path when "
+     "transport type 'unix'. This option overrides --volfile option"},
+    {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
+     "File to use as VOLUME_FILE"},
+    {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
+     "File to use as VOLUME FILE"},
+
+    {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
+     "Logging severity.  Valid options are DEBUG, INFO, WARNING, ERROR, "
+     "CRITICAL, TRACE and NONE [default: INFO]"},
+    {"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
+     "File to use for logging [default: " DEFAULT_LOG_FILE_DIRECTORY
+     "/" PACKAGE_NAME ".log"
+     "]"},
+    {"logger", ARGP_LOGGER, "LOGGER", 0,
+     "Set which logging sub-system to "
+     "log to, valid options are: gluster-log and syslog, "
+     "[default: \"gluster-log\"]"},
+    {"log-format", ARGP_LOG_FORMAT, "LOG-FORMAT", 0,
+     "Set log format, valid"
+     " options are: no-msg-id and with-msg-id, [default: \"with-msg-id\"]"},
+    {"log-buf-size", ARGP_LOG_BUF_SIZE, "LOG-BUF-SIZE", 0,
+     "Set logging "
+     "buffer size, [default: 5]"},
+    {"log-flush-timeout", ARGP_LOG_FLUSH_TIMEOUT, "LOG-FLUSH-TIMEOUT", 0,
+     "Set log flush timeout, [default: 2 minutes]"},
+
+    {0, 0, 0, 0, "Advanced Options:"},
+    {"volfile-server-port", ARGP_VOLFILE_SERVER_PORT_KEY, "PORT", 0,
+     "Listening port number of volfile server"},
+    {"volfile-server-transport", ARGP_VOLFILE_SERVER_TRANSPORT_KEY, "TRANSPORT",
+     0, "Transport type to get volfile from server [default: socket]"},
+    {"volfile-id", ARGP_VOLFILE_ID_KEY, "KEY", 0,
+     "'key' of the volfile to be fetched from server"},
+    {"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0, "File to use as pid file"},
+    {"socket-file", ARGP_SOCK_FILE_KEY, "SOCKFILE", 0,
+     "File to use as unix-socket"},
+    {"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0, "Run in foreground"},
+    {"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
+     "Run ID for the process, used by scripts to keep track of process "
+     "they started, defaults to none"},
+    {"debug", ARGP_DEBUG_KEY, 0, 0,
+     "Run in debug mode.  This option sets --no-daemon, --log-level "
+     "to DEBUG and --log-file to console"},
+    {"volume-name", ARGP_VOLUME_NAME_KEY, "XLATOR-NAME", 0,
+     "Translator name to be used for MOUNT-POINT [default: top most volume "
+     "definition in VOLFILE]"},
+    {"xlator-option", ARGP_XLATOR_OPTION_KEY, "XLATOR-NAME.OPTION=VALUE", 0,
+     "Add/override an option for a translator in volume file with specified"
+     " value"},
+    {"read-only", ARGP_READ_ONLY_KEY, 0, 0,
+     "Mount the filesystem in 'read-only' mode"},
+    {"acl", ARGP_ACL_KEY, 0, 0, "Mount the filesystem with POSIX ACL support"},
+    {"selinux", ARGP_SELINUX_KEY, 0, 0,
+     "Enable SELinux label (extended attributes) support on inodes"},
+    {"capability", ARGP_CAPABILITY_KEY, 0, 0,
+     "Enable Capability (extended attributes) support on inodes"},
+    {"subdir-mount", ARGP_SUBDIR_MOUNT_KEY, "SUBDIR-PATH", 0,
+     "Mount subdirectory given [default: NULL]"},
+
+    {"print-netgroups", ARGP_PRINT_NETGROUPS, "NETGROUP-FILE", 0,
+     "Validate the netgroups file and print it out"},
+    {"print-exports", ARGP_PRINT_EXPORTS, "EXPORTS-FILE", 0,
+     "Validate the exports file and print it out"},
+    {"print-xlatordir", ARGP_PRINT_XLATORDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print xlator directory path"},
+    {"print-statedumpdir", ARGP_PRINT_STATEDUMPDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print directory path in which statedumps shall be generated"},
+    {"print-logdir", ARGP_PRINT_LOGDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print path of default log directory"},
+    {"print-libexecdir", ARGP_PRINT_LIBEXECDIR_KEY, 0, OPTION_ARG_OPTIONAL,
+     "Print path of default libexec directory"},
+
+    {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS, "0",
+     OPTION_HIDDEN, "Maximum number of attempts to fetch the volfile"},
+    {"aux-gfid-mount", ARGP_AUX_GFID_MOUNT_KEY, 0, 0,
+     "Enable access to filesystem through gfid directly"},
+    {"enable-ino32", ARGP_INODE32_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Use 32-bit inodes when mounting to workaround broken applications"
+     "that don't support 64-bit inodes"},
+    {"worm", ARGP_WORM_KEY, 0, 0, "Mount the filesystem in 'worm' mode"},
+    {"mac-compat", ARGP_MAC_COMPAT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Provide stubs for attributes needed for seamless operation on Macs "
 #ifdef GF_DARWIN_HOST_OS
-         "[default: \"on\" on client side, else \"off\"]"
+     "[default: \"on\" on client side, else \"off\"]"
 #else
-         "[default: \"off\"]"
+     "[default: \"off\"]"
 #endif
-        },
-        {"brick-name", ARGP_BRICK_NAME_KEY, "BRICK-NAME", OPTION_HIDDEN,
-         "Brick name to be registered with Gluster portmapper" },
-        {"brick-port", ARGP_BRICK_PORT_KEY, "BRICK-PORT", OPTION_HIDDEN,
-         "Brick Port to be registered with Gluster portmapper" },
-	{"fopen-keep-cache", ARGP_FOPEN_KEEP_CACHE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-	 "Do not purge the cache on file open"},
-        {"global-timer-wheel", ARGP_GLOBAL_TIMER_WHEEL, "BOOL",
-         OPTION_ARG_OPTIONAL, "Instantiate process global timer-wheel"},
-        {"thin-client", ARGP_THIN_CLIENT_KEY, 0, 0,
-         "Enables thin mount and connects via gfproxyd daemon"},
-
-        {0, 0, 0, 0, "Fuse options:"},
-        {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL|auto", OPTION_ARG_OPTIONAL,
-         "Specify direct I/O strategy [default: \"auto\"]"},
-        {"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
-         "Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
-        {"negative-timeout", ARGP_NEGATIVE_TIMEOUT_KEY, "SECONDS", 0,
-         "Set negative timeout to SECONDS in fuse kernel module [default: 0]"},
-        {"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
-         "Set attribute timeout to SECONDS for inodes in fuse kernel module "
-         "[default: 1]"},
-	{"gid-timeout", ARGP_GID_TIMEOUT_KEY, "SECONDS", 0,
-	 "Set auxiliary group list timeout to SECONDS for fuse translator "
-	 "[default: 300]"},
-        {"resolve-gids", ARGP_RESOLVE_GIDS_KEY, 0, 0,
-         "Resolve all auxiliary groups in fuse translator (max 32 otherwise)"},
-	{"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0,
-	 "Set fuse module's background queue length to N "
-	 "[default: 64]"},
-	{"congestion-threshold", ARGP_FUSE_CONGESTION_THRESHOLD_KEY, "N", 0,
-	 "Set fuse module's congestion threshold to N "
-	 "[default: 48]"},
+    },
+    {"brick-name", ARGP_BRICK_NAME_KEY, "BRICK-NAME", OPTION_HIDDEN,
+     "Brick name to be registered with Gluster portmapper"},
+    {"brick-port", ARGP_BRICK_PORT_KEY, "BRICK-PORT", OPTION_HIDDEN,
+     "Brick Port to be registered with Gluster portmapper"},
+    {"fopen-keep-cache", ARGP_FOPEN_KEEP_CACHE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Do not purge the cache on file open"},
+    {"global-timer-wheel", ARGP_GLOBAL_TIMER_WHEEL, "BOOL", OPTION_ARG_OPTIONAL,
+     "Instantiate process global timer-wheel"},
+    {"thin-client", ARGP_THIN_CLIENT_KEY, 0, 0,
+     "Enables thin mount and connects via gfproxyd daemon"},
+
+    {0, 0, 0, 0, "Fuse options:"},
+    {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL|auto",
+     OPTION_ARG_OPTIONAL, "Specify direct I/O strategy [default: \"auto\"]"},
+    {"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
+     "Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
+    {"negative-timeout", ARGP_NEGATIVE_TIMEOUT_KEY, "SECONDS", 0,
+     "Set negative timeout to SECONDS in fuse kernel module [default: 0]"},
+    {"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
+     "Set attribute timeout to SECONDS for inodes in fuse kernel module "
+     "[default: 1]"},
+    {"gid-timeout", ARGP_GID_TIMEOUT_KEY, "SECONDS", 0,
+     "Set auxiliary group list timeout to SECONDS for fuse translator "
+     "[default: 300]"},
+    {"resolve-gids", ARGP_RESOLVE_GIDS_KEY, 0, 0,
+     "Resolve all auxiliary groups in fuse translator (max 32 otherwise)"},
+    {"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0,
+     "Set fuse module's background queue length to N "
+     "[default: 64]"},
+    {"congestion-threshold", ARGP_FUSE_CONGESTION_THRESHOLD_KEY, "N", 0,
+     "Set fuse module's congestion threshold to N "
+     "[default: 48]"},
 #ifdef GF_LINUX_HOST_OS
-        {"oom-score-adj", ARGP_OOM_SCORE_ADJ_KEY, "INTEGER", 0,
-         "Set oom_score_adj value for process"
-         "[default: 0]"},
+    {"oom-score-adj", ARGP_OOM_SCORE_ADJ_KEY, "INTEGER", 0,
+     "Set oom_score_adj value for process"
+     "[default: 0]"},
 #endif
-        {"client-pid", ARGP_CLIENT_PID_KEY, "PID", OPTION_HIDDEN,
-         "client will authenticate itself with process id PID to server"},
-        {"no-root-squash", ARGP_FUSE_NO_ROOT_SQUASH_KEY, "BOOL",
-         OPTION_ARG_OPTIONAL, "disable/enable root squashing for the trusted "
-         "client"},
-        {"user-map-root", ARGP_USER_MAP_ROOT_KEY, "USER", OPTION_HIDDEN,
-         "replace USER with root in messages"},
-        {"dump-fuse", ARGP_DUMP_FUSE_KEY, "PATH", 0,
-         "Dump fuse traffic to PATH"},
-        {"volfile-check", ARGP_VOLFILE_CHECK_KEY, 0, 0,
-         "Enable strict volume file checking"},
-        {"no-mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN,
-         "disable internal memory accounting"},
-        {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN,
-         "Extra mount options to pass to FUSE"},
-        {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Use readdirp mode in fuse kernel module"
-         " [default: \"yes\"]"},
-        {"secure-mgmt", ARGP_SECURE_MGMT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
-         "Override default for secure (SSL) management connections"},
-        {"localtime-logging", ARGP_LOCALTIME_LOGGING_KEY, 0, 0,
-         "Enable localtime logging"},
-        {"process-name", ARGP_PROCESS_NAME_KEY, "PROCESS-NAME", OPTION_HIDDEN,
-         "option to specify the process type" },
-        {"event-history", ARGP_FUSE_EVENT_HISTORY_KEY, "BOOL",
-         OPTION_ARG_OPTIONAL, "disable/enable fuse event-history"},
-        {"reader-thread-count", ARGP_READER_THREAD_COUNT_KEY, "INTEGER",
-         OPTION_ARG_OPTIONAL, "set fuse reader thread count"},
-        {"kernel-writeback-cache", ARGP_KERNEL_WRITEBACK_CACHE_KEY, "BOOL",
-         OPTION_ARG_OPTIONAL, "enable fuse in-kernel writeback cache"},
-        {"attr-times-granularity", ARGP_ATTR_TIMES_GRANULARITY_KEY, "NS",
-         OPTION_ARG_OPTIONAL, "declare supported granularity of file attribute"
-         " times in nanoseconds"},
-        {0, 0, 0, 0, "Miscellaneous Options:"},
-        {0, }
-};
-
-
-static struct argp argp = { gf_options, parse_opts, argp_doc, gf_doc };
-
-
-int glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx);
-int glusterfs_volumes_init (glusterfs_ctx_t *ctx);
-int glusterfs_mgmt_init (glusterfs_ctx_t *ctx);
-int glusterfs_listener_init (glusterfs_ctx_t *ctx);
-int glusterfs_listener_stop (glusterfs_ctx_t *ctx);
+    {"client-pid", ARGP_CLIENT_PID_KEY, "PID", OPTION_HIDDEN,
+     "client will authenticate itself with process id PID to server"},
+    {"no-root-squash", ARGP_FUSE_NO_ROOT_SQUASH_KEY, "BOOL",
+     OPTION_ARG_OPTIONAL,
+     "disable/enable root squashing for the trusted "
+     "client"},
+    {"user-map-root", ARGP_USER_MAP_ROOT_KEY, "USER", OPTION_HIDDEN,
+     "replace USER with root in messages"},
+    {"dump-fuse", ARGP_DUMP_FUSE_KEY, "PATH", 0, "Dump fuse traffic to PATH"},
+    {"volfile-check", ARGP_VOLFILE_CHECK_KEY, 0, 0,
+     "Enable strict volume file checking"},
+    {"no-mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN,
+     "disable internal memory accounting"},
+    {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN,
+     "Extra mount options to pass to FUSE"},
+    {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Use readdirp mode in fuse kernel module"
+     " [default: \"yes\"]"},
+    {"secure-mgmt", ARGP_SECURE_MGMT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "Override default for secure (SSL) management connections"},
+    {"localtime-logging", ARGP_LOCALTIME_LOGGING_KEY, 0, 0,
+     "Enable localtime logging"},
+    {"process-name", ARGP_PROCESS_NAME_KEY, "PROCESS-NAME", OPTION_HIDDEN,
+     "option to specify the process type"},
+    {"event-history", ARGP_FUSE_EVENT_HISTORY_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+     "disable/enable fuse event-history"},
+    {"reader-thread-count", ARGP_READER_THREAD_COUNT_KEY, "INTEGER",
+     OPTION_ARG_OPTIONAL, "set fuse reader thread count"},
+    {"kernel-writeback-cache", ARGP_KERNEL_WRITEBACK_CACHE_KEY, "BOOL",
+     OPTION_ARG_OPTIONAL, "enable fuse in-kernel writeback cache"},
+    {"attr-times-granularity", ARGP_ATTR_TIMES_GRANULARITY_KEY, "NS",
+     OPTION_ARG_OPTIONAL,
+     "declare supported granularity of file attribute"
+     " times in nanoseconds"},
+    {0, 0, 0, 0, "Miscellaneous Options:"},
+    {
+        0,
+    }};
+
+static struct argp argp = {gf_options, parse_opts, argp_doc, gf_doc};
 
+int
+glusterfs_pidfile_cleanup(glusterfs_ctx_t *ctx);
+int
+glusterfs_volumes_init(glusterfs_ctx_t *ctx);
+int
+glusterfs_mgmt_init(glusterfs_ctx_t *ctx);
+int
+glusterfs_listener_init(glusterfs_ctx_t *ctx);
+int
+glusterfs_listener_stop(glusterfs_ctx_t *ctx);
 
 static int
-set_fuse_mount_options (glusterfs_ctx_t *ctx, dict_t *options)
+set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options)
 {
-        int              ret = 0;
-        cmd_args_t      *cmd_args = NULL;
-        char            *mount_point = NULL;
-        char            cwd[PATH_MAX] = {0,};
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    char *mount_point = NULL;
+    char cwd[PATH_MAX] = {
+        0,
+    };
+
+    cmd_args = &ctx->cmd_args;
+
+    /* Check if mount-point is absolute path,
+     * if not convert to absolute path by concatenating with CWD
+     */
+    if (cmd_args->mount_point[0] != '/') {
+        if (getcwd(cwd, PATH_MAX) != NULL) {
+            ret = gf_asprintf(&mount_point, "%s/%s", cwd,
+                              cmd_args->mount_point);
+            if (ret == -1) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_1,
+                       "Could not create absolute mountpoint "
+                       "path");
+                goto err;
+            }
+        } else {
+            gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_2,
+                   "Could not get current working directory");
+            goto err;
+        }
+    } else
+        mount_point = gf_strdup(cmd_args->mount_point);
 
-        cmd_args = &ctx->cmd_args;
+    ret = dict_set_dynstr(options, ZR_MOUNTPOINT_OPT, mount_point);
+    if (ret < 0) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3,
+               "failed to set mount-point to options dictionary");
+        goto err;
+    }
 
-        /* Check if mount-point is absolute path,
-         * if not convert to absolute path by concatenating with CWD
-         */
-        if (cmd_args->mount_point[0] != '/') {
-                if (getcwd (cwd, PATH_MAX) != NULL) {
-                        ret = gf_asprintf (&mount_point, "%s/%s", cwd,
-                                           cmd_args->mount_point);
-                        if (ret == -1) {
-                                gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                        glusterfsd_msg_1,
-                                        "Could not create absolute mountpoint "
-                                        "path");
-                                goto err;
-                        }
-                } else {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                glusterfsd_msg_2,
-                                "Could not get current working directory");
-                        goto err;
-                }
-        } else
-                mount_point = gf_strdup (cmd_args->mount_point);
+    if (cmd_args->fuse_attribute_timeout >= 0) {
+        ret = dict_set_double(options, ZR_ATTR_TIMEOUT_OPT,
+                              cmd_args->fuse_attribute_timeout);
 
-        ret = dict_set_dynstr (options, ZR_MOUNTPOINT_OPT, mount_point);
         if (ret < 0) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3,
-                        "failed to set mount-point to options dictionary");
-                goto err;
+            gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_4,
+                   "failed to set dict value "
+                   "for key " ZR_ATTR_TIMEOUT_OPT);
+            goto err;
         }
+    }
 
-        if (cmd_args->fuse_attribute_timeout >= 0) {
-                ret = dict_set_double (options, ZR_ATTR_TIMEOUT_OPT,
-                                       cmd_args->fuse_attribute_timeout);
+    if (cmd_args->fuse_entry_timeout >= 0) {
+        ret = dict_set_double(options, ZR_ENTRY_TIMEOUT_OPT,
+                              cmd_args->fuse_entry_timeout);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key " ZR_ENTRY_TIMEOUT_OPT);
+            goto err;
+        }
+    }
 
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, errno,
-                                glusterfsd_msg_4, "failed to set dict value "
-                                "for key " ZR_ATTR_TIMEOUT_OPT);
-                        goto err;
-                }
+    if (cmd_args->fuse_negative_timeout >= 0) {
+        ret = dict_set_double(options, ZR_NEGATIVE_TIMEOUT_OPT,
+                              cmd_args->fuse_negative_timeout);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key " ZR_NEGATIVE_TIMEOUT_OPT);
+            goto err;
         }
+    }
 
-        if (cmd_args->fuse_entry_timeout >= 0) {
-                ret = dict_set_double (options, ZR_ENTRY_TIMEOUT_OPT,
-                                       cmd_args->fuse_entry_timeout);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                ZR_ENTRY_TIMEOUT_OPT);
-                        goto err;
-                }
+    if (cmd_args->client_pid_set) {
+        ret = dict_set_int32(options, "client-pid", cmd_args->client_pid);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key client-pid");
+            goto err;
         }
+    }
 
-        if (cmd_args->fuse_negative_timeout >= 0) {
-                ret = dict_set_double (options, ZR_NEGATIVE_TIMEOUT_OPT,
-                                       cmd_args->fuse_negative_timeout);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                ZR_NEGATIVE_TIMEOUT_OPT);
-                        goto err;
-                }
+    if (cmd_args->uid_map_root) {
+        ret = dict_set_int32(options, "uid-map-root", cmd_args->uid_map_root);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "uid-map-root");
+            goto err;
         }
+    }
 
-        if (cmd_args->client_pid_set) {
-                ret = dict_set_int32 (options, "client-pid",
-                                      cmd_args->client_pid);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key client-pid");
-                        goto err;
-                }
+    if (cmd_args->volfile_check) {
+        ret = dict_set_int32(options, ZR_STRICT_VOLFILE_CHECK,
+                             cmd_args->volfile_check);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key " ZR_STRICT_VOLFILE_CHECK);
+            goto err;
         }
+    }
 
-        if (cmd_args->uid_map_root) {
-                ret = dict_set_int32 (options, "uid-map-root",
-                                      cmd_args->uid_map_root);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "uid-map-root");
-                        goto err;
-                }
+    if (cmd_args->dump_fuse) {
+        ret = dict_set_static_ptr(options, ZR_DUMP_FUSE, cmd_args->dump_fuse);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key " ZR_DUMP_FUSE);
+            goto err;
         }
+    }
 
-        if (cmd_args->volfile_check) {
-                ret = dict_set_int32 (options, ZR_STRICT_VOLFILE_CHECK,
-                                      cmd_args->volfile_check);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                ZR_STRICT_VOLFILE_CHECK);
-                        goto err;
-                }
+    if (cmd_args->acl) {
+        ret = dict_set_static_ptr(options, "acl", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key acl");
+            goto err;
         }
+    }
 
-        if (cmd_args->dump_fuse) {
-                ret = dict_set_static_ptr (options, ZR_DUMP_FUSE,
-                                           cmd_args->dump_fuse);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                ZR_DUMP_FUSE);
-                        goto err;
-                }
+    if (cmd_args->selinux) {
+        ret = dict_set_static_ptr(options, "selinux", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key selinux");
+            goto err;
         }
+    }
 
-        if (cmd_args->acl) {
-                ret = dict_set_static_ptr (options, "acl", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key acl");
-                        goto err;
-                }
+    if (cmd_args->capability) {
+        ret = dict_set_static_ptr(options, "capability", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key capability");
+            goto err;
         }
+    }
 
-        if (cmd_args->selinux) {
-                ret = dict_set_static_ptr (options, "selinux", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key selinux");
-                        goto err;
-                }
+    if (cmd_args->aux_gfid_mount) {
+        ret = dict_set_static_ptr(options, "virtual-gfid-access", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "aux-gfid-mount");
+            goto err;
         }
+    }
 
-        if (cmd_args->capability) {
-                ret = dict_set_static_ptr (options, "capability", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key capability");
-                        goto err;
-                }
+    if (cmd_args->enable_ino32) {
+        ret = dict_set_static_ptr(options, "enable-ino32", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "enable-ino32");
+            goto err;
         }
+    }
 
-        if (cmd_args->aux_gfid_mount) {
-                ret = dict_set_static_ptr (options, "virtual-gfid-access",
-                                           "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "aux-gfid-mount");
-                        goto err;
-                }
+    if (cmd_args->read_only) {
+        ret = dict_set_static_ptr(options, "read-only", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key read-only");
+            goto err;
         }
+    }
 
-        if (cmd_args->enable_ino32) {
-                ret = dict_set_static_ptr (options, "enable-ino32", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "enable-ino32");
-                        goto err;
-                }
+    switch (cmd_args->fopen_keep_cache) {
+        case GF_OPTION_ENABLE:
+            ret = dict_set_static_ptr(options, "fopen-keep-cache", "on");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                       "failed to set dict value for key "
+                       "fopen-keep-cache");
+                goto err;
+            }
+            break;
+        case GF_OPTION_DISABLE:
+            ret = dict_set_static_ptr(options, "fopen-keep-cache", "off");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                       "failed to set dict value for key "
+                       "fopen-keep-cache");
+                goto err;
+            }
+            break;
+        case GF_OPTION_DEFERRED: /* default */
+        default:
+            gf_msg_debug("glusterfsd", 0, "fopen-keep-cache mode %d",
+                         cmd_args->fopen_keep_cache);
+            break;
+    }
+
+    if (cmd_args->gid_timeout_set) {
+        ret = dict_set_int32(options, "gid-timeout", cmd_args->gid_timeout);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key gid-timeout");
+            goto err;
         }
+    }
 
-        if (cmd_args->read_only) {
-                ret = dict_set_static_ptr (options, "read-only", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key read-only");
-                        goto err;
-                }
+    if (cmd_args->resolve_gids) {
+        ret = dict_set_static_ptr(options, "resolve-gids", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "resolve-gids");
+            goto err;
         }
+    }
 
-	switch (cmd_args->fopen_keep_cache) {
-	case GF_OPTION_ENABLE:
-		ret = dict_set_static_ptr(options, "fopen-keep-cache",
-			"on");
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-				"fopen-keep-cache");
-			goto err;
-		}
-		break;
-	case GF_OPTION_DISABLE:
-		ret = dict_set_static_ptr(options, "fopen-keep-cache",
-			"off");
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-				"fopen-keep-cache");
-			goto err;
-		}
-		break;
-        case GF_OPTION_DEFERRED: /* default */
-        default:
-                gf_msg_debug ("glusterfsd", 0, "fopen-keep-cache mode %d",
-                              cmd_args->fopen_keep_cache);
-                break;
-	}
-
-	if (cmd_args->gid_timeout_set) {
-		ret = dict_set_int32(options, "gid-timeout",
-			cmd_args->gid_timeout);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key gid-timeout");
-			goto err;
-		}
-	}
-
-        if (cmd_args->resolve_gids) {
-                ret = dict_set_static_ptr (options, "resolve-gids", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "resolve-gids");
-                        goto err;
-                }
+    if (cmd_args->background_qlen) {
+        ret = dict_set_int32(options, "background-qlen",
+                             cmd_args->background_qlen);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "background-qlen");
+            goto err;
+        }
+    }
+    if (cmd_args->congestion_threshold) {
+        ret = dict_set_int32(options, "congestion-threshold",
+                             cmd_args->congestion_threshold);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "congestion-threshold");
+            goto err;
         }
+    }
 
-	if (cmd_args->background_qlen) {
-		ret = dict_set_int32 (options, "background-qlen",
-                                      cmd_args->background_qlen);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "background-qlen");
-			goto err;
-		}
-	}
-	if (cmd_args->congestion_threshold) {
-		ret = dict_set_int32 (options, "congestion-threshold",
-                                      cmd_args->congestion_threshold);
-		if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "congestion-threshold");
-			goto err;
-		}
-	}
-
-        switch (cmd_args->fuse_direct_io_mode) {
+    switch (cmd_args->fuse_direct_io_mode) {
         case GF_OPTION_DISABLE: /* disable */
-                ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
-                                           "disable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
-                                "failed to set 'disable' for key "
-                                ZR_DIRECT_IO_OPT);
-                        goto err;
-                }
-                break;
+            ret = dict_set_static_ptr(options, ZR_DIRECT_IO_OPT, "disable");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
+                       "failed to set 'disable' for key " ZR_DIRECT_IO_OPT);
+                goto err;
+            }
+            break;
         case GF_OPTION_ENABLE: /* enable */
-                ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
-                                "failed to set 'enable' for key "
-                                ZR_DIRECT_IO_OPT);
-                        goto err;
-                }
-                break;
+            ret = dict_set_static_ptr(options, ZR_DIRECT_IO_OPT, "enable");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
+                       "failed to set 'enable' for key " ZR_DIRECT_IO_OPT);
+                goto err;
+            }
+            break;
         case GF_OPTION_DEFERRED: /* auto */
         default:
-                gf_msg_debug ("glusterfsd", 0, "fuse direct io type %d",
-                              cmd_args->fuse_direct_io_mode);
-                break;
-        }
+            gf_msg_debug("glusterfsd", 0, "fuse direct io type %d",
+                         cmd_args->fuse_direct_io_mode);
+            break;
+    }
 
-        switch (cmd_args->no_root_squash) {
+    switch (cmd_args->no_root_squash) {
         case GF_OPTION_ENABLE: /* enable */
-                ret = dict_set_static_ptr (options, "no-root-squash",
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
-                                "failed to set 'enable' for key "
-                                "no-root-squash");
-                        goto err;
-                }
-                break;
+            ret = dict_set_static_ptr(options, "no-root-squash", "enable");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6,
+                       "failed to set 'enable' for key "
+                       "no-root-squash");
+                goto err;
+            }
+            break;
         case GF_OPTION_DISABLE: /* disable/default */
         default:
-                ret = dict_set_static_ptr (options, "no-root-squash",
-                                           "disable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
-                                "failed to set 'disable' for key "
-                                "no-root-squash");
-                        goto err;
-                }
-                gf_msg_debug ("glusterfsd", 0, "fuse no-root-squash mode %d",
-                        cmd_args->no_root_squash);
-                break;
-        }
-
-        if (!cmd_args->no_daemon_mode) {
-                ret = dict_set_static_ptr (options, "sync-to-mount",
-                                           "enable");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key sync-mtab");
-                        goto err;
-                }
+            ret = dict_set_static_ptr(options, "no-root-squash", "disable");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5,
+                       "failed to set 'disable' for key "
+                       "no-root-squash");
+                goto err;
+            }
+            gf_msg_debug("glusterfsd", 0, "fuse no-root-squash mode %d",
+                         cmd_args->no_root_squash);
+            break;
+    }
+
+    if (!cmd_args->no_daemon_mode) {
+        ret = dict_set_static_ptr(options, "sync-to-mount", "enable");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key sync-mtab");
+            goto err;
         }
+    }
 
-        if (cmd_args->use_readdirp) {
-                ret = dict_set_str (options, "use-readdirp",
-                                    cmd_args->use_readdirp);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "use-readdirp");
-                        goto err;
-                }
-        }
-        if (cmd_args->event_history) {
-                ret = dict_set_str (options, "event-history",
-                                    cmd_args->event_history);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "event-history");
-                        goto err;
-                }
-        }
-        if (cmd_args->thin_client) {
-                ret = dict_set_static_ptr (options, "thin-client", "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "thin-client");
-                        goto err;
-                }
-        }
-        if (cmd_args->reader_thread_count) {
-                ret = dict_set_uint32 (options, "reader-thread-count",
-                                       cmd_args->reader_thread_count);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "reader-thread-count");
-                        goto err;
-                }
+    if (cmd_args->use_readdirp) {
+        ret = dict_set_str(options, "use-readdirp", cmd_args->use_readdirp);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "use-readdirp");
+            goto err;
+        }
+    }
+    if (cmd_args->event_history) {
+        ret = dict_set_str(options, "event-history", cmd_args->event_history);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "event-history");
+            goto err;
+        }
+    }
+    if (cmd_args->thin_client) {
+        ret = dict_set_static_ptr(options, "thin-client", "on");
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "thin-client");
+            goto err;
+        }
+    }
+    if (cmd_args->reader_thread_count) {
+        ret = dict_set_uint32(options, "reader-thread-count",
+                              cmd_args->reader_thread_count);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "reader-thread-count");
+            goto err;
         }
-        switch (cmd_args->kernel_writeback_cache) {
+    }
+    switch (cmd_args->kernel_writeback_cache) {
         case GF_OPTION_ENABLE:
-                ret = dict_set_static_ptr(options, "kernel-writeback-cache",
-                        "on");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "kernel-writeback-cache");
-                        goto err;
-                }
-                break;
+            ret = dict_set_static_ptr(options, "kernel-writeback-cache", "on");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                       "failed to set dict value for key "
+                       "kernel-writeback-cache");
+                goto err;
+            }
+            break;
         case GF_OPTION_DISABLE:
-                ret = dict_set_static_ptr(options, "kernel-writeback-cache",
-                        "off");
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "kernel-writeback-cache");
-                        goto err;
-                }
-                break;
+            ret = dict_set_static_ptr(options, "kernel-writeback-cache", "off");
+            if (ret < 0) {
+                gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                       "failed to set dict value for key "
+                       "kernel-writeback-cache");
+                goto err;
+            }
+            break;
         case GF_OPTION_DEFERRED: /* default */
         default:
-                gf_msg_debug ("glusterfsd", 0, "kernel-writeback-cache mode %d",
-                              cmd_args->kernel_writeback_cache);
-                break;
-        }
-        if (cmd_args->attr_times_granularity) {
-                ret = dict_set_uint32 (options, "attr-times-granularity",
-                                       cmd_args->attr_times_granularity);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                "attr-times-granularity");
-                        goto err;
-                }
+            gf_msg_debug("glusterfsd", 0, "kernel-writeback-cache mode %d",
+                         cmd_args->kernel_writeback_cache);
+            break;
+    }
+    if (cmd_args->attr_times_granularity) {
+        ret = dict_set_uint32(options, "attr-times-granularity",
+                              cmd_args->attr_times_granularity);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key "
+                   "attr-times-granularity");
+            goto err;
         }
+    }
 
-
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-create_fuse_mount (glusterfs_ctx_t *ctx)
+create_fuse_mount(glusterfs_ctx_t *ctx)
 {
-        int              ret = 0;
-        cmd_args_t      *cmd_args = NULL;
-        xlator_t        *master = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    xlator_t *master = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->mount_point) {
-                gf_msg_trace ("glusterfsd", 0,
-                              "mount point not found, not a client process");
-                return 0;
-        }
-
-        if (ctx->process_mode != GF_CLIENT_PROCESS) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7,
-                        "Not a client process, not performing mount operation");
-                return -1;
-        }
-
-        master = GF_CALLOC (1, sizeof (*master),
-                            gfd_mt_xlator_t);
-        if (!master)
-                goto err;
-
-        master->name = gf_strdup ("fuse");
-        if (!master->name)
-                goto err;
-
-        if (xlator_set_type (master, "mount/fuse") == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8,
-                        "MOUNT-POINT %s initialization failed",
-                        cmd_args->mount_point);
-                goto err;
-        }
-
-        master->ctx      = ctx;
-        master->options  = get_new_dict ();
-        if (!master->options)
-                goto err;
-
-        ret = set_fuse_mount_options (ctx, master->options);
-        if (ret)
-                goto err;
-
-        if (cmd_args->fuse_mountopts) {
-                ret = dict_set_static_ptr (master->options, ZR_FUSE_MOUNTOPTS,
-                                           cmd_args->fuse_mountopts);
-                if (ret < 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
-                                "failed to set dict value for key "
-                                ZR_FUSE_MOUNTOPTS);
-                        goto err;
-                }
+    if (!cmd_args->mount_point) {
+        gf_msg_trace("glusterfsd", 0,
+                     "mount point not found, not a client process");
+        return 0;
+    }
+
+    if (ctx->process_mode != GF_CLIENT_PROCESS) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7,
+               "Not a client process, not performing mount operation");
+        return -1;
+    }
+
+    master = GF_CALLOC(1, sizeof(*master), gfd_mt_xlator_t);
+    if (!master)
+        goto err;
+
+    master->name = gf_strdup("fuse");
+    if (!master->name)
+        goto err;
+
+    if (xlator_set_type(master, "mount/fuse") == -1) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8,
+               "MOUNT-POINT %s initialization failed", cmd_args->mount_point);
+        goto err;
+    }
+
+    master->ctx = ctx;
+    master->options = get_new_dict();
+    if (!master->options)
+        goto err;
+
+    ret = set_fuse_mount_options(ctx, master->options);
+    if (ret)
+        goto err;
+
+    if (cmd_args->fuse_mountopts) {
+        ret = dict_set_static_ptr(master->options, ZR_FUSE_MOUNTOPTS,
+                                  cmd_args->fuse_mountopts);
+        if (ret < 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4,
+                   "failed to set dict value for key " ZR_FUSE_MOUNTOPTS);
+            goto err;
         }
+    }
 
-        ret = xlator_init (master);
-        if (ret) {
-                gf_msg_debug ("glusterfsd", 0,
-                              "failed to initialize fuse translator");
-                goto err;
-        }
+    ret = xlator_init(master);
+    if (ret) {
+        gf_msg_debug("glusterfsd", 0, "failed to initialize fuse translator");
+        goto err;
+    }
 
-        ctx->master = master;
+    ctx->master = master;
 
-        return 0;
+    return 0;
 
 err:
-        if (master) {
-                xlator_destroy (master);
-        }
+    if (master) {
+        xlator_destroy(master);
+    }
 
-        return 1;
+    return 1;
 }
 
-
 static FILE *
-get_volfp (glusterfs_ctx_t *ctx)
+get_volfp(glusterfs_ctx_t *ctx)
 {
-        int          ret = 0;
-        cmd_args_t  *cmd_args = NULL;
-        FILE        *specfp = NULL;
-        struct stat  statbuf;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    FILE *specfp = NULL;
+    struct stat statbuf;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        ret = sys_lstat (cmd_args->volfile, &statbuf);
-        if (ret == -1) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
-                        "loading volume file %s failed", cmd_args->volfile);
-                return NULL;
-        }
+    ret = sys_lstat(cmd_args->volfile, &statbuf);
+    if (ret == -1) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
+               "loading volume file %s failed", cmd_args->volfile);
+        return NULL;
+    }
 
-        if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
-                        "loading volume file %s failed", cmd_args->volfile);
-                return NULL;
-        }
+    if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9,
+               "loading volume file %s failed", cmd_args->volfile);
+        return NULL;
+    }
 
-        gf_msg_debug ("glusterfsd", 0, "loading volume file %s",
-                      cmd_args->volfile);
+    gf_msg_debug("glusterfsd", 0, "loading volume file %s", cmd_args->volfile);
 
-        return specfp;
+    return specfp;
 }
 
 static int
-gf_remember_backup_volfile_server (char *arg)
+gf_remember_backup_volfile_server(char *arg)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        cmd_args_t              *cmd_args = NULL;
-        int                      ret = -1;
-
-        ctx = glusterfsd_ctx;
-        if (!ctx)
-                goto out;
-        cmd_args = &ctx->cmd_args;
-
-        if(!cmd_args)
-                goto out;
-
-        ret = gf_set_volfile_server_common(cmd_args, arg,
-                                           GF_DEFAULT_VOLFILE_TRANSPORT,
-                                           GF_DEFAULT_BASE_PORT);
-        if (ret) {
-                gf_log ("glusterfs", GF_LOG_ERROR,
-                        "failed to set volfile server: %s", strerror (errno));
-        }
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+
+    ctx = glusterfsd_ctx;
+    if (!ctx)
+        goto out;
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args)
+        goto out;
+
+    ret = gf_set_volfile_server_common(
+        cmd_args, arg, GF_DEFAULT_VOLFILE_TRANSPORT, GF_DEFAULT_BASE_PORT);
+    if (ret) {
+        gf_log("glusterfs", GF_LOG_ERROR, "failed to set volfile server: %s",
+               strerror(errno));
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_remember_xlator_option (char *arg)
+gf_remember_xlator_option(char *arg)
 {
-        glusterfs_ctx_t         *ctx = NULL;
-        cmd_args_t              *cmd_args  = NULL;
-        xlator_cmdline_option_t *option = NULL;
-        int                      ret = -1;
-        char                    *dot = NULL;
-        char                    *equals = NULL;
-
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
-
-        option = GF_CALLOC (1, sizeof (xlator_cmdline_option_t),
-                            gfd_mt_xlator_cmdline_option_t);
-        if (!option)
-                goto out;
-
-        INIT_LIST_HEAD (&option->cmd_args);
-
-        dot = strchr (arg, '.');
-        if (!dot) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
-                        "xlator option %s is invalid", arg);
-                goto out;
-        }
-
-        option->volume = GF_MALLOC ((dot - arg) + 1, gfd_mt_char);
-        if (!option->volume)
-                goto out;
-
-        strncpy (option->volume, arg, (dot - arg));
-        option->volume[(dot - arg)] = '\0';
-
-        equals = strchr (arg, '=');
-        if (!equals) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
-                        "xlator option %s is invalid", arg);
-                goto out;
-        }
-
-        option->key = GF_MALLOC ((equals - dot) + 1, gfd_mt_char);
-        if (!option->key)
-                goto out;
-
-        strncpy (option->key, dot + 1, (equals - dot - 1));
-        option->key[(equals - dot - 1)] = '\0';
-
-        if (!*(equals + 1)) {
-                gf_msg ("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
-                        "xlator option %s is invalid", arg);
-                goto out;
-        }
-
-        option->value = gf_strdup (equals + 1);
-
-        list_add (&option->cmd_args, &cmd_args->xlator_options);
-
-        ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    xlator_cmdline_option_t *option = NULL;
+    int ret = -1;
+    char *dot = NULL;
+    char *equals = NULL;
+
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
+
+    option = GF_CALLOC(1, sizeof(xlator_cmdline_option_t),
+                       gfd_mt_xlator_cmdline_option_t);
+    if (!option)
+        goto out;
+
+    INIT_LIST_HEAD(&option->cmd_args);
+
+    dot = strchr(arg, '.');
+    if (!dot) {
+        gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
+               "xlator option %s is invalid", arg);
+        goto out;
+    }
+
+    option->volume = GF_MALLOC((dot - arg) + 1, gfd_mt_char);
+    if (!option->volume)
+        goto out;
+
+    strncpy(option->volume, arg, (dot - arg));
+    option->volume[(dot - arg)] = '\0';
+
+    equals = strchr(arg, '=');
+    if (!equals) {
+        gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
+               "xlator option %s is invalid", arg);
+        goto out;
+    }
+
+    option->key = GF_MALLOC((equals - dot) + 1, gfd_mt_char);
+    if (!option->key)
+        goto out;
+
+    strncpy(option->key, dot + 1, (equals - dot - 1));
+    option->key[(equals - dot - 1)] = '\0';
+
+    if (!*(equals + 1)) {
+        gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10,
+               "xlator option %s is invalid", arg);
+        goto out;
+    }
+
+    option->value = gf_strdup(equals + 1);
+
+    list_add(&option->cmd_args, &cmd_args->xlator_options);
+
+    ret = 0;
 out:
-        if (ret == -1) {
-                if (option) {
-                        GF_FREE (option->volume);
-                        GF_FREE (option->key);
-                        GF_FREE (option->value);
+    if (ret == -1) {
+        if (option) {
+            GF_FREE(option->volume);
+            GF_FREE(option->key);
+            GF_FREE(option->value);
 
-                        GF_FREE (option);
-                }
+            GF_FREE(option);
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 #ifdef GF_LINUX_HOST_OS
 static struct oom_api_info {
-        char *oom_api_file;
-        int32_t oom_min;
-        int32_t oom_max;
+    char *oom_api_file;
+    int32_t oom_min;
+    int32_t oom_max;
 } oom_api_info[] = {
-        { "/proc/self/oom_score_adj", OOM_SCORE_ADJ_MIN, OOM_SCORE_ADJ_MAX },
-        { "/proc/self/oom_adj",       OOM_DISABLE,       OOM_ADJUST_MAX },
-        { NULL, 0, 0 }
-};
-
+    {"/proc/self/oom_score_adj", OOM_SCORE_ADJ_MIN, OOM_SCORE_ADJ_MAX},
+    {"/proc/self/oom_adj", OOM_DISABLE, OOM_ADJUST_MAX},
+    {NULL, 0, 0}};
 
 static struct oom_api_info *
-get_oom_api_info (void)
+get_oom_api_info(void)
 {
-        struct oom_api_info *api = NULL;
+    struct oom_api_info *api = NULL;
 
-        for (api = oom_api_info; api->oom_api_file; api++) {
-                if (sys_access (api->oom_api_file, F_OK) != -1) {
-                        return api;
-                }
+    for (api = oom_api_info; api->oom_api_file; api++) {
+        if (sys_access(api->oom_api_file, F_OK) != -1) {
+            return api;
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 #endif
 
 static error_t
-parse_opts (int key, char *arg, struct argp_state *state)
+parse_opts(int key, char *arg, struct argp_state *state)
 {
-        cmd_args_t          *cmd_args      = NULL;
-        uint32_t             n             = 0;
+    cmd_args_t *cmd_args = NULL;
+    uint32_t n = 0;
 #ifdef GF_LINUX_HOST_OS
-        int32_t              k             = 0;
-        struct oom_api_info *api           = NULL;
+    int32_t k = 0;
+    struct oom_api_info *api = NULL;
 #endif
-        double               d             = 0.0;
-        gf_boolean_t         b             = _gf_false;
-        char                *pwd           = NULL;
-        char                *tmp_str       = NULL;
-        char                *port_str      = NULL;
-        struct passwd       *pw            = NULL;
-        int                  ret           = 0;
+    double d = 0.0;
+    gf_boolean_t b = _gf_false;
+    char *pwd = NULL;
+    char *tmp_str = NULL;
+    char *port_str = NULL;
+    struct passwd *pw = NULL;
+    int ret = 0;
 
-        cmd_args = state->input;
+    cmd_args = state->input;
 
-        switch (key) {
+    switch (key) {
         case ARGP_VOLFILE_SERVER_KEY:
-                gf_remember_backup_volfile_server (arg);
+            gf_remember_backup_volfile_server(arg);
 
-                break;
+            break;
 
         case ARGP_READ_ONLY_KEY:
-                cmd_args->read_only = 1;
-                break;
+            cmd_args->read_only = 1;
+            break;
 
         case ARGP_ACL_KEY:
-                cmd_args->acl = 1;
-                gf_remember_xlator_option ("*-md-cache.cache-posix-acl=true");
-                break;
+            cmd_args->acl = 1;
+            gf_remember_xlator_option("*-md-cache.cache-posix-acl=true");
+            break;
 
         case ARGP_SELINUX_KEY:
-                cmd_args->selinux = 1;
-                gf_remember_xlator_option ("*-md-cache.cache-selinux=true");
-                break;
+            cmd_args->selinux = 1;
+            gf_remember_xlator_option("*-md-cache.cache-selinux=true");
+            break;
 
         case ARGP_CAPABILITY_KEY:
-                cmd_args->capability = 1;
-                break;
+            cmd_args->capability = 1;
+            break;
 
         case ARGP_AUX_GFID_MOUNT_KEY:
-                cmd_args->aux_gfid_mount = 1;
-                break;
+            cmd_args->aux_gfid_mount = 1;
+            break;
 
         case ARGP_INODE32_KEY:
-                cmd_args->enable_ino32 = 1;
-                break;
+            cmd_args->enable_ino32 = 1;
+            break;
 
         case ARGP_WORM_KEY:
-                cmd_args->worm = 1;
-                break;
+            cmd_args->worm = 1;
+            break;
 
         case ARGP_PRINT_NETGROUPS:
-                cmd_args->print_netgroups = arg;
-                break;
+            cmd_args->print_netgroups = arg;
+            break;
 
         case ARGP_PRINT_EXPORTS:
-                cmd_args->print_exports = arg;
-                break;
+            cmd_args->print_exports = arg;
+            break;
 
         case ARGP_PRINT_XLATORDIR_KEY:
-                cmd_args->print_xlatordir = _gf_true;
-                break;
+            cmd_args->print_xlatordir = _gf_true;
+            break;
 
         case ARGP_PRINT_STATEDUMPDIR_KEY:
-                cmd_args->print_statedumpdir = _gf_true;
-                break;
+            cmd_args->print_statedumpdir = _gf_true;
+            break;
 
         case ARGP_PRINT_LOGDIR_KEY:
-                cmd_args->print_logdir = _gf_true;
-                break;
+            cmd_args->print_logdir = _gf_true;
+            break;
 
         case ARGP_PRINT_LIBEXECDIR_KEY:
-                cmd_args->print_libexecdir = _gf_true;
-                break;
+            cmd_args->print_libexecdir = _gf_true;
+            break;
 
         case ARGP_MAC_COMPAT_KEY:
-                if (!arg)
-                        arg = "on";
-
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->mac_compat = b;
+            if (!arg)
+                arg = "on";
 
-                        break;
-                }
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->mac_compat = b;
 
-                argp_failure (state, -1, 0,
-                              "invalid value \"%s\" for mac-compat", arg);
                 break;
+            }
+
+            argp_failure(state, -1, 0, "invalid value \"%s\" for mac-compat",
+                         arg);
+            break;
 
         case ARGP_VOLUME_FILE_KEY:
-                GF_FREE (cmd_args->volfile);
-
-                if (arg[0] != '/') {
-                        pwd = getcwd (NULL, PATH_MAX);
-                        if (!pwd) {
-                               argp_failure (state, -1, errno,
-                                            "getcwd failed with error no %d",
-                                             errno);
-                               break;
-                        }
-                        char tmp_buf[1024];
-                        snprintf (tmp_buf, sizeof(tmp_buf), "%s/%s", pwd, arg);
-                        cmd_args->volfile = gf_strdup (tmp_buf);
-                        free (pwd);
-                } else {
-                        cmd_args->volfile = gf_strdup (arg);
+            GF_FREE(cmd_args->volfile);
+
+            if (arg[0] != '/') {
+                pwd = getcwd(NULL, PATH_MAX);
+                if (!pwd) {
+                    argp_failure(state, -1, errno,
+                                 "getcwd failed with error no %d", errno);
+                    break;
                 }
+                char tmp_buf[1024];
+                snprintf(tmp_buf, sizeof(tmp_buf), "%s/%s", pwd, arg);
+                cmd_args->volfile = gf_strdup(tmp_buf);
+                free(pwd);
+            } else {
+                cmd_args->volfile = gf_strdup(arg);
+            }
 
-                break;
+            break;
 
         case ARGP_LOG_LEVEL_KEY:
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_NONE;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_CRITICAL;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_ERROR;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_WARNING;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_INFO_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_INFO;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_DEBUG;
-                        break;
-                }
-                if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
-                        cmd_args->log_level = GF_LOG_TRACE;
-                        break;
-                }
-
-                argp_failure (state, -1, 0, "unknown log level %s", arg);
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_NONE;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_CRITICAL;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_ERROR;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_WARNING;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_INFO_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_INFO;
                 break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_DEBUG;
+                break;
+            }
+            if (strcasecmp(arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
+                cmd_args->log_level = GF_LOG_TRACE;
+                break;
+            }
+
+            argp_failure(state, -1, 0, "unknown log level %s", arg);
+            break;
 
         case ARGP_LOG_FILE_KEY:
-                cmd_args->log_file = gf_strdup (arg);
-                break;
+            cmd_args->log_file = gf_strdup(arg);
+            break;
 
         case ARGP_VOLFILE_SERVER_PORT_KEY:
-                n = 0;
+            n = 0;
 
-                if (gf_string2uint_base10 (arg, &n) == 0) {
-                        cmd_args->volfile_server_port = n;
-                        break;
-                }
-
-                argp_failure (state, -1, 0,
-                              "unknown volfile server port %s", arg);
+            if (gf_string2uint_base10(arg, &n) == 0) {
+                cmd_args->volfile_server_port = n;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown volfile server port %s", arg);
+            break;
 
         case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
-                cmd_args->volfile_server_transport = gf_strdup (arg);
-                break;
+            cmd_args->volfile_server_transport = gf_strdup(arg);
+            break;
 
         case ARGP_VOLFILE_ID_KEY:
-                cmd_args->volfile_id = gf_strdup (arg);
-                break;
+            cmd_args->volfile_id = gf_strdup(arg);
+            break;
 
         case ARGP_THIN_CLIENT_KEY:
-                cmd_args->thin_client = _gf_true;
-                break;
+            cmd_args->thin_client = _gf_true;
+            break;
 
         case ARGP_PID_FILE_KEY:
-                cmd_args->pid_file = gf_strdup (arg);
-                break;
+            cmd_args->pid_file = gf_strdup(arg);
+            break;
 
         case ARGP_SOCK_FILE_KEY:
-                cmd_args->sock_file = gf_strdup (arg);
-                break;
+            cmd_args->sock_file = gf_strdup(arg);
+            break;
 
         case ARGP_NO_DAEMON_KEY:
-                cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
-                break;
+            cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+            break;
 
         case ARGP_RUN_ID_KEY:
-                cmd_args->run_id = gf_strdup (arg);
-                break;
+            cmd_args->run_id = gf_strdup(arg);
+            break;
 
         case ARGP_DEBUG_KEY:
-                cmd_args->debug_mode = ENABLE_DEBUG_MODE;
-                break;
+            cmd_args->debug_mode = ENABLE_DEBUG_MODE;
+            break;
         case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS:
-                cmd_args->max_connect_attempts = 1;
-                break;
+            cmd_args->max_connect_attempts = 1;
+            break;
 
         case ARGP_DIRECT_IO_MODE_KEY:
-                if (!arg)
-                        arg = "on";
+            if (!arg)
+                arg = "on";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->fuse_direct_io_mode = b;
-
-                        break;
-                }
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fuse_direct_io_mode = b;
 
-                if (strcmp (arg, "auto") == 0)
-                        break;
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown direct I/O mode setting \"%s\"", arg);
+            if (strcmp(arg, "auto") == 0)
                 break;
 
+            argp_failure(state, -1, 0, "unknown direct I/O mode setting \"%s\"",
+                         arg);
+            break;
+
         case ARGP_FUSE_NO_ROOT_SQUASH_KEY:
-                cmd_args->no_root_squash = _gf_true;
-                break;
+            cmd_args->no_root_squash = _gf_true;
+            break;
 
         case ARGP_ENTRY_TIMEOUT_KEY:
-                d = 0.0;
+            d = 0.0;
 
-                gf_string2double (arg, &d);
-                if (!(d < 0.0)) {
-                        cmd_args->fuse_entry_timeout = d;
-                        break;
-                }
-
-                argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
+            gf_string2double(arg, &d);
+            if (!(d < 0.0)) {
+                cmd_args->fuse_entry_timeout = d;
                 break;
+            }
 
-        case ARGP_NEGATIVE_TIMEOUT_KEY:
-                d = 0.0;
+            argp_failure(state, -1, 0, "unknown entry timeout %s", arg);
+            break;
 
-                ret = gf_string2double (arg, &d);
-                if ((ret == 0) && !(d < 0.0)) {
-                        cmd_args->fuse_negative_timeout = d;
-                        break;
-                }
+        case ARGP_NEGATIVE_TIMEOUT_KEY:
+            d = 0.0;
 
-                argp_failure (state, -1, 0, "unknown negative timeout %s", arg);
+            ret = gf_string2double(arg, &d);
+            if ((ret == 0) && !(d < 0.0)) {
+                cmd_args->fuse_negative_timeout = d;
                 break;
+            }
 
-        case ARGP_ATTRIBUTE_TIMEOUT_KEY:
-                d = 0.0;
+            argp_failure(state, -1, 0, "unknown negative timeout %s", arg);
+            break;
 
-                gf_string2double (arg, &d);
-                if (!(d < 0.0)) {
-                        cmd_args->fuse_attribute_timeout = d;
-                        break;
-                }
+        case ARGP_ATTRIBUTE_TIMEOUT_KEY:
+            d = 0.0;
 
-                argp_failure (state, -1, 0,
-                              "unknown attribute timeout %s", arg);
+            gf_string2double(arg, &d);
+            if (!(d < 0.0)) {
+                cmd_args->fuse_attribute_timeout = d;
                 break;
+            }
 
-        case ARGP_CLIENT_PID_KEY:
-                if (gf_string2int (arg, &cmd_args->client_pid) == 0) {
-                        cmd_args->client_pid_set = 1;
-                        break;
-                }
+            argp_failure(state, -1, 0, "unknown attribute timeout %s", arg);
+            break;
 
-                argp_failure (state, -1, 0,
-                              "unknown client pid %s", arg);
+        case ARGP_CLIENT_PID_KEY:
+            if (gf_string2int(arg, &cmd_args->client_pid) == 0) {
+                cmd_args->client_pid_set = 1;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown client pid %s", arg);
+            break;
 
         case ARGP_USER_MAP_ROOT_KEY:
-                pw = getpwnam (arg);
-                if (pw)
-                        cmd_args->uid_map_root = pw->pw_uid;
-                else
-                        argp_failure (state, -1, 0,
-                                      "user %s does not exist", arg);
-                break;
+            pw = getpwnam(arg);
+            if (pw)
+                cmd_args->uid_map_root = pw->pw_uid;
+            else
+                argp_failure(state, -1, 0, "user %s does not exist", arg);
+            break;
 
         case ARGP_VOLFILE_CHECK_KEY:
-                cmd_args->volfile_check = 1;
-                break;
+            cmd_args->volfile_check = 1;
+            break;
 
         case ARGP_VOLUME_NAME_KEY:
-                cmd_args->volume_name = gf_strdup (arg);
-                break;
+            cmd_args->volume_name = gf_strdup(arg);
+            break;
 
         case ARGP_XLATOR_OPTION_KEY:
-                if (gf_remember_xlator_option (arg))
-                        argp_failure (state, -1, 0, "invalid xlator option  %s",
-                                      arg);
+            if (gf_remember_xlator_option(arg))
+                argp_failure(state, -1, 0, "invalid xlator option  %s", arg);
 
-                break;
+            break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
 
         case ARGP_KEY_ARG:
-                if (state->arg_num >= 1)
-                        argp_usage (state);
+            if (state->arg_num >= 1)
+                argp_usage(state);
 
-                cmd_args->mount_point = gf_strdup (arg);
-                break;
+            cmd_args->mount_point = gf_strdup(arg);
+            break;
 
         case ARGP_DUMP_FUSE_KEY:
-                cmd_args->dump_fuse = gf_strdup (arg);
-                break;
+            cmd_args->dump_fuse = gf_strdup(arg);
+            break;
         case ARGP_BRICK_NAME_KEY:
-                cmd_args->brick_name = gf_strdup (arg);
-                break;
+            cmd_args->brick_name = gf_strdup(arg);
+            break;
         case ARGP_BRICK_PORT_KEY:
-                n = 0;
-
-                port_str = strtok_r (arg, ",", &tmp_str);
-                if (gf_string2uint_base10 (port_str, &n) == 0) {
-                        cmd_args->brick_port = n;
-                        port_str = strtok_r (NULL, ",", &tmp_str);
-                        if (port_str) {
-                                if (gf_string2uint_base10 (port_str, &n) == 0) {
-                                        cmd_args->brick_port2 = n;
-                                        break;
-                                }
-                                argp_failure (state, -1, 0,
-                                              "wrong brick (listen) port %s", arg);
-                        }
+            n = 0;
+
+            port_str = strtok_r(arg, ",", &tmp_str);
+            if (gf_string2uint_base10(port_str, &n) == 0) {
+                cmd_args->brick_port = n;
+                port_str = strtok_r(NULL, ",", &tmp_str);
+                if (port_str) {
+                    if (gf_string2uint_base10(port_str, &n) == 0) {
+                        cmd_args->brick_port2 = n;
                         break;
+                    }
+                    argp_failure(state, -1, 0, "wrong brick (listen) port %s",
+                                 arg);
                 }
-
-                argp_failure (state, -1, 0,
-                              "unknown brick (listen) port %s", arg);
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown brick (listen) port %s", arg);
+            break;
 
         case ARGP_MEM_ACCOUNTING_KEY:
-                /* TODO: it should have got handled much earlier */
-		//gf_mem_acct_enable_set (THIS->ctx);
-                break;
+            /* TODO: it should have got handled much earlier */
+            // gf_mem_acct_enable_set (THIS->ctx);
+            break;
 
-	case ARGP_FOPEN_KEEP_CACHE_KEY:
-                if (!arg)
-                        arg = "on";
+        case ARGP_FOPEN_KEEP_CACHE_KEY:
+            if (!arg)
+                arg = "on";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->fopen_keep_cache = b;
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->fopen_keep_cache = b;
 
-                        break;
-                }
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown cache setting \"%s\"", arg);
+            argp_failure(state, -1, 0, "unknown cache setting \"%s\"", arg);
 
-		break;
+            break;
 
         case ARGP_GLOBAL_TIMER_WHEEL:
-                cmd_args->global_timer_wheel = 1;
-                break;
+            cmd_args->global_timer_wheel = 1;
+            break;
 
-	case ARGP_GID_TIMEOUT_KEY:
-		if (!gf_string2int(arg, &cmd_args->gid_timeout)) {
-			cmd_args->gid_timeout_set = _gf_true;
-			break;
-		}
+        case ARGP_GID_TIMEOUT_KEY:
+            if (!gf_string2int(arg, &cmd_args->gid_timeout)) {
+                cmd_args->gid_timeout_set = _gf_true;
+                break;
+            }
 
-		argp_failure(state, -1, 0, "unknown group list timeout %s", arg);
-		break;
+            argp_failure(state, -1, 0, "unknown group list timeout %s", arg);
+            break;
 
         case ARGP_RESOLVE_GIDS_KEY:
-                cmd_args->resolve_gids = 1;
-                break;
+            cmd_args->resolve_gids = 1;
+            break;
 
         case ARGP_FUSE_BACKGROUND_QLEN_KEY:
-                if (!gf_string2int (arg, &cmd_args->background_qlen))
-                        break;
-
-                argp_failure (state, -1, 0,
-                              "unknown background qlen option %s", arg);
+            if (!gf_string2int(arg, &cmd_args->background_qlen))
                 break;
-        case ARGP_FUSE_CONGESTION_THRESHOLD_KEY:
-                if (!gf_string2int (arg, &cmd_args->congestion_threshold))
-                        break;
 
-                argp_failure (state, -1, 0,
-                              "unknown congestion threshold option %s", arg);
+            argp_failure(state, -1, 0, "unknown background qlen option %s",
+                         arg);
+            break;
+        case ARGP_FUSE_CONGESTION_THRESHOLD_KEY:
+            if (!gf_string2int(arg, &cmd_args->congestion_threshold))
                 break;
 
+            argp_failure(state, -1, 0, "unknown congestion threshold option %s",
+                         arg);
+            break;
+
 #ifdef GF_LINUX_HOST_OS
         case ARGP_OOM_SCORE_ADJ_KEY:
-                k = 0;
+            k = 0;
 
-                api = get_oom_api_info();
-                if (!api)
-                        goto no_oom_api;
+            api = get_oom_api_info();
+            if (!api)
+                goto no_oom_api;
 
-                if (gf_string2int (arg, &k) == 0 &&
-                    k >= api->oom_min && k <= api->oom_max) {
-                        cmd_args->oom_score_adj = gf_strdup (arg);
-                        break;
-                }
+            if (gf_string2int(arg, &k) == 0 && k >= api->oom_min &&
+                k <= api->oom_max) {
+                cmd_args->oom_score_adj = gf_strdup(arg);
+                break;
+            }
 
-                argp_failure (state, -1, 0,
-                              "unknown oom_score_adj value %s", arg);
+            argp_failure(state, -1, 0, "unknown oom_score_adj value %s", arg);
 
-no_oom_api:
-                break;
+        no_oom_api:
+            break;
 #endif
 
         case ARGP_FUSE_MOUNTOPTS_KEY:
-                cmd_args->fuse_mountopts = gf_strdup (arg);
-                break;
+            cmd_args->fuse_mountopts = gf_strdup(arg);
+            break;
 
         case ARGP_FUSE_USE_READDIRP_KEY:
-                if (!arg)
-                        arg = "yes";
+            if (!arg)
+                arg = "yes";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        if (b) {
-                                cmd_args->use_readdirp = "yes";
-                        } else {
-                                cmd_args->use_readdirp = "no";
-                        }
-
-                        break;
+            if (gf_string2boolean(arg, &b) == 0) {
+                if (b) {
+                    cmd_args->use_readdirp = "yes";
+                } else {
+                    cmd_args->use_readdirp = "no";
                 }
 
-                argp_failure (state, -1, 0,
-                              "unknown use-readdirp setting \"%s\"", arg);
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown use-readdirp setting \"%s\"",
+                         arg);
+            break;
 
         case ARGP_LOGGER:
-                if (strcasecmp (arg, GF_LOGGER_GLUSTER_LOG) == 0)
-                        cmd_args->logger = gf_logger_glusterlog;
-                else if (strcasecmp (arg, GF_LOGGER_SYSLOG) == 0)
-                        cmd_args->logger = gf_logger_syslog;
-                else
-                        argp_failure (state, -1, 0, "unknown logger %s", arg);
+            if (strcasecmp(arg, GF_LOGGER_GLUSTER_LOG) == 0)
+                cmd_args->logger = gf_logger_glusterlog;
+            else if (strcasecmp(arg, GF_LOGGER_SYSLOG) == 0)
+                cmd_args->logger = gf_logger_syslog;
+            else
+                argp_failure(state, -1, 0, "unknown logger %s", arg);
 
-                break;
+            break;
 
         case ARGP_LOG_FORMAT:
-                if (strcasecmp (arg, GF_LOG_FORMAT_NO_MSG_ID) == 0)
-                        cmd_args->log_format = gf_logformat_traditional;
-                else if (strcasecmp (arg, GF_LOG_FORMAT_WITH_MSG_ID) == 0)
-                        cmd_args->log_format = gf_logformat_withmsgid;
-                else
-                        argp_failure (state, -1, 0, "unknown log format %s",
-                                      arg);
+            if (strcasecmp(arg, GF_LOG_FORMAT_NO_MSG_ID) == 0)
+                cmd_args->log_format = gf_logformat_traditional;
+            else if (strcasecmp(arg, GF_LOG_FORMAT_WITH_MSG_ID) == 0)
+                cmd_args->log_format = gf_logformat_withmsgid;
+            else
+                argp_failure(state, -1, 0, "unknown log format %s", arg);
 
-                break;
+            break;
 
         case ARGP_LOG_BUF_SIZE:
-                if (gf_string2uint32 (arg, &cmd_args->log_buf_size)) {
-                        argp_failure (state, -1, 0,
-                                      "unknown log buf size option %s", arg);
-                } else if (cmd_args->log_buf_size > GF_LOG_LRU_BUFSIZE_MAX) {
-                        argp_failure (state, -1, 0,
-                                      "Invalid log buf size %s. "
-                                      "Valid range: ["
-                                      GF_LOG_LRU_BUFSIZE_MIN_STR","
-                                      GF_LOG_LRU_BUFSIZE_MAX_STR"]", arg);
-                }
-
-                break;
+            if (gf_string2uint32(arg, &cmd_args->log_buf_size)) {
+                argp_failure(state, -1, 0, "unknown log buf size option %s",
+                             arg);
+            } else if (cmd_args->log_buf_size > GF_LOG_LRU_BUFSIZE_MAX) {
+                argp_failure(state, -1, 0,
+                             "Invalid log buf size %s. "
+                             "Valid range: [" GF_LOG_LRU_BUFSIZE_MIN_STR
+                             "," GF_LOG_LRU_BUFSIZE_MAX_STR "]",
+                             arg);
+            }
+
+            break;
 
         case ARGP_LOG_FLUSH_TIMEOUT:
-                if (gf_string2uint32 (arg, &cmd_args->log_flush_timeout)) {
-                        argp_failure (state, -1, 0,
-                                "unknown log flush timeout option %s", arg);
-                } else if ((cmd_args->log_flush_timeout <
-                            GF_LOG_FLUSH_TIMEOUT_MIN) ||
-                           (cmd_args->log_flush_timeout >
-                            GF_LOG_FLUSH_TIMEOUT_MAX)) {
-                            argp_failure (state, -1, 0,
-                                          "Invalid log flush timeout %s. "
-                                          "Valid range: ["
-                                          GF_LOG_FLUSH_TIMEOUT_MIN_STR","
-                                          GF_LOG_FLUSH_TIMEOUT_MAX_STR"]", arg);
-                }
-
-                break;
+            if (gf_string2uint32(arg, &cmd_args->log_flush_timeout)) {
+                argp_failure(state, -1, 0,
+                             "unknown log flush timeout option %s", arg);
+            } else if ((cmd_args->log_flush_timeout <
+                        GF_LOG_FLUSH_TIMEOUT_MIN) ||
+                       (cmd_args->log_flush_timeout >
+                        GF_LOG_FLUSH_TIMEOUT_MAX)) {
+                argp_failure(state, -1, 0,
+                             "Invalid log flush timeout %s. "
+                             "Valid range: [" GF_LOG_FLUSH_TIMEOUT_MIN_STR
+                             "," GF_LOG_FLUSH_TIMEOUT_MAX_STR "]",
+                             arg);
+            }
+
+            break;
 
         case ARGP_SECURE_MGMT_KEY:
-                if (!arg)
-                        arg = "yes";
+            if (!arg)
+                arg = "yes";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->secure_mgmt = b ? 1 : 0;
-                        break;
-                }
-
-                argp_failure (state, -1, 0,
-                              "unknown secure-mgmt setting \"%s\"", arg);
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->secure_mgmt = b ? 1 : 0;
                 break;
+            }
+
+            argp_failure(state, -1, 0, "unknown secure-mgmt setting \"%s\"",
+                         arg);
+            break;
 
         case ARGP_LOCALTIME_LOGGING_KEY:
-                cmd_args->localtime_logging = 1;
-                break;
+            cmd_args->localtime_logging = 1;
+            break;
         case ARGP_PROCESS_NAME_KEY:
-                cmd_args->process_name = gf_strdup (arg);
-                break;
+            cmd_args->process_name = gf_strdup(arg);
+            break;
         case ARGP_SUBDIR_MOUNT_KEY:
-                if (arg[0] != '/') {
-                        argp_failure (state, -1, 0,
-                                      "expect '/%s', provided just \"%s\"", arg, arg);
-                        break;
-                }
-                cmd_args->subdir_mount = gf_strdup (arg);
+            if (arg[0] != '/') {
+                argp_failure(state, -1, 0, "expect '/%s', provided just \"%s\"",
+                             arg, arg);
                 break;
+            }
+            cmd_args->subdir_mount = gf_strdup(arg);
+            break;
         case ARGP_FUSE_EVENT_HISTORY_KEY:
-                if (!arg)
-                        arg = "no";
+            if (!arg)
+                arg = "no";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        if (b) {
-                                cmd_args->event_history = "yes";
-                        } else {
-                                cmd_args->event_history = "no";
-                        }
-
-                        break;
+            if (gf_string2boolean(arg, &b) == 0) {
+                if (b) {
+                    cmd_args->event_history = "yes";
+                } else {
+                    cmd_args->event_history = "no";
                 }
 
-                argp_failure (state, -1, 0,
-                              "unknown event-history setting \"%s\"", arg);
                 break;
-        case ARGP_READER_THREAD_COUNT_KEY:
-                if (gf_string2uint32 (arg, &cmd_args->reader_thread_count)) {
-                        argp_failure (state, -1, 0,
-                                      "unknown reader thread count option %s",
-                                      arg);
-                } else if ((cmd_args->reader_thread_count < 1) ||
-                           (cmd_args->reader_thread_count > 64)) {
-                        argp_failure (state, -1, 0,
-                                      "Invalid reader thread count %s. "
-                                      "Valid range: [\"1, 64\"]", arg);
-                }
+            }
 
-                break;
+            argp_failure(state, -1, 0, "unknown event-history setting \"%s\"",
+                         arg);
+            break;
+        case ARGP_READER_THREAD_COUNT_KEY:
+            if (gf_string2uint32(arg, &cmd_args->reader_thread_count)) {
+                argp_failure(state, -1, 0,
+                             "unknown reader thread count option %s", arg);
+            } else if ((cmd_args->reader_thread_count < 1) ||
+                       (cmd_args->reader_thread_count > 64)) {
+                argp_failure(state, -1, 0,
+                             "Invalid reader thread count %s. "
+                             "Valid range: [\"1, 64\"]",
+                             arg);
+            }
+
+            break;
 
         case ARGP_KERNEL_WRITEBACK_CACHE_KEY:
-                if (!arg)
-                        arg = "yes";
+            if (!arg)
+                arg = "yes";
 
-                if (gf_string2boolean (arg, &b) == 0) {
-                        cmd_args->kernel_writeback_cache = b;
-
-                        break;
-                }
-
-                argp_failure (state, -1, 0,
-                              "unknown kernel writeback cache setting \"%s\"", arg);
-                break;
-        case ARGP_ATTR_TIMES_GRANULARITY_KEY:
-                if (gf_string2uint32 (arg, &cmd_args->attr_times_granularity)) {
-                        argp_failure (state, -1, 0,
-                                      "unknown attribute times granularity option %s",
-                                      arg);
-                } else if (cmd_args->attr_times_granularity > 1000000000) {
-                        argp_failure (state, -1, 0,
-                                      "Invalid attribute times granularity value %s. "
-                                      "Valid range: [\"0, 1000000000\"]", arg);
-                }
+            if (gf_string2boolean(arg, &b) == 0) {
+                cmd_args->kernel_writeback_cache = b;
 
                 break;
+            }
 
-	}
-        return 0;
+            argp_failure(state, -1, 0,
+                         "unknown kernel writeback cache setting \"%s\"", arg);
+            break;
+        case ARGP_ATTR_TIMES_GRANULARITY_KEY:
+            if (gf_string2uint32(arg, &cmd_args->attr_times_granularity)) {
+                argp_failure(state, -1, 0,
+                             "unknown attribute times granularity option %s",
+                             arg);
+            } else if (cmd_args->attr_times_granularity > 1000000000) {
+                argp_failure(state, -1, 0,
+                             "Invalid attribute times granularity value %s. "
+                             "Valid range: [\"0, 1000000000\"]",
+                             arg);
+            }
+
+            break;
+    }
+    return 0;
 }
 
 gf_boolean_t
-should_call_fini (glusterfs_ctx_t *ctx, xlator_t *trav)
+should_call_fini(glusterfs_ctx_t *ctx, xlator_t *trav)
 {
-        /* There's nothing to call, so the other checks don't matter. */
-        if (!trav->fini) {
-                return _gf_false;
-        }
+    /* There's nothing to call, so the other checks don't matter. */
+    if (!trav->fini) {
+        return _gf_false;
+    }
 
-        /* This preserves previous behavior in glusterd. */
-        if (ctx->process_mode == GF_GLUSTERD_PROCESS) {
-                return _gf_true;
-        }
+    /* This preserves previous behavior in glusterd. */
+    if (ctx->process_mode == GF_GLUSTERD_PROCESS) {
+        return _gf_true;
+    }
 
-        /* This is the only one known to be safe in glusterfsd. */
-        if (!strcmp(trav->type,"experimental/fdl")) {
-                return _gf_true;
-        }
+    /* This is the only one known to be safe in glusterfsd. */
+    if (!strcmp(trav->type, "experimental/fdl")) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 void
-cleanup_and_exit (int signum)
+cleanup_and_exit(int signum)
 {
-        glusterfs_ctx_t *ctx      = NULL;
-        xlator_t        *trav     = NULL;
-        xlator_t        *top;
-        xlator_t        *victim;
-        xlator_list_t   **trav_p;
-
-        ctx = glusterfsd_ctx;
-
-        if (!ctx)
-                return;
-
-        /* To take or not to take the mutex here and in the other
-         * signal handler - gf_print_trace() - is the big question here.
-         *
-         * Taking mutex in signal handler would mean that if the process
-         * receives a fatal signal while another thread is holding
-         * ctx->log.log_buf_lock to perhaps log a message in _gf_msg_internal(),
-         * the offending thread hangs on the mutex lock forever without letting
-         * the process exit.
-         *
-         * On the other hand. not taking the mutex in signal handler would cause
-         * it to modify the lru_list of buffered log messages in a racy manner,
-         * corrupt the list and potentially give rise to an unending
-         * cascade of SIGSEGVs and other re-entrancy issues.
-         */
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_t *trav = NULL;
+    xlator_t *top;
+    xlator_t *victim;
+    xlator_list_t **trav_p;
 
-        gf_log_disable_suppression_before_exit (ctx);
+    ctx = glusterfsd_ctx;
 
-        gf_msg_callingfn ("", GF_LOG_WARNING, 0, glusterfsd_msg_32,
-                          "received signum (%d), shutting down", signum);
-
-        if (ctx->cleanup_started)
-                return;
-
-        ctx->cleanup_started = 1;
-
-        /* signout should be sent to all the bricks in case brick mux is enabled
-         * and multiple brick instances are attached to this process
-         */
-        if (ctx->active) {
-                top = ctx->active->first;
-                for (trav_p = &top->children; *trav_p;
-                     trav_p = &(*trav_p)->next) {
-                        victim = (*trav_p)->xlator;
-                        rpc_clnt_mgmt_pmap_signout (ctx, victim->name);
-                }
-        } else {
-                rpc_clnt_mgmt_pmap_signout (ctx, NULL);
-        }
+    if (!ctx)
+        return;
 
-        /* below part is a racy code where the rpcsvc object is freed.
-         * But in another thread (epoll thread), upon poll error in the
-         * socket the transports are cleaned up where again rpcsvc object
-         * is accessed (which is already freed by the below function).
-         * Since the process is about to be killed don't execute the function
-         * below.
-         */
-        /* if (ctx->listener) { */
-        /*         (void) glusterfs_listener_stop (ctx); */
-        /* } */
-
-        /* Call fini() of FUSE xlator first:
-         * so there are no more requests coming and
-         * 'umount' of mount point is done properly */
-        trav = ctx->master;
-        if (trav && trav->fini) {
-                THIS = trav;
-                trav->fini (trav);
-        }
+    /* To take or not to take the mutex here and in the other
+     * signal handler - gf_print_trace() - is the big question here.
+     *
+     * Taking mutex in signal handler would mean that if the process
+     * receives a fatal signal while another thread is holding
+     * ctx->log.log_buf_lock to perhaps log a message in _gf_msg_internal(),
+     * the offending thread hangs on the mutex lock forever without letting
+     * the process exit.
+     *
+     * On the other hand. not taking the mutex in signal handler would cause
+     * it to modify the lru_list of buffered log messages in a racy manner,
+     * corrupt the list and potentially give rise to an unending
+     * cascade of SIGSEGVs and other re-entrancy issues.
+     */
+
+    gf_log_disable_suppression_before_exit(ctx);
+
+    gf_msg_callingfn("", GF_LOG_WARNING, 0, glusterfsd_msg_32,
+                     "received signum (%d), shutting down", signum);
+
+    if (ctx->cleanup_started)
+        return;
 
-        glusterfs_pidfile_cleanup (ctx);
+    ctx->cleanup_started = 1;
+
+    /* signout should be sent to all the bricks in case brick mux is enabled
+     * and multiple brick instances are attached to this process
+     */
+    if (ctx->active) {
+        top = ctx->active->first;
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            victim = (*trav_p)->xlator;
+            rpc_clnt_mgmt_pmap_signout(ctx, victim->name);
+        }
+    } else {
+        rpc_clnt_mgmt_pmap_signout(ctx, NULL);
+    }
+
+    /* below part is a racy code where the rpcsvc object is freed.
+     * But in another thread (epoll thread), upon poll error in the
+     * socket the transports are cleaned up where again rpcsvc object
+     * is accessed (which is already freed by the below function).
+     * Since the process is about to be killed don't execute the function
+     * below.
+     */
+    /* if (ctx->listener) { */
+    /*         (void) glusterfs_listener_stop (ctx); */
+    /* } */
+
+    /* Call fini() of FUSE xlator first:
+     * so there are no more requests coming and
+     * 'umount' of mount point is done properly */
+    trav = ctx->master;
+    if (trav && trav->fini) {
+        THIS = trav;
+        trav->fini(trav);
+    }
+
+    glusterfs_pidfile_cleanup(ctx);
 
 #if 0
         /* TODO: Properly do cleanup_and_exit(), with synchronization */
@@ -1569,303 +1529,304 @@ cleanup_and_exit (int signum)
         }
 #endif
 
-        trav = NULL;
+    trav = NULL;
 
-        /* NOTE: Only the least significant 8 bits i.e (signum & 255)
-           will be available to parent process on calling exit() */
-        exit(abs(signum));
+    /* NOTE: Only the least significant 8 bits i.e (signum & 255)
+       will be available to parent process on calling exit() */
+    exit(abs(signum));
 }
 
-
 static void
-reincarnate (int signum)
+reincarnate(int signum)
 {
-        int                 ret = 0;
-        glusterfs_ctx_t    *ctx = NULL;
-        cmd_args_t         *cmd_args = NULL;
-
-        ctx = glusterfsd_ctx;
-        cmd_args = &ctx->cmd_args;
-
-        if (cmd_args->volfile_server) {
-                gf_msg ("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11,
-                        "Fetching the volume file from server...");
-                ret = glusterfs_volfile_fetch (ctx);
-        } else {
-                gf_msg_debug ("glusterfsd", 0,
-                              "Not reloading volume specification file"
-                              " on SIGHUP");
-        }
-
-        /* Also, SIGHUP should do logrotate */
-        gf_log_logrotate (1);
-
-        if (ret < 0)
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12,
-                        "volume initialization failed.");
-
-        return;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+
+    ctx = glusterfsd_ctx;
+    cmd_args = &ctx->cmd_args;
+
+    if (cmd_args->volfile_server) {
+        gf_msg("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11,
+               "Fetching the volume file from server...");
+        ret = glusterfs_volfile_fetch(ctx);
+    } else {
+        gf_msg_debug("glusterfsd", 0,
+                     "Not reloading volume specification file"
+                     " on SIGHUP");
+    }
+
+    /* Also, SIGHUP should do logrotate */
+    gf_log_logrotate(1);
+
+    if (ret < 0)
+        gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12,
+               "volume initialization failed.");
+
+    return;
 }
 
 void
-emancipate (glusterfs_ctx_t *ctx, int ret)
+emancipate(glusterfs_ctx_t *ctx, int ret)
 {
-        /* break free from the parent */
-        if (ctx->daemon_pipe[1] != -1) {
-                sys_write (ctx->daemon_pipe[1], (void *) &ret, sizeof (ret));
-                sys_close (ctx->daemon_pipe[1]);
-                ctx->daemon_pipe[1] = -1;
-        }
+    /* break free from the parent */
+    if (ctx->daemon_pipe[1] != -1) {
+        sys_write(ctx->daemon_pipe[1], (void *)&ret, sizeof(ret));
+        sys_close(ctx->daemon_pipe[1]);
+        ctx->daemon_pipe[1] = -1;
+    }
 }
 
 static uint8_t
-gf_get_process_mode (char *exec_name)
+gf_get_process_mode(char *exec_name)
 {
-        char *dup_execname = NULL, *base = NULL;
-        uint8_t ret = 0;
+    char *dup_execname = NULL, *base = NULL;
+    uint8_t ret = 0;
 
-        dup_execname = gf_strdup (exec_name);
-        base = basename (dup_execname);
+    dup_execname = gf_strdup(exec_name);
+    base = basename(dup_execname);
 
-        if (!strncmp (base, "glusterfsd", 10)) {
-                ret = GF_SERVER_PROCESS;
-        } else if (!strncmp (base, "glusterd", 8)) {
-                ret = GF_GLUSTERD_PROCESS;
-        } else {
-                ret = GF_CLIENT_PROCESS;
-        }
+    if (!strncmp(base, "glusterfsd", 10)) {
+        ret = GF_SERVER_PROCESS;
+    } else if (!strncmp(base, "glusterd", 8)) {
+        ret = GF_GLUSTERD_PROCESS;
+    } else {
+        ret = GF_CLIENT_PROCESS;
+    }
 
-        GF_FREE (dup_execname);
+    GF_FREE(dup_execname);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
+glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t          *cmd_args = NULL;
-        struct rlimit        lim      = {0, };
-        int                  ret      = -1;
-
-        if (!ctx)
-                return ret;
-
-        ret = xlator_mem_acct_init (THIS, gfd_mt_end);
-        if (ret != 0) {
-                gf_msg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34,
-                       "memory accounting init failed.");
-                return ret;
-        }
+    cmd_args_t *cmd_args = NULL;
+    struct rlimit lim = {
+        0,
+    };
+    int ret = -1;
 
-        /* reset ret to -1 so that we don't need to explicitly
-         * set it in all error paths before "goto err"
-         */
-        ret = -1;
-
-        /* monitoring should be enabled by default */
-        ctx->measure_latency = true;
-
-        ctx->process_uuid = generate_glusterfs_ctx_id ();
-        if (!ctx->process_uuid) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13,
-                        "ERROR: glusterfs uuid generation failed");
-                goto out;
-        }
-
-        ctx->page_size  = 128 * GF_UNIT_KB;
-
-        ctx->iobuf_pool = iobuf_pool_new ();
-        if (!ctx->iobuf_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs iobuf pool creation failed");
-                goto out;
-        }
-
-        ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE,
-                                          STARTING_EVENT_THREADS);
-        if (!ctx->event_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs event pool creation failed");
-                goto out;
-        }
-
-        ctx->pool = GF_CALLOC (1, sizeof (call_pool_t), gfd_mt_call_pool_t);
-        if (!ctx->pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs call pool creation failed");
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&ctx->pool->all_frames);
-        LOCK_INIT (&ctx->pool->lock);
-
-        /* frame_mem_pool size 112 * 4k */
-        ctx->pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096);
-        if (!ctx->pool->frame_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs frame pool creation failed");
-                goto out;
-        }
-        /* stack_mem_pool size 256 * 1024 */
-        ctx->pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024);
-        if (!ctx->pool->stack_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs stack pool creation failed");
-                goto out;
-        }
-
-        ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
-        if (!ctx->stub_mem_pool) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
-                        "ERROR: glusterfs stub pool creation failed");
-                goto out;
-        }
-
-        ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
-        if (!ctx->dict_pool)
-                goto out;
-
-        ctx->dict_pair_pool = mem_pool_new (data_pair_t,
-                                            GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
-        if (!ctx->dict_pair_pool)
-                goto out;
-
-        ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
-        if (!ctx->dict_data_pool)
-                goto out;
-
-        ctx->logbuf_pool = mem_pool_new (log_buf_t,
-                                         GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
-        if (!ctx->logbuf_pool)
-                goto out;
-
-        pthread_mutex_init (&ctx->notify_lock, NULL);
-        pthread_cond_init (&ctx->notify_cond, NULL);
-
-        ctx->clienttable = gf_clienttable_alloc();
-        if (!ctx->clienttable)
-                goto out;
-
-        cmd_args = &ctx->cmd_args;
-
-        /* parsing command line arguments */
-        cmd_args->log_level = DEFAULT_LOG_LEVEL;
-        cmd_args->logger    = gf_logger_glusterlog;
-        cmd_args->log_format = gf_logformat_withmsgid;
-        cmd_args->log_buf_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
-        cmd_args->log_flush_timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+    if (!ctx)
+        return ret;
 
-        cmd_args->mac_compat = GF_OPTION_DISABLE;
+    ret = xlator_mem_acct_init(THIS, gfd_mt_end);
+    if (ret != 0) {
+        gf_msg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34,
+               "memory accounting init failed.");
+        return ret;
+    }
+
+    /* reset ret to -1 so that we don't need to explicitly
+     * set it in all error paths before "goto err"
+     */
+    ret = -1;
+
+    /* monitoring should be enabled by default */
+    ctx->measure_latency = true;
+
+    ctx->process_uuid = generate_glusterfs_ctx_id();
+    if (!ctx->process_uuid) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13,
+               "ERROR: glusterfs uuid generation failed");
+        goto out;
+    }
+
+    ctx->page_size = 128 * GF_UNIT_KB;
+
+    ctx->iobuf_pool = iobuf_pool_new();
+    if (!ctx->iobuf_pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs iobuf pool creation failed");
+        goto out;
+    }
+
+    ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE,
+                                     STARTING_EVENT_THREADS);
+    if (!ctx->event_pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs event pool creation failed");
+        goto out;
+    }
+
+    ctx->pool = GF_CALLOC(1, sizeof(call_pool_t), gfd_mt_call_pool_t);
+    if (!ctx->pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs call pool creation failed");
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&ctx->pool->all_frames);
+    LOCK_INIT(&ctx->pool->lock);
+
+    /* frame_mem_pool size 112 * 4k */
+    ctx->pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096);
+    if (!ctx->pool->frame_mem_pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs frame pool creation failed");
+        goto out;
+    }
+    /* stack_mem_pool size 256 * 1024 */
+    ctx->pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024);
+    if (!ctx->pool->stack_mem_pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs stack pool creation failed");
+        goto out;
+    }
+
+    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024);
+    if (!ctx->stub_mem_pool) {
+        gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14,
+               "ERROR: glusterfs stub pool creation failed");
+        goto out;
+    }
+
+    ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
+    if (!ctx->dict_pool)
+        goto out;
+
+    ctx->dict_pair_pool = mem_pool_new(data_pair_t,
+                                       GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
+    if (!ctx->dict_pair_pool)
+        goto out;
+
+    ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
+    if (!ctx->dict_data_pool)
+        goto out;
+
+    ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T);
+    if (!ctx->logbuf_pool)
+        goto out;
+
+    pthread_mutex_init(&ctx->notify_lock, NULL);
+    pthread_cond_init(&ctx->notify_cond, NULL);
+
+    ctx->clienttable = gf_clienttable_alloc();
+    if (!ctx->clienttable)
+        goto out;
+
+    cmd_args = &ctx->cmd_args;
+
+    /* parsing command line arguments */
+    cmd_args->log_level = DEFAULT_LOG_LEVEL;
+    cmd_args->logger = gf_logger_glusterlog;
+    cmd_args->log_format = gf_logformat_withmsgid;
+    cmd_args->log_buf_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
+    cmd_args->log_flush_timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+
+    cmd_args->mac_compat = GF_OPTION_DISABLE;
 #ifdef GF_DARWIN_HOST_OS
-        /* On Darwin machines, O_APPEND is not handled,
-         * which may corrupt the data
-         */
-        cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
+    /* On Darwin machines, O_APPEND is not handled,
+     * which may corrupt the data
+     */
+    cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
 #else
-        cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
+    cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
 #endif
-        cmd_args->fuse_attribute_timeout = -1;
-        cmd_args->fuse_entry_timeout = -1;
-	cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;
-        cmd_args->kernel_writeback_cache = GF_OPTION_DEFERRED;
+    cmd_args->fuse_attribute_timeout = -1;
+    cmd_args->fuse_entry_timeout = -1;
+    cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;
+    cmd_args->kernel_writeback_cache = GF_OPTION_DEFERRED;
 
-        if (ctx->mem_acct_enable)
-                cmd_args->mem_acct = 1;
+    if (ctx->mem_acct_enable)
+        cmd_args->mem_acct = 1;
 
-        INIT_LIST_HEAD (&cmd_args->xlator_options);
-        INIT_LIST_HEAD (&cmd_args->volfile_servers);
+    INIT_LIST_HEAD(&cmd_args->xlator_options);
+    INIT_LIST_HEAD(&cmd_args->volfile_servers);
 
-        lim.rlim_cur = RLIM_INFINITY;
-        lim.rlim_max = RLIM_INFINITY;
-        setrlimit (RLIMIT_CORE, &lim);
+    lim.rlim_cur = RLIM_INFINITY;
+    lim.rlim_max = RLIM_INFINITY;
+    setrlimit(RLIMIT_CORE, &lim);
 
-        ret = 0;
+    ret = 0;
 out:
 
-        if (ret) {
-                if (ctx->pool) {
-                        mem_pool_destroy (ctx->pool->frame_mem_pool);
-                        mem_pool_destroy (ctx->pool->stack_mem_pool);
-                }
-                GF_FREE (ctx->pool);
-                mem_pool_destroy (ctx->stub_mem_pool);
-                mem_pool_destroy (ctx->dict_pool);
-                mem_pool_destroy (ctx->dict_data_pool);
-                mem_pool_destroy (ctx->dict_pair_pool);
-                mem_pool_destroy (ctx->logbuf_pool);
+    if (ret) {
+        if (ctx->pool) {
+            mem_pool_destroy(ctx->pool->frame_mem_pool);
+            mem_pool_destroy(ctx->pool->stack_mem_pool);
         }
+        GF_FREE(ctx->pool);
+        mem_pool_destroy(ctx->stub_mem_pool);
+        mem_pool_destroy(ctx->dict_pool);
+        mem_pool_destroy(ctx->dict_data_pool);
+        mem_pool_destroy(ctx->dict_pair_pool);
+        mem_pool_destroy(ctx->logbuf_pool);
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-logging_init (glusterfs_ctx_t *ctx, const char *progpath)
+logging_init(glusterfs_ctx_t *ctx, const char *progpath)
 {
-        cmd_args_t *cmd_args = NULL;
-        int         ret = 0;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->log_file == NULL) {
-                ret = gf_set_log_file_path (cmd_args, ctx);
-                if (ret == -1) {
-                        fprintf (stderr, "ERROR: failed to set the log file "
-                                         "path\n");
-                        return -1;
-                }
+    if (cmd_args->log_file == NULL) {
+        ret = gf_set_log_file_path(cmd_args, ctx);
+        if (ret == -1) {
+            fprintf(stderr,
+                    "ERROR: failed to set the log file "
+                    "path\n");
+            return -1;
         }
+    }
 
-        if (cmd_args->log_ident == NULL) {
-                ret = gf_set_log_ident (cmd_args);
-                if (ret == -1) {
-                        fprintf (stderr, "ERROR: failed to set the log "
-                                         "identity\n");
-                        return -1;
-                }
+    if (cmd_args->log_ident == NULL) {
+        ret = gf_set_log_ident(cmd_args);
+        if (ret == -1) {
+            fprintf(stderr,
+                    "ERROR: failed to set the log "
+                    "identity\n");
+            return -1;
         }
+    }
 
-        /* finish log set parameters before init */
-        gf_log_set_loglevel (ctx, cmd_args->log_level);
+    /* finish log set parameters before init */
+    gf_log_set_loglevel(ctx, cmd_args->log_level);
 
-        gf_log_set_localtime (cmd_args->localtime_logging);
+    gf_log_set_localtime(cmd_args->localtime_logging);
 
-        gf_log_set_logger (cmd_args->logger);
+    gf_log_set_logger(cmd_args->logger);
 
-        gf_log_set_logformat (cmd_args->log_format);
+    gf_log_set_logformat(cmd_args->log_format);
 
-        gf_log_set_log_buf_size (cmd_args->log_buf_size);
+    gf_log_set_log_buf_size(cmd_args->log_buf_size);
 
-        gf_log_set_log_flush_timeout (cmd_args->log_flush_timeout);
+    gf_log_set_log_flush_timeout(cmd_args->log_flush_timeout);
 
-        if (gf_log_init (ctx, cmd_args->log_file, cmd_args->log_ident) == -1) {
-                fprintf (stderr, "ERROR: failed to open logfile %s\n",
-                         cmd_args->log_file);
-                return -1;
-        }
+    if (gf_log_init(ctx, cmd_args->log_file, cmd_args->log_ident) == -1) {
+        fprintf(stderr, "ERROR: failed to open logfile %s\n",
+                cmd_args->log_file);
+        return -1;
+    }
 
-        /* At this point, all the logging related parameters are initialised
-         * except for the log flush timer, which will be injected post fork(2)
-         * in daemonize() . During this time, any log message that is logged
-         * will be kept buffered. And if the list that holds these messages
-         * overflows, then the same lru policy is used to drive out the least
-         * recently used message and displace it with the message just logged.
-         */
+    /* At this point, all the logging related parameters are initialised
+     * except for the log flush timer, which will be injected post fork(2)
+     * in daemonize() . During this time, any log message that is logged
+     * will be kept buffered. And if the list that holds these messages
+     * overflows, then the same lru policy is used to drive out the least
+     * recently used message and displace it with the message just logged.
+     */
 
-        return 0;
+    return 0;
 }
 
 void
-gf_check_and_set_mem_acct (int argc, char *argv[])
+gf_check_and_set_mem_acct(int argc, char *argv[])
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < argc; i++) {
-                if (strcmp (argv[i], "--no-mem-accounting") == 0) {
-			gf_global_mem_acct_enable_set (0);
-                        break;
-                }
+    for (i = 0; i < argc; i++) {
+        if (strcmp(argv[i], "--no-mem-accounting") == 0) {
+            gf_global_mem_acct_enable_set(0);
+            break;
         }
+    }
 }
 
 /**
@@ -1883,87 +1844,85 @@ gf_check_and_set_mem_acct (int argc, char *argv[])
  * error messages. Hence there are different return values.
  */
 int
-print_exports_file (const char *exports_file)
+print_exports_file(const char *exports_file)
 {
-        void                   *libhandle = NULL;
-        char                   *libpathfull = NULL;
-        struct exports_file    *file = NULL;
-        int                     ret = 0;
-
-        int  (*exp_file_parse)(const char *filepath,
-                               struct exports_file **expfile,
-                               struct mount3_state *ms) = NULL;
-        void (*exp_file_print)(const struct exports_file *file) = NULL;
-        void (*exp_file_deinit)(struct exports_file *ptr) = NULL;
-
-        /* XLATORDIR passed through a -D flag to GCC */
-        ret = gf_asprintf (&libpathfull, "%s/%s/server.so", XLATORDIR,
-                           "nfs");
-        if (ret < 0) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the library */
-        libhandle = dlopen (libpathfull, RTLD_NOW);
-        if (!libhandle) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error loading NFS server library : "
-                        "%s\n", dlerror ());
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the function */
-        exp_file_parse = dlsym (libhandle, "exp_file_parse");
-        if (!exp_file_parse) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_parse "
-                        "in symbol.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Parse the file */
-        ret = exp_file_parse (exports_file, &file, NULL);
-        if (ret < 0) {
-                ret = 1;        /* This means we failed to parse */
-                goto out;
-        }
-
-        /* Load up the function */
-        exp_file_print = dlsym (libhandle, "exp_file_print");
-        if (!exp_file_print) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_print in symbol.");
-                ret = -1;
-                goto out;
-        }
+    void *libhandle = NULL;
+    char *libpathfull = NULL;
+    struct exports_file *file = NULL;
+    int ret = 0;
+
+    int (*exp_file_parse)(const char *filepath, struct exports_file **expfile,
+                          struct mount3_state *ms) = NULL;
+    void (*exp_file_print)(const struct exports_file *file) = NULL;
+    void (*exp_file_deinit)(struct exports_file * ptr) = NULL;
+
+    /* XLATORDIR passed through a -D flag to GCC */
+    ret = gf_asprintf(&libpathfull, "%s/%s/server.so", XLATORDIR, "nfs");
+    if (ret < 0) {
+        gf_log("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the library */
+    libhandle = dlopen(libpathfull, RTLD_NOW);
+    if (!libhandle) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error loading NFS server library : "
+               "%s\n",
+               dlerror());
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the function */
+    exp_file_parse = dlsym(libhandle, "exp_file_parse");
+    if (!exp_file_parse) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_parse "
+               "in symbol.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Parse the file */
+    ret = exp_file_parse(exports_file, &file, NULL);
+    if (ret < 0) {
+        ret = 1; /* This means we failed to parse */
+        goto out;
+    }
+
+    /* Load up the function */
+    exp_file_print = dlsym(libhandle, "exp_file_print");
+    if (!exp_file_print) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_print in symbol.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Print it out to screen */
-        exp_file_print (file);
+    /* Print it out to screen */
+    exp_file_print(file);
 
-        /* Load up the function */
-        exp_file_deinit = dlsym (libhandle, "exp_file_deinit");
-        if (!exp_file_deinit) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function exp_file_deinit in lib.");
-                ret = -1;
-                goto out;
-        }
+    /* Load up the function */
+    exp_file_deinit = dlsym(libhandle, "exp_file_deinit");
+    if (!exp_file_deinit) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function exp_file_deinit in lib.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Free the file */
-        exp_file_deinit (file);
+    /* Free the file */
+    exp_file_deinit(file);
 
 out:
-        if (libhandle)
-                dlclose(libhandle);
-        GF_FREE (libpathfull);
-        return ret;
+    if (libhandle)
+        dlclose(libhandle);
+    GF_FREE(libpathfull);
+    return ret;
 }
 
-
 /**
  * print_netgroups_file - Print out & verify the syntax
  *                        of the netgroups file specified
@@ -1981,821 +1940,804 @@ out:
  * we want to print out a different error messages based on the ret value.
  */
 int
-print_netgroups_file (const char *netgroups_file)
+print_netgroups_file(const char *netgroups_file)
 {
-        void                   *libhandle = NULL;
-        char                   *libpathfull = NULL;
-        struct netgroups_file  *file = NULL;
-        int                     ret = 0;
-
-        struct netgroups_file  *(*ng_file_parse)(const char *file_path) = NULL;
-        void         (*ng_file_print)(const struct netgroups_file *file) = NULL;
-        void         (*ng_file_deinit)(struct netgroups_file *ptr) = NULL;
-
-        /* XLATORDIR passed through a -D flag to GCC */
-        ret = gf_asprintf (&libpathfull, "%s/%s/server.so", XLATORDIR,
-                        "nfs");
-        if (ret < 0) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
-                ret = -1;
-                goto out;
-        }
-        /* Load up the library */
-        libhandle = dlopen (libpathfull, RTLD_NOW);
-        if (!libhandle) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error loading NFS server library : %s\n", dlerror ());
-                ret = -1;
-                goto out;
-        }
-
-        /* Load up the function */
-        ng_file_parse = dlsym (libhandle, "ng_file_parse");
-        if (!ng_file_parse) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_parse in symbol.");
-                ret = -1;
-                goto out;
-        }
-
-        /* Parse the file */
-        file = ng_file_parse (netgroups_file);
-        if (!file) {
-                ret = 1;        /* This means we failed to parse */
-                goto out;
-        }
-
-        /* Load up the function */
-        ng_file_print = dlsym (libhandle, "ng_file_print");
-        if (!ng_file_print) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_print in symbol.");
-                ret = -1;
-                goto out;
-        }
+    void *libhandle = NULL;
+    char *libpathfull = NULL;
+    struct netgroups_file *file = NULL;
+    int ret = 0;
+
+    struct netgroups_file *(*ng_file_parse)(const char *file_path) = NULL;
+    void (*ng_file_print)(const struct netgroups_file *file) = NULL;
+    void (*ng_file_deinit)(struct netgroups_file * ptr) = NULL;
+
+    /* XLATORDIR passed through a -D flag to GCC */
+    ret = gf_asprintf(&libpathfull, "%s/%s/server.so", XLATORDIR, "nfs");
+    if (ret < 0) {
+        gf_log("glusterfs", GF_LOG_CRITICAL, "asprintf () failed.");
+        ret = -1;
+        goto out;
+    }
+    /* Load up the library */
+    libhandle = dlopen(libpathfull, RTLD_NOW);
+    if (!libhandle) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error loading NFS server library : %s\n", dlerror());
+        ret = -1;
+        goto out;
+    }
+
+    /* Load up the function */
+    ng_file_parse = dlsym(libhandle, "ng_file_parse");
+    if (!ng_file_parse) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_parse in symbol.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Parse the file */
+    file = ng_file_parse(netgroups_file);
+    if (!file) {
+        ret = 1; /* This means we failed to parse */
+        goto out;
+    }
+
+    /* Load up the function */
+    ng_file_print = dlsym(libhandle, "ng_file_print");
+    if (!ng_file_print) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_print in symbol.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Print it out to screen */
-        ng_file_print (file);
+    /* Print it out to screen */
+    ng_file_print(file);
 
-        /* Load up the function */
-        ng_file_deinit = dlsym (libhandle, "ng_file_deinit");
-        if (!ng_file_deinit) {
-                gf_log ("glusterfs", GF_LOG_CRITICAL,
-                        "Error finding function ng_file_deinit in lib.");
-                ret = -1;
-                goto out;
-        }
+    /* Load up the function */
+    ng_file_deinit = dlsym(libhandle, "ng_file_deinit");
+    if (!ng_file_deinit) {
+        gf_log("glusterfs", GF_LOG_CRITICAL,
+               "Error finding function ng_file_deinit in lib.");
+        ret = -1;
+        goto out;
+    }
 
-        /* Free the file */
-        ng_file_deinit (file);
+    /* Free the file */
+    ng_file_deinit(file);
 
 out:
-        if (libhandle)
-                dlclose(libhandle);
-        GF_FREE (libpathfull);
-        return ret;
+    if (libhandle)
+        dlclose(libhandle);
+    GF_FREE(libpathfull);
+    return ret;
 }
 
-
 int
-parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx)
+parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx)
 {
-        int          process_mode = 0;
-        int          ret = 0;
-        struct stat  stbuf = {0, };
-        char         timestr[32];
-        char         tmp_logfile[1024] = { 0 };
-        char        *tmp_logfile_dyn = NULL;
-        char        *tmp_logfilebase = NULL;
-        cmd_args_t  *cmd_args = NULL;
-        int          len = 0;
-        char        *thin_volfileid = NULL;
-
-        cmd_args = &ctx->cmd_args;
-
-        /* Do this before argp_parse so it can be overridden. */
-        if (sys_access (SECURE_ACCESS_FILE, F_OK) == 0) {
-                cmd_args->secure_mgmt = 1;
-                ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-
-        argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
-
-        if (cmd_args->print_xlatordir || cmd_args->print_statedumpdir ||
-            cmd_args->print_logdir || cmd_args->print_libexecdir) {
-                /* Just print, nothing else to do */
-                goto out;
-        }
-
-        if (cmd_args->print_netgroups) {
-                /* When this option is set we don't want to do anything else
-                 * except for printing & verifying the netgroups file.
-                 */
-                ret = 0;
-                goto out;
-        }
+    int process_mode = 0;
+    int ret = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char timestr[32];
+    char tmp_logfile[1024] = {0};
+    char *tmp_logfile_dyn = NULL;
+    char *tmp_logfilebase = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int len = 0;
+    char *thin_volfileid = NULL;
+
+    cmd_args = &ctx->cmd_args;
+
+    /* Do this before argp_parse so it can be overridden. */
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        cmd_args->secure_mgmt = 1;
+        ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+
+    argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
+
+    if (cmd_args->print_xlatordir || cmd_args->print_statedumpdir ||
+        cmd_args->print_logdir || cmd_args->print_libexecdir) {
+        /* Just print, nothing else to do */
+        goto out;
+    }
+
+    if (cmd_args->print_netgroups) {
+        /* When this option is set we don't want to do anything else
+         * except for printing & verifying the netgroups file.
+         */
+        ret = 0;
+        goto out;
+    }
 
-        if (cmd_args->print_exports) {
-                /* When this option is set we don't want to do anything else
-                 * except for printing & verifying the exports file.
-                  */
-                ret = 0;
+    if (cmd_args->print_exports) {
+        /* When this option is set we don't want to do anything else
+         * except for printing & verifying the exports file.
+         */
+        ret = 0;
+        goto out;
+    }
+
+    ctx->secure_mgmt = cmd_args->secure_mgmt;
+
+    if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
+        cmd_args->log_level = GF_LOG_DEBUG;
+        cmd_args->log_file = gf_strdup("/dev/stderr");
+        cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+    }
+
+    process_mode = gf_get_process_mode(argv[0]);
+    ctx->process_mode = process_mode;
+
+    if (cmd_args->process_name) {
+        ctx->cmd_args.process_name = cmd_args->process_name;
+    }
+    /* Make sure after the parsing cli, if '--volfile-server' option is
+       given, then '--volfile-id' is mandatory */
+    if (cmd_args->volfile_server && !cmd_args->volfile_id) {
+        gf_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15,
+               "ERROR: '--volfile-id' is mandatory if '-s' OR "
+               "'--volfile-server' option is given");
+        ret = -1;
+        goto out;
+    }
+
+    if ((cmd_args->volfile_server == NULL) && (cmd_args->volfile == NULL)) {
+        if (process_mode == GF_SERVER_PROCESS)
+            cmd_args->volfile = gf_strdup(DEFAULT_SERVER_VOLFILE);
+        else if (process_mode == GF_GLUSTERD_PROCESS)
+            cmd_args->volfile = gf_strdup(DEFAULT_GLUSTERD_VOLFILE);
+        else
+            cmd_args->volfile = gf_strdup(DEFAULT_CLIENT_VOLFILE);
+
+        /* Check if the volfile exists, if not give usage output
+           and exit */
+        ret = sys_stat(cmd_args->volfile, &stbuf);
+        if (ret) {
+            gf_msg("glusterfs", GF_LOG_CRITICAL, errno, glusterfsd_msg_16,
+                   "ERROR: parsing the volfile failed");
+            /* argp_usage (argp.) */
+            fprintf(stderr, "USAGE: %s [options] [mountpoint]\n", argv[0]);
+            goto out;
+        }
+    }
+
+    if (cmd_args->thin_client) {
+        len = strlen(cmd_args->volfile_id) + SLEN("gfproxy-client/");
+        thin_volfileid = GF_MALLOC(len + 1, gf_common_mt_char);
+        snprintf(thin_volfileid, len + 1, "gfproxy-client/%s",
+                 cmd_args->volfile_id);
+        GF_FREE(cmd_args->volfile_id);
+        cmd_args->volfile_id = thin_volfileid;
+    }
+
+    if (cmd_args->run_id) {
+        ret = sys_lstat(cmd_args->log_file, &stbuf);
+        /* If its /dev/null, or /dev/stdout, /dev/stderr,
+         * let it use the same, no need to alter
+         */
+        if (((ret == 0) &&
+             (S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) ||
+            (ret == -1)) {
+            /* Have separate logfile per run */
+            gf_time_fmt(timestr, sizeof timestr, time(NULL), gf_timefmt_FT);
+            sprintf(tmp_logfile, "%s.%s.%d", cmd_args->log_file, timestr,
+                    getpid());
+
+            /* Create symlink to actual log file */
+            sys_unlink(cmd_args->log_file);
+
+            tmp_logfile_dyn = gf_strdup(tmp_logfile);
+            tmp_logfilebase = basename(tmp_logfile_dyn);
+            ret = sys_symlink(tmp_logfilebase, cmd_args->log_file);
+            if (ret == -1) {
+                fprintf(stderr, "ERROR: symlink of logfile failed\n");
                 goto out;
-        }
-
+            }
 
-        ctx->secure_mgmt = cmd_args->secure_mgmt;
+            GF_FREE(cmd_args->log_file);
+            cmd_args->log_file = gf_strdup(tmp_logfile);
 
-        if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
-                cmd_args->log_level = GF_LOG_DEBUG;
-                cmd_args->log_file = gf_strdup ("/dev/stderr");
-                cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
-        }
-
-        process_mode = gf_get_process_mode (argv[0]);
-        ctx->process_mode = process_mode;
-
-        if (cmd_args->process_name) {
-                ctx->cmd_args.process_name = cmd_args->process_name;
-        }
-        /* Make sure after the parsing cli, if '--volfile-server' option is
-           given, then '--volfile-id' is mandatory */
-        if (cmd_args->volfile_server && !cmd_args->volfile_id) {
-                gf_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15,
-                        "ERROR: '--volfile-id' is mandatory if '-s' OR "
-                        "'--volfile-server' option is given");
-                ret = -1;
-                goto out;
+            GF_FREE(tmp_logfile_dyn);
         }
+    }
 
-        if ((cmd_args->volfile_server == NULL)
-            && (cmd_args->volfile == NULL)) {
-                if (process_mode == GF_SERVER_PROCESS)
-                        cmd_args->volfile = gf_strdup (DEFAULT_SERVER_VOLFILE);
-                else if (process_mode == GF_GLUSTERD_PROCESS)
-                        cmd_args->volfile = gf_strdup (DEFAULT_GLUSTERD_VOLFILE);
-                else
-                        cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
-
-                /* Check if the volfile exists, if not give usage output
-                   and exit */
-                ret = sys_stat (cmd_args->volfile, &stbuf);
-                if (ret) {
-                        gf_msg ("glusterfs", GF_LOG_CRITICAL, errno,
-                                glusterfsd_msg_16,
-                                "ERROR: parsing the volfile failed");
-                        /* argp_usage (argp.) */
-                        fprintf (stderr, "USAGE: %s [options] [mountpoint]\n",
-                                 argv[0]);
-                        goto out;
-                }
-        }
-
-        if (cmd_args->thin_client) {
-                len = strlen (cmd_args->volfile_id) + SLEN ("gfproxy-client/");
-                thin_volfileid = GF_MALLOC (len + 1, gf_common_mt_char);
-                snprintf (thin_volfileid, len + 1, "gfproxy-client/%s",
-                          cmd_args->volfile_id);
-                GF_FREE (cmd_args->volfile_id);
-                cmd_args->volfile_id = thin_volfileid;
-        }
-
-        if (cmd_args->run_id) {
-                ret = sys_lstat (cmd_args->log_file, &stbuf);
-                /* If its /dev/null, or /dev/stdout, /dev/stderr,
-                 * let it use the same, no need to alter
-                 */
-                if (((ret == 0) &&
-                     (S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) ||
-                    (ret == -1)) {
-                        /* Have separate logfile per run */
-                        gf_time_fmt (timestr, sizeof timestr, time (NULL),
-                                     gf_timefmt_FT);
-                        sprintf (tmp_logfile, "%s.%s.%d",
-                                 cmd_args->log_file, timestr, getpid ());
-
-                        /* Create symlink to actual log file */
-                        sys_unlink (cmd_args->log_file);
-
-                        tmp_logfile_dyn = gf_strdup (tmp_logfile);
-                        tmp_logfilebase = basename (tmp_logfile_dyn);
-                        ret = sys_symlink (tmp_logfilebase,
-                                           cmd_args->log_file);
-                        if (ret == -1) {
-                                fprintf (stderr, "ERROR: symlink of logfile failed\n");
-                                goto out;
-                        }
-
-                        GF_FREE (cmd_args->log_file);
-                        cmd_args->log_file = gf_strdup (tmp_logfile);
-
-                        GF_FREE (tmp_logfile_dyn);
-                }
-        }
-
-        /*
-           This option was made obsolete but parsing it for backward
-           compatibility with third party applications
-         */
-        if (cmd_args->max_connect_attempts) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33,
-                        "obsolete option '--volfile-max-fecth-attempts or "
-                        "fetch-attempts' was provided");
-        }
+    /*
+       This option was made obsolete but parsing it for backward
+       compatibility with third party applications
+     */
+    if (cmd_args->max_connect_attempts) {
+        gf_msg("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33,
+               "obsolete option '--volfile-max-fecth-attempts or "
+               "fetch-attempts' was provided");
+    }
 
 #ifdef GF_DARWIN_HOST_OS
-        if (cmd_args->mount_point)
-               cmd_args->mac_compat = GF_OPTION_DEFERRED;
+    if (cmd_args->mount_point)
+        cmd_args->mac_compat = GF_OPTION_DEFERRED;
 #endif
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
+glusterfs_pidfile_setup(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t  *cmd_args = NULL;
-        int          ret = -1;
-        FILE        *pidfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = -1;
+    FILE *pidfp = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->pid_file)
-                return 0;
+    if (!cmd_args->pid_file)
+        return 0;
 
-        pidfp = fopen (cmd_args->pid_file, "a+");
-        if (!pidfp) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17,
-                        "pidfile %s open failed", cmd_args->pid_file);
-                goto out;
-        }
+    pidfp = fopen(cmd_args->pid_file, "a+");
+    if (!pidfp) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17,
+               "pidfile %s open failed", cmd_args->pid_file);
+        goto out;
+    }
 
-        ctx->pidfp = pidfp;
+    ctx->pidfp = pidfp;
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx)
+glusterfs_pidfile_cleanup(glusterfs_ctx_t *ctx)
 {
-        cmd_args_t      *cmd_args = NULL;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!ctx->pidfp)
-                return 0;
+    if (!ctx->pidfp)
+        return 0;
 
-        gf_msg_trace ("glusterfsd", 0, "pidfile %s cleanup",
-                      cmd_args->pid_file);
+    gf_msg_trace("glusterfsd", 0, "pidfile %s cleanup", cmd_args->pid_file);
 
-        if (ctx->cmd_args.pid_file) {
-                ctx->cmd_args.pid_file = NULL;
-        }
+    if (ctx->cmd_args.pid_file) {
+        ctx->cmd_args.pid_file = NULL;
+    }
 
-        lockf (fileno (ctx->pidfp), F_ULOCK, 0);
-        fclose (ctx->pidfp);
-        ctx->pidfp = NULL;
+    lockf(fileno(ctx->pidfp), F_ULOCK, 0);
+    fclose(ctx->pidfp);
+    ctx->pidfp = NULL;
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_pidfile_update (glusterfs_ctx_t *ctx, pid_t pid)
+glusterfs_pidfile_update(glusterfs_ctx_t *ctx, pid_t pid)
 {
-        cmd_args_t  *cmd_args = NULL;
-        int          ret = 0;
-        FILE        *pidfp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
+    FILE *pidfp = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        pidfp = ctx->pidfp;
-        if (!pidfp)
-                return 0;
+    pidfp = ctx->pidfp;
+    if (!pidfp)
+        return 0;
 
-        ret = lockf (fileno (pidfp), F_TLOCK, 0);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18,
-                        "pidfile %s lock failed", cmd_args->pid_file);
-                return ret;
-        }
+    ret = lockf(fileno(pidfp), F_TLOCK, 0);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18,
+               "pidfile %s lock failed", cmd_args->pid_file);
+        return ret;
+    }
 
-        ret = sys_ftruncate (fileno (pidfp), 0);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20,
-                        "pidfile %s truncation failed", cmd_args->pid_file);
-                return ret;
-        }
+    ret = sys_ftruncate(fileno(pidfp), 0);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20,
+               "pidfile %s truncation failed", cmd_args->pid_file);
+        return ret;
+    }
 
-        ret = fprintf (pidfp, "%d\n", pid);
-        if (ret <= 0) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
-                        "pidfile %s write failed", cmd_args->pid_file);
-                return ret;
-        }
+    ret = fprintf(pidfp, "%d\n", pid);
+    if (ret <= 0) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
+               "pidfile %s write failed", cmd_args->pid_file);
+        return ret;
+    }
 
-        ret = fflush (pidfp);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
-                        "pidfile %s write failed", cmd_args->pid_file);
-                return ret;
-        }
+    ret = fflush(pidfp);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21,
+               "pidfile %s write failed", cmd_args->pid_file);
+        return ret;
+    }
 
-        gf_msg_debug ("glusterfsd", 0, "pidfile %s updated with pid %d",
-                      cmd_args->pid_file, pid);
+    gf_msg_debug("glusterfsd", 0, "pidfile %s updated with pid %d",
+                 cmd_args->pid_file, pid);
 
-        return 0;
+    return 0;
 }
 
-
 void *
-glusterfs_sigwaiter (void *arg)
+glusterfs_sigwaiter(void *arg)
 {
-        sigset_t  set;
-        int       ret = 0;
-        int       sig = 0;
-        char     *file = NULL;
-
-        sigemptyset (&set);
-        sigaddset (&set, SIGINT);   /* cleanup_and_exit */
-        sigaddset (&set, SIGTERM);  /* cleanup_and_exit */
-        sigaddset (&set, SIGHUP);   /* reincarnate */
-        sigaddset (&set, SIGUSR1);  /* gf_proc_dump_info */
-        sigaddset (&set, SIGUSR2);
-
-        for (;;) {
-                ret = sigwait (&set, &sig);
-                if (ret)
-                        continue;
-
-
-                switch (sig) {
-                case SIGINT:
-                case SIGTERM:
-                        cleanup_and_exit (sig);
-                        break;
-                case SIGHUP:
-                        reincarnate (sig);
-                        break;
-                case SIGUSR1:
-                        gf_proc_dump_info (sig, glusterfsd_ctx);
-                        break;
-                case SIGUSR2:
-                        file = gf_monitor_metrics (glusterfsd_ctx);
+    sigset_t set;
+    int ret = 0;
+    int sig = 0;
+    char *file = NULL;
+
+    sigemptyset(&set);
+    sigaddset(&set, SIGINT);  /* cleanup_and_exit */
+    sigaddset(&set, SIGTERM); /* cleanup_and_exit */
+    sigaddset(&set, SIGHUP);  /* reincarnate */
+    sigaddset(&set, SIGUSR1); /* gf_proc_dump_info */
+    sigaddset(&set, SIGUSR2);
+
+    for (;;) {
+        ret = sigwait(&set, &sig);
+        if (ret)
+            continue;
 
-                        /* Nothing needed to be done here */
-                        GF_FREE (file);
+        switch (sig) {
+            case SIGINT:
+            case SIGTERM:
+                cleanup_and_exit(sig);
+                break;
+            case SIGHUP:
+                reincarnate(sig);
+                break;
+            case SIGUSR1:
+                gf_proc_dump_info(sig, glusterfsd_ctx);
+                break;
+            case SIGUSR2:
+                file = gf_monitor_metrics(glusterfsd_ctx);
 
-                        break;
-                default:
+                /* Nothing needed to be done here */
+                GF_FREE(file);
 
-                        break;
-                }
+                break;
+            default:
+
+                break;
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 void
-glusterfsd_print_trace (int signum)
+glusterfsd_print_trace(int signum)
 {
-	gf_print_trace (signum, glusterfsd_ctx);
+    gf_print_trace(signum, glusterfsd_ctx);
 }
 
-
 int
-glusterfs_signals_setup (glusterfs_ctx_t *ctx)
+glusterfs_signals_setup(glusterfs_ctx_t *ctx)
 {
-        sigset_t  set;
-        int       ret = 0;
-
-        sigemptyset (&set);
-
-        /* common setting for all threads */
-        signal (SIGSEGV, glusterfsd_print_trace);
-        signal (SIGABRT, glusterfsd_print_trace);
-        signal (SIGILL, glusterfsd_print_trace);
-        signal (SIGTRAP, glusterfsd_print_trace);
-        signal (SIGFPE, glusterfsd_print_trace);
-        signal (SIGBUS, glusterfsd_print_trace);
-        signal (SIGINT, cleanup_and_exit);
-        signal (SIGPIPE, SIG_IGN);
-
-        /* block these signals from non-sigwaiter threads */
-        sigaddset (&set, SIGTERM);  /* cleanup_and_exit */
-        sigaddset (&set, SIGHUP);   /* reincarnate */
-        sigaddset (&set, SIGUSR1);  /* gf_proc_dump_info */
-        sigaddset (&set, SIGUSR2);
-
-        ret = pthread_sigmask (SIG_BLOCK, &set, NULL);
-        if (ret) {
-                gf_msg ("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22,
-                        "failed to execute pthread_sigmask");
-                return ret;
-        }
-
-        ret = gf_thread_create (&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
-                                (void *) &set, "sigwait");
-        if (ret) {
-                /*
-                  TODO:
-                  fallback to signals getting handled by other threads.
-                  setup the signal handlers
-                */
-                gf_msg ("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23,
-                        "failed to create pthread");
-                return ret;
-        }
+    sigset_t set;
+    int ret = 0;
+
+    sigemptyset(&set);
+
+    /* common setting for all threads */
+    signal(SIGSEGV, glusterfsd_print_trace);
+    signal(SIGABRT, glusterfsd_print_trace);
+    signal(SIGILL, glusterfsd_print_trace);
+    signal(SIGTRAP, glusterfsd_print_trace);
+    signal(SIGFPE, glusterfsd_print_trace);
+    signal(SIGBUS, glusterfsd_print_trace);
+    signal(SIGINT, cleanup_and_exit);
+    signal(SIGPIPE, SIG_IGN);
+
+    /* block these signals from non-sigwaiter threads */
+    sigaddset(&set, SIGTERM); /* cleanup_and_exit */
+    sigaddset(&set, SIGHUP);  /* reincarnate */
+    sigaddset(&set, SIGUSR1); /* gf_proc_dump_info */
+    sigaddset(&set, SIGUSR2);
+
+    ret = pthread_sigmask(SIG_BLOCK, &set, NULL);
+    if (ret) {
+        gf_msg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22,
+               "failed to execute pthread_sigmask");
+        return ret;
+    }
 
+    ret = gf_thread_create(&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
+                           (void *)&set, "sigwait");
+    if (ret) {
+        /*
+          TODO:
+          fallback to signals getting handled by other threads.
+          setup the signal handlers
+        */
+        gf_msg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23,
+               "failed to create pthread");
         return ret;
-}
+    }
 
+    return ret;
+}
 
 int
-daemonize (glusterfs_ctx_t *ctx)
+daemonize(glusterfs_ctx_t *ctx)
 {
-        int            ret = -1;
-        cmd_args_t    *cmd_args = NULL;
-        int            cstatus = 0;
-        int            err = 1;
-        int            child_pid = 0;
-
-        cmd_args = &ctx->cmd_args;
-
-        ret = glusterfs_pidfile_setup (ctx);
-        if (ret)
-                goto out;
+    int ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    int cstatus = 0;
+    int err = 1;
+    int child_pid = 0;
 
-        if (cmd_args->no_daemon_mode) {
-                ret = glusterfs_pidfile_update (ctx, getpid());
-                if (ret)
-                        goto out;
-                goto postfork;
-        }
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->debug_mode)
-                goto postfork;
-
-        ret = pipe (ctx->daemon_pipe);
-        if (ret) {
-                /* If pipe() fails, retain daemon_pipe[] = {-1, -1}
-                   and parent will just not wait for child status
-                */
-                ctx->daemon_pipe[0] = -1;
-                ctx->daemon_pipe[1] = -1;
-        }
+    ret = glusterfs_pidfile_setup(ctx);
+    if (ret)
+        goto out;
 
-        ret = os_daemon_return (0, 0);
-        switch (ret) {
+    if (cmd_args->no_daemon_mode) {
+        ret = glusterfs_pidfile_update(ctx, getpid());
+        if (ret)
+            goto out;
+        goto postfork;
+    }
+
+    if (cmd_args->debug_mode)
+        goto postfork;
+
+    ret = pipe(ctx->daemon_pipe);
+    if (ret) {
+        /* If pipe() fails, retain daemon_pipe[] = {-1, -1}
+           and parent will just not wait for child status
+        */
+        ctx->daemon_pipe[0] = -1;
+        ctx->daemon_pipe[1] = -1;
+    }
+
+    ret = os_daemon_return(0, 0);
+    switch (ret) {
         case -1:
-                if (ctx->daemon_pipe[0] != -1) {
-                        sys_close (ctx->daemon_pipe[0]);
-                        sys_close (ctx->daemon_pipe[1]);
-                }
-
-                gf_msg ("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24,
-                        "daemonization failed");
-                goto out;
+            if (ctx->daemon_pipe[0] != -1) {
+                sys_close(ctx->daemon_pipe[0]);
+                sys_close(ctx->daemon_pipe[1]);
+            }
+
+            gf_msg("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24,
+                   "daemonization failed");
+            goto out;
         case 0:
-                /* child */
-                /* close read */
-                sys_close (ctx->daemon_pipe[0]);
-                break;
+            /* child */
+            /* close read */
+            sys_close(ctx->daemon_pipe[0]);
+            break;
         default:
-                /* parent */
-                /* close write */
-                child_pid = ret;
-                sys_close (ctx->daemon_pipe[1]);
-
-                if (ctx->mnt_pid > 0) {
-                        ret = waitpid (ctx->mnt_pid, &cstatus, 0);
-                        if (!(ret == ctx->mnt_pid)) {
-                                if (WIFEXITED(cstatus)) {
-                                        err = WEXITSTATUS(cstatus);
-                                } else {
-                                        err = cstatus;
-                                }
-                                gf_msg ("daemonize", GF_LOG_ERROR, 0,
-                                        glusterfsd_msg_25, "mount failed");
-                                exit (err);
-                        }
-                }
-                sys_read (ctx->daemon_pipe[0], (void *)&err, sizeof (err));
-                /* NOTE: Only the least significant 8 bits i.e (err & 255)
-                   will be available to parent process on calling exit() */
-                if (err)
-                        _exit (abs(err));
-                ret = glusterfs_pidfile_update (ctx, child_pid);
-                if (ret)
-                        _exit (1);
-                _exit (0);
-        }
+            /* parent */
+            /* close write */
+            child_pid = ret;
+            sys_close(ctx->daemon_pipe[1]);
+
+            if (ctx->mnt_pid > 0) {
+                ret = waitpid(ctx->mnt_pid, &cstatus, 0);
+                if (!(ret == ctx->mnt_pid)) {
+                    if (WIFEXITED(cstatus)) {
+                        err = WEXITSTATUS(cstatus);
+                    } else {
+                        err = cstatus;
+                    }
+                    gf_msg("daemonize", GF_LOG_ERROR, 0, glusterfsd_msg_25,
+                           "mount failed");
+                    exit(err);
+                }
+            }
+            sys_read(ctx->daemon_pipe[0], (void *)&err, sizeof(err));
+            /* NOTE: Only the least significant 8 bits i.e (err & 255)
+               will be available to parent process on calling exit() */
+            if (err)
+                _exit(abs(err));
+            ret = glusterfs_pidfile_update(ctx, child_pid);
+            if (ret)
+                _exit(1);
+            _exit(0);
+    }
 
 postfork:
-        ret = gf_log_inject_timer_event (ctx);
+    ret = gf_log_inject_timer_event(ctx);
 
-        glusterfs_signals_setup (ctx);
+    glusterfs_signals_setup(ctx);
 out:
-        return ret;
+    return ret;
 }
 
-
 #ifdef GF_LINUX_HOST_OS
 static int
-set_oom_score_adj (glusterfs_ctx_t *ctx)
+set_oom_score_adj(glusterfs_ctx_t *ctx)
 {
-        int                  ret           = -1;
-        cmd_args_t          *cmd_args      =  NULL;
-        int                  fd            = -1;
-        size_t               oom_score_len =  0;
-        struct oom_api_info *api           =  NULL;
+    int ret = -1;
+    cmd_args_t *cmd_args = NULL;
+    int fd = -1;
+    size_t oom_score_len = 0;
+    struct oom_api_info *api = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->oom_score_adj)
-                goto success;
+    if (!cmd_args->oom_score_adj)
+        goto success;
 
-        api = get_oom_api_info();
-        if (!api)
-                goto out;
+    api = get_oom_api_info();
+    if (!api)
+        goto out;
 
-        fd = open (api->oom_api_file, O_WRONLY);
-        if (fd < 0)
-                goto out;
+    fd = open(api->oom_api_file, O_WRONLY);
+    if (fd < 0)
+        goto out;
 
-        oom_score_len = strlen (cmd_args->oom_score_adj);
-        if (sys_write (fd,
-                  cmd_args->oom_score_adj, oom_score_len) != oom_score_len) {
-                sys_close (fd);
-                goto out;
-        }
+    oom_score_len = strlen(cmd_args->oom_score_adj);
+    if (sys_write(fd, cmd_args->oom_score_adj, oom_score_len) !=
+        oom_score_len) {
+        sys_close(fd);
+        goto out;
+    }
 
-        if (sys_close (fd) < 0)
-                goto out;
+    if (sys_close(fd) < 0)
+        goto out;
 
 success:
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 #endif
 
-
 int
-glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp)
+glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp)
 {
-        glusterfs_graph_t  *graph = NULL;
-        int                 ret = -1;
-        xlator_t           *trav = NULL;
-
-        graph = glusterfs_graph_construct (fp);
-        if (!graph) {
-                gf_msg ("", GF_LOG_ERROR, 0, glusterfsd_msg_26,
-                        "failed to construct the graph");
-                goto out;
-        }
+    glusterfs_graph_t *graph = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
 
-        for (trav = graph->first; trav; trav = trav->next) {
-                if (strcmp (trav->type, "mount/fuse") == 0) {
-                        gf_msg ("glusterfsd", GF_LOG_ERROR, 0,
-                                glusterfsd_msg_27,
-                                "fuse xlator cannot be specified in volume "
-                                "file");
-                        goto out;
-                }
-        }
+    graph = glusterfs_graph_construct(fp);
+    if (!graph) {
+        gf_msg("", GF_LOG_ERROR, 0, glusterfsd_msg_26,
+               "failed to construct the graph");
+        goto out;
+    }
 
-        xlator_t *xl = graph->first;
-        if (strcmp (xl->type, "protocol/server") == 0) {
-                (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*");
+    for (trav = graph->first; trav; trav = trav->next) {
+        if (strcmp(trav->type, "mount/fuse") == 0) {
+            gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_27,
+                   "fuse xlator cannot be specified in volume "
+                   "file");
+            goto out;
         }
+    }
 
-        ret = glusterfs_graph_prepare (graph, ctx, ctx->cmd_args.volume_name);
-        if (ret) {
-                goto out;
-        }
+    xlator_t *xl = graph->first;
+    if (strcmp(xl->type, "protocol/server") == 0) {
+        (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*");
+    }
 
-        ret = glusterfs_graph_activate (graph, ctx);
+    ret = glusterfs_graph_prepare(graph, ctx, ctx->cmd_args.volume_name);
+    if (ret) {
+        goto out;
+    }
 
-        if (ret) {
-                goto out;
-        }
+    ret = glusterfs_graph_activate(graph, ctx);
 
-        gf_log_dump_graph (fp, graph);
+    if (ret) {
+        goto out;
+    }
 
-        ret = 0;
+    gf_log_dump_graph(fp, graph);
+
+    ret = 0;
 out:
-        if (fp)
-                fclose (fp);
-
-        if (ret && !ctx->active) {
-                glusterfs_graph_destroy (graph);
-                /* there is some error in setting up the first graph itself */
-                emancipate (ctx, ret);
-                cleanup_and_exit (ret);
-        }
+    if (fp)
+        fclose(fp);
 
-        return ret;
-}
+    if (ret && !ctx->active) {
+        glusterfs_graph_destroy(graph);
+        /* there is some error in setting up the first graph itself */
+        emancipate(ctx, ret);
+        cleanup_and_exit(ret);
+    }
 
+    return ret;
+}
 
 int
-glusterfs_volumes_init (glusterfs_ctx_t *ctx)
+glusterfs_volumes_init(glusterfs_ctx_t *ctx)
 {
-        FILE               *fp = NULL;
-        cmd_args_t         *cmd_args = NULL;
-        int                 ret = 0;
+    FILE *fp = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->sock_file) {
-                ret = glusterfs_listener_init (ctx);
-                if (ret)
-                        goto out;
-        }
+    if (cmd_args->sock_file) {
+        ret = glusterfs_listener_init(ctx);
+        if (ret)
+            goto out;
+    }
 
-        if (cmd_args->volfile_server) {
-                ret = glusterfs_mgmt_init (ctx);
-                /* return, do not emancipate() yet */
-                return ret;
-        }
+    if (cmd_args->volfile_server) {
+        ret = glusterfs_mgmt_init(ctx);
+        /* return, do not emancipate() yet */
+        return ret;
+    }
 
-        fp = get_volfp (ctx);
+    fp = get_volfp(ctx);
 
-        if (!fp) {
-                gf_msg ("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28,
-                        "Cannot reach volume specification file");
-                ret = -1;
-                goto out;
-        }
+    if (!fp) {
+        gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28,
+               "Cannot reach volume specification file");
+        ret = -1;
+        goto out;
+    }
 
-        ret = glusterfs_process_volfp (ctx, fp);
-        if (ret)
-                goto out;
+    ret = glusterfs_process_volfp(ctx, fp);
+    if (ret)
+        goto out;
 
 out:
-        emancipate (ctx, ret);
-        return ret;
+    emancipate(ctx, ret);
+    return ret;
 }
 
 /* This is the only legal global pointer  */
 glusterfs_ctx_t *glusterfsd_ctx;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        int               ret = -1;
-        char              cmdlinestr[PATH_MAX] = {0,};
-        cmd_args_t       *cmd = NULL;
-
-        mem_pools_init_early ();
-
-	gf_check_and_set_mem_acct (argc, argv);
-
-	ctx = glusterfs_ctx_new ();
-        if (!ctx) {
-                gf_msg ("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29,
-                        "ERROR: glusterfs context not initialized");
-                return ENOMEM;
-        }
-	glusterfsd_ctx = ctx;
-
-        ret = glusterfs_globals_init (ctx);
-        if (ret)
-                return ret;
-
-	THIS->ctx = ctx;
-
-        ret = glusterfs_ctx_defaults_init (ctx);
-        if (ret)
-                goto out;
-
-        ret = parse_cmdline (argc, argv, ctx);
-        if (ret)
-                goto out;
-        cmd = &ctx->cmd_args;
+    glusterfs_ctx_t *ctx = NULL;
+    int ret = -1;
+    char cmdlinestr[PATH_MAX] = {
+        0,
+    };
+    cmd_args_t *cmd = NULL;
+
+    mem_pools_init_early();
+
+    gf_check_and_set_mem_acct(argc, argv);
+
+    ctx = glusterfs_ctx_new();
+    if (!ctx) {
+        gf_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29,
+               "ERROR: glusterfs context not initialized");
+        return ENOMEM;
+    }
+    glusterfsd_ctx = ctx;
+
+    ret = glusterfs_globals_init(ctx);
+    if (ret)
+        return ret;
 
-        if (cmd->print_xlatordir) {
-                /* XLATORDIR passed through a -D flag to GCC */
-                printf ("%s\n", XLATORDIR);
-                goto out;
-        }
+    THIS->ctx = ctx;
 
-        if (cmd->print_statedumpdir) {
-                printf ("%s\n", DEFAULT_VAR_RUN_DIRECTORY);
-                goto out;
-        }
+    ret = glusterfs_ctx_defaults_init(ctx);
+    if (ret)
+        goto out;
 
-        if (cmd->print_logdir) {
-                printf ("%s\n", DEFAULT_LOG_FILE_DIRECTORY);
-                goto out;
-        }
+    ret = parse_cmdline(argc, argv, ctx);
+    if (ret)
+        goto out;
+    cmd = &ctx->cmd_args;
 
-        if (cmd->print_libexecdir) {
-                printf ("%s\n", LIBEXECDIR);
-                goto out;
-        }
+    if (cmd->print_xlatordir) {
+        /* XLATORDIR passed through a -D flag to GCC */
+        printf("%s\n", XLATORDIR);
+        goto out;
+    }
+
+    if (cmd->print_statedumpdir) {
+        printf("%s\n", DEFAULT_VAR_RUN_DIRECTORY);
+        goto out;
+    }
+
+    if (cmd->print_logdir) {
+        printf("%s\n", DEFAULT_LOG_FILE_DIRECTORY);
+        goto out;
+    }
+
+    if (cmd->print_libexecdir) {
+        printf("%s\n", LIBEXECDIR);
+        goto out;
+    }
+
+    if (cmd->print_netgroups) {
+        /* If this option is set we want to print & verify the file,
+         * set the return value (exit code in this case) and exit.
+         */
+        ret = print_netgroups_file(cmd->print_netgroups);
+        goto out;
+    }
+
+    if (cmd->print_exports) {
+        /* If this option is set we want to print & verify the file,
+         * set the return value (exit code in this case)
+         * and exit.
+         */
+        ret = print_exports_file(cmd->print_exports);
+        goto out;
+    }
 
-        if (cmd->print_netgroups) {
-                /* If this option is set we want to print & verify the file,
-                 * set the return value (exit code in this case) and exit.
-                 */
-                ret =  print_netgroups_file (cmd->print_netgroups);
-                goto out;
-        }
+    ret = logging_init(ctx, argv[0]);
+    if (ret)
+        goto out;
 
-        if (cmd->print_exports) {
-                /* If this option is set we want to print & verify the file,
-                 * set the return value (exit code in this case)
-                 * and exit.
-                 */
-                ret = print_exports_file (cmd->print_exports);
+    /* log the version of glusterfs running here along with the actual
+       command line options. */
+    {
+        int i = 0;
+        int pos = 0;
+        int len = snprintf(cmdlinestr, sizeof(cmdlinestr), "%s", argv[0]);
+        for (i = 1; (i < argc) && (len > 0); i++) {
+            pos += len;
+            len = snprintf(cmdlinestr + pos, sizeof(cmdlinestr) - pos, " %s",
+                           argv[i]);
+            if ((len <= 0) || (len >= (sizeof(cmdlinestr) - pos))) {
+                gf_msg("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_29,
+                       "failed to create command line string");
+                ret = -1;
                 goto out;
+            }
         }
+        gf_msg(argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30,
+               "Started running %s version %s (args: %s)", argv[0],
+               PACKAGE_VERSION, cmdlinestr);
 
-        ret = logging_init (ctx, argv[0]);
-        if (ret)
-                goto out;
-
-
-        /* log the version of glusterfs running here along with the actual
-           command line options. */
-        {
-                int i = 0;
-                int pos = 0;
-                int len = snprintf (cmdlinestr, sizeof (cmdlinestr), "%s", argv[0]);
-                for (i = 1; (i < argc) && (len > 0); i++) {
-                        pos += len;
-                        len = snprintf (cmdlinestr + pos, sizeof (cmdlinestr) - pos, " %s",
-                                       argv[i]);
-                        if ((len <= 0) || (len >= (sizeof (cmdlinestr) - pos))) {
-                                gf_msg ("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_29,
-                                        "failed to create command line string");
-                                ret = -1;
-                                goto out;
-                        }
-                }
-                gf_msg (argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30,
-                        "Started running %s version %s (args: %s)",
-                        argv[0], PACKAGE_VERSION, cmdlinestr);
-
-		ctx->cmdlinestr = gf_strdup (cmdlinestr);
-        }
+        ctx->cmdlinestr = gf_strdup(cmdlinestr);
+    }
 
-        gf_proc_dump_init();
+    gf_proc_dump_init();
 
-        ret = create_fuse_mount (ctx);
-        if (ret)
-                goto out;
+    ret = create_fuse_mount(ctx);
+    if (ret)
+        goto out;
 
-        ret = daemonize (ctx);
-        if (ret)
-                goto out;
+    ret = daemonize(ctx);
+    if (ret)
+        goto out;
 
-        /*
-         * If we do this before daemonize, the pool-sweeper thread dies with
-         * the parent, but we want to do it as soon as possible after that in
-         * case something else depends on pool allocations.
-         */
-        mem_pools_init_late ();
+    /*
+     * If we do this before daemonize, the pool-sweeper thread dies with
+     * the parent, but we want to do it as soon as possible after that in
+     * case something else depends on pool allocations.
+     */
+    mem_pools_init_late();
 
 #ifdef GF_LINUX_HOST_OS
-        ret = set_oom_score_adj (ctx);
-        if (ret)
-                goto out;
+    ret = set_oom_score_adj(ctx);
+    if (ret)
+        goto out;
 #endif
 
-	ctx->env = syncenv_new (0, 0, 0);
-        if (!ctx->env) {
-                gf_msg ("", GF_LOG_ERROR, 0, glusterfsd_msg_31,
-                        "Could not create new sync-environment");
-                goto out;
-        }
+    ctx->env = syncenv_new(0, 0, 0);
+    if (!ctx->env) {
+        gf_msg("", GF_LOG_ERROR, 0, glusterfsd_msg_31,
+               "Could not create new sync-environment");
+        goto out;
+    }
 
-        /* do this _after_ daemonize() */
-        if (cmd->global_timer_wheel) {
-                if (!glusterfs_ctx_tw_get (ctx)) {
-                        ret = -1;
-                        goto out;
-                }
+    /* do this _after_ daemonize() */
+    if (cmd->global_timer_wheel) {
+        if (!glusterfs_ctx_tw_get(ctx)) {
+            ret = -1;
+            goto out;
         }
+    }
 
-        ret = glusterfs_volumes_init (ctx);
-        if (ret)
-                goto out;
+    ret = glusterfs_volumes_init(ctx);
+    if (ret)
+        goto out;
 
-        ret = event_dispatch (ctx->event_pool);
+    ret = event_dispatch(ctx->event_pool);
 
 out:
-//        glusterfs_ctx_destroy (ctx);
-        return ret;
+    //        glusterfs_ctx_destroy (ctx);
+    return ret;
 }
diff --git a/heal/src/glfs-heal.c b/heal/src/glfs-heal.c
index 176ba6e44de..f0576f9d76e 100644
--- a/heal/src/glfs-heal.c
+++ b/heal/src/glfs-heal.c
@@ -28,1484 +28,1448 @@
 #include <libxml/xmlwriter.h>
 
 xmlTextWriterPtr glfsh_writer;
-xmlDocPtr        glfsh_doc = NULL;
+xmlDocPtr glfsh_doc = NULL;
 #endif
 
-#define XML_RET_CHECK_AND_GOTO(ret, label)      do {            \
-                if (ret < 0) {                                  \
-                        ret = -1;                               \
-                        goto label;                             \
-                }                                               \
-                else                                            \
-                        ret = 0;                                \
-        } while (0)                                             \
+#define XML_RET_CHECK_AND_GOTO(ret, label)                                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        } else                                                                 \
+            ret = 0;                                                           \
+    } while (0)
 
 typedef struct num_entries {
-        uint64_t num_entries;
-        uint64_t pending_entries;
-        uint64_t spb_entries;
-        uint64_t possibly_healing_entries;
+    uint64_t num_entries;
+    uint64_t pending_entries;
+    uint64_t spb_entries;
+    uint64_t possibly_healing_entries;
 } num_entries_t;
 
-typedef int    (*print_status) (dict_t *, char *, uuid_t, num_entries_t *,
-                 gf_boolean_t flag);
+typedef int (*print_status)(dict_t *, char *, uuid_t, num_entries_t *,
+                            gf_boolean_t flag);
 
-int glfsh_heal_splitbrain_file (glfs_t *fs, xlator_t *top_subvol,
-                                loc_t *rootloc, char *file, dict_t *xattr_req);
+int
+glfsh_heal_splitbrain_file(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *file, dict_t *xattr_req);
 
 typedef struct glfs_info {
-        int (*init)(void);
-        int (*print_brick_from_xl)(xlator_t *xl, loc_t *rootloc);
-        int (*print_heal_op_status)(int ret, uint64_t num_entries,
-                        char *fmt_str);
-        int (*print_heal_op_summary)(int ret, num_entries_t *num_entries);
-        int (*print_heal_status)(char *path, uuid_t gfid, char *status);
-        int (*print_spb_status)(char *path, uuid_t gfid, char *status);
-        int (*end) (int op_ret, char *op_errstr);
+    int (*init)(void);
+    int (*print_brick_from_xl)(xlator_t *xl, loc_t *rootloc);
+    int (*print_heal_op_status)(int ret, uint64_t num_entries, char *fmt_str);
+    int (*print_heal_op_summary)(int ret, num_entries_t *num_entries);
+    int (*print_heal_status)(char *path, uuid_t gfid, char *status);
+    int (*print_spb_status)(char *path, uuid_t gfid, char *status);
+    int (*end)(int op_ret, char *op_errstr);
 } glfsh_info_t;
 
 glfsh_info_t *glfsh_output = NULL;
 int32_t is_xml;
 
 #define DEFAULT_HEAL_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
-#define USAGE_STR "Usage: %s <VOLNAME> [bigger-file <FILE> | "\
-                  "latest-mtime <FILE> | "\
-                  "source-brick <HOSTNAME:BRICKNAME> [<FILE>] | "\
-                  "split-brain-info | info-summary] [glusterd-sock <FILE>"\
-                  "]\n"
+#define USAGE_STR                                                              \
+    "Usage: %s <VOLNAME> [bigger-file <FILE> | "                               \
+    "latest-mtime <FILE> | "                                                   \
+    "source-brick <HOSTNAME:BRICKNAME> [<FILE>] | "                            \
+    "split-brain-info | info-summary] [glusterd-sock <FILE>"                   \
+    "]\n"
 
 typedef enum {
-        GLFSH_MODE_CONTINUE_ON_ERROR = 1,
-        GLFSH_MODE_EXIT_ON_FIRST_FAILURE,
+    GLFSH_MODE_CONTINUE_ON_ERROR = 1,
+    GLFSH_MODE_EXIT_ON_FIRST_FAILURE,
 } glfsh_fail_mode_t;
 
 int
-glfsh_init ()
+glfsh_init()
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_end_op_granular_entry_heal (int op_ret, char *op_errstr)
+glfsh_end_op_granular_entry_heal(int op_ret, char *op_errstr)
 {
-        /* If error string is available, give it higher precedence.*/
-
-        if (op_errstr) {
-                printf ("%s\n", op_errstr);
-        } else if (op_ret < 0) {
-                if (op_ret == -EAGAIN)
-                        printf ("One or more entries need heal. Please execute "
-                                "the command again after there are no entries "
-                                "to be healed\n");
-                else if (op_ret == -ENOTCONN)
-                        printf ("One or more bricks could be down. Please "
-                                "execute the command again after bringing all "
-                                "bricks online and finishing any pending "
-                                "heals\n");
-                else
-                        printf ("Command failed - %s. Please check the logs for"
-                                " more details\n", strerror (-op_ret));
-        }
-        return 0;
+    /* If error string is available, give it higher precedence.*/
+
+    if (op_errstr) {
+        printf("%s\n", op_errstr);
+    } else if (op_ret < 0) {
+        if (op_ret == -EAGAIN)
+            printf(
+                "One or more entries need heal. Please execute "
+                "the command again after there are no entries "
+                "to be healed\n");
+        else if (op_ret == -ENOTCONN)
+            printf(
+                "One or more bricks could be down. Please "
+                "execute the command again after bringing all "
+                "bricks online and finishing any pending "
+                "heals\n");
+        else
+            printf(
+                "Command failed - %s. Please check the logs for"
+                " more details\n",
+                strerror(-op_ret));
+    }
+    return 0;
 }
 
 int
-glfsh_end (int op_ret, char *op_errstr)
+glfsh_end(int op_ret, char *op_errstr)
 {
-        if (op_errstr)
-                printf ("%s\n", op_errstr);
-        return 0;
+    if (op_errstr)
+        printf("%s\n", op_errstr);
+    return 0;
 }
 
 int
-glfsh_print_hr_spb_status (char *path, uuid_t gfid, char *status)
+glfsh_print_hr_spb_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s\n", path);
-        fflush (stdout);
-        return 0;
+    printf("%s\n", path);
+    fflush(stdout);
+    return 0;
 }
 
 int
-glfsh_no_print_hr_status (char *path, uuid_t gfid, char *status)
+glfsh_no_print_hr_status(char *path, uuid_t gfid, char *status)
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_status (char *path, uuid_t gfid, char *status)
+glfsh_print_hr_heal_status(char *path, uuid_t gfid, char *status)
 {
-        printf ("%s%s\n", path, status);
-        fflush (stdout);
-        return 0;
+    printf("%s%s\n", path, status);
+    fflush(stdout);
+    return 0;
 }
 
 #if (HAVE_LIB_XML)
 
 int
-glfsh_xml_init ()
+glfsh_xml_init()
 {
-        int     ret     = -1;
-        glfsh_writer = xmlNewTextWriterDoc (&glfsh_doc, 0);
-        if (glfsh_writer == NULL) {
-                return -1;
-        }
-
-        ret = xmlTextWriterStartDocument (glfsh_writer, "1.0", "UTF-8",
-                        "yes");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* <cliOutput> */
-        ret = xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"cliOutput");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* <healInfo> */
-        ret = xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"healInfo");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-        /* <bricks> */
-        ret = xmlTextWriterStartElement (glfsh_writer,
-                        (xmlChar *)"bricks");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-        xmlTextWriterFlush (glfsh_writer);
+    int ret = -1;
+    glfsh_writer = xmlNewTextWriterDoc(&glfsh_doc, 0);
+    if (glfsh_writer == NULL) {
+        return -1;
+    }
+
+    ret = xmlTextWriterStartDocument(glfsh_writer, "1.0", "UTF-8", "yes");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* <cliOutput> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"cliOutput");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* <healInfo> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"healInfo");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    /* <bricks> */
+    ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"bricks");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    xmlTextWriterFlush(glfsh_writer);
 xml_out:
-        return ret;
+    return ret;
 }
 
 int
-glfsh_xml_end (int op_ret, char *op_errstr)
+glfsh_xml_end(int op_ret, char *op_errstr)
 {
-        int                     ret             = -1;
-        int                     op_errno        = 0;
-        gf_boolean_t            alloc           = _gf_false;
-
-        if (op_ret < 0) {
-                op_errno = -op_ret;
-                op_ret = -1;
-                if (op_errstr == NULL) {
-                        op_errstr = gf_strdup (strerror (op_errno));
-                        alloc = _gf_true;
-                }
-        } else {
-                op_errstr = NULL;
+    int ret = -1;
+    int op_errno = 0;
+    gf_boolean_t alloc = _gf_false;
+
+    if (op_ret < 0) {
+        op_errno = -op_ret;
+        op_ret = -1;
+        if (op_errstr == NULL) {
+            op_errstr = gf_strdup(strerror(op_errno));
+            alloc = _gf_true;
         }
-
-        /* </bricks> */
-        ret = xmlTextWriterEndElement (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        /* </healInfo> */
-        ret = xmlTextWriterEndElement (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"opRet", "%d", op_ret);
-
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"opErrno",
-                        "%d", op_errno);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-        if (op_errstr)
-                ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"opErrstr",
-                                "%s", op_errstr);
-        else
-                ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"opErrstr",
-                                "%s", "");
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-        ret = xmlTextWriterEndDocument (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (ret, xml_out);
-
-
-        /* Dump xml document to stdout and pretty format it */
-        xmlSaveFormatFileEnc ("-", glfsh_doc, "UTF-8", 1);
-
-        xmlFreeTextWriter (glfsh_writer);
-        xmlFreeDoc (glfsh_doc);
+    } else {
+        op_errstr = NULL;
+    }
+
+    /* </bricks> */
+    ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* </healInfo> */
+    ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    ret = xmlTextWriterWriteFormatElement(glfsh_writer, (xmlChar *)"opRet",
+                                          "%d", op_ret);
+
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    ret = xmlTextWriterWriteFormatElement(glfsh_writer, (xmlChar *)"opErrno",
+                                          "%d", op_errno);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    if (op_errstr)
+        ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"opErrstr", "%s", op_errstr);
+    else
+        ret = xmlTextWriterWriteFormatElement(glfsh_writer,
+                                              (xmlChar *)"opErrstr", "%s", "");
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+    ret = xmlTextWriterEndDocument(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(ret, xml_out);
+
+    /* Dump xml document to stdout and pretty format it */
+    xmlSaveFormatFileEnc("-", glfsh_doc, "UTF-8", 1);
+
+    xmlFreeTextWriter(glfsh_writer);
+    xmlFreeDoc(glfsh_doc);
 xml_out:
-        if (alloc)
-                GF_FREE (op_errstr);
-        return ret;
+    if (alloc)
+        GF_FREE(op_errstr);
+    return ret;
 }
 
 int
-glfsh_print_xml_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_print_xml_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        int x_ret = 0;
-        if (ret < 0 && num_entries == 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"status",
-                                "%s", strerror (-ret));
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                if (fmt_str) {
-                        x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"numberOfEntries",
-                                        "-");
-                        XML_RET_CHECK_AND_GOTO (x_ret, out);
-                }
-                goto out;
-        } else if (ret == 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                                 (xmlChar *)"status",
-                                                 "%s", "Connected");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
+    int x_ret = 0;
+    if (ret < 0 && num_entries == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", strerror(-ret));
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"numberOfEntries", "-");
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
         }
-
-        if (ret < 0) {
-                if (fmt_str) {
-                        x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"status",
-                                        "Failed to process entries completely. "
-                                        "(%s)%s %"PRIu64"", strerror (-ret),
-                                        fmt_str,
-                                        num_entries);
-                        XML_RET_CHECK_AND_GOTO (x_ret, out);
-                }
-        } else {
-                if (fmt_str) {
-                        x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                        (xmlChar *)"numberOfEntries",
-                                        "%"PRIu64"", num_entries);
-                        XML_RET_CHECK_AND_GOTO (x_ret, out);
-                }
+        goto out;
+    } else if (ret == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", "Connected");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
+
+    if (ret < 0) {
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"status",
+                "Failed to process entries completely. "
+                "(%s)%s %" PRIu64 "",
+                strerror(-ret), fmt_str, num_entries);
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
+        }
+    } else {
+        if (fmt_str) {
+            x_ret = xmlTextWriterWriteFormatElement(
+                glfsh_writer, (xmlChar *)"numberOfEntries", "%" PRIu64 "",
+                num_entries);
+            XML_RET_CHECK_AND_GOTO(x_ret, out);
         }
+    }
 out:
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
         if (x_ret >= 0) {
-                x_ret = xmlTextWriterEndElement (glfsh_writer);
-                if (x_ret >= 0) {
-                        xmlTextWriterFlush (glfsh_writer);
-                        x_ret = 0;
-                } else {
-                        x_ret = -1;
-                }
+            xmlTextWriterFlush(glfsh_writer);
+            x_ret = 0;
+        } else {
+            x_ret = -1;
         }
-        return x_ret;
+    }
+    return x_ret;
 }
 
 int
-glfsh_print_xml_heal_op_summary (int ret, num_entries_t *num_entries)
+glfsh_print_xml_heal_op_summary(int ret, num_entries_t *num_entries)
 {
-        int x_ret = 0;
-
-        if (ret < 0 && num_entries == 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"status",
-                                "%s", strerror (-ret));
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"totalNumberOfEntries", "-");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesInHealPending", "-");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesInSplitBrain", "-");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesPossiblyHealing",
-                                "-");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                goto out;
-        } else if (ret == 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                                 (xmlChar *)"status",
-                                                 "%s", "Connected");
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-        }
-
-        if (ret < 0) {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"status", "Failed to process entries"
-                                " completely. "
-                                "(%s)totalNumberOfEntries%"PRIu64"",
-                                strerror (-ret), num_entries->num_entries);
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-        } else {
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"totalNumberOfEntries",
-                                "%"PRIu64"", num_entries->num_entries);
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesInHealPending",
-                                "%"PRIu64"", num_entries->pending_entries);
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesInSplitBrain",
-                                "%"PRIu64"", num_entries->spb_entries);
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-                x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                                (xmlChar *)"numberOfEntriesPossiblyHealing",
-                                "%"PRIu64"",
-                                num_entries->possibly_healing_entries);
-                XML_RET_CHECK_AND_GOTO (x_ret, out);
-        }
+    int x_ret = 0;
+
+    if (ret < 0 && num_entries == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", strerror(-ret));
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"totalNumberOfEntries", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInHealPending", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInSplitBrain", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesPossiblyHealing", "-");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        goto out;
+    } else if (ret == 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status", "%s", "Connected");
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
+
+    if (ret < 0) {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"status",
+            "Failed to process entries"
+            " completely. "
+            "(%s)totalNumberOfEntries%" PRIu64 "",
+            strerror(-ret), num_entries->num_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    } else {
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"totalNumberOfEntries", "%" PRIu64 "",
+            num_entries->num_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInHealPending",
+            "%" PRIu64 "", num_entries->pending_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesInSplitBrain",
+            "%" PRIu64 "", num_entries->spb_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+        x_ret = xmlTextWriterWriteFormatElement(
+            glfsh_writer, (xmlChar *)"numberOfEntriesPossiblyHealing",
+            "%" PRIu64 "", num_entries->possibly_healing_entries);
+        XML_RET_CHECK_AND_GOTO(x_ret, out);
+    }
 out:
-        if (x_ret >= 0) {
-                x_ret = xmlTextWriterEndElement (glfsh_writer);
-        }
-        return x_ret;
+    if (x_ret >= 0) {
+        x_ret = xmlTextWriterEndElement(glfsh_writer);
+    }
+    return x_ret;
 }
 
 int
-glfsh_print_xml_file_status (char *path, uuid_t gfid, char *status)
+glfsh_print_xml_file_status(char *path, uuid_t gfid, char *status)
 {
-        int x_ret = 0;
-
-        x_ret = xmlTextWriterStartElement (glfsh_writer, (xmlChar *)"file");
-        XML_RET_CHECK_AND_GOTO (x_ret, out);
-        x_ret = xmlTextWriterWriteFormatAttribute (glfsh_writer,
-                                                   (xmlChar *)"gfid",
-                                                   "%s", uuid_utoa (gfid));
-        XML_RET_CHECK_AND_GOTO (x_ret, out);
-        x_ret = xmlTextWriterWriteFormatString (glfsh_writer, "%s", path);
-        XML_RET_CHECK_AND_GOTO (x_ret, out);
-        x_ret = xmlTextWriterEndElement (glfsh_writer);
-        XML_RET_CHECK_AND_GOTO (x_ret, out);
-        xmlTextWriterFlush (glfsh_writer);
+    int x_ret = 0;
+
+    x_ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"file");
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterWriteFormatAttribute(glfsh_writer, (xmlChar *)"gfid",
+                                              "%s", uuid_utoa(gfid));
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterWriteFormatString(glfsh_writer, "%s", path);
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    x_ret = xmlTextWriterEndElement(glfsh_writer);
+    XML_RET_CHECK_AND_GOTO(x_ret, out);
+    xmlTextWriterFlush(glfsh_writer);
 out:
-        return x_ret;
+    return x_ret;
 }
 
 int
-glfsh_print_xml_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_print_xml_brick_from_xl(xlator_t *xl, loc_t *rootloc)
 {
-        char    *remote_host = NULL;
-        char    *remote_subvol = NULL;
-        char    *uuid = NULL;
-        int     ret = 0;
-        int     x_ret = 0;
-
-        ret = dict_get_str (xl->options, "remote-host", &remote_host);
-        if (ret < 0)
-                goto print;
-
-        ret = dict_get_str (xl->options, "remote-subvolume", &remote_subvol);
-        if (ret < 0)
-                goto print;
-        ret = syncop_getxattr (xl, rootloc, &xl->options,
-                        GF_XATTR_NODE_UUID_KEY, NULL, NULL);
-        if (ret < 0)
-                goto print;
-
-        ret = dict_get_str (xl->options, GF_XATTR_NODE_UUID_KEY, &uuid);
-        if (ret < 0)
-                goto print;
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
+    char *uuid = NULL;
+    int ret = 0;
+    int x_ret = 0;
+
+    ret = dict_get_str(xl->options, "remote-host", &remote_host);
+    if (ret < 0)
+        goto print;
+
+    ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+    if (ret < 0)
+        goto print;
+    ret = syncop_getxattr(xl, rootloc, &xl->options, GF_XATTR_NODE_UUID_KEY,
+                          NULL, NULL);
+    if (ret < 0)
+        goto print;
+
+    ret = dict_get_str(xl->options, GF_XATTR_NODE_UUID_KEY, &uuid);
+    if (ret < 0)
+        goto print;
 print:
 
-        x_ret = xmlTextWriterStartElement (glfsh_writer, (xmlChar *)"brick");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-        x_ret = xmlTextWriterWriteFormatAttribute (glfsh_writer,
-                        (xmlChar *)"hostUuid", "%s", uuid?uuid:"-");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-
-        x_ret = xmlTextWriterWriteFormatElement (glfsh_writer,
-                        (xmlChar *)"name", "%s:%s",
-                        remote_host ? remote_host : "-",
-                        remote_subvol ? remote_subvol : "-");
-        XML_RET_CHECK_AND_GOTO (x_ret, xml_out);
-        xmlTextWriterFlush (glfsh_writer);
+    x_ret = xmlTextWriterStartElement(glfsh_writer, (xmlChar *)"brick");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+    x_ret = xmlTextWriterWriteFormatAttribute(
+        glfsh_writer, (xmlChar *)"hostUuid", "%s", uuid ? uuid : "-");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+
+    x_ret = xmlTextWriterWriteFormatElement(
+        glfsh_writer, (xmlChar *)"name", "%s:%s",
+        remote_host ? remote_host : "-", remote_subvol ? remote_subvol : "-");
+    XML_RET_CHECK_AND_GOTO(x_ret, xml_out);
+    xmlTextWriterFlush(glfsh_writer);
 xml_out:
-        return ret;
+    return ret;
 }
 #endif
 
 int
-glfsh_link_inode_update_loc (loc_t *loc, struct iatt *iattr)
+glfsh_link_inode_update_loc(loc_t *loc, struct iatt *iattr)
 {
-        inode_t       *link_inode = NULL;
-        int           ret = -1;
+    inode_t *link_inode = NULL;
+    int ret = -1;
 
-        link_inode = inode_link (loc->inode, NULL, NULL, iattr);
-        if (link_inode == NULL)
-                goto out;
+    link_inode = inode_link(loc->inode, NULL, NULL, iattr);
+    if (link_inode == NULL)
+        goto out;
 
-        inode_unref (loc->inode);
-        loc->inode = link_inode;
-        ret = 0;
+    inode_unref(loc->inode);
+    loc->inode = link_inode;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfsh_no_print_hr_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_no_print_hr_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        return 0;
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_op_summary (int ret, num_entries_t *num_entries)
+glfsh_print_hr_heal_op_summary(int ret, num_entries_t *num_entries)
 {
-        if (ret < 0 && num_entries->num_entries == 0) {
-                printf ("Status: %s\n", strerror (-ret));
-                printf ("Total Number of entries: -\n");
-                printf ("Number of entries in heal pending: -\n");
-                printf ("Number of entries in split-brain: -\n");
-                printf ("Number of entries possibly healing: -\n");
-                goto out;
-        } else if (ret == 0) {
-                printf ("Status: Connected\n");
-        }
-
-        if (ret < 0) {
-                printf ("Status: Failed to process entries completely. "
-                        "(%s)\nTotal Number of entries: %"PRIu64"\n",
-                        strerror (-ret), num_entries->num_entries);
-        } else {
-                printf ("Total Number of entries: %"PRIu64"\n",
-                        num_entries->num_entries);
-                printf ("Number of entries in heal pending: %"PRIu64"\n",
-                        num_entries->pending_entries);
-                printf ("Number of entries in split-brain: %"PRIu64"\n",
-                        num_entries->spb_entries);
-                printf ("Number of entries possibly healing: %"PRIu64"\n",
-                        num_entries->possibly_healing_entries);
-        }
+    if (ret < 0 && num_entries->num_entries == 0) {
+        printf("Status: %s\n", strerror(-ret));
+        printf("Total Number of entries: -\n");
+        printf("Number of entries in heal pending: -\n");
+        printf("Number of entries in split-brain: -\n");
+        printf("Number of entries possibly healing: -\n");
+        goto out;
+    } else if (ret == 0) {
+        printf("Status: Connected\n");
+    }
+
+    if (ret < 0) {
+        printf(
+            "Status: Failed to process entries completely. "
+            "(%s)\nTotal Number of entries: %" PRIu64 "\n",
+            strerror(-ret), num_entries->num_entries);
+    } else {
+        printf("Total Number of entries: %" PRIu64 "\n",
+               num_entries->num_entries);
+        printf("Number of entries in heal pending: %" PRIu64 "\n",
+               num_entries->pending_entries);
+        printf("Number of entries in split-brain: %" PRIu64 "\n",
+               num_entries->spb_entries);
+        printf("Number of entries possibly healing: %" PRIu64 "\n",
+               num_entries->possibly_healing_entries);
+    }
 out:
-        printf ("\n");
-        fflush (stdout);
-        return 0;
+    printf("\n");
+    fflush(stdout);
+    return 0;
 }
 
 int
-glfsh_print_hr_heal_op_status (int ret, uint64_t num_entries, char *fmt_str)
+glfsh_print_hr_heal_op_status(int ret, uint64_t num_entries, char *fmt_str)
 {
-        if (ret < 0 && num_entries == 0) {
-                printf ("Status: %s\n", strerror (-ret));
-                if (fmt_str)
-                        printf ("%s -\n", fmt_str);
-                goto out;
-        } else if (ret == 0) {
-                printf ("Status: Connected\n");
-        }
-
-        if (ret < 0) {
-                if (fmt_str)
-                        printf ("Status: Failed to process entries completely. "
-                                "(%s)\n%s %"PRIu64"\n",
-                         strerror (-ret), fmt_str, num_entries);
-        } else {
-                if (fmt_str)
-                        printf ("%s %"PRIu64"\n", fmt_str, num_entries);
-        }
+    if (ret < 0 && num_entries == 0) {
+        printf("Status: %s\n", strerror(-ret));
+        if (fmt_str)
+            printf("%s -\n", fmt_str);
+        goto out;
+    } else if (ret == 0) {
+        printf("Status: Connected\n");
+    }
+
+    if (ret < 0) {
+        if (fmt_str)
+            printf(
+                "Status: Failed to process entries completely. "
+                "(%s)\n%s %" PRIu64 "\n",
+                strerror(-ret), fmt_str, num_entries);
+    } else {
+        if (fmt_str)
+            printf("%s %" PRIu64 "\n", fmt_str, num_entries);
+    }
 out:
-        printf ("\n");
-        return 0;
+    printf("\n");
+    return 0;
 }
 
 int
-glfsh_print_info_summary (int ret, num_entries_t *num_entries)
+glfsh_print_info_summary(int ret, num_entries_t *num_entries)
 {
-        return glfsh_output->print_heal_op_summary (ret, num_entries);
-
+    return glfsh_output->print_heal_op_summary(ret, num_entries);
 }
 
 int
-glfsh_print_heal_op_status (int ret, uint64_t num_entries,
-                            gf_xl_afr_op_t heal_op)
+glfsh_print_heal_op_status(int ret, uint64_t num_entries,
+                           gf_xl_afr_op_t heal_op)
 {
-        char *fmt_str = NULL;
+    char *fmt_str = NULL;
 
-        if (heal_op == GF_SHD_OP_INDEX_SUMMARY)
-                fmt_str = "Number of entries:";
-        else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES)
-                fmt_str = "Number of entries in split-brain:";
-        else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK)
-                fmt_str = "Number of healed entries:";
+    if (heal_op == GF_SHD_OP_INDEX_SUMMARY)
+        fmt_str = "Number of entries:";
+    else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES)
+        fmt_str = "Number of entries in split-brain:";
+    else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK)
+        fmt_str = "Number of healed entries:";
 
-        return glfsh_output->print_heal_op_status (ret, num_entries, fmt_str);
+    return glfsh_output->print_heal_op_status(ret, num_entries, fmt_str);
 }
 
 int
-glfsh_get_index_dir_loc (loc_t *rootloc, xlator_t *xl, loc_t *dirloc,
-                         int32_t *op_errno, char *vgfid)
+glfsh_get_index_dir_loc(loc_t *rootloc, xlator_t *xl, loc_t *dirloc,
+                        int32_t *op_errno, char *vgfid)
 {
-        void      *index_gfid = NULL;
-        int       ret = 0;
-        dict_t    *xattr = NULL;
-        struct iatt   iattr = {0};
-        struct iatt   parent = {0};
-
-        ret = syncop_getxattr (xl, rootloc, &xattr, vgfid, NULL, NULL);
-        if (ret < 0) {
-                *op_errno = -ret;
-                goto out;
-        }
-
-        ret = dict_get_ptr (xattr, vgfid, &index_gfid);
-        if (ret < 0) {
-                *op_errno = EINVAL;
-                goto out;
-        }
-
-        gf_uuid_copy (dirloc->gfid, index_gfid);
-        dirloc->path = "";
-        dirloc->inode = inode_new (rootloc->inode->table);
-        ret = syncop_lookup (xl, dirloc, &iattr, &parent, NULL, NULL);
-        dirloc->path = NULL;
-        if (ret < 0) {
-                *op_errno = -ret;
-                goto out;
-        }
-        ret = glfsh_link_inode_update_loc (dirloc, &iattr);
-        if (ret)
-                goto out;
-
-        ret = glfs_loc_touchup (dirloc);
-        if (ret < 0) {
-                *op_errno = errno;
-                goto out;
-        }
-
-
-        ret = 0;
+    void *index_gfid = NULL;
+    int ret = 0;
+    dict_t *xattr = NULL;
+    struct iatt iattr = {0};
+    struct iatt parent = {0};
+
+    ret = syncop_getxattr(xl, rootloc, &xattr, vgfid, NULL, NULL);
+    if (ret < 0) {
+        *op_errno = -ret;
+        goto out;
+    }
+
+    ret = dict_get_ptr(xattr, vgfid, &index_gfid);
+    if (ret < 0) {
+        *op_errno = EINVAL;
+        goto out;
+    }
+
+    gf_uuid_copy(dirloc->gfid, index_gfid);
+    dirloc->path = "";
+    dirloc->inode = inode_new(rootloc->inode->table);
+    ret = syncop_lookup(xl, dirloc, &iattr, &parent, NULL, NULL);
+    dirloc->path = NULL;
+    if (ret < 0) {
+        *op_errno = -ret;
+        goto out;
+    }
+    ret = glfsh_link_inode_update_loc(dirloc, &iattr);
+    if (ret)
+        goto out;
+
+    ret = glfs_loc_touchup(dirloc);
+    if (ret < 0) {
+        *op_errno = errno;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (xattr)
-                dict_unref (xattr);
-        return ret;
+    if (xattr)
+        dict_unref(xattr);
+    return ret;
 }
 
-static xlator_t*
-_get_ancestor (xlator_t *xl, gf_xl_afr_op_t heal_op)
+static xlator_t *
+_get_ancestor(xlator_t *xl, gf_xl_afr_op_t heal_op)
 {
-        static char *replica_xl[] = {"cluster/replicate", NULL};
-        static char *heal_xls[] = {"cluster/replicate", "cluster/disperse",
-                                         NULL};
-        char **ancestors = NULL;
-
-        if (heal_op == GF_SHD_OP_INDEX_SUMMARY ||
-            heal_op == GF_SHD_OP_HEAL_SUMMARY)
-                ancestors = heal_xls;
-        else
-                ancestors = replica_xl;
+    static char *replica_xl[] = {"cluster/replicate", NULL};
+    static char *heal_xls[] = {"cluster/replicate", "cluster/disperse", NULL};
+    char **ancestors = NULL;
 
-        if (!xl || !xl->parents)
-                return NULL;
-
-        while (xl->parents) {
-                xl = xl->parents->xlator;
-                if (!xl)
-                        break;
-                if (gf_get_index_by_elem (ancestors, xl->type) != -1)
-                        return xl;
-        }
+    if (heal_op == GF_SHD_OP_INDEX_SUMMARY || heal_op == GF_SHD_OP_HEAL_SUMMARY)
+        ancestors = heal_xls;
+    else
+        ancestors = replica_xl;
 
+    if (!xl || !xl->parents)
         return NULL;
+
+    while (xl->parents) {
+        xl = xl->parents->xlator;
+        if (!xl)
+            break;
+        if (gf_get_index_by_elem(ancestors, xl->type) != -1)
+            return xl;
+    }
+
+    return NULL;
 }
 
 int
-glfsh_index_purge (xlator_t *subvol, inode_t *inode, char *name)
+glfsh_index_purge(xlator_t *subvol, inode_t *inode, char *name)
 {
-        loc_t loc = {0, };
-        int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
 
-        loc.parent = inode_ref (inode);
-        loc.name = name;
+    loc.parent = inode_ref(inode);
+    loc.name = name;
 
-        ret = syncop_unlink (subvol, &loc, NULL, NULL);
+    ret = syncop_unlink(subvol, &loc, NULL, NULL);
 
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-glfsh_print_summary_status (dict_t *dict, char *path, uuid_t gfid,
-                            num_entries_t *num_entries, gf_boolean_t flag)
+glfsh_print_summary_status(dict_t *dict, char *path, uuid_t gfid,
+                           num_entries_t *num_entries, gf_boolean_t flag)
 {
-        int     ret     = 0;
-        char    *value  = NULL;
-
-        ret = dict_get_str (dict, "heal-info", &value);
-        if (ret)
-                goto out;
-
-        if ((!strcmp (value, "heal")) || (!strcmp (value, "heal-pending"))) {
-                (num_entries->pending_entries)++;
-        } else if ((!strcmp (value, "split-brain")) ||
-                        (!strcmp (value, "split-brain-pending"))) {
-                (num_entries->spb_entries)++;
-        } else if ((!strcmp (value, "possibly-healing-pending")) ||
-                        (!strcmp (value, "possibly-healing"))) {
-                (num_entries->possibly_healing_entries)++;
-        } else {
-                goto out;
-        }
-        (num_entries->num_entries)++;
+    int ret = 0;
+    char *value = NULL;
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret)
+        goto out;
+
+    if ((!strcmp(value, "heal")) || (!strcmp(value, "heal-pending"))) {
+        (num_entries->pending_entries)++;
+    } else if ((!strcmp(value, "split-brain")) ||
+               (!strcmp(value, "split-brain-pending"))) {
+        (num_entries->spb_entries)++;
+    } else if ((!strcmp(value, "possibly-healing-pending")) ||
+               (!strcmp(value, "possibly-healing"))) {
+        (num_entries->possibly_healing_entries)++;
+    } else {
+        goto out;
+    }
+    (num_entries->num_entries)++;
 out:
-        return ret;
+    return ret;
 }
 
 int
-glfsh_print_spb_status (dict_t *dict, char *path, uuid_t gfid,
-                        num_entries_t *num_entries, gf_boolean_t flag)
+glfsh_print_spb_status(dict_t *dict, char *path, uuid_t gfid,
+                       num_entries_t *num_entries, gf_boolean_t flag)
 {
-        int   ret    = 0;
-        gf_boolean_t    pending         = _gf_false;
-        gf_boolean_t    split_b         = _gf_false;
-        char            *value          = NULL;
-        char            gfid_str[64]    = {0};
-
-        ret = dict_get_str (dict, "heal-info", &value);
-        if (ret)
-                return 0;
+    int ret = 0;
+    gf_boolean_t pending = _gf_false;
+    gf_boolean_t split_b = _gf_false;
+    char *value = NULL;
+    char gfid_str[64] = {0};
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret)
+        return 0;
 
-        if (!strcmp (value, "split-brain")) {
-                split_b = _gf_true;
-        } else if (!strcmp (value, "split-brain-pending")) {
-                split_b = _gf_true;
-                pending = _gf_true;
+    if (!strcmp(value, "split-brain")) {
+        split_b = _gf_true;
+    } else if (!strcmp(value, "split-brain-pending")) {
+        split_b = _gf_true;
+        pending = _gf_true;
+    }
+    /* Consider the entry only iff :
+     * 1) The dir being processed is not indices/dirty, indicated by
+     *    flag == _gf_false
+     * 2) The dir being processed is indices/dirty but the entry also
+     *    exists in indices/xattrop dir and has already been processed.
+     */
+    if (split_b) {
+        if (!flag || (flag && !pending)) {
+            (num_entries->num_entries)++;
+            glfsh_output->print_spb_status(
+                path ? path : uuid_utoa_r(gfid, gfid_str), gfid, NULL);
         }
-        /* Consider the entry only iff :
-         * 1) The dir being processed is not indices/dirty, indicated by
-         *    flag == _gf_false
-         * 2) The dir being processed is indices/dirty but the entry also
-         *    exists in indices/xattrop dir and has already been processed.
-         */
-        if (split_b) {
-                if (!flag || (flag && !pending)) {
-                        (num_entries->num_entries)++;
-                        glfsh_output->print_spb_status (path ? path :
-                                                uuid_utoa_r (gfid, gfid_str),
-                                                gfid, NULL);
-                }
-        }
-        return 0;
+    }
+    return 0;
 }
 
 int
-glfsh_print_heal_status (dict_t *dict, char *path, uuid_t gfid,
-                         num_entries_t *num_entries,
-                         gf_boolean_t ignore_dirty)
+glfsh_print_heal_status(dict_t *dict, char *path, uuid_t gfid,
+                        num_entries_t *num_entries, gf_boolean_t ignore_dirty)
 {
-        int             ret             = 0;
-        gf_boolean_t    pending         = _gf_false;
-        char            *status         = NULL;
-        char            *value          = NULL;
-        char            gfid_str[64]    = {0};
-
-        ret = dict_get_str (dict, "heal-info", &value);
-        if (ret || (!strcmp (value, "no-heal")))
-                return 0;
-
-        if (!strcmp (value, "heal")) {
-                ret = gf_asprintf (&status, " ");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "possibly-healing")) {
-                ret = gf_asprintf (&status,
-                                   " - Possibly undergoing heal");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "split-brain")) {
-                ret = gf_asprintf (&status, " - Is in split-brain");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "heal-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status, " ");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "split-brain-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status, " - Is in split-brain");
-                if (ret < 0)
-                        goto out;
-        } else if (!strcmp (value, "possibly-healing-pending")) {
-                pending = _gf_true;
-                ret = gf_asprintf (&status,
-                                   " - Possibly undergoing heal");
-                if (ret < 0)
-                        goto out;
-        }
+    int ret = 0;
+    gf_boolean_t pending = _gf_false;
+    char *status = NULL;
+    char *value = NULL;
+    char gfid_str[64] = {0};
+
+    ret = dict_get_str(dict, "heal-info", &value);
+    if (ret || (!strcmp(value, "no-heal")))
+        return 0;
+
+    if (!strcmp(value, "heal")) {
+        ret = gf_asprintf(&status, " ");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "possibly-healing")) {
+        ret = gf_asprintf(&status, " - Possibly undergoing heal");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "split-brain")) {
+        ret = gf_asprintf(&status, " - Is in split-brain");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "heal-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " ");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "split-brain-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " - Is in split-brain");
+        if (ret < 0)
+            goto out;
+    } else if (!strcmp(value, "possibly-healing-pending")) {
+        pending = _gf_true;
+        ret = gf_asprintf(&status, " - Possibly undergoing heal");
+        if (ret < 0)
+            goto out;
+    }
 out:
-        /* If ignore_dirty is set, it means indices/dirty directory is
-         * being processed. Ignore the entry if it also exists in
-         * indices/xattrop.
-         * Boolean pending is set to true if the entry also exists in
-         * indices/xattrop directory.
-         */
-        if (ignore_dirty) {
-                if (pending) {
-                        GF_FREE (status);
-                        status = NULL;
-                        return 0;
-                }
+    /* If ignore_dirty is set, it means indices/dirty directory is
+     * being processed. Ignore the entry if it also exists in
+     * indices/xattrop.
+     * Boolean pending is set to true if the entry also exists in
+     * indices/xattrop directory.
+     */
+    if (ignore_dirty) {
+        if (pending) {
+            GF_FREE(status);
+            status = NULL;
+            return 0;
         }
-        if (ret == -1)
-                status = NULL;
+    }
+    if (ret == -1)
+        status = NULL;
 
-        (num_entries->num_entries)++;
-        glfsh_output->print_heal_status (path ? path :
-                                         uuid_utoa_r (gfid, gfid_str),
-                                         gfid,
-                                         status ? status : "");
+    (num_entries->num_entries)++;
+    glfsh_output->print_heal_status(path ? path : uuid_utoa_r(gfid, gfid_str),
+                                    gfid, status ? status : "");
 
-        GF_FREE (status);
-        return 0;
+    GF_FREE(status);
+    return 0;
 }
 
 int
-glfsh_heal_status_boolean (dict_t *dict, char *path, uuid_t gfid,
-                           num_entries_t *num_entries, gf_boolean_t ignore_dirty)
+glfsh_heal_status_boolean(dict_t *dict, char *path, uuid_t gfid,
+                          num_entries_t *num_entries, gf_boolean_t ignore_dirty)
 {
-        int             ret             = 0;
-        char            *value          = NULL;
+    int ret = 0;
+    char *value = NULL;
 
-        ret = dict_get_str (dict, "heal-info", &value);
-        if ((!ret) && (!strcmp (value, "no-heal")))
-                return 0;
-        else
-                return -1;
+    ret = dict_get_str(dict, "heal-info", &value);
+    if ((!ret) && (!strcmp(value, "no-heal")))
+        return 0;
+    else
+        return -1;
 }
 
 static void
-glfsh_heal_entries (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                    gf_dirent_t *entries,  uint64_t *offset,
-                    num_entries_t *num_entries, dict_t *xattr_req) {
-
-        gf_dirent_t      *entry          = NULL;
-        gf_dirent_t      *tmp            = NULL;
-        int               ret            = 0;
-        char              file[64]      = {0};
-
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                *offset = entry->d_off;
-                if ((strcmp (entry->d_name, ".") == 0) ||
-                    (strcmp (entry->d_name, "..") == 0))
-                        continue;
-                snprintf (file, sizeof(file), "gfid:%s", entry->d_name);
-                ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                                 xattr_req);
-                if (ret)
-                        continue;
-                (num_entries->num_entries)++;
-        }
+glfsh_heal_entries(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                   gf_dirent_t *entries, uint64_t *offset,
+                   num_entries_t *num_entries, dict_t *xattr_req)
+{
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    int ret = 0;
+    char file[64] = {0};
+
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        *offset = entry->d_off;
+        if ((strcmp(entry->d_name, ".") == 0) ||
+            (strcmp(entry->d_name, "..") == 0))
+            continue;
+        snprintf(file, sizeof(file), "gfid:%s", entry->d_name);
+        ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file,
+                                         xattr_req);
+        if (ret)
+            continue;
+        (num_entries->num_entries)++;
+    }
 }
 
 static int
-glfsh_process_entries (xlator_t *xl, fd_t *fd, gf_dirent_t *entries,
-                       uint64_t *offset, num_entries_t *num_entries,
-                       print_status glfsh_print_status,
-                       gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode)
+glfsh_process_entries(xlator_t *xl, fd_t *fd, gf_dirent_t *entries,
+                      uint64_t *offset, num_entries_t *num_entries,
+                      print_status glfsh_print_status,
+                      gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode)
 {
-        gf_dirent_t      *entry = NULL;
-        gf_dirent_t      *tmp = NULL;
-        int              ret = 0;
-        int              print_status = 0;
-        char            *path = NULL;
-        uuid_t          gfid = {0};
-        xlator_t        *this = NULL;
-        dict_t          *dict = NULL;
-        loc_t           loc   = {0,};
-        this = THIS;
-
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                *offset = entry->d_off;
-                if ((strcmp (entry->d_name, ".") == 0) ||
-                    (strcmp (entry->d_name, "..") == 0))
-                        continue;
-
-                if (dict) {
-                        dict_unref (dict);
-                        dict = NULL;
-                }
-                gf_uuid_clear (gfid);
-                GF_FREE (path);
-                path = NULL;
-
-                gf_uuid_parse (entry->d_name, gfid);
-                gf_uuid_copy (loc.gfid, gfid);
-                ret = syncop_getxattr (this, &loc, &dict, GF_HEAL_INFO, NULL,
-                                       NULL);
-                if (ret) {
-                        if ((mode != GLFSH_MODE_CONTINUE_ON_ERROR) &&
-                            (ret == -ENOTCONN))
-                                goto out;
-                        else
-                                continue;
-                }
-
-                ret = syncop_gfid_to_path (this->itable, xl, gfid, &path);
-
-                if (ret == -ENOENT || ret == -ESTALE) {
-                        glfsh_index_purge (xl, fd->inode, entry->d_name);
-                        ret = 0;
-                        continue;
-                }
-                if (dict) {
-                        print_status = glfsh_print_status (dict, path, gfid,
-                                                           num_entries,
-                                                           ignore_dirty);
-                        if ((print_status) &&
-                            (mode != GLFSH_MODE_CONTINUE_ON_ERROR)) {
-                                ret = -EAGAIN;
-                                goto out;
-                        }
-                }
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    int ret = 0;
+    int print_status = 0;
+    char *path = NULL;
+    uuid_t gfid = {0};
+    xlator_t *this = NULL;
+    dict_t *dict = NULL;
+    loc_t loc = {
+        0,
+    };
+    this = THIS;
+
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        *offset = entry->d_off;
+        if ((strcmp(entry->d_name, ".") == 0) ||
+            (strcmp(entry->d_name, "..") == 0))
+            continue;
+
+        if (dict) {
+            dict_unref(dict);
+            dict = NULL;
+        }
+        gf_uuid_clear(gfid);
+        GF_FREE(path);
+        path = NULL;
+
+        gf_uuid_parse(entry->d_name, gfid);
+        gf_uuid_copy(loc.gfid, gfid);
+        ret = syncop_getxattr(this, &loc, &dict, GF_HEAL_INFO, NULL, NULL);
+        if (ret) {
+            if ((mode != GLFSH_MODE_CONTINUE_ON_ERROR) && (ret == -ENOTCONN))
+                goto out;
+            else
+                continue;
+        }
+
+        ret = syncop_gfid_to_path(this->itable, xl, gfid, &path);
+
+        if (ret == -ENOENT || ret == -ESTALE) {
+            glfsh_index_purge(xl, fd->inode, entry->d_name);
+            ret = 0;
+            continue;
         }
-        ret = 0;
-out:
-        GF_FREE (path);
         if (dict) {
-                dict_unref (dict);
-                dict = NULL;
+            print_status = glfsh_print_status(dict, path, gfid, num_entries,
+                                              ignore_dirty);
+            if ((print_status) && (mode != GLFSH_MODE_CONTINUE_ON_ERROR)) {
+                ret = -EAGAIN;
+                goto out;
+            }
         }
-        return ret;
+    }
+    ret = 0;
+out:
+    GF_FREE(path);
+    if (dict) {
+        dict_unref(dict);
+        dict = NULL;
+    }
+    return ret;
 }
 
 static int
-glfsh_crawl_directory (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                       xlator_t *readdir_xl, fd_t *fd, loc_t *loc,
-                       dict_t *xattr_req, num_entries_t *num_entries,
-                       gf_boolean_t ignore)
+glfsh_crawl_directory(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                      xlator_t *readdir_xl, fd_t *fd, loc_t *loc,
+                      dict_t *xattr_req, num_entries_t *num_entries,
+                      gf_boolean_t ignore)
 {
-        int             ret          = 0;
-        int             heal_op      = -1;
-        uint64_t        offset       = 0;
-        gf_dirent_t     entries;
-        gf_boolean_t    free_entries = _gf_false;
-        glfsh_fail_mode_t mode = GLFSH_MODE_CONTINUE_ON_ERROR;
-
-        INIT_LIST_HEAD (&entries.list);
-        ret = dict_get_int32 (xattr_req, "heal-op", &heal_op);
-        if (ret)
-                return ret;
+    int ret = 0;
+    int heal_op = -1;
+    uint64_t offset = 0;
+    gf_dirent_t entries;
+    gf_boolean_t free_entries = _gf_false;
+    glfsh_fail_mode_t mode = GLFSH_MODE_CONTINUE_ON_ERROR;
+
+    INIT_LIST_HEAD(&entries.list);
+    ret = dict_get_int32(xattr_req, "heal-op", &heal_op);
+    if (ret)
+        return ret;
 
-        if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                mode = GLFSH_MODE_EXIT_ON_FIRST_FAILURE;
+    if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        mode = GLFSH_MODE_EXIT_ON_FIRST_FAILURE;
 
-        while (1) {
-                ret = syncop_readdir (readdir_xl, fd, 131072, offset, &entries,
-                                      NULL, NULL);
-                if (ret <= 0)
-                        break;
-                ret = 0;
-                free_entries = _gf_true;
-
-                if (list_empty (&entries.list))
-                        goto out;
-
-                if (heal_op == GF_SHD_OP_INDEX_SUMMARY) {
-                        ret = glfsh_process_entries (readdir_xl, fd,
-                                                     &entries, &offset,
-                                                     num_entries,
-                                                     glfsh_print_heal_status,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) {
-                        ret = glfsh_process_entries (readdir_xl, fd,
-                                                     &entries, &offset,
-                                                     num_entries,
-                                                     glfsh_print_spb_status,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                } else if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
-                        ret = glfsh_process_entries (readdir_xl, fd,
-                                                     &entries, &offset,
-                                                     num_entries,
-                                                     glfsh_print_summary_status,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
-                        glfsh_heal_entries (fs, top_subvol, rootloc, &entries,
-                                            &offset, num_entries, xattr_req);
-                } else if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) {
-                        ret = glfsh_process_entries (readdir_xl, fd, &entries,
-                                                     &offset, num_entries,
-                                                     glfsh_heal_status_boolean,
-                                                     ignore, mode);
-                        if (ret < 0)
-                                goto out;
-                }
-                gf_dirent_free (&entries);
-                free_entries = _gf_false;
-        }
+    while (1) {
+        ret = syncop_readdir(readdir_xl, fd, 131072, offset, &entries, NULL,
+                             NULL);
+        if (ret <= 0)
+            break;
         ret = 0;
+        free_entries = _gf_true;
+
+        if (list_empty(&entries.list))
+            goto out;
+
+        if (heal_op == GF_SHD_OP_INDEX_SUMMARY) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_heal_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_spb_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_print_summary_status,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
+            glfsh_heal_entries(fs, top_subvol, rootloc, &entries, &offset,
+                               num_entries, xattr_req);
+        } else if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) {
+            ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,
+                                        num_entries, glfsh_heal_status_boolean,
+                                        ignore, mode);
+            if (ret < 0)
+                goto out;
+        }
+        gf_dirent_free(&entries);
+        free_entries = _gf_false;
+    }
+    ret = 0;
 out:
-        if (free_entries)
-                gf_dirent_free (&entries);
-        return ret;
+    if (free_entries)
+        gf_dirent_free(&entries);
+    return ret;
 }
 
 static int
-glfsh_no_print_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_no_print_brick_from_xl(xlator_t *xl, loc_t *rootloc)
 {
-        return 0;
+    return 0;
 }
 
 static int
-glfsh_print_brick_from_xl (xlator_t *xl, loc_t *rootloc)
+glfsh_print_brick_from_xl(xlator_t *xl, loc_t *rootloc)
 {
-        char    *remote_host = NULL;
-        char    *remote_subvol = NULL;
-        int     ret = 0;
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
+    int ret = 0;
 
-        ret = dict_get_str (xl->options, "remote-host", &remote_host);
-        if (ret < 0)
-                goto out;
+    ret = dict_get_str(xl->options, "remote-host", &remote_host);
+    if (ret < 0)
+        goto out;
 
-        ret = dict_get_str (xl->options, "remote-subvolume", &remote_subvol);
-        if (ret < 0)
-                goto out;
+    ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+    if (ret < 0)
+        goto out;
 out:
-        if (ret < 0)
-                printf ("Brick - Not able to get brick information\n");
-        else
-                printf ("Brick %s:%s\n", remote_host, remote_subvol);
-        return ret;
+    if (ret < 0)
+        printf("Brick - Not able to get brick information\n");
+    else
+        printf("Brick %s:%s\n", remote_host, remote_subvol);
+    return ret;
 }
 
 int
-glfsh_print_pending_heals_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                                xlator_t *xl, gf_xl_afr_op_t heal_op,
-                                dict_t *xattr_req, char *vgfid,
-                                num_entries_t *num_entries)
+glfsh_print_pending_heals_type(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                               xlator_t *xl, gf_xl_afr_op_t heal_op,
+                               dict_t *xattr_req, char *vgfid,
+                               num_entries_t *num_entries)
 {
-        int ret = 0;
-        loc_t   dirloc = {0};
-        fd_t    *fd = NULL;
-        int32_t op_errno = 0;
-        gf_boolean_t ignore = _gf_false;
-
-        if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID))
-                ignore = _gf_true;
-
-        ret = glfsh_get_index_dir_loc (rootloc, xl, &dirloc, &op_errno,
-                                       vgfid);
-        if (ret < 0) {
-                if (op_errno == ESTALE || op_errno == ENOENT ||
-                    op_errno == ENOTSUP)
-                        ret = 0;
-                else
-                        ret = -op_errno;
-                goto out;
-        }
-
-        ret = syncop_dirfd (xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
-        if (ret)
-                goto out;
-
-        ret = glfsh_crawl_directory (fs, top_subvol, rootloc, xl, fd, &dirloc,
-                                     xattr_req, num_entries, ignore);
-        if (fd)
-                fd_unref (fd);
+    int ret = 0;
+    loc_t dirloc = {0};
+    fd_t *fd = NULL;
+    int32_t op_errno = 0;
+    gf_boolean_t ignore = _gf_false;
+
+    if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID))
+        ignore = _gf_true;
+
+    ret = glfsh_get_index_dir_loc(rootloc, xl, &dirloc, &op_errno, vgfid);
+    if (ret < 0) {
+        if (op_errno == ESTALE || op_errno == ENOENT || op_errno == ENOTSUP)
+            ret = 0;
+        else
+            ret = -op_errno;
+        goto out;
+    }
+
+    ret = syncop_dirfd(xl, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
+    if (ret)
+        goto out;
+
+    ret = glfsh_crawl_directory(fs, top_subvol, rootloc, xl, fd, &dirloc,
+                                xattr_req, num_entries, ignore);
+    if (fd)
+        fd_unref(fd);
 out:
-        loc_wipe (&dirloc);
-        return ret;
+    loc_wipe(&dirloc);
+    return ret;
 }
 
 int
-glfsh_print_pending_heals (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                           xlator_t *xl, gf_xl_afr_op_t heal_op, gf_boolean_t
-                           is_parent_replicate)
+glfsh_print_pending_heals(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                          xlator_t *xl, gf_xl_afr_op_t heal_op,
+                          gf_boolean_t is_parent_replicate)
 {
-        int ret = 0;
-        num_entries_t num_entries = {0, };
-        num_entries_t total = {0, };
-
-        dict_t *xattr_req = NULL;
-
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op", heal_op);
-        if (ret)
-                goto out;
-
-        if ((!is_parent_replicate) &&
-            ((heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||
-             (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE))) {
-                ret = 0;
-                goto out;
-        }
-
-        ret = glfsh_output->print_brick_from_xl (xl, rootloc);
-        if (ret < 0)
-                goto out;
-
-        ret = glfsh_print_pending_heals_type (fs, top_subvol, rootloc, xl,
-                                              heal_op, xattr_req,
-                                              GF_XATTROP_INDEX_GFID,
-                                              &num_entries);
-
-        if (ret < 0 && heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                goto out;
-
+    int ret = 0;
+    num_entries_t num_entries = {
+        0,
+    };
+    num_entries_t total = {
+        0,
+    };
+
+    dict_t *xattr_req = NULL;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op", heal_op);
+    if (ret)
+        goto out;
+
+    if ((!is_parent_replicate) &&
+        ((heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) ||
+         (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_DISABLE))) {
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfsh_output->print_brick_from_xl(xl, rootloc);
+    if (ret < 0)
+        goto out;
+
+    ret = glfsh_print_pending_heals_type(fs, top_subvol, rootloc, xl, heal_op,
+                                         xattr_req, GF_XATTROP_INDEX_GFID,
+                                         &num_entries);
+
+    if (ret < 0 && heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        goto out;
+
+    total.num_entries += num_entries.num_entries;
+    total.pending_entries += num_entries.pending_entries;
+    total.spb_entries += num_entries.spb_entries;
+    total.possibly_healing_entries += num_entries.possibly_healing_entries;
+    num_entries.num_entries = 0;
+    num_entries.pending_entries = 0;
+    num_entries.spb_entries = 0;
+    num_entries.possibly_healing_entries = 0;
+    if (ret == -ENOTCONN)
+        goto out;
+
+    if (is_parent_replicate) {
+        ret = glfsh_print_pending_heals_type(
+            fs, top_subvol, rootloc, xl, heal_op, xattr_req,
+            GF_XATTROP_DIRTY_GFID, &num_entries);
         total.num_entries += num_entries.num_entries;
         total.pending_entries += num_entries.pending_entries;
         total.spb_entries += num_entries.spb_entries;
         total.possibly_healing_entries += num_entries.possibly_healing_entries;
-        num_entries.num_entries = 0;
-        num_entries.pending_entries = 0;
-        num_entries.spb_entries = 0;
-        num_entries.possibly_healing_entries = 0;
-        if (ret == -ENOTCONN)
-                goto out;
-
-        if (is_parent_replicate) {
-                ret = glfsh_print_pending_heals_type (fs, top_subvol,
-                                                      rootloc, xl,
-                                                      heal_op, xattr_req,
-                                                      GF_XATTROP_DIRTY_GFID,
-                                                      &num_entries);
-                total.num_entries += num_entries.num_entries;
-                total.pending_entries += num_entries.pending_entries;
-                total.spb_entries += num_entries.spb_entries;
-                total.possibly_healing_entries += num_entries.possibly_healing_entries;
-        }
+    }
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
-                glfsh_print_info_summary (ret, &total);
-        } else {
-                glfsh_print_heal_op_status (ret, total.num_entries, heal_op);
-        }
-        return ret;
-
+    if (xattr_req)
+        dict_unref(xattr_req);
+    if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {
+        glfsh_print_info_summary(ret, &total);
+    } else {
+        glfsh_print_heal_op_status(ret, total.num_entries, heal_op);
+    }
+    return ret;
 }
 
 static int
-glfsh_set_heal_options (glfs_t *fs, gf_xl_afr_op_t heal_op)
+glfsh_set_heal_options(glfs_t *fs, gf_xl_afr_op_t heal_op)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*",
-                                      "background-self-heal-count", "0");
-        if (ret)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*",
+                                 "background-self-heal-count", "0");
+    if (ret)
+        goto out;
 
-        if ((heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) &&
-            (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) &&
-            (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME))
-                return 0;
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "data-self-heal",
-                                      "on");
-        if (ret)
-                goto out;
+    if ((heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) &&
+        (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) &&
+        (heal_op != GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME))
+        return 0;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "data-self-heal", "on");
+    if (ret)
+        goto out;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "metadata-self-heal",
-                                      "on");
-        if (ret)
-                goto out;
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "metadata-self-heal",
+                                 "on");
+    if (ret)
+        goto out;
 
-        ret = glfs_set_xlator_option (fs, "*-replicate-*", "entry-self-heal",
-                                      "on");
+    ret = glfs_set_xlator_option(fs, "*-replicate-*", "entry-self-heal", "on");
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-glfsh_validate_volume (xlator_t *xl, gf_xl_afr_op_t heal_op)
+glfsh_validate_volume(xlator_t *xl, gf_xl_afr_op_t heal_op)
 {
-        xlator_t        *heal_xl = NULL;
-        int             ret = -1;
-
-        while (xl->next)
-                xl = xl->next;
-
-        while (xl) {
-                if (strcmp (xl->type, "protocol/client") == 0) {
-                        heal_xl = _get_ancestor (xl, heal_op);
-                        if (heal_xl) {
-                                ret = 0;
-                                break;
-                        }
-                }
-
-                xl = xl->prev;
+    xlator_t *heal_xl = NULL;
+    int ret = -1;
+
+    while (xl->next)
+        xl = xl->next;
+
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0) {
+            heal_xl = _get_ancestor(xl, heal_op);
+            if (heal_xl) {
+                ret = 0;
+                break;
+            }
         }
 
-        return ret;
+        xl = xl->prev;
+    }
+
+    return ret;
 }
 
-static xlator_t*
-_brick_path_to_client_xlator (xlator_t *top_subvol, char *hostname,
-                              char *brickpath)
+static xlator_t *
+_brick_path_to_client_xlator(xlator_t *top_subvol, char *hostname,
+                             char *brickpath)
 {
-        int ret             = 0;
-        xlator_t *xl        = NULL;
-        char *remote_host   = NULL;
-        char *remote_subvol = NULL;
-
-        xl = top_subvol;
-
-        while (xl->next)
-                xl = xl->next;
-
-        while (xl) {
-                if (!strcmp (xl->type, "protocol/client")) {
-                        ret = dict_get_str (xl->options, "remote-host",
-                                                    &remote_host);
-                        if (ret < 0)
-                                goto out;
-                        ret = dict_get_str (xl->options,
-                                            "remote-subvolume", &remote_subvol);
-                        if (ret < 0)
-                                goto out;
-                        if (!strcmp (hostname, remote_host) &&
-                            !strcmp (brickpath, remote_subvol))
-                                return xl;
-                }
-                xl = xl->prev;
+    int ret = 0;
+    xlator_t *xl = NULL;
+    char *remote_host = NULL;
+    char *remote_subvol = NULL;
+
+    xl = top_subvol;
+
+    while (xl->next)
+        xl = xl->next;
+
+    while (xl) {
+        if (!strcmp(xl->type, "protocol/client")) {
+            ret = dict_get_str(xl->options, "remote-host", &remote_host);
+            if (ret < 0)
+                goto out;
+            ret = dict_get_str(xl->options, "remote-subvolume", &remote_subvol);
+            if (ret < 0)
+                goto out;
+            if (!strcmp(hostname, remote_host) &&
+                !strcmp(brickpath, remote_subvol))
+                return xl;
         }
+        xl = xl->prev;
+    }
 
 out:
-        return NULL;
+    return NULL;
 }
 
 int
-glfsh_gather_heal_info (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                        gf_xl_afr_op_t heal_op)
+glfsh_gather_heal_info(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                       gf_xl_afr_op_t heal_op)
 {
-        int        ret       = 0;
-        xlator_t  *xl        = NULL;
-        xlator_t  *heal_xl   = NULL;
-        xlator_t  *old_THIS  = NULL;
-
-        xl = top_subvol;
-        while (xl->next)
-                xl = xl->next;
-        while (xl) {
-                if (strcmp (xl->type, "protocol/client") == 0) {
-                        heal_xl = _get_ancestor (xl, heal_op);
-                        if (heal_xl) {
-                                old_THIS = THIS;
-                                THIS = heal_xl;
-                                ret = glfsh_print_pending_heals (fs, top_subvol,
-                                                                 rootloc, xl,
-                                                                 heal_op,
-                                                                 !strcmp
-                                                                (heal_xl->type,
-                                                          "cluster/replicate"));
-                                THIS = old_THIS;
-
-                                if ((ret < 0) &&
-                              (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE))
-                                        goto out;
-                        }
-                }
-
-                xl = xl->prev;
+    int ret = 0;
+    xlator_t *xl = NULL;
+    xlator_t *heal_xl = NULL;
+    xlator_t *old_THIS = NULL;
+
+    xl = top_subvol;
+    while (xl->next)
+        xl = xl->next;
+    while (xl) {
+        if (strcmp(xl->type, "protocol/client") == 0) {
+            heal_xl = _get_ancestor(xl, heal_op);
+            if (heal_xl) {
+                old_THIS = THIS;
+                THIS = heal_xl;
+                ret = glfsh_print_pending_heals(
+                    fs, top_subvol, rootloc, xl, heal_op,
+                    !strcmp(heal_xl->type, "cluster/replicate"));
+                THIS = old_THIS;
+
+                if ((ret < 0) &&
+                    (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE))
+                    goto out;
+            }
         }
 
+        xl = xl->prev;
+    }
+
 out:
-        if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                ret = 0;
+    if (heal_op != GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int
-_validate_directory (dict_t *xattr_req, char *file)
+_validate_directory(dict_t *xattr_req, char *file)
 {
-        int heal_op = -1;
-        int ret = 0;
-
-        ret = dict_get_int32 (xattr_req, "heal-op", &heal_op);
-        if (ret)
-                return ret;
-
-        if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) {
-                printf ("'bigger-file' not a valid option for directories.\n");
-                ret = -1;
-        } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
-                printf ("'source-brick' option used on a directory (%s). "
-                        "Performing conservative merge.\n", file);
-        }
+    int heal_op = -1;
+    int ret = 0;
 
+    ret = dict_get_int32(xattr_req, "heal-op", &heal_op);
+    if (ret)
         return ret;
+
+    if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE) {
+        printf("'bigger-file' not a valid option for directories.\n");
+        ret = -1;
+    } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {
+        printf(
+            "'source-brick' option used on a directory (%s). "
+            "Performing conservative merge.\n",
+            file);
+    }
+
+    return ret;
 }
 
 int
-glfsh_heal_splitbrain_file (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                            char *file, dict_t *xattr_req)
+glfsh_heal_splitbrain_file(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *file, dict_t *xattr_req)
 {
-        int          ret           = -1;
-        int          reval         = 0;
-        loc_t        loc           = {0, };
-        char        *path          = NULL;
-        char        *path1         = NULL;
-        char        *path2         = NULL;
-        char        *filename      = NULL;
-        char        *filename1     = NULL;
-        struct iatt  iatt          = {0, };
-        xlator_t    *xl            = top_subvol;
-        dict_t      *xattr_rsp     = NULL;
-        char        *sh_fail_msg   = NULL;
-        char        *gfid_heal_msg = NULL;
-        int32_t      op_errno      = 0;
-        gf_boolean_t flag          = _gf_false;
-
-        if (!strncmp (file, "gfid:", 5)) {
-                filename = gf_strdup(file);
-                if (!filename) {
-                        printf ("Error allocating memory to filename\n");
-                        goto out;
-                }
-                path = strtok (filename, ":");
-                path = strtok (NULL, ";");
-                gf_uuid_parse (path, loc.gfid);
-                loc.path = gf_strdup (uuid_utoa (loc.gfid));
-                if (!loc.path) {
-                        printf ("Error allocating memory to path\n");
-                        goto out;
-                }
-                loc.inode = inode_new (rootloc->inode->table);
-                if (!loc.inode) {
-                        printf ("Error getting inode\n");
-                        goto out;
-                }
-                ret = syncop_lookup (xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
-                if (ret) {
-                        op_errno = -ret;
-                        printf ("Lookup failed on %s:%s.\n", file,
-                                strerror(op_errno));
-                        goto out;
-                }
-        } else {
-                if (file[0] != '/') {
-                        printf ("<FILE> must be absolute path w.r.t. the "
-                                "volume, starting with '/'\n");
-                        ret = -1;
-                        goto out;
-                }
-                path1 = gf_strdup (file);
-                if (!path1) {
-                        printf ("Error allocating memory to path\n");
-                        ret = -1;
-                        goto out;
-                }
-                path2 = gf_strdup (file);
-                if (!path2) {
-                        printf ("Error allocating memory to path\n");
-                        ret = -1;
-                        goto out;
-                }
-                path = dirname (path1);
-                filename1 = basename (path2);
-retry1:
-                ret = glfs_resolve (fs, xl, path, &loc, &iatt, reval);
-                ESTALE_RETRY (ret, errno, reval, &loc, retry1);
-                if (ret) {
-                        printf("Lookup failed on %s:%s\n",
-                               path, strerror (errno));
-                        goto out;
-                }
-                GF_FREE ((char *)loc.path);
-                loc.path = gf_strdup (file);
-                if (!loc.path) {
-                        printf ("Error allocating memory for path\n");
-                        ret = -1;
-                        goto out;
-                }
-                loc.parent = inode_unref (loc.parent);
-                loc.parent = inode_ref (loc.inode);
-                loc.inode = inode_unref (loc.inode);
-                loc.inode = inode_new (rootloc->inode->table);
-                if (!loc.inode) {
-                        printf ("Error getting inode\n");
-                        ret = -1;
-                        goto out;
-                }
-                loc.name = filename1;
-                gf_uuid_copy (loc.pargfid, loc.gfid);
-                gf_uuid_clear (loc.gfid);
-
-                ret = syncop_lookup (xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
-                if (ret) {
-                        op_errno = -ret;
-                        printf ("Lookup failed on %s:%s.\n", file,
-                                strerror(op_errno));
-                        flag = _gf_true;
-                }
-
-                ret = dict_get_str (xattr_rsp, "gfid-heal-msg", &gfid_heal_msg);
-                if (!ret) {
-                        printf ("%s for file %s\n", gfid_heal_msg, file);
-                        loc_wipe (&loc);
-                        goto out;
-                }
-                if (flag)
-                        goto out;
-
-                reval = 0;
-                loc_wipe (&loc);
-                memset (&iatt, 0, sizeof(iatt));
-
-retry2:
-                ret = glfs_resolve (fs, xl, file, &loc, &iatt, reval);
-                ESTALE_RETRY (ret, errno, reval, &loc, retry2);
-                if (ret) {
-                        printf("Lookup failed on %s:%s\n",
-                               file, strerror (errno));
-                        goto out;
-                }
+    int ret = -1;
+    int reval = 0;
+    loc_t loc = {
+        0,
+    };
+    char *path = NULL;
+    char *path1 = NULL;
+    char *path2 = NULL;
+    char *filename = NULL;
+    char *filename1 = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    xlator_t *xl = top_subvol;
+    dict_t *xattr_rsp = NULL;
+    char *sh_fail_msg = NULL;
+    char *gfid_heal_msg = NULL;
+    int32_t op_errno = 0;
+    gf_boolean_t flag = _gf_false;
+
+    if (!strncmp(file, "gfid:", 5)) {
+        filename = gf_strdup(file);
+        if (!filename) {
+            printf("Error allocating memory to filename\n");
+            goto out;
         }
-
-        if (iatt.ia_type == IA_IFDIR) {
-                ret = _validate_directory (xattr_req, file);
-                if (ret)
-                        goto out;
+        path = strtok(filename, ":");
+        path = strtok(NULL, ";");
+        gf_uuid_parse(path, loc.gfid);
+        loc.path = gf_strdup(uuid_utoa(loc.gfid));
+        if (!loc.path) {
+            printf("Error allocating memory to path\n");
+            goto out;
+        }
+        loc.inode = inode_new(rootloc->inode->table);
+        if (!loc.inode) {
+            printf("Error getting inode\n");
+            goto out;
         }
-        ret = syncop_getxattr (xl, &loc, &xattr_rsp, GF_AFR_HEAL_SBRAIN,
-                               xattr_req, NULL);
+        ret = syncop_lookup(xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
         if (ret) {
-                op_errno = -ret;
-                printf ("Healing %s failed:%s.\n", file, strerror(op_errno));
-                goto out;
+            op_errno = -ret;
+            printf("Lookup failed on %s:%s.\n", file, strerror(op_errno));
+            goto out;
+        }
+    } else {
+        if (file[0] != '/') {
+            printf(
+                "<FILE> must be absolute path w.r.t. the "
+                "volume, starting with '/'\n");
+            ret = -1;
+            goto out;
+        }
+        path1 = gf_strdup(file);
+        if (!path1) {
+            printf("Error allocating memory to path\n");
+            ret = -1;
+            goto out;
+        }
+        path2 = gf_strdup(file);
+        if (!path2) {
+            printf("Error allocating memory to path\n");
+            ret = -1;
+            goto out;
+        }
+        path = dirname(path1);
+        filename1 = basename(path2);
+    retry1:
+        ret = glfs_resolve(fs, xl, path, &loc, &iatt, reval);
+        ESTALE_RETRY(ret, errno, reval, &loc, retry1);
+        if (ret) {
+            printf("Lookup failed on %s:%s\n", path, strerror(errno));
+            goto out;
+        }
+        GF_FREE((char *)loc.path);
+        loc.path = gf_strdup(file);
+        if (!loc.path) {
+            printf("Error allocating memory for path\n");
+            ret = -1;
+            goto out;
         }
-        ret = dict_get_str (xattr_rsp, "sh-fail-msg", &sh_fail_msg);
+        loc.parent = inode_unref(loc.parent);
+        loc.parent = inode_ref(loc.inode);
+        loc.inode = inode_unref(loc.inode);
+        loc.inode = inode_new(rootloc->inode->table);
+        if (!loc.inode) {
+            printf("Error getting inode\n");
+            ret = -1;
+            goto out;
+        }
+        loc.name = filename1;
+        gf_uuid_copy(loc.pargfid, loc.gfid);
+        gf_uuid_clear(loc.gfid);
+
+        ret = syncop_lookup(xl, &loc, &iatt, 0, xattr_req, &xattr_rsp);
+        if (ret) {
+            op_errno = -ret;
+            printf("Lookup failed on %s:%s.\n", file, strerror(op_errno));
+            flag = _gf_true;
+        }
+
+        ret = dict_get_str(xattr_rsp, "gfid-heal-msg", &gfid_heal_msg);
         if (!ret) {
-                printf ("Healing %s failed: %s.\n", file, sh_fail_msg);
-                ret = -1;
-                goto out;
+            printf("%s for file %s\n", gfid_heal_msg, file);
+            loc_wipe(&loc);
+            goto out;
         }
-        printf ("Healed %s.\n", file);
-        ret = 0;
+        if (flag)
+            goto out;
+
+        reval = 0;
+        loc_wipe(&loc);
+        memset(&iatt, 0, sizeof(iatt));
+
+    retry2:
+        ret = glfs_resolve(fs, xl, file, &loc, &iatt, reval);
+        ESTALE_RETRY(ret, errno, reval, &loc, retry2);
+        if (ret) {
+            printf("Lookup failed on %s:%s\n", file, strerror(errno));
+            goto out;
+        }
+    }
+
+    if (iatt.ia_type == IA_IFDIR) {
+        ret = _validate_directory(xattr_req, file);
+        if (ret)
+            goto out;
+    }
+    ret = syncop_getxattr(xl, &loc, &xattr_rsp, GF_AFR_HEAL_SBRAIN, xattr_req,
+                          NULL);
+    if (ret) {
+        op_errno = -ret;
+        printf("Healing %s failed:%s.\n", file, strerror(op_errno));
+        goto out;
+    }
+    ret = dict_get_str(xattr_rsp, "sh-fail-msg", &sh_fail_msg);
+    if (!ret) {
+        printf("Healing %s failed: %s.\n", file, sh_fail_msg);
+        ret = -1;
+        goto out;
+    }
+    printf("Healed %s.\n", file);
+    ret = 0;
 out:
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
-        if (path1)
-                GF_FREE (path1);
-        if (path2)
-                GF_FREE (path2);
-        if (filename)
-                GF_FREE (filename);
-        loc_wipe (&loc);
-        return ret;
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
+    if (path1)
+        GF_FREE(path1);
+    if (path2)
+        GF_FREE(path2);
+    if (filename)
+        GF_FREE(filename);
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-glfsh_heal_from_brick_type (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
-                            char *hostname, char *brickpath, xlator_t *client,
-                            dict_t *xattr_req, char *vgfid,
-                            num_entries_t *num_entries)
+glfsh_heal_from_brick_type(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+                           char *hostname, char *brickpath, xlator_t *client,
+                           dict_t *xattr_req, char *vgfid,
+                           num_entries_t *num_entries)
 {
-        fd_t     *fd        = NULL;
-        loc_t     dirloc    = {0};
-        int32_t   op_errno  = 0;
-        int       ret       = -1;
-
-        ret = glfsh_get_index_dir_loc (rootloc, client, &dirloc,
-                                       &op_errno, vgfid);
-        if (ret < 0) {
-                if (op_errno == ESTALE || op_errno == ENOENT)
-                        ret = 0;
-                else
-                        ret = -op_errno;
-                goto out;
-        }
-
-        ret = syncop_dirfd (client, &dirloc, &fd,
-                            GF_CLIENT_PID_GLFS_HEAL);
-        if (ret)
-                goto out;
-        ret = glfsh_crawl_directory (fs, top_subvol, rootloc, client,
-                                     fd, &dirloc, xattr_req, num_entries,
-                                     _gf_false);
-        if (fd)
-                fd_unref (fd);
+    fd_t *fd = NULL;
+    loc_t dirloc = {0};
+    int32_t op_errno = 0;
+    int ret = -1;
+
+    ret = glfsh_get_index_dir_loc(rootloc, client, &dirloc, &op_errno, vgfid);
+    if (ret < 0) {
+        if (op_errno == ESTALE || op_errno == ENOENT)
+            ret = 0;
+        else
+            ret = -op_errno;
+        goto out;
+    }
+
+    ret = syncop_dirfd(client, &dirloc, &fd, GF_CLIENT_PID_GLFS_HEAL);
+    if (ret)
+        goto out;
+    ret = glfsh_crawl_directory(fs, top_subvol, rootloc, client, fd, &dirloc,
+                                xattr_req, num_entries, _gf_false);
+    if (fd)
+        fd_unref(fd);
 out:
-        loc_wipe (&dirloc);
-        return ret;
+    loc_wipe(&dirloc);
+    return ret;
 }
 
 int
-glfsh_heal_from_brick (glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
+glfsh_heal_from_brick(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,
                       char *hostname, char *brickpath, char *file)
 {
-        int       ret       = -1;
-        dict_t   *xattr_req = NULL;
-        xlator_t *client    = NULL;
-        num_entries_t num_entries = {0, };
-        num_entries_t total = {0, };
-
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op",
-                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-        if (ret)
-                goto out;
-        client = _brick_path_to_client_xlator (top_subvol, hostname, brickpath);
-        if (!client) {
-                printf("\"%s:%s\"- No such brick available in the volume.\n",
-                       hostname, brickpath);
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str (xattr_req, "child-name", client->name);
-        if (ret)
-                goto out;
-        if (file)
-                ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                                  xattr_req);
-        else {
-                ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc,
-                                                  hostname, brickpath,
-                                                  client, xattr_req,
-                                                  GF_XATTROP_INDEX_GFID,
-                                                  &num_entries);
-                total.num_entries += num_entries.num_entries;
-                num_entries.num_entries = 0;
-                if (ret == -ENOTCONN)
-                        goto out;
-
-                ret = glfsh_heal_from_brick_type (fs, top_subvol, rootloc,
-                                                  hostname, brickpath,
-                                                  client, xattr_req,
-                                                  GF_XATTROP_DIRTY_GFID,
-                                                  &num_entries);
-                total.num_entries += num_entries.num_entries;
-                if (ret < 0)
-                        goto out;
-        }
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+    xlator_t *client = NULL;
+    num_entries_t num_entries = {
+        0,
+    };
+    num_entries_t total = {
+        0,
+    };
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op",
+                         GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (ret)
+        goto out;
+    client = _brick_path_to_client_xlator(top_subvol, hostname, brickpath);
+    if (!client) {
+        printf("\"%s:%s\"- No such brick available in the volume.\n", hostname,
+               brickpath);
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str(xattr_req, "child-name", client->name);
+    if (ret)
+        goto out;
+    if (file)
+        ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file,
+                                         xattr_req);
+    else {
+        ret = glfsh_heal_from_brick_type(fs, top_subvol, rootloc, hostname,
+                                         brickpath, client, xattr_req,
+                                         GF_XATTROP_INDEX_GFID, &num_entries);
+        total.num_entries += num_entries.num_entries;
+        num_entries.num_entries = 0;
+        if (ret == -ENOTCONN)
+            goto out;
+
+        ret = glfsh_heal_from_brick_type(fs, top_subvol, rootloc, hostname,
+                                         brickpath, client, xattr_req,
+                                         GF_XATTROP_DIRTY_GFID, &num_entries);
+        total.num_entries += num_entries.num_entries;
+        if (ret < 0)
+            goto out;
+    }
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        if (!file)
-                glfsh_print_heal_op_status (ret, total.num_entries,
-                                            GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (xattr_req)
+        dict_unref(xattr_req);
+    if (!file)
+        glfsh_print_heal_op_status(ret, total.num_entries,
+                                   GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
 
-        return ret;
+    return ret;
 }
 
 int
-glfsh_heal_from_bigger_file_or_mtime (glfs_t *fs, xlator_t *top_subvol,
-                                      loc_t *rootloc, char *file,
-                                      gf_xl_afr_op_t heal_op)
+glfsh_heal_from_bigger_file_or_mtime(glfs_t *fs, xlator_t *top_subvol,
+                                     loc_t *rootloc, char *file,
+                                     gf_xl_afr_op_t heal_op)
 {
-
-        int ret = -1;
-        dict_t *xattr_req = NULL;
-
-        xattr_req = dict_new();
-        if (!xattr_req)
-                goto out;
-        ret = dict_set_int32 (xattr_req, "heal-op", heal_op);
-        if (ret)
-                goto out;
-        ret = glfsh_heal_splitbrain_file (fs, top_subvol, rootloc, file,
-                                         xattr_req);
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        goto out;
+    ret = dict_set_int32(xattr_req, "heal-op", heal_op);
+    if (ret)
+        goto out;
+    ret = glfsh_heal_splitbrain_file(fs, top_subvol, rootloc, file, xattr_req);
 out:
-        if (xattr_req)
-                dict_unref (xattr_req);
-        return ret;
+    if (xattr_req)
+        dict_unref(xattr_req);
+    return ret;
 }
 
 static void
-cleanup (glfs_t *fs)
+cleanup(glfs_t *fs)
 {
-        if (!fs)
-                return;
+    if (!fs)
+        return;
 #if 0
         /* glfs fini path is still racy and crashing the program. Since
          * this program any way has to die, we are not going to call fini
@@ -1516,270 +1480,269 @@ cleanup (glfs_t *fs)
 #endif
 }
 
-
 glfsh_info_t glfsh_human_readable = {
-        .init = glfsh_init,
-        .print_brick_from_xl = glfsh_print_brick_from_xl,
-        .print_heal_op_status = glfsh_print_hr_heal_op_status,
-        .print_heal_op_summary = glfsh_print_hr_heal_op_summary,
-        .print_heal_status = glfsh_print_hr_heal_status,
-        .print_spb_status = glfsh_print_hr_spb_status,
-        .end = glfsh_end
-};
+    .init = glfsh_init,
+    .print_brick_from_xl = glfsh_print_brick_from_xl,
+    .print_heal_op_status = glfsh_print_hr_heal_op_status,
+    .print_heal_op_summary = glfsh_print_hr_heal_op_summary,
+    .print_heal_status = glfsh_print_hr_heal_status,
+    .print_spb_status = glfsh_print_hr_spb_status,
+    .end = glfsh_end};
 
 glfsh_info_t glfsh_no_print = {
-        .init = glfsh_init,
-        .print_brick_from_xl = glfsh_no_print_brick_from_xl,
-        .print_heal_op_status = glfsh_no_print_hr_heal_op_status,
-        .print_heal_status = glfsh_no_print_hr_status,
-        .print_spb_status = glfsh_no_print_hr_status,
-        .end = glfsh_end_op_granular_entry_heal
-};
+    .init = glfsh_init,
+    .print_brick_from_xl = glfsh_no_print_brick_from_xl,
+    .print_heal_op_status = glfsh_no_print_hr_heal_op_status,
+    .print_heal_status = glfsh_no_print_hr_status,
+    .print_spb_status = glfsh_no_print_hr_status,
+    .end = glfsh_end_op_granular_entry_heal};
 
 #if (HAVE_LIB_XML)
 glfsh_info_t glfsh_xml_output = {
-        .init = glfsh_xml_init,
-        .print_brick_from_xl = glfsh_print_xml_brick_from_xl,
-        .print_heal_op_status = glfsh_print_xml_heal_op_status,
-        .print_heal_op_summary = glfsh_print_xml_heal_op_summary,
-        .print_heal_status = glfsh_print_xml_file_status,
-        .print_spb_status = glfsh_print_xml_file_status,
-        .end = glfsh_xml_end
-};
+    .init = glfsh_xml_init,
+    .print_brick_from_xl = glfsh_print_xml_brick_from_xl,
+    .print_heal_op_status = glfsh_print_xml_heal_op_status,
+    .print_heal_op_summary = glfsh_print_xml_heal_op_summary,
+    .print_heal_status = glfsh_print_xml_file_status,
+    .print_spb_status = glfsh_print_xml_file_status,
+    .end = glfsh_xml_end};
 #endif
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0;
-        char      *volname = NULL;
-        xlator_t  *top_subvol = NULL;
-        loc_t     rootloc = {0};
-        char      logfilepath[PATH_MAX] = {0};
-        char      *hostname = NULL;
-        char      *path = NULL;
-        char      *file = NULL;
-        char      *op_errstr = NULL;
-        char      *socket_filepath = NULL;
-        gf_xl_afr_op_t heal_op = -1;
-
-        if (argc < 2) {
-                printf (USAGE_STR, argv[0]);
-                ret = -1;
-                goto out;
-        } else if (argc >= 4) {
-                if (!strcmp(argv[argc - 2], "glusterd-sock")) {
-                        socket_filepath = argv[argc - 1];
-                        argc = argc - 2;
-                }
+    glfs_t *fs = NULL;
+    int ret = 0;
+    char *volname = NULL;
+    xlator_t *top_subvol = NULL;
+    loc_t rootloc = {0};
+    char logfilepath[PATH_MAX] = {0};
+    char *hostname = NULL;
+    char *path = NULL;
+    char *file = NULL;
+    char *op_errstr = NULL;
+    char *socket_filepath = NULL;
+    gf_xl_afr_op_t heal_op = -1;
+
+    if (argc < 2) {
+        printf(USAGE_STR, argv[0]);
+        ret = -1;
+        goto out;
+    } else if (argc >= 4) {
+        if (!strcmp(argv[argc - 2], "glusterd-sock")) {
+            socket_filepath = argv[argc - 1];
+            argc = argc - 2;
         }
-        volname = argv[1];
-        switch (argc) {
+    }
+    volname = argv[1];
+    switch (argc) {
         case 2:
-                heal_op = GF_SHD_OP_INDEX_SUMMARY;
-                break;
+            heal_op = GF_SHD_OP_INDEX_SUMMARY;
+            break;
         case 3:
-                if (!strcmp (argv[2], "split-brain-info")) {
-                        heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
-                } else if (!strcmp (argv[2], "xml")) {
-                        heal_op = GF_SHD_OP_INDEX_SUMMARY;
-                        is_xml = 1;
-                } else if (!strcmp (argv[2], "granular-entry-heal-op")) {
-                        heal_op = GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE;
-		} else if (!strcmp (argv[2], "info-summary")) {
-                        heal_op = GF_SHD_OP_HEAL_SUMMARY;
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
+            if (!strcmp(argv[2], "split-brain-info")) {
+                heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
+            } else if (!strcmp(argv[2], "xml")) {
+                heal_op = GF_SHD_OP_INDEX_SUMMARY;
+                is_xml = 1;
+            } else if (!strcmp(argv[2], "granular-entry-heal-op")) {
+                heal_op = GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE;
+            } else if (!strcmp(argv[2], "info-summary")) {
+                heal_op = GF_SHD_OP_HEAL_SUMMARY;
+            } else {
+                printf(USAGE_STR, argv[0]);
+                ret = -1;
+                goto out;
+            }
+            break;
         case 4:
-                if ((!strcmp (argv[2], "split-brain-info")) &&
-                    (!strcmp (argv[3], "xml"))) {
-                        heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
-                        is_xml = 1;
-                } else if ((!strcmp (argv[2], "info-summary")) &&
-                           (!strcmp (argv[3], "xml"))) {
-                        heal_op = GF_SHD_OP_HEAL_SUMMARY;
-                        is_xml = 1;
-                } else if (!strcmp (argv[2], "bigger-file")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE;
-                        file = argv[3];
-                } else if (!strcmp (argv[2], "latest-mtime")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME;
-                        file = argv[3];
-                } else if (!strcmp (argv[2], "source-brick")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
-                        hostname = strtok (argv[3], ":");
-                        path = strtok (NULL, ":");
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
+            if ((!strcmp(argv[2], "split-brain-info")) &&
+                (!strcmp(argv[3], "xml"))) {
+                heal_op = GF_SHD_OP_SPLIT_BRAIN_FILES;
+                is_xml = 1;
+            } else if ((!strcmp(argv[2], "info-summary")) &&
+                       (!strcmp(argv[3], "xml"))) {
+                heal_op = GF_SHD_OP_HEAL_SUMMARY;
+                is_xml = 1;
+            } else if (!strcmp(argv[2], "bigger-file")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE;
+                file = argv[3];
+            } else if (!strcmp(argv[2], "latest-mtime")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME;
+                file = argv[3];
+            } else if (!strcmp(argv[2], "source-brick")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
+                hostname = strtok(argv[3], ":");
+                path = strtok(NULL, ":");
+            } else {
+                printf(USAGE_STR, argv[0]);
+                ret = -1;
+                goto out;
+            }
+            break;
         case 5:
-                if (!strcmp (argv[2], "source-brick")) {
-                        heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
-                        hostname = strtok (argv[3], ":");
-                        path = strtok (NULL, ":");
-                        file = argv[4];
-                } else {
-                        printf (USAGE_STR, argv[0]);
-                        ret = -1;
-                        goto out;
-                }
-                break;
-        default:
-                printf (USAGE_STR, argv[0]);
+            if (!strcmp(argv[2], "source-brick")) {
+                heal_op = GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK;
+                hostname = strtok(argv[3], ":");
+                path = strtok(NULL, ":");
+                file = argv[4];
+            } else {
+                printf(USAGE_STR, argv[0]);
                 ret = -1;
                 goto out;
-        }
+            }
+            break;
+        default:
+            printf(USAGE_STR, argv[0]);
+            ret = -1;
+            goto out;
+    }
 
-        glfsh_output = &glfsh_human_readable;
-        if (is_xml) {
+    glfsh_output = &glfsh_human_readable;
+    if (is_xml) {
 #if (HAVE_LIB_XML)
-                glfsh_output = &glfsh_xml_output;
+        glfsh_output = &glfsh_xml_output;
 #else
-                /*No point doing anything, just fail the command*/
-                exit (EXIT_FAILURE);
+        /*No point doing anything, just fail the command*/
+        exit(EXIT_FAILURE);
 #endif
-
-        }
-
-        if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
-                glfsh_output = &glfsh_no_print;
-
-        ret = glfsh_output->init ();
-        if (ret)
-                exit (EXIT_FAILURE);
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Not able to initialize volume '%s'",
-                             volname);
-                goto out;
-        }
-
-        if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
-                fs->ctx->secure_mgmt = 1;
-                fs->ctx->ssl_cert_depth = glusterfs_read_secure_access_file ();
-        }
-        if (socket_filepath != NULL) {
-                ret = glfs_set_volfile_server (fs, "unix", socket_filepath, 0);
+    }
+
+    if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE)
+        glfsh_output = &glfsh_no_print;
+
+    ret = glfsh_output->init();
+    if (ret)
+        exit(EXIT_FAILURE);
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        ret = -errno;
+        gf_asprintf(&op_errstr, "Not able to initialize volume '%s'", volname);
+        goto out;
+    }
+
+    if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) {
+        fs->ctx->secure_mgmt = 1;
+        fs->ctx->ssl_cert_depth = glusterfs_read_secure_access_file();
+    }
+    if (socket_filepath != NULL) {
+        ret = glfs_set_volfile_server(fs, "unix", socket_filepath, 0);
+    } else {
+        ret = glfs_set_volfile_server(fs, "unix", DEFAULT_GLUSTERD_SOCKFILE, 0);
+    }
+    if (ret) {
+        ret = -errno;
+        gf_asprintf(&op_errstr,
+                    "Setting the volfile server failed, "
+                    "%s",
+                    strerror(errno));
+        goto out;
+    }
+
+    ret = glfsh_set_heal_options(fs, heal_op);
+    if (ret) {
+        printf("Setting xlator heal options failed, %s\n", strerror(errno));
+        goto out;
+    }
+    snprintf(logfilepath, sizeof(logfilepath),
+             DEFAULT_HEAL_LOG_FILE_DIRECTORY "/glfsheal-%s.log", volname);
+    ret = glfs_set_logging(fs, logfilepath, GF_LOG_INFO);
+    if (ret < 0) {
+        ret = -errno;
+        gf_asprintf(&op_errstr,
+                    "Failed to set the log file path, "
+                    "%s",
+                    strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        ret = -errno;
+        if (errno == ENOENT) {
+            gf_asprintf(&op_errstr, "Volume %s does not exist", volname);
         } else {
-                ret = glfs_set_volfile_server (fs, "unix",
-                                DEFAULT_GLUSTERD_SOCKFILE, 0);
+            gf_asprintf(&op_errstr,
+                        "%s: Not able to fetch "
+                        "volfile from glusterd",
+                        volname);
         }
-        if (ret) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Setting the volfile server failed, "
-                             "%s", strerror (errno));
-                goto out;
-        }
-
-        ret = glfsh_set_heal_options (fs, heal_op);
-        if (ret) {
-                printf ("Setting xlator heal options failed, %s\n",
-                        strerror(errno));
-                goto out;
-        }
-        snprintf (logfilepath, sizeof (logfilepath),
-                  DEFAULT_HEAL_LOG_FILE_DIRECTORY"/glfsheal-%s.log", volname);
-        ret = glfs_set_logging(fs, logfilepath, GF_LOG_INFO);
-        if (ret < 0) {
-                ret = -errno;
-                gf_asprintf (&op_errstr, "Failed to set the log file path, "
-                             "%s", strerror (errno));
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                ret = -errno;
-                if (errno == ENOENT) {
-                        gf_asprintf (&op_errstr, "Volume %s does not exist",
-                                     volname);
-                } else {
-                        gf_asprintf (&op_errstr, "%s: Not able to fetch "
-                                     "volfile from glusterd", volname);
-                }
-                goto out;
-        }
-
-        top_subvol = glfs_active_subvol (fs);
-        if (!top_subvol) {
-                ret = -errno;
-                if (errno == ENOTCONN) {
-                        gf_asprintf (&op_errstr, "Volume %s is not started "
-                                                 "(Or) All the bricks are not "
-                                                 "running.", volname);
-                }
-                else {
-                        gf_asprintf (&op_errstr, "%s: Not able to mount the "
-                                             "volume, %s", volname,
-                                             strerror (errno));
-                }
-                goto out;
-        }
-
-        ret = glfsh_validate_volume (top_subvol, heal_op);
-        if (ret < 0) {
-                ret = -EINVAL;
-                gf_asprintf (&op_errstr, "Volume %s is not of type %s", volname,
-                                     (heal_op == GF_SHD_OP_INDEX_SUMMARY ||
-                                      heal_op == GF_SHD_OP_HEAL_SUMMARY) ?
-                                     "replicate/disperse":"replicate");
-                goto out;
-        }
-        rootloc.inode = inode_ref (top_subvol->itable->root);
-        ret = glfs_loc_touchup (&rootloc);
-        if (ret < 0) {
-                ret = -errno;
-                goto out;
+        goto out;
+    }
+
+    top_subvol = glfs_active_subvol(fs);
+    if (!top_subvol) {
+        ret = -errno;
+        if (errno == ENOTCONN) {
+            gf_asprintf(&op_errstr,
+                        "Volume %s is not started "
+                        "(Or) All the bricks are not "
+                        "running.",
+                        volname);
+        } else {
+            gf_asprintf(&op_errstr,
+                        "%s: Not able to mount the "
+                        "volume, %s",
+                        volname, strerror(errno));
         }
-
-        switch (heal_op) {
+        goto out;
+    }
+
+    ret = glfsh_validate_volume(top_subvol, heal_op);
+    if (ret < 0) {
+        ret = -EINVAL;
+        gf_asprintf(&op_errstr, "Volume %s is not of type %s", volname,
+                    (heal_op == GF_SHD_OP_INDEX_SUMMARY ||
+                     heal_op == GF_SHD_OP_HEAL_SUMMARY)
+                        ? "replicate/disperse"
+                        : "replicate");
+        goto out;
+    }
+    rootloc.inode = inode_ref(top_subvol->itable->root);
+    ret = glfs_loc_touchup(&rootloc);
+    if (ret < 0) {
+        ret = -errno;
+        goto out;
+    }
+
+    switch (heal_op) {
         case GF_SHD_OP_INDEX_SUMMARY:
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
         case GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE:
         case GF_SHD_OP_HEAL_SUMMARY:
-                ret = glfsh_gather_heal_info (fs, top_subvol, &rootloc,
-                                              heal_op);
-                break;
+            ret = glfsh_gather_heal_info(fs, top_subvol, &rootloc, heal_op);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                ret = glfsh_heal_from_bigger_file_or_mtime (fs, top_subvol,
-                                                   &rootloc, file, heal_op);
-                        break;
+            ret = glfsh_heal_from_bigger_file_or_mtime(fs, top_subvol, &rootloc,
+                                                       file, heal_op);
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = glfsh_heal_from_brick (fs, top_subvol, &rootloc,
-                                             hostname, path, file);
-                break;
+            ret = glfsh_heal_from_brick(fs, top_subvol, &rootloc, hostname,
+                                        path, file);
+            break;
         default:
-                ret = -EINVAL;
-                break;
-        }
-
-        glfsh_output->end (ret, NULL);
-        if (ret < 0)
-                ret = -ret;
-        loc_wipe (&rootloc);
-        glfs_subvol_done (fs, top_subvol);
-        cleanup (fs);
-
-        return ret;
+            ret = -EINVAL;
+            break;
+    }
+
+    glfsh_output->end(ret, NULL);
+    if (ret < 0)
+        ret = -ret;
+    loc_wipe(&rootloc);
+    glfs_subvol_done(fs, top_subvol);
+    cleanup(fs);
+
+    return ret;
 out:
-        if (fs && top_subvol)
-                glfs_subvol_done (fs, top_subvol);
-        loc_wipe (&rootloc);
-        cleanup (fs);
-        if (glfsh_output)
-                glfsh_output->end (ret, op_errstr);
-        if (op_errstr)
-                GF_FREE (op_errstr);
-        return ret;
+    if (fs && top_subvol)
+        glfs_subvol_done(fs, top_subvol);
+    loc_wipe(&rootloc);
+    cleanup(fs);
+    if (glfsh_output)
+        glfsh_output->end(ret, op_errstr);
+    if (op_errstr)
+        GF_FREE(op_errstr);
+    return ret;
 }
diff --git a/libglusterfs/src/atomic.h b/libglusterfs/src/atomic.h
index 3fd3a8764bf..dbbdc309628 100644
--- a/libglusterfs/src/atomic.h
+++ b/libglusterfs/src/atomic.h
@@ -114,10 +114,14 @@ GF_ATOMIC_TYPE(SIZEOF_LONG, uintptr); /* gf_atomic_uintptr_t */
  * builtin version depending on the size of the atomic structure. */
 #define GF_ATOMIC_CHOOSE(_atomic, _op, _args...)                               \
     ((sizeof(_atomic) > sizeof(uint64_t))                                      \
-         ? ({ GF_ATOMIC_MACRO(GF_ATOMIC_LOCK_, _op)                            \
-              (_atomic, ##_args); })      \
-         : ({ GF_ATOMIC_MACRO(GF_ATOMIC_BASE_, _op)                            \
-              (_atomic, ##_args); }))
+         ? ({                                                                  \
+               GF_ATOMIC_MACRO(GF_ATOMIC_LOCK_, _op)                           \
+               (_atomic, ##_args);                                             \
+           })                                                                  \
+         : ({                                                                  \
+               GF_ATOMIC_MACRO(GF_ATOMIC_BASE_, _op)                           \
+               (_atomic, ##_args);                                             \
+           }))
 
 /* Macros to implement the mutex-based atomics. */
 #define GF_ATOMIC_OP_PREPARE(_atomic, _name)                                   \
diff --git a/libglusterfs/src/call-stub.c b/libglusterfs/src/call-stub.c
index a1b87bf5db2..7e2713fa384 100644
--- a/libglusterfs/src/call-stub.c
+++ b/libglusterfs/src/call-stub.c
@@ -16,2754 +16,2557 @@
 #include "libglusterfs-messages.h"
 
 static call_stub_t *
-stub_new (call_frame_t *frame,
-          char wind,
-          glusterfs_fop_t fop)
+stub_new(call_frame_t *frame, char wind, glusterfs_fop_t fop)
 {
-        call_stub_t *new = NULL;
+    call_stub_t *new = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        new = mem_get0 (frame->this->ctx->stub_mem_pool);
-        GF_VALIDATE_OR_GOTO ("call-stub", new, out);
+    new = mem_get0(frame->this->ctx->stub_mem_pool);
+    GF_VALIDATE_OR_GOTO("call-stub", new, out);
 
-        new->frame = frame;
-        new->wind = wind;
-        new->fop = fop;
-        new->stub_mem_pool = frame->this->ctx->stub_mem_pool;
-        INIT_LIST_HEAD (&new->list);
+    new->frame = frame;
+    new->wind = wind;
+    new->fop = fop;
+    new->stub_mem_pool = frame->this->ctx->stub_mem_pool;
+    INIT_LIST_HEAD(&new->list);
 
-        INIT_LIST_HEAD (&new->args_cbk.entries);
+    INIT_LIST_HEAD(&new->args_cbk.entries);
 out:
-        return new;
+    return new;
 }
 
-
 call_stub_t *
-fop_lookup_stub (call_frame_t *frame, fop_lookup_t fn, loc_t *loc,
-                 dict_t *xdata)
+fop_lookup_stub(call_frame_t *frame, fop_lookup_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LOOKUP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LOOKUP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lookup = fn;
-        args_lookup_store (&stub->args, loc, xdata);
+    stub->fn.lookup = fn;
+    args_lookup_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lookup_cbk_stub (call_frame_t *frame, fop_lookup_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     inode_t *inode, struct iatt *buf,
-                     dict_t *xdata, struct iatt *postparent)
+fop_lookup_cbk_stub(call_frame_t *frame, fop_lookup_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, inode_t *inode, struct iatt *buf,
+                    dict_t *xdata, struct iatt *postparent)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LOOKUP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LOOKUP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.lookup = fn;
-        args_lookup_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                               buf, xdata, postparent);
+    stub->fn_cbk.lookup = fn;
+    args_lookup_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf, xdata,
+                          postparent);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_stat_stub (call_frame_t *frame, fop_stat_t fn,
-               loc_t *loc, dict_t *xdata)
+fop_stat_stub(call_frame_t *frame, fop_stat_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_STAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_STAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.stat = fn;
-        args_stat_store (&stub->args, loc, xdata);
+    stub->fn.stat = fn;
+    args_stat_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_stat_cbk_stub (call_frame_t *frame, fop_stat_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   struct iatt *buf, dict_t *xdata)
+fop_stat_cbk_stub(call_frame_t *frame, fop_stat_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_STAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_STAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.stat = fn;
-        args_stat_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                             xdata);
+    stub->fn_cbk.stat = fn;
+    args_stat_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fstat_stub (call_frame_t *frame, fop_fstat_t fn,
-                fd_t *fd, dict_t *xdata)
+fop_fstat_stub(call_frame_t *frame, fop_fstat_t fn, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSTAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSTAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fstat = fn;
-        args_fstat_store (&stub->args, fd, xdata);
+    stub->fn.fstat = fn;
+    args_fstat_store(&stub->args, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fstat_cbk_stub (call_frame_t *frame, fop_fstat_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *buf, dict_t *xdata)
+fop_fstat_cbk_stub(call_frame_t *frame, fop_fstat_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSTAT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSTAT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fstat = fn;
-        args_fstat_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                              xdata);
+    stub->fn_cbk.fstat = fn;
+    args_fstat_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_truncate_stub (call_frame_t *frame, fop_truncate_t fn,
-                   loc_t *loc, off_t off, dict_t *xdata)
+fop_truncate_stub(call_frame_t *frame, fop_truncate_t fn, loc_t *loc, off_t off,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_TRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_TRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.truncate = fn;
-        args_truncate_store (&stub->args, loc, off, xdata);
+    stub->fn.truncate = fn;
+    args_truncate_store(&stub->args, loc, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_truncate_cbk_stub (call_frame_t *frame, fop_truncate_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-		       struct iatt *postbuf, dict_t *xdata)
+fop_truncate_cbk_stub(call_frame_t *frame, fop_truncate_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_TRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_TRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.truncate = fn;
-        args_truncate_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                 prebuf, postbuf, xdata);
+    stub->fn_cbk.truncate = fn;
+    args_truncate_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_ftruncate_stub (call_frame_t *frame, fop_ftruncate_t fn,
-                    fd_t *fd, off_t off, dict_t *xdata)
+fop_ftruncate_stub(call_frame_t *frame, fop_ftruncate_t fn, fd_t *fd, off_t off,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FTRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FTRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.ftruncate = fn;
-        args_ftruncate_store (&stub->args, fd, off, xdata);
+    stub->fn.ftruncate = fn;
+    args_ftruncate_store(&stub->args, fd, off, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_ftruncate_cbk_stub (call_frame_t *frame, fop_ftruncate_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-			struct iatt *postbuf, dict_t *xdata)
+fop_ftruncate_cbk_stub(call_frame_t *frame, fop_ftruncate_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FTRUNCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FTRUNCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.ftruncate = fn;
-        args_ftruncate_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                  prebuf, postbuf, xdata);
+    stub->fn_cbk.ftruncate = fn;
+    args_ftruncate_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                             xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_access_stub (call_frame_t *frame, fop_access_t fn,
-                 loc_t *loc, int32_t mask, dict_t *xdata)
+fop_access_stub(call_frame_t *frame, fop_access_t fn, loc_t *loc, int32_t mask,
+                dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ACCESS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_ACCESS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.access = fn;
-        args_access_store (&stub->args, loc, mask, xdata);
+    stub->fn.access = fn;
+    args_access_store(&stub->args, loc, mask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_access_cbk_stub (call_frame_t *frame, fop_access_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_access_cbk_stub(call_frame_t *frame, fop_access_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ACCESS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_ACCESS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.access = fn;
-        args_access_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.access = fn;
+    args_access_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readlink_stub (call_frame_t *frame, fop_readlink_t fn,
-                   loc_t *loc, size_t size, dict_t *xdata)
+fop_readlink_stub(call_frame_t *frame, fop_readlink_t fn, loc_t *loc,
+                  size_t size, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_READLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readlink = fn;
-        args_readlink_store (&stub->args, loc, size, xdata);
+    stub->fn.readlink = fn;
+    args_readlink_store(&stub->args, loc, size, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readlink_cbk_stub (call_frame_t *frame, fop_readlink_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       const char *path, struct iatt *stbuf, dict_t *xdata)
+fop_readlink_cbk_stub(call_frame_t *frame, fop_readlink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, const char *path,
+                      struct iatt *stbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_READLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_READLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readlink = fn;
-        args_readlink_cbk_store (&stub->args_cbk, op_ret, op_errno, path,
-                                 stbuf, xdata);
+    stub->fn_cbk.readlink = fn;
+    args_readlink_cbk_store(&stub->args_cbk, op_ret, op_errno, path, stbuf,
+                            xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mknod_stub (call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
-                dev_t rdev, mode_t umask, dict_t *xdata)
+fop_mknod_stub(call_frame_t *frame, fop_mknod_t fn, loc_t *loc, mode_t mode,
+               dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_MKNOD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_MKNOD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.mknod = fn;
-        args_mknod_store (&stub->args, loc, mode, rdev, umask, xdata);
+    stub->fn.mknod = fn;
+    args_mknod_store(&stub->args, loc, mode, rdev, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mknod_cbk_stub (call_frame_t *frame, fop_mknod_cbk_t fn, int32_t op_ret,
-                    int32_t op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-		    dict_t *xdata)
+fop_mknod_cbk_stub(call_frame_t *frame, fop_mknod_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_MKNOD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_MKNOD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.mknod = fn;
-        args_mknod_cbk_store (&stub->args_cbk, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
+    stub->fn_cbk.mknod = fn;
+    args_mknod_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                         preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mkdir_stub (call_frame_t *frame, fop_mkdir_t fn,
-                loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata)
+fop_mkdir_stub(call_frame_t *frame, fop_mkdir_t fn, loc_t *loc, mode_t mode,
+               mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_MKDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_MKDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.mkdir = fn;
-        args_mkdir_store (&stub->args, loc, mode, umask, xdata);
+    stub->fn.mkdir = fn;
+    args_mkdir_store(&stub->args, loc, mode, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_mkdir_cbk_stub (call_frame_t *frame, fop_mkdir_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+fop_mkdir_cbk_stub(call_frame_t *frame, fop_mkdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, inode_t *inode, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_MKDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_MKDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.mkdir = fn;
-        args_mkdir_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                              buf, preparent, postparent, xdata);
+    stub->fn_cbk.mkdir = fn;
+    args_mkdir_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                         preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_unlink_stub (call_frame_t *frame, fop_unlink_t fn,
-                 loc_t *loc, int xflag, dict_t *xdata)
+fop_unlink_stub(call_frame_t *frame, fop_unlink_t fn, loc_t *loc, int xflag,
+                dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_UNLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_UNLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.unlink = fn;
-        args_unlink_store (&stub->args, loc, xflag, xdata);
+    stub->fn.unlink = fn;
+    args_unlink_store(&stub->args, loc, xflag, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_unlink_cbk_stub (call_frame_t *frame, fop_unlink_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preparent, struct iatt *postparent,
-		     dict_t *xdata)
+fop_unlink_cbk_stub(call_frame_t *frame, fop_unlink_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_UNLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_UNLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.unlink = fn;
-        args_unlink_cbk_store (&stub->args_cbk, op_ret, op_errno, preparent,
-                               postparent, xdata);
+    stub->fn_cbk.unlink = fn;
+    args_unlink_cbk_store(&stub->args_cbk, op_ret, op_errno, preparent,
+                          postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
-
 call_stub_t *
-fop_rmdir_stub (call_frame_t *frame, fop_rmdir_t fn,
-                loc_t *loc, int flags, dict_t *xdata)
+fop_rmdir_stub(call_frame_t *frame, fop_rmdir_t fn, loc_t *loc, int flags,
+               dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RMDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RMDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rmdir = fn;
-        args_rmdir_store (&stub->args, loc, flags, xdata);
+    stub->fn.rmdir = fn;
+    args_rmdir_store(&stub->args, loc, flags, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rmdir_cbk_stub (call_frame_t *frame, fop_rmdir_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preparent, struct iatt *postparent,
-		    dict_t *xdata)
+fop_rmdir_cbk_stub(call_frame_t *frame, fop_rmdir_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_RMDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_RMDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.rmdir = fn;
-        args_rmdir_cbk_store (&stub->args_cbk, op_ret, op_errno, preparent,
-                              postparent, xdata);
+    stub->fn_cbk.rmdir = fn;
+    args_rmdir_cbk_store(&stub->args_cbk, op_ret, op_errno, preparent,
+                         postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_symlink_stub (call_frame_t *frame, fop_symlink_t fn,
-                  const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata)
+fop_symlink_stub(call_frame_t *frame, fop_symlink_t fn, const char *linkname,
+                 loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", linkname, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", linkname, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SYMLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SYMLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.symlink = fn;
-        args_symlink_store (&stub->args, linkname, loc, umask, xdata);
+    stub->fn.symlink = fn;
+    args_symlink_store(&stub->args, linkname, loc, umask, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_symlink_cbk_stub (call_frame_t *frame, fop_symlink_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-		      dict_t *xdata)
+fop_symlink_cbk_stub(call_frame_t *frame, fop_symlink_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SYMLINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SYMLINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.symlink = fn;
-        args_symlink_cbk_store (&stub->args_cbk, op_ret, op_errno, inode, buf,
-                                preparent, postparent, xdata);
+    stub->fn_cbk.symlink = fn;
+    args_symlink_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                           preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rename_stub (call_frame_t *frame, fop_rename_t fn,
-                 loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+fop_rename_stub(call_frame_t *frame, fop_rename_t fn, loc_t *oldloc,
+                loc_t *newloc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", newloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", oldloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", newloc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RENAME);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RENAME);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rename = fn;
-        args_rename_store (&stub->args, oldloc, newloc, xdata);
+    stub->fn.rename = fn;
+    args_rename_store(&stub->args, oldloc, newloc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rename_cbk_stub (call_frame_t *frame, fop_rename_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-		     dict_t *xdata)
+fop_rename_cbk_stub(call_frame_t *frame, fop_rename_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *buf,
+                    struct iatt *preoldparent, struct iatt *postoldparent,
+                    struct iatt *prenewparent, struct iatt *postnewparent,
+                    dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_RENAME);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_RENAME);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.rename = fn;
-        args_rename_cbk_store (&stub->args_cbk, op_ret, op_errno, buf,
-                               preoldparent, postoldparent, prenewparent,
-                               postnewparent, xdata);
+    stub->fn_cbk.rename = fn;
+    args_rename_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, preoldparent,
+                          postoldparent, prenewparent, postnewparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_link_stub (call_frame_t *frame, fop_link_t fn,
-               loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+fop_link_stub(call_frame_t *frame, fop_link_t fn, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", newloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", oldloc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", newloc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.link = fn;
-        args_link_store (&stub->args, oldloc, newloc, xdata);
+    stub->fn.link = fn;
+    args_link_store(&stub->args, oldloc, newloc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_link_cbk_stub (call_frame_t *frame, fop_link_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   inode_t *inode, struct iatt *buf,
-                   struct iatt *preparent, struct iatt *postparent,
-		   dict_t *xdata)
+fop_link_cbk_stub(call_frame_t *frame, fop_link_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, inode_t *inode, struct iatt *buf,
+                  struct iatt *preparent, struct iatt *postparent,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.link = fn;
-        args_link_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                             inode, buf, preparent, postparent, xdata);
+    stub->fn_cbk.link = fn;
+    args_link_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                        preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_create_stub (call_frame_t *frame, fop_create_t fn,
-                 loc_t *loc, int32_t flags, mode_t mode,
-                 mode_t umask, fd_t *fd, dict_t *xdata)
+fop_create_stub(call_frame_t *frame, fop_create_t fn, loc_t *loc, int32_t flags,
+                mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_CREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_CREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.create = fn;
-        args_create_store (&stub->args, loc, flags, mode,
-                           umask, fd, xdata);
+    stub->fn.create = fn;
+    args_create_store(&stub->args, loc, flags, mode, umask, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_create_cbk_stub (call_frame_t *frame, fop_create_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-		     dict_t *xdata)
+fop_create_cbk_stub(call_frame_t *frame, fop_create_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, fd_t *fd, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_CREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_CREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.create = fn;
-        args_create_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, inode,
-                               buf, preparent, postparent, xdata);
+    stub->fn_cbk.create = fn;
+    args_create_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, inode, buf,
+                          preparent, postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_open_stub (call_frame_t *frame, fop_open_t fn,
-               loc_t *loc, int32_t flags, fd_t *fd, dict_t *xdata)
+fop_open_stub(call_frame_t *frame, fop_open_t fn, loc_t *loc, int32_t flags,
+              fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_OPEN);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_OPEN);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.open = fn;
-        args_open_store (&stub->args, loc, flags, fd, xdata);
+    stub->fn.open = fn;
+    args_open_store(&stub->args, loc, flags, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_open_cbk_stub (call_frame_t *frame, fop_open_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno,
-                   fd_t *fd, dict_t *xdata)
+fop_open_cbk_stub(call_frame_t *frame, fop_open_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_OPEN);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_OPEN);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.open = fn;
-        args_open_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, xdata);
+    stub->fn_cbk.open = fn;
+    args_open_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readv_stub (call_frame_t *frame, fop_readv_t fn,
-                fd_t *fd, size_t size, off_t off, uint32_t flags,
-		dict_t *xdata)
+fop_readv_stub(call_frame_t *frame, fop_readv_t fn, fd_t *fd, size_t size,
+               off_t off, uint32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_READ);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READ);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readv = fn;
-        args_readv_store (&stub->args, fd, size, off, flags, xdata);
+    stub->fn.readv = fn;
+    args_readv_store(&stub->args, fd, size, off, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readv_cbk_stub (call_frame_t *frame, fop_readv_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-		    int32_t count, struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata)
+fop_readv_cbk_stub(call_frame_t *frame, fop_readv_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iovec *vector, int32_t count,
+                   struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_READ);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_READ);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readv = fn;
-        args_readv_cbk_store (&stub->args_cbk, op_ret, op_errno, vector,
-                              count, stbuf, iobref, xdata);
+    stub->fn_cbk.readv = fn;
+    args_readv_cbk_store(&stub->args_cbk, op_ret, op_errno, vector, count,
+                         stbuf, iobref, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_writev_stub (call_frame_t *frame, fop_writev_t fn,
-                 fd_t *fd, struct iovec *vector, int32_t count, off_t off,
-		 uint32_t flags, struct iobref *iobref, dict_t *xdata)
+fop_writev_stub(call_frame_t *frame, fop_writev_t fn, fd_t *fd,
+                struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+                struct iobref *iobref, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", vector, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", vector, out);
 
-        stub = stub_new (frame, 1, GF_FOP_WRITE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_WRITE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.writev = fn;
-        args_writev_store (&stub->args, fd, vector, count, off, flags,
-                           iobref, xdata);
+    stub->fn.writev = fn;
+    args_writev_store(&stub->args, fd, vector, count, off, flags, iobref,
+                      xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_writev_cbk_stub (call_frame_t *frame, fop_writev_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+fop_writev_cbk_stub(call_frame_t *frame, fop_writev_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                    dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_WRITE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_WRITE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.writev = fn;
-        args_writev_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                               prebuf, postbuf, xdata);
+    stub->fn_cbk.writev = fn;
+    args_writev_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                          xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_flush_stub (call_frame_t *frame, fop_flush_t fn,
-                fd_t *fd, dict_t *xdata)
+fop_flush_stub(call_frame_t *frame, fop_flush_t fn, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FLUSH);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FLUSH);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.flush = fn;
-        args_flush_store (&stub->args, fd, xdata);
+    stub->fn.flush = fn;
+    args_flush_store(&stub->args, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_flush_cbk_stub (call_frame_t *frame, fop_flush_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_flush_cbk_stub(call_frame_t *frame, fop_flush_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FLUSH);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FLUSH);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.flush = fn;
-        args_flush_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.flush = fn;
+    args_flush_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsync_stub (call_frame_t *frame, fop_fsync_t fn,
-                fd_t *fd, int32_t datasync, dict_t *xdata)
+fop_fsync_stub(call_frame_t *frame, fop_fsync_t fn, fd_t *fd, int32_t datasync,
+               dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSYNC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSYNC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsync = fn;
-        args_fsync_store (&stub->args, fd, datasync, xdata);
+    stub->fn.fsync = fn;
+    args_fsync_store(&stub->args, fd, datasync, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsync_cbk_stub (call_frame_t *frame, fop_fsync_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+fop_fsync_cbk_stub(call_frame_t *frame, fop_fsync_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                   dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSYNC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSYNC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsync = fn;
-        args_fsync_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                              prebuf, postbuf, xdata);
+    stub->fn_cbk.fsync = fn;
+    args_fsync_cbk_store(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                         xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_opendir_stub (call_frame_t *frame, fop_opendir_t fn,
-                  loc_t *loc, fd_t *fd, dict_t *xdata)
+fop_opendir_stub(call_frame_t *frame, fop_opendir_t fn, loc_t *loc, fd_t *fd,
+                 dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_OPENDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_OPENDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.opendir = fn;
-        args_opendir_store (&stub->args, loc, fd, xdata);
+    stub->fn.opendir = fn;
+    args_opendir_store(&stub->args, loc, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_opendir_cbk_stub (call_frame_t *frame, fop_opendir_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      fd_t *fd, dict_t *xdata)
+fop_opendir_cbk_stub(call_frame_t *frame, fop_opendir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_OPENDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_OPENDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.opendir = fn;
-        args_opendir_cbk_store (&stub->args_cbk, op_ret, op_errno, fd, xdata);
+    stub->fn_cbk.opendir = fn;
+    args_opendir_cbk_store(&stub->args_cbk, op_ret, op_errno, fd, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsyncdir_stub (call_frame_t *frame, fop_fsyncdir_t fn,
-                   fd_t *fd, int32_t datasync, dict_t *xdata)
+fop_fsyncdir_stub(call_frame_t *frame, fop_fsyncdir_t fn, fd_t *fd,
+                  int32_t datasync, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSYNCDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSYNCDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsyncdir = fn;
-        args_fsyncdir_store (&stub->args, fd, datasync, xdata);
+    stub->fn.fsyncdir = fn;
+    args_fsyncdir_store(&stub->args, fd, datasync, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsyncdir_cbk_stub (call_frame_t *frame, fop_fsyncdir_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fsyncdir_cbk_stub(call_frame_t *frame, fop_fsyncdir_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSYNCDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSYNCDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsyncdir = fn;
-        args_fsyncdir_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fsyncdir = fn;
+    args_fsyncdir_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_statfs_stub (call_frame_t *frame, fop_statfs_t fn,
-                 loc_t *loc, dict_t *xdata)
+fop_statfs_stub(call_frame_t *frame, fop_statfs_t fn, loc_t *loc, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_STATFS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_STATFS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.statfs = fn;
-        args_statfs_store (&stub->args, loc, xdata);
+    stub->fn.statfs = fn;
+    args_statfs_store(&stub->args, loc, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_statfs_cbk_stub (call_frame_t *frame, fop_statfs_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct statvfs *buf, dict_t *xdata)
+fop_statfs_cbk_stub(call_frame_t *frame, fop_statfs_cbk_t fn, int32_t op_ret,
+                    int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_STATFS);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_STATFS);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.statfs = fn;
-        args_statfs_cbk_store (&stub->args_cbk, op_ret, op_errno, buf, xdata);
+    stub->fn_cbk.statfs = fn;
+    args_statfs_cbk_store(&stub->args_cbk, op_ret, op_errno, buf, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setxattr_stub (call_frame_t *frame, fop_setxattr_t fn,
-                   loc_t *loc, dict_t *dict,
-                   int32_t flags, dict_t *xdata)
+fop_setxattr_stub(call_frame_t *frame, fop_setxattr_t fn, loc_t *loc,
+                  dict_t *dict, int32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.setxattr = fn;
-        args_setxattr_store (&stub->args, loc, dict, flags, xdata);
+    stub->fn.setxattr = fn;
+    args_setxattr_store(&stub->args, loc, dict, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setxattr_cbk_stub (call_frame_t *frame,
-                       fop_setxattr_cbk_t fn,
-                       int32_t op_ret,
-                       int32_t op_errno, dict_t *xdata)
+fop_setxattr_cbk_stub(call_frame_t *frame, fop_setxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.setxattr = fn;
-        args_setxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.setxattr = fn;
+    args_setxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getxattr_stub (call_frame_t *frame, fop_getxattr_t fn,
-                   loc_t *loc, const char *name, dict_t *xdata)
+fop_getxattr_stub(call_frame_t *frame, fop_getxattr_t fn, loc_t *loc,
+                  const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
 
-        stub = stub_new (frame, 1, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.getxattr = fn;
-        args_getxattr_store (&stub->args, loc, name, xdata);
+    stub->fn.getxattr = fn;
+    args_getxattr_store(&stub->args, loc, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getxattr_cbk_stub (call_frame_t *frame, fop_getxattr_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata)
+fop_getxattr_cbk_stub(call_frame_t *frame, fop_getxattr_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.getxattr = fn;
-        args_getxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, dict,
-                                 xdata);
+    stub->fn_cbk.getxattr = fn;
+    args_getxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, dict, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetxattr_stub (call_frame_t *frame, fop_fsetxattr_t fn,
-                    fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+fop_fsetxattr_stub(call_frame_t *frame, fop_fsetxattr_t fn, fd_t *fd,
+                   dict_t *dict, int32_t flags, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetxattr = fn;
-        args_fsetxattr_store (&stub->args, fd, dict, flags, xdata);
+    stub->fn.fsetxattr = fn;
+    args_fsetxattr_store(&stub->args, fd, dict, flags, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetxattr_cbk_stub (call_frame_t *frame, fop_fsetxattr_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fsetxattr_cbk_stub(call_frame_t *frame, fop_fsetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsetxattr = fn;
-        args_fsetxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fsetxattr = fn;
+    args_fsetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fgetxattr_stub (call_frame_t *frame, fop_fgetxattr_t fn,
-                    fd_t *fd, const char *name, dict_t *xdata)
+fop_fgetxattr_stub(call_frame_t *frame, fop_fgetxattr_t fn, fd_t *fd,
+                   const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FGETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FGETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fgetxattr = fn;
-        args_fgetxattr_store (&stub->args, fd, name, xdata);
+    stub->fn.fgetxattr = fn;
+    args_fgetxattr_store(&stub->args, fd, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fgetxattr_cbk_stub (call_frame_t *frame, fop_fgetxattr_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+fop_fgetxattr_cbk_stub(call_frame_t *frame, fop_fgetxattr_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_GETXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_GETXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fgetxattr = fn;
-        args_fgetxattr_cbk_store (&stub->args_cbk, op_ret, op_errno, dict,
-                                  xdata);
+    stub->fn_cbk.fgetxattr = fn;
+    args_fgetxattr_cbk_store(&stub->args_cbk, op_ret, op_errno, dict, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_removexattr_stub (call_frame_t *frame, fop_removexattr_t fn,
-                      loc_t *loc, const char *name, dict_t *xdata)
+fop_removexattr_stub(call_frame_t *frame, fop_removexattr_t fn, loc_t *loc,
+                     const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", loc, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", name, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", loc, out);
+    GF_VALIDATE_OR_GOTO("call-stub", name, out);
 
-        stub = stub_new (frame, 1, GF_FOP_REMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_REMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.removexattr = fn;
-        args_removexattr_store (&stub->args, loc, name, xdata);
+    stub->fn.removexattr = fn;
+    args_removexattr_store(&stub->args, loc, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_removexattr_cbk_stub (call_frame_t *frame, fop_removexattr_cbk_t fn,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_removexattr_cbk_stub(call_frame_t *frame, fop_removexattr_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_REMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_REMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.removexattr = fn;
-        args_removexattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.removexattr = fn;
+    args_removexattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fremovexattr_stub (call_frame_t *frame, fop_fremovexattr_t fn,
-                       fd_t *fd, const char *name, dict_t *xdata)
+fop_fremovexattr_stub(call_frame_t *frame, fop_fremovexattr_t fn, fd_t *fd,
+                      const char *name, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", name, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", name, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FREMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FREMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fremovexattr = fn;
-        args_fremovexattr_store (&stub->args, fd, name, xdata);
+    stub->fn.fremovexattr = fn;
+    args_fremovexattr_store(&stub->args, fd, name, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fremovexattr_cbk_stub (call_frame_t *frame, fop_fremovexattr_cbk_t fn,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fremovexattr_cbk_stub(call_frame_t *frame, fop_fremovexattr_cbk_t fn,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FREMOVEXATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FREMOVEXATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fremovexattr = fn;
-        args_fremovexattr_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fremovexattr = fn;
+    args_fremovexattr_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lk_stub (call_frame_t *frame, fop_lk_t fn,
-             fd_t *fd, int32_t cmd,
-             struct gf_flock *lock, dict_t *xdata)
+fop_lk_stub(call_frame_t *frame, fop_lk_t fn, fd_t *fd, int32_t cmd,
+            struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lk = fn;
-        args_lk_store (&stub->args, fd, cmd, lock, xdata);
+    stub->fn.lk = fn;
+    args_lk_store(&stub->args, fd, cmd, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_lk_cbk_stub (call_frame_t *frame, fop_lk_cbk_t fn,
-                 int32_t op_ret, int32_t op_errno,
-                 struct gf_flock *lock, dict_t *xdata)
+fop_lk_cbk_stub(call_frame_t *frame, fop_lk_cbk_t fn, int32_t op_ret,
+                int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.lk = fn;
-        args_lk_cbk_store (&stub->args_cbk, op_ret, op_errno, lock, xdata);
+    stub->fn_cbk.lk = fn;
+    args_lk_cbk_store(&stub->args_cbk, op_ret, op_errno, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_inodelk_stub (call_frame_t *frame, fop_inodelk_t fn,
-                  const char *volume, loc_t *loc, int32_t cmd,
-                  struct gf_flock *lock, dict_t *xdata)
+fop_inodelk_stub(call_frame_t *frame, fop_inodelk_t fn, const char *volume,
+                 loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        stub = stub_new (frame, 1, GF_FOP_INODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_INODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.inodelk = fn;
-        args_inodelk_store (&stub->args, volume, loc, cmd,
-                            lock, xdata);
+    stub->fn.inodelk = fn;
+    args_inodelk_store(&stub->args, volume, loc, cmd, lock, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_inodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_inodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_INODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_INODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.inodelk       = fn;
-        args_inodelk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.inodelk = fn;
+    args_inodelk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_finodelk_stub (call_frame_t *frame, fop_finodelk_t fn,
-                   const char *volume, fd_t *fd, int32_t cmd,
-                   struct gf_flock *lock, dict_t *xdata)
+fop_finodelk_stub(call_frame_t *frame, fop_finodelk_t fn, const char *volume,
+                  fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lock, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lock, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FINODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FINODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.finodelk = fn;
-        args_finodelk_store (&stub->args, volume, fd, cmd,
-                             lock, xdata);
+    stub->fn.finodelk = fn;
+    args_finodelk_store(&stub->args, volume, fd, cmd, lock, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_finodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_finodelk_cbk_stub(call_frame_t *frame, fop_inodelk_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FINODELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FINODELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.finodelk       = fn;
-        args_finodelk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.finodelk = fn;
+    args_finodelk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_entrylk_stub (call_frame_t *frame, fop_entrylk_t fn,
-                  const char *volume, loc_t *loc, const char *name,
-                  entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+fop_entrylk_stub(call_frame_t *frame, fop_entrylk_t fn, const char *volume,
+                 loc_t *loc, const char *name, entrylk_cmd cmd,
+                 entrylk_type type, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_ENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.entrylk = fn;
-        args_entrylk_store (&stub->args, volume, loc, name, cmd, type, xdata);
+    stub->fn.entrylk = fn;
+    args_entrylk_store(&stub->args, volume, loc, name, cmd, type, xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_entrylk_cbk_stub (call_frame_t *frame, fop_entrylk_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_entrylk_cbk_stub(call_frame_t *frame, fop_entrylk_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_ENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.entrylk       = fn;
-        args_entrylk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.entrylk = fn;
+    args_entrylk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fentrylk_stub (call_frame_t *frame, fop_fentrylk_t fn,
-                   const char *volume, fd_t *fd, const char *name,
-                   entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+fop_fentrylk_stub(call_frame_t *frame, fop_fentrylk_t fn, const char *volume,
+                  fd_t *fd, const char *name, entrylk_cmd cmd,
+                  entrylk_type type, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fentrylk = fn;
-        args_fentrylk_store (&stub->args, volume, fd, name, cmd, type, xdata);
+    stub->fn.fentrylk = fn;
+    args_fentrylk_store(&stub->args, volume, fd, name, cmd, type, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fentrylk_cbk_stub (call_frame_t *frame, fop_fentrylk_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_fentrylk_cbk_stub(call_frame_t *frame, fop_fentrylk_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FENTRYLK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FENTRYLK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fentrylk       = fn;
-        args_fentrylk_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    stub->fn_cbk.fentrylk = fn;
+    args_fentrylk_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdirp_cbk_stub (call_frame_t *frame, fop_readdirp_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata)
+fop_readdirp_cbk_stub(call_frame_t *frame, fop_readdirp_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_READDIRP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_READDIRP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readdirp = fn;
-        args_readdirp_cbk_store (&stub->args_cbk, op_ret, op_errno, entries,
-                                 xdata);
+    stub->fn_cbk.readdirp = fn;
+    args_readdirp_cbk_store(&stub->args_cbk, op_ret, op_errno, entries, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdir_cbk_stub (call_frame_t *frame, fop_readdir_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      gf_dirent_t *entries, dict_t *xdata)
+fop_readdir_cbk_stub(call_frame_t *frame, fop_readdir_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_READDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.readdir = fn;
-        args_readdir_cbk_store (&stub->args_cbk, op_ret, op_errno, entries,
-                                xdata);
+    stub->fn_cbk.readdir = fn;
+    args_readdir_cbk_store(&stub->args_cbk, op_ret, op_errno, entries, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdir_stub (call_frame_t *frame, fop_readdir_t fn,
-                  fd_t *fd, size_t size,
-                  off_t off, dict_t *xdata)
+fop_readdir_stub(call_frame_t *frame, fop_readdir_t fn, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_READDIR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READDIR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readdir = fn;
-        args_readdir_store (&stub->args, fd, size, off, xdata);
+    stub->fn.readdir = fn;
+    args_readdir_store(&stub->args, fd, size, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_readdirp_stub (call_frame_t *frame, fop_readdirp_t fn,
-                   fd_t *fd, size_t size, off_t off, dict_t *xdata)
+fop_readdirp_stub(call_frame_t *frame, fop_readdirp_t fn, fd_t *fd, size_t size,
+                  off_t off, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        stub = stub_new (frame, 1, GF_FOP_READDIRP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_READDIRP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.readdirp = fn;
-        args_readdirp_store (&stub->args, fd, size, off, xdata);
+    stub->fn.readdirp = fn;
+    args_readdirp_store(&stub->args, fd, size, off, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rchecksum_stub (call_frame_t *frame, fop_rchecksum_t fn,
-                    fd_t *fd, off_t offset, int32_t len, dict_t *xdata)
+fop_rchecksum_stub(call_frame_t *frame, fop_rchecksum_t fn, fd_t *fd,
+                   off_t offset, int32_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fd, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fd, out);
 
-        stub = stub_new (frame, 1, GF_FOP_RCHECKSUM);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_RCHECKSUM);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.rchecksum = fn;
-        args_rchecksum_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.rchecksum = fn;
+    args_rchecksum_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_rchecksum_cbk_stub (call_frame_t *frame, fop_rchecksum_cbk_t fn,
-                        int32_t op_ret, int32_t op_errno,
-                        uint32_t weak_checksum, uint8_t *strong_checksum,
-			dict_t *xdata)
+fop_rchecksum_cbk_stub(call_frame_t *frame, fop_rchecksum_cbk_t fn,
+                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                       uint8_t *strong_checksum, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_RCHECKSUM);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_RCHECKSUM);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.rchecksum = fn;
-        args_rchecksum_cbk_store (&stub->args_cbk, op_ret, op_errno,
-                                  weak_checksum, strong_checksum, xdata);
+    stub->fn_cbk.rchecksum = fn;
+    args_rchecksum_cbk_store(&stub->args_cbk, op_ret, op_errno, weak_checksum,
+                             strong_checksum, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_xattrop_cbk_stub (call_frame_t *frame, fop_xattrop_cbk_t fn, int32_t op_ret,
-                      int32_t op_errno, dict_t *xattr, dict_t *xdata)
+fop_xattrop_cbk_stub(call_frame_t *frame, fop_xattrop_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_XATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_XATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.xattrop       = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                xdata);
+    stub->fn_cbk.xattrop = fn;
+    args_xattrop_cbk_store(&stub->args_cbk, op_ret, op_errno, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fxattrop_cbk_stub (call_frame_t *frame, fop_fxattrop_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+fop_fxattrop_cbk_stub(call_frame_t *frame, fop_fxattrop_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                      dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    call_stub_t *stub = NULL;
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FXATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FXATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fxattrop = fn;
-        args_xattrop_cbk_store (&stub->args_cbk, op_ret, op_errno, xattr,
-                                xdata);
+    stub->fn_cbk.fxattrop = fn;
+    args_xattrop_cbk_store(&stub->args_cbk, op_ret, op_errno, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_xattrop_stub (call_frame_t *frame, fop_xattrop_t fn,
-                  loc_t *loc, gf_xattrop_flags_t optype,
-                  dict_t *xattr, dict_t *xdata)
+fop_xattrop_stub(call_frame_t *frame, fop_xattrop_t fn, loc_t *loc,
+                 gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", xattr, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_XATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_XATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.xattrop = fn;
-        args_xattrop_store (&stub->args, loc, optype, xattr, xdata);
+    stub->fn.xattrop = fn;
+    args_xattrop_store(&stub->args, loc, optype, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fxattrop_stub (call_frame_t *frame, fop_fxattrop_t fn,
-                   fd_t *fd, gf_xattrop_flags_t optype,
-                   dict_t *xattr, dict_t *xdata)
+fop_fxattrop_stub(call_frame_t *frame, fop_fxattrop_t fn, fd_t *fd,
+                  gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", xattr, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", xattr, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FXATTROP);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FXATTROP);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fxattrop = fn;
-        args_fxattrop_store (&stub->args, fd, optype, xattr, xdata);
+    stub->fn.fxattrop = fn;
+    args_fxattrop_store(&stub->args, fd, optype, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setattr_cbk_stub (call_frame_t *frame, fop_setattr_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt *statpre, struct iatt *statpost,
-		      dict_t *xdata)
+fop_setattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.setattr = fn;
-        args_setattr_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                statpost, xdata);
+    stub->fn_cbk.setattr = fn;
+    args_setattr_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre, statpost,
+                           xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetattr_cbk_stub (call_frame_t *frame, fop_setattr_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-		       dict_t *xdata)
+fop_fsetattr_cbk_stub(call_frame_t *frame, fop_setattr_cbk_t fn, int32_t op_ret,
+                      int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FSETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fsetattr = fn;
-        args_fsetattr_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                 statpost, xdata);
+    stub->fn_cbk.fsetattr = fn;
+    args_fsetattr_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_setattr_stub (call_frame_t *frame, fop_setattr_t fn,
-                  loc_t *loc, struct iatt *stbuf,
-                  int32_t valid, dict_t *xdata)
+fop_setattr_stub(call_frame_t *frame, fop_setattr_t fn, loc_t *loc,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.setattr = fn;
-        args_setattr_store (&stub->args, loc, stbuf, valid, xdata);
+    stub->fn.setattr = fn;
+    args_setattr_store(&stub->args, loc, stbuf, valid, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_fsetattr_stub (call_frame_t *frame, fop_fsetattr_t fn,
-                   fd_t *fd, struct iatt *stbuf,
-                   int32_t valid, dict_t *xdata)
+fop_fsetattr_stub(call_frame_t *frame, fop_fsetattr_t fn, fd_t *fd,
+                  struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FSETATTR);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FSETATTR);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fsetattr = fn;
-        args_fsetattr_store (&stub->args, fd, stbuf, valid, xdata);
+    stub->fn.fsetattr = fn;
+    args_fsetattr_store(&stub->args, fd, stbuf, valid, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
 fop_fallocate_cbk_stub(call_frame_t *frame, fop_fallocate_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-		       dict_t *xdata)
+                       int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_FALLOCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.fallocate = fn;
+    stub->fn_cbk.fallocate = fn;
 
-        args_fallocate_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                  statpost, xdata);
+    args_fallocate_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                             statpost, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
 fop_fallocate_stub(call_frame_t *frame, fop_fallocate_t fn, fd_t *fd,
-		   int32_t mode, off_t offset, size_t len, dict_t *xdata)
+                   int32_t mode, off_t offset, size_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_FALLOCATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_FALLOCATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.fallocate = fn;
-        args_fallocate_store (&stub->args, fd, mode, offset, len, xdata);
+    stub->fn.fallocate = fn;
+    args_fallocate_store(&stub->args, fd, mode, offset, len, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_discard_cbk_stub(call_frame_t *frame, fop_discard_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-		     dict_t *xdata)
+fop_discard_cbk_stub(call_frame_t *frame, fop_discard_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, struct iatt *statpre,
+                     struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_DISCARD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_DISCARD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.discard = fn;
+    stub->fn_cbk.discard = fn;
 
-        args_discard_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                statpost, xdata);
+    args_discard_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre, statpost,
+                           xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd,
-		 off_t offset, size_t len, dict_t *xdata)
+fop_discard_stub(call_frame_t *frame, fop_discard_t fn, fd_t *fd, off_t offset,
+                 size_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_DISCARD);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_DISCARD);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.discard = fn;
-        args_discard_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.discard = fn;
+    args_discard_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
 fop_zerofill_cbk_stub(call_frame_t *frame, fop_zerofill_cbk_t fn,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                      struct iatt *statpost, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ZEROFILL);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_ZEROFILL);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.zerofill = fn;
+    stub->fn_cbk.zerofill = fn;
 
-        args_zerofill_cbk_store (&stub->args_cbk, op_ret, op_errno, statpre,
-                                 statpost, xdata);
+    args_zerofill_cbk_store(&stub->args_cbk, op_ret, op_errno, statpre,
+                            statpost, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
 fop_zerofill_stub(call_frame_t *frame, fop_zerofill_t fn, fd_t *fd,
-                 off_t offset, off_t len, dict_t *xdata)
+                  off_t offset, off_t len, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ZEROFILL);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_ZEROFILL);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.zerofill = fn;
-        args_zerofill_store (&stub->args, fd, offset, len, xdata);
+    stub->fn.zerofill = fn;
+    args_zerofill_store(&stub->args, fd, offset, len, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
-
 call_stub_t *
-fop_ipc_cbk_stub (call_frame_t *frame, fop_ipc_cbk_t fn,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_ipc_cbk_stub(call_frame_t *frame, fop_ipc_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_IPC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_IPC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.ipc = fn;
+    stub->fn_cbk.ipc = fn;
 
-        args_ipc_cbk_store (&stub->args_cbk, op_ret, op_errno, xdata);
+    args_ipc_cbk_store(&stub->args_cbk, op_ret, op_errno, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_ipc_stub (call_frame_t *frame, fop_ipc_t fn,
-              int32_t op, dict_t *xdata)
+fop_ipc_stub(call_frame_t *frame, fop_ipc_t fn, int32_t op, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_IPC);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_IPC);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.ipc = fn;
-        args_ipc_store (&stub->args, op, xdata);
+    stub->fn.ipc = fn;
+    args_ipc_store(&stub->args, op, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_lease_cbk_stub (call_frame_t *frame, fop_lease_cbk_t fn,
-                    int32_t op_ret, int32_t op_errno,
-                    struct gf_lease *lease, dict_t *xdata)
+fop_lease_cbk_stub(call_frame_t *frame, fop_lease_cbk_t fn, int32_t op_ret,
+                   int32_t op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_LEASE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.lease = fn;
-        args_lease_cbk_store (&stub->args_cbk, op_ret, op_errno, lease, xdata);
+    stub->fn_cbk.lease = fn;
+    args_lease_cbk_store(&stub->args_cbk, op_ret, op_errno, lease, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_lease_stub (call_frame_t *frame, fop_lease_t fn,
-                loc_t *loc, struct gf_lease *lease, dict_t *xdata)
+fop_lease_stub(call_frame_t *frame, fop_lease_t fn, loc_t *loc,
+               struct gf_lease *lease, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", lease, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", lease, out);
 
-        stub = stub_new (frame, 1, GF_FOP_LEASE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_LEASE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.lease = fn;
-        args_lease_store (&stub->args, loc, lease, xdata);
+    stub->fn.lease = fn;
+    args_lease_store(&stub->args, loc, lease, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_seek_cbk_stub (call_frame_t *frame, fop_seek_cbk_t fn,
-                   int32_t op_ret, int32_t op_errno, off_t offset,
-                   dict_t *xdata)
+fop_seek_cbk_stub(call_frame_t *frame, fop_seek_cbk_t fn, int32_t op_ret,
+                  int32_t op_errno, off_t offset, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.seek = fn;
+    stub->fn_cbk.seek = fn;
 
-        args_seek_cbk_store (&stub->args_cbk, op_ret, op_errno, offset, xdata);
+    args_seek_cbk_store(&stub->args_cbk, op_ret, op_errno, offset, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_seek_stub (call_frame_t *frame, fop_seek_t fn, fd_t *fd,
-               off_t offset, gf_seek_what_t what, dict_t *xdata)
+fop_seek_stub(call_frame_t *frame, fop_seek_t fn, fd_t *fd, off_t offset,
+              gf_seek_what_t what, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SEEK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SEEK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.seek = fn;
-        args_seek_store (&stub->args, fd, offset, what, xdata);
+    stub->fn.seek = fn;
+    args_seek_store(&stub->args, fd, offset, what, xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_getactivelk_cbk_stub (call_frame_t *frame, fop_getactivelk_cbk_t fn,
-                          int32_t op_ret, int32_t op_errno,
-                          lock_migration_info_t *lmi, dict_t *xdata)
+fop_getactivelk_cbk_stub(call_frame_t *frame, fop_getactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno,
+                         lock_migration_info_t *lmi, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_GETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_GETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.getactivelk = fn;
+    stub->fn_cbk.getactivelk = fn;
 
-        args_getactivelk_cbk_store (&stub->args_cbk, op_ret, op_errno, lmi,
-                                    xdata);
+    args_getactivelk_cbk_store(&stub->args_cbk, op_ret, op_errno, lmi, xdata);
 out:
-        return stub;
+    return stub;
 }
 
-
 call_stub_t *
-fop_getactivelk_stub (call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
-                      dict_t *xdata)
+fop_getactivelk_stub(call_frame_t *frame, fop_getactivelk_t fn, loc_t *loc,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_GETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_GETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.getactivelk = fn;
+    stub->fn.getactivelk = fn;
 
-        loc_copy (&stub->args.loc, loc);
+    loc_copy(&stub->args.loc, loc);
 
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_setactivelk_cbk_stub (call_frame_t *frame, fop_setactivelk_cbk_t fn,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fop_setactivelk_cbk_stub(call_frame_t *frame, fop_setactivelk_cbk_t fn,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_SETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_SETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.setactivelk = fn;
-        stub->args_cbk.op_ret = op_ret;
-        stub->args_cbk.op_errno = op_errno;
+    stub->fn_cbk.setactivelk = fn;
+    stub->args_cbk.op_ret = op_ret;
+    stub->args_cbk.op_errno = op_errno;
 
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_setactivelk_stub (call_frame_t *frame, fop_setactivelk_t fn,
-                        loc_t *loc, lock_migration_info_t *locklist,
-                        dict_t *xdata)
+fop_setactivelk_stub(call_frame_t *frame, fop_setactivelk_t fn, loc_t *loc,
+                     lock_migration_info_t *locklist, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_SETACTIVELK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_SETACTIVELK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.setactivelk = fn;
+    stub->fn.setactivelk = fn;
 
-        args_setactivelk_store (&stub->args, loc, locklist, xdata);
+    args_setactivelk_store(&stub->args, loc, locklist, xdata);
 
 out:
-        return stub;
-
+    return stub;
 }
 
 call_stub_t *
-fop_put_stub (call_frame_t *frame, fop_put_t fn,
-              loc_t *loc, mode_t mode, mode_t umask, uint32_t flags,
-              struct iovec *vector, int32_t count, off_t offset,
-              struct iobref *iobref, dict_t *xattr, dict_t *xdata)
+fop_put_stub(call_frame_t *frame, fop_put_t fn, loc_t *loc, mode_t mode,
+             mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+             off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", vector, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", vector, out);
 
-        stub = stub_new (frame, 1, GF_FOP_PUT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_PUT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.put = fn;
-        args_put_store (&stub->args, loc, mode, umask, flags, vector,
-                        count, offset, iobref, xattr, xdata);
+    stub->fn.put = fn;
+    args_put_store(&stub->args, loc, mode, umask, flags, vector, count, offset,
+                   iobref, xattr, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_put_cbk_stub (call_frame_t *frame, fop_put_cbk_t fn,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+fop_put_cbk_stub(call_frame_t *frame, fop_put_cbk_t fn, int32_t op_ret,
+                 int32_t op_errno, inode_t *inode, struct iatt *buf,
+                 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_PUT);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_PUT);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.put = fn;
-        args_put_cbk_store (&stub->args_cbk, op_ret, op_errno, inode,
-                            buf, preparent, postparent, xdata);
+    stub->fn_cbk.put = fn;
+    args_put_cbk_store(&stub->args_cbk, op_ret, op_errno, inode, buf, preparent,
+                       postparent, xdata);
 out:
-        return stub;
+    return stub;
 }
 
 call_stub_t *
-fop_icreate_stub (call_frame_t *frame, fop_icreate_t fn,
-                  loc_t *loc, mode_t mode, dict_t *xdata)
+fop_icreate_stub(call_frame_t *frame, fop_icreate_t fn, loc_t *loc, mode_t mode,
+                 dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_ICREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_ICREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.icreate = fn;
+    stub->fn.icreate = fn;
 
-        stub->args.mode = mode;
-        if (loc)
-                loc_copy (&stub->args.loc, loc);
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    stub->args.mode = mode;
+    if (loc)
+        loc_copy(&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
- out:
-        return stub;
+out:
+    return stub;
 }
 
 static void
-args_icreate_store_cbk (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        inode_t *inode, struct iatt *buf, dict_t *xdata)
+args_icreate_store_cbk(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, inode_t *inode, struct iatt *buf,
+                       dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 }
 
 call_stub_t *
-fop_icreate_cbk_stub (call_frame_t *frame,
-                      fop_icreate_cbk_t fn,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf, dict_t *xdata)
+fop_icreate_cbk_stub(call_frame_t *frame, fop_icreate_cbk_t fn, int32_t op_ret,
+                     int32_t op_errno, inode_t *inode, struct iatt *buf,
+                     dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_ICREATE);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_ICREATE);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.icreate = fn;
-        args_icreate_store_cbk (&stub->args_cbk,
-                                op_ret, op_errno, inode, buf, xdata);
+    stub->fn_cbk.icreate = fn;
+    args_icreate_store_cbk(&stub->args_cbk, op_ret, op_errno, inode, buf,
+                           xdata);
 
- out:
-        return stub;
+out:
+    return stub;
 }
 
 call_stub_t *
-fop_namelink_stub (call_frame_t *frame,
-                   fop_namelink_t fn, loc_t *loc, dict_t *xdata)
+fop_namelink_stub(call_frame_t *frame, fop_namelink_t fn, loc_t *loc,
+                  dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
-        GF_VALIDATE_OR_GOTO ("call-stub", fn, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", fn, out);
 
-        stub = stub_new (frame, 1, GF_FOP_NAMELINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 1, GF_FOP_NAMELINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn.namelink = fn;
+    stub->fn.namelink = fn;
 
-        if (loc)
-                loc_copy (&stub->args.loc, loc);
-        if (xdata)
-                stub->args.xdata = dict_ref (xdata);
+    if (loc)
+        loc_copy(&stub->args.loc, loc);
+    if (xdata)
+        stub->args.xdata = dict_ref(xdata);
 
- out:
-        return stub;
+out:
+    return stub;
 }
 
 static void
-args_namelink_store_cbk (default_args_cbk_t *args,
-                         int32_t op_ret, int32_t op_errno,
-                         struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+args_namelink_store_cbk(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
 
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 }
 
 call_stub_t *
-fop_namelink_cbk_stub (call_frame_t *frame,
-                       fop_namelink_cbk_t fn,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+fop_namelink_cbk_stub(call_frame_t *frame, fop_namelink_cbk_t fn,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        call_stub_t *stub = NULL;
+    call_stub_t *stub = NULL;
 
-        GF_VALIDATE_OR_GOTO ("call-stub", frame, out);
+    GF_VALIDATE_OR_GOTO("call-stub", frame, out);
 
-        stub = stub_new (frame, 0, GF_FOP_NAMELINK);
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    stub = stub_new(frame, 0, GF_FOP_NAMELINK);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        stub->fn_cbk.namelink = fn;
-        args_namelink_store_cbk (&stub->args_cbk,
-                                 op_ret, op_errno, prebuf, postbuf, xdata);
+    stub->fn_cbk.namelink = fn;
+    args_namelink_store_cbk(&stub->args_cbk, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
 
- out:
-        return stub;
+out:
+    return stub;
 }
 
 void
-call_resume_wind (call_stub_t *stub)
+call_resume_wind(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        switch (stub->fop) {
+    switch (stub->fop) {
         case GF_FOP_OPEN:
-                stub->fn.open (stub->frame, stub->frame->this,
-			       &stub->args.loc, stub->args.flags,
-			       stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.open(stub->frame, stub->frame->this, &stub->args.loc,
+                          stub->args.flags, stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_CREATE:
-                stub->fn.create (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.flags,
-				 stub->args.mode, stub->args.umask,
-				 stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.create(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.flags, stub->args.mode, stub->args.umask,
+                            stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_STAT:
-                stub->fn.stat (stub->frame, stub->frame->this,
-			       &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.stat(stub->frame, stub->frame->this, &stub->args.loc,
+                          stub->args.xdata);
+            break;
         case GF_FOP_READLINK:
-                stub->fn.readlink (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.size,
-				   stub->args.xdata);
-                break;
+            stub->fn.readlink(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.size, stub->args.xdata);
+            break;
         case GF_FOP_MKNOD:
-                stub->fn.mknod (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.mode,
-				stub->args.rdev, stub->args.umask,
-				stub->args.xdata);
-		break;
+            stub->fn.mknod(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.mode, stub->args.rdev, stub->args.umask,
+                           stub->args.xdata);
+            break;
         case GF_FOP_MKDIR:
-                stub->fn.mkdir (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.mode,
-				stub->args.umask, stub->args.xdata);
-		break;
+            stub->fn.mkdir(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.mode, stub->args.umask, stub->args.xdata);
+            break;
         case GF_FOP_UNLINK:
-                stub->fn.unlink (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xflag,
-				 stub->args.xdata);
-		break;
+            stub->fn.unlink(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xflag, stub->args.xdata);
+            break;
         case GF_FOP_RMDIR:
-                stub->fn.rmdir (stub->frame, stub->frame->this,
-				&stub->args.loc, stub->args.flags,
-				stub->args.xdata);
-		break;
+            stub->fn.rmdir(stub->frame, stub->frame->this, &stub->args.loc,
+                           stub->args.flags, stub->args.xdata);
+            break;
         case GF_FOP_SYMLINK:
-                stub->fn.symlink (stub->frame, stub->frame->this,
-				  stub->args.linkname, &stub->args.loc,
-				  stub->args.umask, stub->args.xdata);
-		break;
+            stub->fn.symlink(stub->frame, stub->frame->this,
+                             stub->args.linkname, &stub->args.loc,
+                             stub->args.umask, stub->args.xdata);
+            break;
         case GF_FOP_RENAME:
-                stub->fn.rename (stub->frame, stub->frame->this,
-				 &stub->args.loc, &stub->args.loc2,
-				 stub->args.xdata);
-		break;
+            stub->fn.rename(stub->frame, stub->frame->this, &stub->args.loc,
+                            &stub->args.loc2, stub->args.xdata);
+            break;
         case GF_FOP_LINK:
-                stub->fn.link (stub->frame, stub->frame->this,
-			       &stub->args.loc, &stub->args.loc2,
-			       stub->args.xdata);
-		break;
+            stub->fn.link(stub->frame, stub->frame->this, &stub->args.loc,
+                          &stub->args.loc2, stub->args.xdata);
+            break;
         case GF_FOP_TRUNCATE:
-                stub->fn.truncate (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.offset,
-				   stub->args.xdata);
-                break;
+            stub->fn.truncate(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.offset, stub->args.xdata);
+            break;
         case GF_FOP_READ:
-                stub->fn.readv (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.size,
-				stub->args.offset, stub->args.flags,
-				stub->args.xdata);
-                break;
+            stub->fn.readv(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.size, stub->args.offset, stub->args.flags,
+                           stub->args.xdata);
+            break;
         case GF_FOP_WRITE:
-                stub->fn.writev (stub->frame, stub->frame->this,
-				 stub->args.fd, stub->args.vector,
-				 stub->args.count, stub->args.offset,
-				 stub->args.flags, stub->args.iobref,
-				 stub->args.xdata);
-                break;
+            stub->fn.writev(stub->frame, stub->frame->this, stub->args.fd,
+                            stub->args.vector, stub->args.count,
+                            stub->args.offset, stub->args.flags,
+                            stub->args.iobref, stub->args.xdata);
+            break;
         case GF_FOP_STATFS:
-                stub->fn.statfs (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.statfs(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xdata);
+            break;
         case GF_FOP_FLUSH:
-                stub->fn.flush (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.flush(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.xdata);
+            break;
         case GF_FOP_FSYNC:
-                stub->fn.fsync (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.datasync,
-				stub->args.xdata);
-                break;
+            stub->fn.fsync(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.datasync, stub->args.xdata);
+            break;
         case GF_FOP_SETXATTR:
-                stub->fn.setxattr (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.xattr,
-				   stub->args.flags, stub->args.xdata);
-                break;
+            stub->fn.setxattr(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.xattr, stub->args.flags,
+                              stub->args.xdata);
+            break;
         case GF_FOP_GETXATTR:
-                stub->fn.getxattr (stub->frame, stub->frame->this,
-				   &stub->args.loc, stub->args.name,
-				   stub->args.xdata);
-                break;
+            stub->fn.getxattr(stub->frame, stub->frame->this, &stub->args.loc,
+                              stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_FSETXATTR:
-                stub->fn.fsetxattr (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.xattr,
-				    stub->args.flags, stub->args.xdata);
-                break;
+            stub->fn.fsetxattr(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.xattr, stub->args.flags,
+                               stub->args.xdata);
+            break;
         case GF_FOP_FGETXATTR:
-                stub->fn.fgetxattr (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.name,
-				    stub->args.xdata);
-                break;
+            stub->fn.fgetxattr(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_REMOVEXATTR:
-                stub->fn.removexattr (stub->frame, stub->frame->this,
-				      &stub->args.loc, stub->args.name,
-				      stub->args.xdata);
-                break;
+            stub->fn.removexattr(stub->frame, stub->frame->this,
+                                 &stub->args.loc, stub->args.name,
+                                 stub->args.xdata);
+            break;
         case GF_FOP_FREMOVEXATTR:
-                stub->fn.fremovexattr (stub->frame, stub->frame->this,
-				       stub->args.fd, stub->args.name,
-				       stub->args.xdata);
-                break;
+            stub->fn.fremovexattr(stub->frame, stub->frame->this, stub->args.fd,
+                                  stub->args.name, stub->args.xdata);
+            break;
         case GF_FOP_OPENDIR:
-                stub->fn.opendir (stub->frame, stub->frame->this,
-				  &stub->args.loc, stub->args.fd,
-				  stub->args.xdata);
-                break;
+            stub->fn.opendir(stub->frame, stub->frame->this, &stub->args.loc,
+                             stub->args.fd, stub->args.xdata);
+            break;
         case GF_FOP_FSYNCDIR:
-                stub->fn.fsyncdir (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.datasync,
-				   stub->args.xdata);
-                break;
+            stub->fn.fsyncdir(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.datasync, stub->args.xdata);
+            break;
         case GF_FOP_ACCESS:
-                stub->fn.access (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.mask,
-				 stub->args.xdata);
-                break;
+            stub->fn.access(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.mask, stub->args.xdata);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                stub->fn.ftruncate (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.offset,
-				    stub->args.xdata);
-                break;
+            stub->fn.ftruncate(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.offset, stub->args.xdata);
+            break;
         case GF_FOP_FSTAT:
-                stub->fn.fstat (stub->frame, stub->frame->this,
-				stub->args.fd, stub->args.xdata);
-                break;
+            stub->fn.fstat(stub->frame, stub->frame->this, stub->args.fd,
+                           stub->args.xdata);
+            break;
         case GF_FOP_LK:
-                stub->fn.lk (stub->frame, stub->frame->this,
-			     stub->args.fd, stub->args.cmd,
-			     &stub->args.lock, stub->args.xdata);
-                break;
+            stub->fn.lk(stub->frame, stub->frame->this, stub->args.fd,
+                        stub->args.cmd, &stub->args.lock, stub->args.xdata);
+            break;
         case GF_FOP_INODELK:
-                stub->fn.inodelk (stub->frame, stub->frame->this,
-				  stub->args.volume, &stub->args.loc,
-				  stub->args.cmd, &stub->args.lock,
-				  stub->args.xdata);
-                break;
+            stub->fn.inodelk(stub->frame, stub->frame->this, stub->args.volume,
+                             &stub->args.loc, stub->args.cmd, &stub->args.lock,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FINODELK:
-                stub->fn.finodelk (stub->frame, stub->frame->this,
-				   stub->args.volume, stub->args.fd,
-				   stub->args.cmd, &stub->args.lock,
-				   stub->args.xdata);
-                break;
+            stub->fn.finodelk(stub->frame, stub->frame->this, stub->args.volume,
+                              stub->args.fd, stub->args.cmd, &stub->args.lock,
+                              stub->args.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                stub->fn.entrylk (stub->frame, stub->frame->this,
-				  stub->args.volume, &stub->args.loc,
-				  stub->args.name, stub->args.entrylkcmd,
-				  stub->args.entrylktype, stub->args.xdata);
-                break;
+            stub->fn.entrylk(stub->frame, stub->frame->this, stub->args.volume,
+                             &stub->args.loc, stub->args.name,
+                             stub->args.entrylkcmd, stub->args.entrylktype,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                stub->fn.fentrylk (stub->frame, stub->frame->this,
-				   stub->args.volume, stub->args.fd,
-				   stub->args.name, stub->args.entrylkcmd,
-				   stub->args.entrylktype, stub->args.xdata);
-		break;
+            stub->fn.fentrylk(stub->frame, stub->frame->this, stub->args.volume,
+                              stub->args.fd, stub->args.name,
+                              stub->args.entrylkcmd, stub->args.entrylktype,
+                              stub->args.xdata);
+            break;
         case GF_FOP_LOOKUP:
-                stub->fn.lookup (stub->frame, stub->frame->this,
-				 &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.lookup(stub->frame, stub->frame->this, &stub->args.loc,
+                            stub->args.xdata);
+            break;
         case GF_FOP_RCHECKSUM:
-                stub->fn.rchecksum (stub->frame, stub->frame->this,
-				    stub->args.fd, stub->args.offset,
-				    stub->args.size, stub->args.xdata);
-                break;
+            stub->fn.rchecksum(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.offset, stub->args.size,
+                               stub->args.xdata);
+            break;
         case GF_FOP_READDIR:
-                stub->fn.readdir (stub->frame, stub->frame->this,
-				  stub->args.fd, stub->args.size,
-				  stub->args.offset, stub->args.xdata);
-                break;
+            stub->fn.readdir(stub->frame, stub->frame->this, stub->args.fd,
+                             stub->args.size, stub->args.offset,
+                             stub->args.xdata);
+            break;
         case GF_FOP_READDIRP:
-                stub->fn.readdirp (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.size,
-				   stub->args.offset, stub->args.xdata);
-                break;
+            stub->fn.readdirp(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.size, stub->args.offset,
+                              stub->args.xdata);
+            break;
         case GF_FOP_XATTROP:
-                stub->fn.xattrop (stub->frame, stub->frame->this,
-				  &stub->args.loc, stub->args.optype,
-				  stub->args.xattr, stub->args.xdata);
-                break;
+            stub->fn.xattrop(stub->frame, stub->frame->this, &stub->args.loc,
+                             stub->args.optype, stub->args.xattr,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FXATTROP:
-                stub->fn.fxattrop (stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.optype,
-				   stub->args.xattr, stub->args.xdata);
-                break;
+            stub->fn.fxattrop(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.optype, stub->args.xattr,
+                              stub->args.xdata);
+            break;
         case GF_FOP_SETATTR:
-                stub->fn.setattr (stub->frame, stub->frame->this,
-				  &stub->args.loc, &stub->args.stat,
-				  stub->args.valid, stub->args.xdata);
-                break;
+            stub->fn.setattr(stub->frame, stub->frame->this, &stub->args.loc,
+                             &stub->args.stat, stub->args.valid,
+                             stub->args.xdata);
+            break;
         case GF_FOP_FSETATTR:
-                stub->fn.fsetattr (stub->frame, stub->frame->this,
-				   stub->args.fd, &stub->args.stat,
-				   stub->args.valid, stub->args.xdata);
-                break;
-	case GF_FOP_FALLOCATE:
-		stub->fn.fallocate(stub->frame, stub->frame->this,
-				   stub->args.fd, stub->args.flags,
-				   stub->args.offset, stub->args.size,
-				   stub->args.xdata);
-		break;
-	case GF_FOP_DISCARD:
-		stub->fn.discard(stub->frame, stub->frame->this,
-				 stub->args.fd, stub->args.offset,
-				 stub->args.size, stub->args.xdata);
-		break;
+            stub->fn.fsetattr(stub->frame, stub->frame->this, stub->args.fd,
+                              &stub->args.stat, stub->args.valid,
+                              stub->args.xdata);
+            break;
+        case GF_FOP_FALLOCATE:
+            stub->fn.fallocate(stub->frame, stub->frame->this, stub->args.fd,
+                               stub->args.flags, stub->args.offset,
+                               stub->args.size, stub->args.xdata);
+            break;
+        case GF_FOP_DISCARD:
+            stub->fn.discard(stub->frame, stub->frame->this, stub->args.fd,
+                             stub->args.offset, stub->args.size,
+                             stub->args.xdata);
+            break;
         case GF_FOP_ZEROFILL:
-                stub->fn.zerofill(stub->frame, stub->frame->this,
-                                 stub->args.fd, stub->args.offset,
-                                 stub->args.size, stub->args.xdata);
-                break;
+            stub->fn.zerofill(stub->frame, stub->frame->this, stub->args.fd,
+                              stub->args.offset, stub->args.size,
+                              stub->args.xdata);
+            break;
         case GF_FOP_IPC:
-                stub->fn.ipc (stub->frame, stub->frame->this,
-                              stub->args.cmd, stub->args.xdata);
-                break;
+            stub->fn.ipc(stub->frame, stub->frame->this, stub->args.cmd,
+                         stub->args.xdata);
+            break;
         case GF_FOP_SEEK:
-                stub->fn.seek (stub->frame, stub->frame->this,
-                               stub->args.fd, stub->args.offset,
-                               stub->args.what, stub->args.xdata);
-                break;
+            stub->fn.seek(stub->frame, stub->frame->this, stub->args.fd,
+                          stub->args.offset, stub->args.what, stub->args.xdata);
+            break;
         case GF_FOP_LEASE:
-                stub->fn.lease (stub->frame, stub->frame->this,
-                                &stub->args.loc, &stub->args.lease,
-                                stub->args.xdata);
-                break;
+            stub->fn.lease(stub->frame, stub->frame->this, &stub->args.loc,
+                           &stub->args.lease, stub->args.xdata);
+            break;
 
         case GF_FOP_GETACTIVELK:
-                stub->fn.getactivelk (stub->frame, stub->frame->this,
-                                       &stub->args.loc, stub->args.xdata);
-                break;
+            stub->fn.getactivelk(stub->frame, stub->frame->this,
+                                 &stub->args.loc, stub->args.xdata);
+            break;
 
         case GF_FOP_SETACTIVELK:
-                stub->fn.setactivelk (stub->frame, stub->frame->this,
-                                        &stub->args.loc, &stub->args.locklist,
-                                        stub->args.xdata);
-                break;
+            stub->fn.setactivelk(stub->frame, stub->frame->this,
+                                 &stub->args.loc, &stub->args.locklist,
+                                 stub->args.xdata);
+            break;
 
         case GF_FOP_PUT:
-                stub->fn.put (stub->frame, stub->frame->this,
-                              &stub->args.loc, stub->args.mode, stub->args.umask,
-                              stub->args.flags, stub->args.vector,
-                              stub->args.count, stub->args.offset,
-                              stub->args.iobref, stub->args.xattr,
-                              stub->args.xdata);
-                break;
+            stub->fn.put(stub->frame, stub->frame->this, &stub->args.loc,
+                         stub->args.mode, stub->args.umask, stub->args.flags,
+                         stub->args.vector, stub->args.count, stub->args.offset,
+                         stub->args.iobref, stub->args.xattr, stub->args.xdata);
+            break;
 
         default:
-                gf_msg_callingfn ("call-stub", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ENTRY, "Invalid value of FOP"
-                                  " (%d)", stub->fop);
-                break;
-        }
-out:
-        return;
-}
-
-
-#define STUB_UNWIND(stb, fop, args ...) do {				\
-	if (stb->fn_cbk.fop)						\
-		stb->fn_cbk.fop (stb->frame, stb->frame->cookie,	\
-				 stb->frame->this, stb->args_cbk.op_ret, \
-				 stb->args_cbk.op_errno, args);		\
-	else								\
-		STACK_UNWIND_STRICT (fop, stb->frame, stb->args_cbk.op_ret, \
-				     stb->args_cbk.op_errno, args);	\
-	} while (0)
-
+            gf_msg_callingfn("call-stub", GF_LOG_ERROR, EINVAL,
+                             LG_MSG_INVALID_ENTRY,
+                             "Invalid value of FOP"
+                             " (%d)",
+                             stub->fop);
+            break;
+    }
+out:
+    return;
+}
+
+#define STUB_UNWIND(stb, fop, args...)                                         \
+    do {                                                                       \
+        if (stb->fn_cbk.fop)                                                   \
+            stb->fn_cbk.fop(stb->frame, stb->frame->cookie, stb->frame->this,  \
+                            stb->args_cbk.op_ret, stb->args_cbk.op_errno,      \
+                            args);                                             \
+        else                                                                   \
+            STACK_UNWIND_STRICT(fop, stb->frame, stb->args_cbk.op_ret,         \
+                                stb->args_cbk.op_errno, args);                 \
+    } while (0)
 
 static void
-call_resume_unwind (call_stub_t *stub)
+call_resume_unwind(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        switch (stub->fop) {
+    switch (stub->fop) {
         case GF_FOP_OPEN:
-		STUB_UNWIND (stub, open, stub->args_cbk.fd,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, open, stub->args_cbk.fd, stub->args_cbk.xdata);
+            break;
         case GF_FOP_CREATE:
-		STUB_UNWIND (stub, create, stub->args_cbk.fd,
-			     stub->args_cbk.inode, &stub->args_cbk.stat,
-			     &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, create, stub->args_cbk.fd, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_STAT:
-		STUB_UNWIND (stub, stat, &stub->args_cbk.stat,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, stat, &stub->args_cbk.stat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READLINK:
-		STUB_UNWIND (stub, readlink, stub->args_cbk.buf,
-			     &stub->args_cbk.stat, stub->args.xdata);
-		break;
+            STUB_UNWIND(stub, readlink, stub->args_cbk.buf,
+                        &stub->args_cbk.stat, stub->args.xdata);
+            break;
         case GF_FOP_MKNOD:
-		STUB_UNWIND (stub, mknod, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, mknod, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_MKDIR:
-		STUB_UNWIND (stub, mkdir, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, mkdir, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_UNLINK:
-		STUB_UNWIND (stub, unlink, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, unlink, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_RMDIR:
-		STUB_UNWIND (stub, rmdir, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rmdir, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SYMLINK:
-		STUB_UNWIND (stub, symlink, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, symlink, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, &stub->args_cbk.preparent,
+                        &stub->args_cbk.postparent, stub->args_cbk.xdata);
+            break;
         case GF_FOP_RENAME:
-		STUB_UNWIND (stub, rename, &stub->args_cbk.stat,
-			     &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent,
-			     &stub->args_cbk.preparent2,
-			     &stub->args_cbk.postparent2,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rename, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        &stub->args_cbk.preparent2, &stub->args_cbk.postparent2,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LINK:
-		STUB_UNWIND (stub, link, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, &stub->args_cbk.preparent,
-			     &stub->args_cbk.postparent, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, link, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_TRUNCATE:
-		STUB_UNWIND (stub, truncate, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, truncate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READ:
-		STUB_UNWIND (stub, readv, stub->args_cbk.vector,
-			     stub->args_cbk.count, &stub->args_cbk.stat,
-			     stub->args_cbk.iobref, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, readv, stub->args_cbk.vector,
+                        stub->args_cbk.count, &stub->args_cbk.stat,
+                        stub->args_cbk.iobref, stub->args_cbk.xdata);
+            break;
         case GF_FOP_WRITE:
-		STUB_UNWIND (stub, writev, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, writev, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_STATFS:
-		STUB_UNWIND (stub, statfs, &stub->args_cbk.statvfs,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, statfs, &stub->args_cbk.statvfs,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FLUSH:
-		STUB_UNWIND (stub, flush, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, flush, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSYNC:
-		STUB_UNWIND (stub, fsync, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsync, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SETXATTR:
-		STUB_UNWIND (stub, setxattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, setxattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_GETXATTR:
-		STUB_UNWIND (stub, getxattr, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, getxattr, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSETXATTR:
-		STUB_UNWIND (stub, fsetxattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsetxattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FGETXATTR:
-		STUB_UNWIND (stub, fgetxattr, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fgetxattr, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_REMOVEXATTR:
-		STUB_UNWIND (stub, removexattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, removexattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FREMOVEXATTR:
-		STUB_UNWIND (stub, fremovexattr, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fremovexattr, stub->args_cbk.xdata);
+            break;
         case GF_FOP_OPENDIR:
-		STUB_UNWIND (stub, opendir, stub->args_cbk.fd,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, opendir, stub->args_cbk.fd, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSYNCDIR:
-		STUB_UNWIND (stub, fsyncdir, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fsyncdir, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ACCESS:
-		STUB_UNWIND (stub, access, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, access, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FTRUNCATE:
-		STUB_UNWIND (stub, ftruncate, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, ftruncate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSTAT:
-		STUB_UNWIND (stub, fstat, &stub->args_cbk.stat,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fstat, &stub->args_cbk.stat,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LK:
-		STUB_UNWIND (stub, lk, &stub->args_cbk.lock,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, lk, &stub->args_cbk.lock, stub->args_cbk.xdata);
+            break;
         case GF_FOP_INODELK:
-		STUB_UNWIND (stub, inodelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, inodelk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FINODELK:
-		STUB_UNWIND (stub, finodelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, finodelk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-		STUB_UNWIND (stub, entrylk, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, entrylk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-		STUB_UNWIND (stub, fentrylk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, fentrylk, stub->args_cbk.xdata);
+            break;
         case GF_FOP_LOOKUP:
-		STUB_UNWIND (stub, lookup, stub->args_cbk.inode,
-			     &stub->args_cbk.stat, stub->args_cbk.xdata,
-			     &stub->args_cbk.postparent);
-                break;
+            STUB_UNWIND(stub, lookup, stub->args_cbk.inode,
+                        &stub->args_cbk.stat, stub->args_cbk.xdata,
+                        &stub->args_cbk.postparent);
+            break;
         case GF_FOP_RCHECKSUM:
-		STUB_UNWIND (stub, rchecksum, stub->args_cbk.weak_checksum,
-			     stub->args_cbk.strong_checksum, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, rchecksum, stub->args_cbk.weak_checksum,
+                        stub->args_cbk.strong_checksum, stub->args_cbk.xdata);
+            break;
         case GF_FOP_READDIR:
-		STUB_UNWIND (stub, readdir, &stub->args_cbk.entries,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, readdir, &stub->args_cbk.entries,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_READDIRP:
-		STUB_UNWIND (stub, readdir, &stub->args_cbk.entries,
-			     stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, readdir, &stub->args_cbk.entries,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_XATTROP:
-		STUB_UNWIND (stub, xattrop, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, xattrop, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_FXATTROP:
-		STUB_UNWIND (stub, fxattrop, stub->args_cbk.xattr,
-			     stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fxattrop, stub->args_cbk.xattr,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_SETATTR:
-		STUB_UNWIND (stub, setattr, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, setattr, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_FSETATTR:
-		STUB_UNWIND (stub, fsetattr, &stub->args_cbk.prestat,
-			     &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
-	case GF_FOP_FALLOCATE:
-		STUB_UNWIND(stub, fallocate, &stub->args_cbk.prestat,
-			    &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
-	case GF_FOP_DISCARD:
-		STUB_UNWIND(stub, discard, &stub->args_cbk.prestat,
-			    &stub->args_cbk.poststat, stub->args_cbk.xdata);
-		break;
+            STUB_UNWIND(stub, fsetattr, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
+        case GF_FOP_FALLOCATE:
+            STUB_UNWIND(stub, fallocate, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
+        case GF_FOP_DISCARD:
+            STUB_UNWIND(stub, discard, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_ZEROFILL:
-                STUB_UNWIND(stub, zerofill, &stub->args_cbk.prestat,
-                            &stub->args_cbk.poststat, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, zerofill, &stub->args_cbk.prestat,
+                        &stub->args_cbk.poststat, stub->args_cbk.xdata);
+            break;
         case GF_FOP_IPC:
-                STUB_UNWIND (stub, ipc, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, ipc, stub->args_cbk.xdata);
+            break;
         case GF_FOP_SEEK:
-                STUB_UNWIND (stub, seek, stub->args_cbk.offset,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, seek, stub->args_cbk.offset,
+                        stub->args_cbk.xdata);
+            break;
         case GF_FOP_LEASE:
-                STUB_UNWIND (stub, lease, &stub->args_cbk.lease,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, lease, &stub->args_cbk.lease,
+                        stub->args_cbk.xdata);
+            break;
 
         case GF_FOP_GETACTIVELK:
-                STUB_UNWIND (stub, getactivelk, &stub->args_cbk.locklist,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, getactivelk, &stub->args_cbk.locklist,
+                        stub->args_cbk.xdata);
+            break;
 
         case GF_FOP_SETACTIVELK:
-                STUB_UNWIND (stub, setactivelk, stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, setactivelk, stub->args_cbk.xdata);
+            break;
 
         case GF_FOP_PUT:
-                STUB_UNWIND (stub, put, stub->args_cbk.inode,
-                             &stub->args_cbk.stat,
-                             &stub->args_cbk.preparent,
-                             &stub->args_cbk.postparent,
-                             stub->args_cbk.xdata);
-                break;
+            STUB_UNWIND(stub, put, stub->args_cbk.inode, &stub->args_cbk.stat,
+                        &stub->args_cbk.preparent, &stub->args_cbk.postparent,
+                        stub->args_cbk.xdata);
+            break;
 
         default:
-                gf_msg_callingfn ("call-stub", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ENTRY, "Invalid value of FOP"
-                                  " (%d)", stub->fop);
-                break;
-        }
+            gf_msg_callingfn("call-stub", GF_LOG_ERROR, EINVAL,
+                             LG_MSG_INVALID_ENTRY,
+                             "Invalid value of FOP"
+                             " (%d)",
+                             stub->fop);
+            break;
+    }
 out:
-        return;
+    return;
 }
 
-
 static void
-call_stub_wipe_args (call_stub_t *stub)
+call_stub_wipe_args(call_stub_t *stub)
 {
-        args_wipe (&stub->args);
+    args_wipe(&stub->args);
 }
 
 static void
-call_stub_wipe_args_cbk (call_stub_t *stub)
+call_stub_wipe_args_cbk(call_stub_t *stub)
 {
-        args_cbk_wipe (&stub->args_cbk);
+    args_cbk_wipe(&stub->args_cbk);
 }
 
-
 void
-call_stub_destroy (call_stub_t *stub)
+call_stub_destroy(call_stub_t *stub)
 {
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        if (stub->wind)
-                call_stub_wipe_args (stub);
-        else
-                call_stub_wipe_args_cbk (stub);
+    if (stub->wind)
+        call_stub_wipe_args(stub);
+    else
+        call_stub_wipe_args_cbk(stub);
 
-        stub->stub_mem_pool = NULL;
+    stub->stub_mem_pool = NULL;
 
-        mem_put (stub);
+    mem_put(stub);
 out:
-        return;
+    return;
 }
 
-
 void
-call_resume (call_stub_t *stub)
+call_resume(call_stub_t *stub)
 {
-        xlator_t *old_THIS = NULL;
+    xlator_t *old_THIS = NULL;
 
-        errno = EINVAL;
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    errno = EINVAL;
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                if (stub->wind)
-                        call_resume_wind (stub);
-                else
-                        call_resume_unwind (stub);
-        }
-        THIS = old_THIS;
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        if (stub->wind)
+            call_resume_wind(stub);
+        else
+            call_resume_unwind(stub);
+    }
+    THIS = old_THIS;
 
-        call_stub_destroy (stub);
+    call_stub_destroy(stub);
 out:
-        return;
+    return;
 }
 
-
 void
-call_unwind_error (call_stub_t *stub, int op_ret, int op_errno)
+call_unwind_error(call_stub_t *stub, int op_ret, int op_errno)
 {
-        xlator_t *old_THIS = NULL;
-
-        list_del_init (&stub->list);
+    xlator_t *old_THIS = NULL;
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-		stub->args_cbk.op_ret = op_ret;
-		stub->args_cbk.op_errno = op_errno;
-		call_resume_unwind (stub);
-        }
-        THIS = old_THIS;
+    list_del_init(&stub->list);
 
-        call_stub_destroy (stub);
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        stub->args_cbk.op_ret = op_ret;
+        stub->args_cbk.op_errno = op_errno;
+        call_resume_unwind(stub);
+    }
+    THIS = old_THIS;
 
-        return;
+    call_stub_destroy(stub);
 
+    return;
 }
 
-
 void
-call_unwind_error_keep_stub (call_stub_t *stub, int op_ret, int op_errno)
+call_unwind_error_keep_stub(call_stub_t *stub, int op_ret, int op_errno)
 {
-        xlator_t *old_THIS = NULL;
+    xlator_t *old_THIS = NULL;
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                stub->args_cbk.op_ret = op_ret;
-                stub->args_cbk.op_errno = op_errno;
-                call_resume_unwind (stub);
-        }
-
-        THIS = old_THIS;
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        stub->args_cbk.op_ret = op_ret;
+        stub->args_cbk.op_errno = op_errno;
+        call_resume_unwind(stub);
+    }
 
-        return;
+    THIS = old_THIS;
 
+    return;
 }
 
 void
-call_resume_keep_stub (call_stub_t *stub)
+call_resume_keep_stub(call_stub_t *stub)
 {
-        xlator_t *old_THIS = NULL;
+    xlator_t *old_THIS = NULL;
 
-        errno = EINVAL;
-        GF_VALIDATE_OR_GOTO ("call-stub", stub, out);
+    errno = EINVAL;
+    GF_VALIDATE_OR_GOTO("call-stub", stub, out);
 
-        list_del_init (&stub->list);
+    list_del_init(&stub->list);
 
-        old_THIS = THIS;
-        THIS = stub->frame->this;
-        {
-                if (stub->wind)
-                        call_resume_wind (stub);
-                else
-                        call_resume_unwind (stub);
-        }
+    old_THIS = THIS;
+    THIS = stub->frame->this;
+    {
+        if (stub->wind)
+            call_resume_wind(stub);
+        else
+            call_resume_unwind(stub);
+    }
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/checksum.c b/libglusterfs/src/checksum.c
index 561ca04e48b..acdaed04ae2 100644
--- a/libglusterfs/src/checksum.c
+++ b/libglusterfs/src/checksum.c
@@ -22,24 +22,23 @@
  * data. Thus int32_t and uint32_t are sufficient
  */
 uint32_t
-gf_rsync_weak_checksum (unsigned char *buf, size_t len)
+gf_rsync_weak_checksum(unsigned char *buf, size_t len)
 {
-        return adler32 (0, buf, len);
+    return adler32(0, buf, len);
 }
 
-
 /*
  * The "strong" checksum required for the rsync algorithm.
  */
 void
-gf_rsync_strong_checksum (unsigned char *data, size_t len,
-                          unsigned char *sha256_md)
+gf_rsync_strong_checksum(unsigned char *data, size_t len,
+                         unsigned char *sha256_md)
 {
-        SHA256((const unsigned char *)data, len, sha256_md);
+    SHA256((const unsigned char *)data, len, sha256_md);
 }
 
 void
-gf_rsync_md5_checksum (unsigned char *data, size_t len, unsigned char *md5)
+gf_rsync_md5_checksum(unsigned char *data, size_t len, unsigned char *md5)
 {
-        MD5 (data, len, md5);
+    MD5(data, len, md5);
 }
diff --git a/libglusterfs/src/circ-buff.c b/libglusterfs/src/circ-buff.c
index 6259282a917..cb37ed30ea2 100644
--- a/libglusterfs/src/circ-buff.c
+++ b/libglusterfs/src/circ-buff.c
@@ -12,190 +12,182 @@
 #include "libglusterfs-messages.h"
 
 void
-cb_destroy_data (circular_buffer_t *cb,
-                 void (*destroy_buffer_data) (void *data))
+cb_destroy_data(circular_buffer_t *cb, void (*destroy_buffer_data)(void *data))
 {
-        if (destroy_buffer_data)
-                destroy_buffer_data (cb->data);
-        GF_FREE (cb->data);
-        return;
+    if (destroy_buffer_data)
+        destroy_buffer_data(cb->data);
+    GF_FREE(cb->data);
+    return;
 }
 
-
 /* hold lock while calling this function */
 int
-__cb_add_entry_buffer (buffer_t *buffer, void *item)
+__cb_add_entry_buffer(buffer_t *buffer, void *item)
 {
-        circular_buffer_t   *ptr  = NULL;
-        int    ret   = -1;
-        //DO we really need the assert here?
-        GF_ASSERT (buffer->used_len <= buffer->size_buffer);
-
-        if (buffer->use_once == _gf_true &&
-            buffer->used_len == buffer->size_buffer) {
-                gf_msg  ("circ-buff", GF_LOG_WARNING, 0, LG_MSG_BUFFER_ERROR,
-                         "buffer %p is use once buffer", buffer);
-                return -1;
-        } else {
-                if (buffer->used_len == buffer->size_buffer) {
-                        if (buffer->cb[buffer->w_index]) {
-                                ptr = buffer->cb[buffer->w_index];
-                                if (ptr->data) {
-                                        cb_destroy_data (ptr,
-                                                   buffer->destroy_buffer_data);
-                                        ptr->data = NULL;
-                                        GF_FREE (ptr);
-                                }
-                                buffer->cb[buffer->w_index] = NULL;
-                                ptr = NULL;
-                        }
+    circular_buffer_t *ptr = NULL;
+    int ret = -1;
+    // DO we really need the assert here?
+    GF_ASSERT(buffer->used_len <= buffer->size_buffer);
+
+    if (buffer->use_once == _gf_true &&
+        buffer->used_len == buffer->size_buffer) {
+        gf_msg("circ-buff", GF_LOG_WARNING, 0, LG_MSG_BUFFER_ERROR,
+               "buffer %p is use once buffer", buffer);
+        return -1;
+    } else {
+        if (buffer->used_len == buffer->size_buffer) {
+            if (buffer->cb[buffer->w_index]) {
+                ptr = buffer->cb[buffer->w_index];
+                if (ptr->data) {
+                    cb_destroy_data(ptr, buffer->destroy_buffer_data);
+                    ptr->data = NULL;
+                    GF_FREE(ptr);
                 }
-
-                buffer->cb[buffer->w_index] =
-                        GF_CALLOC (1, sizeof (circular_buffer_t),
-                                   gf_common_mt_circular_buffer_t);
-                if (!buffer->cb[buffer->w_index])
-                        return -1;
-
-                buffer->cb[buffer->w_index]->data = item;
-                ret = gettimeofday (&buffer->cb[buffer->w_index]->tv, NULL);
-                if (ret == -1)
-                        gf_msg_callingfn ("circ-buff", GF_LOG_WARNING, 0,
-                                          LG_MSG_GETTIMEOFDAY_FAILED,
-                                          "getting time of the day failed");
-                buffer->w_index++;
-                buffer->w_index %= buffer->size_buffer;
-                //used_buffer size cannot be greater than the total buffer size
-
-                if (buffer->used_len < buffer->size_buffer)
-                        buffer->used_len++;
-                return buffer->w_index;
+                buffer->cb[buffer->w_index] = NULL;
+                ptr = NULL;
+            }
         }
+
+        buffer->cb[buffer->w_index] = GF_CALLOC(1, sizeof(circular_buffer_t),
+                                                gf_common_mt_circular_buffer_t);
+        if (!buffer->cb[buffer->w_index])
+            return -1;
+
+        buffer->cb[buffer->w_index]->data = item;
+        ret = gettimeofday(&buffer->cb[buffer->w_index]->tv, NULL);
+        if (ret == -1)
+            gf_msg_callingfn("circ-buff", GF_LOG_WARNING, 0,
+                             LG_MSG_GETTIMEOFDAY_FAILED,
+                             "getting time of the day failed");
+        buffer->w_index++;
+        buffer->w_index %= buffer->size_buffer;
+        // used_buffer size cannot be greater than the total buffer size
+
+        if (buffer->used_len < buffer->size_buffer)
+            buffer->used_len++;
+        return buffer->w_index;
+    }
 }
 
 int
-cb_add_entry_buffer (buffer_t *buffer, void *item)
+cb_add_entry_buffer(buffer_t *buffer, void *item)
 {
-        int write_index = -1;
+    int write_index = -1;
 
-        pthread_mutex_lock (&buffer->lock);
-        {
-                write_index = __cb_add_entry_buffer (buffer, item);
-        }
-        pthread_mutex_unlock (&buffer->lock);
+    pthread_mutex_lock(&buffer->lock);
+    {
+        write_index = __cb_add_entry_buffer(buffer, item);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 
-        return write_index;
+    return write_index;
 }
 
 void
-cb_buffer_show (buffer_t *buffer)
+cb_buffer_show(buffer_t *buffer)
 {
-        pthread_mutex_lock (&buffer->lock);
-        {
-                gf_msg_debug ("circ-buff", 0, "w_index: %d, size: %"
-                              GF_PRI_SIZET" used_buffer: %d", buffer->w_index,
-                              buffer->size_buffer, buffer->used_len);
-        }
-        pthread_mutex_unlock (&buffer->lock);
+    pthread_mutex_lock(&buffer->lock);
+    {
+        gf_msg_debug("circ-buff", 0,
+                     "w_index: %d, size: %" GF_PRI_SIZET " used_buffer: %d",
+                     buffer->w_index, buffer->size_buffer, buffer->used_len);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 }
 
 void
-cb_buffer_dump (buffer_t *buffer, void *data,
-                int (fn) (circular_buffer_t *buffer, void *data))
+cb_buffer_dump(buffer_t *buffer, void *data,
+               int(fn)(circular_buffer_t *buffer, void *data))
 {
-        int index = 0;
-        circular_buffer_t *entry = NULL;
-        int  entries = 0;
-        int ul = 0;
-        int w_ind = 0;
-        int size_buff = 0;
-        int i = 0;
-
-        ul = buffer->used_len;
-        w_ind = buffer->w_index;
-        size_buff = buffer->size_buffer;
-
-        pthread_mutex_lock (&buffer->lock);
-        {
-                if (buffer->use_once == _gf_false) {
-                        index = (size_buff + (w_ind - ul))%size_buff;
-                        for (entries = 0; entries < buffer->used_len;
-                             entries++) {
-                                entry = buffer->cb[index];
-                                if (entry)
-                                        fn (entry, data);
-                                else
-                                        gf_msg_callingfn ("circ-buff",
-                                                          GF_LOG_WARNING, 0,
-                                                          LG_MSG_NULL_PTR,
-                                                          "Null entry in "
-                                                          "circular buffer at "
-                                                          "index %d.", index);
-
-                                index++;
-                                index %= buffer->size_buffer;
-                        }
-                } else {
-                        for (i = 0; i < buffer->used_len ; i++) {
-                                entry = buffer->cb[i];
-                                fn (entry, data);
-                        }
-                }
+    int index = 0;
+    circular_buffer_t *entry = NULL;
+    int entries = 0;
+    int ul = 0;
+    int w_ind = 0;
+    int size_buff = 0;
+    int i = 0;
+
+    ul = buffer->used_len;
+    w_ind = buffer->w_index;
+    size_buff = buffer->size_buffer;
+
+    pthread_mutex_lock(&buffer->lock);
+    {
+        if (buffer->use_once == _gf_false) {
+            index = (size_buff + (w_ind - ul)) % size_buff;
+            for (entries = 0; entries < buffer->used_len; entries++) {
+                entry = buffer->cb[index];
+                if (entry)
+                    fn(entry, data);
+                else
+                    gf_msg_callingfn("circ-buff", GF_LOG_WARNING, 0,
+                                     LG_MSG_NULL_PTR,
+                                     "Null entry in "
+                                     "circular buffer at "
+                                     "index %d.",
+                                     index);
+
+                index++;
+                index %= buffer->size_buffer;
+            }
+        } else {
+            for (i = 0; i < buffer->used_len; i++) {
+                entry = buffer->cb[i];
+                fn(entry, data);
+            }
         }
-        pthread_mutex_unlock (&buffer->lock);
+    }
+    pthread_mutex_unlock(&buffer->lock);
 }
 
 buffer_t *
-cb_buffer_new (size_t buffer_size, gf_boolean_t use_once,
-               void (*destroy_buffer_data) (void *data))
+cb_buffer_new(size_t buffer_size, gf_boolean_t use_once,
+              void (*destroy_buffer_data)(void *data))
 {
-        buffer_t    *buffer = NULL;
-
-        buffer = GF_CALLOC (1, sizeof (*buffer), gf_common_mt_buffer_t);
-        if (!buffer) {
-                goto out;
-        }
-
-        buffer->cb = GF_CALLOC (buffer_size,
-                                sizeof (circular_buffer_t *),
-                                gf_common_mt_circular_buffer_t);
-        if (!buffer->cb) {
-                GF_FREE (buffer);
-                buffer = NULL;
-                goto out;
-        }
-
-        buffer->w_index = 0;
-        buffer->size_buffer = buffer_size;
-        buffer->use_once = use_once;
-        buffer->used_len = 0;
-        buffer->destroy_buffer_data = destroy_buffer_data;
-        pthread_mutex_init (&buffer->lock, NULL);
+    buffer_t *buffer = NULL;
+
+    buffer = GF_CALLOC(1, sizeof(*buffer), gf_common_mt_buffer_t);
+    if (!buffer) {
+        goto out;
+    }
+
+    buffer->cb = GF_CALLOC(buffer_size, sizeof(circular_buffer_t *),
+                           gf_common_mt_circular_buffer_t);
+    if (!buffer->cb) {
+        GF_FREE(buffer);
+        buffer = NULL;
+        goto out;
+    }
+
+    buffer->w_index = 0;
+    buffer->size_buffer = buffer_size;
+    buffer->use_once = use_once;
+    buffer->used_len = 0;
+    buffer->destroy_buffer_data = destroy_buffer_data;
+    pthread_mutex_init(&buffer->lock, NULL);
 
 out:
-        return buffer;
+    return buffer;
 }
 
 void
-cb_buffer_destroy (buffer_t *buffer)
+cb_buffer_destroy(buffer_t *buffer)
 {
-        int                     i = 0;
-        circular_buffer_t       *ptr = NULL;
-        if (buffer) {
-                if (buffer->cb) {
-                        for (i = 0; i < buffer->used_len ; i++) {
-                                ptr = buffer->cb[i];
-                                if (ptr->data) {
-                                        cb_destroy_data (ptr,
-                                                   buffer->destroy_buffer_data);
-                                        ptr->data = NULL;
-                                        GF_FREE (ptr);
-                                }
-                        }
-                        GF_FREE (buffer->cb);
+    int i = 0;
+    circular_buffer_t *ptr = NULL;
+    if (buffer) {
+        if (buffer->cb) {
+            for (i = 0; i < buffer->used_len; i++) {
+                ptr = buffer->cb[i];
+                if (ptr->data) {
+                    cb_destroy_data(ptr, buffer->destroy_buffer_data);
+                    ptr->data = NULL;
+                    GF_FREE(ptr);
                 }
-                pthread_mutex_destroy (&buffer->lock);
-                GF_FREE (buffer);
+            }
+            GF_FREE(buffer->cb);
         }
+        pthread_mutex_destroy(&buffer->lock);
+        GF_FREE(buffer);
+    }
 }
-
diff --git a/libglusterfs/src/client_t.c b/libglusterfs/src/client_t.c
index 844acbc459c..35e0beda8d6 100644
--- a/libglusterfs/src/client_t.c
+++ b/libglusterfs/src/client_t.c
@@ -17,648 +17,625 @@
 #include "libglusterfs-messages.h"
 
 static int
-gf_client_chain_client_entries (cliententry_t *entries, uint32_t startidx,
-                        uint32_t endcount)
+gf_client_chain_client_entries(cliententry_t *entries, uint32_t startidx,
+                               uint32_t endcount)
 {
-        uint32_t        i = 0;
+    uint32_t i = 0;
 
-        if (!entries) {
-                gf_msg_callingfn ("client_t", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!entries");
-                return -1;
-        }
+    if (!entries) {
+        gf_msg_callingfn("client_t", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!entries");
+        return -1;
+    }
 
-        /* Chain only till the second to last entry because we want to
-         * ensure that the last entry has GF_CLIENTTABLE_END.
-         */
-        for (i = startidx; i < (endcount - 1); i++)
-                entries[i].next_free = i + 1;
+    /* Chain only till the second to last entry because we want to
+     * ensure that the last entry has GF_CLIENTTABLE_END.
+     */
+    for (i = startidx; i < (endcount - 1); i++)
+        entries[i].next_free = i + 1;
 
-        /* i has already been incremented up to the last entry. */
-        entries[i].next_free = GF_CLIENTTABLE_END;
+    /* i has already been incremented up to the last entry. */
+    entries[i].next_free = GF_CLIENTTABLE_END;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-gf_client_clienttable_expand (clienttable_t *clienttable, uint32_t nr)
+gf_client_clienttable_expand(clienttable_t *clienttable, uint32_t nr)
 {
-        cliententry_t   *oldclients     = NULL;
-        uint32_t         oldmax_clients = -1;
-        int              ret            = -1;
-
-        if (clienttable == NULL || nr <= clienttable->max_clients) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                ret = EINVAL;
-                goto out;
-        }
-
-        oldclients = clienttable->cliententries;
-        oldmax_clients = clienttable->max_clients;
-
-        clienttable->cliententries = GF_CALLOC (nr, sizeof (cliententry_t),
-                                                gf_common_mt_cliententry_t);
-        if (!clienttable->cliententries) {
-                clienttable->cliententries = oldclients;
-                ret = 0;
-                goto out;
-        }
-        clienttable->max_clients = nr;
-
-        if (oldclients) {
-                uint32_t cpy = oldmax_clients * sizeof (cliententry_t);
-                memcpy (clienttable->cliententries, oldclients, cpy);
-        }
-
-        gf_client_chain_client_entries (clienttable->cliententries,
-                                        oldmax_clients,
-                                        clienttable->max_clients);
-
-        /* Now that expansion is done, we must update the client list
-         * head pointer so that the client allocation functions can continue
-         * using the expanded table.
-         */
-        clienttable->first_free = oldmax_clients;
-        GF_FREE (oldclients);
+    cliententry_t *oldclients = NULL;
+    uint32_t oldmax_clients = -1;
+    int ret = -1;
+
+    if (clienttable == NULL || nr <= clienttable->max_clients) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        ret = EINVAL;
+        goto out;
+    }
+
+    oldclients = clienttable->cliententries;
+    oldmax_clients = clienttable->max_clients;
+
+    clienttable->cliententries = GF_CALLOC(nr, sizeof(cliententry_t),
+                                           gf_common_mt_cliententry_t);
+    if (!clienttable->cliententries) {
+        clienttable->cliententries = oldclients;
         ret = 0;
+        goto out;
+    }
+    clienttable->max_clients = nr;
+
+    if (oldclients) {
+        uint32_t cpy = oldmax_clients * sizeof(cliententry_t);
+        memcpy(clienttable->cliententries, oldclients, cpy);
+    }
+
+    gf_client_chain_client_entries(clienttable->cliententries, oldmax_clients,
+                                   clienttable->max_clients);
+
+    /* Now that expansion is done, we must update the client list
+     * head pointer so that the client allocation functions can continue
+     * using the expanded table.
+     */
+    clienttable->first_free = oldmax_clients;
+    GF_FREE(oldclients);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 clienttable_t *
-gf_clienttable_alloc (void)
+gf_clienttable_alloc(void)
 {
-        clienttable_t *clienttable = NULL;
-        int            result = 0;
-
-        clienttable =
-                GF_CALLOC (1, sizeof (clienttable_t), gf_common_mt_clienttable_t);
-        if (!clienttable)
-                return NULL;
-
-        LOCK_INIT (&clienttable->lock);
-
-        result = gf_client_clienttable_expand (clienttable,
-                                               GF_CLIENTTABLE_INITIAL_SIZE);
-        if (result != 0) {
-                gf_msg ("client_t", GF_LOG_ERROR, 0,
-                        LG_MSG_EXPAND_CLIENT_TABLE_FAILED,
-                        "gf_client_clienttable_expand failed");
-                GF_FREE (clienttable);
-                return NULL;
-        }
-
-        return clienttable;
+    clienttable_t *clienttable = NULL;
+    int result = 0;
+
+    clienttable = GF_CALLOC(1, sizeof(clienttable_t),
+                            gf_common_mt_clienttable_t);
+    if (!clienttable)
+        return NULL;
+
+    LOCK_INIT(&clienttable->lock);
+
+    result = gf_client_clienttable_expand(clienttable,
+                                          GF_CLIENTTABLE_INITIAL_SIZE);
+    if (result != 0) {
+        gf_msg("client_t", GF_LOG_ERROR, 0, LG_MSG_EXPAND_CLIENT_TABLE_FAILED,
+               "gf_client_clienttable_expand failed");
+        GF_FREE(clienttable);
+        return NULL;
+    }
+
+    return clienttable;
 }
 
-
 void
-gf_client_clienttable_destroy (clienttable_t *clienttable)
+gf_client_clienttable_destroy(clienttable_t *clienttable)
 {
-        client_t         *client        = NULL;
-        cliententry_t    *cliententries = NULL;
-        uint32_t          client_count  = 0;
-        int32_t           i             = 0;
-
-        if (!clienttable) {
-                gf_msg_callingfn ("client_t", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!clienttable");
-                return;
-        }
-
-        LOCK (&clienttable->lock);
-        {
-                client_count = clienttable->max_clients;
-                clienttable->max_clients = 0;
-                cliententries = clienttable->cliententries;
-                clienttable->cliententries = NULL;
-        }
-        UNLOCK (&clienttable->lock);
-
-        if (cliententries != NULL) {
-                for (i = 0; i < client_count; i++) {
-                        client = cliententries[i].client;
-                        if (client != NULL) {
-                                gf_client_unref (client);
-                        }
-                }
-
-                GF_FREE (cliententries);
-                LOCK_DESTROY (&clienttable->lock);
-                GF_FREE (clienttable);
-        }
+    client_t *client = NULL;
+    cliententry_t *cliententries = NULL;
+    uint32_t client_count = 0;
+    int32_t i = 0;
+
+    if (!clienttable) {
+        gf_msg_callingfn("client_t", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!clienttable");
+        return;
+    }
+
+    LOCK(&clienttable->lock);
+    {
+        client_count = clienttable->max_clients;
+        clienttable->max_clients = 0;
+        cliententries = clienttable->cliententries;
+        clienttable->cliententries = NULL;
+    }
+    UNLOCK(&clienttable->lock);
+
+    if (cliententries != NULL) {
+        for (i = 0; i < client_count; i++) {
+            client = cliententries[i].client;
+            if (client != NULL) {
+                gf_client_unref(client);
+            }
+        }
+
+        GF_FREE(cliententries);
+        LOCK_DESTROY(&clienttable->lock);
+        GF_FREE(clienttable);
+    }
 }
 
-
 /*
  * Increments ref.bind if the client is already present or creates a new
  * client with ref.bind = 1,ref.count = 1 it signifies that
  * as long as ref.bind is > 0 client should be alive.
  */
 client_t *
-gf_client_get (xlator_t *this, struct rpcsvc_auth_data *cred, char *client_uid,
-               char *subdir_mount)
+gf_client_get(xlator_t *this, struct rpcsvc_auth_data *cred, char *client_uid,
+              char *subdir_mount)
 {
-        client_t      *client      = NULL;
-        cliententry_t *cliententry = NULL;
-        clienttable_t *clienttable = NULL;
-        unsigned int   i           = 0;
-
-        if (this == NULL || client_uid == NULL) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
-
-        clienttable = this->ctx->clienttable;
-
-        LOCK (&clienttable->lock);
-        {
-                for (; i < clienttable->max_clients; i++) {
-                        client = clienttable->cliententries[i].client;
-                        if (client == NULL)
-                                continue;
-                        /*
-                         * look for matching client_uid, _and_
-                         * if auth was used, matching auth flavour and data
-                         */
-                        if (strcmp (client_uid, client->client_uid) == 0 &&
-                                (cred->flavour != AUTH_NONE &&
-                                        (cred->flavour == client->auth.flavour &&
-                                        (size_t) cred->datalen == client->auth.len &&
-                                        memcmp (cred->authdata,
-                                                client->auth.data,
-                                                client->auth.len) == 0))) {
-                                GF_ATOMIC_INC (client->bind);
-                                goto unlock;
-                        }
-                }
-
-                client = GF_CALLOC (1, sizeof(client_t), gf_common_mt_client_t);
-                if (client == NULL) {
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-
-                client->this = this;
-                if (subdir_mount != NULL)
-                        client->subdir_mount = gf_strdup (subdir_mount);
-
-                LOCK_INIT (&client->scratch_ctx.lock);
-
-                client->client_uid = gf_strdup (client_uid);
-                if (client->client_uid == NULL) {
-                        GF_FREE (client);
-                        client = NULL;
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-                client->scratch_ctx.count = GF_CLIENTCTX_INITIAL_SIZE;
-                client->scratch_ctx.ctx =
-                        GF_CALLOC (GF_CLIENTCTX_INITIAL_SIZE,
-                                   sizeof (struct client_ctx),
-                                   gf_common_mt_client_ctx);
-                if (client->scratch_ctx.ctx == NULL) {
-                        GF_FREE (client->client_uid);
-                        GF_FREE (client);
-                        client = NULL;
-                        errno = ENOMEM;
-                        goto unlock;
-                }
-
-                GF_ATOMIC_INIT (client->bind, 1);
-                GF_ATOMIC_INIT (client->count, 1);
-
-                client->auth.flavour = cred->flavour;
-                if (cred->flavour != AUTH_NONE) {
-                        client->auth.data =
-                                GF_MALLOC (cred->datalen,
-                                           gf_common_mt_client_t);
-                        if (client->auth.data == NULL) {
-                                GF_FREE (client->scratch_ctx.ctx);
-                                GF_FREE (client->client_uid);
-                                GF_FREE (client);
-                                client = NULL;
-                                errno = ENOMEM;
-                                goto unlock;
-                        }
-                        memcpy (client->auth.data, cred->authdata,
-                                cred->datalen);
-                        client->auth.len = cred->datalen;
-                }
-
-                client->tbl_index = clienttable->first_free;
-                cliententry = &clienttable->cliententries[clienttable->first_free];
-                if (cliententry->next_free == GF_CLIENTTABLE_END) {
-                        int result =
-                                gf_client_clienttable_expand (clienttable,
-                                        clienttable->max_clients +
-                                                GF_CLIENTTABLE_INITIAL_SIZE);
-                        if (result != 0) {
-                                GF_FREE (client->scratch_ctx.ctx);
-                                GF_FREE (client->client_uid);
-                                GF_FREE (client);
-                                client = NULL;
-                                errno = result;
-                                goto unlock;
-                        }
-                        cliententry = &clienttable->cliententries[client->tbl_index];
-                        cliententry->next_free = clienttable->first_free;
-                }
-                cliententry->client = client;
-                clienttable->first_free = cliententry->next_free;
-                cliententry->next_free = GF_CLIENTENTRY_ALLOCATED;
-        }
+    client_t *client = NULL;
+    cliententry_t *cliententry = NULL;
+    clienttable_t *clienttable = NULL;
+    unsigned int i = 0;
+
+    if (this == NULL || client_uid == NULL) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
+
+    clienttable = this->ctx->clienttable;
+
+    LOCK(&clienttable->lock);
+    {
+        for (; i < clienttable->max_clients; i++) {
+            client = clienttable->cliententries[i].client;
+            if (client == NULL)
+                continue;
+            /*
+             * look for matching client_uid, _and_
+             * if auth was used, matching auth flavour and data
+             */
+            if (strcmp(client_uid, client->client_uid) == 0 &&
+                (cred->flavour != AUTH_NONE &&
+                 (cred->flavour == client->auth.flavour &&
+                  (size_t)cred->datalen == client->auth.len &&
+                  memcmp(cred->authdata, client->auth.data, client->auth.len) ==
+                      0))) {
+                GF_ATOMIC_INC(client->bind);
+                goto unlock;
+            }
+        }
+
+        client = GF_CALLOC(1, sizeof(client_t), gf_common_mt_client_t);
+        if (client == NULL) {
+            errno = ENOMEM;
+            goto unlock;
+        }
+
+        client->this = this;
+        if (subdir_mount != NULL)
+            client->subdir_mount = gf_strdup(subdir_mount);
+
+        LOCK_INIT(&client->scratch_ctx.lock);
+
+        client->client_uid = gf_strdup(client_uid);
+        if (client->client_uid == NULL) {
+            GF_FREE(client);
+            client = NULL;
+            errno = ENOMEM;
+            goto unlock;
+        }
+        client->scratch_ctx.count = GF_CLIENTCTX_INITIAL_SIZE;
+        client->scratch_ctx.ctx = GF_CALLOC(GF_CLIENTCTX_INITIAL_SIZE,
+                                            sizeof(struct client_ctx),
+                                            gf_common_mt_client_ctx);
+        if (client->scratch_ctx.ctx == NULL) {
+            GF_FREE(client->client_uid);
+            GF_FREE(client);
+            client = NULL;
+            errno = ENOMEM;
+            goto unlock;
+        }
+
+        GF_ATOMIC_INIT(client->bind, 1);
+        GF_ATOMIC_INIT(client->count, 1);
+
+        client->auth.flavour = cred->flavour;
+        if (cred->flavour != AUTH_NONE) {
+            client->auth.data = GF_MALLOC(cred->datalen, gf_common_mt_client_t);
+            if (client->auth.data == NULL) {
+                GF_FREE(client->scratch_ctx.ctx);
+                GF_FREE(client->client_uid);
+                GF_FREE(client);
+                client = NULL;
+                errno = ENOMEM;
+                goto unlock;
+            }
+            memcpy(client->auth.data, cred->authdata, cred->datalen);
+            client->auth.len = cred->datalen;
+        }
+
+        client->tbl_index = clienttable->first_free;
+        cliententry = &clienttable->cliententries[clienttable->first_free];
+        if (cliententry->next_free == GF_CLIENTTABLE_END) {
+            int result = gf_client_clienttable_expand(
+                clienttable,
+                clienttable->max_clients + GF_CLIENTTABLE_INITIAL_SIZE);
+            if (result != 0) {
+                GF_FREE(client->scratch_ctx.ctx);
+                GF_FREE(client->client_uid);
+                GF_FREE(client);
+                client = NULL;
+                errno = result;
+                goto unlock;
+            }
+            cliententry = &clienttable->cliententries[client->tbl_index];
+            cliententry->next_free = clienttable->first_free;
+        }
+        cliententry->client = client;
+        clienttable->first_free = cliententry->next_free;
+        cliententry->next_free = GF_CLIENTENTRY_ALLOCATED;
+    }
 unlock:
-        UNLOCK (&clienttable->lock);
-
-        if (client)
-                gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
-                                  "%s: bind_ref: %"GF_PRI_ATOMIC", ref: "
-                                  "%"GF_PRI_ATOMIC, client->client_uid,
-                                  GF_ATOMIC_GET (client->bind),
-                                  GF_ATOMIC_GET (client->count));
-        return client;
+    UNLOCK(&clienttable->lock);
+
+    if (client)
+        gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
+                         "%s: bind_ref: %" GF_PRI_ATOMIC
+                         ", ref: "
+                         "%" GF_PRI_ATOMIC,
+                         client->client_uid, GF_ATOMIC_GET(client->bind),
+                         GF_ATOMIC_GET(client->count));
+    return client;
 }
 
 void
-gf_client_put (client_t *client, gf_boolean_t *detached)
+gf_client_put(client_t *client, gf_boolean_t *detached)
 {
-        gf_boolean_t unref = _gf_false;
-        int bind_ref;
-
-        if (client == NULL)
-                goto out;
-
+    gf_boolean_t unref = _gf_false;
+    int bind_ref;
+
+    if (client == NULL)
+        goto out;
+
+    if (detached)
+        *detached = _gf_false;
+
+    bind_ref = GF_ATOMIC_DEC(client->bind);
+    if (bind_ref == 0)
+        unref = _gf_true;
+
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF,
+                     "%s: "
+                     "bind_ref: %" GF_PRI_ATOMIC ", ref: %" GF_PRI_ATOMIC
+                     ", "
+                     "unref: %d",
+                     client->client_uid, GF_ATOMIC_GET(client->bind),
+                     GF_ATOMIC_GET(client->count), unref);
+    if (unref) {
         if (detached)
-                *detached = _gf_false;
-
-        bind_ref = GF_ATOMIC_DEC (client->bind);
-        if (bind_ref == 0)
-                unref = _gf_true;
-
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_BIND_REF, "%s: "
-                          "bind_ref: %"GF_PRI_ATOMIC", ref: %"GF_PRI_ATOMIC", "
-                          "unref: %d", client->client_uid,
-                          GF_ATOMIC_GET (client->bind),
-                          GF_ATOMIC_GET (client->count), unref);
-        if (unref) {
-                if (detached)
-                        *detached = _gf_true;
-                gf_client_unref (client);
-        }
+            *detached = _gf_true;
+        gf_client_unref(client);
+    }
 
 out:
-        return;
+    return;
 }
 
 client_t *
-gf_client_ref (client_t *client)
+gf_client_ref(client_t *client)
 {
-        if (!client) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "null client");
-                return NULL;
-        }
-
-        GF_ATOMIC_INC (client->count);
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT, "%s: "
-                          "ref-count %"GF_PRI_ATOMIC, client->client_uid,
-                          GF_ATOMIC_GET (client->count));
-        return client;
+    if (!client) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "null client");
+        return NULL;
+    }
+
+    GF_ATOMIC_INC(client->count);
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT,
+                     "%s: "
+                     "ref-count %" GF_PRI_ATOMIC,
+                     client->client_uid, GF_ATOMIC_GET(client->count));
+    return client;
 }
 
-
 static void
-gf_client_destroy_recursive (xlator_t *xl, client_t *client)
+gf_client_destroy_recursive(xlator_t *xl, client_t *client)
 {
-        xlator_list_t   *trav;
+    xlator_list_t *trav;
 
-        if (!xl->call_cleanup && xl->cbks->client_destroy) {
-                xl->cbks->client_destroy (xl, client);
-        }
+    if (!xl->call_cleanup && xl->cbks->client_destroy) {
+        xl->cbks->client_destroy(xl, client);
+    }
 
-        for (trav = xl->children; trav; trav = trav->next) {
-                gf_client_destroy_recursive (trav->xlator, client);
-        }
+    for (trav = xl->children; trav; trav = trav->next) {
+        gf_client_destroy_recursive(trav->xlator, client);
+    }
 }
 
-
 static void
-client_destroy (client_t *client)
+client_destroy(client_t *client)
 {
-        clienttable_t     *clienttable = NULL;
-        glusterfs_graph_t *gtrav       = NULL;
-
-        if (client == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                goto out;
-        }
-
-        clienttable = client->this->ctx->clienttable;
-
-        LOCK_DESTROY (&client->scratch_ctx.lock);
-
-        LOCK (&clienttable->lock);
-        {
-                clienttable->cliententries[client->tbl_index].client = NULL;
-                clienttable->cliententries[client->tbl_index].next_free =
-                        clienttable->first_free;
-                clienttable->first_free = client->tbl_index;
-        }
-        UNLOCK (&clienttable->lock);
-
-        list_for_each_entry (gtrav, &client->this->ctx->graphs, list) {
-                gf_client_destroy_recursive (gtrav->top, client);
-        }
-
-        if (client->subdir_inode)
-                inode_unref (client->subdir_inode);
-
-        GF_FREE (client->auth.data);
-        GF_FREE (client->auth.username);
-        GF_FREE (client->auth.passwd);
-        GF_FREE (client->scratch_ctx.ctx);
-        GF_FREE (client->client_uid);
-        GF_FREE (client->subdir_mount);
-        GF_FREE (client->client_name);
-        GF_FREE (client);
+    clienttable_t *clienttable = NULL;
+    glusterfs_graph_t *gtrav = NULL;
+
+    if (client == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        goto out;
+    }
+
+    clienttable = client->this->ctx->clienttable;
+
+    LOCK_DESTROY(&client->scratch_ctx.lock);
+
+    LOCK(&clienttable->lock);
+    {
+        clienttable->cliententries[client->tbl_index].client = NULL;
+        clienttable->cliententries[client->tbl_index]
+            .next_free = clienttable->first_free;
+        clienttable->first_free = client->tbl_index;
+    }
+    UNLOCK(&clienttable->lock);
+
+    list_for_each_entry(gtrav, &client->this->ctx->graphs, list)
+    {
+        gf_client_destroy_recursive(gtrav->top, client);
+    }
+
+    if (client->subdir_inode)
+        inode_unref(client->subdir_inode);
+
+    GF_FREE(client->auth.data);
+    GF_FREE(client->auth.username);
+    GF_FREE(client->auth.passwd);
+    GF_FREE(client->scratch_ctx.ctx);
+    GF_FREE(client->client_uid);
+    GF_FREE(client->subdir_mount);
+    GF_FREE(client->client_name);
+    GF_FREE(client);
 out:
-        return;
+    return;
 }
 
 static int
-gf_client_disconnect_recursive (xlator_t *xl, client_t *client)
+gf_client_disconnect_recursive(xlator_t *xl, client_t *client)
 {
-        int             ret     = 0;
-        xlator_list_t   *trav;
+    int ret = 0;
+    xlator_list_t *trav;
 
-        if (!xl->call_cleanup && xl->cbks->client_disconnect) {
-                ret = xl->cbks->client_disconnect (xl, client);
-        }
+    if (!xl->call_cleanup && xl->cbks->client_disconnect) {
+        ret = xl->cbks->client_disconnect(xl, client);
+    }
 
-        for (trav = xl->children; trav; trav = trav->next) {
-                ret |= gf_client_disconnect_recursive (trav->xlator, client);
-        }
+    for (trav = xl->children; trav; trav = trav->next) {
+        ret |= gf_client_disconnect_recursive(trav->xlator, client);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-gf_client_disconnect (client_t *client)
+gf_client_disconnect(client_t *client)
 {
-        int                ret   = 0;
-        glusterfs_graph_t *gtrav = NULL;
+    int ret = 0;
+    glusterfs_graph_t *gtrav = NULL;
 
-        list_for_each_entry (gtrav, &client->this->ctx->graphs, list) {
-                ret |= gf_client_disconnect_recursive (gtrav->top, client);
-        }
+    list_for_each_entry(gtrav, &client->this->ctx->graphs, list)
+    {
+        ret |= gf_client_disconnect_recursive(gtrav->top, client);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 void
-gf_client_unref (client_t *client)
+gf_client_unref(client_t *client)
 {
-        uint64_t refcount;
-
-        if (!client) {
-                gf_msg_callingfn ("client_t", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "client is NULL");
-                return;
-        }
+    uint64_t refcount;
 
-        refcount = GF_ATOMIC_DEC (client->count);
-        gf_msg_callingfn ("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT, "%s: "
-                          "ref-count %"GF_PRI_ATOMIC, client->client_uid,
-                          refcount);
-        if (refcount == 0) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_DISCONNECT_CLIENT,
-                        "Shutting down connection %s", client->client_uid);
-                client_destroy (client);
-        }
+    if (!client) {
+        gf_msg_callingfn("client_t", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "client is NULL");
+        return;
+    }
+
+    refcount = GF_ATOMIC_DEC(client->count);
+    gf_msg_callingfn("client_t", GF_LOG_DEBUG, 0, LG_MSG_REF_COUNT,
+                     "%s: "
+                     "ref-count %" GF_PRI_ATOMIC,
+                     client->client_uid, refcount);
+    if (refcount == 0) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, LG_MSG_DISCONNECT_CLIENT,
+               "Shutting down connection %s", client->client_uid);
+        client_destroy(client);
+    }
 }
 
-
 static int
-__client_ctx_get_int (client_t *client, void *key, void **value)
+__client_ctx_get_int(client_t *client, void *key, void **value)
 {
-        int index = 0;
-        int ret   = 0;
+    int index = 0;
+    int ret = 0;
 
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (client->scratch_ctx.ctx[index].ctx_key == key)
-                        break;
-        }
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (client->scratch_ctx.ctx[index].ctx_key == key)
+            break;
+    }
 
-        if (index == client->scratch_ctx.count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == client->scratch_ctx.count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = client->scratch_ctx.ctx[index].ctx_value;
+    if (value)
+        *value = client->scratch_ctx.ctx[index].ctx_value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__client_ctx_set_int (client_t *client, void *key, void *value)
+__client_ctx_set_int(client_t *client, void *key, void *value)
 {
-        int index   = 0;
-        int ret     = 0;
-        int set_idx = -1;
-
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (!client->scratch_ctx.ctx[index].ctx_key) {
-                        if (set_idx == -1)
-                                set_idx = index;
-                        /* don't break, to check if key already exists
-                           further on */
-                }
-                if (client->scratch_ctx.ctx[index].ctx_key == key) {
-                        set_idx = index;
-                        break;
-                }
-        }
+    int index = 0;
+    int ret = 0;
+    int set_idx = -1;
 
-        if (set_idx == -1) {
-                ret = -1;
-                goto out;
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (!client->scratch_ctx.ctx[index].ctx_key) {
+            if (set_idx == -1)
+                set_idx = index;
+            /* don't break, to check if key already exists
+               further on */
+        }
+        if (client->scratch_ctx.ctx[index].ctx_key == key) {
+            set_idx = index;
+            break;
         }
+    }
 
-        client->scratch_ctx.ctx[set_idx].ctx_key = key;
-        client->scratch_ctx.ctx[set_idx].ctx_value  = value;
+    if (set_idx == -1) {
+        ret = -1;
+        goto out;
+    }
+
+    client->scratch_ctx.ctx[set_idx].ctx_key = key;
+    client->scratch_ctx.ctx[set_idx].ctx_value = value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /*will return success with old value if exist*/
 void *
-client_ctx_set (client_t *client, void *key, void *value)
+client_ctx_set(client_t *client, void *key, void *value)
 {
-        int ret = 0;
-        void *ret_value = NULL;
-
-        if (!client || !key || !value)
-                return NULL;
-
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_get_int (client, key, &ret_value);
-                if (!ret && ret_value) {
-                        UNLOCK (&client->scratch_ctx.lock);
-                        return ret_value;
-                }
+    int ret = 0;
+    void *ret_value = NULL;
+
+    if (!client || !key || !value)
+        return NULL;
 
-                ret = __client_ctx_set_int (client, key, value);
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_get_int(client, key, &ret_value);
+        if (!ret && ret_value) {
+            UNLOCK(&client->scratch_ctx.lock);
+            return ret_value;
         }
-        UNLOCK (&client->scratch_ctx.lock);
 
-        if (ret)
-                return NULL;
-        return value;
-}
+        ret = __client_ctx_set_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
+    if (ret)
+        return NULL;
+    return value;
+}
 
 int
-client_ctx_get (client_t *client, void *key, void **value)
+client_ctx_get(client_t *client, void *key, void **value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!client || !key)
-                return -1;
+    if (!client || !key)
+        return -1;
 
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_get_int (client, key, value);
-        }
-        UNLOCK (&client->scratch_ctx.lock);
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_get_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__client_ctx_del_int (client_t *client, void *key, void **value)
+__client_ctx_del_int(client_t *client, void *key, void **value)
 {
-        int index = 0;
-        int ret   = 0;
+    int index = 0;
+    int ret = 0;
 
-        for (index = 0; index < client->scratch_ctx.count; index++) {
-                if (client->scratch_ctx.ctx[index].ctx_key == key)
-                        break;
-        }
+    for (index = 0; index < client->scratch_ctx.count; index++) {
+        if (client->scratch_ctx.ctx[index].ctx_key == key)
+            break;
+    }
 
-        if (index == client->scratch_ctx.count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == client->scratch_ctx.count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = client->scratch_ctx.ctx[index].ctx_value;
+    if (value)
+        *value = client->scratch_ctx.ctx[index].ctx_value;
 
-        client->scratch_ctx.ctx[index].ctx_key   = 0;
-        client->scratch_ctx.ctx[index].ctx_value = 0;
+    client->scratch_ctx.ctx[index].ctx_key = 0;
+    client->scratch_ctx.ctx[index].ctx_value = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-client_ctx_del (client_t *client, void *key, void **value)
+client_ctx_del(client_t *client, void *key, void **value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!client || !key)
-                return -1;
+    if (!client || !key)
+        return -1;
 
-        LOCK (&client->scratch_ctx.lock);
-        {
-                ret = __client_ctx_del_int (client, key, value);
-        }
-        UNLOCK (&client->scratch_ctx.lock);
+    LOCK(&client->scratch_ctx.lock);
+    {
+        ret = __client_ctx_del_int(client, key, value);
+    }
+    UNLOCK(&client->scratch_ctx.lock);
 
-        return ret;
+    return ret;
 }
 
-
 void
-client_dump (client_t *client, char *prefix)
+client_dump(client_t *client, char *prefix)
 {
-        if (!client)
-                return;
+    if (!client)
+        return;
 
-        gf_proc_dump_write("refcount", GF_PRI_ATOMIC,
-                           GF_ATOMIC_GET (client->count));
+    gf_proc_dump_write("refcount", GF_PRI_ATOMIC, GF_ATOMIC_GET(client->count));
 }
 
-
 void
-cliententry_dump (cliententry_t *cliententry, char *prefix)
+cliententry_dump(cliententry_t *cliententry, char *prefix)
 {
-        if (!cliententry)
-                return;
+    if (!cliententry)
+        return;
 
-        if (GF_CLIENTENTRY_ALLOCATED != cliententry->next_free)
-                return;
+    if (GF_CLIENTENTRY_ALLOCATED != cliententry->next_free)
+        return;
 
-        if (cliententry->client)
-                client_dump(cliententry->client, prefix);
+    if (cliententry->client)
+        client_dump(cliententry->client, prefix);
 }
 
-
 void
-clienttable_dump (clienttable_t *clienttable, char *prefix)
+clienttable_dump(clienttable_t *clienttable, char *prefix)
 {
-        int     i   = 0;
-        int     ret = -1;
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0};
-
-        if (!clienttable)
-                return;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return;
-                }
-                gf_proc_dump_build_key(key, prefix, "maxclients");
-                gf_proc_dump_write(key, "%d", clienttable->max_clients);
-                gf_proc_dump_build_key(key, prefix, "first_free");
-                gf_proc_dump_write(key, "%d", clienttable->first_free);
-                for ( i = 0 ; i < clienttable->max_clients; i++) {
-                        if (GF_CLIENTENTRY_ALLOCATED ==
-                            clienttable->cliententries[i].next_free) {
-                                gf_proc_dump_build_key(key, prefix,
-                                                       "cliententry[%d]", i);
-                                gf_proc_dump_add_section(key);
-                                cliententry_dump(&clienttable->cliententries[i],
-                                                 key);
-                        }
-                }
-        }
-        UNLOCK(&clienttable->lock);
-}
+    int i = 0;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {0};
 
+    if (!clienttable)
+        return;
+
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return;
+        }
+        gf_proc_dump_build_key(key, prefix, "maxclients");
+        gf_proc_dump_write(key, "%d", clienttable->max_clients);
+        gf_proc_dump_build_key(key, prefix, "first_free");
+        gf_proc_dump_write(key, "%d", clienttable->first_free);
+        for (i = 0; i < clienttable->max_clients; i++) {
+            if (GF_CLIENTENTRY_ALLOCATED ==
+                clienttable->cliententries[i].next_free) {
+                gf_proc_dump_build_key(key, prefix, "cliententry[%d]", i);
+                gf_proc_dump_add_section(key);
+                cliententry_dump(&clienttable->cliententries[i], key);
+            }
+        }
+    }
+    UNLOCK(&clienttable->lock);
+}
 
 void
-client_ctx_dump (client_t *client, char *prefix)
+client_ctx_dump(client_t *client, char *prefix)
 {
 #if 0 /* TBD, FIXME */
         struct client_ctx   *client_ctx = NULL;
@@ -701,254 +678,241 @@ out:
 #endif
 }
 
-
 /*
  * the following functions are here to preserve legacy behavior of the
  * protocol/server xlator dump, but perhaps they should just be folded
  * into the client dump instead?
  */
 int
-gf_client_dump_fdtables_to_dict (xlator_t *this, dict_t *dict)
+gf_client_dump_fdtables_to_dict(xlator_t *this, dict_t *dict)
 {
-        clienttable_t  *clienttable = NULL;
-        int             count       = 0;
-        int             ret         = -1;
+    clienttable_t *clienttable = NULL;
+    int count = 0;
+    int ret = -1;
 #ifdef NOTYET
-        client_t       *client      = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
+    client_t *client = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
 #endif
 
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, dict, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, dict, out);
 
-        clienttable = this->ctx->clienttable;
+    clienttable = this->ctx->clienttable;
 
-        if (!clienttable)
-                return -1;
+    if (!clienttable)
+        return -1;
 
 #ifdef NOTYET
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        if (client->bound_xl &&
-                            !strcmp (client->bound_xl->name, this->name)) {
-                                snprintf (key, sizeof (key), "conn%d", count++);
-                                fdtable_dump_to_dict (client->server_ctx.
-                                                      fdtable,
-                                                      key, dict);
-                        }
-                }
-        }
-        UNLOCK(&clienttable->lock);
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->bound_xl &&
+                !strcmp(client->bound_xl->name, this->name)) {
+                snprintf(key, sizeof(key), "conn%d", count++);
+                fdtable_dump_to_dict(client->server_ctx.fdtable, key, dict);
+            }
+        }
+    }
+    UNLOCK(&clienttable->lock);
 #endif
 
-        ret = dict_set_int32 (dict, "conncount", count);
+    ret = dict_set_int32(dict, "conncount", count);
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_client_dump_fdtables (xlator_t *this)
+gf_client_dump_fdtables(xlator_t *this)
 {
-        client_t       *client = NULL;
-        clienttable_t  *clienttable = NULL;
-        int             count = 1;
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                return -1;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-
-
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        if (client->client_uid) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.id", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->client_uid);
-                        }
-
-                        if (client->subdir_mount) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.subdir", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->subdir_mount);
-                        }
-                        gf_proc_dump_build_key (key, "conn", "%d.ref",
-                                                        count);
-                        gf_proc_dump_write (key, GF_PRI_ATOMIC,
-                                            GF_ATOMIC_GET (client->count));
-                        if (client->bound_xl) {
-                                gf_proc_dump_build_key (key, "conn",
-                                                        "%d.bound_xl", count);
-                                gf_proc_dump_write (key, "%s",
-                                                    client->bound_xl->name);
-                        }
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    int count = 1;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        return -1;
+
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->client_uid) {
+                gf_proc_dump_build_key(key, "conn", "%d.id", count);
+                gf_proc_dump_write(key, "%s", client->client_uid);
+            }
+
+            if (client->subdir_mount) {
+                gf_proc_dump_build_key(key, "conn", "%d.subdir", count);
+                gf_proc_dump_write(key, "%s", client->subdir_mount);
+            }
+            gf_proc_dump_build_key(key, "conn", "%d.ref", count);
+            gf_proc_dump_write(key, GF_PRI_ATOMIC,
+                               GF_ATOMIC_GET(client->count));
+            if (client->bound_xl) {
+                gf_proc_dump_build_key(key, "conn", "%d.bound_xl", count);
+                gf_proc_dump_write(key, "%s", client->bound_xl->name);
+            }
 
 #ifdef NOTYET
-                        gf_proc_dump_build_key (key, "conn","%d.id", count);
-                        fdtable_dump (client->server_ctx.fdtable, key);
+            gf_proc_dump_build_key(key, "conn", "%d.id", count);
+            fdtable_dump(client->server_ctx.fdtable, key);
 #endif
-                }
         }
+    }
 
-        UNLOCK(&clienttable->lock);
+    UNLOCK(&clienttable->lock);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-gf_client_dump_inodes_to_dict (xlator_t *this, dict_t *dict)
+gf_client_dump_inodes_to_dict(xlator_t *this, dict_t *dict)
 {
-        client_t       *client        = NULL;
-        clienttable_t  *clienttable   = NULL;
-        xlator_t       *prev_bound_xl = NULL;
-        char            key[32]       = {0,};
-        int             count         = 0;
-        int             ret           = -1;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, dict, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                return -1;
-
-        ret = LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        return -1;
-                }
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        if (!strcmp (client->bound_xl->name, this->name)) {
-                                if (client->bound_xl && client->bound_xl->
-                                                itable) {
-                                        /* Presently every brick contains only
-                                         * one bound_xl for all connections.
-                                         * This will lead to duplicating of
-                                         *  the inode lists, if listing is
-                                         * done for every connection. This
-                                         * simple check prevents duplication
-                                         * in the present case. If need arises
-                                         * the check can be improved.
-                                         */
-                                        if (client->bound_xl == prev_bound_xl)
-                                                continue;
-                                        prev_bound_xl = client->bound_xl;
-
-                                        snprintf (key, sizeof (key), "conn%d",
-                                                        count);
-                                        inode_table_dump_to_dict (client->
-                                                        bound_xl->itable,
-                                                        key, dict);
-                                }
-                        }
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    xlator_t *prev_bound_xl = NULL;
+    char key[32] = {
+        0,
+    };
+    int count = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, dict, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        return -1;
+
+    ret = LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            return -1;
+        }
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (!strcmp(client->bound_xl->name, this->name)) {
+                if (client->bound_xl && client->bound_xl->itable) {
+                    /* Presently every brick contains only
+                     * one bound_xl for all connections.
+                     * This will lead to duplicating of
+                     *  the inode lists, if listing is
+                     * done for every connection. This
+                     * simple check prevents duplication
+                     * in the present case. If need arises
+                     * the check can be improved.
+                     */
+                    if (client->bound_xl == prev_bound_xl)
+                        continue;
+                    prev_bound_xl = client->bound_xl;
+
+                    snprintf(key, sizeof(key), "conn%d", count);
+                    inode_table_dump_to_dict(client->bound_xl->itable, key,
+                                             dict);
                 }
+            }
         }
-        UNLOCK(&clienttable->lock);
+    }
+    UNLOCK(&clienttable->lock);
 
-        ret = dict_set_int32 (dict, "conncount", count);
+    ret = dict_set_int32(dict, "conncount", count);
 
 out:
-        if (prev_bound_xl)
-                prev_bound_xl = NULL;
-        return ret;
+    if (prev_bound_xl)
+        prev_bound_xl = NULL;
+    return ret;
 }
 
 int
-gf_client_dump_inodes (xlator_t *this)
+gf_client_dump_inodes(xlator_t *this)
 {
-        client_t       *client        = NULL;
-        clienttable_t  *clienttable   = NULL;
-        xlator_t       *prev_bound_xl = NULL;
-        int             count         = 0;
-        int             ret           = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-
-        clienttable = this->ctx->clienttable;
-
-        if (!clienttable)
-                goto out;
-
-        ret = TRY_LOCK (&clienttable->lock);
-        {
-                if (ret) {
-                        gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_FAILED,
-                                "Unable to acquire lock");
-                        goto out;
-                }
-
-                for ( ; count < clienttable->max_clients; count++) {
-                        if (GF_CLIENTENTRY_ALLOCATED !=
-                            clienttable->cliententries[count].next_free)
-                                continue;
-                        client = clienttable->cliententries[count].client;
-                        if (client->bound_xl && client->bound_xl->itable) {
-                                /* Presently every brick contains only
-                                 * one bound_xl for all connections.
-                                 * This will lead to duplicating of
-                                 * the inode lists, if listing is
-                                 * done for every connection. This
-                                 * simple check prevents duplication
-                                 * in the present case. If need arises
-                                 * the check can be improved.
-                                 */
-                                if (client->bound_xl == prev_bound_xl)
-                                        continue;
-                                prev_bound_xl = client->bound_xl;
-
-                                gf_proc_dump_build_key(key, "conn",
-                                                       "%d.bound_xl.%s", count,
-                                                       client->bound_xl->name);
-                                inode_table_dump(client->bound_xl->itable,key);
-                        }
-                }
-        }
-        UNLOCK(&clienttable->lock);
-
-        ret = 0;
+    client_t *client = NULL;
+    clienttable_t *clienttable = NULL;
+    xlator_t *prev_bound_xl = NULL;
+    int count = 0;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+
+    clienttable = this->ctx->clienttable;
+
+    if (!clienttable)
+        goto out;
+
+    ret = TRY_LOCK(&clienttable->lock);
+    {
+        if (ret) {
+            gf_msg("client_t", GF_LOG_WARNING, 0, LG_MSG_LOCK_FAILED,
+                   "Unable to acquire lock");
+            goto out;
+        }
+
+        for (; count < clienttable->max_clients; count++) {
+            if (GF_CLIENTENTRY_ALLOCATED !=
+                clienttable->cliententries[count].next_free)
+                continue;
+            client = clienttable->cliententries[count].client;
+            if (client->bound_xl && client->bound_xl->itable) {
+                /* Presently every brick contains only
+                 * one bound_xl for all connections.
+                 * This will lead to duplicating of
+                 * the inode lists, if listing is
+                 * done for every connection. This
+                 * simple check prevents duplication
+                 * in the present case. If need arises
+                 * the check can be improved.
+                 */
+                if (client->bound_xl == prev_bound_xl)
+                    continue;
+                prev_bound_xl = client->bound_xl;
+
+                gf_proc_dump_build_key(key, "conn", "%d.bound_xl.%s", count,
+                                       client->bound_xl->name);
+                inode_table_dump(client->bound_xl->itable, key);
+            }
+        }
+    }
+    UNLOCK(&clienttable->lock);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
-
diff --git a/libglusterfs/src/cluster-syncop.c b/libglusterfs/src/cluster-syncop.c
index aa9cea75ba3..dab00577886 100644
--- a/libglusterfs/src/cluster-syncop.c
+++ b/libglusterfs/src/cluster-syncop.c
@@ -17,539 +17,496 @@
 #include "cluster-syncop.h"
 #include "defaults.h"
 
-#define FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fop, args ...) do {\
-        int __i = 0;                                                    \
-        int __count = 0;					        \
-        cluster_local_t __local = {0,};                                 \
-        void    *__old_local = frame->local;                            \
-                                                                        \
-        __local.replies = replies;                                      \
-        memset (output, 0, numsubvols);                                 \
-        cluster_replies_wipe (replies, numsubvols);                     \
-        for (__i = 0; __i < numsubvols; __i++)                          \
-                INIT_LIST_HEAD (&replies[__i].entries.list);            \
-        if (syncbarrier_init (&__local.barrier))                        \
-                break;                                                  \
-        frame->local = &__local;                                        \
-        for (__i = 0; __i < numsubvols; __i++) {                        \
-                if (on[__i]) {                                          \
-                        __count++;                                      \
-                }                                                       \
-        }                                                               \
-        __local.barrier.waitfor = __count;                              \
-        for (__i = 0; __i < numsubvols; __i++) {		        \
-                if (!on[__i])                                           \
-                        continue;				        \
-                STACK_WIND_COOKIE (frame, cluster_##fop##_cbk,          \
-                                   (void *)(long) __i, subvols[__i],    \
-                                   subvols[__i]->fops->fop, args);      \
-        }								\
-        syncbarrier_wait (&__local.barrier, __count);			\
-        syncbarrier_destroy (&__local.barrier);                         \
-        frame->local = __old_local;                                     \
-        STACK_RESET (frame->root);                                      \
-        } while (0)
-
-#define FOP_SEQ(subvols, on, numsubvols, replies, output, frame, fop, args ...) do {\
-        int __i = 0;					                \
-                                                                        \
-        cluster_local_t __local = {0,};                                 \
-        void    *__old_local = frame->local;                            \
-        __local.replies = replies;                                      \
-        memset (output, 0, numsubvols);                                 \
-        cluster_replies_wipe (replies, numsubvols);                     \
-        for (__i = 0; __i < numsubvols; __i++)                          \
-                INIT_LIST_HEAD (&replies[__i].entries.list);            \
-        if (syncbarrier_init (&__local.barrier))                        \
-                break;                                                  \
-        frame->local = &__local;                                        \
-        for (__i = 0; __i < numsubvols; __i++) {		        \
-                if (!on[__i])                                           \
-                        continue;				        \
-                STACK_WIND_COOKIE (frame, cluster_##fop##_cbk,          \
-                                   (void *)(long) __i, subvols[__i],    \
-                                   subvols[__i]->fops->fop, args);      \
-                syncbarrier_wait (&__local.barrier, 1);                 \
-        }                                                               \
-        syncbarrier_destroy (&__local.barrier);                         \
-        frame->local = __old_local;                                     \
-        STACK_RESET (frame->root);                                      \
-        } while (0)
-
-#define FOP_CBK(fop, frame, cookie, args ...) do {\
-        cluster_local_t *__local = frame->local;                        \
-        int __i = (long)cookie;                                         \
-        args_##fop##_cbk_store (&__local->replies[__i], args);          \
-        __local->replies[__i].valid = 1;                                \
-        syncbarrier_wake (&__local->barrier);                           \
-        } while (0)
-
-int32_t
-cluster_fop_success_fill (default_args_cbk_t *replies, int numsubvols,
-                          unsigned char *success)
-{
-        int i = 0;
-        int count = 0;
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].valid && replies[i].op_ret >= 0) {
-                        success[i] = 1;
-                        count++;
-                } else {
-                        success[i] = 0;
-                }
+#define FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fop,       \
+                   args...)                                                    \
+    do {                                                                       \
+        int __i = 0;                                                           \
+        int __count = 0;                                                       \
+        cluster_local_t __local = {                                            \
+            0,                                                                 \
+        };                                                                     \
+        void *__old_local = frame->local;                                      \
+                                                                               \
+        __local.replies = replies;                                             \
+        memset(output, 0, numsubvols);                                         \
+        cluster_replies_wipe(replies, numsubvols);                             \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+        if (syncbarrier_init(&__local.barrier))                                \
+            break;                                                             \
+        frame->local = &__local;                                               \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (on[__i]) {                                                     \
+                __count++;                                                     \
+            }                                                                  \
+        }                                                                      \
+        __local.barrier.waitfor = __count;                                     \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (!on[__i])                                                      \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, cluster_##fop##_cbk, (void *)(long)__i,   \
+                              subvols[__i], subvols[__i]->fops->fop, args);    \
+        }                                                                      \
+        syncbarrier_wait(&__local.barrier, __count);                           \
+        syncbarrier_destroy(&__local.barrier);                                 \
+        frame->local = __old_local;                                            \
+        STACK_RESET(frame->root);                                              \
+    } while (0)
+
+#define FOP_SEQ(subvols, on, numsubvols, replies, output, frame, fop, args...) \
+    do {                                                                       \
+        int __i = 0;                                                           \
+                                                                               \
+        cluster_local_t __local = {                                            \
+            0,                                                                 \
+        };                                                                     \
+        void *__old_local = frame->local;                                      \
+        __local.replies = replies;                                             \
+        memset(output, 0, numsubvols);                                         \
+        cluster_replies_wipe(replies, numsubvols);                             \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+        if (syncbarrier_init(&__local.barrier))                                \
+            break;                                                             \
+        frame->local = &__local;                                               \
+        for (__i = 0; __i < numsubvols; __i++) {                               \
+            if (!on[__i])                                                      \
+                continue;                                                      \
+            STACK_WIND_COOKIE(frame, cluster_##fop##_cbk, (void *)(long)__i,   \
+                              subvols[__i], subvols[__i]->fops->fop, args);    \
+            syncbarrier_wait(&__local.barrier, 1);                             \
+        }                                                                      \
+        syncbarrier_destroy(&__local.barrier);                                 \
+        frame->local = __old_local;                                            \
+        STACK_RESET(frame->root);                                              \
+    } while (0)
+
+#define FOP_CBK(fop, frame, cookie, args...)                                   \
+    do {                                                                       \
+        cluster_local_t *__local = frame->local;                               \
+        int __i = (long)cookie;                                                \
+        args_##fop##_cbk_store(&__local->replies[__i], args);                  \
+        __local->replies[__i].valid = 1;                                       \
+        syncbarrier_wake(&__local->barrier);                                   \
+    } while (0)
+
+int32_t
+cluster_fop_success_fill(default_args_cbk_t *replies, int numsubvols,
+                         unsigned char *success)
+{
+    int i = 0;
+    int count = 0;
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret >= 0) {
+            success[i] = 1;
+            count++;
+        } else {
+            success[i] = 0;
         }
+    }
 
-        return count;
+    return count;
 }
 
 void
-cluster_replies_wipe (default_args_cbk_t *replies, int numsubvols)
+cluster_replies_wipe(default_args_cbk_t *replies, int numsubvols)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!replies)
-                return;
+    if (!replies)
+        return;
 
-        for (i = 0; i < numsubvols; i++)
-                args_cbk_wipe (&replies[i]);
-        memset (replies, 0, numsubvols * sizeof (*replies));
+    for (i = 0; i < numsubvols; i++)
+        args_cbk_wipe(&replies[i]);
+    memset(replies, 0, numsubvols * sizeof(*replies));
 }
 
 int32_t
-cluster_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, dict_t *xdata, struct iatt *postparent)
+cluster_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, dict_t *xdata, struct iatt *postparent)
 {
-        FOP_CBK (lookup, frame, cookie, op_ret, op_errno, inode, buf,
-                 xdata, postparent);
-        return 0;
+    FOP_CBK(lookup, frame, cookie, op_ret, op_errno, inode, buf, xdata,
+            postparent);
+    return 0;
 }
 
 int32_t
-cluster_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                  dict_t *xdata)
+cluster_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata)
 {
-        FOP_CBK (stat, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(stat, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
+int32_t
+cluster_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
+{
+    FOP_CBK(truncate, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
+}
 
 int32_t
-cluster_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf,
-                      dict_t *xdata)
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (truncate, frame, cookie, op_ret, op_errno, prebuf,
-                 postbuf, xdata);
-        return 0;
+    FOP_CBK(ftruncate, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf,
-                       dict_t *xdata)
+cluster_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (ftruncate, frame, cookie, op_ret, op_errno, prebuf,
-                 postbuf, xdata);
-        return 0;
+    FOP_CBK(access, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno,
-                    dict_t *xdata)
+cluster_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, const char *path,
+                     struct iatt *buf, dict_t *xdata)
 {
-        FOP_CBK (access, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(readlink, frame, cookie, op_ret, op_errno, path, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, const char *path,
-                      struct iatt *buf, dict_t *xdata)
+cluster_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (readlink, frame, cookie, op_ret, op_errno, path, buf,
-                 xdata);
-        return 0;
+    FOP_CBK(mknod, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+cluster_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (mknod, frame, cookie, op_ret, op_errno, inode,
-                 buf, preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(mkdir, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
+cluster_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
                    struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (mkdir, frame, cookie, op_ret, op_errno, inode,
-                 buf, preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(unlink, frame, cookie, op_ret, op_errno, preparent, postparent,
+            xdata);
+    return 0;
 }
 
 int32_t
-cluster_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+cluster_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (unlink, frame, cookie, op_ret, op_errno, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(rmdir, frame, cookie, op_ret, op_errno, preparent, postparent,
+            xdata);
+    return 0;
 }
 
 int32_t
-cluster_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent,
-                   dict_t *xdata)
+cluster_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (rmdir, frame, cookie, op_ret, op_errno, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(symlink, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+cluster_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
 {
-        FOP_CBK (symlink, frame, cookie, op_ret, op_errno, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(rename, frame, cookie, op_ret, op_errno, buf, preoldparent,
+            postoldparent, prenewparent, postnewparent, xdata);
+    return 0;
 }
 
 int32_t
-cluster_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
+cluster_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (rename, frame, cookie, op_ret, op_errno, buf, preoldparent,
-                 postoldparent, prenewparent, postnewparent, xdata);
-        return 0;
+    FOP_CBK(link, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent,
-                  dict_t *xdata)
+cluster_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (link, frame, cookie, op_ret, op_errno, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(create, frame, cookie, op_ret, op_errno, fd, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent,
-                    dict_t *xdata)
+cluster_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        FOP_CBK (create, frame, cookie, op_ret, op_errno, fd, inode, buf,
-                 preparent, postparent, xdata);
-        return 0;
+    FOP_CBK(open, frame, cookie, op_ret, op_errno, fd, xdata);
+    return 0;
 }
 
 int32_t
-cluster_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd,
+cluster_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
                   dict_t *xdata)
 {
-        FOP_CBK (open, frame, cookie, op_ret, op_errno, fd, xdata);
-        return 0;
+    FOP_CBK(readv, frame, cookie, op_ret, op_errno, vector, count, stbuf,
+            iobref, xdata);
+    return 0;
 }
 
 int32_t
-cluster_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                   dict_t *xdata)
+cluster_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (readv, frame, cookie, op_ret, op_errno, vector, count,
-                 stbuf, iobref, xdata);
-        return 0;
+    FOP_CBK(writev, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf,
-                    dict_t *xdata)
+cluster_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata)
 {
-        FOP_CBK (writev, frame, cookie, op_ret, op_errno, prebuf, postbuf,
-                 xdata);
-        return 0;
+    FOP_CBK(put, frame, cookie, op_ret, op_errno, inode, buf, preparent,
+            postparent, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_put_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+cluster_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (put, frame, cookie, op_ret, op_errno, inode, buf, preparent,
-                 postparent, xdata);
-        return 0;
+    FOP_CBK(flush, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno,
-                   dict_t *xdata)
+cluster_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata)
 {
-        FOP_CBK (flush, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fsync, frame, cookie, op_ret, op_errno, prebuf, postbuf, xdata);
+    return 0;
 }
 
-
-
 int32_t
-cluster_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf,
-                   dict_t *xdata)
+cluster_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  dict_t *xdata)
 {
-        FOP_CBK (fsync, frame, cookie, op_ret, op_errno, prebuf, postbuf,
-                 xdata);
-        return 0;
+    FOP_CBK(fstat, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                   dict_t *xdata)
+cluster_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        FOP_CBK (fstat, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(opendir, frame, cookie, op_ret, op_errno, fd, xdata);
+    return 0;
 }
 
 int32_t
-cluster_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, fd_t *fd,
-                     dict_t *xdata)
+cluster_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (opendir, frame, cookie, op_ret, op_errno, fd, xdata);
-        return 0;
+    FOP_CBK(fsyncdir, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                   dict_t *xdata)
 {
-        FOP_CBK (fsyncdir, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(statfs, frame, cookie, op_ret, op_errno, buf, xdata);
+    return 0;
 }
 
 int32_t
-cluster_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct statvfs *buf,
-                    dict_t *xdata)
+cluster_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (statfs, frame, cookie, op_ret, op_errno, buf, xdata);
-        return 0;
+    FOP_CBK(setxattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (setxattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fsetxattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+cluster_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
-        FOP_CBK (fsetxattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fgetxattr, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
-
 int32_t
-cluster_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict,
-                       dict_t *xdata)
+cluster_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
 {
-        FOP_CBK (fgetxattr, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(getxattr, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict,
-                      dict_t *xdata)
+cluster_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata)
 {
-        FOP_CBK (getxattr, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(xattrop, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-cluster_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, dict_t *dict,
                      dict_t *xdata)
 {
-        FOP_CBK (xattrop, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(fxattrop, frame, cookie, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict,
-                      dict_t *xdata)
+cluster_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (fxattrop, frame, cookie, op_ret, op_errno, dict, xdata);
-        return 0;
+    FOP_CBK(removexattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+cluster_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (removexattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fremovexattr, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          dict_t *xdata)
+cluster_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+               dict_t *xdata)
 {
-        FOP_CBK (fremovexattr, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(lk, frame, cookie, op_ret, op_errno, lock, xdata);
+    return 0;
 }
 
 int32_t
-cluster_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-                dict_t *xdata)
+cluster_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (lk, frame, cookie, op_ret, op_errno, lock, xdata);
-        return 0;
+    FOP_CBK(inodelk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     dict_t *xdata)
+cluster_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (inodelk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(finodelk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (finodelk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(entrylk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     dict_t *xdata)
+cluster_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (entrylk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(fentrylk, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      dict_t *xdata)
+cluster_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+                      uint8_t *strong_checksum, dict_t *xdata)
 {
-        FOP_CBK (fentrylk, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(rchecksum, frame, cookie, op_ret, op_errno, weak_checksum,
+            strong_checksum, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
-                       uint8_t *strong_checksum,
-                       dict_t *xdata)
+cluster_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
 {
-        FOP_CBK (rchecksum, frame, cookie, op_ret, op_errno, weak_checksum,
-                             strong_checksum, xdata);
-        return 0;
+    FOP_CBK(readdir, frame, cookie, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
                      dict_t *xdata)
 {
-        FOP_CBK (readdir, frame, cookie, op_ret, op_errno, entries, xdata);
-        return 0;
+    FOP_CBK(readdirp, frame, cookie, op_ret, op_errno, entries, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                      dict_t *xdata)
+cluster_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+                    struct iatt *statpost, dict_t *xdata)
 {
-        FOP_CBK (readdirp, frame, cookie, op_ret, op_errno, entries, xdata);
-        return 0;
+    FOP_CBK(setattr, frame, cookie, op_ret, op_errno, statpre, statpost, xdata);
+    return 0;
 }
 
 int32_t
-cluster_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+cluster_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                     struct iatt *statpost,
-                     dict_t *xdata)
+                     struct iatt *statpost, dict_t *xdata)
 {
-        FOP_CBK (setattr, frame, cookie, op_ret, op_errno, statpre,
-                 statpost, xdata);
-        return 0;
-}
-
-int32_t
-cluster_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                      struct iatt *statpost,
-                      dict_t *xdata)
-{
-        FOP_CBK (fsetattr, frame, cookie, op_ret, op_errno, statpre,
-                 statpost, xdata);
-        return 0;
+    FOP_CBK(fsetattr, frame, cookie, op_ret, op_errno, statpre, statpost,
+            xdata);
+    return 0;
 }
 
 int32_t
@@ -557,8 +514,8 @@ cluster_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *pre,
                       struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (fallocate, frame, cookie, op_ret, op_errno, pre, post, xdata);
-        return 0;
+    FOP_CBK(fallocate, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
 int32_t
@@ -566,752 +523,733 @@ cluster_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
                     struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (discard, frame, cookie, op_ret, op_errno, pre, post, xdata);
-        return 0;
+    FOP_CBK(discard, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
 int32_t
 cluster_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                    struct iatt *post, dict_t *xdata)
+                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                     struct iatt *post, dict_t *xdata)
 {
-        FOP_CBK (zerofill, frame, cookie, op_ret, op_errno, pre,
-                 post, xdata);
-        return 0;
+    FOP_CBK(zerofill, frame, cookie, op_ret, op_errno, pre, post, xdata);
+    return 0;
 }
 
-
 int32_t
-cluster_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
+cluster_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        FOP_CBK (ipc, frame, cookie, op_ret, op_errno, xdata);
-        return 0;
+    FOP_CBK(ipc, frame, cookie, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-cluster_fgetxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   const char *name, dict_t *xdata)
-{
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fgetxattr, fd,
-                    name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
-}
-
-int32_t
-cluster_fsetxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                   int32_t flags, dict_t *xdata)
+cluster_fgetxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd,
+                  const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsetxattr, fd,
-                    dict, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fgetxattr, fd,
+               name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_setxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fsetxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
                   default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
                   int32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, setxattr, loc,
-                    dict, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsetxattr, fd,
+               dict, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_statfs (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_setxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                 int32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, statfs, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, setxattr, loc,
+               dict, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsyncdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-                  dict_t *xdata)
+cluster_statfs(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsyncdir, fd,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, statfs, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_opendir (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fsyncdir(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
                  dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, opendir, loc,
-                    fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsyncdir, fd,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fstat (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+cluster_opendir(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fstat, fd,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, opendir, loc,
+               fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsync (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-               dict_t *xdata)
+cluster_fstat(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsync, fd,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fstat, fd,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_flush (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+cluster_fsync(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+              dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, flush, fd,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsync, fd,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_writev (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, fd_t *fd,
-                struct iovec *vector, int32_t count, off_t off, uint32_t flags,
-                struct iobref *iobref, dict_t *xdata)
+cluster_flush(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, writev, fd,
-                    vector, count, off, flags, iobref, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, flush, fd,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_put (xlator_t **subvols, unsigned char *on, int numsubvols,
-             default_args_cbk_t *replies, unsigned char *output,
-             call_frame_t *frame, xlator_t *this, loc_t *loc,
-             mode_t mode, mode_t umask, uint32_t flags, struct iovec *vector,
-             int32_t count, off_t offset, struct iobref *iobref, dict_t *xattr,
-             dict_t *xdata)
+cluster_writev(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, fd_t *fd,
+               struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+               struct iobref *iobref, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, put, loc,
-                    mode, umask, flags, vector, count, offset, iobref, xattr,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, writev, fd,
+               vector, count, off, flags, iobref, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_readv (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-               off_t offset, uint32_t flags, dict_t *xdata)
+cluster_put(xlator_t **subvols, unsigned char *on, int numsubvols,
+            default_args_cbk_t *replies, unsigned char *output,
+            call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
+            off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readv, fd, size,
-                    offset, flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, put, loc, mode,
+               umask, flags, vector, count, offset, iobref, xattr, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_open (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_readv(xlator_t **subvols, unsigned char *on, int numsubvols,
               default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-              fd_t *fd, dict_t *xdata)
+              call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+              off_t offset, uint32_t flags, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, open, loc,
-                    flags, fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readv, fd, size,
+               offset, flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_create (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-                mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+cluster_open(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, create, loc,
-                    flags, mode, umask, fd, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, open, loc,
+               flags, fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_link (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-              dict_t *xdata)
+cluster_create(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+               mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, link, oldloc,
-                    newloc, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, create, loc,
+               flags, mode, umask, fd, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_rename (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-                loc_t *newloc, dict_t *xdata)
+cluster_link(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rename, oldloc,
-                    newloc, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, link, oldloc,
+               newloc, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
+int32_t
+cluster_rename(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+               loc_t *newloc, dict_t *xdata)
+{
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rename, oldloc,
+               newloc, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int
-cluster_symlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, const char *linkpath,
-                 loc_t *loc, mode_t umask, dict_t *xdata)
+cluster_symlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, const char *linkpath,
+                loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, symlink,
-                    linkpath, loc, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, symlink,
+               linkpath, loc, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_rmdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-               dict_t *xdata)
+cluster_rmdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+              dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rmdir, loc,
-                    flags, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rmdir, loc,
+               flags, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_unlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-                dict_t *xdata)
+cluster_unlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+               dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, unlink, loc,
-                    xflag, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, unlink, loc,
+               xflag, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_mkdir (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               mode_t umask, dict_t *xdata)
+cluster_mkdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, mkdir, loc,
-                    mode, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, mkdir, loc,
+               mode, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int
-cluster_mknod (xlator_t **subvols, unsigned char *on, int numsubvols,
-               default_args_cbk_t *replies, unsigned char *output,
-               call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-               dev_t rdev, mode_t umask, dict_t *xdata)
+cluster_mknod(xlator_t **subvols, unsigned char *on, int numsubvols,
+              default_args_cbk_t *replies, unsigned char *output,
+              call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+              dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, mknod, loc,
-                    mode, rdev, umask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, mknod, loc,
+               mode, rdev, umask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_readlink (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-                  dict_t *xdata)
+cluster_readlink(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                 dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readlink, loc,
-                    size, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readlink, loc,
+               size, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_access (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-                dict_t *xdata)
+cluster_access(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+               dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, access, loc,
-                    mask, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, access, loc,
+               mask, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_ftruncate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   dict_t *xdata)
+cluster_ftruncate(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, ftruncate, fd,
-                    offset, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, ftruncate, fd,
+               offset, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_getxattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  const char *name, dict_t *xdata)
+cluster_getxattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, getxattr, loc,
-                    name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, getxattr, loc,
+               name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
+int32_t
+cluster_xattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+{
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, xattrop, loc,
+               flags, dict, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
+}
 
 int32_t
-cluster_xattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fxattrop(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, xattrop, loc,
-                    flags, dict, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fxattrop, fd,
+               flags, dict, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fxattrop (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+cluster_removexattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                    default_args_cbk_t *replies, unsigned char *output,
+                    call_frame_t *frame, xlator_t *this, loc_t *loc,
+                    const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fxattrop, fd,
-                    flags, dict, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, removexattr,
+               loc, name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_removexattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fremovexattr(xlator_t **subvols, unsigned char *on, int numsubvols,
                      default_args_cbk_t *replies, unsigned char *output,
-                     call_frame_t *frame, xlator_t *this, loc_t *loc,
+                     call_frame_t *frame, xlator_t *this, fd_t *fd,
                      const char *name, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, removexattr,
-                    loc, name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fremovexattr,
+               fd, name, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fremovexattr (xlator_t **subvols, unsigned char *on, int numsubvols,
-                      default_args_cbk_t *replies, unsigned char *output,
-                      call_frame_t *frame, xlator_t *this, fd_t *fd,
-                      const char *name, dict_t *xdata)
+cluster_lk(xlator_t **subvols, unsigned char *on, int numsubvols,
+           default_args_cbk_t *replies, unsigned char *output,
+           call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+           struct gf_flock *lock, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fremovexattr,
-                    fd, name, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, lk, fd, cmd,
+               lock, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_lk (xlator_t **subvols, unsigned char *on, int numsubvols,
-            default_args_cbk_t *replies, unsigned char *output,
-            call_frame_t *frame, xlator_t *this, fd_t *fd,
-            int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+cluster_rchecksum(xlator_t **subvols, unsigned char *on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  int32_t len, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, lk, fd, cmd,
-                    lock, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, rchecksum, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_rchecksum (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   int32_t len, dict_t *xdata)
+cluster_readdir(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t off, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, rchecksum, fd,
-                    offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readdir, fd,
+               size, off, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_readdir (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_readdirp(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 size_t size, off_t off, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                 off_t off, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readdir, fd,
-                    size, off, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, readdirp, fd,
+               size, off, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_readdirp (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  size_t size, off_t off, dict_t *xdata)
+cluster_setattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, loc_t *loc,
+                struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, readdirp, fd,
-                    size, off, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, setattr, loc,
+               stbuf, valid, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_setattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_truncate(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, loc_t *loc,
-                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                 dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, setattr, loc,
-                    stbuf, valid, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, truncate, loc,
+               offset, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_truncate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                  default_args_cbk_t *replies, unsigned char *output,
-                  call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-                  dict_t *xdata)
+cluster_stat(xlator_t **subvols, unsigned char *on, int numsubvols,
+             default_args_cbk_t *replies, unsigned char *output,
+             call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, truncate, loc,
-                    offset, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, stat, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_stat (xlator_t **subvols, unsigned char *on, int numsubvols,
-              default_args_cbk_t *replies, unsigned char *output,
-              call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_lookup(xlator_t **subvols, unsigned char *on, int numsubvols,
+               default_args_cbk_t *replies, unsigned char *output,
+               call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, stat, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, lookup, loc,
+               xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_lookup (xlator_t **subvols, unsigned char *on, int numsubvols,
-                default_args_cbk_t *replies, unsigned char *output,
-                call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+cluster_fsetattr(xlator_t **subvols, unsigned char *on, int numsubvols,
+                 default_args_cbk_t *replies, unsigned char *output,
+                 call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, lookup, loc,
-                    xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fsetattr, fd,
+               stbuf, valid, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fsetattr (xlator_t **subvols, unsigned char *on, int numsubvols,
+cluster_fallocate(xlator_t **subvols, unsigned char *on, int numsubvols,
                   default_args_cbk_t *replies, unsigned char *output,
                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  struct iatt *stbuf, int32_t valid, dict_t *xdata)
+                  int32_t keep_size, off_t offset, size_t len, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, fsetattr, fd,
-                    stbuf, valid, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fallocate, fd,
+               keep_size, offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
-cluster_fallocate (xlator_t **subvols, unsigned char *on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   int32_t keep_size, off_t offset, size_t len, dict_t *xdata)
-{
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, fallocate, fd,
-                   keep_size, offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
-}
-
-int32_t
-cluster_discard (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 off_t offset, size_t len, dict_t *xdata)
+cluster_discard(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *output,
+                call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                size_t len, dict_t *xdata)
 {
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, discard, fd,
-                   offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, discard, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int32_t
 cluster_zerofill(xlator_t **subvols, unsigned char *on, int numsubvols,
                  default_args_cbk_t *replies, unsigned char *output,
-                 call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 off_t offset, off_t len, dict_t *xdata)
+                 call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                 off_t len, dict_t *xdata)
 {
-        FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, zerofill, fd,
-                   offset, len, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, zerofill, fd,
+               offset, len, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
-
 int32_t
-cluster_ipc (xlator_t **subvols, unsigned char *on, int numsubvols,
-             default_args_cbk_t *replies, unsigned char *output,
-             call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+cluster_ipc(xlator_t **subvols, unsigned char *on, int numsubvols,
+            default_args_cbk_t *replies, unsigned char *output,
+            call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        FOP_ONLIST (subvols, on, numsubvols, replies, output, frame, ipc, op, xdata);
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    FOP_ONLIST(subvols, on, numsubvols, replies, output, frame, ipc, op, xdata);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_uninodelk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, char *dom,
-                   inode_t *inode, off_t off, size_t size)
+cluster_uninodelk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, off_t off, size_t size)
 {
-        loc_t loc = {0,};
-        struct gf_flock flock = {0, };
-
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        flock.l_type = F_UNLCK;
-        flock.l_start = off;
-        flock.l_len = size;
+    flock.l_type = F_UNLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-        FOP_ONLIST (subvols, locked_on, numsubvols, replies, output, frame, inodelk,
-                    dom, &loc, F_SETLK, &flock, NULL);
+    FOP_ONLIST(subvols, locked_on, numsubvols, replies, output, frame, inodelk,
+               dom, &loc, F_SETLK, &flock, NULL);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_tryinodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, off_t off, size_t size)
+cluster_tryinodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
+                   call_frame_t *frame, xlator_t *this, char *dom,
+                   inode_t *inode, off_t off, size_t size)
 {
-        struct gf_flock flock = {0, };
-        loc_t loc = {0};
+    struct gf_flock flock = {
+        0,
+    };
+    loc_t loc = {0};
 
-        flock.l_type = F_WRLCK;
-        flock.l_start = off;
-        flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
-                    &loc, F_SETLK, &flock, NULL);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_inodelk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, off_t off, size_t size)
-{
-        struct gf_flock flock = {0, };
-        int i = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-
-        flock.l_type = F_WRLCK;
-        flock.l_start = off;
-        flock.l_len = size;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    inodelk, dom, &loc, F_SETLK, &flock, NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_uninodelk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom, inode, off, size);
-
-                        FOP_SEQ (subvols, on, numsubvols, replies, locked_on,
-                                 frame, inodelk, dom, &loc, F_SETLKW, &flock,
-                                 NULL);
-                        break;
-                }
+cluster_inodelk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                off_t off, size_t size)
+{
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_uninodelk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, off, size);
+
+            FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame, inodelk,
+                    dom, &loc, F_SETLKW, &flock, NULL);
+            break;
         }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
-
 int
-cluster_unentrylk (xlator_t **subvols, unsigned char *locked_on, int numsubvols,
-                   default_args_cbk_t *replies, unsigned char *output,
-                   call_frame_t *frame, xlator_t *this, char *dom,
-                   inode_t *inode, const char *name)
+cluster_unentrylk(xlator_t **subvols, unsigned char *locked_on, int numsubvols,
+                  default_args_cbk_t *replies, unsigned char *output,
+                  call_frame_t *frame, xlator_t *this, char *dom,
+                  inode_t *inode, const char *name)
 {
-        loc_t loc = {0,};
-
+    loc_t loc = {
+        0,
+    };
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        FOP_ONLIST (subvols, locked_on, numsubvols, replies, output, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK,
-                    NULL);
+    FOP_ONLIST(subvols, locked_on, numsubvols, replies, output, frame, entrylk,
+               dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return cluster_fop_success_fill (replies, numsubvols, output);
+    return cluster_fop_success_fill(replies, numsubvols, output);
 }
 
 int
-cluster_tryentrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                    default_args_cbk_t *replies, unsigned char *locked_on,
-                    call_frame_t *frame, xlator_t *this, char *dom,
-                    inode_t *inode, const char *name)
+cluster_tryentrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                   default_args_cbk_t *replies, unsigned char *locked_on,
+                   call_frame_t *frame, xlator_t *this, char *dom,
+                   inode_t *inode, const char *name)
 {
-        loc_t loc = {0};
+    loc_t loc = {0};
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_entrylk (xlator_t **subvols, unsigned char *on, int numsubvols,
-                 default_args_cbk_t *replies, unsigned char *locked_on,
-                 call_frame_t *frame, xlator_t *this, char *dom,
-                 inode_t *inode, const char *name)
-{
-        int i = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_unentrylk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom,
-                                           inode, name);
-                        FOP_SEQ (subvols, on, numsubvols, replies,
-                                 locked_on, frame, entrylk, dom, &loc, name,
-                                 ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                        break;
-                }
+cluster_entrylk(xlator_t **subvols, unsigned char *on, int numsubvols,
+                default_args_cbk_t *replies, unsigned char *locked_on,
+                call_frame_t *frame, xlator_t *this, char *dom, inode_t *inode,
+                const char *name)
+{
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_unentrylk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, name);
+            FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame, entrylk,
+                    dom, &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+            break;
         }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_tiebreaker_inodelk (xlator_t **subvols, unsigned char *on,
-                            int numsubvols, default_args_cbk_t *replies,
-                            unsigned char *locked_on, call_frame_t *frame,
-                            xlator_t *this, char *dom, inode_t *inode,
-                            off_t off, size_t size)
-{
-        struct gf_flock flock = {0, };
-        int i = 0;
-        int num_success = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-
-        flock.l_type = F_WRLCK;
-        flock.l_start = off;
-        flock.l_len = size;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    inodelk, dom, &loc, F_SETLK, &flock, NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].valid && replies[i].op_ret == 0) {
-                        num_success++;
-                        continue;
-                }
-
-                /* TODO: If earlier subvols fail with an error other
-                 * than EAGAIN, we could still have 2 clients competing
-                 * for the lock*/
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_uninodelk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom,
-                                           inode, off, size);
-
-                        if (num_success) {
-                                FOP_SEQ (subvols, on, numsubvols, replies,
-                                         locked_on, frame, inodelk, dom, &loc,
-                                         F_SETLKW, &flock, NULL);
-                        }
-                        break;
-                }
+cluster_tiebreaker_inodelk(xlator_t **subvols, unsigned char *on,
+                           int numsubvols, default_args_cbk_t *replies,
+                           unsigned char *locked_on, call_frame_t *frame,
+                           xlator_t *this, char *dom, inode_t *inode, off_t off,
+                           size_t size)
+{
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0;
+    int num_success = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, inodelk, dom,
+               &loc, F_SETLK, &flock, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            num_success++;
+            continue;
         }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+        /* TODO: If earlier subvols fail with an error other
+         * than EAGAIN, we could still have 2 clients competing
+         * for the lock*/
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_uninodelk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, off, size);
+
+            if (num_success) {
+                FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame,
+                        inodelk, dom, &loc, F_SETLKW, &flock, NULL);
+            }
+            break;
+        }
+    }
+
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
 
 int
-cluster_tiebreaker_entrylk (xlator_t **subvols, unsigned char *on,
-                            int numsubvols, default_args_cbk_t *replies,
-                            unsigned char *locked_on, call_frame_t *frame,
-                            xlator_t *this, char *dom, inode_t *inode,
-                            const char *name)
-{
-        int i = 0;
-        loc_t loc = {0};
-        unsigned char *output = NULL;
-        int num_success = 0;
-
-        output = alloca(numsubvols);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        FOP_ONLIST (subvols, on, numsubvols, replies, locked_on, frame,
-                    entrylk, dom, &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                    NULL);
-
-        for (i = 0; i < numsubvols; i++) {
-                if (replies[i].valid && replies[i].op_ret == 0) {
-                        num_success++;
-                        continue;
-                }
-                if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
-                        cluster_fop_success_fill (replies, numsubvols,
-                                                  locked_on);
-                        cluster_unentrylk (subvols, locked_on, numsubvols,
-                                           replies, output, frame, this, dom,
-                                           inode, name);
-                        if (num_success) {
-                                FOP_SEQ (subvols, on, numsubvols, replies,
-                                         locked_on, frame, entrylk, dom, &loc,
-                                         name, ENTRYLK_LOCK, ENTRYLK_WRLCK,
-                                         NULL);
-                        } else {
-                                memset (locked_on, 0, numsubvols);
-                        }
-                        break;
-                }
+cluster_tiebreaker_entrylk(xlator_t **subvols, unsigned char *on,
+                           int numsubvols, default_args_cbk_t *replies,
+                           unsigned char *locked_on, call_frame_t *frame,
+                           xlator_t *this, char *dom, inode_t *inode,
+                           const char *name)
+{
+    int i = 0;
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+    int num_success = 0;
+
+    output = alloca(numsubvols);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    FOP_ONLIST(subvols, on, numsubvols, replies, locked_on, frame, entrylk, dom,
+               &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+    for (i = 0; i < numsubvols; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            num_success++;
+            continue;
+        }
+        if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            cluster_fop_success_fill(replies, numsubvols, locked_on);
+            cluster_unentrylk(subvols, locked_on, numsubvols, replies, output,
+                              frame, this, dom, inode, name);
+            if (num_success) {
+                FOP_SEQ(subvols, on, numsubvols, replies, locked_on, frame,
+                        entrylk, dom, &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK,
+                        NULL);
+            } else {
+                memset(locked_on, 0, numsubvols);
+            }
+            break;
         }
+    }
 
-        loc_wipe (&loc);
-        return cluster_fop_success_fill (replies, numsubvols, locked_on);
+    loc_wipe(&loc);
+    return cluster_fop_success_fill(replies, numsubvols, locked_on);
 }
diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c
index 748772bb21b..aae9858fe22 100644
--- a/libglusterfs/src/common-utils.c
+++ b/libglusterfs/src/common-utils.c
@@ -63,36 +63,41 @@
 #define AI_ADDRCONFIG 0
 #endif /* AI_ADDRCONFIG */
 
-char *vol_type_str[] = {"Distribute",
-                        "Stripe",
-                        "Replicate",
-                        "Striped-Replicate",
-                        "Disperse",
-                        "Tier",
-                        "Distributed-Stripe",
-                        "Distributed-Replicate",
-                        "Distributed-Striped-Replicate",
-                        "Distributed-Disperse",
-                       };
+char *vol_type_str[] = {
+    "Distribute",
+    "Stripe",
+    "Replicate",
+    "Striped-Replicate",
+    "Disperse",
+    "Tier",
+    "Distributed-Stripe",
+    "Distributed-Replicate",
+    "Distributed-Striped-Replicate",
+    "Distributed-Disperse",
+};
 
 typedef int32_t (*rw_op_t)(int32_t fd, char *buf, int32_t size);
 typedef int32_t (*rwv_op_t)(int32_t fd, const struct iovec *buf, int32_t size);
 
 void
-gf_xxh64_wrapper(const unsigned char *data, size_t const len, unsigned long long const seed,
-                 char *xxh64)
+gf_xxh64_wrapper(const unsigned char *data, size_t const len,
+                 unsigned long long const seed, char *xxh64)
 {
-        unsigned short         i      = 0;
-        const unsigned short   lim    = GF_XXH64_DIGEST_LENGTH*2+1;
-        XXH64_hash_t           hash   = 0;
-        XXH64_canonical_t      c_hash = {{0,},};
-        const uint8_t          *p     = (const uint8_t *) &c_hash;
+    unsigned short i = 0;
+    const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1;
+    XXH64_hash_t hash = 0;
+    XXH64_canonical_t c_hash = {
+        {
+            0,
+        },
+    };
+    const uint8_t *p = (const uint8_t *)&c_hash;
 
-        hash = XXH64(data, len, seed);
-        XXH64_canonicalFromHash(&c_hash, hash);
+    hash = XXH64(data, len, seed);
+    XXH64_canonicalFromHash(&c_hash, hash);
 
-        for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
-                snprintf(xxh64 + i * 2, lim-i*2, "%02x", p[i]);
+    for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
+        snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]);
 }
 
 /**
@@ -133,34 +138,35 @@ gf_xxh64_wrapper(const unsigned char *data, size_t const len, unsigned long long
  *      tmp[15] = (hash_1) & 0xff;
  **/
 static int
-gf_gfid_from_xxh64 (xlator_t *this, uuid_t gfid, XXH64_hash_t hash,
-                    unsigned short index)
-{
-        int ret = -1;
-        int i   = -1;
-
-        if ((index != 0) && (index != 8)) {
-                gf_msg_callingfn ("gfid-from-xxh64", GF_LOG_WARNING, 0,
-                                  LG_MSG_INDEX_NOT_FOUND,
-                                  "index can only be either 0 or 8, as this"
-                                  "function's purpose is to encode a 8 byte "
-                                  "hash inside the gfid (index: %d)", index);
-                goto out;
-        }
-
-        for (i = 0; i < sizeof (hash); i++) {
-                /*
-                 * As of now the below statement is equivalent of this.
-                 * gfid[index+i] = (hash >> (64 - (8 * (i+1)))) & 0xff;
-                 */
-                gfid[index+i] = (hash >> ((sizeof (hash) * 8) - (8 * (i+1))))
-                                & (0xff);
-        }
+gf_gfid_from_xxh64(xlator_t *this, uuid_t gfid, XXH64_hash_t hash,
+                   unsigned short index)
+{
+    int ret = -1;
+    int i = -1;
+
+    if ((index != 0) && (index != 8)) {
+        gf_msg_callingfn("gfid-from-xxh64", GF_LOG_WARNING, 0,
+                         LG_MSG_INDEX_NOT_FOUND,
+                         "index can only be either 0 or 8, as this"
+                         "function's purpose is to encode a 8 byte "
+                         "hash inside the gfid (index: %d)",
+                         index);
+        goto out;
+    }
+
+    for (i = 0; i < sizeof(hash); i++) {
+        /*
+         * As of now the below statement is equivalent of this.
+         * gfid[index+i] = (hash >> (64 - (8 * (i+1)))) & 0xff;
+         */
+        gfid[index + i] = (hash >> ((sizeof(hash) * 8) - (8 * (i + 1)))) &
+                          (0xff);
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -177,22 +183,26 @@ out:
  *   of the hash).
  **/
 XXH64_hash_t
-gf_xxh64_hash_wrapper (const unsigned char *data, size_t const len,
-                       unsigned long long const seed, char *xxh64)
+gf_xxh64_hash_wrapper(const unsigned char *data, size_t const len,
+                      unsigned long long const seed, char *xxh64)
 {
-        unsigned short         i      = 0;
-        const unsigned short   lim    = GF_XXH64_DIGEST_LENGTH*2+1;
-        XXH64_hash_t           hash   = 0;
-        XXH64_canonical_t      c_hash = {{0,},};
-        const uint8_t          *p     = (const uint8_t *)&c_hash;
+    unsigned short i = 0;
+    const unsigned short lim = GF_XXH64_DIGEST_LENGTH * 2 + 1;
+    XXH64_hash_t hash = 0;
+    XXH64_canonical_t c_hash = {
+        {
+            0,
+        },
+    };
+    const uint8_t *p = (const uint8_t *)&c_hash;
 
-        hash = XXH64(data, len, seed);
-        XXH64_canonicalFromHash (&c_hash, hash);
+    hash = XXH64(data, len, seed);
+    XXH64_canonicalFromHash(&c_hash, hash);
 
-        for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
-                snprintf (xxh64 + i * 2, lim-i*2, "%02x", p[i]);
+    for (i = 0; i < GF_XXH64_DIGEST_LENGTH; i++)
+        snprintf(xxh64 + i * 2, lim - i * 2, "%02x", p[i]);
 
-        return hash;
+    return hash;
 }
 
 /**
@@ -220,152 +230,165 @@ gf_xxh64_hash_wrapper (const unsigned char *data, size_t const len,
  * one 16 byte entity.
  **/
 int
-gf_gfid_generate_from_xxh64 (uuid_t gfid, char *key)
-{
-        char xxh64_1[GF_XXH64_DIGEST_LENGTH*2+1] = {0, };
-        char xxh64_2[GF_XXH64_DIGEST_LENGTH*2+1] = {0, };
-        XXH64_hash_t hash_1                      = 0;
-        XXH64_hash_t hash_2                      = 0;
-        int          ret                         = -1;
-        xlator_t    *this                        = THIS;
-
-        hash_1 = gf_xxh64_hash_wrapper((unsigned char *)key,
-                                       strlen (key), GF_XXHSUM64_DEFAULT_SEED,
-                                       xxh64_1);
-
-        hash_2 = gf_xxh64_hash_wrapper((unsigned char *)xxh64_1,
-                                       strlen (xxh64_1),
-                                       GF_XXHSUM64_DEFAULT_SEED, xxh64_2);
-
-        /* hash_2 is saved in 1st 8 elements of uuid_t char array */
-        if (gf_gfid_from_xxh64 (this, gfid, hash_2, 0)) {
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_XXH64_TO_GFID_FAILED,
-                                  "failed to encode the hash %llx into the 1st"
-                                  "half of gfid", hash_2);
-                goto out;
-        }
-
-        /* hash_1 is saved in the remaining 8 elements of uuid_t */
-        if (gf_gfid_from_xxh64 (this, gfid, hash_1, 8)) {
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_XXH64_TO_GFID_FAILED,
-                                  "failed to encode the hash %llx into the 2nd"
-                                  "half of gfid", hash_1);
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0, "gfid generated is %s (hash1: %llx) "
-                      "hash2: %llx, xxh64_1: %s xxh64_2: %s", uuid_utoa (gfid),
-                      hash_1, hash_2, xxh64_1, xxh64_2);
-
-        ret = 0;
+gf_gfid_generate_from_xxh64(uuid_t gfid, char *key)
+{
+    char xxh64_1[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    char xxh64_2[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    XXH64_hash_t hash_1 = 0;
+    XXH64_hash_t hash_2 = 0;
+    int ret = -1;
+    xlator_t *this = THIS;
+
+    hash_1 = gf_xxh64_hash_wrapper((unsigned char *)key, strlen(key),
+                                   GF_XXHSUM64_DEFAULT_SEED, xxh64_1);
+
+    hash_2 = gf_xxh64_hash_wrapper((unsigned char *)xxh64_1, strlen(xxh64_1),
+                                   GF_XXHSUM64_DEFAULT_SEED, xxh64_2);
+
+    /* hash_2 is saved in 1st 8 elements of uuid_t char array */
+    if (gf_gfid_from_xxh64(this, gfid, hash_2, 0)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         LG_MSG_XXH64_TO_GFID_FAILED,
+                         "failed to encode the hash %llx into the 1st"
+                         "half of gfid",
+                         hash_2);
+        goto out;
+    }
+
+    /* hash_1 is saved in the remaining 8 elements of uuid_t */
+    if (gf_gfid_from_xxh64(this, gfid, hash_1, 8)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         LG_MSG_XXH64_TO_GFID_FAILED,
+                         "failed to encode the hash %llx into the 2nd"
+                         "half of gfid",
+                         hash_1);
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "gfid generated is %s (hash1: %llx) "
+                 "hash2: %llx, xxh64_1: %s xxh64_2: %s",
+                 uuid_utoa(gfid), hash_1, hash_2, xxh64_1, xxh64_2);
+
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 /* works similar to mkdir(1) -p.
  */
 int
-mkdir_p (char *path, mode_t mode, gf_boolean_t allow_symlinks)
-{
-        int             i               = 0;
-        int             ret             = -1;
-        char            dir[PATH_MAX]   = {0,};
-        struct stat     stbuf           = {0,};
-
-        const int path_len = min(strlen(path), PATH_MAX -1);
-
-        snprintf(dir, path_len + 1, "%s", path);
-
-        i = (dir[0] == '/')? 1: 0;
-        do {
-                if (path[i] != '/' && path[i] != '\0')
-                        continue;
-
-                dir[i] = '\0';
-                ret = sys_mkdir (dir, mode);
-                if (ret && errno != EEXIST) {
-                        gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-                                "Failed due to reason");
-                        goto out;
-                }
-
-                if (ret && errno == EEXIST && !allow_symlinks) {
-                        ret = sys_lstat (dir, &stbuf);
-                        if (ret)
-                                goto out;
-
-                        if (S_ISLNK (stbuf.st_mode)) {
-                                ret = -1;
-                                gf_msg ("", GF_LOG_ERROR, 0,
-                                        LG_MSG_DIR_IS_SYMLINK, "%s is a "
-                                        "symlink", dir);
-                                goto out;
-                        }
-                }
-                dir[i] = '/';
-
-        } while (path[i++] != '\0');
-
-        ret = sys_stat (dir, &stbuf);
-        if (ret || !S_ISDIR (stbuf.st_mode)) {
-                if (ret == 0)
-                        errno = 0;
+mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks)
+{
+    int i = 0;
+    int ret = -1;
+    char dir[PATH_MAX] = {
+        0,
+    };
+    struct stat stbuf = {
+        0,
+    };
+
+    const int path_len = min(strlen(path), PATH_MAX - 1);
+
+    snprintf(dir, path_len + 1, "%s", path);
+
+    i = (dir[0] == '/') ? 1 : 0;
+    do {
+        if (path[i] != '/' && path[i] != '\0')
+            continue;
+
+        dir[i] = '\0';
+        ret = sys_mkdir(dir, mode);
+        if (ret && errno != EEXIST) {
+            gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                   "Failed due to reason");
+            goto out;
+        }
+
+        if (ret && errno == EEXIST && !allow_symlinks) {
+            ret = sys_lstat(dir, &stbuf);
+            if (ret)
+                goto out;
+
+            if (S_ISLNK(stbuf.st_mode)) {
                 ret = -1;
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "Failed"
-                        " to create directory, possibly some of the components"
-                        " were not directories");
+                gf_msg("", GF_LOG_ERROR, 0, LG_MSG_DIR_IS_SYMLINK,
+                       "%s is a "
+                       "symlink",
+                       dir);
                 goto out;
+            }
         }
+        dir[i] = '/';
 
-        ret = 0;
+    } while (path[i++] != '\0');
+
+    ret = sys_stat(dir, &stbuf);
+    if (ret || !S_ISDIR(stbuf.st_mode)) {
+        if (ret == 0)
+            errno = 0;
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "Failed"
+               " to create directory, possibly some of the components"
+               " were not directories");
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int
-gf_lstat_dir (const char *path, struct stat *stbuf_in)
+gf_lstat_dir(const char *path, struct stat *stbuf_in)
 {
-        int ret           = -1;
-        struct stat stbuf = {0,};
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
 
-        if (path == NULL) {
-                errno = EINVAL;
-                goto out;
-        }
+    if (path == NULL) {
+        errno = EINVAL;
+        goto out;
+    }
 
-        ret = sys_lstat (path, &stbuf);
-        if (ret)
-                goto out;
+    ret = sys_lstat(path, &stbuf);
+    if (ret)
+        goto out;
 
-        if (!S_ISDIR (stbuf.st_mode)) {
-                errno = ENOTDIR;
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+    if (!S_ISDIR(stbuf.st_mode)) {
+        errno = ENOTDIR;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        if (!ret && stbuf_in)
-                *stbuf_in = stbuf;
+    if (!ret && stbuf_in)
+        *stbuf_in = stbuf;
 
-        return ret;
+    return ret;
 }
 
 int
-log_base2 (unsigned long x)
+log_base2(unsigned long x)
 {
-        int val = 0;
+    int val = 0;
 
-        while (x > 1) {
-                x /= 2;
-                val++;
-        }
+    while (x > 1) {
+        x /= 2;
+        val++;
+    }
 
-        return val;
+    return val;
 }
 
 /**
@@ -377,22 +400,23 @@ log_base2 (unsigned long x)
  *          failure: NULL
  */
 char *
-gf_rev_dns_lookup (const char *ip)
+gf_rev_dns_lookup(const char *ip)
 {
-        char               *fqdn = NULL;
-        int                ret  = 0;
+    char *fqdn = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("resolver", ip, out);
+    GF_VALIDATE_OR_GOTO("resolver", ip, out);
 
-        /* Get the FQDN */
-        ret =  gf_get_hostname_from_ip ((char *)ip, &fqdn);
-        if (ret != 0) {
-                gf_msg ("resolver", GF_LOG_INFO, errno,
-                        LG_MSG_RESOLVE_HOSTNAME_FAILED, "could not resolve "
-                        "hostname for %s", ip);
-        }
+    /* Get the FQDN */
+    ret = gf_get_hostname_from_ip((char *)ip, &fqdn);
+    if (ret != 0) {
+        gf_msg("resolver", GF_LOG_INFO, errno, LG_MSG_RESOLVE_HOSTNAME_FAILED,
+               "could not resolve "
+               "hostname for %s",
+               ip);
+    }
 out:
-       return fqdn;
+    return fqdn;
 }
 
 /**
@@ -402,144 +426,145 @@ out:
  * @return: The parent path if found, NULL otherwise
  */
 char *
-gf_resolve_path_parent (const char *path)
+gf_resolve_path_parent(const char *path)
 {
-        char    *parent = NULL;
-        char    *tmp    = NULL;
-        char    *pathc  = NULL;
+    char *parent = NULL;
+    char *tmp = NULL;
+    char *pathc = NULL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, path, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, path, out);
 
-        if (strlen (path) <= 0) {
-                gf_msg_callingfn (THIS->name, GF_LOG_DEBUG, 0,
-                                  LG_MSG_INVALID_STRING,
-                                  "invalid string for 'path'");
-                goto out;
-        }
+    if (strlen(path) <= 0) {
+        gf_msg_callingfn(THIS->name, GF_LOG_DEBUG, 0, LG_MSG_INVALID_STRING,
+                         "invalid string for 'path'");
+        goto out;
+    }
 
-        /* dup the parameter, we don't want to modify it */
-        pathc = strdupa (path);
-        if (!pathc) {
-                goto out;
-        }
+    /* dup the parameter, we don't want to modify it */
+    pathc = strdupa(path);
+    if (!pathc) {
+        goto out;
+    }
 
-        /* Get the parent directory */
-        tmp = dirname (pathc);
-        if (strcmp (tmp, "/") == 0)
-                goto out;
+    /* Get the parent directory */
+    tmp = dirname(pathc);
+    if (strcmp(tmp, "/") == 0)
+        goto out;
 
-        parent = gf_strdup (tmp);
+    parent = gf_strdup(tmp);
 out:
-        return parent;
+    return parent;
 }
 
 int32_t
-gf_resolve_ip6 (const char *hostname,
-                uint16_t port,
-                int family,
-                void **dnscache,
-                struct addrinfo **addr_info)
-{
-        int32_t ret = 0;
-        struct addrinfo hints;
-        struct dnscache6 *cache = NULL;
-        char service[NI_MAXSERV], host[NI_MAXHOST];
-
-        if (!hostname) {
-                gf_msg_callingfn ("resolver", GF_LOG_WARNING, 0,
-                                  LG_MSG_HOSTNAME_NULL, "hostname is NULL");
-                return -1;
-        }
+gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
+               struct addrinfo **addr_info)
+{
+    int32_t ret = 0;
+    struct addrinfo hints;
+    struct dnscache6 *cache = NULL;
+    char service[NI_MAXSERV], host[NI_MAXHOST];
 
-        if (!*dnscache) {
-                *dnscache = GF_CALLOC (1, sizeof (struct dnscache6),
-                                       gf_common_mt_dnscache6);
-                if (!*dnscache)
-                        return -1;
-        }
+    if (!hostname) {
+        gf_msg_callingfn("resolver", GF_LOG_WARNING, 0, LG_MSG_HOSTNAME_NULL,
+                         "hostname is NULL");
+        return -1;
+    }
+
+    if (!*dnscache) {
+        *dnscache = GF_CALLOC(1, sizeof(struct dnscache6),
+                              gf_common_mt_dnscache6);
+        if (!*dnscache)
+            return -1;
+    }
+
+    cache = *dnscache;
+    if (cache->first && !cache->next) {
+        freeaddrinfo(cache->first);
+        cache->first = cache->next = NULL;
+        gf_msg_trace("resolver", 0, "flushing DNS cache");
+    }
 
-        cache = *dnscache;
-        if (cache->first && !cache->next) {
-                freeaddrinfo(cache->first);
-                cache->first = cache->next = NULL;
-                gf_msg_trace ("resolver", 0, "flushing DNS cache");
-        }
+    if (!cache->first) {
+        char *port_str = NULL;
+        gf_msg_trace("resolver", 0,
+                     "DNS cache not present, freshly "
+                     "probing hostname: %s",
+                     hostname);
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = family;
+        hints.ai_socktype = SOCK_STREAM;
 
-        if (!cache->first) {
-                char *port_str = NULL;
-                gf_msg_trace ("resolver", 0, "DNS cache not present, freshly "
-                              "probing hostname: %s", hostname);
-
-                memset(&hints, 0, sizeof(hints));
-                hints.ai_family   = family;
-                hints.ai_socktype = SOCK_STREAM;
-
-                ret = gf_asprintf (&port_str, "%d", port);
-                if (-1 == ret) {
-                        return -1;
-                }
-                if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETADDRINFO_FAILED, "getaddrinfo failed"
-                                " (%s)", gai_strerror (ret));
-
-                        GF_FREE (*dnscache);
-                        *dnscache = NULL;
-                        GF_FREE (port_str);
-                        return -1;
-                }
-                GF_FREE (port_str);
-
-                cache->next = cache->first;
+        ret = gf_asprintf(&port_str, "%d", port);
+        if (-1 == ret) {
+            return -1;
         }
+        if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) !=
+            0) {
+            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+                   "getaddrinfo failed"
+                   " (%s)",
+                   gai_strerror(ret));
 
-        if (cache->next) {
-                ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
-                                  cache->next->ai_addrlen,
-                                  host, sizeof (host),
-                                  service, sizeof (service),
-                                  NI_NUMERICHOST);
-                if (ret != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed"
-                                " (%s)", gai_strerror (ret));
-                        goto err;
-                }
-
-                gf_msg_debug ("resolver", 0, "returning ip-%s (port-%s) for "
-                              "hostname: %s and port: %d", host, service,
-                              hostname, port);
-
-                *addr_info = cache->next;
+            GF_FREE(*dnscache);
+            *dnscache = NULL;
+            GF_FREE(port_str);
+            return -1;
         }
+        GF_FREE(port_str);
+
+        cache->next = cache->first;
+    }
 
-        if (cache->next)
-                cache->next = cache->next->ai_next;
-        if (cache->next) {
-                ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
-                                  cache->next->ai_addrlen,
-                                  host, sizeof (host),
-                                  service, sizeof (service),
-                                  NI_NUMERICHOST);
-                if (ret != 0) {
-                        gf_msg ("resolver", GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo failed"
-                                " (%s)", gai_strerror (ret));
-                        goto err;
-                }
-
-                gf_msg_debug ("resolver", 0, "next DNS query will return: "
-                              "ip-%s port-%s", host, service);
+    if (cache->next) {
+        ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
+                          cache->next->ai_addrlen, host, sizeof(host), service,
+                          sizeof(service), NI_NUMERICHOST);
+        if (ret != 0) {
+            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                   "getnameinfo failed"
+                   " (%s)",
+                   gai_strerror(ret));
+            goto err;
+        }
+
+        gf_msg_debug("resolver", 0,
+                     "returning ip-%s (port-%s) for "
+                     "hostname: %s and port: %d",
+                     host, service, hostname, port);
+
+        *addr_info = cache->next;
+    }
+
+    if (cache->next)
+        cache->next = cache->next->ai_next;
+    if (cache->next) {
+        ret = getnameinfo((struct sockaddr *)cache->next->ai_addr,
+                          cache->next->ai_addrlen, host, sizeof(host), service,
+                          sizeof(service), NI_NUMERICHOST);
+        if (ret != 0) {
+            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                   "getnameinfo failed"
+                   " (%s)",
+                   gai_strerror(ret));
+            goto err;
         }
 
-        return 0;
+        gf_msg_debug("resolver", 0,
+                     "next DNS query will return: "
+                     "ip-%s port-%s",
+                     host, service);
+    }
+
+    return 0;
 
 err:
-        freeaddrinfo (cache->first);
-        cache->first = cache->next = NULL;
-        GF_FREE (cache);
-        *dnscache = NULL;
-        return -1;
+    freeaddrinfo(cache->first);
+    cache->first = cache->next = NULL;
+    GF_FREE(cache);
+    *dnscache = NULL;
+    return -1;
 }
 
 /**
@@ -551,16 +576,15 @@ err:
  *          FAILURE: NULL
  */
 struct dnscache *
-gf_dnscache_init (time_t ttl)
+gf_dnscache_init(time_t ttl)
 {
-        struct dnscache *cache = GF_MALLOC (sizeof (*cache),
-                                            gf_common_mt_dnscache);
-        if (cache) {
-                cache->cache_dict = NULL;
-                cache->ttl = ttl;
-        }
+    struct dnscache *cache = GF_MALLOC(sizeof(*cache), gf_common_mt_dnscache);
+    if (cache) {
+        cache->cache_dict = NULL;
+        cache->ttl = ttl;
+    }
 
-        return cache;
+    return cache;
 }
 
 /**
@@ -570,11 +594,11 @@ gf_dnscache_init (time_t ttl)
  *          FAILURE: NULL
  */
 struct dnscache_entry *
-gf_dnscache_entry_init ()
+gf_dnscache_entry_init()
 {
-        struct dnscache_entry *entry = GF_CALLOC (1, sizeof (*entry),
-                                                 gf_common_mt_dnscache_entry);
-        return entry;
+    struct dnscache_entry *entry = GF_CALLOC(1, sizeof(*entry),
+                                             gf_common_mt_dnscache_entry);
+    return entry;
 }
 
 /**
@@ -583,11 +607,11 @@ gf_dnscache_entry_init ()
  * @entry: Pointer to deallocate
  */
 void
-gf_dnscache_entry_deinit (struct dnscache_entry *entry)
+gf_dnscache_entry_deinit(struct dnscache_entry *entry)
 {
-        GF_FREE (entry->ip);
-        GF_FREE (entry->fqdn);
-        GF_FREE (entry);
+    GF_FREE(entry->ip);
+    GF_FREE(entry->fqdn);
+    GF_FREE(entry);
 }
 
 /**
@@ -599,1466 +623,1448 @@ gf_dnscache_entry_deinit (struct dnscache_entry *entry)
  *          failure: NULL
  */
 char *
-gf_rev_dns_lookup_cached (const char *ip, struct dnscache *dnscache)
+gf_rev_dns_lookup_cached(const char *ip, struct dnscache *dnscache)
 {
-        char               *fqdn = NULL;
-        int                ret  = 0;
-        dict_t             *cache = NULL;
-        data_t             *entrydata = NULL;
-        struct dnscache_entry *dnsentry = NULL;
-        gf_boolean_t        from_cache = _gf_false;
+    char *fqdn = NULL;
+    int ret = 0;
+    dict_t *cache = NULL;
+    data_t *entrydata = NULL;
+    struct dnscache_entry *dnsentry = NULL;
+    gf_boolean_t from_cache = _gf_false;
 
-        if (!dnscache)
-                goto out;
+    if (!dnscache)
+        goto out;
 
+    if (!dnscache->cache_dict) {
+        dnscache->cache_dict = dict_new();
         if (!dnscache->cache_dict) {
-                dnscache->cache_dict = dict_new ();
-                if (!dnscache->cache_dict) {
-                        goto out;
-                }
-        }
-        cache = dnscache->cache_dict;
-
-        /* Quick cache lookup to see if we already hold it */
-        entrydata = dict_get (cache, (char *)ip);
-        if (entrydata) {
-                dnsentry = (struct dnscache_entry *)entrydata->data;
-                /* First check the TTL & timestamp */
-                if (time (NULL) - dnsentry->timestamp > dnscache->ttl) {
-                        gf_dnscache_entry_deinit (dnsentry);
-                        entrydata->data = NULL; /* Mark this as 'null' so
-                                                 * dict_del () doesn't try free
-                                                 * this after we've already
-                                                 * freed it.
-                                                 */
-
-                        dict_del (cache, (char *)ip); /* Remove this entry */
-                } else {
-                        /* Cache entry is valid, get the FQDN and return */
-                        fqdn = dnsentry->fqdn;
-                        from_cache = _gf_true; /* Mark this as from cache */
-                        goto out;
-                }
+            goto out;
+        }
+    }
+    cache = dnscache->cache_dict;
+
+    /* Quick cache lookup to see if we already hold it */
+    entrydata = dict_get(cache, (char *)ip);
+    if (entrydata) {
+        dnsentry = (struct dnscache_entry *)entrydata->data;
+        /* First check the TTL & timestamp */
+        if (time(NULL) - dnsentry->timestamp > dnscache->ttl) {
+            gf_dnscache_entry_deinit(dnsentry);
+            entrydata->data = NULL; /* Mark this as 'null' so
+                                     * dict_del () doesn't try free
+                                     * this after we've already
+                                     * freed it.
+                                     */
+
+            dict_del(cache, (char *)ip); /* Remove this entry */
+        } else {
+            /* Cache entry is valid, get the FQDN and return */
+            fqdn = dnsentry->fqdn;
+            from_cache = _gf_true; /* Mark this as from cache */
+            goto out;
         }
+    }
 
-        /* Get the FQDN */
-        ret =  gf_get_hostname_from_ip ((char *)ip, &fqdn);
-        if (ret != 0)
-                goto out;
+    /* Get the FQDN */
+    ret = gf_get_hostname_from_ip((char *)ip, &fqdn);
+    if (ret != 0)
+        goto out;
 
-        if (!fqdn) {
-                gf_log_callingfn ("resolver", GF_LOG_CRITICAL,
-                                  "Allocation failed for the host address");
-                goto out;
-        }
+    if (!fqdn) {
+        gf_log_callingfn("resolver", GF_LOG_CRITICAL,
+                         "Allocation failed for the host address");
+        goto out;
+    }
 
-        from_cache = _gf_false;
+    from_cache = _gf_false;
 out:
-        /* Insert into the cache */
-        if (fqdn && !from_cache) {
-                struct dnscache_entry *entry = gf_dnscache_entry_init ();
-
-                if (!entry) {
-                        goto out;
-                }
-                entry->fqdn = fqdn;
-                if (!ip) {
-                        gf_dnscache_entry_deinit (entry);
-                        goto out;
-                }
-
-                entry->ip = gf_strdup (ip);
-                entry->timestamp = time (NULL);
-
-                entrydata = bin_to_data (entry, sizeof (*entry));
-                dict_set (cache, (char *)ip, entrydata);
+    /* Insert into the cache */
+    if (fqdn && !from_cache) {
+        struct dnscache_entry *entry = gf_dnscache_entry_init();
+
+        if (!entry) {
+            goto out;
         }
-        return fqdn;
+        entry->fqdn = fqdn;
+        if (!ip) {
+            gf_dnscache_entry_deinit(entry);
+            goto out;
+        }
+
+        entry->ip = gf_strdup(ip);
+        entry->timestamp = time(NULL);
+
+        entrydata = bin_to_data(entry, sizeof(*entry));
+        dict_set(cache, (char *)ip, entrydata);
+    }
+    return fqdn;
 }
 
 struct xldump {
-	int lineno;
+    int lineno;
 };
 
 /* to catch any format discrepencies that may arise in code */
-static int nprintf (struct xldump *dump, const char *fmt, ...)
-                    __attribute__ ((__format__ (__printf__, 2, 3)));
 static int
-nprintf (struct xldump *dump, const char *fmt, ...)
+nprintf(struct xldump *dump, const char *fmt, ...)
+    __attribute__((__format__(__printf__, 2, 3)));
+static int
+nprintf(struct xldump *dump, const char *fmt, ...)
 {
-        va_list  ap;
-        char    *msg = NULL;
-        char     header[32];
-        int      ret = 0;
+    va_list ap;
+    char *msg = NULL;
+    char header[32];
+    int ret = 0;
 
-        ret = snprintf (header, 32, "%3d:", ++dump->lineno);
-        if (ret < 0)
-                goto out;
+    ret = snprintf(header, 32, "%3d:", ++dump->lineno);
+    if (ret < 0)
+        goto out;
 
-        va_start (ap, fmt);
-        ret = vasprintf (&msg, fmt, ap);
-        va_end (ap);
-        if (-1 == ret)
-                goto out;
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret)
+        goto out;
 
-        /* NOTE: No ret value from gf_msg_plain, so unable to compute printed
-         * characters. The return value from nprintf is not used, so for now
-         * living with it */
-        gf_msg_plain (GF_LOG_WARNING, "%s %s", header, msg);
+    /* NOTE: No ret value from gf_msg_plain, so unable to compute printed
+     * characters. The return value from nprintf is not used, so for now
+     * living with it */
+    gf_msg_plain(GF_LOG_WARNING, "%s %s", header, msg);
 
 out:
-        FREE (msg);
-        return 0;
+    FREE(msg);
+    return 0;
 }
 
-
 static int
-xldump_options (dict_t *this, char *key, data_t *value,	void *d)
+xldump_options(dict_t *this, char *key, data_t *value, void *d)
 {
-	nprintf (d, "    option %s %s", key, value->data);
-	return 0;
+    nprintf(d, "    option %s %s", key, value->data);
+    return 0;
 }
 
-
 static void
-xldump_subvolumes (xlator_t *this, void *d)
+xldump_subvolumes(xlator_t *this, void *d)
 {
-	xlator_list_t *subv = NULL;
-	int len = 0;
-	char *subvstr = NULL;
+    xlator_list_t *subv = NULL;
+    int len = 0;
+    char *subvstr = NULL;
 
-	subv = this->children;
-	if (!this->children)
-		return;
+    subv = this->children;
+    if (!this->children)
+        return;
 
-	for (subv = this->children; subv; subv = subv->next)
-		len += (strlen (subv->xlator->name) + 1);
+    for (subv = this->children; subv; subv = subv->next)
+        len += (strlen(subv->xlator->name) + 1);
 
-	subvstr = GF_MALLOC (len, gf_common_mt_strdup);
+    subvstr = GF_MALLOC(len, gf_common_mt_strdup);
 
-	len = 0;
-	for (subv = this->children; subv; subv= subv->next)
-		len += sprintf (subvstr + len, "%s%s", subv->xlator->name,
-				subv->next ? " " : "");
+    len = 0;
+    for (subv = this->children; subv; subv = subv->next)
+        len += sprintf(subvstr + len, "%s%s", subv->xlator->name,
+                       subv->next ? " " : "");
 
-	nprintf (d, "    subvolumes %s", subvstr);
+    nprintf(d, "    subvolumes %s", subvstr);
 
-	GF_FREE (subvstr);
+    GF_FREE(subvstr);
 }
 
-
 static void
-xldump (xlator_t *each, void *d)
+xldump(xlator_t *each, void *d)
 {
-	nprintf (d, "volume %s", each->name);
-	nprintf (d, "    type %s", each->type);
-	dict_foreach (each->options, xldump_options, d);
+    nprintf(d, "volume %s", each->name);
+    nprintf(d, "    type %s", each->type);
+    dict_foreach(each->options, xldump_options, d);
 
-	xldump_subvolumes (each, d);
+    xldump_subvolumes(each, d);
 
-	nprintf (d, "end-volume");
-	nprintf (d, " ");
+    nprintf(d, "end-volume");
+    nprintf(d, " ");
 }
 
-
 void
-gf_log_dump_graph (FILE *specfp, glusterfs_graph_t *graph)
+gf_log_dump_graph(FILE *specfp, glusterfs_graph_t *graph)
 {
-	struct xldump xld = {0, };
+    struct xldump xld = {
+        0,
+    };
 
-        gf_msg_plain (GF_LOG_WARNING, "Final graph:");
-        gf_msg_plain (GF_LOG_WARNING,
-                      "+---------------------------------------"
-                      "---------------------------------------+");
+    gf_msg_plain(GF_LOG_WARNING, "Final graph:");
+    gf_msg_plain(GF_LOG_WARNING,
+                 "+---------------------------------------"
+                 "---------------------------------------+");
 
-	xlator_foreach_depth_first (graph->top, xldump, &xld);
+    xlator_foreach_depth_first(graph->top, xldump, &xld);
 
-        gf_msg_plain (GF_LOG_WARNING,
-                      "+---------------------------------------"
-                      "---------------------------------------+");
+    gf_msg_plain(GF_LOG_WARNING,
+                 "+---------------------------------------"
+                 "---------------------------------------+");
 }
 
 static void
-gf_dump_config_flags ()
+gf_dump_config_flags()
 {
-        gf_msg_plain_nomem (GF_LOG_ALERT, "configuration details:");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "configuration details:");
 
 /* have argp */
 #ifdef HAVE_ARGP
-        gf_msg_plain_nomem (GF_LOG_ALERT, "argp 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "argp 1");
 #endif
 
 /* ifdef if found backtrace */
 #ifdef HAVE_BACKTRACE
-        gf_msg_plain_nomem (GF_LOG_ALERT, "backtrace 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "backtrace 1");
 #endif
 
 /* Berkeley-DB version has cursor->get() */
 #ifdef HAVE_BDB_CURSOR_GET
-        gf_msg_plain_nomem (GF_LOG_ALERT, "bdb->cursor->get 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "bdb->cursor->get 1");
 #endif
 
 /* Define to 1 if you have the <db.h> header file. */
 #ifdef HAVE_DB_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "db.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "db.h 1");
 #endif
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #ifdef HAVE_DLFCN_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "dlfcn 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "dlfcn 1");
 #endif
 
 /* define if fdatasync exists */
 #ifdef HAVE_FDATASYNC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "fdatasync 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "fdatasync 1");
 #endif
 
 /* Define to 1 if you have the `pthread' library (-lpthread). */
 #ifdef HAVE_LIBPTHREAD
-        gf_msg_plain_nomem (GF_LOG_ALERT, "libpthread 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "libpthread 1");
 #endif
 
 /* define if llistxattr exists */
 #ifdef HAVE_LLISTXATTR
-        gf_msg_plain_nomem (GF_LOG_ALERT, "llistxattr 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "llistxattr 1");
 #endif
 
 /* define if found setfsuid setfsgid */
 #ifdef HAVE_SET_FSID
-        gf_msg_plain_nomem (GF_LOG_ALERT, "setfsid 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "setfsid 1");
 #endif
 
 /* define if found spinlock */
 #ifdef HAVE_SPINLOCK
-        gf_msg_plain_nomem (GF_LOG_ALERT, "spinlock 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "spinlock 1");
 #endif
 
 /* Define to 1 if you have the <sys/epoll.h> header file. */
 #ifdef HAVE_SYS_EPOLL_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "epoll.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "epoll.h 1");
 #endif
 
 /* Define to 1 if you have the <sys/extattr.h> header file. */
 #ifdef HAVE_SYS_EXTATTR_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "extattr.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "extattr.h 1");
 #endif
 
 /* Define to 1 if you have the <sys/xattr.h> header file. */
 #ifdef HAVE_SYS_XATTR_H
-        gf_msg_plain_nomem (GF_LOG_ALERT, "xattr.h 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "xattr.h 1");
 #endif
 
 /* define if found st_atim.tv_nsec */
 #ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "st_atim.tv_nsec 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "st_atim.tv_nsec 1");
 #endif
 
 /* define if found st_atimespec.tv_nsec */
 #ifdef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC
-        gf_msg_plain_nomem (GF_LOG_ALERT, "st_atimespec.tv_nsec 1");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "st_atimespec.tv_nsec 1");
 #endif
 
 /* Define to the full name and version of this package. */
 #ifdef PACKAGE_STRING
-        {
-                char *msg = NULL;
-                int   ret = -1;
-
-                ret = gf_asprintf (&msg, "package-string: %s", PACKAGE_STRING);
-                if (ret >= 0) {
-                        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-                        GF_FREE (msg);
-                }
+    {
+        char *msg = NULL;
+        int ret = -1;
+
+        ret = gf_asprintf(&msg, "package-string: %s", PACKAGE_STRING);
+        if (ret >= 0) {
+            gf_msg_plain_nomem(GF_LOG_ALERT, msg);
+            GF_FREE(msg);
         }
+    }
 #endif
 
-        return;
+    return;
 }
 
 /* Obtain a backtrace and print it to the log */
 void
-gf_print_trace (int32_t signum, glusterfs_ctx_t *ctx)
-{
-        char         msg[1024] = {0,};
-        char         timestr[64] = {0,};
-        call_stack_t *stack = NULL;
-
-        /* Now every gf_log call will just write to a buffer and when the
-         * buffer becomes full, its written to the log-file. Suppose the process
-         * crashes and prints the backtrace in the log-file, then the previous
-         * log information will still be in the buffer itself. So flush the
-         * contents of the buffer to the log file before printing the backtrace
-         * which helps in debugging.
-         */
-        gf_log_flush();
-
-        gf_log_disable_suppression_before_exit (ctx);
-
-        /* Pending frames, (if any), list them in order */
-        gf_msg_plain_nomem (GF_LOG_ALERT, "pending frames:");
+gf_print_trace(int32_t signum, glusterfs_ctx_t *ctx)
+{
+    char msg[1024] = {
+        0,
+    };
+    char timestr[64] = {
+        0,
+    };
+    call_stack_t *stack = NULL;
+
+    /* Now every gf_log call will just write to a buffer and when the
+     * buffer becomes full, its written to the log-file. Suppose the process
+     * crashes and prints the backtrace in the log-file, then the previous
+     * log information will still be in the buffer itself. So flush the
+     * contents of the buffer to the log file before printing the backtrace
+     * which helps in debugging.
+     */
+    gf_log_flush();
+
+    gf_log_disable_suppression_before_exit(ctx);
+
+    /* Pending frames, (if any), list them in order */
+    gf_msg_plain_nomem(GF_LOG_ALERT, "pending frames:");
+    {
+        /* FIXME: traversing stacks outside pool->lock */
+        list_for_each_entry(stack, &ctx->pool->all_frames, all_frames)
         {
-                /* FIXME: traversing stacks outside pool->lock */
-                list_for_each_entry (stack, &ctx->pool->all_frames,
-                                     all_frames) {
-                        if (stack->type == GF_OP_TYPE_FOP)
-                                sprintf (msg,"frame : type(%d) op(%s)",
-                                         stack->type,
-                                         gf_fop_list[stack->op]);
-                        else
-                                sprintf (msg,"frame : type(%d) op(%d)",
-                                         stack->type,
-                                         stack->op);
-
-                        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-                }
+            if (stack->type == GF_OP_TYPE_FOP)
+                sprintf(msg, "frame : type(%d) op(%s)", stack->type,
+                        gf_fop_list[stack->op]);
+            else
+                sprintf(msg, "frame : type(%d) op(%d)", stack->type, stack->op);
+
+            gf_msg_plain_nomem(GF_LOG_ALERT, msg);
         }
+    }
 
-        sprintf (msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION);
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
+    sprintf(msg, "patchset: %s", GLUSTERFS_REPOSITORY_REVISION);
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
 
-        sprintf (msg, "signal received: %d", signum);
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
-        {
-                /* Dump the timestamp of the crash too, so the previous logs
-                   can be related */
-                gf_time_fmt (timestr, sizeof timestr, time (NULL),
-                             gf_timefmt_FT);
-                gf_msg_plain_nomem (GF_LOG_ALERT, "time of crash: ");
-                gf_msg_plain_nomem (GF_LOG_ALERT, timestr);
-        }
+    sprintf(msg, "signal received: %d", signum);
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
+    {
+        /* Dump the timestamp of the crash too, so the previous logs
+           can be related */
+        gf_time_fmt(timestr, sizeof timestr, time(NULL), gf_timefmt_FT);
+        gf_msg_plain_nomem(GF_LOG_ALERT, "time of crash: ");
+        gf_msg_plain_nomem(GF_LOG_ALERT, timestr);
+    }
 
-        gf_dump_config_flags ();
-        gf_msg_backtrace_nomem (GF_LOG_ALERT, 200);
-        sprintf (msg, "---------");
-        gf_msg_plain_nomem (GF_LOG_ALERT, msg);
+    gf_dump_config_flags();
+    gf_msg_backtrace_nomem(GF_LOG_ALERT, 200);
+    sprintf(msg, "---------");
+    gf_msg_plain_nomem(GF_LOG_ALERT, msg);
 
-        /* Send a signal to terminate the process */
-        signal (signum, SIG_DFL);
-        raise (signum);
+    /* Send a signal to terminate the process */
+    signal(signum, SIG_DFL);
+    raise(signum);
 }
 
 void
-trap (void)
+trap(void)
 {
-
 }
 
 char *
-gf_trim (char *string)
+gf_trim(char *string)
 {
-        register char *s, *t;
+    register char *s, *t;
 
-        if (string == NULL) {
-                return NULL;
-        }
+    if (string == NULL) {
+        return NULL;
+    }
 
-        for (s = string; isspace (*s); s++)
-                ;
+    for (s = string; isspace(*s); s++)
+        ;
 
-        if (*s == 0)
-                return s;
+    if (*s == 0)
+        return s;
 
-        t = s + strlen (s) - 1;
-        while (t > s && isspace (*t))
-                t--;
-        *++t = '\0';
+    t = s + strlen(s) - 1;
+    while (t > s && isspace(*t))
+        t--;
+    *++t = '\0';
 
-        return s;
+    return s;
 }
 
 int
-gf_strstr (const char *str, const char *delim, const char *match)
+gf_strstr(const char *str, const char *delim, const char *match)
 {
-        char *tmp      = NULL;
-        char *save_ptr = NULL;
-        char *tmp_str  = NULL;
+    char *tmp = NULL;
+    char *save_ptr = NULL;
+    char *tmp_str = NULL;
 
-        int  ret       = 0;
+    int ret = 0;
 
-        tmp_str = strdup (str);
+    tmp_str = strdup(str);
 
-        if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                ret = -1;
-                goto out;
-        }
+    if (str == NULL || delim == NULL || match == NULL || tmp_str == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        ret = -1;
+        goto out;
+    }
 
+    tmp = strtok_r(tmp_str, delim, &save_ptr);
 
-        tmp = strtok_r (tmp_str, delim, &save_ptr);
+    while (tmp) {
+        ret = strcmp(tmp, match);
 
-        while (tmp) {
-                ret = strcmp (tmp, match);
+        if (ret == 0)
+            break;
 
-                if (ret == 0)
-                        break;
-
-                tmp = strtok_r (NULL, delim, &save_ptr);
-        }
+        tmp = strtok_r(NULL, delim, &save_ptr);
+    }
 
 out:
-        free (tmp_str);
-
-        return ret;
+    free(tmp_str);
 
+    return ret;
 }
 
 int
-gf_volume_name_validate (const char *volume_name)
+gf_volume_name_validate(const char *volume_name)
 {
-        const char *vname = NULL;
+    const char *vname = NULL;
 
-        if (volume_name == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return -1;
-        }
+    if (volume_name == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return -1;
+    }
 
-        if (!isalpha (volume_name[0]))
-                return 1;
+    if (!isalpha(volume_name[0]))
+        return 1;
 
-        for (vname = &volume_name[1]; *vname != '\0'; vname++) {
-                if (!(isalnum (*vname) || *vname == '_'))
-                        return 1;
-        }
+    for (vname = &volume_name[1]; *vname != '\0'; vname++) {
+        if (!(isalnum(*vname) || *vname == '_'))
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-gf_string2time (const char *str, uint32_t *n)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtol (str, &tail, 0);
-        if (str == tail)
-                errno = EINVAL;
-
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
-
-        if (errno == 0)
-                errno = old_errno;
-
-        if (((tail[0] == '\0') ||
-              ((tail[0] == 's') && (tail[1] == '\0')) ||
-              ((tail[0] == 's') && (tail[1] == 'e') &&
-	       (tail[2] == 'c') && (tail[3] == '\0'))))
-               goto out;
-
-        else if (((tail[0] == 'm') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'm') && (tail[1] == 'i') &&
-                  (tail[2] == 'n') && (tail[3] == '\0'))) {
-                value = value * GF_MINUTE_IN_SECONDS;
-                goto out;
-        }
-
-        else if (((tail[0] == 'h') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'h') && (tail[1] == 'r') &&
-	         (tail[2] == '\0'))) {
-                value = value * GF_HOUR_IN_SECONDS;
-                goto out;
-        }
+gf_string2time(const char *str, uint32_t *n)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        else if (((tail[0] == 'd') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'd') && (tail[1] == 'a') &&
-	         (tail[2] == 'y') && (tail[3] == 's') &&
-                 (tail[4] == '\0'))) {
-                value = value * GF_DAY_IN_SECONDS;
-                goto out;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtol(str, &tail, 0);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        else if (((tail[0] == 'w') && (tail[1] == '\0')) ||
-                 ((tail[0] == 'w') && (tail[1] == 'k') &&
-	         (tail[2] == '\0'))) {
-                value = value * GF_WEEK_IN_SECONDS;
-                goto out;
-        } else {
-                return -1;
-        }
+    if (errno == 0)
+        errno = old_errno;
+
+    if (((tail[0] == '\0') || ((tail[0] == 's') && (tail[1] == '\0')) ||
+         ((tail[0] == 's') && (tail[1] == 'e') && (tail[2] == 'c') &&
+          (tail[3] == '\0'))))
+        goto out;
+
+    else if (((tail[0] == 'm') && (tail[1] == '\0')) ||
+             ((tail[0] == 'm') && (tail[1] == 'i') && (tail[2] == 'n') &&
+              (tail[3] == '\0'))) {
+        value = value * GF_MINUTE_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'h') && (tail[1] == '\0')) ||
+             ((tail[0] == 'h') && (tail[1] == 'r') && (tail[2] == '\0'))) {
+        value = value * GF_HOUR_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'd') && (tail[1] == '\0')) ||
+             ((tail[0] == 'd') && (tail[1] == 'a') && (tail[2] == 'y') &&
+              (tail[3] == 's') && (tail[4] == '\0'))) {
+        value = value * GF_DAY_IN_SECONDS;
+        goto out;
+    }
+
+    else if (((tail[0] == 'w') && (tail[1] == '\0')) ||
+             ((tail[0] == 'w') && (tail[1] == 'k') && (tail[2] == '\0'))) {
+        value = value * GF_WEEK_IN_SECONDS;
+        goto out;
+    } else {
+        return -1;
+    }
 
 out:
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2percent (const char *str, double *n)
-{
-        double value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
+gf_string2percent(const char *str, double *n)
+{
+    double value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (!((tail[0] == '\0') ||
-              ((tail[0] == '%') && (tail[1] == '\0'))))
-                return -1;
+    if (!((tail[0] == '\0') || ((tail[0] == '%') && (tail[1] == '\0'))))
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-_gf_string2long (const char *str, long *n, int base)
+_gf_string2long(const char *str, long *n, int base)
 {
-        long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
+    long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtol (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtol(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2ulong (const char *str, unsigned long *n, int base)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoul (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2ulong(const char *str, unsigned long *n, int base)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoul(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2uint (const char *str, unsigned int *n, int base)
-{
-        unsigned long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoul (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2uint(const char *str, unsigned int *n, int base)
+{
+    unsigned long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoul(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = (unsigned int)value;
+    *n = (unsigned int)value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2double (const char *str, double *n)
+_gf_string2double(const char *str, double *n)
 {
-        double value     = 0.0;
-        char   *tail     = NULL;
-        int    old_errno = 0;
+    double value = 0.0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2longlong (const char *str, long long *n, int base)
+_gf_string2longlong(const char *str, long long *n, int base)
 {
-        long long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
+    long long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
 
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        old_errno = errno;
-        errno = 0;
-        value = strtoll (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+    old_errno = errno;
+    errno = 0;
+    value = strtoll(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 static int
-_gf_string2ulonglong (const char *str, unsigned long long *n, int base)
-{
-        unsigned long long value = 0;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
-
-        old_errno = errno;
-        errno = 0;
-        value = strtoull (str, &tail, base);
-        if (str == tail)
-                errno = EINVAL;
+_gf_string2ulonglong(const char *str, unsigned long long *n, int base)
+{
+    unsigned long long value = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtoull(str, &tail, base);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-                return -1;
+    if (tail[0] != '\0')
+        return -1;
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2long (const char *str, long *n)
+gf_string2long(const char *str, long *n)
 {
-        return _gf_string2long (str, n, 0);
+    return _gf_string2long(str, n, 0);
 }
 
 int
-gf_string2ulong (const char *str, unsigned long *n)
+gf_string2ulong(const char *str, unsigned long *n)
 {
-        return _gf_string2ulong (str, n, 0);
+    return _gf_string2ulong(str, n, 0);
 }
 
 int
-gf_string2int (const char *str, int *n)
+gf_string2int(const char *str, int *n)
 {
-        long l = 0;
-        int  ret = 0;
+    long l = 0;
+    int ret = 0;
 
-        ret = _gf_string2long (str, &l, 0);
+    ret = _gf_string2long(str, &l, 0);
 
-        *n = l;
-        return ret;
+    *n = l;
+    return ret;
 }
 
 int
-gf_string2uint (const char *str, unsigned int *n)
+gf_string2uint(const char *str, unsigned int *n)
 {
-        return _gf_string2uint (str, n, 0);
+    return _gf_string2uint(str, n, 0);
 }
 
 int
-gf_string2double (const char *str, double *n)
+gf_string2double(const char *str, double *n)
 {
-        return _gf_string2double (str, n);
+    return _gf_string2double(str, n);
 }
 
 int
-gf_string2longlong (const char *str, long long *n)
+gf_string2longlong(const char *str, long long *n)
 {
-        return _gf_string2longlong (str, n, 0);
+    return _gf_string2longlong(str, n, 0);
 }
 
 int
-gf_string2ulonglong (const char *str, unsigned long long *n)
+gf_string2ulonglong(const char *str, unsigned long long *n)
 {
-        return _gf_string2ulonglong (str, n, 0);
+    return _gf_string2ulonglong(str, n, 0);
 }
 
 int
-gf_string2int8 (const char *str, int8_t *n)
+gf_string2int8(const char *str, int8_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT8_MIN) && (l <= INT8_MAX)) {
-                *n = (int8_t) l;
-                return 0;
-        }
+    if ((l >= INT8_MIN) && (l <= INT8_MAX)) {
+        *n = (int8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int16 (const char *str, int16_t *n)
+gf_string2int16(const char *str, int16_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT16_MIN) && (l <= INT16_MAX)) {
-                *n = (int16_t) l;
-                return 0;
-        }
+    if ((l >= INT16_MIN) && (l <= INT16_MAX)) {
+        *n = (int16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int32 (const char *str, int32_t *n)
+gf_string2int32(const char *str, int32_t *n)
 {
-        long l = 0L;
-        int rv = 0;
+    long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2long (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2long(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if ((l >= INT32_MIN) && (l <= INT32_MAX)) {
-                *n = (int32_t) l;
-                return 0;
-        }
+    if ((l >= INT32_MIN) && (l <= INT32_MAX)) {
+        *n = (int32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2int64 (const char *str, int64_t *n)
+gf_string2int64(const char *str, int64_t *n)
 {
-        long long l = 0LL;
-        int rv = 0;
+    long long l = 0LL;
+    int rv = 0;
 
-        rv = _gf_string2longlong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2longlong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        *n = (int64_t) l;
-        return 0;
+    *n = (int64_t)l;
+    return 0;
 }
 
 int
-gf_string2uint8 (const char *str, uint8_t *n)
+gf_string2uint8(const char *str, uint8_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT8_MAX) {
-                *n = (uint8_t) l;
-                return 0;
-        }
+    if (l <= UINT8_MAX) {
+        *n = (uint8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint16 (const char *str, uint16_t *n)
+gf_string2uint16(const char *str, uint16_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT16_MAX) {
-                *n = (uint16_t) l;
-                return 0;
-        }
+    if (l <= UINT16_MAX) {
+        *n = (uint16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint32 (const char *str, uint32_t *n)
+gf_string2uint32(const char *str, uint32_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-	if (l <= UINT32_MAX) {
-                *n = (uint32_t) l;
-                return 0;
-        }
+    if (l <= UINT32_MAX) {
+        *n = (uint32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint64 (const char *str, uint64_t *n)
+gf_string2uint64(const char *str, uint64_t *n)
 {
-        unsigned long long l = 0ULL;
-        int rv = 0;
+    unsigned long long l = 0ULL;
+    int rv = 0;
 
-        rv = _gf_string2ulonglong (str, &l, 0);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulonglong(str, &l, 0);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT64_MAX) {
-                *n = (uint64_t) l;
-                return 0;
-        }
+    if (l <= UINT64_MAX) {
+        *n = (uint64_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2ulong_base10 (const char *str, unsigned long *n)
+gf_string2ulong_base10(const char *str, unsigned long *n)
 {
-        return _gf_string2ulong (str, n, 10);
+    return _gf_string2ulong(str, n, 10);
 }
 
 int
-gf_string2uint_base10 (const char *str, unsigned int *n)
+gf_string2uint_base10(const char *str, unsigned int *n)
 {
-        return _gf_string2uint (str,  n, 10);
+    return _gf_string2uint(str, n, 10);
 }
 
 int
-gf_string2uint8_base10 (const char *str, uint8_t *n)
+gf_string2uint8_base10(const char *str, uint8_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT8_MAX) {
-                *n = (uint8_t) l;
-                return 0;
-        }
+    if (l <= UINT8_MAX) {
+        *n = (uint8_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint16_base10 (const char *str, uint16_t *n)
+gf_string2uint16_base10(const char *str, uint16_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT16_MAX) {
-                *n = (uint16_t) l;
-                return 0;
-        }
+    if (l <= UINT16_MAX) {
+        *n = (uint16_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint32_base10 (const char *str, uint32_t *n)
+gf_string2uint32_base10(const char *str, uint32_t *n)
 {
-        unsigned long l = 0L;
-        int rv = 0;
+    unsigned long l = 0L;
+    int rv = 0;
 
-        rv = _gf_string2ulong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT32_MAX) {
-                *n = (uint32_t) l;
-                return 0;
-        }
+    if (l <= UINT32_MAX) {
+        *n = (uint32_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 int
-gf_string2uint64_base10 (const char *str, uint64_t *n)
+gf_string2uint64_base10(const char *str, uint64_t *n)
 {
-        unsigned long long l = 0ULL;
-        int rv = 0;
+    unsigned long long l = 0ULL;
+    int rv = 0;
 
-        rv = _gf_string2ulonglong (str, &l, 10);
-        if (rv != 0)
-                return rv;
+    rv = _gf_string2ulonglong(str, &l, 10);
+    if (rv != 0)
+        return rv;
 
-        if (l <= UINT64_MAX) {
-                *n = (uint64_t) l;
-                return 0;
-        }
+    if (l <= UINT64_MAX) {
+        *n = (uint64_t)l;
+        return 0;
+    }
 
-        errno = ERANGE;
-        return -1;
+    errno = ERANGE;
+    return -1;
 }
 
 char *
-gf_uint64_2human_readable (uint64_t n)
-{
-        int   ret = 0;
-        char *str = NULL;
-
-        if (n >= GF_UNIT_PB) {
-                ret = gf_asprintf (&str, "%.1lfPB", ((double) n)/GF_UNIT_PB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_TB) {
-                ret = gf_asprintf (&str, "%.1lfTB", ((double) n)/GF_UNIT_TB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_GB) {
-                ret = gf_asprintf (&str, "%.1lfGB", ((double) n)/GF_UNIT_GB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_MB) {
-                ret = gf_asprintf (&str, "%.1lfMB", ((double) n)/GF_UNIT_MB);
-                if (ret < 0)
-                        goto err;
-        } else if (n >= GF_UNIT_KB) {
-                ret = gf_asprintf (&str, "%.1lfKB", ((double) n)/GF_UNIT_KB);
-                if (ret < 0)
-                        goto err;
-        } else {
-                ret = gf_asprintf (&str, "%luBytes", n);
-                if (ret < 0)
-                        goto err;
-        }
-        return str;
+gf_uint64_2human_readable(uint64_t n)
+{
+    int ret = 0;
+    char *str = NULL;
+
+    if (n >= GF_UNIT_PB) {
+        ret = gf_asprintf(&str, "%.1lfPB", ((double)n) / GF_UNIT_PB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_TB) {
+        ret = gf_asprintf(&str, "%.1lfTB", ((double)n) / GF_UNIT_TB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_GB) {
+        ret = gf_asprintf(&str, "%.1lfGB", ((double)n) / GF_UNIT_GB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_MB) {
+        ret = gf_asprintf(&str, "%.1lfMB", ((double)n) / GF_UNIT_MB);
+        if (ret < 0)
+            goto err;
+    } else if (n >= GF_UNIT_KB) {
+        ret = gf_asprintf(&str, "%.1lfKB", ((double)n) / GF_UNIT_KB);
+        if (ret < 0)
+            goto err;
+    } else {
+        ret = gf_asprintf(&str, "%luBytes", n);
+        if (ret < 0)
+            goto err;
+    }
+    return str;
 err:
-        return NULL;
+    return NULL;
 }
 
 int
-gf_string2bytesize_range (const char *str, uint64_t *n, uint64_t umax)
-{
-        double        value      = 0.0;
-        int64_t       int_value  = 0;
-        uint64_t      unit       = 0;
-        int64_t       max        = 0;
-        char         *tail       = NULL;
-        int           old_errno  = 0;
-        const char   *s          = NULL;
-        gf_boolean_t  fraction   = _gf_false;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
+gf_string2bytesize_range(const char *str, uint64_t *n, uint64_t umax)
+{
+    double value = 0.0;
+    int64_t int_value = 0;
+    uint64_t unit = 0;
+    int64_t max = 0;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+    gf_boolean_t fraction = _gf_false;
+
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
 
-        max = umax & 0x7fffffffffffffffLL;
+    max = umax & 0x7fffffffffffffffLL;
 
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
 
-        if (strrchr (str, '.'))
-                fraction = _gf_true;
+    if (strrchr(str, '.'))
+        fraction = _gf_true;
 
-        old_errno = errno;
-        errno = 0;
-        if (fraction)
-                value = strtod (str, &tail);
-        else
-                int_value = strtoll (str, &tail, 10);
+    old_errno = errno;
+    errno = 0;
+    if (fraction)
+        value = strtod(str, &tail);
+    else
+        int_value = strtoll(str, &tail, 10);
 
-        if (str == tail)
-                errno = EINVAL;
+    if (str == tail)
+        errno = EINVAL;
 
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        if (errno == 0)
-                errno = old_errno;
+    if (errno == 0)
+        errno = old_errno;
 
-        if (tail[0] != '\0')
-        {
-                if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0)
-                        unit = GF_UNIT_KB;
-                else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0)
-                        unit = GF_UNIT_MB;
-                else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0)
-                        unit = GF_UNIT_GB;
-                else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0)
-                        unit = GF_UNIT_TB;
-                else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0)
-                        unit = GF_UNIT_PB;
-                else if (strcasecmp (tail, GF_UNIT_B_STRING) != 0)
-                        return -1;
-
-                if (unit > 0) {
-                        if (fraction)
-                                value *= unit;
-                        else
-                                int_value *= unit;
-                }
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0)
+            unit = GF_UNIT_KB;
+        else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0)
+            unit = GF_UNIT_MB;
+        else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0)
+            unit = GF_UNIT_GB;
+        else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0)
+            unit = GF_UNIT_TB;
+        else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0)
+            unit = GF_UNIT_PB;
+        else if (strcasecmp(tail, GF_UNIT_B_STRING) != 0)
+            return -1;
+
+        if (unit > 0) {
+            if (fraction)
+                value *= unit;
+            else
+                int_value *= unit;
         }
+    }
 
-        if (fraction) {
-                if ((max - value) < 0) {
-                        errno = ERANGE;
-                        return -1;
-                }
-                *n = (uint64_t) value;
-        } else {
-                if ((max - int_value) < 0) {
-                        errno = ERANGE;
-                        return -1;
-                }
-                *n = int_value;
+    if (fraction) {
+        if ((max - value) < 0) {
+            errno = ERANGE;
+            return -1;
+        }
+        *n = (uint64_t)value;
+    } else {
+        if ((max - int_value) < 0) {
+            errno = ERANGE;
+            return -1;
         }
+        *n = int_value;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-gf_string2bytesize_size (const char *str, size_t *n)
+gf_string2bytesize_size(const char *str, size_t *n)
 {
-        uint64_t u64;
-        size_t max = (size_t) - 1;
-        int val = gf_string2bytesize_range (str, &u64, max);
-        *n = (size_t) u64;
-        return val;
+    uint64_t u64;
+    size_t max = (size_t)-1;
+    int val = gf_string2bytesize_range(str, &u64, max);
+    *n = (size_t)u64;
+    return val;
 }
 
 int
-gf_string2bytesize (const char *str, uint64_t *n)
+gf_string2bytesize(const char *str, uint64_t *n)
 {
-        return gf_string2bytesize_range(str, n, UINT64_MAX);
+    return gf_string2bytesize_range(str, n, UINT64_MAX);
 }
 
 int
-gf_string2bytesize_uint64 (const char *str, uint64_t *n)
+gf_string2bytesize_uint64(const char *str, uint64_t *n)
 {
-        return gf_string2bytesize_range(str, n, UINT64_MAX);
+    return gf_string2bytesize_range(str, n, UINT64_MAX);
 }
 
 int
-gf_string2bytesize_int64 (const char *str, int64_t *n)
+gf_string2bytesize_int64(const char *str, int64_t *n)
 {
-        uint64_t u64 = 0;
-        int      ret = 0;
+    uint64_t u64 = 0;
+    int ret = 0;
 
-        ret = gf_string2bytesize_range(str, &u64, INT64_MAX);
-        *n = (int64_t) u64;
-        return ret;
+    ret = gf_string2bytesize_range(str, &u64, INT64_MAX);
+    *n = (int64_t)u64;
+    return ret;
 }
 
 int
-gf_string2percent_or_bytesize (const char *str, double *n,
-			       gf_boolean_t *is_percent)
-{
-        double value = 0ULL;
-        char *tail = NULL;
-        int old_errno = 0;
-        const char *s = NULL;
-
-        if (str == NULL || n == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                errno = EINVAL;
-                return -1;
-        }
-
-        for (s = str; *s != '\0'; s++) {
-                if (isspace (*s))
-                        continue;
-                if (*s == '-')
-                        return -1;
-                break;
-        }
+gf_string2percent_or_bytesize(const char *str, double *n,
+                              gf_boolean_t *is_percent)
+{
+    double value = 0ULL;
+    char *tail = NULL;
+    int old_errno = 0;
+    const char *s = NULL;
+
+    if (str == NULL || n == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (s = str; *s != '\0'; s++) {
+        if (isspace(*s))
+            continue;
+        if (*s == '-')
+            return -1;
+        break;
+    }
+
+    old_errno = errno;
+    errno = 0;
+    value = strtod(str, &tail);
+    if (str == tail)
+        errno = EINVAL;
+
+    if (errno == ERANGE || errno == EINVAL)
+        return -1;
 
-        old_errno = errno;
-        errno = 0;
-        value = strtod (str, &tail);
-        if (str == tail)
-                errno = EINVAL;
-
-        if (errno == ERANGE || errno == EINVAL)
-                return -1;
-
-        if (errno == 0)
-                errno = old_errno;
-
-        /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/
-        if (tail[0] != '\0') {
-                if (strcasecmp (tail, GF_UNIT_KB_STRING) == 0)
-                        value *= GF_UNIT_KB;
-                else if (strcasecmp (tail, GF_UNIT_MB_STRING) == 0)
-                        value *= GF_UNIT_MB;
-                else if (strcasecmp (tail, GF_UNIT_GB_STRING) == 0)
-                        value *= GF_UNIT_GB;
-                else if (strcasecmp (tail, GF_UNIT_TB_STRING) == 0)
-                        value *= GF_UNIT_TB;
-                else if (strcasecmp (tail, GF_UNIT_PB_STRING) == 0)
-                        value *= GF_UNIT_PB;
-		else if (strcasecmp (tail, GF_UNIT_PERCENT_STRING) == 0)
-			*is_percent = _gf_true;
-                else
-                        return -1;
-        }
+    if (errno == 0)
+        errno = old_errno;
+
+    /*Maximum accepted value for 64 bit OS will be (2^14 -1)PB*/
+    if (tail[0] != '\0') {
+        if (strcasecmp(tail, GF_UNIT_KB_STRING) == 0)
+            value *= GF_UNIT_KB;
+        else if (strcasecmp(tail, GF_UNIT_MB_STRING) == 0)
+            value *= GF_UNIT_MB;
+        else if (strcasecmp(tail, GF_UNIT_GB_STRING) == 0)
+            value *= GF_UNIT_GB;
+        else if (strcasecmp(tail, GF_UNIT_TB_STRING) == 0)
+            value *= GF_UNIT_TB;
+        else if (strcasecmp(tail, GF_UNIT_PB_STRING) == 0)
+            value *= GF_UNIT_PB;
+        else if (strcasecmp(tail, GF_UNIT_PERCENT_STRING) == 0)
+            *is_percent = _gf_true;
+        else
+            return -1;
+    }
 
-        /* Error out if we cannot store the value in uint64 */
-        if ((UINT64_MAX - value) < 0) {
-                errno = ERANGE;
-                return -1;
-        }
+    /* Error out if we cannot store the value in uint64 */
+    if ((UINT64_MAX - value) < 0) {
+        errno = ERANGE;
+        return -1;
+    }
 
-        *n = value;
+    *n = value;
 
-        return 0;
+    return 0;
 }
 
 int64_t
-gf_str_to_long_long (const char *number)
-{
-        int64_t unit = 1;
-        int64_t ret = 0;
-        char *endptr = NULL ;
-        if (!number)
-                return 0;
-
-        ret = strtoll (number, &endptr, 0);
-
-        if (endptr) {
-                switch (*endptr) {
-                case 'G':
-                case 'g':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024 * 1024 * 1024;
-                        break;
-                case 'M':
-                case 'm':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024 * 1024;
-                        break;
-                case 'K':
-                case 'k':
-                        if ((* (endptr + 1) == 'B') ||(* (endptr + 1) == 'b'))
-                                unit = 1024;
-                        break;
-                case '%':
-                        unit = 1;
-                        break;
-                default:
-                        unit = 1;
-                        break;
-                }
+gf_str_to_long_long(const char *number)
+{
+    int64_t unit = 1;
+    int64_t ret = 0;
+    char *endptr = NULL;
+    if (!number)
+        return 0;
+
+    ret = strtoll(number, &endptr, 0);
+
+    if (endptr) {
+        switch (*endptr) {
+            case 'G':
+            case 'g':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024 * 1024 * 1024;
+                break;
+            case 'M':
+            case 'm':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024 * 1024;
+                break;
+            case 'K':
+            case 'k':
+                if ((*(endptr + 1) == 'B') || (*(endptr + 1) == 'b'))
+                    unit = 1024;
+                break;
+            case '%':
+                unit = 1;
+                break;
+            default:
+                unit = 1;
+                break;
         }
-        return ret * unit;
+    }
+    return ret * unit;
 }
 
 int
-gf_string2boolean (const char *str, gf_boolean_t *b)
+gf_string2boolean(const char *str, gf_boolean_t *b)
 {
-        if (str == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return -1;
-        }
+    if (str == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return -1;
+    }
 
-        if ((strcasecmp (str, "1") == 0) ||
-            (strcasecmp (str, "on") == 0) ||
-            (strcasecmp (str, "yes") == 0) ||
-            (strcasecmp (str, "true") == 0) ||
-            (strcasecmp (str, "enable") == 0)) {
-                *b = _gf_true;
-                return 0;
-        }
+    if ((strcasecmp(str, "1") == 0) || (strcasecmp(str, "on") == 0) ||
+        (strcasecmp(str, "yes") == 0) || (strcasecmp(str, "true") == 0) ||
+        (strcasecmp(str, "enable") == 0)) {
+        *b = _gf_true;
+        return 0;
+    }
 
-        if ((strcasecmp (str, "0") == 0) ||
-            (strcasecmp (str, "off") == 0) ||
-            (strcasecmp (str, "no") == 0) ||
-            (strcasecmp (str, "false") == 0) ||
-            (strcasecmp (str, "disable") == 0)) {
-                *b = _gf_false;
-                return 0;
-        }
+    if ((strcasecmp(str, "0") == 0) || (strcasecmp(str, "off") == 0) ||
+        (strcasecmp(str, "no") == 0) || (strcasecmp(str, "false") == 0) ||
+        (strcasecmp(str, "disable") == 0)) {
+        *b = _gf_false;
+        return 0;
+    }
 
-        return -1;
+    return -1;
 }
 
-
 int
-gf_lockfd (int fd)
+gf_lockfd(int fd)
 {
-        struct gf_flock fl;
+    struct gf_flock fl;
 
-        fl.l_type = F_WRLCK;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = 0;
-        fl.l_len = 0;
+    fl.l_type = F_WRLCK;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
 
-        return fcntl (fd, F_SETLK, &fl);
+    return fcntl(fd, F_SETLK, &fl);
 }
 
-
 int
-gf_unlockfd (int fd)
+gf_unlockfd(int fd)
 {
-        struct gf_flock fl;
+    struct gf_flock fl;
 
-        fl.l_type = F_UNLCK;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = 0;
-        fl.l_len = 0;
+    fl.l_type = F_UNLCK;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
 
-        return fcntl (fd, F_SETLK, &fl);
+    return fcntl(fd, F_SETLK, &fl);
 }
 
 static void
-compute_checksum (char *buf, size_t size, uint32_t *checksum)
+compute_checksum(char *buf, size_t size, uint32_t *checksum)
 {
-        int  ret = -1;
-        char *checksum_buf = NULL;
+    int ret = -1;
+    char *checksum_buf = NULL;
 
-        checksum_buf = (char *)(checksum);
+    checksum_buf = (char *)(checksum);
 
-        if (!(*checksum)) {
-                checksum_buf [0] = 0xba;
-                checksum_buf [1] = 0xbe;
-                checksum_buf [2] = 0xb0;
-                checksum_buf [3] = 0x0b;
-        }
+    if (!(*checksum)) {
+        checksum_buf[0] = 0xba;
+        checksum_buf[1] = 0xbe;
+        checksum_buf[2] = 0xb0;
+        checksum_buf[3] = 0x0b;
+    }
 
-        for (ret = 0; ret < (size - 4); ret += 4) {
-                checksum_buf[0] ^= (buf[ret]);
-                checksum_buf[1] ^= (buf[ret + 1] << 1) ;
-                checksum_buf[2] ^= (buf[ret + 2] << 2);
-                checksum_buf[3] ^= (buf[ret + 3] << 3);
-        }
+    for (ret = 0; ret < (size - 4); ret += 4) {
+        checksum_buf[0] ^= (buf[ret]);
+        checksum_buf[1] ^= (buf[ret + 1] << 1);
+        checksum_buf[2] ^= (buf[ret + 2] << 2);
+        checksum_buf[3] ^= (buf[ret + 3] << 3);
+    }
 
-        for (ret = 0; ret <= (size % 4); ret++) {
-                checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret);
-        }
+    for (ret = 0; ret <= (size % 4); ret++) {
+        checksum_buf[ret] ^= (buf[(size - 4) + ret] << ret);
+    }
 
-        return;
+    return;
 }
 
 #define GF_CHECKSUM_BUF_SIZE 1024
 
 int
-get_checksum_for_file (int fd, uint32_t *checksum)
+get_checksum_for_file(int fd, uint32_t *checksum)
 {
-        int ret = -1;
-        char buf[GF_CHECKSUM_BUF_SIZE] = {0,};
+    int ret = -1;
+    char buf[GF_CHECKSUM_BUF_SIZE] = {
+        0,
+    };
 
-        /* goto first place */
-        sys_lseek (fd, 0L, SEEK_SET);
-        do {
-                ret = sys_read (fd, &buf, GF_CHECKSUM_BUF_SIZE);
-                if (ret > 0)
-                        compute_checksum (buf, GF_CHECKSUM_BUF_SIZE,
-                                          checksum);
-        } while (ret > 0);
+    /* goto first place */
+    sys_lseek(fd, 0L, SEEK_SET);
+    do {
+        ret = sys_read(fd, &buf, GF_CHECKSUM_BUF_SIZE);
+        if (ret > 0)
+            compute_checksum(buf, GF_CHECKSUM_BUF_SIZE, checksum);
+    } while (ret > 0);
 
-        /* set it back */
-        sys_lseek (fd, 0L, SEEK_SET);
+    /* set it back */
+    sys_lseek(fd, 0L, SEEK_SET);
 
-        return ret;
+    return ret;
 }
 
-
 int
-get_checksum_for_path (char *path, uint32_t *checksum)
+get_checksum_for_path(char *path, uint32_t *checksum)
 {
-        int     ret = -1;
-        int     fd = -1;
+    int ret = -1;
+    int fd = -1;
 
-        GF_ASSERT (path);
-        GF_ASSERT (checksum);
+    GF_ASSERT(path);
+    GF_ASSERT(checksum);
 
-        fd = open (path, O_RDWR);
+    fd = open(path, O_RDWR);
 
-        if (fd == -1) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR,
-                        "Unable to open %s", path);
-                goto out;
-        }
+    if (fd == -1) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR,
+               "Unable to open %s", path);
+        goto out;
+    }
 
-        ret = get_checksum_for_file (fd, checksum);
+    ret = get_checksum_for_file(fd, checksum);
 
 out:
-        if (fd != -1)
-                sys_close (fd);
+    if (fd != -1)
+        sys_close(fd);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -2071,26 +2077,25 @@ out:
  *           errors : Errors returned by the stat () call
  */
 int
-get_file_mtime (const char *path, time_t *stamp)
+get_file_mtime(const char *path, time_t *stamp)
 {
-        struct stat     f_stat  = {0};
-        int             ret     = -EINVAL;
+    struct stat f_stat = {0};
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, path, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, stamp, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, path, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, stamp, out);
 
-        ret = sys_stat (path, &f_stat);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FILE_STAT_FAILED, "failed to stat %s",
-                        path);
-                goto out;
-        }
+    ret = sys_stat(path, &f_stat);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+               "failed to stat %s", path);
+        goto out;
+    }
 
-        /* Set the mtime */
-        *stamp = f_stat.st_mtime;
+    /* Set the mtime */
+    *stamp = f_stat.st_mtime;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2106,117 +2111,117 @@ out:
  *          failure: -EINVAL for bad args, retval of inet_pton otherwise
  */
 gf_boolean_t
-gf_is_ip_in_net (const char *network, const char *ip_str)
-{
-        unsigned long ip_buf       = 0;
-        unsigned long net_ip_buf   = 0;
-        unsigned long subnet_mask  = 0;
-        int           ret          = -EINVAL;
-        char          *slash       = NULL;
-        char          *net_ip      = NULL;
-        char          *subnet      = NULL;
-        char          *net_str     = NULL;
-        int           family       = AF_INET;
-        gf_boolean_t  result       = _gf_false;
-
-        GF_ASSERT (network);
-        GF_ASSERT (ip_str);
-
-        if (strchr (network, ':'))
-                family = AF_INET6;
-        else if (strchr (network, '.'))
-                family = AF_INET;
-        else {
-                family = -1;
-                goto out;
-        }
-
-        net_str = strdupa (network);
-        slash = strchr (net_str, '/');
-        if (!slash)
-                goto out;
-        *slash = '\0';
-
-        subnet = slash + 1;
-        net_ip = net_str;
-
-        /* Convert IP address to a long */
-        ret = inet_pton (family, ip_str, &ip_buf);
-        if (ret < 0)
-                gf_msg ("common-utils", GF_LOG_ERROR, errno,
-                        LG_MSG_INET_PTON_FAILED, "inet_pton() failed");
-
-        /* Convert network IP address to a long */
-        ret = inet_pton (family, net_ip, &net_ip_buf);
-        if (ret < 0) {
-                gf_msg ("common-utils", GF_LOG_ERROR, errno,
-                        LG_MSG_INET_PTON_FAILED, "inet_pton() failed");
-                goto out;
-        }
-
-        /* Converts /x into a mask */
-        subnet_mask = (1 << atoi (subnet)) - 1;
-
-        result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask));
+gf_is_ip_in_net(const char *network, const char *ip_str)
+{
+    unsigned long ip_buf = 0;
+    unsigned long net_ip_buf = 0;
+    unsigned long subnet_mask = 0;
+    int ret = -EINVAL;
+    char *slash = NULL;
+    char *net_ip = NULL;
+    char *subnet = NULL;
+    char *net_str = NULL;
+    int family = AF_INET;
+    gf_boolean_t result = _gf_false;
+
+    GF_ASSERT(network);
+    GF_ASSERT(ip_str);
+
+    if (strchr(network, ':'))
+        family = AF_INET6;
+    else if (strchr(network, '.'))
+        family = AF_INET;
+    else {
+        family = -1;
+        goto out;
+    }
+
+    net_str = strdupa(network);
+    slash = strchr(net_str, '/');
+    if (!slash)
+        goto out;
+    *slash = '\0';
+
+    subnet = slash + 1;
+    net_ip = net_str;
+
+    /* Convert IP address to a long */
+    ret = inet_pton(family, ip_str, &ip_buf);
+    if (ret < 0)
+        gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+               "inet_pton() failed");
+
+    /* Convert network IP address to a long */
+    ret = inet_pton(family, net_ip, &net_ip_buf);
+    if (ret < 0) {
+        gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+               "inet_pton() failed");
+        goto out;
+    }
+
+    /* Converts /x into a mask */
+    subnet_mask = (1 << atoi(subnet)) - 1;
+
+    result = ((ip_buf & subnet_mask) == (net_ip_buf & subnet_mask));
 out:
-        return result;
+    return result;
 }
 
 char *
-strtail (char *str, const char *pattern)
+strtail(char *str, const char *pattern)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; str[i] == pattern[i] && str[i]; i++);
+    for (i = 0; str[i] == pattern[i] && str[i]; i++)
+        ;
 
-        if (pattern[i] == '\0')
-                return str + i;
+    if (pattern[i] == '\0')
+        return str + i;
 
-        return NULL;
+    return NULL;
 }
 
 void
-skipwhite (char **s)
+skipwhite(char **s)
 {
-        while (isspace (**s))
-                (*s)++;
+    while (isspace(**s))
+        (*s)++;
 }
 
 void
-gf_strTrim (char **s)
+gf_strTrim(char **s)
 {
-        char *end = NULL;
+    char *end = NULL;
 
-        end = *s + strlen(*s) - 1;
-        while (end > *s && isspace ((unsigned char)*end))
-                end--;
+    end = *s + strlen(*s) - 1;
+    while (end > *s && isspace((unsigned char)*end))
+        end--;
 
-        *(end+1) = '\0';
+    *(end + 1) = '\0';
 
-        while (isspace (**s))
-                (*s)++;
+    while (isspace(**s))
+        (*s)++;
 
-        return;
+    return;
 }
 
 char *
-nwstrtail (char *str, char *pattern)
+nwstrtail(char *str, char *pattern)
 {
-        for (;;) {
-                skipwhite (&str);
-                skipwhite (&pattern);
+    for (;;) {
+        skipwhite(&str);
+        skipwhite(&pattern);
 
-                if (*str != *pattern || !*str)
-                        break;
+        if (*str != *pattern || !*str)
+            break;
 
-                str++;
-                pattern++;
-        }
+        str++;
+        pattern++;
+    }
 
-        return *pattern ? NULL : str;
+    return *pattern ? NULL : str;
 }
 
-
 /**
  * token_iter_init -- initialize tokenization
  *
@@ -2231,12 +2236,12 @@ nwstrtail (char *str, char *pattern)
  * next_token().
  */
 char *
-token_iter_init (char *str, char sep, token_iter_t *tit)
+token_iter_init(char *str, char sep, token_iter_t *tit)
 {
-        tit->end = str + strlen (str);
-        tit->sep = sep;
+    tit->end = str + strlen(str);
+    tit->sep = sep;
 
-        return str;
+    return str;
 }
 
 /**
@@ -2256,30 +2261,32 @@ token_iter_init (char *str, char sep, token_iter_t *tit)
  * apart from dropped tokens (see drop_token()).
  */
 gf_boolean_t
-next_token (char **tokenp, token_iter_t *tit)
-{
-        char        *cursor  = NULL;
-        gf_boolean_t is_last = _gf_false;
-
-        for (cursor = *tokenp; *cursor; cursor++);
-        if (cursor < tit->end) {
-                /*
-                 * We detect that in between current token and end a zero
-                 * marker has already been inserted. This means that the
-                 * token has already been returned. We restore the
-                 * separator and move ahead.
-                 */
-                *cursor = tit->sep;
-                *tokenp = cursor + 1;
-        }
+next_token(char **tokenp, token_iter_t *tit)
+{
+    char *cursor = NULL;
+    gf_boolean_t is_last = _gf_false;
 
-        for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++);
-        /* If the cursor ended up on a zero byte, then it's the last token. */
-        is_last = !*cursor;
-        /* Zero-terminate the token. */
-        *cursor = 0;
+    for (cursor = *tokenp; *cursor; cursor++)
+        ;
+    if (cursor < tit->end) {
+        /*
+         * We detect that in between current token and end a zero
+         * marker has already been inserted. This means that the
+         * token has already been returned. We restore the
+         * separator and move ahead.
+         */
+        *cursor = tit->sep;
+        *tokenp = cursor + 1;
+    }
 
-        return is_last;
+    for (cursor = *tokenp; *cursor && *cursor != tit->sep; cursor++)
+        ;
+    /* If the cursor ended up on a zero byte, then it's the last token. */
+    is_last = !*cursor;
+    /* Zero-terminate the token. */
+    *cursor = 0;
+
+    return is_last;
 }
 
 /*
@@ -2330,142 +2337,143 @@ next_token (char **tokenp, token_iter_t *tit)
  * }
  */
 void
-drop_token (char *token, token_iter_t *tit)
-{
-        char *cursor = NULL;
-
-        for (cursor = token; *cursor; cursor++);
-        if (cursor < tit->end) {
-                /*
-                 * We detect a zero inserted by next_token().
-                 * Step the cursor and copy what comes after
-                 * to token.
-                 */
-                for (cursor++; cursor < tit->end; *token++ = *cursor++);
-        }
+drop_token(char *token, token_iter_t *tit)
+{
+    char *cursor = NULL;
 
+    for (cursor = token; *cursor; cursor++)
+        ;
+    if (cursor < tit->end) {
         /*
-         * Zero out the remainder of the buffer.
-         * It would be enough to insert just a single zero,
-         * but we continue 'till the end to have cleaner
-         * memory content.
+         * We detect a zero inserted by next_token().
+         * Step the cursor and copy what comes after
+         * to token.
          */
-        for (cursor = token; cursor < tit->end; *cursor++ = 0);
+        for (cursor++; cursor < tit->end; *token++ = *cursor++)
+            ;
+    }
 
-        /* Adjust the end to point to the new terminating zero. */
-        tit->end = token;
+    /*
+     * Zero out the remainder of the buffer.
+     * It would be enough to insert just a single zero,
+     * but we continue 'till the end to have cleaner
+     * memory content.
+     */
+    for (cursor = token; cursor < tit->end; *cursor++ = 0)
+        ;
+
+    /* Adjust the end to point to the new terminating zero. */
+    tit->end = token;
 }
 
 /* Syntax formed according to RFC 1912 (RFC 1123 & 952 are more restrictive)  *
    <hname> ::= <gen-name>*["."<gen-name>]                                     *
    <gen-name> ::= <let-or-digit> <[*[<let-or-digit-or-hyphen>]<let-or-digit>] */
 char
-valid_host_name (char *address, int length)
+valid_host_name(char *address, int length)
 {
-        int             i = 0;
-        int             str_len = 0;
-        char            ret = 1;
-        char            *dup_addr = NULL;
-        char            *temp_str = NULL;
-        char            *save_ptr = NULL;
+    int i = 0;
+    int str_len = 0;
+    char ret = 1;
+    char *dup_addr = NULL;
+    char *temp_str = NULL;
+    char *save_ptr = NULL;
 
-        if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) {
-                ret = 0;
-                goto out;
-        }
+    if ((length > _POSIX_HOST_NAME_MAX) || (length < 1)) {
+        ret = 0;
+        goto out;
+    }
 
-        dup_addr = gf_strdup (address);
-        if (!dup_addr) {
-                ret = 0;
-                goto out;
-        }
+    dup_addr = gf_strdup(address);
+    if (!dup_addr) {
+        ret = 0;
+        goto out;
+    }
 
-        if (!isalnum (dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) {
-                ret = 0;
-                goto out;
-        }
+    if (!isalnum(dup_addr[length - 1]) && (dup_addr[length - 1] != '*')) {
+        ret = 0;
+        goto out;
+    }
 
-        /* Check for consecutive dots, which is invalid in a hostname and is
-         * ignored by strtok()
-         */
-        if (strstr (dup_addr, "..")) {
+    /* Check for consecutive dots, which is invalid in a hostname and is
+     * ignored by strtok()
+     */
+    if (strstr(dup_addr, "..")) {
+        ret = 0;
+        goto out;
+    }
+
+    /* gen-name */
+    temp_str = strtok_r(dup_addr, ".", &save_ptr);
+    do {
+        str_len = strlen(temp_str);
+
+        if (!isalnum(temp_str[0]) || !isalnum(temp_str[str_len - 1])) {
+            ret = 0;
+            goto out;
+        }
+        for (i = 1; i < str_len; i++) {
+            if (!isalnum(temp_str[i]) && (temp_str[i] != '-')) {
                 ret = 0;
                 goto out;
+            }
         }
-
-        /* gen-name */
-        temp_str = strtok_r (dup_addr, ".", &save_ptr);
-        do {
-                str_len = strlen (temp_str);
-
-                if (!isalnum (temp_str[0]) ||
-                    !isalnum (temp_str[str_len-1])) {
-                        ret = 0;
-                        goto out;
-                }
-                for (i = 1; i < str_len; i++) {
-                        if (!isalnum (temp_str[i]) && (temp_str[i] != '-')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-        } while ((temp_str = strtok_r (NULL, ".", &save_ptr)));
+    } while ((temp_str = strtok_r(NULL, ".", &save_ptr)));
 
 out:
-        GF_FREE (dup_addr);
-        return ret;
+    GF_FREE(dup_addr);
+    return ret;
 }
 
 /*  Matches all ipv4 address, if wildcard_acc is true  '*' wildcard pattern for*
-  subnets is considered as valid strings as well                               */
+  subnets is considered as valid strings as well */
 char
-valid_ipv4_address (char *address, int length, gf_boolean_t wildcard_acc)
-{
-        int octets = 0;
-        int value = 0;
-        char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
-        char ret = 1;
-        int is_wildcard = 0;
+valid_ipv4_address(char *address, int length, gf_boolean_t wildcard_acc)
+{
+    int octets = 0;
+    int value = 0;
+    char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
+    char ret = 1;
+    int is_wildcard = 0;
+
+    tmp = gf_strdup(address);
+
+    /*
+     * To prevent cases where last character is '.' and which have
+     * consecutive dots like ".." as strtok ignore consecutive
+     * delimiters.
+     */
+    if (length <= 0 || (strstr(address, "..")) ||
+        (!isdigit(tmp[length - 1]) && (tmp[length - 1] != '*'))) {
+        ret = 0;
+        goto out;
+    }
 
-        tmp = gf_strdup (address);
+    prev = tmp;
+    prev = strtok_r(tmp, ".", &ptr);
 
-        /*
-         * To prevent cases where last character is '.' and which have
-         * consecutive dots like ".." as strtok ignore consecutive
-         * delimiters.
-         */
-        if (length <= 0 ||
-            (strstr (address, "..")) ||
-            (!isdigit (tmp[length - 1]) && (tmp[length - 1] != '*'))) {
+    while (prev != NULL) {
+        octets++;
+        if (wildcard_acc && !strcmp(prev, "*")) {
+            is_wildcard = 1;
+        } else {
+            value = strtol(prev, &endptr, 10);
+            if ((value > 255) || (value < 0) ||
+                (endptr != NULL && *endptr != '\0')) {
                 ret = 0;
                 goto out;
+            }
         }
+        prev = strtok_r(NULL, ".", &ptr);
+    }
 
-        prev = tmp;
-        prev = strtok_r (tmp, ".", &ptr);
-
-        while (prev != NULL) {
-                octets++;
-                if (wildcard_acc && !strcmp (prev, "*")) {
-                        is_wildcard = 1;
-                } else {
-                        value = strtol (prev, &endptr, 10);
-                        if ((value > 255) || (value < 0) ||
-                            (endptr != NULL && *endptr != '\0')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-                prev = strtok_r (NULL, ".", &ptr);
-        }
-
-        if ((octets > 4) || (octets < 4 && !is_wildcard)) {
-                ret = 0;
-        }
+    if ((octets > 4) || (octets < 4 && !is_wildcard)) {
+        ret = 0;
+    }
 
 out:
-        GF_FREE (tmp);
-        return ret;
+    GF_FREE(tmp);
+    return ret;
 }
 
 /**
@@ -2479,152 +2487,153 @@ out:
  *         _gf_false otherwise.
  */
 gf_boolean_t
-valid_ipv4_subnetwork (const char *address)
+valid_ipv4_subnetwork(const char *address)
 {
-        char         *slash     = NULL;
-        char         *paddr     = NULL;
-        char         *endptr    = NULL;
-        long         prefixlen  = -1;
-        gf_boolean_t retv       = _gf_true;
+    char *slash = NULL;
+    char *paddr = NULL;
+    char *endptr = NULL;
+    long prefixlen = -1;
+    gf_boolean_t retv = _gf_true;
 
-        if (address == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return _gf_false;
-        }
-
-        paddr = gf_strdup (address);
-        if (paddr == NULL) /* ENOMEM */
-                return _gf_false;
-
-        /*
-         * INVALID: If '/' is not present OR
-         *          Nothing specified after '/'
-         */
-        slash = strchr(paddr, '/');
-        if ((slash == NULL) || (slash[1] == '\0')) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT, "Invalid IPv4 "
-                                  "subnetwork format");
-                retv = _gf_false;
-                goto out;
-        }
+    if (address == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return _gf_false;
+    }
 
-        *slash = '\0';
-        retv = valid_ipv4_address (paddr, strlen(paddr), _gf_false);
-        if (retv == _gf_false) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT,
-                                  "Invalid IPv4 subnetwork address");
-                goto out;
-        }
-        /*
-         * Reset errno before checking it
-         */
-        errno = 0;
-        prefixlen = strtol (slash + 1, &endptr, 10);
-        if ((errno != 0) || (*endptr != '\0') ||
-            (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INVALID_IPV4_FORMAT,
-                                  "Invalid IPv4 subnetwork mask");
-                retv = _gf_false;
-                goto out;
-        }
+    paddr = gf_strdup(address);
+    if (paddr == NULL) /* ENOMEM */
+        return _gf_false;
 
-        retv = _gf_true;
+    /*
+     * INVALID: If '/' is not present OR
+     *          Nothing specified after '/'
+     */
+    slash = strchr(paddr, '/');
+    if ((slash == NULL) || (slash[1] == '\0')) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 "
+                         "subnetwork format");
+        retv = _gf_false;
+        goto out;
+    }
+
+    *slash = '\0';
+    retv = valid_ipv4_address(paddr, strlen(paddr), _gf_false);
+    if (retv == _gf_false) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 subnetwork address");
+        goto out;
+    }
+    /*
+     * Reset errno before checking it
+     */
+    errno = 0;
+    prefixlen = strtol(slash + 1, &endptr, 10);
+    if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) ||
+        (prefixlen > IPv4_ADDR_SIZE)) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INVALID_IPV4_FORMAT,
+                         "Invalid IPv4 subnetwork mask");
+        retv = _gf_false;
+        goto out;
+    }
+
+    retv = _gf_true;
 out:
-        GF_FREE (paddr);
-        return retv;
+    GF_FREE(paddr);
+    return retv;
 }
 
 char
-valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc)
-{
-        int hex_numbers = 0;
-        int value = 0;
-        int i = 0;
-        char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
-        char ret = 1;
-        int is_wildcard = 0;
-        int is_compressed = 0;
-
-        tmp = gf_strdup (address);
-
-        /* Check for '%' for link local addresses */
-        endptr = strchr(tmp, '%');
-        if (endptr) {
-                *endptr = '\0';
-                length = strlen(tmp);
-                endptr = NULL;
-        }
-
-        /* Check for compressed form */
-        if (length <= 0 || tmp[length - 1] == ':') {
+valid_ipv6_address(char *address, int length, gf_boolean_t wildcard_acc)
+{
+    int hex_numbers = 0;
+    int value = 0;
+    int i = 0;
+    char *tmp = NULL, *ptr = NULL, *prev = NULL, *endptr = NULL;
+    char ret = 1;
+    int is_wildcard = 0;
+    int is_compressed = 0;
+
+    tmp = gf_strdup(address);
+
+    /* Check for '%' for link local addresses */
+    endptr = strchr(tmp, '%');
+    if (endptr) {
+        *endptr = '\0';
+        length = strlen(tmp);
+        endptr = NULL;
+    }
+
+    /* Check for compressed form */
+    if (length <= 0 || tmp[length - 1] == ':') {
+        ret = 0;
+        goto out;
+    }
+    for (i = 0; i < (length - 1); i++) {
+        if (tmp[i] == ':' && tmp[i + 1] == ':') {
+            if (is_compressed == 0)
+                is_compressed = 1;
+            else {
                 ret = 0;
                 goto out;
+            }
         }
-        for (i = 0; i < (length - 1) ; i++) {
-                if (tmp[i] == ':' && tmp[i + 1] == ':') {
-                        if (is_compressed == 0)
-                                is_compressed = 1;
-                        else {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-        }
+    }
 
-        prev = strtok_r (tmp, ":", &ptr);
-
-        while (prev != NULL) {
-                hex_numbers++;
-                if (wildcard_acc && !strcmp (prev, "*")) {
-                        is_wildcard = 1;
-                } else {
-                        value = strtol (prev, &endptr, 16);
-                        if ((value > 0xffff) || (value < 0)
-                        || (endptr != NULL && *endptr != '\0')) {
-                                ret = 0;
-                                goto out;
-                        }
-                }
-                prev = strtok_r (NULL, ":", &ptr);
-        }
+    prev = strtok_r(tmp, ":", &ptr);
 
-        if ((hex_numbers > 8) || (hex_numbers < 8 && !is_wildcard
-            && !is_compressed)) {
+    while (prev != NULL) {
+        hex_numbers++;
+        if (wildcard_acc && !strcmp(prev, "*")) {
+            is_wildcard = 1;
+        } else {
+            value = strtol(prev, &endptr, 16);
+            if ((value > 0xffff) || (value < 0) ||
+                (endptr != NULL && *endptr != '\0')) {
                 ret = 0;
+                goto out;
+            }
         }
+        prev = strtok_r(NULL, ":", &ptr);
+    }
+
+    if ((hex_numbers > 8) ||
+        (hex_numbers < 8 && !is_wildcard && !is_compressed)) {
+        ret = 0;
+    }
 
 out:
-        GF_FREE (tmp);
-        return ret;
+    GF_FREE(tmp);
+    return ret;
 }
 
 char
-valid_internet_address (char *address, gf_boolean_t wildcard_acc)
+valid_internet_address(char *address, gf_boolean_t wildcard_acc)
 {
-        char ret = 0;
-        int length = 0;
+    char ret = 0;
+    int length = 0;
 
-        if (address == NULL) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                goto out;
-        }
+    if (address == NULL) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        goto out;
+    }
 
-        length = strlen (address);
-        if (length == 0)
-                goto out;
+    length = strlen(address);
+    if (length == 0)
+        goto out;
 
-        if (valid_ipv4_address (address, length, wildcard_acc)
-            || valid_ipv6_address (address, length, wildcard_acc)
-            || valid_host_name (address, length))
-                ret = 1;
+    if (valid_ipv4_address(address, length, wildcard_acc) ||
+        valid_ipv6_address(address, length, wildcard_acc) ||
+        valid_host_name(address, length))
+        ret = 1;
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2634,56 +2643,56 @@ out:
  *
  * @return _gf_true if "address" is "*" (anonymous) 'OR'
  *                  if "address" is valid FQDN or valid IPv4/6 address 'OR'
- *                  if "address" contains wildcard chars e.g. "'*' or '?' or '['"
- *                  if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n)
- *         _gf_false otherwise
+ *                  if "address" contains wildcard chars e.g. "'*' or '?' or
+ * '['" if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n) _gf_false
+ * otherwise
  *
  *
  * NB: If the user/admin set for wildcard pattern, then it does not have
  *     to be validated. Make it similar to the way exportfs (kNFS) works.
  */
 gf_boolean_t
-valid_mount_auth_address (char *address)
+valid_mount_auth_address(char *address)
 {
-        int    length = 0;
-        char   *cp    = NULL;
+    int length = 0;
+    char *cp = NULL;
 
-        /* 1. Check for "NULL and empty string */
-        if ((address == NULL) || (address[0] == '\0')){
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "argument invalid");
-                return _gf_false;
-        }
+    /* 1. Check for "NULL and empty string */
+    if ((address == NULL) || (address[0] == '\0')) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "argument invalid");
+        return _gf_false;
+    }
 
-        /* 2. Check for Anonymous */
-        if (strcmp(address, "*") == 0)
-                return _gf_true;
+    /* 2. Check for Anonymous */
+    if (strcmp(address, "*") == 0)
+        return _gf_true;
 
-        for (cp = address; *cp; cp++) {
-                /* 3. Check for wildcard pattern */
-                if (*cp == '*' || *cp == '?' || *cp == '[') {
-                        return _gf_true;
-                }
-
-                /*
-                 * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n
-                 * TODO: check for IPv6 subnetwork
-                 * NB: Wildcard must not be mixed with subnetwork.
-                 */
-                if (*cp == '/') {
-                        return valid_ipv4_subnetwork (address);
-                }
+    for (cp = address; *cp; cp++) {
+        /* 3. Check for wildcard pattern */
+        if (*cp == '*' || *cp == '?' || *cp == '[') {
+            return _gf_true;
         }
 
-        /* 5. Check for v4/v6 IP addr and FQDN/hostname */
-        length = strlen (address);
-        if ((valid_ipv4_address (address, length, _gf_false)) ||
-            (valid_ipv6_address (address, length, _gf_false)) ||
-            (valid_host_name (address, length))) {
-                return _gf_true;
+        /*
+         * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n
+         * TODO: check for IPv6 subnetwork
+         * NB: Wildcard must not be mixed with subnetwork.
+         */
+        if (*cp == '/') {
+            return valid_ipv4_subnetwork(address);
         }
+    }
 
-        return _gf_false;
+    /* 5. Check for v4/v6 IP addr and FQDN/hostname */
+    length = strlen(address);
+    if ((valid_ipv4_address(address, length, _gf_false)) ||
+        (valid_ipv6_address(address, length, _gf_false)) ||
+        (valid_host_name(address, length))) {
+        return _gf_true;
+    }
+
+    return _gf_false;
 }
 
 /**
@@ -2694,40 +2703,39 @@ valid_mount_auth_address (char *address)
  * @return _gf_true if a and b have same ipv{4,6} addr, _gf_false otherwise
  */
 gf_boolean_t
-gf_sock_union_equal_addr (union gf_sock_union *a,
-                          union gf_sock_union *b)
+gf_sock_union_equal_addr(union gf_sock_union *a, union gf_sock_union *b)
 {
-        if (!a || !b) {
-                gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Invalid arguments to gf_sock_union_equal_addr");
-                return _gf_false;
-        }
+    if (!a || !b) {
+        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Invalid arguments to gf_sock_union_equal_addr");
+        return _gf_false;
+    }
 
-        if (a->storage.ss_family != b->storage.ss_family)
-                return _gf_false;
+    if (a->storage.ss_family != b->storage.ss_family)
+        return _gf_false;
 
-        switch (a->storage.ss_family) {
+    switch (a->storage.ss_family) {
         case AF_INET:
-                if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr)
-                        return _gf_true;
-                else
-                        return _gf_false;
+            if (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr)
+                return _gf_true;
+            else
+                return _gf_false;
 
         case AF_INET6:
-                if (memcmp ((void *)(&a->sin6.sin6_addr),
-                            (void *)(&b->sin6.sin6_addr),
-                            sizeof (a->sin6.sin6_addr)))
-                        return _gf_false;
-                else
-                        return _gf_true;
+            if (memcmp((void *)(&a->sin6.sin6_addr),
+                       (void *)(&b->sin6.sin6_addr), sizeof(a->sin6.sin6_addr)))
+                return _gf_false;
+            else
+                return _gf_true;
 
         default:
-                gf_msg_debug ("common-utils", 0, "Unsupported/invalid address "
-                              "family");
-                break;
-        }
+            gf_msg_debug("common-utils", 0,
+                         "Unsupported/invalid address "
+                         "family");
+            break;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 /*
@@ -2743,62 +2751,61 @@ gf_sock_union_equal_addr (union gf_sock_union *a,
 gf_boolean_t
 mask_match(const uint32_t a, const uint32_t b, const uint32_t m)
 {
-        return (((a ^ b) & m) == 0);
+    return (((a ^ b) & m) == 0);
 }
 
-
 /*Thread safe conversion function*/
 char *
-uuid_utoa (uuid_t uuid)
+uuid_utoa(uuid_t uuid)
 {
-        char *uuid_buffer = glusterfs_uuid_buf_get ();
-        gf_uuid_unparse (uuid, uuid_buffer);
-        return uuid_buffer;
+    char *uuid_buffer = glusterfs_uuid_buf_get();
+    gf_uuid_unparse(uuid, uuid_buffer);
+    return uuid_buffer;
 }
 
 /*Re-entrant conversion function*/
 char *
-uuid_utoa_r (uuid_t uuid, char *dst)
+uuid_utoa_r(uuid_t uuid, char *dst)
 {
-        if(!dst)
-                return NULL;
-        gf_uuid_unparse (uuid, dst);
-        return dst;
+    if (!dst)
+        return NULL;
+    gf_uuid_unparse(uuid, dst);
+    return dst;
 }
 
 /*Thread safe conversion function*/
 char *
-lkowner_utoa (gf_lkowner_t *lkowner)
+lkowner_utoa(gf_lkowner_t *lkowner)
 {
-        char *lkowner_buffer = glusterfs_lkowner_buf_get ();
-        lkowner_unparse (lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE);
-        return lkowner_buffer;
+    char *lkowner_buffer = glusterfs_lkowner_buf_get();
+    lkowner_unparse(lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE);
+    return lkowner_buffer;
 }
 
 /*Re-entrant conversion function*/
 char *
-lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len)
+lkowner_utoa_r(gf_lkowner_t *lkowner, char *dst, int len)
 {
-        if(!dst)
-                return NULL;
-        lkowner_unparse (lkowner, dst, len);
-        return dst;
+    if (!dst)
+        return NULL;
+    lkowner_unparse(lkowner, dst, len);
+    return dst;
 }
 
 gf_boolean_t
-is_valid_lease_id (const char *lease_id)
+is_valid_lease_id(const char *lease_id)
 {
-        int i = 0;
-        gf_boolean_t valid = _gf_false;
+    int i = 0;
+    gf_boolean_t valid = _gf_false;
 
-        for (i = 0; i < LEASE_ID_SIZE; i++) {
-                if (lease_id[i] != 0) {
-                        valid = _gf_true;
-                        goto out;
-                }
+    for (i = 0; i < LEASE_ID_SIZE; i++) {
+        if (lease_id[i] != 0) {
+            valid = _gf_true;
+            goto out;
         }
+    }
 out:
-        return valid;
+    return valid;
 }
 
 /* Lease_id can be a either in printable or non printable binary
@@ -2815,108 +2822,107 @@ out:
  * subsequent call to this function will override the same buffer.
  */
 char *
-leaseid_utoa (const char *lease_id)
-{
-        char *buf = NULL;
-        int   i   = 0;
-        int   j   = 0;
-
-        buf = glusterfs_leaseid_buf_get ();
-        if (!buf)
-                goto out;
-
-        for (i = 0; i < LEASE_ID_SIZE; i++) {
-                if (i && !(i % 2)) {
-                        buf[j] = '-';
-                        j++;
-                }
-                sprintf (&buf[j], "%02hhx", lease_id[i]);
-                j += 2;
-                if (j == GF_LEASE_ID_BUF_SIZE)
-                        break;
-        }
-        buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0';
+leaseid_utoa(const char *lease_id)
+{
+    char *buf = NULL;
+    int i = 0;
+    int j = 0;
+
+    buf = glusterfs_leaseid_buf_get();
+    if (!buf)
+        goto out;
+
+    for (i = 0; i < LEASE_ID_SIZE; i++) {
+        if (i && !(i % 2)) {
+            buf[j] = '-';
+            j++;
+        }
+        sprintf(&buf[j], "%02hhx", lease_id[i]);
+        j += 2;
+        if (j == GF_LEASE_ID_BUF_SIZE)
+            break;
+    }
+    buf[GF_LEASE_ID_BUF_SIZE - 1] = '\0';
 out:
-        return buf;
+    return buf;
 }
 
 char *
-gf_leaseid_get ()
+gf_leaseid_get()
 {
-        return glusterfs_leaseid_buf_get ();
+    return glusterfs_leaseid_buf_get();
 }
 
 char *
-gf_existing_leaseid ()
+gf_existing_leaseid()
 {
-        return glusterfs_leaseid_exist ();
+    return glusterfs_leaseid_exist();
 }
 
-void* gf_array_elem (void *a, int index, size_t elem_size)
+void *
+gf_array_elem(void *a, int index, size_t elem_size)
 {
-        uint8_t* ptr = a;
-        return (void*)(ptr + index * elem_size);
+    uint8_t *ptr = a;
+    return (void *)(ptr + index * elem_size);
 }
 
 void
-gf_elem_swap (void *x, void *y, size_t l) {
-        uint8_t *a = x, *b = y, c;
-        while(l--) {
-                c = *a;
-                *a++ = *b;
-                *b++ = c;
-        }
+gf_elem_swap(void *x, void *y, size_t l)
+{
+    uint8_t *a = x, *b = y, c;
+    while (l--) {
+        c = *a;
+        *a++ = *b;
+        *b++ = c;
+    }
 }
 
 void
-gf_array_insertionsort (void *A, int l, int r, size_t elem_size,
-                        gf_cmp cmp)
-{
-        int  i = l;
-        int  N = r+1;
-        void *Temp = NULL;
-        int  j = 0;
-
-        for(i = l; i < N; i++) {
-                Temp = gf_array_elem (A, i, elem_size);
-                j = i - 1;
-                while (j >= 0 && (cmp (Temp, gf_array_elem (A, j, elem_size))
-                      < 0)) {
-                        gf_elem_swap (Temp, gf_array_elem (A, j, elem_size),
-                                      elem_size);
-                        Temp = gf_array_elem (A, j, elem_size);
-                        j = j-1;
-                }
+gf_array_insertionsort(void *A, int l, int r, size_t elem_size, gf_cmp cmp)
+{
+    int i = l;
+    int N = r + 1;
+    void *Temp = NULL;
+    int j = 0;
+
+    for (i = l; i < N; i++) {
+        Temp = gf_array_elem(A, i, elem_size);
+        j = i - 1;
+        while (j >= 0 && (cmp(Temp, gf_array_elem(A, j, elem_size)) < 0)) {
+            gf_elem_swap(Temp, gf_array_elem(A, j, elem_size), elem_size);
+            Temp = gf_array_elem(A, j, elem_size);
+            j = j - 1;
         }
+    }
 }
 
 int
-gf_is_str_int (const char *value)
+gf_is_str_int(const char *value)
 {
-        int     flag = 0;
-        char   *str  = NULL;
-        char   *fptr = NULL;
+    int flag = 0;
+    char *str = NULL;
+    char *fptr = NULL;
 
-        GF_VALIDATE_OR_GOTO (THIS->name, value, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, value, out);
 
-        str = gf_strdup (value);
-        if (!str)
-                goto out;
+    str = gf_strdup(value);
+    if (!str)
+        goto out;
 
-        fptr = str;
+    fptr = str;
 
-        while (*str) {
-                if (!isdigit(*str)) {
-                        flag = 1;
-                        goto out;
-                }
-                str++;
+    while (*str) {
+        if (!isdigit(*str)) {
+            flag = 1;
+            goto out;
         }
+        str++;
+    }
 
 out:
-        GF_FREE (fptr);
+    GF_FREE(fptr);
 
-        return flag;
+    return flag;
 }
 /*
  * rounds up nr to power of two. If nr is already a power of two, just returns
@@ -2924,22 +2930,22 @@ out:
  */
 
 int32_t
-gf_roundup_power_of_two (int32_t nr)
+gf_roundup_power_of_two(int32_t nr)
 {
-        int32_t result = 1;
+    int32_t result = 1;
 
-        if (nr < 0) {
-                gf_msg ("common-utils", GF_LOG_WARNING, 0,
-                        LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed");
-                result = -1;
-                goto out;
-        }
+    if (nr < 0) {
+        gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+               "negative number passed");
+        result = -1;
+        goto out;
+    }
 
-        while (result < nr)
-                result *= 2;
+    while (result < nr)
+        result *= 2;
 
 out:
-        return result;
+    return result;
 }
 
 /*
@@ -2948,392 +2954,384 @@ out:
  */
 
 int32_t
-gf_roundup_next_power_of_two (int32_t nr)
+gf_roundup_next_power_of_two(int32_t nr)
 {
-        int32_t result = 1;
+    int32_t result = 1;
 
-        if (nr < 0) {
-                gf_msg ("common-utils", GF_LOG_WARNING, 0,
-                        LG_MSG_NEGATIVE_NUM_PASSED, "negative number passed");
-                result = -1;
-                goto out;
-        }
+    if (nr < 0) {
+        gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+               "negative number passed");
+        result = -1;
+        goto out;
+    }
 
-        while (result <= nr)
-                result *= 2;
+    while (result <= nr)
+        result *= 2;
 
 out:
-        return result;
+    return result;
 }
 
 int
-get_vol_type (int type, int dist_count, int brick_count)
+get_vol_type(int type, int dist_count, int brick_count)
 {
-        if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) &&
-             (dist_count < brick_count))
-              type = type + GF_CLUSTER_TYPE_MAX - 1;
+    if ((type != GF_CLUSTER_TYPE_TIER) && (type > 0) &&
+        (dist_count < brick_count))
+        type = type + GF_CLUSTER_TYPE_MAX - 1;
 
-        return type;
+    return type;
 }
 
 int
-validate_brick_name (char *brick)
+validate_brick_name(char *brick)
 {
-        char *delimiter = NULL;
-        int  ret = 0;
-        delimiter = strrchr (brick, ':');
-        if (!delimiter || delimiter == brick
-            || *(delimiter+1) != '/')
-                ret = -1;
+    char *delimiter = NULL;
+    int ret = 0;
+    delimiter = strrchr(brick, ':');
+    if (!delimiter || delimiter == brick || *(delimiter + 1) != '/')
+        ret = -1;
 
-        return ret;
+    return ret;
 }
 
 char *
-get_host_name (char *word, char **host)
+get_host_name(char *word, char **host)
 {
-        char *delimiter = NULL;
-        delimiter = strrchr (word, ':');
-        if (delimiter)
-                *delimiter = '\0';
-        else
-                return NULL;
-        *host = word;
-        return *host;
+    char *delimiter = NULL;
+    delimiter = strrchr(word, ':');
+    if (delimiter)
+        *delimiter = '\0';
+    else
+        return NULL;
+    *host = word;
+    return *host;
 }
 
-
 char *
-get_path_name (char *word, char **path)
+get_path_name(char *word, char **path)
 {
-        char *delimiter = NULL;
-        delimiter = strchr (word, '/');
-        if (!delimiter)
-                return NULL;
-        *path = delimiter;
-        return *path;
+    char *delimiter = NULL;
+    delimiter = strchr(word, '/');
+    if (!delimiter)
+        return NULL;
+    *path = delimiter;
+    return *path;
 }
 
 void
-gf_path_strip_trailing_slashes (char *path)
+gf_path_strip_trailing_slashes(char *path)
 {
-        int i = 0;
-        int len = 0;
+    int i = 0;
+    int len = 0;
 
-        if (!path)
-                return;
+    if (!path)
+        return;
 
-        len = strlen (path);
-        for (i = len - 1; i > 0; i--) {
-                if (path[i] != '/')
-                        break;
-	}
+    len = strlen(path);
+    for (i = len - 1; i > 0; i--) {
+        if (path[i] != '/')
+            break;
+    }
 
-        if (i < (len -1))
-                path [i+1] = '\0';
+    if (i < (len - 1))
+        path[i + 1] = '\0';
 
-        return;
+    return;
 }
 
 uint64_t
-get_mem_size ()
+get_mem_size()
 {
-        uint64_t memsize = -1;
+    uint64_t memsize = -1;
 
 #if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS
 
-	uint64_t page_size = 0;
-	uint64_t num_pages = 0;
+    uint64_t page_size = 0;
+    uint64_t num_pages = 0;
 
-	page_size = sysconf (_SC_PAGESIZE);
-	num_pages = sysconf (_SC_PHYS_PAGES);
+    page_size = sysconf(_SC_PAGESIZE);
+    num_pages = sysconf(_SC_PHYS_PAGES);
 
-	memsize = page_size * num_pages;
+    memsize = page_size * num_pages;
 #endif
 
 #if defined GF_DARWIN_HOST_OS
 
-	size_t len = sizeof(memsize);
-	int name [] = { CTL_HW, HW_PHYSMEM };
+    size_t len = sizeof(memsize);
+    int name[] = {CTL_HW, HW_PHYSMEM};
 
-	sysctl (name, 2, &memsize, &len, NULL, 0);
+    sysctl(name, 2, &memsize, &len, NULL, 0);
 #endif
 
 #if defined __NetBSD__
 
-	size_t len = sizeof(memsize);
-	int name64 [] = { CTL_HW, HW_PHYSMEM64 };
+    size_t len = sizeof(memsize);
+    int name64[] = {CTL_HW, HW_PHYSMEM64};
 
-	sysctl (name64, 2, &memsize, &len, NULL, 0);
-	if (memsize == -1)
-		sysctl (name64, 2, &memsize, &len, NULL, 0);
+    sysctl(name64, 2, &memsize, &len, NULL, 0);
+    if (memsize == -1)
+        sysctl(name64, 2, &memsize, &len, NULL, 0);
 #endif
-	return memsize;
+    return memsize;
 }
 
 /* Strips all whitespace characters in a string and returns length of new string
  * on success
  */
 int
-gf_strip_whitespace (char *str, int len)
+gf_strip_whitespace(char *str, int len)
 {
-        int     i = 0;
-        int     new_len = 0;
-        char    *new_str = NULL;
+    int i = 0;
+    int new_len = 0;
+    char *new_str = NULL;
 
-        GF_ASSERT (str);
+    GF_ASSERT(str);
 
-        new_str = GF_MALLOC (len + 1, gf_common_mt_char);
-        if (new_str == NULL)
-                return -1;
+    new_str = GF_MALLOC(len + 1, gf_common_mt_char);
+    if (new_str == NULL)
+        return -1;
 
-        for (i = 0; i < len; i++) {
-                if (!isspace (str[i]))
-                        new_str[new_len++] = str[i];
-        }
-        new_str[new_len] = '\0';
+    for (i = 0; i < len; i++) {
+        if (!isspace(str[i]))
+            new_str[new_len++] = str[i];
+    }
+    new_str[new_len] = '\0';
 
-        if (new_len != len) {
-                snprintf(str, new_len + 1, "%s", new_str);
-        }
+    if (new_len != len) {
+        snprintf(str, new_len + 1, "%s", new_str);
+    }
 
-        GF_FREE (new_str);
-        return new_len;
+    GF_FREE(new_str);
+    return new_len;
 }
 
 int
-gf_canonicalize_path (char *path)
+gf_canonicalize_path(char *path)
 {
-        int             ret                  = -1;
-        int             path_len             = 0;
-        int             dir_path_len         = 0;
-        char           *tmppath              = NULL;
-        char           *dir                  = NULL;
-        char           *tmpstr               = NULL;
+    int ret = -1;
+    int path_len = 0;
+    int dir_path_len = 0;
+    char *tmppath = NULL;
+    char *dir = NULL;
+    char *tmpstr = NULL;
 
-        if (!path || *path != '/')
-                goto out;
+    if (!path || *path != '/')
+        goto out;
+
+    if (!strcmp(path, "/"))
+        return 0;
 
-        if (!strcmp (path, "/"))
-                return 0;
+    tmppath = gf_strdup(path);
+    if (!tmppath)
+        goto out;
 
-        tmppath = gf_strdup (path);
-        if (!tmppath)
-                goto out;
+    /* Strip the extra slashes and return */
+    bzero(path, strlen(path));
+    path[0] = '/';
+    dir = strtok_r(tmppath, "/", &tmpstr);
 
-        /* Strip the extra slashes and return */
-        bzero (path, strlen(path));
-        path[0] = '/';
-        dir = strtok_r(tmppath, "/", &tmpstr);
-
-        while (dir) {
-                dir_path_len = strlen(dir);
-                strncpy ((path + path_len + 1), dir, dir_path_len);
-                path_len += dir_path_len + 1;
-                dir = strtok_r (NULL, "/", &tmpstr);
-                if (dir) {
-                        path[path_len] = '/';
-                }
+    while (dir) {
+        dir_path_len = strlen(dir);
+        strncpy((path + path_len + 1), dir, dir_path_len);
+        path_len += dir_path_len + 1;
+        dir = strtok_r(NULL, "/", &tmpstr);
+        if (dir) {
+            path[path_len] = '/';
         }
-        path[path_len] = '\0';
-        ret = 0;
+    }
+    path[path_len] = '\0';
+    ret = 0;
 
- out:
-        if (ret)
-                gf_msg ("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR,
-                        "Path manipulation failed");
+out:
+    if (ret)
+        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR,
+               "Path manipulation failed");
 
-        GF_FREE(tmppath);
+    GF_FREE(tmppath);
 
-        return ret;
+    return ret;
 }
 
 static const char *__gf_timefmts[] = {
-        "%F %T",
-        "%Y/%m/%d-%T",
-        "%b %d %T",
-        "%F %H%M%S",
-	"%Y-%m-%d-%T",
-        "%s",
+    "%F %T", "%Y/%m/%d-%T", "%b %d %T", "%F %H%M%S", "%Y-%m-%d-%T", "%s",
 };
 
 static const char *__gf_zerotimes[] = {
-        "0000-00-00 00:00:00",
-        "0000/00/00-00:00:00",
-        "xxx 00 00:00:00",
-        "0000-00-00 000000",
-	"0000-00-00-00:00:00",
-        "0",
+    "0000-00-00 00:00:00", "0000/00/00-00:00:00", "xxx 00 00:00:00",
+    "0000-00-00 000000",   "0000-00-00-00:00:00", "0",
 };
 
 void
-_gf_timestuff (const char ***fmts, const char ***zeros)
+_gf_timestuff(const char ***fmts, const char ***zeros)
 {
-        *fmts = __gf_timefmts;
-        *zeros = __gf_zerotimes;
+    *fmts = __gf_timefmts;
+    *zeros = __gf_zerotimes;
 }
 
-
 char *
-generate_glusterfs_ctx_id (void)
+generate_glusterfs_ctx_id(void)
 {
-        uuid_t         ctxid;
-        char          *tmp = NULL;
+    uuid_t ctxid;
+    char *tmp = NULL;
 
-        gf_uuid_generate (ctxid);
-        tmp = uuid_utoa (ctxid);
+    gf_uuid_generate(ctxid);
+    tmp = uuid_utoa(ctxid);
 
-        return gf_strdup (tmp);
+    return gf_strdup(tmp);
 }
 
 char *
-gf_get_reserved_ports ()
+gf_get_reserved_ports()
 {
-        char    *ports_info  = NULL;
+    char *ports_info = NULL;
 #if defined GF_LINUX_HOST_OS
-        int     proc_fd      = -1;
-        char    *proc_file   = "/proc/sys/net/ipv4/ip_local_reserved_ports";
-        char    buffer[4096] = {0,};
-        int32_t ret          = -1;
-
-        proc_fd = open (proc_file, O_RDONLY);
-        if (proc_fd == -1) {
-                /* What should be done in this case? error out from here
-                 * and thus stop the glusterfs process from starting or
-                 * continue with older method of using any of the available
-                 * port? For now 2nd option is considered.
-                 */
-                gf_msg ("glusterfs", GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "could not open the file "
-                        "/proc/sys/net/ipv4/ip_local_reserved_ports for "
-                        "getting reserved ports info");
-                goto out;
-        }
-
-        ret = sys_read (proc_fd, buffer, sizeof (buffer)-1);
-        if (ret < 0) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "could not read the file %s for"
-                        " getting reserved ports info", proc_file);
-                goto out;
-        }
-
-        buffer[ret] = '\0';
-        ports_info = gf_strdup (buffer);
+    int proc_fd = -1;
+    char *proc_file = "/proc/sys/net/ipv4/ip_local_reserved_ports";
+    char buffer[4096] = {
+        0,
+    };
+    int32_t ret = -1;
+
+    proc_fd = open(proc_file, O_RDONLY);
+    if (proc_fd == -1) {
+        /* What should be done in this case? error out from here
+         * and thus stop the glusterfs process from starting or
+         * continue with older method of using any of the available
+         * port? For now 2nd option is considered.
+         */
+        gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "could not open the file "
+               "/proc/sys/net/ipv4/ip_local_reserved_ports for "
+               "getting reserved ports info");
+        goto out;
+    }
+
+    ret = sys_read(proc_fd, buffer, sizeof(buffer) - 1);
+    if (ret < 0) {
+        gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "could not read the file %s for"
+               " getting reserved ports info",
+               proc_file);
+        goto out;
+    }
+
+    buffer[ret] = '\0';
+    ports_info = gf_strdup(buffer);
 
 out:
-        if (proc_fd != -1)
-                sys_close (proc_fd);
+    if (proc_fd != -1)
+        sys_close(proc_fd);
 #endif /* GF_LINUX_HOST_OS */
-        return ports_info;
+    return ports_info;
 }
 
 int
-gf_process_reserved_ports (unsigned char *ports, uint32_t ceiling)
+gf_process_reserved_ports(unsigned char *ports, uint32_t ceiling)
 {
-        int      ret         = -1;
+    int ret = -1;
 
-        memset (ports, 0, GF_PORT_ARRAY_SIZE);
+    memset(ports, 0, GF_PORT_ARRAY_SIZE);
 
 #if defined GF_LINUX_HOST_OS
-        char    *ports_info  = NULL;
-        char    *tmp         = NULL;
-        char    *blocked_port = NULL;
-
-        ports_info = gf_get_reserved_ports ();
-        if (!ports_info) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, 0,
-                        LG_MSG_RESERVED_PORTS_ERROR, "Not able to get reserved"
-                        " ports, hence there is a possibility that glusterfs "
-                        "may consume reserved port");
-                goto out;
-        }
+    char *ports_info = NULL;
+    char *tmp = NULL;
+    char *blocked_port = NULL;
 
-        blocked_port = strtok_r (ports_info, ",\n",&tmp);
+    ports_info = gf_get_reserved_ports();
+    if (!ports_info) {
+        gf_msg("glusterfs", GF_LOG_WARNING, 0, LG_MSG_RESERVED_PORTS_ERROR,
+               "Not able to get reserved"
+               " ports, hence there is a possibility that glusterfs "
+               "may consume reserved port");
+        goto out;
+    }
 
-        while (blocked_port) {
-                gf_ports_reserved (blocked_port, ports, ceiling);
-                blocked_port = strtok_r (NULL, ",\n", &tmp);
-        }
+    blocked_port = strtok_r(ports_info, ",\n", &tmp);
 
-        ret = 0;
+    while (blocked_port) {
+        gf_ports_reserved(blocked_port, ports, ceiling);
+        blocked_port = strtok_r(NULL, ",\n", &tmp);
+    }
+
+    ret = 0;
 
 out:
-        GF_FREE (ports_info);
+    GF_FREE(ports_info);
 
 #else  /* FIXME: Non Linux Host */
-        ret = 0;
+    ret = 0;
 #endif /* GF_LINUX_HOST_OS */
 
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-gf_ports_reserved (char *blocked_port, unsigned char *ports, uint32_t ceiling)
-{
-        gf_boolean_t    result      = _gf_false;
-        char            *range_port = NULL;
-        int32_t         tmp_port1   = -1;
-        int32_t         tmp_port2   = -1;
-
-        if (strstr (blocked_port, "-") == NULL) {
-                /* get rid of the new line character*/
-                if (blocked_port[strlen(blocked_port) -1] == '\n')
-                        blocked_port[strlen(blocked_port) -1] = '\0';
-                if (gf_string2int32 (blocked_port, &tmp_port1) == 0) {
-                        if (tmp_port1 > ceiling
-                            || tmp_port1 < 0) {
-                                gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0,
-                                        LG_MSG_INVALID_PORT, "invalid port %d",
-                                        tmp_port1);
-                                result = _gf_true;
-                                goto out;
-                        } else {
-                                gf_msg_debug ("glusterfs", 0, "blocking port "
-                                              "%d", tmp_port1);
-                                BIT_SET (ports, tmp_port1);
-                        }
-                } else {
-                        gf_msg ("glusterfs-socket", GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_PORT, "%s is not a valid port "
-                                "identifier", blocked_port);
-                        result = _gf_true;
-                        goto out;
-                }
+gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling)
+{
+    gf_boolean_t result = _gf_false;
+    char *range_port = NULL;
+    int32_t tmp_port1 = -1;
+    int32_t tmp_port2 = -1;
+
+    if (strstr(blocked_port, "-") == NULL) {
+        /* get rid of the new line character*/
+        if (blocked_port[strlen(blocked_port) - 1] == '\n')
+            blocked_port[strlen(blocked_port) - 1] = '\0';
+        if (gf_string2int32(blocked_port, &tmp_port1) == 0) {
+            if (tmp_port1 > ceiling || tmp_port1 < 0) {
+                gf_msg("glusterfs-socket", GF_LOG_WARNING, 0,
+                       LG_MSG_INVALID_PORT, "invalid port %d", tmp_port1);
+                result = _gf_true;
+                goto out;
+            } else {
+                gf_msg_debug("glusterfs", 0,
+                             "blocking port "
+                             "%d",
+                             tmp_port1);
+                BIT_SET(ports, tmp_port1);
+            }
         } else {
-                range_port = strtok (blocked_port, "-");
-                if (!range_port){
-                        result = _gf_true;
-                        goto out;
-                }
-                if (gf_string2int32 (range_port, &tmp_port1) == 0) {
-                        if (tmp_port1 > ceiling)
-                                tmp_port1 = ceiling;
-                        if (tmp_port1 < 0)
-                                tmp_port1 = 0;
-                }
-                range_port = strtok (NULL, "-");
-                if (!range_port) {
-                        result = _gf_true;
-                        goto out;
-                }
-                /* get rid of the new line character*/
-                if (range_port[strlen(range_port) -1] == '\n')
-                        range_port[strlen(range_port) - 1] = '\0';
-                if (gf_string2int32 (range_port, &tmp_port2) == 0) {
-                        if (tmp_port2 > ceiling)
-                                tmp_port2 = ceiling;
-                        if (tmp_port2 < 0)
-                                tmp_port2 = 0;
-                }
-                gf_msg_debug ("glusterfs", 0, "lower: %d, higher: %d",
-                              tmp_port1, tmp_port2);
-                for (; tmp_port1 <= tmp_port2; tmp_port1++)
-                        BIT_SET (ports, tmp_port1);
-        }
+            gf_msg("glusterfs-socket", GF_LOG_WARNING, 0, LG_MSG_INVALID_PORT,
+                   "%s is not a valid port "
+                   "identifier",
+                   blocked_port);
+            result = _gf_true;
+            goto out;
+        }
+    } else {
+        range_port = strtok(blocked_port, "-");
+        if (!range_port) {
+            result = _gf_true;
+            goto out;
+        }
+        if (gf_string2int32(range_port, &tmp_port1) == 0) {
+            if (tmp_port1 > ceiling)
+                tmp_port1 = ceiling;
+            if (tmp_port1 < 0)
+                tmp_port1 = 0;
+        }
+        range_port = strtok(NULL, "-");
+        if (!range_port) {
+            result = _gf_true;
+            goto out;
+        }
+        /* get rid of the new line character*/
+        if (range_port[strlen(range_port) - 1] == '\n')
+            range_port[strlen(range_port) - 1] = '\0';
+        if (gf_string2int32(range_port, &tmp_port2) == 0) {
+            if (tmp_port2 > ceiling)
+                tmp_port2 = ceiling;
+            if (tmp_port2 < 0)
+                tmp_port2 = 0;
+        }
+        gf_msg_debug("glusterfs", 0, "lower: %d, higher: %d", tmp_port1,
+                     tmp_port2);
+        for (; tmp_port1 <= tmp_port2; tmp_port1++)
+            BIT_SET(ports, tmp_port1);
+    }
 
 out:
-        return result;
+    return result;
 }
 
 /* Takes in client ip{v4,v6} and returns associated hostname, if any
@@ -3341,331 +3339,326 @@ out:
  * Returns: 0 for success, -1 for failure
  */
 int
-gf_get_hostname_from_ip (char *client_ip, char **hostname)
-{
-        int                      ret                          = -1;
-        struct sockaddr         *client_sockaddr              = NULL;
-        struct sockaddr_in       client_sock_in               = {0};
-        struct sockaddr_in6      client_sock_in6              = {0};
-        char                     client_hostname[NI_MAXHOST]  = {0};
-        char                    *client_ip_copy               = NULL;
-        char                    *tmp                          = NULL;
-        char                    *ip                           = NULL;
-        size_t                   addr_sz                      = 0;
-
-        /* if ipv4, reverse lookup the hostname to
-         * allow FQDN based rpc authentication
-         */
-        if (!valid_ipv6_address (client_ip, strlen (client_ip), 0) &&
-            !valid_ipv4_address (client_ip, strlen (client_ip), 0)) {
-                /* most times, we get a.b.c.d:port form, so check that */
-                client_ip_copy = gf_strdup (client_ip);
-                if (!client_ip_copy)
-                        goto out;
-
-                ip = strtok_r (client_ip_copy, ":", &tmp);
-        } else {
-                ip = client_ip;
-        }
-
-        if (valid_ipv4_address (ip, strlen (ip), 0) == _gf_true) {
-                client_sockaddr = (struct sockaddr *)&client_sock_in;
-                addr_sz = sizeof (client_sock_in);
-                client_sock_in.sin_family = AF_INET;
-                ret = inet_pton (AF_INET, ip,
-                                 (void *)&client_sock_in.sin_addr.s_addr);
-
-        } else if (valid_ipv6_address (ip, strlen (ip), 0) == _gf_true) {
-                client_sockaddr = (struct sockaddr *) &client_sock_in6;
-                addr_sz = sizeof (client_sock_in6);
+gf_get_hostname_from_ip(char *client_ip, char **hostname)
+{
+    int ret = -1;
+    struct sockaddr *client_sockaddr = NULL;
+    struct sockaddr_in client_sock_in = {0};
+    struct sockaddr_in6 client_sock_in6 = {0};
+    char client_hostname[NI_MAXHOST] = {0};
+    char *client_ip_copy = NULL;
+    char *tmp = NULL;
+    char *ip = NULL;
+    size_t addr_sz = 0;
+
+    /* if ipv4, reverse lookup the hostname to
+     * allow FQDN based rpc authentication
+     */
+    if (!valid_ipv6_address(client_ip, strlen(client_ip), 0) &&
+        !valid_ipv4_address(client_ip, strlen(client_ip), 0)) {
+        /* most times, we get a.b.c.d:port form, so check that */
+        client_ip_copy = gf_strdup(client_ip);
+        if (!client_ip_copy)
+            goto out;
+
+        ip = strtok_r(client_ip_copy, ":", &tmp);
+    } else {
+        ip = client_ip;
+    }
+
+    if (valid_ipv4_address(ip, strlen(ip), 0) == _gf_true) {
+        client_sockaddr = (struct sockaddr *)&client_sock_in;
+        addr_sz = sizeof(client_sock_in);
+        client_sock_in.sin_family = AF_INET;
+        ret = inet_pton(AF_INET, ip, (void *)&client_sock_in.sin_addr.s_addr);
+
+    } else if (valid_ipv6_address(ip, strlen(ip), 0) == _gf_true) {
+        client_sockaddr = (struct sockaddr *)&client_sock_in6;
+        addr_sz = sizeof(client_sock_in6);
+
+        client_sock_in6.sin6_family = AF_INET6;
+        ret = inet_pton(AF_INET6, ip, (void *)&client_sock_in6.sin6_addr);
+    } else {
+        goto out;
+    }
+
+    if (ret != 1) {
+        ret = -1;
+        goto out;
+    }
+
+    /* You cannot just use sizeof (*client_sockaddr), as per the man page
+     * the (getnameinfo) size must be the size of the underlying sockaddr
+     * struct e.g. sockaddr_in6 or sockaddr_in.  Failure to do so will
+     * break IPv6 hostname resolution (IPv4 will work only because
+     * the sockaddr_in struct happens to be of the correct size).
+     */
+    ret = getnameinfo(client_sockaddr, addr_sz, client_hostname,
+                      sizeof(client_hostname), NULL, 0, 0);
+    if (ret) {
+        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+               "Could not lookup hostname "
+               "of %s : %s",
+               client_ip, gai_strerror(ret));
+        ret = -1;
+        goto out;
+    }
+
+    *hostname = gf_strdup((char *)client_hostname);
+out:
+    if (client_ip_copy)
+        GF_FREE(client_ip_copy);
 
-                client_sock_in6.sin6_family = AF_INET6;
-                ret = inet_pton (AF_INET6, ip,
-                                 (void *)&client_sock_in6.sin6_addr);
-        } else {
-                goto out;
-        }
+    return ret;
+}
 
-        if (ret != 1) {
-                ret = -1;
-                goto out;
-        }
+gf_boolean_t
+gf_interface_search(char *ip)
+{
+    int32_t ret = -1;
+    gf_boolean_t found = _gf_false;
+    struct ifaddrs *ifaddr, *ifa;
+    int family;
+    char host[NI_MAXHOST];
+    xlator_t *this = NULL;
+    char *pct = NULL;
 
-        /* You cannot just use sizeof (*client_sockaddr), as per the man page
-         * the (getnameinfo) size must be the size of the underlying sockaddr
-         * struct e.g. sockaddr_in6 or sockaddr_in.  Failure to do so will
-         * break IPv6 hostname resolution (IPv4 will work only because
-         * the sockaddr_in struct happens to be of the correct size).
-         */
-        ret = getnameinfo (client_sockaddr,
-                           addr_sz,
-                           client_hostname, sizeof (client_hostname),
-                           NULL, 0, 0);
-        if (ret) {
-                gf_msg ("common-utils", GF_LOG_ERROR, 0,
-                        LG_MSG_GETNAMEINFO_FAILED, "Could not lookup hostname "
-                        "of %s : %s", client_ip, gai_strerror (ret));
-                ret = -1;
-                goto out;
-        }
+    this = THIS;
 
-        *hostname = gf_strdup ((char *)client_hostname);
- out:
-        if (client_ip_copy)
-                GF_FREE (client_ip_copy);
+    ret = getifaddrs(&ifaddr);
 
-        return ret;
-}
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED,
+               "getifaddrs() failed: %s\n", gai_strerror(ret));
+        goto out;
+    }
 
-gf_boolean_t
-gf_interface_search (char *ip)
-{
-        int32_t         ret = -1;
-        gf_boolean_t    found = _gf_false;
-        struct          ifaddrs *ifaddr, *ifa;
-        int             family;
-        char            host[NI_MAXHOST];
-        xlator_t        *this = NULL;
-        char            *pct = NULL;
+    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+        if (!ifa->ifa_addr) {
+            /*
+             * This seemingly happens if an interface hasn't
+             * been bound to a particular protocol (seen with
+             * TUN devices).
+             */
+            continue;
+        }
+        family = ifa->ifa_addr->sa_family;
 
-        this = THIS;
+        if (family != AF_INET && family != AF_INET6)
+            continue;
 
-        ret = getifaddrs (&ifaddr);
+        ret = getnameinfo(ifa->ifa_addr,
+                          (family == AF_INET) ? sizeof(struct sockaddr_in)
+                                              : sizeof(struct sockaddr_in6),
+                          host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 
         if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED,
-                        "getifaddrs() failed: %s\n", gai_strerror(ret));
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                   "getnameinfo() "
+                   "failed: %s\n",
+                   gai_strerror(ret));
+            goto out;
+        }
+
+        /*
+         * Sometimes the address comes back as addr%eth0 or
+         * similar.  Since % is an invalid character, we can
+         * strip it out with confidence that doing so won't
+         * harm anything.
+         */
+        pct = index(host, '%');
+        if (pct) {
+            *pct = '\0';
         }
 
-        for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
-                if (!ifa->ifa_addr) {
-                        /*
-                         * This seemingly happens if an interface hasn't
-                         * been bound to a particular protocol (seen with
-                         * TUN devices).
-                         */
-                        continue;
-                }
-                family = ifa->ifa_addr->sa_family;
-
-                if (family != AF_INET && family != AF_INET6)
-                        continue;
-
-                ret = getnameinfo (ifa->ifa_addr,
-                        (family == AF_INET) ? sizeof(struct sockaddr_in) :
-                                              sizeof(struct sockaddr_in6),
-                        host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
-
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                LG_MSG_GETNAMEINFO_FAILED, "getnameinfo() "
-                                "failed: %s\n", gai_strerror(ret));
-                        goto out;
-                }
-
-                /*
-                 * Sometimes the address comes back as addr%eth0 or
-                 * similar.  Since % is an invalid character, we can
-                 * strip it out with confidence that doing so won't
-                 * harm anything.
-                 */
-                pct = index(host,'%');
-                if (pct) {
-                        *pct = '\0';
-                }
-
-                if (strncmp (ip, host, NI_MAXHOST) == 0) {
-                        gf_msg_debug (this->name, 0, "%s is local address at "
-                                      "interface %s", ip, ifa->ifa_name);
-                        found = _gf_true;
-                        goto out;
-                }
+        if (strncmp(ip, host, NI_MAXHOST) == 0) {
+            gf_msg_debug(this->name, 0,
+                         "%s is local address at "
+                         "interface %s",
+                         ip, ifa->ifa_name);
+            found = _gf_true;
+            goto out;
         }
+    }
 out:
-        if(ifaddr)
-                freeifaddrs (ifaddr);
-        return found;
+    if (ifaddr)
+        freeifaddrs(ifaddr);
+    return found;
 }
 
 char *
-get_ip_from_addrinfo (struct addrinfo *addr, char **ip)
+get_ip_from_addrinfo(struct addrinfo *addr, char **ip)
 {
-        char buf[64];
-        void *in_addr = NULL;
-        struct sockaddr_in *s4 = NULL;
-        struct sockaddr_in6 *s6 = NULL;
+    char buf[64];
+    void *in_addr = NULL;
+    struct sockaddr_in *s4 = NULL;
+    struct sockaddr_in6 *s6 = NULL;
 
-        switch (addr->ai_family)
-        {
-                case AF_INET:
-                        s4 = (struct sockaddr_in *)addr->ai_addr;
-                        in_addr = &s4->sin_addr;
-                        break;
-
-                case AF_INET6:
-                        s6 = (struct sockaddr_in6 *)addr->ai_addr;
-                        in_addr = &s6->sin6_addr;
-                        break;
-
-                default:
-                        gf_msg ("glusterd", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_FAMILY, "Invalid family");
-                        return NULL;
-        }
+    switch (addr->ai_family) {
+        case AF_INET:
+            s4 = (struct sockaddr_in *)addr->ai_addr;
+            in_addr = &s4->sin_addr;
+            break;
 
-        if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) {
-                gf_msg ("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED,
-                        "String conversion failed");
-                return NULL;
-        }
+        case AF_INET6:
+            s6 = (struct sockaddr_in6 *)addr->ai_addr;
+            in_addr = &s6->sin6_addr;
+            break;
+
+        default:
+            gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
+                   "Invalid family");
+            return NULL;
+    }
+
+    if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) {
+        gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED,
+               "String conversion failed");
+        return NULL;
+    }
 
-        *ip = gf_strdup (buf);
-        return *ip;
+    *ip = gf_strdup(buf);
+    return *ip;
 }
 
 gf_boolean_t
-gf_is_loopback_localhost (const struct sockaddr *sa, char *hostname)
-{
-        GF_ASSERT (sa);
-
-        gf_boolean_t is_local = _gf_false;
-        const struct in_addr *addr4 = NULL;
-        const struct in6_addr *addr6 = NULL;
-        uint8_t      *ap   = NULL;
-        struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT;
-
-        switch (sa->sa_family) {
-                case AF_INET:
-                        addr4 = &(((struct sockaddr_in *)sa)->sin_addr);
-                        ap = (uint8_t*)&addr4->s_addr;
-                        if (ap[0] == 127)
-                                is_local = _gf_true;
-                        break;
-
-                case AF_INET6:
-                        addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr);
-                        if (memcmp (addr6, &loopbackaddr6,
-                                    sizeof (loopbackaddr6)) == 0)
-                                is_local = _gf_true;
-                        break;
-
-                default:
-                        if (hostname)
-                                gf_msg ("glusterd", GF_LOG_ERROR, 0,
-                                        LG_MSG_INVALID_FAMILY, "unknown "
-                                        "address family %d for %s",
-                                        sa->sa_family, hostname);
-                        break;
-        }
+gf_is_loopback_localhost(const struct sockaddr *sa, char *hostname)
+{
+    GF_ASSERT(sa);
+
+    gf_boolean_t is_local = _gf_false;
+    const struct in_addr *addr4 = NULL;
+    const struct in6_addr *addr6 = NULL;
+    uint8_t *ap = NULL;
+    struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT;
+
+    switch (sa->sa_family) {
+        case AF_INET:
+            addr4 = &(((struct sockaddr_in *)sa)->sin_addr);
+            ap = (uint8_t *)&addr4->s_addr;
+            if (ap[0] == 127)
+                is_local = _gf_true;
+            break;
+
+        case AF_INET6:
+            addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr);
+            if (memcmp(addr6, &loopbackaddr6, sizeof(loopbackaddr6)) == 0)
+                is_local = _gf_true;
+            break;
+
+        default:
+            if (hostname)
+                gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
+                       "unknown "
+                       "address family %d for %s",
+                       sa->sa_family, hostname);
+            break;
+    }
 
-        return is_local;
+    return is_local;
 }
 
 gf_boolean_t
-gf_is_local_addr (char *hostname)
+gf_is_local_addr(char *hostname)
 {
-        int32_t         ret = -1;
-        struct          addrinfo *result = NULL;
-        struct          addrinfo *res = NULL;
-        gf_boolean_t    found = _gf_false;
-        char            *ip = NULL;
-        xlator_t        *this = NULL;
-        struct          addrinfo hints;
+    int32_t ret = -1;
+    struct addrinfo *result = NULL;
+    struct addrinfo *res = NULL;
+    gf_boolean_t found = _gf_false;
+    char *ip = NULL;
+    xlator_t *this = NULL;
+    struct addrinfo hints;
 
-        this = THIS;
+    this = THIS;
 
-        memset (&hints, 0, sizeof (hints));
-        /*
-         * Removing AI_ADDRCONFIG from default_hints
-         * for being able to use link local ipv6 addresses
-         */
-        hints.ai_family = AF_UNSPEC;
+    memset(&hints, 0, sizeof(hints));
+    /*
+     * Removing AI_ADDRCONFIG from default_hints
+     * for being able to use link local ipv6 addresses
+     */
+    hints.ai_family = AF_UNSPEC;
 
-        ret = getaddrinfo (hostname, NULL, &hints, &result);
+    ret = getaddrinfo(hostname, NULL, &hints, &result);
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(ret));
-                goto out;
-        }
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+               "error in getaddrinfo: %s\n", gai_strerror(ret));
+        goto out;
+    }
+
+    for (res = result; res != NULL; res = res->ai_next) {
+        gf_msg_debug(this->name, 0, "%s ", get_ip_from_addrinfo(res, &ip));
 
-        for (res = result; res != NULL; res = res->ai_next) {
-                gf_msg_debug (this->name, 0, "%s ",
-                              get_ip_from_addrinfo (res, &ip));
-
-                if (ip) {
-                        found = gf_is_loopback_localhost
-                                (res->ai_addr, hostname) ||
-                                gf_interface_search (ip);
-                }
-                if (found) {
-                        GF_FREE (ip);
-                        goto out;
-                }
-                GF_FREE (ip);
+        if (ip) {
+            found = gf_is_loopback_localhost(res->ai_addr, hostname) ||
+                    gf_interface_search(ip);
+        }
+        if (found) {
+            GF_FREE(ip);
+            goto out;
         }
+        GF_FREE(ip);
+    }
 
 out:
-        if (result)
-                freeaddrinfo (result);
+    if (result)
+        freeaddrinfo(result);
 
-        if (!found)
-                gf_msg_debug (this->name, 0, "%s is not local", hostname);
+    if (!found)
+        gf_msg_debug(this->name, 0, "%s is not local", hostname);
 
-        return found;
+    return found;
 }
 
 gf_boolean_t
-gf_is_same_address (char *name1, char *name2)
-{
-        struct addrinfo         *addr1 = NULL;
-        struct addrinfo         *addr2 = NULL;
-        struct addrinfo         *p = NULL;
-        struct addrinfo         *q = NULL;
-        gf_boolean_t            ret = _gf_false;
-        int                     gai_err = 0;
-        struct                  addrinfo hints;
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = AF_UNSPEC;
-
-        gai_err = getaddrinfo(name1, NULL, &hints, &addr1);
-        if (gai_err != 0) {
-                gf_msg (name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(gai_err));
-                goto out;
-        }
-
-        gai_err = getaddrinfo(name2, NULL, &hints, &addr2);
-        if (gai_err != 0) {
-                gf_msg (name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-                        "error in getaddrinfo: %s\n", gai_strerror(gai_err));
-                goto out;
-        }
-
-        for (p = addr1; p; p = p->ai_next) {
-                for (q = addr2; q; q = q->ai_next) {
-                        if (p->ai_addrlen != q->ai_addrlen) {
-                                continue;
-                        }
-                        if (memcmp(p->ai_addr,q->ai_addr,p->ai_addrlen)) {
-                                continue;
-                        }
-                        ret = _gf_true;
-                        goto out;
-                }
-        }
+gf_is_same_address(char *name1, char *name2)
+{
+    struct addrinfo *addr1 = NULL;
+    struct addrinfo *addr2 = NULL;
+    struct addrinfo *p = NULL;
+    struct addrinfo *q = NULL;
+    gf_boolean_t ret = _gf_false;
+    int gai_err = 0;
+    struct addrinfo hints;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+
+    gai_err = getaddrinfo(name1, NULL, &hints, &addr1);
+    if (gai_err != 0) {
+        gf_msg(name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
+               "error in getaddrinfo: %s\n", gai_strerror(gai_err));
+        goto out;
+    }
+
+    gai_err = getaddrinfo(name2, NULL, &hints, &addr2);
+    if (gai_err != 0) {
+        gf_msg(name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
+               "error in getaddrinfo: %s\n", gai_strerror(gai_err));
+        goto out;
+    }
+
+    for (p = addr1; p; p = p->ai_next) {
+        for (q = addr2; q; q = q->ai_next) {
+            if (p->ai_addrlen != q->ai_addrlen) {
+                continue;
+            }
+            if (memcmp(p->ai_addr, q->ai_addr, p->ai_addrlen)) {
+                continue;
+            }
+            ret = _gf_true;
+            goto out;
+        }
+    }
 
 out:
-        if (addr1) {
-                freeaddrinfo(addr1);
-        }
-        if (addr2) {
-                freeaddrinfo(addr2);
-        }
-        return ret;
-
+    if (addr1) {
+        freeaddrinfo(addr1);
+    }
+    if (addr2) {
+        freeaddrinfo(addr2);
+    }
+    return ret;
 }
 
 /*
@@ -3673,511 +3666,503 @@ out:
  * Format: <host1>:<port1> <host2>:<port2>...
  */
 int
-gf_process_getspec_servers_list(cmd_args_t *cmd_args,
-                                const char *servers_list) {
-        char        *tmp = NULL;
-        char        *address = NULL;
-        char        *host = NULL;
-        char        *last_colon = NULL;
-        char        *save_ptr = NULL;
-        int          port = 0;
-        int          ret = -1;
-
-        tmp = gf_strdup (servers_list);
-        if (!tmp) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        address = strtok_r (tmp, " ", &save_ptr);
+gf_process_getspec_servers_list(cmd_args_t *cmd_args, const char *servers_list)
+{
+    char *tmp = NULL;
+    char *address = NULL;
+    char *host = NULL;
+    char *last_colon = NULL;
+    char *save_ptr = NULL;
+    int port = 0;
+    int ret = -1;
+
+    tmp = gf_strdup(servers_list);
+    if (!tmp) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    address = strtok_r(tmp, " ", &save_ptr);
+    if (!address) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    while (1) {
+        last_colon = strrchr(address, ':');
+        if (!last_colon) {
+            errno = EINVAL;
+            ret = -1;
+            break;
+        }
+        *last_colon = '\0';
+        host = address;
+        port = atoi(last_colon + 1);
+        if (port <= 0) {
+            errno = EINVAL;
+            ret = -1;
+            break;
+        }
+        ret = gf_set_volfile_server_common(cmd_args, host,
+                                           GF_DEFAULT_VOLFILE_TRANSPORT, port);
+        if (ret && errno != EEXIST) {
+            break;
+        }
+        address = strtok_r(NULL, " ", &save_ptr);
         if (!address) {
-                errno = EINVAL;
-                goto out;
-        }
-
-        while (1) {
-                last_colon = strrchr (address, ':');
-                if (!last_colon) {
-                        errno = EINVAL;
-                        ret = -1;
-                        break;
-                }
-                *last_colon = '\0';
-                host = address;
-                port = atoi (last_colon + 1);
-                if (port <= 0) {
-                        errno = EINVAL;
-                        ret = -1;
-                        break;
-                }
-                ret = gf_set_volfile_server_common (
-                        cmd_args, host, GF_DEFAULT_VOLFILE_TRANSPORT, port);
-                if (ret && errno != EEXIST) {
-                        break;
-                }
-                address = strtok_r (NULL, " ", &save_ptr);
-                if (!address) {
-                        errno = 0;
-                        ret = 0;
-                        break;
-                }
+            errno = 0;
+            ret = 0;
+            break;
         }
+    }
 
 out:
-        if (tmp) {
-                GF_FREE (tmp);
-        }
+    if (tmp) {
+        GF_FREE(tmp);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_set_volfile_server_common (cmd_args_t *cmd_args, const char *host,
-                              const char *transport, int port)
-{
-        server_cmdline_t      *server = NULL;
-        server_cmdline_t      *tmp = NULL;
-        int                    ret = -1;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, cmd_args, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, host, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, transport, out);
-
-        server = GF_CALLOC (1, sizeof (server_cmdline_t),
-                            gf_common_mt_server_cmdline_t);
-        if (!server) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&server->list);
-
-        server->volfile_server = gf_strdup (host);
-        if (!server->volfile_server) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        server->transport = gf_strdup (transport);
-        if (!server->transport) {
-                errno = ENOMEM;
-                goto out;
-        }
-
-        server->port = port;
-
-        if (!cmd_args->volfile_server) {
-                cmd_args->volfile_server = server->volfile_server;
-                cmd_args->volfile_server_transport = server->transport;
-                cmd_args->volfile_server_port = server->port;
-                cmd_args->curr_server = server;
-        }
-
-        list_for_each_entry(tmp, &cmd_args->volfile_servers, list) {
-                if ((!strcmp(tmp->volfile_server, server->volfile_server) &&
-                     !strcmp(tmp->transport, server->transport) &&
-                     (tmp->port == server->port))) {
-                        errno = EEXIST;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        list_add_tail (&server->list, &cmd_args->volfile_servers);
-
-        ret = 0;
+gf_set_volfile_server_common(cmd_args_t *cmd_args, const char *host,
+                             const char *transport, int port)
+{
+    server_cmdline_t *server = NULL;
+    server_cmdline_t *tmp = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, host, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, transport, out);
+
+    server = GF_CALLOC(1, sizeof(server_cmdline_t),
+                       gf_common_mt_server_cmdline_t);
+    if (!server) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    INIT_LIST_HEAD(&server->list);
+
+    server->volfile_server = gf_strdup(host);
+    if (!server->volfile_server) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    server->transport = gf_strdup(transport);
+    if (!server->transport) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    server->port = port;
+
+    if (!cmd_args->volfile_server) {
+        cmd_args->volfile_server = server->volfile_server;
+        cmd_args->volfile_server_transport = server->transport;
+        cmd_args->volfile_server_port = server->port;
+        cmd_args->curr_server = server;
+    }
+
+    list_for_each_entry(tmp, &cmd_args->volfile_servers, list)
+    {
+        if ((!strcmp(tmp->volfile_server, server->volfile_server) &&
+             !strcmp(tmp->transport, server->transport) &&
+             (tmp->port == server->port))) {
+            errno = EEXIST;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    list_add_tail(&server->list, &cmd_args->volfile_servers);
+
+    ret = 0;
 out:
-        if (-1 == ret) {
-                if (server) {
-                        GF_FREE (server->volfile_server);
-                        GF_FREE (server->transport);
-                        GF_FREE (server);
-                }
+    if (-1 == ret) {
+        if (server) {
+            GF_FREE(server->volfile_server);
+            GF_FREE(server->transport);
+            GF_FREE(server);
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 /* Sets log file path from user provided arguments */
 int
-gf_set_log_file_path (cmd_args_t *cmd_args, glusterfs_ctx_t *ctx)
-{
-        int   i = 0;
-        int   j = 0;
-        int   ret = 0;
-        int   tmp_len = 0;
-        char  tmp_str[1024] = {0,};
-
-        if (!cmd_args)
-                goto done;
-
-        if (cmd_args->mount_point) {
-                j = 0;
-                i = 0;
-                if (cmd_args->mount_point[0] == '/')
-                        i = 1;
-                for (; i < strlen (cmd_args->mount_point); i++,j++) {
-                        tmp_str[j] = cmd_args->mount_point[i];
-                        if (cmd_args->mount_point[i] == '/')
-                                tmp_str[j] = '-';
-                }
-
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   tmp_str);
-                if (ret > 0)
-                        ret = 0;
-                goto done;
-        }
+gf_set_log_file_path(cmd_args_t *cmd_args, glusterfs_ctx_t *ctx)
+{
+    int i = 0;
+    int j = 0;
+    int ret = 0;
+    int tmp_len = 0;
+    char tmp_str[1024] = {
+        0,
+    };
 
-        if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) {
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   GLUSTERD_NAME);
-                if (ret > 0)
-                        ret = 0;
+    if (!cmd_args)
+        goto done;
 
-                goto done;
+    if (cmd_args->mount_point) {
+        j = 0;
+        i = 0;
+        if (cmd_args->mount_point[0] == '/')
+            i = 1;
+        for (; i < strlen(cmd_args->mount_point); i++, j++) {
+            tmp_str[j] = cmd_args->mount_point[i];
+            if (cmd_args->mount_point[i] == '/')
+                tmp_str[j] = '-';
         }
 
-        if (cmd_args->volfile) {
-                j = 0;
-                i = 0;
-                if (cmd_args->volfile[0] == '/')
-                        i = 1;
-                for (; i < strlen (cmd_args->volfile); i++,j++) {
-                        tmp_str[j] = cmd_args->volfile[i];
-                        if (cmd_args->volfile[i] == '/')
-                                tmp_str[j] = '-';
-                }
-                ret = gf_asprintf (&cmd_args->log_file,
-                                   DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
-                                   tmp_str);
-                if (ret > 0)
-                        ret = 0;
-                goto done;
-        }
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str);
+        if (ret > 0)
+            ret = 0;
+        goto done;
+    }
+
+    if (ctx && GF_GLUSTERD_PROCESS == ctx->process_mode) {
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", GLUSTERD_NAME);
+        if (ret > 0)
+            ret = 0;
+
+        goto done;
+    }
 
-        if (cmd_args->volfile_server) {
-                if (strncmp (cmd_args->volfile_server_transport,
-                             "unix", 4) == 0) {
-                        if (cmd_args->volfile_server[0] == '/')
-                                i = 1;
-                        tmp_len = strlen (cmd_args->volfile_server);
-                        for (j = 0; i < tmp_len; i++, j++) {
-                                tmp_str[j] = cmd_args->volfile_server[i];
-                                if (cmd_args->volfile_server[i] == '/')
-                                        tmp_str[j] = '-';
-                        }
-                        ret = gf_asprintf (&cmd_args->log_file,
-                                           "%s/%s-%s-%d.log",
-                                           DEFAULT_LOG_FILE_DIRECTORY,
-                                           tmp_str,
-                                           cmd_args->volfile_id, getpid());
-                } else {
-                        ret = gf_asprintf (&cmd_args->log_file,
-                                           "%s/%s-%s-%d.log",
-                                           DEFAULT_LOG_FILE_DIRECTORY,
-                                           cmd_args->volfile_server,
-                                           cmd_args->volfile_id, getpid());
-                }
-                if (ret > 0)
-                        ret = 0;
+    if (cmd_args->volfile) {
+        j = 0;
+        i = 0;
+        if (cmd_args->volfile[0] == '/')
+            i = 1;
+        for (; i < strlen(cmd_args->volfile); i++, j++) {
+            tmp_str[j] = cmd_args->volfile[i];
+            if (cmd_args->volfile[i] == '/')
+                tmp_str[j] = '-';
+        }
+        ret = gf_asprintf(&cmd_args->log_file,
+                          DEFAULT_LOG_FILE_DIRECTORY "/%s.log", tmp_str);
+        if (ret > 0)
+            ret = 0;
+        goto done;
+    }
+
+    if (cmd_args->volfile_server) {
+        if (strncmp(cmd_args->volfile_server_transport, "unix", 4) == 0) {
+            if (cmd_args->volfile_server[0] == '/')
+                i = 1;
+            tmp_len = strlen(cmd_args->volfile_server);
+            for (j = 0; i < tmp_len; i++, j++) {
+                tmp_str[j] = cmd_args->volfile_server[i];
+                if (cmd_args->volfile_server[i] == '/')
+                    tmp_str[j] = '-';
+            }
+            ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log",
+                              DEFAULT_LOG_FILE_DIRECTORY, tmp_str,
+                              cmd_args->volfile_id, getpid());
+        } else {
+            ret = gf_asprintf(&cmd_args->log_file, "%s/%s-%s-%d.log",
+                              DEFAULT_LOG_FILE_DIRECTORY,
+                              cmd_args->volfile_server, cmd_args->volfile_id,
+                              getpid());
         }
+        if (ret > 0)
+            ret = 0;
+    }
 done:
-        return ret;
+    return ret;
 }
 
 int
-gf_set_log_ident (cmd_args_t *cmd_args)
+gf_set_log_ident(cmd_args_t *cmd_args)
 {
-        int              ret = 0;
-        char            *ptr = NULL;
-
-        if (cmd_args->log_file == NULL) {
-                /* no ident source */
-                return 0;
-        }
+    int ret = 0;
+    char *ptr = NULL;
 
-        /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which
-         * seems ugly and can be bettered? */
-        /* just get the filename as the ident */
-        if (NULL != (ptr = strrchr (cmd_args->log_file, '/'))) {
-                ret = gf_asprintf (&cmd_args->log_ident, "%s", ptr + 1);
-        } else {
-                ret = gf_asprintf (&cmd_args->log_ident, "%s",
-                                   cmd_args->log_file);
-        }
-
-        if (ret > 0)
-                ret = 0;
-        else
-                return ret;
+    if (cmd_args->log_file == NULL) {
+        /* no ident source */
+        return 0;
+    }
+
+    /* TODO: Some idents would look like, etc-glusterfs-glusterd.vol, which
+     * seems ugly and can be bettered? */
+    /* just get the filename as the ident */
+    if (NULL != (ptr = strrchr(cmd_args->log_file, '/'))) {
+        ret = gf_asprintf(&cmd_args->log_ident, "%s", ptr + 1);
+    } else {
+        ret = gf_asprintf(&cmd_args->log_ident, "%s", cmd_args->log_file);
+    }
+
+    if (ret > 0)
+        ret = 0;
+    else
+        return ret;
 
-        /* remove .log suffix */
-        if (NULL != (ptr = strrchr (cmd_args->log_ident, '.'))) {
-                if (strcmp (ptr, ".log") == 0) {
-                        ptr[0] = '\0';
-                }
+    /* remove .log suffix */
+    if (NULL != (ptr = strrchr(cmd_args->log_ident, '.'))) {
+        if (strcmp(ptr, ".log") == 0) {
+            ptr[0] = '\0';
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_thread_cleanup_xint (pthread_t thread)
+gf_thread_cleanup_xint(pthread_t thread)
 {
-        int ret = 0;
-        void *res = NULL;
+    int ret = 0;
+    void *res = NULL;
 
-        ret = pthread_cancel (thread);
-        if (ret != 0)
-                goto error_return;
+    ret = pthread_cancel(thread);
+    if (ret != 0)
+        goto error_return;
 
-        ret = pthread_join (thread, &res);
-        if (ret != 0)
-                goto error_return;
+    ret = pthread_join(thread, &res);
+    if (ret != 0)
+        goto error_return;
 
-        if (res != PTHREAD_CANCELED)
-                goto error_return;
+    if (res != PTHREAD_CANCELED)
+        goto error_return;
 
-        ret = 0;
+    ret = 0;
 
- error_return:
-        return ret;
+error_return:
+    return ret;
 }
 
 int
-gf_thread_create (pthread_t *thread, const pthread_attr_t *attr,
-                  void *(*start_routine)(void *), void *arg, const char *name)
-{
-        sigset_t set, old;
-        int ret;
-        char thread_name[GF_THREAD_NAMEMAX+GF_THREAD_NAME_PREFIX_LEN] = {0,};
-        /* Max name on Linux is 16 and on NetBSD is 32
-         * All Gluster threads have a set prefix of gluster and hence the limit
-         * of 9 on GF_THREAD_NAMEMAX including the null character.
-         */
-
-        sigemptyset (&old);
-        sigfillset (&set);
-        sigdelset (&set, SIGSEGV);
-        sigdelset (&set, SIGBUS);
-        sigdelset (&set, SIGILL);
-        sigdelset (&set, SIGSYS);
-        sigdelset (&set, SIGFPE);
-        sigdelset (&set, SIGABRT);
-
-        pthread_sigmask (SIG_BLOCK, &set, &old);
-
-        ret = pthread_create (thread, attr, start_routine, arg);
-        snprintf (thread_name, sizeof(thread_name), "%s%s",
-                  GF_THREAD_NAME_PREFIX, name);
-
-        if (0 == ret && name) {
-                #ifdef GF_LINUX_HOST_OS
-                        pthread_setname_np(*thread, thread_name);
-                #elif defined(__NetBSD__)
-                        pthread_setname_np(*thread, thread_name, NULL);
-                #elif defined(__FreeBSD__)
-                        pthread_set_name_np(*thread, thread_name);
-                #else
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_PTHREAD_NAMING_FAILED,
-                                "Could not set thread name: %s",
-                                thread_name);
-                #endif
-        }
+gf_thread_create(pthread_t *thread, const pthread_attr_t *attr,
+                 void *(*start_routine)(void *), void *arg, const char *name)
+{
+    sigset_t set, old;
+    int ret;
+    char thread_name[GF_THREAD_NAMEMAX + GF_THREAD_NAME_PREFIX_LEN] = {
+        0,
+    };
+    /* Max name on Linux is 16 and on NetBSD is 32
+     * All Gluster threads have a set prefix of gluster and hence the limit
+     * of 9 on GF_THREAD_NAMEMAX including the null character.
+     */
+
+    sigemptyset(&old);
+    sigfillset(&set);
+    sigdelset(&set, SIGSEGV);
+    sigdelset(&set, SIGBUS);
+    sigdelset(&set, SIGILL);
+    sigdelset(&set, SIGSYS);
+    sigdelset(&set, SIGFPE);
+    sigdelset(&set, SIGABRT);
+
+    pthread_sigmask(SIG_BLOCK, &set, &old);
+
+    ret = pthread_create(thread, attr, start_routine, arg);
+    snprintf(thread_name, sizeof(thread_name), "%s%s", GF_THREAD_NAME_PREFIX,
+             name);
+
+    if (0 == ret && name) {
+#ifdef GF_LINUX_HOST_OS
+        pthread_setname_np(*thread, thread_name);
+#elif defined(__NetBSD__)
+        pthread_setname_np(*thread, thread_name, NULL);
+#elif defined(__FreeBSD__)
+        pthread_set_name_np(*thread, thread_name);
+#else
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED,
+               "Could not set thread name: %s", thread_name);
+#endif
+    }
 
-        pthread_sigmask (SIG_SETMASK, &old, NULL);
+    pthread_sigmask(SIG_SETMASK, &old, NULL);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_thread_create_detached (pthread_t *thread,
-                         void *(*start_routine)(void *), void *arg,
-                         const char *name)
+gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *),
+                          void *arg, const char *name)
 {
-        pthread_attr_t attr;
-        int ret = -1;
+    pthread_attr_t attr;
+    int ret = -1;
 
-        ret = pthread_attr_init (&attr);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ret,
-                        LG_MSG_PTHREAD_ATTR_INIT_FAILED,
-                        "Thread attribute initialization failed");
-                return -1;
-        }
+    ret = pthread_attr_init(&attr);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED,
+               "Thread attribute initialization failed");
+        return -1;
+    }
 
-        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
-        ret = gf_thread_create (thread, &attr, start_routine, arg, name);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ret,
-                        LG_MSG_PTHREAD_FAILED,
-                        "Thread creation failed");
-                ret = -1;
-        }
+    ret = gf_thread_create(thread, &attr, start_routine, arg, name);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_FAILED,
+               "Thread creation failed");
+        ret = -1;
+    }
 
-        pthread_attr_destroy (&attr);
+    pthread_attr_destroy(&attr);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_skip_header_section (int fd, int header_len)
+gf_skip_header_section(int fd, int header_len)
 {
-        int  ret           = -1;
+    int ret = -1;
 
-        ret = sys_lseek (fd, header_len, SEEK_SET);
-        if (ret == (off_t) -1) {
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED,
-                        "Failed to skip header section");
-        } else {
-                ret = 0;
-        }
+    ret = sys_lseek(fd, header_len, SEEK_SET);
+    if (ret == (off_t)-1) {
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED,
+               "Failed to skip header section");
+    } else {
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
 /* Below function is use to check at runtime if pid is running */
 
 gf_boolean_t
-gf_is_pid_running (int pid)
+gf_is_pid_running(int pid)
 {
-        char fname[32] = {0,};
+    char fname[32] = {
+        0,
+    };
 
-        snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
-
-        if (sys_access (fname , R_OK) != 0) {
-                return _gf_false;
-        }
+    snprintf(fname, sizeof(fname), "/proc/%d/cmdline", pid);
 
-        return _gf_true;
+    if (sys_access(fname, R_OK) != 0) {
+        return _gf_false;
+    }
 
+    return _gf_true;
 }
 
-
 gf_boolean_t
-gf_is_service_running (char *pidfile, int *pid)
-{
-        FILE            *file = NULL;
-        gf_boolean_t    running = _gf_false;
-        int             ret = 0;
-        int             fno = 0;
-
-        file = fopen (pidfile, "r+");
-        if (!file) {
-                goto out;
-        }
-
-        fno = fileno (file);
-        ret = lockf (fno, F_TEST, 0);
-        if (ret == -1) {
-                running = _gf_true;
-                goto out;
-        }
-
-        ret = fscanf (file, "%d", pid);
-        if (ret <= 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to read pidfile: %s", pidfile);
-                *pid = -1;
-        }
-
-        running = gf_is_pid_running (*pid);
+gf_is_service_running(char *pidfile, int *pid)
+{
+    FILE *file = NULL;
+    gf_boolean_t running = _gf_false;
+    int ret = 0;
+    int fno = 0;
+
+    file = fopen(pidfile, "r+");
+    if (!file) {
+        goto out;
+    }
+
+    fno = fileno(file);
+    ret = lockf(fno, F_TEST, 0);
+    if (ret == -1) {
+        running = _gf_true;
+        goto out;
+    }
+
+    ret = fscanf(file, "%d", pid);
+    if (ret <= 0) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to read pidfile: %s", pidfile);
+        *pid = -1;
+    }
+
+    running = gf_is_pid_running(*pid);
 out:
-        if (file)
-                fclose (file);
-        return running;
+    if (file)
+        fclose(file);
+    return running;
 }
 
 /* Check if the pid is > 0 */
 gf_boolean_t
-gf_valid_pid (const char *pid, int length)
+gf_valid_pid(const char *pid, int length)
 {
-        gf_boolean_t    ret = _gf_true;
-        pid_t           value = 0;
-        char           *end_ptr = NULL;
+    gf_boolean_t ret = _gf_true;
+    pid_t value = 0;
+    char *end_ptr = NULL;
 
-        if (length <= 0) {
-                ret = _gf_false;
-                goto out;
-        }
+    if (length <= 0) {
+        ret = _gf_false;
+        goto out;
+    }
 
-        value = strtol (pid, &end_ptr, 10);
-        if (value <= 0) {
-                ret = _gf_false;
-        }
+    value = strtol(pid, &end_ptr, 10);
+    if (value <= 0) {
+        ret = _gf_false;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-dht_is_linkfile_key (dict_t *this, char *key, data_t *value, void *data)
+dht_is_linkfile_key(dict_t *this, char *key, data_t *value, void *data)
 {
-        gf_boolean_t *linkfile_key_found = NULL;
+    gf_boolean_t *linkfile_key_found = NULL;
 
-        if (!data)
-                goto out;
+    if (!data)
+        goto out;
 
-        linkfile_key_found = data;
+    linkfile_key_found = data;
 
-        *linkfile_key_found = _gf_true;
+    *linkfile_key_found = _gf_true;
 out:
-        return 0;
+    return 0;
 }
 
-
 gf_boolean_t
-dht_is_linkfile (struct iatt *buf, dict_t *dict)
+dht_is_linkfile(struct iatt *buf, dict_t *dict)
 {
-        gf_boolean_t linkfile_key_found = _gf_false;
+    gf_boolean_t linkfile_key_found = _gf_false;
 
-        if (!IS_DHT_LINKFILE_MODE (buf))
-                return _gf_false;
+    if (!IS_DHT_LINKFILE_MODE(buf))
+        return _gf_false;
 
-        dict_foreach_fnmatch (dict, "*."DHT_LINKFILE_STR, dht_is_linkfile_key,
-                              &linkfile_key_found);
+    dict_foreach_fnmatch(dict, "*." DHT_LINKFILE_STR, dht_is_linkfile_key,
+                         &linkfile_key_found);
 
-        return linkfile_key_found;
+    return linkfile_key_found;
 }
 
 int
-gf_check_log_format (const char *value)
+gf_check_log_format(const char *value)
 {
-        int log_format = -1;
+    int log_format = -1;
 
-        if (!strcasecmp (value, GF_LOG_FORMAT_NO_MSG_ID))
-                log_format = gf_logformat_traditional;
-        else if (!strcasecmp (value, GF_LOG_FORMAT_WITH_MSG_ID))
-                log_format = gf_logformat_withmsgid;
+    if (!strcasecmp(value, GF_LOG_FORMAT_NO_MSG_ID))
+        log_format = gf_logformat_traditional;
+    else if (!strcasecmp(value, GF_LOG_FORMAT_WITH_MSG_ID))
+        log_format = gf_logformat_withmsgid;
 
-        if (log_format == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-                        "Invalid log-format. possible values are "
-                        GF_LOG_FORMAT_NO_MSG_ID "|" GF_LOG_FORMAT_WITH_MSG_ID);
+    if (log_format == -1)
+        gf_msg(
+            THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+            "Invalid log-format. possible values are " GF_LOG_FORMAT_NO_MSG_ID
+            "|" GF_LOG_FORMAT_WITH_MSG_ID);
 
-        return log_format;
+    return log_format;
 }
 
 int
-gf_check_logger (const char *value)
+gf_check_logger(const char *value)
 {
-        int logger = -1;
+    int logger = -1;
 
-        if (!strcasecmp (value, GF_LOGGER_GLUSTER_LOG))
-                logger = gf_logger_glusterlog;
-        else if (!strcasecmp (value, GF_LOGGER_SYSLOG))
-                logger = gf_logger_syslog;
+    if (!strcasecmp(value, GF_LOGGER_GLUSTER_LOG))
+        logger = gf_logger_glusterlog;
+    else if (!strcasecmp(value, GF_LOGGER_SYSLOG))
+        logger = gf_logger_syslog;
 
-        if (logger == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-                        "Invalid logger. possible values are "
-                        GF_LOGGER_GLUSTER_LOG "|" GF_LOGGER_SYSLOG);
+    if (logger == -1)
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+               "Invalid logger. possible values are " GF_LOGGER_GLUSTER_LOG
+               "|" GF_LOGGER_SYSLOG);
 
-        return logger;
+    return logger;
 }
 
 /* gf_compare_sockaddr compares the given addresses @addr1 and @addr2 for
@@ -4187,30 +4172,28 @@ gf_check_logger (const char *value)
  * https://www.opensource.apple.com/source/postfix/postfix-197/postfix/src/util/sock_addr.c
  */
 gf_boolean_t
-gf_compare_sockaddr (const struct sockaddr *addr1,
-                     const struct sockaddr *addr2)
+gf_compare_sockaddr(const struct sockaddr *addr1, const struct sockaddr *addr2)
 {
-        GF_ASSERT (addr1 != NULL);
-        GF_ASSERT (addr2 != NULL);
-
-        /* Obviously, the addresses don't match if their families are different
-         */
-        if (addr1->sa_family != addr2->sa_family)
-                return _gf_false;
+    GF_ASSERT(addr1 != NULL);
+    GF_ASSERT(addr2 != NULL);
 
+    /* Obviously, the addresses don't match if their families are different
+     */
+    if (addr1->sa_family != addr2->sa_family)
+        return _gf_false;
 
-        if (AF_INET == addr1->sa_family) {
-                if (((struct sockaddr_in *)addr1)->sin_addr.s_addr ==
-                       ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
-                        return _gf_true;
+    if (AF_INET == addr1->sa_family) {
+        if (((struct sockaddr_in *)addr1)->sin_addr.s_addr ==
+            ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
+            return _gf_true;
 
-        } else if (AF_INET6 == addr1->sa_family) {
-                if (memcmp ((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr,
-                            (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr,
-                            sizeof (struct in6_addr)) == 0)
-                        return _gf_true;
-        }
-        return _gf_false;
+    } else if (AF_INET6 == addr1->sa_family) {
+        if (memcmp((char *)&((struct sockaddr_in6 *)addr1)->sin6_addr,
+                   (char *)&((struct sockaddr_in6 *)addr2)->sin6_addr,
+                   sizeof(struct in6_addr)) == 0)
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 /*
@@ -4219,155 +4202,168 @@ gf_compare_sockaddr (const struct sockaddr *addr1,
  */
 
 int
-gf_set_timestamp  (const char *src, const char* dest)
+gf_set_timestamp(const char *src, const char *dest)
 {
-        struct stat    sb             = {0, };
+    struct stat sb = {
+        0,
+    };
 #if defined(HAVE_UTIMENSAT)
-        struct timespec new_time[2]   = { {0, }, {0, } };
+    struct timespec new_time[2] = {{
+                                       0,
+                                   },
+                                   {
+                                       0,
+                                   }};
 #else
-        struct timeval new_time[2]    = { {0, }, {0, } };
+    struct timeval new_time[2] = {{
+                                      0,
+                                  },
+                                  {
+                                      0,
+                                  }};
 #endif
-        int            ret            = 0;
-        xlator_t       *this          = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-        GF_ASSERT (src);
-        GF_ASSERT (dest);
-
-        ret = sys_stat (src, &sb);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FILE_STAT_FAILED, "stat on %s", src);
-                goto out;
-        }
-        /* The granularity is nano seconds if `utimensat()` is available,
-         * and micro seconds otherwise.
-         */
+    int ret = 0;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(src);
+    GF_ASSERT(dest);
+
+    ret = sys_stat(src, &sb);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+               "stat on %s", src);
+        goto out;
+    }
+    /* The granularity is nano seconds if `utimensat()` is available,
+     * and micro seconds otherwise.
+     */
 #if defined(HAVE_UTIMENSAT)
-        new_time[0].tv_sec = sb.st_atime;
-        new_time[0].tv_nsec = ST_ATIM_NSEC (&sb);
-
-        new_time[1].tv_sec = sb.st_mtime;
-        new_time[1].tv_nsec = ST_MTIM_NSEC (&sb);
-
-        /* dirfd = 0 is ignored because `dest` is an absolute path. */
-        ret = sys_utimensat (AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_UTIMENSAT_FAILED, "utimensat on %s", dest);
-        }
+    new_time[0].tv_sec = sb.st_atime;
+    new_time[0].tv_nsec = ST_ATIM_NSEC(&sb);
+
+    new_time[1].tv_sec = sb.st_mtime;
+    new_time[1].tv_nsec = ST_MTIM_NSEC(&sb);
+
+    /* dirfd = 0 is ignored because `dest` is an absolute path. */
+    ret = sys_utimensat(AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMENSAT_FAILED,
+               "utimensat on %s", dest);
+    }
 #else
-        new_time[0].tv_sec = sb.st_atime;
-        new_time[0].tv_usec = ST_ATIM_NSEC (&sb)/1000;
+    new_time[0].tv_sec = sb.st_atime;
+    new_time[0].tv_usec = ST_ATIM_NSEC(&sb) / 1000;
 
-        new_time[1].tv_sec = sb.st_mtime;
-        new_time[1].tv_usec = ST_MTIM_NSEC (&sb)/1000;
+    new_time[1].tv_sec = sb.st_mtime;
+    new_time[1].tv_usec = ST_MTIM_NSEC(&sb) / 1000;
 
-        ret = sys_utimes (dest, new_time);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
-                        "utimes on %s", dest);
-        }
+    ret = sys_utimes(dest, new_time);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
+               "utimes on %s", dest);
+    }
 #endif
 out:
-        return ret;
+    return ret;
 }
 
 static void
-gf_backtrace_end (char *buf, size_t frames)
+gf_backtrace_end(char *buf, size_t frames)
 {
-        size_t pos = 0;
+    size_t pos = 0;
 
-        if (!buf)
-                return;
+    if (!buf)
+        return;
 
-        pos = strlen (buf);
+    pos = strlen(buf);
 
-        frames = min(frames, GF_BACKTRACE_LEN - pos -1);
+    frames = min(frames, GF_BACKTRACE_LEN - pos - 1);
 
-        if (frames <= 0)
-                return;
+    if (frames <= 0)
+        return;
 
-        memset (buf+pos, ')', frames);
-        buf[pos+frames] = '\0';
+    memset(buf + pos, ')', frames);
+    buf[pos + frames] = '\0';
 }
 
 /*Returns bytes written*/
 static int
-gf_backtrace_append (char *buf, size_t pos, char *framestr)
+gf_backtrace_append(char *buf, size_t pos, char *framestr)
 {
-        if (pos >= GF_BACKTRACE_LEN)
-                return -1;
-        return snprintf (buf+pos, GF_BACKTRACE_LEN-pos, "(--> %s ", framestr);
+    if (pos >= GF_BACKTRACE_LEN)
+        return -1;
+    return snprintf(buf + pos, GF_BACKTRACE_LEN - pos, "(--> %s ", framestr);
 }
 
 static int
-gf_backtrace_fillframes (char *buf)
-{
-        void    *array[GF_BACKTRACE_FRAME_COUNT];
-        size_t  frames                  = 0;
-        FILE    *fp                     = NULL;
-        char    callingfn[GF_BACKTRACE_FRAME_COUNT-2][1024] = {{0},};
-        int     ret                     = -1;
-        int     fd                      = -1;
-        size_t  idx                     = 0;
-        size_t  pos                     = 0;
-        size_t  inc                     = 0;
-        char    tmpl[]                  = "/tmp/glfs-bt-XXXXXX";
-
-        frames = backtrace (array, GF_BACKTRACE_FRAME_COUNT);
-        if (!frames)
-                return -1;
-
-        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-        fd = mkstemp (tmpl);
-        if (fd == -1)
-                return -1;
-
-        /* Calling unlink so that when the file is closed or program
-         * terminates the temporary file is deleted.
-         */
-        ret = sys_unlink (tmpl);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED,
-                        "Unable to delete temporary file: %s", tmpl);
-        }
-
-        /*The most recent two frames are the calling function and
-         * gf_backtrace_save, which we can infer.*/
-
-        backtrace_symbols_fd (&array[2], frames-2, fd);
-
-        fp = fdopen (fd, "r");
-        if (!fp) {
-                sys_close (fd);
-                ret = -1;
-                goto out;
-        }
+gf_backtrace_fillframes(char *buf)
+{
+    void *array[GF_BACKTRACE_FRAME_COUNT];
+    size_t frames = 0;
+    FILE *fp = NULL;
+    char callingfn[GF_BACKTRACE_FRAME_COUNT - 2][1024] = {
+        {0},
+    };
+    int ret = -1;
+    int fd = -1;
+    size_t idx = 0;
+    size_t pos = 0;
+    size_t inc = 0;
+    char tmpl[] = "/tmp/glfs-bt-XXXXXX";
+
+    frames = backtrace(array, GF_BACKTRACE_FRAME_COUNT);
+    if (!frames)
+        return -1;
 
-        ret = fseek (fp, 0L, SEEK_SET);
-        if (ret)
-                goto out;
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(tmpl);
+    if (fd == -1)
+        return -1;
 
-        pos = 0;
-        for (idx = 0; idx < frames - 2; idx++) {
-                ret = fscanf (fp, "%s", callingfn[idx]);
-                if (ret == EOF)
-                        break;
-                inc = gf_backtrace_append (buf, pos, callingfn[idx]);
-                if (inc == -1)
-                        break;
-                pos += inc;
-        }
-        gf_backtrace_end (buf, idx);
+    /* Calling unlink so that when the file is closed or program
+     * terminates the temporary file is deleted.
+     */
+    ret = sys_unlink(tmpl);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED,
+               "Unable to delete temporary file: %s", tmpl);
+    }
+
+    /*The most recent two frames are the calling function and
+     * gf_backtrace_save, which we can infer.*/
+
+    backtrace_symbols_fd(&array[2], frames - 2, fd);
+
+    fp = fdopen(fd, "r");
+    if (!fp) {
+        sys_close(fd);
+        ret = -1;
+        goto out;
+    }
+
+    ret = fseek(fp, 0L, SEEK_SET);
+    if (ret)
+        goto out;
+
+    pos = 0;
+    for (idx = 0; idx < frames - 2; idx++) {
+        ret = fscanf(fp, "%s", callingfn[idx]);
+        if (ret == EOF)
+            break;
+        inc = gf_backtrace_append(buf, pos, callingfn[idx]);
+        if (inc == -1)
+            break;
+        pos += inc;
+    }
+    gf_backtrace_end(buf, idx);
 
 out:
-        if (fp)
-                fclose (fp);
-
-        return (idx > 0)? 0: -1;
+    if (fp)
+        fclose(fp);
 
+    return (idx > 0) ? 0 : -1;
 }
 
 /* Optionally takes @buf to save backtrace.  If @buf is NULL, uses the
@@ -4378,72 +4374,66 @@ out:
  * when there is a real-use for that.*/
 
 char *
-gf_backtrace_save (char *buf)
+gf_backtrace_save(char *buf)
 {
-        char *bt = NULL;
-
-        if (!buf) {
-                bt = THIS->ctx->btbuf;
-                GF_ASSERT (bt);
+    char *bt = NULL;
 
-        } else {
-                bt = buf;
+    if (!buf) {
+        bt = THIS->ctx->btbuf;
+        GF_ASSERT(bt);
 
-        }
+    } else {
+        bt = buf;
+    }
 
-        if ((0 == gf_backtrace_fillframes (bt)))
-                return bt;
+    if ((0 == gf_backtrace_fillframes(bt)))
+        return bt;
 
-        gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED,
-                "Failed to save the backtrace.");
-        return NULL;
+    gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED,
+           "Failed to save the backtrace.");
+    return NULL;
 }
 
 gf_loglevel_t
-fop_log_level (glusterfs_fop_t fop, int op_errno)
-{
-        /* if gfid doesn't exist ESTALE comes */
-        if (op_errno == ENOENT || op_errno == ESTALE)
-                return GF_LOG_DEBUG;
-
-        if ((fop == GF_FOP_ENTRYLK) ||
-            (fop == GF_FOP_FENTRYLK) ||
-            (fop == GF_FOP_FINODELK) ||
-            (fop == GF_FOP_INODELK) ||
-            (fop == GF_FOP_LK)) {
-                /*
-                 * if non-blocking lock fails EAGAIN comes
-                 * if locks xlator is not loaded ENOSYS comes
-                 */
-                if (op_errno == EAGAIN || op_errno == ENOSYS)
-                        return GF_LOG_DEBUG;
-        }
+fop_log_level(glusterfs_fop_t fop, int op_errno)
+{
+    /* if gfid doesn't exist ESTALE comes */
+    if (op_errno == ENOENT || op_errno == ESTALE)
+        return GF_LOG_DEBUG;
 
-        if ((fop == GF_FOP_GETXATTR) ||
-            (fop == GF_FOP_FGETXATTR)) {
-                if (op_errno == ENOTSUP || op_errno == ENODATA)
-                        return GF_LOG_DEBUG;
-        }
+    if ((fop == GF_FOP_ENTRYLK) || (fop == GF_FOP_FENTRYLK) ||
+        (fop == GF_FOP_FINODELK) || (fop == GF_FOP_INODELK) ||
+        (fop == GF_FOP_LK)) {
+        /*
+         * if non-blocking lock fails EAGAIN comes
+         * if locks xlator is not loaded ENOSYS comes
+         */
+        if (op_errno == EAGAIN || op_errno == ENOSYS)
+            return GF_LOG_DEBUG;
+    }
 
-        if ((fop == GF_FOP_SETXATTR) ||
-            (fop == GF_FOP_FSETXATTR) ||
-            (fop == GF_FOP_REMOVEXATTR) ||
-            (fop == GF_FOP_FREMOVEXATTR)) {
-                if (op_errno == ENOTSUP)
-                        return GF_LOG_DEBUG;
-        }
+    if ((fop == GF_FOP_GETXATTR) || (fop == GF_FOP_FGETXATTR)) {
+        if (op_errno == ENOTSUP || op_errno == ENODATA)
+            return GF_LOG_DEBUG;
+    }
+
+    if ((fop == GF_FOP_SETXATTR) || (fop == GF_FOP_FSETXATTR) ||
+        (fop == GF_FOP_REMOVEXATTR) || (fop == GF_FOP_FREMOVEXATTR)) {
+        if (op_errno == ENOTSUP)
+            return GF_LOG_DEBUG;
+    }
 
-        if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR)
-                if (op_errno == EEXIST)
-                        return GF_LOG_DEBUG;
+    if (fop == GF_FOP_MKNOD || fop == GF_FOP_MKDIR)
+        if (op_errno == EEXIST)
+            return GF_LOG_DEBUG;
 
-        if (fop == GF_FOP_SEEK) {
-                if (op_errno == ENXIO) {
-                        return GF_LOG_DEBUG;
-                }
+    if (fop == GF_FOP_SEEK) {
+        if (op_errno == ENXIO) {
+            return GF_LOG_DEBUG;
         }
+    }
 
-        return GF_LOG_ERROR;
+    return GF_LOG_ERROR;
 }
 
 /* This function will build absolute path of file/directory from the
@@ -4461,116 +4451,115 @@ fop_log_level (glusterfs_fop_t fop, int op_errno)
  */
 
 int32_t
-gf_build_absolute_path (char *current_path, char *relative_path, char **path)
-{
-        char                    *absolute_path          = NULL;
-        char                    *token                  = NULL;
-        char                    *component              = NULL;
-        char                    *saveptr                = NULL;
-        char                    *end                    = NULL;
-        int                     ret                     = 0;
-        size_t                  relativepath_len        = 0;
-        size_t                  currentpath_len         = 0;
-        size_t                  max_absolutepath_len    = 0;
-
-        GF_ASSERT (current_path);
-        GF_ASSERT (relative_path);
-        GF_ASSERT (path);
-
-        if (!path || !current_path || !relative_path) {
-                ret = -EFAULT;
-                goto err;
-        }
-        /* Check for current and relative path
-         * current path should be absolute one and  start from '/'
-         * relative path should not start from '/'
-         */
-        currentpath_len = strlen (current_path);
-        if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Wrong value for current path %s", current_path);
-                ret = -EINVAL;
-                goto err;
-        }
-
-        relativepath_len = strlen (relative_path);
-        if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Wrong value for relative path %s", relative_path);
-                ret = -EINVAL;
+gf_build_absolute_path(char *current_path, char *relative_path, char **path)
+{
+    char *absolute_path = NULL;
+    char *token = NULL;
+    char *component = NULL;
+    char *saveptr = NULL;
+    char *end = NULL;
+    int ret = 0;
+    size_t relativepath_len = 0;
+    size_t currentpath_len = 0;
+    size_t max_absolutepath_len = 0;
+
+    GF_ASSERT(current_path);
+    GF_ASSERT(relative_path);
+    GF_ASSERT(path);
+
+    if (!path || !current_path || !relative_path) {
+        ret = -EFAULT;
+        goto err;
+    }
+    /* Check for current and relative path
+     * current path should be absolute one and  start from '/'
+     * relative path should not start from '/'
+     */
+    currentpath_len = strlen(current_path);
+    if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Wrong value for current path %s", current_path);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    relativepath_len = strlen(relative_path);
+    if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Wrong value for relative path %s", relative_path);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    /* It is maximum possible value for absolute path */
+    max_absolutepath_len = currentpath_len + relativepath_len + 2;
+
+    absolute_path = GF_CALLOC(1, max_absolutepath_len, gf_common_mt_char);
+    if (!absolute_path) {
+        ret = -ENOMEM;
+        goto err;
+    }
+    absolute_path[0] = '\0';
+
+    /* If current path is root i.e contains only "/", we do not
+     * need to copy it
+     */
+    if (strcmp(current_path, "/") != 0) {
+        strcpy(absolute_path, current_path);
+
+        /* We trim '/' at the end for easier string manipulation */
+        gf_path_strip_trailing_slashes(absolute_path);
+    }
+
+    /* Used to spilt relative path based on '/' */
+    component = gf_strdup(relative_path);
+    if (!component) {
+        ret = -ENOMEM;
+        goto err;
+    }
+
+    /* In the relative path, we want to consider ".." and "."
+     * if token is ".." , we just need to reduce one level hierarchy
+     * if token is "." , we just ignore it
+     * if token is NULL , end of relative path
+     * if absolute path becomes '\0' and still "..", then it is a bad
+     * relative path,  it points to out of boundary area and stop
+     * building the absolute path
+     * All other cases we just concatenate token to the absolute path
+     */
+    for (token = strtok_r(component, "/", &saveptr),
+        end = strchr(absolute_path, '\0');
+         token; token = strtok_r(NULL, "/", &saveptr)) {
+        if (strcmp(token, ".") == 0)
+            continue;
+
+        else if (strcmp(token, "..") == 0) {
+            if (absolute_path[0] == '\0') {
+                ret = -EACCES;
                 goto err;
-        }
-
-        /* It is maximum possible value for absolute path */
-        max_absolutepath_len = currentpath_len + relativepath_len + 2;
-
-        absolute_path = GF_CALLOC (1, max_absolutepath_len, gf_common_mt_char);
-        if (!absolute_path) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        absolute_path[0] = '\0';
-
-        /* If current path is root i.e contains only "/", we do not
-         * need to copy it
-         */
-        if (strcmp (current_path, "/") != 0) {
-                strcpy (absolute_path, current_path);
-
-                /* We trim '/' at the end for easier string manipulation */
-                gf_path_strip_trailing_slashes (absolute_path);
-        }
-
-        /* Used to spilt relative path based on '/' */
-        component = gf_strdup (relative_path);
-        if (!component) {
-                ret = -ENOMEM;
-                goto err;
-        }
+            }
 
-        /* In the relative path, we want to consider ".." and "."
-         * if token is ".." , we just need to reduce one level hierarchy
-         * if token is "." , we just ignore it
-         * if token is NULL , end of relative path
-         * if absolute path becomes '\0' and still "..", then it is a bad
-         * relative path,  it points to out of boundary area and stop
-         * building the absolute path
-         * All other cases we just concatenate token to the absolute path
-         */
-        for (token = strtok_r (component,  "/", &saveptr),
-             end = strchr (absolute_path, '\0'); token;
-             token = strtok_r (NULL, "/", &saveptr)) {
-                if (strcmp (token, ".") == 0)
-                        continue;
-
-                else if (strcmp (token, "..") == 0) {
-
-                        if (absolute_path[0] == '\0') {
-                                ret = -EACCES;
-                                goto err;
-                         }
-
-                         end = strrchr (absolute_path, '/');
-                         *end = '\0';
-                } else {
-                        ret = snprintf (end, max_absolutepath_len -
-                                        strlen (absolute_path), "/%s", token);
-                        end = strchr (absolute_path , '\0');
-                }
+            end = strrchr(absolute_path, '/');
+            *end = '\0';
+        } else {
+            ret = snprintf(end, max_absolutepath_len - strlen(absolute_path),
+                           "/%s", token);
+            end = strchr(absolute_path, '\0');
         }
+    }
 
-        if (strlen (absolute_path) > PATH_MAX) {
-                ret = -EINVAL;
-                goto err;
-        }
-        *path = gf_strdup (absolute_path);
+    if (strlen(absolute_path) > PATH_MAX) {
+        ret = -EINVAL;
+        goto err;
+    }
+    *path = gf_strdup(absolute_path);
 
 err:
-        if (component)
-                GF_FREE (component);
-        if (absolute_path)
-                GF_FREE (absolute_path);
-        return ret;
+    if (component)
+        GF_FREE(component);
+    if (absolute_path)
+        GF_FREE(absolute_path);
+    return ret;
 }
 
 /* This is an utility function which will recursively delete
@@ -4581,69 +4570,85 @@ err:
  * @return 0 on success and -1 on failure.
  */
 int
-recursive_rmdir (const char *delete_path)
-{
-        int             ret             = -1;
-        char            path[PATH_MAX]  = {0,};
-        struct stat     st              = {0,};
-        DIR            *dir             = NULL;
-        struct dirent  *entry           = NULL;
-        struct dirent   scratch[2]      = {{0,},};
-        xlator_t       *this            = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-        GF_VALIDATE_OR_GOTO (this->name, delete_path, out);
-
-        dir = sys_opendir (delete_path);
-        if (!dir) {
-                gf_msg_debug (this->name, 0, "Failed to open directory %s. "
-                              "Reason : %s", delete_path, strerror (errno));
-                ret = 0;
-                goto out;
-        }
+recursive_rmdir(const char *delete_path)
+{
+    int ret = -1;
+    char path[PATH_MAX] = {
+        0,
+    };
+    struct stat st = {
+        0,
+    };
+    DIR *dir = NULL;
+    struct dirent *entry = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_VALIDATE_OR_GOTO(this->name, delete_path, out);
+
+    dir = sys_opendir(delete_path);
+    if (!dir) {
+        gf_msg_debug(this->name, 0,
+                     "Failed to open directory %s. "
+                     "Reason : %s",
+                     delete_path, strerror(errno));
+        ret = 0;
+        goto out;
+    }
 
-        GF_SKIP_IRRELEVANT_ENTRIES (entry, dir, scratch);
-        while (entry) {
-                snprintf (path, PATH_MAX, "%s/%s", delete_path, entry->d_name);
-                ret = sys_lstat (path, &st);
-                if (ret == -1) {
-                        gf_msg_debug (this->name, 0, "Failed to stat entry %s :"
-                                      " %s", path, strerror (errno));
-                        (void) sys_closedir (dir);
-                        goto out;
-                }
-
-                if (S_ISDIR (st.st_mode))
-                        ret = recursive_rmdir (path);
-                else
-                        ret = sys_unlink (path);
-
-                if (ret) {
-                        gf_msg_debug (this->name, 0, " Failed to remove %s. "
-                                      "Reason : %s", path, strerror (errno));
-                }
-
-                gf_msg_debug (this->name, 0, "%s %s", ret ?
-                              "Failed to remove" : "Removed", entry->d_name);
-
-                GF_SKIP_IRRELEVANT_ENTRIES (entry, dir, scratch);
+    GF_SKIP_IRRELEVANT_ENTRIES(entry, dir, scratch);
+    while (entry) {
+        snprintf(path, PATH_MAX, "%s/%s", delete_path, entry->d_name);
+        ret = sys_lstat(path, &st);
+        if (ret == -1) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to stat entry %s :"
+                         " %s",
+                         path, strerror(errno));
+            (void)sys_closedir(dir);
+            goto out;
         }
 
-        ret = sys_closedir (dir);
-        if (ret) {
-                gf_msg_debug (this->name, 0, "Failed to close dir %s. Reason :"
-                              " %s", delete_path, strerror (errno));
-        }
+        if (S_ISDIR(st.st_mode))
+            ret = recursive_rmdir(path);
+        else
+            ret = sys_unlink(path);
 
-        ret = sys_rmdir (delete_path);
         if (ret) {
-                gf_msg_debug (this->name, 0, "Failed to rmdir: %s,err: %s",
-                              delete_path, strerror (errno));
+            gf_msg_debug(this->name, 0,
+                         " Failed to remove %s. "
+                         "Reason : %s",
+                         path, strerror(errno));
         }
 
+        gf_msg_debug(this->name, 0, "%s %s",
+                     ret ? "Failed to remove" : "Removed", entry->d_name);
+
+        GF_SKIP_IRRELEVANT_ENTRIES(entry, dir, scratch);
+    }
+
+    ret = sys_closedir(dir);
+    if (ret) {
+        gf_msg_debug(this->name, 0,
+                     "Failed to close dir %s. Reason :"
+                     " %s",
+                     delete_path, strerror(errno));
+    }
+
+    ret = sys_rmdir(delete_path);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Failed to rmdir: %s,err: %s", delete_path,
+                     strerror(errno));
+    }
+
 out:
-        return ret;
+    return ret;
 }
 /*
  * Input: Array of strings 'array' terminating in NULL
@@ -4652,197 +4657,198 @@ out:
  * Output: Index of the element in the array if found, '-1' otherwise
  */
 int
-gf_get_index_by_elem (char **array, char *elem)
+gf_get_index_by_elem(char **array, char *elem)
 {
-        int     i = 0;
+    int i = 0;
 
-        for (i = 0; array[i]; i++) {
-                if (strcmp (elem, array[i]) == 0)
-                        return i;
-        }
+    for (i = 0; array[i]; i++) {
+        if (strcmp(elem, array[i]) == 0)
+            return i;
+    }
 
-        return -1;
+    return -1;
 }
 
 static int
-get_pathinfo_host (char *pathinfo, char *hostname, size_t size)
+get_pathinfo_host(char *pathinfo, char *hostname, size_t size)
 {
-        char    *start = NULL;
-        char    *end = NULL;
-        int     ret  = -1;
-        int     i    = 0;
+    char *start = NULL;
+    char *end = NULL;
+    int ret = -1;
+    int i = 0;
 
-        if (!pathinfo)
-                goto out;
+    if (!pathinfo)
+        goto out;
 
-        start = strchr (pathinfo, ':');
-        if (!start)
-                goto out;
+    start = strchr(pathinfo, ':');
+    if (!start)
+        goto out;
 
-        end = strrchr (pathinfo, ':');
-        if (start == end)
-                goto out;
+    end = strrchr(pathinfo, ':');
+    if (start == end)
+        goto out;
 
-        memset (hostname, 0, size);
-        i = 0;
-        while (++start != end)
-                hostname[i++] = *start;
-        ret = 0;
+    memset(hostname, 0, size);
+    i = 0;
+    while (++start != end)
+        hostname[i++] = *start;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /*Note: 'pathinfo' should be gathered only from one brick*/
 int
-glusterfs_is_local_pathinfo (char *pathinfo, gf_boolean_t *is_local)
+glusterfs_is_local_pathinfo(char *pathinfo, gf_boolean_t *is_local)
 {
-        int             ret   = 0;
-        char            pathinfohost[1024] = {0};
-        char            localhost[1024] = {0};
+    int ret = 0;
+    char pathinfohost[1024] = {0};
+    char localhost[1024] = {0};
 
-        *is_local = _gf_false;
-        ret = get_pathinfo_host (pathinfo, pathinfohost, sizeof (pathinfohost));
-        if (ret)
-                goto out;
+    *is_local = _gf_false;
+    ret = get_pathinfo_host(pathinfo, pathinfohost, sizeof(pathinfohost));
+    if (ret)
+        goto out;
 
-        ret = gethostname (localhost, sizeof (localhost));
-        if (ret)
-                goto out;
+    ret = gethostname(localhost, sizeof(localhost));
+    if (ret)
+        goto out;
 
-        if (!strcmp (localhost, pathinfohost))
-                *is_local = _gf_true;
+    if (!strcmp(localhost, pathinfohost))
+        *is_local = _gf_true;
 out:
-        return ret;
+    return ret;
 }
 
 ssize_t
-gf_nread (int fd, void *buf, size_t count)
-{
-        ssize_t  ret           = 0;
-        ssize_t  read_bytes    = 0;
-
-        for (read_bytes = 0; read_bytes < count; read_bytes += ret) {
-                ret = sys_read (fd, buf + read_bytes, count - read_bytes);
-                if (ret == 0) {
-                        break;
-                } else if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+gf_nread(int fd, void *buf, size_t count)
+{
+    ssize_t ret = 0;
+    ssize_t read_bytes = 0;
+
+    for (read_bytes = 0; read_bytes < count; read_bytes += ret) {
+        ret = sys_read(fd, buf + read_bytes, count - read_bytes);
+        if (ret == 0) {
+            break;
+        } else if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = read_bytes;
+    ret = read_bytes;
 out:
-        return ret;
+    return ret;
 }
 
 ssize_t
-gf_nwrite (int fd, const void *buf, size_t count)
-{
-        ssize_t  ret        = 0;
-        ssize_t  written    = 0;
-
-        for (written = 0; written != count; written += ret) {
-                ret = sys_write (fd, buf + written, count - written);
-                if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+gf_nwrite(int fd, const void *buf, size_t count)
+{
+    ssize_t ret = 0;
+    ssize_t written = 0;
+
+    for (written = 0; written != count; written += ret) {
+        ret = sys_write(fd, buf + written, count - written);
+        if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = written;
+    ret = written;
 out:
-        return ret;
+    return ret;
 }
 
 void
-gf_free_mig_locks (lock_migration_info_t *locks)
+gf_free_mig_locks(lock_migration_info_t *locks)
 {
-        lock_migration_info_t    *current       = NULL;
-        lock_migration_info_t    *temp          = NULL;
+    lock_migration_info_t *current = NULL;
+    lock_migration_info_t *temp = NULL;
 
-        if (!locks)
-                return;
+    if (!locks)
+        return;
 
-        if (list_empty (&locks->list))
-                return;
+    if (list_empty(&locks->list))
+        return;
 
-        list_for_each_entry_safe (current, temp, &locks->list, list) {
-                list_del_init (&current->list);
-                GF_FREE (current->client_uid);
-                GF_FREE (current);
-        }
+    list_for_each_entry_safe(current, temp, &locks->list, list)
+    {
+        list_del_init(&current->list);
+        GF_FREE(current->client_uid);
+        GF_FREE(current);
+    }
 }
 
 void
-_mask_cancellation (void)
+_mask_cancellation(void)
 {
-        (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
+    (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 }
 
 void
-_unmask_cancellation (void)
+_unmask_cancellation(void)
 {
-        (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+    (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 }
 
 /* This is a wrapper function to add a pointer to a list,
  * which doesn't contain list member
  */
-struct list_node*
-_list_node_add (void *ptr, struct list_head *list,
+struct list_node *
+_list_node_add(void *ptr, struct list_head *list,
                int (*compare)(struct list_head *, struct list_head *))
 {
-        struct list_node  *node = NULL;
+    struct list_node *node = NULL;
 
-        if (ptr == NULL || list == NULL)
-                goto out;
+    if (ptr == NULL || list == NULL)
+        goto out;
 
-        node = GF_CALLOC (1, sizeof (struct list_node), gf_common_list_node);
+    node = GF_CALLOC(1, sizeof(struct list_node), gf_common_list_node);
 
-        if (node == NULL)
-                goto out;
+    if (node == NULL)
+        goto out;
 
-        node->ptr = ptr;
-        if (compare)
-                list_add_order (&node->list, list, compare);
-        else
-                list_add_tail (&node->list, list);
+    node->ptr = ptr;
+    if (compare)
+        list_add_order(&node->list, list, compare);
+    else
+        list_add_tail(&node->list, list);
 out:
-        return node;
+    return node;
 }
 
-struct list_node*
-list_node_add (void *ptr, struct list_head *list)
+struct list_node *
+list_node_add(void *ptr, struct list_head *list)
 {
-        return _list_node_add (ptr, list, NULL);
+    return _list_node_add(ptr, list, NULL);
 }
 
-struct list_node*
-list_node_add_order (void *ptr, struct list_head *list,
-                     int (*compare)(struct list_head *, struct list_head *))
+struct list_node *
+list_node_add_order(void *ptr, struct list_head *list,
+                    int (*compare)(struct list_head *, struct list_head *))
 {
-        return _list_node_add (ptr, list, compare);
+    return _list_node_add(ptr, list, compare);
 }
 
 void
-list_node_del (struct list_node *node)
+list_node_del(struct list_node *node)
 {
-        if (node == NULL)
-                return;
+    if (node == NULL)
+        return;
 
-        list_del_init (&node->list);
-        GF_FREE (node);
+    list_del_init(&node->list);
+    GF_FREE(node);
 }
 
 const char *
-fop_enum_to_pri_string (glusterfs_fop_t fop)
+fop_enum_to_pri_string(glusterfs_fop_t fop)
 {
-        switch (fop) {
+    switch (fop) {
         case GF_FOP_OPEN:
         case GF_FOP_STAT:
         case GF_FOP_FSTAT:
@@ -4857,7 +4863,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_SETACTIVELK:
         case GF_FOP_ICREATE:
         case GF_FOP_NAMELINK:
-                return "HIGH";
+            return "HIGH";
 
         case GF_FOP_CREATE:
         case GF_FOP_FLUSH:
@@ -4883,7 +4889,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_FREMOVEXATTR:
         case GF_FOP_IPC:
         case GF_FOP_LEASE:
-                return "NORMAL";
+            return "NORMAL";
 
         case GF_FOP_READ:
         case GF_FOP_WRITE:
@@ -4897,7 +4903,7 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_ZEROFILL:
         case GF_FOP_FALLOCATE:
         case GF_FOP_SEEK:
-                return "LOW";
+            return "LOW";
 
         case GF_FOP_NULL:
         case GF_FOP_FORGET:
@@ -4906,187 +4912,184 @@ fop_enum_to_pri_string (glusterfs_fop_t fop)
         case GF_FOP_GETSPEC:
         case GF_FOP_MAXVALUE:
         case GF_FOP_DISCARD:
-                return "LEAST";
+            return "LEAST";
         default:
-                return "UNKNOWN";
-        }
+            return "UNKNOWN";
+    }
 }
 
 const char *
-gf_inode_type_to_str (ia_type_t type)
+gf_inode_type_to_str(ia_type_t type)
 {
-        static const char *const str_ia_type[] = {
-                "UNKNOWN",
-                "REGULAR FILE",
-                "DIRECTORY",
-                "LINK",
-                "BLOCK DEVICE",
-                "CHARACTER DEVICE",
-                "PIPE",
-                "SOCKET"};
-        return str_ia_type[type];
+    static const char *const str_ia_type[] = {
+        "UNKNOWN",      "REGULAR FILE",     "DIRECTORY", "LINK",
+        "BLOCK DEVICE", "CHARACTER DEVICE", "PIPE",      "SOCKET"};
+    return str_ia_type[type];
 }
 
 gf_boolean_t
-gf_is_zero_filled_stat (struct iatt *buf)
+gf_is_zero_filled_stat(struct iatt *buf)
 {
-        if (!buf)
-                return 1;
+    if (!buf)
+        return 1;
 
-        /* Do not use st_dev because it is transformed to store the xlator id
-         * in place of the device number. Do not use st_ino because by this time
-         * we've already mapped the root ino to 1 so it is not guaranteed to be
-         * 0.
-         */
-        if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0))
-                return 1;
+    /* Do not use st_dev because it is transformed to store the xlator id
+     * in place of the device number. Do not use st_ino because by this time
+     * we've already mapped the root ino to 1 so it is not guaranteed to be
+     * 0.
+     */
+    if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0))
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 void
-gf_zero_fill_stat (struct iatt *buf)
+gf_zero_fill_stat(struct iatt *buf)
 {
-        buf->ia_nlink = 0;
-        buf->ia_ctime = 0;
+    buf->ia_nlink = 0;
+    buf->ia_ctime = 0;
 }
 
 gf_boolean_t
-gf_is_valid_xattr_namespace (char *key)
+gf_is_valid_xattr_namespace(char *key)
 {
-        static char *xattr_namespaces[] = {"trusted.", "security.", "system.",
-                                           "user.", NULL };
-        int i = 0;
+    static char *xattr_namespaces[] = {"trusted.", "security.", "system.",
+                                       "user.", NULL};
+    int i = 0;
 
-        for (i = 0; xattr_namespaces[i]; i++) {
-                if (strncmp (key, xattr_namespaces[i],
-                             strlen (xattr_namespaces[i])) == 0)
-                        return _gf_true;
-        }
+    for (i = 0; xattr_namespaces[i]; i++) {
+        if (strncmp(key, xattr_namespaces[i], strlen(xattr_namespaces[i])) == 0)
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 ino_t
-gfid_to_ino (uuid_t gfid)
+gfid_to_ino(uuid_t gfid)
 {
-        ino_t ino = 0;
-        int32_t i;
+    ino_t ino = 0;
+    int32_t i;
 
-        for (i = 8; i < 16; i++) {
-                ino <<= 8;
-                ino += (uint8_t)gfid[i];
-        }
+    for (i = 8; i < 16; i++) {
+        ino <<= 8;
+        ino += (uint8_t)gfid[i];
+    }
 
-        return ino;
+    return ino;
 }
 
 int
-gf_bits_count (uint64_t n)
+gf_bits_count(uint64_t n)
 {
-        int val = 0;
+    int val = 0;
 #if defined(__GNUC__) || defined(__clang__)
-        val = __builtin_popcountll (n);
+    val = __builtin_popcountll(n);
 #else
-        n -= (n >> 1) & 0x5555555555555555ULL;
-        n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL);
-        n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-        n += n >> 8;
-        n += n >> 16;
-        n += n >> 32;
-        val = n & 0xFF;
+    n -= (n >> 1) & 0x5555555555555555ULL;
+    n = ((n >> 2) & 0x3333333333333333ULL) + (n & 0x3333333333333333ULL);
+    n = (n + (n >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+    n += n >> 8;
+    n += n >> 16;
+    n += n >> 32;
+    val = n & 0xFF;
 #endif
-        return val;
+    return val;
 }
 
 int
-gf_bits_index (uint64_t n)
+gf_bits_index(uint64_t n)
 {
 #if defined(__GNUC__) || defined(__clang__)
-        return __builtin_ffsll (n) - 1;
+    return __builtin_ffsll(n) - 1;
 #else
-        return ffsll (n) - 1;
+    return ffsll(n) - 1;
 #endif
 }
 
-const char*
-gf_fop_string (glusterfs_fop_t fop)
+const char *
+gf_fop_string(glusterfs_fop_t fop)
 {
-        if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE))
-                return gf_fop_list[fop];
-        return "INVALID";
+    if ((fop > GF_FOP_NULL) && (fop < GF_FOP_MAXVALUE))
+        return gf_fop_list[fop];
+    return "INVALID";
 }
 
 int
-gf_fop_int (char *fop)
+gf_fop_int(char *fop)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
-                if (strcasecmp (fop, gf_fop_list[i]) == 0)
-                        return i;
-        }
-        return -1;
+    for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
+        if (strcasecmp(fop, gf_fop_list[i]) == 0)
+            return i;
+    }
+    return -1;
 }
 
 int
-close_fds_except (int *fdv, size_t count)
+close_fds_except(int *fdv, size_t count)
 {
-        int          i            = 0;
-        size_t       j            = 0;
-        gf_boolean_t should_close = _gf_true;
+    int i = 0;
+    size_t j = 0;
+    gf_boolean_t should_close = _gf_true;
 #ifdef GF_LINUX_HOST_OS
-        DIR           *d          = NULL;
-        struct dirent *de         = NULL;
-        struct dirent  scratch[2] = {{0,},};
-        char          *e          = NULL;
-
-        d = sys_opendir ("/proc/self/fd");
-        if (!d)
-                return -1;
-
-        for (;;) {
-                should_close = _gf_true;
-
-                errno = 0;
-                de = sys_readdir (d, scratch);
-                if (!de || errno != 0)
-                        break;
-                i = strtoul (de->d_name, &e, 10);
-                if (*e != '\0' || i == dirfd (d))
-                        continue;
-
-                for (j = 0; j < count; j++) {
-                        if (i == fdv[j]) {
-                                should_close = _gf_false;
-                                break;
-                        }
-               }
-               if (should_close)
-                        sys_close (i);
-        }
-        sys_closedir (d);
-#else /* !GF_LINUX_HOST_OS */
-        struct rlimit rl;
-        int ret = -1;
+    DIR *d = NULL;
+    struct dirent *de = NULL;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    char *e = NULL;
+
+    d = sys_opendir("/proc/self/fd");
+    if (!d)
+        return -1;
+
+    for (;;) {
+        should_close = _gf_true;
 
-        ret = getrlimit (RLIMIT_NOFILE, &rl);
-        if (ret)
-                return ret;
-
-        for (i = 0; i < rl.rlim_cur; i++) {
-                should_close = _gf_true;
-                for (j = 0; j < count; j++) {
-                        if (i == fdv[j]) {
-                                should_close = _gf_false;
-                                break;
-                        }
-                }
-                if (should_close)
-                        sys_close (i);
+        errno = 0;
+        de = sys_readdir(d, scratch);
+        if (!de || errno != 0)
+            break;
+        i = strtoul(de->d_name, &e, 10);
+        if (*e != '\0' || i == dirfd(d))
+            continue;
+
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = _gf_false;
+                break;
+            }
+        }
+        if (should_close)
+            sys_close(i);
+    }
+    sys_closedir(d);
+#else  /* !GF_LINUX_HOST_OS */
+    struct rlimit rl;
+    int ret = -1;
+
+    ret = getrlimit(RLIMIT_NOFILE, &rl);
+    if (ret)
+        return ret;
+
+    for (i = 0; i < rl.rlim_cur; i++) {
+        should_close = _gf_true;
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = _gf_false;
+                break;
+            }
         }
+        if (should_close)
+            sys_close(i);
+    }
 #endif /* !GF_LINUX_HOST_OS */
-        return 0;
+    return 0;
 }
 
 /**
@@ -5106,105 +5109,129 @@ close_fds_except (int *fdv, size_t count)
  *         failure: -1
  */
 int
-gf_getgrouplist (const char *user, gid_t group, gid_t **groups)
+gf_getgrouplist(const char *user, gid_t group, gid_t **groups)
 {
-        int ret     = -1;
-        int ngroups = SMALL_GROUP_COUNT;
+    int ret = -1;
+    int ngroups = SMALL_GROUP_COUNT;
 
-        *groups = GF_CALLOC (sizeof (gid_t), ngroups, gf_common_mt_groups_t);
-        if (!*groups)
-                return -1;
+    *groups = GF_CALLOC(sizeof(gid_t), ngroups, gf_common_mt_groups_t);
+    if (!*groups)
+        return -1;
 
-        /*
-         * We are running getgrouplist() in a loop until we succeed (or hit
-         * certain exit conditions, see the comments below). This is because
-         * the indicated number of auxiliary groups that we obtain in case of
-         * the failure of the first invocation is not guaranteed to keep its
-         * validity upon the next invocation with a gid buffer of that size.
-         */
-        for (;;) {
-                int ngroups_old = ngroups;
-                ret = getgrouplist (user, group, *groups, &ngroups);
-                if (ret != -1)
-                        break;
-
-                if (ngroups >= GF_MAX_AUX_GROUPS) {
-                        /*
-                         * This should not happen as GF_MAX_AUX_GROUPS is set
-                         * to the max value of number of supported auxiliary
-                         * groups across all platforms supported by GlusterFS.
-                         * However, if it still happened some way, we wouldn't
-                         * care about the incompleteness of the result, we'd
-                         * just go on with what we got.
-                         */
-                        return GF_MAX_AUX_GROUPS;
-                } else if (ngroups <= ngroups_old) {
-                        /*
-                         * There is an edge case that getgrouplist() fails but
-                         * ngroups remains the same. This is actually not
-                         * specified in getgrouplist(3), but implementations
-                         * can do this upon internal failure[1]. To avoid
-                         * falling into an infinite loop when this happens, we
-                         * break the loop if the getgrouplist call failed
-                         * without an increase in the indicated group number.
-                         *
-                         * [1] https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168
-                         */
-                        GF_FREE (*groups);
-                        return -1;
-                }
-
-                *groups = GF_REALLOC (*groups, ngroups * sizeof (gid_t));
-                if (!*groups)
-                        return -1;
-        }
-        return ret;
+    /*
+     * We are running getgrouplist() in a loop until we succeed (or hit
+     * certain exit conditions, see the comments below). This is because
+     * the indicated number of auxiliary groups that we obtain in case of
+     * the failure of the first invocation is not guaranteed to keep its
+     * validity upon the next invocation with a gid buffer of that size.
+     */
+    for (;;) {
+        int ngroups_old = ngroups;
+        ret = getgrouplist(user, group, *groups, &ngroups);
+        if (ret != -1)
+            break;
+
+        if (ngroups >= GF_MAX_AUX_GROUPS) {
+            /*
+             * This should not happen as GF_MAX_AUX_GROUPS is set
+             * to the max value of number of supported auxiliary
+             * groups across all platforms supported by GlusterFS.
+             * However, if it still happened some way, we wouldn't
+             * care about the incompleteness of the result, we'd
+             * just go on with what we got.
+             */
+            return GF_MAX_AUX_GROUPS;
+        } else if (ngroups <= ngroups_old) {
+            /*
+             * There is an edge case that getgrouplist() fails but
+             * ngroups remains the same. This is actually not
+             * specified in getgrouplist(3), but implementations
+             * can do this upon internal failure[1]. To avoid
+             * falling into an infinite loop when this happens, we
+             * break the loop if the getgrouplist call failed
+             * without an increase in the indicated group number.
+             *
+             * [1]
+             * https://sourceware.org/git/?p=glibc.git;a=blob;f=grp/initgroups.c;hb=refs/heads/release/2.25/master#l168
+             */
+            GF_FREE(*groups);
+            return -1;
+        }
+
+        *groups = GF_REALLOC(*groups, ngroups * sizeof(gid_t));
+        if (!*groups)
+            return -1;
+    }
+    return ret;
 }
 
 int
-glusterfs_compute_sha256 (const unsigned char *content, size_t size,
-                          char *sha256_hash) {
-        SHA256_CTX               sha256;
+glusterfs_compute_sha256(const unsigned char *content, size_t size,
+                         char *sha256_hash)
+{
+    SHA256_CTX sha256;
 
-        SHA256_Init (&sha256);
-        SHA256_Update (&sha256, (const unsigned char *) (content), size);
-        SHA256_Final ((unsigned char *) sha256_hash, &sha256);
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, (const unsigned char *)(content), size);
+    SHA256_Final((unsigned char *)sha256_hash, &sha256);
 
-        return 0;
+    return 0;
 }
 
-char*
-get_struct_variable (int mem_num, gf_gsync_status_t *sts_val)
-{
-        switch (mem_num) {
-        case 0:  return (sts_val->node);
-        case 1:  return (sts_val->master);
-        case 2:  return (sts_val->brick);
-        case 3:  return (sts_val->slave_user);
-        case 4:  return (sts_val->slave);
-        case 5:  return (sts_val->slave_node);
-        case 6:  return (sts_val->worker_status);
-        case 7:  return (sts_val->crawl_status);
-        case 8:  return (sts_val->last_synced);
-        case 9:  return (sts_val->entry);
-        case 10:  return (sts_val->data);
-        case 11:  return (sts_val->meta);
-        case 12: return (sts_val->failures);
-        case 13:  return (sts_val->checkpoint_time);
-        case 14:  return (sts_val->checkpoint_completed);
-        case 15:  return (sts_val->checkpoint_completion_time);
-        case 16: return (sts_val->brick_host_uuid);
-        case 17: return (sts_val->last_synced_utc);
-        case 18: return (sts_val->checkpoint_time_utc);
-        case 19: return (sts_val->checkpoint_completion_time_utc);
-        case 20: return (sts_val->slavekey);
-        case 21: return (sts_val->session_slave);
+char *
+get_struct_variable(int mem_num, gf_gsync_status_t *sts_val)
+{
+    switch (mem_num) {
+        case 0:
+            return (sts_val->node);
+        case 1:
+            return (sts_val->master);
+        case 2:
+            return (sts_val->brick);
+        case 3:
+            return (sts_val->slave_user);
+        case 4:
+            return (sts_val->slave);
+        case 5:
+            return (sts_val->slave_node);
+        case 6:
+            return (sts_val->worker_status);
+        case 7:
+            return (sts_val->crawl_status);
+        case 8:
+            return (sts_val->last_synced);
+        case 9:
+            return (sts_val->entry);
+        case 10:
+            return (sts_val->data);
+        case 11:
+            return (sts_val->meta);
+        case 12:
+            return (sts_val->failures);
+        case 13:
+            return (sts_val->checkpoint_time);
+        case 14:
+            return (sts_val->checkpoint_completed);
+        case 15:
+            return (sts_val->checkpoint_completion_time);
+        case 16:
+            return (sts_val->brick_host_uuid);
+        case 17:
+            return (sts_val->last_synced_utc);
+        case 18:
+            return (sts_val->checkpoint_time_utc);
+        case 19:
+            return (sts_val->checkpoint_completion_time_utc);
+        case 20:
+            return (sts_val->slavekey);
+        case 21:
+            return (sts_val->session_slave);
         default:
-                 goto out;
-        }
+            goto out;
+    }
 
 out:
-        return NULL;
+    return NULL;
 }
 
 /* * Safe wrapper function for strncpy.
@@ -5214,73 +5241,73 @@ out:
  */
 
 char *
-gf_strncpy (char *dest, const char *src, const size_t dest_size)
+gf_strncpy(char *dest, const char *src, const size_t dest_size)
 {
-        strncpy (dest, src, dest_size - 1);
-        dest[dest_size - 1] = '\0';
-        return dest;
+    strncpy(dest, src, dest_size - 1);
+    dest[dest_size - 1] = '\0';
+    return dest;
 }
 
 int
-gf_replace_old_iatt_in_dict (dict_t *xdata)
+gf_replace_old_iatt_in_dict(dict_t *xdata)
 {
-        int ret;
-        struct old_iatt *o_iatt; /* old iatt structure */
-        struct iatt *c_iatt; /* current iatt */
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* current iatt */
 
-        if (!xdata) {
-                return 0;
-        }
+    if (!xdata) {
+        return 0;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt);
-        if (ret < 0) {
-                return 0;
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&c_iatt);
+    if (ret < 0) {
+        return 0;
+    }
 
-        o_iatt = GF_CALLOC (1, sizeof (struct old_iatt), gf_common_mt_char);
-        if (!o_iatt) {
-                return -1;
-        }
+    o_iatt = GF_CALLOC(1, sizeof(struct old_iatt), gf_common_mt_char);
+    if (!o_iatt) {
+        return -1;
+    }
 
-        oldiatt_from_iatt (o_iatt, c_iatt);
+    oldiatt_from_iatt(o_iatt, c_iatt);
 
-        ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, o_iatt,
-                            sizeof (struct old_iatt));
-        if (ret) {
-                GF_FREE (o_iatt);
-        }
+    ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, o_iatt,
+                       sizeof(struct old_iatt));
+    if (ret) {
+        GF_FREE(o_iatt);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-gf_replace_new_iatt_in_dict (dict_t *xdata)
+gf_replace_new_iatt_in_dict(dict_t *xdata)
 {
-        int ret;
-        struct old_iatt *o_iatt; /* old iatt structure */
-        struct iatt *c_iatt; /* new iatt */
+    int ret;
+    struct old_iatt *o_iatt; /* old iatt structure */
+    struct iatt *c_iatt;     /* new iatt */
 
-        if (!xdata) {
-                return 0;
-        }
+    if (!xdata) {
+        return 0;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt);
-        if (ret < 0) {
-                return 0;
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&o_iatt);
+    if (ret < 0) {
+        return 0;
+    }
 
-        c_iatt = GF_CALLOC (1, sizeof (struct iatt), gf_common_mt_char);
-        if (!c_iatt) {
-                return -1;
-        }
+    c_iatt = GF_CALLOC(1, sizeof(struct iatt), gf_common_mt_char);
+    if (!c_iatt) {
+        return -1;
+    }
 
-        iatt_from_oldiatt (c_iatt, o_iatt);
+    iatt_from_oldiatt(c_iatt, o_iatt);
 
-        ret = dict_set_bin (xdata, DHT_IATT_IN_XDATA_KEY, c_iatt,
-                            sizeof (struct iatt));
-        if (ret) {
-                GF_FREE (c_iatt);
-        }
+    ret = dict_set_bin(xdata, DHT_IATT_IN_XDATA_KEY, c_iatt,
+                       sizeof(struct iatt));
+    if (ret) {
+        GF_FREE(c_iatt);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/compat-errno.c b/libglusterfs/src/compat-errno.c
index 3674596ad71..5051b75c772 100644
--- a/libglusterfs/src/compat-errno.c
+++ b/libglusterfs/src/compat-errno.c
@@ -12,7 +12,6 @@
 
 #include "compat-errno.h"
 
-
 static int32_t gf_error_to_errno_array[1024];
 static int32_t gf_errno_to_error_array[1024];
 
@@ -20,912 +19,937 @@ static int32_t gf_compat_errno_init_done;
 
 #ifdef GF_SOLARIS_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-/*      ENOMSG  35      / * No message of desired type          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-/*      EIDRM   36      / * Identifier removed                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-
-/*      ECHRNG  37      / * Channel number out of range         */
-        gf_error_to_errno_array[GF_ERROR_CODE_CHRNG] = ECHRNG;
-        gf_errno_to_error_array[ECHRNG] = GF_ERROR_CODE_CHRNG;
-
-/*      EL2NSYNC 38     / * Level 2 not synchronized            */
-        gf_error_to_errno_array[GF_ERROR_CODE_L2NSYNC] = EL2NSYNC;
-        gf_errno_to_error_array[EL2NSYNC] = GF_ERROR_CODE_L2NSYNC;
-
-/*      EL3HLT  39      / * Level 3 halted                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_L3HLT] = EL3HLT;
-        gf_errno_to_error_array[EL3HLT] = GF_ERROR_CODE_L3HLT;
-
-/*      EL3RST  40      / * Level 3 reset                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_L3RST] = EL3RST;
-        gf_errno_to_error_array[EL3RST] = GF_ERROR_CODE_L3RST;
-
-/*      ELNRNG  41      / * Link number out of range            */
-        gf_error_to_errno_array[GF_ERROR_CODE_LNRNG] = ELNRNG;
-        gf_errno_to_error_array[ELNRNG] = GF_ERROR_CODE_LNRNG;
-
-/*      EUNATCH 42      / * Protocol driver not attached                */
-        gf_error_to_errno_array[GF_ERROR_CODE_UNATCH] = EUNATCH;
-        gf_errno_to_error_array[EUNATCH] = GF_ERROR_CODE_UNATCH;
-
-/*      ENOCSI  43      / * No CSI structure available          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOCSI] = ENOCSI;
-        gf_errno_to_error_array[ENOCSI] = GF_ERROR_CODE_NOCSI;
-
-/*      EL2HLT  44      / * Level 2 halted                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_L2HLT] = EL2HLT;
-        gf_errno_to_error_array[EL2HLT] = GF_ERROR_CODE_L2HLT;
-
-/*      EDEADLK 45      / * Deadlock condition.                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-/*      ENOLCK  46      / * No record locks available.          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-/*      ECANCELED 47    / * Operation canceled                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-/*      ENOTSUP 48      / * Operation not supported             */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSUPP] = ENOTSUP;
-        gf_errno_to_error_array[ENOTSUP] = GF_ERROR_CODE_NOTSUPP;
-
-/* Filesystem Quotas */
-/*      EDQUOT  49      / * Disc quota exceeded                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-/* Convergent Error Returns */
-/*      EBADE   50      / * invalid exchange                    */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADE] = EBADE;
-        gf_errno_to_error_array[EBADE] = GF_ERROR_CODE_BADE;
-/*      EBADR   51      / * invalid request descriptor          */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADR] = EBADR;
-        gf_errno_to_error_array[EBADR] = GF_ERROR_CODE_BADR;
-/*      EXFULL  52      / * exchange full                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_XFULL] = EXFULL;
-        gf_errno_to_error_array[EXFULL] = GF_ERROR_CODE_XFULL;
-/*      ENOANO  53      / * no anode                            */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOANO] = ENOANO;
-        gf_errno_to_error_array[ENOANO] = GF_ERROR_CODE_NOANO;
-/*      EBADRQC 54      / * invalid request code                        */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRQC] = EBADRQC;
-        gf_errno_to_error_array[EBADRQC] = GF_ERROR_CODE_BADRQC;
-/*      EBADSLT 55      / * invalid slot                                */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADSLT] = EBADSLT;
-        gf_errno_to_error_array[EBADSLT] = GF_ERROR_CODE_BADSLT;
-/*      EDEADLOCK 56    / * file locking deadlock error         */
-/* This is same as EDEADLK on linux */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLOCK;
-        gf_errno_to_error_array[EDEADLOCK] = GF_ERROR_CODE_DEADLK;
-
-/*      EBFONT  57      / * bad font file fmt                   */
-        gf_error_to_errno_array[GF_ERROR_CODE_BFONT] = EBFONT;
-        gf_errno_to_error_array[EBFONT] = GF_ERROR_CODE_BFONT;
-
-/* Interprocess Robust Locks */
-/*      EOWNERDEAD      58      / * process died with the lock */
-        gf_error_to_errno_array[GF_ERROR_CODE_OWNERDEAD] = EOWNERDEAD;
-        gf_errno_to_error_array[EOWNERDEAD] = GF_ERROR_CODE_OWNERDEAD;
-/*      ENOTRECOVERABLE 59      / * lock is not recoverable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTRECOVERABLE] = ENOTRECOVERABLE;
-        gf_errno_to_error_array[ENOTRECOVERABLE] = GF_ERROR_CODE_NOTRECOVERABLE;
-
-/* stream problems */
-/*      ENOSTR  60      / * Device not a stream                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
-        gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
-/*      ENODATA 61      / * no data (for no delay io)           */
-        gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
-        gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
-/*      ETIME   62      / * timer expired                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
-        gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
-/*      ENOSR   63      / * out of streams resources            */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
-        gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
-
-/*      ENONET  64      / * Machine is not on the network       */
-        gf_error_to_errno_array[GF_ERROR_CODE_NONET] = ENONET;
-        gf_errno_to_error_array[ENONET] = GF_ERROR_CODE_NONET;
-/*      ENOPKG  65      / * Package not installed               */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPKG] = ENOPKG;
-        gf_errno_to_error_array[ENOPKG] = GF_ERROR_CODE_NOPKG;
-/*      EREMOTE 66      / * The object is remote                        */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-/*      ENOLINK 67      / * the link has been severed           */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
-/*      EADV    68      / * advertise error                     */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADV] = EADV;
-        gf_errno_to_error_array[EADV] = GF_ERROR_CODE_ADV;
-/*      ESRMNT  69      / * srmount error                       */
-        gf_error_to_errno_array[GF_ERROR_CODE_SRMNT] = ESRMNT;
-        gf_errno_to_error_array[ESRMNT] = GF_ERROR_CODE_SRMNT;
-
-/*      ECOMM   70      / * Communication error on send         */
-        gf_error_to_errno_array[GF_ERROR_CODE_COMM] = ECOMM;
-        gf_errno_to_error_array[ECOMM] = GF_ERROR_CODE_COMM;
-/*      EPROTO  71      / * Protocol error                      */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
-
-/* Interprocess Robust Locks */
-/*      ELOCKUNMAPPED   72      / * locked lock was unmapped */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOCKUNMAPPED] = ELOCKUNMAPPED;
-        gf_errno_to_error_array[ELOCKUNMAPPED] = GF_ERROR_CODE_LOCKUNMAPPED;
-
-/*      ENOTACTIVE 73   / * Facility is not active              */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTACTIVE] = ENOTACTIVE;
-        gf_errno_to_error_array[ENOTACTIVE] = GF_ERROR_CODE_NOTACTIVE;
-/*      EMULTIHOP 74    / * multihop attempted                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-/*      EBADMSG 77      / * trying to read unreadable message   */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
-/*      ENAMETOOLONG 78 / * path name is too long               */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-/*      EOVERFLOW 79    / * value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-/*      ENOTUNIQ 80     / * given log. name not unique          */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTUNIQ] = ENOTUNIQ;
-        gf_errno_to_error_array[ENOTUNIQ] = GF_ERROR_CODE_NOTUNIQ;
-/*      EBADFD  81      / * f.d. invalid for this operation     */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADFD] = EBADFD;
-        gf_errno_to_error_array[EBADFD] = GF_ERROR_CODE_BADFD;
-/*      EREMCHG 82      / * Remote address changed              */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMCHG] = EREMCHG;
-        gf_errno_to_error_array[EREMCHG] = GF_ERROR_CODE_REMCHG;
-
-/* shared library problems */
-/*      ELIBACC 83      / * Can't access a needed shared lib.   */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBACC] = ELIBACC;
-        gf_errno_to_error_array[ELIBACC] = GF_ERROR_CODE_LIBACC;
-/*      ELIBBAD 84      / * Accessing a corrupted shared lib.   */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBBAD] = ELIBBAD;
-        gf_errno_to_error_array[ELIBBAD] = GF_ERROR_CODE_LIBBAD;
-/*      ELIBSCN 85      / * .lib section in a.out corrupted.    */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBSCN] = ELIBSCN;
-        gf_errno_to_error_array[ELIBSCN] = GF_ERROR_CODE_LIBSCN;
-/*      ELIBMAX 86      / * Attempting to link in too many libs.        */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBMAX] = ELIBMAX;
-        gf_errno_to_error_array[ELIBMAX] = GF_ERROR_CODE_LIBMAX;
-/*      ELIBEXEC 87     / * Attempting to exec a shared library.        */
-        gf_error_to_errno_array[GF_ERROR_CODE_LIBEXEC] = ELIBEXEC;
-        gf_errno_to_error_array[ELIBEXEC] = GF_ERROR_CODE_LIBEXEC;
-/*      EILSEQ  88      / * Illegal byte sequence.              */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-/*      ENOSYS  89      / * Unsupported file system operation   */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-/*      ELOOP   90      / * Symbolic link loop                  */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-/*      ERESTART 91     / * Restartable system call             */
-        gf_error_to_errno_array[GF_ERROR_CODE_RESTART] = ERESTART;
-        gf_errno_to_error_array[ERESTART] = GF_ERROR_CODE_RESTART;
-/*      ESTRPIPE 92     / * if pipe/FIFO, don't sleep in stream head */
-        gf_error_to_errno_array[GF_ERROR_CODE_STRPIPE] = ESTRPIPE;
-        gf_errno_to_error_array[ESTRPIPE] = GF_ERROR_CODE_STRPIPE;
-/*      ENOTEMPTY 93    / * directory not empty                 */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-/*      EUSERS  94      / * Too many users (for UFS)            */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-/* BSD Networking Software */
-        /* argument errors */
-/*      ENOTSOCK        95      / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-/*      EDESTADDRREQ    96      / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-/*      EMSGSIZE        97      / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-/*      EPROTOTYPE      98      / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-/*      ENOPROTOOPT     99      / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-/*      EPROTONOSUPPORT 120     / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-/*      ESOCKTNOSUPPORT 121     / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-/*      EOPNOTSUPP      122     / * Operation not supported on socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-/*      EPFNOSUPPORT    123     / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-/*      EAFNOSUPPORT    124     / * Address family not supported by */
-        /* protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
-/*      EADDRINUSE      125     / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
-/*      EADDRNOTAVAIL   126     / * Can't assign requested address */
-        /* operational errors */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
-/*      ENETDOWN        127     / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
-/*      ENETUNREACH     128     / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
-/*      ENETRESET       129     / * Network dropped connection because */
-        /* of reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
-/*      ECONNABORTED    130     / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
-/*      ECONNRESET      131     / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-/*      ENOBUFS         132     / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-/*      EISCONN         133     / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-/*      ENOTCONN        134     / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-/* XENIX has 135 - 142 */
-/*      ESHUTDOWN       143     / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-/*      ETOOMANYREFS    144     / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-/*      ETIMEDOUT       145     / * Connection timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-/*      ECONNREFUSED    146     / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-/*      EHOSTDOWN       147     / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-/*      EHOSTUNREACH    148     / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-/*      EALREADY        149     / * operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-/*      EINPROGRESS     150     / * operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-/* SUN Network File System */
-/*      ESTALE          151     / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        return ;
+    /*      ENOMSG  35      / * No message of desired type          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
+
+    /*      EIDRM   36      / * Identifier removed                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
+
+    /*      ECHRNG  37      / * Channel number out of range         */
+    gf_error_to_errno_array[GF_ERROR_CODE_CHRNG] = ECHRNG;
+    gf_errno_to_error_array[ECHRNG] = GF_ERROR_CODE_CHRNG;
+
+    /*      EL2NSYNC 38     / * Level 2 not synchronized            */
+    gf_error_to_errno_array[GF_ERROR_CODE_L2NSYNC] = EL2NSYNC;
+    gf_errno_to_error_array[EL2NSYNC] = GF_ERROR_CODE_L2NSYNC;
+
+    /*      EL3HLT  39      / * Level 3 halted                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_L3HLT] = EL3HLT;
+    gf_errno_to_error_array[EL3HLT] = GF_ERROR_CODE_L3HLT;
+
+    /*      EL3RST  40      / * Level 3 reset                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_L3RST] = EL3RST;
+    gf_errno_to_error_array[EL3RST] = GF_ERROR_CODE_L3RST;
+
+    /*      ELNRNG  41      / * Link number out of range            */
+    gf_error_to_errno_array[GF_ERROR_CODE_LNRNG] = ELNRNG;
+    gf_errno_to_error_array[ELNRNG] = GF_ERROR_CODE_LNRNG;
+
+    /*      EUNATCH 42      / * Protocol driver not attached                */
+    gf_error_to_errno_array[GF_ERROR_CODE_UNATCH] = EUNATCH;
+    gf_errno_to_error_array[EUNATCH] = GF_ERROR_CODE_UNATCH;
+
+    /*      ENOCSI  43      / * No CSI structure available          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOCSI] = ENOCSI;
+    gf_errno_to_error_array[ENOCSI] = GF_ERROR_CODE_NOCSI;
+
+    /*      EL2HLT  44      / * Level 2 halted                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_L2HLT] = EL2HLT;
+    gf_errno_to_error_array[EL2HLT] = GF_ERROR_CODE_L2HLT;
+
+    /*      EDEADLK 45      / * Deadlock condition.                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*      ENOLCK  46      / * No record locks available.          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
+
+    /*      ECANCELED 47    / * Operation canceled                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
+
+    /*      ENOTSUP 48      / * Operation not supported             */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSUPP] = ENOTSUP;
+    gf_errno_to_error_array[ENOTSUP] = GF_ERROR_CODE_NOTSUPP;
+
+    /* Filesystem Quotas */
+    /*      EDQUOT  49      / * Disc quota exceeded                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /* Convergent Error Returns */
+    /*      EBADE   50      / * invalid exchange                    */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADE] = EBADE;
+    gf_errno_to_error_array[EBADE] = GF_ERROR_CODE_BADE;
+    /*      EBADR   51      / * invalid request descriptor          */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADR] = EBADR;
+    gf_errno_to_error_array[EBADR] = GF_ERROR_CODE_BADR;
+    /*      EXFULL  52      / * exchange full                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_XFULL] = EXFULL;
+    gf_errno_to_error_array[EXFULL] = GF_ERROR_CODE_XFULL;
+    /*      ENOANO  53      / * no anode                            */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOANO] = ENOANO;
+    gf_errno_to_error_array[ENOANO] = GF_ERROR_CODE_NOANO;
+    /*      EBADRQC 54      / * invalid request code                        */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRQC] = EBADRQC;
+    gf_errno_to_error_array[EBADRQC] = GF_ERROR_CODE_BADRQC;
+    /*      EBADSLT 55      / * invalid slot                                */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADSLT] = EBADSLT;
+    gf_errno_to_error_array[EBADSLT] = GF_ERROR_CODE_BADSLT;
+    /*      EDEADLOCK 56    / * file locking deadlock error         */
+    /* This is same as EDEADLK on linux */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLOCK;
+    gf_errno_to_error_array[EDEADLOCK] = GF_ERROR_CODE_DEADLK;
+
+    /*      EBFONT  57      / * bad font file fmt                   */
+    gf_error_to_errno_array[GF_ERROR_CODE_BFONT] = EBFONT;
+    gf_errno_to_error_array[EBFONT] = GF_ERROR_CODE_BFONT;
+
+    /* Interprocess Robust Locks */
+    /*      EOWNERDEAD      58      / * process died with the lock */
+    gf_error_to_errno_array[GF_ERROR_CODE_OWNERDEAD] = EOWNERDEAD;
+    gf_errno_to_error_array[EOWNERDEAD] = GF_ERROR_CODE_OWNERDEAD;
+    /*      ENOTRECOVERABLE 59      / * lock is not recoverable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTRECOVERABLE] = ENOTRECOVERABLE;
+    gf_errno_to_error_array[ENOTRECOVERABLE] = GF_ERROR_CODE_NOTRECOVERABLE;
+
+    /* stream problems */
+    /*      ENOSTR  60      / * Device not a stream                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
+    gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
+    /*      ENODATA 61      / * no data (for no delay io)           */
+    gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
+    gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
+    /*      ETIME   62      / * timer expired                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
+    gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
+    /*      ENOSR   63      / * out of streams resources            */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
+    gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
+
+    /*      ENONET  64      / * Machine is not on the network       */
+    gf_error_to_errno_array[GF_ERROR_CODE_NONET] = ENONET;
+    gf_errno_to_error_array[ENONET] = GF_ERROR_CODE_NONET;
+    /*      ENOPKG  65      / * Package not installed               */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPKG] = ENOPKG;
+    gf_errno_to_error_array[ENOPKG] = GF_ERROR_CODE_NOPKG;
+    /*      EREMOTE 66      / * The object is remote                        */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+    /*      ENOLINK 67      / * the link has been severed           */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+    /*      EADV    68      / * advertise error                     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADV] = EADV;
+    gf_errno_to_error_array[EADV] = GF_ERROR_CODE_ADV;
+    /*      ESRMNT  69      / * srmount error                       */
+    gf_error_to_errno_array[GF_ERROR_CODE_SRMNT] = ESRMNT;
+    gf_errno_to_error_array[ESRMNT] = GF_ERROR_CODE_SRMNT;
+
+    /*      ECOMM   70      / * Communication error on send         */
+    gf_error_to_errno_array[GF_ERROR_CODE_COMM] = ECOMM;
+    gf_errno_to_error_array[ECOMM] = GF_ERROR_CODE_COMM;
+    /*      EPROTO  71      / * Protocol error                      */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+
+    /* Interprocess Robust Locks */
+    /*      ELOCKUNMAPPED   72      / * locked lock was unmapped */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOCKUNMAPPED] = ELOCKUNMAPPED;
+    gf_errno_to_error_array[ELOCKUNMAPPED] = GF_ERROR_CODE_LOCKUNMAPPED;
+
+    /*      ENOTACTIVE 73   / * Facility is not active              */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTACTIVE] = ENOTACTIVE;
+    gf_errno_to_error_array[ENOTACTIVE] = GF_ERROR_CODE_NOTACTIVE;
+    /*      EMULTIHOP 74    / * multihop attempted                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
+    /*      EBADMSG 77      / * trying to read unreadable message   */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+    /*      ENAMETOOLONG 78 / * path name is too long               */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+    /*      EOVERFLOW 79    / * value too large to be stored in data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
+    /*      ENOTUNIQ 80     / * given log. name not unique          */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTUNIQ] = ENOTUNIQ;
+    gf_errno_to_error_array[ENOTUNIQ] = GF_ERROR_CODE_NOTUNIQ;
+    /*      EBADFD  81      / * f.d. invalid for this operation     */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADFD] = EBADFD;
+    gf_errno_to_error_array[EBADFD] = GF_ERROR_CODE_BADFD;
+    /*      EREMCHG 82      / * Remote address changed              */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMCHG] = EREMCHG;
+    gf_errno_to_error_array[EREMCHG] = GF_ERROR_CODE_REMCHG;
+
+    /* shared library problems */
+    /*      ELIBACC 83      / * Can't access a needed shared lib.   */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBACC] = ELIBACC;
+    gf_errno_to_error_array[ELIBACC] = GF_ERROR_CODE_LIBACC;
+    /*      ELIBBAD 84      / * Accessing a corrupted shared lib.   */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBBAD] = ELIBBAD;
+    gf_errno_to_error_array[ELIBBAD] = GF_ERROR_CODE_LIBBAD;
+    /*      ELIBSCN 85      / * .lib section in a.out corrupted.    */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBSCN] = ELIBSCN;
+    gf_errno_to_error_array[ELIBSCN] = GF_ERROR_CODE_LIBSCN;
+    /*      ELIBMAX 86      / * Attempting to link in too many libs.        */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBMAX] = ELIBMAX;
+    gf_errno_to_error_array[ELIBMAX] = GF_ERROR_CODE_LIBMAX;
+    /*      ELIBEXEC 87     / * Attempting to exec a shared library.        */
+    gf_error_to_errno_array[GF_ERROR_CODE_LIBEXEC] = ELIBEXEC;
+    gf_errno_to_error_array[ELIBEXEC] = GF_ERROR_CODE_LIBEXEC;
+    /*      EILSEQ  88      / * Illegal byte sequence.              */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
+    /*      ENOSYS  89      / * Unsupported file system operation   */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
+    /*      ELOOP   90      / * Symbolic link loop                  */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+    /*      ERESTART 91     / * Restartable system call             */
+    gf_error_to_errno_array[GF_ERROR_CODE_RESTART] = ERESTART;
+    gf_errno_to_error_array[ERESTART] = GF_ERROR_CODE_RESTART;
+    /*      ESTRPIPE 92     / * if pipe/FIFO, don't sleep in stream head */
+    gf_error_to_errno_array[GF_ERROR_CODE_STRPIPE] = ESTRPIPE;
+    gf_errno_to_error_array[ESTRPIPE] = GF_ERROR_CODE_STRPIPE;
+    /*      ENOTEMPTY 93    / * directory not empty                 */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+    /*      EUSERS  94      / * Too many users (for UFS)            */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /* BSD Networking Software */
+    /* argument errors */
+    /*      ENOTSOCK        95      / * Socket operation on non-socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+    /*      EDESTADDRREQ    96      / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+    /*      EMSGSIZE        97      / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+    /*      EPROTOTYPE      98      / * Protocol wrong type for socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+    /*      ENOPROTOOPT     99      / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+    /*      EPROTONOSUPPORT 120     / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+    /*      ESOCKTNOSUPPORT 121     / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      122     / * Operation not supported on socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+    /*      EPFNOSUPPORT    123     / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+    /*      EAFNOSUPPORT    124     / * Address family not supported by */
+    /* protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+    /*      EADDRINUSE      125     / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+    /*      EADDRNOTAVAIL   126     / * Can't assign requested address */
+    /* operational errors */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+    /*      ENETDOWN        127     / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+    /*      ENETUNREACH     128     / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+    /*      ENETRESET       129     / * Network dropped connection because */
+    /* of reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+    /*      ECONNABORTED    130     / * Software caused connection abort */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+    /*      ECONNRESET      131     / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+    /*      ENOBUFS         132     / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+    /*      EISCONN         133     / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+    /*      ENOTCONN        134     / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+    /* XENIX has 135 - 142 */
+    /*      ESHUTDOWN       143     / * Can't send after socket shutdown */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+    /*      ETOOMANYREFS    144     / * Too many references: can't splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+    /*      ETIMEDOUT       145     / * Connection timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    146     / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+    /*      EHOSTDOWN       147     / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+    /*      EHOSTUNREACH    148     / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+    /*      EALREADY        149     / * operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+    /*      EINPROGRESS     150     / * operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /* SUN Network File System */
+    /*      ESTALE          151     / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    return;
 }
 #endif /* GF_SOLARIS_HOST_OS */
 
 #ifdef GF_DARWIN_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /*    EDEADLK         11              / * Resource deadlock would occur */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-        /*    EAGAIN          35              / * Try Again */
-        gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
-        gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
-
-        /*      EINPROGRESS     36              / * Operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-        /*      EALREADY        37              / * Operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-
-        /*      ENOTSOCK        38              / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-
-        /*      EDESTADDRREQ    39              / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-
-        /*      EMSGSIZE        40              / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-
-        /*      EPROTOTYPE      41              / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-
-        /*      ENOPROTOOPT     42              / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-
-        /*      EPROTONOSUPPORT 43              / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-
-        /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-        /*      EOPNOTSUPP      45              / * Operation not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-        /*      EPFNOSUPPORT    46              / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-
-        /*      EAFNOSUPPORT    47              / * Address family not supported by protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
-
-        /*      EADDRINUSE      48              / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
-
-        /*      EADDRNOTAVAIL   49              / * Can't assign requested address */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
-
-        /*      ENETDOWN        50              / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
-
-        /*      ENETUNREACH     51              / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
-
-        /*      ENETRESET       52              / * Network dropped connection on reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
-
-        /*      ECONNABORTED    53              / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
-
-        /*      ECONNRESET      54              / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-
-        /*      ENOBUFS         55              / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-
-        /*      EISCONN         56              / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-
-        /*      ENOTCONN        57              / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-
-        /*      ESHUTDOWN       58              / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-
-        /*      ETOOMANYREFS    59              / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-
-        /*      ETIMEDOUT       60              / * Operation timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-        /*      ECONNREFUSED    61              / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-
-        /*      ELOOP           62              / * Too many levels of symbolic links */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-
-        /*      ENAMETOOLONG    63              / * File name too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-
-        /*      EHOSTDOWN       64              / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-
-        /*      EHOSTUNREACH    65              / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-
-        /*      ENOTEMPTY       66              / * Directory not empty */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-
-        /*      EPROCLIM        67              / * Too many processes */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
-        gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
-
-        /*      EUSERS          68              / * Too many users */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-        /*      EDQUOT          69              / * Disc quota exceeded */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-        /*      ESTALE          70              / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        /*      EREMOTE         71              / * Too many levels of remote in path */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-
-        /*      EBADRPC         72              / * RPC struct is bad */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
-        gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
-
-        /*      ERPCMISMATCH    73              / * RPC version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
-        gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
-
-        /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
-        gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
-
-        /*      EPROGMISMATCH   75              / * Program version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
-        gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
-
-        /*      EPROCUNAVAIL    76              / * Bad procedure for program */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
-        gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
-
-        /*      ENOLCK          77              / * No locks available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-        /*      ENOSYS          78              / * Function not implemented */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-
-        /*      EFTYPE          79              / * Inappropriate file type or format */
-        gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
-        gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
-
-        /*      EAUTH           80              / * Authentication error */
-        gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
-        gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
-
-        /*      ENEEDAUTH       81              / * Need authenticator */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-/* Intelligent device errors */
-/*      EPWROFF         82      / * Device power is off */
-        gf_error_to_errno_array[GF_ERROR_CODE_PWROFF] = EPWROFF;
-        gf_errno_to_error_array[EPWROFF] = GF_ERROR_CODE_PWROFF;
-/*      EDEVERR         83      / * Device error, e.g. paper out */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEVERR] = EDEVERR;
-        gf_errno_to_error_array[EDEVERR] = GF_ERROR_CODE_DEVERR;
-
-        /*      EOVERFLOW       84              / * Value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-
-/* Program loading errors */
-/*   EBADEXEC   85      / * Bad executable */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADEXEC] = EBADEXEC;
-        gf_errno_to_error_array[EBADEXEC] = GF_ERROR_CODE_BADEXEC;
-
-/*   EBADARCH   86      / * Bad CPU type in executable */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADARCH] = EBADARCH;
-        gf_errno_to_error_array[EBADARCH] = GF_ERROR_CODE_BADARCH;
-
-/*   ESHLIBVERS 87      / * Shared library version mismatch */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHLIBVERS] = ESHLIBVERS;
-        gf_errno_to_error_array[ESHLIBVERS] = GF_ERROR_CODE_SHLIBVERS;
-
-/*   EBADMACHO  88      / * Malformed Macho file */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMACHO] = EBADMACHO;
-        gf_errno_to_error_array[EBADMACHO] = GF_ERROR_CODE_BADMACHO;
+    /*    EDEADLK         11              / * Resource deadlock would occur */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*    EAGAIN          35              / * Try Again */
+    gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
+    gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
+
+    /*      EINPROGRESS     36              / * Operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /*      EALREADY        37              / * Operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+
+    /*      ENOTSOCK        38              / * Socket operation on non-socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+
+    /*      EDESTADDRREQ    39              / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+
+    /*      EMSGSIZE        40              / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+
+    /*      EPROTOTYPE      41              / * Protocol wrong type for socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+
+    /*      ENOPROTOOPT     42              / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+
+    /*      EPROTONOSUPPORT 43              / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+
+    /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      45              / * Operation not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*      EPFNOSUPPORT    46              / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+
+    /*      EAFNOSUPPORT    47              / * Address family not supported by
+     * protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+
+    /*      EADDRINUSE      48              / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+
+    /*      EADDRNOTAVAIL   49              / * Can't assign requested address
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+
+    /*      ENETDOWN        50              / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+
+    /*      ENETUNREACH     51              / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+
+    /*      ENETRESET       52              / * Network dropped connection on
+     * reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+
+    /*      ECONNABORTED    53              / * Software caused connection abort
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+
+    /*      ECONNRESET      54              / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+
+    /*      ENOBUFS         55              / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+
+    /*      EISCONN         56              / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+
+    /*      ENOTCONN        57              / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+
+    /*      ESHUTDOWN       58              / * Can't send after socket shutdown
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+
+    /*      ETOOMANYREFS    59              / * Too many references: can't
+     * splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+
+    /*      ETIMEDOUT       60              / * Operation timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    61              / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+
+    /*      ELOOP           62              / * Too many levels of symbolic
+     * links */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+
+    /*      ENAMETOOLONG    63              / * File name too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+
+    /*      EHOSTDOWN       64              / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+
+    /*      EHOSTUNREACH    65              / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+
+    /*      ENOTEMPTY       66              / * Directory not empty */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+
+    /*      EPROCLIM        67              / * Too many processes */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
+    gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
+
+    /*      EUSERS          68              / * Too many users */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /*      EDQUOT          69              / * Disc quota exceeded */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /*      ESTALE          70              / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    /*      EREMOTE         71              / * Too many levels of remote in
+     * path */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+
+    /*      EBADRPC         72              / * RPC struct is bad */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
+    gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
+
+    /*      ERPCMISMATCH    73              / * RPC version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
+    gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
+
+    /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
+    gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
+
+    /*      EPROGMISMATCH   75              / * Program version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
+    gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
+
+    /*      EPROCUNAVAIL    76              / * Bad procedure for program */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
+    gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
+
+    /*      ENOLCK          77              / * No locks available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
+
+    /*      ENOSYS          78              / * Function not implemented */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
+
+    /*      EFTYPE          79              / * Inappropriate file type or
+     * format */
+    gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
+    gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
+
+    /*      EAUTH           80              / * Authentication error */
+    gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
+    gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
+
+    /*      ENEEDAUTH       81              / * Need authenticator */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+    /* Intelligent device errors */
+    /*      EPWROFF         82      / * Device power is off */
+    gf_error_to_errno_array[GF_ERROR_CODE_PWROFF] = EPWROFF;
+    gf_errno_to_error_array[EPWROFF] = GF_ERROR_CODE_PWROFF;
+    /*      EDEVERR         83      / * Device error, e.g. paper out */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEVERR] = EDEVERR;
+    gf_errno_to_error_array[EDEVERR] = GF_ERROR_CODE_DEVERR;
+
+    /*      EOVERFLOW       84              / * Value too large to be stored in
+     * data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
+
+    /* Program loading errors */
+    /*   EBADEXEC   85      / * Bad executable */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADEXEC] = EBADEXEC;
+    gf_errno_to_error_array[EBADEXEC] = GF_ERROR_CODE_BADEXEC;
+
+    /*   EBADARCH   86      / * Bad CPU type in executable */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADARCH] = EBADARCH;
+    gf_errno_to_error_array[EBADARCH] = GF_ERROR_CODE_BADARCH;
+
+    /*   ESHLIBVERS 87      / * Shared library version mismatch */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHLIBVERS] = ESHLIBVERS;
+    gf_errno_to_error_array[ESHLIBVERS] = GF_ERROR_CODE_SHLIBVERS;
+
+    /*   EBADMACHO  88      / * Malformed Macho file */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMACHO] = EBADMACHO;
+    gf_errno_to_error_array[EBADMACHO] = GF_ERROR_CODE_BADMACHO;
 
 #ifdef EDOOFUS
-        /*    EDOOFUS           88              / * Programming error */
-        gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
-        gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
+    /*    EDOOFUS           88              / * Programming error */
+    gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
+    gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
 #endif
 
-        /*      ECANCELED       89              / * Operation canceled */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-        /*   EIDRM              90              / * Identifier removed */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-        /*   ENOMSG             91              / * No message of desired type */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-        /*   EILSEQ             92              / * Illegal byte sequence */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-
-        /*   ENOATTR            93              / * Attribute not found */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
-        gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
-
-        /*   EBADMSG            94              / * Bad message */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
-
-        /*   EMULTIHOP  95              / * Reserved */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-
-        /*      ENODATA         96              / * No message available on STREAM */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-
-        /*   ENOLINK            97              / * Reserved */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
-
-        /*   ENOSR              98              / * No STREAM resources */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
-        gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
-
-        /*   ENOSTR             99              / * Not a STREAM */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
-        gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
-
-/*      EPROTO          100             / * Protocol error */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
-/*   ETIME              101             / * STREAM ioctl timeout */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
-        gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
-
-/* This value is only discrete when compiling __DARWIN_UNIX03, or KERNEL */
-/*      EOPNOTSUPP      102             / * Operation not supported on socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-/*   ENOPOLICY  103             / * No such policy registered */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPOLICY] = ENOPOLICY;
-        gf_errno_to_error_array[ENOPOLICY] = GF_ERROR_CODE_NOPOLICY;
-
-        return ;
+    /*      ECANCELED       89              / * Operation canceled */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
+
+    /*   EIDRM              90              / * Identifier removed */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
+    /*   ENOMSG             91              / * No message of desired type */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
+
+    /*   EILSEQ             92              / * Illegal byte sequence */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
+
+    /*   ENOATTR            93              / * Attribute not found */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
+    gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
+
+    /*   EBADMSG            94              / * Bad message */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+
+    /*   EMULTIHOP  95              / * Reserved */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
+
+    /*      ENODATA         96              / * No message available on STREAM
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+
+    /*   ENOLINK            97              / * Reserved */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+
+    /*   ENOSR              98              / * No STREAM resources */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSR] = ENOSR;
+    gf_errno_to_error_array[ENOSR] = GF_ERROR_CODE_NOSR;
+
+    /*   ENOSTR             99              / * Not a STREAM */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSTR] = ENOSTR;
+    gf_errno_to_error_array[ENOSTR] = GF_ERROR_CODE_NOSTR;
+
+    /*      EPROTO          100             / * Protocol error */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+    /*   ETIME              101             / * STREAM ioctl timeout */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIME] = ETIME;
+    gf_errno_to_error_array[ETIME] = GF_ERROR_CODE_TIME;
+
+    /* This value is only discrete when compiling __DARWIN_UNIX03, or KERNEL */
+    /*      EOPNOTSUPP      102             / * Operation not supported on
+     * socket */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*   ENOPOLICY  103             / * No such policy registered */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPOLICY] = ENOPOLICY;
+    gf_errno_to_error_array[ENOPOLICY] = GF_ERROR_CODE_NOPOLICY;
+
+    return;
 }
 #endif /* GF_DARWIN_HOST_OS */
 
 #ifdef GF_BSD_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /* Quite a bit of things changed in FreeBSD - current */
-
-        /*    EAGAIN          35              / * Try Again */
-        gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
-        gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
-
-        /*    EDEADLK         11              / * Resource deadlock would occur */
-        gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
-        gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
-
-        /*      EINPROGRESS     36              / * Operation now in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
-        gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
-
-        /*      EALREADY        37              / * Operation already in progress */
-        gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
-        gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
-
-        /*      ENOTSOCK        38              / * Socket operation on non-socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
-        gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
-
-        /*      EDESTADDRREQ    39              / * Destination address required */
-        gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
-        gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
-
-        /*      EMSGSIZE        40              / * Message too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
-        gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
-
-        /*      EPROTOTYPE      41              / * Protocol wrong type for socket */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
-        gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
-
-        /*      ENOPROTOOPT     42              / * Protocol not available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
-        gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
-
-        /*      EPROTONOSUPPORT 43              / * Protocol not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
-        gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
-
-        /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
-        gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
-
-        /*      EOPNOTSUPP      45              / * Operation not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
-        gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
-
-        /*      EPFNOSUPPORT    46              / * Protocol family not supported */
-        gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
-        gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
-
-        /*      EAFNOSUPPORT    47              / * Address family not supported by protocol family */
-        gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
-        gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+    /* Quite a bit of things changed in FreeBSD - current */
+
+    /*    EAGAIN          35              / * Try Again */
+    gf_error_to_errno_array[GF_ERROR_CODE_AGAIN] = EAGAIN;
+    gf_errno_to_error_array[EAGAIN] = GF_ERROR_CODE_AGAIN;
+
+    /*    EDEADLK         11              / * Resource deadlock would occur */
+    gf_error_to_errno_array[GF_ERROR_CODE_DEADLK] = EDEADLK;
+    gf_errno_to_error_array[EDEADLK] = GF_ERROR_CODE_DEADLK;
+
+    /*      EINPROGRESS     36              / * Operation now in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_INPROGRESS] = EINPROGRESS;
+    gf_errno_to_error_array[EINPROGRESS] = GF_ERROR_CODE_INPROGRESS;
+
+    /*      EALREADY        37              / * Operation already in progress */
+    gf_error_to_errno_array[GF_ERROR_CODE_ALREADY] = EALREADY;
+    gf_errno_to_error_array[EALREADY] = GF_ERROR_CODE_ALREADY;
+
+    /*      ENOTSOCK        38              / * Socket operation on non-socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTSOCK] = ENOTSOCK;
+    gf_errno_to_error_array[ENOTSOCK] = GF_ERROR_CODE_NOTSOCK;
+
+    /*      EDESTADDRREQ    39              / * Destination address required */
+    gf_error_to_errno_array[GF_ERROR_CODE_DESTADDRREQ] = EDESTADDRREQ;
+    gf_errno_to_error_array[EDESTADDRREQ] = GF_ERROR_CODE_DESTADDRREQ;
+
+    /*      EMSGSIZE        40              / * Message too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_MSGSIZE] = EMSGSIZE;
+    gf_errno_to_error_array[EMSGSIZE] = GF_ERROR_CODE_MSGSIZE;
+
+    /*      EPROTOTYPE      41              / * Protocol wrong type for socket
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTOTYPE] = EPROTOTYPE;
+    gf_errno_to_error_array[EPROTOTYPE] = GF_ERROR_CODE_PROTOTYPE;
+
+    /*      ENOPROTOOPT     42              / * Protocol not available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOPROTOOPT] = ENOPROTOOPT;
+    gf_errno_to_error_array[ENOPROTOOPT] = GF_ERROR_CODE_NOPROTOOPT;
+
+    /*      EPROTONOSUPPORT 43              / * Protocol not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTONOSUPPORT] = EPROTONOSUPPORT;
+    gf_errno_to_error_array[EPROTONOSUPPORT] = GF_ERROR_CODE_PROTONOSUPPORT;
+
+    /*      ESOCKTNOSUPPORT 44              / * Socket type not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_SOCKTNOSUPPORT] = ESOCKTNOSUPPORT;
+    gf_errno_to_error_array[ESOCKTNOSUPPORT] = GF_ERROR_CODE_SOCKTNOSUPPORT;
+
+    /*      EOPNOTSUPP      45              / * Operation not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_OPNOTSUPP] = EOPNOTSUPP;
+    gf_errno_to_error_array[EOPNOTSUPP] = GF_ERROR_CODE_OPNOTSUPP;
+
+    /*      EPFNOSUPPORT    46              / * Protocol family not supported */
+    gf_error_to_errno_array[GF_ERROR_CODE_PFNOSUPPORT] = EPFNOSUPPORT;
+    gf_errno_to_error_array[EPFNOSUPPORT] = GF_ERROR_CODE_PFNOSUPPORT;
+
+    /*      EAFNOSUPPORT    47              / * Address family not supported by
+     * protocol family */
+    gf_error_to_errno_array[GF_ERROR_CODE_AFNOSUPPORT] = EAFNOSUPPORT;
+    gf_errno_to_error_array[EAFNOSUPPORT] = GF_ERROR_CODE_AFNOSUPPORT;
+
+    /*      EADDRINUSE      48              / * Address already in use */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
+    gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+
+    /*      EADDRNOTAVAIL   49              / * Can't assign requested address
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
+    gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+
+    /*      ENETDOWN        50              / * Network is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
+    gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+
+    /*      ENETUNREACH     51              / * Network is unreachable */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
+    gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+
+    /*      ENETRESET       52              / * Network dropped connection on
+     * reset */
+    gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
+    gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+
+    /*      ECONNABORTED    53              / * Software caused connection abort
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
+    gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+
+    /*      ECONNRESET      54              / * Connection reset by peer */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
+    gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
+
+    /*      ENOBUFS         55              / * No buffer space available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
+    gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
+
+    /*      EISCONN         56              / * Socket is already connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
+    gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
+
+    /*      ENOTCONN        57              / * Socket is not connected */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
+    gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
+
+    /*      ESHUTDOWN       58              / * Can't send after socket shutdown
+     */
+    gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
+    gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
+
+    /*      ETOOMANYREFS    59              / * Too many references: can't
+     * splice */
+    gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
+    gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
+
+    /*      ETIMEDOUT       60              / * Operation timed out */
+    gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
+    gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
+
+    /*      ECONNREFUSED    61              / * Connection refused */
+    gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
+    gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
+
+    /*      ELOOP           62              / * Too many levels of symbolic
+     * links */
+    gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
+    gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
+
+    /*      ENAMETOOLONG    63              / * File name too long */
+    gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
+    gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
+
+    /*      EHOSTDOWN       64              / * Host is down */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
+    gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
+
+    /*      EHOSTUNREACH    65              / * No route to host */
+    gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
+    gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
+
+    /*      ENOTEMPTY       66              / * Directory not empty */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
+    gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
+
+    /*      EPROCLIM        67              / * Too many processes */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
+    gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
+
+    /*      EUSERS          68              / * Too many users */
+    gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
+    gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
+
+    /*      EDQUOT          69              / * Disc quota exceeded */
+    gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
+    gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
+
+    /*      ESTALE          70              / * Stale NFS file handle */
+    gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
+    gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
+
+    /*      EREMOTE         71              / * Too many levels of remote in
+     * path */
+    gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
+    gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
+
+    /*      EBADRPC         72              / * RPC struct is bad */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
+    gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
+
+    /*      ERPCMISMATCH    73              / * RPC version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
+    gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
+
+    /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
+    gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
+
+    /*      EPROGMISMATCH   75              / * Program version wrong */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
+    gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
+
+    /*      EPROCUNAVAIL    76              / * Bad procedure for program */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
+    gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
+
+    /*      ENOLCK          77              / * No locks available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
+    gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
 
-        /*      EADDRINUSE      48              / * Address already in use */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRINUSE] = EADDRINUSE;
-        gf_errno_to_error_array[EADDRINUSE] = GF_ERROR_CODE_ADDRINUSE;
+    /*      ENOSYS          78              / * Function not implemented */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
+    gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
 
-        /*      EADDRNOTAVAIL   49              / * Can't assign requested address */
-        gf_error_to_errno_array[GF_ERROR_CODE_ADDRNOTAVAIL] = EADDRNOTAVAIL;
-        gf_errno_to_error_array[EADDRNOTAVAIL] = GF_ERROR_CODE_ADDRNOTAVAIL;
+    /*      EFTYPE          79              / * Inappropriate file type or
+     * format */
+    gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
+    gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
+
+    /*      EAUTH           80              / * Authentication error */
+    gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
+    gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
+
+    /*      ENEEDAUTH       81              / * Need authenticator */
+    gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
+    gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
+
+    /*      EIDRM           82              / * Identifier removed */
+    gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
+    gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
 
-        /*      ENETDOWN        50              / * Network is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETDOWN] = ENETDOWN;
-        gf_errno_to_error_array[ENETDOWN] = GF_ERROR_CODE_NETDOWN;
+    /*      ENOMSG          83              / * No message of desired type */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
+    gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
 
-        /*      ENETUNREACH     51              / * Network is unreachable */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETUNREACH] = ENETUNREACH;
-        gf_errno_to_error_array[ENETUNREACH] = GF_ERROR_CODE_NETUNREACH;
+    /*      EOVERFLOW       84              / * Value too large to be stored in
+     * data type */
+    gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
+    gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
 
-        /*      ENETRESET       52              / * Network dropped connection on reset */
-        gf_error_to_errno_array[GF_ERROR_CODE_NETRESET] = ENETRESET;
-        gf_errno_to_error_array[ENETRESET] = GF_ERROR_CODE_NETRESET;
+    /*      ECANCELED       85              / * Operation canceled */
+    gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
+    gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
 
-        /*      ECONNABORTED    53              / * Software caused connection abort */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNABORTED] = ECONNABORTED;
-        gf_errno_to_error_array[ECONNABORTED] = GF_ERROR_CODE_CONNABORTED;
+    /*      EILSEQ          86              / * Illegal byte sequence */
+    gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
+    gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
 
-        /*      ECONNRESET      54              / * Connection reset by peer */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNRESET] = ECONNRESET;
-        gf_errno_to_error_array[ECONNRESET] = GF_ERROR_CODE_CONNRESET;
-
-        /*      ENOBUFS         55              / * No buffer space available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOBUFS] = ENOBUFS;
-        gf_errno_to_error_array[ENOBUFS] = GF_ERROR_CODE_NOBUFS;
-
-        /*      EISCONN         56              / * Socket is already connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_ISCONN] = EISCONN;
-        gf_errno_to_error_array[EISCONN] = GF_ERROR_CODE_ISCONN;
-
-        /*      ENOTCONN        57              / * Socket is not connected */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTCONN] = ENOTCONN;
-        gf_errno_to_error_array[ENOTCONN] = GF_ERROR_CODE_NOTCONN;
-
-        /*      ESHUTDOWN       58              / * Can't send after socket shutdown */
-        gf_error_to_errno_array[GF_ERROR_CODE_SHUTDOWN] = ESHUTDOWN;
-        gf_errno_to_error_array[ESHUTDOWN] = GF_ERROR_CODE_SHUTDOWN;
-
-        /*      ETOOMANYREFS    59              / * Too many references: can't splice */
-        gf_error_to_errno_array[GF_ERROR_CODE_TOOMANYREFS] = ETOOMANYREFS;
-        gf_errno_to_error_array[ETOOMANYREFS] = GF_ERROR_CODE_TOOMANYREFS;
-
-        /*      ETIMEDOUT       60              / * Operation timed out */
-        gf_error_to_errno_array[GF_ERROR_CODE_TIMEDOUT] = ETIMEDOUT;
-        gf_errno_to_error_array[ETIMEDOUT] = GF_ERROR_CODE_TIMEDOUT;
-
-        /*      ECONNREFUSED    61              / * Connection refused */
-        gf_error_to_errno_array[GF_ERROR_CODE_CONNREFUSED] = ECONNREFUSED;
-        gf_errno_to_error_array[ECONNREFUSED] = GF_ERROR_CODE_CONNREFUSED;
-
-        /*      ELOOP           62              / * Too many levels of symbolic links */
-        gf_error_to_errno_array[GF_ERROR_CODE_LOOP] = ELOOP;
-        gf_errno_to_error_array[ELOOP] = GF_ERROR_CODE_LOOP;
-
-        /*      ENAMETOOLONG    63              / * File name too long */
-        gf_error_to_errno_array[GF_ERROR_CODE_NAMETOOLONG] = ENAMETOOLONG;
-        gf_errno_to_error_array[ENAMETOOLONG] = GF_ERROR_CODE_NAMETOOLONG;
-
-        /*      EHOSTDOWN       64              / * Host is down */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTDOWN] = EHOSTDOWN;
-        gf_errno_to_error_array[EHOSTDOWN] = GF_ERROR_CODE_HOSTDOWN;
-
-        /*      EHOSTUNREACH    65              / * No route to host */
-        gf_error_to_errno_array[GF_ERROR_CODE_HOSTUNREACH] = EHOSTUNREACH;
-        gf_errno_to_error_array[EHOSTUNREACH] = GF_ERROR_CODE_HOSTUNREACH;
-
-        /*      ENOTEMPTY       66              / * Directory not empty */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOTEMPTY] = ENOTEMPTY;
-        gf_errno_to_error_array[ENOTEMPTY] = GF_ERROR_CODE_NOTEMPTY;
-
-        /*      EPROCLIM        67              / * Too many processes */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCLIM] = EPROCLIM;
-        gf_errno_to_error_array[EPROCLIM] = GF_ERROR_CODE_PROCLIM;
-
-        /*      EUSERS          68              / * Too many users */
-        gf_error_to_errno_array[GF_ERROR_CODE_USERS] = EUSERS;
-        gf_errno_to_error_array[EUSERS] = GF_ERROR_CODE_USERS;
-
-        /*      EDQUOT          69              / * Disc quota exceeded */
-        gf_error_to_errno_array[GF_ERROR_CODE_DQUOT] = EDQUOT;
-        gf_errno_to_error_array[EDQUOT] = GF_ERROR_CODE_DQUOT;
-
-        /*      ESTALE          70              / * Stale NFS file handle */
-        gf_error_to_errno_array[GF_ERROR_CODE_STALE] = ESTALE;
-        gf_errno_to_error_array[ESTALE] = GF_ERROR_CODE_STALE;
-
-        /*      EREMOTE         71              / * Too many levels of remote in path */
-        gf_error_to_errno_array[GF_ERROR_CODE_REMOTE] = EREMOTE;
-        gf_errno_to_error_array[EREMOTE] = GF_ERROR_CODE_REMOTE;
-
-        /*      EBADRPC         72              / * RPC struct is bad */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADRPC] = EBADRPC;
-        gf_errno_to_error_array[EBADRPC] = GF_ERROR_CODE_BADRPC;
-
-        /*      ERPCMISMATCH    73              / * RPC version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_RPCMISMATCH] = ERPCMISMATCH;
-        gf_errno_to_error_array[ERPCMISMATCH] = GF_ERROR_CODE_RPCMISMATCH;
-
-        /*      EPROGUNAVAIL    74              / * RPC prog. not avail */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGUNAVAIL] = EPROGUNAVAIL;
-        gf_errno_to_error_array[EPROGUNAVAIL] = GF_ERROR_CODE_PROGUNAVAIL;
-
-        /*      EPROGMISMATCH   75              / * Program version wrong */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROGMISMATCH] = EPROGMISMATCH;
-        gf_errno_to_error_array[EPROGMISMATCH] = GF_ERROR_CODE_PROGMISMATCH;
-
-        /*      EPROCUNAVAIL    76              / * Bad procedure for program */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROCUNAVAIL] = EPROCUNAVAIL;
-        gf_errno_to_error_array[EPROCUNAVAIL] = GF_ERROR_CODE_PROCUNAVAIL;
-
-        /*      ENOLCK          77              / * No locks available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLCK] = ENOLCK;
-        gf_errno_to_error_array[ENOLCK] = GF_ERROR_CODE_NOLCK;
-
-        /*      ENOSYS          78              / * Function not implemented */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOSYS] = ENOSYS;
-        gf_errno_to_error_array[ENOSYS] = GF_ERROR_CODE_NOSYS;
-
-        /*      EFTYPE          79              / * Inappropriate file type or format */
-        gf_error_to_errno_array[GF_ERROR_CODE_FTYPE] = EFTYPE;
-        gf_errno_to_error_array[EFTYPE] = GF_ERROR_CODE_FTYPE;
-
-        /*      EAUTH           80              / * Authentication error */
-        gf_error_to_errno_array[GF_ERROR_CODE_AUTH] = EAUTH;
-        gf_errno_to_error_array[EAUTH] = GF_ERROR_CODE_AUTH;
-
-        /*      ENEEDAUTH       81              / * Need authenticator */
-        gf_error_to_errno_array[GF_ERROR_CODE_NEEDAUTH] = ENEEDAUTH;
-        gf_errno_to_error_array[ENEEDAUTH] = GF_ERROR_CODE_NEEDAUTH;
-
-        /*      EIDRM           82              / * Identifier removed */
-        gf_error_to_errno_array[GF_ERROR_CODE_IDRM] = EIDRM;
-        gf_errno_to_error_array[EIDRM] = GF_ERROR_CODE_IDRM;
-
-        /*      ENOMSG          83              / * No message of desired type */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOMSG] = ENOMSG;
-        gf_errno_to_error_array[ENOMSG] = GF_ERROR_CODE_NOMSG;
-
-        /*      EOVERFLOW       84              / * Value too large to be stored in data type */
-        gf_error_to_errno_array[GF_ERROR_CODE_OVERFLOW] = EOVERFLOW;
-        gf_errno_to_error_array[EOVERFLOW] = GF_ERROR_CODE_OVERFLOW;
-
-        /*      ECANCELED       85              / * Operation canceled */
-        gf_error_to_errno_array[GF_ERROR_CODE_CANCELED] = ECANCELED;
-        gf_errno_to_error_array[ECANCELED] = GF_ERROR_CODE_CANCELED;
-
-        /*      EILSEQ          86              / * Illegal byte sequence */
-        gf_error_to_errno_array[GF_ERROR_CODE_ILSEQ] = EILSEQ;
-        gf_errno_to_error_array[EILSEQ] = GF_ERROR_CODE_ILSEQ;
-
-        /*      ENOATTR         87              / * Attribute not found */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
-        gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
+    /*      ENOATTR         87              / * Attribute not found */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOATTR] = ENOATTR;
+    gf_errno_to_error_array[ENOATTR] = GF_ERROR_CODE_NOATTR;
 
 #ifdef EDOOFUS
-        /*    EDOOFUS           88              / * Programming error */
-        gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
-        gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
+    /*    EDOOFUS           88              / * Programming error */
+    gf_error_to_errno_array[GF_ERROR_CODE_DOOFUS] = EDOOFUS;
+    gf_errno_to_error_array[EDOOFUS] = GF_ERROR_CODE_DOOFUS;
 #endif
 
-        /*      EBADMSG         89              / * Bad message */
-        gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
-        gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
+    /*      EBADMSG         89              / * Bad message */
+    gf_error_to_errno_array[GF_ERROR_CODE_BADMSG] = EBADMSG;
+    gf_errno_to_error_array[EBADMSG] = GF_ERROR_CODE_BADMSG;
 
 #ifdef __NetBSD__
-        /*      ENODATA         89              / * No message available */
-        gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
-        gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
+    /*      ENODATA         89              / * No message available */
+    gf_error_to_errno_array[GF_ERROR_CODE_NODATA] = ENODATA;
+    gf_errno_to_error_array[ENODATA] = GF_ERROR_CODE_NODATA;
 #endif
 
-        /*      EMULTIHOP       90              / * Multihop attempted */
-        gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
-        gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
-
-        /*      ENOLINK         91              / * Link has been severed */
-        gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
-        gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
+    /*      EMULTIHOP       90              / * Multihop attempted */
+    gf_error_to_errno_array[GF_ERROR_CODE_MULTIHOP] = EMULTIHOP;
+    gf_errno_to_error_array[EMULTIHOP] = GF_ERROR_CODE_MULTIHOP;
 
-        /*      EPROTO          92              / * Protocol error */
-        gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
-        gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
+    /*      ENOLINK         91              / * Link has been severed */
+    gf_error_to_errno_array[GF_ERROR_CODE_NOLINK] = ENOLINK;
+    gf_errno_to_error_array[ENOLINK] = GF_ERROR_CODE_NOLINK;
 
+    /*      EPROTO          92              / * Protocol error */
+    gf_error_to_errno_array[GF_ERROR_CODE_PROTO] = EPROTO;
+    gf_errno_to_error_array[EPROTO] = GF_ERROR_CODE_PROTO;
 
-        return ;
+    return;
 }
 #endif /* GF_BSD_HOST_OS */
 
 #ifdef GF_LINUX_HOST_OS
 static void
-init_compat_errno_arrays ()
+init_compat_errno_arrays()
 {
-        /* Things are fine. Everything should work seemlessly on GNU/Linux machines */
-        return ;
+    /* Things are fine. Everything should work seemlessly on GNU/Linux machines
+     */
+    return;
 }
 #endif /* GF_LINUX_HOST_OS */
 
-
 static void
-init_errno_arrays ()
+init_errno_arrays()
 {
-        int i;
-        for (i=0; i < GF_ERROR_CODE_UNKNOWN; i++) {
-                gf_errno_to_error_array[i] = i;
-                gf_error_to_errno_array[i] = i;
-        }
-        /* Now change the order if it needs to be. */
-        init_compat_errno_arrays();
-
-        return;
+    int i;
+    for (i = 0; i < GF_ERROR_CODE_UNKNOWN; i++) {
+        gf_errno_to_error_array[i] = i;
+        gf_error_to_errno_array[i] = i;
+    }
+    /* Now change the order if it needs to be. */
+    init_compat_errno_arrays();
+
+    return;
 }
 
 int32_t
-gf_errno_to_error (int32_t op_errno)
+gf_errno_to_error(int32_t op_errno)
 {
-        if (!gf_compat_errno_init_done) {
-                init_errno_arrays ();
-                gf_compat_errno_init_done = 1;
-        }
+    if (!gf_compat_errno_init_done) {
+        init_errno_arrays();
+        gf_compat_errno_init_done = 1;
+    }
 
-        if ((op_errno > GF_ERROR_CODE_SUCCESS) && (op_errno < GF_ERROR_CODE_UNKNOWN))
-                return gf_errno_to_error_array[op_errno];
+    if ((op_errno > GF_ERROR_CODE_SUCCESS) &&
+        (op_errno < GF_ERROR_CODE_UNKNOWN))
+        return gf_errno_to_error_array[op_errno];
 
-        return op_errno;
+    return op_errno;
 }
 
-
 int32_t
-gf_error_to_errno (int32_t error)
+gf_error_to_errno(int32_t error)
 {
-        if (!gf_compat_errno_init_done) {
-                init_errno_arrays ();
-                gf_compat_errno_init_done = 1;
-        }
+    if (!gf_compat_errno_init_done) {
+        init_errno_arrays();
+        gf_compat_errno_init_done = 1;
+    }
 
-        if ((error > GF_ERROR_CODE_SUCCESS) && (error < GF_ERROR_CODE_UNKNOWN))
-                return gf_error_to_errno_array[error];
+    if ((error > GF_ERROR_CODE_SUCCESS) && (error < GF_ERROR_CODE_UNKNOWN))
+        return gf_error_to_errno_array[error];
 
-        return error;
+    return error;
 }
diff --git a/libglusterfs/src/compat.c b/libglusterfs/src/compat.c
index a27fe20ce64..137bdf45cab 100644
--- a/libglusterfs/src/compat.c
+++ b/libglusterfs/src/compat.c
@@ -30,507 +30,521 @@
 
 #ifdef GF_SOLARIS_HOST_OS
 int
-solaris_fsetxattr(int fd, const char* key, const char *value, size_t size,
+solaris_fsetxattr(int fd, const char *key, const char *value, size_t size,
                   int flags)
 {
-        int attrfd = -1;
-        int ret = 0;
-
-        attrfd = openat (fd, key, flags|O_CREAT|O_WRONLY|O_XATTR, 0777);
-        if (attrfd >= 0) {
-                ftruncate (attrfd, 0);
-                ret = write (attrfd, value, size);
-                close (attrfd);
-        } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_ERROR, errno,
-                                LG_MSG_SET_ATTRIBUTE_FAILED, "Couldn't set "
-                                "extended attribute for %d", fd);
-                return -1;
-        }
-
-        return 0;
+    int attrfd = -1;
+    int ret = 0;
+
+    attrfd = openat(fd, key, flags | O_CREAT | O_WRONLY | O_XATTR, 0777);
+    if (attrfd >= 0) {
+        ftruncate(attrfd, 0);
+        ret = write(attrfd, value, size);
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_ERROR, errno,
+                   LG_MSG_SET_ATTRIBUTE_FAILED,
+                   "Couldn't set "
+                   "extended attribute for %d",
+                   fd);
+        return -1;
+    }
+
+    return 0;
 }
 
-
 int
-solaris_fgetxattr(int fd, const char* key, char *value, size_t size)
+solaris_fgetxattr(int fd, const char *key, char *value, size_t size)
 {
-        int attrfd = -1;
-        int ret = 0;
-
-        attrfd = openat (fd, key, O_RDONLY|O_XATTR);
-        if (attrfd >= 0) {
-                if (size == 0) {
-                        struct stat buf;
-                        fstat (attrfd, &buf);
-                        ret = buf.st_size;
-                } else {
-                        ret = read (attrfd, value, size);
-                }
-                close (attrfd);
+    int attrfd = -1;
+    int ret = 0;
+
+    attrfd = openat(fd, key, O_RDONLY | O_XATTR);
+    if (attrfd >= 0) {
+        if (size == 0) {
+            struct stat buf;
+            fstat(attrfd, &buf);
+            ret = buf.st_size;
         } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_INFO, errno,
-                                LG_MSG_READ_ATTRIBUTE_FAILED, "Couldn't read "
-                                "extended attribute for the file %d", fd);
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                return -1;
+            ret = read(attrfd, value, size);
         }
-
-        return ret;
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_INFO, errno,
+                   LG_MSG_READ_ATTRIBUTE_FAILED,
+                   "Couldn't read "
+                   "extended attribute for the file %d",
+                   fd);
+        if (errno == ENOENT)
+            errno = ENODATA;
+        return -1;
+    }
+
+    return ret;
 }
 
 /* Solaris does not support xattr for symlinks and dev files. Since gfid and
    other trusted attributes are stored as xattrs, we need to provide support for
-   them. A mapped regular file is stored in the /.glusterfs_xattr_inode of the export dir.
-   All xattr ops related to the special files are redirected to this map file.
+   them. A mapped regular file is stored in the /.glusterfs_xattr_inode of the
+   export dir. All xattr ops related to the special files are redirected to this
+   map file.
 */
 
 int
-make_export_path (const char *real_path, char **path)
+make_export_path(const char *real_path, char **path)
 {
-        int     ret = -1;
-        char   *tmp = NULL;
-        char   *export_path = NULL;
-        char   *dup = NULL;
-        char   *ptr = NULL;
-        char   *freeptr = NULL;
-        uuid_t  gfid = {0, };
-
-        export_path = GF_CALLOC (1, sizeof (char) * PATH_MAX, 0);
-        if (!export_path)
-                goto out;
+    int ret = -1;
+    char *tmp = NULL;
+    char *export_path = NULL;
+    char *dup = NULL;
+    char *ptr = NULL;
+    char *freeptr = NULL;
+    uuid_t gfid = {
+        0,
+    };
+
+    export_path = GF_CALLOC(1, sizeof(char) * PATH_MAX, 0);
+    if (!export_path)
+        goto out;
 
-        dup = gf_strdup (real_path);
-        if (!dup)
-                goto out;
+    dup = gf_strdup(real_path);
+    if (!dup)
+        goto out;
 
-        freeptr = dup;
-        ret = solaris_getxattr ("/", GFID_XATTR_KEY, gfid, 16);
-        /* Return value of getxattr */
+    freeptr = dup;
+    ret = solaris_getxattr("/", GFID_XATTR_KEY, gfid, 16);
+    /* Return value of getxattr */
+    if (ret == 16) {
+        if (__is_root_gfid(gfid)) {
+            strcat(export_path, "/");
+            ret = 0;
+            goto done;
+        }
+    }
+
+    do {
+        ptr = strtok_r(dup, "/", &tmp);
+        if (!ptr)
+            break;
+        strcat(export_path, dup);
+        ret = solaris_getxattr(export_path, GFID_XATTR_KEY, gfid, 16);
         if (ret == 16) {
-                if (__is_root_gfid (gfid)){
-                        strcat (export_path, "/");
-                        ret = 0;
-                        goto done;
-                }
+            if (__is_root_gfid(gfid)) {
+                ret = 0;
+                goto done;
+            }
         }
+        strcat(export_path, "/");
+        dup = tmp;
+    } while (ptr);
 
-        do {
-                ptr = strtok_r (dup, "/", &tmp);
-                if (!ptr)
-                        break;
-                strcat (export_path, dup);
-                ret = solaris_getxattr (export_path, GFID_XATTR_KEY, gfid, 16);
-                if (ret == 16) {
-                        if (__is_root_gfid (gfid)) {
-                                ret = 0;
-                                goto done;
-                        }
-                }
-                strcat (export_path, "/");
-                dup = tmp;
-        } while (ptr);
-
-        goto out;
+    goto out;
 
 done:
-        if (!ret) {
-                *path = export_path;
-        }
+    if (!ret) {
+        *path = export_path;
+    }
 out:
-        GF_FREE (freeptr);
-        if (ret && export_path)
-                GF_FREE (export_path);
+    GF_FREE(freeptr);
+    if (ret && export_path)
+        GF_FREE(export_path);
 
-        return ret;
+    return ret;
 }
 int
-solaris_xattr_resolve_path (const char *real_path, char **path)
+solaris_xattr_resolve_path(const char *real_path, char **path)
 {
-        int                    ret  = -1;
-        char                   *export_path = NULL;
-        char                   xattr_path[PATH_MAX] = {0, };
-        struct stat            lstatbuf = {0, };
-        struct iatt            stbuf = {0, };
-        struct stat            statbuf = {0, };
-
-        ret = lstat (real_path, &lstatbuf);
-        if (ret != 0 )
-                return ret;
-        iatt_from_stat (&stbuf, &lstatbuf);
-        if (IA_ISREG(stbuf.ia_type) || IA_ISDIR(stbuf.ia_type))
-                return -1;
-
-        ret = make_export_path (real_path, &export_path);
-        if (!ret && export_path) {
-                strcat (export_path, "/"GF_SOLARIS_XATTR_DIR);
-                if (lstat (export_path, &statbuf)) {
-                        ret = mkdir (export_path, 0777);
-                        if (ret && (errno != EEXIST)) {
-                                gf_msg_debug (THIS->name, 0, "mkdir failed,"
-                                        " errno: %d", errno);
-                                goto out;
-                        }
-                }
+    int ret = -1;
+    char *export_path = NULL;
+    char xattr_path[PATH_MAX] = {
+        0,
+    };
+    struct stat lstatbuf = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    struct stat statbuf = {
+        0,
+    };
+
+    ret = lstat(real_path, &lstatbuf);
+    if (ret != 0)
+        return ret;
+    iatt_from_stat(&stbuf, &lstatbuf);
+    if (IA_ISREG(stbuf.ia_type) || IA_ISDIR(stbuf.ia_type))
+        return -1;
+
+    ret = make_export_path(real_path, &export_path);
+    if (!ret && export_path) {
+        strcat(export_path, "/" GF_SOLARIS_XATTR_DIR);
+        if (lstat(export_path, &statbuf)) {
+            ret = mkdir(export_path, 0777);
+            if (ret && (errno != EEXIST)) {
+                gf_msg_debug(THIS->name, 0,
+                             "mkdir failed,"
+                             " errno: %d",
+                             errno);
+                goto out;
+            }
+        }
 
-                snprintf(xattr_path, PATH_MAX, "%s%s%lu", export_path,
-                         "/", stbuf.ia_ino);
+        snprintf(xattr_path, PATH_MAX, "%s%s%lu", export_path, "/",
+                 stbuf.ia_ino);
 
-                ret = lstat (xattr_path, &statbuf);
+        ret = lstat(xattr_path, &statbuf);
 
-                if (ret) {
-                        ret = mknod (xattr_path, S_IFREG|O_WRONLY, 0);
-                        if (ret && (errno != EEXIST)) {
-                                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                        LG_MSG_FILE_OP_FAILED, "Failed to "
-                                        "create mapped file %s", xattr_path);
-                                goto out;
-                        }
-                }
-                *path = gf_strdup (xattr_path);
+        if (ret) {
+            ret = mknod(xattr_path, S_IFREG | O_WRONLY, 0);
+            if (ret && (errno != EEXIST)) {
+                gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                       "Failed to "
+                       "create mapped file %s",
+                       xattr_path);
+                goto out;
+            }
         }
+        *path = gf_strdup(xattr_path);
+    }
 out:
-        GF_FREE (export_path);
-        if (*path)
-                return 0;
-        else
-                return -1;
+    GF_FREE(export_path);
+    if (*path)
+        return 0;
+    else
+        return -1;
 }
 
 int
-solaris_setxattr(const char *path, const char* key, const char *value,
+solaris_setxattr(const char *path, const char *key, const char *value,
                  size_t size, int flags)
 {
-        int attrfd = -1;
-        int ret = 0;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path,  key, flags|O_CREAT|O_WRONLY,
-                                   0777);
-        } else {
-                attrfd = attropen (path, key, flags|O_CREAT|O_WRONLY, 0777);
-        }
-        if (attrfd >= 0) {
-                ftruncate (attrfd, 0);
-                ret = write (attrfd, value, size);
-                close (attrfd);
-                ret = 0;
-        } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_ERROR, errno,
-                                LG_MSG_SET_ATTRIBUTE_FAILED, "Couldn't set "
-                                "extended attribute for %s", path);
-                ret = -1;
-        }
-        GF_FREE (mapped_path);
-        return ret;
+    int attrfd = -1;
+    int ret = 0;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, key, flags | O_CREAT | O_WRONLY, 0777);
+    } else {
+        attrfd = attropen(path, key, flags | O_CREAT | O_WRONLY, 0777);
+    }
+    if (attrfd >= 0) {
+        ftruncate(attrfd, 0);
+        ret = write(attrfd, value, size);
+        close(attrfd);
+        ret = 0;
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_ERROR, errno,
+                   LG_MSG_SET_ATTRIBUTE_FAILED,
+                   "Couldn't set "
+                   "extended attribute for %s",
+                   path);
+        ret = -1;
+    }
+    GF_FREE(mapped_path);
+    return ret;
 }
 
-
 int
 solaris_listxattr(const char *path, char *list, size_t size)
 {
-        int attrdirfd = -1;
-        ssize_t len = 0;
-        DIR *dirptr = NULL;
-        struct dirent *dent = NULL;
-        int newfd = -1;
-        char *mapped_path = NULL;
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrdirfd = attropen (mapped_path, ".", O_RDONLY, 0);
-        } else {
-                attrdirfd = attropen (path, ".", O_RDONLY, 0);
-        }
-        if (attrdirfd >= 0) {
-                newfd = dup(attrdirfd);
-                dirptr = fdopendir(newfd);
-                if (dirptr) {
-                        while ((dent = readdir(dirptr))) {
-                                size_t listlen = strlen(dent->d_name);
-                                if (!strcmp(dent->d_name, ".") ||
-                                    !strcmp(dent->d_name, "..")) {
-                                        /* we don't want "." and ".." here */
-                                        continue;
-                                }
-                                if (size == 0) {
-                                        /* return the current size of the list
-                                           of extended attribute names*/
-                                        len += listlen + 1;
-                                } else {
-                                        /* check size and copy entry + null
-                                           into list. */
-                                        if ((len + listlen + 1) > size) {
-                                                errno = ERANGE;
-                                                len = -1;
-                                                break;
-                                        } else {
-                                                strncpy(list + len, dent->d_name, listlen);
-                                                len += listlen;
-                                                list[len] = '\0';
-                                                ++len;
-                                        }
-                                }
-                        }
-
-                        if (closedir(dirptr) == -1) {
-                                close (attrdirfd);
-                                len = -1;
-                                goto out;
-                        }
+    int attrdirfd = -1;
+    ssize_t len = 0;
+    DIR *dirptr = NULL;
+    struct dirent *dent = NULL;
+    int newfd = -1;
+    char *mapped_path = NULL;
+    int ret = -1;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrdirfd = attropen(mapped_path, ".", O_RDONLY, 0);
+    } else {
+        attrdirfd = attropen(path, ".", O_RDONLY, 0);
+    }
+    if (attrdirfd >= 0) {
+        newfd = dup(attrdirfd);
+        dirptr = fdopendir(newfd);
+        if (dirptr) {
+            while ((dent = readdir(dirptr))) {
+                size_t listlen = strlen(dent->d_name);
+                if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) {
+                    /* we don't want "." and ".." here */
+                    continue;
+                }
+                if (size == 0) {
+                    /* return the current size of the list
+                       of extended attribute names*/
+                    len += listlen + 1;
                 } else {
-                        close (attrdirfd);
+                    /* check size and copy entry + null
+                       into list. */
+                    if ((len + listlen + 1) > size) {
+                        errno = ERANGE;
                         len = -1;
-                        goto out;
+                        break;
+                    } else {
+                        strncpy(list + len, dent->d_name, listlen);
+                        len += listlen;
+                        list[len] = '\0';
+                        ++len;
+                    }
                 }
-                close (attrdirfd);
+            }
+
+            if (closedir(dirptr) == -1) {
+                close(attrdirfd);
+                len = -1;
+                goto out;
+            }
+        } else {
+            close(attrdirfd);
+            len = -1;
+            goto out;
         }
+        close(attrdirfd);
+    }
 out:
-        GF_FREE (mapped_path);
-        return len;
+    GF_FREE(mapped_path);
+    return len;
 }
 
-
 int
 solaris_flistxattr(int fd, char *list, size_t size)
 {
-        int attrdirfd = -1;
-        ssize_t len = 0;
-        DIR *dirptr = NULL;
-        struct dirent *dent = NULL;
-        int newfd = -1;
-
-        attrdirfd = openat (fd, ".", O_RDONLY, 0);
-        if (attrdirfd >= 0) {
-                newfd = dup(attrdirfd);
-                dirptr = fdopendir(newfd);
-                if (dirptr) {
-                        while ((dent = readdir(dirptr))) {
-                                size_t listlen = strlen(dent->d_name);
-                                if (!strcmp(dent->d_name, ".") ||
-                                    !strcmp(dent->d_name, "..")) {
-                                        /* we don't want "." and ".." here */
-                                        continue;
-                                }
-                                if (size == 0) {
-                                        /* return the current size of the list
-                                           of extended attribute names*/
-                                        len += listlen + 1;
-                                } else {
-                                        /* check size and copy entry + null
-                                           into list. */
-                                        if ((len + listlen + 1) > size) {
-                                                errno = ERANGE;
-                                                len = -1;
-                                                break;
-                                        } else {
-                                                strncpy(list + len, dent->d_name, listlen);
-                                                len += listlen;
-                                                list[len] = '\0';
-                                                ++len;
-                                        }
-                                }
-                        }
-
-                        if (closedir(dirptr) == -1) {
-                                close (attrdirfd);
-                                return -1;
-                        }
+    int attrdirfd = -1;
+    ssize_t len = 0;
+    DIR *dirptr = NULL;
+    struct dirent *dent = NULL;
+    int newfd = -1;
+
+    attrdirfd = openat(fd, ".", O_RDONLY, 0);
+    if (attrdirfd >= 0) {
+        newfd = dup(attrdirfd);
+        dirptr = fdopendir(newfd);
+        if (dirptr) {
+            while ((dent = readdir(dirptr))) {
+                size_t listlen = strlen(dent->d_name);
+                if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) {
+                    /* we don't want "." and ".." here */
+                    continue;
+                }
+                if (size == 0) {
+                    /* return the current size of the list
+                       of extended attribute names*/
+                    len += listlen + 1;
                 } else {
-                        close (attrdirfd);
-                        return -1;
+                    /* check size and copy entry + null
+                       into list. */
+                    if ((len + listlen + 1) > size) {
+                        errno = ERANGE;
+                        len = -1;
+                        break;
+                    } else {
+                        strncpy(list + len, dent->d_name, listlen);
+                        len += listlen;
+                        list[len] = '\0';
+                        ++len;
+                    }
                 }
-                close (attrdirfd);
+            }
+
+            if (closedir(dirptr) == -1) {
+                close(attrdirfd);
+                return -1;
+            }
+        } else {
+            close(attrdirfd);
+            return -1;
         }
-        return len;
+        close(attrdirfd);
+    }
+    return len;
 }
 
-
 int
-solaris_removexattr(const char *path, const char* key)
+solaris_removexattr(const char *path, const char *key)
 {
-        int ret = -1;
-        int attrfd = -1;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path, ".", O_RDONLY, 0);
-        } else {
-                attrfd = attropen (path, ".", O_RDONLY, 0);
-        }
-        if (attrfd >= 0) {
-                ret = unlinkat (attrfd, key, 0);
-                close (attrfd);
-        } else {
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                ret = -1;
-        }
-
-        GF_FREE (mapped_path);
-
-        return ret;
+    int ret = -1;
+    int attrfd = -1;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, ".", O_RDONLY, 0);
+    } else {
+        attrfd = attropen(path, ".", O_RDONLY, 0);
+    }
+    if (attrfd >= 0) {
+        ret = unlinkat(attrfd, key, 0);
+        close(attrfd);
+    } else {
+        if (errno == ENOENT)
+            errno = ENODATA;
+        ret = -1;
+    }
+
+    GF_FREE(mapped_path);
+
+    return ret;
 }
 
 int
-solaris_getxattr(const char *path,
-                 const char* key,
-                 char *value,
-                 size_t size)
+solaris_getxattr(const char *path, const char *key, char *value, size_t size)
 {
-        int attrfd = -1;
-        int ret = 0;
-        char *mapped_path = NULL;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-        if (!ret) {
-                attrfd = attropen (mapped_path, key, O_RDONLY, 0);
-        } else {
-                attrfd = attropen (path, key, O_RDONLY, 0);
-        }
-
-        if (attrfd >= 0) {
-                if (size == 0) {
-                        struct stat buf;
-                        fstat (attrfd, &buf);
-                        ret = buf.st_size;
-                } else {
-                        ret = read (attrfd, value, size);
-                }
-                close (attrfd);
+    int attrfd = -1;
+    int ret = 0;
+    char *mapped_path = NULL;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+    if (!ret) {
+        attrfd = attropen(mapped_path, key, O_RDONLY, 0);
+    } else {
+        attrfd = attropen(path, key, O_RDONLY, 0);
+    }
+
+    if (attrfd >= 0) {
+        if (size == 0) {
+            struct stat buf;
+            fstat(attrfd, &buf);
+            ret = buf.st_size;
         } else {
-                if (errno != ENOENT)
-                        gf_msg ("libglusterfs", GF_LOG_INFO, errno,
-                                LG_MSG_READ_ATTRIBUTE_FAILED, "Couldn't read "
-                                "extended attribute for the file %s", path);
-                if (errno == ENOENT)
-                        errno = ENODATA;
-                ret = -1;
+            ret = read(attrfd, value, size);
         }
-        GF_FREE (mapped_path);
-        return ret;
+        close(attrfd);
+    } else {
+        if (errno != ENOENT)
+            gf_msg("libglusterfs", GF_LOG_INFO, errno,
+                   LG_MSG_READ_ATTRIBUTE_FAILED,
+                   "Couldn't read "
+                   "extended attribute for the file %s",
+                   path);
+        if (errno == ENOENT)
+            errno = ENODATA;
+        ret = -1;
+    }
+    GF_FREE(mapped_path);
+    return ret;
 }
 
-
-char* strsep(char** str, const char* delims)
+char *
+strsep(char **str, const char *delims)
 {
-        char* token;
-
-        if (*str==NULL) {
-                /* No more tokens */
-                return NULL;
-        }
-
-        token=*str;
-        while (**str!='\0') {
-                if (strchr(delims,**str)!=NULL) {
-                        **str='\0';
-                        (*str)++;
-                        return token;
-                }
-                (*str)++;
+    char *token;
+
+    if (*str == NULL) {
+        /* No more tokens */
+        return NULL;
+    }
+
+    token = *str;
+    while (**str != '\0') {
+        if (strchr(delims, **str) != NULL) {
+            **str = '\0';
+            (*str)++;
+            return token;
         }
-        /* There is no other token */
-        *str=NULL;
-        return token;
+        (*str)++;
+    }
+    /* There is no other token */
+    *str = NULL;
+    return token;
 }
 
 /* Code comes from libiberty */
 
 int
-vasprintf (char **result, const char *format, va_list args)
+vasprintf(char **result, const char *format, va_list args)
 {
-        return gf_vasprintf(result, format, args);
+    return gf_vasprintf(result, format, args);
 }
 
 int
-asprintf (char **buf, const char *fmt, ...)
+asprintf(char **buf, const char *fmt, ...)
 {
-        int status;
-        va_list ap;
+    int status;
+    va_list ap;
 
-        va_start (ap, fmt);
-        status = vasprintf (buf, fmt, ap);
-        va_end (ap);
-        return status;
+    va_start(ap, fmt);
+    status = vasprintf(buf, fmt, ap);
+    va_end(ap);
+    return status;
 }
 
-int solaris_unlink (const char *path)
+int
+solaris_unlink(const char *path)
 {
-        char *mapped_path = NULL;
-        struct stat     stbuf = {0, };
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (path, &mapped_path);
-
-
-        if (!ret && mapped_path) {
-                if (lstat(path, &stbuf)) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                LG_MSG_FILE_OP_FAILED, "Stat failed on "
-                                "mapped file %s", mapped_path);
-                        goto out;
-                }
-                if (stbuf.st_nlink == 1) {
-                        if(remove (mapped_path))
-                                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                        LG_MSG_FILE_OP_FAILED, "Failed to "
-                                        "remove mapped file %s", mapped_path);
-                }
-
+    char *mapped_path = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    int ret = -1;
+
+    ret = solaris_xattr_resolve_path(path, &mapped_path);
+
+    if (!ret && mapped_path) {
+        if (lstat(path, &stbuf)) {
+            gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                   "Stat failed on "
+                   "mapped file %s",
+                   mapped_path);
+            goto out;
+        }
+        if (stbuf.st_nlink == 1) {
+            if (remove(mapped_path))
+                gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                       "Failed to "
+                       "remove mapped file %s",
+                       mapped_path);
         }
+    }
 
 out:
-        GF_FREE (mapped_path);
+    GF_FREE(mapped_path);
 
-        return  unlink (path);
+    return unlink(path);
 }
 
 int
-solaris_rename (const char *old_path, const char *new_path)
+solaris_rename(const char *old_path, const char *new_path)
 {
-        char *mapped_path = NULL;
-        int ret = -1;
-
-        ret = solaris_xattr_resolve_path (new_path, &mapped_path);
+    char *mapped_path = NULL;
+    int ret = -1;
 
+    ret = solaris_xattr_resolve_path(new_path, &mapped_path);
 
-        if (!ret && mapped_path) {
-                if (!remove (mapped_path))
-                        gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                                LG_MSG_FILE_OP_FAILED, "Failed to remove "
-                                "mapped file %s.", mapped_path);
-                GF_FREE (mapped_path);
-        }
-
-        return rename(old_path, new_path);
+    if (!ret && mapped_path) {
+        if (!remove(mapped_path))
+            gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                   "Failed to remove "
+                   "mapped file %s.",
+                   mapped_path);
+        GF_FREE(mapped_path);
+    }
 
+    return rename(old_path, new_path);
 }
 
 char *
-mkdtemp (char *tempstring)
+mkdtemp(char *tempstring)
 {
-        char *new_string = NULL;
-        int   ret        = 0;
+    char *new_string = NULL;
+    int ret = 0;
 
-        new_string = mkstemp (tempstring);
-        if (!new_string)
-                goto out;
+    new_string = mkstemp(tempstring);
+    if (!new_string)
+        goto out;
 
-        ret = mkdir (new_string, 0700);
-        if (ret < 0)
-                new_string = NULL;
+    ret = mkdir(new_string, 0700);
+    if (ret < 0)
+        new_string = NULL;
 
 out:
-        return new_string;
+    return new_string;
 }
 
 #endif /* GF_SOLARIS_HOST_OS */
@@ -539,27 +553,27 @@ out:
 void
 gf_extattr_list_reshape(char *bsd_list, ssize_t size)
 {
-        /*
-         * the format of bsd_list is
-         *     <attr_len>attr<attr_len>attr...
-         * we try to reformat it as Linux's
-         *     attr<\0>attr<\0>...
-         * */
-        if (NULL == bsd_list || size <= 0)
-                return;
-
-        size_t i = 0, j;
-
-        while (i < size) {
-                size_t attr_len = bsd_list[i];
-
-                for (j = i; j < i+attr_len; ++j)
-                        bsd_list[j] = bsd_list[j+1];
-                bsd_list[j] = '\0';
-
-                i += attr_len + 1;
-                gf_msg_debug ("syscall", 0, "syscall debug: %lu", attr_len);
-        }
+    /*
+     * the format of bsd_list is
+     *     <attr_len>attr<attr_len>attr...
+     * we try to reformat it as Linux's
+     *     attr<\0>attr<\0>...
+     * */
+    if (NULL == bsd_list || size <= 0)
+        return;
+
+    size_t i = 0, j;
+
+    while (i < size) {
+        size_t attr_len = bsd_list[i];
+
+        for (j = i; j < i + attr_len; ++j)
+            bsd_list[j] = bsd_list[j + 1];
+        bsd_list[j] = '\0';
+
+        i += attr_len + 1;
+        gf_msg_debug("syscall", 0, "syscall debug: %lu", attr_len);
+    }
 }
 #endif /* GF_BSD_HOST_OS */
 
@@ -567,44 +581,44 @@ gf_extattr_list_reshape(char *bsd_list, ssize_t size)
 size_t
 strnlen(const char *string, size_t maxlen)
 {
-        int len = 0;
-        while ((len < maxlen) && string[len])
-                len++;
-        return len;
+    int len = 0;
+    while ((len < maxlen) && string[len])
+        len++;
+    return len;
 }
 #endif /* STRNLEN */
 
 int
-gf_umount_lazy (char *xlname, char *path, int rmdir_flag)
+gf_umount_lazy(char *xlname, char *path, int rmdir_flag)
 {
-        int                   ret               = -1;
-        runner_t              runner            = {0,};
+    int ret = -1;
+    runner_t runner = {
+        0,
+    };
 
-        runinit (&runner);
+    runinit(&runner);
 #ifdef GF_LINUX_HOST_OS
-        runner_add_args (&runner, _PATH_UMOUNT, "-l", path, NULL);
+    runner_add_args(&runner, _PATH_UMOUNT, "-l", path, NULL);
 #else
-        if (rmdir_flag)
-                runner_add_args (&runner, SBIN_DIR "/umountd",
-                                 "-r", path, NULL);
-        else
-                runner_add_args (&runner, SBIN_DIR "/umountd",
-                                 path, NULL);
+    if (rmdir_flag)
+        runner_add_args(&runner, SBIN_DIR "/umountd", "-r", path, NULL);
+    else
+        runner_add_args(&runner, SBIN_DIR "/umountd", path, NULL);
 #endif
-        ret = runner_run (&runner);
-        if (ret) {
-                gf_msg (xlname, GF_LOG_ERROR, errno, LG_MSG_UNMOUNT_FAILED,
-                        "Lazy unmount of %s", path);
-        }
+    ret = runner_run(&runner);
+    if (ret) {
+        gf_msg(xlname, GF_LOG_ERROR, errno, LG_MSG_UNMOUNT_FAILED,
+               "Lazy unmount of %s", path);
+    }
 
 #ifdef GF_LINUX_HOST_OS
-        if (!ret && rmdir_flag) {
-                ret = sys_rmdir (path);
-                if (ret)
-                        gf_msg (xlname, GF_LOG_WARNING, errno,
-                                LG_MSG_DIR_OP_FAILED, "rmdir %s", path);
-        }
+    if (!ret && rmdir_flag) {
+        ret = sys_rmdir(path);
+        if (ret)
+            gf_msg(xlname, GF_LOG_WARNING, errno, LG_MSG_DIR_OP_FAILED,
+                   "rmdir %s", path);
+    }
 #endif
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/compound-fop-utils.c b/libglusterfs/src/compound-fop-utils.c
index 03d7b5ba459..8bdb8e8fd5b 100644
--- a/libglusterfs/src/compound-fop-utils.c
+++ b/libglusterfs/src/compound-fop-utils.c
@@ -14,125 +14,125 @@
 #include "dict.h"
 
 void
-compound_args_cleanup (compound_args_t *args)
+compound_args_cleanup(compound_args_t *args)
 {
-        int i;
+    int i;
 
-        if (!args)
-                return;
+    if (!args)
+        return;
 
-        if (args->xdata)
-                dict_unref (args->xdata);
+    if (args->xdata)
+        dict_unref(args->xdata);
 
-        if (args->req_list) {
-                for (i = 0; i < args->fop_length; i++) {
-                        args_wipe (&args->req_list[i]);
-                }
+    if (args->req_list) {
+        for (i = 0; i < args->fop_length; i++) {
+            args_wipe(&args->req_list[i]);
         }
+    }
 
-        GF_FREE (args->enum_list);
-        GF_FREE (args->req_list);
-        GF_FREE (args);
+    GF_FREE(args->enum_list);
+    GF_FREE(args->req_list);
+    GF_FREE(args);
 }
 
 void
-compound_args_cbk_cleanup (compound_args_cbk_t *args_cbk)
+compound_args_cbk_cleanup(compound_args_cbk_t *args_cbk)
 {
-        int i;
+    int i;
 
-        if (!args_cbk)
-                return;
+    if (!args_cbk)
+        return;
 
-        if (args_cbk->xdata)
-                dict_unref (args_cbk->xdata);
+    if (args_cbk->xdata)
+        dict_unref(args_cbk->xdata);
 
-        if (args_cbk->rsp_list) {
-                for (i = 0; i < args_cbk->fop_length; i++) {
-                        args_cbk_wipe (&args_cbk->rsp_list[i]);
-                }
+    if (args_cbk->rsp_list) {
+        for (i = 0; i < args_cbk->fop_length; i++) {
+            args_cbk_wipe(&args_cbk->rsp_list[i]);
         }
+    }
 
-        GF_FREE (args_cbk->rsp_list);
-        GF_FREE (args_cbk->enum_list);
-        GF_FREE (args_cbk);
+    GF_FREE(args_cbk->rsp_list);
+    GF_FREE(args_cbk->enum_list);
+    GF_FREE(args_cbk);
 }
 
-compound_args_cbk_t*
-compound_args_cbk_alloc (int length, dict_t *xdata)
+compound_args_cbk_t *
+compound_args_cbk_alloc(int length, dict_t *xdata)
 {
-        int                 i             = 0;
-        compound_args_cbk_t *args_cbk     = NULL;
+    int i = 0;
+    compound_args_cbk_t *args_cbk = NULL;
 
-        args_cbk = GF_CALLOC (1, sizeof (*args_cbk), gf_mt_compound_rsp_t);
-        if (!args_cbk)
-                return NULL;
+    args_cbk = GF_CALLOC(1, sizeof(*args_cbk), gf_mt_compound_rsp_t);
+    if (!args_cbk)
+        return NULL;
 
-        args_cbk->fop_length = length;
+    args_cbk->fop_length = length;
 
-        args_cbk->rsp_list = GF_CALLOC (length, sizeof (*args_cbk->rsp_list),
-                                        gf_mt_default_args_cbk_t);
-        if (!args_cbk->rsp_list)
-                goto out;
+    args_cbk->rsp_list = GF_CALLOC(length, sizeof(*args_cbk->rsp_list),
+                                   gf_mt_default_args_cbk_t);
+    if (!args_cbk->rsp_list)
+        goto out;
 
-        for (i = 0; i < length; i++) {
-                args_cbk_init (&args_cbk->rsp_list[i]);
-        }
+    for (i = 0; i < length; i++) {
+        args_cbk_init(&args_cbk->rsp_list[i]);
+    }
 
-        args_cbk->enum_list = GF_CALLOC (length, sizeof (*args_cbk->enum_list),
-                                        gf_common_mt_int);
-        if (!args_cbk->enum_list)
-                goto out;
+    args_cbk->enum_list = GF_CALLOC(length, sizeof(*args_cbk->enum_list),
+                                    gf_common_mt_int);
+    if (!args_cbk->enum_list)
+        goto out;
 
-        if (xdata) {
-                args_cbk->xdata = dict_copy_with_ref (xdata, NULL);
-                if (!args_cbk->xdata)
-                        goto out;
-        }
+    if (xdata) {
+        args_cbk->xdata = dict_copy_with_ref(xdata, NULL);
+        if (!args_cbk->xdata)
+            goto out;
+    }
 
-        return args_cbk;
+    return args_cbk;
 out:
-        compound_args_cbk_cleanup (args_cbk);
-        return NULL;
+    compound_args_cbk_cleanup(args_cbk);
+    return NULL;
 }
 
-compound_args_t*
-compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata)
+compound_args_t *
+compound_fop_alloc(int length, glusterfs_compound_fop_t fop, dict_t *xdata)
 {
-        compound_args_t *args     = NULL;
+    compound_args_t *args = NULL;
 
-        args = GF_CALLOC (1, sizeof (*args), gf_mt_compound_req_t);
+    args = GF_CALLOC(1, sizeof(*args), gf_mt_compound_req_t);
 
-        if (!args)
-                return NULL;
+    if (!args)
+        return NULL;
 
-        /* fop_enum can be used by xlators to see which fops are
-         * included as part of compound fop. This will help in checking
-         * for compatibility or support without going through the entire
-         * fop list packed.
-         */
-        args->fop_enum = fop;
-        args->fop_length = length;
+    /* fop_enum can be used by xlators to see which fops are
+     * included as part of compound fop. This will help in checking
+     * for compatibility or support without going through the entire
+     * fop list packed.
+     */
+    args->fop_enum = fop;
+    args->fop_length = length;
 
-        args->enum_list = GF_CALLOC (length, sizeof (*args->enum_list),
-                                     gf_common_mt_int);
+    args->enum_list = GF_CALLOC(length, sizeof(*args->enum_list),
+                                gf_common_mt_int);
 
-        if (!args->enum_list)
-                goto out;
+    if (!args->enum_list)
+        goto out;
 
-        args->req_list = GF_CALLOC (length, sizeof (*args->req_list),
-                                     gf_mt_default_args_t);
+    args->req_list = GF_CALLOC(length, sizeof(*args->req_list),
+                               gf_mt_default_args_t);
 
-        if (!args->req_list)
-                goto out;
+    if (!args->req_list)
+        goto out;
 
-        if (xdata) {
-                args->xdata = dict_copy_with_ref (xdata, args->xdata);
-                if (!args->xdata)
-                        goto out;
-        }
+    if (xdata) {
+        args->xdata = dict_copy_with_ref(xdata, args->xdata);
+        if (!args->xdata)
+            goto out;
+    }
 
-        return args;
+    return args;
 out:
-        compound_args_cleanup (args);
-        return NULL;
+    compound_args_cleanup(args);
+    return NULL;
 }
diff --git a/libglusterfs/src/ctx.c b/libglusterfs/src/ctx.c
index afd12cd22f8..1e4c341df05 100644
--- a/libglusterfs/src/ctx.c
+++ b/libglusterfs/src/ctx.c
@@ -15,82 +15,82 @@
 #include "timer-wheel.h"
 
 glusterfs_ctx_t *
-glusterfs_ctx_new ()
+glusterfs_ctx_new()
 {
-        int               ret = 0;
-	glusterfs_ctx_t  *ctx = NULL;
-
-	/* no GF_CALLOC here, gf_acct_mem_set_enable is not
-	   yet decided at this point */
-        ctx = calloc (1, sizeof (*ctx));
-        if (!ctx) {
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+
+    /* no GF_CALLOC here, gf_acct_mem_set_enable is not
+       yet decided at this point */
+    ctx = calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        ret = -1;
+        goto out;
+    }
 
-        ctx->mem_acct_enable = gf_global_mem_acct_enable_get();
+    ctx->mem_acct_enable = gf_global_mem_acct_enable_get();
 
-        INIT_LIST_HEAD (&ctx->graphs);
-        INIT_LIST_HEAD (&ctx->mempool_list);
-        INIT_LIST_HEAD (&ctx->volfile_list);
+    INIT_LIST_HEAD(&ctx->graphs);
+    INIT_LIST_HEAD(&ctx->mempool_list);
+    INIT_LIST_HEAD(&ctx->volfile_list);
 
-	ctx->daemon_pipe[0] = -1;
-	ctx->daemon_pipe[1] = -1;
+    ctx->daemon_pipe[0] = -1;
+    ctx->daemon_pipe[1] = -1;
 
-        ctx->log.loglevel = DEFAULT_LOG_LEVEL;
+    ctx->log.loglevel = DEFAULT_LOG_LEVEL;
 
 #ifdef RUN_WITH_VALGRIND
-        ctx->cmd_args.valgrind = _gf_true;
+    ctx->cmd_args.valgrind = _gf_true;
 #endif
 
-        /* lock is never destroyed! */
-	ret = LOCK_INIT (&ctx->lock);
-	if (ret) {
-		free (ctx);
-		ctx = NULL;
-                goto out;
-	}
-
-        GF_ATOMIC_INIT (ctx->stats.max_dict_pairs, 0);
-        GF_ATOMIC_INIT (ctx->stats.total_pairs_used, 0);
-        GF_ATOMIC_INIT (ctx->stats.total_dicts_used, 0);
+    /* lock is never destroyed! */
+    ret = LOCK_INIT(&ctx->lock);
+    if (ret) {
+        free(ctx);
+        ctx = NULL;
+        goto out;
+    }
+
+    GF_ATOMIC_INIT(ctx->stats.max_dict_pairs, 0);
+    GF_ATOMIC_INIT(ctx->stats.total_pairs_used, 0);
+    GF_ATOMIC_INIT(ctx->stats.total_dicts_used, 0);
 out:
-	return ctx;
+    return ctx;
 }
 
 static void
-glusterfs_ctx_tw_destroy (struct gf_ctx_tw *ctx_tw)
+glusterfs_ctx_tw_destroy(struct gf_ctx_tw *ctx_tw)
 {
-        if (ctx_tw->timer_wheel)
-                gf_tw_cleanup_timers (ctx_tw->timer_wheel);
+    if (ctx_tw->timer_wheel)
+        gf_tw_cleanup_timers(ctx_tw->timer_wheel);
 
-        GF_FREE (ctx_tw);
+    GF_FREE(ctx_tw);
 }
 
-struct tvec_base*
-glusterfs_ctx_tw_get (glusterfs_ctx_t *ctx)
+struct tvec_base *
+glusterfs_ctx_tw_get(glusterfs_ctx_t *ctx)
 {
-        struct gf_ctx_tw *ctx_tw = NULL;
-
-        LOCK (&ctx->lock);
-        {
-                if (ctx->tw) {
-                        ctx_tw = GF_REF_GET (ctx->tw);
-                } else {
-                        ctx_tw = GF_CALLOC (1, sizeof (struct gf_ctx_tw),
-                                            gf_common_mt_tw_ctx);
-                        ctx_tw->timer_wheel = gf_tw_init_timers();
-                        GF_REF_INIT (ctx_tw, glusterfs_ctx_tw_destroy);
-                        ctx->tw = ctx_tw;
-                }
+    struct gf_ctx_tw *ctx_tw = NULL;
+
+    LOCK(&ctx->lock);
+    {
+        if (ctx->tw) {
+            ctx_tw = GF_REF_GET(ctx->tw);
+        } else {
+            ctx_tw = GF_CALLOC(1, sizeof(struct gf_ctx_tw),
+                               gf_common_mt_tw_ctx);
+            ctx_tw->timer_wheel = gf_tw_init_timers();
+            GF_REF_INIT(ctx_tw, glusterfs_ctx_tw_destroy);
+            ctx->tw = ctx_tw;
         }
-        UNLOCK (&ctx->lock);
+    }
+    UNLOCK(&ctx->lock);
 
-        return ctx_tw->timer_wheel;
+    return ctx_tw->timer_wheel;
 }
 
 void
-glusterfs_ctx_tw_put (glusterfs_ctx_t *ctx)
+glusterfs_ctx_tw_put(glusterfs_ctx_t *ctx)
 {
-        GF_REF_PUT (ctx->tw);
+    GF_REF_PUT(ctx->tw);
 }
diff --git a/libglusterfs/src/daemon.c b/libglusterfs/src/daemon.c
index 348e3ad4083..f821f8f7ed0 100644
--- a/libglusterfs/src/daemon.c
+++ b/libglusterfs/src/daemon.c
@@ -14,53 +14,53 @@
 #include "daemon.h"
 
 int
-os_daemon_return (int nochdir, int noclose)
+os_daemon_return(int nochdir, int noclose)
 {
-	pid_t   pid  = -1;
-	int     ret  = -1;
-        FILE    *ptr = NULL;
+    pid_t pid = -1;
+    int ret = -1;
+    FILE *ptr = NULL;
 
-	ret = fork();
-	if (ret)
-		return ret;
+    ret = fork();
+    if (ret)
+        return ret;
 
-	pid = setsid();
+    pid = setsid();
 
-	if (pid == -1) {
-                ret = -1;
-		goto out;
-        }
+    if (pid == -1) {
+        ret = -1;
+        goto out;
+    }
 
-	if (!nochdir)
-		ret = chdir("/");
+    if (!nochdir)
+        ret = chdir("/");
 
-        if (!noclose) {
-                ptr = freopen (DEVNULLPATH, "r", stdin);
-                if (!ptr)
-                        goto out;
+    if (!noclose) {
+        ptr = freopen(DEVNULLPATH, "r", stdin);
+        if (!ptr)
+            goto out;
 
-                ptr = freopen (DEVNULLPATH, "w", stdout);
-                if (!ptr)
-                        goto out;
+        ptr = freopen(DEVNULLPATH, "w", stdout);
+        if (!ptr)
+            goto out;
 
-                ptr = freopen (DEVNULLPATH, "w", stderr);
-                if (!ptr)
-                        goto out;
-	}
+        ptr = freopen(DEVNULLPATH, "w", stderr);
+        if (!ptr)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
 int
-os_daemon (int nochdir, int noclose)
+os_daemon(int nochdir, int noclose)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = os_daemon_return (nochdir, noclose);
-	if (ret <= 0)
-		return ret;
+    ret = os_daemon_return(nochdir, noclose);
+    if (ret <= 0)
+        return ret;
 
-	_exit (0);
+    _exit(0);
 }
diff --git a/libglusterfs/src/default-args.c b/libglusterfs/src/default-args.c
index 2bc1ec28649..c92f3d46a86 100644
--- a/libglusterfs/src/default-args.c
+++ b/libglusterfs/src/default-args.c
@@ -17,1656 +17,1593 @@
 #include "defaults.h"
 
 int
-args_lookup_store (default_args_t *args, loc_t *loc,
-                   dict_t *xdata)
+args_lookup_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_lookup_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     inode_t *inode, struct iatt *buf,
-                     dict_t *xdata, struct iatt *postparent)
+args_lookup_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, inode_t *inode, struct iatt *buf,
+                      dict_t *xdata, struct iatt *postparent)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_stat_store (default_args_t *args, loc_t *loc, dict_t *xdata)
+args_stat_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_stat_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   struct iatt *buf, dict_t *xdata)
+args_stat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    struct iatt *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->stat = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fstat_store (default_args_t *args, fd_t *fd, dict_t *xdata)
+args_fstat_store(default_args_t *args, fd_t *fd, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fstat_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *buf, dict_t *xdata)
+args_fstat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (buf)
-                args->stat = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (buf)
+        args->stat = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_truncate_store (default_args_t *args, loc_t *loc, off_t off,
-                     dict_t *xdata)
+args_truncate_store(default_args_t *args, loc_t *loc, off_t off, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_truncate_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
+args_truncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ftruncate_store (default_args_t *args, fd_t *fd, off_t off,
-                      dict_t *xdata)
+args_ftruncate_store(default_args_t *args, fd_t *fd, off_t off, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ftruncate_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+args_ftruncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_access_store (default_args_t *args, loc_t *loc, int32_t mask,
-                   dict_t *xdata)
+args_access_store(default_args_t *args, loc_t *loc, int32_t mask, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mask = mask;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->mask = mask;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_access_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_access_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_readlink_store (default_args_t *args, loc_t *loc, size_t size,
-                     dict_t *xdata)
+args_readlink_store(default_args_t *args, loc_t *loc, size_t size,
+                    dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->size = size;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->size = size;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readlink_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       const char *path, struct iatt *stbuf, dict_t *xdata)
+args_readlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, const char *path, struct iatt *stbuf,
+                        dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (path)
-                args->buf = gf_strdup (path);
-        if (stbuf)
-                args->stat = *stbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (path)
+        args->buf = gf_strdup(path);
+    if (stbuf)
+        args->stat = *stbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mknod_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  dev_t rdev, mode_t umask, dict_t *xdata)
+args_mknod_store(default_args_t *args, loc_t *loc, mode_t mode, dev_t rdev,
+                 mode_t umask, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode = mode;
-        args->rdev = rdev;
-        args->umask = umask;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->rdev = rdev;
+    args->umask = umask;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mknod_cbk_store (default_args_cbk_t *args, int op_ret,
-                    int32_t op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata)
+args_mknod_cbk_store(default_args_cbk_t *args, int op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mkdir_store (default_args_t *args, loc_t *loc, mode_t mode,
-                  mode_t umask, dict_t *xdata)
+args_mkdir_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+                 dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode  = mode;
-        args->umask = umask;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->umask = umask;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_mkdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+args_mkdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_unlink_store (default_args_t *args, loc_t *loc, int xflag, dict_t *xdata)
+args_unlink_store(default_args_t *args, loc_t *loc, int xflag, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->xflag = xflag;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->xflag = xflag;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_unlink_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+args_unlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_rmdir_store (default_args_t *args, loc_t *loc, int flags, dict_t *xdata)
+args_rmdir_store(default_args_t *args, loc_t *loc, int flags, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_rmdir_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preparent, struct iatt *postparent,
-                    dict_t *xdata)
+args_rmdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_symlink_store (default_args_t *args, const char *linkname, loc_t *loc,
+args_symlink_store(default_args_t *args, const char *linkname, loc_t *loc,
                    mode_t umask, dict_t *xdata)
 {
-        args->linkname = gf_strdup (linkname);
-        args->umask = umask;
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->linkname = gf_strdup(linkname);
+    args->umask = umask;
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_symlink_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+args_symlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, inode_t *inode, struct iatt *buf,
+                       struct iatt *preparent, struct iatt *postparent,
+                       dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_rename_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                   dict_t *xdata)
+args_rename_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                  dict_t *xdata)
 {
-        loc_copy (&args->loc, oldloc);
-        loc_copy (&args->loc2, newloc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, oldloc);
+    loc_copy(&args->loc2, newloc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_rename_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-                     dict_t *xdata)
+args_rename_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *buf,
+                      struct iatt *preoldparent, struct iatt *postoldparent,
+                      struct iatt *prenewparent, struct iatt *postnewparent,
+                      dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (buf)
-                args->stat = *buf;
-        if (preoldparent)
-                args->preparent = *preoldparent;
-        if (postoldparent)
-                args->postparent = *postoldparent;
-        if (prenewparent)
-                args->preparent2 = *prenewparent;
-        if (postnewparent)
-                args->postparent2 = *postnewparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (buf)
+        args->stat = *buf;
+    if (preoldparent)
+        args->preparent = *preoldparent;
+    if (postoldparent)
+        args->postparent = *postoldparent;
+    if (prenewparent)
+        args->preparent2 = *prenewparent;
+    if (postnewparent)
+        args->postparent2 = *postnewparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_link_store (default_args_t *args, loc_t *oldloc, loc_t *newloc,
-                 dict_t *xdata)
+args_link_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,
+                dict_t *xdata)
 {
-        loc_copy (&args->loc, oldloc);
-        loc_copy (&args->loc2, newloc);
+    loc_copy(&args->loc, oldloc);
+    loc_copy(&args->loc2, newloc);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_link_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   inode_t *inode, struct iatt *buf,
-                   struct iatt *preparent, struct iatt *postparent,
-                   dict_t *xdata)
+args_link_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_create_store (default_args_t *args,
-                  loc_t *loc, int32_t flags, mode_t mode,
+args_create_store(default_args_t *args, loc_t *loc, int32_t flags, mode_t mode,
                   mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        args->mode = mode;
-        args->umask = umask;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    args->mode = mode;
+    args->umask = umask;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_create_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+args_create_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, fd_t *fd, inode_t *inode,
+                      struct iatt *buf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (buf)
-                args->stat = *buf;
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (buf)
+        args->stat = *buf;
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_open_store (default_args_t *args, loc_t *loc, int32_t flags,
-                 fd_t *fd, dict_t *xdata)
+args_open_store(default_args_t *args, loc_t *loc, int32_t flags, fd_t *fd,
+                dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->flags = flags;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    args->flags = flags;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_open_cbk_store (default_args_cbk_t *args,
-                   int32_t op_ret, int32_t op_errno,
-                   fd_t *fd, dict_t *xdata)
+args_open_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    fd_t *fd, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readv_store (default_args_t *args, fd_t *fd, size_t size, off_t off,
-                  uint32_t flags, dict_t *xdata)
+args_readv_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                 uint32_t flags, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->size  = size;
-        args->offset  = off;
-        args->flags = flags;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
+    args->flags = flags;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_readv_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                    int32_t count, struct iatt *stbuf,
-                    struct iobref *iobref, dict_t *xdata)
+args_readv_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iovec *vector, int32_t count, struct iatt *stbuf,
+                     struct iobref *iobref, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0) {
-                args->vector = iov_dup (vector, count);
-                args->count = count;
-                args->stat = *stbuf;
-                args->iobref = iobref_ref (iobref);
-        }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0) {
+        args->vector = iov_dup(vector, count);
+        args->count = count;
+        args->stat = *stbuf;
+        args->iobref = iobref_ref(iobref);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_writev_store (default_args_t *args, fd_t *fd, struct iovec *vector,
-                   int32_t count, off_t off, uint32_t flags,
-                   struct iobref *iobref, dict_t *xdata)
+args_writev_store(default_args_t *args, fd_t *fd, struct iovec *vector,
+                  int32_t count, off_t off, uint32_t flags,
+                  struct iobref *iobref, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->vector = iov_dup (vector, count);
-        args->count  = count;
-        args->offset = off;
-        args->flags  = flags;
-        args->iobref = iobref_ref (iobref);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->vector = iov_dup(vector, count);
+    args->count = count;
+    args->offset = off;
+    args->flags = flags;
+    args->iobref = iobref_ref(iobref);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_writev_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+args_writev_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0)
-                args->poststat = *postbuf;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0)
+        args->poststat = *postbuf;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_put_store (default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
-                uint32_t flags, struct iovec *vector, int32_t count, off_t off,
-                struct iobref *iobref, dict_t *xattr, dict_t *xdata)
+args_put_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,
+               uint32_t flags, struct iovec *vector, int32_t count, off_t off,
+               struct iobref *iobref, dict_t *xattr, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode = mode;
-        args->umask = umask;
-        args->flags  = flags;
-        args->vector = iov_dup (vector, count);
-        args->count  = count;
-        args->offset = off;
-        args->iobref = iobref_ref (iobref);
-        if (xattr)
-                args->xattr = dict_ref (xattr);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
+    args->umask = umask;
+    args->flags = flags;
+    args->vector = iov_dup(vector, count);
+    args->count = count;
+    args->offset = off;
+    args->iobref = iobref_ref(iobref);
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_put_cbk_store (default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
-                    inode_t *inode, struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+args_put_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   inode_t *inode, struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0)
-                args->stat = *buf;
-        if (inode)
-                args->inode = inode_ref (inode);
-        if (preparent)
-                args->preparent = *preparent;
-        if (postparent)
-                args->postparent = *postparent;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0)
+        args->stat = *buf;
+    if (inode)
+        args->inode = inode_ref(inode);
+    if (preparent)
+        args->preparent = *preparent;
+    if (postparent)
+        args->postparent = *postparent;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 int
-args_flush_store (default_args_t *args, fd_t *fd, dict_t *xdata)
+args_flush_store(default_args_t *args, fd_t *fd, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_flush_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_flush_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fsync_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                  dict_t *xdata)
+args_fsync_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                 dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->datasync = datasync;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->datasync = datasync;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fsync_cbk_store (default_args_cbk_t *args,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+args_fsync_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (prebuf)
-                args->prestat = *prebuf;
-        if (postbuf)
-                args->poststat = *postbuf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (prebuf)
+        args->prestat = *prebuf;
+    if (postbuf)
+        args->poststat = *postbuf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_opendir_store (default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata)
+args_opendir_store(default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_opendir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      fd_t *fd, dict_t *xdata)
+args_opendir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (fd)
-                args->fd = fd_ref (fd);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (fd)
+        args->fd = fd_ref(fd);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fsyncdir_store (default_args_t *args, fd_t *fd, int32_t datasync,
-                     dict_t *xdata)
+args_fsyncdir_store(default_args_t *args, fd_t *fd, int32_t datasync,
+                    dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->datasync = datasync;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->datasync = datasync;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 int
-args_fsyncdir_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fsyncdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_statfs_store (default_args_t *args, loc_t *loc, dict_t *xdata)
+args_statfs_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_statfs_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct statvfs *buf, dict_t *xdata)
+args_statfs_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                      int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->statvfs = *buf;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->statvfs = *buf;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_setxattr_store (default_args_t *args,
-                     loc_t *loc, dict_t *dict,
-                     int32_t flags, dict_t *xdata)
+args_setxattr_store(default_args_t *args, loc_t *loc, dict_t *dict,
+                    int32_t flags, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        /* TODO */
-        if (dict)
-                args->xattr = dict_ref (dict);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    /* TODO */
+    if (dict)
+        args->xattr = dict_ref(dict);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_setxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret,
-                       int32_t op_errno, dict_t *xdata)
+args_setxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_getxattr_store (default_args_t *args,
-                     loc_t *loc, const char *name, dict_t *xdata)
+args_getxattr_store(default_args_t *args, loc_t *loc, const char *name,
+                    dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (name)
-                args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (name)
+        args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_getxattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata)
+args_getxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (dict)
-                args->xattr = dict_ref (dict);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fsetxattr_store (default_args_t *args,
-                      fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+args_fsetxattr_store(default_args_t *args, fd_t *fd, dict_t *dict,
+                     int32_t flags, dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        if (dict)
-                args->xattr = dict_ref (dict);
-        args->flags = flags;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    args->flags = flags;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fsetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fsetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fgetxattr_store (default_args_t *args,
-                      fd_t *fd, const char *name, dict_t *xdata)
+args_fgetxattr_store(default_args_t *args, fd_t *fd, const char *name,
+                     dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        if (name)
-                args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (name)
+        args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fgetxattr_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+args_fgetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (dict)
-                args->xattr = dict_ref (dict);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (dict)
+        args->xattr = dict_ref(dict);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_removexattr_store (default_args_t *args,
-                        loc_t *loc, const char *name, dict_t *xdata)
+args_removexattr_store(default_args_t *args, loc_t *loc, const char *name,
+                       dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_removexattr_cbk_store (default_args_cbk_t *args,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_removexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fremovexattr_store (default_args_t *args,
-                         fd_t *fd, const char *name, dict_t *xdata)
+args_fremovexattr_store(default_args_t *args, fd_t *fd, const char *name,
+                        dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->name = gf_strdup (name);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    args->fd = fd_ref(fd);
+    args->name = gf_strdup(name);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fremovexattr_cbk_store (default_args_cbk_t *args,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fremovexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                            int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_lk_store (default_args_t *args,
-               fd_t *fd, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata)
+args_lk_store(default_args_t *args, fd_t *fd, int32_t cmd,
+              struct gf_flock *lock, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->cmd = cmd;
-        args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->cmd = cmd;
+    args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_lk_cbk_store (default_args_cbk_t *args,
-                 int32_t op_ret, int32_t op_errno,
-                 struct gf_flock *lock, dict_t *xdata)
+args_lk_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                  struct gf_flock *lock, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_inodelk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, int32_t cmd,
-                    struct gf_flock *lock, dict_t *xdata)
+args_inodelk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        loc_copy (&args->loc, loc);
-        args->cmd  = cmd;
-        args->lock = *lock;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    loc_copy(&args->loc, loc);
+    args->cmd = cmd;
+    args->lock = *lock;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_inodelk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_inodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_finodelk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, int32_t cmd,
-                     struct gf_flock *lock, dict_t *xdata)
+args_finodelk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        if (fd)
-                args->fd   = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        args->cmd  = cmd;
-        args->lock = *lock;
+    args->cmd = cmd;
+    args->lock = *lock;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_finodelk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_finodelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_entrylk_store (default_args_t *args,
-                    const char *volume, loc_t *loc, const char *name,
-                    entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+args_entrylk_store(default_args_t *args, const char *volume, loc_t *loc,
+                   const char *name, entrylk_cmd cmd, entrylk_type type,
+                   dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        args->entrylkcmd = cmd;
-        args->entrylktype = type;
+    args->entrylkcmd = cmd;
+    args->entrylktype = type;
 
-        if (name)
-                args->name = gf_strdup (name);
+    if (name)
+        args->name = gf_strdup(name);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_entrylk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_entrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fentrylk_store (default_args_t *args,
-                     const char *volume, fd_t *fd, const char *name,
-                     entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+args_fentrylk_store(default_args_t *args, const char *volume, fd_t *fd,
+                    const char *name, entrylk_cmd cmd, entrylk_type type,
+                    dict_t *xdata)
 {
-        if (volume)
-                args->volume = gf_strdup (volume);
+    if (volume)
+        args->volume = gf_strdup(volume);
 
-        if (fd)
-                args->fd = fd_ref (fd);
-        args->entrylkcmd = cmd;
-        args->entrylktype = type;
-        if (name)
-                args->name = gf_strdup (name);
+    if (fd)
+        args->fd = fd_ref(fd);
+    args->entrylkcmd = cmd;
+    args->entrylktype = type;
+    if (name)
+        args->name = gf_strdup(name);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fentrylk_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_fentrylk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-
-        return 0;
-}
-
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-int
-args_readdirp_store (default_args_t *args,
-                     fd_t *fd, size_t size, off_t off, dict_t *xdata)
-{
-        args->fd = fd_ref (fd);
-        args->size = size;
-        args->offset = off;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    return 0;
 }
 
 int
-args_readdirp_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata)
+args_readdirp_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                    dict_t *xdata)
 {
-        gf_dirent_t *stub_entry = NULL, *entry = NULL;
-
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        stub_entry = gf_dirent_for_name (entry->d_name);
-                        if (!stub_entry)
-                                goto out;
-                        stub_entry->d_off = entry->d_off;
-                        stub_entry->d_ino = entry->d_ino;
-                        stub_entry->d_stat = entry->d_stat;
-                        stub_entry->d_type = entry->d_type;
-                        if (entry->inode)
-                                stub_entry->inode = inode_ref (entry->inode);
-                        if (entry->dict)
-                                stub_entry->dict = dict_ref (entry->dict);
-                        list_add_tail (&stub_entry->list,
-                                       &args->entries.list);
-                }
+    args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
+}
+
+int
+args_readdirp_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
+{
+    gf_dirent_t *stub_entry = NULL, *entry = NULL;
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            stub_entry = gf_dirent_for_name(entry->d_name);
+            if (!stub_entry)
+                goto out;
+            stub_entry->d_off = entry->d_off;
+            stub_entry->d_ino = entry->d_ino;
+            stub_entry->d_stat = entry->d_stat;
+            stub_entry->d_type = entry->d_type;
+            if (entry->inode)
+                stub_entry->inode = inode_ref(entry->inode);
+            if (entry->dict)
+                stub_entry->dict = dict_ref(entry->dict);
+            list_add_tail(&stub_entry->list, &args->entries.list);
         }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-args_readdir_store (default_args_t *args,
-                    fd_t *fd, size_t size,
-                    off_t off, dict_t *xdata)
+args_readdir_store(default_args_t *args, fd_t *fd, size_t size, off_t off,
+                   dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->size = size;
-        args->offset = off;
+    args->fd = fd_ref(fd);
+    args->size = size;
+    args->offset = off;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_readdir_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      gf_dirent_t *entries, dict_t *xdata)
+args_readdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
-        gf_dirent_t *stub_entry = NULL, *entry = NULL;
+    gf_dirent_t *stub_entry = NULL, *entry = NULL;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        stub_entry = gf_dirent_for_name (entry->d_name);
-                        if (!stub_entry)
-                                goto out;
-                        stub_entry->d_off = entry->d_off;
-                        stub_entry->d_ino = entry->d_ino;
-                        stub_entry->d_type = entry->d_type;
-                        list_add_tail (&stub_entry->list,
-                                       &args->entries.list);
-                }
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            stub_entry = gf_dirent_for_name(entry->d_name);
+            if (!stub_entry)
+                goto out;
+            stub_entry->d_off = entry->d_off;
+            stub_entry->d_ino = entry->d_ino;
+            stub_entry->d_type = entry->d_type;
+            list_add_tail(&stub_entry->list, &args->entries.list);
         }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-args_rchecksum_store (default_args_t *args,
-                      fd_t *fd, off_t offset, int32_t len, dict_t *xdata)
+args_rchecksum_store(default_args_t *args, fd_t *fd, off_t offset, int32_t len,
+                     dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
-        args->offset = offset;
-        args->size    = len;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    args->fd = fd_ref(fd);
+    args->offset = offset;
+    args->size = len;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_rchecksum_cbk_store (default_args_cbk_t *args,
-                        int32_t op_ret, int32_t op_errno,
-                        uint32_t weak_checksum, uint8_t *strong_checksum,
-                        dict_t *xdata)
+args_rchecksum_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, uint32_t weak_checksum,
+                         uint8_t *strong_checksum, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret >= 0) {
-                args->weak_checksum =
-                        weak_checksum;
-                args->strong_checksum =
-                        memdup (strong_checksum, SHA256_DIGEST_LENGTH);
-        }
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret >= 0) {
+        args->weak_checksum = weak_checksum;
+        args->strong_checksum = memdup(strong_checksum, SHA256_DIGEST_LENGTH);
+    }
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_xattrop_store (default_args_t *args,
-                    loc_t *loc, gf_xattrop_flags_t optype,
-                    dict_t *xattr, dict_t *xdata)
+args_xattrop_store(default_args_t *args, loc_t *loc, gf_xattrop_flags_t optype,
+                   dict_t *xattr, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        args->optype = optype;
-        args->xattr = dict_ref (xattr);
+    args->optype = optype;
+    args->xattr = dict_ref(xattr);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
-
 int
-args_xattrop_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                        int32_t op_errno, dict_t *xattr, dict_t *xdata)
+args_xattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xattr)
-                args->xattr = dict_ref (xattr);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_fxattrop_store (default_args_t *args,
-                     fd_t *fd, gf_xattrop_flags_t optype,
-                     dict_t *xattr, dict_t *xdata)
+args_fxattrop_store(default_args_t *args, fd_t *fd, gf_xattrop_flags_t optype,
+                    dict_t *xattr, dict_t *xdata)
 {
-        args->fd = fd_ref (fd);
+    args->fd = fd_ref(fd);
 
-        args->optype = optype;
-        args->xattr = dict_ref (xattr);
+    args->optype = optype;
+    args->xattr = dict_ref(xattr);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fxattrop_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+args_fxattrop_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xattr)
-                args->xattr = dict_ref (xattr);
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xattr)
+        args->xattr = dict_ref(xattr);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_setattr_store (default_args_t *args,
-                    loc_t *loc, struct iatt *stbuf,
-                    int32_t valid, dict_t *xdata)
+args_setattr_store(default_args_t *args, loc_t *loc, struct iatt *stbuf,
+                   int32_t valid, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (stbuf)
-                args->stat = *stbuf;
+    if (stbuf)
+        args->stat = *stbuf;
 
-        args->valid = valid;
+    args->valid = valid;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_setattr_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt *statpre, struct iatt *statpost,
-                      dict_t *xdata)
+args_setattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-args_fsetattr_store (default_args_t *args,
-                     fd_t *fd, struct iatt *stbuf,
-                     int32_t valid, dict_t *xdata)
+args_fsetattr_store(default_args_t *args, fd_t *fd, struct iatt *stbuf,
+                    int32_t valid, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        if (stbuf)
-                args->stat = *stbuf;
+    if (stbuf)
+        args->stat = *stbuf;
 
-        args->valid = valid;
+    args->valid = valid;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 int
-args_fsetattr_cbk_store (default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata)
+args_fsetattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_fallocate_store (default_args_t *args, fd_t *fd,
-                      int32_t mode, off_t offset, size_t len, dict_t *xdata)
+args_fallocate_store(default_args_t *args, fd_t *fd, int32_t mode, off_t offset,
+                     size_t len, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-	args->flags = mode;
-	args->offset = offset;
-	args->size = len;
+    args->flags = mode;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_fallocate_cbk_store(default_args_cbk_t *args,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *statpre, struct iatt *statpost,
-                       dict_t *xdata)
+args_fallocate_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                         int32_t op_errno, struct iatt *statpre,
+                         struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_discard_store (default_args_t *args, fd_t *fd,
-		    off_t offset, size_t len, dict_t *xdata)
+args_discard_store(default_args_t *args, fd_t *fd, off_t offset, size_t len,
+                   dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-	args->offset = offset;
-	args->size = len;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_discard_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+args_discard_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                       int32_t op_errno, struct iatt *statpre,
+                       struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_zerofill_store (default_args_t *args, fd_t *fd,
-                     off_t offset, off_t len, dict_t *xdata)
+args_zerofill_store(default_args_t *args, fd_t *fd, off_t offset, off_t len,
+                    dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = offset;
-        args->size = len;
+    args->offset = offset;
+    args->size = len;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_zerofill_cbk_store(default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *statpre, struct iatt *statpost,
-                     dict_t *xdata)
+args_zerofill_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                        int32_t op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (statpre)
-                args->prestat = *statpre;
-        if (statpost)
-                args->poststat = *statpost;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (statpre)
+        args->prestat = *statpre;
+    if (statpost)
+        args->poststat = *statpost;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_ipc_store (default_args_t *args,
-                int32_t op, dict_t *xdata)
+args_ipc_store(default_args_t *args, int32_t op, dict_t *xdata)
 {
-        args->cmd = op;
+    args->cmd = op;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_ipc_cbk_store (default_args_cbk_t *args,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+args_ipc_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                   dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_seek_store (default_args_t *args, fd_t *fd,
-                 off_t offset, gf_seek_what_t what, dict_t *xdata)
+args_seek_store(default_args_t *args, fd_t *fd, off_t offset,
+                gf_seek_what_t what, dict_t *xdata)
 {
-        if (fd)
-                args->fd = fd_ref (fd);
+    if (fd)
+        args->fd = fd_ref(fd);
 
-        args->offset = offset;
-        args->what = what;
+    args->offset = offset;
+    args->what = what;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_seek_cbk_store (default_args_cbk_t *args, int32_t op_ret,
-                     int32_t op_errno, off_t offset, dict_t *xdata)
+args_seek_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
+                    off_t offset, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        args->offset = offset;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    args->offset = offset;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-args_getactivelk_cbk_store (default_args_cbk_t *args,
-                      int32_t op_ret, int32_t op_errno,
-                      lock_migration_info_t *locklist, dict_t *xdata)
+args_getactivelk_cbk_store(default_args_cbk_t *args, int32_t op_ret,
+                           int32_t op_errno, lock_migration_info_t *locklist,
+                           dict_t *xdata)
 {
-        lock_migration_info_t  *stub_entry = NULL, *entry = NULL;
-        int     ret = 0;
+    lock_migration_info_t *stub_entry = NULL, *entry = NULL;
+    int ret = 0;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        /*op_ret needs to carry the number of locks present in the list*/
-        if (op_ret > 0) {
-                list_for_each_entry (entry, &locklist->list, list) {
-                        stub_entry = GF_CALLOC (1, sizeof (*stub_entry),
-                                                gf_common_mt_char);
-                        if (!stub_entry) {
-                               ret = -1;
-                               goto out;
-                        }
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    /*op_ret needs to carry the number of locks present in the list*/
+    if (op_ret > 0) {
+        list_for_each_entry(entry, &locklist->list, list)
+        {
+            stub_entry = GF_CALLOC(1, sizeof(*stub_entry), gf_common_mt_char);
+            if (!stub_entry) {
+                ret = -1;
+                goto out;
+            }
 
-                        INIT_LIST_HEAD (&stub_entry->list);
-                        stub_entry->flock = entry->flock;
+            INIT_LIST_HEAD(&stub_entry->list);
+            stub_entry->flock = entry->flock;
 
-                        stub_entry->lk_flags = entry->lk_flags;
+            stub_entry->lk_flags = entry->lk_flags;
 
-                        stub_entry->client_uid = gf_strdup (entry->client_uid);
-                        if (!stub_entry->client_uid) {
-                                GF_FREE (stub_entry);
-                                ret = -1;
-                                goto out;
-                        }
+            stub_entry->client_uid = gf_strdup(entry->client_uid);
+            if (!stub_entry->client_uid) {
+                GF_FREE(stub_entry);
+                ret = -1;
+                goto out;
+            }
 
-                        list_add_tail (&stub_entry->list,
-                                       &args->locklist.list);
-                }
+            list_add_tail(&stub_entry->list, &args->locklist.list);
         }
+    }
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 out:
-        return ret;
+    return ret;
 }
 
 int
-args_setactivelk_store (default_args_t *args, loc_t *loc,
-                          lock_migration_info_t *locklist, dict_t *xdata)
+args_setactivelk_store(default_args_t *args, loc_t *loc,
+                       lock_migration_info_t *locklist, dict_t *xdata)
 {
-        lock_migration_info_t  *stub_entry = NULL, *entry = NULL;
-        int     ret = 0;
-
-        list_for_each_entry (entry, &locklist->list, list) {
-                stub_entry = GF_CALLOC (1, sizeof (*stub_entry),
-                                        gf_common_mt_lock_mig);
-                if (!stub_entry) {
-                       ret = -1;
-                       goto out;
-                }
+    lock_migration_info_t *stub_entry = NULL, *entry = NULL;
+    int ret = 0;
 
-                INIT_LIST_HEAD (&stub_entry->list);
-                stub_entry->flock = entry->flock;
+    list_for_each_entry(entry, &locklist->list, list)
+    {
+        stub_entry = GF_CALLOC(1, sizeof(*stub_entry), gf_common_mt_lock_mig);
+        if (!stub_entry) {
+            ret = -1;
+            goto out;
+        }
 
-                stub_entry->lk_flags = entry->lk_flags;
+        INIT_LIST_HEAD(&stub_entry->list);
+        stub_entry->flock = entry->flock;
 
-                stub_entry->client_uid = gf_strdup (entry->client_uid);
-                if (!stub_entry->client_uid) {
-                        GF_FREE (stub_entry);
-                        ret = -1;
-                        goto out;
-                }
+        stub_entry->lk_flags = entry->lk_flags;
 
-                list_add_tail (&stub_entry->list,
-                               &args->locklist.list);
+        stub_entry->client_uid = gf_strdup(entry->client_uid);
+        if (!stub_entry->client_uid) {
+            GF_FREE(stub_entry);
+            ret = -1;
+            goto out;
         }
 
-        loc_copy (&args->loc, loc);
+        list_add_tail(&stub_entry->list, &args->locklist.list);
+    }
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    loc_copy(&args->loc, loc);
+
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-args_lease_store (default_args_t *args, loc_t *loc, struct gf_lease *lease,
-                  dict_t *xdata)
+args_lease_store(default_args_t *args, loc_t *loc, struct gf_lease *lease,
+                 dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->lease = *lease;
+    loc_copy(&args->loc, loc);
+    args->lease = *lease;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        return;
+    return;
 }
 
 void
-args_lease_cbk_store (default_args_cbk_t *args,
-                     int32_t op_ret, int32_t op_errno,
+args_lease_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,
                      struct gf_lease *lease, dict_t *xdata)
 {
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (op_ret == 0)
-                args->lease = *lease;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (op_ret == 0)
+        args->lease = *lease;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 }
 
 int
-args_icreate_store (default_args_t *args,
-                    loc_t *loc, mode_t mode, dict_t *xdata)
+args_icreate_store(default_args_t *args, loc_t *loc, mode_t mode, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
-        args->mode = mode;
+    loc_copy(&args->loc, loc);
+    args->mode = mode;
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 int
-args_namelink_store (default_args_t *args,
-                     loc_t *loc, dict_t *xdata)
+args_namelink_store(default_args_t *args, loc_t *loc, dict_t *xdata)
 {
-        loc_copy (&args->loc, loc);
+    loc_copy(&args->loc, loc);
 
-        if (xdata)
-                args->xdata = dict_ref (xdata);
-        return 0;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    return 0;
 }
 
 void
-args_cbk_wipe (default_args_cbk_t *args_cbk)
+args_cbk_wipe(default_args_cbk_t *args_cbk)
 {
-        if (!args_cbk)
-                return;
-        if (args_cbk->inode)
-                inode_unref (args_cbk->inode);
+    if (!args_cbk)
+        return;
+    if (args_cbk->inode)
+        inode_unref(args_cbk->inode);
 
-        GF_FREE ((char *)args_cbk->buf);
+    GF_FREE((char *)args_cbk->buf);
 
-        GF_FREE (args_cbk->vector);
+    GF_FREE(args_cbk->vector);
 
-        if (args_cbk->iobref)
-                iobref_unref (args_cbk->iobref);
+    if (args_cbk->iobref)
+        iobref_unref(args_cbk->iobref);
 
-        if (args_cbk->fd)
-                fd_unref (args_cbk->fd);
+    if (args_cbk->fd)
+        fd_unref(args_cbk->fd);
 
-        if (args_cbk->xattr)
-                dict_unref (args_cbk->xattr);
+    if (args_cbk->xattr)
+        dict_unref(args_cbk->xattr);
 
-        GF_FREE (args_cbk->strong_checksum);
+    GF_FREE(args_cbk->strong_checksum);
 
-        if (args_cbk->xdata)
-                dict_unref (args_cbk->xdata);
+    if (args_cbk->xdata)
+        dict_unref(args_cbk->xdata);
 
-        if (!list_empty (&args_cbk->entries.list))
-                gf_dirent_free (&args_cbk->entries);
+    if (!list_empty(&args_cbk->entries.list))
+        gf_dirent_free(&args_cbk->entries);
 }
 
 void
-args_wipe (default_args_t *args)
+args_wipe(default_args_t *args)
 {
-        if (!args)
-                return;
-
-        loc_wipe (&args->loc);
+    if (!args)
+        return;
 
-        loc_wipe (&args->loc2);
+    loc_wipe(&args->loc);
 
-        if (args->fd)
-                fd_unref (args->fd);
+    loc_wipe(&args->loc2);
 
-        GF_FREE ((char *)args->linkname);
+    if (args->fd)
+        fd_unref(args->fd);
 
-	GF_FREE (args->vector);
+    GF_FREE((char *)args->linkname);
 
-        if (args->iobref)
-                iobref_unref (args->iobref);
+    GF_FREE(args->vector);
 
-        if (args->xattr)
-                dict_unref (args->xattr);
+    if (args->iobref)
+        iobref_unref(args->iobref);
 
-        if (args->xdata)
-                dict_unref (args->xdata);
+    if (args->xattr)
+        dict_unref(args->xattr);
 
-	GF_FREE ((char *)args->name);
+    if (args->xdata)
+        dict_unref(args->xdata);
 
-	GF_FREE ((char *)args->volume);
+    GF_FREE((char *)args->name);
 
+    GF_FREE((char *)args->volume);
 }
 
 void
-args_cbk_init (default_args_cbk_t *args_cbk)
+args_cbk_init(default_args_cbk_t *args_cbk)
 {
-        INIT_LIST_HEAD (&args_cbk->entries);
+    INIT_LIST_HEAD(&args_cbk->entries);
 }
diff --git a/libglusterfs/src/defaults-tmpl.c b/libglusterfs/src/defaults-tmpl.c
index 74550030446..2ce5ec7c685 100644
--- a/libglusterfs/src/defaults-tmpl.c
+++ b/libglusterfs/src/defaults-tmpl.c
@@ -31,206 +31,191 @@
 #pragma generate
 
 struct xlator_fops _default_fops = {
-        .create = default_create,
-        .open = default_open,
-        .stat = default_stat,
-        .readlink = default_readlink,
-        .mknod = default_mknod,
-        .mkdir = default_mkdir,
-        .unlink = default_unlink,
-        .rmdir = default_rmdir,
-        .symlink = default_symlink,
-        .rename = default_rename,
-        .link = default_link,
-        .truncate = default_truncate,
-        .readv = default_readv,
-        .writev = default_writev,
-        .statfs = default_statfs,
-        .flush = default_flush,
-        .fsync = default_fsync,
-        .setxattr = default_setxattr,
-        .getxattr = default_getxattr,
-        .fsetxattr = default_fsetxattr,
-        .fgetxattr = default_fgetxattr,
-        .removexattr = default_removexattr,
-        .fremovexattr = default_fremovexattr,
-        .opendir = default_opendir,
-        .readdir = default_readdir,
-        .readdirp = default_readdirp,
-        .fsyncdir = default_fsyncdir,
-        .access = default_access,
-        .ftruncate = default_ftruncate,
-        .fstat = default_fstat,
-        .lk = default_lk,
-        .inodelk = default_inodelk,
-        .finodelk = default_finodelk,
-        .entrylk = default_entrylk,
-        .fentrylk = default_fentrylk,
-        .lookup = default_lookup,
-        .rchecksum = default_rchecksum,
-        .xattrop = default_xattrop,
-        .fxattrop = default_fxattrop,
-        .setattr = default_setattr,
-        .fsetattr = default_fsetattr,
-	.fallocate = default_fallocate,
-	.discard = default_discard,
-        .zerofill = default_zerofill,
-        .ipc = default_ipc,
-        .seek = default_seek,
-
-        .getspec = default_getspec,
-        .getactivelk = default_getactivelk,
-        .setactivelk = default_setactivelk,
-        .put = default_put,
-        .icreate = default_icreate,
-        .namelink = default_namelink,
+    .create = default_create,
+    .open = default_open,
+    .stat = default_stat,
+    .readlink = default_readlink,
+    .mknod = default_mknod,
+    .mkdir = default_mkdir,
+    .unlink = default_unlink,
+    .rmdir = default_rmdir,
+    .symlink = default_symlink,
+    .rename = default_rename,
+    .link = default_link,
+    .truncate = default_truncate,
+    .readv = default_readv,
+    .writev = default_writev,
+    .statfs = default_statfs,
+    .flush = default_flush,
+    .fsync = default_fsync,
+    .setxattr = default_setxattr,
+    .getxattr = default_getxattr,
+    .fsetxattr = default_fsetxattr,
+    .fgetxattr = default_fgetxattr,
+    .removexattr = default_removexattr,
+    .fremovexattr = default_fremovexattr,
+    .opendir = default_opendir,
+    .readdir = default_readdir,
+    .readdirp = default_readdirp,
+    .fsyncdir = default_fsyncdir,
+    .access = default_access,
+    .ftruncate = default_ftruncate,
+    .fstat = default_fstat,
+    .lk = default_lk,
+    .inodelk = default_inodelk,
+    .finodelk = default_finodelk,
+    .entrylk = default_entrylk,
+    .fentrylk = default_fentrylk,
+    .lookup = default_lookup,
+    .rchecksum = default_rchecksum,
+    .xattrop = default_xattrop,
+    .fxattrop = default_fxattrop,
+    .setattr = default_setattr,
+    .fsetattr = default_fsetattr,
+    .fallocate = default_fallocate,
+    .discard = default_discard,
+    .zerofill = default_zerofill,
+    .ipc = default_ipc,
+    .seek = default_seek,
+
+    .getspec = default_getspec,
+    .getactivelk = default_getactivelk,
+    .setactivelk = default_setactivelk,
+    .put = default_put,
+    .icreate = default_icreate,
+    .namelink = default_namelink,
 };
 struct xlator_fops *default_fops = &_default_fops;
 
-
 /*
  * Remaining functions don't follow the fop calling conventions, so they're
  * not generated.
  */
 
 int32_t
-default_forget (xlator_t *this, inode_t *inode)
+default_forget(xlator_t *this, inode_t *inode)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement forget_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement forget_cbk");
+    return 0;
 }
 
-
 int32_t
-default_releasedir (xlator_t *this, fd_t *fd)
+default_releasedir(xlator_t *this, fd_t *fd)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement releasedir_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement releasedir_cbk");
+    return 0;
 }
 
 int32_t
-default_release (xlator_t *this, fd_t *fd)
+default_release(xlator_t *this, fd_t *fd)
 {
-        gf_log_callingfn (this->name, GF_LOG_DEBUG, "xlator does not "
-                          "implement release_cbk");
-        return 0;
+    gf_log_callingfn(this->name, GF_LOG_DEBUG,
+                     "xlator does not "
+                     "implement release_cbk");
+    return 0;
 }
 
 /* notify */
 int
-default_notify (xlator_t *this, int32_t event, void *data, ...)
+default_notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        GF_UNUSED int ret = 0;
-        switch (event) {
+    GF_UNUSED int ret = 0;
+    switch (event) {
         case GF_EVENT_PARENT_UP:
-        case GF_EVENT_PARENT_DOWN:
-        {
-                xlator_list_t *list = this->children;
-
-                while (list) {
-                        xlator_notify (list->xlator, event, this);
-                        list = list->next;
-                }
-        }
-        break;
+        case GF_EVENT_PARENT_DOWN: {
+            xlator_list_t *list = this->children;
+
+            while (list) {
+                xlator_notify(list->xlator, event, this);
+                list = list->next;
+            }
+        } break;
         case GF_EVENT_CHILD_CONNECTING:
         case GF_EVENT_CHILD_DOWN:
         case GF_EVENT_CHILD_UP:
-        case GF_EVENT_AUTH_FAILED:
-        {
-                xlator_list_t *parent = this->parents;
-
-                /*
-                 * Handle case of CHILD_* & AUTH_FAILED event specially, send
-                 * it to fuse.
-                 */
-                if (!parent && this->ctx && this->ctx->master) {
-                        xlator_notify (this->ctx->master, event, this->graph,
-                                       NULL);
-                }
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               this, NULL);
-                        parent = parent->next;
-                }
-        }
-        break;
-        case GF_EVENT_UPCALL:
-        {
-                xlator_list_t *parent = this->parents;
-
-                if (!parent && this->ctx && this->ctx->master)
-                        xlator_notify (this->ctx->master, event, data, NULL);
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               data, NULL);
-                        parent = parent->next;
-                }
-        }
-        break;
-        case GF_EVENT_CHILD_PING:
-        {
-                xlator_list_t *parent = this->parents;
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                XLATOR_NOTIFY (ret, parent->xlator, event,
-                                               this, data);
-                        parent = parent->next;
-                }
+        case GF_EVENT_AUTH_FAILED: {
+            xlator_list_t *parent = this->parents;
+
+            /*
+             * Handle case of CHILD_* & AUTH_FAILED event specially, send
+             * it to fuse.
+             */
+            if (!parent && this->ctx && this->ctx->master) {
+                xlator_notify(this->ctx->master, event, this->graph, NULL);
+            }
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, this, NULL);
+                parent = parent->next;
+            }
+        } break;
+        case GF_EVENT_UPCALL: {
+            xlator_list_t *parent = this->parents;
+
+            if (!parent && this->ctx && this->ctx->master)
+                xlator_notify(this->ctx->master, event, data, NULL);
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, data, NULL);
+                parent = parent->next;
+            }
+        } break;
+        case GF_EVENT_CHILD_PING: {
+            xlator_list_t *parent = this->parents;
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    XLATOR_NOTIFY(ret, parent->xlator, event, this, data);
+                parent = parent->next;
+            }
+        } break;
+        case GF_EVENT_CLEANUP: {
+            xlator_list_t *list = this->children;
+
+            while (list) {
+                xlator_notify(list->xlator, event, this);
+                list = list->next;
+            }
+        } break;
+
+        default: {
+            xlator_list_t *parent = this->parents;
+
+            while (parent) {
+                if (parent->xlator->init_succeeded)
+                    xlator_notify(parent->xlator, event, this, NULL);
+                parent = parent->next;
+            }
         }
-        break;
-        case GF_EVENT_CLEANUP:
-        {
-                xlator_list_t *list = this->children;
-
-                while (list) {
-                        xlator_notify (list->xlator, event, this);
-                        list = list->next;
-                }
-        }
-        break;
-
-        default:
-        {
-                xlator_list_t *parent = this->parents;
-
-                while (parent) {
-                        if (parent->xlator->init_succeeded)
-                                xlator_notify (parent->xlator, event,
-                                               this, NULL);
-                        parent = parent->next;
-                }
-        }
-        /*
-         * Apparently our picky-about-everything else coding standard allows
-         * adjacent same-indendation-level close braces.  Clearly it has
-         * nothing to do with readability.
-         */
-        }
-
-        return 0;
+            /*
+             * Apparently our picky-about-everything else coding standard allows
+             * adjacent same-indendation-level close braces.  Clearly it has
+             * nothing to do with readability.
+             */
+    }
+
+    return 0;
 }
 
 int32_t
-default_mem_acct_init (xlator_t *this)
+default_mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_common_mt_end);
+    ret = xlator_mem_acct_init(this, gf_common_mt_end);
 
-        return ret;
+    return ret;
 }
 
 void
-default_fini (xlator_t *this)
+default_fini(xlator_t *this)
 {
-        if (this && this->private)
-                GF_FREE (this->private);
+    if (this && this->private)
+        GF_FREE(this->private);
 }
diff --git a/libglusterfs/src/dict.c b/libglusterfs/src/dict.c
index b7cf2b0c8fe..2e69da98fdc 100644
--- a/libglusterfs/src/dict.c
+++ b/libglusterfs/src/dict.c
@@ -31,213 +31,209 @@
 #include "glusterfs-fops.h"
 
 struct dict_cmp {
-        dict_t *dict;
-        gf_boolean_t (*value_ignore) (char *k);
+    dict_t *dict;
+    gf_boolean_t (*value_ignore)(char *k);
 };
 
-#define VALIDATE_DATA_AND_LOG(data, type, key, ret_val) do {                 \
-                if (!data || !data->data) {                             \
-                        gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL, \
-                                          LG_MSG_INVALID_ARG, "data is NULL"); \
-                        return ret_val;                                 \
-                }                                                       \
-                /* Not of the asked type, or old version */             \
-                if ((data->data_type != type) &&                        \
-                    (data->data_type != GF_DATA_TYPE_STR_OLD)) {        \
-                        gf_msg_callingfn ("dict", GF_LOG_INFO, EINVAL,  \
-                                          LG_MSG_INVALID_ARG,           \
-                                          "key %s, %s type asked, has %s type", \
-                                          key, data_type_name[type],         \
-                                          data_type_name[data->data_type]); \
-                }                                                       \
-        } while (0)
+#define VALIDATE_DATA_AND_LOG(data, type, key, ret_val)                        \
+    do {                                                                       \
+        if (!data || !data->data) {                                            \
+            gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL,                   \
+                             LG_MSG_INVALID_ARG, "data is NULL");              \
+            return ret_val;                                                    \
+        }                                                                      \
+        /* Not of the asked type, or old version */                            \
+        if ((data->data_type != type) &&                                       \
+            (data->data_type != GF_DATA_TYPE_STR_OLD)) {                       \
+            gf_msg_callingfn("dict", GF_LOG_INFO, EINVAL, LG_MSG_INVALID_ARG,  \
+                             "key %s, %s type asked, has %s type", key,        \
+                             data_type_name[type],                             \
+                             data_type_name[data->data_type]);                 \
+        }                                                                      \
+    } while (0)
 
 static data_t *
-get_new_data ()
+get_new_data()
 {
-        data_t *data = NULL;
+    data_t *data = NULL;
 
-        data = mem_get (THIS->ctx->dict_data_pool);
-        if (!data)
-                return NULL;
+    data = mem_get(THIS->ctx->dict_data_pool);
+    if (!data)
+        return NULL;
 
-        GF_ATOMIC_INIT (data->refcount, 0);
-        data->is_static = _gf_false;
-        LOCK_INIT (&data->lock);
+    GF_ATOMIC_INIT(data->refcount, 0);
+    data->is_static = _gf_false;
+    LOCK_INIT(&data->lock);
 
-        return data;
+    return data;
 }
 
 static dict_t *
-get_new_dict_full (int size_hint)
+get_new_dict_full(int size_hint)
 {
-        dict_t *dict = mem_get0 (THIS->ctx->dict_pool);
+    dict_t *dict = mem_get0(THIS->ctx->dict_pool);
 
-        if (!dict) {
-                return NULL;
-        }
+    if (!dict) {
+        return NULL;
+    }
 
-        dict->hash_size = size_hint;
-        if (size_hint == 1) {
-                /*
-                 * This is the only case we ever see currently.  If we ever
-                 * need to support resizing the hash table, the resize function
-                 * will have to take into account the possibility that
-                 * "members" is not separately allocated (i.e. don't just call
-                 * realloc() blindly.
-                 */
-                dict->members = &dict->members_internal;
-        }
-        else {
-                /*
-                 * We actually need to allocate space for size_hint *pointers*
-                 * but we actually allocate space for one *structure*.  Since
-                 * a data_pair_t consists of five pointers, we're wasting four
-                 * pointers' worth for N=1, and will overrun what we allocated
-                 * for N>5.  If anybody ever starts using size_hint, we'll need
-                 * to fix this.
-                 */
-                GF_ASSERT (size_hint <=
-                           (sizeof(data_pair_t) / sizeof(data_pair_t *)));
-                dict->members = mem_get0 (THIS->ctx->dict_pair_pool);
-                if (!dict->members) {
-                        mem_put (dict);
-                        return NULL;
-                }
+    dict->hash_size = size_hint;
+    if (size_hint == 1) {
+        /*
+         * This is the only case we ever see currently.  If we ever
+         * need to support resizing the hash table, the resize function
+         * will have to take into account the possibility that
+         * "members" is not separately allocated (i.e. don't just call
+         * realloc() blindly.
+         */
+        dict->members = &dict->members_internal;
+    } else {
+        /*
+         * We actually need to allocate space for size_hint *pointers*
+         * but we actually allocate space for one *structure*.  Since
+         * a data_pair_t consists of five pointers, we're wasting four
+         * pointers' worth for N=1, and will overrun what we allocated
+         * for N>5.  If anybody ever starts using size_hint, we'll need
+         * to fix this.
+         */
+        GF_ASSERT(size_hint <= (sizeof(data_pair_t) / sizeof(data_pair_t *)));
+        dict->members = mem_get0(THIS->ctx->dict_pair_pool);
+        if (!dict->members) {
+            mem_put(dict);
+            return NULL;
         }
+    }
 
-        LOCK_INIT (&dict->lock);
+    LOCK_INIT(&dict->lock);
 
-        return dict;
+    return dict;
 }
 
 dict_t *
-get_new_dict (void)
+get_new_dict(void)
 {
-        return get_new_dict_full (1);
+    return get_new_dict_full(1);
 }
 
 dict_t *
-dict_new (void)
+dict_new(void)
 {
-        dict_t *dict = NULL;
+    dict_t *dict = NULL;
 
-        dict = get_new_dict_full(1);
+    dict = get_new_dict_full(1);
 
-        if (dict)
-                dict_ref (dict);
+    if (dict)
+        dict_ref(dict);
 
-        return dict;
+    return dict;
 }
 
 int32_t
-is_data_equal (data_t *one,
-               data_t *two)
+is_data_equal(data_t *one, data_t *two)
 {
-        struct iatt *iatt1, *iatt2;
+    struct iatt *iatt1, *iatt2;
+
+    if (!one || !two || !one->data || !two->data) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "input arguments are provided "
+                         "with value data_t as NULL");
+        return -1;
+    }
 
-        if (!one || !two || !one->data || !two->data) {
-		gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-				  "input arguments are provided "
-				  "with value data_t as NULL");
-                return -1;
-	}
+    if (one == two)
+        return 1;
 
-        if (one == two)
-                return 1;
+    if (one->data == two->data)
+        return 1;
 
-        if (one->data == two->data)
-                return 1;
+    if (one->data_type != two->data_type) {
+        return 0;
+    }
 
-        if (one->data_type != two->data_type) {
-                return 0;
+    if (one->data_type == GF_DATA_TYPE_IATT) {
+        if ((one->len < sizeof(struct iatt)) ||
+            (two->len < sizeof(struct iatt))) {
+            return 0;
         }
 
-        if (one->data_type == GF_DATA_TYPE_IATT) {
-                if ((one->len < sizeof(struct iatt)) ||
-                    (two->len < sizeof(struct iatt))) {
-                        return 0;
-                }
+        iatt1 = (struct iatt *)one->data;
+        iatt2 = (struct iatt *)two->data;
 
-                iatt1 = (struct iatt *)one->data;
-                iatt2 = (struct iatt *)two->data;
+        /* Two iatt structs are considered equal if main fields are
+         * equal, even if times differ.
+         * TODO: maybe when ctime if fully operational we could
+         *       enforce time matching. */
+        if (iatt1->ia_ino != iatt2->ia_ino) {
+            return 0;
+        }
+        if (iatt1->ia_type != iatt2->ia_type) {
+            return 0;
+        }
+        if ((iatt1->ia_type == IA_IFBLK) || (iatt1->ia_type == IA_IFCHR)) {
+            if (iatt1->ia_rdev != iatt2->ia_rdev) {
+                return 0;
+            }
+        }
+        if (gf_uuid_compare(iatt1->ia_gfid, iatt2->ia_gfid) != 0) {
+            return 0;
+        }
 
-                /* Two iatt structs are considered equal if main fields are
-                 * equal, even if times differ.
-                 * TODO: maybe when ctime if fully operational we could
-                 *       enforce time matching. */
-                if (iatt1->ia_ino != iatt2->ia_ino) {
-                        return 0;
-                }
-                if (iatt1->ia_type != iatt2->ia_type) {
-                        return 0;
-                }
-                if ((iatt1->ia_type == IA_IFBLK) ||
-                    (iatt1->ia_type == IA_IFCHR)) {
-                        if (iatt1->ia_rdev != iatt2->ia_rdev) {
-                                return 0;
+        /* TODO: ia_uid, ia_gid, ia_prot and ia_size can be changed
+         *       with some commands. Here we don't have enough
+         *       information to decide if they should match or not. */
+        /*
+                        if ((iatt1->ia_uid != iatt2->ia_uid) ||
+                            (iatt1->ia_gid != iatt2->ia_gid) ||
+                            (st_mode_from_ia(iatt1->ia_prot, iatt1->ia_type) !=
+                                    st_mode_from_ia(iatt2->ia_prot,
+           iatt2->ia_type))) { return 0;
                         }
-                }
-                if (gf_uuid_compare(iatt1->ia_gfid, iatt2->ia_gfid) != 0) {
-                        return 0;
-                }
-
-                /* TODO: ia_uid, ia_gid, ia_prot and ia_size can be changed
-                 *       with some commands. Here we don't have enough
-                 *       information to decide if they should match or not. */
-/*
-                if ((iatt1->ia_uid != iatt2->ia_uid) ||
-                    (iatt1->ia_gid != iatt2->ia_gid) ||
-                    (st_mode_from_ia(iatt1->ia_prot, iatt1->ia_type) !=
-                            st_mode_from_ia(iatt2->ia_prot, iatt2->ia_type))) {
-                        return 0;
-                }
-                if (iatt1->ia_type == IA_IFREG) {
-                        if (iatt1->ia_size != iatt2->ia_size) {
-                                return 0;
+                        if (iatt1->ia_type == IA_IFREG) {
+                                if (iatt1->ia_size != iatt2->ia_size) {
+                                        return 0;
+                                }
                         }
-                }
-*/
-                return 1;
-        }
+        */
+        return 1;
+    }
 
-        if (one->len != two->len)
-                return 0;
+    if (one->len != two->len)
+        return 0;
 
-        if (memcmp (one->data, two->data, one->len) == 0)
-                return 1;
+    if (memcmp(one->data, two->data, one->len) == 0)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 static int
-key_value_cmp (dict_t *one, char *key1, data_t *value1, void *data)
+key_value_cmp(dict_t *one, char *key1, data_t *value1, void *data)
 {
-        struct dict_cmp *cmp = data;
-        dict_t *two = NULL;
-        data_t *value2 = NULL;
+    struct dict_cmp *cmp = data;
+    dict_t *two = NULL;
+    data_t *value2 = NULL;
 
-        two = cmp->dict;
-        value2 = dict_get (two, key1);
+    two = cmp->dict;
+    value2 = dict_get(two, key1);
 
-        if (value2) {
-                if (cmp->value_ignore && cmp->value_ignore (key1))
-                        return 0;
+    if (value2) {
+        if (cmp->value_ignore && cmp->value_ignore(key1))
+            return 0;
 
-                if (is_data_equal (value1, value2) == 1)
-                        return 0;
-        }
+        if (is_data_equal(value1, value2) == 1)
+            return 0;
+    }
 
-        if (value2 == NULL) {
-                gf_msg_debug (THIS->name, 0, "'%s' found only on one dict",
-                              key1);
-        } else {
-                gf_msg_debug (THIS->name, 0, "'%s' is different in two dicts "
-                              "(%u, %u)", key1, value1->len, value2->len);
-        }
+    if (value2 == NULL) {
+        gf_msg_debug(THIS->name, 0, "'%s' found only on one dict", key1);
+    } else {
+        gf_msg_debug(THIS->name, 0,
+                     "'%s' is different in two dicts "
+                     "(%u, %u)",
+                     key1, value1->len, value2->len);
+    }
 
-        return -1;
+    return -1;
 }
 
 /* If both dicts are NULL then equal. If one of the dicts is NULL but the
@@ -248,93 +244,92 @@ key_value_cmp (dict_t *one, char *key1, data_t *value1, void *data)
  * different.
  */
 gf_boolean_t
-are_dicts_equal (dict_t *one, dict_t *two,
-                 gf_boolean_t (*match) (dict_t *d, char *k, data_t *v,
-                                        void *data),
-                 gf_boolean_t (*value_ignore) (char *k))
+are_dicts_equal(dict_t *one, dict_t *two,
+                gf_boolean_t (*match)(dict_t *d, char *k, data_t *v,
+                                      void *data),
+                gf_boolean_t (*value_ignore)(char *k))
 {
-        int     num_matches1 = 0;
-        int     num_matches2 = 0;
-        struct  dict_cmp cmp = {0};
+    int num_matches1 = 0;
+    int num_matches2 = 0;
+    struct dict_cmp cmp = {0};
 
-        if (one == two)
-                return _gf_true;
+    if (one == two)
+        return _gf_true;
 
-        if (!match)
-                match = dict_match_everything;
+    if (!match)
+        match = dict_match_everything;
 
-        if ((one == NULL) || (two == NULL)) {
-                num_matches1 = dict_foreach_match(one ? one : two, match, NULL,
-                                                  dict_null_foreach_fn, NULL);
-                goto done;
-        }
+    if ((one == NULL) || (two == NULL)) {
+        num_matches1 = dict_foreach_match(one ? one : two, match, NULL,
+                                          dict_null_foreach_fn, NULL);
+        goto done;
+    }
 
-        cmp.dict = two;
-        cmp.value_ignore = value_ignore;
-        num_matches1 = dict_foreach_match (one, match, NULL, key_value_cmp,
-                                           &cmp);
+    cmp.dict = two;
+    cmp.value_ignore = value_ignore;
+    num_matches1 = dict_foreach_match(one, match, NULL, key_value_cmp, &cmp);
 
-        if (num_matches1 == -1)
-                return _gf_false;
+    if (num_matches1 == -1)
+        return _gf_false;
 
-        if ((num_matches1 == one->count) && (one->count == two->count))
-                return _gf_true;
+    if ((num_matches1 == one->count) && (one->count == two->count))
+        return _gf_true;
 
-        num_matches2 = dict_foreach_match (two, match, NULL,
-                                           dict_null_foreach_fn, NULL);
+    num_matches2 = dict_foreach_match(two, match, NULL, dict_null_foreach_fn,
+                                      NULL);
 done:
-        /* If the number of matches is same in 'two' then for all the
-         * valid-keys that exist in 'one' the value matched and no extra valid
-         * keys exist in 'two' alone. Otherwise there exists at least one extra
-         * valid-key in 'two' which doesn't exist in 'one' */
-        if (num_matches1 == num_matches2)
-                return _gf_true;
-        return _gf_false;
+    /* If the number of matches is same in 'two' then for all the
+     * valid-keys that exist in 'one' the value matched and no extra valid
+     * keys exist in 'two' alone. Otherwise there exists at least one extra
+     * valid-key in 'two' which doesn't exist in 'one' */
+    if (num_matches1 == num_matches2)
+        return _gf_true;
+    return _gf_false;
 }
 
 void
-data_destroy (data_t *data)
+data_destroy(data_t *data)
 {
-        if (data) {
-                LOCK_DESTROY (&data->lock);
+    if (data) {
+        LOCK_DESTROY(&data->lock);
 
-                if (!data->is_static)
-                        GF_FREE (data->data);
+        if (!data->is_static)
+            GF_FREE(data->data);
 
-                data->len = 0xbabababa;
-                mem_put (data);
-        }
+        data->len = 0xbabababa;
+        mem_put(data);
+    }
 }
 
 data_t *
-data_copy (data_t *old)
+data_copy(data_t *old)
 {
-        if (!old) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, 0, LG_MSG_NULL_PTR,
-                                  "old is NULL");
-                return NULL;
-        }
+    if (!old) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, 0, LG_MSG_NULL_PTR,
+                         "old is NULL");
+        return NULL;
+    }
 
-        data_t *newdata = mem_get0 (THIS->ctx->dict_data_pool);
-        if (!newdata) {
-                return NULL;
-        }
+    data_t *newdata = mem_get0(THIS->ctx->dict_data_pool);
+    if (!newdata) {
+        return NULL;
+    }
 
-        newdata->len = old->len;
-        if (old->data) {
-                newdata->data = memdup (old->data, old->len);
-                if (!newdata->data)
-                        goto err_out;
-        }
-        newdata->data_type = old->data_type;
+    newdata->len = old->len;
+    if (old->data) {
+        newdata->data = memdup(old->data, old->len);
+        if (!newdata->data)
+            goto err_out;
+    }
+    newdata->data_type = old->data_type;
 
-        LOCK_INIT (&newdata->lock);
-        return newdata;
+    LOCK_INIT(&newdata->lock);
+    return newdata;
 
 err_out:
-        mem_put (newdata);
+    mem_put(newdata);
 
-        return NULL;
+    return NULL;
 }
 
 /* Always need to be called under lock
@@ -342,986 +337,962 @@ err_out:
  * checked by callers.
  */
 static data_pair_t *
-dict_lookup_common (dict_t *this, char *key, uint32_t hash)
+dict_lookup_common(dict_t *this, char *key, uint32_t hash)
 {
-        int hashval = 0;
-        data_pair_t *pair;
+    int hashval = 0;
+    data_pair_t *pair;
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        if (this->hash_size != 1)
-                hashval = hash % this->hash_size;
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1)
+        hashval = hash % this->hash_size;
 
-        for (pair = this->members[hashval]; pair != NULL; pair = pair->hash_next) {
-                if (pair->key && (hash == pair->key_hash) &&
-                    !strcmp (pair->key, key))
-                        return pair;
-        }
+    for (pair = this->members[hashval]; pair != NULL; pair = pair->hash_next) {
+        if (pair->key && (hash == pair->key_hash) && !strcmp(pair->key, key))
+            return pair;
+    }
 
-        return NULL;
+    return NULL;
 }
 
 int32_t
-dict_lookup (dict_t *this, char *key, data_t **data)
+dict_lookup(dict_t *this, char *key, data_t **data)
 {
-        uint32_t hash;
+    uint32_t hash;
 
-        if (!this || !key || !data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || !key || "
-                                  "!data");
-                return -1;
-        }
+    if (!this || !key || !data) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !key || "
+                         "!data");
+        return -1;
+    }
 
-        data_pair_t *tmp = NULL;
+    data_pair_t *tmp = NULL;
 
-        hash = SuperFastHash (key, strlen (key));
+    hash = SuperFastHash(key, strlen(key));
 
-        LOCK (&this->lock);
-        {
-                tmp = dict_lookup_common (this, key, hash);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        tmp = dict_lookup_common(this, key, hash);
+    }
+    UNLOCK(&this->lock);
 
-        if (!tmp)
-                return -1;
+    if (!tmp)
+        return -1;
 
-        *data = tmp->value;
-        return 0;
+    *data = tmp->value;
+    return 0;
 }
 
 static int32_t
-dict_set_lk (dict_t *this, char *key, data_t *value, const uint32_t hash, gf_boolean_t replace)
-{
-        int hashval = 0;
-        data_pair_t *pair;
-        int key_free = 0;
-        uint32_t key_hash;
-        int keylen;
-
-        if (!key) {
-                keylen = gf_asprintf (&key, "ref:%p", value);
-                if (-1 == keylen) {
-                        return -1;
-                }
-                key_free = 1;
-                key_hash = SuperFastHash (key, keylen);
-        }
-        else {
-                keylen = strlen(key);
-                key_hash = hash;
-        }
-
-        /* Search for a existing key if 'replace' is asked for */
-        if (replace) {
-                pair = dict_lookup_common (this, key, key_hash);
-
-                if (pair) {
-                        data_t *unref_data = pair->value;
-                        pair->value = data_ref (value);
-                        data_unref (unref_data);
-                        if (key_free)
-                                GF_FREE (key);
-                        /* Indicates duplicate key */
-                        return 0;
-                }
-        }
-
-        if (this->free_pair_in_use) {
-                pair = mem_get (THIS->ctx->dict_pair_pool);
-                if (!pair) {
-                        if (key_free)
-                                GF_FREE (key);
-                        return -1;
-                }
-        }
-        else {
-                pair = &this->free_pair;
-                this->free_pair_in_use = _gf_true;
-        }
-
-        if (key_free) {
-                /* It's ours.  Use it. */
-                pair->key = key;
-                key_free = 0;
-        }
-        else {
-                pair->key = (char *) GF_MALLOC (keylen + 1,
-                                                gf_common_mt_char);
-                if (!pair->key) {
-                        if (pair == &this->free_pair) {
-                                this->free_pair_in_use = _gf_false;
-                        }
-                        else {
-                                mem_put (pair);
-                        }
-                        return -1;
-                }
-                strcpy (pair->key, key);
-        }
-        pair->key_hash = key_hash;
-        pair->value = data_ref (value);
+dict_set_lk(dict_t *this, char *key, data_t *value, const uint32_t hash,
+            gf_boolean_t replace)
+{
+    int hashval = 0;
+    data_pair_t *pair;
+    int key_free = 0;
+    uint32_t key_hash;
+    int keylen;
+
+    if (!key) {
+        keylen = gf_asprintf(&key, "ref:%p", value);
+        if (-1 == keylen) {
+            return -1;
+        }
+        key_free = 1;
+        key_hash = SuperFastHash(key, keylen);
+    } else {
+        keylen = strlen(key);
+        key_hash = hash;
+    }
+
+    /* Search for a existing key if 'replace' is asked for */
+    if (replace) {
+        pair = dict_lookup_common(this, key, key_hash);
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        if (this->hash_size != 1) {
-                hashval = (key_hash % this->hash_size);
-        }
-        pair->hash_next = this->members[hashval];
-        this->members[hashval] = pair;
-
-        pair->next = this->members_list;
-        pair->prev = NULL;
-        if (this->members_list)
-                this->members_list->prev = pair;
-        this->members_list = pair;
-        this->count++;
-
-        if (key_free)
-                GF_FREE (key);
-
-        if (this->max_count < this->count)
-                this->max_count = this->count;
-        return 0;
+        if (pair) {
+            data_t *unref_data = pair->value;
+            pair->value = data_ref(value);
+            data_unref(unref_data);
+            if (key_free)
+                GF_FREE(key);
+            /* Indicates duplicate key */
+            return 0;
+        }
+    }
+
+    if (this->free_pair_in_use) {
+        pair = mem_get(THIS->ctx->dict_pair_pool);
+        if (!pair) {
+            if (key_free)
+                GF_FREE(key);
+            return -1;
+        }
+    } else {
+        pair = &this->free_pair;
+        this->free_pair_in_use = _gf_true;
+    }
+
+    if (key_free) {
+        /* It's ours.  Use it. */
+        pair->key = key;
+        key_free = 0;
+    } else {
+        pair->key = (char *)GF_MALLOC(keylen + 1, gf_common_mt_char);
+        if (!pair->key) {
+            if (pair == &this->free_pair) {
+                this->free_pair_in_use = _gf_false;
+            } else {
+                mem_put(pair);
+            }
+            return -1;
+        }
+        strcpy(pair->key, key);
+    }
+    pair->key_hash = key_hash;
+    pair->value = data_ref(value);
+
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1) {
+        hashval = (key_hash % this->hash_size);
+    }
+    pair->hash_next = this->members[hashval];
+    this->members[hashval] = pair;
+
+    pair->next = this->members_list;
+    pair->prev = NULL;
+    if (this->members_list)
+        this->members_list->prev = pair;
+    this->members_list = pair;
+    this->count++;
+
+    if (key_free)
+        GF_FREE(key);
+
+    if (this->max_count < this->count)
+        this->max_count = this->count;
+    return 0;
 }
 
 int32_t
-dict_set (dict_t *this,
-          char *key,
-          data_t *value)
+dict_set(dict_t *this, char *key, data_t *value)
 {
-        if (key)
-                return dict_setn (this, key, strlen (key), value);
-        else
-                return dict_setn (this, NULL, 0, value);
+    if (key)
+        return dict_setn(this, key, strlen(key), value);
+    else
+        return dict_setn(this, NULL, 0, value);
 }
 
 int32_t
-dict_setn (dict_t *this,
-          char *key,
-          const int keylen,
-          data_t *value)
-{
-        int32_t ret;
-        uint32_t key_hash = 0;
-
-        if (!this || !value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || !value for "
-                                  "key=%s", key);
-                return -1;
-        }
+dict_setn(dict_t *this, char *key, const int keylen, data_t *value)
+{
+    int32_t ret;
+    uint32_t key_hash = 0;
 
-        if (key) {
-                key_hash = SuperFastHash (key, keylen);
-        }
+    if (!this || !value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !value for "
+                         "key=%s",
+                         key);
+        return -1;
+    }
 
-        LOCK (&this->lock);
+    if (key) {
+        key_hash = SuperFastHash(key, keylen);
+    }
 
-        ret = dict_set_lk (this, key, value, key_hash, 1);
+    LOCK(&this->lock);
 
-        UNLOCK (&this->lock);
+    ret = dict_set_lk(this, key, value, key_hash, 1);
 
-        return ret;
-}
+    UNLOCK(&this->lock);
 
+    return ret;
+}
 
 int32_t
-dict_add (dict_t *this, char *key, data_t *value)
+dict_add(dict_t *this, char *key, data_t *value)
 {
-        if (key)
-                return dict_addn(this, key, strlen (key), value);
-        else
-                return dict_addn(this, NULL, 0, value);
+    if (key)
+        return dict_addn(this, key, strlen(key), value);
+    else
+        return dict_addn(this, NULL, 0, value);
 }
 
 int32_t
-dict_addn (dict_t *this, char *key, const int keylen, data_t *value)
+dict_addn(dict_t *this, char *key, const int keylen, data_t *value)
 {
-        int32_t ret;
-        uint32_t key_hash = 0;
+    int32_t ret;
+    uint32_t key_hash = 0;
 
-        if (!this || !value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || !value for key=%s", key);
-                return -1;
-        }
+    if (!this || !value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || !value for key=%s", key);
+        return -1;
+    }
 
-        if (key) {
-                key_hash = SuperFastHash (key, keylen);
-        }
+    if (key) {
+        key_hash = SuperFastHash(key, keylen);
+    }
 
-        LOCK (&this->lock);
+    LOCK(&this->lock);
 
-        ret = dict_set_lk (this, key, value, key_hash, 0);
+    ret = dict_set_lk(this, key, value, key_hash, 0);
 
-        UNLOCK (&this->lock);
+    UNLOCK(&this->lock);
 
-        return ret;
+    return ret;
 }
 
-
 data_t *
-dict_get (dict_t *this, char *key)
+dict_get(dict_t *this, char *key)
 {
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_INFO, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || key=%s", (key) ? key : "()");
-                return NULL;
-        }
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_INFO, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", (key) ? key : "()");
+        return NULL;
+    }
 
-        return dict_getn(this, key, strlen (key));
+    return dict_getn(this, key, strlen(key));
 }
 
 data_t *
-dict_getn (dict_t *this, char *key, const int keylen)
+dict_getn(dict_t *this, char *key, const int keylen)
 {
-        data_pair_t *pair;
-        uint32_t hash;
+    data_pair_t *pair;
+    uint32_t hash;
 
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_INFO, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "!this || key=%s", (key) ? key : "()");
-                return NULL;
-        }
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_INFO, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", (key) ? key : "()");
+        return NULL;
+    }
 
-        hash = SuperFastHash (key, keylen);
+    hash = SuperFastHash(key, keylen);
 
-        LOCK (&this->lock);
-        {
-                pair = dict_lookup_common (this, key, hash);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
+    }
+    UNLOCK(&this->lock);
 
-        if (pair)
-                return pair->value;
+    if (pair)
+        return pair->value;
 
-        return NULL;
+    return NULL;
 }
 
 int
-dict_key_count (dict_t *this)
+dict_key_count(dict_t *this)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict passed is NULL");
-                return ret;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict passed is NULL");
+        return ret;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = this->count;
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = this->count;
+    }
+    UNLOCK(&this->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-dict_del (dict_t *this, char *key)
+dict_del(dict_t *this, char *key)
 {
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || key=%s", key);
-                return;
-        }
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", key);
+        return;
+    }
 
-        return dict_deln(this, key, strlen (key));
+    return dict_deln(this, key, strlen(key));
 }
 
 void
-dict_deln (dict_t *this, char *key, const int keylen)
+dict_deln(dict_t *this, char *key, const int keylen)
 {
-        int hashval = 0;
-        uint32_t hash;
+    int hashval = 0;
+    uint32_t hash;
 
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!this || key=%s", key);
-                return;
-        }
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!this || key=%s", key);
+        return;
+    }
 
-	hash = SuperFastHash (key, keylen);
+    hash = SuperFastHash(key, keylen);
 
-        LOCK (&this->lock);
+    LOCK(&this->lock);
 
-        /* If the divisor is 1, the modulo is always 0,
-         * in such case avoid hash calculation.
-         */
-        if (this->hash_size != 1)
-                hashval = hash % this->hash_size;
+    /* If the divisor is 1, the modulo is always 0,
+     * in such case avoid hash calculation.
+     */
+    if (this->hash_size != 1)
+        hashval = hash % this->hash_size;
 
-        data_pair_t *pair = this->members[hashval];
-        data_pair_t *prev = NULL;
+    data_pair_t *pair = this->members[hashval];
+    data_pair_t *prev = NULL;
 
-        while (pair) {
-                if ((hash == pair->key_hash) && strcmp (pair->key, key) == 0) {
-                        if (prev)
-                                prev->hash_next = pair->hash_next;
-                        else
-                                this->members[hashval] = pair->hash_next;
+    while (pair) {
+        if ((hash == pair->key_hash) && strcmp(pair->key, key) == 0) {
+            if (prev)
+                prev->hash_next = pair->hash_next;
+            else
+                this->members[hashval] = pair->hash_next;
 
-                        data_unref (pair->value);
+            data_unref(pair->value);
 
-                        if (pair->prev)
-                                pair->prev->next = pair->next;
-                        else
-                                this->members_list = pair->next;
+            if (pair->prev)
+                pair->prev->next = pair->next;
+            else
+                this->members_list = pair->next;
 
-                        if (pair->next)
-                                pair->next->prev = pair->prev;
+            if (pair->next)
+                pair->next->prev = pair->prev;
 
-                        GF_FREE (pair->key);
-                        if (pair == &this->free_pair) {
-                                this->free_pair_in_use = _gf_false;
-                        }
-                        else {
-                                mem_put (pair);
-                        }
-                        this->count--;
-                        break;
-                }
-
-                prev = pair;
-                pair = pair->hash_next;
+            GF_FREE(pair->key);
+            if (pair == &this->free_pair) {
+                this->free_pair_in_use = _gf_false;
+            } else {
+                mem_put(pair);
+            }
+            this->count--;
+            break;
         }
 
-        UNLOCK (&this->lock);
+        prev = pair;
+        pair = pair->hash_next;
+    }
 
-        return;
+    UNLOCK(&this->lock);
+
+    return;
 }
 
 void
-dict_destroy (dict_t *this)
+dict_destroy(dict_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return;
+    }
 
-        data_pair_t *pair = this->members_list;
-        data_pair_t *prev = this->members_list;
-        glusterfs_ctx_t *ctx = NULL;
-        uint64_t current_max = 0;
-        uint32_t total_pairs = 0;
+    data_pair_t *pair = this->members_list;
+    data_pair_t *prev = this->members_list;
+    glusterfs_ctx_t *ctx = NULL;
+    uint64_t current_max = 0;
+    uint32_t total_pairs = 0;
 
-        LOCK_DESTROY (&this->lock);
+    LOCK_DESTROY(&this->lock);
 
-        while (prev) {
-                pair = pair->next;
-                data_unref (prev->value);
-                GF_FREE (prev->key);
-                if (prev != &this->free_pair) {
-                        mem_put (prev);
-                }
-                total_pairs++;
-                prev = pair;
+    while (prev) {
+        pair = pair->next;
+        data_unref(prev->value);
+        GF_FREE(prev->key);
+        if (prev != &this->free_pair) {
+            mem_put(prev);
         }
+        total_pairs++;
+        prev = pair;
+    }
 
-        if (this->members != &this->members_internal) {
-                mem_put (this->members);
-        }
+    if (this->members != &this->members_internal) {
+        mem_put(this->members);
+    }
 
-        GF_FREE (this->extra_free);
-        free (this->extra_stdfree);
+    GF_FREE(this->extra_free);
+    free(this->extra_stdfree);
 
-        /* update 'ctx->stats.dict.details' using max_count */
-        ctx = THIS->ctx;
+    /* update 'ctx->stats.dict.details' using max_count */
+    ctx = THIS->ctx;
 
-        /* NOTE: below logic is not totaly race proof */
-        /* thread0 and thread1 gets current_max as 10 */
-        /* thread0 has 'this->max_count as 11 */
-        /* thread1 has 'this->max_count as 20 */
-        /* thread1 goes ahead and sets the max_dict_pairs to 20 */
-        /* thread0 then goes and sets it to 11 */
-        /* As it is for information purpose only, no functionality will be
-           broken by this, but a point to consider about ATOMIC macros. */
-        current_max = GF_ATOMIC_GET (ctx->stats.max_dict_pairs);
-        if (current_max < this->max_count)
-                GF_ATOMIC_INIT (ctx->stats.max_dict_pairs, this->max_count);
+    /* NOTE: below logic is not totaly race proof */
+    /* thread0 and thread1 gets current_max as 10 */
+    /* thread0 has 'this->max_count as 11 */
+    /* thread1 has 'this->max_count as 20 */
+    /* thread1 goes ahead and sets the max_dict_pairs to 20 */
+    /* thread0 then goes and sets it to 11 */
+    /* As it is for information purpose only, no functionality will be
+       broken by this, but a point to consider about ATOMIC macros. */
+    current_max = GF_ATOMIC_GET(ctx->stats.max_dict_pairs);
+    if (current_max < this->max_count)
+        GF_ATOMIC_INIT(ctx->stats.max_dict_pairs, this->max_count);
 
-        GF_ATOMIC_ADD (ctx->stats.total_pairs_used, total_pairs);
-        GF_ATOMIC_INC (ctx->stats.total_dicts_used);
+    GF_ATOMIC_ADD(ctx->stats.total_pairs_used, total_pairs);
+    GF_ATOMIC_INC(ctx->stats.total_dicts_used);
 
-        mem_put (this);
+    mem_put(this);
 
-        return;
+    return;
 }
 
 void
-dict_unref (dict_t *this)
+dict_unref(dict_t *this)
 {
-        uint64_t ref = 0;
+    uint64_t ref = 0;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return;
+    }
 
-        ref = GF_ATOMIC_DEC (this->refcount);
+    ref = GF_ATOMIC_DEC(this->refcount);
 
-        if (!ref)
-                dict_destroy (this);
+    if (!ref)
+        dict_destroy(this);
 }
 
 dict_t *
-dict_ref (dict_t *this)
+dict_ref(dict_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return NULL;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (this->refcount);
-        return this;
+    GF_ATOMIC_INC(this->refcount);
+    return this;
 }
 
 void
-data_unref (data_t *this)
+data_unref(data_t *this)
 {
+    int32_t ref;
 
-        int32_t ref;
-
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return;
+    }
 
-        ref = GF_ATOMIC_DEC (this->refcount);
+    ref = GF_ATOMIC_DEC(this->refcount);
 
-        if (!ref)
-                data_destroy (this);
+    if (!ref)
+        data_destroy(this);
 }
 
 data_t *
-data_ref (data_t *this)
+data_ref(data_t *this)
 {
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "data is NULL");
-                return NULL;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "data is NULL");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (this->refcount);
+    GF_ATOMIC_INC(this->refcount);
 
-        return this;
+    return this;
 }
 
 data_t *
-int_to_data (int64_t value)
+int_to_data(int64_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
 
-        data->len = gf_asprintf (&data->data, "%"PRId64, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_INT;
+    data->len = gf_asprintf(&data->data, "%" PRId64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int64 (int64_t value)
+data_from_int64(int64_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRId64, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_INT;
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int32 (int32_t value)
+data_from_int32(int32_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRId32, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId32, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_INT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int16 (int16_t value)
+data_from_int16(int16_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRId16, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRId16, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_INT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_int8 (int8_t value)
+data_from_int8(int8_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%d", value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%d", value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_INT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_INT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_uint64 (uint64_t value)
+data_from_uint64(uint64_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRIu64, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu64, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_UINT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_double (double value)
+data_from_double(double value)
 {
-        data_t *data = NULL;
+    data_t *data = NULL;
 
-        data = get_new_data ();
+    data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
 
-        data->len = gf_asprintf (&data->data, "%f", value);
-        if (data->len == -1) {
-                return NULL;
-        }
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_DOUBLE;
+    data->len = gf_asprintf(&data->data, "%f", value);
+    if (data->len == -1) {
+        return NULL;
+    }
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_DOUBLE;
 
-        return data;
+    return data;
 }
 
-
 data_t *
-data_from_uint32 (uint32_t value)
+data_from_uint32(uint32_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRIu32, value);
-        if (-1 == data->len) {
-                gf_msg_debug ("dict", 0, "asprintf failed");
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu32, value);
+    if (-1 == data->len) {
+        gf_msg_debug("dict", 0, "asprintf failed");
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_UINT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
-
 data_t *
-data_from_uint16 (uint16_t value)
+data_from_uint16(uint16_t value)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = gf_asprintf (&data->data, "%"PRIu16, value);
-        if (-1 == data->len) {
-                return NULL;
-        }
+    if (!data) {
+        return NULL;
+    }
+    data->len = gf_asprintf(&data->data, "%" PRIu16, value);
+    if (-1 == data->len) {
+        return NULL;
+    }
 
-        data->len++; /* account for terminating NULL */
-        data->data_type = GF_DATA_TYPE_UINT;
+    data->len++; /* account for terminating NULL */
+    data->data_type = GF_DATA_TYPE_UINT;
 
-        return data;
+    return data;
 }
 
 static data_t *
-data_from_ptr_common (void *value, gf_boolean_t is_static)
+data_from_ptr_common(void *value, gf_boolean_t is_static)
 {
-        /* it is valid to set 0/NULL as a value, no need to check *value */
+    /* it is valid to set 0/NULL as a value, no need to check *value */
 
-        data_t *data = get_new_data ();
-        if (!data) {
-                return NULL;
-        }
+    data_t *data = get_new_data();
+    if (!data) {
+        return NULL;
+    }
 
-        data->data = value;
-	data->len = 0;
-        data->is_static = is_static;
+    data->data = value;
+    data->len = 0;
+    data->is_static = is_static;
 
-        data->data_type = GF_DATA_TYPE_PTR;
-        return data;
+    data->data_type = GF_DATA_TYPE_PTR;
+    return data;
 }
 
 data_t *
-str_to_data (char *value)
+str_to_data(char *value)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        return strn_to_data(value, strlen (value));
+    return strn_to_data(value, strlen(value));
 }
 
 data_t *
-strn_to_data (char *value, const int vallen)
+strn_to_data(char *value, const int vallen)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
-        data_t *data = get_new_data ();
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
+    data_t *data = get_new_data();
 
-        if (!data) {
-                return NULL;
-        }
-        data->len = vallen + 1;
-        data->data_type = GF_DATA_TYPE_STR;
+    if (!data) {
+        return NULL;
+    }
+    data->len = vallen + 1;
+    data->data_type = GF_DATA_TYPE_STR;
 
-        data->data = value;
-        data->is_static = _gf_true;
+    data->data = value;
+    data->is_static = _gf_true;
 
-        return data;
+    return data;
 }
 
 static data_t *
-data_from_dynstr (char *value)
+data_from_dynstr(char *value)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
-        data->len = strlen (value) + 1;
-        data->data = value;
-        data->data_type = GF_DATA_TYPE_STR;
+    if (!data)
+        return NULL;
+    data->len = strlen(value) + 1;
+    data->data = value;
+    data->data_type = GF_DATA_TYPE_STR;
 
-        return data;
+    return data;
 }
 
 data_t *
-data_from_dynptr (void *value, int32_t len)
+data_from_dynptr(void *value, int32_t len)
 {
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
+    if (!data)
+        return NULL;
 
-        data->len = len;
-        data->data = value;
-        data->data_type = GF_DATA_TYPE_PTR;
+    data->len = len;
+    data->data = value;
+    data->data_type = GF_DATA_TYPE_PTR;
 
-        return data;
+    return data;
 }
 
 data_t *
-bin_to_data (void *value, int32_t len)
+bin_to_data(void *value, int32_t len)
 {
-        if (!value) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "value is NULL");
-                return NULL;
-        }
+    if (!value) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "value is NULL");
+        return NULL;
+    }
 
-        data_t *data = get_new_data ();
+    data_t *data = get_new_data();
 
-        if (!data)
-                return NULL;
+    if (!data)
+        return NULL;
 
-        data->is_static = _gf_true;
-        data->len = len;
-        data->data = value;
+    data->is_static = _gf_true;
+    data->len = len;
+    data->data = value;
 
-        return data;
+    return data;
 }
 
 static char *data_type_name[GF_DATA_TYPE_MAX] = {
-        [GF_DATA_TYPE_UNKNOWN] = "unknown",
-        [GF_DATA_TYPE_STR_OLD] = "string-old-version",
-        [GF_DATA_TYPE_INT] = "integer",
-        [GF_DATA_TYPE_UINT] = "unsigned integer",
-        [GF_DATA_TYPE_DOUBLE] = "float",
-        [GF_DATA_TYPE_STR] = "string",
-        [GF_DATA_TYPE_PTR] = "pointer",
-        [GF_DATA_TYPE_GFUUID] = "gf-uuid",
-        [GF_DATA_TYPE_IATT] = "iatt",
+    [GF_DATA_TYPE_UNKNOWN] = "unknown",
+    [GF_DATA_TYPE_STR_OLD] = "string-old-version",
+    [GF_DATA_TYPE_INT] = "integer",
+    [GF_DATA_TYPE_UINT] = "unsigned integer",
+    [GF_DATA_TYPE_DOUBLE] = "float",
+    [GF_DATA_TYPE_STR] = "string",
+    [GF_DATA_TYPE_PTR] = "pointer",
+    [GF_DATA_TYPE_GFUUID] = "gf-uuid",
+    [GF_DATA_TYPE_IATT] = "iatt",
 };
 
 int64_t
-data_to_int64 (data_t *data)
+data_to_int64(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
 
-        return (int64_t) strtoull (data->data, NULL, 0);
+    return (int64_t)strtoull(data->data, NULL, 0);
 }
 
 int32_t
-data_to_int32 (data_t *data)
+data_to_int32(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
 
-        return strtoul (data->data, NULL, 0);
+    return strtoul(data->data, NULL, 0);
 }
 
 int16_t
-data_to_int16 (data_t *data)
+data_to_int16(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
 
-        int16_t value = 0;
+    int16_t value = 0;
 
-        errno = 0;
-        value = strtol (data->data, NULL, 0);
+    errno = 0;
+    value = strtol(data->data, NULL, 0);
 
-        if ((value > SHRT_MAX) || (value < SHRT_MIN)) {
-                errno = ERANGE;
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "Error in data"
-                                  " conversion: detected overflow");
-                return -1;
-        }
+    if ((value > SHRT_MAX) || (value < SHRT_MIN)) {
+        errno = ERANGE;
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "Error in data"
+                         " conversion: detected overflow");
+        return -1;
+    }
 
-        return (int16_t)value;
+    return (int16_t)value;
 }
 
-
 int8_t
-data_to_int8 (data_t *data)
+data_to_int8(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, "null", -1);
 
-        int8_t value = 0;
+    int8_t value = 0;
 
-        errno = 0;
-        value = strtol (data->data, NULL, 0);
+    errno = 0;
+    value = strtol(data->data, NULL, 0);
 
-        if ((value > SCHAR_MAX) || (value < SCHAR_MIN)) {
-                errno = ERANGE;
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "Error in data"
-                                  " conversion: detected overflow");
-                return -1;
-        }
+    if ((value > SCHAR_MAX) || (value < SCHAR_MIN)) {
+        errno = ERANGE;
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "Error in data"
+                         " conversion: detected overflow");
+        return -1;
+    }
 
-        return (int8_t)value;
+    return (int8_t)value;
 }
 
-
 uint64_t
-data_to_uint64 (data_t *data)
+data_to_uint64(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
 
-        return strtoll (data->data, NULL, 0);
+    return strtoll(data->data, NULL, 0);
 }
 
 uint32_t
-data_to_uint32 (data_t *data)
+data_to_uint32(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
 
-        return strtol (data->data, NULL, 0);
+    return strtol(data->data, NULL, 0);
 }
 
 uint16_t
-data_to_uint16 (data_t *data)
+data_to_uint16(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
 
-	uint16_t value = 0;
+    uint16_t value = 0;
 
-	errno = 0;
-	value = strtol (data->data, NULL, 0);
+    errno = 0;
+    value = strtol(data->data, NULL, 0);
 
-	if ((USHRT_MAX - value) < 0) {
-		errno = ERANGE;
-		gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR,
-				  "Error in data conversion: "
-				  "overflow detected");
-		return -1;
-	}
+    if ((USHRT_MAX - value) < 0) {
+        errno = ERANGE;
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "Error in data conversion: "
+                         "overflow detected");
+        return -1;
+    }
 
-        return (uint16_t)value;
+    return (uint16_t)value;
 }
 
 uint8_t
-data_to_uint8 (data_t *data)
+data_to_uint8(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, "null", -1);
 
-	uint32_t value = 0;
+    uint32_t value = 0;
 
-	errno = 0;
-	value = strtol (data->data, NULL, 0);
+    errno = 0;
+    value = strtol(data->data, NULL, 0);
 
-	if ((UCHAR_MAX - (uint8_t)value) < 0) {
-		errno = ERANGE;
-		gf_msg_callingfn ("dict", GF_LOG_WARNING, errno,
-                                  LG_MSG_DATA_CONVERSION_ERROR, "data "
-                                  "conversion overflow detected");
-		return -1;
-	}
+    if ((UCHAR_MAX - (uint8_t)value) < 0) {
+        errno = ERANGE;
+        gf_msg_callingfn("dict", GF_LOG_WARNING, errno,
+                         LG_MSG_DATA_CONVERSION_ERROR,
+                         "data "
+                         "conversion overflow detected");
+        return -1;
+    }
 
-        return (uint8_t) value;
+    return (uint8_t)value;
 }
 
 char *
-data_to_str (data_t *data)
+data_to_str(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, "null", NULL);
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, "null", NULL);
+    return data->data;
 }
 
 void *
-data_to_ptr (data_t *data)
+data_to_ptr(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
+    return data->data;
 }
 
 void *
-data_to_bin (data_t *data)
+data_to_bin(data_t *data)
 {
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
-        return data->data;
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, "null", NULL);
+    return data->data;
 }
 
 struct iatt *
-data_to_iatt (data_t *data, char *key)
-{
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, NULL);
-
-        /* We only check for smaller size. If it's bigger we simply ignore
-         * the extra data. This way it's easy to do changes in the future that
-         * pass more data but are backward compatible (if the initial contents
-         * of the struct are maintained, of course). */
-        if (data->len < sizeof(struct iatt)) {
-                gf_msg("glusterfs", GF_LOG_ERROR, ENOBUFS,
-                       LG_MSG_UNDERSIZED_BUF,
-                       "data value for '%s' is smaller than expected", key);
-                return NULL;
-        }
+data_to_iatt(data_t *data, char *key)
+{
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, NULL);
 
-        return (struct iatt *)data->data;
+    /* We only check for smaller size. If it's bigger we simply ignore
+     * the extra data. This way it's easy to do changes in the future that
+     * pass more data but are backward compatible (if the initial contents
+     * of the struct are maintained, of course). */
+    if (data->len < sizeof(struct iatt)) {
+        gf_msg("glusterfs", GF_LOG_ERROR, ENOBUFS, LG_MSG_UNDERSIZED_BUF,
+               "data value for '%s' is smaller than expected", key);
+        return NULL;
+    }
+
+    return (struct iatt *)data->data;
 }
 
 int
-dict_null_foreach_fn (dict_t *d, char *k,
-                      data_t *v, void *tmp)
+dict_null_foreach_fn(dict_t *d, char *k, data_t *v, void *tmp)
 {
-        return 0;
+    return 0;
 }
 
 int
-dict_remove_foreach_fn (dict_t *d, char *k,
-                        data_t *v, void *_tmp)
-{
-        if (!d || !k) {
-                gf_msg ("glusterfs", GF_LOG_WARNING, EINVAL,
-                        LG_MSG_INVALID_ENTRY, "%s is NULL",
-                        d?"key":"dictionary");
-                return -1;
-        }
+dict_remove_foreach_fn(dict_t *d, char *k, data_t *v, void *_tmp)
+{
+    if (!d || !k) {
+        gf_msg("glusterfs", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ENTRY,
+               "%s is NULL", d ? "key" : "dictionary");
+        return -1;
+    }
 
-        dict_del (d, k);
-        return 0;
+    dict_del(d, k);
+    return 0;
 }
 
 gf_boolean_t
-dict_match_everything (dict_t *d, char *k, data_t *v, void *data)
+dict_match_everything(dict_t *d, char *k, data_t *v, void *data)
 {
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-dict_foreach (dict_t *dict,
-              int (*fn)(dict_t *this,
-                        char *key,
-                        data_t *value,
-                        void *data),
-              void *data)
+dict_foreach(dict_t *dict,
+             int (*fn)(dict_t *this, char *key, data_t *value, void *data),
+             void *data)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        ret = dict_foreach_match (dict, dict_match_everything, NULL, fn, data);
+    ret = dict_foreach_match(dict, dict_match_everything, NULL, fn, data);
 
-        if (ret > 0)
-                ret = 0;
+    if (ret > 0)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 /* return values:
@@ -1330,50 +1301,45 @@ dict_foreach (dict_t *dict,
    +n = n number of matches
 */
 int
-dict_foreach_match (dict_t *dict,
-             gf_boolean_t (*match)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *mdata),
-             void *match_data,
-             int (*action)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *adata),
-              void *action_data)
-{
-        if (!dict || !match || !action) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict|match|action is "
-                                  "NULL");
-                return -1;
-        }
-
-        int          ret   = -1;
-        int          count = 0;
-        data_pair_t *pairs = NULL;
-        data_pair_t *next  = NULL;
-
-        pairs = dict->members_list;
-        while (pairs) {
-                next = pairs->next;
-                if (match (dict, pairs->key, pairs->value, match_data)) {
-                        ret = action (dict, pairs->key, pairs->value,
-                                      action_data);
-                        if (ret < 0)
-                                return ret;
-                        count++;
-                }
-                pairs = next;
+dict_foreach_match(dict_t *dict,
+                   gf_boolean_t (*match)(dict_t *this, char *key, data_t *value,
+                                         void *mdata),
+                   void *match_data,
+                   int (*action)(dict_t *this, char *key, data_t *value,
+                                 void *adata),
+                   void *action_data)
+{
+    if (!dict || !match || !action) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict|match|action is "
+                         "NULL");
+        return -1;
+    }
+
+    int ret = -1;
+    int count = 0;
+    data_pair_t *pairs = NULL;
+    data_pair_t *next = NULL;
+
+    pairs = dict->members_list;
+    while (pairs) {
+        next = pairs->next;
+        if (match(dict, pairs->key, pairs->value, match_data)) {
+            ret = action(dict, pairs->key, pairs->value, action_data);
+            if (ret < 0)
+                return ret;
+            count++;
         }
+        pairs = next;
+    }
 
-        return count;
+    return count;
 }
 
 static gf_boolean_t
-dict_fnmatch (dict_t *d, char *k, data_t *val, void *match_data)
+dict_fnmatch(dict_t *d, char *k, data_t *val, void *match_data)
 {
-        return (fnmatch (match_data, k, 0) == 0);
+    return (fnmatch(match_data, k, 0) == 0);
 }
 /* return values:
    -1 = failure,
@@ -1381,17 +1347,14 @@ dict_fnmatch (dict_t *d, char *k, data_t *val, void *match_data)
    +n = n number of matches
 */
 int
-dict_foreach_fnmatch (dict_t *dict, char *pattern,
-                      int (*fn)(dict_t *this,
-                                char *key,
-                                data_t *value,
-                                void *data),
-                      void *data)
+dict_foreach_fnmatch(dict_t *dict, char *pattern,
+                     int (*fn)(dict_t *this, char *key, data_t *value,
+                               void *data),
+                     void *data)
 {
-        return dict_foreach_match (dict, dict_fnmatch, pattern, fn, data);
+    return dict_foreach_match(dict, dict_fnmatch, pattern, fn, data);
 }
 
-
 /**
  * dict_keys_join - pack the keys of the dictionary in a buffer.
  *
@@ -1406,89 +1369,86 @@ dict_foreach_fnmatch (dict_t *dict, char *pattern,
  */
 
 int
-dict_keys_join (void *value, int size, dict_t *dict,
-                int (*filter_fn)(char *k))
+dict_keys_join(void *value, int size, dict_t *dict, int (*filter_fn)(char *k))
 {
-	int          len = 0;
-        data_pair_t *pairs = NULL;
-        data_pair_t *next  = NULL;
+    int len = 0;
+    data_pair_t *pairs = NULL;
+    data_pair_t *next = NULL;
 
-        pairs = dict->members_list;
-        while (pairs) {
-                next = pairs->next;
+    pairs = dict->members_list;
+    while (pairs) {
+        next = pairs->next;
 
-                if (filter_fn && filter_fn (pairs->key)){
-		    pairs = next;
-		    continue;
-		}
+        if (filter_fn && filter_fn(pairs->key)) {
+            pairs = next;
+            continue;
+        }
 
-		if (value && (size > len))
-			strncpy (value + len, pairs->key, size - len);
+        if (value && (size > len))
+            strncpy(value + len, pairs->key, size - len);
 
-                len += (strlen (pairs->key) + 1);
+        len += (strlen(pairs->key) + 1);
 
-                pairs = next;
-        }
+        pairs = next;
+    }
 
-	return len;
+    return len;
 }
 
 static int
-dict_copy_one (dict_t *unused, char *key, data_t *value, void *newdict)
+dict_copy_one(dict_t *unused, char *key, data_t *value, void *newdict)
 {
-        return dict_set ((dict_t *)newdict, key, (value));
+    return dict_set((dict_t *)newdict, key, (value));
 }
 
 dict_t *
-dict_copy (dict_t *dict,
-           dict_t *new)
+dict_copy(dict_t *dict, dict_t *new)
 {
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return NULL;
-        }
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return NULL;
+    }
 
-        if (!new)
-                new = get_new_dict_full (dict->hash_size);
+    if (!new)
+        new = get_new_dict_full(dict->hash_size);
 
-        dict_foreach (dict, dict_copy_one, new);
+    dict_foreach(dict, dict_copy_one, new);
 
-        return new;
+    return new;
 }
 
 int
-dict_reset (dict_t *dict)
-{
-        int32_t         ret = -1;
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                goto out;
-        }
-        dict_foreach (dict, dict_remove_foreach_fn, NULL);
-        ret = 0;
+dict_reset(dict_t *dict)
+{
+    int32_t ret = -1;
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+    dict_foreach(dict, dict_remove_foreach_fn, NULL);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 dict_t *
-dict_copy_with_ref (dict_t *dict,
-                    dict_t *new)
+dict_copy_with_ref(dict_t *dict, dict_t *new)
 {
-        dict_t *local_new = NULL;
+    dict_t *local_new = NULL;
 
-        GF_VALIDATE_OR_GOTO("dict", dict, fail);
+    GF_VALIDATE_OR_GOTO("dict", dict, fail);
 
-        if (new == NULL) {
-                local_new = dict_new ();
-                GF_VALIDATE_OR_GOTO("dict", local_new, fail);
-                new = local_new;
-        }
+    if (new == NULL) {
+        local_new = dict_new();
+        GF_VALIDATE_OR_GOTO("dict", local_new, fail);
+        new = local_new;
+    }
 
-        dict_foreach (dict, dict_copy_one, new);
+    dict_foreach(dict, dict_copy_one, new);
 fail:
-        return new;
+    return new;
 }
 
 /*
@@ -1502,592 +1462,581 @@ fail:
  *               -val error, val = errno
  */
 
-
 int
-dict_get_with_ref (dict_t *this, char *key, data_t **data)
+dict_get_with_ref(dict_t *this, char *key, data_t **data)
 {
-        if (!this || !key || !data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "dict OR key (%s) is NULL", key);
-                return -EINVAL;
-        }
+    if (!this || !key || !data) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict OR key (%s) is NULL", key);
+        return -EINVAL;
+    }
 
-        return dict_get_with_refn(this, key, strlen (key), data);
+    return dict_get_with_refn(this, key, strlen(key), data);
 }
 
 int
-dict_get_with_refn (dict_t *this, char *key, const int keylen, data_t **data)
+dict_get_with_refn(dict_t *this, char *key, const int keylen, data_t **data)
 {
-        data_pair_t * pair = NULL;
-        int           ret  = -ENOENT;
-        uint32_t      hash;
+    data_pair_t *pair = NULL;
+    int ret = -ENOENT;
+    uint32_t hash;
 
-        if (!this || !key || !data) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "dict OR key (%s) is NULL", key);
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !data) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict OR key (%s) is NULL", key);
+        ret = -EINVAL;
+        goto err;
+    }
 
-        hash = SuperFastHash (key, keylen);
+    hash = SuperFastHash(key, keylen);
 
-        LOCK (&this->lock);
-        {
-                pair = dict_lookup_common (this, key, hash);
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
 
-                if (pair) {
-                        ret = 0;
-                        *data = data_ref (pair->value);
-                 }
+        if (pair) {
+            ret = 0;
+            *data = data_ref(pair->value);
         }
-        UNLOCK (&this->lock);
+    }
+    UNLOCK(&this->lock);
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_ptr_common (data_t *data, void **val)
+data_to_ptr_common(data_t *data, void **val)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        *val = data->data;
+    *val = data->data;
 err:
-        return ret;
+    return ret;
 }
 
-
 static int
-data_to_int8_ptr (data_t *data, int8_t *val)
+data_to_int8_ptr(data_t *data, int8_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int16_ptr (data_t *data, int16_t *val)
+data_to_int16_ptr(data_t *data, int16_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int32_ptr (data_t *data, int32_t *val)
+data_to_int32_ptr(data_t *data, int32_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtol (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtol(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_int64_ptr (data_t *data, int64_t *val)
+data_to_int64_ptr(data_t *data, int64_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtoll (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoll(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint16_ptr (data_t *data, uint16_t *val)
+data_to_uint16_ptr(data_t *data, uint16_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtoul (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoul(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint32_ptr (data_t *data, uint32_t *val)
+data_to_uint32_ptr(data_t *data, uint32_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtoul (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoul(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_uint64_ptr (data_t *data, uint64_t *val)
+data_to_uint64_ptr(data_t *data, uint64_t *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtoull (data->data, NULL, 0);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtoull(data->data, NULL, 0);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-data_to_double_ptr (data_t *data, double *val)
+data_to_double_ptr(data_t *data, double *val)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        if (!data || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!data || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        errno = 0;
-        *val = strtod (data->data, NULL);
-        if (errno != 0)
-                ret = -errno;
+    errno = 0;
+    *val = strtod(data->data, NULL);
+    if (errno != 0)
+        ret = -errno;
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int8 (dict_t *this, char *key, int8_t *val)
+dict_get_int8(dict_t *this, char *key, int8_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int8_ptr (data, val);
+    ret = data_to_int8_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_int8 (dict_t *this, char *key, int8_t val)
+dict_set_int8(dict_t *this, char *key, int8_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int8 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int8(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int16 (dict_t *this, char *key, int16_t *val)
+dict_get_int16(dict_t *this, char *key, int16_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int16_ptr (data, val);
+    ret = data_to_int16_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_int16 (dict_t *this, char *key, int16_t val)
+dict_set_int16(dict_t *this, char *key, int16_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int16 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int16(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int32n (dict_t *this, char *key, const int keylen, int32_t *val)
+dict_get_int32n(dict_t *this, char *key, const int keylen, int32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_refn (this, key, keylen, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_refn(this, key, keylen, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int32_ptr (data, val);
+    ret = data_to_int32_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_get_int32 (dict_t *this, char *key, int32_t *val)
+dict_get_int32(dict_t *this, char *key, int32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int32_ptr (data, val);
+    ret = data_to_int32_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_set_int32n (dict_t *this, char *key, const int keylen, int32_t val)
+dict_set_int32n(dict_t *this, char *key, const int keylen, int32_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int32 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int32(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_setn (this, key, keylen, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_set_int32 (dict_t *this, char *key, int32_t val)
+dict_set_int32(dict_t *this, char *key, int32_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int32 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int32(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_int64 (dict_t *this, char *key, int64_t *val)
+dict_get_int64(dict_t *this, char *key, int64_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = data_to_int64_ptr (data, val);
+    ret = data_to_int64_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_int64 (dict_t *this, char *key, int64_t val)
+dict_set_int64(dict_t *this, char *key, int64_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_int64 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_int64(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint16 (dict_t *this, char *key, uint16_t *val)
+dict_get_uint16(dict_t *this, char *key, uint16_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint16_ptr (data, val);
+    ret = data_to_uint16_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_uint16 (dict_t *this, char *key, uint16_t val)
+dict_set_uint16(dict_t *this, char *key, uint16_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_uint16 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_uint16(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint32 (dict_t *this, char *key, uint32_t *val)
+dict_get_uint32(dict_t *this, char *key, uint32_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint32_ptr (data, val);
+    ret = data_to_uint32_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
-
 int
-dict_set_uint32 (dict_t *this, char *key, uint32_t val)
+dict_set_uint32(dict_t *this, char *key, uint32_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_uint32 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_uint32(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_uint64 (dict_t *this, char *key, uint64_t *val)
+dict_get_uint64(dict_t *this, char *key, uint64_t *val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_UINT, key, -EINVAL);
 
-        ret = data_to_uint64_ptr (data, val);
+    ret = data_to_uint64_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
-
 int
-dict_set_uint64 (dict_t *this, char *key, uint64_t val)
+dict_set_uint64(dict_t *this, char *key, uint64_t val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_uint64 (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_uint64(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 /*
@@ -2100,23 +2049,23 @@ err:
  * <0: Error
  */
 int
-dict_check_flag (dict_t *this, char *key, int flag)
+dict_check_flag(dict_t *this, char *key, int flag)
 {
-        data_t  *data = NULL;
-        int     ret = -ENOENT;
+    data_t *data = NULL;
+    int ret = -ENOENT;
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                return ret;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        return ret;
+    }
 
-        if (BIT_VALUE((unsigned char *)(data->data), flag))
-                ret = 1;
-        else
-                ret = 0;
+    if (BIT_VALUE((unsigned char *)(data->data), flag))
+        ret = 1;
+    else
+        ret = 0;
 
-        data_unref(data);
-        return ret;
+    data_unref(data);
+    return ret;
 }
 
 /*
@@ -2125,138 +2074,128 @@ dict_check_flag (dict_t *this, char *key, int flag)
  * op: Indicates operation DICT_FLAG_SET / DICT_FLAG_CLEAR
  */
 static int
-_dict_modify_flag (dict_t *this, char *key, int flag, int op)
-{
-        data_t          *data           = NULL;
-        int             ret             = 0;
-        data_pair_t     *pair           = NULL;
-        char            *ptr            = NULL;
-        int             hashval         = 0;
-        uint32_t        hash;
-
-        if (!this || !key) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "dict OR key (%s) is NULL", key);
-                ret = -EINVAL;
-                goto err;
-        }
-
-        /*
-         * Using a size of 32 bytes to support max of 256
-         * flags in a single key. This should be suffcient.
-         */
-        GF_ASSERT(flag >= 0 && flag < DICT_MAX_FLAGS);
-
-        hash = SuperFastHash (key, strlen (key));
-        LOCK (&this->lock);
-        {
-                pair = dict_lookup_common (this, key, hash);
-
-                if (pair) {
-                        data = pair->value;
-                        if (op == DICT_FLAG_SET)
-                                BIT_SET((unsigned char *)(data->data), flag);
-                        else
-                                BIT_CLEAR((unsigned char *)(data->data), flag);
-                } else {
-                        ptr = GF_CALLOC(1, DICT_MAX_FLAGS / 8,
-                                        gf_common_mt_char);
-                        if (!ptr) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate flag bit array");
-                                ret = -ENOMEM;
-                                goto err;
-                        }
+_dict_modify_flag(dict_t *this, char *key, int flag, int op)
+{
+    data_t *data = NULL;
+    int ret = 0;
+    data_pair_t *pair = NULL;
+    char *ptr = NULL;
+    int hashval = 0;
+    uint32_t hash;
+
+    if (!this || !key) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict OR key (%s) is NULL", key);
+        ret = -EINVAL;
+        goto err;
+    }
+
+    /*
+     * Using a size of 32 bytes to support max of 256
+     * flags in a single key. This should be suffcient.
+     */
+    GF_ASSERT(flag >= 0 && flag < DICT_MAX_FLAGS);
+
+    hash = SuperFastHash(key, strlen(key));
+    LOCK(&this->lock);
+    {
+        pair = dict_lookup_common(this, key, hash);
 
-                        data = data_from_dynptr(ptr, DICT_MAX_FLAGS / 8);
-
-                        if (!data) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate data");
-                                GF_FREE(ptr);
-                                ret = -ENOMEM;
-                                goto err;
-                        }
-
-                        if (op == DICT_FLAG_SET)
-                                BIT_SET((unsigned char *)(data->data), flag);
-                        else
-                                BIT_CLEAR((unsigned char *)(data->data), flag);
-
-                        if (this->free_pair_in_use) {
-                                pair = mem_get0 (THIS->ctx->dict_pair_pool);
-                                if (!pair) {
-                                        gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                               LG_MSG_NO_MEMORY,
-                                               "unable to allocate dict pair");
-                                        ret = -ENOMEM;
-                                        goto err;
-                                }
-                        } else {
-                                pair = &this->free_pair;
-                                this->free_pair_in_use = _gf_true;
-                        }
-
-                        pair->key = (char *)GF_MALLOC(strlen (key) + 1,
-                                                      gf_common_mt_char);
-                        if (!pair->key) {
-                                gf_msg("dict", GF_LOG_ERROR, ENOMEM,
-                                       LG_MSG_NO_MEMORY,
-                                       "unable to allocate dict pair");
-                                ret = -ENOMEM;
-                                goto err;
-                        }
-                        strcpy (pair->key, key);
-                        pair->key_hash = hash;
-                        pair->value = data_ref (data);
+        if (pair) {
+            data = pair->value;
+            if (op == DICT_FLAG_SET)
+                BIT_SET((unsigned char *)(data->data), flag);
+            else
+                BIT_CLEAR((unsigned char *)(data->data), flag);
+        } else {
+            ptr = GF_CALLOC(1, DICT_MAX_FLAGS / 8, gf_common_mt_char);
+            if (!ptr) {
+                gf_msg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                       "unable to allocate flag bit array");
+                ret = -ENOMEM;
+                goto err;
+            }
 
-                        hashval = hash % this->hash_size;
-                        pair->hash_next = this->members[hashval];
-                        this->members[hashval] = pair;
+            data = data_from_dynptr(ptr, DICT_MAX_FLAGS / 8);
 
-                        pair->next = this->members_list;
-                        pair->prev = NULL;
-                        if (this->members_list)
-                                this->members_list->prev = pair;
-                        this->members_list = pair;
-                        this->count++;
+            if (!data) {
+                gf_msg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                       "unable to allocate data");
+                GF_FREE(ptr);
+                ret = -ENOMEM;
+                goto err;
+            }
 
+            if (op == DICT_FLAG_SET)
+                BIT_SET((unsigned char *)(data->data), flag);
+            else
+                BIT_CLEAR((unsigned char *)(data->data), flag);
 
-                        if (this->max_count < this->count)
-                                this->max_count = this->count;
+            if (this->free_pair_in_use) {
+                pair = mem_get0(THIS->ctx->dict_pair_pool);
+                if (!pair) {
+                    gf_msg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                           "unable to allocate dict pair");
+                    ret = -ENOMEM;
+                    goto err;
                 }
+            } else {
+                pair = &this->free_pair;
+                this->free_pair_in_use = _gf_true;
+            }
+
+            pair->key = (char *)GF_MALLOC(strlen(key) + 1, gf_common_mt_char);
+            if (!pair->key) {
+                gf_msg("dict", GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+                       "unable to allocate dict pair");
+                ret = -ENOMEM;
+                goto err;
+            }
+            strcpy(pair->key, key);
+            pair->key_hash = hash;
+            pair->value = data_ref(data);
+
+            hashval = hash % this->hash_size;
+            pair->hash_next = this->members[hashval];
+            this->members[hashval] = pair;
+
+            pair->next = this->members_list;
+            pair->prev = NULL;
+            if (this->members_list)
+                this->members_list->prev = pair;
+            this->members_list = pair;
+            this->count++;
+
+            if (this->max_count < this->count)
+                this->max_count = this->count;
         }
+    }
 
-        UNLOCK (&this->lock);
-        return 0;
+    UNLOCK(&this->lock);
+    return 0;
 
 err:
-        if (key && this)
-                UNLOCK (&this->lock);
+    if (key && this)
+        UNLOCK(&this->lock);
 
-        if (pair) {
-                if (pair->key)
-                        free(pair->key);
+    if (pair) {
+        if (pair->key)
+            free(pair->key);
 
-                if (pair == &this->free_pair) {
-                        this->free_pair_in_use = _gf_false;
-                } else {
-                        mem_put (pair);
-                }
+        if (pair == &this->free_pair) {
+            this->free_pair_in_use = _gf_false;
+        } else {
+            mem_put(pair);
         }
+    }
 
-        if (data)
-                data_destroy(data);
-
+    if (data)
+        data_destroy(data);
 
-        gf_msg("dict", GF_LOG_ERROR, EINVAL,
-               LG_MSG_DICT_SET_FAILED,
-               "unable to set key (%s) in dict ", key);
+    gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_DICT_SET_FAILED,
+           "unable to set key (%s) in dict ", key);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -2269,396 +2208,395 @@ err:
  */
 
 int
-dict_set_flag (dict_t *this, char *key, int flag)
+dict_set_flag(dict_t *this, char *key, int flag)
 {
-        return _dict_modify_flag (this, key, flag, DICT_FLAG_SET);
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_SET);
 }
 
 int
-dict_clear_flag (dict_t *this, char *key, int flag)
+dict_clear_flag(dict_t *this, char *key, int flag)
 {
-        return _dict_modify_flag (this, key, flag, DICT_FLAG_CLEAR);
+    return _dict_modify_flag(this, key, flag, DICT_FLAG_CLEAR);
 }
 
-
 int
-dict_get_double (dict_t *this, char *key, double *val)
+dict_get_double(dict_t *this, char *key, double *val)
 {
-        data_t *data = NULL;
-        int     ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !val) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !val) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_DOUBLE, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_DOUBLE, key, -EINVAL);
 
-        ret = data_to_double_ptr (data, val);
+    ret = data_to_double_ptr(data, val);
 
 err:
-        if (data)
-                data_unref (data);
-        return ret;
+    if (data)
+        data_unref(data);
+    return ret;
 }
 
 int
-dict_set_double (dict_t *this, char *key, double val)
+dict_set_double(dict_t *this, char *key, double val)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_double (val);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_double(val);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_set_static_ptr (dict_t *this, char *key, void *ptr)
+dict_set_static_ptr(dict_t *this, char *key, void *ptr)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_ptr_common (ptr, _gf_true);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_ptr_common(ptr, _gf_true);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_set_dynptr (dict_t *this, char *key, void *ptr, size_t len)
+dict_set_dynptr(dict_t *this, char *key, void *ptr, size_t len)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_dynptr (ptr, len);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_dynptr(ptr, len);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_get_ptr (dict_t *this, char *key, void **ptr)
+dict_get_ptr(dict_t *this, char *key, void **ptr)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !ptr) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !ptr) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = data_to_ptr_common(data, ptr);
+    if (ret != 0) {
+        goto err;
+    }
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_get_ptr_and_len (dict_t *this, char *key, void **ptr, int *len)
+dict_get_ptr_and_len(dict_t *this, char *key, void **ptr, int *len)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!this || !key || !ptr) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!this || !key || !ptr) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret != 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, -EINVAL);
 
-	*len = data->len;
+    *len = data->len;
 
-        ret = data_to_ptr_common (data, ptr);
-        if (ret != 0) {
-                goto err;
-        }
+    ret = data_to_ptr_common(data, ptr);
+    if (ret != 0) {
+        goto err;
+    }
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 /* Get string - with known key length */
 int
-dict_get_strn (dict_t *this, char *key, const int keylen, char **str)
+dict_get_strn(dict_t *this, char *key, const int keylen, char **str)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !str) {
-                goto err;
-        }
-        ret = dict_get_with_refn (this, key, keylen, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    if (!this || !key || !str) {
+        goto err;
+    }
+    ret = dict_get_with_refn(this, key, keylen, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
 
-        *str = data->data;
+    *str = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_get_str (dict_t *this, char *key, char **str)
+dict_get_str(dict_t *this, char *key, char **str)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !str) {
-                goto err;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    if (!this || !key || !str) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_STR, key, -EINVAL);
 
-        *str = data->data;
+    *str = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_set_str (dict_t *this, char *key, char *str)
+dict_set_str(dict_t *this, char *key, char *str)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = str_to_data (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = str_to_data(str);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 /* Set string - with known key length */
 int
-dict_set_strn (dict_t *this, char *key, const int keylen, char *str)
+dict_set_strn(dict_t *this, char *key, const int keylen, char *str)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = str_to_data (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = str_to_data(str);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_setn (this, key, keylen, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 /* Set string - with known key length and known value length */
 int
-dict_set_nstrn (dict_t *this, char *key, const int keylen, char *str, const int vallen)
+dict_set_nstrn(dict_t *this, char *key, const int keylen, char *str,
+               const int vallen)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = strn_to_data (str, vallen);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = strn_to_data(str, vallen);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_setn (this, key, keylen, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_set_dynstr_with_alloc (dict_t *this, char *key, const char *str)
+dict_set_dynstr_with_alloc(dict_t *this, char *key, const char *str)
 {
-        char *alloc_str = NULL;
-        int   ret       = -1;
+    char *alloc_str = NULL;
+    int ret = -1;
 
-        alloc_str = gf_strdup (str);
-        if (!alloc_str)
-                return -1;
+    alloc_str = gf_strdup(str);
+    if (!alloc_str)
+        return -1;
 
-        ret = dict_set_dynstr (this, key, alloc_str);
-        if (ret == -EINVAL)
-                GF_FREE (alloc_str);
+    ret = dict_set_dynstr(this, key, alloc_str);
+    if (ret == -EINVAL)
+        GF_FREE(alloc_str);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_set_dynstr (dict_t *this, char *key, char *str)
+dict_set_dynstr(dict_t *this, char *key, char *str)
 {
-        const int keylen = strlen(key);
-        return dict_set_dynstrn(this, key, keylen, str);
+    const int keylen = strlen(key);
+    return dict_set_dynstrn(this, key, keylen, str);
 }
 
 int
-dict_set_dynstrn (dict_t *this, char *key, const int keylen, char *str)
+dict_set_dynstrn(dict_t *this, char *key, const int keylen, char *str)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_dynstr (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_dynstr(str);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        ret = dict_setn (this, key, keylen, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_setn(this, key, keylen, data);
+    if (ret < 0)
+        data_destroy(data);
 
 err:
-        return ret;
+    return ret;
 }
 
 /* This function is called only by the volgen for now.
    Check how else you can handle it */
 int
-dict_set_option (dict_t *this, char *key, char *str)
+dict_set_option(dict_t *this, char *key, char *str)
 {
-        data_t *data = NULL;
-        int     ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        data = data_from_dynstr (str);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = data_from_dynstr(str);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        data->data_type = GF_DATA_TYPE_STR_OLD;
-        ret = dict_set (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    data->data_type = GF_DATA_TYPE_STR_OLD;
+    ret = dict_set(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 err:
-        return ret;
+    return ret;
 }
 
 int
-dict_add_dynstr_with_alloc (dict_t *this, char *key, char *str)
+dict_add_dynstr_with_alloc(dict_t *this, char *key, char *str)
 {
-        data_t  *data = NULL;
-        int      ret  = 0;
-        char    *alloc_str = NULL;
+    data_t *data = NULL;
+    int ret = 0;
+    char *alloc_str = NULL;
 
-        alloc_str = gf_strdup (str);
-        if (!alloc_str)
-                goto out;
+    alloc_str = gf_strdup(str);
+    if (!alloc_str)
+        goto out;
 
-        data = data_from_dynstr (alloc_str);
-        if (!data) {
-                GF_FREE (alloc_str);
-                ret = -EINVAL;
-                goto out;
-        }
+    data = data_from_dynstr(alloc_str);
+    if (!data) {
+        GF_FREE(alloc_str);
+        ret = -EINVAL;
+        goto out;
+    }
 
-        ret = dict_add (this, key, data);
-        if (ret < 0)
-                data_destroy (data);
+    ret = dict_add(this, key, data);
+    if (ret < 0)
+        data_destroy(data);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dict_get_bin (dict_t *this, char *key, void **bin)
+dict_get_bin(dict_t *this, char *key, void **bin)
 {
-        data_t * data = NULL;
-        int      ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !bin) {
-                goto err;
-        }
+    if (!this || !key || !bin) {
+        goto err;
+    }
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, ret);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_PTR, key, ret);
 
-        *bin = data->data;
+    *bin = data->data;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 /********************************************************************
@@ -2671,35 +2609,35 @@ err:
  *
  *******************************************************************/
 static int
-dict_set_bin_common (dict_t *this, char *key, void *ptr, size_t size,
-                     gf_boolean_t is_static, gf_dict_data_type_t type)
+dict_set_bin_common(dict_t *this, char *key, void *ptr, size_t size,
+                    gf_boolean_t is_static, gf_dict_data_type_t type)
 {
-        data_t * data = NULL;
-        int      ret  = 0;
+    data_t *data = NULL;
+    int ret = 0;
 
-        if (!ptr || (size > DICT_KEY_VALUE_MAX_SIZE)) {
-                ret = -EINVAL;
-                goto err;
-        }
+    if (!ptr || (size > DICT_KEY_VALUE_MAX_SIZE)) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        data = bin_to_data (ptr, size);
-        if (!data) {
-                ret = -EINVAL;
-                goto err;
-        }
+    data = bin_to_data(ptr, size);
+    if (!data) {
+        ret = -EINVAL;
+        goto err;
+    }
 
-        data->is_static = is_static;
-        data->data_type = type;
+    data->is_static = is_static;
+    data->data_type = type;
 
-        ret = dict_set (this, key, data);
-        if (ret < 0) {
-                /* don't free data->data, let callers handle it */
-                data->data = NULL;
-                data_destroy (data);
-        }
+    ret = dict_set(this, key, data);
+    if (ret < 0) {
+        /* don't free data->data, let callers handle it */
+        data->data = NULL;
+        data_destroy(data);
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 /********************************************************************
@@ -2710,10 +2648,10 @@ err:
  *
  *******************************************************************/
 int
-dict_set_bin (dict_t *this, char *key, void *ptr, size_t size)
+dict_set_bin(dict_t *this, char *key, void *ptr, size_t size)
 {
-        return dict_set_bin_common (this, key, ptr, size, _gf_false,
-                                    GF_DATA_TYPE_PTR);
+    return dict_set_bin_common(this, key, ptr, size, _gf_false,
+                               GF_DATA_TYPE_PTR);
 }
 
 /********************************************************************
@@ -2724,78 +2662,77 @@ dict_set_bin (dict_t *this, char *key, void *ptr, size_t size)
  *
  *******************************************************************/
 int
-dict_set_static_bin (dict_t *this, char *key, void *ptr, size_t size)
+dict_set_static_bin(dict_t *this, char *key, void *ptr, size_t size)
 {
-        return dict_set_bin_common (this, key, ptr, size, _gf_true,
-                                    GF_DATA_TYPE_PTR);
+    return dict_set_bin_common(this, key, ptr, size, _gf_true,
+                               GF_DATA_TYPE_PTR);
 }
 
 /*  */
 int
-dict_set_gfuuid (dict_t *this, char *key, uuid_t gfid, bool is_static)
+dict_set_gfuuid(dict_t *this, char *key, uuid_t gfid, bool is_static)
 {
-        return dict_set_bin_common (this, key, gfid, sizeof (uuid_t),
-                                    is_static, GF_DATA_TYPE_GFUUID);
+    return dict_set_bin_common(this, key, gfid, sizeof(uuid_t), is_static,
+                               GF_DATA_TYPE_GFUUID);
 }
 
 int
-dict_get_gfuuid (dict_t *this, char *key, uuid_t *gfid)
+dict_get_gfuuid(dict_t *this, char *key, uuid_t *gfid)
 {
-        data_t *data = NULL;
-        int     ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !gfid) {
-                goto err;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    if (!this || !key || !gfid) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_GFUUID, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_GFUUID, key, -EINVAL);
 
-        memcpy (*gfid, data->data, min(data->len, sizeof (uuid_t)));
+    memcpy(*gfid, data->data, min(data->len, sizeof(uuid_t)));
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_set_iatt (dict_t *this, char *key, struct iatt *iatt, bool is_static)
+dict_set_iatt(dict_t *this, char *key, struct iatt *iatt, bool is_static)
 {
-        return dict_set_bin_common (this, key, iatt, sizeof (struct iatt),
-                                    is_static, GF_DATA_TYPE_IATT);
+    return dict_set_bin_common(this, key, iatt, sizeof(struct iatt), is_static,
+                               GF_DATA_TYPE_IATT);
 }
 
 int
-dict_get_iatt (dict_t *this, char *key, struct iatt *iatt)
+dict_get_iatt(dict_t *this, char *key, struct iatt *iatt)
 {
-        data_t *data = NULL;
-        int     ret  = -EINVAL;
+    data_t *data = NULL;
+    int ret = -EINVAL;
 
-        if (!this || !key || !iatt) {
-                goto err;
-        }
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                goto err;
-        }
+    if (!this || !key || !iatt) {
+        goto err;
+    }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_IATT, key, -EINVAL);
 
-        memcpy (iatt, data->data, min(data->len, sizeof (struct iatt)));
+    memcpy(iatt, data->data, min(data->len, sizeof(struct iatt)));
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_get_str_boolean - get a boolean value based on string representation.
  *
@@ -2820,75 +2757,74 @@ err:
  */
 
 int
-dict_get_str_boolean (dict_t *this, char *key, int default_val)
+dict_get_str_boolean(dict_t *this, char *key, int default_val)
 {
-        data_t       *data = NULL;
-        gf_boolean_t  boo = _gf_false;
-        int           ret  = 0;
+    data_t *data = NULL;
+    gf_boolean_t boo = _gf_false;
+    int ret = 0;
 
-        ret = dict_get_with_ref (this, key, &data);
-        if (ret < 0) {
-                if (ret == -ENOENT)
-                        ret = default_val;
-                else
-                        ret = -1;
-                goto err;
-        }
+    ret = dict_get_with_ref(this, key, &data);
+    if (ret < 0) {
+        if (ret == -ENOENT)
+            ret = default_val;
+        else
+            ret = -1;
+        goto err;
+    }
 
-        VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
+    VALIDATE_DATA_AND_LOG(data, GF_DATA_TYPE_INT, key, -EINVAL);
 
-        ret = gf_string2boolean (data->data, &boo);
-        if (ret == -1)
-                goto err;
+    ret = gf_string2boolean(data->data, &boo);
+    if (ret == -1)
+        goto err;
 
-        ret = boo;
+    ret = boo;
 
 err:
-        if (data)
-                data_unref (data);
+    if (data)
+        data_unref(data);
 
-        return ret;
+    return ret;
 }
 
 int
-dict_rename_key (dict_t *this, char *key, char *replace_key)
+dict_rename_key(dict_t *this, char *key, char *replace_key)
 {
-        data_pair_t *pair = NULL;
-        int          ret  = -EINVAL;
-        uint32_t     hash;
-        uint32_t replacekey_hash;
+    data_pair_t *pair = NULL;
+    int ret = -EINVAL;
+    uint32_t hash;
+    uint32_t replacekey_hash;
 
-        /* replacing a key by itself is a NO-OP */
-        if (strcmp (key, replace_key) == 0)
-                return 0;
+    /* replacing a key by itself is a NO-OP */
+    if (strcmp(key, replace_key) == 0)
+        return 0;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                return ret;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        return ret;
+    }
 
-        hash = SuperFastHash (key, strlen (key));
-        replacekey_hash = SuperFastHash (replace_key,
-                                         strlen(replace_key));
-
-        LOCK (&this->lock);
-        {
-                /* no need to data_ref(pair->value), dict_set_lk() does it */
-                pair = dict_lookup_common (this, key, hash);
-                if (!pair)
-                        ret = -ENODATA;
-                else
-                        ret = dict_set_lk (this, replace_key, pair->value,
-                                           replacekey_hash, 1);
-        }
-        UNLOCK (&this->lock);
+    hash = SuperFastHash(key, strlen(key));
+    replacekey_hash = SuperFastHash(replace_key, strlen(replace_key));
 
-        if (!ret)
-                /* only delete the key on success */
-                dict_del (this, key);
+    LOCK(&this->lock);
+    {
+        /* no need to data_ref(pair->value), dict_set_lk() does it */
+        pair = dict_lookup_common(this, key, hash);
+        if (!pair)
+            ret = -ENODATA;
+        else
+            ret = dict_set_lk(this, replace_key, pair->value, replacekey_hash,
+                              1);
+    }
+    UNLOCK(&this->lock);
 
-        return ret;
+    if (!ret)
+        /* only delete the key on success */
+        dict_del(this, key);
+
+    return ret;
 }
 
 /**
@@ -2899,9 +2835,9 @@ dict_rename_key (dict_t *this, char *key, char *replace_key)
  *     4        4         4       <key len>   <value len>
  */
 
-#define DICT_HDR_LEN               4
-#define DICT_DATA_HDR_KEY_LEN      4
-#define DICT_DATA_HDR_VAL_LEN      4
+#define DICT_HDR_LEN 4
+#define DICT_DATA_HDR_KEY_LEN 4
+#define DICT_DATA_HDR_VAL_LEN 4
 
 /**
  * dict_serialized_length_lk - return the length of serialized dict. This
@@ -2913,59 +2849,59 @@ dict_rename_key (dict_t *this, char *key, char *replace_key)
  */
 
 static int
-dict_serialized_length_lk (dict_t *this)
+dict_serialized_length_lk(dict_t *this)
 {
-        int ret            = -EINVAL;
-        int count          = this->count;
-        int len            = DICT_HDR_LEN;
-        data_pair_t * pair = this->members_list;
+    int ret = -EINVAL;
+    int count = this->count;
+    int len = DICT_HDR_LEN;
+    data_pair_t *pair = this->members_list;
 
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                        LG_MSG_COUNT_LESS_THAN_ZERO, "count (%d) < 0!", count);
-                goto out;
-        }
+    if (count < 0) {
+        gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_COUNT_LESS_THAN_ZERO,
+               "count (%d) < 0!", count);
+        goto out;
+    }
 
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_COUNT_LESS_THAN_DATA_PAIRS,
-                                "less than count data pairs found!");
-                        goto out;
-                }
+    while (count) {
+        if (!pair) {
+            gf_msg("dict", GF_LOG_ERROR, EINVAL,
+                   LG_MSG_COUNT_LESS_THAN_DATA_PAIRS,
+                   "less than count data pairs found!");
+            goto out;
+        }
 
-                len += DICT_DATA_HDR_KEY_LEN + DICT_DATA_HDR_VAL_LEN;
+        len += DICT_DATA_HDR_KEY_LEN + DICT_DATA_HDR_VAL_LEN;
 
-                if (!pair->key) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_NULL_PTR, "pair->key is null!");
-                        goto out;
-                }
+        if (!pair->key) {
+            gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_NULL_PTR,
+                   "pair->key is null!");
+            goto out;
+        }
 
-                len += strlen (pair->key) + 1  /* for '\0' */;
+        len += strlen(pair->key) + 1 /* for '\0' */;
 
-                if (!pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_NULL_PTR, "pair->value is null!");
-                        goto out;
-                }
+        if (!pair->value) {
+            gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_NULL_PTR,
+                   "pair->value is null!");
+            goto out;
+        }
 
-                if (pair->value->len < 0) {
-                        gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                                LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO,
-                                "value->len (%d) < 0", pair->value->len);
-                        goto out;
-                }
+        if (pair->value->len < 0) {
+            gf_msg("dict", GF_LOG_ERROR, EINVAL,
+                   LG_MSG_VALUE_LENGTH_LESS_THAN_ZERO, "value->len (%d) < 0",
+                   pair->value->len);
+            goto out;
+        }
 
-                len += pair->value->len;
+        len += pair->value->len;
 
-                pair = pair->next;
-                count--;
-        }
+        pair = pair->next;
+        count--;
+    }
 
-        ret = len;
+    ret = len;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -2981,80 +2917,76 @@ out:
  */
 
 static int
-dict_serialize_lk (dict_t *this, char *buf)
+dict_serialize_lk(dict_t *this, char *buf)
 {
-        int           ret     = -1;
-        data_pair_t * pair    = this->members_list;
-        int32_t       count   = this->count;
-        int32_t       keylen  = 0;
-        int32_t       netword = 0;
+    int ret = -1;
+    data_pair_t *pair = this->members_list;
+    int32_t count = this->count;
+    int32_t keylen = 0;
+    int32_t netword = 0;
 
+    if (!buf) {
+        gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+               "buf is null!");
+        goto out;
+    }
 
-        if (!buf) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
-                        "buf is null!");
-                goto out;
-        }
-
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
-                        "count (%d) < 0!", count);
-                goto out;
-        }
+    if (count < 0) {
+        gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
+               "count (%d) < 0!", count);
+        goto out;
+    }
 
-        netword = hton32 (count);
-        memcpy (buf, &netword, sizeof(netword));
-        buf += DICT_HDR_LEN;
+    netword = hton32(count);
+    memcpy(buf, &netword, sizeof(netword));
+    buf += DICT_HDR_LEN;
 
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_PAIRS_LESS_THAN_COUNT,
-                                "less than count data pairs found!");
-                        goto out;
-                }
-
-                if (!pair->key) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR,
-                                "pair->key is null!");
-                        goto out;
-                }
+    while (count) {
+        if (!pair) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_PAIRS_LESS_THAN_COUNT,
+                   "less than count data pairs found!");
+            goto out;
+        }
 
-                keylen  = strlen (pair->key);
-                netword = hton32 (keylen);
-                memcpy (buf, &netword, sizeof(netword));
-                buf += DICT_DATA_HDR_KEY_LEN;
+        if (!pair->key) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR,
+                   "pair->key is null!");
+            goto out;
+        }
 
-                if (!pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_NULL_PTR,
-                                "pair->value is null!");
-                        goto out;
-                }
+        keylen = strlen(pair->key);
+        netword = hton32(keylen);
+        memcpy(buf, &netword, sizeof(netword));
+        buf += DICT_DATA_HDR_KEY_LEN;
 
-                netword = hton32 (pair->value->len);
-                memcpy (buf, &netword, sizeof(netword));
-                buf += DICT_DATA_HDR_VAL_LEN;
+        if (!pair->value) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_PTR,
+                   "pair->value is null!");
+            goto out;
+        }
 
-                memcpy (buf, pair->key, keylen);
-                buf += keylen;
-                *buf++ = '\0';
+        netword = hton32(pair->value->len);
+        memcpy(buf, &netword, sizeof(netword));
+        buf += DICT_DATA_HDR_VAL_LEN;
 
-                if (pair->value->data) {
-                        memcpy (buf, pair->value->data, pair->value->len);
-                        buf += pair->value->len;
-                }
+        memcpy(buf, pair->key, keylen);
+        buf += keylen;
+        *buf++ = '\0';
 
-                pair = pair->next;
-                count--;
+        if (pair->value->data) {
+            memcpy(buf, pair->value->data, pair->value->len);
+            buf += pair->value->len;
         }
 
-        ret = 0;
+        pair = pair->next;
+        count--;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_serialized_length - return the length of serialized dict
  *
@@ -3064,24 +2996,24 @@ out:
  */
 
 int
-dict_serialized_length (dict_t *this)
+dict_serialized_length(dict_t *this)
 {
-        int ret            = -EINVAL;
+    int ret = -EINVAL;
 
-        if (!this) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
+    if (!this) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = dict_serialized_length_lk (this);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = dict_serialized_length_lk(this);
+    }
+    UNLOCK(&this->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -3096,26 +3028,25 @@ out:
  */
 
 int
-dict_serialize (dict_t *this, char *buf)
+dict_serialize(dict_t *this, char *buf)
 {
-        int           ret    = -1;
+    int ret = -1;
 
-        if (!this || !buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
+    if (!this || !buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                ret = dict_serialize_lk (this, buf);
-        }
-        UNLOCK (&this->lock);
+    LOCK(&this->lock);
+    {
+        ret = dict_serialize_lk(this, buf);
+    }
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_unserialize - unserialize a buffer into a dict
  *
@@ -3128,143 +3059,137 @@ out:
  */
 
 int32_t
-dict_unserialize (char *orig_buf, int32_t size, dict_t **fill)
-{
-        char   *buf   = orig_buf;
-        int     ret   = -1;
-        int32_t count = 0;
-        int     i     = 0;
-
-        data_t * value   = NULL;
-        char   * key     = NULL;
-        int32_t  keylen  = 0;
-        int32_t  vallen  = 0;
-        int32_t  hostord = 0;
-
-        if (!buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "buf is null!");
-                goto out;
-        }
+dict_unserialize(char *orig_buf, int32_t size, dict_t **fill)
+{
+    char *buf = orig_buf;
+    int ret = -1;
+    int32_t count = 0;
+    int i = 0;
+
+    data_t *value = NULL;
+    char *key = NULL;
+    int32_t keylen = 0;
+    int32_t vallen = 0;
+    int32_t hostord = 0;
+
+    if (!buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "buf is null!");
+        goto out;
+    }
+
+    if (size == 0) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "size is 0!");
+        goto out;
+    }
+
+    if (!fill) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "fill is null!");
+        goto out;
+    }
+
+    if (!*fill) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "*fill is null!");
+        goto out;
+    }
+
+    if ((buf + DICT_HDR_LEN) > (orig_buf + size)) {
+        gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                         "undersized buffer "
+                         "passed. available (%lu) < required (%lu)",
+                         (long)(orig_buf + size), (long)(buf + DICT_HDR_LEN));
+        goto out;
+    }
+
+    memcpy(&hostord, buf, sizeof(hostord));
+    count = ntoh32(hostord);
+    buf += DICT_HDR_LEN;
+
+    if (count < 0) {
+        gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
+               "count (%d) <= 0", count);
+        goto out;
+    }
+
+    /* count will be set by the dict_set's below */
+    (*fill)->count = 0;
+
+    for (i = 0; i < count; i++) {
+        if ((buf + DICT_DATA_HDR_KEY_LEN) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized "
+                             "buffer passed. available (%lu) < "
+                             "required (%lu)",
+                             (long)(orig_buf + size),
+                             (long)(buf + DICT_DATA_HDR_KEY_LEN));
+            goto out;
+        }
+        memcpy(&hostord, buf, sizeof(hostord));
+        keylen = ntoh32(hostord);
+        buf += DICT_DATA_HDR_KEY_LEN;
+
+        if ((buf + DICT_DATA_HDR_VAL_LEN) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized "
+                             "buffer passed. available (%lu) < "
+                             "required (%lu)",
+                             (long)(orig_buf + size),
+                             (long)(buf + DICT_DATA_HDR_VAL_LEN));
+            goto out;
+        }
+        memcpy(&hostord, buf, sizeof(hostord));
+        vallen = ntoh32(hostord);
+        buf += DICT_DATA_HDR_VAL_LEN;
+
+        if ((keylen < 0) || (vallen < 0)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized length passed "
+                             "key:%d val:%d",
+                             keylen, vallen);
+            goto out;
+        }
+        if ((buf + keylen) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized buffer passed. "
+                             "available (%lu) < required (%lu)",
+                             (long)(orig_buf + size), (long)(buf + keylen));
+            goto out;
+        }
+        key = buf;
+        buf += keylen + 1; /* for '\0' */
+
+        if ((buf + vallen) > (orig_buf + size)) {
+            gf_msg_callingfn("dict", GF_LOG_ERROR, 0, LG_MSG_UNDERSIZED_BUF,
+                             "undersized buffer passed. "
+                             "available (%lu) < required (%lu)",
+                             (long)(orig_buf + size), (long)(buf + vallen));
+            goto out;
+        }
+        value = get_new_data();
 
-        if (size == 0) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "size is 0!");
-                goto out;
-        }
-
-        if (!fill) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "fill is null!");
-                goto out;
-        }
-
-        if (!*fill) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "*fill is null!");
-                goto out;
-        }
-
-        if ((buf + DICT_HDR_LEN) > (orig_buf + size)) {
-                gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                  LG_MSG_UNDERSIZED_BUF, "undersized buffer "
-                                  "passed. available (%lu) < required (%lu)",
-                                  (long)(orig_buf + size),
-                                  (long)(buf + DICT_HDR_LEN));
-                goto out;
-        }
-
-        memcpy (&hostord, buf, sizeof(hostord));
-        count = ntoh32 (hostord);
-        buf += DICT_HDR_LEN;
-
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, 0, LG_MSG_COUNT_LESS_THAN_ZERO,
-                        "count (%d) <= 0", count);
-                goto out;
+        if (!value) {
+            ret = -1;
+            goto out;
         }
+        value->len = vallen;
+        value->data = memdup(buf, vallen);
+        value->data_type = GF_DATA_TYPE_STR_OLD;
+        value->is_static = _gf_false;
+        buf += vallen;
 
-        /* count will be set by the dict_set's below */
-        (*fill)->count = 0;
-
-        for (i = 0; i < count; i++) {
-                if ((buf + DICT_DATA_HDR_KEY_LEN) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF, "undersized "
-                                          "buffer passed. available (%lu) < "
-                                          "required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + DICT_DATA_HDR_KEY_LEN));
-                        goto out;
-                }
-                memcpy (&hostord, buf, sizeof(hostord));
-                keylen = ntoh32 (hostord);
-                buf += DICT_DATA_HDR_KEY_LEN;
-
-                if ((buf + DICT_DATA_HDR_VAL_LEN) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF, "undersized "
-                                          "buffer passed. available (%lu) < "
-                                          "required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + DICT_DATA_HDR_VAL_LEN));
-                        goto out;
-                }
-                memcpy (&hostord, buf, sizeof(hostord));
-                vallen = ntoh32 (hostord);
-                buf += DICT_DATA_HDR_VAL_LEN;
-
-                if ((keylen < 0) || (vallen < 0)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF,
-                                          "undersized length passed "
-                                          "key:%d val:%d", keylen, vallen);
-                        goto out;
-                }
-                if ((buf + keylen) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF,
-                                          "undersized buffer passed. "
-                                          "available (%lu) < required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + keylen));
-                        goto out;
-                }
-                key = buf;
-                buf += keylen + 1;  /* for '\0' */
-
-                if ((buf + vallen) > (orig_buf + size)) {
-                        gf_msg_callingfn ("dict", GF_LOG_ERROR, 0,
-                                          LG_MSG_UNDERSIZED_BUF,
-                                          "undersized buffer passed. "
-                                          "available (%lu) < required (%lu)",
-                                          (long)(orig_buf + size),
-                                          (long)(buf + vallen));
-                        goto out;
-                }
-                value = get_new_data ();
-
-                if (!value) {
-                        ret = -1;
-                        goto out;
-                }
-                value->len  = vallen;
-                value->data = memdup (buf, vallen);
-                value->data_type = GF_DATA_TYPE_STR_OLD;
-                value->is_static = _gf_false;
-                buf += vallen;
-
-                ret = dict_add (*fill, key, value);
-                if (ret < 0)
-                        goto out;
-        }
+        ret = dict_add(*fill, key, value);
+        if (ret < 0)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * dict_allocate_and_serialize - serialize a dictionary into an allocated buffer
  *
@@ -3277,45 +3202,45 @@ out:
  */
 
 int32_t
-dict_allocate_and_serialize (dict_t *this, char **buf, u_int *length)
+dict_allocate_and_serialize(dict_t *this, char **buf, u_int *length)
 {
-        int           ret    = -EINVAL;
-        ssize_t       len = 0;
+    int ret = -EINVAL;
+    ssize_t len = 0;
 
-        if (!this || !buf) {
-                gf_msg_debug ("dict", 0, "dict OR buf is NULL");
-                goto out;
-        }
+    if (!this || !buf) {
+        gf_msg_debug("dict", 0, "dict OR buf is NULL");
+        goto out;
+    }
 
-        LOCK (&this->lock);
-        {
-                len = dict_serialized_length_lk (this);
-                if (len < 0) {
-                        ret = len;
-                        goto unlock;
-                }
+    LOCK(&this->lock);
+    {
+        len = dict_serialized_length_lk(this);
+        if (len < 0) {
+            ret = len;
+            goto unlock;
+        }
 
-                *buf = GF_MALLOC (len, gf_common_mt_char);
-                if (*buf == NULL) {
-                        ret = -ENOMEM;
-                        goto unlock;
-                }
+        *buf = GF_MALLOC(len, gf_common_mt_char);
+        if (*buf == NULL) {
+            ret = -ENOMEM;
+            goto unlock;
+        }
 
-                ret = dict_serialize_lk (this, *buf);
-                if (ret < 0) {
-                        GF_FREE (*buf);
-                        *buf = NULL;
-                        goto unlock;
-                }
+        ret = dict_serialize_lk(this, *buf);
+        if (ret < 0) {
+            GF_FREE(*buf);
+            *buf = NULL;
+            goto unlock;
+        }
 
-                if (length != NULL) {
-                        *length = len;
-                }
+        if (length != NULL) {
+            *length = len;
         }
+    }
 unlock:
-        UNLOCK (&this->lock);
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -3331,236 +3256,232 @@ out:
  *            : -errno -> failure
  */
 int
-dict_serialize_value_with_delim_lk (dict_t *this, char *buf, int32_t *serz_len,
-                                    char delimiter)
-{
-        int          ret       = -1;
-        int32_t      count     = this->count;
-        int32_t      vallen    = 0;
-        int32_t      total_len = 0;
-        data_pair_t *pair      = this->members_list;
-
-        if (!buf) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL,
-                        LG_MSG_INVALID_ARG, "buf is null");
-                goto out;
-        }
+dict_serialize_value_with_delim_lk(dict_t *this, char *buf, int32_t *serz_len,
+                                   char delimiter)
+{
+    int ret = -1;
+    int32_t count = this->count;
+    int32_t vallen = 0;
+    int32_t total_len = 0;
+    data_pair_t *pair = this->members_list;
 
-        if (count < 0) {
-                gf_msg ("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
-                        "count (%d) < 0", count);
-                goto out;
-        }
+    if (!buf) {
+        gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "buf is null");
+        goto out;
+    }
 
-        while (count) {
-                if (!pair) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_PAIRS_LESS_THAN_COUNT,
-                                "less than count data pairs found");
-                        goto out;
-                }
+    if (count < 0) {
+        gf_msg("dict", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+               "count (%d) < 0", count);
+        goto out;
+    }
 
-                if (!pair->key || !pair->value) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_KEY_OR_VALUE_NULL,
-                                "key or value is null");
-                        goto out;
-                }
+    while (count) {
+        if (!pair) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_PAIRS_LESS_THAN_COUNT,
+                   "less than count data pairs found");
+            goto out;
+        }
 
-                if (!pair->value->data) {
-                        gf_msg ("dict", GF_LOG_ERROR, 0,
-                                LG_MSG_NULL_VALUE_IN_DICT,
-                                "null value found in dict");
-                        goto out;
-                }
+        if (!pair->key || !pair->value) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_KEY_OR_VALUE_NULL,
+                   "key or value is null");
+            goto out;
+        }
 
-                vallen = pair->value->len - 1; // length includes \0
-                memcpy (buf, pair->value->data, vallen);
-                buf += vallen;
-                *buf++ = delimiter;
+        if (!pair->value->data) {
+            gf_msg("dict", GF_LOG_ERROR, 0, LG_MSG_NULL_VALUE_IN_DICT,
+                   "null value found in dict");
+            goto out;
+        }
 
-                total_len += (vallen + 1);
+        vallen = pair->value->len - 1;  // length includes \0
+        memcpy(buf, pair->value->data, vallen);
+        buf += vallen;
+        *buf++ = delimiter;
 
-                pair = pair->next;
-                count--;
-        }
+        total_len += (vallen + 1);
 
-        *--buf = '\0'; // remove the last delimiter
-        total_len--;   // adjust the length
-        ret = 0;
+        pair = pair->next;
+        count--;
+    }
 
-        if (serz_len)
-                *serz_len = total_len;
+    *--buf = '\0';  // remove the last delimiter
+    total_len--;    // adjust the length
+    ret = 0;
 
- out:
-        return ret;
+    if (serz_len)
+        *serz_len = total_len;
+
+out:
+    return ret;
 }
 
 int
-dict_serialize_value_with_delim (dict_t *this, char *buf, int32_t *serz_len,
-                                 char delimiter)
-{
-        int           ret    = -1;
-
-        if (!this || !buf) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is null!");
-                goto out;
-        }
-
-        LOCK (&this->lock);
-        {
-                ret = dict_serialize_value_with_delim_lk (this, buf, serz_len,
-                                                          delimiter);
-        }
-        UNLOCK (&this->lock);
+dict_serialize_value_with_delim(dict_t *this, char *buf, int32_t *serz_len,
+                                char delimiter)
+{
+    int ret = -1;
+
+    if (!this || !buf) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is null!");
+        goto out;
+    }
+
+    LOCK(&this->lock);
+    {
+        ret = dict_serialize_value_with_delim_lk(this, buf, serz_len,
+                                                 delimiter);
+    }
+    UNLOCK(&this->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dict_dump_to_str (dict_t *dict, char *dump, int dumpsize, char *format)
+dict_dump_to_str(dict_t *dict, char *dump, int dumpsize, char *format)
 {
-        int          ret                       = 0;
-        int          dumplen                   = 0;
-        data_pair_t *trav                      = NULL;
+    int ret = 0;
+    int dumplen = 0;
+    data_pair_t *trav = NULL;
 
-        if (!dict)
-                return 0;
+    if (!dict)
+        return 0;
 
-        for (trav = dict->members_list; trav; trav = trav->next) {
-                ret = snprintf (&dump[dumplen], dumpsize - dumplen,
-                                format, trav->key, trav->value->data);
-                if ((ret == -1) || !ret)
-                        return ret;
+    for (trav = dict->members_list; trav; trav = trav->next) {
+        ret = snprintf(&dump[dumplen], dumpsize - dumplen, format, trav->key,
+                       trav->value->data);
+        if ((ret == -1) || !ret)
+            return ret;
 
-                dumplen += ret;
-        }
-        return 0;
+        dumplen += ret;
+    }
+    return 0;
 }
 
 void
-dict_dump_to_log (dict_t *dict)
-{
-        int          ret                       = -1;
-        char        *dump                      = NULL;
-        int          dump_size                 = 64*1024;
-        char        *format                    = "(%s:%s)";
-
-        if (!dict) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                goto out;
-        }
-
-        dump = GF_MALLOC (dump_size, gf_common_mt_char);
-        if (!dump) {
-                gf_msg_callingfn ("dict", GF_LOG_WARNING, ENOMEM,
-                                  LG_MSG_NO_MEMORY, "dump buffer is NULL");
-                goto out;
-        }
-
-        ret = dict_dump_to_str (dict, dump, dump_size, format);
-        if (ret) {
-                gf_msg ("dict", GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary");
-                goto out;
-        }
-        gf_msg ("dict", GF_LOG_INFO, 0, LG_MSG_DICT_ERROR,
-                "dict=%p (%s)", dict, dump);
+dict_dump_to_log(dict_t *dict)
+{
+    int ret = -1;
+    char *dump = NULL;
+    int dump_size = 64 * 1024;
+    char *format = "(%s:%s)";
+
+    if (!dict) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+
+    dump = GF_MALLOC(dump_size, gf_common_mt_char);
+    if (!dump) {
+        gf_msg_callingfn("dict", GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+                         "dump buffer is NULL");
+        goto out;
+    }
+
+    ret = dict_dump_to_str(dict, dump, dump_size, format);
+    if (ret) {
+        gf_msg("dict", GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
+               "Failed to log dictionary");
+        goto out;
+    }
+    gf_msg("dict", GF_LOG_INFO, 0, LG_MSG_DICT_ERROR, "dict=%p (%s)", dict,
+           dump);
 out:
-        GF_FREE (dump);
-
+    GF_FREE(dump);
 
-        return;
+    return;
 }
 
 void
-dict_dump_to_statedump (dict_t *dict, char *dict_name, char *domain)
-{
-        int          ret                       = -1;
-        char        *dump                      = NULL;
-        int          dump_size                 = 64*1024;
-        char         key[4096]                 = {0,};
-        char        *format                    = "\n\t%s:%s";
-
-        if (!dict) {
-                gf_msg_callingfn (domain, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "dict is NULL");
-                goto out;
-        }
-
-        dump = GF_MALLOC (dump_size, gf_common_mt_char);
-        if (!dump) {
-                gf_msg_callingfn (domain, GF_LOG_WARNING, ENOMEM,
-                                  LG_MSG_NO_MEMORY, "dump buffer is NULL");
-                goto out;
-        }
-
-        ret = dict_dump_to_str (dict, dump, dump_size, format);
-        if (ret) {
-                gf_msg (domain, GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
-                        "Failed to log dictionary %s", dict_name);
-                goto out;
-        }
-        gf_proc_dump_build_key (key, domain, "%s", dict_name);
-        gf_proc_dump_write (key, "%s", dump);
+dict_dump_to_statedump(dict_t *dict, char *dict_name, char *domain)
+{
+    int ret = -1;
+    char *dump = NULL;
+    int dump_size = 64 * 1024;
+    char key[4096] = {
+        0,
+    };
+    char *format = "\n\t%s:%s";
+
+    if (!dict) {
+        gf_msg_callingfn(domain, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "dict is NULL");
+        goto out;
+    }
+
+    dump = GF_MALLOC(dump_size, gf_common_mt_char);
+    if (!dump) {
+        gf_msg_callingfn(domain, GF_LOG_WARNING, ENOMEM, LG_MSG_NO_MEMORY,
+                         "dump buffer is NULL");
+        goto out;
+    }
+
+    ret = dict_dump_to_str(dict, dump, dump_size, format);
+    if (ret) {
+        gf_msg(domain, GF_LOG_WARNING, 0, LG_MSG_FAILED_TO_LOG_DICT,
+               "Failed to log dictionary %s", dict_name);
+        goto out;
+    }
+    gf_proc_dump_build_key(key, domain, "%s", dict_name);
+    gf_proc_dump_write(key, "%s", dump);
 
 out:
-        GF_FREE (dump);
+    GF_FREE(dump);
 
-        return;
+    return;
 }
 
 dict_t *
-dict_for_key_value (const char *name, const char *value, size_t size,
-                    gf_boolean_t is_static)
+dict_for_key_value(const char *name, const char *value, size_t size,
+                   gf_boolean_t is_static)
 {
-	dict_t *xattr = NULL;
-	int     ret = 0;
+    dict_t *xattr = NULL;
+    int ret = 0;
 
-	xattr = dict_new ();
-	if (!xattr)
-		return NULL;
+    xattr = dict_new();
+    if (!xattr)
+        return NULL;
 
-        if (is_static)
-                ret = dict_set_static_bin (xattr, (char *)name, (void *)value,
-                                           size);
-        else
-                ret = dict_set_bin (xattr, (char *)name, (void *)value, size);
+    if (is_static)
+        ret = dict_set_static_bin(xattr, (char *)name, (void *)value, size);
+    else
+        ret = dict_set_bin(xattr, (char *)name, (void *)value, size);
 
-	if (ret) {
-		dict_destroy (xattr);
-		xattr = NULL;
-	}
+    if (ret) {
+        dict_destroy(xattr);
+        xattr = NULL;
+    }
 
-	return xattr;
+    return xattr;
 }
 
 /*
  * "strings" should be NULL terminated strings array.
  */
 int
-dict_has_key_from_array (dict_t *dict, char **strings, gf_boolean_t *result)
+dict_has_key_from_array(dict_t *dict, char **strings, gf_boolean_t *result)
 {
-        int      i    = 0;
-        uint32_t hash = 0;
+    int i = 0;
+    uint32_t hash = 0;
 
-        if (!dict || !strings || !result)
-                return -EINVAL;
+    if (!dict || !strings || !result)
+        return -EINVAL;
 
-        LOCK (&dict->lock);
-        {
-                for (i = 0; strings[i]; i++) {
-                        hash = SuperFastHash (strings[i], strlen (strings[i]));
-                        if (dict_lookup_common (dict, strings[i], hash)) {
-                                *result = _gf_true;
-                                goto unlock;
-                        }
-                }
-                *result = _gf_false;
+    LOCK(&dict->lock);
+    {
+        for (i = 0; strings[i]; i++) {
+            hash = SuperFastHash(strings[i], strlen(strings[i]));
+            if (dict_lookup_common(dict, strings[i], hash)) {
+                *result = _gf_true;
+                goto unlock;
+            }
         }
+        *result = _gf_false;
+    }
 unlock:
-        UNLOCK (&dict->lock);
-        return 0;
+    UNLOCK(&dict->lock);
+    return 0;
 }
diff --git a/libglusterfs/src/event-epoll.c b/libglusterfs/src/event-epoll.c
index b144b77a11c..9826cc9e275 100644
--- a/libglusterfs/src/event-epoll.c
+++ b/libglusterfs/src/event-epoll.c
@@ -23,766 +23,747 @@
 #include "syscall.h"
 #include "libglusterfs-messages.h"
 
-
 #ifdef HAVE_SYS_EPOLL_H
 #include <sys/epoll.h>
 
-
 struct event_slot_epoll {
-	int fd;
-	int events;
-	int gen;
-	gf_atomic_t ref;
-	int do_close;
-	int in_handler;
-        int handled_error;
-	void *data;
-	event_handler_t handler;
-	gf_lock_t lock;
+    int fd;
+    int events;
+    int gen;
+    gf_atomic_t ref;
+    int do_close;
+    int in_handler;
+    int handled_error;
+    void *data;
+    event_handler_t handler;
+    gf_lock_t lock;
 };
 
 struct event_thread_data {
-        struct event_pool *event_pool;
-        int    event_index;
+    struct event_pool *event_pool;
+    int event_index;
 };
 
 static struct event_slot_epoll *
-__event_newtable (struct event_pool *event_pool, int table_idx)
+__event_newtable(struct event_pool *event_pool, int table_idx)
 {
-	struct event_slot_epoll *table = NULL;
-	int                      i = -1;
+    struct event_slot_epoll *table = NULL;
+    int i = -1;
 
-	table = GF_CALLOC (sizeof (*table), EVENT_EPOLL_SLOTS,
-			   gf_common_mt_ereg);
-	if (!table)
-		return NULL;
+    table = GF_CALLOC(sizeof(*table), EVENT_EPOLL_SLOTS, gf_common_mt_ereg);
+    if (!table)
+        return NULL;
 
-	for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
-		table[i].fd = -1;
-		LOCK_INIT (&table[i].lock);
-	}
+    for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
+        table[i].fd = -1;
+        LOCK_INIT(&table[i].lock);
+    }
 
-	event_pool->ereg[table_idx] = table;
-	event_pool->slots_used[table_idx] = 0;
+    event_pool->ereg[table_idx] = table;
+    event_pool->slots_used[table_idx] = 0;
 
-	return table;
+    return table;
 }
 
-
 static int
-__event_slot_alloc (struct event_pool *event_pool, int fd)
+__event_slot_alloc(struct event_pool *event_pool, int fd)
 {
-        int  i = 0;
-	int  table_idx = -1;
-	int  gen = -1;
-	struct event_slot_epoll *table = NULL;
-
-	for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
-		switch (event_pool->slots_used[i]) {
-		case EVENT_EPOLL_SLOTS:
-			continue;
-		case 0:
-			if (!event_pool->ereg[i]) {
-				table = __event_newtable (event_pool, i);
-				if (!table)
-					return -1;
-			} else {
-                                table = event_pool->ereg[i];
-                        }
-			break;
-		default:
-			table = event_pool->ereg[i];
-			break;
-		}
-
-		if (table)
-			/* break out of the loop */
-			break;
-	}
-
-	if (!table)
-		return -1;
-
-	table_idx = i;
-
-	for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
-		if (table[i].fd == -1) {
-			/* wipe everything except bump the generation */
-			gen = table[i].gen;
-			memset (&table[i], 0, sizeof (table[i]));
-			table[i].gen = gen + 1;
-
-			LOCK_INIT (&table[i].lock);
-
-			table[i].fd = fd;
-			event_pool->slots_used[table_idx]++;
-
-			break;
-		}
-	}
-
-	return table_idx * EVENT_EPOLL_SLOTS + i;
-}
+    int i = 0;
+    int table_idx = -1;
+    int gen = -1;
+    struct event_slot_epoll *table = NULL;
+
+    for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
+        switch (event_pool->slots_used[i]) {
+            case EVENT_EPOLL_SLOTS:
+                continue;
+            case 0:
+                if (!event_pool->ereg[i]) {
+                    table = __event_newtable(event_pool, i);
+                    if (!table)
+                        return -1;
+                } else {
+                    table = event_pool->ereg[i];
+                }
+                break;
+            default:
+                table = event_pool->ereg[i];
+                break;
+        }
 
+        if (table)
+            /* break out of the loop */
+            break;
+    }
 
-static int
-event_slot_alloc (struct event_pool *event_pool, int fd)
-{
-	int  idx = -1;
+    if (!table)
+        return -1;
+
+    table_idx = i;
+
+    for (i = 0; i < EVENT_EPOLL_SLOTS; i++) {
+        if (table[i].fd == -1) {
+            /* wipe everything except bump the generation */
+            gen = table[i].gen;
+            memset(&table[i], 0, sizeof(table[i]));
+            table[i].gen = gen + 1;
 
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_slot_alloc (event_pool, fd);
-	}
-	pthread_mutex_unlock (&event_pool->mutex);
+            LOCK_INIT(&table[i].lock);
 
-	return idx;
+            table[i].fd = fd;
+            event_pool->slots_used[table_idx]++;
+
+            break;
+        }
+    }
+
+    return table_idx * EVENT_EPOLL_SLOTS + i;
 }
 
+static int
+event_slot_alloc(struct event_pool *event_pool, int fd)
+{
+    int idx = -1;
 
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_slot_alloc(event_pool, fd);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    return idx;
+}
 
 static void
-__event_slot_dealloc (struct event_pool *event_pool, int idx)
+__event_slot_dealloc(struct event_pool *event_pool, int idx)
 {
-	int                      table_idx = 0;
-	int                      offset = 0;
-	struct event_slot_epoll *table = NULL;
-	struct event_slot_epoll *slot = NULL;
+    int table_idx = 0;
+    int offset = 0;
+    struct event_slot_epoll *table = NULL;
+    struct event_slot_epoll *slot = NULL;
 
-	table_idx = idx / EVENT_EPOLL_SLOTS;
-	offset = idx % EVENT_EPOLL_SLOTS;
+    table_idx = idx / EVENT_EPOLL_SLOTS;
+    offset = idx % EVENT_EPOLL_SLOTS;
 
-	table = event_pool->ereg[table_idx];
-	if (!table)
-		return;
+    table = event_pool->ereg[table_idx];
+    if (!table)
+        return;
 
-	slot = &table[offset];
-	slot->gen++;
+    slot = &table[offset];
+    slot->gen++;
 
-	slot->fd = -1;
-        slot->handled_error = 0;
-        slot->in_handler = 0;
-	event_pool->slots_used[table_idx]--;
+    slot->fd = -1;
+    slot->handled_error = 0;
+    slot->in_handler = 0;
+    event_pool->slots_used[table_idx]--;
 
-	return;
+    return;
 }
 
-
 static void
-event_slot_dealloc (struct event_pool *event_pool, int idx)
+event_slot_dealloc(struct event_pool *event_pool, int idx)
 {
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		__event_slot_dealloc (event_pool, idx);
-	}
-	pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        __event_slot_dealloc(event_pool, idx);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-	return;
+    return;
 }
 
-
 static struct event_slot_epoll *
-event_slot_get (struct event_pool *event_pool, int idx)
+event_slot_get(struct event_pool *event_pool, int idx)
 {
-	struct event_slot_epoll *slot = NULL;
-	struct event_slot_epoll *table = NULL;
-	int                      table_idx = 0;
-	int                      offset = 0;
+    struct event_slot_epoll *slot = NULL;
+    struct event_slot_epoll *table = NULL;
+    int table_idx = 0;
+    int offset = 0;
 
-	table_idx = idx / EVENT_EPOLL_SLOTS;
-	offset = idx % EVENT_EPOLL_SLOTS;
+    table_idx = idx / EVENT_EPOLL_SLOTS;
+    offset = idx % EVENT_EPOLL_SLOTS;
 
-	table = event_pool->ereg[table_idx];
-	if (!table)
-		return NULL;
+    table = event_pool->ereg[table_idx];
+    if (!table)
+        return NULL;
 
-	slot = &table[offset];
-        GF_ATOMIC_INC (slot->ref);
+    slot = &table[offset];
+    GF_ATOMIC_INC(slot->ref);
 
-	return slot;
+    return slot;
 }
 
-
 static void
-event_slot_unref (struct event_pool *event_pool, struct event_slot_epoll *slot,
-		  int idx)
+event_slot_unref(struct event_pool *event_pool, struct event_slot_epoll *slot,
+                 int idx)
 {
-	int ref = -1;
-	int fd = -1;
-	int do_close = 0;
-
-        ref = GF_ATOMIC_DEC (slot->ref);
-	if (ref)
-		/* slot still alive */
-		goto done;
-
-	LOCK (&slot->lock);
-	{
-		fd = slot->fd;
-		do_close = slot->do_close;
-                slot->do_close = 0;
-	}
-	UNLOCK (&slot->lock);
-
-	event_slot_dealloc (event_pool, idx);
-
-	if (do_close)
-		sys_close (fd);
+    int ref = -1;
+    int fd = -1;
+    int do_close = 0;
+
+    ref = GF_ATOMIC_DEC(slot->ref);
+    if (ref)
+        /* slot still alive */
+        goto done;
+
+    LOCK(&slot->lock);
+    {
+        fd = slot->fd;
+        do_close = slot->do_close;
+        slot->do_close = 0;
+    }
+    UNLOCK(&slot->lock);
+
+    event_slot_dealloc(event_pool, idx);
+
+    if (do_close)
+        sys_close(fd);
 done:
-	return;
+    return;
 }
 
-
 static struct event_pool *
-event_pool_new_epoll (int count, int eventthreadcount)
+event_pool_new_epoll(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-        int                epfd = -1;
+    struct event_pool *event_pool = NULL;
+    int epfd = -1;
 
-        event_pool = GF_CALLOC (1, sizeof (*event_pool),
-                                gf_common_mt_event_pool);
+    event_pool = GF_CALLOC(1, sizeof(*event_pool), gf_common_mt_event_pool);
 
-        if (!event_pool)
-                goto out;
+    if (!event_pool)
+        goto out;
 
-        epfd = epoll_create (count);
+    epfd = epoll_create(count);
 
-        if (epfd == -1) {
-                gf_msg ("epoll", GF_LOG_ERROR, errno,
-                        LG_MSG_EPOLL_FD_CREATE_FAILED, "epoll fd creation "
-                        "failed");
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                event_pool = NULL;
-                goto out;
-        }
+    if (epfd == -1) {
+        gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_CREATE_FAILED,
+               "epoll fd creation "
+               "failed");
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        event_pool = NULL;
+        goto out;
+    }
 
-        event_pool->fd = epfd;
+    event_pool->fd = epfd;
 
-        event_pool->count = count;
+    event_pool->count = count;
 
-        event_pool->eventthreadcount = eventthreadcount;
-        event_pool->auto_thread_count = 0;
+    event_pool->eventthreadcount = eventthreadcount;
+    event_pool->auto_thread_count = 0;
 
-        pthread_mutex_init (&event_pool->mutex, NULL);
+    pthread_mutex_init(&event_pool->mutex, NULL);
 
 out:
-        return event_pool;
+    return event_pool;
 }
 
-
 static void
-__slot_update_events (struct event_slot_epoll *slot, int poll_in, int poll_out)
+__slot_update_events(struct event_slot_epoll *slot, int poll_in, int poll_out)
 {
-	switch (poll_in) {
-	case 1:
-		slot->events |= EPOLLIN;
-		break;
-	case 0:
-		slot->events &= ~EPOLLIN;
-		break;
-	case -1:
-		/* do nothing */
-		break;
-	default:
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
-			"invalid poll_in value %d", poll_in);
-		break;
-	}
-
-	switch (poll_out) {
-	case 1:
-		slot->events |= EPOLLOUT;
-		break;
-	case 0:
-		slot->events &= ~EPOLLOUT;
-		break;
-	case -1:
-		/* do nothing */
-		break;
-	default:
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
-			"invalid poll_out value %d", poll_out);
-		break;
-	}
+    switch (poll_in) {
+        case 1:
+            slot->events |= EPOLLIN;
+            break;
+        case 0:
+            slot->events &= ~EPOLLIN;
+            break;
+        case -1:
+            /* do nothing */
+            break;
+        default:
+            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                   "invalid poll_in value %d", poll_in);
+            break;
+    }
+
+    switch (poll_out) {
+        case 1:
+            slot->events |= EPOLLOUT;
+            break;
+        case 0:
+            slot->events &= ~EPOLLOUT;
+            break;
+        case -1:
+            /* do nothing */
+            break;
+        default:
+            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                   "invalid poll_out value %d", poll_out);
+            break;
+    }
 }
 
-
 int
-event_register_epoll (struct event_pool *event_pool, int fd,
-                      event_handler_t handler,
-                      void *data, int poll_in, int poll_out)
+event_register_epoll(struct event_pool *event_pool, int fd,
+                     event_handler_t handler, void *data, int poll_in,
+                     int poll_out)
 {
-        int                 idx = -1;
-        int                 ret = -1;
-        int             destroy = 0;
-        struct epoll_event  epoll_event = {0, };
-        struct event_data  *ev_data = (void *)&epoll_event.data;
-	struct event_slot_epoll *slot = NULL;
-
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        /* TODO: Even with the below check, there is a possibility of race,
-         * What if the destroy mode is set after the check is done.
-         * Not sure of the best way to prevent this race, ref counting
-         * is one possibility.
-         * There is no harm in registering and unregistering the fd
-         * even after destroy mode is set, just that such fds will remain
-         * open until unregister is called, also the events on that fd will be
-         * notified, until one of the poller thread is alive.
-         */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                destroy = event_pool->destroy;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        if (destroy == 1)
-               goto out;
-
-	idx = event_slot_alloc (event_pool, fd);
-	if (idx == -1) {
-		gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-			"could not find slot for fd=%d", fd);
-		return -1;
-	}
-
-	slot = event_slot_get (event_pool, idx);
-        if (!slot) {
-                gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-                        "could not find slot for fd=%d idx=%d", fd, idx);
-                return -1;
-        }
-
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		/* make epoll 'singleshot', which
-		   means we need to re-add the fd with
-		   epoll_ctl(EPOLL_CTL_MOD) after delivery of every
-		   single event. This assures us that while a poller
-		   thread has picked up and is processing an event,
-		   another poller will not try to pick this at the same
-		   time as well.
-		*/
-
-		slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT;
-		slot->handler = handler;
-		slot->data = data;
-
-		__slot_update_events (slot, poll_in, poll_out);
-
-		epoll_event.events = slot->events;
-		ev_data->idx = idx;
-		ev_data->gen = slot->gen;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd,
-				 &epoll_event);
-		/* check ret after UNLOCK() to avoid deadlock in
-		   event_slot_unref()
-		*/
-	}
-	UNLOCK (&slot->lock);
-
-	if (ret == -1) {
-		gf_msg ("epoll", GF_LOG_ERROR, errno,
-                        LG_MSG_EPOLL_FD_ADD_FAILED, "failed to add fd(=%d) to "
-                        "epoll fd(=%d)", fd, event_pool->fd);
-		event_slot_unref (event_pool, slot, idx);
-		idx = -1;
-	}
-
-	/* keep slot->ref (do not event_slot_unref) if successful */
+    int idx = -1;
+    int ret = -1;
+    int destroy = 0;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+    struct event_slot_epoll *slot = NULL;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    /* TODO: Even with the below check, there is a possibility of race,
+     * What if the destroy mode is set after the check is done.
+     * Not sure of the best way to prevent this race, ref counting
+     * is one possibility.
+     * There is no harm in registering and unregistering the fd
+     * even after destroy mode is set, just that such fds will remain
+     * open until unregister is called, also the events on that fd will be
+     * notified, until one of the poller thread is alive.
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        destroy = event_pool->destroy;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    if (destroy == 1)
+        goto out;
+
+    idx = event_slot_alloc(event_pool, fd);
+    if (idx == -1) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for fd=%d", fd);
+        return -1;
+    }
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for fd=%d idx=%d", fd, idx);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        /* make epoll 'singleshot', which
+           means we need to re-add the fd with
+           epoll_ctl(EPOLL_CTL_MOD) after delivery of every
+           single event. This assures us that while a poller
+           thread has picked up and is processing an event,
+           another poller will not try to pick this at the same
+           time as well.
+        */
+
+        slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT;
+        slot->handler = handler;
+        slot->data = data;
+
+        __slot_update_events(slot, poll_in, poll_out);
+
+        epoll_event.events = slot->events;
+        ev_data->idx = idx;
+        ev_data->gen = slot->gen;
+
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_ADD, fd, &epoll_event);
+        /* check ret after UNLOCK() to avoid deadlock in
+           event_slot_unref()
+        */
+    }
+    UNLOCK(&slot->lock);
+
+    if (ret == -1) {
+        gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_ADD_FAILED,
+               "failed to add fd(=%d) to "
+               "epoll fd(=%d)",
+               fd, event_pool->fd);
+        event_slot_unref(event_pool, slot, idx);
+        idx = -1;
+    }
+
+    /* keep slot->ref (do not event_slot_unref) if successful */
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_epoll_common (struct event_pool *event_pool, int fd,
-			       int idx, int do_close)
+event_unregister_epoll_common(struct event_pool *event_pool, int fd, int idx,
+                              int do_close)
 {
-        int  ret = -1;
-	struct event_slot_epoll *slot = NULL;
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        /* During shutdown, it may happen that a socket registration with
-         * the event sub-system may fail and an rpc_transport_unref() may
-         * be called for such an unregistered socket with idx == -1. This
-         * may cause the following assert(slot->fd == fd) to fail.
-         */
-        if (idx < 0)
-                goto out;
-
-	slot = event_slot_get (event_pool, idx);
-        if (!slot) {
-                gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-                        "could not find slot for fd=%d idx=%d", fd, idx);
-                return -1;
+    int ret = -1;
+    struct event_slot_epoll *slot = NULL;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    /* During shutdown, it may happen that a socket registration with
+     * the event sub-system may fail and an rpc_transport_unref() may
+     * be called for such an unregistered socket with idx == -1. This
+     * may cause the following assert(slot->fd == fd) to fail.
+     */
+    if (idx < 0)
+        goto out;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for fd=%d idx=%d", fd, idx);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
+
+        if (ret == -1) {
+            gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_DEL_FAILED,
+                   "fail to del "
+                   "fd(=%d) from epoll fd(=%d)",
+                   fd, event_pool->fd);
+            goto unlock;
         }
 
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
-
-                if (ret == -1) {
-                        gf_msg ("epoll", GF_LOG_ERROR, errno,
-                                LG_MSG_EPOLL_FD_DEL_FAILED, "fail to del "
-                                "fd(=%d) from epoll fd(=%d)", fd,
-                                event_pool->fd);
-                        goto unlock;
-                }
-
-		slot->do_close = do_close;
-		slot->gen++; /* detect unregister in dispatch_handler() */
-        }
+        slot->do_close = do_close;
+        slot->gen++; /* detect unregister in dispatch_handler() */
+    }
 unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-	event_slot_unref (event_pool, slot, idx); /* one for event_register() */
-	event_slot_unref (event_pool, slot, idx); /* one for event_slot_get() */
+    event_slot_unref(event_pool, slot, idx); /* one for event_register() */
+    event_slot_unref(event_pool, slot, idx); /* one for event_slot_get() */
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-event_unregister_epoll (struct event_pool *event_pool, int fd, int idx_hint)
+event_unregister_epoll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 0);
+    ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 0);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-event_unregister_close_epoll (struct event_pool *event_pool, int fd,
-			      int idx_hint)
+event_unregister_close_epoll(struct event_pool *event_pool, int fd,
+                             int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 1);
+    ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 1);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-event_select_on_epoll (struct event_pool *event_pool, int fd, int idx,
-                       int poll_in, int poll_out)
+event_select_on_epoll(struct event_pool *event_pool, int fd, int idx,
+                      int poll_in, int poll_out)
 {
-        int ret = -1;
-	struct event_slot_epoll *slot = NULL;
-        struct epoll_event epoll_event = {0, };
-        struct event_data *ev_data = (void *)&epoll_event.data;
-
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-	slot = event_slot_get (event_pool, idx);
-        if (!slot) {
-                gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-                        "could not find slot for fd=%d idx=%d", fd, idx);
-                return -1;
+    int ret = -1;
+    struct event_slot_epoll *slot = NULL;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for fd=%d idx=%d", fd, idx);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        __slot_update_events(slot, poll_in, poll_out);
+
+        epoll_event.events = slot->events;
+        ev_data->idx = idx;
+        ev_data->gen = slot->gen;
+
+        if (slot->in_handler)
+            /*
+             * in_handler indicates at least one thread
+             * executing event_dispatch_epoll_handler()
+             * which will perform epoll_ctl(EPOLL_CTL_MOD)
+             * anyways (because of EPOLLET)
+             *
+             * This not only saves a system call, but also
+             * avoids possibility of another epoll thread
+             * picking up the next event while the ongoing
+             * handler is still in progress (and resulting
+             * in unnecessary contention on rpc_transport_t->mutex).
+             */
+            goto unlock;
+
+        ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event);
+        if (ret == -1) {
+            gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_MODIFY_FAILED,
+                   "failed to "
+                   "modify fd(=%d) events to %d",
+                   fd, epoll_event.events);
         }
-
-	assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		__slot_update_events (slot, poll_in, poll_out);
-
-		epoll_event.events = slot->events;
-		ev_data->idx = idx;
-		ev_data->gen = slot->gen;
-
-		if (slot->in_handler)
-			/*
-			 * in_handler indicates at least one thread
-			 * executing event_dispatch_epoll_handler()
-			 * which will perform epoll_ctl(EPOLL_CTL_MOD)
-			 * anyways (because of EPOLLET)
-			 *
-			 * This not only saves a system call, but also
-			 * avoids possibility of another epoll thread
-			 * picking up the next event while the ongoing
-			 * handler is still in progress (and resulting
-			 * in unnecessary contention on rpc_transport_t->mutex).
-			 */
-			goto unlock;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, fd,
-				 &epoll_event);
-		if (ret == -1) {
-			gf_msg ("epoll", GF_LOG_ERROR, errno,
-                                LG_MSG_EPOLL_FD_MODIFY_FAILED, "failed to "
-                                "modify fd(=%d) events to %d", fd,
-                                epoll_event.events);
-		}
-	}
+    }
 unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-	event_slot_unref (event_pool, slot, idx);
+    event_slot_unref(event_pool, slot, idx);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_dispatch_epoll_handler (struct event_pool *event_pool,
-                              struct epoll_event *event)
+event_dispatch_epoll_handler(struct event_pool *event_pool,
+                             struct epoll_event *event)
 {
-        struct event_data  *ev_data = NULL;
-	struct event_slot_epoll *slot = NULL;
-        event_handler_t     handler = NULL;
-        void               *data = NULL;
-        int                 idx = -1;
-	int                 gen = -1;
-        int                 ret = -1;
-	int                 fd = -1;
-        gf_boolean_t        handled_error_previously = _gf_false;
-
-	ev_data = (void *)&event->data;
-        handler = NULL;
-        data = NULL;
-
-	idx = ev_data->idx;
-	gen = ev_data->gen;
-
-	slot = event_slot_get (event_pool, idx);
-        if (!slot) {
-                gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-                        "could not find slot for idx=%d", idx);
-                return -1;
+    struct event_data *ev_data = NULL;
+    struct event_slot_epoll *slot = NULL;
+    event_handler_t handler = NULL;
+    void *data = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+    gf_boolean_t handled_error_previously = _gf_false;
+
+    ev_data = (void *)&event->data;
+    handler = NULL;
+    data = NULL;
+
+    idx = ev_data->idx;
+    gen = ev_data->gen;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for idx=%d", idx);
+        return -1;
+    }
+
+    LOCK(&slot->lock);
+    {
+        fd = slot->fd;
+        if (fd == -1) {
+            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_STALE_FD_FOUND,
+                   "stale fd found on "
+                   "idx=%d, gen=%d, events=%d, slot->gen=%d",
+                   idx, gen, event->events, slot->gen);
+            /* fd got unregistered in another thread */
+            goto pre_unlock;
         }
 
-	LOCK (&slot->lock);
-	{
-		fd = slot->fd;
-		if (fd == -1) {
-			gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_STALE_FD_FOUND, "stale fd found on "
-                                "idx=%d, gen=%d, events=%d, slot->gen=%d",
-				idx, gen, event->events, slot->gen);
-			/* fd got unregistered in another thread */
-			goto pre_unlock;
-		}
-
-		if (gen != slot->gen) {
-			gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_GENERATION_MISMATCH, "generation "
-                                "mismatch on idx=%d, gen=%d, slot->gen=%d, "
-                                "slot->fd=%d", idx, gen, slot->gen, slot->fd);
-			/* slot was re-used and therefore is another fd! */
-			goto pre_unlock;
-		}
-
-		handler = slot->handler;
-		data = slot->data;
-
-                if (slot->handled_error) {
-                        handled_error_previously = _gf_true;
-                } else {
-                        slot->handled_error = (event->events
-                                               & (EPOLLERR|EPOLLHUP));
-                        slot->in_handler++;
-                }
-	}
+        if (gen != slot->gen) {
+            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_GENERATION_MISMATCH,
+                   "generation "
+                   "mismatch on idx=%d, gen=%d, slot->gen=%d, "
+                   "slot->fd=%d",
+                   idx, gen, slot->gen, slot->fd);
+            /* slot was re-used and therefore is another fd! */
+            goto pre_unlock;
+        }
+
+        handler = slot->handler;
+        data = slot->data;
+
+        if (slot->handled_error) {
+            handled_error_previously = _gf_true;
+        } else {
+            slot->handled_error = (event->events & (EPOLLERR | EPOLLHUP));
+            slot->in_handler++;
+        }
+    }
 pre_unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-        ret = 0;
+    ret = 0;
 
-        if (!handler)
-		goto out;
+    if (!handler)
+        goto out;
 
-        if (!handled_error_previously) {
-                ret = handler (fd, idx, gen, data,
-                               (event->events & (EPOLLIN|EPOLLPRI)),
-                               (event->events & (EPOLLOUT)),
-                               (event->events & (EPOLLERR|EPOLLHUP)));
-        }
+    if (!handled_error_previously) {
+        ret = handler(fd, idx, gen, data,
+                      (event->events & (EPOLLIN | EPOLLPRI)),
+                      (event->events & (EPOLLOUT)),
+                      (event->events & (EPOLLERR | EPOLLHUP)));
+    }
 out:
-	event_slot_unref (event_pool, slot, idx);
+    event_slot_unref(event_pool, slot, idx);
 
-        return ret;
+    return ret;
 }
 
-
 static void *
-event_dispatch_epoll_worker (void *data)
+event_dispatch_epoll_worker(void *data)
 {
-        struct epoll_event  event;
-        int                 ret = -1;
-        struct event_thread_data *ev_data = data;
-	struct event_pool  *event_pool;
-        int                 myindex = -1;
-        int                 timetodie = 0;
-
-        GF_VALIDATE_OR_GOTO ("event", ev_data, out);
-
-        event_pool = ev_data->event_pool;
-        myindex = ev_data->event_index;
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        gf_msg ("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, "Started"
-                " thread with index %d", myindex);
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                event_pool->activethreadcount++;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-	for (;;) {
+    struct epoll_event event;
+    int ret = -1;
+    struct event_thread_data *ev_data = data;
+    struct event_pool *event_pool;
+    int myindex = -1;
+    int timetodie = 0;
+
+    GF_VALIDATE_OR_GOTO("event", ev_data, out);
+
+    event_pool = ev_data->event_pool;
+    myindex = ev_data->event_index;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD,
+           "Started"
+           " thread with index %d",
+           myindex);
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount++;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    for (;;) {
+        if (event_pool->eventthreadcount < myindex) {
+            /* ...time to die, thread count was decreased below
+             * this threads index */
+            /* Start with extra safety at this point, reducing
+             * lock conention in normal case when threads are not
+             * reconfigured always */
+            pthread_mutex_lock(&event_pool->mutex);
+            {
                 if (event_pool->eventthreadcount < myindex) {
-                        /* ...time to die, thread count was decreased below
-                         * this threads index */
-                        /* Start with extra safety at this point, reducing
-                         * lock conention in normal case when threads are not
-                         * reconfigured always */
-                        pthread_mutex_lock (&event_pool->mutex);
-                        {
-                                if (event_pool->eventthreadcount <
-                                    myindex) {
-                                        /* if found true in critical section,
-                                         * die */
-                                        event_pool->pollers[myindex - 1] = 0;
-                                        event_pool->activethreadcount--;
-                                        timetodie = 1;
-                                        pthread_cond_broadcast (&event_pool->cond);
-                                }
-                        }
-                        pthread_mutex_unlock (&event_pool->mutex);
-                        if (timetodie) {
-                                gf_msg ("epoll", GF_LOG_INFO, 0,
-                                        LG_MSG_EXITED_EPOLL_THREAD, "Exited "
-                                        "thread with index %d", myindex);
-                                goto out;
-                        }
+                    /* if found true in critical section,
+                     * die */
+                    event_pool->pollers[myindex - 1] = 0;
+                    event_pool->activethreadcount--;
+                    timetodie = 1;
+                    pthread_cond_broadcast(&event_pool->cond);
                 }
+            }
+            pthread_mutex_unlock(&event_pool->mutex);
+            if (timetodie) {
+                gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_EXITED_EPOLL_THREAD,
+                       "Exited "
+                       "thread with index %d",
+                       myindex);
+                goto out;
+            }
+        }
 
-                ret = epoll_wait (event_pool->fd, &event, 1, -1);
+        ret = epoll_wait(event_pool->fd, &event, 1, -1);
 
-                if (ret == 0)
-                        /* timeout */
-                        continue;
+        if (ret == 0)
+            /* timeout */
+            continue;
 
-                if (ret == -1 && errno == EINTR)
-                        /* sys call */
-                        continue;
+        if (ret == -1 && errno == EINTR)
+            /* sys call */
+            continue;
 
-		ret = event_dispatch_epoll_handler (event_pool, &event);
-                if (ret) {
-                        gf_msg ("epoll", GF_LOG_ERROR, 0,
-                                LG_MSG_EXITED_EPOLL_THREAD,
-                                "Failed to dispatch handler");
-                }
+        ret = event_dispatch_epoll_handler(event_pool, &event);
+        if (ret) {
+            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_EXITED_EPOLL_THREAD,
+                   "Failed to dispatch handler");
         }
+    }
 out:
-        if (ev_data)
-                GF_FREE (ev_data);
-        return NULL;
+    if (ev_data)
+        GF_FREE(ev_data);
+    return NULL;
 }
 
 /* Attempts to start the # of configured pollers, ensuring at least the first
  * is started in a joinable state */
 static int
-event_dispatch_epoll (struct event_pool *event_pool)
+event_dispatch_epoll(struct event_pool *event_pool)
 {
-	int                       i = 0;
-        pthread_t                 t_id;
-        int                       pollercount = 0;
-	int                       ret = -1;
-        struct event_thread_data *ev_data = NULL;
-        char                      thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        /* Start the configured number of pollers */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                pollercount = event_pool->eventthreadcount;
-
-                /* Set to MAX if greater */
-                if (pollercount > EVENT_MAX_THREADS)
-                        pollercount = EVENT_MAX_THREADS;
-
-                /* Default pollers to 1 in case this is incorrectly set */
-                if (pollercount <= 0)
-                        pollercount = 1;
-
-                event_pool->activethreadcount++;
-
-                for (i = 0; i < pollercount; i++) {
-                        ev_data = GF_CALLOC (1, sizeof (*ev_data),
-                                     gf_common_mt_event_pool);
-                        if (!ev_data) {
-                                if (i == 0) {
-                                        /* Need to succeed creating 0'th
-                                         * thread, to joinable and wait */
-                                        break;
-                                } else {
-                                        /* Inability to create other threads
-                                         * are a lesser evil, and ignored */
-                                        continue;
-                                }
-                        }
-
-                        ev_data->event_pool = event_pool;
-                        ev_data->event_index = i + 1;
-
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "epoll%03hx", (i & 0x3ff));
-                        ret = gf_thread_create (&t_id, NULL,
-                                                event_dispatch_epoll_worker,
-                                                ev_data, thread_name);
-                        if (!ret) {
-                                event_pool->pollers[i] = t_id;
-
-                                /* mark all threads other than one in index 0
-                                 * as detachable. Errors can be ignored, they
-                                 * spend their time as zombies if not detched
-                                 * and the thread counts are decreased */
-                                if (i != 0)
-                                        pthread_detach (event_pool->pollers[i]);
-                        } else {
-                                gf_msg ("epoll", GF_LOG_WARNING, 0,
-                                        LG_MSG_START_EPOLL_THREAD_FAILED,
-                                        "Failed to start thread for index %d",
-                                        i);
-                                if (i == 0) {
-                                        GF_FREE (ev_data);
-                                        break;
-                                } else {
-                                        GF_FREE (ev_data);
-                                        continue;
-                                }
-                        }
+    int i = 0;
+    pthread_t t_id;
+    int pollercount = 0;
+    int ret = -1;
+    struct event_thread_data *ev_data = NULL;
+    char thread_name[GF_THREAD_NAMEMAX] = {
+        0,
+    };
+
+    /* Start the configured number of pollers */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        pollercount = event_pool->eventthreadcount;
+
+        /* Set to MAX if greater */
+        if (pollercount > EVENT_MAX_THREADS)
+            pollercount = EVENT_MAX_THREADS;
+
+        /* Default pollers to 1 in case this is incorrectly set */
+        if (pollercount <= 0)
+            pollercount = 1;
+
+        event_pool->activethreadcount++;
+
+        for (i = 0; i < pollercount; i++) {
+            ev_data = GF_CALLOC(1, sizeof(*ev_data), gf_common_mt_event_pool);
+            if (!ev_data) {
+                if (i == 0) {
+                    /* Need to succeed creating 0'th
+                     * thread, to joinable and wait */
+                    break;
+                } else {
+                    /* Inability to create other threads
+                     * are a lesser evil, and ignored */
+                    continue;
                 }
+            }
+
+            ev_data->event_pool = event_pool;
+            ev_data->event_index = i + 1;
+
+            snprintf(thread_name, sizeof(thread_name), "epoll%03hx",
+                     (i & 0x3ff));
+            ret = gf_thread_create(&t_id, NULL, event_dispatch_epoll_worker,
+                                   ev_data, thread_name);
+            if (!ret) {
+                event_pool->pollers[i] = t_id;
+
+                /* mark all threads other than one in index 0
+                 * as detachable. Errors can be ignored, they
+                 * spend their time as zombies if not detched
+                 * and the thread counts are decreased */
+                if (i != 0)
+                    pthread_detach(event_pool->pollers[i]);
+            } else {
+                gf_msg("epoll", GF_LOG_WARNING, 0,
+                       LG_MSG_START_EPOLL_THREAD_FAILED,
+                       "Failed to start thread for index %d", i);
+                if (i == 0) {
+                    GF_FREE(ev_data);
+                    break;
+                } else {
+                    GF_FREE(ev_data);
+                    continue;
+                }
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        /* Just wait for the first thread, that is created in a joinable state
-         * and will never die, ensuring this function never returns */
-        if (event_pool->pollers[0] != 0)
-		pthread_join (event_pool->pollers[0], NULL);
+    /* Just wait for the first thread, that is created in a joinable state
+     * and will never die, ensuring this function never returns */
+    if (event_pool->pollers[0] != 0)
+        pthread_join(event_pool->pollers[0], NULL);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                event_pool->activethreadcount--;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount--;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-	return ret;
+    return ret;
 }
 
 /**
@@ -795,89 +776,87 @@ event_dispatch_epoll (struct event_pool *event_pool)
  */
 
 static int
-event_pool_dispatched_unlocked (struct event_pool *event_pool)
+event_pool_dispatched_unlocked(struct event_pool *event_pool)
 {
-        return (event_pool->pollers[0] != 0);
-
+    return (event_pool->pollers[0] != 0);
 }
 
-
 int
-event_reconfigure_threads_epoll (struct event_pool *event_pool, int value)
+event_reconfigure_threads_epoll(struct event_pool *event_pool, int value)
 {
-        int                              i;
-        int                              ret = 0;
-        pthread_t                        t_id;
-        int                              oldthreadcount;
-        struct event_thread_data        *ev_data = NULL;
-        char                             thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                /* Reconfigure to 0 threads is allowed only in destroy mode */
-                if (event_pool->destroy == 1) {
-                        value = 0;
-                } else {
-                        /* Set to MAX if greater */
-                        if (value > EVENT_MAX_THREADS)
-                                value = EVENT_MAX_THREADS;
-
-                        /* Default pollers to 1 in case this is set incorrectly */
-                        if (value <= 0)
-                                value = 1;
-                }
+    int i;
+    int ret = 0;
+    pthread_t t_id;
+    int oldthreadcount;
+    struct event_thread_data *ev_data = NULL;
+    char thread_name[GF_THREAD_NAMEMAX] = {
+        0,
+    };
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        /* Reconfigure to 0 threads is allowed only in destroy mode */
+        if (event_pool->destroy == 1) {
+            value = 0;
+        } else {
+            /* Set to MAX if greater */
+            if (value > EVENT_MAX_THREADS)
+                value = EVENT_MAX_THREADS;
+
+            /* Default pollers to 1 in case this is set incorrectly */
+            if (value <= 0)
+                value = 1;
+        }
 
-                oldthreadcount = event_pool->eventthreadcount;
-
-                /* Start 'worker' threads as necessary only if event_dispatch()
-                 * was called before. If event_dispatch() was not called, there
-                 * will be no epoll 'worker' threads running yet. */
-
-                if (event_pool_dispatched_unlocked(event_pool)
-                    && (oldthreadcount < value)) {
-                        /* create more poll threads */
-                        for (i = oldthreadcount; i < value; i++) {
-                                /* Start a thread if the index at this location
-                                 * is a 0, so that the older thread is confirmed
-                                 * as dead */
-                                if (event_pool->pollers[i] == 0) {
-                                        ev_data = GF_CALLOC (1,
-                                                      sizeof (*ev_data),
-                                                      gf_common_mt_event_pool);
-                                        if (!ev_data) {
-                                                continue;
-                                        }
-
-                                        ev_data->event_pool = event_pool;
-                                        ev_data->event_index = i + 1;
-
-                                        snprintf (thread_name,
-                                                  sizeof(thread_name),
-                                                  "epoll%03hx", (i & 0x3ff));
-                                        ret = gf_thread_create (&t_id, NULL,
-                                                event_dispatch_epoll_worker,
-                                                ev_data, thread_name);
-                                        if (ret) {
-                                                gf_msg ("epoll", GF_LOG_WARNING,
-                                                        0,
-                                                        LG_MSG_START_EPOLL_THREAD_FAILED,
-                                                        "Failed to start thread"
-                                                        " for index %d", i);
-                                                GF_FREE (ev_data);
-                                        } else {
-                                                pthread_detach (t_id);
-                                                event_pool->pollers[i] = t_id;
-                                        }
-                                }
-                        }
+        oldthreadcount = event_pool->eventthreadcount;
+
+        /* Start 'worker' threads as necessary only if event_dispatch()
+         * was called before. If event_dispatch() was not called, there
+         * will be no epoll 'worker' threads running yet. */
+
+        if (event_pool_dispatched_unlocked(event_pool) &&
+            (oldthreadcount < value)) {
+            /* create more poll threads */
+            for (i = oldthreadcount; i < value; i++) {
+                /* Start a thread if the index at this location
+                 * is a 0, so that the older thread is confirmed
+                 * as dead */
+                if (event_pool->pollers[i] == 0) {
+                    ev_data = GF_CALLOC(1, sizeof(*ev_data),
+                                        gf_common_mt_event_pool);
+                    if (!ev_data) {
+                        continue;
+                    }
+
+                    ev_data->event_pool = event_pool;
+                    ev_data->event_index = i + 1;
+
+                    snprintf(thread_name, sizeof(thread_name), "epoll%03hx",
+                             (i & 0x3ff));
+                    ret = gf_thread_create(&t_id, NULL,
+                                           event_dispatch_epoll_worker, ev_data,
+                                           thread_name);
+                    if (ret) {
+                        gf_msg("epoll", GF_LOG_WARNING, 0,
+                               LG_MSG_START_EPOLL_THREAD_FAILED,
+                               "Failed to start thread"
+                               " for index %d",
+                               i);
+                        GF_FREE(ev_data);
+                    } else {
+                        pthread_detach(t_id);
+                        event_pool->pollers[i] = t_id;
+                    }
                 }
-
-                /* if value decreases, threads will terminate, themselves */
-                event_pool->eventthreadcount = value;
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
 
-        return 0;
+        /* if value decreases, threads will terminate, themselves */
+        event_pool->eventthreadcount = value;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    return 0;
 }
 
 /* This function is the destructor for the event_pool data structure
@@ -885,98 +864,99 @@ event_reconfigure_threads_epoll (struct event_pool *event_pool, int value)
  * else will lead to crashes.
  */
 static int
-event_pool_destroy_epoll (struct event_pool *event_pool)
+event_pool_destroy_epoll(struct event_pool *event_pool)
 {
-        int ret = 0, i = 0, j = 0;
-        struct event_slot_epoll *table = NULL;
-
-        ret = sys_close (event_pool->fd);
-
-        for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
-                if (event_pool->ereg[i]) {
-                        table = event_pool->ereg[i];
-                        event_pool->ereg[i] = NULL;
-                                for (j = 0; j < EVENT_EPOLL_SLOTS; j++) {
-                                        LOCK_DESTROY (&table[j].lock);
-                                }
-                        GF_FREE (table);
-                }
+    int ret = 0, i = 0, j = 0;
+    struct event_slot_epoll *table = NULL;
+
+    ret = sys_close(event_pool->fd);
+
+    for (i = 0; i < EVENT_EPOLL_TABLES; i++) {
+        if (event_pool->ereg[i]) {
+            table = event_pool->ereg[i];
+            event_pool->ereg[i] = NULL;
+            for (j = 0; j < EVENT_EPOLL_SLOTS; j++) {
+                LOCK_DESTROY(&table[j].lock);
+            }
+            GF_FREE(table);
         }
+    }
 
-        pthread_mutex_destroy (&event_pool->mutex);
-        pthread_cond_destroy (&event_pool->cond);
+    pthread_mutex_destroy(&event_pool->mutex);
+    pthread_cond_destroy(&event_pool->cond);
 
-        GF_FREE (event_pool->evcache);
-        GF_FREE (event_pool->reg);
-        GF_FREE (event_pool);
+    GF_FREE(event_pool->evcache);
+    GF_FREE(event_pool->reg);
+    GF_FREE(event_pool);
 
-        return ret;
+    return ret;
 }
 
 static int
-event_handled_epoll (struct event_pool *event_pool, int fd, int idx, int gen)
+event_handled_epoll(struct event_pool *event_pool, int fd, int idx, int gen)
 {
-        struct event_slot_epoll *slot  = NULL;
-        struct epoll_event epoll_event = {0, };
-        struct event_data *ev_data     = (void *)&epoll_event.data;
-        int                ret         = 0;
-
-	slot = event_slot_get (event_pool, idx);
-        if (!slot) {
-                gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-                        "could not find slot for fd=%d idx=%d", fd, idx);
-                return -1;
+    struct event_slot_epoll *slot = NULL;
+    struct epoll_event epoll_event = {
+        0,
+    };
+    struct event_data *ev_data = (void *)&epoll_event.data;
+    int ret = 0;
+
+    slot = event_slot_get(event_pool, idx);
+    if (!slot) {
+        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
+               "could not find slot for fd=%d idx=%d", fd, idx);
+        return -1;
+    }
+
+    assert(slot->fd == fd);
+
+    LOCK(&slot->lock);
+    {
+        slot->in_handler--;
+
+        if (gen != slot->gen) {
+            /* event_unregister() happened while we were
+               in handler()
+            */
+            gf_msg_debug("epoll", 0,
+                         "generation bumped on idx=%d"
+                         " from gen=%d to slot->gen=%d, fd=%d, "
+                         "slot->fd=%d",
+                         idx, gen, slot->gen, fd, slot->fd);
+            goto post_unlock;
         }
 
-        assert (slot->fd == fd);
-
-	LOCK (&slot->lock);
-	{
-		slot->in_handler--;
-
-		if (gen != slot->gen) {
-			/* event_unregister() happened while we were
-			   in handler()
-			*/
-			gf_msg_debug ("epoll", 0, "generation bumped on idx=%d"
-                                      " from gen=%d to slot->gen=%d, fd=%d, "
-				      "slot->fd=%d", idx, gen, slot->gen, fd,
-                                      slot->fd);
-			goto post_unlock;
-		}
-
-		/* This call also picks up the changes made by another
-		   thread calling event_select_on_epoll() while this
-		   thread was busy in handler()
-		*/
-                if (slot->in_handler == 0) {
-                        epoll_event.events = slot->events;
-                        ev_data->idx = idx;
-                        ev_data->gen = gen;
-
-                        ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD,
-                                         fd, &epoll_event);
-                }
-	}
+        /* This call also picks up the changes made by another
+           thread calling event_select_on_epoll() while this
+           thread was busy in handler()
+        */
+        if (slot->in_handler == 0) {
+            epoll_event.events = slot->events;
+            ev_data->idx = idx;
+            ev_data->gen = gen;
+
+            ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event);
+        }
+    }
 post_unlock:
-	UNLOCK (&slot->lock);
+    UNLOCK(&slot->lock);
 
-        event_slot_unref (event_pool, slot, idx);
+    event_slot_unref(event_pool, slot, idx);
 
-        return ret;
+    return ret;
 }
 
-
 struct event_ops event_ops_epoll = {
-        .new                       = event_pool_new_epoll,
-        .event_register            = event_register_epoll,
-        .event_select_on           = event_select_on_epoll,
-        .event_unregister          = event_unregister_epoll,
-        .event_unregister_close    = event_unregister_close_epoll,
-        .event_dispatch            = event_dispatch_epoll,
-        .event_reconfigure_threads = event_reconfigure_threads_epoll,
-        .event_pool_destroy        = event_pool_destroy_epoll,
-        .event_handled             = event_handled_epoll,
+    .new = event_pool_new_epoll,
+    .event_register = event_register_epoll,
+    .event_select_on = event_select_on_epoll,
+    .event_unregister = event_unregister_epoll,
+    .event_unregister_close = event_unregister_close_epoll,
+    .event_dispatch = event_dispatch_epoll,
+    .event_reconfigure_threads = event_reconfigure_threads_epoll,
+    .event_pool_destroy = event_pool_destroy_epoll,
+    .event_handled = event_handled_epoll,
 };
 
 #endif
diff --git a/libglusterfs/src/event-history.c b/libglusterfs/src/event-history.c
index 95484a4322b..4845330f62b 100644
--- a/libglusterfs/src/event-history.c
+++ b/libglusterfs/src/event-history.c
@@ -12,72 +12,71 @@
 #include "libglusterfs-messages.h"
 
 eh_t *
-eh_new (size_t buffer_size, gf_boolean_t use_buffer_once,
-        void (*destroy_buffer_data) (void *data))
+eh_new(size_t buffer_size, gf_boolean_t use_buffer_once,
+       void (*destroy_buffer_data)(void *data))
 {
-        eh_t *history = NULL;
-        buffer_t *buffer = NULL;
+    eh_t *history = NULL;
+    buffer_t *buffer = NULL;
 
-        history = GF_CALLOC (1, sizeof (eh_t), gf_common_mt_eh_t);
-        if (!history) {
-                goto out;
-        }
+    history = GF_CALLOC(1, sizeof(eh_t), gf_common_mt_eh_t);
+    if (!history) {
+        goto out;
+    }
 
-        buffer = cb_buffer_new (buffer_size, use_buffer_once,
-                                destroy_buffer_data);
-        if (!buffer) {
-                GF_FREE (history);
-                history = NULL;
-                goto out;
-        }
+    buffer = cb_buffer_new(buffer_size, use_buffer_once, destroy_buffer_data);
+    if (!buffer) {
+        GF_FREE(history);
+        history = NULL;
+        goto out;
+    }
 
-        history->buffer = buffer;
+    history->buffer = buffer;
 
-        pthread_mutex_init (&history->lock, NULL);
+    pthread_mutex_init(&history->lock, NULL);
 out:
-        return history;
+    return history;
 }
 
 void
-eh_dump (eh_t *history, void *data,
-         int (dump_fn) (circular_buffer_t *buffer, void *data))
+eh_dump(eh_t *history, void *data,
+        int(dump_fn)(circular_buffer_t *buffer, void *data))
 {
-        if (!history) {
-                gf_msg_debug ("event-history", 0, "history is NULL");
-                goto out;
-        }
+    if (!history) {
+        gf_msg_debug("event-history", 0, "history is NULL");
+        goto out;
+    }
 
-        cb_buffer_dump (history->buffer, data, dump_fn);
+    cb_buffer_dump(history->buffer, data, dump_fn);
 
 out:
-        return;
+    return;
 }
 
 int
-eh_save_history (eh_t *history, void *data)
+eh_save_history(eh_t *history, void *data)
 {
-        int   ret = -1;
+    int ret = -1;
 
-        ret = cb_add_entry_buffer (history->buffer, data);
+    ret = cb_add_entry_buffer(history->buffer, data);
 
-        return ret;
+    return ret;
 }
 
 int
-eh_destroy (eh_t *history)
+eh_destroy(eh_t *history)
 {
-        if (!history) {
-                gf_msg ("event-history", GF_LOG_INFO, 0, LG_MSG_INVALID_ARG,
-                        "history for the xlator is NULL");
-                return -1;
-        }
+    if (!history) {
+        gf_msg("event-history", GF_LOG_INFO, 0, LG_MSG_INVALID_ARG,
+               "history for the xlator is NULL");
+        return -1;
+    }
 
-        cb_buffer_destroy (history->buffer);
-        history->buffer = NULL;
+    cb_buffer_destroy(history->buffer);
+    history->buffer = NULL;
 
-        pthread_mutex_destroy (&history->lock);
+    pthread_mutex_destroy(&history->lock);
 
-        GF_FREE (history);
+    GF_FREE(history);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/event-poll.c b/libglusterfs/src/event-poll.c
index 283e2861b2b..727d2a000a2 100644
--- a/libglusterfs/src/event-poll.c
+++ b/libglusterfs/src/event-poll.c
@@ -23,490 +23,469 @@
 #include "syscall.h"
 #include "libglusterfs-messages.h"
 
-
-
 struct event_slot_poll {
-	int fd;
-	int events;
-	void *data;
-	event_handler_t handler;
+    int fd;
+    int events;
+    void *data;
+    event_handler_t handler;
 };
 
-
 static int
-event_register_poll (struct event_pool *event_pool, int fd,
-                     event_handler_t handler,
-                     void *data, int poll_in, int poll_out);
-
+event_register_poll(struct event_pool *event_pool, int fd,
+                    event_handler_t handler, void *data, int poll_in,
+                    int poll_out);
 
 static int
-__flush_fd (int fd, int idx, int gen, void *data,
-            int poll_in, int poll_out, int poll_err)
+__flush_fd(int fd, int idx, int gen, void *data, int poll_in, int poll_out,
+           int poll_err)
 {
-        char buf[64];
-        int ret = -1;
+    char buf[64];
+    int ret = -1;
 
-        if (!poll_in)
-                return ret;
+    if (!poll_in)
+        return ret;
 
-        do {
-                ret = sys_read (fd, buf, 64);
-                if (ret == -1 && errno != EAGAIN) {
-                        gf_msg ("poll", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED, "read on %d returned "
-                                "error", fd);
-                }
-        } while (ret == 64);
+    do {
+        ret = sys_read(fd, buf, 64);
+        if (ret == -1 && errno != EAGAIN) {
+            gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                   "read on %d returned "
+                   "error",
+                   fd);
+        }
+    } while (ret == 64);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__event_getindex (struct event_pool *event_pool, int fd, int idx)
+__event_getindex(struct event_pool *event_pool, int fd, int idx)
 {
-        int  ret = -1;
-        int  i = 0;
+    int ret = -1;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        /* lookup in used space based on index provided */
-        if (idx > -1 && idx < event_pool->used) {
-                if (event_pool->reg[idx].fd == fd) {
-                        ret = idx;
-                        goto out;
-                }
+    /* lookup in used space based on index provided */
+    if (idx > -1 && idx < event_pool->used) {
+        if (event_pool->reg[idx].fd == fd) {
+            ret = idx;
+            goto out;
         }
+    }
 
-        /* search in used space, if lookup fails */
-        for (i = 0; i < event_pool->used; i++) {
-                if (event_pool->reg[i].fd == fd) {
-                        ret = i;
-                        break;
-                }
+    /* search in used space, if lookup fails */
+    for (i = 0; i < event_pool->used; i++) {
+        if (event_pool->reg[i].fd == fd) {
+            ret = i;
+            break;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static struct event_pool *
-event_pool_new_poll (int count, int eventthreadcount)
+event_pool_new_poll(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-        int                ret = -1;
+    struct event_pool *event_pool = NULL;
+    int ret = -1;
 
-        event_pool = GF_CALLOC (1, sizeof (*event_pool),
-                                gf_common_mt_event_pool);
+    event_pool = GF_CALLOC(1, sizeof(*event_pool), gf_common_mt_event_pool);
 
-        if (!event_pool)
-                return NULL;
+    if (!event_pool)
+        return NULL;
 
-        event_pool->count = count;
-        event_pool->reg = GF_CALLOC (event_pool->count,
-                                     sizeof (*event_pool->reg),
-                                     gf_common_mt_reg);
+    event_pool->count = count;
+    event_pool->reg = GF_CALLOC(event_pool->count, sizeof(*event_pool->reg),
+                                gf_common_mt_reg);
 
-        if (!event_pool->reg) {
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    if (!event_pool->reg) {
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        pthread_mutex_init (&event_pool->mutex, NULL);
+    pthread_mutex_init(&event_pool->mutex, NULL);
 
-        ret = pipe (event_pool->breaker);
+    ret = pipe(event_pool->breaker);
 
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED,
-                        "pipe creation failed");
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    if (ret == -1) {
+        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED,
+               "pipe creation failed");
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        ret = fcntl (event_pool->breaker[0], F_SETFL, O_NONBLOCK);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-                        "could not set pipe to non blocking mode");
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
-
-        ret = fcntl (event_pool->breaker[1], F_SETFL, O_NONBLOCK);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-                        "could not set pipe to non blocking mode");
-
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
+    ret = fcntl(event_pool->breaker[0], F_SETFL, O_NONBLOCK);
+    if (ret == -1) {
+        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
+               "could not set pipe to non blocking mode");
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
 
-        ret = event_register_poll (event_pool, event_pool->breaker[0],
-                                   __flush_fd, NULL, 1, 0);
-        if (ret == -1) {
-                gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED,
-                        "could not register pipe fd with poll event loop");
-                sys_close (event_pool->breaker[0]);
-                sys_close (event_pool->breaker[1]);
-                event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-                GF_FREE (event_pool->reg);
-                GF_FREE (event_pool);
-                return NULL;
-        }
+    ret = fcntl(event_pool->breaker[1], F_SETFL, O_NONBLOCK);
+    if (ret == -1) {
+        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
+               "could not set pipe to non blocking mode");
 
-        if (eventthreadcount > 1) {
-                gf_msg ("poll", GF_LOG_INFO, 0,
-                        LG_MSG_POLL_IGNORE_MULTIPLE_THREADS, "Currently poll "
-                        "does not use multiple event processing threads, "
-                        "thread count (%d) ignored", eventthreadcount);
-        }
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        /* although, eventhreadcount for poll implementation is always
-         * going to be 1, eventthreadcount needs to be set to 1 so that
-         * rpcsvc_request_handler() thread scaling works flawlessly in
-         * both epoll and poll models
-         */
-        event_pool->eventthreadcount = 1;
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
+
+    ret = event_register_poll(event_pool, event_pool->breaker[0], __flush_fd,
+                              NULL, 1, 0);
+    if (ret == -1) {
+        gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED,
+               "could not register pipe fd with poll event loop");
+        sys_close(event_pool->breaker[0]);
+        sys_close(event_pool->breaker[1]);
+        event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        return event_pool;
+        GF_FREE(event_pool->reg);
+        GF_FREE(event_pool);
+        return NULL;
+    }
+
+    if (eventthreadcount > 1) {
+        gf_msg("poll", GF_LOG_INFO, 0, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
+               "Currently poll "
+               "does not use multiple event processing threads, "
+               "thread count (%d) ignored",
+               eventthreadcount);
+    }
+
+    /* although, eventhreadcount for poll implementation is always
+     * going to be 1, eventthreadcount needs to be set to 1 so that
+     * rpcsvc_request_handler() thread scaling works flawlessly in
+     * both epoll and poll models
+     */
+    event_pool->eventthreadcount = 1;
+
+    return event_pool;
 }
 
-
 static int
-event_register_poll (struct event_pool *event_pool, int fd,
-                     event_handler_t handler,
-                     void *data, int poll_in, int poll_out)
+event_register_poll(struct event_pool *event_pool, int fd,
+                    event_handler_t handler, void *data, int poll_in,
+                    int poll_out)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                if (event_pool->count == event_pool->used)
-                {
-                        event_pool->count += 256;
-
-                        event_pool->reg = GF_REALLOC (event_pool->reg,
-                                                      event_pool->count *
-                                                      sizeof (*event_pool->reg));
-                        if (!event_pool->reg)
-                                goto unlock;
-                }
-
-                idx = event_pool->used++;
-
-                event_pool->reg[idx].fd = fd;
-                event_pool->reg[idx].events = POLLPRI;
-                event_pool->reg[idx].handler = handler;
-                event_pool->reg[idx].data = data;
-
-                switch (poll_in) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLIN;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLIN;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_POLL_IN,
-                                "invalid poll_in value %d", poll_in);
-                        break;
-                }
-
-                switch (poll_out) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLOUT;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLOUT;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_POLL_OUT,
-                                "invalid poll_out value %d", poll_out);
-                        break;
-                }
-
-                event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        if (event_pool->count == event_pool->used) {
+            event_pool->count += 256;
+
+            event_pool->reg = GF_REALLOC(
+                event_pool->reg, event_pool->count * sizeof(*event_pool->reg));
+            if (!event_pool->reg)
+                goto unlock;
+        }
+
+        idx = event_pool->used++;
+
+        event_pool->reg[idx].fd = fd;
+        event_pool->reg[idx].events = POLLPRI;
+        event_pool->reg[idx].handler = handler;
+        event_pool->reg[idx].data = data;
+
+        switch (poll_in) {
+            case 1:
+                event_pool->reg[idx].events |= POLLIN;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLIN;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                       "invalid poll_in value %d", poll_in);
+                break;
+        }
 
+        switch (poll_out) {
+            case 1:
+                event_pool->reg[idx].events |= POLLOUT;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLOUT;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                       "invalid poll_out value %d", poll_out);
+                break;
         }
+
+        event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_poll (struct event_pool *event_pool, int fd, int idx_hint)
+event_unregister_poll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, fd, idx_hint);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                                "index not found for fd=%d (idx_hint=%d)",
-                                fd, idx_hint);
-                        errno = ENOENT;
-                        goto unlock;
-                }
-
-                event_pool->reg[idx] =  event_pool->reg[--event_pool->used];
-                event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, fd, idx_hint);
+
+        if (idx == -1) {
+            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
+                   "index not found for fd=%d (idx_hint=%d)", fd, idx_hint);
+            errno = ENOENT;
+            goto unlock;
         }
+
+        event_pool->reg[idx] = event_pool->reg[--event_pool->used];
+        event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_unregister_close_poll (struct event_pool *event_pool, int fd,
-			     int idx_hint)
+event_unregister_close_poll(struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = event_unregister_poll (event_pool, fd, idx_hint);
+    ret = event_unregister_poll(event_pool, fd, idx_hint);
 
-	sys_close (fd);
+    sys_close(fd);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-event_select_on_poll (struct event_pool *event_pool, int fd, int idx_hint,
-                      int poll_in, int poll_out)
+event_select_on_poll(struct event_pool *event_pool, int fd, int idx_hint,
+                     int poll_in, int poll_out)
 {
-        int idx = -1;
+    int idx = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, fd, idx_hint);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                                "index not found for fd=%d (idx_hint=%d)",
-                                fd, idx_hint);
-                        errno = ENOENT;
-                        goto unlock;
-                }
-
-                switch (poll_in) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLIN;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLIN;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        /* TODO: log error */
-                        break;
-                }
-
-                switch (poll_out) {
-                case 1:
-                        event_pool->reg[idx].events |= POLLOUT;
-                        break;
-                case 0:
-                        event_pool->reg[idx].events &= ~POLLOUT;
-                        break;
-                case -1:
-                        /* do nothing */
-                        break;
-                default:
-                        /* TODO: log error */
-                        break;
-                }
-
-                if (poll_in + poll_out > -2)
-                        event_pool->changed = 1;
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, fd, idx_hint);
+
+        if (idx == -1) {
+            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
+                   "index not found for fd=%d (idx_hint=%d)", fd, idx_hint);
+            errno = ENOENT;
+            goto unlock;
         }
+
+        switch (poll_in) {
+            case 1:
+                event_pool->reg[idx].events |= POLLIN;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLIN;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                /* TODO: log error */
+                break;
+        }
+
+        switch (poll_out) {
+            case 1:
+                event_pool->reg[idx].events |= POLLOUT;
+                break;
+            case 0:
+                event_pool->reg[idx].events &= ~POLLOUT;
+                break;
+            case -1:
+                /* do nothing */
+                break;
+            default:
+                /* TODO: log error */
+                break;
+        }
+
+        if (poll_in + poll_out > -2)
+            event_pool->changed = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
 out:
-        return idx;
+    return idx;
 }
 
-
 static int
-event_dispatch_poll_handler (struct event_pool *event_pool,
-                             struct pollfd *ufds, int i)
+event_dispatch_poll_handler(struct event_pool *event_pool, struct pollfd *ufds,
+                            int i)
 {
-        event_handler_t  handler = NULL;
-        void            *data = NULL;
-        int              idx = -1;
-        int              ret = 0;
-
-        handler = NULL;
-        data    = NULL;
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                idx = __event_getindex (event_pool, ufds[i].fd, i);
-
-                if (idx == -1) {
-                        gf_msg ("poll", GF_LOG_ERROR, 0,
-                                LG_MSG_INDEX_NOT_FOUND, "index not found for "
-                                "fd=%d (idx_hint=%d)", ufds[i].fd, i);
-                        goto unlock;
-                }
-
-                handler = event_pool->reg[idx].handler;
-                data = event_pool->reg[idx].data;
+    event_handler_t handler = NULL;
+    void *data = NULL;
+    int idx = -1;
+    int ret = 0;
+
+    handler = NULL;
+    data = NULL;
+
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        idx = __event_getindex(event_pool, ufds[i].fd, i);
+
+        if (idx == -1) {
+            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
+                   "index not found for "
+                   "fd=%d (idx_hint=%d)",
+                   ufds[i].fd, i);
+            goto unlock;
         }
+
+        handler = event_pool->reg[idx].handler;
+        data = event_pool->reg[idx].data;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        if (handler)
-                ret = handler (ufds[i].fd, idx, 0, data,
-                               (ufds[i].revents & (POLLIN|POLLPRI)),
-                               (ufds[i].revents & (POLLOUT)),
-                               (ufds[i].revents & (POLLERR|POLLHUP|POLLNVAL)));
+    if (handler)
+        ret = handler(ufds[i].fd, idx, 0, data,
+                      (ufds[i].revents & (POLLIN | POLLPRI)),
+                      (ufds[i].revents & (POLLOUT)),
+                      (ufds[i].revents & (POLLERR | POLLHUP | POLLNVAL)));
 
-        return ret;
+    return ret;
 }
 
-
 static int
-event_dispatch_poll_resize (struct event_pool *event_pool,
-                            struct pollfd *ufds, int size)
+event_dispatch_poll_resize(struct event_pool *event_pool, struct pollfd *ufds,
+                           int size)
 {
-        int              i = 0;
-
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                if (event_pool->changed == 0) {
-                        goto unlock;
-                }
+    int i = 0;
 
-                if (event_pool->used > event_pool->evcache_size) {
-                        GF_FREE (event_pool->evcache);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        if (event_pool->changed == 0) {
+            goto unlock;
+        }
 
-                        event_pool->evcache = ufds = NULL;
+        if (event_pool->used > event_pool->evcache_size) {
+            GF_FREE(event_pool->evcache);
 
-                        event_pool->evcache_size = event_pool->used;
+            event_pool->evcache = ufds = NULL;
 
-                        ufds = GF_CALLOC (sizeof (struct pollfd),
-                                          event_pool->evcache_size,
-                                          gf_common_mt_pollfd);
-                        if (!ufds)
-                                goto unlock;
-                        event_pool->evcache = ufds;
-                }
+            event_pool->evcache_size = event_pool->used;
 
-                if (ufds == NULL) {
-                        goto unlock;
-                }
+            ufds = GF_CALLOC(sizeof(struct pollfd), event_pool->evcache_size,
+                             gf_common_mt_pollfd);
+            if (!ufds)
+                goto unlock;
+            event_pool->evcache = ufds;
+        }
 
-                for (i = 0; i < event_pool->used; i++) {
-                        ufds[i].fd = event_pool->reg[i].fd;
-                        ufds[i].events = event_pool->reg[i].events;
-                        ufds[i].revents = 0;
-                }
+        if (ufds == NULL) {
+            goto unlock;
+        }
 
-                size = i;
+        for (i = 0; i < event_pool->used; i++) {
+            ufds[i].fd = event_pool->reg[i].fd;
+            ufds[i].events = event_pool->reg[i].events;
+            ufds[i].revents = 0;
         }
+
+        size = i;
+    }
 unlock:
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        return size;
+    return size;
 }
 
-
 static int
-event_dispatch_poll (struct event_pool *event_pool)
+event_dispatch_poll(struct event_pool *event_pool)
 {
-        struct pollfd   *ufds = NULL;
-        int              size = 0;
-        int              i = 0;
-        int              ret = -1;
+    struct pollfd *ufds = NULL;
+    int size = 0;
+    int i = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        event_pool->activethreadcount = 1;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        pthread_mutex_lock (&event_pool->mutex);
+    while (1) {
+        pthread_mutex_lock(&event_pool->mutex);
         {
-                event_pool->activethreadcount = 1;
+            if (event_pool->destroy == 1) {
+                event_pool->activethreadcount = 0;
+                pthread_cond_broadcast(&event_pool->cond);
+                pthread_mutex_unlock(&event_pool->mutex);
+                return 0;
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        while (1) {
-                pthread_mutex_lock (&event_pool->mutex);
-                {
-                        if (event_pool->destroy == 1) {
-                                event_pool->activethreadcount = 0;
-                                pthread_cond_broadcast (&event_pool->cond);
-                                pthread_mutex_unlock (&event_pool->mutex);
-                                return 0;
-                        }
-                }
-                pthread_mutex_unlock (&event_pool->mutex);
-
-                size = event_dispatch_poll_resize (event_pool, ufds, size);
-                ufds = event_pool->evcache;
-
-                ret = poll (ufds, size, 1);
-
-                if (ret == 0)
-                        /* timeout */
-                        continue;
-
-                if (ret == -1 && errno == EINTR)
-                        /* sys call */
-                        continue;
-
-                for (i = 0; i < size; i++) {
-                        if (!ufds[i].revents)
-                                continue;
-
-                        event_dispatch_poll_handler (event_pool, ufds, i);
-                }
+        pthread_mutex_unlock(&event_pool->mutex);
+
+        size = event_dispatch_poll_resize(event_pool, ufds, size);
+        ufds = event_pool->evcache;
+
+        ret = poll(ufds, size, 1);
+
+        if (ret == 0)
+            /* timeout */
+            continue;
+
+        if (ret == -1 && errno == EINTR)
+            /* sys call */
+            continue;
+
+        for (i = 0; i < size; i++) {
+            if (!ufds[i].revents)
+                continue;
+
+            event_dispatch_poll_handler(event_pool, ufds, i);
         }
+    }
 
 out:
-        return -1;
+    return -1;
 }
 
 int
-event_reconfigure_threads_poll (struct event_pool *event_pool, int value)
+event_reconfigure_threads_poll(struct event_pool *event_pool, int value)
 {
-        /* No-op for poll */
+    /* No-op for poll */
 
-        return 0;
+    return 0;
 }
 
 /* This function is the destructor for the event_pool data structure
@@ -514,33 +493,32 @@ event_reconfigure_threads_poll (struct event_pool *event_pool, int value)
  * else will lead to crashes.
  */
 static int
-event_pool_destroy_poll (struct event_pool *event_pool)
+event_pool_destroy_poll(struct event_pool *event_pool)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = sys_close (event_pool->breaker[0]);
-        if (ret)
-                return ret;
+    ret = sys_close(event_pool->breaker[0]);
+    if (ret)
+        return ret;
 
-        ret = sys_close (event_pool->breaker[1]);
-        if (ret)
-                return ret;
+    ret = sys_close(event_pool->breaker[1]);
+    if (ret)
+        return ret;
 
-        event_pool->breaker[0] = event_pool->breaker[1] = -1;
+    event_pool->breaker[0] = event_pool->breaker[1] = -1;
 
-        GF_FREE (event_pool->reg);
-        GF_FREE (event_pool);
+    GF_FREE(event_pool->reg);
+    GF_FREE(event_pool);
 
-        return ret;
+    return ret;
 }
 
 struct event_ops event_ops_poll = {
-        .new                    = event_pool_new_poll,
-        .event_register         = event_register_poll,
-        .event_select_on        = event_select_on_poll,
-        .event_unregister       = event_unregister_poll,
-        .event_unregister_close = event_unregister_close_poll,
-        .event_dispatch         = event_dispatch_poll,
-        .event_reconfigure_threads = event_reconfigure_threads_poll,
-        .event_pool_destroy     = event_pool_destroy_poll
-};
+    .new = event_pool_new_poll,
+    .event_register = event_register_poll,
+    .event_select_on = event_select_on_poll,
+    .event_unregister = event_unregister_poll,
+    .event_unregister_close = event_unregister_close_poll,
+    .event_dispatch = event_dispatch_poll,
+    .event_reconfigure_threads = event_reconfigure_threads_poll,
+    .event_pool_destroy = event_pool_destroy_poll};
diff --git a/libglusterfs/src/event.c b/libglusterfs/src/event.c
index 2598cd305a8..5b4d43e8650 100644
--- a/libglusterfs/src/event.c
+++ b/libglusterfs/src/event.c
@@ -23,173 +23,164 @@
 #include "libglusterfs-messages.h"
 #include "syscall.h"
 
-
-
 struct event_pool *
-event_pool_new (int count, int eventthreadcount)
+event_pool_new(int count, int eventthreadcount)
 {
-        struct event_pool *event_pool = NULL;
-	extern struct event_ops event_ops_poll;
+    struct event_pool *event_pool = NULL;
+    extern struct event_ops event_ops_poll;
 
 #ifdef HAVE_SYS_EPOLL_H
-	extern struct event_ops event_ops_epoll;
+    extern struct event_ops event_ops_epoll;
 
-        event_pool = event_ops_epoll.new (count, eventthreadcount);
+    event_pool = event_ops_epoll.new(count, eventthreadcount);
 
-        if (event_pool) {
-                event_pool->ops = &event_ops_epoll;
-        } else {
-                gf_msg ("event", GF_LOG_WARNING, 0, LG_MSG_FALLBACK_TO_POLL,
-                        "falling back to poll based event handling");
-        }
+    if (event_pool) {
+        event_pool->ops = &event_ops_epoll;
+    } else {
+        gf_msg("event", GF_LOG_WARNING, 0, LG_MSG_FALLBACK_TO_POLL,
+               "falling back to poll based event handling");
+    }
 #endif
 
-        if (!event_pool) {
-                event_pool = event_ops_poll.new (count, eventthreadcount);
+    if (!event_pool) {
+        event_pool = event_ops_poll.new(count, eventthreadcount);
 
-                if (event_pool)
-                        event_pool->ops = &event_ops_poll;
-        }
+        if (event_pool)
+            event_pool->ops = &event_ops_poll;
+    }
 
-        return event_pool;
+    return event_pool;
 }
 
-
 int
-event_register (struct event_pool *event_pool, int fd,
-                event_handler_t handler,
-                void *data, int poll_in, int poll_out)
+event_register(struct event_pool *event_pool, int fd, event_handler_t handler,
+               void *data, int poll_in, int poll_out)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_register (event_pool, fd, handler, data,
-                                               poll_in, poll_out);
+    ret = event_pool->ops->event_register(event_pool, fd, handler, data,
+                                          poll_in, poll_out);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_unregister (struct event_pool *event_pool, int fd, int idx)
+event_unregister(struct event_pool *event_pool, int fd, int idx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_unregister (event_pool, fd, idx);
+    ret = event_pool->ops->event_unregister(event_pool, fd, idx);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_unregister_close (struct event_pool *event_pool, int fd, int idx)
+event_unregister_close(struct event_pool *event_pool, int fd, int idx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_unregister_close (event_pool, fd, idx);
+    ret = event_pool->ops->event_unregister_close(event_pool, fd, idx);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_select_on (struct event_pool *event_pool, int fd, int idx_hint,
-                 int poll_in, int poll_out)
+event_select_on(struct event_pool *event_pool, int fd, int idx_hint,
+                int poll_in, int poll_out)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_select_on (event_pool, fd, idx_hint,
-                                                poll_in, poll_out);
+    ret = event_pool->ops->event_select_on(event_pool, fd, idx_hint, poll_in,
+                                           poll_out);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-event_dispatch (struct event_pool *event_pool)
+event_dispatch(struct event_pool *event_pool)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        ret = event_pool->ops->event_dispatch (event_pool);
-        if (ret)
-                goto out;
+    ret = event_pool->ops->event_dispatch(event_pool);
+    if (ret)
+        goto out;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-event_reconfigure_threads (struct event_pool *event_pool, int value)
+event_reconfigure_threads(struct event_pool *event_pool, int value)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        /* call event refresh function */
-        ret = event_pool->ops->event_reconfigure_threads (event_pool,
-                                                          value);
+    /* call event refresh function */
+    ret = event_pool->ops->event_reconfigure_threads(event_pool, value);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-event_pool_destroy (struct event_pool *event_pool)
+event_pool_destroy(struct event_pool *event_pool)
 {
-        int ret = -1;
-        int destroy = 0, activethreadcount = 0;
+    int ret = -1;
+    int destroy = 0, activethreadcount = 0;
 
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                destroy = event_pool->destroy;
-                activethreadcount = event_pool->activethreadcount;
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        destroy = event_pool->destroy;
+        activethreadcount = event_pool->activethreadcount;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        if (!destroy || (activethreadcount > 0)) {
-                goto out;
-        }
+    if (!destroy || (activethreadcount > 0)) {
+        goto out;
+    }
 
-        ret = event_pool->ops->event_pool_destroy (event_pool);
+    ret = event_pool->ops->event_pool_destroy(event_pool);
 out:
-        return ret;
+    return ret;
 }
 
 int
-poller_destroy_handler (int fd, int idx, int gen, void *data,
-                       int poll_out, int poll_in, int poll_err)
+poller_destroy_handler(int fd, int idx, int gen, void *data, int poll_out,
+                       int poll_in, int poll_err)
 {
-        struct event_destroy_data *destroy = NULL;
-        int                        readfd  = -1, ret = -1;
-        char                       buf     = '\0';
-
-        destroy = data;
-        readfd = destroy->readfd;
-        if (readfd < 0) {
-                goto out;
-        }
+    struct event_destroy_data *destroy = NULL;
+    int readfd = -1, ret = -1;
+    char buf = '\0';
 
-        while (sys_read (readfd, &buf, 1) > 0) {
-        }
+    destroy = data;
+    readfd = destroy->readfd;
+    if (readfd < 0) {
+        goto out;
+    }
+
+    while (sys_read(readfd, &buf, 1) > 0) {
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        event_handled (destroy->pool, fd, idx, gen);
+    event_handled(destroy->pool, fd, idx, gen);
 
-        return ret;
+    return ret;
 }
 
 /* This function destroys all the poller threads.
@@ -204,109 +195,111 @@ out:
  *   threads are destroyed)
  */
 int
-event_dispatch_destroy (struct event_pool *event_pool)
+event_dispatch_destroy(struct event_pool *event_pool)
 {
-        int                       ret        = -1, threadcount = 0;
-        int  fd[2]                           = {-1};
-        int                       idx        = -1;
-        int                       flags      = 0;
-        struct timespec           sleep_till = {0, };
-        struct event_destroy_data data       = {0, };
-
-        GF_VALIDATE_OR_GOTO ("event", event_pool, out);
-
-        ret = pipe (fd);
-        if (ret < 0)
-                goto out;
-
-        /* Make the read end of the pipe nonblocking */
-        flags = fcntl(fd[0], F_GETFL);
-        flags |= O_NONBLOCK;
-        ret = fcntl(fd[0], F_SETFL, flags);
-        if (ret < 0)
-                goto out;
-
-        /* Make the write end of the pipe nonblocking */
-        flags = fcntl(fd[1], F_GETFL);
-        flags |= O_NONBLOCK;
-        ret = fcntl(fd[1], F_SETFL, flags);
-        if (ret < 0)
-                goto out;
-
-        data.pool = event_pool;
-        data.readfd = fd[1];
-
-        /* From the main thread register an event on the pipe fd[0],
-         */
-        idx = event_register (event_pool, fd[0], poller_destroy_handler,
-                              &data, 1, 0);
-        if (idx < 0)
-                goto out;
-
-        /* Enter the destroy mode first, set this before reconfiguring to 0
-         * threads, to prevent further reconfigure to thread count > 0.
+    int ret = -1, threadcount = 0;
+    int fd[2] = {-1};
+    int idx = -1;
+    int flags = 0;
+    struct timespec sleep_till = {
+        0,
+    };
+    struct event_destroy_data data = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("event", event_pool, out);
+
+    ret = pipe(fd);
+    if (ret < 0)
+        goto out;
+
+    /* Make the read end of the pipe nonblocking */
+    flags = fcntl(fd[0], F_GETFL);
+    flags |= O_NONBLOCK;
+    ret = fcntl(fd[0], F_SETFL, flags);
+    if (ret < 0)
+        goto out;
+
+    /* Make the write end of the pipe nonblocking */
+    flags = fcntl(fd[1], F_GETFL);
+    flags |= O_NONBLOCK;
+    ret = fcntl(fd[1], F_SETFL, flags);
+    if (ret < 0)
+        goto out;
+
+    data.pool = event_pool;
+    data.readfd = fd[1];
+
+    /* From the main thread register an event on the pipe fd[0],
+     */
+    idx = event_register(event_pool, fd[0], poller_destroy_handler, &data, 1,
+                         0);
+    if (idx < 0)
+        goto out;
+
+    /* Enter the destroy mode first, set this before reconfiguring to 0
+     * threads, to prevent further reconfigure to thread count > 0.
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        threadcount = event_pool->eventthreadcount;
+        event_pool->destroy = 1;
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
+
+    ret = event_reconfigure_threads(event_pool, 0);
+    if (ret < 0)
+        goto out;
+
+    /* Write something onto the write end of the pipe(fd[1]) so that
+     * poll wakes up and calls the handler, poller_destroy_handler()
+     */
+    pthread_mutex_lock(&event_pool->mutex);
+    {
+        /* Write to pipe(fd[1]) and then wait for 1 second or until
+         * a poller thread that is dying, broadcasts. Make sure we
+         * do not loop forever by limiting to 10 retries
          */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                threadcount = event_pool->eventthreadcount;
-                event_pool->destroy = 1;
+        int retry = 0;
+
+        while (event_pool->activethreadcount > 0 &&
+               (retry++ < (threadcount + 10))) {
+            if (sys_write(fd[1], "dummy", 6) == -1) {
+                break;
+            }
+            sleep_till.tv_sec = time(NULL) + 1;
+            ret = pthread_cond_timedwait(&event_pool->cond, &event_pool->mutex,
+                                         &sleep_till);
+            if (ret) {
+                gf_msg_debug("event", 0,
+                             "thread cond-timedwait failed "
+                             "active-thread-count: %d, "
+                             "retry: %d",
+                             event_pool->activethreadcount, retry);
+            }
         }
-        pthread_mutex_unlock (&event_pool->mutex);
+    }
+    pthread_mutex_unlock(&event_pool->mutex);
 
-        ret = event_reconfigure_threads (event_pool, 0);
-        if (ret < 0)
-                goto out;
+    ret = event_unregister(event_pool, fd[0], idx);
 
-        /* Write something onto the write end of the pipe(fd[1]) so that
-         * poll wakes up and calls the handler, poller_destroy_handler()
-         */
-        pthread_mutex_lock (&event_pool->mutex);
-        {
-                /* Write to pipe(fd[1]) and then wait for 1 second or until
-                 * a poller thread that is dying, broadcasts. Make sure we
-                 * do not loop forever by limiting to 10 retries
-                 */
-                int retry = 0;
-
-                while (event_pool->activethreadcount > 0
-                       && (retry++ < (threadcount + 10))) {
-                        if (sys_write (fd[1], "dummy", 6) == -1) {
-                                break;
-                        }
-                        sleep_till.tv_sec = time (NULL) + 1;
-                        ret = pthread_cond_timedwait (&event_pool->cond,
-                                                      &event_pool->mutex,
-                                                      &sleep_till);
-                        if (ret) {
-                                gf_msg_debug ("event", 0,
-                                              "thread cond-timedwait failed "
-                                              "active-thread-count: %d, "
-                                              "retry: %d",
-                                              event_pool->activethreadcount,
-                                              retry);
-                        }
-                }
-        }
-        pthread_mutex_unlock (&event_pool->mutex);
-
-        ret = event_unregister (event_pool, fd[0], idx);
-
- out:
-        if (fd[0] != -1)
-                sys_close (fd[0]);
-        if (fd[1] != -1)
-                sys_close (fd[1]);
+out:
+    if (fd[0] != -1)
+        sys_close(fd[0]);
+    if (fd[1] != -1)
+        sys_close(fd[1]);
 
-        return ret;
+    return ret;
 }
 
 int
-event_handled (struct event_pool *event_pool, int fd, int idx, int gen)
+event_handled(struct event_pool *event_pool, int fd, int idx, int gen)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (event_pool->ops->event_handled)
-                ret = event_pool->ops->event_handled (event_pool, fd, idx, gen);
+    if (event_pool->ops->event_handled)
+        ret = event_pool->ops->event_handled(event_pool, fd, idx, gen);
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/events.c b/libglusterfs/src/events.c
index 5a1b4c06e57..b1fa057b81e 100644
--- a/libglusterfs/src/events.c
+++ b/libglusterfs/src/events.c
@@ -25,112 +25,109 @@
 #include "globals.h"
 #include "events.h"
 
-
 #define EVENT_HOST "127.0.0.1"
 #define EVENT_PORT 24009
 
-
 int
-_gf_event (eventtypes_t event, const char *fmt, ...)
+_gf_event(eventtypes_t event, const char *fmt, ...)
 {
-        int                ret                   = 0;
-        int                sock                  = -1;
-        char              *eventstr              = NULL;
-        struct             sockaddr_in server;
-        va_list            arguments;
-        char              *msg                   = NULL;
-        glusterfs_ctx_t   *ctx                   = NULL;
-        char              *host                  = NULL;
-        struct addrinfo    hints;
-        struct addrinfo   *result                = NULL;
-
-        /* Global context */
-        ctx = THIS->ctx;
-
-        if (event < 0 || event >= EVENT_LAST) {
-                ret = EVENT_ERROR_INVALID_INPUTS;
-                goto out;
-        }
-
-        /* Initialize UDP socket */
-        sock = socket (AF_INET, SOCK_DGRAM, 0);
-        if (sock < 0) {
-                ret = EVENT_ERROR_SOCKET;
-                goto out;
-        }
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = AF_UNSPEC;
-
-        /* Get Host name to send message */
-        if (ctx && ctx->cmd_args.volfile_server) {
-                /* If it is client code then volfile_server is set
-                   use that information to push the events. */
-                if ((getaddrinfo (ctx->cmd_args.volfile_server,
-                                  NULL, &hints, &result)) != 0) {
-                        ret = EVENT_ERROR_RESOLVE;
-                        goto out;
-                }
-
-                if (get_ip_from_addrinfo (result, &host) == NULL) {
-                        ret = EVENT_ERROR_RESOLVE;
-                        goto out;
-                }
-        } else {
-                /* Localhost, Use the defined IP for localhost */
-                host = gf_strdup (EVENT_HOST);
+    int ret = 0;
+    int sock = -1;
+    char *eventstr = NULL;
+    struct sockaddr_in server;
+    va_list arguments;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char *host = NULL;
+    struct addrinfo hints;
+    struct addrinfo *result = NULL;
+
+    /* Global context */
+    ctx = THIS->ctx;
+
+    if (event < 0 || event >= EVENT_LAST) {
+        ret = EVENT_ERROR_INVALID_INPUTS;
+        goto out;
+    }
+
+    /* Initialize UDP socket */
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0) {
+        ret = EVENT_ERROR_SOCKET;
+        goto out;
+    }
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+
+    /* Get Host name to send message */
+    if (ctx && ctx->cmd_args.volfile_server) {
+        /* If it is client code then volfile_server is set
+           use that information to push the events. */
+        if ((getaddrinfo(ctx->cmd_args.volfile_server, NULL, &hints,
+                         &result)) != 0) {
+            ret = EVENT_ERROR_RESOLVE;
+            goto out;
         }
 
-        /* Socket Configurations */
-        server.sin_family = AF_INET;
-        server.sin_port = htons (EVENT_PORT);
-        server.sin_addr.s_addr = inet_addr (host);
-        memset (&server.sin_zero, '\0', sizeof (server.sin_zero));
-
-        va_start (arguments, fmt);
-        ret = gf_vasprintf (&msg, fmt, arguments);
-        va_end (arguments);
-
-        if (ret < 0) {
-                ret = EVENT_ERROR_INVALID_INPUTS;
-                goto out;
-        }
-
-        ret = gf_asprintf (&eventstr, "%u %d %s",
-                            (unsigned)time(NULL), event, msg);
-
-        if (ret <= 0) {
-                ret = EVENT_ERROR_MSG_FORMAT;
-                goto out;
+        if (get_ip_from_addrinfo(result, &host) == NULL) {
+            ret = EVENT_ERROR_RESOLVE;
+            goto out;
         }
-
-        /* Send Message */
-        if (sendto (sock, eventstr, strlen (eventstr),
-                    0, (struct sockaddr *)&server, sizeof (server)) <= 0) {
-                ret = EVENT_ERROR_SEND;
-                goto out;
-        }
-
-        ret = EVENT_SEND_OK;
-
- out:
-        if (sock >= 0) {
-                sys_close (sock);
-        }
-
-        /* Allocated by gf_vasprintf */
-        if (msg)
-                GF_FREE (msg);
-
-        /* Allocated by gf_asprintf */
-        if (eventstr)
-                GF_FREE (eventstr);
-
-        if (host)
-                GF_FREE (host);
-
-        if (result)
-                freeaddrinfo (result);
-
-        return ret;
+    } else {
+        /* Localhost, Use the defined IP for localhost */
+        host = gf_strdup(EVENT_HOST);
+    }
+
+    /* Socket Configurations */
+    server.sin_family = AF_INET;
+    server.sin_port = htons(EVENT_PORT);
+    server.sin_addr.s_addr = inet_addr(host);
+    memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
+
+    va_start(arguments, fmt);
+    ret = gf_vasprintf(&msg, fmt, arguments);
+    va_end(arguments);
+
+    if (ret < 0) {
+        ret = EVENT_ERROR_INVALID_INPUTS;
+        goto out;
+    }
+
+    ret = gf_asprintf(&eventstr, "%u %d %s", (unsigned)time(NULL), event, msg);
+
+    if (ret <= 0) {
+        ret = EVENT_ERROR_MSG_FORMAT;
+        goto out;
+    }
+
+    /* Send Message */
+    if (sendto(sock, eventstr, strlen(eventstr), 0, (struct sockaddr *)&server,
+               sizeof(server)) <= 0) {
+        ret = EVENT_ERROR_SEND;
+        goto out;
+    }
+
+    ret = EVENT_SEND_OK;
+
+out:
+    if (sock >= 0) {
+        sys_close(sock);
+    }
+
+    /* Allocated by gf_vasprintf */
+    if (msg)
+        GF_FREE(msg);
+
+    /* Allocated by gf_asprintf */
+    if (eventstr)
+        GF_FREE(eventstr);
+
+    if (host)
+        GF_FREE(host);
+
+    if (result)
+        freeaddrinfo(result);
+
+    return ret;
 }
diff --git a/libglusterfs/src/fd-lk.c b/libglusterfs/src/fd-lk.c
index e516f64bff6..a6680661be6 100644
--- a/libglusterfs/src/fd-lk.c
+++ b/libglusterfs/src/fd-lk.c
@@ -13,430 +13,421 @@
 #include "libglusterfs-messages.h"
 
 int32_t
-_fd_lk_delete_lock (fd_lk_ctx_node_t *lock)
+_fd_lk_delete_lock(fd_lk_ctx_node_t *lock)
 {
-        int32_t    ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lock, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lock, out);
 
-        list_del_init (&lock->next);
+    list_del_init(&lock->next);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-_fd_lk_destroy_lock (fd_lk_ctx_node_t *lock)
+_fd_lk_destroy_lock(fd_lk_ctx_node_t *lock)
 {
-        int32_t    ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lock, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lock, out);
 
-        GF_FREE (lock);
+    GF_FREE(lock);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-_fd_lk_destroy_lock_list (fd_lk_ctx_t *lk_ctx)
+_fd_lk_destroy_lock_list(fd_lk_ctx_t *lk_ctx)
 {
-        int               ret     = -1;
-        fd_lk_ctx_node_t *lk      = NULL;
-        fd_lk_ctx_node_t *tmp     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, out);
-
-        list_for_each_entry_safe (lk, tmp, &lk_ctx->lk_list, next) {
-                _fd_lk_delete_lock (lk);
-                _fd_lk_destroy_lock (lk);
-        }
-        ret = 0;
+    int ret = -1;
+    fd_lk_ctx_node_t *lk = NULL;
+    fd_lk_ctx_node_t *tmp = NULL;
+
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, out);
+
+    list_for_each_entry_safe(lk, tmp, &lk_ctx->lk_list, next)
+    {
+        _fd_lk_delete_lock(lk);
+        _fd_lk_destroy_lock(lk);
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_lk_ctx_unref (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_unref(fd_lk_ctx_t *lk_ctx)
 {
-        int ref = -1;
+    int ref = -1;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, err);
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, err);
 
-        ref = GF_ATOMIC_DEC (lk_ctx->ref);
-        if (ref < 0)
-                GF_ASSERT (!ref);
-        if (ref == 0)
-                _fd_lk_destroy_lock_list (lk_ctx);
+    ref = GF_ATOMIC_DEC(lk_ctx->ref);
+    if (ref < 0)
+        GF_ASSERT(!ref);
+    if (ref == 0)
+        _fd_lk_destroy_lock_list(lk_ctx);
 
-        if (ref == 0) {
-                LOCK_DESTROY (&lk_ctx->lock);
-                GF_FREE (lk_ctx);
-        }
+    if (ref == 0) {
+        LOCK_DESTROY(&lk_ctx->lock);
+        GF_FREE(lk_ctx);
+    }
 
-        return 0;
+    return 0;
 err:
-        return -1;
+    return -1;
 }
 
 fd_lk_ctx_t *
-fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_ref(fd_lk_ctx_t *lk_ctx)
 {
-        if (!lk_ctx) {
-                gf_msg_callingfn ("fd-lk", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+    if (!lk_ctx) {
+        gf_msg_callingfn("fd-lk", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (lk_ctx->ref);
+    GF_ATOMIC_INC(lk_ctx->ref);
 
-        return lk_ctx;
+    return lk_ctx;
 }
 
 fd_lk_ctx_t *
-fd_lk_ctx_create ()
+fd_lk_ctx_create()
 {
-        fd_lk_ctx_t *fd_lk_ctx = NULL;
+    fd_lk_ctx_t *fd_lk_ctx = NULL;
 
-        fd_lk_ctx = GF_CALLOC (1, sizeof (fd_lk_ctx_t),
-                               gf_common_mt_fd_lk_ctx_t);
-        if (!fd_lk_ctx)
-                goto out;
+    fd_lk_ctx = GF_CALLOC(1, sizeof(fd_lk_ctx_t), gf_common_mt_fd_lk_ctx_t);
+    if (!fd_lk_ctx)
+        goto out;
 
-        INIT_LIST_HEAD (&fd_lk_ctx->lk_list);
+    INIT_LIST_HEAD(&fd_lk_ctx->lk_list);
 
-        LOCK_INIT (&fd_lk_ctx->lock);
+    LOCK_INIT(&fd_lk_ctx->lock);
 
-        fd_lk_ctx = fd_lk_ctx_ref (fd_lk_ctx);
+    fd_lk_ctx = fd_lk_ctx_ref(fd_lk_ctx);
 out:
-        return fd_lk_ctx;
+    return fd_lk_ctx;
 }
 
 int
-_fd_lk_insert_lock (fd_lk_ctx_t *lk_ctx,
-                    fd_lk_ctx_node_t *lock)
+_fd_lk_insert_lock(fd_lk_ctx_t *lk_ctx, fd_lk_ctx_node_t *lock)
 {
-        list_add_tail (&lock->next, &lk_ctx->lk_list);
-        return 0;
+    list_add_tail(&lock->next, &lk_ctx->lk_list);
+    return 0;
 }
 
 static off_t
-_fd_lk_get_lock_len (off_t start, off_t end)
+_fd_lk_get_lock_len(off_t start, off_t end)
 {
-        if (end == LLONG_MAX)
-                return 0;
-        else
-                return (end - start + 1);
+    if (end == LLONG_MAX)
+        return 0;
+    else
+        return (end - start + 1);
 }
 
 fd_lk_ctx_node_t *
-fd_lk_ctx_node_new (int32_t cmd, struct gf_flock *flock)
+fd_lk_ctx_node_new(int32_t cmd, struct gf_flock *flock)
 {
-        fd_lk_ctx_node_t  *new_lock  = NULL;
+    fd_lk_ctx_node_t *new_lock = NULL;
 
-        /* TODO: get from mem-pool */
-        new_lock = GF_CALLOC (1, sizeof (fd_lk_ctx_node_t),
-                              gf_common_mt_fd_lk_ctx_node_t);
-        if (!new_lock)
-                goto out;
+    /* TODO: get from mem-pool */
+    new_lock = GF_CALLOC(1, sizeof(fd_lk_ctx_node_t),
+                         gf_common_mt_fd_lk_ctx_node_t);
+    if (!new_lock)
+        goto out;
 
-        new_lock->cmd = cmd;
+    new_lock->cmd = cmd;
 
-        if (flock) {
-                new_lock->fl_type  = flock->l_type;
-                new_lock->fl_start = flock->l_start;
+    if (flock) {
+        new_lock->fl_type = flock->l_type;
+        new_lock->fl_start = flock->l_start;
 
-                if (flock->l_len == 0)
-                        new_lock->fl_end = LLONG_MAX;
-                else
-                        new_lock->fl_end = flock->l_start + flock->l_len - 1;
+        if (flock->l_len == 0)
+            new_lock->fl_end = LLONG_MAX;
+        else
+            new_lock->fl_end = flock->l_start + flock->l_len - 1;
 
-                memcpy (&new_lock->user_flock, flock,
-                        sizeof (struct gf_flock));
-        }
+        memcpy(&new_lock->user_flock, flock, sizeof(struct gf_flock));
+    }
 
-        INIT_LIST_HEAD (&new_lock->next);
+    INIT_LIST_HEAD(&new_lock->next);
 out:
-        return new_lock;
+    return new_lock;
 }
 
 int32_t
-_fd_lk_delete_unlck_locks (fd_lk_ctx_t *lk_ctx)
+_fd_lk_delete_unlck_locks(fd_lk_ctx_t *lk_ctx)
 {
-        int32_t            ret   = -1;
-        fd_lk_ctx_node_t  *tmp   = NULL;
-        fd_lk_ctx_node_t  *lk    = NULL;
+    int32_t ret = -1;
+    fd_lk_ctx_node_t *tmp = NULL;
+    fd_lk_ctx_node_t *lk = NULL;
 
-        GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", lk_ctx, out);
 
-        list_for_each_entry_safe (lk, tmp, &lk_ctx->lk_list, next) {
-                if (lk->fl_type == F_UNLCK) {
-                        _fd_lk_delete_lock (lk);
-                        _fd_lk_destroy_lock (lk);
-                }
+    list_for_each_entry_safe(lk, tmp, &lk_ctx->lk_list, next)
+    {
+        if (lk->fl_type == F_UNLCK) {
+            _fd_lk_delete_lock(lk);
+            _fd_lk_destroy_lock(lk);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-fd_lk_overlap (fd_lk_ctx_node_t *l1,
-               fd_lk_ctx_node_t *l2)
+fd_lk_overlap(fd_lk_ctx_node_t *l1, fd_lk_ctx_node_t *l2)
 {
-        if (l1->fl_end >= l2->fl_start &&
-            l2->fl_end >= l1->fl_start)
-                return 1;
+    if (l1->fl_end >= l2->fl_start && l2->fl_end >= l1->fl_start)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 fd_lk_ctx_node_t *
-_fd_lk_add_locks (fd_lk_ctx_node_t *l1,
-                  fd_lk_ctx_node_t *l2)
+_fd_lk_add_locks(fd_lk_ctx_node_t *l1, fd_lk_ctx_node_t *l2)
 {
-        fd_lk_ctx_node_t  *sum = NULL;
+    fd_lk_ctx_node_t *sum = NULL;
 
-        sum = fd_lk_ctx_node_new (0, NULL);
-        if (!sum)
-                goto out;
+    sum = fd_lk_ctx_node_new(0, NULL);
+    if (!sum)
+        goto out;
 
-        sum->fl_start = min (l1->fl_start, l2->fl_start);
-        sum->fl_end   = max (l1->fl_end, l2->fl_end);
+    sum->fl_start = min(l1->fl_start, l2->fl_start);
+    sum->fl_end = max(l1->fl_end, l2->fl_end);
 
-        sum->user_flock.l_start = sum->fl_start;
-        sum->user_flock.l_len   = _fd_lk_get_lock_len (sum->fl_start,
-                                                       sum->fl_end);
+    sum->user_flock.l_start = sum->fl_start;
+    sum->user_flock.l_len = _fd_lk_get_lock_len(sum->fl_start, sum->fl_end);
 out:
-        return sum;
+    return sum;
 }
 
 /* Subtract two locks */
 struct _values {
-        fd_lk_ctx_node_t *locks[3];
+    fd_lk_ctx_node_t *locks[3];
 };
 
 int32_t
-_fd_lk_sub_locks (struct _values *v,
-                  fd_lk_ctx_node_t *big,
-                  fd_lk_ctx_node_t *small)
+_fd_lk_sub_locks(struct _values *v, fd_lk_ctx_node_t *big,
+                 fd_lk_ctx_node_t *small)
 {
-        int32_t  ret  = -1;
-
-        if ((big->fl_start == small->fl_start) &&
-            (big->fl_end   == small->fl_end)) {
-                /* both edges coincide with big */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-
-                v->locks[0]->fl_type            = small->fl_type;
-                v->locks[0]->user_flock.l_type = small->fl_type;
-        } else if ((small->fl_start > big->fl_start) &&
-                   (small->fl_end   < big->fl_end)) {
-                /* small lock is completely inside big lock,
-                   break it down into 3 different locks. */
-                v->locks[0] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                v->locks[2] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[2])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[0]->fl_end = small->fl_start - 1;
-                v->locks[0]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[0]->fl_start,
-                                             v->locks[0]->fl_end);
-
-                memcpy (v->locks[1], small, sizeof (fd_lk_ctx_node_t));
-
-                memcpy (v->locks[2], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[2]->fl_start = small->fl_end + 1;
-                v->locks[2]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[2]->fl_start,
-                                             v->locks[2]->fl_end);
-        } else if (small->fl_start == big->fl_start) {
-                /* One of the ends co-incide, break the
-                   locks into two separate parts */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                memcpy (v->locks[0], small, sizeof (fd_lk_ctx_node_t));
-
-                memcpy (v->locks[1], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[1]->fl_start = small->fl_end + 1;
-                v->locks[1]->user_flock.l_start = small->fl_end + 1;
-        } else if (small->fl_end == big->fl_end) {
-                /* One of the ends co-incide, break the
-                   locks into two separate parts */
-                v->locks[0] = fd_lk_ctx_node_new (small->cmd, NULL);
-                if (!v->locks[0])
-                        goto out;
-
-                v->locks[1] = fd_lk_ctx_node_new (big->cmd, NULL);
-                if (!v->locks[1])
-                        goto out;
-
-                memcpy (v->locks[0], big, sizeof (fd_lk_ctx_node_t));
-                v->locks[0]->fl_end = small->fl_start - 1;
-                v->locks[0]->user_flock.l_len =
-                        _fd_lk_get_lock_len (v->locks[0]->fl_start,
-                                             v->locks[0]->fl_end);
-
-                memcpy (v->locks[1], small, sizeof (fd_lk_ctx_node_t));
-        } else {
-                /* We should never come to this case */
-                GF_ASSERT (!"Invalid case");
-        }
-        ret = 0;
+    int32_t ret = -1;
+
+    if ((big->fl_start == small->fl_start) && (big->fl_end == small->fl_end)) {
+        /* both edges coincide with big */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+
+        v->locks[0]->fl_type = small->fl_type;
+        v->locks[0]->user_flock.l_type = small->fl_type;
+    } else if ((small->fl_start > big->fl_start) &&
+               (small->fl_end < big->fl_end)) {
+        /* small lock is completely inside big lock,
+           break it down into 3 different locks. */
+        v->locks[0] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        v->locks[2] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[2])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[0]->fl_end = small->fl_start - 1;
+        v->locks[0]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[0]->fl_start, v->locks[0]->fl_end);
+
+        memcpy(v->locks[1], small, sizeof(fd_lk_ctx_node_t));
+
+        memcpy(v->locks[2], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[2]->fl_start = small->fl_end + 1;
+        v->locks[2]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[2]->fl_start, v->locks[2]->fl_end);
+    } else if (small->fl_start == big->fl_start) {
+        /* One of the ends co-incide, break the
+           locks into two separate parts */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        memcpy(v->locks[0], small, sizeof(fd_lk_ctx_node_t));
+
+        memcpy(v->locks[1], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[1]->fl_start = small->fl_end + 1;
+        v->locks[1]->user_flock.l_start = small->fl_end + 1;
+    } else if (small->fl_end == big->fl_end) {
+        /* One of the ends co-incide, break the
+           locks into two separate parts */
+        v->locks[0] = fd_lk_ctx_node_new(small->cmd, NULL);
+        if (!v->locks[0])
+            goto out;
+
+        v->locks[1] = fd_lk_ctx_node_new(big->cmd, NULL);
+        if (!v->locks[1])
+            goto out;
+
+        memcpy(v->locks[0], big, sizeof(fd_lk_ctx_node_t));
+        v->locks[0]->fl_end = small->fl_start - 1;
+        v->locks[0]->user_flock.l_len = _fd_lk_get_lock_len(
+            v->locks[0]->fl_start, v->locks[0]->fl_end);
+
+        memcpy(v->locks[1], small, sizeof(fd_lk_ctx_node_t));
+    } else {
+        /* We should never come to this case */
+        GF_ASSERT(!"Invalid case");
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-_fd_lk_insert_and_merge (fd_lk_ctx_t *lk_ctx,
-                         fd_lk_ctx_node_t *lock)
+_fd_lk_insert_and_merge(fd_lk_ctx_t *lk_ctx, fd_lk_ctx_node_t *lock)
 {
-        int32_t               ret     = -1;
-        int32_t               i       = 0;
-        fd_lk_ctx_node_t     *entry   = NULL;
-        fd_lk_ctx_node_t     *t       = NULL;
-        fd_lk_ctx_node_t     *sum     = NULL;
-        struct _values        v       = {.locks = {0, 0, 0 }};
-
-        list_for_each_entry_safe (entry, t, &lk_ctx->lk_list, next) {
-                if (!fd_lk_overlap (entry, lock))
-                        continue;
-
-                if (entry->fl_type == lock->fl_type) {
-                        sum = _fd_lk_add_locks (entry, lock);
-                        if (!sum)
-                                return;
-                        sum->fl_type = entry->fl_type;
-                        sum->user_flock.l_type = entry->fl_type;
-                        _fd_lk_delete_lock (entry);
-                        _fd_lk_destroy_lock (entry);
-                        _fd_lk_destroy_lock (lock);
-                        _fd_lk_insert_and_merge (lk_ctx, sum);
-                        return;
-                } else {
-                        sum = _fd_lk_add_locks (entry, lock);
-                        sum->fl_type = lock->fl_type;
-                        sum->user_flock.l_type = lock->fl_type;
-                        ret = _fd_lk_sub_locks (&v, sum, lock);
-                        if (ret)
-                                return;
-                        _fd_lk_delete_lock (entry);
-                        _fd_lk_destroy_lock (entry);
-
-                        _fd_lk_delete_lock (lock);
-                        _fd_lk_destroy_lock (lock);
-
-                        _fd_lk_destroy_lock (sum);
-
-                        for (i = 0; i < 3; i++) {
-                                if (!v.locks[i])
-                                        continue;
-
-                                INIT_LIST_HEAD (&v.locks[i]->next);
-                                _fd_lk_insert_and_merge (lk_ctx, v.locks[i]);
-                        }
-                        _fd_lk_delete_unlck_locks (lk_ctx);
-                        return;
-                }
-        }
-
-        /* no conflicts, so just insert */
-        if (lock->fl_type != F_UNLCK) {
-                _fd_lk_insert_lock (lk_ctx, lock);
+    int32_t ret = -1;
+    int32_t i = 0;
+    fd_lk_ctx_node_t *entry = NULL;
+    fd_lk_ctx_node_t *t = NULL;
+    fd_lk_ctx_node_t *sum = NULL;
+    struct _values v = {.locks = {0, 0, 0}};
+
+    list_for_each_entry_safe(entry, t, &lk_ctx->lk_list, next)
+    {
+        if (!fd_lk_overlap(entry, lock))
+            continue;
+
+        if (entry->fl_type == lock->fl_type) {
+            sum = _fd_lk_add_locks(entry, lock);
+            if (!sum)
+                return;
+            sum->fl_type = entry->fl_type;
+            sum->user_flock.l_type = entry->fl_type;
+            _fd_lk_delete_lock(entry);
+            _fd_lk_destroy_lock(entry);
+            _fd_lk_destroy_lock(lock);
+            _fd_lk_insert_and_merge(lk_ctx, sum);
+            return;
         } else {
-                _fd_lk_destroy_lock (lock);
+            sum = _fd_lk_add_locks(entry, lock);
+            sum->fl_type = lock->fl_type;
+            sum->user_flock.l_type = lock->fl_type;
+            ret = _fd_lk_sub_locks(&v, sum, lock);
+            if (ret)
+                return;
+            _fd_lk_delete_lock(entry);
+            _fd_lk_destroy_lock(entry);
+
+            _fd_lk_delete_lock(lock);
+            _fd_lk_destroy_lock(lock);
+
+            _fd_lk_destroy_lock(sum);
+
+            for (i = 0; i < 3; i++) {
+                if (!v.locks[i])
+                    continue;
+
+                INIT_LIST_HEAD(&v.locks[i]->next);
+                _fd_lk_insert_and_merge(lk_ctx, v.locks[i]);
+            }
+            _fd_lk_delete_unlck_locks(lk_ctx);
+            return;
         }
+    }
+
+    /* no conflicts, so just insert */
+    if (lock->fl_type != F_UNLCK) {
+        _fd_lk_insert_lock(lk_ctx, lock);
+    } else {
+        _fd_lk_destroy_lock(lock);
+    }
 }
 
 static void
-print_lock_list (fd_lk_ctx_t *lk_ctx)
+print_lock_list(fd_lk_ctx_t *lk_ctx)
 {
-        fd_lk_ctx_node_t    *lk     = NULL;
-
-        gf_msg_debug ("fd-lk", 0, "lock list:");
-
-        list_for_each_entry (lk, &lk_ctx->lk_list, next)
-                gf_msg_debug ("fd-lk", 0, "owner = %s, cmd = %s fl_type = %s,"
-                              " fs_start = %"PRId64", fs_end = %"PRId64", "
-                              "user_flock: l_type = %s, l_start = %"PRId64", "
-                              "l_len = %"PRId64", ",
-                              lkowner_utoa (&lk->user_flock.l_owner),
-                              get_lk_cmd (lk->cmd), get_lk_type (lk->fl_type),
-                              lk->fl_start, lk->fl_end,
-                              get_lk_type (lk->user_flock.l_type),
-                              lk->user_flock.l_start, lk->user_flock.l_len);
+    fd_lk_ctx_node_t *lk = NULL;
+
+    gf_msg_debug("fd-lk", 0, "lock list:");
+
+    list_for_each_entry(lk, &lk_ctx->lk_list, next)
+        gf_msg_debug("fd-lk", 0,
+                     "owner = %s, cmd = %s fl_type = %s,"
+                     " fs_start = %" PRId64 ", fs_end = %" PRId64
+                     ", "
+                     "user_flock: l_type = %s, l_start = %" PRId64
+                     ", "
+                     "l_len = %" PRId64 ", ",
+                     lkowner_utoa(&lk->user_flock.l_owner), get_lk_cmd(lk->cmd),
+                     get_lk_type(lk->fl_type), lk->fl_start, lk->fl_end,
+                     get_lk_type(lk->user_flock.l_type), lk->user_flock.l_start,
+                     lk->user_flock.l_len);
 }
 
 int
-fd_lk_insert_and_merge (fd_t *fd, int32_t cmd,
-                        struct gf_flock *flock)
+fd_lk_insert_and_merge(fd_t *fd, int32_t cmd, struct gf_flock *flock)
 {
-        int32_t              ret      = -1;
-        fd_lk_ctx_t         *lk_ctx   = NULL;
-        fd_lk_ctx_node_t    *lk     = NULL;
-
-        GF_VALIDATE_OR_GOTO ("fd-lk", fd, out);
-        GF_VALIDATE_OR_GOTO ("fd-lk", flock, out);
-
-        lk_ctx = fd_lk_ctx_ref (fd->lk_ctx);
-        lk     = fd_lk_ctx_node_new (cmd, flock);
-
-        gf_msg_debug ("fd-lk", 0, "new lock request: owner = %s, fl_type = %s"
-                      ", fs_start = %"PRId64", fs_end = %"PRId64", user_flock:"
-                      " l_type = %s, l_start = %"PRId64", l_len = %"PRId64,
-                      lkowner_utoa (&flock->l_owner),
-                      get_lk_type (lk->fl_type), lk->fl_start, lk->fl_end,
-                      get_lk_type (lk->user_flock.l_type),
-                      lk->user_flock.l_start, lk->user_flock.l_len);
-
-        LOCK (&lk_ctx->lock);
-        {
-                _fd_lk_insert_and_merge (lk_ctx, lk);
-                print_lock_list (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
-
-        fd_lk_ctx_unref (lk_ctx);
-
-        ret = 0;
+    int32_t ret = -1;
+    fd_lk_ctx_t *lk_ctx = NULL;
+    fd_lk_ctx_node_t *lk = NULL;
+
+    GF_VALIDATE_OR_GOTO("fd-lk", fd, out);
+    GF_VALIDATE_OR_GOTO("fd-lk", flock, out);
+
+    lk_ctx = fd_lk_ctx_ref(fd->lk_ctx);
+    lk = fd_lk_ctx_node_new(cmd, flock);
+
+    gf_msg_debug("fd-lk", 0,
+                 "new lock request: owner = %s, fl_type = %s"
+                 ", fs_start = %" PRId64 ", fs_end = %" PRId64
+                 ", user_flock:"
+                 " l_type = %s, l_start = %" PRId64 ", l_len = %" PRId64,
+                 lkowner_utoa(&flock->l_owner), get_lk_type(lk->fl_type),
+                 lk->fl_start, lk->fl_end, get_lk_type(lk->user_flock.l_type),
+                 lk->user_flock.l_start, lk->user_flock.l_len);
+
+    LOCK(&lk_ctx->lock);
+    {
+        _fd_lk_insert_and_merge(lk_ctx, lk);
+        print_lock_list(lk_ctx);
+    }
+    UNLOCK(&lk_ctx->lock);
+
+    fd_lk_ctx_unref(lk_ctx);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-fd_lk_ctx_empty (fd_lk_ctx_t *lk_ctx)
+fd_lk_ctx_empty(fd_lk_ctx_t *lk_ctx)
 {
-	gf_boolean_t verdict = _gf_true;
+    gf_boolean_t verdict = _gf_true;
 
-	if (!lk_ctx)
-		return _gf_true;
+    if (!lk_ctx)
+        return _gf_true;
 
-	LOCK (&lk_ctx->lock);
-	{
-		verdict = list_empty (&lk_ctx->lk_list);
-	}
-	UNLOCK (&lk_ctx->lock);
+    LOCK(&lk_ctx->lock);
+    {
+        verdict = list_empty(&lk_ctx->lk_list);
+    }
+    UNLOCK(&lk_ctx->lock);
 
-	return verdict;
+    return verdict;
 }
diff --git a/libglusterfs/src/fd.c b/libglusterfs/src/fd.c
index ee14dc8fe43..d26b7097fd4 100644
--- a/libglusterfs/src/fd.c
+++ b/libglusterfs/src/fd.c
@@ -14,1218 +14,1173 @@
 #include "statedump.h"
 #include "libglusterfs-messages.h"
 
-
 static int
-gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr);
-
+gf_fd_fdtable_expand(fdtable_t *fdtable, uint32_t nr);
 
 fd_t *
-__fd_ref (fd_t *fd);
+__fd_ref(fd_t *fd);
 
 static int
-gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
-                        uint32_t endcount)
+gf_fd_chain_fd_entries(fdentry_t *entries, uint32_t startidx, uint32_t endcount)
 {
-        uint32_t        i = 0;
+    uint32_t i = 0;
 
-        if (!entries) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!entries");
-                return -1;
-        }
+    if (!entries) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!entries");
+        return -1;
+    }
 
-        /* Chain only till the second to last entry because we want to
-         * ensure that the last entry has GF_FDTABLE_END.
-         */
-        for (i = startidx; i < (endcount - 1); i++)
-                entries[i].next_free = i + 1;
+    /* Chain only till the second to last entry because we want to
+     * ensure that the last entry has GF_FDTABLE_END.
+     */
+    for (i = startidx; i < (endcount - 1); i++)
+        entries[i].next_free = i + 1;
 
-        /* i has already been incremented up to the last entry. */
-        entries[i].next_free = GF_FDTABLE_END;
+    /* i has already been incremented up to the last entry. */
+    entries[i].next_free = GF_FDTABLE_END;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
+gf_fd_fdtable_expand(fdtable_t *fdtable, uint32_t nr)
 {
-        fdentry_t   *oldfds = NULL;
-        uint32_t     oldmax_fds = -1;
-        int          ret = -1;
-
-        if (fdtable == NULL || nr > UINT32_MAX) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                ret = EINVAL;
-                goto out;
-        }
-
-        nr /= (1024 / sizeof (fdentry_t));
-        nr = gf_roundup_next_power_of_two (nr + 1);
-        nr *= (1024 / sizeof (fdentry_t));
-
-        oldfds = fdtable->fdentries;
-        oldmax_fds = fdtable->max_fds;
-
-        fdtable->fdentries = GF_CALLOC (nr, sizeof (fdentry_t),
-                                        gf_common_mt_fdentry_t);
-        if (!fdtable->fdentries) {
-                ret = ENOMEM;
-                goto out;
-        }
-        fdtable->max_fds = nr;
-
-        if (oldfds) {
-                uint32_t cpy = oldmax_fds * sizeof (fdentry_t);
-                memcpy (fdtable->fdentries, oldfds, cpy);
-        }
-
-        gf_fd_chain_fd_entries (fdtable->fdentries, oldmax_fds,
-                                fdtable->max_fds);
-
-        /* Now that expansion is done, we must update the fd list
-         * head pointer so that the fd allocation functions can continue
-         * using the expanded table.
-         */
-        fdtable->first_free = oldmax_fds;
-        GF_FREE (oldfds);
-        ret = 0;
+    fdentry_t *oldfds = NULL;
+    uint32_t oldmax_fds = -1;
+    int ret = -1;
+
+    if (fdtable == NULL || nr > UINT32_MAX) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        ret = EINVAL;
+        goto out;
+    }
+
+    nr /= (1024 / sizeof(fdentry_t));
+    nr = gf_roundup_next_power_of_two(nr + 1);
+    nr *= (1024 / sizeof(fdentry_t));
+
+    oldfds = fdtable->fdentries;
+    oldmax_fds = fdtable->max_fds;
+
+    fdtable->fdentries = GF_CALLOC(nr, sizeof(fdentry_t),
+                                   gf_common_mt_fdentry_t);
+    if (!fdtable->fdentries) {
+        ret = ENOMEM;
+        goto out;
+    }
+    fdtable->max_fds = nr;
+
+    if (oldfds) {
+        uint32_t cpy = oldmax_fds * sizeof(fdentry_t);
+        memcpy(fdtable->fdentries, oldfds, cpy);
+    }
+
+    gf_fd_chain_fd_entries(fdtable->fdentries, oldmax_fds, fdtable->max_fds);
+
+    /* Now that expansion is done, we must update the fd list
+     * head pointer so that the fd allocation functions can continue
+     * using the expanded table.
+     */
+    fdtable->first_free = oldmax_fds;
+    GF_FREE(oldfds);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 fdtable_t *
-gf_fd_fdtable_alloc (void)
+gf_fd_fdtable_alloc(void)
 {
-        fdtable_t *fdtable = NULL;
+    fdtable_t *fdtable = NULL;
 
-        fdtable = GF_CALLOC (1, sizeof (*fdtable), gf_common_mt_fdtable_t);
-        if (!fdtable)
-                return NULL;
+    fdtable = GF_CALLOC(1, sizeof(*fdtable), gf_common_mt_fdtable_t);
+    if (!fdtable)
+        return NULL;
 
-        pthread_rwlock_init (&fdtable->lock, NULL);
+    pthread_rwlock_init(&fdtable->lock, NULL);
 
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-                gf_fd_fdtable_expand (fdtable, 0);
-        }
-        pthread_rwlock_unlock (&fdtable->lock);
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        gf_fd_fdtable_expand(fdtable, 0);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fdtable;
+    return fdtable;
 }
 
-
 static fdentry_t *
-__gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
+__gf_fd_fdtable_get_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t       *fdentries = NULL;
+    fdentry_t *fdentries = NULL;
 
-        if (count == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!count");
-                goto out;
-        }
+    if (count == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!count");
+        goto out;
+    }
 
-        fdentries = fdtable->fdentries;
-        fdtable->fdentries = GF_CALLOC (fdtable->max_fds, sizeof (fdentry_t),
-                                        gf_common_mt_fdentry_t);
-        gf_fd_chain_fd_entries (fdtable->fdentries, 0, fdtable->max_fds);
-        *count = fdtable->max_fds;
+    fdentries = fdtable->fdentries;
+    fdtable->fdentries = GF_CALLOC(fdtable->max_fds, sizeof(fdentry_t),
+                                   gf_common_mt_fdentry_t);
+    gf_fd_chain_fd_entries(fdtable->fdentries, 0, fdtable->max_fds);
+    *count = fdtable->max_fds;
 
 out:
-        return fdentries;
+    return fdentries;
 }
 
-
 fdentry_t *
-gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
+gf_fd_fdtable_get_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t       *entries = NULL;
-
-        if (fdtable) {
-                pthread_rwlock_wrlock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_get_all_fds (fdtable, count);
-                }
-                pthread_rwlock_unlock (&fdtable->lock);
+    fdentry_t *entries = NULL;
+
+    if (fdtable) {
+        pthread_rwlock_wrlock(&fdtable->lock);
+        {
+            entries = __gf_fd_fdtable_get_all_fds(fdtable, count);
         }
+        pthread_rwlock_unlock(&fdtable->lock);
+    }
 
-        return entries;
+    return entries;
 }
 
-
 static fdentry_t *
-__gf_fd_fdtable_copy_all_fds (fdtable_t *fdtable, uint32_t *count)
+__gf_fd_fdtable_copy_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t *fdentries = NULL;
-        int        i         = 0;
+    fdentry_t *fdentries = NULL;
+    int i = 0;
 
-        if (count == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!count");
-                goto out;
-        }
+    if (count == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!count");
+        goto out;
+    }
 
-        fdentries = GF_CALLOC (fdtable->max_fds, sizeof (fdentry_t),
-                               gf_common_mt_fdentry_t);
-        if (fdentries == NULL) {
-                goto out;
-        }
+    fdentries = GF_CALLOC(fdtable->max_fds, sizeof(fdentry_t),
+                          gf_common_mt_fdentry_t);
+    if (fdentries == NULL) {
+        goto out;
+    }
 
-        *count = fdtable->max_fds;
+    *count = fdtable->max_fds;
 
-        for (i = 0; i < fdtable->max_fds; i++) {
-                if (fdtable->fdentries[i].fd != NULL) {
-                        fdentries[i].fd = fd_ref (fdtable->fdentries[i].fd);
-                }
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (fdtable->fdentries[i].fd != NULL) {
+            fdentries[i].fd = fd_ref(fdtable->fdentries[i].fd);
         }
+    }
 
 out:
-        return fdentries;
+    return fdentries;
 }
 
-
 fdentry_t *
-gf_fd_fdtable_copy_all_fds (fdtable_t *fdtable, uint32_t *count)
+gf_fd_fdtable_copy_all_fds(fdtable_t *fdtable, uint32_t *count)
 {
-        fdentry_t *entries = NULL;
-
-        if (fdtable) {
-                pthread_rwlock_rdlock (&fdtable->lock);
-                {
-                        entries = __gf_fd_fdtable_copy_all_fds (fdtable, count);
-                }
-                pthread_rwlock_unlock (&fdtable->lock);
+    fdentry_t *entries = NULL;
+
+    if (fdtable) {
+        pthread_rwlock_rdlock(&fdtable->lock);
+        {
+            entries = __gf_fd_fdtable_copy_all_fds(fdtable, count);
         }
+        pthread_rwlock_unlock(&fdtable->lock);
+    }
 
-        return entries;
+    return entries;
 }
 
-
 void
-gf_fd_fdtable_destroy (fdtable_t *fdtable)
+gf_fd_fdtable_destroy(fdtable_t *fdtable)
 {
-        struct list_head  list = {0, };
-        fd_t             *fd = NULL;
-        fdentry_t        *fdentries = NULL;
-        uint32_t          fd_count = 0;
-        int32_t           i = 0;
-
-        INIT_LIST_HEAD (&list);
-
-        if (!fdtable) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!fdtable");
-                return;
-        }
-
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-                fdentries = __gf_fd_fdtable_get_all_fds (fdtable, &fd_count);
-                GF_FREE (fdtable->fdentries);
-        }
-        pthread_rwlock_unlock (&fdtable->lock);
-
-        if (fdentries != NULL) {
-                for (i = 0; i < fd_count; i++) {
-                        fd = fdentries[i].fd;
-                        if (fd != NULL) {
-                                fd_unref (fd);
-                        }
-                }
-
-                GF_FREE (fdentries);
-                pthread_rwlock_destroy (&fdtable->lock);
-                GF_FREE (fdtable);
-        }
+    struct list_head list = {
+        0,
+    };
+    fd_t *fd = NULL;
+    fdentry_t *fdentries = NULL;
+    uint32_t fd_count = 0;
+    int32_t i = 0;
+
+    INIT_LIST_HEAD(&list);
+
+    if (!fdtable) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!fdtable");
+        return;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        fdentries = __gf_fd_fdtable_get_all_fds(fdtable, &fd_count);
+        GF_FREE(fdtable->fdentries);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
+
+    if (fdentries != NULL) {
+        for (i = 0; i < fd_count; i++) {
+            fd = fdentries[i].fd;
+            if (fd != NULL) {
+                fd_unref(fd);
+            }
+        }
+
+        GF_FREE(fdentries);
+        pthread_rwlock_destroy(&fdtable->lock);
+        GF_FREE(fdtable);
+    }
 }
 
-
 int
-gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr)
+gf_fd_unused_get(fdtable_t *fdtable, fd_t *fdptr)
 {
-        int32_t         fd = -1;
-        fdentry_t       *fde = NULL;
-        int             error;
-        int             alloc_attempts = 0;
-
-        if (fdtable == NULL || fdptr == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return EINVAL;
-        }
-
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-        fd_alloc_try_again:
-                if (fdtable->first_free != GF_FDTABLE_END) {
-                        fde = &fdtable->fdentries[fdtable->first_free];
-                        fd = fdtable->first_free;
-                        fdtable->first_free = fde->next_free;
-                        fde->next_free = GF_FDENTRY_ALLOCATED;
-                        fde->fd = fdptr;
-                } else {
-                        /* If this is true, there is something
-                         * seriously wrong with our data structures.
-                         */
-                        if (alloc_attempts >= 2) {
-                                gf_msg ("fd", GF_LOG_ERROR, 0,
-                                        LG_MSG_EXPAND_FD_TABLE_FAILED,
-                                        "multiple attempts to expand fd table"
-                                        " have failed.");
-                                goto out;
-                        }
-                        error = gf_fd_fdtable_expand (fdtable,
-                                                      fdtable->max_fds + 1);
-                        if (error) {
-                                gf_msg ("fd", GF_LOG_ERROR, error,
-                                        LG_MSG_EXPAND_FD_TABLE_FAILED,
-                                        "Cannot expand fdtable");
-                                goto out;
-                        }
-                        ++alloc_attempts;
-                        /* At this point, the table stands expanded
-                         * with the first_free referring to the first
-                         * free entry in the new set of fdentries that
-                         * have just been allocated. That means, the
-                         * above logic should just work.
-                         */
-                        goto fd_alloc_try_again;
-                }
-        }
+    int32_t fd = -1;
+    fdentry_t *fde = NULL;
+    int error;
+    int alloc_attempts = 0;
+
+    if (fdtable == NULL || fdptr == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return EINVAL;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+    fd_alloc_try_again:
+        if (fdtable->first_free != GF_FDTABLE_END) {
+            fde = &fdtable->fdentries[fdtable->first_free];
+            fd = fdtable->first_free;
+            fdtable->first_free = fde->next_free;
+            fde->next_free = GF_FDENTRY_ALLOCATED;
+            fde->fd = fdptr;
+        } else {
+            /* If this is true, there is something
+             * seriously wrong with our data structures.
+             */
+            if (alloc_attempts >= 2) {
+                gf_msg("fd", GF_LOG_ERROR, 0, LG_MSG_EXPAND_FD_TABLE_FAILED,
+                       "multiple attempts to expand fd table"
+                       " have failed.");
+                goto out;
+            }
+            error = gf_fd_fdtable_expand(fdtable, fdtable->max_fds + 1);
+            if (error) {
+                gf_msg("fd", GF_LOG_ERROR, error, LG_MSG_EXPAND_FD_TABLE_FAILED,
+                       "Cannot expand fdtable");
+                goto out;
+            }
+            ++alloc_attempts;
+            /* At this point, the table stands expanded
+             * with the first_free referring to the first
+             * free entry in the new set of fdentries that
+             * have just been allocated. That means, the
+             * above logic should just work.
+             */
+            goto fd_alloc_try_again;
+        }
+    }
 out:
-        pthread_rwlock_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fd;
+    return fd;
 }
 
-
 void
-gf_fd_put (fdtable_t *fdtable, int32_t fd)
+gf_fd_put(fdtable_t *fdtable, int32_t fd)
 {
-        fd_t *fdptr = NULL;
-        fdentry_t *fde = NULL;
+    fd_t *fdptr = NULL;
+    fdentry_t *fde = NULL;
 
-        if (fd == GF_ANON_FD_NO)
-                return;
-
-        if (fdtable == NULL || fd < 0) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
+    if (fd == GF_ANON_FD_NO)
+        return;
 
-        if (!(fd < fdtable->max_fds)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
+    if (fdtable == NULL || fd < 0) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
 
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-                fde = &fdtable->fdentries[fd];
-                /* If the entry is not allocated, put operation must return
-                 * without doing anything.
-                 * This has the potential of masking out any bugs in a user of
-                 * fd that ends up calling gf_fd_put twice for the same fd or
-                 * for an unallocated fd, but it is a price we have to pay for
-                 * ensuring sanity of our fd-table.
-                 */
-                if (fde->next_free != GF_FDENTRY_ALLOCATED)
-                        goto unlock_out;
-                fdptr = fde->fd;
-                fde->fd = NULL;
-                fde->next_free = fdtable->first_free;
-                fdtable->first_free = fd;
-        }
+    if (!(fd < fdtable->max_fds)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
+
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        fde = &fdtable->fdentries[fd];
+        /* If the entry is not allocated, put operation must return
+         * without doing anything.
+         * This has the potential of masking out any bugs in a user of
+         * fd that ends up calling gf_fd_put twice for the same fd or
+         * for an unallocated fd, but it is a price we have to pay for
+         * ensuring sanity of our fd-table.
+         */
+        if (fde->next_free != GF_FDENTRY_ALLOCATED)
+            goto unlock_out;
+        fdptr = fde->fd;
+        fde->fd = NULL;
+        fde->next_free = fdtable->first_free;
+        fdtable->first_free = fd;
+    }
 unlock_out:
-        pthread_rwlock_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        if (fdptr) {
-                fd_unref (fdptr);
-        }
+    if (fdptr) {
+        fd_unref(fdptr);
+    }
 }
 
-
 void
-gf_fdptr_put (fdtable_t *fdtable, fd_t *fd)
+gf_fdptr_put(fdtable_t *fdtable, fd_t *fd)
 {
-        fdentry_t *fde   = NULL;
-        int32_t    i     = 0;
+    fdentry_t *fde = NULL;
+    int32_t i = 0;
+
+    if ((fdtable == NULL) || (fd == NULL)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
 
-        if ((fdtable == NULL) || (fd == NULL)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
+    pthread_rwlock_wrlock(&fdtable->lock);
+    {
+        for (i = 0; i < fdtable->max_fds; i++) {
+            if (fdtable->fdentries[i].fd == fd) {
+                fde = &fdtable->fdentries[i];
+                break;
+            }
         }
 
-        pthread_rwlock_wrlock (&fdtable->lock);
-        {
-                for (i = 0; i < fdtable->max_fds; i++) {
-                        if (fdtable->fdentries[i].fd == fd) {
-                                fde = &fdtable->fdentries[i];
-                                break;
-                        }
-                }
-
-                if (fde == NULL) {
-                        gf_msg_callingfn ("fd", GF_LOG_WARNING, 0,
-                                          LG_MSG_FD_NOT_FOUND_IN_FDTABLE,
-                                          "fd (%p) is not present in fdtable",
-                                          fd);
-                        goto unlock_out;
-                }
-
-                /* If the entry is not allocated, put operation must return
-                 * without doing anything.
-                 * This has the potential of masking out any bugs in a user of
-                 * fd that ends up calling gf_fd_put twice for the same fd or
-                 * for an unallocated fd, but it is a price we have to pay for
-                 * ensuring sanity of our fd-table.
-                 */
-                if (fde->next_free != GF_FDENTRY_ALLOCATED)
-                        goto unlock_out;
-                fde->fd = NULL;
-                fde->next_free = fdtable->first_free;
-                fdtable->first_free = i;
+        if (fde == NULL) {
+            gf_msg_callingfn("fd", GF_LOG_WARNING, 0,
+                             LG_MSG_FD_NOT_FOUND_IN_FDTABLE,
+                             "fd (%p) is not present in fdtable", fd);
+            goto unlock_out;
         }
+
+        /* If the entry is not allocated, put operation must return
+         * without doing anything.
+         * This has the potential of masking out any bugs in a user of
+         * fd that ends up calling gf_fd_put twice for the same fd or
+         * for an unallocated fd, but it is a price we have to pay for
+         * ensuring sanity of our fd-table.
+         */
+        if (fde->next_free != GF_FDENTRY_ALLOCATED)
+            goto unlock_out;
+        fde->fd = NULL;
+        fde->next_free = fdtable->first_free;
+        fdtable->first_free = i;
+    }
 unlock_out:
-        pthread_rwlock_unlock (&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        if ((fd != NULL) && (fde != NULL)) {
-                fd_unref (fd);
-        }
+    if ((fd != NULL) && (fde != NULL)) {
+        fd_unref(fd);
+    }
 }
 
-
 fd_t *
-gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
+gf_fd_fdptr_get(fdtable_t *fdtable, int64_t fd)
 {
-        fd_t *fdptr = NULL;
+    fd_t *fdptr = NULL;
 
-        if (fdtable == NULL || fd < 0) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
+    if (fdtable == NULL || fd < 0) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
 
-        if (!(fd < fdtable->max_fds)) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                errno = EINVAL;
-                return NULL;
-        }
+    if (!(fd < fdtable->max_fds)) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        errno = EINVAL;
+        return NULL;
+    }
 
-        pthread_rwlock_rdlock (&fdtable->lock);
-        {
-                fdptr = fdtable->fdentries[fd].fd;
-                if (fdptr) {
-                        fd_ref (fdptr);
-                }
+    pthread_rwlock_rdlock(&fdtable->lock);
+    {
+        fdptr = fdtable->fdentries[fd].fd;
+        if (fdptr) {
+            fd_ref(fdptr);
         }
-        pthread_rwlock_unlock (&fdtable->lock);
+    }
+    pthread_rwlock_unlock(&fdtable->lock);
 
-        return fdptr;
+    return fdptr;
 }
 
-
 fd_t *
-__fd_ref (fd_t *fd)
+__fd_ref(fd_t *fd)
 {
-        GF_ATOMIC_INC (fd->refcount);
+    GF_ATOMIC_INC(fd->refcount);
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_ref (fd_t *fd)
+fd_ref(fd_t *fd)
 {
-        if (!fd) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "null fd");
-                return NULL;
-        }
+    if (!fd) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "null fd");
+        return NULL;
+    }
 
-        GF_ATOMIC_INC (fd->refcount);
+    GF_ATOMIC_INC(fd->refcount);
 
-        return fd;
+    return fd;
 }
 
-
 static void
-fd_destroy (fd_t *fd, gf_boolean_t bound)
+fd_destroy(fd_t *fd, gf_boolean_t bound)
 {
-        xlator_t    *xl = NULL;
-        int          i = 0;
-        xlator_t    *old_THIS = NULL;
-
-        if (fd == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR,  EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                goto out;
-        }
-
-        if (fd->inode == NULL){
-                gf_msg_callingfn ("xlator", GF_LOG_ERROR, 0,
-                                  LG_MSG_FD_INODE_NULL,
-                                  "fd->inode is NULL");
-                goto out;
-        }
-        if (!fd->_ctx)
-                goto out;
-
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                for (i = 0; i <  fd->xl_count; i++) {
-                        if (fd->_ctx[i].key) {
-                                xl = fd->_ctx[i].xl_key;
-                                old_THIS = THIS;
-                                THIS = xl;
-                                if (!xl->call_cleanup && xl->cbks->releasedir)
-                                        xl->cbks->releasedir (xl, fd);
-                                THIS = old_THIS;
-                        }
-                }
-        } else {
-                for (i = 0; i < fd->xl_count; i++) {
-                        if (fd->_ctx[i].key) {
-                                xl = fd->_ctx[i].xl_key;
-                                old_THIS = THIS;
-                                THIS = xl;
-                                if (!xl->call_cleanup && xl->cbks->release)
-                                        xl->cbks->release (xl, fd);
-                                THIS = old_THIS;
-                        }
-                }
-        }
-
-        LOCK_DESTROY (&fd->lock);
-
-        GF_FREE (fd->_ctx);
-        if (bound) {
-                /*Decrease the count only after close happens on file*/
-                LOCK (&fd->inode->lock);
-                {
-                        fd->inode->fd_count--;
-                }
-                UNLOCK (&fd->inode->lock);
-        }
-        inode_unref (fd->inode);
-        fd->inode = NULL;
-        fd_lk_ctx_unref (fd->lk_ctx);
-        mem_put (fd);
+    xlator_t *xl = NULL;
+    int i = 0;
+    xlator_t *old_THIS = NULL;
+
+    if (fd == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        goto out;
+    }
+
+    if (fd->inode == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_ERROR, 0, LG_MSG_FD_INODE_NULL,
+                         "fd->inode is NULL");
+        goto out;
+    }
+    if (!fd->_ctx)
+        goto out;
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        for (i = 0; i < fd->xl_count; i++) {
+            if (fd->_ctx[i].key) {
+                xl = fd->_ctx[i].xl_key;
+                old_THIS = THIS;
+                THIS = xl;
+                if (!xl->call_cleanup && xl->cbks->releasedir)
+                    xl->cbks->releasedir(xl, fd);
+                THIS = old_THIS;
+            }
+        }
+    } else {
+        for (i = 0; i < fd->xl_count; i++) {
+            if (fd->_ctx[i].key) {
+                xl = fd->_ctx[i].xl_key;
+                old_THIS = THIS;
+                THIS = xl;
+                if (!xl->call_cleanup && xl->cbks->release)
+                    xl->cbks->release(xl, fd);
+                THIS = old_THIS;
+            }
+        }
+    }
+
+    LOCK_DESTROY(&fd->lock);
+
+    GF_FREE(fd->_ctx);
+    if (bound) {
+        /*Decrease the count only after close happens on file*/
+        LOCK(&fd->inode->lock);
+        {
+            fd->inode->fd_count--;
+        }
+        UNLOCK(&fd->inode->lock);
+    }
+    inode_unref(fd->inode);
+    fd->inode = NULL;
+    fd_lk_ctx_unref(fd->lk_ctx);
+    mem_put(fd);
 out:
-        return;
+    return;
 }
 
-
 void
-fd_unref (fd_t *fd)
+fd_unref(fd_t *fd)
 {
-        int32_t refcount = 0;
-        gf_boolean_t bound = _gf_false;
-
-        if (!fd) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "fd is NULL");
-                return;
-        }
-
-        LOCK (&fd->inode->lock);
-        {
-                refcount = GF_ATOMIC_DEC (fd->refcount);
-                if (refcount == 0) {
-                        if (!list_empty (&fd->inode_list)) {
-                                list_del_init (&fd->inode_list);
-                                fd->inode->active_fd_count--;
-                                bound = _gf_true;
-                        }
-                }
+    int32_t refcount = 0;
+    gf_boolean_t bound = _gf_false;
 
-        }
-        UNLOCK (&fd->inode->lock);
+    if (!fd) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "fd is NULL");
+        return;
+    }
 
+    LOCK(&fd->inode->lock);
+    {
+        refcount = GF_ATOMIC_DEC(fd->refcount);
         if (refcount == 0) {
-                fd_destroy (fd, bound);
+            if (!list_empty(&fd->inode_list)) {
+                list_del_init(&fd->inode_list);
+                fd->inode->active_fd_count--;
+                bound = _gf_true;
+            }
         }
+    }
+    UNLOCK(&fd->inode->lock);
 
-        return ;
-}
+    if (refcount == 0) {
+        fd_destroy(fd, bound);
+    }
 
+    return;
+}
 
 fd_t *
-__fd_bind (fd_t *fd)
+__fd_bind(fd_t *fd)
 {
-        list_del_init (&fd->inode_list);
-        list_add (&fd->inode_list, &fd->inode->fd_list);
-        fd->inode->fd_count++;
-        fd->inode->active_fd_count++;
+    list_del_init(&fd->inode_list);
+    list_add(&fd->inode_list, &fd->inode->fd_list);
+    fd->inode->fd_count++;
+    fd->inode->active_fd_count++;
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_bind (fd_t *fd)
+fd_bind(fd_t *fd)
 {
-        if (!fd || !fd->inode) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!fd || !fd->inode");
-                return NULL;
-        }
+    if (!fd || !fd->inode) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "!fd || !fd->inode");
+        return NULL;
+    }
 
-        LOCK (&fd->inode->lock);
-        {
-                fd = __fd_bind (fd);
-        }
-        UNLOCK (&fd->inode->lock);
+    LOCK(&fd->inode->lock);
+    {
+        fd = __fd_bind(fd);
+    }
+    UNLOCK(&fd->inode->lock);
 
-        return fd;
+    return fd;
 }
 
-
 static fd_t *
-__fd_create (inode_t *inode, uint64_t pid)
+__fd_create(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (inode == NULL) {
-                gf_msg_callingfn ("fd", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+    if (inode == NULL) {
+        gf_msg_callingfn("fd", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        fd = mem_get0 (inode->table->fd_mem_pool);
-        if (!fd)
-                goto out;
+    fd = mem_get0(inode->table->fd_mem_pool);
+    if (!fd)
+        goto out;
 
-        fd->xl_count = inode->table->xl->graph->xl_count + 1;
+    fd->xl_count = inode->table->xl->graph->xl_count + 1;
 
-        fd->_ctx = GF_CALLOC (1, (sizeof (struct _fd_ctx) * fd->xl_count),
-                              gf_common_mt_fd_ctx);
-        if (!fd->_ctx)
-                goto free_fd;
+    fd->_ctx = GF_CALLOC(1, (sizeof(struct _fd_ctx) * fd->xl_count),
+                         gf_common_mt_fd_ctx);
+    if (!fd->_ctx)
+        goto free_fd;
 
-        fd->lk_ctx = fd_lk_ctx_create ();
-        if (!fd->lk_ctx)
-                goto free_fd_ctx;
+    fd->lk_ctx = fd_lk_ctx_create();
+    if (!fd->lk_ctx)
+        goto free_fd_ctx;
 
-        fd->inode = inode_ref (inode);
-        fd->pid = pid;
-        INIT_LIST_HEAD (&fd->inode_list);
+    fd->inode = inode_ref(inode);
+    fd->pid = pid;
+    INIT_LIST_HEAD(&fd->inode_list);
 
-        LOCK_INIT (&fd->lock);
+    LOCK_INIT(&fd->lock);
 out:
-        return fd;
+    return fd;
 
 free_fd_ctx:
-        GF_FREE (fd->_ctx);
+    GF_FREE(fd->_ctx);
 free_fd:
-        mem_put (fd);
+    mem_put(fd);
 
-        return NULL;
+    return NULL;
 }
 
-
 fd_t *
-fd_create (inode_t *inode, pid_t pid)
+fd_create(inode_t *inode, pid_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        fd = __fd_create (inode, (uint64_t)pid);
-        if (!fd)
-                goto out;
+    fd = __fd_create(inode, (uint64_t)pid);
+    if (!fd)
+        goto out;
 
-        fd = fd_ref (fd);
+    fd = fd_ref(fd);
 
 out:
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_create_uint64 (inode_t *inode, uint64_t pid)
+fd_create_uint64(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        fd = __fd_create (inode, pid);
-        if (!fd)
-                goto out;
+    fd = __fd_create(inode, pid);
+    if (!fd)
+        goto out;
 
-        fd = fd_ref (fd);
+    fd = fd_ref(fd);
 
 out:
-        return fd;
+    return fd;
 }
 
-
 static fd_t *
-__fd_lookup (inode_t *inode, uint64_t pid)
+__fd_lookup(inode_t *inode, uint64_t pid)
 {
-        fd_t *iter_fd = NULL;
-        fd_t *fd = NULL;
-
-        if (list_empty (&inode->fd_list))
-                return NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *fd = NULL;
 
+    if (list_empty(&inode->fd_list))
+        return NULL;
 
-        list_for_each_entry (iter_fd, &inode->fd_list, inode_list) {
-                if (iter_fd->anonymous)
-                        /* If someone was interested in getting an
-                           anonymous fd (or was OK getting an anonymous fd),
-                           they can as well call fd_anonymous() directly */
-                        continue;
+    list_for_each_entry(iter_fd, &inode->fd_list, inode_list)
+    {
+        if (iter_fd->anonymous)
+            /* If someone was interested in getting an
+               anonymous fd (or was OK getting an anonymous fd),
+               they can as well call fd_anonymous() directly */
+            continue;
 
-                if (!pid || iter_fd->pid == pid) {
-                        fd = __fd_ref (iter_fd);
-                        break;
-                }
+        if (!pid || iter_fd->pid == pid) {
+            fd = __fd_ref(iter_fd);
+            break;
         }
+    }
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_lookup (inode_t *inode, pid_t pid)
+fd_lookup(inode_t *inode, pid_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup (inode, (uint64_t)pid);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup(inode, (uint64_t)pid);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_lookup_uint64 (inode_t *inode, uint64_t pid)
+fd_lookup_uint64(inode_t *inode, uint64_t pid)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup (inode, pid);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup(inode, pid);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
 static fd_t *
-__fd_lookup_anonymous (inode_t *inode, int32_t flags)
+__fd_lookup_anonymous(inode_t *inode, int32_t flags)
 {
-        fd_t *iter_fd = NULL;
-        fd_t *fd = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *fd = NULL;
 
-        if (list_empty (&inode->fd_list))
-                return NULL;
+    if (list_empty(&inode->fd_list))
+        return NULL;
 
-        list_for_each_entry (iter_fd, &inode->fd_list, inode_list) {
-                if ((iter_fd->anonymous) && (flags == iter_fd->flags)) {
-                        fd = __fd_ref (iter_fd);
-                        break;
-                }
+    list_for_each_entry(iter_fd, &inode->fd_list, inode_list)
+    {
+        if ((iter_fd->anonymous) && (flags == iter_fd->flags)) {
+            fd = __fd_ref(iter_fd);
+            break;
         }
+    }
 
-        return fd;
+    return fd;
 }
 
 static fd_t *
-__fd_anonymous (inode_t *inode, int32_t flags)
+__fd_anonymous(inode_t *inode, int32_t flags)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        fd = __fd_lookup_anonymous (inode, flags);
+    fd = __fd_lookup_anonymous(inode, flags);
 
-        /* if (fd); then we already have increased the refcount in
-           __fd_lookup_anonymous(), so no need of one more fd_ref().
-           if (!fd); then both create and bind won't bump up the ref
-           count, so we have to call fd_ref() after bind. */
-        if (!fd) {
-                fd = __fd_create (inode, 0);
+    /* if (fd); then we already have increased the refcount in
+       __fd_lookup_anonymous(), so no need of one more fd_ref().
+       if (!fd); then both create and bind won't bump up the ref
+       count, so we have to call fd_ref() after bind. */
+    if (!fd) {
+        fd = __fd_create(inode, 0);
 
-                if (!fd)
-                        return NULL;
+        if (!fd)
+            return NULL;
 
-                fd->anonymous = _gf_true;
-                fd->flags = GF_ANON_FD_FLAGS|flags;
+        fd->anonymous = _gf_true;
+        fd->flags = GF_ANON_FD_FLAGS | flags;
 
-                __fd_bind (fd);
+        __fd_bind(fd);
 
-                __fd_ref (fd);
-        }
+        __fd_ref(fd);
+    }
 
-        return fd;
+    return fd;
 }
 
-
 fd_t *
-fd_anonymous (inode_t *inode)
+fd_anonymous(inode_t *inode)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_anonymous (inode, GF_ANON_FD_FLAGS);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        fd = __fd_anonymous(inode, GF_ANON_FD_FLAGS);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
 fd_t *
-fd_anonymous_with_flags (inode_t *inode, int32_t flags)
+fd_anonymous_with_flags(inode_t *inode, int32_t flags)
 {
-        fd_t *fd = NULL;
+    fd_t *fd = NULL;
 
-        LOCK (&inode->lock);
-        {
-                if (flags & O_DIRECT)
-                        flags = GF_ANON_FD_FLAGS | O_DIRECT;
-                else
-                        flags = GF_ANON_FD_FLAGS;
+    LOCK(&inode->lock);
+    {
+        if (flags & O_DIRECT)
+            flags = GF_ANON_FD_FLAGS | O_DIRECT;
+        else
+            flags = GF_ANON_FD_FLAGS;
 
-                fd = __fd_anonymous (inode, flags);
-        }
-        UNLOCK (&inode->lock);
+        fd = __fd_anonymous(inode, flags);
+    }
+    UNLOCK(&inode->lock);
 
-        return fd;
+    return fd;
 }
 
-fd_t*
-fd_lookup_anonymous (inode_t *inode, int32_t flags)
+fd_t *
+fd_lookup_anonymous(inode_t *inode, int32_t flags)
 {
-        fd_t *fd = NULL;
-
-        if (!inode) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "!inode");
-                return NULL;
-        }
+    fd_t *fd = NULL;
 
-        LOCK (&inode->lock);
-        {
-                fd = __fd_lookup_anonymous (inode, flags);
-        }
-        UNLOCK (&inode->lock);
-        return fd;
+    if (!inode) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "!inode");
+        return NULL;
+    }
+
+    LOCK(&inode->lock);
+    {
+        fd = __fd_lookup_anonymous(inode, flags);
+    }
+    UNLOCK(&inode->lock);
+    return fd;
 }
 
 gf_boolean_t
-fd_is_anonymous (fd_t *fd)
+fd_is_anonymous(fd_t *fd)
 {
-        return (fd && fd->anonymous);
+    return (fd && fd->anonymous);
 }
 
-
 uint8_t
-fd_list_empty (inode_t *inode)
+fd_list_empty(inode_t *inode)
 {
-        uint8_t empty = 0;
+    uint8_t empty = 0;
 
-        LOCK (&inode->lock);
-        {
-                empty = list_empty (&inode->fd_list);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        empty = list_empty(&inode->fd_list);
+    }
+    UNLOCK(&inode->lock);
 
-        return empty;
+    return empty;
 }
 
-
 int
-__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
+__fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value)
 {
-        int             index   = 0, new_xl_count = 0;
-        int             ret     = 0;
-        int             set_idx = -1;
-        void           *begin   = NULL;
-        size_t          diff    = 0;
-        struct _fd_ctx *tmp     = NULL;
-
-	if (!fd || !xlator)
-		return -1;
-
-        for (index = 0; index < fd->xl_count; index++) {
-                if (!fd->_ctx[index].key) {
-                        if (set_idx == -1)
-                                set_idx = index;
-                        /* don't break, to check if key already exists
-                           further on */
-                }
-                if (fd->_ctx[index].xl_key == xlator) {
-                        set_idx = index;
-                        break;
-                }
+    int index = 0, new_xl_count = 0;
+    int ret = 0;
+    int set_idx = -1;
+    void *begin = NULL;
+    size_t diff = 0;
+    struct _fd_ctx *tmp = NULL;
+
+    if (!fd || !xlator)
+        return -1;
+
+    for (index = 0; index < fd->xl_count; index++) {
+        if (!fd->_ctx[index].key) {
+            if (set_idx == -1)
+                set_idx = index;
+            /* don't break, to check if key already exists
+               further on */
         }
+        if (fd->_ctx[index].xl_key == xlator) {
+            set_idx = index;
+            break;
+        }
+    }
 
-        if (set_idx == -1) {
-                set_idx = fd->xl_count;
+    if (set_idx == -1) {
+        set_idx = fd->xl_count;
 
-                new_xl_count = fd->xl_count + xlator->graph->xl_count;
+        new_xl_count = fd->xl_count + xlator->graph->xl_count;
 
-                tmp = GF_REALLOC (fd->_ctx,
-                                  (sizeof (struct _fd_ctx)
-                                   * new_xl_count));
-                if (tmp == NULL) {
-                        ret = -1;
-                        goto out;
-                }
+        tmp = GF_REALLOC(fd->_ctx, (sizeof(struct _fd_ctx) * new_xl_count));
+        if (tmp == NULL) {
+            ret = -1;
+            goto out;
+        }
 
-                fd->_ctx = tmp;
+        fd->_ctx = tmp;
 
-                begin = fd->_ctx;
-                begin += (fd->xl_count * sizeof (struct _fd_ctx));
+        begin = fd->_ctx;
+        begin += (fd->xl_count * sizeof(struct _fd_ctx));
 
-                diff = (new_xl_count - fd->xl_count )
-                        * sizeof (struct _fd_ctx);
+        diff = (new_xl_count - fd->xl_count) * sizeof(struct _fd_ctx);
 
-                memset (begin, 0, diff);
+        memset(begin, 0, diff);
 
-                fd->xl_count = new_xl_count;
-        }
+        fd->xl_count = new_xl_count;
+    }
 
-        fd->_ctx[set_idx].xl_key = xlator;
-        fd->_ctx[set_idx].value1  = value;
+    fd->_ctx[set_idx].xl_key = xlator;
+    fd->_ctx[set_idx].value1 = value;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
+fd_ctx_set(fd_t *fd, xlator_t *xlator, uint64_t value)
 {
-        int ret = 0;
+    int ret = 0;
 
-	if (!fd || !xlator) {
-                gf_msg_callingfn ("fd", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "%p %p", fd, xlator);
-		return -1;
-        }
+    if (!fd || !xlator) {
+        gf_msg_callingfn("fd", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "%p %p", fd, xlator);
+        return -1;
+    }
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_set (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_set(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
+__fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        for (index = 0; index < fd->xl_count; index++) {
-                if (fd->_ctx[index].xl_key == xlator)
-                        break;
-        }
+    for (index = 0; index < fd->xl_count; index++) {
+        if (fd->_ctx[index].xl_key == xlator)
+            break;
+    }
 
-        if (index == fd->xl_count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == fd->xl_count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = fd->_ctx[index].value1;
+    if (value)
+        *value = fd->_ctx[index].value1;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
+fd_ctx_get(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
+__fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        for (index = 0; index < fd->xl_count; index++) {
-                if (fd->_ctx[index].xl_key == xlator)
-                        break;
-        }
+    for (index = 0; index < fd->xl_count; index++) {
+        if (fd->_ctx[index].xl_key == xlator)
+            break;
+    }
 
-        if (index == fd->xl_count) {
-                ret = -1;
-                goto out;
-        }
+    if (index == fd->xl_count) {
+        ret = -1;
+        goto out;
+    }
 
-        if (value)
-                *value = fd->_ctx[index].value1;
+    if (value)
+        *value = fd->_ctx[index].value1;
 
-        fd->_ctx[index].key   = 0;
-        fd->_ctx[index].value1 = 0;
+    fd->_ctx[index].key = 0;
+    fd->_ctx[index].value1 = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
+fd_ctx_del(fd_t *fd, xlator_t *xlator, uint64_t *value)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!fd || !xlator)
-                return -1;
+    if (!fd || !xlator)
+        return -1;
 
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_del (fd, xlator, value);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_del(fd, xlator, value);
+    }
+    UNLOCK(&fd->lock);
 
-        return ret;
+    return ret;
 }
 
-
 void
-fd_dump (fd_t *fd, char *prefix)
+fd_dump(fd_t *fd, char *prefix)
 {
-        char        key[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
 
-        if (!fd)
-                return;
-
-        gf_proc_dump_write("pid", "%llu", fd->pid);
-        gf_proc_dump_write("refcount", "%d", fd->refcount);
-        gf_proc_dump_write("flags", "%d", fd->flags);
+    if (!fd)
+        return;
 
-        if (fd->inode) {
-                gf_proc_dump_build_key (key, "inode", NULL);
-                gf_proc_dump_add_section(key);
-                inode_dump (fd->inode, key);
-        }
+    gf_proc_dump_write("pid", "%llu", fd->pid);
+    gf_proc_dump_write("refcount", "%d", fd->refcount);
+    gf_proc_dump_write("flags", "%d", fd->flags);
 
+    if (fd->inode) {
+        gf_proc_dump_build_key(key, "inode", NULL);
+        gf_proc_dump_add_section(key);
+        inode_dump(fd->inode, key);
+    }
 }
 
-
 void
-fdentry_dump (fdentry_t *fdentry, char *prefix)
+fdentry_dump(fdentry_t *fdentry, char *prefix)
 {
-        if (!fdentry)
-                return;
+    if (!fdentry)
+        return;
 
-        if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
-                return;
+    if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
+        return;
 
-        if (fdentry->fd)
-                fd_dump(fdentry->fd, prefix);
+    if (fdentry->fd)
+        fd_dump(fdentry->fd, prefix);
 }
 
-
 void
-fdtable_dump (fdtable_t *fdtable, char *prefix)
+fdtable_dump(fdtable_t *fdtable, char *prefix)
 {
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     i = 0;
-        int     ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+    int ret = -1;
 
-        if (!fdtable)
-                return;
+    if (!fdtable)
+        return;
 
-        ret = pthread_rwlock_tryrdlock (&fdtable->lock);
-        if (ret)
-                goto out;
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        goto out;
 
-        gf_proc_dump_build_key(key, prefix, "refcount");
-        gf_proc_dump_write(key, "%d", fdtable->refcount);
-        gf_proc_dump_build_key(key, prefix, "maxfds");
-        gf_proc_dump_write(key, "%d", fdtable->max_fds);
-        gf_proc_dump_build_key(key, prefix, "first_free");
-        gf_proc_dump_write(key, "%d", fdtable->first_free);
-
-        for ( i = 0 ; i < fdtable->max_fds; i++) {
-                if (GF_FDENTRY_ALLOCATED ==
-                    fdtable->fdentries[i].next_free) {
-                        gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
-                        gf_proc_dump_add_section(key);
-                        fdentry_dump(&fdtable->fdentries[i], key);
-                }
+    gf_proc_dump_build_key(key, prefix, "refcount");
+    gf_proc_dump_write(key, "%d", fdtable->refcount);
+    gf_proc_dump_build_key(key, prefix, "maxfds");
+    gf_proc_dump_write(key, "%d", fdtable->max_fds);
+    gf_proc_dump_build_key(key, prefix, "first_free");
+    gf_proc_dump_write(key, "%d", fdtable->first_free);
+
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (GF_FDENTRY_ALLOCATED == fdtable->fdentries[i].next_free) {
+            gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
+            gf_proc_dump_add_section(key);
+            fdentry_dump(&fdtable->fdentries[i], key);
         }
+    }
 
-        pthread_rwlock_unlock(&fdtable->lock);
+    pthread_rwlock_unlock(&fdtable->lock);
 
 out:
-        if (ret != 0)
-                gf_proc_dump_write ("Unable to dump the fdtable",
-                                    "(Lock acquistion failed) %p", fdtable);
-        return;
+    if (ret != 0)
+        gf_proc_dump_write("Unable to dump the fdtable",
+                           "(Lock acquistion failed) %p", fdtable);
+    return;
 }
 
-
 void
-fd_ctx_dump (fd_t *fd, char *prefix)
+fd_ctx_dump(fd_t *fd, char *prefix)
 {
-        struct _fd_ctx *fd_ctx = NULL;
-        xlator_t       *xl     = NULL;
-        int    i               = 0;
-
-
-        if ((fd == NULL) || (fd->_ctx == NULL)) {
-                goto out;
-        }
-
-        LOCK (&fd->lock);
-        {
-                if (fd->_ctx != NULL) {
-                        fd_ctx = GF_CALLOC (fd->xl_count, sizeof (*fd_ctx),
-                                            gf_common_mt_fd_ctx);
-                        if (fd_ctx == NULL) {
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < fd->xl_count; i++) {
-                                fd_ctx[i] = fd->_ctx[i];
-                        }
-                }
-        }
+    struct _fd_ctx *fd_ctx = NULL;
+    xlator_t *xl = NULL;
+    int i = 0;
+
+    if ((fd == NULL) || (fd->_ctx == NULL)) {
+        goto out;
+    }
+
+    LOCK(&fd->lock);
+    {
+        if (fd->_ctx != NULL) {
+            fd_ctx = GF_CALLOC(fd->xl_count, sizeof(*fd_ctx),
+                               gf_common_mt_fd_ctx);
+            if (fd_ctx == NULL) {
+                goto unlock;
+            }
+
+            for (i = 0; i < fd->xl_count; i++) {
+                fd_ctx[i] = fd->_ctx[i];
+            }
+        }
+    }
 unlock:
-        UNLOCK (&fd->lock);
+    UNLOCK(&fd->lock);
 
-        if (fd_ctx == NULL) {
-                goto out;
-        }
+    if (fd_ctx == NULL) {
+        goto out;
+    }
 
-        for (i = 0; i < fd->xl_count; i++) {
-                if (fd_ctx[i].xl_key) {
-                        xl = (xlator_t *)(long)fd_ctx[i].xl_key;
-                        if (xl->dumpops && xl->dumpops->fdctx)
-                                xl->dumpops->fdctx (xl, fd);
-                }
+    for (i = 0; i < fd->xl_count; i++) {
+        if (fd_ctx[i].xl_key) {
+            xl = (xlator_t *)(long)fd_ctx[i].xl_key;
+            if (xl->dumpops && xl->dumpops->fdctx)
+                xl->dumpops->fdctx(xl, fd);
         }
+    }
 
 out:
-        GF_FREE (fd_ctx);
+    GF_FREE(fd_ctx);
 
-        return;
+    return;
 }
 
 void
-fdentry_dump_to_dict (fdentry_t *fdentry, char *prefix, dict_t *dict,
-                      int *openfds)
+fdentry_dump_to_dict(fdentry_t *fdentry, char *prefix, dict_t *dict,
+                     int *openfds)
 {
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int     ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int ret = -1;
 
-        if (!fdentry)
-                return;
-        if (!dict)
-                return;
+    if (!fdentry)
+        return;
+    if (!dict)
+        return;
 
-        if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
-                return;
+    if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
+        return;
 
-        if (fdentry->fd) {
-                snprintf (key, sizeof (key), "%s.pid", prefix);
-                ret = dict_set_uint64 (dict, key, fdentry->fd->pid);
-                if (ret)
-                        return;
+    if (fdentry->fd) {
+        snprintf(key, sizeof(key), "%s.pid", prefix);
+        ret = dict_set_uint64(dict, key, fdentry->fd->pid);
+        if (ret)
+            return;
 
-                snprintf (key, sizeof (key), "%s.refcount", prefix);
-                ret = dict_set_int32 (dict, key, GF_ATOMIC_GET (fdentry->fd->refcount));
-                if (ret)
-                        return;
+        snprintf(key, sizeof(key), "%s.refcount", prefix);
+        ret = dict_set_int32(dict, key, GF_ATOMIC_GET(fdentry->fd->refcount));
+        if (ret)
+            return;
 
-                snprintf (key, sizeof (key), "%s.flags", prefix);
-                ret = dict_set_int32 (dict, key, fdentry->fd->flags);
+        snprintf(key, sizeof(key), "%s.flags", prefix);
+        ret = dict_set_int32(dict, key, fdentry->fd->flags);
 
-                (*openfds)++;
-        }
-        return;
+        (*openfds)++;
+    }
+    return;
 }
 
 void
-fdtable_dump_to_dict (fdtable_t *fdtable, char *prefix, dict_t *dict)
+fdtable_dump_to_dict(fdtable_t *fdtable, char *prefix, dict_t *dict)
 {
-        char    key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int     i = 0;
-        int     openfds = 0;
-        int     ret = -1;
-
-        if (!fdtable)
-                return;
-        if (!dict)
-                return;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int i = 0;
+    int openfds = 0;
+    int ret = -1;
+
+    if (!fdtable)
+        return;
+    if (!dict)
+        return;
 
-        ret = pthread_rwlock_tryrdlock (&fdtable->lock);
-        if (ret)
-                return;
+    ret = pthread_rwlock_tryrdlock(&fdtable->lock);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.fdtable.refcount", prefix);
-        ret = dict_set_int32 (dict, key, fdtable->refcount);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.fdtable.refcount", prefix);
+    ret = dict_set_int32(dict, key, fdtable->refcount);
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "%s.fdtable.maxfds", prefix);
-        ret = dict_set_uint32 (dict, key, fdtable->max_fds);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.fdtable.maxfds", prefix);
+    ret = dict_set_uint32(dict, key, fdtable->max_fds);
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "%s.fdtable.firstfree", prefix);
-        ret = dict_set_int32 (dict, key, fdtable->first_free);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.fdtable.firstfree", prefix);
+    ret = dict_set_int32(dict, key, fdtable->first_free);
+    if (ret)
+        goto out;
 
-        for (i = 0; i < fdtable->max_fds; i++) {
-                if (GF_FDENTRY_ALLOCATED ==
-                    fdtable->fdentries[i].next_free) {
-                        snprintf (key, sizeof (key), "%s.fdtable.fdentry%d",
-                                  prefix, i);
-                        fdentry_dump_to_dict (&fdtable->fdentries[i], key,
-                                              dict, &openfds);
-                }
+    for (i = 0; i < fdtable->max_fds; i++) {
+        if (GF_FDENTRY_ALLOCATED == fdtable->fdentries[i].next_free) {
+            snprintf(key, sizeof(key), "%s.fdtable.fdentry%d", prefix, i);
+            fdentry_dump_to_dict(&fdtable->fdentries[i], key, dict, &openfds);
         }
+    }
 
-        snprintf (key, sizeof (key), "%s.fdtable.openfds", prefix);
-        ret = dict_set_int32 (dict, key, openfds);
+    snprintf(key, sizeof(key), "%s.fdtable.openfds", prefix);
+    ret = dict_set_int32(dict, key, openfds);
 
 out:
-        pthread_rwlock_unlock (&fdtable->lock);
-        return;
+    pthread_rwlock_unlock(&fdtable->lock);
+    return;
 }
diff --git a/libglusterfs/src/gf-dirent.c b/libglusterfs/src/gf-dirent.c
index d0df80e2886..c06e959aeba 100644
--- a/libglusterfs/src/gf-dirent.c
+++ b/libglusterfs/src/gf-dirent.c
@@ -8,8 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
@@ -22,223 +20,221 @@
 #define BACKEND_D_OFF_BITS 63
 #define TOP_BIT (ONE << (PRESENT_D_OFF_BITS - 1))
 #define MASK (~0ULL)
-#define SHIFT_BITS (max (0, (BACKEND_D_OFF_BITS - PRESENT_D_OFF_BITS + 1)))
+#define SHIFT_BITS (max(0, (BACKEND_D_OFF_BITS - PRESENT_D_OFF_BITS + 1)))
 #define PRESENT_MASK (MASK >> (64 - PRESENT_D_OFF_BITS))
 
 static uint64_t
-bits_for (uint64_t num)
+bits_for(uint64_t num)
 {
-	uint64_t bits = 0, ctrl = 1;
+    uint64_t bits = 0, ctrl = 1;
 
-	while (ctrl < num) {
-		ctrl *= 2;
-		bits++;
-	}
+    while (ctrl < num) {
+        ctrl *= 2;
+        bits++;
+    }
 
-	return bits;
+    return bits;
 }
 
 int
-gf_deitransform(xlator_t *this,
-                uint64_t offset)
+gf_deitransform(xlator_t *this, uint64_t offset)
 {
-        int         cnt = 0;
-        int         max = 0;
-        int         max_bits = 0;
-        uint64_t    off_mask = 0;
-        uint64_t    host_mask = 0;
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-		cnt = 0;
-		goto out;
-	}
-
-        if (offset & TOP_BIT) {
-                /* HUGE d_off */
-                max_bits = bits_for (max);
-                off_mask = (MASK << max_bits);
-                host_mask = ~(off_mask);
-
-                cnt = offset & host_mask;
-	} else {
-                /* small d_off */
-                cnt = offset % max;
-        }
+    int cnt = 0;
+    int max = 0;
+    int max_bits = 0;
+    uint64_t off_mask = 0;
+    uint64_t host_mask = 0;
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        cnt = 0;
+        goto out;
+    }
+
+    if (offset & TOP_BIT) {
+        /* HUGE d_off */
+        max_bits = bits_for(max);
+        off_mask = (MASK << max_bits);
+        host_mask = ~(off_mask);
+
+        cnt = offset & host_mask;
+    } else {
+        /* small d_off */
+        cnt = offset % max;
+    }
 out:
-        return cnt;
+    return cnt;
 }
 
 uint64_t
-gf_dirent_orig_offset(xlator_t *this,
-                      uint64_t offset)
+gf_dirent_orig_offset(xlator_t *this, uint64_t offset)
 {
-        int         max = 0;
-        int         max_bits = 0;
-        uint64_t    off_mask = 0;
-        uint64_t    orig_offset;
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-                orig_offset = offset;
-		goto out;
-	}
-
-        if (offset & TOP_BIT) {
-                /* HUGE d_off */
-                max_bits = bits_for (max);
-                off_mask = (MASK << max_bits);
-                orig_offset = ((offset & ~TOP_BIT) & off_mask) << SHIFT_BITS;
-	} else {
-                /* small d_off */
-                orig_offset = offset / max;
-        }
+    int max = 0;
+    int max_bits = 0;
+    uint64_t off_mask = 0;
+    uint64_t orig_offset;
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        orig_offset = offset;
+        goto out;
+    }
+
+    if (offset & TOP_BIT) {
+        /* HUGE d_off */
+        max_bits = bits_for(max);
+        off_mask = (MASK << max_bits);
+        orig_offset = ((offset & ~TOP_BIT) & off_mask) << SHIFT_BITS;
+    } else {
+        /* small d_off */
+        orig_offset = offset / max;
+    }
 out:
-        return orig_offset;
+    return orig_offset;
 }
 
 int
-gf_itransform (xlator_t *this, uint64_t x, uint64_t *y_p, int client_id)
+gf_itransform(xlator_t *this, uint64_t x, uint64_t *y_p, int client_id)
 {
-        int         max = 0;
-        uint64_t    y = 0;
-        uint64_t    hi_mask = 0;
-        uint64_t    off_mask = 0;
-        int         max_bits = 0;
-
-        if (x == ((uint64_t) -1)) {
-                y = (uint64_t) -1;
-                goto out;
-        }
-
-        if (!x) {
-                y = 0;
-                goto out;
-        }
-
-        max = glusterfs_get_leaf_count(this->graph);
-
-	if (max == 1) {
-		y = x;
-		goto out;
-	}
-
-        max_bits = bits_for (max);
-
-        hi_mask = ~(PRESENT_MASK >> (max_bits + 1));
-
-        if (x & hi_mask) {
-                /* HUGE d_off */
-                off_mask = MASK << max_bits;
-                y = TOP_BIT | ((x >> SHIFT_BITS) & off_mask) | client_id;
-        } else {
-                /* small d_off */
-                y = ((x * max) + client_id);
-        }
+    int max = 0;
+    uint64_t y = 0;
+    uint64_t hi_mask = 0;
+    uint64_t off_mask = 0;
+    int max_bits = 0;
+
+    if (x == ((uint64_t)-1)) {
+        y = (uint64_t)-1;
+        goto out;
+    }
+
+    if (!x) {
+        y = 0;
+        goto out;
+    }
+
+    max = glusterfs_get_leaf_count(this->graph);
+
+    if (max == 1) {
+        y = x;
+        goto out;
+    }
+
+    max_bits = bits_for(max);
+
+    hi_mask = ~(PRESENT_MASK >> (max_bits + 1));
+
+    if (x & hi_mask) {
+        /* HUGE d_off */
+        off_mask = MASK << max_bits;
+        y = TOP_BIT | ((x >> SHIFT_BITS) & off_mask) | client_id;
+    } else {
+        /* small d_off */
+        y = ((x * max) + client_id);
+    }
 
 out:
-        if (y_p)
-                *y_p = y;
+    if (y_p)
+        *y_p = y;
 
-        return 0;
+    return 0;
 }
 
 gf_dirent_t *
-gf_dirent_for_name (const char *name)
+gf_dirent_for_name(const char *name)
 {
-        gf_dirent_t *gf_dirent = NULL;
+    gf_dirent_t *gf_dirent = NULL;
 
-        /* TODO: use mem-pool */
-        gf_dirent = GF_CALLOC (gf_dirent_size (name), 1,
-                               gf_common_mt_gf_dirent_t);
-        if (!gf_dirent)
-                return NULL;
+    /* TODO: use mem-pool */
+    gf_dirent = GF_CALLOC(gf_dirent_size(name), 1, gf_common_mt_gf_dirent_t);
+    if (!gf_dirent)
+        return NULL;
 
-        INIT_LIST_HEAD (&gf_dirent->list);
-        strcpy (gf_dirent->d_name, name);
+    INIT_LIST_HEAD(&gf_dirent->list);
+    strcpy(gf_dirent->d_name, name);
 
-        gf_dirent->d_off = 0;
-        gf_dirent->d_ino = -1;
-        gf_dirent->d_type = 0;
-        gf_dirent->d_len = strlen (name);
+    gf_dirent->d_off = 0;
+    gf_dirent->d_ino = -1;
+    gf_dirent->d_type = 0;
+    gf_dirent->d_len = strlen(name);
 
-        return gf_dirent;
+    return gf_dirent;
 }
 
 void
-gf_dirent_entry_free (gf_dirent_t *entry)
+gf_dirent_entry_free(gf_dirent_t *entry)
 {
-        if (!entry)
-                return;
+    if (!entry)
+        return;
 
-        if (entry->dict)
-                dict_unref (entry->dict);
-        if (entry->inode)
-                inode_unref (entry->inode);
+    if (entry->dict)
+        dict_unref(entry->dict);
+    if (entry->inode)
+        inode_unref(entry->inode);
 
-        list_del_init (&entry->list);
-        GF_FREE (entry);
+    list_del_init(&entry->list);
+    GF_FREE(entry);
 }
 
 void
-gf_dirent_free (gf_dirent_t *entries)
+gf_dirent_free(gf_dirent_t *entries)
 {
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        if (!entries)
-                return;
+    if (!entries)
+        return;
 
-        if (list_empty (&entries->list))
-                return;
+    if (list_empty(&entries->list))
+        return;
 
-        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-                gf_dirent_entry_free (entry);
-        }
+    list_for_each_entry_safe(entry, tmp, &entries->list, list)
+    {
+        gf_dirent_entry_free(entry);
+    }
 }
 
 gf_dirent_t *
-entry_copy (gf_dirent_t *source)
+entry_copy(gf_dirent_t *source)
 {
-        gf_dirent_t *sink = NULL;
+    gf_dirent_t *sink = NULL;
 
-        sink = gf_dirent_for_name (source->d_name);
-        if (!sink)
-                return NULL;
+    sink = gf_dirent_for_name(source->d_name);
+    if (!sink)
+        return NULL;
 
-        sink->d_off = source->d_off;
-        sink->d_ino = source->d_ino;
-        sink->d_type = source->d_type;
-        sink->d_stat = source->d_stat;
-        sink->d_len  = source->d_len;
+    sink->d_off = source->d_off;
+    sink->d_ino = source->d_ino;
+    sink->d_type = source->d_type;
+    sink->d_stat = source->d_stat;
+    sink->d_len = source->d_len;
 
-	if (source->inode)
-		sink->inode = inode_ref (source->inode);
+    if (source->inode)
+        sink->inode = inode_ref(source->inode);
 
-	if (source->dict)
-		sink->dict = dict_ref (source->dict);
-        return sink;
+    if (source->dict)
+        sink->dict = dict_ref(source->dict);
+    return sink;
 }
 
 void
-gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry)
+gf_link_inode_from_dirent(xlator_t *this, inode_t *parent, gf_dirent_t *entry)
 {
-        inode_t     *link_inode = NULL;
-        inode_t     *tmp        = NULL;
-
-        if (!entry->inode)
-                return;
-        link_inode = inode_link (entry->inode, parent,
-                                 entry->d_name, &entry->d_stat);
-        if (!link_inode)
-                return;
-
-        inode_lookup (link_inode);
-        tmp = entry->inode;
-        entry->inode = link_inode;
-        inode_unref (tmp);
+    inode_t *link_inode = NULL;
+    inode_t *tmp = NULL;
+
+    if (!entry->inode)
+        return;
+    link_inode = inode_link(entry->inode, parent, entry->d_name,
+                            &entry->d_stat);
+    if (!link_inode)
+        return;
+
+    inode_lookup(link_inode);
+    tmp = entry->inode;
+    entry->inode = link_inode;
+    inode_unref(tmp);
 }
 
 /* TODO: Currently, with this function, we will be breaking the
@@ -247,55 +243,60 @@ gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry)
    Need more thoughts before finalizing this function
 */
 int
-gf_link_inodes_from_dirent (xlator_t *this, inode_t *parent,
-                            gf_dirent_t *entries)
+gf_link_inodes_from_dirent(xlator_t *this, inode_t *parent,
+                           gf_dirent_t *entries)
 {
-        gf_dirent_t *entry      = NULL;
+    gf_dirent_t *entry = NULL;
 
-        list_for_each_entry (entry, &entries->list, list) {
-                gf_link_inode_from_dirent (this, parent, entry);
-        }
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        gf_link_inode_from_dirent(this, parent, entry);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-gf_fill_iatt_for_dirent (gf_dirent_t *entry, inode_t *parent, xlator_t *subvol)
+gf_fill_iatt_for_dirent(gf_dirent_t *entry, inode_t *parent, xlator_t *subvol)
 {
-        loc_t                   loc             = {0, };
-        int                     ret             = -1;
-        char                   *path            = NULL;
-        struct iatt             iatt            = {0,};
-
-        loc.inode = inode_grep (parent->table, parent, entry->d_name);
-        if (!loc.inode) {
-                loc.inode = inode_new (parent->table);
-                gf_uuid_copy (loc.inode->gfid, entry->d_stat.ia_gfid);
-        }
-
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.name = entry->d_name;
-        loc.parent = inode_ref (parent);
-        ret = inode_path (loc.inode, entry->d_name, &path);
-        loc.path = path;
-        if (ret < 0)
-                goto out;
-
-        ret = syncop_lookup (subvol, &loc, &iatt, NULL, NULL, NULL);
-        if (ret)
-                goto out;
-
-        entry->d_stat = iatt;
-        entry->inode = inode_ref (loc.inode);
-        /* We don't need to link inode here, because as part of readdirp_cbk
-         * we will link all dirents.
-         *
-         * Since we did a proper lookup, we don't need to set need_lookup
-         * flag.
-         */
-
-        ret = 0;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *path = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    loc.inode = inode_grep(parent->table, parent, entry->d_name);
+    if (!loc.inode) {
+        loc.inode = inode_new(parent->table);
+        gf_uuid_copy(loc.inode->gfid, entry->d_stat.ia_gfid);
+    }
+
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = entry->d_name;
+    loc.parent = inode_ref(parent);
+    ret = inode_path(loc.inode, entry->d_name, &path);
+    loc.path = path;
+    if (ret < 0)
+        goto out;
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, NULL, NULL);
+    if (ret)
+        goto out;
+
+    entry->d_stat = iatt;
+    entry->inode = inode_ref(loc.inode);
+    /* We don't need to link inode here, because as part of readdirp_cbk
+     * we will link all dirents.
+     *
+     * Since we did a proper lookup, we don't need to set need_lookup
+     * flag.
+     */
+
+    ret = 0;
 out:
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.c b/libglusterfs/src/gfdb/gfdb_data_store.c
index 78fd22ee252..426596c571e 100644
--- a/libglusterfs/src/gfdb/gfdb_data_store.c
+++ b/libglusterfs/src/gfdb/gfdb_data_store.c
@@ -30,11 +30,10 @@
  * gfdb_conn_node_t is an opaque structure.
  * */
 struct gfdb_conn_node_t {
-        gfdb_connection_t       gfdb_connection;
-        struct list_head        conn_list;
+    gfdb_connection_t gfdb_connection;
+    struct list_head conn_list;
 };
 
-
 /*
  * db_conn_list is the circular linked list which
  * will have all the database connections for the process
@@ -48,173 +47,168 @@ static gfdb_conn_node_t *db_conn_list;
  * */
 static pthread_mutex_t db_conn_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-
 /*Checks the sanity of the connection node*/
-#define CHECK_CONN_NODE(_conn_node)\
-do {\
-        GF_ASSERT (_conn_node);\
-        GF_ASSERT (_conn_node->gfdb_connection.gf_db_connection);\
-} while (0)
+#define CHECK_CONN_NODE(_conn_node)                                            \
+    do {                                                                       \
+        GF_ASSERT(_conn_node);                                                 \
+        GF_ASSERT(_conn_node->gfdb_connection.gf_db_connection);               \
+    } while (0)
 
 /* Checks the sanity of the connection node and goto */
-#define CHECK_CONN_NODE_GOTO(_conn_node, label)\
-do {\
-        if (!_conn_node) {\
-                goto label;\
-        };\
-        if (!_conn_node->gfdb_connection.gf_db_connection) {\
-                goto label;\
-        };\
-} while (0)
+#define CHECK_CONN_NODE_GOTO(_conn_node, label)                                \
+    do {                                                                       \
+        if (!_conn_node) {                                                     \
+            goto label;                                                        \
+        };                                                                     \
+        if (!_conn_node->gfdb_connection.gf_db_connection) {                   \
+            goto label;                                                        \
+        };                                                                     \
+    } while (0)
 
 /*Check if the conn node is first in the list*/
-#define IS_FIRST_NODE(db_conn_list, _conn_node)\
-        ((_conn_node == db_conn_list) ? _gf_true : _gf_false)
-
+#define IS_FIRST_NODE(db_conn_list, _conn_node)                                \
+    ((_conn_node == db_conn_list) ? _gf_true : _gf_false)
 
 /*Check if the conn node is the only node in the list*/
-#define IS_THE_ONLY_NODE(_conn_node)\
-((_conn_node->conn_list.next == _conn_node->conn_list.prev)\
-        ? _gf_true : _gf_false)
-
-
+#define IS_THE_ONLY_NODE(_conn_node)                                           \
+    ((_conn_node->conn_list.next == _conn_node->conn_list.prev) ? _gf_true     \
+                                                                : _gf_false)
 
 /*Internal Function: Adds connection node to the end of
  * the db connection list.*/
 static int
-add_connection_node (gfdb_conn_node_t *_conn_node) {
-        int ret = -1;
-
-        GF_ASSERT (_conn_node);
-
-        /*Lock the list*/
-        ret = pthread_mutex_lock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_LOCK_LIST_FAILED, "Failed lock db connection "
-                        "list %s", strerror(ret));
-                ret = -1;
-                goto out;
-        }
-
-        if (db_conn_list == NULL) {
-                db_conn_list = _conn_node;
-        } else {
-                list_add_tail (&_conn_node->conn_list,
-                                &db_conn_list->conn_list);
-        }
-
-        /*unlock the list*/
-        ret = pthread_mutex_unlock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock db "
-                        "connection list %s", strerror(ret));
-                ret = -1;
-                goto out;
-                /*TODO What if the unlock fails.
-                * Will it lead to deadlock?
-                * Most of the gluster code
-                * no check for unlock or destroy of mutex!*/
-        }
-        ret = 0;
+add_connection_node(gfdb_conn_node_t *_conn_node)
+{
+    int ret = -1;
+
+    GF_ASSERT(_conn_node);
+
+    /*Lock the list*/
+    ret = pthread_mutex_lock(&db_conn_mutex);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_LOCK_LIST_FAILED,
+               "Failed lock db connection "
+               "list %s",
+               strerror(ret));
+        ret = -1;
+        goto out;
+    }
+
+    if (db_conn_list == NULL) {
+        db_conn_list = _conn_node;
+    } else {
+        list_add_tail(&_conn_node->conn_list, &db_conn_list->conn_list);
+    }
+
+    /*unlock the list*/
+    ret = pthread_mutex_unlock(&db_conn_mutex);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_UNLOCK_LIST_FAILED,
+               "Failed unlock db "
+               "connection list %s",
+               strerror(ret));
+        ret = -1;
+        goto out;
+        /*TODO What if the unlock fails.
+         * Will it lead to deadlock?
+         * Most of the gluster code
+         * no check for unlock or destroy of mutex!*/
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /*Internal Function:
  * Delete connection node from the list*/
 static int
-delete_conn_node (gfdb_conn_node_t *_conn_node)
+delete_conn_node(gfdb_conn_node_t *_conn_node)
 {
-        int ret = -1;
-
-        GF_ASSERT (_conn_node);
-
-        /*Lock of the list*/
-        ret = pthread_mutex_lock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret,
-                        LG_MSG_LOCK_LIST_FAILED, "Failed lock on db connection"
-                        " list %s", strerror(ret));
-                goto out;
+    int ret = -1;
+
+    GF_ASSERT(_conn_node);
+
+    /*Lock of the list*/
+    ret = pthread_mutex_lock(&db_conn_mutex);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_LOCK_LIST_FAILED,
+               "Failed lock on db connection"
+               " list %s",
+               strerror(ret));
+        goto out;
+    }
+
+    /*Remove the connection object from list*/
+    if (IS_THE_ONLY_NODE(_conn_node)) {
+        db_conn_list = NULL;
+        GF_FREE(_conn_node);
+    } else {
+        if (IS_FIRST_NODE(db_conn_list, _conn_node)) {
+            db_conn_list = list_entry(db_conn_list->conn_list.next,
+                                      gfdb_conn_node_t, conn_list);
         }
-
-        /*Remove the connection object from list*/
-        if (IS_THE_ONLY_NODE(_conn_node)) {
-                db_conn_list = NULL;
-                GF_FREE (_conn_node);
-        } else {
-                if (IS_FIRST_NODE(db_conn_list, _conn_node)) {
-                        db_conn_list = list_entry (db_conn_list->conn_list.next,
-                                                gfdb_conn_node_t, conn_list);
-                }
-                list_del(&_conn_node->conn_list);
-                GF_FREE (_conn_node);
-        }
-
-        /*Release the list lock*/
-        ret =  pthread_mutex_unlock (&db_conn_mutex);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_WARNING, ret,
-                        LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock on db "
-                        "connection list %s", strerror(ret));
-                /*TODO What if the unlock fails.
-                * Will it lead to deadlock?
-                * Most of the gluster code
-                * no check for unlock or destroy of mutex!*/
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+        list_del(&_conn_node->conn_list);
+        GF_FREE(_conn_node);
+    }
+
+    /*Release the list lock*/
+    ret = pthread_mutex_unlock(&db_conn_mutex);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_WARNING, ret, LG_MSG_UNLOCK_LIST_FAILED,
+               "Failed unlock on db "
+               "connection list %s",
+               strerror(ret));
+        /*TODO What if the unlock fails.
+         * Will it lead to deadlock?
+         * Most of the gluster code
+         * no check for unlock or destroy of mutex!*/
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /*Internal function: Used initialize/map db operation of
  * specified type of db plugin*/
 static int
-init_db_operations (gfdb_db_type_t       gfdb_db_type,
-                    gfdb_db_operations_t *gfdb_db_operations)
+init_db_operations(gfdb_db_type_t gfdb_db_type,
+                   gfdb_db_operations_t *gfdb_db_operations)
 {
+    int ret = -1;
 
-        int ret = -1;
+    GF_ASSERT(gfdb_db_operations);
 
-        GF_ASSERT (gfdb_db_operations);
-
-        /*Clear the gfdb_db_operations*/
-        gfdb_db_operations = memset(gfdb_db_operations, 0,
-                                        sizeof(*gfdb_db_operations));
-        switch (gfdb_db_type) {
+    /*Clear the gfdb_db_operations*/
+    gfdb_db_operations = memset(gfdb_db_operations, 0,
+                                sizeof(*gfdb_db_operations));
+    switch (gfdb_db_type) {
         case GFDB_SQLITE3:
-                gf_sqlite3_fill_db_operations (gfdb_db_operations);
-                ret = 0;
-                break;
+            gf_sqlite3_fill_db_operations(gfdb_db_operations);
+            ret = 0;
+            break;
         case GFDB_HYPERDEX:
         case GFDB_HASH_FILE_STORE:
         case GFDB_ROCKS_DB:
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_UNSUPPORTED_PLUGIN, "Plugin not supported");
-                break;
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_UNSUPPORTED_PLUGIN,
+                   "Plugin not supported");
+            break;
         case GFDB_INVALID_DB:
         case GFDB_DB_END:
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INVALID_DB_TYPE, "Invalid DB Type");
-                break;
-        }
-        return ret;
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INVALID_DB_TYPE,
+                   "Invalid DB Type");
+            break;
+    }
+    return ret;
 }
 
-
 /******************************************************************************
  *
  *                      LIBGFDB API Functions
  *
  * ****************************************************************************/
 
-
 /*Libgfdb API Function: Used to initialize a db connection
  *                      (Constructor function for db connection object)
  * Arguments:
@@ -225,85 +219,79 @@ init_db_operations (gfdb_db_type_t       gfdb_db_type,
  * Returns : if successful return the GFDB Connection node to the caller or
  *          NULL in case of failure*/
 gfdb_conn_node_t *
-init_db (dict_t *args, gfdb_db_type_t gfdb_db_type)
+init_db(dict_t *args, gfdb_db_type_t gfdb_db_type)
 {
-        int ret                                 = -1;
-        gfdb_conn_node_t *_conn_node            = NULL;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-
-        /*Create data base connection object*/
-        _conn_node = GF_CALLOC (1, sizeof(gfdb_conn_node_t),
-                                        gf_mt_db_conn_node_t);
-        if (!_conn_node) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Failed mem alloc for "
-                        "gfdb_conn_node_t");
-                goto alloc_failed;
-        }
-
-        /*Init the list component of db connection object*/
-        INIT_LIST_HEAD (&_conn_node->conn_list);
-
-
-        /*Add created connection node to the list*/
-        ret = add_connection_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_ADD_TO_LIST_FAILED, "Failed to add connection "
-                        "node to list");
-                goto _conn_failed;
-        }
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-
-        /*init the db ops object of db connection object*/
-        ret = init_db_operations(gfdb_db_type, db_operations_t);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INIT_DB_FAILED, "Failed initializing database "
-                        "operation failed.");
-                goto init_db_failed;
-        }
-
-        /*Calling the init_db_op of the respected db type*/
-        GF_ASSERT (db_operations_t->init_db_op);
-        ret = db_operations_t->init_db_op (args, &_conn_node->gfdb_connection.
-                                           gf_db_connection);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_INIT_DB_FAILED, "Failed initializing database");
-                goto init_db_failed;
-        }
-        _conn_node->gfdb_connection.gfdb_db_type = gfdb_db_type;
-        ret = 0;
-
-        return _conn_node;
-
-        /*****Error Handling********/
-        /* If init_db_operations or init_db of plugin failed delete
-        * conn node from the list.
-        * connection node will be free by delete_conn_node*/
+    int ret = -1;
+    gfdb_conn_node_t *_conn_node = NULL;
+    gfdb_db_operations_t *db_operations_t = NULL;
+
+    /*Create data base connection object*/
+    _conn_node = GF_CALLOC(1, sizeof(gfdb_conn_node_t), gf_mt_db_conn_node_t);
+    if (!_conn_node) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+               "Failed mem alloc for "
+               "gfdb_conn_node_t");
+        goto alloc_failed;
+    }
+
+    /*Init the list component of db connection object*/
+    INIT_LIST_HEAD(&_conn_node->conn_list);
+
+    /*Add created connection node to the list*/
+    ret = add_connection_node(_conn_node);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_ADD_TO_LIST_FAILED,
+               "Failed to add connection "
+               "node to list");
+        goto _conn_failed;
+    }
+
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+
+    /*init the db ops object of db connection object*/
+    ret = init_db_operations(gfdb_db_type, db_operations_t);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INIT_DB_FAILED,
+               "Failed initializing database "
+               "operation failed.");
+        goto init_db_failed;
+    }
+
+    /*Calling the init_db_op of the respected db type*/
+    GF_ASSERT(db_operations_t->init_db_op);
+    ret = db_operations_t->init_db_op(
+        args, &_conn_node->gfdb_connection.gf_db_connection);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INIT_DB_FAILED,
+               "Failed initializing database");
+        goto init_db_failed;
+    }
+    _conn_node->gfdb_connection.gfdb_db_type = gfdb_db_type;
+    ret = 0;
+
+    return _conn_node;
+
+    /*****Error Handling********/
+    /* If init_db_operations or init_db of plugin failed delete
+     * conn node from the list.
+     * connection node will be free by delete_conn_node*/
 init_db_failed:
-        ret = delete_conn_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting "
-                        "connection node from list");
-        }
-        return NULL;
-        /*if adding to the list failed free connection node*/
+    ret = delete_conn_node(_conn_node);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FROM_LIST_FAILED,
+               "Failed deleting "
+               "connection node from list");
+    }
+    return NULL;
+    /*if adding to the list failed free connection node*/
 _conn_failed:
-        GF_FREE (_conn_node);
-        /*if allocation failed*/
+    GF_FREE(_conn_node);
+    /*if allocation failed*/
 alloc_failed:
-        return NULL;
-        /*****Error Handling********/
+    return NULL;
+    /*****Error Handling********/
 }
 
-
-
-
-
 /*Libgfdb API Function: Used to terminate/de-initialize db connection
  *                      (Destructor function for db connection object)
  * Arguments:
@@ -311,43 +299,38 @@ alloc_failed:
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-fini_db (gfdb_conn_node_t *_conn_node)
+fini_db(gfdb_conn_node_t *_conn_node)
 {
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-
-        CHECK_CONN_NODE_GOTO (_conn_node, empty);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-
-        GF_ASSERT (db_operations_t->fini_db_op);
-
-        ret = db_operations_t->fini_db_op(&_conn_node->gfdb_connection.
-                                          gf_db_connection);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_CLOSE_CONNECTION_FAILED, "Failed close the db "
-                        "connection");
-                goto out;
-        }
-
-        ret = delete_conn_node (_conn_node);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting "
-                        "connection node from list");
-        }
+    int ret = -1;
+    gfdb_db_operations_t *db_operations_t = NULL;
+
+    CHECK_CONN_NODE_GOTO(_conn_node, empty);
+
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+
+    GF_ASSERT(db_operations_t->fini_db_op);
+
+    ret = db_operations_t->fini_db_op(
+        &_conn_node->gfdb_connection.gf_db_connection);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_CLOSE_CONNECTION_FAILED,
+               "Failed close the db "
+               "connection");
+        goto out;
+    }
+
+    ret = delete_conn_node(_conn_node);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FROM_LIST_FAILED,
+               "Failed deleting "
+               "connection node from list");
+    }
 empty:
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
-
-
-
 /*Libgfdb API Function: Used to insert/update records in the database
  *                      NOTE: In current gfdb_sqlite plugin we use that
  *                      same function to delete the record. Set the
@@ -364,36 +347,32 @@ out:
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-insert_record (gfdb_conn_node_t *_conn_node,
-               gfdb_db_record_t *gfdb_db_record)
+insert_record(gfdb_conn_node_t *_conn_node, gfdb_db_record_t *gfdb_db_record)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        CHECK_CONN_NODE(_conn_node);
+    CHECK_CONN_NODE(_conn_node);
 
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
-        if (db_operations_t->insert_record_op) {
-
-                ret = db_operations_t->insert_record_op (gf_db_connection,
-                                                         gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED, "Insert/Update"
-                                " operation failed");
-                }
+    if (db_operations_t->insert_record_op) {
+        ret = db_operations_t->insert_record_op(gf_db_connection,
+                                                gfdb_db_record);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE,
+                   _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors),
+                   0, LG_MSG_INSERT_OR_UPDATE_FAILED,
+                   "Insert/Update"
+                   " operation failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
-
 /*Libgfdb API Function: Used to delete record from the database
  *                      NOTE: In the current gfdb_sqlite3 plugin
  *                      implementation this function is dummy.
@@ -405,31 +384,28 @@ insert_record (gfdb_conn_node_t *_conn_node,
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-delete_record (gfdb_conn_node_t *_conn_node,
-               gfdb_db_record_t *gfdb_db_record)
+delete_record(gfdb_conn_node_t *_conn_node, gfdb_db_record_t *gfdb_db_record)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
+    CHECK_CONN_NODE(_conn_node);
 
-        if (db_operations_t->delete_record_op) {
-
-                ret = db_operations_t->delete_record_op (gf_db_connection,
-                                                         gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DELETE_FAILED, "Delete operation "
-                                "failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->delete_record_op) {
+        ret = db_operations_t->delete_record_op(gf_db_connection,
+                                                gfdb_db_record);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FAILED,
+                   "Delete operation "
+                   "failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 /*Libgfdb API Function: Compact the database.
@@ -441,38 +417,31 @@ delete_record (gfdb_conn_node_t *_conn_node,
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active,
-            gf_boolean_t _compact_mode_switched)
+compact_db(gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active,
+           gf_boolean_t _compact_mode_switched)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        CHECK_CONN_NODE(_conn_node);
+    CHECK_CONN_NODE(_conn_node);
 
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->compact_db_op) {
-
-                ret = db_operations_t->compact_db_op (gf_db_connection,
-                                                      _compact_active,
-                                                      _compact_mode_switched);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_COMPACT_FAILED, "Compaction operation "
-                                "failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->compact_db_op) {
+        ret = db_operations_t->compact_db_op(gf_db_connection, _compact_active,
+                                             _compact_mode_switched);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_COMPACT_FAILED,
+                   "Compaction operation "
+                   "failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
-
-
 /*Libgfdb API Function: Query all the records from the database
  * Arguments:
  *      _conn_node      : GFDB Connection node
@@ -484,37 +453,30 @@ compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active,
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-find_all (gfdb_conn_node_t      *_conn_node,
-          gf_query_callback_t   query_callback,
-          void                  *_query_cbk_args,
-          int                   query_limit)
+find_all(gfdb_conn_node_t *_conn_node, gf_query_callback_t query_callback,
+         void *_query_cbk_args, int query_limit)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_all_op) {
-                ret = db_operations_t->find_all_op (gf_db_connection,
-                                                    query_callback,
-                                                    _query_cbk_args,
-                                                    query_limit);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED, "Find all operation "
-                                "failed");
-                }
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        }
+    CHECK_CONN_NODE(_conn_node);
 
-        return ret;
-}
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->find_all_op) {
+        ret = db_operations_t->find_all_op(gf_db_connection, query_callback,
+                                           _query_cbk_args, query_limit);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Find all operation "
+                   "failed");
+        }
+    }
 
+    return ret;
+}
 
 /*Libgfdb API Function: Query records/files that have not changed/accessed
  *                      from a time in past to current time
@@ -529,35 +491,30 @@ find_all (gfdb_conn_node_t      *_conn_node,
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-find_unchanged_for_time(gfdb_conn_node_t        *_conn_node,
-                        gf_query_callback_t     query_callback,
-                        void                    *_query_cbk_args,
-                        gfdb_time_t             *for_time)
+find_unchanged_for_time(gfdb_conn_node_t *_conn_node,
+                        gf_query_callback_t query_callback,
+                        void *_query_cbk_args, gfdb_time_t *for_time)
 {
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations_t->find_unchanged_for_time_op) {
+    CHECK_CONN_NODE(_conn_node);
 
-                ret = db_operations_t->find_unchanged_for_time_op
-                                (gf_db_connection, query_callback,
-                                _query_cbk_args, for_time);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED, "Find unchanged "
-                                "operation failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->find_unchanged_for_time_op) {
+        ret = db_operations_t->find_unchanged_for_time_op(
+            gf_db_connection, query_callback, _query_cbk_args, for_time);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Find unchanged "
+                   "operation failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 /*Libgfdb API Function: Query records/files that have changed/accessed from a
@@ -573,36 +530,29 @@ find_unchanged_for_time(gfdb_conn_node_t        *_conn_node,
  * Returns : if successful return 0 or
  *          -ve value in case of failure*/
 int
-find_recently_changed_files(gfdb_conn_node_t    *_conn_node,
+find_recently_changed_files(gfdb_conn_node_t *_conn_node,
                             gf_query_callback_t query_callback,
-                            void                *_query_cbk_args,
-                            gfdb_time_t         *from_time)
+                            void *_query_cbk_args, gfdb_time_t *from_time)
 {
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
+    CHECK_CONN_NODE(_conn_node);
 
-        if (db_operations_t->find_recently_changed_files_op) {
-
-                ret =  db_operations_t->find_recently_changed_files_op (
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, from_time);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find changed operation failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->find_recently_changed_files_op) {
+        ret = db_operations_t->find_recently_changed_files_op(
+            gf_db_connection, query_callback, _query_cbk_args, from_time);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Find changed operation failed");
         }
+    }
 
-        return ret;
-
+    return ret;
 }
 
 /*Libgfdb API Function: Query records/files that have not changed/accessed
@@ -624,38 +574,31 @@ find_recently_changed_files(gfdb_conn_node_t    *_conn_node,
  *          -ve value in case of failure*/
 int
 find_unchanged_for_time_freq(gfdb_conn_node_t *_conn_node,
-                                        gf_query_callback_t query_callback,
-                                        void *_query_cbk_args,
-                                        gfdb_time_t *for_time,
-                                        int write_freq_thresold,
-                                        int read_freq_thresold,
-                                        gf_boolean_t _clear_counters)
+                             gf_query_callback_t query_callback,
+                             void *_query_cbk_args, gfdb_time_t *for_time,
+                             int write_freq_thresold, int read_freq_thresold,
+                             gf_boolean_t _clear_counters)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
+    CHECK_CONN_NODE(_conn_node);
 
-        if (db_operations_t->find_unchanged_for_time_freq_op) {
-
-                ret = db_operations_t->find_unchanged_for_time_freq_op(
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, for_time,
-                                write_freq_thresold, read_freq_thresold,
-                                _clear_counters);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find unchanged with freq operation failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->find_unchanged_for_time_freq_op) {
+        ret = db_operations_t->find_unchanged_for_time_freq_op(
+            gf_db_connection, query_callback, _query_cbk_args, for_time,
+            write_freq_thresold, read_freq_thresold, _clear_counters);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Find unchanged with freq operation failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 /*Libgfdb API Function: Query records/files that have changed/accessed from a
@@ -677,44 +620,34 @@ find_unchanged_for_time_freq(gfdb_conn_node_t *_conn_node,
  *          -ve value in case of failure*/
 int
 find_recently_changed_files_freq(gfdb_conn_node_t *_conn_node,
-                                gf_query_callback_t query_callback,
-                                void *_query_cbk_args,
-                                gfdb_time_t *from_time,
-                                int write_freq_thresold,
-                                int read_freq_thresold,
-                                gf_boolean_t _clear_counters)
+                                 gf_query_callback_t query_callback,
+                                 void *_query_cbk_args, gfdb_time_t *from_time,
+                                 int write_freq_thresold,
+                                 int read_freq_thresold,
+                                 gf_boolean_t _clear_counters)
 {
+    int ret = 0;
+    gfdb_db_operations_t *db_operations_t = NULL;
+    void *gf_db_connection = NULL;
 
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations_t   = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(_conn_node);
-
-        db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
+    CHECK_CONN_NODE(_conn_node);
 
-        if (db_operations_t->find_recently_changed_files_freq_op) {
-
-                ret =  db_operations_t->find_recently_changed_files_freq_op(
-                                gf_db_connection, query_callback,
-                                _query_cbk_args, from_time,
-                                write_freq_thresold, read_freq_thresold,
-                                _clear_counters);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Find changed with freq operation failed");
-                }
+    db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = _conn_node->gfdb_connection.gf_db_connection;
 
+    if (db_operations_t->find_recently_changed_files_freq_op) {
+        ret = db_operations_t->find_recently_changed_files_freq_op(
+            gf_db_connection, query_callback, _query_cbk_args, from_time,
+            write_freq_thresold, read_freq_thresold, _clear_counters);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Find changed with freq operation failed");
         }
+    }
 
-        return ret;
-
+    return ret;
 }
 
-
-
 /*Libgfdb API Function: Clear the heat for all the files
  *
  *  Arguments:
@@ -725,30 +658,29 @@ find_recently_changed_files_freq(gfdb_conn_node_t *_conn_node,
  **/
 
 int
-clear_files_heat (gfdb_conn_node_t *conn_node)
+clear_files_heat(gfdb_conn_node_t *conn_node)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->clear_files_heat_op) {
-                ret =  db_operations->clear_files_heat_op (gf_db_connection);
-                if (ret) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED,
-                                "Clear files heat operation failed");
-                }
+    int ret = 0;
+    gfdb_db_operations_t *db_operations = NULL;
+    void *gf_db_connection = NULL;
+
+    CHECK_CONN_NODE(conn_node);
+
+    db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
+
+    if (db_operations->clear_files_heat_op) {
+        ret = db_operations->clear_files_heat_op(gf_db_connection);
+        if (ret) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0,
+                   LG_MSG_INSERT_OR_UPDATE_FAILED,
+                   "Clear files heat operation failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 /* Libgfdb API Function: Function to extract version of the db
  * Input:
  * gfdb_conn_node_t *conn_node        : GFDB Connection node
@@ -761,122 +693,111 @@ clear_files_heat (gfdb_conn_node_t *conn_node)
  *      On failure return -1
  * */
 int
-get_db_version (gfdb_conn_node_t *conn_node, char **version)
+get_db_version(gfdb_conn_node_t *conn_node, char **version)
 {
-        int ret                                 = 0;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->get_db_version) {
-                ret =  db_operations->get_db_version (gf_db_connection,
-                                                      version);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Get version failed");
-                }
+    int ret = 0;
+    gfdb_db_operations_t *db_operations = NULL;
+    void *gf_db_connection = NULL;
+
+    CHECK_CONN_NODE(conn_node);
+
+    db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
+
+    if (db_operations->get_db_version) {
+        ret = db_operations->get_db_version(gf_db_connection, version);
+        if (ret < 0) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Get version failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-get_db_params (gfdb_conn_node_t *conn_node, char *param_key,
-                char **param_value)
+get_db_params(gfdb_conn_node_t *conn_node, char *param_key, char **param_value)
 {
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->get_db_params) {
-                ret =  db_operations->get_db_params (gf_db_connection,
-                                                     param_key,
-                                                     param_value);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_FIND_OP_FAILED,
-                                "Get setting failed");
-                }
+    int ret = -1;
+    gfdb_db_operations_t *db_operations = NULL;
+    void *gf_db_connection = NULL;
+
+    CHECK_CONN_NODE(conn_node);
+
+    db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
+
+    if (db_operations->get_db_params) {
+        ret = db_operations->get_db_params(gf_db_connection, param_key,
+                                           param_value);
+        if (ret < 0) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED,
+                   "Get setting failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-set_db_params (gfdb_conn_node_t *conn_node, char *param_key,
-                char *param_value)
+set_db_params(gfdb_conn_node_t *conn_node, char *param_key, char *param_value)
 {
-        int ret                                 = -1;
-        gfdb_db_operations_t *db_operations     = NULL;
-        void *gf_db_connection                  = NULL;
-
-        CHECK_CONN_NODE(conn_node);
-
-        db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
-        gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
-
-        if (db_operations->set_db_params) {
-                ret =  db_operations->set_db_params (gf_db_connection,
-                                                     param_key,
-                                                     param_value);
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_INSERT_OR_UPDATE_FAILED,
-                                "Failed to set database setting");
-                }
+    int ret = -1;
+    gfdb_db_operations_t *db_operations = NULL;
+    void *gf_db_connection = NULL;
+
+    CHECK_CONN_NODE(conn_node);
+
+    db_operations = &conn_node->gfdb_connection.gfdb_db_operations;
+    gf_db_connection = conn_node->gfdb_connection.gf_db_connection;
+
+    if (db_operations->set_db_params) {
+        ret = db_operations->set_db_params(gf_db_connection, param_key,
+                                           param_value);
+        if (ret < 0) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0,
+                   LG_MSG_INSERT_OR_UPDATE_FAILED,
+                   "Failed to set database setting");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
-
-static const
-char *get_db_path_key()
+static const char *
+get_db_path_key()
 {
-        return GFDB_SQL_PARAM_DBPATH;
+    return GFDB_SQL_PARAM_DBPATH;
 }
 
-void get_gfdb_methods (gfdb_methods_t *methods)
+void
+get_gfdb_methods(gfdb_methods_t *methods)
 {
-        methods->init_db = init_db;
-        methods->fini_db = fini_db;
-        methods->find_all = find_all;
-        methods->find_unchanged_for_time = find_unchanged_for_time;
-        methods->find_recently_changed_files = find_recently_changed_files;
-        methods->find_unchanged_for_time_freq = find_unchanged_for_time_freq;
-        methods->find_recently_changed_files_freq =
-                                               find_recently_changed_files_freq;
-        methods->clear_files_heat = clear_files_heat;
-        methods->get_db_version = get_db_version;
-        methods->get_db_params = get_db_params;
-        methods->set_db_params = set_db_params;
-        methods->get_db_path_key = get_db_path_key;
-
-        /* Query Record related functions */
-        methods->gfdb_query_record_new = gfdb_query_record_new;
-        methods->gfdb_query_record_free = gfdb_query_record_free;
-        methods->gfdb_add_link_to_query_record = gfdb_add_link_to_query_record;
-        methods->gfdb_write_query_record = gfdb_write_query_record;
-        methods->gfdb_read_query_record = gfdb_read_query_record;
-
-        /* Link info related functions */
-        methods->gfdb_link_info_new = gfdb_link_info_new;
-        methods->gfdb_link_info_free = gfdb_link_info_free;
-
-        /* Compaction related functions */
-        methods->compact_db = compact_db;
+    methods->init_db = init_db;
+    methods->fini_db = fini_db;
+    methods->find_all = find_all;
+    methods->find_unchanged_for_time = find_unchanged_for_time;
+    methods->find_recently_changed_files = find_recently_changed_files;
+    methods->find_unchanged_for_time_freq = find_unchanged_for_time_freq;
+    methods
+        ->find_recently_changed_files_freq = find_recently_changed_files_freq;
+    methods->clear_files_heat = clear_files_heat;
+    methods->get_db_version = get_db_version;
+    methods->get_db_params = get_db_params;
+    methods->set_db_params = set_db_params;
+    methods->get_db_path_key = get_db_path_key;
+
+    /* Query Record related functions */
+    methods->gfdb_query_record_new = gfdb_query_record_new;
+    methods->gfdb_query_record_free = gfdb_query_record_free;
+    methods->gfdb_add_link_to_query_record = gfdb_add_link_to_query_record;
+    methods->gfdb_write_query_record = gfdb_write_query_record;
+    methods->gfdb_read_query_record = gfdb_read_query_record;
+
+    /* Link info related functions */
+    methods->gfdb_link_info_new = gfdb_link_info_new;
+    methods->gfdb_link_info_free = gfdb_link_info_free;
+
+    /* Compaction related functions */
+    methods->compact_db = compact_db;
 }
-
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.c b/libglusterfs/src/gfdb/gfdb_data_store_helper.c
index 39a97ff73d9..fb01a6c699b 100644
--- a/libglusterfs/src/gfdb/gfdb_data_store_helper.c
+++ b/libglusterfs/src/gfdb/gfdb_data_store_helper.c
@@ -9,151 +9,139 @@
  * ****************************************************************************/
 
 /*Create a single link info structure*/
-gfdb_link_info_t*
-gfdb_link_info_new ()
+gfdb_link_info_t *
+gfdb_link_info_new()
 {
-        gfdb_link_info_t *link_info = NULL;
+    gfdb_link_info_t *link_info = NULL;
 
-        link_info = GF_CALLOC (1, sizeof(gfdb_link_info_t),
-                                        gf_mt_gfdb_link_info_t);
-        if (!link_info) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Memory allocation failed for "
-                        "link_info ");
-                goto out;
-        }
+    link_info = GF_CALLOC(1, sizeof(gfdb_link_info_t), gf_mt_gfdb_link_info_t);
+    if (!link_info) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+               "Memory allocation failed for "
+               "link_info ");
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&link_info->list);
+    INIT_LIST_HEAD(&link_info->list);
 
 out:
 
-        return link_info;
+    return link_info;
 }
 
 /*Destroy a link info structure*/
 void
 gfdb_link_info_free(gfdb_link_info_t *link_info)
 {
-        GF_FREE (link_info);
+    GF_FREE(link_info);
 }
 
-
 /*Function to create the query_record*/
 gfdb_query_record_t *
 gfdb_query_record_new()
 {
-        int ret = -1;
-        gfdb_query_record_t *query_record = NULL;
-
-        query_record = GF_CALLOC (1, sizeof(gfdb_query_record_t),
-                                        gf_mt_gfdb_query_record_t);
-        if (!query_record) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Memory allocation failed for "
-                        "query_record ");
-                goto out;
-        }
+    int ret = -1;
+    gfdb_query_record_t *query_record = NULL;
 
-        INIT_LIST_HEAD (&query_record->link_list);
+    query_record = GF_CALLOC(1, sizeof(gfdb_query_record_t),
+                             gf_mt_gfdb_query_record_t);
+    if (!query_record) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+               "Memory allocation failed for "
+               "query_record ");
+        goto out;
+    }
 
-        ret = 0;
+    INIT_LIST_HEAD(&query_record->link_list);
+
+    ret = 0;
 out:
-        if (ret == -1) {
-                GF_FREE (query_record);
-        }
-        return query_record;
+    if (ret == -1) {
+        GF_FREE(query_record);
+    }
+    return query_record;
 }
 
-
 /*Function to delete a single linkinfo from list*/
 static void
-gfdb_delete_linkinfo_from_list (gfdb_link_info_t **link_info)
+gfdb_delete_linkinfo_from_list(gfdb_link_info_t **link_info)
 {
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, link_info, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, *link_info, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, link_info, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, *link_info, out);
 
-        /*Remove hard link from list*/
-        list_del(&(*link_info)->list);
-        gfdb_link_info_free (*link_info);
-        link_info = NULL;
+    /*Remove hard link from list*/
+    list_del(&(*link_info)->list);
+    gfdb_link_info_free(*link_info);
+    link_info = NULL;
 out:
-        return;
+    return;
 }
 
-
 /*Function to destroy link_info list*/
 void
-gfdb_free_link_info_list (gfdb_query_record_t *query_record)
+gfdb_free_link_info_list(gfdb_query_record_t *query_record)
 {
-        gfdb_link_info_t        *link_info = NULL;
-        gfdb_link_info_t        *temp = NULL;
+    gfdb_link_info_t *link_info = NULL;
+    gfdb_link_info_t *temp = NULL;
 
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
 
-        list_for_each_entry_safe(link_info, temp,
-                        &query_record->link_list, list)
-        {
-                gfdb_delete_linkinfo_from_list (&link_info);
-                link_info = NULL;
-        }
+    list_for_each_entry_safe(link_info, temp, &query_record->link_list, list)
+    {
+        gfdb_delete_linkinfo_from_list(&link_info);
+        link_info = NULL;
+    }
 
 out:
-        return;
+    return;
 }
 
-
-
 /* Function to add linkinfo to the query record */
 int
-gfdb_add_link_to_query_record (gfdb_query_record_t      *query_record,
-                           uuid_t                   pgfid,
-                           char               *base_name)
+gfdb_add_link_to_query_record(gfdb_query_record_t *query_record, uuid_t pgfid,
+                              char *base_name)
 {
-        int ret                                 = -1;
-        gfdb_link_info_t *link_info             = NULL;
-        int base_name_len                       = 0;
+    int ret = -1;
+    gfdb_link_info_t *link_info = NULL;
+    int base_name_len = 0;
 
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, pgfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, base_name, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, pgfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, base_name, out);
 
-        link_info = gfdb_link_info_new ();
-        if (!link_info) {
-                goto out;
-        }
+    link_info = gfdb_link_info_new();
+    if (!link_info) {
+        goto out;
+    }
 
-        gf_uuid_copy (link_info->pargfid, pgfid);
-        base_name_len = strlen (base_name);
-        memcpy (link_info->file_name, base_name, base_name_len);
-        link_info->file_name[base_name_len] = '\0';
+    gf_uuid_copy(link_info->pargfid, pgfid);
+    base_name_len = strlen(base_name);
+    memcpy(link_info->file_name, base_name, base_name_len);
+    link_info->file_name[base_name_len] = '\0';
 
-        list_add_tail (&link_info->list,
-                        &query_record->link_list);
+    list_add_tail(&link_info->list, &query_record->link_list);
 
-        query_record->link_count++;
+    query_record->link_count++;
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                gfdb_link_info_free (link_info);
-                link_info = NULL;
-        }
-        return ret;
+    if (ret) {
+        gfdb_link_info_free(link_info);
+        link_info = NULL;
+    }
+    return ret;
 }
 
-
-
 /*Function to destroy query record*/
 void
 gfdb_query_record_free(gfdb_query_record_t *query_record)
 {
-        if (query_record) {
-                gfdb_free_link_info_list (query_record);
-                GF_FREE (query_record);
-        }
+    if (query_record) {
+        gfdb_free_link_info_list(query_record);
+        GF_FREE(query_record);
+    }
 }
 
-
 /******************************************************************************
                 SERIALIZATION/DE-SERIALIZATION OF QUERY RECORD
 *******************************************************************************/
@@ -197,40 +185,39 @@ gfdb_query_record_free(gfdb_query_record_t *query_record)
  * ****************************************************************************/
 
 #define GFDB_QUERY_RECORD_FOOTER 0xBAADF00D
-#define UUID_LEN                 16
+#define UUID_LEN 16
 
 /*Function to get the potential length of the serialized buffer*/
 static int32_t
-gfdb_query_record_serialized_length (gfdb_query_record_t *query_record)
+gfdb_query_record_serialized_length(gfdb_query_record_t *query_record)
 {
-        int32_t len                         = -1;
-        gfdb_link_info_t *link_info     = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
+    int32_t len = -1;
+    gfdb_link_info_t *link_info = NULL;
 
-        /* Length of GFID */
-        len = UUID_LEN;
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
 
-        /* length of number of links*/
-        len += sizeof (int32_t);
+    /* Length of GFID */
+    len = UUID_LEN;
 
-        list_for_each_entry (link_info, &query_record->link_list, list) {
+    /* length of number of links*/
+    len += sizeof(int32_t);
 
-                /* length of PFID */
-                len += UUID_LEN;
+    list_for_each_entry(link_info, &query_record->link_list, list)
+    {
+        /* length of PFID */
+        len += UUID_LEN;
 
-                /* Add size of base name length*/
-                len += sizeof (int32_t);
+        /* Add size of base name length*/
+        len += sizeof(int32_t);
 
-                /* Length of base_name */
-                len += strlen (link_info->file_name);
-
-        }
+        /* Length of base_name */
+        len += strlen(link_info->file_name);
+    }
 
-        /* length of footer */
-        len += sizeof (int32_t);
+    /* length of footer */
+    len += sizeof(int32_t);
 out:
-        return len;
+    return len;
 }
 
 /* Function for serializing query record.
@@ -259,210 +246,200 @@ out:
  *
  * */
 static int
-gfdb_query_record_serialize (gfdb_query_record_t *query_record,
-                             char **in_buffer)
+gfdb_query_record_serialize(gfdb_query_record_t *query_record, char **in_buffer)
 {
-        gfdb_link_info_t *link_info     = NULL;
-        int              count          = -1;
-        int              base_name_len  = 0;
-        int              buffer_length  = 0;
-        int              footer         = GFDB_QUERY_RECORD_FOOTER;
-        char             *buffer        = NULL;
-        char             *ret_buffer    = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE,
-                             (query_record->link_count > 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out);
-
-
-        /* Calculate the total length of the serialized buffer */
-        buffer_length = gfdb_query_record_serialized_length (query_record);
-        if (buffer_length <= 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to calculate the length of "
-                        "serialized buffer");
-                goto out;
-        }
-
-        /* Allocate memory to the serialized buffer */
-        ret_buffer = GF_CALLOC (1, buffer_length,  gf_common_mt_char);
-        if (!ret_buffer) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Memory allocation failed for "
-                        "serialized buffer.");
-                goto out;
-        }
-
-        buffer = ret_buffer;
-
-        count = 0;
-
-        /* Copying the GFID */
-        memcpy (buffer, query_record->gfid, UUID_LEN);
+    gfdb_link_info_t *link_info = NULL;
+    int count = -1;
+    int base_name_len = 0;
+    int buffer_length = 0;
+    int footer = GFDB_QUERY_RECORD_FOOTER;
+    char *buffer = NULL;
+    char *ret_buffer = NULL;
+
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (query_record->link_count > 0), out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, in_buffer, out);
+
+    /* Calculate the total length of the serialized buffer */
+    buffer_length = gfdb_query_record_serialized_length(query_record);
+    if (buffer_length <= 0) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to calculate the length of "
+               "serialized buffer");
+        goto out;
+    }
+
+    /* Allocate memory to the serialized buffer */
+    ret_buffer = GF_CALLOC(1, buffer_length, gf_common_mt_char);
+    if (!ret_buffer) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Memory allocation failed for "
+               "serialized buffer.");
+        goto out;
+    }
+
+    buffer = ret_buffer;
+
+    count = 0;
+
+    /* Copying the GFID */
+    memcpy(buffer, query_record->gfid, UUID_LEN);
+    buffer += UUID_LEN;
+    count += UUID_LEN;
+
+    /* Copying the number of links */
+    memcpy(buffer, &query_record->link_count, sizeof(int32_t));
+    buffer += sizeof(int32_t);
+    count += sizeof(int32_t);
+
+    list_for_each_entry(link_info, &query_record->link_list, list)
+    {
+        /* Copying the PFID */
+        memcpy(buffer, link_info->pargfid, UUID_LEN);
         buffer += UUID_LEN;
         count += UUID_LEN;
 
-        /* Copying the number of links */
-        memcpy (buffer, &query_record->link_count, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
-
-        list_for_each_entry (link_info, &query_record->link_list, list) {
-
-                /* Copying the PFID */
-                memcpy(buffer, link_info->pargfid, UUID_LEN);
-                buffer += UUID_LEN;
-                count += UUID_LEN;
-
-                /* Copying base name length*/
-                base_name_len = strlen (link_info->file_name);
-                memcpy (buffer, &base_name_len, sizeof (int32_t));
-                buffer += sizeof (int32_t);
-                count += sizeof (int32_t);
+        /* Copying base name length*/
+        base_name_len = strlen(link_info->file_name);
+        memcpy(buffer, &base_name_len, sizeof(int32_t));
+        buffer += sizeof(int32_t);
+        count += sizeof(int32_t);
 
-                /* Length of base_name */
-                memcpy(buffer, link_info->file_name, base_name_len);
-                buffer += base_name_len;
-                count += base_name_len;
+        /* Length of base_name */
+        memcpy(buffer, link_info->file_name, base_name_len);
+        buffer += base_name_len;
+        count += base_name_len;
+    }
 
-        }
-
-        /* Copying the Footer of the record */
-        memcpy (buffer, &footer, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
+    /* Copying the Footer of the record */
+    memcpy(buffer, &footer, sizeof(int32_t));
+    buffer += sizeof(int32_t);
+    count += sizeof(int32_t);
 
 out:
-        if (count < 0) {
-                GF_FREE (ret_buffer);
-                ret_buffer = NULL;
-        }
-        *in_buffer = ret_buffer;
-        return count;
+    if (count < 0) {
+        GF_FREE(ret_buffer);
+        ret_buffer = NULL;
+    }
+    *in_buffer = ret_buffer;
+    return count;
 }
 
 static gf_boolean_t
-is_serialized_buffer_valid (char *in_buffer, int buffer_length) {
-        gf_boolean_t    ret        = _gf_false;
-        int             footer     = 0;
-
-        /* Read the footer */
-        in_buffer += (buffer_length - sizeof (int32_t));
-        memcpy (&footer, in_buffer, sizeof (int32_t));
-
-        /*
-         * if the footer is not GFDB_QUERY_RECORD_FOOTER
-         * then the serialized record is invalid
-         *
-         * */
-        if (footer != GFDB_QUERY_RECORD_FOOTER) {
-                goto out;
-        }
-
-        ret = _gf_true;
+is_serialized_buffer_valid(char *in_buffer, int buffer_length)
+{
+    gf_boolean_t ret = _gf_false;
+    int footer = 0;
+
+    /* Read the footer */
+    in_buffer += (buffer_length - sizeof(int32_t));
+    memcpy(&footer, in_buffer, sizeof(int32_t));
+
+    /*
+     * if the footer is not GFDB_QUERY_RECORD_FOOTER
+     * then the serialized record is invalid
+     *
+     * */
+    if (footer != GFDB_QUERY_RECORD_FOOTER) {
+        goto out;
+    }
+
+    ret = _gf_true;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-gfdb_query_record_deserialize (char *in_buffer,
-                               int buffer_length,
-                               gfdb_query_record_t **query_record)
+gfdb_query_record_deserialize(char *in_buffer, int buffer_length,
+                              gfdb_query_record_t **query_record)
 {
-        int ret                                 = -1;
-        char *buffer                            = NULL;
-        int i                                   = 0;
-        gfdb_link_info_t *link_info             = NULL;
-        int count                               = 0;
-        int base_name_len                       = 0;
-        gfdb_query_record_t *ret_qrecord        = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (buffer_length > 0), out);
-
-        if (!is_serialized_buffer_valid (in_buffer, buffer_length)) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Invalid serialized query record");
-                goto out;
+    int ret = -1;
+    char *buffer = NULL;
+    int i = 0;
+    gfdb_link_info_t *link_info = NULL;
+    int count = 0;
+    int base_name_len = 0;
+    gfdb_query_record_t *ret_qrecord = NULL;
+
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, in_buffer, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (buffer_length > 0), out);
+
+    if (!is_serialized_buffer_valid(in_buffer, buffer_length)) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Invalid serialized query record");
+        goto out;
+    }
+
+    buffer = in_buffer;
+
+    ret_qrecord = gfdb_query_record_new();
+    if (!ret_qrecord) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to allocate space to "
+               "gfdb_query_record_t");
+        goto out;
+    }
+
+    /* READ GFID */
+    memcpy((ret_qrecord)->gfid, buffer, UUID_LEN);
+    buffer += UUID_LEN;
+    count += UUID_LEN;
+
+    /* Read the number of link */
+    memcpy(&(ret_qrecord->link_count), buffer, sizeof(int32_t));
+    buffer += sizeof(int32_t);
+    count += sizeof(int32_t);
+
+    /* Read all the links */
+    for (i = 0; i < ret_qrecord->link_count; i++) {
+        if (count >= buffer_length) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+                   "Invalid serialized "
+                   "query record");
+            ret = -1;
+            goto out;
         }
 
-        buffer = in_buffer;
-
-        ret_qrecord = gfdb_query_record_new ();
-        if (!ret_qrecord) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to allocate space to "
-                        "gfdb_query_record_t");
-                goto out;
+        link_info = gfdb_link_info_new();
+        if (!link_info) {
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+                   "Failed to create link_info");
+            goto out;
         }
 
-        /* READ GFID */
-        memcpy ((ret_qrecord)->gfid, buffer, UUID_LEN);
+        /* READ PGFID */
+        memcpy(link_info->pargfid, buffer, UUID_LEN);
         buffer += UUID_LEN;
         count += UUID_LEN;
 
-        /* Read the number of link */
-        memcpy (&(ret_qrecord->link_count), buffer, sizeof (int32_t));
-        buffer += sizeof (int32_t);
-        count += sizeof (int32_t);
-
-        /* Read all the links */
-        for (i = 0; i < ret_qrecord->link_count; i++) {
-                if (count >= buffer_length) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Invalid serialized "
-                                "query record");
-                        ret = -1;
-                        goto out;
-                }
-
-                link_info = gfdb_link_info_new ();
-                if (!link_info) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed to create link_info");
-                        goto out;
-                }
-
-                /* READ PGFID */
-                memcpy (link_info->pargfid, buffer, UUID_LEN);
-                buffer += UUID_LEN;
-                count += UUID_LEN;
-
-                /* Read base name length */
-                memcpy (&base_name_len, buffer, sizeof (int32_t));
-                buffer += sizeof (int32_t);
-                count += sizeof (int32_t);
-
-                /* READ basename */
-                memcpy (link_info->file_name, buffer, base_name_len);
-                buffer += base_name_len;
-                count += base_name_len;
-                link_info->file_name[base_name_len] = '\0';
-
-                /* Add link_info to the list */
-                list_add_tail (&link_info->list,
-                               &(ret_qrecord->link_list));
-
-                /* Resetting link_info */
-                link_info = NULL;
-        }
-
-        ret = 0;
-out:
-        if (ret) {
-                gfdb_query_record_free (ret_qrecord);
-                ret_qrecord = NULL;
-        }
-        *query_record = ret_qrecord;
-        return ret;
-}
+        /* Read base name length */
+        memcpy(&base_name_len, buffer, sizeof(int32_t));
+        buffer += sizeof(int32_t);
+        count += sizeof(int32_t);
 
+        /* READ basename */
+        memcpy(link_info->file_name, buffer, base_name_len);
+        buffer += base_name_len;
+        count += base_name_len;
+        link_info->file_name[base_name_len] = '\0';
 
+        /* Add link_info to the list */
+        list_add_tail(&link_info->list, &(ret_qrecord->link_list));
 
+        /* Resetting link_info */
+        link_info = NULL;
+    }
 
+    ret = 0;
+out:
+    if (ret) {
+        gfdb_query_record_free(ret_qrecord);
+        ret_qrecord = NULL;
+    }
+    *query_record = ret_qrecord;
+    return ret;
+}
 
 /* Function to write query record to file
  *
@@ -477,57 +454,54 @@ out:
  *
  * */
 int
-gfdb_write_query_record (int fd,
-                        gfdb_query_record_t *query_record)
+gfdb_write_query_record(int fd, gfdb_query_record_t *query_record)
 {
-        int ret                 = -1;
-        int buffer_len          = 0;
-        char *buffer            = NULL;
-        int write_len           = 0;
-        char *write_buffer      = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-        buffer_len = gfdb_query_record_serialize (query_record, &buffer);
-        if (buffer_len < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to serialize query record");
-                goto out;
-        }
-
-        /* Serialize the buffer length and write to file */
-        ret = write (fd, &buffer_len, sizeof (int32_t));
+    int ret = -1;
+    int buffer_len = 0;
+    char *buffer = NULL;
+    int write_len = 0;
+    char *write_buffer = NULL;
+
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (fd >= 0), out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
+
+    buffer_len = gfdb_query_record_serialize(query_record, &buffer);
+    if (buffer_len < 0) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to serialize query record");
+        goto out;
+    }
+
+    /* Serialize the buffer length and write to file */
+    ret = write(fd, &buffer_len, sizeof(int32_t));
+    if (ret < 0) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to write buffer length"
+               " to file");
+        goto out;
+    }
+
+    /* Write the serialized query record to file */
+    write_len = buffer_len;
+    write_buffer = buffer;
+    while ((ret = write(fd, write_buffer, write_len)) < write_len) {
         if (ret < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed to write buffer length"
-                                " to file");
-                goto out;
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, errno, LG_MSG_DB_ERROR,
+                   "Failed to write serialized "
+                   "query record to file");
+            goto out;
         }
 
-        /* Write the serialized query record to file */
-        write_len = buffer_len;
-        write_buffer = buffer;
-        while ((ret = write (fd, write_buffer, write_len)) <  write_len) {
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno,
-                                LG_MSG_DB_ERROR, "Failed to write serialized "
-                                "query record to file");
-                        goto out;
-                }
-
-                write_buffer += ret;
-                write_len -= ret;
-        }
+        write_buffer += ret;
+        write_len -= ret;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (buffer);
-        return ret;
+    GF_FREE(buffer);
+    return ret;
 }
 
-
-
 /* Function to read query record from file.
  * Allocates memory to query record and
  * returns length of serialized query record when successful
@@ -535,86 +509,81 @@ out:
  * Return 0 when reached EOF.
  * */
 int
-gfdb_read_query_record (int fd,
-                        gfdb_query_record_t **query_record)
+gfdb_read_query_record(int fd, gfdb_query_record_t **query_record)
 {
-        int ret                 = -1;
-        int buffer_len          = 0;
-        int read_len            = 0;
-        char *buffer            = NULL;
-        char *read_buffer       = NULL;
-
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out);
-        GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out);
-
-
-        /* Read serialized query record length from the file*/
-        ret = sys_read (fd, &buffer_len, sizeof (int32_t));
+    int ret = -1;
+    int buffer_len = 0;
+    int read_len = 0;
+    char *buffer = NULL;
+    char *read_buffer = NULL;
+
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (fd >= 0), out);
+    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
+
+    /* Read serialized query record length from the file*/
+    ret = sys_read(fd, &buffer_len, sizeof(int32_t));
+    if (ret < 0) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed reading buffer length"
+               " from file");
+        goto out;
+    }
+    /* EOF */
+    else if (ret == 0) {
+        ret = 0;
+        goto out;
+    }
+
+    /* Assumed sane range is 1B - 10MB */
+    if ((buffer_len <= 0) || (buffer_len > (10 * 1024 * 1024))) {
+        ret = -1;
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "buffer length range is out of bound %d", buffer_len);
+        goto out;
+    }
+
+    /* Allocating memory to the serialization buffer */
+    buffer = GF_CALLOC(1, buffer_len, gf_common_mt_char);
+    if (!buffer) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to allocate space to "
+               "serialized buffer");
+        goto out;
+    }
+
+    /* Read the serialized query record from file */
+    read_len = buffer_len;
+    read_buffer = buffer;
+    while ((ret = sys_read(fd, read_buffer, read_len)) < read_len) {
+        /*Any error */
         if (ret < 0) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Failed reading buffer length"
-                                " from file");
-                goto out;
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, errno, LG_MSG_DB_ERROR,
+                   "Failed to read serialized "
+                   "query record from file");
+            goto out;
         }
         /* EOF */
         else if (ret == 0) {
-                ret = 0;
-                goto out;
+            gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+                   "Invalid query record or "
+                   "corrupted query file");
+            ret = -1;
+            goto out;
         }
 
-        /* Assumed sane range is 1B - 10MB */
-        if ((buffer_len <= 0) || (buffer_len > (10 * 1024 * 1024))) {
-                ret = -1;
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
-                        "buffer length range is out of bound %d", buffer_len);
-                goto out;
-        }
-
-        /* Allocating memory to the serialization buffer */
-        buffer = GF_CALLOC (1, buffer_len,  gf_common_mt_char);
-        if (!buffer) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to allocate space to "
-                        "serialized buffer");
-                goto out;
-        }
+        read_buffer += ret;
+        read_len -= ret;
+    }
 
+    ret = gfdb_query_record_deserialize(buffer, buffer_len, query_record);
+    if (ret) {
+        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "Failed to de-serialize query record");
+        goto out;
+    }
 
-        /* Read the serialized query record from file */
-        read_len = buffer_len;
-        read_buffer = buffer;
-        while ((ret = sys_read (fd, read_buffer, read_len)) < read_len) {
-
-                /*Any error */
-                if (ret < 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno,
-                                LG_MSG_DB_ERROR, "Failed to read serialized "
-                                "query record from file");
-                        goto out;
-                }
-                /* EOF */
-                else if (ret == 0) {
-                        gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                                LG_MSG_DB_ERROR, "Invalid query record or "
-                                "corrupted query file");
-                        ret = -1;
-                        goto out;
-                }
-
-                read_buffer += ret;
-                read_len -= ret;
-        }
-
-        ret = gfdb_query_record_deserialize (buffer, buffer_len,
-                                             query_record);
-        if (ret) {
-                gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-                        LG_MSG_DB_ERROR, "Failed to de-serialize query record");
-                goto out;
-        }
-
-        ret = buffer_len;
+    ret = buffer_len;
 out:
-        GF_FREE (buffer);
-        return ret;
+    GF_FREE(buffer);
+    return ret;
 }
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.c b/libglusterfs/src/gfdb/gfdb_sqlite3.c
index ad94d648369..63957278e8a 100644
--- a/libglusterfs/src/gfdb/gfdb_sqlite3.c
+++ b/libglusterfs/src/gfdb/gfdb_sqlite3.c
@@ -19,160 +19,158 @@
  *
  * ***************************************************************************/
 gf_sql_connection_t *
-gf_sql_connection_init ()
+gf_sql_connection_init()
 {
-        gf_sql_connection_t *gf_sql_conn = NULL;
-
-        gf_sql_conn = GF_CALLOC (1, sizeof(gf_sql_connection_t),
-                        gf_mt_sql_connection_t);
-        if (gf_sql_conn == NULL) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Error allocating memory to "
-                        "gf_sql_connection_t ");
-        }
+    gf_sql_connection_t *gf_sql_conn = NULL;
+
+    gf_sql_conn = GF_CALLOC(1, sizeof(gf_sql_connection_t),
+                            gf_mt_sql_connection_t);
+    if (gf_sql_conn == NULL) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+               "Error allocating memory to "
+               "gf_sql_connection_t ");
+    }
 
-        return gf_sql_conn;
+    return gf_sql_conn;
 }
 
 void
-gf_sql_connection_fini (gf_sql_connection_t **sql_connection)
+gf_sql_connection_fini(gf_sql_connection_t **sql_connection)
 {
-        if (!sql_connection)
-                return;
-        GF_FREE (*sql_connection);
-        *sql_connection = NULL;
+    if (!sql_connection)
+        return;
+    GF_FREE(*sql_connection);
+    *sql_connection = NULL;
 }
 
 const char *
-gf_sql_jm2str (gf_sql_journal_mode_t jm)
+gf_sql_jm2str(gf_sql_journal_mode_t jm)
 {
-        switch (jm) {
+    switch (jm) {
         case gf_sql_jm_delete:
-                return GF_SQL_JM_DELETE;
+            return GF_SQL_JM_DELETE;
         case gf_sql_jm_truncate:
-                return GF_SQL_JM_TRUNCATE;
+            return GF_SQL_JM_TRUNCATE;
         case gf_sql_jm_persist:
-                return GF_SQL_JM_PERSIST;
+            return GF_SQL_JM_PERSIST;
         case gf_sql_jm_memory:
-                return GF_SQL_JM_MEMORY;
+            return GF_SQL_JM_MEMORY;
         case gf_sql_jm_wal:
-                return GF_SQL_JM_WAL;
+            return GF_SQL_JM_WAL;
         case gf_sql_jm_off:
-                return GF_SQL_JM_OFF;
+            return GF_SQL_JM_OFF;
         case gf_sql_jm_invalid:
-                break;
-        }
-        return NULL;
+            break;
+    }
+    return NULL;
 }
 
 gf_sql_journal_mode_t
-gf_sql_str2jm (const char *jm_str)
+gf_sql_str2jm(const char *jm_str)
 {
-        if (!jm_str) {
-                return gf_sql_jm_invalid;
-        } else if (strcmp (jm_str, GF_SQL_JM_DELETE) == 0) {
-                return gf_sql_jm_delete;
-        } else if (strcmp (jm_str, GF_SQL_JM_TRUNCATE) == 0) {
-                return gf_sql_jm_truncate;
-        } else if (strcmp (jm_str, GF_SQL_JM_PERSIST) == 0) {
-                return gf_sql_jm_persist;
-        } else if (strcmp (jm_str, GF_SQL_JM_MEMORY) == 0) {
-                return gf_sql_jm_memory;
-        } else if (strcmp (jm_str, GF_SQL_JM_WAL) == 0) {
-                return gf_sql_jm_wal;
-        } else if (strcmp (jm_str, GF_SQL_JM_OFF) == 0) {
-                return gf_sql_jm_off;
-        }
+    if (!jm_str) {
         return gf_sql_jm_invalid;
+    } else if (strcmp(jm_str, GF_SQL_JM_DELETE) == 0) {
+        return gf_sql_jm_delete;
+    } else if (strcmp(jm_str, GF_SQL_JM_TRUNCATE) == 0) {
+        return gf_sql_jm_truncate;
+    } else if (strcmp(jm_str, GF_SQL_JM_PERSIST) == 0) {
+        return gf_sql_jm_persist;
+    } else if (strcmp(jm_str, GF_SQL_JM_MEMORY) == 0) {
+        return gf_sql_jm_memory;
+    } else if (strcmp(jm_str, GF_SQL_JM_WAL) == 0) {
+        return gf_sql_jm_wal;
+    } else if (strcmp(jm_str, GF_SQL_JM_OFF) == 0) {
+        return gf_sql_jm_off;
+    }
+    return gf_sql_jm_invalid;
 }
 
 const char *
-gf_sql_av_t2str (gf_sql_auto_vacuum_t sql_av)
+gf_sql_av_t2str(gf_sql_auto_vacuum_t sql_av)
 {
-        switch (sql_av) {
+    switch (sql_av) {
         case gf_sql_av_none:
-                return GF_SQL_AV_NONE;
+            return GF_SQL_AV_NONE;
         case gf_sql_av_full:
-                return GF_SQL_AV_FULL;
+            return GF_SQL_AV_FULL;
         case gf_sql_av_incr:
-                return GF_SQL_AV_INCR;
+            return GF_SQL_AV_INCR;
         case gf_sql_av_invalid:
-                break;
-        }
-        return NULL;
+            break;
+    }
+    return NULL;
 }
 
 gf_sql_auto_vacuum_t
-gf_sql_str2av_t (const char *av_str)
+gf_sql_str2av_t(const char *av_str)
 {
-        if (!av_str) {
-                return gf_sql_av_invalid;
-        } else if (strcmp (av_str, GF_SQL_AV_NONE) == 0) {
-                return gf_sql_av_none;
-        } else if (strcmp (av_str, GF_SQL_AV_FULL) == 0) {
-                return gf_sql_av_full;
-        } else if (strcmp (av_str, GF_SQL_AV_INCR) == 0) {
-                return gf_sql_av_incr;
-        }
+    if (!av_str) {
         return gf_sql_av_invalid;
+    } else if (strcmp(av_str, GF_SQL_AV_NONE) == 0) {
+        return gf_sql_av_none;
+    } else if (strcmp(av_str, GF_SQL_AV_FULL) == 0) {
+        return gf_sql_av_full;
+    } else if (strcmp(av_str, GF_SQL_AV_INCR) == 0) {
+        return gf_sql_av_incr;
+    }
+    return gf_sql_av_invalid;
 }
 
 const char *
-gf_sync_t2str (gf_sql_sync_t sql_sync)
+gf_sync_t2str(gf_sql_sync_t sql_sync)
 {
-        switch (sql_sync) {
+    switch (sql_sync) {
         case gf_sql_sync_off:
-                return GF_SQL_SYNC_OFF;
+            return GF_SQL_SYNC_OFF;
         case gf_sql_sync_normal:
-                return GF_SQL_SYNC_NORMAL;
+            return GF_SQL_SYNC_NORMAL;
         case gf_sql_sync_full:
-                return GF_SQL_SYNC_FULL;
+            return GF_SQL_SYNC_FULL;
         case gf_sql_sync_invalid:
-                break;
-        }
-        return NULL;
+            break;
+    }
+    return NULL;
 }
 
 gf_sql_sync_t
-gf_sql_str2sync_t (const char *sync_str)
+gf_sql_str2sync_t(const char *sync_str)
 {
-        if (!sync_str) {
-                return gf_sql_sync_invalid;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_OFF) == 0) {
-                return gf_sql_sync_off;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_NORMAL) == 0) {
-                return gf_sql_sync_normal;
-        } else if (strcmp (sync_str, GF_SQL_SYNC_FULL) == 0) {
-                return gf_sql_sync_full;
-        }
+    if (!sync_str) {
         return gf_sql_sync_invalid;
+    } else if (strcmp(sync_str, GF_SQL_SYNC_OFF) == 0) {
+        return gf_sql_sync_off;
+    } else if (strcmp(sync_str, GF_SQL_SYNC_NORMAL) == 0) {
+        return gf_sql_sync_normal;
+    } else if (strcmp(sync_str, GF_SQL_SYNC_FULL) == 0) {
+        return gf_sql_sync_full;
+    }
+    return gf_sql_sync_invalid;
 }
 
-
 /*TODO replace GF_CALLOC by mem_pool or iobuff if required for performance */
 static char *
-sql_stmt_init ()
+sql_stmt_init()
 {
-        char *sql_stmt = NULL;
+    char *sql_stmt = NULL;
 
-        sql_stmt = GF_CALLOC (GF_STMT_SIZE_MAX, sizeof(char),
-                        gf_common_mt_char);
+    sql_stmt = GF_CALLOC(GF_STMT_SIZE_MAX, sizeof(char), gf_common_mt_char);
 
-        if (!sql_stmt) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM,
-                        LG_MSG_NO_MEMORY, "Error allocating memory to SQL "
-                        "Statement ");
-                goto out;
-        }
+    if (!sql_stmt) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY,
+               "Error allocating memory to SQL "
+               "Statement ");
+        goto out;
+    }
 out:
-        return sql_stmt;
+    return sql_stmt;
 }
 
 /*TODO replace GF_FREE by mem_pool or iobuff if required for performance */
 static void
-sql_stmt_fini (char **sql_stmt)
+sql_stmt_fini(char **sql_stmt)
 {
-        GF_FREE (*sql_stmt);
+    GF_FREE(*sql_stmt);
 }
 
 /******************************************************************************
@@ -183,334 +181,313 @@ sql_stmt_fini (char **sql_stmt)
 static sqlite3 *
 gf_open_sqlite3_conn(char *sqlite3_db_path, int flags)
 {
-        sqlite3 *sqlite3_db_conn = NULL;
-        int ret = -1;
-
-        GF_ASSERT (sqlite3_db_path);
-
-        /*Creates DB if not created*/
-        ret = sqlite3_open_v2 (sqlite3_db_path, &sqlite3_db_conn, flags, NULL);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
-                        "FATAL: Could open %s : %s",
-                        sqlite3_db_path, sqlite3_errmsg (sqlite3_db_conn));
-        }
-        return sqlite3_db_conn;
+    sqlite3 *sqlite3_db_conn = NULL;
+    int ret = -1;
+
+    GF_ASSERT(sqlite3_db_path);
+
+    /*Creates DB if not created*/
+    ret = sqlite3_open_v2(sqlite3_db_path, &sqlite3_db_conn, flags, NULL);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR,
+               "FATAL: Could open %s : %s", sqlite3_db_path,
+               sqlite3_errmsg(sqlite3_db_conn));
+    }
+    return sqlite3_db_conn;
 }
 
 static int
 gf_close_sqlite3_conn(sqlite3 *sqlite3_db_conn)
 {
-        int ret = 0;
-
-        GF_ASSERT (sqlite3_db_conn);
-
-        if (sqlite3_db_conn) {
-                ret = sqlite3_close (sqlite3_db_conn);
-                if (ret != SQLITE_OK) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CONNECTION_ERROR, "FATAL: sqlite3 close"
-                                " connection failed %s",
-                                sqlite3_errmsg (sqlite3_db_conn));
-                        ret = -1;
-                        goto out;
-                }
-        }
-        ret = 0;
+    int ret = 0;
+
+    GF_ASSERT(sqlite3_db_conn);
+
+    if (sqlite3_db_conn) {
+        ret = sqlite3_close(sqlite3_db_conn);
+        if (ret != SQLITE_OK) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR,
+                   "FATAL: sqlite3 close"
+                   " connection failed %s",
+                   sqlite3_errmsg(sqlite3_db_conn));
+            ret = -1;
+            goto out;
+        }
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /******************************************************************************
-*
-*                      Database init / fini / create table
-*
-* ***************************************************************************/
-
+ *
+ *                      Database init / fini / create table
+ *
+ * ***************************************************************************/
 
 /*Function to fill db operations*/
 void
-gf_sqlite3_fill_db_operations(gfdb_db_operations_t  *gfdb_db_ops)
+gf_sqlite3_fill_db_operations(gfdb_db_operations_t *gfdb_db_ops)
 {
-        GF_ASSERT (gfdb_db_ops);
+    GF_ASSERT(gfdb_db_ops);
 
-        gfdb_db_ops->init_db_op = gf_sqlite3_init;
-        gfdb_db_ops->fini_db_op = gf_sqlite3_fini;
+    gfdb_db_ops->init_db_op = gf_sqlite3_init;
+    gfdb_db_ops->fini_db_op = gf_sqlite3_fini;
 
-        gfdb_db_ops->insert_record_op = gf_sqlite3_insert;
-        gfdb_db_ops->delete_record_op = gf_sqlite3_delete;
-        gfdb_db_ops->compact_db_op = gf_sqlite3_vacuum;
+    gfdb_db_ops->insert_record_op = gf_sqlite3_insert;
+    gfdb_db_ops->delete_record_op = gf_sqlite3_delete;
+    gfdb_db_ops->compact_db_op = gf_sqlite3_vacuum;
 
-        gfdb_db_ops->find_all_op = gf_sqlite3_find_all;
-        gfdb_db_ops->find_unchanged_for_time_op =
-                        gf_sqlite3_find_unchanged_for_time;
-        gfdb_db_ops->find_recently_changed_files_op =
-                        gf_sqlite3_find_recently_changed_files;
-        gfdb_db_ops->find_unchanged_for_time_freq_op =
-                        gf_sqlite3_find_unchanged_for_time_freq;
-        gfdb_db_ops->find_recently_changed_files_freq_op =
-                        gf_sqlite3_find_recently_changed_files_freq;
+    gfdb_db_ops->find_all_op = gf_sqlite3_find_all;
+    gfdb_db_ops
+        ->find_unchanged_for_time_op = gf_sqlite3_find_unchanged_for_time;
+    gfdb_db_ops->find_recently_changed_files_op =
+        gf_sqlite3_find_recently_changed_files;
+    gfdb_db_ops->find_unchanged_for_time_freq_op =
+        gf_sqlite3_find_unchanged_for_time_freq;
+    gfdb_db_ops->find_recently_changed_files_freq_op =
+        gf_sqlite3_find_recently_changed_files_freq;
 
-        gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat;
+    gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat;
 
-        gfdb_db_ops->get_db_version = gf_sqlite3_version;
+    gfdb_db_ops->get_db_version = gf_sqlite3_version;
 
-        gfdb_db_ops->get_db_params = gf_sqlite3_pragma;
+    gfdb_db_ops->get_db_params = gf_sqlite3_pragma;
 
-        gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma;
+    gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma;
 }
 
-
 static int
-create_filetable (sqlite3 *sqlite3_db_conn)
+create_filetable(sqlite3 *sqlite3_db_conn)
 {
-        int ret                         =       -1;
-        char *sql_stmt                  =       NULL;
-        char *sql_strerror              =       NULL;
-
-        GF_ASSERT(sqlite3_db_conn);
-
-        sql_stmt = sql_stmt_init ();
-        if (!sql_stmt) {
-                ret = ENOMEM;
-                goto out;
-        }
-
-        GF_CREATE_STMT(sql_stmt);
-
-        ret = sqlite3_exec (sqlite3_db_conn, sql_stmt, NULL, NULL,
-                                &sql_strerror);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
-                        "Failed executing: %s : %s", sql_stmt, sql_strerror);
-                sqlite3_free (sql_strerror);
-                        ret = -1;
-                        goto out;
-        }
-
-
-        ret = 0;
+    int ret = -1;
+    char *sql_stmt = NULL;
+    char *sql_strerror = NULL;
+
+    GF_ASSERT(sqlite3_db_conn);
+
+    sql_stmt = sql_stmt_init();
+    if (!sql_stmt) {
+        ret = ENOMEM;
+        goto out;
+    }
+
+    GF_CREATE_STMT(sql_stmt);
+
+    ret = sqlite3_exec(sqlite3_db_conn, sql_stmt, NULL, NULL, &sql_strerror);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
+               "Failed executing: %s : %s", sql_stmt, sql_strerror);
+        sqlite3_free(sql_strerror);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        sql_stmt_fini (&sql_stmt);
-        return ret;
+    sql_stmt_fini(&sql_stmt);
+    return ret;
 }
 
-
-
-
 static int
 apply_sql_params_db(gf_sql_connection_t *sql_conn, dict_t *param_dict)
 {
-        int ret = -1;
-        char *temp_str = NULL;
-        char sqlite3_config_str[GF_NAME_MAX] = "";
-
-        GF_ASSERT(sql_conn);
-        GF_ASSERT(param_dict);
-
-        /*Extract sql page_size from param_dict,
-         * if not specified default value will be GF_SQL_DEFAULT_PAGE_SIZE*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_PAGE_SIZE, temp_str,
-                        GF_SQL_DEFAULT_PAGE_SIZE);
-        sql_conn->page_size = atoi (temp_str);
-        /*Apply page_size on the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "page_size", "%zd",
-                        sql_conn->page_size, ret, out);
-
-
-
-        /*Extract sql cache size from param_dict,
+    int ret = -1;
+    char *temp_str = NULL;
+    char sqlite3_config_str[GF_NAME_MAX] = "";
+
+    GF_ASSERT(sql_conn);
+    GF_ASSERT(param_dict);
+
+    /*Extract sql page_size from param_dict,
+     * if not specified default value will be GF_SQL_DEFAULT_PAGE_SIZE*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
+                                   GFDB_SQL_PARAM_PAGE_SIZE, temp_str,
+                                   GF_SQL_DEFAULT_PAGE_SIZE);
+    sql_conn->page_size = atoi(temp_str);
+    /*Apply page_size on the sqlite db*/
+    GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "page_size", "%zd",
+                          sql_conn->page_size, ret, out);
+
+    /*Extract sql cache size from param_dict,
+     * if not specified default value will be
+     * GF_SQL_DEFAULT_CACHE_SIZE pages*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
+                                   GFDB_SQL_PARAM_CACHE_SIZE, temp_str,
+                                   GF_SQL_DEFAULT_CACHE_SIZE);
+    sql_conn->cache_size = atoi(temp_str);
+    /*Apply cache size on the sqlite db*/
+    GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "cache_size", "%zd",
+                          sql_conn->cache_size, ret, out);
+
+    /*Extract sql journal mode from param_dict,
+     * if not specified default value will be
+     * GF_SQL_DEFAULT_JOURNAL_MODE i.e "wal"*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
+                                   GFDB_SQL_PARAM_JOURNAL_MODE, temp_str,
+                                   GF_SQL_DEFAULT_JOURNAL_MODE);
+    sql_conn->journal_mode = gf_sql_str2jm(temp_str);
+    /*Apply journal mode to the sqlite db*/
+    GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "journal_mode", "%s", temp_str,
+                          ret, out);
+
+    /*Only when the journal mode is WAL, wal_autocheckpoint makes sense*/
+    if (sql_conn->journal_mode == gf_sql_jm_wal) {
+        /*Extract sql wal auto check point from param_dict
          * if not specified default value will be
-         * GF_SQL_DEFAULT_CACHE_SIZE pages*/
+         * GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT pages*/
         temp_str = NULL;
         GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_CACHE_SIZE, temp_str,
-                        GF_SQL_DEFAULT_CACHE_SIZE);
-        sql_conn->cache_size = atoi (temp_str);
-        /*Apply cache size on the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "cache_size", "%zd",
-                        sql_conn->cache_size, ret, out);
-
-
-
-
-        /*Extract sql journal mode from param_dict,
-         * if not specified default value will be
-         * GF_SQL_DEFAULT_JOURNAL_MODE i.e "wal"*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_JOURNAL_MODE, temp_str,
-                        GF_SQL_DEFAULT_JOURNAL_MODE);
-        sql_conn->journal_mode = gf_sql_str2jm (temp_str);
-        /*Apply journal mode to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "journal_mode", "%s",
-                        temp_str, ret, out);
-
-
-
-        /*Only when the journal mode is WAL, wal_autocheckpoint makes sense*/
-        if (sql_conn->journal_mode == gf_sql_jm_wal) {
-                /*Extract sql wal auto check point from param_dict
-                * if not specified default value will be
-                * GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT pages*/
-                temp_str = NULL;
-                GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_WAL_AUTOCHECK, temp_str,
-                        GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT);
-                sql_conn->wal_autocheckpoint = atoi(temp_str);
-                /*Apply wal auto check point to the sqlite db*/
-                GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "wal_autocheckpoint",
-                        "%zd", sql_conn->wal_autocheckpoint, ret, out);
-        }
-
-
-
-        /*Extract sql synchronous from param_dict
-         * if not specified default value will be GF_SQL_DEFAULT_SYNC*/
-         temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_SYNC, temp_str, GF_SQL_DEFAULT_SYNC);
-        sql_conn->synchronous = gf_sql_str2sync_t (temp_str);
-        /*Apply synchronous to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "synchronous", "%d",
-                        sql_conn->synchronous, ret, out);
-
-
-
-        /*Extract sql auto_vacuum from param_dict
-         * if not specified default value will be GF_SQL_DEFAULT_AUTO_VACUUM*/
-         temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
-                        GFDB_SQL_PARAM_AUTO_VACUUM, temp_str,
-                        GF_SQL_DEFAULT_AUTO_VACUUM);
-        sql_conn->auto_vacuum = gf_sql_str2av_t (temp_str);
-        /*Apply auto_vacuum to the sqlite db*/
-        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "auto_vacuum", "%d",
-                        sql_conn->auto_vacuum, ret, out);
-
-        ret = 0;
+                                       GFDB_SQL_PARAM_WAL_AUTOCHECK, temp_str,
+                                       GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT);
+        sql_conn->wal_autocheckpoint = atoi(temp_str);
+        /*Apply wal auto check point to the sqlite db*/
+        GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "wal_autocheckpoint", "%zd",
+                              sql_conn->wal_autocheckpoint, ret, out);
+    }
+
+    /*Extract sql synchronous from param_dict
+     * if not specified default value will be GF_SQL_DEFAULT_SYNC*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
+                                   GFDB_SQL_PARAM_SYNC, temp_str,
+                                   GF_SQL_DEFAULT_SYNC);
+    sql_conn->synchronous = gf_sql_str2sync_t(temp_str);
+    /*Apply synchronous to the sqlite db*/
+    GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "synchronous", "%d",
+                          sql_conn->synchronous, ret, out);
+
+    /*Extract sql auto_vacuum from param_dict
+     * if not specified default value will be GF_SQL_DEFAULT_AUTO_VACUUM*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict,
+                                   GFDB_SQL_PARAM_AUTO_VACUUM, temp_str,
+                                   GF_SQL_DEFAULT_AUTO_VACUUM);
+    sql_conn->auto_vacuum = gf_sql_str2av_t(temp_str);
+    /*Apply auto_vacuum to the sqlite db*/
+    GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "auto_vacuum", "%d",
+                          sql_conn->auto_vacuum, ret, out);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-gf_sqlite3_init (dict_t *args, void **db_conn) {
-        int ret                         = -1;
-        gf_sql_connection_t *sql_conn   = NULL;
-        struct stat stbuf               = {0,};
-        gf_boolean_t    is_dbfile_exist = _gf_false;
-        char *temp_str                  = NULL;
-
-        GF_ASSERT (args);
-        GF_ASSERT (db_conn);
-
-        if (*db_conn != NULL) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CONNECTION_ERROR, "DB Connection is not "
-                        "empty!");
-                return 0;
-        }
-
-        if (!sqlite3_threadsafe ()) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_NOT_MULTITHREAD_MODE,
-                        "sqlite3 is not in multithreaded mode");
-                goto out;
-        }
-
-        sql_conn = gf_sql_connection_init ();
-        if (!sql_conn) {
-                goto out;
-        }
-
-        /*Extract sql db path from args*/
-        temp_str = NULL;
-        GET_DB_PARAM_FROM_DICT(GFDB_STR_SQLITE3, args,
-                        GFDB_SQL_PARAM_DBPATH, temp_str, out);
-        strncpy(sql_conn->sqlite3_db_path, temp_str, PATH_MAX-1);
-        sql_conn->sqlite3_db_path[PATH_MAX-1] = 0;
-
-        is_dbfile_exist = (sys_stat (sql_conn->sqlite3_db_path, &stbuf) == 0) ?
-                                                _gf_true : _gf_false;
-
-        /*Creates DB if not created*/
-        sql_conn->sqlite3_db_conn = gf_open_sqlite3_conn (
-                                        sql_conn->sqlite3_db_path,
-                                        SQLITE_OPEN_READWRITE |
-                                        SQLITE_OPEN_CREATE);
-        if (!sql_conn->sqlite3_db_conn) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CONNECTION_ERROR,
-                        "Failed creating db connection");
-                goto out;
-        }
-
-        /* If the file exist we skip the config part
-         * and creation of the schema */
-        if (is_dbfile_exist)
-                goto db_exists;
-
-
-        /*Apply sqlite3 params to database*/
-        ret = apply_sql_params_db (sql_conn, args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_SET_PARAM_FAILED, "Failed applying sql params"
-                        " to %s", sql_conn->sqlite3_db_path);
-                goto out;
-        }
-
-        /*Create the schema if NOT present*/
-        ret = create_filetable (sql_conn->sqlite3_db_conn);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CREATE_FAILED, "Failed Creating %s Table",
-                        GF_FILE_TABLE);
-               goto out;
-        }
+gf_sqlite3_init(dict_t *args, void **db_conn)
+{
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    gf_boolean_t is_dbfile_exist = _gf_false;
+    char *temp_str = NULL;
+
+    GF_ASSERT(args);
+    GF_ASSERT(db_conn);
+
+    if (*db_conn != NULL) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR,
+               "DB Connection is not "
+               "empty!");
+        return 0;
+    }
+
+    if (!sqlite3_threadsafe()) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_NOT_MULTITHREAD_MODE,
+               "sqlite3 is not in multithreaded mode");
+        goto out;
+    }
+
+    sql_conn = gf_sql_connection_init();
+    if (!sql_conn) {
+        goto out;
+    }
+
+    /*Extract sql db path from args*/
+    temp_str = NULL;
+    GET_DB_PARAM_FROM_DICT(GFDB_STR_SQLITE3, args, GFDB_SQL_PARAM_DBPATH,
+                           temp_str, out);
+    strncpy(sql_conn->sqlite3_db_path, temp_str, PATH_MAX - 1);
+    sql_conn->sqlite3_db_path[PATH_MAX - 1] = 0;
+
+    is_dbfile_exist = (sys_stat(sql_conn->sqlite3_db_path, &stbuf) == 0)
+                          ? _gf_true
+                          : _gf_false;
+
+    /*Creates DB if not created*/
+    sql_conn->sqlite3_db_conn = gf_open_sqlite3_conn(
+        sql_conn->sqlite3_db_path, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+    if (!sql_conn->sqlite3_db_conn) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR,
+               "Failed creating db connection");
+        goto out;
+    }
+
+    /* If the file exist we skip the config part
+     * and creation of the schema */
+    if (is_dbfile_exist)
+        goto db_exists;
+
+    /*Apply sqlite3 params to database*/
+    ret = apply_sql_params_db(sql_conn, args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+               "Failed applying sql params"
+               " to %s",
+               sql_conn->sqlite3_db_path);
+        goto out;
+    }
+
+    /*Create the schema if NOT present*/
+    ret = create_filetable(sql_conn->sqlite3_db_conn);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Failed Creating %s Table", GF_FILE_TABLE);
+        goto out;
+    }
 
 db_exists:
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                gf_sqlite3_fini ((void **)&sql_conn);
-        }
+    if (ret) {
+        gf_sqlite3_fini((void **)&sql_conn);
+    }
 
-        *db_conn = sql_conn;
+    *db_conn = sql_conn;
 
-        return ret;
+    return ret;
 }
 
-
 int
-gf_sqlite3_fini (void **db_conn)
+gf_sqlite3_fini(void **db_conn)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = NULL;
-
-        GF_ASSERT (db_conn);
-        sql_conn = *db_conn;
-
-        if (sql_conn) {
-                if (sql_conn->sqlite3_db_conn) {
-                        ret = gf_close_sqlite3_conn (sql_conn->sqlite3_db_conn);
-                        if (ret) {
-                                /*Logging of error done in
-                                 * gf_close_sqlite3_conn()*/
-                                goto out;
-                        }
-                        sql_conn->sqlite3_db_conn = NULL;
-                }
-                gf_sql_connection_fini (&sql_conn);
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = NULL;
+
+    GF_ASSERT(db_conn);
+    sql_conn = *db_conn;
+
+    if (sql_conn) {
+        if (sql_conn->sqlite3_db_conn) {
+            ret = gf_close_sqlite3_conn(sql_conn->sqlite3_db_conn);
+            if (ret) {
+                /*Logging of error done in
+                 * gf_close_sqlite3_conn()*/
+                goto out;
+            }
+            sql_conn->sqlite3_db_conn = NULL;
         }
-        *db_conn = sql_conn;
-        ret = 0;
+        gf_sql_connection_fini(&sql_conn);
+    }
+    *db_conn = sql_conn;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /******************************************************************************
@@ -520,79 +497,84 @@ out:
  *
  * ***************************************************************************/
 
-int gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *gfdb_db_record)
+int
+gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *gfdb_db_record)
 {
-        int ret                         =       -1;
-        gf_sql_connection_t *sql_conn   =       db_conn;
-
-        CHECK_SQL_CONN(sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
 
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
 
-        switch (gfdb_db_record->gfdb_fop_path) {
+    switch (gfdb_db_record->gfdb_fop_path) {
         case GFDB_FOP_WIND:
-                ret = gf_sql_insert_wind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_FAILED, "Failed wind insert");
-                        goto out;
-                }
-                break;
+            ret = gf_sql_insert_wind(sql_conn, gfdb_db_record);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_INSERT_FAILED, "Failed wind insert");
+                goto out;
+            }
+            break;
         case GFDB_FOP_UNWIND:
-                ret = gf_sql_insert_unwind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_INSERT_FAILED, "Failed unwind insert");
-                        goto out;
-                }
-                break;
+            ret = gf_sql_insert_unwind(sql_conn, gfdb_db_record);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_INSERT_FAILED, "Failed unwind insert");
+                goto out;
+            }
+            break;
 
         case GFDB_FOP_WDEL:
-                ret = gf_sql_update_delete_wind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_UPDATE_FAILED, "Failed updating delete "
-                                "during wind");
-                        goto out;
-                }
-                break;
+            ret = gf_sql_update_delete_wind(sql_conn, gfdb_db_record);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_UPDATE_FAILED,
+                       "Failed updating delete "
+                       "during wind");
+                goto out;
+            }
+            break;
         case GFDB_FOP_UNDEL:
         case GFDB_FOP_UNDEL_ALL:
-                ret = gf_sql_delete_unwind (sql_conn, gfdb_db_record);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_DELETE_FAILED, "Failed deleting");
-                        goto out;
-                }
-                break;
+            ret = gf_sql_delete_unwind(sql_conn, gfdb_db_record);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_DELETE_FAILED, "Failed deleting");
+                goto out;
+            }
+            break;
         case GFDB_FOP_INVALID:
         default:
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_FOP,
-                        "Cannot record to DB: Invalid FOP");
-                goto out;
-        }
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_FOP,
+                   "Cannot record to DB: Invalid FOP");
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
 gf_sqlite3_delete(void *db_conn, gfdb_db_record_t *gfdb_db_record)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
 
-        CHECK_SQL_CONN(sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /******************************************************************************
@@ -603,27 +585,24 @@ out:
  * ***************************************************************************/
 
 static int
-gf_get_basic_query_stmt (char **out_stmt)
+gf_get_basic_query_stmt(char **out_stmt)
 {
-        int ret = -1;
-        ret = gf_asprintf (out_stmt, "select GF_FILE_TB.GF_ID,"
-                                  "GF_FLINK_TB.GF_PID ,"
-                                  "GF_FLINK_TB.FNAME "
-                                  "from GF_FLINK_TB, GF_FILE_TB "
-                                  "where "
-                                  "GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID ");
-        if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create base query statement");
-                *out_stmt = NULL;
-        }
-        return ret;
+    int ret = -1;
+    ret = gf_asprintf(out_stmt,
+                      "select GF_FILE_TB.GF_ID,"
+                      "GF_FLINK_TB.GF_PID ,"
+                      "GF_FLINK_TB.FNAME "
+                      "from GF_FLINK_TB, GF_FILE_TB "
+                      "where "
+                      "GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID ");
+    if (ret <= 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed to create base query statement");
+        *out_stmt = NULL;
+    }
+    return ret;
 }
 
-
-
-
-
 /*
  * Find All files recorded in the DB
  * Input:
@@ -631,71 +610,65 @@ gf_get_basic_query_stmt (char **out_stmt)
  *                              result records from the query
  * */
 int
-gf_sqlite3_find_all (void *db_conn, gf_query_callback_t query_callback,
-                        void *query_cbk_args,
-                        int query_limit)
+gf_sqlite3_find_all(void *db_conn, gf_query_callback_t query_callback,
+                    void *query_cbk_args, int query_limit)
 {
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        char *limit_query                       =       NULL;
-        char *query                             =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+    int ret = -1;
+    char *query_str = NULL;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *prep_stmt = NULL;
+    char *limit_query = NULL;
+    char *query = NULL;
 
-        ret = gf_get_basic_query_stmt (&query_str);
-        if (ret <= 0) {
-                goto out;
-        }
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
 
-        query = query_str;
-
-        if (query_limit > 0) {
-                ret = gf_asprintf (&limit_query, "%s LIMIT %d",
-                                   query, query_limit);
-                if (ret < 0) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_FAILED,
-                                "Failed creating limit query statement");
-                        limit_query = NULL;
-                        goto out;
-                }
+    ret = gf_get_basic_query_stmt(&query_str);
+    if (ret <= 0) {
+        goto out;
+    }
 
-                query = limit_query;
-        }
+    query = query_str;
 
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED,
-                        "Failed to prepare statement %s: %s", query,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query);
-                goto out;
-        }
-
-        ret = 0;
+    if (query_limit > 0) {
+        ret = gf_asprintf(&limit_query, "%s LIMIT %d", query, query_limit);
+        if (ret < 0) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+                   "Failed creating limit query statement");
+            limit_query = NULL;
+            goto out;
+        }
+
+        query = limit_query;
+    }
+
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query, -1, &prep_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed to prepare statement %s: %s", query,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed Query %s", query);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (query_str);
+    sqlite3_finalize(prep_stmt);
+    GF_FREE(query_str);
 
-        if (limit_query)
-                GF_FREE (limit_query);
+    if (limit_query)
+        GF_FREE(limit_query);
 
-        return ret;
+    return ret;
 }
 
-
 /*
  * Find recently changed files from the DB
  * Input:
@@ -705,97 +678,101 @@ out:
  * */
 int
 gf_sqlite3_find_recently_changed_files(void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *from_time)
+                                       gf_query_callback_t query_callback,
+                                       void *query_cbk_args,
+                                       gfdb_time_t *from_time)
 {
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  from_time_usec                =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND"
-                /*First condition: For writes*/
-                "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? )"
-                " OR "
-                /*Second condition: For reads*/
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ?) )"
-                /* Order by write wind time in a descending order
-                 * i.e most hot files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC DESC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed creating query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        from_time_usec = gfdb_time_2_usec (from_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                               &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 2, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s ", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char *query_str = NULL;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *prep_stmt = NULL;
+    uint64_t from_time_usec = 0;
+    char *base_query_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+
+    ret = gf_get_basic_query_stmt(&base_query_str);
+    if (ret <= 0) {
+        goto out;
+    }
+
+    ret = gf_asprintf(
+        &query_str,
+        "%s AND"
+        /*First condition: For writes*/
+        "( ((" GF_COL_TB_WSEC " * " TOSTRING(
+            GFDB_MICROSEC) " + " GF_COL_TB_WMSEC
+                           ") >= ? )"
+                           " OR "
+                           /*Second condition: For reads*/
+                           "((" GF_COL_TB_RWSEC " * " TOSTRING(
+                               GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC
+                                              ") >= ?) )"
+                                              /* Order by write wind time in a
+                                               * descending order i.e most hot
+                                               * files w.r.t to write */
+                                              " ORDER BY GF_FILE_TB.W_SEC DESC",
+        base_query_str);
+
+    if (ret < 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed creating query statement");
+        query_str = NULL;
+        goto out;
+    }
+
+    from_time_usec = gfdb_time_2_usec(from_time);
+
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt,
+                          0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed to prepare statement %s :"
+               " %s",
+               query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 1, from_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind from_time_usec "
+               "%" PRIu64 " : %s",
+               from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 2, from_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind from_time_usec "
+               "%" PRIu64 " : %s ",
+               from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the query*/
+    ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed Query %s", query_str);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
+    sqlite3_finalize(prep_stmt);
+    GF_FREE(base_query_str);
+    GF_FREE(query_str);
+    return ret;
 }
 
-
 /*
  * Find unchanged files from a specified time from the DB
  * Input:
@@ -804,101 +781,101 @@ out:
  *      for_time        :        Time from where the file/s are not changed
  * */
 int
-gf_sqlite3_find_unchanged_for_time (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *for_time)
+gf_sqlite3_find_unchanged_for_time(void *db_conn,
+                                   gf_query_callback_t query_callback,
+                                   void *query_cbk_args, gfdb_time_t *for_time)
 {
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  for_time_usec                 =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND "
-                /*First condition: For writes*/
-                "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") <= ? )"
-                " AND "
-                /*Second condition: For reads*/
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") <= ?) )"
-                /* Order by write wind time in a ascending order
-                 * i.e most cold files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC ASC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        for_time_usec = gfdb_time_2_usec (for_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                               &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 2, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char *query_str = NULL;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *prep_stmt = NULL;
+    uint64_t for_time_usec = 0;
+    char *base_query_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+
+    ret = gf_get_basic_query_stmt(&base_query_str);
+    if (ret <= 0) {
+        goto out;
+    }
+
+    ret = gf_asprintf(
+        &query_str,
+        "%s AND "
+        /*First condition: For writes*/
+        "( ((" GF_COL_TB_WSEC " * " TOSTRING(
+            GFDB_MICROSEC) " + " GF_COL_TB_WMSEC
+                           ") <= ? )"
+                           " AND "
+                           /*Second condition: For reads*/
+                           "((" GF_COL_TB_RWSEC " * " TOSTRING(
+                               GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC
+                                              ") <= ?) )"
+                                              /* Order by write wind time in a
+                                               * ascending order i.e most cold
+                                               * files w.r.t to write */
+                                              " ORDER BY GF_FILE_TB.W_SEC ASC",
+        base_query_str);
+
+    if (ret < 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed to create query statement");
+        query_str = NULL;
+        goto out;
+    }
+
+    for_time_usec = gfdb_time_2_usec(for_time);
+
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt,
+                          0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed to prepare statement %s :"
+               " %s",
+               query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 1, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 2, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the query*/
+    ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed Query %s", query_str);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
+    sqlite3_finalize(prep_stmt);
+    GF_FREE(base_query_str);
+    GF_FREE(query_str);
+    return ret;
 }
 
-
-
-
-
 /*
  * Find recently changed files with a specific frequency from the DB
  * Input:
@@ -911,140 +888,144 @@ out:
  *      clear_counters  :       Clear counters (r/w) for all inodes in DB
  * */
 int
-gf_sqlite3_find_recently_changed_files_freq (void *db_conn,
-                                        gf_query_callback_t query_callback,
-                                        void *query_cbk_args,
-                                        gfdb_time_t *from_time,
-                                        int freq_write_cnt,
-                                        int freq_read_cnt,
-                                        gf_boolean_t clear_counters)
+gf_sqlite3_find_recently_changed_files_freq(
+    void *db_conn, gf_query_callback_t query_callback, void *query_cbk_args,
+    gfdb_time_t *from_time, int freq_write_cnt, int freq_read_cnt,
+    gf_boolean_t clear_counters)
 {
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  from_time_usec                =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-        ret = gf_asprintf (&query_str, "%s AND "
-                /*First condition: For Writes*/
-                "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? )"
-                " AND "" (" GF_COL_TB_WFC " >= ? ) )"
-                " OR "
-                /*Second condition: For Reads */
-                "( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ?)"
-                " AND "" (" GF_COL_TB_RFC " >= ? ) ) )"
-                /* Order by write wind time and write freq in a descending order
-                 * i.e most hot files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC DESC, "
-                "GF_FILE_TB.WRITE_FREQ_CNTR DESC",
-                base_query_str);
-
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        from_time_usec = gfdb_time_2_usec (from_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :"
-                        " %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt "
-                        "%d : %s", freq_write_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 3, from_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec "
-                        "%"PRIu64" : %s", from_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 4, freq_read_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt "
-                        "%d : %s", freq_read_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
+    int ret = -1;
+    char *query_str = NULL;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *prep_stmt = NULL;
+    uint64_t from_time_usec = 0;
+    char *base_query_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+
+    ret = gf_get_basic_query_stmt(&base_query_str);
+    if (ret <= 0) {
+        goto out;
+    }
+    ret = gf_asprintf(
+        &query_str,
+        "%s AND "
+        /*First condition: For Writes*/
+        "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(
+            GFDB_MICROSEC) " + " GF_COL_TB_WMSEC
+                           ") >= ? )"
+                           " AND "
+                           " (" GF_COL_TB_WFC
+                           " >= ? ) )"
+                           " OR "
+                           /*Second condition: For Reads */
+                           "( ((" GF_COL_TB_RWSEC " * " TOSTRING(
+                               GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC
+                                              ") >= ?)"
+                                              " AND "
+                                              " (" GF_COL_TB_RFC
+                                              " >= ? ) ) )"
+                                              /* Order by write wind time and
+                                               * write freq in a descending
+                                               * order
+                                               * i.e most hot files w.r.t to
+                                               * write */
+                                              " ORDER BY GF_FILE_TB.W_SEC "
+                                              "DESC, "
+                                              "GF_FILE_TB.WRITE_FREQ_CNTR DESC",
+        base_query_str);
+
+    if (ret < 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed to create query statement");
+        query_str = NULL;
+        goto out;
+    }
+
+    from_time_usec = gfdb_time_2_usec(from_time);
+
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt,
+                          0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed to prepare statement %s :"
+               " %s",
+               query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 1, from_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind from_time_usec "
+               "%" PRIu64 " : %s",
+               from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write frequency thresold*/
+    ret = sqlite3_bind_int(prep_stmt, 2, freq_write_cnt);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind freq_write_cnt "
+               "%d : %s",
+               freq_write_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 3, from_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind from_time_usec "
+               "%" PRIu64 " : %s",
+               from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read frequency thresold*/
+    ret = sqlite3_bind_int(prep_stmt, 4, freq_read_cnt);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind freq_read_cnt "
+               "%d : %s",
+               freq_read_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the query*/
+    ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed Query %s", query_str);
+        goto out;
+    }
+
+    /*Clear counters*/
+    if (clear_counters) {
+        ret = gf_sql_clear_counters(sql_conn);
         if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-
-
-        /*Clear counters*/
-        if (clear_counters) {
-                ret = gf_sql_clear_counters (sql_conn);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear"
-                                " counters!");
-                        goto out;
-                }
-        }
-        ret = 0;
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                   LG_MSG_CLEAR_COUNTER_FAILED,
+                   "Failed to clear"
+                   " counters!");
+            goto out;
+        }
+    }
+    ret = 0;
 out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
+    sqlite3_finalize(prep_stmt);
+    GF_FREE(base_query_str);
+    GF_FREE(query_str);
+    return ret;
 }
 
-
-
-
 /*
  * Find unchanged files from a specified time, w.r.t to frequency, from the DB
  * Input:
@@ -1056,30 +1037,29 @@ out:
  *      clear_counters  :       Clear counters (r/w) for all inodes in DB
  * */
 int
-gf_sqlite3_find_unchanged_for_time_freq (void *db_conn,
+gf_sqlite3_find_unchanged_for_time_freq(void *db_conn,
                                         gf_query_callback_t query_callback,
                                         void *query_cbk_args,
                                         gfdb_time_t *for_time,
-                                        int freq_write_cnt,
-                                        int freq_read_cnt,
+                                        int freq_write_cnt, int freq_read_cnt,
                                         gf_boolean_t clear_counters)
 {
-        int ret                                 =       -1;
-        char *query_str                         =       NULL;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *prep_stmt                 =       NULL;
-        uint64_t  for_time_usec                 =       0;
-        char *base_query_str                    =       NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
-
-        ret = gf_get_basic_query_stmt (&base_query_str);
-        if (ret <= 0) {
-                goto out;
-        }
-
-        ret = gf_asprintf (&query_str, "%s AND "
+    int ret = -1;
+    char *query_str = NULL;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *prep_stmt = NULL;
+    uint64_t for_time_usec = 0;
+    char *base_query_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+
+    ret = gf_get_basic_query_stmt(&base_query_str);
+    if (ret <= 0) {
+        goto out;
+    }
+
+    ret = gf_asprintf (&query_str, "%s AND "
                 /*First condition: For Writes
                  * Files that have write wind time smaller than for_time
                  * OR
@@ -1109,145 +1089,141 @@ gf_sqlite3_find_unchanged_for_time_freq (void *db_conn,
                 "GF_FILE_TB.WRITE_FREQ_CNTR ASC",
                 base_query_str);
 
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to create query statement");
-                query_str = NULL;
-                goto out;
-        }
-
-        for_time_usec = gfdb_time_2_usec (for_time);
-
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1,
-                                &prep_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed to prepare delete "
-                        "statement %s : %s", query_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt"
-                        " %d : %s", freq_write_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind write wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 3, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 4, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read frequency thresold*/
-        ret = sqlite3_bind_int (prep_stmt, 5, freq_read_cnt);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt "
-                        "%d : %s", freq_read_cnt,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind read wind time*/
-        ret = sqlite3_bind_int64 (prep_stmt, 6, for_time_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec "
-                        "%"PRIu64" : %s", for_time_usec,
-                        sqlite3_errmsg(sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the query*/
-        ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args);
+    if (ret < 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed to create query statement");
+        query_str = NULL;
+        goto out;
+    }
+
+    for_time_usec = gfdb_time_2_usec(for_time);
+
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt,
+                          0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed to prepare delete "
+               "statement %s : %s",
+               query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 1, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write frequency thresold*/
+    ret = sqlite3_bind_int(prep_stmt, 2, freq_write_cnt);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind freq_write_cnt"
+               " %d : %s",
+               freq_write_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind write wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 3, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 4, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read frequency thresold*/
+    ret = sqlite3_bind_int(prep_stmt, 5, freq_read_cnt);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind freq_read_cnt "
+               "%d : %s",
+               freq_read_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind read wind time*/
+    ret = sqlite3_bind_int64(prep_stmt, 6, for_time_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed to bind for_time_usec "
+               "%" PRIu64 " : %s",
+               for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the query*/
+    ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed Query %s", query_str);
+        goto out;
+    }
+
+    /*Clear counters*/
+    if (clear_counters) {
+        ret = gf_sql_clear_counters(sql_conn);
         if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed Query %s", query_str);
-                goto out;
-        }
-
-
-        /*Clear counters*/
-        if (clear_counters) {
-                ret = gf_sql_clear_counters (sql_conn);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear "
-                                "counters!");
-                        goto out;
-                }
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                   LG_MSG_CLEAR_COUNTER_FAILED,
+                   "Failed to clear "
+                   "counters!");
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        sqlite3_finalize (prep_stmt);
-        GF_FREE (base_query_str);
-        GF_FREE (query_str);
-        return ret;
+    sqlite3_finalize(prep_stmt);
+    GF_FREE(base_query_str);
+    GF_FREE(query_str);
+    return ret;
 }
 
-
 int
-gf_sqlite3_clear_files_heat (void *db_conn)
+gf_sqlite3_clear_files_heat(void *db_conn)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
 
-        CHECK_SQL_CONN (sql_conn, out);
+    CHECK_SQL_CONN(sql_conn, out);
 
-        ret = gf_sql_clear_counters (sql_conn);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear "
-                        "files heat");
-                goto out;
-        }
+    ret = gf_sql_clear_counters(sql_conn);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CLEAR_COUNTER_FAILED,
+               "Failed to clear "
+               "files heat");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Function to extract version of sqlite db
  * Input:
  * void *db_conn        : Sqlite connection
@@ -1260,48 +1236,45 @@ out:
  *      On failure return -1
  * */
 int
-gf_sqlite3_version (void *db_conn, char **version)
+gf_sqlite3_version(void *db_conn, char **version)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        sqlite3_stmt *pre_stmt = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
-                                "SELECT SQLITE_VERSION()",
-                                -1, &pre_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
-                        sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = sqlite3_step(pre_stmt);
-        if (ret != SQLITE_ROW) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to get records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = gf_asprintf (version, "%s", sqlite3_column_text (pre_stmt, 0));
-        if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed extracting version");
-        }
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *pre_stmt = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+
+    ret = sqlite3_prepare_v2(sql_conn->sqlite3_db_conn,
+                             "SELECT SQLITE_VERSION()", -1, &pre_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed init prepare stmt %s", sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = sqlite3_step(pre_stmt);
+    if (ret != SQLITE_ROW) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED,
+               "Failed to get records "
+               "from db : %s",
+               sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_asprintf(version, "%s", sqlite3_column_text(pre_stmt, 0));
+    if (ret <= 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed extracting version");
+    }
 
 out:
-        sqlite3_finalize (pre_stmt);
+    sqlite3_finalize(pre_stmt);
 
-        return ret;
+    return ret;
 }
 
-
-
 /* Function to extract PRAGMA from sqlite db
  * Input:
  * void *db_conn        : Sqlite connection
@@ -1315,59 +1288,57 @@ out:
  *      On failure return -1
  * */
 int
-gf_sqlite3_pragma (void *db_conn, char *pragma_key, char **pragma_value)
+gf_sqlite3_pragma(void *db_conn, char *pragma_key, char **pragma_value)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
-        sqlite3_stmt *pre_stmt = NULL;
-        char *sqlstring = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out);
-
-        ret = gf_asprintf (&sqlstring, "PRAGMA %s;", pragma_key);
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
+    sqlite3_stmt *pre_stmt = NULL;
+    char *sqlstring = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_key, out);
+
+    ret = gf_asprintf(&sqlstring, "PRAGMA %s;", pragma_key);
+    if (ret <= 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed allocating memory");
+        goto out;
+    }
+
+    ret = sqlite3_prepare_v2(sql_conn->sqlite3_db_conn, sqlstring, -1,
+                             &pre_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed init prepare stmt %s", sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = sqlite3_step(pre_stmt);
+    if (ret != SQLITE_ROW) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED,
+               "Failed to get records "
+               "from db : %s",
+               sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    if (pragma_value) {
+        ret = gf_asprintf(pragma_value, "%s", sqlite3_column_text(pre_stmt, 0));
         if (ret <= 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed allocating memory");
-                goto out;
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+                   "Failed to get %s from db", pragma_key);
         }
+    }
 
-        ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn,
-                                  sqlstring, -1, &pre_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s",
-                        sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = sqlite3_step (pre_stmt);
-        if (ret != SQLITE_ROW) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to get records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        if (pragma_value) {
-                ret = gf_asprintf (pragma_value, "%s",
-                                   sqlite3_column_text (pre_stmt, 0));
-                if (ret <= 0) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_FAILED, "Failed to get %s from db",
-                                pragma_key);
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (sqlstring);
+    GF_FREE(sqlstring);
 
-        sqlite3_finalize (pre_stmt);
+    sqlite3_finalize(pre_stmt);
 
-        return ret;
+    return ret;
 }
 
 /* Function to set PRAGMA to sqlite db
@@ -1380,35 +1351,34 @@ out:
  *      On failure return -1
  * */
 int
-gf_sqlite3_set_pragma (void *db_conn, char *pragma_key, char *pragma_value)
+gf_sqlite3_set_pragma(void *db_conn, char *pragma_key, char *pragma_value)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn = db_conn;
-        char sqlstring[GF_NAME_MAX] = "";
-        char *db_pragma_value = NULL;
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
+    char sqlstring[GF_NAME_MAX] = "";
+    char *db_pragma_value = NULL;
 
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_value, out);
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_key, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_value, out);
 
-        GF_SQLITE3_SET_PRAGMA(sqlstring, pragma_key, "%s",
-                              pragma_value, ret, out);
+    GF_SQLITE3_SET_PRAGMA(sqlstring, pragma_key, "%s", pragma_value, ret, out);
 
-        ret = gf_sqlite3_pragma (db_conn, pragma_key, &db_pragma_value);
-        if (ret < 0) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
-                        "Failed to get %s pragma", pragma_key);
-        } else {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, 0,
-                        "Value set on DB %s : %s", pragma_key, db_pragma_value);
-        }
-        GF_FREE (db_pragma_value);
+    ret = gf_sqlite3_pragma(db_conn, pragma_key, &db_pragma_value);
+    if (ret < 0) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED,
+               "Failed to get %s pragma", pragma_key);
+    } else {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, 0, "Value set on DB %s : %s",
+               pragma_key, db_pragma_value);
+    }
+    GF_FREE(db_pragma_value);
 
-        ret = 0;
+    ret = 0;
 
 out:
 
-        return ret;
+    return ret;
 }
 
 /* Function to vacuum of sqlite db
@@ -1421,167 +1391,152 @@ out:
  *      On failure return -1
  * */
 int
-gf_sqlite3_vacuum (void *db_conn, gf_boolean_t compact_active,
-                   gf_boolean_t compact_mode_switched)
+gf_sqlite3_vacuum(void *db_conn, gf_boolean_t compact_active,
+                  gf_boolean_t compact_mode_switched)
 {
-        int ret = -1;
-        gf_sql_connection_t *sql_conn           =       db_conn;
-        char *sqlstring = NULL;
-        char *sql_strerror = NULL;
-        gf_boolean_t changing_pragma = _gf_true;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_NONE) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                        LG_MSG_COMPACT_STATUS,
-                        "VACUUM type is off: no VACUUM to do");
-                goto out;
-        }
-
-        if (compact_mode_switched) {
-                if (compact_active) { /* Then it was OFF before.
-                                        So turn everything on */
-                        ret = 0;
-                        switch (GF_SQL_COMPACT_DEF) {
-                        case GF_SQL_COMPACT_FULL:
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_FULL);
-                                break;
-                        case GF_SQL_COMPACT_INCR:
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_INCR);
-                                break;
-                        case GF_SQL_COMPACT_MANUAL:
-                                changing_pragma = _gf_false;
-                                break;
-                        default:
-                                ret = -1;
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_COMPACT_FAILED,
-                                        "VACUUM type undefined");
-                                goto out;
-                                break;
-                        }
-
-                } else { /* Then it was ON before, so turn it all off */
-                        if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_FULL ||
-                           GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_INCR) {
-                                ret = gf_sqlite3_set_pragma (db_conn,
-                                                             "auto_vacuum",
-                                                             GF_SQL_AV_NONE);
-                        } else {
-                                changing_pragma = _gf_false;
-                        }
-                }
-
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0,
-                                LG_MSG_PREPARE_FAILED,
-                                "Failed to set the pragma");
-                        goto out;
-                }
+    int ret = -1;
+    gf_sql_connection_t *sql_conn = db_conn;
+    char *sqlstring = NULL;
+    char *sql_strerror = NULL;
+    gf_boolean_t changing_pragma = _gf_true;
 
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                        LG_MSG_COMPACT_STATUS, "Turning compaction %i",
-                        GF_SQL_COMPACT_DEF);
-
-                /* If we move from an auto_vacuum scheme to off, */
-                /* or vice-versa, we must VACUUM to save the change. */
-                /* In the case of a manual VACUUM scheme, we might as well */
-                /* run a manual VACUUM now if we */
-                if (changing_pragma || compact_active) {
-                        ret = gf_asprintf (&sqlstring, "VACUUM;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS, "Sealed with a VACUUM");
-                }
-        } else { /* We are active, so it's time to VACUUM */
-                if (!compact_active) { /* Did we somehow enter an inconsistent
-                                          state? */
-                        ret = -1;
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_PREPARE_FAILED,
-                                "Tried to VACUUM when compaction inactive");
-                        goto out;
-                }
+    CHECK_SQL_CONN(sql_conn, out);
 
-                gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0,
-                       LG_MSG_COMPACT_STATUS,
-                       "Doing regular vacuum of type %i", GF_SQL_COMPACT_DEF);
-
-                switch (GF_SQL_COMPACT_DEF) {
-                case GF_SQL_COMPACT_INCR: /* INCR auto_vacuum */
-                        ret = gf_asprintf(&sqlstring,
-                                          "PRAGMA incremental_vacuum;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS,
-                               "Will commence an incremental VACUUM");
-                        break;
-                /* (MANUAL) Invoke the VACUUM command */
-                case GF_SQL_COMPACT_MANUAL:
-                        ret = gf_asprintf(&sqlstring, "VACUUM;");
-                        if (ret <= 0) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PREPARE_FAILED,
-                                        "Failed allocating memory");
-                                goto out;
-                        }
-                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0,
-                               LG_MSG_COMPACT_STATUS,
-                               "Will commence a VACUUM");
-                        break;
-                /* (FULL) The database does the compaction itself. */
-                /* We cannot do anything else, so we can leave */
-                /* without sending anything to the database */
+    if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_NONE) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+               "VACUUM type is off: no VACUUM to do");
+        goto out;
+    }
+
+    if (compact_mode_switched) {
+        if (compact_active) { /* Then it was OFF before.
+                                So turn everything on */
+            ret = 0;
+            switch (GF_SQL_COMPACT_DEF) {
                 case GF_SQL_COMPACT_FULL:
-                        ret = 0;
-                        goto success;
-                /* Any other state must be an error. Note that OFF */
-                /* cannot hit this statement since we immediately leave */
-                /* in that case */
+                    ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum",
+                                                GF_SQL_AV_FULL);
+                    break;
+                case GF_SQL_COMPACT_INCR:
+                    ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum",
+                                                GF_SQL_AV_INCR);
+                    break;
+                case GF_SQL_COMPACT_MANUAL:
+                    changing_pragma = _gf_false;
+                    break;
                 default:
-                        ret = -1;
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_COMPACT_FAILED,
-                                "VACUUM type undefined");
-                        goto out;
-                        break;
-                }
+                    ret = -1;
+                    gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                           LG_MSG_COMPACT_FAILED, "VACUUM type undefined");
+                    goto out;
+                    break;
+            }
+
+        } else { /* Then it was ON before, so turn it all off */
+            if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_FULL ||
+                GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_INCR) {
+                ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum",
+                                            GF_SQL_AV_NONE);
+            } else {
+                changing_pragma = _gf_false;
+            }
         }
 
-        gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS,
-               "SQLString == %s", sqlstring);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_PREPARE_FAILED,
+                   "Failed to set the pragma");
+            goto out;
+        }
 
-        ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlstring, NULL, NULL,
-                           &sql_strerror);
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+               "Turning compaction %i", GF_SQL_COMPACT_DEF);
+
+        /* If we move from an auto_vacuum scheme to off, */
+        /* or vice-versa, we must VACUUM to save the change. */
+        /* In the case of a manual VACUUM scheme, we might as well */
+        /* run a manual VACUUM now if we */
+        if (changing_pragma || compact_active) {
+            ret = gf_asprintf(&sqlstring, "VACUUM;");
+            if (ret <= 0) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+                       "Failed allocating memory");
+                goto out;
+            }
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+                   "Sealed with a VACUUM");
+        }
+    } else {                   /* We are active, so it's time to VACUUM */
+        if (!compact_active) { /* Did we somehow enter an inconsistent
+                                  state? */
+            ret = -1;
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+                   "Tried to VACUUM when compaction inactive");
+            goto out;
+        }
 
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to vacuum "
-                        "the db : %s", sqlite3_errmsg (db_conn));
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS,
+               "Doing regular vacuum of type %i", GF_SQL_COMPACT_DEF);
+
+        switch (GF_SQL_COMPACT_DEF) {
+            case GF_SQL_COMPACT_INCR: /* INCR auto_vacuum */
+                ret = gf_asprintf(&sqlstring, "PRAGMA incremental_vacuum;");
+                if (ret <= 0) {
+                    gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                           LG_MSG_PREPARE_FAILED, "Failed allocating memory");
+                    goto out;
+                }
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+                       "Will commence an incremental VACUUM");
+                break;
+            /* (MANUAL) Invoke the VACUUM command */
+            case GF_SQL_COMPACT_MANUAL:
+                ret = gf_asprintf(&sqlstring, "VACUUM;");
+                if (ret <= 0) {
+                    gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                           LG_MSG_PREPARE_FAILED, "Failed allocating memory");
+                    goto out;
+                }
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+                       "Will commence a VACUUM");
+                break;
+            /* (FULL) The database does the compaction itself. */
+            /* We cannot do anything else, so we can leave */
+            /* without sending anything to the database */
+            case GF_SQL_COMPACT_FULL:
+                ret = 0;
+                goto success;
+            /* Any other state must be an error. Note that OFF */
+            /* cannot hit this statement since we immediately leave */
+            /* in that case */
+            default:
                 ret = -1;
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_COMPACT_FAILED,
+                       "VACUUM type undefined");
                 goto out;
+                break;
         }
+    }
+
+    gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS,
+           "SQLString == %s", sqlstring);
+
+    ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlstring, NULL, NULL,
+                       &sql_strerror);
+
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED,
+               "Failed to vacuum "
+               "the db : %s",
+               sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
 success:
-        gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
-               compact_mode_switched ? "Successfully changed VACUUM on/off"
-               : "DB successfully VACUUM");
+    gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS,
+           compact_mode_switched ? "Successfully changed VACUUM on/off"
+                                 : "DB successfully VACUUM");
 out:
-        GF_FREE(sqlstring);
+    GF_FREE(sqlstring);
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
index b2c3392f45a..60dd5e25e66 100644
--- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
+++ b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
@@ -10,7 +10,6 @@
 
 #include "gfdb_sqlite3_helper.h"
 
-
 #define GFDB_SQL_STMT_SIZE 256
 
 /*****************************************************************************
@@ -21,711 +20,653 @@
  * ****************************************************************************/
 
 static int
-gf_sql_delete_all (gf_sql_connection_t  *sql_conn,
-                  char                  *gfid,
-                  gf_boolean_t          ignore_errors)
+gf_sql_delete_all(gf_sql_connection_t *sql_conn, char *gfid,
+                  gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *delete_file_stmt = NULL;
-        sqlite3_stmt *delete_link_stmt = NULL;
-        char *delete_link_str = "DELETE FROM "
-                           GF_FILE_LINK_TABLE
-                           " WHERE GF_ID = ? ;";
-        char *delete_file_str = "DELETE FROM "
-                           GF_FILE_TABLE
-                           " WHERE GF_ID = ? ;";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-
-        /*
-         * Delete all links associated with this GFID
-         *
-         * */
-        /*Prepare statement for delete all links*/
-        ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1,
-                                &delete_link_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_link_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_link_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (delete_link_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_link_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*
-         * Delete entry from file table associated with this GFID
-         *
-         * */
-        /*Prepare statement for delete all links*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_file_str, -1,
-                                &delete_file_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_file_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_file_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (delete_file_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_file_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
+    int ret = -1;
+    sqlite3_stmt *delete_file_stmt = NULL;
+    sqlite3_stmt *delete_link_stmt = NULL;
+    char *delete_link_str = "DELETE FROM " GF_FILE_LINK_TABLE
+                            " WHERE GF_ID = ? ;";
+    char *delete_file_str = "DELETE FROM " GF_FILE_TABLE " WHERE GF_ID = ? ;";
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+
+    /*
+     * Delete all links associated with this GFID
+     *
+     * */
+    /*Prepare statement for delete all links*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1,
+                          &delete_link_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing delete "
+               "statement %s : %s",
+               delete_link_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(delete_link_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(delete_link_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", delete_link_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*
+     * Delete entry from file table associated with this GFID
+     *
+     * */
+    /*Prepare statement for delete all links*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_file_str, -1,
+                          &delete_file_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing delete "
+               "statement %s : %s",
+               delete_file_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(delete_file_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(delete_file_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", delete_file_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
 
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (delete_file_stmt);
-        sqlite3_finalize (delete_link_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(delete_file_stmt);
+    sqlite3_finalize(delete_link_stmt);
+    return ret;
 }
 
 static int
-gf_sql_delete_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   gf_boolean_t         ignore_errors)
+gf_sql_delete_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid,
+                   char *basename, gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *delete_stmt = NULL;
-        char *delete_str = "DELETE FROM "
-                           GF_FILE_LINK_TABLE
-                           " WHERE GF_ID = ? AND GF_PID = ?"
-                           " AND FNAME = ?;";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_str, -1,
-                                &delete_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing delete "
-                        "statement %s : %s", delete_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (delete_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED,
-                        "Failed binding gfid %s : %s", gfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (delete_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (delete_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step(delete_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        delete_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        ret = 0;
+    int ret = -1;
+    sqlite3_stmt *delete_stmt = NULL;
+    char *delete_str = "DELETE FROM " GF_FILE_LINK_TABLE
+                       " WHERE GF_ID = ? AND GF_PID = ?"
+                       " AND FNAME = ?;";
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out);
+
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_str, -1,
+                          &delete_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing delete "
+               "statement %s : %s",
+               delete_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(delete_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind pargfid*/
+    ret = sqlite3_bind_text(delete_stmt, 2, pargfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent gfid %s "
+               ": %s",
+               pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind basename*/
+    ret = sqlite3_bind_text(delete_stmt, 3, basename, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding basename %s : "
+               "%s",
+               basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(delete_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", delete_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (delete_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(delete_stmt);
+    return ret;
 }
 
-
-
 static int
-gf_sql_update_link_flags (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   int                  update_flag,
-                   gf_boolean_t         is_update_or_delete,
-                   gf_boolean_t         ignore_errors)
+gf_sql_update_link_flags(gf_sql_connection_t *sql_conn, char *gfid,
+                         char *pargfid, char *basename, int update_flag,
+                         gf_boolean_t is_update_or_delete,
+                         gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *update_stmt = NULL;
-        char *update_column = NULL;
-        char update_str[1024] = "";
-
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG";
-
-        sprintf (update_str, "UPDATE "
-                            GF_FILE_LINK_TABLE
-                            " SET %s = ?"
-                            " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;",
-                            update_column);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
-                                &update_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing update "
-                        "statement %s : %s", update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Bind link_update*/
-        ret = sqlite3_bind_int (update_stmt, 1, update_flag);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding update_flag %d "
-                        ": %s", update_flag,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (update_stmt, 2, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (update_stmt, 3, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (update_stmt, 4, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step(update_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    sqlite3_stmt *update_stmt = NULL;
+    char *update_column = NULL;
+    char update_str[1024] = "";
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out);
+
+    update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG";
+
+    sprintf(update_str,
+            "UPDATE " GF_FILE_LINK_TABLE
+            " SET %s = ?"
+            " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;",
+            update_column);
+
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, update_str, -1,
+                          &update_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing update "
+               "statement %s : %s",
+               update_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind link_update*/
+    ret = sqlite3_bind_int(update_stmt, 1, update_flag);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding update_flag %d "
+               ": %s",
+               update_flag, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(update_stmt, 2, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind pargfid*/
+    ret = sqlite3_bind_text(update_stmt, 3, pargfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent gfid %s "
+               ": %s",
+               pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind basename*/
+    ret = sqlite3_bind_text(update_stmt, 4, basename, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding basename %s : "
+               "%s",
+               basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(update_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", update_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (update_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(update_stmt);
+    return ret;
 }
 
-
 static int
-gf_sql_insert_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   gf_boolean_t         link_consistency,
-                   gf_boolean_t         ignore_errors)
+gf_sql_insert_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid,
+                   char *basename, gf_boolean_t link_consistency,
+                   gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char insert_str[GFDB_SQL_STMT_SIZE] = "";
-
-        sprintf (insert_str, "INSERT INTO "
-                           GF_FILE_LINK_TABLE
-                           " (GF_ID, GF_PID, FNAME,"
-                           " W_DEL_FLAG, LINK_UPDATE) "
-                           " VALUES (?, ?, ?, 0, %d);",
-                           link_consistency);
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                                &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED,
-                        "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED,
-                        "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind pargfid*/
-        ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_BINDING_FAILED,
-                        "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind basename*/
-        ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_BINDING_FAILED,
-                        "Failed binding basename %s : %s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors),
-                        0, LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared "
-                        "stmt %s %s %s %s : %s",
-                        gfid, pargfid, basename, insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    sqlite3_stmt *insert_stmt = NULL;
+    char insert_str[GFDB_SQL_STMT_SIZE] = "";
+
+    sprintf(insert_str,
+            "INSERT INTO " GF_FILE_LINK_TABLE
+            " (GF_ID, GF_PID, FNAME,"
+            " W_DEL_FLAG, LINK_UPDATE) "
+            " VALUES (?, ?, ?, 0, %d);",
+            link_consistency);
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out);
+
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1,
+                          &insert_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing insert "
+               "statement %s : %s",
+               insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind pargfid*/
+    ret = sqlite3_bind_text(insert_stmt, 2, pargfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent gfid %s "
+               ": %s",
+               pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind basename*/
+    ret = sqlite3_bind_text(insert_stmt, 3, basename, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding basename %s : %s", basename,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(insert_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared "
+               "stmt %s %s %s %s : %s",
+               gfid, pargfid, basename, insert_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(insert_stmt);
+    return ret;
 }
 
-
 static int
-gf_sql_update_link (gf_sql_connection_t  *sql_conn,
-                   char                 *gfid,
-                   char                 *pargfid,
-                   char                 *basename,
-                   char                 *old_pargfid,
-                   char                 *old_basename,
-                   gf_boolean_t         link_consistency,
-                   gf_boolean_t         ignore_errors)
+gf_sql_update_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid,
+                   char *basename, char *old_pargfid, char *old_basename,
+                   gf_boolean_t link_consistency, gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char insert_str[GFDB_SQL_STMT_SIZE] = "";
-
-        sprintf (insert_str, "INSERT INTO "
-                            GF_FILE_LINK_TABLE
-                            " (GF_ID, GF_PID, FNAME,"
-                            " W_DEL_FLAG, LINK_UPDATE) "
-                            " VALUES (? , ?, ?, 0, %d);",
-                            link_consistency);
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_pargfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_basename, out);
-
-        /*
-         *
-         * Delete the old link
-         *
-         * */
-         ret = gf_sql_delete_link (sql_conn, gfid, old_pargfid,
-                                old_basename, ignore_errors);
-        if (ret) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_DELETE_FAILED, "Failed deleting old link");
-                goto out;
-        }
-
-        /*
-         *
-         * insert new link
-         *
-         * */
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                                &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind new pargfid*/
-        ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "
-                        ": %s", pargfid,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind new basename*/
-        ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "
-                        "%s", basename,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-
-
-        ret = 0;
+    int ret = -1;
+    sqlite3_stmt *insert_stmt = NULL;
+    char insert_str[GFDB_SQL_STMT_SIZE] = "";
+
+    sprintf(insert_str,
+            "INSERT INTO " GF_FILE_LINK_TABLE
+            " (GF_ID, GF_PID, FNAME,"
+            " W_DEL_FLAG, LINK_UPDATE) "
+            " VALUES (? , ?, ?, 0, %d);",
+            link_consistency);
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, old_pargfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, old_basename, out);
+
+    /*
+     *
+     * Delete the old link
+     *
+     * */
+    ret = gf_sql_delete_link(sql_conn, gfid, old_pargfid, old_basename,
+                             ignore_errors);
+    if (ret) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_DELETE_FAILED, "Failed deleting old link");
+        goto out;
+    }
+
+    /*
+     *
+     * insert new link
+     *
+     * */
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1,
+                          &insert_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing insert "
+               "statement %s : %s",
+               insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind new pargfid*/
+    ret = sqlite3_bind_text(insert_stmt, 2, pargfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent gfid %s "
+               ": %s",
+               pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind new basename*/
+    ret = sqlite3_bind_text(insert_stmt, 3, basename, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding basename %s : "
+               "%s",
+               basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(insert_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", insert_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(insert_stmt);
+    return ret;
 }
 
 static int
-gf_sql_insert_write_wind_time (gf_sql_connection_t      *sql_conn,
-                                char                    *gfid,
-                                gfdb_time_t             *wind_time,
-                                gf_boolean_t            ignore_errors)
+gf_sql_insert_write_wind_time(gf_sql_connection_t *sql_conn, char *gfid,
+                              gfdb_time_t *wind_time,
+                              gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *insert_stmt = NULL;
-        char *insert_str = "INSERT INTO "
-                           GF_FILE_TABLE
-                           "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)"
-                           " VALUES (?, ?, ?, 0, 0);";
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, wind_time, out);
-
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,
-                        &insert_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind wind secs*/
-        ret = sqlite3_bind_int (insert_stmt, 2, wind_time->tv_sec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "secs %ld : %s", wind_time->tv_sec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind wind msecs*/
-        ret = sqlite3_bind_int (insert_stmt, 3, wind_time->tv_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "msecs %ld : %s", wind_time->tv_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt GFID:%s %s : %s",
-                        gfid, insert_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    sqlite3_stmt *insert_stmt = NULL;
+    char *insert_str = "INSERT INTO " GF_FILE_TABLE
+                       "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)"
+                       " VALUES (?, ?, ?, 0, 0);";
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, wind_time, out);
+
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1,
+                          &insert_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing insert "
+               "statement %s : %s",
+               insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind wind secs*/
+    ret = sqlite3_bind_int(insert_stmt, 2, wind_time->tv_sec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent wind "
+               "secs %ld : %s",
+               wind_time->tv_sec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind wind msecs*/
+    ret = sqlite3_bind_int(insert_stmt, 3, wind_time->tv_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent wind "
+               "msecs %ld : %s",
+               wind_time->tv_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(insert_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt GFID:%s %s : %s", gfid,
+               insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (insert_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(insert_stmt);
+    return ret;
 }
 
-
-
 /*Update write/read times for both wind and unwind*/
 static int
-gf_update_time (gf_sql_connection_t    *sql_conn,
-                char                    *gfid,
-                gfdb_time_t             *update_time,
-                gf_boolean_t            record_counter,
-                gf_boolean_t            is_wind,
-                gf_boolean_t            is_read,
-                gf_boolean_t            ignore_errors)
+gf_update_time(gf_sql_connection_t *sql_conn, char *gfid,
+               gfdb_time_t *update_time, gf_boolean_t record_counter,
+               gf_boolean_t is_wind, gf_boolean_t is_read,
+               gf_boolean_t ignore_errors)
 {
-        int ret = -1;
-        sqlite3_stmt *update_stmt = NULL;
-        char update_str[1024] = "";
-        char *freq_cntr_str = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, update_time, out);
-
-        /*
-         * Constructing the prepare statement string.
-         *
-         * */
-        /*For write time*/
-        if (!is_read) {
-                if (is_wind) {
-                        /*if record counter is on*/
-                        freq_cntr_str = (record_counter) ?
-                        ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" : "";
-
-                        /*Perfectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET W_SEC = ?, W_MSEC = ? "
-                                " %s"/*place for read freq counters*/
-                                " WHERE GF_ID = ? ;", freq_cntr_str);
-                } else {
-                        /*Perfectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET UW_SEC = ?, UW_MSEC = ? ;");
-                }
+    int ret = -1;
+    sqlite3_stmt *update_stmt = NULL;
+    char update_str[1024] = "";
+    char *freq_cntr_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, update_time, out);
+
+    /*
+     * Constructing the prepare statement string.
+     *
+     * */
+    /*For write time*/
+    if (!is_read) {
+        if (is_wind) {
+            /*if record counter is on*/
+            freq_cntr_str = (record_counter)
+                                ? ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1"
+                                : "";
+
+            /*Perfectly safe as we will not go array of bound*/
+            sprintf(update_str,
+                    "UPDATE " GF_FILE_TABLE
+                    " SET W_SEC = ?, W_MSEC = ? "
+                    " %s" /*place for read freq counters*/
+                    " WHERE GF_ID = ? ;",
+                    freq_cntr_str);
+        } else {
+            /*Perfectly safe as we will not go array of bound*/
+            sprintf(update_str,
+                    "UPDATE " GF_FILE_TABLE " SET UW_SEC = ?, UW_MSEC = ? ;");
         }
-        /*For Read Time update*/
-        else {
-                if (is_wind) {
-                        /*if record counter is on*/
-                        freq_cntr_str = (record_counter) ?
-                        ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" : "";
-
-                        /*Perfectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
-                                " SET W_READ_SEC = ?, W_READ_MSEC = ? "
-                                " %s"/*place for read freq counters*/
-                                " WHERE GF_ID = ? ;", freq_cntr_str);
-                } else {
-                        /*Perfectly safe as we will not go array of bound*/
-                        sprintf (update_str, "UPDATE "
-                                GF_FILE_TABLE
+    }
+    /*For Read Time update*/
+    else {
+        if (is_wind) {
+            /*if record counter is on*/
+            freq_cntr_str = (record_counter)
+                                ? ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1"
+                                : "";
+
+            /*Perfectly safe as we will not go array of bound*/
+            sprintf(update_str,
+                    "UPDATE " GF_FILE_TABLE
+                    " SET W_READ_SEC = ?, W_READ_MSEC = ? "
+                    " %s" /*place for read freq counters*/
+                    " WHERE GF_ID = ? ;",
+                    freq_cntr_str);
+        } else {
+            /*Perfectly safe as we will not go array of bound*/
+            sprintf(update_str, "UPDATE " GF_FILE_TABLE
                                 " SET UW_READ_SEC = ?, UW_READ_MSEC = ? ;");
-                }
-        }
-
-        /*Prepare statement*/
-        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,
-                                &update_stmt, 0);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "
-                        "statement %s : %s", update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind time secs*/
-        ret = sqlite3_bind_int (update_stmt, 1, update_time->tv_sec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "secs %ld : %s", update_time->tv_sec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Bind time msecs*/
-        ret = sqlite3_bind_int (update_stmt, 2, update_time->tv_usec);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "
-                        "msecs %ld : %s", update_time->tv_usec,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
         }
-
-        /*Bind gfid*/
-        ret = sqlite3_bind_text (update_stmt, 3, gfid, -1, NULL);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",
-                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        /*Execute the prepare statement*/
-        if (sqlite3_step (update_stmt) != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3,
-                        _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0,
-                        LG_MSG_EXEC_FAILED,
-                        "Failed executing the prepared stmt %s : %s",
-                        update_str,
-                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    }
+
+    /*Prepare statement*/
+    ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, update_str, -1,
+                          &update_stmt, 0);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED,
+               "Failed preparing insert "
+               "statement %s : %s",
+               update_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind time secs*/
+    ret = sqlite3_bind_int(update_stmt, 1, update_time->tv_sec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent wind "
+               "secs %ld : %s",
+               update_time->tv_sec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind time msecs*/
+    ret = sqlite3_bind_int(update_stmt, 2, update_time->tv_usec);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding parent wind "
+               "msecs %ld : %s",
+               update_time->tv_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Bind gfid*/
+    ret = sqlite3_bind_text(update_stmt, 3, gfid, -1, NULL);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED,
+               "Failed binding gfid %s : %s", gfid,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    /*Execute the prepare statement*/
+    if (sqlite3_step(update_stmt) != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors),
+               0, LG_MSG_EXEC_FAILED,
+               "Failed executing the prepared stmt %s : %s", update_str,
+               sqlite3_errmsg(sql_conn->sqlite3_db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        /*Free prepared statement*/
-        sqlite3_finalize (update_stmt);
-        return ret;
+    /*Free prepared statement*/
+    sqlite3_finalize(update_stmt);
+    return ret;
 }
 
 /******************************************************************************
@@ -736,394 +677,364 @@ out:
  * ****************************************************************************/
 
 int
-gf_sql_insert_wind (gf_sql_connection_t  *sql_conn,
-                   gfdb_db_record_t     *gfdb_db_record)
+gf_sql_insert_wind(gf_sql_connection_t *sql_conn,
+                   gfdb_db_record_t *gfdb_db_record)
 {
-        int ret                 = -1;
-        gfdb_time_t *modtime    = NULL;
-        char *pargfid_str       = NULL;
-        char *gfid_str          = NULL;
-        char *old_pargfid_str   = NULL;
-        gf_boolean_t its_wind   = _gf_true;/*remains true for this function*/
-
-
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
+    int ret = -1;
+    gfdb_time_t *modtime = NULL;
+    char *pargfid_str = NULL;
+    char *gfid_str = NULL;
+    char *old_pargfid_str = NULL;
+    gf_boolean_t its_wind = _gf_true; /*remains true for this function*/
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+
+    gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid));
+    if (!gfid_str) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Creating gfid string failed.");
+        goto out;
+    }
+
+    modtime = &gfdb_db_record->gfdb_wind_change_time;
+
+    /* handle all dentry based operations */
+    if (isdentryfop(gfdb_db_record->gfdb_fop_type)) {
+        /*Parent GFID is always set*/
+        pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
+        if (!pargfid_str) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+                   "Creating gfid string "
+                   "failed.");
+            goto out;
+        }
 
-        gfid_str = gf_strdup (uuid_utoa (gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
+        /* handle create, mknod */
+        if (isdentrycreatefop(gfdb_db_record->gfdb_fop_type)) {
+            /*insert link*/
+            ret = gf_sql_insert_link(
+                sql_conn, gfid_str, pargfid_str, gfdb_db_record->file_name,
+                gfdb_db_record->link_consistency, _gf_true);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_WARNING,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_INSERT_FAILED,
+                       "Failed "
+                       "inserting link in DB");
+                /* Even if link creation is failed we
+                 * continue with the creation of file record.
+                 * This covers to cases
+                 * 1) Lookup heal: If the file record from
+                 * gf_file_tb is deleted but the link record
+                 * still exist. Lookup heal will attempt a heal
+                 * with create_wind set. The link heal will fail
+                 * as there is already a record and if we don't
+                 * ignore the error we will not heal the
+                 * gf_file_tb.
+                 * 2) Rename file in cold tier: During a rename
+                 * of a file that is there in cold tier. We get
+                 * an link record created in hot tier for the
+                 * linkto file. When the file gets heated and
+                 * moves to hot tier there will be attempt from
+                 * ctr lookup heal to create link and file
+                 * record and If we don't ignore the error we
+                 * will not heal the gf_file_tb.
+                 * */
+            }
+            gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency;
+
+            /*
+             * Only for create/mknod insert wind time
+             * for the first time
+             * */
+            ret = gf_sql_insert_write_wind_time(sql_conn, gfid_str, modtime,
+                                                gfdb_db_record->ignore_errors);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_INSERT_FAILED,
+                       "Failed inserting wind time in DB");
                 goto out;
+            }
+            goto out;
         }
-
-        modtime = &gfdb_db_record->gfdb_wind_change_time;
-
-        /* handle all dentry based operations */
-        if (isdentryfop (gfdb_db_record->gfdb_fop_type)) {
-                /*Parent GFID is always set*/
-                pargfid_str = gf_strdup (uuid_utoa (gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating gfid string "
-                                "failed.");
-                        goto out;
-                }
-
-                /* handle create, mknod */
-                if (isdentrycreatefop (gfdb_db_record->gfdb_fop_type)) {
-                        /*insert link*/
-                        ret = gf_sql_insert_link(sql_conn,
-                                        gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name,
-                                        gfdb_db_record->link_consistency,
-                                        _gf_true);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_WARNING,
-                                                gfdb_db_record->ignore_errors),
-                                        0,
-                                        LG_MSG_INSERT_FAILED, "Failed "
-                                        "inserting link in DB");
-                                /* Even if link creation is failed we
-                                 * continue with the creation of file record.
-                                 * This covers to cases
-                                 * 1) Lookup heal: If the file record from
-                                 * gf_file_tb is deleted but the link record
-                                 * still exist. Lookup heal will attempt a heal
-                                 * with create_wind set. The link heal will fail
-                                 * as there is already a record and if we don't
-                                 * ignore the error we will not heal the
-                                 * gf_file_tb.
-                                 * 2) Rename file in cold tier: During a rename
-                                 * of a file that is there in cold tier. We get
-                                 * an link record created in hot tier for the
-                                 * linkto file. When the file gets heated and
-                                 * moves to hot tier there will be attempt from
-                                 * ctr lookup heal to create link and file
-                                 * record and If we don't ignore the error we
-                                 * will not heal the gf_file_tb.
-                                 * */
-                        }
-                        gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-
-                        /*
-                         * Only for create/mknod insert wind time
-                         * for the first time
-                         * */
-                        ret = gf_sql_insert_write_wind_time (sql_conn, gfid_str,
-                                        modtime, gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_INSERT_FAILED,
-                                        "Failed inserting wind time in DB");
-                                goto out;
-                        }
-                        goto out;
+        /*handle rename, link */
+        else {
+            /*rename*/
+            if (strlen(gfdb_db_record->old_file_name) != 0) {
+                old_pargfid_str = gf_strdup(
+                    uuid_utoa(gfdb_db_record->old_pargfid));
+                if (!old_pargfid_str) {
+                    gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                           LG_MSG_CREATE_FAILED,
+                           "Creating gfid string failed.");
+                    goto out;
                 }
-                /*handle rename, link */
-                else {
-                        /*rename*/
-                        if (strlen (gfdb_db_record->old_file_name) != 0) {
-                                old_pargfid_str = gf_strdup (uuid_utoa (
-                                                gfdb_db_record->old_pargfid));
-                                if (!old_pargfid_str) {
-                                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                                0, LG_MSG_CREATE_FAILED,
-                                                "Creating gfid string failed.");
-                                        goto out;
-                                }
-                                ret = gf_sql_update_link (sql_conn, gfid_str,
-                                                pargfid_str,
-                                                gfdb_db_record->file_name,
-                                                old_pargfid_str,
-                                                gfdb_db_record->old_file_name,
-                                                gfdb_db_record->
-                                                        link_consistency,
-                                                gfdb_db_record->ignore_errors);
-                                if (ret) {
-                                        gf_msg (GFDB_STR_SQLITE3,
-                                                _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                                0, LG_MSG_UPDATE_FAILED,
-                                                "Failed updating link");
-                                        goto out;
-                                }
-                                gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-                        }
-                        /*link*/
-                        else {
-                                ret = gf_sql_insert_link (sql_conn,
-                                                gfid_str, pargfid_str,
-                                                gfdb_db_record->file_name,
-                                                gfdb_db_record->
-                                                        link_consistency,
-                                                gfdb_db_record->ignore_errors);
-                                if (ret) {
-                                        gf_msg (GFDB_STR_SQLITE3,
-                                                _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                                0, LG_MSG_INSERT_FAILED,
-                                                "Failed inserting link in DB");
-                                        goto out;
-                                }
-                                gfdb_db_record->islinkupdate = gfdb_db_record->
-                                                        link_consistency;
-                        }
+                ret = gf_sql_update_link(
+                    sql_conn, gfid_str, pargfid_str, gfdb_db_record->file_name,
+                    old_pargfid_str, gfdb_db_record->old_file_name,
+                    gfdb_db_record->link_consistency,
+                    gfdb_db_record->ignore_errors);
+                if (ret) {
+                    gf_msg(GFDB_STR_SQLITE3,
+                           _gfdb_log_level(GF_LOG_ERROR,
+                                           gfdb_db_record->ignore_errors),
+                           0, LG_MSG_UPDATE_FAILED, "Failed updating link");
+                    goto out;
                 }
-        }
-
-        /* update times only when said!*/
-        if (gfdb_db_record->do_record_times) {
-                /*All fops update times read or write*/
-                ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                its_wind,
-                                isreadfop (gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
+                gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency;
+            }
+            /*link*/
+            else {
+                ret = gf_sql_insert_link(sql_conn, gfid_str, pargfid_str,
+                                         gfdb_db_record->file_name,
+                                         gfdb_db_record->link_consistency,
+                                         gfdb_db_record->ignore_errors);
                 if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                gfdb_db_record->ignore_errors), 0,
-                                LG_MSG_UPDATE_FAILED, "Failed update wind time"
-                                " in DB");
-                        goto out;
+                    gf_msg(GFDB_STR_SQLITE3,
+                           _gfdb_log_level(GF_LOG_ERROR,
+                                           gfdb_db_record->ignore_errors),
+                           0, LG_MSG_INSERT_FAILED,
+                           "Failed inserting link in DB");
+                    goto out;
                 }
+                gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency;
+            }
+        }
+    }
+
+    /* update times only when said!*/
+    if (gfdb_db_record->do_record_times) {
+        /*All fops update times read or write*/
+        ret = gf_update_time(sql_conn, gfid_str, modtime,
+                             gfdb_db_record->do_record_counters, its_wind,
+                             isreadfop(gfdb_db_record->gfdb_fop_type),
+                             gfdb_db_record->ignore_errors);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3,
+                   _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors),
+                   0, LG_MSG_UPDATE_FAILED,
+                   "Failed update wind time"
+                   " in DB");
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        GF_FREE (old_pargfid_str);
-        return ret;
+    GF_FREE(gfid_str);
+    GF_FREE(pargfid_str);
+    GF_FREE(old_pargfid_str);
+    return ret;
 }
 
-
-
-
 int
-gf_sql_insert_unwind (gf_sql_connection_t  *sql_conn,
-                     gfdb_db_record_t     *gfdb_db_record)
+gf_sql_insert_unwind(gf_sql_connection_t *sql_conn,
+                     gfdb_db_record_t *gfdb_db_record)
 {
-
-        int ret = -1;
-        gfdb_time_t *modtime    = NULL;
-        gf_boolean_t its_wind   = _gf_true;/*remains true for this function*/
-        char *gfid_str = NULL;
-        char *pargfid_str = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
-                goto out;
+    int ret = -1;
+    gfdb_time_t *modtime = NULL;
+    gf_boolean_t its_wind = _gf_true; /*remains true for this function*/
+    char *gfid_str = NULL;
+    char *pargfid_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+
+    gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid));
+    if (!gfid_str) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Creating gfid string failed.");
+        goto out;
+    }
+
+    /*Only update if recording unwind is set*/
+    if (gfdb_db_record->do_record_times &&
+        gfdb_db_record->do_record_uwind_time) {
+        modtime = &gfdb_db_record->gfdb_unwind_change_time;
+        ret = gf_update_time(sql_conn, gfid_str, modtime,
+                             gfdb_db_record->do_record_counters, (!its_wind),
+                             isreadfop(gfdb_db_record->gfdb_fop_type),
+                             gfdb_db_record->ignore_errors);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3,
+                   _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors),
+                   0, LG_MSG_UPDATE_FAILED,
+                   "Failed update unwind "
+                   "time in DB");
+            goto out;
         }
+    }
 
-        /*Only update if recording unwind is set*/
-        if (gfdb_db_record->do_record_times &&
-                gfdb_db_record->do_record_uwind_time) {
-                modtime = &gfdb_db_record->gfdb_unwind_change_time;
-                ret = gf_update_time (sql_conn, gfid_str, modtime,
-                        gfdb_db_record->do_record_counters,
-                        (!its_wind),
-                        isreadfop (gfdb_db_record->gfdb_fop_type),
-                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED, "Failed update unwind "
-                                "time in DB");
-                        goto out;
-                }
+    /*For link creation and changes we use link updated*/
+    if (gfdb_db_record->islinkupdate &&
+        isdentryfop(gfdb_db_record->gfdb_fop_type)) {
+        pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
+        if (!pargfid_str) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+                   "Creating pargfid_str string failed.");
+            goto out;
         }
 
-        /*For link creation and changes we use link updated*/
-        if (gfdb_db_record->islinkupdate &&
-                isdentryfop(gfdb_db_record->gfdb_fop_type)) {
-
-                pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED,
-                                "Creating pargfid_str string failed.");
-                        goto out;
-                }
-
-                ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name, 0, _gf_true,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED,
-                                "Failed updating link flags in unwind");
-                        goto out;
-                }
+        ret = gf_sql_update_link_flags(sql_conn, gfid_str, pargfid_str,
+                                       gfdb_db_record->file_name, 0, _gf_true,
+                                       gfdb_db_record->ignore_errors);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3,
+                   _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors),
+                   0, LG_MSG_UPDATE_FAILED,
+                   "Failed updating link flags in unwind");
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
+    GF_FREE(gfid_str);
+    GF_FREE(pargfid_str);
+    return ret;
 }
 
-
 int
-gf_sql_update_delete_wind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record)
+gf_sql_update_delete_wind(gf_sql_connection_t *sql_conn,
+                          gfdb_db_record_t *gfdb_db_record)
 {
-        int ret = -1;
-        char *gfid_str          = NULL;
-        char *pargfid_str       = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
-                goto out;
-        }
-
-        pargfid_str = gf_strdup (uuid_utoa(gfdb_db_record->pargfid));
-        if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating pargfid_str "
-                                "string failed.");
-                        goto out;
-        }
-
-        if (gfdb_db_record->link_consistency) {
-                ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name, 1,
-                                        _gf_false,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3,
-                                _gfdb_log_level (GF_LOG_ERROR,
-                                        gfdb_db_record->ignore_errors),
-                                0, LG_MSG_UPDATE_FAILED,
-                                "Failed updating link flags in wind");
-                        goto out;
-                }
+    int ret = -1;
+    char *gfid_str = NULL;
+    char *pargfid_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+
+    gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid));
+    if (!gfid_str) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Creating gfid string failed.");
+        goto out;
+    }
+
+    pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
+    if (!pargfid_str) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Creating pargfid_str "
+               "string failed.");
+        goto out;
+    }
+
+    if (gfdb_db_record->link_consistency) {
+        ret = gf_sql_update_link_flags(sql_conn, gfid_str, pargfid_str,
+                                       gfdb_db_record->file_name, 1, _gf_false,
+                                       gfdb_db_record->ignore_errors);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3,
+                   _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors),
+                   0, LG_MSG_UPDATE_FAILED,
+                   "Failed updating link flags in wind");
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
+    GF_FREE(gfid_str);
+    GF_FREE(pargfid_str);
+    return ret;
 }
 
 int
-gf_sql_delete_unwind (gf_sql_connection_t  *sql_conn,
-                          gfdb_db_record_t     *gfdb_db_record)
+gf_sql_delete_unwind(gf_sql_connection_t *sql_conn,
+                     gfdb_db_record_t *gfdb_db_record)
 {
-        int ret = -1;
-        char *gfid_str = NULL;
-        char *pargfid_str = NULL;
-        gfdb_time_t *modtime    = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-        gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
-        if (!gfid_str) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
-                        "Creating gfid string failed.");
-                goto out;
+    int ret = -1;
+    char *gfid_str = NULL;
+    char *pargfid_str = NULL;
+    gfdb_time_t *modtime = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
+
+    gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid));
+    if (!gfid_str) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+               "Creating gfid string failed.");
+        goto out;
+    }
+
+    /*Nuke all the entries for this GFID from DB*/
+    if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) {
+        gf_sql_delete_all(sql_conn, gfid_str, gfdb_db_record->ignore_errors);
+    }
+    /*Remove link entries only*/
+    else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) {
+        pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
+        if (!pargfid_str) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED,
+                   "Creating pargfid_str "
+                   "string failed.");
+            goto out;
         }
 
-        /*Nuke all the entries for this GFID from DB*/
-        if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) {
-                gf_sql_delete_all (sql_conn, gfid_str,
-                                gfdb_db_record->ignore_errors);
+        /* Special performance case:
+         * Updating wind time in unwind for delete. This is done here
+         * as in the wind path we will not know whether its the last
+         * link or not. For a last link there is not use to update any
+         * wind or unwind time!*/
+        if (gfdb_db_record->do_record_times) {
+            /*Update the wind write times*/
+            modtime = &gfdb_db_record->gfdb_wind_change_time;
+            ret = gf_update_time(sql_conn, gfid_str, modtime,
+                                 gfdb_db_record->do_record_counters, _gf_true,
+                                 isreadfop(gfdb_db_record->gfdb_fop_type),
+                                 gfdb_db_record->ignore_errors);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_UPDATE_FAILED,
+                       "Failed update wind time in DB");
+                goto out;
+            }
         }
-        /*Remove link entries only*/
-        else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) {
-
-                pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
-                if (!pargfid_str) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                0, LG_MSG_CREATE_FAILED, "Creating pargfid_str "
-                                "string failed.");
-                        goto out;
-                }
-
-                /* Special performance case:
-                 * Updating wind time in unwind for delete. This is done here
-                 * as in the wind path we will not know whether its the last
-                 * link or not. For a last link there is not use to update any
-                 * wind or unwind time!*/
-                if (gfdb_db_record->do_record_times) {
-                        /*Update the wind write times*/
-                        modtime = &gfdb_db_record->gfdb_wind_change_time;
-                        ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                _gf_true,
-                                isreadfop (gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_UPDATE_FAILED,
-                                        "Failed update wind time in DB");
-                                goto out;
-                        }
-                }
 
-                modtime = &gfdb_db_record->gfdb_unwind_change_time;
+        modtime = &gfdb_db_record->gfdb_unwind_change_time;
 
-                ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str,
-                                        gfdb_db_record->file_name,
-                                        gfdb_db_record->ignore_errors);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_DELETE_FAILED, "Failed deleting link");
-                        goto out;
-                }
+        ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str,
+                                 gfdb_db_record->file_name,
+                                 gfdb_db_record->ignore_errors);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DELETE_FAILED,
+                   "Failed deleting link");
+            goto out;
+        }
 
-                if (gfdb_db_record->do_record_times &&
-                        gfdb_db_record->do_record_uwind_time) {
-                        ret = gf_update_time (sql_conn, gfid_str, modtime,
-                                gfdb_db_record->do_record_counters,
-                                _gf_false,
-                                isreadfop(gfdb_db_record->gfdb_fop_type),
-                                gfdb_db_record->ignore_errors);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3,
-                                        _gfdb_log_level (GF_LOG_ERROR,
-                                                gfdb_db_record->ignore_errors),
-                                        0, LG_MSG_UPDATE_FAILED,
-                                        "Failed update unwind time in DB");
-                                goto out;
-                        }
-                }
-        } else {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                        0, LG_MSG_INVALID_UPLINK, "Invalid unlink option");
+        if (gfdb_db_record->do_record_times &&
+            gfdb_db_record->do_record_uwind_time) {
+            ret = gf_update_time(sql_conn, gfid_str, modtime,
+                                 gfdb_db_record->do_record_counters, _gf_false,
+                                 isreadfop(gfdb_db_record->gfdb_fop_type),
+                                 gfdb_db_record->ignore_errors);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3,
+                       _gfdb_log_level(GF_LOG_ERROR,
+                                       gfdb_db_record->ignore_errors),
+                       0, LG_MSG_UPDATE_FAILED,
+                       "Failed update unwind time in DB");
                 goto out;
+            }
         }
-        ret = 0;
+    } else {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_UPLINK,
+               "Invalid unlink option");
+        goto out;
+    }
+    ret = 0;
 out:
-        GF_FREE (gfid_str);
-        GF_FREE (pargfid_str);
-        return ret;
+    GF_FREE(gfid_str);
+    GF_FREE(pargfid_str);
+    return ret;
 }
 
 /******************************************************************************
@@ -1132,240 +1043,218 @@ out:
  *
  * ****************************************************************************/
 int
-gf_sql_query_function (sqlite3_stmt              *prep_stmt,
-                      gf_query_callback_t       query_callback,
-                      void                      *_query_cbk_args)
+gf_sql_query_function(sqlite3_stmt *prep_stmt,
+                      gf_query_callback_t query_callback, void *_query_cbk_args)
 {
-        int ret                                         = -1;
-        gfdb_query_record_t *query_record               = NULL;
-        char *text_column                               = NULL;
-        sqlite3 *db_conn                                = NULL;
-        uuid_t  prev_gfid                               = {0};
-        uuid_t  curr_gfid                               = {0};
-        uuid_t  pgfid                                   = {0};
-        char *base_name                                 = NULL;
-        gf_boolean_t is_first_record                    = _gf_true;
-        gf_boolean_t is_query_empty                     = _gf_true;
-
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, prep_stmt, out);
-        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, query_callback, out);
-
-        db_conn = sqlite3_db_handle(prep_stmt);
-
-        /*
-         * Loop to access queried rows
-         * Each db record will have 3 columns
-         * GFID, PGFID, FILE_NAME
-         *
-         * For file with multiple hard links we will get multiple query rows
-         * with the same GFID, but different PGID and FILE_NAME Combination
-         * For Example if a file with
-         *         GFID = 00000000-0000-0000-0000-000000000006
-         * has 3 hardlinks file1, file2 and file3 in 3 different folder
-         * with GFID's
-         * 00000000-0000-0000-0000-0000EFC00001,
-         * 00000000-0000-0000-0000-00000ABC0001 and
-         * 00000000-0000-0000-0000-00000ABC00CD
-         * Then there will be 3 records
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-0000EFC00001
-         *         FILE_NAME    : file1
-         *
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-00000ABC0001
-         *         FILE_NAME    : file2
-         *
-         *         GFID         : 00000000-0000-0000-0000-000000000006
-         *         PGFID        : 00000000-0000-0000-0000-00000ABC00CD
-         *         FILE_NAME    : file3
-         *
-         * This is retrieved and added to a single query_record
-         *
-         * query_record->gfid = 00000000-0000-0000-0000-000000000006
-         *                  ->link_info = {00000000-0000-0000-0000-0000EFC00001,
-         *                                 "file1"}
-         *                                  |
-         *                                  V
-         *             link_info = {00000000-0000-0000-0000-00000ABC0001,
-         *                                 "file2"}
-         *                                  |
-         *                                  V
-         *             link_info = {00000000-0000-0000-0000-00000ABC0001,
-         *                                 "file3",
-         *                                 list}
-         *
-         * This query record is sent to the registered query_callback()
-         *
-         * */
-        while ((ret = sqlite3_step (prep_stmt)) == SQLITE_ROW) {
-
-                if (sqlite3_column_count(prep_stmt) > 0) {
-
-                        is_query_empty = _gf_false;
-
-                        /*Retrieving GFID - column index is 0*/
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 0);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        "retrieve GFID");
-                                goto out;
-                        }
-                        ret = gf_uuid_parse (text_column, curr_gfid);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PARSE_FAILED, "Failed to parse "
-                                        "GFID");
-                                goto out;
-                        }
-
-                        /*
-                         * if the previous record was not of the current gfid
-                         * call the call_back function and send the
-                         * query record, which will have all the link_info
-                         * objects associated with this gfid
-                         *
-                         * */
-                        if (gf_uuid_compare (curr_gfid, prev_gfid) != 0) {
-
-                                /* If this is not the first record */
-                                if (!is_first_record) {
-                                        /*Call the call_back function provided*/
-                                        ret = query_callback (query_record,
-                                                        _query_cbk_args);
-                                        if (ret) {
-                                                gf_msg (GFDB_STR_SQLITE3,
-                                                        GF_LOG_ERROR, 0,
-                                                LG_MSG_QUERY_CALL_BACK_FAILED,
-                                                        "Query call back "
-                                                        "failed");
-                                                goto out;
-                                        }
-
-                                }
-
-                                /*Clear the query record*/
-                                gfdb_query_record_free (query_record);
-                                query_record = NULL;
-                                query_record = gfdb_query_record_new ();
-                                if (!query_record) {
-                                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
-                                                0, LG_MSG_CREATE_FAILED,
-                                                "Failed to create "
-                                                "query_record");
-                                        goto out;
-                                }
-
-                                gf_uuid_copy(query_record->gfid,
-                                                                curr_gfid);
-                                gf_uuid_copy(prev_gfid, curr_gfid);
-
-                        }
-
-                        /* Get PGFID */
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 1);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " retrieve GF_ID");
-                                goto out;
-                        }
-                        ret = gf_uuid_parse (text_column, pgfid);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_PARSE_FAILED, "Failed to parse "
-                                        "GF_ID");
-                                goto out;
-                        }
-
-                        /* Get Base name */
-                        text_column = (char *)sqlite3_column_text
-                                                        (prep_stmt, 2);
-                        if (!text_column) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " retrieve GF_ID");
-                                goto out;
-                        }
-                        base_name = text_column;
-
-
-                        /* Add link info to the list */
-                        ret = gfdb_add_link_to_query_record (query_record,
-                                                         pgfid, base_name);
-                        if (ret) {
-                                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                        LG_MSG_GET_ID_FAILED, "Failed to"
-                                        " add link info to query record");
-                                goto out;
-                        }
-
-                        is_first_record = _gf_false;
+    int ret = -1;
+    gfdb_query_record_t *query_record = NULL;
+    char *text_column = NULL;
+    sqlite3 *db_conn = NULL;
+    uuid_t prev_gfid = {0};
+    uuid_t curr_gfid = {0};
+    uuid_t pgfid = {0};
+    char *base_name = NULL;
+    gf_boolean_t is_first_record = _gf_true;
+    gf_boolean_t is_query_empty = _gf_true;
+
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, prep_stmt, out);
+    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out);
+
+    db_conn = sqlite3_db_handle(prep_stmt);
+
+    /*
+     * Loop to access queried rows
+     * Each db record will have 3 columns
+     * GFID, PGFID, FILE_NAME
+     *
+     * For file with multiple hard links we will get multiple query rows
+     * with the same GFID, but different PGID and FILE_NAME Combination
+     * For Example if a file with
+     *         GFID = 00000000-0000-0000-0000-000000000006
+     * has 3 hardlinks file1, file2 and file3 in 3 different folder
+     * with GFID's
+     * 00000000-0000-0000-0000-0000EFC00001,
+     * 00000000-0000-0000-0000-00000ABC0001 and
+     * 00000000-0000-0000-0000-00000ABC00CD
+     * Then there will be 3 records
+     *         GFID         : 00000000-0000-0000-0000-000000000006
+     *         PGFID        : 00000000-0000-0000-0000-0000EFC00001
+     *         FILE_NAME    : file1
+     *
+     *         GFID         : 00000000-0000-0000-0000-000000000006
+     *         PGFID        : 00000000-0000-0000-0000-00000ABC0001
+     *         FILE_NAME    : file2
+     *
+     *         GFID         : 00000000-0000-0000-0000-000000000006
+     *         PGFID        : 00000000-0000-0000-0000-00000ABC00CD
+     *         FILE_NAME    : file3
+     *
+     * This is retrieved and added to a single query_record
+     *
+     * query_record->gfid = 00000000-0000-0000-0000-000000000006
+     *                  ->link_info = {00000000-0000-0000-0000-0000EFC00001,
+     *                                 "file1"}
+     *                                  |
+     *                                  V
+     *             link_info = {00000000-0000-0000-0000-00000ABC0001,
+     *                                 "file2"}
+     *                                  |
+     *                                  V
+     *             link_info = {00000000-0000-0000-0000-00000ABC0001,
+     *                                 "file3",
+     *                                 list}
+     *
+     * This query record is sent to the registered query_callback()
+     *
+     * */
+    while ((ret = sqlite3_step(prep_stmt)) == SQLITE_ROW) {
+        if (sqlite3_column_count(prep_stmt) > 0) {
+            is_query_empty = _gf_false;
+
+            /*Retrieving GFID - column index is 0*/
+            text_column = (char *)sqlite3_column_text(prep_stmt, 0);
+            if (!text_column) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED,
+                       "Failed to"
+                       "retrieve GFID");
+                goto out;
+            }
+            ret = gf_uuid_parse(text_column, curr_gfid);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PARSE_FAILED,
+                       "Failed to parse "
+                       "GFID");
+                goto out;
+            }
+
+            /*
+             * if the previous record was not of the current gfid
+             * call the call_back function and send the
+             * query record, which will have all the link_info
+             * objects associated with this gfid
+             *
+             * */
+            if (gf_uuid_compare(curr_gfid, prev_gfid) != 0) {
+                /* If this is not the first record */
+                if (!is_first_record) {
+                    /*Call the call_back function provided*/
+                    ret = query_callback(query_record, _query_cbk_args);
+                    if (ret) {
+                        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                               LG_MSG_QUERY_CALL_BACK_FAILED,
+                               "Query call back "
+                               "failed");
+                        goto out;
+                    }
+                }
 
+                /*Clear the query record*/
+                gfdb_query_record_free(query_record);
+                query_record = NULL;
+                query_record = gfdb_query_record_new();
+                if (!query_record) {
+                    gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                           LG_MSG_CREATE_FAILED,
+                           "Failed to create "
+                           "query_record");
+                    goto out;
                 }
 
-        }
+                gf_uuid_copy(query_record->gfid, curr_gfid);
+                gf_uuid_copy(prev_gfid, curr_gfid);
+            }
 
-        if (ret != SQLITE_DONE) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                        LG_MSG_GET_RECORD_FAILED, "Failed to retrieve records "
-                        "from db : %s", sqlite3_errmsg (db_conn));
-                ret = -1;
+            /* Get PGFID */
+            text_column = (char *)sqlite3_column_text(prep_stmt, 1);
+            if (!text_column) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED,
+                       "Failed to"
+                       " retrieve GF_ID");
                 goto out;
-        }
-
+            }
+            ret = gf_uuid_parse(text_column, pgfid);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PARSE_FAILED,
+                       "Failed to parse "
+                       "GF_ID");
+                goto out;
+            }
+
+            /* Get Base name */
+            text_column = (char *)sqlite3_column_text(prep_stmt, 2);
+            if (!text_column) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED,
+                       "Failed to"
+                       " retrieve GF_ID");
+                goto out;
+            }
+            base_name = text_column;
+
+            /* Add link info to the list */
+            ret = gfdb_add_link_to_query_record(query_record, pgfid, base_name);
+            if (ret) {
+                gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED,
+                       "Failed to"
+                       " add link info to query record");
+                goto out;
+            }
 
-        if (!is_query_empty) {
-                /*
-                 * Call the call_back function for the last record from the
-                 * Database
-                 * */
-                ret = query_callback (query_record, _query_cbk_args);
-                if (ret) {
-                        gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
-                                LG_MSG_QUERY_CALL_BACK_FAILED,
-                                "Query call back failed");
-                        goto out;
-                }
+            is_first_record = _gf_false;
         }
+    }
+
+    if (ret != SQLITE_DONE) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED,
+               "Failed to retrieve records "
+               "from db : %s",
+               sqlite3_errmsg(db_conn));
+        ret = -1;
+        goto out;
+    }
+
+    if (!is_query_empty) {
+        /*
+         * Call the call_back function for the last record from the
+         * Database
+         * */
+        ret = query_callback(query_record, _query_cbk_args);
+        if (ret) {
+            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
+                   LG_MSG_QUERY_CALL_BACK_FAILED, "Query call back failed");
+            goto out;
+        }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        gfdb_query_record_free (query_record);
-        query_record = NULL;
-        return ret;
+    gfdb_query_record_free(query_record);
+    query_record = NULL;
+    return ret;
 }
 
-
-
 int
-gf_sql_clear_counters (gf_sql_connection_t *sql_conn)
+gf_sql_clear_counters(gf_sql_connection_t *sql_conn)
 {
-        int ret                 = -1;
-        char *sql_strerror      = NULL;
-        char *query_str         = NULL;
-
-        CHECK_SQL_CONN (sql_conn, out);
-
-        query_str = "UPDATE "
-                    GF_FILE_TABLE
-                    " SET " GF_COL_READ_FREQ_CNTR " = 0 , "
-                    GF_COL_WRITE_FREQ_CNTR " = 0 ;";
-
-        ret = sqlite3_exec (sql_conn->sqlite3_db_conn, query_str, NULL, NULL,
-                                &sql_strerror);
-        if (ret != SQLITE_OK) {
-                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
-                        "Failed to execute: %s : %s",
-                        query_str, sql_strerror);
-                sqlite3_free (sql_strerror);
-                        ret = -1;
-                        goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char *sql_strerror = NULL;
+    char *query_str = NULL;
+
+    CHECK_SQL_CONN(sql_conn, out);
+
+    query_str = "UPDATE " GF_FILE_TABLE " SET " GF_COL_READ_FREQ_CNTR
+                " = 0 , " GF_COL_WRITE_FREQ_CNTR " = 0 ;";
+
+    ret = sqlite3_exec(sql_conn->sqlite3_db_conn, query_str, NULL, NULL,
+                       &sql_strerror);
+    if (ret != SQLITE_OK) {
+        gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,
+               "Failed to execute: %s : %s", query_str, sql_strerror);
+        sqlite3_free(sql_strerror);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/gidcache.c b/libglusterfs/src/gidcache.c
index f2d98abefc3..b9fdb9a39be 100644
--- a/libglusterfs/src/gidcache.c
+++ b/libglusterfs/src/gidcache.c
@@ -16,37 +16,39 @@
  * out after a configurable interval.  Hardly rocket science, but lots of
  * details to worry about.
  */
-#define BUCKET_START(p,n)       ((p) + ((n) * AUX_GID_CACHE_ASSOC))
+#define BUCKET_START(p, n) ((p) + ((n)*AUX_GID_CACHE_ASSOC))
 
 /*
  * Initialize the cache.
  */
-int gid_cache_init(gid_cache_t *cache, uint32_t timeout)
+int
+gid_cache_init(gid_cache_t *cache, uint32_t timeout)
 {
-	if (!cache)
-		return -1;
+    if (!cache)
+        return -1;
 
-	LOCK_INIT(&cache->gc_lock);
-	cache->gc_max_age = timeout;
-	cache->gc_nbuckets = AUX_GID_CACHE_BUCKETS;
-	memset(cache->gc_cache, 0, sizeof(gid_list_t) * AUX_GID_CACHE_SIZE);
+    LOCK_INIT(&cache->gc_lock);
+    cache->gc_max_age = timeout;
+    cache->gc_nbuckets = AUX_GID_CACHE_BUCKETS;
+    memset(cache->gc_cache, 0, sizeof(gid_list_t) * AUX_GID_CACHE_SIZE);
 
-	return 0;
+    return 0;
 }
 
 /*
  * Reconfigure the cache timeout.
  */
-int gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
+int
+gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
 {
-        if (!cache)
-                return -1;
+    if (!cache)
+        return -1;
 
-        LOCK(&cache->gc_lock);
-        cache->gc_max_age = timeout;
-        UNLOCK(&cache->gc_lock);
+    LOCK(&cache->gc_lock);
+    cache->gc_max_age = timeout;
+    UNLOCK(&cache->gc_lock);
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -54,153 +56,155 @@ int gid_cache_reconf(gid_cache_t *cache, uint32_t timeout)
  * an additional allocation and memory copy. The caller should copy the data and
  * release (unlock) the cache as soon as possible.
  */
-const gid_list_t *gid_cache_lookup(gid_cache_t *cache, uint64_t id,
-				   uint64_t uid, uint64_t gid)
+const gid_list_t *
+gid_cache_lookup(gid_cache_t *cache, uint64_t id, uint64_t uid, uint64_t gid)
 {
-	int bucket;
-	int i;
-	time_t now;
-	const gid_list_t *agl;
-
-	LOCK(&cache->gc_lock);
-	now = time(NULL);
-	bucket = id % cache->gc_nbuckets;
-	agl = BUCKET_START(cache->gc_cache, bucket);
-	for (i = 0; i < AUX_GID_CACHE_ASSOC; i++, agl++) {
-		if (!agl->gl_list)
-			continue;
-		if (agl->gl_id != id)
-			continue;
-
-		/*
-		  @uid and @gid reflect the latest UID/GID of the
-		   process performing the syscall (taken from frame->root).
-
-		   If the UID and GID has changed for the PID since the
-		   time we cached it, we should treat the cache as having
-		   stale values and query them freshly.
-		*/
-		if (agl->gl_uid != uid || agl->gl_gid != gid)
-			break;
-
-		/*
-		 * We don't put new entries in the cache when expiration=0, but
-		 * there might be entries still in there if expiration was
-		 * changed very recently.  Writing the check this way ensures
-		 * that they're not used.
-		 */
-		if (now < agl->gl_deadline) {
-			return agl;
-		}
-
-		/*
-		 * We're not going to find any more UID matches, and reaping
-		 * is handled further down to maintain LRU order.
-		 */
-		break;
-	}
-	UNLOCK(&cache->gc_lock);
-	return NULL;
+    int bucket;
+    int i;
+    time_t now;
+    const gid_list_t *agl;
+
+    LOCK(&cache->gc_lock);
+    now = time(NULL);
+    bucket = id % cache->gc_nbuckets;
+    agl = BUCKET_START(cache->gc_cache, bucket);
+    for (i = 0; i < AUX_GID_CACHE_ASSOC; i++, agl++) {
+        if (!agl->gl_list)
+            continue;
+        if (agl->gl_id != id)
+            continue;
+
+        /*
+          @uid and @gid reflect the latest UID/GID of the
+           process performing the syscall (taken from frame->root).
+
+           If the UID and GID has changed for the PID since the
+           time we cached it, we should treat the cache as having
+           stale values and query them freshly.
+        */
+        if (agl->gl_uid != uid || agl->gl_gid != gid)
+            break;
+
+        /*
+         * We don't put new entries in the cache when expiration=0, but
+         * there might be entries still in there if expiration was
+         * changed very recently.  Writing the check this way ensures
+         * that they're not used.
+         */
+        if (now < agl->gl_deadline) {
+            return agl;
+        }
+
+        /*
+         * We're not going to find any more UID matches, and reaping
+         * is handled further down to maintain LRU order.
+         */
+        break;
+    }
+    UNLOCK(&cache->gc_lock);
+    return NULL;
 }
 
 /*
  * Release an entry found via lookup.
  */
-void gid_cache_release(gid_cache_t *cache, const gid_list_t *agl)
+void
+gid_cache_release(gid_cache_t *cache, const gid_list_t *agl)
 {
-	UNLOCK(&cache->gc_lock);
+    UNLOCK(&cache->gc_lock);
 }
 
 /*
  * Add a new list entry to the cache. If an entry for this ID already exists,
  * update it.
  */
-int gid_cache_add(gid_cache_t *cache, gid_list_t *gl)
+int
+gid_cache_add(gid_cache_t *cache, gid_list_t *gl)
 {
-	gid_list_t *agl;
-	int bucket;
-	int i;
-	time_t now;
-
-	if (!gl || !gl->gl_list)
-		return -1;
-
-	if (!cache->gc_max_age)
-		return 0;
-
-	LOCK(&cache->gc_lock);
-	now = time(NULL);
-
-	/*
-	 * Scan for the first free entry or one that matches this id. The id
-	 * check is added to address a bug where the cache might contain an
-	 * expired entry for this id. Since lookup occurs in LRU order and
-	 * does not reclaim entries, it will always return failure on discovery
-	 * of an expired entry. This leads to duplicate entries being added,
-	 * which still do not satisfy lookups until the expired entry (and
-	 * everything before it) is reclaimed.
-	 *
-	 * We address this through reuse of an entry already allocated to this
-	 * id, whether expired or not, since we have obviously already received
-	 * more recent data. The entry is repopulated with the new data and a new
-	 * deadline and is pushed forward to reside as the last populated entry in
-	 * the bucket.
-	 */
-	bucket = gl->gl_id % cache->gc_nbuckets;
-	agl = BUCKET_START(cache->gc_cache, bucket);
-	for (i = 0; i < AUX_GID_CACHE_ASSOC; ++i, ++agl) {
-		if (agl->gl_id == gl->gl_id)
-			break;
-		if (!agl->gl_list)
-			break;
-	}
-
-	/*
-	 * The way we allocate free entries naturally places the newest
-	 * ones at the highest indices, so evicting the lowest makes
-	 * sense, but that also means we can't just replace it with the
-	 * one that caused the eviction.  That would cause us to thrash
-	 * the first entry while others remain idle.  Therefore, we
-	 * need to slide the other entries down and add the new one at
-	 * the end just as if the *last* slot had been free.
-	 *
-	 * Deadline expiration is also handled here, since the oldest
-	 * expired entry will be in the first position.  This does mean
-	 * the bucket can stay full of expired entries if we're idle
-	 * but, if the small amount of extra memory or scan time before
-	 * we decide to evict someone ever become issues, we could
-	 * easily add a reaper thread.
-	 */
-
-	if (i >= AUX_GID_CACHE_ASSOC) {
-		/* cache full, evict the first (LRU) entry */
-		i = 0;
-		agl = BUCKET_START(cache->gc_cache, bucket);
-		GF_FREE(agl->gl_list);
-	} else if (agl->gl_list) {
-		/* evict the old entry we plan to reuse */
-		GF_FREE(agl->gl_list);
-	}
-
-	/*
-	 * If we have evicted an entry, slide the subsequent populated entries
-	 * back and populate the last entry.
-	 */
-	for (; i < AUX_GID_CACHE_ASSOC - 1; i++) {
-		if (!agl[1].gl_list)
-			break;
-		agl[0] = agl[1];
-		agl++;
-	}
-
-	agl->gl_id = gl->gl_id;
-	agl->gl_uid = gl->gl_uid;
-	agl->gl_gid = gl->gl_gid;
-	agl->gl_count = gl->gl_count;
-	agl->gl_list = gl->gl_list;
-	agl->gl_deadline = now + cache->gc_max_age;
-
-	UNLOCK(&cache->gc_lock);
-
-	return 1;
+    gid_list_t *agl;
+    int bucket;
+    int i;
+    time_t now;
+
+    if (!gl || !gl->gl_list)
+        return -1;
+
+    if (!cache->gc_max_age)
+        return 0;
+
+    LOCK(&cache->gc_lock);
+    now = time(NULL);
+
+    /*
+     * Scan for the first free entry or one that matches this id. The id
+     * check is added to address a bug where the cache might contain an
+     * expired entry for this id. Since lookup occurs in LRU order and
+     * does not reclaim entries, it will always return failure on discovery
+     * of an expired entry. This leads to duplicate entries being added,
+     * which still do not satisfy lookups until the expired entry (and
+     * everything before it) is reclaimed.
+     *
+     * We address this through reuse of an entry already allocated to this
+     * id, whether expired or not, since we have obviously already received
+     * more recent data. The entry is repopulated with the new data and a new
+     * deadline and is pushed forward to reside as the last populated entry in
+     * the bucket.
+     */
+    bucket = gl->gl_id % cache->gc_nbuckets;
+    agl = BUCKET_START(cache->gc_cache, bucket);
+    for (i = 0; i < AUX_GID_CACHE_ASSOC; ++i, ++agl) {
+        if (agl->gl_id == gl->gl_id)
+            break;
+        if (!agl->gl_list)
+            break;
+    }
+
+    /*
+     * The way we allocate free entries naturally places the newest
+     * ones at the highest indices, so evicting the lowest makes
+     * sense, but that also means we can't just replace it with the
+     * one that caused the eviction.  That would cause us to thrash
+     * the first entry while others remain idle.  Therefore, we
+     * need to slide the other entries down and add the new one at
+     * the end just as if the *last* slot had been free.
+     *
+     * Deadline expiration is also handled here, since the oldest
+     * expired entry will be in the first position.  This does mean
+     * the bucket can stay full of expired entries if we're idle
+     * but, if the small amount of extra memory or scan time before
+     * we decide to evict someone ever become issues, we could
+     * easily add a reaper thread.
+     */
+
+    if (i >= AUX_GID_CACHE_ASSOC) {
+        /* cache full, evict the first (LRU) entry */
+        i = 0;
+        agl = BUCKET_START(cache->gc_cache, bucket);
+        GF_FREE(agl->gl_list);
+    } else if (agl->gl_list) {
+        /* evict the old entry we plan to reuse */
+        GF_FREE(agl->gl_list);
+    }
+
+    /*
+     * If we have evicted an entry, slide the subsequent populated entries
+     * back and populate the last entry.
+     */
+    for (; i < AUX_GID_CACHE_ASSOC - 1; i++) {
+        if (!agl[1].gl_list)
+            break;
+        agl[0] = agl[1];
+        agl++;
+    }
+
+    agl->gl_id = gl->gl_id;
+    agl->gl_uid = gl->gl_uid;
+    agl->gl_gid = gl->gl_gid;
+    agl->gl_count = gl->gl_count;
+    agl->gl_list = gl->gl_list;
+    agl->gl_deadline = now + cache->gc_max_age;
+
+    UNLOCK(&cache->gc_lock);
+
+    return 1;
 }
diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c
index 3506d482bda..98990460c86 100644
--- a/libglusterfs/src/globals.c
+++ b/libglusterfs/src/globals.c
@@ -19,75 +19,75 @@
 #include "upcall-utils.h"
 
 const char *gf_fop_list[GF_FOP_MAXVALUE] = {
-        [GF_FOP_NULL]        = "NULL",
-        [GF_FOP_STAT]        = "STAT",
-        [GF_FOP_READLINK]    = "READLINK",
-        [GF_FOP_MKNOD]       = "MKNOD",
-        [GF_FOP_MKDIR]       = "MKDIR",
-        [GF_FOP_UNLINK]      = "UNLINK",
-        [GF_FOP_RMDIR]       = "RMDIR",
-        [GF_FOP_SYMLINK]     = "SYMLINK",
-        [GF_FOP_RENAME]      = "RENAME",
-        [GF_FOP_LINK]        = "LINK",
-        [GF_FOP_TRUNCATE]    = "TRUNCATE",
-        [GF_FOP_OPEN]        = "OPEN",
-        [GF_FOP_READ]        = "READ",
-        [GF_FOP_WRITE]       = "WRITE",
-        [GF_FOP_STATFS]      = "STATFS",
-        [GF_FOP_FLUSH]       = "FLUSH",
-        [GF_FOP_FSYNC]       = "FSYNC",
-        [GF_FOP_SETXATTR]    = "SETXATTR",
-        [GF_FOP_GETXATTR]    = "GETXATTR",
-        [GF_FOP_REMOVEXATTR] = "REMOVEXATTR",
-        [GF_FOP_OPENDIR]     = "OPENDIR",
-        [GF_FOP_FSYNCDIR]    = "FSYNCDIR",
-        [GF_FOP_ACCESS]      = "ACCESS",
-        [GF_FOP_CREATE]      = "CREATE",
-        [GF_FOP_FTRUNCATE]   = "FTRUNCATE",
-        [GF_FOP_FSTAT]       = "FSTAT",
-        [GF_FOP_LK]          = "LK",
-        [GF_FOP_LOOKUP]      = "LOOKUP",
-        [GF_FOP_READDIR]     = "READDIR",
-        [GF_FOP_INODELK]     = "INODELK",
-        [GF_FOP_FINODELK]    = "FINODELK",
-        [GF_FOP_ENTRYLK]     = "ENTRYLK",
-        [GF_FOP_FENTRYLK]    = "FENTRYLK",
-        [GF_FOP_XATTROP]     = "XATTROP",
-        [GF_FOP_FXATTROP]    = "FXATTROP",
-        [GF_FOP_FSETXATTR]   = "FSETXATTR",
-        [GF_FOP_FGETXATTR]   = "FGETXATTR",
-        [GF_FOP_RCHECKSUM]   = "RCHECKSUM",
-        [GF_FOP_SETATTR]     = "SETATTR",
-        [GF_FOP_FSETATTR]    = "FSETATTR",
-        [GF_FOP_READDIRP]    = "READDIRP",
-        [GF_FOP_GETSPEC]     = "GETSPEC",
-        [GF_FOP_FORGET]      = "FORGET",
-        [GF_FOP_RELEASE]     = "RELEASE",
-        [GF_FOP_RELEASEDIR]  = "RELEASEDIR",
-        [GF_FOP_FREMOVEXATTR]= "FREMOVEXATTR",
-	[GF_FOP_FALLOCATE]   = "FALLOCATE",
-	[GF_FOP_DISCARD]     = "DISCARD",
-        [GF_FOP_ZEROFILL]    = "ZEROFILL",
-        [GF_FOP_IPC]         = "IPC",
-        [GF_FOP_SEEK]        = "SEEK",
-        [GF_FOP_LEASE]       = "LEASE",
-        [GF_FOP_COMPOUND]    = "COMPOUND",
-        [GF_FOP_GETACTIVELK] = "GETACTIVELK",
-        [GF_FOP_SETACTIVELK] = "SETACTIVELK",
-        [GF_FOP_PUT]         = "PUT",
-        [GF_FOP_ICREATE]     = "ICREATE",
-        [GF_FOP_NAMELINK]    = "NAMELINK",
+    [GF_FOP_NULL] = "NULL",
+    [GF_FOP_STAT] = "STAT",
+    [GF_FOP_READLINK] = "READLINK",
+    [GF_FOP_MKNOD] = "MKNOD",
+    [GF_FOP_MKDIR] = "MKDIR",
+    [GF_FOP_UNLINK] = "UNLINK",
+    [GF_FOP_RMDIR] = "RMDIR",
+    [GF_FOP_SYMLINK] = "SYMLINK",
+    [GF_FOP_RENAME] = "RENAME",
+    [GF_FOP_LINK] = "LINK",
+    [GF_FOP_TRUNCATE] = "TRUNCATE",
+    [GF_FOP_OPEN] = "OPEN",
+    [GF_FOP_READ] = "READ",
+    [GF_FOP_WRITE] = "WRITE",
+    [GF_FOP_STATFS] = "STATFS",
+    [GF_FOP_FLUSH] = "FLUSH",
+    [GF_FOP_FSYNC] = "FSYNC",
+    [GF_FOP_SETXATTR] = "SETXATTR",
+    [GF_FOP_GETXATTR] = "GETXATTR",
+    [GF_FOP_REMOVEXATTR] = "REMOVEXATTR",
+    [GF_FOP_OPENDIR] = "OPENDIR",
+    [GF_FOP_FSYNCDIR] = "FSYNCDIR",
+    [GF_FOP_ACCESS] = "ACCESS",
+    [GF_FOP_CREATE] = "CREATE",
+    [GF_FOP_FTRUNCATE] = "FTRUNCATE",
+    [GF_FOP_FSTAT] = "FSTAT",
+    [GF_FOP_LK] = "LK",
+    [GF_FOP_LOOKUP] = "LOOKUP",
+    [GF_FOP_READDIR] = "READDIR",
+    [GF_FOP_INODELK] = "INODELK",
+    [GF_FOP_FINODELK] = "FINODELK",
+    [GF_FOP_ENTRYLK] = "ENTRYLK",
+    [GF_FOP_FENTRYLK] = "FENTRYLK",
+    [GF_FOP_XATTROP] = "XATTROP",
+    [GF_FOP_FXATTROP] = "FXATTROP",
+    [GF_FOP_FSETXATTR] = "FSETXATTR",
+    [GF_FOP_FGETXATTR] = "FGETXATTR",
+    [GF_FOP_RCHECKSUM] = "RCHECKSUM",
+    [GF_FOP_SETATTR] = "SETATTR",
+    [GF_FOP_FSETATTR] = "FSETATTR",
+    [GF_FOP_READDIRP] = "READDIRP",
+    [GF_FOP_GETSPEC] = "GETSPEC",
+    [GF_FOP_FORGET] = "FORGET",
+    [GF_FOP_RELEASE] = "RELEASE",
+    [GF_FOP_RELEASEDIR] = "RELEASEDIR",
+    [GF_FOP_FREMOVEXATTR] = "FREMOVEXATTR",
+    [GF_FOP_FALLOCATE] = "FALLOCATE",
+    [GF_FOP_DISCARD] = "DISCARD",
+    [GF_FOP_ZEROFILL] = "ZEROFILL",
+    [GF_FOP_IPC] = "IPC",
+    [GF_FOP_SEEK] = "SEEK",
+    [GF_FOP_LEASE] = "LEASE",
+    [GF_FOP_COMPOUND] = "COMPOUND",
+    [GF_FOP_GETACTIVELK] = "GETACTIVELK",
+    [GF_FOP_SETACTIVELK] = "SETACTIVELK",
+    [GF_FOP_PUT] = "PUT",
+    [GF_FOP_ICREATE] = "ICREATE",
+    [GF_FOP_NAMELINK] = "NAMELINK",
 };
 
 const char *gf_upcall_list[GF_UPCALL_FLAGS_MAXVALUE] = {
-        [GF_UPCALL_NULL] = "NULL",
-        [GF_UPCALL] = "UPCALL",
-        [GF_UPCALL_CI_STAT] = "CI_IATT",
-        [GF_UPCALL_CI_XATTR] = "CI_XATTR",
-        [GF_UPCALL_CI_RENAME] = "CI_RENAME",
-        [GF_UPCALL_CI_NLINK] = "CI_UNLINK",
-        [GF_UPCALL_CI_FORGET] = "CI_FORGET",
-        [GF_UPCALL_LEASE_RECALL] = "LEASE_RECALL",
+    [GF_UPCALL_NULL] = "NULL",
+    [GF_UPCALL] = "UPCALL",
+    [GF_UPCALL_CI_STAT] = "CI_IATT",
+    [GF_UPCALL_CI_XATTR] = "CI_XATTR",
+    [GF_UPCALL_CI_RENAME] = "CI_RENAME",
+    [GF_UPCALL_CI_NLINK] = "CI_UNLINK",
+    [GF_UPCALL_CI_FORGET] = "CI_FORGET",
+    [GF_UPCALL_LEASE_RECALL] = "LEASE_RECALL",
 };
 
 /* THIS */
@@ -101,461 +101,452 @@ xlator_t global_xlator;
 static pthread_key_t this_xlator_key;
 static pthread_key_t synctask_key;
 static pthread_key_t uuid_buf_key;
-static char          global_uuid_buf[GF_UUID_BUF_SIZE];
+static char global_uuid_buf[GF_UUID_BUF_SIZE];
 static pthread_key_t lkowner_buf_key;
-static char          global_lkowner_buf[GF_LKOWNER_BUF_SIZE];
+static char global_lkowner_buf[GF_LKOWNER_BUF_SIZE];
 static pthread_key_t leaseid_buf_key;
 static int gf_global_mem_acct_enable = 1;
 static pthread_once_t globals_inited = PTHREAD_ONCE_INIT;
 
-
 int
-gf_global_mem_acct_enable_get (void)
+gf_global_mem_acct_enable_get(void)
 {
-	return gf_global_mem_acct_enable;
+    return gf_global_mem_acct_enable;
 }
 
 int
-gf_global_mem_acct_enable_set (int val)
+gf_global_mem_acct_enable_set(int val)
 {
-	gf_global_mem_acct_enable = val;
-	return 0;
+    gf_global_mem_acct_enable = val;
+    return 0;
 }
 
 void
-glusterfs_this_destroy (void *ptr)
+glusterfs_this_destroy(void *ptr)
 {
-        FREE (ptr);
+    FREE(ptr);
 }
 
 static struct xlator_cbks global_cbks = {
-        .forget                 = NULL,
-        .release                = NULL,
-        .releasedir             = NULL,
-        .invalidate             = NULL,
-        .client_destroy         = NULL,
-        .client_disconnect      = NULL,
-        .ictxmerge              = NULL,
-        .ictxsize               = NULL,
-        .fdctxsize              = NULL,
+    .forget = NULL,
+    .release = NULL,
+    .releasedir = NULL,
+    .invalidate = NULL,
+    .client_destroy = NULL,
+    .client_disconnect = NULL,
+    .ictxmerge = NULL,
+    .ictxsize = NULL,
+    .fdctxsize = NULL,
 };
 
 /* This is required to get through the check in graph.c */
-static struct xlator_fops global_fops = {
-};
+static struct xlator_fops global_fops = {};
 
 static int
-global_xl_reconfigure (xlator_t *this, dict_t *options)
+global_xl_reconfigure(xlator_t *this, dict_t *options)
 {
-        int ret = -1;
-        gf_boolean_t bool_opt = _gf_false;
+    int ret = -1;
+    gf_boolean_t bool_opt = _gf_false;
 
-        /* This is not added in volume dump, hence adding the options in log
-           would be helpful for debugging later */
-        dict_dump_to_log (options);
+    /* This is not added in volume dump, hence adding the options in log
+       would be helpful for debugging later */
+    dict_dump_to_log(options);
 
-        GF_OPTION_RECONF ("measure-latency", bool_opt, options, bool, out);
-        this->ctx->measure_latency = bool_opt;
+    GF_OPTION_RECONF("measure-latency", bool_opt, options, bool, out);
+    this->ctx->measure_latency = bool_opt;
 
-        GF_OPTION_RECONF ("metrics-dump-path", this->ctx->config.metrics_dumppath,
-                          options, str, out);
+    GF_OPTION_RECONF("metrics-dump-path", this->ctx->config.metrics_dumppath,
+                     options, str, out);
 
-        /* TODO: add more things here */
-        ret = 0;
+    /* TODO: add more things here */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-global_xl_init (xlator_t *this)
+global_xl_init(xlator_t *this)
 {
-        int ret = -1;
-        gf_boolean_t bool_opt = false;
+    int ret = -1;
+    gf_boolean_t bool_opt = false;
 
-        GF_OPTION_INIT ("measure-latency", bool_opt, bool, out);
-        this->ctx->measure_latency = bool_opt;
+    GF_OPTION_INIT("measure-latency", bool_opt, bool, out);
+    this->ctx->measure_latency = bool_opt;
 
-        GF_OPTION_INIT ("metrics-dump-path", this->ctx->config.metrics_dumppath,
-                        str, out);
+    GF_OPTION_INIT("metrics-dump-path", this->ctx->config.metrics_dumppath, str,
+                   out);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 static void
-global_xl_fini (xlator_t *this)
+global_xl_fini(xlator_t *this)
 {
-        return;
+    return;
 }
 
 struct volume_options global_xl_options[] = {
-        { .key   = {"measure-latency"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .op_version = {GD_OP_VERSION_4_0_0},
-          .flags = OPT_FLAG_SETTABLE,
-          .tags = {"global", "context"},
-          .description = "Use this option to toggle measuring latency"
-        },
-        { .key   = {"metrics-dump-path"},
-          .type  = GF_OPTION_TYPE_STR,
-          .default_value = "{{gluster_workdir}}/metrics",
-          .op_version = {GD_OP_VERSION_4_0_0},
-          .flags = OPT_FLAG_SETTABLE,
-          .tags = {"global", "context"},
-          .description = "Use this option to set the metrics dump path"
-        },
-
-        { .key = {NULL},},
+    {.key = {"measure-latency"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .tags = {"global", "context"},
+     .description = "Use this option to toggle measuring latency"},
+    {.key = {"metrics-dump-path"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "{{gluster_workdir}}/metrics",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .tags = {"global", "context"},
+     .description = "Use this option to set the metrics dump path"},
+
+    {
+        .key = {NULL},
+    },
 };
 
 static volume_opt_list_t global_xl_opt_list;
 
 int
-glusterfs_this_init ()
+glusterfs_this_init()
 {
-        int ret = 0;
-        ret = pthread_key_create (&this_xlator_key, glusterfs_this_destroy);
-        if (ret != 0) {
-                gf_msg ("", GF_LOG_WARNING, ret,
-                        LG_MSG_PTHREAD_KEY_CREATE_FAILED, "failed to create "
-                        "the pthread key");
-                return ret;
-        }
+    int ret = 0;
+    ret = pthread_key_create(&this_xlator_key, glusterfs_this_destroy);
+    if (ret != 0) {
+        gf_msg("", GF_LOG_WARNING, ret, LG_MSG_PTHREAD_KEY_CREATE_FAILED,
+               "failed to create "
+               "the pthread key");
+        return ret;
+    }
 
-        global_xlator.name = "glusterfs";
-        global_xlator.type = GF_GLOBAL_XLATOR_NAME;
-        global_xlator.cbks = &global_cbks;
-        global_xlator.fops = &global_fops;
-        global_xlator.reconfigure = global_xl_reconfigure;
-        global_xlator.init = global_xl_init;
-        global_xlator.fini = global_xl_fini;
+    global_xlator.name = "glusterfs";
+    global_xlator.type = GF_GLOBAL_XLATOR_NAME;
+    global_xlator.cbks = &global_cbks;
+    global_xlator.fops = &global_fops;
+    global_xlator.reconfigure = global_xl_reconfigure;
+    global_xlator.init = global_xl_init;
+    global_xlator.fini = global_xl_fini;
 
-        INIT_LIST_HEAD (&global_xlator.volume_options);
-        INIT_LIST_HEAD (&global_xl_opt_list.list);
-        global_xl_opt_list.given_opt = global_xl_options;
+    INIT_LIST_HEAD(&global_xlator.volume_options);
+    INIT_LIST_HEAD(&global_xl_opt_list.list);
+    global_xl_opt_list.given_opt = global_xl_options;
 
-        list_add_tail (&global_xl_opt_list.list, &global_xlator.volume_options);
+    list_add_tail(&global_xl_opt_list.list, &global_xlator.volume_options);
 
-        return ret;
+    return ret;
 }
 
-
 xlator_t **
-__glusterfs_this_location ()
+__glusterfs_this_location()
 {
-        xlator_t **this_location = NULL;
-        int        ret = 0;
-
-        this_location = pthread_getspecific (this_xlator_key);
-
-        if (!this_location) {
-                this_location = CALLOC (1, sizeof (*this_location));
-                if (!this_location)
-                        goto out;
-
-                ret = pthread_setspecific (this_xlator_key, this_location);
-                if (ret != 0) {
-                        FREE (this_location);
-                        this_location = NULL;
-                        goto out;
-                }
+    xlator_t **this_location = NULL;
+    int ret = 0;
+
+    this_location = pthread_getspecific(this_xlator_key);
+
+    if (!this_location) {
+        this_location = CALLOC(1, sizeof(*this_location));
+        if (!this_location)
+            goto out;
+
+        ret = pthread_setspecific(this_xlator_key, this_location);
+        if (ret != 0) {
+            FREE(this_location);
+            this_location = NULL;
+            goto out;
         }
+    }
 out:
-        if (this_location) {
-                if (!*this_location)
-                        *this_location = &global_xlator;
-        }
-        return this_location;
+    if (this_location) {
+        if (!*this_location)
+            *this_location = &global_xlator;
+    }
+    return this_location;
 }
 
-
 xlator_t *
-glusterfs_this_get ()
+glusterfs_this_get()
 {
-        xlator_t **this_location = NULL;
+    xlator_t **this_location = NULL;
 
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return &global_xlator;
+    this_location = __glusterfs_this_location();
+    if (!this_location)
+        return &global_xlator;
 
-        return *this_location;
+    return *this_location;
 }
 
-
 int
-glusterfs_this_set (xlator_t *this)
+glusterfs_this_set(xlator_t *this)
 {
-        xlator_t **this_location = NULL;
+    xlator_t **this_location = NULL;
 
-        this_location = __glusterfs_this_location ();
-        if (!this_location)
-                return -ENOMEM;
+    this_location = __glusterfs_this_location();
+    if (!this_location)
+        return -ENOMEM;
 
-        *this_location = this;
+    *this_location = this;
 
-        return 0;
+    return 0;
 }
 
 /* SYNCOPCTX */
 static pthread_key_t syncopctx_key;
 
 static void
-syncopctx_key_destroy (void *ptr)
+syncopctx_key_destroy(void *ptr)
 {
-	struct syncopctx *opctx = ptr;
+    struct syncopctx *opctx = ptr;
 
-	if (opctx) {
-		if (opctx->groups)
-			GF_FREE (opctx->groups);
+    if (opctx) {
+        if (opctx->groups)
+            GF_FREE(opctx->groups);
 
-		GF_FREE (opctx);
-	}
+        GF_FREE(opctx);
+    }
 
-	return;
+    return;
 }
 
 void *
-syncopctx_getctx ()
+syncopctx_getctx()
 {
-	void *opctx = NULL;
+    void *opctx = NULL;
 
-	opctx = pthread_getspecific (syncopctx_key);
+    opctx = pthread_getspecific(syncopctx_key);
 
-	return opctx;
+    return opctx;
 }
 
 int
-syncopctx_setctx (void *ctx)
+syncopctx_setctx(void *ctx)
 {
-	int ret = 0;
+    int ret = 0;
 
-	ret = pthread_setspecific (syncopctx_key, ctx);
+    ret = pthread_setspecific(syncopctx_key, ctx);
 
-	return ret;
+    return ret;
 }
 
 static int
-syncopctx_init (void)
+syncopctx_init(void)
 {
-	int ret;
+    int ret;
 
-	ret = pthread_key_create (&syncopctx_key, syncopctx_key_destroy);
+    ret = pthread_key_create(&syncopctx_key, syncopctx_key_destroy);
 
-	return ret;
+    return ret;
 }
 
 /* SYNCTASK */
 
 int
-synctask_init ()
+synctask_init()
 {
-        int  ret = 0;
+    int ret = 0;
 
-        ret = pthread_key_create (&synctask_key, NULL);
+    ret = pthread_key_create(&synctask_key, NULL);
 
-        return ret;
+    return ret;
 }
 
 void *
-synctask_get ()
+synctask_get()
 {
-        void   *synctask = NULL;
+    void *synctask = NULL;
 
-        synctask = pthread_getspecific (synctask_key);
+    synctask = pthread_getspecific(synctask_key);
 
-        return synctask;
+    return synctask;
 }
 
-
 int
-synctask_set (void *synctask)
+synctask_set(void *synctask)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        pthread_setspecific (synctask_key, synctask);
+    pthread_setspecific(synctask_key, synctask);
 
-        return ret;
+    return ret;
 }
 
-//UUID_BUFFER
+// UUID_BUFFER
 
 void
-glusterfs_uuid_buf_destroy (void *ptr)
+glusterfs_uuid_buf_destroy(void *ptr)
 {
-        FREE (ptr);
+    FREE(ptr);
 }
 
 int
-glusterfs_uuid_buf_init ()
+glusterfs_uuid_buf_init()
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = pthread_key_create (&uuid_buf_key,
-                                  glusterfs_uuid_buf_destroy);
-        return ret;
+    ret = pthread_key_create(&uuid_buf_key, glusterfs_uuid_buf_destroy);
+    return ret;
 }
 
 char *
-glusterfs_uuid_buf_get ()
+glusterfs_uuid_buf_get()
 {
-        char *buf;
-        int ret = 0;
-
-        buf = pthread_getspecific (uuid_buf_key);
-        if(!buf) {
-                buf = MALLOC (GF_UUID_BUF_SIZE);
-                ret = pthread_setspecific (uuid_buf_key, (void *) buf);
-                if (ret)
-                        buf = global_uuid_buf;
-        }
-        return buf;
+    char *buf;
+    int ret = 0;
+
+    buf = pthread_getspecific(uuid_buf_key);
+    if (!buf) {
+        buf = MALLOC(GF_UUID_BUF_SIZE);
+        ret = pthread_setspecific(uuid_buf_key, (void *)buf);
+        if (ret)
+            buf = global_uuid_buf;
+    }
+    return buf;
 }
 
 /* LKOWNER_BUFFER */
 
 void
-glusterfs_lkowner_buf_destroy (void *ptr)
+glusterfs_lkowner_buf_destroy(void *ptr)
 {
-        FREE (ptr);
+    FREE(ptr);
 }
 
 int
-glusterfs_lkowner_buf_init ()
+glusterfs_lkowner_buf_init()
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = pthread_key_create (&lkowner_buf_key,
-                                  glusterfs_lkowner_buf_destroy);
-        return ret;
+    ret = pthread_key_create(&lkowner_buf_key, glusterfs_lkowner_buf_destroy);
+    return ret;
 }
 
 char *
-glusterfs_lkowner_buf_get ()
+glusterfs_lkowner_buf_get()
 {
-        char *buf;
-        int ret = 0;
-
-        buf = pthread_getspecific (lkowner_buf_key);
-        if(!buf) {
-                buf = MALLOC (GF_LKOWNER_BUF_SIZE);
-                ret = pthread_setspecific (lkowner_buf_key, (void *) buf);
-                if (ret)
-                        buf = global_lkowner_buf;
-        }
-        return buf;
+    char *buf;
+    int ret = 0;
+
+    buf = pthread_getspecific(lkowner_buf_key);
+    if (!buf) {
+        buf = MALLOC(GF_LKOWNER_BUF_SIZE);
+        ret = pthread_setspecific(lkowner_buf_key, (void *)buf);
+        if (ret)
+            buf = global_lkowner_buf;
+    }
+    return buf;
 }
 
 /* Leaseid buffer */
 void
-glusterfs_leaseid_buf_destroy (void *ptr)
+glusterfs_leaseid_buf_destroy(void *ptr)
 {
-        FREE (ptr);
+    FREE(ptr);
 }
 
 int
-glusterfs_leaseid_buf_init ()
+glusterfs_leaseid_buf_init()
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = pthread_key_create (&leaseid_buf_key,
-                                  glusterfs_leaseid_buf_destroy);
-        return ret;
+    ret = pthread_key_create(&leaseid_buf_key, glusterfs_leaseid_buf_destroy);
+    return ret;
 }
 
 char *
-glusterfs_leaseid_buf_get ()
+glusterfs_leaseid_buf_get()
 {
-        char *buf = NULL;
-        int   ret = 0;
-
-        buf = pthread_getspecific (leaseid_buf_key);
-        if (!buf) {
-                buf = CALLOC (1, GF_LEASE_ID_BUF_SIZE);
-                ret = pthread_setspecific (leaseid_buf_key, (void *) buf);
-                if (ret) {
-                        FREE (buf);
-                        buf = NULL;
-                }
+    char *buf = NULL;
+    int ret = 0;
+
+    buf = pthread_getspecific(leaseid_buf_key);
+    if (!buf) {
+        buf = CALLOC(1, GF_LEASE_ID_BUF_SIZE);
+        ret = pthread_setspecific(leaseid_buf_key, (void *)buf);
+        if (ret) {
+            FREE(buf);
+            buf = NULL;
         }
-        return buf;
+    }
+    return buf;
 }
 
 char *
-glusterfs_leaseid_exist ()
+glusterfs_leaseid_exist()
 {
-        return pthread_getspecific (leaseid_buf_key);
+    return pthread_getspecific(leaseid_buf_key);
 }
 
 static void
-gf_globals_init_once ()
+gf_globals_init_once()
 {
-        int ret = 0;
-
-        ret = glusterfs_this_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_TRANSLATOR_INIT_FAILED,
-                        "ERROR: glusterfs-translator init failed");
-                goto out;
-        }
-
-        ret = glusterfs_uuid_buf_init ();
-        if(ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_UUID_BUF_INIT_FAILED,
-                        "ERROR: glusterfs uuid buffer init failed");
-                goto out;
-        }
-
-        ret = glusterfs_lkowner_buf_init ();
-        if(ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_LKOWNER_BUF_INIT_FAILED,
-                        "ERROR: glusterfs lkowner buffer init failed");
-                goto out;
-        }
-
-        ret = glusterfs_leaseid_buf_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_LEASEID_BUF_INIT_FAILED,
-                        "ERROR: glusterfs leaseid buffer init failed");
-                goto out;
-        }
-
-        ret = synctask_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCTASK_INIT_FAILED,
-                        "ERROR: glusterfs synctask init failed");
-                goto out;
-        }
-
-        ret = syncopctx_init ();
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCOPCTX_INIT_FAILED,
-                        "ERROR: glusterfs syncopctx init failed");
-                goto out;
-        }
+    int ret = 0;
+
+    ret = glusterfs_this_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_TRANSLATOR_INIT_FAILED,
+               "ERROR: glusterfs-translator init failed");
+        goto out;
+    }
+
+    ret = glusterfs_uuid_buf_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_UUID_BUF_INIT_FAILED,
+               "ERROR: glusterfs uuid buffer init failed");
+        goto out;
+    }
+
+    ret = glusterfs_lkowner_buf_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_LKOWNER_BUF_INIT_FAILED,
+               "ERROR: glusterfs lkowner buffer init failed");
+        goto out;
+    }
+
+    ret = glusterfs_leaseid_buf_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_LEASEID_BUF_INIT_FAILED,
+               "ERROR: glusterfs leaseid buffer init failed");
+        goto out;
+    }
+
+    ret = synctask_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCTASK_INIT_FAILED,
+               "ERROR: glusterfs synctask init failed");
+        goto out;
+    }
+
+    ret = syncopctx_init();
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_SYNCOPCTX_INIT_FAILED,
+               "ERROR: glusterfs syncopctx init failed");
+        goto out;
+    }
 out:
 
-        if (ret) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_GLOBAL_INIT_FAILED,
-                        "Exiting as global initialization failed");
-                exit (ret);
-        }
+    if (ret) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_GLOBAL_INIT_FAILED,
+               "Exiting as global initialization failed");
+        exit(ret);
+    }
 }
 
 int
-glusterfs_globals_init (glusterfs_ctx_t *ctx)
+glusterfs_globals_init(glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
+    int ret = 0;
 
-        gf_log_globals_init (ctx, GF_LOG_INFO);
+    gf_log_globals_init(ctx, GF_LOG_INFO);
 
-        ret =  pthread_once (&globals_inited, gf_globals_init_once);
+    ret = pthread_once(&globals_inited, gf_globals_init_once);
 
-        if (ret)
-                gf_msg ("", GF_LOG_CRITICAL, ret, LG_MSG_PTHREAD_FAILED,
-                        "pthread_once failed");
+    if (ret)
+        gf_msg("", GF_LOG_CRITICAL, ret, LG_MSG_PTHREAD_FAILED,
+               "pthread_once failed");
 
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/graph-print.c b/libglusterfs/src/graph-print.c
index 676167b17d2..3b984b64508 100644
--- a/libglusterfs/src/graph-print.c
+++ b/libglusterfs/src/graph-print.c
@@ -15,183 +15,180 @@
 #include "graph-utils.h"
 #include "libglusterfs-messages.h"
 
-
 struct gf_printer {
-        ssize_t (*write) (struct gf_printer *gp, char *buf, size_t len);
-        void *priv;
-        int  len;
+    ssize_t (*write)(struct gf_printer *gp, char *buf, size_t len);
+    void *priv;
+    int len;
 };
 
 static ssize_t
-gp_write_file (struct gf_printer *gp, char *buf, size_t len)
+gp_write_file(struct gf_printer *gp, char *buf, size_t len)
 {
-        FILE *f = gp->priv;
+    FILE *f = gp->priv;
 
-        if (fwrite (buf, len, 1, f) != 1) {
-                gf_msg ("graph-print", GF_LOG_ERROR, errno,
-                        LG_MSG_FWRITE_FAILED, "fwrite failed");
+    if (fwrite(buf, len, 1, f) != 1) {
+        gf_msg("graph-print", GF_LOG_ERROR, errno, LG_MSG_FWRITE_FAILED,
+               "fwrite failed");
 
-                return -1;
-        }
+        return -1;
+    }
 
-        return len;
+    return len;
 }
 
 static ssize_t
-gp_write_buf (struct gf_printer *gp, char *buf, size_t len)
+gp_write_buf(struct gf_printer *gp, char *buf, size_t len)
 {
-        struct iovec *iov = gp->priv;
+    struct iovec *iov = gp->priv;
 
-        if (iov->iov_len < len) {
-                gf_msg ("graph-print", GF_LOG_ERROR, 0, LG_MSG_BUFFER_FULL,
-                        "buffer full");
+    if (iov->iov_len < len) {
+        gf_msg("graph-print", GF_LOG_ERROR, 0, LG_MSG_BUFFER_FULL,
+               "buffer full");
 
-                return -1;
-        }
+        return -1;
+    }
 
-        memcpy (iov->iov_base, buf, len);
-        iov->iov_base += len;
-        iov->iov_len  -= len;
+    memcpy(iov->iov_base, buf, len);
+    iov->iov_base += len;
+    iov->iov_len -= len;
 
-        return len;
+    return len;
 }
 
 static int
-gpprintf (struct gf_printer *gp, const char *format, ...)
+gpprintf(struct gf_printer *gp, const char *format, ...)
 {
-        va_list arg;
-        char *str = NULL;
-        int ret = 0;
+    va_list arg;
+    char *str = NULL;
+    int ret = 0;
 
-        va_start (arg, format);
-        ret = gf_vasprintf (&str, format, arg);
-        va_end (arg);
+    va_start(arg, format);
+    ret = gf_vasprintf(&str, format, arg);
+    va_end(arg);
 
-        if (ret < 0)
-                return ret;
+    if (ret < 0)
+        return ret;
 
-        ret = gp->write (gp, str, ret);
+    ret = gp->write(gp, str, ret);
 
-        GF_FREE (str);
+    GF_FREE(str);
 
-        return ret;
+    return ret;
 }
 
-#define GPPRINTF(gp, fmt, ...) do {                             \
-                ret = gpprintf (gp, fmt, ## __VA_ARGS__);       \
-                if (ret == -1)                                  \
-                        goto out;                               \
-                else                                            \
-                        gp->len += ret;                             \
-        } while (0)
+#define GPPRINTF(gp, fmt, ...)                                                 \
+    do {                                                                       \
+        ret = gpprintf(gp, fmt, ##__VA_ARGS__);                                \
+        if (ret == -1)                                                         \
+            goto out;                                                          \
+        else                                                                   \
+            gp->len += ret;                                                    \
+    } while (0)
 
 static int
-_print_volume_options (dict_t *d, char *k, data_t *v,
-                           void *tmp)
+_print_volume_options(dict_t *d, char *k, data_t *v, void *tmp)
 {
-        struct gf_printer *gp  = tmp;
-        int                ret = 0;
-        GPPRINTF (gp, "    option %s %s\n", k, v->data);
-        return 0;
+    struct gf_printer *gp = tmp;
+    int ret = 0;
+    GPPRINTF(gp, "    option %s %s\n", k, v->data);
+    return 0;
 out:
-        /* means, it is a failure */
-        return -1;
+    /* means, it is a failure */
+    return -1;
 }
 
 static int
-glusterfs_graph_print (struct gf_printer *gp, glusterfs_graph_t *graph)
+glusterfs_graph_print(struct gf_printer *gp, glusterfs_graph_t *graph)
 {
-        xlator_t      *trav = NULL;
-        xlator_list_t *xch = NULL;
-        int            ret = 0;
-        ssize_t        len = 0;
-
-        if (!graph->first)
-                return 0;
+    xlator_t *trav = NULL;
+    xlator_list_t *xch = NULL;
+    int ret = 0;
+    ssize_t len = 0;
 
-        for (trav = graph->first; trav->next; trav = trav->next);
-        for (; trav; trav = trav->prev) {
-                GPPRINTF (gp, "volume %s\n    type %s\n", trav->name,
-                          trav->type);
+    if (!graph->first)
+        return 0;
 
-                ret = dict_foreach (trav->options, _print_volume_options, gp);
-                if (ret)
-                        goto out;
+    for (trav = graph->first; trav->next; trav = trav->next)
+        ;
+    for (; trav; trav = trav->prev) {
+        GPPRINTF(gp, "volume %s\n    type %s\n", trav->name, trav->type);
 
-                if (trav->children) {
-                        GPPRINTF (gp, "    subvolumes");
+        ret = dict_foreach(trav->options, _print_volume_options, gp);
+        if (ret)
+            goto out;
 
-                        for (xch = trav->children; xch; xch = xch->next)
-                                GPPRINTF (gp, " %s", xch->xlator->name);
+        if (trav->children) {
+            GPPRINTF(gp, "    subvolumes");
 
-                        GPPRINTF (gp, "\n");
-                }
+            for (xch = trav->children; xch; xch = xch->next)
+                GPPRINTF(gp, " %s", xch->xlator->name);
 
-                GPPRINTF (gp, "end-volume\n");
-                if (trav != graph->first)
-                        GPPRINTF (gp, "\n");
+            GPPRINTF(gp, "\n");
         }
 
+        GPPRINTF(gp, "end-volume\n");
+        if (trav != graph->first)
+            GPPRINTF(gp, "\n");
+    }
+
 out:
-        len = gp->len;
-        if (ret == -1) {
-                gf_msg ("graph-print", GF_LOG_ERROR, 0, LG_MSG_PRINT_FAILED,
-                        "printing failed");
+    len = gp->len;
+    if (ret == -1) {
+        gf_msg("graph-print", GF_LOG_ERROR, 0, LG_MSG_PRINT_FAILED,
+               "printing failed");
 
-                return -1;
-        }
+        return -1;
+    }
 
-        return len;
+    return len;
 
 #undef GPPRINTF
 }
 
 int
-glusterfs_graph_print_file (FILE *file, glusterfs_graph_t *graph)
+glusterfs_graph_print_file(FILE *file, glusterfs_graph_t *graph)
 {
-        struct gf_printer gp = { .write = gp_write_file,
-                                 .priv  = file
-        };
+    struct gf_printer gp = {.write = gp_write_file, .priv = file};
 
-        return glusterfs_graph_print (&gp, graph);
+    return glusterfs_graph_print(&gp, graph);
 }
 
 char *
-glusterfs_graph_print_buf (glusterfs_graph_t *graph)
+glusterfs_graph_print_buf(glusterfs_graph_t *graph)
 {
-        FILE *f = NULL;
-        struct iovec iov = {0,};
-        int len = 0;
-        char *buf = NULL;
-        struct gf_printer gp = { .write = gp_write_buf,
-                                 .priv  = &iov
-        };
-
-        f = fopen ("/dev/null", "a");
-        if (!f) {
-                gf_msg ("graph-print", GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "cannot open /dev/null");
-
-                return NULL;
-        }
-        len = glusterfs_graph_print_file (f, graph);
-        fclose (f);
-        if (len == -1)
-                return NULL;
-
-        buf = GF_CALLOC (1, len + 1, gf_common_mt_graph_buf);
-        if (!buf) {
-                return NULL;
-        }
-        iov.iov_base = buf;
-        iov.iov_len  = len;
-
-        len = glusterfs_graph_print (&gp, graph);
-        if (len == -1) {
-                GF_FREE (buf);
-
-                return NULL;
-        }
-
-        return buf;
+    FILE *f = NULL;
+    struct iovec iov = {
+        0,
+    };
+    int len = 0;
+    char *buf = NULL;
+    struct gf_printer gp = {.write = gp_write_buf, .priv = &iov};
+
+    f = fopen("/dev/null", "a");
+    if (!f) {
+        gf_msg("graph-print", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "cannot open /dev/null");
+
+        return NULL;
+    }
+    len = glusterfs_graph_print_file(f, graph);
+    fclose(f);
+    if (len == -1)
+        return NULL;
+
+    buf = GF_CALLOC(1, len + 1, gf_common_mt_graph_buf);
+    if (!buf) {
+        return NULL;
+    }
+    iov.iov_base = buf;
+    iov.iov_len = len;
+
+    len = glusterfs_graph_print(&gp, graph);
+    if (len == -1) {
+        GF_FREE(buf);
+
+        return NULL;
+    }
+
+    return buf;
 }
diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c
index 03ef55c5892..2a213d2c48e 100644
--- a/libglusterfs/src/graph.c
+++ b/libglusterfs/src/graph.c
@@ -69,623 +69,611 @@ _gf_dump_details (int argc, char **argv)
 #endif
 
 int
-glusterfs_read_secure_access_file (void)
+glusterfs_read_secure_access_file(void)
 {
-        FILE *fp = NULL;
-        char  line[100] = {0,};
-        int   cert_depth = 1;   /* Default SSL CERT DEPTH */
-        regex_t regcmpl;
-        char *key = {"^option transport.socket.ssl-cert-depth"};
-        char  keyval[50] = {0,};
-        int start = 0, end = 0, copy_len = 0;
-        regmatch_t result[1] = {{0} };
-
-        fp = fopen (SECURE_ACCESS_FILE, "r");
-        if (!fp)
-                goto out;
-
-        /* Check if any line matches with key */
-        while (fgets(line, sizeof(line), fp) != NULL) {
-                if (regcomp (&regcmpl, key, REG_EXTENDED)) {
-                        goto out;
-                }
-                if (!regexec (&regcmpl, line, 1, result, 0)) {
-                        start = result[0].rm_so;
-                        end  = result[0].rm_eo;
-                        copy_len = end - start;
-                        gf_strncpy (keyval, line+copy_len, sizeof (keyval));
-                        if (keyval[0]) {
-                                cert_depth = atoi(keyval);
-                                if (cert_depth == 0)
-                                        cert_depth = 1; /* Default SSL CERT DEPTH */
-                                break;
-                        }
-                }
-                regfree(&regcmpl);
+    FILE *fp = NULL;
+    char line[100] = {
+        0,
+    };
+    int cert_depth = 1; /* Default SSL CERT DEPTH */
+    regex_t regcmpl;
+    char *key = {"^option transport.socket.ssl-cert-depth"};
+    char keyval[50] = {
+        0,
+    };
+    int start = 0, end = 0, copy_len = 0;
+    regmatch_t result[1] = {{0}};
+
+    fp = fopen(SECURE_ACCESS_FILE, "r");
+    if (!fp)
+        goto out;
+
+    /* Check if any line matches with key */
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (regcomp(&regcmpl, key, REG_EXTENDED)) {
+            goto out;
         }
+        if (!regexec(&regcmpl, line, 1, result, 0)) {
+            start = result[0].rm_so;
+            end = result[0].rm_eo;
+            copy_len = end - start;
+            gf_strncpy(keyval, line + copy_len, sizeof(keyval));
+            if (keyval[0]) {
+                cert_depth = atoi(keyval);
+                if (cert_depth == 0)
+                    cert_depth = 1; /* Default SSL CERT DEPTH */
+                break;
+            }
+        }
+        regfree(&regcmpl);
+    }
 
 out:
-        if (fp)
-                fclose (fp);
-        return cert_depth;
+    if (fp)
+        fclose(fp);
+    return cert_depth;
 }
 
 int
-glusterfs_xlator_link (xlator_t *pxl, xlator_t *cxl)
+glusterfs_xlator_link(xlator_t *pxl, xlator_t *cxl)
 {
-        xlator_list_t   *xlchild = NULL;
-        xlator_list_t   *xlparent = NULL;
-        xlator_list_t  **tmp = NULL;
+    xlator_list_t *xlchild = NULL;
+    xlator_list_t *xlparent = NULL;
+    xlator_list_t **tmp = NULL;
 
-        xlparent = (void *) GF_CALLOC (1, sizeof (*xlparent),
-                                       gf_common_mt_xlator_list_t);
-        if (!xlparent)
-                return -1;
+    xlparent = (void *)GF_CALLOC(1, sizeof(*xlparent),
+                                 gf_common_mt_xlator_list_t);
+    if (!xlparent)
+        return -1;
 
-        xlchild = (void *) GF_CALLOC (1, sizeof (*xlchild),
-                                      gf_common_mt_xlator_list_t);
-        if (!xlchild) {
-                GF_FREE (xlparent);
+    xlchild = (void *)GF_CALLOC(1, sizeof(*xlchild),
+                                gf_common_mt_xlator_list_t);
+    if (!xlchild) {
+        GF_FREE(xlparent);
 
-                return -1;
-        }
+        return -1;
+    }
 
-        xlparent->xlator = pxl;
-        for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next);
-        *tmp = xlparent;
+    xlparent->xlator = pxl;
+    for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next)
+        ;
+    *tmp = xlparent;
 
-        xlchild->xlator = cxl;
-        for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next);
-        *tmp = xlchild;
+    xlchild->xlator = cxl;
+    for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next)
+        ;
+    *tmp = xlchild;
 
-        return 0;
+    return 0;
 }
 
-
 void
-glusterfs_graph_set_first (glusterfs_graph_t *graph, xlator_t *xl)
+glusterfs_graph_set_first(glusterfs_graph_t *graph, xlator_t *xl)
 {
-        xl->next = graph->first;
-        if (graph->first)
-                ((xlator_t *)graph->first)->prev = xl;
-        graph->first = xl;
+    xl->next = graph->first;
+    if (graph->first)
+        ((xlator_t *)graph->first)->prev = xl;
+    graph->first = xl;
 
-        graph->xl_count++;
-        xl->xl_id = graph->xl_count;
+    graph->xl_count++;
+    xl->xl_id = graph->xl_count;
 }
 
-
 int
-glusterfs_graph_insert (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
-                        const char *type, const char *name,
-                        gf_boolean_t autoload)
+glusterfs_graph_insert(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+                       const char *type, const char *name,
+                       gf_boolean_t autoload)
 {
-        xlator_t        *ixl = NULL;
+    xlator_t *ixl = NULL;
 
-        if (!ctx->master) {
-                gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
-                        "volume \"%s\" can be added from command line only "
-                        "on client side", type);
+    if (!ctx->master) {
+        gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
+               "volume \"%s\" can be added from command line only "
+               "on client side",
+               type);
 
-                return -1;
-        }
+        return -1;
+    }
 
-        ixl = GF_CALLOC (1, sizeof (*ixl), gf_common_mt_xlator_t);
-        if (!ixl)
-                return -1;
+    ixl = GF_CALLOC(1, sizeof(*ixl), gf_common_mt_xlator_t);
+    if (!ixl)
+        return -1;
 
-        ixl->ctx      = ctx;
-        ixl->graph    = graph;
-        ixl->options  = get_new_dict ();
-        if (!ixl->options)
-                goto err;
+    ixl->ctx = ctx;
+    ixl->graph = graph;
+    ixl->options = get_new_dict();
+    if (!ixl->options)
+        goto err;
 
-        ixl->name  = gf_strdup (name);
-        if (!ixl->name)
-                goto err;
+    ixl->name = gf_strdup(name);
+    if (!ixl->name)
+        goto err;
 
-        ixl->is_autoloaded = autoload;
+    ixl->is_autoloaded = autoload;
 
-        if (xlator_set_type (ixl, type) == -1) {
-                gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
-                        "%s (%s) initialization failed",
-                        name, type);
-                return -1;
-        }
+    if (xlator_set_type(ixl, type) == -1) {
+        gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
+               "%s (%s) initialization failed", name, type);
+        return -1;
+    }
 
-        if (glusterfs_xlator_link (ixl, graph->top) == -1)
-                goto err;
-        glusterfs_graph_set_first (graph, ixl);
-        graph->top = ixl;
+    if (glusterfs_xlator_link(ixl, graph->top) == -1)
+        goto err;
+    glusterfs_graph_set_first(graph, ixl);
+    graph->top = ixl;
 
-        return 0;
+    return 0;
 err:
-        xlator_destroy (ixl);
-        return -1;
+    xlator_destroy(ixl);
+    return -1;
 }
 
 int
-glusterfs_graph_acl (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_acl(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->acl)
-                return 0;
+    if (!cmd_args->acl)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "system/posix-acl",
-                                      "posix-acl-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "system/posix-acl",
+                                 "posix-acl-autoload", 1);
+    return ret;
 }
 
 int
-glusterfs_graph_worm (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_worm(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->worm)
-                return 0;
+    if (!cmd_args->worm)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/worm",
-                                      "worm-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "features/worm", "worm-autoload",
+                                 1);
+    return ret;
 }
 
-
 int
-glusterfs_graph_meta (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_meta(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
+    int ret = 0;
 
-	if (!ctx->master)
-		return 0;
+    if (!ctx->master)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "meta",
-                                      "meta-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "meta", "meta-autoload", 1);
+    return ret;
 }
 
-
 int
-glusterfs_graph_mac_compat (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_mac_compat(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (cmd_args->mac_compat == GF_OPTION_DISABLE)
-                return 0;
+    if (cmd_args->mac_compat == GF_OPTION_DISABLE)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/mac-compat",
-                                      "mac-compat-autoload", 1);
+    ret = glusterfs_graph_insert(graph, ctx, "features/mac-compat",
+                                 "mac-compat-autoload", 1);
 
-        return ret;
+    return ret;
 }
 
 int
-glusterfs_graph_gfid_access (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_gfid_access(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        cmd_args_t      *cmd_args = NULL;
+    int ret = 0;
+    cmd_args_t *cmd_args = NULL;
 
-        cmd_args = &ctx->cmd_args;
+    cmd_args = &ctx->cmd_args;
 
-        if (!cmd_args->aux_gfid_mount)
-                return 0;
+    if (!cmd_args->aux_gfid_mount)
+        return 0;
 
-        ret = glusterfs_graph_insert (graph, ctx, "features/gfid-access",
-                                      "gfid-access-autoload", 1);
-        return ret;
+    ret = glusterfs_graph_insert(graph, ctx, "features/gfid-access",
+                                 "gfid-access-autoload", 1);
+    return ret;
 }
 
 static void
-gf_add_cmdline_options (glusterfs_graph_t *graph, cmd_args_t *cmd_args)
+gf_add_cmdline_options(glusterfs_graph_t *graph, cmd_args_t *cmd_args)
 {
-        int                      ret = 0;
-        xlator_t                *trav = NULL;
-        xlator_cmdline_option_t *cmd_option = NULL;
-
-        trav = graph->first;
-
-        while (trav) {
-                list_for_each_entry (cmd_option,
-                                     &cmd_args->xlator_options, cmd_args) {
-                        if (!fnmatch (cmd_option->volume,
-                                      trav->name, FNM_NOESCAPE)) {
-                                ret = dict_set_str (trav->options,
-                                                    cmd_option->key,
-                                                    cmd_option->value);
-                                if (ret == 0) {
-                                        gf_msg (trav->name, GF_LOG_TRACE, 0,
-                                                LG_MSG_VOL_OPTION_ADD,
-                                                "adding option '%s' for "
-                                                "volume '%s' with value '%s'",
-                                                cmd_option->key, trav->name,
-                                                cmd_option->value);
-                                } else {
-                                        gf_msg (trav->name, GF_LOG_WARNING,
-                                                -ret, LG_MSG_VOL_OPTION_ADD,
-                                                "adding option '%s' for "
-                                                "volume '%s' failed",
-                                                cmd_option->key, trav->name);
-                                }
-                        }
+    int ret = 0;
+    xlator_t *trav = NULL;
+    xlator_cmdline_option_t *cmd_option = NULL;
+
+    trav = graph->first;
+
+    while (trav) {
+        list_for_each_entry(cmd_option, &cmd_args->xlator_options, cmd_args)
+        {
+            if (!fnmatch(cmd_option->volume, trav->name, FNM_NOESCAPE)) {
+                ret = dict_set_str(trav->options, cmd_option->key,
+                                   cmd_option->value);
+                if (ret == 0) {
+                    gf_msg(trav->name, GF_LOG_TRACE, 0, LG_MSG_VOL_OPTION_ADD,
+                           "adding option '%s' for "
+                           "volume '%s' with value '%s'",
+                           cmd_option->key, trav->name, cmd_option->value);
+                } else {
+                    gf_msg(trav->name, GF_LOG_WARNING, -ret,
+                           LG_MSG_VOL_OPTION_ADD,
+                           "adding option '%s' for "
+                           "volume '%s' failed",
+                           cmd_option->key, trav->name);
                 }
-                trav = trav->next;
+            }
         }
+        trav = trav->next;
+    }
 }
 
-
 int
-glusterfs_graph_validate_options (glusterfs_graph_t *graph)
+glusterfs_graph_validate_options(glusterfs_graph_t *graph)
 {
-        xlator_t           *trav = NULL;
-        int                 ret = -1;
-        char               *errstr = NULL;
+    xlator_t *trav = NULL;
+    int ret = -1;
+    char *errstr = NULL;
 
-        trav = graph->first;
+    trav = graph->first;
 
-        while (trav) {
-                if (list_empty (&trav->volume_options)) {
-                        trav = trav->next;
-                        continue;
-                }
+    while (trav) {
+        if (list_empty(&trav->volume_options)) {
+            trav = trav->next;
+            continue;
+        }
 
-                ret = xlator_options_validate (trav, trav->options, &errstr);
-                if (ret) {
-                        gf_msg (trav->name, GF_LOG_ERROR, 0,
-                                LG_MSG_VALIDATION_FAILED, "validation failed: "
-                                "%s", errstr);
-                        return ret;
-                }
-                trav = trav->next;
+        ret = xlator_options_validate(trav, trav->options, &errstr);
+        if (ret) {
+            gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
+                   "validation failed: "
+                   "%s",
+                   errstr);
+            return ret;
         }
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-glusterfs_graph_init (glusterfs_graph_t *graph)
+glusterfs_graph_init(glusterfs_graph_t *graph)
 {
-        xlator_t           *trav = NULL;
-        int                 ret = -1;
-
-        trav = graph->first;
-
-        while (trav) {
-                ret = xlator_init (trav);
-                if (ret) {
-                        gf_msg (trav->name, GF_LOG_ERROR, 0,
-                                LG_MSG_TRANSLATOR_INIT_FAILED,
-                                "initializing translator failed");
-                        return ret;
-                }
-                trav = trav->next;
+    xlator_t *trav = NULL;
+    int ret = -1;
+
+    trav = graph->first;
+
+    while (trav) {
+        ret = xlator_init(trav);
+        if (ret) {
+            gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_TRANSLATOR_INIT_FAILED,
+                   "initializing translator failed");
+            return ret;
         }
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-glusterfs_graph_deactivate (glusterfs_graph_t *graph)
+glusterfs_graph_deactivate(glusterfs_graph_t *graph)
 {
-        xlator_t           *top = NULL;
+    xlator_t *top = NULL;
 
-        if (graph == NULL)
-                goto out;
+    if (graph == NULL)
+        goto out;
 
-        top = graph->top;
-        xlator_tree_fini (top);
- out:
-        return 0;
+    top = graph->top;
+    xlator_tree_fini(top);
+out:
+    return 0;
 }
 
 static int
-_log_if_unknown_option (dict_t *dict, char *key, data_t *value, void *data)
+_log_if_unknown_option(dict_t *dict, char *key, data_t *value, void *data)
 {
-        volume_option_t   *found = NULL;
-        xlator_t          *xl = NULL;
+    volume_option_t *found = NULL;
+    xlator_t *xl = NULL;
 
-        xl = data;
+    xl = data;
 
-        found = xlator_volume_option_get (xl, key);
+    found = xlator_volume_option_get(xl, key);
 
-        if (!found) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_XLATOR_OPTION_INVALID,
-                        "option '%s' is not recognized", key);
-        }
+    if (!found) {
+        gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_XLATOR_OPTION_INVALID,
+               "option '%s' is not recognized", key);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static void
-_xlator_check_unknown_options (xlator_t *xl, void *data)
+_xlator_check_unknown_options(xlator_t *xl, void *data)
 {
-        dict_foreach (xl->options, _log_if_unknown_option, xl);
+    dict_foreach(xl->options, _log_if_unknown_option, xl);
 }
 
-
 int
-glusterfs_graph_unknown_options (glusterfs_graph_t *graph)
+glusterfs_graph_unknown_options(glusterfs_graph_t *graph)
 {
-        xlator_foreach (graph->first, _xlator_check_unknown_options, NULL);
-        return 0;
+    xlator_foreach(graph->first, _xlator_check_unknown_options, NULL);
+    return 0;
 }
 
-
 void
-fill_uuid (char *uuid, int size)
+fill_uuid(char *uuid, int size)
 {
-        char           hostname[256] = {0,};
-        struct timeval tv = {0,};
-        char           now_str[64];
-
-        if (gettimeofday (&tv, NULL) == -1) {
-                gf_msg ("graph", GF_LOG_ERROR, errno,
-                        LG_MSG_GETTIMEOFDAY_FAILED, "gettimeofday: "
-                        "failed");
-        }
-
-        if (gethostname (hostname, 256) == -1) {
-                gf_msg ("graph", GF_LOG_ERROR, errno,
-                        LG_MSG_GETHOSTNAME_FAILED, "gethostname: "
-                        "failed");
-        }
-
-        gf_time_fmt (now_str, sizeof now_str, tv.tv_sec, gf_timefmt_dirent);
-        snprintf (uuid, size, "%s-%d-%s:%"GF_PRI_SUSECONDS,
-                  hostname, getpid(), now_str, tv.tv_usec);
-
-        return;
+    char hostname[256] = {
+        0,
+    };
+    struct timeval tv = {
+        0,
+    };
+    char now_str[64];
+
+    if (gettimeofday(&tv, NULL) == -1) {
+        gf_msg("graph", GF_LOG_ERROR, errno, LG_MSG_GETTIMEOFDAY_FAILED,
+               "gettimeofday: "
+               "failed");
+    }
+
+    if (gethostname(hostname, 256) == -1) {
+        gf_msg("graph", GF_LOG_ERROR, errno, LG_MSG_GETHOSTNAME_FAILED,
+               "gethostname: "
+               "failed");
+    }
+
+    gf_time_fmt(now_str, sizeof now_str, tv.tv_sec, gf_timefmt_dirent);
+    snprintf(uuid, size, "%s-%d-%s:%" GF_PRI_SUSECONDS, hostname, getpid(),
+             now_str, tv.tv_usec);
+
+    return;
 }
 
-
 static int
-glusterfs_graph_settop (glusterfs_graph_t *graph, char *volume_name,
-                        gf_boolean_t exact_match)
+glusterfs_graph_settop(glusterfs_graph_t *graph, char *volume_name,
+                       gf_boolean_t exact_match)
 {
-        int         ret  = -1;
-        xlator_t   *trav = NULL;
+    int ret = -1;
+    xlator_t *trav = NULL;
 
-        if (!volume_name || !exact_match) {
-                graph->top = graph->first;
+    if (!volume_name || !exact_match) {
+        graph->top = graph->first;
+        ret = 0;
+    } else {
+        for (trav = graph->first; trav; trav = trav->next) {
+            if (strcmp(trav->name, volume_name) == 0) {
+                graph->top = trav;
                 ret = 0;
-        } else {
-                for (trav = graph->first; trav; trav = trav->next) {
-                        if (strcmp (trav->name, volume_name) == 0) {
-                                graph->top = trav;
-                                ret = 0;
-                                break;
-                        }
-                }
+                break;
+            }
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_parent_up (glusterfs_graph_t *graph)
+glusterfs_graph_parent_up(glusterfs_graph_t *graph)
 {
-        xlator_t *trav = NULL;
-        int       ret = -1;
+    xlator_t *trav = NULL;
+    int ret = -1;
 
-        trav = graph->first;
+    trav = graph->first;
 
-        while (trav) {
-                if (!xlator_has_parent (trav)) {
-                        ret = xlator_notify (trav, GF_EVENT_PARENT_UP, trav);
-                }
+    while (trav) {
+        if (!xlator_has_parent(trav)) {
+            ret = xlator_notify(trav, GF_EVENT_PARENT_UP, trav);
+        }
 
-                if (ret)
-                        break;
+        if (ret)
+            break;
 
-                trav = trav->next;
-        }
+        trav = trav->next;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
-                         char *volume_name)
+glusterfs_graph_prepare(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+                        char *volume_name)
 {
-        xlator_t    *trav = NULL;
-        int          ret = 0;
-
-        /* XXX: CHECKSUM */
-
-        /* XXX: attach to -n volname */
-        /* A '/' in the volume name suggests brick multiplexing is used, find
-         * the top of the (sub)graph. The volname MUST match the subvol in this
-         * case. In other cases (like for gfapi) the default top for the
-         * (sub)graph is ok. */
-        if (!volume_name) {
-                /* GlusterD does not pass a volume_name */
-                ret = glusterfs_graph_settop (graph, volume_name, _gf_false);
-        } else if (strncmp (volume_name, "/snaps/", 7) == 0) {
-                /* snap shots have their top xlator named like "/snaps/..."  */
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_false);
-        } else if (volume_name[0] == '/') {
-                /* brick multiplexing passes the brick path */
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_true);
-        } else {
-                ret = glusterfs_graph_settop (graph, volume_name,
-                                              _gf_false);
-        }
-        if (!ret) {
-                goto ok;
-        }
-
-        gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                "glusterfs graph settop failed");
-        return -1;
+    xlator_t *trav = NULL;
+    int ret = 0;
+
+    /* XXX: CHECKSUM */
+
+    /* XXX: attach to -n volname */
+    /* A '/' in the volume name suggests brick multiplexing is used, find
+     * the top of the (sub)graph. The volname MUST match the subvol in this
+     * case. In other cases (like for gfapi) the default top for the
+     * (sub)graph is ok. */
+    if (!volume_name) {
+        /* GlusterD does not pass a volume_name */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    } else if (strncmp(volume_name, "/snaps/", 7) == 0) {
+        /* snap shots have their top xlator named like "/snaps/..."  */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    } else if (volume_name[0] == '/') {
+        /* brick multiplexing passes the brick path */
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_true);
+    } else {
+        ret = glusterfs_graph_settop(graph, volume_name, _gf_false);
+    }
+    if (!ret) {
+        goto ok;
+    }
+
+    gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+           "glusterfs graph settop failed");
+    return -1;
 ok:
 
-        /* XXX: WORM VOLUME */
-        ret = glusterfs_graph_worm (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph worm failed");
-                return -1;
-        }
-        ret = glusterfs_graph_acl (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph ACL failed");
-                return -1;
-        }
+    /* XXX: WORM VOLUME */
+    ret = glusterfs_graph_worm(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph worm failed");
+        return -1;
+    }
+    ret = glusterfs_graph_acl(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph ACL failed");
+        return -1;
+    }
 
-        /* XXX: MAC COMPAT */
-        ret = glusterfs_graph_mac_compat (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph mac compat failed");
-                return -1;
-        }
+    /* XXX: MAC COMPAT */
+    ret = glusterfs_graph_mac_compat(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph mac compat failed");
+        return -1;
+    }
 
-        /* XXX: gfid-access */
-        ret = glusterfs_graph_gfid_access (graph, ctx);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-                        "glusterfs graph 'gfid-access' failed");
-                return -1;
-        }
+    /* XXX: gfid-access */
+    ret = glusterfs_graph_gfid_access(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph 'gfid-access' failed");
+        return -1;
+    }
 
-	/* XXX: topmost xlator */
-	ret = glusterfs_graph_meta (graph, ctx);
-	if (ret) {
-		gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
-			"glusterfs graph meta failed");
-		return -1;
-	}
+    /* XXX: topmost xlator */
+    ret = glusterfs_graph_meta(graph, ctx);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR,
+               "glusterfs graph meta failed");
+        return -1;
+    }
 
-        /* XXX: this->ctx setting */
-        for (trav = graph->first; trav; trav = trav->next) {
-                trav->ctx = ctx;
-        }
+    /* XXX: this->ctx setting */
+    for (trav = graph->first; trav; trav = trav->next) {
+        trav->ctx = ctx;
+    }
 
-        /* XXX: DOB setting */
-        gettimeofday (&graph->dob, NULL);
+    /* XXX: DOB setting */
+    gettimeofday(&graph->dob, NULL);
 
-        fill_uuid (graph->graph_uuid, 128);
+    fill_uuid(graph->graph_uuid, 128);
 
-        graph->id = ctx->graph_id++;
+    graph->id = ctx->graph_id++;
 
-        /* XXX: --xlator-option additions */
-        gf_add_cmdline_options (graph, &ctx->cmd_args);
+    /* XXX: --xlator-option additions */
+    gf_add_cmdline_options(graph, &ctx->cmd_args);
 
-        return 0;
+    return 0;
 }
 
-static
-xlator_t *glusterfs_root(glusterfs_graph_t *graph)
+static xlator_t *
+glusterfs_root(glusterfs_graph_t *graph)
 {
-        return graph->first;
+    return graph->first;
 }
 
-static
-int glusterfs_is_leaf(xlator_t *xl)
+static int
+glusterfs_is_leaf(xlator_t *xl)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!xl->children)
-                ret = 1;
+    if (!xl->children)
+        ret = 1;
 
-        return ret;
+    return ret;
 }
 
-static
-uint32_t glusterfs_count_leaves(xlator_t *xl)
+static uint32_t
+glusterfs_count_leaves(xlator_t *xl)
 {
-        int n = 0;
-        xlator_list_t *list = NULL;
+    int n = 0;
+    xlator_list_t *list = NULL;
 
-        if (glusterfs_is_leaf(xl))
-                n = 1;
-        else
-                for (list = xl->children; list; list = list->next)
-                        n += glusterfs_count_leaves(list->xlator);
+    if (glusterfs_is_leaf(xl))
+        n = 1;
+    else
+        for (list = xl->children; list; list = list->next)
+            n += glusterfs_count_leaves(list->xlator);
 
-        return n;
+    return n;
 }
 
-int glusterfs_get_leaf_count(glusterfs_graph_t *graph)
+int
+glusterfs_get_leaf_count(glusterfs_graph_t *graph)
 {
-        return graph->leaf_count;
+    return graph->leaf_count;
 }
 
-static
-int _glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl)
+static int
+_glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl)
 {
-        xlator_list_t *list = NULL;
-        int found = 0;
-
-        if (xl == tgt)
-                found = 1;
-        else if (glusterfs_is_leaf(xl))
-                *id += 1;
-        else
-                for (list = xl->children; !found && list; list = list->next)
-                        found = _glusterfs_leaf_position(tgt, id, list->xlator);
-
-        return found;
+    xlator_list_t *list = NULL;
+    int found = 0;
+
+    if (xl == tgt)
+        found = 1;
+    else if (glusterfs_is_leaf(xl))
+        *id += 1;
+    else
+        for (list = xl->children; !found && list; list = list->next)
+            found = _glusterfs_leaf_position(tgt, id, list->xlator);
+
+    return found;
 }
 
-int glusterfs_leaf_position(xlator_t *tgt)
+int
+glusterfs_leaf_position(xlator_t *tgt)
 {
-        xlator_t *root = NULL;
-        int pos = 0;
+    xlator_t *root = NULL;
+    int pos = 0;
 
-        root = glusterfs_root(tgt->graph);
+    root = glusterfs_root(tgt->graph);
 
-        if (!_glusterfs_leaf_position(tgt, &pos, root))
-                pos = -1;
+    if (!_glusterfs_leaf_position(tgt, &pos, root))
+        pos = -1;
 
-        return pos;
+    return pos;
 }
 
 static int
 _glusterfs_reachable_leaves(xlator_t *base, xlator_t *xl, dict_t *leaves)
 {
-        xlator_list_t *list = NULL;
-        int err = 1;
-        int pos = 0;
-        char *strpos = NULL;
+    xlator_list_t *list = NULL;
+    int err = 1;
+    int pos = 0;
+    char *strpos = NULL;
 
-        if (glusterfs_is_leaf(xl)) {
-                pos = glusterfs_leaf_position(xl);
-                if (pos < 0)
-                        goto out;
+    if (glusterfs_is_leaf(xl)) {
+        pos = glusterfs_leaf_position(xl);
+        if (pos < 0)
+            goto out;
 
-                err = gf_asprintf(&strpos, "%d", pos);
+        err = gf_asprintf(&strpos, "%d", pos);
 
-                if (err >= 0) {
-                        err = dict_set_static_ptr(leaves, strpos, base);
-                        GF_FREE (strpos);
-                }
-        } else {
-                for (err = 0, list = xl->children;
-                     !err && list;
-                     list = list->next)
-                        err = _glusterfs_reachable_leaves(base, list->xlator,
-                                                          leaves);
+        if (err >= 0) {
+            err = dict_set_static_ptr(leaves, strpos, base);
+            GF_FREE(strpos);
         }
+    } else {
+        for (err = 0, list = xl->children; !err && list; list = list->next)
+            err = _glusterfs_reachable_leaves(base, list->xlator, leaves);
+    }
 
 out:
-        return err;
+    return err;
 }
 
 /*
@@ -703,230 +691,226 @@ out:
 int
 glusterfs_reachable_leaves(xlator_t *base, dict_t *leaves)
 {
-        xlator_list_t *list = NULL;
-        int err = 0;
+    xlator_list_t *list = NULL;
+    int err = 0;
 
-        for (list = base->children; !err && list; list = list->next)
-                err = _glusterfs_reachable_leaves(list->xlator,
-                                                  list->xlator, leaves);
+    for (list = base->children; !err && list; list = list->next)
+        err = _glusterfs_reachable_leaves(list->xlator, list->xlator, leaves);
 
-        return err;
+    return err;
 }
 
 int
-glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+glusterfs_graph_activate(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
 {
-        int ret = 0;
-        xlator_t *root = NULL;
+    int ret = 0;
+    xlator_t *root = NULL;
 
-        root = glusterfs_root(graph);
+    root = glusterfs_root(graph);
 
-        graph->leaf_count = glusterfs_count_leaves(root);
+    graph->leaf_count = glusterfs_count_leaves(root);
 
-        /* XXX: all xlator options validation */
-        ret = glusterfs_graph_validate_options (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
-                        "validate options failed");
-                return ret;
-        }
-
-        /* XXX: perform init () */
-        ret = glusterfs_graph_init (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED,
-                        "init failed");
-                return ret;
-        }
+    /* XXX: all xlator options validation */
+    ret = glusterfs_graph_validate_options(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED,
+               "validate options failed");
+        return ret;
+    }
 
-        ret = glusterfs_graph_unknown_options (graph);
-        if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0,
-                        LG_MSG_UNKNOWN_OPTIONS_FAILED, "unknown options "
-                        "failed");
-                return ret;
-        }
+    /* XXX: perform init () */
+    ret = glusterfs_graph_init(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED,
+               "init failed");
+        return ret;
+    }
 
-        /* XXX: log full graph (_gf_dump_details) */
+    ret = glusterfs_graph_unknown_options(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_UNKNOWN_OPTIONS_FAILED,
+               "unknown options "
+               "failed");
+        return ret;
+    }
 
-        list_add (&graph->list, &ctx->graphs);
-        ctx->active = graph;
+    /* XXX: log full graph (_gf_dump_details) */
 
-        /* XXX: attach to master and set active pointer */
-        if (ctx->master) {
-                ret = xlator_notify (ctx->master, GF_EVENT_GRAPH_NEW, graph);
-                if (ret) {
-                        gf_msg ("graph", GF_LOG_ERROR, 0,
-                                LG_MSG_EVENT_NOTIFY_FAILED,
-                                "graph new notification failed");
-                        return ret;
-                }
-                ((xlator_t *)ctx->master)->next = graph->top;
-        }
+    list_add(&graph->list, &ctx->graphs);
+    ctx->active = graph;
 
-        /* XXX: perform parent up */
-        ret = glusterfs_graph_parent_up (graph);
+    /* XXX: attach to master and set active pointer */
+    if (ctx->master) {
+        ret = xlator_notify(ctx->master, GF_EVENT_GRAPH_NEW, graph);
         if (ret) {
-                gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
-                        "parent up notification failed");
-                return ret;
+            gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+                   "graph new notification failed");
+            return ret;
         }
+        ((xlator_t *)ctx->master)->next = graph->top;
+    }
+
+    /* XXX: perform parent up */
+    ret = glusterfs_graph_parent_up(graph);
+    if (ret) {
+        gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED,
+               "parent up notification failed");
+        return ret;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-xlator_equal_rec (xlator_t *xl1, xlator_t *xl2)
+xlator_equal_rec(xlator_t *xl1, xlator_t *xl2)
 {
-        xlator_list_t *trav1 = NULL;
-        xlator_list_t *trav2 = NULL;
-        int            ret   = 0;
+    xlator_list_t *trav1 = NULL;
+    xlator_list_t *trav2 = NULL;
+    int ret = 0;
 
-        if (xl1 == NULL || xl2 == NULL) {
-                gf_msg_debug ("xlator", 0, "invalid argument");
-                return -1;
-        }
-
-        trav1 = xl1->children;
-        trav2 = xl2->children;
-
-        while (trav1 && trav2) {
-                ret = xlator_equal_rec (trav1->xlator, trav2->xlator);
-                if (ret) {
-                        gf_msg_debug ("glusterfsd-mgmt", 0, "xlators children "
-                                      "not equal");
-                        goto out;
-                }
-
-                trav1 = trav1->next;
-                trav2 = trav2->next;
-        }
+    if (xl1 == NULL || xl2 == NULL) {
+        gf_msg_debug("xlator", 0, "invalid argument");
+        return -1;
+    }
 
-        if (trav1 || trav2) {
-                ret = -1;
-                goto out;
-        }
+    trav1 = xl1->children;
+    trav2 = xl2->children;
 
-        if (strcmp (xl1->name, xl2->name)) {
-                ret = -1;
-                goto out;
+    while (trav1 && trav2) {
+        ret = xlator_equal_rec(trav1->xlator, trav2->xlator);
+        if (ret) {
+            gf_msg_debug("glusterfsd-mgmt", 0,
+                         "xlators children "
+                         "not equal");
+            goto out;
         }
 
-	/* type could have changed even if xlator names match,
-	   e.g cluster/distribute and cluster/nufa share the same
-	   xlator name
-	*/
-        if (strcmp (xl1->type, xl2->type)) {
-                ret = -1;
-                goto out;
-        }
-out :
-        return ret;
+        trav1 = trav1->next;
+        trav2 = trav2->next;
+    }
+
+    if (trav1 || trav2) {
+        ret = -1;
+        goto out;
+    }
+
+    if (strcmp(xl1->name, xl2->name)) {
+        ret = -1;
+        goto out;
+    }
+
+    /* type could have changed even if xlator names match,
+       e.g cluster/distribute and cluster/nufa share the same
+       xlator name
+    */
+    if (strcmp(xl1->type, xl2->type)) {
+        ret = -1;
+        goto out;
+    }
+out:
+    return ret;
 }
 
-
 gf_boolean_t
-is_graph_topology_equal (glusterfs_graph_t *graph1, glusterfs_graph_t *graph2)
+is_graph_topology_equal(glusterfs_graph_t *graph1, glusterfs_graph_t *graph2)
 {
-        xlator_t      *trav1    = NULL;
-        xlator_t      *trav2    = NULL;
-        gf_boolean_t   ret      = _gf_true;
-        xlator_list_t *ltrav;
-
-        trav1 = graph1->first;
-        trav2 = graph2->first;
-
-        if (strcmp (trav2->type, "protocol/server") == 0) {
-                trav2 = trav2->children->xlator;
-                for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) {
-                        trav1 = ltrav->xlator;
-                        if (!trav1->cleanup_starting && !strcmp (trav1->name, trav2->name)) {
-                                break;
-                        }
-                }
-                if (!ltrav) {
-                        return _gf_false;
-                }
+    xlator_t *trav1 = NULL;
+    xlator_t *trav2 = NULL;
+    gf_boolean_t ret = _gf_true;
+    xlator_list_t *ltrav;
+
+    trav1 = graph1->first;
+    trav2 = graph2->first;
+
+    if (strcmp(trav2->type, "protocol/server") == 0) {
+        trav2 = trav2->children->xlator;
+        for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) {
+            trav1 = ltrav->xlator;
+            if (!trav1->cleanup_starting && !strcmp(trav1->name, trav2->name)) {
+                break;
+            }
+        }
+        if (!ltrav) {
+            return _gf_false;
         }
+    }
 
-        ret = xlator_equal_rec (trav1, trav2);
+    ret = xlator_equal_rec(trav1, trav2);
 
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are not equal");
-                ret = _gf_false;
-                goto out;
-        }
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0, "graphs are not equal");
+        ret = _gf_false;
+        goto out;
+    }
 
-        ret = _gf_true;
-        gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are equal");
+    ret = _gf_true;
+    gf_msg_debug("glusterfsd-mgmt", 0, "graphs are equal");
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Function has 3types of return value 0, -ve , 1
  *   return 0          =======> reconfiguration of options has succeeded
- *   return 1          =======> the graph has to be reconstructed and all the xlators should be inited
- *   return -1(or -ve) =======> Some Internal Error occurred during the operation
+ *   return 1          =======> the graph has to be reconstructed and all the
+ * xlators should be inited return -1(or -ve) =======> Some Internal Error
+ * occurred during the operation
  */
 int
-glusterfs_volfile_reconfigure (FILE *newvolfile_fp, glusterfs_ctx_t *ctx)
+glusterfs_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx)
 {
-        glusterfs_graph_t *oldvolfile_graph = NULL;
-        glusterfs_graph_t *newvolfile_graph = NULL;
-
-        int ret = -1;
-
-        if (!ctx) {
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
-                        "ctx is NULL");
-                goto out;
-        }
-
-        oldvolfile_graph = ctx->active;
-        if (!oldvolfile_graph) {
-                ret = 1;
-                goto out;
-        }
-
-        newvolfile_graph = glusterfs_graph_construct (newvolfile_fp);
-
-        if (!newvolfile_graph) {
-                goto out;
-        }
-
-        glusterfs_graph_prepare (newvolfile_graph, ctx,
-                                 ctx->cmd_args.volume_name);
-
-        if (!is_graph_topology_equal (oldvolfile_graph,
-                                      newvolfile_graph)) {
-
-                ret = 1;
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not "
-                              "equal(should call INIT)");
-                goto out;
-        }
-
-        gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the"
-                      " new graph");
-
-        ret = glusterfs_graph_reconfigure (oldvolfile_graph,
-                                           newvolfile_graph);
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure "
-                              "new options in old graph");
-                goto out;
-        }
-
-        ret = 0;
+    glusterfs_graph_t *oldvolfile_graph = NULL;
+    glusterfs_graph_t *newvolfile_graph = NULL;
+
+    int ret = -1;
+
+    if (!ctx) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "ctx is NULL");
+        goto out;
+    }
+
+    oldvolfile_graph = ctx->active;
+    if (!oldvolfile_graph) {
+        ret = 1;
+        goto out;
+    }
+
+    newvolfile_graph = glusterfs_graph_construct(newvolfile_fp);
+
+    if (!newvolfile_graph) {
+        goto out;
+    }
+
+    glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name);
+
+    if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) {
+        ret = 1;
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Graph topology not "
+                     "equal(should call INIT)");
+        goto out;
+    }
+
+    gf_msg_debug("glusterfsd-mgmt", 0,
+                 "Only options have changed in the"
+                 " new graph");
+
+    ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph);
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Could not reconfigure "
+                     "new options in old graph");
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        if (newvolfile_graph)
-                glusterfs_graph_destroy (newvolfile_graph);
+    if (newvolfile_graph)
+        glusterfs_graph_destroy(newvolfile_graph);
 
-        return ret;
+    return ret;
 }
 
 /* This function need to remove. This added to support gfapi volfile
@@ -934,183 +918,183 @@ out:
  */
 
 int
-gf_volfile_reconfigure (int oldvollen, FILE *newvolfile_fp,
-                        glusterfs_ctx_t *ctx, const char *oldvolfile)
+gf_volfile_reconfigure(int oldvollen, FILE *newvolfile_fp, glusterfs_ctx_t *ctx,
+                       const char *oldvolfile)
 {
-        glusterfs_graph_t *oldvolfile_graph = NULL;
-        glusterfs_graph_t *newvolfile_graph = NULL;
-        FILE              *oldvolfile_fp    = NULL;
-        /*Since the function mkstemp() replaces XXXXXX,
-         * assigning it to a variable
-         */
-        char temp_file[]                    = "/tmp/temp_vol_file_XXXXXX";
-        gf_boolean_t      active_graph_found = _gf_true;
-
-        int ret = -1;
-        int u_ret = -1;
-        int file_desc = -1;
-
-        if (!oldvollen) {
-                ret = 1; // Has to call INIT for the whole graph
-                goto out;
-        }
-
-        if (!ctx) {
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
-                        "ctx is NULL");
-                goto out;
-        }
-
-        oldvolfile_graph = ctx->active;
-        if (!oldvolfile_graph) {
-                active_graph_found = _gf_false;
-                gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0,
-                        LG_MSG_ACTIVE_GRAPH_NULL,
-                        "glusterfs_ctx->active is NULL");
+    glusterfs_graph_t *oldvolfile_graph = NULL;
+    glusterfs_graph_t *newvolfile_graph = NULL;
+    FILE *oldvolfile_fp = NULL;
+    /*Since the function mkstemp() replaces XXXXXX,
+     * assigning it to a variable
+     */
+    char temp_file[] = "/tmp/temp_vol_file_XXXXXX";
+    gf_boolean_t active_graph_found = _gf_true;
+
+    int ret = -1;
+    int u_ret = -1;
+    int file_desc = -1;
+
+    if (!oldvollen) {
+        ret = 1;  // Has to call INIT for the whole graph
+        goto out;
+    }
+
+    if (!ctx) {
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL,
+               "ctx is NULL");
+        goto out;
+    }
+
+    oldvolfile_graph = ctx->active;
+    if (!oldvolfile_graph) {
+        active_graph_found = _gf_false;
+        gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_ACTIVE_GRAPH_NULL,
+               "glusterfs_ctx->active is NULL");
 
         /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-                file_desc = mkstemp(temp_file);
-                if (file_desc < 0) {
-                        gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno,
-                                LG_MSG_TMPFILE_CREATE_FAILED, "Unable to "
-                                "create temporary volfile");
-                        goto out;
-                }
-
-                /*Calling unlink so that when the file is closed or program
-                 *terminates the tempfile is deleted.
-                 */
-                u_ret = sys_unlink(temp_file);
-
-                if (u_ret < 0) {
-                        gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno,
-                                LG_MSG_TMPFILE_DELETE_FAILED, "Temporary file"
-                                " delete failed.");
-                        sys_close (file_desc);
-                        goto out;
-                }
-
-
-                oldvolfile_fp = fdopen (file_desc, "w+b");
-                if (!oldvolfile_fp)
-                        goto out;
-
-                fwrite (oldvolfile, oldvollen, 1, oldvolfile_fp);
-                fflush (oldvolfile_fp);
-                if (ferror (oldvolfile_fp)) {
-                        goto out;
-                }
-
-                oldvolfile_graph = glusterfs_graph_construct (oldvolfile_fp);
-                if (!oldvolfile_graph)
-                        goto out;
-        }
-
-        newvolfile_graph = glusterfs_graph_construct (newvolfile_fp);
-        if (!newvolfile_graph) {
-                goto out;
+        file_desc = mkstemp(temp_file);
+        if (file_desc < 0) {
+            gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno,
+                   LG_MSG_TMPFILE_CREATE_FAILED,
+                   "Unable to "
+                   "create temporary volfile");
+            goto out;
         }
 
-        glusterfs_graph_prepare (newvolfile_graph, ctx,
-                                 ctx->cmd_args.volume_name);
-
-        if (!is_graph_topology_equal (oldvolfile_graph,
-                                      newvolfile_graph)) {
-
-                ret = 1;
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not "
-                              "equal(should call INIT)");
-                goto out;
+        /*Calling unlink so that when the file is closed or program
+         *terminates the tempfile is deleted.
+         */
+        u_ret = sys_unlink(temp_file);
+
+        if (u_ret < 0) {
+            gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno,
+                   LG_MSG_TMPFILE_DELETE_FAILED,
+                   "Temporary file"
+                   " delete failed.");
+            sys_close(file_desc);
+            goto out;
         }
 
-        gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the"
-                      " new graph");
+        oldvolfile_fp = fdopen(file_desc, "w+b");
+        if (!oldvolfile_fp)
+            goto out;
 
-        /* */
-        ret = glusterfs_graph_reconfigure (oldvolfile_graph,
-                                           newvolfile_graph);
-        if (ret) {
-                gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure "
-                              "new options in old graph");
-                goto out;
+        fwrite(oldvolfile, oldvollen, 1, oldvolfile_fp);
+        fflush(oldvolfile_fp);
+        if (ferror(oldvolfile_fp)) {
+            goto out;
         }
 
-        ret = 0;
+        oldvolfile_graph = glusterfs_graph_construct(oldvolfile_fp);
+        if (!oldvolfile_graph)
+            goto out;
+    }
+
+    newvolfile_graph = glusterfs_graph_construct(newvolfile_fp);
+    if (!newvolfile_graph) {
+        goto out;
+    }
+
+    glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name);
+
+    if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) {
+        ret = 1;
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Graph topology not "
+                     "equal(should call INIT)");
+        goto out;
+    }
+
+    gf_msg_debug("glusterfsd-mgmt", 0,
+                 "Only options have changed in the"
+                 " new graph");
+
+    /* */
+    ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph);
+    if (ret) {
+        gf_msg_debug("glusterfsd-mgmt", 0,
+                     "Could not reconfigure "
+                     "new options in old graph");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (oldvolfile_fp)
-                fclose (oldvolfile_fp);
-
-        /*  Do not simply destroy the old graph here. If the oldgraph
-            is constructed here in this function itself instead of getting
-            it from ctx->active (which happens only of ctx->active is NULL),
-            then destroy the old graph. If some i/o is still happening in
-            the old graph and the old graph is obtained from ctx->active,
-            then destroying the graph will cause problems.
-        */
-        if (!active_graph_found && oldvolfile_graph)
-                glusterfs_graph_destroy (oldvolfile_graph);
-        if (newvolfile_graph)
-                glusterfs_graph_destroy (newvolfile_graph);
-
-        return ret;
+    if (oldvolfile_fp)
+        fclose(oldvolfile_fp);
+
+    /*  Do not simply destroy the old graph here. If the oldgraph
+        is constructed here in this function itself instead of getting
+        it from ctx->active (which happens only of ctx->active is NULL),
+        then destroy the old graph. If some i/o is still happening in
+        the old graph and the old graph is obtained from ctx->active,
+        then destroying the graph will cause problems.
+    */
+    if (!active_graph_found && oldvolfile_graph)
+        glusterfs_graph_destroy(oldvolfile_graph);
+    if (newvolfile_graph)
+        glusterfs_graph_destroy(newvolfile_graph);
+
+    return ret;
 }
 
 int
-glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph,
-                             glusterfs_graph_t *newgraph)
+glusterfs_graph_reconfigure(glusterfs_graph_t *oldgraph,
+                            glusterfs_graph_t *newgraph)
 {
-        xlator_t        *old_xl   = NULL;
-        xlator_t        *new_xl   = NULL;
-        xlator_list_t   *trav;
-
-        GF_ASSERT (oldgraph);
-        GF_ASSERT (newgraph);
-
-        old_xl   = oldgraph->first;
-        while (old_xl->is_autoloaded) {
-                old_xl = old_xl->children->xlator;
-        }
-
-        new_xl   = newgraph->first;
-        while (new_xl->is_autoloaded) {
-                new_xl = new_xl->children->xlator;
-        }
-
-        if (strcmp (old_xl->type, "protocol/server") != 0) {
-                return xlator_tree_reconfigure (old_xl, new_xl);
-        }
-
-        /* Some options still need to be handled by the server translator. */
-        if (old_xl->reconfigure) {
-                old_xl->reconfigure (old_xl, new_xl->options);
-        }
-
-        (void) copy_opts_to_child (new_xl, FIRST_CHILD (new_xl), "*auth*");
-        new_xl = FIRST_CHILD (new_xl);
-
-        for (trav = old_xl->children; trav; trav = trav->next) {
-                if (!trav->xlator->cleanup_starting && !strcmp (trav->xlator->name, new_xl->name)) {
-                        return xlator_tree_reconfigure (trav->xlator, new_xl);
-                }
+    xlator_t *old_xl = NULL;
+    xlator_t *new_xl = NULL;
+    xlator_list_t *trav;
+
+    GF_ASSERT(oldgraph);
+    GF_ASSERT(newgraph);
+
+    old_xl = oldgraph->first;
+    while (old_xl->is_autoloaded) {
+        old_xl = old_xl->children->xlator;
+    }
+
+    new_xl = newgraph->first;
+    while (new_xl->is_autoloaded) {
+        new_xl = new_xl->children->xlator;
+    }
+
+    if (strcmp(old_xl->type, "protocol/server") != 0) {
+        return xlator_tree_reconfigure(old_xl, new_xl);
+    }
+
+    /* Some options still need to be handled by the server translator. */
+    if (old_xl->reconfigure) {
+        old_xl->reconfigure(old_xl, new_xl->options);
+    }
+
+    (void)copy_opts_to_child(new_xl, FIRST_CHILD(new_xl), "*auth*");
+    new_xl = FIRST_CHILD(new_xl);
+
+    for (trav = old_xl->children; trav; trav = trav->next) {
+        if (!trav->xlator->cleanup_starting &&
+            !strcmp(trav->xlator->name, new_xl->name)) {
+            return xlator_tree_reconfigure(trav->xlator, new_xl);
         }
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-glusterfs_graph_destroy_residual (glusterfs_graph_t *graph)
+glusterfs_graph_destroy_residual(glusterfs_graph_t *graph)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (graph == NULL)
-                return ret;
+    if (graph == NULL)
+        return ret;
 
-        ret = xlator_tree_free_memacct (graph->first);
+    ret = xlator_tree_free_memacct(graph->first);
 
-        list_del_init (&graph->list);
-        GF_FREE (graph);
+    list_del_init(&graph->list);
+    GF_FREE(graph);
 
-        return ret;
+    return ret;
 }
 
 /* This function destroys all the xlator members except for the
@@ -1136,137 +1120,139 @@ glusterfs_graph_destroy_residual (glusterfs_graph_t *graph)
  *   object itself.
  */
 int
-glusterfs_graph_destroy (glusterfs_graph_t *graph)
+glusterfs_graph_destroy(glusterfs_graph_t *graph)
 {
-        int ret = 0;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("graph", graph, out);
+    GF_VALIDATE_OR_GOTO("graph", graph, out);
 
-        ret = xlator_tree_free_members (graph->first);
+    ret = xlator_tree_free_members(graph->first);
 
-        ret = glusterfs_graph_destroy_residual (graph);
+    ret = glusterfs_graph_destroy_residual(graph);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterfs_graph_attach (glusterfs_graph_t *orig_graph, char *path,
-                        glusterfs_graph_t **newgraph)
+glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path,
+                       glusterfs_graph_t **newgraph)
 {
-        xlator_t                *this   = THIS;
-        FILE                    *fp;
-        glusterfs_graph_t       *graph;
-        xlator_t                *xl;
-        char                    *volfile_id                        = NULL;
-        char                    *volfile_content                   = NULL;
-        struct stat              stbuf                             = {0,};
-        size_t                   file_len                          = -1;
-        gf_volfile_t            *volfile_obj                       = NULL;
-        int                      ret                               = -1;
-        char                     sha256_hash[SHA256_DIGEST_LENGTH] = {0, };
-
-        if (!orig_graph) {
-                return -EINVAL;
-        }
-
-        ret = sys_stat (path, &stbuf);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)",
-                        path, strerror (errno));
-                return -EINVAL;
-        }
-
-        file_len = stbuf.st_size;
-        volfile_content = GF_MALLOC (file_len+1, gf_common_mt_char);
-        if (!volfile_content)
-                return -ENOMEM;
-
-        fp = fopen (path, "r");
-        if (!fp) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "oops, %s disappeared on us", path);
-                GF_FREE (volfile_content);
-                return -EIO;
-        }
-
-        ret = fread (volfile_content, sizeof (char), file_len, fp);
-        if (ret == file_len) {
-              glusterfs_compute_sha256 ((const unsigned char *) volfile_content,
-                                         file_len, sha256_hash);
-        } else {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "read failed on path %s. File size=%"GF_PRI_SIZET
-                        "read size=%d", path, file_len, ret);
-                GF_FREE (volfile_content);
-                fclose (fp);
-                return -EIO;
-        }
-
-        GF_FREE (volfile_content);
-
-        graph = glusterfs_graph_construct (fp);
+    xlator_t *this = THIS;
+    FILE *fp;
+    glusterfs_graph_t *graph;
+    xlator_t *xl;
+    char *volfile_id = NULL;
+    char *volfile_content = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    size_t file_len = -1;
+    gf_volfile_t *volfile_obj = NULL;
+    int ret = -1;
+    char sha256_hash[SHA256_DIGEST_LENGTH] = {
+        0,
+    };
+
+    if (!orig_graph) {
+        return -EINVAL;
+    }
+
+    ret = sys_stat(path, &stbuf);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)", path,
+               strerror(errno));
+        return -EINVAL;
+    }
+
+    file_len = stbuf.st_size;
+    volfile_content = GF_MALLOC(file_len + 1, gf_common_mt_char);
+    if (!volfile_content)
+        return -ENOMEM;
+
+    fp = fopen(path, "r");
+    if (!fp) {
+        gf_log(THIS->name, GF_LOG_WARNING, "oops, %s disappeared on us", path);
+        GF_FREE(volfile_content);
+        return -EIO;
+    }
+
+    ret = fread(volfile_content, sizeof(char), file_len, fp);
+    if (ret == file_len) {
+        glusterfs_compute_sha256((const unsigned char *)volfile_content,
+                                 file_len, sha256_hash);
+    } else {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "read failed on path %s. File size=%" GF_PRI_SIZET
+               "read size=%d",
+               path, file_len, ret);
+        GF_FREE(volfile_content);
         fclose(fp);
-        if (!graph) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "could not create graph from %s", path);
-                return -EIO;
-        }
-
-        /*
-         * If there's a server translator on top, we want whatever's below
-         * that.
-         */
-        xl = graph->first;
-        if (strcmp(xl->type, "protocol/server") == 0) {
-                (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*");
-                xl = FIRST_CHILD(xl);
-        }
-        graph->first = xl;
-        *newgraph = graph;
-
-        volfile_id = strstr (path, "/snaps/");
-        if (!volfile_id) {
-                volfile_id = rindex (path, '/');
-                if (volfile_id) {
-                        ++volfile_id;
-                }
-        }
+        return -EIO;
+    }
+
+    GF_FREE(volfile_content);
+
+    graph = glusterfs_graph_construct(fp);
+    fclose(fp);
+    if (!graph) {
+        gf_log(this->name, GF_LOG_WARNING, "could not create graph from %s",
+               path);
+        return -EIO;
+    }
+
+    /*
+     * If there's a server translator on top, we want whatever's below
+     * that.
+     */
+    xl = graph->first;
+    if (strcmp(xl->type, "protocol/server") == 0) {
+        (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*");
+        xl = FIRST_CHILD(xl);
+    }
+    graph->first = xl;
+    *newgraph = graph;
+
+    volfile_id = strstr(path, "/snaps/");
+    if (!volfile_id) {
+        volfile_id = rindex(path, '/');
         if (volfile_id) {
-                xl->volfile_id = gf_strdup (volfile_id);
-                /* There's a stray ".vol" at the end. */
-                xl->volfile_id[strlen(xl->volfile_id)-4] = '\0';
-        }
-
-        /* TODO memory leaks everywhere need to free graph in case of error */
-        if (glusterfs_graph_prepare (graph, this->ctx, xl->name)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to prepare graph for xlator %s", xl->name);
-                return -EIO;
-        } else if (glusterfs_graph_init (graph)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to initialize graph for xlator %s", xl->name);
-                return -EIO;
-        } else if (glusterfs_xlator_link (orig_graph->top, graph->top)) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to link the graphs for xlator %s ", xl->name);
-                return -EIO;
+            ++volfile_id;
         }
-
+    }
+    if (volfile_id) {
+        xl->volfile_id = gf_strdup(volfile_id);
+        /* There's a stray ".vol" at the end. */
+        xl->volfile_id[strlen(xl->volfile_id) - 4] = '\0';
+    }
+
+    /* TODO memory leaks everywhere need to free graph in case of error */
+    if (glusterfs_graph_prepare(graph, this->ctx, xl->name)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to prepare graph for xlator %s", xl->name);
+        return -EIO;
+    } else if (glusterfs_graph_init(graph)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to initialize graph for xlator %s", xl->name);
+        return -EIO;
+    } else if (glusterfs_xlator_link(orig_graph->top, graph->top)) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "failed to link the graphs for xlator %s ", xl->name);
+        return -EIO;
+    }
+
+    if (!volfile_obj) {
+        volfile_obj = GF_CALLOC(1, sizeof(gf_volfile_t), gf_common_volfile_t);
         if (!volfile_obj) {
-                volfile_obj = GF_CALLOC (1, sizeof (gf_volfile_t),
-                                         gf_common_volfile_t);
-                if (!volfile_obj) {
-                        return -EIO;
-                }
+            return -EIO;
         }
+    }
 
-        INIT_LIST_HEAD (&volfile_obj->volfile_list);
-        snprintf (volfile_obj->vol_id, sizeof (volfile_obj->vol_id),
-                  "%s", xl->volfile_id);
-        memcpy (volfile_obj->volfile_checksum, sha256_hash,
-                 sizeof (volfile_obj->volfile_checksum));
-        list_add (&volfile_obj->volfile_list, &this->ctx->volfile_list);
+    INIT_LIST_HEAD(&volfile_obj->volfile_list);
+    snprintf(volfile_obj->vol_id, sizeof(volfile_obj->vol_id), "%s",
+             xl->volfile_id);
+    memcpy(volfile_obj->volfile_checksum, sha256_hash,
+           sizeof(volfile_obj->volfile_checksum));
+    list_add(&volfile_obj->volfile_list, &this->ctx->volfile_list);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/hashfn.c b/libglusterfs/src/hashfn.c
index 62f7ab87800..5c4561f1ee8 100644
--- a/libglusterfs/src/hashfn.c
+++ b/libglusterfs/src/hashfn.c
@@ -13,21 +13,20 @@
 
 #include "hashfn.h"
 
-#define get16bits(d) (*((const uint16_t *) (d)))
+#define get16bits(d) (*((const uint16_t *)(d)))
 
 #define DM_DELTA 0x9E3779B9
-#define DM_FULLROUNDS 10        /* 32 is overkill, 16 is strong crypto */
-#define DM_PARTROUNDS 6         /* 6 gets complete mixing */
-
+#define DM_FULLROUNDS 10 /* 32 is overkill, 16 is strong crypto */
+#define DM_PARTROUNDS 6  /* 6 gets complete mixing */
 
 uint32_t
-ReallySimpleHash (char *path, int len)
+ReallySimpleHash(char *path, int len)
 {
-        uint32_t        hash = 0;
-        for (;len > 0; len--)
-                hash ^= (char)path[len];
+    uint32_t hash = 0;
+    for (; len > 0; len--)
+        hash ^= (char)path[len];
 
-        return hash;
+    return hash;
 }
 
 /*
@@ -37,146 +36,145 @@ ReallySimpleHash (char *path, int len)
 
 /* In any case make sure, you return 1 */
 
-uint32_t SuperFastHash (const char * data, int32_t len) {
-        uint32_t hash = len, tmp;
-        int32_t rem;
-
-        if (len <= 1 || data == NULL) return 1;
-
-        rem = len & 3;
-        len >>= 2;
-
-        /* Main loop */
-        for (;len > 0; len--) {
-                hash  += get16bits (data);
-                tmp    = (get16bits (data+2) << 11) ^ hash;
-                hash   = (hash << 16) ^ tmp;
-                data  += 2*sizeof (uint16_t);
-                hash  += hash >> 11;
-        }
-
-        /* Handle end cases */
-        switch (rem) {
-        case 3: hash += get16bits (data);
-                hash ^= hash << 16;
-                hash ^= data[sizeof (uint16_t)] << 18;
-                hash += hash >> 11;
-                break;
-        case 2: hash += get16bits (data);
-                hash ^= hash << 11;
-                hash += hash >> 17;
-                break;
-        case 1: hash += *data;
-                hash ^= hash << 10;
-                hash += hash >> 1;
-        }
-
-        /* Force "avalanching" of final 127 bits */
-        hash ^= hash << 3;
-        hash += hash >> 5;
-        hash ^= hash << 4;
-        hash += hash >> 17;
-        hash ^= hash << 25;
-        hash += hash >> 6;
-
-        return hash;
+uint32_t
+SuperFastHash(const char *data, int32_t len)
+{
+    uint32_t hash = len, tmp;
+    int32_t rem;
+
+    if (len <= 1 || data == NULL)
+        return 1;
+
+    rem = len & 3;
+    len >>= 2;
+
+    /* Main loop */
+    for (; len > 0; len--) {
+        hash += get16bits(data);
+        tmp = (get16bits(data + 2) << 11) ^ hash;
+        hash = (hash << 16) ^ tmp;
+        data += 2 * sizeof(uint16_t);
+        hash += hash >> 11;
+    }
+
+    /* Handle end cases */
+    switch (rem) {
+        case 3:
+            hash += get16bits(data);
+            hash ^= hash << 16;
+            hash ^= data[sizeof(uint16_t)] << 18;
+            hash += hash >> 11;
+            break;
+        case 2:
+            hash += get16bits(data);
+            hash ^= hash << 11;
+            hash += hash >> 17;
+            break;
+        case 1:
+            hash += *data;
+            hash ^= hash << 10;
+            hash += hash >> 1;
+    }
+
+    /* Force "avalanching" of final 127 bits */
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+
+    return hash;
 }
 
-
 /* Davies-Meyer hashing function implementation
  */
 static int
-dm_round (int rounds, uint32_t *array, uint32_t *h0, uint32_t *h1)
+dm_round(int rounds, uint32_t *array, uint32_t *h0, uint32_t *h1)
 {
-        uint32_t sum = 0;
-        int      n = 0;
-        uint32_t b0  = 0;
-        uint32_t b1  = 0;
-
-        b0 = *h0;
-        b1 = *h1;
-
-        n = rounds;
-
-        do {
-                sum += DM_DELTA;
-                b0  += ((b1 << 4) + array[0])
-                        ^ (b1 + sum)
-                        ^ ((b1 >> 5) + array[1]);
-                b1  += ((b0 << 4) + array[2])
-                        ^ (b0 + sum)
-                        ^ ((b0 >> 5) + array[3]);
-        } while (--n);
-
-        *h0 += b0;
-        *h1 += b1;
-
-        return 0;
-}
+    uint32_t sum = 0;
+    int n = 0;
+    uint32_t b0 = 0;
+    uint32_t b1 = 0;
+
+    b0 = *h0;
+    b1 = *h1;
+
+    n = rounds;
+
+    do {
+        sum += DM_DELTA;
+        b0 += ((b1 << 4) + array[0]) ^ (b1 + sum) ^ ((b1 >> 5) + array[1]);
+        b1 += ((b0 << 4) + array[2]) ^ (b0 + sum) ^ ((b0 >> 5) + array[3]);
+    } while (--n);
 
+    *h0 += b0;
+    *h1 += b1;
+
+    return 0;
+}
 
 uint32_t
-__pad (int len)
+__pad(int len)
 {
-        uint32_t pad = 0;
+    uint32_t pad = 0;
 
-        pad = (uint32_t) len | ((uint32_t) len << 8);
-        pad |= pad << 16;
+    pad = (uint32_t)len | ((uint32_t)len << 8);
+    pad |= pad << 16;
 
-        return pad;
+    return pad;
 }
 
 uint32_t
-gf_dm_hashfn (const char *msg, int len)
+gf_dm_hashfn(const char *msg, int len)
 {
-        uint32_t  h0 = 0x9464a485;
-        uint32_t  h1 = 0x542e1a94;
-        uint32_t  array[4];
-        uint32_t  pad = 0;
-        int       i = 0;
-        int       j = 0;
-        int       full_quads = 0;
-        int       full_words = 0;
-        int       full_bytes = 0;
-        uint32_t *intmsg = NULL;
-        int       word = 0;
-
-
-        intmsg = (uint32_t *) msg;
-        pad = __pad (len);
-
-        full_bytes   = len;
-        full_words   = len / 4;
-        full_quads   = len / 16;
-
-        for (i = 0; i < full_quads; i++) {
-                for (j = 0; j < 4; j++) {
-                        word     = *intmsg;
-                        array[j] = word;
-                        intmsg++;
-                        full_words--;
-                        full_bytes -= 4;
-                }
-                dm_round (DM_PARTROUNDS, &array[0], &h0, &h1);
-        }
-
+    uint32_t h0 = 0x9464a485;
+    uint32_t h1 = 0x542e1a94;
+    uint32_t array[4];
+    uint32_t pad = 0;
+    int i = 0;
+    int j = 0;
+    int full_quads = 0;
+    int full_words = 0;
+    int full_bytes = 0;
+    uint32_t *intmsg = NULL;
+    int word = 0;
+
+    intmsg = (uint32_t *)msg;
+    pad = __pad(len);
+
+    full_bytes = len;
+    full_words = len / 4;
+    full_quads = len / 16;
+
+    for (i = 0; i < full_quads; i++) {
         for (j = 0; j < 4; j++) {
-                if (full_words) {
-                        word     = *intmsg;
-                        array[j] = word;
-                        intmsg++;
-                        full_words--;
-                        full_bytes -= 4;
-                } else {
-                        array[j] = pad;
-                        while (full_bytes) {
-                                array[j] <<= 8;
-                                array[j] |= msg[len - full_bytes];
-                                full_bytes--;
-                        }
-                }
+            word = *intmsg;
+            array[j] = word;
+            intmsg++;
+            full_words--;
+            full_bytes -= 4;
+        }
+        dm_round(DM_PARTROUNDS, &array[0], &h0, &h1);
+    }
+
+    for (j = 0; j < 4; j++) {
+        if (full_words) {
+            word = *intmsg;
+            array[j] = word;
+            intmsg++;
+            full_words--;
+            full_bytes -= 4;
+        } else {
+            array[j] = pad;
+            while (full_bytes) {
+                array[j] <<= 8;
+                array[j] |= msg[len - full_bytes];
+                full_bytes--;
+            }
         }
-        dm_round (DM_FULLROUNDS, &array[0], &h0, &h1);
+    }
+    dm_round(DM_FULLROUNDS, &array[0], &h0, &h1);
 
-        return h0 ^ h1;
+    return h0 ^ h1;
 }
diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index 70909bf596f..ee85c0e793c 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -23,676 +23,651 @@
    move latest accessed dentry to list_head of inode
 */
 
-#define INODE_DUMP_LIST(head, key_buf, key_prefix, list_type)           \
-        {                                                               \
-                int i = 1;                                              \
-                inode_t *inode = NULL;                                  \
-                list_for_each_entry (inode, head, list) {               \
-                        gf_proc_dump_build_key(key_buf, key_prefix,     \
-                                               "%s.%d",list_type, i++); \
-                        gf_proc_dump_add_section(key_buf);              \
-                        inode_dump(inode, key);                         \
-                }                                                       \
-        }
+#define INODE_DUMP_LIST(head, key_buf, key_prefix, list_type)                  \
+    {                                                                          \
+        int i = 1;                                                             \
+        inode_t *inode = NULL;                                                 \
+        list_for_each_entry(inode, head, list)                                 \
+        {                                                                      \
+            gf_proc_dump_build_key(key_buf, key_prefix, "%s.%d", list_type,    \
+                                   i++);                                       \
+            gf_proc_dump_add_section(key_buf);                                 \
+            inode_dump(inode, key);                                            \
+        }                                                                      \
+    }
 
 static inode_t *
-__inode_unref (inode_t *inode);
+__inode_unref(inode_t *inode);
 
 static int
-inode_table_prune (inode_table_t *table);
+inode_table_prune(inode_table_t *table);
 
 void
-fd_dump (struct list_head *head, char *prefix);
+fd_dump(struct list_head *head, char *prefix);
 
 static int
-hash_dentry (inode_t *parent, const char *name, int mod)
+hash_dentry(inode_t *parent, const char *name, int mod)
 {
-        int hash = 0;
-        int ret = 0;
+    int hash = 0;
+    int ret = 0;
 
-        hash = *name;
-        if (hash) {
-                for (name += 1; *name != '\0'; name++) {
-                        hash = (hash << 5) - hash + *name;
-                }
+    hash = *name;
+    if (hash) {
+        for (name += 1; *name != '\0'; name++) {
+            hash = (hash << 5) - hash + *name;
         }
-        ret = (hash + (unsigned long)parent) % mod;
+    }
+    ret = (hash + (unsigned long)parent) % mod;
 
-        return ret;
+    return ret;
 }
 
-
 static int
-hash_gfid (uuid_t uuid, int mod)
+hash_gfid(uuid_t uuid, int mod)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = uuid[15] + (uuid[14] << 8);
+    ret = uuid[15] + (uuid[14] << 8);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__dentry_hash (dentry_t *dentry)
+__dentry_hash(dentry_t *dentry)
 {
-        inode_table_t   *table = NULL;
-        int              hash = 0;
+    inode_table_t *table = NULL;
+    int hash = 0;
 
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return;
+    }
 
-        table = dentry->inode->table;
-        hash = hash_dentry (dentry->parent, dentry->name,
-                            table->hashsize);
+    table = dentry->inode->table;
+    hash = hash_dentry(dentry->parent, dentry->name, table->hashsize);
 
-        list_del_init (&dentry->hash);
-        list_add (&dentry->hash, &table->name_hash[hash]);
+    list_del_init(&dentry->hash);
+    list_add(&dentry->hash, &table->name_hash[hash]);
 }
 
-
 static int
-__is_dentry_hashed (dentry_t *dentry)
+__is_dentry_hashed(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return 0;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return 0;
+    }
 
-        return !list_empty (&dentry->hash);
+    return !list_empty(&dentry->hash);
 }
 
-
 static void
-__dentry_unhash (dentry_t *dentry)
+__dentry_unhash(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return;
+    }
 
-        list_del_init (&dentry->hash);
+    list_del_init(&dentry->hash);
 }
 
-
 static void
-__dentry_unset (dentry_t *dentry)
+__dentry_unset(dentry_t *dentry)
 {
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return;
+    }
 
-        __dentry_unhash (dentry);
+    __dentry_unhash(dentry);
 
-        list_del_init (&dentry->inode_list);
+    list_del_init(&dentry->inode_list);
 
-        GF_FREE (dentry->name);
-        dentry->name = NULL;
+    GF_FREE(dentry->name);
+    dentry->name = NULL;
 
-        if (dentry->parent) {
-                __inode_unref (dentry->parent);
-                dentry->parent = NULL;
-        }
+    if (dentry->parent) {
+        __inode_unref(dentry->parent);
+        dentry->parent = NULL;
+    }
 
-        mem_put (dentry);
+    mem_put(dentry);
 }
 
-
 static int
-__foreach_ancestor_dentry (dentry_t *dentry,
-                           int (per_dentry_fn) (dentry_t *dentry,
-                                                void *data),
-                           void *data)
-{
-        inode_t  *parent = NULL;
-        dentry_t *each = NULL;
-        int       ret = 0;
-
-        if (!dentry) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_DENTRY_NOT_FOUND, "dentry not found");
-                return 0;
-        }
-
-        ret = per_dentry_fn (dentry, data);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_PER_DENTRY_FAILED, "per dentry fn returned %d",
-                        ret);
-                goto out;
-        }
-
-        parent = dentry->parent;
-        if (!parent) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_PARENT_DENTRY_NOT_FOUND,
-                        "parent not found");
-                goto out;
-        }
+__foreach_ancestor_dentry(dentry_t *dentry,
+                          int(per_dentry_fn)(dentry_t *dentry, void *data),
+                          void *data)
+{
+    inode_t *parent = NULL;
+    dentry_t *each = NULL;
+    int ret = 0;
 
-        list_for_each_entry (each, &parent->dentry_list, inode_list) {
-                ret = __foreach_ancestor_dentry (each, per_dentry_fn, data);
-                if (ret)
-                        goto out;
-        }
+    if (!dentry) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+                         "dentry not found");
+        return 0;
+    }
+
+    ret = per_dentry_fn(dentry, data);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PER_DENTRY_FAILED,
+               "per dentry fn returned %d", ret);
+        goto out;
+    }
+
+    parent = dentry->parent;
+    if (!parent) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PARENT_DENTRY_NOT_FOUND,
+               "parent not found");
+        goto out;
+    }
+
+    list_for_each_entry(each, &parent->dentry_list, inode_list)
+    {
+        ret = __foreach_ancestor_dentry(each, per_dentry_fn, data);
+        if (ret)
+            goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__check_cycle (dentry_t *a_dentry, void *data)
+__check_cycle(dentry_t *a_dentry, void *data)
 {
-        inode_t *link_inode = NULL;
+    inode_t *link_inode = NULL;
 
-        link_inode = data;
+    link_inode = data;
 
-        if (a_dentry->parent == link_inode)
-                return 1;
+    if (a_dentry->parent == link_inode)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
-
 static int
-__is_dentry_cyclic (dentry_t *dentry)
+__is_dentry_cyclic(dentry_t *dentry)
 {
-        int       ret = 0;
-        inode_t  *inode = NULL;
-        char     *name = "<nul>";
+    int ret = 0;
+    inode_t *inode = NULL;
+    char *name = "<nul>";
 
-        ret = __foreach_ancestor_dentry (dentry, __check_cycle,
-                                         dentry->inode);
-        if (ret) {
-                inode = dentry->inode;
+    ret = __foreach_ancestor_dentry(dentry, __check_cycle, dentry->inode);
+    if (ret) {
+        inode = dentry->inode;
 
-                if (dentry->name)
-                        name = dentry->name;
+        if (dentry->name)
+            name = dentry->name;
 
-                gf_msg (dentry->inode->table->name, GF_LOG_CRITICAL, 0,
-                        LG_MSG_DENTRY_CYCLIC_LOOP, "detected cyclic loop "
-                        "formation during inode linkage. inode (%s) linking "
-                        "under itself as %s", uuid_utoa (inode->gfid), name);
-        }
+        gf_msg(dentry->inode->table->name, GF_LOG_CRITICAL, 0,
+               LG_MSG_DENTRY_CYCLIC_LOOP,
+               "detected cyclic loop "
+               "formation during inode linkage. inode (%s) linking "
+               "under itself as %s",
+               uuid_utoa(inode->gfid), name);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__inode_unhash (inode_t *inode)
+__inode_unhash(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        list_del_init (&inode->hash);
+    list_del_init(&inode->hash);
 }
 
-
 static int
-__is_inode_hashed (inode_t *inode)
+__is_inode_hashed(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return 0;
+    }
 
-        return !list_empty (&inode->hash);
+    return !list_empty(&inode->hash);
 }
 
-
 static void
-__inode_hash (inode_t *inode)
+__inode_hash(inode_t *inode)
 {
-        inode_table_t *table = NULL;
-        int            hash = 0;
+    inode_table_t *table = NULL;
+    int hash = 0;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        table = inode->table;
-        hash = hash_gfid (inode->gfid, 65536);
+    table = inode->table;
+    hash = hash_gfid(inode->gfid, 65536);
 
-        list_del_init (&inode->hash);
-        list_add (&inode->hash, &table->inode_hash[hash]);
+    list_del_init(&inode->hash);
+    list_add(&inode->hash, &table->inode_hash[hash]);
 }
 
-
 static dentry_t *
-__dentry_search_for_inode (inode_t *inode, uuid_t pargfid, const char *name)
+__dentry_search_for_inode(inode_t *inode, uuid_t pargfid, const char *name)
 {
-        dentry_t *dentry = NULL;
-        dentry_t *tmp = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *tmp = NULL;
 
-        if (!inode || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "inode || name not found");
-                return NULL;
-        }
+    if (!inode || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "inode || name not found");
+        return NULL;
+    }
 
-        /* earlier, just the ino was sent, which could have been 0, now
-           we deal with gfid, and if sent gfid is null or 0, no need to
-           continue with the check */
-        if (!pargfid || gf_uuid_is_null (pargfid))
-                return NULL;
+    /* earlier, just the ino was sent, which could have been 0, now
+       we deal with gfid, and if sent gfid is null or 0, no need to
+       continue with the check */
+    if (!pargfid || gf_uuid_is_null(pargfid))
+        return NULL;
 
-        list_for_each_entry (tmp, &inode->dentry_list, inode_list) {
-                if ((gf_uuid_compare (tmp->parent->gfid, pargfid) == 0) &&
-                    !strcmp (tmp->name, name)) {
-                        dentry = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &inode->dentry_list, inode_list)
+    {
+        if ((gf_uuid_compare(tmp->parent->gfid, pargfid) == 0) &&
+            !strcmp(tmp->name, name)) {
+            dentry = tmp;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 static void
-__inode_ctx_free (inode_t *inode)
+__inode_ctx_free(inode_t *inode)
 {
-        int          index = 0;
-        xlator_t    *xl = NULL;
-        xlator_t    *old_THIS = NULL;
+    int index = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        if (!inode->_ctx) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_CTX_NULL,
-                        "_ctx not found");
-                goto noctx;
-        }
+    if (!inode->_ctx) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_CTX_NULL,
+               "_ctx not found");
+        goto noctx;
+    }
 
-        for (index = 0; index < inode->table->xl->graph->xl_count; index++) {
-                if (inode->_ctx[index].value1 || inode->_ctx[index].value2) {
-                        xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
-                        old_THIS = THIS;
-                        THIS = xl;
-                        if (!xl->call_cleanup && xl->cbks->forget)
-                                xl->cbks->forget (xl, inode);
-                        THIS = old_THIS;
-                }
+    for (index = 0; index < inode->table->xl->graph->xl_count; index++) {
+        if (inode->_ctx[index].value1 || inode->_ctx[index].value2) {
+            xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
+            old_THIS = THIS;
+            THIS = xl;
+            if (!xl->call_cleanup && xl->cbks->forget)
+                xl->cbks->forget(xl, inode);
+            THIS = old_THIS;
         }
+    }
 
-        GF_FREE (inode->_ctx);
-        inode->_ctx = NULL;
+    GF_FREE(inode->_ctx);
+    inode->_ctx = NULL;
 
 noctx:
-        return;
+    return;
 }
 
 static void
-__inode_destroy (inode_t *inode)
+__inode_destroy(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        __inode_ctx_free (inode);
+    __inode_ctx_free(inode);
 
-        LOCK_DESTROY (&inode->lock);
-        //  memset (inode, 0xb, sizeof (*inode));
-        mem_put (inode);
+    LOCK_DESTROY(&inode->lock);
+    //  memset (inode, 0xb, sizeof (*inode));
+    mem_put(inode);
 }
 
 void
-inode_ctx_merge (fd_t *fd, inode_t *inode, inode_t *linked_inode)
+inode_ctx_merge(fd_t *fd, inode_t *inode, inode_t *linked_inode)
 {
-        int       index    = 0;
-        xlator_t *xl       = NULL;
-        xlator_t *old_THIS = NULL;
+    int index = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
 
-        if (!fd || !inode || !linked_inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid inode");
-                return;
-        }
+    if (!fd || !inode || !linked_inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode");
+        return;
+    }
 
-        if (!inode->_ctx || !linked_inode->_ctx) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "invalid inode context");
-                return;
-        }
+    if (!inode->_ctx || !linked_inode->_ctx) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode context");
+        return;
+    }
 
-        for (; index < inode->table->ctxcount; index++) {
-                if (inode->_ctx[index].xl_key) {
-                        xl = (xlator_t *)(long) inode->_ctx[index].xl_key;
+    for (; index < inode->table->ctxcount; index++) {
+        if (inode->_ctx[index].xl_key) {
+            xl = (xlator_t *)(long)inode->_ctx[index].xl_key;
 
-                        old_THIS = THIS;
-                        THIS = xl;
-                        if (xl->cbks->ictxmerge)
-                                xl->cbks->ictxmerge (xl, fd,
-                                                     inode, linked_inode);
-                        THIS = old_THIS;
-                }
+            old_THIS = THIS;
+            THIS = xl;
+            if (xl->cbks->ictxmerge)
+                xl->cbks->ictxmerge(xl, fd, inode, linked_inode);
+            THIS = old_THIS;
         }
+    }
 }
 
 static void
-__inode_activate (inode_t *inode)
+__inode_activate(inode_t *inode)
 {
-        if (!inode)
-                return;
+    if (!inode)
+        return;
 
-        list_move (&inode->list, &inode->table->active);
-        inode->table->active_size++;
+    list_move(&inode->list, &inode->table->active);
+    inode->table->active_size++;
 }
 
-
 static void
-__inode_passivate (inode_t *inode)
+__inode_passivate(inode_t *inode)
 {
-        dentry_t      *dentry = NULL;
-        dentry_t      *t = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *t = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        list_move_tail (&inode->list, &inode->table->lru);
-        inode->table->lru_size++;
+    list_move_tail(&inode->list, &inode->table->lru);
+    inode->table->lru_size++;
 
-        list_for_each_entry_safe (dentry, t, &inode->dentry_list, inode_list) {
-                if (!__is_dentry_hashed (dentry))
-                        __dentry_unset (dentry);
-        }
+    list_for_each_entry_safe(dentry, t, &inode->dentry_list, inode_list)
+    {
+        if (!__is_dentry_hashed(dentry))
+            __dentry_unset(dentry);
+    }
 }
 
-
 static void
-__inode_retire (inode_t *inode)
+__inode_retire(inode_t *inode)
 {
-        dentry_t      *dentry = NULL;
-        dentry_t      *t = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *t = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        list_move_tail (&inode->list, &inode->table->purge);
-        inode->table->purge_size++;
+    list_move_tail(&inode->list, &inode->table->purge);
+    inode->table->purge_size++;
 
-        __inode_unhash (inode);
+    __inode_unhash(inode);
 
-        list_for_each_entry_safe (dentry, t, &inode->dentry_list, inode_list) {
-                __dentry_unset (dentry);
-        }
+    list_for_each_entry_safe(dentry, t, &inode->dentry_list, inode_list)
+    {
+        __dentry_unset(dentry);
+    }
 }
 
-
 static int
-__inode_get_xl_index (inode_t *inode, xlator_t *xlator)
+__inode_get_xl_index(inode_t *inode, xlator_t *xlator)
 {
-        int set_idx = -1;
+    int set_idx = -1;
 
-        if ((inode->_ctx[xlator->xl_id].xl_key != NULL) &&
-            (inode->_ctx[xlator->xl_id].xl_key != xlator))
-                goto out;
+    if ((inode->_ctx[xlator->xl_id].xl_key != NULL) &&
+        (inode->_ctx[xlator->xl_id].xl_key != xlator))
+        goto out;
 
-        set_idx = xlator->xl_id;
-        inode->_ctx[set_idx].xl_key = xlator;
+    set_idx = xlator->xl_id;
+    inode->_ctx[set_idx].xl_key = xlator;
 
 out:
-        return set_idx;
+    return set_idx;
 }
 
-
 static inode_t *
-__inode_unref (inode_t *inode)
+__inode_unref(inode_t *inode)
 {
-        int       index = 0;
-        xlator_t *this  = NULL;
+    int index = 0;
+    xlator_t *this = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        this = THIS;
+    this = THIS;
 
-        /*
-         * Root inode should always be in active list of inode table. So unrefs
-         * on root inode are no-ops.
-         */
-        if (__is_root_gfid(inode->gfid))
-                return inode;
+    /*
+     * Root inode should always be in active list of inode table. So unrefs
+     * on root inode are no-ops.
+     */
+    if (__is_root_gfid(inode->gfid))
+        return inode;
 
-        GF_ASSERT (inode->ref);
+    GF_ASSERT(inode->ref);
 
-        --inode->ref;
+    --inode->ref;
 
-        index = __inode_get_xl_index (inode, this);
-        if (index >= 0) {
-                inode->_ctx[index].xl_key = this;
-                inode->_ctx[index].ref--;
-        }
+    index = __inode_get_xl_index(inode, this);
+    if (index >= 0) {
+        inode->_ctx[index].xl_key = this;
+        inode->_ctx[index].ref--;
+    }
 
-        if (!inode->ref) {
-                inode->table->active_size--;
+    if (!inode->ref) {
+        inode->table->active_size--;
 
-                if (inode->nlookup)
-                        __inode_passivate (inode);
-                else
-                        __inode_retire (inode);
-        }
+        if (inode->nlookup)
+            __inode_passivate(inode);
+        else
+            __inode_retire(inode);
+    }
 
-        return inode;
+    return inode;
 }
 
-
 static inode_t *
-__inode_ref (inode_t *inode)
-{
-        int       index = 0;
-        xlator_t *this  = NULL;
-
-        if (!inode)
-                return NULL;
-
-        this = THIS;
-
-        if (!inode->ref) {
-                inode->table->lru_size--;
-                __inode_activate (inode);
-        }
-
-        /*
-         * Root inode should always be in active list of inode table. So unrefs
-         * on root inode are no-ops. If we do not allow unrefs but allow refs,
-         * it leads to refcount overflows and deleting and adding the inode
-         * to active-list, which is ugly. active_size (check __inode_activate)
-         * in inode table increases which is wrong. So just keep the ref
-         * count as 1 always
-         */
-        if (__is_root_gfid(inode->gfid) && inode->ref)
-                return inode;
+__inode_ref(inode_t *inode)
+{
+    int index = 0;
+    xlator_t *this = NULL;
+
+    if (!inode)
+        return NULL;
+
+    this = THIS;
+
+    if (!inode->ref) {
+        inode->table->lru_size--;
+        __inode_activate(inode);
+    }
+
+    /*
+     * Root inode should always be in active list of inode table. So unrefs
+     * on root inode are no-ops. If we do not allow unrefs but allow refs,
+     * it leads to refcount overflows and deleting and adding the inode
+     * to active-list, which is ugly. active_size (check __inode_activate)
+     * in inode table increases which is wrong. So just keep the ref
+     * count as 1 always
+     */
+    if (__is_root_gfid(inode->gfid) && inode->ref)
+        return inode;
 
-        inode->ref++;
+    inode->ref++;
 
-        index = __inode_get_xl_index (inode, this);
-        if (index >= 0) {
-                inode->_ctx[index].xl_key = this;
-                inode->_ctx[index].ref++;
-        }
+    index = __inode_get_xl_index(inode, this);
+    if (index >= 0) {
+        inode->_ctx[index].xl_key = this;
+        inode->_ctx[index].ref++;
+    }
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_unref (inode_t *inode)
+inode_unref(inode_t *inode)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_unref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_unref(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_ref (inode_t *inode)
+inode_ref(inode_t *inode)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_ref(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 static dentry_t *
-__dentry_create (inode_t *inode, inode_t *parent, const char *name)
+__dentry_create(inode_t *inode, inode_t *parent, const char *name)
 {
-        dentry_t      *newd = NULL;
+    dentry_t *newd = NULL;
 
-        if (!inode || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG,
-                                  "inode || parent || name not found");
-                return NULL;
-        }
+    if (!inode || !parent || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "inode || parent || name not found");
+        return NULL;
+    }
 
-        newd = mem_get0 (parent->table->dentry_pool);
-        if (newd == NULL) {
-                goto out;
-        }
+    newd = mem_get0(parent->table->dentry_pool);
+    if (newd == NULL) {
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&newd->inode_list);
-        INIT_LIST_HEAD (&newd->hash);
+    INIT_LIST_HEAD(&newd->inode_list);
+    INIT_LIST_HEAD(&newd->hash);
 
-        newd->name = gf_strdup (name);
-        if (newd->name == NULL) {
-                mem_put (newd);
-                newd = NULL;
-                goto out;
-        }
+    newd->name = gf_strdup(name);
+    if (newd->name == NULL) {
+        mem_put(newd);
+        newd = NULL;
+        goto out;
+    }
 
-        if (parent)
-                newd->parent = __inode_ref (parent);
+    if (parent)
+        newd->parent = __inode_ref(parent);
 
-        list_add (&newd->inode_list, &inode->dentry_list);
-        newd->inode = inode;
+    list_add(&newd->inode_list, &inode->dentry_list);
+    newd->inode = inode;
 
 out:
-        return newd;
+    return newd;
 }
 
-
 static inode_t *
-__inode_create (inode_table_t *table)
+__inode_create(inode_table_t *table)
 {
-        inode_t  *newi = NULL;
+    inode_t *newi = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                return NULL;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "table not "
+                         "found");
+        return NULL;
+    }
 
-        newi = mem_get0 (table->inode_pool);
-        if (!newi) {
-                goto out;
-        }
+    newi = mem_get0(table->inode_pool);
+    if (!newi) {
+        goto out;
+    }
 
-        newi->table = table;
+    newi->table = table;
 
-        LOCK_INIT (&newi->lock);
+    LOCK_INIT(&newi->lock);
 
-        INIT_LIST_HEAD (&newi->fd_list);
-        INIT_LIST_HEAD (&newi->list);
-        INIT_LIST_HEAD (&newi->hash);
-        INIT_LIST_HEAD (&newi->dentry_list);
+    INIT_LIST_HEAD(&newi->fd_list);
+    INIT_LIST_HEAD(&newi->list);
+    INIT_LIST_HEAD(&newi->hash);
+    INIT_LIST_HEAD(&newi->dentry_list);
 
-        newi->_ctx = GF_CALLOC (1,
-                                (sizeof (struct _inode_ctx) * table->ctxcount),
-                                gf_common_mt_inode_ctx);
-        if (newi->_ctx == NULL) {
-                LOCK_DESTROY (&newi->lock);
-                mem_put (newi);
-                newi = NULL;
-                goto out;
-        }
+    newi->_ctx = GF_CALLOC(1, (sizeof(struct _inode_ctx) * table->ctxcount),
+                           gf_common_mt_inode_ctx);
+    if (newi->_ctx == NULL) {
+        LOCK_DESTROY(&newi->lock);
+        mem_put(newi);
+        newi = NULL;
+        goto out;
+    }
 
-        list_add (&newi->list, &table->lru);
-        table->lru_size++;
+    list_add(&newi->list, &table->lru);
+    table->lru_size++;
 
 out:
 
-        return newi;
+    return newi;
 }
 
-
 inode_t *
-inode_new (inode_table_t *table)
+inode_new(inode_table_t *table)
 {
-        inode_t *inode = NULL;
+    inode_t *inode = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "inode not "
-                                  "found");
-                return NULL;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "inode not "
+                         "found");
+        return NULL;
+    }
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_create (table);
-                if (inode != NULL) {
-                        __inode_ref (inode);
-                }
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_create(table);
+        if (inode != NULL) {
+            __inode_ref(inode);
         }
-        pthread_mutex_unlock (&table->lock);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 /* Reduce the ref count by value 'nref'
  * Args:
  * inode - address of the inode to operate on
@@ -703,1240 +678,1221 @@ inode_new (inode_table_t *table)
  * hence to be used only in destructor functions and not otherwise.
  */
 static inode_t *
-__inode_ref_reduce_by_n (inode_t *inode, uint64_t nref)
+__inode_ref_reduce_by_n(inode_t *inode, uint64_t nref)
 {
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        GF_ASSERT (inode->ref >= nref);
+    GF_ASSERT(inode->ref >= nref);
 
-        inode->ref -= nref;
+    inode->ref -= nref;
 
-        if (!nref)
-                inode->ref = 0;
+    if (!nref)
+        inode->ref = 0;
 
-        if (!inode->ref) {
-                inode->table->active_size--;
+    if (!inode->ref) {
+        inode->table->active_size--;
 
-                if (inode->nlookup)
-                        __inode_passivate (inode);
-                else
-                        __inode_retire (inode);
-        }
+        if (inode->nlookup)
+            __inode_passivate(inode);
+        else
+            __inode_retire(inode);
+    }
 
-        return inode;
+    return inode;
 }
 
-
 static inode_t *
-__inode_lookup (inode_t *inode)
+__inode_lookup(inode_t *inode)
 {
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        inode->nlookup++;
+    inode->nlookup++;
 
-        return inode;
+    return inode;
 }
 
-
 static inode_t *
-__inode_forget (inode_t *inode, uint64_t nlookup)
+__inode_forget(inode_t *inode, uint64_t nlookup)
 {
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        GF_ASSERT (inode->nlookup >= nlookup);
+    GF_ASSERT(inode->nlookup >= nlookup);
 
-        inode->nlookup -= nlookup;
+    inode->nlookup -= nlookup;
 
-        if (!nlookup)
-                inode->nlookup = 0;
+    if (!nlookup)
+        inode->nlookup = 0;
 
-        return inode;
+    return inode;
 }
 
-
 dentry_t *
-__dentry_grep (inode_table_t *table, inode_t *parent, const char *name)
+__dentry_grep(inode_table_t *table, inode_t *parent, const char *name)
 {
-        int       hash = 0;
-        dentry_t *dentry = NULL;
-        dentry_t *tmp = NULL;
+    int hash = 0;
+    dentry_t *dentry = NULL;
+    dentry_t *tmp = NULL;
 
-        if (!table || !name || !parent)
-                return NULL;
+    if (!table || !name || !parent)
+        return NULL;
 
-        hash = hash_dentry (parent, name, table->hashsize);
+    hash = hash_dentry(parent, name, table->hashsize);
 
-        list_for_each_entry (tmp, &table->name_hash[hash], hash) {
-                if (tmp->parent == parent && !strcmp (tmp->name, name)) {
-                        dentry = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &table->name_hash[hash], hash)
+    {
+        if (tmp->parent == parent && !strcmp(tmp->name, name)) {
+            dentry = tmp;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 inode_t *
-inode_grep (inode_table_t *table, inode_t *parent, const char *name)
+inode_grep(inode_table_t *table, inode_t *parent, const char *name)
 {
-        inode_t   *inode = NULL;
-        dentry_t  *dentry = NULL;
+    inode_t *inode = NULL;
+    dentry_t *dentry = NULL;
 
-        if (!table || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "table || parent || name"
-                                  " not found");
-                return NULL;
-        }
+    if (!table || !parent || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "table || parent || name"
+                         " not found");
+        return NULL;
+    }
 
-        pthread_mutex_lock (&table->lock);
-        {
-                dentry = __dentry_grep (table, parent, name);
+    pthread_mutex_lock(&table->lock);
+    {
+        dentry = __dentry_grep(table, parent, name);
 
-                if (dentry)
-                        inode = dentry->inode;
+        if (dentry)
+            inode = dentry->inode;
 
-                if (inode)
-                        __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+        if (inode)
+            __inode_ref(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_resolve (inode_table_t *table, char *path)
+inode_resolve(inode_table_t *table, char *path)
 {
-        char    *tmp   = NULL, *bname = NULL, *str = NULL, *saveptr = NULL;
-        inode_t *inode = NULL, *parent = NULL;
-
-        if ((path == NULL) || (table == NULL)) {
-                goto out;
-        }
+    char *tmp = NULL, *bname = NULL, *str = NULL, *saveptr = NULL;
+    inode_t *inode = NULL, *parent = NULL;
 
-        parent = inode_ref (table->root);
-        str = tmp = gf_strdup (path);
+    if ((path == NULL) || (table == NULL)) {
+        goto out;
+    }
 
-        while (1) {
-                bname = strtok_r (str, "/", &saveptr);
-                if (bname == NULL) {
-                        break;
-                }
+    parent = inode_ref(table->root);
+    str = tmp = gf_strdup(path);
 
-                if (inode != NULL) {
-                        inode_unref (inode);
-                }
+    while (1) {
+        bname = strtok_r(str, "/", &saveptr);
+        if (bname == NULL) {
+            break;
+        }
 
-                inode = inode_grep (table, parent, bname);
-                if (inode == NULL) {
-                        break;
-                }
+        if (inode != NULL) {
+            inode_unref(inode);
+        }
 
-                if (parent != NULL) {
-                        inode_unref (parent);
-                }
+        inode = inode_grep(table, parent, bname);
+        if (inode == NULL) {
+            break;
+        }
 
-                parent = inode_ref (inode);
-                str = NULL;
+        if (parent != NULL) {
+            inode_unref(parent);
         }
 
-        inode_unref (parent);
-        GF_FREE (tmp);
+        parent = inode_ref(inode);
+        str = NULL;
+    }
+
+    inode_unref(parent);
+    GF_FREE(tmp);
 out:
-        return inode;
+    return inode;
 }
 
-
 int
-inode_grep_for_gfid (inode_table_t *table, inode_t *parent, const char *name,
-                     uuid_t gfid, ia_type_t *type)
-{
-        inode_t   *inode = NULL;
-        dentry_t  *dentry = NULL;
-        int        ret = -1;
-
-        if (!table || !parent || !name) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "table || parent || name"
-                                  " not found");
-                return ret;
-        }
+inode_grep_for_gfid(inode_table_t *table, inode_t *parent, const char *name,
+                    uuid_t gfid, ia_type_t *type)
+{
+    inode_t *inode = NULL;
+    dentry_t *dentry = NULL;
+    int ret = -1;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                dentry = __dentry_grep (table, parent, name);
+    if (!table || !parent || !name) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "table || parent || name"
+                         " not found");
+        return ret;
+    }
 
-                if (dentry)
-                        inode = dentry->inode;
+    pthread_mutex_lock(&table->lock);
+    {
+        dentry = __dentry_grep(table, parent, name);
 
-                if (inode) {
-                        gf_uuid_copy (gfid, inode->gfid);
-                        *type = inode->ia_type;
-                        ret = 0;
-                }
+        if (dentry)
+            inode = dentry->inode;
+
+        if (inode) {
+            gf_uuid_copy(gfid, inode->gfid);
+            *type = inode->ia_type;
+            ret = 0;
         }
-        pthread_mutex_unlock (&table->lock);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
-
 /* return 1 if gfid is of root, 0 if not */
 gf_boolean_t
-__is_root_gfid (uuid_t gfid)
+__is_root_gfid(uuid_t gfid)
 {
-        static uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+    static uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
-        if (gf_uuid_compare (gfid, root) == 0)
-                return _gf_true;
+    if (gf_uuid_compare(gfid, root) == 0)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
-
 inode_t *
-__inode_find (inode_table_t *table, uuid_t gfid)
+__inode_find(inode_table_t *table, uuid_t gfid)
 {
-        inode_t   *inode = NULL;
-        inode_t   *tmp = NULL;
-        int        hash = 0;
+    inode_t *inode = NULL;
+    inode_t *tmp = NULL;
+    int hash = 0;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                goto out;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "table not "
+                         "found");
+        goto out;
+    }
 
-        if (__is_root_gfid (gfid))
-                return table->root;
+    if (__is_root_gfid(gfid))
+        return table->root;
 
-        hash = hash_gfid (gfid, 65536);
+    hash = hash_gfid(gfid, 65536);
 
-        list_for_each_entry (tmp, &table->inode_hash[hash], hash) {
-                if (gf_uuid_compare (tmp->gfid, gfid) == 0) {
-                        inode = tmp;
-                        break;
-                }
+    list_for_each_entry(tmp, &table->inode_hash[hash], hash)
+    {
+        if (gf_uuid_compare(tmp->gfid, gfid) == 0) {
+            inode = tmp;
+            break;
         }
+    }
 
 out:
-        return inode;
+    return inode;
 }
 
-
 inode_t *
-inode_find (inode_table_t *table, uuid_t gfid)
+inode_find(inode_table_t *table, uuid_t gfid)
 {
-        inode_t   *inode = NULL;
+    inode_t *inode = NULL;
 
-        if (!table) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_TABLE_NOT_FOUND, "table not "
-                                  "found");
-                return NULL;
-        }
+    if (!table) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                         LG_MSG_INODE_TABLE_NOT_FOUND,
+                         "table not "
+                         "found");
+        return NULL;
+    }
 
-        pthread_mutex_lock (&table->lock);
-        {
-                inode = __inode_find (table, gfid);
-                if (inode)
-                        __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        inode = __inode_find(table, gfid);
+        if (inode)
+            __inode_ref(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return inode;
+    return inode;
 }
 
-
 static inode_t *
-__inode_link (inode_t *inode, inode_t *parent, const char *name,
-              struct iatt *iatt)
-{
-        dentry_t      *dentry = NULL;
-        dentry_t      *old_dentry = NULL;
-        inode_t       *old_inode = NULL;
-        inode_table_t *table = NULL;
-        inode_t       *link_inode = NULL;
-
-        if (!inode) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        table = inode->table;
-        if (!table) {
-                errno = EINVAL;
-                return NULL;
-        }
-
-        if (parent) {
-                /* We should prevent inode linking between different
-                   inode tables. This can cause errors which is very
-                   hard to catch/debug. */
-                if (inode->table != parent->table) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted b/w inodes of diff table");
-                }
-
-                if (parent->ia_type != IA_IFDIR) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted on non-directory parent");
-                        return NULL;
-                }
-
-                if (!name || strlen (name) == 0) {
-                        errno = EINVAL;
-                        GF_ASSERT (!"link attempted with no basename on "
+__inode_link(inode_t *inode, inode_t *parent, const char *name,
+             struct iatt *iatt)
+{
+    dentry_t *dentry = NULL;
+    dentry_t *old_dentry = NULL;
+    inode_t *old_inode = NULL;
+    inode_table_t *table = NULL;
+    inode_t *link_inode = NULL;
+
+    if (!inode) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    table = inode->table;
+    if (!table) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    if (parent) {
+        /* We should prevent inode linking between different
+           inode tables. This can cause errors which is very
+           hard to catch/debug. */
+        if (inode->table != parent->table) {
+            errno = EINVAL;
+            GF_ASSERT(!"link attempted b/w inodes of diff table");
+        }
+
+        if (parent->ia_type != IA_IFDIR) {
+            errno = EINVAL;
+            GF_ASSERT(!"link attempted on non-directory parent");
+            return NULL;
+        }
+
+        if (!name || strlen(name) == 0) {
+            errno = EINVAL;
+            GF_ASSERT (!"link attempted with no basename on "
                                     "parent");
-                        return NULL;
-                }
+            return NULL;
         }
+    }
 
-        link_inode = inode;
+    link_inode = inode;
 
-        if (!__is_inode_hashed (inode)) {
-                if (!iatt) {
-                        errno = EINVAL;
-                        return NULL;
-                }
+    if (!__is_inode_hashed(inode)) {
+        if (!iatt) {
+            errno = EINVAL;
+            return NULL;
+        }
 
-                if (gf_uuid_is_null (iatt->ia_gfid)) {
-                        errno = EINVAL;
-                        return NULL;
-                }
+        if (gf_uuid_is_null(iatt->ia_gfid)) {
+            errno = EINVAL;
+            return NULL;
+        }
 
-                old_inode = __inode_find (table, iatt->ia_gfid);
+        old_inode = __inode_find(table, iatt->ia_gfid);
 
-                if (old_inode) {
-                        link_inode = old_inode;
-                } else {
-                        gf_uuid_copy (inode->gfid, iatt->ia_gfid);
-                        inode->ia_type    = iatt->ia_type;
-                        __inode_hash (inode);
-                }
+        if (old_inode) {
+            link_inode = old_inode;
         } else {
-		/* @old_inode serves another important purpose - it indicates
-		   to the code further below whether a dentry cycle check is
-		   required or not (a new inode linkage can never result in
-		   creation of a loop.)
-
-		   if the given @inode is already hashed, it actually means
-		   it is an "old" inode and deserves to undergo the cyclic
-		   check.
-		*/
-		old_inode = inode;
-	}
-
-        if (name) {
-                if (!strcmp(name, ".") || !strcmp(name, ".."))
-                        return link_inode;
-
-                if (strchr (name, '/')) {
-                        GF_ASSERT (!"inode link attempted with '/' in name");
-                        return NULL;
-                }
-        }
+            gf_uuid_copy(inode->gfid, iatt->ia_gfid);
+            inode->ia_type = iatt->ia_type;
+            __inode_hash(inode);
+        }
+    } else {
+        /* @old_inode serves another important purpose - it indicates
+           to the code further below whether a dentry cycle check is
+           required or not (a new inode linkage can never result in
+           creation of a loop.)
+
+           if the given @inode is already hashed, it actually means
+           it is an "old" inode and deserves to undergo the cyclic
+           check.
+        */
+        old_inode = inode;
+    }
+
+    if (name) {
+        if (!strcmp(name, ".") || !strcmp(name, ".."))
+            return link_inode;
+
+        if (strchr(name, '/')) {
+            GF_ASSERT(!"inode link attempted with '/' in name");
+            return NULL;
+        }
+    }
+
+    /* use only link_inode beyond this point */
+    if (parent) {
+        old_dentry = __dentry_grep(table, parent, name);
+
+        if (!old_dentry || old_dentry->inode != link_inode) {
+            dentry = __dentry_create(link_inode, parent, name);
+            if (!dentry) {
+                gf_msg_callingfn(
+                    THIS->name, GF_LOG_ERROR, 0, LG_MSG_DENTRY_CREATE_FAILED,
+                    "dentry create failed on "
+                    "inode %s with parent %s",
+                    uuid_utoa(link_inode->gfid), uuid_utoa(parent->gfid));
+                errno = ENOMEM;
+                return NULL;
+            }
+            if (old_inode && __is_dentry_cyclic(dentry)) {
+                errno = ELOOP;
+                __dentry_unset(dentry);
+                return NULL;
+            }
+            __dentry_hash(dentry);
 
-        /* use only link_inode beyond this point */
-        if (parent) {
-                old_dentry = __dentry_grep (table, parent, name);
-
-                if (!old_dentry || old_dentry->inode != link_inode) {
-                        dentry = __dentry_create (link_inode, parent, name);
-                        if (!dentry) {
-                                gf_msg_callingfn (THIS->name, GF_LOG_ERROR, 0,
-                                                  LG_MSG_DENTRY_CREATE_FAILED,
-                                                  "dentry create failed on "
-                                                  "inode %s with parent %s",
-                                                  uuid_utoa (link_inode->gfid),
-                                                  uuid_utoa (parent->gfid));
-                                errno = ENOMEM;
-                                return NULL;
-                        }
-                        if (old_inode && __is_dentry_cyclic (dentry)) {
-                                errno = ELOOP;
-                                __dentry_unset (dentry);
-                                return NULL;
-                        }
-                        __dentry_hash (dentry);
-
-                        if (old_dentry)
-                                __dentry_unset (old_dentry);
-                }
+            if (old_dentry)
+                __dentry_unset(old_dentry);
         }
+    }
 
-        return link_inode;
+    return link_inode;
 }
 
-
 inode_t *
-inode_link (inode_t *inode, inode_t *parent, const char *name,
-            struct iatt *iatt)
+inode_link(inode_t *inode, inode_t *parent, const char *name, struct iatt *iatt)
 {
-        inode_table_t *table = NULL;
-        inode_t       *linked_inode = NULL;
+    inode_table_t *table = NULL;
+    inode_t *linked_inode = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return NULL;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                linked_inode = __inode_link (inode, parent, name, iatt);
+    pthread_mutex_lock(&table->lock);
+    {
+        linked_inode = __inode_link(inode, parent, name, iatt);
 
-                if (linked_inode)
-                        __inode_ref (linked_inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+        if (linked_inode)
+            __inode_ref(linked_inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return linked_inode;
+    return linked_inode;
 }
 
-
 int
-inode_lookup (inode_t *inode)
+inode_lookup(inode_t *inode)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_lookup (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_lookup(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return 0;
+    return 0;
 }
 
-
 int
-inode_ref_reduce_by_n (inode_t *inode, uint64_t nref)
+inode_ref_reduce_by_n(inode_t *inode, uint64_t nref)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_ref_reduce_by_n (inode, nref);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_ref_reduce_by_n(inode, nref);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return 0;
+    return 0;
 }
 
-
 int
-inode_forget (inode_t *inode, uint64_t nlookup)
+inode_forget(inode_t *inode, uint64_t nlookup)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_forget (inode, nlookup);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_forget(inode, nlookup);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return 0;
+    return 0;
 }
 
 /*
- * Invalidate an inode. This is invoked when a translator decides that an inode's
- * cache is no longer valid. Any translator interested in taking action in this
- * situation can define the invalidate callback.
+ * Invalidate an inode. This is invoked when a translator decides that an
+ * inode's cache is no longer valid. Any translator interested in taking action
+ * in this situation can define the invalidate callback.
  */
 int
 inode_invalidate(inode_t *inode)
 {
-	int ret = 0;
-	xlator_t *xl = NULL;
-	xlator_t *old_THIS = NULL;
-
-	if (!inode) {
-		gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
-                                 LG_MSG_INODE_NOT_FOUND, "inode not found");
-		return -1;
-	}
-
-	/*
-	 * The master xlator is not in the graph but it can define an invalidate
-	 * handler.
-	 */
-	xl = inode->table->xl->ctx->master;
-	if (xl && xl->cbks->invalidate) {
-		old_THIS = THIS;
-		THIS = xl;
-		ret = xl->cbks->invalidate(xl, inode);
-		THIS = old_THIS;
-		if (ret)
-			return ret;
-	}
+    int ret = 0;
+    xlator_t *xl = NULL;
+    xlator_t *old_THIS = NULL;
+
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
+
+    /*
+     * The master xlator is not in the graph but it can define an invalidate
+     * handler.
+     */
+    xl = inode->table->xl->ctx->master;
+    if (xl && xl->cbks->invalidate) {
+        old_THIS = THIS;
+        THIS = xl;
+        ret = xl->cbks->invalidate(xl, inode);
+        THIS = old_THIS;
+        if (ret)
+            return ret;
+    }
 
-	xl = inode->table->xl->graph->first;
-	while (xl) {
-		old_THIS = THIS;
-		THIS = xl;
-		if (xl->cbks->invalidate)
-			ret = xl->cbks->invalidate(xl, inode);
-		THIS = old_THIS;
+    xl = inode->table->xl->graph->first;
+    while (xl) {
+        old_THIS = THIS;
+        THIS = xl;
+        if (xl->cbks->invalidate)
+            ret = xl->cbks->invalidate(xl, inode);
+        THIS = old_THIS;
 
-		if (ret)
-			break;
+        if (ret)
+            break;
 
-		xl = xl->next;
-	}
+        xl = xl->next;
+    }
 
-	return ret;
+    return ret;
 }
 
-
 static void
-__inode_unlink (inode_t *inode, inode_t *parent, const char *name)
+__inode_unlink(inode_t *inode, inode_t *parent, const char *name)
 {
-        dentry_t *dentry = NULL;
-        char pgfid[64] = {0};
-        char gfid[64] = {0};
+    dentry_t *dentry = NULL;
+    char pgfid[64] = {0};
+    char gfid[64] = {0};
 
-        if (!inode || !parent || !name)
-                return;
+    if (!inode || !parent || !name)
+        return;
 
-        dentry = __dentry_search_for_inode (inode, parent->gfid, name);
-
-        /* dentry NULL for corrupted backend */
-        if (dentry) {
-                __dentry_unset (dentry);
-        } else {
-                gf_msg ("inode", GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
-                        "%s/%s: dentry not found in %s",
-                        uuid_utoa_r (parent->gfid, pgfid), name,
-                        uuid_utoa_r (inode->gfid, gfid));
-        }
+    dentry = __dentry_search_for_inode(inode, parent->gfid, name);
 
+    /* dentry NULL for corrupted backend */
+    if (dentry) {
+        __dentry_unset(dentry);
+    } else {
+        gf_msg("inode", GF_LOG_WARNING, 0, LG_MSG_DENTRY_NOT_FOUND,
+               "%s/%s: dentry not found in %s",
+               uuid_utoa_r(parent->gfid, pgfid), name,
+               uuid_utoa_r(inode->gfid, gfid));
+    }
 }
 
-
 void
-inode_unlink (inode_t *inode, inode_t *parent, const char *name)
+inode_unlink(inode_t *inode, inode_t *parent, const char *name)
 {
-        inode_table_t *table = NULL;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_unlink (inode, parent, name);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_unlink(inode, parent, name);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 }
 
-
 int
-inode_rename (inode_table_t *table, inode_t *srcdir, const char *srcname,
-              inode_t *dstdir, const char *dstname, inode_t *inode,
-              struct iatt *iatt)
-{
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return -1;
-        }
+inode_rename(inode_table_t *table, inode_t *srcdir, const char *srcname,
+             inode_t *dstdir, const char *dstname, inode_t *inode,
+             struct iatt *iatt)
+{
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return -1;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_link (inode, dstdir, dstname, iatt);
-                __inode_unlink (inode, srcdir, srcname);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_link(inode, dstdir, dstname, iatt);
+        __inode_unlink(inode, srcdir, srcname);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return 0;
+    return 0;
 }
 
-
 static dentry_t *
-__dentry_search_arbit (inode_t *inode)
+__dentry_search_arbit(inode_t *inode)
 {
-        dentry_t *dentry = NULL;
-        dentry_t *trav = NULL;
+    dentry_t *dentry = NULL;
+    dentry_t *trav = NULL;
 
-        if (!inode)
-                return NULL;
+    if (!inode)
+        return NULL;
 
-        list_for_each_entry (trav, &inode->dentry_list, inode_list) {
-                if (__is_dentry_hashed (trav)) {
-                        dentry = trav;
-                        break;
-                }
+    list_for_each_entry(trav, &inode->dentry_list, inode_list)
+    {
+        if (__is_dentry_hashed(trav)) {
+            dentry = trav;
+            break;
         }
+    }
 
-        if (!dentry) {
-                list_for_each_entry (trav, &inode->dentry_list, inode_list) {
-                        dentry = trav;
-                        break;
-                }
+    if (!dentry) {
+        list_for_each_entry(trav, &inode->dentry_list, inode_list)
+        {
+            dentry = trav;
+            break;
         }
+    }
 
-        return dentry;
+    return dentry;
 }
 
-
 inode_t *
-inode_parent (inode_t *inode, uuid_t pargfid, const char *name)
+inode_parent(inode_t *inode, uuid_t pargfid, const char *name)
 {
-        inode_t       *parent = NULL;
-        inode_table_t *table = NULL;
-        dentry_t      *dentry = NULL;
+    inode_t *parent = NULL;
+    inode_table_t *table = NULL;
+    dentry_t *dentry = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return NULL;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return NULL;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                if (pargfid && !gf_uuid_is_null (pargfid) && name) {
-                        dentry = __dentry_search_for_inode (inode, pargfid, name);
-                } else {
-                        dentry = __dentry_search_arbit (inode);
-                }
+    pthread_mutex_lock(&table->lock);
+    {
+        if (pargfid && !gf_uuid_is_null(pargfid) && name) {
+            dentry = __dentry_search_for_inode(inode, pargfid, name);
+        } else {
+            dentry = __dentry_search_arbit(inode);
+        }
 
-                if (dentry)
-                        parent = dentry->parent;
+        if (dentry)
+            parent = dentry->parent;
 
-                if (parent)
-                        __inode_ref (parent);
-        }
-        pthread_mutex_unlock (&table->lock);
+        if (parent)
+            __inode_ref(parent);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return parent;
+    return parent;
 }
 
 static int
-__inode_has_dentry (inode_t *inode)
+__inode_has_dentry(inode_t *inode)
 {
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return 0;
+    }
 
-        return !list_empty (&inode->dentry_list);
+    return !list_empty(&inode->dentry_list);
 }
 
 int
-inode_has_dentry (inode_t *inode)
+inode_has_dentry(inode_t *inode)
 {
+    int dentry_present = 0;
 
-        int dentry_present = 0;
-
-        LOCK (&inode->lock);
-        {
-                dentry_present = __inode_has_dentry (inode);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        dentry_present = __inode_has_dentry(inode);
+    }
+    UNLOCK(&inode->lock);
 
-        return dentry_present;
+    return dentry_present;
 }
 
 int
-__inode_path (inode_t *inode, const char *name, char **bufp)
-{
-        inode_table_t *table = NULL;
-        inode_t       *itrav = NULL;
-        dentry_t      *trav  = NULL;
-        size_t         i     = 0, size = 0;
-        int64_t        ret   = 0;
-        int            len   = 0;
-        char          *buf   = NULL;
-
-        if (!inode || gf_uuid_is_null (inode->gfid)) {
-                GF_ASSERT (0);
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid inode");
-                return -EINVAL;
-        }
+__inode_path(inode_t *inode, const char *name, char **bufp)
+{
+    inode_table_t *table = NULL;
+    inode_t *itrav = NULL;
+    dentry_t *trav = NULL;
+    size_t i = 0, size = 0;
+    int64_t ret = 0;
+    int len = 0;
+    char *buf = NULL;
+
+    if (!inode || gf_uuid_is_null(inode->gfid)) {
+        GF_ASSERT(0);
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid inode");
+        return -EINVAL;
+    }
+
+    table = inode->table;
+
+    itrav = inode;
+    for (trav = __dentry_search_arbit(itrav); trav;
+         trav = __dentry_search_arbit(itrav)) {
+        itrav = trav->parent;
+        i++; /* "/" */
+        i += strlen(trav->name);
+        if (i > PATH_MAX) {
+            gf_msg(table->name, GF_LOG_CRITICAL, 0, LG_MSG_DENTRY_CYCLIC_LOOP,
+                   "possible infinite "
+                   "loop detected, forcing break. name=(%s)",
+                   name);
+            ret = -ENOENT;
+            goto out;
+        }
+    }
+
+    if (!__is_root_gfid(itrav->gfid)) {
+        /* "<gfid:00000000-0000-0000-0000-000000000000>"/path */
+        i += GFID_STR_PFX_LEN;
+    }
+
+    if (name) {
+        i++;
+        i += strlen(name);
+    }
+
+    ret = i;
+    size = i + 1;
+    buf = GF_CALLOC(size, sizeof(char), gf_common_mt_char);
+    if (buf) {
+        buf[size - 1] = 0;
 
-        table = inode->table;
+        if (name) {
+            len = strlen(name);
+            strncpy(buf + (i - len), name, len);
+            buf[i - len - 1] = '/';
+            i -= (len + 1);
+        }
 
         itrav = inode;
-        for (trav = __dentry_search_arbit (itrav); trav;
-             trav = __dentry_search_arbit (itrav)) {
-                itrav = trav->parent;
-                i ++; /* "/" */
-                i += strlen (trav->name);
-                if (i > PATH_MAX) {
-                        gf_msg (table->name, GF_LOG_CRITICAL, 0,
-                                LG_MSG_DENTRY_CYCLIC_LOOP, "possible infinite "
-                                "loop detected, forcing break. name=(%s)",
-                                name);
-                        ret = -ENOENT;
-                        goto out;
-                }
+        for (trav = __dentry_search_arbit(itrav); trav;
+             trav = __dentry_search_arbit(itrav)) {
+            itrav = trav->parent;
+            len = strlen(trav->name);
+            strncpy(buf + (i - len), trav->name, len);
+            buf[i - len - 1] = '/';
+            i -= (len + 1);
         }
 
-        if (!__is_root_gfid (itrav->gfid)) {
-                /* "<gfid:00000000-0000-0000-0000-000000000000>"/path */
-                i += GFID_STR_PFX_LEN;
+        if (!__is_root_gfid(itrav->gfid)) {
+            snprintf(&buf[i - GFID_STR_PFX_LEN], GFID_STR_PFX_LEN,
+                     INODE_PATH_FMT, uuid_utoa(itrav->gfid));
+            buf[i - 1] = '>';
         }
 
-        if (name) {
-                i++;
-                i += strlen (name);
-        }
+        *bufp = buf;
+    } else {
+        ret = -ENOMEM;
+    }
 
-        ret = i;
-        size = i + 1;
-        buf = GF_CALLOC (size, sizeof (char), gf_common_mt_char);
+out:
+    if (__is_root_gfid(inode->gfid) && !name) {
+        ret = 1;
+        GF_FREE(buf);
+        buf = GF_CALLOC(ret + 1, sizeof(char), gf_common_mt_char);
         if (buf) {
-
-                buf[size - 1] = 0;
-
-                if (name) {
-                        len = strlen (name);
-                        strncpy (buf + (i - len), name, len);
-                        buf[i-len-1] = '/';
-                        i -= (len + 1);
-                }
-
-                itrav = inode;
-                for (trav = __dentry_search_arbit (itrav); trav;
-                     trav = __dentry_search_arbit (itrav)) {
-                        itrav = trav->parent;
-                        len = strlen (trav->name);
-                        strncpy (buf + (i - len), trav->name, len);
-                        buf[i-len-1] = '/';
-                        i -= (len + 1);
-                }
-
-                if (!__is_root_gfid (itrav->gfid)) {
-                        snprintf (&buf[i-GFID_STR_PFX_LEN], GFID_STR_PFX_LEN,
-                                  INODE_PATH_FMT, uuid_utoa (itrav->gfid));
-                        buf[i-1] = '>';
-                }
-
-                *bufp = buf;
+            strcpy(buf, "/");
+            *bufp = buf;
         } else {
-                ret = -ENOMEM;
+            ret = -ENOMEM;
         }
+    }
 
-out:
-        if (__is_root_gfid (inode->gfid) && !name) {
-                ret = 1;
-                GF_FREE (buf);
-                buf = GF_CALLOC (ret + 1, sizeof (char), gf_common_mt_char);
-                if (buf) {
-                        strcpy (buf, "/");
-                        *bufp = buf;
-                } else {
-                        ret = -ENOMEM;
-                }
-        }
-
-        if (ret < 0)
-                *bufp = NULL;
-        return ret;
+    if (ret < 0)
+        *bufp = NULL;
+    return ret;
 }
 
-
 int
-inode_path (inode_t *inode, const char *name, char **bufp)
+inode_path(inode_t *inode, const char *name, char **bufp)
 {
-        inode_table_t *table = NULL;
-        int            ret   = -1;
+    inode_table_t *table = NULL;
+    int ret = -1;
 
-        if (!inode)
-                return -EINVAL;
+    if (!inode)
+        return -EINVAL;
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                ret = __inode_path (inode, name, bufp);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        ret = __inode_path(inode, name, bufp);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-__inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit)
+__inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit)
 {
-        table->lru_limit = lru_limit;
-        return;
+    table->lru_limit = lru_limit;
+    return;
 }
 
-
 void
-inode_table_set_lru_limit (inode_table_t *table, uint32_t lru_limit)
+inode_table_set_lru_limit(inode_table_t *table, uint32_t lru_limit)
 {
-        pthread_mutex_lock (&table->lock);
-        {
-                __inode_table_set_lru_limit (table, lru_limit);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        __inode_table_set_lru_limit(table, lru_limit);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        inode_table_prune (table);
+    inode_table_prune(table);
 
-        return;
+    return;
 }
 
 static int
-inode_table_prune (inode_table_t *table)
+inode_table_prune(inode_table_t *table)
 {
-        int               ret = 0;
-        struct list_head  purge = {0, };
-        inode_t          *del = NULL;
-        inode_t          *tmp = NULL;
-        inode_t          *entry = NULL;
+    int ret = 0;
+    struct list_head purge = {
+        0,
+    };
+    inode_t *del = NULL;
+    inode_t *tmp = NULL;
+    inode_t *entry = NULL;
 
-        if (!table)
-                return -1;
+    if (!table)
+        return -1;
 
-        INIT_LIST_HEAD (&purge);
+    INIT_LIST_HEAD(&purge);
 
-        pthread_mutex_lock (&table->lock);
-        {
-                while (table->lru_limit
-                       && table->lru_size > (table->lru_limit)) {
-                        if (list_empty (&table->lru)) {
-                                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                                  LG_MSG_INVALID_INODE_LIST,
-                                                  "Empty inode lru list found"
-                                                  " but with (%d) lru_size",
-                                                  table->lru_size);
-                                break;
-                        }
-
-                        entry = list_entry (table->lru.next, inode_t, list);
-
-                        table->lru_size--;
-                        __inode_retire (entry);
-
-                        ret++;
-                }
+    pthread_mutex_lock(&table->lock);
+    {
+        while (table->lru_limit && table->lru_size > (table->lru_limit)) {
+            if (list_empty(&table->lru)) {
+                gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                                 LG_MSG_INVALID_INODE_LIST,
+                                 "Empty inode lru list found"
+                                 " but with (%d) lru_size",
+                                 table->lru_size);
+                break;
+            }
+
+            entry = list_entry(table->lru.next, inode_t, list);
+
+            table->lru_size--;
+            __inode_retire(entry);
 
-                list_splice_init (&table->purge, &purge);
-                table->purge_size = 0;
+            ret++;
         }
-        pthread_mutex_unlock (&table->lock);
 
+        list_splice_init(&table->purge, &purge);
+        table->purge_size = 0;
+    }
+    pthread_mutex_unlock(&table->lock);
+
+    {
+        list_for_each_entry_safe(del, tmp, &purge, list)
         {
-                list_for_each_entry_safe (del, tmp, &purge, list) {
-                        list_del_init (&del->list);
-                        __inode_forget (del, 0);
-                        __inode_destroy (del);
-                }
+            list_del_init(&del->list);
+            __inode_forget(del, 0);
+            __inode_destroy(del);
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__inode_table_init_root (inode_table_t *table)
+__inode_table_init_root(inode_table_t *table)
 {
-        inode_t     *root = NULL;
-        struct iatt  iatt = {0, };
+    inode_t *root = NULL;
+    struct iatt iatt = {
+        0,
+    };
 
-        if (!table)
-                return;
+    if (!table)
+        return;
 
-        root = __inode_create (table);
+    root = __inode_create(table);
 
-        iatt.ia_gfid[15] = 1;
-        iatt.ia_ino = 1;
-        iatt.ia_type = IA_IFDIR;
+    iatt.ia_gfid[15] = 1;
+    iatt.ia_ino = 1;
+    iatt.ia_type = IA_IFDIR;
 
-        __inode_link (root, NULL, NULL, &iatt);
-        table->root = root;
+    __inode_link(root, NULL, NULL, &iatt);
+    table->root = root;
 }
 
-
 inode_table_t *
-inode_table_new (size_t lru_limit, xlator_t *xl)
+inode_table_new(size_t lru_limit, xlator_t *xl)
 {
-        inode_table_t *new = NULL;
-        int            ret = -1;
-        int            i = 0;
-
-        new = (void *)GF_CALLOC(1, sizeof (*new), gf_common_mt_inode_table_t);
-        if (!new)
-                return NULL;
+    inode_table_t *new = NULL;
+    int ret = -1;
+    int i = 0;
 
-        new->xl = xl;
-        new->ctxcount = xl->graph->xl_count + 1;
+    new = (void *)GF_CALLOC(1, sizeof(*new), gf_common_mt_inode_table_t);
+    if (!new)
+        return NULL;
 
-        new->lru_limit = lru_limit;
+    new->xl = xl;
+    new->ctxcount = xl->graph->xl_count + 1;
 
-        new->hashsize = 14057; /* TODO: Random Number?? */
+    new->lru_limit = lru_limit;
 
-        /* In case FUSE is initing the inode table. */
-        if (lru_limit == 0)
-                lru_limit = DEFAULT_INODE_MEMPOOL_ENTRIES;
+    new->hashsize = 14057; /* TODO: Random Number?? */
 
-        new->inode_pool = mem_pool_new (inode_t, lru_limit);
+    /* In case FUSE is initing the inode table. */
+    if (lru_limit == 0)
+        lru_limit = DEFAULT_INODE_MEMPOOL_ENTRIES;
 
-        if (!new->inode_pool)
-                goto out;
+    new->inode_pool = mem_pool_new(inode_t, lru_limit);
 
-        new->dentry_pool = mem_pool_new (dentry_t, lru_limit);
+    if (!new->inode_pool)
+        goto out;
 
-        if (!new->dentry_pool)
-                goto out;
+    new->dentry_pool = mem_pool_new(dentry_t, lru_limit);
 
-        new->inode_hash = (void *)GF_CALLOC (65536,
-                                             sizeof (struct list_head),
-                                             gf_common_mt_list_head);
-        if (!new->inode_hash)
-                goto out;
+    if (!new->dentry_pool)
+        goto out;
 
-        new->name_hash = (void *)GF_CALLOC (new->hashsize,
-                                            sizeof (struct list_head),
-                                            gf_common_mt_list_head);
-        if (!new->name_hash)
-                goto out;
+    new->inode_hash = (void *)GF_CALLOC(65536, sizeof(struct list_head),
+                                        gf_common_mt_list_head);
+    if (!new->inode_hash)
+        goto out;
 
-        /* if number of fd open in one process is more than this,
-           we may hit perf issues */
-        new->fd_mem_pool = mem_pool_new (fd_t, 1024);
+    new->name_hash = (void *)GF_CALLOC(new->hashsize, sizeof(struct list_head),
+                                       gf_common_mt_list_head);
+    if (!new->name_hash)
+        goto out;
 
-        if (!new->fd_mem_pool)
-                goto out;
+    /* if number of fd open in one process is more than this,
+       we may hit perf issues */
+    new->fd_mem_pool = mem_pool_new(fd_t, 1024);
 
-        for (i = 0; i < 65536; i++) {
-                INIT_LIST_HEAD (&new->inode_hash[i]);
-        }
+    if (!new->fd_mem_pool)
+        goto out;
 
+    for (i = 0; i < 65536; i++) {
+        INIT_LIST_HEAD(&new->inode_hash[i]);
+    }
 
-        for (i = 0; i < new->hashsize; i++) {
-                INIT_LIST_HEAD (&new->name_hash[i]);
-        }
+    for (i = 0; i < new->hashsize; i++) {
+        INIT_LIST_HEAD(&new->name_hash[i]);
+    }
 
-        INIT_LIST_HEAD (&new->active);
-        INIT_LIST_HEAD (&new->lru);
-        INIT_LIST_HEAD (&new->purge);
+    INIT_LIST_HEAD(&new->active);
+    INIT_LIST_HEAD(&new->lru);
+    INIT_LIST_HEAD(&new->purge);
 
-        ret = gf_asprintf (&new->name, "%s/inode", xl->name);
-        if (-1 == ret) {
-                /* TODO: This should be ok to continue, check with avati */
-                ;
-        }
+    ret = gf_asprintf(&new->name, "%s/inode", xl->name);
+    if (-1 == ret) {
+        /* TODO: This should be ok to continue, check with avati */
+        ;
+    }
 
-        __inode_table_init_root (new);
+    __inode_table_init_root(new);
 
-        pthread_mutex_init (&new->lock, NULL);
+    pthread_mutex_init(&new->lock, NULL);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                if (new) {
-                        GF_FREE (new->inode_hash);
-                        GF_FREE (new->name_hash);
-                        if (new->dentry_pool)
-                                mem_pool_destroy (new->dentry_pool);
-                        if (new->inode_pool)
-                                mem_pool_destroy (new->inode_pool);
-                        GF_FREE (new);
-                        new = NULL;
-                }
+    if (ret) {
+        if (new) {
+            GF_FREE(new->inode_hash);
+            GF_FREE(new->name_hash);
+            if (new->dentry_pool)
+                mem_pool_destroy(new->dentry_pool);
+            if (new->inode_pool)
+                mem_pool_destroy(new->inode_pool);
+            GF_FREE(new);
+            new = NULL;
         }
+    }
 
-        return new;
+    return new;
 }
 
 int
-inode_table_ctx_free (inode_table_t *table)
+inode_table_ctx_free(inode_table_t *table)
 {
-        int ret = 0;
-        inode_t *del = NULL;
-        inode_t *tmp = NULL;
-        int purge_count = 0;
-        int lru_count = 0;
-        int active_count = 0;
-        xlator_t *this = NULL;
-        int itable_size = 0;
+    int ret = 0;
+    inode_t *del = NULL;
+    inode_t *tmp = NULL;
+    int purge_count = 0;
+    int lru_count = 0;
+    int active_count = 0;
+    xlator_t *this = NULL;
+    int itable_size = 0;
 
-        if (!table)
-                return -1;
+    if (!table)
+        return -1;
 
-        this = THIS;
+    this = THIS;
 
-        pthread_mutex_lock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        list_for_each_entry_safe(del, tmp, &table->purge, list)
         {
-                list_for_each_entry_safe (del, tmp, &table->purge, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                purge_count++;
-                        }
-                }
-
-                list_for_each_entry_safe (del, tmp, &table->lru, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                lru_count++;
-                        }
-                }
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                purge_count++;
+            }
+        }
 
-                /* should the contexts of active inodes be freed?
-                 * Since before this function being called fds would have
-                 * been migrated and would have held the ref on the new
-                 * inode from the new inode table, the older inode would not
-                 * be used.
-                 */
-                list_for_each_entry_safe (del, tmp, &table->active, list) {
-                        if (del->_ctx) {
-                                __inode_ctx_free (del);
-                                active_count++;
-                        }
-                }
+        list_for_each_entry_safe(del, tmp, &table->lru, list)
+        {
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                lru_count++;
+            }
         }
-        pthread_mutex_unlock (&table->lock);
-
-        ret = purge_count + lru_count + active_count;
-        itable_size = table->active_size + table->lru_size + table->purge_size;
-        gf_msg_callingfn (this->name, GF_LOG_INFO, 0,
-                          LG_MSG_INODE_CONTEXT_FREED, "total %d (itable size: "
-                          "%d) inode contexts have been freed (active: %d, ("
-                          "active size: %d), lru: %d, (lru size: %d),  purge: "
-                          "%d, (purge size: %d))", ret, itable_size,
-                          active_count, table->active_size, lru_count,
-                          table->lru_size, purge_count, table->purge_size);
-        return ret;
+
+        /* should the contexts of active inodes be freed?
+         * Since before this function being called fds would have
+         * been migrated and would have held the ref on the new
+         * inode from the new inode table, the older inode would not
+         * be used.
+         */
+        list_for_each_entry_safe(del, tmp, &table->active, list)
+        {
+            if (del->_ctx) {
+                __inode_ctx_free(del);
+                active_count++;
+            }
+        }
+    }
+    pthread_mutex_unlock(&table->lock);
+
+    ret = purge_count + lru_count + active_count;
+    itable_size = table->active_size + table->lru_size + table->purge_size;
+    gf_msg_callingfn(this->name, GF_LOG_INFO, 0, LG_MSG_INODE_CONTEXT_FREED,
+                     "total %d (itable size: "
+                     "%d) inode contexts have been freed (active: %d, ("
+                     "active size: %d), lru: %d, (lru size: %d),  purge: "
+                     "%d, (purge size: %d))",
+                     ret, itable_size, active_count, table->active_size,
+                     lru_count, table->lru_size, purge_count,
+                     table->purge_size);
+    return ret;
 }
 
 void
-inode_table_destroy_all (glusterfs_ctx_t *ctx) {
-
-        glusterfs_graph_t *trav_graph  = NULL, *tmp = NULL;
-        xlator_t          *tree        = NULL;
-        inode_table_t     *inode_table = NULL;
+inode_table_destroy_all(glusterfs_ctx_t *ctx)
+{
+    glusterfs_graph_t *trav_graph = NULL, *tmp = NULL;
+    xlator_t *tree = NULL;
+    inode_table_t *inode_table = NULL;
+
+    if (ctx == NULL)
+        goto out;
+
+    /* TODO: Traverse ctx->graphs with in ctx->lock and also the other
+     * graph additions and traversals in ctx->lock.
+     */
+    list_for_each_entry_safe(trav_graph, tmp, &ctx->graphs, list)
+    {
+        tree = trav_graph->first;
+        inode_table = tree->itable;
+        tree->itable = NULL;
+        if (inode_table)
+            inode_table_destroy(inode_table);
+    }
+out:
+    return;
+}
 
-        if (ctx == NULL)
-                goto out;
+void
+inode_table_destroy(inode_table_t *inode_table)
+{
+    inode_t *trav = NULL;
 
-        /* TODO: Traverse ctx->graphs with in ctx->lock and also the other
-         * graph additions and traversals in ctx->lock.
-         */
-        list_for_each_entry_safe (trav_graph, tmp, &ctx->graphs, list) {
-                tree = trav_graph->first;
-                inode_table = tree->itable;
-                tree->itable = NULL;
-                if (inode_table)
-                        inode_table_destroy (inode_table);
-        }
- out:
+    if (inode_table == NULL)
         return;
-}
 
-void
-inode_table_destroy (inode_table_t *inode_table) {
-
-        inode_t  *trav = NULL;
-
-        if (inode_table == NULL)
-                return;
-
-        /* Ideally at this point in time, there should be no inodes with
-         * refs remaining. But there are quite a few chances where the inodes
-         * leak. So we can take three approaches for cleaning up the inode table:
-         * 1. Assume there are no leaks and then send a forget on all the inodes
-         *    in lru list.(If no leaks there should be no inodes in active list)
-         * 2. Knowing there could be leaks and not freeing those inodes will
-         *    also not free its inode context and this could leak a lot of
-         *    memory, force free the inodes by changing the ref to 0.
-         *    The problem with this is that any reference to inode after this
-         *    calling this function will lead to a crash.
-         * 3. Knowing there could be leakes, just free the inode contexts of
-         *    all the inodes. and let the inodes be alive. This way the major
-         *    memory consumed by the inode contexts are freed, but there can
-         *    be errors when any inode contexts are accessed after destroying
-         *    this table.
+    /* Ideally at this point in time, there should be no inodes with
+     * refs remaining. But there are quite a few chances where the inodes
+     * leak. So we can take three approaches for cleaning up the inode table:
+     * 1. Assume there are no leaks and then send a forget on all the inodes
+     *    in lru list.(If no leaks there should be no inodes in active list)
+     * 2. Knowing there could be leaks and not freeing those inodes will
+     *    also not free its inode context and this could leak a lot of
+     *    memory, force free the inodes by changing the ref to 0.
+     *    The problem with this is that any reference to inode after this
+     *    calling this function will lead to a crash.
+     * 3. Knowing there could be leakes, just free the inode contexts of
+     *    all the inodes. and let the inodes be alive. This way the major
+     *    memory consumed by the inode contexts are freed, but there can
+     *    be errors when any inode contexts are accessed after destroying
+     *    this table.
+     *
+     * Not sure which is the approach to be taken, going by approach 2.
+     */
+
+    /* Approach 3:
+     * ret = inode_table_ctx_free (inode_table);
+     */
+    pthread_mutex_lock(&inode_table->lock);
+    {
+        /* Process lru list first as we need to unset their dentry
+         * entries (the ones which may not be unset during
+         * '__inode_passivate' as they were hashed) which in turn
+         * shall unref their parent
          *
-         * Not sure which is the approach to be taken, going by approach 2.
-         */
-
-        /* Approach 3:
-         * ret = inode_table_ctx_free (inode_table);
+         * These parent inodes when unref'ed may well again fall
+         * into lru list and if we are at the end of traversing
+         * the list, we may miss to delete/retire that entry. Hence
+         * traverse the lru list till it gets empty.
          */
-        pthread_mutex_lock (&inode_table->lock);
-        {
-                /* Process lru list first as we need to unset their dentry
-                 * entries (the ones which may not be unset during
-                 * '__inode_passivate' as they were hashed) which in turn
-                 * shall unref their parent
-                 *
-                 * These parent inodes when unref'ed may well again fall
-                 * into lru list and if we are at the end of traversing
-                 * the list, we may miss to delete/retire that entry. Hence
-                 * traverse the lru list till it gets empty.
-                 */
-                while (!list_empty (&inode_table->lru)) {
-                        trav = list_first_entry (&inode_table->lru,
-                                                 inode_t, list);
-                        __inode_forget (trav, 0);
-                        __inode_retire (trav);
-                        inode_table->lru_size--;
-                }
-
-                while (!list_empty (&inode_table->active)) {
-                        trav = list_first_entry (&inode_table->active,
-                                                 inode_t, list);
-                        /* forget and unref the inode to retire and add it to
-                         * purge list. By this time there should not be any
-                         * inodes present in the active list except for root
-                         * inode. Its a ref_leak otherwise. */
-                        if (trav != inode_table->root)
-                                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                                  LG_MSG_REF_COUNT,
-                                                  "Active inode(%p) with refcount"
-                                                  "(%d) found during cleanup",
-                                                  trav, trav->ref);
-                        __inode_forget (trav, 0);
-                        __inode_ref_reduce_by_n (trav, 0);
-                }
-
-        }
-        pthread_mutex_unlock (&inode_table->lock);
-
-        inode_table_prune (inode_table);
-
-        GF_FREE (inode_table->inode_hash);
-        GF_FREE (inode_table->name_hash);
-        if (inode_table->dentry_pool)
-                mem_pool_destroy (inode_table->dentry_pool);
-        if (inode_table->inode_pool)
-                mem_pool_destroy (inode_table->inode_pool);
-        if (inode_table->fd_mem_pool)
-                mem_pool_destroy (inode_table->fd_mem_pool);
-
-        pthread_mutex_destroy (&inode_table->lock);
-
-        GF_FREE (inode_table->name);
-        GF_FREE (inode_table);
-
-        return;
+        while (!list_empty(&inode_table->lru)) {
+            trav = list_first_entry(&inode_table->lru, inode_t, list);
+            __inode_forget(trav, 0);
+            __inode_retire(trav);
+            inode_table->lru_size--;
+        }
+
+        while (!list_empty(&inode_table->active)) {
+            trav = list_first_entry(&inode_table->active, inode_t, list);
+            /* forget and unref the inode to retire and add it to
+             * purge list. By this time there should not be any
+             * inodes present in the active list except for root
+             * inode. Its a ref_leak otherwise. */
+            if (trav != inode_table->root)
+                gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0,
+                                 LG_MSG_REF_COUNT,
+                                 "Active inode(%p) with refcount"
+                                 "(%d) found during cleanup",
+                                 trav, trav->ref);
+            __inode_forget(trav, 0);
+            __inode_ref_reduce_by_n(trav, 0);
+        }
+    }
+    pthread_mutex_unlock(&inode_table->lock);
+
+    inode_table_prune(inode_table);
+
+    GF_FREE(inode_table->inode_hash);
+    GF_FREE(inode_table->name_hash);
+    if (inode_table->dentry_pool)
+        mem_pool_destroy(inode_table->dentry_pool);
+    if (inode_table->inode_pool)
+        mem_pool_destroy(inode_table->inode_pool);
+    if (inode_table->fd_mem_pool)
+        mem_pool_destroy(inode_table->fd_mem_pool);
+
+    pthread_mutex_destroy(&inode_table->lock);
+
+    GF_FREE(inode_table->name);
+    GF_FREE(inode_table);
+
+    return;
 }
 
 inode_t *
-inode_from_path (inode_table_t *itable, const char *path)
+inode_from_path(inode_table_t *itable, const char *path)
 {
-        inode_t  *inode = NULL;
-        inode_t  *parent = NULL;
-        inode_t  *root = NULL;
-        inode_t  *curr = NULL;
-        char     *pathname = NULL;
-        char     *component = NULL, *next_component = NULL;
-        char     *strtokptr = NULL;
+    inode_t *inode = NULL;
+    inode_t *parent = NULL;
+    inode_t *root = NULL;
+    inode_t *curr = NULL;
+    char *pathname = NULL;
+    char *component = NULL, *next_component = NULL;
+    char *strtokptr = NULL;
 
-        if (!itable || !path)
-                return NULL;
+    if (!itable || !path)
+        return NULL;
 
-        /* top-down approach */
-        pathname = gf_strdup (path);
-        if (pathname == NULL) {
-                goto out;
-        }
+    /* top-down approach */
+    pathname = gf_strdup(path);
+    if (pathname == NULL) {
+        goto out;
+    }
 
-        root = itable->root;
-        parent = inode_ref (root);
-        component = strtok_r (pathname, "/", &strtokptr);
+    root = itable->root;
+    parent = inode_ref(root);
+    component = strtok_r(pathname, "/", &strtokptr);
 
-        if (component == NULL)
-                /* root inode */
-                inode = inode_ref (parent);
+    if (component == NULL)
+        /* root inode */
+        inode = inode_ref(parent);
 
-        while (component) {
-                curr = inode_grep (itable, parent, component);
+    while (component) {
+        curr = inode_grep(itable, parent, component);
 
-                if (curr == NULL) {
-                        strtok_r (NULL, "/", &strtokptr);
-                        break;
-                }
-
-                next_component = strtok_r (NULL, "/", &strtokptr);
+        if (curr == NULL) {
+            strtok_r(NULL, "/", &strtokptr);
+            break;
+        }
 
-                if (next_component) {
-                        inode_unref (parent);
-                        parent = curr;
-                        curr = NULL;
-                } else {
-                        inode = curr;
-                }
+        next_component = strtok_r(NULL, "/", &strtokptr);
 
-                component = next_component;
+        if (next_component) {
+            inode_unref(parent);
+            parent = curr;
+            curr = NULL;
+        } else {
+            inode = curr;
         }
 
-        if (parent)
-                inode_unref (parent);
+        component = next_component;
+    }
+
+    if (parent)
+        inode_unref(parent);
 
-        GF_FREE (pathname);
+    GF_FREE(pathname);
 
 out:
-        return inode;
+    return inode;
 }
 
 void
-inode_set_need_lookup (inode_t *inode, xlator_t *this)
+inode_set_need_lookup(inode_t *inode, xlator_t *this)
 {
-        uint64_t  need_lookup = LOOKUP_NEEDED;
+    uint64_t need_lookup = LOOKUP_NEEDED;
 
-        if (!inode || !this)
-                return;
+    if (!inode || !this)
+        return;
 
-        inode_ctx_set (inode, this, &need_lookup);
+    inode_ctx_set(inode, this, &need_lookup);
 
-        return;
+    return;
 }
 
 /* Function behaviour:
@@ -1947,264 +1903,259 @@ inode_set_need_lookup (inode_t *inode, xlator_t *this)
  * needed.
  */
 gf_boolean_t
-inode_needs_lookup (inode_t *inode, xlator_t *this)
-{
-        uint64_t     need_lookup = 0;
-        gf_boolean_t ret         = _gf_false;
-        int          op_ret      = -1;
-
-        if (!inode || !this)
-                return ret;
-
-        op_ret = inode_ctx_get (inode, this, &need_lookup);
-        if (op_ret == -1) {
-                ret = _gf_true;
-        } else if (need_lookup == LOOKUP_NEEDED) {
-                ret = _gf_true;
-                need_lookup = LOOKUP_NOT_NEEDED;
-                inode_ctx_set (inode, this, &need_lookup);
-        }
+inode_needs_lookup(inode_t *inode, xlator_t *this)
+{
+    uint64_t need_lookup = 0;
+    gf_boolean_t ret = _gf_false;
+    int op_ret = -1;
 
+    if (!inode || !this)
         return ret;
-}
-
-int
-__inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                  uint64_t *value2_p)
-{
-        int ret = 0;
-        int set_idx = -1;
 
-        if (!inode || !xlator || !inode->_ctx)
-                return -1;
+    op_ret = inode_ctx_get(inode, this, &need_lookup);
+    if (op_ret == -1) {
+        ret = _gf_true;
+    } else if (need_lookup == LOOKUP_NEEDED) {
+        ret = _gf_true;
+        need_lookup = LOOKUP_NOT_NEEDED;
+        inode_ctx_set(inode, this, &need_lookup);
+    }
 
-        set_idx = __inode_get_xl_index (inode, xlator);
-        if (set_idx == -1) {
-                ret = -1;
-                goto out;;
-        }
+    return ret;
+}
 
-        inode->_ctx[set_idx].xl_key = xlator;
-        if (value1_p)
-                inode->_ctx[set_idx].value1 = *value1_p;
-        if (value2_p)
-                inode->_ctx[set_idx].value2 = *value2_p;
+int
+__inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+                 uint64_t *value2_p)
+{
+    int ret = 0;
+    int set_idx = -1;
+
+    if (!inode || !xlator || !inode->_ctx)
+        return -1;
+
+    set_idx = __inode_get_xl_index(inode, xlator);
+    if (set_idx == -1) {
+        ret = -1;
+        goto out;
+        ;
+    }
+
+    inode->_ctx[set_idx].xl_key = xlator;
+    if (value1_p)
+        inode->_ctx[set_idx].value1 = *value1_p;
+    if (value2_p)
+        inode->_ctx[set_idx].value2 = *value2_p;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+__inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        return __inode_ctx_set2 (inode, xlator, value1_p, NULL);
+    return __inode_ctx_set2(inode, xlator, value1_p, NULL);
 }
 
 int
-__inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+__inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        return __inode_ctx_set2 (inode, xlator, NULL, value2_p);
+    return __inode_ctx_set2(inode, xlator, NULL, value2_p);
 }
 
-
 int
-inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                uint64_t *value2_p)
+inode_ctx_set2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+               uint64_t *value2_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set2 (inode, xlator, value1_p, value2_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set2(inode, xlator, value1_p, value2_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+inode_ctx_set1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set1 (inode, xlator, value2_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set1(inode, xlator, value2_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 int
-inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+inode_ctx_set0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_set0 (inode, xlator, value1_p);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_set0(inode, xlator, value1_p);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                  uint64_t *value2)
+__inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                 uint64_t *value2)
 {
-        int index = 0;
-        int ret = -1;
+    int index = 0;
+    int ret = -1;
 
-        if (!inode || !xlator || !inode->_ctx)
-                goto out;
+    if (!inode || !xlator || !inode->_ctx)
+        goto out;
 
-        index = xlator->xl_id;
-        if (inode->_ctx[index].xl_key != xlator)
-                goto out;
+    index = xlator->xl_id;
+    if (inode->_ctx[index].xl_key != xlator)
+        goto out;
 
-        if (inode->_ctx[index].value1) {
-                if (value1) {
-                        *value1 = inode->_ctx[index].value1;
-                        ret = 0;
-                }
+    if (inode->_ctx[index].value1) {
+        if (value1) {
+            *value1 = inode->_ctx[index].value1;
+            ret = 0;
         }
-        if (inode->_ctx[index].value2) {
-                if (value2) {
-                        *value2 = inode->_ctx[index].value2;
-                        ret = 0;
-                }
+    }
+    if (inode->_ctx[index].value2) {
+        if (value2) {
+            *value2 = inode->_ctx[index].value2;
+            ret = 0;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-__inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+__inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1)
 {
-        uint64_t tmp_value = 0;
-        int ret = 0;
+    uint64_t tmp_value = 0;
+    int ret = 0;
 
-        ret =  __inode_ctx_get2 (inode, xlator, &tmp_value, NULL);
-        if (!ret && value1)
-                *value1 = tmp_value;
+    ret = __inode_ctx_get2(inode, xlator, &tmp_value, NULL);
+    if (!ret && value1)
+        *value1 = tmp_value;
 
-        return ret;
+    return ret;
 }
 
 int
-__inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+__inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2)
 {
-        uint64_t tmp_value = 0;
-        int ret = 0;
+    uint64_t tmp_value = 0;
+    int ret = 0;
 
-        ret =  __inode_ctx_get2 (inode, xlator, NULL, &tmp_value);
-        if (!ret && value2)
-                *value2 = tmp_value;
+    ret = __inode_ctx_get2(inode, xlator, NULL, &tmp_value);
+    if (!ret && value2)
+        *value2 = tmp_value;
 
-        return ret;
+    return ret;
 }
 
-
 int
-inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2)
+inode_ctx_get2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get2 (inode, xlator, value1, value2);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get2(inode, xlator, value1, value2);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+inode_ctx_get1(inode_t *inode, xlator_t *xlator, uint64_t *value2)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get1 (inode, xlator, value2);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get1(inode, xlator, value2);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+inode_ctx_get0(inode_t *inode, xlator_t *xlator, uint64_t *value1)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get0 (inode, xlator, value1);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get0(inode, xlator, value1);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                uint64_t *value2)
+inode_ctx_del2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+               uint64_t *value2)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                if (!inode->_ctx)
-                        goto unlock;
+    LOCK(&inode->lock);
+    {
+        if (!inode->_ctx)
+            goto unlock;
 
-                index = xlator->xl_id;
-                if (inode->_ctx[index].xl_key != xlator) {
-                        ret = -1;
-                        goto unlock;
-                }
+        index = xlator->xl_id;
+        if (inode->_ctx[index].xl_key != xlator) {
+            ret = -1;
+            goto unlock;
+        }
 
-                if (inode->_ctx[index].value1 && value1)
-                        *value1 = inode->_ctx[index].value1;
-                if (inode->_ctx[index].value2 && value2)
-                        *value2 = inode->_ctx[index].value2;
+        if (inode->_ctx[index].value1 && value1)
+            *value1 = inode->_ctx[index].value1;
+        if (inode->_ctx[index].value2 && value2)
+            *value2 = inode->_ctx[index].value2;
 
-                inode->_ctx[index].key    = 0;
-                inode->_ctx[index].xl_key = NULL;
-                inode->_ctx[index].value1 = 0;
-                inode->_ctx[index].value2 = 0;
-        }
+        inode->_ctx[index].key = 0;
+        inode->_ctx[index].xl_key = NULL;
+        inode->_ctx[index].value1 = 0;
+        inode->_ctx[index].value2 = 0;
+    }
 unlock:
-        UNLOCK (&inode->lock);
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 /* function behavior:
@@ -2215,348 +2166,344 @@ unlock:
  - if both are set, both fields are reset.
 */
 static int
-__inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
-                    uint64_t *value2)
+__inode_ctx_reset2(inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                   uint64_t *value2)
 {
-        int index = 0;
-        int ret = 0;
+    int index = 0;
+    int ret = 0;
 
-        if (!inode || !xlator)
-                return -1;
+    if (!inode || !xlator)
+        return -1;
 
-        LOCK (&inode->lock);
-        {
-                index = xlator->xl_id;
-                if (inode->_ctx[index].xl_key != xlator) {
-                        ret = -1;
-                        goto unlock;
-                }
+    LOCK(&inode->lock);
+    {
+        index = xlator->xl_id;
+        if (inode->_ctx[index].xl_key != xlator) {
+            ret = -1;
+            goto unlock;
+        }
 
-                if (inode->_ctx[index].value1 && value1) {
-                        *value1 = inode->_ctx[index].value1;
-                        inode->_ctx[index].value1 = 0;
-                }
-                if (inode->_ctx[index].value2 && value2) {
-                        *value2 = inode->_ctx[index].value2;
-                        inode->_ctx[index].value2 = 0;
-                }
+        if (inode->_ctx[index].value1 && value1) {
+            *value1 = inode->_ctx[index].value1;
+            inode->_ctx[index].value1 = 0;
+        }
+        if (inode->_ctx[index].value2 && value2) {
+            *value2 = inode->_ctx[index].value2;
+            inode->_ctx[index].value2 = 0;
         }
+    }
 unlock:
-        UNLOCK (&inode->lock);
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
-                  uint64_t *value2_p)
-{
-        uint64_t tmp_value1 = 0;
-        uint64_t tmp_value2 = 0;
-        int ret = 0;
-
-        ret =  __inode_ctx_reset2 (inode, xlator, &tmp_value1, &tmp_value2);
-        if (!ret) {
-                if (value1_p)
-                        *value1_p = tmp_value1;
-                if (value2_p)
-                        *value2_p = tmp_value2;
-        }
-        return ret;
+inode_ctx_reset2(inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+                 uint64_t *value2_p)
+{
+    uint64_t tmp_value1 = 0;
+    uint64_t tmp_value2 = 0;
+    int ret = 0;
+
+    ret = __inode_ctx_reset2(inode, xlator, &tmp_value1, &tmp_value2);
+    if (!ret) {
+        if (value1_p)
+            *value1_p = tmp_value1;
+        if (value2_p)
+            *value2_p = tmp_value2;
+    }
+    return ret;
 }
 
 int
-inode_ctx_reset1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+inode_ctx_reset1(inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
 {
-        uint64_t tmp_value2 = 0;
-        int ret = 0;
+    uint64_t tmp_value2 = 0;
+    int ret = 0;
 
-        ret = __inode_ctx_reset2 (inode, xlator, NULL, &tmp_value2);
+    ret = __inode_ctx_reset2(inode, xlator, NULL, &tmp_value2);
 
-        if (!ret && value2_p)
-                *value2_p = tmp_value2;
-
-        return ret;
+    if (!ret && value2_p)
+        *value2_p = tmp_value2;
 
+    return ret;
 }
 int
-inode_ctx_reset0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+inode_ctx_reset0(inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
 {
-        uint64_t tmp_value1 = 0;
-        int ret = 0;
+    uint64_t tmp_value1 = 0;
+    int ret = 0;
 
-        ret = __inode_ctx_reset2 (inode, xlator, &tmp_value1, NULL);
+    ret = __inode_ctx_reset2(inode, xlator, &tmp_value1, NULL);
 
-        if (!ret && value1_p)
-                *value1_p = tmp_value1;
+    if (!ret && value1_p)
+        *value1_p = tmp_value1;
 
-        return ret;
+    return ret;
 }
 
 int
-inode_is_linked (inode_t *inode)
+inode_is_linked(inode_t *inode)
 {
-        int            ret   = 0;
-        inode_table_t *table = NULL;
+    int ret = 0;
+    inode_table_t *table = NULL;
 
-        if (!inode) {
-                gf_msg_callingfn (THIS->name, GF_LOG_WARNING, 0,
-                                  LG_MSG_INODE_NOT_FOUND, "inode not found");
-                return 0;
-        }
+    if (!inode) {
+        gf_msg_callingfn(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INODE_NOT_FOUND,
+                         "inode not found");
+        return 0;
+    }
 
-        table = inode->table;
+    table = inode->table;
 
-        pthread_mutex_lock (&table->lock);
-        {
-                ret = __is_inode_hashed (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
+    pthread_mutex_lock(&table->lock);
+    {
+        ret = __is_inode_hashed(inode);
+    }
+    pthread_mutex_unlock(&table->lock);
 
-        return ret;
+    return ret;
 }
 
 void
-inode_dump (inode_t *inode, char *prefix)
-{
-        int                ret       = -1;
-        xlator_t          *xl        = NULL;
-        int                i         = 0;
-        fd_t              *fd        = NULL;
-        struct _inode_ctx *inode_ctx = NULL;
-        struct list_head   fd_list;
-        int                ref       = 0;
-        char               key[GF_DUMP_MAX_BUF_LEN];
-
-        if (!inode)
-                return;
+inode_dump(inode_t *inode, char *prefix)
+{
+    int ret = -1;
+    xlator_t *xl = NULL;
+    int i = 0;
+    fd_t *fd = NULL;
+    struct _inode_ctx *inode_ctx = NULL;
+    struct list_head fd_list;
+    int ref = 0;
+    char key[GF_DUMP_MAX_BUF_LEN];
+
+    if (!inode)
+        return;
 
-        INIT_LIST_HEAD (&fd_list);
+    INIT_LIST_HEAD(&fd_list);
 
-        ret = TRY_LOCK(&inode->lock);
-        if (ret != 0) {
-                return;
-        }
-
-        {
-                gf_proc_dump_write("gfid", "%s", uuid_utoa (inode->gfid));
-                gf_proc_dump_write("nlookup", "%ld", inode->nlookup);
-                gf_proc_dump_write("fd-count", "%u", inode->fd_count);
-                gf_proc_dump_write("active-fd-count", "%u",
-                                   inode->active_fd_count);
-                gf_proc_dump_write("ref", "%u", inode->ref);
-                gf_proc_dump_write("ia_type", "%d", inode->ia_type);
-                if (inode->_ctx) {
-                        inode_ctx = GF_CALLOC (inode->table->ctxcount,
-                                               sizeof (*inode_ctx),
-                                               gf_common_mt_inode_ctx);
-                        if (inode_ctx == NULL) {
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < inode->table->ctxcount;
-                             i++) {
-                                inode_ctx[i] = inode->_ctx[i];
-                                xl = inode_ctx[i].xl_key;
-                                ref = inode_ctx[i].ref;
-                                if (ref != 0 && xl) {
-                                        gf_proc_dump_build_key (key,
-                                                                "ref_by_xl:",
-                                                                "%s",
-                                                                xl->name);
-                                        gf_proc_dump_write (key, "%d", ref);
-                                }
-                        }
+    ret = TRY_LOCK(&inode->lock);
+    if (ret != 0) {
+        return;
+    }
+
+    {
+        gf_proc_dump_write("gfid", "%s", uuid_utoa(inode->gfid));
+        gf_proc_dump_write("nlookup", "%ld", inode->nlookup);
+        gf_proc_dump_write("fd-count", "%u", inode->fd_count);
+        gf_proc_dump_write("active-fd-count", "%u", inode->active_fd_count);
+        gf_proc_dump_write("ref", "%u", inode->ref);
+        gf_proc_dump_write("ia_type", "%d", inode->ia_type);
+        if (inode->_ctx) {
+            inode_ctx = GF_CALLOC(inode->table->ctxcount, sizeof(*inode_ctx),
+                                  gf_common_mt_inode_ctx);
+            if (inode_ctx == NULL) {
+                goto unlock;
+            }
+
+            for (i = 0; i < inode->table->ctxcount; i++) {
+                inode_ctx[i] = inode->_ctx[i];
+                xl = inode_ctx[i].xl_key;
+                ref = inode_ctx[i].ref;
+                if (ref != 0 && xl) {
+                    gf_proc_dump_build_key(key, "ref_by_xl:", "%s", xl->name);
+                    gf_proc_dump_write(key, "%d", ref);
                 }
+            }
+        }
 
-		if (dump_options.xl_options.dump_fdctx != _gf_true)
-			goto unlock;
-
+        if (dump_options.xl_options.dump_fdctx != _gf_true)
+            goto unlock;
 
-                list_for_each_entry (fd, &inode->fd_list, inode_list) {
-                        fd_ctx_dump (fd, prefix);
-                }
+        list_for_each_entry(fd, &inode->fd_list, inode_list)
+        {
+            fd_ctx_dump(fd, prefix);
         }
+    }
 unlock:
-        UNLOCK(&inode->lock);
-
-        if (inode_ctx && (dump_options.xl_options.dump_inodectx == _gf_true)) {
-                for (i = 0; i < inode->table->ctxcount; i++) {
-                        if (inode_ctx[i].xl_key) {
-                                xl = (xlator_t *)(long)inode_ctx[i].xl_key;
-                                if (xl->dumpops && xl->dumpops->inodectx)
-                                        xl->dumpops->inodectx (xl, inode);
-                        }
-                }
+    UNLOCK(&inode->lock);
+
+    if (inode_ctx && (dump_options.xl_options.dump_inodectx == _gf_true)) {
+        for (i = 0; i < inode->table->ctxcount; i++) {
+            if (inode_ctx[i].xl_key) {
+                xl = (xlator_t *)(long)inode_ctx[i].xl_key;
+                if (xl->dumpops && xl->dumpops->inodectx)
+                    xl->dumpops->inodectx(xl, inode);
+            }
         }
+    }
 
-        GF_FREE (inode_ctx);
+    GF_FREE(inode_ctx);
 
-        return;
+    return;
 }
 
 void
-inode_table_dump (inode_table_t *itable, char *prefix)
+inode_table_dump(inode_table_t *itable, char *prefix)
 {
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int ret = 0;
 
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     ret = 0;
-
-        if (!itable)
-                return;
+    if (!itable)
+        return;
 
-        ret = pthread_mutex_trylock(&itable->lock);
+    ret = pthread_mutex_trylock(&itable->lock);
 
-        if (ret != 0) {
-                return;
-        }
+    if (ret != 0) {
+        return;
+    }
 
-        gf_proc_dump_build_key(key, prefix, "hashsize");
-        gf_proc_dump_write(key, "%d", itable->hashsize);
-        gf_proc_dump_build_key(key, prefix, "name");
-        gf_proc_dump_write(key, "%s", itable->name);
+    gf_proc_dump_build_key(key, prefix, "hashsize");
+    gf_proc_dump_write(key, "%d", itable->hashsize);
+    gf_proc_dump_build_key(key, prefix, "name");
+    gf_proc_dump_write(key, "%s", itable->name);
 
-        gf_proc_dump_build_key(key, prefix, "lru_limit");
-        gf_proc_dump_write(key, "%d", itable->lru_limit);
-        gf_proc_dump_build_key(key, prefix, "active_size");
-        gf_proc_dump_write(key, "%d", itable->active_size);
-        gf_proc_dump_build_key(key, prefix, "lru_size");
-        gf_proc_dump_write(key, "%d", itable->lru_size);
-        gf_proc_dump_build_key(key, prefix, "purge_size");
-        gf_proc_dump_write(key, "%d", itable->purge_size);
+    gf_proc_dump_build_key(key, prefix, "lru_limit");
+    gf_proc_dump_write(key, "%d", itable->lru_limit);
+    gf_proc_dump_build_key(key, prefix, "active_size");
+    gf_proc_dump_write(key, "%d", itable->active_size);
+    gf_proc_dump_build_key(key, prefix, "lru_size");
+    gf_proc_dump_write(key, "%d", itable->lru_size);
+    gf_proc_dump_build_key(key, prefix, "purge_size");
+    gf_proc_dump_write(key, "%d", itable->purge_size);
 
-        INODE_DUMP_LIST(&itable->active, key, prefix, "active");
-        INODE_DUMP_LIST(&itable->lru, key, prefix, "lru");
-        INODE_DUMP_LIST(&itable->purge, key, prefix, "purge");
+    INODE_DUMP_LIST(&itable->active, key, prefix, "active");
+    INODE_DUMP_LIST(&itable->lru, key, prefix, "lru");
+    INODE_DUMP_LIST(&itable->purge, key, prefix, "purge");
 
-        pthread_mutex_unlock(&itable->lock);
+    pthread_mutex_unlock(&itable->lock);
 }
 
 void
-inode_dump_to_dict (inode_t *inode, char *prefix, dict_t *dict)
+inode_dump_to_dict(inode_t *inode, char *prefix, dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
 
-        ret = TRY_LOCK (&inode->lock);
-        if (ret)
-                return;
+    ret = TRY_LOCK(&inode->lock);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.gfid", prefix);
-        ret = dict_set_dynstr (dict, key, gf_strdup (uuid_utoa (inode->gfid)));
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.gfid", prefix);
+    ret = dict_set_dynstr(dict, key, gf_strdup(uuid_utoa(inode->gfid)));
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "%s.nlookup", prefix);
-        ret = dict_set_uint64 (dict, key, inode->nlookup);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.nlookup", prefix);
+    ret = dict_set_uint64(dict, key, inode->nlookup);
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "%s.ref", prefix);
-        ret = dict_set_uint32 (dict, key, inode->ref);
-        if (ret)
-                goto out;
+    snprintf(key, sizeof(key), "%s.ref", prefix);
+    ret = dict_set_uint32(dict, key, inode->ref);
+    if (ret)
+        goto out;
 
-        snprintf (key, sizeof (key), "%s.ia_type", prefix);
-        ret = dict_set_int32 (dict, key, inode->ia_type);
+    snprintf(key, sizeof(key), "%s.ia_type", prefix);
+    ret = dict_set_int32(dict, key, inode->ia_type);
 
 out:
-        UNLOCK (&inode->lock);
-        return;
+    UNLOCK(&inode->lock);
+    return;
 }
 
 void
-inode_table_dump_to_dict (inode_table_t *itable, char *prefix, dict_t *dict)
+inode_table_dump_to_dict(inode_table_t *itable, char *prefix, dict_t *dict)
 {
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             ret = 0;
-        inode_t         *inode = NULL;
-        int             count = 0;
-
-        ret = pthread_mutex_trylock (&itable->lock);
-        if (ret)
-                return;
-
-        snprintf (key, sizeof (key), "%s.itable.active_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->active_size);
-        if (ret)
-                goto out;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int ret = 0;
+    inode_t *inode = NULL;
+    int count = 0;
 
-        snprintf (key, sizeof (key), "%s.itable.lru_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->lru_size);
-        if (ret)
-                goto out;
-
-        snprintf (key, sizeof (key), "%s.itable.purge_size", prefix);
-        ret = dict_set_uint32 (dict, key, itable->purge_size);
-        if (ret)
-                goto out;
-
-        list_for_each_entry (inode, &itable->active, list) {
-                snprintf (key, sizeof (key), "%s.itable.active%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
-        count = 0;
+    ret = pthread_mutex_trylock(&itable->lock);
+    if (ret)
+        return;
 
-        list_for_each_entry (inode, &itable->lru, list) {
-                snprintf (key, sizeof (key), "%s.itable.lru%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
-        count = 0;
-
-        list_for_each_entry (inode, &itable->purge, list) {
-                snprintf (key, sizeof (key), "%s.itable.purge%d", prefix,
-                          count++);
-                inode_dump_to_dict (inode, key, dict);
-        }
+    snprintf(key, sizeof(key), "%s.itable.active_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->active_size);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.itable.lru_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->lru_size);
+    if (ret)
+        goto out;
+
+    snprintf(key, sizeof(key), "%s.itable.purge_size", prefix);
+    ret = dict_set_uint32(dict, key, itable->purge_size);
+    if (ret)
+        goto out;
+
+    list_for_each_entry(inode, &itable->active, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.active%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
+    count = 0;
+
+    list_for_each_entry(inode, &itable->lru, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.lru%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
+    count = 0;
+
+    list_for_each_entry(inode, &itable->purge, list)
+    {
+        snprintf(key, sizeof(key), "%s.itable.purge%d", prefix, count++);
+        inode_dump_to_dict(inode, key, dict);
+    }
 
 out:
-        pthread_mutex_unlock (&itable->lock);
+    pthread_mutex_unlock(&itable->lock);
 
-        return;
+    return;
 }
 
 size_t
-inode_ctx_size (inode_t *inode)
+inode_ctx_size(inode_t *inode)
 {
-        int       i    = 0;
-        size_t    size = 0;
-        xlator_t *xl   = NULL, *old_THIS = NULL;
+    int i = 0;
+    size_t size = 0;
+    xlator_t *xl = NULL, *old_THIS = NULL;
 
-        if (!inode)
-                goto out;
+    if (!inode)
+        goto out;
 
-        LOCK (&inode->lock);
-        {
-                for (i = 0; i < inode->table->ctxcount; i++) {
-                        if (!inode->_ctx[i].xl_key)
-                                continue;
-
-                        xl = (xlator_t *)(long)inode->_ctx[i].xl_key;
-                        old_THIS = THIS;
-                        THIS = xl;
-
-                        /* If inode ref is taken when THIS is global xlator,
-                         * the ctx xl_key is set, but the value is NULL.
-                         * For global xlator the cbks can be NULL, hence check
-                         * for the same */
-                        if (!xl->cbks) {
-                                THIS = old_THIS;
-                                continue;
-                        }
-
-                        if (xl->cbks->ictxsize)
-                                size += xl->cbks->ictxsize (xl, inode);
-
-                        THIS = old_THIS;
-                }
+    LOCK(&inode->lock);
+    {
+        for (i = 0; i < inode->table->ctxcount; i++) {
+            if (!inode->_ctx[i].xl_key)
+                continue;
+
+            xl = (xlator_t *)(long)inode->_ctx[i].xl_key;
+            old_THIS = THIS;
+            THIS = xl;
+
+            /* If inode ref is taken when THIS is global xlator,
+             * the ctx xl_key is set, but the value is NULL.
+             * For global xlator the cbks can be NULL, hence check
+             * for the same */
+            if (!xl->cbks) {
+                THIS = old_THIS;
+                continue;
+            }
+
+            if (xl->cbks->ictxsize)
+                size += xl->cbks->ictxsize(xl, inode);
+
+            THIS = old_THIS;
         }
-        UNLOCK (&inode->lock);
+    }
+    UNLOCK(&inode->lock);
 
 out:
-        return size;
+    return size;
 }
 
 /* *
@@ -2566,23 +2513,24 @@ out:
  * not possible(no hardlinks)
  * */
 void
-inode_find_directory_name (inode_t *inode, const char **name) {
-        dentry_t *dentry = NULL;
+inode_find_directory_name(inode_t *inode, const char **name)
+{
+    dentry_t *dentry = NULL;
 
-        GF_VALIDATE_OR_GOTO ("inode", inode, out);
-        GF_VALIDATE_OR_GOTO ("inode", name, out);
+    GF_VALIDATE_OR_GOTO("inode", inode, out);
+    GF_VALIDATE_OR_GOTO("inode", name, out);
 
-        if (!IA_ISDIR (inode->ia_type))
-                return;
+    if (!IA_ISDIR(inode->ia_type))
+        return;
 
-        pthread_mutex_lock (&inode->table->lock);
-        {
-                dentry = __dentry_search_arbit (inode);
-                if (dentry) {
-                        *name = dentry->name;
-                }
+    pthread_mutex_lock(&inode->table->lock);
+    {
+        dentry = __dentry_search_arbit(inode);
+        if (dentry) {
+            *name = dentry->name;
         }
-        pthread_mutex_unlock (&inode->table->lock);
+    }
+    pthread_mutex_unlock(&inode->table->lock);
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/iobuf.c b/libglusterfs/src/iobuf.c
index b2b4da1c111..8682420d8f8 100644
--- a/libglusterfs/src/iobuf.c
+++ b/libglusterfs/src/iobuf.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "iobuf.h"
 #include "statedump.h"
 #include <stdio.h>
@@ -18,1240 +17,1204 @@
   TODO: implement destroy margins and prefetching of arenas
 */
 
-#define IOBUF_ARENA_MAX_INDEX  (sizeof (gf_iobuf_init_config) /         \
-                                (sizeof (struct iobuf_init_config)))
+#define IOBUF_ARENA_MAX_INDEX                                                  \
+    (sizeof(gf_iobuf_init_config) / (sizeof(struct iobuf_init_config)))
 
 /* Make sure this array is sorted based on pagesize */
 struct iobuf_init_config gf_iobuf_init_config[] = {
-        /* { pagesize, num_pages }, */
-        {128, 1024},
-        {512, 512},
-        {2 * 1024, 512},
-        {8 * 1024, 128},
-        {32 * 1024, 64},
-        {128 * 1024, 32},
-        {256 * 1024, 8},
-        {1 * 1024 * 1024, 2},
+    /* { pagesize, num_pages }, */
+    {128, 1024},     {512, 512},       {2 * 1024, 512}, {8 * 1024, 128},
+    {32 * 1024, 64}, {128 * 1024, 32}, {256 * 1024, 8}, {1 * 1024 * 1024, 2},
 };
 
 int
-gf_iobuf_get_arena_index (size_t page_size)
+gf_iobuf_get_arena_index(size_t page_size)
 {
-        int i = -1;
+    int i = -1;
 
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                if (page_size <= gf_iobuf_init_config[i].pagesize)
-                        break;
-        }
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        if (page_size <= gf_iobuf_init_config[i].pagesize)
+            break;
+    }
 
-        if (i >= IOBUF_ARENA_MAX_INDEX)
-                i = -1;
+    if (i >= IOBUF_ARENA_MAX_INDEX)
+        i = -1;
 
-        return i;
+    return i;
 }
 
-
 size_t
-gf_iobuf_get_pagesize (size_t page_size)
+gf_iobuf_get_pagesize(size_t page_size)
 {
-        int    i    = 0;
-        size_t size = 0;
+    int i = 0;
+    size_t size = 0;
 
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                size = gf_iobuf_init_config[i].pagesize;
-                if (page_size <= size)
-                        break;
-        }
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        size = gf_iobuf_init_config[i].pagesize;
+        if (page_size <= size)
+            break;
+    }
 
-        if (i >= IOBUF_ARENA_MAX_INDEX)
-                size = -1;
+    if (i >= IOBUF_ARENA_MAX_INDEX)
+        size = -1;
 
-        return size;
+    return size;
 }
 
 void
-__iobuf_arena_init_iobufs (struct iobuf_arena *iobuf_arena)
+__iobuf_arena_init_iobufs(struct iobuf_arena *iobuf_arena)
 {
-        int                 iobuf_cnt = 0;
-        struct iobuf       *iobuf = NULL;
-        int                 offset = 0;
-        int                 i = 0;
+    int iobuf_cnt = 0;
+    struct iobuf *iobuf = NULL;
+    int offset = 0;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
 
-        iobuf_cnt  = iobuf_arena->page_count;
+    iobuf_cnt = iobuf_arena->page_count;
 
-        iobuf_arena->iobufs = GF_CALLOC (sizeof (*iobuf), iobuf_cnt,
-                                         gf_common_mt_iobuf);
-        if (!iobuf_arena->iobufs)
-                return;
+    iobuf_arena->iobufs = GF_CALLOC(sizeof(*iobuf), iobuf_cnt,
+                                    gf_common_mt_iobuf);
+    if (!iobuf_arena->iobufs)
+        return;
 
-        iobuf = iobuf_arena->iobufs;
-        for (i = 0; i < iobuf_cnt; i++) {
-                INIT_LIST_HEAD (&iobuf->list);
-                LOCK_INIT (&iobuf->lock);
+    iobuf = iobuf_arena->iobufs;
+    for (i = 0; i < iobuf_cnt; i++) {
+        INIT_LIST_HEAD(&iobuf->list);
+        LOCK_INIT(&iobuf->lock);
 
-                iobuf->iobuf_arena = iobuf_arena;
+        iobuf->iobuf_arena = iobuf_arena;
 
-                iobuf->ptr = iobuf_arena->mem_base + offset;
+        iobuf->ptr = iobuf_arena->mem_base + offset;
 
-                list_add (&iobuf->list, &iobuf_arena->passive.list);
-                iobuf_arena->passive_cnt++;
+        list_add(&iobuf->list, &iobuf_arena->passive.list);
+        iobuf_arena->passive_cnt++;
 
-                offset += iobuf_arena->page_size;
-                iobuf++;
-        }
+        offset += iobuf_arena->page_size;
+        iobuf++;
+    }
 
 out:
-        return;
+    return;
 }
 
-
 void
-__iobuf_arena_destroy_iobufs (struct iobuf_arena *iobuf_arena)
+__iobuf_arena_destroy_iobufs(struct iobuf_arena *iobuf_arena)
 {
-        int                 iobuf_cnt = 0;
-        struct iobuf       *iobuf = NULL;
-        int                 i = 0;
+    int iobuf_cnt = 0;
+    struct iobuf *iobuf = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
 
-        iobuf_cnt  = iobuf_arena->page_count;
+    iobuf_cnt = iobuf_arena->page_count;
 
-        if (!iobuf_arena->iobufs) {
-                gf_msg_callingfn (THIS->name, GF_LOG_ERROR, 0,
-                                  LG_MSG_IOBUFS_NOT_FOUND, "iobufs not found");
-                return;
-        }
+    if (!iobuf_arena->iobufs) {
+        gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0, LG_MSG_IOBUFS_NOT_FOUND,
+                         "iobufs not found");
+        return;
+    }
 
-        iobuf = iobuf_arena->iobufs;
-        for (i = 0; i < iobuf_cnt; i++) {
-                GF_ASSERT (GF_ATOMIC_GET(iobuf->ref) == 0);
+    iobuf = iobuf_arena->iobufs;
+    for (i = 0; i < iobuf_cnt; i++) {
+        GF_ASSERT(GF_ATOMIC_GET(iobuf->ref) == 0);
 
-                LOCK_DESTROY (&iobuf->lock);
-                list_del_init (&iobuf->list);
-                iobuf++;
-        }
+        LOCK_DESTROY(&iobuf->lock);
+        list_del_init(&iobuf->list);
+        iobuf++;
+    }
 
-        GF_FREE (iobuf_arena->iobufs);
+    GF_FREE(iobuf_arena->iobufs);
 
 out:
-        return;
+    return;
 }
 
-
 void
-__iobuf_arena_destroy (struct iobuf_pool *iobuf_pool,
-                       struct iobuf_arena *iobuf_arena)
+__iobuf_arena_destroy(struct iobuf_pool *iobuf_pool,
+                      struct iobuf_arena *iobuf_arena)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
 
-        if (iobuf_pool->rdma_deregistration)
-                iobuf_pool->rdma_deregistration (iobuf_pool->mr_list,
-                                                 iobuf_arena);
+    if (iobuf_pool->rdma_deregistration)
+        iobuf_pool->rdma_deregistration(iobuf_pool->mr_list, iobuf_arena);
 
-        __iobuf_arena_destroy_iobufs (iobuf_arena);
+    __iobuf_arena_destroy_iobufs(iobuf_arena);
 
-        if (iobuf_arena->mem_base
-            && iobuf_arena->mem_base != MAP_FAILED)
-                munmap (iobuf_arena->mem_base, iobuf_arena->arena_size);
+    if (iobuf_arena->mem_base && iobuf_arena->mem_base != MAP_FAILED)
+        munmap(iobuf_arena->mem_base, iobuf_arena->arena_size);
 
-        GF_FREE (iobuf_arena);
+    GF_FREE(iobuf_arena);
 out:
-        return;
+    return;
 }
 
-
 struct iobuf_arena *
-__iobuf_arena_alloc (struct iobuf_pool *iobuf_pool, size_t page_size,
-                     int32_t num_iobufs)
+__iobuf_arena_alloc(struct iobuf_pool *iobuf_pool, size_t page_size,
+                    int32_t num_iobufs)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        size_t              rounded_size = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    size_t rounded_size = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        iobuf_arena = GF_CALLOC (sizeof (*iobuf_arena), 1,
-                                 gf_common_mt_iobuf_arena);
-        if (!iobuf_arena)
-                goto err;
+    iobuf_arena = GF_CALLOC(sizeof(*iobuf_arena), 1, gf_common_mt_iobuf_arena);
+    if (!iobuf_arena)
+        goto err;
 
-        INIT_LIST_HEAD (&iobuf_arena->list);
-        INIT_LIST_HEAD (&iobuf_arena->all_list);
-        INIT_LIST_HEAD (&iobuf_arena->active.list);
-        INIT_LIST_HEAD (&iobuf_arena->passive.list);
-        iobuf_arena->iobuf_pool = iobuf_pool;
+    INIT_LIST_HEAD(&iobuf_arena->list);
+    INIT_LIST_HEAD(&iobuf_arena->all_list);
+    INIT_LIST_HEAD(&iobuf_arena->active.list);
+    INIT_LIST_HEAD(&iobuf_arena->passive.list);
+    iobuf_arena->iobuf_pool = iobuf_pool;
 
-        rounded_size = gf_iobuf_get_pagesize (page_size);
+    rounded_size = gf_iobuf_get_pagesize(page_size);
 
-        iobuf_arena->page_size  = rounded_size;
-        iobuf_arena->page_count = num_iobufs;
+    iobuf_arena->page_size = rounded_size;
+    iobuf_arena->page_count = num_iobufs;
 
-        iobuf_arena->arena_size = rounded_size * num_iobufs;
+    iobuf_arena->arena_size = rounded_size * num_iobufs;
 
-        iobuf_arena->mem_base = mmap (NULL, iobuf_arena->arena_size,
-                                      PROT_READ|PROT_WRITE,
-                                      MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
-        if (iobuf_arena->mem_base == MAP_FAILED) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_MAPPING_FAILED,
-                        "mapping failed");
-                goto err;
-        }
+    iobuf_arena->mem_base = mmap(NULL, iobuf_arena->arena_size,
+                                 PROT_READ | PROT_WRITE,
+                                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (iobuf_arena->mem_base == MAP_FAILED) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_MAPPING_FAILED,
+               "mapping failed");
+        goto err;
+    }
 
-        if (iobuf_pool->rdma_registration) {
-                iobuf_pool->rdma_registration (iobuf_pool->device,
-                                               iobuf_arena);
-        }
+    if (iobuf_pool->rdma_registration) {
+        iobuf_pool->rdma_registration(iobuf_pool->device, iobuf_arena);
+    }
 
-        list_add_tail (&iobuf_arena->all_list, &iobuf_pool->all_arenas);
+    list_add_tail(&iobuf_arena->all_list, &iobuf_pool->all_arenas);
 
-        __iobuf_arena_init_iobufs (iobuf_arena);
-        if (!iobuf_arena->iobufs) {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_IOBUF_FAILED,
-                        "init failed");
-                goto err;
-        }
+    __iobuf_arena_init_iobufs(iobuf_arena);
+    if (!iobuf_arena->iobufs) {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_IOBUF_FAILED,
+               "init failed");
+        goto err;
+    }
 
-        iobuf_pool->arena_cnt++;
+    iobuf_pool->arena_cnt++;
 
-        return iobuf_arena;
+    return iobuf_arena;
 
 err:
-        __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
+    __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
 
 out:
-        return NULL;
+    return NULL;
 }
 
-
 struct iobuf_arena *
-__iobuf_arena_unprune (struct iobuf_pool *iobuf_pool, size_t page_size)
+__iobuf_arena_unprune(struct iobuf_pool *iobuf_pool, size_t page_size)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        struct iobuf_arena *tmp          = NULL;
-        int                 index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
-
-        list_for_each_entry (tmp, &iobuf_pool->purge[index], list) {
-                list_del_init (&tmp->list);
-                iobuf_arena = tmp;
-                break;
-        }
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
+    int index = 0;
+
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
+
+    index = gf_iobuf_get_arena_index(page_size);
+    if (index == -1) {
+        gf_msg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+               "page_size (%zu) of iobufs in arena being added is "
+               "greater than max available",
+               page_size);
+        return NULL;
+    }
+
+    list_for_each_entry(tmp, &iobuf_pool->purge[index], list)
+    {
+        list_del_init(&tmp->list);
+        iobuf_arena = tmp;
+        break;
+    }
 out:
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
 struct iobuf_arena *
-__iobuf_pool_add_arena (struct iobuf_pool *iobuf_pool, size_t page_size,
-                        int32_t num_pages)
+__iobuf_pool_add_arena(struct iobuf_pool *iobuf_pool, size_t page_size,
+                       int32_t num_pages)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        int                 index        = 0;
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
-
-        iobuf_arena = __iobuf_arena_unprune (iobuf_pool, page_size);
+    struct iobuf_arena *iobuf_arena = NULL;
+    int index = 0;
+
+    index = gf_iobuf_get_arena_index(page_size);
+    if (index == -1) {
+        gf_msg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+               "page_size (%zu) of iobufs in arena being added is "
+               "greater than max available",
+               page_size);
+        return NULL;
+    }
 
-        if (!iobuf_arena)
-                iobuf_arena = __iobuf_arena_alloc (iobuf_pool, page_size,
-                                                   num_pages);
+    iobuf_arena = __iobuf_arena_unprune(iobuf_pool, page_size);
 
-        if (!iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                return NULL;
-        }
-        list_add (&iobuf_arena->list, &iobuf_pool->arenas[index]);
+    if (!iobuf_arena)
+        iobuf_arena = __iobuf_arena_alloc(iobuf_pool, page_size, num_pages);
 
+    if (!iobuf_arena) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
+               "arena not found");
+        return NULL;
+    }
+    list_add(&iobuf_arena->list, &iobuf_pool->arenas[index]);
 
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
 struct iobuf_arena *
-iobuf_pool_add_arena (struct iobuf_pool *iobuf_pool, size_t page_size,
-                      int32_t num_pages)
+iobuf_pool_add_arena(struct iobuf_pool *iobuf_pool, size_t page_size,
+                     int32_t num_pages)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                iobuf_arena = __iobuf_pool_add_arena (iobuf_pool, page_size,
-                                                      num_pages);
-        }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        iobuf_arena = __iobuf_pool_add_arena(iobuf_pool, page_size, num_pages);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
 /* This function destroys all the iobufs and the iobuf_pool */
 void
-iobuf_pool_destroy (struct iobuf_pool *iobuf_pool)
+iobuf_pool_destroy(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *tmp         = NULL;
-        int                 i           = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->arenas[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->purge[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        /* If there are no iobuf leaks, there should be no
-                         * arenas in the filled list. If at all there are any
-                         * arenas in the filled list, the below function will
-                         * assert.
-                         */
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                        &iobuf_pool->filled[i], list) {
-                                list_del_init (&iobuf_arena->list);
-                                iobuf_pool->arena_cnt--;
-                                __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
-                        }
-                        /* If there are no iobuf leaks, there shoould be
-                         * no standard allocated arenas, iobuf_put will free
-                         * such arenas.
-                         * TODO: Free the stdalloc arenas forcefully if present?
-                         */
-                }
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->arenas[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->purge[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            /* If there are no iobuf leaks, there should be no
+             * arenas in the filled list. If at all there are any
+             * arenas in the filled list, the below function will
+             * assert.
+             */
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->filled[i],
+                                     list)
+            {
+                list_del_init(&iobuf_arena->list);
+                iobuf_pool->arena_cnt--;
+                __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
+            }
+            /* If there are no iobuf leaks, there shoould be
+             * no standard allocated arenas, iobuf_put will free
+             * such arenas.
+             * TODO: Free the stdalloc arenas forcefully if present?
+             */
         }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
-        pthread_mutex_destroy (&iobuf_pool->mutex);
+    pthread_mutex_destroy(&iobuf_pool->mutex);
 
-        GF_FREE (iobuf_pool);
+    GF_FREE(iobuf_pool);
 
 out:
-        return;
+    return;
 }
 
 static void
-iobuf_create_stdalloc_arena (struct iobuf_pool *iobuf_pool)
+iobuf_create_stdalloc_arena(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        /* No locking required here as its called only once during init */
-        iobuf_arena = GF_CALLOC (sizeof (*iobuf_arena), 1,
-                                 gf_common_mt_iobuf_arena);
-        if (!iobuf_arena)
-                goto err;
+    /* No locking required here as its called only once during init */
+    iobuf_arena = GF_CALLOC(sizeof(*iobuf_arena), 1, gf_common_mt_iobuf_arena);
+    if (!iobuf_arena)
+        goto err;
 
-        INIT_LIST_HEAD (&iobuf_arena->list);
-        INIT_LIST_HEAD (&iobuf_arena->active.list);
-        INIT_LIST_HEAD (&iobuf_arena->passive.list);
+    INIT_LIST_HEAD(&iobuf_arena->list);
+    INIT_LIST_HEAD(&iobuf_arena->active.list);
+    INIT_LIST_HEAD(&iobuf_arena->passive.list);
 
-        iobuf_arena->iobuf_pool = iobuf_pool;
+    iobuf_arena->iobuf_pool = iobuf_pool;
 
-        iobuf_arena->page_size = 0x7fffffff;
+    iobuf_arena->page_size = 0x7fffffff;
 
-        list_add_tail (&iobuf_arena->list,
-                       &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX]);
+    list_add_tail(&iobuf_arena->list,
+                  &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX]);
 
 err:
-        return;
+    return;
 }
 
 struct iobuf_pool *
-iobuf_pool_new (void)
+iobuf_pool_new(void)
 {
-        struct iobuf_pool  *iobuf_pool = NULL;
-        int                 i          = 0;
-        size_t              page_size  = 0;
-        size_t              arena_size = 0;
-        int32_t             num_pages  = 0;
-
-        iobuf_pool = GF_CALLOC (sizeof (*iobuf_pool), 1,
-                                gf_common_mt_iobuf_pool);
-        if (!iobuf_pool)
-                goto out;
-        INIT_LIST_HEAD (&iobuf_pool->all_arenas);
-        pthread_mutex_init (&iobuf_pool->mutex, NULL);
-        for (i = 0; i <= IOBUF_ARENA_MAX_INDEX; i++) {
-                INIT_LIST_HEAD (&iobuf_pool->arenas[i]);
-                INIT_LIST_HEAD (&iobuf_pool->filled[i]);
-                INIT_LIST_HEAD (&iobuf_pool->purge[i]);
-        }
-
-        iobuf_pool->default_page_size  = 128 * GF_UNIT_KB;
-
-        iobuf_pool->rdma_registration = NULL;
-        iobuf_pool->rdma_deregistration = NULL;
-
-        for (i = 0; i < GF_RDMA_DEVICE_COUNT; i++) {
-
-                iobuf_pool->device[i] = NULL;
-                iobuf_pool->mr_list[i] = NULL;
-
-        }
-
-        arena_size = 0;
-        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                page_size = gf_iobuf_init_config[i].pagesize;
-                num_pages = gf_iobuf_init_config[i].num_pages;
-
-                iobuf_pool_add_arena (iobuf_pool, page_size, num_pages);
-
-                arena_size += page_size * num_pages;
-        }
-
-        /* Need an arena to handle all the bigger iobuf requests */
-        iobuf_create_stdalloc_arena (iobuf_pool);
-
-        iobuf_pool->arena_size = arena_size;
+    struct iobuf_pool *iobuf_pool = NULL;
+    int i = 0;
+    size_t page_size = 0;
+    size_t arena_size = 0;
+    int32_t num_pages = 0;
+
+    iobuf_pool = GF_CALLOC(sizeof(*iobuf_pool), 1, gf_common_mt_iobuf_pool);
+    if (!iobuf_pool)
+        goto out;
+    INIT_LIST_HEAD(&iobuf_pool->all_arenas);
+    pthread_mutex_init(&iobuf_pool->mutex, NULL);
+    for (i = 0; i <= IOBUF_ARENA_MAX_INDEX; i++) {
+        INIT_LIST_HEAD(&iobuf_pool->arenas[i]);
+        INIT_LIST_HEAD(&iobuf_pool->filled[i]);
+        INIT_LIST_HEAD(&iobuf_pool->purge[i]);
+    }
+
+    iobuf_pool->default_page_size = 128 * GF_UNIT_KB;
+
+    iobuf_pool->rdma_registration = NULL;
+    iobuf_pool->rdma_deregistration = NULL;
+
+    for (i = 0; i < GF_RDMA_DEVICE_COUNT; i++) {
+        iobuf_pool->device[i] = NULL;
+        iobuf_pool->mr_list[i] = NULL;
+    }
+
+    arena_size = 0;
+    for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+        page_size = gf_iobuf_init_config[i].pagesize;
+        num_pages = gf_iobuf_init_config[i].num_pages;
+
+        iobuf_pool_add_arena(iobuf_pool, page_size, num_pages);
+
+        arena_size += page_size * num_pages;
+    }
+
+    /* Need an arena to handle all the bigger iobuf requests */
+    iobuf_create_stdalloc_arena(iobuf_pool);
+
+    iobuf_pool->arena_size = arena_size;
 out:
 
-        return iobuf_pool;
+    return iobuf_pool;
 }
 
-
 void
-__iobuf_arena_prune (struct iobuf_pool *iobuf_pool,
-                     struct iobuf_arena *iobuf_arena, int index)
+__iobuf_arena_prune(struct iobuf_pool *iobuf_pool,
+                    struct iobuf_arena *iobuf_arena, int index)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        /* code flow comes here only if the arena is in purge list and we can
-         * free the arena only if we have at least one arena in 'arenas' list
-         * (ie, at least few iobufs free in arena), that way, there won't
-         * be spurious mmap/unmap of buffers
-         */
-        if (list_empty (&iobuf_pool->arenas[index]))
-                goto out;
+    /* code flow comes here only if the arena is in purge list and we can
+     * free the arena only if we have at least one arena in 'arenas' list
+     * (ie, at least few iobufs free in arena), that way, there won't
+     * be spurious mmap/unmap of buffers
+     */
+    if (list_empty(&iobuf_pool->arenas[index]))
+        goto out;
 
-        /* All cases matched, destroy */
-        list_del_init (&iobuf_arena->list);
-        list_del_init (&iobuf_arena->all_list);
-        iobuf_pool->arena_cnt--;
+    /* All cases matched, destroy */
+    list_del_init(&iobuf_arena->list);
+    list_del_init(&iobuf_arena->all_list);
+    iobuf_pool->arena_cnt--;
 
-        __iobuf_arena_destroy (iobuf_pool, iobuf_arena);
+    __iobuf_arena_destroy(iobuf_pool, iobuf_arena);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobuf_pool_prune (struct iobuf_pool *iobuf_pool)
+iobuf_pool_prune(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *tmp         = NULL;
-        int                 i           = 0;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *tmp = NULL;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
-                        if (list_empty (&iobuf_pool->arenas[i])) {
-                                continue;
-                        }
-
-                        list_for_each_entry_safe (iobuf_arena, tmp,
-                                                  &iobuf_pool->purge[i], list) {
-                                __iobuf_arena_prune (iobuf_pool, iobuf_arena, i);
-                        }
-                }
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        for (i = 0; i < IOBUF_ARENA_MAX_INDEX; i++) {
+            if (list_empty(&iobuf_pool->arenas[i])) {
+                continue;
+            }
+
+            list_for_each_entry_safe(iobuf_arena, tmp, &iobuf_pool->purge[i],
+                                     list)
+            {
+                __iobuf_arena_prune(iobuf_pool, iobuf_arena, i);
+            }
         }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
 struct iobuf_arena *
-__iobuf_select_arena (struct iobuf_pool *iobuf_pool, size_t page_size)
+__iobuf_select_arena(struct iobuf_pool *iobuf_pool, size_t page_size)
 {
-        struct iobuf_arena *iobuf_arena  = NULL;
-        struct iobuf_arena *trav         = NULL;
-        int                 index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
-
-        index = gf_iobuf_get_arena_index (page_size);
-        if (index == -1) {
-                gf_msg ("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
-                        "page_size (%zu) of iobufs in arena being added is "
-                        "greater than max available", page_size);
-                return NULL;
-        }
-
-        /* look for unused iobuf from the head-most arena */
-        list_for_each_entry (trav, &iobuf_pool->arenas[index], list) {
-                if (trav->passive_cnt) {
-                        iobuf_arena = trav;
-                        break;
-                }
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *trav = NULL;
+    int index = 0;
+
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
+
+    index = gf_iobuf_get_arena_index(page_size);
+    if (index == -1) {
+        gf_msg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+               "page_size (%zu) of iobufs in arena being added is "
+               "greater than max available",
+               page_size);
+        return NULL;
+    }
+
+    /* look for unused iobuf from the head-most arena */
+    list_for_each_entry(trav, &iobuf_pool->arenas[index], list)
+    {
+        if (trav->passive_cnt) {
+            iobuf_arena = trav;
+            break;
         }
+    }
 
-        if (!iobuf_arena) {
-                /* all arenas were full, find the right count to add */
-                iobuf_arena = __iobuf_pool_add_arena (iobuf_pool, page_size,
-                                                      gf_iobuf_init_config[index].num_pages);
-        }
+    if (!iobuf_arena) {
+        /* all arenas were full, find the right count to add */
+        iobuf_arena = __iobuf_pool_add_arena(
+            iobuf_pool, page_size, gf_iobuf_init_config[index].num_pages);
+    }
 
 out:
-        return iobuf_arena;
+    return iobuf_arena;
 }
 
-
 struct iobuf *
-__iobuf_get (struct iobuf_arena *iobuf_arena, size_t page_size)
+__iobuf_get(struct iobuf_arena *iobuf_arena, size_t page_size)
 {
-        struct iobuf      *iobuf        = NULL;
-        struct iobuf_pool *iobuf_pool   = NULL;
-        int                index        = 0;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
+    struct iobuf *iobuf = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
+    int index = 0;
 
-        iobuf_pool = iobuf_arena->iobuf_pool;
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
 
-        list_for_each_entry (iobuf, &iobuf_arena->passive.list, list)
-                break;
+    iobuf_pool = iobuf_arena->iobuf_pool;
 
-        list_del (&iobuf->list);
-        iobuf_arena->passive_cnt--;
+    list_for_each_entry(iobuf, &iobuf_arena->passive.list, list) break;
 
-        list_add (&iobuf->list, &iobuf_arena->active.list);
-        iobuf_arena->active_cnt++;
+    list_del(&iobuf->list);
+    iobuf_arena->passive_cnt--;
 
-        /* no resetting requied for this element */
-        iobuf_arena->alloc_cnt++;
+    list_add(&iobuf->list, &iobuf_arena->active.list);
+    iobuf_arena->active_cnt++;
 
-        if (iobuf_arena->max_active < iobuf_arena->active_cnt)
-                iobuf_arena->max_active = iobuf_arena->active_cnt;
+    /* no resetting requied for this element */
+    iobuf_arena->alloc_cnt++;
 
-        if (iobuf_arena->passive_cnt == 0) {
-                index = gf_iobuf_get_arena_index (page_size);
-                if (index == -1) {
-                        gf_msg ("iobuf", GF_LOG_ERROR, 0,
-                                LG_MSG_PAGE_SIZE_EXCEEDED, "page_size (%zu) of"
-                                " iobufs in arena being added is greater "
-                                "than max available", page_size);
-                        goto out;
-                }
+    if (iobuf_arena->max_active < iobuf_arena->active_cnt)
+        iobuf_arena->max_active = iobuf_arena->active_cnt;
 
-                list_del (&iobuf_arena->list);
-                list_add (&iobuf_arena->list, &iobuf_pool->filled[index]);
+    if (iobuf_arena->passive_cnt == 0) {
+        index = gf_iobuf_get_arena_index(page_size);
+        if (index == -1) {
+            gf_msg("iobuf", GF_LOG_ERROR, 0, LG_MSG_PAGE_SIZE_EXCEEDED,
+                   "page_size (%zu) of"
+                   " iobufs in arena being added is greater "
+                   "than max available",
+                   page_size);
+            goto out;
         }
 
+        list_del(&iobuf_arena->list);
+        list_add(&iobuf_arena->list, &iobuf_pool->filled[index]);
+    }
+
 out:
-        return iobuf;
+    return iobuf;
 }
 
 struct iobuf *
-iobuf_get_from_stdalloc (struct iobuf_pool *iobuf_pool, size_t page_size)
+iobuf_get_from_stdalloc(struct iobuf_pool *iobuf_pool, size_t page_size)
 {
-        struct iobuf       *iobuf       = NULL;
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_arena *trav        = NULL;
-        int                 ret         = -1;
-
-        /* The first arena in the 'MAX-INDEX' will always be used for misc */
-        list_for_each_entry (trav, &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX],
-                             list) {
-                iobuf_arena = trav;
-                break;
-        }
-
-        iobuf = GF_CALLOC (1, sizeof (*iobuf), gf_common_mt_iobuf);
-        if (!iobuf)
-                goto out;
-
-        /* 4096 is the alignment */
-        iobuf->free_ptr = GF_CALLOC (1, ((page_size + GF_IOBUF_ALIGN_SIZE) - 1),
-                                     gf_common_mt_char);
-        if (!iobuf->free_ptr)
-                goto out;
-
-        iobuf->ptr = GF_ALIGN_BUF (iobuf->free_ptr, GF_IOBUF_ALIGN_SIZE);
-        iobuf->iobuf_arena = iobuf_arena;
-        LOCK_INIT (&iobuf->lock);
-
-        /* Hold a ref because you are allocating and using it */
-        GF_ATOMIC_INIT (iobuf->ref, 1);
-
-        ret = 0;
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_arena *trav = NULL;
+    int ret = -1;
+
+    /* The first arena in the 'MAX-INDEX' will always be used for misc */
+    list_for_each_entry(trav, &iobuf_pool->arenas[IOBUF_ARENA_MAX_INDEX], list)
+    {
+        iobuf_arena = trav;
+        break;
+    }
+
+    iobuf = GF_CALLOC(1, sizeof(*iobuf), gf_common_mt_iobuf);
+    if (!iobuf)
+        goto out;
+
+    /* 4096 is the alignment */
+    iobuf->free_ptr = GF_CALLOC(1, ((page_size + GF_IOBUF_ALIGN_SIZE) - 1),
+                                gf_common_mt_char);
+    if (!iobuf->free_ptr)
+        goto out;
+
+    iobuf->ptr = GF_ALIGN_BUF(iobuf->free_ptr, GF_IOBUF_ALIGN_SIZE);
+    iobuf->iobuf_arena = iobuf_arena;
+    LOCK_INIT(&iobuf->lock);
+
+    /* Hold a ref because you are allocating and using it */
+    GF_ATOMIC_INIT(iobuf->ref, 1);
+
+    ret = 0;
 out:
-        if (ret && iobuf) {
-                GF_FREE (iobuf->free_ptr);
-                GF_FREE (iobuf);
-                iobuf = NULL;
-        }
+    if (ret && iobuf) {
+        GF_FREE(iobuf->free_ptr);
+        GF_FREE(iobuf);
+        iobuf = NULL;
+    }
 
-        return iobuf;
+    return iobuf;
 }
 
-
 struct iobuf *
-iobuf_get2 (struct iobuf_pool *iobuf_pool, size_t page_size)
+iobuf_get2(struct iobuf_pool *iobuf_pool, size_t page_size)
 {
-        struct iobuf       *iobuf        = NULL;
-        struct iobuf_arena *iobuf_arena  = NULL;
-        size_t              rounded_size = 0;
-
-        if (page_size == 0) {
-                page_size = iobuf_pool->default_page_size;
-        }
-
-        rounded_size = gf_iobuf_get_pagesize (page_size);
-        if (rounded_size == -1) {
-                /* make sure to provide the requested buffer with standard
-                   memory allocations */
-                iobuf = iobuf_get_from_stdalloc (iobuf_pool, page_size);
-
-                gf_msg_debug ("iobuf", 0, "request for iobuf of size %zu "
-                        "is serviced using standard calloc() (%p) as it "
-                        "exceeds the maximum available buffer size",
-                        page_size, iobuf);
-
-                iobuf_pool->request_misses++;
-                return iobuf;
-        }
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
+    size_t rounded_size = 0;
+
+    if (page_size == 0) {
+        page_size = iobuf_pool->default_page_size;
+    }
+
+    rounded_size = gf_iobuf_get_pagesize(page_size);
+    if (rounded_size == -1) {
+        /* make sure to provide the requested buffer with standard
+           memory allocations */
+        iobuf = iobuf_get_from_stdalloc(iobuf_pool, page_size);
+
+        gf_msg_debug("iobuf", 0,
+                     "request for iobuf of size %zu "
+                     "is serviced using standard calloc() (%p) as it "
+                     "exceeds the maximum available buffer size",
+                     page_size, iobuf);
+
+        iobuf_pool->request_misses++;
+        return iobuf;
+    }
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                /* most eligible arena for picking an iobuf */
-                iobuf_arena = __iobuf_select_arena (iobuf_pool, rounded_size);
-                if (!iobuf_arena)
-                        goto unlock;
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        /* most eligible arena for picking an iobuf */
+        iobuf_arena = __iobuf_select_arena(iobuf_pool, rounded_size);
+        if (!iobuf_arena)
+            goto unlock;
 
-                iobuf = __iobuf_get (iobuf_arena, rounded_size);
-                if (!iobuf)
-                        goto unlock;
+        iobuf = __iobuf_get(iobuf_arena, rounded_size);
+        if (!iobuf)
+            goto unlock;
 
-                iobuf_ref (iobuf);
-         }
+        iobuf_ref(iobuf);
+    }
 unlock:
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
-        return iobuf;
+    return iobuf;
 }
 
 struct iobuf *
-iobuf_get_page_aligned (struct iobuf_pool *iobuf_pool, size_t page_size,
-                        size_t align_size)
+iobuf_get_page_aligned(struct iobuf_pool *iobuf_pool, size_t page_size,
+                       size_t align_size)
 {
-        size_t              req_size     = 0;
-        struct iobuf       *iobuf        = NULL;
+    size_t req_size = 0;
+    struct iobuf *iobuf = NULL;
 
-        req_size = page_size;
+    req_size = page_size;
 
-        if (req_size == 0) {
-                req_size = iobuf_pool->default_page_size;
-        }
+    if (req_size == 0) {
+        req_size = iobuf_pool->default_page_size;
+    }
 
-        iobuf = iobuf_get2 (iobuf_pool, req_size + align_size);
-        if (!iobuf)
-                return NULL;
-        /* If std allocation was used, then free_ptr will be non-NULL. In this
-         * case, we do not want to modify the original free_ptr.
-         * On the other hand, if the buf was gotten through the available
-         * arenas, then we use iobuf->free_ptr to store the original
-         * pointer to the offset into the mmap'd block of memory and in turn
-         * reuse iobuf->ptr to hold the page-aligned address. And finally, in
-         * iobuf_put(), we copy iobuf->free_ptr into iobuf->ptr - back to where
-         * it was originally when __iobuf_get() returned this iobuf.
-         */
-        if (!iobuf->free_ptr)
-                iobuf->free_ptr = iobuf->ptr;
-        iobuf->ptr = GF_ALIGN_BUF (iobuf->ptr, align_size);
-
-        return iobuf;
+    iobuf = iobuf_get2(iobuf_pool, req_size + align_size);
+    if (!iobuf)
+        return NULL;
+    /* If std allocation was used, then free_ptr will be non-NULL. In this
+     * case, we do not want to modify the original free_ptr.
+     * On the other hand, if the buf was gotten through the available
+     * arenas, then we use iobuf->free_ptr to store the original
+     * pointer to the offset into the mmap'd block of memory and in turn
+     * reuse iobuf->ptr to hold the page-aligned address. And finally, in
+     * iobuf_put(), we copy iobuf->free_ptr into iobuf->ptr - back to where
+     * it was originally when __iobuf_get() returned this iobuf.
+     */
+    if (!iobuf->free_ptr)
+        iobuf->free_ptr = iobuf->ptr;
+    iobuf->ptr = GF_ALIGN_BUF(iobuf->ptr, align_size);
+
+    return iobuf;
 }
 
 struct iobuf *
-iobuf_get (struct iobuf_pool *iobuf_pool)
+iobuf_get(struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf       *iobuf        = NULL;
-        struct iobuf_arena *iobuf_arena  = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                /* most eligible arena for picking an iobuf */
-                iobuf_arena = __iobuf_select_arena (iobuf_pool,
-                                                    iobuf_pool->default_page_size);
-                if (!iobuf_arena) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_ARENA_NOT_FOUND, "arena not found");
-                        goto unlock;
-                }
-
-                iobuf = __iobuf_get (iobuf_arena,
-                                     iobuf_pool->default_page_size);
-                if (!iobuf) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_IOBUF_NOT_FOUND, "iobuf not found");
-                        goto unlock;
-                }
-
-                iobuf_ref (iobuf);
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        /* most eligible arena for picking an iobuf */
+        iobuf_arena = __iobuf_select_arena(iobuf_pool,
+                                           iobuf_pool->default_page_size);
+        if (!iobuf_arena) {
+            gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
+                   "arena not found");
+            goto unlock;
+        }
+
+        iobuf = __iobuf_get(iobuf_arena, iobuf_pool->default_page_size);
+        if (!iobuf) {
+            gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_IOBUF_NOT_FOUND,
+                   "iobuf not found");
+            goto unlock;
         }
+
+        iobuf_ref(iobuf);
+    }
 unlock:
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return iobuf;
+    return iobuf;
 }
 
 void
-__iobuf_put (struct iobuf *iobuf, struct iobuf_arena *iobuf_arena)
+__iobuf_put(struct iobuf *iobuf, struct iobuf_arena *iobuf_arena)
 {
-        struct iobuf_pool *iobuf_pool = NULL;
-        int                index      = 0;
+    struct iobuf_pool *iobuf_pool = NULL;
+    int index = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        iobuf_pool = iobuf_arena->iobuf_pool;
+    iobuf_pool = iobuf_arena->iobuf_pool;
 
-        index = gf_iobuf_get_arena_index (iobuf_arena->page_size);
-        if (index == -1) {
-                gf_msg_debug ("iobuf", 0, "freeing the iobuf (%p) "
-                        "allocated with standard calloc()", iobuf);
-
-                /* free up properly without bothering about lists and all */
-                LOCK_DESTROY (&iobuf->lock);
-                GF_FREE (iobuf->free_ptr);
-                GF_FREE (iobuf);
-                return;
-        }
+    index = gf_iobuf_get_arena_index(iobuf_arena->page_size);
+    if (index == -1) {
+        gf_msg_debug("iobuf", 0,
+                     "freeing the iobuf (%p) "
+                     "allocated with standard calloc()",
+                     iobuf);
 
-        if (iobuf_arena->passive_cnt == 0) {
-                list_del (&iobuf_arena->list);
-                list_add_tail (&iobuf_arena->list, &iobuf_pool->arenas[index]);
-        }
+        /* free up properly without bothering about lists and all */
+        LOCK_DESTROY(&iobuf->lock);
+        GF_FREE(iobuf->free_ptr);
+        GF_FREE(iobuf);
+        return;
+    }
 
-        list_del_init (&iobuf->list);
-        iobuf_arena->active_cnt--;
+    if (iobuf_arena->passive_cnt == 0) {
+        list_del(&iobuf_arena->list);
+        list_add_tail(&iobuf_arena->list, &iobuf_pool->arenas[index]);
+    }
 
-        if (iobuf->free_ptr) {
-                iobuf->ptr = iobuf->free_ptr;
-                iobuf->free_ptr = NULL;
-        }
+    list_del_init(&iobuf->list);
+    iobuf_arena->active_cnt--;
 
-        list_add (&iobuf->list, &iobuf_arena->passive.list);
-        iobuf_arena->passive_cnt++;
+    if (iobuf->free_ptr) {
+        iobuf->ptr = iobuf->free_ptr;
+        iobuf->free_ptr = NULL;
+    }
 
-        if (iobuf_arena->active_cnt == 0) {
-                list_del (&iobuf_arena->list);
-                list_add_tail (&iobuf_arena->list, &iobuf_pool->purge[index]);
-                __iobuf_arena_prune (iobuf_pool, iobuf_arena, index);
-        }
+    list_add(&iobuf->list, &iobuf_arena->passive.list);
+    iobuf_arena->passive_cnt++;
+
+    if (iobuf_arena->active_cnt == 0) {
+        list_del(&iobuf_arena->list);
+        list_add_tail(&iobuf_arena->list, &iobuf_pool->purge[index]);
+        __iobuf_arena_prune(iobuf_pool, iobuf_arena, index);
+    }
 out:
-        return;
+    return;
 }
 
-
 void
-iobuf_put (struct iobuf *iobuf)
+iobuf_put(struct iobuf *iobuf)
 {
-        struct iobuf_arena *iobuf_arena = NULL;
-        struct iobuf_pool  *iobuf_pool = NULL;
+    struct iobuf_arena *iobuf_arena = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        iobuf_arena = iobuf->iobuf_arena;
-        if (!iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                return;
-        }
+    iobuf_arena = iobuf->iobuf_arena;
+    if (!iobuf_arena) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
+               "arena not found");
+        return;
+    }
 
-        iobuf_pool = iobuf_arena->iobuf_pool;
-        if (!iobuf_pool) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                        LG_MSG_POOL_NOT_FOUND, "iobuf pool not found");
-                return;
-        }
+    iobuf_pool = iobuf_arena->iobuf_pool;
+    if (!iobuf_pool) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND,
+               "iobuf pool not found");
+        return;
+    }
 
-        pthread_mutex_lock (&iobuf_pool->mutex);
-        {
-                __iobuf_put (iobuf, iobuf_arena);
-        }
-        pthread_mutex_unlock (&iobuf_pool->mutex);
+    pthread_mutex_lock(&iobuf_pool->mutex);
+    {
+        __iobuf_put(iobuf, iobuf_arena);
+    }
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobuf_unref (struct iobuf *iobuf)
+iobuf_unref(struct iobuf *iobuf)
 {
-        int  ref = 0;
+    int ref = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        ref = GF_ATOMIC_DEC (iobuf->ref);
+    ref = GF_ATOMIC_DEC(iobuf->ref);
 
-        if (!ref)
-                iobuf_put (iobuf);
+    if (!ref)
+        iobuf_put(iobuf);
 
 out:
-        return;
+    return;
 }
 
-
 struct iobuf *
-iobuf_ref (struct iobuf *iobuf)
+iobuf_ref(struct iobuf *iobuf)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
-        GF_ATOMIC_INC (iobuf->ref);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
+    GF_ATOMIC_INC(iobuf->ref);
 
 out:
-        return iobuf;
+    return iobuf;
 }
 
-
 struct iobref *
-iobref_new ()
+iobref_new()
 {
-        struct iobref *iobref = NULL;
+    struct iobref *iobref = NULL;
 
-        iobref = GF_MALLOC (sizeof (*iobref), gf_common_mt_iobref);
-        if (!iobref)
-                return NULL;
+    iobref = GF_MALLOC(sizeof(*iobref), gf_common_mt_iobref);
+    if (!iobref)
+        return NULL;
 
-	iobref->iobrefs = GF_CALLOC (sizeof (*iobref->iobrefs),
-				     16, gf_common_mt_iobrefs);
-	if (!iobref->iobrefs) {
-		GF_FREE (iobref);
-		return NULL;
-	}
+    iobref->iobrefs = GF_CALLOC(sizeof(*iobref->iobrefs), 16,
+                                gf_common_mt_iobrefs);
+    if (!iobref->iobrefs) {
+        GF_FREE(iobref);
+        return NULL;
+    }
 
-	iobref->allocated = 16;
-	iobref->used = 0;
+    iobref->allocated = 16;
+    iobref->used = 0;
 
-        LOCK_INIT (&iobref->lock);
+    LOCK_INIT(&iobref->lock);
 
-        GF_ATOMIC_INIT (iobref->ref, 1);
-        return iobref;
+    GF_ATOMIC_INIT(iobref->ref, 1);
+    return iobref;
 }
 
-
 struct iobref *
-iobref_ref (struct iobref *iobref)
+iobref_ref(struct iobref *iobref)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        GF_ATOMIC_INC (iobref->ref);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_ATOMIC_INC(iobref->ref);
 
 out:
-        return iobref;
+    return iobref;
 }
 
-
 void
-iobref_destroy (struct iobref *iobref)
+iobref_destroy(struct iobref *iobref)
 {
-        int            i = 0;
-        struct iobuf  *iobuf = NULL;
+    int i = 0;
+    struct iobuf *iobuf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        for (i = 0; i < iobref->allocated; i++) {
-                iobuf = iobref->iobrefs[i];
+    for (i = 0; i < iobref->allocated; i++) {
+        iobuf = iobref->iobrefs[i];
 
-                iobref->iobrefs[i] = NULL;
-                if (iobuf)
-                        iobuf_unref (iobuf);
-        }
+        iobref->iobrefs[i] = NULL;
+        if (iobuf)
+            iobuf_unref(iobuf);
+    }
 
-	GF_FREE (iobref->iobrefs);
-        GF_FREE (iobref);
+    GF_FREE(iobref->iobrefs);
+    GF_FREE(iobref);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobref_unref (struct iobref *iobref)
+iobref_unref(struct iobref *iobref)
 {
-        int ref = 0;
+    int ref = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        ref = GF_ATOMIC_DEC (iobref->ref);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    ref = GF_ATOMIC_DEC(iobref->ref);
 
-        if (!ref)
-                iobref_destroy (iobref);
+    if (!ref)
+        iobref_destroy(iobref);
 
 out:
-        return;
+    return;
 }
 
-
 void
-iobref_clear (struct iobref *iobref)
+iobref_clear(struct iobref *iobref)
 {
-        int i = 0;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        for (; i < iobref->allocated; i++) {
-                if (iobref->iobrefs[i] != NULL) {
-                        iobuf_unref (iobref->iobrefs[i]);
-                } else {
-                        /** iobuf's are attached serially */
-                        break;
-                }
+    for (; i < iobref->allocated; i++) {
+        if (iobref->iobrefs[i] != NULL) {
+            iobuf_unref(iobref->iobrefs[i]);
+        } else {
+            /** iobuf's are attached serially */
+            break;
         }
+    }
 
-        iobref_unref (iobref);
+    iobref_unref(iobref);
 
- out:
-        return;
+out:
+    return;
 }
 
-
 static void
-__iobref_grow (struct iobref *iobref)
+__iobref_grow(struct iobref *iobref)
 {
-	void *newptr = NULL;
-	int i = 0;
-
-	newptr = GF_REALLOC (iobref->iobrefs,
-			     iobref->allocated * 2 * (sizeof (*iobref->iobrefs)));
-	if (newptr) {
-		iobref->iobrefs = newptr;
-		iobref->allocated *= 2;
-
-		for (i = iobref->used; i < iobref->allocated; i++)
-			iobref->iobrefs[i] = NULL;
-	}
+    void *newptr = NULL;
+    int i = 0;
+
+    newptr = GF_REALLOC(iobref->iobrefs,
+                        iobref->allocated * 2 * (sizeof(*iobref->iobrefs)));
+    if (newptr) {
+        iobref->iobrefs = newptr;
+        iobref->allocated *= 2;
+
+        for (i = iobref->used; i < iobref->allocated; i++)
+            iobref->iobrefs[i] = NULL;
+    }
 }
 
-
 int
-__iobref_add (struct iobref *iobref, struct iobuf *iobuf)
+__iobref_add(struct iobref *iobref, struct iobuf *iobuf)
 {
-        int  i = 0;
-        int  ret = -ENOMEM;
+    int i = 0;
+    int ret = -ENOMEM;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-	if (iobref->used == iobref->allocated) {
-		__iobref_grow (iobref);
+    if (iobref->used == iobref->allocated) {
+        __iobref_grow(iobref);
 
-		if (iobref->used == iobref->allocated) {
-			ret = -ENOMEM;
-			goto out;
-		}
-	}
-
-        for (i = 0; i < iobref->allocated; i++) {
-                if (iobref->iobrefs[i] == NULL) {
-                        iobref->iobrefs[i] = iobuf_ref (iobuf);
-			iobref->used++;
-                        ret = 0;
-                        break;
-                }
+        if (iobref->used == iobref->allocated) {
+            ret = -ENOMEM;
+            goto out;
+        }
+    }
+
+    for (i = 0; i < iobref->allocated; i++) {
+        if (iobref->iobrefs[i] == NULL) {
+            iobref->iobrefs[i] = iobuf_ref(iobuf);
+            iobref->used++;
+            ret = 0;
+            break;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-iobref_add (struct iobref *iobref, struct iobuf *iobuf)
+iobref_add(struct iobref *iobref, struct iobuf *iobuf)
 {
-        int  ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        LOCK (&iobref->lock);
-        {
-                ret = __iobref_add (iobref, iobuf);
-        }
-        UNLOCK (&iobref->lock);
+    LOCK(&iobref->lock);
+    {
+        ret = __iobref_add(iobref, iobuf);
+    }
+    UNLOCK(&iobref->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-iobref_merge (struct iobref *to, struct iobref *from)
+iobref_merge(struct iobref *to, struct iobref *from)
 {
-        int           i = 0;
-        int           ret = 0;
-        struct iobuf *iobuf = NULL;
+    int i = 0;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", to, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", from, out);
+    GF_VALIDATE_OR_GOTO("iobuf", to, out);
+    GF_VALIDATE_OR_GOTO("iobuf", from, out);
 
-        LOCK (&from->lock);
-        {
-                for (i = 0; i < from->allocated; i++) {
-                        iobuf = from->iobrefs[i];
+    LOCK(&from->lock);
+    {
+        for (i = 0; i < from->allocated; i++) {
+            iobuf = from->iobrefs[i];
 
-                        if (!iobuf)
-                                break;
+            if (!iobuf)
+                break;
 
-                        ret = iobref_add (to, iobuf);
+            ret = iobref_add(to, iobuf);
 
-                        if (ret < 0)
-                                break;
-                }
+            if (ret < 0)
+                break;
         }
-        UNLOCK (&from->lock);
+    }
+    UNLOCK(&from->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 size_t
-iobuf_size (struct iobuf *iobuf)
+iobuf_size(struct iobuf *iobuf)
 {
-        size_t size = 0;
+    size_t size = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        if (!iobuf->iobuf_arena) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
-                        "arena not found");
-                goto out;
-        }
+    if (!iobuf->iobuf_arena) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_ARENA_NOT_FOUND,
+               "arena not found");
+        goto out;
+    }
 
-        if (!iobuf->iobuf_arena->iobuf_pool) {
-                gf_msg (THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND,
-                        "pool not found");
-                goto out;
-        }
+    if (!iobuf->iobuf_arena->iobuf_pool) {
+        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_POOL_NOT_FOUND,
+               "pool not found");
+        goto out;
+    }
 
-        size = iobuf->iobuf_arena->page_size;
+    size = iobuf->iobuf_arena->page_size;
 out:
-        return size;
+    return size;
 }
 
-
 size_t
-iobref_size (struct iobref *iobref)
+iobref_size(struct iobref *iobref)
 {
-        size_t size = 0;
-        int    i = 0;
+    size_t size = 0;
+    int i = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobref, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobref, out);
 
-        LOCK (&iobref->lock);
-        {
-                for (i = 0; i < iobref->allocated; i++) {
-                        if (iobref->iobrefs[i])
-                                size += iobuf_size (iobref->iobrefs[i]);
-                }
+    LOCK(&iobref->lock);
+    {
+        for (i = 0; i < iobref->allocated; i++) {
+            if (iobref->iobrefs[i])
+                size += iobuf_size(iobref->iobrefs[i]);
         }
-        UNLOCK (&iobref->lock);
+    }
+    UNLOCK(&iobref->lock);
 
 out:
-        return size;
+    return size;
 }
 
 void
-iobuf_info_dump (struct iobuf *iobuf, const char *key_prefix)
+iobuf_info_dump(struct iobuf *iobuf, const char *key_prefix)
 {
-        char   key[GF_DUMP_MAX_BUF_LEN];
-        struct iobuf my_iobuf;
-        int    ret = 0;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    struct iobuf my_iobuf;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf, out);
 
-        ret = TRY_LOCK(&iobuf->lock);
-        if (ret) {
-                return;
-        }
-        memcpy(&my_iobuf, iobuf, sizeof(my_iobuf));
-        UNLOCK(&iobuf->lock);
+    ret = TRY_LOCK(&iobuf->lock);
+    if (ret) {
+        return;
+    }
+    memcpy(&my_iobuf, iobuf, sizeof(my_iobuf));
+    UNLOCK(&iobuf->lock);
 
-        gf_proc_dump_build_key(key, key_prefix,"ref");
-        gf_proc_dump_write(key, "%d", my_iobuf.ref);
-        gf_proc_dump_build_key(key, key_prefix,"ptr");
-        gf_proc_dump_write(key, "%p", my_iobuf.ptr);
+    gf_proc_dump_build_key(key, key_prefix, "ref");
+    gf_proc_dump_write(key, "%d", my_iobuf.ref);
+    gf_proc_dump_build_key(key, key_prefix, "ptr");
+    gf_proc_dump_write(key, "%p", my_iobuf.ptr);
 
 out:
-        return;
+    return;
 }
 
 void
-iobuf_arena_info_dump (struct iobuf_arena *iobuf_arena, const char *key_prefix)
+iobuf_arena_info_dump(struct iobuf_arena *iobuf_arena, const char *key_prefix)
 {
-        char key[GF_DUMP_MAX_BUF_LEN];
-        int  i = 1;
-        struct iobuf *trav;
-
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_arena, out);
-
-        gf_proc_dump_build_key(key, key_prefix,"mem_base");
-        gf_proc_dump_write(key, "%p", iobuf_arena->mem_base);
-        gf_proc_dump_build_key(key, key_prefix, "active_cnt");
-        gf_proc_dump_write(key, "%d", iobuf_arena->active_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "passive_cnt");
-        gf_proc_dump_write(key, "%d", iobuf_arena->passive_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "alloc_cnt");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->alloc_cnt);
-        gf_proc_dump_build_key(key, key_prefix, "max_active");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->max_active);
-        gf_proc_dump_build_key(key, key_prefix, "page_size");
-        gf_proc_dump_write(key, "%"PRIu64, iobuf_arena->page_size);
-        list_for_each_entry (trav, &iobuf_arena->active.list, list) {
-                gf_proc_dump_build_key(key, key_prefix,"active_iobuf.%d", i++);
-                gf_proc_dump_add_section(key);
-                iobuf_info_dump(trav, key);
-        }
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 1;
+    struct iobuf *trav;
+
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_arena, out);
+
+    gf_proc_dump_build_key(key, key_prefix, "mem_base");
+    gf_proc_dump_write(key, "%p", iobuf_arena->mem_base);
+    gf_proc_dump_build_key(key, key_prefix, "active_cnt");
+    gf_proc_dump_write(key, "%d", iobuf_arena->active_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "passive_cnt");
+    gf_proc_dump_write(key, "%d", iobuf_arena->passive_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "alloc_cnt");
+    gf_proc_dump_write(key, "%" PRIu64, iobuf_arena->alloc_cnt);
+    gf_proc_dump_build_key(key, key_prefix, "max_active");
+    gf_proc_dump_write(key, "%" PRIu64, iobuf_arena->max_active);
+    gf_proc_dump_build_key(key, key_prefix, "page_size");
+    gf_proc_dump_write(key, "%" PRIu64, iobuf_arena->page_size);
+    list_for_each_entry(trav, &iobuf_arena->active.list, list)
+    {
+        gf_proc_dump_build_key(key, key_prefix, "active_iobuf.%d", i++);
+        gf_proc_dump_add_section(key);
+        iobuf_info_dump(trav, key);
+    }
 
 out:
-        return;
+    return;
 }
 
 void
-iobuf_stats_dump (struct iobuf_pool *iobuf_pool)
+iobuf_stats_dump(struct iobuf_pool *iobuf_pool)
 {
-        char               msg[1024];
-        struct iobuf_arena *trav = NULL;
-        int                i = 1;
-        int                j = 0;
-        int                ret = -1;
+    char msg[1024];
+    struct iobuf_arena *trav = NULL;
+    int i = 1;
+    int j = 0;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("iobuf", iobuf_pool, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iobuf_pool, out);
 
-        ret = pthread_mutex_trylock(&iobuf_pool->mutex);
+    ret = pthread_mutex_trylock(&iobuf_pool->mutex);
 
-        if (ret) {
-                return;
+    if (ret) {
+        return;
+    }
+    gf_proc_dump_add_section("iobuf.global");
+    gf_proc_dump_write("iobuf_pool", "%p", iobuf_pool);
+    gf_proc_dump_write("iobuf_pool.default_page_size", "%d",
+                       iobuf_pool->default_page_size);
+    gf_proc_dump_write("iobuf_pool.arena_size", "%d", iobuf_pool->arena_size);
+    gf_proc_dump_write("iobuf_pool.arena_cnt", "%d", iobuf_pool->arena_cnt);
+    gf_proc_dump_write("iobuf_pool.request_misses", "%" PRId64,
+                       iobuf_pool->request_misses);
+
+    for (j = 0; j < IOBUF_ARENA_MAX_INDEX; j++) {
+        list_for_each_entry(trav, &iobuf_pool->arenas[j], list)
+        {
+            snprintf(msg, sizeof(msg), "arena.%d", i);
+            gf_proc_dump_add_section(msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
         }
-        gf_proc_dump_add_section("iobuf.global");
-        gf_proc_dump_write("iobuf_pool","%p", iobuf_pool);
-        gf_proc_dump_write("iobuf_pool.default_page_size", "%d",
-                                                iobuf_pool->default_page_size);
-        gf_proc_dump_write("iobuf_pool.arena_size", "%d",
-                           iobuf_pool->arena_size);
-        gf_proc_dump_write("iobuf_pool.arena_cnt", "%d",
-                           iobuf_pool->arena_cnt);
-        gf_proc_dump_write("iobuf_pool.request_misses", "%"PRId64,
-                           iobuf_pool->request_misses);
-
-        for (j = 0; j < IOBUF_ARENA_MAX_INDEX; j++) {
-                list_for_each_entry (trav, &iobuf_pool->arenas[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "arena.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-                list_for_each_entry (trav, &iobuf_pool->purge[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "purge.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-                list_for_each_entry (trav, &iobuf_pool->filled[j], list) {
-                        snprintf(msg, sizeof(msg),
-                                 "filled.%d", i);
-                        gf_proc_dump_add_section(msg);
-                        iobuf_arena_info_dump(trav,msg);
-                        i++;
-                }
-
+        list_for_each_entry(trav, &iobuf_pool->purge[j], list)
+        {
+            snprintf(msg, sizeof(msg), "purge.%d", i);
+            gf_proc_dump_add_section(msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
+        }
+        list_for_each_entry(trav, &iobuf_pool->filled[j], list)
+        {
+            snprintf(msg, sizeof(msg), "filled.%d", i);
+            gf_proc_dump_add_section(msg);
+            iobuf_arena_info_dump(trav, msg);
+            i++;
         }
+    }
 
-        pthread_mutex_unlock(&iobuf_pool->mutex);
+    pthread_mutex_unlock(&iobuf_pool->mutex);
 
 out:
-        return;
+    return;
 }
 
-
 void
 iobuf_to_iovec(struct iobuf *iob, struct iovec *iov)
 {
-        GF_VALIDATE_OR_GOTO ("iobuf", iob, out);
-        GF_VALIDATE_OR_GOTO ("iobuf", iov, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iob, out);
+    GF_VALIDATE_OR_GOTO("iobuf", iov, out);
 
-        iov->iov_base = iobuf_ptr (iob);
-        iov->iov_len =  iobuf_pagesize (iob);
+    iov->iov_base = iobuf_ptr(iob);
+    iov->iov_len = iobuf_pagesize(iob);
 
 out:
-        return;
+    return;
 }
 
 int
-iobuf_copy (struct iobuf_pool *iobuf_pool, const struct iovec *iovec_src,
-            int iovcnt, struct iobref **iobref, struct iobuf **iobuf,
-            struct iovec *iov_dst)
+iobuf_copy(struct iobuf_pool *iobuf_pool, const struct iovec *iovec_src,
+           int iovcnt, struct iobref **iobref, struct iobuf **iobuf,
+           struct iovec *iov_dst)
 {
-        size_t         size = -1;
-        int            ret  = 0;
-
-        size = iov_length (iovec_src, iovcnt);
-
-        *iobuf = iobuf_get2 (iobuf_pool, size);
-        if (!(*iobuf)) {
-                ret = -1;
-                errno = ENOMEM;
-                goto out;
-        }
-
-        *iobref = iobref_new ();
-        if (!(*iobref)) {
-                iobuf_unref (*iobuf);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        ret = iobref_add (*iobref, *iobuf);
-        if (ret) {
-                iobuf_unref (*iobuf);
-                iobref_unref (*iobref);
-                errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-
-        iov_unload (iobuf_ptr (*iobuf), iovec_src, iovcnt);
-
-        iov_dst->iov_base = iobuf_ptr (*iobuf);
-        iov_dst->iov_len = size;
+    size_t size = -1;
+    int ret = 0;
+
+    size = iov_length(iovec_src, iovcnt);
+
+    *iobuf = iobuf_get2(iobuf_pool, size);
+    if (!(*iobuf)) {
+        ret = -1;
+        errno = ENOMEM;
+        goto out;
+    }
+
+    *iobref = iobref_new();
+    if (!(*iobref)) {
+        iobuf_unref(*iobuf);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = iobref_add(*iobref, *iobuf);
+    if (ret) {
+        iobuf_unref(*iobuf);
+        iobref_unref(*iobref);
+        errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    iov_unload(iobuf_ptr(*iobuf), iovec_src, iovcnt);
+
+    iov_dst->iov_base = iobuf_ptr(*iobuf);
+    iov_dst->iov_len = size;
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/libglusterfs/src/latency.c b/libglusterfs/src/latency.c
index fb3b155caa6..2dc2a318216 100644
--- a/libglusterfs/src/latency.c
+++ b/libglusterfs/src/latency.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /*
  * This file contains functions to support dumping of
  * latencies of FOPs broken down by subvolumes.
@@ -21,82 +20,77 @@
 #include "libglusterfs-messages.h"
 
 void
-gf_update_latency (call_frame_t *frame)
+gf_update_latency(call_frame_t *frame)
 {
-        double elapsed;
-        struct timespec *begin, *end;
+    double elapsed;
+    struct timespec *begin, *end;
 
-        fop_latency_t *lat;
+    fop_latency_t *lat;
 
-        begin = &frame->begin;
-        end   = &frame->end;
+    begin = &frame->begin;
+    end = &frame->end;
 
-        if (!(begin->tv_sec && end->tv_sec))
-                goto out;
+    if (!(begin->tv_sec && end->tv_sec))
+        goto out;
 
-        elapsed = (end->tv_sec - begin->tv_sec) * 1e9
-                + (end->tv_nsec - begin->tv_nsec);
+    elapsed = (end->tv_sec - begin->tv_sec) * 1e9 +
+              (end->tv_nsec - begin->tv_nsec);
 
-        if (frame->op < 0 || frame->op >= GF_FOP_MAXVALUE) {
-                gf_log ("[core]", GF_LOG_WARNING,
-                        "Invalid frame op value: %d",
-                        frame->op);
-                return;
-        }
+    if (frame->op < 0 || frame->op >= GF_FOP_MAXVALUE) {
+        gf_log("[core]", GF_LOG_WARNING, "Invalid frame op value: %d",
+               frame->op);
+        return;
+    }
 
-        /* Can happen mostly at initiator xlator, as STACK_WIND/UNWIND macros
-           set it right anyways for those frames */
-        if (!frame->op)
-                frame->op = frame->root->op;
+    /* Can happen mostly at initiator xlator, as STACK_WIND/UNWIND macros
+       set it right anyways for those frames */
+    if (!frame->op)
+        frame->op = frame->root->op;
 
-        lat = &frame->this->stats.interval.latencies[frame->op];
+    lat = &frame->this->stats.interval.latencies[frame->op];
 
-        if (lat->max < elapsed)
-                lat->max = elapsed;
+    if (lat->max < elapsed)
+        lat->max = elapsed;
 
-        if (lat->min > elapsed)
-                lat->min = elapsed;
+    if (lat->min > elapsed)
+        lat->min = elapsed;
 
-        lat->total += elapsed;
-        lat->count++;
+    lat->total += elapsed;
+    lat->count++;
 out:
-        return;
+    return;
 }
 
-
 void
-gf_proc_dump_latency_info (xlator_t *xl)
+gf_proc_dump_latency_info(xlator_t *xl)
 {
-        char key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char key[GF_DUMP_MAX_BUF_LEN];
-        int i;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i;
 
-        snprintf (key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.latency", xl->name);
-        gf_proc_dump_add_section (key_prefix);
+    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.latency", xl->name);
+    gf_proc_dump_add_section(key_prefix);
 
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                gf_proc_dump_build_key (key, key_prefix, "%s",
-                                        (char *)gf_fop_list[i]);
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        gf_proc_dump_build_key(key, key_prefix, "%s", (char *)gf_fop_list[i]);
 
-                fop_latency_t *lat = &xl->stats.interval.latencies[i];
+        fop_latency_t *lat = &xl->stats.interval.latencies[i];
 
-                /* Doesn't make sense to continue if there are no fops
-                   came in the given interval */
-                if (!lat->count)
-                        continue;
+        /* Doesn't make sense to continue if there are no fops
+           came in the given interval */
+        if (!lat->count)
+            continue;
 
-                gf_proc_dump_write (key, "%.03f,%"PRId64",%.03f",
-                                    (lat->total / lat->count), lat->count,
-                                    lat->total);
-        }
+        gf_proc_dump_write(key, "%.03f,%" PRId64 ",%.03f",
+                           (lat->total / lat->count), lat->count, lat->total);
+    }
 
-        memset (xl->stats.interval.latencies, 0,
-                sizeof (xl->stats.interval.latencies));
+    memset(xl->stats.interval.latencies, 0,
+           sizeof(xl->stats.interval.latencies));
 
-        /* make sure 'min' is set to high value, so it would be
-           properly set later */
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                xl->stats.interval.latencies[i].min = 0xffffffff;
-        }
+    /* make sure 'min' is set to high value, so it would be
+       properly set later */
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        xl->stats.interval.latencies[i].min = 0xffffffff;
+    }
 }
-
diff --git a/libglusterfs/src/locking.c b/libglusterfs/src/locking.c
index f27b0d05b35..89cbaa00c8b 100644
--- a/libglusterfs/src/locking.c
+++ b/libglusterfs/src/locking.c
@@ -19,10 +19,9 @@
 
 int use_spinlocks = 0;
 
-static void __attribute__((constructor))
-gf_lock_setup (void)
+static void __attribute__((constructor)) gf_lock_setup(void)
 {
-        //use_spinlocks = (sysconf(_SC_NPROCESSORS_ONLN) > 1);
+    // use_spinlocks = (sysconf(_SC_NPROCESSORS_ONLN) > 1);
 }
 
 #endif
diff --git a/libglusterfs/src/logging.c b/libglusterfs/src/logging.c
index a46cb234b72..61909ef4dae 100644
--- a/libglusterfs/src/logging.c
+++ b/libglusterfs/src/logging.c
@@ -28,14 +28,14 @@
 
 #include "syscall.h"
 
-#define GF_JSON_MSG_LENGTH      8192
-#define GF_SYSLOG_CEE_FORMAT    \
-        "@cee: {\"msg\": \"%s\", \"gf_code\": \"%u\", \"gf_message\": \"%s\"}"
-#define GF_LOG_CONTROL_FILE     "/etc/glusterfs/logger.conf"
-#define GF_LOG_BACKTRACE_DEPTH  5
-#define GF_LOG_BACKTRACE_SIZE   4096
-#define GF_LOG_TIMESTR_SIZE     256
-#define GF_MAX_SLOG_PAIR_COUNT  100
+#define GF_JSON_MSG_LENGTH 8192
+#define GF_SYSLOG_CEE_FORMAT                                                   \
+    "@cee: {\"msg\": \"%s\", \"gf_code\": \"%u\", \"gf_message\": \"%s\"}"
+#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf"
+#define GF_LOG_BACKTRACE_DEPTH 5
+#define GF_LOG_BACKTRACE_SIZE 4096
+#define GF_LOG_TIMESTR_SIZE 256
+#define GF_MAX_SLOG_PAIR_COUNT 100
 
 #include "xlator.h"
 #include "logging.h"
@@ -46,147 +46,146 @@
 
 /* Do not replace gf_log in TEST_LOG with gf_msg, as there is a slight chance
  * that it could lead to an infinite recursion.*/
-#define TEST_LOG(__msg, __args ...)                             \
-                gf_log ("logging-infra", GF_LOG_DEBUG, __msg, ##__args);
+#define TEST_LOG(__msg, __args...)                                             \
+    gf_log("logging-infra", GF_LOG_DEBUG, __msg, ##__args);
 
 void
-gf_log_flush_timeout_cbk (void *data);
+gf_log_flush_timeout_cbk(void *data);
 
 int
-gf_log_inject_timer_event (glusterfs_ctx_t *ctx);
+gf_log_inject_timer_event(glusterfs_ctx_t *ctx);
 
 static void
-gf_log_flush_extra_msgs (glusterfs_ctx_t *ctx, uint32_t new);
+gf_log_flush_extra_msgs(glusterfs_ctx_t *ctx, uint32_t new);
 
 static char *gf_level_strings[] = {"",  /* NONE */
-                "M", /* EMERGENCY */
-                "A", /* ALERT */
-                "C", /* CRITICAL */
-                "E", /* ERROR */
-                "W", /* WARNING */
-                "N", /* NOTICE */
-                "I", /* INFO */
-                "D", /* DEBUG */
-                "T", /* TRACE */
-                ""
-};
+                                   "M", /* EMERGENCY */
+                                   "A", /* ALERT */
+                                   "C", /* CRITICAL */
+                                   "E", /* ERROR */
+                                   "W", /* WARNING */
+                                   "N", /* NOTICE */
+                                   "I", /* INFO */
+                                   "D", /* DEBUG */
+                                   "T", /* TRACE */
+                                   ""};
 
 /* Ideally this should get moved to logging.h */
 struct _msg_queue {
-        struct list_head msgs;
+    struct list_head msgs;
 };
 
 struct _log_msg {
-        const char *msg;
-        struct list_head queue;
+    const char *msg;
+    struct list_head queue;
 };
 
 void
-gf_log_logrotate (int signum)
+gf_log_logrotate(int signum)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx) {
-                ctx->log.logrotate = 1;
-                ctx->log.cmd_history_logrotate = 1;
-        }
+    if (ctx) {
+        ctx->log.logrotate = 1;
+        ctx->log.cmd_history_logrotate = 1;
+    }
 }
 
 void
-gf_log_enable_syslog (void)
+gf_log_enable_syslog(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.gf_log_syslog = 1;
+    if (ctx)
+        ctx->log.gf_log_syslog = 1;
 }
 
 void
-gf_log_disable_syslog (void)
+gf_log_disable_syslog(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.gf_log_syslog = 0;
+    if (ctx)
+        ctx->log.gf_log_syslog = 0;
 }
 
 gf_loglevel_t
-gf_log_get_loglevel (void)
+gf_log_get_loglevel(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                return ctx->log.loglevel;
-        else
-                /* return global defaults (see gf_log_globals_init) */
-                return GF_LOG_INFO;
+    if (ctx)
+        return ctx->log.loglevel;
+    else
+        /* return global defaults (see gf_log_globals_init) */
+        return GF_LOG_INFO;
 }
 
 void
-gf_log_set_loglevel (glusterfs_ctx_t *ctx, gf_loglevel_t level)
+gf_log_set_loglevel(glusterfs_ctx_t *ctx, gf_loglevel_t level)
 {
-        if (ctx)
-                ctx->log.loglevel = level;
+    if (ctx)
+        ctx->log.loglevel = level;
 }
 
 int
-gf_log_get_localtime (void)
+gf_log_get_localtime(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                return ctx->log.localtime;
-        else
-                /* return global defaults (see gf_log_globals_init) */
-                return 0;
+    if (ctx)
+        return ctx->log.localtime;
+    else
+        /* return global defaults (see gf_log_globals_init) */
+        return 0;
 }
 
 void
-gf_log_set_localtime (int on_off)
+gf_log_set_localtime(int on_off)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.localtime = on_off;
+    if (ctx)
+        ctx->log.localtime = on_off;
 }
 
 void
-gf_log_flush (void)
+gf_log_flush(void)
 {
-        xlator_t        *this           = NULL;
-        glusterfs_ctx_t *ctx            = NULL;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (ctx && ctx->log.logger == gf_logger_glusterlog) {
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                fflush (ctx->log.gf_log_logfile);
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        }
+    if (ctx && ctx->log.logger == gf_logger_glusterlog) {
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        fflush(ctx->log.gf_log_logfile);
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    }
 
-        return;
+    return;
 }
 
 void
-gf_log_set_xl_loglevel (void *this, gf_loglevel_t level)
+gf_log_set_xl_loglevel(void *this, gf_loglevel_t level)
 {
-        xlator_t *xl = this;
-        if (!xl)
-                return;
-        xl->loglevel = level;
+    xlator_t *xl = this;
+    if (!xl)
+        return;
+    xl->loglevel = level;
 }
 
 /* TODO: The following get/set functions are yet not invoked from anywhere
@@ -207,104 +206,104 @@ gf_log_set_xl_loglevel (void *this, gf_loglevel_t level)
  * care needs to be taken to configure and start daemons based on the versions
  * that supports these features */
 gf_log_format_t
-gf_log_get_logformat (void)
+gf_log_get_logformat(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                return ctx->log.logformat;
-        else
-                /* return global defaluts (see gf_log_globals_init) */
-                return gf_logformat_withmsgid;
+    if (ctx)
+        return ctx->log.logformat;
+    else
+        /* return global defaluts (see gf_log_globals_init) */
+        return gf_logformat_withmsgid;
 }
 
 void
-gf_log_set_logformat (gf_log_format_t format)
+gf_log_set_logformat(gf_log_format_t format)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.logformat = format;
+    if (ctx)
+        ctx->log.logformat = format;
 }
 
 gf_log_logger_t
-gf_log_get_logger (void)
+gf_log_get_logger(void)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                return ctx->log.logger;
-        else
-                /* return global defaluts (see gf_log_globals_init) */
-                return gf_logger_glusterlog;
+    if (ctx)
+        return ctx->log.logger;
+    else
+        /* return global defaluts (see gf_log_globals_init) */
+        return gf_logger_glusterlog;
 }
 
 void
-gf_log_set_logger (gf_log_logger_t logger)
+gf_log_set_logger(gf_log_logger_t logger)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.logger = logger;
+    if (ctx)
+        ctx->log.logger = logger;
 }
 
 gf_loglevel_t
-gf_log_get_xl_loglevel (void *this)
+gf_log_get_xl_loglevel(void *this)
 {
-        xlator_t *xl = this;
-        if (!xl)
-                return 0;
-        return xl->loglevel;
+    xlator_t *xl = this;
+    if (!xl)
+        return 0;
+    return xl->loglevel;
 }
 
 void
-gf_log_set_log_buf_size (uint32_t buf_size)
+gf_log_set_log_buf_size(uint32_t buf_size)
 {
-        uint32_t          old = 0;
-        glusterfs_ctx_t  *ctx = THIS->ctx;
-
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                old = ctx->log.lru_size;
-                ctx->log.lru_size = buf_size;
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-
-        /* If the old size is less than/equal to the new size, then do nothing.
-         *
-         * But if the new size is less than the old size, then
-         *   a. If the cur size of the buf is less than or equal the new size,
-         *      then do nothing.
-         *   b. But if the current size of the buf is greater than the new size,
-         *      then flush the least recently used (cur size - new_size) msgs
-         *      to disk.
-         */
-        if (buf_size < old)
-                gf_log_flush_extra_msgs (ctx, buf_size);
+    uint32_t old = 0;
+    glusterfs_ctx_t *ctx = THIS->ctx;
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        old = ctx->log.lru_size;
+        ctx->log.lru_size = buf_size;
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+
+    /* If the old size is less than/equal to the new size, then do nothing.
+     *
+     * But if the new size is less than the old size, then
+     *   a. If the cur size of the buf is less than or equal the new size,
+     *      then do nothing.
+     *   b. But if the current size of the buf is greater than the new size,
+     *      then flush the least recently used (cur size - new_size) msgs
+     *      to disk.
+     */
+    if (buf_size < old)
+        gf_log_flush_extra_msgs(ctx, buf_size);
 }
 
 void
-gf_log_set_log_flush_timeout (uint32_t timeout)
+gf_log_set_log_flush_timeout(uint32_t timeout)
 {
-        THIS->ctx->log.timeout = timeout;
+    THIS->ctx->log.timeout = timeout;
 }
 
 log_buf_t *
-log_buf_new ()
+log_buf_new()
 {
-        log_buf_t  *buf  = NULL;
+    log_buf_t *buf = NULL;
 
-        buf = mem_get0 (THIS->ctx->logbuf_pool);
+    buf = mem_get0(THIS->ctx->logbuf_pool);
 
-        return buf;
+    return buf;
 }
 
 /* If log_buf_init() fails (indicated by a return value of -1),
@@ -312,147 +311,145 @@ log_buf_new ()
  * the log_buf_t object back to its memory pool.
  */
 int
-log_buf_init (log_buf_t *buf, const char *domain, const char *file,
-              const char *function, int32_t line, gf_loglevel_t level,
-              int errnum, uint64_t msgid, char **appmsgstr, int graph_id)
+log_buf_init(log_buf_t *buf, const char *domain, const char *file,
+             const char *function, int32_t line, gf_loglevel_t level,
+             int errnum, uint64_t msgid, char **appmsgstr, int graph_id)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!buf || !domain || !file || !function || !appmsgstr || !*appmsgstr)
-                goto out;
+    if (!buf || !domain || !file || !function || !appmsgstr || !*appmsgstr)
+        goto out;
 
-        buf->msg = gf_strdup (*appmsgstr);
-        if (!buf->msg)
-                goto out;
+    buf->msg = gf_strdup(*appmsgstr);
+    if (!buf->msg)
+        goto out;
 
-        buf->msg_id = msgid;
-        buf->errnum = errnum;
-        buf->domain = gf_strdup (domain);
-        if (!buf->domain)
-                goto out;
+    buf->msg_id = msgid;
+    buf->errnum = errnum;
+    buf->domain = gf_strdup(domain);
+    if (!buf->domain)
+        goto out;
 
-        buf->file = gf_strdup (file);
-        if (!buf->file)
-                goto out;
+    buf->file = gf_strdup(file);
+    if (!buf->file)
+        goto out;
 
-        buf->function = gf_strdup (function);
-        if (!buf->function)
-                goto out;
+    buf->function = gf_strdup(function);
+    if (!buf->function)
+        goto out;
 
-        buf->line = line;
-        buf->level = level;
-        buf->refcount = 0;
-        buf->graph_id = graph_id;
-        INIT_LIST_HEAD (&buf->msg_list);
+    buf->line = line;
+    buf->level = level;
+    buf->refcount = 0;
+    buf->graph_id = graph_id;
+    INIT_LIST_HEAD(&buf->msg_list);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-log_buf_destroy (log_buf_t *buf)
+log_buf_destroy(log_buf_t *buf)
 {
+    if (!buf)
+        return -1;
 
-        if (!buf)
-                return -1;
-
-        GF_FREE (buf->msg);
-        GF_FREE (buf->domain);
-        GF_FREE (buf->file);
-        GF_FREE (buf->function);
+    GF_FREE(buf->msg);
+    GF_FREE(buf->domain);
+    GF_FREE(buf->file);
+    GF_FREE(buf->function);
 
-        mem_put (buf);
-        return 0;
+    mem_put(buf);
+    return 0;
 }
 
 static void
 gf_log_rotate(glusterfs_ctx_t *ctx)
 {
-        int            fd   = -1;
-        FILE          *new_logfile = NULL;
-        FILE          *old_logfile = NULL;
-
-        /* not involving locks on initial check to speed it up */
-        if (ctx->log.logrotate) {
-                /* let only one winner through on races */
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-
-                if (!ctx->log.logrotate) {
-                        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                        return;
-                } else {
-                        ctx->log.logrotate = 0;
-                        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                }
-
-                fd = sys_open (ctx->log.filename, O_CREAT | O_WRONLY | O_APPEND,
-                               S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg ("logrotate", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open "
-                                "logfile");
-                        return;
-                }
+    int fd = -1;
+    FILE *new_logfile = NULL;
+    FILE *old_logfile = NULL;
+
+    /* not involving locks on initial check to speed it up */
+    if (ctx->log.logrotate) {
+        /* let only one winner through on races */
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+
+        if (!ctx->log.logrotate) {
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
+            return;
+        } else {
+            ctx->log.logrotate = 0;
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
+        }
 
-                new_logfile = fdopen (fd, "a");
-                if (!new_logfile) {
-                        gf_msg ("logrotate", GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open logfile"
-                                " %s", ctx->log.filename);
-                        sys_close (fd);
-                        return;
-                }
+        fd = sys_open(ctx->log.filename, O_CREAT | O_WRONLY | O_APPEND,
+                      S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            gf_msg("logrotate", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open "
+                   "logfile");
+            return;
+        }
 
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile)
-                                old_logfile = ctx->log.logfile;
+        new_logfile = fdopen(fd, "a");
+        if (!new_logfile) {
+            gf_msg("logrotate", GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open logfile"
+                   " %s",
+                   ctx->log.filename);
+            sys_close(fd);
+            return;
+        }
 
-                        ctx->log.gf_log_logfile = ctx->log.logfile =
-                                                                new_logfile;
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        {
+            if (ctx->log.logfile)
+                old_logfile = ctx->log.logfile;
 
-                if (old_logfile != NULL)
-                        fclose (old_logfile);
+            ctx->log.gf_log_logfile = ctx->log.logfile = new_logfile;
         }
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-        return;
+        if (old_logfile != NULL)
+            fclose(old_logfile);
+    }
+
+    return;
 }
 
 void
-gf_log_globals_fini (void)
+gf_log_globals_fini(void)
 {
-        /* TODO: Nobody is invoking the fini, but cleanup needs to happen here,
-         * needs cleanup for, log.ident, log.filename, closelog, log file close
-         * rotate state, possibly under a lock */
-        pthread_mutex_destroy (&THIS->ctx->log.logfile_mutex);
-        pthread_mutex_destroy (&THIS->ctx->log.log_buf_lock);
+    /* TODO: Nobody is invoking the fini, but cleanup needs to happen here,
+     * needs cleanup for, log.ident, log.filename, closelog, log file close
+     * rotate state, possibly under a lock */
+    pthread_mutex_destroy(&THIS->ctx->log.logfile_mutex);
+    pthread_mutex_destroy(&THIS->ctx->log.log_buf_lock);
 }
 
 void
-gf_log_disable_suppression_before_exit (glusterfs_ctx_t *ctx)
+gf_log_disable_suppression_before_exit(glusterfs_ctx_t *ctx)
 {
-        /*
-         * First set log buf size to 0. This would ensure two things:
-         * i. that all outstanding log messages are flushed to disk, and
-         * ii. all subsequent calls to gf_msg will result in the logs getting
-         *     directly flushed to disk without being buffered.
-         *
-         * Then, cancel the current log timer event.
-         */
-
-        gf_log_set_log_buf_size (0);
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                if (ctx->log.log_flush_timer) {
-                        gf_timer_call_cancel (ctx, ctx->log.log_flush_timer);
-                        ctx->log.log_flush_timer = NULL;
-                }
+    /*
+     * First set log buf size to 0. This would ensure two things:
+     * i. that all outstanding log messages are flushed to disk, and
+     * ii. all subsequent calls to gf_msg will result in the logs getting
+     *     directly flushed to disk without being buffered.
+     *
+     * Then, cancel the current log timer event.
+     */
+
+    gf_log_set_log_buf_size(0);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        if (ctx->log.log_flush_timer) {
+            gf_timer_call_cancel(ctx, ctx->log.log_flush_timer);
+            ctx->log.log_flush_timer = NULL;
         }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 }
 
 /** gf_log_fini - function to perform the cleanup of the log information
@@ -461,45 +458,44 @@ gf_log_disable_suppression_before_exit (glusterfs_ctx_t *ctx)
  *          failure: -1
  */
 int
-gf_log_fini (void *data)
+gf_log_fini(void *data)
 {
-        glusterfs_ctx_t *ctx = data;
-        int              ret = 0;
-        FILE            *old_logfile = NULL;
+    glusterfs_ctx_t *ctx = data;
+    int ret = 0;
+    FILE *old_logfile = NULL;
 
-        if (ctx == NULL) {
-	        ret = -1;
-                goto out;
-        }
+    if (ctx == NULL) {
+        ret = -1;
+        goto out;
+    }
 
-        gf_log_disable_suppression_before_exit (ctx);
+    gf_log_disable_suppression_before_exit(ctx);
 
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        old_logfile = ctx->log.logfile;
-
-                        /* Logfile needs to be set to NULL, so that any
-                           call to gf_log after calling gf_log_fini, will
-                           log the message to stderr.
-                        */
-                        ctx->log.loglevel = GF_LOG_NONE;
-                        ctx->log.logfile = NULL;
-                }
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            old_logfile = ctx->log.logfile;
+
+            /* Logfile needs to be set to NULL, so that any
+               call to gf_log after calling gf_log_fini, will
+               log the message to stderr.
+            */
+            ctx->log.loglevel = GF_LOG_NONE;
+            ctx->log.logfile = NULL;
         }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    }
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-        if (old_logfile && (fclose (old_logfile) != 0))
-                ret = -1;
+    if (old_logfile && (fclose(old_logfile) != 0))
+        ret = -1;
 
-        GF_FREE (ctx->log.ident);
-        GF_FREE (ctx->log.filename);
+    GF_FREE(ctx->log.ident);
+    GF_FREE(ctx->log.filename);
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
-
 /**
  * gf_openlog -function to open syslog specific to gluster based on
  *             existence of file /etc/glusterfs/logger.conf
@@ -512,27 +508,26 @@ gf_log_fini (void *data)
  * @return: void
  */
 void
-gf_openlog (const char *ident, int option, int facility)
+gf_openlog(const char *ident, int option, int facility)
 {
-        int _option = option;
-        int _facility = facility;
-
-        if (-1 == _option) {
-                _option = LOG_PID | LOG_NDELAY;
-        }
-        if (-1 == _facility) {
-                _facility = LOG_LOCAL1;
-        }
-
-        /* TODO: Should check for errors here and return appropriately */
-        setlocale(LC_ALL, "");
-        setlocale(LC_NUMERIC, "C"); /* C-locale for strtod, ... */
-        /* close the previous syslog if open as we are changing settings */
-        closelog ();
-        openlog(ident, _option, _facility);
+    int _option = option;
+    int _facility = facility;
+
+    if (-1 == _option) {
+        _option = LOG_PID | LOG_NDELAY;
+    }
+    if (-1 == _facility) {
+        _facility = LOG_LOCAL1;
+    }
+
+    /* TODO: Should check for errors here and return appropriately */
+    setlocale(LC_ALL, "");
+    setlocale(LC_NUMERIC, "C"); /* C-locale for strtod, ... */
+    /* close the previous syslog if open as we are changing settings */
+    closelog();
+    openlog(ident, _option, _facility);
 }
 
-
 /**
  * _json_escape -function to convert string to json encoded string
  * @str: input string
@@ -559,85 +554,75 @@ gf_openlog (const char *ident, int option, int facility)
 char *
 _json_escape(const char *str, char *buf, size_t len)
 {
-        static const unsigned char json_exceptions[UCHAR_MAX + 1] =
-                {
-                        [0x01] = 1, [0x02] = 1, [0x03] = 1, [0x04] = 1,
-                        [0x05] = 1, [0x06] = 1, [0x07] = 1, [0x08] = 1,
-                        [0x09] = 1, [0x0a] = 1, [0x0b] = 1, [0x0c] = 1,
-                        [0x0d] = 1, [0x0e] = 1, [0x0f] = 1, [0x10] = 1,
-                        [0x11] = 1, [0x12] = 1, [0x13] = 1, [0x14] = 1,
-                        [0x15] = 1, [0x16] = 1, [0x17] = 1, [0x18] = 1,
-                        [0x19] = 1, [0x1a] = 1, [0x1b] = 1, [0x1c] = 1,
-                        [0x1d] = 1, [0x1e] = 1, [0x1f] = 1,
-                        ['\\'] = 1, ['"'] = 1
-                };
-        static const char  json_hex_chars[16] = "0123456789abcdef";
-        unsigned char     *p = NULL;
-        size_t             pos = 0;
-
-        if (!str || !buf || len <= 0) {
-                return NULL;
-        }
-
-        for (p = (unsigned char *)str;
-             *p && (pos + 1) < len;
-             p++)
-        {
-                if (json_exceptions[*p] == 0) {
-                        buf[pos++] = *p;
-                        continue;
-                }
-
-                if ((pos + 2) >= len) {
-                        break;
-                }
-
-                switch (*p)
-                {
-                case '\b':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'b';
-                        break;
-                case '\n':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'n';
-                        break;
-                case '\r':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'r';
-                        break;
-                case '\t':
-                        buf[pos++] = '\\';
-                        buf[pos++] = 't';
-                        break;
-                case '\\':
-                        buf[pos++] = '\\';
-                        buf[pos++] = '\\';
-                        break;
-                case '"':
-                        buf[pos++] = '\\';
-                        buf[pos++] = '"';
-                        break;
-                default:
-                        if ((pos + 6) >= len) {
-                                buf[pos] = '\0';
-                                return (char *)p;
-                        }
-                        buf[pos++] = '\\';
-                        buf[pos++] = 'u';
-                        buf[pos++] = '0';
-                        buf[pos++] = '0';
-                        buf[pos++] = json_hex_chars[(*p) >> 4];
-                        buf[pos++] = json_hex_chars[(*p) & 0xf];
-                        break;
+    static const unsigned char json_exceptions[UCHAR_MAX + 1] = {
+        [0x01] = 1, [0x02] = 1, [0x03] = 1, [0x04] = 1, [0x05] = 1, [0x06] = 1,
+        [0x07] = 1, [0x08] = 1, [0x09] = 1, [0x0a] = 1, [0x0b] = 1, [0x0c] = 1,
+        [0x0d] = 1, [0x0e] = 1, [0x0f] = 1, [0x10] = 1, [0x11] = 1, [0x12] = 1,
+        [0x13] = 1, [0x14] = 1, [0x15] = 1, [0x16] = 1, [0x17] = 1, [0x18] = 1,
+        [0x19] = 1, [0x1a] = 1, [0x1b] = 1, [0x1c] = 1, [0x1d] = 1, [0x1e] = 1,
+        [0x1f] = 1, ['\\'] = 1, ['"'] = 1};
+    static const char json_hex_chars[16] = "0123456789abcdef";
+    unsigned char *p = NULL;
+    size_t pos = 0;
+
+    if (!str || !buf || len <= 0) {
+        return NULL;
+    }
+
+    for (p = (unsigned char *)str; *p && (pos + 1) < len; p++) {
+        if (json_exceptions[*p] == 0) {
+            buf[pos++] = *p;
+            continue;
+        }
+
+        if ((pos + 2) >= len) {
+            break;
+        }
+
+        switch (*p) {
+            case '\b':
+                buf[pos++] = '\\';
+                buf[pos++] = 'b';
+                break;
+            case '\n':
+                buf[pos++] = '\\';
+                buf[pos++] = 'n';
+                break;
+            case '\r':
+                buf[pos++] = '\\';
+                buf[pos++] = 'r';
+                break;
+            case '\t':
+                buf[pos++] = '\\';
+                buf[pos++] = 't';
+                break;
+            case '\\':
+                buf[pos++] = '\\';
+                buf[pos++] = '\\';
+                break;
+            case '"':
+                buf[pos++] = '\\';
+                buf[pos++] = '"';
+                break;
+            default:
+                if ((pos + 6) >= len) {
+                    buf[pos] = '\0';
+                    return (char *)p;
                 }
+                buf[pos++] = '\\';
+                buf[pos++] = 'u';
+                buf[pos++] = '0';
+                buf[pos++] = '0';
+                buf[pos++] = json_hex_chars[(*p) >> 4];
+                buf[pos++] = json_hex_chars[(*p) & 0xf];
+                break;
         }
+    }
 
-        buf[pos] = '\0';
-        return (char *)p;
+    buf[pos] = '\0';
+    return (char *)p;
 }
 
-
 /**
  * gf_syslog -function to submit message to syslog specific to gluster
  * @facility_priority: facility_priority of syslog()
@@ -646,158 +631,162 @@ _json_escape(const char *str, char *buf, size_t len)
  * @return: void
  */
 void
-gf_syslog (int facility_priority, char *format, ...)
+gf_syslog(int facility_priority, char *format, ...)
 {
-        char       *msg = NULL;
-        char        json_msg[GF_JSON_MSG_LENGTH];
-        GF_UNUSED char       *p = NULL;
-        va_list     ap;
-
-        GF_ASSERT (format);
-
-        va_start (ap, format);
-        if (vasprintf (&msg, format, ap) != -1) {
-                p = _json_escape (msg, json_msg, GF_JSON_MSG_LENGTH);
-                syslog (facility_priority, "%s", msg);
-                free (msg);
-        } else
-                syslog (GF_LOG_CRITICAL, "vasprintf() failed, out of memory?");
-        va_end (ap);
+    char *msg = NULL;
+    char json_msg[GF_JSON_MSG_LENGTH];
+    GF_UNUSED char *p = NULL;
+    va_list ap;
+
+    GF_ASSERT(format);
+
+    va_start(ap, format);
+    if (vasprintf(&msg, format, ap) != -1) {
+        p = _json_escape(msg, json_msg, GF_JSON_MSG_LENGTH);
+        syslog(facility_priority, "%s", msg);
+        free(msg);
+    } else
+        syslog(GF_LOG_CRITICAL, "vasprintf() failed, out of memory?");
+    va_end(ap);
 }
 
 void
-gf_log_globals_init (void *data, gf_loglevel_t level)
+gf_log_globals_init(void *data, gf_loglevel_t level)
 {
-        glusterfs_ctx_t *ctx = data;
+    glusterfs_ctx_t *ctx = data;
 
-        pthread_mutex_init (&ctx->log.logfile_mutex, NULL);
+    pthread_mutex_init(&ctx->log.logfile_mutex, NULL);
 
-        ctx->log.loglevel         = level;
-        ctx->log.gf_log_syslog    = 1;
-        ctx->log.sys_log_level    = GF_LOG_CRITICAL;
-        ctx->log.logger           = gf_logger_glusterlog;
-        ctx->log.logformat        = gf_logformat_withmsgid;
-        ctx->log.lru_size         = GF_LOG_LRU_BUFSIZE_DEFAULT;
-        ctx->log.timeout          = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
-        ctx->log.localtime        = GF_LOG_LOCALTIME_DEFAULT;
+    ctx->log.loglevel = level;
+    ctx->log.gf_log_syslog = 1;
+    ctx->log.sys_log_level = GF_LOG_CRITICAL;
+    ctx->log.logger = gf_logger_glusterlog;
+    ctx->log.logformat = gf_logformat_withmsgid;
+    ctx->log.lru_size = GF_LOG_LRU_BUFSIZE_DEFAULT;
+    ctx->log.timeout = GF_LOG_FLUSH_TIMEOUT_DEFAULT;
+    ctx->log.localtime = GF_LOG_LOCALTIME_DEFAULT;
 
-        pthread_mutex_init (&ctx->log.log_buf_lock, NULL);
+    pthread_mutex_init(&ctx->log.log_buf_lock, NULL);
 
-        INIT_LIST_HEAD (&ctx->log.lru_queue);
+    INIT_LIST_HEAD(&ctx->log.lru_queue);
 
 #ifdef GF_LINUX_HOST_OS
-        /* For the 'syslog' output. one can grep 'GlusterFS' in syslog
-           for serious logs */
-        openlog ("GlusterFS", LOG_PID, LOG_DAEMON);
+    /* For the 'syslog' output. one can grep 'GlusterFS' in syslog
+       for serious logs */
+    openlog("GlusterFS", LOG_PID, LOG_DAEMON);
 #endif
-
 }
 
 int
-gf_log_init (void *data, const char *file, const char *ident)
+gf_log_init(void *data, const char *file, const char *ident)
 {
-        glusterfs_ctx_t *ctx = NULL;
-        int              fd = -1;
-        struct stat      buf;
-
-        ctx = data;
-
-        if (ctx == NULL) {
-                fprintf (stderr, "ERROR: ctx is NULL\n");
-                return -1;
-        }
-        if (ident) {
-                GF_FREE (ctx->log.ident);
-                ctx->log.ident = gf_strdup (ident);
-        }
-
-        /* we keep the files and the syslog open, so that on logger change, we
-         * are ready to log anywhere, that the new value specifies */
-        if (ctx->log.ident) {
-                gf_openlog (ctx->log.ident, -1, LOG_DAEMON);
-        } else {
-                gf_openlog (NULL, -1, LOG_DAEMON);
-        }
-        /* TODO: make FACILITY configurable than LOG_DAEMON */
-        if (sys_stat (GF_LOG_CONTROL_FILE, &buf) == 0) {
-                /* use syslog logging */
-                ctx->log.log_control_file_found = 1;
-        } else {
-                /* use old style logging */
-                ctx->log.log_control_file_found = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    int fd = -1;
+    struct stat buf;
+
+    ctx = data;
+
+    if (ctx == NULL) {
+        fprintf(stderr, "ERROR: ctx is NULL\n");
+        return -1;
+    }
+    if (ident) {
+        GF_FREE(ctx->log.ident);
+        ctx->log.ident = gf_strdup(ident);
+    }
+
+    /* we keep the files and the syslog open, so that on logger change, we
+     * are ready to log anywhere, that the new value specifies */
+    if (ctx->log.ident) {
+        gf_openlog(ctx->log.ident, -1, LOG_DAEMON);
+    } else {
+        gf_openlog(NULL, -1, LOG_DAEMON);
+    }
+    /* TODO: make FACILITY configurable than LOG_DAEMON */
+    if (sys_stat(GF_LOG_CONTROL_FILE, &buf) == 0) {
+        /* use syslog logging */
+        ctx->log.log_control_file_found = 1;
+    } else {
+        /* use old style logging */
+        ctx->log.log_control_file_found = 0;
+    }
+
+    if (!file) {
+        fprintf(stderr, "ERROR: no filename specified\n");
+        return -1;
+    }
+
+    /* free the (possible) previous filename */
+    GF_FREE(ctx->log.filename);
+    ctx->log.filename = NULL;
+
+    if (strcmp(file, "-") == 0) {
+        int dupfd = -1;
+
+        ctx->log.filename = gf_strdup("/dev/stderr");
+        if (!ctx->log.filename) {
+            fprintf(stderr, "ERROR: strdup failed\n");
+            return -1;
+        }
+
+        dupfd = dup(fileno(stderr));
+        if (dupfd == -1) {
+            fprintf(stderr, "ERROR: could not dup %d (%s)\n", fileno(stderr),
+                    strerror(errno));
+            return -1;
+        }
+
+        ctx->log.logfile = fdopen(dupfd, "a");
+        if (!ctx->log.logfile) {
+            fprintf(stderr, "ERROR: could not fdopen on %d (%s)\n", dupfd,
+                    strerror(errno));
+            sys_close(dupfd);
+            return -1;
+        }
+    } else {
+        ctx->log.filename = gf_strdup(file);
+        if (!ctx->log.filename) {
+            fprintf(stderr,
+                    "ERROR: updating log-filename failed: "
+                    "%s\n",
+                    strerror(errno));
+            return -1;
+        }
+
+        fd = sys_open(file, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            fprintf(stderr,
+                    "ERROR: failed to create logfile"
+                    " \"%s\" (%s)\n",
+                    file, strerror(errno));
+            return -1;
         }
 
-        if (!file) {
-                fprintf (stderr, "ERROR: no filename specified\n");
-                return -1;
+        ctx->log.logfile = fdopen(fd, "a");
+        if (!ctx->log.logfile) {
+            fprintf(stderr,
+                    "ERROR: failed to open logfile \"%s\" "
+                    "(%s)\n",
+                    file, strerror(errno));
+            sys_close(fd);
+            return -1;
         }
+    }
 
-        /* free the (possible) previous filename */
-        GF_FREE (ctx->log.filename);
-        ctx->log.filename = NULL;
-
-        if (strcmp (file, "-") == 0) {
-		int dupfd = -1;
-
-		ctx->log.filename = gf_strdup ("/dev/stderr");
-		if (!ctx->log.filename) {
-			fprintf (stderr, "ERROR: strdup failed\n");
-			return -1;
-		}
-
-		dupfd = dup (fileno (stderr));
-		if (dupfd == -1) {
-			fprintf (stderr, "ERROR: could not dup %d (%s)\n",
-				 fileno (stderr), strerror (errno));
-			return -1;
-		}
-
-		ctx->log.logfile = fdopen (dupfd, "a");
-		if (!ctx->log.logfile) {
-			fprintf (stderr, "ERROR: could not fdopen on %d (%s)\n",
-				 dupfd, strerror (errno));
-                        sys_close (dupfd);
-			return -1;
-		}
-        } else {
-                ctx->log.filename = gf_strdup (file);
-                if (!ctx->log.filename) {
-                        fprintf (stderr, "ERROR: updating log-filename failed: "
-                                 "%s\n", strerror (errno));
-                        return -1;
-                }
-
-                fd = sys_open (file, O_CREAT | O_WRONLY | O_APPEND,
-                               S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        fprintf (stderr, "ERROR: failed to create logfile"
-                                 " \"%s\" (%s)\n", file, strerror (errno));
-                        return -1;
-                }
+    ctx->log.gf_log_logfile = ctx->log.logfile;
 
-                ctx->log.logfile = fdopen (fd, "a");
-                if (!ctx->log.logfile) {
-                        fprintf (stderr, "ERROR: failed to open logfile \"%s\" "
-                                 "(%s)\n", file, strerror (errno));
-                        sys_close (fd);
-                        return -1;
-                }
-        }
-
-        ctx->log.gf_log_logfile = ctx->log.logfile;
-
-        return 0;
+    return 0;
 }
 
 void
-set_sys_log_level (gf_loglevel_t level)
+set_sys_log_level(gf_loglevel_t level)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = THIS->ctx;
+    ctx = THIS->ctx;
 
-        if (ctx)
-                ctx->log.sys_log_level = level;
+    if (ctx)
+        ctx->log.sys_log_level = level;
 }
 
 /* Check if we should be logging
@@ -805,1844 +794,1857 @@ set_sys_log_level (gf_loglevel_t level)
  *               _gf_true : Do not Print the log
  */
 static gf_boolean_t
-skip_logging (xlator_t *this, gf_loglevel_t level)
+skip_logging(xlator_t *this, gf_loglevel_t level)
 {
-        gf_boolean_t ret = _gf_false;
-        gf_loglevel_t existing_level = GF_LOG_NONE;
-
-        if (level == GF_LOG_NONE) {
-                ret = _gf_true;
-                goto out;
-        }
-
-        existing_level = this->loglevel ? this->loglevel : this->ctx->log.loglevel;
-        if (level > existing_level) {
-                ret = _gf_true;
-                goto out;
-        }
+    gf_boolean_t ret = _gf_false;
+    gf_loglevel_t existing_level = GF_LOG_NONE;
+
+    if (level == GF_LOG_NONE) {
+        ret = _gf_true;
+        goto out;
+    }
+
+    existing_level = this->loglevel ? this->loglevel : this->ctx->log.loglevel;
+    if (level > existing_level) {
+        ret = _gf_true;
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_log_callingfn (const char *domain, const char *file, const char *function,
-                   int line, gf_loglevel_t level, const char *fmt, ...)
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int line, gf_loglevel_t level, const char *fmt, ...)
 {
-        const char     *basename        = NULL;
-        xlator_t       *this            = NULL;
-        char           *str1            = NULL;
-        char           *str2            = NULL;
-        char           *msg             = NULL;
-        char            timestr[256]    = {0,};
-        char           *callstr         = NULL;
-        struct timeval  tv              = {0,};
-        size_t          len             = 0;
-        int             ret             = 0;
-        va_list         ap;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        static char *level_strings[] = {"",  /* NONE */
-                                        "M", /* EMERGENCY */
-                                        "A", /* ALERT */
-                                        "C", /* CRITICAL */
-                                        "E", /* ERROR */
-                                        "W", /* WARNING */
-                                        "N", /* NOTICE */
-                                        "I", /* INFO */
-                                        "D", /* DEBUG */
-                                        "T", /* TRACE */
-                                        ""};
-
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
+    const char *basename = NULL;
+    xlator_t *this = NULL;
+    char *str1 = NULL;
+    char *str2 = NULL;
+    char *msg = NULL;
+    char timestr[256] = {
+        0,
+    };
+    char *callstr = NULL;
+    struct timeval tv = {
+        0,
+    };
+    size_t len = 0;
+    int ret = 0;
+    va_list ap;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    static char *level_strings[] = {"",  /* NONE */
+                                    "M", /* EMERGENCY */
+                                    "A", /* ALERT */
+                                    "C", /* CRITICAL */
+                                    "E", /* ERROR */
+                                    "W", /* WARNING */
+                                    "N", /* NOTICE */
+                                    "I", /* INFO */
+                                    "D", /* DEBUG */
+                                    "T", /* TRACE */
+                                    ""};
+
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    basename = strrchr(file, '/');
+    if (basename)
+        basename++;
+    else
+        basename = file;
+
+    /*Saving the backtrace to pre-allocated ctx->btbuf
+     * to avoid allocating memory from the heap*/
+    callstr = gf_backtrace_save(NULL);
+
+    if (ctx->log.log_control_file_found) {
+        int priority;
+        /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
+           other level as is */
+        if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
+            priority = LOG_DEBUG;
+        } else {
+            priority = level - 1;
         }
 
-        basename = strrchr (file, '/');
-        if (basename)
-                basename++;
-        else
-                basename = file;
+        va_start(ap, fmt);
+        vasprintf(&str2, fmt, ap);
+        va_end(ap);
 
-        /*Saving the backtrace to pre-allocated ctx->btbuf
-         * to avoid allocating memory from the heap*/
-        callstr = gf_backtrace_save (NULL);
+        gf_syslog(priority, "[%s:%d:%s] %s %d-%s: %s", basename, line, function,
+                  callstr, ((this->graph) ? this->graph->id : 0), domain, str2);
 
-        if (ctx->log.log_control_file_found)
-        {
-                int priority;
-                /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
-                   other level as is */
-                if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
-                        priority = LOG_DEBUG;
-                } else {
-                        priority = level - 1;
-                }
+        goto out;
+    }
 
-                va_start (ap, fmt);
-                vasprintf (&str2, fmt, ap);
-                va_end (ap);
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
+    va_start(ap, fmt);
+    gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+    snprintf(timestr + strlen(timestr), sizeof timestr - strlen(timestr),
+             ".%" GF_PRI_SUSECONDS, tv.tv_usec);
 
-                gf_syslog (priority, "[%s:%d:%s] %s %d-%s: %s",
-                           basename, line, function,
-                           callstr,
-                           ((this->graph) ? this->graph->id:0), domain,
-                           str2);
+    ret = gf_asprintf(&str1, "[%s] %s [%s:%d:%s] %s %d-%s: ", timestr,
+                      level_strings[level], basename, line, function, callstr,
+                      ((this->graph) ? this->graph->id : 0), domain);
+    if (-1 == ret) {
+        goto out;
+    }
 
-                goto out;
-        }
+    ret = vasprintf(&str2, fmt, ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %s %d-%s: ",
-                           timestr, level_strings[level],
-                           basename, line, function, callstr,
-                           ((this->graph) ? this->graph->id:0), domain);
-        if (-1 == ret) {
-                goto out;
-        }
+    va_end(ap);
 
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    len = strlen(str1);
+    msg = GF_MALLOC(len + strlen(str2) + 1, gf_common_mt_char);
+    if (!msg) {
+        ret = -1;
+        goto out;
+    }
 
-        va_end (ap);
+    strcpy(msg, str1);
+    strcpy(msg + len, str2);
 
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto out;
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s\n", msg);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s\n", msg);
+            fflush(stderr);
         }
 
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious log in 'syslog', not our debug
-                   and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                    (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious log in 'syslog', not our debug
+           and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s\n", msg);
 #endif
-        }
+    }
 
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 out:
-        GF_FREE (msg);
+    GF_FREE(msg);
 
-        GF_FREE (str1);
+    GF_FREE(str1);
 
-        FREE (str2);
+    FREE(str2);
 
-        va_end (ap);
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg_plain_internal (gf_loglevel_t level, const char *msg)
+_gf_msg_plain_internal(gf_loglevel_t level, const char *msg)
 {
-        xlator_t        *this           = NULL;
-        glusterfs_ctx_t *ctx            = NULL;
-        int              priority;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int priority;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        /* log to the configured logging service */
-        switch (ctx->log.logger) {
+    /* log to the configured logging service */
+    switch (ctx->log.logger) {
         case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        SET_LOG_PRIO (level, priority);
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                SET_LOG_PRIO(level, priority);
 
-                        syslog (priority, "%s", msg);
-                        break;
-                }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
+                syslog(priority, "%s", msg);
+                break;
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
         case gf_logger_glusterlog:
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile) {
-                                fprintf (ctx->log.logfile, "%s\n", msg);
-                                fflush (ctx->log.logfile);
-                        } else {
-                                fprintf (stderr, "%s\n", msg);
-                                fflush (stderr);
-                        }
+            pthread_mutex_lock(&ctx->log.logfile_mutex);
+            {
+                if (ctx->log.logfile) {
+                    fprintf(ctx->log.logfile, "%s\n", msg);
+                    fflush(ctx->log.logfile);
+                } else {
+                    fprintf(stderr, "%s\n", msg);
+                    fflush(stderr);
+                }
 
 #ifdef GF_LINUX_HOST_OS
-                        /* We want only serious logs in 'syslog', not our debug
-                                * and trace logs */
-                        if (ctx->log.gf_log_syslog && level &&
-                                (level <= ctx->log.sys_log_level))
-                                syslog ((level-1), "%s\n", msg);
+                /* We want only serious logs in 'syslog', not our debug
+                 * and trace logs */
+                if (ctx->log.gf_log_syslog && level &&
+                    (level <= ctx->log.sys_log_level))
+                    syslog((level - 1), "%s\n", msg);
 #endif
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+            }
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-                break;
-        }
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-_gf_msg_plain (gf_loglevel_t level, const char *fmt, ...)
+_gf_msg_plain(gf_loglevel_t level, const char *fmt, ...)
 {
-        xlator_t        *this            = NULL;
-        int              ret             = 0;
-        va_list          ap;
-        char            *msg             = NULL;
-        glusterfs_ctx_t *ctx = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    va_list ap;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        va_start (ap, fmt);
-        ret = vasprintf (&msg, fmt, ap);
-        va_end (ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    va_start(ap, fmt);
+    ret = vasprintf(&msg, fmt, ap);
+    va_end(ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
-        FREE (msg);
+    FREE(msg);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg_vplain (gf_loglevel_t level, const char *fmt, va_list ap)
+_gf_msg_vplain(gf_loglevel_t level, const char *fmt, va_list ap)
 {
-        xlator_t        *this            = NULL;
-        int              ret             = 0;
-        char            *msg             = NULL;
-        glusterfs_ctx_t *ctx             = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    char *msg = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        ret = vasprintf (&msg, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    ret = vasprintf(&msg, fmt, ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
-        FREE (msg);
+    FREE(msg);
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg_plain_nomem (gf_loglevel_t level, const char *msg)
+_gf_msg_plain_nomem(gf_loglevel_t level, const char *msg)
 {
-        xlator_t        *this           = NULL;
-        int              ret            = 0;
-        glusterfs_ctx_t *ctx            = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
 
-        this = THIS;
-        ctx = this->ctx;
+    this = THIS;
+    ctx = this->ctx;
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (skip_logging (this, level))
-                goto out;
+    if (skip_logging(this, level))
+        goto out;
 
-        ret = _gf_msg_plain_internal (level, msg);
+    ret = _gf_msg_plain_internal(level, msg);
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-_gf_msg_backtrace_nomem (gf_loglevel_t level, int stacksize)
+_gf_msg_backtrace_nomem(gf_loglevel_t level, int stacksize)
 {
-        xlator_t        *this            = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-        void            *array[200];
-        size_t           bt_size = 0;
-        int              fd = -1;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        /* syslog does not have fd support, hence no no-mem variant */
-        if (ctx->log.logger != gf_logger_glusterlog)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        bt_size = backtrace (array, ((stacksize <= 200)? stacksize : 200));
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                fd = ctx->log.logfile?
-                        fileno (ctx->log.logfile) :
-                        fileno (stderr);
-                if (bt_size && (fd != -1)) {
-                        /* print to the file fd, to prevent any
-                           allocations from backtrace_symbols
-                         */
-                        backtrace_symbols_fd (&array[0], bt_size, fd);
-                }
-        }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    void *array[200];
+    size_t bt_size = 0;
+    int fd = -1;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    /* syslog does not have fd support, hence no no-mem variant */
+    if (ctx->log.logger != gf_logger_glusterlog)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    bt_size = backtrace(array, ((stacksize <= 200) ? stacksize : 200));
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        fd = ctx->log.logfile ? fileno(ctx->log.logfile) : fileno(stderr);
+        if (bt_size && (fd != -1)) {
+            /* print to the file fd, to prevent any
+               allocations from backtrace_symbols
+             */
+            backtrace_symbols_fd(&array[0], bt_size, fd);
+        }
+    }
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 out:
-        return;
+    return;
 }
 
 int
-_gf_msg_backtrace (int stacksize, char *callstr, size_t strsize)
+_gf_msg_backtrace(int stacksize, char *callstr, size_t strsize)
 {
-        int       ret = -1;
-        int       i = 0;
-        int       size = 0;
-        int       savstrsize = strsize;
-        void     *array[200];
-        char    **callingfn = NULL;
-
-        /* We chop off last 2 anyway, so if request is less than tolerance
-         * nothing to do */
-        if (stacksize < 3)
-                goto out;
-
-        size = backtrace (array, ((stacksize <= 200)? stacksize : 200));
-        if ((size - 3) < 0)
-                goto out;
-        if (size)
-                callingfn = backtrace_symbols (&array[2], size - 2);
-        if (!callingfn)
-                goto out;
-
-        ret = snprintf (callstr, strsize, "(");
-        PRINT_SIZE_CHECK (ret, out, strsize);
-
-        for ((i = size - 3); i >= 0; i--) {
-                ret = snprintf (callstr + savstrsize - strsize, strsize,
-                                "-->%s ", callingfn[i]);
-                PRINT_SIZE_CHECK (ret, out, strsize);
-        }
-
-        ret = snprintf (callstr + savstrsize - strsize, strsize, ")");
-        PRINT_SIZE_CHECK (ret, out, strsize);
+    int ret = -1;
+    int i = 0;
+    int size = 0;
+    int savstrsize = strsize;
+    void *array[200];
+    char **callingfn = NULL;
+
+    /* We chop off last 2 anyway, so if request is less than tolerance
+     * nothing to do */
+    if (stacksize < 3)
+        goto out;
+
+    size = backtrace(array, ((stacksize <= 200) ? stacksize : 200));
+    if ((size - 3) < 0)
+        goto out;
+    if (size)
+        callingfn = backtrace_symbols(&array[2], size - 2);
+    if (!callingfn)
+        goto out;
+
+    ret = snprintf(callstr, strsize, "(");
+    PRINT_SIZE_CHECK(ret, out, strsize);
+
+    for ((i = size - 3); i >= 0; i--) {
+        ret = snprintf(callstr + savstrsize - strsize, strsize, "-->%s ",
+                       callingfn[i]);
+        PRINT_SIZE_CHECK(ret, out, strsize);
+    }
+
+    ret = snprintf(callstr + savstrsize - strsize, strsize, ")");
+    PRINT_SIZE_CHECK(ret, out, strsize);
 out:
-        FREE (callingfn);
-        return ret;
+    FREE(callingfn);
+    return ret;
 }
 
 int
-_gf_msg_nomem (const char *domain, const char *file,
-               const char *function, int line, gf_loglevel_t level,
-               size_t size)
+_gf_msg_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
-        const char      *basename        = NULL;
-        xlator_t        *this            = NULL;
-        struct timeval   tv              = {0,};
-        int              ret             = 0;
-        int              fd              = -1;
-        char             msg[2048]       = {0,};
-        char             timestr[GF_LOG_TIMESTR_SIZE]    = {0,};
-        glusterfs_ctx_t *ctx = NULL;
-        int              wlen = 0;
-        int              priority;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        if (!domain || !file || !function) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
-        }
-
-        GET_FILE_NAME_TO_LOG (file, basename);
+    const char *basename = NULL;
+    xlator_t *this = NULL;
+    struct timeval tv = {
+        0,
+    };
+    int ret = 0;
+    int fd = -1;
+    char msg[2048] = {
+        0,
+    };
+    char timestr[GF_LOG_TIMESTR_SIZE] = {
+        0,
+    };
+    glusterfs_ctx_t *ctx = NULL;
+    int wlen = 0;
+    int priority;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    if (!domain || !file || !function) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    GET_FILE_NAME_TO_LOG(file, basename);
+
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
+    gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+    ret = snprintf(timestr + strlen(timestr), sizeof timestr - strlen(timestr),
+                   ".%" GF_PRI_SUSECONDS, tv.tv_usec);
+    if (-1 == ret) {
+        goto out;
+    }
+
+    /* TODO: Currently we print in the enhanced format, with a message ID
+     * of 0. Need to enhance this to support format as configured */
+    ret = snprintf(msg, sizeof msg,
+                   "[%s] %s [MSGID: %" PRIu64
+                   "]"
+                   " [%s:%d:%s] %s: no memory "
+                   "available for size (%" GF_PRI_SIZET
+                   ")"
+                   " [call stack follows]\n",
+                   timestr, gf_level_strings[level], (uint64_t)0, basename,
+                   line, function, domain, size);
+    if (-1 == ret) {
+        goto out;
+    }
+
+    /* log to the configured logging service */
+    switch (ctx->log.logger) {
+        case gf_logger_syslog:
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                SET_LOG_PRIO(level, priority);
 
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        ret = snprintf (timestr + strlen (timestr),
-                        sizeof timestr - strlen (timestr),
-                        ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        if (-1 == ret) {
-                goto out;
-        }
+                /* if syslog allocates, then this may fail, but we
+                 * cannot do much about it at the moment */
+                /* There is no fd for syslog, hence no stack printed */
+                syslog(priority, "%s", msg);
+                break;
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
+        case gf_logger_glusterlog:
+            pthread_mutex_lock(&ctx->log.logfile_mutex);
+            {
+                fd = ctx->log.logfile ? fileno(ctx->log.logfile)
+                                      : fileno(stderr);
+                if (fd == -1) {
+                    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+                    goto out;
+                }
 
-        /* TODO: Currently we print in the enhanced format, with a message ID
-         * of 0. Need to enhance this to support format as configured */
-        ret = snprintf (msg, sizeof msg, "[%s] %s [MSGID: %"PRIu64"]"
-                        " [%s:%d:%s] %s: no memory "
-                        "available for size (%"GF_PRI_SIZET")"
-                        " [call stack follows]\n",
-                        timestr, gf_level_strings[level], (uint64_t) 0,
-                        basename, line, function, domain, size);
-        if (-1 == ret) {
-                goto out;
-        }
+                wlen = strlen(msg);
 
-        /* log to the configured logging service */
-        switch (ctx->log.logger) {
-        case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        SET_LOG_PRIO (level, priority);
-
-                        /* if syslog allocates, then this may fail, but we
-                         * cannot do much about it at the moment */
-                        /* There is no fd for syslog, hence no stack printed */
-                        syslog (priority, "%s", msg);
-                        break;
+                /* write directly to the fd to prevent out of order
+                 * message and stack */
+                ret = sys_write(fd, msg, wlen);
+                if (ret == -1) {
+                    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+                    goto out;
                 }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
-        case gf_logger_glusterlog:
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        fd = ctx->log.logfile? fileno (ctx->log.logfile) :
-                                fileno (stderr);
-                        if (fd == -1) {
-                                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                                goto out;
-                        }
-
-                        wlen = strlen (msg);
-
-                        /* write directly to the fd to prevent out of order
-                         * message and stack */
-                        ret = sys_write (fd, msg, wlen);
-                        if (ret == -1) {
-                                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-                                goto out;
-                        }
 #ifdef GF_LINUX_HOST_OS
-                        /* We want only serious log in 'syslog', not our debug
-                         * and trace logs */
-                        if (ctx->log.gf_log_syslog && level &&
-                                (level <= ctx->log.sys_log_level))
-                                syslog ((level-1), "%s\n", msg);
+                /* We want only serious log in 'syslog', not our debug
+                 * and trace logs */
+                if (ctx->log.gf_log_syslog && level &&
+                    (level <= ctx->log.sys_log_level))
+                    syslog((level - 1), "%s\n", msg);
 #endif
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
+            }
+            pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
-                _gf_msg_backtrace_nomem (level, GF_LOG_BACKTRACE_DEPTH);
+            _gf_msg_backtrace_nomem(level, GF_LOG_BACKTRACE_DEPTH);
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_log_syslog (glusterfs_ctx_t *ctx, const char *domain, const char *file,
-               const char *function, int32_t line, gf_loglevel_t level,
-               int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
-               int graph_id, gf_log_format_t fmt)
+gf_log_syslog(glusterfs_ctx_t *ctx, const char *domain, const char *file,
+              const char *function, int32_t line, gf_loglevel_t level,
+              int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
+              int graph_id, gf_log_format_t fmt)
 {
-        int              priority;
-
-        SET_LOG_PRIO (level, priority);
-
-        /* log with appropriate format */
-        switch (fmt) {
-                case gf_logformat_traditional:
-                if (!callstr) {
-                        if (errnum)
-                                syslog (priority, "[%s:%d:%s] %d-%s: %s [%s]",
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr);
-                } else {
-                        if (errnum)
-                                syslog (priority, "[%s:%d:%s] %s %d-%s:"
-                                        " %s [%s]",
-                                        file, line, function, callstr, graph_id,
-                                        domain, *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[%s:%d:%s] %s %d-%s: %s",
-                                        file, line, function, callstr, graph_id,
-                                        domain, *appmsgstr);
-                }
-                break;
-                case gf_logformat_withmsgid:
-                if (!callstr) {
-                        if (errnum)
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %d-%s: %s [%s]", msgid,
-                                        file, line, function, graph_id, domain,
-                                        *appmsgstr, strerror(errnum));
-                        else
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %d-%s: %s",
-                                        msgid, file, line, function, graph_id,
-                                        domain, *appmsgstr);
-                } else {
-                        if (errnum)
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %s %d-%s: %s [%s]",
-                                        msgid, file, line, function, callstr,
-                                        graph_id, domain, *appmsgstr,
-                                        strerror(errnum));
-                        else
-                                syslog (priority, "[MSGID: %"PRIu64"]"
-                                        " [%s:%d:%s] %s %d-%s: %s",
-                                        msgid, file, line, function, callstr,
-                                        graph_id, domain, *appmsgstr);
-                }
-                break;
-                case gf_logformat_cee:
-                /* TODO: Enhance CEE with additional parameters */
-                gf_syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                           file, line, function, graph_id, domain, *appmsgstr);
-                break;
-
-                default:
-                /* NOTE: should not get here without logging */
-                break;
-        }
-
-        /* TODO: There can be no errors from gf_syslog? */
-        return 0;
+    int priority;
+
+    SET_LOG_PRIO(level, priority);
+
+    /* log with appropriate format */
+    switch (fmt) {
+        case gf_logformat_traditional:
+            if (!callstr) {
+                if (errnum)
+                    syslog(priority, "[%s:%d:%s] %d-%s: %s [%s]", file, line,
+                           function, graph_id, domain, *appmsgstr,
+                           strerror(errnum));
+                else
+                    syslog(priority, "[%s:%d:%s] %d-%s: %s", file, line,
+                           function, graph_id, domain, *appmsgstr);
+            } else {
+                if (errnum)
+                    syslog(priority,
+                           "[%s:%d:%s] %s %d-%s:"
+                           " %s [%s]",
+                           file, line, function, callstr, graph_id, domain,
+                           *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority, "[%s:%d:%s] %s %d-%s: %s", file, line,
+                           function, callstr, graph_id, domain, *appmsgstr);
+            }
+            break;
+        case gf_logformat_withmsgid:
+            if (!callstr) {
+                if (errnum)
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %d-%s: %s [%s]",
+                           msgid, file, line, function, graph_id, domain,
+                           *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %d-%s: %s",
+                           msgid, file, line, function, graph_id, domain,
+                           *appmsgstr);
+            } else {
+                if (errnum)
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %s %d-%s: %s [%s]",
+                           msgid, file, line, function, callstr, graph_id,
+                           domain, *appmsgstr, strerror(errnum));
+                else
+                    syslog(priority,
+                           "[MSGID: %" PRIu64
+                           "]"
+                           " [%s:%d:%s] %s %d-%s: %s",
+                           msgid, file, line, function, callstr, graph_id,
+                           domain, *appmsgstr);
+            }
+            break;
+        case gf_logformat_cee:
+            /* TODO: Enhance CEE with additional parameters */
+            gf_syslog(priority, "[%s:%d:%s] %d-%s: %s", file, line, function,
+                      graph_id, domain, *appmsgstr);
+            break;
+
+        default:
+            /* NOTE: should not get here without logging */
+            break;
+    }
+
+    /* TODO: There can be no errors from gf_syslog? */
+    return 0;
 }
 
 static int
-gf_log_glusterlog (glusterfs_ctx_t *ctx, const char *domain, const char *file,
-                   const char *function, int32_t line, gf_loglevel_t level,
-                   int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
-                   struct timeval tv, int graph_id, gf_log_format_t fmt)
+gf_log_glusterlog(glusterfs_ctx_t *ctx, const char *domain, const char *file,
+                  const char *function, int32_t line, gf_loglevel_t level,
+                  int errnum, uint64_t msgid, char **appmsgstr, char *callstr,
+                  struct timeval tv, int graph_id, gf_log_format_t fmt)
 {
-        char             timestr[GF_LOG_TIMESTR_SIZE] = {0,};
-        char            *header = NULL;
-        char            *footer = NULL;
-        char            *msg  = NULL;
-        size_t           hlen  = 0, flen = 0, mlen = 0;
-        int              ret  = 0;
-
-        /* rotate if required */
-        gf_log_rotate(ctx);
-
-        /* format the time stamp */
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        /* generate header and footer */
-        if (fmt == gf_logformat_traditional) {
-                if (!callstr) {
-                        ret = gf_asprintf (&header, "[%s] %s [%s:%d:%s]"
-                                                    " %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           file, line, function, graph_id,
-                                           domain);
-                } else {
-                        ret = gf_asprintf (&header, "[%s] %s [%s:%d:%s] %s"
-                                                    " %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           file, line, function, callstr,
-                                           graph_id, domain);
-                }
-                if (-1 == ret) {
-                        goto err;
-                }
-        } else { /* gf_logformat_withmsgid */
-                /* CEE log format unsupported in logger_glusterlog, so just
-                 * print enhanced log format */
-                if (!callstr) {
-                        ret = gf_asprintf (&header, "[%s] %s [MSGID: %"PRIu64"]"
-                                                    " [%s:%d:%s] %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           msgid, file, line, function,
-                                           graph_id, domain);
-                } else {
-                        ret = gf_asprintf (&header, "[%s] %s [MSGID: %"PRIu64"]"
-                                                    " [%s:%d:%s] %s %d-%s: ",
-                                           timestr, gf_level_strings[level],
-                                           msgid, file, line, function, callstr,
-                                           graph_id, domain);
-                }
-                if (-1 == ret) {
-                        goto err;
-                }
+    char timestr[GF_LOG_TIMESTR_SIZE] = {
+        0,
+    };
+    char *header = NULL;
+    char *footer = NULL;
+    char *msg = NULL;
+    size_t hlen = 0, flen = 0, mlen = 0;
+    int ret = 0;
+
+    /* rotate if required */
+    gf_log_rotate(ctx);
+
+    /* format the time stamp */
+    gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+    snprintf(timestr + strlen(timestr), sizeof timestr - strlen(timestr),
+             ".%" GF_PRI_SUSECONDS, tv.tv_usec);
+
+    /* generate header and footer */
+    if (fmt == gf_logformat_traditional) {
+        if (!callstr) {
+            ret = gf_asprintf(&header,
+                              "[%s] %s [%s:%d:%s]"
+                              " %d-%s: ",
+                              timestr, gf_level_strings[level], file, line,
+                              function, graph_id, domain);
+        } else {
+            ret = gf_asprintf(&header,
+                              "[%s] %s [%s:%d:%s] %s"
+                              " %d-%s: ",
+                              timestr, gf_level_strings[level], file, line,
+                              function, callstr, graph_id, domain);
         }
-
-        if (errnum) {
-                ret = gf_asprintf (&footer, " [%s]",strerror(errnum));
-                if (-1 == ret) {
-                        goto err;
-                }
+        if (-1 == ret) {
+            goto err;
+        }
+    } else { /* gf_logformat_withmsgid */
+        /* CEE log format unsupported in logger_glusterlog, so just
+         * print enhanced log format */
+        if (!callstr) {
+            ret = gf_asprintf(&header,
+                              "[%s] %s [MSGID: %" PRIu64
+                              "]"
+                              " [%s:%d:%s] %d-%s: ",
+                              timestr, gf_level_strings[level], msgid, file,
+                              line, function, graph_id, domain);
+        } else {
+            ret = gf_asprintf(&header,
+                              "[%s] %s [MSGID: %" PRIu64
+                              "]"
+                              " [%s:%d:%s] %s %d-%s: ",
+                              timestr, gf_level_strings[level], msgid, file,
+                              line, function, callstr, graph_id, domain);
         }
-
-        /* generate the full message to log */
-        hlen = strlen (header);
-        flen = footer? strlen (footer) : 0;
-        mlen = strlen (*appmsgstr);
-        msg = GF_MALLOC (hlen + flen + mlen + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto err;
+        if (-1 == ret) {
+            goto err;
         }
+    }
 
-        strcpy (msg, header);
-        strcpy (msg + hlen, *appmsgstr);
-        if (footer)
-                strcpy (msg + hlen + mlen, footer);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
+    if (errnum) {
+        ret = gf_asprintf(&footer, " [%s]", strerror(errnum));
+        if (-1 == ret) {
+            goto err;
+        }
+    }
+
+    /* generate the full message to log */
+    hlen = strlen(header);
+    flen = footer ? strlen(footer) : 0;
+    mlen = strlen(*appmsgstr);
+    msg = GF_MALLOC(hlen + flen + mlen + 1, gf_common_mt_char);
+    if (!msg) {
+        ret = -1;
+        goto err;
+    }
+
+    strcpy(msg, header);
+    strcpy(msg + hlen, *appmsgstr);
+    if (footer)
+        strcpy(msg + hlen + mlen, footer);
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s\n", msg);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s\n", msg);
+            fflush(stderr);
+        }
 
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious logs in 'syslog', not our debug
-                 * and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                        (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious logs in 'syslog', not our debug
+         * and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s\n", msg);
 #endif
-        }
+    }
 
-        /* TODO: Plugin in memory log buffer retention here. For logs not
-         * flushed during cores, it would be useful to retain some of the last
-         * few messages in memory */
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        ret = 0;
+    /* TODO: Plugin in memory log buffer retention here. For logs not
+     * flushed during cores, it would be useful to retain some of the last
+     * few messages in memory */
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    ret = 0;
 
 err:
-        GF_FREE (msg);
-        GF_FREE (header);
-        GF_FREE (footer);
+    GF_FREE(msg);
+    GF_FREE(header);
+    GF_FREE(footer);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_syslog_log_repetitions (const char *domain, const char *file,
-                           const char *function, int32_t line,
-                           gf_loglevel_t level, int errnum, uint64_t msgid,
-                           char **appmsgstr, char *callstr, int refcount,
-                           struct timeval oldest, struct timeval latest,
-                           int graph_id)
+gf_syslog_log_repetitions(const char *domain, const char *file,
+                          const char *function, int32_t line,
+                          gf_loglevel_t level, int errnum, uint64_t msgid,
+                          char **appmsgstr, char *callstr, int refcount,
+                          struct timeval oldest, struct timeval latest,
+                          int graph_id)
 {
-        int              priority;
-        char             timestr_latest[256] = {0,};
-        char             timestr_oldest[256] = {0,};
-
-        SET_LOG_PRIO (level, priority);
-
-        gf_time_fmt (timestr_latest, sizeof timestr_latest, latest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_latest + strlen (timestr_latest),
-                  sizeof (timestr_latest) - strlen (timestr_latest),
-                  ".%"GF_PRI_SUSECONDS, latest.tv_usec);
-
-        gf_time_fmt (timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_oldest + strlen (timestr_oldest),
-                  sizeof (timestr_oldest) - strlen (timestr_oldest),
-                  ".%"GF_PRI_SUSECONDS, oldest.tv_usec);
-
-        if (errnum) {
-                syslog (priority, "The message \"[MSGID: %"PRIu64"] [%s:%d:%s] "
-                        "%d-%s: %s [%s] \" repeated %d times between %s and %s",
-                        msgid, file, line, function, graph_id, domain,
-                        *appmsgstr, strerror(errnum), refcount, timestr_oldest,
-                        timestr_latest);
-        } else {
-                syslog (priority, "The message \"[MSGID: %"PRIu64"] [%s:%d:%s] "
-                        "%d-%s: %s \" repeated %d times between %s and %s",
-                        msgid, file, line, function, graph_id, domain,
-                        *appmsgstr, refcount, timestr_oldest, timestr_latest);
-        }
-        return 0;
+    int priority;
+    char timestr_latest[256] = {
+        0,
+    };
+    char timestr_oldest[256] = {
+        0,
+    };
+
+    SET_LOG_PRIO(level, priority);
+
+    gf_time_fmt(timestr_latest, sizeof timestr_latest, latest.tv_sec,
+                gf_timefmt_FT);
+    snprintf(timestr_latest + strlen(timestr_latest),
+             sizeof(timestr_latest) - strlen(timestr_latest),
+             ".%" GF_PRI_SUSECONDS, latest.tv_usec);
+
+    gf_time_fmt(timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
+                gf_timefmt_FT);
+    snprintf(timestr_oldest + strlen(timestr_oldest),
+             sizeof(timestr_oldest) - strlen(timestr_oldest),
+             ".%" GF_PRI_SUSECONDS, oldest.tv_usec);
+
+    if (errnum) {
+        syslog(priority,
+               "The message \"[MSGID: %" PRIu64
+               "] [%s:%d:%s] "
+               "%d-%s: %s [%s] \" repeated %d times between %s and %s",
+               msgid, file, line, function, graph_id, domain, *appmsgstr,
+               strerror(errnum), refcount, timestr_oldest, timestr_latest);
+    } else {
+        syslog(priority,
+               "The message \"[MSGID: %" PRIu64
+               "] [%s:%d:%s] "
+               "%d-%s: %s \" repeated %d times between %s and %s",
+               msgid, file, line, function, graph_id, domain, *appmsgstr,
+               refcount, timestr_oldest, timestr_latest);
+    }
+    return 0;
 }
 
 static int
-gf_glusterlog_log_repetitions (glusterfs_ctx_t *ctx, const char *domain,
-                               const char *file, const char *function,
-                               int32_t line, gf_loglevel_t level, int errnum,
-                               uint64_t msgid, char **appmsgstr, char *callstr,
-                               int refcount, struct timeval oldest,
-                               struct timeval latest, int graph_id)
+gf_glusterlog_log_repetitions(glusterfs_ctx_t *ctx, const char *domain,
+                              const char *file, const char *function,
+                              int32_t line, gf_loglevel_t level, int errnum,
+                              uint64_t msgid, char **appmsgstr, char *callstr,
+                              int refcount, struct timeval oldest,
+                              struct timeval latest, int graph_id)
 {
-        int              ret                 = 0;
-        size_t           hlen                = 0;
-        size_t           flen                = 0;
-        size_t           mlen                = 0;
-        char             timestr_latest[256] = {0,};
-        char             timestr_oldest[256] = {0,};
-        char             errstr[256]         = {0,};
-        char            *header              = NULL;
-        char            *footer              = NULL;
-        char            *msg                 = NULL;
-
-        if (!ctx)
-                goto err;
-
-        gf_log_rotate (ctx);
-
-        gf_time_fmt (timestr_latest, sizeof timestr_latest, latest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_latest + strlen (timestr_latest),
-                  sizeof (timestr_latest) - strlen (timestr_latest),
-                  ".%"GF_PRI_SUSECONDS, latest.tv_usec);
-
-        gf_time_fmt (timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
-                     gf_timefmt_FT);
-        snprintf (timestr_oldest + strlen (timestr_oldest),
-                  sizeof (timestr_oldest) - strlen (timestr_oldest),
-                  ".%"GF_PRI_SUSECONDS, oldest.tv_usec);
-
-        ret = gf_asprintf (&header, "The message \"%s [MSGID: %"PRIu64"]"
-                           " [%s:%d:%s] %d-%s: ", gf_level_strings[level],
-                           msgid, file, line, function, graph_id, domain);
-        if (-1 == ret)
-                goto err;
-
-        if (errnum)
-                snprintf (errstr, sizeof (errstr) - 1, " [%s]",
-                          strerror (errnum));
-
-        ret = gf_asprintf (&footer, "%s\" repeated %d times between"
-                           " [%s] and [%s]", errstr, refcount, timestr_oldest,
-                           timestr_latest);
-        if (-1 == ret)
-                goto err;
-
-        /* generate the full message to log */
-        hlen = strlen (header);
-        flen = strlen (footer);
-        mlen = strlen (*appmsgstr);
-        msg = GF_MALLOC (hlen + flen + mlen + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto err;
+    int ret = 0;
+    size_t hlen = 0;
+    size_t flen = 0;
+    size_t mlen = 0;
+    char timestr_latest[256] = {
+        0,
+    };
+    char timestr_oldest[256] = {
+        0,
+    };
+    char errstr[256] = {
+        0,
+    };
+    char *header = NULL;
+    char *footer = NULL;
+    char *msg = NULL;
+
+    if (!ctx)
+        goto err;
+
+    gf_log_rotate(ctx);
+
+    gf_time_fmt(timestr_latest, sizeof timestr_latest, latest.tv_sec,
+                gf_timefmt_FT);
+    snprintf(timestr_latest + strlen(timestr_latest),
+             sizeof(timestr_latest) - strlen(timestr_latest),
+             ".%" GF_PRI_SUSECONDS, latest.tv_usec);
+
+    gf_time_fmt(timestr_oldest, sizeof timestr_oldest, oldest.tv_sec,
+                gf_timefmt_FT);
+    snprintf(timestr_oldest + strlen(timestr_oldest),
+             sizeof(timestr_oldest) - strlen(timestr_oldest),
+             ".%" GF_PRI_SUSECONDS, oldest.tv_usec);
+
+    ret = gf_asprintf(&header,
+                      "The message \"%s [MSGID: %" PRIu64
+                      "]"
+                      " [%s:%d:%s] %d-%s: ",
+                      gf_level_strings[level], msgid, file, line, function,
+                      graph_id, domain);
+    if (-1 == ret)
+        goto err;
+
+    if (errnum)
+        snprintf(errstr, sizeof(errstr) - 1, " [%s]", strerror(errnum));
+
+    ret = gf_asprintf(&footer,
+                      "%s\" repeated %d times between"
+                      " [%s] and [%s]",
+                      errstr, refcount, timestr_oldest, timestr_latest);
+    if (-1 == ret)
+        goto err;
+
+    /* generate the full message to log */
+    hlen = strlen(header);
+    flen = strlen(footer);
+    mlen = strlen(*appmsgstr);
+    msg = GF_MALLOC(hlen + flen + mlen + 1, gf_common_mt_char);
+    if (!msg) {
+        ret = -1;
+        goto err;
+    }
+
+    strcpy(msg, header);
+    strcpy(msg + hlen, *appmsgstr);
+    strcpy(msg + hlen + mlen, footer);
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s\n", msg);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s\n", msg);
+            fflush(stderr);
         }
 
-        strcpy (msg, header);
-        strcpy (msg + hlen, *appmsgstr);
-        strcpy (msg + hlen + mlen, footer);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious logs in 'syslog', not our debug
-                 * and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                        (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious logs in 'syslog', not our debug
+         * and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s\n", msg);
 #endif
-        }
+    }
 
-        /* TODO: Plugin in memory log buffer retention here. For logs not
-         * flushed during cores, it would be useful to retain some of the last
-         * few messages in memory */
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-        ret = 0;
+    /* TODO: Plugin in memory log buffer retention here. For logs not
+     * flushed during cores, it would be useful to retain some of the last
+     * few messages in memory */
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    ret = 0;
 
 err:
-        GF_FREE (msg);
-        GF_FREE (header);
-        GF_FREE (footer);
+    GF_FREE(msg);
+    GF_FREE(header);
+    GF_FREE(footer);
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_log_print_with_repetitions (glusterfs_ctx_t *ctx, const char *domain,
-                               const char *file, const char *function,
-                               int32_t line, gf_loglevel_t level, int errnum,
-                               uint64_t msgid, char **appmsgstr, char *callstr,
-                               int refcount, struct timeval oldest,
-                               struct timeval latest, int graph_id)
+gf_log_print_with_repetitions(glusterfs_ctx_t *ctx, const char *domain,
+                              const char *file, const char *function,
+                              int32_t line, gf_loglevel_t level, int errnum,
+                              uint64_t msgid, char **appmsgstr, char *callstr,
+                              int refcount, struct timeval oldest,
+                              struct timeval latest, int graph_id)
 {
-        int               ret    = -1;
-        gf_log_logger_t   logger = 0;
-
-        logger = ctx->log.logger;
-
-
-        switch (logger) {
-                case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        ret = gf_syslog_log_repetitions (domain, file, function,
-                                                         line, level, errnum,
-                                                         msgid, appmsgstr,
-                                                         callstr, refcount,
-                                                         oldest, latest,
-                                                         graph_id);
-                        break;
-                }
-                case gf_logger_glusterlog:
-                ret = gf_glusterlog_log_repetitions (ctx, domain, file,
-                                                     function, line, level,
-                                                     errnum, msgid, appmsgstr,
-                                                     callstr, refcount, oldest,
-                                                     latest, graph_id);
+    int ret = -1;
+    gf_log_logger_t logger = 0;
+
+    logger = ctx->log.logger;
+
+    switch (logger) {
+        case gf_logger_syslog:
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                ret = gf_syslog_log_repetitions(
+                    domain, file, function, line, level, errnum, msgid,
+                    appmsgstr, callstr, refcount, oldest, latest, graph_id);
                 break;
-        }
+            }
+        case gf_logger_glusterlog:
+            ret = gf_glusterlog_log_repetitions(
+                ctx, domain, file, function, line, level, errnum, msgid,
+                appmsgstr, callstr, refcount, oldest, latest, graph_id);
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-gf_log_print_plain_fmt (glusterfs_ctx_t *ctx, const char *domain,
-                        const char *file, const char *function, int32_t line,
-                        gf_loglevel_t level, int errnum, uint64_t msgid,
-                        char **appmsgstr, char *callstr, struct timeval tv,
-                        int graph_id, gf_log_format_t fmt)
+gf_log_print_plain_fmt(glusterfs_ctx_t *ctx, const char *domain,
+                       const char *file, const char *function, int32_t line,
+                       gf_loglevel_t level, int errnum, uint64_t msgid,
+                       char **appmsgstr, char *callstr, struct timeval tv,
+                       int graph_id, gf_log_format_t fmt)
 {
-        int               ret    = -1;
-        gf_log_logger_t   logger = 0;
+    int ret = -1;
+    gf_log_logger_t logger = 0;
 
-        logger = ctx->log.logger;
+    logger = ctx->log.logger;
 
-        /* log to the configured logging service */
-        switch (logger) {
+    /* log to the configured logging service */
+    switch (logger) {
         case gf_logger_syslog:
-                if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
-                        ret = gf_log_syslog (ctx, domain, file, function, line,
-                                             level, errnum, msgid, appmsgstr,
-                                             callstr, graph_id, fmt);
-                        break;
-                }
-                /* NOTE: If syslog control file is absent, which is another
-                 * way to control logging to syslog, then we will fall through
-                 * to the gluster log. The ideal way to do things would be to
-                 * not have the extra control file check */
-        case gf_logger_glusterlog:
-                ret = gf_log_glusterlog (ctx, domain, file, function, line,
-                                         level, errnum, msgid, appmsgstr,
-                                         callstr, tv, graph_id, fmt);
+            if (ctx->log.log_control_file_found && ctx->log.gf_log_syslog) {
+                ret = gf_log_syslog(ctx, domain, file, function, line, level,
+                                    errnum, msgid, appmsgstr, callstr, graph_id,
+                                    fmt);
                 break;
-        }
+            }
+            /* NOTE: If syslog control file is absent, which is another
+             * way to control logging to syslog, then we will fall through
+             * to the gluster log. The ideal way to do things would be to
+             * not have the extra control file check */
+        case gf_logger_glusterlog:
+            ret = gf_log_glusterlog(ctx, domain, file, function, line, level,
+                                    errnum, msgid, appmsgstr, callstr, tv,
+                                    graph_id, fmt);
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-gf_log_flush_message (log_buf_t *buf, glusterfs_ctx_t *ctx)
+gf_log_flush_message(log_buf_t *buf, glusterfs_ctx_t *ctx)
 {
-        if (buf->refcount == 1) {
-                (void) gf_log_print_plain_fmt (ctx, buf->domain, buf->file,
-                                               buf->function, buf->line,
-                                               buf->level, buf->errnum,
-                                               buf->msg_id, &buf->msg, NULL,
-                                               buf->latest, buf->graph_id,
-                                               gf_logformat_withmsgid);
-        }
-
-        if (buf->refcount > 1) {
-                gf_log_print_with_repetitions (ctx, buf->domain, buf->file,
-                                               buf->function, buf->line,
-                                               buf->level, buf->errnum,
-                                               buf->msg_id, &buf->msg, NULL,
-                                               buf->refcount, buf->oldest,
-                                               buf->latest, buf->graph_id);
-        }
-        return;
+    if (buf->refcount == 1) {
+        (void)gf_log_print_plain_fmt(ctx, buf->domain, buf->file, buf->function,
+                                     buf->line, buf->level, buf->errnum,
+                                     buf->msg_id, &buf->msg, NULL, buf->latest,
+                                     buf->graph_id, gf_logformat_withmsgid);
+    }
+
+    if (buf->refcount > 1) {
+        gf_log_print_with_repetitions(
+            ctx, buf->domain, buf->file, buf->function, buf->line, buf->level,
+            buf->errnum, buf->msg_id, &buf->msg, NULL, buf->refcount,
+            buf->oldest, buf->latest, buf->graph_id);
+    }
+    return;
 }
 
 static void
-gf_log_flush_list (struct list_head *copy, glusterfs_ctx_t *ctx)
+gf_log_flush_list(struct list_head *copy, glusterfs_ctx_t *ctx)
 {
-        log_buf_t        *iter = NULL;
-        log_buf_t        *tmp  = NULL;
-
-        list_for_each_entry_safe (iter, tmp, copy, msg_list) {
-                gf_log_flush_message (iter, ctx);
-                list_del_init (&iter->msg_list);
-                log_buf_destroy (iter);
-        }
+    log_buf_t *iter = NULL;
+    log_buf_t *tmp = NULL;
+
+    list_for_each_entry_safe(iter, tmp, copy, msg_list)
+    {
+        gf_log_flush_message(iter, ctx);
+        list_del_init(&iter->msg_list);
+        log_buf_destroy(iter);
+    }
 }
 
 void
-gf_log_flush_msgs (glusterfs_ctx_t *ctx)
+gf_log_flush_msgs(glusterfs_ctx_t *ctx)
 {
-        struct list_head copy;
+    struct list_head copy;
 
-        INIT_LIST_HEAD (&copy);
+    INIT_LIST_HEAD(&copy);
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                list_splice_init (&ctx->log.lru_queue, &copy);
-                ctx->log.lru_cur_size = 0;
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        list_splice_init(&ctx->log.lru_queue, &copy);
+        ctx->log.lru_cur_size = 0;
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 
-        gf_log_flush_list (&copy, ctx);
+    gf_log_flush_list(&copy, ctx);
 
-        return;
+    return;
 }
 
 static void
-gf_log_flush_extra_msgs (glusterfs_ctx_t *ctx, uint32_t new)
+gf_log_flush_extra_msgs(glusterfs_ctx_t *ctx, uint32_t new)
 {
-        int               count = 0;
-        int                   i = 0;
-        log_buf_t        *iter  = NULL;
-        log_buf_t        *tmp   = NULL;
-        struct list_head copy;
-
-        INIT_LIST_HEAD (&copy);
-
-        /* If the number of outstanding log messages does not cause list
-         * overflow even after reducing the size of the list, then do nothing.
-         * Otherwise (that is if there are more items in the list than there
-         * need to be after reducing its size), move the least recently used
-         * 'diff' elements to be flushed into a separate list...
-         */
-
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
+    int count = 0;
+    int i = 0;
+    log_buf_t *iter = NULL;
+    log_buf_t *tmp = NULL;
+    struct list_head copy;
+
+    INIT_LIST_HEAD(&copy);
+
+    /* If the number of outstanding log messages does not cause list
+     * overflow even after reducing the size of the list, then do nothing.
+     * Otherwise (that is if there are more items in the list than there
+     * need to be after reducing its size), move the least recently used
+     * 'diff' elements to be flushed into a separate list...
+     */
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        if (ctx->log.lru_cur_size <= new)
+            goto unlock;
+        count = ctx->log.lru_cur_size - new;
+        list_for_each_entry_safe(iter, tmp, &ctx->log.lru_queue, msg_list)
         {
-                if (ctx->log.lru_cur_size <= new)
-                        goto unlock;
-                count = ctx->log.lru_cur_size - new;
-                list_for_each_entry_safe (iter, tmp, &ctx->log.lru_queue,
-                                          msg_list) {
-                        if (i == count)
-                                break;
-
-                        list_del_init (&iter->msg_list);
-                        list_add_tail (&iter->msg_list, &copy);
-                        i++;
-                }
-                ctx->log.lru_cur_size = ctx->log.lru_cur_size - count;
+            if (i == count)
+                break;
+
+            list_del_init(&iter->msg_list);
+            list_add_tail(&iter->msg_list, &copy);
+            i++;
         }
-        // ... quickly unlock ...
+        ctx->log.lru_cur_size = ctx->log.lru_cur_size - count;
+    }
+    // ... quickly unlock ...
 unlock:
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
-        if (list_empty (&copy))
-                return;
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+    if (list_empty(&copy))
+        return;
 
-        TEST_LOG("Log buffer size reduced. About to flush %d extra log "
-                 "messages", count);
-        // ... and then flush them outside the lock.
-        gf_log_flush_list (&copy, ctx);
-        TEST_LOG("Just flushed %d extra log messages", count);
+    TEST_LOG(
+        "Log buffer size reduced. About to flush %d extra log "
+        "messages",
+        count);
+    // ... and then flush them outside the lock.
+    gf_log_flush_list(&copy, ctx);
+    TEST_LOG("Just flushed %d extra log messages", count);
 
-        return;
+    return;
 }
 
 static int
-__gf_log_inject_timer_event (glusterfs_ctx_t *ctx)
+__gf_log_inject_timer_event(glusterfs_ctx_t *ctx)
 {
-        int              ret      = -1;
-        struct timespec  timeout  = {0,};
+    int ret = -1;
+    struct timespec timeout = {
+        0,
+    };
 
-        if (!ctx)
-                goto out;
+    if (!ctx)
+        goto out;
 
-        if (ctx->log.log_flush_timer) {
-                gf_timer_call_cancel (ctx, ctx->log.log_flush_timer);
-                ctx->log.log_flush_timer = NULL;
-        }
+    if (ctx->log.log_flush_timer) {
+        gf_timer_call_cancel(ctx, ctx->log.log_flush_timer);
+        ctx->log.log_flush_timer = NULL;
+    }
 
-        timeout.tv_sec  = ctx->log.timeout;
-        timeout.tv_nsec = 0;
+    timeout.tv_sec = ctx->log.timeout;
+    timeout.tv_nsec = 0;
 
-        TEST_LOG("Starting timer now. Timeout = %u, current buf size = %d",
-                 ctx->log.timeout, ctx->log.lru_size);
-        ctx->log.log_flush_timer = gf_timer_call_after (ctx, timeout,
-                                                      gf_log_flush_timeout_cbk,
-                                                        (void *)ctx);
-        if (!ctx->log.log_flush_timer)
-                goto out;
+    TEST_LOG("Starting timer now. Timeout = %u, current buf size = %d",
+             ctx->log.timeout, ctx->log.lru_size);
+    ctx->log.log_flush_timer = gf_timer_call_after(
+        ctx, timeout, gf_log_flush_timeout_cbk, (void *)ctx);
+    if (!ctx->log.log_flush_timer)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-gf_log_inject_timer_event (glusterfs_ctx_t *ctx)
+gf_log_inject_timer_event(glusterfs_ctx_t *ctx)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!ctx)
-                return -1;
+    if (!ctx)
+        return -1;
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                ret = __gf_log_inject_timer_event (ctx);
-        }
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        ret = __gf_log_inject_timer_event(ctx);
+    }
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
 
-        return ret;
+    return ret;
 }
 
 void
-gf_log_flush_timeout_cbk (void *data)
+gf_log_flush_timeout_cbk(void *data)
 {
-        glusterfs_ctx_t  *ctx  = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = (glusterfs_ctx_t *) data;
+    ctx = (glusterfs_ctx_t *)data;
 
-        TEST_LOG("Log timer timed out. About to flush outstanding messages if "
-                 "present");
-        gf_log_flush_msgs (ctx);
+    TEST_LOG(
+        "Log timer timed out. About to flush outstanding messages if "
+        "present");
+    gf_log_flush_msgs(ctx);
 
-        (void) gf_log_inject_timer_event (ctx);
+    (void)gf_log_inject_timer_event(ctx);
 
-        return;
+    return;
 }
 
 static int
-_gf_msg_internal (const char *domain, const char *file, const char *function,
-                  int32_t line, gf_loglevel_t level, int errnum, uint64_t msgid,
-                  char **appmsgstr, char *callstr, int graph_id)
+_gf_msg_internal(const char *domain, const char *file, const char *function,
+                 int32_t line, gf_loglevel_t level, int errnum, uint64_t msgid,
+                 char **appmsgstr, char *callstr, int graph_id)
 {
-        int              ret              = -1;
-        uint32_t         size             = 0;
-        const char      *basename         = NULL;
-        xlator_t        *this             = NULL;
-        glusterfs_ctx_t *ctx              = NULL;
-        log_buf_t       *iter             = NULL;
-        log_buf_t       *buf_tmp          = NULL;
-        log_buf_t       *buf_new          = NULL;
-        log_buf_t       *first            = NULL;
-        struct timeval   tv               = {0,};
-        gf_boolean_t     found            = _gf_false;
-        gf_boolean_t     flush_lru        = _gf_false;
-        gf_boolean_t     flush_logged_msg = _gf_false;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
+    int ret = -1;
+    uint32_t size = 0;
+    const char *basename = NULL;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    log_buf_t *iter = NULL;
+    log_buf_t *buf_tmp = NULL;
+    log_buf_t *buf_new = NULL;
+    log_buf_t *first = NULL;
+    struct timeval tv = {
+        0,
+    };
+    gf_boolean_t found = _gf_false;
+    gf_boolean_t flush_lru = _gf_false;
+    gf_boolean_t flush_logged_msg = _gf_false;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    GET_FILE_NAME_TO_LOG(file, basename);
+
+    ret = gettimeofday(&tv, NULL);
+    if (ret)
+        goto out;
+
+    /* If this function is called via _gf_msg_callingfn () (indicated by a
+     * non-NULL callstr), or if the logformat is traditional, flush the
+     * message directly to disk.
+     */
+
+    if ((callstr) || (ctx->log.logformat == gf_logformat_traditional)) {
+        ret = gf_log_print_plain_fmt(ctx, domain, basename, function, line,
+                                     level, errnum, msgid, appmsgstr, callstr,
+                                     tv, graph_id, gf_logformat_traditional);
+        goto out;
+    }
+
+    pthread_mutex_lock(&ctx->log.log_buf_lock);
+    {
+        /* Check if the msg being logged is already part of the list */
+        list_for_each_entry_safe_reverse(iter, buf_tmp, &ctx->log.lru_queue,
+                                         msg_list)
+        {
+            if (first == NULL)
+                // Remember the first (lru) element in first ptr
+                first = iter;
 
-        GET_FILE_NAME_TO_LOG (file, basename);
+            /* Try to fail the search early on by doing the less
+             * expensive integer comparisons and continue to string
+             * parameter comparisons only after all int parameters
+             * are found to be matching.
+             */
+            if (line != iter->line)
+                continue;
 
-        ret = gettimeofday (&tv, NULL);
-        if (ret)
-                goto out;
+            if (errnum != iter->errnum)
+                continue;
 
-        /* If this function is called via _gf_msg_callingfn () (indicated by a
-         * non-NULL callstr), or if the logformat is traditional, flush the
-         * message directly to disk.
-         */
+            if (msgid != iter->msg_id)
+                continue;
 
-        if ((callstr) || (ctx->log.logformat == gf_logformat_traditional)) {
-                ret = gf_log_print_plain_fmt (ctx, domain, basename, function,
-                                              line, level, errnum, msgid,
-                                              appmsgstr, callstr, tv, graph_id,
-                                              gf_logformat_traditional);
-                goto out;
-        }
+            if (level != iter->level)
+                continue;
 
-        pthread_mutex_lock (&ctx->log.log_buf_lock);
-        {
-                /* Check if the msg being logged is already part of the list */
-                list_for_each_entry_safe_reverse (iter, buf_tmp,
-                                                  &ctx->log.lru_queue,
-                                                  msg_list) {
-                        if (first == NULL)
-                                // Remember the first (lru) element in first ptr
-                                first = iter;
-
-                        /* Try to fail the search early on by doing the less
-                         * expensive integer comparisons and continue to string
-                         * parameter comparisons only after all int parameters
-                         * are found to be matching.
-                         */
-                        if (line != iter->line)
-                                continue;
-
-                        if (errnum != iter->errnum)
-                                continue;
-
-                        if (msgid != iter->msg_id)
-                                continue;
-
-                        if (level != iter->level)
-                                continue;
-
-                        if (graph_id != iter->graph_id)
-                                continue;
-
-                        if (strcmp (domain, iter->domain))
-                                continue;
-
-                        if (strcmp (basename, iter->file))
-                                continue;
-
-                        if (strcmp (function, iter->function))
-                                continue;
-
-                        if (strcmp (*appmsgstr, iter->msg))
-                                continue;
-
-                        //Ah! Found a match!
-                        list_move_tail (&iter->msg_list, &ctx->log.lru_queue);
-                        iter->refcount++;
-                        found = _gf_true;
-                        //Update the 'latest' timestamp.
-                        memcpy ((void *)&(iter->latest), (void *)&tv,
-                                sizeof (struct timeval));
-                        break;
-                }
-                if (found) {
-                        ret = 0;
-                        goto unlock;
-                }
-                // else ...
-
-                size = ctx->log.lru_size;
-                /* If the upper limit on the log buf size is 0, flush the msg to
-                 * disk directly after unlock. There's no need to buffer the
-                 * msg here.
-                 */
-                if (size == 0) {
-                        flush_logged_msg = _gf_true;
-                        goto unlock;
-                } else if ((ctx->log.lru_cur_size + 1) > size) {
-                /* If the list is full, flush the lru msg to disk and also
-                 * release it after unlock, and ...
-                 * */
-                if (first->refcount >= 1)
-                        TEST_LOG("Buffer overflow of a buffer whose size limit "
-                                 "is %d. About to flush least recently used log"
-                                 " message to disk", size);
-                        list_del_init (&first->msg_list);
-                        ctx->log.lru_cur_size--;
-                        flush_lru = _gf_true;
-                }
-                /* create a new list element, initialise and enqueue it.
-                 * Additionally, this being the first occurrence of the msg,
-                 * log it directly to disk after unlock. */
-                buf_new = log_buf_new ();
-                if (!buf_new) {
-                        ret = -1;
-                        goto unlock;
-                }
-                ret = log_buf_init (buf_new, domain, basename, function, line,
-                                    level, errnum, msgid, appmsgstr, graph_id);
-                if (ret) {
-                        log_buf_destroy (buf_new);
-                        goto unlock;
-                }
+            if (graph_id != iter->graph_id)
+                continue;
 
-                memcpy ((void *)&(buf_new->latest), (void *)&tv,
-                        sizeof (struct timeval));
-                memcpy ((void *)&(buf_new->oldest), (void *)&tv,
-                        sizeof (struct timeval));
+            if (strcmp(domain, iter->domain))
+                continue;
 
-                list_add_tail (&buf_new->msg_list, &ctx->log.lru_queue);
-                ctx->log.lru_cur_size++;
-                flush_logged_msg = _gf_true;
-                ret = 0;
-        }
-unlock:
-        pthread_mutex_unlock (&ctx->log.log_buf_lock);
+            if (strcmp(basename, iter->file))
+                continue;
 
-        /* Value of @ret is a don't-care below since irrespective of success or
-         * failure post setting of @flush_lru, @first must be flushed and freed.
-         */
-        if (flush_lru) {
-                gf_log_flush_message (first, ctx);
-                log_buf_destroy (first);
+            if (strcmp(function, iter->function))
+                continue;
+
+            if (strcmp(*appmsgstr, iter->msg))
+                continue;
+
+            // Ah! Found a match!
+            list_move_tail(&iter->msg_list, &ctx->log.lru_queue);
+            iter->refcount++;
+            found = _gf_true;
+            // Update the 'latest' timestamp.
+            memcpy((void *)&(iter->latest), (void *)&tv,
+                   sizeof(struct timeval));
+            break;
         }
-        /* Similarly, irrespective of whether all operations since setting of
-         * @flush_logged_msg were successful or not, flush the message being
-         * logged to disk in the plain format.
-         */
-        if (flush_logged_msg) {
-                ret = gf_log_print_plain_fmt (ctx, domain, basename,
-                                              function, line, level,
-                                              errnum, msgid, appmsgstr,
-                                              callstr, tv, graph_id,
-                                              gf_logformat_withmsgid);
+        if (found) {
+            ret = 0;
+            goto unlock;
         }
+        // else ...
+
+        size = ctx->log.lru_size;
+        /* If the upper limit on the log buf size is 0, flush the msg to
+         * disk directly after unlock. There's no need to buffer the
+         * msg here.
+         */
+        if (size == 0) {
+            flush_logged_msg = _gf_true;
+            goto unlock;
+        } else if ((ctx->log.lru_cur_size + 1) > size) {
+            /* If the list is full, flush the lru msg to disk and also
+             * release it after unlock, and ...
+             * */
+            if (first->refcount >= 1)
+                TEST_LOG(
+                    "Buffer overflow of a buffer whose size limit "
+                    "is %d. About to flush least recently used log"
+                    " message to disk",
+                    size);
+            list_del_init(&first->msg_list);
+            ctx->log.lru_cur_size--;
+            flush_lru = _gf_true;
+        }
+        /* create a new list element, initialise and enqueue it.
+         * Additionally, this being the first occurrence of the msg,
+         * log it directly to disk after unlock. */
+        buf_new = log_buf_new();
+        if (!buf_new) {
+            ret = -1;
+            goto unlock;
+        }
+        ret = log_buf_init(buf_new, domain, basename, function, line, level,
+                           errnum, msgid, appmsgstr, graph_id);
+        if (ret) {
+            log_buf_destroy(buf_new);
+            goto unlock;
+        }
+
+        memcpy((void *)&(buf_new->latest), (void *)&tv, sizeof(struct timeval));
+        memcpy((void *)&(buf_new->oldest), (void *)&tv, sizeof(struct timeval));
+
+        list_add_tail(&buf_new->msg_list, &ctx->log.lru_queue);
+        ctx->log.lru_cur_size++;
+        flush_logged_msg = _gf_true;
+        ret = 0;
+    }
+unlock:
+    pthread_mutex_unlock(&ctx->log.log_buf_lock);
+
+    /* Value of @ret is a don't-care below since irrespective of success or
+     * failure post setting of @flush_lru, @first must be flushed and freed.
+     */
+    if (flush_lru) {
+        gf_log_flush_message(first, ctx);
+        log_buf_destroy(first);
+    }
+    /* Similarly, irrespective of whether all operations since setting of
+     * @flush_logged_msg were successful or not, flush the message being
+     * logged to disk in the plain format.
+     */
+    if (flush_logged_msg) {
+        ret = gf_log_print_plain_fmt(ctx, domain, basename, function, line,
+                                     level, errnum, msgid, appmsgstr, callstr,
+                                     tv, graph_id, gf_logformat_withmsgid);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-_gf_msg (const char *domain, const char *file, const char *function,
-         int32_t line, gf_loglevel_t level, int errnum, int trace,
-         uint64_t msgid, const char *fmt, ...)
+_gf_msg(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, int errnum, int trace,
+        uint64_t msgid, const char *fmt, ...)
 {
-        int              ret = 0;
-        char            *msgstr = NULL;
-        va_list          ap;
-        xlator_t        *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-        char             callstr[GF_LOG_BACKTRACE_SIZE] = {0,};
-        int              passcallstr = 0;
-        int              log_inited = 0;
-
-        /* in args check */
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
-        }
-
-        this = THIS;
-
-        if (this == NULL)
-                return -1;
-
-        ctx = this->ctx;
-        if (ctx == NULL) {
-                /* messages before context initialization are ignored */
-                return -1;
-        }
-
-        /* check if we should be logging */
-        if (skip_logging (this, level))
-                goto out;
-
-        if (trace) {
-                ret = _gf_msg_backtrace (GF_LOG_BACKTRACE_DEPTH, callstr,
-                                         GF_LOG_BACKTRACE_SIZE);
-                if (ret >= 0)
-                        passcallstr = 1;
-                else
-                        ret = 0;
-        }
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-                if (ctx->log.logfile) {
-                        log_inited = 1;
-                }
-        }
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
-
-        /* form the message */
-        va_start (ap, fmt);
-        ret = vasprintf (&msgstr, fmt, ap);
-        va_end (ap);
-
-        /* log */
-        if (ret != -1) {
-                if (!log_inited && ctx->log.gf_log_syslog) {
-                        ret = gf_log_syslog (ctx, domain, file, function, line,
-                                            level, errnum, msgid, &msgstr,
-                                            (passcallstr? callstr : NULL),
-                                            (this->graph)? this->graph->id : 0,
-                                            gf_logformat_traditional);
-                } else {
-                        ret = _gf_msg_internal (domain, file, function, line,
-                                            level, errnum, msgid, &msgstr,
-                                            (passcallstr? callstr : NULL),
-                                            (this->graph)? this->graph->id : 0);
-                }
+    int ret = 0;
+    char *msgstr = NULL;
+    va_list ap;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    char callstr[GF_LOG_BACKTRACE_SIZE] = {
+        0,
+    };
+    int passcallstr = 0;
+    int log_inited = 0;
+
+    /* in args check */
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    this = THIS;
+
+    if (this == NULL)
+        return -1;
+
+    ctx = this->ctx;
+    if (ctx == NULL) {
+        /* messages before context initialization are ignored */
+        return -1;
+    }
+
+    /* check if we should be logging */
+    if (skip_logging(this, level))
+        goto out;
+
+    if (trace) {
+        ret = _gf_msg_backtrace(GF_LOG_BACKTRACE_DEPTH, callstr,
+                                GF_LOG_BACKTRACE_SIZE);
+        if (ret >= 0)
+            passcallstr = 1;
+        else
+            ret = 0;
+    }
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            log_inited = 1;
+        }
+    }
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
+
+    /* form the message */
+    va_start(ap, fmt);
+    ret = vasprintf(&msgstr, fmt, ap);
+    va_end(ap);
+
+    /* log */
+    if (ret != -1) {
+        if (!log_inited && ctx->log.gf_log_syslog) {
+            ret = gf_log_syslog(
+                ctx, domain, file, function, line, level, errnum, msgid,
+                &msgstr, (passcallstr ? callstr : NULL),
+                (this->graph) ? this->graph->id : 0, gf_logformat_traditional);
         } else {
-                /* man (3) vasprintf states on error strp contents
-                 * are undefined, be safe */
-                msgstr = NULL;
+            ret = _gf_msg_internal(domain, file, function, line, level, errnum,
+                                   msgid, &msgstr,
+                                   (passcallstr ? callstr : NULL),
+                                   (this->graph) ? this->graph->id : 0);
         }
+    } else {
+        /* man (3) vasprintf states on error strp contents
+         * are undefined, be safe */
+        msgstr = NULL;
+    }
 
-        FREE (msgstr);
+    FREE(msgstr);
 
 out:
-        return ret;
+    return ret;
 }
 
 /* TODO: Deprecate (delete) _gf_log, _gf_log_callingfn,
  * once messages are changed to use _gf_msgXXX APIs for logging */
 int
-_gf_log (const char *domain, const char *file, const char *function, int line,
-         gf_loglevel_t level, const char *fmt, ...)
+_gf_log(const char *domain, const char *file, const char *function, int line,
+        gf_loglevel_t level, const char *fmt, ...)
 {
-        const char    *basename = NULL;
-        FILE          *new_logfile = NULL;
-        va_list        ap;
-        char           timestr[GF_LOG_TIMESTR_SIZE] = {0,};
-        struct timeval tv = {0,};
-        char          *str1 = NULL;
-        char          *str2 = NULL;
-        char          *msg  = NULL;
-        size_t         len  = 0;
-        int            ret  = 0;
-        int            fd   = -1;
-        xlator_t      *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx = this->ctx;
-
-        if (!ctx)
-                goto out;
-
-        if (skip_logging (this, level))
-                goto out;
-
-        static char *level_strings[] = {"",  /* NONE */
-                                        "M", /* EMERGENCY */
-                                        "A", /* ALERT */
-                                        "C", /* CRITICAL */
-                                        "E", /* ERROR */
-                                        "W", /* WARNING */
-                                        "N", /* NOTICE */
-                                        "I", /* INFO */
-                                        "D", /* DEBUG */
-                                        "T", /* TRACE */
-                                        ""};
-
-        if (!domain || !file || !function || !fmt) {
-                fprintf (stderr,
-                         "logging: %s:%s():%d: invalid argument\n",
-                         __FILE__, __PRETTY_FUNCTION__, __LINE__);
-                return -1;
+    const char *basename = NULL;
+    FILE *new_logfile = NULL;
+    va_list ap;
+    char timestr[GF_LOG_TIMESTR_SIZE] = {
+        0,
+    };
+    struct timeval tv = {
+        0,
+    };
+    char *str1 = NULL;
+    char *str2 = NULL;
+    char *msg = NULL;
+    size_t len = 0;
+    int ret = 0;
+    int fd = -1;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        goto out;
+
+    if (skip_logging(this, level))
+        goto out;
+
+    static char *level_strings[] = {"",  /* NONE */
+                                    "M", /* EMERGENCY */
+                                    "A", /* ALERT */
+                                    "C", /* CRITICAL */
+                                    "E", /* ERROR */
+                                    "W", /* WARNING */
+                                    "N", /* NOTICE */
+                                    "I", /* INFO */
+                                    "D", /* DEBUG */
+                                    "T", /* TRACE */
+                                    ""};
+
+    if (!domain || !file || !function || !fmt) {
+        fprintf(stderr, "logging: %s:%s():%d: invalid argument\n", __FILE__,
+                __PRETTY_FUNCTION__, __LINE__);
+        return -1;
+    }
+
+    basename = strrchr(file, '/');
+    if (basename)
+        basename++;
+    else
+        basename = file;
+
+    if (ctx->log.log_control_file_found) {
+        int priority;
+        /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
+           other level as is */
+        if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
+            priority = LOG_DEBUG;
+        } else {
+            priority = level - 1;
         }
 
-        basename = strrchr (file, '/');
-        if (basename)
-                basename++;
-        else
-                basename = file;
+        va_start(ap, fmt);
+        vasprintf(&str2, fmt, ap);
+        va_end(ap);
 
-        if (ctx->log.log_control_file_found)
-        {
-                int priority;
-                /* treat GF_LOG_TRACE and GF_LOG_NONE as LOG_DEBUG and
-                   other level as is */
-                if (GF_LOG_TRACE == level || GF_LOG_NONE == level) {
-                        priority = LOG_DEBUG;
-                } else {
-                        priority = level - 1;
-                }
+        gf_syslog(priority, "[%s:%d:%s] %d-%s: %s", basename, line, function,
+                  ((this->graph) ? this->graph->id : 0), domain, str2);
+        goto err;
+    }
 
-                va_start (ap, fmt);
-                vasprintf (&str2, fmt, ap);
-                va_end (ap);
+    if (ctx->log.logrotate) {
+        ctx->log.logrotate = 0;
 
-                gf_syslog (priority, "[%s:%d:%s] %d-%s: %s",
-                           basename, line, function,
-                           ((this->graph) ? this->graph->id:0), domain, str2);
-                goto err;
+        fd = sys_open(ctx->log.filename, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            gf_msg("logrotate", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open logfile");
+            return -1;
         }
+        sys_close(fd);
 
-        if (ctx->log.logrotate) {
-                ctx->log.logrotate = 0;
-
-                fd = sys_open (ctx->log.filename,
-                               O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg ("logrotate", GF_LOG_ERROR, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile");
-                        return -1;
-                }
-                sys_close (fd);
-
-                new_logfile = fopen (ctx->log.filename, "a");
-                if (!new_logfile) {
-                        gf_msg ("logrotate", GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile %s",
-                                ctx->log.filename);
-                        goto log;
-                }
-
-                pthread_mutex_lock (&ctx->log.logfile_mutex);
-                {
-                        if (ctx->log.logfile)
-                                fclose (ctx->log.logfile);
-
-                        ctx->log.gf_log_logfile =
-                                ctx->log.logfile = new_logfile;
-                }
-                pthread_mutex_unlock (&ctx->log.logfile_mutex);
-
+        new_logfile = fopen(ctx->log.filename, "a");
+        if (!new_logfile) {
+            gf_msg("logrotate", GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open logfile %s", ctx->log.filename);
+            goto log;
         }
 
-log:
-        ret = gettimeofday (&tv, NULL);
-        if (-1 == ret)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %d-%s: ",
-                           timestr, level_strings[level],
-                           basename, line, function,
-                           ((this->graph)?this->graph->id:0), domain);
-        if (-1 == ret) {
-                goto err;
-        }
+        pthread_mutex_lock(&ctx->log.logfile_mutex);
+        {
+            if (ctx->log.logfile)
+                fclose(ctx->log.logfile);
 
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto err;
+            ctx->log.gf_log_logfile = ctx->log.logfile = new_logfile;
         }
+        pthread_mutex_unlock(&ctx->log.logfile_mutex);
+    }
 
-        va_end (ap);
-
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                goto err;
+log:
+    ret = gettimeofday(&tv, NULL);
+    if (-1 == ret)
+        goto out;
+    va_start(ap, fmt);
+    gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+    snprintf(timestr + strlen(timestr), sizeof timestr - strlen(timestr),
+             ".%" GF_PRI_SUSECONDS, tv.tv_usec);
+
+    ret = gf_asprintf(&str1, "[%s] %s [%s:%d:%s] %d-%s: ", timestr,
+                      level_strings[level], basename, line, function,
+                      ((this->graph) ? this->graph->id : 0), domain);
+    if (-1 == ret) {
+        goto err;
+    }
+
+    ret = vasprintf(&str2, fmt, ap);
+    if (-1 == ret) {
+        goto err;
+    }
+
+    va_end(ap);
+
+    len = strlen(str1);
+    msg = GF_MALLOC(len + strlen(str2) + 1, gf_common_mt_char);
+    if (!msg) {
+        goto err;
+    }
+
+    strcpy(msg, str1);
+    strcpy(msg + len, str2);
+
+    pthread_mutex_lock(&ctx->log.logfile_mutex);
+    {
+        if (ctx->log.logfile) {
+            fprintf(ctx->log.logfile, "%s\n", msg);
+            fflush(ctx->log.logfile);
+        } else if (ctx->log.loglevel >= level) {
+            fprintf(stderr, "%s\n", msg);
+            fflush(stderr);
         }
 
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
-
-        pthread_mutex_lock (&ctx->log.logfile_mutex);
-        {
-
-                if (ctx->log.logfile) {
-                        fprintf (ctx->log.logfile, "%s\n", msg);
-                        fflush (ctx->log.logfile);
-                } else if (ctx->log.loglevel >= level) {
-                        fprintf (stderr, "%s\n", msg);
-                        fflush (stderr);
-                }
-
 #ifdef GF_LINUX_HOST_OS
-                /* We want only serious log in 'syslog', not our debug
-                   and trace logs */
-                if (ctx->log.gf_log_syslog && level &&
-                    (level <= ctx->log.sys_log_level))
-                        syslog ((level-1), "%s\n", msg);
+        /* We want only serious log in 'syslog', not our debug
+           and trace logs */
+        if (ctx->log.gf_log_syslog && level &&
+            (level <= ctx->log.sys_log_level))
+            syslog((level - 1), "%s\n", msg);
 #endif
-        }
+    }
 
-        pthread_mutex_unlock (&ctx->log.logfile_mutex);
+    pthread_mutex_unlock(&ctx->log.logfile_mutex);
 
 err:
-        GF_FREE (msg);
+    GF_FREE(msg);
 
-        GF_FREE (str1);
+    GF_FREE(str1);
 
-        FREE (str2);
+    FREE(str2);
 
 out:
-        va_end (ap);
-        return (0);
+    va_end(ap);
+    return (0);
 }
 
 int
-_gf_log_eh (const char *function, const char *fmt, ...)
+_gf_log_eh(const char *function, const char *fmt, ...)
 {
-        int          ret   = -1;
-        va_list      ap;
-        char         *str1 = NULL;
-        char         *str2 = NULL;
-        char         *msg  = NULL;
-        xlator_t     *this = NULL;
-
-        this = THIS;
-
-        ret = gf_asprintf (&str1, "[%d] %s: ",
-                           ((this->graph)?this->graph->id:0),
-                           function);
-        if (-1 == ret) {
-                goto out;
-        }
+    int ret = -1;
+    va_list ap;
+    char *str1 = NULL;
+    char *str2 = NULL;
+    char *msg = NULL;
+    xlator_t *this = NULL;
 
-        va_start (ap, fmt);
+    this = THIS;
 
-        ret = vasprintf (&str2, fmt, ap);
-        if (-1 == ret) {
-                goto out;
-        }
+    ret = gf_asprintf(&str1, "[%d] %s: ", ((this->graph) ? this->graph->id : 0),
+                      function);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        msg = GF_MALLOC (strlen (str1) + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                ret = -1;
-                goto out;
-        }
+    va_start(ap, fmt);
+
+    ret = vasprintf(&str2, fmt, ap);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        strcpy (msg, str1);
-        strcat (msg, str2);
+    msg = GF_MALLOC(strlen(str1) + strlen(str2) + 1, gf_common_mt_char);
+    if (!msg) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = eh_save_history (this->history, msg);
-        if (ret < 0)
-                GF_FREE (msg);
+    strcpy(msg, str1);
+    strcat(msg, str2);
+
+    ret = eh_save_history(this->history, msg);
+    if (ret < 0)
+        GF_FREE(msg);
 
 out:
-        GF_FREE (str1);
+    GF_FREE(str1);
 
-        /* Use FREE instead of GF_FREE since str2 was allocated by vasprintf */
-        if (str2)
-                FREE (str2);
+    /* Use FREE instead of GF_FREE since str2 was allocated by vasprintf */
+    if (str2)
+        FREE(str2);
 
-        va_end (ap);
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_cmd_log_init (const char *filename)
+gf_cmd_log_init(const char *filename)
 {
-        int         fd   = -1;
-        xlator_t   *this = NULL;
-        glusterfs_ctx_t *ctx = NULL;
-
-        this = THIS;
-        ctx  = this->ctx;
-
-        if (!ctx)
-                return -1;
-
-        if (!filename){
-                gf_msg (this->name, GF_LOG_CRITICAL, 0, LG_MSG_INVALID_ENTRY,
-                        "gf_cmd_log_init: no filename specified\n");
-                return -1;
-        }
-
-        ctx->log.cmd_log_filename = gf_strdup (filename);
-        if (!ctx->log.cmd_log_filename) {
-                return -1;
-        }
-        /* close and reopen cmdlogfile for log rotate*/
-        if (ctx->log.cmdlogfile) {
-                fclose (ctx->log.cmdlogfile);
-                ctx->log.cmdlogfile = NULL;
-        }
-
-        fd = sys_open (ctx->log.cmd_log_filename,
-                       O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
-        if (fd < 0) {
-                gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                        LG_MSG_FILE_OP_FAILED, "failed to open cmd_log_file");
-                return -1;
-        }
-
-        ctx->log.cmdlogfile = fdopen (fd, "a");
-        if (!ctx->log.cmdlogfile){
-                gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                        LG_MSG_FILE_OP_FAILED,
-                        "gf_cmd_log_init: failed to open logfile \"%s\" "
-                        "\n", ctx->log.cmd_log_filename);
-                sys_close (fd);
-                return -1;
-        }
-        return 0;
+    int fd = -1;
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = THIS;
+    ctx = this->ctx;
+
+    if (!ctx)
+        return -1;
+
+    if (!filename) {
+        gf_msg(this->name, GF_LOG_CRITICAL, 0, LG_MSG_INVALID_ENTRY,
+               "gf_cmd_log_init: no filename specified\n");
+        return -1;
+    }
+
+    ctx->log.cmd_log_filename = gf_strdup(filename);
+    if (!ctx->log.cmd_log_filename) {
+        return -1;
+    }
+    /* close and reopen cmdlogfile for log rotate*/
+    if (ctx->log.cmdlogfile) {
+        fclose(ctx->log.cmdlogfile);
+        ctx->log.cmdlogfile = NULL;
+    }
+
+    fd = sys_open(ctx->log.cmd_log_filename, O_CREAT | O_WRONLY | O_APPEND,
+                  S_IRUSR | S_IWUSR);
+    if (fd < 0) {
+        gf_msg(this->name, GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+               "failed to open cmd_log_file");
+        return -1;
+    }
+
+    ctx->log.cmdlogfile = fdopen(fd, "a");
+    if (!ctx->log.cmdlogfile) {
+        gf_msg(this->name, GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+               "gf_cmd_log_init: failed to open logfile \"%s\" "
+               "\n",
+               ctx->log.cmd_log_filename);
+        sys_close(fd);
+        return -1;
+    }
+    return 0;
 }
 
 int
-gf_cmd_log (const char *domain, const char *fmt, ...)
+gf_cmd_log(const char *domain, const char *fmt, ...)
 {
-        va_list        ap;
-        char           timestr[64];
-        struct timeval tv = {0,};
-        char          *str1 = NULL;
-        char          *str2 = NULL;
-        char          *msg  = NULL;
-        size_t         len  = 0;
-        int            ret  = 0;
-        int            fd   = -1;
-        glusterfs_ctx_t *ctx = NULL;
-
-        ctx = THIS->ctx;
-
-        if (!ctx)
-                return -1;
-
-        if (!ctx->log.cmdlogfile)
-                return -1;
-
-
-        if (!domain || !fmt) {
-                gf_msg_trace ("glusterd", 0,
-                        "logging: invalid argument\n");
-                return -1;
-        }
+    va_list ap;
+    char timestr[64];
+    struct timeval tv = {
+        0,
+    };
+    char *str1 = NULL;
+    char *str2 = NULL;
+    char *msg = NULL;
+    size_t len = 0;
+    int ret = 0;
+    int fd = -1;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = THIS->ctx;
+
+    if (!ctx)
+        return -1;
+
+    if (!ctx->log.cmdlogfile)
+        return -1;
+
+    if (!domain || !fmt) {
+        gf_msg_trace("glusterd", 0, "logging: invalid argument\n");
+        return -1;
+    }
+
+    ret = gettimeofday(&tv, NULL);
+    if (ret == -1)
+        goto out;
+    va_start(ap, fmt);
+    gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+    snprintf(timestr + strlen(timestr), GF_LOG_TIMESTR_SIZE - strlen(timestr),
+             ".%" GF_PRI_SUSECONDS, tv.tv_usec);
+
+    ret = gf_asprintf(&str1, "[%s] %s : ", timestr, domain);
+    if (ret == -1) {
+        goto out;
+    }
+
+    ret = vasprintf(&str2, fmt, ap);
+    if (ret == -1) {
+        goto out;
+    }
+
+    va_end(ap);
+
+    len = strlen(str1);
+    msg = GF_MALLOC(len + strlen(str2) + 1, gf_common_mt_char);
+    if (!msg) {
+        goto out;
+    }
+
+    strcpy(msg, str1);
+    strcpy(msg + len, str2);
+
+    /* close and reopen cmdlogfile fd for in case of log rotate*/
+    if (ctx->log.cmd_history_logrotate) {
+        ctx->log.cmd_history_logrotate = 0;
 
-        ret = gettimeofday (&tv, NULL);
-        if (ret == -1)
-                goto out;
-        va_start (ap, fmt);
-        gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-        snprintf (timestr + strlen (timestr),
-                  GF_LOG_TIMESTR_SIZE - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-
-        ret = gf_asprintf (&str1, "[%s] %s : ",
-                           timestr, domain);
-        if (ret == -1) {
-                goto out;
-        }
-
-        ret = vasprintf (&str2, fmt, ap);
-        if (ret == -1) {
-                goto out;
+        if (ctx->log.cmdlogfile) {
+            fclose(ctx->log.cmdlogfile);
+            ctx->log.cmdlogfile = NULL;
         }
 
-        va_end (ap);
-
-        len = strlen (str1);
-        msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
-        if (!msg) {
-                goto out;
+        fd = sys_open(ctx->log.cmd_log_filename, O_CREAT | O_WRONLY | O_APPEND,
+                      S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            gf_msg(THIS->name, GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open "
+                   "logfile \"%s\" \n",
+                   ctx->log.cmd_log_filename);
+            ret = -1;
+            goto out;
         }
 
-        strcpy (msg, str1);
-        strcpy (msg + len, str2);
-
-        /* close and reopen cmdlogfile fd for in case of log rotate*/
-        if (ctx->log.cmd_history_logrotate) {
-                ctx->log.cmd_history_logrotate = 0;
-
-                if (ctx->log.cmdlogfile) {
-                        fclose (ctx->log.cmdlogfile);
-                        ctx->log.cmdlogfile = NULL;
-                }
-
-                fd = sys_open (ctx->log.cmd_log_filename,
-                               O_CREAT | O_WRONLY | O_APPEND,
-                               S_IRUSR | S_IWUSR);
-                if (fd < 0) {
-                        gf_msg (THIS->name, GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED, "failed to open "
-                                "logfile \"%s\" \n", ctx->log.cmd_log_filename);
-                        ret = -1;
-                        goto out;
-                }
-
-                ctx->log.cmdlogfile = fdopen (fd, "a");
-                if (!ctx->log.cmdlogfile) {
-                        gf_msg (THIS->name, GF_LOG_CRITICAL, errno,
-                                LG_MSG_FILE_OP_FAILED,
-                                "failed to open logfile \"%s\""
-                                " \n", ctx->log.cmd_log_filename);
-                        ret = -1;
-                        sys_close (fd);
-                        goto out;
-                }
+        ctx->log.cmdlogfile = fdopen(fd, "a");
+        if (!ctx->log.cmdlogfile) {
+            gf_msg(THIS->name, GF_LOG_CRITICAL, errno, LG_MSG_FILE_OP_FAILED,
+                   "failed to open logfile \"%s\""
+                   " \n",
+                   ctx->log.cmd_log_filename);
+            ret = -1;
+            sys_close(fd);
+            goto out;
         }
+    }
 
-        fprintf (ctx->log.cmdlogfile, "%s\n", msg);
-        fflush (ctx->log.cmdlogfile);
+    fprintf(ctx->log.cmdlogfile, "%s\n", msg);
+    fflush(ctx->log.cmdlogfile);
 
 out:
-        GF_FREE (msg);
+    GF_FREE(msg);
 
-        GF_FREE (str1);
+    GF_FREE(str1);
 
-        FREE (str2);
+    FREE(str2);
 
-        va_end (ap);
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 static int
-_do_slog_format (const char *event, va_list inp, char **msg) {
-        va_list                    valist_tmp;
-        int                        i = 0;
-        int                        j = 0;
-        int                        k = 0;
-        int                        ret = 0;
-        char                      *fmt = NULL;
-        char                      *buffer = NULL;
-        int                        num_format_chars = 0;
-        char                       format_char = '%';
-        char                      *tmp1 = NULL;
-        char                      *tmp2 = NULL;
-
-        ret = gf_asprintf (&tmp2, "%s", event);
-        if (ret == -1)
+_do_slog_format(const char *event, va_list inp, char **msg)
+{
+    va_list valist_tmp;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    int ret = 0;
+    char *fmt = NULL;
+    char *buffer = NULL;
+    int num_format_chars = 0;
+    char format_char = '%';
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+
+    ret = gf_asprintf(&tmp2, "%s", event);
+    if (ret == -1)
+        goto out;
+
+    /* Hardcoded value for max key value pairs, exits early */
+    /* from loop if found NULL */
+    for (i = 0; i < GF_MAX_SLOG_PAIR_COUNT; i++) {
+        fmt = va_arg(inp, char *);
+        if (fmt == NULL) {
+            break;
+        }
+
+        /* Get number of times % is used in input for formatting, */
+        /* this count will be used to skip those many args from the */
+        /* main list and will be used to format inner format */
+        num_format_chars = 0;
+        for (k = 0; fmt[k] != '\0'; k++) {
+            /* If %% is used then that is escaped */
+            if (fmt[k] == format_char && fmt[k + 1] == format_char) {
+                k++;
+            } else if (fmt[k] == format_char) {
+                num_format_chars++;
+            }
+        }
+
+        tmp1 = gf_strdup(tmp2);
+        if (!tmp1) {
+            ret = -1;
+            goto out;
+        }
+
+        GF_FREE(tmp2);
+        tmp2 = NULL;
+
+        if (num_format_chars > 0) {
+            /* Make separate valist and format the string */
+            va_copy(valist_tmp, inp);
+            ret = gf_vasprintf(&buffer, fmt, valist_tmp);
+            if (ret < 0) {
+                va_end(valist_tmp);
                 goto out;
+            }
+            va_end(valist_tmp);
 
-        /* Hardcoded value for max key value pairs, exits early */
-        /* from loop if found NULL */
-        for (i = 0; i < GF_MAX_SLOG_PAIR_COUNT; i++) {
-                fmt = va_arg (inp, char*);
-                if (fmt == NULL) {
-                        break;
-                }
-
-                /* Get number of times % is used in input for formatting, */
-                /* this count will be used to skip those many args from the */
-                /* main list and will be used to format inner format */
-                num_format_chars = 0;
-                for (k = 0; fmt[k] != '\0'; k++) {
-                        /* If %% is used then that is escaped */
-                        if (fmt[k] == format_char && fmt[k+1] == format_char) {
-                                k++;
-                        } else if (fmt[k] == format_char) {
-                                num_format_chars++;
-                        }
-                }
-
-                tmp1 = gf_strdup (tmp2);
-                if (!tmp1) {
-                        ret = -1;
-                        goto out;
-                }
+            for (j = 0; j < num_format_chars; j++) {
+                /* Skip the va_arg value since these values
+                   are already used for internal formatting */
+                (void)va_arg(inp, void *);
+            }
 
-                GF_FREE (tmp2);
-                tmp2 = NULL;
-
-                if (num_format_chars > 0) {
-                        /* Make separate valist and format the string */
-                        va_copy (valist_tmp, inp);
-                        ret = gf_vasprintf (&buffer, fmt, valist_tmp);
-                        if (ret < 0) {
-                                va_end (valist_tmp);
-                                goto out;
-                        }
-                        va_end (valist_tmp);
-
-                        for (j = 0; j < num_format_chars; j++) {
-                                /* Skip the va_arg value since these values
-                                   are already used for internal formatting */
-                                (void) va_arg (inp, void*);
-                        }
-
-                        ret = gf_asprintf (&tmp2, "%s\t%s", tmp1, buffer);
-                        if (ret < 0)
-                                goto out;
-
-                        GF_FREE (buffer);
-                        buffer = NULL;
-                } else {
-                        ret = gf_asprintf (&tmp2, "%s\t%s", tmp1, fmt);
-                        if (ret < 0)
-                                goto out;
-                }
+            ret = gf_asprintf(&tmp2, "%s\t%s", tmp1, buffer);
+            if (ret < 0)
+                goto out;
 
-                GF_FREE (tmp1);
-                tmp1 = NULL;
+            GF_FREE(buffer);
+            buffer = NULL;
+        } else {
+            ret = gf_asprintf(&tmp2, "%s\t%s", tmp1, fmt);
+            if (ret < 0)
+                goto out;
         }
 
-        *msg = gf_strdup (tmp2);
-        if (!*msg)
-                ret = -1;
+        GF_FREE(tmp1);
+        tmp1 = NULL;
+    }
 
- out:
-        if (buffer)
-                GF_FREE (buffer);
+    *msg = gf_strdup(tmp2);
+    if (!*msg)
+        ret = -1;
 
-        if (tmp1)
-                GF_FREE (tmp1);
+out:
+    if (buffer)
+        GF_FREE(buffer);
 
-        if (tmp2)
-                GF_FREE (tmp2);
+    if (tmp1)
+        GF_FREE(tmp1);
 
-        return ret;
+    if (tmp2)
+        GF_FREE(tmp2);
+
+    return ret;
 }
 
 int
-_gf_smsg (const char *domain, const char *file, const char *function,
-          int32_t line, gf_loglevel_t level, int errnum, int trace,
-          uint64_t msgid, const char *event, ...)
+_gf_smsg(const char *domain, const char *file, const char *function,
+         int32_t line, gf_loglevel_t level, int errnum, int trace,
+         uint64_t msgid, const char *event, ...)
 {
-        va_list     valist;
-        char       *msg = NULL;
-        int         ret = 0;
+    va_list valist;
+    char *msg = NULL;
+    int ret = 0;
 
-        va_start (valist, event);
-        ret = _do_slog_format (event, valist, &msg);
-        if (ret == -1)
-                goto out;
+    va_start(valist, event);
+    ret = _do_slog_format(event, valist, &msg);
+    if (ret == -1)
+        goto out;
 
-        ret = _gf_msg (domain, file, function, line, level, errnum, trace,
-                       msgid, "%s", msg);
+    ret = _gf_msg(domain, file, function, line, level, errnum, trace, msgid,
+                  "%s", msg);
 
- out:
-        va_end (valist);
-        if (msg)
-                GF_FREE (msg);
-        return ret;
+out:
+    va_end(valist);
+    if (msg)
+        GF_FREE(msg);
+    return ret;
 }
 
 int
-_gf_slog (const char *domain, const char *file, const char *function, int line,
-          gf_loglevel_t level, const char *event, ...)
+_gf_slog(const char *domain, const char *file, const char *function, int line,
+         gf_loglevel_t level, const char *event, ...)
 {
-        va_list      valist;
-        char        *msg = NULL;
-        int          ret = 0;
+    va_list valist;
+    char *msg = NULL;
+    int ret = 0;
 
-        va_start (valist, event);
-        ret = _do_slog_format (event, valist, &msg);
-        if (ret == -1)
-                goto out;
+    va_start(valist, event);
+    ret = _do_slog_format(event, valist, &msg);
+    if (ret == -1)
+        goto out;
 
-        ret = _gf_log (domain, file, function, line, level, "%s", msg);
+    ret = _gf_log(domain, file, function, line, level, "%s", msg);
 
- out:
-        va_end (valist);
-        if (msg)
-                GF_FREE (msg);
-        return ret;
+out:
+    va_end(valist);
+    if (msg)
+        GF_FREE(msg);
+    return ret;
 }
diff --git a/libglusterfs/src/mem-pool.c b/libglusterfs/src/mem-pool.c
index 4b140296b4f..cff96323867 100644
--- a/libglusterfs/src/mem-pool.c
+++ b/libglusterfs/src/mem-pool.c
@@ -18,528 +18,519 @@
 #include "libglusterfs-messages.h"
 
 void
-gf_mem_acct_enable_set (void *data)
+gf_mem_acct_enable_set(void *data)
 {
-        glusterfs_ctx_t *ctx = NULL;
+    glusterfs_ctx_t *ctx = NULL;
 
-        REQUIRE(data != NULL);
+    REQUIRE(data != NULL);
 
-        ctx = data;
+    ctx = data;
 
-        GF_ASSERT (ctx != NULL);
+    GF_ASSERT(ctx != NULL);
 
-        ctx->mem_acct_enable = 1;
+    ctx->mem_acct_enable = 1;
 
-        ENSURE(1 == ctx->mem_acct_enable);
+    ENSURE(1 == ctx->mem_acct_enable);
 
-        return;
+    return;
 }
 
 int
-gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
-		      uint32_t type, const char *typestr)
+gf_mem_set_acct_info(xlator_t *xl, char **alloc_ptr, size_t size, uint32_t type,
+                     const char *typestr)
 {
+    void *ptr = NULL;
+    struct mem_header *header = NULL;
 
-        void              *ptr    = NULL;
-        struct mem_header *header = NULL;
+    if (!alloc_ptr)
+        return -1;
 
-        if (!alloc_ptr)
-                return -1;
+    ptr = *alloc_ptr;
 
-        ptr = *alloc_ptr;
+    GF_ASSERT(xl != NULL);
 
-        GF_ASSERT (xl != NULL);
+    GF_ASSERT(xl->mem_acct != NULL);
 
-        GF_ASSERT (xl->mem_acct != NULL);
+    GF_ASSERT(type <= xl->mem_acct->num_types);
 
-        GF_ASSERT (type <= xl->mem_acct->num_types);
+    LOCK(&xl->mem_acct->rec[type].lock);
+    {
+        if (!xl->mem_acct->rec[type].typestr)
+            xl->mem_acct->rec[type].typestr = typestr;
+        xl->mem_acct->rec[type].size += size;
+        xl->mem_acct->rec[type].num_allocs++;
+        xl->mem_acct->rec[type].total_allocs++;
+        xl->mem_acct->rec[type].max_size = max(xl->mem_acct->rec[type].max_size,
+                                               xl->mem_acct->rec[type].size);
+        xl->mem_acct->rec[type].max_num_allocs = max(
+            xl->mem_acct->rec[type].max_num_allocs,
+            xl->mem_acct->rec[type].num_allocs);
+    }
+    UNLOCK(&xl->mem_acct->rec[type].lock);
 
-        LOCK(&xl->mem_acct->rec[type].lock);
-        {
-		if (!xl->mem_acct->rec[type].typestr)
-			xl->mem_acct->rec[type].typestr = typestr;
-                xl->mem_acct->rec[type].size += size;
-                xl->mem_acct->rec[type].num_allocs++;
-                xl->mem_acct->rec[type].total_allocs++;
-                xl->mem_acct->rec[type].max_size =
-                        max (xl->mem_acct->rec[type].max_size,
-                             xl->mem_acct->rec[type].size);
-                xl->mem_acct->rec[type].max_num_allocs =
-                        max (xl->mem_acct->rec[type].max_num_allocs,
-                             xl->mem_acct->rec[type].num_allocs);
-        }
-        UNLOCK(&xl->mem_acct->rec[type].lock);
+    GF_ATOMIC_INC(xl->mem_acct->refcnt);
 
-        GF_ATOMIC_INC (xl->mem_acct->refcnt);
-
-        header = (struct mem_header *) ptr;
-        header->type = type;
-        header->size = size;
-        header->mem_acct = xl->mem_acct;
-        header->magic = GF_MEM_HEADER_MAGIC;
+    header = (struct mem_header *)ptr;
+    header->type = type;
+    header->size = size;
+    header->mem_acct = xl->mem_acct;
+    header->magic = GF_MEM_HEADER_MAGIC;
 
 #ifdef DEBUG
-        INIT_LIST_HEAD(&header->acct_list);
-        LOCK(&xl->mem_acct->rec[type].lock);
-        {
-                list_add (&header->acct_list,
-                          &(xl->mem_acct->rec[type].obj_list));
-        }
-        UNLOCK(&xl->mem_acct->rec[type].lock);
+    INIT_LIST_HEAD(&header->acct_list);
+    LOCK(&xl->mem_acct->rec[type].lock);
+    {
+        list_add(&header->acct_list, &(xl->mem_acct->rec[type].obj_list));
+    }
+    UNLOCK(&xl->mem_acct->rec[type].lock);
 #endif
-        ptr += sizeof (struct mem_header);
-        /* data follows in this gap of 'size' bytes */
-        *(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
+    ptr += sizeof(struct mem_header);
+    /* data follows in this gap of 'size' bytes */
+    *(uint32_t *)(ptr + size) = GF_MEM_TRAILER_MAGIC;
 
-        *alloc_ptr = ptr;
-        return 0;
+    *alloc_ptr = ptr;
+    return 0;
 }
 
-
 void *
-__gf_calloc (size_t nmemb, size_t size, uint32_t type, const char *typestr)
+__gf_calloc(size_t nmemb, size_t size, uint32_t type, const char *typestr)
 {
-        size_t          tot_size = 0;
-        size_t          req_size = 0;
-        char            *ptr = NULL;
-        xlator_t        *xl = NULL;
+    size_t tot_size = 0;
+    size_t req_size = 0;
+    char *ptr = NULL;
+    xlator_t *xl = NULL;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return CALLOC (nmemb, size);
+    if (!THIS->ctx->mem_acct_enable)
+        return CALLOC(nmemb, size);
 
-        xl = THIS;
+    xl = THIS;
 
-        req_size = nmemb * size;
-        tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    req_size = nmemb * size;
+    tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
 
-        ptr = calloc (1, tot_size);
+    ptr = calloc(1, tot_size);
 
-        if (!ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
-        gf_mem_set_acct_info (xl, &ptr, req_size, type, typestr);
+    if (!ptr) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
+    gf_mem_set_acct_info(xl, &ptr, req_size, type, typestr);
 
-        return (void *)ptr;
+    return (void *)ptr;
 }
 
 void *
-__gf_malloc (size_t size, uint32_t type, const char *typestr)
+__gf_malloc(size_t size, uint32_t type, const char *typestr)
 {
-        size_t          tot_size = 0;
-        char            *ptr = NULL;
-        xlator_t        *xl = NULL;
+    size_t tot_size = 0;
+    char *ptr = NULL;
+    xlator_t *xl = NULL;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return MALLOC (size);
+    if (!THIS->ctx->mem_acct_enable)
+        return MALLOC(size);
 
-        xl = THIS;
+    xl = THIS;
 
-        tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
 
-        ptr = malloc (tot_size);
-        if (!ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
-        gf_mem_set_acct_info (xl, &ptr, size, type, typestr);
+    ptr = malloc(tot_size);
+    if (!ptr) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
+    gf_mem_set_acct_info(xl, &ptr, size, type, typestr);
 
-        return (void *)ptr;
+    return (void *)ptr;
 }
 
 void *
-__gf_realloc (void *ptr, size_t size)
+__gf_realloc(void *ptr, size_t size)
 {
-        size_t             tot_size = 0;
-        char              *new_ptr;
-        struct mem_header *old_header = NULL;
-        struct mem_header *new_header = NULL;
-        struct mem_header  tmp_header;
+    size_t tot_size = 0;
+    char *new_ptr;
+    struct mem_header *old_header = NULL;
+    struct mem_header *new_header = NULL;
+    struct mem_header tmp_header;
 
-        if (!THIS->ctx->mem_acct_enable)
-                return REALLOC (ptr, size);
+    if (!THIS->ctx->mem_acct_enable)
+        return REALLOC(ptr, size);
 
-        REQUIRE(NULL != ptr);
+    REQUIRE(NULL != ptr);
 
-        old_header = (struct mem_header *) (ptr - GF_MEM_HEADER_SIZE);
-        GF_ASSERT (old_header->magic == GF_MEM_HEADER_MAGIC);
-        tmp_header = *old_header;
+    old_header = (struct mem_header *)(ptr - GF_MEM_HEADER_SIZE);
+    GF_ASSERT(old_header->magic == GF_MEM_HEADER_MAGIC);
+    tmp_header = *old_header;
 
 #ifdef DEBUG
-        int type = 0;
-        size_t copy_size = 0;
-
-        /* Making these changes for realloc is not straightforward. So
-         * I am simulating realloc using calloc and free
-         */
-
-        type = tmp_header.type;
-        new_ptr = __gf_calloc (1, size, type,
-                               tmp_header.mem_acct->rec[type].typestr);
-        if (new_ptr) {
-                copy_size = (size > tmp_header.size) ? tmp_header.size : size;
-                memcpy (new_ptr, ptr, copy_size);
-                __gf_free (ptr);
-        }
-
-        /* This is not quite what the man page says should happen */
-        return new_ptr;
+    int type = 0;
+    size_t copy_size = 0;
+
+    /* Making these changes for realloc is not straightforward. So
+     * I am simulating realloc using calloc and free
+     */
+
+    type = tmp_header.type;
+    new_ptr = __gf_calloc(1, size, type,
+                          tmp_header.mem_acct->rec[type].typestr);
+    if (new_ptr) {
+        copy_size = (size > tmp_header.size) ? tmp_header.size : size;
+        memcpy(new_ptr, ptr, copy_size);
+        __gf_free(ptr);
+    }
+
+    /* This is not quite what the man page says should happen */
+    return new_ptr;
 #endif
 
-        tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
-        new_ptr = realloc (old_header, tot_size);
-        if (!new_ptr) {
-                gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
-                return NULL;
-        }
-
-        /*
-         * We used to pass (char **)&ptr as the second
-         * argument after the value of realloc was saved
-         * in ptr, but the compiler warnings complained
-         * about the casting to and forth from void ** to
-         * char **.
-         * TBD: it would be nice to adjust the memory accounting info here,
-         * but calling gf_mem_set_acct_info here is wrong because it bumps
-         * up counts as though this is a new allocation - which it's not.
-         * The consequence of doing nothing here is only that the sizes will be
-         * wrong, but at least the counts won't be.
-        uint32_t           type = 0;
-        xlator_t          *xl = NULL;
-        type = header->type;
-        xl = (xlator_t *) header->xlator;
-        gf_mem_set_acct_info (xl, &new_ptr, size, type, NULL);
-         */
-
-        new_header = (struct mem_header *) new_ptr;
-        *new_header = tmp_header;
-        new_header->size = size;
-
-        new_ptr += sizeof (struct mem_header);
-        /* data follows in this gap of 'size' bytes */
-        *(uint32_t *) (new_ptr + size) = GF_MEM_TRAILER_MAGIC;
-
-        return (void *)new_ptr;
+    tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+    new_ptr = realloc(old_header, tot_size);
+    if (!new_ptr) {
+        gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+        return NULL;
+    }
+
+    /*
+     * We used to pass (char **)&ptr as the second
+     * argument after the value of realloc was saved
+     * in ptr, but the compiler warnings complained
+     * about the casting to and forth from void ** to
+     * char **.
+     * TBD: it would be nice to adjust the memory accounting info here,
+     * but calling gf_mem_set_acct_info here is wrong because it bumps
+     * up counts as though this is a new allocation - which it's not.
+     * The consequence of doing nothing here is only that the sizes will be
+     * wrong, but at least the counts won't be.
+    uint32_t           type = 0;
+    xlator_t          *xl = NULL;
+    type = header->type;
+    xl = (xlator_t *) header->xlator;
+    gf_mem_set_acct_info (xl, &new_ptr, size, type, NULL);
+     */
+
+    new_header = (struct mem_header *)new_ptr;
+    *new_header = tmp_header;
+    new_header->size = size;
+
+    new_ptr += sizeof(struct mem_header);
+    /* data follows in this gap of 'size' bytes */
+    *(uint32_t *)(new_ptr + size) = GF_MEM_TRAILER_MAGIC;
+
+    return (void *)new_ptr;
 }
 
 int
-gf_vasprintf (char **string_ptr, const char *format, va_list arg)
+gf_vasprintf(char **string_ptr, const char *format, va_list arg)
 {
-        va_list arg_save;
-        char    *str = NULL;
-        int     size = 0;
-        int     rv = 0;
-
-        if (!string_ptr || !format)
-                return -1;
-
-        va_copy (arg_save, arg);
-
-        size = vsnprintf (NULL, 0, format, arg);
-        size++;
-        str = GF_MALLOC (size, gf_common_mt_asprintf);
-        if (str == NULL) {
-                /* log is done in GF_MALLOC itself */
-                va_end (arg_save);
-                return -1;
-        }
-        rv = vsnprintf (str, size, format, arg_save);
-
-        *string_ptr = str;
-        va_end (arg_save);
-        return (rv);
+    va_list arg_save;
+    char *str = NULL;
+    int size = 0;
+    int rv = 0;
+
+    if (!string_ptr || !format)
+        return -1;
+
+    va_copy(arg_save, arg);
+
+    size = vsnprintf(NULL, 0, format, arg);
+    size++;
+    str = GF_MALLOC(size, gf_common_mt_asprintf);
+    if (str == NULL) {
+        /* log is done in GF_MALLOC itself */
+        va_end(arg_save);
+        return -1;
+    }
+    rv = vsnprintf(str, size, format, arg_save);
+
+    *string_ptr = str;
+    va_end(arg_save);
+    return (rv);
 }
 
 int
-gf_asprintf (char **string_ptr, const char *format, ...)
+gf_asprintf(char **string_ptr, const char *format, ...)
 {
-        va_list arg;
-        int     rv = 0;
+    va_list arg;
+    int rv = 0;
 
-        va_start (arg, format);
-        rv = gf_vasprintf (string_ptr, format, arg);
-        va_end (arg);
+    va_start(arg, format);
+    rv = gf_vasprintf(string_ptr, format, arg);
+    va_end(arg);
 
-        return rv;
+    return rv;
 }
 
 #ifdef DEBUG
 void
-__gf_mem_invalidate (void *ptr)
+__gf_mem_invalidate(void *ptr)
 {
-        struct mem_header *header = ptr;
-        void              *end    = NULL;
-
-        struct mem_invalid inval = {
-                .magic = GF_MEM_INVALID_MAGIC,
-                .mem_acct = header->mem_acct,
-                .type = header->type,
-                .size = header->size,
-                .baseaddr = ptr + GF_MEM_HEADER_SIZE,
-        };
-
-        /* calculate the last byte of the allocated area */
-        end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
-
-        /* overwrite the old mem_header */
-        memcpy (ptr, &inval, sizeof (inval));
-        ptr += sizeof (inval);
-
-        /* zero out remaining (old) mem_header bytes) */
-        memset (ptr, 0x00, sizeof (*header) - sizeof (inval));
-        ptr += sizeof (*header) - sizeof (inval);
-
-        /* zero out the first byte of data */
-        *(uint32_t *)(ptr) = 0x00;
-        ptr += 1;
-
-        /* repeated writes of invalid structurein data area */
-        while ((ptr + (sizeof (inval))) < (end - 1)) {
-                memcpy (ptr, &inval, sizeof (inval));
-                ptr += sizeof (inval);
-        }
-
-        /* fill out remaining data area with 0xff */
-        memset (ptr, 0xff, end - ptr);
+    struct mem_header *header = ptr;
+    void *end = NULL;
+
+    struct mem_invalid inval = {
+        .magic = GF_MEM_INVALID_MAGIC,
+        .mem_acct = header->mem_acct,
+        .type = header->type,
+        .size = header->size,
+        .baseaddr = ptr + GF_MEM_HEADER_SIZE,
+    };
+
+    /* calculate the last byte of the allocated area */
+    end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
+
+    /* overwrite the old mem_header */
+    memcpy(ptr, &inval, sizeof(inval));
+    ptr += sizeof(inval);
+
+    /* zero out remaining (old) mem_header bytes) */
+    memset(ptr, 0x00, sizeof(*header) - sizeof(inval));
+    ptr += sizeof(*header) - sizeof(inval);
+
+    /* zero out the first byte of data */
+    *(uint32_t *)(ptr) = 0x00;
+    ptr += 1;
+
+    /* repeated writes of invalid structurein data area */
+    while ((ptr + (sizeof(inval))) < (end - 1)) {
+        memcpy(ptr, &inval, sizeof(inval));
+        ptr += sizeof(inval);
+    }
+
+    /* fill out remaining data area with 0xff */
+    memset(ptr, 0xff, end - ptr);
 }
 #endif /* DEBUG */
 
 void
-__gf_free (void *free_ptr)
+__gf_free(void *free_ptr)
 {
-        void              *ptr = NULL;
-        struct mem_acct   *mem_acct;
-        struct mem_header *header = NULL;
+    void *ptr = NULL;
+    struct mem_acct *mem_acct;
+    struct mem_header *header = NULL;
 
-        if (!THIS->ctx->mem_acct_enable) {
-                FREE (free_ptr);
-                return;
-        }
-
-        if (!free_ptr)
-                return;
-
-        ptr = free_ptr - GF_MEM_HEADER_SIZE;
-        header = (struct mem_header *) ptr;
-
-        //Possible corruption, assert here
-        GF_ASSERT (GF_MEM_HEADER_MAGIC == header->magic);
-
-        mem_acct = header->mem_acct;
-        if (!mem_acct) {
-                goto free;
-        }
+    if (!THIS->ctx->mem_acct_enable) {
+        FREE(free_ptr);
+        return;
+    }
 
-        // This points to a memory overrun
-        GF_ASSERT (GF_MEM_TRAILER_MAGIC ==
-                *(uint32_t *)((char *)free_ptr + header->size));
+    if (!free_ptr)
+        return;
 
-        LOCK (&mem_acct->rec[header->type].lock);
-        {
-                mem_acct->rec[header->type].size -= header->size;
-                mem_acct->rec[header->type].num_allocs--;
-                /* If all the instances are freed up then ensure typestr is set
-                 * to NULL */
-                if (!mem_acct->rec[header->type].num_allocs)
-                        mem_acct->rec[header->type].typestr = NULL;
+    ptr = free_ptr - GF_MEM_HEADER_SIZE;
+    header = (struct mem_header *)ptr;
+
+    // Possible corruption, assert here
+    GF_ASSERT(GF_MEM_HEADER_MAGIC == header->magic);
+
+    mem_acct = header->mem_acct;
+    if (!mem_acct) {
+        goto free;
+    }
+
+    // This points to a memory overrun
+    GF_ASSERT(GF_MEM_TRAILER_MAGIC ==
+              *(uint32_t *)((char *)free_ptr + header->size));
+
+    LOCK(&mem_acct->rec[header->type].lock);
+    {
+        mem_acct->rec[header->type].size -= header->size;
+        mem_acct->rec[header->type].num_allocs--;
+        /* If all the instances are freed up then ensure typestr is set
+         * to NULL */
+        if (!mem_acct->rec[header->type].num_allocs)
+            mem_acct->rec[header->type].typestr = NULL;
 #ifdef DEBUG
-                list_del (&header->acct_list);
+        list_del(&header->acct_list);
 #endif
-        }
-        UNLOCK (&mem_acct->rec[header->type].lock);
+    }
+    UNLOCK(&mem_acct->rec[header->type].lock);
 
-        if (GF_ATOMIC_DEC (mem_acct->refcnt) == 0) {
-                FREE (mem_acct);
-        }
+    if (GF_ATOMIC_DEC(mem_acct->refcnt) == 0) {
+        FREE(mem_acct);
+    }
 
 free:
 #ifdef DEBUG
-        __gf_mem_invalidate (ptr);
+    __gf_mem_invalidate(ptr);
 #endif
 
-        FREE (ptr);
+    FREE(ptr);
 }
 
-#define POOL_SMALLEST   7       /* i.e. 128 */
-#define POOL_LARGEST    20      /* i.e. 1048576 */
-#define NPOOLS          (POOL_LARGEST - POOL_SMALLEST + 1)
+#define POOL_SMALLEST 7 /* i.e. 128 */
+#define POOL_LARGEST 20 /* i.e. 1048576 */
+#define NPOOLS (POOL_LARGEST - POOL_SMALLEST + 1)
 
-static pthread_key_t            pool_key;
-static pthread_mutex_t          pool_lock       = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head         pool_threads;
-static pthread_mutex_t          pool_free_lock  = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head         pool_free_threads;
-static struct mem_pool_shared   pools[NPOOLS];
-static size_t                   pool_list_size;
+static pthread_key_t pool_key;
+static pthread_mutex_t pool_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_threads;
+static pthread_mutex_t pool_free_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_free_threads;
+static struct mem_pool_shared pools[NPOOLS];
+static size_t pool_list_size;
 
 #if !defined(GF_DISABLE_MEMPOOL)
-#define N_COLD_LISTS    1024
+#define N_COLD_LISTS 1024
 #define POOL_SWEEP_SECS 30
 
-static unsigned long            sweep_times;
-static unsigned long            sweep_usecs;
-static unsigned long            frees_to_system;
+static unsigned long sweep_times;
+static unsigned long sweep_usecs;
+static unsigned long frees_to_system;
 
 typedef struct {
-        struct list_head        death_row;
-        pooled_obj_hdr_t        *cold_lists[N_COLD_LISTS];
-        unsigned int            n_cold_lists;
+    struct list_head death_row;
+    pooled_obj_hdr_t *cold_lists[N_COLD_LISTS];
+    unsigned int n_cold_lists;
 } sweep_state_t;
 
 enum init_state {
-        GF_MEMPOOL_INIT_NONE = 0,
-        GF_MEMPOOL_INIT_PREINIT,
-        GF_MEMPOOL_INIT_EARLY,
-        GF_MEMPOOL_INIT_LATE,
-        GF_MEMPOOL_INIT_DESTROY
+    GF_MEMPOOL_INIT_NONE = 0,
+    GF_MEMPOOL_INIT_PREINIT,
+    GF_MEMPOOL_INIT_EARLY,
+    GF_MEMPOOL_INIT_LATE,
+    GF_MEMPOOL_INIT_DESTROY
 };
 
-static enum init_state  init_done       = GF_MEMPOOL_INIT_NONE;
-static pthread_mutex_t  init_mutex      = PTHREAD_MUTEX_INITIALIZER;
-static unsigned int     init_count      = 0;
-static pthread_t        sweeper_tid;
-
+static enum init_state init_done = GF_MEMPOOL_INIT_NONE;
+static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static unsigned int init_count = 0;
+static pthread_t sweeper_tid;
 
 void
-collect_garbage (sweep_state_t *state, per_thread_pool_list_t *pool_list)
+collect_garbage(sweep_state_t *state, per_thread_pool_list_t *pool_list)
 {
-        unsigned int            i;
-        per_thread_pool_t       *pt_pool;
+    unsigned int i;
+    per_thread_pool_t *pt_pool;
 
-        if (pool_list->poison) {
-                list_del (&pool_list->thr_list);
-                list_add (&pool_list->thr_list, &state->death_row);
-                return;
-        }
+    if (pool_list->poison) {
+        list_del(&pool_list->thr_list);
+        list_add(&pool_list->thr_list, &state->death_row);
+        return;
+    }
 
-        if (state->n_cold_lists >= N_COLD_LISTS) {
-                return;
-        }
+    if (state->n_cold_lists >= N_COLD_LISTS) {
+        return;
+    }
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        for (i = 0; i < NPOOLS; ++i) {
-                pt_pool = &pool_list->pools[i];
-                if (pt_pool->cold_list) {
-                        state->cold_lists[state->n_cold_lists++]
-                                = pt_pool->cold_list;
-                }
-                pt_pool->cold_list = pt_pool->hot_list;
-                pt_pool->hot_list = NULL;
-                if (state->n_cold_lists >= N_COLD_LISTS) {
-                        /* We'll just catch up on a future pass. */
-                        break;
-                }
+    (void)pthread_spin_lock(&pool_list->lock);
+    for (i = 0; i < NPOOLS; ++i) {
+        pt_pool = &pool_list->pools[i];
+        if (pt_pool->cold_list) {
+            state->cold_lists[state->n_cold_lists++] = pt_pool->cold_list;
+        }
+        pt_pool->cold_list = pt_pool->hot_list;
+        pt_pool->hot_list = NULL;
+        if (state->n_cold_lists >= N_COLD_LISTS) {
+            /* We'll just catch up on a future pass. */
+            break;
         }
-        (void) pthread_spin_unlock (&pool_list->lock);
+    }
+    (void)pthread_spin_unlock(&pool_list->lock);
 }
 
-
 void
-free_obj_list (pooled_obj_hdr_t *victim)
+free_obj_list(pooled_obj_hdr_t *victim)
 {
-        pooled_obj_hdr_t        *next;
-
-        while (victim) {
-                next = victim->next;
-                free (victim);
-                victim = next;
-                ++frees_to_system;
-        }
+    pooled_obj_hdr_t *next;
+
+    while (victim) {
+        next = victim->next;
+        free(victim);
+        victim = next;
+        ++frees_to_system;
+    }
 }
 
 void *
-pool_sweeper (void *arg)
+pool_sweeper(void *arg)
 {
-        sweep_state_t           state;
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_list_t  *next_pl;
-        per_thread_pool_t       *pt_pool;
-        unsigned int            i;
-        struct timeval          begin_time;
-        struct timeval          end_time;
-        struct timeval          elapsed;
-
-        /*
-         * This is all a bit inelegant, but the point is to avoid doing
-         * expensive things (like freeing thousands of objects) while holding a
-         * global lock.  Thus, we split each iteration into three passes, with
-         * only the first and fastest holding the lock.
-         */
-
-        for (;;) {
-                sleep (POOL_SWEEP_SECS);
-                (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
-                INIT_LIST_HEAD (&state.death_row);
-                state.n_cold_lists = 0;
-
-                /* First pass: collect stuff that needs our attention. */
-                (void) gettimeofday (&begin_time, NULL);
-                (void) pthread_mutex_lock (&pool_lock);
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_threads, thr_list) {
-                        collect_garbage (&state, pool_list);
-                }
-                (void) pthread_mutex_unlock (&pool_lock);
-                (void) gettimeofday (&end_time, NULL);
-                timersub (&end_time, &begin_time, &elapsed);
-                sweep_usecs += elapsed.tv_sec * 1000000 + elapsed.tv_usec;
-                sweep_times += 1;
-
-                /* Second pass: free dead pools. */
-                (void) pthread_mutex_lock (&pool_free_lock);
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &state.death_row, thr_list) {
-                        for (i = 0; i < NPOOLS; ++i) {
-                                pt_pool = &pool_list->pools[i];
-                                free_obj_list (pt_pool->cold_list);
-                                free_obj_list (pt_pool->hot_list);
-                                pt_pool->hot_list = pt_pool->cold_list = NULL;
-                        }
-                        list_del (&pool_list->thr_list);
-                        list_add (&pool_list->thr_list, &pool_free_threads);
-                }
-                (void) pthread_mutex_unlock (&pool_free_lock);
+    sweep_state_t state;
+    per_thread_pool_list_t *pool_list;
+    per_thread_pool_list_t *next_pl;
+    per_thread_pool_t *pt_pool;
+    unsigned int i;
+    struct timeval begin_time;
+    struct timeval end_time;
+    struct timeval elapsed;
+
+    /*
+     * This is all a bit inelegant, but the point is to avoid doing
+     * expensive things (like freeing thousands of objects) while holding a
+     * global lock.  Thus, we split each iteration into three passes, with
+     * only the first and fastest holding the lock.
+     */
+
+    for (;;) {
+        sleep(POOL_SWEEP_SECS);
+        (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+        INIT_LIST_HEAD(&state.death_row);
+        state.n_cold_lists = 0;
+
+        /* First pass: collect stuff that needs our attention. */
+        (void)gettimeofday(&begin_time, NULL);
+        (void)pthread_mutex_lock(&pool_lock);
+        list_for_each_entry_safe(pool_list, next_pl, &pool_threads, thr_list)
+        {
+            collect_garbage(&state, pool_list);
+        }
+        (void)pthread_mutex_unlock(&pool_lock);
+        (void)gettimeofday(&end_time, NULL);
+        timersub(&end_time, &begin_time, &elapsed);
+        sweep_usecs += elapsed.tv_sec * 1000000 + elapsed.tv_usec;
+        sweep_times += 1;
 
-                /* Third pass: free cold objects from live pools. */
-                for (i = 0; i < state.n_cold_lists; ++i) {
-                        free_obj_list (state.cold_lists[i]);
-                }
-                (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+        /* Second pass: free dead pools. */
+        (void)pthread_mutex_lock(&pool_free_lock);
+        list_for_each_entry_safe(pool_list, next_pl, &state.death_row, thr_list)
+        {
+            for (i = 0; i < NPOOLS; ++i) {
+                pt_pool = &pool_list->pools[i];
+                free_obj_list(pt_pool->cold_list);
+                free_obj_list(pt_pool->hot_list);
+                pt_pool->hot_list = pt_pool->cold_list = NULL;
+            }
+            list_del(&pool_list->thr_list);
+            list_add(&pool_list->thr_list, &pool_free_threads);
         }
-}
+        (void)pthread_mutex_unlock(&pool_free_lock);
 
+        /* Third pass: free cold objects from live pools. */
+        for (i = 0; i < state.n_cold_lists; ++i) {
+            free_obj_list(state.cold_lists[i]);
+        }
+        (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    }
+}
 
 void
-pool_destructor (void *arg)
+pool_destructor(void *arg)
 {
-        per_thread_pool_list_t  *pool_list      = arg;
+    per_thread_pool_list_t *pool_list = arg;
 
-        /* The pool-sweeper thread will take it from here. */
-        pool_list->poison = 1;
+    /* The pool-sweeper thread will take it from here. */
+    pool_list->poison = 1;
 }
 
-
 static __attribute__((constructor)) void
-mem_pools_preinit (void)
+mem_pools_preinit(void)
 {
-        unsigned int    i;
+    unsigned int i;
 
-        INIT_LIST_HEAD (&pool_threads);
-        INIT_LIST_HEAD (&pool_free_threads);
+    INIT_LIST_HEAD(&pool_threads);
+    INIT_LIST_HEAD(&pool_free_threads);
 
-        for (i = 0; i < NPOOLS; ++i) {
-                pools[i].power_of_two = POOL_SMALLEST + i;
+    for (i = 0; i < NPOOLS; ++i) {
+        pools[i].power_of_two = POOL_SMALLEST + i;
 
-                GF_ATOMIC_INIT (pools[i].allocs_hot, 0);
-                GF_ATOMIC_INIT (pools[i].allocs_cold, 0);
-                GF_ATOMIC_INIT (pools[i].allocs_stdc, 0);
-                GF_ATOMIC_INIT (pools[i].frees_to_list, 0);
-        }
+        GF_ATOMIC_INIT(pools[i].allocs_hot, 0);
+        GF_ATOMIC_INIT(pools[i].allocs_cold, 0);
+        GF_ATOMIC_INIT(pools[i].allocs_stdc, 0);
+        GF_ATOMIC_INIT(pools[i].frees_to_list, 0);
+    }
 
-        pool_list_size = sizeof (per_thread_pool_list_t)
-                       + sizeof (per_thread_pool_t) * (NPOOLS - 1);
+    pool_list_size = sizeof(per_thread_pool_list_t) +
+                     sizeof(per_thread_pool_t) * (NPOOLS - 1);
 
-        init_done = GF_MEMPOOL_INIT_PREINIT;
+    init_done = GF_MEMPOOL_INIT_PREINIT;
 }
 
 /* Use mem_pools_init_early() function for basic initialization. There will be
@@ -547,358 +538,365 @@ mem_pools_preinit (void)
  * been called. Calling mem_get() will be possible after this function has
  * setup the basic structures. */
 void
-mem_pools_init_early (void)
+mem_pools_init_early(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        /* Use a pthread_key destructor to clean up when a thread exits.
-         *
-         * We won't increase init_count here, that is only done when the
-         * pool_sweeper thread is started too.
-         */
-        if (init_done == GF_MEMPOOL_INIT_PREINIT ||
-            init_done == GF_MEMPOOL_INIT_DESTROY) {
-                /* key has not been created yet */
-                if (pthread_key_create (&pool_key, pool_destructor) != 0) {
-                        gf_log ("mem-pool", GF_LOG_CRITICAL,
-                                "failed to initialize mem-pool key");
-                }
-
-                init_done = GF_MEMPOOL_INIT_EARLY;
-        } else {
-                gf_log ("mem-pool", GF_LOG_CRITICAL,
-                        "incorrect order of mem-pool initialization "
-                        "(init_done=%d)", init_done);
-        }
-
-        pthread_mutex_unlock (&init_mutex);
+    pthread_mutex_lock(&init_mutex);
+    /* Use a pthread_key destructor to clean up when a thread exits.
+     *
+     * We won't increase init_count here, that is only done when the
+     * pool_sweeper thread is started too.
+     */
+    if (init_done == GF_MEMPOOL_INIT_PREINIT ||
+        init_done == GF_MEMPOOL_INIT_DESTROY) {
+        /* key has not been created yet */
+        if (pthread_key_create(&pool_key, pool_destructor) != 0) {
+            gf_log("mem-pool", GF_LOG_CRITICAL,
+                   "failed to initialize mem-pool key");
+        }
+
+        init_done = GF_MEMPOOL_INIT_EARLY;
+    } else {
+        gf_log("mem-pool", GF_LOG_CRITICAL,
+               "incorrect order of mem-pool initialization "
+               "(init_done=%d)",
+               init_done);
+    }
+
+    pthread_mutex_unlock(&init_mutex);
 }
 
 /* Call mem_pools_init_late() once threading has been configured completely.
  * This prevent the pool_sweeper thread from getting killed once the main()
  * thread exits during deamonizing. */
 void
-mem_pools_init_late (void)
+mem_pools_init_late(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        if ((init_count++) == 0) {
-                (void) gf_thread_create (&sweeper_tid, NULL, pool_sweeper,
-                                         NULL, "memsweep");
-
-                init_done = GF_MEMPOOL_INIT_LATE;
-        }
-        pthread_mutex_unlock (&init_mutex);
+    pthread_mutex_lock(&init_mutex);
+    if ((init_count++) == 0) {
+        (void)gf_thread_create(&sweeper_tid, NULL, pool_sweeper, NULL,
+                               "memsweep");
+
+        init_done = GF_MEMPOOL_INIT_LATE;
+    }
+    pthread_mutex_unlock(&init_mutex);
 }
 
 void
-mem_pools_fini (void)
+mem_pools_fini(void)
 {
-        pthread_mutex_lock (&init_mutex);
-        switch (init_count) {
+    pthread_mutex_lock(&init_mutex);
+    switch (init_count) {
         case 0:
-                /*
-                 * If init_count is already zero (as e.g. if somebody called
-                 * this before mem_pools_init_late) then the sweeper was
-                 * probably never even started so we don't need to stop it.
-                 * Even if there's some crazy circumstance where there is a
-                 * sweeper but init_count is still zero, that just means we'll
-                 * leave it running.  Not perfect, but far better than any
-                 * known alternative.
-                 */
-                break;
-        case 1:
-        {
-                per_thread_pool_list_t *pool_list;
-                per_thread_pool_list_t *next_pl;
-                unsigned int            i;
-
-                /* if only mem_pools_init_early() was called, sweeper_tid will
-                 * be invalid and the functions will error out. That is not
-                 * critical. In all other cases, the sweeper_tid will be valid
-                 * and the thread gets stopped. */
-                (void) pthread_cancel (sweeper_tid);
-                (void) pthread_join (sweeper_tid, NULL);
-
-                /* Need to clean the pool_key to prevent further usage of the
-                 * per_thread_pool_list_t structure that is stored for each
-                 * thread.
-                 * This also prevents calling pool_destructor() when a thread
-                 * exits, so there is no chance on a use-after-free of the
-                 * per_thread_pool_list_t structure. */
-                (void) pthread_key_delete (pool_key);
-
-                /* free all objects from all pools */
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_threads, thr_list) {
-                        for (i = 0; i < NPOOLS; ++i) {
-                                free_obj_list (pool_list->pools[i].hot_list);
-                                free_obj_list (pool_list->pools[i].cold_list);
-                                pool_list->pools[i].hot_list = NULL;
-                                pool_list->pools[i].cold_list = NULL;
-                        }
-
-                        list_del (&pool_list->thr_list);
-                        FREE (pool_list);
+            /*
+             * If init_count is already zero (as e.g. if somebody called
+             * this before mem_pools_init_late) then the sweeper was
+             * probably never even started so we don't need to stop it.
+             * Even if there's some crazy circumstance where there is a
+             * sweeper but init_count is still zero, that just means we'll
+             * leave it running.  Not perfect, but far better than any
+             * known alternative.
+             */
+            break;
+        case 1: {
+            per_thread_pool_list_t *pool_list;
+            per_thread_pool_list_t *next_pl;
+            unsigned int i;
+
+            /* if only mem_pools_init_early() was called, sweeper_tid will
+             * be invalid and the functions will error out. That is not
+             * critical. In all other cases, the sweeper_tid will be valid
+             * and the thread gets stopped. */
+            (void)pthread_cancel(sweeper_tid);
+            (void)pthread_join(sweeper_tid, NULL);
+
+            /* Need to clean the pool_key to prevent further usage of the
+             * per_thread_pool_list_t structure that is stored for each
+             * thread.
+             * This also prevents calling pool_destructor() when a thread
+             * exits, so there is no chance on a use-after-free of the
+             * per_thread_pool_list_t structure. */
+            (void)pthread_key_delete(pool_key);
+
+            /* free all objects from all pools */
+            list_for_each_entry_safe(pool_list, next_pl, &pool_threads,
+                                     thr_list)
+            {
+                for (i = 0; i < NPOOLS; ++i) {
+                    free_obj_list(pool_list->pools[i].hot_list);
+                    free_obj_list(pool_list->pools[i].cold_list);
+                    pool_list->pools[i].hot_list = NULL;
+                    pool_list->pools[i].cold_list = NULL;
                 }
 
-                list_for_each_entry_safe (pool_list, next_pl,
-                                          &pool_free_threads, thr_list) {
-                        list_del (&pool_list->thr_list);
-                        FREE (pool_list);
-                }
+                list_del(&pool_list->thr_list);
+                FREE(pool_list);
+            }
 
-                init_done = GF_MEMPOOL_INIT_DESTROY;
-                /* Fall through. */
+            list_for_each_entry_safe(pool_list, next_pl, &pool_free_threads,
+                                     thr_list)
+            {
+                list_del(&pool_list->thr_list);
+                FREE(pool_list);
+            }
+
+            init_done = GF_MEMPOOL_INIT_DESTROY;
+            /* Fall through. */
         }
         default:
-                --init_count;
-        }
-        pthread_mutex_unlock (&init_mutex);
+            --init_count;
+    }
+    pthread_mutex_unlock(&init_mutex);
 }
 
 #else
-void mem_pools_init_early (void) {}
-void mem_pools_init_late (void) {}
-void mem_pools_fini (void) {}
+void
+mem_pools_init_early(void)
+{
+}
+void
+mem_pools_init_late(void)
+{
+}
+void
+mem_pools_fini(void)
+{
+}
 #endif
 
 struct mem_pool *
-mem_pool_new_fn (glusterfs_ctx_t *ctx, unsigned long sizeof_type,
-                 unsigned long count, char *name)
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+                unsigned long count, char *name)
 {
-        unsigned int            i;
-        struct mem_pool         *new = NULL;
-        struct mem_pool_shared  *pool = NULL;
-
-        if (!sizeof_type) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        for (i = 0; i < NPOOLS; ++i) {
-                if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
-                        pool = &pools[i];
-                        break;
-                }
-        }
-
-        if (!pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        new = GF_CALLOC (sizeof (struct mem_pool), 1, gf_common_mt_mem_pool);
-        if (!new)
-                return NULL;
-
-        new->ctx = ctx;
-        new->sizeof_type = sizeof_type;
-        new->count = count;
-        new->name = name;
-        new->pool = pool;
-        GF_ATOMIC_INIT (new->active, 0);
-        INIT_LIST_HEAD (&new->owner);
-
-        LOCK (&ctx->lock);
-        {
-                list_add (&new->owner, &ctx->mempool_list);
-        }
-        UNLOCK (&ctx->lock);
-
-        return new;
+    unsigned int i;
+    struct mem_pool *new = NULL;
+    struct mem_pool_shared *pool = NULL;
+
+    if (!sizeof_type) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
+
+    for (i = 0; i < NPOOLS; ++i) {
+        if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
+            pool = &pools[i];
+            break;
+        }
+    }
+
+    if (!pool) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
+
+    new = GF_CALLOC(sizeof(struct mem_pool), 1, gf_common_mt_mem_pool);
+    if (!new)
+        return NULL;
+
+    new->ctx = ctx;
+    new->sizeof_type = sizeof_type;
+    new->count = count;
+    new->name = name;
+    new->pool = pool;
+    GF_ATOMIC_INIT(new->active, 0);
+    INIT_LIST_HEAD(&new->owner);
+
+    LOCK(&ctx->lock);
+    {
+        list_add(&new->owner, &ctx->mempool_list);
+    }
+    UNLOCK(&ctx->lock);
+
+    return new;
 }
 
-void*
-mem_get0 (struct mem_pool *mem_pool)
+void *
+mem_get0(struct mem_pool *mem_pool)
 {
-        void             *ptr = NULL;
+    void *ptr = NULL;
 
-        if (!mem_pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
+    if (!mem_pool) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
 
-        ptr = mem_get(mem_pool);
-        if (ptr) {
+    ptr = mem_get(mem_pool);
+    if (ptr) {
 #if defined(GF_DISABLE_MEMPOOL)
-                memset (ptr, 0, mem_pool->sizeof_type);
+        memset(ptr, 0, mem_pool->sizeof_type);
 #else
-                memset (ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
+        memset(ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
 #endif
-        }
+    }
 
-        return ptr;
+    return ptr;
 }
 
-
 per_thread_pool_list_t *
-mem_get_pool_list (void)
+mem_get_pool_list(void)
 {
-        per_thread_pool_list_t  *pool_list;
-        unsigned int            i;
-
-        pool_list = pthread_getspecific (pool_key);
-        if (pool_list) {
-                return pool_list;
-        }
-
-        (void) pthread_mutex_lock (&pool_free_lock);
-        if (!list_empty (&pool_free_threads)) {
-                pool_list = list_entry (pool_free_threads.next,
-                                        per_thread_pool_list_t, thr_list);
-                list_del (&pool_list->thr_list);
-        }
-        (void) pthread_mutex_unlock (&pool_free_lock);
+    per_thread_pool_list_t *pool_list;
+    unsigned int i;
 
+    pool_list = pthread_getspecific(pool_key);
+    if (pool_list) {
+        return pool_list;
+    }
+
+    (void)pthread_mutex_lock(&pool_free_lock);
+    if (!list_empty(&pool_free_threads)) {
+        pool_list = list_entry(pool_free_threads.next, per_thread_pool_list_t,
+                               thr_list);
+        list_del(&pool_list->thr_list);
+    }
+    (void)pthread_mutex_unlock(&pool_free_lock);
+
+    if (!pool_list) {
+        pool_list = CALLOC(pool_list_size, 1);
         if (!pool_list) {
-                pool_list = CALLOC (pool_list_size, 1);
-                if (!pool_list) {
-                        return NULL;
-                }
+            return NULL;
+        }
 
-                INIT_LIST_HEAD (&pool_list->thr_list);
-                (void) pthread_spin_init (&pool_list->lock,
-                                          PTHREAD_PROCESS_PRIVATE);
-                for (i = 0; i < NPOOLS; ++i) {
-                        pool_list->pools[i].parent = &pools[i];
-                        pool_list->pools[i].hot_list = NULL;
-                        pool_list->pools[i].cold_list = NULL;
-                }
+        INIT_LIST_HEAD(&pool_list->thr_list);
+        (void)pthread_spin_init(&pool_list->lock, PTHREAD_PROCESS_PRIVATE);
+        for (i = 0; i < NPOOLS; ++i) {
+            pool_list->pools[i].parent = &pools[i];
+            pool_list->pools[i].hot_list = NULL;
+            pool_list->pools[i].cold_list = NULL;
         }
+    }
 
-        (void) pthread_mutex_lock (&pool_lock);
-        pool_list->poison = 0;
-        list_add (&pool_list->thr_list, &pool_threads);
-        (void) pthread_mutex_unlock (&pool_lock);
+    (void)pthread_mutex_lock(&pool_lock);
+    pool_list->poison = 0;
+    list_add(&pool_list->thr_list, &pool_threads);
+    (void)pthread_mutex_unlock(&pool_lock);
 
-        (void) pthread_setspecific (pool_key, pool_list);
-        return pool_list;
+    (void)pthread_setspecific(pool_key, pool_list);
+    return pool_list;
 }
 
 pooled_obj_hdr_t *
-mem_get_from_pool (per_thread_pool_t *pt_pool)
+mem_get_from_pool(per_thread_pool_t *pt_pool)
 {
-        pooled_obj_hdr_t        *retval;
-
-        retval = pt_pool->hot_list;
-        if (retval) {
-                GF_ATOMIC_INC (pt_pool->parent->allocs_hot);
-                pt_pool->hot_list = retval->next;
-                return retval;
-        }
-
-        retval = pt_pool->cold_list;
-        if (retval) {
-                GF_ATOMIC_INC (pt_pool->parent->allocs_cold);
-                pt_pool->cold_list = retval->next;
-                return retval;
-        }
-
-        GF_ATOMIC_INC (pt_pool->parent->allocs_stdc);
-        return malloc (1 << pt_pool->parent->power_of_two);
+    pooled_obj_hdr_t *retval;
+
+    retval = pt_pool->hot_list;
+    if (retval) {
+        GF_ATOMIC_INC(pt_pool->parent->allocs_hot);
+        pt_pool->hot_list = retval->next;
+        return retval;
+    }
+
+    retval = pt_pool->cold_list;
+    if (retval) {
+        GF_ATOMIC_INC(pt_pool->parent->allocs_cold);
+        pt_pool->cold_list = retval->next;
+        return retval;
+    }
+
+    GF_ATOMIC_INC(pt_pool->parent->allocs_stdc);
+    return malloc(1 << pt_pool->parent->power_of_two);
 }
 
-
 void *
-mem_get (struct mem_pool *mem_pool)
+mem_get(struct mem_pool *mem_pool)
 {
 #if defined(GF_DISABLE_MEMPOOL)
-        return GF_MALLOC (mem_pool->sizeof_type, gf_common_mt_mem_pool);
+    return GF_MALLOC(mem_pool->sizeof_type, gf_common_mt_mem_pool);
 #else
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_t       *pt_pool;
-        pooled_obj_hdr_t        *retval;
-
-        if (!mem_pool) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        pool_list = mem_get_pool_list ();
-        if (!pool_list || pool_list->poison) {
-                return NULL;
-        }
-
-        (void) pthread_spin_lock (&pool_list->lock);
-        pt_pool = &pool_list->pools[mem_pool->pool->power_of_two-POOL_SMALLEST];
-        retval = mem_get_from_pool (pt_pool);
-
-        if (!retval) {
-                (void) pthread_spin_unlock (&pool_list->lock);
-                return NULL;
-        }
-
-        retval->magic = GF_MEM_HEADER_MAGIC;
-        retval->pool = mem_pool;
-        retval->pool_list = pool_list;
-        retval->power_of_two = mem_pool->pool->power_of_two;
-        (void) pthread_spin_unlock (&pool_list->lock);
-
-        GF_ATOMIC_INC (mem_pool->active);
-
-        return retval + 1;
+    per_thread_pool_list_t *pool_list;
+    per_thread_pool_t *pt_pool;
+    pooled_obj_hdr_t *retval;
+
+    if (!mem_pool) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return NULL;
+    }
+
+    pool_list = mem_get_pool_list();
+    if (!pool_list || pool_list->poison) {
+        return NULL;
+    }
+
+    (void)pthread_spin_lock(&pool_list->lock);
+    pt_pool = &pool_list->pools[mem_pool->pool->power_of_two - POOL_SMALLEST];
+    retval = mem_get_from_pool(pt_pool);
+
+    if (!retval) {
+        (void)pthread_spin_unlock(&pool_list->lock);
+        return NULL;
+    }
+
+    retval->magic = GF_MEM_HEADER_MAGIC;
+    retval->pool = mem_pool;
+    retval->pool_list = pool_list;
+    retval->power_of_two = mem_pool->pool->power_of_two;
+    (void)pthread_spin_unlock(&pool_list->lock);
+
+    GF_ATOMIC_INC(mem_pool->active);
+
+    return retval + 1;
 #endif /* GF_DISABLE_MEMPOOL */
 }
 
-
 void
-mem_put (void *ptr)
+mem_put(void *ptr)
 {
 #if defined(GF_DISABLE_MEMPOOL)
-        GF_FREE (ptr);
+    GF_FREE(ptr);
 #else
-        pooled_obj_hdr_t        *hdr;
-        per_thread_pool_list_t  *pool_list;
-        per_thread_pool_t       *pt_pool;
-
-        if (!ptr) {
-                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
-
-        hdr = ((pooled_obj_hdr_t *)ptr) - 1;
-        if (hdr->magic != GF_MEM_HEADER_MAGIC) {
-                /* Not one of ours; don't touch it. */
-                return;
-        }
-        pool_list = hdr->pool_list;
-        pt_pool = &pool_list->pools[hdr->power_of_two-POOL_SMALLEST];
+    pooled_obj_hdr_t *hdr;
+    per_thread_pool_list_t *pool_list;
+    per_thread_pool_t *pt_pool;
 
-        GF_ATOMIC_DEC (hdr->pool->active);
+    if (!ptr) {
+        gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return;
+    }
 
-        (void) pthread_spin_lock (&pool_list->lock);
-        hdr->magic = GF_MEM_INVALID_MAGIC;
-        hdr->next = pt_pool->hot_list;
-        pt_pool->hot_list = hdr;
-        GF_ATOMIC_INC (pt_pool->parent->frees_to_list);
-        (void) pthread_spin_unlock (&pool_list->lock);
+    hdr = ((pooled_obj_hdr_t *)ptr) - 1;
+    if (hdr->magic != GF_MEM_HEADER_MAGIC) {
+        /* Not one of ours; don't touch it. */
+        return;
+    }
+    pool_list = hdr->pool_list;
+    pt_pool = &pool_list->pools[hdr->power_of_two - POOL_SMALLEST];
+
+    GF_ATOMIC_DEC(hdr->pool->active);
+
+    (void)pthread_spin_lock(&pool_list->lock);
+    hdr->magic = GF_MEM_INVALID_MAGIC;
+    hdr->next = pt_pool->hot_list;
+    pt_pool->hot_list = hdr;
+    GF_ATOMIC_INC(pt_pool->parent->frees_to_list);
+    (void)pthread_spin_unlock(&pool_list->lock);
 #endif /* GF_DISABLE_MEMPOOL */
 }
 
 void
-mem_pool_destroy (struct mem_pool *pool)
+mem_pool_destroy(struct mem_pool *pool)
 {
-        if (!pool)
-                return;
-
-        /* remove this pool from the owner (glusterfs_ctx_t) */
-        LOCK (&pool->ctx->lock);
-        {
-                list_del (&pool->owner);
-        }
-        UNLOCK (&pool->ctx->lock);
-
-        /* free this pool, but keep the mem_pool_shared */
-        GF_FREE (pool);
+    if (!pool)
+        return;
 
-        /*
-         * Pools are now permanent, so the mem_pool->pool is kept around. All
-         * of the objects *in* the pool will eventually be freed via the
-         * pool-sweeper thread, and this way we don't have to add a lot of
-         * reference-counting complexity.
-         */
+    /* remove this pool from the owner (glusterfs_ctx_t) */
+    LOCK(&pool->ctx->lock);
+    {
+        list_del(&pool->owner);
+    }
+    UNLOCK(&pool->ctx->lock);
+
+    /* free this pool, but keep the mem_pool_shared */
+    GF_FREE(pool);
+
+    /*
+     * Pools are now permanent, so the mem_pool->pool is kept around. All
+     * of the objects *in* the pool will eventually be freed via the
+     * pool-sweeper thread, and this way we don't have to add a lot of
+     * reference-counting complexity.
+     */
 }
diff --git a/libglusterfs/src/monitoring.c b/libglusterfs/src/monitoring.c
index 10b0a817e40..041b70acf7a 100644
--- a/libglusterfs/src/monitoring.c
+++ b/libglusterfs/src/monitoring.c
@@ -17,254 +17,256 @@
 static void
 dump_mem_acct_details(xlator_t *xl, int fd)
 {
-        struct mem_acct_rec *mem_rec;
-        int i = 0;
-
-        if (!xl || !xl->mem_acct || (xl->ctx->active != xl->graph))
-                return;
-
-        dprintf (fd, "# %s.%s.total.num_types %d\n", xl->type, xl->name,
-                 xl->mem_acct->num_types);
-
-        dprintf (fd, "# type, in-use-size, in-use-units, max-size, "
-                 "max-units, total-allocs\n");
-
-        for (i = 0; i < xl->mem_acct->num_types; i++) {
-                mem_rec = &xl->mem_acct->rec[i];
-                if (mem_rec->num_allocs == 0)
-                        continue;
-                dprintf (fd, "# %s, %"GF_PRI_SIZET", %u, %"GF_PRI_SIZET", %u,"
-                         " %u\n", mem_rec->typestr, mem_rec->size,
-                         mem_rec->num_allocs, mem_rec->max_size,
-                         mem_rec->max_num_allocs, mem_rec->total_allocs);
-        }
+    struct mem_acct_rec *mem_rec;
+    int i = 0;
+
+    if (!xl || !xl->mem_acct || (xl->ctx->active != xl->graph))
+        return;
+
+    dprintf(fd, "# %s.%s.total.num_types %d\n", xl->type, xl->name,
+            xl->mem_acct->num_types);
+
+    dprintf(fd,
+            "# type, in-use-size, in-use-units, max-size, "
+            "max-units, total-allocs\n");
+
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        mem_rec = &xl->mem_acct->rec[i];
+        if (mem_rec->num_allocs == 0)
+            continue;
+        dprintf(fd,
+                "# %s, %" GF_PRI_SIZET ", %u, %" GF_PRI_SIZET
+                ", %u,"
+                " %u\n",
+                mem_rec->typestr, mem_rec->size, mem_rec->num_allocs,
+                mem_rec->max_size, mem_rec->max_num_allocs,
+                mem_rec->total_allocs);
+    }
 }
 
 static void
-dump_global_memory_accounting (int fd)
+dump_global_memory_accounting(int fd)
 {
 #if MEMORY_ACCOUNTING_STATS
-        int      i        = 0;
-        uint64_t count    = 0;
-
-        uint64_t tcalloc = GF_ATOMIC_GET (gf_memory_stat_counts.total_calloc);
-        uint64_t tmalloc = GF_ATOMIC_GET (gf_memory_stat_counts.total_malloc);
-        uint64_t tfree   = GF_ATOMIC_GET (gf_memory_stat_counts.total_free);
-
-        dprintf (fd, "memory.total.calloc %lu\n", tcalloc);
-        dprintf (fd, "memory.total.malloc %lu\n", tmalloc);
-        dprintf (fd, "memory.total.realloc %lu\n",
-                 GF_ATOMIC_GET (gf_memory_stat_counts.total_realloc));
-        dprintf (fd, "memory.total.free %lu\n", tfree);
-        dprintf (fd, "memory.total.in-use %lu\n", ((tcalloc + tmalloc) - tfree));
-
-        for (i = 0; i < GF_BLK_MAX_VALUE; i++) {
-                count = GF_ATOMIC_GET (gf_memory_stat_counts.blk_size[i]);
-                dprintf (fd, "memory.total.blk_size.%s %lu\n",
-                         gf_mem_stats_blk[i].blk_size_str, count);
-        }
-
-        dprintf (fd, "#----\n");
+    int i = 0;
+    uint64_t count = 0;
+
+    uint64_t tcalloc = GF_ATOMIC_GET(gf_memory_stat_counts.total_calloc);
+    uint64_t tmalloc = GF_ATOMIC_GET(gf_memory_stat_counts.total_malloc);
+    uint64_t tfree = GF_ATOMIC_GET(gf_memory_stat_counts.total_free);
+
+    dprintf(fd, "memory.total.calloc %lu\n", tcalloc);
+    dprintf(fd, "memory.total.malloc %lu\n", tmalloc);
+    dprintf(fd, "memory.total.realloc %lu\n",
+            GF_ATOMIC_GET(gf_memory_stat_counts.total_realloc));
+    dprintf(fd, "memory.total.free %lu\n", tfree);
+    dprintf(fd, "memory.total.in-use %lu\n", ((tcalloc + tmalloc) - tfree));
+
+    for (i = 0; i < GF_BLK_MAX_VALUE; i++) {
+        count = GF_ATOMIC_GET(gf_memory_stat_counts.blk_size[i]);
+        dprintf(fd, "memory.total.blk_size.%s %lu\n",
+                gf_mem_stats_blk[i].blk_size_str, count);
+    }
+
+    dprintf(fd, "#----\n");
 #endif
 
-        /* This is not a metric to be watched in admin guide,
-           but keeping it here till we resolve all leak-issues
-           would be great */
+    /* This is not a metric to be watched in admin guide,
+       but keeping it here till we resolve all leak-issues
+       would be great */
 }
 
-
 static void
-dump_latency_and_count (xlator_t *xl, int fd)
+dump_latency_and_count(xlator_t *xl, int fd)
 {
-        int32_t  index = 0;
-        uint64_t fop;
-        uint64_t cbk;
-        uint64_t count;
-
-        if (xl->winds)
-                dprintf (fd, "%s.total.pending-winds.count %lu\n", xl->name, xl->winds);
-
-        /* Need 'fuse' data, and don't need all the old graph info */
-        if ((xl != xl->ctx->master) && (xl->ctx->active != xl->graph))
-                return;
-
-        count = GF_ATOMIC_GET (xl->stats.total.count);
-        dprintf (fd, "%s.total.fop-count %lu\n", xl->name, count);
-
-        count = GF_ATOMIC_GET (xl->stats.interval.count);
-        dprintf (fd, "%s.interval.fop-count %lu\n", xl->name, count);
-        GF_ATOMIC_INIT (xl->stats.interval.count, 0);
-
-        for (index = 0; index < GF_FOP_MAXVALUE; index++) {
-                fop = GF_ATOMIC_GET (xl->stats.total.metrics[index].fop);
-                if (fop) {
-                        dprintf (fd, "%s.total.%s.count %lu\n",
-                                 xl->name, gf_fop_list[index], fop);
-                }
-                fop = GF_ATOMIC_GET (xl->stats.interval.metrics[index].fop);
-                if (fop) {
-                        dprintf (fd, "%s.interval.%s.count %lu\n",
-                                 xl->name, gf_fop_list[index], fop);
-                }
-                cbk = GF_ATOMIC_GET (xl->stats.interval.metrics[index].cbk);
-                if (cbk) {
-                        dprintf (fd, "%s.interval.%s.fail_count %lu\n",
-                                 xl->name, gf_fop_list[index], cbk);
-                }
-                if (xl->stats.interval.latencies[index].count != 0.0) {
-                        dprintf (fd, "%s.interval.%s.latency %lf\n",
-                                 xl->name, gf_fop_list[index],
-                                 (xl->stats.interval.latencies[index].total /
-                                  xl->stats.interval.latencies[index].count));
-                        dprintf (fd, "%s.interval.%s.max %lf\n",
-                                 xl->name, gf_fop_list[index],
-                                 xl->stats.interval.latencies[index].max);
-                        dprintf (fd, "%s.interval.%s.min %lf\n",
-                                 xl->name, gf_fop_list[index],
-                                 xl->stats.interval.latencies[index].min);
-                }
-                GF_ATOMIC_INIT (xl->stats.interval.metrics[index].cbk, 0);
-                GF_ATOMIC_INIT (xl->stats.interval.metrics[index].fop, 0);
+    int32_t index = 0;
+    uint64_t fop;
+    uint64_t cbk;
+    uint64_t count;
+
+    if (xl->winds)
+        dprintf(fd, "%s.total.pending-winds.count %lu\n", xl->name, xl->winds);
+
+    /* Need 'fuse' data, and don't need all the old graph info */
+    if ((xl != xl->ctx->master) && (xl->ctx->active != xl->graph))
+        return;
+
+    count = GF_ATOMIC_GET(xl->stats.total.count);
+    dprintf(fd, "%s.total.fop-count %lu\n", xl->name, count);
+
+    count = GF_ATOMIC_GET(xl->stats.interval.count);
+    dprintf(fd, "%s.interval.fop-count %lu\n", xl->name, count);
+    GF_ATOMIC_INIT(xl->stats.interval.count, 0);
+
+    for (index = 0; index < GF_FOP_MAXVALUE; index++) {
+        fop = GF_ATOMIC_GET(xl->stats.total.metrics[index].fop);
+        if (fop) {
+            dprintf(fd, "%s.total.%s.count %lu\n", xl->name, gf_fop_list[index],
+                    fop);
         }
-        memset (xl->stats.interval.latencies, 0,
-                sizeof (xl->stats.interval.latencies));
+        fop = GF_ATOMIC_GET(xl->stats.interval.metrics[index].fop);
+        if (fop) {
+            dprintf(fd, "%s.interval.%s.count %lu\n", xl->name,
+                    gf_fop_list[index], fop);
+        }
+        cbk = GF_ATOMIC_GET(xl->stats.interval.metrics[index].cbk);
+        if (cbk) {
+            dprintf(fd, "%s.interval.%s.fail_count %lu\n", xl->name,
+                    gf_fop_list[index], cbk);
+        }
+        if (xl->stats.interval.latencies[index].count != 0.0) {
+            dprintf(fd, "%s.interval.%s.latency %lf\n", xl->name,
+                    gf_fop_list[index],
+                    (xl->stats.interval.latencies[index].total /
+                     xl->stats.interval.latencies[index].count));
+            dprintf(fd, "%s.interval.%s.max %lf\n", xl->name,
+                    gf_fop_list[index],
+                    xl->stats.interval.latencies[index].max);
+            dprintf(fd, "%s.interval.%s.min %lf\n", xl->name,
+                    gf_fop_list[index],
+                    xl->stats.interval.latencies[index].min);
+        }
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[index].cbk, 0);
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[index].fop, 0);
+    }
+    memset(xl->stats.interval.latencies, 0,
+           sizeof(xl->stats.interval.latencies));
 }
 
 static inline void
-dump_call_stack_details (glusterfs_ctx_t *ctx, int fd)
+dump_call_stack_details(glusterfs_ctx_t *ctx, int fd)
 {
-        dprintf (fd, "total.stack.count %lu\n",
-                 GF_ATOMIC_GET (ctx->pool->total_count));
-        dprintf (fd, "total.stack.in-flight %lu\n",
-                 ctx->pool->cnt);
+    dprintf(fd, "total.stack.count %lu\n",
+            GF_ATOMIC_GET(ctx->pool->total_count));
+    dprintf(fd, "total.stack.in-flight %lu\n", ctx->pool->cnt);
 }
 
 static inline void
-dump_dict_details (glusterfs_ctx_t *ctx, int fd)
+dump_dict_details(glusterfs_ctx_t *ctx, int fd)
 {
-        uint64_t total_dicts = 0;
-        uint64_t total_pairs = 0;
-
-        total_dicts = GF_ATOMIC_GET (ctx->stats.total_dicts_used);
-        total_pairs = GF_ATOMIC_GET (ctx->stats.total_pairs_used);
-
-        dprintf (fd, "total.dict.max-pairs-per %lu\n",
-                 GF_ATOMIC_GET (ctx->stats.max_dict_pairs));
-        dprintf (fd, "total.dict.pairs-used %lu\n", total_pairs);
-        dprintf (fd, "total.dict.used %lu\n", total_dicts);
-        dprintf (fd, "total.dict.average-pairs %lu\n",
-                            (total_pairs / total_dicts));
+    uint64_t total_dicts = 0;
+    uint64_t total_pairs = 0;
+
+    total_dicts = GF_ATOMIC_GET(ctx->stats.total_dicts_used);
+    total_pairs = GF_ATOMIC_GET(ctx->stats.total_pairs_used);
+
+    dprintf(fd, "total.dict.max-pairs-per %lu\n",
+            GF_ATOMIC_GET(ctx->stats.max_dict_pairs));
+    dprintf(fd, "total.dict.pairs-used %lu\n", total_pairs);
+    dprintf(fd, "total.dict.used %lu\n", total_dicts);
+    dprintf(fd, "total.dict.average-pairs %lu\n", (total_pairs / total_dicts));
 }
 
 static void
-dump_inode_stats (glusterfs_ctx_t *ctx, int fd)
+dump_inode_stats(glusterfs_ctx_t *ctx, int fd)
 {
 }
 
 static void
-dump_global_metrics (glusterfs_ctx_t *ctx, int fd)
+dump_global_metrics(glusterfs_ctx_t *ctx, int fd)
 {
-        struct timeval tv;
-        time_t nowtime;
-        struct tm *nowtm;
-        char tmbuf[64] = {0,};
-
-        gettimeofday(&tv, NULL);
-        nowtime = tv.tv_sec;
-        nowtm = localtime(&nowtime);
-        strftime(tmbuf, sizeof tmbuf, "%Y-%m-%d %H:%M:%S", nowtm);
-
-        /* Let every file have information on which process dumped info */
-        dprintf (fd, "## %s\n", ctx->cmdlinestr);
-        dprintf (fd, "### %s\n", tmbuf);
-        dprintf (fd, "### BrickName: %s\n", ctx->cmd_args.brick_name);
-        dprintf (fd, "### MountName: %s\n", ctx->cmd_args.mount_point);
-        dprintf (fd, "### VolumeName: %s\n", ctx->cmd_args.volume_name);
-
-        /* Dump memory accounting */
-        dump_global_memory_accounting (fd);
-        dprintf (fd, "# -----\n");
-
-        dump_call_stack_details (ctx, fd);
-        dump_dict_details (ctx, fd);
-        dprintf (fd, "# -----\n");
-
-        dump_inode_stats (ctx, fd);
-        dprintf (fd, "# -----\n");
+    struct timeval tv;
+    time_t nowtime;
+    struct tm *nowtm;
+    char tmbuf[64] = {
+        0,
+    };
+
+    gettimeofday(&tv, NULL);
+    nowtime = tv.tv_sec;
+    nowtm = localtime(&nowtime);
+    strftime(tmbuf, sizeof tmbuf, "%Y-%m-%d %H:%M:%S", nowtm);
+
+    /* Let every file have information on which process dumped info */
+    dprintf(fd, "## %s\n", ctx->cmdlinestr);
+    dprintf(fd, "### %s\n", tmbuf);
+    dprintf(fd, "### BrickName: %s\n", ctx->cmd_args.brick_name);
+    dprintf(fd, "### MountName: %s\n", ctx->cmd_args.mount_point);
+    dprintf(fd, "### VolumeName: %s\n", ctx->cmd_args.volume_name);
+
+    /* Dump memory accounting */
+    dump_global_memory_accounting(fd);
+    dprintf(fd, "# -----\n");
+
+    dump_call_stack_details(ctx, fd);
+    dump_dict_details(ctx, fd);
+    dprintf(fd, "# -----\n");
+
+    dump_inode_stats(ctx, fd);
+    dprintf(fd, "# -----\n");
 }
 
 static void
-dump_xl_metrics (glusterfs_ctx_t *ctx, int fd)
+dump_xl_metrics(glusterfs_ctx_t *ctx, int fd)
 {
-        xlator_t *xl;
+    xlator_t *xl;
 
-        xl = ctx->active->top;
+    xl = ctx->active->top;
 
-        while (xl) {
-                dump_latency_and_count (xl, fd);
-                dump_mem_acct_details (xl, fd);
-                if (xl->dump_metrics)
-                        xl->dump_metrics (xl, fd);
-                xl = xl->next;
-        }
+    while (xl) {
+        dump_latency_and_count(xl, fd);
+        dump_mem_acct_details(xl, fd);
+        if (xl->dump_metrics)
+            xl->dump_metrics(xl, fd);
+        xl = xl->next;
+    }
 
-        if (ctx->master) {
-                xl = ctx->master;
+    if (ctx->master) {
+        xl = ctx->master;
 
-                dump_latency_and_count (xl, fd);
-                dump_mem_acct_details (xl, fd);
-                if (xl->dump_metrics)
-                        xl->dump_metrics (xl, fd);
-        }
+        dump_latency_and_count(xl, fd);
+        dump_mem_acct_details(xl, fd);
+        if (xl->dump_metrics)
+            xl->dump_metrics(xl, fd);
+    }
 
-        return;
+    return;
 }
 
 char *
-gf_monitor_metrics (glusterfs_ctx_t *ctx)
+gf_monitor_metrics(glusterfs_ctx_t *ctx)
 {
-        int ret = -1;
-        int fd = 0;
-        char *filepath, *dumppath;
-
-        dumppath = ctx->config.metrics_dumppath;
-        if (dumppath == NULL) {
-                dumppath = GLUSTER_METRICS_DIR;
-        }
-
-        ret = gf_asprintf(&filepath, "%s/gmetrics.XXXXXX", dumppath);
-        if (ret < 0) {
-                return NULL;
-        }
-
-        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-        fd = mkstemp (filepath);
-        if (fd < 0) {
-                gf_msg ("monitoring", GF_LOG_ERROR, 0, LG_MSG_STRDUP_ERROR,
-                        "failed to open tmp file %s (%s)",
-                        filepath, strerror (errno));
-                GF_FREE (filepath);
-                return NULL;
-        }
-
-        dump_global_metrics (ctx, fd);
-
-        dump_xl_metrics (ctx, fd);
-
-        /* This below line is used just to capture any errors with dprintf() */
-        ret = dprintf (fd, "\n# End of metrics\n");
-        if (ret < 0) {
-                gf_msg ("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
-                        "dprintf() failed: %s", strerror (errno));
-        }
-
-        ret = sys_fsync (fd);
-        if (ret < 0) {
-                gf_msg ("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
-                        "fsync() failed: %s", strerror (errno));
-        }
-        sys_close (fd);
-
-        /* Figure this out, not happy with returning this string */
-        return filepath;
+    int ret = -1;
+    int fd = 0;
+    char *filepath, *dumppath;
+
+    dumppath = ctx->config.metrics_dumppath;
+    if (dumppath == NULL) {
+        dumppath = GLUSTER_METRICS_DIR;
+    }
+
+    ret = gf_asprintf(&filepath, "%s/gmetrics.XXXXXX", dumppath);
+    if (ret < 0) {
+        return NULL;
+    }
+
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(filepath);
+    if (fd < 0) {
+        gf_msg("monitoring", GF_LOG_ERROR, 0, LG_MSG_STRDUP_ERROR,
+               "failed to open tmp file %s (%s)", filepath, strerror(errno));
+        GF_FREE(filepath);
+        return NULL;
+    }
+
+    dump_global_metrics(ctx, fd);
+
+    dump_xl_metrics(ctx, fd);
+
+    /* This below line is used just to capture any errors with dprintf() */
+    ret = dprintf(fd, "\n# End of metrics\n");
+    if (ret < 0) {
+        gf_msg("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
+               "dprintf() failed: %s", strerror(errno));
+    }
+
+    ret = sys_fsync(fd);
+    if (ret < 0) {
+        gf_msg("monitoring", GF_LOG_WARNING, 0, LG_MSG_STRDUP_ERROR,
+               "fsync() failed: %s", strerror(errno));
+    }
+    sys_close(fd);
+
+    /* Figure this out, not happy with returning this string */
+    return filepath;
 }
diff --git a/libglusterfs/src/options.c b/libglusterfs/src/options.c
index a0f04c772e8..30607d2e390 100644
--- a/libglusterfs/src/options.c
+++ b/libglusterfs/src/options.c
@@ -16,1238 +16,1206 @@
 
 #define GF_OPTION_LIST_EMPTY(_opt) (_opt->value[0] == NULL)
 
-
 static int
-xlator_option_validate_path (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_path(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        int   ret = -1;
-        char  errstr[256];
-
-        if (strstr (value, "../")) {
-                snprintf (errstr, 256,
-                          "invalid path given '%s'",
-                          value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-                /* Make sure the given path is valid */
-        if (value[0] != '/') {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not an "
-                          "absolute path name",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    char errstr[256];
+
+    if (strstr(value, "../")) {
+        snprintf(errstr, 256, "invalid path given '%s'", value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    /* Make sure the given path is valid */
+    if (value[0] != '/') {
+        snprintf(errstr, 256,
+                 "option %s %s: '%s' is not an "
+                 "absolute path name",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
 static int
-xlator_option_validate_int (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_int(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        long long inputll = 0;
-        unsigned long long uinputll = 0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2longlong (value, &inputll) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        /* Handle '-0' */
-        if ((inputll == 0) && (gf_string2ulonglong (value, &uinputll) != 0)) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        if ((opt->min == 0) && (opt->max == 0) &&
-            (opt->validate == GF_OPT_VALIDATE_BOTH)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
+    long long inputll = 0;
+    unsigned long long uinputll = 0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2longlong(value, &inputll) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    /* Handle '-0' */
+    if ((inputll == 0) && (gf_string2ulonglong(value, &uinputll) != 0)) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0) &&
+        (opt->validate == GF_OPT_VALIDATE_BOTH)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        ret = 0;
+        goto out;
+    }
+
+    if (opt->validate == GF_OPT_VALIDATE_MIN) {
+        if (inputll < opt->min) {
+            snprintf(errstr, 256,
+                     "'%lld' in 'option %s %s' is smaller than "
+                     "minimum value '%.0f'",
+                     inputll, key, value, opt->min);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
+                   errstr);
+            goto out;
         }
-
-        if (opt->validate == GF_OPT_VALIDATE_MIN) {
-                if (inputll < opt->min) {
-                        snprintf (errstr, 256,
-                                  "'%lld' in 'option %s %s' is smaller than "
-                                  "minimum value '%.0f'", inputll, key,
-                                  value, opt->min);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
-                if (inputll > opt->max) {
-                        snprintf (errstr, 256,
-                                  "'%lld' in 'option %s %s' is greater than "
-                                  "maximum value '%.0f'", inputll, key,
-                                  value, opt->max);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if ((inputll < opt->min) || (inputll > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%lld' in 'option %s %s' is out of range "
-                          "[%.0f - %.0f]",
-                          inputll, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+    } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
+        if (inputll > opt->max) {
+            snprintf(errstr, 256,
+                     "'%lld' in 'option %s %s' is greater than "
+                     "maximum value '%.0f'",
+                     inputll, key, value, opt->max);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
+                   errstr);
+            goto out;
         }
-
-        ret = 0;
+    } else if ((inputll < opt->min) || (inputll > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%lld' in 'option %s %s' is out of range "
+                 "[%.0f - %.0f]",
+                 inputll, key, value, opt->min, opt->max);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_sizet (xlator_t *xl, const char *key, const char *value,
-                              volume_option_t *opt, char **op_errstr)
+xlator_option_validate_sizet(xlator_t *xl, const char *key, const char *value,
+                             volume_option_t *opt, char **op_errstr)
 {
-        size_t  size = 0;
-        int       ret = 0;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2bytesize_size (value, &size) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                ret = -1;
-                goto out;
-        }
-
-        if ((opt->min == 0) && (opt->max == 0)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                goto out;
-        }
-
-        if ((size < opt->min) || (size > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%" GF_PRI_SIZET "' in 'option %s %s' "
-                          "is out of range [%.0f - %.0f]",
-                          size, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0,
-                        LG_MSG_OUT_OF_RANGE, "%s", errstr);
-                ret = -1;
-        }
+    size_t size = 0;
+    int ret = 0;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2bytesize_size(value, &size) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        ret = -1;
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
+        goto out;
+    }
+
+    if ((size < opt->min) || (size > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%" GF_PRI_SIZET
+                 "' in 'option %s %s' "
+                 "is out of range [%.0f - %.0f]",
+                 size, key, value, opt->min, opt->max);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr);
+        ret = -1;
+    }
 
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_bool (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_bool(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        gf_boolean_t is_valid;
+    int ret = -1;
+    char errstr[256];
+    gf_boolean_t is_valid;
 
+    /* Check if the value is one of
+       '0|1|on|off|no|yes|true|false|enable|disable' */
 
-        /* Check if the value is one of
-           '0|1|on|off|no|yes|true|false|enable|disable' */
+    if (gf_string2boolean(value, &is_valid) != 0) {
+        snprintf(errstr, 256, "option %s %s: '%s' is not a valid boolean value",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
 
-        if (gf_string2boolean (value, &is_valid) != 0) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not a valid boolean value",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_xlator (xlator_t *xl, const char *key, const char *value,
-                               volume_option_t *opt, char **op_errstr)
+xlator_option_validate_xlator(xlator_t *xl, const char *key, const char *value,
+                              volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        xlator_t    *xlopt = NULL;
-
-
-        /* Check if the value is one of the xlators */
-        xlopt = xl;
-        while (xlopt->prev)
-                xlopt = xlopt->prev;
-
-        while (xlopt) {
-                if (strcmp (value, xlopt->name) == 0) {
-                        ret = 0;
-                        break;
-                }
-                xlopt = xlopt->next;
+    int ret = -1;
+    char errstr[256];
+    xlator_t *xlopt = NULL;
+
+    /* Check if the value is one of the xlators */
+    xlopt = xl;
+    while (xlopt->prev)
+        xlopt = xlopt->prev;
+
+    while (xlopt) {
+        if (strcmp(value, xlopt->name) == 0) {
+            ret = 0;
+            break;
         }
+        xlopt = xlopt->next;
+    }
 
-        if (!xlopt) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s' is not a valid volume name",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
+    if (!xlopt) {
+        snprintf(errstr, 256, "option %s %s: '%s' is not a valid volume name",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
 void
-set_error_str (char *errstr, size_t len, volume_option_t *opt, const char *key,
-               const char *value)
+set_error_str(char *errstr, size_t len, volume_option_t *opt, const char *key,
+              const char *value)
 {
-        int i   = 0;
-        int ret = 0;
-
-        ret = snprintf (errstr, len, "option %s %s: '%s' is not valid "
-                        "(possible options are ", key, value, value);
-
-        for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i];) {
-                ret += snprintf (errstr + ret, len - ret, "%s", opt->value[i]);
-                if (((++i) < ZR_OPTION_MAX_ARRAY_SIZE) &&
-                    (opt->value[i]))
-                        ret += snprintf (errstr + ret, len - ret, ", ");
-                else
-                        ret += snprintf (errstr + ret, len - ret, ".)");
-        }
-        return;
+    int i = 0;
+    int ret = 0;
+
+    ret = snprintf(errstr, len,
+                   "option %s %s: '%s' is not valid "
+                   "(possible options are ",
+                   key, value, value);
+
+    for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i];) {
+        ret += snprintf(errstr + ret, len - ret, "%s", opt->value[i]);
+        if (((++i) < ZR_OPTION_MAX_ARRAY_SIZE) && (opt->value[i]))
+            ret += snprintf(errstr + ret, len - ret, ", ");
+        else
+            ret += snprintf(errstr + ret, len - ret, ".)");
+    }
+    return;
 }
 
 int
-is_all_whitespaces (const char *value)
+is_all_whitespaces(const char *value)
 {
-        int i = 0;
-        size_t len = 0;
+    int i = 0;
+    size_t len = 0;
 
-        if (value == NULL)
-                return -1;
+    if (value == NULL)
+        return -1;
 
-        len = strlen (value);
+    len = strlen(value);
 
-        for (i = 0; i < len; i++) {
-                if (value[i] == ' ')
-                        continue;
-                else
-                        return 0;
-        }
+    for (i = 0; i < len; i++) {
+        if (value[i] == ' ')
+            continue;
+        else
+            return 0;
+    }
 
-        return 1;
+    return 1;
 }
 
 static int
-xlator_option_validate_str (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_str(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        int          i = 0;
-        char         errstr[4096] = {0,};
-
-        /* Check if the '*str' is valid */
-        if (GF_OPTION_LIST_EMPTY(opt)) {
-                ret = 0;
-                goto out;
-        }
-
-        if (is_all_whitespaces (value) == 1)
-                goto out;
-
-        for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i]; i++) {
- #ifdef  GF_DARWIN_HOST_OS
-                if (fnmatch (opt->value[i], value, 0) == 0) {
-                        ret = 0;
-                        break;
-                }
- #else
-                if (fnmatch (opt->value[i], value, FNM_EXTMATCH) == 0) {
-                        ret = 0;
-                        break;
-                }
- #endif
-        }
-
-        if ((i == ZR_OPTION_MAX_ARRAY_SIZE) || (!opt->value[i]))
-                goto out;
-                /* enter here only if
-                 * 1. reached end of opt->value array and haven't
-                 *    validated input
-                 *                      OR
-                 * 2. valid input list is less than
-                 *    ZR_OPTION_MAX_ARRAY_SIZE and input has not
-                 *    matched all possible input values.
-                 */
-
+    int ret = -1;
+    int i = 0;
+    char errstr[4096] = {
+        0,
+    };
+
+    /* Check if the '*str' is valid */
+    if (GF_OPTION_LIST_EMPTY(opt)) {
         ret = 0;
+        goto out;
+    }
 
-out:
-        if (ret) {
-                set_error_str (errstr, sizeof (errstr), opt, key, value);
+    if (is_all_whitespaces(value) == 1)
+        goto out;
 
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
+    for (i = 0; (i < ZR_OPTION_MAX_ARRAY_SIZE) && opt->value[i]; i++) {
+#ifdef GF_DARWIN_HOST_OS
+        if (fnmatch(opt->value[i], value, 0) == 0) {
+            ret = 0;
+            break;
         }
-        return ret;
-}
-
-
-static int
-xlator_option_validate_percent (xlator_t *xl, const char *key, const char *value,
-                                volume_option_t *opt, char **op_errstr)
-{
-        double    percent = 0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check if the value is valid percentage */
-        if (gf_string2percent (value, &percent) != 0) {
-                snprintf (errstr, 256,
-                          "invalid percent format \"%s\" in \"option %s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        if ((percent < 0.0) || (percent > 100.0)) {
-                snprintf (errstr, 256,
-                          "'%lf' in 'option %s %s' is out of range [0 - 100]",
-                          percent, key, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+#else
+        if (fnmatch(opt->value[i], value, FNM_EXTMATCH) == 0) {
+            ret = 0;
+            break;
         }
+#endif
+    }
+
+    if ((i == ZR_OPTION_MAX_ARRAY_SIZE) || (!opt->value[i]))
+        goto out;
+    /* enter here only if
+     * 1. reached end of opt->value array and haven't
+     *    validated input
+     *                      OR
+     * 2. valid input list is less than
+     *    ZR_OPTION_MAX_ARRAY_SIZE and input has not
+     *    matched all possible input values.
+     */
+
+    ret = 0;
 
-        ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret) {
+        set_error_str(errstr, sizeof(errstr), opt, key, value);
+
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    return ret;
 }
 
 static int
-xlator_option_validate_fractional_value (const char *value)
+xlator_option_validate_percent(xlator_t *xl, const char *key, const char *value,
+                               volume_option_t *opt, char **op_errstr)
 {
-        const char *s   = NULL;
-        int        ret  = 0;
-
-        s = strchr (value, '.');
-        if (s) {
-                for (s = s+1; *s != '\0'; s++) {
-                        if (*s != '0') {
-                                return -1;
-                        }
-                }
-        }
-
-        return ret;
+    double percent = 0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check if the value is valid percentage */
+    if (gf_string2percent(value, &percent) != 0) {
+        snprintf(errstr, 256, "invalid percent format \"%s\" in \"option %s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    if ((percent < 0.0) || (percent > 100.0)) {
+        snprintf(errstr, 256,
+                 "'%lf' in 'option %s %s' is out of range [0 - 100]", percent,
+                 key, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr);
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
 static int
-xlator_option_validate_percent_or_sizet (xlator_t *xl, const char *key,
-                                         const char *value,
-                                         volume_option_t *opt, char **op_errstr)
+xlator_option_validate_fractional_value(const char *value)
 {
-        int               ret = -1;
-        char              errstr[256];
-        double            size = 0;
-	gf_boolean_t is_percent = _gf_false;
-
-	if (gf_string2percent_or_bytesize (value, &size, &is_percent) == 0) {
-		if (is_percent) {
-                        if ((size < 0.0) || (size > 100.0)) {
-                                snprintf (errstr, sizeof (errstr),
-                                          "'%lf' in 'option %s %s' is out"
-                                          " of range [0 - 100]", size, key,
-                                          value);
-                                gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                        LG_MSG_OUT_OF_RANGE, "%s", errstr);
-                                goto out;
-                        }
-			ret = 0;
-			goto out;
-		}
-
-                /*Input value of size(in byte) should not be fractional*/
-                ret = xlator_option_validate_fractional_value (value);
-                if (ret) {
-                        snprintf (errstr, sizeof (errstr), "'%lf' in 'option %s"
-                                  " %s' should not be fractional value. Use "
-                                  "valid unsigned integer value.", size, key,
-                                  value);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-
-		/* Check the range */
-		if ((opt->min == 0) && (opt->max == 0)) {
-			gf_msg_trace (xl->name, 0, "no range check required "
-                                      "for 'option %s %s'", key, value);
-			ret = 0;
-			goto out;
-		}
-		if ((size < opt->min) || (size > opt->max)) {
-			snprintf (errstr, 256,
-				  "'%lf' in 'option %s %s'"
-				  " is out of range [%.0f - %.0f]",
-				  size, key, value, opt->min, opt->max);
-			gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE,
-                                "%s", errstr);
-			goto out;
-		}
-		ret = 0;
-		goto out;
-	}
-
-	/* If control reaches here, invalid argument */
-
-	snprintf (errstr, 256,
-		  "invalid number format \"%s\" in \"option %s\"",
-		  value, key);
-	gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+    const char *s = NULL;
+    int ret = 0;
 
+    s = strchr(value, '.');
+    if (s) {
+        for (s = s + 1; *s != '\0'; s++) {
+            if (*s != '0') {
+                return -1;
+            }
+        }
+    }
 
-out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    return ret;
 }
 
-
 static int
-xlator_option_validate_time (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_percent_or_sizet(xlator_t *xl, const char *key,
+                                        const char *value, volume_option_t *opt,
+                                        char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-        uint32_t     input_time = 0;
-
-	/* Check if the value is valid time */
-        if (gf_string2time (value, &input_time) != 0) {
-                snprintf (errstr, 256,
-                          "invalid time format \"%s\" in "
-                          "\"option %s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
+    int ret = -1;
+    char errstr[256];
+    double size = 0;
+    gf_boolean_t is_percent = _gf_false;
+
+    if (gf_string2percent_or_bytesize(value, &size, &is_percent) == 0) {
+        if (is_percent) {
+            if ((size < 0.0) || (size > 100.0)) {
+                snprintf(errstr, sizeof(errstr),
+                         "'%lf' in 'option %s %s' is out"
+                         " of range [0 - 100]",
+                         size, key, value);
+                gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
+                       errstr);
                 goto out;
+            }
+            ret = 0;
+            goto out;
         }
 
-        if ((opt->min == 0) && (opt->max == 0)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
+        /*Input value of size(in byte) should not be fractional*/
+        ret = xlator_option_validate_fractional_value(value);
+        if (ret) {
+            snprintf(errstr, sizeof(errstr),
+                     "'%lf' in 'option %s"
+                     " %s' should not be fractional value. Use "
+                     "valid unsigned integer value.",
+                     size, key, value);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
+                   errstr);
+            goto out;
         }
 
-        if ((input_time < opt->min) || (input_time > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%"PRIu32"' in 'option %s %s' is "
-                          "out of range [%.0f - %.0f]",
-                          input_time, key, value,
-                          opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
+        /* Check the range */
+        if ((opt->min == 0) && (opt->max == 0)) {
+            gf_msg_trace(xl->name, 0,
+                         "no range check required "
+                         "for 'option %s %s'",
+                         key, value);
+            ret = 0;
+            goto out;
+        }
+        if ((size < opt->min) || (size > opt->max)) {
+            snprintf(errstr, 256,
+                     "'%lf' in 'option %s %s'"
+                     " is out of range [%.0f - %.0f]",
+                     size, key, value, opt->min, opt->max);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
+                   errstr);
+            goto out;
         }
-
         ret = 0;
+        goto out;
+    }
+
+    /* If control reaches here, invalid argument */
+
+    snprintf(errstr, 256, "invalid number format \"%s\" in \"option %s\"",
+             value, key);
+    gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_double (xlator_t *xl, const char *key, const char *value,
-                               volume_option_t *opt, char **op_errstr)
+xlator_option_validate_time(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
 {
-        double    input = 0.0;
-        int       ret = -1;
-        char      errstr[256];
-
-        /* Check the range */
-        if (gf_string2double (value, &input) != 0) {
-                snprintf (errstr, 256,
-                          "invalid number format \"%s\" in option \"%s\"",
-                          value, key);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                goto out;
-        }
-
-        if ((opt->min == 0) && (opt->max == 0) &&
-            (opt->validate == GF_OPT_VALIDATE_BOTH)) {
-                gf_msg_trace (xl->name, 0, "no range check required for "
-                              "'option %s %s'", key, value);
-                ret = 0;
-                goto out;
-        }
-
-        if (opt->validate == GF_OPT_VALIDATE_MIN) {
-                if (input < opt->min) {
-                        snprintf (errstr, 256,
-                                  "'%f' in 'option %s %s' is smaller than "
-                                  "minimum value '%f'", input, key,
-                                  value, opt->min);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
-                if (input > opt->max) {
-                        snprintf (errstr, 256,
-                                  "'%f' in 'option %s %s' is greater than "
-                                  "maximum value '%f'", input, key,
-                                  value, opt->max);
-                        gf_msg (xl->name, GF_LOG_ERROR, 0,
-                                LG_MSG_INVALID_ENTRY, "%s", errstr);
-                        goto out;
-                }
-        } else if ((input < opt->min) || (input > opt->max)) {
-                snprintf (errstr, 256,
-                          "'%f' in 'option %s %s' is out of range "
-                          "[%f - %f]",
-                          input, key, value, opt->min, opt->max);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
-                        errstr);
-                goto out;
-        }
-
+    int ret = -1;
+    char errstr[256];
+    uint32_t input_time = 0;
+
+    /* Check if the value is valid time */
+    if (gf_string2time(value, &input_time) != 0) {
+        snprintf(errstr, 256,
+                 "invalid time format \"%s\" in "
+                 "\"option %s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
         ret = 0;
+        goto out;
+    }
+
+    if ((input_time < opt->min) || (input_time > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%" PRIu32
+                 "' in 'option %s %s' is "
+                 "out of range [%.0f - %.0f]",
+                 input_time, key, value, opt->min, opt->max);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret && op_errstr)
-                *op_errstr = gf_strdup (errstr);
-        return ret;
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
 }
 
-
 static int
-xlator_option_validate_addr (xlator_t *xl, const char *key, const char *value,
-                             volume_option_t *opt, char **op_errstr)
+xlator_option_validate_double(xlator_t *xl, const char *key, const char *value,
+                              volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         errstr[256];
-
-        if (!valid_internet_address ((char *)value, _gf_false)) {
-                snprintf (errstr, 256,
-                          "option %s %s: '%s'  is not a valid internet-address,"
-                          " it does not conform to standards.",
-                          key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-
+    double input = 0.0;
+    int ret = -1;
+    char errstr[256];
+
+    /* Check the range */
+    if (gf_string2double(value, &input) != 0) {
+        snprintf(errstr, 256, "invalid number format \"%s\" in option \"%s\"",
+                 value, key);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        goto out;
+    }
+
+    if ((opt->min == 0) && (opt->max == 0) &&
+        (opt->validate == GF_OPT_VALIDATE_BOTH)) {
+        gf_msg_trace(xl->name, 0,
+                     "no range check required for "
+                     "'option %s %s'",
+                     key, value);
         ret = 0;
+        goto out;
+    }
+
+    if (opt->validate == GF_OPT_VALIDATE_MIN) {
+        if (input < opt->min) {
+            snprintf(errstr, 256,
+                     "'%f' in 'option %s %s' is smaller than "
+                     "minimum value '%f'",
+                     input, key, value, opt->min);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
+                   errstr);
+            goto out;
+        }
+    } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
+        if (input > opt->max) {
+            snprintf(errstr, 256,
+                     "'%f' in 'option %s %s' is greater than "
+                     "maximum value '%f'",
+                     input, key, value, opt->max);
+            gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
+                   errstr);
+            goto out;
+        }
+    } else if ((input < opt->min) || (input > opt->max)) {
+        snprintf(errstr, 256,
+                 "'%f' in 'option %s %s' is out of range "
+                 "[%f - %f]",
+                 input, key, value, opt->min, opt->max);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr);
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (ret && op_errstr)
+        *op_errstr = gf_strdup(errstr);
+    return ret;
+}
 
-        return ret;
+static int
+xlator_option_validate_addr(xlator_t *xl, const char *key, const char *value,
+                            volume_option_t *opt, char **op_errstr)
+{
+    int ret = -1;
+    char errstr[256];
+
+    if (!valid_internet_address((char *)value, _gf_false)) {
+        snprintf(errstr, 256,
+                 "option %s %s: '%s'  is not a valid internet-address,"
+                 " it does not conform to standards.",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+
+    ret = 0;
+
+    return ret;
 }
 
 int
-xlator_option_validate_addr_list (xlator_t *xl, const char *key,
-                                  const char *value, volume_option_t *opt,
-                                  char **op_errstr)
+xlator_option_validate_addr_list(xlator_t *xl, const char *key,
+                                 const char *value, volume_option_t *opt,
+                                 char **op_errstr)
 {
-        int          ret = -1;
-        char         *dup_val = NULL;
-        char         *addr_tok = NULL;
-        char         *save_ptr = NULL;
-        char         *entry = NULL;
-        char         *entry_ptr = NULL;
-        char         *dir_and_addr = NULL;
-        char         *addr_ptr = NULL;
-        char         *addr_list = NULL;
-        char         *addr = NULL;
-        char         *dir = NULL;
-        char         errstr[4096] = {0,};
-
-        dup_val = gf_strdup (value);
-        if (!dup_val)
+    int ret = -1;
+    char *dup_val = NULL;
+    char *addr_tok = NULL;
+    char *save_ptr = NULL;
+    char *entry = NULL;
+    char *entry_ptr = NULL;
+    char *dir_and_addr = NULL;
+    char *addr_ptr = NULL;
+    char *addr_list = NULL;
+    char *addr = NULL;
+    char *dir = NULL;
+    char errstr[4096] = {
+        0,
+    };
+
+    dup_val = gf_strdup(value);
+    if (!dup_val)
+        goto out;
+
+    if (dup_val[0] != '/' && !strchr(dup_val, '(')) {
+        /* Possible old format, handle it for back-ward compatibility */
+        addr_tok = strtok_r(dup_val, ",", &save_ptr);
+        while (addr_tok) {
+            if (!valid_internet_address(addr_tok, _gf_true))
                 goto out;
 
-        if (dup_val[0] != '/' && !strchr (dup_val, '(')) {
-                /* Possible old format, handle it for back-ward compatibility */
-                addr_tok = strtok_r (dup_val, ",", &save_ptr);
-                while (addr_tok) {
-                        if (!valid_internet_address (addr_tok, _gf_true))
-                                goto out;
+            addr_tok = strtok_r(NULL, ",", &save_ptr);
+        }
+        ret = 0;
+        goto out;
+    }
+
+    /* Lets handle the value with new format */
+    entry = strtok_r(dup_val, ",", &entry_ptr);
+    while (entry) {
+        dir_and_addr = gf_strdup(entry);
+        if (!dir_and_addr)
+            goto out;
+
+        dir = strtok_r(dir_and_addr, "(", &addr_ptr);
+        if (dir[0] != '/') {
+            /* Valid format should be starting from '/' */
+            goto out;
+        }
+        /* dir = strtok_r (NULL, " =", &addr_tmp); */
+        addr = strtok_r(NULL, ")", &addr_ptr);
+        if (!addr)
+            goto out;
+
+        addr_list = gf_strdup(addr);
+        if (!addr_list)
+            goto out;
 
-                        addr_tok = strtok_r (NULL, ",", &save_ptr);
-                }
-                ret = 0;
+        /* This format be separated by '|' */
+        addr_tok = strtok_r(addr_list, "|", &save_ptr);
+        if (addr_tok == NULL)
+            goto out;
+        while (addr_tok) {
+            if (!valid_internet_address(addr_tok, _gf_true))
                 goto out;
-        }
 
-        /* Lets handle the value with new format */
-        entry = strtok_r (dup_val, ",", &entry_ptr);
-        while (entry) {
-                dir_and_addr = gf_strdup (entry);
-                if (!dir_and_addr)
-                        goto out;
-
-                dir = strtok_r (dir_and_addr, "(", &addr_ptr);
-                if (dir[0] != '/') {
-                        /* Valid format should be starting from '/' */
-                        goto out;
-                }
-                /* dir = strtok_r (NULL, " =", &addr_tmp); */
-                addr = strtok_r (NULL, ")", &addr_ptr);
-                if (!addr)
-                        goto out;
-
-                addr_list = gf_strdup (addr);
-                if (!addr_list)
-                        goto out;
-
-                /* This format be separated by '|' */
-                addr_tok = strtok_r (addr_list, "|", &save_ptr);
-                if (addr_tok == NULL)
-                        goto out;
-                while (addr_tok) {
-                        if (!valid_internet_address (addr_tok, _gf_true))
-                                goto out;
-
-                        addr_tok = strtok_r (NULL, "|", &save_ptr);
-                }
-                entry = strtok_r (NULL, ",", &entry_ptr);
-                GF_FREE (dir_and_addr);
-                GF_FREE (addr_list);
-                addr_list = NULL;
-                dir_and_addr = NULL;
+            addr_tok = strtok_r(NULL, "|", &save_ptr);
         }
+        entry = strtok_r(NULL, ",", &entry_ptr);
+        GF_FREE(dir_and_addr);
+        GF_FREE(addr_list);
+        addr_list = NULL;
+        dir_and_addr = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret) {
-                snprintf (errstr, sizeof (errstr), "option %s %s: '%s' is not "
-                          "a valid internet-address-list", key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-        GF_FREE (dup_val);
-        GF_FREE (dir_and_addr);
-        GF_FREE (addr_list);
-        return ret;
+    if (ret) {
+        snprintf(errstr, sizeof(errstr),
+                 "option %s %s: '%s' is not "
+                 "a valid internet-address-list",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    GF_FREE(dup_val);
+    GF_FREE(dir_and_addr);
+    GF_FREE(addr_list);
+    return ret;
 }
 
 static int
-xlator_option_validate_mntauth (xlator_t *xl, const char *key,
-                                const char *value, volume_option_t *opt,
-                                char **op_errstr)
+xlator_option_validate_mntauth(xlator_t *xl, const char *key, const char *value,
+                               volume_option_t *opt, char **op_errstr)
 {
-        int          ret = -1;
-        char         *dup_val = NULL;
-        char         *addr_tok = NULL;
-        char         *save_ptr = NULL;
-        char         errstr[4096] = {0,};
-
-        dup_val = gf_strdup (value);
-        if (!dup_val)
-                goto out;
-
-        addr_tok = strtok_r (dup_val, ",", &save_ptr);
-        if (addr_tok == NULL)
-                goto out;
-        while (addr_tok) {
-                if (!valid_mount_auth_address (addr_tok))
-                        goto out;
-
-                addr_tok = strtok_r (NULL, ",", &save_ptr);
-        }
-        ret = 0;
+    int ret = -1;
+    char *dup_val = NULL;
+    char *addr_tok = NULL;
+    char *save_ptr = NULL;
+    char errstr[4096] = {
+        0,
+    };
+
+    dup_val = gf_strdup(value);
+    if (!dup_val)
+        goto out;
+
+    addr_tok = strtok_r(dup_val, ",", &save_ptr);
+    if (addr_tok == NULL)
+        goto out;
+    while (addr_tok) {
+        if (!valid_mount_auth_address(addr_tok))
+            goto out;
+
+        addr_tok = strtok_r(NULL, ",", &save_ptr);
+    }
+    ret = 0;
 
 out:
-        if (ret) {
-                snprintf (errstr, sizeof (errstr), "option %s %s: '%s' is not "
-                "a valid mount-auth-address", key, value, value);
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
-                        errstr);
-                if (op_errstr)
-                        *op_errstr = gf_strdup (errstr);
-        }
-        GF_FREE (dup_val);
-
-        return ret;
+    if (ret) {
+        snprintf(errstr, sizeof(errstr),
+                 "option %s %s: '%s' is not "
+                 "a valid mount-auth-address",
+                 key, value, value);
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr);
+        if (op_errstr)
+            *op_errstr = gf_strdup(errstr);
+    }
+    GF_FREE(dup_val);
+
+    return ret;
 }
 
 /*XXX: the rules to validate are as per block-size required for stripe xlator */
 static int
-gf_validate_size (const char *sizestr, volume_option_t *opt)
+gf_validate_size(const char *sizestr, volume_option_t *opt)
 {
-        size_t                value = 0;
-        int                     ret = 0;
+    size_t value = 0;
+    int ret = 0;
 
-        GF_ASSERT (opt);
+    GF_ASSERT(opt);
 
-        if (gf_string2bytesize_size (sizestr, &value) != 0 ||
-            value < opt->min ||
-            value % 512) {
-                ret = -1;
-                goto out;
-        }
+    if (gf_string2bytesize_size(sizestr, &value) != 0 || value < opt->min ||
+        value % 512) {
+        ret = -1;
+        goto out;
+    }
 
- out:
-        gf_msg_debug (THIS->name, 0, "Returning %d", ret);
-        return ret;
+out:
+    gf_msg_debug(THIS->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 static int
-gf_validate_number (const char *numstr, volume_option_t *opt)
+gf_validate_number(const char *numstr, volume_option_t *opt)
 {
-        int32_t value;
-        return gf_string2int32 (numstr, &value);
+    int32_t value;
+    return gf_string2int32(numstr, &value);
 }
 
 /*  Parses the string to be of the form <key1>:<value1>,<key2>:<value2>...  *
  *  takes two optional validaters key_validator and value_validator         */
 static int
-validate_list_elements (const char *string, volume_option_t *opt,
-                        int (key_validator)( const char *),
-                        int (value_validator)( const char *, volume_option_t *))
+validate_list_elements(const char *string, volume_option_t *opt,
+                       int(key_validator)(const char *),
+                       int(value_validator)(const char *, volume_option_t *))
 {
-
-        char                    *dup_string = NULL;
-        char                    *str_sav = NULL;
-        char                    *substr_sav = NULL;
-        char                    *str_ptr = NULL;
-        char                    *key = NULL;
-        char                    *value = NULL;
-        int                     ret = 0;
-
-        GF_ASSERT (string);
-
-        dup_string = gf_strdup (string);
-        if (NULL == dup_string)
-                goto out;
-
-        str_ptr = strtok_r (dup_string, ",", &str_sav);
-        if (str_ptr == NULL) {
-                ret = -1;
-                goto out;
+    char *dup_string = NULL;
+    char *str_sav = NULL;
+    char *substr_sav = NULL;
+    char *str_ptr = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    int ret = 0;
+
+    GF_ASSERT(string);
+
+    dup_string = gf_strdup(string);
+    if (NULL == dup_string)
+        goto out;
+
+    str_ptr = strtok_r(dup_string, ",", &str_sav);
+    if (str_ptr == NULL) {
+        ret = -1;
+        goto out;
+    }
+    while (str_ptr) {
+        key = strtok_r(str_ptr, ":", &substr_sav);
+        if (!key || (key_validator && key_validator(key))) {
+            ret = -1;
+            gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+                   "invalid list '%s', key "
+                   "'%s' not valid.",
+                   string, key);
+            goto out;
         }
-        while (str_ptr) {
-
-                key = strtok_r (str_ptr, ":", &substr_sav);
-                if (!key ||
-                    (key_validator && key_validator(key))) {
-                        ret = -1;
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "invalid list '%s', key "
-                                "'%s' not valid.", string, key);
-                        goto out;
-                }
-
-                value = strtok_r (NULL, ":", &substr_sav);
-                if (!value ||
-                    (value_validator && value_validator(value, opt))) {
-                        ret = -1;
-                        gf_msg (THIS->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "invalid list '%s', "
-                                "value '%s' not valid.", string, key);
-                        goto out;
-                }
-
-                str_ptr = strtok_r (NULL, ",", &str_sav);
-                substr_sav = NULL;
+
+        value = strtok_r(NULL, ":", &substr_sav);
+        if (!value || (value_validator && value_validator(value, opt))) {
+            ret = -1;
+            gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+                   "invalid list '%s', "
+                   "value '%s' not valid.",
+                   string, key);
+            goto out;
         }
 
- out:
-        GF_FREE (dup_string);
-        gf_msg_debug (THIS->name, 0, "Returning %d", ret);
-        return ret;
+        str_ptr = strtok_r(NULL, ",", &str_sav);
+        substr_sav = NULL;
+    }
+
+out:
+    GF_FREE(dup_string);
+    gf_msg_debug(THIS->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 static int
-xlator_option_validate_priority_list (xlator_t *xl, const char *key,
-                                      const char *value, volume_option_t *opt,
-                                      char **op_errstr)
+xlator_option_validate_priority_list(xlator_t *xl, const char *key,
+                                     const char *value, volume_option_t *opt,
+                                     char **op_errstr)
 {
-        int                     ret =0;
-        char                    errstr[1024] = {0, };
-
-        GF_ASSERT (value);
-
-        ret = validate_list_elements (value, opt, NULL, &gf_validate_number);
-        if (ret) {
-                snprintf (errstr, 1024,
-                          "option %s %s: '%s' is not a valid "
-                          "priority-list", key, value, value);
-                *op_errstr = gf_strdup (errstr);
-        }
-
-        return ret;
+    int ret = 0;
+    char errstr[1024] = {
+        0,
+    };
+
+    GF_ASSERT(value);
+
+    ret = validate_list_elements(value, opt, NULL, &gf_validate_number);
+    if (ret) {
+        snprintf(errstr, 1024,
+                 "option %s %s: '%s' is not a valid "
+                 "priority-list",
+                 key, value, value);
+        *op_errstr = gf_strdup(errstr);
+    }
+
+    return ret;
 }
 
 static int
-xlator_option_validate_size_list (xlator_t *xl, const char *key,
-                                  const char *value, volume_option_t *opt,
-                                  char **op_errstr)
+xlator_option_validate_size_list(xlator_t *xl, const char *key,
+                                 const char *value, volume_option_t *opt,
+                                 char **op_errstr)
 {
-
-        int                    ret = 0;
-        char                   errstr[1024] = {0, };
-
-        GF_ASSERT (value);
-
-        ret = gf_validate_size (value, opt);
-        if (ret)
-                ret = validate_list_elements (value, opt, NULL, &gf_validate_size);
-
-        if (ret) {
-                snprintf (errstr, 1024,
-                          "option %s %s: '%s' is not a valid "
-                          "size-list", key, value, value);
-                *op_errstr = gf_strdup (errstr);
-        }
-
-        return ret;
-
+    int ret = 0;
+    char errstr[1024] = {
+        0,
+    };
+
+    GF_ASSERT(value);
+
+    ret = gf_validate_size(value, opt);
+    if (ret)
+        ret = validate_list_elements(value, opt, NULL, &gf_validate_size);
+
+    if (ret) {
+        snprintf(errstr, 1024,
+                 "option %s %s: '%s' is not a valid "
+                 "size-list",
+                 key, value, value);
+        *op_errstr = gf_strdup(errstr);
+    }
+
+    return ret;
 }
 
 static int
-xlator_option_validate_any (xlator_t *xl, const char *key, const char *value,
-                            volume_option_t *opt, char **op_errstr)
+xlator_option_validate_any(xlator_t *xl, const char *key, const char *value,
+                           volume_option_t *opt, char **op_errstr)
 {
-        return 0;
+    return 0;
 }
 
-typedef int (xlator_option_validator_t) (xlator_t *xl, const char *key,
-                                         const char *value,
-                                         volume_option_t *opt, char **operrstr);
+typedef int(xlator_option_validator_t)(xlator_t *xl, const char *key,
+                                       const char *value, volume_option_t *opt,
+                                       char **operrstr);
 
 int
-xlator_option_validate (xlator_t *xl, char *key, char *value,
-                        volume_option_t *opt, char **op_errstr)
+xlator_option_validate(xlator_t *xl, char *key, char *value,
+                       volume_option_t *opt, char **op_errstr)
 {
-        int       ret = -1;
-        xlator_option_validator_t *validate;
-        xlator_option_validator_t *validators[] = {
-                [GF_OPTION_TYPE_PATH]        = xlator_option_validate_path,
-                [GF_OPTION_TYPE_INT]         = xlator_option_validate_int,
-                [GF_OPTION_TYPE_SIZET]       = xlator_option_validate_sizet,
-                [GF_OPTION_TYPE_BOOL]        = xlator_option_validate_bool,
-                [GF_OPTION_TYPE_XLATOR]      = xlator_option_validate_xlator,
-                [GF_OPTION_TYPE_STR]         = xlator_option_validate_str,
-                [GF_OPTION_TYPE_PERCENT]     = xlator_option_validate_percent,
-                [GF_OPTION_TYPE_PERCENT_OR_SIZET] =
-                xlator_option_validate_percent_or_sizet,
-                [GF_OPTION_TYPE_TIME]        = xlator_option_validate_time,
-                [GF_OPTION_TYPE_DOUBLE]      = xlator_option_validate_double,
-                [GF_OPTION_TYPE_INTERNET_ADDRESS] = xlator_option_validate_addr,
-                [GF_OPTION_TYPE_INTERNET_ADDRESS_LIST] =
-                xlator_option_validate_addr_list,
-                [GF_OPTION_TYPE_PRIORITY_LIST] =
-                xlator_option_validate_priority_list,
-                [GF_OPTION_TYPE_SIZE_LIST]   = xlator_option_validate_size_list,
-                [GF_OPTION_TYPE_ANY]         = xlator_option_validate_any,
-                [GF_OPTION_TYPE_CLIENT_AUTH_ADDR] = xlator_option_validate_mntauth,
-                [GF_OPTION_TYPE_MAX]         = NULL,
-        };
-
-        if (opt->type > GF_OPTION_TYPE_MAX) {
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "unknown option type '%d'", opt->type);
-                goto out;
-        }
-
-        validate = validators[opt->type];
-
-        ret = validate (xl, key, value, opt, op_errstr);
+    int ret = -1;
+    xlator_option_validator_t *validate;
+    xlator_option_validator_t *validators[] = {
+        [GF_OPTION_TYPE_PATH] = xlator_option_validate_path,
+        [GF_OPTION_TYPE_INT] = xlator_option_validate_int,
+        [GF_OPTION_TYPE_SIZET] = xlator_option_validate_sizet,
+        [GF_OPTION_TYPE_BOOL] = xlator_option_validate_bool,
+        [GF_OPTION_TYPE_XLATOR] = xlator_option_validate_xlator,
+        [GF_OPTION_TYPE_STR] = xlator_option_validate_str,
+        [GF_OPTION_TYPE_PERCENT] = xlator_option_validate_percent,
+        [GF_OPTION_TYPE_PERCENT_OR_SIZET] =
+            xlator_option_validate_percent_or_sizet,
+        [GF_OPTION_TYPE_TIME] = xlator_option_validate_time,
+        [GF_OPTION_TYPE_DOUBLE] = xlator_option_validate_double,
+        [GF_OPTION_TYPE_INTERNET_ADDRESS] = xlator_option_validate_addr,
+        [GF_OPTION_TYPE_INTERNET_ADDRESS_LIST] =
+            xlator_option_validate_addr_list,
+        [GF_OPTION_TYPE_PRIORITY_LIST] = xlator_option_validate_priority_list,
+        [GF_OPTION_TYPE_SIZE_LIST] = xlator_option_validate_size_list,
+        [GF_OPTION_TYPE_ANY] = xlator_option_validate_any,
+        [GF_OPTION_TYPE_CLIENT_AUTH_ADDR] = xlator_option_validate_mntauth,
+        [GF_OPTION_TYPE_MAX] = NULL,
+    };
+
+    if (opt->type > GF_OPTION_TYPE_MAX) {
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "unknown option type '%d'", opt->type);
+        goto out;
+    }
+
+    validate = validators[opt->type];
+
+    ret = validate(xl, key, value, opt, op_errstr);
 out:
-        return ret;
+    return ret;
 }
 
-
 volume_option_t *
-xlator_volume_option_get_list (volume_opt_list_t *vol_list, const char *key)
+xlator_volume_option_get_list(volume_opt_list_t *vol_list, const char *key)
 {
-        volume_option_t         *opt = NULL;
-        volume_opt_list_t       *opt_list = NULL;
-        volume_option_t         *found = NULL;
-        int                      index = 0;
-        int                      i = 0;
-        char                    *cmp_key = NULL;
-
-        if (!vol_list->given_opt) {
-                opt_list = list_entry (vol_list->list.next, volume_opt_list_t,
-                                       list);
-                opt = opt_list->given_opt;
-        } else
-                opt = vol_list->given_opt;
-
-        for (index = 0; opt[index].key[0]; index++) {
-                for (i = 0; i < ZR_VOLUME_MAX_NUM_KEY; i++) {
-                        cmp_key = opt[index].key[i];
-                        if (!cmp_key)
-                                break;
-                        if (fnmatch (cmp_key, key, FNM_NOESCAPE) == 0) {
-                                found = &opt[index];
-                                goto out;
-                        }
-                }
+    volume_option_t *opt = NULL;
+    volume_opt_list_t *opt_list = NULL;
+    volume_option_t *found = NULL;
+    int index = 0;
+    int i = 0;
+    char *cmp_key = NULL;
+
+    if (!vol_list->given_opt) {
+        opt_list = list_entry(vol_list->list.next, volume_opt_list_t, list);
+        opt = opt_list->given_opt;
+    } else
+        opt = vol_list->given_opt;
+
+    for (index = 0; opt[index].key[0]; index++) {
+        for (i = 0; i < ZR_VOLUME_MAX_NUM_KEY; i++) {
+            cmp_key = opt[index].key[i];
+            if (!cmp_key)
+                break;
+            if (fnmatch(cmp_key, key, FNM_NOESCAPE) == 0) {
+                found = &opt[index];
+                goto out;
+            }
         }
+    }
 out:
-        return found;
+    return found;
 }
 
-
 volume_option_t *
-xlator_volume_option_get (xlator_t *xl, const char *key)
+xlator_volume_option_get(xlator_t *xl, const char *key)
 {
-        volume_opt_list_t       *vol_list = NULL;
-        volume_option_t         *found = NULL;
+    volume_opt_list_t *vol_list = NULL;
+    volume_option_t *found = NULL;
 
-        list_for_each_entry (vol_list, &xl->volume_options, list) {
-                found = xlator_volume_option_get_list (vol_list, key);
-                if (found)
-                        break;
-        }
+    list_for_each_entry(vol_list, &xl->volume_options, list)
+    {
+        found = xlator_volume_option_get_list(vol_list, key);
+        if (found)
+            break;
+    }
 
-        return found;
+    return found;
 }
 
-
 static int
-xl_opt_validate (dict_t *dict, char *key, data_t *value, void *data)
+xl_opt_validate(dict_t *dict, char *key, data_t *value, void *data)
 {
-        xlator_t          *xl = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        volume_option_t   *opt = NULL;
-        int                ret = 0;
-        char              *errstr = NULL;
-
-        struct {
-                xlator_t           *this;
-                volume_opt_list_t  *vol_opt;
-                char               *errstr;
-        } *stub;
-
-        stub = data;
-        xl = stub->this;
-        vol_opt = stub->vol_opt;
-
-        opt = xlator_volume_option_get_list (vol_opt, key);
-        if (!opt)
-                return 0;
-
-        ret = xlator_option_validate (xl, key, value->data, opt, &errstr);
-        if (ret)
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_VALIDATE_RETURNS,
-                        "validate of %s returned %d", key, ret);
-
-        if (errstr)
-                /* possible small leak of previously set stub->errstr */
-                stub->errstr = errstr;
-
-        if (fnmatch (opt->key[0], key, FNM_NOESCAPE) != 0) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
-                        "option '%s' is deprecated, preferred is '%s', "
-                        "continuing with correction", key, opt->key[0]);
-                dict_set (dict, opt->key[0], value);
-                dict_del (dict, key);
-        }
+    xlator_t *xl = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    volume_option_t *opt = NULL;
+    int ret = 0;
+    char *errstr = NULL;
+
+    struct {
+        xlator_t *this;
+        volume_opt_list_t *vol_opt;
+        char *errstr;
+    } * stub;
+
+    stub = data;
+    xl = stub->this;
+    vol_opt = stub->vol_opt;
+
+    opt = xlator_volume_option_get_list(vol_opt, key);
+    if (!opt)
         return 0;
-}
 
+    ret = xlator_option_validate(xl, key, value->data, opt, &errstr);
+    if (ret)
+        gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_VALIDATE_RETURNS,
+               "validate of %s returned %d", key, ret);
+
+    if (errstr)
+        /* possible small leak of previously set stub->errstr */
+        stub->errstr = errstr;
+
+    if (fnmatch(opt->key[0], key, FNM_NOESCAPE) != 0) {
+        gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+               "option '%s' is deprecated, preferred is '%s', "
+               "continuing with correction",
+               key, opt->key[0]);
+        dict_set(dict, opt->key[0], value);
+        dict_del(dict, key);
+    }
+    return 0;
+}
 
 int
-xlator_options_validate_list (xlator_t *xl, dict_t *options,
-                              volume_opt_list_t *vol_opt, char **op_errstr)
+xlator_options_validate_list(xlator_t *xl, dict_t *options,
+                             volume_opt_list_t *vol_opt, char **op_errstr)
 {
-        int ret = 0;
-        struct {
-                xlator_t           *this;
-                volume_opt_list_t  *vol_opt;
-                char               *errstr;
-        } stub;
-
-        stub.this = xl;
-        stub.vol_opt = vol_opt;
-        stub.errstr = NULL;
-
-        dict_foreach (options, xl_opt_validate, &stub);
-        if (stub.errstr) {
-                ret = -1;
-                if (op_errstr)
-                        *op_errstr = stub.errstr;
-        }
-
-        return ret;
+    int ret = 0;
+    struct {
+        xlator_t *this;
+        volume_opt_list_t *vol_opt;
+        char *errstr;
+    } stub;
+
+    stub.this = xl;
+    stub.vol_opt = vol_opt;
+    stub.errstr = NULL;
+
+    dict_foreach(options, xl_opt_validate, &stub);
+    if (stub.errstr) {
+        ret = -1;
+        if (op_errstr)
+            *op_errstr = stub.errstr;
+    }
+
+    return ret;
 }
 
-
 int
-xlator_options_validate (xlator_t *xl, dict_t *options, char **op_errstr)
+xlator_options_validate(xlator_t *xl, dict_t *options, char **op_errstr)
 {
-        int                ret     = 0;
-        volume_opt_list_t *vol_opt = NULL;
-
-
-        if (!xl) {
-                gf_msg_debug (THIS->name, 0, "'this' not a valid ptr");
-                ret = -1;
-                goto out;
-        }
-
-        if (list_empty (&xl->volume_options))
-                goto out;
-
-        list_for_each_entry (vol_opt, &xl->volume_options, list) {
-                ret = xlator_options_validate_list (xl, options, vol_opt,
-                                                    op_errstr);
-        }
+    int ret = 0;
+    volume_opt_list_t *vol_opt = NULL;
+
+    if (!xl) {
+        gf_msg_debug(THIS->name, 0, "'this' not a valid ptr");
+        ret = -1;
+        goto out;
+    }
+
+    if (list_empty(&xl->volume_options))
+        goto out;
+
+    list_for_each_entry(vol_opt, &xl->volume_options, list)
+    {
+        ret = xlator_options_validate_list(xl, options, vol_opt, op_errstr);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_validate_rec (xlator_t *xlator, char **op_errstr)
+xlator_validate_rec(xlator_t *xlator, char **op_errstr)
 {
-        int            ret  = -1;
-        xlator_list_t *trav = NULL;
-        xlator_t      *old_THIS = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xlator, out);
+    int ret = -1;
+    xlator_list_t *trav = NULL;
+    xlator_t *old_THIS = NULL;
 
-        trav = xlator->children;
+    GF_VALIDATE_OR_GOTO("xlator", xlator, out);
 
-        while (trav) {
-                if (xlator_validate_rec (trav->xlator, op_errstr)) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_VALIDATE_REC_FAILED, "validate_rec "
-                                "failed");
-                        goto out;
-                }
+    trav = xlator->children;
 
-                trav = trav->next;
+    while (trav) {
+        if (xlator_validate_rec(trav->xlator, op_errstr)) {
+            gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_VALIDATE_REC_FAILED,
+                   "validate_rec "
+                   "failed");
+            goto out;
         }
 
-        if (xlator_dynload (xlator))
-                gf_msg_debug (xlator->name, 0, "Did not load the symbols");
+        trav = trav->next;
+    }
 
-        old_THIS = THIS;
-        THIS = xlator;
+    if (xlator_dynload(xlator))
+        gf_msg_debug(xlator->name, 0, "Did not load the symbols");
 
-        /* Need this here, as this graph has not yet called init() */
-        if (!xlator->mem_acct) {
-                if (!xlator->mem_acct_init)
-                        xlator->mem_acct_init = default_mem_acct_init;
-                xlator->mem_acct_init (xlator);
-        }
+    old_THIS = THIS;
+    THIS = xlator;
 
-        ret = xlator_options_validate (xlator, xlator->options, op_errstr);
-        THIS = old_THIS;
+    /* Need this here, as this graph has not yet called init() */
+    if (!xlator->mem_acct) {
+        if (!xlator->mem_acct_init)
+            xlator->mem_acct_init = default_mem_acct_init;
+        xlator->mem_acct_init(xlator);
+    }
 
-        if (ret) {
-                gf_msg (xlator->name, GF_LOG_INFO, 0, LG_MSG_INVALID_ENTRY,
-                        "%s", *op_errstr);
-                goto out;
-        }
+    ret = xlator_options_validate(xlator, xlator->options, op_errstr);
+    THIS = old_THIS;
 
-        gf_msg_debug (xlator->name, 0, "Validated options");
+    if (ret) {
+        gf_msg(xlator->name, GF_LOG_INFO, 0, LG_MSG_INVALID_ENTRY, "%s",
+               *op_errstr);
+        goto out;
+    }
 
-        ret = 0;
+    gf_msg_debug(xlator->name, 0, "Validated options");
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-graph_reconf_validateopt (glusterfs_graph_t *graph, char **op_errstr)
+graph_reconf_validateopt(glusterfs_graph_t *graph, char **op_errstr)
 {
-        xlator_t *xlator = NULL;
-        int       ret = -1;
+    xlator_t *xlator = NULL;
+    int ret = -1;
 
-        GF_ASSERT (graph);
+    GF_ASSERT(graph);
 
-        xlator = graph->first;
+    xlator = graph->first;
 
-        ret = xlator_validate_rec (xlator, op_errstr);
+    ret = xlator_validate_rec(xlator, op_errstr);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-xlator_reconfigure_rec (xlator_t *old_xl, xlator_t *new_xl)
+xlator_reconfigure_rec(xlator_t *old_xl, xlator_t *new_xl)
 {
-        xlator_list_t *trav1    = NULL;
-        xlator_list_t *trav2    = NULL;
-        int32_t        ret      = -1;
-        xlator_t      *old_THIS = NULL;
+    xlator_list_t *trav1 = NULL;
+    xlator_list_t *trav2 = NULL;
+    int32_t ret = -1;
+    xlator_t *old_THIS = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", old_xl, out);
-        GF_VALIDATE_OR_GOTO ("xlator", new_xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", old_xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", new_xl, out);
 
-        trav1 = old_xl->children;
-        trav2 = new_xl->children;
+    trav1 = old_xl->children;
+    trav2 = new_xl->children;
 
-        while (trav1 && trav2) {
-                ret = xlator_reconfigure_rec (trav1->xlator, trav2->xlator);
-                if (ret)
-                        goto out;
+    while (trav1 && trav2) {
+        ret = xlator_reconfigure_rec(trav1->xlator, trav2->xlator);
+        if (ret)
+            goto out;
 
-                gf_msg_debug (trav1->xlator->name, 0, "reconfigured");
+        gf_msg_debug(trav1->xlator->name, 0, "reconfigured");
 
-                trav1 = trav1->next;
-                trav2 = trav2->next;
-        }
+        trav1 = trav1->next;
+        trav2 = trav2->next;
+    }
 
-        if (old_xl->reconfigure) {
-                old_THIS = THIS;
-                THIS = old_xl;
+    if (old_xl->reconfigure) {
+        old_THIS = THIS;
+        THIS = old_xl;
 
-                xlator_init_lock ();
-                ret = old_xl->reconfigure (old_xl, new_xl->options);
-                xlator_init_unlock ();
+        xlator_init_lock();
+        ret = old_xl->reconfigure(old_xl, new_xl->options);
+        xlator_init_unlock();
 
-                THIS = old_THIS;
+        THIS = old_THIS;
 
-                if (ret)
-                        goto out;
-        } else {
-                gf_msg_debug (old_xl->name, 0, "No reconfigure() found");
-        }
+        if (ret)
+            goto out;
+    } else {
+        gf_msg_debug(old_xl->name, 0, "No reconfigure() found");
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_tree_reconfigure (xlator_t *old_xl, xlator_t *new_xl)
+xlator_tree_reconfigure(xlator_t *old_xl, xlator_t *new_xl)
 {
-        xlator_t *new_top = NULL;
-        xlator_t *old_top = NULL;
+    xlator_t *new_top = NULL;
+    xlator_t *old_top = NULL;
 
-        GF_ASSERT (old_xl);
-        GF_ASSERT (new_xl);
+    GF_ASSERT(old_xl);
+    GF_ASSERT(new_xl);
 
-        old_top = old_xl;
-        new_top = new_xl;
+    old_top = old_xl;
+    new_top = new_xl;
 
-        return xlator_reconfigure_rec (old_top, new_top);
+    return xlator_reconfigure_rec(old_top, new_top);
 }
 
-
 int
-xlator_option_info_list (volume_opt_list_t *list, char *key,
-                         char **def_val, char **descr)
+xlator_option_info_list(volume_opt_list_t *list, char *key, char **def_val,
+                        char **descr)
 {
-        int                     ret = -1;
-        volume_option_t         *opt = NULL;
+    int ret = -1;
+    volume_option_t *opt = NULL;
 
+    opt = xlator_volume_option_get_list(list, key);
+    if (!opt)
+        goto out;
 
-        opt = xlator_volume_option_get_list (list, key);
-        if (!opt)
-                goto out;
-
-        if (def_val)
-                *def_val = opt->default_value;
-        if (descr)
-                *descr = opt->description;
+    if (def_val)
+        *def_val = opt->default_value;
+    if (descr)
+        *descr = opt->description;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-pass (char *in, char **out)
+pass(char *in, char **out)
 {
-        *out = in;
-        return 0;
+    *out = in;
+    return 0;
 }
 
-
 static int
-xl_by_name (char *in, xlator_t **out)
+xl_by_name(char *in, xlator_t **out)
 {
-        xlator_t  *xl = NULL;
+    xlator_t *xl = NULL;
 
-        xl = xlator_search_by_name (THIS, in);
+    xl = xlator_search_by_name(THIS, in);
 
-        if (!xl)
-                return -1;
-        *out = xl;
-        return 0;
+    if (!xl)
+        return -1;
+    *out = xl;
+    return 0;
 }
 
-
 static int
-pc_or_size (char *in, double *out)
+pc_or_size(char *in, double *out)
 {
-        double  pc = 0;
-        int       ret = 0;
-        size_t  size = 0;
-
-        if (gf_string2percent (in, &pc) == 0) {
-                if (pc > 100.0) {
-                        ret = gf_string2bytesize_size (in, &size);
-                        if (!ret)
-                                *out = size;
-                } else {
-                        *out = pc;
-                }
+    double pc = 0;
+    int ret = 0;
+    size_t size = 0;
+
+    if (gf_string2percent(in, &pc) == 0) {
+        if (pc > 100.0) {
+            ret = gf_string2bytesize_size(in, &size);
+            if (!ret)
+                *out = size;
         } else {
-                ret = gf_string2bytesize_size (in, &size);
-                if (!ret)
-                        *out = size;
+            *out = pc;
         }
-        return ret;
+    } else {
+        ret = gf_string2bytesize_size(in, &size);
+        if (!ret)
+            *out = size;
+    }
+    return ret;
 }
 
 DEFINE_INIT_OPT(char *, str, pass);
@@ -1265,7 +1233,6 @@ DEFINE_INIT_OPT(char *, path, pass);
 DEFINE_INIT_OPT(double, double, gf_string2double);
 DEFINE_INIT_OPT(uint32_t, time, gf_string2time);
 
-
 DEFINE_RECONF_OPT(char *, str, pass);
 DEFINE_RECONF_OPT(uint64_t, uint64, gf_string2uint64);
 DEFINE_RECONF_OPT(int64_t, int64, gf_string2int64);
diff --git a/libglusterfs/src/options.h b/libglusterfs/src/options.h
index e47d7496a39..b0f76d5639c 100644
--- a/libglusterfs/src/options.h
+++ b/libglusterfs/src/options.h
@@ -76,8 +76,8 @@ typedef enum {
  * try a solution in GD2 for this.
  */
 /* typedef int (*option_validation_fn) (glusterd_volinfo_t *volinfo, dict_t
-   *dict, char *key, char *value, char **op_errstr);
-*/
+ *dict, char *key, char *value, char **op_errstr);
+ */
 
 /* Each translator should define this structure */
 /* XXX: This structure is in use by GD2, and SHOULD NOT be modified.
diff --git a/libglusterfs/src/parse-utils.c b/libglusterfs/src/parse-utils.c
index 304232f6b56..d3fd0963507 100644
--- a/libglusterfs/src/parse-utils.c
+++ b/libglusterfs/src/parse-utils.c
@@ -36,33 +36,33 @@
  *              : failure: NULL (on failure to compile regex or allocate memory)
  */
 struct parser *
-parser_init (const char *regex)
+parser_init(const char *regex)
 {
-        int           rc      = 0;
-        struct parser *parser = NULL;
-
-        parser = GF_MALLOC (sizeof(*parser), gf_common_mt_parser_t);
-        if (!parser)
-                goto out;
-
-        parser->regex = gf_strdup (regex);
-        if (!parser->regex) {
-                GF_FREE (parser);
-                parser = NULL;
-                goto out;
-        }
-
-        rc = regcomp (&parser->preg, parser->regex, REG_EXTENDED);
-        if (rc != 0) {
-                gf_msg (GF_PARSE, GF_LOG_INFO, 0, LG_MSG_REGEX_OP_FAILED,
-                        "Failed to compile regex pattern.");
-                parser_deinit (parser);
-                parser = NULL;
-                goto out;
-        }
-        parser->complete_str = NULL;
+    int rc = 0;
+    struct parser *parser = NULL;
+
+    parser = GF_MALLOC(sizeof(*parser), gf_common_mt_parser_t);
+    if (!parser)
+        goto out;
+
+    parser->regex = gf_strdup(regex);
+    if (!parser->regex) {
+        GF_FREE(parser);
+        parser = NULL;
+        goto out;
+    }
+
+    rc = regcomp(&parser->preg, parser->regex, REG_EXTENDED);
+    if (rc != 0) {
+        gf_msg(GF_PARSE, GF_LOG_INFO, 0, LG_MSG_REGEX_OP_FAILED,
+               "Failed to compile regex pattern.");
+        parser_deinit(parser);
+        parser = NULL;
+        goto out;
+    }
+    parser->complete_str = NULL;
 out:
-        return parser;
+    return parser;
 }
 
 /**
@@ -78,22 +78,22 @@ out:
  *          failure: -EINVAL for NULL args, -ENOMEM for allocation errors
  */
 int
-parser_set_string (struct parser *parser, const char *complete_str)
+parser_set_string(struct parser *parser, const char *complete_str)
 {
-        int ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
-        GF_VALIDATE_OR_GOTO (GF_PARSE, complete_str, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, complete_str, out);
 
-        parser->complete_str = gf_strdup (complete_str);
-        GF_CHECK_ALLOC_AND_LOG (GF_PARSE, parser, ret,
-                                "Failed to duplicate string!", out);
+    parser->complete_str = gf_strdup(complete_str);
+    GF_CHECK_ALLOC_AND_LOG(GF_PARSE, parser, ret, "Failed to duplicate string!",
+                           out);
 
-        /* Point the temp internal string to what we just dup'ed */
-        parser->_rstr = (char *)parser->complete_str;
-        ret = 0;
+    /* Point the temp internal string to what we just dup'ed */
+    parser->_rstr = (char *)parser->complete_str;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -107,17 +107,17 @@ out:
  *              : failure: -EINVAL on NULL args
  */
 int
-parser_unset_string (struct parser *parser)
+parser_unset_string(struct parser *parser)
 {
-        int ret = -EINVAL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
 
-        GF_FREE (parser->complete_str);
-        parser->complete_str = NULL; /* Avoid double frees in parser_deinit */
-        ret = 0;
+    GF_FREE(parser->complete_str);
+    parser->complete_str = NULL; /* Avoid double frees in parser_deinit */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -128,15 +128,15 @@ out:
  * @return    : nothing
  */
 void
-parser_deinit (struct parser *ptr)
+parser_deinit(struct parser *ptr)
 {
-        if (!ptr)
-                return;
+    if (!ptr)
+        return;
 
-        regfree (&ptr->preg);
-        GF_FREE (ptr->complete_str);
-        GF_FREE (ptr->regex);
-        GF_FREE (ptr);
+    regfree(&ptr->preg);
+    GF_FREE(ptr->complete_str);
+    GF_FREE(ptr->regex);
+    GF_FREE(ptr);
 }
 
 /**
@@ -149,29 +149,28 @@ parser_deinit (struct parser *ptr)
  *            : failure: NULL
  */
 char *
-parser_get_next_match (struct parser *parser)
+parser_get_next_match(struct parser *parser)
 {
-        int             rc       = -EINVAL;
-        size_t          copy_len = 0;
-        char            *match   = NULL;
+    int rc = -EINVAL;
+    size_t copy_len = 0;
+    char *match = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_PARSE, parser, out);
+    GF_VALIDATE_OR_GOTO(GF_PARSE, parser, out);
 
-        rc = regexec (&parser->preg, parser->_rstr, 1, parser->pmatch, 0);
-        if (rc != 0) {
-                gf_msg_debug (GF_PARSE, 0,
-                        "Could not match %s with regex %s",
-                        parser->_rstr, parser->regex);
-                goto out;
-        }
+    rc = regexec(&parser->preg, parser->_rstr, 1, parser->pmatch, 0);
+    if (rc != 0) {
+        gf_msg_debug(GF_PARSE, 0, "Could not match %s with regex %s",
+                     parser->_rstr, parser->regex);
+        goto out;
+    }
 
-        copy_len = parser->pmatch[0].rm_eo - parser->pmatch[0].rm_so;
+    copy_len = parser->pmatch[0].rm_eo - parser->pmatch[0].rm_so;
 
-        match = gf_strndup (parser->_rstr + parser->pmatch[0].rm_so, copy_len);
-        GF_CHECK_ALLOC_AND_LOG (GF_PARSE, match, rc,
-                                "Duplicating match failed!", out);
+    match = gf_strndup(parser->_rstr + parser->pmatch[0].rm_so, copy_len);
+    GF_CHECK_ALLOC_AND_LOG(GF_PARSE, match, rc, "Duplicating match failed!",
+                           out);
 
-        parser->_rstr = &parser->_rstr[parser->pmatch[0].rm_eo];
+    parser->_rstr = &parser->_rstr[parser->pmatch[0].rm_eo];
 out:
-        return match;
+    return match;
 }
diff --git a/libglusterfs/src/quota-common-utils.c b/libglusterfs/src/quota-common-utils.c
index a0a7dd5aafe..7e271ad7d07 100644
--- a/libglusterfs/src/quota-common-utils.c
+++ b/libglusterfs/src/quota-common-utils.c
@@ -8,7 +8,6 @@
    cases as published by the Free Software Foundation.
 */
 
-
 #include "dict.h"
 #include "logging.h"
 #include "byte-order.h"
@@ -17,227 +16,224 @@
 #include "libglusterfs-messages.h"
 
 gf_boolean_t
-quota_meta_is_null (const quota_meta_t *meta)
+quota_meta_is_null(const quota_meta_t *meta)
 {
-        if (meta->size == 0 &&
-            meta->file_count == 0 &&
-            meta->dir_count == 0)
-                return _gf_true;
+    if (meta->size == 0 && meta->file_count == 0 && meta->dir_count == 0)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int32_t
-quota_data_to_meta (data_t *data, char *key, quota_meta_t *meta)
+quota_data_to_meta(data_t *data, char *key, quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
-        quota_meta_t  *value    = NULL;
-        int64_t       *size     = NULL;
-
-        if (!data || !key || !meta)
-                goto out;
-
-        if (data->len > sizeof (int64_t)) {
-                value = (quota_meta_t *) data->data;
-                meta->size = ntoh64 (value->size);
-                meta->file_count = ntoh64 (value->file_count);
-                if (data->len > (sizeof (int64_t)) * 2)
-                        meta->dir_count  = ntoh64 (value->dir_count);
-                else
-                        meta->dir_count = 0;
-        } else {
-                size = (int64_t *) data->data;
-                meta->size = ntoh64 (*size);
-                meta->file_count = 0;
-                meta->dir_count = 0;
-                /* This can happen during software upgrade.
-                 * Older version of glusterfs will not have inode count.
-                 * Return failure, this will be healed as part of lookup
-                 */
-                gf_msg_callingfn ("quota", GF_LOG_DEBUG, 0,
-                                  LG_MSG_QUOTA_XATTRS_MISSING, "Object quota "
-                                  "xattrs missing: len = %d", data->len);
-                ret = -2;
-                goto out;
-        }
-
-        ret = 0;
+    int32_t ret = -1;
+    quota_meta_t *value = NULL;
+    int64_t *size = NULL;
+
+    if (!data || !key || !meta)
+        goto out;
+
+    if (data->len > sizeof(int64_t)) {
+        value = (quota_meta_t *)data->data;
+        meta->size = ntoh64(value->size);
+        meta->file_count = ntoh64(value->file_count);
+        if (data->len > (sizeof(int64_t)) * 2)
+            meta->dir_count = ntoh64(value->dir_count);
+        else
+            meta->dir_count = 0;
+    } else {
+        size = (int64_t *)data->data;
+        meta->size = ntoh64(*size);
+        meta->file_count = 0;
+        meta->dir_count = 0;
+        /* This can happen during software upgrade.
+         * Older version of glusterfs will not have inode count.
+         * Return failure, this will be healed as part of lookup
+         */
+        gf_msg_callingfn("quota", GF_LOG_DEBUG, 0, LG_MSG_QUOTA_XATTRS_MISSING,
+                         "Object quota "
+                         "xattrs missing: len = %d",
+                         data->len);
+        ret = -2;
+        goto out;
+    }
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_get_inode_meta (dict_t *dict, char *key, quota_meta_t *meta)
+quota_dict_get_inode_meta(dict_t *dict, char *key, quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
-        data_t        *data     = NULL;
+    int32_t ret = -1;
+    data_t *data = NULL;
 
-        if (!dict || !key || !meta)
-                goto out;
+    if (!dict || !key || !meta)
+        goto out;
 
-        data = dict_get (dict, key);
-        if (!data || !data->data)
-                goto out;
+    data = dict_get(dict, key);
+    if (!data || !data->data)
+        goto out;
 
-        ret = quota_data_to_meta (data, key, meta);
+    ret = quota_data_to_meta(data, key, meta);
 
 out:
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_get_meta (dict_t *dict, char *key, quota_meta_t *meta)
+quota_dict_get_meta(dict_t *dict, char *key, quota_meta_t *meta)
 {
-        int32_t        ret      = -1;
+    int32_t ret = -1;
 
-        ret = quota_dict_get_inode_meta (dict, key, meta);
-        if (ret == -2)
-                ret = 0;
+    ret = quota_dict_get_inode_meta(dict, key, meta);
+    if (ret == -2)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_dict_set_meta (dict_t *dict, char *key, const quota_meta_t *meta,
-                     ia_type_t ia_type)
+quota_dict_set_meta(dict_t *dict, char *key, const quota_meta_t *meta,
+                    ia_type_t ia_type)
 {
-        int32_t         ret      = -ENOMEM;
-        quota_meta_t   *value    = NULL;
-
-        value = GF_MALLOC (sizeof (quota_meta_t), gf_common_quota_meta_t);
-        if (value == NULL) {
-                goto out;
-        }
-
-        value->size = hton64 (meta->size);
-        value->file_count = hton64 (meta->file_count);
-        value->dir_count = hton64 (meta->dir_count);
-
-        if (ia_type == IA_IFDIR) {
-                ret = dict_set_bin (dict, key, value, sizeof (*value));
-        } else {
-                /* For a file we don't need to store dir_count in the
-                 * quota size xattr, so we set the len of the data in the dict
-                 * as 128bits, so when the posix xattrop reads the dict, it only
-                 * performs operations on size and file_count
-                 */
-                ret = dict_set_bin (dict, key, value,
-                                    sizeof (*value) - sizeof (int64_t));
-        }
-
-        if (ret < 0) {
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_DICT_SET_FAILED, "dict set failed");
-                GF_FREE (value);
-        }
+    int32_t ret = -ENOMEM;
+    quota_meta_t *value = NULL;
+
+    value = GF_MALLOC(sizeof(quota_meta_t), gf_common_quota_meta_t);
+    if (value == NULL) {
+        goto out;
+    }
+
+    value->size = hton64(meta->size);
+    value->file_count = hton64(meta->file_count);
+    value->dir_count = hton64(meta->dir_count);
+
+    if (ia_type == IA_IFDIR) {
+        ret = dict_set_bin(dict, key, value, sizeof(*value));
+    } else {
+        /* For a file we don't need to store dir_count in the
+         * quota size xattr, so we set the len of the data in the dict
+         * as 128bits, so when the posix xattrop reads the dict, it only
+         * performs operations on size and file_count
+         */
+        ret = dict_set_bin(dict, key, value, sizeof(*value) - sizeof(int64_t));
+    }
+
+    if (ret < 0) {
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_DICT_SET_FAILED,
+                         "dict set failed");
+        GF_FREE(value);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_read_header (int fd, char *buf)
+quota_conf_read_header(int fd, char *buf)
 {
-        int    ret             = 0;
-        const int header_len = SLEN (QUOTA_CONF_HEADER);
-
-        ret = gf_nread (fd, buf, header_len);
-        if (ret <= 0) {
-                goto out;
-        } else if (ret > 0 && ret != header_len) {
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    const int header_len = SLEN(QUOTA_CONF_HEADER);
 
-        buf[header_len-1] = 0;
+    ret = gf_nread(fd, buf, header_len);
+    if (ret <= 0) {
+        goto out;
+    } else if (ret > 0 && ret != header_len) {
+        ret = -1;
+        goto out;
+    }
+
+    buf[header_len - 1] = 0;
 
 out:
-        if (ret < 0)
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to read "
-                                  "header from a quota conf");
+    if (ret < 0)
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to read "
+                         "header from a quota conf");
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_read_version (int fd, float *version)
+quota_conf_read_version(int fd, float *version)
 {
-        int    ret             = 0;
-        char   buf[PATH_MAX]   = "";
-        char  *tail            = NULL;
-        float  value           = 0.0f;
-
-        ret = quota_conf_read_header (fd, buf);
-        if (ret == 0) {
-                /* quota.conf is empty */
-                value = GF_QUOTA_CONF_VERSION;
-                goto out;
-        } else if (ret < 0) {
-                goto out;
-        }
-
-        value = strtof ((buf + strlen(buf) - 3), &tail);
-        if (tail[0] != '\0') {
-                ret = -1;
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "invalid quota conf"
-                                  " version");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    char buf[PATH_MAX] = "";
+    char *tail = NULL;
+    float value = 0.0f;
+
+    ret = quota_conf_read_header(fd, buf);
+    if (ret == 0) {
+        /* quota.conf is empty */
+        value = GF_QUOTA_CONF_VERSION;
+        goto out;
+    } else if (ret < 0) {
+        goto out;
+    }
+
+    value = strtof((buf + strlen(buf) - 3), &tail);
+    if (tail[0] != '\0') {
+        ret = -1;
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "invalid quota conf"
+                         " version");
+        goto out;
+    }
+
+    ret = 0;
 
 out:
-        if (ret >= 0)
-                *version = value;
-        else
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to "
-                                  "read version from a quota conf header");
-
-        return ret;
+    if (ret >= 0)
+        *version = value;
+    else
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to "
+                         "read version from a quota conf header");
+
+    return ret;
 }
 
 int32_t
-quota_conf_read_gfid (int fd, void *buf, char *type, float version)
+quota_conf_read_gfid(int fd, void *buf, char *type, float version)
 {
-        int           ret         = 0;
-
-        ret = gf_nread (fd, buf, 16);
-        if (ret <= 0)
-                goto out;
-
-        if (ret != 16) {
-                ret = -1;
-                goto out;
-        }
-
-        if (version >= 1.2f) {
-                ret = gf_nread (fd, type, 1);
-                if (ret != 1) {
-                        ret = -1;
-                        goto out;
-                }
-                ret = 17;
-        } else {
-                *type = GF_QUOTA_CONF_TYPE_USAGE;
+    int ret = 0;
+
+    ret = gf_nread(fd, buf, 16);
+    if (ret <= 0)
+        goto out;
+
+    if (ret != 16) {
+        ret = -1;
+        goto out;
+    }
+
+    if (version >= 1.2f) {
+        ret = gf_nread(fd, type, 1);
+        if (ret != 1) {
+            ret = -1;
+            goto out;
         }
+        ret = 17;
+    } else {
+        *type = GF_QUOTA_CONF_TYPE_USAGE;
+    }
 
 out:
-        if (ret < 0)
-                gf_msg_callingfn ("quota", GF_LOG_ERROR, 0,
-                                  LG_MSG_QUOTA_CONF_ERROR, "failed to "
-                                  "read gfid from a quota conf");
+    if (ret < 0)
+        gf_msg_callingfn("quota", GF_LOG_ERROR, 0, LG_MSG_QUOTA_CONF_ERROR,
+                         "failed to "
+                         "read gfid from a quota conf");
 
-        return ret;
+    return ret;
 }
 
 int32_t
-quota_conf_skip_header (int fd)
+quota_conf_skip_header(int fd)
 {
-        return gf_skip_header_section (fd, strlen (QUOTA_CONF_HEADER));
+    return gf_skip_header_section(fd, strlen(QUOTA_CONF_HEADER));
 }
-
diff --git a/libglusterfs/src/rbthash.c b/libglusterfs/src/rbthash.c
index 4d654066e13..0068b7b881e 100644
--- a/libglusterfs/src/rbthash.c
+++ b/libglusterfs/src/rbthash.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "rbthash.h"
 #include "rb.h"
 #include "locking.h"
@@ -19,59 +18,57 @@
 #include <pthread.h>
 #include <string.h>
 
-
 int
-rbthash_comparator (void *entry1, void *entry2, void *param)
+rbthash_comparator(void *entry1, void *entry2, void *param)
 {
-        int             ret = 0;
-        rbthash_entry_t *e1 = NULL;
-        rbthash_entry_t *e2 = NULL;
+    int ret = 0;
+    rbthash_entry_t *e1 = NULL;
+    rbthash_entry_t *e2 = NULL;
 
-        if ((!entry1) || (!entry2) || (!param))
-                return -1;
+    if ((!entry1) || (!entry2) || (!param))
+        return -1;
 
-        e1 = (rbthash_entry_t *)entry1;
-        e2 = (rbthash_entry_t *)entry2;
+    e1 = (rbthash_entry_t *)entry1;
+    e2 = (rbthash_entry_t *)entry2;
 
-        if (e1->keylen != e2->keylen) {
-                if (e1->keylen < e2->keylen)
-                        ret = -1;
-                else if (e1->keylen > e2->keylen)
-                        ret = 1;
-        } else
-                ret = memcmp (e1->key, e2->key, e1->keylen);
+    if (e1->keylen != e2->keylen) {
+        if (e1->keylen < e2->keylen)
+            ret = -1;
+        else if (e1->keylen > e2->keylen)
+            ret = 1;
+    } else
+        ret = memcmp(e1->key, e2->key, e1->keylen);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__rbthash_init_buckets (rbthash_table_t *tbl, int buckets)
+__rbthash_init_buckets(rbthash_table_t *tbl, int buckets)
 {
-        int     i = 0;
-        int     ret = -1;
-
-        if (!tbl)
-                return -1;
-
-        for (; i < buckets; i++) {
-                LOCK_INIT (&tbl->buckets[i].bucketlock);
-                tbl->buckets[i].bucket = rb_create ((rb_comparison_func *)rbthash_comparator, tbl, NULL);
-                if (!tbl->buckets[i].bucket) {
-                        gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                                LG_MSG_RB_TABLE_CREATE_FAILED, "Failed to "
-                                "create rb table bucket");
-                        ret = -1;
-                        goto err;
-                }
+    int i = 0;
+    int ret = -1;
+
+    if (!tbl)
+        return -1;
+
+    for (; i < buckets; i++) {
+        LOCK_INIT(&tbl->buckets[i].bucketlock);
+        tbl->buckets[i].bucket = rb_create(
+            (rb_comparison_func *)rbthash_comparator, tbl, NULL);
+        if (!tbl->buckets[i].bucket) {
+            gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RB_TABLE_CREATE_FAILED,
+                   "Failed to "
+                   "create rb table bucket");
+            ret = -1;
+            goto err;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 /*
  * rbthash_table_init - Initialize a RBT based hash table
  * @buckets - Number of buckets in the hash table
@@ -83,391 +80,377 @@ err:
  */
 
 rbthash_table_t *
-rbthash_table_init (glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
-                    rbt_data_destroyer_t dfunc,
-                    unsigned long expected_entries,
-                    struct mem_pool *entrypool)
+rbthash_table_init(glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
+                   rbt_data_destroyer_t dfunc, unsigned long expected_entries,
+                   struct mem_pool *entrypool)
 {
-        rbthash_table_t         *newtab = NULL;
-        int                     ret = -1;
-
-        if (!hfunc) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR,
-                        "Hash function not given");
-                return NULL;
+    rbthash_table_t *newtab = NULL;
+    int ret = -1;
+
+    if (!hfunc) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR,
+               "Hash function not given");
+        return NULL;
+    }
+
+    if (!entrypool && !expected_entries) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Both mem-pool and expected entries not provided");
+        return NULL;
+    }
+
+    if (entrypool && expected_entries) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Both mem-pool and expected entries are provided");
+        return NULL;
+    }
+
+    newtab = GF_CALLOC(1, sizeof(*newtab), gf_common_mt_rbthash_table_t);
+    if (!newtab)
+        return NULL;
+
+    newtab->buckets = GF_CALLOC(buckets, sizeof(struct rbthash_bucket),
+                                gf_common_mt_rbthash_bucket);
+    if (!newtab->buckets) {
+        goto free_newtab;
+    }
+
+    if (expected_entries) {
+        newtab->entrypool = mem_pool_new_ctx(ctx, rbthash_entry_t,
+                                             expected_entries);
+        if (!newtab->entrypool) {
+            goto free_buckets;
         }
-
-        if (!entrypool && !expected_entries) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Both mem-pool and expected entries not provided");
-                return NULL;
-        }
-
-        if (entrypool && expected_entries) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-                        "Both mem-pool and expected entries are provided");
-                return NULL;
-        }
-
-
-        newtab = GF_CALLOC (1, sizeof (*newtab),
-                            gf_common_mt_rbthash_table_t);
-        if (!newtab)
-                return NULL;
-
-        newtab->buckets = GF_CALLOC (buckets, sizeof (struct rbthash_bucket),
-                                     gf_common_mt_rbthash_bucket);
-        if (!newtab->buckets) {
-                goto free_newtab;
-        }
-
-        if (expected_entries) {
-                newtab->entrypool =
-                        mem_pool_new_ctx (ctx, rbthash_entry_t,
-                                          expected_entries);
-                if (!newtab->entrypool) {
-                        goto free_buckets;
-                }
-                newtab->pool_alloced = _gf_true;
-        } else {
-                newtab->entrypool = entrypool;
-        }
-
-        LOCK_INIT (&newtab->tablelock);
-        INIT_LIST_HEAD (&newtab->list);
-        newtab->numbuckets = buckets;
-        ret = __rbthash_init_buckets (newtab, buckets);
-
-        if (ret == -1) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
-                        "Failed to init buckets");
-                if (newtab->pool_alloced)
-                        mem_pool_destroy (newtab->entrypool);
-        } else {
-                gf_msg_trace (GF_RBTHASH, 0, "Inited hash table: buckets:"
-                        " %d", buckets);
-        }
-
-        newtab->hashfunc = hfunc;
-        newtab->dfunc = dfunc;
+        newtab->pool_alloced = _gf_true;
+    } else {
+        newtab->entrypool = entrypool;
+    }
+
+    LOCK_INIT(&newtab->tablelock);
+    INIT_LIST_HEAD(&newtab->list);
+    newtab->numbuckets = buckets;
+    ret = __rbthash_init_buckets(newtab, buckets);
+
+    if (ret == -1) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
+               "Failed to init buckets");
+        if (newtab->pool_alloced)
+            mem_pool_destroy(newtab->entrypool);
+    } else {
+        gf_msg_trace(GF_RBTHASH, 0,
+                     "Inited hash table: buckets:"
+                     " %d",
+                     buckets);
+    }
+
+    newtab->hashfunc = hfunc;
+    newtab->dfunc = dfunc;
 
 free_buckets:
-        if (ret == -1)
-                GF_FREE (newtab->buckets);
+    if (ret == -1)
+        GF_FREE(newtab->buckets);
 
 free_newtab:
-        if (ret == -1) {
-                GF_FREE (newtab);
-                newtab = NULL;
-        }
+    if (ret == -1) {
+        GF_FREE(newtab);
+        newtab = NULL;
+    }
 
-        return newtab;
+    return newtab;
 }
 
 rbthash_entry_t *
-rbthash_init_entry (rbthash_table_t *tbl, void *data, void *key, int keylen)
+rbthash_init_entry(rbthash_table_t *tbl, void *data, void *key, int keylen)
 {
-        int             ret = -1;
-        rbthash_entry_t *entry = NULL;
-
-        if ((!tbl) || (!data) || (!key))
-                return NULL;
-
-        entry = mem_get (tbl->entrypool);
-        if (!entry) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_ENTRY_FAILED,
-                        "Failed to get entry from mem-pool");
-                goto ret;
-        }
-
-        entry->data = data;
-        entry->key = GF_MALLOC (keylen, gf_common_mt_char);
-        if (!entry->key) {
-                goto free_entry;
-        }
-
-        INIT_LIST_HEAD (&entry->list);
-        memcpy (entry->key, key, keylen);
-        entry->keylen = keylen;
-        entry->keyhash = tbl->hashfunc (entry->key, entry->keylen);
-        gf_msg_trace (GF_RBTHASH, 0, "HASH: %u", entry->keyhash);
-
-        ret = 0;
+    int ret = -1;
+    rbthash_entry_t *entry = NULL;
+
+    if ((!tbl) || (!data) || (!key))
+        return NULL;
+
+    entry = mem_get(tbl->entrypool);
+    if (!entry) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_ENTRY_FAILED,
+               "Failed to get entry from mem-pool");
+        goto ret;
+    }
+
+    entry->data = data;
+    entry->key = GF_MALLOC(keylen, gf_common_mt_char);
+    if (!entry->key) {
+        goto free_entry;
+    }
+
+    INIT_LIST_HEAD(&entry->list);
+    memcpy(entry->key, key, keylen);
+    entry->keylen = keylen;
+    entry->keyhash = tbl->hashfunc(entry->key, entry->keylen);
+    gf_msg_trace(GF_RBTHASH, 0, "HASH: %u", entry->keyhash);
+
+    ret = 0;
 free_entry:
-        if (ret == -1) {
-                mem_put (entry);
-                entry = NULL;
-        }
+    if (ret == -1) {
+        mem_put(entry);
+        entry = NULL;
+    }
 
 ret:
-        return entry;
+    return entry;
 }
 
-
 void
-rbthash_deinit_entry (rbthash_table_t *tbl, rbthash_entry_t *entry)
+rbthash_deinit_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
+    if (!entry)
+        return;
 
-        if (!entry)
-                return;
-
-        GF_FREE (entry->key);
-
-        if (tbl) {
-                if ((entry->data) && (tbl->dfunc))
-                        tbl->dfunc (entry->data);
+    GF_FREE(entry->key);
 
-                LOCK (&tbl->tablelock);
-                {
-                        list_del_init (&entry->list);
-                }
-                UNLOCK (&tbl->tablelock);
+    if (tbl) {
+        if ((entry->data) && (tbl->dfunc))
+            tbl->dfunc(entry->data);
 
-                mem_put (entry);
+        LOCK(&tbl->tablelock);
+        {
+            list_del_init(&entry->list);
         }
+        UNLOCK(&tbl->tablelock);
 
-        return;
-}
+        mem_put(entry);
+    }
 
+    return;
+}
 
 static struct rbthash_bucket *
-rbthash_entry_bucket (rbthash_table_t *tbl, rbthash_entry_t * entry)
+rbthash_entry_bucket(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
-        int     nbucket = 0;
+    int nbucket = 0;
 
-        nbucket = (entry->keyhash % tbl->numbuckets);
-        gf_msg_trace (GF_RBTHASH, 0, "BUCKET: %d", nbucket);
-        return &tbl->buckets[nbucket];
+    nbucket = (entry->keyhash % tbl->numbuckets);
+    gf_msg_trace(GF_RBTHASH, 0, "BUCKET: %d", nbucket);
+    return &tbl->buckets[nbucket];
 }
 
-
 int
-rbthash_insert_entry (rbthash_table_t *tbl, rbthash_entry_t *entry)
+rbthash_insert_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
 {
-        struct rbthash_bucket   *bucket = NULL;
-        int                     ret = -1;
-
-        if ((!tbl) || (!entry))
-                return -1;
-
-        bucket = rbthash_entry_bucket (tbl, entry);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                goto err;
+    struct rbthash_bucket *bucket = NULL;
+    int ret = -1;
+
+    if ((!tbl) || (!entry))
+        return -1;
+
+    bucket = rbthash_entry_bucket(tbl, entry);
+    if (!bucket) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+               "Failed to get bucket");
+        goto err;
+    }
+
+    ret = 0;
+    LOCK(&bucket->bucketlock);
+    {
+        if (!rb_probe(bucket->bucket, (void *)entry)) {
+            gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+                   "Failed to insert"
+                   " entry");
+            ret = -1;
         }
-
-        ret = 0;
-        LOCK (&bucket->bucketlock);
-        {
-                if (!rb_probe (bucket->bucket, (void *)entry)) {
-                        gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                                LG_MSG_RBTHASH_INSERT_FAILED, "Failed to insert"
-                                " entry");
-                        ret = -1;
-                }
-        }
-        UNLOCK (&bucket->bucketlock);
+    }
+    UNLOCK(&bucket->bucketlock);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rbthash_insert (rbthash_table_t *tbl, void *data, void *key, int keylen)
+rbthash_insert(rbthash_table_t *tbl, void *data, void *key, int keylen)
 {
-        rbthash_entry_t         *entry = NULL;
-        int                     ret = -1;
-
-        if ((!tbl) || (!data) || (!key))
-                return -1;
-
-        entry = rbthash_init_entry (tbl, data, key, keylen);
-        if (!entry) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
-                        "Failed to init entry");
-                goto err;
-        }
+    rbthash_entry_t *entry = NULL;
+    int ret = -1;
 
-        ret = rbthash_insert_entry (tbl, entry);
+    if ((!tbl) || (!data) || (!key))
+        return -1;
 
-        if (ret == -1) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_INSERT_FAILED,
-                        "Failed to insert entry");
-                rbthash_deinit_entry (tbl, entry);
-        }
+    entry = rbthash_init_entry(tbl, data, key, keylen);
+    if (!entry) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
+               "Failed to init entry");
+        goto err;
+    }
 
-        LOCK (&tbl->tablelock);
-        {
-                list_add_tail (&entry->list, &tbl->list);
-        }
-        UNLOCK (&tbl->tablelock);
+    ret = rbthash_insert_entry(tbl, entry);
+
+    if (ret == -1) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+               "Failed to insert entry");
+        rbthash_deinit_entry(tbl, entry);
+    }
+
+    LOCK(&tbl->tablelock);
+    {
+        list_add_tail(&entry->list, &tbl->list);
+    }
+    UNLOCK(&tbl->tablelock);
 
 err:
-        return ret;
+    return ret;
 }
 
 static struct rbthash_bucket *
-rbthash_key_bucket (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_key_bucket(rbthash_table_t *tbl, void *key, int keylen)
 {
-        uint32_t        keyhash = 0;
-        int             nbucket = 0;
+    uint32_t keyhash = 0;
+    int nbucket = 0;
 
-        if ((!tbl) || (!key))
-                return NULL;
+    if ((!tbl) || (!key))
+        return NULL;
 
-        keyhash =  tbl->hashfunc (key, keylen);
-        gf_msg_trace (GF_RBTHASH, 0, "HASH: %u", keyhash);
-        nbucket = (keyhash % tbl->numbuckets);
-        gf_msg_trace (GF_RBTHASH, 0, "BUCKET: %u", nbucket);
+    keyhash = tbl->hashfunc(key, keylen);
+    gf_msg_trace(GF_RBTHASH, 0, "HASH: %u", keyhash);
+    nbucket = (keyhash % tbl->numbuckets);
+    gf_msg_trace(GF_RBTHASH, 0, "BUCKET: %u", nbucket);
 
-        return &tbl->buckets[nbucket];
+    return &tbl->buckets[nbucket];
 }
 
-
 void *
-rbthash_get (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_get(rbthash_table_t *tbl, void *key, int keylen)
 {
-        struct rbthash_bucket           *bucket = NULL;
-        rbthash_entry_t                 *entry = NULL;
-        rbthash_entry_t                 searchentry = {0, };
-
-        if ((!tbl) || (!key))
-                return NULL;
-
-        bucket = rbthash_key_bucket (tbl, key, keylen);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                return NULL;
-        }
-
-        searchentry.key = key;
-        searchentry.keylen = keylen;
-        LOCK (&bucket->bucketlock);
-        {
-                entry = rb_find (bucket->bucket, &searchentry);
-        }
-        UNLOCK (&bucket->bucketlock);
-
-        if (!entry)
-                return NULL;
-
-        return entry->data;
+    struct rbthash_bucket *bucket = NULL;
+    rbthash_entry_t *entry = NULL;
+    rbthash_entry_t searchentry = {
+        0,
+    };
+
+    if ((!tbl) || (!key))
+        return NULL;
+
+    bucket = rbthash_key_bucket(tbl, key, keylen);
+    if (!bucket) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_GET_BUCKET_FAILED,
+               "Failed to get bucket");
+        return NULL;
+    }
+
+    searchentry.key = key;
+    searchentry.keylen = keylen;
+    LOCK(&bucket->bucketlock);
+    {
+        entry = rb_find(bucket->bucket, &searchentry);
+    }
+    UNLOCK(&bucket->bucketlock);
+
+    if (!entry)
+        return NULL;
+
+    return entry->data;
 }
 
-
 void *
-rbthash_remove (rbthash_table_t *tbl, void *key, int keylen)
+rbthash_remove(rbthash_table_t *tbl, void *key, int keylen)
 {
-        struct rbthash_bucket   *bucket = NULL;
-        rbthash_entry_t         *entry = NULL;
-        rbthash_entry_t         searchentry = {0, };
-        void                    *dataref = NULL;
-
-        if ((!tbl) || (!key))
-                return NULL;
-
-        bucket = rbthash_key_bucket (tbl, key, keylen);
-        if (!bucket) {
-                gf_msg (GF_RBTHASH, GF_LOG_ERROR, 0,
-                        LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-                        "Failed to get bucket");
-                return NULL;
-        }
-
-        searchentry.key = key;
-        searchentry.keylen = keylen;
-
-        LOCK (&bucket->bucketlock);
-        {
-                entry = rb_delete (bucket->bucket, &searchentry);
-        }
-        UNLOCK (&bucket->bucketlock);
-
-        if (!entry)
-                return NULL;
-
-        GF_FREE (entry->key);
-        dataref = entry->data;
-
-        LOCK (&tbl->tablelock);
-        {
-                list_del_init (&entry->list);
-        }
-        UNLOCK (&tbl->tablelock);
-
-        mem_put (entry);
-
-        return dataref;
+    struct rbthash_bucket *bucket = NULL;
+    rbthash_entry_t *entry = NULL;
+    rbthash_entry_t searchentry = {
+        0,
+    };
+    void *dataref = NULL;
+
+    if ((!tbl) || (!key))
+        return NULL;
+
+    bucket = rbthash_key_bucket(tbl, key, keylen);
+    if (!bucket) {
+        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+               "Failed to get bucket");
+        return NULL;
+    }
+
+    searchentry.key = key;
+    searchentry.keylen = keylen;
+
+    LOCK(&bucket->bucketlock);
+    {
+        entry = rb_delete(bucket->bucket, &searchentry);
+    }
+    UNLOCK(&bucket->bucketlock);
+
+    if (!entry)
+        return NULL;
+
+    GF_FREE(entry->key);
+    dataref = entry->data;
+
+    LOCK(&tbl->tablelock);
+    {
+        list_del_init(&entry->list);
+    }
+    UNLOCK(&tbl->tablelock);
+
+    mem_put(entry);
+
+    return dataref;
 }
 
-
 void
-rbthash_entry_deiniter (void *entry, void *rbparam)
+rbthash_entry_deiniter(void *entry, void *rbparam)
 {
-        if (!entry)
-                return;
+    if (!entry)
+        return;
 
-        rbthash_deinit_entry (rbparam, entry);
+    rbthash_deinit_entry(rbparam, entry);
 }
 
-
 void
-rbthash_table_destroy_buckets (rbthash_table_t *tbl)
+rbthash_table_destroy_buckets(rbthash_table_t *tbl)
 {
-        int x = 0;
-        if (!tbl)
-                return;
+    int x = 0;
+    if (!tbl)
+        return;
 
-        for (;x < tbl->numbuckets; x++) {
-                LOCK_DESTROY (&tbl->buckets[x].bucketlock);
-                rb_destroy (tbl->buckets[x].bucket, rbthash_entry_deiniter);
-        }
+    for (; x < tbl->numbuckets; x++) {
+        LOCK_DESTROY(&tbl->buckets[x].bucketlock);
+        rb_destroy(tbl->buckets[x].bucket, rbthash_entry_deiniter);
+    }
 
-        return;
+    return;
 }
 
-
 void
-rbthash_table_destroy (rbthash_table_t *tbl)
+rbthash_table_destroy(rbthash_table_t *tbl)
 {
-        if (!tbl)
-                return;
+    if (!tbl)
+        return;
 
-        rbthash_table_destroy_buckets (tbl);
-        if (tbl->pool_alloced)
-                mem_pool_destroy (tbl->entrypool);
+    rbthash_table_destroy_buckets(tbl);
+    if (tbl->pool_alloced)
+        mem_pool_destroy(tbl->entrypool);
 
-        GF_FREE (tbl->buckets);
-        GF_FREE (tbl);
+    GF_FREE(tbl->buckets);
+    GF_FREE(tbl);
 }
 
-
 void
-rbthash_table_traverse (rbthash_table_t *tbl, rbt_traverse_t traverse,
-                        void *mydata)
+rbthash_table_traverse(rbthash_table_t *tbl, rbt_traverse_t traverse,
+                       void *mydata)
 {
-        rbthash_entry_t *entry = NULL;
+    rbthash_entry_t *entry = NULL;
 
-        if ((tbl == NULL) || (traverse == NULL)) {
-                goto out;
-        }
+    if ((tbl == NULL) || (traverse == NULL)) {
+        goto out;
+    }
 
-        LOCK (&tbl->tablelock);
+    LOCK(&tbl->tablelock);
+    {
+        list_for_each_entry(entry, &tbl->list, list)
         {
-                list_for_each_entry (entry, &tbl->list, list) {
-                        traverse (entry->data, mydata);
-                }
+            traverse(entry->data, mydata);
         }
-        UNLOCK (&tbl->tablelock);
+    }
+    UNLOCK(&tbl->tablelock);
 
 out:
-        return;
+    return;
 }
diff --git a/libglusterfs/src/refcount.c b/libglusterfs/src/refcount.c
index 714bb9afef6..a522d86a677 100644
--- a/libglusterfs/src/refcount.c
+++ b/libglusterfs/src/refcount.c
@@ -14,96 +14,95 @@
 #ifndef REFCOUNT_NEEDS_LOCK
 
 void *
-_gf_ref_get (gf_ref_t *ref)
+_gf_ref_get(gf_ref_t *ref)
 {
-        unsigned int cnt = __sync_fetch_and_add (&ref->cnt, 1);
-
-        /* if cnt == 0, we're in a fatal position, the object will be free'd
-         *
-         * There is a race when two threads do a _gf_ref_get(). Only one of
-         * them may get a 0 returned. That is acceptable, because one
-         * _gf_ref_get() returning 0 should be handled as a fatal problem and
-         * when correct usage/locking is used, it should never happen.
-         */
-        GF_ASSERT (cnt != 0);
-
-        return cnt ? ref->data : NULL;
+    unsigned int cnt = __sync_fetch_and_add(&ref->cnt, 1);
+
+    /* if cnt == 0, we're in a fatal position, the object will be free'd
+     *
+     * There is a race when two threads do a _gf_ref_get(). Only one of
+     * them may get a 0 returned. That is acceptable, because one
+     * _gf_ref_get() returning 0 should be handled as a fatal problem and
+     * when correct usage/locking is used, it should never happen.
+     */
+    GF_ASSERT(cnt != 0);
+
+    return cnt ? ref->data : NULL;
 }
 
 unsigned int
-_gf_ref_put (gf_ref_t *ref)
+_gf_ref_put(gf_ref_t *ref)
 {
-        unsigned int cnt = __sync_fetch_and_sub (&ref->cnt, 1);
+    unsigned int cnt = __sync_fetch_and_sub(&ref->cnt, 1);
 
-        /* if cnt == 1, the last user just did a _gf_ref_put()
-         *
-         * When cnt == 0, one _gf_ref_put() was done too much and there has
-         * been a thread using the refcounted structure when it was not
-         * supposed to.
-         */
-        GF_ASSERT (cnt != 0);
+    /* if cnt == 1, the last user just did a _gf_ref_put()
+     *
+     * When cnt == 0, one _gf_ref_put() was done too much and there has
+     * been a thread using the refcounted structure when it was not
+     * supposed to.
+     */
+    GF_ASSERT(cnt != 0);
 
-        if (cnt == 1 && ref->release)
-                ref->release (ref->data);
+    if (cnt == 1 && ref->release)
+        ref->release(ref->data);
 
-        return (cnt != 1);
+    return (cnt != 1);
 }
 
 #else
 
 void *
-_gf_ref_get (gf_ref_t *ref)
+_gf_ref_get(gf_ref_t *ref)
 {
-        unsigned int cnt = 0;
-
-        LOCK (&ref->lk);
-        {
-                /* never can be 0, should have been free'd */
-                if (ref->cnt > 0)
-                        cnt = ++ref->cnt;
-                else
-                        GF_ASSERT (ref->cnt > 0);
-        }
-        UNLOCK (&ref->lk);
-
-        return cnt ? ref->data : NULL;
+    unsigned int cnt = 0;
+
+    LOCK(&ref->lk);
+    {
+        /* never can be 0, should have been free'd */
+        if (ref->cnt > 0)
+            cnt = ++ref->cnt;
+        else
+            GF_ASSERT(ref->cnt > 0);
+    }
+    UNLOCK(&ref->lk);
+
+    return cnt ? ref->data : NULL;
 }
 
 unsigned int
-_gf_ref_put (gf_ref_t *ref)
+_gf_ref_put(gf_ref_t *ref)
 {
-        unsigned int cnt = 0;
-        int release = 0;
-
-        LOCK (&ref->lk);
-        {
-                if (ref->cnt != 0) {
-                        cnt = --ref->cnt;
-                        /* call release() only when cnt == 0 */
-                        release = (cnt == 0);
-                } else
-                        GF_ASSERT (ref->cnt != 0);
-        }
-        UNLOCK (&ref->lk);
-
-        if (release && ref->release)
-                ref->release (ref->data);
-
-        return !release;
+    unsigned int cnt = 0;
+    int release = 0;
+
+    LOCK(&ref->lk);
+    {
+        if (ref->cnt != 0) {
+            cnt = --ref->cnt;
+            /* call release() only when cnt == 0 */
+            release = (cnt == 0);
+        } else
+            GF_ASSERT(ref->cnt != 0);
+    }
+    UNLOCK(&ref->lk);
+
+    if (release && ref->release)
+        ref->release(ref->data);
+
+    return !release;
 }
 
 #endif /* REFCOUNT_NEEDS_LOCK */
 
-
 void
-_gf_ref_init (gf_ref_t *ref, gf_ref_release_t release, void *data)
+_gf_ref_init(gf_ref_t *ref, gf_ref_release_t release, void *data)
 {
-        GF_ASSERT (ref);
+    GF_ASSERT(ref);
 
 #ifdef REFCOUNT_NEEDS_LOCK
-        LOCK_INIT (&ref->lk);
+    LOCK_INIT(&ref->lk);
 #endif
-        ref->cnt = 1;
-        ref->release = release;
-        ref->data = data;
+    ref->cnt = 1;
+    ref->release = release;
+    ref->data = data;
 }
diff --git a/libglusterfs/src/rot-buffs.c b/libglusterfs/src/rot-buffs.c
index cbded2b3f46..c5147321c60 100644
--- a/libglusterfs/src/rot-buffs.c
+++ b/libglusterfs/src/rot-buffs.c
@@ -26,10 +26,10 @@
  * TODO: do away with opaques (use arrays with indexing).
  */
 
-#define ROT_BUFF_DEFAULT_COUNT  2
-#define ROT_BUFF_ALLOC_SIZE  (1 * 1024 * 1024)  /* 1MB per iovec */
+#define ROT_BUFF_DEFAULT_COUNT 2
+#define ROT_BUFF_ALLOC_SIZE (1 * 1024 * 1024) /* 1MB per iovec */
 
-#define RLIST_IOV_MELDED_ALLOC_SIZE  (RBUF_IOVEC_SIZE + ROT_BUFF_ALLOC_SIZE)
+#define RLIST_IOV_MELDED_ALLOC_SIZE (RBUF_IOVEC_SIZE + ROT_BUFF_ALLOC_SIZE)
 
 /**
  * iovec list is not shrunk (deallocated) if usage/total count
@@ -37,373 +37,369 @@
  * most of the workloads. for the rest shrinking iovec list is
  * generous.
  */
-#define RVEC_LOW_WATERMARK_COUNT  1
+#define RVEC_LOW_WATERMARK_COUNT 1
 #define RVEC_HIGH_WATERMARK_COUNT (1 << 4)
 
-static inline
-rbuf_list_t *rbuf_current_buffer (rbuf_t *rbuf)
+static inline rbuf_list_t *
+rbuf_current_buffer(rbuf_t *rbuf)
 {
-        return rbuf->current;
+    return rbuf->current;
 }
 
 static void
-rlist_mark_waiting (rbuf_list_t *rlist)
+rlist_mark_waiting(rbuf_list_t *rlist)
 {
-        LOCK (&rlist->c_lock);
-        {
-                rlist->awaiting = _gf_true;
-        }
-        UNLOCK (&rlist->c_lock);
+    LOCK(&rlist->c_lock);
+    {
+        rlist->awaiting = _gf_true;
+    }
+    UNLOCK(&rlist->c_lock);
 }
 
 static int
-__rlist_has_waiter (rbuf_list_t *rlist)
+__rlist_has_waiter(rbuf_list_t *rlist)
 {
-        return (rlist->awaiting == _gf_true);
+    return (rlist->awaiting == _gf_true);
 }
 
 static void *
-rbuf_alloc_rvec ()
+rbuf_alloc_rvec()
 {
-        return GF_CALLOC (1, RLIST_IOV_MELDED_ALLOC_SIZE, gf_common_mt_rvec_t);
+    return GF_CALLOC(1, RLIST_IOV_MELDED_ALLOC_SIZE, gf_common_mt_rvec_t);
 }
 
 static void
-rlist_reset_vector_usage (rbuf_list_t *rlist)
+rlist_reset_vector_usage(rbuf_list_t *rlist)
 {
-        rlist->used = 1;
+    rlist->used = 1;
 }
 
 static void
-rlist_increment_vector_usage (rbuf_list_t *rlist)
+rlist_increment_vector_usage(rbuf_list_t *rlist)
 {
-        rlist->used++;
+    rlist->used++;
 }
 
 static void
-rlist_increment_total_usage (rbuf_list_t *rlist)
+rlist_increment_total_usage(rbuf_list_t *rlist)
 {
-        rlist->total++;
+    rlist->total++;
 }
 
 static int
-rvec_in_watermark_range (rbuf_list_t *rlist)
+rvec_in_watermark_range(rbuf_list_t *rlist)
 {
-        return ((rlist->total >= RVEC_LOW_WATERMARK_COUNT)
-                    && (rlist->total <= RVEC_HIGH_WATERMARK_COUNT));
+    return ((rlist->total >= RVEC_LOW_WATERMARK_COUNT) &&
+            (rlist->total <= RVEC_HIGH_WATERMARK_COUNT));
 }
 
 static void
-rbuf_reset_rvec (rbuf_iovec_t *rvec)
+rbuf_reset_rvec(rbuf_iovec_t *rvec)
 {
-        /* iov_base is _never_ modified */
-        rvec->iov.iov_len = 0;
+    /* iov_base is _never_ modified */
+    rvec->iov.iov_len = 0;
 }
 
 /* TODO: alloc multiple rbuf_iovec_t */
 static int
-rlist_add_new_vec (rbuf_list_t *rlist)
+rlist_add_new_vec(rbuf_list_t *rlist)
 {
-        rbuf_iovec_t *rvec = NULL;
+    rbuf_iovec_t *rvec = NULL;
 
-        rvec = (rbuf_iovec_t *) rbuf_alloc_rvec ();
-        if (!rvec)
-                return -1;
-        INIT_LIST_HEAD (&rvec->list);
-        rvec->iov.iov_base = ((char *)rvec) + RBUF_IOVEC_SIZE;
-        rvec->iov.iov_len = 0;
+    rvec = (rbuf_iovec_t *)rbuf_alloc_rvec();
+    if (!rvec)
+        return -1;
+    INIT_LIST_HEAD(&rvec->list);
+    rvec->iov.iov_base = ((char *)rvec) + RBUF_IOVEC_SIZE;
+    rvec->iov.iov_len = 0;
 
-        list_add_tail (&rvec->list, &rlist->veclist);
+    list_add_tail(&rvec->list, &rlist->veclist);
 
-        rlist->rvec = rvec; /* cache the latest */
+    rlist->rvec = rvec; /* cache the latest */
 
-        rlist_increment_vector_usage (rlist);
-        rlist_increment_total_usage (rlist);
+    rlist_increment_vector_usage(rlist);
+    rlist_increment_total_usage(rlist);
 
-        return 0;
+    return 0;
 }
 
 static void
-rlist_free_rvec (rbuf_iovec_t *rvec)
+rlist_free_rvec(rbuf_iovec_t *rvec)
 {
-        if (!rvec)
-                return;
-        list_del (&rvec->list);
-        GF_FREE (rvec);
+    if (!rvec)
+        return;
+    list_del(&rvec->list);
+    GF_FREE(rvec);
 }
 
 static void
-rlist_purge_all_rvec (rbuf_list_t *rlist)
+rlist_purge_all_rvec(rbuf_list_t *rlist)
 {
-        rbuf_iovec_t *rvec = NULL;
-
-        if (!rlist)
-                return;
-        while (!list_empty (&rlist->veclist)) {
-                rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-                rlist_free_rvec (rvec);
-        }
+    rbuf_iovec_t *rvec = NULL;
+
+    if (!rlist)
+        return;
+    while (!list_empty(&rlist->veclist)) {
+        rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+        rlist_free_rvec(rvec);
+    }
 }
 
 static void
-rlist_shrink_rvec (rbuf_list_t *rlist, unsigned long long shrink)
+rlist_shrink_rvec(rbuf_list_t *rlist, unsigned long long shrink)
 {
-        rbuf_iovec_t *rvec = NULL;
+    rbuf_iovec_t *rvec = NULL;
 
-        while (!list_empty (&rlist->veclist) && (shrink-- > 0)) {
-                rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-                rlist_free_rvec (rvec);
-        }
+    while (!list_empty(&rlist->veclist) && (shrink-- > 0)) {
+        rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+        rlist_free_rvec(rvec);
+    }
 }
 
 static void
-rbuf_purge_rlist (rbuf_t *rbuf)
+rbuf_purge_rlist(rbuf_t *rbuf)
 {
-        rbuf_list_t *rlist = NULL;
+    rbuf_list_t *rlist = NULL;
 
-        while (!list_empty (&rbuf->freelist)) {
-                rlist = list_first_entry (&rbuf->freelist, rbuf_list_t, list);
-                list_del (&rlist->list);
+    while (!list_empty(&rbuf->freelist)) {
+        rlist = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+        list_del(&rlist->list);
 
-                rlist_purge_all_rvec (rlist);
+        rlist_purge_all_rvec(rlist);
 
-                LOCK_DESTROY (&rlist->c_lock);
+        LOCK_DESTROY(&rlist->c_lock);
 
-                (void) pthread_mutex_destroy (&rlist->b_lock);
-                (void) pthread_cond_destroy (&rlist->b_cond);
+        (void)pthread_mutex_destroy(&rlist->b_lock);
+        (void)pthread_cond_destroy(&rlist->b_cond);
 
-                GF_FREE (rlist);
-        }
+        GF_FREE(rlist);
+    }
 }
 
 rbuf_t *
-rbuf_init (int bufcount)
+rbuf_init(int bufcount)
 {
-        int          j     = 0;
-        int          ret   = 0;
-        rbuf_t      *rbuf  = NULL;
-        rbuf_list_t *rlist = NULL;
-
-        if (bufcount <= 0)
-                bufcount = ROT_BUFF_DEFAULT_COUNT;
-
-        rbuf = GF_CALLOC (1, sizeof (rbuf_t), gf_common_mt_rbuf_t);
-        if (!rbuf)
-                goto error_return;
-
-        LOCK_INIT (&rbuf->lock);
-        INIT_LIST_HEAD (&rbuf->freelist);
-
-        /* it could have been one big calloc() but this is just once.. */
-        for (j = 0; j < bufcount; j++) {
-                rlist = GF_CALLOC (1,
-                                   sizeof (rbuf_list_t), gf_common_mt_rlist_t);
-                if (!rlist) {
-                        ret = -1;
-                        break;
-                }
-
-                INIT_LIST_HEAD (&rlist->list);
-                INIT_LIST_HEAD (&rlist->veclist);
-
-                rlist->pending = rlist->completed = 0;
-
-                ret = rlist_add_new_vec (rlist);
-                if (ret)
-                        break;
-
-                LOCK_INIT (&rlist->c_lock);
-
-                rlist->awaiting = _gf_false;
-                ret = pthread_mutex_init (&rlist->b_lock, 0);
-                if (ret != 0) {
-                        GF_FREE (rlist);
-                        break;
-                }
-
-                ret = pthread_cond_init (&rlist->b_cond, 0);
-                if (ret != 0) {
-                        GF_FREE (rlist);
-                        break;
-                }
-
-                list_add_tail (&rlist->list, &rbuf->freelist);
+    int j = 0;
+    int ret = 0;
+    rbuf_t *rbuf = NULL;
+    rbuf_list_t *rlist = NULL;
+
+    if (bufcount <= 0)
+        bufcount = ROT_BUFF_DEFAULT_COUNT;
+
+    rbuf = GF_CALLOC(1, sizeof(rbuf_t), gf_common_mt_rbuf_t);
+    if (!rbuf)
+        goto error_return;
+
+    LOCK_INIT(&rbuf->lock);
+    INIT_LIST_HEAD(&rbuf->freelist);
+
+    /* it could have been one big calloc() but this is just once.. */
+    for (j = 0; j < bufcount; j++) {
+        rlist = GF_CALLOC(1, sizeof(rbuf_list_t), gf_common_mt_rlist_t);
+        if (!rlist) {
+            ret = -1;
+            break;
         }
 
-        if (ret != 0)
-                goto dealloc_rlist;
+        INIT_LIST_HEAD(&rlist->list);
+        INIT_LIST_HEAD(&rlist->veclist);
 
-        /* cache currently used buffer: first in the list */
-        rbuf->current = list_first_entry (&rbuf->freelist, rbuf_list_t, list);
-        return rbuf;
+        rlist->pending = rlist->completed = 0;
 
- dealloc_rlist:
-        rbuf_purge_rlist (rbuf);
-        LOCK_DESTROY (&rbuf->lock);
-        GF_FREE (rbuf);
- error_return:
-        return NULL;
+        ret = rlist_add_new_vec(rlist);
+        if (ret)
+            break;
+
+        LOCK_INIT(&rlist->c_lock);
+
+        rlist->awaiting = _gf_false;
+        ret = pthread_mutex_init(&rlist->b_lock, 0);
+        if (ret != 0) {
+            GF_FREE(rlist);
+            break;
+        }
+
+        ret = pthread_cond_init(&rlist->b_cond, 0);
+        if (ret != 0) {
+            GF_FREE(rlist);
+            break;
+        }
+
+        list_add_tail(&rlist->list, &rbuf->freelist);
+    }
+
+    if (ret != 0)
+        goto dealloc_rlist;
+
+    /* cache currently used buffer: first in the list */
+    rbuf->current = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+    return rbuf;
+
+dealloc_rlist:
+    rbuf_purge_rlist(rbuf);
+    LOCK_DESTROY(&rbuf->lock);
+    GF_FREE(rbuf);
+error_return:
+    return NULL;
 }
 
 void
-rbuf_dtor (rbuf_t *rbuf)
+rbuf_dtor(rbuf_t *rbuf)
 {
-        if (!rbuf)
-                return;
-        rbuf->current = NULL;
-        rbuf_purge_rlist (rbuf);
-        LOCK_DESTROY (&rbuf->lock);
+    if (!rbuf)
+        return;
+    rbuf->current = NULL;
+    rbuf_purge_rlist(rbuf);
+    LOCK_DESTROY(&rbuf->lock);
 
-        GF_FREE (rbuf);
+    GF_FREE(rbuf);
 }
 
 static char *
-rbuf_adjust_write_area (struct iovec *iov, size_t bytes)
+rbuf_adjust_write_area(struct iovec *iov, size_t bytes)
 {
-        char *wbuf = NULL;
+    char *wbuf = NULL;
 
-        wbuf = iov->iov_base + iov->iov_len;
-        iov->iov_len += bytes;
-        return wbuf;
+    wbuf = iov->iov_base + iov->iov_len;
+    iov->iov_len += bytes;
+    return wbuf;
 }
 
 static char *
-rbuf_alloc_write_area (rbuf_list_t *rlist, size_t bytes)
+rbuf_alloc_write_area(rbuf_list_t *rlist, size_t bytes)
 {
-        int           ret = 0;
-        struct iovec *iov = NULL;
-
-        /* check for available space in _current_ IO buffer */
-        iov = &rlist->rvec->iov;
-        if (iov->iov_len + bytes <= ROT_BUFF_ALLOC_SIZE)
-                return rbuf_adjust_write_area (iov, bytes); /* fast path */
-
-        /* not enough bytes, try next available buffers */
-        if (list_is_last (&rlist->rvec->list, &rlist->veclist)) {
-                /* OH! consumed all vector buffers */
-                GF_ASSERT (rlist->used == rlist->total);
-                ret = rlist_add_new_vec (rlist);
-                if (ret)
-                        goto error_return;
-        } else {
-                /* not the end, have available rbuf_iovec's */
-                rlist->rvec = list_next_entry (rlist->rvec, list);
-                rlist->used++;
-                rbuf_reset_rvec (rlist->rvec);
-        }
+    int ret = 0;
+    struct iovec *iov = NULL;
+
+    /* check for available space in _current_ IO buffer */
+    iov = &rlist->rvec->iov;
+    if (iov->iov_len + bytes <= ROT_BUFF_ALLOC_SIZE)
+        return rbuf_adjust_write_area(iov, bytes); /* fast path */
+
+    /* not enough bytes, try next available buffers */
+    if (list_is_last(&rlist->rvec->list, &rlist->veclist)) {
+        /* OH! consumed all vector buffers */
+        GF_ASSERT(rlist->used == rlist->total);
+        ret = rlist_add_new_vec(rlist);
+        if (ret)
+            goto error_return;
+    } else {
+        /* not the end, have available rbuf_iovec's */
+        rlist->rvec = list_next_entry(rlist->rvec, list);
+        rlist->used++;
+        rbuf_reset_rvec(rlist->rvec);
+    }
 
-        iov = &rlist->rvec->iov;
-        return rbuf_adjust_write_area (iov, bytes);
+    iov = &rlist->rvec->iov;
+    return rbuf_adjust_write_area(iov, bytes);
 
- error_return:
-        return NULL;
+error_return:
+    return NULL;
 }
 
 char *
-rbuf_reserve_write_area (rbuf_t *rbuf, size_t bytes, void **opaque)
+rbuf_reserve_write_area(rbuf_t *rbuf, size_t bytes, void **opaque)
 {
-        char        *wbuf  = NULL;
-        rbuf_list_t *rlist = NULL;
-
-        if (!rbuf || (bytes <= 0) || (bytes > ROT_BUFF_ALLOC_SIZE) || !opaque)
-                return NULL;
-
-        LOCK (&rbuf->lock);
-        {
-                rlist = rbuf_current_buffer (rbuf);
-                wbuf = rbuf_alloc_write_area (rlist, bytes);
-                if (!wbuf)
-                        goto unblock;
-                rlist->pending++;
-        }
- unblock:
-        UNLOCK (&rbuf->lock);
+    char *wbuf = NULL;
+    rbuf_list_t *rlist = NULL;
+
+    if (!rbuf || (bytes <= 0) || (bytes > ROT_BUFF_ALLOC_SIZE) || !opaque)
+        return NULL;
 
-        if (wbuf)
-                *opaque = rlist;
-        return wbuf;
+    LOCK(&rbuf->lock);
+    {
+        rlist = rbuf_current_buffer(rbuf);
+        wbuf = rbuf_alloc_write_area(rlist, bytes);
+        if (!wbuf)
+            goto unblock;
+        rlist->pending++;
+    }
+unblock:
+    UNLOCK(&rbuf->lock);
+
+    if (wbuf)
+        *opaque = rlist;
+    return wbuf;
 }
 
 static void
-rbuf_notify_waiter (rbuf_list_t *rlist)
+rbuf_notify_waiter(rbuf_list_t *rlist)
 {
-        pthread_mutex_lock (&rlist->b_lock);
-        {
-                pthread_cond_signal (&rlist->b_cond);
-        }
-        pthread_mutex_unlock (&rlist->b_lock);
+    pthread_mutex_lock(&rlist->b_lock);
+    {
+        pthread_cond_signal(&rlist->b_cond);
+    }
+    pthread_mutex_unlock(&rlist->b_lock);
 }
 
 int
-rbuf_write_complete (void *opaque)
+rbuf_write_complete(void *opaque)
 {
-        rbuf_list_t *rlist = NULL;
-        gf_boolean_t notify = _gf_false;
-
-        if (!opaque)
-                return -1;
-
-        rlist = opaque;
-
-        LOCK (&rlist->c_lock);
-        {
-                rlist->completed++;
-                /**
-                 * it's safe to test ->pending without rbuf->lock *only* if
-                 * there's a waiter as there can be no new incoming writes.
-                 */
-                if (__rlist_has_waiter (rlist)
-                                  && (rlist->completed == rlist->pending))
-                        notify = _gf_true;
-        }
-        UNLOCK (&rlist->c_lock);
+    rbuf_list_t *rlist = NULL;
+    gf_boolean_t notify = _gf_false;
+
+    if (!opaque)
+        return -1;
+
+    rlist = opaque;
+
+    LOCK(&rlist->c_lock);
+    {
+        rlist->completed++;
+        /**
+         * it's safe to test ->pending without rbuf->lock *only* if
+         * there's a waiter as there can be no new incoming writes.
+         */
+        if (__rlist_has_waiter(rlist) && (rlist->completed == rlist->pending))
+            notify = _gf_true;
+    }
+    UNLOCK(&rlist->c_lock);
 
-        if (notify)
-                rbuf_notify_waiter (rlist);
+    if (notify)
+        rbuf_notify_waiter(rlist);
 
-        return 0;
+    return 0;
 }
 
 int
-rbuf_get_buffer (rbuf_t *rbuf,
-                 void **opaque, sequence_fn *seqfn, void *mydata)
+rbuf_get_buffer(rbuf_t *rbuf, void **opaque, sequence_fn *seqfn, void *mydata)
 {
-        int retval = RBUF_CONSUMABLE;
-        rbuf_list_t *rlist = NULL;
-
-        if (!rbuf || !opaque)
-                return -1;
-
-        LOCK (&rbuf->lock);
-        {
-                rlist = rbuf_current_buffer (rbuf);
-                if (!rlist->pending) {
-                        retval = RBUF_EMPTY;
-                        goto unblock;
-                }
-
-                if (list_is_singular (&rbuf->freelist)) {
-                        /**
-                         * removal would lead to writer starvation, disallow
-                         * switching.
-                         */
-                        retval = RBUF_WOULD_STARVE;
-                        goto unblock;
-                }
-
-                list_del_init (&rlist->list);
-                if (seqfn)
-                        seqfn (rlist, mydata);
-                rbuf->current =
-                        list_first_entry (&rbuf->freelist, rbuf_list_t, list);
+    int retval = RBUF_CONSUMABLE;
+    rbuf_list_t *rlist = NULL;
+
+    if (!rbuf || !opaque)
+        return -1;
+
+    LOCK(&rbuf->lock);
+    {
+        rlist = rbuf_current_buffer(rbuf);
+        if (!rlist->pending) {
+            retval = RBUF_EMPTY;
+            goto unblock;
+        }
+
+        if (list_is_singular(&rbuf->freelist)) {
+            /**
+             * removal would lead to writer starvation, disallow
+             * switching.
+             */
+            retval = RBUF_WOULD_STARVE;
+            goto unblock;
         }
- unblock:
-        UNLOCK (&rbuf->lock);
 
-        if (retval == RBUF_CONSUMABLE)
-                *opaque = rlist; /* caller _owns_ the buffer */
+        list_del_init(&rlist->list);
+        if (seqfn)
+            seqfn(rlist, mydata);
+        rbuf->current = list_first_entry(&rbuf->freelist, rbuf_list_t, list);
+    }
+unblock:
+    UNLOCK(&rbuf->lock);
 
-        return retval;
+    if (retval == RBUF_CONSUMABLE)
+        *opaque = rlist; /* caller _owns_ the buffer */
+
+    return retval;
 }
 
 /**
@@ -412,10 +408,10 @@ rbuf_get_buffer (rbuf_t *rbuf,
  */
 
 static void
-__rbuf_wait_for_writers (rbuf_list_t *rlist)
+__rbuf_wait_for_writers(rbuf_list_t *rlist)
 {
-        while (rlist->completed != rlist->pending)
-                pthread_cond_wait (&rlist->b_cond, &rlist->b_lock);
+    while (rlist->completed != rlist->pending)
+        pthread_cond_wait(&rlist->b_cond, &rlist->b_lock);
 }
 
 #ifndef M_E
@@ -423,69 +419,69 @@ __rbuf_wait_for_writers (rbuf_list_t *rlist)
 #endif
 
 static void
-rlist_shrink_vector (rbuf_list_t *rlist)
+rlist_shrink_vector(rbuf_list_t *rlist)
 {
-        unsigned long long shrink = 0;
-
-        /**
-         * fast path: don't bother to deallocate if vectors are hardly
-         * used.
-         */
-        if (rvec_in_watermark_range (rlist))
-                return;
-
-        /**
-         * Calculate the shrink count based on total allocated vectors.
-         * Note that the calculation sticks to rlist->total irrespective
-         * of the actual usage count (rlist->used). Later, ->used could
-         * be used to apply slack to the calculation based on how much
-         * it lags from ->total. For now, let's stick to slow decay.
-         */
-        shrink = rlist->total - (rlist->total * pow (M_E, -0.2));
-
-        rlist_shrink_rvec (rlist, shrink);
-        rlist->total -= shrink;
+    unsigned long long shrink = 0;
+
+    /**
+     * fast path: don't bother to deallocate if vectors are hardly
+     * used.
+     */
+    if (rvec_in_watermark_range(rlist))
+        return;
+
+    /**
+     * Calculate the shrink count based on total allocated vectors.
+     * Note that the calculation sticks to rlist->total irrespective
+     * of the actual usage count (rlist->used). Later, ->used could
+     * be used to apply slack to the calculation based on how much
+     * it lags from ->total. For now, let's stick to slow decay.
+     */
+    shrink = rlist->total - (rlist->total * pow(M_E, -0.2));
+
+    rlist_shrink_rvec(rlist, shrink);
+    rlist->total -= shrink;
 }
 
 int
-rbuf_wait_for_completion (rbuf_t *rbuf, void *opaque,
-                          void (*fn)(rbuf_list_t *, void *), void *arg)
+rbuf_wait_for_completion(rbuf_t *rbuf, void *opaque,
+                         void (*fn)(rbuf_list_t *, void *), void *arg)
 {
-        rbuf_list_t *rlist = NULL;
+    rbuf_list_t *rlist = NULL;
 
-        if (!rbuf || !opaque)
-                return -1;
+    if (!rbuf || !opaque)
+        return -1;
 
-        rlist = opaque;
+    rlist = opaque;
 
-        pthread_mutex_lock (&rlist->b_lock);
-        {
-                rlist_mark_waiting (rlist);
-                __rbuf_wait_for_writers (rlist);
-        }
-        pthread_mutex_unlock (&rlist->b_lock);
+    pthread_mutex_lock(&rlist->b_lock);
+    {
+        rlist_mark_waiting(rlist);
+        __rbuf_wait_for_writers(rlist);
+    }
+    pthread_mutex_unlock(&rlist->b_lock);
 
-        /**
-         * from here on, no need of locking until the rlist is put
-         * back into rotation.
-         */
+    /**
+     * from here on, no need of locking until the rlist is put
+     * back into rotation.
+     */
 
-        fn (rlist, arg); /* invoke dispatcher */
+    fn(rlist, arg); /* invoke dispatcher */
 
-        rlist->awaiting = _gf_false;
-        rlist->pending = rlist->completed = 0;
+    rlist->awaiting = _gf_false;
+    rlist->pending = rlist->completed = 0;
 
-        rlist_shrink_vector (rlist);
-        rlist_reset_vector_usage (rlist);
+    rlist_shrink_vector(rlist);
+    rlist_reset_vector_usage(rlist);
 
-        rlist->rvec = list_first_entry (&rlist->veclist, rbuf_iovec_t, list);
-        rbuf_reset_rvec (rlist->rvec);
+    rlist->rvec = list_first_entry(&rlist->veclist, rbuf_iovec_t, list);
+    rbuf_reset_rvec(rlist->rvec);
 
-        LOCK (&rbuf->lock);
-        {
-                list_add_tail (&rlist->list, &rbuf->freelist);
-        }
-        UNLOCK (&rbuf->lock);
+    LOCK(&rbuf->lock);
+    {
+        list_add_tail(&rlist->list, &rbuf->freelist);
+    }
+    UNLOCK(&rbuf->lock);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/run.c b/libglusterfs/src/run.c
index c501bab9685..41275066b20 100644
--- a/libglusterfs/src/run.c
+++ b/libglusterfs/src/run.c
@@ -42,8 +42,9 @@
  *
  * $ cc -DRUN_DO_DEMO -DRUN_STANDALONE -orun run.c
  */
-#if defined(RUN_STANDALONE ) || defined(RUN_DO_DEMO)
-int close_fds_except (int *fdv, size_t count);
+#if defined(RUN_STANDALONE) || defined(RUN_DO_DEMO)
+int
+close_fds_except(int *fdv, size_t count);
 #define sys_read(f, b, c) read(f, b, c)
 #define sys_write(f, b, c) write(f, b, c)
 #define sys_close(f) close(f)
@@ -54,36 +55,37 @@ int close_fds_except (int *fdv, size_t count);
 #define gf_strdup(s) strdup(s)
 #define gf_vasprintf(p, f, va) vasprintf(p, f, va)
 #define gf_loglevel_t int
-#define gf_msg_callingfn(dom, level, errnum, msgid, fmt, args...) printf("LOG: " fmt "\n", ##args)
+#define gf_msg_callingfn(dom, level, errnum, msgid, fmt, args...)              \
+    printf("LOG: " fmt "\n", ##args)
 #define LOG_DEBUG 0
 #ifdef RUN_STANDALONE
 #include <stdbool.h>
 #include <sys/resource.h>
 int
-close_fds_except (int *fdv, size_t count)
+close_fds_except(int *fdv, size_t count)
 {
-        int    i            = 0;
-        size_t j            = 0;
-        bool   should_close = true;
-        struct rlimit rl;
-        int ret = -1;
-
-        ret = getrlimit (RLIMIT_NOFILE, &rl);
-        if (ret)
-                return ret;
-
-        for (i = 0; i < rl.rlim_cur; i++) {
-                should_close = true;
-                for (j = 0; j < count; j++) {
-                        if (i == fdv[j]) {
-                                should_close = false;
-                                break;
-                        }
-                }
-                if (should_close)
-                        sys_close (i);
+    int i = 0;
+    size_t j = 0;
+    bool should_close = true;
+    struct rlimit rl;
+    int ret = -1;
+
+    ret = getrlimit(RLIMIT_NOFILE, &rl);
+    if (ret)
+        return ret;
+
+    for (i = 0; i < rl.rlim_cur; i++) {
+        should_close = true;
+        for (j = 0; j < count; j++) {
+            if (i == fdv[j]) {
+                should_close = false;
+                break;
+            }
         }
-        return 0;
+        if (should_close)
+            sys_close(i);
+    }
+    return 0;
 }
 #endif
 #ifdef __linux__
@@ -97,470 +99,472 @@ close_fds_except (int *fdv, size_t count)
 
 #include "run.h"
 void
-runinit (runner_t *runner)
+runinit(runner_t *runner)
 {
-        int i = 0;
-
-        runner->argvlen = 64;
-        runner->argv = GF_CALLOC (runner->argvlen,
-                                  sizeof (*runner->argv),
-                                  gf_common_mt_run_argv);
-        runner->runerr = runner->argv ? 0 : errno;
-        runner->chpid = -1;
-        for (i = 0; i < 3; i++) {
-                runner->chfd[i] = -1;
-                runner->chio[i] = NULL;
-        }
+    int i = 0;
+
+    runner->argvlen = 64;
+    runner->argv = GF_CALLOC(runner->argvlen, sizeof(*runner->argv),
+                             gf_common_mt_run_argv);
+    runner->runerr = runner->argv ? 0 : errno;
+    runner->chpid = -1;
+    for (i = 0; i < 3; i++) {
+        runner->chfd[i] = -1;
+        runner->chio[i] = NULL;
+    }
 }
 
 FILE *
-runner_chio (runner_t *runner, int fd)
+runner_chio(runner_t *runner, int fd)
 {
-        GF_ASSERT (fd > 0 && fd < 3);
+    GF_ASSERT(fd > 0 && fd < 3);
 
-        if ((fd > 0) && (fd < 3))
-                return runner->chio[fd];
+    if ((fd > 0) && (fd < 3))
+        return runner->chio[fd];
 
-        return NULL;
+    return NULL;
 }
 
 static void
-runner_insert_arg (runner_t *runner, char *arg)
+runner_insert_arg(runner_t *runner, char *arg)
 {
-        int i = 0;
+    int i = 0;
 
-        GF_ASSERT (arg);
+    GF_ASSERT(arg);
 
-        if (runner->runerr)
-                return;
+    if (runner->runerr)
+        return;
 
-        for (i = 0; i < runner->argvlen; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-        }
-        GF_ASSERT (i < runner->argvlen);
-
-        if (i == runner->argvlen - 1) {
-                runner->argv = GF_REALLOC (runner->argv,
-                                           runner->argvlen * 2 * sizeof (*runner->argv));
-                if (!runner->argv) {
-                        runner->runerr = errno;
-                        return;
-                }
-                memset (/* "+" is aware of the type of its left side,
-                         * no need to multiply with type-size */
-                        runner->argv + runner->argvlen,
-                        0, runner->argvlen * sizeof (*runner->argv));
-                runner->argvlen *= 2;
-        }
+    for (i = 0; i < runner->argvlen; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+    }
+    GF_ASSERT(i < runner->argvlen);
 
-        runner->argv[i] = arg;
+    if (i == runner->argvlen - 1) {
+        runner->argv = GF_REALLOC(runner->argv,
+                                  runner->argvlen * 2 * sizeof(*runner->argv));
+        if (!runner->argv) {
+            runner->runerr = errno;
+            return;
+        }
+        memset(/* "+" is aware of the type of its left side,
+                * no need to multiply with type-size */
+               runner->argv + runner->argvlen, 0,
+               runner->argvlen * sizeof(*runner->argv));
+        runner->argvlen *= 2;
+    }
+
+    runner->argv[i] = arg;
 }
 
 void
-runner_add_arg (runner_t *runner, const char *arg)
+runner_add_arg(runner_t *runner, const char *arg)
 {
-        arg = gf_strdup (arg);
-        if (!arg) {
-                runner->runerr = errno;
-                return;
-        }
+    arg = gf_strdup(arg);
+    if (!arg) {
+        runner->runerr = errno;
+        return;
+    }
 
-        runner_insert_arg (runner, (char *)arg);
+    runner_insert_arg(runner, (char *)arg);
 }
 
 static void
-runner_va_add_args (runner_t *runner, va_list argp)
+runner_va_add_args(runner_t *runner, va_list argp)
 {
-        const char *arg;
+    const char *arg;
 
-        while ((arg = va_arg (argp, const char *)))
-                runner_add_arg (runner, arg);
+    while ((arg = va_arg(argp, const char *)))
+        runner_add_arg(runner, arg);
 }
 
 void
-runner_add_args (runner_t *runner, ...)
+runner_add_args(runner_t *runner, ...)
 {
-        va_list argp;
+    va_list argp;
 
-        va_start (argp, runner);
-        runner_va_add_args (runner, argp);
-        va_end (argp);
+    va_start(argp, runner);
+    runner_va_add_args(runner, argp);
+    va_end(argp);
 }
 
 void
-runner_argprintf (runner_t *runner, const char *format, ...)
+runner_argprintf(runner_t *runner, const char *format, ...)
 {
-        va_list argva;
-        char *arg = NULL;
-        int ret = 0;
+    va_list argva;
+    char *arg = NULL;
+    int ret = 0;
 
-        va_start (argva, format);
-        ret = gf_vasprintf (&arg, format, argva);
-        va_end (argva);
+    va_start(argva, format);
+    ret = gf_vasprintf(&arg, format, argva);
+    va_end(argva);
 
-        if (ret < 0) {
-                runner->runerr = errno;
-                return;
-        }
+    if (ret < 0) {
+        runner->runerr = errno;
+        return;
+    }
 
-        runner_insert_arg (runner, arg);
+    runner_insert_arg(runner, arg);
 }
 
 void
-runner_log (runner_t *runner, const char *dom, gf_loglevel_t lvl,
-            const char *msg)
+runner_log(runner_t *runner, const char *dom, gf_loglevel_t lvl,
+           const char *msg)
 {
-        char *buf = NULL;
-        size_t len = 0;
-        int i = 0;
-
-        if (runner->runerr)
-                return;
-
-        for (i = 0;; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-                len += (strlen (runner->argv[i]) + 1);
-        }
-
-        buf = GF_CALLOC (1, len + 1, gf_common_mt_run_logbuf);
-        if (!buf) {
-                runner->runerr = errno;
-                return;
-        }
-        for (i = 0;; i++) {
-                if (runner->argv[i] == NULL)
-                        break;
-                strcat (buf, runner->argv[i]);
-                strcat (buf, " ");
-        }
-        if (len > 0)
-                buf[len - 1] = '\0';
-
-        gf_msg_callingfn (dom, lvl, 0, LG_MSG_RUNNER_LOG, "%s: %s", msg, buf);
-
-        GF_FREE (buf);
+    char *buf = NULL;
+    size_t len = 0;
+    int i = 0;
+
+    if (runner->runerr)
+        return;
+
+    for (i = 0;; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+        len += (strlen(runner->argv[i]) + 1);
+    }
+
+    buf = GF_CALLOC(1, len + 1, gf_common_mt_run_logbuf);
+    if (!buf) {
+        runner->runerr = errno;
+        return;
+    }
+    for (i = 0;; i++) {
+        if (runner->argv[i] == NULL)
+            break;
+        strcat(buf, runner->argv[i]);
+        strcat(buf, " ");
+    }
+    if (len > 0)
+        buf[len - 1] = '\0';
+
+    gf_msg_callingfn(dom, lvl, 0, LG_MSG_RUNNER_LOG, "%s: %s", msg, buf);
+
+    GF_FREE(buf);
 }
 
 void
-runner_redir (runner_t *runner, int fd, int tgt_fd)
+runner_redir(runner_t *runner, int fd, int tgt_fd)
 {
-        GF_ASSERT (fd > 0 && fd < 3);
+    GF_ASSERT(fd > 0 && fd < 3);
 
-        if ((fd > 0) && (fd < 3))
-                runner->chfd[fd] = (tgt_fd >= 0) ? tgt_fd : -2;
+    if ((fd > 0) && (fd < 3))
+        runner->chfd[fd] = (tgt_fd >= 0) ? tgt_fd : -2;
 }
 
 int
-runner_start (runner_t *runner)
+runner_start(runner_t *runner)
 {
-        int pi[3][2] = {{-1, -1}, {-1, -1}, {-1, -1}};
-        int xpi[2];
-        int ret = 0;
-        int errno_priv = 0;
-        int i = 0;
-        sigset_t set;
-
-        if (runner->runerr) {
-                errno = runner->runerr;
-                return -1;
-        }
-
-        GF_ASSERT (runner->argv[0]);
-
-        /* set up a channel to child to communicate back
-         * possible execve(2) failures
-         */
-        ret = pipe(xpi);
-        if (ret != -1)
-                ret = fcntl (xpi[1], F_SETFD, FD_CLOEXEC);
-
-        for (i = 0; i < 3; i++) {
-                if (runner->chfd[i] != -2)
-                        continue;
-                ret = pipe (pi[i]);
-                if (ret != -1) {
-                        runner->chio[i] = fdopen (pi[i][i ? 0 : 1], i ? "r" : "w");
-                        if (!runner->chio[i])
-                                ret = -1;
-                }
+    int pi[3][2] = {{-1, -1}, {-1, -1}, {-1, -1}};
+    int xpi[2];
+    int ret = 0;
+    int errno_priv = 0;
+    int i = 0;
+    sigset_t set;
+
+    if (runner->runerr) {
+        errno = runner->runerr;
+        return -1;
+    }
+
+    GF_ASSERT(runner->argv[0]);
+
+    /* set up a channel to child to communicate back
+     * possible execve(2) failures
+     */
+    ret = pipe(xpi);
+    if (ret != -1)
+        ret = fcntl(xpi[1], F_SETFD, FD_CLOEXEC);
+
+    for (i = 0; i < 3; i++) {
+        if (runner->chfd[i] != -2)
+            continue;
+        ret = pipe(pi[i]);
+        if (ret != -1) {
+            runner->chio[i] = fdopen(pi[i][i ? 0 : 1], i ? "r" : "w");
+            if (!runner->chio[i])
+                ret = -1;
         }
+    }
 
-        if (ret != -1)
-                runner->chpid = fork ();
-        switch (runner->chpid) {
+    if (ret != -1)
+        runner->chpid = fork();
+    switch (runner->chpid) {
         case -1:
-                errno_priv = errno;
-                sys_close (xpi[0]);
-                sys_close (xpi[1]);
-                for (i = 0; i < 3; i++) {
-                        sys_close (pi[i][0]);
-                        sys_close (pi[i][1]);
-                }
-                errno = errno_priv;
-                return -1;
+            errno_priv = errno;
+            sys_close(xpi[0]);
+            sys_close(xpi[1]);
+            for (i = 0; i < 3; i++) {
+                sys_close(pi[i][0]);
+                sys_close(pi[i][1]);
+            }
+            errno = errno_priv;
+            return -1;
         case 0:
-                for (i = 0; i < 3; i++)
-                        sys_close (pi[i][i ? 0 : 1]);
-                sys_close (xpi[0]);
-                ret = 0;
-
-                for (i = 0; i < 3; i++) {
-                        if (ret == -1)
-                                break;
-                        switch (runner->chfd[i]) {
-                        case -1:
-                                /* no redir */
-                                break;
-                        case -2:
-                                /* redir to pipe */
-                                ret = dup2 (pi[i][i ? 1 : 0], i);
-                                break;
-                        default:
-                                /* redir to file */
-                                ret = dup2 (runner->chfd[i], i);
-                        }
-                }
-
-                if (ret != -1 ) {
-                        int fdv[4] = {0, 1, 2, xpi[1]};
-
-                        ret = close_fds_except(fdv, sizeof (fdv) / sizeof (*fdv));
-                }
-
-                if (ret != -1) {
-                        /* save child from inheriting our signal handling */
-                        sigemptyset (&set);
-                        sigprocmask (SIG_SETMASK, &set, NULL);
-
-                        execvp (runner->argv[0], runner->argv);
-                }
-                ret = sys_write (xpi[1], &errno, sizeof (errno));
-                _exit (1);
-        }
-
-        errno_priv = errno;
-        for (i = 0; i < 3; i++)
-                sys_close (pi[i][i ? 1 : 0]);
-        sys_close (xpi[1]);
-        if (ret == -1) {
-                for (i = 0; i < 3; i++) {
-                        if (runner->chio[i]) {
-                                fclose (runner->chio[i]);
-                                runner->chio[i] = NULL;
-                        }
+            for (i = 0; i < 3; i++)
+                sys_close(pi[i][i ? 0 : 1]);
+            sys_close(xpi[0]);
+            ret = 0;
+
+            for (i = 0; i < 3; i++) {
+                if (ret == -1)
+                    break;
+                switch (runner->chfd[i]) {
+                    case -1:
+                        /* no redir */
+                        break;
+                    case -2:
+                        /* redir to pipe */
+                        ret = dup2(pi[i][i ? 1 : 0], i);
+                        break;
+                    default:
+                        /* redir to file */
+                        ret = dup2(runner->chfd[i], i);
                 }
-        } else {
-                ret = sys_read (xpi[0], (char *)&errno_priv, sizeof (errno_priv));
-                sys_close (xpi[0]);
-                if (ret <= 0)
-                        return 0;
-                GF_ASSERT (ret == sizeof (errno_priv));
+            }
+
+            if (ret != -1) {
+                int fdv[4] = {0, 1, 2, xpi[1]};
+
+                ret = close_fds_except(fdv, sizeof(fdv) / sizeof(*fdv));
+            }
+
+            if (ret != -1) {
+                /* save child from inheriting our signal handling */
+                sigemptyset(&set);
+                sigprocmask(SIG_SETMASK, &set, NULL);
+
+                execvp(runner->argv[0], runner->argv);
+            }
+            ret = sys_write(xpi[1], &errno, sizeof(errno));
+            _exit(1);
+    }
+
+    errno_priv = errno;
+    for (i = 0; i < 3; i++)
+        sys_close(pi[i][i ? 1 : 0]);
+    sys_close(xpi[1]);
+    if (ret == -1) {
+        for (i = 0; i < 3; i++) {
+            if (runner->chio[i]) {
+                fclose(runner->chio[i]);
+                runner->chio[i] = NULL;
+            }
         }
-        errno = errno_priv;
-        return -1;
+    } else {
+        ret = sys_read(xpi[0], (char *)&errno_priv, sizeof(errno_priv));
+        sys_close(xpi[0]);
+        if (ret <= 0)
+            return 0;
+        GF_ASSERT(ret == sizeof(errno_priv));
+    }
+    errno = errno_priv;
+    return -1;
 }
 
 int
-runner_end_reuse (runner_t *runner)
+runner_end_reuse(runner_t *runner)
 {
-        int i = 0;
-        int ret = 1;
-        int chstat = 0;
-
-        if (runner->chpid > 0) {
-                if (waitpid (runner->chpid, &chstat, 0) == runner->chpid) {
-                        if (WIFEXITED(chstat)) {
-                                ret = WEXITSTATUS(chstat);
-                        } else {
-                                ret = chstat;
-                        }
-                }
+    int i = 0;
+    int ret = 1;
+    int chstat = 0;
+
+    if (runner->chpid > 0) {
+        if (waitpid(runner->chpid, &chstat, 0) == runner->chpid) {
+            if (WIFEXITED(chstat)) {
+                ret = WEXITSTATUS(chstat);
+            } else {
+                ret = chstat;
+            }
         }
+    }
 
-        for (i = 0; i < 3; i++) {
-                if (runner->chio[i]) {
-                        fclose (runner->chio[i]);
-                        runner->chio[i] = NULL;
-                }
+    for (i = 0; i < 3; i++) {
+        if (runner->chio[i]) {
+            fclose(runner->chio[i]);
+            runner->chio[i] = NULL;
         }
+    }
 
-        return -ret;
+    return -ret;
 }
 
 int
-runner_end (runner_t *runner)
+runner_end(runner_t *runner)
 {
-        int i = 0;
-        int ret = -1;
-        char **p = NULL;
+    int i = 0;
+    int ret = -1;
+    char **p = NULL;
 
-        ret = runner_end_reuse (runner);
+    ret = runner_end_reuse(runner);
 
-        if (runner->argv) {
-                for (p = runner->argv; *p; p++)
-                        GF_FREE (*p);
-                GF_FREE (runner->argv);
-        }
-        for (i = 0; i < 3; i++)
-                sys_close (runner->chfd[i]);
+    if (runner->argv) {
+        for (p = runner->argv; *p; p++)
+            GF_FREE(*p);
+        GF_FREE(runner->argv);
+    }
+    for (i = 0; i < 3; i++)
+        sys_close(runner->chfd[i]);
 
-        return ret;
+    return ret;
 }
 
 static int
-runner_run_generic (runner_t *runner, int (*rfin)(runner_t *runner))
+runner_run_generic(runner_t *runner, int (*rfin)(runner_t *runner))
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = runner_start (runner);
-        if (ret)
-                goto out;
-        ret = rfin (runner);
+    ret = runner_start(runner);
+    if (ret)
+        goto out;
+    ret = rfin(runner);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-runner_run (runner_t *runner)
+runner_run(runner_t *runner)
 {
-        return runner_run_generic (runner, runner_end);
+    return runner_run_generic(runner, runner_end);
 }
 
-
 int
-runner_run_nowait (runner_t *runner)
+runner_run_nowait(runner_t *runner)
 {
-	int pid;
+    int pid;
 
-	pid = fork ();
+    pid = fork();
 
-	if (!pid) {
-		setsid ();
-		_exit (runner_start (runner));
-	}
+    if (!pid) {
+        setsid();
+        _exit(runner_start(runner));
+    }
 
-	if (pid > 0)
-		runner->chpid = pid;
-	return runner_end (runner);
+    if (pid > 0)
+        runner->chpid = pid;
+    return runner_end(runner);
 }
 
-
 int
-runner_run_reuse (runner_t *runner)
+runner_run_reuse(runner_t *runner)
 {
-        return runner_run_generic (runner, runner_end_reuse);
+    return runner_run_generic(runner, runner_end_reuse);
 }
 
 int
-runcmd (const char *arg, ...)
+runcmd(const char *arg, ...)
 {
-        runner_t runner;
-        va_list argp;
+    runner_t runner;
+    va_list argp;
 
-        runinit (&runner);
-        /* ISO C requires a named argument before '...' */
-        runner_add_arg (&runner, arg);
+    runinit(&runner);
+    /* ISO C requires a named argument before '...' */
+    runner_add_arg(&runner, arg);
 
-        va_start (argp, arg);
-        runner_va_add_args (&runner, argp);
-        va_end (argp);
+    va_start(argp, arg);
+    runner_va_add_args(&runner, argp);
+    va_end(argp);
 
-        return runner_run (&runner);
+    return runner_run(&runner);
 }
 
 #ifdef RUN_DO_DEMO
 static void
-TBANNER (const char *txt)
+TBANNER(const char *txt)
 {
-        printf("######\n### demoing %s\n", txt);
+    printf("######\n### demoing %s\n", txt);
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        runner_t runner;
-        char buf[80];
-        char *wdbuf;;
-        int ret;
-        int fd;
-        long pathmax = pathconf ("/", _PC_PATH_MAX);
-        struct timeval tv = {0,};
-        struct timeval *tvp = NULL;
-        char *tfile;
-
-        wdbuf = malloc (pathmax);
-        assert (wdbuf);
-        getcwd (wdbuf, pathmax);
-
-        TBANNER ("basic functionality: running \"echo a b\"");
-        runcmd ("echo", "a", "b", NULL);
-
-        TBANNER ("argv extension: running \"echo 1 2 ... 100\"");
-        runcmd ("echo", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
-                "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
-                "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
-                "31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
-                "41", "42", "43", "44", "45", "46", "47", "48", "49", "50",
-                "51", "52", "53", "54", "55", "56", "57", "58", "59", "60",
-                "61", "62", "63", "64", "65", "66", "67", "68", "69", "70",
-                "71", "72", "73", "74", "75", "76", "77", "78", "79", "80",
-                "81", "82", "83", "84", "85", "86", "87", "88", "89", "90",
-                "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", NULL);
-
-        TBANNER ("add_args, argprintf, log, and popen-style functionality:\n"
-                 "    running a multiline echo command, emit a log about it,\n"
-                 "    redirect it to a pipe, read output lines\n"
-                 "    and print them prefixed with \"got: \"");
-        runinit (&runner);
-        runner_add_args (&runner, "echo", "pid:", NULL);
-        runner_argprintf (&runner, "%d\n", getpid());
-        runner_add_arg (&runner, "wd:");
-        runner_add_arg (&runner, wdbuf);
-        runner_redir (&runner, 1, RUN_PIPE);
-        runner_start (&runner);
-        runner_log (&runner, "(x)", LOG_DEBUG, "starting program");
-        while (fgets (buf, sizeof(buf), runner_chio (&runner, 1)))
-                printf ("got: %s", buf);
-        runner_end (&runner);
-
-        TBANNER ("execve error reporting: running a non-existent command");
-        ret = runcmd ("bafflavvitty", NULL);
-        printf ("%d %d [%s]\n", ret, errno, strerror (errno));
-
-        TBANNER ("output redirection: running \"echo foo\" redirected "
-                 "to a temp file");
-        tfile = strdup ("/tmp/foofXXXXXX");
-        assert (tfile);
-        fd = mkstemp (tfile);
-        assert (fd != -1);
-        printf ("redirecting to %s\n", tfile);
-        runinit (&runner);
-        runner_add_args (&runner, "echo", "foo", NULL);
-        runner_redir (&runner, 1, fd);
-        ret = runner_run (&runner);
-        printf ("runner_run returned: %d", ret);
-        if (ret != 0)
-                printf (", with errno %d [%s]", errno, strerror (errno));
-        putchar ('\n');
-
-        /* sleep for seconds given as argument (0 means forever)
-         * to allow investigation of post-execution state to
-         * cbeck for resource leaks (eg. zombies).
-         */
-        if (argc > 1) {
-                tv.tv_sec = strtoul (argv[1], NULL, 10);
-                printf ("### %s", "sleeping for");
-                if (tv.tv_sec > 0) {
-                        printf (" %d seconds\n", tv.tv_sec);
-                        tvp = &tv;
-                } else
-                        printf ("%s\n", "ever");
-                select (0, 0, 0, 0, tvp);
-        }
-
-        return 0;
+    runner_t runner;
+    char buf[80];
+    char *wdbuf;
+    ;
+    int ret;
+    int fd;
+    long pathmax = pathconf("/", _PC_PATH_MAX);
+    struct timeval tv = {
+        0,
+    };
+    struct timeval *tvp = NULL;
+    char *tfile;
+
+    wdbuf = malloc(pathmax);
+    assert(wdbuf);
+    getcwd(wdbuf, pathmax);
+
+    TBANNER("basic functionality: running \"echo a b\"");
+    runcmd("echo", "a", "b", NULL);
+
+    TBANNER("argv extension: running \"echo 1 2 ... 100\"");
+    runcmd("echo", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
+           "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
+           "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33",
+           "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44",
+           "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55",
+           "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66",
+           "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77",
+           "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88",
+           "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
+           "100", NULL);
+
+    TBANNER(
+        "add_args, argprintf, log, and popen-style functionality:\n"
+        "    running a multiline echo command, emit a log about it,\n"
+        "    redirect it to a pipe, read output lines\n"
+        "    and print them prefixed with \"got: \"");
+    runinit(&runner);
+    runner_add_args(&runner, "echo", "pid:", NULL);
+    runner_argprintf(&runner, "%d\n", getpid());
+    runner_add_arg(&runner, "wd:");
+    runner_add_arg(&runner, wdbuf);
+    runner_redir(&runner, 1, RUN_PIPE);
+    runner_start(&runner);
+    runner_log(&runner, "(x)", LOG_DEBUG, "starting program");
+    while (fgets(buf, sizeof(buf), runner_chio(&runner, 1)))
+        printf("got: %s", buf);
+    runner_end(&runner);
+
+    TBANNER("execve error reporting: running a non-existent command");
+    ret = runcmd("bafflavvitty", NULL);
+    printf("%d %d [%s]\n", ret, errno, strerror(errno));
+
+    TBANNER(
+        "output redirection: running \"echo foo\" redirected "
+        "to a temp file");
+    tfile = strdup("/tmp/foofXXXXXX");
+    assert(tfile);
+    fd = mkstemp(tfile);
+    assert(fd != -1);
+    printf("redirecting to %s\n", tfile);
+    runinit(&runner);
+    runner_add_args(&runner, "echo", "foo", NULL);
+    runner_redir(&runner, 1, fd);
+    ret = runner_run(&runner);
+    printf("runner_run returned: %d", ret);
+    if (ret != 0)
+        printf(", with errno %d [%s]", errno, strerror(errno));
+    putchar('\n');
+
+    /* sleep for seconds given as argument (0 means forever)
+     * to allow investigation of post-execution state to
+     * cbeck for resource leaks (eg. zombies).
+     */
+    if (argc > 1) {
+        tv.tv_sec = strtoul(argv[1], NULL, 10);
+        printf("### %s", "sleeping for");
+        if (tv.tv_sec > 0) {
+            printf(" %d seconds\n", tv.tv_sec);
+            tvp = &tv;
+        } else
+            printf("%s\n", "ever");
+        select(0, 0, 0, 0, tvp);
+    }
+
+    return 0;
 }
 #endif
diff --git a/libglusterfs/src/stack.c b/libglusterfs/src/stack.c
index 037f565aba3..7196c18418e 100644
--- a/libglusterfs/src/stack.c
+++ b/libglusterfs/src/stack.c
@@ -13,433 +13,433 @@
 #include "libglusterfs-messages.h"
 
 call_frame_t *
-create_frame (xlator_t *xl, call_pool_t *pool)
+create_frame(xlator_t *xl, call_pool_t *pool)
 {
-        call_stack_t    *stack = NULL;
-        call_frame_t    *frame = NULL;
-
-        if (!xl || !pool) {
-                return NULL;
-        }
-
-        stack = mem_get0 (pool->stack_mem_pool);
-        if (!stack)
-                return NULL;
-
-        INIT_LIST_HEAD (&stack->myframes);
-
-        frame = mem_get0 (pool->frame_mem_pool);
-        if (!frame) {
-                mem_put (stack);
-                return NULL;
-        }
-
-        frame->root = stack;
-        frame->this = xl;
-        LOCK_INIT (&frame->lock);
-        INIT_LIST_HEAD (&frame->frames);
-        list_add (&frame->frames, &stack->myframes);
-
-        stack->pool = pool;
-        stack->ctx = xl->ctx;
-
-        if (frame->root->ctx->measure_latency) {
-                timespec_now (&stack->tv);
-                memcpy (&frame->begin, &stack->tv,
-                        sizeof (stack->tv));
-        }
-
-        LOCK (&pool->lock);
-        {
-                list_add (&stack->all_frames, &pool->all_frames);
-                pool->cnt++;
-        }
-        UNLOCK (&pool->lock);
-        GF_ATOMIC_INC (pool->total_count);
-
-        LOCK_INIT (&stack->stack_lock);
-
-        return frame;
+    call_stack_t *stack = NULL;
+    call_frame_t *frame = NULL;
+
+    if (!xl || !pool) {
+        return NULL;
+    }
+
+    stack = mem_get0(pool->stack_mem_pool);
+    if (!stack)
+        return NULL;
+
+    INIT_LIST_HEAD(&stack->myframes);
+
+    frame = mem_get0(pool->frame_mem_pool);
+    if (!frame) {
+        mem_put(stack);
+        return NULL;
+    }
+
+    frame->root = stack;
+    frame->this = xl;
+    LOCK_INIT(&frame->lock);
+    INIT_LIST_HEAD(&frame->frames);
+    list_add(&frame->frames, &stack->myframes);
+
+    stack->pool = pool;
+    stack->ctx = xl->ctx;
+
+    if (frame->root->ctx->measure_latency) {
+        timespec_now(&stack->tv);
+        memcpy(&frame->begin, &stack->tv, sizeof(stack->tv));
+    }
+
+    LOCK(&pool->lock);
+    {
+        list_add(&stack->all_frames, &pool->all_frames);
+        pool->cnt++;
+    }
+    UNLOCK(&pool->lock);
+    GF_ATOMIC_INC(pool->total_count);
+
+    LOCK_INIT(&stack->stack_lock);
+
+    return frame;
 }
 
 void
-call_stack_set_groups (call_stack_t *stack, int ngrps, gid_t **groupbuf_p)
+call_stack_set_groups(call_stack_t *stack, int ngrps, gid_t **groupbuf_p)
 {
-        /* We take the ownership of the passed group buffer. */
-
-        if (ngrps <= SMALL_GROUP_COUNT) {
-                memcpy (stack->groups_small, *groupbuf_p,
-                        sizeof (gid_t) * ngrps);
-                stack->groups = stack->groups_small;
-                GF_FREE (*groupbuf_p);
-        } else {
-                stack->groups_large = *groupbuf_p;
-                stack->groups = stack->groups_large;
-        }
-
-        stack->ngrps = ngrps;
-        /* Set a canary. */
-        *groupbuf_p = (void *)0xdeadf00d;
+    /* We take the ownership of the passed group buffer. */
+
+    if (ngrps <= SMALL_GROUP_COUNT) {
+        memcpy(stack->groups_small, *groupbuf_p, sizeof(gid_t) * ngrps);
+        stack->groups = stack->groups_small;
+        GF_FREE(*groupbuf_p);
+    } else {
+        stack->groups_large = *groupbuf_p;
+        stack->groups = stack->groups_large;
+    }
+
+    stack->ngrps = ngrps;
+    /* Set a canary. */
+    *groupbuf_p = (void *)0xdeadf00d;
 }
 
 void
-gf_proc_dump_call_frame (call_frame_t *call_frame, const char *key_buf,...)
+gf_proc_dump_call_frame(call_frame_t *call_frame, const char *key_buf, ...)
 {
+    char prefix[GF_DUMP_MAX_BUF_LEN];
+    va_list ap;
+    call_frame_t my_frame;
+    int ret = -1;
+    char timestr[256] = {
+        0,
+    };
+    int len;
+
+    if (!call_frame)
+        return;
 
-        char prefix[GF_DUMP_MAX_BUF_LEN];
-        va_list ap;
-        call_frame_t my_frame;
-        int  ret = -1;
-        char timestr[256] = {0,};
-        int len;
+    GF_ASSERT(key_buf);
 
-        if (!call_frame)
-                return;
+    va_start(ap, key_buf);
+    vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
+    va_end(ap);
 
-        GF_ASSERT (key_buf);
+    ret = TRY_LOCK(&call_frame->lock);
+    if (ret)
+        goto out;
 
-        va_start(ap, key_buf);
-        vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
-        va_end(ap);
+    memcpy(&my_frame, call_frame, sizeof(my_frame));
+    UNLOCK(&call_frame->lock);
 
-        ret = TRY_LOCK(&call_frame->lock);
-        if (ret)
-                goto out;
-
-        memcpy(&my_frame, call_frame, sizeof(my_frame));
-        UNLOCK(&call_frame->lock);
-
-        if (my_frame.root->ctx->measure_latency) {
-                gf_time_fmt (timestr, sizeof (timestr), my_frame.begin.tv_sec,
-                             gf_timefmt_FT);
-                len = strlen (timestr);
-                snprintf (timestr + len, sizeof (timestr) - len,
-                          ".%"GF_PRI_SNSECONDS, my_frame.begin.tv_nsec);
-                gf_proc_dump_write("frame-creation-time", "%s", timestr);
-                gf_proc_dump_write("timings", "%ld.%"GF_PRI_SNSECONDS
-                                   " -> %ld.%"GF_PRI_SNSECONDS,
-                                   my_frame.begin.tv_sec,
-                                   my_frame.begin.tv_nsec,
-                                   my_frame.end.tv_sec,
-                                   my_frame.end.tv_nsec);
-        }
-
-        gf_proc_dump_write("frame", "%p", call_frame);
-        gf_proc_dump_write("ref_count", "%d", my_frame.ref_count);
-        gf_proc_dump_write("translator", "%s", my_frame.this->name);
-        gf_proc_dump_write("complete", "%d", my_frame.complete);
-
-        if (my_frame.parent)
-                gf_proc_dump_write("parent", "%s", my_frame.parent->this->name);
-
-        if (my_frame.wind_from)
-                gf_proc_dump_write("wind_from", "%s", my_frame.wind_from);
-
-        if (my_frame.wind_to)
-                gf_proc_dump_write("wind_to", "%s", my_frame.wind_to);
-
-        if (my_frame.unwind_from)
-                gf_proc_dump_write("unwind_from", "%s", my_frame.unwind_from);
-
-        if (my_frame.unwind_to)
-                gf_proc_dump_write("unwind_to", "%s", my_frame.unwind_to);
-
-        ret = 0;
+    if (my_frame.root->ctx->measure_latency) {
+        gf_time_fmt(timestr, sizeof(timestr), my_frame.begin.tv_sec,
+                    gf_timefmt_FT);
+        len = strlen(timestr);
+        snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SNSECONDS,
+                 my_frame.begin.tv_nsec);
+        gf_proc_dump_write("frame-creation-time", "%s", timestr);
+        gf_proc_dump_write(
+            "timings", "%ld.%" GF_PRI_SNSECONDS " -> %ld.%" GF_PRI_SNSECONDS,
+            my_frame.begin.tv_sec, my_frame.begin.tv_nsec, my_frame.end.tv_sec,
+            my_frame.end.tv_nsec);
+    }
+
+    gf_proc_dump_write("frame", "%p", call_frame);
+    gf_proc_dump_write("ref_count", "%d", my_frame.ref_count);
+    gf_proc_dump_write("translator", "%s", my_frame.this->name);
+    gf_proc_dump_write("complete", "%d", my_frame.complete);
+
+    if (my_frame.parent)
+        gf_proc_dump_write("parent", "%s", my_frame.parent->this->name);
+
+    if (my_frame.wind_from)
+        gf_proc_dump_write("wind_from", "%s", my_frame.wind_from);
+
+    if (my_frame.wind_to)
+        gf_proc_dump_write("wind_to", "%s", my_frame.wind_to);
+
+    if (my_frame.unwind_from)
+        gf_proc_dump_write("unwind_from", "%s", my_frame.unwind_from);
+
+    if (my_frame.unwind_to)
+        gf_proc_dump_write("unwind_to", "%s", my_frame.unwind_to);
+
+    ret = 0;
 out:
-        if (ret) {
-                gf_proc_dump_write("Unable to dump the frame information",
-                                   "(Lock acquisition failed) %p", my_frame);
-                return;
-        }
+    if (ret) {
+        gf_proc_dump_write("Unable to dump the frame information",
+                           "(Lock acquisition failed) %p", my_frame);
+        return;
+    }
 }
 
-
 void
-gf_proc_dump_call_stack (call_stack_t *call_stack, const char *key_buf,...)
+gf_proc_dump_call_stack(call_stack_t *call_stack, const char *key_buf, ...)
 {
-        char prefix[GF_DUMP_MAX_BUF_LEN];
-        va_list ap;
-        call_frame_t *trav;
-        int32_t i = 1, cnt = 0;
-        char timestr[256] = {0,};
-        int len;
-
-        if (!call_stack)
-                return;
-
-        GF_ASSERT (key_buf);
-
-        va_start(ap, key_buf);
-        vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
-        va_end(ap);
-
-        cnt = call_frames_count (call_stack);
-        gf_time_fmt (timestr, sizeof (timestr), call_stack->tv.tv_sec,
-                     gf_timefmt_FT);
-        len = strlen (timestr);
-        snprintf (timestr + len, sizeof (timestr) - len,
-                  ".%"GF_PRI_SNSECONDS, call_stack->tv.tv_nsec);
-        gf_proc_dump_write("callstack-creation-time", "%s", timestr);
-
-        gf_proc_dump_write("stack", "%p", call_stack);
-        gf_proc_dump_write("uid", "%d", call_stack->uid);
-        gf_proc_dump_write("gid", "%d", call_stack->gid);
-        gf_proc_dump_write("pid", "%d", call_stack->pid);
-        gf_proc_dump_write("unique", "%Ld", call_stack->unique);
-        gf_proc_dump_write("lk-owner", "%s", lkowner_utoa (&call_stack->lk_owner));
-        gf_proc_dump_write("ctime", "%lld.%"GF_PRI_SNSECONDS,
-                           call_stack->tv.tv_sec, call_stack->tv.tv_nsec);
-
-        if (call_stack->type == GF_OP_TYPE_FOP)
-                gf_proc_dump_write("op", "%s",
-                                   (char *)gf_fop_list[call_stack->op]);
-        else
-                gf_proc_dump_write("op", "stack");
-
-        gf_proc_dump_write("type", "%d", call_stack->type);
-        gf_proc_dump_write("cnt", "%d", cnt);
-
-        list_for_each_entry (trav, &call_stack->myframes, frames) {
-                gf_proc_dump_add_section("%s.frame.%d", prefix, i);
-                gf_proc_dump_call_frame(trav, "%s.frame.%d", prefix, i);
-                i++;
-        }
+    char prefix[GF_DUMP_MAX_BUF_LEN];
+    va_list ap;
+    call_frame_t *trav;
+    int32_t i = 1, cnt = 0;
+    char timestr[256] = {
+        0,
+    };
+    int len;
+
+    if (!call_stack)
+        return;
+
+    GF_ASSERT(key_buf);
+
+    va_start(ap, key_buf);
+    vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN, key_buf, ap);
+    va_end(ap);
+
+    cnt = call_frames_count(call_stack);
+    gf_time_fmt(timestr, sizeof(timestr), call_stack->tv.tv_sec, gf_timefmt_FT);
+    len = strlen(timestr);
+    snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SNSECONDS,
+             call_stack->tv.tv_nsec);
+    gf_proc_dump_write("callstack-creation-time", "%s", timestr);
+
+    gf_proc_dump_write("stack", "%p", call_stack);
+    gf_proc_dump_write("uid", "%d", call_stack->uid);
+    gf_proc_dump_write("gid", "%d", call_stack->gid);
+    gf_proc_dump_write("pid", "%d", call_stack->pid);
+    gf_proc_dump_write("unique", "%Ld", call_stack->unique);
+    gf_proc_dump_write("lk-owner", "%s", lkowner_utoa(&call_stack->lk_owner));
+    gf_proc_dump_write("ctime", "%lld.%" GF_PRI_SNSECONDS,
+                       call_stack->tv.tv_sec, call_stack->tv.tv_nsec);
+
+    if (call_stack->type == GF_OP_TYPE_FOP)
+        gf_proc_dump_write("op", "%s", (char *)gf_fop_list[call_stack->op]);
+    else
+        gf_proc_dump_write("op", "stack");
+
+    gf_proc_dump_write("type", "%d", call_stack->type);
+    gf_proc_dump_write("cnt", "%d", cnt);
+
+    list_for_each_entry(trav, &call_stack->myframes, frames)
+    {
+        gf_proc_dump_add_section("%s.frame.%d", prefix, i);
+        gf_proc_dump_call_frame(trav, "%s.frame.%d", prefix, i);
+        i++;
+    }
 }
 
 void
-gf_proc_dump_pending_frames (call_pool_t *call_pool)
+gf_proc_dump_pending_frames(call_pool_t *call_pool)
 {
+    call_stack_t *trav = NULL;
+    int i = 1;
+    int ret = -1;
+    gf_boolean_t section_added = _gf_false;
 
-        call_stack_t     *trav = NULL;
-        int              i = 1;
-        int              ret = -1;
-        gf_boolean_t     section_added = _gf_false;
-
-        if (!call_pool)
-                return;
-
-        ret = TRY_LOCK (&(call_pool->lock));
-        if (ret)
-                goto out;
-
+    if (!call_pool)
+        return;
 
-        gf_proc_dump_add_section("global.callpool");
-        section_added = _gf_true;
-        gf_proc_dump_write("callpool_address","%p", call_pool);
-        gf_proc_dump_write("callpool.cnt","%d", call_pool->cnt);
+    ret = TRY_LOCK(&(call_pool->lock));
+    if (ret)
+        goto out;
 
+    gf_proc_dump_add_section("global.callpool");
+    section_added = _gf_true;
+    gf_proc_dump_write("callpool_address", "%p", call_pool);
+    gf_proc_dump_write("callpool.cnt", "%d", call_pool->cnt);
 
-        list_for_each_entry (trav, &call_pool->all_frames, all_frames) {
-                gf_proc_dump_add_section("global.callpool.stack.%d",i);
-                gf_proc_dump_call_stack(trav, "global.callpool.stack.%d", i);
-                i++;
-        }
-        UNLOCK (&(call_pool->lock));
+    list_for_each_entry(trav, &call_pool->all_frames, all_frames)
+    {
+        gf_proc_dump_add_section("global.callpool.stack.%d", i);
+        gf_proc_dump_call_stack(trav, "global.callpool.stack.%d", i);
+        i++;
+    }
+    UNLOCK(&(call_pool->lock));
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                if (_gf_false == section_added)
-                        gf_proc_dump_add_section("global.callpool");
-                gf_proc_dump_write("Unable to dump the callpool",
-                                   "(Lock acquisition failed) %p",
-                                   call_pool);
-        }
-        return;
+    if (ret) {
+        if (_gf_false == section_added)
+            gf_proc_dump_add_section("global.callpool");
+        gf_proc_dump_write("Unable to dump the callpool",
+                           "(Lock acquisition failed) %p", call_pool);
+    }
+    return;
 }
 
 void
-gf_proc_dump_call_frame_to_dict (call_frame_t *call_frame,
-                                 char *prefix, dict_t *dict)
+gf_proc_dump_call_frame_to_dict(call_frame_t *call_frame, char *prefix,
+                                dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        char            msg[GF_DUMP_MAX_BUF_LEN] = {0,};
-        call_frame_t    tmp_frame = {0,};
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    char msg[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    call_frame_t tmp_frame = {
+        0,
+    };
+
+    if (!call_frame || !dict)
+        return;
+
+    ret = TRY_LOCK(&call_frame->lock);
+    if (ret)
+        return;
+    memcpy(&tmp_frame, call_frame, sizeof(tmp_frame));
+    UNLOCK(&call_frame->lock);
+
+    snprintf(key, sizeof(key), "%s.refcount", prefix);
+    ret = dict_set_int32(dict, key, tmp_frame.ref_count);
+    if (ret)
+        return;
+
+    snprintf(key, sizeof(key), "%s.translator", prefix);
+    ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.this->name));
+    if (ret)
+        return;
+
+    snprintf(key, sizeof(key), "%s.complete", prefix);
+    ret = dict_set_int32(dict, key, tmp_frame.complete);
+    if (ret)
+        return;
 
-        if (!call_frame || !dict)
-                return;
+    if (tmp_frame.root->ctx->measure_latency) {
+        snprintf(key, sizeof(key), "%s.timings", prefix);
+        snprintf(msg, sizeof(msg),
+                 "%ld.%" GF_PRI_SNSECONDS " -> %ld.%" GF_PRI_SNSECONDS,
+                 tmp_frame.begin.tv_sec, tmp_frame.begin.tv_nsec,
+                 tmp_frame.end.tv_sec, tmp_frame.end.tv_nsec);
+        ret = dict_set_str(dict, key, msg);
+        if (ret)
+            return;
+    }
 
-        ret = TRY_LOCK (&call_frame->lock);
+    if (tmp_frame.parent) {
+        snprintf(key, sizeof(key), "%s.parent", prefix);
+        ret = dict_set_dynstr(dict, key,
+                              gf_strdup(tmp_frame.parent->this->name));
         if (ret)
-                return;
-        memcpy (&tmp_frame, call_frame, sizeof (tmp_frame));
-        UNLOCK (&call_frame->lock);
+            return;
+    }
 
-        snprintf (key, sizeof (key), "%s.refcount", prefix);
-        ret = dict_set_int32 (dict, key, tmp_frame.ref_count);
+    if (tmp_frame.wind_from) {
+        snprintf(key, sizeof(key), "%s.windfrom", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.wind_from));
         if (ret)
-                return;
+            return;
+    }
 
-        snprintf (key, sizeof (key), "%s.translator", prefix);
-        ret = dict_set_dynstr (dict, key, gf_strdup (tmp_frame.this->name));
+    if (tmp_frame.wind_to) {
+        snprintf(key, sizeof(key), "%s.windto", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.wind_to));
         if (ret)
-                return;
+            return;
+    }
 
-        snprintf (key, sizeof (key), "%s.complete", prefix);
-        ret = dict_set_int32 (dict, key, tmp_frame.complete);
+    if (tmp_frame.unwind_from) {
+        snprintf(key, sizeof(key), "%s.unwindfrom", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.unwind_from));
         if (ret)
-                return;
-
-        if (tmp_frame.root->ctx->measure_latency) {
-                snprintf (key, sizeof (key), "%s.timings", prefix);
-                snprintf (msg, sizeof (msg), "%ld.%"GF_PRI_SNSECONDS
-                          " -> %ld.%"GF_PRI_SNSECONDS,
-                          tmp_frame.begin.tv_sec, tmp_frame.begin.tv_nsec,
-                          tmp_frame.end.tv_sec, tmp_frame.end.tv_nsec);
-                ret = dict_set_str (dict, key, msg);
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.parent) {
-                snprintf (key, sizeof (key), "%s.parent", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                    gf_strdup (tmp_frame.parent->this->name));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.wind_from) {
-                snprintf (key, sizeof (key), "%s.windfrom", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.wind_from));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.wind_to) {
-                snprintf (key, sizeof (key), "%s.windto", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.wind_to));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.unwind_from) {
-                snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.unwind_from));
-                if (ret)
-                        return;
-        }
-
-        if (tmp_frame.unwind_to) {
-                snprintf (key, sizeof (key), "%s.unwind_to", prefix);
-                ret = dict_set_dynstr (dict, key,
-                                       gf_strdup (tmp_frame.unwind_to));
-        }
+            return;
+    }
 
-        return;
+    if (tmp_frame.unwind_to) {
+        snprintf(key, sizeof(key), "%s.unwind_to", prefix);
+        ret = dict_set_dynstr(dict, key, gf_strdup(tmp_frame.unwind_to));
+    }
+
+    return;
 }
 
 void
-gf_proc_dump_call_stack_to_dict (call_stack_t *call_stack,
-                                 char *prefix, dict_t *dict)
+gf_proc_dump_call_stack_to_dict(call_stack_t *call_stack, char *prefix,
+                                dict_t *dict)
 {
-        int             ret = -1;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        call_frame_t    *trav = NULL;
-        int             i = 0;
-        int             count = 0;
-
-        if (!call_stack || !dict)
-                return;
-
-        count = call_frames_count (call_stack);
-        snprintf (key, sizeof (key), "%s.uid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->uid);
-        if (ret)
-                return;
-
-        snprintf (key, sizeof (key), "%s.gid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->gid);
-        if (ret)
-                return;
+    int ret = -1;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    call_frame_t *trav = NULL;
+    int i = 0;
+    int count = 0;
+
+    if (!call_stack || !dict)
+        return;
 
-        snprintf (key, sizeof (key), "%s.pid", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->pid);
-        if (ret)
-                return;
+    count = call_frames_count(call_stack);
+    snprintf(key, sizeof(key), "%s.uid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->uid);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.unique", prefix);
-        ret = dict_set_uint64 (dict, key, call_stack->unique);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.gid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->gid);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.op", prefix);
-        if (call_stack->type == GF_OP_TYPE_FOP)
-                ret = dict_set_str (dict, key,
-                                    (char *)gf_fop_list[call_stack->op]);
-        else
-                ret = dict_set_str (dict, key, "other");
+    snprintf(key, sizeof(key), "%s.pid", prefix);
+    ret = dict_set_int32(dict, key, call_stack->pid);
+    if (ret)
+        return;
 
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.unique", prefix);
+    ret = dict_set_uint64(dict, key, call_stack->unique);
+    if (ret)
+        return;
 
-        snprintf (key, sizeof (key), "%s.type", prefix);
-        ret = dict_set_int32 (dict, key, call_stack->type);
-        if (ret)
-                return;
+    snprintf(key, sizeof(key), "%s.op", prefix);
+    if (call_stack->type == GF_OP_TYPE_FOP)
+        ret = dict_set_str(dict, key, (char *)gf_fop_list[call_stack->op]);
+    else
+        ret = dict_set_str(dict, key, "other");
 
-        snprintf (key, sizeof (key), "%s.count", prefix);
-        ret = dict_set_int32 (dict, key, count);
-        if (ret)
-                return;
+    if (ret)
+        return;
 
-        list_for_each_entry (trav, &call_stack->myframes, frames) {
-                snprintf (key, sizeof (key), "%s.frame%d",
-                          prefix, i);
-                gf_proc_dump_call_frame_to_dict (trav, key, dict);
-                i++;
-        }
+    snprintf(key, sizeof(key), "%s.type", prefix);
+    ret = dict_set_int32(dict, key, call_stack->type);
+    if (ret)
+        return;
 
+    snprintf(key, sizeof(key), "%s.count", prefix);
+    ret = dict_set_int32(dict, key, count);
+    if (ret)
         return;
+
+    list_for_each_entry(trav, &call_stack->myframes, frames)
+    {
+        snprintf(key, sizeof(key), "%s.frame%d", prefix, i);
+        gf_proc_dump_call_frame_to_dict(trav, key, dict);
+        i++;
+    }
+
+    return;
 }
 
 void
-gf_proc_dump_pending_frames_to_dict (call_pool_t *call_pool, dict_t *dict)
+gf_proc_dump_pending_frames_to_dict(call_pool_t *call_pool, dict_t *dict)
 {
-        int             ret = -1;
-        call_stack_t    *trav = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             i = 0;
-
-        if (!call_pool || !dict)
-                return;
-
-        ret = TRY_LOCK (&call_pool->lock);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        LG_MSG_LOCK_FAILURE, "Unable to dump call "
-                        "pool to dict.");
-                return;
-        }
-
-        ret = dict_set_int32 (dict, "callpool.count", call_pool->cnt);
-        if (ret)
-                goto out;
+    int ret = -1;
+    call_stack_t *trav = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int i = 0;
+
+    if (!call_pool || !dict)
+        return;
+
+    ret = TRY_LOCK(&call_pool->lock);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_LOCK_FAILURE,
+               "Unable to dump call "
+               "pool to dict.");
+        return;
+    }
+
+    ret = dict_set_int32(dict, "callpool.count", call_pool->cnt);
+    if (ret)
+        goto out;
 
-        list_for_each_entry (trav, &call_pool->all_frames, all_frames) {
-                snprintf (key, sizeof (key), "callpool.stack%d", i);
-                gf_proc_dump_call_stack_to_dict (trav, key, dict);
-                i++;
-        }
+    list_for_each_entry(trav, &call_pool->all_frames, all_frames)
+    {
+        snprintf(key, sizeof(key), "callpool.stack%d", i);
+        gf_proc_dump_call_stack_to_dict(trav, key, dict);
+        i++;
+    }
 
 out:
-        UNLOCK (&call_pool->lock);
+    UNLOCK(&call_pool->lock);
 
-        return;
+    return;
 }
 
 gf_boolean_t
-__is_fuse_call (call_frame_t *frame)
+__is_fuse_call(call_frame_t *frame)
 {
-        gf_boolean_t    is_fuse_call = _gf_false;
-        GF_ASSERT (frame);
-        GF_ASSERT (frame->root);
+    gf_boolean_t is_fuse_call = _gf_false;
+    GF_ASSERT(frame);
+    GF_ASSERT(frame->root);
 
-        if (NFS_PID != frame->root->pid)
-                is_fuse_call = _gf_true;
-        return is_fuse_call;
+    if (NFS_PID != frame->root->pid)
+        is_fuse_call = _gf_true;
+    return is_fuse_call;
 }
diff --git a/libglusterfs/src/statedump.c b/libglusterfs/src/statedump.c
index 057499eef68..422fb05ede6 100644
--- a/libglusterfs/src/statedump.c
+++ b/libglusterfs/src/statedump.c
@@ -17,7 +17,6 @@
 #include "common-utils.h"
 #include "syscall.h"
 
-
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif /* MALLOC_H */
@@ -26,1035 +25,1006 @@
    'deadlock' with statedump. This is because statedump happens
    inside a signal handler and cannot afford to block on a lock.*/
 #ifdef gf_log
-# undef gf_log
+#undef gf_log
 #endif
 
-#define GF_PROC_DUMP_IS_OPTION_ENABLED(opt)     \
-        (dump_options.dump_##opt == _gf_true)
+#define GF_PROC_DUMP_IS_OPTION_ENABLED(opt)                                    \
+    (dump_options.dump_##opt == _gf_true)
 
-#define GF_PROC_DUMP_IS_XL_OPTION_ENABLED(opt)                  \
-        (dump_options.xl_options.dump_##opt == _gf_true)
+#define GF_PROC_DUMP_IS_XL_OPTION_ENABLED(opt)                                 \
+    (dump_options.xl_options.dump_##opt == _gf_true)
 
 extern xlator_t global_xlator;
 
-static pthread_mutex_t  gf_proc_dump_mutex;
+static pthread_mutex_t gf_proc_dump_mutex;
 static int gf_dump_fd = -1;
 gf_dump_options_t dump_options;
 
 static strfd_t *gf_dump_strfd = NULL;
 
 static void
-gf_proc_dump_lock (void)
+gf_proc_dump_lock(void)
 {
-        pthread_mutex_lock (&gf_proc_dump_mutex);
+    pthread_mutex_lock(&gf_proc_dump_mutex);
 }
 
-
 static void
-gf_proc_dump_unlock (void)
+gf_proc_dump_unlock(void)
 {
-        pthread_mutex_unlock (&gf_proc_dump_mutex);
+    pthread_mutex_unlock(&gf_proc_dump_mutex);
 }
 
 static int
-gf_proc_dump_open (char *tmpname)
+gf_proc_dump_open(char *tmpname)
 {
-        int  dump_fd = -1;
+    int dump_fd = -1;
 
-        mode_t mask = umask(S_IRWXG | S_IRWXO);
-        dump_fd = mkstemp (tmpname);
-        umask(mask);
-        if (dump_fd < 0)
-                return -1;
+    mode_t mask = umask(S_IRWXG | S_IRWXO);
+    dump_fd = mkstemp(tmpname);
+    umask(mask);
+    if (dump_fd < 0)
+        return -1;
 
-        gf_dump_fd = dump_fd;
-        return 0;
+    gf_dump_fd = dump_fd;
+    return 0;
 }
 
 static void
-gf_proc_dump_close (void)
+gf_proc_dump_close(void)
 {
-        sys_close (gf_dump_fd);
-        gf_dump_fd = -1;
+    sys_close(gf_dump_fd);
+    gf_dump_fd = -1;
 }
 
 static int
-gf_proc_dump_set_path (char *dump_options_file)
+gf_proc_dump_set_path(char *dump_options_file)
 {
-        int     ret = -1;
-        FILE    *fp = NULL;
-        char    buf[256];
-        char    *key = NULL, *value = NULL;
-        char    *saveptr = NULL;
-
-        fp = fopen (dump_options_file, "r");
-        if (!fp)
-                goto out;
-
-        ret = fscanf (fp, "%s", buf);
-
-        while (ret != EOF) {
-                key = strtok_r (buf, "=", &saveptr);
-                if (!key) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-
-                value = strtok_r (NULL, "=", &saveptr);
-
-                if (!value) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
-                if (!strcmp (key, "path")) {
-                        dump_options.dump_path = gf_strdup (value);
-                        break;
-                }
+    int ret = -1;
+    FILE *fp = NULL;
+    char buf[256];
+    char *key = NULL, *value = NULL;
+    char *saveptr = NULL;
+
+    fp = fopen(dump_options_file, "r");
+    if (!fp)
+        goto out;
+
+    ret = fscanf(fp, "%s", buf);
+
+    while (ret != EOF) {
+        key = strtok_r(buf, "=", &saveptr);
+        if (!key) {
+            ret = fscanf(fp, "%s", buf);
+            continue;
         }
 
+        value = strtok_r(NULL, "=", &saveptr);
+
+        if (!value) {
+            ret = fscanf(fp, "%s", buf);
+            continue;
+        }
+        if (!strcmp(key, "path")) {
+            dump_options.dump_path = gf_strdup(value);
+            break;
+        }
+    }
+
 out:
-        if (fp)
-                fclose (fp);
-        return ret;
+    if (fp)
+        fclose(fp);
+    return ret;
 }
 
 static int
-gf_proc_dump_add_section_fd (char *key, va_list ap)
+gf_proc_dump_add_section_fd(char *key, va_list ap)
 {
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int len;
 
-        char buf[GF_DUMP_MAX_BUF_LEN];
-        int len;
+    GF_ASSERT(key);
 
-        GF_ASSERT(key);
-
-        len = snprintf (buf, GF_DUMP_MAX_BUF_LEN, "\n[");
-        len += vsnprintf (buf + len,
-                   GF_DUMP_MAX_BUF_LEN - len, key, ap);
-        len += snprintf (buf + len,
-                  GF_DUMP_MAX_BUF_LEN - len, "]\n");
-        return sys_write (gf_dump_fd, buf, len);
+    len = snprintf(buf, GF_DUMP_MAX_BUF_LEN, "\n[");
+    len += vsnprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, key, ap);
+    len += snprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, "]\n");
+    return sys_write(gf_dump_fd, buf, len);
 }
 
-
 static int
-gf_proc_dump_add_section_strfd (char *key, va_list ap)
+gf_proc_dump_add_section_strfd(char *key, va_list ap)
 {
-	int ret = 0;
+    int ret = 0;
 
-        ret += strprintf (gf_dump_strfd, "[");
-	ret += strvprintf (gf_dump_strfd, key, ap);
-	ret += strprintf (gf_dump_strfd,  "]\n");
+    ret += strprintf(gf_dump_strfd, "[");
+    ret += strvprintf(gf_dump_strfd, key, ap);
+    ret += strprintf(gf_dump_strfd, "]\n");
 
-	return ret;
+    return ret;
 }
 
-
 int
-gf_proc_dump_add_section (char *key, ...)
+gf_proc_dump_add_section(char *key, ...)
 {
-	va_list ap;
-	int ret = 0;
+    va_list ap;
+    int ret = 0;
 
-	va_start (ap, key);
-	if (gf_dump_strfd)
-		ret = gf_proc_dump_add_section_strfd (key, ap);
-	else
-		ret = gf_proc_dump_add_section_fd (key, ap);
-	va_end (ap);
+    va_start(ap, key);
+    if (gf_dump_strfd)
+        ret = gf_proc_dump_add_section_strfd(key, ap);
+    else
+        ret = gf_proc_dump_add_section_fd(key, ap);
+    va_end(ap);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-gf_proc_dump_write_fd (char *key, char *value, va_list ap)
+gf_proc_dump_write_fd(char *key, char *value, va_list ap)
 {
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int len = 0;
 
-        char         buf[GF_DUMP_MAX_BUF_LEN];
-        int          len = 0;
-
-        GF_ASSERT (key);
+    GF_ASSERT(key);
 
-        len = snprintf (buf, GF_DUMP_MAX_BUF_LEN, "%s=", key);
-        len += vsnprintf (buf + len, GF_DUMP_MAX_BUF_LEN - len, value, ap);
+    len = snprintf(buf, GF_DUMP_MAX_BUF_LEN, "%s=", key);
+    len += vsnprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, value, ap);
 
-        len += snprintf (buf + len, GF_DUMP_MAX_BUF_LEN - len, "\n");
-        return sys_write (gf_dump_fd, buf, len);
+    len += snprintf(buf + len, GF_DUMP_MAX_BUF_LEN - len, "\n");
+    return sys_write(gf_dump_fd, buf, len);
 }
 
-
 static int
-gf_proc_dump_write_strfd (char *key, char *value, va_list ap)
+gf_proc_dump_write_strfd(char *key, char *value, va_list ap)
 {
-	int ret = 0;
+    int ret = 0;
 
-	ret += strprintf (gf_dump_strfd, "%s = ", key);
-	ret += strvprintf (gf_dump_strfd, value, ap);
-	ret += strprintf (gf_dump_strfd, "\n");
+    ret += strprintf(gf_dump_strfd, "%s = ", key);
+    ret += strvprintf(gf_dump_strfd, value, ap);
+    ret += strprintf(gf_dump_strfd, "\n");
 
-	return ret;
+    return ret;
 }
 
-
 int
-gf_proc_dump_write (char *key, char *value, ...)
+gf_proc_dump_write(char *key, char *value, ...)
 {
-	int ret = 0;
-	va_list ap;
+    int ret = 0;
+    va_list ap;
 
-	va_start (ap, value);
-	if (gf_dump_strfd)
-		ret = gf_proc_dump_write_strfd (key, value, ap);
-	else
-		ret = gf_proc_dump_write_fd (key, value, ap);
-	va_end (ap);
+    va_start(ap, value);
+    if (gf_dump_strfd)
+        ret = gf_proc_dump_write_strfd(key, value, ap);
+    else
+        ret = gf_proc_dump_write_fd(key, value, ap);
+    va_end(ap);
 
-	return ret;
+    return ret;
 }
 
-
 static void
-gf_proc_dump_xlator_mem_info (xlator_t *xl)
+gf_proc_dump_xlator_mem_info(xlator_t *xl)
 {
-        int     i = 0;
-
-        if (!xl)
-                return;
-
-        if (!xl->mem_acct)
-                return;
-
-        gf_proc_dump_add_section ("%s.%s - Memory usage", xl->type, xl->name);
-        gf_proc_dump_write ("num_types", "%d", xl->mem_acct->num_types);
-
-        for (i = 0; i < xl->mem_acct->num_types; i++) {
-                if (xl->mem_acct->rec[i].num_allocs == 0)
-                        continue;
-
-                gf_proc_dump_add_section ("%s.%s - usage-type %s memusage",
-                                          xl->type, xl->name,
-                                          xl->mem_acct->rec[i].typestr);
-                gf_proc_dump_write ("size", "%u", xl->mem_acct->rec[i].size);
-                gf_proc_dump_write ("num_allocs", "%u",
-                                    xl->mem_acct->rec[i].num_allocs);
-                gf_proc_dump_write ("max_size", "%u",
-                                    xl->mem_acct->rec[i].max_size);
-                gf_proc_dump_write ("max_num_allocs", "%u",
-                                    xl->mem_acct->rec[i].max_num_allocs);
-                gf_proc_dump_write ("total_allocs", "%u",
-                                    xl->mem_acct->rec[i].total_allocs);
-        }
+    int i = 0;
+
+    if (!xl)
+        return;
 
+    if (!xl->mem_acct)
         return;
+
+    gf_proc_dump_add_section("%s.%s - Memory usage", xl->type, xl->name);
+    gf_proc_dump_write("num_types", "%d", xl->mem_acct->num_types);
+
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        if (xl->mem_acct->rec[i].num_allocs == 0)
+            continue;
+
+        gf_proc_dump_add_section("%s.%s - usage-type %s memusage", xl->type,
+                                 xl->name, xl->mem_acct->rec[i].typestr);
+        gf_proc_dump_write("size", "%u", xl->mem_acct->rec[i].size);
+        gf_proc_dump_write("num_allocs", "%u", xl->mem_acct->rec[i].num_allocs);
+        gf_proc_dump_write("max_size", "%u", xl->mem_acct->rec[i].max_size);
+        gf_proc_dump_write("max_num_allocs", "%u",
+                           xl->mem_acct->rec[i].max_num_allocs);
+        gf_proc_dump_write("total_allocs", "%u",
+                           xl->mem_acct->rec[i].total_allocs);
+    }
+
+    return;
 }
 
 static void
-gf_proc_dump_xlator_mem_info_only_in_use (xlator_t *xl)
+gf_proc_dump_xlator_mem_info_only_in_use(xlator_t *xl)
 {
-        int     i = 0;
-
-        if (!xl)
-                return;
-
-        if (!xl->mem_acct)
-                return;
-
-        gf_proc_dump_add_section ("%s.%s - Memory usage", xl->type, xl->name);
-        gf_proc_dump_write ("num_types", "%d", xl->mem_acct->num_types);
-
-        for (i = 0; i < xl->mem_acct->num_types; i++) {
-                if (!xl->mem_acct->rec[i].size)
-                        continue;
-
-                gf_proc_dump_add_section ("%s.%s - usage-type %d", xl->type,
-                                          xl->name,i);
-
-                gf_proc_dump_write ("size", "%u",
-                                    xl->mem_acct->rec[i].size);
-                gf_proc_dump_write ("max_size", "%u",
-                                    xl->mem_acct->rec[i].max_size);
-                gf_proc_dump_write ("num_allocs", "%u",
-                                    xl->mem_acct->rec[i].num_allocs);
-                gf_proc_dump_write ("max_num_allocs", "%u",
-                                    xl->mem_acct->rec[i].max_num_allocs);
-                gf_proc_dump_write ("total_allocs", "%u",
-                                    xl->mem_acct->rec[i].total_allocs);
-        }
+    int i = 0;
 
+    if (!xl)
+        return;
+
+    if (!xl->mem_acct)
         return;
-}
 
+    gf_proc_dump_add_section("%s.%s - Memory usage", xl->type, xl->name);
+    gf_proc_dump_write("num_types", "%d", xl->mem_acct->num_types);
 
+    for (i = 0; i < xl->mem_acct->num_types; i++) {
+        if (!xl->mem_acct->rec[i].size)
+            continue;
+
+        gf_proc_dump_add_section("%s.%s - usage-type %d", xl->type, xl->name,
+                                 i);
+
+        gf_proc_dump_write("size", "%u", xl->mem_acct->rec[i].size);
+        gf_proc_dump_write("max_size", "%u", xl->mem_acct->rec[i].max_size);
+        gf_proc_dump_write("num_allocs", "%u", xl->mem_acct->rec[i].num_allocs);
+        gf_proc_dump_write("max_num_allocs", "%u",
+                           xl->mem_acct->rec[i].max_num_allocs);
+        gf_proc_dump_write("total_allocs", "%u",
+                           xl->mem_acct->rec[i].total_allocs);
+    }
+
+    return;
+}
 
 /* Currently this dumps only mallinfo. More can be built on here */
 void
-gf_proc_dump_mem_info ()
+gf_proc_dump_mem_info()
 {
 #ifdef HAVE_MALLOC_STATS
-        struct mallinfo info;
-
-        memset (&info, 0, sizeof (struct mallinfo));
-        info = mallinfo ();
-
-        gf_proc_dump_add_section ("mallinfo");
-        gf_proc_dump_write ("mallinfo_arena", "%d", info.arena);
-        gf_proc_dump_write ("mallinfo_ordblks", "%d", info.ordblks);
-        gf_proc_dump_write ("mallinfo_smblks", "%d", info.smblks);
-        gf_proc_dump_write ("mallinfo_hblks", "%d", info.hblks);
-        gf_proc_dump_write ("mallinfo_hblkhd", "%d", info.hblkhd);
-        gf_proc_dump_write ("mallinfo_usmblks", "%d", info.usmblks);
-        gf_proc_dump_write ("mallinfo_fsmblks", "%d", info.fsmblks);
-        gf_proc_dump_write ("mallinfo_uordblks", "%d", info.uordblks);
-        gf_proc_dump_write ("mallinfo_fordblks", "%d", info.fordblks);
-        gf_proc_dump_write ("mallinfo_keepcost", "%d", info.keepcost);
+    struct mallinfo info;
+
+    memset(&info, 0, sizeof(struct mallinfo));
+    info = mallinfo();
+
+    gf_proc_dump_add_section("mallinfo");
+    gf_proc_dump_write("mallinfo_arena", "%d", info.arena);
+    gf_proc_dump_write("mallinfo_ordblks", "%d", info.ordblks);
+    gf_proc_dump_write("mallinfo_smblks", "%d", info.smblks);
+    gf_proc_dump_write("mallinfo_hblks", "%d", info.hblks);
+    gf_proc_dump_write("mallinfo_hblkhd", "%d", info.hblkhd);
+    gf_proc_dump_write("mallinfo_usmblks", "%d", info.usmblks);
+    gf_proc_dump_write("mallinfo_fsmblks", "%d", info.fsmblks);
+    gf_proc_dump_write("mallinfo_uordblks", "%d", info.uordblks);
+    gf_proc_dump_write("mallinfo_fordblks", "%d", info.fordblks);
+    gf_proc_dump_write("mallinfo_keepcost", "%d", info.keepcost);
 #endif
-        gf_proc_dump_xlator_mem_info(&global_xlator);
-
+    gf_proc_dump_xlator_mem_info(&global_xlator);
 }
 
 void
-gf_proc_dump_mem_info_to_dict (dict_t *dict)
+gf_proc_dump_mem_info_to_dict(dict_t *dict)
 {
-        if (!dict)
-                return;
+    if (!dict)
+        return;
 #ifdef HAVE_MALLOC_STATS
-        struct  mallinfo info;
-        int     ret = -1;
+    struct mallinfo info;
+    int ret = -1;
 
-        memset (&info, 0, sizeof(struct mallinfo));
-        info = mallinfo ();
+    memset(&info, 0, sizeof(struct mallinfo));
+    info = mallinfo();
 
-        ret = dict_set_int32 (dict, "mallinfo.arena", info.arena);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.arena", info.arena);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.ordblks", info.ordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.ordblks", info.ordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.smblks", info.smblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.smblks", info.smblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.hblks", info.hblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.hblks", info.hblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.hblkhd", info.hblkhd);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.hblkhd", info.hblkhd);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.usmblks", info.usmblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.usmblks", info.usmblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.fsmblks", info.fsmblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.fsmblks", info.fsmblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.uordblks", info.uordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.uordblks", info.uordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.fordblks", info.fordblks);
-        if (ret)
-                return;
+    ret = dict_set_int32(dict, "mallinfo.fordblks", info.fordblks);
+    if (ret)
+        return;
 
-        ret = dict_set_int32 (dict, "mallinfo.keepcost", info.keepcost);
-        if (ret)
-                return;
-#endif
+    ret = dict_set_int32(dict, "mallinfo.keepcost", info.keepcost);
+    if (ret)
         return;
+#endif
+    return;
 }
 
 void
-gf_proc_dump_mempool_info (glusterfs_ctx_t *ctx)
+gf_proc_dump_mempool_info(glusterfs_ctx_t *ctx)
 {
-        struct mem_pool *pool = NULL;
+    struct mem_pool *pool = NULL;
 
-        gf_proc_dump_add_section ("mempool");
+    gf_proc_dump_add_section("mempool");
 
 #if defined(OLD_MEM_POOLS)
-        list_for_each_entry (pool, &ctx->mempool_list, global_list) {
-                gf_proc_dump_write ("-----", "-----");
-                gf_proc_dump_write ("pool-name", "%s", pool->name);
-                gf_proc_dump_write ("hot-count", "%d", pool->hot_count);
-                gf_proc_dump_write ("cold-count", "%d", pool->cold_count);
-                gf_proc_dump_write ("padded_sizeof", "%lu",
-                                    pool->padded_sizeof_type);
-                gf_proc_dump_write ("alloc-count", "%"PRIu64, pool->alloc_count);
-                gf_proc_dump_write ("max-alloc", "%d", pool->max_alloc);
-
-                gf_proc_dump_write ("pool-misses", "%"PRIu64, pool->pool_misses);
-                gf_proc_dump_write ("cur-stdalloc", "%d", pool->curr_stdalloc);
-                gf_proc_dump_write ("max-stdalloc", "%d", pool->max_stdalloc);
-        }
+    list_for_each_entry(pool, &ctx->mempool_list, global_list)
+    {
+        gf_proc_dump_write("-----", "-----");
+        gf_proc_dump_write("pool-name", "%s", pool->name);
+        gf_proc_dump_write("hot-count", "%d", pool->hot_count);
+        gf_proc_dump_write("cold-count", "%d", pool->cold_count);
+        gf_proc_dump_write("padded_sizeof", "%lu", pool->padded_sizeof_type);
+        gf_proc_dump_write("alloc-count", "%" PRIu64, pool->alloc_count);
+        gf_proc_dump_write("max-alloc", "%d", pool->max_alloc);
+
+        gf_proc_dump_write("pool-misses", "%" PRIu64, pool->pool_misses);
+        gf_proc_dump_write("cur-stdalloc", "%d", pool->curr_stdalloc);
+        gf_proc_dump_write("max-stdalloc", "%d", pool->max_stdalloc);
+    }
 #else
-        LOCK (&ctx->lock);
+    LOCK(&ctx->lock);
+    {
+        list_for_each_entry(pool, &ctx->mempool_list, owner)
         {
-                list_for_each_entry (pool, &ctx->mempool_list, owner) {
-                        int64_t active = GF_ATOMIC_GET (pool->active);
-
-                        gf_proc_dump_write ("-----", "-----");
-                        gf_proc_dump_write ("pool-name", "%s", pool->name);
-                        gf_proc_dump_write ("active-count", "%"GF_PRI_ATOMIC, active);
-                        gf_proc_dump_write ("sizeof-type", "%d", pool->sizeof_type);
-                        gf_proc_dump_write ("padded-sizeof", "%lu", 1 << pool->pool->power_of_two);
-                        gf_proc_dump_write ("size", "%lu", (1 << pool->pool->power_of_two) * active);
-                        gf_proc_dump_write ("shared-pool", "%p", pool->pool);
-                }
+            int64_t active = GF_ATOMIC_GET(pool->active);
+
+            gf_proc_dump_write("-----", "-----");
+            gf_proc_dump_write("pool-name", "%s", pool->name);
+            gf_proc_dump_write("active-count", "%" GF_PRI_ATOMIC, active);
+            gf_proc_dump_write("sizeof-type", "%d", pool->sizeof_type);
+            gf_proc_dump_write("padded-sizeof", "%lu",
+                               1 << pool->pool->power_of_two);
+            gf_proc_dump_write("size", "%lu",
+                               (1 << pool->pool->power_of_two) * active);
+            gf_proc_dump_write("shared-pool", "%p", pool->pool);
         }
-        UNLOCK (&ctx->lock);
+    }
+    UNLOCK(&ctx->lock);
 
-        /* TODO: details of (struct mem_pool_shared) pool->pool */
+    /* TODO: details of (struct mem_pool_shared) pool->pool */
 #endif
 }
 
 void
-gf_proc_dump_mempool_info_to_dict (glusterfs_ctx_t *ctx, dict_t *dict)
+gf_proc_dump_mempool_info_to_dict(glusterfs_ctx_t *ctx, dict_t *dict)
 {
 #if defined(OLD_MEM_POOLS)
-        struct mem_pool *pool = NULL;
-        char            key[GF_DUMP_MAX_BUF_LEN] = {0,};
-        int             count = 0;
-        int             ret = -1;
-
-        if (!ctx || !dict)
-                return;
-
-        list_for_each_entry (pool, &ctx->mempool_list, global_list) {
-                snprintf (key, sizeof (key), "pool%d.name", count);
-                ret = dict_set_str (dict, key, pool->name);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.hotcount", count);
-                ret = dict_set_int32 (dict, key, pool->hot_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.coldcount", count);
-                ret = dict_set_int32 (dict, key, pool->cold_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.paddedsizeof", count);
-                ret = dict_set_uint64 (dict, key, pool->padded_sizeof_type);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.alloccount", count);
-                ret = dict_set_uint64 (dict, key, pool->alloc_count);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.max_alloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_alloc);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.max-stdalloc", count);
-                ret = dict_set_int32 (dict, key, pool->max_stdalloc);
-                if (ret)
-                        return;
-
-                snprintf (key, sizeof (key), "pool%d.pool-misses", count);
-                ret = dict_set_uint64 (dict, key, pool->pool_misses);
-                if (ret)
-                        return;
-                count++;
-        }
-        ret = dict_set_int32 (dict, "mempool-count", count);
+    struct mem_pool *pool = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    int count = 0;
+    int ret = -1;
+
+    if (!ctx || !dict)
+        return;
+
+    list_for_each_entry(pool, &ctx->mempool_list, global_list)
+    {
+        snprintf(key, sizeof(key), "pool%d.name", count);
+        ret = dict_set_str(dict, key, pool->name);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.hotcount", count);
+        ret = dict_set_int32(dict, key, pool->hot_count);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.coldcount", count);
+        ret = dict_set_int32(dict, key, pool->cold_count);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.paddedsizeof", count);
+        ret = dict_set_uint64(dict, key, pool->padded_sizeof_type);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.alloccount", count);
+        ret = dict_set_uint64(dict, key, pool->alloc_count);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.max_alloc", count);
+        ret = dict_set_int32(dict, key, pool->max_alloc);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.max-stdalloc", count);
+        ret = dict_set_int32(dict, key, pool->max_stdalloc);
+        if (ret)
+            return;
+
+        snprintf(key, sizeof(key), "pool%d.pool-misses", count);
+        ret = dict_set_uint64(dict, key, pool->pool_misses);
+        if (ret)
+            return;
+        count++;
+    }
+    ret = dict_set_int32(dict, "mempool-count", count);
 #endif
 }
 
-void gf_proc_dump_latency_info (xlator_t *xl);
+void
+gf_proc_dump_latency_info(xlator_t *xl);
 
 void
-gf_proc_dump_dict_info (glusterfs_ctx_t *ctx)
+gf_proc_dump_dict_info(glusterfs_ctx_t *ctx)
 {
-        uint64_t total_dicts = 0;
-        uint64_t total_pairs = 0;
-
-        total_dicts = GF_ATOMIC_GET (ctx->stats.total_dicts_used);
-        total_pairs = GF_ATOMIC_GET (ctx->stats.total_pairs_used);
-
-        gf_proc_dump_write ("max-pairs-per-dict", "%u",
-                            GF_ATOMIC_GET (ctx->stats.max_dict_pairs));
-        gf_proc_dump_write ("total-pairs-used", "%lu", total_pairs);
-        gf_proc_dump_write ("total-dicts-used", "%lu", total_dicts);
-        gf_proc_dump_write ("average-pairs-per-dict", "%lu",
-                            (total_pairs / total_dicts));
+    uint64_t total_dicts = 0;
+    uint64_t total_pairs = 0;
+
+    total_dicts = GF_ATOMIC_GET(ctx->stats.total_dicts_used);
+    total_pairs = GF_ATOMIC_GET(ctx->stats.total_pairs_used);
+
+    gf_proc_dump_write("max-pairs-per-dict", "%u",
+                       GF_ATOMIC_GET(ctx->stats.max_dict_pairs));
+    gf_proc_dump_write("total-pairs-used", "%lu", total_pairs);
+    gf_proc_dump_write("total-dicts-used", "%lu", total_dicts);
+    gf_proc_dump_write("average-pairs-per-dict", "%lu",
+                       (total_pairs / total_dicts));
 }
 
 static void
-gf_proc_dump_single_xlator_info (xlator_t *trav)
+gf_proc_dump_single_xlator_info(xlator_t *trav)
 {
-        glusterfs_ctx_t *ctx = trav->ctx;
-        char             itable_key[1024] = {0,};
+    glusterfs_ctx_t *ctx = trav->ctx;
+    char itable_key[1024] = {
+        0,
+    };
 
+    if (trav->cleanup_starting)
+        return;
 
-        if (trav->cleanup_starting)
-                return;
-
-        if (ctx->measure_latency)
-                gf_proc_dump_latency_info (trav);
+    if (ctx->measure_latency)
+        gf_proc_dump_latency_info(trav);
 
-        gf_proc_dump_xlator_mem_info(trav);
+    gf_proc_dump_xlator_mem_info(trav);
 
-        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-            (trav->itable)) {
-                snprintf (itable_key, sizeof (itable_key), "%d.%s.itable",
-                          ctx->graph_id, trav->name);
-        }
+    if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->itable)) {
+        snprintf(itable_key, sizeof(itable_key), "%d.%s.itable", ctx->graph_id,
+                 trav->name);
+    }
 
-        if (!trav->dumpops) {
-                return;
-        }
+    if (!trav->dumpops) {
+        return;
+    }
 
-        if (trav->dumpops->priv &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (priv))
-                trav->dumpops->priv (trav);
+    if (trav->dumpops->priv && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(priv))
+        trav->dumpops->priv(trav);
 
-        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-            (trav->dumpops->inode))
-                trav->dumpops->inode (trav);
-        if (trav->dumpops->fd &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (fd))
-                trav->dumpops->fd (trav);
+    if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->dumpops->inode))
+        trav->dumpops->inode(trav);
+    if (trav->dumpops->fd && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(fd))
+        trav->dumpops->fd(trav);
 
-        if (trav->dumpops->history &&
-            GF_PROC_DUMP_IS_XL_OPTION_ENABLED (history))
-                trav->dumpops->history (trav);
+    if (trav->dumpops->history && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(history))
+        trav->dumpops->history(trav);
 }
 
 static void
-gf_proc_dump_per_xlator_info (xlator_t *top)
+gf_proc_dump_per_xlator_info(xlator_t *top)
 {
-        xlator_t        *trav = top;
+    xlator_t *trav = top;
 
-        while (trav && !trav->cleanup_starting) {
-                gf_proc_dump_single_xlator_info (trav);
-                trav = trav->next;
-        }
+    while (trav && !trav->cleanup_starting) {
+        gf_proc_dump_single_xlator_info(trav);
+        trav = trav->next;
+    }
 }
 
-
-
 void
-gf_proc_dump_xlator_info (xlator_t *top, gf_boolean_t brick_mux)
+gf_proc_dump_xlator_info(xlator_t *top, gf_boolean_t brick_mux)
 {
-        xlator_t        *trav = NULL;
-        xlator_list_t   **trav_p        = NULL;
-
-        if (!top)
-                return;
-
-        trav = top;
-        gf_proc_dump_per_xlator_info (trav);
-
-        if (brick_mux) {
-                trav_p = &top->children;
-                while (*trav_p) {
-                        trav = (*trav_p)->xlator;
-                        gf_proc_dump_per_xlator_info (trav);
-                        trav_p = &(*trav_p)->next;
-                }
-        }
+    xlator_t *trav = NULL;
+    xlator_list_t **trav_p = NULL;
 
+    if (!top)
         return;
+
+    trav = top;
+    gf_proc_dump_per_xlator_info(trav);
+
+    if (brick_mux) {
+        trav_p = &top->children;
+        while (*trav_p) {
+            trav = (*trav_p)->xlator;
+            gf_proc_dump_per_xlator_info(trav);
+            trav_p = &(*trav_p)->next;
+        }
+    }
+
+    return;
 }
 
 static void
-gf_proc_dump_oldgraph_xlator_info (xlator_t *top)
+gf_proc_dump_oldgraph_xlator_info(xlator_t *top)
 {
-        xlator_t        *trav = NULL;
+    xlator_t *trav = NULL;
 
-        if (!top)
-                return;
+    if (!top)
+        return;
 
-        trav = top;
-        while (trav) {
-                gf_proc_dump_xlator_mem_info_only_in_use (trav);
+    trav = top;
+    while (trav) {
+        gf_proc_dump_xlator_mem_info_only_in_use(trav);
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->itable)) {
-                        /*TODO: dump inode table info if necessary by
-                          printing the graph id (taken by glusterfs_cbtx_t)
-                          in the key
-                        */
-                }
+        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->itable)) {
+            /*TODO: dump inode table info if necessary by
+              printing the graph id (taken by glusterfs_cbtx_t)
+              in the key
+            */
+        }
 
-                if (!trav->dumpops) {
-                        trav = trav->next;
-                        continue;
-                }
+        if (!trav->dumpops) {
+            trav = trav->next;
+            continue;
+        }
 
-                if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED (inode) &&
-                    (trav->dumpops->inode))
-                        trav->dumpops->inode (trav);
+        if (GF_PROC_DUMP_IS_XL_OPTION_ENABLED(inode) && (trav->dumpops->inode))
+            trav->dumpops->inode(trav);
 
-                if (trav->dumpops->fd &&
-                    GF_PROC_DUMP_IS_XL_OPTION_ENABLED (fd))
-                        trav->dumpops->fd (trav);
+        if (trav->dumpops->fd && GF_PROC_DUMP_IS_XL_OPTION_ENABLED(fd))
+            trav->dumpops->fd(trav);
 
-                trav = trav->next;
-        }
+        trav = trav->next;
+    }
 
-        return;
+    return;
 }
 
 static int
-gf_proc_dump_enable_all_options ()
+gf_proc_dump_enable_all_options()
 {
-
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_iobuf, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_priv, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inode, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fd, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inodectx,
-                                 _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fdctx, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_history,
-                                 _gf_true);
-
-        return 0;
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_iobuf, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_priv, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inode, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fd, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inodectx, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fdctx, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_history, _gf_true);
+
+    return 0;
 }
 
 gf_boolean_t
-is_gf_proc_dump_all_disabled ()
+is_gf_proc_dump_all_disabled()
 {
-        gf_boolean_t all_disabled = _gf_true;
-
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_mem, all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_iobuf, all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.dump_callpool, all_disabled,
-                                   out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_priv,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_inode,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_fd,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_inodectx,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_fdctx,
-                                   all_disabled, out);
-        GF_CHECK_DUMP_OPTION_ENABLED (dump_options.xl_options.dump_history,
-                                   all_disabled, out);
+    gf_boolean_t all_disabled = _gf_true;
+
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_mem, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_iobuf, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.dump_callpool, all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_priv,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_inode,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_fd, all_disabled,
+                                 out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_inodectx,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_fdctx,
+                                 all_disabled, out);
+    GF_CHECK_DUMP_OPTION_ENABLED(dump_options.xl_options.dump_history,
+                                 all_disabled, out);
 
 out:
-        return all_disabled;
+    return all_disabled;
 }
 
 /* These options are dumped by default if glusterdump.options
    file exists and it is emtpty
 */
 static int
-gf_proc_dump_enable_default_options ()
+gf_proc_dump_enable_default_options()
 {
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_true);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_true);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_true);
 
-        return 0;
+    return 0;
 }
 
 static int
-gf_proc_dump_disable_all_options ()
+gf_proc_dump_disable_all_options()
 {
-
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_mem, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_iobuf, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.dump_callpool, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_priv, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inode,
-                                 _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fd, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_inodectx,
-                                 _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_fdctx, _gf_false);
-        GF_PROC_DUMP_SET_OPTION (dump_options.xl_options.dump_history,
-                                 _gf_false);
-        return 0;
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_mem, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_iobuf, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.dump_callpool, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_priv, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inode, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fd, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_inodectx, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_fdctx, _gf_false);
+    GF_PROC_DUMP_SET_OPTION(dump_options.xl_options.dump_history, _gf_false);
+    return 0;
 }
 
 static int
-gf_proc_dump_parse_set_option (char *key, char *value)
+gf_proc_dump_parse_set_option(char *key, char *value)
 {
-        gf_boolean_t    *opt_key = NULL;
-        gf_boolean_t    opt_value = _gf_false;
-        char buf[GF_DUMP_MAX_BUF_LEN];
-        int ret = -1;
-        int len;
-
-        if (!strcasecmp (key, "all")) {
-                (void)gf_proc_dump_enable_all_options ();
-                return 0;
-        } else if (!strcasecmp (key, "mem")) {
-                opt_key = &dump_options.dump_mem;
-        } else if (!strcasecmp (key, "iobuf")) {
-                opt_key = &dump_options.dump_iobuf;
-        } else if (!strcasecmp (key, "callpool")) {
-                opt_key = &dump_options.dump_callpool;
-        } else if (!strcasecmp (key, "priv")) {
-                opt_key = &dump_options.xl_options.dump_priv;
-        } else if (!strcasecmp (key, "fd")) {
-                opt_key = &dump_options.xl_options.dump_fd;
-        } else if (!strcasecmp (key, "inode")) {
-                opt_key = &dump_options.xl_options.dump_inode;
-        } else if (!strcasecmp (key, "inodectx")) {
-                opt_key = &dump_options.xl_options.dump_inodectx;
-        } else if (!strcasecmp (key, "fdctx")) {
-                opt_key = &dump_options.xl_options.dump_fdctx;
-        } else if (!strcasecmp (key, "history")) {
-                opt_key = &dump_options.xl_options.dump_history;
-        }
-
-        if (!opt_key) {
-                //None of dump options match the key, return back
-                len = snprintf (buf, sizeof (buf), "[Warning]:None of the options "
-                          "matched key : %s\n", key);
-                if (len < 0)
-                        ret = -1;
-                else {
-                        ret = sys_write (gf_dump_fd, buf, len);
-                        if (ret >= 0)
-                                ret = -1;
-                }
-                goto out;
+    gf_boolean_t *opt_key = NULL;
+    gf_boolean_t opt_value = _gf_false;
+    char buf[GF_DUMP_MAX_BUF_LEN];
+    int ret = -1;
+    int len;
+
+    if (!strcasecmp(key, "all")) {
+        (void)gf_proc_dump_enable_all_options();
+        return 0;
+    } else if (!strcasecmp(key, "mem")) {
+        opt_key = &dump_options.dump_mem;
+    } else if (!strcasecmp(key, "iobuf")) {
+        opt_key = &dump_options.dump_iobuf;
+    } else if (!strcasecmp(key, "callpool")) {
+        opt_key = &dump_options.dump_callpool;
+    } else if (!strcasecmp(key, "priv")) {
+        opt_key = &dump_options.xl_options.dump_priv;
+    } else if (!strcasecmp(key, "fd")) {
+        opt_key = &dump_options.xl_options.dump_fd;
+    } else if (!strcasecmp(key, "inode")) {
+        opt_key = &dump_options.xl_options.dump_inode;
+    } else if (!strcasecmp(key, "inodectx")) {
+        opt_key = &dump_options.xl_options.dump_inodectx;
+    } else if (!strcasecmp(key, "fdctx")) {
+        opt_key = &dump_options.xl_options.dump_fdctx;
+    } else if (!strcasecmp(key, "history")) {
+        opt_key = &dump_options.xl_options.dump_history;
+    }
+
+    if (!opt_key) {
+        // None of dump options match the key, return back
+        len = snprintf(buf, sizeof(buf),
+                       "[Warning]:None of the options "
+                       "matched key : %s\n",
+                       key);
+        if (len < 0)
+            ret = -1;
+        else {
+            ret = sys_write(gf_dump_fd, buf, len);
+            if (ret >= 0)
+                ret = -1;
         }
+        goto out;
+    }
 
-        opt_value = (strncasecmp (value, "yes", 3) ?
-                     _gf_false: _gf_true);
+    opt_value = (strncasecmp(value, "yes", 3) ? _gf_false : _gf_true);
 
-        GF_PROC_DUMP_SET_OPTION (*opt_key, opt_value);
+    GF_PROC_DUMP_SET_OPTION(*opt_key, opt_value);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-gf_proc_dump_options_init ()
+gf_proc_dump_options_init()
 {
-        int     ret = -1;
-        FILE    *fp = NULL;
-        char    buf[256];
-        char    *key = NULL, *value = NULL;
-        char    *saveptr = NULL;
-        char    dump_option_file[PATH_MAX];
-
-        /* glusterd will create a file glusterdump.<pid>.options and
-           sets the statedump options for the process and the file is removed
-           after the statedump is taken. Direct issue of SIGUSR1 does not have
-           mechanism for considering the statedump options. So to have a way
-           of configuring the statedump of all the glusterfs processes through
-           both cli command and SIGUSR1, glusterdump.options file is searched
-           and the options mentioned in it are given the higher priority.
-        */
-        snprintf (dump_option_file, sizeof (dump_option_file),
-                  DEFAULT_VAR_RUN_DIRECTORY
-                  "/glusterdump.options");
-        fp = fopen (dump_option_file, "r");
-        if (!fp) {
-                snprintf (dump_option_file, sizeof (dump_option_file),
-                          DEFAULT_VAR_RUN_DIRECTORY
-                          "/glusterdump.%d.options", getpid ());
-
-                fp = fopen (dump_option_file, "r");
+    int ret = -1;
+    FILE *fp = NULL;
+    char buf[256];
+    char *key = NULL, *value = NULL;
+    char *saveptr = NULL;
+    char dump_option_file[PATH_MAX];
+
+    /* glusterd will create a file glusterdump.<pid>.options and
+       sets the statedump options for the process and the file is removed
+       after the statedump is taken. Direct issue of SIGUSR1 does not have
+       mechanism for considering the statedump options. So to have a way
+       of configuring the statedump of all the glusterfs processes through
+       both cli command and SIGUSR1, glusterdump.options file is searched
+       and the options mentioned in it are given the higher priority.
+    */
+    snprintf(dump_option_file, sizeof(dump_option_file),
+             DEFAULT_VAR_RUN_DIRECTORY "/glusterdump.options");
+    fp = fopen(dump_option_file, "r");
+    if (!fp) {
+        snprintf(dump_option_file, sizeof(dump_option_file),
+                 DEFAULT_VAR_RUN_DIRECTORY "/glusterdump.%d.options", getpid());
+
+        fp = fopen(dump_option_file, "r");
 
-                if (!fp) {
-                        //ENOENT, return success
-                        (void) gf_proc_dump_enable_all_options ();
-                        return 0;
-                }
+        if (!fp) {
+            // ENOENT, return success
+            (void)gf_proc_dump_enable_all_options();
+            return 0;
         }
+    }
 
-        (void) gf_proc_dump_disable_all_options ();
-
-        // swallow the errors if setting statedump file path is failed.
-        ret = gf_proc_dump_set_path (dump_option_file);
+    (void)gf_proc_dump_disable_all_options();
 
-        ret = fscanf (fp, "%s", buf);
+    // swallow the errors if setting statedump file path is failed.
+    ret = gf_proc_dump_set_path(dump_option_file);
 
-        while (ret != EOF) {
-                key = strtok_r (buf, "=", &saveptr);
-                if (!key) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
+    ret = fscanf(fp, "%s", buf);
 
-                value = strtok_r (NULL, "=", &saveptr);
+    while (ret != EOF) {
+        key = strtok_r(buf, "=", &saveptr);
+        if (!key) {
+            ret = fscanf(fp, "%s", buf);
+            continue;
+        }
 
-                if (!value) {
-                        ret = fscanf (fp, "%s", buf);
-                        continue;
-                }
+        value = strtok_r(NULL, "=", &saveptr);
 
-                gf_proc_dump_parse_set_option (key, value);
+        if (!value) {
+            ret = fscanf(fp, "%s", buf);
+            continue;
         }
 
-        if (is_gf_proc_dump_all_disabled ())
-                (void) gf_proc_dump_enable_default_options ();
+        gf_proc_dump_parse_set_option(key, value);
+    }
 
-        if (fp)
-                fclose (fp);
+    if (is_gf_proc_dump_all_disabled())
+        (void)gf_proc_dump_enable_default_options();
 
-        return 0;
+    if (fp)
+        fclose(fp);
+
+    return 0;
 }
 
 void
-gf_proc_dump_info (int signum, glusterfs_ctx_t *ctx)
+gf_proc_dump_info(int signum, glusterfs_ctx_t *ctx)
 {
-        int                i                       = 0;
-        int                ret                     = -1;
-        glusterfs_graph_t *trav                    = NULL;
-        char               brick_name[PATH_MAX]    = {0,};
-        char               timestr[256]            = {0,};
-        char               sign_string[512]        = {0,};
-        char               tmp_dump_name[PATH_MAX] = {0,};
-        char               path[PATH_MAX]          = {0,};
-        struct timeval     tv                      = {0,};
-        gf_boolean_t       is_brick_mux            = _gf_false;
-        xlator_t          *top                     = NULL;
-        xlator_list_t    **trav_p                 = NULL;
-        int                brick_count            = 0;
-        int                len                    = 0;
-
-        gf_proc_dump_lock ();
-
-        if (!ctx)
-                goto out;
-
-        if (ctx) {
-                top = ctx->active->first;
-                for (trav_p = &top->children; *trav_p;
-                                     trav_p = &(*trav_p)->next) {
-                        brick_count++;
-                }
-
-                if (brick_count > 1)
-                        is_brick_mux = _gf_true;
-        }
-
-        if (ctx->cmd_args.brick_name) {
-                GF_REMOVE_SLASH_FROM_PATH (ctx->cmd_args.brick_name, brick_name);
-        } else
-                snprintf(brick_name, sizeof (brick_name), "glusterdump");
-
-        ret = gf_proc_dump_options_init ();
-        if (ret < 0)
-                goto out;
-
-        ret = snprintf (path, sizeof (path), "%s/%s.%d.dump.%"PRIu64,
-                        ((dump_options.dump_path != NULL)
-                                ? dump_options.dump_path
-                                : ((ctx->statedump_path != NULL)
-                                        ? ctx->statedump_path
-                                        : DEFAULT_VAR_RUN_DIRECTORY)),
-                        brick_name, getpid(), (uint64_t) time (NULL));
-        if ((ret < 0) || (ret >= sizeof(path))) {
-                goto out;
-        }
-
-        snprintf (tmp_dump_name, PATH_MAX, "%s/dumpXXXXXX",
-                  ((dump_options.dump_path != NULL)?dump_options.dump_path:
-                   ((ctx->statedump_path != NULL)?ctx->statedump_path:
-                    DEFAULT_VAR_RUN_DIRECTORY)));
-
-        ret = gf_proc_dump_open (tmp_dump_name);
-        if (ret < 0)
-                goto out;
-
-        //continue even though gettimeofday() has failed
-        ret = gettimeofday (&tv, NULL);
-        if (0 == ret) {
-                gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                len = strlen (timestr);
-                snprintf (timestr + len,
-                          sizeof timestr - len,
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        }
-
-        len = snprintf (sign_string, sizeof (sign_string), "DUMP-START-TIME: %s\n",
-                  timestr);
-
-        //swallow the errors of write for start and end marker
-        ret = sys_write (gf_dump_fd, sign_string, len);
-
-        memset (timestr, 0, sizeof (timestr));
-
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (mem)) {
-                gf_proc_dump_mem_info ();
-                gf_proc_dump_mempool_info (ctx);
-        }
-
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (iobuf))
-                iobuf_stats_dump (ctx->iobuf_pool);
-        if (GF_PROC_DUMP_IS_OPTION_ENABLED (callpool))
-                gf_proc_dump_pending_frames (ctx->pool);
-
-        /* dictionary stats */
-        gf_proc_dump_add_section ("dict");
-        gf_proc_dump_dict_info (ctx);
-
-        if (ctx->master) {
-                gf_proc_dump_add_section ("fuse");
-                gf_proc_dump_single_xlator_info (ctx->master);
+    int i = 0;
+    int ret = -1;
+    glusterfs_graph_t *trav = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+    char timestr[256] = {
+        0,
+    };
+    char sign_string[512] = {
+        0,
+    };
+    char tmp_dump_name[PATH_MAX] = {
+        0,
+    };
+    char path[PATH_MAX] = {
+        0,
+    };
+    struct timeval tv = {
+        0,
+    };
+    gf_boolean_t is_brick_mux = _gf_false;
+    xlator_t *top = NULL;
+    xlator_list_t **trav_p = NULL;
+    int brick_count = 0;
+    int len = 0;
+
+    gf_proc_dump_lock();
+
+    if (!ctx)
+        goto out;
+
+    if (ctx) {
+        top = ctx->active->first;
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            brick_count++;
         }
 
-        if (ctx->active) {
-                gf_proc_dump_add_section ("active graph - %d", ctx->graph_id);
-                gf_proc_dump_xlator_info (ctx->active->top, is_brick_mux);
-        }
-
-        i = 0;
-        list_for_each_entry (trav, &ctx->graphs, list) {
-                if (trav == ctx->active)
-                        continue;
-
-                gf_proc_dump_add_section ("oldgraph[%d]", i);
-
-                gf_proc_dump_oldgraph_xlator_info (trav->top);
-                i++;
-        }
-
-        ret = gettimeofday (&tv, NULL);
-        if (0 == ret) {
-                gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
-                len = strlen (timestr);
-                snprintf (timestr + len,
-                          sizeof timestr - len,
-                          ".%"GF_PRI_SUSECONDS, tv.tv_usec);
-        }
-
-        len = snprintf (sign_string, sizeof (sign_string), "\nDUMP-END-TIME: %s",
-                  timestr);
-        ret = sys_write (gf_dump_fd, sign_string, len);
-
-        if (gf_dump_fd != -1)
-                gf_proc_dump_close ();
-        sys_rename (tmp_dump_name, path);
+        if (brick_count > 1)
+            is_brick_mux = _gf_true;
+    }
+
+    if (ctx->cmd_args.brick_name) {
+        GF_REMOVE_SLASH_FROM_PATH(ctx->cmd_args.brick_name, brick_name);
+    } else
+        snprintf(brick_name, sizeof(brick_name), "glusterdump");
+
+    ret = gf_proc_dump_options_init();
+    if (ret < 0)
+        goto out;
+
+    ret = snprintf(
+        path, sizeof(path), "%s/%s.%d.dump.%" PRIu64,
+        ((dump_options.dump_path != NULL)
+             ? dump_options.dump_path
+             : ((ctx->statedump_path != NULL) ? ctx->statedump_path
+                                              : DEFAULT_VAR_RUN_DIRECTORY)),
+        brick_name, getpid(), (uint64_t)time(NULL));
+    if ((ret < 0) || (ret >= sizeof(path))) {
+        goto out;
+    }
+
+    snprintf(
+        tmp_dump_name, PATH_MAX, "%s/dumpXXXXXX",
+        ((dump_options.dump_path != NULL)
+             ? dump_options.dump_path
+             : ((ctx->statedump_path != NULL) ? ctx->statedump_path
+                                              : DEFAULT_VAR_RUN_DIRECTORY)));
+
+    ret = gf_proc_dump_open(tmp_dump_name);
+    if (ret < 0)
+        goto out;
+
+    // continue even though gettimeofday() has failed
+    ret = gettimeofday(&tv, NULL);
+    if (0 == ret) {
+        gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+        len = strlen(timestr);
+        snprintf(timestr + len, sizeof timestr - len, ".%" GF_PRI_SUSECONDS,
+                 tv.tv_usec);
+    }
+
+    len = snprintf(sign_string, sizeof(sign_string), "DUMP-START-TIME: %s\n",
+                   timestr);
+
+    // swallow the errors of write for start and end marker
+    ret = sys_write(gf_dump_fd, sign_string, len);
+
+    memset(timestr, 0, sizeof(timestr));
+
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(mem)) {
+        gf_proc_dump_mem_info();
+        gf_proc_dump_mempool_info(ctx);
+    }
+
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(iobuf))
+        iobuf_stats_dump(ctx->iobuf_pool);
+    if (GF_PROC_DUMP_IS_OPTION_ENABLED(callpool))
+        gf_proc_dump_pending_frames(ctx->pool);
+
+    /* dictionary stats */
+    gf_proc_dump_add_section("dict");
+    gf_proc_dump_dict_info(ctx);
+
+    if (ctx->master) {
+        gf_proc_dump_add_section("fuse");
+        gf_proc_dump_single_xlator_info(ctx->master);
+    }
+
+    if (ctx->active) {
+        gf_proc_dump_add_section("active graph - %d", ctx->graph_id);
+        gf_proc_dump_xlator_info(ctx->active->top, is_brick_mux);
+    }
+
+    i = 0;
+    list_for_each_entry(trav, &ctx->graphs, list)
+    {
+        if (trav == ctx->active)
+            continue;
+
+        gf_proc_dump_add_section("oldgraph[%d]", i);
+
+        gf_proc_dump_oldgraph_xlator_info(trav->top);
+        i++;
+    }
+
+    ret = gettimeofday(&tv, NULL);
+    if (0 == ret) {
+        gf_time_fmt(timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
+        len = strlen(timestr);
+        snprintf(timestr + len, sizeof timestr - len, ".%" GF_PRI_SUSECONDS,
+                 tv.tv_usec);
+    }
+
+    len = snprintf(sign_string, sizeof(sign_string), "\nDUMP-END-TIME: %s",
+                   timestr);
+    ret = sys_write(gf_dump_fd, sign_string, len);
+
+    if (gf_dump_fd != -1)
+        gf_proc_dump_close();
+    sys_rename(tmp_dump_name, path);
 out:
-        GF_FREE (dump_options.dump_path);
-        dump_options.dump_path = NULL;
-        gf_proc_dump_unlock ();
+    GF_FREE(dump_options.dump_path);
+    dump_options.dump_path = NULL;
+    gf_proc_dump_unlock();
 
-        return;
+    return;
 }
 
-
 void
-gf_proc_dump_fini (void)
+gf_proc_dump_fini(void)
 {
-        pthread_mutex_destroy (&gf_proc_dump_mutex);
+    pthread_mutex_destroy(&gf_proc_dump_mutex);
 }
 
-
 void
-gf_proc_dump_init ()
+gf_proc_dump_init()
 {
-        pthread_mutex_init (&gf_proc_dump_mutex, NULL);
+    pthread_mutex_init(&gf_proc_dump_mutex, NULL);
 
-        return;
+    return;
 }
 
-
 void
-gf_proc_dump_cleanup (void)
+gf_proc_dump_cleanup(void)
 {
-        pthread_mutex_destroy (&gf_proc_dump_mutex);
+    pthread_mutex_destroy(&gf_proc_dump_mutex);
 }
 
-
 void
-gf_proc_dump_xlator_private (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_private(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		if (this->dumpops && this->dumpops->priv)
-			this->dumpops->priv (this);
+        if (this->dumpops && this->dumpops->priv)
+            this->dumpops->priv(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_mallinfo (strfd_t *strfd)
+gf_proc_dump_mallinfo(strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_mem_info ();
+        gf_proc_dump_mem_info();
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_history (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_history(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		if (this->dumpops && this->dumpops->history)
-			this->dumpops->history (this);
+        if (this->dumpops && this->dumpops->history)
+            this->dumpops->history(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_itable (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_itable(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
-
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_meminfo (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_meminfo(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_xlator_mem_info (this);
+        gf_proc_dump_xlator_mem_info(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
 
-
 void
-gf_proc_dump_xlator_profile (xlator_t *this, strfd_t *strfd)
+gf_proc_dump_xlator_profile(xlator_t *this, strfd_t *strfd)
 {
-        gf_proc_dump_lock ();
-	{
-		gf_dump_strfd = strfd;
+    gf_proc_dump_lock();
+    {
+        gf_dump_strfd = strfd;
 
-		gf_proc_dump_latency_info (this);
+        gf_proc_dump_latency_info(this);
 
-		gf_dump_strfd = NULL;
-	}
-	gf_proc_dump_unlock ();
+        gf_dump_strfd = NULL;
+    }
+    gf_proc_dump_unlock();
 }
diff --git a/libglusterfs/src/store.c b/libglusterfs/src/store.c
index 5172982149f..39ca3ec1c74 100644
--- a/libglusterfs/src/store.c
+++ b/libglusterfs/src/store.c
@@ -18,725 +18,734 @@
 #include "syscall.h"
 #include "libglusterfs-messages.h"
 
-
 int32_t
-gf_store_mkdir (char *path)
+gf_store_mkdir(char *path)
 {
-        int32_t     ret = -1;
+    int32_t ret = -1;
 
-        ret = mkdir_p (path, 0777, _gf_true);
+    ret = mkdir_p(path, 0777, _gf_true);
 
-        if ((-1 == ret) && (EEXIST != errno)) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "mkdir()"
-                        " failed on path %s.", path);
-        } else {
-                ret = 0;
-        }
+    if ((-1 == ret) && (EEXIST != errno)) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "mkdir()"
+               " failed on path %s.",
+               path);
+    } else {
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_handle_create_on_absence (gf_store_handle_t **shandle,
-                                   char *path)
+gf_store_handle_create_on_absence(gf_store_handle_t **shandle, char *path)
 {
-        GF_ASSERT (shandle);
-        int32_t     ret = 0;
+    GF_ASSERT(shandle);
+    int32_t ret = 0;
 
-        if (*shandle == NULL) {
-                ret = gf_store_handle_new (path, shandle);
+    if (*shandle == NULL) {
+        ret = gf_store_handle_new(path, shandle);
 
-                if (ret) {
-                        gf_msg ("", GF_LOG_ERROR, 0,
-                                LG_MSG_STORE_HANDLE_CREATE_FAILED, "Unable to"
-                                " create store handle for path: %s", path);
-                }
+        if (ret) {
+            gf_msg("", GF_LOG_ERROR, 0, LG_MSG_STORE_HANDLE_CREATE_FAILED,
+                   "Unable to"
+                   " create store handle for path: %s",
+                   path);
         }
-        return ret;
+    }
+    return ret;
 }
 
 int32_t
-gf_store_mkstemp (gf_store_handle_t *shandle)
+gf_store_mkstemp(gf_store_handle_t *shandle)
 {
-        char    tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        shandle->tmp_fd = open (tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600);
-        if (shandle->tmp_fd < 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open %s.", tmppath);
-        }
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    shandle->tmp_fd = open(tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    if (shandle->tmp_fd < 0) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open %s.", tmppath);
+    }
 out:
-        return shandle->tmp_fd;
+    return shandle->tmp_fd;
 }
 
 int
-gf_store_sync_direntry (char *path)
+gf_store_sync_direntry(char *path)
 {
-        int             ret     = -1;
-        int             dirfd   = -1;
-        char            *dir    = NULL;
-        char            *pdir   = NULL;
-        xlator_t        *this = NULL;
-
-        this = THIS;
-
-        dir = gf_strdup (path);
-        if (!dir)
-                goto out;
-
-        pdir = dirname (dir);
-        dirfd = open (pdir, O_RDONLY);
-        if (dirfd == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-                        "Failed to open directory %s.", pdir);
-                goto out;
-        }
-
-        ret = sys_fsync (dirfd);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "Failed to fsync %s.", pdir);
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    int dirfd = -1;
+    char *dir = NULL;
+    char *pdir = NULL;
+    xlator_t *this = NULL;
+
+    this = THIS;
+
+    dir = gf_strdup(path);
+    if (!dir)
+        goto out;
+
+    pdir = dirname(dir);
+    dirfd = open(pdir, O_RDONLY);
+    if (dirfd == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "Failed to open directory %s.", pdir);
+        goto out;
+    }
+
+    ret = sys_fsync(dirfd);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "Failed to fsync %s.", pdir);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (dirfd >= 0) {
-                ret = sys_close (dirfd);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                LG_MSG_DIR_OP_FAILED, "Failed to close %s", pdir);
-                }
+    if (dirfd >= 0) {
+        ret = sys_close(dirfd);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                   "Failed to close %s", pdir);
         }
+    }
 
-        if (dir)
-                GF_FREE (dir);
+    if (dir)
+        GF_FREE(dir);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_rename_tmppath (gf_store_handle_t *shandle)
+gf_store_rename_tmppath(gf_store_handle_t *shandle)
 {
-        int32_t         ret = -1;
-        char            tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        ret = sys_fsync (shandle->tmp_fd);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to fsync %s", shandle->path);
-                goto out;
-        }
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        ret = sys_rename (tmppath, shandle->path);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to rename %s to %s", tmppath,
-                        shandle->path);
-                goto out;
-        }
-
-        ret = gf_store_sync_direntry (tmppath);
+    int32_t ret = -1;
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    ret = sys_fsync(shandle->tmp_fd);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to fsync %s", shandle->path);
+        goto out;
+    }
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    ret = sys_rename(tmppath, shandle->path);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to rename %s to %s", tmppath, shandle->path);
+        goto out;
+    }
+
+    ret = gf_store_sync_direntry(tmppath);
 out:
-        if (shandle && shandle->tmp_fd >= 0) {
-                sys_close (shandle->tmp_fd);
-                shandle->tmp_fd = -1;
-        }
-        return ret;
+    if (shandle && shandle->tmp_fd >= 0) {
+        sys_close(shandle->tmp_fd);
+        shandle->tmp_fd = -1;
+    }
+    return ret;
 }
 
 int32_t
-gf_store_unlink_tmppath (gf_store_handle_t *shandle)
+gf_store_unlink_tmppath(gf_store_handle_t *shandle)
 {
-        int32_t         ret = -1;
-        char            tmppath[PATH_MAX] = {0,};
-
-        GF_VALIDATE_OR_GOTO ("store", shandle, out);
-        GF_VALIDATE_OR_GOTO ("store", shandle->path, out);
-
-        snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
-        ret = sys_unlink (tmppath);
-        if (ret && (errno != ENOENT)) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to mv %s to %s", tmppath,
-                        shandle->path);
-        } else {
-                ret = 0;
-        }
+    int32_t ret = -1;
+    char tmppath[PATH_MAX] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("store", shandle, out);
+    GF_VALIDATE_OR_GOTO("store", shandle->path, out);
+
+    snprintf(tmppath, sizeof(tmppath), "%s.tmp", shandle->path);
+    ret = sys_unlink(tmppath);
+    if (ret && (errno != ENOENT)) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to mv %s to %s", tmppath, shandle->path);
+    } else {
+        ret = 0;
+    }
 out:
-        if (shandle && shandle->tmp_fd >= 0) {
-                sys_close (shandle->tmp_fd);
-                shandle->tmp_fd = -1;
-        }
-        return ret;
+    if (shandle && shandle->tmp_fd >= 0) {
+        sys_close(shandle->tmp_fd);
+        shandle->tmp_fd = -1;
+    }
+    return ret;
 }
 
 int
-gf_store_read_and_tokenize (FILE *file, char *str, int size, char **iter_key,
-                            char **iter_val, gf_store_op_errno_t *store_errno)
+gf_store_read_and_tokenize(FILE *file, char *str, int size, char **iter_key,
+                           char **iter_val, gf_store_op_errno_t *store_errno)
 {
-        int32_t     ret         =   -1;
-        char        *savetok    = NULL;
-        char        *key        = NULL;
-        char        *value      = NULL;
-        char        *temp       = NULL;
-        size_t       str_len    =    0;
-
-        GF_ASSERT (file);
-        GF_ASSERT (str);
-        GF_ASSERT (iter_key);
-        GF_ASSERT (iter_val);
-        GF_ASSERT (store_errno);
+    int32_t ret = -1;
+    char *savetok = NULL;
+    char *key = NULL;
+    char *value = NULL;
+    char *temp = NULL;
+    size_t str_len = 0;
+
+    GF_ASSERT(file);
+    GF_ASSERT(str);
+    GF_ASSERT(iter_key);
+    GF_ASSERT(iter_val);
+    GF_ASSERT(store_errno);
 
 retry:
-        temp = fgets (str, size, file);
-        if (temp == NULL || feof (file)) {
-                ret = -1;
-                *store_errno = GD_STORE_EOF;
-                goto out;
-        }
-
-        if (strcmp (str, "\n") == 0)
-                goto retry;
-
-        str_len = strlen(str);
-        str[str_len - 1] = '\0';
-        /* Truncate the "\n", as fgets stores "\n" in str */
-
-        key = strtok_r (str, "=", &savetok);
-        if (!key) {
-                ret = -1;
-                *store_errno = GD_STORE_KEY_NULL;
-                goto out;
-        }
-
-        value = strtok_r (NULL, "", &savetok);
-        if (!value) {
-                ret = -1;
-                *store_errno = GD_STORE_VALUE_NULL;
-                goto out;
-        }
-
-        *iter_key = key;
-        *iter_val = value;
-        *store_errno = GD_STORE_SUCCESS;
-        ret = 0;
+    temp = fgets(str, size, file);
+    if (temp == NULL || feof(file)) {
+        ret = -1;
+        *store_errno = GD_STORE_EOF;
+        goto out;
+    }
+
+    if (strcmp(str, "\n") == 0)
+        goto retry;
+
+    str_len = strlen(str);
+    str[str_len - 1] = '\0';
+    /* Truncate the "\n", as fgets stores "\n" in str */
+
+    key = strtok_r(str, "=", &savetok);
+    if (!key) {
+        ret = -1;
+        *store_errno = GD_STORE_KEY_NULL;
+        goto out;
+    }
+
+    value = strtok_r(NULL, "", &savetok);
+    if (!value) {
+        ret = -1;
+        *store_errno = GD_STORE_VALUE_NULL;
+        goto out;
+    }
+
+    *iter_key = key;
+    *iter_val = value;
+    *store_errno = GD_STORE_SUCCESS;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
+gf_store_retrieve_value(gf_store_handle_t *handle, char *key, char **value)
 {
-        int32_t         ret = -1;
-        char            *scan_str = NULL;
-        char            *iter_key = NULL;
-        char            *iter_val = NULL;
-        char            *free_str = NULL;
-        struct stat     st        = {0,};
-        gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
-
-        GF_ASSERT (handle);
-
-        if (handle->locked == F_ULOCK)
-                /* no locking is used handle->fd gets closed() after usage */
-                handle->fd = open (handle->path, O_RDWR);
-        else
-                /* handle->fd is valid already, kept open for lockf() */
-                sys_lseek (handle->fd, 0, SEEK_SET);
-
-        if (handle->fd == -1) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to open file %s", handle->path);
-                goto out;
-        }
+    int32_t ret = -1;
+    char *scan_str = NULL;
+    char *iter_key = NULL;
+    char *iter_val = NULL;
+    char *free_str = NULL;
+    struct stat st = {
+        0,
+    };
+    gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
+
+    GF_ASSERT(handle);
+
+    if (handle->locked == F_ULOCK)
+        /* no locking is used handle->fd gets closed() after usage */
+        handle->fd = open(handle->path, O_RDWR);
+    else
+        /* handle->fd is valid already, kept open for lockf() */
+        sys_lseek(handle->fd, 0, SEEK_SET);
+
+    if (handle->fd == -1) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to open file %s", handle->path);
+        goto out;
+    }
+    if (!handle->read) {
+        int duped_fd = dup(handle->fd);
+
+        if (duped_fd >= 0)
+            handle->read = fdopen(duped_fd, "r");
         if (!handle->read) {
-                int duped_fd = dup(handle->fd);
-
-                if (duped_fd >= 0)
-                        handle->read = fdopen (duped_fd, "r");
-                if (!handle->read) {
-                        if (duped_fd != -1)
-                                sys_close (duped_fd);
-                        gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                                "Unable to open file %s", handle->path);
-                        goto out;
-                }
-        } else {
-                fseek (handle->read, 0, SEEK_SET);
-        }
-        ret = sys_fstat (handle->fd, &st);
+            if (duped_fd != -1)
+                sys_close(duped_fd);
+            gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                   "Unable to open file %s", handle->path);
+            goto out;
+        }
+    } else {
+        fseek(handle->read, 0, SEEK_SET);
+    }
+    ret = sys_fstat(handle->fd, &st);
+    if (ret < 0) {
+        gf_msg("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "stat on file %s failed", handle->path);
+        ret = -1;
+        store_errno = GD_STORE_STAT_FAILED;
+        goto out;
+    }
+
+    /* "st.st_size + 1" is used as we are fetching each
+     * line of a file using fgets, fgets will append "\0"
+     * to the end of the string
+     */
+    scan_str = GF_CALLOC(1, st.st_size + 1, gf_common_mt_char);
+
+    if (scan_str == NULL) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+
+    free_str = scan_str;
+
+    do {
+        ret = gf_store_read_and_tokenize(handle->read, scan_str, st.st_size + 1,
+                                         &iter_key, &iter_val, &store_errno);
         if (ret < 0) {
-                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "stat on file %s failed", handle->path);
-                ret = -1;
-                store_errno = GD_STORE_STAT_FAILED;
-                goto out;
+            gf_msg_trace("", 0,
+                         "error while reading key '%s': "
+                         "%s",
+                         key, gf_store_strerror(store_errno));
+            goto out;
         }
 
-        /* "st.st_size + 1" is used as we are fetching each
-         * line of a file using fgets, fgets will append "\0"
-         * to the end of the string
-         */
-        scan_str = GF_CALLOC (1, st.st_size + 1,
-                              gf_common_mt_char);
-
-        if (scan_str == NULL) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
+        gf_msg_trace("", 0, "key %s read", iter_key);
 
-        free_str = scan_str;
-
-        do {
-                ret = gf_store_read_and_tokenize (handle->read, scan_str,
-                                                  st.st_size + 1,
-                                                  &iter_key, &iter_val,
-                                                  &store_errno);
-                if (ret < 0) {
-                        gf_msg_trace ("", 0, "error while reading key '%s': "
-                                      "%s", key,
-                                      gf_store_strerror (store_errno));
-                        goto out;
-                }
-
-                gf_msg_trace ("", 0, "key %s read", iter_key);
-
-                if (!strcmp (key, iter_key)) {
-                        gf_msg_debug ("", 0, "key %s found", key);
-                        ret = 0;
-                        if (iter_val)
-                                *value = gf_strdup (iter_val);
-                        goto out;
-                }
-        } while (1);
-out:
-        if (handle->read) {
-                fclose (handle->read);
-                handle->read = NULL;
+        if (!strcmp(key, iter_key)) {
+            gf_msg_debug("", 0, "key %s found", key);
+            ret = 0;
+            if (iter_val)
+                *value = gf_strdup(iter_val);
+            goto out;
         }
+    } while (1);
+out:
+    if (handle->read) {
+        fclose(handle->read);
+        handle->read = NULL;
+    }
 
-        if (handle->fd > 0 && handle->locked == F_ULOCK) {
-                /* only invalidate handle->fd if not locked */
-                sys_close (handle->fd);
-        }
+    if (handle->fd > 0 && handle->locked == F_ULOCK) {
+        /* only invalidate handle->fd if not locked */
+        sys_close(handle->fd);
+    }
 
-        GF_FREE (free_str);
+    GF_FREE(free_str);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_save_value (int fd, char *key, char *value)
+gf_store_save_value(int fd, char *key, char *value)
 {
-        int32_t         ret = -1;
-        int             dup_fd = -1;
-        FILE           *fp  = NULL;
-
-        GF_ASSERT (fd > 0);
-        GF_ASSERT (key);
-        GF_ASSERT (value);
-
-        dup_fd = dup (fd);
-        if (dup_fd == -1)
-                goto out;
-
-        fp = fdopen (dup_fd, "a+");
-        if (fp == NULL) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno,
-                        LG_MSG_FILE_OP_FAILED, "fdopen failed.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = fprintf (fp, "%s=%s\n", key, value);
-        if (ret < 0) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to store key: %s, value: %s.",
-                        key, value);
-                ret = -1;
-                goto out;
-        }
-
-        ret = fflush (fp);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "fflush failed.");
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int32_t ret = -1;
+    int dup_fd = -1;
+    FILE *fp = NULL;
+
+    GF_ASSERT(fd > 0);
+    GF_ASSERT(key);
+    GF_ASSERT(value);
+
+    dup_fd = dup(fd);
+    if (dup_fd == -1)
+        goto out;
+
+    fp = fdopen(dup_fd, "a+");
+    if (fp == NULL) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fdopen failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = fprintf(fp, "%s=%s\n", key, value);
+    if (ret < 0) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to store key: %s, value: %s.", key, value);
+        ret = -1;
+        goto out;
+    }
+
+    ret = fflush(fp);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "fflush failed.");
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (fp)
-                fclose (fp);
+    if (fp)
+        fclose(fp);
 
-        gf_msg_debug (THIS->name, 0, "returning: %d", ret);
-        return ret;
+    gf_msg_debug(THIS->name, 0, "returning: %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_handle_new (const char *path, gf_store_handle_t **handle)
+gf_store_handle_new(const char *path, gf_store_handle_t **handle)
 {
-        int32_t                 ret = -1;
-        gf_store_handle_t *shandle = NULL;
-        int                     fd = -1;
-        char                    *spath = NULL;
-
-        shandle = GF_CALLOC (1, sizeof (*shandle), gf_common_mt_store_handle_t);
-        if (!shandle)
-                goto out;
-
-        spath = gf_strdup (path);
-        if (!spath)
-                goto out;
-
-        fd = open (path, O_RDWR | O_CREAT | O_APPEND, 0600);
-        if (fd < 0) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open file: %s.", path);
-                goto out;
-        }
-
-        ret = gf_store_sync_direntry (spath);
-        if (ret)
-                goto out;
-
-        shandle->path = spath;
-        shandle->locked = F_ULOCK;
-        *handle = shandle;
-        shandle->tmp_fd = -1;
-
-        ret = 0;
+    int32_t ret = -1;
+    gf_store_handle_t *shandle = NULL;
+    int fd = -1;
+    char *spath = NULL;
+
+    shandle = GF_CALLOC(1, sizeof(*shandle), gf_common_mt_store_handle_t);
+    if (!shandle)
+        goto out;
+
+    spath = gf_strdup(path);
+    if (!spath)
+        goto out;
+
+    fd = open(path, O_RDWR | O_CREAT | O_APPEND, 0600);
+    if (fd < 0) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open file: %s.", path);
+        goto out;
+    }
+
+    ret = gf_store_sync_direntry(spath);
+    if (ret)
+        goto out;
+
+    shandle->path = spath;
+    shandle->locked = F_ULOCK;
+    *handle = shandle;
+    shandle->tmp_fd = -1;
+
+    ret = 0;
 out:
-        if (fd >= 0)
-                sys_close (fd);
+    if (fd >= 0)
+        sys_close(fd);
 
-        if (ret < 0) {
-                GF_FREE (spath);
-                GF_FREE (shandle);
-        }
+    if (ret < 0) {
+        GF_FREE(spath);
+        GF_FREE(shandle);
+    }
 
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
 
 int
-gf_store_handle_retrieve (char *path, gf_store_handle_t **handle)
+gf_store_handle_retrieve(char *path, gf_store_handle_t **handle)
 {
-        int32_t                 ret = -1;
-        struct stat statbuf = {0};
-
-        ret = sys_stat (path, &statbuf);
-        if (ret) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND, "Path "
-                        "corresponding to %s.", path);
-                goto out;
-        }
-        ret =  gf_store_handle_new (path, handle);
+    int32_t ret = -1;
+    struct stat statbuf = {0};
+
+    ret = sys_stat(path, &statbuf);
+    if (ret) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND,
+               "Path "
+               "corresponding to %s.",
+               path);
+        goto out;
+    }
+    ret = gf_store_handle_new(path, handle);
 out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_handle_destroy (gf_store_handle_t *handle)
+gf_store_handle_destroy(gf_store_handle_t *handle)
 {
-        int32_t                 ret = -1;
+    int32_t ret = -1;
 
-        if (!handle) {
-                ret = 0;
-                goto out;
-        }
+    if (!handle) {
+        ret = 0;
+        goto out;
+    }
 
-        GF_FREE (handle->path);
+    GF_FREE(handle->path);
 
-        GF_FREE (handle);
+    GF_FREE(handle);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
+    gf_msg_debug("", 0, "Returning %d", ret);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_new (gf_store_handle_t  *shandle, gf_store_iter_t  **iter)
+gf_store_iter_new(gf_store_handle_t *shandle, gf_store_iter_t **iter)
 {
-        int32_t                 ret = -1;
-        FILE                    *fp = NULL;
-        gf_store_iter_t         *tmp_iter = NULL;
-
-        GF_ASSERT (shandle);
-        GF_ASSERT (iter);
-
-        fp = fopen (shandle->path, "r");
-        if (!fp) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Unable to open file %s", shandle->path);
-                goto out;
-        }
+    int32_t ret = -1;
+    FILE *fp = NULL;
+    gf_store_iter_t *tmp_iter = NULL;
 
-        tmp_iter = GF_CALLOC (1, sizeof (*tmp_iter),
-                              gf_common_mt_store_iter_t);
-        if (!tmp_iter)
-                goto out;
+    GF_ASSERT(shandle);
+    GF_ASSERT(iter);
 
-        if (snprintf (tmp_iter->filepath, sizeof (tmp_iter->filepath), "%s",
-                      shandle->path) >= sizeof (tmp_iter->filepath))
-                goto out;
+    fp = fopen(shandle->path, "r");
+    if (!fp) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable to open file %s", shandle->path);
+        goto out;
+    }
 
-        tmp_iter->file = fp;
+    tmp_iter = GF_CALLOC(1, sizeof(*tmp_iter), gf_common_mt_store_iter_t);
+    if (!tmp_iter)
+        goto out;
 
-        *iter = tmp_iter;
-        tmp_iter = NULL;
-        ret = 0;
+    if (snprintf(tmp_iter->filepath, sizeof(tmp_iter->filepath), "%s",
+                 shandle->path) >= sizeof(tmp_iter->filepath))
+        goto out;
+
+    tmp_iter->file = fp;
+
+    *iter = tmp_iter;
+    tmp_iter = NULL;
+    ret = 0;
 
 out:
-        if (ret && fp)
-                fclose (fp);
+    if (ret && fp)
+        fclose(fp);
 
-        GF_FREE (tmp_iter);
+    GF_FREE(tmp_iter);
 
-        gf_msg_debug ("", 0, "Returning with %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning with %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_validate_key_value (char *storepath, char *key, char *val,
-                             gf_store_op_errno_t *op_errno)
+gf_store_validate_key_value(char *storepath, char *key, char *val,
+                            gf_store_op_errno_t *op_errno)
 {
-        int ret = 0;
-
-        GF_ASSERT (op_errno);
-        GF_ASSERT (storepath);
-
-        if ((key == NULL) && (val == NULL)) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid key and value (null)"
-                        " in %s", storepath);
-                *op_errno = GD_STORE_KEY_VALUE_NULL;
-        } else if (key == NULL) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid key (null) in %s",
-                        storepath);
-                *op_errno = GD_STORE_KEY_NULL;
-        } else if (val == NULL) {
-                ret = -1;
-                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
-                        "store may be corrupted, Invalid value (null) for key"
-                        " %s in %s", key, storepath);
-                *op_errno = GD_STORE_VALUE_NULL;
-        } else {
-                ret = 0;
-                *op_errno = GD_STORE_SUCCESS;
-        }
+    int ret = 0;
+
+    GF_ASSERT(op_errno);
+    GF_ASSERT(storepath);
+
+    if ((key == NULL) && (val == NULL)) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid key and value (null)"
+               " in %s",
+               storepath);
+        *op_errno = GD_STORE_KEY_VALUE_NULL;
+    } else if (key == NULL) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid key (null) in %s",
+               storepath);
+        *op_errno = GD_STORE_KEY_NULL;
+    } else if (val == NULL) {
+        ret = -1;
+        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+               "Glusterd "
+               "store may be corrupted, Invalid value (null) for key"
+               " %s in %s",
+               key, storepath);
+        *op_errno = GD_STORE_VALUE_NULL;
+    } else {
+        ret = 0;
+        *op_errno = GD_STORE_SUCCESS;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_get_next (gf_store_iter_t *iter, char  **key, char **value,
-                        gf_store_op_errno_t *op_errno)
+gf_store_iter_get_next(gf_store_iter_t *iter, char **key, char **value,
+                       gf_store_op_errno_t *op_errno)
 {
-        int32_t         ret       = -1;
-        char            *scan_str = NULL;
-        char            *iter_key = NULL;
-        char            *iter_val = NULL;
-        struct stat     st        = {0,};
-        gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
-
-        GF_ASSERT (iter);
-        GF_ASSERT (key);
-        GF_ASSERT (value);
-
-        ret = sys_stat (iter->filepath, &st);
-        if (ret < 0) {
-                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-                        "stat on file failed");
-                ret = -1;
-                store_errno = GD_STORE_STAT_FAILED;
-                goto out;
-        }
-
-        /* "st.st_size + 1" is used as we are fetching each
-         * line of a file using fgets, fgets will append "\0"
-         * to the end of the string
-         */
-        scan_str = GF_CALLOC (1, st.st_size + 1,
-                              gf_common_mt_char);
-        if (!scan_str) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-
-        ret = gf_store_read_and_tokenize (iter->file, scan_str,
-                                          st.st_size + 1,
-                                          &iter_key, &iter_val,
-                                          &store_errno);
-        if (ret < 0) {
-                goto out;
-        }
-
-        ret = gf_store_validate_key_value (iter->filepath, iter_key,
-                                           iter_val, &store_errno);
-        if (ret)
-                goto out;
-
-        *key = gf_strdup (iter_key);
-        if (!*key) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-        *value = gf_strdup (iter_val);
-        if (!*value) {
-                ret = -1;
-                store_errno = GD_STORE_ENOMEM;
-                goto out;
-        }
-        ret = 0;
+    int32_t ret = -1;
+    char *scan_str = NULL;
+    char *iter_key = NULL;
+    char *iter_val = NULL;
+    struct stat st = {
+        0,
+    };
+    gf_store_op_errno_t store_errno = GD_STORE_SUCCESS;
+
+    GF_ASSERT(iter);
+    GF_ASSERT(key);
+    GF_ASSERT(value);
+
+    ret = sys_stat(iter->filepath, &st);
+    if (ret < 0) {
+        gf_msg("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+               "stat on file failed");
+        ret = -1;
+        store_errno = GD_STORE_STAT_FAILED;
+        goto out;
+    }
+
+    /* "st.st_size + 1" is used as we are fetching each
+     * line of a file using fgets, fgets will append "\0"
+     * to the end of the string
+     */
+    scan_str = GF_CALLOC(1, st.st_size + 1, gf_common_mt_char);
+    if (!scan_str) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+
+    ret = gf_store_read_and_tokenize(iter->file, scan_str, st.st_size + 1,
+                                     &iter_key, &iter_val, &store_errno);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = gf_store_validate_key_value(iter->filepath, iter_key, iter_val,
+                                      &store_errno);
+    if (ret)
+        goto out;
+
+    *key = gf_strdup(iter_key);
+    if (!*key) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+    *value = gf_strdup(iter_val);
+    if (!*value) {
+        ret = -1;
+        store_errno = GD_STORE_ENOMEM;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        GF_FREE (scan_str);
-        if (ret) {
-                GF_FREE (*key);
-                GF_FREE (*value);
-                *key = NULL;
-                *value = NULL;
-        }
-        if (op_errno)
-                *op_errno = store_errno;
-
-        gf_msg_debug ("", 0, "Returning with %d", ret);
-        return ret;
+    GF_FREE(scan_str);
+    if (ret) {
+        GF_FREE(*key);
+        GF_FREE(*value);
+        *key = NULL;
+        *value = NULL;
+    }
+    if (op_errno)
+        *op_errno = store_errno;
+
+    gf_msg_debug("", 0, "Returning with %d", ret);
+    return ret;
 }
 
 int32_t
-gf_store_iter_get_matching (gf_store_iter_t *iter, char *key, char **value)
+gf_store_iter_get_matching(gf_store_iter_t *iter, char *key, char **value)
 {
-        int32_t ret = -1;
-        char    *tmp_key = NULL;
-        char    *tmp_value = NULL;
-
-        ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value, NULL);
-        while (!ret) {
-                if (!strncmp (key, tmp_key, strlen (key))){
-                        *value = tmp_value;
-                        GF_FREE (tmp_key);
-                        goto out;
-                }
-                GF_FREE (tmp_key);
-                tmp_key = NULL;
-                GF_FREE (tmp_value);
-                tmp_value = NULL;
-                ret = gf_store_iter_get_next (iter, &tmp_key, &tmp_value,
-                                              NULL);
-        }
+    int32_t ret = -1;
+    char *tmp_key = NULL;
+    char *tmp_value = NULL;
+
+    ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL);
+    while (!ret) {
+        if (!strncmp(key, tmp_key, strlen(key))) {
+            *value = tmp_value;
+            GF_FREE(tmp_key);
+            goto out;
+        }
+        GF_FREE(tmp_key);
+        tmp_key = NULL;
+        GF_FREE(tmp_value);
+        tmp_value = NULL;
+        ret = gf_store_iter_get_next(iter, &tmp_key, &tmp_value, NULL);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_store_iter_destroy (gf_store_iter_t *iter)
+gf_store_iter_destroy(gf_store_iter_t *iter)
 {
-        int32_t         ret = -1;
-
-        if (!iter)
-                return 0;
-
-        /* gf_store_iter_new will not return a valid iter object with iter->file
-         * being NULL*/
-        ret = fclose (iter->file);
-        if (ret)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "Unable"
-                        " to close file: %s, ret: %d" ,
-                        iter->filepath, ret);
-
-        GF_FREE (iter);
-        return ret;
+    int32_t ret = -1;
+
+    if (!iter)
+        return 0;
+
+    /* gf_store_iter_new will not return a valid iter object with iter->file
+     * being NULL*/
+    ret = fclose(iter->file);
+    if (ret)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Unable"
+               " to close file: %s, ret: %d",
+               iter->filepath, ret);
+
+    GF_FREE(iter);
+    return ret;
 }
 
-char*
-gf_store_strerror (gf_store_op_errno_t op_errno)
+char *
+gf_store_strerror(gf_store_op_errno_t op_errno)
 {
-        switch (op_errno) {
+    switch (op_errno) {
         case GD_STORE_SUCCESS:
-                return "Success";
+            return "Success";
         case GD_STORE_KEY_NULL:
-                return "Invalid Key";
+            return "Invalid Key";
         case GD_STORE_VALUE_NULL:
-                return "Invalid Value";
+            return "Invalid Value";
         case GD_STORE_KEY_VALUE_NULL:
-                return "Invalid Key and Value";
+            return "Invalid Key and Value";
         case GD_STORE_EOF:
-                return "No data";
+            return "No data";
         case GD_STORE_ENOMEM:
-                return "No memory";
+            return "No memory";
         default:
-                return "Invalid errno";
-        }
+            return "Invalid errno";
+    }
 }
 
 int
-gf_store_lock (gf_store_handle_t *sh)
+gf_store_lock(gf_store_handle_t *sh)
 {
-        int                     ret;
-
-        GF_ASSERT (sh);
-        GF_ASSERT (sh->path);
-        GF_ASSERT (sh->locked == F_ULOCK);
-
-        sh->fd = open (sh->path, O_RDWR);
-        if (sh->fd == -1) {
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                        "Failed to open '%s'", sh->path);
-                return -1;
-        }
-
-        ret = lockf (sh->fd, F_LOCK, 0);
-        if (ret)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED,
-                        "Failed to gain lock on '%s'", sh->path);
-        else
-                /* sh->locked is protected by the lockf(sh->fd) above */
-                sh->locked = F_LOCK;
-
-        return ret;
+    int ret;
+
+    GF_ASSERT(sh);
+    GF_ASSERT(sh->path);
+    GF_ASSERT(sh->locked == F_ULOCK);
+
+    sh->fd = open(sh->path, O_RDWR);
+    if (sh->fd == -1) {
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+               "Failed to open '%s'", sh->path);
+        return -1;
+    }
+
+    ret = lockf(sh->fd, F_LOCK, 0);
+    if (ret)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED,
+               "Failed to gain lock on '%s'", sh->path);
+    else
+        /* sh->locked is protected by the lockf(sh->fd) above */
+        sh->locked = F_LOCK;
+
+    return ret;
 }
 
 void
-gf_store_unlock (gf_store_handle_t *sh)
+gf_store_unlock(gf_store_handle_t *sh)
 {
-        GF_ASSERT (sh);
-        GF_ASSERT (sh->locked == F_LOCK);
+    GF_ASSERT(sh);
+    GF_ASSERT(sh->locked == F_LOCK);
 
-        sh->locked = F_ULOCK;
+    sh->locked = F_ULOCK;
 
-        /* does not matter if this fails, locks are released on close anyway */
-        if (lockf (sh->fd, F_ULOCK, 0) == -1)
-                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED,
-                        "Failed to release lock on '%s'", sh->path);
+    /* does not matter if this fails, locks are released on close anyway */
+    if (lockf(sh->fd, F_ULOCK, 0) == -1)
+        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED,
+               "Failed to release lock on '%s'", sh->path);
 
-        sys_close (sh->fd);
+    sys_close(sh->fd);
 }
 
 int
-gf_store_locked_local (gf_store_handle_t *sh)
+gf_store_locked_local(gf_store_handle_t *sh)
 {
-        GF_ASSERT (sh);
+    GF_ASSERT(sh);
 
-        return (sh->locked == F_LOCK);
+    return (sh->locked == F_LOCK);
 }
diff --git a/libglusterfs/src/strfd.c b/libglusterfs/src/strfd.c
index 002d48629bc..ad66b622361 100644
--- a/libglusterfs/src/strfd.c
+++ b/libglusterfs/src/strfd.c
@@ -16,77 +16,78 @@
 #include "common-utils.h"
 
 strfd_t *
-strfd_open ()
+strfd_open()
 {
-        strfd_t *strfd = NULL;
+    strfd_t *strfd = NULL;
 
-        strfd = GF_CALLOC(1, sizeof(*strfd), gf_common_mt_strfd_t);
+    strfd = GF_CALLOC(1, sizeof(*strfd), gf_common_mt_strfd_t);
 
-        return strfd;
+    return strfd;
 }
 
 int
-strvprintf (strfd_t *strfd, const char *fmt, va_list ap)
+strvprintf(strfd_t *strfd, const char *fmt, va_list ap)
 {
-        char *str = NULL;
-        int size = 0;
-
-        size = vasprintf (&str, fmt, ap);
-
-        if (size < 0)
-                return size;
-
-        if (!strfd->alloc_size) {
-                strfd->data = GF_CALLOC (max(size + 1, 4096), 1,
-                                         gf_common_mt_strfd_data_t);
-                if (!strfd->data) {
-                        free (str); /* NOT GF_FREE */
-                        return -1;
-                }
-                strfd->alloc_size = max(size + 1, 4096);
-        }
+    char *str = NULL;
+    int size = 0;
+
+    size = vasprintf(&str, fmt, ap);
+
+    if (size < 0)
+        return size;
 
-        if (strfd->alloc_size <= (strfd->size + size)) {
-                char *tmp_ptr = NULL;
-                int new_size = max ((strfd->alloc_size * 2),
-                                    gf_roundup_next_power_of_two (strfd->size + size + 1));
-                tmp_ptr = GF_REALLOC (strfd->data, new_size);
-                if (!tmp_ptr) {
-                        free (str); /* NOT GF_FREE */
-                        return -1;
-                }
-                strfd->alloc_size = new_size;
-                strfd->data = tmp_ptr;
+    if (!strfd->alloc_size) {
+        strfd->data = GF_CALLOC(max(size + 1, 4096), 1,
+                                gf_common_mt_strfd_data_t);
+        if (!strfd->data) {
+            free(str); /* NOT GF_FREE */
+            return -1;
+        }
+        strfd->alloc_size = max(size + 1, 4096);
+    }
+
+    if (strfd->alloc_size <= (strfd->size + size)) {
+        char *tmp_ptr = NULL;
+        int new_size = max(
+            (strfd->alloc_size * 2),
+            gf_roundup_next_power_of_two(strfd->size + size + 1));
+        tmp_ptr = GF_REALLOC(strfd->data, new_size);
+        if (!tmp_ptr) {
+            free(str); /* NOT GF_FREE */
+            return -1;
         }
+        strfd->alloc_size = new_size;
+        strfd->data = tmp_ptr;
+    }
 
-        /* Copy the trailing '\0', but do not account for it in ->size.
-           This allows safe use of strfd->data as a string. */
-        memcpy (strfd->data + strfd->size, str, size + 1);
-        strfd->size += size;
+    /* Copy the trailing '\0', but do not account for it in ->size.
+       This allows safe use of strfd->data as a string. */
+    memcpy(strfd->data + strfd->size, str, size + 1);
+    strfd->size += size;
 
-        free (str); /* NOT GF_FREE */
+    free(str); /* NOT GF_FREE */
 
-        return size;
+    return size;
 }
 
 int
-strprintf (strfd_t *strfd, const char *fmt, ...)
+strprintf(strfd_t *strfd, const char *fmt, ...)
 {
-        int ret = 0;
-        va_list ap;
+    int ret = 0;
+    va_list ap;
 
-        va_start (ap, fmt);
-        ret = strvprintf (strfd, fmt, ap);
-        va_end (ap);
+    va_start(ap, fmt);
+    ret = strvprintf(strfd, fmt, ap);
+    va_end(ap);
 
-        return ret;
+    return ret;
 }
 
 int
-strfd_close (strfd_t *strfd)
+strfd_close(strfd_t *strfd)
 {
-        GF_FREE (strfd->data);
-        GF_FREE (strfd);
+    GF_FREE(strfd->data);
+    GF_FREE(strfd);
 
-        return 0;
+    return 0;
 }
diff --git a/libglusterfs/src/syncop-utils.c b/libglusterfs/src/syncop-utils.c
index 1ccda55e4c5..d2a71698745 100644
--- a/libglusterfs/src/syncop-utils.c
+++ b/libglusterfs/src/syncop-utils.c
@@ -14,39 +14,38 @@
 #include "libglusterfs-messages.h"
 
 struct syncop_dir_scan_data {
-        xlator_t *subvol;
-        loc_t *parent;
-        void *data;
-        gf_dirent_t *q;
-        gf_dirent_t *entry;
-        pthread_cond_t *cond;
-        pthread_mutex_t *mut;
-        syncop_dir_scan_fn_t fn;
-        uint32_t *jobs_running;
-        uint32_t *qlen;
-        int32_t  *retval;
+    xlator_t *subvol;
+    loc_t *parent;
+    void *data;
+    gf_dirent_t *q;
+    gf_dirent_t *entry;
+    pthread_cond_t *cond;
+    pthread_mutex_t *mut;
+    syncop_dir_scan_fn_t fn;
+    uint32_t *jobs_running;
+    uint32_t *qlen;
+    int32_t *retval;
 };
 
 int
-syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
+syncop_dirfd(xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
 {
-        int  ret    = 0;
-        fd_t *dirfd = NULL;
-
-        if (!fd)
-                return -EINVAL;
-
-        dirfd = fd_create (loc->inode, pid);
-        if (!dirfd) {
-                gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                        LG_MSG_FD_CREATE_FAILED, "fd_create of %s",
-                        uuid_utoa (loc->gfid));
-                ret = -errno;
-                goto out;
-        }
-
-        ret = syncop_opendir (subvol, loc, dirfd, NULL, NULL);
-        if (ret) {
+    int ret = 0;
+    fd_t *dirfd = NULL;
+
+    if (!fd)
+        return -EINVAL;
+
+    dirfd = fd_create(loc->inode, pid);
+    if (!dirfd) {
+        gf_msg(subvol->name, GF_LOG_ERROR, errno, LG_MSG_FD_CREATE_FAILED,
+               "fd_create of %s", uuid_utoa(loc->gfid));
+        ret = -errno;
+        goto out;
+    }
+
+    ret = syncop_opendir(subvol, loc, dirfd, NULL, NULL);
+    if (ret) {
         /*
          * On Linux, if the brick was not updated, opendir will
          * fail. We therefore use backward compatible code
@@ -57,93 +56,95 @@ syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
          * to provide backward-compatibility.
          */
 #ifdef GF_LINUX_HOST_OS
-                fd_unref (dirfd);
-                dirfd = fd_anonymous (loc->inode);
-                if (!dirfd) {
-                        gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                                LG_MSG_FD_ANONYMOUS_FAILED, "fd_anonymous of "
-                                "%s", uuid_utoa (loc->gfid));
-                        ret = -errno;
-                        goto out;
-                }
-                ret = 0;
-#else /* GF_LINUX_HOST_OS */
-                fd_unref (dirfd);
-                gf_msg (subvol->name, GF_LOG_ERROR, errno,
-                        LG_MSG_DIR_OP_FAILED, "opendir of %s",
-                        uuid_utoa (loc->gfid));
-                goto out;
-#endif /* GF_LINUX_HOST_OS */
-        } else {
-                fd_bind (dirfd);
+        fd_unref(dirfd);
+        dirfd = fd_anonymous(loc->inode);
+        if (!dirfd) {
+            gf_msg(subvol->name, GF_LOG_ERROR, errno,
+                   LG_MSG_FD_ANONYMOUS_FAILED,
+                   "fd_anonymous of "
+                   "%s",
+                   uuid_utoa(loc->gfid));
+            ret = -errno;
+            goto out;
         }
+        ret = 0;
+#else  /* GF_LINUX_HOST_OS */
+        fd_unref(dirfd);
+        gf_msg(subvol->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+               "opendir of %s", uuid_utoa(loc->gfid));
+        goto out;
+#endif /* GF_LINUX_HOST_OS */
+    } else {
+        fd_bind(dirfd);
+    }
 out:
-        if (ret == 0)
-                *fd = dirfd;
-        return ret;
+    if (ret == 0)
+        *fd = dirfd;
+    return ret;
 }
 
 int
-syncop_ftw (xlator_t *subvol, loc_t *loc, int pid, void *data,
-            int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                       void *data))
+syncop_ftw(xlator_t *subvol, loc_t *loc, int pid, void *data,
+           int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                     void *data))
 {
-        loc_t       child_loc = {0, };
-        fd_t        *fd       = NULL;
-        uint64_t    offset    = 0;
-        gf_dirent_t *entry    = NULL;
-        int         ret       = 0;
-        gf_dirent_t entries;
-
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    loc_t child_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    while ((ret = syncop_readdirp(subvol, fd, 131072, offset, &entries, NULL,
+                                  NULL))) {
+        if (ret < 0)
+            break;
+
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-        INIT_LIST_HEAD (&entries.list);
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
-        while ((ret = syncop_readdirp (subvol, fd, 131072, offset, &entries,
-                                       NULL, NULL))) {
-                if (ret < 0)
-                        break;
+            gf_link_inode_from_dirent(NULL, fd->inode, entry);
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-
-                        gf_link_inode_from_dirent (NULL, fd->inode, entry);
-
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                break;
-
-                        if (entry->d_stat.ia_type == IA_IFDIR) {
-                                child_loc.inode = inode_ref (entry->inode);
-                                gf_uuid_copy (child_loc.gfid, entry->inode->gfid);
-                                ret = syncop_ftw (subvol, &child_loc,
-                                                  pid, data, fn);
-                                loc_wipe (&child_loc);
-                                if (ret)
-                                        break;
-                        }
-                }
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                break;
 
-                gf_dirent_free (&entries);
+            if (entry->d_stat.ia_type == IA_IFDIR) {
+                child_loc.inode = inode_ref(entry->inode);
+                gf_uuid_copy(child_loc.gfid, entry->inode->gfid);
+                ret = syncop_ftw(subvol, &child_loc, pid, data, fn);
+                loc_wipe(&child_loc);
                 if (ret)
-                        break;
+                    break;
+            }
         }
 
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
+
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 /**
@@ -156,402 +157,399 @@ out:
  * syncop_ftw.
  */
 int
-syncop_ftw_throttle (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                     int (*fn) (xlator_t *subvol, gf_dirent_t *entry,
-                                loc_t *parent, void *data),
-                     int count, int sleep_time)
+syncop_ftw_throttle(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                    int (*fn)(xlator_t *subvol, gf_dirent_t *entry,
+                              loc_t *parent, void *data),
+                    int count, int sleep_time)
 {
-        loc_t       child_loc = {0, };
-        fd_t        *fd       = NULL;
-        uint64_t    offset    = 0;
-        gf_dirent_t *entry    = NULL;
-        int         ret       = 0;
-        gf_dirent_t entries;
-        int         tmp       = 0;
-
-        if (sleep_time <= 0) {
-                ret = syncop_ftw (subvol, loc, pid, data, fn);
-                goto out;
-        }
+    loc_t child_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
+    int tmp = 0;
+
+    if (sleep_time <= 0) {
+        ret = syncop_ftw(subvol, loc, pid, data, fn);
+        goto out;
+    }
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    while ((ret = syncop_readdirp(subvol, fd, 131072, offset, &entries, NULL,
+                                  NULL))) {
+        if (ret < 0)
+            break;
 
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-        INIT_LIST_HEAD (&entries.list);
+        tmp = 0;
 
-        while ((ret = syncop_readdirp (subvol, fd, 131072, offset, &entries,
-                                       NULL, NULL))) {
-                if (ret < 0)
-                        break;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
+            if (++tmp >= count) {
                 tmp = 0;
+                sleep(sleep_time);
+            }
 
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-
-                        if (++tmp >= count) {
-                                tmp = 0;
-                                sleep (sleep_time);
-                        }
-
-                        gf_link_inode_from_dirent (NULL, fd->inode, entry);
-
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                continue;
-
-                        if (entry->d_stat.ia_type == IA_IFDIR) {
-                                child_loc.inode = inode_ref (entry->inode);
-                                gf_uuid_copy (child_loc.gfid, entry->inode->gfid);
-                                ret = syncop_ftw_throttle (subvol, &child_loc,
-                                                           pid, data, fn, count,
-                                                           sleep_time);
-                                loc_wipe (&child_loc);
-                                if (ret)
-                                        continue;
-                        }
-                }
+            gf_link_inode_from_dirent(NULL, fd->inode, entry);
+
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                continue;
 
-                gf_dirent_free (&entries);
+            if (entry->d_stat.ia_type == IA_IFDIR) {
+                child_loc.inode = inode_ref(entry->inode);
+                gf_uuid_copy(child_loc.gfid, entry->inode->gfid);
+                ret = syncop_ftw_throttle(subvol, &child_loc, pid, data, fn,
+                                          count, sleep_time);
+                loc_wipe(&child_loc);
                 if (ret)
-                        break;
+                    continue;
+            }
         }
 
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
+
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 static void
-_scan_data_destroy (struct syncop_dir_scan_data *data)
+_scan_data_destroy(struct syncop_dir_scan_data *data)
 {
-        GF_FREE (data);
+    GF_FREE(data);
 }
 
 static int
-_dir_scan_job_fn_cbk (int ret, call_frame_t *frame, void *opaque)
+_dir_scan_job_fn_cbk(int ret, call_frame_t *frame, void *opaque)
 {
-        struct syncop_dir_scan_data *scan_data = opaque;
+    struct syncop_dir_scan_data *scan_data = opaque;
 
-        _scan_data_destroy (scan_data);
-        return 0;
+    _scan_data_destroy(scan_data);
+    return 0;
 }
 
 static int
-_dir_scan_job_fn (void *data)
+_dir_scan_job_fn(void *data)
 {
-        struct syncop_dir_scan_data *scan_data = data;
-        gf_dirent_t                 *entry     = NULL;
-        int                         ret        = 0;
-
-        entry = scan_data->entry;
-        scan_data->entry = NULL;
-        do {
-                ret = scan_data->fn (scan_data->subvol, entry,
-                                     scan_data->parent,
-                                     scan_data->data);
-                gf_dirent_entry_free (entry);
-                entry = NULL;
-                pthread_mutex_lock (scan_data->mut);
-                {
-                        if (ret)
-                                *scan_data->retval |= ret;
-                        if (list_empty (&scan_data->q->list)) {
-                                (*scan_data->jobs_running)--;
-                                pthread_cond_broadcast (scan_data->cond);
-                        } else {
-                                entry = list_first_entry (&scan_data->q->list,
-                                                  typeof (*scan_data->q), list);
-                                list_del_init (&entry->list);
-                                (*scan_data->qlen)--;
-                        }
-                }
-                pthread_mutex_unlock (scan_data->mut);
-        } while (entry);
+    struct syncop_dir_scan_data *scan_data = data;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+
+    entry = scan_data->entry;
+    scan_data->entry = NULL;
+    do {
+        ret = scan_data->fn(scan_data->subvol, entry, scan_data->parent,
+                            scan_data->data);
+        gf_dirent_entry_free(entry);
+        entry = NULL;
+        pthread_mutex_lock(scan_data->mut);
+        {
+            if (ret)
+                *scan_data->retval |= ret;
+            if (list_empty(&scan_data->q->list)) {
+                (*scan_data->jobs_running)--;
+                pthread_cond_broadcast(scan_data->cond);
+            } else {
+                entry = list_first_entry(&scan_data->q->list,
+                                         typeof(*scan_data->q), list);
+                list_del_init(&entry->list);
+                (*scan_data->qlen)--;
+            }
+        }
+        pthread_mutex_unlock(scan_data->mut);
+    } while (entry);
 
-        return ret;
+    return ret;
 }
 
 static int
-_run_dir_scan_task (call_frame_t *frame, xlator_t *subvol, loc_t *parent,
-                    gf_dirent_t *q, gf_dirent_t *entry, int *retval,
-                    pthread_mutex_t *mut, pthread_cond_t *cond,
-                    uint32_t *jobs_running, uint32_t *qlen,
-                    syncop_dir_scan_fn_t fn, void *data)
+_run_dir_scan_task(call_frame_t *frame, xlator_t *subvol, loc_t *parent,
+                   gf_dirent_t *q, gf_dirent_t *entry, int *retval,
+                   pthread_mutex_t *mut, pthread_cond_t *cond,
+                   uint32_t *jobs_running, uint32_t *qlen,
+                   syncop_dir_scan_fn_t fn, void *data)
 {
-        int     ret = 0;
-        struct syncop_dir_scan_data *scan_data = NULL;
-
-
-        scan_data = GF_CALLOC (1, sizeof (struct syncop_dir_scan_data),
-                               gf_common_mt_scan_data);
-        if (!scan_data) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        scan_data->subvol       = subvol;
-        scan_data->parent       = parent;
-        scan_data->data         = data;
-        scan_data->mut          = mut;
-        scan_data->cond         = cond;
-        scan_data->fn           = fn;
-        scan_data->jobs_running = jobs_running;
-        scan_data->entry        = entry;
-        scan_data->q            = q;
-        scan_data->qlen         = qlen;
-        scan_data->retval       = retval;
-
-        ret = synctask_new (subvol->ctx->env, _dir_scan_job_fn,
-                            _dir_scan_job_fn_cbk, frame, scan_data);
+    int ret = 0;
+    struct syncop_dir_scan_data *scan_data = NULL;
+
+    scan_data = GF_CALLOC(1, sizeof(struct syncop_dir_scan_data),
+                          gf_common_mt_scan_data);
+    if (!scan_data) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    scan_data->subvol = subvol;
+    scan_data->parent = parent;
+    scan_data->data = data;
+    scan_data->mut = mut;
+    scan_data->cond = cond;
+    scan_data->fn = fn;
+    scan_data->jobs_running = jobs_running;
+    scan_data->entry = entry;
+    scan_data->q = q;
+    scan_data->qlen = qlen;
+    scan_data->retval = retval;
+
+    ret = synctask_new(subvol->ctx->env, _dir_scan_job_fn, _dir_scan_job_fn_cbk,
+                       frame, scan_data);
 out:
-        if (ret < 0) {
-                gf_dirent_entry_free (entry);
-                _scan_data_destroy (scan_data);
-                pthread_mutex_lock (mut);
-                {
-                        *jobs_running = *jobs_running - 1;
-                }
-                pthread_mutex_unlock (mut);
-                /*No need to cond-broadcast*/
+    if (ret < 0) {
+        gf_dirent_entry_free(entry);
+        _scan_data_destroy(scan_data);
+        pthread_mutex_lock(mut);
+        {
+            *jobs_running = *jobs_running - 1;
         }
-        return ret;
+        pthread_mutex_unlock(mut);
+        /*No need to cond-broadcast*/
+    }
+    return ret;
 }
 
 int
-syncop_mt_dir_scan (call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
-                    void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
-                    uint32_t max_jobs, uint32_t max_qlen)
+syncop_mt_dir_scan(call_frame_t *frame, xlator_t *subvol, loc_t *loc, int pid,
+                   void *data, syncop_dir_scan_fn_t fn, dict_t *xdata,
+                   uint32_t max_jobs, uint32_t max_qlen)
 {
-        fd_t        *fd    = NULL;
-        uint64_t    offset = 0;
-        gf_dirent_t *last = NULL;
-        int         ret    = 0;
-        int         retval = 0;
-        gf_dirent_t q;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t *tmp = NULL;
-        uint32_t    jobs_running = 0;
-        uint32_t    qlen = 0;
-        pthread_cond_t cond;
-        pthread_mutex_t mut;
-        gf_boolean_t cond_init = _gf_false;
-        gf_boolean_t mut_init = _gf_false;
-        gf_dirent_t entries;
-
-        /*For this functionality to be implemented in general, we need
-         * synccond_t infra which doesn't block the executing thread. Until then
-         * return failures inside synctask if they use this.*/
-        if (synctask_get())
-                return -ENOTSUP;
-
-        if (max_jobs == 0)
-                return -EINVAL;
-
-        /*Code becomes simpler this way. cond_wait just on qlength.
-         * Little bit of cheating*/
-        if (max_qlen == 0)
-                max_qlen = 1;
-
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *last = NULL;
+    int ret = 0;
+    int retval = 0;
+    gf_dirent_t q;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    uint32_t jobs_running = 0;
+    uint32_t qlen = 0;
+    pthread_cond_t cond;
+    pthread_mutex_t mut;
+    gf_boolean_t cond_init = _gf_false;
+    gf_boolean_t mut_init = _gf_false;
+    gf_dirent_t entries;
+
+    /*For this functionality to be implemented in general, we need
+     * synccond_t infra which doesn't block the executing thread. Until then
+     * return failures inside synctask if they use this.*/
+    if (synctask_get())
+        return -ENOTSUP;
+
+    if (max_jobs == 0)
+        return -EINVAL;
+
+    /*Code becomes simpler this way. cond_wait just on qlength.
+     * Little bit of cheating*/
+    if (max_qlen == 0)
+        max_qlen = 1;
+
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
+
+    INIT_LIST_HEAD(&entries.list);
+    INIT_LIST_HEAD(&q.list);
+    ret = pthread_mutex_init(&mut, NULL);
+    if (ret)
+        goto out;
+    mut_init = _gf_true;
+
+    ret = pthread_cond_init(&cond, NULL);
+    if (ret)
+        goto out;
+    cond_init = _gf_true;
+
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, xdata,
+                                 NULL))) {
+        if (ret < 0)
+            break;
 
-        INIT_LIST_HEAD (&entries.list);
-        INIT_LIST_HEAD (&q.list);
-        ret = pthread_mutex_init (&mut, NULL);
-        if (ret)
-                goto out;
-        mut_init = _gf_true;
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-        ret = pthread_cond_init (&cond, NULL);
-        if (ret)
-                goto out;
-        cond_init = _gf_true;
+        last = list_last_entry(&entries.list, typeof(*last), list);
+        offset = last->d_off;
 
-        while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      xdata, NULL))) {
-                if (ret < 0)
-                        break;
+        list_for_each_entry_safe(entry, tmp, &entries.list, list)
+        {
+            list_del_init(&entry->list);
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
+                gf_dirent_entry_free(entry);
+                continue;
+            }
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+            if (entry->d_type == IA_IFDIR) {
+                ret = fn(subvol, entry, loc, data);
+                gf_dirent_entry_free(entry);
+                if (ret)
+                    goto out;
+                continue;
+            }
+
+            if (retval) /*Any jobs failed?*/
+                goto out;
 
-                last = list_last_entry (&entries.list, typeof (*last), list);
-                offset = last->d_off;
-
-                list_for_each_entry_safe (entry, tmp, &entries.list, list) {
-                        list_del_init (&entry->list);
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, "..")) {
-                                gf_dirent_entry_free (entry);
-                                continue;
-                        }
-
-                        if (entry->d_type == IA_IFDIR) {
-                                ret = fn (subvol, entry, loc, data);
-                                gf_dirent_entry_free (entry);
-                                if (ret)
-                                        goto out;
-                                continue;
-                        }
-
-                        if (retval) /*Any jobs failed?*/
-                                goto out;
-
-                        pthread_mutex_lock (&mut);
-                        {
-                                while (qlen == max_qlen)
-                                        pthread_cond_wait (&cond, &mut);
-                                if (max_jobs == jobs_running) {
-                                        list_add_tail (&entry->list, &q.list);
-                                        qlen++;
-                                        entry = NULL;
-                                } else {
-                                        jobs_running++;
-                                }
-                        }
-                        pthread_mutex_unlock (&mut);
-
-
-                        if (!entry)
-                                continue;
-
-                        ret = _run_dir_scan_task (frame, subvol, loc, &q, entry,
-                                                  &retval, &mut, &cond,
-                                                &jobs_running, &qlen, fn, data);
-                        if (ret)
-                                goto out;
+            pthread_mutex_lock(&mut);
+            {
+                while (qlen == max_qlen)
+                    pthread_cond_wait(&cond, &mut);
+                if (max_jobs == jobs_running) {
+                    list_add_tail(&entry->list, &q.list);
+                    qlen++;
+                    entry = NULL;
+                } else {
+                    jobs_running++;
                 }
+            }
+            pthread_mutex_unlock(&mut);
+
+            if (!entry)
+                continue;
+
+            ret = _run_dir_scan_task(frame, subvol, loc, &q, entry, &retval,
+                                     &mut, &cond, &jobs_running, &qlen, fn,
+                                     data);
+            if (ret)
+                goto out;
         }
+    }
 
 out:
-        if (fd)
-                fd_unref (fd);
-        if (mut_init && cond_init) {
-                pthread_mutex_lock (&mut);
-                {
-                        while (jobs_running)
-                                pthread_cond_wait (&cond, &mut);
-                }
-                pthread_mutex_unlock (&mut);
-                gf_dirent_free (&q);
-                gf_dirent_free (&entries);
+    if (fd)
+        fd_unref(fd);
+    if (mut_init && cond_init) {
+        pthread_mutex_lock(&mut);
+        {
+            while (jobs_running)
+                pthread_cond_wait(&cond, &mut);
         }
-
-        if (mut_init)
-                pthread_mutex_destroy (&mut);
-        if (cond_init)
-                pthread_cond_destroy (&cond);
-        return ret|retval;
+        pthread_mutex_unlock(&mut);
+        gf_dirent_free(&q);
+        gf_dirent_free(&entries);
+    }
+
+    if (mut_init)
+        pthread_mutex_destroy(&mut);
+    if (cond_init)
+        pthread_cond_destroy(&cond);
+    return ret | retval;
 }
 
 int
-syncop_dir_scan (xlator_t *subvol, loc_t *loc, int pid, void *data,
-                 int (*fn) (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                            void *data))
+syncop_dir_scan(xlator_t *subvol, loc_t *loc, int pid, void *data,
+                int (*fn)(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                          void *data))
 {
-        fd_t        *fd    = NULL;
-        uint64_t    offset = 0;
-        gf_dirent_t *entry = NULL;
-        int         ret    = 0;
-        gf_dirent_t entries;
+    fd_t *fd = NULL;
+    uint64_t offset = 0;
+    gf_dirent_t *entry = NULL;
+    int ret = 0;
+    gf_dirent_t entries;
 
-        ret = syncop_dirfd (subvol, loc, &fd, pid);
-        if (ret)
-                goto out;
+    ret = syncop_dirfd(subvol, loc, &fd, pid);
+    if (ret)
+        goto out;
 
-        INIT_LIST_HEAD (&entries.list);
+    INIT_LIST_HEAD(&entries.list);
 
-        while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      NULL, NULL))) {
-                if (ret < 0)
-                        break;
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, NULL,
+                                 NULL))) {
+        if (ret < 0)
+            break;
 
-                if (ret > 0) {
-                        /* If the entries are only '.', and '..' then ret
-                         * value will be non-zero. so set it to zero here. */
-                        ret = 0;
-                }
+        if (ret > 0) {
+            /* If the entries are only '.', and '..' then ret
+             * value will be non-zero. so set it to zero here. */
+            ret = 0;
+        }
 
-                list_for_each_entry (entry, &entries.list, list) {
-                        offset = entry->d_off;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
 
-                        ret = fn (subvol, entry, loc, data);
-                        if (ret)
-                                break;
-                }
-                gf_dirent_free (&entries);
-                if (ret)
-                        break;
+            ret = fn(subvol, entry, loc, data);
+            if (ret)
+                break;
         }
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
 
 out:
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
 int
-syncop_is_subvol_local (xlator_t *this, loc_t *loc, gf_boolean_t *is_local)
+syncop_is_subvol_local(xlator_t *this, loc_t *loc, gf_boolean_t *is_local)
 {
-        char *pathinfo = NULL;
-        dict_t *xattr = NULL;
-        int ret = 0;
+    char *pathinfo = NULL;
+    dict_t *xattr = NULL;
+    int ret = 0;
 
-        if (!this || !this->type || !is_local)
-                return -EINVAL;
+    if (!this || !this->type || !is_local)
+        return -EINVAL;
 
-        if (strcmp (this->type, "protocol/client") != 0)
-                return -EINVAL;
+    if (strcmp(this->type, "protocol/client") != 0)
+        return -EINVAL;
 
-        *is_local = _gf_false;
+    *is_local = _gf_false;
 
-        ret = syncop_getxattr (this, loc, &xattr, GF_XATTR_PATHINFO_KEY, NULL,
-                               NULL);
-        if (ret < 0) {
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_getxattr(this, loc, &xattr, GF_XATTR_PATHINFO_KEY, NULL, NULL);
+    if (ret < 0) {
+        ret = -1;
+        goto out;
+    }
 
-        if (!xattr) {
-                ret = -EINVAL;
-                goto out;
-        }
+    if (!xattr) {
+        ret = -EINVAL;
+        goto out;
+    }
 
-        ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &pathinfo);
-        if (ret)
-                goto out;
+    ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &pathinfo);
+    if (ret)
+        goto out;
 
-        ret = glusterfs_is_local_pathinfo (pathinfo, is_local);
+    ret = glusterfs_is_local_pathinfo(pathinfo, is_local);
 
-        gf_msg_debug (this->name, 0, "subvol %s is %slocal",
-                this->name, *is_local ? "" : "not ");
+    gf_msg_debug(this->name, 0, "subvol %s is %slocal", this->name,
+                 *is_local ? "" : "not ");
 
 out:
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -565,109 +563,112 @@ out:
  **/
 
 int
-syncop_gfid_to_path_hard (inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
-                          inode_t *inode, char **path_p,
-                          gf_boolean_t hard_resolve)
+syncop_gfid_to_path_hard(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                         inode_t *inode, char **path_p,
+                         gf_boolean_t hard_resolve)
 {
-        int      ret   = 0;
-        char    *path  = NULL;
-        loc_t    loc   = {0,};
-        dict_t  *xattr = NULL;
-
-        gf_uuid_copy (loc.gfid, gfid);
-
-        if (!inode)
-                loc.inode = inode_new (itable);
-        else
-                loc.inode = inode_ref (inode);
-
-        if (!hard_resolve)
-                ret = syncop_getxattr (subvol, &loc, &xattr, GFID_TO_PATH_KEY,
-                                       NULL, NULL);
-        else
-                ret = syncop_getxattr (subvol, &loc, &xattr,
-                                       GFID2PATH_VIRT_XATTR_KEY, NULL, NULL);
-
-        if (ret < 0)
-                goto out;
-
-
-        /*
-         * posix will do dict_set_dynstr for GFID_TO_PATH_KEY i.e.
-         * for in memory search for the path. And for on disk xattr
-         * fetching of the path for the key GFID2PATH_VIRT_XATTR_KEY
-         * it uses dict_set_dynptr. So, for GFID2PATH_VIRT_XATTR_KEY
-         * use dict_get_ptr to avoid dict complaining about type
-         * mismatch (i.e. str vs ptr)
-         */
-        if (!hard_resolve)
-                ret = dict_get_str (xattr, GFID_TO_PATH_KEY, &path);
-        else
-                ret = dict_get_ptr (xattr, GFID2PATH_VIRT_XATTR_KEY,
-                                    (void **)&path);
-
-        if (ret || !path) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        if (path_p) {
-                *path_p = gf_strdup (path);
-                if (!*path_p) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+    int ret = 0;
+    char *path = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    gf_uuid_copy(loc.gfid, gfid);
+
+    if (!inode)
+        loc.inode = inode_new(itable);
+    else
+        loc.inode = inode_ref(inode);
+
+    if (!hard_resolve)
+        ret = syncop_getxattr(subvol, &loc, &xattr, GFID_TO_PATH_KEY, NULL,
+                              NULL);
+    else
+        ret = syncop_getxattr(subvol, &loc, &xattr, GFID2PATH_VIRT_XATTR_KEY,
+                              NULL, NULL);
+
+    if (ret < 0)
+        goto out;
+
+    /*
+     * posix will do dict_set_dynstr for GFID_TO_PATH_KEY i.e.
+     * for in memory search for the path. And for on disk xattr
+     * fetching of the path for the key GFID2PATH_VIRT_XATTR_KEY
+     * it uses dict_set_dynptr. So, for GFID2PATH_VIRT_XATTR_KEY
+     * use dict_get_ptr to avoid dict complaining about type
+     * mismatch (i.e. str vs ptr)
+     */
+    if (!hard_resolve)
+        ret = dict_get_str(xattr, GFID_TO_PATH_KEY, &path);
+    else
+        ret = dict_get_ptr(xattr, GFID2PATH_VIRT_XATTR_KEY, (void **)&path);
+
+    if (ret || !path) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (path_p) {
+        *path_p = gf_strdup(path);
+        if (!*path_p) {
+            ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        loc_wipe (&loc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 int
-syncop_gfid_to_path (inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
-                     char **path_p)
+syncop_gfid_to_path(inode_table_t *itable, xlator_t *subvol, uuid_t gfid,
+                    char **path_p)
 {
-        return syncop_gfid_to_path_hard (itable, subvol, gfid, NULL, path_p,
-                                         _gf_false);
+    return syncop_gfid_to_path_hard(itable, subvol, gfid, NULL, path_p,
+                                    _gf_false);
 }
 
 int
-syncop_inode_find (xlator_t *this, xlator_t *subvol,
-                   uuid_t gfid, inode_t **inode,
-                   dict_t *xdata, dict_t **rsp_dict)
+syncop_inode_find(xlator_t *this, xlator_t *subvol, uuid_t gfid,
+                  inode_t **inode, dict_t *xdata, dict_t **rsp_dict)
 {
-        int         ret    = 0;
-        loc_t       loc    = {0, };
-        struct iatt iatt   = {0, };
-	*inode =  NULL;
-
-        *inode = inode_find (this->itable, gfid);
-        if (*inode)
-                goto out;
-
-        loc.inode = inode_new (this->itable);
-        if (!loc.inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        gf_uuid_copy (loc.gfid, gfid);
-
-	ret = syncop_lookup (subvol, &loc, &iatt, NULL, xdata, rsp_dict);
-        if (ret < 0)
-                goto out;
-
-        *inode = inode_link (loc.inode, NULL, NULL, &iatt);
-        if (!*inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    *inode = NULL;
+
+    *inode = inode_find(this->itable, gfid);
+    if (*inode)
+        goto out;
+
+    loc.inode = inode_new(this->itable);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    gf_uuid_copy(loc.gfid, gfid);
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, xdata, rsp_dict);
+    if (ret < 0)
+        goto out;
+
+    *inode = inode_link(loc.inode, NULL, NULL, &iatt);
+    if (!*inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
 out:
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
diff --git a/libglusterfs/src/syncop.c b/libglusterfs/src/syncop.c
index 8323dd71a10..ec646425d74 100644
--- a/libglusterfs/src/syncop.c
+++ b/libglusterfs/src/syncop.c
@@ -12,2758 +12,2742 @@
 #include "libglusterfs-messages.h"
 
 int
-syncopctx_setfsuid (void *uid)
-{
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
-
-	/* In args check */
-	if (!uid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	opctx = syncopctx_getctx ();
-
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
-
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+syncopctx_setfsuid(void *uid)
+{
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
+
+    /* In args check */
+    if (!uid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    opctx = syncopctx_getctx();
+
+    /* alloc for this thread the first time */
+    if (!opctx) {
+        opctx = GF_CALLOC(1, sizeof(*opctx), gf_common_mt_syncopctx);
+        if (!opctx) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncopctx_setctx(opctx);
+        if (ret != 0) {
+            GF_FREE(opctx);
+            opctx = NULL;
+            goto out;
+        }
+    }
 
 out:
-	if (opctx && uid) {
-		opctx->uid = *(uid_t *)uid;
-		opctx->valid |= SYNCOPCTX_UID;
-	}
+    if (opctx && uid) {
+        opctx->uid = *(uid_t *)uid;
+        opctx->valid |= SYNCOPCTX_UID;
+    }
 
-	return ret;
+    return ret;
 }
 
 int
-syncopctx_setfsgid (void *gid)
+syncopctx_setfsgid(void *gid)
 {
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-	/* In args check */
-	if (!gid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    /* In args check */
+    if (!gid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	opctx = syncopctx_getctx ();
+    opctx = syncopctx_getctx();
 
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
+    /* alloc for this thread the first time */
+    if (!opctx) {
+        opctx = GF_CALLOC(1, sizeof(*opctx), gf_common_mt_syncopctx);
+        if (!opctx) {
+            ret = -1;
+            goto out;
+        }
 
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+        ret = syncopctx_setctx(opctx);
+        if (ret != 0) {
+            GF_FREE(opctx);
+            opctx = NULL;
+            goto out;
+        }
+    }
 
 out:
-	if (opctx && gid) {
-		opctx->gid = *(gid_t *)gid;
-		opctx->valid |= SYNCOPCTX_GID;
-	}
-
-	return ret;
-}
-
-int
-syncopctx_setfsgroups (int count, const void *groups)
-{
-	struct syncopctx *opctx = NULL;
-	gid_t            *tmpgroups = NULL;
-	int               ret = 0;
-
-	/* In args check */
-	if (count != 0 && !groups) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	opctx = syncopctx_getctx ();
-
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
-
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
-
-	/* resize internal groups as required */
-	if (count && opctx->grpsize < count) {
-		if (opctx->groups) {
-			tmpgroups = GF_REALLOC (opctx->groups,
-						(sizeof (gid_t) * count));
-			/* NOTE: Not really required to zero the reallocation,
-			 * as ngrps controls the validity of data,
-			 * making a note irrespective */
-			if (tmpgroups == NULL) {
-				opctx->grpsize = 0;
-				GF_FREE (opctx->groups);
-				opctx->groups = NULL;
-				ret = -1;
-				goto out;
-			}
-		}
-		else {
-			tmpgroups = GF_CALLOC (count, sizeof (gid_t),
-					       gf_common_mt_syncopctx);
-			if (tmpgroups == NULL) {
-				opctx->grpsize = 0;
-				ret = -1;
-				goto out;
-			}
-		}
-
-		opctx->groups = tmpgroups;
-		opctx->grpsize = count;
-	}
-
-	/* copy out the groups passed */
-	if (count)
-		memcpy (opctx->groups, groups, (sizeof (gid_t) * count));
-
-	/* set/reset the ngrps, this is where reset of groups is handled */
-	opctx->ngrps = count;
-	opctx->valid |= SYNCOPCTX_GROUPS;
+    if (opctx && gid) {
+        opctx->gid = *(gid_t *)gid;
+        opctx->valid |= SYNCOPCTX_GID;
+    }
+
+    return ret;
+}
+
+int
+syncopctx_setfsgroups(int count, const void *groups)
+{
+    struct syncopctx *opctx = NULL;
+    gid_t *tmpgroups = NULL;
+    int ret = 0;
+
+    /* In args check */
+    if (count != 0 && !groups) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
+
+    opctx = syncopctx_getctx();
+
+    /* alloc for this thread the first time */
+    if (!opctx) {
+        opctx = GF_CALLOC(1, sizeof(*opctx), gf_common_mt_syncopctx);
+        if (!opctx) {
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncopctx_setctx(opctx);
+        if (ret != 0) {
+            GF_FREE(opctx);
+            opctx = NULL;
+            goto out;
+        }
+    }
+
+    /* resize internal groups as required */
+    if (count && opctx->grpsize < count) {
+        if (opctx->groups) {
+            tmpgroups = GF_REALLOC(opctx->groups, (sizeof(gid_t) * count));
+            /* NOTE: Not really required to zero the reallocation,
+             * as ngrps controls the validity of data,
+             * making a note irrespective */
+            if (tmpgroups == NULL) {
+                opctx->grpsize = 0;
+                GF_FREE(opctx->groups);
+                opctx->groups = NULL;
+                ret = -1;
+                goto out;
+            }
+        } else {
+            tmpgroups = GF_CALLOC(count, sizeof(gid_t), gf_common_mt_syncopctx);
+            if (tmpgroups == NULL) {
+                opctx->grpsize = 0;
+                ret = -1;
+                goto out;
+            }
+        }
+
+        opctx->groups = tmpgroups;
+        opctx->grpsize = count;
+    }
+
+    /* copy out the groups passed */
+    if (count)
+        memcpy(opctx->groups, groups, (sizeof(gid_t) * count));
+
+    /* set/reset the ngrps, this is where reset of groups is handled */
+    opctx->ngrps = count;
+    opctx->valid |= SYNCOPCTX_GROUPS;
 
 out:
-	return ret;
+    return ret;
 }
 
 int
-syncopctx_setfspid (void *pid)
+syncopctx_setfspid(void *pid)
 {
-	struct syncopctx *opctx = NULL;
-	int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-	/* In args check */
-	if (!pid) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
+    /* In args check */
+    if (!pid) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-	opctx = syncopctx_getctx ();
+    opctx = syncopctx_getctx();
 
-	/* alloc for this thread the first time */
-	if (!opctx) {
-		opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-		if (!opctx) {
-			ret = -1;
-			goto out;
-		}
+    /* alloc for this thread the first time */
+    if (!opctx) {
+        opctx = GF_CALLOC(1, sizeof(*opctx), gf_common_mt_syncopctx);
+        if (!opctx) {
+            ret = -1;
+            goto out;
+        }
 
-		ret = syncopctx_setctx (opctx);
-		if (ret != 0) {
-			GF_FREE (opctx);
-			opctx = NULL;
-			goto out;
-		}
-	}
+        ret = syncopctx_setctx(opctx);
+        if (ret != 0) {
+            GF_FREE(opctx);
+            opctx = NULL;
+            goto out;
+        }
+    }
 
 out:
-	if (opctx && pid) {
-		opctx->pid = *(pid_t *)pid;
-		opctx->valid |= SYNCOPCTX_PID;
-	}
+    if (opctx && pid) {
+        opctx->pid = *(pid_t *)pid;
+        opctx->valid |= SYNCOPCTX_PID;
+    }
 
-	return ret;
+    return ret;
 }
 
 int
-syncopctx_setfslkowner (gf_lkowner_t *lk_owner)
+syncopctx_setfslkowner(gf_lkowner_t *lk_owner)
 {
-        struct syncopctx *opctx = NULL;
-        int               ret = 0;
+    struct syncopctx *opctx = NULL;
+    int ret = 0;
 
-        /* In args check */
-        if (!lk_owner) {
-                ret = -1;
-                errno = EINVAL;
-                goto out;
-        }
+    /* In args check */
+    if (!lk_owner) {
+        ret = -1;
+        errno = EINVAL;
+        goto out;
+    }
 
-        opctx = syncopctx_getctx ();
+    opctx = syncopctx_getctx();
 
-        /* alloc for this thread the first time */
+    /* alloc for this thread the first time */
+    if (!opctx) {
+        opctx = GF_CALLOC(1, sizeof(*opctx), gf_common_mt_syncopctx);
         if (!opctx) {
-                opctx = GF_CALLOC (1, sizeof (*opctx), gf_common_mt_syncopctx);
-                if (!opctx) {
-                        ret = -1;
-                        goto out;
-                }
+            ret = -1;
+            goto out;
+        }
 
-                ret = syncopctx_setctx (opctx);
-                if (ret != 0) {
-                        GF_FREE (opctx);
-                        opctx = NULL;
-                        goto out;
-                }
+        ret = syncopctx_setctx(opctx);
+        if (ret != 0) {
+            GF_FREE(opctx);
+            opctx = NULL;
+            goto out;
         }
+    }
 
 out:
-        if (opctx && lk_owner) {
-                opctx->lk_owner = *lk_owner;
-                opctx->valid |= SYNCOPCTX_LKOWNER;
-        }
+    if (opctx && lk_owner) {
+        opctx->lk_owner = *lk_owner;
+        opctx->valid |= SYNCOPCTX_LKOWNER;
+    }
 
-        return ret;
+    return ret;
 }
 
 static void
-__run (struct synctask *task)
+__run(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        list_del_init (&task->all_tasks);
-        switch (task->state) {
+    list_del_init(&task->all_tasks);
+    switch (task->state) {
         case SYNCTASK_INIT:
         case SYNCTASK_SUSPEND:
-                break;
+            break;
         case SYNCTASK_RUN:
-                gf_msg_debug (task->xl->name, 0, "re-running already running"
-                              " task");
-                env->runcount--;
-                break;
+            gf_msg_debug(task->xl->name, 0,
+                         "re-running already running"
+                         " task");
+            env->runcount--;
+            break;
         case SYNCTASK_WAIT:
-                env->waitcount--;
-                break;
+            env->waitcount--;
+            break;
         case SYNCTASK_DONE:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_COMPLETED_TASK, "running completed task");
-		return;
-	case SYNCTASK_ZOMBIE:
-		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_WAKE_UP_ZOMBIE, "attempted to wake up "
-                        "zombie!!");
-		return;
-        }
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_COMPLETED_TASK,
+                   "running completed task");
+            return;
+        case SYNCTASK_ZOMBIE:
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_WAKE_UP_ZOMBIE,
+                   "attempted to wake up "
+                   "zombie!!");
+            return;
+    }
 
-        list_add_tail (&task->all_tasks, &env->runq);
-        env->runcount++;
-        task->state = SYNCTASK_RUN;
+    list_add_tail(&task->all_tasks, &env->runq);
+    env->runcount++;
+    task->state = SYNCTASK_RUN;
 }
 
-
 static void
-__wait (struct synctask *task)
+__wait(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        list_del_init (&task->all_tasks);
-        switch (task->state) {
+    list_del_init(&task->all_tasks);
+    switch (task->state) {
         case SYNCTASK_INIT:
         case SYNCTASK_SUSPEND:
-                break;
+            break;
         case SYNCTASK_RUN:
-                env->runcount--;
-                break;
+            env->runcount--;
+            break;
         case SYNCTASK_WAIT:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_REWAITING_TASK, "re-waiting already waiting "
-                        "task");
-                env->waitcount--;
-                break;
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_REWAITING_TASK,
+                   "re-waiting already waiting "
+                   "task");
+            env->waitcount--;
+            break;
         case SYNCTASK_DONE:
-                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_COMPLETED_TASK,
-                        "running completed task");
-                return;
-	case SYNCTASK_ZOMBIE:
-		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
-                        LG_MSG_SLEEP_ZOMBIE,
-			"attempted to sleep a zombie!!");
-		return;
-        }
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_COMPLETED_TASK,
+                   "running completed task");
+            return;
+        case SYNCTASK_ZOMBIE:
+            gf_msg(task->xl->name, GF_LOG_WARNING, 0, LG_MSG_SLEEP_ZOMBIE,
+                   "attempted to sleep a zombie!!");
+            return;
+    }
 
-        list_add_tail (&task->all_tasks, &env->waitq);
-        env->waitcount++;
-        task->state = SYNCTASK_WAIT;
+    list_add_tail(&task->all_tasks, &env->waitq);
+    env->waitcount++;
+    task->state = SYNCTASK_WAIT;
 }
 
-
 void
-synctask_yield (struct synctask *task)
+synctask_yield(struct synctask *task)
 {
-        xlator_t *oldTHIS = THIS;
+    xlator_t *oldTHIS = THIS;
 
 #if defined(__NetBSD__) && defined(_UC_TLSBASE)
-        /* Preserve pthread private pointer through swapcontex() */
-        task->proc->sched.uc_flags &= ~_UC_TLSBASE;
+    /* Preserve pthread private pointer through swapcontex() */
+    task->proc->sched.uc_flags &= ~_UC_TLSBASE;
 #endif
 
-        if (task->state != SYNCTASK_DONE) {
-                task->state = SYNCTASK_SUSPEND;
-                (void) gf_backtrace_save (task->btbuf);
-        }
-        if (swapcontext (&task->ctx, &task->proc->sched) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_SWAPCONTEXT_FAILED, "swapcontext failed");
-        }
+    if (task->state != SYNCTASK_DONE) {
+        task->state = SYNCTASK_SUSPEND;
+        (void)gf_backtrace_save(task->btbuf);
+    }
+    if (swapcontext(&task->ctx, &task->proc->sched) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_SWAPCONTEXT_FAILED,
+               "swapcontext failed");
+    }
 
-        THIS = oldTHIS;
+    THIS = oldTHIS;
 }
 
-
 void
-synctask_wake (struct synctask *task)
+synctask_wake(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                task->woken = 1;
+    pthread_mutex_lock(&env->mutex);
+    {
+        task->woken = 1;
 
-                if (task->slept)
-                        __run (task);
+        if (task->slept)
+            __run(task);
 
-		pthread_cond_broadcast (&env->cond);
-        }
-        pthread_mutex_unlock (&env->mutex);
+        pthread_cond_broadcast(&env->cond);
+    }
+    pthread_mutex_unlock(&env->mutex);
 }
 
 void
-synctask_wrap (void)
+synctask_wrap(void)
 {
-        struct synctask *task = NULL;
+    struct synctask *task = NULL;
 
-        /* Do not trust the pointer received. It may be
-           wrong and can lead to crashes. */
+    /* Do not trust the pointer received. It may be
+       wrong and can lead to crashes. */
 
-        task = synctask_get ();
-        task->ret = task->syncfn (task->opaque);
-        if (task->synccbk)
-                task->synccbk (task->ret, task->frame, task->opaque);
+    task = synctask_get();
+    task->ret = task->syncfn(task->opaque);
+    if (task->synccbk)
+        task->synccbk(task->ret, task->frame, task->opaque);
 
-        task->state = SYNCTASK_DONE;
+    task->state = SYNCTASK_DONE;
 
-        synctask_yield (task);
+    synctask_yield(task);
 }
 
-
 void
-synctask_destroy (struct synctask *task)
+synctask_destroy(struct synctask *task)
 {
-        if (!task)
-                return;
+    if (!task)
+        return;
 
-        GF_FREE (task->stack);
+    GF_FREE(task->stack);
 
-        if (task->opframe)
-                STACK_DESTROY (task->opframe->root);
+    if (task->opframe)
+        STACK_DESTROY(task->opframe->root);
 
-        if (task->synccbk == NULL) {
-               pthread_mutex_destroy (&task->mutex);
-               pthread_cond_destroy (&task->cond);
-        }
+    if (task->synccbk == NULL) {
+        pthread_mutex_destroy(&task->mutex);
+        pthread_cond_destroy(&task->cond);
+    }
 
-        GF_FREE (task);
+    GF_FREE(task);
 }
 
-
 void
-synctask_done (struct synctask *task)
+synctask_done(struct synctask *task)
 {
-        if (task->synccbk) {
-                synctask_destroy (task);
-                return;
-        }
+    if (task->synccbk) {
+        synctask_destroy(task);
+        return;
+    }
 
-        pthread_mutex_lock (&task->mutex);
-        {
-		task->state = SYNCTASK_ZOMBIE;
-                task->done = 1;
-                pthread_cond_broadcast (&task->cond);
-        }
-        pthread_mutex_unlock (&task->mutex);
+    pthread_mutex_lock(&task->mutex);
+    {
+        task->state = SYNCTASK_ZOMBIE;
+        task->done = 1;
+        pthread_cond_broadcast(&task->cond);
+    }
+    pthread_mutex_unlock(&task->mutex);
 }
 
-
 int
-synctask_setid (struct synctask *task, uid_t uid, gid_t gid)
+synctask_setid(struct synctask *task, uid_t uid, gid_t gid)
 {
-        if (!task)
-                return -1;
+    if (!task)
+        return -1;
 
-        if (uid != -1)
-                task->uid = uid;
+    if (uid != -1)
+        task->uid = uid;
 
-        if (gid != -1)
-                task->gid = gid;
+    if (gid != -1)
+        task->gid = gid;
 
-        return 0;
+    return 0;
 }
 
-
 struct synctask *
-synctask_create (struct syncenv *env, size_t stacksize, synctask_fn_t fn,
-                 synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
+synctask_create(struct syncenv *env, size_t stacksize, synctask_fn_t fn,
+                synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
 {
-        struct synctask *newtask = NULL;
-        xlator_t        *this    = THIS;
-        int             destroymode = 0;
-
-        VALIDATE_OR_GOTO (env, err);
-        VALIDATE_OR_GOTO (fn, err);
-
-        /* Check if the syncenv is in destroymode i.e. destroy is SET.
-         * If YES, then don't allow any new synctasks on it. Return NULL.
-         */
-        pthread_mutex_lock (&env->mutex);
-        {
-                destroymode = env->destroy;
-        }
-        pthread_mutex_unlock (&env->mutex);
-
-        /* syncenv is in DESTROY mode, return from here */
-        if (destroymode)
-                return NULL;
-
-        newtask = GF_CALLOC (1, sizeof (*newtask), gf_common_mt_synctask);
-        if (!newtask)
-                return NULL;
-
-        newtask->frame      = frame;
-        if (!frame) {
-                newtask->opframe = create_frame (this, this->ctx->pool);
-                if (!newtask->opframe)
-                        goto err;
-                set_lk_owner_from_ptr (&newtask->opframe->root->lk_owner,
-                                       newtask->opframe->root);
-        } else {
-                newtask->opframe = copy_frame (frame);
-        }
-        if (!newtask->opframe)
-                goto err;
-        newtask->env        = env;
-        newtask->xl         = this;
-        newtask->syncfn     = fn;
-        newtask->synccbk    = cbk;
-        newtask->opaque     = opaque;
-
-        /* default to the uid/gid of the passed frame */
-        newtask->uid = newtask->opframe->root->uid;
-        newtask->gid = newtask->opframe->root->gid;
-
-        INIT_LIST_HEAD (&newtask->all_tasks);
-        INIT_LIST_HEAD (&newtask->waitq);
-
-        if (getcontext (&newtask->ctx) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_GETCONTEXT_FAILED, "getcontext failed");
-                goto err;
-        }
+    struct synctask *newtask = NULL;
+    xlator_t *this = THIS;
+    int destroymode = 0;
 
-        if (stacksize <= 0) {
-                newtask->stack = GF_CALLOC (1, env->stacksize,
-                                            gf_common_mt_syncstack);
-                newtask->ctx.uc_stack.ss_size = env->stacksize;
-        } else {
-                newtask->stack = GF_CALLOC (1, stacksize,
-                                            gf_common_mt_syncstack);
-                newtask->ctx.uc_stack.ss_size = stacksize;
-        }
-
-        if (!newtask->stack) {
-                goto err;
-        }
-
-        newtask->ctx.uc_stack.ss_sp   = newtask->stack;
-
-        makecontext (&newtask->ctx, (void (*)(void)) synctask_wrap, 0);
-
-        newtask->state = SYNCTASK_INIT;
+    VALIDATE_OR_GOTO(env, err);
+    VALIDATE_OR_GOTO(fn, err);
 
-        newtask->slept = 1;
+    /* Check if the syncenv is in destroymode i.e. destroy is SET.
+     * If YES, then don't allow any new synctasks on it. Return NULL.
+     */
+    pthread_mutex_lock(&env->mutex);
+    {
+        destroymode = env->destroy;
+    }
+    pthread_mutex_unlock(&env->mutex);
 
-        if (!cbk) {
-                pthread_mutex_init (&newtask->mutex, NULL);
-                pthread_cond_init (&newtask->cond, NULL);
-                newtask->done = 0;
-        }
+    /* syncenv is in DESTROY mode, return from here */
+    if (destroymode)
+        return NULL;
 
-        synctask_wake (newtask);
-        /*
-         * Make sure someone's there to execute anything we just put on the
-         * run queue.
-         */
-        syncenv_scale(env);
+    newtask = GF_CALLOC(1, sizeof(*newtask), gf_common_mt_synctask);
+    if (!newtask)
+        return NULL;
 
-	return newtask;
+    newtask->frame = frame;
+    if (!frame) {
+        newtask->opframe = create_frame(this, this->ctx->pool);
+        if (!newtask->opframe)
+            goto err;
+        set_lk_owner_from_ptr(&newtask->opframe->root->lk_owner,
+                              newtask->opframe->root);
+    } else {
+        newtask->opframe = copy_frame(frame);
+    }
+    if (!newtask->opframe)
+        goto err;
+    newtask->env = env;
+    newtask->xl = this;
+    newtask->syncfn = fn;
+    newtask->synccbk = cbk;
+    newtask->opaque = opaque;
+
+    /* default to the uid/gid of the passed frame */
+    newtask->uid = newtask->opframe->root->uid;
+    newtask->gid = newtask->opframe->root->gid;
+
+    INIT_LIST_HEAD(&newtask->all_tasks);
+    INIT_LIST_HEAD(&newtask->waitq);
+
+    if (getcontext(&newtask->ctx) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_GETCONTEXT_FAILED,
+               "getcontext failed");
+        goto err;
+    }
+
+    if (stacksize <= 0) {
+        newtask->stack = GF_CALLOC(1, env->stacksize, gf_common_mt_syncstack);
+        newtask->ctx.uc_stack.ss_size = env->stacksize;
+    } else {
+        newtask->stack = GF_CALLOC(1, stacksize, gf_common_mt_syncstack);
+        newtask->ctx.uc_stack.ss_size = stacksize;
+    }
+
+    if (!newtask->stack) {
+        goto err;
+    }
+
+    newtask->ctx.uc_stack.ss_sp = newtask->stack;
+
+    makecontext(&newtask->ctx, (void (*)(void))synctask_wrap, 0);
+
+    newtask->state = SYNCTASK_INIT;
+
+    newtask->slept = 1;
+
+    if (!cbk) {
+        pthread_mutex_init(&newtask->mutex, NULL);
+        pthread_cond_init(&newtask->cond, NULL);
+        newtask->done = 0;
+    }
+
+    synctask_wake(newtask);
+    /*
+     * Make sure someone's there to execute anything we just put on the
+     * run queue.
+     */
+    syncenv_scale(env);
+
+    return newtask;
 err:
-        if (newtask) {
-                GF_FREE (newtask->stack);
-                if (newtask->opframe)
-                        STACK_DESTROY (newtask->opframe->root);
-                GF_FREE (newtask);
-        }
+    if (newtask) {
+        GF_FREE(newtask->stack);
+        if (newtask->opframe)
+            STACK_DESTROY(newtask->opframe->root);
+        GF_FREE(newtask);
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 int
-synctask_join (struct synctask *task)
+synctask_join(struct synctask *task)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&task->mutex);
-	{
-		while (!task->done)
-			pthread_cond_wait (&task->cond, &task->mutex);
-	}
-	pthread_mutex_unlock (&task->mutex);
+    pthread_mutex_lock(&task->mutex);
+    {
+        while (!task->done)
+            pthread_cond_wait(&task->cond, &task->mutex);
+    }
+    pthread_mutex_unlock(&task->mutex);
 
-	ret = task->ret;
+    ret = task->ret;
 
-	synctask_destroy (task);
+    synctask_destroy(task);
 
-	return ret;
+    return ret;
 }
 
-
 int
-synctask_new1 (struct syncenv *env, size_t stacksize, synctask_fn_t fn,
-                synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
+synctask_new1(struct syncenv *env, size_t stacksize, synctask_fn_t fn,
+              synctask_cbk_t cbk, call_frame_t *frame, void *opaque)
 {
-	struct synctask *newtask = NULL;
-	int              ret = 0;
+    struct synctask *newtask = NULL;
+    int ret = 0;
 
-	newtask = synctask_create (env, stacksize, fn, cbk, frame, opaque);
-	if (!newtask)
-		return -1;
+    newtask = synctask_create(env, stacksize, fn, cbk, frame, opaque);
+    if (!newtask)
+        return -1;
 
-        if (!cbk)
-		ret = synctask_join (newtask);
+    if (!cbk)
+        ret = synctask_join(newtask);
 
-        return ret;
+    return ret;
 }
 
-
 int
-synctask_new (struct syncenv *env, synctask_fn_t fn, synctask_cbk_t cbk,
-              call_frame_t *frame, void *opaque)
+synctask_new(struct syncenv *env, synctask_fn_t fn, synctask_cbk_t cbk,
+             call_frame_t *frame, void *opaque)
 {
-        return synctask_new1 (env, 0, fn, cbk, frame, opaque);
+    return synctask_new1(env, 0, fn, cbk, frame, opaque);
 }
 
 struct synctask *
-syncenv_task (struct syncproc *proc)
-{
-        struct syncenv   *env = NULL;
-        struct synctask  *task = NULL;
-        struct timespec   sleep_till = {0, };
-        int               ret = 0;
-
-        env = proc->env;
-
-        pthread_mutex_lock (&env->mutex);
-        {
-                while (list_empty (&env->runq)) {
-                        sleep_till.tv_sec = time (NULL) + SYNCPROC_IDLE_TIME;
-                        ret = pthread_cond_timedwait (&env->cond, &env->mutex,
-                                                      &sleep_till);
-                        if (!list_empty (&env->runq))
-                                break;
-                        /* If either of the conditions are met then exit
-                         * the current thread:
-                         * 1. syncenv has to scale down(procs > procmin)
-                         * 2. syncenv is in destroy mode and no tasks in
-                         *    either waitq or runq.
-                         *
-                         * At any point in time, a task can be either in runq,
-                         * or in executing state or in the waitq. Once the
-                         * destroy mode is set, no new synctask creates will
-                         * be allowed, but whatever in waitq or runq should be
-                         * allowed to finish before exiting any of the syncenv
-                         * processor threads.
-                         */
-                        if (((ret == ETIMEDOUT) && (env->procs > env->procmin))
-                            || (env->destroy && list_empty (&env->waitq))) {
-                                task = NULL;
-                                env->procs--;
-                                memset (proc, 0, sizeof (*proc));
-                                pthread_cond_broadcast (&env->cond);
-                                goto unlock;
-                        }
-                }
+syncenv_task(struct syncproc *proc)
+{
+    struct syncenv *env = NULL;
+    struct synctask *task = NULL;
+    struct timespec sleep_till = {
+        0,
+    };
+    int ret = 0;
+
+    env = proc->env;
+
+    pthread_mutex_lock(&env->mutex);
+    {
+        while (list_empty(&env->runq)) {
+            sleep_till.tv_sec = time(NULL) + SYNCPROC_IDLE_TIME;
+            ret = pthread_cond_timedwait(&env->cond, &env->mutex, &sleep_till);
+            if (!list_empty(&env->runq))
+                break;
+            /* If either of the conditions are met then exit
+             * the current thread:
+             * 1. syncenv has to scale down(procs > procmin)
+             * 2. syncenv is in destroy mode and no tasks in
+             *    either waitq or runq.
+             *
+             * At any point in time, a task can be either in runq,
+             * or in executing state or in the waitq. Once the
+             * destroy mode is set, no new synctask creates will
+             * be allowed, but whatever in waitq or runq should be
+             * allowed to finish before exiting any of the syncenv
+             * processor threads.
+             */
+            if (((ret == ETIMEDOUT) && (env->procs > env->procmin)) ||
+                (env->destroy && list_empty(&env->waitq))) {
+                task = NULL;
+                env->procs--;
+                memset(proc, 0, sizeof(*proc));
+                pthread_cond_broadcast(&env->cond);
+                goto unlock;
+            }
+        }
 
-                task = list_entry (env->runq.next, struct synctask, all_tasks);
+        task = list_entry(env->runq.next, struct synctask, all_tasks);
 
-                list_del_init (&task->all_tasks);
-                env->runcount--;
+        list_del_init(&task->all_tasks);
+        env->runcount--;
 
-                task->woken = 0;
-                task->slept = 0;
+        task->woken = 0;
+        task->slept = 0;
 
-                task->proc = proc;
-        }
+        task->proc = proc;
+    }
 unlock:
-        pthread_mutex_unlock (&env->mutex);
+    pthread_mutex_unlock(&env->mutex);
 
-        return task;
+    return task;
 }
 
-
 void
-synctask_switchto (struct synctask *task)
+synctask_switchto(struct synctask *task)
 {
-        struct syncenv *env = NULL;
+    struct syncenv *env = NULL;
 
-        env = task->env;
+    env = task->env;
 
-        synctask_set (task);
-        THIS = task->xl;
+    synctask_set(task);
+    THIS = task->xl;
 
 #if defined(__NetBSD__) && defined(_UC_TLSBASE)
-        /* Preserve pthread private pointer through swapcontex() */
-        task->ctx.uc_flags &= ~_UC_TLSBASE;
+    /* Preserve pthread private pointer through swapcontex() */
+    task->ctx.uc_flags &= ~_UC_TLSBASE;
 #endif
 
-        if (swapcontext (&task->proc->sched, &task->ctx) < 0) {
-                gf_msg ("syncop", GF_LOG_ERROR, errno,
-                        LG_MSG_SWAPCONTEXT_FAILED, "swapcontext failed");
-        }
+    if (swapcontext(&task->proc->sched, &task->ctx) < 0) {
+        gf_msg("syncop", GF_LOG_ERROR, errno, LG_MSG_SWAPCONTEXT_FAILED,
+               "swapcontext failed");
+    }
 
-        if (task->state == SYNCTASK_DONE) {
-                synctask_done (task);
-                return;
-        }
+    if (task->state == SYNCTASK_DONE) {
+        synctask_done(task);
+        return;
+    }
 
-        pthread_mutex_lock (&env->mutex);
-        {
-                if (task->woken) {
-                        __run (task);
-                } else {
-                        task->slept = 1;
-                        __wait (task);
-                }
+    pthread_mutex_lock(&env->mutex);
+    {
+        if (task->woken) {
+            __run(task);
+        } else {
+            task->slept = 1;
+            __wait(task);
         }
-        pthread_mutex_unlock (&env->mutex);
+    }
+    pthread_mutex_unlock(&env->mutex);
 }
 
 void *
-syncenv_processor (void *thdata)
+syncenv_processor(void *thdata)
 {
-        struct syncenv  *env = NULL;
-        struct syncproc *proc = NULL;
-        struct synctask *task = NULL;
+    struct syncenv *env = NULL;
+    struct syncproc *proc = NULL;
+    struct synctask *task = NULL;
 
-        proc = thdata;
-        env = proc->env;
+    proc = thdata;
+    env = proc->env;
 
-        for (;;) {
-                task = syncenv_task (proc);
-                if (!task)
-                        break;
+    for (;;) {
+        task = syncenv_task(proc);
+        if (!task)
+            break;
 
-                synctask_switchto (task);
+        synctask_switchto(task);
 
-                syncenv_scale (env);
-        }
+        syncenv_scale(env);
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 void
-syncenv_scale (struct syncenv *env)
-{
-        int  diff = 0;
-        int  scale = 0;
-        int  i = 0;
-        int  ret = 0;
-        char thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        pthread_mutex_lock (&env->mutex);
-        {
-                if (env->procs > env->runcount)
-                        goto unlock;
-
-                scale = env->runcount;
-                if (scale > env->procmax)
-                        scale = env->procmax;
-                if (scale > env->procs)
-                        diff = scale - env->procs;
-                while (diff) {
-                        diff--;
-                        for (; (i < env->procmax); i++) {
-                                if (env->proc[i].processor == 0)
-                                        break;
-                        }
-
-                        env->proc[i].env = env;
-                        snprintf (thread_name, sizeof(thread_name),
-                                  "sproc%03hx", (env->procs & 0x3ff));
-                        ret = gf_thread_create (&env->proc[i].processor, NULL,
-                                                syncenv_processor,
-                                                &env->proc[i], thread_name);
-                        if (ret)
-                                break;
-                        env->procs++;
-                        i++;
-                }
+syncenv_scale(struct syncenv *env)
+{
+    int diff = 0;
+    int scale = 0;
+    int i = 0;
+    int ret = 0;
+    char thread_name[GF_THREAD_NAMEMAX] = {
+        0,
+    };
+
+    pthread_mutex_lock(&env->mutex);
+    {
+        if (env->procs > env->runcount)
+            goto unlock;
+
+        scale = env->runcount;
+        if (scale > env->procmax)
+            scale = env->procmax;
+        if (scale > env->procs)
+            diff = scale - env->procs;
+        while (diff) {
+            diff--;
+            for (; (i < env->procmax); i++) {
+                if (env->proc[i].processor == 0)
+                    break;
+            }
+
+            env->proc[i].env = env;
+            snprintf(thread_name, sizeof(thread_name), "sproc%03hx",
+                     (env->procs & 0x3ff));
+            ret = gf_thread_create(&env->proc[i].processor, NULL,
+                                   syncenv_processor, &env->proc[i],
+                                   thread_name);
+            if (ret)
+                break;
+            env->procs++;
+            i++;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&env->mutex);
+    pthread_mutex_unlock(&env->mutex);
 }
 
 /* The syncenv threads are cleaned up in this routine.
  */
 void
-syncenv_destroy (struct syncenv *env)
-{
-
-        if (env == NULL)
-                return;
-
-        /* SET the 'destroy' in syncenv structure to prohibit any
-         * further synctask(s) on this syncenv which is in destroy mode.
-         *
-         * If syncenv threads are in pthread cond wait with no tasks in
-         * their run or wait queue, then the threads are woken up by
-         * broadcasting the cond variable and if destroy field is set,
-         * the infinite loop in syncenv_processor is broken and the
-         * threads return.
-         *
-         * If syncenv threads have tasks in runq or waitq, the tasks are
-         * completed and only then the thread returns.
+syncenv_destroy(struct syncenv *env)
+{
+    if (env == NULL)
+        return;
+
+    /* SET the 'destroy' in syncenv structure to prohibit any
+     * further synctask(s) on this syncenv which is in destroy mode.
+     *
+     * If syncenv threads are in pthread cond wait with no tasks in
+     * their run or wait queue, then the threads are woken up by
+     * broadcasting the cond variable and if destroy field is set,
+     * the infinite loop in syncenv_processor is broken and the
+     * threads return.
+     *
+     * If syncenv threads have tasks in runq or waitq, the tasks are
+     * completed and only then the thread returns.
+     */
+    pthread_mutex_lock(&env->mutex);
+    {
+        env->destroy = 1;
+        /* This broadcast will wake threads in pthread_cond_wait
+         * in syncenv_task
          */
-        pthread_mutex_lock (&env->mutex);
-        {
-                env->destroy = 1;
-                /* This broadcast will wake threads in pthread_cond_wait
-                 * in syncenv_task
-                 */
-                pthread_cond_broadcast (&env->cond);
-
-                /* when the syncenv_task() thread is exiting, it broadcasts to
-                 * wake the below wait.
-                 */
-                while (env->procs != 0) {
-                        pthread_cond_wait (&env->cond, &env->mutex);
-                }
+        pthread_cond_broadcast(&env->cond);
+
+        /* when the syncenv_task() thread is exiting, it broadcasts to
+         * wake the below wait.
+         */
+        while (env->procs != 0) {
+            pthread_cond_wait(&env->cond, &env->mutex);
         }
-        pthread_mutex_unlock (&env->mutex);
+    }
+    pthread_mutex_unlock(&env->mutex);
 
-        pthread_mutex_destroy (&env->mutex);
-        pthread_cond_destroy (&env->cond);
+    pthread_mutex_destroy(&env->mutex);
+    pthread_cond_destroy(&env->cond);
 
-        GF_FREE (env);
+    GF_FREE(env);
 
-        return;
+    return;
 }
 
-
 struct syncenv *
-syncenv_new (size_t stacksize, int procmin, int procmax)
-{
-        struct syncenv *newenv = NULL;
-        int             ret = 0;
-        int             i = 0;
-        char            thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-	if (!procmin || procmin < 0)
-		procmin = SYNCENV_PROC_MIN;
-	if (!procmax || procmax > SYNCENV_PROC_MAX)
-		procmax = SYNCENV_PROC_MAX;
-
-	if (procmin > procmax)
-		return NULL;
-
-        newenv = GF_CALLOC (1, sizeof (*newenv), gf_common_mt_syncenv);
-
-        if (!newenv)
-                return NULL;
-
-        pthread_mutex_init (&newenv->mutex, NULL);
-        pthread_cond_init (&newenv->cond, NULL);
-
-        INIT_LIST_HEAD (&newenv->runq);
-        INIT_LIST_HEAD (&newenv->waitq);
-
-        newenv->stacksize    = SYNCENV_DEFAULT_STACKSIZE;
-        if (stacksize)
-                newenv->stacksize = stacksize;
-	newenv->procmin = procmin;
-	newenv->procmax = procmax;
-
-        for (i = 0; i < newenv->procmin; i++) {
-                newenv->proc[i].env = newenv;
-                snprintf (thread_name, sizeof(thread_name),
-                          "%s%d", "sproc", (newenv->procs));
-                ret = gf_thread_create (&newenv->proc[i].processor, NULL,
-                                        syncenv_processor, &newenv->proc[i],
-                                        thread_name);
-                if (ret)
-                        break;
-                newenv->procs++;
-        }
+syncenv_new(size_t stacksize, int procmin, int procmax)
+{
+    struct syncenv *newenv = NULL;
+    int ret = 0;
+    int i = 0;
+    char thread_name[GF_THREAD_NAMEMAX] = {
+        0,
+    };
 
-        if (ret != 0) {
-                syncenv_destroy (newenv);
-                newenv = NULL;
-        }
+    if (!procmin || procmin < 0)
+        procmin = SYNCENV_PROC_MIN;
+    if (!procmax || procmax > SYNCENV_PROC_MAX)
+        procmax = SYNCENV_PROC_MAX;
 
-        return newenv;
-}
+    if (procmin > procmax)
+        return NULL;
+
+    newenv = GF_CALLOC(1, sizeof(*newenv), gf_common_mt_syncenv);
+
+    if (!newenv)
+        return NULL;
+
+    pthread_mutex_init(&newenv->mutex, NULL);
+    pthread_cond_init(&newenv->cond, NULL);
+
+    INIT_LIST_HEAD(&newenv->runq);
+    INIT_LIST_HEAD(&newenv->waitq);
 
+    newenv->stacksize = SYNCENV_DEFAULT_STACKSIZE;
+    if (stacksize)
+        newenv->stacksize = stacksize;
+    newenv->procmin = procmin;
+    newenv->procmax = procmax;
+
+    for (i = 0; i < newenv->procmin; i++) {
+        newenv->proc[i].env = newenv;
+        snprintf(thread_name, sizeof(thread_name), "%s%d", "sproc",
+                 (newenv->procs));
+        ret = gf_thread_create(&newenv->proc[i].processor, NULL,
+                               syncenv_processor, &newenv->proc[i],
+                               thread_name);
+        if (ret)
+            break;
+        newenv->procs++;
+    }
+
+    if (ret != 0) {
+        syncenv_destroy(newenv);
+        newenv = NULL;
+    }
+
+    return newenv;
+}
 
 int
-synclock_init (synclock_t *lock, lock_attr_t attr)
+synclock_init(synclock_t *lock, lock_attr_t attr)
 {
-        if (!lock)
-               return -1;
+    if (!lock)
+        return -1;
 
-        pthread_cond_init (&lock->cond, 0);
-        lock->type = LOCK_NULL;
-        lock->owner = NULL;
-        lock->owner_tid = 0;
-        lock->lock = 0;
-        lock->attr = attr;
-        INIT_LIST_HEAD (&lock->waitq);
+    pthread_cond_init(&lock->cond, 0);
+    lock->type = LOCK_NULL;
+    lock->owner = NULL;
+    lock->owner_tid = 0;
+    lock->lock = 0;
+    lock->attr = attr;
+    INIT_LIST_HEAD(&lock->waitq);
 
-        return pthread_mutex_init (&lock->guard, 0);
+    return pthread_mutex_init(&lock->guard, 0);
 }
 
-
 int
-synclock_destroy (synclock_t *lock)
+synclock_destroy(synclock_t *lock)
 {
-	if (!lock)
-		return -1;
+    if (!lock)
+        return -1;
 
-	pthread_cond_destroy (&lock->cond);
-	return pthread_mutex_destroy (&lock->guard);
+    pthread_cond_destroy(&lock->cond);
+    return pthread_mutex_destroy(&lock->guard);
 }
 
-
 static int
-__synclock_lock (struct synclock *lock)
-{
-        struct synctask *task = NULL;
-
-        if (!lock)
-                return -1;
-
-        task = synctask_get ();
-
-        if (lock->lock && (lock->attr == SYNC_LOCK_RECURSIVE)) {
-                /*Recursive lock (if same owner requested for lock again then
-                 *increment lock count and return success).
-                 *Note:same number of unlocks required.
-                 */
-                switch (lock->type) {
-                case LOCK_TASK:
-                        if (task == lock->owner) {
-                                lock->lock++;
-                                gf_msg_trace ("", 0, "Recursive lock called by"
-                                              " sync task.owner= %p,lock=%d",
-                                              lock->owner, lock->lock);
-                                return 0;
-                        }
-                        break;
-                case LOCK_THREAD:
-                        if (pthread_equal(pthread_self (), lock->owner_tid)) {
-                                lock->lock++;
-                                gf_msg_trace ("", 0, "Recursive lock called by"
-                                              " thread ,owner=%u lock=%d",
-                                              (unsigned int) lock->owner_tid,
-                                              lock->lock);
-                                return 0;
-                        }
-                        break;
-                default:
-                        gf_msg ("", GF_LOG_CRITICAL, 0,
-                                LG_MSG_UNKNOWN_LOCK_TYPE, "unknown lock type");
-                        break;
-                }
-        }
+__synclock_lock(struct synclock *lock)
+{
+    struct synctask *task = NULL;
 
+    if (!lock)
+        return -1;
 
-        while (lock->lock) {
-                if (task) {
-                        /* called within a synctask */
-                        task->woken = 0;
-                        list_add_tail (&task->waitq, &lock->waitq);
-                        pthread_mutex_unlock (&lock->guard);
-                        synctask_yield (task);
-                        /* task is removed from waitq in unlock,
-                         * under lock->guard.*/
-                        pthread_mutex_lock (&lock->guard);
-                } else {
-                        /* called by a non-synctask */
-                        pthread_cond_wait (&lock->cond, &lock->guard);
+    task = synctask_get();
+
+    if (lock->lock && (lock->attr == SYNC_LOCK_RECURSIVE)) {
+        /*Recursive lock (if same owner requested for lock again then
+         *increment lock count and return success).
+         *Note:same number of unlocks required.
+         */
+        switch (lock->type) {
+            case LOCK_TASK:
+                if (task == lock->owner) {
+                    lock->lock++;
+                    gf_msg_trace("", 0,
+                                 "Recursive lock called by"
+                                 " sync task.owner= %p,lock=%d",
+                                 lock->owner, lock->lock);
+                    return 0;
+                }
+                break;
+            case LOCK_THREAD:
+                if (pthread_equal(pthread_self(), lock->owner_tid)) {
+                    lock->lock++;
+                    gf_msg_trace("", 0,
+                                 "Recursive lock called by"
+                                 " thread ,owner=%u lock=%d",
+                                 (unsigned int)lock->owner_tid, lock->lock);
+                    return 0;
                 }
+                break;
+            default:
+                gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_UNKNOWN_LOCK_TYPE,
+                       "unknown lock type");
+                break;
         }
+    }
 
+    while (lock->lock) {
         if (task) {
-                lock->type = LOCK_TASK;
-                lock->owner = task;    /* for synctask*/
-
+            /* called within a synctask */
+            task->woken = 0;
+            list_add_tail(&task->waitq, &lock->waitq);
+            pthread_mutex_unlock(&lock->guard);
+            synctask_yield(task);
+            /* task is removed from waitq in unlock,
+             * under lock->guard.*/
+            pthread_mutex_lock(&lock->guard);
         } else {
-                lock->type = LOCK_THREAD;
-                lock->owner_tid = pthread_self (); /* for non-synctask */
-
+            /* called by a non-synctask */
+            pthread_cond_wait(&lock->cond, &lock->guard);
         }
-        lock->lock = 1;
+    }
 
-        return 0;
-}
+    if (task) {
+        lock->type = LOCK_TASK;
+        lock->owner = task; /* for synctask*/
 
+    } else {
+        lock->type = LOCK_THREAD;
+        lock->owner_tid = pthread_self(); /* for non-synctask */
+    }
+    lock->lock = 1;
+
+    return 0;
+}
 
 int
-synclock_lock (synclock_t *lock)
+synclock_lock(synclock_t *lock)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_lock (lock);
-	}
-	pthread_mutex_unlock (&lock->guard);
+    pthread_mutex_lock(&lock->guard);
+    {
+        ret = __synclock_lock(lock);
+    }
+    pthread_mutex_unlock(&lock->guard);
 
-	return ret;
+    return ret;
 }
 
-
 int
-synclock_trylock (synclock_t *lock)
+synclock_trylock(synclock_t *lock)
 {
-	int ret = 0;
+    int ret = 0;
 
-	errno = 0;
+    errno = 0;
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		if (lock->lock) {
-			errno = EBUSY;
-			ret = -1;
-			goto unlock;
-		}
+    pthread_mutex_lock(&lock->guard);
+    {
+        if (lock->lock) {
+            errno = EBUSY;
+            ret = -1;
+            goto unlock;
+        }
 
-		ret = __synclock_lock (lock);
-	}
+        ret = __synclock_lock(lock);
+    }
 unlock:
-	pthread_mutex_unlock (&lock->guard);
+    pthread_mutex_unlock(&lock->guard);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__synclock_unlock (synclock_t *lock)
-{
-        struct synctask *task = NULL;
-        struct synctask *curr = NULL;
-
-        if (!lock)
-               return -1;
-
-        if (lock->lock == 0) {
-                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_UNLOCK_BEFORE_LOCK,
-                        "Unlock called  before lock ");
-                return -1;
-        }
-        curr = synctask_get ();
-        /*unlock should be called by lock owner
-         *i.e this will not allow the lock in nonsync task and unlock
-         * in sync task and vice-versa
-         */
-        switch (lock->type) {
+__synclock_unlock(synclock_t *lock)
+{
+    struct synctask *task = NULL;
+    struct synctask *curr = NULL;
+
+    if (!lock)
+        return -1;
+
+    if (lock->lock == 0) {
+        gf_msg("", GF_LOG_CRITICAL, 0, LG_MSG_UNLOCK_BEFORE_LOCK,
+               "Unlock called  before lock ");
+        return -1;
+    }
+    curr = synctask_get();
+    /*unlock should be called by lock owner
+     *i.e this will not allow the lock in nonsync task and unlock
+     * in sync task and vice-versa
+     */
+    switch (lock->type) {
         case LOCK_TASK:
-                if (curr == lock->owner) {
-                        lock->lock--;
-                        gf_msg_trace ("", 0, "Unlock success %p, remaining"
-                                      " locks=%d", lock->owner, lock->lock);
-                } else {
-                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
-                                "Unlock called by %p, but lock held by %p",
-                                curr, lock->owner);
-                }
-
-                break;
+            if (curr == lock->owner) {
+                lock->lock--;
+                gf_msg_trace("", 0,
+                             "Unlock success %p, remaining"
+                             " locks=%d",
+                             lock->owner, lock->lock);
+            } else {
+                gf_msg("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                       "Unlock called by %p, but lock held by %p", curr,
+                       lock->owner);
+            }
+
+            break;
         case LOCK_THREAD:
-                if (pthread_equal(pthread_self (), lock->owner_tid)) {
-                        lock->lock--;
-                        gf_msg_trace ("", 0, "Unlock success %u, remaining "
-                                      "locks=%d",
-                                      (unsigned int)lock->owner_tid,
-                                      lock->lock);
-                } else {
-                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
-                                "Unlock called by %u, but lock held by %u",
-                                (unsigned int) pthread_self(),
-                                (unsigned int) lock->owner_tid);
-                }
-
-                break;
+            if (pthread_equal(pthread_self(), lock->owner_tid)) {
+                lock->lock--;
+                gf_msg_trace("", 0,
+                             "Unlock success %u, remaining "
+                             "locks=%d",
+                             (unsigned int)lock->owner_tid, lock->lock);
+            } else {
+                gf_msg("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                       "Unlock called by %u, but lock held by %u",
+                       (unsigned int)pthread_self(),
+                       (unsigned int)lock->owner_tid);
+            }
+
+            break;
         default:
-                break;
-        }
-
-        if (lock->lock > 0) {
-                 return 0;
-        }
-        lock->type = LOCK_NULL;
-        lock->owner = NULL;
-        lock->owner_tid = 0;
-        lock->lock = 0;
-        /* There could be both synctasks and non synctasks
-           waiting (or none, or either). As a mid-approach
-           between maintaining too many waiting counters
-           at one extreme and a thundering herd on unlock
-           at the other, call a cond_signal (which wakes
-           one waiter) and first synctask waiter. So at
-           most we have two threads waking up to grab the
-           just released lock.
-        */
-        pthread_cond_signal (&lock->cond);
-        if (!list_empty (&lock->waitq)) {
-                task = list_entry (lock->waitq.next, struct synctask, waitq);
-                list_del_init (&task->waitq);
-                synctask_wake (task);
-        }
+            break;
+    }
 
+    if (lock->lock > 0) {
         return 0;
-}
+    }
+    lock->type = LOCK_NULL;
+    lock->owner = NULL;
+    lock->owner_tid = 0;
+    lock->lock = 0;
+    /* There could be both synctasks and non synctasks
+       waiting (or none, or either). As a mid-approach
+       between maintaining too many waiting counters
+       at one extreme and a thundering herd on unlock
+       at the other, call a cond_signal (which wakes
+       one waiter) and first synctask waiter. So at
+       most we have two threads waking up to grab the
+       just released lock.
+    */
+    pthread_cond_signal(&lock->cond);
+    if (!list_empty(&lock->waitq)) {
+        task = list_entry(lock->waitq.next, struct synctask, waitq);
+        list_del_init(&task->waitq);
+        synctask_wake(task);
+    }
 
+    return 0;
+}
 
 int
-synclock_unlock (synclock_t *lock)
+synclock_unlock(synclock_t *lock)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&lock->guard);
-	{
-		ret = __synclock_unlock (lock);
-	}
-	pthread_mutex_unlock (&lock->guard);
+    pthread_mutex_lock(&lock->guard);
+    {
+        ret = __synclock_unlock(lock);
+    }
+    pthread_mutex_unlock(&lock->guard);
 
-	return ret;
+    return ret;
 }
 
 /* Barriers */
 
 int
-syncbarrier_init (struct syncbarrier *barrier)
+syncbarrier_init(struct syncbarrier *barrier)
 {
-        int ret = 0;
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	ret = pthread_cond_init (&barrier->cond, 0);
-        if (ret) {
-                errno = ret;
-                return -1;
-        }
-	barrier->count = 0;
-        barrier->waitfor = 0;
-	INIT_LIST_HEAD (&barrier->waitq);
-
-	ret = pthread_mutex_init (&barrier->guard, 0);
-        if (ret) {
-                (void)pthread_cond_destroy (&barrier->cond);
-                errno = ret;
-                return -1;
-        }
-        barrier->initialized = _gf_true;
-        return 0;
-}
+    ret = pthread_cond_init(&barrier->cond, 0);
+    if (ret) {
+        errno = ret;
+        return -1;
+    }
+    barrier->count = 0;
+    barrier->waitfor = 0;
+    INIT_LIST_HEAD(&barrier->waitq);
 
+    ret = pthread_mutex_init(&barrier->guard, 0);
+    if (ret) {
+        (void)pthread_cond_destroy(&barrier->cond);
+        errno = ret;
+        return -1;
+    }
+    barrier->initialized = _gf_true;
+    return 0;
+}
 
 int
-syncbarrier_destroy (struct syncbarrier *barrier)
+syncbarrier_destroy(struct syncbarrier *barrier)
 {
-        int ret = 0;
-        int ret1 = 0;
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    int ret = 0;
+    int ret1 = 0;
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-        if (barrier->initialized) {
-                ret = pthread_cond_destroy (&barrier->cond);
-                ret1 = pthread_mutex_destroy (&barrier->guard);
-                barrier->initialized = _gf_false;
-        }
-        if (ret || ret1) {
-                errno = ret?ret:ret1;
-                return -1;
-        }
-        return 0;
+    if (barrier->initialized) {
+        ret = pthread_cond_destroy(&barrier->cond);
+        ret1 = pthread_mutex_destroy(&barrier->guard);
+        barrier->initialized = _gf_false;
+    }
+    if (ret || ret1) {
+        errno = ret ? ret : ret1;
+        return -1;
+    }
+    return 0;
 }
 
-
 static int
-__syncbarrier_wait (struct syncbarrier *barrier, int waitfor)
+__syncbarrier_wait(struct syncbarrier *barrier, int waitfor)
 {
-	struct synctask *task = NULL;
+    struct synctask *task = NULL;
 
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	task = synctask_get ();
+    task = synctask_get();
 
-	while (barrier->count < waitfor) {
-		if (task) {
-			/* called within a synctask */
-			list_add_tail (&task->waitq, &barrier->waitq);
-                        pthread_mutex_unlock (&barrier->guard);
-                        synctask_yield (task);
-                        pthread_mutex_lock (&barrier->guard);
-		} else {
-			/* called by a non-synctask */
-			pthread_cond_wait (&barrier->cond, &barrier->guard);
-		}
-	}
+    while (barrier->count < waitfor) {
+        if (task) {
+            /* called within a synctask */
+            list_add_tail(&task->waitq, &barrier->waitq);
+            pthread_mutex_unlock(&barrier->guard);
+            synctask_yield(task);
+            pthread_mutex_lock(&barrier->guard);
+        } else {
+            /* called by a non-synctask */
+            pthread_cond_wait(&barrier->cond, &barrier->guard);
+        }
+    }
 
-	barrier->count = 0;
+    barrier->count = 0;
 
-	return 0;
+    return 0;
 }
 
-
 int
-syncbarrier_wait (struct syncbarrier *barrier, int waitfor)
+syncbarrier_wait(struct syncbarrier *barrier, int waitfor)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&barrier->guard);
-	{
-		ret = __syncbarrier_wait (barrier, waitfor);
-	}
-	pthread_mutex_unlock (&barrier->guard);
+    pthread_mutex_lock(&barrier->guard);
+    {
+        ret = __syncbarrier_wait(barrier, waitfor);
+    }
+    pthread_mutex_unlock(&barrier->guard);
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__syncbarrier_wake (struct syncbarrier *barrier)
+__syncbarrier_wake(struct syncbarrier *barrier)
 {
-	struct synctask *task = NULL;
+    struct synctask *task = NULL;
 
-	if (!barrier) {
-		errno = EINVAL;
-		return -1;
-	}
+    if (!barrier) {
+        errno = EINVAL;
+        return -1;
+    }
 
-	barrier->count++;
-        if (barrier->waitfor && (barrier->count < barrier->waitfor))
-                return 0;
+    barrier->count++;
+    if (barrier->waitfor && (barrier->count < barrier->waitfor))
+        return 0;
 
-	pthread_cond_signal (&barrier->cond);
-	if (!list_empty (&barrier->waitq)) {
-		task = list_entry (barrier->waitq.next, struct synctask, waitq);
-                list_del_init (&task->waitq);
-		synctask_wake (task);
-	}
-        barrier->waitfor = 0;
+    pthread_cond_signal(&barrier->cond);
+    if (!list_empty(&barrier->waitq)) {
+        task = list_entry(barrier->waitq.next, struct synctask, waitq);
+        list_del_init(&task->waitq);
+        synctask_wake(task);
+    }
+    barrier->waitfor = 0;
 
-	return 0;
+    return 0;
 }
 
-
 int
-syncbarrier_wake (struct syncbarrier *barrier)
+syncbarrier_wake(struct syncbarrier *barrier)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&barrier->guard);
-	{
-		ret = __syncbarrier_wake (barrier);
-	}
-	pthread_mutex_unlock (&barrier->guard);
+    pthread_mutex_lock(&barrier->guard);
+    {
+        ret = __syncbarrier_wake(barrier);
+    }
+    pthread_mutex_unlock(&barrier->guard);
 
-	return ret;
+    return ret;
 }
 
-
 /* FOPS */
 
-
 int
-syncop_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, inode_t *inode,
-                   struct iatt *iatt, dict_t *xdata, struct iatt *parent)
+syncop_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, inode_t *inode, struct iatt *iatt,
+                  dict_t *xdata, struct iatt *parent)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->iatt1  = *iatt;
-                args->iatt2  = *parent;
-        }
+    if (op_ret == 0) {
+        args->iatt1 = *iatt;
+        args->iatt2 = *parent;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_lookup (xlator_t *subvol, loc_t *loc, struct iatt *iatt,
-               struct iatt *parent, dict_t *xdata_in, dict_t **xdata_out)
+syncop_lookup(xlator_t *subvol, loc_t *loc, struct iatt *iatt,
+              struct iatt *parent, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lookup_cbk, subvol->fops->lookup,
-                loc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lookup_cbk, subvol->fops->lookup, loc,
+           xdata_in);
 
-        if (iatt)
-                *iatt = args.iatt1;
-        if (parent)
-                *parent = args.iatt2;
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
+    if (parent)
+        *parent = args.iatt2;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_readdirp_cbk (call_frame_t *frame,
-                     void *cookie,
-                     xlator_t *this,
-                     int32_t op_ret,
-                     int32_t op_errno,
-                     gf_dirent_t *entries, dict_t *xdata)
-{
-        struct syncargs *args = NULL;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t  *tmp = NULL;
-
-        int count = 0;
-
-        args = cookie;
-
-        INIT_LIST_HEAD (&args->entries.list);
-
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-
-
-        if (op_ret >= 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        tmp = entry_copy (entry);
-                        if (!tmp) {
-                                args->op_ret = -1;
-                                args->op_errno = ENOMEM;
-                                gf_dirent_free (&(args->entries));
-                                break;
-                        }
-                        gf_msg_trace (this->name, 0, "adding entry=%s, "
-                                      "count=%d", tmp->d_name, count);
-                        list_add_tail (&tmp->list, &(args->entries.list));
-                        count++;
-                }
-        }
+syncop_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        __wake (args);
+    int count = 0;
 
-        return 0;
+    args = cookie;
+
+    INIT_LIST_HEAD(&args->entries.list);
+
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            tmp = entry_copy(entry);
+            if (!tmp) {
+                args->op_ret = -1;
+                args->op_errno = ENOMEM;
+                gf_dirent_free(&(args->entries));
+                break;
+            }
+            gf_msg_trace(this->name, 0,
+                         "adding entry=%s, "
+                         "count=%d",
+                         tmp->d_name, count);
+            list_add_tail(&tmp->list, &(args->entries.list));
+            count++;
+        }
+    }
+
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_readdirp (xlator_t *subvol,
-                 fd_t *fd,
-                 size_t size,
-                 off_t off,
-                 gf_dirent_t *entries,
-                 dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_readdirp(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+                gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_readdirp_cbk, subvol->fops->readdirp,
-                fd, size, off, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (entries)
-                list_splice_init (&args.entries.list, &entries->list);
-        else
-                gf_dirent_free (&args.entries);
+    SYNCOP(subvol, (&args), syncop_readdirp_cbk, subvol->fops->readdirp, fd,
+           size, off, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (entries)
+        list_splice_init(&args.entries.list, &entries->list);
+    else
+        gf_dirent_free(&args.entries);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_readdir_cbk (call_frame_t *frame,
-                    void *cookie,
-                    xlator_t *this,
-                    int32_t op_ret,
-                    int32_t op_errno,
-                    gf_dirent_t *entries, dict_t *xdata)
-{
-        struct syncargs *args = NULL;
-        gf_dirent_t *entry = NULL;
-        gf_dirent_t  *tmp = NULL;
-
-        int count = 0;
-
-        args = cookie;
-
-        INIT_LIST_HEAD (&args->entries.list);
-
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-
-        if (op_ret >= 0) {
-                list_for_each_entry (entry, &entries->list, list) {
-                        tmp = entry_copy (entry);
-                        if (!tmp) {
-                                args->op_ret = -1;
-                                args->op_errno = ENOMEM;
-                                gf_dirent_free (&(args->entries));
-                                break;
-                        }
-                        gf_msg_trace (this->name, 0, "adding "
-                                      "entry=%s, count=%d", tmp->d_name,
-                                      count);
-                        list_add_tail (&tmp->list, &(args->entries.list));
-                        count++;
-                }
-        }
+syncop_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                   dict_t *xdata)
+{
+    struct syncargs *args = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
 
-        __wake (args);
+    int count = 0;
 
-        return 0;
+    args = cookie;
+
+    INIT_LIST_HEAD(&args->entries.list);
 
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        list_for_each_entry(entry, &entries->list, list)
+        {
+            tmp = entry_copy(entry);
+            if (!tmp) {
+                args->op_ret = -1;
+                args->op_errno = ENOMEM;
+                gf_dirent_free(&(args->entries));
+                break;
+            }
+            gf_msg_trace(this->name, 0,
+                         "adding "
+                         "entry=%s, count=%d",
+                         tmp->d_name, count);
+            list_add_tail(&tmp->list, &(args->entries.list));
+            count++;
+        }
+    }
+
+    __wake(args);
+
+    return 0;
 }
 
 int
-syncop_readdir (xlator_t *subvol,
-                fd_t *fd,
-                size_t size,
-                off_t off,
-                gf_dirent_t *entries,
-		dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_readdir(xlator_t *subvol, fd_t *fd, size_t size, off_t off,
+               gf_dirent_t *entries, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir,
-                fd, size, off, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readdir_cbk, subvol->fops->readdir, fd, size,
+           off, xdata_in);
 
-        if (entries)
-                list_splice_init (&args.entries.list, &entries->list);
-        else
-                gf_dirent_free (&args.entries);
+    if (entries)
+        list_splice_init(&args.entries.list, &entries->list);
+    else
+        gf_dirent_free(&args.entries);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_opendir_cbk (call_frame_t *frame,
-                    void *cookie,
-                    xlator_t *this,
-                    int32_t op_ret,
-                    int32_t op_errno,
-                    fd_t *fd, dict_t *xdata)
+syncop_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_opendir (xlator_t *subvol,
-                loc_t *loc,
-                fd_t *fd,
-		dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_opendir(xlator_t *subvol, loc_t *loc, fd_t *fd, dict_t *xdata_in,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_opendir_cbk, subvol->fops->opendir,
-                loc, fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_opendir_cbk, subvol->fops->opendir, loc, fd,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsyncdir_cbk (call_frame_t *frame, void* cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+syncop_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_fsyncdir (xlator_t *subvol, fd_t *fd, int datasync, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_fsyncdir(xlator_t *subvol, fd_t *fd, int datasync, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fsyncdir_cbk, subvol->fops->fsyncdir,
-                fd, datasync, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fsyncdir_cbk, subvol->fops->fsyncdir, fd,
+           datasync, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
+syncop_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_removexattr (xlator_t *subvol, loc_t *loc, const char *name,
-                    dict_t *xdata_in, dict_t **xdata_out)
+syncop_removexattr(xlator_t *subvol, loc_t *loc, const char *name,
+                   dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_removexattr_cbk,
-                subvol->fops->removexattr, loc, name, xdata_in);
+    SYNCOP(subvol, (&args), syncop_removexattr_cbk, subvol->fops->removexattr,
+           loc, name, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+syncop_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_fremovexattr (xlator_t *subvol, fd_t *fd, const char *name,
-                     dict_t *xdata_in, dict_t **xdata_out)
+syncop_fremovexattr(xlator_t *subvol, fd_t *fd, const char *name,
+                    dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fremovexattr_cbk,
-                subvol->fops->fremovexattr, fd, name, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fremovexattr_cbk, subvol->fops->fremovexattr,
+           fd, name, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
+syncop_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_setxattr (xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
-                 dict_t *xdata_in, dict_t **xdata_out)
+syncop_setxattr(xlator_t *subvol, loc_t *loc, dict_t *dict, int32_t flags,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setxattr_cbk, subvol->fops->setxattr,
-                loc, dict, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setxattr_cbk, subvol->fops->setxattr, loc,
+           dict, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, dict_t *xdata)
+syncop_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_fsetxattr (xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
-		  dict_t *xdata_in, dict_t **xdata_out)
+syncop_fsetxattr(xlator_t *subvol, fd_t *fd, dict_t *dict, int32_t flags,
+                 dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fsetxattr_cbk, subvol->fops->fsetxattr,
-                fd, dict, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fsetxattr_cbk, subvol->fops->fsetxattr, fd,
+           dict, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+syncop_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret >= 0)
-                args->xattr = dict_ref (dict);
+    if (op_ret >= 0)
+        args->xattr = dict_ref(dict);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_listxattr (xlator_t *subvol, loc_t *loc, dict_t **dict, dict_t *xdata_in,
-                  dict_t **xdata_out)
+syncop_listxattr(xlator_t *subvol, loc_t *loc, dict_t **dict, dict_t *xdata_in,
+                 dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr,
-                loc, NULL, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr, loc,
+           NULL, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_getxattr (xlator_t *subvol, loc_t *loc, dict_t **dict, const char *key,
-                 dict_t *xdata_in, dict_t **xdata_out)
+syncop_getxattr(xlator_t *subvol, loc_t *loc, dict_t **dict, const char *key,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr,
-                loc, key, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->getxattr, loc,
+           key, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fgetxattr (xlator_t *subvol, fd_t *fd, dict_t **dict, const char *key,
-                  dict_t *xdata_in, dict_t **xdata_out)
+syncop_fgetxattr(xlator_t *subvol, fd_t *fd, dict_t **dict, const char *key,
+                 dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_getxattr_cbk, subvol->fops->fgetxattr,
-                fd, key, xdata_in);
+    SYNCOP(subvol, (&args), syncop_getxattr_cbk, subvol->fops->fgetxattr, fd,
+           key, xdata_in);
 
-        if (dict)
-                *dict = args.xattr;
-        else if (args.xattr)
-                dict_unref (args.xattr);
+    if (dict)
+        *dict = args.xattr;
+    else if (args.xattr)
+        dict_unref(args.xattr);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno,
-                   struct statvfs *buf, dict_t *xdata)
+syncop_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                  dict_t *xdata)
 
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->statvfs_buf  = *buf;
-        }
+    if (op_ret == 0) {
+        args->statvfs_buf = *buf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_statfs (xlator_t *subvol, loc_t *loc, struct statvfs *buf,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_statfs(xlator_t *subvol, loc_t *loc, struct statvfs *buf,
+              dict_t *xdata_in, dict_t **xdata_out)
 
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_statfs_cbk, subvol->fops->statfs,
-                loc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_statfs_cbk, subvol->fops->statfs, loc,
+           xdata_in);
 
-        if (buf)
-                *buf = args.statvfs_buf;
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (buf)
+        *buf = args.statvfs_buf;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    struct iatt *preop, struct iatt *postop, dict_t *xdata)
+syncop_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, struct iatt *preop,
+                   struct iatt *postop, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0) {
-                args->iatt1  = *preop;
-                args->iatt2  = *postop;
-        }
+    if (op_ret == 0) {
+        args->iatt1 = *preop;
+        args->iatt2 = *postop;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_setattr (xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
-                struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                dict_t **xdata_out)
+syncop_setattr(xlator_t *subvol, loc_t *loc, struct iatt *iatt, int valid,
+               struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setattr_cbk, subvol->fops->setattr,
-                loc, iatt, valid, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setattr_cbk, subvol->fops->setattr, loc,
+           iatt, valid, xdata_in);
 
-        if (preop)
-                *preop = args.iatt1;
-        if (postop)
-                *postop = args.iatt2;
+    if (preop)
+        *preop = args.iatt1;
+    if (postop)
+        *postop = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_fsetattr (xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
-                 struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_fsetattr(xlator_t *subvol, fd_t *fd, struct iatt *iatt, int valid,
+                struct iatt *preop, struct iatt *postop, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setattr_cbk, subvol->fops->fsetattr,
-                fd, iatt, valid, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setattr_cbk, subvol->fops->fsetattr, fd,
+           iatt, valid, xdata_in);
 
-        if (preop)
-                *preop = args.iatt1;
-        if (postop)
-                *postop = args.iatt2;
+    if (preop)
+        *preop = args.iatt1;
+    if (postop)
+        *postop = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int32_t
-syncop_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+syncop_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_open (xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
-	     dict_t *xdata_in, dict_t **xdata_out)
+syncop_open(xlator_t *subvol, loc_t *loc, int32_t flags, fd_t *fd,
+            dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_open_cbk, subvol->fops->open,
-                loc, flags, fd, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    SYNCOP(subvol, (&args), syncop_open_cbk, subvol->fops->open, loc, flags, fd,
+           xdata_in);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int32_t
-syncop_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                  dict_t *xdata)
+syncop_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                 int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                 dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        INIT_LIST_HEAD (&args->entries.list);
+    INIT_LIST_HEAD(&args->entries.list);
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (args->op_ret >= 0) {
-                if (iobref)
-                        args->iobref = iobref_ref (iobref);
-                args->vector = iov_dup (vector, count);
-                args->count  = count;
-                args->iatt1 = *stbuf;
-        }
+    if (args->op_ret >= 0) {
+        if (iobref)
+            args->iobref = iobref_ref(iobref);
+        args->vector = iov_dup(vector, count);
+        args->count = count;
+        args->iatt1 = *stbuf;
+    }
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_readv (xlator_t *subvol, fd_t *fd, size_t size, off_t off,
-              uint32_t flags, struct iovec **vector, int *count,
-              struct iobref **iobref, struct iatt *iatt,
-              dict_t *xdata_in, dict_t **xdata_out)
+syncop_readv(xlator_t *subvol, fd_t *fd, size_t size, off_t off, uint32_t flags,
+             struct iovec **vector, int *count, struct iobref **iobref,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readv_cbk, subvol->fops->readv,
-                fd, size, off, flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readv_cbk, subvol->fops->readv, fd, size,
+           off, flags, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (iatt)
-                *iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                goto out;
+    if (args.op_ret < 0)
+        goto out;
 
-        if (vector)
-                *vector = args.vector;
-        else
-                GF_FREE (args.vector);
+    if (vector)
+        *vector = args.vector;
+    else
+        GF_FREE(args.vector);
 
-        if (count)
-                *count = args.count;
+    if (count)
+        *count = args.count;
 
-        /* Do we need a 'ref' here? */
-        if (iobref)
-                *iobref = args.iobref;
-        else if (args.iobref)
-                iobref_unref (args.iobref);
+    /* Do we need a 'ref' here? */
+    if (iobref)
+        *iobref = args.iobref;
+    else if (args.iobref)
+        iobref_unref(args.iobref);
 
 out:
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+syncop_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret >= 0) {
-                args->iatt1 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_writev (xlator_t *subvol, fd_t *fd, const struct iovec *vector,
-               int32_t count, off_t offset, struct iobref *iobref,
-               uint32_t flags, struct iatt *preiatt, struct iatt *postiatt,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_writev(xlator_t *subvol, fd_t *fd, const struct iovec *vector,
+              int32_t count, off_t offset, struct iobref *iobref,
+              uint32_t flags, struct iatt *preiatt, struct iatt *postiatt,
+              dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_writev_cbk, subvol->fops->writev,
-                fd, (struct iovec *) vector, count, offset, flags, iobref,
-                xdata_in);
+    SYNCOP(subvol, (&args), syncop_writev_cbk, subvol->fops->writev, fd,
+           (struct iovec *)vector, count, offset, flags, iobref, xdata_in);
 
-        if (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-int syncop_write (xlator_t *subvol, fd_t *fd, const char *buf, int size,
-                  off_t offset, struct iobref *iobref, uint32_t flags,
-                  dict_t *xdata_in, dict_t **xdata_out)
+int
+syncop_write(xlator_t *subvol, fd_t *fd, const char *buf, int size,
+             off_t offset, struct iobref *iobref, uint32_t flags,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0,};
-        struct iovec    vec  = {0,};
+    struct syncargs args = {
+        0,
+    };
+    struct iovec vec = {
+        0,
+    };
 
-        vec.iov_len = size;
-        vec.iov_base = (void *)buf;
+    vec.iov_len = size;
+    vec.iov_base = (void *)buf;
 
-        SYNCOP (subvol, (&args), syncop_writev_cbk, subvol->fops->writev,
-                fd, &vec, 1, offset, flags, iobref, xdata_in);
+    SYNCOP(subvol, (&args), syncop_writev_cbk, subvol->fops->writev, fd, &vec,
+           1, offset, flags, iobref, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_close (fd_t *fd)
+syncop_close(fd_t *fd)
 {
-        if (fd)
-                fd_unref (fd);
-        return 0;
+    if (fd)
+        fd_unref(fd);
+    return 0;
 }
 
 int32_t
-syncop_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+syncop_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_create (xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
-               fd_t *fd, struct iatt *iatt,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_create(xlator_t *subvol, loc_t *loc, int32_t flags, mode_t mode,
+              fd_t *fd, struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_create_cbk, subvol->fops->create,
-                loc, flags, mode, 0, fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_create_cbk, subvol->fops->create, loc, flags,
+           mode, 0, fd, xdata_in);
 
-	if (iatt)
-		*iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_put_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, inode_t *inode,
-                struct iatt *buf, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
+syncop_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, inode_t *inode,
+               struct iatt *buf, struct iatt *preparent,
+               struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (buf)
-                args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_put (xlator_t *subvol, loc_t *loc, mode_t mode, mode_t umask,
-            uint32_t flags, struct iovec *vector, int32_t count,
-            off_t offset, struct iobref *iobref, dict_t *xattr,
-            struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_put(xlator_t *subvol, loc_t *loc, mode_t mode, mode_t umask,
+           uint32_t flags, struct iovec *vector, int32_t count, off_t offset,
+           struct iobref *iobref, dict_t *xattr, struct iatt *iatt,
+           dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_put_cbk, subvol->fops->put,
-                loc, mode, umask, flags, (struct iovec *) vector, count,
-                offset, iobref, xattr, xdata_in);
+    SYNCOP(subvol, (&args), syncop_put_cbk, subvol->fops->put, loc, mode, umask,
+           flags, (struct iovec *)vector, count, offset, iobref, xattr,
+           xdata_in);
 
-        if (iatt)
-                *iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+syncop_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *preparent, struct iatt *postparent,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_unlink (xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
-               dict_t **xdata_out)
+syncop_unlink(xlator_t *subvol, loc_t *loc, dict_t *xdata_in,
+              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_unlink_cbk, subvol->fops->unlink, loc,
-                0, xdata_in);
+    SYNCOP(subvol, (&args), syncop_unlink_cbk, subvol->fops->unlink, loc, 0,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+syncop_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *preparent, struct iatt *postparent,
+                 dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_rmdir (xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_rmdir(xlator_t *subvol, loc_t *loc, int flags, dict_t *xdata_in,
+             dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_rmdir_cbk, subvol->fops->rmdir, loc,
-                flags, xdata_in);
+    SYNCOP(subvol, (&args), syncop_rmdir_cbk, subvol->fops->rmdir, loc, flags,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+syncop_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (buf)
-                args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_link (xlator_t *subvol, loc_t *oldloc, loc_t *newloc, struct iatt *iatt,
-             dict_t *xdata_in, dict_t **xdata_out)
+syncop_link(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, struct iatt *iatt,
+            dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_link_cbk, subvol->fops->link,
-                oldloc, newloc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_link_cbk, subvol->fops->link, oldloc, newloc,
+           xdata_in);
 
-        if (iatt)
-                *iatt = args.iatt1;
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
-
 int
-syncop_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                   struct iatt *preoldparent, struct iatt *postoldparent,
-                   struct iatt *prenewparent, struct iatt *postnewparent,
-                   dict_t *xdata)
+syncop_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  struct iatt *preoldparent, struct iatt *postoldparent,
+                  struct iatt *prenewparent, struct iatt *postnewparent,
+                  dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_rename (xlator_t *subvol, loc_t *oldloc, loc_t *newloc,
-               dict_t *xdata_in, dict_t **xdata_out)
+syncop_rename(xlator_t *subvol, loc_t *oldloc, loc_t *newloc, dict_t *xdata_in,
+              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_rename_cbk, subvol->fops->rename,
-                oldloc, newloc, xdata_in);
+    SYNCOP(subvol, (&args), syncop_rename_cbk, subvol->fops->rename, oldloc,
+           newloc, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
-
 int
-syncop_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+syncop_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret >= 0) {
-                args->iatt1 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_ftruncate (xlator_t *subvol, fd_t *fd, off_t offset,
-                  struct iatt *preiatt, struct iatt *postiatt,
-                  dict_t *xdata_in, dict_t **xdata_out)
+syncop_ftruncate(xlator_t *subvol, fd_t *fd, off_t offset, struct iatt *preiatt,
+                 struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate,
-                fd, offset, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ftruncate_cbk, subvol->fops->ftruncate, fd,
+           offset, xdata_in);
 
-        if (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_truncate (xlator_t *subvol, loc_t *loc, off_t offset, dict_t *xdata_in,
-                 dict_t **xdata_out)
+syncop_truncate(xlator_t *subvol, loc_t *loc, off_t offset, dict_t *xdata_in,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ftruncate_cbk, subvol->fops->truncate,
-                loc, offset, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ftruncate_cbk, subvol->fops->truncate, loc,
+           offset, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno,
-                  struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+syncop_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                 struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret >= 0) {
-                args->iatt1 = *prebuf;
-                args->iatt2 = *postbuf;
-        }
+    if (op_ret >= 0) {
+        args->iatt1 = *prebuf;
+        args->iatt2 = *postbuf;
+    }
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_fsync (xlator_t *subvol, fd_t *fd, int dataonly, struct iatt *preiatt,
-              struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_fsync(xlator_t *subvol, fd_t *fd, int dataonly, struct iatt *preiatt,
+             struct iatt *postiatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_fsync_cbk, subvol->fops->fsync,
-                fd, dataonly, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (preiatt)
-                *preiatt = args.iatt1;
-        if (postiatt)
-                *postiatt = args.iatt2;
+    SYNCOP(subvol, (&args), syncop_fsync_cbk, subvol->fops->fsync, fd, dataonly,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (preiatt)
+        *preiatt = args.iatt1;
+    if (postiatt)
+        *postiatt = args.iatt2;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_flush (xlator_t *subvol, fd_t *fd, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_flush(xlator_t *subvol, fd_t *fd, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0};
+    struct syncargs args = {0};
 
-        SYNCOP (subvol, (&args), syncop_flush_cbk, subvol->fops->flush,
-                fd, xdata_in);
+    SYNCOP(subvol, (&args), syncop_flush_cbk, subvol->fops->flush, fd,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
-
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                  dict_t *xdata)
+syncop_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                 dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if (op_ret == 0)
-                args->iatt1 = *stbuf;
+    if (op_ret == 0)
+        args->iatt1 = *stbuf;
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_fstat (xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
-              dict_t **xdata_out)
+syncop_fstat(xlator_t *subvol, fd_t *fd, struct iatt *stbuf, dict_t *xdata_in,
+             dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_fstat_cbk, subvol->fops->fstat,
-                fd, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (stbuf)
-                *stbuf = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_fstat_cbk, subvol->fops->fstat, fd,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (stbuf)
+        *stbuf = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_stat (xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
-             dict_t **xdata_out)
+syncop_stat(xlator_t *subvol, loc_t *loc, struct iatt *stbuf, dict_t *xdata_in,
+            dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_fstat_cbk, subvol->fops->stat,
-                loc, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (stbuf)
-                *stbuf = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_fstat_cbk, subvol->fops->stat, loc,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (stbuf)
+        *stbuf = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+syncop_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_symlink (xlator_t *subvol, loc_t *loc, const char *newpath,
-                struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_symlink(xlator_t *subvol, loc_t *loc, const char *newpath,
+               struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_symlink_cbk, subvol->fops->symlink,
-                newpath, loc, 0, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-	if (iatt)
-		*iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_symlink_cbk, subvol->fops->symlink, newpath,
+           loc, 0, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, const char *path,
-                     struct iatt *stbuf, dict_t *xdata)
+syncop_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, const char *path,
+                    struct iatt *stbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        if ((op_ret != -1) && path)
-                args->buffer = gf_strdup (path);
+    if ((op_ret != -1) && path)
+        args->buffer = gf_strdup(path);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_readlink (xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
-		 dict_t *xdata_in, dict_t **xdata_out)
+syncop_readlink(xlator_t *subvol, loc_t *loc, char **buffer, size_t size,
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_readlink_cbk, subvol->fops->readlink,
-                loc, size, xdata_in);
+    SYNCOP(subvol, (&args), syncop_readlink_cbk, subvol->fops->readlink, loc,
+           size, xdata_in);
 
-        if (buffer)
-                *buffer = args.buffer;
-        else GF_FREE (args.buffer);
+    if (buffer)
+        *buffer = args.buffer;
+    else
+        GF_FREE(args.buffer);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+syncop_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_mknod (xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
-              struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
+syncop_mknod(xlator_t *subvol, loc_t *loc, mode_t mode, dev_t rdev,
+             struct iatt *iatt, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod,
-                loc, mode, rdev, 0, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-	if (iatt)
-		*iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_mknod_cbk, subvol->fops->mknod, loc, mode,
+           rdev, 0, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+syncop_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-syncop_mkdir (xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
-              dict_t *xdata_in, dict_t **xdata_out)
+syncop_mkdir(xlator_t *subvol, loc_t *loc, mode_t mode, struct iatt *iatt,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_mkdir_cbk, subvol->fops->mkdir,
-                loc, mode, 0, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-	if (iatt)
-		*iatt = args.iatt1;
+    SYNCOP(subvol, (&args), syncop_mkdir_cbk, subvol->fops->mkdir, loc, mode, 0,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (iatt)
+        *iatt = args.iatt1;
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 /* posix_acl xlator will respond in different ways for access calls from
@@ -2782,659 +2766,674 @@ syncop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
    got is the mode of the access.
 */
 int
-syncop_access (xlator_t *subvol, loc_t *loc, int32_t mask, dict_t *xdata_in,
-               dict_t **xdata_out)
+syncop_access(xlator_t *subvol, loc_t *loc, int32_t mask, dict_t *xdata_in,
+              dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_access_cbk, subvol->fops->access,
-                loc, mask, xdata_in);
+    SYNCOP(subvol, (&args), syncop_access_cbk, subvol->fops->access, loc, mask,
+           xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_errno;
 }
 
-
 int
-syncop_fallocate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+syncop_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-	struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-	return 0;
+    return 0;
 }
 
 int
 syncop_fallocate(xlator_t *subvol, fd_t *fd, int32_t keep_size, off_t offset,
-		 size_t len, dict_t *xdata_in, dict_t **xdata_out)
+                 size_t len, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_fallocate_cbk, subvol->fops->fallocate,
-                fd, keep_size, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_fallocate_cbk, subvol->fops->fallocate, fd,
+           keep_size, offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_discard_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
+syncop_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-	struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-	return 0;
+    return 0;
 }
 
 int
 syncop_discard(xlator_t *subvol, fd_t *fd, off_t offset, size_t len,
-	       dict_t *xdata_in, dict_t **xdata_out)
+               dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_discard_cbk, subvol->fops->discard,
-                fd, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_discard_cbk, subvol->fops->discard, fd,
+           offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_zerofill_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+syncop_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                     int op_ret, int op_errno, struct iatt *prebuf,
                     struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
 syncop_zerofill(xlator_t *subvol, fd_t *fd, off_t offset, off_t len,
-		dict_t *xdata_in, dict_t **xdata_out)
+                dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_zerofill_cbk, subvol->fops->zerofill,
-                fd, offset, len, xdata_in);
+    SYNCOP(subvol, (&args), syncop_zerofill_cbk, subvol->fops->zerofill, fd,
+           offset, len, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
-
 int
-syncop_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, dict_t *xdata)
+syncop_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_ipc (xlator_t *subvol, int32_t op, dict_t *xdata_in, dict_t **xdata_out)
+syncop_ipc(xlator_t *subvol, int32_t op, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_ipc_cbk, subvol->fops->ipc,
-                op, xdata_in);
+    SYNCOP(subvol, (&args), syncop_ipc_cbk, subvol->fops->ipc, op, xdata_in);
 
-        if (args.xdata) {
-                if (xdata_out) {
-                        /*
-                         * We're passing this reference to the caller, along
-                         * with the pointer itself.  That means they're
-                         * responsible for calling dict_unref at some point.
-                         */
-                        *xdata_out = args.xdata;
-                } else {
-                        dict_unref(args.xdata);
-                }
+    if (args.xdata) {
+        if (xdata_out) {
+            /*
+             * We're passing this reference to the caller, along
+             * with the pointer itself.  That means they're
+             * responsible for calling dict_unref at some point.
+             */
+            *xdata_out = args.xdata;
+        } else {
+            dict_unref(args.xdata);
         }
+    }
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, off_t offset, dict_t *xdata)
+syncop_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, off_t offset, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        args->offset   = offset;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    args->offset = offset;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_seek (xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
-             dict_t *xdata_in, off_t *off)
+syncop_seek(xlator_t *subvol, fd_t *fd, off_t offset, gf_seek_what_t what,
+            dict_t *xdata_in, off_t *off)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_seek_cbk, subvol->fops->seek, fd,
-                offset, what, xdata_in);
+    SYNCOP(subvol, (&args), syncop_seek_cbk, subvol->fops->seek, fd, offset,
+           what, xdata_in);
 
-        if (*off)
-                *off = args.offset;
+    if (*off)
+        *off = args.offset;
 
-        if (args.op_ret == -1)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret == -1)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, struct gf_lease *lease, dict_t *xdata)
+syncop_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-        if (lease)
-                args->lease = *lease;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    if (lease)
+        args->lease = *lease;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_lease (xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
-              dict_t *xdata_in, dict_t **xdata_out)
+syncop_lease(xlator_t *subvol, loc_t *loc, struct gf_lease *lease,
+             dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lease_cbk, subvol->fops->lease,
-                loc, lease, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lease_cbk, subvol->fops->lease, loc, lease,
+           xdata_in);
 
-        *lease = args.lease;
+    *lease = args.lease;
 
-        if (args.xdata) {
-                if (xdata_out) {
-                        /*
-                         * We're passing this reference to the caller, along
-                         * with the pointer itself.  That means they're
-                         * responsible for calling dict_unref at some point.
-                         */
-                        *xdata_out = args.xdata;
-                } else {
-                        dict_unref(args.xdata);
-                }
+    if (args.xdata) {
+        if (xdata_out) {
+            /*
+             * We're passing this reference to the caller, along
+             * with the pointer itself.  That means they're
+             * responsible for calling dict_unref at some point.
+             */
+            *xdata_out = args.xdata;
+        } else {
+            dict_unref(args.xdata);
         }
+    }
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-	       int op_ret, int op_errno, struct gf_flock *flock,
-	       dict_t *xdata)
+syncop_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct gf_flock *flock, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (flock)
-		args->flock = *flock;
-        __wake (args);
+    if (flock)
+        args->flock = *flock;
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_lk (xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
-	   dict_t *xdata_in, dict_t **xdata_out)
+syncop_lk(xlator_t *subvol, fd_t *fd, int cmd, struct gf_flock *flock,
+          dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_lk_cbk, subvol->fops->lk,
-                fd, cmd, flock, xdata_in);
+    SYNCOP(subvol, (&args), syncop_lk_cbk, subvol->fops->lk, fd, cmd, flock,
+           xdata_in);
 
-	*flock = args.flock;
+    *flock = args.flock;
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
+    return args.op_ret;
 }
 
 int32_t
-syncop_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_inodelk (xlator_t *subvol, const char *volume, loc_t *loc, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata_in, dict_t **xdata_out)
+syncop_inodelk(xlator_t *subvol, const char *volume, loc_t *loc, int32_t cmd,
+               struct gf_flock *lock, dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_inodelk_cbk, subvol->fops->inodelk,
-                volume, loc, cmd, lock, xdata_in);
+    SYNCOP(subvol, (&args), syncop_inodelk_cbk, subvol->fops->inodelk, volume,
+           loc, cmd, lock, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
 int32_t
-syncop_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
-        args->op_ret = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata = dict_ref (xdata);
+    args = cookie;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
-        return 0;
+    __wake(args);
+    return 0;
 }
 
 int
-syncop_entrylk (xlator_t *subvol, const char *volume, loc_t *loc,
-                const char *basename, entrylk_cmd cmd, entrylk_type type,
-                dict_t *xdata_in, dict_t **xdata_out)
+syncop_entrylk(xlator_t *subvol, const char *volume, loc_t *loc,
+               const char *basename, entrylk_cmd cmd, entrylk_type type,
+               dict_t *xdata_in, dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_entrylk_cbk, subvol->fops->entrylk,
-                volume, loc, basename, cmd, type, xdata_in);
+    SYNCOP(subvol, (&args), syncop_entrylk_cbk, subvol->fops->entrylk, volume,
+           loc, basename, cmd, type, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
 int32_t
-syncop_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *dict,
-                    dict_t *xdata)
+syncop_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *dict,
+                   dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-
-        args = cookie;
+    struct syncargs *args = NULL;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
-        if (dict)
-                args->dict_out = dict_ref (dict);
+    args = cookie;
 
-        __wake (args);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
+    if (dict)
+        args->dict_out = dict_ref(dict);
 
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_xattrop (xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
-                dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
-                dict_t **xdata_out)
+syncop_xattrop(xlator_t *subvol, loc_t *loc, gf_xattrop_flags_t flags,
+               dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+               dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_xattrop_cbk, subvol->fops->xattrop,
-                loc, flags, dict, xdata_in);
+    SYNCOP(subvol, (&args), syncop_xattrop_cbk, subvol->fops->xattrop, loc,
+           flags, dict, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (dict_out)
-                *dict_out = args.dict_out;
-        else if (args.dict_out)
-                dict_unref (args.dict_out);
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
 int
-syncop_fxattrop (xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
-                 dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
-                 dict_t **xdata_out)
+syncop_fxattrop(xlator_t *subvol, fd_t *fd, gf_xattrop_flags_t flags,
+                dict_t *dict, dict_t *xdata_in, dict_t **dict_out,
+                dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_xattrop_cbk, subvol->fops->fxattrop,
-                fd, flags, dict, xdata_in);
+    SYNCOP(subvol, (&args), syncop_xattrop_cbk, subvol->fops->fxattrop, fd,
+           flags, dict, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (dict_out)
-                *dict_out = args.dict_out;
-        else if (args.dict_out)
-                dict_unref (args.dict_out);
+    if (dict_out)
+        *dict_out = args.dict_out;
+    else if (args.dict_out)
+        dict_unref(args.dict_out);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
-        return args.op_ret;
+    return args.op_ret;
 }
 
 int32_t
-syncop_getactivelk_cbk (call_frame_t *frame,
-                         void *cookie,
-                         xlator_t *this,
-                         int32_t op_ret,
-                         int32_t op_errno,
-                         lock_migration_info_t *locklist, dict_t *xdata)
+syncop_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno,
+                       lock_migration_info_t *locklist, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-        lock_migration_info_t   *tmp = NULL;
-        lock_migration_info_t   *entry = NULL;
-
-        args = cookie;
+    struct syncargs *args = NULL;
+    lock_migration_info_t *tmp = NULL;
+    lock_migration_info_t *entry = NULL;
 
-        INIT_LIST_HEAD (&args->locklist.list);
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    INIT_LIST_HEAD(&args->locklist.list);
 
-        if (op_ret > 0) {
-                list_for_each_entry (tmp, &locklist->list, list) {
-                        entry = GF_CALLOC (1, sizeof (lock_migration_info_t),
-                                          gf_common_mt_char);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-                        if (!entry) {
-                                gf_msg (THIS->name, GF_LOG_ERROR, 0, 0,
-                                        "lock mem allocation  failed");
-                                gf_free_mig_locks (&args->locklist);
+    if (op_ret > 0) {
+        list_for_each_entry(tmp, &locklist->list, list)
+        {
+            entry = GF_CALLOC(1, sizeof(lock_migration_info_t),
+                              gf_common_mt_char);
 
-                                break;
-                        }
+            if (!entry) {
+                gf_msg(THIS->name, GF_LOG_ERROR, 0, 0,
+                       "lock mem allocation  failed");
+                gf_free_mig_locks(&args->locklist);
 
-                        INIT_LIST_HEAD (&entry->list);
+                break;
+            }
 
-                        entry->flock = tmp->flock;
+            INIT_LIST_HEAD(&entry->list);
 
-                        entry->lk_flags = tmp->lk_flags;
+            entry->flock = tmp->flock;
 
-                        entry->client_uid = gf_strdup (tmp->client_uid);
+            entry->lk_flags = tmp->lk_flags;
 
-                        list_add_tail (&entry->list, &args->locklist.list);
+            entry->client_uid = gf_strdup(tmp->client_uid);
 
-                }
+            list_add_tail(&entry->list, &args->locklist.list);
         }
+    }
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_getactivelk (xlator_t *subvol, loc_t *loc,
-                    lock_migration_info_t *locklist,  dict_t *xdata_in,
-                    dict_t **xdata_out)
+syncop_getactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
-
-        SYNCOP (subvol, (&args), syncop_getactivelk_cbk,
-                subvol->fops->getactivelk,
-                loc, xdata_in);
+    struct syncargs args = {
+        0,
+    };
 
-        if (locklist)
-                list_splice_init (&args.locklist.list, &locklist->list);
-        else
-                gf_free_mig_locks (&args.locklist) ;
+    SYNCOP(subvol, (&args), syncop_getactivelk_cbk, subvol->fops->getactivelk,
+           loc, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (locklist)
+        list_splice_init(&args.locklist.list, &locklist->list);
+    else
+        gf_free_mig_locks(&args.locklist);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
+    return args.op_ret;
 }
 
 int
-syncop_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+syncop_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
-
-        args = cookie;
+    struct syncargs *args = NULL;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
+    args = cookie;
 
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
 
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
-
-        return 0;
+    __wake(args);
 
+    return 0;
 }
 
 int
-syncop_setactivelk (xlator_t *subvol, loc_t *loc,
-                     lock_migration_info_t *locklist,  dict_t *xdata_in,
-                     dict_t **xdata_out)
+syncop_setactivelk(xlator_t *subvol, loc_t *loc,
+                   lock_migration_info_t *locklist, dict_t *xdata_in,
+                   dict_t **xdata_out)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_setactivelk_cbk,
-                subvol->fops->setactivelk,
-                loc, locklist, xdata_in);
+    SYNCOP(subvol, (&args), syncop_setactivelk_cbk, subvol->fops->setactivelk,
+           loc, locklist, xdata_in);
 
-        if (xdata_out)
-                *xdata_out = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata_out)
+        *xdata_out = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        if (args.op_ret < 0)
-                return -args.op_errno;
-
-        return args.op_ret;
+    if (args.op_ret < 0)
+        return -args.op_errno;
 
+    return args.op_ret;
 }
 
 int
-syncop_icreate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+syncop_icreate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, inode_t *inode,
                    struct iatt *buf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-	if (buf)
-		args->iatt1 = *buf;
+    if (buf)
+        args->iatt1 = *buf;
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_namelink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+syncop_namelink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
 {
-        struct syncargs *args = NULL;
+    struct syncargs *args = NULL;
 
-        args = cookie;
+    args = cookie;
 
-        args->op_ret   = op_ret;
-        args->op_errno = op_errno;
+    args->op_ret = op_ret;
+    args->op_errno = op_errno;
 
-        if (xdata)
-                args->xdata  = dict_ref (xdata);
+    if (xdata)
+        args->xdata = dict_ref(xdata);
 
-        __wake (args);
+    __wake(args);
 
-        return 0;
+    return 0;
 }
 
 int
-syncop_icreate (xlator_t *subvol, loc_t *loc, mode_t mode, dict_t *xdata)
+syncop_icreate(xlator_t *subvol, loc_t *loc, mode_t mode, dict_t *xdata)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_icreate_cbk, subvol->fops->icreate,
-                loc, mode, xdata);
+    SYNCOP(subvol, (&args), syncop_icreate_cbk, subvol->fops->icreate, loc,
+           mode, xdata);
 
-        if (xdata)
-                xdata = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata)
+        xdata = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        errno = args.op_errno;
-        return args.op_ret;
+    errno = args.op_errno;
+    return args.op_ret;
 }
 
 int
-syncop_namelink (xlator_t *subvol, loc_t *loc, dict_t *xdata)
+syncop_namelink(xlator_t *subvol, loc_t *loc, dict_t *xdata)
 {
-        struct syncargs args = {0, };
+    struct syncargs args = {
+        0,
+    };
 
-        SYNCOP (subvol, (&args), syncop_namelink_cbk, subvol->fops->namelink,
-                loc, xdata);
+    SYNCOP(subvol, (&args), syncop_namelink_cbk, subvol->fops->namelink, loc,
+           xdata);
 
-        if (xdata)
-                xdata = args.xdata;
-        else if (args.xdata)
-                dict_unref (args.xdata);
+    if (xdata)
+        xdata = args.xdata;
+    else if (args.xdata)
+        dict_unref(args.xdata);
 
-        errno = args.op_errno;
-        return args.op_ret;
+    errno = args.op_errno;
+    return args.op_ret;
 }
diff --git a/libglusterfs/src/syscall.c b/libglusterfs/src/syscall.c
index 6a17d1ec6ca..a3bc9189257 100644
--- a/libglusterfs/src/syscall.c
+++ b/libglusterfs/src/syscall.c
@@ -21,776 +21,709 @@
 #include <stdarg.h>
 
 #define FS_ERROR_LOG(result)                                                   \
-        do {                                                                   \
-                gf_msg_callingfn ("FS", GF_LOG_CRITICAL, EIO,                  \
-                                  LG_MSG_SYSCALL_RETURNS_WRONG,                \
-                                  "returned %zd for the syscall",              \
-                                  (ssize_t)result);                            \
-        } while (0)
-
+    do {                                                                       \
+        gf_msg_callingfn("FS", GF_LOG_CRITICAL, EIO,                           \
+                         LG_MSG_SYSCALL_RETURNS_WRONG,                         \
+                         "returned %zd for the syscall", (ssize_t)result);     \
+    } while (0)
 
 /*
  * Input to these macros is generally a function call, so capture the result
  * i.e. (_ret) in another variable and use that instead of using _ret again
  */
-#define FS_RET_CHECK(_ret, err)                                        \
-({                                                                     \
-        typeof(_ret) _result = (_ret);                                 \
-        if (_result < -1) {                                            \
-                FS_ERROR_LOG (_result);                                \
-                _result = -1;                                          \
-                err = EIO;                                             \
-        }                                                              \
-        _result;                                                       \
- })
+#define FS_RET_CHECK(_ret, err)                                                \
+    ({                                                                         \
+        typeof(_ret) _result = (_ret);                                         \
+        if (_result < -1) {                                                    \
+            FS_ERROR_LOG(_result);                                             \
+            _result = -1;                                                      \
+            err = EIO;                                                         \
+        }                                                                      \
+        _result;                                                               \
+    })
 
-#define FS_RET_CHECK0(_ret, err)                                       \
-({                                                                     \
-        typeof(_ret) _result0 = (_ret);                                \
-        if (_result0 < -1 || _result0 > 0) {                           \
-                FS_ERROR_LOG (_result0);                               \
-                _result0 = -1;                                         \
-                err = EIO;                                             \
-        }                                                              \
-        _result0;                                                      \
-})
+#define FS_RET_CHECK0(_ret, err)                                               \
+    ({                                                                         \
+        typeof(_ret) _result0 = (_ret);                                        \
+        if (_result0 < -1 || _result0 > 0) {                                   \
+            FS_ERROR_LOG(_result0);                                            \
+            _result0 = -1;                                                     \
+            err = EIO;                                                         \
+        }                                                                      \
+        _result0;                                                              \
+    })
 
-#define FS_RET_CHECK_ERRNO(_ret, err)                                  \
-({                                                                     \
-        typeof(_ret) _result1 = (_ret);                                \
-        if (_result1 < 0) {                                            \
-                FS_ERROR_LOG (_result1);                               \
-                _result1 = -1;                                         \
-                err = EIO;                                             \
-        } else if (_result1 > 0) {                                     \
-                err = _result1;                                        \
-                _result1 = -1;                                         \
-        }                                                              \
-        _result1;                                                      \
-})
+#define FS_RET_CHECK_ERRNO(_ret, err)                                          \
+    ({                                                                         \
+        typeof(_ret) _result1 = (_ret);                                        \
+        if (_result1 < 0) {                                                    \
+            FS_ERROR_LOG(_result1);                                            \
+            _result1 = -1;                                                     \
+            err = EIO;                                                         \
+        } else if (_result1 > 0) {                                             \
+            err = _result1;                                                    \
+            _result1 = -1;                                                     \
+        }                                                                      \
+        _result1;                                                              \
+    })
 
 int
-sys_lstat (const char *path, struct stat *buf)
+sys_lstat(const char *path, struct stat *buf)
 {
-        return FS_RET_CHECK0(lstat (path, buf), errno);
+    return FS_RET_CHECK0(lstat(path, buf), errno);
 }
 
-
 int
-sys_stat (const char *path, struct stat *buf)
+sys_stat(const char *path, struct stat *buf)
 {
-        return FS_RET_CHECK0(stat (path, buf), errno);
+    return FS_RET_CHECK0(stat(path, buf), errno);
 }
 
-
 int
-sys_fstat (int fd, struct stat *buf)
+sys_fstat(int fd, struct stat *buf)
 {
-        return FS_RET_CHECK0(fstat (fd, buf), errno);
+    return FS_RET_CHECK0(fstat(fd, buf), errno);
 }
 
-
 int
 sys_fstatat(int dirfd, const char *pathname, struct stat *buf, int flags)
 {
 #ifdef GF_DARWIN_HOST_OS
-        if (fchdir(dirfd) < 0)
-                return -1;
-        if(flags & AT_SYMLINK_NOFOLLOW)
-                return FS_RET_CHECK0(lstat(pathname, buf), errno);
-        else
-                return FS_RET_CHECK0(stat(pathname, buf), errno);
+    if (fchdir(dirfd) < 0)
+        return -1;
+    if (flags & AT_SYMLINK_NOFOLLOW)
+        return FS_RET_CHECK0(lstat(pathname, buf), errno);
+    else
+        return FS_RET_CHECK0(stat(pathname, buf), errno);
 #else
-        return FS_RET_CHECK0(fstatat (dirfd, pathname, buf, flags), errno);
+    return FS_RET_CHECK0(fstatat(dirfd, pathname, buf, flags), errno);
 #endif
 }
 
-
 int
 sys_openat(int dirfd, const char *pathname, int flags, int mode)
 {
-        int fd;
+    int fd;
 
 #ifdef GF_DARWIN_HOST_OS
-        if (fchdir(dirfd) < 0)
-                return -1;
-        fd = open (pathname, flags, mode);
-        /* TODO: Shouldn't we restore the old current directory */
+    if (fchdir(dirfd) < 0)
+        return -1;
+    fd = open(pathname, flags, mode);
+    /* TODO: Shouldn't we restore the old current directory */
 #else /* GF_DARWIN_HOST_OS */
-        fd = openat (dirfd, pathname, flags, mode);
+    fd = openat(dirfd, pathname, flags, mode);
 #ifdef __FreeBSD__
-        /* On FreeBSD S_ISVTX flag is ignored for an open() with O_CREAT set.
-         * We need to force the flag using fchmod(). */
-        if ((fd >= 0) &&
-            ((flags & O_CREAT) != 0) && ((mode & S_ISVTX) != 0)) {
-                sys_fchmod(fd, mode);
-                /* TODO: It's unlikely that fchmod could fail here. However,
-                         if it fails we cannot always restore the old state
-                         (if the file existed, we cannot recover it). We would
-                         need many more system calls to correctly handle all
-                         possible cases and it doesn't worth it. For now we
-                         simply ignore the error. */
-        }
+    /* On FreeBSD S_ISVTX flag is ignored for an open() with O_CREAT set.
+     * We need to force the flag using fchmod(). */
+    if ((fd >= 0) && ((flags & O_CREAT) != 0) && ((mode & S_ISVTX) != 0)) {
+        sys_fchmod(fd, mode);
+        /* TODO: It's unlikely that fchmod could fail here. However,
+                 if it fails we cannot always restore the old state
+                 (if the file existed, we cannot recover it). We would
+                 need many more system calls to correctly handle all
+                 possible cases and it doesn't worth it. For now we
+                 simply ignore the error. */
+    }
 #endif /* __FreeBSD__ */
 #endif /* !GF_DARWIN_HOST_OS */
 
-        return FS_RET_CHECK(fd, errno);
+    return FS_RET_CHECK(fd, errno);
 }
 
-
 int
 sys_open(const char *pathname, int flags, int mode)
 {
-        return FS_RET_CHECK(sys_openat(AT_FDCWD, pathname, flags, mode), errno);
+    return FS_RET_CHECK(sys_openat(AT_FDCWD, pathname, flags, mode), errno);
 }
 
-
 DIR *
-sys_opendir (const char *name)
+sys_opendir(const char *name)
 {
-        return opendir (name);
+    return opendir(name);
 }
 
-int sys_mkdirat(int dirfd, const char *pathname, mode_t mode)
+int
+sys_mkdirat(int dirfd, const char *pathname, mode_t mode)
 {
 #ifdef GF_DARWIN_HOST_OS
-        if(fchdir(dirfd) < 0)
-                return -1;
-        return FS_RET_CHECK0(mkdir(pathname, mode), errno);
+    if (fchdir(dirfd) < 0)
+        return -1;
+    return FS_RET_CHECK0(mkdir(pathname, mode), errno);
 #else
-        return FS_RET_CHECK0(mkdirat (dirfd, pathname, mode), errno);
+    return FS_RET_CHECK0(mkdirat(dirfd, pathname, mode), errno);
 #endif
 }
 
 struct dirent *
-sys_readdir (DIR *dir, struct dirent *de)
+sys_readdir(DIR *dir, struct dirent *de)
 {
 #if !defined(__GLIBC__)
-        /*
-         * World+Dog says glibc's readdir(3) is MT-SAFE as long as
-         * two threads are not accessing the same DIR; there's a
-         * potential buffer overflow in glibc's readdir_r(3); and
-         * glibc's readdir_r(3) is deprecated after version 2.22
-         * with presumed eventual removal.
-         * Given all that, World+Dog says everyone should just use
-         * readdir(3). But it's unknown, unclear whether the same
-         * is also true for *BSD, MacOS, and, etc.
-        */
-        struct dirent *entry = NULL;
-
-        (void) readdir_r (dir, de, &entry);
-        return entry;
+    /*
+     * World+Dog says glibc's readdir(3) is MT-SAFE as long as
+     * two threads are not accessing the same DIR; there's a
+     * potential buffer overflow in glibc's readdir_r(3); and
+     * glibc's readdir_r(3) is deprecated after version 2.22
+     * with presumed eventual removal.
+     * Given all that, World+Dog says everyone should just use
+     * readdir(3). But it's unknown, unclear whether the same
+     * is also true for *BSD, MacOS, and, etc.
+     */
+    struct dirent *entry = NULL;
+
+    (void)readdir_r(dir, de, &entry);
+    return entry;
 #else
-        return readdir (dir);
+    return readdir(dir);
 #endif
 }
 
-
 ssize_t
-sys_readlink (const char *path, char *buf, size_t bufsiz)
+sys_readlink(const char *path, char *buf, size_t bufsiz)
 {
-        return FS_RET_CHECK(readlink (path, buf, bufsiz), errno);
+    return FS_RET_CHECK(readlink(path, buf, bufsiz), errno);
 }
 
-
 int
-sys_closedir (DIR *dir)
+sys_closedir(DIR *dir)
 {
-        return FS_RET_CHECK0(closedir (dir), errno);
+    return FS_RET_CHECK0(closedir(dir), errno);
 }
 
-
 int
-sys_mknod (const char *pathname, mode_t mode, dev_t dev)
+sys_mknod(const char *pathname, mode_t mode, dev_t dev)
 {
-        return FS_RET_CHECK0(mknod (pathname, mode, dev), errno);
+    return FS_RET_CHECK0(mknod(pathname, mode, dev), errno);
 }
 
-
 int
-sys_mkdir (const char *pathname, mode_t mode)
+sys_mkdir(const char *pathname, mode_t mode)
 {
-        return FS_RET_CHECK0(mkdir (pathname, mode), errno);
+    return FS_RET_CHECK0(mkdir(pathname, mode), errno);
 }
 
-
 int
-sys_unlink (const char *pathname)
+sys_unlink(const char *pathname)
 {
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_unlink (pathname), errno);
+    return FS_RET_CHECK0(solaris_unlink(pathname), errno);
 #endif
-        return FS_RET_CHECK0(unlink (pathname), errno);
+    return FS_RET_CHECK0(unlink(pathname), errno);
 }
 
-
 int
-sys_rmdir (const char *pathname)
+sys_rmdir(const char *pathname)
 {
-        return FS_RET_CHECK0(rmdir (pathname), errno);
+    return FS_RET_CHECK0(rmdir(pathname), errno);
 }
 
-
 int
-sys_symlink (const char *oldpath, const char *newpath)
+sys_symlink(const char *oldpath, const char *newpath)
 {
-        return FS_RET_CHECK0(symlink (oldpath, newpath), errno);
+    return FS_RET_CHECK0(symlink(oldpath, newpath), errno);
 }
 
-
 int
-sys_rename (const char *oldpath, const char *newpath)
+sys_rename(const char *oldpath, const char *newpath)
 {
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_rename (oldpath, newpath), errno);
+    return FS_RET_CHECK0(solaris_rename(oldpath, newpath), errno);
 #endif
-        return FS_RET_CHECK0(rename (oldpath, newpath), errno);
+    return FS_RET_CHECK0(rename(oldpath, newpath), errno);
 }
 
-
 int
-sys_link (const char *oldpath, const char *newpath)
+sys_link(const char *oldpath, const char *newpath)
 {
 #ifdef HAVE_LINKAT
-	/*
-	 * On most systems (Linux being the notable exception), link(2)
-	 * first resolves symlinks. If the target is a directory or
-	 * is nonexistent, it will fail. linkat(2) operates on the
-	 * symlink instead of its target when the AT_SYMLINK_FOLLOW
-	 * flag is not supplied.
-	 */
-        return FS_RET_CHECK0(linkat (AT_FDCWD, oldpath, AT_FDCWD, newpath, 0),
-                             errno);
+    /*
+     * On most systems (Linux being the notable exception), link(2)
+     * first resolves symlinks. If the target is a directory or
+     * is nonexistent, it will fail. linkat(2) operates on the
+     * symlink instead of its target when the AT_SYMLINK_FOLLOW
+     * flag is not supplied.
+     */
+    return FS_RET_CHECK0(linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0),
+                         errno);
 #else
-        return FS_RET_CHECK0(link (oldpath, newpath), errno);
+    return FS_RET_CHECK0(link(oldpath, newpath), errno);
 #endif
 }
 
-
 int
-sys_chmod (const char *path, mode_t mode)
+sys_chmod(const char *path, mode_t mode)
 {
-        return FS_RET_CHECK0(chmod (path, mode), errno);
+    return FS_RET_CHECK0(chmod(path, mode), errno);
 }
 
-
 int
-sys_fchmod (int fd, mode_t mode)
+sys_fchmod(int fd, mode_t mode)
 {
-        return FS_RET_CHECK0(fchmod (fd, mode), errno);
+    return FS_RET_CHECK0(fchmod(fd, mode), errno);
 }
 
-
 int
-sys_chown (const char *path, uid_t owner, gid_t group)
+sys_chown(const char *path, uid_t owner, gid_t group)
 {
-        return FS_RET_CHECK0(chown (path, owner, group), errno);
+    return FS_RET_CHECK0(chown(path, owner, group), errno);
 }
 
-
 int
-sys_fchown (int fd, uid_t owner, gid_t group)
+sys_fchown(int fd, uid_t owner, gid_t group)
 {
-        return FS_RET_CHECK0(fchown (fd, owner, group), errno);
+    return FS_RET_CHECK0(fchown(fd, owner, group), errno);
 }
 
-
 int
-sys_lchown (const char *path, uid_t owner, gid_t group)
+sys_lchown(const char *path, uid_t owner, gid_t group)
 {
-        return FS_RET_CHECK0(lchown (path, owner, group), errno);
+    return FS_RET_CHECK0(lchown(path, owner, group), errno);
 }
 
-
 int
-sys_truncate (const char *path, off_t length)
+sys_truncate(const char *path, off_t length)
 {
-        return FS_RET_CHECK0(truncate (path, length), errno);
+    return FS_RET_CHECK0(truncate(path, length), errno);
 }
 
-
 int
-sys_ftruncate (int fd, off_t length)
+sys_ftruncate(int fd, off_t length)
 {
-        return FS_RET_CHECK0(ftruncate (fd, length), errno);
+    return FS_RET_CHECK0(ftruncate(fd, length), errno);
 }
 
-
 int
-sys_utimes (const char *filename, const struct timeval times[2])
+sys_utimes(const char *filename, const struct timeval times[2])
 {
-        return FS_RET_CHECK0(utimes (filename, times), errno);
+    return FS_RET_CHECK0(utimes(filename, times), errno);
 }
 
-
 #if defined(HAVE_UTIMENSAT)
 int
-sys_utimensat (int dirfd, const char *filename, const struct timespec times[2],
-               int flags)
+sys_utimensat(int dirfd, const char *filename, const struct timespec times[2],
+              int flags)
 {
-        return FS_RET_CHECK0(utimensat (dirfd, filename, times, flags), errno);
+    return FS_RET_CHECK0(utimensat(dirfd, filename, times, flags), errno);
 }
 #endif
 
-
 int
-sys_futimes (int fd, const struct timeval times[2])
+sys_futimes(int fd, const struct timeval times[2])
 {
-        return futimes (fd, times);
+    return futimes(fd, times);
 }
 
-
 int
-sys_creat (const char *pathname, mode_t mode)
+sys_creat(const char *pathname, mode_t mode)
 {
-        return FS_RET_CHECK(sys_open(pathname, O_CREAT | O_TRUNC | O_WRONLY,
-                                     mode), errno);
+    return FS_RET_CHECK(sys_open(pathname, O_CREAT | O_TRUNC | O_WRONLY, mode),
+                        errno);
 }
 
-
 ssize_t
-sys_readv (int fd, const struct iovec *iov, int iovcnt)
+sys_readv(int fd, const struct iovec *iov, int iovcnt)
 {
-        return FS_RET_CHECK(readv (fd, iov, iovcnt), errno);
+    return FS_RET_CHECK(readv(fd, iov, iovcnt), errno);
 }
 
-
 ssize_t
-sys_writev (int fd, const struct iovec *iov, int iovcnt)
+sys_writev(int fd, const struct iovec *iov, int iovcnt)
 {
-        return FS_RET_CHECK(writev (fd, iov, iovcnt), errno);
+    return FS_RET_CHECK(writev(fd, iov, iovcnt), errno);
 }
 
-
 ssize_t
-sys_read (int fd, void *buf, size_t count)
+sys_read(int fd, void *buf, size_t count)
 {
-        return FS_RET_CHECK(read (fd, buf, count), errno);
+    return FS_RET_CHECK(read(fd, buf, count), errno);
 }
 
-
 ssize_t
-sys_write (int fd, const void *buf, size_t count)
+sys_write(int fd, const void *buf, size_t count)
 {
-        return FS_RET_CHECK(write (fd, buf, count), errno);
+    return FS_RET_CHECK(write(fd, buf, count), errno);
 }
 
-
 ssize_t
-sys_preadv (int fd, const struct iovec *iov, int iovcnt, off_t offset)
+sys_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset)
 {
-        return FS_RET_CHECK(preadv (fd, iov, iovcnt, offset), errno);
+    return FS_RET_CHECK(preadv(fd, iov, iovcnt, offset), errno);
 }
 
-
 ssize_t
-sys_pwritev (int fd, const struct iovec *iov, int iovcnt, off_t offset)
+sys_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset)
 {
-        return FS_RET_CHECK(pwritev (fd, iov, iovcnt, offset), errno);
+    return FS_RET_CHECK(pwritev(fd, iov, iovcnt, offset), errno);
 }
 
-
 ssize_t
-sys_pread (int fd, void *buf, size_t count, off_t offset)
+sys_pread(int fd, void *buf, size_t count, off_t offset)
 {
-        return FS_RET_CHECK(pread (fd, buf, count, offset), errno);
+    return FS_RET_CHECK(pread(fd, buf, count, offset), errno);
 }
 
-
 ssize_t
-sys_pwrite (int fd, const void *buf, size_t count, off_t offset)
+sys_pwrite(int fd, const void *buf, size_t count, off_t offset)
 {
-        return FS_RET_CHECK(pwrite (fd, buf, count, offset), errno);
+    return FS_RET_CHECK(pwrite(fd, buf, count, offset), errno);
 }
 
-
 off_t
-sys_lseek (int fd, off_t offset, int whence)
+sys_lseek(int fd, off_t offset, int whence)
 {
-        return FS_RET_CHECK(lseek (fd, offset, whence), errno);
+    return FS_RET_CHECK(lseek(fd, offset, whence), errno);
 }
 
-
 int
-sys_statvfs (const char *path, struct statvfs *buf)
+sys_statvfs(const char *path, struct statvfs *buf)
 {
-        int ret;
+    int ret;
 
-        ret = statvfs (path, buf);
+    ret = statvfs(path, buf);
 #ifdef __FreeBSD__
-        /* FreeBSD doesn't return the expected value in buf->f_bsize. It
-         * contains the optimal I/O size instead of the file system block
-         * size. Gluster expects that this field contains the block size.
-         */
-        if (ret == 0) {
-                buf->f_bsize = buf->f_frsize;
-        }
+    /* FreeBSD doesn't return the expected value in buf->f_bsize. It
+     * contains the optimal I/O size instead of the file system block
+     * size. Gluster expects that this field contains the block size.
+     */
+    if (ret == 0) {
+        buf->f_bsize = buf->f_frsize;
+    }
 #endif /* __FreeBSD__ */
 
-        return FS_RET_CHECK0(ret, errno);
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_fstatvfs (int fd, struct statvfs *buf)
+sys_fstatvfs(int fd, struct statvfs *buf)
 {
-        int ret;
+    int ret;
 
-        ret = fstatvfs (fd, buf);
+    ret = fstatvfs(fd, buf);
 #ifdef __FreeBSD__
-        /* FreeBSD doesn't return the expected value in buf->f_bsize. It
-         * contains the optimal I/O size instead of the file system block
-         * size. Gluster expects this field to contain the block size.
-         */
-        if (ret == 0) {
-                buf->f_bsize = buf->f_frsize;
-        }
+    /* FreeBSD doesn't return the expected value in buf->f_bsize. It
+     * contains the optimal I/O size instead of the file system block
+     * size. Gluster expects this field to contain the block size.
+     */
+    if (ret == 0) {
+        buf->f_bsize = buf->f_frsize;
+    }
 #endif /* __FreeBSD__ */
 
-        return FS_RET_CHECK0(ret, errno);
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_close (int fd)
+sys_close(int fd)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (fd >= 0)
-                ret = close (fd);
+    if (fd >= 0)
+        ret = close(fd);
 
-        return FS_RET_CHECK0(ret, errno);
+    return FS_RET_CHECK0(ret, errno);
 }
 
-
 int
-sys_fsync (int fd)
+sys_fsync(int fd)
 {
-        return FS_RET_CHECK0(fsync (fd), errno);
+    return FS_RET_CHECK0(fsync(fd), errno);
 }
 
-
 int
-sys_fdatasync (int fd)
+sys_fdatasync(int fd)
 {
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fcntl (fd, F_FULLFSYNC), errno);
+    return FS_RET_CHECK0(fcntl(fd, F_FULLFSYNC), errno);
 #elif __FreeBSD__
-	return FS_RET_CHECK0(fsync (fd), errno);
+    return FS_RET_CHECK0(fsync(fd), errno);
 #else
-        return FS_RET_CHECK0(fdatasync (fd), errno);
+    return FS_RET_CHECK0(fdatasync(fd), errno);
 #endif
 }
 
 void
 gf_add_prefix(const char *ns, const char *key, char **newkey)
 {
-        /* if we don't have any namespace, append USER NS */
-        if (strncmp(key, XATTR_USER_PREFIX,     XATTR_USER_PREFIX_LEN) &&
-            strncmp(key, XATTR_TRUSTED_PREFIX,  XATTR_TRUSTED_PREFIX_LEN) &&
-            strncmp(key, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
-            strncmp(key, XATTR_SYSTEM_PREFIX,   XATTR_SYSTEM_PREFIX_LEN)) {
-                int ns_length =  strlen(ns);
-                *newkey = GF_MALLOC(ns_length + strlen(key) + 10,
-                                    gf_common_mt_char);
-                if (!*newkey)
-                        return;
-                strcpy(*newkey, ns);
-                strcat(*newkey, key);
-        } else {
-                *newkey = gf_strdup(key);
-        }
+    /* if we don't have any namespace, append USER NS */
+    if (strncmp(key, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
+        strncmp(key, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) &&
+        strncmp(key, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
+        strncmp(key, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) {
+        int ns_length = strlen(ns);
+        *newkey = GF_MALLOC(ns_length + strlen(key) + 10, gf_common_mt_char);
+        if (!*newkey)
+            return;
+        strcpy(*newkey, ns);
+        strcat(*newkey, key);
+    } else {
+        *newkey = gf_strdup(key);
+    }
 }
 
 void
 gf_remove_prefix(const char *ns, const char *key, char **newkey)
 {
-        int ns_length =  strlen(ns);
-        if (strncmp(key, ns, ns_length) == 0) {
-                *newkey = GF_MALLOC(-ns_length + strlen(key) + 10,
-                                    gf_common_mt_char);
-                if (!*newkey)
-                        return;
-                strcpy(*newkey, key + ns_length);
-        } else {
-                *newkey = gf_strdup(key);
-        }
+    int ns_length = strlen(ns);
+    if (strncmp(key, ns, ns_length) == 0) {
+        *newkey = GF_MALLOC(-ns_length + strlen(key) + 10, gf_common_mt_char);
+        if (!*newkey)
+            return;
+        strcpy(*newkey, key + ns_length);
+    } else {
+        *newkey = gf_strdup(key);
+    }
 }
 
 int
-sys_lsetxattr (const char *path, const char *name, const void *value,
-               size_t size, int flags)
+sys_lsetxattr(const char *path, const char *name, const void *value,
+              size_t size, int flags)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK0(lsetxattr (path, name, value, size, flags), errno);
+    return FS_RET_CHECK0(lsetxattr(path, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_set_link (path, EXTATTR_NAMESPACE_USER,
-                             name, value, size), errno);
+    return FS_RET_CHECK0(
+        extattr_set_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_setxattr (path, name, value, size, flags),
-                             errno);
+    return FS_RET_CHECK0(solaris_setxattr(path, name, value, size, flags),
+                         errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        /* OS X clients will carry other flags, which will be used on a
-           OS X host, but masked out on others. GF assume NOFOLLOW on Linux,
-           enforcing  */
-        return FS_RET_CHECK0(setxattr (path, name, value, size, 0,
-                             (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW),
-                             errno);
+    /* OS X clients will carry other flags, which will be used on a
+       OS X host, but masked out on others. GF assume NOFOLLOW on Linux,
+       enforcing  */
+    return FS_RET_CHECK0(setxattr(path, name, value, size, 0,
+                                  (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW),
+                         errno);
 #endif
-
 }
 
-
 ssize_t
-sys_llistxattr (const char *path, char *list, size_t size)
+sys_llistxattr(const char *path, char *list, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK(llistxattr (path, list, size), errno);
+    return FS_RET_CHECK(llistxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        ssize_t ret = FS_RET_CHECK(extattr_list_link (path,
-                                                      EXTATTR_NAMESPACE_USER,
-                                                      list, size), errno);
-        gf_extattr_list_reshape (list, ret);
-        return ret;
+    ssize_t ret = FS_RET_CHECK(
+        extattr_list_link(path, EXTATTR_NAMESPACE_USER, list, size), errno);
+    gf_extattr_list_reshape(list, ret);
+    return ret;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_listxattr (path, list, size), errno);
+    return FS_RET_CHECK(solaris_listxattr(path, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(listxattr (path, list, size, XATTR_NOFOLLOW),
-                            errno);
+    return FS_RET_CHECK(listxattr(path, list, size, XATTR_NOFOLLOW), errno);
 #endif
 }
 
 ssize_t
-sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
+sys_lgetxattr(const char *path, const char *name, void *value, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK(lgetxattr (path, name, value, size), errno);
+    return FS_RET_CHECK(lgetxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK(extattr_get_link (path, EXTATTR_NAMESPACE_USER,
-                                              name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_get_link(path, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_getxattr (path, name, value, size), errno);
+    return FS_RET_CHECK(solaris_getxattr(path, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-         return FS_RET_CHECK(getxattr (path, name, value, size, 0,
-                                       XATTR_NOFOLLOW), errno);
+    return FS_RET_CHECK(getxattr(path, name, value, size, 0, XATTR_NOFOLLOW),
+                        errno);
 #endif
-
 }
 
-
 ssize_t
-sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
+sys_fgetxattr(int filedes, const char *name, void *value, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK(fgetxattr (filedes, name, value, size), errno);
+    return FS_RET_CHECK(fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK(extattr_get_fd (filedes, EXTATTR_NAMESPACE_USER,
-                            name, value, size), errno);
+    return FS_RET_CHECK(
+        extattr_get_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_fgetxattr (filedes, name, value, size),
-                            errno);
+    return FS_RET_CHECK(solaris_fgetxattr(filedes, name, value, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(fgetxattr (filedes, name, value, size, 0, 0),
-                            errno);
+    return FS_RET_CHECK(fgetxattr(filedes, name, value, size, 0, 0), errno);
 #endif
-
 }
 
 int
-sys_fremovexattr (int filedes, const char *name)
+sys_fremovexattr(int filedes, const char *name)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK0(fremovexattr (filedes, name), errno);
+    return FS_RET_CHECK0(fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_delete_fd (filedes, EXTATTR_NAMESPACE_USER,
-                                                name), errno);
+    return FS_RET_CHECK0(
+        extattr_delete_fd(filedes, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_fremovexattr (filedes, name), errno);
+    return FS_RET_CHECK0(solaris_fremovexattr(filedes, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fremovexattr (filedes, name, 0), errno);
+    return FS_RET_CHECK0(fremovexattr(filedes, name, 0), errno);
 #endif
 }
 
-
 int
-sys_fsetxattr (int filedes, const char *name, const void *value,
-               size_t size, int flags)
+sys_fsetxattr(int filedes, const char *name, const void *value, size_t size,
+              int flags)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK0(fsetxattr (filedes, name, value, size, flags),
-                             errno);
+    return FS_RET_CHECK0(fsetxattr(filedes, name, value, size, flags), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_set_fd (filedes, EXTATTR_NAMESPACE_USER,
-                                             name, value, size), errno);
+    return FS_RET_CHECK0(
+        extattr_set_fd(filedes, EXTATTR_NAMESPACE_USER, name, value, size),
+        errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_fsetxattr (filedes, name, value, size,
-                                                flags), errno);
+    return FS_RET_CHECK0(solaris_fsetxattr(filedes, name, value, size, flags),
+                         errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(fsetxattr (filedes, name, value, size, 0,
-                                        flags & ~XATTR_NOSECURITY), errno);
+    return FS_RET_CHECK0(
+        fsetxattr(filedes, name, value, size, 0, flags & ~XATTR_NOSECURITY),
+        errno);
 #endif
-
 }
 
-
 ssize_t
-sys_flistxattr (int filedes, char *list, size_t size)
+sys_flistxattr(int filedes, char *list, size_t size)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK(flistxattr (filedes, list, size), errno);
+    return FS_RET_CHECK(flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        ssize_t ret = FS_RET_CHECK (extattr_list_fd (filedes,
-                                                     EXTATTR_NAMESPACE_USER,
-                                                     list, size), errno);
-        gf_extattr_list_reshape (list, ret);
-        return ret;
+    ssize_t ret = FS_RET_CHECK(
+        extattr_list_fd(filedes, EXTATTR_NAMESPACE_USER, list, size), errno);
+    gf_extattr_list_reshape(list, ret);
+    return ret;
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK(solaris_flistxattr (filedes, list, size), errno);
+    return FS_RET_CHECK(solaris_flistxattr(filedes, list, size), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK(flistxattr (filedes, list, size, XATTR_NOFOLLOW),
-                            errno);
+    return FS_RET_CHECK(flistxattr(filedes, list, size, XATTR_NOFOLLOW), errno);
 #endif
-
 }
 
-
 int
-sys_lremovexattr (const char *path, const char *name)
+sys_lremovexattr(const char *path, const char *name)
 {
-
 #if defined(GF_LINUX_HOST_OS) || defined(__NetBSD__)
-        return FS_RET_CHECK0(lremovexattr (path, name), errno);
+    return FS_RET_CHECK0(lremovexattr(path, name), errno);
 #endif
 
 #ifdef GF_BSD_HOST_OS
-        return FS_RET_CHECK0(extattr_delete_link (path, EXTATTR_NAMESPACE_USER,
-                                                  name), errno);
+    return FS_RET_CHECK0(
+        extattr_delete_link(path, EXTATTR_NAMESPACE_USER, name), errno);
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-        return FS_RET_CHECK0(solaris_removexattr (path, name), errno);
+    return FS_RET_CHECK0(solaris_removexattr(path, name), errno);
 #endif
 
 #ifdef GF_DARWIN_HOST_OS
-        return FS_RET_CHECK0(removexattr (path, name, XATTR_NOFOLLOW), errno);
+    return FS_RET_CHECK0(removexattr(path, name, XATTR_NOFOLLOW), errno);
 #endif
-
 }
 
-
 int
-sys_access (const char *pathname, int mode)
+sys_access(const char *pathname, int mode)
 {
-        return FS_RET_CHECK0(access (pathname, mode), errno);
+    return FS_RET_CHECK0(access(pathname, mode), errno);
 }
 
-
 int
 sys_fallocate(int fd, int mode, off_t offset, off_t len)
 {
 #ifdef HAVE_FALLOCATE
-        return FS_RET_CHECK0(fallocate(fd, mode, offset, len), errno);
+    return FS_RET_CHECK0(fallocate(fd, mode, offset, len), errno);
 #endif
 
 #ifdef HAVE_POSIX_FALLOCATE
-        if (mode) {
-                /* keep size not supported */
-                errno = EOPNOTSUPP;
-                return -1;
-        }
+    if (mode) {
+        /* keep size not supported */
+        errno = EOPNOTSUPP;
+        return -1;
+    }
 
-        return FS_RET_CHECK_ERRNO(posix_fallocate(fd, offset, len), errno);
+    return FS_RET_CHECK_ERRNO(posix_fallocate(fd, offset, len), errno);
 #endif
 
 #if defined(F_ALLOCATECONTIG) && defined(GF_DARWIN_HOST_OS)
-        /* C conversion from C++ implementation for OSX by Mozilla Foundation */
-        if (mode) {
-                /* keep size not supported */
-                errno = EOPNOTSUPP;
-                return -1;
-        }
-        /*
-         *   The F_PREALLOCATE command operates on the following structure:
-         *
-         *    typedef struct fstore {
-         *    u_int32_t fst_flags;      // IN: flags word
-         *    int       fst_posmode;    // IN: indicates offset field
-         *    off_t     fst_offset;     // IN: start of the region
-         *    off_t     fst_length;     // IN: size of the region
-         *    off_t     fst_bytesalloc; // OUT: number of bytes allocated
-         *    } fstore_t;
-         *
-         * The flags (fst_flags) for the F_PREALLOCATE command are as follows:
-         *    F_ALLOCATECONTIG   Allocate contiguous space.
-         *    F_ALLOCATEALL      Allocate all requested space or no space at all.
-         *
-         * The position modes (fst_posmode) for the F_PREALLOCATE command
-         * indicate how to use the offset field.  The modes are as follows:
-         *    F_PEOFPOSMODE   Allocate from the physical end of file.
-         *    F_VOLPOSMODE    Allocate from the volume offset.
-         *
-         */
-
-        int ret;
-        fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, offset, len, 0};
-        ret = fcntl (fd, F_PREALLOCATE, &store);
-        if (ret == -1) {
-                store.fst_flags = F_ALLOCATEALL;
-                ret = fcntl (fd, F_PREALLOCATE, &store);
-        }
-        if (ret == -1)
-                return ret;
-        return FS_RET_CHECK0(ftruncate (fd, offset + len), errno);
-#endif
-        errno = ENOSYS;
+    /* C conversion from C++ implementation for OSX by Mozilla Foundation */
+    if (mode) {
+        /* keep size not supported */
+        errno = EOPNOTSUPP;
         return -1;
+    }
+    /*
+     *   The F_PREALLOCATE command operates on the following structure:
+     *
+     *    typedef struct fstore {
+     *    u_int32_t fst_flags;      // IN: flags word
+     *    int       fst_posmode;    // IN: indicates offset field
+     *    off_t     fst_offset;     // IN: start of the region
+     *    off_t     fst_length;     // IN: size of the region
+     *    off_t     fst_bytesalloc; // OUT: number of bytes allocated
+     *    } fstore_t;
+     *
+     * The flags (fst_flags) for the F_PREALLOCATE command are as follows:
+     *    F_ALLOCATECONTIG   Allocate contiguous space.
+     *    F_ALLOCATEALL      Allocate all requested space or no space at all.
+     *
+     * The position modes (fst_posmode) for the F_PREALLOCATE command
+     * indicate how to use the offset field.  The modes are as follows:
+     *    F_PEOFPOSMODE   Allocate from the physical end of file.
+     *    F_VOLPOSMODE    Allocate from the volume offset.
+     *
+     */
+
+    int ret;
+    fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, offset, len, 0};
+    ret = fcntl(fd, F_PREALLOCATE, &store);
+    if (ret == -1) {
+        store.fst_flags = F_ALLOCATEALL;
+        ret = fcntl(fd, F_PREALLOCATE, &store);
+    }
+    if (ret == -1)
+        return ret;
+    return FS_RET_CHECK0(ftruncate(fd, offset + len), errno);
+#endif
+    errno = ENOSYS;
+    return -1;
 }
diff --git a/libglusterfs/src/throttle-tbf.c b/libglusterfs/src/throttle-tbf.c
index a425166b681..9519defa37f 100644
--- a/libglusterfs/src/throttle-tbf.c
+++ b/libglusterfs/src/throttle-tbf.c
@@ -27,93 +27,93 @@
 #include "throttle-tbf.h"
 
 typedef struct tbf_throttle {
-        char done;
+    char done;
 
-        pthread_mutex_t mutex;
-        pthread_cond_t  cond;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
 
-        unsigned long tokens;
+    unsigned long tokens;
 
-        struct list_head list;
+    struct list_head list;
 } tbf_throttle_t;
 
 static tbf_throttle_t *
-tbf_init_throttle (unsigned long tokens_required)
+tbf_init_throttle(unsigned long tokens_required)
 {
-        tbf_throttle_t *throttle = NULL;
+    tbf_throttle_t *throttle = NULL;
 
-        throttle = GF_CALLOC (1, sizeof (*throttle),
-                              gf_common_mt_tbf_throttle_t);
-        if (!throttle)
-                return NULL;
+    throttle = GF_CALLOC(1, sizeof(*throttle), gf_common_mt_tbf_throttle_t);
+    if (!throttle)
+        return NULL;
 
-        throttle->done = 0;
-        throttle->tokens = tokens_required;
-        INIT_LIST_HEAD (&throttle->list);
+    throttle->done = 0;
+    throttle->tokens = tokens_required;
+    INIT_LIST_HEAD(&throttle->list);
 
-        (void) pthread_mutex_init (&throttle->mutex, NULL);
-        (void) pthread_cond_init (&throttle->cond, NULL);
+    (void)pthread_mutex_init(&throttle->mutex, NULL);
+    (void)pthread_cond_init(&throttle->cond, NULL);
 
-        return throttle;
+    return throttle;
 }
 
 void
-_tbf_dispatch_queued (tbf_bucket_t *bucket)
+_tbf_dispatch_queued(tbf_bucket_t *bucket)
 {
-        gf_boolean_t xcont = _gf_false;
-        tbf_throttle_t *tmp = NULL;
-        tbf_throttle_t *throttle = NULL;
-
-        list_for_each_entry_safe (throttle, tmp, &bucket->queued, list) {
-
-                pthread_mutex_lock (&throttle->mutex);
-                {
-                        if (bucket->tokens < throttle->tokens) {
-                                xcont = _gf_true;
-                                goto unblock;
-                        }
-
-                        /* this request can now be serviced */
-                        throttle->done = 1;
-                        list_del_init (&throttle->list);
-
-                        bucket->tokens -= throttle->tokens;
-                        pthread_cond_signal (&throttle->cond);
-                }
-        unblock:
-                pthread_mutex_unlock (&throttle->mutex);
-                if (xcont)
-                        break;
+    gf_boolean_t xcont = _gf_false;
+    tbf_throttle_t *tmp = NULL;
+    tbf_throttle_t *throttle = NULL;
+
+    list_for_each_entry_safe(throttle, tmp, &bucket->queued, list)
+    {
+        pthread_mutex_lock(&throttle->mutex);
+        {
+            if (bucket->tokens < throttle->tokens) {
+                xcont = _gf_true;
+                goto unblock;
+            }
+
+            /* this request can now be serviced */
+            throttle->done = 1;
+            list_del_init(&throttle->list);
+
+            bucket->tokens -= throttle->tokens;
+            pthread_cond_signal(&throttle->cond);
         }
+    unblock:
+        pthread_mutex_unlock(&throttle->mutex);
+        if (xcont)
+            break;
+    }
 }
 
-void *tbf_tokengenerator (void *arg)
+void *
+tbf_tokengenerator(void *arg)
 {
-        unsigned long tokenrate = 0;
-        unsigned long maxtokens = 0;
-        unsigned long token_gen_interval = 0;
-        tbf_bucket_t *bucket = arg;
-
-        tokenrate = bucket->tokenrate;
-        maxtokens = bucket->maxtokens;
-        token_gen_interval = bucket->token_gen_interval;
-
-        while (1) {
-                usleep (token_gen_interval);
-
-                LOCK (&bucket->lock);
-                {
-                        bucket->tokens += tokenrate;
-                        if (bucket->tokens > maxtokens)
-                                bucket->tokens = maxtokens;
-
-                        if (!list_empty (&bucket->queued))
-                                _tbf_dispatch_queued (bucket);
-                }
-                UNLOCK (&bucket->lock);
+    unsigned long tokenrate = 0;
+    unsigned long maxtokens = 0;
+    unsigned long token_gen_interval = 0;
+    tbf_bucket_t *bucket = arg;
+
+    tokenrate = bucket->tokenrate;
+    maxtokens = bucket->maxtokens;
+    token_gen_interval = bucket->token_gen_interval;
+
+    while (1) {
+        usleep(token_gen_interval);
+
+        LOCK(&bucket->lock);
+        {
+            bucket->tokens += tokenrate;
+            if (bucket->tokens > maxtokens)
+                bucket->tokens = maxtokens;
+
+            if (!list_empty(&bucket->queued))
+                _tbf_dispatch_queued(bucket);
         }
+        UNLOCK(&bucket->lock);
+    }
 
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -122,170 +122,169 @@ void *tbf_tokengenerator (void *arg)
  * updated _after_ all the required variables are initialized.
  */
 static int32_t
-tbf_init_bucket (tbf_t *tbf, tbf_opspec_t *spec)
+tbf_init_bucket(tbf_t *tbf, tbf_opspec_t *spec)
 {
-        int ret = 0;
-        tbf_bucket_t *curr = NULL;
-        tbf_bucket_t **bucket = NULL;
+    int ret = 0;
+    tbf_bucket_t *curr = NULL;
+    tbf_bucket_t **bucket = NULL;
 
-        GF_ASSERT (spec->op >= TBF_OP_MIN);
-        GF_ASSERT (spec->op <= TBF_OP_MAX);
+    GF_ASSERT(spec->op >= TBF_OP_MIN);
+    GF_ASSERT(spec->op <= TBF_OP_MAX);
 
-        /* no rate? no throttling. */
-        if (!spec->rate)
-                return 0;
+    /* no rate? no throttling. */
+    if (!spec->rate)
+        return 0;
 
-        bucket = tbf->bucket + spec->op;
+    bucket = tbf->bucket + spec->op;
 
-        curr = GF_CALLOC (1, sizeof (*curr), gf_common_mt_tbf_bucket_t);
-        if (!curr)
-                goto error_return;
+    curr = GF_CALLOC(1, sizeof(*curr), gf_common_mt_tbf_bucket_t);
+    if (!curr)
+        goto error_return;
 
-        LOCK_INIT (&curr->lock);
-        INIT_LIST_HEAD (&curr->queued);
+    LOCK_INIT(&curr->lock);
+    INIT_LIST_HEAD(&curr->queued);
 
-        curr->tokens = 0;
-        curr->tokenrate = spec->rate;
-        curr->maxtokens = spec->maxlimit;
-        curr->token_gen_interval = spec->token_gen_interval;
+    curr->tokens = 0;
+    curr->tokenrate = spec->rate;
+    curr->maxtokens = spec->maxlimit;
+    curr->token_gen_interval = spec->token_gen_interval;
 
-        ret = gf_thread_create (&curr->tokener,
-                                NULL, tbf_tokengenerator, curr, "tbfclock");
-        if (ret != 0)
-                goto freemem;
+    ret = gf_thread_create(&curr->tokener, NULL, tbf_tokengenerator, curr,
+                           "tbfclock");
+    if (ret != 0)
+        goto freemem;
 
-        *bucket = curr;
-        return 0;
+    *bucket = curr;
+    return 0;
 
- freemem:
-        LOCK_DESTROY (&curr->lock);
-        GF_FREE (curr);
- error_return:
-        return -1;
+freemem:
+    LOCK_DESTROY(&curr->lock);
+    GF_FREE(curr);
+error_return:
+    return -1;
 }
 
-#define TBF_ALLOC_SIZE                                               \
-        (sizeof (tbf_t) + (TBF_OP_MAX * sizeof (tbf_bucket_t)))
+#define TBF_ALLOC_SIZE (sizeof(tbf_t) + (TBF_OP_MAX * sizeof(tbf_bucket_t)))
 
 tbf_t *
-tbf_init (tbf_opspec_t *tbfspec, unsigned int count)
+tbf_init(tbf_opspec_t *tbfspec, unsigned int count)
 {
-        int32_t i = 0;
-        int32_t ret = 0;
-        tbf_t *tbf = NULL;
-        tbf_opspec_t *opspec = NULL;
-
-        tbf = GF_CALLOC (1, TBF_ALLOC_SIZE, gf_common_mt_tbf_t);
-        if (!tbf)
-                goto error_return;
-
-        tbf->bucket = (tbf_bucket_t **) ((char *)tbf + sizeof (*tbf));
-        for (i = 0; i < TBF_OP_MAX; i++) {
-                *(tbf->bucket + i) = NULL;
-        }
+    int32_t i = 0;
+    int32_t ret = 0;
+    tbf_t *tbf = NULL;
+    tbf_opspec_t *opspec = NULL;
 
-        for (i = 0; i < count; i++) {
-                opspec = tbfspec + i;
+    tbf = GF_CALLOC(1, TBF_ALLOC_SIZE, gf_common_mt_tbf_t);
+    if (!tbf)
+        goto error_return;
 
-                ret = tbf_init_bucket (tbf, opspec);
-                if (ret)
-                        break;
-        }
+    tbf->bucket = (tbf_bucket_t **)((char *)tbf + sizeof(*tbf));
+    for (i = 0; i < TBF_OP_MAX; i++) {
+        *(tbf->bucket + i) = NULL;
+    }
 
+    for (i = 0; i < count; i++) {
+        opspec = tbfspec + i;
+
+        ret = tbf_init_bucket(tbf, opspec);
         if (ret)
-                goto error_return;
+            break;
+    }
 
-        return tbf;
+    if (ret)
+        goto error_return;
 
- error_return:
-        return NULL;
+    return tbf;
+
+error_return:
+    return NULL;
 }
 
 static void
-tbf_mod_bucket (tbf_bucket_t *bucket, tbf_opspec_t *spec)
+tbf_mod_bucket(tbf_bucket_t *bucket, tbf_opspec_t *spec)
 {
-        LOCK (&bucket->lock);
-        {
-                bucket->tokens = 0;
-                bucket->tokenrate = spec->rate;
-                bucket->maxtokens = spec->maxlimit;
-        }
-        UNLOCK (&bucket->lock);
-
-        /* next token tick would unqueue pending operations */
+    LOCK(&bucket->lock);
+    {
+        bucket->tokens = 0;
+        bucket->tokenrate = spec->rate;
+        bucket->maxtokens = spec->maxlimit;
+    }
+    UNLOCK(&bucket->lock);
+
+    /* next token tick would unqueue pending operations */
 }
 
 int
-tbf_mod (tbf_t *tbf, tbf_opspec_t *tbfspec)
+tbf_mod(tbf_t *tbf, tbf_opspec_t *tbfspec)
 {
-        int              ret    = 0;
-        tbf_bucket_t *bucket = NULL;
-        tbf_ops_t     op     = TBF_OP_MIN;
+    int ret = 0;
+    tbf_bucket_t *bucket = NULL;
+    tbf_ops_t op = TBF_OP_MIN;
 
-        if (!tbf || !tbfspec)
-                return -1;
+    if (!tbf || !tbfspec)
+        return -1;
 
-        op = tbfspec->op;
+    op = tbfspec->op;
 
-        GF_ASSERT (op >= TBF_OP_MIN);
-        GF_ASSERT (op <= TBF_OP_MAX);
+    GF_ASSERT(op >= TBF_OP_MIN);
+    GF_ASSERT(op <= TBF_OP_MAX);
 
-        bucket = *(tbf->bucket + op);
-        if (bucket) {
-                tbf_mod_bucket (bucket, tbfspec);
-        } else {
-                ret = tbf_init_bucket (tbf, tbfspec);
-        }
+    bucket = *(tbf->bucket + op);
+    if (bucket) {
+        tbf_mod_bucket(bucket, tbfspec);
+    } else {
+        ret = tbf_init_bucket(tbf, tbfspec);
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-tbf_throttle (tbf_t *tbf, tbf_ops_t op, unsigned long tokens_requested)
+tbf_throttle(tbf_t *tbf, tbf_ops_t op, unsigned long tokens_requested)
 {
-        char waitq = 0;
-        tbf_bucket_t *bucket = NULL;
-        tbf_throttle_t *throttle = NULL;
-
-        GF_ASSERT (op >= TBF_OP_MIN);
-        GF_ASSERT (op <= TBF_OP_MAX);
-
-        bucket = *(tbf->bucket + op);
-        if (!bucket)
-                return;
+    char waitq = 0;
+    tbf_bucket_t *bucket = NULL;
+    tbf_throttle_t *throttle = NULL;
+
+    GF_ASSERT(op >= TBF_OP_MIN);
+    GF_ASSERT(op <= TBF_OP_MAX);
+
+    bucket = *(tbf->bucket + op);
+    if (!bucket)
+        return;
+
+    LOCK(&bucket->lock);
+    {
+        /**
+         * if there are enough tokens in the bucket there is no need
+         * to throttle the request: therefore, consume the required
+         * number of tokens and continue.
+         */
+        if (tokens_requested <= bucket->tokens) {
+            bucket->tokens -= tokens_requested;
+        } else {
+            throttle = tbf_init_throttle(tokens_requested);
+            if (!throttle) /* let it slip through for now.. */
+                goto unblock;
 
-        LOCK (&bucket->lock);
-        {
-                /**
-                 * if there are enough tokens in the bucket there is no need
-                 * to throttle the request: therefore, consume the required
-                 * number of tokens and continue.
-                 */
-                if (tokens_requested <= bucket->tokens) {
-                        bucket->tokens -= tokens_requested;
-                } else {
-                        throttle = tbf_init_throttle (tokens_requested);
-                        if (!throttle) /* let it slip through for now.. */
-                                goto unblock;
-
-                        waitq = 1;
-                        pthread_mutex_lock (&throttle->mutex);
-                        list_add_tail (&throttle->list, &bucket->queued);
-                }
+            waitq = 1;
+            pthread_mutex_lock(&throttle->mutex);
+            list_add_tail(&throttle->list, &bucket->queued);
         }
- unblock:
-        UNLOCK (&bucket->lock);
+    }
+unblock:
+    UNLOCK(&bucket->lock);
 
-        if (waitq) {
-                while (!throttle->done) {
-                        pthread_cond_wait (&throttle->cond, &throttle->mutex);
-                }
+    if (waitq) {
+        while (!throttle->done) {
+            pthread_cond_wait(&throttle->cond, &throttle->mutex);
+        }
 
-                pthread_mutex_unlock (&throttle->mutex);
+        pthread_mutex_unlock(&throttle->mutex);
 
-                pthread_mutex_destroy (&throttle->mutex);
-                pthread_cond_destroy (&throttle->cond);
+        pthread_mutex_destroy(&throttle->mutex);
+        pthread_cond_destroy(&throttle->cond);
 
-                GF_FREE (throttle);
-        }
+        GF_FREE(throttle);
+    }
 }
diff --git a/libglusterfs/src/timer.c b/libglusterfs/src/timer.c
index 68ac7b0edff..88a28a9bd16 100644
--- a/libglusterfs/src/timer.c
+++ b/libglusterfs/src/timer.c
@@ -17,265 +17,255 @@
 
 /* fwd decl */
 static gf_timer_registry_t *
-gf_timer_registry_init (glusterfs_ctx_t *);
+gf_timer_registry_init(glusterfs_ctx_t *);
 
 gf_timer_t *
-gf_timer_call_after (glusterfs_ctx_t *ctx,
-                     struct timespec delta,
-                     gf_timer_cbk_t callbk,
-                     void *data)
+gf_timer_call_after(glusterfs_ctx_t *ctx, struct timespec delta,
+                    gf_timer_cbk_t callbk, void *data)
 {
-        gf_timer_registry_t *reg = NULL;
-        gf_timer_t *event = NULL;
-        gf_timer_t *trav = NULL;
-        uint64_t at = 0;
-
-        if ((ctx == NULL) || (ctx->cleanup_started))
-        {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "Either ctx is NULL or"
-                                  " ctx cleanup started");
-                return NULL;
-        }
+    gf_timer_registry_t *reg = NULL;
+    gf_timer_t *event = NULL;
+    gf_timer_t *trav = NULL;
+    uint64_t at = 0;
+
+    if ((ctx == NULL) || (ctx->cleanup_started)) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "Either ctx is NULL or"
+                         " ctx cleanup started");
+        return NULL;
+    }
 
-        reg = gf_timer_registry_init (ctx);
+    reg = gf_timer_registry_init(ctx);
 
-        if (!reg) {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
-                                  LG_MSG_TIMER_REGISTER_ERROR, "!reg");
-                return NULL;
-        }
+    if (!reg) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, 0, LG_MSG_TIMER_REGISTER_ERROR,
+                         "!reg");
+        return NULL;
+    }
 
-        event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
-        if (!event) {
-                return NULL;
-        }
-        timespec_now (&event->at);
-        timespec_adjust_delta (&event->at, delta);
-        at = TS (event->at);
-        event->callbk = callbk;
-        event->data = data;
-        event->xl = THIS;
-        LOCK (&reg->lock);
+    event = GF_CALLOC(1, sizeof(*event), gf_common_mt_gf_timer_t);
+    if (!event) {
+        return NULL;
+    }
+    timespec_now(&event->at);
+    timespec_adjust_delta(&event->at, delta);
+    at = TS(event->at);
+    event->callbk = callbk;
+    event->data = data;
+    event->xl = THIS;
+    LOCK(&reg->lock);
+    {
+        list_for_each_entry_reverse(trav, &reg->active, list)
         {
-                list_for_each_entry_reverse (trav, &reg->active, list) {
-                        if (TS (trav->at) < at)
-                                break;
-                }
-                list_add (&event->list, &trav->list);
+            if (TS(trav->at) < at)
+                break;
         }
-        UNLOCK (&reg->lock);
-        return event;
+        list_add(&event->list, &trav->list);
+    }
+    UNLOCK(&reg->lock);
+    return event;
 }
 
-
 int32_t
-gf_timer_call_cancel (glusterfs_ctx_t *ctx,
-                      gf_timer_t *event)
+gf_timer_call_cancel(glusterfs_ctx_t *ctx, gf_timer_t *event)
 {
-        gf_timer_registry_t *reg = NULL;
-        gf_boolean_t fired = _gf_false;
-
-        if (ctx == NULL || event == NULL)
-        {
-                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return 0;
-        }
-
-        if (ctx->cleanup_started) {
-                gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
-                                  LG_MSG_CTX_CLEANUP_STARTED,
-                                  "ctx cleanup started");
-                return 0;
-        }
-
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-        }
-        UNLOCK (&ctx->lock);
-
-        if (!reg) {
-                /* This can happen when cleanup may have just started and
-                 * gf_timer_registry_destroy() sets ctx->timer to NULL.
-                 * Just bail out as success as gf_timer_proc() takes
-                 * care of cleaning up the events.
-                 */
-                return 0;
-        }
-
-        LOCK (&reg->lock);
-        {
-                fired = event->fired;
-                if (fired)
-                        goto unlock;
-                list_del (&event->list);
-        }
+    gf_timer_registry_t *reg = NULL;
+    gf_boolean_t fired = _gf_false;
+
+    if (ctx == NULL || event == NULL) {
+        gf_msg_callingfn("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
+        return 0;
+    }
+
+    if (ctx->cleanup_started) {
+        gf_msg_callingfn("timer", GF_LOG_INFO, 0, LG_MSG_CTX_CLEANUP_STARTED,
+                         "ctx cleanup started");
+        return 0;
+    }
+
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+    }
+    UNLOCK(&ctx->lock);
+
+    if (!reg) {
+        /* This can happen when cleanup may have just started and
+         * gf_timer_registry_destroy() sets ctx->timer to NULL.
+         * Just bail out as success as gf_timer_proc() takes
+         * care of cleaning up the events.
+         */
+        return 0;
+    }
+
+    LOCK(&reg->lock);
+    {
+        fired = event->fired;
+        if (fired)
+            goto unlock;
+        list_del(&event->list);
+    }
 unlock:
-        UNLOCK (&reg->lock);
+    UNLOCK(&reg->lock);
 
-        if (!fired) {
-                GF_FREE (event);
-                return 0;
-        }
-        return -1;
+    if (!fired) {
+        GF_FREE(event);
+        return 0;
+    }
+    return -1;
 }
 
-
 static void *
-gf_timer_proc (void *data)
+gf_timer_proc(void *data)
 {
-        gf_timer_registry_t *reg = data;
-        struct timespec sleepts;
-        gf_timer_t *event = NULL;
-        gf_timer_t *tmp = NULL;
-        xlator_t   *old_THIS = NULL;
-
-        while (!reg->fin) {
-                uint64_t now;
-                struct timespec now_ts;
-
-                timespec_now (&now_ts);
-                now = TS (now_ts);
-                while (1) {
-                        uint64_t at;
-                        char need_cbk = 0;
-
-                        /*
-                         * This will be overridden with a shorter interval if
-                         * there's an event scheduled sooner. That makes the
-                         * system more responsive in most cases, but doesn't
-                         * include the case where a timer is added while we're
-                         * asleep. It's tempting to use pthread_cond_timedwait,
-                         * with the caveat that we'd be relying on system time
-                         * instead of monotonic time. That's a mess when the
-                         * system time is adjusted.  Another alternative might
-                         * be to use pthread_kill, but that will remain TBD for
-                         * now.
-                         */
-                        sleepts.tv_sec = 1;
-                        sleepts.tv_nsec = 0;
-
-                        LOCK (&reg->lock);
-                        {
-                                /*
-                                 * Using list_for_each and then always breaking
-                                 * after the first iteration might seem strange,
-                                 * but (unlike alternatives) is independent of
-                                 * the underlying list implementation.
-                                 */
-                                list_for_each_entry_safe (event,
-                                             tmp, &reg->active, list) {
-                                        at = TS (event->at);
-                                        if (now >= at) {
-                                                need_cbk = 1;
-                                                event->fired = _gf_true;
-                                                list_del (&event->list);
-                                        } else {
-                                                uint64_t diff = now - at;
-
-                                                if (diff < 1000000000) {
-                                                        sleepts.tv_sec = 0;
-                                                        sleepts.tv_nsec = diff;
-                                                }
-                                        }
-                                        break;
-                                }
-                        }
-                        UNLOCK (&reg->lock);
-                        if (need_cbk) {
-                                old_THIS = NULL;
-                                if (event->xl) {
-                                        old_THIS = THIS;
-                                        THIS = event->xl;
-                                }
-                                event->callbk (event->data);
-                                GF_FREE (event);
-                                if (old_THIS) {
-                                        THIS = old_THIS;
-                                }
-                        } else {
-                                break;
+    gf_timer_registry_t *reg = data;
+    struct timespec sleepts;
+    gf_timer_t *event = NULL;
+    gf_timer_t *tmp = NULL;
+    xlator_t *old_THIS = NULL;
+
+    while (!reg->fin) {
+        uint64_t now;
+        struct timespec now_ts;
+
+        timespec_now(&now_ts);
+        now = TS(now_ts);
+        while (1) {
+            uint64_t at;
+            char need_cbk = 0;
+
+            /*
+             * This will be overridden with a shorter interval if
+             * there's an event scheduled sooner. That makes the
+             * system more responsive in most cases, but doesn't
+             * include the case where a timer is added while we're
+             * asleep. It's tempting to use pthread_cond_timedwait,
+             * with the caveat that we'd be relying on system time
+             * instead of monotonic time. That's a mess when the
+             * system time is adjusted.  Another alternative might
+             * be to use pthread_kill, but that will remain TBD for
+             * now.
+             */
+            sleepts.tv_sec = 1;
+            sleepts.tv_nsec = 0;
+
+            LOCK(&reg->lock);
+            {
+                /*
+                 * Using list_for_each and then always breaking
+                 * after the first iteration might seem strange,
+                 * but (unlike alternatives) is independent of
+                 * the underlying list implementation.
+                 */
+                list_for_each_entry_safe(event, tmp, &reg->active, list)
+                {
+                    at = TS(event->at);
+                    if (now >= at) {
+                        need_cbk = 1;
+                        event->fired = _gf_true;
+                        list_del(&event->list);
+                    } else {
+                        uint64_t diff = now - at;
+
+                        if (diff < 1000000000) {
+                            sleepts.tv_sec = 0;
+                            sleepts.tv_nsec = diff;
                         }
+                    }
+                    break;
+                }
+            }
+            UNLOCK(&reg->lock);
+            if (need_cbk) {
+                old_THIS = NULL;
+                if (event->xl) {
+                    old_THIS = THIS;
+                    THIS = event->xl;
                 }
-                nanosleep (&sleepts, NULL);
+                event->callbk(event->data);
+                GF_FREE(event);
+                if (old_THIS) {
+                    THIS = old_THIS;
+                }
+            } else {
+                break;
+            }
         }
-
-        LOCK (&reg->lock);
+        nanosleep(&sleepts, NULL);
+    }
+
+    LOCK(&reg->lock);
+    {
+        /* Do not call gf_timer_call_cancel(),
+         * it will lead to deadlock
+         */
+        list_for_each_entry_safe(event, tmp, &reg->active, list)
         {
-                /* Do not call gf_timer_call_cancel(),
-                 * it will lead to deadlock
-                 */
-                list_for_each_entry_safe (event, tmp, &reg->active, list) {
-                        list_del (&event->list);
-                        GF_FREE (event);
-                }
+            list_del(&event->list);
+            GF_FREE(event);
         }
-        UNLOCK (&reg->lock);
-        LOCK_DESTROY (&reg->lock);
+    }
+    UNLOCK(&reg->lock);
+    LOCK_DESTROY(&reg->lock);
 
-        return NULL;
+    return NULL;
 }
 
-
 static gf_timer_registry_t *
-gf_timer_registry_init (glusterfs_ctx_t *ctx)
+gf_timer_registry_init(glusterfs_ctx_t *ctx)
 {
-        gf_timer_registry_t *reg = NULL;
-        int ret = -1;
-
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-                if (reg) {
-                        UNLOCK (&ctx->lock);
-                        goto out;
-                }
-                reg = GF_CALLOC (1, sizeof (*reg),
-                              gf_common_mt_gf_timer_registry_t);
-                if (!reg) {
-                        UNLOCK (&ctx->lock);
-                        goto out;
-                }
-                ctx->timer = reg;
-                LOCK_INIT (&reg->lock);
-                INIT_LIST_HEAD (&reg->active);
+    gf_timer_registry_t *reg = NULL;
+    int ret = -1;
+
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+        if (reg) {
+            UNLOCK(&ctx->lock);
+            goto out;
         }
-        UNLOCK (&ctx->lock);
-        ret = gf_thread_create (&reg->th, NULL, gf_timer_proc, reg, "timer");
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_ERROR, ret,
-                        LG_MSG_PTHREAD_FAILED,
-                        "Thread creation failed");
+        reg = GF_CALLOC(1, sizeof(*reg), gf_common_mt_gf_timer_registry_t);
+        if (!reg) {
+            UNLOCK(&ctx->lock);
+            goto out;
         }
+        ctx->timer = reg;
+        LOCK_INIT(&reg->lock);
+        INIT_LIST_HEAD(&reg->active);
+    }
+    UNLOCK(&ctx->lock);
+    ret = gf_thread_create(&reg->th, NULL, gf_timer_proc, reg, "timer");
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_FAILED,
+               "Thread creation failed");
+    }
 
 out:
-        return reg;
+    return reg;
 }
 
-
 void
-gf_timer_registry_destroy (glusterfs_ctx_t *ctx)
+gf_timer_registry_destroy(glusterfs_ctx_t *ctx)
 {
-        pthread_t thr_id;
-        gf_timer_registry_t *reg = NULL;
-
-        if (ctx == NULL)
-                return;
-
-        LOCK (&ctx->lock);
-        {
-                reg = ctx->timer;
-                ctx->timer = NULL;
-        }
-        UNLOCK (&ctx->lock);
-
-        if (!reg)
-                return;
-
-        thr_id = reg->th;
-        reg->fin = 1;
-        pthread_join (thr_id, NULL);
-        GF_FREE (reg);
+    pthread_t thr_id;
+    gf_timer_registry_t *reg = NULL;
+
+    if (ctx == NULL)
+        return;
+
+    LOCK(&ctx->lock);
+    {
+        reg = ctx->timer;
+        ctx->timer = NULL;
+    }
+    UNLOCK(&ctx->lock);
+
+    if (!reg)
+        return;
+
+    thr_id = reg->th;
+    reg->fin = 1;
+    pthread_join(thr_id, NULL);
+    GF_FREE(reg);
 }
diff --git a/libglusterfs/src/timespec.c b/libglusterfs/src/timespec.c
index 932a18c0103..d17506662ac 100644
--- a/libglusterfs/src/timespec.c
+++ b/libglusterfs/src/timespec.c
@@ -24,65 +24,69 @@ static mach_timebase_info_data_t gf_timebase;
 #include "libglusterfs-messages.h"
 #include "common-utils.h"
 
-void timespec_now (struct timespec *ts)
+void
+timespec_now(struct timespec *ts)
 {
-#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS || defined GF_BSD_HOST_OS
-        if (0 == clock_gettime(CLOCK_MONOTONIC, ts)) {
-                /* All good */
-                return;
-        }
+#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS ||                  \
+    defined GF_BSD_HOST_OS
+    if (0 == clock_gettime(CLOCK_MONOTONIC, ts)) {
+        /* All good */
+        return;
+    }
 
-        /* Fall back, but there is hope in gettimeofday() syscall */
-        struct timeval tv;
-        if (0 == gettimeofday(&tv, NULL)) {
-                /* Again, all good */
-                TIMEVAL_TO_TIMESPEC(&tv, ts);
-                return;
-        }
+    /* Fall back, but there is hope in gettimeofday() syscall */
+    struct timeval tv;
+    if (0 == gettimeofday(&tv, NULL)) {
+        /* Again, all good */
+        TIMEVAL_TO_TIMESPEC(&tv, ts);
+        return;
+    }
 
-        /* If control hits here, there is surely a problem,
-           mainly because, as per man page too, these syscalls
-           shouldn't fail. Best way is to ABORT, because it is
-           not right */
-        GF_ABORT ("gettimeofday() failed!!");
+    /* If control hits here, there is surely a problem,
+       mainly because, as per man page too, these syscalls
+       shouldn't fail. Best way is to ABORT, because it is
+       not right */
+    GF_ABORT("gettimeofday() failed!!");
 
 #elif defined GF_DARWIN_HOST_OS
-        uint64_t time = mach_absolute_time();
-        static double scaling = 0.0;
+    uint64_t time = mach_absolute_time();
+    static double scaling = 0.0;
 
-        if (mach_timebase_info(&gf_timebase) != KERN_SUCCESS) {
-                gf_timebase.numer = 1;
-                gf_timebase.denom = 1;
-        }
-        if (gf_timebase.denom == 0) {
-                gf_timebase.numer = 1;
-                gf_timebase.denom = 1;
-        }
+    if (mach_timebase_info(&gf_timebase) != KERN_SUCCESS) {
+        gf_timebase.numer = 1;
+        gf_timebase.denom = 1;
+    }
+    if (gf_timebase.denom == 0) {
+        gf_timebase.numer = 1;
+        gf_timebase.denom = 1;
+    }
 
-        scaling = (double) gf_timebase.numer / (double) gf_timebase.denom;
-        time *= scaling;
+    scaling = (double)gf_timebase.numer / (double)gf_timebase.denom;
+    time *= scaling;
 
-        ts->tv_sec = (time * NANO);
-        ts->tv_nsec = (time - (ts->tv_sec * GIGA));
+    ts->tv_sec = (time * NANO);
+    ts->tv_nsec = (time - (ts->tv_sec * GIGA));
 
 #endif /* Platform verification */
 }
 
-void timespec_adjust_delta (struct timespec *ts, struct timespec delta)
+void
+timespec_adjust_delta(struct timespec *ts, struct timespec delta)
 {
-        ts->tv_nsec = ((ts->tv_nsec + delta.tv_nsec) % 1000000000);
-        ts->tv_sec += ((ts->tv_nsec + delta.tv_nsec) / 1000000000);
-        ts->tv_sec += delta.tv_sec;
+    ts->tv_nsec = ((ts->tv_nsec + delta.tv_nsec) % 1000000000);
+    ts->tv_sec += ((ts->tv_nsec + delta.tv_nsec) / 1000000000);
+    ts->tv_sec += delta.tv_sec;
 }
 
-void timespec_sub (const struct timespec *begin, const struct timespec *end,
-                   struct timespec *res)
+void
+timespec_sub(const struct timespec *begin, const struct timespec *end,
+             struct timespec *res)
 {
-        if (end->tv_nsec < begin->tv_nsec) {
-                res->tv_sec = end->tv_sec - begin->tv_sec - 1;
-                res->tv_nsec = end->tv_nsec + 1000000000 - begin->tv_nsec;
-        } else {
-                res->tv_sec = end->tv_sec - begin->tv_sec;
-                res->tv_nsec = end->tv_nsec - begin->tv_nsec;
-        }
+    if (end->tv_nsec < begin->tv_nsec) {
+        res->tv_sec = end->tv_sec - begin->tv_sec - 1;
+        res->tv_nsec = end->tv_nsec + 1000000000 - begin->tv_nsec;
+    } else {
+        res->tv_sec = end->tv_sec - begin->tv_sec;
+        res->tv_nsec = end->tv_nsec - begin->tv_nsec;
+    }
 }
diff --git a/libglusterfs/src/trie.c b/libglusterfs/src/trie.c
index f96bbebf6d3..4f01bcfe0da 100644
--- a/libglusterfs/src/trie.c
+++ b/libglusterfs/src/trie.c
@@ -17,371 +17,352 @@
 #include "trie.h"
 
 #define DISTANCE_EDIT 1
-#define DISTANCE_INS  1
-#define DISTANCE_DEL  1
-
+#define DISTANCE_INS 1
+#define DISTANCE_DEL 1
 
 struct trienode {
-        char             id;
-        char             eow;
-        int              depth;
-        void            *data;
-        struct trie     *trie;
-        struct trienode *parent;
-        struct trienode *subnodes[255];
+    char id;
+    char eow;
+    int depth;
+    void *data;
+    struct trie *trie;
+    struct trienode *parent;
+    struct trienode *subnodes[255];
 };
 
 struct trie {
-        struct trienode   root;
-        int               nodecnt;
-        size_t            len;
+    struct trienode root;
+    int nodecnt;
+    size_t len;
 };
 
-
 trie_t *
-trie_new ()
+trie_new()
 {
-        trie_t *trie = NULL;
+    trie_t *trie = NULL;
 
-        trie = GF_CALLOC (1, sizeof (*trie),  gf_common_mt_trie_trie);
-        if (!trie)
-                return NULL;
+    trie = GF_CALLOC(1, sizeof(*trie), gf_common_mt_trie_trie);
+    if (!trie)
+        return NULL;
 
-        trie->root.trie = trie;
+    trie->root.trie = trie;
 
-        return trie;
+    return trie;
 }
 
-
 static trienode_t *
-trie_subnode (trienode_t *node, int id)
+trie_subnode(trienode_t *node, int id)
 {
-        trienode_t *subnode = NULL;
-
-        subnode = node->subnodes[id];
-        if (!subnode) {
-                subnode = GF_CALLOC (1, sizeof (*subnode),
-                                     gf_common_mt_trie_node);
-                if (!subnode)
-                        return NULL;
-
-                subnode->id        = id;
-                subnode->depth     = node->depth + 1;
-                node->subnodes[id] = subnode;
-                subnode->parent    = node;
-                subnode->trie      = node->trie;
-                node->trie->nodecnt++;
-        }
-
-        return subnode;
+    trienode_t *subnode = NULL;
+
+    subnode = node->subnodes[id];
+    if (!subnode) {
+        subnode = GF_CALLOC(1, sizeof(*subnode), gf_common_mt_trie_node);
+        if (!subnode)
+            return NULL;
+
+        subnode->id = id;
+        subnode->depth = node->depth + 1;
+        node->subnodes[id] = subnode;
+        subnode->parent = node;
+        subnode->trie = node->trie;
+        node->trie->nodecnt++;
+    }
+
+    return subnode;
 }
 
-
 int
-trie_add (trie_t *trie, const char *dword)
+trie_add(trie_t *trie, const char *dword)
 {
-        trienode_t *node = NULL;
-        int              i = 0;
-        char             id = 0;
-        trienode_t *subnode = NULL;
+    trienode_t *node = NULL;
+    int i = 0;
+    char id = 0;
+    trienode_t *subnode = NULL;
 
-        node = &trie->root;
+    node = &trie->root;
 
-        for (i = 0; i < strlen (dword); i++) {
-                id = dword[i];
+    for (i = 0; i < strlen(dword); i++) {
+        id = dword[i];
 
-                subnode = trie_subnode (node, id);
-                if (!subnode)
-                        return -1;
-                node = subnode;
-        }
+        subnode = trie_subnode(node, id);
+        if (!subnode)
+            return -1;
+        node = subnode;
+    }
 
-        node->eow = 1;
+    node->eow = 1;
 
-        return 0;
+    return 0;
 }
 
 static void
-trienode_free (trienode_t *node)
+trienode_free(trienode_t *node)
 {
-        trienode_t *trav = NULL;
-        int              i = 0;
+    trienode_t *trav = NULL;
+    int i = 0;
 
-        for (i = 0; i < 255; i++) {
-                trav = node->subnodes[i];
+    for (i = 0; i < 255; i++) {
+        trav = node->subnodes[i];
 
-                if (trav)
-                        trienode_free (trav);
-        }
+        if (trav)
+            trienode_free(trav);
+    }
 
-        GF_FREE (node->data);
-        GF_FREE (node);
+    GF_FREE(node->data);
+    GF_FREE(node);
 }
 
-
 void
-trie_destroy (trie_t *trie)
+trie_destroy(trie_t *trie)
 {
-        trienode_free ((trienode_t *)trie);
+    trienode_free((trienode_t *)trie);
 }
 
-
 void
-trie_destroy_bynode (trienode_t *node)
+trie_destroy_bynode(trienode_t *node)
 {
-        trie_destroy (node->trie);
+    trie_destroy(node->trie);
 }
 
-
 static int
-trienode_walk (trienode_t *node, int (*fn)(trienode_t *node, void *data),
-               void *data, int eowonly)
+trienode_walk(trienode_t *node, int (*fn)(trienode_t *node, void *data),
+              void *data, int eowonly)
 {
-        trienode_t *trav = NULL;
-        int              i = 0;
-        int              cret = 0;
-        int              ret = 0;
-
-        if (!eowonly || node->eow)
-                ret = fn (node, data);
-
-        if (ret)
-                goto out;
-
-        for (i = 0; i < 255; i++) {
-                trav = node->subnodes[i];
-                if (!trav)
-                        continue;
-
-                cret = trienode_walk (trav, fn, data, eowonly);
-                if (cret < 0) {
-                        ret = cret;
-                        goto out;
-                }
-                ret += cret;
+    trienode_t *trav = NULL;
+    int i = 0;
+    int cret = 0;
+    int ret = 0;
+
+    if (!eowonly || node->eow)
+        ret = fn(node, data);
+
+    if (ret)
+        goto out;
+
+    for (i = 0; i < 255; i++) {
+        trav = node->subnodes[i];
+        if (!trav)
+            continue;
+
+        cret = trienode_walk(trav, fn, data, eowonly);
+        if (cret < 0) {
+            ret = cret;
+            goto out;
         }
+        ret += cret;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-trie_walk (trie_t *trie, int (*fn)(trienode_t *node, void *data),
-           void *data, int eowonly)
+trie_walk(trie_t *trie, int (*fn)(trienode_t *node, void *data), void *data,
+          int eowonly)
 {
-        return trienode_walk (&trie->root, fn, data, eowonly);
+    return trienode_walk(&trie->root, fn, data, eowonly);
 }
 
-
 static void
-print_node (trienode_t *node, char **buf)
+print_node(trienode_t *node, char **buf)
 {
-        if (!node->parent)
-                return;
+    if (!node->parent)
+        return;
 
-        if (node->parent) {
-                print_node (node->parent, buf);
-                *(*buf)++ = node->id;
-        }
+    if (node->parent) {
+        print_node(node->parent, buf);
+        *(*buf)++ = node->id;
+    }
 }
 
-
 int
-trienode_get_word (trienode_t *node, char **bufp)
+trienode_get_word(trienode_t *node, char **bufp)
 {
-        char *buf = NULL;
+    char *buf = NULL;
 
-        buf = GF_CALLOC (1, node->depth + 1, gf_common_mt_trie_buf);
-        if (!buf)
-                return -1;
-        *bufp = buf;
+    buf = GF_CALLOC(1, node->depth + 1, gf_common_mt_trie_buf);
+    if (!buf)
+        return -1;
+    *bufp = buf;
 
-        print_node (node, &buf);
+    print_node(node, &buf);
 
-        return 0;
+    return 0;
 }
 
-
 static int
-calc_dist (trienode_t *node, void *data)
+calc_dist(trienode_t *node, void *data)
 {
-        const char *word = NULL;
-        int         i = 0;
-        int        *row = NULL;
-        int        *uprow = NULL;
-        int         distu = 0;
-        int         distl = 0;
-        int         distul = 0;
-
-        word = data;
-
-        node->data = GF_CALLOC (node->trie->len, sizeof (int),
-                                gf_common_mt_trie_data);
-        if (!node->data)
-                return -1;
-        row = node->data;
-
-        if (!node->parent) {
-                for (i = 0; i < node->trie->len; i++)
-                        row[i] = i+1;
-
-                return 0;
-        }
+    const char *word = NULL;
+    int i = 0;
+    int *row = NULL;
+    int *uprow = NULL;
+    int distu = 0;
+    int distl = 0;
+    int distul = 0;
+
+    word = data;
+
+    node->data = GF_CALLOC(node->trie->len, sizeof(int),
+                           gf_common_mt_trie_data);
+    if (!node->data)
+        return -1;
+    row = node->data;
+
+    if (!node->parent) {
+        for (i = 0; i < node->trie->len; i++)
+            row[i] = i + 1;
 
-        uprow = node->parent->data;
+        return 0;
+    }
 
-        distu = node->depth;          /* up node */
-        distul = node->parent->depth; /* up-left node */
+    uprow = node->parent->data;
 
-        for (i = 0; i < node->trie->len; i++) {
-                distl = uprow[i];     /* left node */
+    distu = node->depth;          /* up node */
+    distul = node->parent->depth; /* up-left node */
 
-                if (word[i] == node->id)
-                        row[i] = distul;
-                else
-                        row[i] = min ((distul + DISTANCE_EDIT),
-                                      min ((distu + DISTANCE_DEL),
-                                           (distl + DISTANCE_INS)));
+    for (i = 0; i < node->trie->len; i++) {
+        distl = uprow[i]; /* left node */
 
-                distu  = row[i];
-                distul = distl;
-        }
+        if (word[i] == node->id)
+            row[i] = distul;
+        else
+            row[i] = min((distul + DISTANCE_EDIT),
+                         min((distu + DISTANCE_DEL), (distl + DISTANCE_INS)));
 
-        return 0;
-}
+        distu = row[i];
+        distul = distl;
+    }
 
+    return 0;
+}
 
 int
-trienode_get_dist (trienode_t *node)
+trienode_get_dist(trienode_t *node)
 {
-        int *row = NULL;
+    int *row = NULL;
 
-        row = node->data;
+    row = node->data;
 
-        return row[node->trie->len - 1];
+    return row[node->trie->len - 1];
 }
 
-
 struct trienodevec_w {
-        struct trienodevec *vec;
-        const char *word;
+    struct trienodevec *vec;
+    const char *word;
 };
 
-
 static void
-trienodevec_clear (struct trienodevec *nodevec)
+trienodevec_clear(struct trienodevec *nodevec)
 {
-        memset(nodevec->nodes, 0, sizeof (*nodevec->nodes) * nodevec->cnt);
+    memset(nodevec->nodes, 0, sizeof(*nodevec->nodes) * nodevec->cnt);
 }
 
-
 static int
-collect_closest (trienode_t *node, void *data)
+collect_closest(trienode_t *node, void *data)
 {
-        struct trienodevec_w *nodevec_w = NULL;
-        struct trienodevec *nodevec = NULL;
-        int dist = 0;
-        int i = 0;
-
-        nodevec_w = data;
-        nodevec = nodevec_w->vec;
-
-        if (calc_dist (node, (void *)nodevec_w->word))
-                return -1;
-
-        if (!node->eow || !nodevec->cnt)
-                return 0;
-
-        dist = trienode_get_dist (node);
-
-        /*
-         * I thought that when descending further after some dictionary word dw,
-         * if we see that child's distance is bigger than it was for dw, then we
-         * can prune this branch, as it can contain only worse nodes.
-         *
-         * This conjecture fails, see eg:
-         *
-         * d("AB", "B") = 1;
-         * d("AB", "BA") = 2;
-         * d("AB", "BAB") = 1;
-         *
-         * -- if both "B" and "BAB" are in dict., then pruning at "BA" * would
-         * miss "BAB".
-         *
-         * (example courtesy of Richard Bann <richardbann at gmail.com>)
-
-        if (node->parent->eow && dist > trienode_get_dist (node->parent))
-                return 1;
-
-         */
-
-        if (nodevec->nodes[0] &&
-            dist < trienode_get_dist (nodevec->nodes[0])) {
-                /* improving over the findings so far */
-                trienodevec_clear (nodevec);
-                nodevec->nodes[0] = node;
-        } else if (!nodevec->nodes[0] ||
-                   dist == trienode_get_dist (nodevec->nodes[0])) {
-                /* as good as the best so far, add if there is free space */
-                for (i = 0; i < nodevec->cnt; i++) {
-                        if (!nodevec->nodes[i]) {
-                                nodevec->nodes[i] = node;
-                                break;
-                        }
-                }
-        }
+    struct trienodevec_w *nodevec_w = NULL;
+    struct trienodevec *nodevec = NULL;
+    int dist = 0;
+    int i = 0;
+
+    nodevec_w = data;
+    nodevec = nodevec_w->vec;
 
+    if (calc_dist(node, (void *)nodevec_w->word))
+        return -1;
+
+    if (!node->eow || !nodevec->cnt)
         return 0;
-}
 
+    dist = trienode_get_dist(node);
+
+    /*
+     * I thought that when descending further after some dictionary word dw,
+     * if we see that child's distance is bigger than it was for dw, then we
+     * can prune this branch, as it can contain only worse nodes.
+     *
+     * This conjecture fails, see eg:
+     *
+     * d("AB", "B") = 1;
+     * d("AB", "BA") = 2;
+     * d("AB", "BAB") = 1;
+     *
+     * -- if both "B" and "BAB" are in dict., then pruning at "BA" * would
+     * miss "BAB".
+     *
+     * (example courtesy of Richard Bann <richardbann at gmail.com>)
+
+    if (node->parent->eow && dist > trienode_get_dist (node->parent))
+            return 1;
+
+     */
+
+    if (nodevec->nodes[0] && dist < trienode_get_dist(nodevec->nodes[0])) {
+        /* improving over the findings so far */
+        trienodevec_clear(nodevec);
+        nodevec->nodes[0] = node;
+    } else if (!nodevec->nodes[0] ||
+               dist == trienode_get_dist(nodevec->nodes[0])) {
+        /* as good as the best so far, add if there is free space */
+        for (i = 0; i < nodevec->cnt; i++) {
+            if (!nodevec->nodes[i]) {
+                nodevec->nodes[i] = node;
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
 
 int
-trie_measure (trie_t *trie, const char *word, trienode_t **nodes,
-              int nodecnt)
+trie_measure(trie_t *trie, const char *word, trienode_t **nodes, int nodecnt)
 {
-        struct trienodevec nodevec = {0,};
+    struct trienodevec nodevec = {
+        0,
+    };
 
-        nodevec.nodes = nodes;
-        nodevec.cnt = nodecnt;
+    nodevec.nodes = nodes;
+    nodevec.cnt = nodecnt;
 
-        return trie_measure_vec (trie, word, &nodevec);
+    return trie_measure_vec(trie, word, &nodevec);
 }
 
-
 int
-trie_measure_vec (trie_t *trie, const char *word, struct trienodevec *nodevec)
+trie_measure_vec(trie_t *trie, const char *word, struct trienodevec *nodevec)
 {
-        struct trienodevec_w nodevec_w = {0,};
-        int ret = 0;
+    struct trienodevec_w nodevec_w = {
+        0,
+    };
+    int ret = 0;
 
-        trie->len = strlen (word);
+    trie->len = strlen(word);
 
-        trienodevec_clear (nodevec);
-        nodevec_w.vec = nodevec;
-        nodevec_w.word = word;
+    trienodevec_clear(nodevec);
+    nodevec_w.vec = nodevec;
+    nodevec_w.word = word;
 
-        ret = trie_walk (trie, collect_closest, &nodevec_w, 0);
-        if (ret > 0)
-                ret = 0;
+    ret = trie_walk(trie, collect_closest, &nodevec_w, 0);
+    if (ret > 0)
+        ret = 0;
 
-        return ret;
+    return ret;
 }
 
-
 static int
-trienode_reset (trienode_t *node, void *data)
+trienode_reset(trienode_t *node, void *data)
 {
-        GF_FREE (node->data);
+    GF_FREE(node->data);
 
-        return 0;
+    return 0;
 }
 
-
 void
-trie_reset_search (trie_t *trie)
+trie_reset_search(trie_t *trie)
 {
-        trie->len = 0;
+    trie->len = 0;
 
-        trie_walk (trie, trienode_reset, NULL, 0);
+    trie_walk(trie, trienode_reset, NULL, 0);
 }
diff --git a/libglusterfs/src/unittest/global_mock.c b/libglusterfs/src/unittest/global_mock.c
index afdadc4e868..52156847d81 100644
--- a/libglusterfs/src/unittest/global_mock.c
+++ b/libglusterfs/src/unittest/global_mock.c
@@ -18,7 +18,8 @@
 
 #include <cmocka.h>
 
-xlator_t **__glusterfs_this_location ()
+xlator_t **
+__glusterfs_this_location()
 {
     return ((xlator_t **)(uintptr_t)mock());
 }
diff --git a/libglusterfs/src/unittest/log_mock.c b/libglusterfs/src/unittest/log_mock.c
index c03ff524612..d342de31067 100644
--- a/libglusterfs/src/unittest/log_mock.c
+++ b/libglusterfs/src/unittest/log_mock.c
@@ -18,33 +18,35 @@
 
 #include <cmocka.h>
 
-int _gf_log (const char *domain, const char *file,
-             const char *function, int32_t line, gf_loglevel_t level,
-             const char *fmt, ...)
+int
+_gf_log(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-int _gf_log_callingfn (const char *domain, const char *file,
-                       const char *function, int32_t line, gf_loglevel_t level,
-                       const char *fmt, ...)
+int
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-int _gf_log_nomem (const char *domain, const char *file,
-                   const char *function, int line, gf_loglevel_t level,
-                   size_t size)
+int
+_gf_log_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
     return 0;
 }
 
-int _gf_msg_nomem (const char *domain, const char *file,
-                   const char *function, int line, gf_loglevel_t level,
-                   size_t size)
+int
+_gf_msg_nomem(const char *domain, const char *file, const char *function,
+              int line, gf_loglevel_t level, size_t size)
 {
-	return 0;
+    return 0;
 }
 
 void
-gf_log_globals_init (void *data, gf_loglevel_t level) {}
+gf_log_globals_init(void *data, gf_loglevel_t level)
+{
+}
diff --git a/libglusterfs/src/unittest/mem_pool_unittest.c b/libglusterfs/src/unittest/mem_pool_unittest.c
index 00c7688637f..32137b95bb0 100644
--- a/libglusterfs/src/unittest/mem_pool_unittest.c
+++ b/libglusterfs/src/unittest/mem_pool_unittest.c
@@ -21,10 +21,10 @@
 #include <cmocka.h>
 
 #ifndef assert_ptr_equal
-#define assert_ptr_equal(a, b) \
-    _assert_int_equal(cast_ptr_to_largest_integral_type(a), \
-                      cast_ptr_to_largest_integral_type(b), \
-                      __FILE__, __LINE__)
+#define assert_ptr_equal(a, b)                                                 \
+    _assert_int_equal(cast_ptr_to_largest_integral_type(a),                    \
+                      cast_ptr_to_largest_integral_type(b), __FILE__,          \
+                      __LINE__)
 #endif
 
 /*
@@ -42,8 +42,8 @@ typedef struct __attribute__((packed)) {
  * Prototypes to private functions
  */
 int
-gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
-                      uint32_t type, const char *typestr);
+gf_mem_set_acct_info(xlator_t *xl, char **alloc_ptr, size_t size, uint32_t type,
+                     const char *typestr);
 
 /*
  * Helper functions
@@ -59,16 +59,16 @@ helper_xlator_init(uint32_t num_types)
     xl = test_calloc(1, sizeof(xlator_t));
     assert_non_null(xl);
     xl->mem_acct->num_types = num_types;
-    xl->mem_acct = test_calloc (sizeof(struct mem_acct)
-                                + sizeof(struct mem_acct_rec) * num_types);
+    xl->mem_acct = test_calloc(sizeof(struct mem_acct) +
+                               sizeof(struct mem_acct_rec) * num_types);
     assert_non_null(xl->mem_acct);
 
     xl->ctx = test_calloc(1, sizeof(glusterfs_ctx_t));
     assert_non_null(xl->ctx);
 
     for (i = 0; i < num_types; i++) {
-            ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
-            assert_int_equal(ret, 0);
+        ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
+        assert_int_equal(ret, 0);
     }
 
     ENSURE(num_types == xl->mem_acct->num_types);
@@ -83,8 +83,8 @@ helper_xlator_destroy(xlator_t *xl)
     int i, ret;
 
     for (i = 0; i < xl->mem_acct->num_types; i++) {
-            ret = LOCK_DESTROY(&(xl->mem_acct->rec[i].lock));
-            assert_int_equal(ret, 0);
+        ret = LOCK_DESTROY(&(xl->mem_acct->rec[i].lock));
+        assert_int_equal(ret, 0);
     }
 
     free(xl->mem_acct->rec);
@@ -94,20 +94,16 @@ helper_xlator_destroy(xlator_t *xl)
 }
 
 static void
-helper_check_memory_headers( char *mem,
-        xlator_t *xl,
-        size_t size,
-        uint32_t type)
+helper_check_memory_headers(char *mem, xlator_t *xl, size_t size, uint32_t type)
 {
     mem_header_t *p;
 
-    p = (mem_header_t *)mem,
-    assert_int_equal(p->type, type);
+    p = (mem_header_t *)mem, assert_int_equal(p->type, type);
     assert_int_equal(p->size, size);
     assert_true(p->xl == xl);
     assert_int_equal(p->header_magic, GF_MEM_HEADER_MAGIC);
-    assert_true(*(uint32_t *)(mem+sizeof(mem_header_t)+size) == GF_MEM_TRAILER_MAGIC);
-
+    assert_true(*(uint32_t *)(mem + sizeof(mem_header_t) + size) ==
+                GF_MEM_TRAILER_MAGIC);
 }
 
 /*
@@ -116,7 +112,7 @@ helper_check_memory_headers( char *mem,
 static void
 test_gf_mem_acct_enable_set(void **state)
 {
-    (void) state;
+    (void)state;
     glusterfs_ctx_t test_ctx;
 
     expect_assert_failure(gf_mem_acct_enable_set(NULL));
@@ -143,14 +139,16 @@ test_gf_mem_set_acct_info_asserts(void **state)
     size = 8196;
     type = 0;
 
-
     // Check xl is NULL
-    expect_assert_failure(gf_mem_set_acct_info(NULL, &alloc_ptr, size, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(NULL, &alloc_ptr, size, type, ""));
     // Check xl->mem_acct = NULL
-    expect_assert_failure(gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
     // Check type <= xl->mem_acct->num_types
     type = 100;
-    expect_assert_failure(gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
+    expect_assert_failure(
+        gf_mem_set_acct_info(&xltest, &alloc_ptr, 0, type, ""));
     // Check alloc is NULL
     assert_int_equal(-1, gf_mem_set_acct_info(&xltest, NULL, size, type, ""));
 
@@ -189,7 +187,7 @@ test_gf_mem_set_acct_info_memory(void **state)
     alloc_ptr = temp_ptr;
     gf_mem_set_acct_info(xl, &alloc_ptr, size, type, typestr);
 
-    //Check values
+    // Check values
     assert_ptr_equal(typestr, xl->mem_acct->rec[type].typestr);
     assert_int_equal(xl->mem_acct->rec[type].size, size);
     assert_int_equal(xl->mem_acct->rec[type].num_allocs, 1);
@@ -420,10 +418,10 @@ test_gf_realloc_mem_acct_enabled(void **state)
     // not to the realloc + the malloc.
     // Is this a bug?
     //
-    assert_int_equal(xl->mem_acct->rec[type].size, size+1024);
+    assert_int_equal(xl->mem_acct->rec[type].size, size + 1024);
     assert_int_equal(xl->mem_acct->rec[type].num_allocs, 2);
     assert_int_equal(xl->mem_acct->rec[type].total_allocs, 2);
-    assert_int_equal(xl->mem_acct->rec[type].max_size, size+1024);
+    assert_int_equal(xl->mem_acct->rec[type].max_size, size + 1024);
     assert_int_equal(xl->mem_acct->rec[type].max_num_allocs, 2);
 
     // Check memory
@@ -465,7 +463,9 @@ test_gf_realloc_ptr(void **state)
     helper_xlator_destroy(xl);
 }
 
-int main(void) {
+int
+main(void)
+{
     const struct CMUnitTest libglusterfs_mem_pool_tests[] = {
         cmocka_unit_test(test_gf_mem_acct_enable_set),
         cmocka_unit_test(test_gf_mem_set_acct_info_asserts),
diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c
index d3c134ba903..6975fbbd15f 100644
--- a/libglusterfs/src/xlator.c
+++ b/libglusterfs/src/xlator.c
@@ -15,605 +15,599 @@
 #include "defaults.h"
 #include "libglusterfs-messages.h"
 
-#define SET_DEFAULT_FOP(fn) do {                                        \
-                if (!xl->fops->fn)                                      \
-                        xl->fops->fn = default_##fn;                    \
-                if (!xl->pass_through_fops->fn)                         \
-                        xl->pass_through_fops->fn = default_##fn;       \
-        } while (0)
-
-#define SET_DEFAULT_CBK(fn) do {			\
-                if (!xl->cbks->fn)			\
-                        xl->cbks->fn = default_##fn;	\
-        } while (0)
+#define SET_DEFAULT_FOP(fn)                                                    \
+    do {                                                                       \
+        if (!xl->fops->fn)                                                     \
+            xl->fops->fn = default_##fn;                                       \
+        if (!xl->pass_through_fops->fn)                                        \
+            xl->pass_through_fops->fn = default_##fn;                          \
+    } while (0)
+
+#define SET_DEFAULT_CBK(fn)                                                    \
+    do {                                                                       \
+        if (!xl->cbks->fn)                                                     \
+            xl->cbks->fn = default_##fn;                                       \
+    } while (0)
 
 pthread_mutex_t xlator_init_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void
-xlator_init_lock (void)
+xlator_init_lock(void)
 {
-        (void) pthread_mutex_lock (&xlator_init_mutex);
+    (void)pthread_mutex_lock(&xlator_init_mutex);
 }
 
-
 void
-xlator_init_unlock (void)
+xlator_init_unlock(void)
 {
-        (void) pthread_mutex_unlock (&xlator_init_mutex);
+    (void)pthread_mutex_unlock(&xlator_init_mutex);
 }
 
-static struct xlator_cbks default_cbks = { };
+static struct xlator_cbks default_cbks = {};
 struct volume_options default_options[] = {
-        { .key   = {NULL} },
+    {.key = {NULL}},
 };
 
 static void
-fill_defaults (xlator_t *xl)
+fill_defaults(xlator_t *xl)
 {
-        if (xl == NULL)	{
-                gf_msg_callingfn ("xlator", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return;
-        }
-
-        if (!xl->pass_through_fops)
-                xl->pass_through_fops = default_fops;
-
-        SET_DEFAULT_FOP (create);
-        SET_DEFAULT_FOP (open);
-        SET_DEFAULT_FOP (stat);
-        SET_DEFAULT_FOP (readlink);
-        SET_DEFAULT_FOP (mknod);
-        SET_DEFAULT_FOP (mkdir);
-        SET_DEFAULT_FOP (unlink);
-        SET_DEFAULT_FOP (rmdir);
-        SET_DEFAULT_FOP (symlink);
-        SET_DEFAULT_FOP (rename);
-        SET_DEFAULT_FOP (link);
-        SET_DEFAULT_FOP (truncate);
-        SET_DEFAULT_FOP (readv);
-        SET_DEFAULT_FOP (writev);
-        SET_DEFAULT_FOP (statfs);
-        SET_DEFAULT_FOP (flush);
-        SET_DEFAULT_FOP (fsync);
-        SET_DEFAULT_FOP (setxattr);
-        SET_DEFAULT_FOP (getxattr);
-        SET_DEFAULT_FOP (fsetxattr);
-        SET_DEFAULT_FOP (fgetxattr);
-        SET_DEFAULT_FOP (removexattr);
-        SET_DEFAULT_FOP (fremovexattr);
-        SET_DEFAULT_FOP (opendir);
-        SET_DEFAULT_FOP (readdir);
-        SET_DEFAULT_FOP (readdirp);
-        SET_DEFAULT_FOP (fsyncdir);
-        SET_DEFAULT_FOP (access);
-        SET_DEFAULT_FOP (ftruncate);
-        SET_DEFAULT_FOP (fstat);
-        SET_DEFAULT_FOP (lk);
-        SET_DEFAULT_FOP (inodelk);
-        SET_DEFAULT_FOP (finodelk);
-        SET_DEFAULT_FOP (entrylk);
-        SET_DEFAULT_FOP (fentrylk);
-        SET_DEFAULT_FOP (lookup);
-        SET_DEFAULT_FOP (rchecksum);
-        SET_DEFAULT_FOP (xattrop);
-        SET_DEFAULT_FOP (fxattrop);
-        SET_DEFAULT_FOP (setattr);
-        SET_DEFAULT_FOP (fsetattr);
-	SET_DEFAULT_FOP (fallocate);
-	SET_DEFAULT_FOP (discard);
-        SET_DEFAULT_FOP (zerofill);
-        SET_DEFAULT_FOP (ipc);
-        SET_DEFAULT_FOP (seek);
-        SET_DEFAULT_FOP (lease);
-        SET_DEFAULT_FOP (getactivelk);
-        SET_DEFAULT_FOP (setactivelk);
-        SET_DEFAULT_FOP (put);
-
-        SET_DEFAULT_FOP (getspec);
-        SET_DEFAULT_FOP (icreate);
-        SET_DEFAULT_FOP (namelink);
-
-        if (!xl->cbks)
-                xl->cbks = &default_cbks;
-
-        SET_DEFAULT_CBK (release);
-        SET_DEFAULT_CBK (releasedir);
-        SET_DEFAULT_CBK (forget);
-
-        if (!xl->fini)
-                xl->fini = default_fini;
-
-        if (!xl->notify)
-                xl->notify = default_notify;
-
-        if (!xl->mem_acct_init)
-                xl->mem_acct_init = default_mem_acct_init;
-
+    if (xl == NULL) {
+        gf_msg_callingfn("xlator", GF_LOG_WARNING, EINVAL, LG_MSG_INVALID_ARG,
+                         "invalid argument");
         return;
+    }
+
+    if (!xl->pass_through_fops)
+        xl->pass_through_fops = default_fops;
+
+    SET_DEFAULT_FOP(create);
+    SET_DEFAULT_FOP(open);
+    SET_DEFAULT_FOP(stat);
+    SET_DEFAULT_FOP(readlink);
+    SET_DEFAULT_FOP(mknod);
+    SET_DEFAULT_FOP(mkdir);
+    SET_DEFAULT_FOP(unlink);
+    SET_DEFAULT_FOP(rmdir);
+    SET_DEFAULT_FOP(symlink);
+    SET_DEFAULT_FOP(rename);
+    SET_DEFAULT_FOP(link);
+    SET_DEFAULT_FOP(truncate);
+    SET_DEFAULT_FOP(readv);
+    SET_DEFAULT_FOP(writev);
+    SET_DEFAULT_FOP(statfs);
+    SET_DEFAULT_FOP(flush);
+    SET_DEFAULT_FOP(fsync);
+    SET_DEFAULT_FOP(setxattr);
+    SET_DEFAULT_FOP(getxattr);
+    SET_DEFAULT_FOP(fsetxattr);
+    SET_DEFAULT_FOP(fgetxattr);
+    SET_DEFAULT_FOP(removexattr);
+    SET_DEFAULT_FOP(fremovexattr);
+    SET_DEFAULT_FOP(opendir);
+    SET_DEFAULT_FOP(readdir);
+    SET_DEFAULT_FOP(readdirp);
+    SET_DEFAULT_FOP(fsyncdir);
+    SET_DEFAULT_FOP(access);
+    SET_DEFAULT_FOP(ftruncate);
+    SET_DEFAULT_FOP(fstat);
+    SET_DEFAULT_FOP(lk);
+    SET_DEFAULT_FOP(inodelk);
+    SET_DEFAULT_FOP(finodelk);
+    SET_DEFAULT_FOP(entrylk);
+    SET_DEFAULT_FOP(fentrylk);
+    SET_DEFAULT_FOP(lookup);
+    SET_DEFAULT_FOP(rchecksum);
+    SET_DEFAULT_FOP(xattrop);
+    SET_DEFAULT_FOP(fxattrop);
+    SET_DEFAULT_FOP(setattr);
+    SET_DEFAULT_FOP(fsetattr);
+    SET_DEFAULT_FOP(fallocate);
+    SET_DEFAULT_FOP(discard);
+    SET_DEFAULT_FOP(zerofill);
+    SET_DEFAULT_FOP(ipc);
+    SET_DEFAULT_FOP(seek);
+    SET_DEFAULT_FOP(lease);
+    SET_DEFAULT_FOP(getactivelk);
+    SET_DEFAULT_FOP(setactivelk);
+    SET_DEFAULT_FOP(put);
+
+    SET_DEFAULT_FOP(getspec);
+    SET_DEFAULT_FOP(icreate);
+    SET_DEFAULT_FOP(namelink);
+
+    if (!xl->cbks)
+        xl->cbks = &default_cbks;
+
+    SET_DEFAULT_CBK(release);
+    SET_DEFAULT_CBK(releasedir);
+    SET_DEFAULT_CBK(forget);
+
+    if (!xl->fini)
+        xl->fini = default_fini;
+
+    if (!xl->notify)
+        xl->notify = default_notify;
+
+    if (!xl->mem_acct_init)
+        xl->mem_acct_init = default_mem_acct_init;
+
+    return;
 }
 
-
 int
-xlator_set_type_virtual (xlator_t *xl, const char *type)
+xlator_set_type_virtual(xlator_t *xl, const char *type)
 {
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
-        GF_VALIDATE_OR_GOTO ("xlator", type, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", type, out);
 
-        xl->type = gf_strdup (type);
+    xl->type = gf_strdup(type);
 
-        if (xl->type)
-                return 0;
+    if (xl->type)
+        return 0;
 
 out:
-        return -1;
+    return -1;
 }
 
-
 int
-xlator_volopt_dynload (char *xlator_type, void **dl_handle,
-                       volume_opt_list_t *opt_list)
+xlator_volopt_dynload(char *xlator_type, void **dl_handle,
+                      volume_opt_list_t *opt_list)
 {
-        int            ret = -1;
-        char          *name = NULL;
-        void          *handle = NULL;
-        xlator_api_t  *xlapi = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
-
-        /* socket.so doesn't fall under the default xlator directory, hence we
-         * need this check */
-        if (!strstr(xlator_type, "rpc-transport"))
-                ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
-        else
-                ret = gf_asprintf (&name, "%s/%s.so", XLATORPARENTDIR, xlator_type);
-        if (-1 == ret) {
-                goto out;
-        }
-
-        ret = -1;
-
-        gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
-
-        handle = dlopen (name, RTLD_NOW);
-        if (!handle) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto out;
-        }
-
-        /* check new struct first, and then check this */
-        xlapi = dlsym (handle, "xlator_api");
-        if (!xlapi) {
-                gf_msg ("xlator", GF_LOG_DEBUG, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(xlator_api) on %s. "
-                        "Fall back to old symbols", dlerror ());
-                /* This case is not an error for now, so allow it
-                   to fall back to old methods. */
-                opt_list->given_opt = dlsym (handle, "options");
-                if (!opt_list->given_opt) {
-                        dlerror ();
-                        gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
-                                "Failed to load xlator opt table");
-                        goto out;
-                }
-        } else {
-                opt_list->given_opt = xlapi->options;
-                if (!opt_list->given_opt) {
-                        gf_msg ("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
-                                "Failed to load xlator options table");
-                        goto out;
-                }
-        }
-
-        *dl_handle = handle;
-        handle = NULL;
-
-        ret = 0;
- out:
-        GF_FREE (name);
-        if (handle)
-                dlclose (handle);
-
-        gf_msg_debug ("xlator", 0, "Returning %d", ret);
-        return ret;
+    int ret = -1;
+    char *name = NULL;
+    void *handle = NULL;
+    xlator_api_t *xlapi = NULL;
+
+    GF_VALIDATE_OR_GOTO("xlator", xlator_type, out);
+
+    /* socket.so doesn't fall under the default xlator directory, hence we
+     * need this check */
+    if (!strstr(xlator_type, "rpc-transport"))
+        ret = gf_asprintf(&name, "%s/%s.so", XLATORDIR, xlator_type);
+    else
+        ret = gf_asprintf(&name, "%s/%s.so", XLATORPARENTDIR, xlator_type);
+    if (-1 == ret) {
+        goto out;
+    }
+
+    ret = -1;
+
+    gf_msg_trace("xlator", 0, "attempt to load file %s", name);
+
+    handle = dlopen(name, RTLD_NOW);
+    if (!handle) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, "%s",
+               dlerror());
+        goto out;
+    }
+
+    /* check new struct first, and then check this */
+    xlapi = dlsym(handle, "xlator_api");
+    if (!xlapi) {
+        gf_msg("xlator", GF_LOG_DEBUG, 0, LG_MSG_DLSYM_ERROR,
+               "dlsym(xlator_api) on %s. "
+               "Fall back to old symbols",
+               dlerror());
+        /* This case is not an error for now, so allow it
+           to fall back to old methods. */
+        opt_list->given_opt = dlsym(handle, "options");
+        if (!opt_list->given_opt) {
+            dlerror();
+            gf_msg("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
+                   "Failed to load xlator opt table");
+            goto out;
+        }
+    } else {
+        opt_list->given_opt = xlapi->options;
+        if (!opt_list->given_opt) {
+            gf_msg("xlator", GF_LOG_ERROR, 0, LG_MSG_LOAD_FAILED,
+                   "Failed to load xlator options table");
+            goto out;
+        }
+    }
+
+    *dl_handle = handle;
+    handle = NULL;
+
+    ret = 0;
+out:
+    GF_FREE(name);
+    if (handle)
+        dlclose(handle);
 
+    gf_msg_debug("xlator", 0, "Returning %d", ret);
+    return ret;
 }
 
-int xlator_dynload_oldway (xlator_t *xl)
+int
+xlator_dynload_oldway(xlator_t *xl)
 {
-        int                i = 0;
-        int                ret = -1;
-        void              *handle = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        class_methods_t   *vtbl = NULL;
-
-        handle = xl->dlhandle;
-
-        xl->fops = dlsym (handle, "fops");
-        if (!xl->fops) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(fops) on %s", dlerror ());
-                goto out;
-        }
-
-        xl->cbks = dlsym (handle, "cbks");
-        if (!xl->cbks) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(cbks) on %s", dlerror ());
-                goto out;
-        }
-
-        /*
-         * If class_methods exists, its contents override any definitions of
-         * init or fini for that translator.  Otherwise, we fall back to the
-         * older method of looking for init and fini directly.
-         */
-        vtbl = dlsym(handle,"class_methods");
-        if (vtbl) {
-                xl->init        = vtbl->init;
-                xl->fini        = vtbl->fini;
-                xl->reconfigure = vtbl->reconfigure;
-                xl->notify      = vtbl->notify;
-        }
-        else {
-                if (!(*VOID(&xl->init) = dlsym (handle, "init"))) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_DLSYM_ERROR, "dlsym(init) on %s",
-                                dlerror ());
-                        goto out;
-                }
-
-                if (!(*VOID(&(xl->fini)) = dlsym (handle, "fini"))) {
-                        gf_msg ("xlator", GF_LOG_WARNING, 0,
-                                LG_MSG_DLSYM_ERROR, "dlsym(fini) on %s",
-                                dlerror ());
-                        goto out;
-                }
-                if (!(*VOID(&(xl->reconfigure)) = dlsym (handle,
-                                                         "reconfigure"))) {
-                        gf_msg_trace ("xlator", 0, "dlsym(reconfigure) on %s "
-                                      "-- neglecting", dlerror());
-                }
-                if (!(*VOID(&(xl->notify)) = dlsym (handle, "notify"))) {
-                        gf_msg_trace ("xlator", 0, "dlsym(notify) on %s -- "
-                                      "neglecting", dlerror ());
-                }
-
-        }
-
-        if (!(xl->dumpops = dlsym (handle, "dumpops"))) {
-                gf_msg_trace ("xlator", 0, "dlsym(dumpops) on %s -- "
-                              "neglecting", dlerror ());
-        }
-
-        if (!(*VOID(&(xl->mem_acct_init)) = dlsym (handle, "mem_acct_init"))) {
-                gf_msg_trace (xl->name, 0, "dlsym(mem_acct_init) on %s -- "
-                              "neglecting", dlerror ());
-        }
-
-        vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                             gf_common_mt_volume_opt_list_t);
-
-        if (!vol_opt) {
-                goto out;
-        }
-
-        if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
-                gf_msg_trace (xl->name, 0, "Strict option validation not "
-                              "enforced -- neglecting (%s)", dlerror ());
-        }
-        INIT_LIST_HEAD (&vol_opt->list);
-        list_add_tail (&vol_opt->list, &xl->volume_options);
-
-        /* make sure 'min' is set to high value, so it would be
-           properly set later */
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                xl->stats.interval.latencies[i].min = 0xffffffff;
-        }
-
-        ret = 0;
+    int i = 0;
+    int ret = -1;
+    void *handle = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    class_methods_t *vtbl = NULL;
+
+    handle = xl->dlhandle;
+
+    xl->fops = dlsym(handle, "fops");
+    if (!xl->fops) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+               "dlsym(fops) on %s", dlerror());
+        goto out;
+    }
+
+    xl->cbks = dlsym(handle, "cbks");
+    if (!xl->cbks) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+               "dlsym(cbks) on %s", dlerror());
+        goto out;
+    }
+
+    /*
+     * If class_methods exists, its contents override any definitions of
+     * init or fini for that translator.  Otherwise, we fall back to the
+     * older method of looking for init and fini directly.
+     */
+    vtbl = dlsym(handle, "class_methods");
+    if (vtbl) {
+        xl->init = vtbl->init;
+        xl->fini = vtbl->fini;
+        xl->reconfigure = vtbl->reconfigure;
+        xl->notify = vtbl->notify;
+    } else {
+        if (!(*VOID(&xl->init) = dlsym(handle, "init"))) {
+            gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+                   "dlsym(init) on %s", dlerror());
+            goto out;
+        }
+
+        if (!(*VOID(&(xl->fini)) = dlsym(handle, "fini"))) {
+            gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+                   "dlsym(fini) on %s", dlerror());
+            goto out;
+        }
+        if (!(*VOID(&(xl->reconfigure)) = dlsym(handle, "reconfigure"))) {
+            gf_msg_trace("xlator", 0,
+                         "dlsym(reconfigure) on %s "
+                         "-- neglecting",
+                         dlerror());
+        }
+        if (!(*VOID(&(xl->notify)) = dlsym(handle, "notify"))) {
+            gf_msg_trace("xlator", 0,
+                         "dlsym(notify) on %s -- "
+                         "neglecting",
+                         dlerror());
+        }
+    }
+
+    if (!(xl->dumpops = dlsym(handle, "dumpops"))) {
+        gf_msg_trace("xlator", 0,
+                     "dlsym(dumpops) on %s -- "
+                     "neglecting",
+                     dlerror());
+    }
+
+    if (!(*VOID(&(xl->mem_acct_init)) = dlsym(handle, "mem_acct_init"))) {
+        gf_msg_trace(xl->name, 0,
+                     "dlsym(mem_acct_init) on %s -- "
+                     "neglecting",
+                     dlerror());
+    }
+
+    vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                        gf_common_mt_volume_opt_list_t);
+
+    if (!vol_opt) {
+        goto out;
+    }
+
+    if (!(vol_opt->given_opt = dlsym(handle, "options"))) {
+        gf_msg_trace(xl->name, 0,
+                     "Strict option validation not "
+                     "enforced -- neglecting (%s)",
+                     dlerror());
+    }
+    INIT_LIST_HEAD(&vol_opt->list);
+    list_add_tail(&vol_opt->list, &xl->volume_options);
+
+    /* make sure 'min' is set to high value, so it would be
+       properly set later */
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        xl->stats.interval.latencies[i].min = 0xffffffff;
+    }
+
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-int xlator_dynload_newway (xlator_t *xl)
+int
+xlator_dynload_newway(xlator_t *xl)
 {
-        int                ret = -1;
-        void              *handle = NULL;
-        volume_opt_list_t *vol_opt = NULL;
-        xlator_api_t      *xlapi = NULL;
-
-        handle = xl->dlhandle;
-
-        xlapi = dlsym (handle, "xlator_api");
-        if (!xlapi) {
-                gf_msg ("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
-                        "dlsym(xlator_api) on %s. "
-                        "Fall back to old symbols", dlerror ());
-                /* This case is not an error for now, so allow it
-                   to fall back to old methods. */
-                ret = 1;
-                goto out;
-        }
-
-        xl->fops = xlapi->fops;
-        if (!xl->fops) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: struct missing (fops)", xl->name);
-                goto out;
-        }
-
-        xl->cbks = xlapi->cbks;
-        if (!xl->cbks) {
-                gf_msg_trace ("xlator", 0, "%s: struct missing (cbks)",
-                              xl->name);
-        }
+    int ret = -1;
+    void *handle = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    xlator_api_t *xlapi = NULL;
+
+    handle = xl->dlhandle;
+
+    xlapi = dlsym(handle, "xlator_api");
+    if (!xlapi) {
+        gf_msg("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
+               "dlsym(xlator_api) on %s. "
+               "Fall back to old symbols",
+               dlerror());
+        /* This case is not an error for now, so allow it
+           to fall back to old methods. */
+        ret = 1;
+        goto out;
+    }
+
+    xl->fops = xlapi->fops;
+    if (!xl->fops) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+               "%s: struct missing (fops)", xl->name);
+        goto out;
+    }
+
+    xl->cbks = xlapi->cbks;
+    if (!xl->cbks) {
+        gf_msg_trace("xlator", 0, "%s: struct missing (cbks)", xl->name);
+    }
+
+    xl->init = xlapi->init;
+    if (!xl->init) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
+               "%s: method missing (init)", xl->name);
+        goto out;
+    }
+
+    xl->fini = xlapi->fini;
+    if (!xl->fini) {
+        gf_msg_trace("xlator", 0, "%s: method missing (fini)", xl->name);
+    }
+
+    xl->reconfigure = xlapi->reconfigure;
+    if (!xl->reconfigure) {
+        gf_msg_trace("xlator", 0, "%s: method missing (reconfigure)", xl->name);
+    }
+    xl->notify = xlapi->notify;
+    if (!xl->notify) {
+        gf_msg_trace("xlator", 0, "%s: method missing (notify)", xl->name);
+    }
+    xl->dumpops = xlapi->dumpops;
+    if (!xl->dumpops) {
+        gf_msg_trace("xlator", 0, "%s: method missing (dumpops)", xl->name);
+    }
+    xl->mem_acct_init = xlapi->mem_acct_init;
+    if (!xl->mem_acct_init) {
+        gf_msg_trace("xlator", 0, "%s: method missing (mem_acct_init)",
+                     xl->name);
+    }
+
+    xl->dump_metrics = xlapi->dump_metrics;
+    if (!xl->dump_metrics) {
+        gf_msg_trace("xlator", 0, "%s: method missing (dump_metrics)",
+                     xl->name);
+    }
+
+    xl->pass_through_fops = xlapi->pass_through_fops;
+    if (!xl->pass_through_fops) {
+        gf_msg_trace("xlator", 0,
+                     "%s: method missing (pass_through_fops), "
+                     "falling back to default",
+                     xl->name);
+    }
+
+    vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                        gf_common_mt_volume_opt_list_t);
+    if (!vol_opt) {
+        goto out;
+    }
+
+    vol_opt->given_opt = xlapi->options;
+    if (!vol_opt->given_opt) {
+        gf_msg("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
+               "%s: options not provided, using default", xl->name);
+        vol_opt->given_opt = default_options;
+    }
+
+    INIT_LIST_HEAD(&vol_opt->list);
+    list_add_tail(&vol_opt->list, &xl->volume_options);
+
+    xl->id = xlapi->xlator_id;
+    xl->flags = xlapi->flags;
+    xl->identifier = xlapi->identifier;
+    xl->category = xlapi->category;
+
+    memcpy(xl->op_version, xlapi->op_version,
+           sizeof(uint32_t) * GF_MAX_RELEASES);
+
+    ret = 0;
+out:
+    return ret;
+}
 
-        xl->init = xlapi->init;
-        if (!xl->init) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: method missing (init)", xl->name);
-                goto out;
-        }
+int
+xlator_dynload(xlator_t *xl)
+{
+    int ret = -1;
+    char *name = NULL;
+    void *handle = NULL;
 
-        xl->fini = xlapi->fini;
-        if (!xl->fini) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (fini)",
-                              xl->name);
-        }
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        xl->reconfigure = xlapi->reconfigure;
-        if (!xl->reconfigure) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (reconfigure)",
-                              xl->name);
-        }
-        xl->notify = xlapi->notify;
-        if (!xl->notify) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (notify)",
-                              xl->name);
-        }
-        xl->dumpops = xlapi->dumpops;
-        if (!xl->dumpops) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (dumpops)",
-                              xl->name);
-        }
-        xl->mem_acct_init = xlapi->mem_acct_init;
-        if (!xl->mem_acct_init) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (mem_acct_init)",
-                              xl->name);
-        }
+    INIT_LIST_HEAD(&xl->volume_options);
 
-        xl->dump_metrics = xlapi->dump_metrics;
-        if (!xl->dump_metrics) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (dump_metrics)",
-                              xl->name);
-        }
+    ret = gf_asprintf(&name, "%s/%s.so", XLATORDIR, xl->type);
+    if (-1 == ret) {
+        goto out;
+    }
 
-        xl->pass_through_fops = xlapi->pass_through_fops;
-        if (!xl->pass_through_fops) {
-                gf_msg_trace ("xlator", 0, "%s: method missing (pass_through_fops), "
-                              "falling back to default",
-                              xl->name);
-        }
+    ret = -1;
 
-        vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                             gf_common_mt_volume_opt_list_t);
-        if (!vol_opt) {
-                goto out;
-        }
+    gf_msg_trace("xlator", 0, "attempt to load file %s", name);
 
-        vol_opt->given_opt = xlapi->options;
-        if (!vol_opt->given_opt) {
-                gf_msg ("xlator", GF_LOG_INFO, 0, LG_MSG_DLSYM_ERROR,
-                        "%s: options not provided, using default", xl->name);
-                vol_opt->given_opt = default_options;
-        }
+    handle = dlopen(name, RTLD_NOW);
+    if (!handle) {
+        gf_msg("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, "%s",
+               dlerror());
+        goto out;
+    }
+    xl->dlhandle = handle;
 
-        INIT_LIST_HEAD (&vol_opt->list);
-        list_add_tail (&vol_opt->list, &xl->volume_options);
+    ret = xlator_dynload_newway(xl);
+    if (-1 == ret)
+        goto out;
+    if (1 == ret) {
+        /* it means we don't find the new symbol in xlator code */
+        ret = xlator_dynload_oldway(xl);
+        if (-1 == ret)
+            goto out;
+    }
 
-        xl->id         = xlapi->xlator_id;
-        xl->flags      = xlapi->flags;
-        xl->identifier = xlapi->identifier;
-        xl->category   = xlapi->category;
+    fill_defaults(xl);
 
-        memcpy (xl->op_version, xlapi->op_version,
-                sizeof (uint32_t) * GF_MAX_RELEASES);
+    ret = 0;
 
-        ret = 0;
 out:
-        return ret;
+    GF_FREE(name);
+    return ret;
 }
 
-
 int
-xlator_dynload (xlator_t *xl)
+xlator_set_type(xlator_t *xl, const char *type)
 {
-        int                ret = -1;
-        char              *name = NULL;
-        void              *handle = NULL;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
-
-        INIT_LIST_HEAD (&xl->volume_options);
+    int ret = 0;
 
-        ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xl->type);
-        if (-1 == ret) {
-                goto out;
-        }
-
-        ret = -1;
+    /* Handle 'global' translator differently */
+    if (!strncmp(GF_GLOBAL_XLATOR_NAME, type, SLEN(GF_GLOBAL_XLATOR_NAME))) {
+        volume_opt_list_t *vol_opt = NULL;
 
-        gf_msg_trace ("xlator", 0, "attempt to load file %s", name);
+        /* set the required values from Global xlator */
+        xl->type = gf_strdup(GF_GLOBAL_XLATOR_NAME);
+        xl->cbks = global_xlator.cbks;
+        xl->fops = global_xlator.fops;
+        xl->init = global_xlator.init;
+        xl->fini = global_xlator.fini;
+        xl->reconfigure = global_xlator.reconfigure;
 
-        handle = dlopen (name, RTLD_NOW);
-        if (!handle) {
-                gf_msg ("xlator", GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                        "%s", dlerror ());
-                goto out;
+        vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                            gf_common_mt_volume_opt_list_t);
+        if (!vol_opt) {
+            ret = -1;
+            goto out;
         }
-        xl->dlhandle = handle;
 
-        ret = xlator_dynload_newway (xl);
-        if (-1 == ret)
-                goto out;
-        if (1 == ret) {
-                /* it means we don't find the new symbol in xlator code */
-                ret = xlator_dynload_oldway (xl);
-                if (-1 == ret)
-                        goto out;
-        }
+        vol_opt->given_opt = global_xl_options;
 
-        fill_defaults (xl);
+        INIT_LIST_HEAD(&xl->volume_options);
+        INIT_LIST_HEAD(&vol_opt->list);
+        list_add_tail(&vol_opt->list, &xl->volume_options);
 
+        fill_defaults(xl);
         ret = 0;
+        goto out;
+    }
 
+    ret = xlator_set_type_virtual(xl, type);
+    if (!ret)
+        ret = xlator_dynload(xl);
 out:
-        GF_FREE (name);
-        return ret;
-}
-
-
-int
-xlator_set_type (xlator_t *xl, const char *type)
-{
-        int ret = 0;
-
-        /* Handle 'global' translator differently */
-        if (!strncmp (GF_GLOBAL_XLATOR_NAME, type,
-                      SLEN (GF_GLOBAL_XLATOR_NAME))) {
-                volume_opt_list_t *vol_opt = NULL;
-
-                /* set the required values from Global xlator */
-                xl->type = gf_strdup (GF_GLOBAL_XLATOR_NAME);
-                xl->cbks = global_xlator.cbks;
-                xl->fops = global_xlator.fops;
-                xl->init = global_xlator.init;
-                xl->fini = global_xlator.fini;
-                xl->reconfigure = global_xlator.reconfigure;
-
-                vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                                     gf_common_mt_volume_opt_list_t);
-                if (!vol_opt) {
-                        ret = -1;
-                        goto out;
-                }
-
-                vol_opt->given_opt = global_xl_options;
-
-                INIT_LIST_HEAD (&xl->volume_options);
-                INIT_LIST_HEAD (&vol_opt->list);
-                list_add_tail (&vol_opt->list, &xl->volume_options);
-
-                fill_defaults(xl);
-                ret = 0;
-                goto out;
-        }
-
-        ret = xlator_set_type_virtual (xl, type);
-        if (!ret)
-                ret = xlator_dynload (xl);
-out:
-        return ret;
+    return ret;
 }
 
 void
-xlator_set_inode_lru_limit (xlator_t *this, void *data)
+xlator_set_inode_lru_limit(xlator_t *this, void *data)
 {
-        int inode_lru_limit = 0;
-
-        if (this->itable) {
-                if (!data) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                LG_MSG_INVALID_ENTRY, "input data is NULL. "
-                                "Cannot update the lru limit of the inode"
-                                " table. Continuing with older value");
-                        goto out;
-                }
-                inode_lru_limit = *(int *)data;
-                inode_table_set_lru_limit (this->itable, inode_lru_limit);
+    int inode_lru_limit = 0;
+
+    if (this->itable) {
+        if (!data) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_INVALID_ENTRY,
+                   "input data is NULL. "
+                   "Cannot update the lru limit of the inode"
+                   " table. Continuing with older value");
+            goto out;
         }
+        inode_lru_limit = *(int *)data;
+        inode_table_set_lru_limit(this->itable, inode_lru_limit);
+    }
 
 out:
-        return;
+    return;
 }
 
 void
-xlator_foreach (xlator_t *this,
-                void (*fn)(xlator_t *each,
-                           void *data),
-                void *data)
+xlator_foreach(xlator_t *this, void (*fn)(xlator_t *each, void *data),
+               void *data)
 {
-        xlator_t *first    = NULL;
-        xlator_t *old_THIS = NULL;
+    xlator_t *first = NULL;
+    xlator_t *old_THIS = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", this, out);
-        GF_VALIDATE_OR_GOTO ("xlator", fn, out);
+    GF_VALIDATE_OR_GOTO("xlator", this, out);
+    GF_VALIDATE_OR_GOTO("xlator", fn, out);
 
-        first = this;
+    first = this;
 
-        while (first->prev)
-                first = first->prev;
+    while (first->prev)
+        first = first->prev;
 
-        while (first) {
-                old_THIS = THIS;
-                THIS = first;
+    while (first) {
+        old_THIS = THIS;
+        THIS = first;
 
-                fn (first, data);
+        fn(first, data);
 
-                THIS = old_THIS;
-                first = first->next;
-        }
+        THIS = old_THIS;
+        first = first->next;
+    }
 
 out:
-        return;
+    return;
 }
 
-
 void
-xlator_foreach_depth_first (xlator_t *this,
-			    void (*fn)(xlator_t *each, void *data),
-			    void *data)
+xlator_foreach_depth_first(xlator_t *this,
+                           void (*fn)(xlator_t *each, void *data), void *data)
 {
-	xlator_list_t *subv = NULL;
+    xlator_list_t *subv = NULL;
 
-	subv = this->children;
+    subv = this->children;
 
-	while (subv) {
-		xlator_foreach_depth_first (subv->xlator, fn, data);
-		subv = subv->next;
-	}
+    while (subv) {
+        xlator_foreach_depth_first(subv->xlator, fn, data);
+        subv = subv->next;
+    }
 
-	fn (this, data);
+    fn(this, data);
 }
 
-
 xlator_t *
-xlator_search_by_name (xlator_t *any, const char *name)
+xlator_search_by_name(xlator_t *any, const char *name)
 {
-        xlator_t *search = NULL;
+    xlator_t *search = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", any, out);
-        GF_VALIDATE_OR_GOTO ("xlator", name, out);
+    GF_VALIDATE_OR_GOTO("xlator", any, out);
+    GF_VALIDATE_OR_GOTO("xlator", name, out);
 
-        search = any;
+    search = any;
 
-        while (search->prev)
-                search = search->prev;
+    while (search->prev)
+        search = search->prev;
 
-        while (search) {
-                if (!strcmp (search->name, name))
-                        break;
-                search = search->next;
-        }
+    while (search) {
+        if (!strcmp(search->name, name))
+            break;
+        search = search->next;
+    }
 
 out:
-        return search;
+    return search;
 }
 
-
 /*
  * With brick multiplexing, we sort of have multiple graphs, so
  * xlator_search_by_name might not find what we want.  Also, the translator
@@ -623,294 +617,289 @@ out:
  * search instead of a linear search works around both problems.
  */
 static xlator_t *
-get_xlator_by_name_or_type (xlator_t *this, char *target, int is_name)
+get_xlator_by_name_or_type(xlator_t *this, char *target, int is_name)
 {
-        xlator_list_t   *trav;
-        xlator_t        *child_xl;
-        char            *value;
-
-        for (trav = this->children; trav; trav = trav->next) {
-                value = is_name ? trav->xlator->name : trav->xlator->type;
-                if (!strcmp(value, target) && !trav->xlator->cleanup_starting) {
-                        return trav->xlator;
-                }
-                child_xl = get_xlator_by_name_or_type (trav->xlator, target,
-                                                       is_name);
-                if (child_xl) {
-                        /*
-                         * If the xlator we're looking for is somewhere down
-                         * the stack, get_xlator_by_name expects to get a
-                         * pointer to the top of its subtree (child of "this")
-                         * while get_xlator_by_type expects a pointer to what
-                         * we actually found.  Handle both cases here.
-                         *
-                         * TBD: rename the functions and fix callers to better
-                         * reflect the difference in semantics.
-                         */
-                        return is_name ? trav->xlator : child_xl;
-                }
-        }
-
-        return NULL;
+    xlator_list_t *trav;
+    xlator_t *child_xl;
+    char *value;
+
+    for (trav = this->children; trav; trav = trav->next) {
+        value = is_name ? trav->xlator->name : trav->xlator->type;
+        if (!strcmp(value, target) && !trav->xlator->cleanup_starting) {
+            return trav->xlator;
+        }
+        child_xl = get_xlator_by_name_or_type(trav->xlator, target, is_name);
+        if (child_xl) {
+            /*
+             * If the xlator we're looking for is somewhere down
+             * the stack, get_xlator_by_name expects to get a
+             * pointer to the top of its subtree (child of "this")
+             * while get_xlator_by_type expects a pointer to what
+             * we actually found.  Handle both cases here.
+             *
+             * TBD: rename the functions and fix callers to better
+             * reflect the difference in semantics.
+             */
+            return is_name ? trav->xlator : child_xl;
+        }
+    }
+
+    return NULL;
 }
 
 xlator_t *
-get_xlator_by_name (xlator_t *this, char *target)
+get_xlator_by_name(xlator_t *this, char *target)
 {
-        return get_xlator_by_name_or_type (this, target, 1);
+    return get_xlator_by_name_or_type(this, target, 1);
 }
 
 xlator_t *
-get_xlator_by_type (xlator_t *this, char *target)
+get_xlator_by_type(xlator_t *this, char *target)
 {
-        return get_xlator_by_name_or_type (this, target, 0);
+    return get_xlator_by_name_or_type(this, target, 0);
 }
 
 static int
 __xlator_init(xlator_t *xl)
 {
-        xlator_t *old_THIS = NULL;
-        int       ret = 0;
-        int       fop_idx = 0;
+    xlator_t *old_THIS = NULL;
+    int ret = 0;
+    int fop_idx = 0;
 
-        old_THIS = THIS;
-        THIS = xl;
+    old_THIS = THIS;
+    THIS = xl;
 
-        /* initialize the metrics related locks */
-        for (fop_idx = 0; fop_idx < GF_FOP_MAXVALUE; fop_idx++) {
-                GF_ATOMIC_INIT (xl->stats.total.metrics[fop_idx].fop, 0);
-                GF_ATOMIC_INIT (xl->stats.total.metrics[fop_idx].cbk, 0);
+    /* initialize the metrics related locks */
+    for (fop_idx = 0; fop_idx < GF_FOP_MAXVALUE; fop_idx++) {
+        GF_ATOMIC_INIT(xl->stats.total.metrics[fop_idx].fop, 0);
+        GF_ATOMIC_INIT(xl->stats.total.metrics[fop_idx].cbk, 0);
 
-                GF_ATOMIC_INIT (xl->stats.interval.metrics[fop_idx].fop, 0);
-                GF_ATOMIC_INIT (xl->stats.interval.metrics[fop_idx].cbk, 0);
-        }
-        GF_ATOMIC_INIT (xl->stats.total.count, 0);
-        GF_ATOMIC_INIT (xl->stats.interval.count, 0);
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[fop_idx].fop, 0);
+        GF_ATOMIC_INIT(xl->stats.interval.metrics[fop_idx].cbk, 0);
+    }
+    GF_ATOMIC_INIT(xl->stats.total.count, 0);
+    GF_ATOMIC_INIT(xl->stats.interval.count, 0);
 
-        xlator_init_lock ();
-        ret = xl->init (xl);
-        xlator_init_unlock ();
+    xlator_init_lock();
+    ret = xl->init(xl);
+    xlator_init_unlock();
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_init (xlator_t *xl)
+xlator_init(xlator_t *xl)
 {
-        int32_t ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
-
-        if (xl->mem_acct_init)
-                xl->mem_acct_init (xl);
-
-        xl->instance_name = NULL;
-        if (!xl->init) {
-                gf_msg (xl->name, GF_LOG_WARNING, 0, LG_MSG_INIT_FAILED,
-                        "No init() found");
-                goto out;
-        }
-
-        ret = __xlator_init (xl);
-
-        if (ret) {
-                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
-                        "Initialization of volume '%s' failed,"
-                        " review your volfile again", xl->name);
-                goto out;
-        }
-
-        xl->init_succeeded = 1;
-        /*xl->cleanup_starting = 0;
-          xl->call_cleanup = 0;
-        */
-        ret = 0;
+    int32_t ret = -1;
+
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
+
+    if (xl->mem_acct_init)
+        xl->mem_acct_init(xl);
+
+    xl->instance_name = NULL;
+    if (!xl->init) {
+        gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_INIT_FAILED,
+               "No init() found");
+        goto out;
+    }
+
+    ret = __xlator_init(xl);
+
+    if (ret) {
+        gf_msg(xl->name, GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR,
+               "Initialization of volume '%s' failed,"
+               " review your volfile again",
+               xl->name);
+        goto out;
+    }
+
+    xl->init_succeeded = 1;
+    /*xl->cleanup_starting = 0;
+      xl->call_cleanup = 0;
+    */
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static void
-xlator_fini_rec (xlator_t *xl)
+xlator_fini_rec(xlator_t *xl)
 {
-        xlator_list_t *trav     = NULL;
-        xlator_t      *old_THIS = NULL;
+    xlator_list_t *trav = NULL;
+    xlator_t *old_THIS = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        trav = xl->children;
+    trav = xl->children;
 
-        while (trav) {
-                if (!trav->xlator->init_succeeded) {
-                        break;
-                }
-
-                xlator_fini_rec (trav->xlator);
-                gf_msg_debug (trav->xlator->name, 0, "fini done");
-                trav = trav->next;
+    while (trav) {
+        if (!trav->xlator->init_succeeded) {
+            break;
         }
 
-        if (xl->init_succeeded) {
-                if (xl->fini) {
-                        old_THIS = THIS;
-                        THIS = xl;
+        xlator_fini_rec(trav->xlator);
+        gf_msg_debug(trav->xlator->name, 0, "fini done");
+        trav = trav->next;
+    }
+
+    if (xl->init_succeeded) {
+        if (xl->fini) {
+            old_THIS = THIS;
+            THIS = xl;
 
-                        xl->fini (xl);
+            xl->fini(xl);
 
-                        if (xl->local_pool)
-                                mem_pool_destroy (xl->local_pool);
+            if (xl->local_pool)
+                mem_pool_destroy(xl->local_pool);
 
-                        THIS = old_THIS;
-                } else {
-                        gf_msg_debug (xl->name, 0, "No fini() found");
-                }
-                xl->init_succeeded = 0;
+            THIS = old_THIS;
+        } else {
+            gf_msg_debug(xl->name, 0, "No fini() found");
         }
+        xl->init_succeeded = 0;
+    }
 
 out:
-        return;
+    return;
 }
 
-
 int
-xlator_notify (xlator_t *xl, int event, void *data, ...)
+xlator_notify(xlator_t *xl, int event, void *data, ...)
 {
-        xlator_t *old_THIS = NULL;
-        int       ret = 0;
+    xlator_t *old_THIS = NULL;
+    int ret = 0;
 
-        old_THIS = THIS;
-        THIS = xl;
+    old_THIS = THIS;
+    THIS = xl;
 
-        ret = xl->notify (xl, event, data);
+    ret = xl->notify(xl, event, data);
 
-        THIS = old_THIS;
+    THIS = old_THIS;
 
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_mem_acct_init (xlator_t *xl, int num_types)
+xlator_mem_acct_init(xlator_t *xl, int num_types)
 {
-        int             i = 0;
-        int             ret = 0;
+    int i = 0;
+    int ret = 0;
 
-        if (!xl)
-                return -1;
-
-        if (!xl->ctx)
-                return -1;
+    if (!xl)
+        return -1;
 
-        if (!xl->ctx->mem_acct_enable)
-                return 0;
+    if (!xl->ctx)
+        return -1;
 
+    if (!xl->ctx->mem_acct_enable)
+        return 0;
 
-        xl->mem_acct = MALLOC (sizeof(struct mem_acct)
-                               + sizeof(struct mem_acct_rec) * num_types);
+    xl->mem_acct = MALLOC(sizeof(struct mem_acct) +
+                          sizeof(struct mem_acct_rec) * num_types);
 
-        if (!xl->mem_acct) {
-                return -1;
-        }
+    if (!xl->mem_acct) {
+        return -1;
+    }
 
-        xl->mem_acct->num_types = num_types;
-        GF_ATOMIC_INIT (xl->mem_acct->refcnt, 1);
+    xl->mem_acct->num_types = num_types;
+    GF_ATOMIC_INIT(xl->mem_acct->refcnt, 1);
 
-        for (i = 0; i < num_types; i++) {
-                memset (&xl->mem_acct->rec[i], 0, sizeof(struct mem_acct_rec));
-                ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
-                if (ret) {
-                        fprintf(stderr, "Unable to lock..errno : %d",errno);
-                }
+    for (i = 0; i < num_types; i++) {
+        memset(&xl->mem_acct->rec[i], 0, sizeof(struct mem_acct_rec));
+        ret = LOCK_INIT(&(xl->mem_acct->rec[i].lock));
+        if (ret) {
+            fprintf(stderr, "Unable to lock..errno : %d", errno);
+        }
 #ifdef DEBUG
-                INIT_LIST_HEAD(&(xl->mem_acct->rec[i].obj_list));
+        INIT_LIST_HEAD(&(xl->mem_acct->rec[i].obj_list));
 #endif
-        }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 void
-xlator_tree_fini (xlator_t *xl)
+xlator_tree_fini(xlator_t *xl)
 {
-        xlator_t *top = NULL;
+    xlator_t *top = NULL;
 
-        GF_VALIDATE_OR_GOTO ("xlator", xl, out);
+    GF_VALIDATE_OR_GOTO("xlator", xl, out);
 
-        top = xl;
-        xlator_fini_rec (top);
+    top = xl;
+    xlator_fini_rec(top);
 
 out:
-        return;
+    return;
 }
 
 int
-xlator_list_destroy (xlator_list_t *list)
+xlator_list_destroy(xlator_list_t *list)
 {
-        xlator_list_t *next = NULL;
+    xlator_list_t *next = NULL;
 
-        while (list) {
-                next = list->next;
-                GF_FREE (list);
-                list = next;
-        }
+    while (list) {
+        next = list->next;
+        GF_FREE(list);
+        list = next;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-xlator_memrec_free (xlator_t *xl)
+xlator_memrec_free(xlator_t *xl)
 {
-        uint32_t        i               = 0;
-        struct mem_acct *mem_acct       = NULL;
+    uint32_t i = 0;
+    struct mem_acct *mem_acct = NULL;
 
-        if (!xl) {
-                return 0;
+    if (!xl) {
+        return 0;
+    }
+    mem_acct = xl->mem_acct;
+
+    if (mem_acct) {
+        for (i = 0; i < mem_acct->num_types; i++) {
+            LOCK_DESTROY(&(mem_acct->rec[i].lock));
         }
-        mem_acct = xl->mem_acct;
-
-        if (mem_acct) {
-                for (i = 0; i < mem_acct->num_types; i++) {
-                        LOCK_DESTROY (&(mem_acct->rec[i].lock));
-                }
-                if (GF_ATOMIC_DEC (mem_acct->refcnt) == 0) {
-                        FREE (mem_acct);
-                        xl->mem_acct = NULL;
-                }
+        if (GF_ATOMIC_DEC(mem_acct->refcnt) == 0) {
+            FREE(mem_acct);
+            xl->mem_acct = NULL;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-xlator_members_free (xlator_t *xl)
+xlator_members_free(xlator_t *xl)
 {
-        volume_opt_list_t *vol_opt = NULL;
-        volume_opt_list_t *tmp     = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    volume_opt_list_t *tmp = NULL;
 
-        if (!xl)
-                return 0;
+    if (!xl)
+        return 0;
 
-        GF_FREE (xl->name);
-        GF_FREE (xl->type);
-        if (!(xl->ctx && xl->ctx->cmd_args.valgrind) && xl->dlhandle)
-                dlclose (xl->dlhandle);
-        if (xl->options)
-                dict_unref (xl->options);
+    GF_FREE(xl->name);
+    GF_FREE(xl->type);
+    if (!(xl->ctx && xl->ctx->cmd_args.valgrind) && xl->dlhandle)
+        dlclose(xl->dlhandle);
+    if (xl->options)
+        dict_unref(xl->options);
 
-        xlator_list_destroy (xl->children);
+    xlator_list_destroy(xl->children);
 
-        xlator_list_destroy (xl->parents);
+    xlator_list_destroy(xl->parents);
 
-        list_for_each_entry_safe (vol_opt, tmp, &xl->volume_options, list) {
-                list_del_init (&vol_opt->list);
-                GF_FREE (vol_opt);
-        }
+    list_for_each_entry_safe(vol_opt, tmp, &xl->volume_options, list)
+    {
+        list_del_init(&vol_opt->list);
+        GF_FREE(vol_opt);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* This function destroys all the xlator members except for the
@@ -939,609 +928,606 @@ xlator_members_free (xlator_t *xl)
  */
 
 int
-xlator_tree_free_members (xlator_t *tree)
+xlator_tree_free_members(xlator_t *tree)
 {
-        xlator_t *trav = tree;
-        xlator_t *prev = tree;
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
 
-        if (!tree) {
-                gf_msg ("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
-                        "Translator tree not found");
-                return -1;
-        }
+    if (!tree) {
+        gf_msg("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
+               "Translator tree not found");
+        return -1;
+    }
 
-        while (prev) {
-                trav = prev->next;
-                xlator_members_free (prev);
-                prev = trav;
-        }
+    while (prev) {
+        trav = prev->next;
+        xlator_members_free(prev);
+        prev = trav;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-xlator_tree_free_memacct (xlator_t *tree)
+xlator_tree_free_memacct(xlator_t *tree)
 {
-        xlator_t *trav = tree;
-        xlator_t *prev = tree;
+    xlator_t *trav = tree;
+    xlator_t *prev = tree;
 
-        if (!tree) {
-                gf_msg ("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
-                        "Translator tree not found");
-                return -1;
-        }
+    if (!tree) {
+        gf_msg("parser", GF_LOG_ERROR, 0, LG_MSG_TREE_NOT_FOUND,
+               "Translator tree not found");
+        return -1;
+    }
 
-        while (prev) {
-                trav = prev->next;
-                xlator_memrec_free (prev);
-                GF_FREE (prev);
-                prev = trav;
-        }
+    while (prev) {
+        trav = prev->next;
+        xlator_memrec_free(prev);
+        GF_FREE(prev);
+        prev = trav;
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-xlator_mem_free (xlator_t *xl)
+xlator_mem_free(xlator_t *xl)
 {
-        volume_opt_list_t *vol_opt = NULL;
-        volume_opt_list_t *tmp     = NULL;
+    volume_opt_list_t *vol_opt = NULL;
+    volume_opt_list_t *tmp = NULL;
 
-        if (!xl)
-                return 0;
+    if (!xl)
+        return 0;
 
-        if (xl->options) {
-                dict_ref (xl->options);
-                dict_unref (xl->options);
-                xl->options = NULL;
-        }
+    if (xl->options) {
+        dict_ref(xl->options);
+        dict_unref(xl->options);
+        xl->options = NULL;
+    }
 
-        list_for_each_entry_safe (vol_opt, tmp, &xl->volume_options, list) {
-                list_del_init (&vol_opt->list);
-                GF_FREE (vol_opt);
-        }
+    list_for_each_entry_safe(vol_opt, tmp, &xl->volume_options, list)
+    {
+        list_del_init(&vol_opt->list);
+        GF_FREE(vol_opt);
+    }
 
-        xlator_memrec_free (xl);
+    xlator_memrec_free(xl);
 
-        return 0;
+    return 0;
 }
 
 static void
-xlator_call_fini (xlator_t *this) {
-        if (!this || this->cleanup_starting)
-                return;
-        this->cleanup_starting = 1;
-        this->call_cleanup = 1;
-        xlator_call_fini (this->next);
-        this->fini (this);
+xlator_call_fini(xlator_t *this)
+{
+    if (!this || this->cleanup_starting)
+        return;
+    this->cleanup_starting = 1;
+    this->call_cleanup = 1;
+    xlator_call_fini(this->next);
+    this->fini(this);
 }
 
 void
-xlator_mem_cleanup (xlator_t *this) {
-        xlator_list_t     *list         = this->children;
-        xlator_t          *trav         = list->xlator;
-        inode_table_t     *inode_table  = NULL;
-        xlator_t          *prev         = trav;
-        glusterfs_ctx_t   *ctx          = NULL;
-        xlator_list_t    **trav_p       = NULL;
-        xlator_t          *top          = NULL;
-        xlator_t          *victim       = NULL;
-
-
-        if (this->call_cleanup || !this->ctx)
-                return;
-
-        this->call_cleanup = 1;
-        ctx = this->ctx;
-
-        xlator_call_fini (trav);
-
-        while (prev) {
-                trav = prev->next;
-                xlator_mem_free (prev);
-                prev = trav;
-        }
-
-        inode_table = this->itable;
-        if (inode_table) {
-                inode_table_destroy (inode_table);
-                this->itable = NULL;
-        }
-
-        if (this->fini) {
-                this->fini (this);
-        }
+xlator_mem_cleanup(xlator_t *this)
+{
+    xlator_list_t *list = this->children;
+    xlator_t *trav = list->xlator;
+    inode_table_t *inode_table = NULL;
+    xlator_t *prev = trav;
+    glusterfs_ctx_t *ctx = NULL;
+    xlator_list_t **trav_p = NULL;
+    xlator_t *top = NULL;
+    xlator_t *victim = NULL;
+
+    if (this->call_cleanup || !this->ctx)
+        return;
 
-        xlator_mem_free (this);
-
-        if (ctx->active) {
-                top = ctx->active->first;
-                LOCK (&ctx->volfile_lock);
-                /* TODO here we have leak for xlator node in a graph */
-                for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
-                        victim = (*trav_p)->xlator;
-                        if (victim->call_cleanup && !strcmp (victim->name, this->name)) {
-                                        (*trav_p) = (*trav_p)->next;
-                                        break;
-                        }
-                }
-                /* TODO Sometime brick xlator is not moved from graph so followed below
-                   approach to move brick xlator from a graph, will move specific brick
-                   xlator from graph only while inode table and mem_acct are cleaned up
-                */
-                trav_p = &top->children;
-                while (*trav_p) {
-                        victim = (*trav_p)->xlator;
-                        if (victim->call_cleanup && !victim->itable && !victim->mem_acct) {
-                                (*trav_p) = (*trav_p)->next;
-                        } else {
-                                trav_p = &(*trav_p)->next;
-                        }
-                }
-                UNLOCK (&ctx->volfile_lock);
-        }
+    this->call_cleanup = 1;
+    ctx = this->ctx;
+
+    xlator_call_fini(trav);
+
+    while (prev) {
+        trav = prev->next;
+        xlator_mem_free(prev);
+        prev = trav;
+    }
+
+    inode_table = this->itable;
+    if (inode_table) {
+        inode_table_destroy(inode_table);
+        this->itable = NULL;
+    }
+
+    if (this->fini) {
+        this->fini(this);
+    }
+
+    xlator_mem_free(this);
+
+    if (ctx->active) {
+        top = ctx->active->first;
+        LOCK(&ctx->volfile_lock);
+        /* TODO here we have leak for xlator node in a graph */
+        for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {
+            victim = (*trav_p)->xlator;
+            if (victim->call_cleanup && !strcmp(victim->name, this->name)) {
+                (*trav_p) = (*trav_p)->next;
+                break;
+            }
+        }
+        /* TODO Sometime brick xlator is not moved from graph so followed below
+           approach to move brick xlator from a graph, will move specific brick
+           xlator from graph only while inode table and mem_acct are cleaned up
+        */
+        trav_p = &top->children;
+        while (*trav_p) {
+            victim = (*trav_p)->xlator;
+            if (victim->call_cleanup && !victim->itable && !victim->mem_acct) {
+                (*trav_p) = (*trav_p)->next;
+            } else {
+                trav_p = &(*trav_p)->next;
+            }
+        }
+        UNLOCK(&ctx->volfile_lock);
+    }
 }
 
 void
-loc_wipe (loc_t *loc)
+loc_wipe(loc_t *loc)
 {
-        if (loc->inode) {
-                inode_unref (loc->inode);
-                loc->inode = NULL;
-        }
-        if (loc->path) {
-                GF_FREE ((char *)loc->path);
-                loc->path = NULL;
-        }
-
-        if (loc->parent) {
-                inode_unref (loc->parent);
-                loc->parent = NULL;
-        }
-
-        memset (loc, 0, sizeof (*loc));
+    if (loc->inode) {
+        inode_unref(loc->inode);
+        loc->inode = NULL;
+    }
+    if (loc->path) {
+        GF_FREE((char *)loc->path);
+        loc->path = NULL;
+    }
+
+    if (loc->parent) {
+        inode_unref(loc->parent);
+        loc->parent = NULL;
+    }
+
+    memset(loc, 0, sizeof(*loc));
 }
 
 int
-loc_path (loc_t *loc, const char *bname)
+loc_path(loc_t *loc, const char *bname)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        if (loc->path)
-                goto out;
+    if (loc->path)
+        goto out;
 
-        ret = -1;
+    ret = -1;
 
-        if (bname && !strlen (bname))
-                bname = NULL;
+    if (bname && !strlen(bname))
+        bname = NULL;
 
-        if (!bname)
-                goto inode_path;
+    if (!bname)
+        goto inode_path;
 
-        if (loc->parent && !gf_uuid_is_null (loc->parent->gfid)) {
-                ret = inode_path (loc->parent, bname, (char**)&loc->path);
-        } else if (!gf_uuid_is_null (loc->pargfid)) {
-                ret = gf_asprintf ((char**)&loc->path, INODE_PATH_FMT"/%s",
-                                   uuid_utoa (loc->pargfid), bname);
-        }
+    if (loc->parent && !gf_uuid_is_null(loc->parent->gfid)) {
+        ret = inode_path(loc->parent, bname, (char **)&loc->path);
+    } else if (!gf_uuid_is_null(loc->pargfid)) {
+        ret = gf_asprintf((char **)&loc->path, INODE_PATH_FMT "/%s",
+                          uuid_utoa(loc->pargfid), bname);
+    }
 
-        if (loc->path)
-                goto out;
+    if (loc->path)
+        goto out;
 
 inode_path:
-        if (loc->inode && !gf_uuid_is_null (loc->inode->gfid)) {
-                ret = inode_path (loc->inode, NULL, (char **)&loc->path);
-        } else if (!gf_uuid_is_null (loc->gfid)) {
-                ret = gf_asprintf ((char**)&loc->path, INODE_PATH_FMT,
-                                   uuid_utoa (loc->gfid));
-        }
+    if (loc->inode && !gf_uuid_is_null(loc->inode->gfid)) {
+        ret = inode_path(loc->inode, NULL, (char **)&loc->path);
+    } else if (!gf_uuid_is_null(loc->gfid)) {
+        ret = gf_asprintf((char **)&loc->path, INODE_PATH_FMT,
+                          uuid_utoa(loc->gfid));
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void
-loc_gfid (loc_t *loc, uuid_t gfid)
+loc_gfid(loc_t *loc, uuid_t gfid)
 {
-        if (!gfid)
-                goto out;
-        gf_uuid_clear (gfid);
-
-        if (!loc)
-                goto out;
-        else if (!gf_uuid_is_null (loc->gfid))
-                gf_uuid_copy (gfid, loc->gfid);
-        else if (loc->inode && (!gf_uuid_is_null (loc->inode->gfid)))
-                gf_uuid_copy (gfid, loc->inode->gfid);
+    if (!gfid)
+        goto out;
+    gf_uuid_clear(gfid);
+
+    if (!loc)
+        goto out;
+    else if (!gf_uuid_is_null(loc->gfid))
+        gf_uuid_copy(gfid, loc->gfid);
+    else if (loc->inode && (!gf_uuid_is_null(loc->inode->gfid)))
+        gf_uuid_copy(gfid, loc->inode->gfid);
 out:
-        return;
+    return;
 }
 
 void
-loc_pargfid (loc_t *loc, uuid_t gfid)
+loc_pargfid(loc_t *loc, uuid_t gfid)
 {
-        if (!gfid)
-                goto out;
-        gf_uuid_clear (gfid);
-
-        if (!loc)
-                goto out;
-        else if (!gf_uuid_is_null (loc->pargfid))
-                gf_uuid_copy (gfid, loc->pargfid);
-        else if (loc->parent && (!gf_uuid_is_null (loc->parent->gfid)))
-                gf_uuid_copy (gfid, loc->parent->gfid);
+    if (!gfid)
+        goto out;
+    gf_uuid_clear(gfid);
+
+    if (!loc)
+        goto out;
+    else if (!gf_uuid_is_null(loc->pargfid))
+        gf_uuid_copy(gfid, loc->pargfid);
+    else if (loc->parent && (!gf_uuid_is_null(loc->parent->gfid)))
+        gf_uuid_copy(gfid, loc->parent->gfid);
 out:
-        return;
+    return;
 }
 
-char*
-loc_gfid_utoa (loc_t *loc)
+char *
+loc_gfid_utoa(loc_t *loc)
 {
-        uuid_t gfid = {0, };
-        loc_gfid (loc, gfid);
-        return uuid_utoa (gfid);
+    uuid_t gfid = {
+        0,
+    };
+    loc_gfid(loc, gfid);
+    return uuid_utoa(gfid);
 }
 
 int
-loc_touchup (loc_t *loc, const char *name)
+loc_touchup(loc_t *loc, const char *name)
 {
-        char   *path   = NULL;
-        int    ret     = 0;
-
-        if (loc->path)
-                goto out;
-
-        if (loc->parent && name && strlen (name)) {
-                ret = inode_path (loc->parent, name, &path);
-                if (path) /*Guaranteed to have trailing '/' */
-                        loc->name = strrchr (path, '/') + 1;
-
-                if (gf_uuid_is_null (loc->pargfid))
-                        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
-        } else if (loc->inode) {
-                ret = inode_path (loc->inode, 0, &path);
-                if (gf_uuid_is_null (loc->gfid))
-                        gf_uuid_copy (loc->gfid, loc->inode->gfid);
-        }
-
-        if (ret < 0 || !path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        loc->path = path;
-        ret = 0;
+    char *path = NULL;
+    int ret = 0;
+
+    if (loc->path)
+        goto out;
+
+    if (loc->parent && name && strlen(name)) {
+        ret = inode_path(loc->parent, name, &path);
+        if (path) /*Guaranteed to have trailing '/' */
+            loc->name = strrchr(path, '/') + 1;
+
+        if (gf_uuid_is_null(loc->pargfid))
+            gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    } else if (loc->inode) {
+        ret = inode_path(loc->inode, 0, &path);
+        if (gf_uuid_is_null(loc->gfid))
+            gf_uuid_copy(loc->gfid, loc->inode->gfid);
+    }
+
+    if (ret < 0 || !path) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    loc->path = path;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-loc_copy_overload_parent (loc_t *dst, loc_t *src, inode_t *parent)
+loc_copy_overload_parent(loc_t *dst, loc_t *src, inode_t *parent)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", dst, err);
-        GF_VALIDATE_OR_GOTO ("xlator", src, err);
-        GF_VALIDATE_OR_GOTO ("xlator", parent, err);
+    GF_VALIDATE_OR_GOTO("xlator", dst, err);
+    GF_VALIDATE_OR_GOTO("xlator", src, err);
+    GF_VALIDATE_OR_GOTO("xlator", parent, err);
 
-        gf_uuid_copy (dst->gfid, src->gfid);
-        gf_uuid_copy (dst->pargfid, parent->gfid);
+    gf_uuid_copy(dst->gfid, src->gfid);
+    gf_uuid_copy(dst->pargfid, parent->gfid);
 
-        if (src->inode)
-                dst->inode = inode_ref (src->inode);
+    if (src->inode)
+        dst->inode = inode_ref(src->inode);
 
-        if (parent)
-                dst->parent = inode_ref (parent);
+    if (parent)
+        dst->parent = inode_ref(parent);
 
-        if (src->path) {
-                dst->path = gf_strdup (src->path);
+    if (src->path) {
+        dst->path = gf_strdup(src->path);
 
-                if (!dst->path)
-                        goto out;
+        if (!dst->path)
+            goto out;
 
-                if (src->name)
-                        dst->name = strrchr (dst->path, '/');
-                if (dst->name)
-                        dst->name++;
-        } else if (src->name) {
-		dst->name = src->name;
-	}
+        if (src->name)
+            dst->name = strrchr(dst->path, '/');
+        if (dst->name)
+            dst->name++;
+    } else if (src->name) {
+        dst->name = src->name;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1)
-                loc_wipe (dst);
+    if (ret == -1)
+        loc_wipe(dst);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-loc_copy (loc_t *dst, loc_t *src)
+loc_copy(loc_t *dst, loc_t *src)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", dst, err);
-        GF_VALIDATE_OR_GOTO ("xlator", src, err);
+    GF_VALIDATE_OR_GOTO("xlator", dst, err);
+    GF_VALIDATE_OR_GOTO("xlator", src, err);
 
-        if (!gf_uuid_is_null (src->gfid))
-                gf_uuid_copy (dst->gfid, src->gfid);
-        else if (src->inode && !gf_uuid_is_null (src->inode->gfid))
-                gf_uuid_copy (dst->gfid, src->inode->gfid);
+    if (!gf_uuid_is_null(src->gfid))
+        gf_uuid_copy(dst->gfid, src->gfid);
+    else if (src->inode && !gf_uuid_is_null(src->inode->gfid))
+        gf_uuid_copy(dst->gfid, src->inode->gfid);
 
-        gf_uuid_copy (dst->pargfid, src->pargfid);
+    gf_uuid_copy(dst->pargfid, src->pargfid);
 
-        if (src->inode)
-                dst->inode = inode_ref (src->inode);
+    if (src->inode)
+        dst->inode = inode_ref(src->inode);
 
-        if (src->parent)
-                dst->parent = inode_ref (src->parent);
+    if (src->parent)
+        dst->parent = inode_ref(src->parent);
 
-        if (src->path) {
-                dst->path = gf_strdup (src->path);
+    if (src->path) {
+        dst->path = gf_strdup(src->path);
 
-                if (!dst->path)
-                        goto out;
+        if (!dst->path)
+            goto out;
 
-                if (src->name)
-                        dst->name = strrchr (dst->path, '/');
-                if (dst->name)
-                        dst->name++;
-        } else if (src->name) {
-		dst->name = src->name;
-	}
+        if (src->name)
+            dst->name = strrchr(dst->path, '/');
+        if (dst->name)
+            dst->name++;
+    } else if (src->name) {
+        dst->name = src->name;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1)
-                loc_wipe (dst);
+    if (ret == -1)
+        loc_wipe(dst);
 
 err:
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-loc_is_root (loc_t *loc)
+loc_is_root(loc_t *loc)
 {
-        if (loc && __is_root_gfid (loc->gfid)) {
-                return _gf_true;
-        } else if (loc && loc->inode && __is_root_gfid (loc->inode->gfid)) {
-                return _gf_true;
-        }
+    if (loc && __is_root_gfid(loc->gfid)) {
+        return _gf_true;
+    } else if (loc && loc->inode && __is_root_gfid(loc->inode->gfid)) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int32_t
-loc_build_child (loc_t *child, loc_t *parent, char *name)
+loc_build_child(loc_t *child, loc_t *parent, char *name)
 {
-        int32_t  ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("xlator", child, out);
-        GF_VALIDATE_OR_GOTO ("xlator", parent, out);
-        GF_VALIDATE_OR_GOTO ("xlator", name, out);
+    GF_VALIDATE_OR_GOTO("xlator", child, out);
+    GF_VALIDATE_OR_GOTO("xlator", parent, out);
+    GF_VALIDATE_OR_GOTO("xlator", name, out);
 
-        loc_gfid (parent, child->pargfid);
+    loc_gfid(parent, child->pargfid);
 
-        if (strcmp (parent->path, "/") == 0)
-                ret = gf_asprintf ((char **)&child->path, "/%s", name);
-        else
-                ret = gf_asprintf ((char **)&child->path, "%s/%s", parent->path,
-                                   name);
+    if (strcmp(parent->path, "/") == 0)
+        ret = gf_asprintf((char **)&child->path, "/%s", name);
+    else
+        ret = gf_asprintf((char **)&child->path, "%s/%s", parent->path, name);
 
-        if (ret < 0 || !child->path) {
-                ret = -1;
-                goto out;
-        }
+    if (ret < 0 || !child->path) {
+        ret = -1;
+        goto out;
+    }
 
-        child->name = strrchr (child->path, '/') + 1;
+    child->name = strrchr(child->path, '/') + 1;
 
-        child->parent = inode_ref (parent->inode);
-        child->inode = inode_new (parent->inode->table);
+    child->parent = inode_ref(parent->inode);
+    child->inode = inode_new(parent->inode->table);
 
-        if (!child->inode) {
-                ret = -1;
-                goto out;
-        }
+    if (!child->inode) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if ((ret < 0) && child)
-                loc_wipe (child);
+    if ((ret < 0) && child)
+        loc_wipe(child);
 
-        return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-loc_is_nameless (loc_t *loc)
+loc_is_nameless(loc_t *loc)
 {
-        gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("xlator", loc, out);
+    GF_VALIDATE_OR_GOTO("xlator", loc, out);
 
-        if ((!loc->parent && gf_uuid_is_null (loc->pargfid)) || !loc->name)
-                ret = _gf_true;
+    if ((!loc->parent && gf_uuid_is_null(loc->pargfid)) || !loc->name)
+        ret = _gf_true;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xlator_destroy (xlator_t *xl)
+xlator_destroy(xlator_t *xl)
 {
-        if (!xl)
-                return 0;
+    if (!xl)
+        return 0;
 
-        xlator_members_free (xl);
-        xlator_memrec_free (xl);
-        GF_FREE (xl);
+    xlator_members_free(xl);
+    xlator_memrec_free(xl);
+    GF_FREE(xl);
 
-        return 0;
+    return 0;
 }
 
-
 int
-is_gf_log_command (xlator_t *this, const char *name, char *value)
+is_gf_log_command(xlator_t *this, const char *name, char *value)
 {
-        xlator_t       *trav        = NULL;
-        char            key[1024]   = {0,};
-        int             ret         = -1;
-        int             log_level   = -1;
-        gf_boolean_t    syslog_flag = 0;
-        glusterfs_ctx_t *ctx        = NULL;
-
-        if (!strcmp ("trusted.glusterfs.syslog", name)) {
-                ret = gf_string2boolean (value, &syslog_flag);
-                if (ret) {
-                        ret = EOPNOTSUPP;
-                        goto out;
-                }
-                if (syslog_flag)
-                        gf_log_enable_syslog ();
-                else
-                        gf_log_disable_syslog ();
-
-                goto out;
-        }
-
-        if (fnmatch ("trusted.glusterfs*set-log-level", name, FNM_NOESCAPE))
-                goto out;
-
-        log_level = glusterd_check_log_level (value);
-        if (log_level == -1) {
-                ret = EOPNOTSUPP;
-                goto out;
-        }
-
-        /* Some crude way to change the log-level of process */
-        if (!strcmp (name, "trusted.glusterfs.set-log-level")) {
-                gf_msg ("glusterfs", gf_log_get_loglevel(), 0,
-                        LG_MSG_SET_LOG_LEVEL,
-                        "setting log level to %d (old-value=%d)",
-                        log_level, gf_log_get_loglevel());
-                gf_log_set_loglevel (this->ctx, log_level);
-                ret = 0;
-                goto out;
-        }
-
-        if (!strcmp (name, "trusted.glusterfs.fuse.set-log-level")) {
-                /* */
-                gf_msg (this->name, gf_log_get_xl_loglevel (this), 0,
-                        LG_MSG_SET_LOG_LEVEL,
-                        "setting log level to %d (old-value=%d)",
-                        log_level, gf_log_get_xl_loglevel (this));
-                gf_log_set_xl_loglevel (this, log_level);
-                ret = 0;
-                goto out;
-        }
-
-        ctx = this->ctx;
-        if (!ctx)
-                goto out;
-        if (!ctx->active)
-                goto out;
-        trav = ctx->active->top;
-
-        while (trav) {
-                snprintf (key, 1024, "trusted.glusterfs.%s.set-log-level",
-                          trav->name);
-                if (fnmatch (name, key, FNM_NOESCAPE) == 0) {
-                        gf_msg (trav->name, gf_log_get_xl_loglevel (trav), 0,
-                                LG_MSG_SET_LOG_LEVEL,
-                                "setting log level to %d (old-value=%d)",
-                                log_level, gf_log_get_xl_loglevel (trav));
-                        gf_log_set_xl_loglevel (trav, log_level);
-                        ret = 0;
-                }
-                trav = trav->next;
+    xlator_t *trav = NULL;
+    char key[1024] = {
+        0,
+    };
+    int ret = -1;
+    int log_level = -1;
+    gf_boolean_t syslog_flag = 0;
+    glusterfs_ctx_t *ctx = NULL;
+
+    if (!strcmp("trusted.glusterfs.syslog", name)) {
+        ret = gf_string2boolean(value, &syslog_flag);
+        if (ret) {
+            ret = EOPNOTSUPP;
+            goto out;
         }
+        if (syslog_flag)
+            gf_log_enable_syslog();
+        else
+            gf_log_disable_syslog();
+
+        goto out;
+    }
+
+    if (fnmatch("trusted.glusterfs*set-log-level", name, FNM_NOESCAPE))
+        goto out;
+
+    log_level = glusterd_check_log_level(value);
+    if (log_level == -1) {
+        ret = EOPNOTSUPP;
+        goto out;
+    }
+
+    /* Some crude way to change the log-level of process */
+    if (!strcmp(name, "trusted.glusterfs.set-log-level")) {
+        gf_msg("glusterfs", gf_log_get_loglevel(), 0, LG_MSG_SET_LOG_LEVEL,
+               "setting log level to %d (old-value=%d)", log_level,
+               gf_log_get_loglevel());
+        gf_log_set_loglevel(this->ctx, log_level);
+        ret = 0;
+        goto out;
+    }
+
+    if (!strcmp(name, "trusted.glusterfs.fuse.set-log-level")) {
+        /* */
+        gf_msg(this->name, gf_log_get_xl_loglevel(this), 0,
+               LG_MSG_SET_LOG_LEVEL, "setting log level to %d (old-value=%d)",
+               log_level, gf_log_get_xl_loglevel(this));
+        gf_log_set_xl_loglevel(this, log_level);
+        ret = 0;
+        goto out;
+    }
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto out;
+    if (!ctx->active)
+        goto out;
+    trav = ctx->active->top;
+
+    while (trav) {
+        snprintf(key, 1024, "trusted.glusterfs.%s.set-log-level", trav->name);
+        if (fnmatch(name, key, FNM_NOESCAPE) == 0) {
+            gf_msg(trav->name, gf_log_get_xl_loglevel(trav), 0,
+                   LG_MSG_SET_LOG_LEVEL,
+                   "setting log level to %d (old-value=%d)", log_level,
+                   gf_log_get_xl_loglevel(trav));
+            gf_log_set_xl_loglevel(trav, log_level);
+            ret = 0;
+        }
+        trav = trav->next;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-glusterd_check_log_level (const char *value)
+glusterd_check_log_level(const char *value)
 {
-        int log_level = -1;
-
-        if (!strcasecmp (value, "CRITICAL")) {
-                log_level = GF_LOG_CRITICAL;
-        } else if (!strcasecmp (value, "ERROR")) {
-                log_level = GF_LOG_ERROR;
-        } else if (!strcasecmp (value, "WARNING")) {
-                log_level = GF_LOG_WARNING;
-        } else if (!strcasecmp (value, "INFO")) {
-                log_level = GF_LOG_INFO;
-        } else if (!strcasecmp (value, "DEBUG")) {
-                log_level = GF_LOG_DEBUG;
-        } else if (!strcasecmp (value, "TRACE")) {
-                log_level = GF_LOG_TRACE;
-        } else if (!strcasecmp (value, "NONE")) {
-                log_level = GF_LOG_NONE;
-        }
-
-        if (log_level == -1)
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
-                        "Invalid log-level. possible values are "
-                        "DEBUG|WARNING|ERROR|CRITICAL|NONE|TRACE");
-
-        return log_level;
+    int log_level = -1;
+
+    if (!strcasecmp(value, "CRITICAL")) {
+        log_level = GF_LOG_CRITICAL;
+    } else if (!strcasecmp(value, "ERROR")) {
+        log_level = GF_LOG_ERROR;
+    } else if (!strcasecmp(value, "WARNING")) {
+        log_level = GF_LOG_WARNING;
+    } else if (!strcasecmp(value, "INFO")) {
+        log_level = GF_LOG_INFO;
+    } else if (!strcasecmp(value, "DEBUG")) {
+        log_level = GF_LOG_DEBUG;
+    } else if (!strcasecmp(value, "TRACE")) {
+        log_level = GF_LOG_TRACE;
+    } else if (!strcasecmp(value, "NONE")) {
+        log_level = GF_LOG_NONE;
+    }
+
+    if (log_level == -1)
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED,
+               "Invalid log-level. possible values are "
+               "DEBUG|WARNING|ERROR|CRITICAL|NONE|TRACE");
+
+    return log_level;
 }
 
 int
-xlator_subvolume_count (xlator_t *this)
+xlator_subvolume_count(xlator_t *this)
 {
-        int i = 0;
-        xlator_list_t *list = NULL;
+    int i = 0;
+    xlator_list_t *list = NULL;
 
-        for (list = this->children; list; list = list->next)
-                i++;
-        return i;
+    for (list = this->children; list; list = list->next)
+        i++;
+    return i;
 }
 
 static int
-_copy_opt_to_child (dict_t *options, char *key, data_t *value, void *data)
+_copy_opt_to_child(dict_t *options, char *key, data_t *value, void *data)
 {
-        xlator_t        *child = data;
+    xlator_t *child = data;
 
-        gf_log (__func__, GF_LOG_DEBUG,
-                "copying %s to child %s", key, child->name);
-        dict_set (child->options, key, value);
+    gf_log(__func__, GF_LOG_DEBUG, "copying %s to child %s", key, child->name);
+    dict_set(child->options, key, value);
 
-        return 0;
+    return 0;
 }
 
 int
-copy_opts_to_child (xlator_t *src, xlator_t *dst, char *glob)
+copy_opts_to_child(xlator_t *src, xlator_t *dst, char *glob)
 {
-        return dict_foreach_fnmatch (src->options, glob,
-                                     _copy_opt_to_child, dst);
+    return dict_foreach_fnmatch(src->options, glob, _copy_opt_to_child, dst);
 }
 
 int
-glusterfs_delete_volfile_checksum (glusterfs_ctx_t *ctx,
-                                   const char *volfile_id) {
-
-        gf_volfile_t            *volfile_tmp      = NULL;
-        gf_volfile_t            *volfile_obj      = NULL;
-
-        list_for_each_entry (volfile_tmp,  &ctx->volfile_list,
-                             volfile_list) {
-                if (!strcmp (volfile_id, volfile_tmp->vol_id)) {
-                        list_del_init (&volfile_tmp->volfile_list);
-                        volfile_obj = volfile_tmp;
-                        break;
-                }
-        }
-
-        if (volfile_obj) {
-                GF_FREE (volfile_obj);
-        } else {
-                gf_log (THIS->name, GF_LOG_ERROR, "failed to get volfile "
-                        "checksum for volfile id %s.", volfile_id);
-        }
-
-        return 0;
+glusterfs_delete_volfile_checksum(glusterfs_ctx_t *ctx, const char *volfile_id)
+{
+    gf_volfile_t *volfile_tmp = NULL;
+    gf_volfile_t *volfile_obj = NULL;
+
+    list_for_each_entry(volfile_tmp, &ctx->volfile_list, volfile_list)
+    {
+        if (!strcmp(volfile_id, volfile_tmp->vol_id)) {
+            list_del_init(&volfile_tmp->volfile_list);
+            volfile_obj = volfile_tmp;
+            break;
+        }
+    }
+
+    if (volfile_obj) {
+        GF_FREE(volfile_obj);
+    } else {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to get volfile "
+               "checksum for volfile id %s.",
+               volfile_id);
+    }
+
+    return 0;
 }
diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c
index 78f283557b0..d569a0403f8 100644
--- a/rpc/rpc-lib/src/auth-glusterfs.c
+++ b/rpc/rpc-lib/src/auth-glusterfs.c
@@ -8,8 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include "rpcsvc.h"
 #include "list.h"
 #include "dict.h"
@@ -21,386 +19,369 @@
 /* V1 */
 
 ssize_t
-xdr_to_glusterfs_auth (char *buf, struct auth_glusterfs_parms *req)
+xdr_to_glusterfs_auth(char *buf, struct auth_glusterfs_parms *req)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
-
-        if ((!buf) || (!req))
-                return -1;
-
-        xdrmem_create (&xdr, buf, sizeof (struct auth_glusterfs_parms),
-                       XDR_DECODE);
-        if (!xdr_auth_glusterfs_parms (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs parameters");
-                ret  = -1;
-                goto ret;
-        }
-
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
-ret:
-        return ret;
+    XDR xdr;
+    ssize_t ret = -1;
 
+    if ((!buf) || (!req))
+        return -1;
+
+    xdrmem_create(&xdr, buf, sizeof(struct auth_glusterfs_parms), XDR_DECODE);
+    if (!xdr_auth_glusterfs_parms(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs parameters");
+        ret = -1;
+        goto ret;
+    }
+
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+ret:
+    return ret;
 }
 int
-auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_glusterfs_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        struct auth_glusterfs_parms  au = {0,};
-
-        int ret      = RPCSVC_AUTH_REJECT;
-        int j        = 0;
-        int i        = 0;
-        int gidcount = 0;
-
-        if (!req)
-                return ret;
-
-        ret = xdr_to_glusterfs_auth (req->cred.authdata, &au);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        req->pid = au.pid;
-        req->uid = au.uid;
-        req->gid = au.gid;
-        req->lk_owner.len = 8;
-        {
-                for (i = 0; i < req->lk_owner.len; i++, j += 8)
-                        req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff);
-        }
-        req->auxgidcount = au.ngrps;
-
-        if (req->auxgidcount > 16) {
-                gf_log ("", GF_LOG_WARNING,
-                        "more than 16 aux gids found, failing authentication");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-	if (req->auxgidcount > SMALL_GROUP_COUNT) {
-		req->auxgidlarge = GF_CALLOC(req->auxgidcount,
-					     sizeof(req->auxgids[0]),
-					     gf_common_mt_auxgids);
-		req->auxgids = req->auxgidlarge;
-	} else {
-		req->auxgids = req->auxgidsmall;
-	}
-
-	if (!req->auxgids) {
-		gf_log ("auth-glusterfs", GF_LOG_WARNING,
-			"cannot allocate gid list");
-		ret = RPCSVC_AUTH_REJECT;
-		goto err;
-	}
-
-        for (gidcount = 0; gidcount < au.ngrps; ++gidcount)
-                req->auxgids[gidcount] = au.groups[gidcount];
-
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s",
-                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
-        ret = RPCSVC_AUTH_ACCEPT;
-err:
+    struct auth_glusterfs_parms au = {
+        0,
+    };
+
+    int ret = RPCSVC_AUTH_REJECT;
+    int j = 0;
+    int i = 0;
+    int gidcount = 0;
+
+    if (!req)
         return ret;
+
+    ret = xdr_to_glusterfs_auth(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = 8;
+    {
+        for (i = 0; i < req->lk_owner.len; i++, j += 8)
+            req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff);
+    }
+    req->auxgidcount = au.ngrps;
+
+    if (req->auxgidcount > 16) {
+        gf_log("", GF_LOG_WARNING,
+               "more than 16 aux gids found, failing authentication");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (gidcount = 0; gidcount < au.ngrps; ++gidcount)
+        req->auxgids[gidcount] = au.groups[gidcount];
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner));
+    ret = RPCSVC_AUTH_ACCEPT;
+err:
+    return ret;
 }
 
 rpcsvc_auth_ops_t auth_glusterfs_ops = {
-        .transport_init         = NULL,
-        .request_init           = auth_glusterfs_request_init,
-        .authenticate           = auth_glusterfs_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_glusterfs = {
-        .authname       = "AUTH_GLUSTERFS",
-        .authnum        = AUTH_GLUSTERFS,
-        .authops        = &auth_glusterfs_ops,
-        .authprivate    = NULL
-};
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_request_init,
+    .authenticate = auth_glusterfs_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_glusterfs = {.authname = "AUTH_GLUSTERFS",
+                                       .authnum = AUTH_GLUSTERFS,
+                                       .authops = &auth_glusterfs_ops,
+                                       .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs;
+    return &rpcsvc_auth_glusterfs;
 }
 
 /* V2 */
 
 ssize_t
-xdr_to_glusterfs_auth_v2 (char *buf, struct auth_glusterfs_parms_v2 *req)
+xdr_to_glusterfs_auth_v2(char *buf, struct auth_glusterfs_parms_v2 *req)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!buf) || (!req))
-                return -1;
+    if ((!buf) || (!req))
+        return -1;
 
-        xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
-        if (!xdr_auth_glusterfs_parms_v2 (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs v2 parameters");
-                ret  = -1;
-                goto ret;
-        }
+    xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
+    if (!xdr_auth_glusterfs_parms_v2(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v2 parameters");
+        ret = -1;
+        goto ret;
+    }
 
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 ret:
-        return ret;
-
+    return ret;
 }
 int
-auth_glusterfs_v2_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_v2_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_v2_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_glusterfs_v2_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        struct auth_glusterfs_parms_v2  au = {0,};
-        int ret                            = RPCSVC_AUTH_REJECT;
-        int i                              = 0;
-        int max_groups                     = 0;
-        int max_lk_owner_len               = 0;
-
-        if (!req)
-                return ret;
-
-        ret = xdr_to_glusterfs_auth_v2 (req->cred.authdata, &au);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        req->pid = au.pid;
-        req->uid = au.uid;
-        req->gid = au.gid;
-        req->lk_owner.len = au.lk_owner.lk_owner_len;
-        req->auxgidcount = au.groups.groups_len;
-
-        /* the number of groups and size of lk_owner depend on each other */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (req->lk_owner.len,
-                                                   AUTH_GLUSTERFS_v2);
-        max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (req->auxgidcount,
-                                                          AUTH_GLUSTERFS_v2);
-
-        if (req->auxgidcount > max_groups) {
-                gf_log ("", GF_LOG_WARNING,
-                        "more than max aux gids found (%d) , truncating it "
-                        "to %d and continuing", au.groups.groups_len,
-                        max_groups);
-                req->auxgidcount = max_groups;
-        }
-
-        if (req->lk_owner.len > max_lk_owner_len) {
-                gf_log ("", GF_LOG_WARNING,
-                        "lkowner field to big (%d), depends on the number of "
-                        "groups (%d), failing authentication",
-                        req->lk_owner.len, req->auxgidcount);
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-	if (req->auxgidcount > SMALL_GROUP_COUNT) {
-		req->auxgidlarge = GF_CALLOC(req->auxgidcount,
-					     sizeof(req->auxgids[0]),
-					     gf_common_mt_auxgids);
-		req->auxgids = req->auxgidlarge;
-	} else {
-		req->auxgids = req->auxgidsmall;
-	}
-
-	if (!req->auxgids) {
-		gf_log ("auth-glusterfs-v2", GF_LOG_WARNING,
-			"cannot allocate gid list");
-		ret = RPCSVC_AUTH_REJECT;
-		goto err;
-	}
-
-        for (i = 0; i < req->auxgidcount; ++i)
-                req->auxgids[i] = au.groups.groups_val[i];
-
-        for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
-                req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
-
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s",
-                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
-        ret = RPCSVC_AUTH_ACCEPT;
+    struct auth_glusterfs_parms_v2 au = {
+        0,
+    };
+    int ret = RPCSVC_AUTH_REJECT;
+    int i = 0;
+    int max_groups = 0;
+    int max_lk_owner_len = 0;
+
+    if (!req)
+        return ret;
+
+    ret = xdr_to_glusterfs_auth_v2(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = au.lk_owner.lk_owner_len;
+    req->auxgidcount = au.groups.groups_len;
+
+    /* the number of groups and size of lk_owner depend on each other */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len,
+                                              AUTH_GLUSTERFS_v2);
+    max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount,
+                                                     AUTH_GLUSTERFS_v2);
+
+    if (req->auxgidcount > max_groups) {
+        gf_log("", GF_LOG_WARNING,
+               "more than max aux gids found (%d) , truncating it "
+               "to %d and continuing",
+               au.groups.groups_len, max_groups);
+        req->auxgidcount = max_groups;
+    }
+
+    if (req->lk_owner.len > max_lk_owner_len) {
+        gf_log("", GF_LOG_WARNING,
+               "lkowner field to big (%d), depends on the number of "
+               "groups (%d), failing authentication",
+               req->lk_owner.len, req->auxgidcount);
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (i = 0; i < req->auxgidcount; ++i)
+        req->auxgids[i] = au.groups.groups_val[i];
+
+    for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
+        req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner));
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        /* TODO: instead use alloca() for these variables */
-        free (au.groups.groups_val);
-        free (au.lk_owner.lk_owner_val);
+    /* TODO: instead use alloca() for these variables */
+    free(au.groups.groups_val);
+    free(au.lk_owner.lk_owner_val);
 
-        return ret;
+    return ret;
 }
 
 rpcsvc_auth_ops_t auth_glusterfs_ops_v2 = {
-        .transport_init         = NULL,
-        .request_init           = auth_glusterfs_v2_request_init,
-        .authenticate           = auth_glusterfs_v2_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {
-        .authname       = "AUTH_GLUSTERFS-v2",
-        .authnum        = AUTH_GLUSTERFS_v2,
-        .authops        = &auth_glusterfs_ops_v2,
-        .authprivate    = NULL
-};
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_v2_request_init,
+    .authenticate = auth_glusterfs_v2_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {.authname = "AUTH_GLUSTERFS-v2",
+                                          .authnum = AUTH_GLUSTERFS_v2,
+                                          .authops = &auth_glusterfs_ops_v2,
+                                          .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs_v2;
+    return &rpcsvc_auth_glusterfs_v2;
 }
 
 /* V3 */
 
 ssize_t
-xdr_to_glusterfs_auth_v3 (char *buf, struct auth_glusterfs_params_v3 *req)
+xdr_to_glusterfs_auth_v3(char *buf, struct auth_glusterfs_params_v3 *req)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!buf) || (!req))
-                return -1;
+    if ((!buf) || (!req))
+        return -1;
 
-        xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
-        if (!xdr_auth_glusterfs_params_v3 (&xdr, req)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs v3 parameters");
-                ret  = -1;
-                goto ret;
-        }
+    xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
+    if (!xdr_auth_glusterfs_params_v3(&xdr, req)) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v3 parameters");
+        ret = -1;
+        goto ret;
+    }
 
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 ret:
-        return ret;
+    return ret;
 }
 
 int
-auth_glusterfs_v3_request_init (rpcsvc_request_t *req, void *priv)
+auth_glusterfs_v3_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_glusterfs_v3_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_glusterfs_v3_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        struct auth_glusterfs_params_v3  au = {0,};
-        int ret                            = RPCSVC_AUTH_REJECT;
-        int i                              = 0;
-        int max_groups                     = 0;
-        int max_lk_owner_len               = 0;
-
-        if (!req)
-                return ret;
-
-        ret = xdr_to_glusterfs_auth_v3 (req->cred.authdata, &au);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING,
-                        "failed to decode glusterfs credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        req->pid = au.pid;
-        req->uid = au.uid;
-        req->gid = au.gid;
-        req->lk_owner.len = au.lk_owner.lk_owner_len;
-        req->auxgidcount = au.groups.groups_len;
-
-        /* the number of groups and size of lk_owner depend on each other */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (req->lk_owner.len,
-                                                   AUTH_GLUSTERFS_v3);
-        max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (req->auxgidcount,
-                                                          AUTH_GLUSTERFS_v3);
-
-        if (req->auxgidcount > max_groups) {
-                gf_log ("", GF_LOG_WARNING,
-                        "more than max aux gids found (%d) , truncating it "
-                        "to %d and continuing", au.groups.groups_len,
-                        max_groups);
-                req->auxgidcount = max_groups;
-        }
-
-        if (req->lk_owner.len > max_lk_owner_len) {
-                gf_log ("", GF_LOG_WARNING,
-                        "lkowner field to big (%d), depends on the number of "
-                        "groups (%d), failing authentication",
-                        req->lk_owner.len, req->auxgidcount);
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-	if (req->auxgidcount > SMALL_GROUP_COUNT) {
-		req->auxgidlarge = GF_CALLOC(req->auxgidcount,
-					     sizeof(req->auxgids[0]),
-					     gf_common_mt_auxgids);
-		req->auxgids = req->auxgidlarge;
-	} else {
-		req->auxgids = req->auxgidsmall;
-	}
-
-	if (!req->auxgids) {
-		gf_log ("auth-glusterfs-v2", GF_LOG_WARNING,
-			"cannot allocate gid list");
-		ret = RPCSVC_AUTH_REJECT;
-		goto err;
-	}
-
-        for (i = 0; i < req->auxgidcount; ++i)
-                req->auxgids[i] = au.groups.groups_val[i];
-
-        for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
-                req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
-
-        /* All new things, starting glusterfs-4.0.0 */
-        req->flags = au.flags;
-        req->ctime.tv_sec = au.ctime_sec;
-        req->ctime.tv_nsec = au.ctime_nsec;
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %s, flags: %d",
-                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner),
-                req->flags);
-        ret = RPCSVC_AUTH_ACCEPT;
+    struct auth_glusterfs_params_v3 au = {
+        0,
+    };
+    int ret = RPCSVC_AUTH_REJECT;
+    int i = 0;
+    int max_groups = 0;
+    int max_lk_owner_len = 0;
+
+    if (!req)
+        return ret;
+
+    ret = xdr_to_glusterfs_auth_v3(req->cred.authdata, &au);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    req->pid = au.pid;
+    req->uid = au.uid;
+    req->gid = au.gid;
+    req->lk_owner.len = au.lk_owner.lk_owner_len;
+    req->auxgidcount = au.groups.groups_len;
+
+    /* the number of groups and size of lk_owner depend on each other */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len,
+                                              AUTH_GLUSTERFS_v3);
+    max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount,
+                                                     AUTH_GLUSTERFS_v3);
+
+    if (req->auxgidcount > max_groups) {
+        gf_log("", GF_LOG_WARNING,
+               "more than max aux gids found (%d) , truncating it "
+               "to %d and continuing",
+               au.groups.groups_len, max_groups);
+        req->auxgidcount = max_groups;
+    }
+
+    if (req->lk_owner.len > max_lk_owner_len) {
+        gf_log("", GF_LOG_WARNING,
+               "lkowner field to big (%d), depends on the number of "
+               "groups (%d), failing authentication",
+               req->lk_owner.len, req->auxgidcount);
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    if (req->auxgidcount > SMALL_GROUP_COUNT) {
+        req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]),
+                                     gf_common_mt_auxgids);
+        req->auxgids = req->auxgidlarge;
+    } else {
+        req->auxgids = req->auxgidsmall;
+    }
+
+    if (!req->auxgids) {
+        gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    for (i = 0; i < req->auxgidcount; ++i)
+        req->auxgids[i] = au.groups.groups_val[i];
+
+    for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
+        req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
+
+    /* All new things, starting glusterfs-4.0.0 */
+    req->flags = au.flags;
+    req->ctime.tv_sec = au.ctime_sec;
+    req->ctime.tv_nsec = au.ctime_nsec;
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: pid: %u, uid: %d"
+           ", gid: %d, owner: %s, flags: %d",
+           req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner),
+           req->flags);
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        /* TODO: instead use alloca() for these variables */
-        free (au.groups.groups_val);
-        free (au.lk_owner.lk_owner_val);
+    /* TODO: instead use alloca() for these variables */
+    free(au.groups.groups_val);
+    free(au.lk_owner.lk_owner_val);
 
-        return ret;
+    return ret;
 }
 
 rpcsvc_auth_ops_t auth_glusterfs_ops_v3 = {
-        .transport_init         = NULL,
-        .request_init           = auth_glusterfs_v3_request_init,
-        .authenticate           = auth_glusterfs_v3_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_glusterfs_v3 = {
-        .authname       = "AUTH_GLUSTERFS-v3",
-        .authnum        = AUTH_GLUSTERFS_v3,
-        .authops        = &auth_glusterfs_ops_v3,
-        .authprivate    = NULL
-};
+    .transport_init = NULL,
+    .request_init = auth_glusterfs_v3_request_init,
+    .authenticate = auth_glusterfs_v3_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_glusterfs_v3 = {.authname = "AUTH_GLUSTERFS-v3",
+                                          .authnum = AUTH_GLUSTERFS_v3,
+                                          .authops = &auth_glusterfs_ops_v3,
+                                          .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v3_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_glusterfs_v3;
+    return &rpcsvc_auth_glusterfs_v3;
 }
diff --git a/rpc/rpc-lib/src/auth-null.c b/rpc/rpc-lib/src/auth-null.c
index 774fdc8da3a..46046e8e440 100644
--- a/rpc/rpc-lib/src/auth-null.c
+++ b/rpc/rpc-lib/src/auth-null.c
@@ -8,40 +8,34 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "rpcsvc.h"
 #include "list.h"
 #include "dict.h"
 
-
 int
-auth_null_request_init (rpcsvc_request_t *req, void *priv)
+auth_null_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_null_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_null_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        /* Always succeed. */
-        return RPCSVC_AUTH_ACCEPT;
+    /* Always succeed. */
+    return RPCSVC_AUTH_ACCEPT;
 }
 
-rpcsvc_auth_ops_t auth_null_ops = {
-        .transport_init              = NULL,
-        .request_init           = auth_null_request_init,
-        .authenticate           = auth_null_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_null = {
-        .authname       = "AUTH_NULL",
-        .authnum        = AUTH_NULL,
-        .authops        = &auth_null_ops,
-        .authprivate    = NULL
-};
+rpcsvc_auth_ops_t auth_null_ops = {.transport_init = NULL,
+                                   .request_init = auth_null_request_init,
+                                   .authenticate = auth_null_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_null = {.authname = "AUTH_NULL",
+                                  .authnum = AUTH_NULL,
+                                  .authops = &auth_null_ops,
+                                  .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_null;
+    return &rpcsvc_auth_null;
 }
diff --git a/rpc/rpc-lib/src/auth-unix.c b/rpc/rpc-lib/src/auth-unix.c
index 74ebfe0d1ff..c53870fcf94 100644
--- a/rpc/rpc-lib/src/auth-unix.c
+++ b/rpc/rpc-lib/src/auth-unix.c
@@ -8,65 +8,60 @@
   cases as published by the Free Software Foundation.
 */
 
-
-
 #include "rpcsvc.h"
 #include "list.h"
 #include "dict.h"
 #include "xdr-rpc.h"
 
-
 int
-auth_unix_request_init (rpcsvc_request_t *req, void *priv)
+auth_unix_request_init(rpcsvc_request_t *req, void *priv)
 {
-        return 0;
+    return 0;
 }
 
-int auth_unix_authenticate (rpcsvc_request_t *req, void *priv)
+int
+auth_unix_authenticate(rpcsvc_request_t *req, void *priv)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        struct authunix_parms   aup;
-        char                    machname[MAX_MACHINE_NAME];
+    int ret = RPCSVC_AUTH_REJECT;
+    struct authunix_parms aup;
+    char machname[MAX_MACHINE_NAME];
 
-        if (!req)
-                return ret;
+    if (!req)
+        return ret;
 
-	req->auxgids = req->auxgidsmall;
-        ret = xdr_to_auth_unix_cred (req->cred.authdata, req->cred.datalen,
-                                     &aup, machname, req->auxgids);
-        if (ret == -1) {
-                gf_log ("", GF_LOG_WARNING, "failed to decode unix credentials");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
+    req->auxgids = req->auxgidsmall;
+    ret = xdr_to_auth_unix_cred(req->cred.authdata, req->cred.datalen, &aup,
+                                machname, req->auxgids);
+    if (ret == -1) {
+        gf_log("", GF_LOG_WARNING, "failed to decode unix credentials");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
 
-        req->uid = aup.aup_uid;
-        req->gid = aup.aup_gid;
-        req->auxgidcount = aup.aup_len;
+    req->uid = aup.aup_uid;
+    req->gid = aup.aup_gid;
+    req->auxgidcount = aup.aup_len;
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: machine name: %s, uid: %d"
-                ", gid: %d", machname, req->uid, req->gid);
-        ret = RPCSVC_AUTH_ACCEPT;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Auth Info: machine name: %s, uid: %d"
+           ", gid: %d",
+           machname, req->uid, req->gid);
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        return ret;
+    return ret;
 }
 
-rpcsvc_auth_ops_t auth_unix_ops = {
-        .transport_init              = NULL,
-        .request_init           = auth_unix_request_init,
-        .authenticate           = auth_unix_authenticate
-};
-
-rpcsvc_auth_t rpcsvc_auth_unix = {
-        .authname       = "AUTH_UNIX",
-        .authnum        = AUTH_UNIX,
-        .authops        = &auth_unix_ops,
-        .authprivate    = NULL
-};
+rpcsvc_auth_ops_t auth_unix_ops = {.transport_init = NULL,
+                                   .request_init = auth_unix_request_init,
+                                   .authenticate = auth_unix_authenticate};
 
+rpcsvc_auth_t rpcsvc_auth_unix = {.authname = "AUTH_UNIX",
+                                  .authnum = AUTH_UNIX,
+                                  .authops = &auth_unix_ops,
+                                  .authprivate = NULL};
 
 rpcsvc_auth_t *
-rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options)
 {
-        return &rpcsvc_auth_unix;
+    return &rpcsvc_auth_unix;
 }
diff --git a/rpc/rpc-lib/src/autoscale-threads.c b/rpc/rpc-lib/src/autoscale-threads.c
index 4840fd4e971..337f002df10 100644
--- a/rpc/rpc-lib/src/autoscale-threads.c
+++ b/rpc/rpc-lib/src/autoscale-threads.c
@@ -12,12 +12,12 @@
 #include "rpcsvc.h"
 
 void
-rpcsvc_autoscale_threads (glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr)
+rpcsvc_autoscale_threads(glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr)
 {
-        struct event_pool       *pool           = ctx->event_pool;
-        int                      thread_count   = pool->eventthreadcount;
+    struct event_pool *pool = ctx->event_pool;
+    int thread_count = pool->eventthreadcount;
 
-        pool->auto_thread_count += incr;
-        (void) event_reconfigure_threads (pool, thread_count+incr);
-        rpcsvc_ownthread_reconf (rpc, pool->eventthreadcount);
+    pool->auto_thread_count += incr;
+    (void)event_reconfigure_threads(pool, thread_count + incr);
+    rpcsvc_ownthread_reconf(rpc, pool->eventthreadcount);
 }
diff --git a/rpc/rpc-lib/src/mgmt-pmap.c b/rpc/rpc-lib/src/mgmt-pmap.c
index fbcc78a7a7e..344ec56bbf7 100644
--- a/rpc/rpc-lib/src/mgmt-pmap.c
+++ b/rpc/rpc-lib/src/mgmt-pmap.c
@@ -17,122 +17,126 @@
 /* Defining a minimal RPC client program for portmap signout
  */
 char *clnt_pmap_signout_procs[GF_PMAP_MAXVALUE] = {
-        [GF_PMAP_SIGNOUT]     = "SIGNOUT",
+    [GF_PMAP_SIGNOUT] = "SIGNOUT",
 };
 
-
 rpc_clnt_prog_t clnt_pmap_signout_prog = {
-        .progname  = "Gluster Portmap",
-        .prognum   = GLUSTER_PMAP_PROGRAM,
-        .progver   = GLUSTER_PMAP_VERSION,
-        .procnames = clnt_pmap_signout_procs,
+    .progname = "Gluster Portmap",
+    .prognum = GLUSTER_PMAP_PROGRAM,
+    .progver = GLUSTER_PMAP_VERSION,
+    .procnames = clnt_pmap_signout_procs,
 };
 
 static int
-mgmt_pmap_signout_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
+mgmt_pmap_signout_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
 {
-        pmap_signout_rsp  rsp   = {0,};
-        int              ret   = 0;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp);
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 == rsp.op_ret) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "failed to register the port with glusterd");
-                goto out;
-        }
+    pmap_signout_rsp rsp = {
+        0,
+    };
+    int ret = 0;
+
+    if (-1 == req->rpc_status) {
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp);
+    if (ret < 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "XDR decoding failed");
+        rsp.op_ret = -1;
+        rsp.op_errno = EINVAL;
+        goto out;
+    }
+
+    if (-1 == rsp.op_ret) {
+        gf_log(THIS->name, GF_LOG_ERROR,
+               "failed to register the port with glusterd");
+        goto out;
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int
-rpc_clnt_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brickname)
+rpc_clnt_mgmt_pmap_signout(glusterfs_ctx_t *ctx, char *brickname)
 {
-        int               ret = 0;
-        pmap_signout_req  req = {0, };
-        call_frame_t     *frame = NULL;
-        cmd_args_t       *cmd_args = NULL;
-        char              brick_name[PATH_MAX]  = {0,};
-        struct iovec      iov = {0, };
-        struct iobuf     *iobuf = NULL;
-        struct iobref    *iobref = NULL;
-        ssize_t           xdr_size = 0;
-
-        frame = create_frame (THIS, ctx->pool);
-        cmd_args = &ctx->cmd_args;
-
-        if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) {
-                gf_log ("fsd-mgmt", GF_LOG_DEBUG,
-                        "portmapper signout arguments not given");
-                goto out;
-        }
-
-        if (cmd_args->volfile_server_transport &&
-            !strcmp(cmd_args->volfile_server_transport, "rdma")) {
-                snprintf (brick_name, sizeof(brick_name), "%s.rdma",
-                          cmd_args->brick_name);
-                req.brick = brick_name;
-        } else {
-                if (brickname)
-                        req.brick = brickname;
-                else
-                        req.brick = cmd_args->brick_name;
-        }
-
-        req.port  = cmd_args->brick_port;
-        req.rdma_port = cmd_args->brick_port2;
-
-        /* mgmt_submit_request is not available in libglusterfs.
-         * Need to serialize and submit manually.
-         */
-        iobref = iobref_new ();
-        if (!iobref) {
-                goto out;
-        }
-
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_pmap_signout_req, &req);
-        iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-        if (!iobuf) {
-                goto out;
-        };
-
-        iobref_add (iobref, iobuf);
-
-        iov.iov_base = iobuf->ptr;
-        iov.iov_len  = iobuf_pagesize (iobuf);
-
-        /* Create the xdr payload */
-        ret = xdr_serialize_generic (iov, &req,
-                                     (xdrproc_t)xdr_pmap_signout_req);
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to create XDR payload");
-                goto out;
-        }
-        iov.iov_len = ret;
-
-        ret = rpc_clnt_submit (ctx->mgmt, &clnt_pmap_signout_prog,
-                               GF_PMAP_SIGNOUT, mgmt_pmap_signout_cbk,
-                               &iov, 1,
-                               NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
+    int ret = 0;
+    pmap_signout_req req = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    cmd_args_t *cmd_args = NULL;
+    char brick_name[PATH_MAX] = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    ssize_t xdr_size = 0;
+
+    frame = create_frame(THIS, ctx->pool);
+    cmd_args = &ctx->cmd_args;
+
+    if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) {
+        gf_log("fsd-mgmt", GF_LOG_DEBUG,
+               "portmapper signout arguments not given");
+        goto out;
+    }
+
+    if (cmd_args->volfile_server_transport &&
+        !strcmp(cmd_args->volfile_server_transport, "rdma")) {
+        snprintf(brick_name, sizeof(brick_name), "%s.rdma",
+                 cmd_args->brick_name);
+        req.brick = brick_name;
+    } else {
+        if (brickname)
+            req.brick = brickname;
+        else
+            req.brick = cmd_args->brick_name;
+    }
+
+    req.port = cmd_args->brick_port;
+    req.rdma_port = cmd_args->brick_port2;
+
+    /* mgmt_submit_request is not available in libglusterfs.
+     * Need to serialize and submit manually.
+     */
+    iobref = iobref_new();
+    if (!iobref) {
+        goto out;
+    }
+
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_pmap_signout_req, &req);
+    iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+    if (!iobuf) {
+        goto out;
+    };
+
+    iobref_add(iobref, iobuf);
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    /* Create the xdr payload */
+    ret = xdr_serialize_generic(iov, &req, (xdrproc_t)xdr_pmap_signout_req);
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+        goto out;
+    }
+    iov.iov_len = ret;
+
+    ret = rpc_clnt_submit(ctx->mgmt, &clnt_pmap_signout_prog, GF_PMAP_SIGNOUT,
+                          mgmt_pmap_signout_cbk, &iov, 1, NULL, 0, iobref,
+                          frame, NULL, 0, NULL, 0, NULL);
 out:
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-        if (iobuf)
-                iobuf_unref (iobuf);
-        return ret;
+    if (iobuf)
+        iobuf_unref(iobuf);
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/rpc-clnt-ping.c b/rpc/rpc-lib/src/rpc-clnt-ping.c
index 25629891379..a98a83dd8c8 100644
--- a/rpc/rpc-lib/src/rpc-clnt-ping.c
+++ b/rpc/rpc-lib/src/rpc-clnt-ping.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "rpc-clnt.h"
 #include "rpc-clnt-ping.h"
 #include "byte-order.h"
@@ -20,15 +19,14 @@
 #include "rpc-common-xdr.h"
 #include "timespec.h"
 
-
 char *clnt_ping_procs[GF_DUMP_MAXVALUE] = {
-        [GF_DUMP_PING] = "NULL",
+    [GF_DUMP_PING] = "NULL",
 };
 struct rpc_clnt_program clnt_ping_prog = {
-        .progname  = "GF-DUMP",
-        .prognum   = GLUSTER_DUMP_PROGRAM,
-        .progver   = GLUSTER_DUMP_VERSION,
-        .procnames = clnt_ping_procs,
+    .progname = "GF-DUMP",
+    .prognum = GLUSTER_DUMP_PROGRAM,
+    .progver = GLUSTER_DUMP_VERSION,
+    .procnames = clnt_ping_procs,
 };
 
 struct ping_local {
@@ -38,341 +36,326 @@ struct ping_local {
 
 /* Must be called under conn->lock */
 static int
-__rpc_clnt_rearm_ping_timer (struct rpc_clnt *rpc, gf_timer_cbk_t cbk)
+__rpc_clnt_rearm_ping_timer(struct rpc_clnt *rpc, gf_timer_cbk_t cbk)
 {
-        rpc_clnt_connection_t *conn    = &rpc->conn;
-        rpc_transport_t       *trans   = conn->trans;
-        struct timespec        timeout = {0, };
-        gf_timer_t            *timer   = NULL;
-
-        if (conn->ping_timer) {
-                gf_log_callingfn ("", GF_LOG_CRITICAL,
-                                  "%s: ping timer event already scheduled",
-                                  conn->trans->peerinfo.identifier);
-                return -1;
-        }
-
-        timeout.tv_sec = conn->ping_timeout;
-        timeout.tv_nsec = 0;
-
-        rpc_clnt_ref (rpc);
-        timer = gf_timer_call_after (rpc->ctx, timeout,
-                                     cbk,
-                                     (void *) rpc);
-        if (timer == NULL) {
-                gf_log (trans->name, GF_LOG_WARNING,
-                        "unable to setup ping timer");
-
-                /* This unref can't be the last. We just took a ref few lines
-                 * above. So this can be performed under conn->lock. */
-                rpc_clnt_unref (rpc);
-                conn->ping_started = 0;
-                return -1;
-        }
-
-        conn->ping_timer = timer;
-        conn->ping_started = 1;
-        return 0;
+    rpc_clnt_connection_t *conn = &rpc->conn;
+    rpc_transport_t *trans = conn->trans;
+    struct timespec timeout = {
+        0,
+    };
+    gf_timer_t *timer = NULL;
+
+    if (conn->ping_timer) {
+        gf_log_callingfn("", GF_LOG_CRITICAL,
+                         "%s: ping timer event already scheduled",
+                         conn->trans->peerinfo.identifier);
+        return -1;
+    }
+
+    timeout.tv_sec = conn->ping_timeout;
+    timeout.tv_nsec = 0;
+
+    rpc_clnt_ref(rpc);
+    timer = gf_timer_call_after(rpc->ctx, timeout, cbk, (void *)rpc);
+    if (timer == NULL) {
+        gf_log(trans->name, GF_LOG_WARNING, "unable to setup ping timer");
+
+        /* This unref can't be the last. We just took a ref few lines
+         * above. So this can be performed under conn->lock. */
+        rpc_clnt_unref(rpc);
+        conn->ping_started = 0;
+        return -1;
+    }
+
+    conn->ping_timer = timer;
+    conn->ping_started = 1;
+    return 0;
 }
 
 /* Must be called under conn->lock */
 int
-rpc_clnt_remove_ping_timer_locked (struct rpc_clnt *rpc)
+rpc_clnt_remove_ping_timer_locked(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t *conn  = &rpc->conn;
-        gf_timer_t            *timer = NULL;
-
-        if (conn->ping_timer) {
-                timer = conn->ping_timer;
-                conn->ping_timer = NULL;
-                gf_timer_call_cancel (rpc->ctx, timer);
-                conn->ping_started = 0;
-                return 1;
-
-        }
-
-        /* This is to account for rpc_clnt_disable that might have set
-         *  conn->trans to NULL. */
-        if (conn->trans)
-                gf_log_callingfn ("", GF_LOG_DEBUG, "%s: ping timer event "
-                                  "already removed",
-                                   conn->trans->peerinfo.identifier);
-
-        return 0;
+    rpc_clnt_connection_t *conn = &rpc->conn;
+    gf_timer_t *timer = NULL;
+
+    if (conn->ping_timer) {
+        timer = conn->ping_timer;
+        conn->ping_timer = NULL;
+        gf_timer_call_cancel(rpc->ctx, timer);
+        conn->ping_started = 0;
+        return 1;
+    }
+
+    /* This is to account for rpc_clnt_disable that might have set
+     *  conn->trans to NULL. */
+    if (conn->trans)
+        gf_log_callingfn("", GF_LOG_DEBUG,
+                         "%s: ping timer event "
+                         "already removed",
+                         conn->trans->peerinfo.identifier);
+
+    return 0;
 }
 
 static void
-rpc_clnt_start_ping (void *rpc_ptr);
+rpc_clnt_start_ping(void *rpc_ptr);
 
 void
-rpc_clnt_ping_timer_expired (void *rpc_ptr)
+rpc_clnt_ping_timer_expired(void *rpc_ptr)
 {
-        struct rpc_clnt         *rpc                = NULL;
-        rpc_transport_t         *trans              = NULL;
-        rpc_clnt_connection_t   *conn               = NULL;
-        int                      disconnect         = 0;
-        int                      transport_activity = 0;
-        struct timespec          current            = {0, };
-        int                      unref              = 0;
-
-        rpc = (struct rpc_clnt*) rpc_ptr;
-        conn = &rpc->conn;
-        trans = conn->trans;
-
-        if (!trans) {
-                gf_log ("ping-timer", GF_LOG_WARNING,
-                        "transport not initialized");
-                goto out;
+    struct rpc_clnt *rpc = NULL;
+    rpc_transport_t *trans = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    int disconnect = 0;
+    int transport_activity = 0;
+    struct timespec current = {
+        0,
+    };
+    int unref = 0;
+
+    rpc = (struct rpc_clnt *)rpc_ptr;
+    conn = &rpc->conn;
+    trans = conn->trans;
+
+    if (!trans) {
+        gf_log("ping-timer", GF_LOG_WARNING, "transport not initialized");
+        goto out;
+    }
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+
+        clock_gettime(CLOCK_REALTIME, &current);
+        if (((current.tv_sec - conn->last_received.tv_sec) <
+             conn->ping_timeout) ||
+            ((current.tv_sec - conn->last_sent.tv_sec) < conn->ping_timeout)) {
+            transport_activity = 1;
         }
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-
-                clock_gettime (CLOCK_REALTIME, &current);
-                if (((current.tv_sec - conn->last_received.tv_sec) <
-                     conn->ping_timeout)
-                    || ((current.tv_sec - conn->last_sent.tv_sec) <
-                        conn->ping_timeout)) {
-                        transport_activity = 1;
-                }
-
-                if (transport_activity) {
-                        gf_log (trans->name, GF_LOG_TRACE,
-                                "ping timer expired but transport activity "
-                                "detected - not bailing transport");
-
-                        if (__rpc_clnt_rearm_ping_timer (rpc,
-                                         rpc_clnt_ping_timer_expired) == -1) {
-                                gf_log (trans->name, GF_LOG_WARNING,
-                                        "unable to setup ping timer");
-                        }
-
-                } else {
-                        conn->ping_started = 0;
-                        disconnect = 1;
-                }
+        if (transport_activity) {
+            gf_log(trans->name, GF_LOG_TRACE,
+                   "ping timer expired but transport activity "
+                   "detected - not bailing transport");
+
+            if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) ==
+                -1) {
+                gf_log(trans->name, GF_LOG_WARNING,
+                       "unable to setup ping timer");
+            }
+
+        } else {
+            conn->ping_started = 0;
+            disconnect = 1;
         }
-        pthread_mutex_unlock (&conn->lock);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (unref)
-                rpc_clnt_unref (rpc);
+    if (unref)
+        rpc_clnt_unref(rpc);
 
-        if (disconnect) {
-                gf_log (trans->name, GF_LOG_CRITICAL,
-                        "server %s has not responded in the last %d "
-                        "seconds, disconnecting.",
-                        trans->peerinfo.identifier,
-                        conn->ping_timeout);
+    if (disconnect) {
+        gf_log(trans->name, GF_LOG_CRITICAL,
+               "server %s has not responded in the last %d "
+               "seconds, disconnecting.",
+               trans->peerinfo.identifier, conn->ping_timeout);
 
-                rpc_transport_disconnect (conn->trans, _gf_false);
-        }
+        rpc_transport_disconnect(conn->trans, _gf_false);
+    }
 
 out:
-        return;
+    return;
 }
 
 int
-rpc_clnt_ping_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                   void *myframe)
+rpc_clnt_ping_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
 {
-        struct ping_local     *local   = NULL;
-        xlator_t              *this    = NULL;
-        rpc_clnt_connection_t *conn    = NULL;
-        call_frame_t          *frame   = NULL;
-        int                   unref    = 0;
-        gf_boolean_t          call_notify = _gf_false;
-
-        struct timespec       now;
-        struct timespec       delta;
-        int64_t               latency_msec = 0;
-        int                   ret = 0;
-
-        if (!myframe) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "frame with the request is NULL");
-                goto out;
+    struct ping_local *local = NULL;
+    xlator_t *this = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    call_frame_t *frame = NULL;
+    int unref = 0;
+    gf_boolean_t call_notify = _gf_false;
+
+    struct timespec now;
+    struct timespec delta;
+    int64_t latency_msec = 0;
+    int ret = 0;
+
+    if (!myframe) {
+        gf_log(THIS->name, GF_LOG_WARNING, "frame with the request is NULL");
+        goto out;
+    }
+
+    frame = myframe;
+    this = frame->this;
+    local = frame->local;
+    conn = &local->rpc->conn;
+
+    timespec_now(&now);
+    timespec_sub(&local->submit_time, &now, &delta);
+    latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        gf_log(THIS->name, GF_LOG_DEBUG, "Ping latency is %" PRIu64 "ms",
+               latency_msec);
+
+        call_notify = _gf_true;
+        if (req->rpc_status == -1) {
+            unref = rpc_clnt_remove_ping_timer_locked(local->rpc);
+            if (unref) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "socket or ib related error");
+
+            } else {
+                /* timer expired and transport bailed out */
+                gf_log(this->name, GF_LOG_WARNING, "socket disconnected");
+            }
+            conn->ping_started = 0;
+            goto unlock;
         }
 
-        frame = myframe;
-        this = frame->this;
-        local = frame->local;
-        conn = &local->rpc->conn;
-
-        timespec_now (&now);
-        timespec_sub (&local->submit_time, &now, &delta);
-        latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                gf_log (THIS->name, GF_LOG_DEBUG,
-                        "Ping latency is %" PRIu64 "ms",
-                        latency_msec);
-
-                call_notify = _gf_true;
-                if (req->rpc_status == -1) {
-                        unref = rpc_clnt_remove_ping_timer_locked (local->rpc);
-                        if (unref) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "socket or ib related error");
-
-                        } else {
-                                /* timer expired and transport bailed out */
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "socket disconnected");
-
-                        }
-                        conn->ping_started = 0;
-                        goto unlock;
-                }
-
-                unref = rpc_clnt_remove_ping_timer_locked (local->rpc);
-                if (__rpc_clnt_rearm_ping_timer (local->rpc,
-                                                 rpc_clnt_start_ping) == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "failed to set the ping timer");
-                }
-
+        unref = rpc_clnt_remove_ping_timer_locked(local->rpc);
+        if (__rpc_clnt_rearm_ping_timer(local->rpc, rpc_clnt_start_ping) ==
+            -1) {
+            gf_log(this->name, GF_LOG_WARNING, "failed to set the ping timer");
         }
+    }
 unlock:
-        pthread_mutex_unlock (&conn->lock);
-
-        if (call_notify) {
-                ret = local->rpc->notifyfn (local->rpc, this, RPC_CLNT_PING,
-                                            (void *)(uintptr_t)latency_msec);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "RPC_CLNT_PING notify failed");
-                }
-        }
-out:
-        if (unref)
-                rpc_clnt_unref (local->rpc);
+    pthread_mutex_unlock(&conn->lock);
 
-        if (frame) {
-                GF_FREE (frame->local);
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
+    if (call_notify) {
+        ret = local->rpc->notifyfn(local->rpc, this, RPC_CLNT_PING,
+                                   (void *)(uintptr_t)latency_msec);
+        if (ret) {
+            gf_log(this->name, GF_LOG_WARNING, "RPC_CLNT_PING notify failed");
         }
-        return 0;
+    }
+out:
+    if (unref)
+        rpc_clnt_unref(local->rpc);
+
+    if (frame) {
+        GF_FREE(frame->local);
+        frame->local = NULL;
+        STACK_DESTROY(frame->root);
+    }
+    return 0;
 }
 
 int
-rpc_clnt_ping (struct rpc_clnt *rpc)
+rpc_clnt_ping(struct rpc_clnt *rpc)
 {
-        call_frame_t *frame = NULL;
-        int32_t       ret   = -1;
-        rpc_clnt_connection_t *conn = NULL;
-        struct ping_local *local = NULL;
-
-        conn = &rpc->conn;
-        local = GF_MALLOC (sizeof(struct ping_local),
-                           gf_common_ping_local_t);
-        if (!local)
-                return ret;
-        frame = create_frame (THIS, THIS->ctx->pool);
-        if (!frame) {
-                GF_FREE (local);
-                return ret;
-        }
-
-        local->rpc = rpc;
-        timespec_now (&local->submit_time);
-        frame->local = local;
-
-        ret = rpc_clnt_submit (rpc, &clnt_ping_prog,
-                               GF_DUMP_PING, rpc_clnt_ping_cbk, NULL, 0,
-                               NULL, 0, NULL, frame, NULL, 0, NULL, 0, NULL);
-        if (ret) {
-                /* FIXME: should we free the frame here? Methinks so! */
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "failed to start ping timer");
-        }
-        else {
-                /* ping successfully queued in list of saved frames
-                 * for the connection*/
-                pthread_mutex_lock (&conn->lock);
-                conn->pingcnt++;
-                pthread_mutex_unlock (&conn->lock);
-        }
-
+    call_frame_t *frame = NULL;
+    int32_t ret = -1;
+    rpc_clnt_connection_t *conn = NULL;
+    struct ping_local *local = NULL;
+
+    conn = &rpc->conn;
+    local = GF_MALLOC(sizeof(struct ping_local), gf_common_ping_local_t);
+    if (!local)
         return ret;
-
+    frame = create_frame(THIS, THIS->ctx->pool);
+    if (!frame) {
+        GF_FREE(local);
+        return ret;
+    }
+
+    local->rpc = rpc;
+    timespec_now(&local->submit_time);
+    frame->local = local;
+
+    ret = rpc_clnt_submit(rpc, &clnt_ping_prog, GF_DUMP_PING, rpc_clnt_ping_cbk,
+                          NULL, 0, NULL, 0, NULL, frame, NULL, 0, NULL, 0,
+                          NULL);
+    if (ret) {
+        /* FIXME: should we free the frame here? Methinks so! */
+        gf_log(THIS->name, GF_LOG_ERROR, "failed to start ping timer");
+    } else {
+        /* ping successfully queued in list of saved frames
+         * for the connection*/
+        pthread_mutex_lock(&conn->lock);
+        conn->pingcnt++;
+        pthread_mutex_unlock(&conn->lock);
+    }
+
+    return ret;
 }
 
 static void
-rpc_clnt_start_ping (void *rpc_ptr)
+rpc_clnt_start_ping(void *rpc_ptr)
 {
-        struct rpc_clnt         *rpc         = NULL;
-        rpc_clnt_connection_t   *conn        = NULL;
-        int                      frame_count = 0;
-        int                      unref       = 0;
-
-        rpc = (struct rpc_clnt*) rpc_ptr;
-        conn = &rpc->conn;
-
-        if (conn->ping_timeout == 0) {
-                gf_log (THIS->name, GF_LOG_DEBUG, "ping timeout is 0,"
-                        " returning");
-                return;
+    struct rpc_clnt *rpc = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    int frame_count = 0;
+    int unref = 0;
+
+    rpc = (struct rpc_clnt *)rpc_ptr;
+    conn = &rpc->conn;
+
+    if (conn->ping_timeout == 0) {
+        gf_log(THIS->name, GF_LOG_DEBUG,
+               "ping timeout is 0,"
+               " returning");
+        return;
+    }
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+
+        if (conn->saved_frames) {
+            GF_ASSERT(conn->saved_frames->count >= 0);
+            /* treat the case where conn->saved_frames is NULL
+               as no pending frames */
+            frame_count = conn->saved_frames->count;
         }
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-
-                if (conn->saved_frames) {
-                        GF_ASSERT (conn->saved_frames->count >= 0);
-                        /* treat the case where conn->saved_frames is NULL
-                           as no pending frames */
-                        frame_count = conn->saved_frames->count;
-                }
-
-                if ((frame_count == 0) || !conn->connected) {
-                        gf_log (THIS->name, GF_LOG_DEBUG,
-                                "returning as transport is already disconnected"
-                                " OR there are no frames (%d || %d)",
-                                !conn->connected, frame_count);
-
-                        pthread_mutex_unlock (&conn->lock);
-                        if (unref)
-                                rpc_clnt_unref (rpc);
-                        return;
-                }
-
-                if (__rpc_clnt_rearm_ping_timer (rpc,
-                                         rpc_clnt_ping_timer_expired) == -1) {
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "unable to setup ping timer");
-                        pthread_mutex_unlock (&conn->lock);
-                        if (unref)
-                                rpc_clnt_unref (rpc);
-                        return;
-
-                }
+        if ((frame_count == 0) || !conn->connected) {
+            gf_log(THIS->name, GF_LOG_DEBUG,
+                   "returning as transport is already disconnected"
+                   " OR there are no frames (%d || %d)",
+                   !conn->connected, frame_count);
 
+            pthread_mutex_unlock(&conn->lock);
+            if (unref)
+                rpc_clnt_unref(rpc);
+            return;
         }
-        pthread_mutex_unlock (&conn->lock);
-        if (unref)
-                rpc_clnt_unref (rpc);
 
-        rpc_clnt_ping(rpc);
+        if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) ==
+            -1) {
+            gf_log(THIS->name, GF_LOG_WARNING, "unable to setup ping timer");
+            pthread_mutex_unlock(&conn->lock);
+            if (unref)
+                rpc_clnt_unref(rpc);
+            return;
+        }
+    }
+    pthread_mutex_unlock(&conn->lock);
+    if (unref)
+        rpc_clnt_unref(rpc);
+
+    rpc_clnt_ping(rpc);
 }
 
 void
-rpc_clnt_check_and_start_ping (struct rpc_clnt *rpc)
+rpc_clnt_check_and_start_ping(struct rpc_clnt *rpc)
 {
-        char start_ping = 0;
+    char start_ping = 0;
 
-        pthread_mutex_lock (&rpc->conn.lock);
-        {
-                if (!rpc->conn.ping_started)
-                        start_ping = 1;
-        }
-        pthread_mutex_unlock (&rpc->conn.lock);
+    pthread_mutex_lock(&rpc->conn.lock);
+    {
+        if (!rpc->conn.ping_started)
+            start_ping = 1;
+    }
+    pthread_mutex_unlock(&rpc->conn.lock);
 
-        if (start_ping)
-                rpc_clnt_start_ping ((void *)rpc);
+    if (start_ping)
+        rpc_clnt_start_ping((void *)rpc);
 
-        return;
+    return;
 }
diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c
index 9ee9161c904..c5236251549 100644
--- a/rpc/rpc-lib/src/rpc-clnt.c
+++ b/rpc/rpc-lib/src/rpc-clnt.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #define RPC_CLNT_DEFAULT_REQUEST_COUNT 512
 
 #include "rpc-clnt.h"
@@ -22,479 +21,465 @@
 #include "rpc-common-xdr.h"
 
 void
-rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool);
+rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool);
 
 struct saved_frame *
-__saved_frames_get_timedout (struct saved_frames *frames, uint32_t timeout,
-                             struct timeval *current)
+__saved_frames_get_timedout(struct saved_frames *frames, uint32_t timeout,
+                            struct timeval *current)
 {
-	struct saved_frame *bailout_frame = NULL, *tmp = NULL;
-
-	if (!list_empty(&frames->sf.list)) {
-		tmp = list_entry (frames->sf.list.next, typeof (*tmp), list);
-		if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) {
-			bailout_frame = tmp;
-			list_del_init (&bailout_frame->list);
-			frames->count--;
-		}
-	}
-
-	return bailout_frame;
+    struct saved_frame *bailout_frame = NULL, *tmp = NULL;
+
+    if (!list_empty(&frames->sf.list)) {
+        tmp = list_entry(frames->sf.list.next, typeof(*tmp), list);
+        if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) {
+            bailout_frame = tmp;
+            list_del_init(&bailout_frame->list);
+            frames->count--;
+        }
+    }
+
+    return bailout_frame;
 }
 
 static int
-_is_lock_fop (struct saved_frame *sframe)
+_is_lock_fop(struct saved_frame *sframe)
 {
-        int     fop     = 0;
+    int fop = 0;
 
-        if (SFRAME_GET_PROGNUM (sframe) == GLUSTER_FOP_PROGRAM &&
-            SFRAME_GET_PROGVER (sframe) == GLUSTER_FOP_VERSION)
-                fop = SFRAME_GET_PROCNUM (sframe);
+    if (SFRAME_GET_PROGNUM(sframe) == GLUSTER_FOP_PROGRAM &&
+        SFRAME_GET_PROGVER(sframe) == GLUSTER_FOP_VERSION)
+        fop = SFRAME_GET_PROCNUM(sframe);
 
-        return ((fop == GFS3_OP_LK) ||
-                (fop == GFS3_OP_INODELK) ||
-                (fop == GFS3_OP_FINODELK) ||
-                (fop == GFS3_OP_ENTRYLK) ||
-                (fop == GFS3_OP_FENTRYLK));
+    return ((fop == GFS3_OP_LK) || (fop == GFS3_OP_INODELK) ||
+            (fop == GFS3_OP_FINODELK) || (fop == GFS3_OP_ENTRYLK) ||
+            (fop == GFS3_OP_FENTRYLK));
 }
 
 struct saved_frame *
-__saved_frames_put (struct saved_frames *frames, void *frame,
-                    struct rpc_req *rpcreq)
+__saved_frames_put(struct saved_frames *frames, void *frame,
+                   struct rpc_req *rpcreq)
 {
-	struct saved_frame *saved_frame = NULL;
+    struct saved_frame *saved_frame = NULL;
 
-        saved_frame = mem_get (rpcreq->conn->rpc_clnt->saved_frames_pool);
-	if (!saved_frame) {
-                goto out;
-	}
-        /* THIS should be saved and set back */
+    saved_frame = mem_get(rpcreq->conn->rpc_clnt->saved_frames_pool);
+    if (!saved_frame) {
+        goto out;
+    }
+    /* THIS should be saved and set back */
 
-        memset (saved_frame, 0, sizeof (*saved_frame));
-	INIT_LIST_HEAD (&saved_frame->list);
+    memset(saved_frame, 0, sizeof(*saved_frame));
+    INIT_LIST_HEAD(&saved_frame->list);
 
-	saved_frame->capital_this = THIS;
-	saved_frame->frame        = frame;
-        saved_frame->rpcreq       = rpcreq;
-	gettimeofday (&saved_frame->saved_at, NULL);
+    saved_frame->capital_this = THIS;
+    saved_frame->frame = frame;
+    saved_frame->rpcreq = rpcreq;
+    gettimeofday(&saved_frame->saved_at, NULL);
 
-        if (_is_lock_fop (saved_frame))
-                list_add_tail (&saved_frame->list, &frames->lk_sf.list);
-        else
-                list_add_tail (&saved_frame->list, &frames->sf.list);
+    if (_is_lock_fop(saved_frame))
+        list_add_tail(&saved_frame->list, &frames->lk_sf.list);
+    else
+        list_add_tail(&saved_frame->list, &frames->sf.list);
 
-	frames->count++;
+    frames->count++;
 
 out:
-	return saved_frame;
+    return saved_frame;
 }
 
-
-
 static void
-call_bail (void *data)
+call_bail(void *data)
 {
-        rpc_transport_t       *trans = NULL;
-        struct rpc_clnt       *clnt = NULL;
-        rpc_clnt_connection_t *conn = NULL;
-        struct timeval         current;
-        struct list_head       list;
-        struct saved_frame    *saved_frame = NULL;
-        struct saved_frame    *trav = NULL;
-        struct saved_frame    *tmp = NULL;
-        char                   frame_sent[256] = {0,};
-        struct timespec        timeout = {0,};
-        char                   peerid[UNIX_PATH_MAX] = {0};
-        gf_boolean_t           need_unref = _gf_false;
-        int                    len;
-
-        GF_VALIDATE_OR_GOTO ("client", data, out);
-
-        clnt = data;
-
-        conn = &clnt->conn;
-        pthread_mutex_lock (&conn->lock);
-        {
-            trans = conn->trans;
-            if (trans) {
-                    strncpy (peerid, conn->trans->peerinfo.identifier,
-                             sizeof (peerid)-1);
-
+    rpc_transport_t *trans = NULL;
+    struct rpc_clnt *clnt = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    struct timeval current;
+    struct list_head list;
+    struct saved_frame *saved_frame = NULL;
+    struct saved_frame *trav = NULL;
+    struct saved_frame *tmp = NULL;
+    char frame_sent[256] = {
+        0,
+    };
+    struct timespec timeout = {
+        0,
+    };
+    char peerid[UNIX_PATH_MAX] = {0};
+    gf_boolean_t need_unref = _gf_false;
+    int len;
+
+    GF_VALIDATE_OR_GOTO("client", data, out);
+
+    clnt = data;
+
+    conn = &clnt->conn;
+    pthread_mutex_lock(&conn->lock);
+    {
+        trans = conn->trans;
+        if (trans) {
+            strncpy(peerid, conn->trans->peerinfo.identifier,
+                    sizeof(peerid) - 1);
+        }
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /*rpc_clnt_connection_cleanup will be unwinding all saved frames,
+     * bailed or otherwise*/
+    if (!trans)
+        goto out;
+
+    gettimeofday(&current, NULL);
+    INIT_LIST_HEAD(&list);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        /* Chaining to get call-always functionality from
+           call-once timer */
+        if (conn->timer) {
+            timeout.tv_sec = 10;
+            timeout.tv_nsec = 0;
+
+            /* Ref rpc as it's added to timer event queue */
+            rpc_clnt_ref(clnt);
+            gf_timer_call_cancel(clnt->ctx, conn->timer);
+            conn->timer = gf_timer_call_after(clnt->ctx, timeout, call_bail,
+                                              (void *)clnt);
+
+            if (conn->timer == NULL) {
+                gf_log(conn->name, GF_LOG_WARNING,
+                       "Cannot create bailout timer for %s", peerid);
+                need_unref = _gf_true;
             }
         }
-        pthread_mutex_unlock (&conn->lock);
-        /*rpc_clnt_connection_cleanup will be unwinding all saved frames,
-         * bailed or otherwise*/
-        if (!trans)
-                goto out;
-
-        gettimeofday (&current, NULL);
-        INIT_LIST_HEAD (&list);
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                /* Chaining to get call-always functionality from
-                   call-once timer */
-                if (conn->timer) {
-                        timeout.tv_sec = 10;
-                        timeout.tv_nsec = 0;
-
-                        /* Ref rpc as it's added to timer event queue */
-                        rpc_clnt_ref (clnt);
-                        gf_timer_call_cancel (clnt->ctx, conn->timer);
-                        conn->timer = gf_timer_call_after (clnt->ctx,
-                                                           timeout,
-                                                           call_bail,
-                                                           (void *) clnt);
-
-                        if (conn->timer == NULL) {
-                                gf_log (conn->name, GF_LOG_WARNING,
-                                        "Cannot create bailout timer for %s",
-                                        peerid);
-                                need_unref = _gf_true;
-                        }
-                }
-
-                do {
-                        saved_frame =
-                                __saved_frames_get_timedout (conn->saved_frames,
-                                                             conn->frame_timeout,
-                                                             &current);
-                        if (saved_frame)
-                                list_add (&saved_frame->list, &list);
-
-                } while (saved_frame);
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        list_for_each_entry_safe (trav, tmp, &list, list) {
-                gf_time_fmt (frame_sent, sizeof frame_sent,
-                             trav->saved_at.tv_sec, gf_timefmt_FT);
-                len = strlen (frame_sent);
-                snprintf (frame_sent + len, sizeof (frame_sent) - len,
-                          ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec);
-
-		gf_log (conn->name, GF_LOG_ERROR,
-			"bailing out frame type(%s), op(%s(%d)), xid = 0x%x, "
-                        "unique = %"PRIu64", sent = %s, timeout = %d for %s",
-			trav->rpcreq->prog->progname,
-                        (trav->rpcreq->prog->procnames) ?
-                        trav->rpcreq->prog->procnames[trav->rpcreq->procnum] :
-                        "--",
-                        trav->rpcreq->procnum, trav->rpcreq->xid,
-                        ((call_frame_t *)(trav->frame))->root->unique,
-                        frame_sent, conn->frame_timeout, peerid);
-
-                clnt = rpc_clnt_ref (clnt);
-                trav->rpcreq->rpc_status = -1;
-		trav->rpcreq->cbkfn (trav->rpcreq, NULL, 0, trav->frame);
-
-                rpc_clnt_reply_deinit (trav->rpcreq, clnt->reqpool);
-                clnt = rpc_clnt_unref (clnt);
-                list_del_init (&trav->list);
-                mem_put (trav);
-        }
+        do {
+            saved_frame = __saved_frames_get_timedout(
+                conn->saved_frames, conn->frame_timeout, &current);
+            if (saved_frame)
+                list_add(&saved_frame->list, &list);
+
+        } while (saved_frame);
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    list_for_each_entry_safe(trav, tmp, &list, list)
+    {
+        gf_time_fmt(frame_sent, sizeof frame_sent, trav->saved_at.tv_sec,
+                    gf_timefmt_FT);
+        len = strlen(frame_sent);
+        snprintf(frame_sent + len, sizeof(frame_sent) - len,
+                 ".%" GF_PRI_SUSECONDS, trav->saved_at.tv_usec);
+
+        gf_log(conn->name, GF_LOG_ERROR,
+               "bailing out frame type(%s), op(%s(%d)), xid = 0x%x, "
+               "unique = %" PRIu64 ", sent = %s, timeout = %d for %s",
+               trav->rpcreq->prog->progname,
+               (trav->rpcreq->prog->procnames)
+                   ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
+                   : "--",
+               trav->rpcreq->procnum, trav->rpcreq->xid,
+               ((call_frame_t *)(trav->frame))->root->unique, frame_sent,
+               conn->frame_timeout, peerid);
+
+        clnt = rpc_clnt_ref(clnt);
+        trav->rpcreq->rpc_status = -1;
+        trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame);
+
+        rpc_clnt_reply_deinit(trav->rpcreq, clnt->reqpool);
+        clnt = rpc_clnt_unref(clnt);
+        list_del_init(&trav->list);
+        mem_put(trav);
+    }
 out:
-        rpc_clnt_unref (clnt);
-        if (need_unref)
-                rpc_clnt_unref (clnt);
-        return;
+    rpc_clnt_unref(clnt);
+    if (need_unref)
+        rpc_clnt_unref(clnt);
+    return;
 }
 
-
 /* to be called with conn->lock held */
 struct saved_frame *
-__save_frame (struct rpc_clnt *rpc_clnt, call_frame_t *frame,
-              struct rpc_req *rpcreq)
+__save_frame(struct rpc_clnt *rpc_clnt, call_frame_t *frame,
+             struct rpc_req *rpcreq)
 {
-        rpc_clnt_connection_t *conn        = NULL;
-        struct timespec        timeout     = {0, };
-        struct saved_frame    *saved_frame = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    struct timespec timeout = {
+        0,
+    };
+    struct saved_frame *saved_frame = NULL;
 
-        conn = &rpc_clnt->conn;
+    conn = &rpc_clnt->conn;
 
-        saved_frame = __saved_frames_put (conn->saved_frames, frame, rpcreq);
+    saved_frame = __saved_frames_put(conn->saved_frames, frame, rpcreq);
 
-        if (saved_frame == NULL) {
-                goto out;
-        }
+    if (saved_frame == NULL) {
+        goto out;
+    }
 
-        /* TODO: make timeout configurable */
-        if (conn->timer == NULL) {
-                timeout.tv_sec  = 10;
-                timeout.tv_nsec = 0;
-                rpc_clnt_ref (rpc_clnt);
-                conn->timer = gf_timer_call_after (rpc_clnt->ctx,
-                                                   timeout,
-                                                   call_bail,
-                                                   (void *) rpc_clnt);
-        }
+    /* TODO: make timeout configurable */
+    if (conn->timer == NULL) {
+        timeout.tv_sec = 10;
+        timeout.tv_nsec = 0;
+        rpc_clnt_ref(rpc_clnt);
+        conn->timer = gf_timer_call_after(rpc_clnt->ctx, timeout, call_bail,
+                                          (void *)rpc_clnt);
+    }
 
 out:
-        return saved_frame;
+    return saved_frame;
 }
 
-
 struct saved_frames *
-saved_frames_new (void)
+saved_frames_new(void)
 {
-	struct saved_frames *saved_frames = NULL;
+    struct saved_frames *saved_frames = NULL;
 
-	saved_frames = GF_CALLOC (1, sizeof (*saved_frames),
-                                  gf_common_mt_rpcclnt_savedframe_t);
-	if (!saved_frames) {
-		return NULL;
-	}
+    saved_frames = GF_CALLOC(1, sizeof(*saved_frames),
+                             gf_common_mt_rpcclnt_savedframe_t);
+    if (!saved_frames) {
+        return NULL;
+    }
 
-	INIT_LIST_HEAD (&saved_frames->sf.list);
-	INIT_LIST_HEAD (&saved_frames->lk_sf.list);
+    INIT_LIST_HEAD(&saved_frames->sf.list);
+    INIT_LIST_HEAD(&saved_frames->lk_sf.list);
 
-	return saved_frames;
+    return saved_frames;
 }
 
-
 int
-__saved_frame_copy (struct saved_frames *frames, int64_t callid,
-                    struct saved_frame *saved_frame)
+__saved_frame_copy(struct saved_frames *frames, int64_t callid,
+                   struct saved_frame *saved_frame)
 {
-	struct saved_frame *tmp   = NULL;
-        int                 ret   = -1;
+    struct saved_frame *tmp = NULL;
+    int ret = -1;
 
-        if (!saved_frame) {
-                ret = 0;
-                goto out;
+    if (!saved_frame) {
+        ret = 0;
+        goto out;
+    }
+
+    list_for_each_entry(tmp, &frames->sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            *saved_frame = *tmp;
+            ret = 0;
+            goto out;
         }
+    }
 
-	list_for_each_entry (tmp, &frames->sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			*saved_frame = *tmp;
-                        ret = 0;
-			goto out;
-		}
-	}
-
-	list_for_each_entry (tmp, &frames->lk_sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			*saved_frame = *tmp;
-                        ret = 0;
-			goto out;
-		}
-	}
+    list_for_each_entry(tmp, &frames->lk_sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            *saved_frame = *tmp;
+            ret = 0;
+            goto out;
+        }
+    }
 
 out:
-	return ret;
+    return ret;
 }
 
-
 struct saved_frame *
-__saved_frame_get (struct saved_frames *frames, int64_t callid)
+__saved_frame_get(struct saved_frames *frames, int64_t callid)
 {
-	struct saved_frame *saved_frame = NULL;
-	struct saved_frame *tmp = NULL;
-
-	list_for_each_entry (tmp, &frames->sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			list_del_init (&tmp->list);
-			frames->count--;
-			saved_frame = tmp;
-			goto out;
-		}
-	}
-
-	list_for_each_entry (tmp, &frames->lk_sf.list, list) {
-		if (tmp->rpcreq->xid == callid) {
-			list_del_init (&tmp->list);
-			frames->count--;
-			saved_frame = tmp;
-			goto out;
-		}
-	}
+    struct saved_frame *saved_frame = NULL;
+    struct saved_frame *tmp = NULL;
 
-out:
-	if (saved_frame) {
-                THIS  = saved_frame->capital_this;
+    list_for_each_entry(tmp, &frames->sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            list_del_init(&tmp->list);
+            frames->count--;
+            saved_frame = tmp;
+            goto out;
         }
+    }
 
-	return saved_frame;
-}
+    list_for_each_entry(tmp, &frames->lk_sf.list, list)
+    {
+        if (tmp->rpcreq->xid == callid) {
+            list_del_init(&tmp->list);
+            frames->count--;
+            saved_frame = tmp;
+            goto out;
+        }
+    }
+
+out:
+    if (saved_frame) {
+        THIS = saved_frame->capital_this;
+    }
 
+    return saved_frame;
+}
 
 void
-saved_frames_unwind (struct saved_frames *saved_frames)
+saved_frames_unwind(struct saved_frames *saved_frames)
 {
-	struct saved_frame   *trav = NULL;
-	struct saved_frame   *tmp = NULL;
-        char                  timestr[1024] = {0,};
-        int                   len;
-
-        list_splice_init (&saved_frames->lk_sf.list, &saved_frames->sf.list);
-
-	list_for_each_entry_safe (trav, tmp, &saved_frames->sf.list, list) {
-                gf_time_fmt (timestr, sizeof timestr,
-                             trav->saved_at.tv_sec, gf_timefmt_FT);
-                len = strlen (timestr);
-                snprintf (timestr + len, sizeof(timestr) - len,
-                          ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec);
-
-                if (!trav->rpcreq || !trav->rpcreq->prog)
-                        continue;
-
-                gf_log_callingfn (trav->rpcreq->conn->name,
-                                  GF_LOG_ERROR,
-                                  "forced unwinding frame type(%s) op(%s(%d)) "
-                                  "called at %s (xid=0x%x)",
-                                  trav->rpcreq->prog->progname,
-                                  ((trav->rpcreq->prog->procnames) ?
-                                   trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
-                                   : "--"),
-                                  trav->rpcreq->procnum, timestr,
-                                  trav->rpcreq->xid);
-		saved_frames->count--;
-
-                trav->rpcreq->rpc_status = -1;
-                trav->rpcreq->cbkfn (trav->rpcreq, NULL, 0, trav->frame);
-
-                rpc_clnt_reply_deinit (trav->rpcreq,
-                                       trav->rpcreq->conn->rpc_clnt->reqpool);
-
-		list_del_init (&trav->list);
-                mem_put (trav);
-	}
+    struct saved_frame *trav = NULL;
+    struct saved_frame *tmp = NULL;
+    char timestr[1024] = {
+        0,
+    };
+    int len;
+
+    list_splice_init(&saved_frames->lk_sf.list, &saved_frames->sf.list);
+
+    list_for_each_entry_safe(trav, tmp, &saved_frames->sf.list, list)
+    {
+        gf_time_fmt(timestr, sizeof timestr, trav->saved_at.tv_sec,
+                    gf_timefmt_FT);
+        len = strlen(timestr);
+        snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SUSECONDS,
+                 trav->saved_at.tv_usec);
+
+        if (!trav->rpcreq || !trav->rpcreq->prog)
+            continue;
+
+        gf_log_callingfn(
+            trav->rpcreq->conn->name, GF_LOG_ERROR,
+            "forced unwinding frame type(%s) op(%s(%d)) "
+            "called at %s (xid=0x%x)",
+            trav->rpcreq->prog->progname,
+            ((trav->rpcreq->prog->procnames)
+                 ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum]
+                 : "--"),
+            trav->rpcreq->procnum, timestr, trav->rpcreq->xid);
+        saved_frames->count--;
+
+        trav->rpcreq->rpc_status = -1;
+        trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame);
+
+        rpc_clnt_reply_deinit(trav->rpcreq,
+                              trav->rpcreq->conn->rpc_clnt->reqpool);
+
+        list_del_init(&trav->list);
+        mem_put(trav);
+    }
 }
 
-
 void
-saved_frames_destroy (struct saved_frames *frames)
+saved_frames_destroy(struct saved_frames *frames)
 {
-        if (!frames)
-                return;
+    if (!frames)
+        return;
 
-	saved_frames_unwind (frames);
+    saved_frames_unwind(frames);
 
-	GF_FREE (frames);
+    GF_FREE(frames);
 }
 
-
 void
-rpc_clnt_reconnect (void *conn_ptr)
+rpc_clnt_reconnect(void *conn_ptr)
 {
-        rpc_transport_t         *trans = NULL;
-        rpc_clnt_connection_t   *conn  = NULL;
-        struct timespec          ts    = {0, 0};
-        struct rpc_clnt         *clnt  = NULL;
-        gf_boolean_t             need_unref = _gf_false;
+    rpc_transport_t *trans = NULL;
+    rpc_clnt_connection_t *conn = NULL;
+    struct timespec ts = {0, 0};
+    struct rpc_clnt *clnt = NULL;
+    gf_boolean_t need_unref = _gf_false;
 
-        conn  = conn_ptr;
-        clnt = conn->rpc_clnt;
+    conn = conn_ptr;
+    clnt = conn->rpc_clnt;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                trans = conn->trans;
-                if (!trans) {
-                        pthread_mutex_unlock (&conn->lock);
-                        return;
-                }
-                if (conn->reconnect)
-                        gf_timer_call_cancel (clnt->ctx,
-                                              conn->reconnect);
-                conn->reconnect = 0;
-
-                if ((conn->connected == 0) && !clnt->disabled) {
-                        ts.tv_sec = 3;
-                        ts.tv_nsec = 0;
-
-                        gf_log (conn->name, GF_LOG_TRACE,
-                                "attempting reconnect");
-                        (void) rpc_transport_connect (trans,
-                                                      conn->config.remote_port);
-                        rpc_clnt_ref (clnt);
-                        conn->reconnect =
-                                gf_timer_call_after (clnt->ctx, ts,
-                                                     rpc_clnt_reconnect,
-                                                     conn);
-                        if (!conn->reconnect) {
-                                need_unref = _gf_true;
-                                gf_log (conn->name, GF_LOG_ERROR,
-                                        "Error adding to timer event queue");
-                        }
-                } else {
-                        gf_log (conn->name, GF_LOG_TRACE,
-                                "breaking reconnect chain");
-                }
+    pthread_mutex_lock(&conn->lock);
+    {
+        trans = conn->trans;
+        if (!trans) {
+            pthread_mutex_unlock(&conn->lock);
+            return;
+        }
+        if (conn->reconnect)
+            gf_timer_call_cancel(clnt->ctx, conn->reconnect);
+        conn->reconnect = 0;
+
+        if ((conn->connected == 0) && !clnt->disabled) {
+            ts.tv_sec = 3;
+            ts.tv_nsec = 0;
+
+            gf_log(conn->name, GF_LOG_TRACE, "attempting reconnect");
+            (void)rpc_transport_connect(trans, conn->config.remote_port);
+            rpc_clnt_ref(clnt);
+            conn->reconnect = gf_timer_call_after(clnt->ctx, ts,
+                                                  rpc_clnt_reconnect, conn);
+            if (!conn->reconnect) {
+                need_unref = _gf_true;
+                gf_log(conn->name, GF_LOG_ERROR,
+                       "Error adding to timer event queue");
+            }
+        } else {
+            gf_log(conn->name, GF_LOG_TRACE, "breaking reconnect chain");
         }
-        pthread_mutex_unlock (&conn->lock);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        rpc_clnt_unref (clnt);
-        if (need_unref)
-                rpc_clnt_unref (clnt);
-        return;
+    rpc_clnt_unref(clnt);
+    if (need_unref)
+        rpc_clnt_unref(clnt);
+    return;
 }
 
-
 int
-rpc_clnt_fill_request_info (struct rpc_clnt *clnt, rpc_request_info_t *info)
+rpc_clnt_fill_request_info(struct rpc_clnt *clnt, rpc_request_info_t *info)
 {
-        struct saved_frame  saved_frame;
-        int                 ret         = -1;
-
-        pthread_mutex_lock (&clnt->conn.lock);
-        {
-                ret = __saved_frame_copy (clnt->conn.saved_frames, info->xid,
-                                          &saved_frame);
-        }
-        pthread_mutex_unlock (&clnt->conn.lock);
-
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_CRITICAL,
-                        "cannot lookup the saved "
-                        "frame corresponding to xid (%d)", info->xid);
-                goto out;
-        }
-
-        info->prognum = saved_frame.rpcreq->prog->prognum;
-        info->procnum = saved_frame.rpcreq->procnum;
-        info->progver = saved_frame.rpcreq->prog->progver;
-        info->rpc_req = saved_frame.rpcreq;
-        info->rsp     = saved_frame.rsp;
-
-        ret = 0;
+    struct saved_frame saved_frame;
+    int ret = -1;
+
+    pthread_mutex_lock(&clnt->conn.lock);
+    {
+        ret = __saved_frame_copy(clnt->conn.saved_frames, info->xid,
+                                 &saved_frame);
+    }
+    pthread_mutex_unlock(&clnt->conn.lock);
+
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_CRITICAL,
+               "cannot lookup the saved "
+               "frame corresponding to xid (%d)",
+               info->xid);
+        goto out;
+    }
+
+    info->prognum = saved_frame.rpcreq->prog->prognum;
+    info->procnum = saved_frame.rpcreq->procnum;
+    info->progver = saved_frame.rpcreq->prog->progver;
+    info->rpc_req = saved_frame.rpcreq;
+    info->rsp = saved_frame.rsp;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_clnt_reconnect_cleanup (rpc_clnt_connection_t *conn)
+rpc_clnt_reconnect_cleanup(rpc_clnt_connection_t *conn)
 {
-        struct rpc_clnt         *clnt  = NULL;
-        int                      ret   = 0;
-        gf_boolean_t             reconnect_unref = _gf_false;
-
-        if (!conn) {
-                goto out;
-        }
-
-        clnt = conn->rpc_clnt;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (clnt->ctx, conn->reconnect);
-                        if (!ret) {
-                                reconnect_unref = _gf_true;
-                                conn->cleanup_gen++;
-                        }
-                        conn->reconnect = NULL;
-                }
-
+    struct rpc_clnt *clnt = NULL;
+    int ret = 0;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!conn) {
+        goto out;
+    }
+
+    clnt = conn->rpc_clnt;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(clnt->ctx, conn->reconnect);
+            if (!ret) {
+                reconnect_unref = _gf_true;
+                conn->cleanup_gen++;
+            }
+            conn->reconnect = NULL;
         }
-        pthread_mutex_unlock (&conn->lock);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (reconnect_unref)
-                rpc_clnt_unref (clnt);
+    if (reconnect_unref)
+        rpc_clnt_unref(clnt);
 
 out:
-        return 0;
+    return 0;
 }
 
 /*
@@ -503,54 +488,53 @@ out:
  *
  */
 int
-rpc_clnt_connection_cleanup (rpc_clnt_connection_t *conn)
+rpc_clnt_connection_cleanup(rpc_clnt_connection_t *conn)
 {
-        struct saved_frames    *saved_frames = NULL;
-        struct rpc_clnt         *clnt  = NULL;
-        int                     unref = 0;
-        int                     ret   = 0;
-        gf_boolean_t            timer_unref = _gf_false;
-
-        if (!conn) {
-                goto out;
-        }
+    struct saved_frames *saved_frames = NULL;
+    struct rpc_clnt *clnt = NULL;
+    int unref = 0;
+    int ret = 0;
+    gf_boolean_t timer_unref = _gf_false;
 
-        clnt = conn->rpc_clnt;
+    if (!conn) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&conn->lock);
-        {
+    clnt = conn->rpc_clnt;
 
-                saved_frames = conn->saved_frames;
-                conn->saved_frames = saved_frames_new ();
+    pthread_mutex_lock(&conn->lock);
+    {
+        saved_frames = conn->saved_frames;
+        conn->saved_frames = saved_frames_new();
 
-                /* bailout logic cleanup */
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (clnt->ctx, conn->timer);
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
+        /* bailout logic cleanup */
+        if (conn->timer) {
+            ret = gf_timer_call_cancel(clnt->ctx, conn->timer);
+            if (!ret)
+                timer_unref = _gf_true;
+            conn->timer = NULL;
+        }
 
-                conn->connected = 0;
-                conn->disconnected = 1;
+        conn->connected = 0;
+        conn->disconnected = 1;
 
-                unref = rpc_clnt_remove_ping_timer_locked (clnt);
-                /*reset rpc msgs stats*/
-                conn->pingcnt = 0;
-                conn->msgcnt = 0;
-                conn->cleanup_gen++;
-        }
-        pthread_mutex_unlock (&conn->lock);
+        unref = rpc_clnt_remove_ping_timer_locked(clnt);
+        /*reset rpc msgs stats*/
+        conn->pingcnt = 0;
+        conn->msgcnt = 0;
+        conn->cleanup_gen++;
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        saved_frames_destroy (saved_frames);
-        if (unref)
-                rpc_clnt_unref (clnt);
+    saved_frames_destroy(saved_frames);
+    if (unref)
+        rpc_clnt_unref(clnt);
 
-        if (timer_unref)
-                rpc_clnt_unref (clnt);
+    if (timer_unref)
+        rpc_clnt_unref(clnt);
 
 out:
-        return 0;
+    return 0;
 }
 
 /*
@@ -562,1554 +546,1516 @@ out:
  */
 
 static struct saved_frame *
-lookup_frame (rpc_clnt_connection_t *conn, int64_t callid)
+lookup_frame(rpc_clnt_connection_t *conn, int64_t callid)
 {
-        struct saved_frame *frame = NULL;
+    struct saved_frame *frame = NULL;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                frame = __saved_frame_get (conn->saved_frames, callid);
-        }
-        pthread_mutex_unlock (&conn->lock);
+    pthread_mutex_lock(&conn->lock);
+    {
+        frame = __saved_frame_get(conn->saved_frames, callid);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        return frame;
+    return frame;
 }
 
-
 int
-rpc_clnt_reply_fill (rpc_transport_pollin_t *msg,
-                     rpc_clnt_connection_t *conn,
-                     struct rpc_msg *replymsg, struct iovec progmsg,
-                     struct rpc_req *req,
-                     struct saved_frame *saved_frame)
+rpc_clnt_reply_fill(rpc_transport_pollin_t *msg, rpc_clnt_connection_t *conn,
+                    struct rpc_msg *replymsg, struct iovec progmsg,
+                    struct rpc_req *req, struct saved_frame *saved_frame)
 {
-        int             ret   = -1;
-
-        if ((!conn) || (!replymsg)|| (!req) || (!saved_frame) || (!msg)) {
-                goto out;
-        }
-
-        req->rpc_status = 0;
-        if ((rpc_reply_status (replymsg) == MSG_DENIED)
-            || (rpc_accepted_reply_status (replymsg) != SUCCESS)) {
-                req->rpc_status = -1;
-        }
-
-        req->rsp[0] = progmsg;
-        req->rsp_iobref = iobref_ref (msg->iobref);
-
-        if (msg->vectored) {
-                req->rsp[1] = msg->vector[1];
-                req->rspcnt = 2;
-        } else {
-                req->rspcnt = 1;
-        }
-
-        /* By this time, the data bytes for the auth scheme would have already
-         * been copied into the required sections of the req structure,
-         * we just need to fill in the meta-data about it now.
+    int ret = -1;
+
+    if ((!conn) || (!replymsg) || (!req) || (!saved_frame) || (!msg)) {
+        goto out;
+    }
+
+    req->rpc_status = 0;
+    if ((rpc_reply_status(replymsg) == MSG_DENIED) ||
+        (rpc_accepted_reply_status(replymsg) != SUCCESS)) {
+        req->rpc_status = -1;
+    }
+
+    req->rsp[0] = progmsg;
+    req->rsp_iobref = iobref_ref(msg->iobref);
+
+    if (msg->vectored) {
+        req->rsp[1] = msg->vector[1];
+        req->rspcnt = 2;
+    } else {
+        req->rspcnt = 1;
+    }
+
+    /* By this time, the data bytes for the auth scheme would have already
+     * been copied into the required sections of the req structure,
+     * we just need to fill in the meta-data about it now.
+     */
+    if (req->rpc_status == 0) {
+        /*
+         * req->verf.flavour = rpc_reply_verf_flavour (replymsg);
+         * req->verf.datalen = rpc_reply_verf_len (replymsg);
          */
-        if (req->rpc_status == 0) {
-                /*
-                 * req->verf.flavour = rpc_reply_verf_flavour (replymsg);
-                 * req->verf.datalen = rpc_reply_verf_len (replymsg);
-                 */
-        }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool)
+rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool)
 {
-        if (!req) {
-                goto out;
-        }
+    if (!req) {
+        goto out;
+    }
 
-        if (req->rsp_iobref) {
-                iobref_unref (req->rsp_iobref);
-        }
+    if (req->rsp_iobref) {
+        iobref_unref(req->rsp_iobref);
+    }
 
-        mem_put (req);
+    mem_put(req);
 out:
-        return;
+    return;
 }
 
-
 /* TODO: use mem-pool for allocating requests */
 int
-rpc_clnt_reply_init (rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg,
-                     struct rpc_req *req, struct saved_frame *saved_frame)
+rpc_clnt_reply_init(rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg,
+                    struct rpc_req *req, struct saved_frame *saved_frame)
 {
-        char                    *msgbuf = NULL;
-        struct rpc_msg          rpcmsg;
-        struct iovec            progmsg;        /* RPC Program payload */
-        size_t                  msglen  = 0;
-        int                     ret     = -1;
-
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
-
-        ret = xdr_to_rpc_reply (msgbuf, msglen, &rpcmsg, &progmsg,
-                                req->verf.authdata);
-        if (ret != 0) {
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "RPC reply decoding failed");
-                goto out;
-        }
-
-        ret = rpc_clnt_reply_fill (msg, conn, &rpcmsg, progmsg, req,
-                                   saved_frame);
-        if (ret != 0) {
-                goto out;
-        }
-
-        gf_log (conn->name, GF_LOG_TRACE,
-                "received rpc message (RPC XID: 0x%x"
-                " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)",
-                saved_frame->rpcreq->xid,
-                saved_frame->rpcreq->prog->progname,
-                saved_frame->rpcreq->prog->progver,
-                saved_frame->rpcreq->procnum, conn->name);
+    char *msgbuf = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    size_t msglen = 0;
+    int ret = -1;
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    ret = xdr_to_rpc_reply(msgbuf, msglen, &rpcmsg, &progmsg,
+                           req->verf.authdata);
+    if (ret != 0) {
+        gf_log(conn->name, GF_LOG_WARNING, "RPC reply decoding failed");
+        goto out;
+    }
+
+    ret = rpc_clnt_reply_fill(msg, conn, &rpcmsg, progmsg, req, saved_frame);
+    if (ret != 0) {
+        goto out;
+    }
+
+    gf_log(conn->name, GF_LOG_TRACE,
+           "received rpc message (RPC XID: 0x%x"
+           " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)",
+           saved_frame->rpcreq->xid, saved_frame->rpcreq->prog->progname,
+           saved_frame->rpcreq->prog->progver, saved_frame->rpcreq->procnum,
+           conn->name);
 
 out:
-        if (ret != 0) {
-                req->rpc_status = -1;
-        }
+    if (ret != 0) {
+        req->rpc_status = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-rpc_clnt_handle_cbk (struct rpc_clnt *clnt, rpc_transport_pollin_t *msg)
+rpc_clnt_handle_cbk(struct rpc_clnt *clnt, rpc_transport_pollin_t *msg)
 {
-        char                 *msgbuf = NULL;
-        rpcclnt_cb_program_t *program = NULL;
-        struct rpc_msg        rpcmsg;
-        struct iovec          progmsg; /* RPC Program payload */
-        size_t                msglen = 0;
-        int                   found  = 0;
-        int                   ret    = -1;
-        int                   procnum = 0;
-
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
-
-        clnt = rpc_clnt_ref (clnt);
-        ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg, NULL,NULL);
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_WARNING,
-                        "RPC call decoding failed");
-                goto out;
-        }
-
-        gf_log (clnt->conn.name, GF_LOG_TRACE,
-		"receivd rpc message (XID: 0x%" GF_PRI_RPC_XID ", "
-		"Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-		"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                "from rpc-transport (%s)", rpc_call_xid (&rpcmsg),
-                rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                clnt->conn.name);
-
-        procnum = rpc_call_progproc (&rpcmsg);
-
-        pthread_mutex_lock (&clnt->lock);
+    char *msgbuf = NULL;
+    rpcclnt_cb_program_t *program = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    size_t msglen = 0;
+    int found = 0;
+    int ret = -1;
+    int procnum = 0;
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    clnt = rpc_clnt_ref(clnt);
+    ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, NULL, NULL);
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_WARNING, "RPC call decoding failed");
+        goto out;
+    }
+
+    gf_log(clnt->conn.name, GF_LOG_TRACE,
+           "receivd rpc message (XID: 0x%" GF_PRI_RPC_XID
+           ", "
+           "Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID
+           ", "
+           "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+           ") "
+           "from rpc-transport (%s)",
+           rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+           rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+           rpc_call_progproc(&rpcmsg), clnt->conn.name);
+
+    procnum = rpc_call_progproc(&rpcmsg);
+
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_for_each_entry(program, &clnt->programs, program)
         {
-                list_for_each_entry (program, &clnt->programs, program) {
-                        if ((program->prognum == rpc_call_program (&rpcmsg))
-                            && (program->progver
-                                == rpc_call_progver (&rpcmsg))) {
-                                found = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == rpc_call_program(&rpcmsg)) &&
+                (program->progver == rpc_call_progver(&rpcmsg))) {
+                found = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&clnt->lock);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        if (found && (procnum < program->numactors) &&
-            (program->actors[procnum].actor)) {
-                program->actors[procnum].actor (clnt, program->mydata,
-                                                &progmsg);
-        }
+    if (found && (procnum < program->numactors) &&
+        (program->actors[procnum].actor)) {
+        program->actors[procnum].actor(clnt, program->mydata, &progmsg);
+    }
 
 out:
-        rpc_clnt_unref (clnt);
-        return ret;
+    rpc_clnt_unref(clnt);
+    return ret;
 }
 
 int
-rpc_clnt_handle_reply (struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin)
+rpc_clnt_handle_reply(struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin)
 {
-        rpc_clnt_connection_t *conn         = NULL;
-        struct saved_frame    *saved_frame  = NULL;
-        int                    ret          = -1;
-        struct rpc_req        *req          = NULL;
-        uint32_t               xid          = 0;
-
-        clnt = rpc_clnt_ref (clnt);
-        conn = &clnt->conn;
-
-        xid = ntoh32 (*((uint32_t *)pollin->vector[0].iov_base));
-        saved_frame = lookup_frame (conn, xid);
-        if (saved_frame == NULL) {
-                gf_log (conn->name, GF_LOG_ERROR,
-                        "cannot lookup the saved frame for reply with xid (%u)",
-                        xid);
-                goto out;
-        }
-
-        req = saved_frame->rpcreq;
-        if (req == NULL) {
-                gf_log (conn->name, GF_LOG_ERROR,
-                        "no request with frame for xid (%u)", xid);
-                goto out;
-        }
-
-        ret = rpc_clnt_reply_init (conn, pollin, req, saved_frame);
-        if (ret != 0) {
-                req->rpc_status = -1;
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "initialising rpc reply failed");
-        }
-
-        req->cbkfn (req, req->rsp, req->rspcnt, saved_frame->frame);
-
-        if (req) {
-                rpc_clnt_reply_deinit (req, conn->rpc_clnt->reqpool);
-        }
+    rpc_clnt_connection_t *conn = NULL;
+    struct saved_frame *saved_frame = NULL;
+    int ret = -1;
+    struct rpc_req *req = NULL;
+    uint32_t xid = 0;
+
+    clnt = rpc_clnt_ref(clnt);
+    conn = &clnt->conn;
+
+    xid = ntoh32(*((uint32_t *)pollin->vector[0].iov_base));
+    saved_frame = lookup_frame(conn, xid);
+    if (saved_frame == NULL) {
+        gf_log(conn->name, GF_LOG_ERROR,
+               "cannot lookup the saved frame for reply with xid (%u)", xid);
+        goto out;
+    }
+
+    req = saved_frame->rpcreq;
+    if (req == NULL) {
+        gf_log(conn->name, GF_LOG_ERROR, "no request with frame for xid (%u)",
+               xid);
+        goto out;
+    }
+
+    ret = rpc_clnt_reply_init(conn, pollin, req, saved_frame);
+    if (ret != 0) {
+        req->rpc_status = -1;
+        gf_log(conn->name, GF_LOG_WARNING, "initialising rpc reply failed");
+    }
+
+    req->cbkfn(req, req->rsp, req->rspcnt, saved_frame->frame);
+
+    if (req) {
+        rpc_clnt_reply_deinit(req, conn->rpc_clnt->reqpool);
+    }
 out:
 
-        if (saved_frame) {
-                mem_put (saved_frame);
-        }
+    if (saved_frame) {
+        mem_put(saved_frame);
+    }
 
-        rpc_clnt_unref (clnt);
-        return ret;
+    rpc_clnt_unref(clnt);
+    return ret;
 }
 
 gf_boolean_t
-is_rpc_clnt_disconnected (rpc_clnt_connection_t *conn)
+is_rpc_clnt_disconnected(rpc_clnt_connection_t *conn)
 {
-        gf_boolean_t disconnected = _gf_true;
+    gf_boolean_t disconnected = _gf_true;
 
-        if (!conn)
-                return disconnected;
+    if (!conn)
+        return disconnected;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (conn->disconnected == _gf_false)
-                        disconnected = _gf_false;
-        }
-        pthread_mutex_unlock (&conn->lock);
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (conn->disconnected == _gf_false)
+            disconnected = _gf_false;
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        return disconnected;
+    return disconnected;
 }
 
 static void
-rpc_clnt_destroy (struct rpc_clnt *rpc);
+rpc_clnt_destroy(struct rpc_clnt *rpc);
 
-#define RPC_THIS_SAVE(xl) do {                                  \
-        old_THIS = THIS ;                                       \
-        if (!old_THIS)                                          \
-                gf_log_callingfn ("rpc", GF_LOG_CRITICAL,       \
-                                  "THIS is not initialised.");  \
-        THIS = xl;                                              \
-} while (0)
+#define RPC_THIS_SAVE(xl)                                                      \
+    do {                                                                       \
+        old_THIS = THIS;                                                       \
+        if (!old_THIS)                                                         \
+            gf_log_callingfn("rpc", GF_LOG_CRITICAL,                           \
+                             "THIS is not initialised.");                      \
+        THIS = xl;                                                             \
+    } while (0)
 
-#define RPC_THIS_RESTORE        (THIS = old_THIS)
+#define RPC_THIS_RESTORE (THIS = old_THIS)
 
 static int
-rpc_clnt_handle_disconnect (struct rpc_clnt *clnt, rpc_clnt_connection_t *conn)
+rpc_clnt_handle_disconnect(struct rpc_clnt *clnt, rpc_clnt_connection_t *conn)
 {
-        struct timespec ts             = {0, };
-        gf_boolean_t    unref_clnt     = _gf_false;
-        uint64_t        pre_notify_gen = 0, post_notify_gen = 0;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                pre_notify_gen = conn->cleanup_gen;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (clnt->notifyfn)
-                clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL);
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                post_notify_gen = conn->cleanup_gen;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (pre_notify_gen == post_notify_gen) {
-                /* program didn't invoke cleanup, so rpc has to do it */
-                rpc_clnt_connection_cleanup (conn);
-        }
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) {
-                        ts.tv_sec = 10;
-                        ts.tv_nsec = 0;
-
-                        rpc_clnt_ref (clnt);
-                        conn->reconnect = gf_timer_call_after (clnt->ctx, ts,
-                                                rpc_clnt_reconnect, conn);
-                        if (conn->reconnect == NULL) {
-                                gf_log (conn->name, GF_LOG_WARNING,
-                                                "Cannot create rpc_clnt_reconnect timer");
-                                unref_clnt = _gf_true;
-                        }
-                }
+    struct timespec ts = {
+        0,
+    };
+    gf_boolean_t unref_clnt = _gf_false;
+    uint64_t pre_notify_gen = 0, post_notify_gen = 0;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        pre_notify_gen = conn->cleanup_gen;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (clnt->notifyfn)
+        clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        post_notify_gen = conn->cleanup_gen;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (pre_notify_gen == post_notify_gen) {
+        /* program didn't invoke cleanup, so rpc has to do it */
+        rpc_clnt_connection_cleanup(conn);
+    }
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) {
+            ts.tv_sec = 10;
+            ts.tv_nsec = 0;
+
+            rpc_clnt_ref(clnt);
+            conn->reconnect = gf_timer_call_after(clnt->ctx, ts,
+                                                  rpc_clnt_reconnect, conn);
+            if (conn->reconnect == NULL) {
+                gf_log(conn->name, GF_LOG_WARNING,
+                       "Cannot create rpc_clnt_reconnect timer");
+                unref_clnt = _gf_true;
+            }
         }
-        pthread_mutex_unlock (&conn->lock);
-
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (unref_clnt)
-                rpc_clnt_unref (clnt);
+    if (unref_clnt)
+        rpc_clnt_unref(clnt);
 
-        return 0;
+    return 0;
 }
 
 int
-rpc_clnt_notify (rpc_transport_t *trans, void *mydata,
-                 rpc_transport_event_t event, void *data, ...)
+rpc_clnt_notify(rpc_transport_t *trans, void *mydata,
+                rpc_transport_event_t event, void *data, ...)
 {
-        rpc_clnt_connection_t  *conn        = NULL;
-        struct rpc_clnt        *clnt        = NULL;
-        int                     ret         = -1;
-        rpc_request_info_t     *req_info    = NULL;
-        rpc_transport_pollin_t *pollin      = NULL;
-        void                   *clnt_mydata = NULL;
-        DECLARE_OLD_THIS;
-
-        conn = mydata;
-        if (conn == NULL) {
-                goto out;
-        }
-        clnt = conn->rpc_clnt;
-        if (!clnt)
-                goto out;
-
-        RPC_THIS_SAVE (clnt->owner);
-
-        switch (event) {
-        case RPC_TRANSPORT_DISCONNECT:
-        {
-                rpc_clnt_handle_disconnect (clnt, conn);
-                /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
-                 *    if (clnt->auth_value)
-                 *           clnt->auth_value = AUTH_GLUSTERFS_v2;
-                 * It should not be reset here. The disconnect during
-                 * portmap request can race with handshake. If handshake
-                 * happens first and disconnect later, auth_value would set
-                 * to default value and it never sets back to actual auth_value
-                 * supported by server. But it's important to set to lower
-                 * version supported in the case where the server downgrades.
-                 * So moving this code to RPC_TRANSPORT_CONNECT. Note that
-                 * CONNECT cannot race with handshake as by nature it is
-                 * serialized with handhake. An handshake can happen only
-                 * on a connected transport and hence its strictly serialized.
-                 */
-                break;
+    rpc_clnt_connection_t *conn = NULL;
+    struct rpc_clnt *clnt = NULL;
+    int ret = -1;
+    rpc_request_info_t *req_info = NULL;
+    rpc_transport_pollin_t *pollin = NULL;
+    void *clnt_mydata = NULL;
+    DECLARE_OLD_THIS;
+
+    conn = mydata;
+    if (conn == NULL) {
+        goto out;
+    }
+    clnt = conn->rpc_clnt;
+    if (!clnt)
+        goto out;
+
+    RPC_THIS_SAVE(clnt->owner);
+
+    switch (event) {
+        case RPC_TRANSPORT_DISCONNECT: {
+            rpc_clnt_handle_disconnect(clnt, conn);
+            /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
+             *    if (clnt->auth_value)
+             *           clnt->auth_value = AUTH_GLUSTERFS_v2;
+             * It should not be reset here. The disconnect during
+             * portmap request can race with handshake. If handshake
+             * happens first and disconnect later, auth_value would set
+             * to default value and it never sets back to actual auth_value
+             * supported by server. But it's important to set to lower
+             * version supported in the case where the server downgrades.
+             * So moving this code to RPC_TRANSPORT_CONNECT. Note that
+             * CONNECT cannot race with handshake as by nature it is
+             * serialized with handhake. An handshake can happen only
+             * on a connected transport and hence its strictly serialized.
+             */
+            break;
         }
 
         case RPC_TRANSPORT_CLEANUP:
-                if (clnt->notifyfn) {
-                        clnt_mydata = clnt->mydata;
-                        clnt->mydata = NULL;
-                        ret = clnt->notifyfn (clnt, clnt_mydata,
-                                              RPC_CLNT_DESTROY, NULL);
-                        if (ret < 0) {
-                                gf_log (trans->name, GF_LOG_WARNING,
-                                        "client notify handler returned error "
-                                        "while handling RPC_CLNT_DESTROY");
-                        }
+            if (clnt->notifyfn) {
+                clnt_mydata = clnt->mydata;
+                clnt->mydata = NULL;
+                ret = clnt->notifyfn(clnt, clnt_mydata, RPC_CLNT_DESTROY, NULL);
+                if (ret < 0) {
+                    gf_log(trans->name, GF_LOG_WARNING,
+                           "client notify handler returned error "
+                           "while handling RPC_CLNT_DESTROY");
                 }
-                rpc_clnt_destroy (clnt);
-                ret = 0;
-                break;
-
-        case RPC_TRANSPORT_MAP_XID_REQUEST:
-        {
-                req_info = data;
-                ret = rpc_clnt_fill_request_info (clnt, req_info);
-                break;
-        }
-
-        case RPC_TRANSPORT_MSG_RECEIVED:
-        {
-                clock_gettime (CLOCK_REALTIME, &conn->last_received);
-
-                pollin = data;
-                if (pollin->is_reply)
-                        ret = rpc_clnt_handle_reply (clnt, pollin);
-                else
-                        ret = rpc_clnt_handle_cbk (clnt, pollin);
-                /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG,
-                 * data);
-                 */
-                break;
-        }
+            }
+            rpc_clnt_destroy(clnt);
+            ret = 0;
+            break;
+
+        case RPC_TRANSPORT_MAP_XID_REQUEST: {
+            req_info = data;
+            ret = rpc_clnt_fill_request_info(clnt, req_info);
+            break;
+        }
+
+        case RPC_TRANSPORT_MSG_RECEIVED: {
+            clock_gettime(CLOCK_REALTIME, &conn->last_received);
+
+            pollin = data;
+            if (pollin->is_reply)
+                ret = rpc_clnt_handle_reply(clnt, pollin);
+            else
+                ret = rpc_clnt_handle_cbk(clnt, pollin);
+            /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG,
+             * data);
+             */
+            break;
+        }
+
+        case RPC_TRANSPORT_MSG_SENT: {
+            clock_gettime(CLOCK_REALTIME, &conn->last_sent);
+
+            ret = 0;
+            break;
+        }
+
+        case RPC_TRANSPORT_CONNECT: {
+            pthread_mutex_lock(&conn->lock);
+            {
+                /* Every time there is a disconnection, processes
+                 * should try to connect to 'glusterd' (ie, default
+                 * port) or whichever port given as 'option remote-port'
+                 * in volume file. */
+                /* Below code makes sure the (re-)configured port lasts
+                 * for just one successful attempt */
+                conn->config.remote_port = 0;
+                conn->connected = 1;
+                conn->disconnected = 0;
+            }
+            pthread_mutex_unlock(&conn->lock);
 
-        case RPC_TRANSPORT_MSG_SENT:
-        {
-                clock_gettime (CLOCK_REALTIME, &conn->last_sent);
+            /* auth value should be set to lower version available
+             * and will be set to appropriate version supported by
+             * server after the handshake.
+             */
+            if (clnt->auth_value)
+                clnt->auth_value = AUTH_GLUSTERFS_v2;
+            if (clnt->notifyfn)
+                ret = clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_CONNECT,
+                                     NULL);
 
-                ret = 0;
-                break;
-        }
-
-        case RPC_TRANSPORT_CONNECT:
-        {
-                pthread_mutex_lock (&conn->lock);
-                {
-                        /* Every time there is a disconnection, processes
-                         * should try to connect to 'glusterd' (ie, default
-                         * port) or whichever port given as 'option remote-port'
-                         * in volume file. */
-                        /* Below code makes sure the (re-)configured port lasts
-                         * for just one successful attempt */
-                        conn->config.remote_port = 0;
-                        conn->connected = 1;
-                        conn->disconnected = 0;
-                }
-                pthread_mutex_unlock (&conn->lock);
-
-                /* auth value should be set to lower version available
-                 * and will be set to appropriate version supported by
-                 * server after the handshake.
-                 */
-                if (clnt->auth_value)
-                        clnt->auth_value = AUTH_GLUSTERFS_v2;
-                if (clnt->notifyfn)
-                        ret = clnt->notifyfn (clnt, clnt->mydata,
-                                              RPC_CLNT_CONNECT, NULL);
-
-                break;
+            break;
         }
 
         case RPC_TRANSPORT_ACCEPT:
-                /* only meaningful on a server, no need of handling this event
-                 * in a client.
-                 */
-                ret = 0;
-                break;
-        }
+            /* only meaningful on a server, no need of handling this event
+             * in a client.
+             */
+            ret = 0;
+            break;
+    }
 
 out:
-        RPC_THIS_RESTORE;
-        return ret;
+    RPC_THIS_RESTORE;
+    return ret;
 }
 
 static int
-rpc_clnt_connection_init (struct rpc_clnt *clnt, glusterfs_ctx_t *ctx,
-                          dict_t *options, char *name)
+rpc_clnt_connection_init(struct rpc_clnt *clnt, glusterfs_ctx_t *ctx,
+                         dict_t *options, char *name)
 {
-        int                    ret  = -1;
-        rpc_clnt_connection_t *conn = NULL;
-        rpc_transport_t       *trans = NULL;
-
-        conn = &clnt->conn;
-        pthread_mutex_init (&clnt->conn.lock, NULL);
-
-        conn->name = gf_strdup (name);
-        if (!conn->name) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_get_int32 (options, "frame-timeout",
-                              &conn->frame_timeout);
-        if (ret >= 0) {
-                gf_log (name, GF_LOG_INFO,
-                        "setting frame-timeout to %d", conn->frame_timeout);
-        } else {
-                gf_log (name, GF_LOG_DEBUG,
-                        "defaulting frame-timeout to 30mins");
-                conn->frame_timeout = 1800;
-        }
-        conn->rpc_clnt = clnt;
+    int ret = -1;
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
 
-        ret = dict_get_int32 (options, "ping-timeout",
-                              &conn->ping_timeout);
-        if (ret >= 0) {
-                gf_log (name, GF_LOG_DEBUG,
-                        "setting ping-timeout to %d", conn->ping_timeout);
-        } else {
-                /*TODO: Once the epoll thread model is fixed,
-                  change the default ping-timeout to 30sec */
-                gf_log (name, GF_LOG_DEBUG,
-                        "disable ping-timeout");
-                conn->ping_timeout = 0;
-        }
-
-        trans = rpc_transport_load (ctx, options, name);
-        if (!trans) {
-                gf_log (name, GF_LOG_WARNING, "loading of new rpc-transport"
-                        " failed");
-                ret = -1;
-                goto out;
-        }
-        rpc_transport_ref (trans);
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                conn->trans = trans;
-                trans = NULL;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        ret = rpc_transport_register_notify (conn->trans, rpc_clnt_notify,
-                                             conn);
-        if (ret == -1) {
-                gf_log (name, GF_LOG_WARNING, "registering notify failed");
-                goto out;
-        }
+    conn = &clnt->conn;
+    pthread_mutex_init(&clnt->conn.lock, NULL);
 
-        conn->saved_frames = saved_frames_new ();
-        if (!conn->saved_frames) {
-                gf_log (name, GF_LOG_WARNING, "creation of saved_frames "
-                        "failed");
-                ret = -1;
-                goto out;
-        }
+    conn->name = gf_strdup(name);
+    if (!conn->name) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_int32(options, "frame-timeout", &conn->frame_timeout);
+    if (ret >= 0) {
+        gf_log(name, GF_LOG_INFO, "setting frame-timeout to %d",
+               conn->frame_timeout);
+    } else {
+        gf_log(name, GF_LOG_DEBUG, "defaulting frame-timeout to 30mins");
+        conn->frame_timeout = 1800;
+    }
+    conn->rpc_clnt = clnt;
+
+    ret = dict_get_int32(options, "ping-timeout", &conn->ping_timeout);
+    if (ret >= 0) {
+        gf_log(name, GF_LOG_DEBUG, "setting ping-timeout to %d",
+               conn->ping_timeout);
+    } else {
+        /*TODO: Once the epoll thread model is fixed,
+          change the default ping-timeout to 30sec */
+        gf_log(name, GF_LOG_DEBUG, "disable ping-timeout");
+        conn->ping_timeout = 0;
+    }
+
+    trans = rpc_transport_load(ctx, options, name);
+    if (!trans) {
+        gf_log(name, GF_LOG_WARNING,
+               "loading of new rpc-transport"
+               " failed");
+        ret = -1;
+        goto out;
+    }
+    rpc_transport_ref(trans);
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        conn->trans = trans;
+        trans = NULL;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    ret = rpc_transport_register_notify(conn->trans, rpc_clnt_notify, conn);
+    if (ret == -1) {
+        gf_log(name, GF_LOG_WARNING, "registering notify failed");
+        goto out;
+    }
+
+    conn->saved_frames = saved_frames_new();
+    if (!conn->saved_frames) {
+        gf_log(name, GF_LOG_WARNING,
+               "creation of saved_frames "
+               "failed");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret) {
-                pthread_mutex_lock (&conn->lock);
-                {
-                        trans = conn->trans;
-                        conn->trans = NULL;
-                }
-                pthread_mutex_unlock (&conn->lock);
-                if (trans)
-                        rpc_transport_unref (trans);
-                //conn cleanup needs to be done since we might have failed to
-                // register notification.
-                rpc_clnt_connection_cleanup (conn);
-        }
-        return ret;
+    if (ret) {
+        pthread_mutex_lock(&conn->lock);
+        {
+            trans = conn->trans;
+            conn->trans = NULL;
+        }
+        pthread_mutex_unlock(&conn->lock);
+        if (trans)
+            rpc_transport_unref(trans);
+        // conn cleanup needs to be done since we might have failed to
+        // register notification.
+        rpc_clnt_connection_cleanup(conn);
+    }
+    return ret;
 }
 
 struct rpc_clnt *
-rpc_clnt_new (dict_t *options, xlator_t *owner, char *name,
-              uint32_t reqpool_size)
+rpc_clnt_new(dict_t *options, xlator_t *owner, char *name,
+             uint32_t reqpool_size)
 {
-        int                    ret  = -1;
-        struct rpc_clnt       *rpc  = NULL;
-        glusterfs_ctx_t       *ctx  = owner->ctx;
-
-
-        rpc = GF_CALLOC (1, sizeof (*rpc), gf_common_mt_rpcclnt_t);
-        if (!rpc) {
-                goto out;
-        }
-
-        pthread_mutex_init (&rpc->lock, NULL);
-        rpc->ctx = ctx;
-        rpc->owner = owner;
-        GF_ATOMIC_INIT (rpc->xid, 1);
-
-        if (!reqpool_size)
-                reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT;
-
-        rpc->reqpool = mem_pool_new (struct rpc_req, reqpool_size);
-        if (rpc->reqpool == NULL) {
-                pthread_mutex_destroy (&rpc->lock);
-                GF_FREE (rpc);
-                rpc = NULL;
-                goto out;
-        }
-
-        rpc->saved_frames_pool = mem_pool_new (struct saved_frame,
-                                               reqpool_size);
-        if (rpc->saved_frames_pool == NULL) {
-                pthread_mutex_destroy (&rpc->lock);
-                mem_pool_destroy (rpc->reqpool);
-                GF_FREE (rpc);
-                rpc = NULL;
-                goto out;
-        }
-
-        ret = rpc_clnt_connection_init (rpc, ctx, options, name);
-        if (ret == -1) {
-                pthread_mutex_destroy (&rpc->lock);
-                mem_pool_destroy (rpc->reqpool);
-                mem_pool_destroy (rpc->saved_frames_pool);
-                GF_FREE (rpc);
-                rpc = NULL;
-                if (options)
-                        dict_unref (options);
-                goto out;
-        }
-
-        /* This is handled to make sure we have modularity in getting the
-           auth data changed */
-        gf_boolean_t auth_null = dict_get_str_boolean(options, "auth-null", 0);
-
-        rpc->auth_value = (auth_null) ? 0 : AUTH_GLUSTERFS_v2;
-
-        rpc = rpc_clnt_ref (rpc);
-        INIT_LIST_HEAD (&rpc->programs);
+    int ret = -1;
+    struct rpc_clnt *rpc = NULL;
+    glusterfs_ctx_t *ctx = owner->ctx;
+
+    rpc = GF_CALLOC(1, sizeof(*rpc), gf_common_mt_rpcclnt_t);
+    if (!rpc) {
+        goto out;
+    }
+
+    pthread_mutex_init(&rpc->lock, NULL);
+    rpc->ctx = ctx;
+    rpc->owner = owner;
+    GF_ATOMIC_INIT(rpc->xid, 1);
+
+    if (!reqpool_size)
+        reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT;
+
+    rpc->reqpool = mem_pool_new(struct rpc_req, reqpool_size);
+    if (rpc->reqpool == NULL) {
+        pthread_mutex_destroy(&rpc->lock);
+        GF_FREE(rpc);
+        rpc = NULL;
+        goto out;
+    }
+
+    rpc->saved_frames_pool = mem_pool_new(struct saved_frame, reqpool_size);
+    if (rpc->saved_frames_pool == NULL) {
+        pthread_mutex_destroy(&rpc->lock);
+        mem_pool_destroy(rpc->reqpool);
+        GF_FREE(rpc);
+        rpc = NULL;
+        goto out;
+    }
+
+    ret = rpc_clnt_connection_init(rpc, ctx, options, name);
+    if (ret == -1) {
+        pthread_mutex_destroy(&rpc->lock);
+        mem_pool_destroy(rpc->reqpool);
+        mem_pool_destroy(rpc->saved_frames_pool);
+        GF_FREE(rpc);
+        rpc = NULL;
+        if (options)
+            dict_unref(options);
+        goto out;
+    }
+
+    /* This is handled to make sure we have modularity in getting the
+       auth data changed */
+    gf_boolean_t auth_null = dict_get_str_boolean(options, "auth-null", 0);
+
+    rpc->auth_value = (auth_null) ? 0 : AUTH_GLUSTERFS_v2;
+
+    rpc = rpc_clnt_ref(rpc);
+    INIT_LIST_HEAD(&rpc->programs);
 
 out:
-        return rpc;
+    return rpc;
 }
 
-
 int
-rpc_clnt_start (struct rpc_clnt *rpc)
+rpc_clnt_start(struct rpc_clnt *rpc)
 {
-        struct rpc_clnt_connection *conn = NULL;
+    struct rpc_clnt_connection *conn = NULL;
 
-        if (!rpc)
-                return -1;
+    if (!rpc)
+        return -1;
 
-        conn = &rpc->conn;
+    conn = &rpc->conn;
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 0;
-        }
-        pthread_mutex_unlock (&conn->lock);
-        /* Corresponding unref will be either on successful timer cancel or last
-         * rpc_clnt_reconnect fire event.
-         */
-        rpc_clnt_ref (rpc);
-        rpc_clnt_reconnect (conn);
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 0;
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /* Corresponding unref will be either on successful timer cancel or last
+     * rpc_clnt_reconnect fire event.
+     */
+    rpc_clnt_ref(rpc);
+    rpc_clnt_reconnect(conn);
 
-        return 0;
+    return 0;
 }
 
-
 int
-rpc_clnt_cleanup_and_start (struct rpc_clnt *rpc)
+rpc_clnt_cleanup_and_start(struct rpc_clnt *rpc)
 {
-        struct rpc_clnt_connection *conn = NULL;
+    struct rpc_clnt_connection *conn = NULL;
 
-        if (!rpc)
-                return -1;
+    if (!rpc)
+        return -1;
 
-        conn = &rpc->conn;
+    conn = &rpc->conn;
 
-        rpc_clnt_connection_cleanup (conn);
+    rpc_clnt_connection_cleanup(conn);
 
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 0;
-        }
-        pthread_mutex_unlock (&conn->lock);
-        /* Corresponding unref will be either on successful timer cancel or last
-         * rpc_clnt_reconnect fire event.
-         */
-        rpc_clnt_ref (rpc);
-        rpc_clnt_reconnect (conn);
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 0;
+    }
+    pthread_mutex_unlock(&conn->lock);
+    /* Corresponding unref will be either on successful timer cancel or last
+     * rpc_clnt_reconnect fire event.
+     */
+    rpc_clnt_ref(rpc);
+    rpc_clnt_reconnect(conn);
 
-        return 0;
+    return 0;
 }
 
-
 int
-rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
-                          void *mydata)
+rpc_clnt_register_notify(struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
+                         void *mydata)
 {
-        rpc->mydata = mydata;
-        rpc->notifyfn = fn;
+    rpc->mydata = mydata;
+    rpc->notifyfn = fn;
 
-        return 0;
+    return 0;
 }
 
 /* used for GF_LOG_OCCASIONALLY() */
 static int gf_auth_max_groups_log = 0;
 
 static inline int
-setup_glusterfs_auth_param_v3 (call_frame_t *frame,
-                               auth_glusterfs_params_v3 *au,
-                               int lk_owner_len, char *owner_data)
+setup_glusterfs_auth_param_v3(call_frame_t *frame, auth_glusterfs_params_v3 *au,
+                              int lk_owner_len, char *owner_data)
 {
-        int ret = -1;
-        unsigned int max_groups = 0;
-        int max_lkowner_len = 0;
-
-        au->pid      = frame->root->pid;
-        au->uid      = frame->root->uid;
-        au->gid      = frame->root->gid;
-
-        au->flags = frame->root->flags;
-        au->ctime_sec = frame->root->ctime.tv_sec;
-        au->ctime_nsec = frame->root->ctime.tv_nsec;
-
-        au->lk_owner.lk_owner_val = owner_data;
-        au->lk_owner.lk_owner_len = lk_owner_len;
-        au->groups.groups_val = frame->root->groups;
-        au->groups.groups_len = frame->root->ngrps;
-
-        /* The number of groups and the size of lk_owner depend on oneother.
-         * We can truncate the groups, but should not touch the lk_owner. */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (lk_owner_len, AUTH_GLUSTERFS_v3);
-        if (au->groups.groups_len > max_groups) {
-                GF_LOG_OCCASIONALLY (gf_auth_max_groups_log, "rpc-auth",
-                                     GF_LOG_WARNING, "truncating grouplist "
-                                     "from %d to %d", au->groups.groups_len,
-                                     max_groups);
-
-                au->groups.groups_len = max_groups;
-        }
-
-        max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (au->groups.groups_len,
-                                                         AUTH_GLUSTERFS_v3);
-        if (lk_owner_len > max_lkowner_len) {
-                gf_log ("rpc-clnt", GF_LOG_ERROR, "lkowner field is too "
-                        "big (%d), it does not fit in the rpc-header",
-                        au->lk_owner.lk_owner_len);
-                errno = E2BIG;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    unsigned int max_groups = 0;
+    int max_lkowner_len = 0;
+
+    au->pid = frame->root->pid;
+    au->uid = frame->root->uid;
+    au->gid = frame->root->gid;
+
+    au->flags = frame->root->flags;
+    au->ctime_sec = frame->root->ctime.tv_sec;
+    au->ctime_nsec = frame->root->ctime.tv_nsec;
+
+    au->lk_owner.lk_owner_val = owner_data;
+    au->lk_owner.lk_owner_len = lk_owner_len;
+    au->groups.groups_val = frame->root->groups;
+    au->groups.groups_len = frame->root->ngrps;
+
+    /* The number of groups and the size of lk_owner depend on oneother.
+     * We can truncate the groups, but should not touch the lk_owner. */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v3);
+    if (au->groups.groups_len > max_groups) {
+        GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING,
+                            "truncating grouplist "
+                            "from %d to %d",
+                            au->groups.groups_len, max_groups);
+
+        au->groups.groups_len = max_groups;
+    }
+
+    max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len,
+                                                    AUTH_GLUSTERFS_v3);
+    if (lk_owner_len > max_lkowner_len) {
+        gf_log("rpc-clnt", GF_LOG_ERROR,
+               "lkowner field is too "
+               "big (%d), it does not fit in the rpc-header",
+               au->lk_owner.lk_owner_len);
+        errno = E2BIG;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static inline int
-setup_glusterfs_auth_param_v2 (call_frame_t *frame,
-                               auth_glusterfs_parms_v2 *au,
-                               int lk_owner_len, char *owner_data)
+setup_glusterfs_auth_param_v2(call_frame_t *frame, auth_glusterfs_parms_v2 *au,
+                              int lk_owner_len, char *owner_data)
 {
-        unsigned int max_groups = 0;
-        int max_lkowner_len = 0;
-        int ret = -1;
-
-        au->pid      = frame->root->pid;
-        au->uid      = frame->root->uid;
-        au->gid      = frame->root->gid;
-
-        au->lk_owner.lk_owner_val = owner_data;
-        au->lk_owner.lk_owner_len = lk_owner_len;
-        au->groups.groups_val = frame->root->groups;
-        au->groups.groups_len = frame->root->ngrps;
-
-        /* The number of groups and the size of lk_owner depend on oneother.
-         * We can truncate the groups, but should not touch the lk_owner. */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (lk_owner_len, AUTH_GLUSTERFS_v2);
-        if (au->groups.groups_len > max_groups) {
-                GF_LOG_OCCASIONALLY (gf_auth_max_groups_log, "rpc-auth",
-                                     GF_LOG_WARNING, "truncating grouplist "
-                                     "from %d to %d", au->groups.groups_len,
-                                     max_groups);
-
-                au->groups.groups_len = max_groups;
-        }
-
-        max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (au->groups.groups_len,
-                                                         AUTH_GLUSTERFS_v2);
-        if (lk_owner_len > max_lkowner_len) {
-                gf_log ("rpc-auth", GF_LOG_ERROR, "lkowner field is too "
-                        "big (%d), it does not fit in the rpc-header",
-                        au->lk_owner.lk_owner_len);
-                errno = E2BIG;
-                goto out;
-        }
-
-        ret = 0;
+    unsigned int max_groups = 0;
+    int max_lkowner_len = 0;
+    int ret = -1;
+
+    au->pid = frame->root->pid;
+    au->uid = frame->root->uid;
+    au->gid = frame->root->gid;
+
+    au->lk_owner.lk_owner_val = owner_data;
+    au->lk_owner.lk_owner_len = lk_owner_len;
+    au->groups.groups_val = frame->root->groups;
+    au->groups.groups_len = frame->root->ngrps;
+
+    /* The number of groups and the size of lk_owner depend on oneother.
+     * We can truncate the groups, but should not touch the lk_owner. */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v2);
+    if (au->groups.groups_len > max_groups) {
+        GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING,
+                            "truncating grouplist "
+                            "from %d to %d",
+                            au->groups.groups_len, max_groups);
+
+        au->groups.groups_len = max_groups;
+    }
+
+    max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len,
+                                                    AUTH_GLUSTERFS_v2);
+    if (lk_owner_len > max_lkowner_len) {
+        gf_log("rpc-auth", GF_LOG_ERROR,
+               "lkowner field is too "
+               "big (%d), it does not fit in the rpc-header",
+               au->lk_owner.lk_owner_len);
+        errno = E2BIG;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static ssize_t
-xdr_serialize_glusterfs_auth (struct rpc_clnt *clnt, call_frame_t *frame,
-                              char *dest)
+xdr_serialize_glusterfs_auth(struct rpc_clnt *clnt, call_frame_t *frame,
+                             char *dest)
 {
-        ssize_t ret = -1;
-        XDR     xdr;
-        char    owner[4] = {0,};
-        int32_t pid = 0;
-        char   *lk_owner_data = NULL;
-        int     lk_owner_len = 0;
-
-        if ((!dest))
-                return -1;
-
-        xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE);
-
-        if (frame->root->lk_owner.len) {
-                lk_owner_data = frame->root->lk_owner.data;
-                lk_owner_len = frame->root->lk_owner.len;
-        } else {
-                pid = frame->root->pid;
-                owner[0] = (char)(pid & 0xff);
-                owner[1] = (char)((pid >> 8) & 0xff);
-                owner[2] = (char)((pid >> 16) & 0xff);
-                owner[3] = (char)((pid >> 24) & 0xff);
-
-                lk_owner_data = owner;
-                lk_owner_len = 4;
-        }
-
-        if (clnt->auth_value == AUTH_GLUSTERFS_v2) {
-                auth_glusterfs_parms_v2 au_v2 = {0,};
-
-                ret = setup_glusterfs_auth_param_v2 (frame, &au_v2,
-                                                     lk_owner_len,
-                                                     lk_owner_data);
-                if (ret)
-                        goto out;
-                if (!xdr_auth_glusterfs_parms_v2 (&xdr, &au_v2)) {
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "failed to encode auth glusterfs elements");
-                        ret = -1;
-                        goto out;
-                }
-        } else if (clnt->auth_value == AUTH_GLUSTERFS_v3) {
-                auth_glusterfs_params_v3 au_v3 = {0,};
-
-                ret = setup_glusterfs_auth_param_v3 (frame, &au_v3,
-                                                     lk_owner_len,
-                                                     lk_owner_data);
-                if (ret)
-                        goto out;
-
-                if (!xdr_auth_glusterfs_params_v3 (&xdr, &au_v3)) {
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "failed to encode auth glusterfs elements");
-                        ret = -1;
-                        goto out;
-                }
-        } else {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to encode auth glusterfs elements");
-                ret = -1;
-                goto out;
-        }
+    ssize_t ret = -1;
+    XDR xdr;
+    char owner[4] = {
+        0,
+    };
+    int32_t pid = 0;
+    char *lk_owner_data = NULL;
+    int lk_owner_len = 0;
+
+    if ((!dest))
+        return -1;
+
+    xdrmem_create(&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE);
+
+    if (frame->root->lk_owner.len) {
+        lk_owner_data = frame->root->lk_owner.data;
+        lk_owner_len = frame->root->lk_owner.len;
+    } else {
+        pid = frame->root->pid;
+        owner[0] = (char)(pid & 0xff);
+        owner[1] = (char)((pid >> 8) & 0xff);
+        owner[2] = (char)((pid >> 16) & 0xff);
+        owner[3] = (char)((pid >> 24) & 0xff);
+
+        lk_owner_data = owner;
+        lk_owner_len = 4;
+    }
+
+    if (clnt->auth_value == AUTH_GLUSTERFS_v2) {
+        auth_glusterfs_parms_v2 au_v2 = {
+            0,
+        };
+
+        ret = setup_glusterfs_auth_param_v2(frame, &au_v2, lk_owner_len,
+                                            lk_owner_data);
+        if (ret)
+            goto out;
+        if (!xdr_auth_glusterfs_parms_v2(&xdr, &au_v2)) {
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "failed to encode auth glusterfs elements");
+            ret = -1;
+            goto out;
+        }
+    } else if (clnt->auth_value == AUTH_GLUSTERFS_v3) {
+        auth_glusterfs_params_v3 au_v3 = {
+            0,
+        };
+
+        ret = setup_glusterfs_auth_param_v3(frame, &au_v3, lk_owner_len,
+                                            lk_owner_data);
+        if (ret)
+            goto out;
+
+        if (!xdr_auth_glusterfs_params_v3(&xdr, &au_v3)) {
+            gf_log(THIS->name, GF_LOG_WARNING,
+                   "failed to encode auth glusterfs elements");
+            ret = -1;
+            goto out;
+        }
+    } else {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to encode auth glusterfs elements");
+        ret = -1;
+        goto out;
+    }
 
-        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+    ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpc_clnt_fill_request (struct rpc_clnt *clnt, int prognum, int progver,
-                       int procnum, uint64_t xid, call_frame_t *fr,
-                       struct rpc_msg *request, char *auth_data)
+rpc_clnt_fill_request(struct rpc_clnt *clnt, int prognum, int progver,
+                      int procnum, uint64_t xid, call_frame_t *fr,
+                      struct rpc_msg *request, char *auth_data)
 {
-        int   ret          = -1;
+    int ret = -1;
 
-        if (!request) {
-                goto out;
-        }
+    if (!request) {
+        goto out;
+    }
 
-        memset (request, 0, sizeof (*request));
+    memset(request, 0, sizeof(*request));
 
-        request->rm_xid = xid;
-        request->rm_direction = CALL;
+    request->rm_xid = xid;
+    request->rm_direction = CALL;
 
-        request->rm_call.cb_rpcvers = 2;
-        request->rm_call.cb_prog = prognum;
-        request->rm_call.cb_vers = progver;
-        request->rm_call.cb_proc = procnum;
+    request->rm_call.cb_rpcvers = 2;
+    request->rm_call.cb_prog = prognum;
+    request->rm_call.cb_vers = progver;
+    request->rm_call.cb_proc = procnum;
 
-        if (!clnt->auth_value) {
-                request->rm_call.cb_cred.oa_flavor = AUTH_NULL;
-                request->rm_call.cb_cred.oa_base   = NULL;
-                request->rm_call.cb_cred.oa_length = 0;
-        } else {
-                ret = xdr_serialize_glusterfs_auth (clnt, fr, auth_data);
-                if (ret == -1) {
-                        gf_log ("rpc-clnt", GF_LOG_WARNING,
-                                "cannot encode auth credentials");
-                        goto out;
-                }
-
-                request->rm_call.cb_cred.oa_flavor = clnt->auth_value;
-                request->rm_call.cb_cred.oa_base   = auth_data;
-                request->rm_call.cb_cred.oa_length = ret;
+    if (!clnt->auth_value) {
+        request->rm_call.cb_cred.oa_flavor = AUTH_NULL;
+        request->rm_call.cb_cred.oa_base = NULL;
+        request->rm_call.cb_cred.oa_length = 0;
+    } else {
+        ret = xdr_serialize_glusterfs_auth(clnt, fr, auth_data);
+        if (ret == -1) {
+            gf_log("rpc-clnt", GF_LOG_WARNING,
+                   "cannot encode auth credentials");
+            goto out;
         }
-        request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_verf.oa_base = NULL;
-        request->rm_call.cb_verf.oa_length = 0;
 
-        ret = 0;
+        request->rm_call.cb_cred.oa_flavor = clnt->auth_value;
+        request->rm_call.cb_cred.oa_base = auth_data;
+        request->rm_call.cb_cred.oa_length = ret;
+    }
+    request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_verf.oa_base = NULL;
+    request->rm_call.cb_verf.oa_length = 0;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 struct iovec
-rpc_clnt_record_build_header (char *recordstart, size_t rlen,
-                              struct rpc_msg *request, size_t payload)
+rpc_clnt_record_build_header(char *recordstart, size_t rlen,
+                             struct rpc_msg *request, size_t payload)
 {
-        struct iovec    requesthdr = {0, };
-        struct iovec    txrecord   = {0, 0};
-        int             ret        = -1;
-        size_t          fraglen    = 0;
-
-        ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr);
-        if (ret == -1) {
-                gf_log ("rpc-clnt", GF_LOG_DEBUG,
-                        "Failed to create RPC request");
-                goto out;
-        }
-
-        fraglen = payload + requesthdr.iov_len;
-        gf_log ("rpc-clnt", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len);
-
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = requesthdr.iov_len;
+    struct iovec requesthdr = {
+        0,
+    };
+    struct iovec txrecord = {0, 0};
+    int ret = -1;
+    size_t fraglen = 0;
+
+    ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr);
+    if (ret == -1) {
+        gf_log("rpc-clnt", GF_LOG_DEBUG, "Failed to create RPC request");
+        goto out;
+    }
+
+    fraglen = payload + requesthdr.iov_len;
+    gf_log("rpc-clnt", GF_LOG_TRACE,
+           "Request fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, requesthdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = requesthdr.iov_len;
 
 out:
-        return txrecord;
+    return txrecord;
 }
 
-
 struct iobuf *
-rpc_clnt_record_build_record (struct rpc_clnt *clnt, call_frame_t *fr,
-                              int prognum, int progver,
-                              int procnum, size_t hdrsize, uint64_t xid,
-                              struct iovec *recbuf)
+rpc_clnt_record_build_record(struct rpc_clnt *clnt, call_frame_t *fr,
+                             int prognum, int progver, int procnum,
+                             size_t hdrsize, uint64_t xid, struct iovec *recbuf)
 {
-        struct rpc_msg  request                      = {0, };
-        struct iobuf   *request_iob                  = NULL;
-        char           *record                       = NULL;
-        struct iovec    recordhdr                    = {0, };
-        size_t          pagesize                     = 0;
-        int             ret                          = -1;
-        size_t          xdr_size                     = 0;
-        char            auth_data[GF_MAX_AUTH_BYTES] = {0, };
-
-        if ((!clnt) || (!recbuf)) {
-                goto out;
-        }
-
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        ret = rpc_clnt_fill_request (clnt, prognum, progver, procnum,
-                                     xid, fr, &request, auth_data);
-
-        if (ret == -1) {
-                gf_log (clnt->conn.name, GF_LOG_WARNING,
-                        "cannot build a rpc-request xid (%"PRIu64")", xid);
-                goto out;
-        }
-
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request);
-
-        /* First, try to get a pointer into the buffer which the RPC
-         * layer can use.
-         */
-        request_iob = iobuf_get2 (clnt->ctx->iobuf_pool, (xdr_size + hdrsize));
-        if (!request_iob) {
-                goto out;
-        }
-
-        pagesize = iobuf_pagesize (request_iob);
-
-        record = iobuf_ptr (request_iob);  /* Now we have it. */
-
-        recordhdr = rpc_clnt_record_build_header (record, pagesize, &request,
-                                                  hdrsize);
-
-        if (!recordhdr.iov_base) {
-                gf_log (clnt->conn.name, GF_LOG_ERROR,
-                        "Failed to build record header");
-                iobuf_unref (request_iob);
-                request_iob = NULL;
-                recbuf->iov_base = NULL;
-                goto out;
-        }
-
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+    struct rpc_msg request = {
+        0,
+    };
+    struct iobuf *request_iob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    int ret = -1;
+    size_t xdr_size = 0;
+    char auth_data[GF_MAX_AUTH_BYTES] = {
+        0,
+    };
+
+    if ((!clnt) || (!recbuf)) {
+        goto out;
+    }
+
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpc_clnt_fill_request(clnt, prognum, progver, procnum, xid, fr,
+                                &request, auth_data);
+
+    if (ret == -1) {
+        gf_log(clnt->conn.name, GF_LOG_WARNING,
+               "cannot build a rpc-request xid (%" PRIu64 ")", xid);
+        goto out;
+    }
+
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request);
+
+    /* First, try to get a pointer into the buffer which the RPC
+     * layer can use.
+     */
+    request_iob = iobuf_get2(clnt->ctx->iobuf_pool, (xdr_size + hdrsize));
+    if (!request_iob) {
+        goto out;
+    }
+
+    pagesize = iobuf_pagesize(request_iob);
+
+    record = iobuf_ptr(request_iob); /* Now we have it. */
+
+    recordhdr = rpc_clnt_record_build_header(record, pagesize, &request,
+                                             hdrsize);
+
+    if (!recordhdr.iov_base) {
+        gf_log(clnt->conn.name, GF_LOG_ERROR, "Failed to build record header");
+        iobuf_unref(request_iob);
+        request_iob = NULL;
+        recbuf->iov_base = NULL;
+        goto out;
+    }
+
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 
 out:
-        return request_iob;
+    return request_iob;
 }
 
-
 static inline struct iobuf *
-rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame,
-                 rpc_clnt_prog_t *prog, int procnum, size_t hdrlen,
-                 struct iovec *rpchdr, uint64_t callid)
+rpc_clnt_record(struct rpc_clnt *clnt, call_frame_t *call_frame,
+                rpc_clnt_prog_t *prog, int procnum, size_t hdrlen,
+                struct iovec *rpchdr, uint64_t callid)
 {
+    if (!prog || !rpchdr || !call_frame) {
+        return NULL;
+    }
 
-        if (!prog || !rpchdr || !call_frame) {
-                return NULL;
-        }
-
-        return rpc_clnt_record_build_record (clnt, call_frame,
-                                             prog->prognum,
-                                             prog->progver,
-                                             procnum, hdrlen,
-                                             callid, rpchdr);
+    return rpc_clnt_record_build_record(clnt, call_frame, prog->prognum,
+                                        prog->progver, procnum, hdrlen, callid,
+                                        rpchdr);
 }
 
 int
-rpcclnt_cbk_program_register (struct rpc_clnt *clnt,
-                              rpcclnt_cb_program_t *program, void *mydata)
+rpcclnt_cbk_program_register(struct rpc_clnt *clnt,
+                             rpcclnt_cb_program_t *program, void *mydata)
 {
-        int                   ret                = -1;
-        char                  already_registered = 0;
-        rpcclnt_cb_program_t *tmp                = NULL;
+    int ret = -1;
+    char already_registered = 0;
+    rpcclnt_cb_program_t *tmp = NULL;
 
-        if (!clnt)
-                goto out;
+    if (!clnt)
+        goto out;
 
-        if (program->actors == NULL)
-                goto out;
+    if (program->actors == NULL)
+        goto out;
 
-        pthread_mutex_lock (&clnt->lock);
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_for_each_entry(tmp, &clnt->programs, program)
         {
-                list_for_each_entry (tmp, &clnt->programs, program) {
-                        if ((program->prognum == tmp->prognum)
-                            && (program->progver == tmp->progver)) {
-                                already_registered = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == tmp->prognum) &&
+                (program->progver == tmp->progver)) {
+                already_registered = 1;
+                break;
+            }
         }
-        pthread_mutex_unlock (&clnt->lock);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        if (already_registered) {
-                gf_log_callingfn (clnt->conn.name, GF_LOG_DEBUG,
-                                  "already registered");
-                ret = 0;
-                goto out;
-        }
+    if (already_registered) {
+        gf_log_callingfn(clnt->conn.name, GF_LOG_DEBUG, "already registered");
+        ret = 0;
+        goto out;
+    }
 
-        tmp = GF_MALLOC (sizeof (*tmp),
-                         gf_common_mt_rpcclnt_cb_program_t);
-        if (tmp == NULL) {
-                goto out;
-        }
+    tmp = GF_MALLOC(sizeof(*tmp), gf_common_mt_rpcclnt_cb_program_t);
+    if (tmp == NULL) {
+        goto out;
+    }
 
-        memcpy (tmp, program, sizeof (*tmp));
-        INIT_LIST_HEAD (&tmp->program);
+    memcpy(tmp, program, sizeof(*tmp));
+    INIT_LIST_HEAD(&tmp->program);
 
-        tmp->mydata = mydata;
+    tmp->mydata = mydata;
 
-        pthread_mutex_lock (&clnt->lock);
-        {
-                list_add_tail (&tmp->program, &clnt->programs);
-        }
-        pthread_mutex_unlock (&clnt->lock);
+    pthread_mutex_lock(&clnt->lock);
+    {
+        list_add_tail(&tmp->program, &clnt->programs);
+    }
+    pthread_mutex_unlock(&clnt->lock);
 
-        ret = 0;
-        gf_log (clnt->conn.name, GF_LOG_DEBUG,
-                "New program registered: %s, Num: %d, Ver: %d",
-                program->progname, program->prognum,
-                program->progver);
+    ret = 0;
+    gf_log(clnt->conn.name, GF_LOG_DEBUG,
+           "New program registered: %s, Num: %d, Ver: %d", program->progname,
+           program->prognum, program->progver);
 
 out:
-        if (ret == -1 && clnt) {
-                        gf_log (clnt->conn.name, GF_LOG_ERROR,
-                                        "Program registration failed:"
-                                        " %s, Num: %d, Ver: %d",
-                                        program->progname,
-                                        program->prognum, program->progver);
-        }
-
-        return ret;
+    if (ret == -1 && clnt) {
+        gf_log(clnt->conn.name, GF_LOG_ERROR,
+               "Program registration failed:"
+               " %s, Num: %d, Ver: %d",
+               program->progname, program->prognum, program->progver);
+    }
+
+    return ret;
 }
 
-
 int
-rpc_clnt_submit (struct rpc_clnt *rpc, rpc_clnt_prog_t *prog,
-                 int procnum, fop_cbk_fn_t cbkfn,
-                 struct iovec *proghdr, int proghdrcount,
-                 struct iovec *progpayload, int progpayloadcount,
-                 struct iobref *iobref, void *frame, struct iovec *rsphdr,
-                 int rsphdr_count, struct iovec *rsp_payload,
-                 int rsp_payload_count, struct iobref *rsp_iobref)
+rpc_clnt_submit(struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, int procnum,
+                fop_cbk_fn_t cbkfn, struct iovec *proghdr, int proghdrcount,
+                struct iovec *progpayload, int progpayloadcount,
+                struct iobref *iobref, void *frame, struct iovec *rsphdr,
+                int rsphdr_count, struct iovec *rsp_payload,
+                int rsp_payload_count, struct iobref *rsp_iobref)
 {
-        rpc_clnt_connection_t *conn        = NULL;
-        struct iobuf          *request_iob = NULL;
-        struct iovec           rpchdr      = {0,};
-        struct rpc_req        *rpcreq      = NULL;
-        rpc_transport_req_t    req;
-        int                    ret         = -1;
-        int                    proglen     = 0;
-        char                   new_iobref  = 0;
-        uint64_t               callid      = 0;
-        gf_boolean_t           need_unref  = _gf_false;
-        call_frame_t          *cframe      = frame;
-
-        if (!rpc || !prog || !frame) {
-                goto out;
-        }
-
-        conn = &rpc->conn;
-
-        rpcreq = mem_get (rpc->reqpool);
-        if (rpcreq == NULL) {
-                goto out;
-        }
-
-        memset (rpcreq, 0, sizeof (*rpcreq));
-        memset (&req, 0, sizeof (req));
-
+    rpc_clnt_connection_t *conn = NULL;
+    struct iobuf *request_iob = NULL;
+    struct iovec rpchdr = {
+        0,
+    };
+    struct rpc_req *rpcreq = NULL;
+    rpc_transport_req_t req;
+    int ret = -1;
+    int proglen = 0;
+    char new_iobref = 0;
+    uint64_t callid = 0;
+    gf_boolean_t need_unref = _gf_false;
+    call_frame_t *cframe = frame;
+
+    if (!rpc || !prog || !frame) {
+        goto out;
+    }
+
+    conn = &rpc->conn;
+
+    rpcreq = mem_get(rpc->reqpool);
+    if (rpcreq == NULL) {
+        goto out;
+    }
+
+    memset(rpcreq, 0, sizeof(*rpcreq));
+    memset(&req, 0, sizeof(req));
+
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        goto out;
-                }
-
-                new_iobref = 1;
-        }
-
-        callid = GF_ATOMIC_INC (rpc->xid);
-
-        rpcreq->prog = prog;
-        rpcreq->procnum = procnum;
-        rpcreq->conn = conn;
-        rpcreq->xid = callid;
-        rpcreq->cbkfn = cbkfn;
-
-        ret = -1;
-
-        if (proghdr) {
-                proglen += iov_length (proghdr, proghdrcount);
+            goto out;
+        }
+
+        new_iobref = 1;
+    }
+
+    callid = GF_ATOMIC_INC(rpc->xid);
+
+    rpcreq->prog = prog;
+    rpcreq->procnum = procnum;
+    rpcreq->conn = conn;
+    rpcreq->xid = callid;
+    rpcreq->cbkfn = cbkfn;
+
+    ret = -1;
+
+    if (proghdr) {
+        proglen += iov_length(proghdr, proghdrcount);
+    }
+
+    request_iob = rpc_clnt_record(rpc, frame, prog, procnum, proglen, &rpchdr,
+                                  callid);
+    if (!request_iob) {
+        gf_log(conn->name, GF_LOG_WARNING, "cannot build rpc-record");
+        goto out;
+    }
+
+    iobref_add(iobref, request_iob);
+
+    req.msg.rpchdr = &rpchdr;
+    req.msg.rpchdrcount = 1;
+    req.msg.proghdr = proghdr;
+    req.msg.proghdrcount = proghdrcount;
+    req.msg.progpayload = progpayload;
+    req.msg.progpayloadcount = progpayloadcount;
+    req.msg.iobref = iobref;
+
+    req.rsp.rsphdr = rsphdr;
+    req.rsp.rsphdr_count = rsphdr_count;
+    req.rsp.rsp_payload = rsp_payload;
+    req.rsp.rsp_payload_count = rsp_payload_count;
+    req.rsp.rsp_iobref = rsp_iobref;
+    req.rpc_req = rpcreq;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        if (conn->connected == 0 && !rpc->disabled) {
+            ret = rpc_transport_connect(conn->trans, conn->config.remote_port);
+            if (ret < 0) {
+                gf_log(conn->name, GF_LOG_WARNING,
+                       "error returned while attempting to "
+                       "connect to host:%s, port:%d",
+                       conn->config.remote_host, conn->config.remote_port);
+            }
         }
 
-        request_iob = rpc_clnt_record (rpc, frame, prog,
-                                       procnum, proglen,
-                                       &rpchdr, callid);
-        if (!request_iob) {
-                gf_log (conn->name, GF_LOG_WARNING,
-                        "cannot build rpc-record");
-                goto out;
+        ret = rpc_transport_submit_request(conn->trans, &req);
+        if (ret == -1) {
+            gf_log(conn->name, GF_LOG_WARNING,
+                   "failed to submit rpc-request "
+                   "(unique: %" PRIu64
+                   ", XID: 0x%x Program: %s, "
+                   "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
+                   cframe->root->unique, rpcreq->xid, rpcreq->prog->progname,
+                   rpcreq->prog->progver, rpcreq->procnum, conn->name);
         }
 
-        iobref_add (iobref, request_iob);
-
-        req.msg.rpchdr = &rpchdr;
-        req.msg.rpchdrcount = 1;
-        req.msg.proghdr = proghdr;
-        req.msg.proghdrcount = proghdrcount;
-        req.msg.progpayload = progpayload;
-        req.msg.progpayloadcount = progpayloadcount;
-        req.msg.iobref = iobref;
+        if ((ret >= 0) && frame) {
+            /* Save the frame in queue */
+            __save_frame(rpc, frame, rpcreq);
 
-        req.rsp.rsphdr = rsphdr;
-        req.rsp.rsphdr_count = rsphdr_count;
-        req.rsp.rsp_payload = rsp_payload;
-        req.rsp.rsp_payload_count = rsp_payload_count;
-        req.rsp.rsp_iobref = rsp_iobref;
-        req.rpc_req = rpcreq;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                if (conn->connected == 0 && !rpc->disabled) {
-                        ret = rpc_transport_connect (conn->trans,
-                                                     conn->config.remote_port);
-                        if (ret < 0) {
-                                gf_log (conn->name, GF_LOG_WARNING,
-                                        "error returned while attempting to "
-                                        "connect to host:%s, port:%d",
-                                        conn->config.remote_host,
-                                        conn->config.remote_port);
-                        }
-                }
+            /* A ref on rpc-clnt object is taken while registering
+             * call_bail to timer in __save_frame. If it fails to
+             * register, it needs an unref and should happen outside
+             * conn->lock which otherwise leads to deadlocks */
+            if (conn->timer == NULL)
+                need_unref = _gf_true;
 
-                ret = rpc_transport_submit_request (conn->trans, &req);
-                if (ret == -1) {
-                        gf_log (conn->name, GF_LOG_WARNING,
-                                "failed to submit rpc-request "
-                                "(unique: %"PRIu64", XID: 0x%x Program: %s, "
-                                "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
-                                cframe->root->unique, rpcreq->xid,
-                                rpcreq->prog->progname, rpcreq->prog->progver,
-                                rpcreq->procnum, conn->name);
-                }
+            conn->msgcnt++;
 
-                if ((ret >= 0) && frame) {
-                        /* Save the frame in queue */
-                        __save_frame (rpc, frame, rpcreq);
-
-                        /* A ref on rpc-clnt object is taken while registering
-                         * call_bail to timer in __save_frame. If it fails to
-                         * register, it needs an unref and should happen outside
-                         * conn->lock which otherwise leads to deadlocks */
-                        if (conn->timer == NULL)
-                                need_unref = _gf_true;
-
-                        conn->msgcnt++;
-
-                        gf_log ("rpc-clnt", GF_LOG_TRACE, "submitted request "
-                                "(unique: %"PRIu64", XID: 0x%x, Program: %s, "
-                                "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
-                                cframe->root->unique, rpcreq->xid,
-                                rpcreq->prog->progname, rpcreq->prog->progver,
-                                rpcreq->procnum, conn->name);
-                }
+            gf_log("rpc-clnt", GF_LOG_TRACE,
+                   "submitted request "
+                   "(unique: %" PRIu64
+                   ", XID: 0x%x, Program: %s, "
+                   "ProgVers: %d, Proc: %d) to rpc-transport (%s)",
+                   cframe->root->unique, rpcreq->xid, rpcreq->prog->progname,
+                   rpcreq->prog->progver, rpcreq->procnum, conn->name);
         }
-        pthread_mutex_unlock (&conn->lock);
+    }
+    pthread_mutex_unlock(&conn->lock);
 
-        if (need_unref)
-                rpc_clnt_unref (rpc);
+    if (need_unref)
+        rpc_clnt_unref(rpc);
 
-        if (ret == -1) {
-                goto out;
-        }
+    if (ret == -1) {
+        goto out;
+    }
 
-        rpc_clnt_check_and_start_ping (rpc);
-        ret = 0;
+    rpc_clnt_check_and_start_ping(rpc);
+    ret = 0;
 
 out:
-        if (request_iob) {
-                iobuf_unref (request_iob);
-        }
-
-        if (new_iobref && iobref) {
-                iobref_unref (iobref);
-        }
-
-        if (frame && (ret == -1)) {
-                if (rpcreq) {
-                        rpcreq->rpc_status = -1;
-                        cbkfn (rpcreq, NULL, 0, frame);
-                        mem_put (rpcreq);
-                }
-        }
-        return ret;
+    if (request_iob) {
+        iobuf_unref(request_iob);
+    }
+
+    if (new_iobref && iobref) {
+        iobref_unref(iobref);
+    }
+
+    if (frame && (ret == -1)) {
+        if (rpcreq) {
+            rpcreq->rpc_status = -1;
+            cbkfn(rpcreq, NULL, 0, frame);
+            mem_put(rpcreq);
+        }
+    }
+    return ret;
 }
 
-
 struct rpc_clnt *
-rpc_clnt_ref (struct rpc_clnt *rpc)
+rpc_clnt_ref(struct rpc_clnt *rpc)
 {
-        if (!rpc)
-                return NULL;
+    if (!rpc)
+        return NULL;
 
-        GF_ATOMIC_INC (rpc->refcount);
-        return rpc;
+    GF_ATOMIC_INC(rpc->refcount);
+    return rpc;
 }
 
-
 static void
-rpc_clnt_trigger_destroy (struct rpc_clnt *rpc)
+rpc_clnt_trigger_destroy(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t  *conn  = NULL;
-        rpc_transport_t        *trans = NULL;
-
-        if (!rpc)
-                return;
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
 
-        /* reading conn->trans outside conn->lock is OK, since this is the last
-         * ref*/
-        conn = &rpc->conn;
-        trans = conn->trans;
-        rpc_clnt_disconnect (rpc);
+    if (!rpc)
+        return;
 
-        /* This is to account for rpc_clnt_disable that might have been called
-         * before rpc_clnt_unref */
-        if (trans) {
-                /* set conn->trans to NULL before rpc_transport_unref
-                 * as rpc_transport_unref can potentially free conn
-                 */
-                conn->trans = NULL;
-                rpc_transport_unref (trans);
-        }
+    /* reading conn->trans outside conn->lock is OK, since this is the last
+     * ref*/
+    conn = &rpc->conn;
+    trans = conn->trans;
+    rpc_clnt_disconnect(rpc);
+
+    /* This is to account for rpc_clnt_disable that might have been called
+     * before rpc_clnt_unref */
+    if (trans) {
+        /* set conn->trans to NULL before rpc_transport_unref
+         * as rpc_transport_unref can potentially free conn
+         */
+        conn->trans = NULL;
+        rpc_transport_unref(trans);
+    }
 }
 
 static void
-rpc_clnt_destroy (struct rpc_clnt *rpc)
+rpc_clnt_destroy(struct rpc_clnt *rpc)
 {
-        rpcclnt_cb_program_t   *program = NULL;
-        rpcclnt_cb_program_t   *tmp = NULL;
-        struct saved_frames    *saved_frames = NULL;
-        rpc_clnt_connection_t  *conn = NULL;
-
-        if (!rpc)
-                return;
-
-        conn = &rpc->conn;
-        GF_FREE (rpc->conn.name);
-        /* Access saved_frames in critical-section to avoid
-           crash in rpc_clnt_connection_cleanup at the time
-           of destroying saved frames
-        */
-        pthread_mutex_lock (&conn->lock);
-        {
-                saved_frames = conn->saved_frames;
-                conn->saved_frames = NULL;
-        }
-        pthread_mutex_unlock (&conn->lock);
+    rpcclnt_cb_program_t *program = NULL;
+    rpcclnt_cb_program_t *tmp = NULL;
+    struct saved_frames *saved_frames = NULL;
+    rpc_clnt_connection_t *conn = NULL;
 
-        saved_frames_destroy (saved_frames);
-        pthread_mutex_destroy (&rpc->lock);
-        pthread_mutex_destroy (&rpc->conn.lock);
-
-        /* mem-pool should be destroyed, otherwise,
-           it will cause huge memory leaks */
-        mem_pool_destroy (rpc->reqpool);
-        mem_pool_destroy (rpc->saved_frames_pool);
-
-        list_for_each_entry_safe (program, tmp, &rpc->programs, program) {
-                GF_FREE (program);
-        }
-
-        GF_FREE (rpc);
+    if (!rpc)
         return;
+
+    conn = &rpc->conn;
+    GF_FREE(rpc->conn.name);
+    /* Access saved_frames in critical-section to avoid
+       crash in rpc_clnt_connection_cleanup at the time
+       of destroying saved frames
+    */
+    pthread_mutex_lock(&conn->lock);
+    {
+        saved_frames = conn->saved_frames;
+        conn->saved_frames = NULL;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    saved_frames_destroy(saved_frames);
+    pthread_mutex_destroy(&rpc->lock);
+    pthread_mutex_destroy(&rpc->conn.lock);
+
+    /* mem-pool should be destroyed, otherwise,
+       it will cause huge memory leaks */
+    mem_pool_destroy(rpc->reqpool);
+    mem_pool_destroy(rpc->saved_frames_pool);
+
+    list_for_each_entry_safe(program, tmp, &rpc->programs, program)
+    {
+        GF_FREE(program);
+    }
+
+    GF_FREE(rpc);
+    return;
 }
 
 struct rpc_clnt *
-rpc_clnt_unref (struct rpc_clnt *rpc)
+rpc_clnt_unref(struct rpc_clnt *rpc)
 {
-        int     count = 0;
+    int count = 0;
 
-        if (!rpc)
-                return NULL;
+    if (!rpc)
+        return NULL;
 
-        count = GF_ATOMIC_DEC (rpc->refcount);
+    count = GF_ATOMIC_DEC(rpc->refcount);
 
-        if (!count) {
-                rpc_clnt_trigger_destroy (rpc);
-                return NULL;
-        }
-        return rpc;
+    if (!count) {
+        rpc_clnt_trigger_destroy(rpc);
+        return NULL;
+    }
+    return rpc;
 }
 
-
 char
-rpc_clnt_is_disabled (struct rpc_clnt *rpc)
+rpc_clnt_is_disabled(struct rpc_clnt *rpc)
 {
+    rpc_clnt_connection_t *conn = NULL;
+    char disabled = 0;
 
-        rpc_clnt_connection_t *conn = NULL;
-        char                   disabled = 0;
+    if (!rpc) {
+        goto out;
+    }
 
-        if (!rpc) {
-                goto out;
-        }
+    conn = &rpc->conn;
 
-        conn = &rpc->conn;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                disabled = rpc->disabled;
-        }
-        pthread_mutex_unlock (&conn->lock);
+    pthread_mutex_lock(&conn->lock);
+    {
+        disabled = rpc->disabled;
+    }
+    pthread_mutex_unlock(&conn->lock);
 
 out:
-        return disabled;
+    return disabled;
 }
 
 void
-rpc_clnt_disable (struct rpc_clnt *rpc)
+rpc_clnt_disable(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t *conn = NULL;
-        rpc_transport_t       *trans = NULL;
-        int                    unref = 0;
-        int                    ret   = 0;
-        gf_boolean_t           timer_unref = _gf_false;
-        gf_boolean_t           reconnect_unref = _gf_false;
-
-        if (!rpc) {
-                goto out;
-        }
-
-        conn = &rpc->conn;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 1;
-
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->timer);
-                        /* If the event is not fired and it actually cancelled
-                         * the timer, do the unref else registered call back
-                         * function will take care of it.
-                         */
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect);
-                        if (!ret)
-                                reconnect_unref = _gf_true;
-                        conn->reconnect = NULL;
-                }
-                conn->connected = 0;
-
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-                trans = conn->trans;
-
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-                /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
-                 *    if (clnt->auth_value)
-                 *           clnt->auth_value = AUTH_GLUSTERFS_v2;
-                 * It should not be reset here. The disconnect during
-                 * portmap request can race with handshake. If handshake
-                 * happens first and disconnect later, auth_value would set
-                 * to default value and it never sets back to actual auth_value
-                 * supported by server. But it's important to set to lower
-                 * version supported in the case where the server downgrades.
-                 * So moving this code to RPC_TRANSPORT_CONNECT. Note that
-                 * CONNECT cannot race with handshake as by nature it is
-                 * serialized with handhake. An handshake can happen only
-                 * on a connected transport and hence its strictly serialized.
-                 */
-        }
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
+    int unref = 0;
+    int ret = 0;
+    gf_boolean_t timer_unref = _gf_false;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!rpc) {
+        goto out;
+    }
+
+    conn = &rpc->conn;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 1;
+
+        if (conn->timer) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->timer);
+            /* If the event is not fired and it actually cancelled
+             * the timer, do the unref else registered call back
+             * function will take care of it.
+             */
+            if (!ret)
+                timer_unref = _gf_true;
+            conn->timer = NULL;
+        }
+
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->reconnect);
+            if (!ret)
+                reconnect_unref = _gf_true;
+            conn->reconnect = NULL;
+        }
+        conn->connected = 0;
+
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+        trans = conn->trans;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (trans) {
+        rpc_transport_disconnect(trans, _gf_true);
+        /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
+         *    if (clnt->auth_value)
+         *           clnt->auth_value = AUTH_GLUSTERFS_v2;
+         * It should not be reset here. The disconnect during
+         * portmap request can race with handshake. If handshake
+         * happens first and disconnect later, auth_value would set
+         * to default value and it never sets back to actual auth_value
+         * supported by server. But it's important to set to lower
+         * version supported in the case where the server downgrades.
+         * So moving this code to RPC_TRANSPORT_CONNECT. Note that
+         * CONNECT cannot race with handshake as by nature it is
+         * serialized with handhake. An handshake can happen only
+         * on a connected transport and hence its strictly serialized.
+         */
+    }
 
-        if (unref)
-                rpc_clnt_unref (rpc);
+    if (unref)
+        rpc_clnt_unref(rpc);
 
-        if (timer_unref)
-                rpc_clnt_unref (rpc);
+    if (timer_unref)
+        rpc_clnt_unref(rpc);
 
-        if (reconnect_unref)
-                rpc_clnt_unref (rpc);
+    if (reconnect_unref)
+        rpc_clnt_unref(rpc);
 
 out:
-        return;
+    return;
 }
 
 void
-rpc_clnt_disconnect (struct rpc_clnt *rpc)
+rpc_clnt_disconnect(struct rpc_clnt *rpc)
 {
-        rpc_clnt_connection_t *conn  = NULL;
-        rpc_transport_t       *trans = NULL;
-        int                    unref = 0;
-        int                    ret   = 0;
-        gf_boolean_t           timer_unref = _gf_false;
-        gf_boolean_t           reconnect_unref = _gf_false;
-
-        if (!rpc)
-                goto out;
-
-        conn = &rpc->conn;
-
-        pthread_mutex_lock (&conn->lock);
-        {
-                rpc->disabled = 1;
-                if (conn->timer) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->timer);
-                        /* If the event is not fired and it actually cancelled
-                         * the timer, do the unref else registered call back
-                         * function will take care of unref.
-                         */
-                        if (!ret)
-                                timer_unref = _gf_true;
-                        conn->timer = NULL;
-                }
-
-                if (conn->reconnect) {
-                        ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect);
-                        if (!ret)
-                                reconnect_unref = _gf_true;
-                        conn->reconnect = NULL;
-                }
-                conn->connected = 0;
-
-                unref = rpc_clnt_remove_ping_timer_locked (rpc);
-                trans = conn->trans;
-        }
-        pthread_mutex_unlock (&conn->lock);
-
-        if (trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-                /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
-                 *    if (clnt->auth_value)
-                 *           clnt->auth_value = AUTH_GLUSTERFS_v2;
-                 * It should not be reset here. The disconnect during
-                 * portmap request can race with handshake. If handshake
-                 * happens first and disconnect later, auth_value would set
-                 * to default value and it never sets back to actual auth_value
-                 * supported by server. But it's important to set to lower
-                 * version supported in the case where the server downgrades.
-                 * So moving this code to RPC_TRANSPORT_CONNECT. Note that
-                 * CONNECT cannot race with handshake as by nature it is
-                 * serialized with handhake. An handshake can happen only
-                 * on a connected transport and hence its strictly serialized.
-                 */
-        }
-        if (unref)
-                rpc_clnt_unref (rpc);
+    rpc_clnt_connection_t *conn = NULL;
+    rpc_transport_t *trans = NULL;
+    int unref = 0;
+    int ret = 0;
+    gf_boolean_t timer_unref = _gf_false;
+    gf_boolean_t reconnect_unref = _gf_false;
+
+    if (!rpc)
+        goto out;
+
+    conn = &rpc->conn;
+
+    pthread_mutex_lock(&conn->lock);
+    {
+        rpc->disabled = 1;
+        if (conn->timer) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->timer);
+            /* If the event is not fired and it actually cancelled
+             * the timer, do the unref else registered call back
+             * function will take care of unref.
+             */
+            if (!ret)
+                timer_unref = _gf_true;
+            conn->timer = NULL;
+        }
+
+        if (conn->reconnect) {
+            ret = gf_timer_call_cancel(rpc->ctx, conn->reconnect);
+            if (!ret)
+                reconnect_unref = _gf_true;
+            conn->reconnect = NULL;
+        }
+        conn->connected = 0;
+
+        unref = rpc_clnt_remove_ping_timer_locked(rpc);
+        trans = conn->trans;
+    }
+    pthread_mutex_unlock(&conn->lock);
+
+    if (trans) {
+        rpc_transport_disconnect(trans, _gf_true);
+        /* The auth_value was being reset to AUTH_GLUSTERFS_v2.
+         *    if (clnt->auth_value)
+         *           clnt->auth_value = AUTH_GLUSTERFS_v2;
+         * It should not be reset here. The disconnect during
+         * portmap request can race with handshake. If handshake
+         * happens first and disconnect later, auth_value would set
+         * to default value and it never sets back to actual auth_value
+         * supported by server. But it's important to set to lower
+         * version supported in the case where the server downgrades.
+         * So moving this code to RPC_TRANSPORT_CONNECT. Note that
+         * CONNECT cannot race with handshake as by nature it is
+         * serialized with handhake. An handshake can happen only
+         * on a connected transport and hence its strictly serialized.
+         */
+    }
+    if (unref)
+        rpc_clnt_unref(rpc);
 
-        if (timer_unref)
-                rpc_clnt_unref (rpc);
+    if (timer_unref)
+        rpc_clnt_unref(rpc);
 
-        if (reconnect_unref)
-                rpc_clnt_unref (rpc);
+    if (reconnect_unref)
+        rpc_clnt_unref(rpc);
 
 out:
-        return;
+    return;
 }
 
-
 void
-rpc_clnt_reconfig (struct rpc_clnt *rpc, struct rpc_clnt_config *config)
+rpc_clnt_reconfig(struct rpc_clnt *rpc, struct rpc_clnt_config *config)
 {
-        if (config->ping_timeout) {
-                if (config->ping_timeout != rpc->conn.ping_timeout)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing ping timeout to %d (from %d)",
-                                config->ping_timeout,
-                                rpc->conn.ping_timeout);
-
-                pthread_mutex_lock (&rpc->conn.lock);
-                {
-                rpc->conn.ping_timeout = config->ping_timeout;
-                }
-                pthread_mutex_unlock (&rpc->conn.lock);
-
-        }
-
-        if (config->rpc_timeout) {
-                if (config->rpc_timeout != rpc->conn.config.rpc_timeout)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing timeout to %d (from %d)",
-                                config->rpc_timeout,
-                                rpc->conn.config.rpc_timeout);
-                rpc->conn.config.rpc_timeout = config->rpc_timeout;
-        }
-
-        if (config->remote_port) {
-                if (config->remote_port != rpc->conn.config.remote_port)
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "changing port to %d (from %d)",
-                                config->remote_port,
-                                rpc->conn.config.remote_port);
+    if (config->ping_timeout) {
+        if (config->ping_timeout != rpc->conn.ping_timeout)
+            gf_log(rpc->conn.name, GF_LOG_INFO,
+                   "changing ping timeout to %d (from %d)",
+                   config->ping_timeout, rpc->conn.ping_timeout);
 
-                rpc->conn.config.remote_port = config->remote_port;
+        pthread_mutex_lock(&rpc->conn.lock);
+        {
+            rpc->conn.ping_timeout = config->ping_timeout;
+        }
+        pthread_mutex_unlock(&rpc->conn.lock);
+    }
+
+    if (config->rpc_timeout) {
+        if (config->rpc_timeout != rpc->conn.config.rpc_timeout)
+            gf_log(rpc->conn.name, GF_LOG_INFO,
+                   "changing timeout to %d (from %d)", config->rpc_timeout,
+                   rpc->conn.config.rpc_timeout);
+        rpc->conn.config.rpc_timeout = config->rpc_timeout;
+    }
+
+    if (config->remote_port) {
+        if (config->remote_port != rpc->conn.config.remote_port)
+            gf_log(rpc->conn.name, GF_LOG_INFO, "changing port to %d (from %d)",
+                   config->remote_port, rpc->conn.config.remote_port);
+
+        rpc->conn.config.remote_port = config->remote_port;
+    }
+
+    if (config->remote_host) {
+        if (rpc->conn.config.remote_host) {
+            if (strcmp(rpc->conn.config.remote_host, config->remote_host))
+                gf_log(rpc->conn.name, GF_LOG_INFO,
+                       "changing hostname to %s (from %s)", config->remote_host,
+                       rpc->conn.config.remote_host);
+            GF_FREE(rpc->conn.config.remote_host);
+        } else {
+            gf_log(rpc->conn.name, GF_LOG_INFO, "setting hostname to %s",
+                   config->remote_host);
         }
 
-        if (config->remote_host) {
-                if (rpc->conn.config.remote_host) {
-                        if (strcmp (rpc->conn.config.remote_host,
-                                    config->remote_host))
-                                gf_log (rpc->conn.name, GF_LOG_INFO,
-                                        "changing hostname to %s (from %s)",
-                                        config->remote_host,
-                                        rpc->conn.config.remote_host);
-                        GF_FREE (rpc->conn.config.remote_host);
-                } else {
-                        gf_log (rpc->conn.name, GF_LOG_INFO,
-                                "setting hostname to %s",
-                                config->remote_host);
-                }
-
-                rpc->conn.config.remote_host = gf_strdup (config->remote_host);
-        }
+        rpc->conn.config.remote_host = gf_strdup(config->remote_host);
+    }
 }
diff --git a/rpc/rpc-lib/src/rpc-drc.c b/rpc/rpc-lib/src/rpc-drc.c
index fb7d2f13605..ff983b23fb4 100644
--- a/rpc/rpc-lib/src/rpc-drc.c
+++ b/rpc/rpc-lib/src/rpc-drc.c
@@ -29,29 +29,29 @@
  * @return NULL if reply is destroyed, reply otherwise
  */
 static drc_cached_op_t *
-rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
+rpcsvc_drc_op_destroy(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (reply);
-
-        if (reply->state == DRC_OP_IN_TRANSIT)
-                return reply;
-
-        iobref_unref (reply->msg.iobref);
-        if (reply->msg.rpchdr)
-                GF_FREE (reply->msg.rpchdr);
-        if (reply->msg.proghdr)
-                GF_FREE (reply->msg.proghdr);
-        if (reply->msg.progpayload)
-                GF_FREE (reply->msg.progpayload);
-
-        list_del (&reply->global_list);
-        reply->client->op_count--;
-        drc->op_count--;
-        mem_put (reply);
-        reply = NULL;
+    GF_ASSERT(drc);
+    GF_ASSERT(reply);
 
+    if (reply->state == DRC_OP_IN_TRANSIT)
         return reply;
+
+    iobref_unref(reply->msg.iobref);
+    if (reply->msg.rpchdr)
+        GF_FREE(reply->msg.rpchdr);
+    if (reply->msg.proghdr)
+        GF_FREE(reply->msg.proghdr);
+    if (reply->msg.progpayload)
+        GF_FREE(reply->msg.progpayload);
+
+    list_del(&reply->global_list);
+    reply->client->op_count--;
+    drc->op_count--;
+    mem_put(reply);
+    reply = NULL;
+
+    return reply;
 }
 
 /**
@@ -62,9 +62,9 @@ rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
  * @return void
  */
 static void
-rpcsvc_drc_rb_op_destroy (void *reply, void *drc)
+rpcsvc_drc_rb_op_destroy(void *reply, void *drc)
 {
-        rpcsvc_drc_op_destroy (drc, (drc_cached_op_t *)reply);
+    rpcsvc_drc_op_destroy(drc, (drc_cached_op_t *)reply);
 }
 
 /**
@@ -74,11 +74,11 @@ rpcsvc_drc_rb_op_destroy (void *reply, void *drc)
  * @return void
  */
 static void
-rpcsvc_remove_drc_client (drc_client_t *client)
+rpcsvc_remove_drc_client(drc_client_t *client)
 {
-        rb_destroy (client->rbtree, rpcsvc_drc_rb_op_destroy);
-        list_del (&client->client_list);
-        GF_FREE (client);
+    rb_destroy(client->rbtree, rpcsvc_drc_rb_op_destroy);
+    list_del(&client->client_list);
+    GF_FREE(client);
 }
 
 /**
@@ -89,24 +89,25 @@ rpcsvc_remove_drc_client (drc_client_t *client)
  * @return drc client if it exists, NULL otherwise
  */
 static drc_client_t *
-rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc,
-                      struct sockaddr_storage *sockaddr)
+rpcsvc_client_lookup(rpcsvc_drc_globals_t *drc,
+                     struct sockaddr_storage *sockaddr)
 {
-        drc_client_t    *client = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (sockaddr);
+    GF_ASSERT(drc);
+    GF_ASSERT(sockaddr);
 
-        if (list_empty (&drc->clients_head))
-            return NULL;
+    if (list_empty(&drc->clients_head))
+        return NULL;
 
-        list_for_each_entry (client, &drc->clients_head, client_list) {
-                if (gf_sock_union_equal_addr (&client->sock_union,
-                                              (union gf_sock_union *)sockaddr))
-                        return client;
-        }
+    list_for_each_entry(client, &drc->clients_head, client_list)
+    {
+        if (gf_sock_union_equal_addr(&client->sock_union,
+                                     (union gf_sock_union *)sockaddr))
+            return client;
+    }
 
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -119,29 +120,28 @@ rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc,
  * @return 0 if req matches reply, else (req->xid - reply->xid)
  */
 int
-drc_compare_reqs (const void *item, const void *rb_node_data, void *param)
+drc_compare_reqs(const void *item, const void *rb_node_data, void *param)
 {
-        int               ret      = -1;
-        drc_cached_op_t  *req      = NULL;
-        drc_cached_op_t  *reply    = NULL;
+    int ret = -1;
+    drc_cached_op_t *req = NULL;
+    drc_cached_op_t *reply = NULL;
 
-        GF_ASSERT (item);
-        GF_ASSERT (rb_node_data);
-        GF_ASSERT (param);
+    GF_ASSERT(item);
+    GF_ASSERT(rb_node_data);
+    GF_ASSERT(param);
 
-        req = (drc_cached_op_t *)item;
-        reply = (drc_cached_op_t *)rb_node_data;
+    req = (drc_cached_op_t *)item;
+    reply = (drc_cached_op_t *)rb_node_data;
 
-        ret = req->xid - reply->xid;
-        if (ret != 0)
-                return ret;
+    ret = req->xid - reply->xid;
+    if (ret != 0)
+        return ret;
 
-        if (req->prognum == reply->prognum &&
-            req->procnum == reply->procnum &&
-            req->progversion == reply->progversion)
-                return 0;
+    if (req->prognum == reply->prognum && req->procnum == reply->procnum &&
+        req->progversion == reply->progversion)
+        return 0;
 
-        return 1;
+    return 1;
 }
 
 /**
@@ -152,18 +152,18 @@ drc_compare_reqs (const void *item, const void *rb_node_data, void *param)
  * @return 0 on success, -1 on failure
  */
 static int
-drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client)
+drc_init_client_cache(rpcsvc_drc_globals_t *drc, drc_client_t *client)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (client);
+    GF_ASSERT(drc);
+    GF_ASSERT(client);
 
-        client->rbtree = rb_create (drc_compare_reqs, drc, NULL);
-        if (!client->rbtree) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed");
-                return -1;
-        }
+    client->rbtree = rb_create(drc_compare_reqs, drc, NULL);
+    if (!client->rbtree) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed");
+        return -1;
+    }
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -175,42 +175,40 @@ drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client)
  * @return drc client on success, NULL on failure
  */
 static drc_client_t *
-rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc,
-                       struct sockaddr_storage *sockaddr)
+rpcsvc_get_drc_client(rpcsvc_drc_globals_t *drc,
+                      struct sockaddr_storage *sockaddr)
 {
-        drc_client_t      *client      = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (sockaddr);
+    GF_ASSERT(drc);
+    GF_ASSERT(sockaddr);
 
-        client = rpcsvc_client_lookup (drc, sockaddr);
-        if (client)
-                goto out;
+    client = rpcsvc_client_lookup(drc, sockaddr);
+    if (client)
+        goto out;
 
-        /* if lookup fails, allocate cache for the new client */
-        client = GF_CALLOC (1, sizeof (drc_client_t),
-                            gf_common_mt_drc_client_t);
-        if (!client)
-                goto out;
-
-        client->ref = 0;
-        client->sock_union = (union gf_sock_union)*sockaddr;
-        client->op_count = 0;
-        INIT_LIST_HEAD (&client->client_list);
-
-        if (drc_init_client_cache (drc, client)) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG,
-                        "initialization of drc client failed");
-                GF_FREE (client);
-                client = NULL;
-                goto out;
-        }
-        drc->client_count++;
+    /* if lookup fails, allocate cache for the new client */
+    client = GF_CALLOC(1, sizeof(drc_client_t), gf_common_mt_drc_client_t);
+    if (!client)
+        goto out;
+
+    client->ref = 0;
+    client->sock_union = (union gf_sock_union) * sockaddr;
+    client->op_count = 0;
+    INIT_LIST_HEAD(&client->client_list);
+
+    if (drc_init_client_cache(drc, client)) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "initialization of drc client failed");
+        GF_FREE(client);
+        client = NULL;
+        goto out;
+    }
+    drc->client_count++;
 
-        list_add (&client->client_list, &drc->clients_head);
+    list_add(&client->client_list, &drc->clients_head);
 
- out:
-        return client;
+out:
+    return client;
 }
 
 /**
@@ -220,25 +218,24 @@ rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc,
  * @return 1 if DRC is needed for req, 0 otherwise
  */
 int
-rpcsvc_need_drc (rpcsvc_request_t *req)
+rpcsvc_need_drc(rpcsvc_request_t *req)
 {
-        rpcsvc_actor_t           *actor = NULL;
-        rpcsvc_drc_globals_t     *drc   = NULL;
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
 
-        GF_ASSERT (req);
-        GF_ASSERT (req->svc);
+    GF_ASSERT(req);
+    GF_ASSERT(req->svc);
 
-        drc = req->svc->drc;
+    drc = req->svc->drc;
 
-        if (!drc || drc->status == DRC_UNINITIATED)
-                return 0;
+    if (!drc || drc->status == DRC_UNINITIATED)
+        return 0;
 
-        actor = rpcsvc_program_actor (req);
-        if (!actor)
-                return 0;
+    actor = rpcsvc_program_actor(req);
+    if (!actor)
+        return 0;
 
-        return (actor->op_type == DRC_NON_IDEMPOTENT
-                && drc->type != DRC_TYPE_NONE);
+    return (actor->op_type == DRC_NON_IDEMPOTENT && drc->type != DRC_TYPE_NONE);
 }
 
 /**
@@ -248,11 +245,11 @@ rpcsvc_need_drc (rpcsvc_request_t *req)
  * @return client
  */
 static drc_client_t *
-rpcsvc_drc_client_ref (drc_client_t *client)
+rpcsvc_drc_client_ref(drc_client_t *client)
 {
-        GF_ASSERT (client);
-        client->ref++;
-        return client;
+    GF_ASSERT(client);
+    client->ref++;
+    return client;
 }
 
 /**
@@ -264,19 +261,19 @@ rpcsvc_drc_client_ref (drc_client_t *client)
  * @return NULL if it is the last unref, client otherwise
  */
 static drc_client_t *
-rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client)
+rpcsvc_drc_client_unref(rpcsvc_drc_globals_t *drc, drc_client_t *client)
 {
-        GF_ASSERT (drc);
-        GF_ASSERT (client->ref);
-
-        client->ref--;
-        if (!client->ref) {
-                drc->client_count--;
-                rpcsvc_remove_drc_client (client);
-                client = NULL;
-        }
+    GF_ASSERT(drc);
+    GF_ASSERT(client->ref);
 
-        return client;
+    client->ref--;
+    if (!client->ref) {
+        drc->client_count--;
+        rpcsvc_remove_drc_client(client);
+        client = NULL;
+    }
+
+    return client;
 }
 
 /**
@@ -286,38 +283,37 @@ rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client)
  * @return cached reply of req if found, NULL otherwise
  */
 drc_cached_op_t *
-rpcsvc_drc_lookup (rpcsvc_request_t *req)
+rpcsvc_drc_lookup(rpcsvc_request_t *req)
 {
-        drc_client_t           *client = NULL;
-        drc_cached_op_t        *reply  = NULL;
-        drc_cached_op_t        new = {
-                .xid            = req->xid,
-                .prognum        = req->prognum,
-                .progversion    = req->progver,
-                .procnum        = req->procnum,
-        };
-
-        GF_ASSERT (req);
-
-        if (!req->trans->drc_client) {
-                client = rpcsvc_get_drc_client (req->svc->drc,
-                                                &req->trans->peerinfo.sockaddr);
-                if (!client)
-                        goto out;
-
-                req->trans->drc_client
-                        = rpcsvc_drc_client_ref (client);
-        }
+    drc_client_t *client = NULL;
+    drc_cached_op_t *reply = NULL;
+    drc_cached_op_t new = {
+        .xid = req->xid,
+        .prognum = req->prognum,
+        .progversion = req->progver,
+        .procnum = req->procnum,
+    };
+
+    GF_ASSERT(req);
+
+    if (!req->trans->drc_client) {
+        client = rpcsvc_get_drc_client(req->svc->drc,
+                                       &req->trans->peerinfo.sockaddr);
+        if (!client)
+            goto out;
 
-        client = req->trans->drc_client;
+        req->trans->drc_client = rpcsvc_drc_client_ref(client);
+    }
 
-        if (client->op_count == 0)
-                goto out;
+    client = req->trans->drc_client;
 
-        reply = rb_find (client->rbtree, &new);
+    if (client->op_count == 0)
+        goto out;
 
- out:
-        return reply;
+    reply = rb_find(client->rbtree, &new);
+
+out:
+    return reply;
 }
 
 /**
@@ -325,28 +321,30 @@ rpcsvc_drc_lookup (rpcsvc_request_t *req)
  *
  * @param req - incoming request (which is a duplicate in this case)
  * @param reply - the cached reply for req
- * @return 0 on successful reply submission, -1 or other non-zero value otherwise
+ * @return 0 on successful reply submission, -1 or other non-zero value
+ * otherwise
  */
 int
-rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply)
+rpcsvc_send_cached_reply(rpcsvc_request_t *req, drc_cached_op_t *reply)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        GF_ASSERT (req);
-        GF_ASSERT (reply);
+    GF_ASSERT(req);
+    GF_ASSERT(reply);
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "sending cached reply: xid: %d, "
-                "client: %s", req->xid, req->trans->peerinfo.identifier);
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "sending cached reply: xid: %d, "
+           "client: %s",
+           req->xid, req->trans->peerinfo.identifier);
 
-        rpcsvc_drc_client_ref (reply->client);
-        ret = rpcsvc_transport_submit (req->trans,
-                     reply->msg.rpchdr, reply->msg.rpchdrcount,
-                     reply->msg.proghdr, reply->msg.proghdrcount,
-                     reply->msg.progpayload, reply->msg.progpayloadcount,
-                     reply->msg.iobref, req->trans_private);
-        rpcsvc_drc_client_unref (req->svc->drc, reply->client);
+    rpcsvc_drc_client_ref(reply->client);
+    ret = rpcsvc_transport_submit(
+        req->trans, reply->msg.rpchdr, reply->msg.rpchdrcount,
+        reply->msg.proghdr, reply->msg.proghdrcount, reply->msg.progpayload,
+        reply->msg.progpayloadcount, reply->msg.iobref, req->trans_private);
+    rpcsvc_drc_client_unref(req->svc->drc, reply->client);
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -363,38 +361,37 @@ rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref,
-                    struct iovec *rpchdr, int rpchdrcount,
-                    struct iovec *proghdr, int proghdrcount,
-                    struct iovec *payload, int payloadcount)
+rpcsvc_cache_reply(rpcsvc_request_t *req, struct iobref *iobref,
+                   struct iovec *rpchdr, int rpchdrcount, struct iovec *proghdr,
+                   int proghdrcount, struct iovec *payload, int payloadcount)
 {
-        int                       ret              = -1;
-        drc_cached_op_t          *reply            = NULL;
+    int ret = -1;
+    drc_cached_op_t *reply = NULL;
 
-        GF_ASSERT (req);
-        GF_ASSERT (req->reply);
+    GF_ASSERT(req);
+    GF_ASSERT(req->reply);
 
-        reply = req->reply;
+    reply = req->reply;
 
-        reply->state = DRC_OP_CACHED;
+    reply->state = DRC_OP_CACHED;
 
-        reply->msg.iobref = iobref_ref (iobref);
+    reply->msg.iobref = iobref_ref(iobref);
 
-        reply->msg.rpchdrcount = rpchdrcount;
-        reply->msg.rpchdr = iov_dup (rpchdr, rpchdrcount);
+    reply->msg.rpchdrcount = rpchdrcount;
+    reply->msg.rpchdr = iov_dup(rpchdr, rpchdrcount);
 
-        reply->msg.proghdrcount = proghdrcount;
-        reply->msg.proghdr = iov_dup (proghdr, proghdrcount);
+    reply->msg.proghdrcount = proghdrcount;
+    reply->msg.proghdr = iov_dup(proghdr, proghdrcount);
 
-        reply->msg.progpayloadcount = payloadcount;
-        if (payloadcount)
-                reply->msg.progpayload = iov_dup (payload, payloadcount);
+    reply->msg.progpayloadcount = payloadcount;
+    if (payloadcount)
+        reply->msg.progpayload = iov_dup(payload, payloadcount);
 
-        //        rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client);
-        //        rpcsvc_drc_op_unref (req->svc->drc, reply);
-        ret = 0;
+    //        rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client);
+    //        rpcsvc_drc_op_unref (req->svc->drc, reply);
+    ret = 0;
 
-        return ret;
+    return ret;
 }
 
 /**
@@ -405,73 +402,74 @@ rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref,
  * @return void
  */
 static void
-rpcsvc_vacate_drc_entries (rpcsvc_drc_globals_t *drc)
+rpcsvc_vacate_drc_entries(rpcsvc_drc_globals_t *drc)
 {
-        uint32_t            i           = 0;
-        uint32_t            n           = 0;
-        drc_cached_op_t    *reply       = NULL;
-        drc_cached_op_t    *tmp         = NULL;
-        drc_client_t       *client      = NULL;
+    uint32_t i = 0;
+    uint32_t n = 0;
+    drc_cached_op_t *reply = NULL;
+    drc_cached_op_t *tmp = NULL;
+    drc_client_t *client = NULL;
 
-        GF_ASSERT (drc);
+    GF_ASSERT(drc);
 
-        n = drc->global_cache_size / drc->lru_factor;
+    n = drc->global_cache_size / drc->lru_factor;
 
-        list_for_each_entry_safe_reverse (reply, tmp, &drc->cache_head, global_list) {
-                /* Don't delete ops that are in transit */
-                if (reply->state == DRC_OP_IN_TRANSIT)
-                        continue;
+    list_for_each_entry_safe_reverse(reply, tmp, &drc->cache_head, global_list)
+    {
+        /* Don't delete ops that are in transit */
+        if (reply->state == DRC_OP_IN_TRANSIT)
+            continue;
 
-                client = reply->client;
+        client = reply->client;
 
-                rb_delete (client->rbtree, reply);
+        rb_delete(client->rbtree, reply);
 
-                rpcsvc_drc_op_destroy (drc, reply);
-                rpcsvc_drc_client_unref (drc, client);
-                i++;
-                if (i >= n)
-                        break;
-        }
+        rpcsvc_drc_op_destroy(drc, reply);
+        rpcsvc_drc_client_unref(drc, client);
+        i++;
+        if (i >= n)
+            break;
+    }
 }
 
 /**
- * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc list
+ * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc
+ * list
  *
  * @param drc - the main drc structure
  * @param reply - the op to be inserted
  * @return 0 on success, -1 on failure
  */
 static int
-rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
+rpcsvc_add_op_to_cache(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
 {
-        drc_client_t        *client         = NULL;
-        drc_cached_op_t    **tmp_reply      = NULL;
+    drc_client_t *client = NULL;
+    drc_cached_op_t **tmp_reply = NULL;
 
-        GF_ASSERT (drc);
-        GF_ASSERT (reply);
+    GF_ASSERT(drc);
+    GF_ASSERT(reply);
 
-        client = reply->client;
+    client = reply->client;
 
-        /* cache is full, free up some space */
-        if (drc->op_count >= drc->global_cache_size)
-                rpcsvc_vacate_drc_entries (drc);
-
-        tmp_reply = (drc_cached_op_t **)rb_probe (client->rbtree, reply);
-        if (!tmp_reply) {
-                /* mem alloc failed */
-                return -1;
-        } else if (*tmp_reply != reply) {
-                /* should never happen */
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "DRC failed to detect duplicates");
-                return -1;
-        }
+    /* cache is full, free up some space */
+    if (drc->op_count >= drc->global_cache_size)
+        rpcsvc_vacate_drc_entries(drc);
 
-        client->op_count++;
-        list_add (&reply->global_list, &drc->cache_head);
-        drc->op_count++;
+    tmp_reply = (drc_cached_op_t **)rb_probe(client->rbtree, reply);
+    if (!tmp_reply) {
+        /* mem alloc failed */
+        return -1;
+    } else if (*tmp_reply != reply) {
+        /* should never happen */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "DRC failed to detect duplicates");
+        return -1;
+    }
 
-        return 0;
+    client->op_count++;
+    list_add(&reply->global_list, &drc->cache_head);
+    drc->op_count++;
+
+    return 0;
 }
 
 /**
@@ -481,46 +479,46 @@ rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_cache_request (rpcsvc_request_t *req)
+rpcsvc_cache_request(rpcsvc_request_t *req)
 {
-        int                        ret            = -1;
-        drc_client_t              *client         = NULL;
-        drc_cached_op_t           *reply          = NULL;
-        rpcsvc_drc_globals_t      *drc            = NULL;
-
-        GF_ASSERT (req);
-
-        drc = req->svc->drc;
-
-        client = req->trans->drc_client;
-        if (!client) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL");
-                goto out;
-        }
-
-        reply = mem_get0 (drc->mempool);
-        if (!reply)
-                goto out;
-
-        reply->client = rpcsvc_drc_client_ref (client);
-        reply->xid = req->xid;
-        reply->prognum = req->prognum;
-        reply->progversion = req->progver;
-        reply->procnum = req->procnum;
-        reply->state = DRC_OP_IN_TRANSIT;
-        req->reply = reply;
-        INIT_LIST_HEAD (&reply->global_list);
-
-        ret = rpcsvc_add_op_to_cache (drc, reply);
-        if (ret) {
-                req->reply = NULL;
-                rpcsvc_drc_op_destroy (drc, reply);
-                rpcsvc_drc_client_unref (drc, client);
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache");
-        }
-
- out:
-        return ret;
+    int ret = -1;
+    drc_client_t *client = NULL;
+    drc_cached_op_t *reply = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(req);
+
+    drc = req->svc->drc;
+
+    client = req->trans->drc_client;
+    if (!client) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL");
+        goto out;
+    }
+
+    reply = mem_get0(drc->mempool);
+    if (!reply)
+        goto out;
+
+    reply->client = rpcsvc_drc_client_ref(client);
+    reply->xid = req->xid;
+    reply->prognum = req->prognum;
+    reply->progversion = req->progver;
+    reply->procnum = req->procnum;
+    reply->state = DRC_OP_IN_TRANSIT;
+    req->reply = reply;
+    INIT_LIST_HEAD(&reply->global_list);
+
+    ret = rpcsvc_add_op_to_cache(drc, reply);
+    if (ret) {
+        req->reply = NULL;
+        rpcsvc_drc_op_destroy(drc, reply);
+        rpcsvc_drc_client_unref(drc, client);
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache");
+    }
+
+out:
+    return ret;
 }
 
 /**
@@ -531,72 +529,76 @@ rpcsvc_cache_request (rpcsvc_request_t *req)
  * @return 0 on success, -1 on failure
  */
 int32_t
-rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc)
+rpcsvc_drc_priv(rpcsvc_drc_globals_t *drc)
 {
-        int                      i                         = 0;
-        char                     key[GF_DUMP_MAX_BUF_LEN]  = {0};
-        drc_client_t            *client                    = NULL;
-        char                     ip[INET6_ADDRSTRLEN]      = {0};
-
-        if (!drc || drc->status == DRC_UNINITIATED) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "DRC is "
-                        "uninitialized, not dumping its state");
-                return 0;
+    int i = 0;
+    char key[GF_DUMP_MAX_BUF_LEN] = {0};
+    drc_client_t *client = NULL;
+    char ip[INET6_ADDRSTRLEN] = {0};
+
+    if (!drc || drc->status == DRC_UNINITIATED) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "DRC is "
+               "uninitialized, not dumping its state");
+        return 0;
+    }
+
+    gf_proc_dump_add_section("rpc.drc");
+
+    if (TRY_LOCK(&drc->lock))
+        return -1;
+
+    gf_proc_dump_build_key(key, "drc", "type");
+    gf_proc_dump_write(key, "%d", drc->type);
+
+    gf_proc_dump_build_key(key, "drc", "client_count");
+    gf_proc_dump_write(key, "%d", drc->client_count);
+
+    gf_proc_dump_build_key(key, "drc", "current_cache_size");
+    gf_proc_dump_write(key, "%d", drc->op_count);
+
+    gf_proc_dump_build_key(key, "drc", "max_cache_size");
+    gf_proc_dump_write(key, "%d", drc->global_cache_size);
+
+    gf_proc_dump_build_key(key, "drc", "lru_factor");
+    gf_proc_dump_write(key, "%d", drc->lru_factor);
+
+    gf_proc_dump_build_key(key, "drc", "duplicate_request_count");
+    gf_proc_dump_write(key, "%d", drc->cache_hits);
+
+    gf_proc_dump_build_key(key, "drc", "in_transit_duplicate_requests");
+    gf_proc_dump_write(key, "%d", drc->intransit_hits);
+
+    list_for_each_entry(client, &drc->clients_head, client_list)
+    {
+        gf_proc_dump_build_key(key, "client", "%d.ip-address", i);
+        memset(ip, 0, INET6_ADDRSTRLEN);
+        switch (client->sock_union.storage.ss_family) {
+            case AF_INET:
+                gf_proc_dump_write(
+                    key, "%s",
+                    inet_ntop(AF_INET, &client->sock_union.sin.sin_addr.s_addr,
+                              ip, INET_ADDRSTRLEN));
+                break;
+            case AF_INET6:
+                gf_proc_dump_write(
+                    key, "%s",
+                    inet_ntop(AF_INET6, &client->sock_union.sin6.sin6_addr, ip,
+                              INET6_ADDRSTRLEN));
+                break;
+            default:
+                gf_proc_dump_write(key, "%s", "N/A");
         }
 
-        gf_proc_dump_add_section("rpc.drc");
-
-        if (TRY_LOCK (&drc->lock))
-                return -1;
-
-        gf_proc_dump_build_key (key, "drc", "type");
-        gf_proc_dump_write (key, "%d", drc->type);
-
-        gf_proc_dump_build_key (key, "drc", "client_count");
-        gf_proc_dump_write (key, "%d", drc->client_count);
-
-        gf_proc_dump_build_key (key, "drc", "current_cache_size");
-        gf_proc_dump_write (key, "%d", drc->op_count);
-
-        gf_proc_dump_build_key (key, "drc", "max_cache_size");
-        gf_proc_dump_write (key, "%d", drc->global_cache_size);
-
-        gf_proc_dump_build_key (key, "drc", "lru_factor");
-        gf_proc_dump_write (key, "%d", drc->lru_factor);
-
-        gf_proc_dump_build_key (key, "drc", "duplicate_request_count");
-        gf_proc_dump_write (key, "%d", drc->cache_hits);
-
-        gf_proc_dump_build_key (key, "drc", "in_transit_duplicate_requests");
-        gf_proc_dump_write (key, "%d", drc->intransit_hits);
-
-        list_for_each_entry (client, &drc->clients_head, client_list) {
-                gf_proc_dump_build_key (key, "client", "%d.ip-address", i);
-                memset (ip, 0, INET6_ADDRSTRLEN);
-                switch (client->sock_union.storage.ss_family) {
-                case AF_INET:
-                        gf_proc_dump_write (key, "%s", inet_ntop (AF_INET,
-                                &client->sock_union.sin.sin_addr.s_addr,
-                                ip, INET_ADDRSTRLEN));
-                        break;
-                case AF_INET6:
-                        gf_proc_dump_write (key, "%s", inet_ntop (AF_INET6,
-                                &client->sock_union.sin6.sin6_addr,
-                                ip, INET6_ADDRSTRLEN));
-                        break;
-                default:
-                        gf_proc_dump_write (key, "%s", "N/A");
-                }
-
-                gf_proc_dump_build_key (key, "client", "%d.ref_count", i);
-                gf_proc_dump_write (key, "%d", client->ref);
-                gf_proc_dump_build_key (key, "client", "%d.op_count", i);
-                gf_proc_dump_write (key, "%d", client->op_count);
-                i++;
-        }
+        gf_proc_dump_build_key(key, "client", "%d.ref_count", i);
+        gf_proc_dump_write(key, "%d", client->ref);
+        gf_proc_dump_build_key(key, "client", "%d.op_count", i);
+        gf_proc_dump_write(key, "%d", client->op_count);
+        i++;
+    }
 
-        UNLOCK (&drc->lock);
-        return 0;
+    UNLOCK(&drc->lock);
+    return 0;
 }
 
 /**
@@ -609,53 +611,51 @@ rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc)
  * @return 0 on success, -1 on failure
  */
 int
-rpcsvc_drc_notify (rpcsvc_t *svc, void *xl,
-                   rpcsvc_event_t event, void *data)
+rpcsvc_drc_notify(rpcsvc_t *svc, void *xl, rpcsvc_event_t event, void *data)
 {
-        int                       ret          = -1;
-        rpc_transport_t          *trans        = NULL;
-        drc_client_t             *client       = NULL;
-        rpcsvc_drc_globals_t     *drc          = NULL;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (svc->drc);
-        GF_ASSERT (data);
-
-        drc = svc->drc;
-
-        if (drc->status == DRC_UNINITIATED ||
-            drc->type == DRC_TYPE_NONE)
-                return 0;
-
-        LOCK (&drc->lock);
-        {
-                trans = (rpc_transport_t *)data;
-                client = rpcsvc_get_drc_client (drc, &trans->peerinfo.sockaddr);
-                if (!client)
-                        goto unlock;
-
-                switch (event) {
-                case RPCSVC_EVENT_ACCEPT:
-                        trans->drc_client = rpcsvc_drc_client_ref (client);
-                        ret = 0;
-                        break;
-
-                case RPCSVC_EVENT_DISCONNECT:
-                        ret = 0;
-                        if (list_empty (&drc->clients_head))
-                                break;
-                        /* should be the last unref */
-                        trans->drc_client = NULL;
-                        rpcsvc_drc_client_unref (drc, client);
-                        break;
-
-                default:
-                        break;
-                }
+    int ret = -1;
+    rpc_transport_t *trans = NULL;
+    drc_client_t *client = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(svc->drc);
+    GF_ASSERT(data);
+
+    drc = svc->drc;
+
+    if (drc->status == DRC_UNINITIATED || drc->type == DRC_TYPE_NONE)
+        return 0;
+
+    LOCK(&drc->lock);
+    {
+        trans = (rpc_transport_t *)data;
+        client = rpcsvc_get_drc_client(drc, &trans->peerinfo.sockaddr);
+        if (!client)
+            goto unlock;
+
+        switch (event) {
+            case RPCSVC_EVENT_ACCEPT:
+                trans->drc_client = rpcsvc_drc_client_ref(client);
+                ret = 0;
+                break;
+
+            case RPCSVC_EVENT_DISCONNECT:
+                ret = 0;
+                if (list_empty(&drc->clients_head))
+                    break;
+                /* should be the last unref */
+                trans->drc_client = NULL;
+                rpcsvc_drc_client_unref(drc, client);
+                break;
+
+            default:
+                break;
         }
+    }
 unlock:
-        UNLOCK (&drc->lock);
-        return ret;
+    UNLOCK(&drc->lock);
+    return ret;
 }
 
 /**
@@ -666,191 +666,195 @@ unlock:
  * @return 0 on success, non-zero integer on failure
  */
 int
-rpcsvc_drc_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_drc_init(rpcsvc_t *svc, dict_t *options)
 {
-        int                         ret            = 0;
-        uint32_t                    drc_type       = 0;
-        uint32_t                    drc_size       = 0;
-        uint32_t                    drc_factor     = 0;
-        rpcsvc_drc_globals_t       *drc            = NULL;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
-
-        /* Toggle DRC on/off, when more drc types(persistent/cluster)
-         * are added, we shouldn't treat this as boolean. */
-        ret = dict_get_str_boolean (options, "nfs.drc", _gf_false);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                        "drc user options need second look");
-                ret = _gf_false;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF"));
-
-        /*DRC off, nothing to do */
-        if (ret == _gf_false)
-                return (0);
-
-        drc = GF_CALLOC (1, sizeof (rpcsvc_drc_globals_t),
-                         gf_common_mt_drc_globals_t);
-        if (!drc)
-                return (-1);
-
-        LOCK_INIT (&drc->lock);
-        svc->drc = drc;
-
-        LOCK (&drc->lock);
-
-        /* Specify type of DRC to be used */
-        ret = dict_get_uint32 (options, "nfs.drc-type", &drc_type);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc type not set."
-                        " Continuing with default");
-                drc_type = DRC_DEFAULT_TYPE;
-        }
-
-        drc->type = drc_type;
-
-        /* Set the global cache size (no. of ops to cache) */
-        ret = dict_get_uint32 (options, "nfs.drc-size", &drc_size);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc size not set."
-                        " Continuing with default size");
-                drc_size = DRC_DEFAULT_CACHE_SIZE;
-        }
-
-        drc->global_cache_size = drc_size;
-
-        /* Mempool for cached ops */
-        drc->mempool = mem_pool_new (drc_cached_op_t, drc->global_cache_size);
-        if (!drc->mempool) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to get mempool for"
-                        " DRC, drc-size: %d", drc->global_cache_size);
-                ret = -1;
-                goto out;
-        }
-
-        /* What percent of cache to be evicted whenever it fills up */
-        ret = dict_get_uint32 (options, "nfs.drc-lru-factor", &drc_factor);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc lru factor not set."
-                        " Continuing with policy default");
-                drc_factor = DRC_DEFAULT_LRU_FACTOR;
-        }
-
-        drc->lru_factor = (drc_lru_factor_t) drc_factor;
-
-        INIT_LIST_HEAD (&drc->clients_head);
-        INIT_LIST_HEAD (&drc->cache_head);
-
-        ret = rpcsvc_register_notify (svc, rpcsvc_drc_notify, THIS);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "registration of drc_notify function failed");
-                goto out;
-        }
+    int ret = 0;
+    uint32_t drc_type = 0;
+    uint32_t drc_size = 0;
+    uint32_t drc_factor = 0;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
+
+    /* Toggle DRC on/off, when more drc types(persistent/cluster)
+     * are added, we shouldn't treat this as boolean. */
+    ret = dict_get_str_boolean(options, "nfs.drc", _gf_false);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_INFO, "drc user options need second look");
+        ret = _gf_false;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF"));
+
+    /*DRC off, nothing to do */
+    if (ret == _gf_false)
+        return (0);
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc init successful");
-        drc->status = DRC_INITIATED;
- out:
-        UNLOCK (&drc->lock);
-        if (ret == -1) {
-                if (drc->mempool) {
-                        mem_pool_destroy (drc->mempool);
-                        drc->mempool = NULL;
-                }
-                GF_FREE (drc);
-                svc->drc = NULL;
+    drc = GF_CALLOC(1, sizeof(rpcsvc_drc_globals_t),
+                    gf_common_mt_drc_globals_t);
+    if (!drc)
+        return (-1);
+
+    LOCK_INIT(&drc->lock);
+    svc->drc = drc;
+
+    LOCK(&drc->lock);
+
+    /* Specify type of DRC to be used */
+    ret = dict_get_uint32(options, "nfs.drc-type", &drc_type);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc type not set."
+               " Continuing with default");
+        drc_type = DRC_DEFAULT_TYPE;
+    }
+
+    drc->type = drc_type;
+
+    /* Set the global cache size (no. of ops to cache) */
+    ret = dict_get_uint32(options, "nfs.drc-size", &drc_size);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc size not set."
+               " Continuing with default size");
+        drc_size = DRC_DEFAULT_CACHE_SIZE;
+    }
+
+    drc->global_cache_size = drc_size;
+
+    /* Mempool for cached ops */
+    drc->mempool = mem_pool_new(drc_cached_op_t, drc->global_cache_size);
+    if (!drc->mempool) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to get mempool for"
+               " DRC, drc-size: %d",
+               drc->global_cache_size);
+        ret = -1;
+        goto out;
+    }
+
+    /* What percent of cache to be evicted whenever it fills up */
+    ret = dict_get_uint32(options, "nfs.drc-lru-factor", &drc_factor);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "drc lru factor not set."
+               " Continuing with policy default");
+        drc_factor = DRC_DEFAULT_LRU_FACTOR;
+    }
+
+    drc->lru_factor = (drc_lru_factor_t)drc_factor;
+
+    INIT_LIST_HEAD(&drc->clients_head);
+    INIT_LIST_HEAD(&drc->cache_head);
+
+    ret = rpcsvc_register_notify(svc, rpcsvc_drc_notify, THIS);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "registration of drc_notify function failed");
+        goto out;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc init successful");
+    drc->status = DRC_INITIATED;
+out:
+    UNLOCK(&drc->lock);
+    if (ret == -1) {
+        if (drc->mempool) {
+            mem_pool_destroy(drc->mempool);
+            drc->mempool = NULL;
         }
-        return ret;
+        GF_FREE(drc);
+        svc->drc = NULL;
+    }
+    return ret;
 }
 
 int
-rpcsvc_drc_deinit (rpcsvc_t *svc)
+rpcsvc_drc_deinit(rpcsvc_t *svc)
 {
-        rpcsvc_drc_globals_t *drc  = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
 
-        if (!svc)
-                return (-1);
+    if (!svc)
+        return (-1);
 
-        drc = svc->drc;
-        if (!drc)
-                return (0);
+    drc = svc->drc;
+    if (!drc)
+        return (0);
 
-        LOCK (&drc->lock);
-        (void) rpcsvc_unregister_notify (svc, rpcsvc_drc_notify, THIS);
-        if (drc->mempool) {
-                mem_pool_destroy (drc->mempool);
-                drc->mempool = NULL;
-        }
-        UNLOCK (&drc->lock);
+    LOCK(&drc->lock);
+    (void)rpcsvc_unregister_notify(svc, rpcsvc_drc_notify, THIS);
+    if (drc->mempool) {
+        mem_pool_destroy(drc->mempool);
+        drc->mempool = NULL;
+    }
+    UNLOCK(&drc->lock);
 
-        GF_FREE (drc);
-        svc->drc = NULL;
+    GF_FREE(drc);
+    svc->drc = NULL;
 
-        return (0);
+    return (0);
 }
 
 int
-rpcsvc_drc_reconfigure (rpcsvc_t *svc, dict_t *options)
+rpcsvc_drc_reconfigure(rpcsvc_t *svc, dict_t *options)
 {
-        int                     ret        = -1;
-        gf_boolean_t            enable_drc = _gf_false;
-        rpcsvc_drc_globals_t    *drc       = NULL;
-        uint32_t                drc_size   = 0;
-
-        /* Input sanitization */
-        if ((!svc) || (!options))
-                return (-1);
-
-        /* If DRC was not enabled before, Let rpcsvc_drc_init() to
-         * take care of DRC initialization part.
-         */
-        drc = svc->drc;
-        if (!drc) {
-                return rpcsvc_drc_init(svc, options);
-        }
-
-        /* DRC was already enabled before. Going to be reconfigured. Check
-         * if reconfigured options contain "nfs.drc" and "nfs.drc-size".
-         *
-         * NB: If DRC is "OFF", "drc-size" has no role to play.
-         *     So, "drc-size" gets evaluated IFF DRC is "ON".
-         *
-         * If DRC is reconfigured,
-         *     case 1: DRC is "ON"
-         *         sub-case 1: drc-size remains same
-         *              ACTION: Nothing to do.
-         *         sub-case 2: drc-size just changed
-         *              ACTION: rpcsvc_drc_deinit() followed by
-         *                      rpcsvc_drc_init().
-         *
-         *     case 2: DRC is "OFF"
-         *         ACTION: rpcsvc_drc_deinit()
-         */
-        ret = dict_get_str_boolean (options, "nfs.drc", _gf_false);
-        if (ret < 0)
-                ret = _gf_false;
-
-        enable_drc = ret;
-        gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF"));
-
-        /* case 1: DRC is "ON"*/
-        if (enable_drc) {
-                /* Fetch drc-size if reconfigured */
-                if (dict_get_uint32 (options, "nfs.drc-size", &drc_size))
-                        drc_size = DRC_DEFAULT_CACHE_SIZE;
-
-                /* case 1: sub-case 1*/
-                if (drc->global_cache_size == drc_size)
-                        return (0);
-
-                /* case 1: sub-case 2*/
-                (void) rpcsvc_drc_deinit (svc);
-                return rpcsvc_drc_init (svc, options);
-        }
-
-        /* case 2: DRC is "OFF" */
-        return rpcsvc_drc_deinit (svc);
+    int ret = -1;
+    gf_boolean_t enable_drc = _gf_false;
+    rpcsvc_drc_globals_t *drc = NULL;
+    uint32_t drc_size = 0;
+
+    /* Input sanitization */
+    if ((!svc) || (!options))
+        return (-1);
+
+    /* If DRC was not enabled before, Let rpcsvc_drc_init() to
+     * take care of DRC initialization part.
+     */
+    drc = svc->drc;
+    if (!drc) {
+        return rpcsvc_drc_init(svc, options);
+    }
+
+    /* DRC was already enabled before. Going to be reconfigured. Check
+     * if reconfigured options contain "nfs.drc" and "nfs.drc-size".
+     *
+     * NB: If DRC is "OFF", "drc-size" has no role to play.
+     *     So, "drc-size" gets evaluated IFF DRC is "ON".
+     *
+     * If DRC is reconfigured,
+     *     case 1: DRC is "ON"
+     *         sub-case 1: drc-size remains same
+     *              ACTION: Nothing to do.
+     *         sub-case 2: drc-size just changed
+     *              ACTION: rpcsvc_drc_deinit() followed by
+     *                      rpcsvc_drc_init().
+     *
+     *     case 2: DRC is "OFF"
+     *         ACTION: rpcsvc_drc_deinit()
+     */
+    ret = dict_get_str_boolean(options, "nfs.drc", _gf_false);
+    if (ret < 0)
+        ret = _gf_false;
+
+    enable_drc = ret;
+    gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF"));
+
+    /* case 1: DRC is "ON"*/
+    if (enable_drc) {
+        /* Fetch drc-size if reconfigured */
+        if (dict_get_uint32(options, "nfs.drc-size", &drc_size))
+            drc_size = DRC_DEFAULT_CACHE_SIZE;
+
+        /* case 1: sub-case 1*/
+        if (drc->global_cache_size == drc_size)
+            return (0);
+
+        /* case 1: sub-case 2*/
+        (void)rpcsvc_drc_deinit(svc);
+        return rpcsvc_drc_init(svc, options);
+    }
+
+    /* case 2: DRC is "OFF" */
+    return rpcsvc_drc_deinit(svc);
 }
diff --git a/rpc/rpc-lib/src/rpc-transport.c b/rpc/rpc-lib/src/rpc-transport.c
index 062d7905fe0..d70334476c7 100644
--- a/rpc/rpc-lib/src/rpc-transport.c
+++ b/rpc/rpc-lib/src/rpc-transport.c
@@ -29,696 +29,668 @@
 #endif
 
 int32_t
-rpc_transport_count (const char *transport_type)
+rpc_transport_count(const char *transport_type)
 {
-        char     *transport_dup   = NULL;
-        char     *saveptr         = NULL;
-        char     *ptr             = NULL;
-        int       count           = 0;
-
-        if (transport_type == NULL)
-                return -1;
-
-        transport_dup = gf_strdup (transport_type);
-        if (transport_dup == NULL) {
-                return -1;
-        }
-
-        ptr = strtok_r (transport_dup, ",", &saveptr);
-        while (ptr != NULL) {
-                count++;
-                ptr = strtok_r (NULL, ",", &saveptr);
-        }
-
-        GF_FREE (transport_dup);
-        return count;
+    char *transport_dup = NULL;
+    char *saveptr = NULL;
+    char *ptr = NULL;
+    int count = 0;
+
+    if (transport_type == NULL)
+        return -1;
+
+    transport_dup = gf_strdup(transport_type);
+    if (transport_dup == NULL) {
+        return -1;
+    }
+
+    ptr = strtok_r(transport_dup, ",", &saveptr);
+    while (ptr != NULL) {
+        count++;
+        ptr = strtok_r(NULL, ",", &saveptr);
+    }
+
+    GF_FREE(transport_dup);
+    return count;
 }
 
 int
-rpc_transport_get_myaddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                          struct sockaddr_storage *sa, size_t salen)
+rpc_transport_get_myaddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                         struct sockaddr_storage *sa, size_t salen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_myaddr (this, peeraddr, addrlen, sa, salen);
+    ret = this->ops->get_myaddr(this, peeraddr, addrlen, sa, salen);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-rpc_transport_get_myname (rpc_transport_t *this, char *hostname, int hostlen)
+rpc_transport_get_myname(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_myname (this, hostname, hostlen);
+    ret = this->ops->get_myname(this, hostname, hostlen);
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-rpc_transport_get_peername (rpc_transport_t *this, char *hostname, int hostlen)
+rpc_transport_get_peername(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_peername (this, hostname, hostlen);
+    ret = this->ops->get_peername(this, hostname, hostlen);
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_transport_throttle (rpc_transport_t *this, gf_boolean_t onoff)
+rpc_transport_throttle(rpc_transport_t *this, gf_boolean_t onoff)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (!this->ops->throttle)
-                return -ENOSYS;
+    if (!this->ops->throttle)
+        return -ENOSYS;
 
-        ret = this->ops->throttle (this, onoff);
+    ret = this->ops->throttle(this, onoff);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-rpc_transport_get_peeraddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                            struct sockaddr_storage *sa, size_t salen)
+rpc_transport_get_peeraddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                           struct sockaddr_storage *sa, size_t salen)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        ret = this->ops->get_peeraddr (this, peeraddr, addrlen, sa, salen);
+    ret = this->ops->get_peeraddr(this, peeraddr, addrlen, sa, salen);
 out:
-        return ret;
+    return ret;
 }
 
 void
-rpc_transport_pollin_destroy (rpc_transport_pollin_t *pollin)
+rpc_transport_pollin_destroy(rpc_transport_pollin_t *pollin)
 {
-        GF_VALIDATE_OR_GOTO ("rpc", pollin, out);
+    GF_VALIDATE_OR_GOTO("rpc", pollin, out);
 
-        if (pollin->iobref) {
-                iobref_unref (pollin->iobref);
-        }
+    if (pollin->iobref) {
+        iobref_unref(pollin->iobref);
+    }
 
-        if (pollin->private) {
-                /* */
-                GF_FREE (pollin->private);
-        }
+    if (pollin->private) {
+        /* */
+        GF_FREE(pollin->private);
+    }
 
-        GF_FREE (pollin);
+    GF_FREE(pollin);
 out:
-        return;
+    return;
 }
 
-
 rpc_transport_pollin_t *
-rpc_transport_pollin_alloc (rpc_transport_t *this, struct iovec *vector,
-                            int count, struct iobuf *hdr_iobuf,
-                            struct iobref *iobref, void *private)
+rpc_transport_pollin_alloc(rpc_transport_t *this, struct iovec *vector,
+                           int count, struct iobuf *hdr_iobuf,
+                           struct iobref *iobref, void *private)
 {
-        rpc_transport_pollin_t *msg = NULL;
-        msg = GF_CALLOC (1, sizeof (*msg), gf_common_mt_rpc_trans_pollin_t);
-        if (!msg) {
-                goto out;
-        }
-
-        if (count > 1) {
-                msg->vectored = 1;
-        }
-
-        memcpy (msg->vector, vector, count * sizeof (*vector));
-        msg->count = count;
-        msg->iobref = iobref_ref (iobref);
-        msg->private = private;
-        if (hdr_iobuf)
-                iobref_add (iobref, hdr_iobuf);
+    rpc_transport_pollin_t *msg = NULL;
+    msg = GF_CALLOC(1, sizeof(*msg), gf_common_mt_rpc_trans_pollin_t);
+    if (!msg) {
+        goto out;
+    }
+
+    if (count > 1) {
+        msg->vectored = 1;
+    }
+
+    memcpy(msg->vector, vector, count * sizeof(*vector));
+    msg->count = count;
+    msg->iobref = iobref_ref(iobref);
+    msg->private = private;
+    if (hdr_iobuf)
+        iobref_add(iobref, hdr_iobuf);
 
 out:
-        return msg;
+    return msg;
 }
 
-
-
 rpc_transport_t *
-rpc_transport_load (glusterfs_ctx_t *ctx, dict_t *options, char *trans_name)
+rpc_transport_load(glusterfs_ctx_t *ctx, dict_t *options, char *trans_name)
 {
-	struct rpc_transport *trans = NULL, *return_trans = NULL;
-	char *name = NULL;
-	void *handle = NULL;
-	char *type = NULL;
-	char str[] = "ERROR";
-	int32_t ret = -1;
-	int is_tcp = 0, is_unix = 0, is_ibsdp = 0;
-	volume_opt_list_t *vol_opt = NULL;
-        gf_boolean_t bind_insecure = _gf_false;
-        xlator_t   *this = NULL;
-        gf_boolean_t    success = _gf_false;
-
-	GF_VALIDATE_OR_GOTO("rpc-transport", options, fail);
-	GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail);
-	GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail);
-
-	trans = GF_CALLOC (1, sizeof (struct rpc_transport), gf_common_mt_rpc_trans_t);
-        if (!trans)
-                goto fail;
-
-        trans->name = gf_strdup (trans_name);
-        if (!trans->name)
-                goto fail;
-
-	trans->ctx = ctx;
-	type = str;
-
-	/* Backward compatibility */
-        ret = dict_get_str (options, "transport-type", &type);
-	if (ret < 0) {
-		ret = dict_set_str (options, "transport-type", "socket");
-		if (ret < 0)
-			gf_log ("dict", GF_LOG_DEBUG,
-				"setting transport-type failed");
-                else
-                        gf_log ("rpc-transport", GF_LOG_DEBUG,
-                                "missing 'option transport-type'. defaulting to "
-                                "\"socket\"");
-	} else {
-		{
-			/* Backward compatibility to handle * /client,
-			 * * /server.
-			 */
-			char *tmp = strchr (type, '/');
-			if (tmp)
-				*tmp = '\0';
-		}
-
-		is_tcp = strcmp (type, "tcp");
-		is_unix = strcmp (type, "unix");
-		is_ibsdp = strcmp (type, "ib-sdp");
-		if ((is_tcp == 0) ||
-		    (is_unix == 0) ||
-		    (is_ibsdp == 0)) {
-			if (is_unix == 0)
-				ret = dict_set_str (options,
-						    "transport.address-family",
-						    "unix");
-			if (is_ibsdp == 0)
-				ret = dict_set_str (options,
-						    "transport.address-family",
-						    "inet-sdp");
-
-			if (ret < 0)
-				gf_log ("dict", GF_LOG_DEBUG,
-					"setting address-family failed");
-
-			ret = dict_set_str (options,
-					    "transport-type", "socket");
-			if (ret < 0)
-				gf_log ("dict", GF_LOG_DEBUG,
-					"setting transport-type failed");
-		}
-	}
-
-        /* client-bind-insecure is for clients protocol, and
-         * bind-insecure for glusterd. Both mutually exclusive
-        */
-        ret = dict_get_str (options, "client-bind-insecure", &type);
-        if (ret)
-                ret = dict_get_str (options, "bind-insecure", &type);
-        if (ret == 0) {
-                ret = gf_string2boolean (type, &bind_insecure);
-                if (ret < 0) {
-                        gf_log ("rcp-transport", GF_LOG_WARNING,
-                                "bind-insecure option %s is not a"
-                                " valid bool option", type);
-                        goto fail;
-                }
-                if (_gf_true == bind_insecure)
-                        trans->bind_insecure = 1;
-                else
-                        trans->bind_insecure = 0;
-        } else {
-                /* By default allow bind insecure */
-                trans->bind_insecure = 1;
+    struct rpc_transport *trans = NULL, *return_trans = NULL;
+    char *name = NULL;
+    void *handle = NULL;
+    char *type = NULL;
+    char str[] = "ERROR";
+    int32_t ret = -1;
+    int is_tcp = 0, is_unix = 0, is_ibsdp = 0;
+    volume_opt_list_t *vol_opt = NULL;
+    gf_boolean_t bind_insecure = _gf_false;
+    xlator_t *this = NULL;
+    gf_boolean_t success = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("rpc-transport", options, fail);
+    GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail);
+    GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail);
+
+    trans = GF_CALLOC(1, sizeof(struct rpc_transport),
+                      gf_common_mt_rpc_trans_t);
+    if (!trans)
+        goto fail;
+
+    trans->name = gf_strdup(trans_name);
+    if (!trans->name)
+        goto fail;
+
+    trans->ctx = ctx;
+    type = str;
+
+    /* Backward compatibility */
+    ret = dict_get_str(options, "transport-type", &type);
+    if (ret < 0) {
+        ret = dict_set_str(options, "transport-type", "socket");
+        if (ret < 0)
+            gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed");
+        else
+            gf_log("rpc-transport", GF_LOG_DEBUG,
+                   "missing 'option transport-type'. defaulting to "
+                   "\"socket\"");
+    } else {
+        {
+            /* Backward compatibility to handle * /client,
+             * * /server.
+             */
+            char *tmp = strchr(type, '/');
+            if (tmp)
+                *tmp = '\0';
         }
 
-	ret = dict_get_str (options, "transport-type", &type);
-	if (ret < 0) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"'option transport-type <xx>' missing in volume '%s'",
-			trans_name);
-		goto fail;
-	}
-
-	ret = gf_asprintf (&name, "%s/%s.so", RPC_TRANSPORTDIR, type);
-        if (-1 == ret) {
-                goto fail;
+        is_tcp = strcmp(type, "tcp");
+        is_unix = strcmp(type, "unix");
+        is_ibsdp = strcmp(type, "ib-sdp");
+        if ((is_tcp == 0) || (is_unix == 0) || (is_ibsdp == 0)) {
+            if (is_unix == 0)
+                ret = dict_set_str(options, "transport.address-family", "unix");
+            if (is_ibsdp == 0)
+                ret = dict_set_str(options, "transport.address-family",
+                                   "inet-sdp");
+
+            if (ret < 0)
+                gf_log("dict", GF_LOG_DEBUG, "setting address-family failed");
+
+            ret = dict_set_str(options, "transport-type", "socket");
+            if (ret < 0)
+                gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed");
         }
-
-	gf_log ("rpc-transport", GF_LOG_DEBUG,
-		"attempt to load file %s", name);
-
-        handle = dlopen (name, RTLD_NOW);
-	if (handle == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR, "%s", dlerror ());
-		gf_log ("rpc-transport", GF_LOG_WARNING,
-			"volume '%s': transport-type '%s' is not valid or "
-			"not found on this machine",
-			trans_name, type);
-		goto fail;
-	}
-
-        trans->dl_handle = handle;
-
-	trans->ops = dlsym (handle, "tops");
-	if (trans->ops == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (rpc_transport_ops) on %s", dlerror ());
-		goto fail;
-	}
-
-	*VOID(&(trans->init)) = dlsym (handle, "init");
-	if (trans->init == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (gf_rpc_transport_init) on %s", dlerror ());
-		goto fail;
-	}
-
-	*VOID(&(trans->fini)) = dlsym (handle, "fini");
-	if (trans->fini == NULL) {
-		gf_log ("rpc-transport", GF_LOG_ERROR,
-			"dlsym (gf_rpc_transport_fini) on %s", dlerror ());
-		goto fail;
-	}
-
-        *VOID(&(trans->reconfigure)) = dlsym (handle, "reconfigure");
-        if (trans->reconfigure == NULL) {
-                gf_log ("rpc-transport", GF_LOG_DEBUG,
-                        "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror());
+    }
+
+    /* client-bind-insecure is for clients protocol, and
+     * bind-insecure for glusterd. Both mutually exclusive
+     */
+    ret = dict_get_str(options, "client-bind-insecure", &type);
+    if (ret)
+        ret = dict_get_str(options, "bind-insecure", &type);
+    if (ret == 0) {
+        ret = gf_string2boolean(type, &bind_insecure);
+        if (ret < 0) {
+            gf_log("rcp-transport", GF_LOG_WARNING,
+                   "bind-insecure option %s is not a"
+                   " valid bool option",
+                   type);
+            goto fail;
         }
-
-	vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
-                             gf_common_mt_volume_opt_list_t);
-        if (!vol_opt) {
-                goto fail;
+        if (_gf_true == bind_insecure)
+            trans->bind_insecure = 1;
+        else
+            trans->bind_insecure = 0;
+    } else {
+        /* By default allow bind insecure */
+        trans->bind_insecure = 1;
+    }
+
+    ret = dict_get_str(options, "transport-type", &type);
+    if (ret < 0) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "'option transport-type <xx>' missing in volume '%s'",
+               trans_name);
+        goto fail;
+    }
+
+    ret = gf_asprintf(&name, "%s/%s.so", RPC_TRANSPORTDIR, type);
+    if (-1 == ret) {
+        goto fail;
+    }
+
+    gf_log("rpc-transport", GF_LOG_DEBUG, "attempt to load file %s", name);
+
+    handle = dlopen(name, RTLD_NOW);
+    if (handle == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR, "%s", dlerror());
+        gf_log("rpc-transport", GF_LOG_WARNING,
+               "volume '%s': transport-type '%s' is not valid or "
+               "not found on this machine",
+               trans_name, type);
+        goto fail;
+    }
+
+    trans->dl_handle = handle;
+
+    trans->ops = dlsym(handle, "tops");
+    if (trans->ops == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR, "dlsym (rpc_transport_ops) on %s",
+               dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->init)) = dlsym(handle, "init");
+    if (trans->init == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "dlsym (gf_rpc_transport_init) on %s", dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->fini)) = dlsym(handle, "fini");
+    if (trans->fini == NULL) {
+        gf_log("rpc-transport", GF_LOG_ERROR,
+               "dlsym (gf_rpc_transport_fini) on %s", dlerror());
+        goto fail;
+    }
+
+    *VOID(&(trans->reconfigure)) = dlsym(handle, "reconfigure");
+    if (trans->reconfigure == NULL) {
+        gf_log("rpc-transport", GF_LOG_DEBUG,
+               "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror());
+    }
+
+    vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+                        gf_common_mt_volume_opt_list_t);
+    if (!vol_opt) {
+        goto fail;
+    }
+
+    this = THIS;
+    vol_opt->given_opt = dlsym(handle, "options");
+    if (vol_opt->given_opt == NULL) {
+        gf_log("rpc-transport", GF_LOG_DEBUG,
+               "volume option validation not specified");
+    } else {
+        INIT_LIST_HEAD(&vol_opt->list);
+        list_add_tail(&vol_opt->list, &(this->volume_options));
+        if (xlator_options_validate_list(this, options, vol_opt, NULL)) {
+            gf_log("rpc-transport", GF_LOG_ERROR,
+                   "volume option validation failed");
+            goto fail;
         }
+    }
 
-        this = THIS;
-	vol_opt->given_opt = dlsym (handle, "options");
-	if (vol_opt->given_opt == NULL) {
-		gf_log ("rpc-transport", GF_LOG_DEBUG,
-			"volume option validation not specified");
-	} else {
-                INIT_LIST_HEAD (&vol_opt->list);
-		list_add_tail (&vol_opt->list, &(this->volume_options));
-                if (xlator_options_validate_list (this, options, vol_opt,
-                                                  NULL)) {
-			gf_log ("rpc-transport", GF_LOG_ERROR,
-				"volume option validation failed");
-			goto fail;
-		}
-	}
+    trans->options = options;
 
-        trans->options = options;
+    pthread_mutex_init(&trans->lock, NULL);
+    trans->xl = this;
 
-        pthread_mutex_init (&trans->lock, NULL);
-        trans->xl = this;
+    ret = trans->init(trans);
+    if (ret != 0) {
+        gf_log("rpc-transport", GF_LOG_WARNING, "'%s' initialization failed",
+               type);
+        goto fail;
+    }
 
-	ret = trans->init (trans);
-	if (ret != 0) {
-		gf_log ("rpc-transport", GF_LOG_WARNING,
-			"'%s' initialization failed", type);
-		goto fail;
-	}
+    INIT_LIST_HEAD(&trans->list);
 
-        INIT_LIST_HEAD (&trans->list);
+    return_trans = trans;
 
-        return_trans = trans;
+    GF_FREE(name);
 
-        GF_FREE (name);
-
-	success = _gf_true;
+    success = _gf_true;
 
 fail:
-        if (!success) {
-                if (trans) {
-                        GF_FREE (trans->name);
+    if (!success) {
+        if (trans) {
+            GF_FREE(trans->name);
 
-                        if (trans->dl_handle)
-                                dlclose (trans->dl_handle);
+            if (trans->dl_handle)
+                dlclose(trans->dl_handle);
 
-                        GF_FREE (trans);
-                }
+            GF_FREE(trans);
+        }
 
-                GF_FREE (name);
+        GF_FREE(name);
 
-                return_trans = NULL;
-        }
+        return_trans = NULL;
+    }
 
-        if (vol_opt) {
-                if (!list_empty (&vol_opt->list)) {
-                        list_del_init (&vol_opt->list);
-                }
-                GF_FREE (vol_opt);
+    if (vol_opt) {
+        if (!list_empty(&vol_opt->list)) {
+            list_del_init(&vol_opt->list);
         }
+        GF_FREE(vol_opt);
+    }
 
-        return return_trans;
+    return return_trans;
 }
 
-
 int32_t
-rpc_transport_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
+rpc_transport_submit_request(rpc_transport_t *this, rpc_transport_req_t *req)
 {
-	int32_t                       ret          = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
-	GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
 
-	ret = this->ops->submit_request (this, req);
+    ret = this->ops->submit_request(this, req);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
+rpc_transport_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply)
 {
-	int32_t                   ret          = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
-	GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail);
 
-	ret = this->ops->submit_reply (this, reply);
+    ret = this->ops->submit_reply(this, reply);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_connect (rpc_transport_t *this, int port)
+rpc_transport_connect(rpc_transport_t *this, int port)
 {
-	int ret = -1;
+    int ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-	ret = this->ops->connect (this, port);
+    ret = this->ops->connect(this, port);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_listen (rpc_transport_t *this)
+rpc_transport_listen(rpc_transport_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-	ret = this->ops->listen (this);
+    ret = this->ops->listen(this);
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_disconnect (rpc_transport_t *this, gf_boolean_t wait)
+rpc_transport_disconnect(rpc_transport_t *this, gf_boolean_t wait)
 {
-	int32_t ret = -1;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-        ret = this->ops->disconnect (this, wait);
+    ret = this->ops->disconnect(this, wait);
 
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_destroy (rpc_transport_t *this)
+rpc_transport_destroy(rpc_transport_t *this)
 {
-	struct dnscache6 *cache = NULL;
-	int32_t ret = -1;
+    struct dnscache6 *cache = NULL;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-        if (this->clnt_options)
-                dict_unref (this->clnt_options);
-        if (this->options)
-                dict_unref (this->options);
-	if (this->fini)
-		this->fini (this);
+    if (this->clnt_options)
+        dict_unref(this->clnt_options);
+    if (this->options)
+        dict_unref(this->options);
+    if (this->fini)
+        this->fini(this);
 
-	pthread_mutex_destroy (&this->lock);
+    pthread_mutex_destroy(&this->lock);
 
-        GF_FREE (this->name);
+    GF_FREE(this->name);
 
-        if (this->dl_handle)
-                dlclose (this->dl_handle);
+    if (this->dl_handle)
+        dlclose(this->dl_handle);
 
-        if (this->ssl_name) {
-                GF_FREE(this->ssl_name);
-        }
+    if (this->ssl_name) {
+        GF_FREE(this->ssl_name);
+    }
 
-        if (this->dnscache) {
-                cache = this->dnscache;
-                if (cache->first)
-                        freeaddrinfo (cache->first);
-                GF_FREE (this->dnscache);
-        }
+    if (this->dnscache) {
+        cache = this->dnscache;
+        if (cache->first)
+            freeaddrinfo(cache->first);
+        GF_FREE(this->dnscache);
+    }
 
-	GF_FREE (this);
+    GF_FREE(this);
 
-	ret = 0;
+    ret = 0;
 fail:
-	return ret;
+    return ret;
 }
 
-
 rpc_transport_t *
-rpc_transport_ref (rpc_transport_t *this)
+rpc_transport_ref(rpc_transport_t *this)
 {
-	rpc_transport_t *return_this = NULL;
+    rpc_transport_t *return_this = NULL;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-        GF_ATOMIC_INC (this->refcount);
+    GF_ATOMIC_INC(this->refcount);
 
-	return_this = this;
+    return_this = this;
 fail:
-	return return_this;
+    return return_this;
 }
 
-
 int32_t
-rpc_transport_unref (rpc_transport_t *this)
+rpc_transport_unref(rpc_transport_t *this)
 {
-	int32_t refcount = 0;
-	int32_t ret = -1;
+    int32_t refcount = 0;
+    int32_t ret = -1;
 
-	GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
+    GF_VALIDATE_OR_GOTO("rpc_transport", this, fail);
 
-        refcount = GF_ATOMIC_DEC (this->refcount);
+    refcount = GF_ATOMIC_DEC(this->refcount);
 
-	if (refcount == 0) {
-                if (this->mydata)
-                        this->notify (this, this->mydata, RPC_TRANSPORT_CLEANUP,
-                                      NULL);
-                this->mydata = NULL;
-                this->notify = NULL;
-                rpc_transport_destroy (this);
-	}
+    if (refcount == 0) {
+        if (this->mydata)
+            this->notify(this, this->mydata, RPC_TRANSPORT_CLEANUP, NULL);
+        this->mydata = NULL;
+        this->notify = NULL;
+        rpc_transport_destroy(this);
+    }
 
-	ret = 0;
+    ret = 0;
 fail:
-	return ret;
+    return ret;
 }
 
-
 int32_t
-rpc_transport_notify (rpc_transport_t *this, rpc_transport_event_t event,
-                      void *data, ...)
+rpc_transport_notify(rpc_transport_t *this, rpc_transport_event_t event,
+                     void *data, ...)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", this, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", this, out);
 
-        if (this->notify != NULL) {
-                ret = this->notify (this, this->mydata, event, data);
-        } else {
-                ret = 0;
-        }
+    if (this->notify != NULL) {
+        ret = this->notify(this, this->mydata, event, data);
+    } else {
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-rpc_transport_register_notify (rpc_transport_t *trans,
-                               rpc_transport_notify_t notify, void *mydata)
+rpc_transport_register_notify(rpc_transport_t *trans,
+                              rpc_transport_notify_t notify, void *mydata)
 {
-        int32_t ret = -1;
-        GF_VALIDATE_OR_GOTO ("rpc", trans, out);
+    int32_t ret = -1;
+    GF_VALIDATE_OR_GOTO("rpc", trans, out);
 
-        trans->notify = notify;
-        trans->mydata = mydata;
+    trans->notify = notify;
+    trans->mydata = mydata;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
-//give negative values to skip setting that value
-//this function asserts if both the values are negative.
-//why call it if you don't set it.
+// give negative values to skip setting that value
+// this function asserts if both the values are negative.
+// why call it if you don't set it.
 int
-rpc_transport_keepalive_options_set (dict_t *options, int32_t interval,
-                                     int32_t time, int32_t timeout)
+rpc_transport_keepalive_options_set(dict_t *options, int32_t interval,
+                                    int32_t time, int32_t timeout)
 {
-        int                     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (options);
-        GF_ASSERT ((interval > 0) || (time > 0));
+    GF_ASSERT(options);
+    GF_ASSERT((interval > 0) || (time > 0));
 
-        ret = dict_set_int32 (options,
-                "transport.socket.keepalive-interval", interval);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "transport.socket.keepalive-interval",
+                         interval);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options,
-                "transport.socket.keepalive-time", time);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "transport.socket.keepalive-time", time);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (options,
-                "transport.tcp-user-timeout", timeout);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(options, "transport.tcp-user-timeout", timeout);
+    if (ret)
+        goto out;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_transport_unix_options_build (dict_t **options, char *filepath,
-                                  int frame_timeout)
+rpc_transport_unix_options_build(dict_t **options, char *filepath,
+                                 int frame_timeout)
 {
-        dict_t                  *dict = NULL;
-        char                    *fpath = NULL;
-        int                     ret = -1;
-
-        GF_ASSERT (filepath);
-        GF_ASSERT (options);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        fpath = gf_strdup (filepath);
-        if (!fpath) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (dict, "transport.socket.connect-path", fpath);
-        if (ret) {
-                GF_FREE (fpath);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "transport.address-family", "unix");
+    dict_t *dict = NULL;
+    char *fpath = NULL;
+    int ret = -1;
+
+    GF_ASSERT(filepath);
+    GF_ASSERT(options);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    fpath = gf_strdup(filepath);
+    if (!fpath) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_dynstr(dict, "transport.socket.connect-path", fpath);
+    if (ret) {
+        GF_FREE(fpath);
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "transport.address-family", "unix");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(dict, "transport.socket.nodelay", "off");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(dict, "transport-type", "socket");
+    if (ret)
+        goto out;
+
+    ret = dict_set_str(dict, "transport.socket.keepalive", "off");
+    if (ret)
+        goto out;
+
+    if (frame_timeout > 0) {
+        ret = dict_set_int32(dict, "frame-timeout", frame_timeout);
         if (ret)
-                goto out;
+            goto out;
+    }
 
-        ret = dict_set_str (dict, "transport.socket.nodelay", "off");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret)
-                goto out;
-
-        ret = dict_set_str (dict, "transport.socket.keepalive", "off");
-        if (ret)
-                goto out;
-
-        if (frame_timeout > 0) {
-                ret = dict_set_int32 (dict, "frame-timeout", frame_timeout);
-                if (ret)
-                        goto out;
-        }
-
-        *options = dict;
+    *options = dict;
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
-        return ret;
+    if (ret && dict) {
+        dict_unref(dict);
+    }
+    return ret;
 }
 
 int
-rpc_transport_inet_options_build (dict_t **options, const char *hostname,
-                                  int port)
+rpc_transport_inet_options_build(dict_t **options, const char *hostname,
+                                 int port)
 {
-        dict_t          *dict = NULL;
-        char            *host = NULL;
-        int             ret = -1;
+    dict_t *dict = NULL;
+    char *host = NULL;
+    int ret = -1;
 #ifdef IPV6_DEFAULT
-        char            *addr_family = "inet6";
+    char *addr_family = "inet6";
 #else
-        char            *addr_family = "inet";
+    char *addr_family = "inet";
 #endif
 
-        GF_ASSERT (options);
-        GF_ASSERT (hostname);
-        GF_ASSERT (port >= 1024);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-
-        host = gf_strdup ((char*)hostname);
-        if (!host) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_dynstr (dict, "remote-host", host);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set remote-host with %s", host);
-                GF_FREE (host);
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, "remote-port", port);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set remote-port with %d", port);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "address-family", addr_family);
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set address-family to %s", addr_family);
-                goto out;
-        }
-
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set trans-type with socket");
-                goto out;
-        }
-
-        *options = dict;
+    GF_ASSERT(options);
+    GF_ASSERT(hostname);
+    GF_ASSERT(port >= 1024);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+
+    host = gf_strdup((char *)hostname);
+    if (!host) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_dynstr(dict, "remote-host", host);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-host with %s",
+               host);
+        GF_FREE(host);
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, "remote-port", port);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-port with %d",
+               port);
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "address-family", addr_family);
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set address-family to %s",
+               addr_family);
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "transport-type", "socket");
+    if (ret) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to set trans-type with socket");
+        goto out;
+    }
+
+    *options = dict;
 out:
-        if (ret && dict) {
-                dict_unref (dict);
-        }
+    if (ret && dict) {
+        dict_unref(dict);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/rpcsvc-auth.c b/rpc/rpc-lib/src/rpcsvc-auth.c
index ef9b35f56ad..da260ade0c0 100644
--- a/rpc/rpc-lib/src/rpcsvc-auth.c
+++ b/rpc/rpc-lib/src/rpcsvc-auth.c
@@ -13,521 +13,507 @@
 #include "dict.h"
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options);
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options);
 
 extern rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options);
 extern rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options);
 extern rpcsvc_auth_t *
-rpcsvc_auth_glusterfs_v3_init (rpcsvc_t *svc, dict_t *options);
+rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options);
 
 int
-rpcsvc_auth_add_initer (struct list_head *list, char *idfier,
-                        rpcsvc_auth_initer_t init)
+rpcsvc_auth_add_initer(struct list_head *list, char *idfier,
+                       rpcsvc_auth_initer_t init)
 {
-        struct rpcsvc_auth_list         *new = NULL;
+    struct rpcsvc_auth_list *new = NULL;
 
-        if ((!list) || (!init) || (!idfier))
-                return -1;
+    if ((!list) || (!init) || (!idfier))
+        return -1;
 
-        new = GF_CALLOC (1, sizeof (*new), gf_common_mt_rpcsvc_auth_list);
-        if (!new) {
-                return -1;
-        }
+    new = GF_CALLOC(1, sizeof(*new), gf_common_mt_rpcsvc_auth_list);
+    if (!new) {
+        return -1;
+    }
 
-        new->init = init;
-        strncpy (new->name, idfier, sizeof (new->name) - 1);
-        INIT_LIST_HEAD (&new->authlist);
-        list_add_tail (&new->authlist, list);
-        return 0;
+    new->init = init;
+    strncpy(new->name, idfier, sizeof(new->name) - 1);
+    INIT_LIST_HEAD(&new->authlist);
+    list_add_tail(&new->authlist, list);
+    return 0;
 }
 
-
-
 int
-rpcsvc_auth_add_initers (rpcsvc_t *svc)
+rpcsvc_auth_add_initers(rpcsvc_t *svc)
 {
-        int     ret = -1;
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_glusterfs_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS");
-                goto err;
-        }
-
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v2",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_glusterfs_v2_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "Failed to add AUTH_GLUSTERFS-v2");
-                goto err;
-        }
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v3",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_glusterfs_v3_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "Failed to add AUTH_GLUSTERFS-v3");
-                goto err;
-        }
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-unix",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_unix_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX");
-                goto err;
-        }
-
-        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-null",
-                                      (rpcsvc_auth_initer_t)
-                                      rpcsvc_auth_null_init);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL");
-                goto err;
-        }
-
-        ret = 0;
+    int ret = -1;
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs-v2",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v2_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v2");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(
+        &svc->authschemes, "auth-glusterfs-v3",
+        (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v3_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v3");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-unix",
+                                 (rpcsvc_auth_initer_t)rpcsvc_auth_unix_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX");
+        goto err;
+    }
+
+    ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-null",
+                                 (rpcsvc_auth_initer_t)rpcsvc_auth_null_init);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL");
+        goto err;
+    }
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_auth_init_auth (rpcsvc_t *svc, dict_t *options,
-                       struct rpcsvc_auth_list *authitem)
+rpcsvc_auth_init_auth(rpcsvc_t *svc, dict_t *options,
+                      struct rpcsvc_auth_list *authitem)
 {
-        int             ret = -1;
-
-        if ((!svc) || (!options) || (!authitem))
-                return -1;
-
-        if (!authitem->init) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "No init function defined");
-                ret = -1;
-                goto err;
-        }
-
-        authitem->auth = authitem->init (svc, options);
-        if (!authitem->auth) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Registration of auth failed:"
-                        " %s", authitem->name);
-                ret = -1;
-                goto err;
-        }
-
-        authitem->enable = 1;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s",
-                authitem->auth->authname);
-
-        ret = 0;
+    int ret = -1;
+
+    if ((!svc) || (!options) || (!authitem))
+        return -1;
+
+    if (!authitem->init) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "No init function defined");
+        ret = -1;
+        goto err;
+    }
+
+    authitem->auth = authitem->init(svc, options);
+    if (!authitem->auth) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Registration of auth failed:"
+               " %s",
+               authitem->name);
+        ret = -1;
+        goto err;
+    }
+
+    authitem->enable = 1;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s",
+           authitem->auth->authname);
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_auth_init_auths (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_init_auths(rpcsvc_t *svc, dict_t *options)
 {
-        int                     ret = -1;
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
-
-        if (!svc)
-                return -1;
+    int ret = -1;
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
 
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
-                ret = 0;
-                goto err;
-        }
+    if (!svc)
+        return -1;
 
-        /* If auth null and sys are not disabled by the user, we must enable
-         * it by default. This is a globally default rule, the user is still
-         * allowed to disable the two for particular subvolumes.
-         */
-        if (!dict_get (options, "rpc-auth.auth-null")) {
-                ret = dict_set_str (options, "rpc-auth.auth-null", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-nill'");
-        }
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
+        ret = 0;
+        goto err;
+    }
+
+    /* If auth null and sys are not disabled by the user, we must enable
+     * it by default. This is a globally default rule, the user is still
+     * allowed to disable the two for particular subvolumes.
+     */
+    if (!dict_get(options, "rpc-auth.auth-null")) {
+        ret = dict_set_str(options, "rpc-auth.auth-null", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-nill'");
+    }
 
-        if (!dict_get (options, "rpc-auth.auth-unix")) {
-                ret = dict_set_str (options, "rpc-auth.auth-unix", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-unix'");
-        }
+    if (!dict_get(options, "rpc-auth.auth-unix")) {
+        ret = dict_set_str(options, "rpc-auth.auth-unix", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'");
+    }
 
-        if (!dict_get (options, "rpc-auth.auth-glusterfs")) {
-                ret = dict_set_str (options, "rpc-auth.auth-glusterfs", "on");
-                if (ret)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                "dict_set failed for 'auth-unix'");
-        }
+    if (!dict_get(options, "rpc-auth.auth-glusterfs")) {
+        ret = dict_set_str(options, "rpc-auth.auth-glusterfs", "on");
+        if (ret)
+            gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'");
+    }
 
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                ret = rpcsvc_auth_init_auth (svc, options, auth);
-                if (ret == -1)
-                        goto err;
-        }
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        ret = rpcsvc_auth_init_auth(svc, options, auth);
+        if (ret == -1)
+            goto err;
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
-
+    return ret;
 }
 
 int
-rpcsvc_set_addr_namelookup (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_addr_namelookup(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret;
-        static char     *addrlookup_key = "rpc-auth.addr.namelookup";
-
-        if (!svc || !options)
-                return (-1);
-
-        /* By default it's disabled */
-        ret = dict_get_str_boolean (options, addrlookup_key, _gf_false);
-        if (ret < 0) {
-                svc->addr_namelookup = _gf_false;
-        } else {
-                svc->addr_namelookup = ret;
-        }
+    int ret;
+    static char *addrlookup_key = "rpc-auth.addr.namelookup";
+
+    if (!svc || !options)
+        return (-1);
 
-        if (svc->addr_namelookup)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled");
+    /* By default it's disabled */
+    ret = dict_get_str_boolean(options, addrlookup_key, _gf_false);
+    if (ret < 0) {
+        svc->addr_namelookup = _gf_false;
+    } else {
+        svc->addr_namelookup = ret;
+    }
 
-        return (0);
+    if (svc->addr_namelookup)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled");
+
+    return (0);
 }
 
 int
-rpcsvc_set_allow_insecure (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_allow_insecure(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret = -1;
-        char            *allow_insecure_str = NULL;
-        gf_boolean_t    is_allow_insecure = _gf_false;
+    int ret = -1;
+    char *allow_insecure_str = NULL;
+    gf_boolean_t is_allow_insecure = _gf_false;
 
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
 
-        ret = dict_get_str (options, "rpc-auth-allow-insecure",
-                            &allow_insecure_str);
+    ret = dict_get_str(options, "rpc-auth-allow-insecure", &allow_insecure_str);
+    if (0 == ret) {
+        ret = gf_string2boolean(allow_insecure_str, &is_allow_insecure);
         if (0 == ret) {
-                ret = gf_string2boolean (allow_insecure_str,
-                                         &is_allow_insecure);
-                if (0 == ret) {
-                        if (_gf_true == is_allow_insecure)
-                                svc->allow_insecure = 1;
-                        else
-                                svc->allow_insecure = 0;
-                }
-        } else {
-                /* By default set allow-insecure to true */
+            if (_gf_true == is_allow_insecure)
                 svc->allow_insecure = 1;
-
-                /* setting in options for the sake of functions that look
-                 * configuration params for allow insecure,  eg: gf_auth
-                 */
-                ret = dict_set_str (options, "rpc-auth-allow-insecure", "on");
-                if (ret < 0)
-                        gf_log ("rpc-auth", GF_LOG_DEBUG,
-                                        "dict_set failed for 'allow-insecure'");
+            else
+                svc->allow_insecure = 0;
         }
+    } else {
+        /* By default set allow-insecure to true */
+        svc->allow_insecure = 1;
 
-        return ret;
+        /* setting in options for the sake of functions that look
+         * configuration params for allow insecure,  eg: gf_auth
+         */
+        ret = dict_set_str(options, "rpc-auth-allow-insecure", "on");
+        if (ret < 0)
+            gf_log("rpc-auth", GF_LOG_DEBUG,
+                   "dict_set failed for 'allow-insecure'");
+    }
+
+    return ret;
 }
 
 int
-rpcsvc_set_root_squash (rpcsvc_t *svc, dict_t *options)
+rpcsvc_set_root_squash(rpcsvc_t *svc, dict_t *options)
 {
-        int  ret = -1;
-        uid_t anonuid = -1;
-        gid_t anongid = -1;
-
-        GF_ASSERT (svc);
-        GF_ASSERT (options);
-
-        ret = dict_get_str_boolean (options, "root-squash", 0);
-        if (ret != -1)
-                svc->root_squash = ret;
-        else
-                svc->root_squash = _gf_false;
-
-        ret = dict_get_uint32 (options, "anonuid", &anonuid);
-        if (!ret)
-                svc->anonuid = anonuid;
-        else
-                svc->anonuid = RPC_NOBODY_UID;
-
-        ret = dict_get_uint32 (options, "anongid", &anongid);
-        if (!ret)
-                svc->anongid = anongid;
-        else
-                svc->anongid = RPC_NOBODY_GID;
-
-        if (svc->root_squash)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "root squashing enabled "
-                        "(uid=%d, gid=%d)", svc->anonuid, svc->anongid);
-
-        return 0;
+    int ret = -1;
+    uid_t anonuid = -1;
+    gid_t anongid = -1;
+
+    GF_ASSERT(svc);
+    GF_ASSERT(options);
+
+    ret = dict_get_str_boolean(options, "root-squash", 0);
+    if (ret != -1)
+        svc->root_squash = ret;
+    else
+        svc->root_squash = _gf_false;
+
+    ret = dict_get_uint32(options, "anonuid", &anonuid);
+    if (!ret)
+        svc->anonuid = anonuid;
+    else
+        svc->anonuid = RPC_NOBODY_UID;
+
+    ret = dict_get_uint32(options, "anongid", &anongid);
+    if (!ret)
+        svc->anongid = anongid;
+    else
+        svc->anongid = RPC_NOBODY_GID;
+
+    if (svc->root_squash)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "root squashing enabled "
+               "(uid=%d, gid=%d)",
+               svc->anonuid, svc->anongid);
+
+    return 0;
 }
 
 int
-rpcsvc_auth_init (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_init(rpcsvc_t *svc, dict_t *options)
 {
-        int             ret = -1;
-
-        if ((!svc) || (!options))
-                return -1;
-
-        (void) rpcsvc_set_allow_insecure (svc, options);
-        (void) rpcsvc_set_root_squash (svc, options);
-        (void) rpcsvc_set_addr_namelookup (svc, options);
-        ret = rpcsvc_auth_add_initers (svc);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers");
-                goto out;
-        }
-
-        ret = rpcsvc_auth_init_auths (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes");
-                goto out;
-        }
+    int ret = -1;
+
+    if ((!svc) || (!options))
+        return -1;
+
+    (void)rpcsvc_set_allow_insecure(svc, options);
+    (void)rpcsvc_set_root_squash(svc, options);
+    (void)rpcsvc_set_addr_namelookup(svc, options);
+    ret = rpcsvc_auth_add_initers(svc);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers");
+        goto out;
+    }
+
+    ret = rpcsvc_auth_init_auths(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_auth_reconf (rpcsvc_t *svc, dict_t *options)
+rpcsvc_auth_reconf(rpcsvc_t *svc, dict_t *options)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if ((!svc) || (!options))
-                return (-1);
+    if ((!svc) || (!options))
+        return (-1);
 
-        ret = rpcsvc_set_allow_insecure (svc, options);
-        if (ret)
-                return (-1);
+    ret = rpcsvc_set_allow_insecure(svc, options);
+    if (ret)
+        return (-1);
 
-        ret = rpcsvc_set_root_squash (svc, options);
-        if (ret)
-                return (-1);
+    ret = rpcsvc_set_root_squash(svc, options);
+    if (ret)
+        return (-1);
 
-        return rpcsvc_set_addr_namelookup (svc, options);
+    return rpcsvc_set_addr_namelookup(svc, options);
 }
 
-
 rpcsvc_auth_t *
-__rpcsvc_auth_get_handler (rpcsvc_request_t *req)
+__rpcsvc_auth_get_handler(rpcsvc_request_t *req)
 {
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
-        rpcsvc_t                *svc = NULL;
-
-        if (!req)
-                return NULL;
-
-        svc = req->svc;
-        if (!svc) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "!svc");
-                goto err;
-        }
-
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
-                goto err;
-        }
-
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                if (!auth->enable)
-                        continue;
-                if (auth->auth->authnum == req->cred.flavour)
-                        goto err;
-
-        }
-
-        auth = NULL;
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
+    rpcsvc_t *svc = NULL;
+
+    if (!req)
+        return NULL;
+
+    svc = req->svc;
+    if (!svc) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "!svc");
+        goto err;
+    }
+
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!");
+        goto err;
+    }
+
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        if (!auth->enable)
+            continue;
+        if (auth->auth->authnum == req->cred.flavour)
+            goto err;
+    }
+
+    auth = NULL;
 err:
-        if (auth)
-                return auth->auth;
-        else
-                return NULL;
+    if (auth)
+        return auth->auth;
+    else
+        return NULL;
 }
 
 rpcsvc_auth_t *
-rpcsvc_auth_get_handler (rpcsvc_request_t *req)
+rpcsvc_auth_get_handler(rpcsvc_request_t *req)
 {
-        rpcsvc_auth_t           *auth = NULL;
+    rpcsvc_auth_t *auth = NULL;
 
-        auth = __rpcsvc_auth_get_handler (req);
-        if (auth)
-                goto ret;
+    auth = __rpcsvc_auth_get_handler(req);
+    if (auth)
+        goto ret;
 
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d",
-                req->cred.flavour);
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d", req->cred.flavour);
 
-        /* The requested scheme was not available so fall back the to one
-         * scheme that will always be present.
-         */
-        req->cred.flavour = AUTH_NULL;
-        req->verf.flavour = AUTH_NULL;
-        auth = __rpcsvc_auth_get_handler (req);
+    /* The requested scheme was not available so fall back the to one
+     * scheme that will always be present.
+     */
+    req->cred.flavour = AUTH_NULL;
+    req->verf.flavour = AUTH_NULL;
+    auth = __rpcsvc_auth_get_handler(req);
 ret:
-        return auth;
+    return auth;
 }
 
-
 int
-rpcsvc_auth_request_init (rpcsvc_request_t *req, struct rpc_msg *callmsg)
+rpcsvc_auth_request_init(rpcsvc_request_t *req, struct rpc_msg *callmsg)
 {
-        int32_t                 ret = 0;
-        rpcsvc_auth_t           *auth = NULL;
-
-        if (!req || !callmsg) {
-                ret = -1;
-                goto err;
-        }
-
-        req->cred.flavour = rpc_call_cred_flavour (callmsg);
-        req->cred.datalen = rpc_call_cred_len (callmsg);
-        req->verf.flavour = rpc_call_verf_flavour (callmsg);
-        req->verf.datalen = rpc_call_verf_len (callmsg);
-
-        auth = rpcsvc_auth_get_handler (req);
-        if (!auth) {
-                ret = -1;
-                goto err;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname);
-
-        if (auth->authops->request_init)
-              ret = auth->authops->request_init (req, auth->authprivate);
-
-        /* reset to auxgidlarge during
-           unsersialize if necessary */
-        req->auxgids = req->auxgidsmall;
-        req->auxgidlarge = NULL;
+    int32_t ret = 0;
+    rpcsvc_auth_t *auth = NULL;
+
+    if (!req || !callmsg) {
+        ret = -1;
+        goto err;
+    }
+
+    req->cred.flavour = rpc_call_cred_flavour(callmsg);
+    req->cred.datalen = rpc_call_cred_len(callmsg);
+    req->verf.flavour = rpc_call_verf_flavour(callmsg);
+    req->verf.datalen = rpc_call_verf_len(callmsg);
+
+    auth = rpcsvc_auth_get_handler(req);
+    if (!auth) {
+        ret = -1;
+        goto err;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname);
+
+    if (auth->authops->request_init)
+        ret = auth->authops->request_init(req, auth->authprivate);
+
+    /* reset to auxgidlarge during
+       unsersialize if necessary */
+    req->auxgids = req->auxgidsmall;
+    req->auxgidlarge = NULL;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_authenticate (rpcsvc_request_t *req)
+rpcsvc_authenticate(rpcsvc_request_t *req)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        rpcsvc_auth_t           *auth = NULL;
-        int                     minauth = 0;
-
-        if (!req)
-                return ret;
-
-        /* FIXME use rpcsvc_request_prog_minauth() */
-        minauth = 0;
-        if (minauth > rpcsvc_request_cred_flavour (req)) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "Auth too weak");
-                rpcsvc_request_set_autherr (req, AUTH_TOOWEAK);
-                goto err;
-        }
+    int ret = RPCSVC_AUTH_REJECT;
+    rpcsvc_auth_t *auth = NULL;
+    int minauth = 0;
 
-        auth = rpcsvc_auth_get_handler (req);
-        if (!auth) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "No auth handler found");
-                goto err;
-        }
+    if (!req)
+        return ret;
+
+    /* FIXME use rpcsvc_request_prog_minauth() */
+    minauth = 0;
+    if (minauth > rpcsvc_request_cred_flavour(req)) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "Auth too weak");
+        rpcsvc_request_set_autherr(req, AUTH_TOOWEAK);
+        goto err;
+    }
+
+    auth = rpcsvc_auth_get_handler(req);
+    if (!auth) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "No auth handler found");
+        goto err;
+    }
 
-        if (auth->authops->authenticate)
-                ret = auth->authops->authenticate (req, auth->authprivate);
+    if (auth->authops->authenticate)
+        ret = auth->authops->authenticate(req, auth->authprivate);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen)
+rpcsvc_auth_array(rpcsvc_t *svc, char *volname, int *autharr, int arrlen)
 {
-        int             count      = 0;
-        int             result     = RPCSVC_AUTH_REJECT;
-        char           *srchstr    = NULL;
-        int             ret        = 0;
-
-        struct rpcsvc_auth_list *auth = NULL;
-        struct rpcsvc_auth_list *tmp = NULL;
+    int count = 0;
+    int result = RPCSVC_AUTH_REJECT;
+    char *srchstr = NULL;
+    int ret = 0;
+
+    struct rpcsvc_auth_list *auth = NULL;
+    struct rpcsvc_auth_list *tmp = NULL;
+
+    if ((!svc) || (!autharr) || (!volname))
+        return -1;
+
+    memset(autharr, 0, arrlen * sizeof(int));
+    if (list_empty(&svc->authschemes)) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "No authentication!");
+        goto err;
+    }
+
+    list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist)
+    {
+        if (count >= arrlen)
+            break;
+
+        result = gf_asprintf(&srchstr, "rpc-auth.%s.%s", auth->name, volname);
+        if (result == -1) {
+            count = -1;
+            goto err;
+        }
 
-        if ((!svc) || (!autharr) || (!volname))
-                return -1;
+        ret = dict_get_str_boolean(svc->options, srchstr, 0xC00FFEE);
+        GF_FREE(srchstr);
 
-        memset (autharr, 0, arrlen * sizeof(int));
-        if (list_empty (&svc->authschemes)) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "No authentication!");
-                goto err;
-        }
+        switch (ret) {
+            case _gf_true:
+                autharr[count] = auth->auth->authnum;
+                ++count;
+                break;
 
-        list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) {
-                if (count >= arrlen)
-                        break;
-
-                result = gf_asprintf (&srchstr, "rpc-auth.%s.%s",
-                                      auth->name, volname);
-                if (result == -1) {
-                        count = -1;
-                        goto err;
-                }
-
-                ret = dict_get_str_boolean (svc->options, srchstr, 0xC00FFEE);
-                GF_FREE (srchstr);
-
-                switch (ret) {
-                case _gf_true:
-                        autharr[count] = auth->auth->authnum;
-                        ++count;
-                        break;
-
-                default:
-                        /* nothing to do */
-                        break;
-                }
+            default:
+                /* nothing to do */
+                break;
         }
+    }
 
 err:
-        return count;
+    return count;
 }
 
 gid_t *
-rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen)
+rpcsvc_auth_unix_auxgids(rpcsvc_request_t *req, int *arrlen)
 {
-        if ((!req) || (!arrlen))
-                return NULL;
+    if ((!req) || (!arrlen))
+        return NULL;
 
-        /* In case of AUTH_NULL auxgids are not used */
-        switch (req->cred.flavour) {
+    /* In case of AUTH_NULL auxgids are not used */
+    switch (req->cred.flavour) {
         case AUTH_UNIX:
         case AUTH_GLUSTERFS:
         case AUTH_GLUSTERFS_v2:
         case AUTH_GLUSTERFS_v3:
-                break;
+            break;
         default:
-                gf_log ("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs");
-                return NULL;
-        }
+            gf_log("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs");
+            return NULL;
+    }
 
-        *arrlen = req->auxgidcount;
-        if (*arrlen == 0)
-                return NULL;
+    *arrlen = req->auxgidcount;
+    if (*arrlen == 0)
+        return NULL;
 
-        return &req->auxgids[0];
+    return &req->auxgids[0];
 }
diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c
index c8aaf4c7fa9..c6545193a11 100644
--- a/rpc/rpc-lib/src/rpcsvc.c
+++ b/rpc/rpc-lib/src/rpcsvc.c
@@ -46,1175 +46,1176 @@
 
 struct rpcsvc_program gluster_dump_prog;
 
-#define rpcsvc_alloc_request(svc, request)                                \
-        do {                                                              \
-                request = (rpcsvc_request_t *)mem_get ((svc)->rxpool);   \
-                if (request) {                                            \
-                        memset (request, 0, sizeof (rpcsvc_request_t));   \
-                } else {                                                  \
-                        gf_log ("rpcsvc", GF_LOG_ERROR,                   \
-                                "error getting memory for rpc request");  \
-                }                                                         \
-        } while (0)
+#define rpcsvc_alloc_request(svc, request)                                     \
+    do {                                                                       \
+        request = (rpcsvc_request_t *)mem_get((svc)->rxpool);                  \
+        if (request) {                                                         \
+            memset(request, 0, sizeof(rpcsvc_request_t));                      \
+        } else {                                                               \
+            gf_log("rpcsvc", GF_LOG_ERROR,                                     \
+                   "error getting memory for rpc request");                    \
+        }                                                                      \
+    } while (0)
 
 rpcsvc_listener_t *
-rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans);
+rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans);
 
 int
-rpcsvc_notify (rpc_transport_t *trans, void *mydata,
-               rpc_transport_event_t event, void *data, ...);
+rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event,
+              void *data, ...);
 
 static int
-rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr);
+rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr);
 
 rpcsvc_notify_wrapper_t *
-rpcsvc_notify_wrapper_alloc (void)
+rpcsvc_notify_wrapper_alloc(void)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
 
-        wrapper = GF_CALLOC (1, sizeof (*wrapper), gf_common_mt_rpcsvc_wrapper_t);
-        if (!wrapper) {
-                goto out;
-        }
+    wrapper = GF_CALLOC(1, sizeof(*wrapper), gf_common_mt_rpcsvc_wrapper_t);
+    if (!wrapper) {
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&wrapper->list);
+    INIT_LIST_HEAD(&wrapper->list);
 out:
-        return wrapper;
+    return wrapper;
 }
 
-
 void
-rpcsvc_listener_destroy (rpcsvc_listener_t *listener)
+rpcsvc_listener_destroy(rpcsvc_listener_t *listener)
 {
-        rpcsvc_t *svc = NULL;
+    rpcsvc_t *svc = NULL;
 
-        if (!listener) {
-                goto out;
-        }
+    if (!listener) {
+        goto out;
+    }
 
-        svc = listener->svc;
-        if (!svc) {
-                goto listener_free;
-        }
+    svc = listener->svc;
+    if (!svc) {
+        goto listener_free;
+    }
 
-        pthread_rwlock_wrlock (&svc->rpclock);
-        {
-                list_del_init (&listener->list);
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_del_init(&listener->list);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
 listener_free:
-        GF_FREE (listener);
+    GF_FREE(listener);
 out:
-        return;
+    return;
 }
 
 rpcsvc_vector_sizer
-rpcsvc_get_program_vector_sizer (rpcsvc_t *svc, uint32_t prognum,
-                                 uint32_t progver, int procnum)
+rpcsvc_get_program_vector_sizer(rpcsvc_t *svc, uint32_t prognum,
+                                uint32_t progver, int procnum)
 {
-        rpcsvc_program_t        *program = NULL;
-        char                    found    = 0;
+    rpcsvc_program_t *program = NULL;
+    char found = 0;
 
-        if (!svc)
-                return NULL;
+    if (!svc)
+        return NULL;
 
-        pthread_rwlock_rdlock (&svc->rpclock);
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        /* Find the matching RPC program from registered list */
+        list_for_each_entry(program, &svc->programs, program)
         {
-                /* Find the matching RPC program from registered list */
-                list_for_each_entry (program, &svc->programs, program) {
-                        if ((program->prognum == prognum)
-                            && (program->progver == progver)) {
-                                found = 1;
-                                break;
-                        }
-                }
+            if ((program->prognum == prognum) &&
+                (program->progver == progver)) {
+                found = 1;
+                break;
+            }
         }
-        pthread_rwlock_unlock (&svc->rpclock);
-
-        if (found) {
-                /* Make sure the requested procnum is supported by RPC prog */
-                if ((procnum < 0) || (procnum >= program->numactors)) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "RPC procedure %d not available for Program %s",
-                                procnum, program->progname);
-                        return NULL;
-                }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-                /* SUCCESS: Supported procedure */
-                return program->actors[procnum].vector_sizer;
+    if (found) {
+        /* Make sure the requested procnum is supported by RPC prog */
+        if ((procnum < 0) || (procnum >= program->numactors)) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "RPC procedure %d not available for Program %s", procnum,
+                   program->progname);
+            return NULL;
         }
 
-        return NULL; /* FAIL */
+        /* SUCCESS: Supported procedure */
+        return program->actors[procnum].vector_sizer;
+    }
+
+    return NULL; /* FAIL */
 }
 
 gf_boolean_t
-rpcsvc_can_outstanding_req_be_ignored (rpcsvc_request_t *req)
-{
-        /*
-         * If outstanding_rpc_limit is reached because of blocked locks and
-         * throttling is attempted then no unlock requests will be received. So
-         * the outstanding request count will never change i.e. it will always
-         * be equal to the limit. This also leads to ping timer expiry on
-         * client.
-         */
-
-        /*
-         * This is a hack and a necessity until grantedlock == fop completion.
-         * Ideally if we get a blocking lock request which cannot be granted
-         * right now, we should unwind the fop saying “request registered, will
-         * notify you when granted”, which is very hard to implement at the
-         * moment. Until we bring in such mechanism, we will need to live with
-         * not rate-limiting INODELK/ENTRYLK/LK fops
-         */
-
-        if ((req->prognum == GLUSTER_FOP_PROGRAM) &&
-            (req->progver == GLUSTER_FOP_VERSION)) {
-                if ((req->procnum == GFS3_OP_INODELK) ||
-                    (req->procnum == GFS3_OP_FINODELK) ||
-                    (req->procnum == GFS3_OP_ENTRYLK) ||
-                    (req->procnum == GFS3_OP_FENTRYLK) ||
-                    (req->procnum == GFS3_OP_LK))
-                        return _gf_true;
-        }
-        return _gf_false;
+rpcsvc_can_outstanding_req_be_ignored(rpcsvc_request_t *req)
+{
+    /*
+     * If outstanding_rpc_limit is reached because of blocked locks and
+     * throttling is attempted then no unlock requests will be received. So
+     * the outstanding request count will never change i.e. it will always
+     * be equal to the limit. This also leads to ping timer expiry on
+     * client.
+     */
+
+    /*
+     * This is a hack and a necessity until grantedlock == fop completion.
+     * Ideally if we get a blocking lock request which cannot be granted
+     * right now, we should unwind the fop saying “request registered, will
+     * notify you when granted”, which is very hard to implement at the
+     * moment. Until we bring in such mechanism, we will need to live with
+     * not rate-limiting INODELK/ENTRYLK/LK fops
+     */
+
+    if ((req->prognum == GLUSTER_FOP_PROGRAM) &&
+        (req->progver == GLUSTER_FOP_VERSION)) {
+        if ((req->procnum == GFS3_OP_INODELK) ||
+            (req->procnum == GFS3_OP_FINODELK) ||
+            (req->procnum == GFS3_OP_ENTRYLK) ||
+            (req->procnum == GFS3_OP_FENTRYLK) || (req->procnum == GFS3_OP_LK))
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 int
-rpcsvc_request_outstanding (rpcsvc_request_t *req, int delta)
+rpcsvc_request_outstanding(rpcsvc_request_t *req, int delta)
 {
-        int             ret = -1;
-        int             old_count = 0;
-        int             new_count = 0;
-        int             limit = 0;
-        gf_boolean_t    throttle = _gf_false;
+    int ret = -1;
+    int old_count = 0;
+    int new_count = 0;
+    int limit = 0;
+    gf_boolean_t throttle = _gf_false;
 
-        if (!req)
-                goto out;
+    if (!req)
+        goto out;
 
-        throttle = rpcsvc_get_throttle (req->svc);
-        if (!throttle) {
-                ret = 0;
-                goto out;
-        }
+    throttle = rpcsvc_get_throttle(req->svc);
+    if (!throttle) {
+        ret = 0;
+        goto out;
+    }
 
-        if (rpcsvc_can_outstanding_req_be_ignored (req)) {
-                ret = 0;
-                goto out;
-        }
+    if (rpcsvc_can_outstanding_req_be_ignored(req)) {
+        ret = 0;
+        goto out;
+    }
 
-        pthread_mutex_lock (&req->trans->lock);
-        {
-                limit = req->svc->outstanding_rpc_limit;
-                if (!limit)
-                        goto unlock;
+    pthread_mutex_lock(&req->trans->lock);
+    {
+        limit = req->svc->outstanding_rpc_limit;
+        if (!limit)
+            goto unlock;
 
-                old_count = req->trans->outstanding_rpc_count;
-                req->trans->outstanding_rpc_count += delta;
-                new_count = req->trans->outstanding_rpc_count;
+        old_count = req->trans->outstanding_rpc_count;
+        req->trans->outstanding_rpc_count += delta;
+        new_count = req->trans->outstanding_rpc_count;
 
-                if (old_count <= limit && new_count > limit)
-                        ret = rpc_transport_throttle (req->trans, _gf_true);
+        if (old_count <= limit && new_count > limit)
+            ret = rpc_transport_throttle(req->trans, _gf_true);
 
-                if (old_count > limit && new_count <= limit)
-                        ret = rpc_transport_throttle (req->trans, _gf_false);
-        }
+        if (old_count > limit && new_count <= limit)
+            ret = rpc_transport_throttle(req->trans, _gf_false);
+    }
 unlock:
-        pthread_mutex_unlock (&req->trans->lock);
+    pthread_mutex_unlock(&req->trans->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* This needs to change to returning errors, since
  * we need to return RPC specific error messages when some
  * of the pointers below are NULL.
  */
 rpcsvc_actor_t *
-rpcsvc_program_actor (rpcsvc_request_t *req)
-{
-        rpcsvc_program_t        *program = NULL;
-        int                     err      = SYSTEM_ERR;
-        rpcsvc_actor_t          *actor   = NULL;
-        rpcsvc_t                *svc     = NULL;
-        char                    found    = 0;
-        char                    *peername = NULL;
-
-        if (!req)
-                goto err;
-
-        svc = req->svc;
-        peername = req->trans->peerinfo.identifier;
-        pthread_rwlock_rdlock (&svc->rpclock);
+rpcsvc_program_actor(rpcsvc_request_t *req)
+{
+    rpcsvc_program_t *program = NULL;
+    int err = SYSTEM_ERR;
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_t *svc = NULL;
+    char found = 0;
+    char *peername = NULL;
+
+    if (!req)
+        goto err;
+
+    svc = req->svc;
+    peername = req->trans->peerinfo.identifier;
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(program, &svc->programs, program)
         {
-                list_for_each_entry (program, &svc->programs, program) {
-                        if (program->prognum == req->prognum) {
-                                err = PROG_MISMATCH;
-                        }
-
-                        if ((program->prognum == req->prognum)
-                            && (program->progver == req->progver)) {
-                                found = 1;
-                                break;
-                        }
-                }
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
-
-        if (!found) {
-                if (err != PROG_MISMATCH) {
-                        /* log in DEBUG when nfs clients try to see if
-                         * ACL requests are accepted by nfs server
-                         */
-                        gf_log (GF_RPCSVC, (req->prognum == ACL_PROGRAM) ?
-                                GF_LOG_DEBUG : GF_LOG_WARNING,
-                                "RPC program not available (req %u %u) for %s",
-                                req->prognum, req->progver,
-                                peername);
-                        err = PROG_UNAVAIL;
-                        goto err;
-                }
+            if (program->prognum == req->prognum) {
+                err = PROG_MISMATCH;
+            }
 
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "RPC program version not available (req %u %u) for %s",
-                        req->prognum, req->progver,
-                        peername);
-                goto err;
-        }
-        req->prog = program;
-        if (!program->actors) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "RPC Actor not found for program %s %d for %s",
-                        program->progname, program->prognum,
-                        peername);
-                err = SYSTEM_ERR;
-                goto err;
-        }
-
-        if ((req->procnum < 0) || (req->procnum >= program->numactors)) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not"
-                        " available for procedure %d in %s for  %s",
-                        req->procnum, program->progname,
-                        peername);
-                err = PROC_UNAVAIL;
-                goto err;
-        }
-
-        actor = &program->actors[req->procnum];
-        if (!actor->actor) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not"
-                        " available for procedure %d in %s for %s",
-                        req->procnum, program->progname,
-                        peername);
-                err = PROC_UNAVAIL;
-                actor = NULL;
-                goto err;
-        }
-
-        req->ownthread = program->ownthread;
-        req->synctask = program->synctask;
-
-        err = SUCCESS;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s",
-                program->progname, actor->procname,
-                peername);
+            if ((program->prognum == req->prognum) &&
+                (program->progver == req->progver)) {
+                found = 1;
+                break;
+            }
+        }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    if (!found) {
+        if (err != PROG_MISMATCH) {
+            /* log in DEBUG when nfs clients try to see if
+             * ACL requests are accepted by nfs server
+             */
+            gf_log(
+                GF_RPCSVC,
+                (req->prognum == ACL_PROGRAM) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+                "RPC program not available (req %u %u) for %s", req->prognum,
+                req->progver, peername);
+            err = PROG_UNAVAIL;
+            goto err;
+        }
+
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "RPC program version not available (req %u %u) for %s",
+               req->prognum, req->progver, peername);
+        goto err;
+    }
+    req->prog = program;
+    if (!program->actors) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "RPC Actor not found for program %s %d for %s",
+               program->progname, program->prognum, peername);
+        err = SYSTEM_ERR;
+        goto err;
+    }
+
+    if ((req->procnum < 0) || (req->procnum >= program->numactors)) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC Program procedure not"
+               " available for procedure %d in %s for  %s",
+               req->procnum, program->progname, peername);
+        err = PROC_UNAVAIL;
+        goto err;
+    }
+
+    actor = &program->actors[req->procnum];
+    if (!actor->actor) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC Program procedure not"
+               " available for procedure %d in %s for %s",
+               req->procnum, program->progname, peername);
+        err = PROC_UNAVAIL;
+        actor = NULL;
+        goto err;
+    }
+
+    req->ownthread = program->ownthread;
+    req->synctask = program->synctask;
+
+    err = SUCCESS;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s",
+           program->progname, actor->procname, peername);
 err:
-        if (req)
-                req->rpc_err = err;
+    if (req)
+        req->rpc_err = err;
 
-        return actor;
+    return actor;
 }
 
-
 /* this procedure can only pass 4 arguments to registered notifyfn. To send more
  * arguments call wrapper->notify directly.
  */
 static void
-rpcsvc_program_notify (rpcsvc_listener_t *listener, rpcsvc_event_t event,
-                       void *data)
+rpcsvc_program_notify(rpcsvc_listener_t *listener, rpcsvc_event_t event,
+                      void *data)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
 
-        if (!listener) {
-                goto out;
-        }
+    if (!listener) {
+        goto out;
+    }
 
-        list_for_each_entry (wrapper, &listener->svc->notify, list) {
-                if (wrapper->notify) {
-                        wrapper->notify (listener->svc,
-                                         wrapper->data,
-                                         event, data);
-                }
+    list_for_each_entry(wrapper, &listener->svc->notify, list)
+    {
+        if (wrapper->notify) {
+            wrapper->notify(listener->svc, wrapper->data, event, data);
         }
+    }
 
 out:
-        return;
+    return;
 }
 
-
 static int
-rpcsvc_accept (rpcsvc_t *svc, rpc_transport_t *listen_trans,
-               rpc_transport_t *new_trans)
+rpcsvc_accept(rpcsvc_t *svc, rpc_transport_t *listen_trans,
+              rpc_transport_t *new_trans)
 {
-        rpcsvc_listener_t *listener = NULL;
-        int32_t            ret      = -1;
+    rpcsvc_listener_t *listener = NULL;
+    int32_t ret = -1;
 
-        listener = rpcsvc_get_listener (svc, -1, listen_trans);
-        if (listener == NULL) {
-                goto out;
-        }
+    listener = rpcsvc_get_listener(svc, -1, listen_trans);
+    if (listener == NULL) {
+        goto out;
+    }
 
-        rpcsvc_program_notify (listener, RPCSVC_EVENT_ACCEPT, new_trans);
-        ret = 0;
+    rpcsvc_program_notify(listener, RPCSVC_EVENT_ACCEPT, new_trans);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-rpcsvc_request_destroy (rpcsvc_request_t *req)
+rpcsvc_request_destroy(rpcsvc_request_t *req)
 {
-        if (!req) {
-                goto out;
-        }
+    if (!req) {
+        goto out;
+    }
 
-        if (req->iobref) {
-                iobref_unref (req->iobref);
-        }
+    if (req->iobref) {
+        iobref_unref(req->iobref);
+    }
 
-        /* This marks the "end" of an RPC request. Reply is
-           completely written to the socket and is on the way
-           to the client. It is time to decrement the
-           outstanding request counter by 1.
-        */
-        if (req->prognum) //Only for initialized requests
-                rpcsvc_request_outstanding (req, -1);
+    /* This marks the "end" of an RPC request. Reply is
+       completely written to the socket and is on the way
+       to the client. It is time to decrement the
+       outstanding request counter by 1.
+    */
+    if (req->prognum)  // Only for initialized requests
+        rpcsvc_request_outstanding(req, -1);
 
-        rpc_transport_unref (req->trans);
+    rpc_transport_unref(req->trans);
 
-	GF_FREE (req->auxgidlarge);
+    GF_FREE(req->auxgidlarge);
 
-        mem_put (req);
+    mem_put(req);
 
 out:
-        return;
+    return;
 }
 
-
 rpcsvc_request_t *
-rpcsvc_request_init (rpcsvc_t *svc, rpc_transport_t *trans,
-                     struct rpc_msg *callmsg,
-                     struct iovec progmsg, rpc_transport_pollin_t *msg,
-                     rpcsvc_request_t *req)
+rpcsvc_request_init(rpcsvc_t *svc, rpc_transport_t *trans,
+                    struct rpc_msg *callmsg, struct iovec progmsg,
+                    rpc_transport_pollin_t *msg, rpcsvc_request_t *req)
 {
-        int i = 0;
-
-        if ((!trans) || (!callmsg)|| (!req) || (!msg))
-                return NULL;
+    int i = 0;
 
-        /* We start a RPC request as always denied. */
-        req->rpc_status = MSG_DENIED;
-        req->xid = rpc_call_xid (callmsg);
-        req->prognum = rpc_call_program (callmsg);
-        req->progver = rpc_call_progver (callmsg);
-        req->procnum = rpc_call_progproc (callmsg);
-        req->trans = rpc_transport_ref (trans);
-        req->count = msg->count;
-        req->msg[0] = progmsg;
-        req->iobref = iobref_ref (msg->iobref);
-        if (msg->vectored) {
-                /* msg->vector[MAX_IOVEC] is defined in structure. prevent a
-                   out of bound access */
-                for (i = 1; i < min (msg->count, MAX_IOVEC); i++) {
-                        req->msg[i] = msg->vector[i];
-                }
-        }
-
-        req->svc = svc;
-        req->trans_private = msg->private;
-
-        INIT_LIST_HEAD (&req->txlist);
-        INIT_LIST_HEAD (&req->request_list);
-        req->payloadsize = 0;
+    if ((!trans) || (!callmsg) || (!req) || (!msg))
+        return NULL;
 
-        /* By this time, the data bytes for the auth scheme would have already
-         * been copied into the required sections of the req structure,
-         * we just need to fill in the meta-data about it now.
-         */
-        rpcsvc_auth_request_init (req, callmsg);
-        return req;
+    /* We start a RPC request as always denied. */
+    req->rpc_status = MSG_DENIED;
+    req->xid = rpc_call_xid(callmsg);
+    req->prognum = rpc_call_program(callmsg);
+    req->progver = rpc_call_progver(callmsg);
+    req->procnum = rpc_call_progproc(callmsg);
+    req->trans = rpc_transport_ref(trans);
+    req->count = msg->count;
+    req->msg[0] = progmsg;
+    req->iobref = iobref_ref(msg->iobref);
+    if (msg->vectored) {
+        /* msg->vector[MAX_IOVEC] is defined in structure. prevent a
+           out of bound access */
+        for (i = 1; i < min(msg->count, MAX_IOVEC); i++) {
+            req->msg[i] = msg->vector[i];
+        }
+    }
+
+    req->svc = svc;
+    req->trans_private = msg->private;
+
+    INIT_LIST_HEAD(&req->txlist);
+    INIT_LIST_HEAD(&req->request_list);
+    req->payloadsize = 0;
+
+    /* By this time, the data bytes for the auth scheme would have already
+     * been copied into the required sections of the req structure,
+     * we just need to fill in the meta-data about it now.
+     */
+    rpcsvc_auth_request_init(req, callmsg);
+    return req;
 }
 
-
 rpcsvc_request_t *
-rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans,
-                       rpc_transport_pollin_t *msg)
+rpcsvc_request_create(rpcsvc_t *svc, rpc_transport_t *trans,
+                      rpc_transport_pollin_t *msg)
 {
-        char                    *msgbuf = NULL;
-        struct rpc_msg          rpcmsg;
-        struct iovec            progmsg;        /* RPC Program payload */
-        rpcsvc_request_t        *req    = NULL;
-        size_t                  msglen  = 0;
-        int                     ret     = -1;
-
-        if (!svc || !trans || !svc->rxpool)
-                return NULL;
-
-        /* We need to allocate the request before actually calling
-         * rpcsvc_request_init on the request so that we, can fill the auth
-         * data directly into the request structure from the message iobuf.
-         * This avoids a need to keep a temp buffer into which the auth data
-         * would've been copied otherwise.
-         */
-        rpcsvc_alloc_request (svc, req);
-        if (!req) {
-                goto err;
-        }
-
-        msgbuf = msg->vector[0].iov_base;
-        msglen = msg->vector[0].iov_len;
-
-        ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg,
-                               req->cred.authdata,req->verf.authdata);
-
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                req->trans = rpc_transport_ref (trans);
-                req->svc = svc;
-                goto err;
-        }
-
-        ret = -1;
-        rpcsvc_request_init (svc, trans, &rpcmsg, progmsg, msg, req);
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "received rpc-message "
-		"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-		"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                "from rpc-transport (%s)", rpc_call_xid (&rpcmsg),
-                rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                trans->name);
-
-        /* We just received a new request from the wire. Account for
-           it in the outsanding request counter to make sure we don't
-           ingest too many concurrent requests from the same client.
-        */
-        if (req->prognum) //Only for initialized requests
-                ret = rpcsvc_request_outstanding (req, +1);
-
-        if (rpc_call_rpcvers (&rpcmsg) != 2) {
-                /* LOG- TODO: print rpc version, also print the peerinfo
-                   from transport */
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC version not supported "
-			"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-			"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-			"from trans (%s)", rpc_call_xid (&rpcmsg),
-                        rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                        rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                        trans->name);
-                rpcsvc_request_seterr (req, RPC_MISMATCH);
-                goto err;
-        }
-
-        ret = rpcsvc_authenticate (req);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                /* No need to set auth_err, that is the responsibility of
-                 * the authentication handler since only that know what exact
-                 * error happened.
-                 */
-                rpcsvc_request_seterr (req, AUTH_ERROR);
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "auth failed on request. "
-			"(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", "
-			"ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") "
-                        "from trans (%s)", rpc_call_xid (&rpcmsg),
-                        rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),
-                        rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),
-                        trans->name);
-                ret = -1;
-                goto err;
-        }
+    char *msgbuf = NULL;
+    struct rpc_msg rpcmsg;
+    struct iovec progmsg; /* RPC Program payload */
+    rpcsvc_request_t *req = NULL;
+    size_t msglen = 0;
+    int ret = -1;
 
+    if (!svc || !trans || !svc->rxpool)
+        return NULL;
 
-        /* If the error is not RPC_MISMATCH, we consider the call as accepted
-         * since we are not handling authentication failures for now.
+    /* We need to allocate the request before actually calling
+     * rpcsvc_request_init on the request so that we, can fill the auth
+     * data directly into the request structure from the message iobuf.
+     * This avoids a need to keep a temp buffer into which the auth data
+     * would've been copied otherwise.
+     */
+    rpcsvc_alloc_request(svc, req);
+    if (!req) {
+        goto err;
+    }
+
+    msgbuf = msg->vector[0].iov_base;
+    msglen = msg->vector[0].iov_len;
+
+    ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, req->cred.authdata,
+                          req->verf.authdata);
+
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        req->trans = rpc_transport_ref(trans);
+        req->svc = svc;
+        goto err;
+    }
+
+    ret = -1;
+    rpcsvc_request_init(svc, trans, &rpcmsg, progmsg, msg, req);
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "received rpc-message "
+           "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+           ", Program: %" GF_PRI_RPC_PROG_ID
+           ", "
+           "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+           ") "
+           "from rpc-transport (%s)",
+           rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+           rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+           rpc_call_progproc(&rpcmsg), trans->name);
+
+    /* We just received a new request from the wire. Account for
+       it in the outsanding request counter to make sure we don't
+       ingest too many concurrent requests from the same client.
+    */
+    if (req->prognum)  // Only for initialized requests
+        ret = rpcsvc_request_outstanding(req, +1);
+
+    if (rpc_call_rpcvers(&rpcmsg) != 2) {
+        /* LOG- TODO: print rpc version, also print the peerinfo
+           from transport */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "RPC version not supported "
+               "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+               ", Program: %" GF_PRI_RPC_PROG_ID
+               ", "
+               "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+               ") "
+               "from trans (%s)",
+               rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+               rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+               rpc_call_progproc(&rpcmsg), trans->name);
+        rpcsvc_request_seterr(req, RPC_MISMATCH);
+        goto err;
+    }
+
+    ret = rpcsvc_authenticate(req);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        /* No need to set auth_err, that is the responsibility of
+         * the authentication handler since only that know what exact
+         * error happened.
          */
-        req->rpc_status = MSG_ACCEPTED;
-        req->reply = NULL;
-        ret = 0;
+        rpcsvc_request_seterr(req, AUTH_ERROR);
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "auth failed on request. "
+               "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION
+               ", Program: %" GF_PRI_RPC_PROG_ID
+               ", "
+               "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC
+               ") "
+               "from trans (%s)",
+               rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg),
+               rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg),
+               rpc_call_progproc(&rpcmsg), trans->name);
+        ret = -1;
+        goto err;
+    }
+
+    /* If the error is not RPC_MISMATCH, we consider the call as accepted
+     * since we are not handling authentication failures for now.
+     */
+    req->rpc_status = MSG_ACCEPTED;
+    req->reply = NULL;
+    ret = 0;
 err:
-        if (ret == -1) {
-                ret = rpcsvc_error_reply (req);
-                if (ret)
-                        gf_log ("rpcsvc", GF_LOG_WARNING,
-                                "failed to queue error reply");
-                req = NULL;
-        }
+    if (ret == -1) {
+        ret = rpcsvc_error_reply(req);
+        if (ret)
+            gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply");
+        req = NULL;
+    }
 
-        return req;
+    return req;
 }
 
-
 int
-rpcsvc_check_and_reply_error (int ret, call_frame_t *frame, void *opaque)
+rpcsvc_check_and_reply_error(int ret, call_frame_t *frame, void *opaque)
 {
-        rpcsvc_request_t  *req = NULL;
+    rpcsvc_request_t *req = NULL;
+
+    req = opaque;
 
-        req = opaque;
+    if (ret)
+        gf_log("rpcsvc", GF_LOG_ERROR,
+               "rpc actor (%d:%d:%d) failed to complete successfully",
+               req->prognum, req->progver, req->procnum);
 
+    if (ret == RPCSVC_ACTOR_ERROR) {
+        ret = rpcsvc_error_reply(req);
         if (ret)
-                gf_log ("rpcsvc", GF_LOG_ERROR,
-                        "rpc actor (%d:%d:%d) failed to complete successfully",
-                        req->prognum, req->progver, req->procnum);
-
-        if (ret == RPCSVC_ACTOR_ERROR) {
-                ret = rpcsvc_error_reply (req);
-                if (ret)
-                        gf_log ("rpcsvc", GF_LOG_WARNING,
-                                "failed to queue error reply");
-        }
+            gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply");
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-rpcsvc_handle_rpc_call (rpcsvc_t *svc, rpc_transport_t *trans,
-                        rpc_transport_pollin_t *msg)
-{
-        rpcsvc_actor_t         *actor          = NULL;
-        rpcsvc_actor            actor_fn       = NULL;
-        rpcsvc_request_t       *req            = NULL;
-        int                     ret            = -1;
-        uint16_t                port           = 0;
-        gf_boolean_t            is_unix        = _gf_false, empty = _gf_false;
-        gf_boolean_t            unprivileged   = _gf_false;
-        drc_cached_op_t        *reply          = NULL;
-        rpcsvc_drc_globals_t   *drc            = NULL;
-
-        if (!trans || !svc)
-                return -1;
-
-        switch (trans->peerinfo.sockaddr.ss_family) {
+rpcsvc_handle_rpc_call(rpcsvc_t *svc, rpc_transport_t *trans,
+                       rpc_transport_pollin_t *msg)
+{
+    rpcsvc_actor_t *actor = NULL;
+    rpcsvc_actor actor_fn = NULL;
+    rpcsvc_request_t *req = NULL;
+    int ret = -1;
+    uint16_t port = 0;
+    gf_boolean_t is_unix = _gf_false, empty = _gf_false;
+    gf_boolean_t unprivileged = _gf_false;
+    drc_cached_op_t *reply = NULL;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    if (!trans || !svc)
+        return -1;
+
+    switch (trans->peerinfo.sockaddr.ss_family) {
         case AF_INET:
-                port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port;
-                break;
+            port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port;
+            break;
 
         case AF_INET6:
-                port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr)->sin6_port;
-                break;
+            port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr)
+                       ->sin6_port;
+            break;
         case AF_UNIX:
-                is_unix = _gf_true;
-                break;
+            is_unix = _gf_true;
+            break;
         default:
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "invalid address family (%d)",
-                        trans->peerinfo.sockaddr.ss_family);
-                return -1;
-        }
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid address family (%d)",
+                   trans->peerinfo.sockaddr.ss_family);
+            return -1;
+    }
 
+    if (is_unix == _gf_false) {
+        port = ntohs(port);
 
+        gf_log("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port);
 
-        if (is_unix == _gf_false) {
-                port = ntohs (port);
+        if (port >= 1024)
+            unprivileged = _gf_true;
+    }
 
-                gf_log ("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port);
+    req = rpcsvc_request_create(svc, trans, msg);
+    if (!req)
+        goto out;
 
-                if (port >= 1024)
-                        unprivileged = _gf_true;
-        }
+    if (!rpcsvc_request_accepted(req))
+        goto err_reply;
+
+    actor = rpcsvc_program_actor(req);
+    if (!actor)
+        goto err_reply;
+
+    if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) {
+        /* Non-privileged user, fail request */
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Request received from non-"
+               "privileged port. Failing request for %s.",
+               req->trans->peerinfo.identifier);
+        req->rpc_status = MSG_DENIED;
+        req->rpc_err = AUTH_ERROR;
+        req->auth_err = RPCSVC_AUTH_REJECT;
+        goto err_reply;
+    }
 
-        req = rpcsvc_request_create (svc, trans, msg);
-        if (!req)
+    /* DRC */
+    if (rpcsvc_need_drc(req)) {
+        drc = req->svc->drc;
+
+        LOCK(&drc->lock);
+        {
+            reply = rpcsvc_drc_lookup(req);
+
+            /* retransmission of completed request, send cached reply */
+            if (reply && reply->state == DRC_OP_CACHED) {
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "duplicate request:"
+                       " XID: 0x%x",
+                       req->xid);
+                ret = rpcsvc_send_cached_reply(req, reply);
+                drc->cache_hits++;
+                UNLOCK(&drc->lock);
+                goto out;
+
+            } /* retransmitted request, original op in transit, drop it */
+            else if (reply && reply->state == DRC_OP_IN_TRANSIT) {
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "op in transit,"
+                       " discarding. XID: 0x%x",
+                       req->xid);
+                ret = 0;
+                drc->intransit_hits++;
+                rpcsvc_request_destroy(req);
+                UNLOCK(&drc->lock);
                 goto out;
 
-        if (!rpcsvc_request_accepted (req))
-                goto err_reply;
-
-        actor = rpcsvc_program_actor (req);
-        if (!actor)
-                goto err_reply;
-
-        if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) {
-                        /* Non-privileged user, fail request */
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "Request received from non-"
-                                "privileged port. Failing request for %s.",
-                                req->trans->peerinfo.identifier);
-                        req->rpc_status = MSG_DENIED;
-                        req->rpc_err = AUTH_ERROR;
-                        req->auth_err = RPCSVC_AUTH_REJECT;
-                        goto err_reply;
+            } /* fresh request, cache it as in-transit and proceed */
+            else {
+                ret = rpcsvc_cache_request(req);
+            }
         }
+        UNLOCK(&drc->lock);
+    }
 
-        /* DRC */
-        if (rpcsvc_need_drc (req)) {
-                drc = req->svc->drc;
-
-                LOCK (&drc->lock);
-                {
-                        reply = rpcsvc_drc_lookup (req);
-
-                        /* retransmission of completed request, send cached reply */
-                        if (reply && reply->state == DRC_OP_CACHED) {
-                                gf_log (GF_RPCSVC, GF_LOG_INFO, "duplicate request:"
-                                        " XID: 0x%x", req->xid);
-                                ret = rpcsvc_send_cached_reply (req, reply);
-                                drc->cache_hits++;
-                                UNLOCK (&drc->lock);
-                                goto out;
-
-                        } /* retransmitted request, original op in transit, drop it */
-                        else if (reply && reply->state == DRC_OP_IN_TRANSIT) {
-                                gf_log (GF_RPCSVC, GF_LOG_INFO, "op in transit,"
-                                        " discarding. XID: 0x%x", req->xid);
-                                ret = 0;
-                                drc->intransit_hits++;
-                                rpcsvc_request_destroy (req);
-                                UNLOCK (&drc->lock);
-                                goto out;
-
-                        } /* fresh request, cache it as in-transit and proceed */
-                        else {
-                                ret = rpcsvc_cache_request (req);
-                        }
-                }
-                UNLOCK (&drc->lock);
+    if (req->rpc_err == SUCCESS) {
+        /* Before going to xlator code, set the THIS properly */
+        THIS = svc->xl;
+
+        actor_fn = actor->actor;
+
+        if (!actor_fn) {
+            rpcsvc_request_seterr(req, PROC_UNAVAIL);
+            /* LOG TODO: print more info about procnum,
+               prognum etc, also print transport info */
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "No vectored handler present");
+            ret = RPCSVC_ACTOR_ERROR;
+            goto err_reply;
         }
 
-        if (req->rpc_err == SUCCESS) {
-                /* Before going to xlator code, set the THIS properly */
-                THIS = svc->xl;
+        if (req->synctask) {
+            ret = synctask_new(THIS->ctx->env, (synctask_fn_t)actor_fn,
+                               rpcsvc_check_and_reply_error, NULL, req);
+        } else if (req->ownthread) {
+            pthread_mutex_lock(&req->prog->queue_lock);
+            {
+                empty = list_empty(&req->prog->request_queue);
 
-                actor_fn = actor->actor;
+                list_add_tail(&req->request_list, &req->prog->request_queue);
 
-                if (!actor_fn) {
-                        rpcsvc_request_seterr (req, PROC_UNAVAIL);
-                        /* LOG TODO: print more info about procnum,
-                           prognum etc, also print transport info */
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "No vectored handler present");
-                        ret = RPCSVC_ACTOR_ERROR;
-                        goto err_reply;
-                }
+                if (empty)
+                    pthread_cond_signal(&req->prog->queue_cond);
+            }
+            pthread_mutex_unlock(&req->prog->queue_lock);
 
-                if (req->synctask) {
-                        ret = synctask_new (THIS->ctx->env,
-                                            (synctask_fn_t) actor_fn,
-                                            rpcsvc_check_and_reply_error, NULL,
-                                            req);
-                } else if (req->ownthread) {
-                        pthread_mutex_lock (&req->prog->queue_lock);
-                        {
-                                empty = list_empty (&req->prog->request_queue);
-
-                                list_add_tail (&req->request_list,
-                                               &req->prog->request_queue);
-
-                                if (empty)
-                                        pthread_cond_signal (&req->prog->queue_cond);
-                        }
-                        pthread_mutex_unlock (&req->prog->queue_lock);
-
-                        ret = 0;
-                } else {
-                        ret = actor_fn (req);
-                }
+            ret = 0;
+        } else {
+            ret = actor_fn(req);
         }
+    }
 
 err_reply:
 
-        ret = rpcsvc_check_and_reply_error (ret, NULL, req);
-        /* No need to propagate error beyond this function since the reply
-         * has now been queued. */
-        ret = 0;
+    ret = rpcsvc_check_and_reply_error(ret, NULL, req);
+    /* No need to propagate error beyond this function since the reply
+     * has now been queued. */
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_handle_disconnect (rpcsvc_t *svc, rpc_transport_t *trans)
+rpcsvc_handle_disconnect(rpcsvc_t *svc, rpc_transport_t *trans)
 {
-        rpcsvc_event_t           event;
-        rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper;
-        int32_t                  ret      = -1, i = 0, wrapper_count = 0;
-        rpcsvc_listener_t       *listener = NULL;
-
-        event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD
-                : RPCSVC_EVENT_DISCONNECT;
+    rpcsvc_event_t event;
+    rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper;
+    int32_t ret = -1, i = 0, wrapper_count = 0;
+    rpcsvc_listener_t *listener = NULL;
 
-        pthread_rwlock_rdlock (&svc->rpclock);
-        {
-                if (!svc->notify_count)
-                        goto unlock;
+    event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD
+                                      : RPCSVC_EVENT_DISCONNECT;
 
-                wrappers = GF_CALLOC (svc->notify_count, sizeof (*wrapper),
-                                      gf_common_mt_rpcsvc_wrapper_t);
-                if (!wrappers) {
-                        goto unlock;
-                }
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        if (!svc->notify_count)
+            goto unlock;
 
-                list_for_each_entry (wrapper, &svc->notify, list) {
-                        if (wrapper->notify) {
-                                wrappers[i++] = *wrapper;
-                        }
-                }
+        wrappers = GF_CALLOC(svc->notify_count, sizeof(*wrapper),
+                             gf_common_mt_rpcsvc_wrapper_t);
+        if (!wrappers) {
+            goto unlock;
+        }
 
-                wrapper_count = i;
+        list_for_each_entry(wrapper, &svc->notify, list)
+        {
+            if (wrapper->notify) {
+                wrappers[i++] = *wrapper;
+            }
         }
-unlock:
-        pthread_rwlock_unlock (&svc->rpclock);
 
-        if (wrappers) {
-                for (i = 0; i < wrapper_count; i++) {
-                        wrappers[i].notify (svc, wrappers[i].data,
-                                            event, trans);
-                }
+        wrapper_count = i;
+    }
+unlock:
+    pthread_rwlock_unlock(&svc->rpclock);
 
-                GF_FREE (wrappers);
+    if (wrappers) {
+        for (i = 0; i < wrapper_count; i++) {
+            wrappers[i].notify(svc, wrappers[i].data, event, trans);
         }
 
-        if (event == RPCSVC_EVENT_LISTENER_DEAD) {
-                listener = rpcsvc_get_listener (svc, -1, trans->listener);
-                rpcsvc_listener_destroy (listener);
-        }
+        GF_FREE(wrappers);
+    }
 
-        return ret;
-}
+    if (event == RPCSVC_EVENT_LISTENER_DEAD) {
+        listener = rpcsvc_get_listener(svc, -1, trans->listener);
+        rpcsvc_listener_destroy(listener);
+    }
 
+    return ret;
+}
 
 int
-rpcsvc_notify (rpc_transport_t *trans, void *mydata,
-               rpc_transport_event_t event, void *data, ...)
+rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event,
+              void *data, ...)
 {
-        int                     ret       = -1;
-        rpc_transport_pollin_t *msg       = NULL;
-        rpc_transport_t        *new_trans = NULL;
-        rpcsvc_t               *svc       = NULL;
-        rpcsvc_listener_t      *listener  = NULL;
+    int ret = -1;
+    rpc_transport_pollin_t *msg = NULL;
+    rpc_transport_t *new_trans = NULL;
+    rpcsvc_t *svc = NULL;
+    rpcsvc_listener_t *listener = NULL;
 
-        svc = mydata;
-        if (svc == NULL) {
-                goto out;
-        }
+    svc = mydata;
+    if (svc == NULL) {
+        goto out;
+    }
 
-        switch (event) {
+    switch (event) {
         case RPC_TRANSPORT_ACCEPT:
-                new_trans = data;
-                ret = rpcsvc_accept (svc, trans, new_trans);
-                break;
+            new_trans = data;
+            ret = rpcsvc_accept(svc, trans, new_trans);
+            break;
 
         case RPC_TRANSPORT_DISCONNECT:
-                ret = rpcsvc_handle_disconnect (svc, trans);
-                break;
+            ret = rpcsvc_handle_disconnect(svc, trans);
+            break;
 
         case RPC_TRANSPORT_MSG_RECEIVED:
-                msg = data;
-                ret = rpcsvc_handle_rpc_call (svc, trans, msg);
-                break;
+            msg = data;
+            ret = rpcsvc_handle_rpc_call(svc, trans, msg);
+            break;
 
         case RPC_TRANSPORT_MSG_SENT:
-                ret = 0;
-                break;
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_CONNECT:
-                /* do nothing, no need for rpcsvc to handle this, client should
-                 * handle this event
-                 */
-                /* print info about transport too : LOG TODO */
-                gf_log ("rpcsvc", GF_LOG_CRITICAL,
-                        "got CONNECT event, which should have not come");
-                ret = 0;
-                break;
+            /* do nothing, no need for rpcsvc to handle this, client should
+             * handle this event
+             */
+            /* print info about transport too : LOG TODO */
+            gf_log("rpcsvc", GF_LOG_CRITICAL,
+                   "got CONNECT event, which should have not come");
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_CLEANUP:
-                listener = rpcsvc_get_listener (svc, -1, trans->listener);
-                if (listener == NULL) {
-                        goto out;
-                }
+            listener = rpcsvc_get_listener(svc, -1, trans->listener);
+            if (listener == NULL) {
+                goto out;
+            }
 
-                rpcsvc_program_notify (listener, RPCSVC_EVENT_TRANSPORT_DESTROY,
-                                       trans);
-                ret = 0;
-                break;
+            rpcsvc_program_notify(listener, RPCSVC_EVENT_TRANSPORT_DESTROY,
+                                  trans);
+            ret = 0;
+            break;
 
         case RPC_TRANSPORT_MAP_XID_REQUEST:
-                /* FIXME: think about this later */
-                gf_log ("rpcsvc", GF_LOG_CRITICAL,
-                        "got MAP_XID event, which should have not come");
-                ret = 0;
-                break;
-        }
+            /* FIXME: think about this later */
+            gf_log("rpcsvc", GF_LOG_CRITICAL,
+                   "got MAP_XID event, which should have not come");
+            ret = 0;
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Given the RPC reply structure and the payload handed by the RPC program,
  * encode the RPC record header into the buffer pointed by recordstart.
  */
 struct iovec
-rpcsvc_record_build_header (char *recordstart, size_t rlen,
-                            struct rpc_msg reply, size_t payload)
-{
-        struct iovec    replyhdr;
-        struct iovec    txrecord = {0, 0};
-        size_t          fraglen = 0;
-        int             ret = -1;
-
-        /* After leaving aside the 4 bytes for the fragment header, lets
-         * encode the RPC reply structure into the buffer given to us.
-         */
-        ret = rpc_reply_to_xdr (&reply, recordstart, rlen, &replyhdr);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply");
-                goto err;
-        }
-
-        fraglen = payload + replyhdr.iov_len;
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Reply fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, replyhdr.iov_len);
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = replyhdr.iov_len;
+rpcsvc_record_build_header(char *recordstart, size_t rlen, struct rpc_msg reply,
+                           size_t payload)
+{
+    struct iovec replyhdr;
+    struct iovec txrecord = {0, 0};
+    size_t fraglen = 0;
+    int ret = -1;
+
+    /* After leaving aside the 4 bytes for the fragment header, lets
+     * encode the RPC reply structure into the buffer given to us.
+     */
+    ret = rpc_reply_to_xdr(&reply, recordstart, rlen, &replyhdr);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply");
+        goto err;
+    }
+
+    fraglen = payload + replyhdr.iov_len;
+    gf_log(GF_RPCSVC, GF_LOG_TRACE,
+           "Reply fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, replyhdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = replyhdr.iov_len;
 err:
-        return txrecord;
+    return txrecord;
 }
 
 static uint32_t
-rpc_callback_new_callid (struct rpc_transport *trans)
+rpc_callback_new_callid(struct rpc_transport *trans)
 {
-        uint32_t callid = 0;
+    uint32_t callid = 0;
 
-        pthread_mutex_lock (&trans->lock);
-        {
-                callid = ++trans->xid;
-        }
-        pthread_mutex_unlock (&trans->lock);
+    pthread_mutex_lock(&trans->lock);
+    {
+        callid = ++trans->xid;
+    }
+    pthread_mutex_unlock(&trans->lock);
 
-        return callid;
+    return callid;
 }
 
 int
-rpcsvc_fill_callback (int prognum, int progver, int procnum, int payload,
-                      uint32_t xid, struct rpc_msg *request)
+rpcsvc_fill_callback(int prognum, int progver, int procnum, int payload,
+                     uint32_t xid, struct rpc_msg *request)
 {
-        int   ret          = -1;
+    int ret = -1;
 
-        if (!request) {
-                goto out;
-        }
+    if (!request) {
+        goto out;
+    }
 
-        memset (request, 0, sizeof (*request));
+    memset(request, 0, sizeof(*request));
 
-        request->rm_xid = xid;
-        request->rm_direction = CALL;
+    request->rm_xid = xid;
+    request->rm_direction = CALL;
 
-        request->rm_call.cb_rpcvers = 2;
-        request->rm_call.cb_prog = prognum;
-        request->rm_call.cb_vers = progver;
-        request->rm_call.cb_proc = procnum;
+    request->rm_call.cb_rpcvers = 2;
+    request->rm_call.cb_prog = prognum;
+    request->rm_call.cb_vers = progver;
+    request->rm_call.cb_proc = procnum;
 
-        request->rm_call.cb_cred.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_cred.oa_base   = NULL;
-        request->rm_call.cb_cred.oa_length = 0;
+    request->rm_call.cb_cred.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_cred.oa_base = NULL;
+    request->rm_call.cb_cred.oa_length = 0;
 
-        request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
-        request->rm_call.cb_verf.oa_base = NULL;
-        request->rm_call.cb_verf.oa_length = 0;
+    request->rm_call.cb_verf.oa_flavor = AUTH_NONE;
+    request->rm_call.cb_verf.oa_base = NULL;
+    request->rm_call.cb_verf.oa_length = 0;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 struct iovec
-rpcsvc_callback_build_header (char *recordstart, size_t rlen,
+rpcsvc_callback_build_header(char *recordstart, size_t rlen,
                              struct rpc_msg *request, size_t payload)
 {
-        struct iovec    requesthdr = {0, };
-        struct iovec    txrecord   = {0, 0};
-        int             ret        = -1;
-        size_t          fraglen    = 0;
-
-        ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "Failed to create RPC request");
-                goto out;
-        }
-
-        fraglen = payload + requesthdr.iov_len;
-        gf_log ("rpcsvc", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, "
-                "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len);
-
-        txrecord.iov_base = recordstart;
-
-        /* Remember, this is only the vec for the RPC header and does not
-         * include the payload above. We needed the payload only to calculate
-         * the size of the full fragment. This size is sent in the fragment
-         * header.
-         */
-        txrecord.iov_len = requesthdr.iov_len;
+    struct iovec requesthdr = {
+        0,
+    };
+    struct iovec txrecord = {0, 0};
+    int ret = -1;
+    size_t fraglen = 0;
+
+    ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create RPC request");
+        goto out;
+    }
+
+    fraglen = payload + requesthdr.iov_len;
+    gf_log("rpcsvc", GF_LOG_TRACE,
+           "Request fraglen %zu, payload: %zu, "
+           "rpc hdr: %zu",
+           fraglen, payload, requesthdr.iov_len);
+
+    txrecord.iov_base = recordstart;
+
+    /* Remember, this is only the vec for the RPC header and does not
+     * include the payload above. We needed the payload only to calculate
+     * the size of the full fragment. This size is sent in the fragment
+     * header.
+     */
+    txrecord.iov_len = requesthdr.iov_len;
 
 out:
-        return txrecord;
+    return txrecord;
 }
 
 static struct iobuf *
-rpcsvc_callback_build_record (rpcsvc_t *rpc, int prognum, int progver,
-                              int procnum, size_t payload, u_long xid,
-                              struct iovec *recbuf)
-{
-        struct rpc_msg           request     = {0, };
-        struct iobuf            *request_iob = NULL;
-        char                    *record      = NULL;
-        struct iovec             recordhdr   = {0, };
-        size_t                   pagesize    = 0;
-        size_t                   xdr_size    = 0;
-        int                      ret         = -1;
-
-        if ((!rpc) || (!recbuf)) {
-                goto out;
-        }
-
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        ret = rpcsvc_fill_callback (prognum, progver, procnum, payload, xid,
-                                    &request);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING, "cannot build a rpc-request "
-                        "xid (%lu)", xid);
-                goto out;
-        }
-
-        /* First, try to get a pointer into the buffer which the RPC
-         * layer can use.
-         */
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request);
-
-        request_iob = iobuf_get2 (rpc->ctx->iobuf_pool, (xdr_size + payload));
-        if (!request_iob) {
-                goto out;
-        }
-
-        pagesize = iobuf_pagesize (request_iob);
-
-        record = iobuf_ptr (request_iob);  /* Now we have it. */
-
-        recordhdr = rpcsvc_callback_build_header (record, pagesize, &request,
-                                                  payload);
-
-        if (!recordhdr.iov_base) {
-                gf_log ("rpc-clnt", GF_LOG_ERROR, "Failed to build record "
-                        " header");
-                iobuf_unref (request_iob);
-                request_iob = NULL;
-                recbuf->iov_base = NULL;
-                goto out;
-        }
-
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+rpcsvc_callback_build_record(rpcsvc_t *rpc, int prognum, int progver,
+                             int procnum, size_t payload, u_long xid,
+                             struct iovec *recbuf)
+{
+    struct rpc_msg request = {
+        0,
+    };
+    struct iobuf *request_iob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    size_t xdr_size = 0;
+    int ret = -1;
+
+    if ((!rpc) || (!recbuf)) {
+        goto out;
+    }
+
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpcsvc_fill_callback(prognum, progver, procnum, payload, xid,
+                               &request);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING,
+               "cannot build a rpc-request "
+               "xid (%lu)",
+               xid);
+        goto out;
+    }
+
+    /* First, try to get a pointer into the buffer which the RPC
+     * layer can use.
+     */
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request);
+
+    request_iob = iobuf_get2(rpc->ctx->iobuf_pool, (xdr_size + payload));
+    if (!request_iob) {
+        goto out;
+    }
+
+    pagesize = iobuf_pagesize(request_iob);
+
+    record = iobuf_ptr(request_iob); /* Now we have it. */
+
+    recordhdr = rpcsvc_callback_build_header(record, pagesize, &request,
+                                             payload);
+
+    if (!recordhdr.iov_base) {
+        gf_log("rpc-clnt", GF_LOG_ERROR,
+               "Failed to build record "
+               " header");
+        iobuf_unref(request_iob);
+        request_iob = NULL;
+        recbuf->iov_base = NULL;
+        goto out;
+    }
+
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 
 out:
-        return request_iob;
+    return request_iob;
 }
 
-int rpcsvc_request_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                           rpcsvc_cbk_program_t *prog, int procnum,
-                           void *req, glusterfs_ctx_t *ctx,
-                           xdrproc_t xdrproc)
-{
-        int                     ret         = -1;
-        int                     count       = 0;
-        struct iovec            iov         = {0, };
-        struct iobuf            *iobuf      = NULL;
-        ssize_t                 xdr_size    = 0;
-        struct iobref           *iobref     = NULL;
-
-        if (!req)
-                goto out;
-
-        xdr_size = xdr_sizeof (xdrproc, req);
-
-        iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
-        if (!iobuf)
-                goto out;
-
-        iov.iov_base = iobuf->ptr;
-        iov.iov_len  = iobuf_pagesize (iobuf);
-
-        ret = xdr_serialize_generic (iov, req, xdrproc);
-        if (ret == -1) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to create XDR payload");
-                goto out;
-        }
-        iov.iov_len = ret;
-        count = 1;
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                ret = -1;
-                gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
-                goto out;
-        }
+int
+rpcsvc_request_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                      rpcsvc_cbk_program_t *prog, int procnum, void *req,
+                      glusterfs_ctx_t *ctx, xdrproc_t xdrproc)
+{
+    int ret = -1;
+    int count = 0;
+    struct iovec iov = {
+        0,
+    };
+    struct iobuf *iobuf = NULL;
+    ssize_t xdr_size = 0;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        goto out;
+
+    xdr_size = xdr_sizeof(xdrproc, req);
+
+    iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size);
+    if (!iobuf)
+        goto out;
+
+    iov.iov_base = iobuf->ptr;
+    iov.iov_len = iobuf_pagesize(iobuf);
+
+    ret = xdr_serialize_generic(iov, req, xdrproc);
+    if (ret == -1) {
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload");
+        goto out;
+    }
+    iov.iov_len = ret;
+    count = 1;
+
+    iobref = iobref_new();
+    if (!iobref) {
+        ret = -1;
+        gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
+        goto out;
+    }
 
-        iobref_add (iobref, iobuf);
+    iobref_add(iobref, iobuf);
 
-        ret = rpcsvc_callback_submit (rpc, trans, prog, procnum,
-                                      &iov, count, iobref);
+    ret = rpcsvc_callback_submit(rpc, trans, prog, procnum, &iov, count,
+                                 iobref);
 
 out:
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        if (iobref)
-                iobref_unref (iobref);
+    if (iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans,
-                        rpcsvc_cbk_program_t *prog, int procnum,
-                        struct iovec *proghdr, int proghdrcount,
-                        struct iobref *iobref)
-{
-        struct iobuf          *request_iob = NULL;
-        struct iovec           rpchdr      = {0,};
-        rpc_transport_req_t    req;
-        int                    ret         = -1;
-        int                    proglen     = 0;
-        uint32_t               xid         = 0;
-        gf_boolean_t           new_iobref  = _gf_false;
-
-        if (!rpc) {
-                goto out;
-        }
-
-        memset (&req, 0, sizeof (req));
-
-        if (proghdr) {
-                proglen += iov_length (proghdr, proghdrcount);
-        }
-
-        xid = rpc_callback_new_callid (trans);
-
-        request_iob = rpcsvc_callback_build_record (rpc, prog->prognum,
-                                                    prog->progver, procnum,
-                                                    proglen, xid, &rpchdr);
-        if (!request_iob) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "cannot build rpc-record");
-                goto out;
-        }
+rpcsvc_callback_submit(rpcsvc_t *rpc, rpc_transport_t *trans,
+                       rpcsvc_cbk_program_t *prog, int procnum,
+                       struct iovec *proghdr, int proghdrcount,
+                       struct iobref *iobref)
+{
+    struct iobuf *request_iob = NULL;
+    struct iovec rpchdr = {
+        0,
+    };
+    rpc_transport_req_t req;
+    int ret = -1;
+    int proglen = 0;
+    uint32_t xid = 0;
+    gf_boolean_t new_iobref = _gf_false;
+
+    if (!rpc) {
+        goto out;
+    }
+
+    memset(&req, 0, sizeof(req));
+
+    if (proghdr) {
+        proglen += iov_length(proghdr, proghdrcount);
+    }
+
+    xid = rpc_callback_new_callid(trans);
+
+    request_iob = rpcsvc_callback_build_record(
+        rpc, prog->prognum, prog->progver, procnum, proglen, xid, &rpchdr);
+    if (!request_iob) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "cannot build rpc-record");
+        goto out;
+    }
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
-                        goto out;
-                }
-                new_iobref = 1;
+            gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref");
+            goto out;
         }
+        new_iobref = 1;
+    }
 
-        iobref_add (iobref, request_iob);
+    iobref_add(iobref, request_iob);
 
-        req.msg.rpchdr = &rpchdr;
-        req.msg.rpchdrcount = 1;
-        req.msg.proghdr = proghdr;
-        req.msg.proghdrcount = proghdrcount;
-        req.msg.iobref = iobref;
+    req.msg.rpchdr = &rpchdr;
+    req.msg.rpchdrcount = 1;
+    req.msg.proghdr = proghdr;
+    req.msg.proghdrcount = proghdrcount;
+    req.msg.iobref = iobref;
 
-        ret = rpc_transport_submit_request (trans, &req);
-        if (ret == -1) {
-                gf_log ("rpcsvc", GF_LOG_WARNING,
-                        "transmission of rpc-request failed");
-                goto out;
-        }
+    ret = rpc_transport_submit_request(trans, &req);
+    if (ret == -1) {
+        gf_log("rpcsvc", GF_LOG_WARNING, "transmission of rpc-request failed");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        iobuf_unref (request_iob);
+    iobuf_unref(request_iob);
 
-        if (new_iobref)
-               iobref_unref (iobref);
+    if (new_iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_transport_submit (rpc_transport_t *trans, struct iovec *rpchdr,
-                         int rpchdrcount, struct iovec *proghdr,
-                         int proghdrcount, struct iovec *progpayload,
-                         int progpayloadcount, struct iobref *iobref,
-                         void *priv)
-{
-        int                   ret   = -1;
-        rpc_transport_reply_t reply = {{0, }};
-
-        if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) {
-                goto out;
-        }
-
-        reply.msg.rpchdr = rpchdr;
-        reply.msg.rpchdrcount = rpchdrcount;
-        reply.msg.proghdr = proghdr;
-        reply.msg.proghdrcount = proghdrcount;
-        reply.msg.progpayload = progpayload;
-        reply.msg.progpayloadcount = progpayloadcount;
-        reply.msg.iobref = iobref;
-        reply.private = priv;
-
-        ret = rpc_transport_submit_reply (trans, &reply);
+rpcsvc_transport_submit(rpc_transport_t *trans, struct iovec *rpchdr,
+                        int rpchdrcount, struct iovec *proghdr,
+                        int proghdrcount, struct iovec *progpayload,
+                        int progpayloadcount, struct iobref *iobref, void *priv)
+{
+    int ret = -1;
+    rpc_transport_reply_t reply = {{
+        0,
+    }};
+
+    if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) {
+        goto out;
+    }
+
+    reply.msg.rpchdr = rpchdr;
+    reply.msg.rpchdrcount = rpchdrcount;
+    reply.msg.proghdr = proghdr;
+    reply.msg.proghdrcount = proghdrcount;
+    reply.msg.progpayload = progpayload;
+    reply.msg.progpayloadcount = progpayloadcount;
+    reply.msg.iobref = iobref;
+    reply.private = priv;
+
+    ret = rpc_transport_submit_reply(trans, &reply);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_fill_reply (rpcsvc_request_t *req, struct rpc_msg *reply)
-{
-        int                      ret  = -1;
-        rpcsvc_program_t        *prog = NULL;
-        if ((!req) || (!reply))
-                goto out;
-
-        ret = 0;
-        rpc_fill_empty_reply (reply, req->xid);
-        if (req->rpc_status == MSG_DENIED) {
-                rpc_fill_denied_reply (reply, req->rpc_err, req->auth_err);
-                goto out;
-        }
-
-        prog = rpcsvc_request_program (req);
-
-        if (req->rpc_status == MSG_ACCEPTED)
-                rpc_fill_accepted_reply (reply, req->rpc_err,
-                                         (prog) ? prog->proglowvers : 0,
-                                         (prog) ? prog->proghighvers: 0,
-                                         req->verf.flavour, req->verf.datalen,
-                                         req->verf.authdata);
-        else
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value");
+rpcsvc_fill_reply(rpcsvc_request_t *req, struct rpc_msg *reply)
+{
+    int ret = -1;
+    rpcsvc_program_t *prog = NULL;
+    if ((!req) || (!reply))
+        goto out;
+
+    ret = 0;
+    rpc_fill_empty_reply(reply, req->xid);
+    if (req->rpc_status == MSG_DENIED) {
+        rpc_fill_denied_reply(reply, req->rpc_err, req->auth_err);
+        goto out;
+    }
+
+    prog = rpcsvc_request_program(req);
+
+    if (req->rpc_status == MSG_ACCEPTED)
+        rpc_fill_accepted_reply(
+            reply, req->rpc_err, (prog) ? prog->proglowvers : 0,
+            (prog) ? prog->proghighvers : 0, req->verf.flavour,
+            req->verf.datalen, req->verf.authdata);
+    else
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value");
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Given a request and the reply payload, build a reply and encodes the reply
  * into a record header. This record header is encoded into the vector pointed
  * to be recbuf.
@@ -1224,59 +1225,60 @@ out:
  * we should account for the length of that buffer in the RPC fragment header.
  */
 struct iobuf *
-rpcsvc_record_build_record (rpcsvc_request_t *req, size_t payload,
-                            size_t hdrlen, struct iovec *recbuf)
-{
-        struct rpc_msg          reply;
-        struct iobuf            *replyiob = NULL;
-        char                    *record = NULL;
-        struct iovec            recordhdr = {0, };
-        size_t                  pagesize = 0;
-        size_t                  xdr_size = 0;
-        rpcsvc_t                *svc = NULL;
-        int                     ret = -1;
+rpcsvc_record_build_record(rpcsvc_request_t *req, size_t payload, size_t hdrlen,
+                           struct iovec *recbuf)
+{
+    struct rpc_msg reply;
+    struct iobuf *replyiob = NULL;
+    char *record = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    size_t pagesize = 0;
+    size_t xdr_size = 0;
+    rpcsvc_t *svc = NULL;
+    int ret = -1;
+
+    if ((!req) || (!req->trans) || (!req->svc) || (!recbuf))
+        return NULL;
 
-        if ((!req) || (!req->trans) || (!req->svc) || (!recbuf))
-                return NULL;
+    svc = req->svc;
 
-        svc = req->svc;
+    /* Fill the rpc structure and XDR it into the buffer got above. */
+    ret = rpcsvc_fill_reply(req, &reply);
+    if (ret)
+        goto err_exit;
 
-        /* Fill the rpc structure and XDR it into the buffer got above. */
-        ret = rpcsvc_fill_reply (req, &reply);
-        if (ret)
-                goto err_exit;
+    xdr_size = xdr_sizeof((xdrproc_t)xdr_replymsg, &reply);
 
-        xdr_size = xdr_sizeof ((xdrproc_t)xdr_replymsg, &reply);
+    /* Payload would include 'readv' size etc too, where as
+       that comes as another payload iobuf */
+    replyiob = iobuf_get2(svc->ctx->iobuf_pool, (xdr_size + hdrlen));
+    if (!replyiob) {
+        goto err_exit;
+    }
 
-        /* Payload would include 'readv' size etc too, where as
-           that comes as another payload iobuf */
-        replyiob = iobuf_get2 (svc->ctx->iobuf_pool, (xdr_size + hdrlen));
-        if (!replyiob) {
-                goto err_exit;
-        }
-
-        pagesize = iobuf_pagesize (replyiob);
+    pagesize = iobuf_pagesize(replyiob);
 
-        record = iobuf_ptr (replyiob);  /* Now we have it. */
+    record = iobuf_ptr(replyiob); /* Now we have it. */
 
-        recordhdr = rpcsvc_record_build_header (record, pagesize, reply,
-                                                payload);
-        if (!recordhdr.iov_base) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to build record "
-                        " header");
-                iobuf_unref (replyiob);
-                replyiob = NULL;
-                recbuf->iov_base = NULL;
-                goto err_exit;
-        }
+    recordhdr = rpcsvc_record_build_header(record, pagesize, reply, payload);
+    if (!recordhdr.iov_base) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to build record "
+               " header");
+        iobuf_unref(replyiob);
+        replyiob = NULL;
+        recbuf->iov_base = NULL;
+        goto err_exit;
+    }
 
-        recbuf->iov_base = recordhdr.iov_base;
-        recbuf->iov_len = recordhdr.iov_len;
+    recbuf->iov_base = recordhdr.iov_base;
+    recbuf->iov_len = recordhdr.iov_len;
 err_exit:
-        return replyiob;
+    return replyiob;
 }
 
-
 /*
  * The function to submit a program message to the RPC service.
  * This message is added to the transmission queue of the
@@ -1304,331 +1306,336 @@ err_exit:
  */
 
 int
-rpcsvc_submit_generic (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref)
-{
-        int                     ret        = -1, i = 0;
-        struct iobuf           *replyiob   = NULL;
-        struct iovec            recordhdr  = {0, };
-        rpc_transport_t        *trans      = NULL;
-        size_t                  msglen     = 0;
-        size_t                  hdrlen     = 0;
-        char                    new_iobref = 0;
-        rpcsvc_drc_globals_t   *drc        = NULL;
-
-        if ((!req) || (!req->trans))
-                return -1;
-
-        trans = req->trans;
-
-        for (i = 0; i < hdrcount; i++) {
-                msglen += proghdr[i].iov_len;
-        }
-
-        for (i = 0; i < payloadcount; i++) {
-                msglen += payload[i].iov_len;
-        }
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen);
-
-        /* Build the buffer containing the encoded RPC reply. */
-        replyiob = rpcsvc_record_build_record (req, msglen, hdrlen, &recordhdr);
-        if (!replyiob) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,"Reply record creation failed");
-                goto disconnect_exit;
-        }
-
+rpcsvc_submit_generic(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref)
+{
+    int ret = -1, i = 0;
+    struct iobuf *replyiob = NULL;
+    struct iovec recordhdr = {
+        0,
+    };
+    rpc_transport_t *trans = NULL;
+    size_t msglen = 0;
+    size_t hdrlen = 0;
+    char new_iobref = 0;
+    rpcsvc_drc_globals_t *drc = NULL;
+
+    if ((!req) || (!req->trans))
+        return -1;
+
+    trans = req->trans;
+
+    for (i = 0; i < hdrcount; i++) {
+        msglen += proghdr[i].iov_len;
+    }
+
+    for (i = 0; i < payloadcount; i++) {
+        msglen += payload[i].iov_len;
+    }
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen);
+
+    /* Build the buffer containing the encoded RPC reply. */
+    replyiob = rpcsvc_record_build_record(req, msglen, hdrlen, &recordhdr);
+    if (!replyiob) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Reply record creation failed");
+        goto disconnect_exit;
+    }
+
+    if (!iobref) {
+        iobref = iobref_new();
         if (!iobref) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        goto disconnect_exit;
-                }
-
-                new_iobref = 1;
+            goto disconnect_exit;
         }
 
-        iobref_add (iobref, replyiob);
-
-        /* cache the request in the duplicate request cache for appropriate ops */
-        if ((req->reply) && (rpcsvc_need_drc (req))) {
-                drc = req->svc->drc;
+        new_iobref = 1;
+    }
 
-                LOCK (&drc->lock);
-                ret = rpcsvc_cache_reply (req, iobref, &recordhdr, 1,
-                                          proghdr, hdrcount,
-                                          payload, payloadcount);
-                UNLOCK (&drc->lock);
-                if (ret < 0) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                "failed to cache reply");
-                }
-        }
+    iobref_add(iobref, replyiob);
 
-        ret = rpcsvc_transport_submit (trans, &recordhdr, 1, proghdr, hdrcount,
-                                       payload, payloadcount, iobref,
-                                       req->trans_private);
+    /* cache the request in the duplicate request cache for appropriate ops */
+    if ((req->reply) && (rpcsvc_need_drc(req))) {
+        drc = req->svc->drc;
 
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "failed to submit message "
-                        "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to "
-                        "rpc-transport (%s)", req->xid,
-                        req->prog ? req->prog->progname : "(not matched)",
-                        req->prog ? req->prog->progver : 0,
-                        req->procnum, trans ? trans->name : "");
-        } else {
-                gf_log (GF_RPCSVC, GF_LOG_TRACE,
-                        "submitted reply for rpc-message (XID: 0x%x, "
-                        "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport "
-                        "(%s)", req->xid, req->prog ? req->prog->progname: "-",
-                        req->prog ? req->prog->progver : 0,
-                        req->procnum, trans ? trans->name : "");
-        }
+        LOCK(&drc->lock);
+        ret = rpcsvc_cache_reply(req, iobref, &recordhdr, 1, proghdr, hdrcount,
+                                 payload, payloadcount);
+        UNLOCK(&drc->lock);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to cache reply");
+        }
+    }
+
+    ret = rpcsvc_transport_submit(trans, &recordhdr, 1, proghdr, hdrcount,
+                                  payload, payloadcount, iobref,
+                                  req->trans_private);
+
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "failed to submit message "
+               "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to "
+               "rpc-transport (%s)",
+               req->xid, req->prog ? req->prog->progname : "(not matched)",
+               req->prog ? req->prog->progver : 0, req->procnum,
+               trans ? trans->name : "");
+    } else {
+        gf_log(GF_RPCSVC, GF_LOG_TRACE,
+               "submitted reply for rpc-message (XID: 0x%x, "
+               "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport "
+               "(%s)",
+               req->xid, req->prog ? req->prog->progname : "-",
+               req->prog ? req->prog->progver : 0, req->procnum,
+               trans ? trans->name : "");
+    }
 
 disconnect_exit:
-        if (replyiob) {
-                iobuf_unref (replyiob);
-        }
+    if (replyiob) {
+        iobuf_unref(replyiob);
+    }
 
-        if (new_iobref) {
-                iobref_unref (iobref);
-        }
+    if (new_iobref) {
+        iobref_unref(iobref);
+    }
 
-        rpcsvc_request_destroy (req);
+    rpcsvc_request_destroy(req);
 
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_error_reply (rpcsvc_request_t *req)
+rpcsvc_error_reply(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
+    struct iovec dummyvec = {
+        0,
+    };
 
-        if (!req)
-                return -1;
+    if (!req)
+        return -1;
 
-        gf_log_callingfn ("", GF_LOG_DEBUG, "sending a RPC error reply");
+    gf_log_callingfn("", GF_LOG_DEBUG, "sending a RPC error reply");
 
-        /* At this point the req should already have been filled with the
-         * appropriate RPC error numbers.
-         */
-        return rpcsvc_submit_generic (req, &dummyvec, 0, NULL, 0, NULL);
+    /* At this point the req should already have been filled with the
+     * appropriate RPC error numbers.
+     */
+    return rpcsvc_submit_generic(req, &dummyvec, 0, NULL, 0, NULL);
 }
 
 #ifdef IPV6_DEFAULT
 int
-rpcsvc_program_register_rpcbind6 (rpcsvc_program_t *newprog, uint32_t port)
-{
-        const int IP_BUF_LEN = 64;
-        char addr_buf[IP_BUF_LEN];
-
-        int err = 0;
-        bool_t success = 0;
-        struct netconfig *nc;
-        struct netbuf *nb;
-
-        if (!newprog) {
-                goto out;
-        }
-
-        nc = getnetconfigent ("tcp6");
-        if (!nc) {
-                err = -1;
-                goto out;
-        }
-
-
-        err = sprintf (addr_buf, "::.%d.%d", port >> 8 & 0xff,
-                       port & 0xff);
-        if (err < 0) {
-                err = -1;
-                goto out;
-        }
-
-        nb = uaddr2taddr (nc, addr_buf);
-        if (!nb) {
-                err = -1;
-                goto out;
-        }
-
-        /* Force the unregistration of the program first.
-         * This call may fail if nothing has been registered,
-         * which is fine.
-         */
-        rpcsvc_program_unregister_rpcbind6 (newprog);
-
-        success = rpcb_set (newprog->prognum, newprog->progver, nc, nb);
-        if (!success) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register the IPv6"
-                                                 " service with rpcbind");
-        }
-
-        err = 0;
+rpcsvc_program_register_rpcbind6(rpcsvc_program_t *newprog, uint32_t port)
+{
+    const int IP_BUF_LEN = 64;
+    char addr_buf[IP_BUF_LEN];
+
+    int err = 0;
+    bool_t success = 0;
+    struct netconfig *nc;
+    struct netbuf *nb;
+
+    if (!newprog) {
+        goto out;
+    }
+
+    nc = getnetconfigent("tcp6");
+    if (!nc) {
+        err = -1;
+        goto out;
+    }
+
+    err = sprintf(addr_buf, "::.%d.%d", port >> 8 & 0xff, port & 0xff);
+    if (err < 0) {
+        err = -1;
+        goto out;
+    }
+
+    nb = uaddr2taddr(nc, addr_buf);
+    if (!nb) {
+        err = -1;
+        goto out;
+    }
+
+    /* Force the unregistration of the program first.
+     * This call may fail if nothing has been registered,
+     * which is fine.
+     */
+    rpcsvc_program_unregister_rpcbind6(newprog);
+
+    success = rpcb_set(newprog->prognum, newprog->progver, nc, nb);
+    if (!success) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not register the IPv6"
+               " service with rpcbind");
+    }
+
+    err = 0;
 
 out:
-        return err;
+    return err;
 }
 
 int
-rpcsvc_program_unregister_rpcbind6 (rpcsvc_program_t *newprog)
-{
-        int err = 0;
-        bool_t success = 0;
-        struct netconfig *nc;
-
-        if (!newprog) {
-                goto out;
-        }
-
-        nc = getnetconfigent ("tcp6");
-        if (!nc) {
-                err = -1;
-                goto out;
-        }
-
-        success = rpcb_unset (newprog->prognum, newprog->progver, nc);
-        if (!success) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not unregister the IPv6"
-                                                 " service with rpcbind");
-        }
-
-        err = 0;
+rpcsvc_program_unregister_rpcbind6(rpcsvc_program_t *newprog)
+{
+    int err = 0;
+    bool_t success = 0;
+    struct netconfig *nc;
+
+    if (!newprog) {
+        goto out;
+    }
+
+    nc = getnetconfigent("tcp6");
+    if (!nc) {
+        err = -1;
+        goto out;
+    }
+
+    success = rpcb_unset(newprog->prognum, newprog->progver, nc);
+    if (!success) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not unregister the IPv6"
+               " service with rpcbind");
+    }
+
+    err = 0;
 out:
-        return err;
+    return err;
 }
 #endif
 
 /* Register the program with the local portmapper service. */
 int
-rpcsvc_program_register_portmap (rpcsvc_program_t *newprog, uint32_t port)
+rpcsvc_program_register_portmap(rpcsvc_program_t *newprog, uint32_t port)
 {
-        int                ret   = -1; /* FAIL */
+    int ret = -1; /* FAIL */
 
-        if (!newprog) {
-                goto out;
-        }
+    if (!newprog) {
+        goto out;
+    }
 
-        /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */
-        if (!(pmap_set (newprog->prognum, newprog->progver, IPPROTO_TCP,
-                        port))) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register with"
-                        " portmap %d %d %u", newprog->prognum, newprog->progver, port);
-                goto out;
-        }
+    /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */
+    if (!(pmap_set(newprog->prognum, newprog->progver, IPPROTO_TCP, port))) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not register with"
+               " portmap %d %d %u",
+               newprog->prognum, newprog->progver, port);
+        goto out;
+    }
 
-        ret = 0; /* SUCCESS */
+    ret = 0; /* SUCCESS */
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_program_unregister_portmap (rpcsvc_program_t *prog)
+rpcsvc_program_unregister_portmap(rpcsvc_program_t *prog)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!prog)
-                goto out;
+    if (!prog)
+        goto out;
 
-        if (!(pmap_unset(prog->prognum, prog->progver))) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not unregister with"
-                        " portmap");
-                goto out;
-        }
+    if (!(pmap_unset(prog->prognum, prog->progver))) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Could not unregister with"
+               " portmap");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_register_portmap_enabled (rpcsvc_t *svc)
+rpcsvc_register_portmap_enabled(rpcsvc_t *svc)
 {
-        return svc->register_portmap;
+    return svc->register_portmap;
 }
 
 int32_t
-rpcsvc_get_listener_port (rpcsvc_listener_t *listener)
+rpcsvc_get_listener_port(rpcsvc_listener_t *listener)
 {
-        int32_t listener_port = -1;
+    int32_t listener_port = -1;
 
-        if ((listener == NULL) || (listener->trans == NULL)) {
-                goto out;
-        }
+    if ((listener == NULL) || (listener->trans == NULL)) {
+        goto out;
+    }
 
-        switch (listener->trans->myinfo.sockaddr.ss_family) {
+    switch (listener->trans->myinfo.sockaddr.ss_family) {
         case AF_INET:
-                listener_port = ((struct sockaddr_in *)&listener->trans->myinfo.sockaddr)->sin_port;
-                break;
+            listener_port = ((struct sockaddr_in *)&listener->trans->myinfo
+                                 .sockaddr)
+                                ->sin_port;
+            break;
 
         case AF_INET6:
-                listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo.sockaddr)->sin6_port;
-                break;
+            listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo
+                                 .sockaddr)
+                                ->sin6_port;
+            break;
 
         default:
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG,
-                        "invalid address family (%d)",
-                        listener->trans->myinfo.sockaddr.ss_family);
-                goto out;
-        }
+            gf_log(GF_RPCSVC, GF_LOG_DEBUG, "invalid address family (%d)",
+                   listener->trans->myinfo.sockaddr.ss_family);
+            goto out;
+    }
 
-        listener_port = ntohs (listener_port);
+    listener_port = ntohs(listener_port);
 
 out:
-        return listener_port;
+    return listener_port;
 }
 
-
 rpcsvc_listener_t *
-rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans)
+rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans)
 {
-        rpcsvc_listener_t  *listener      = NULL;
-        char                found         = 0;
-        rpcsvc_listener_t  *next          = NULL;
-        uint32_t            listener_port = 0;
+    rpcsvc_listener_t *listener = NULL;
+    char found = 0;
+    rpcsvc_listener_t *next = NULL;
+    uint32_t listener_port = 0;
 
-        if (!svc) {
-                goto out;
-        }
+    if (!svc) {
+        goto out;
+    }
 
-        pthread_rwlock_rdlock (&svc->rpclock);
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry_safe(listener, next, &svc->listeners, list)
         {
-                list_for_each_entry_safe (listener, next, &svc->listeners, list) {
-                        if (trans != NULL) {
-                                if (listener->trans == trans) {
-                                        found = 1;
-                                        break;
-                                }
-
-                                continue;
-                        }
-
-                        listener_port = rpcsvc_get_listener_port (listener);
-                        if (listener_port == -1) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "invalid port for listener %s",
-                                        listener->trans->name);
-                                continue;
-                        }
-
-                        if (listener_port == port) {
-                                found = 1;
-                                break;
-                        }
+            if (trans != NULL) {
+                if (listener->trans == trans) {
+                    found = 1;
+                    break;
                 }
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
 
-        if (!found) {
-                listener = NULL;
+                continue;
+            }
+
+            listener_port = rpcsvc_get_listener_port(listener);
+            if (listener_port == -1) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid port for listener %s",
+                       listener->trans->name);
+                continue;
+            }
+
+            if (listener_port == port) {
+                found = 1;
+                break;
+            }
         }
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    if (!found) {
+        listener = NULL;
+    }
 
 out:
-        return listener;
+    return listener;
 }
 
-
 /* The only difference between the generic submit and this one is that the
  * generic submit is also used for submitting RPC error replies in where there
  * are no payloads so the msgvec and msgbuf can be NULL.
@@ -1636,819 +1643,824 @@ out:
  * we must perform NULL checks before calling the generic submit.
  */
 int
-rpcsvc_submit_message (rpcsvc_request_t *req, struct iovec *proghdr,
-                       int hdrcount, struct iovec *payload, int payloadcount,
-                       struct iobref *iobref)
+rpcsvc_submit_message(rpcsvc_request_t *req, struct iovec *proghdr,
+                      int hdrcount, struct iovec *payload, int payloadcount,
+                      struct iobref *iobref)
 {
-        if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base))
-                return -1;
+    if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base))
+        return -1;
 
-        return rpcsvc_submit_generic (req, proghdr, hdrcount, payload,
-                                      payloadcount, iobref);
+    return rpcsvc_submit_generic(req, proghdr, hdrcount, payload, payloadcount,
+                                 iobref);
 }
 
-
 int
-rpcsvc_program_unregister (rpcsvc_t *svc, rpcsvc_program_t *program)
-{
-        int                     ret = -1;
-        rpcsvc_program_t        *prog = NULL;
-        if (!svc || !program) {
-                goto out;
-        }
-
-        ret = rpcsvc_program_unregister_portmap (program);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "portmap unregistration of"
-                        " program failed");
-                goto out;
-        }
+rpcsvc_program_unregister(rpcsvc_t *svc, rpcsvc_program_t *program)
+{
+    int ret = -1;
+    rpcsvc_program_t *prog = NULL;
+    if (!svc || !program) {
+        goto out;
+    }
+
+    ret = rpcsvc_program_unregister_portmap(program);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "portmap unregistration of"
+               " program failed");
+        goto out;
+    }
 #ifdef IPV6_DEFAULT
-        ret = rpcsvc_program_unregister_rpcbind6 (program);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "rpcbind (ipv6)"
-                        " unregistration of program failed");
-                goto out;
-        }
+    ret = rpcsvc_program_unregister_rpcbind6(program);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "rpcbind (ipv6)"
+               " unregistration of program failed");
+        goto out;
+    }
 #endif
-        pthread_rwlock_rdlock (&svc->rpclock);
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(prog, &svc->programs, program)
         {
-                list_for_each_entry (prog, &svc->programs, program) {
-                        if ((prog->prognum == program->prognum)
-                            && (prog->progver == program->progver)) {
-                                break;
-                        }
-                }
+            if ((prog->prognum == program->prognum) &&
+                (prog->progver == program->progver)) {
+                break;
+            }
         }
-        pthread_rwlock_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Program unregistered: %s, Num: %d,"
-                " Ver: %d, Port: %d", prog->progname, prog->prognum,
-                prog->progver, prog->progport);
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "Program unregistered: %s, Num: %d,"
+           " Ver: %d, Port: %d",
+           prog->progname, prog->prognum, prog->progver, prog->progport);
 
-        if (prog->ownthread) {
-                prog->alive = _gf_false;
-                ret = 0;
-                goto out;
-        }
+    if (prog->ownthread) {
+        prog->alive = _gf_false;
+        ret = 0;
+        goto out;
+    }
 
-        pthread_rwlock_wrlock (&svc->rpclock);
-        {
-                list_del_init (&prog->program);
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_del_init(&prog->program);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret == -1) {
-                if (program) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program "
-                                "unregistration failed"
-                                ": %s, Num: %d, Ver: %d, Port: %d",
-                                program->progname, program->prognum,
-                                program->progver, program->progport);
-                } else {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program not found");
-                }
+    if (ret == -1) {
+        if (program) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Program "
+                   "unregistration failed"
+                   ": %s, Num: %d, Ver: %d, Port: %d",
+                   program->progname, program->prognum, program->progver,
+                   program->progport);
+        } else {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "Program not found");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-rpcsvc_transport_peername (rpc_transport_t *trans, char *hostname, int hostlen)
+rpcsvc_transport_peername(rpc_transport_t *trans, char *hostname, int hostlen)
 {
-        if (!trans) {
-                return -1;
-        }
+    if (!trans) {
+        return -1;
+    }
 
-        return rpc_transport_get_peername (trans, hostname, hostlen);
+    return rpc_transport_get_peername(trans, hostname, hostlen);
 }
 
-
 int
-rpcsvc_transport_peeraddr (rpc_transport_t *trans, char *addrstr, int addrlen,
-                           struct sockaddr_storage *sa, socklen_t sasize)
+rpcsvc_transport_peeraddr(rpc_transport_t *trans, char *addrstr, int addrlen,
+                          struct sockaddr_storage *sa, socklen_t sasize)
 {
-        if (!trans) {
-                return -1;
-        }
+    if (!trans) {
+        return -1;
+    }
 
-        return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa,
-                                          sasize);
+    return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa, sasize);
 }
 
 rpcsvc_listener_t *
-rpcsvc_listener_alloc (rpcsvc_t *svc, rpc_transport_t *trans)
+rpcsvc_listener_alloc(rpcsvc_t *svc, rpc_transport_t *trans)
 {
-        rpcsvc_listener_t *listener = NULL;
+    rpcsvc_listener_t *listener = NULL;
 
-        listener = GF_CALLOC (1, sizeof (*listener),
-                              gf_common_mt_rpcsvc_listener_t);
-        if (!listener) {
-                goto out;
-        }
+    listener = GF_CALLOC(1, sizeof(*listener), gf_common_mt_rpcsvc_listener_t);
+    if (!listener) {
+        goto out;
+    }
 
-        listener->trans = trans;
-        listener->svc = svc;
+    listener->trans = trans;
+    listener->svc = svc;
 
-        INIT_LIST_HEAD (&listener->list);
+    INIT_LIST_HEAD(&listener->list);
 
-        pthread_rwlock_wrlock (&svc->rpclock);
-        {
-                list_add_tail (&listener->list, &svc->listeners);
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_add_tail(&listener->list, &svc->listeners);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 out:
-        return listener;
+    return listener;
 }
 
-
 int32_t
-rpcsvc_create_listener (rpcsvc_t *svc, dict_t *options, char *name)
-{
-        rpc_transport_t   *trans    = NULL;
-        rpcsvc_listener_t *listener = NULL;
-        int32_t            ret      = -1;
-
-        if (!svc || !options) {
-                goto out;
-        }
-
-        trans = rpc_transport_load (svc->ctx, options, name);
-        if (!trans) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "cannot create listener, "
-                        "initing the transport failed");
-                goto out;
-        }
-
-        ret = rpc_transport_listen (trans);
-        if (ret == -EADDRINUSE || ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING,
-                        "listening on transport failed");
-                goto out;
-        }
-
-        ret = rpc_transport_register_notify (trans, rpcsvc_notify, svc);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_WARNING, "registering notify failed");
-                goto out;
-        }
-
-        listener = rpcsvc_listener_alloc (svc, trans);
-        if (listener == NULL) {
-                goto out;
-        }
-
-        ret = 0;
+rpcsvc_create_listener(rpcsvc_t *svc, dict_t *options, char *name)
+{
+    rpc_transport_t *trans = NULL;
+    rpcsvc_listener_t *listener = NULL;
+    int32_t ret = -1;
+
+    if (!svc || !options) {
+        goto out;
+    }
+
+    trans = rpc_transport_load(svc->ctx, options, name);
+    if (!trans) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING,
+               "cannot create listener, "
+               "initing the transport failed");
+        goto out;
+    }
+
+    ret = rpc_transport_listen(trans);
+    if (ret == -EADDRINUSE || ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "listening on transport failed");
+        goto out;
+    }
+
+    ret = rpc_transport_register_notify(trans, rpcsvc_notify, svc);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_WARNING, "registering notify failed");
+        goto out;
+    }
+
+    listener = rpcsvc_listener_alloc(svc, trans);
+    if (listener == NULL) {
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (!listener && trans) {
-                rpc_transport_disconnect (trans, _gf_true);
-        }
+    if (!listener && trans) {
+        rpc_transport_disconnect(trans, _gf_true);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-rpcsvc_create_listeners (rpcsvc_t *svc, dict_t *options, char *name)
+rpcsvc_create_listeners(rpcsvc_t *svc, dict_t *options, char *name)
 {
-        int32_t  ret            = -1, count = 0;
-        data_t  *data           = NULL;
-        char    *str            = NULL, *ptr = NULL, *transport_name = NULL;
-        char    *transport_type = NULL, *saveptr = NULL, *tmp = NULL;
+    int32_t ret = -1, count = 0;
+    data_t *data = NULL;
+    char *str = NULL, *ptr = NULL, *transport_name = NULL;
+    char *transport_type = NULL, *saveptr = NULL, *tmp = NULL;
 
-        if ((svc == NULL) || (options == NULL) || (name == NULL)) {
-                goto out;
-        }
+    if ((svc == NULL) || (options == NULL) || (name == NULL)) {
+        goto out;
+    }
 
-        data = dict_get (options, "transport-type");
-        if (data == NULL) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "option transport-type not set");
-                goto out;
-        }
+    data = dict_get(options, "transport-type");
+    if (data == NULL) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set");
+        goto out;
+    }
 
-        transport_type = data_to_str (data);
-        if (transport_type == NULL) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "option transport-type not set");
-                goto out;
-        }
+    transport_type = data_to_str(data);
+    if (transport_type == NULL) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set");
+        goto out;
+    }
 
-        /* duplicate transport_type, since following dict_set will free it */
-        transport_type = gf_strdup (transport_type);
-        if (transport_type == NULL) {
-                goto out;
-        }
+    /* duplicate transport_type, since following dict_set will free it */
+    transport_type = gf_strdup(transport_type);
+    if (transport_type == NULL) {
+        goto out;
+    }
 
-        str = gf_strdup (transport_type);
-        if (str == NULL) {
-                goto out;
-        }
+    str = gf_strdup(transport_type);
+    if (str == NULL) {
+        goto out;
+    }
 
-        ptr = strtok_r (str, ",", &saveptr);
+    ptr = strtok_r(str, ",", &saveptr);
 
-        while (ptr != NULL) {
-                tmp = gf_strdup (ptr);
-                if (tmp == NULL) {
-                        goto out;
-                }
-
-                ret = gf_asprintf (&transport_name, "%s.%s", tmp, name);
-                if (ret == -1) {
-                        goto out;
-                }
+    while (ptr != NULL) {
+        tmp = gf_strdup(ptr);
+        if (tmp == NULL) {
+            goto out;
+        }
 
-                ret = dict_set_dynstr (options, "transport-type", tmp);
-                if (ret == -1) {
-                        goto out;
-                }
+        ret = gf_asprintf(&transport_name, "%s.%s", tmp, name);
+        if (ret == -1) {
+            goto out;
+        }
 
-                tmp = NULL;
-                ptr = strtok_r (NULL, ",", &saveptr);
+        ret = dict_set_dynstr(options, "transport-type", tmp);
+        if (ret == -1) {
+            goto out;
+        }
 
-                ret = rpcsvc_create_listener (svc, options, transport_name);
-                if (ret != 0) {
-                        goto out;
-                }
+        tmp = NULL;
+        ptr = strtok_r(NULL, ",", &saveptr);
 
-                GF_FREE (transport_name);
-                transport_name = NULL;
-                count++;
+        ret = rpcsvc_create_listener(svc, options, transport_name);
+        if (ret != 0) {
+            goto out;
         }
 
-        ret = dict_set_dynstr (options, "transport-type", transport_type);
-        if (ret == -1) {
-                goto out;
-        }
+        GF_FREE(transport_name);
+        transport_name = NULL;
+        count++;
+    }
+
+    ret = dict_set_dynstr(options, "transport-type", transport_type);
+    if (ret == -1) {
+        goto out;
+    }
 
-        transport_type = NULL;
+    transport_type = NULL;
 
 out:
-        GF_FREE (str);
+    GF_FREE(str);
 
-        GF_FREE (transport_type);
+    GF_FREE(transport_type);
 
-        GF_FREE (tmp);
+    GF_FREE(tmp);
 
-        GF_FREE (transport_name);
+    GF_FREE(transport_name);
 
-        if (count > 0) {
-                return count;
-        } else {
-                return ret;
-        }
+    if (count > 0) {
+        return count;
+    } else {
+        return ret;
+    }
 }
 
-
 int
-rpcsvc_unregister_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
+rpcsvc_unregister_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL;
-        int                      ret     = 0;
+    rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL;
+    int ret = 0;
 
-        if (!svc || !notify) {
-                goto out;
-        }
+    if (!svc || !notify) {
+        goto out;
+    }
 
-        pthread_rwlock_wrlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_for_each_entry_safe(wrapper, tmp, &svc->notify, list)
         {
-                list_for_each_entry_safe (wrapper, tmp, &svc->notify, list) {
-                        if ((wrapper->notify == notify)
-                            && (mydata == wrapper->data)) {
-                                list_del_init (&wrapper->list);
-                                GF_FREE (wrapper);
-                                ret++;
-                        }
-                }
+            if ((wrapper->notify == notify) && (mydata == wrapper->data)) {
+                list_del_init(&wrapper->list);
+                GF_FREE(wrapper);
+                ret++;
+            }
         }
-        pthread_rwlock_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_register_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
+rpcsvc_register_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata)
+{
+    rpcsvc_notify_wrapper_t *wrapper = NULL;
+    int ret = -1;
+
+    wrapper = rpcsvc_notify_wrapper_alloc();
+    if (!wrapper) {
+        goto out;
+    }
+    svc->mydata = mydata;
+    wrapper->data = mydata;
+    wrapper->notify = notify;
+
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_add_tail(&wrapper->list, &svc->notify);
+        svc->notify_count++;
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
+
+    ret = 0;
+out:
+    return ret;
+}
+
+void *
+rpcsvc_request_handler(void *arg)
 {
-        rpcsvc_notify_wrapper_t *wrapper = NULL;
-        int                      ret     = -1;
+    rpcsvc_program_t *program = arg;
+    rpcsvc_request_t *req = NULL;
+    rpcsvc_actor_t *actor = NULL;
+    gf_boolean_t done = _gf_false;
+    int ret = 0;
 
-        wrapper = rpcsvc_notify_wrapper_alloc ();
-        if (!wrapper) {
-                goto out;
-        }
-        svc->mydata   = mydata;
-        wrapper->data = mydata;
-        wrapper->notify = notify;
+    if (!program)
+        return NULL;
 
-        pthread_rwlock_wrlock (&svc->rpclock);
+    while (1) {
+        pthread_mutex_lock(&program->queue_lock);
         {
-                list_add_tail (&wrapper->list, &svc->notify);
-                svc->notify_count++;
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
+            if (!program->alive && list_empty(&program->request_queue)) {
+                done = 1;
+                goto unlock;
+            }
 
-        ret = 0;
-out:
-        return ret;
-}
+            while (list_empty(&program->request_queue) &&
+                   (program->threadcount <= program->eventthreadcount)) {
+                pthread_cond_wait(&program->queue_cond, &program->queue_lock);
+            }
 
-void *
-rpcsvc_request_handler (void *arg)
-{
-        rpcsvc_program_t *program = arg;
-        rpcsvc_request_t *req     = NULL;
-        rpcsvc_actor_t   *actor   = NULL;
-        gf_boolean_t      done    = _gf_false;
-        int               ret     = 0;
-
-        if (!program)
-                return NULL;
-
-        while (1) {
-                pthread_mutex_lock (&program->queue_lock);
-                {
-                        if (!program->alive
-                            && list_empty (&program->request_queue)) {
-                                done = 1;
-                                goto unlock;
-                        }
-
-                        while (list_empty (&program->request_queue) &&
-                               (program->threadcount <=
-                                        program->eventthreadcount)) {
-                                pthread_cond_wait (&program->queue_cond,
-                                                   &program->queue_lock);
-                        }
-
-                        if (program->threadcount > program->eventthreadcount) {
-                                done = 1;
-                                program->threadcount--;
-
-                                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                                        "program '%s' thread terminated; "
-                                        "total count:%d",
-                                        program->progname,
-                                        program->threadcount);
-                        } else if (!list_empty (&program->request_queue)) {
-                                req = list_entry (program->request_queue.next,
-                                                  typeof (*req), request_list);
-
-                                list_del_init (&req->request_list);
-                        }
-                }
-        unlock:
-                pthread_mutex_unlock (&program->queue_lock);
-
-                if (req) {
-                        THIS = req->svc->xl;
-                        actor = rpcsvc_program_actor (req);
-                        ret = actor->actor (req);
-
-                        if (ret != 0) {
-                                rpcsvc_check_and_reply_error (ret, NULL, req);
-                        }
-                        req = NULL;
-                }
+            if (program->threadcount > program->eventthreadcount) {
+                done = 1;
+                program->threadcount--;
+
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "program '%s' thread terminated; "
+                       "total count:%d",
+                       program->progname, program->threadcount);
+            } else if (!list_empty(&program->request_queue)) {
+                req = list_entry(program->request_queue.next, typeof(*req),
+                                 request_list);
 
-                if (done)
-                        break;
+                list_del_init(&req->request_list);
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&program->queue_lock);
 
-        return NULL;
+        if (req) {
+            THIS = req->svc->xl;
+            actor = rpcsvc_program_actor(req);
+            ret = actor->actor(req);
+
+            if (ret != 0) {
+                rpcsvc_check_and_reply_error(ret, NULL, req);
+            }
+            req = NULL;
+        }
+
+        if (done)
+            break;
+    }
+
+    return NULL;
 }
 
 int
-rpcsvc_spawn_threads (rpcsvc_t *svc, rpcsvc_program_t *program)
+rpcsvc_spawn_threads(rpcsvc_t *svc, rpcsvc_program_t *program)
 {
-        int                ret  = 0, delta = 0, creates = 0;
+    int ret = 0, delta = 0, creates = 0;
 
-        if (!program || !svc)
-                goto out;
+    if (!program || !svc)
+        goto out;
 
-        pthread_mutex_lock (&program->queue_lock);
-        {
-                delta = program->eventthreadcount - program->threadcount;
-
-                if (delta >= 0) {
-                        while (delta--) {
-                                ret = gf_thread_create (&program->thread, NULL,
-                                                        rpcsvc_request_handler,
-                                                        program, "rpcrqhnd");
-                                if (!ret) {
-                                        program->threadcount++;
-                                        creates++;
-                                }
-                        }
-
-                        if (creates) {
-                                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                                        "spawned %d threads for program '%s'; "
-                                        "total count:%d",
-                                        creates,
-                                        program->progname,
-                                        program->threadcount);
-                        }
-                } else {
-                        gf_log (GF_RPCSVC, GF_LOG_INFO,
-                                "terminating %d threads for program '%s'",
-                                -delta, program->progname);
-
-                        /* this signal is to just wake up the threads so they
-                         * test for the change in eventthreadcount and kill
-                         * themselves until the program thread count becomes
-                         * equal to the event thread count
-                         */
-                        pthread_cond_broadcast (&program->queue_cond);
+    pthread_mutex_lock(&program->queue_lock);
+    {
+        delta = program->eventthreadcount - program->threadcount;
+
+        if (delta >= 0) {
+            while (delta--) {
+                ret = gf_thread_create(&program->thread, NULL,
+                                       rpcsvc_request_handler, program,
+                                       "rpcrqhnd");
+                if (!ret) {
+                    program->threadcount++;
+                    creates++;
                 }
+            }
+
+            if (creates) {
+                gf_log(GF_RPCSVC, GF_LOG_INFO,
+                       "spawned %d threads for program '%s'; "
+                       "total count:%d",
+                       creates, program->progname, program->threadcount);
+            }
+        } else {
+            gf_log(GF_RPCSVC, GF_LOG_INFO,
+                   "terminating %d threads for program '%s'", -delta,
+                   program->progname);
+
+            /* this signal is to just wake up the threads so they
+             * test for the change in eventthreadcount and kill
+             * themselves until the program thread count becomes
+             * equal to the event thread count
+             */
+            pthread_cond_broadcast(&program->queue_cond);
         }
-        pthread_mutex_unlock (&program->queue_lock);
+    }
+    pthread_mutex_unlock(&program->queue_lock);
 
 out:
-        return creates;
+    return creates;
 }
 
 int
-rpcsvc_program_register (rpcsvc_t *svc, rpcsvc_program_t *program,
-                         gf_boolean_t add_to_head)
+rpcsvc_program_register(rpcsvc_t *svc, rpcsvc_program_t *program,
+                        gf_boolean_t add_to_head)
 {
-        int               ret                = -1;
-        int               creates            = -1;
-        rpcsvc_program_t *newprog            = NULL;
-        char              already_registered = 0;
+    int ret = -1;
+    int creates = -1;
+    rpcsvc_program_t *newprog = NULL;
+    char already_registered = 0;
 
-        if (!svc) {
-                goto out;
-        }
+    if (!svc) {
+        goto out;
+    }
 
-        if (program->actors == NULL) {
-                goto out;
-        }
+    if (program->actors == NULL) {
+        goto out;
+    }
 
-        pthread_rwlock_rdlock (&svc->rpclock);
+    pthread_rwlock_rdlock(&svc->rpclock);
+    {
+        list_for_each_entry(newprog, &svc->programs, program)
         {
-                list_for_each_entry (newprog, &svc->programs, program) {
-                        if ((newprog->prognum == program->prognum)
-                            && (newprog->progver == program->progver)) {
-                                already_registered = 1;
-                                break;
-                        }
-                }
+            if ((newprog->prognum == program->prognum) &&
+                (newprog->progver == program->progver)) {
+                already_registered = 1;
+                break;
+            }
         }
-        pthread_rwlock_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        if (already_registered) {
-                ret = 0;
-                goto out;
-        }
+    if (already_registered) {
+        ret = 0;
+        goto out;
+    }
 
-        newprog = GF_CALLOC (1, sizeof(*newprog),gf_common_mt_rpcsvc_program_t);
-        if (newprog == NULL) {
-                goto out;
-        }
+    newprog = GF_CALLOC(1, sizeof(*newprog), gf_common_mt_rpcsvc_program_t);
+    if (newprog == NULL) {
+        goto out;
+    }
 
-        memcpy (newprog, program, sizeof (*program));
+    memcpy(newprog, program, sizeof(*program));
 
-        INIT_LIST_HEAD (&newprog->program);
-        INIT_LIST_HEAD (&newprog->request_queue);
-        pthread_mutex_init (&newprog->queue_lock, NULL);
-        pthread_cond_init (&newprog->queue_cond, NULL);
+    INIT_LIST_HEAD(&newprog->program);
+    INIT_LIST_HEAD(&newprog->request_queue);
+    pthread_mutex_init(&newprog->queue_lock, NULL);
+    pthread_cond_init(&newprog->queue_cond, NULL);
 
-        newprog->alive = _gf_true;
+    newprog->alive = _gf_true;
 
-        /* make sure synctask gets priority over ownthread */
-        if (newprog->synctask)
-                newprog->ownthread = _gf_false;
+    /* make sure synctask gets priority over ownthread */
+    if (newprog->synctask)
+        newprog->ownthread = _gf_false;
 
-        if (newprog->ownthread) {
-                newprog->eventthreadcount = 1;
-                creates = rpcsvc_spawn_threads (svc, newprog);
+    if (newprog->ownthread) {
+        newprog->eventthreadcount = 1;
+        creates = rpcsvc_spawn_threads(svc, newprog);
 
-                if (creates < 1) {
-                        goto out;
-                }
+        if (creates < 1) {
+            goto out;
         }
+    }
 
-        pthread_rwlock_wrlock (&svc->rpclock);
-        {
-                if (add_to_head)
-                        list_add (&newprog->program, &svc->programs);
-                else
-                        list_add_tail (&newprog->program, &svc->programs);
-        }
-        pthread_rwlock_unlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        if (add_to_head)
+            list_add(&newprog->program, &svc->programs);
+        else
+            list_add_tail(&newprog->program, &svc->programs);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        ret = 0;
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "New program registered: %s, Num: %d,"
-                " Ver: %d, Port: %d", newprog->progname, newprog->prognum,
-                newprog->progver, newprog->progport);
+    ret = 0;
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+           "New program registered: %s, Num: %d,"
+           " Ver: %d, Port: %d",
+           newprog->progname, newprog->prognum, newprog->progver,
+           newprog->progport);
 
 out:
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program registration failed:"
-                        " %s, Num: %d, Ver: %d, Port: %d", program->progname,
-                        program->prognum, program->progver, program->progport);
-        }
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Program registration failed:"
+               " %s, Num: %d, Ver: %d, Port: %d",
+               program->progname, program->prognum, program->progver,
+               program->progport);
+    }
 
-        return ret;
+    return ret;
 }
 
 static void
-free_prog_details (gf_dump_rsp *rsp)
+free_prog_details(gf_dump_rsp *rsp)
 {
-        gf_prog_detail *prev = NULL;
-        gf_prog_detail *trav = NULL;
+    gf_prog_detail *prev = NULL;
+    gf_prog_detail *trav = NULL;
 
-        trav = rsp->prog;
-        while (trav) {
-                prev = trav;
-                trav = trav->next;
-                GF_FREE (prev);
-        }
+    trav = rsp->prog;
+    while (trav) {
+        prev = trav;
+        trav = trav->next;
+        GF_FREE(prev);
+    }
 }
 
 static int
-build_prog_details (rpcsvc_request_t *req, gf_dump_rsp *rsp)
+build_prog_details(rpcsvc_request_t *req, gf_dump_rsp *rsp)
 {
-        int               ret     = -1;
-        rpcsvc_program_t *program = NULL;
-        gf_prog_detail   *prog    = NULL;
-        gf_prog_detail   *prev    = NULL;
+    int ret = -1;
+    rpcsvc_program_t *program = NULL;
+    gf_prog_detail *prog = NULL;
+    gf_prog_detail *prev = NULL;
 
-        if (!req || !req->trans || !req->svc)
-                goto out;
+    if (!req || !req->trans || !req->svc)
+        goto out;
 
-        pthread_rwlock_rdlock (&req->svc->rpclock);
+    pthread_rwlock_rdlock(&req->svc->rpclock);
+    {
+        list_for_each_entry(program, &req->svc->programs, program)
         {
-                list_for_each_entry (program, &req->svc->programs, program) {
-                        prog = GF_CALLOC (1, sizeof (*prog), 0);
-                        if (!prog)
-                                goto unlock;
-
-                        prog->progname = program->progname;
-                        prog->prognum  = program->prognum;
-                        prog->progver  = program->progver;
-
-                        if (!rsp->prog)
-                                rsp->prog = prog;
-                        if (prev)
-                                prev->next = prog;
-                        prev = prog;
-                }
-                if (prev)
-                        ret = 0;
-        }
+            prog = GF_CALLOC(1, sizeof(*prog), 0);
+            if (!prog)
+                goto unlock;
+
+            prog->progname = program->progname;
+            prog->prognum = program->prognum;
+            prog->progver = program->progver;
+
+            if (!rsp->prog)
+                rsp->prog = prog;
+            if (prev)
+                prev->next = prog;
+            prev = prog;
+        }
+        if (prev)
+            ret = 0;
+    }
 unlock:
-        pthread_rwlock_unlock (&req->svc->rpclock);
+    pthread_rwlock_unlock(&req->svc->rpclock);
 out:
-        return ret;
+    return ret;
 }
 
 static int
-rpcsvc_ping (rpcsvc_request_t *req)
+rpcsvc_ping(rpcsvc_request_t *req)
 {
-        char          rsp_buf[8 * 1024] = {0,};
-        gf_common_rsp rsp               = {0,};
-        struct iovec  iov               = {0,};
-        int           ret               = -1;
-        uint32_t      ping_rsp_len      = 0;
+    char rsp_buf[8 * 1024] = {
+        0,
+    };
+    gf_common_rsp rsp = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    int ret = -1;
+    uint32_t ping_rsp_len = 0;
 
-        ping_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_common_rsp,
-                                   &rsp);
+    ping_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_common_rsp, &rsp);
 
-        iov.iov_base = rsp_buf;
-        iov.iov_len  = ping_rsp_len;
+    iov.iov_base = rsp_buf;
+    iov.iov_len = ping_rsp_len;
 
-        ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_common_rsp);
-        if (ret < 0) {
-                ret = RPCSVC_ACTOR_ERROR;
-        } else {
-                rsp.op_ret = 0;
-                rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL);
-        }
+    ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_common_rsp);
+    if (ret < 0) {
+        ret = RPCSVC_ACTOR_ERROR;
+    } else {
+        rsp.op_ret = 0;
+        rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-rpcsvc_dump (rpcsvc_request_t *req)
-{
-        char         rsp_buf[8 * 1024] = {0,};
-        gf_dump_rsp  rsp               = {0,};
-        struct iovec iov               = {0,};
-        int          op_errno          = EINVAL;
-        int          ret               = -1;
-        uint32_t     dump_rsp_len      = 0;
-
-        if (!req)
-                goto sendrsp;
-
-        ret = build_prog_details (req, &rsp);
-        if (ret < 0) {
-                op_errno = -ret;
-                goto sendrsp;
-        }
-
-        op_errno = 0;
+rpcsvc_dump(rpcsvc_request_t *req)
+{
+    char rsp_buf[8 * 1024] = {
+        0,
+    };
+    gf_dump_rsp rsp = {
+        0,
+    };
+    struct iovec iov = {
+        0,
+    };
+    int op_errno = EINVAL;
+    int ret = -1;
+    uint32_t dump_rsp_len = 0;
+
+    if (!req)
+        goto sendrsp;
+
+    ret = build_prog_details(req, &rsp);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto sendrsp;
+    }
+
+    op_errno = 0;
 
 sendrsp:
-        rsp.op_errno = gf_errno_to_error (op_errno);
-        rsp.op_ret   = ret;
+    rsp.op_errno = gf_errno_to_error(op_errno);
+    rsp.op_ret = ret;
 
-        dump_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_dump_rsp,
-                                   &rsp);
+    dump_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_dump_rsp, &rsp);
 
-        iov.iov_base = rsp_buf;
-        iov.iov_len  = dump_rsp_len;
+    iov.iov_base = rsp_buf;
+    iov.iov_len = dump_rsp_len;
 
-        ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp);
-        if (ret < 0) {
-                ret = RPCSVC_ACTOR_ERROR;
-        } else {
-                rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL);
-                ret = 0;
-        }
+    ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp);
+    if (ret < 0) {
+        ret = RPCSVC_ACTOR_ERROR;
+    } else {
+        rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL);
+        ret = 0;
+    }
 
-        free_prog_details (&rsp);
+    free_prog_details(&rsp);
 
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_init_options (rpcsvc_t *svc, dict_t *options)
+rpcsvc_init_options(rpcsvc_t *svc, dict_t *options)
 {
-        char            *optstr = NULL;
-        int             ret = -1;
+    char *optstr = NULL;
+    int ret = -1;
 
-        if ((!svc) || (!options))
-                return -1;
+    if ((!svc) || (!options))
+        return -1;
 
-        svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR;
+    svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR;
 
-        svc->register_portmap = _gf_true;
-        if (dict_get (options, "rpc.register-with-portmap")) {
-                ret = dict_get_str (options, "rpc.register-with-portmap",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse "
-                                "dict");
-                        goto out;
-                }
-
-                ret = gf_string2boolean (optstr, &svc->register_portmap);
-                if (ret < 0) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse bool "
-                                "string");
-                        goto out;
-                }
+    svc->register_portmap = _gf_true;
+    if (dict_get(options, "rpc.register-with-portmap")) {
+        ret = dict_get_str(options, "rpc.register-with-portmap", &optstr);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Failed to parse "
+                   "dict");
+            goto out;
         }
 
-        if (!svc->register_portmap)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Portmap registration "
-                        "disabled");
-        ret = 0;
+        ret = gf_string2boolean(optstr, &svc->register_portmap);
+        if (ret < 0) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR,
+                   "Failed to parse bool "
+                   "string");
+            goto out;
+        }
+    }
+
+    if (!svc->register_portmap)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "Portmap registration "
+               "disabled");
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpcsvc_reconfigure_options (rpcsvc_t *svc, dict_t *options)
-{
-        xlator_t         *xlator    = NULL;
-        xlator_list_t    *volentry  = NULL;
-        char             *srchkey   = NULL;
-        char             *keyval    = NULL;
-        int              ret        = -1;
-
-        if ((!svc) || (!svc->options) || (!options))
-                return (-1);
-
-        /* Fetch the xlator from svc */
-        xlator = svc->xl;
-        if (!xlator)
+rpcsvc_reconfigure_options(rpcsvc_t *svc, dict_t *options)
+{
+    xlator_t *xlator = NULL;
+    xlator_list_t *volentry = NULL;
+    char *srchkey = NULL;
+    char *keyval = NULL;
+    int ret = -1;
+
+    if ((!svc) || (!svc->options) || (!options))
+        return (-1);
+
+    /* Fetch the xlator from svc */
+    xlator = svc->xl;
+    if (!xlator)
+        return (-1);
+
+    /* Reconfigure the volume specific rpc-auth.addr allow part */
+    volentry = xlator->children;
+    while (volentry) {
+        ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.allow",
+                          volentry->xlator->name);
+        if (ret == -1) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+            return (-1);
+        }
+
+        /* key-string: rpc-auth.addr.<volname>.allow
+         *
+         * IMP: Delete the OLD key/value pair from dict.
+         * And set the NEW key/value pair IFF the option is SET
+         * in reconfigured volfile.
+         *
+         * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly,
+         *     build_nfs_graph() sets it as "*" i.e. anonymous.
+         */
+        dict_del(svc->options, srchkey);
+        if (!dict_get_str(options, srchkey, &keyval)) {
+            ret = dict_set_str(svc->options, srchkey, keyval);
+            if (ret < 0) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error");
+                GF_FREE(srchkey);
                 return (-1);
-
-        /* Reconfigure the volume specific rpc-auth.addr allow part */
-        volentry = xlator->children;
-        while (volentry) {
-                ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.allow",
-                                             volentry->xlator->name);
-                if (ret == -1) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                        return (-1);
-                }
-
-                /* key-string: rpc-auth.addr.<volname>.allow
-                 *
-                 * IMP: Delete the OLD key/value pair from dict.
-                 * And set the NEW key/value pair IFF the option is SET
-                 * in reconfigured volfile.
-                 *
-                 * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly,
-                 *     build_nfs_graph() sets it as "*" i.e. anonymous.
-                 */
-                dict_del (svc->options, srchkey);
-                if (!dict_get_str (options, srchkey, &keyval)) {
-                        ret = dict_set_str (svc->options, srchkey, keyval);
-                        if (ret < 0) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "dict_set_str error");
-                                GF_FREE (srchkey);
-                                return (-1);
-                        }
-                }
-
-                GF_FREE (srchkey);
-                volentry = volentry->next;
+            }
         }
 
-        /* Reconfigure the volume specific rpc-auth.addr reject part */
-        volentry = xlator->children;
-        while (volentry) {
-                ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.reject",
-                                             volentry->xlator->name);
-                if (ret == -1) {
-                        gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                        return (-1);
-                }
-
-                /* key-string: rpc-auth.addr.<volname>.reject
-                 *
-                 * IMP: Delete the OLD key/value pair from dict.
-                 * And set the NEW key/value pair IFF the option is SET
-                 * in reconfigured volfile.
-                 *
-                 * NB: No default value for reject key.
-                 */
-                dict_del (svc->options, srchkey);
-                if (!dict_get_str (options, srchkey, &keyval)) {
-                        ret = dict_set_str (svc->options, srchkey, keyval);
-                        if (ret < 0) {
-                                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                                        "dict_set_str error");
-                                GF_FREE (srchkey);
-                                return (-1);
-                        }
-                }
+        GF_FREE(srchkey);
+        volentry = volentry->next;
+    }
 
-                GF_FREE (srchkey);
-                volentry = volentry->next;
+    /* Reconfigure the volume specific rpc-auth.addr reject part */
+    volentry = xlator->children;
+    while (volentry) {
+        ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.reject",
+                          volentry->xlator->name);
+        if (ret == -1) {
+            gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+            return (-1);
         }
 
-        ret = rpcsvc_init_options (svc, options);
-        if (ret)
+        /* key-string: rpc-auth.addr.<volname>.reject
+         *
+         * IMP: Delete the OLD key/value pair from dict.
+         * And set the NEW key/value pair IFF the option is SET
+         * in reconfigured volfile.
+         *
+         * NB: No default value for reject key.
+         */
+        dict_del(svc->options, srchkey);
+        if (!dict_get_str(options, srchkey, &keyval)) {
+            ret = dict_set_str(svc->options, srchkey, keyval);
+            if (ret < 0) {
+                gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error");
+                GF_FREE(srchkey);
                 return (-1);
+            }
+        }
 
-        return rpcsvc_auth_reconf (svc, options);
+        GF_FREE(srchkey);
+        volentry = volentry->next;
+    }
+
+    ret = rpcsvc_init_options(svc, options);
+    if (ret)
+        return (-1);
+
+    return rpcsvc_auth_reconf(svc, options);
 }
 
 int
-rpcsvc_transport_unix_options_build (dict_t **options, char *filepath)
+rpcsvc_transport_unix_options_build(dict_t **options, char *filepath)
 {
-        dict_t                  *dict = NULL;
-        char                    *fpath = NULL;
-        int                     ret = -1;
+    dict_t *dict = NULL;
+    char *fpath = NULL;
+    int ret = -1;
 
-        GF_ASSERT (filepath);
-        GF_ASSERT (options);
+    GF_ASSERT(filepath);
+    GF_ASSERT(options);
 
-        dict = dict_new ();
-        if (!dict)
-                goto out;
+    dict = dict_new();
+    if (!dict)
+        goto out;
 
-        fpath = gf_strdup (filepath);
-        if (!fpath) {
-                ret = -1;
-                goto out;
-        }
+    fpath = gf_strdup(filepath);
+    if (!fpath) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_dynstr (dict, "transport.socket.listen-path", fpath);
-        if (ret)
-                goto out;
+    ret = dict_set_dynstr(dict, "transport.socket.listen-path", fpath);
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "transport.address-family", "unix");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "transport.address-family", "unix");
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "transport.socket.nodelay", "off");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "transport.socket.nodelay", "off");
+    if (ret)
+        goto out;
 
-        ret = dict_set_str (dict, "transport-type", "socket");
-        if (ret)
-                goto out;
+    ret = dict_set_str(dict, "transport-type", "socket");
+    if (ret)
+        goto out;
 
-        *options = dict;
+    *options = dict;
 out:
-        if (ret) {
-                GF_FREE (fpath);
-                if (dict)
-                        dict_unref (dict);
-        }
-        return ret;
+    if (ret) {
+        GF_FREE(fpath);
+        if (dict)
+            dict_unref(dict);
+    }
+    return ret;
 }
 
 /*
@@ -2460,42 +2472,42 @@ out:
  * NB: defval or set-value "0" is special which means unlimited/65536.
  */
 int
-rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue)
+rpcsvc_set_outstanding_rpc_limit(rpcsvc_t *svc, dict_t *options, int defvalue)
 {
-        int            ret        = -1; /* FAILURE */
-        int            rpclim     = 0;
-        static char    *rpclimkey = "rpc.outstanding-rpc-limit";
+    int ret = -1; /* FAILURE */
+    int rpclim = 0;
+    static char *rpclimkey = "rpc.outstanding-rpc-limit";
 
-        if ((!svc) || (!options))
-                return (-1);
+    if ((!svc) || (!options))
+        return (-1);
 
-        if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) ||
-            (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) {
-                return (-1);
-        }
+    if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) ||
+        (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) {
+        return (-1);
+    }
 
-        /* Fetch the rpc.outstanding-rpc-limit from dict. */
-        ret = dict_get_int32 (options, rpclimkey, &rpclim);
-        if (ret < 0) {
-                /* Fall back to default for FAILURE */
-                rpclim = defvalue;
-        }
+    /* Fetch the rpc.outstanding-rpc-limit from dict. */
+    ret = dict_get_int32(options, rpclimkey, &rpclim);
+    if (ret < 0) {
+        /* Fall back to default for FAILURE */
+        rpclim = defvalue;
+    }
 
-        /* Round up to multiple-of-8. It must not exceed
-         * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT.
-         */
-        rpclim = ((rpclim + 8 - 1) >> 3) * 8;
-        if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) {
-                rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT;
-        }
+    /* Round up to multiple-of-8. It must not exceed
+     * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT.
+     */
+    rpclim = ((rpclim + 8 - 1) >> 3) * 8;
+    if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) {
+        rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT;
+    }
 
-        if (svc->outstanding_rpc_limit != rpclim) {
-                svc->outstanding_rpc_limit = rpclim;
-                gf_log (GF_RPCSVC, GF_LOG_INFO,
-                        "Configured %s with value %d", rpclimkey, rpclim);
-        }
+    if (svc->outstanding_rpc_limit != rpclim) {
+        svc->outstanding_rpc_limit = rpclim;
+        gf_log(GF_RPCSVC, GF_LOG_INFO, "Configured %s with value %d", rpclimkey,
+               rpclim);
+    }
 
-        return (0);
+    return (0);
 }
 
 /*
@@ -2503,15 +2515,14 @@ rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue)
  * Returns 0 on success, -1 otherwise.
  */
 int
-rpcsvc_set_throttle_on (rpcsvc_t *svc)
+rpcsvc_set_throttle_on(rpcsvc_t *svc)
 {
+    if (!svc)
+        return -1;
 
-        if (!svc)
-                return -1;
-
-        svc->throttle = _gf_true;
+    svc->throttle = _gf_true;
 
-        return 0;
+    return 0;
 }
 
 /*
@@ -2519,15 +2530,14 @@ rpcsvc_set_throttle_on (rpcsvc_t *svc)
  * Returns 0 on success, -1 otherwise.
  */
 int
-rpcsvc_set_throttle_off (rpcsvc_t *svc)
+rpcsvc_set_throttle_off(rpcsvc_t *svc)
 {
+    if (!svc)
+        return -1;
 
-        if (!svc)
-                return -1;
+    svc->throttle = _gf_false;
 
-        svc->throttle = _gf_false;
-
-        return 0;
+    return 0;
 }
 
 /*
@@ -2535,213 +2545,205 @@ rpcsvc_set_throttle_off (rpcsvc_t *svc)
  * Returns value of attribute throttle on success, _gf_false otherwise.
  */
 gf_boolean_t
-rpcsvc_get_throttle (rpcsvc_t *svc)
+rpcsvc_get_throttle(rpcsvc_t *svc)
 {
+    if (!svc)
+        return _gf_false;
 
-        if (!svc)
-                return _gf_false;
-
-        return svc->throttle;
+    return svc->throttle;
 }
 
 /* The global RPC service initializer.
  */
 rpcsvc_t *
-rpcsvc_init (xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
-             uint32_t poolcount)
+rpcsvc_init(xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options,
+            uint32_t poolcount)
 {
-        rpcsvc_t          *svc              = NULL;
-        int                ret              = -1;
-
-        if ((!xl) || (!ctx) || (!options))
-                return NULL;
-
-        svc = GF_CALLOC (1, sizeof (*svc), gf_common_mt_rpcsvc_t);
-        if (!svc)
-                return NULL;
-
-        pthread_rwlock_init (&svc->rpclock, NULL);
-        INIT_LIST_HEAD (&svc->authschemes);
-        INIT_LIST_HEAD (&svc->notify);
-        INIT_LIST_HEAD (&svc->listeners);
-        INIT_LIST_HEAD (&svc->programs);
+    rpcsvc_t *svc = NULL;
+    int ret = -1;
 
-        ret = rpcsvc_init_options (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init options");
-                goto free_svc;
-        }
-
-        if (!poolcount)
-                poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor;
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount);
-        svc->rxpool = mem_pool_new (rpcsvc_request_t, poolcount);
-        /* TODO: leak */
-        if (!svc->rxpool) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed");
-                goto free_svc;
-        }
-
-        ret = rpcsvc_auth_init (svc, options);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init "
-                        "authentication");
-                goto free_svc;
-        }
-
-        ret = -1;
-        svc->options = options;
-        svc->ctx = ctx;
-        svc->xl = xl;
-        gf_log (GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited.");
-
-        gluster_dump_prog.options = options;
+    if ((!xl) || (!ctx) || (!options))
+        return NULL;
 
-        ret = rpcsvc_program_register (svc, &gluster_dump_prog, _gf_false);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR,
-                        "failed to register DUMP program");
-                goto free_svc;
-        }
+    svc = GF_CALLOC(1, sizeof(*svc), gf_common_mt_rpcsvc_t);
+    if (!svc)
+        return NULL;
 
-        ret = 0;
+    pthread_rwlock_init(&svc->rpclock, NULL);
+    INIT_LIST_HEAD(&svc->authschemes);
+    INIT_LIST_HEAD(&svc->notify);
+    INIT_LIST_HEAD(&svc->listeners);
+    INIT_LIST_HEAD(&svc->programs);
+
+    ret = rpcsvc_init_options(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init options");
+        goto free_svc;
+    }
+
+    if (!poolcount)
+        poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor;
+
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount);
+    svc->rxpool = mem_pool_new(rpcsvc_request_t, poolcount);
+    /* TODO: leak */
+    if (!svc->rxpool) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed");
+        goto free_svc;
+    }
+
+    ret = rpcsvc_auth_init(svc, options);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to init "
+               "authentication");
+        goto free_svc;
+    }
+
+    ret = -1;
+    svc->options = options;
+    svc->ctx = ctx;
+    svc->xl = xl;
+    gf_log(GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited.");
+
+    gluster_dump_prog.options = options;
+
+    ret = rpcsvc_program_register(svc, &gluster_dump_prog, _gf_false);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to register DUMP program");
+        goto free_svc;
+    }
+
+    ret = 0;
 free_svc:
-        if (ret == -1) {
-                GF_FREE (svc);
-                svc = NULL;
-        }
+    if (ret == -1) {
+        GF_FREE(svc);
+        svc = NULL;
+    }
 
-        return svc;
+    return svc;
 }
 
-
 int
-rpcsvc_transport_peer_check_search (dict_t *options, char *pattern,
-                                    char *ip, char *hostname)
+rpcsvc_transport_peer_check_search(dict_t *options, char *pattern, char *ip,
+                                   char *hostname)
 {
-        int                      ret           = -1;
-        char                    *addrtok       = NULL;
-        char                    *addrstr       = NULL;
-        char                    *dup_addrstr   = NULL;
-        char                    *svptr         = NULL;
+    int ret = -1;
+    char *addrtok = NULL;
+    char *addrstr = NULL;
+    char *dup_addrstr = NULL;
+    char *svptr = NULL;
 
-        if ((!options) || (!ip))
-                return -1;
+    if ((!options) || (!ip))
+        return -1;
 
-        ret = dict_get_str (options, pattern, &addrstr);
-        if (ret < 0) {
-                ret = -1;
-                goto err;
-        }
-
-        if (!addrstr) {
-                ret = -1;
-                goto err;
-        }
+    ret = dict_get_str(options, pattern, &addrstr);
+    if (ret < 0) {
+        ret = -1;
+        goto err;
+    }
 
-        dup_addrstr = gf_strdup (addrstr);
-        addrtok = strtok_r (dup_addrstr, ",", &svptr);
-        while (addrtok) {
+    if (!addrstr) {
+        ret = -1;
+        goto err;
+    }
 
-                /* CASEFOLD not present on Solaris */
+    dup_addrstr = gf_strdup(addrstr);
+    addrtok = strtok_r(dup_addrstr, ",", &svptr);
+    while (addrtok) {
+        /* CASEFOLD not present on Solaris */
 #ifdef FNM_CASEFOLD
-                ret = fnmatch (addrtok, ip, FNM_CASEFOLD);
+        ret = fnmatch(addrtok, ip, FNM_CASEFOLD);
 #else
-                ret = fnmatch (addrtok, ip, 0);
+        ret = fnmatch(addrtok, ip, 0);
 #endif
-                if (ret == 0)
-                        goto err;
+        if (ret == 0)
+            goto err;
 
-                /* compare hostnames if applicable */
-                if (hostname) {
+        /* compare hostnames if applicable */
+        if (hostname) {
 #ifdef FNM_CASEFOLD
-                        ret = fnmatch (addrtok, hostname, FNM_CASEFOLD);
+            ret = fnmatch(addrtok, hostname, FNM_CASEFOLD);
 #else
-                        ret = fnmatch (addrtok, hostname, 0);
+            ret = fnmatch(addrtok, hostname, 0);
 #endif
-                        if (ret == 0)
-                                goto err;
-                }
-
-                /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */
-                if (strchr (addrtok, '/')) {
-                        ret = rpcsvc_match_subnet_v4 (addrtok, ip);
-                        if (ret == 0)
-                                goto err;
-                }
+            if (ret == 0)
+                goto err;
+        }
 
-                addrtok = strtok_r (NULL, ",", &svptr);
+        /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */
+        if (strchr(addrtok, '/')) {
+            ret = rpcsvc_match_subnet_v4(addrtok, ip);
+            if (ret == 0)
+                goto err;
         }
 
-        ret = -1;
+        addrtok = strtok_r(NULL, ",", &svptr);
+    }
+
+    ret = -1;
 err:
-        GF_FREE (dup_addrstr);
+    GF_FREE(dup_addrstr);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-rpcsvc_transport_peer_check_allow (dict_t *options, char *volname,
-                                   char *ip, char *hostname)
+rpcsvc_transport_peer_check_allow(dict_t *options, char *volname, char *ip,
+                                  char *hostname)
 {
-        int      ret     = RPCSVC_AUTH_DONTCARE;
-        char    *srchstr = NULL;
+    int ret = RPCSVC_AUTH_DONTCARE;
+    char *srchstr = NULL;
 
-        if ((!options) || (!ip) || (!volname))
-                return ret;
+    if ((!options) || (!ip) || (!volname))
+        return ret;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_DONTCARE;
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_DONTCARE;
+        goto out;
+    }
 
-        ret = rpcsvc_transport_peer_check_search (options, srchstr,
-                                                  ip, hostname);
-        GF_FREE (srchstr);
+    ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname);
+    GF_FREE(srchstr);
 
-        if (ret == 0)
-                ret = RPCSVC_AUTH_ACCEPT;
-        else
-                ret = RPCSVC_AUTH_REJECT;
+    if (ret == 0)
+        ret = RPCSVC_AUTH_ACCEPT;
+    else
+        ret = RPCSVC_AUTH_REJECT;
 out:
-        return ret;
+    return ret;
 }
 
 static int
-rpcsvc_transport_peer_check_reject (dict_t *options, char *volname,
-                                    char *ip, char *hostname)
+rpcsvc_transport_peer_check_reject(dict_t *options, char *volname, char *ip,
+                                   char *hostname)
 {
-        int      ret     = RPCSVC_AUTH_DONTCARE;
-        char    *srchstr = NULL;
+    int ret = RPCSVC_AUTH_DONTCARE;
+    char *srchstr = NULL;
 
-        if ((!options) || (!ip) || (!volname))
-                return ret;
+    if ((!options) || (!ip) || (!volname))
+        return ret;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject",
-                           volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_REJECT;
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_REJECT;
+        goto out;
+    }
 
-        ret = rpcsvc_transport_peer_check_search (options, srchstr,
-                                                  ip, hostname);
-        GF_FREE (srchstr);
+    ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname);
+    GF_FREE(srchstr);
 
-        if (ret == 0)
-                ret = RPCSVC_AUTH_REJECT;
-        else
-                ret = RPCSVC_AUTH_DONTCARE;
+    if (ret == 0)
+        ret = RPCSVC_AUTH_REJECT;
+    else
+        ret = RPCSVC_AUTH_DONTCARE;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Combines rpc auth's allow and reject options.
  * Order of checks is important.
  * First,              REJECT if either rejects.
@@ -2749,188 +2751,188 @@ out:
  * If neither accepts, DONTCARE
  */
 int
-rpcsvc_combine_allow_reject_volume_check (int allow, int reject)
+rpcsvc_combine_allow_reject_volume_check(int allow, int reject)
 {
-        if (allow == RPCSVC_AUTH_REJECT ||
-            reject == RPCSVC_AUTH_REJECT)
-                return RPCSVC_AUTH_REJECT;
+    if (allow == RPCSVC_AUTH_REJECT || reject == RPCSVC_AUTH_REJECT)
+        return RPCSVC_AUTH_REJECT;
 
-        if (allow == RPCSVC_AUTH_ACCEPT ||
-            reject == RPCSVC_AUTH_ACCEPT)
-                return RPCSVC_AUTH_ACCEPT;
+    if (allow == RPCSVC_AUTH_ACCEPT || reject == RPCSVC_AUTH_ACCEPT)
+        return RPCSVC_AUTH_ACCEPT;
 
-        return RPCSVC_AUTH_DONTCARE;
+    return RPCSVC_AUTH_DONTCARE;
 }
 
 int
-rpcsvc_auth_check (rpcsvc_t *svc, char *volname, char *ipaddr)
-{
-        int     ret                            = RPCSVC_AUTH_REJECT;
-        int     accept                         = RPCSVC_AUTH_REJECT;
-        int     reject                         = RPCSVC_AUTH_REJECT;
-        char   *hostname                       = NULL;
-        char   *allow_str                      = NULL;
-        char   *reject_str                     = NULL;
-        char   *srchstr                        = NULL;
-        dict_t *options                        = NULL;
-
-        if (!svc || !volname || !ipaddr)
-                return ret;
-
-        /* Fetch the options from svc struct and validate */
-        options = svc->options;
-        if (!options)
-                return ret;
-
-        /* Accept if its the default case: Allow all, Reject none
-         * The default volfile always contains a 'allow *' rule
-         * for each volume. If allow rule is missing (which implies
-         * there is some bad volfile generating code doing this), we
-         * assume no one is allowed mounts, and thus, we reject mounts.
-         */
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                return RPCSVC_AUTH_REJECT;
-        }
-
-        ret = dict_get_str (options, srchstr, &allow_str);
-        GF_FREE (srchstr);
-        if (ret < 0)
-                return RPCSVC_AUTH_REJECT;
-
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                return RPCSVC_AUTH_REJECT;
-        }
-
-        ret = dict_get_str (options, srchstr, &reject_str);
-        GF_FREE (srchstr);
+rpcsvc_auth_check(rpcsvc_t *svc, char *volname, char *ipaddr)
+{
+    int ret = RPCSVC_AUTH_REJECT;
+    int accept = RPCSVC_AUTH_REJECT;
+    int reject = RPCSVC_AUTH_REJECT;
+    char *hostname = NULL;
+    char *allow_str = NULL;
+    char *reject_str = NULL;
+    char *srchstr = NULL;
+    dict_t *options = NULL;
+
+    if (!svc || !volname || !ipaddr)
+        return ret;
 
-        /*
-         * If "reject_str" is being set as '*' (anonymous), then NFS-server
-         * would reject everything. If the "reject_str" is not set and
-         * "allow_str" is set as '*' (anonymous), then NFS-server would
-         * accept mount requests from all clients.
-         */
-        if (reject_str != NULL) {
-                if (!strcmp ("*", reject_str))
-                        return RPCSVC_AUTH_REJECT;
-        } else {
-                if (!strcmp ("*", allow_str))
-                        return RPCSVC_AUTH_ACCEPT;
-        }
+    /* Fetch the options from svc struct and validate */
+    options = svc->options;
+    if (!options)
+        return ret;
 
-        /* addr-namelookup check */
-        if (svc->addr_namelookup == _gf_true) {
-                ret = gf_get_hostname_from_ip (ipaddr, &hostname);
-                if (ret) {
-                        if (hostname)
-                                GF_FREE (hostname);
-                        /* failed to get hostname, but hostname auth
-                         * is enabled, so authentication will not be
-                         * 100% correct. reject mounts
-                         */
-                        return RPCSVC_AUTH_REJECT;
-                }
+    /* Accept if its the default case: Allow all, Reject none
+     * The default volfile always contains a 'allow *' rule
+     * for each volume. If allow rule is missing (which implies
+     * there is some bad volfile generating code doing this), we
+     * assume no one is allowed mounts, and thus, we reject mounts.
+     */
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        return RPCSVC_AUTH_REJECT;
+    }
+
+    ret = dict_get_str(options, srchstr, &allow_str);
+    GF_FREE(srchstr);
+    if (ret < 0)
+        return RPCSVC_AUTH_REJECT;
+
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        return RPCSVC_AUTH_REJECT;
+    }
+
+    ret = dict_get_str(options, srchstr, &reject_str);
+    GF_FREE(srchstr);
+
+    /*
+     * If "reject_str" is being set as '*' (anonymous), then NFS-server
+     * would reject everything. If the "reject_str" is not set and
+     * "allow_str" is set as '*' (anonymous), then NFS-server would
+     * accept mount requests from all clients.
+     */
+    if (reject_str != NULL) {
+        if (!strcmp("*", reject_str))
+            return RPCSVC_AUTH_REJECT;
+    } else {
+        if (!strcmp("*", allow_str))
+            return RPCSVC_AUTH_ACCEPT;
+    }
+
+    /* addr-namelookup check */
+    if (svc->addr_namelookup == _gf_true) {
+        ret = gf_get_hostname_from_ip(ipaddr, &hostname);
+        if (ret) {
+            if (hostname)
+                GF_FREE(hostname);
+            /* failed to get hostname, but hostname auth
+             * is enabled, so authentication will not be
+             * 100% correct. reject mounts
+             */
+            return RPCSVC_AUTH_REJECT;
         }
+    }
 
-        accept = rpcsvc_transport_peer_check_allow (options, volname,
-                                                    ipaddr, hostname);
+    accept = rpcsvc_transport_peer_check_allow(options, volname, ipaddr,
+                                               hostname);
 
-        reject = rpcsvc_transport_peer_check_reject (options, volname,
-                                                     ipaddr, hostname);
+    reject = rpcsvc_transport_peer_check_reject(options, volname, ipaddr,
+                                                hostname);
 
-        if (hostname)
-                GF_FREE (hostname);
-        return rpcsvc_combine_allow_reject_volume_check (accept, reject);
+    if (hostname)
+        GF_FREE(hostname);
+    return rpcsvc_combine_allow_reject_volume_check(accept, reject);
 }
 
 int
-rpcsvc_transport_privport_check (rpcsvc_t *svc, char *volname, uint16_t port)
+rpcsvc_transport_privport_check(rpcsvc_t *svc, char *volname, uint16_t port)
 {
-        int                     ret = RPCSVC_AUTH_REJECT;
-        char                    *srchstr = NULL;
-        char                    *valstr = NULL;
-        gf_boolean_t            insecure = _gf_false;
-
-        if ((!svc) || (!volname))
-                return ret;
-
-        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port);
-        /* If the port is already a privileged one, don't bother with checking
-         * options.
-         */
-        if (port <= 1024) {
-                ret = RPCSVC_AUTH_ACCEPT;
-                goto err;
-        }
-
-        /* Disabled by default */
-        ret = gf_asprintf (&srchstr, "rpc-auth.ports.%s.insecure", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
+    int ret = RPCSVC_AUTH_REJECT;
+    char *srchstr = NULL;
+    char *valstr = NULL;
+    gf_boolean_t insecure = _gf_false;
 
-        ret = dict_get_str (svc->options, srchstr, &valstr);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to"
-                        " read rpc-auth.ports.insecure value");
-                goto err;
-        }
-
-        ret = gf_string2boolean (valstr, &insecure);
-        if (ret) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to"
-                        " convert rpc-auth.ports.insecure value");
-                goto err;
-        }
+    if ((!svc) || (!volname))
+        return ret;
 
-        ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT;
-
-        if (ret == RPCSVC_AUTH_ACCEPT)
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed");
-        else
-                gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port not"
-                        " allowed");
+    gf_log(GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port);
+    /* If the port is already a privileged one, don't bother with checking
+     * options.
+     */
+    if (port <= 1024) {
+        ret = RPCSVC_AUTH_ACCEPT;
+        goto err;
+    }
+
+    /* Disabled by default */
+    ret = gf_asprintf(&srchstr, "rpc-auth.ports.%s.insecure", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    ret = dict_get_str(svc->options, srchstr, &valstr);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to"
+               " read rpc-auth.ports.insecure value");
+        goto err;
+    }
+
+    ret = gf_string2boolean(valstr, &insecure);
+    if (ret) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR,
+               "Failed to"
+               " convert rpc-auth.ports.insecure value");
+        goto err;
+    }
+
+    ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT;
+
+    if (ret == RPCSVC_AUTH_ACCEPT)
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed");
+    else
+        gf_log(GF_RPCSVC, GF_LOG_DEBUG,
+               "Unprivileged port not"
+               " allowed");
 
 err:
-        if (srchstr)
-                GF_FREE (srchstr);
+    if (srchstr)
+        GF_FREE(srchstr);
 
-        return ret;
+    return ret;
 }
 
-
 char *
-rpcsvc_volume_allowed (dict_t *options, char *volname)
+rpcsvc_volume_allowed(dict_t *options, char *volname)
 {
-        char    globalrule[] = "rpc-auth.addr.allow";
-        char    *srchstr = NULL;
-        char    *addrstr = NULL;
-        int     ret = -1;
+    char globalrule[] = "rpc-auth.addr.allow";
+    char *srchstr = NULL;
+    char *addrstr = NULL;
+    int ret = -1;
 
-        if ((!options) || (!volname))
-                return NULL;
+    if ((!options) || (!volname))
+        return NULL;
 
-        ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname);
-        if (ret == -1) {
-                gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
-                goto out;
-        }
+    ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname);
+    if (ret == -1) {
+        gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed");
+        goto out;
+    }
 
-        if (!dict_get (options, srchstr))
-                ret = dict_get_str (options, globalrule, &addrstr);
-        else
-                ret = dict_get_str (options, srchstr, &addrstr);
+    if (!dict_get(options, srchstr))
+        ret = dict_get_str(options, globalrule, &addrstr);
+    else
+        ret = dict_get_str(options, srchstr, &addrstr);
 
 out:
-        GF_FREE (srchstr);
+    GF_FREE(srchstr);
 
-        return addrstr;
+    return addrstr;
 }
 
 /*
@@ -2944,56 +2946,61 @@ out:
  *     as it's already being done at the time of CLI SET.
  */
 static int
-rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr)
-{
-        char                 *slash     = NULL;
-        char                 *netaddr   = NULL;
-        int                   ret       = -1;
-        uint32_t              prefixlen = 0;
-        uint32_t              shift     = 0;
-        struct sockaddr_in    sin1      = {0, };
-        struct sockaddr_in    sin2      = {0, };
-        struct sockaddr_in    mask      = {0, };
-
-        /* Copy the input */
-        netaddr = gf_strdup (addrtok);
-        if (netaddr == NULL) /* ENOMEM */
-                goto out;
-
-        /* Find the network socket addr of target */
-        if (inet_pton (AF_INET, ipaddr, &sin1.sin_addr) == 0)
-                goto out;
-
-        /* Find the network socket addr of subnet pattern */
-        if (inet_pton (AF_INET, netaddr, &sin2.sin_addr) == 0)
-                goto out;
-
-        slash = strchr (netaddr, '/');
-        if (slash) {
-                *slash = '\0';
-                /*
-                 * Find the IPv4 network mask in network byte order.
-                 * IMP: String slash+1 is already validated, it can't have value
-                 * more than IPv4_ADDR_SIZE (32).
-                 */
-                prefixlen = (uint32_t) atoi (slash + 1);
-                if (prefixlen > 31)
-                        goto out;
-        } else {
-                goto out;
-        }
-
-        shift = IPv4_ADDR_SIZE - prefixlen;
-        mask.sin_addr.s_addr = htonl ((uint32_t)~0 << shift);
-
-        if (mask_match (sin1.sin_addr.s_addr,
-                        sin2.sin_addr.s_addr,
-                        mask.sin_addr.s_addr)) {
-                ret = 0; /* SUCCESS */
-        }
+rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr)
+{
+    char *slash = NULL;
+    char *netaddr = NULL;
+    int ret = -1;
+    uint32_t prefixlen = 0;
+    uint32_t shift = 0;
+    struct sockaddr_in sin1 = {
+        0,
+    };
+    struct sockaddr_in sin2 = {
+        0,
+    };
+    struct sockaddr_in mask = {
+        0,
+    };
+
+    /* Copy the input */
+    netaddr = gf_strdup(addrtok);
+    if (netaddr == NULL) /* ENOMEM */
+        goto out;
+
+    /* Find the network socket addr of target */
+    if (inet_pton(AF_INET, ipaddr, &sin1.sin_addr) == 0)
+        goto out;
+
+    /* Find the network socket addr of subnet pattern */
+    if (inet_pton(AF_INET, netaddr, &sin2.sin_addr) == 0)
+        goto out;
+
+    slash = strchr(netaddr, '/');
+    if (slash) {
+        *slash = '\0';
+        /*
+         * Find the IPv4 network mask in network byte order.
+         * IMP: String slash+1 is already validated, it can't have value
+         * more than IPv4_ADDR_SIZE (32).
+         */
+        prefixlen = (uint32_t)atoi(slash + 1);
+        if (prefixlen > 31)
+            goto out;
+    } else {
+        goto out;
+    }
+
+    shift = IPv4_ADDR_SIZE - prefixlen;
+    mask.sin_addr.s_addr = htonl((uint32_t)~0 << shift);
+
+    if (mask_match(sin1.sin_addr.s_addr, sin2.sin_addr.s_addr,
+                   mask.sin_addr.s_addr)) {
+        ret = 0; /* SUCCESS */
+    }
 out:
-        GF_FREE (netaddr);
-        return ret;
+    GF_FREE(netaddr);
+    return ret;
 }
 
 /* During reconfigure, Make sure to call this function after event-threads are
@@ -3001,45 +3008,43 @@ out:
  */
 
 int
-rpcsvc_ownthread_reconf (rpcsvc_t *svc, int new_eventthreadcount)
+rpcsvc_ownthread_reconf(rpcsvc_t *svc, int new_eventthreadcount)
 {
-        int ret = -1;
-        rpcsvc_program_t *program = NULL;
+    int ret = -1;
+    rpcsvc_program_t *program = NULL;
 
-        if (!svc) {
-                ret = 0;
-                goto out;
-        }
+    if (!svc) {
+        ret = 0;
+        goto out;
+    }
 
-        pthread_rwlock_wrlock (&svc->rpclock);
+    pthread_rwlock_wrlock(&svc->rpclock);
+    {
+        list_for_each_entry(program, &svc->programs, program)
         {
-                list_for_each_entry (program, &svc->programs, program) {
-                        if (program->ownthread) {
-                                program->eventthreadcount =
-                                        new_eventthreadcount;
-                                rpcsvc_spawn_threads (svc, program);
-                        }
-                }
+            if (program->ownthread) {
+                program->eventthreadcount = new_eventthreadcount;
+                rpcsvc_spawn_threads(svc, program);
+            }
         }
-        pthread_rwlock_unlock (&svc->rpclock);
+    }
+    pthread_rwlock_unlock(&svc->rpclock);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 rpcsvc_actor_t gluster_dump_actors[GF_DUMP_MAXVALUE] = {
-        [GF_DUMP_NULL]      = {"NULL",     GF_DUMP_NULL,     NULL,        NULL, 0, DRC_NA},
-        [GF_DUMP_DUMP]      = {"DUMP",     GF_DUMP_DUMP,     rpcsvc_dump, NULL, 0, DRC_NA},
-        [GF_DUMP_PING]      = {"PING",     GF_DUMP_PING,     rpcsvc_ping, NULL, 0, DRC_NA},
+    [GF_DUMP_NULL] = {"NULL", GF_DUMP_NULL, NULL, NULL, 0, DRC_NA},
+    [GF_DUMP_DUMP] = {"DUMP", GF_DUMP_DUMP, rpcsvc_dump, NULL, 0, DRC_NA},
+    [GF_DUMP_PING] = {"PING", GF_DUMP_PING, rpcsvc_ping, NULL, 0, DRC_NA},
 };
 
-
 struct rpcsvc_program gluster_dump_prog = {
-        .progname  = "GF-DUMP",
-        .prognum   = GLUSTER_DUMP_PROGRAM,
-        .progver   = GLUSTER_DUMP_VERSION,
-        .actors    = gluster_dump_actors,
-        .numactors = GF_DUMP_MAXVALUE,
+    .progname = "GF-DUMP",
+    .prognum = GLUSTER_DUMP_PROGRAM,
+    .progver = GLUSTER_DUMP_VERSION,
+    .actors = gluster_dump_actors,
+    .numactors = GF_DUMP_MAXVALUE,
 };
diff --git a/rpc/rpc-lib/src/xdr-rpc.c b/rpc/rpc-lib/src/xdr-rpc.c
index 88a7637b887..36fd9db1a97 100644
--- a/rpc/rpc-lib/src/xdr-rpc.c
+++ b/rpc/rpc-lib/src/xdr-rpc.c
@@ -25,183 +25,178 @@
  * The remaining payload is returned into payload.
  */
 int
-xdr_to_rpc_call (char *msgbuf, size_t len, struct rpc_msg *call,
-                 struct iovec *payload, char *credbytes, char *verfbytes)
+xdr_to_rpc_call(char *msgbuf, size_t len, struct rpc_msg *call,
+                struct iovec *payload, char *credbytes, char *verfbytes)
 {
-        XDR                     xdr;
-        char                    opaquebytes[GF_MAX_AUTH_BYTES];
-        struct opaque_auth      *oa = NULL;
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", call, out);
-
-        memset (call, 0, sizeof (*call));
-
-        oa = &call->rm_call.cb_cred;
-        if (!credbytes)
-                oa->oa_base = opaquebytes;
-        else
-                oa->oa_base = credbytes;
-
-        oa = &call->rm_call.cb_verf;
-        if (!verfbytes)
-                oa->oa_base = opaquebytes;
-        else
-                oa->oa_base = verfbytes;
-
-        xdrmem_create (&xdr, msgbuf, len, XDR_DECODE);
-        if (!xdr_callmsg (&xdr, call)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode call msg");
-                goto out;
-        }
-
-        if (payload) {
-                payload->iov_base = xdr_decoded_remaining_addr (xdr);
-                payload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
-
-        ret = 0;
+    XDR xdr;
+    char opaquebytes[GF_MAX_AUTH_BYTES];
+    struct opaque_auth *oa = NULL;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", call, out);
+
+    memset(call, 0, sizeof(*call));
+
+    oa = &call->rm_call.cb_cred;
+    if (!credbytes)
+        oa->oa_base = opaquebytes;
+    else
+        oa->oa_base = credbytes;
+
+    oa = &call->rm_call.cb_verf;
+    if (!verfbytes)
+        oa->oa_base = opaquebytes;
+    else
+        oa->oa_base = verfbytes;
+
+    xdrmem_create(&xdr, msgbuf, len, XDR_DECODE);
+    if (!xdr_callmsg(&xdr, call)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode call msg");
+        goto out;
+    }
+
+    if (payload) {
+        payload->iov_base = xdr_decoded_remaining_addr(xdr);
+        payload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 bool_t
-true_func (XDR *s, caddr_t *a)
+true_func(XDR *s, caddr_t *a)
 {
-        return TRUE;
+    return TRUE;
 }
 
-
 int
-rpc_fill_empty_reply (struct rpc_msg *reply, uint32_t xid)
+rpc_fill_empty_reply(struct rpc_msg *reply, uint32_t xid)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
 
-        /* Setting to 0 also results in reply verifier flavor to be
-         * set to AUTH_NULL which is what we want right now.
-         */
-        memset (reply, 0, sizeof (*reply));
-        reply->rm_xid = xid;
-        reply->rm_direction = REPLY;
+    /* Setting to 0 also results in reply verifier flavor to be
+     * set to AUTH_NULL which is what we want right now.
+     */
+    memset(reply, 0, sizeof(*reply));
+    reply->rm_xid = xid;
+    reply->rm_direction = REPLY;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_fill_denied_reply (struct rpc_msg *reply, int rjstat, int auth_err)
+rpc_fill_denied_reply(struct rpc_msg *reply, int rjstat, int auth_err)
 {
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-
-        reply->rm_reply.rp_stat = MSG_DENIED;
-        reply->rjcted_rply.rj_stat = rjstat;
-        if (rjstat == RPC_MISMATCH) {
-                /* No problem with hardcoding
-                 * RPC version numbers. We only support
-                 * v2 anyway.
-                 */
-                reply->rjcted_rply.rj_vers.low = 2;
-                reply->rjcted_rply.rj_vers.high = 2;
-        } else if (rjstat == AUTH_ERROR)
-                reply->rjcted_rply.rj_why = auth_err;
-
-        ret = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+
+    reply->rm_reply.rp_stat = MSG_DENIED;
+    reply->rjcted_rply.rj_stat = rjstat;
+    if (rjstat == RPC_MISMATCH) {
+        /* No problem with hardcoding
+         * RPC version numbers. We only support
+         * v2 anyway.
+         */
+        reply->rjcted_rply.rj_vers.low = 2;
+        reply->rjcted_rply.rj_vers.high = 2;
+    } else if (rjstat == AUTH_ERROR)
+        reply->rjcted_rply.rj_why = auth_err;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpc_fill_accepted_reply (struct rpc_msg *reply, int arstat, int proglow,
-                         int proghigh, int verf, int len, char *vdata)
+rpc_fill_accepted_reply(struct rpc_msg *reply, int arstat, int proglow,
+                        int proghigh, int verf, int len, char *vdata)
 {
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-
-        reply->rm_reply.rp_stat = MSG_ACCEPTED;
-        reply->acpted_rply.ar_stat = arstat;
-
-        reply->acpted_rply.ar_verf.oa_flavor = verf;
-        reply->acpted_rply.ar_verf.oa_length = len;
-        reply->acpted_rply.ar_verf.oa_base = vdata;
-        if (arstat == PROG_MISMATCH) {
-                reply->acpted_rply.ar_vers.low = proglow;
-                reply->acpted_rply.ar_vers.high = proghigh;
-        } else if (arstat == SUCCESS) {
-
-                /* This is a hack. I'd really like to build a custom
-                 * XDR library because Sun RPC interface is not very flexible.
-                 */
-                reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func;
-                reply->acpted_rply.ar_results.where = NULL;
-        }
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+
+    reply->rm_reply.rp_stat = MSG_ACCEPTED;
+    reply->acpted_rply.ar_stat = arstat;
+
+    reply->acpted_rply.ar_verf.oa_flavor = verf;
+    reply->acpted_rply.ar_verf.oa_length = len;
+    reply->acpted_rply.ar_verf.oa_base = vdata;
+    if (arstat == PROG_MISMATCH) {
+        reply->acpted_rply.ar_vers.low = proglow;
+        reply->acpted_rply.ar_vers.high = proghigh;
+    } else if (arstat == SUCCESS) {
+        /* This is a hack. I'd really like to build a custom
+         * XDR library because Sun RPC interface is not very flexible.
+         */
+        reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func;
+        reply->acpted_rply.ar_results.where = NULL;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-rpc_reply_to_xdr (struct rpc_msg *reply, char *dest, size_t len,
-                  struct iovec *dst)
+rpc_reply_to_xdr(struct rpc_msg *reply, char *dest, size_t len,
+                 struct iovec *dst)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dst, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", dst, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_ENCODE);
-        if (!xdr_replymsg(&xdr, reply)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to encode reply msg");
-                goto out;
-        }
+    xdrmem_create(&xdr, dest, len, XDR_ENCODE);
+    if (!xdr_replymsg(&xdr, reply)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to encode reply msg");
+        goto out;
+    }
 
-        dst->iov_base = dest;
-        dst->iov_len = xdr_encoded_length (xdr);
+    dst->iov_base = dest;
+    dst->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-xdr_to_auth_unix_cred (char *msgbuf, int msglen, struct authunix_parms *au,
-                       char *machname, gid_t *gids)
+xdr_to_auth_unix_cred(char *msgbuf, int msglen, struct authunix_parms *au,
+                      char *machname, gid_t *gids)
 {
-        XDR             xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", machname, out);
-        GF_VALIDATE_OR_GOTO ("rpc", gids, out);
-        GF_VALIDATE_OR_GOTO ("rpc", au, out);
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", machname, out);
+    GF_VALIDATE_OR_GOTO("rpc", gids, out);
+    GF_VALIDATE_OR_GOTO("rpc", au, out);
 
-        au->aup_machname = machname;
+    au->aup_machname = machname;
 #if defined(GF_DARWIN_HOST_OS) || defined(__FreeBSD__)
-        au->aup_gids = (int *)gids;
+    au->aup_gids = (int *)gids;
 #else
-        au->aup_gids = gids;
+    au->aup_gids = gids;
 #endif
 
-        xdrmem_create (&xdr, msgbuf, msglen, XDR_DECODE);
+    xdrmem_create(&xdr, msgbuf, msglen, XDR_DECODE);
 
-        if (!xdr_authunix_parms (&xdr, au)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode auth unix parms");
-                goto out;
-        }
+    if (!xdr_authunix_parms(&xdr, au)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode auth unix parms");
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-lib/src/xdr-rpcclnt.c b/rpc/rpc-lib/src/xdr-rpcclnt.c
index 5b470442d71..9e60d19e7a2 100644
--- a/rpc/rpc-lib/src/xdr-rpcclnt.c
+++ b/rpc/rpc-lib/src/xdr-rpcclnt.c
@@ -26,86 +26,84 @@
  * The remaining payload is returned into payload.
  */
 int
-xdr_to_rpc_reply (char *msgbuf, size_t len, struct rpc_msg *reply,
-                  struct iovec *payload, char *verfbytes)
+xdr_to_rpc_reply(char *msgbuf, size_t len, struct rpc_msg *reply,
+                 struct iovec *payload, char *verfbytes)
 {
-        XDR                     xdr;
-        int                     ret = -EINVAL;
+    XDR xdr;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out);
-        GF_VALIDATE_OR_GOTO ("rpc", reply, out);
+    GF_VALIDATE_OR_GOTO("rpc", msgbuf, out);
+    GF_VALIDATE_OR_GOTO("rpc", reply, out);
 
-        memset (reply, 0, sizeof (struct rpc_msg));
+    memset(reply, 0, sizeof(struct rpc_msg));
 
-        reply->acpted_rply.ar_verf = _null_auth;
-        reply->acpted_rply.ar_results.where = NULL;
-        reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void);
+    reply->acpted_rply.ar_verf = _null_auth;
+    reply->acpted_rply.ar_results.where = NULL;
+    reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void);
 
-        xdrmem_create (&xdr, msgbuf, len, XDR_DECODE);
-        if (!xdr_replymsg (&xdr, reply)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode reply msg");
-                goto out;
-        }
-        if (payload) {
-                payload->iov_base = xdr_decoded_remaining_addr (xdr);
-                payload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
+    xdrmem_create(&xdr, msgbuf, len, XDR_DECODE);
+    if (!xdr_replymsg(&xdr, reply)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode reply msg");
+        goto out;
+    }
+    if (payload) {
+        payload->iov_base = xdr_decoded_remaining_addr(xdr);
+        payload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-rpc_request_to_xdr (struct rpc_msg *request, char *dest, size_t len,
-                    struct iovec *dst)
+rpc_request_to_xdr(struct rpc_msg *request, char *dest, size_t len,
+                   struct iovec *dst)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", request, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dst, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", request, out);
+    GF_VALIDATE_OR_GOTO("rpc", dst, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_ENCODE);
-        if (!xdr_callmsg (&xdr, request)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to encode call msg");
-                goto out;
-        }
+    xdrmem_create(&xdr, dest, len, XDR_ENCODE);
+    if (!xdr_callmsg(&xdr, request)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to encode call msg");
+        goto out;
+    }
 
-        dst->iov_base = dest;
-        dst->iov_len = xdr_encoded_length (xdr);
+    dst->iov_base = dest;
+    dst->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-auth_unix_cred_to_xdr (struct authunix_parms *au, char *dest, size_t len,
-                       struct iovec *iov)
+auth_unix_cred_to_xdr(struct authunix_parms *au, char *dest, size_t len,
+                      struct iovec *iov)
 {
-        XDR xdr;
-        int ret = -1;
+    XDR xdr;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("rpc", au, out);
-        GF_VALIDATE_OR_GOTO ("rpc", dest, out);
-        GF_VALIDATE_OR_GOTO ("rpc", iov, out);
+    GF_VALIDATE_OR_GOTO("rpc", au, out);
+    GF_VALIDATE_OR_GOTO("rpc", dest, out);
+    GF_VALIDATE_OR_GOTO("rpc", iov, out);
 
-        xdrmem_create (&xdr, dest, len, XDR_DECODE);
+    xdrmem_create(&xdr, dest, len, XDR_DECODE);
 
-        if (!xdr_authunix_parms (&xdr, au)) {
-                gf_log ("rpc", GF_LOG_WARNING, "failed to decode authunix parms");
-                goto out;
-        }
+    if (!xdr_authunix_parms(&xdr, au)) {
+        gf_log("rpc", GF_LOG_WARNING, "failed to decode authunix parms");
+        goto out;
+    }
 
-        iov->iov_base = dest;
-        iov->iov_len = xdr_encoded_length (xdr);
+    iov->iov_base = dest;
+    iov->iov_len = xdr_encoded_length(xdr);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-transport/rdma/src/name.c b/rpc/rpc-transport/rdma/src/name.c
index 2db1f08c751..ea960cba4eb 100644
--- a/rpc/rpc-transport/rdma/src/name.c
+++ b/rpc/rpc-transport/rdma/src/name.c
@@ -25,85 +25,82 @@
 #include "rpc-lib-messages.h"
 #include "rpc-trans-rdma-messages.h"
 
-
 int32_t
-gf_resolve_ip6 (const char *hostname,
-                uint16_t port,
-                int family,
-                void **dnscache,
-                struct addrinfo **addr_info);
-
+gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
+               struct addrinfo **addr_info);
 
 static void
-_assign_port (struct sockaddr *sockaddr, uint16_t port)
+_assign_port(struct sockaddr *sockaddr, uint16_t port)
 {
-        switch (sockaddr->sa_family) {
+    switch (sockaddr->sa_family) {
         case AF_INET6:
-                ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port);
-                break;
+            ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port);
+            break;
 
         case AF_INET_SDP:
         case AF_INET:
-                ((struct sockaddr_in *)sockaddr)->sin_port = htons (port);
-                break;
-        }
+            ((struct sockaddr_in *)sockaddr)->sin_port = htons(port);
+            break;
+    }
 }
 
 static int32_t
-af_inet_bind_to_port_lt_ceiling (struct rdma_cm_id *cm_id,
-                                 struct sockaddr *sockaddr,
-                                 socklen_t sockaddr_len, uint32_t ceiling)
+af_inet_bind_to_port_lt_ceiling(struct rdma_cm_id *cm_id,
+                                struct sockaddr *sockaddr,
+                                socklen_t sockaddr_len, uint32_t ceiling)
 {
 #if GF_DISABLE_PRIVPORT_TRACKING
-        _assign_port (sockaddr, 0);
-        return rdma_bind_addr (cm_id, sockaddr);
+    _assign_port(sockaddr, 0);
+    return rdma_bind_addr(cm_id, sockaddr);
 #else
-        int32_t         ret                             = -1;
-        uint16_t        port                            = ceiling - 1;
-        unsigned char   ports[GF_PORT_ARRAY_SIZE]       = {0,};
-        int             i                               = 0;
+    int32_t ret = -1;
+    uint16_t port = ceiling - 1;
+    unsigned char ports[GF_PORT_ARRAY_SIZE] = {
+        0,
+    };
+    int i = 0;
 
 loop:
-        ret = gf_process_reserved_ports (ports, ceiling);
+    ret = gf_process_reserved_ports(ports, ceiling);
 
-        while (port) {
-                if (port == GF_CLIENT_PORT_CEILING) {
-                        ret = -1;
-                        break;
-                }
+    while (port) {
+        if (port == GF_CLIENT_PORT_CEILING) {
+            ret = -1;
+            break;
+        }
 
-                /* ignore the reserved ports */
-                if (BIT_VALUE (ports, port)) {
-                        port--;
-                        continue;
-                }
+        /* ignore the reserved ports */
+        if (BIT_VALUE(ports, port)) {
+            port--;
+            continue;
+        }
 
-                _assign_port (sockaddr, port);
+        _assign_port(sockaddr, port);
 
-                ret = rdma_bind_addr (cm_id, sockaddr);
+        ret = rdma_bind_addr(cm_id, sockaddr);
 
-                if (ret == 0)
-                        break;
+        if (ret == 0)
+            break;
 
-                if (ret == -1 && errno == EACCES)
-                        break;
+        if (ret == -1 && errno == EACCES)
+            break;
 
-                port--;
-        }
+        port--;
+    }
 
-        /* In case if all the secure ports are exhausted, we are no more
-         * binding to secure ports, hence instead of getting a random
-         * port, lets define the range to restrict it from getting from
-         * ports reserved for bricks i.e from range of 49152 - 65535
-         * which further may lead to port clash */
-        if (!port) {
-                ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
-                for (i = 0; i <= ceiling; i++)
-                        BIT_CLEAR (ports, i);
-                goto loop;
-        }
+    /* In case if all the secure ports are exhausted, we are no more
+     * binding to secure ports, hence instead of getting a random
+     * port, lets define the range to restrict it from getting from
+     * ports reserved for bricks i.e from range of 49152 - 65535
+     * which further may lead to port clash */
+    if (!port) {
+        ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
+        for (i = 0; i <= ceiling; i++)
+            BIT_CLEAR(ports, i);
+        goto loop;
+    }
 
-        return ret;
+    return ret;
 #endif /* GF_DISABLE_PRIVPORT_TRACKING */
 }
 
@@ -146,596 +143,573 @@ err:
 #endif
 
 static int32_t
-client_fill_address_family (rpc_transport_t *this, struct sockaddr *sockaddr)
+client_fill_address_family(rpc_transport_t *this, struct sockaddr *sockaddr)
 {
-        data_t *address_family_data = NULL;
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (!address_family_data) {
-                data_t *remote_host_data = NULL, *connect_path_data = NULL;
-                remote_host_data = dict_get (this->options, "remote-host");
-                connect_path_data = dict_get (this->options,
-                                              "transport.rdma.connect-path");
-
-                if (!(remote_host_data || connect_path_data) ||
-                    (remote_host_data && connect_path_data)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED,
-                                "address-family not specified and not able to "
-                                "determine the same from other options "
-                                "(remote-host:%s and connect-path:%s)",
-                                data_to_str (remote_host_data),
-                                data_to_str (connect_path_data));
-                        return -1;
-                }
+    data_t *address_family_data = NULL;
+
+    address_family_data = dict_get(this->options, "transport.address-family");
+    if (!address_family_data) {
+        data_t *remote_host_data = NULL, *connect_path_data = NULL;
+        remote_host_data = dict_get(this->options, "remote-host");
+        connect_path_data = dict_get(this->options,
+                                     "transport.rdma.connect-path");
+
+        if (!(remote_host_data || connect_path_data) ||
+            (remote_host_data && connect_path_data)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED,
+                   "address-family not specified and not able to "
+                   "determine the same from other options "
+                   "(remote-host:%s and connect-path:%s)",
+                   data_to_str(remote_host_data),
+                   data_to_str(connect_path_data));
+            return -1;
+        }
 
-                if (remote_host_data) {
-                        gf_msg_debug (this->name, 0, "address-family not "
-                                      "specified, guessing it to be "
-                                      "inet/inet6");
-                        sockaddr->sa_family = AF_UNSPEC;
-                } else {
-                        gf_msg_debug (this->name, 0, "address-family not "
-                                      "specified, guessing it to be unix");
-                        sockaddr->sa_family = AF_UNIX;
-                }
+        if (remote_host_data) {
+            gf_msg_debug(this->name, 0,
+                         "address-family not "
+                         "specified, guessing it to be "
+                         "inet/inet6");
+            sockaddr->sa_family = AF_UNSPEC;
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "address-family not "
+                         "specified, guessing it to be unix");
+            sockaddr->sa_family = AF_UNIX;
+        }
 
+    } else {
+        char *address_family = data_to_str(address_family_data);
+        if (!strcasecmp(address_family, "unix")) {
+            sockaddr->sa_family = AF_UNIX;
+        } else if (!strcasecmp(address_family, "inet")) {
+            sockaddr->sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            sockaddr->sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            sockaddr->sa_family = AF_INET_SDP;
         } else {
-                char *address_family = data_to_str (address_family_data);
-                if (!strcasecmp (address_family, "unix")) {
-                        sockaddr->sa_family = AF_UNIX;
-                } else if (!strcasecmp (address_family, "inet")) {
-                        sockaddr->sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        sockaddr->sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        sockaddr->sa_family = AF_INET_SDP;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                                "unknown address-family (%s) specified",
-                                address_family);
-                        sockaddr->sa_family = AF_UNSPEC;
-                        return -1;
-                }
+            gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY,
+                   "unknown address-family (%s) specified", address_family);
+            sockaddr->sa_family = AF_UNSPEC;
+            return -1;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-af_inet_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len,
-                                    int16_t remote_port)
+af_inet_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len, int16_t remote_port)
 {
-        dict_t *options = this->options;
-        data_t *remote_host_data = NULL;
-        data_t *remote_port_data = NULL;
-        char *remote_host = NULL;
-        struct addrinfo *addr_info = NULL;
-        int32_t ret = 0;
-
-        remote_host_data = dict_get (options, "remote-host");
-        if (remote_host_data == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host "
-                        "missing in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_host = data_to_str (remote_host_data);
-        if (remote_host == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host "
-                        "has data NULL in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        if (remote_port == 0) {
-                remote_port_data = dict_get (options, "remote-port");
-                if (remote_port_data == NULL) {
-                        gf_msg_debug (this->name, 0, "option remote-port "
-                                      "missing in volume %s. Defaulting to %d",
-                                      this->name, GF_DEFAULT_RDMA_LISTEN_PORT);
-
-                        remote_port = GF_DEFAULT_RDMA_LISTEN_PORT;
-                } else {
-                        remote_port = data_to_uint16 (remote_port_data);
-                }
-        }
-
-        if (remote_port == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        RDMA_MSG_INVALID_ENTRY, "option remote-port has "
-                        "invalid port in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        /* TODO: gf_resolve is a blocking call. kick in some
-           non blocking dns techniques */
-        ret = gf_resolve_ip6 (remote_host, remote_port,
-                              sockaddr->sa_family,
-                              &this->dnscache, &addr_info);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, TRANS_MSG_DNS_RESOL_FAILED,
-                        "DNS resolution failed on host %s", remote_host);
-                goto err;
+    dict_t *options = this->options;
+    data_t *remote_host_data = NULL;
+    data_t *remote_port_data = NULL;
+    char *remote_host = NULL;
+    struct addrinfo *addr_info = NULL;
+    int32_t ret = 0;
+
+    remote_host_data = dict_get(options, "remote-host");
+    if (remote_host_data == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_REMOTE_HOST_ERROR,
+               "option remote-host "
+               "missing in volume %s",
+               this->name);
+        ret = -1;
+        goto err;
+    }
+
+    remote_host = data_to_str(remote_host_data);
+    if (remote_host == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_REMOTE_HOST_ERROR,
+               "option remote-host "
+               "has data NULL in volume %s",
+               this->name);
+        ret = -1;
+        goto err;
+    }
+
+    if (remote_port == 0) {
+        remote_port_data = dict_get(options, "remote-port");
+        if (remote_port_data == NULL) {
+            gf_msg_debug(this->name, 0,
+                         "option remote-port "
+                         "missing in volume %s. Defaulting to %d",
+                         this->name, GF_DEFAULT_RDMA_LISTEN_PORT);
+
+            remote_port = GF_DEFAULT_RDMA_LISTEN_PORT;
+        } else {
+            remote_port = data_to_uint16(remote_port_data);
         }
-
-        memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
-        *sockaddr_len = addr_info->ai_addrlen;
+    }
+
+    if (remote_port == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, RDMA_MSG_INVALID_ENTRY,
+               "option remote-port has "
+               "invalid port in volume %s",
+               this->name);
+        ret = -1;
+        goto err;
+    }
+
+    /* TODO: gf_resolve is a blocking call. kick in some
+       non blocking dns techniques */
+    ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family,
+                         &this->dnscache, &addr_info);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_DNS_RESOL_FAILED,
+               "DNS resolution failed on host %s", remote_host);
+        goto err;
+    }
+
+    memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
+    *sockaddr_len = addr_info->ai_addrlen;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
+af_unix_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len)
 {
-        struct sockaddr_un *sockaddr_un = NULL;
-        char *connect_path = NULL;
-        data_t *connect_path_data = NULL;
-        int32_t ret = 0;
-
-        connect_path_data = dict_get (this->options,
-                                      "transport.rdma.connect-path");
-        if (!connect_path_data) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_CONNECT_PATH_ERROR, "option "
-                        "transport.rdma.connect-path not specified for "
-                        "address-family unix");
-                ret = -1;
-                goto err;
-        }
-
-        connect_path = data_to_str (connect_path_data);
-        if (!connect_path) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        RDMA_MSG_INVALID_ENTRY, "connect-path is null-string");
-                ret = -1;
-                goto err;
-        }
-
-        if (strlen (connect_path) > UNIX_PATH_MAX) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_CONNECT_PATH_ERROR,
-                        "connect-path value length %"GF_PRI_SIZET" > "
-                        "%d octets", strlen (connect_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
-
-        gf_msg_debug (this->name, 0, "using connect-path %s", connect_path);
-        sockaddr_un = (struct sockaddr_un *)sockaddr;
-        strcpy (sockaddr_un->sun_path, connect_path);
-        *sockaddr_len = sizeof (struct sockaddr_un);
+    struct sockaddr_un *sockaddr_un = NULL;
+    char *connect_path = NULL;
+    data_t *connect_path_data = NULL;
+    int32_t ret = 0;
+
+    connect_path_data = dict_get(this->options, "transport.rdma.connect-path");
+    if (!connect_path_data) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_CONNECT_PATH_ERROR,
+               "option "
+               "transport.rdma.connect-path not specified for "
+               "address-family unix");
+        ret = -1;
+        goto err;
+    }
+
+    connect_path = data_to_str(connect_path_data);
+    if (!connect_path) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, RDMA_MSG_INVALID_ENTRY,
+               "connect-path is null-string");
+        ret = -1;
+        goto err;
+    }
+
+    if (strlen(connect_path) > UNIX_PATH_MAX) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_CONNECT_PATH_ERROR,
+               "connect-path value length %" GF_PRI_SIZET
+               " > "
+               "%d octets",
+               strlen(connect_path), UNIX_PATH_MAX);
+        ret = -1;
+        goto err;
+    }
+
+    gf_msg_debug(this->name, 0, "using connect-path %s", connect_path);
+    sockaddr_un = (struct sockaddr_un *)sockaddr;
+    strcpy(sockaddr_un->sun_path, connect_path);
+    *sockaddr_len = sizeof(struct sockaddr_un);
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        data_t *listen_path_data = NULL;
-        char *listen_path = NULL;
-        int32_t ret = 0;
-        struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
-
-
-        listen_path_data = dict_get (this->options,
-                                     "transport.rdma.listen-path");
-        if (!listen_path_data) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_LISTEN_PATH_ERROR,
-                        "missing option listen-path");
-                ret = -1;
-                goto err;
-        }
+    data_t *listen_path_data = NULL;
+    char *listen_path = NULL;
+    int32_t ret = 0;
+    struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
+
+    listen_path_data = dict_get(this->options, "transport.rdma.listen-path");
+    if (!listen_path_data) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_LISTEN_PATH_ERROR,
+               "missing option listen-path");
+        ret = -1;
+        goto err;
+    }
 
-        listen_path = data_to_str (listen_path_data);
+    listen_path = data_to_str(listen_path_data);
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX 108
 #endif
 
-        if (strlen (listen_path) > UNIX_PATH_MAX) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_LISTEN_PATH_ERROR, "option listen-path has "
-                        "value length %"GF_PRI_SIZET" > %d",
-                        strlen (listen_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
+    if (strlen(listen_path) > UNIX_PATH_MAX) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_LISTEN_PATH_ERROR,
+               "option listen-path has "
+               "value length %" GF_PRI_SIZET " > %d",
+               strlen(listen_path), UNIX_PATH_MAX);
+        ret = -1;
+        goto err;
+    }
 
-        sunaddr->sun_family = AF_UNIX;
-        strcpy (sunaddr->sun_path, listen_path);
-        *addr_len = sizeof (struct sockaddr_un);
+    sunaddr->sun_family = AF_UNIX;
+    strcpy(sunaddr->sun_path, listen_path);
+    *addr_len = sizeof(struct sockaddr_un);
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_inet_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        struct addrinfo hints, *res = 0;
-        data_t *listen_port_data = NULL, *listen_host_data = NULL;
-        uint16_t listen_port = -1;
-        char service[NI_MAXSERV], *listen_host = NULL;
-        dict_t *options = NULL;
-        int32_t ret = 0;
-
-        options = this->options;
-
-        listen_port_data = dict_get (options, "transport.rdma.listen-port");
-        listen_host_data = dict_get (options,
-                                     "transport.rdma.bind-address");
-
-        if (listen_port_data) {
-                listen_port = data_to_uint16 (listen_port_data);
-        } else {
-                listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
-
-                if (addr->sa_family == AF_INET6) {
-                        struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr;
-                        in->sin6_addr = in6addr_any;
-                        in->sin6_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in6);
-                        goto out;
-                } else if (addr->sa_family == AF_INET) {
-                        struct sockaddr_in *in = (struct sockaddr_in *) addr;
-                        in->sin_addr.s_addr = htonl(INADDR_ANY);
-                        in->sin_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in);
-                        goto out;
-                }
+    struct addrinfo hints, *res = 0;
+    data_t *listen_port_data = NULL, *listen_host_data = NULL;
+    uint16_t listen_port = -1;
+    char service[NI_MAXSERV], *listen_host = NULL;
+    dict_t *options = NULL;
+    int32_t ret = 0;
+
+    options = this->options;
+
+    listen_port_data = dict_get(options, "transport.rdma.listen-port");
+    listen_host_data = dict_get(options, "transport.rdma.bind-address");
+
+    if (listen_port_data) {
+        listen_port = data_to_uint16(listen_port_data);
+    } else {
+        listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
+
+        if (addr->sa_family == AF_INET6) {
+            struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr;
+            in->sin6_addr = in6addr_any;
+            in->sin6_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in6);
+            goto out;
+        } else if (addr->sa_family == AF_INET) {
+            struct sockaddr_in *in = (struct sockaddr_in *)addr;
+            in->sin_addr.s_addr = htonl(INADDR_ANY);
+            in->sin_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in);
+            goto out;
         }
+    }
 
-        if (listen_port == (uint16_t) -1)
-                listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
+    if (listen_port == (uint16_t)-1)
+        listen_port = GF_DEFAULT_RDMA_LISTEN_PORT;
 
+    if (listen_host_data) {
+        listen_host = data_to_str(listen_host_data);
+    }
 
-        if (listen_host_data) {
-                listen_host = data_to_str (listen_host_data);
-        }
+    sprintf(service, "%d", listen_port);
 
-        sprintf (service, "%d", listen_port);
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = addr->sa_family;
-        hints.ai_socktype = SOCK_STREAM;
-        hints.ai_flags    = AI_ADDRCONFIG | AI_PASSIVE;
-
-        ret = getaddrinfo(listen_host, service, &hints, &res);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_ADDR_INFO_FAILED,
-                        "getaddrinfo failed for host %s, service %s",
-                        listen_host, service);
-                ret = -1;
-                goto out;
-        }
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = addr->sa_family;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
+
+    ret = getaddrinfo(listen_host, service, &hints, &res);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_ADDR_INFO_FAILED,
+               "getaddrinfo failed for host %s, service %s", listen_host,
+               service);
+        ret = -1;
+        goto out;
+    }
 
-        memcpy (addr, res->ai_addr, res->ai_addrlen);
-        *addr_len = res->ai_addrlen;
+    memcpy(addr, res->ai_addr, res->ai_addrlen);
+    *addr_len = res->ai_addrlen;
 
-        freeaddrinfo (res);
+    freeaddrinfo(res);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_rdma_client_bind (rpc_transport_t *this, struct sockaddr *sockaddr,
-                     socklen_t *sockaddr_len, struct rdma_cm_id *cm_id)
+gf_rdma_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+                    socklen_t *sockaddr_len, struct rdma_cm_id *cm_id)
 {
-        int ret = 0;
+    int ret = 0;
 
-        *sockaddr_len = sizeof (struct sockaddr_in6);
-        switch (sockaddr->sa_family) {
+    *sockaddr_len = sizeof(struct sockaddr_in6);
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
         case AF_INET:
-                *sockaddr_len = sizeof (struct sockaddr_in);
+            *sockaddr_len = sizeof(struct sockaddr_in);
         /* Fall through */
         case AF_INET6:
-                if (!this->bind_insecure) {
-                        ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_CLIENT_PORT_CEILING);
-                        if (ret == -1) {
-                                gf_msg (this->name, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_PORT_BIND_FAILED,
-                                        "cannot bind rdma_cm_id to port "
-                                        "less than %d", GF_CLIENT_PORT_CEILING);
-                        }
-                } else {
-                        ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_IANA_PRIV_PORTS_START);
-                        if (ret == -1) {
-                                gf_msg (this->name, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_PORT_BIND_FAILED,
-                                        "cannot bind rdma_cm_id to port "
-                                        "less than %d",
-                                        GF_IANA_PRIV_PORTS_START);
-                        }
+            if (!this->bind_insecure) {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    cm_id, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING);
+                if (ret == -1) {
+                    gf_msg(this->name, GF_LOG_WARNING, errno,
+                           RDMA_MSG_PORT_BIND_FAILED,
+                           "cannot bind rdma_cm_id to port "
+                           "less than %d",
+                           GF_CLIENT_PORT_CEILING);
+                }
+            } else {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    cm_id, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START);
+                if (ret == -1) {
+                    gf_msg(this->name, GF_LOG_WARNING, errno,
+                           RDMA_MSG_PORT_BIND_FAILED,
+                           "cannot bind rdma_cm_id to port "
+                           "less than %d",
+                           GF_IANA_PRIV_PORTS_START);
                 }
-                break;
+            }
+            break;
 
         case AF_UNIX:
-                *sockaddr_len = sizeof (struct sockaddr_un);
+            *sockaddr_len = sizeof(struct sockaddr_un);
 #if 0
                 ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr,
                                            *sockaddr_len, sock);
 #endif
-                break;
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address family %d", sockaddr->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY,
+                   "unknown address family %d", sockaddr->sa_family);
+            ret = -1;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_rdma_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len,
-                                    int16_t remote_port)
+gf_rdma_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len, int16_t remote_port)
 {
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
+    int32_t ret = 0;
+    char is_inet_sdp = 0;
 
-        ret = client_fill_address_family (this, sockaddr);
-        if (ret) {
-                ret = -1;
-                goto err;
-        }
+    ret = client_fill_address_family(this, sockaddr);
+    if (ret) {
+        ret = -1;
+        goto err;
+    }
 
-        switch (sockaddr->sa_family) {
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
-                sockaddr->sa_family = AF_INET;
-                is_inet_sdp = 1;
+            sockaddr->sa_family = AF_INET;
+            is_inet_sdp = 1;
         /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_client_get_remote_sockaddr (this,
-                                                          sockaddr,
-                                                          sockaddr_len,
-                                                          remote_port);
+            ret = af_inet_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len, remote_port);
 
-                if (is_inet_sdp) {
-                        sockaddr->sa_family = AF_INET_SDP;
-                }
+            if (is_inet_sdp) {
+                sockaddr->sa_family = AF_INET_SDP;
+            }
 
-                break;
+            break;
 
         case AF_UNIX:
-                ret = af_unix_client_get_remote_sockaddr (this,
-                                                          sockaddr,
-                                                          sockaddr_len);
-                break;
+            ret = af_unix_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len);
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address-family %d", sockaddr->sa_family);
-                ret = -1;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY,
+                   "unknown address-family %d", sockaddr->sa_family);
+            ret = -1;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_rdma_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+gf_rdma_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        data_t *address_family_data = NULL;
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (address_family_data) {
-                char *address_family = NULL;
-                address_family = data_to_str (address_family_data);
-
-                if (!strcasecmp (address_family, "inet")) {
-                        addr->sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        addr->sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        addr->sa_family = AF_INET_SDP;
-                } else if (!strcasecmp (address_family, "unix")) {
-                        addr->sa_family = AF_UNIX;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_UNKNOWN_ADDR_FAMILY, "unknown address"
-                                " family (%s) specified", address_family);
-                        addr->sa_family = AF_UNSPEC;
-                        ret = -1;
-                        goto err;
-                }
+    data_t *address_family_data = NULL;
+    int32_t ret = 0;
+    char is_inet_sdp = 0;
+
+    address_family_data = dict_get(this->options, "transport.address-family");
+    if (address_family_data) {
+        char *address_family = NULL;
+        address_family = data_to_str(address_family_data);
+
+        if (!strcasecmp(address_family, "inet")) {
+            addr->sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            addr->sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            addr->sa_family = AF_INET_SDP;
+        } else if (!strcasecmp(address_family, "unix")) {
+            addr->sa_family = AF_UNIX;
         } else {
-                gf_msg_debug (this->name, 0, "option address-family not "
-                              "specified, defaulting to inet");
-                addr->sa_family = AF_INET;
+            gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY,
+                   "unknown address"
+                   " family (%s) specified",
+                   address_family);
+            addr->sa_family = AF_UNSPEC;
+            ret = -1;
+            goto err;
         }
-
-        switch (addr->sa_family) {
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "option address-family not "
+                     "specified, defaulting to inet");
+        addr->sa_family = AF_INET;
+    }
+
+    switch (addr->sa_family) {
         case AF_INET_SDP:
-                is_inet_sdp = 1;
-                addr->sa_family = AF_INET;
-                /* Fall through */
+            is_inet_sdp = 1;
+            addr->sa_family = AF_INET;
+            /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_server_get_local_sockaddr (this, addr, addr_len);
-                if (is_inet_sdp && !ret) {
-                        addr->sa_family = AF_INET_SDP;
-                }
-                break;
+            ret = af_inet_server_get_local_sockaddr(this, addr, addr_len);
+            if (is_inet_sdp && !ret) {
+                addr->sa_family = AF_INET_SDP;
+            }
+            break;
 
         case AF_UNIX:
-                ret = af_unix_server_get_local_sockaddr (this, addr, addr_len);
-                break;
-        }
+            ret = af_unix_server_get_local_sockaddr(this, addr, addr_len);
+            break;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 int32_t
-fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr,
-                             int32_t addr_len, char *identifier)
+fill_inet6_inet_identifiers(rpc_transport_t *this,
+                            struct sockaddr_storage *addr, int32_t addr_len,
+                            char *identifier)
 {
-        int32_t ret = 0, tmpaddr_len = 0;
-        char service[NI_MAXSERV], host[NI_MAXHOST];
-        union gf_sock_union sock_union;
+    int32_t ret = 0, tmpaddr_len = 0;
+    char service[NI_MAXSERV], host[NI_MAXHOST];
+    union gf_sock_union sock_union;
 
-        memset (&sock_union, 0, sizeof (sock_union));
-        sock_union.storage = *addr;
-        tmpaddr_len = addr_len;
+    memset(&sock_union, 0, sizeof(sock_union));
+    sock_union.storage = *addr;
+    tmpaddr_len = addr_len;
 
-        if (sock_union.sa.sa_family == AF_INET6) {
-                int32_t one_to_four, four_to_eight, twelve_to_sixteen;
-                int16_t eight_to_ten, ten_to_twelve;
+    if (sock_union.sa.sa_family == AF_INET6) {
+        int32_t one_to_four, four_to_eight, twelve_to_sixteen;
+        int16_t eight_to_ten, ten_to_twelve;
 
-                one_to_four = four_to_eight = twelve_to_sixteen = 0;
-                eight_to_ten = ten_to_twelve = 0;
+        one_to_four = four_to_eight = twelve_to_sixteen = 0;
+        eight_to_ten = ten_to_twelve = 0;
 
-                one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
-                four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
+        one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
+        four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
 #ifdef GF_SOLARIS_HOST_OS
-                eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
+        eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
 #else
-                eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
+        eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-                ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
+        ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
 #else
-                ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
+        ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
 #endif
-                twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
-
-                /* ipv4 mapped ipv6 address has
-                   bits 0-80: 0
-                   bits 80-96: 0xffff
-                   bits 96-128: ipv4 address
-                */
-
-                if (one_to_four == 0 &&
-                    four_to_eight == 0 &&
-                    eight_to_ten == 0 &&
-                    ten_to_twelve == -1) {
-                        struct sockaddr_in *in_ptr = &sock_union.sin;
-                        memset (&sock_union, 0, sizeof (sock_union));
-
-                        in_ptr->sin_family = AF_INET;
-                        in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
-                        in_ptr->sin_addr.s_addr = twelve_to_sixteen;
-                        tmpaddr_len = sizeof (*in_ptr);
-                }
+        twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
+
+        /* ipv4 mapped ipv6 address has
+           bits 0-80: 0
+           bits 80-96: 0xffff
+           bits 96-128: ipv4 address
+        */
+
+        if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 &&
+            ten_to_twelve == -1) {
+            struct sockaddr_in *in_ptr = &sock_union.sin;
+            memset(&sock_union, 0, sizeof(sock_union));
+
+            in_ptr->sin_family = AF_INET;
+            in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
+            in_ptr->sin_addr.s_addr = twelve_to_sixteen;
+            tmpaddr_len = sizeof(*in_ptr);
         }
+    }
 
-        ret = getnameinfo (&sock_union.sa,
-                           tmpaddr_len,
-                           host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST | NI_NUMERICSERV);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_NAME_INFO_FAILED,
-                        "getnameinfo failed");
-        }
+    ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service,
+                      sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_NAME_INFO_FAILED,
+               "getnameinfo failed");
+    }
 
-        sprintf (identifier, "%s:%s", host, service);
+    sprintf(identifier, "%s:%s", host, service);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_rdma_get_transport_identifiers (rpc_transport_t *this)
+gf_rdma_get_transport_identifiers(rpc_transport_t *this)
 {
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
+    int32_t ret = 0;
+    char is_inet_sdp = 0;
 
-        switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family) {
+    switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) {
         case AF_INET_SDP:
-                is_inet_sdp = 1;
-                ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET;
-                /* Fall through */
+            is_inet_sdp = 1;
+            ((struct sockaddr *)&this->peerinfo.sockaddr)
+                ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                  ->sa_family = AF_INET;
+            /* Fall through */
         case AF_INET:
         case AF_INET6: {
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->myinfo.sockaddr,
-                                                   this->myinfo.sockaddr_len,
-                                                   this->myinfo.identifier);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_INET_ERROR,
-                                "can't fill inet/inet6 identifier for server");
-                        goto err;
-                }
-
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->peerinfo.sockaddr,
-                                                   this->peerinfo.sockaddr_len,
-                                                   this->peerinfo.identifier);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                TRANS_MSG_INET_ERROR,
-                                "can't fill inet/inet6 identifier for client");
-                        goto err;
-                }
+            ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr,
+                                              this->myinfo.sockaddr_len,
+                                              this->myinfo.identifier);
+            if (ret == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_INET_ERROR,
+                       "can't fill inet/inet6 identifier for server");
+                goto err;
+            }
+
+            ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr,
+                                              this->peerinfo.sockaddr_len,
+                                              this->peerinfo.identifier);
+            if (ret == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_INET_ERROR,
+                       "can't fill inet/inet6 identifier for client");
+                goto err;
+            }
 
-                if (is_inet_sdp) {
-                        ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP;
-                }
-        }
-        break;
+            if (is_inet_sdp) {
+                ((struct sockaddr *)&this->peerinfo.sockaddr)
+                    ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                      ->sa_family = AF_INET_SDP;
+            }
+        } break;
 
-        case AF_UNIX:
-        {
-                struct sockaddr_un *sunaddr = NULL;
+        case AF_UNIX: {
+            struct sockaddr_un *sunaddr = NULL;
 
-                sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr;
-                strcpy (this->myinfo.identifier, sunaddr->sun_path);
+            sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr;
+            strcpy(this->myinfo.identifier, sunaddr->sun_path);
 
-                sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr;
-                strcpy (this->peerinfo.identifier, sunaddr->sun_path);
-        }
-        break;
+            sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr;
+            strcpy(this->peerinfo.identifier, sunaddr->sun_path);
+        } break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        TRANS_MSG_UNKNOWN_ADDR_FAMILY,
-                        "unknown address family (%d)",
-                        ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY,
+                   "unknown address family (%d)",
+                   ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family);
+            ret = -1;
+            break;
+    }
 
 err:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-transport/rdma/src/rdma.c b/rpc/rpc-transport/rdma/src/rdma.c
index f1859a73bdf..92c9ce95929 100644
--- a/rpc/rpc-transport/rdma/src/rdma.c
+++ b/rpc/rpc-transport/rdma/src/rdma.c
@@ -24,1363 +24,1322 @@
 #define GF_RDMA_LOG_NAME "rpc-transport/rdma"
 
 static int32_t
-__gf_rdma_ioq_churn (gf_rdma_peer_t *peer);
+__gf_rdma_ioq_churn(gf_rdma_peer_t *peer);
 
 gf_rdma_post_t *
-gf_rdma_post_ref (gf_rdma_post_t *post);
+gf_rdma_post_ref(gf_rdma_post_t *post);
 
 int
-gf_rdma_post_unref (gf_rdma_post_t *post);
+gf_rdma_post_unref(gf_rdma_post_t *post);
 
 static void *
-gf_rdma_send_completion_proc (void *data);
+gf_rdma_send_completion_proc(void *data);
 
 static void *
-gf_rdma_recv_completion_proc (void *data);
+gf_rdma_recv_completion_proc(void *data);
 
 void *
-gf_rdma_async_event_thread (void *context);
+gf_rdma_async_event_thread(void *context);
 
 static int32_t
-gf_rdma_create_qp (rpc_transport_t *this);
+gf_rdma_create_qp(rpc_transport_t *this);
 
 static int32_t
-__gf_rdma_teardown (rpc_transport_t *this);
+__gf_rdma_teardown(rpc_transport_t *this);
 
 static int32_t
-gf_rdma_teardown (rpc_transport_t *this);
+gf_rdma_teardown(rpc_transport_t *this);
 
 static int32_t
-gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait);
+gf_rdma_disconnect(rpc_transport_t *this, gf_boolean_t wait);
 
 static void
-gf_rdma_cm_handle_disconnect (rpc_transport_t *this);
+gf_rdma_cm_handle_disconnect(rpc_transport_t *this);
 
 static int
-gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event);
+gf_rdma_cm_handle_connect_init(struct rdma_cm_event *event);
 
 static void
-gf_rdma_put_post (gf_rdma_queue_t *queue, gf_rdma_post_t *post)
+gf_rdma_put_post(gf_rdma_queue_t *queue, gf_rdma_post_t *post)
 {
-        post->ctx.is_request = 0;
+    post->ctx.is_request = 0;
 
-        pthread_mutex_lock (&queue->lock);
-        {
-                if (post->prev) {
-                        queue->active_count--;
-                        post->prev->next = post->next;
-                }
-
-                if (post->next) {
-                        post->next->prev = post->prev;
-                }
+    pthread_mutex_lock(&queue->lock);
+    {
+        if (post->prev) {
+            queue->active_count--;
+            post->prev->next = post->next;
+        }
 
-                post->prev = &queue->passive_posts;
-                post->next = post->prev->next;
-                post->prev->next = post;
-                post->next->prev = post;
-                queue->passive_count++;
+        if (post->next) {
+            post->next->prev = post->prev;
         }
-        pthread_mutex_unlock (&queue->lock);
-}
 
+        post->prev = &queue->passive_posts;
+        post->next = post->prev->next;
+        post->prev->next = post;
+        post->next->prev = post;
+        queue->passive_count++;
+    }
+    pthread_mutex_unlock(&queue->lock);
+}
 
 static gf_rdma_post_t *
-gf_rdma_new_post (rpc_transport_t *this, gf_rdma_device_t *device, int32_t len,
-                  gf_rdma_post_type_t type)
+gf_rdma_new_post(rpc_transport_t *this, gf_rdma_device_t *device, int32_t len,
+                 gf_rdma_post_type_t type)
 {
-        gf_rdma_post_t *post = NULL;
-        int             ret  = -1;
+    gf_rdma_post_t *post = NULL;
+    int ret = -1;
 
-        post = (gf_rdma_post_t *) GF_CALLOC (1, sizeof (*post),
-                                             gf_common_mt_rdma_post_t);
-        if (post == NULL) {
-                goto out;
-        }
+    post = (gf_rdma_post_t *)GF_CALLOC(1, sizeof(*post),
+                                       gf_common_mt_rdma_post_t);
+    if (post == NULL) {
+        goto out;
+    }
 
-        pthread_mutex_init (&post->lock, NULL);
+    pthread_mutex_init(&post->lock, NULL);
 
-        post->buf_size = len;
+    post->buf_size = len;
 
-        post->buf = valloc (len);
-        if (!post->buf) {
-                gf_msg_nomem (GF_RDMA_LOG_NAME, GF_LOG_ERROR, len);
-                goto out;
-        }
+    post->buf = valloc(len);
+    if (!post->buf) {
+        gf_msg_nomem(GF_RDMA_LOG_NAME, GF_LOG_ERROR, len);
+        goto out;
+    }
 
-        post->mr = ibv_reg_mr (device->pd,
-                               post->buf,
-                               post->buf_size,
-                               IBV_ACCESS_LOCAL_WRITE);
-        if (!post->mr) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_MR_ALOC_FAILED,
-                        "memory registration failed");
-                goto out;
-        }
+    post->mr = ibv_reg_mr(device->pd, post->buf, post->buf_size,
+                          IBV_ACCESS_LOCAL_WRITE);
+    if (!post->mr) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_MR_ALOC_FAILED,
+               "memory registration failed");
+        goto out;
+    }
 
-        post->device = device;
-        post->type = type;
+    post->device = device;
+    post->type = type;
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret != 0 && post) {
-                free (post->buf);
+    if (ret != 0 && post) {
+        free(post->buf);
 
-                GF_FREE (post);
-                post = NULL;
-        }
+        GF_FREE(post);
+        post = NULL;
+    }
 
-        return post;
+    return post;
 }
 
-
 static gf_rdma_post_t *
-gf_rdma_get_post (gf_rdma_queue_t *queue)
+gf_rdma_get_post(gf_rdma_queue_t *queue)
 {
-        gf_rdma_post_t *post = NULL;
-
-        pthread_mutex_lock (&queue->lock);
-        {
-                post = queue->passive_posts.next;
-                if (post == &queue->passive_posts)
-                        post = NULL;
-
-                if (post) {
-                        if (post->prev)
-                                post->prev->next = post->next;
-                        if (post->next)
-                                post->next->prev = post->prev;
-                        post->prev = &queue->active_posts;
-                        post->next = post->prev->next;
-                        post->prev->next = post;
-                        post->next->prev = post;
-                        post->reused++;
-                        queue->active_count++;
-                }
-        }
-        pthread_mutex_unlock (&queue->lock);
-
-        return post;
+    gf_rdma_post_t *post = NULL;
+
+    pthread_mutex_lock(&queue->lock);
+    {
+        post = queue->passive_posts.next;
+        if (post == &queue->passive_posts)
+            post = NULL;
+
+        if (post) {
+            if (post->prev)
+                post->prev->next = post->next;
+            if (post->next)
+                post->next->prev = post->prev;
+            post->prev = &queue->active_posts;
+            post->next = post->prev->next;
+            post->prev->next = post;
+            post->next->prev = post;
+            post->reused++;
+            queue->active_count++;
+        }
+    }
+    pthread_mutex_unlock(&queue->lock);
+
+    return post;
 }
 
 void
-gf_rdma_destroy_post (gf_rdma_post_t *post)
+gf_rdma_destroy_post(gf_rdma_post_t *post)
 {
-        ibv_dereg_mr (post->mr);
-        free (post->buf);
-        GF_FREE (post);
+    ibv_dereg_mr(post->mr);
+    free(post->buf);
+    GF_FREE(post);
 }
 
-
 static int32_t
-__gf_rdma_quota_get (gf_rdma_peer_t *peer)
+__gf_rdma_quota_get(gf_rdma_peer_t *peer)
 {
-        int32_t            ret  = -1;
-        gf_rdma_private_t *priv = NULL;
+    int32_t ret = -1;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = peer->trans->private;
+    priv = peer->trans->private;
 
-        if (priv->connected && peer->quota > 0) {
-                ret = peer->quota--;
-        }
+    if (priv->connected && peer->quota > 0) {
+        ret = peer->quota--;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__gf_rdma_ioq_entry_free (gf_rdma_ioq_t *entry)
+__gf_rdma_ioq_entry_free(gf_rdma_ioq_t *entry)
 {
-        list_del_init (&entry->list);
+    list_del_init(&entry->list);
 
-        if (entry->iobref) {
-                iobref_unref (entry->iobref);
-                entry->iobref = NULL;
-        }
+    if (entry->iobref) {
+        iobref_unref(entry->iobref);
+        entry->iobref = NULL;
+    }
 
-        if (entry->msg.request.rsp_iobref) {
-                iobref_unref (entry->msg.request.rsp_iobref);
-                entry->msg.request.rsp_iobref = NULL;
-        }
+    if (entry->msg.request.rsp_iobref) {
+        iobref_unref(entry->msg.request.rsp_iobref);
+        entry->msg.request.rsp_iobref = NULL;
+    }
 
-        mem_put (entry);
+    mem_put(entry);
 }
 
-
 static void
-__gf_rdma_ioq_flush (gf_rdma_peer_t *peer)
+__gf_rdma_ioq_flush(gf_rdma_peer_t *peer)
 {
-        gf_rdma_ioq_t *entry = NULL, *dummy = NULL;
+    gf_rdma_ioq_t *entry = NULL, *dummy = NULL;
 
-        list_for_each_entry_safe (entry, dummy, &peer->ioq, list) {
-                __gf_rdma_ioq_entry_free (entry);
-        }
+    list_for_each_entry_safe(entry, dummy, &peer->ioq, list)
+    {
+        __gf_rdma_ioq_entry_free(entry);
+    }
 }
 
-
 static int32_t
-__gf_rdma_disconnect (rpc_transport_t *this)
+__gf_rdma_disconnect(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->connected) {
-                rdma_disconnect (priv->peer.cm_id);
-        }
+    if (priv->connected) {
+        rdma_disconnect(priv->peer.cm_id);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static void
-gf_rdma_queue_init (gf_rdma_queue_t *queue)
+gf_rdma_queue_init(gf_rdma_queue_t *queue)
 {
-        pthread_mutex_init (&queue->lock, NULL);
+    pthread_mutex_init(&queue->lock, NULL);
 
-        queue->active_posts.next = &queue->active_posts;
-        queue->active_posts.prev = &queue->active_posts;
-        queue->passive_posts.next = &queue->passive_posts;
-        queue->passive_posts.prev = &queue->passive_posts;
+    queue->active_posts.next = &queue->active_posts;
+    queue->active_posts.prev = &queue->active_posts;
+    queue->passive_posts.next = &queue->passive_posts;
+    queue->passive_posts.prev = &queue->passive_posts;
 }
 
-
 static void
-__gf_rdma_destroy_queue (gf_rdma_post_t *post)
+__gf_rdma_destroy_queue(gf_rdma_post_t *post)
 {
-        gf_rdma_post_t *tmp = NULL;
+    gf_rdma_post_t *tmp = NULL;
 
-        while (post->next != post) {
-                tmp = post->next;
+    while (post->next != post) {
+        tmp = post->next;
 
-                post->next = post->next->next;
-                post->next->prev = post;
+        post->next = post->next->next;
+        post->next->prev = post;
 
-                gf_rdma_destroy_post (tmp);
-        }
+        gf_rdma_destroy_post(tmp);
+    }
 }
 
-
 static void
-gf_rdma_destroy_queue (gf_rdma_queue_t *queue)
+gf_rdma_destroy_queue(gf_rdma_queue_t *queue)
 {
-        if (queue == NULL) {
-                goto out;
-        }
+    if (queue == NULL) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&queue->lock);
-        {
-                if (queue->passive_count > 0) {
-                        __gf_rdma_destroy_queue (&queue->passive_posts);
-                        queue->passive_count = 0;
-                }
+    pthread_mutex_lock(&queue->lock);
+    {
+        if (queue->passive_count > 0) {
+            __gf_rdma_destroy_queue(&queue->passive_posts);
+            queue->passive_count = 0;
+        }
 
-                if (queue->active_count > 0) {
-                        __gf_rdma_destroy_queue (&queue->active_posts);
-                        queue->active_count = 0;
-                }
+        if (queue->active_count > 0) {
+            __gf_rdma_destroy_queue(&queue->active_posts);
+            queue->active_count = 0;
         }
-        pthread_mutex_unlock (&queue->lock);
+    }
+    pthread_mutex_unlock(&queue->lock);
 
 out:
-        return;
+    return;
 }
 
-
 static void
-gf_rdma_destroy_posts (rpc_transport_t *this)
+gf_rdma_destroy_posts(rpc_transport_t *this)
 {
-        gf_rdma_device_t  *device = NULL;
-        gf_rdma_private_t *priv   = NULL;
+    gf_rdma_device_t *device = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        if (this == NULL) {
-                goto out;
-        }
+    if (this == NULL) {
+        goto out;
+    }
 
-        priv = this->private;
-        device = priv->device;
+    priv = this->private;
+    device = priv->device;
 
-        gf_rdma_destroy_queue (&device->sendq);
-        gf_rdma_destroy_queue (&device->recvq);
+    gf_rdma_destroy_queue(&device->sendq);
+    gf_rdma_destroy_queue(&device->recvq);
 
 out:
-        return;
+    return;
 }
 
-
 static int32_t
-__gf_rdma_create_posts (rpc_transport_t *this, int32_t count, int32_t size,
-                        gf_rdma_queue_t *q, gf_rdma_post_type_t type)
+__gf_rdma_create_posts(rpc_transport_t *this, int32_t count, int32_t size,
+                       gf_rdma_queue_t *q, gf_rdma_post_type_t type)
 {
-        int32_t            i      = 0;
-        int32_t            ret    = 0;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-
-        priv = this->private;
-        device = priv->device;
-
-        for (i = 0 ; i < count ; i++) {
-                gf_rdma_post_t *post = NULL;
-
-                post = gf_rdma_new_post (this, device, size + 2048, type);
-                if (!post) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_POST_CREATION_FAILED,
-                                "post creation failed");
-                        ret = -1;
-                        break;
-                }
+    int32_t i = 0;
+    int32_t ret = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+
+    priv = this->private;
+    device = priv->device;
 
-                gf_rdma_put_post (q, post);
+    for (i = 0; i < count; i++) {
+        gf_rdma_post_t *post = NULL;
+
+        post = gf_rdma_new_post(this, device, size + 2048, type);
+        if (!post) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_POST_CREATION_FAILED,
+                   "post creation failed");
+            ret = -1;
+            break;
         }
-        return ret;
-}
 
+        gf_rdma_put_post(q, post);
+    }
+    return ret;
+}
 
 static int32_t
-gf_rdma_post_recv (struct ibv_srq *srq,
-                   gf_rdma_post_t *post)
+gf_rdma_post_recv(struct ibv_srq *srq, gf_rdma_post_t *post)
 {
-        struct ibv_sge list = {
-                .addr   = (unsigned long) post->buf,
-                .length = post->buf_size,
-                .lkey   = post->mr->lkey
-        };
+    struct ibv_sge list = {.addr = (unsigned long)post->buf,
+                           .length = post->buf_size,
+                           .lkey = post->mr->lkey};
 
-        struct ibv_recv_wr wr = {
-                .wr_id  = (unsigned long) post,
-                .sg_list = &list,
-                .num_sge = 1,
-        }, *bad_wr;
+    struct ibv_recv_wr wr =
+                           {
+                               .wr_id = (unsigned long)post,
+                               .sg_list = &list,
+                               .num_sge = 1,
+                           },
+                       *bad_wr;
 
-        gf_rdma_post_ref (post);
+    gf_rdma_post_ref(post);
 
-        return ibv_post_srq_recv (srq, &wr, &bad_wr);
+    return ibv_post_srq_recv(srq, &wr, &bad_wr);
 }
 
 static void
-gf_rdma_deregister_iobuf_pool (gf_rdma_device_t *device)
+gf_rdma_deregister_iobuf_pool(gf_rdma_device_t *device)
 {
+    gf_rdma_arena_mr *arena_mr = NULL;
+    gf_rdma_arena_mr *tmp = NULL;
 
-        gf_rdma_arena_mr   *arena_mr  = NULL;
-        gf_rdma_arena_mr   *tmp       = NULL;
-
-        while (device) {
-                pthread_mutex_lock (&device->all_mr_lock);
+    while (device) {
+        pthread_mutex_lock(&device->all_mr_lock);
+        {
+            if (!list_empty(&device->all_mr)) {
+                list_for_each_entry_safe(arena_mr, tmp, &device->all_mr, list)
                 {
-                        if (!list_empty(&device->all_mr)) {
-                                list_for_each_entry_safe (arena_mr, tmp,
-                                                        &device->all_mr, list) {
-                                        if (ibv_dereg_mr(arena_mr->mr)) {
-                                                gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                                        RDMA_MSG_DEREGISTER_ARENA_FAILED,
-                                                        "deallocation of memory region "
-                                                        "failed");
-                                                pthread_mutex_unlock (&device->all_mr_lock);
-                                                return;
-                                        }
-                                        list_del(&arena_mr->list);
-                                        GF_FREE(arena_mr);
-                                }
-                        }
+                    if (ibv_dereg_mr(arena_mr->mr)) {
+                        gf_msg("rdma", GF_LOG_WARNING, 0,
+                               RDMA_MSG_DEREGISTER_ARENA_FAILED,
+                               "deallocation of memory region "
+                               "failed");
+                        pthread_mutex_unlock(&device->all_mr_lock);
+                        return;
+                    }
+                    list_del(&arena_mr->list);
+                    GF_FREE(arena_mr);
                 }
-                pthread_mutex_unlock (&device->all_mr_lock);
-
-                device = device->next;
+            }
         }
+        pthread_mutex_unlock(&device->all_mr_lock);
+
+        device = device->next;
+    }
 }
 
 int
-gf_rdma_deregister_arena (struct list_head **mr_list,
-                          struct iobuf_arena *iobuf_arena)
+gf_rdma_deregister_arena(struct list_head **mr_list,
+                         struct iobuf_arena *iobuf_arena)
 {
-        gf_rdma_arena_mr *tmp     = NULL;
-        gf_rdma_arena_mr *dummy   = NULL;
-        gf_rdma_device_t *device  = NULL;
-        int               count   = 0, i = 0;
-
-        count = iobuf_arena->iobuf_pool->rdma_device_count;
-        for (i = 0; i < count; i++) {
-                device = iobuf_arena->iobuf_pool->device[i];
-                pthread_mutex_lock (&device->all_mr_lock);
-                {
-                        list_for_each_entry_safe (tmp, dummy, mr_list[i], list) {
-                                if (tmp->iobuf_arena == iobuf_arena) {
-                                        if (ibv_dereg_mr(tmp->mr)) {
-                                                gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                                        RDMA_MSG_DEREGISTER_ARENA_FAILED,
-                                                        "deallocation of memory region "
-                                                        "failed");
-                                                        pthread_mutex_unlock (&device->all_mr_lock);
-                                                return -1;
-                                        }
-                                        list_del(&tmp->list);
-                                        GF_FREE(tmp);
-                                        break;
-                                }
-                        }
+    gf_rdma_arena_mr *tmp = NULL;
+    gf_rdma_arena_mr *dummy = NULL;
+    gf_rdma_device_t *device = NULL;
+    int count = 0, i = 0;
+
+    count = iobuf_arena->iobuf_pool->rdma_device_count;
+    for (i = 0; i < count; i++) {
+        device = iobuf_arena->iobuf_pool->device[i];
+        pthread_mutex_lock(&device->all_mr_lock);
+        {
+            list_for_each_entry_safe(tmp, dummy, mr_list[i], list)
+            {
+                if (tmp->iobuf_arena == iobuf_arena) {
+                    if (ibv_dereg_mr(tmp->mr)) {
+                        gf_msg("rdma", GF_LOG_WARNING, 0,
+                               RDMA_MSG_DEREGISTER_ARENA_FAILED,
+                               "deallocation of memory region "
+                               "failed");
+                        pthread_mutex_unlock(&device->all_mr_lock);
+                        return -1;
+                    }
+                    list_del(&tmp->list);
+                    GF_FREE(tmp);
+                    break;
                 }
-                pthread_mutex_unlock (&device->all_mr_lock);
+            }
         }
+        pthread_mutex_unlock(&device->all_mr_lock);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-gf_rdma_register_arena (void **arg1, void *arg2)
+gf_rdma_register_arena(void **arg1, void *arg2)
 {
-        struct ibv_mr       *mr          = NULL;
-        gf_rdma_arena_mr    *new         = NULL;
-        struct iobuf_pool   *iobuf_pool  = NULL;
-        gf_rdma_device_t    **device     = (gf_rdma_device_t **)arg1;
-        struct iobuf_arena  *iobuf_arena = arg2;
-        int                  count       = 0, i = 0;
-
-        iobuf_pool = iobuf_arena->iobuf_pool;
-        count = iobuf_pool->rdma_device_count;
-        for (i = 0; i < count; i++) {
-                new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
-                                gf_common_mt_rdma_arena_mr);
-                if (new == NULL) {
-                        gf_msg ("rdma", GF_LOG_INFO, ENOMEM,
-                                RDMA_MSG_MR_ALOC_FAILED, "Out of "
-                                "memory: registering pre allocated buffer "
-                                "with rdma device failed.");
-                      return -1;
-                }
-                INIT_LIST_HEAD (&new->list);
-                new->iobuf_arena = iobuf_arena;
-
-                mr = ibv_reg_mr(device[i]->pd, iobuf_arena->mem_base,
-                                         iobuf_arena->arena_size,
-                                         IBV_ACCESS_REMOTE_READ |
-                                         IBV_ACCESS_LOCAL_WRITE |
-                                         IBV_ACCESS_REMOTE_WRITE
-                                         );
-                if (!mr)
-                        gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                RDMA_MSG_MR_ALOC_FAILED, "allocation of mr "
-                                "failed");
-
-                new->mr = mr;
-                pthread_mutex_lock (&device[i]->all_mr_lock);
-                {
-                        list_add (&new->list, &device[i]->all_mr);
-                }
-                pthread_mutex_unlock (&device[i]->all_mr_lock);
-                new = NULL;
+    struct ibv_mr *mr = NULL;
+    gf_rdma_arena_mr *new = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
+    gf_rdma_device_t **device = (gf_rdma_device_t **)arg1;
+    struct iobuf_arena *iobuf_arena = arg2;
+    int count = 0, i = 0;
+
+    iobuf_pool = iobuf_arena->iobuf_pool;
+    count = iobuf_pool->rdma_device_count;
+    for (i = 0; i < count; i++) {
+        new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
+                        gf_common_mt_rdma_arena_mr);
+        if (new == NULL) {
+            gf_msg("rdma", GF_LOG_INFO, ENOMEM, RDMA_MSG_MR_ALOC_FAILED,
+                   "Out of "
+                   "memory: registering pre allocated buffer "
+                   "with rdma device failed.");
+            return -1;
+        }
+        INIT_LIST_HEAD(&new->list);
+        new->iobuf_arena = iobuf_arena;
+
+        mr = ibv_reg_mr(device[i]->pd, iobuf_arena->mem_base,
+                        iobuf_arena->arena_size,
+                        IBV_ACCESS_REMOTE_READ | IBV_ACCESS_LOCAL_WRITE |
+                            IBV_ACCESS_REMOTE_WRITE);
+        if (!mr)
+            gf_msg("rdma", GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED,
+                   "allocation of mr "
+                   "failed");
+
+        new->mr = mr;
+        pthread_mutex_lock(&device[i]->all_mr_lock);
+        {
+            list_add(&new->list, &device[i]->all_mr);
         }
+        pthread_mutex_unlock(&device[i]->all_mr_lock);
+        new = NULL;
+    }
 
-        return 0;
-
+    return 0;
 }
 
 static void
-gf_rdma_register_iobuf_pool (gf_rdma_device_t *device,
-                        struct iobuf_pool *iobuf_pool)
+gf_rdma_register_iobuf_pool(gf_rdma_device_t *device,
+                            struct iobuf_pool *iobuf_pool)
 {
-        struct iobuf_arena  *tmp        = NULL;
-        struct iobuf_arena  *dummy      = NULL;
-        struct ibv_mr       *mr         = NULL;
-        gf_rdma_arena_mr    *new        = NULL;
-
-        if (!list_empty(&iobuf_pool->all_arenas)) {
-
-                list_for_each_entry_safe (tmp, dummy, &iobuf_pool->all_arenas,
-                                          all_list) {
-                        new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
-                                        gf_common_mt_rdma_arena_mr);
-                        if (new == NULL) {
-                                gf_msg ("rdma", GF_LOG_INFO, ENOMEM,
-                                        RDMA_MSG_MR_ALOC_FAILED, "Out of "
-                                        "memory: registering pre allocated "
-                                        "buffer with rdma device failed.");
-                              return;
-                        }
-                        INIT_LIST_HEAD (&new->list);
-                        new->iobuf_arena = tmp;
-
-                        mr = ibv_reg_mr(device->pd, tmp->mem_base,
-                                        tmp->arena_size,
-                                        IBV_ACCESS_REMOTE_READ |
-                                        IBV_ACCESS_LOCAL_WRITE |
-                                        IBV_ACCESS_REMOTE_WRITE);
-                        if (!mr) {
-                                gf_msg ("rdma", GF_LOG_WARNING, 0,
-                                        RDMA_MSG_MR_ALOC_FAILED, "failed"
-                                        " to pre register buffers with rdma "
-                                        "devices.");
-
-                        }
-                        new->mr = mr;
-                        pthread_mutex_lock (&device->all_mr_lock);
-                        {
-                                list_add (&new->list, &device->all_mr);
-                        }
-                        pthread_mutex_unlock (&device->all_mr_lock);
+    struct iobuf_arena *tmp = NULL;
+    struct iobuf_arena *dummy = NULL;
+    struct ibv_mr *mr = NULL;
+    gf_rdma_arena_mr *new = NULL;
 
-                        new = NULL;
-                }
-        }
-
-       return;
+    if (!list_empty(&iobuf_pool->all_arenas)) {
+        list_for_each_entry_safe(tmp, dummy, &iobuf_pool->all_arenas, all_list)
+        {
+            new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr),
+                            gf_common_mt_rdma_arena_mr);
+            if (new == NULL) {
+                gf_msg("rdma", GF_LOG_INFO, ENOMEM, RDMA_MSG_MR_ALOC_FAILED,
+                       "Out of "
+                       "memory: registering pre allocated "
+                       "buffer with rdma device failed.");
+                return;
+            }
+            INIT_LIST_HEAD(&new->list);
+            new->iobuf_arena = tmp;
+
+            mr = ibv_reg_mr(device->pd, tmp->mem_base, tmp->arena_size,
+                            IBV_ACCESS_REMOTE_READ | IBV_ACCESS_LOCAL_WRITE |
+                                IBV_ACCESS_REMOTE_WRITE);
+            if (!mr) {
+                gf_msg("rdma", GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED,
+                       "failed"
+                       " to pre register buffers with rdma "
+                       "devices.");
+            }
+            new->mr = mr;
+            pthread_mutex_lock(&device->all_mr_lock);
+            {
+                list_add(&new->list, &device->all_mr);
+            }
+            pthread_mutex_unlock(&device->all_mr_lock);
+
+            new = NULL;
+        }
+    }
+
+    return;
 }
 
 static void
-gf_rdma_register_iobuf_pool_with_device (gf_rdma_device_t *device,
-                                         struct iobuf_pool *iobuf_pool)
+gf_rdma_register_iobuf_pool_with_device(gf_rdma_device_t *device,
+                                        struct iobuf_pool *iobuf_pool)
 {
-        while (device) {
-                gf_rdma_register_iobuf_pool (device, iobuf_pool);
-                device = device->next;
-        }
+    while (device) {
+        gf_rdma_register_iobuf_pool(device, iobuf_pool);
+        device = device->next;
+    }
 }
 
-static struct ibv_mr*
+static struct ibv_mr *
 gf_rdma_get_pre_registred_mr(rpc_transport_t *this, void *ptr, int size)
 {
-        gf_rdma_arena_mr   *tmp        = NULL;
-        gf_rdma_arena_mr   *dummy      = NULL;
-        gf_rdma_private_t  *priv       = NULL;
-        gf_rdma_device_t   *device     = NULL;
-
-        priv = this->private;
-        device = priv->device;
-
-        pthread_mutex_lock (&device->all_mr_lock);
-        {
-                if (!list_empty(&device->all_mr)) {
-                        list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) {
-                                if (tmp->iobuf_arena->mem_base <= ptr &&
-                                    ptr < tmp->iobuf_arena->mem_base +
-                                    tmp->iobuf_arena->arena_size) {
-                                        pthread_mutex_unlock (&device->all_mr_lock);
-                                        return tmp->mr;
-                                }
-                        }
+    gf_rdma_arena_mr *tmp = NULL;
+    gf_rdma_arena_mr *dummy = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+
+    priv = this->private;
+    device = priv->device;
+
+    pthread_mutex_lock(&device->all_mr_lock);
+    {
+        if (!list_empty(&device->all_mr)) {
+            list_for_each_entry_safe(tmp, dummy, &device->all_mr, list)
+            {
+                if (tmp->iobuf_arena->mem_base <= ptr &&
+                    ptr < tmp->iobuf_arena->mem_base +
+                              tmp->iobuf_arena->arena_size) {
+                    pthread_mutex_unlock(&device->all_mr_lock);
+                    return tmp->mr;
                 }
+            }
         }
-        pthread_mutex_unlock (&device->all_mr_lock);
+    }
+    pthread_mutex_unlock(&device->all_mr_lock);
 
-        return NULL;
+    return NULL;
 }
 
 static int32_t
-gf_rdma_create_posts (rpc_transport_t *this)
+gf_rdma_create_posts(rpc_transport_t *this)
 {
-        int32_t            i       = 0, ret = 0;
-        gf_rdma_post_t    *post    = NULL;
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_options_t *options = NULL;
-        gf_rdma_device_t  *device  = NULL;
-
-        priv = this->private;
-        options = &priv->options;
-        device = priv->device;
-
-        ret =  __gf_rdma_create_posts (this, options->send_count,
-                                       options->send_size,
-                                       &device->sendq, GF_RDMA_SEND_POST);
-        if (!ret)
-                ret =  __gf_rdma_create_posts (this, options->recv_count,
-                                               options->recv_size,
-                                               &device->recvq,
-                                               GF_RDMA_RECV_POST);
-
-        if (!ret) {
-                for (i = 0 ; i < options->recv_count ; i++) {
-                        post = gf_rdma_get_post (&device->recvq);
-                        if (gf_rdma_post_recv (device->srq, post) != 0) {
-                                ret = -1;
-                                break;
-                        }
-                }
+    int32_t i = 0, ret = 0;
+    gf_rdma_post_t *post = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_options_t *options = NULL;
+    gf_rdma_device_t *device = NULL;
+
+    priv = this->private;
+    options = &priv->options;
+    device = priv->device;
+
+    ret = __gf_rdma_create_posts(this, options->send_count, options->send_size,
+                                 &device->sendq, GF_RDMA_SEND_POST);
+    if (!ret)
+        ret = __gf_rdma_create_posts(this, options->recv_count,
+                                     options->recv_size, &device->recvq,
+                                     GF_RDMA_RECV_POST);
+
+    if (!ret) {
+        for (i = 0; i < options->recv_count; i++) {
+            post = gf_rdma_get_post(&device->recvq);
+            if (gf_rdma_post_recv(device->srq, post) != 0) {
+                ret = -1;
+                break;
+            }
         }
+    }
 
-        if (ret)
-                gf_rdma_destroy_posts (this);
+    if (ret)
+        gf_rdma_destroy_posts(this);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-gf_rdma_destroy_cq (rpc_transport_t *this)
+gf_rdma_destroy_cq(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
 
-        priv = this->private;
-        device = priv->device;
+    priv = this->private;
+    device = priv->device;
 
-        if (device->recv_cq)
-                ibv_destroy_cq (device->recv_cq);
-        device->recv_cq = NULL;
+    if (device->recv_cq)
+        ibv_destroy_cq(device->recv_cq);
+    device->recv_cq = NULL;
 
-        if (device->send_cq)
-                ibv_destroy_cq (device->send_cq);
-        device->send_cq = NULL;
+    if (device->send_cq)
+        ibv_destroy_cq(device->send_cq);
+    device->send_cq = NULL;
 
-        return;
+    return;
 }
 
-
 static int32_t
-gf_rdma_create_cq (rpc_transport_t *this)
+gf_rdma_create_cq(rpc_transport_t *this)
 {
-        gf_rdma_private_t      *priv        = NULL;
-        gf_rdma_options_t      *options     = NULL;
-        gf_rdma_device_t       *device      = NULL;
-        uint64_t                send_cqe    = 0;
-        int32_t                 ret         = 0;
-        struct ibv_device_attr  device_attr = {{0}, };
-
-        priv = this->private;
-        options = &priv->options;
-        device = priv->device;
-
-        device->recv_cq = ibv_create_cq (priv->device->context,
-                                         options->recv_count * 2,
-                                         device,
-                                         device->recv_chan,
-                                         0);
-        if (!device->recv_cq) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        RDMA_MSG_CQ_CREATION_FAILED, "creation of CQ for "
-                        "device %s failed", device->device_name);
-                ret = -1;
-                goto out;
-        } else if (ibv_req_notify_cq (device->recv_cq, 0)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED, "ibv_req_notify_"
-                        "cq on recv CQ of device %s failed",
-                        device->device_name);
-                ret = -1;
-                goto out;
-        }
-
-        do {
-                ret = ibv_query_device (priv->device->context, &device_attr);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_QUERY_DEVICE_FAILED, "ibv_query_"
-                                "device on %s returned %d (%s)",
-                                priv->device->device_name, ret,
-                                (ret > 0) ? strerror (ret) : "");
-                        ret = -1;
-                        goto out;
-                }
-
-                send_cqe = (uint64_t)options->send_count * 128;
-                send_cqe = (send_cqe > device_attr.max_cqe)
-                        ? device_attr.max_cqe : send_cqe;
-
-                /* TODO: make send_cq size dynamically adaptive */
-                device->send_cq = ibv_create_cq (priv->device->context,
-                                                 send_cqe, device,
-                                                 device->send_chan, 0);
-                if (!device->send_cq) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CQ_CREATION_FAILED,
-                                "creation of send_cq "
-                                "for device %s failed", device->device_name);
-                        ret = -1;
-                        goto out;
-                }
-
-                if (ibv_req_notify_cq (device->send_cq, 0)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED,
-                                "ibv_req_notify_cq on send_cq for device %s"
-                                " failed",  device->device_name);
-                        ret = -1;
-                        goto out;
-                }
-        } while (0);
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_options_t *options = NULL;
+    gf_rdma_device_t *device = NULL;
+    uint64_t send_cqe = 0;
+    int32_t ret = 0;
+    struct ibv_device_attr device_attr = {
+        {0},
+    };
+
+    priv = this->private;
+    options = &priv->options;
+    device = priv->device;
+
+    device->recv_cq = ibv_create_cq(priv->device->context,
+                                    options->recv_count * 2, device,
+                                    device->recv_chan, 0);
+    if (!device->recv_cq) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED,
+               "creation of CQ for "
+               "device %s failed",
+               device->device_name);
+        ret = -1;
+        goto out;
+    } else if (ibv_req_notify_cq(device->recv_cq, 0)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED,
+               "ibv_req_notify_"
+               "cq on recv CQ of device %s failed",
+               device->device_name);
+        ret = -1;
+        goto out;
+    }
+
+    do {
+        ret = ibv_query_device(priv->device->context, &device_attr);
+        if (ret != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_QUERY_DEVICE_FAILED,
+                   "ibv_query_"
+                   "device on %s returned %d (%s)",
+                   priv->device->device_name, ret,
+                   (ret > 0) ? strerror(ret) : "");
+            ret = -1;
+            goto out;
+        }
+
+        send_cqe = (uint64_t)options->send_count * 128;
+        send_cqe = (send_cqe > device_attr.max_cqe) ? device_attr.max_cqe
+                                                    : send_cqe;
+
+        /* TODO: make send_cq size dynamically adaptive */
+        device->send_cq = ibv_create_cq(priv->device->context, send_cqe, device,
+                                        device->send_chan, 0);
+        if (!device->send_cq) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED,
+                   "creation of send_cq "
+                   "for device %s failed",
+                   device->device_name);
+            ret = -1;
+            goto out;
+        }
+
+        if (ibv_req_notify_cq(device->send_cq, 0)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED,
+                   "ibv_req_notify_cq on send_cq for device %s"
+                   " failed",
+                   device->device_name);
+            ret = -1;
+            goto out;
+        }
+    } while (0);
 
 out:
-        if (ret != 0)
-                gf_rdma_destroy_cq (this);
+    if (ret != 0)
+        gf_rdma_destroy_cq(this);
 
-        return ret;
+    return ret;
 }
 
-
 static gf_rdma_device_t *
-gf_rdma_get_device (rpc_transport_t *this, struct ibv_context *ibctx,
-                    char *device_name)
+gf_rdma_get_device(rpc_transport_t *this, struct ibv_context *ibctx,
+                   char *device_name)
 {
-        glusterfs_ctx_t   *ctx      = NULL;
-        gf_rdma_private_t *priv     = NULL;
-        gf_rdma_options_t *options  = NULL;
-        int32_t            ret      = 0;
-        int32_t            i        = 0;
-        gf_rdma_device_t  *trav     = NULL, *device = NULL;
-        gf_rdma_ctx_t     *rdma_ctx = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-
-        priv        = this->private;
-        options     = &priv->options;
-        ctx         = this->ctx;
-        rdma_ctx    = ctx->ib;
-        iobuf_pool = ctx->iobuf_pool;
-
-        trav = rdma_ctx->device;
-
-        while (trav) {
-                if (!strcmp (trav->device_name, device_name))
-                        break;
-                trav = trav->next;
-        }
-
-        if (!trav) {
-                trav = GF_CALLOC (1, sizeof (*trav),
-                                  gf_common_mt_rdma_device_t);
-                if (trav == NULL) {
-                        goto out;
-                }
-                priv->device = trav;
-                trav->context = ibctx;
-
-                trav->next = rdma_ctx->device;
-                rdma_ctx->device = trav;
-
-                iobuf_pool->device[iobuf_pool->rdma_device_count] = trav;
-                iobuf_pool->mr_list[iobuf_pool->rdma_device_count++] = &trav->all_mr;
-                trav->request_ctx_pool
-                        = mem_pool_new (gf_rdma_request_context_t,
-                                        GF_RDMA_POOL_SIZE);
-                if (trav->request_ctx_pool == NULL) {
-                        goto out;
-                }
+    glusterfs_ctx_t *ctx = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_options_t *options = NULL;
+    int32_t ret = 0;
+    int32_t i = 0;
+    gf_rdma_device_t *trav = NULL, *device = NULL;
+    gf_rdma_ctx_t *rdma_ctx = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
 
-                trav->ioq_pool
-                        = mem_pool_new (gf_rdma_ioq_t, GF_RDMA_POOL_SIZE);
-                if (trav->ioq_pool == NULL) {
-                        goto out;
-                }
-
-                trav->reply_info_pool = mem_pool_new (gf_rdma_reply_info_t,
-                                                      GF_RDMA_POOL_SIZE);
-                if (trav->reply_info_pool == NULL) {
-                        goto out;
-                }
+    priv = this->private;
+    options = &priv->options;
+    ctx = this->ctx;
+    rdma_ctx = ctx->ib;
+    iobuf_pool = ctx->iobuf_pool;
 
-                trav->device_name = gf_strdup (device_name);
+    trav = rdma_ctx->device;
 
-                trav->send_chan = ibv_create_comp_channel (trav->context);
-                if (!trav->send_chan) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_SEND_COMP_CHAN_FAILED, "could not "
-                                "create send completion channel for "
-                                "device (%s)", device_name);
-                        goto out;
-                }
-
-                trav->recv_chan = ibv_create_comp_channel (trav->context);
-                if (!trav->recv_chan) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_RECV_COMP_CHAN_FAILED, "could not "
-                                "create recv completion channel for "
-                                "device (%s)", device_name);
-
-                        /* TODO: cleanup current mess */
-                        goto out;
-                }
-
-                if (gf_rdma_create_cq (this) < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CQ_CREATION_FAILED,
-                                "could not create CQ for device (%s)",
-                                device_name);
-                        goto out;
-                }
-
-                /* protection domain */
-                trav->pd = ibv_alloc_pd (trav->context);
-
-                if (!trav->pd) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ALOC_PROT_DOM_FAILED, "could not "
-                                "allocate protection domain for device (%s)",
-                                device_name);
-                        goto out;
-                }
+    while (trav) {
+        if (!strcmp(trav->device_name, device_name))
+            break;
+        trav = trav->next;
+    }
 
-                struct ibv_srq_init_attr attr = {
-                        .attr = {
-                                .max_wr = options->recv_count,
-                                .max_sge = 1,
-                                .srq_limit = 10
-                        }
-                };
-                trav->srq = ibv_create_srq (trav->pd, &attr);
-
-                if (!trav->srq) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_CRE_SRQ_FAILED, "could not create SRQ"
-                                " for device (%s)",
-                                device_name);
-                        goto out;
-                }
-
-                /* queue init */
-                gf_rdma_queue_init (&trav->sendq);
-                gf_rdma_queue_init (&trav->recvq);
-
-                INIT_LIST_HEAD (&trav->all_mr);
-                pthread_mutex_init (&trav->all_mr_lock, NULL);
-                gf_rdma_register_iobuf_pool(trav, iobuf_pool);
-
-                if (gf_rdma_create_posts (this) < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ALOC_POST_FAILED, "could not allocate"
-                                "posts for device (%s)", device_name);
-                        goto out;
-                }
-
-                /* completion threads */
-                ret = gf_thread_create (&trav->send_thread, NULL,
-                                        gf_rdma_send_completion_proc,
-                                        trav->send_chan, "rdmascom");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_SEND_COMP_THREAD_FAILED,
-                                "could not create send completion thread for "
-                                "device (%s)", device_name);
-                        goto out;
-                }
-
-                ret = gf_thread_create (&trav->recv_thread, NULL,
-                                        gf_rdma_recv_completion_proc,
-                                        trav->recv_chan, "rdmarcom");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_RECV_COMP_THREAD_FAILED,
-                                "could not create recv completion thread "
-                                "for device (%s)", device_name);
-                        return NULL;
-                }
-
-                ret = gf_thread_create (&trav->async_event_thread, NULL,
-                                        gf_rdma_async_event_thread,
-                                        ibctx, "rdmaAsyn");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                RDMA_MSG_ASYNC_EVENT_THEAD_FAILED,
-                                "could not create async_event_thread");
-                        return NULL;
-                }
-
-                /* qpreg */
-                pthread_mutex_init (&trav->qpreg.lock, NULL);
-                for (i = 0; i < 42; i++) {
-                        trav->qpreg.ents[i].next = &trav->qpreg.ents[i];
-                        trav->qpreg.ents[i].prev = &trav->qpreg.ents[i];
-                }
+    if (!trav) {
+        trav = GF_CALLOC(1, sizeof(*trav), gf_common_mt_rdma_device_t);
+        if (trav == NULL) {
+            goto out;
         }
+        priv->device = trav;
+        trav->context = ibctx;
 
-        device = trav;
-        trav = NULL;
-out:
+        trav->next = rdma_ctx->device;
+        rdma_ctx->device = trav;
 
-        if (trav != NULL) {
-                rdma_ctx->device = trav->next;
-                gf_rdma_destroy_posts (this);
-                mem_pool_destroy (trav->ioq_pool);
-                mem_pool_destroy (trav->request_ctx_pool);
-                mem_pool_destroy (trav->reply_info_pool);
-                if (trav->pd != NULL) {
-                        ibv_dealloc_pd (trav->pd);
-                }
-                gf_rdma_destroy_cq (this);
-                ibv_destroy_comp_channel (trav->recv_chan);
-                ibv_destroy_comp_channel (trav->send_chan);
-                GF_FREE ((char *)trav->device_name);
-                GF_FREE (trav);
+        iobuf_pool->device[iobuf_pool->rdma_device_count] = trav;
+        iobuf_pool->mr_list[iobuf_pool->rdma_device_count++] = &trav->all_mr;
+        trav->request_ctx_pool = mem_pool_new(gf_rdma_request_context_t,
+                                              GF_RDMA_POOL_SIZE);
+        if (trav->request_ctx_pool == NULL) {
+            goto out;
         }
 
-        return device;
-}
-
-
-static rpc_transport_t *
-gf_rdma_transport_new (rpc_transport_t *listener, struct rdma_cm_id *cm_id)
-{
-        gf_rdma_private_t *listener_priv = NULL, *priv = NULL;
-        rpc_transport_t   *this          = NULL, *new = NULL;
-        gf_rdma_options_t *options       = NULL;
-        char              *device_name   = NULL;
-
-        listener_priv = listener->private;
-
-        this = GF_CALLOC (1, sizeof (rpc_transport_t),
-                          gf_common_mt_rpc_transport_t);
-        if (this == NULL) {
-                goto out;
+        trav->ioq_pool = mem_pool_new(gf_rdma_ioq_t, GF_RDMA_POOL_SIZE);
+        if (trav->ioq_pool == NULL) {
+            goto out;
         }
 
-        this->listener = listener;
-
-        priv = GF_CALLOC (1, sizeof (gf_rdma_private_t),
-                          gf_common_mt_rdma_private_t);
-        if (priv == NULL) {
-                goto out;
+        trav->reply_info_pool = mem_pool_new(gf_rdma_reply_info_t,
+                                             GF_RDMA_POOL_SIZE);
+        if (trav->reply_info_pool == NULL) {
+            goto out;
         }
 
-        this->private = priv;
-        priv->options = listener_priv->options;
-
-        priv->listener = listener;
-        priv->entity = GF_RDMA_SERVER;
-
-        options = &priv->options;
+        trav->device_name = gf_strdup(device_name);
 
-        this->ops = listener->ops;
-        this->init = listener->init;
-        this->fini = listener->fini;
-        this->ctx = listener->ctx;
-        this->name = gf_strdup (listener->name);
-        this->notify = listener->notify;
-        this->mydata = listener->mydata;
-        this->xl = listener->xl;
-
-        this->myinfo.sockaddr_len = sizeof (cm_id->route.addr.src_addr);
-        memcpy (&this->myinfo.sockaddr, &cm_id->route.addr.src_addr,
-                this->myinfo.sockaddr_len);
-
-        this->peerinfo.sockaddr_len = sizeof (cm_id->route.addr.dst_addr);
-        memcpy (&this->peerinfo.sockaddr, &cm_id->route.addr.dst_addr,
-                this->peerinfo.sockaddr_len);
+        trav->send_chan = ibv_create_comp_channel(trav->context);
+        if (!trav->send_chan) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_SEND_COMP_CHAN_FAILED,
+                   "could not "
+                   "create send completion channel for "
+                   "device (%s)",
+                   device_name);
+            goto out;
+        }
 
-        priv->peer.trans = this;
-        gf_rdma_get_transport_identifiers (this);
+        trav->recv_chan = ibv_create_comp_channel(trav->context);
+        if (!trav->recv_chan) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_RECV_COMP_CHAN_FAILED,
+                   "could not "
+                   "create recv completion channel for "
+                   "device (%s)",
+                   device_name);
 
-        device_name = (char *)ibv_get_device_name (cm_id->verbs->device);
-        if (device_name == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get device "
-                        "name (peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                goto out;
+            /* TODO: cleanup current mess */
+            goto out;
         }
 
-        priv->device = gf_rdma_get_device (this, cm_id->verbs,
-                                           device_name);
-        if (priv->device == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_IB_DEVICE_FAILED, "cannot get infiniband"
-                        " device %s (peer:%s me:%s)", device_name,
-                        this->peerinfo.identifier, this->myinfo.identifier);
-                goto out;
+        if (gf_rdma_create_cq(this) < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED,
+                   "could not create CQ for device (%s)", device_name);
+            goto out;
         }
 
-        priv->peer.send_count = options->send_count;
-        priv->peer.recv_count = options->recv_count;
-        priv->peer.send_size = options->send_size;
-        priv->peer.recv_size = options->recv_size;
-        priv->peer.cm_id = cm_id;
-        INIT_LIST_HEAD (&priv->peer.ioq);
+        /* protection domain */
+        trav->pd = ibv_alloc_pd(trav->context);
 
-        pthread_mutex_init (&priv->write_mutex, NULL);
-        pthread_mutex_init (&priv->recv_mutex, NULL);
-
-        cm_id->context = this;
-
-        new = rpc_transport_ref (this);
-        this = NULL;
-out:
-        if (this != NULL) {
-                if (this->private != NULL) {
-                        GF_FREE (this->private);
-                }
+        if (!trav->pd) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_ALOC_PROT_DOM_FAILED,
+                   "could not "
+                   "allocate protection domain for device (%s)",
+                   device_name);
+            goto out;
+        }
 
-                if (this->name != NULL) {
-                        GF_FREE (this->name);
-                }
+        struct ibv_srq_init_attr attr = {.attr = {.max_wr = options->recv_count,
+                                                  .max_sge = 1,
+                                                  .srq_limit = 10}};
+        trav->srq = ibv_create_srq(trav->pd, &attr);
 
-                GF_FREE (this);
+        if (!trav->srq) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CRE_SRQ_FAILED,
+                   "could not create SRQ"
+                   " for device (%s)",
+                   device_name);
+            goto out;
         }
 
-        return new;
-}
+        /* queue init */
+        gf_rdma_queue_init(&trav->sendq);
+        gf_rdma_queue_init(&trav->recvq);
 
+        INIT_LIST_HEAD(&trav->all_mr);
+        pthread_mutex_init(&trav->all_mr_lock, NULL);
+        gf_rdma_register_iobuf_pool(trav, iobuf_pool);
 
-static int
-gf_rdma_cm_handle_connect_request (struct rdma_cm_event *event)
-{
-        int                     ret         = -1;
-        rpc_transport_t        *this        = NULL, *listener = NULL;
-        struct rdma_cm_id      *child_cm_id = NULL, *listener_cm_id = NULL;
-        struct rdma_conn_param  conn_param  = {0, };
-        gf_rdma_private_t      *priv        = NULL;
-        gf_rdma_options_t      *options     = NULL;
-
-        child_cm_id = event->id;
-        listener_cm_id = event->listen_id;
-
-        listener = listener_cm_id->context;
-        priv = listener->private;
-        options = &priv->options;
-
-        this = gf_rdma_transport_new (listener, child_cm_id);
-        if (this == NULL) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_INC_TRANS_FAILED, "could not create "
-                        "a transport for incoming connection"
-                        " (me.name:%s me.identifier:%s)", listener->name,
-                        listener->myinfo.identifier);
-                rdma_destroy_id (child_cm_id);
-                goto out;
+        if (gf_rdma_create_posts(this) < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_ALOC_POST_FAILED,
+                   "could not allocate"
+                   "posts for device (%s)",
+                   device_name);
+            goto out;
         }
 
-        gf_msg_trace (listener->name, 0, "got a connect request (me:%s peer:"
-                      "%s)", listener->myinfo.identifier,
-                      this->peerinfo.identifier);
+        /* completion threads */
+        ret = gf_thread_create(&trav->send_thread, NULL,
+                               gf_rdma_send_completion_proc, trav->send_chan,
+                               "rdmascom");
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   RDMA_MSG_SEND_COMP_THREAD_FAILED,
+                   "could not create send completion thread for "
+                   "device (%s)",
+                   device_name);
+            goto out;
+        }
 
-        ret = gf_rdma_create_qp (this);
-        if (ret < 0) {
-                gf_msg (listener->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_QP_FAILED, "could not create QP "
-                        "(peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
+        ret = gf_thread_create(&trav->recv_thread, NULL,
+                               gf_rdma_recv_completion_proc, trav->recv_chan,
+                               "rdmarcom");
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   RDMA_MSG_RECV_COMP_THREAD_FAILED,
+                   "could not create recv completion thread "
+                   "for device (%s)",
+                   device_name);
+            return NULL;
         }
 
-        conn_param.responder_resources = 1;
-        conn_param.initiator_depth = 1;
-        conn_param.retry_count = options->attr_retry_cnt;
-        conn_param.rnr_retry_count = options->attr_rnr_retry;
+        ret = gf_thread_create(&trav->async_event_thread, NULL,
+                               gf_rdma_async_event_thread, ibctx, "rdmaAsyn");
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   RDMA_MSG_ASYNC_EVENT_THEAD_FAILED,
+                   "could not create async_event_thread");
+            return NULL;
+        }
 
-        ret = rdma_accept(child_cm_id, &conn_param);
-        if (ret < 0) {
-                gf_msg (listener->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_ACCEPT_FAILED, "rdma_accept failed peer:%s "
-                        "me:%s", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
+        /* qpreg */
+        pthread_mutex_init(&trav->qpreg.lock, NULL);
+        for (i = 0; i < 42; i++) {
+            trav->qpreg.ents[i].next = &trav->qpreg.ents[i];
+            trav->qpreg.ents[i].prev = &trav->qpreg.ents[i];
         }
-        gf_rdma_cm_handle_connect_init (event);
-        ret = 0;
+    }
 
+    device = trav;
+    trav = NULL;
 out:
-        return ret;
-}
 
+    if (trav != NULL) {
+        rdma_ctx->device = trav->next;
+        gf_rdma_destroy_posts(this);
+        mem_pool_destroy(trav->ioq_pool);
+        mem_pool_destroy(trav->request_ctx_pool);
+        mem_pool_destroy(trav->reply_info_pool);
+        if (trav->pd != NULL) {
+            ibv_dealloc_pd(trav->pd);
+        }
+        gf_rdma_destroy_cq(this);
+        ibv_destroy_comp_channel(trav->recv_chan);
+        ibv_destroy_comp_channel(trav->send_chan);
+        GF_FREE((char *)trav->device_name);
+        GF_FREE(trav);
+    }
+
+    return device;
+}
 
-static int
-gf_rdma_cm_handle_route_resolved (struct rdma_cm_event *event)
+static rpc_transport_t *
+gf_rdma_transport_new(rpc_transport_t *listener, struct rdma_cm_id *cm_id)
 {
-        struct rdma_conn_param  conn_param = {0, };
-        int                     ret        = 0;
-        rpc_transport_t        *this       = NULL;
-        gf_rdma_private_t      *priv       = NULL;
-        gf_rdma_peer_t         *peer       = NULL;
-        gf_rdma_options_t      *options    = NULL;
-
-        if (event == NULL) {
-                goto out;
+    gf_rdma_private_t *listener_priv = NULL, *priv = NULL;
+    rpc_transport_t *this = NULL, *new = NULL;
+    gf_rdma_options_t *options = NULL;
+    char *device_name = NULL;
+
+    listener_priv = listener->private;
+
+    this = GF_CALLOC(1, sizeof(rpc_transport_t), gf_common_mt_rpc_transport_t);
+    if (this == NULL) {
+        goto out;
+    }
+
+    this->listener = listener;
+
+    priv = GF_CALLOC(1, sizeof(gf_rdma_private_t), gf_common_mt_rdma_private_t);
+    if (priv == NULL) {
+        goto out;
+    }
+
+    this->private = priv;
+    priv->options = listener_priv->options;
+
+    priv->listener = listener;
+    priv->entity = GF_RDMA_SERVER;
+
+    options = &priv->options;
+
+    this->ops = listener->ops;
+    this->init = listener->init;
+    this->fini = listener->fini;
+    this->ctx = listener->ctx;
+    this->name = gf_strdup(listener->name);
+    this->notify = listener->notify;
+    this->mydata = listener->mydata;
+    this->xl = listener->xl;
+
+    this->myinfo.sockaddr_len = sizeof(cm_id->route.addr.src_addr);
+    memcpy(&this->myinfo.sockaddr, &cm_id->route.addr.src_addr,
+           this->myinfo.sockaddr_len);
+
+    this->peerinfo.sockaddr_len = sizeof(cm_id->route.addr.dst_addr);
+    memcpy(&this->peerinfo.sockaddr, &cm_id->route.addr.dst_addr,
+           this->peerinfo.sockaddr_len);
+
+    priv->peer.trans = this;
+    gf_rdma_get_transport_identifiers(this);
+
+    device_name = (char *)ibv_get_device_name(cm_id->verbs->device);
+    if (device_name == NULL) {
+        gf_msg(listener->name, GF_LOG_WARNING, 0,
+               RDMA_MSG_GET_DEVICE_NAME_FAILED,
+               "cannot get device "
+               "name (peer:%s me:%s)",
+               this->peerinfo.identifier, this->myinfo.identifier);
+        goto out;
+    }
+
+    priv->device = gf_rdma_get_device(this, cm_id->verbs, device_name);
+    if (priv->device == NULL) {
+        gf_msg(listener->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_IB_DEVICE_FAILED,
+               "cannot get infiniband"
+               " device %s (peer:%s me:%s)",
+               device_name, this->peerinfo.identifier, this->myinfo.identifier);
+        goto out;
+    }
+
+    priv->peer.send_count = options->send_count;
+    priv->peer.recv_count = options->recv_count;
+    priv->peer.send_size = options->send_size;
+    priv->peer.recv_size = options->recv_size;
+    priv->peer.cm_id = cm_id;
+    INIT_LIST_HEAD(&priv->peer.ioq);
+
+    pthread_mutex_init(&priv->write_mutex, NULL);
+    pthread_mutex_init(&priv->recv_mutex, NULL);
+
+    cm_id->context = this;
+
+    new = rpc_transport_ref(this);
+    this = NULL;
+out:
+    if (this != NULL) {
+        if (this->private != NULL) {
+            GF_FREE(this->private);
         }
 
-        this = event->id->context;
-
-        priv = this->private;
-        peer = &priv->peer;
-        options = &priv->options;
-
-        ret = gf_rdma_create_qp (this);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CREAT_QP_FAILED, "could not create QP "
-                        "(peer:%s me:%s)", this->peerinfo.identifier,
-                        this->myinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
+        if (this->name != NULL) {
+            GF_FREE(this->name);
         }
 
-        memset(&conn_param, 0, sizeof conn_param);
-        conn_param.responder_resources = 1;
-        conn_param.initiator_depth = 1;
-        conn_param.retry_count = options->attr_retry_cnt;
-        conn_param.rnr_retry_count = options->attr_rnr_retry;
+        GF_FREE(this);
+    }
 
-        ret = rdma_connect(peer->cm_id, &conn_param);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CONNECT_FAILED,
-                        "rdma_connect failed");
-                gf_rdma_cm_handle_disconnect (this);
-                goto out;
-        }
+    return new;
+}
 
-        gf_msg_trace (this->name, 0, "route resolved (me:%s peer:%s)",
-                      this->myinfo.identifier, this->peerinfo.identifier);
+static int
+gf_rdma_cm_handle_connect_request(struct rdma_cm_event *event)
+{
+    int ret = -1;
+    rpc_transport_t *this = NULL, *listener = NULL;
+    struct rdma_cm_id *child_cm_id = NULL, *listener_cm_id = NULL;
+    struct rdma_conn_param conn_param = {
+        0,
+    };
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_options_t *options = NULL;
+
+    child_cm_id = event->id;
+    listener_cm_id = event->listen_id;
+
+    listener = listener_cm_id->context;
+    priv = listener->private;
+    options = &priv->options;
+
+    this = gf_rdma_transport_new(listener, child_cm_id);
+    if (this == NULL) {
+        gf_msg(listener->name, GF_LOG_WARNING, 0,
+               RDMA_MSG_CREAT_INC_TRANS_FAILED,
+               "could not create "
+               "a transport for incoming connection"
+               " (me.name:%s me.identifier:%s)",
+               listener->name, listener->myinfo.identifier);
+        rdma_destroy_id(child_cm_id);
+        goto out;
+    }
+
+    gf_msg_trace(listener->name, 0,
+                 "got a connect request (me:%s peer:"
+                 "%s)",
+                 listener->myinfo.identifier, this->peerinfo.identifier);
+
+    ret = gf_rdma_create_qp(this);
+    if (ret < 0) {
+        gf_msg(listener->name, GF_LOG_WARNING, 0, RDMA_MSG_CREAT_QP_FAILED,
+               "could not create QP "
+               "(peer:%s me:%s)",
+               this->peerinfo.identifier, this->myinfo.identifier);
+        gf_rdma_cm_handle_disconnect(this);
+        goto out;
+    }
+
+    conn_param.responder_resources = 1;
+    conn_param.initiator_depth = 1;
+    conn_param.retry_count = options->attr_retry_cnt;
+    conn_param.rnr_retry_count = options->attr_rnr_retry;
+
+    ret = rdma_accept(child_cm_id, &conn_param);
+    if (ret < 0) {
+        gf_msg(listener->name, GF_LOG_WARNING, errno, RDMA_MSG_ACCEPT_FAILED,
+               "rdma_accept failed peer:%s "
+               "me:%s",
+               this->peerinfo.identifier, this->myinfo.identifier);
+        gf_rdma_cm_handle_disconnect(this);
+        goto out;
+    }
+    gf_rdma_cm_handle_connect_init(event);
+    ret = 0;
 
-        ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
+static int
+gf_rdma_cm_handle_route_resolved(struct rdma_cm_event *event)
+{
+    struct rdma_conn_param conn_param = {
+        0,
+    };
+    int ret = 0;
+    rpc_transport_t *this = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    gf_rdma_options_t *options = NULL;
+
+    if (event == NULL) {
+        goto out;
+    }
+
+    this = event->id->context;
+
+    priv = this->private;
+    peer = &priv->peer;
+    options = &priv->options;
+
+    ret = gf_rdma_create_qp(this);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_CREAT_QP_FAILED,
+               "could not create QP "
+               "(peer:%s me:%s)",
+               this->peerinfo.identifier, this->myinfo.identifier);
+        gf_rdma_cm_handle_disconnect(this);
+        goto out;
+    }
+
+    memset(&conn_param, 0, sizeof conn_param);
+    conn_param.responder_resources = 1;
+    conn_param.initiator_depth = 1;
+    conn_param.retry_count = options->attr_retry_cnt;
+    conn_param.rnr_retry_count = options->attr_rnr_retry;
+
+    ret = rdma_connect(peer->cm_id, &conn_param);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_CONNECT_FAILED,
+               "rdma_connect failed");
+        gf_rdma_cm_handle_disconnect(this);
+        goto out;
+    }
+
+    gf_msg_trace(this->name, 0, "route resolved (me:%s peer:%s)",
+                 this->myinfo.identifier, this->peerinfo.identifier);
+
+    ret = 0;
+out:
+    return ret;
+}
 
 static int
-gf_rdma_cm_handle_addr_resolved (struct rdma_cm_event *event)
+gf_rdma_cm_handle_addr_resolved(struct rdma_cm_event *event)
 {
-        rpc_transport_t   *this = NULL;
-        gf_rdma_peer_t    *peer = NULL;
-        gf_rdma_private_t *priv = NULL;
-        int                ret  = 0;
+    rpc_transport_t *this = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    gf_rdma_private_t *priv = NULL;
+    int ret = 0;
 
-        this = event->id->context;
+    this = event->id->context;
 
-        priv = this->private;
-        peer = &priv->peer;
+    priv = this->private;
+    peer = &priv->peer;
 
-        GF_ASSERT (peer->cm_id == event->id);
+    GF_ASSERT(peer->cm_id == event->id);
 
-        this->myinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.src_addr);
-        memcpy (&this->myinfo.sockaddr, &peer->cm_id->route.addr.src_addr,
-                this->myinfo.sockaddr_len);
+    this->myinfo.sockaddr_len = sizeof(peer->cm_id->route.addr.src_addr);
+    memcpy(&this->myinfo.sockaddr, &peer->cm_id->route.addr.src_addr,
+           this->myinfo.sockaddr_len);
 
-        this->peerinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.dst_addr);
-        memcpy (&this->peerinfo.sockaddr, &peer->cm_id->route.addr.dst_addr,
-                this->peerinfo.sockaddr_len);
+    this->peerinfo.sockaddr_len = sizeof(peer->cm_id->route.addr.dst_addr);
+    memcpy(&this->peerinfo.sockaddr, &peer->cm_id->route.addr.dst_addr,
+           this->peerinfo.sockaddr_len);
 
-        gf_rdma_get_transport_identifiers (this);
+    gf_rdma_get_transport_identifiers(this);
 
-        ret = rdma_resolve_route(peer->cm_id, 2000);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_ROUTE_RESOLVE_FAILED, "rdma_resolve_route "
-                        "failed (me:%s peer:%s)",
-                        this->myinfo.identifier, this->peerinfo.identifier);
-                gf_rdma_cm_handle_disconnect (this);
-                return ret;
-        }
+    ret = rdma_resolve_route(peer->cm_id, 2000);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_ROUTE_RESOLVE_FAILED,
+               "rdma_resolve_route "
+               "failed (me:%s peer:%s)",
+               this->myinfo.identifier, this->peerinfo.identifier);
+        gf_rdma_cm_handle_disconnect(this);
+        return ret;
+    }
 
-        gf_msg_trace (this->name, 0, "Address resolved (me:%s peer:%s)",
-                      this->myinfo.identifier, this->peerinfo.identifier);
+    gf_msg_trace(this->name, 0, "Address resolved (me:%s peer:%s)",
+                 this->myinfo.identifier, this->peerinfo.identifier);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-gf_rdma_cm_handle_disconnect (rpc_transport_t *this)
+gf_rdma_cm_handle_disconnect(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv       = NULL;
-        char               need_unref = 0;
+    gf_rdma_private_t *priv = NULL;
+    char need_unref = 0;
 
-        priv = this->private;
-        gf_msg_debug (this->name, 0, "peer disconnected, cleaning up");
+    priv = this->private;
+    gf_msg_debug(this->name, 0, "peer disconnected, cleaning up");
 
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (priv->peer.cm_id != NULL) {
-                        need_unref = 1;
-                        priv->connected = 0;
-                }
-
-                __gf_rdma_teardown (this);
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        if (priv->peer.cm_id != NULL) {
+            need_unref = 1;
+            priv->connected = 0;
         }
-        pthread_mutex_unlock (&priv->write_mutex);
 
-        rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this);
+        __gf_rdma_teardown(this);
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
 
-        if (need_unref)
-                rpc_transport_unref (this);
+    rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, this);
 
+    if (need_unref)
+        rpc_transport_unref(this);
 }
 
-
 static int
-gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event)
+gf_rdma_cm_handle_connect_init(struct rdma_cm_event *event)
 {
-        rpc_transport_t   *this  = NULL;
-        gf_rdma_private_t *priv  = NULL;
-        struct rdma_cm_id *cm_id = NULL;
-        int                ret   = 0;
-
-        cm_id = event->id;
-        this = cm_id->context;
-        priv = this->private;
-
-        if (priv->connected == 1) {
-                gf_msg_trace (this->name, 0, "received event "
-                              "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
-                              this->myinfo.identifier,
-                              this->peerinfo.identifier);
-                return ret;
-        }
+    rpc_transport_t *this = NULL;
+    gf_rdma_private_t *priv = NULL;
+    struct rdma_cm_id *cm_id = NULL;
+    int ret = 0;
+
+    cm_id = event->id;
+    this = cm_id->context;
+    priv = this->private;
+
+    if (priv->connected == 1) {
+        gf_msg_trace(this->name, 0,
+                     "received event "
+                     "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
+                     this->myinfo.identifier, this->peerinfo.identifier);
+        return ret;
+    }
 
-        priv->connected = 1;
+    priv->connected = 1;
 
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                priv->peer.quota = 1;
-                priv->peer.quota_set = 0;
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        if (priv->entity == GF_RDMA_CLIENT) {
-                gf_msg_trace (this->name, 0, "received event "
-                              "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
-                              this->myinfo.identifier,
-                              this->peerinfo.identifier);
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_CONNECT, this);
-
-        } else if (priv->entity == GF_RDMA_SERVER) {
-                ret = rpc_transport_notify (priv->listener,
-                                            RPC_TRANSPORT_ACCEPT, this);
-        }
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        priv->peer.quota = 1;
+        priv->peer.quota_set = 0;
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
 
-        if (ret < 0) {
-                gf_rdma_disconnect (this, _gf_false);
-        }
+    if (priv->entity == GF_RDMA_CLIENT) {
+        gf_msg_trace(this->name, 0,
+                     "received event "
+                     "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)",
+                     this->myinfo.identifier, this->peerinfo.identifier);
+        ret = rpc_transport_notify(this, RPC_TRANSPORT_CONNECT, this);
 
-        return ret;
-}
+    } else if (priv->entity == GF_RDMA_SERVER) {
+        ret = rpc_transport_notify(priv->listener, RPC_TRANSPORT_ACCEPT, this);
+    }
+
+    if (ret < 0) {
+        gf_rdma_disconnect(this, _gf_false);
+    }
 
+    return ret;
+}
 
 static int
-gf_rdma_cm_handle_event_error (rpc_transport_t *this)
+gf_rdma_cm_handle_event_error(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv  = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->entity != GF_RDMA_SERVER_LISTENER) {
-                gf_rdma_cm_handle_disconnect (this);
-        }
+    if (priv->entity != GF_RDMA_SERVER_LISTENER) {
+        gf_rdma_cm_handle_disconnect(this);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-gf_rdma_cm_handle_device_removal (struct rdma_cm_event *event)
+gf_rdma_cm_handle_device_removal(struct rdma_cm_event *event)
 {
-        return 0;
+    return 0;
 }
 
-
 static void *
-gf_rdma_cm_event_handler (void *data)
+gf_rdma_cm_event_handler(void *data)
 {
-        struct rdma_cm_event      *event         = NULL;
-        int                        ret           = 0;
-        rpc_transport_t           *this          = NULL;
-        struct rdma_event_channel *event_channel = NULL;
-
-        event_channel = data;
-
-        while (1) {
-                ret = rdma_get_cm_event (event_channel, &event);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_CM_EVENT_FAILED,
-                                "rdma_cm_get_event failed");
-                        break;
-                }
+    struct rdma_cm_event *event = NULL;
+    int ret = 0;
+    rpc_transport_t *this = NULL;
+    struct rdma_event_channel *event_channel = NULL;
 
-                switch (event->event) {
-                case RDMA_CM_EVENT_ADDR_RESOLVED:
-                        gf_rdma_cm_handle_addr_resolved (event);
-                        break;
+    event_channel = data;
 
-                case RDMA_CM_EVENT_ROUTE_RESOLVED:
-                        gf_rdma_cm_handle_route_resolved (event);
-                        break;
+    while (1) {
+        ret = rdma_get_cm_event(event_channel, &event);
+        if (ret != 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+                   RDMA_MSG_CM_EVENT_FAILED, "rdma_cm_get_event failed");
+            break;
+        }
 
-                case RDMA_CM_EVENT_CONNECT_REQUEST:
-                        gf_rdma_cm_handle_connect_request (event);
-                        break;
+        switch (event->event) {
+            case RDMA_CM_EVENT_ADDR_RESOLVED:
+                gf_rdma_cm_handle_addr_resolved(event);
+                break;
 
-                case RDMA_CM_EVENT_ESTABLISHED:
-                        gf_rdma_cm_handle_connect_init (event);
-                        break;
+            case RDMA_CM_EVENT_ROUTE_RESOLVED:
+                gf_rdma_cm_handle_route_resolved(event);
+                break;
 
-                case RDMA_CM_EVENT_ADDR_ERROR:
-                case RDMA_CM_EVENT_ROUTE_ERROR:
-                case RDMA_CM_EVENT_CONNECT_ERROR:
-                case RDMA_CM_EVENT_UNREACHABLE:
-                case RDMA_CM_EVENT_REJECTED:
-                        this = event->id->context;
-
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED, "cma event %s, "
-                                "error %d (me:%s peer:%s)\n",
-                                rdma_event_str(event->event), event->status,
-                                this->myinfo.identifier,
-                                this->peerinfo.identifier);
-
-                        rdma_ack_cm_event (event);
-                        event = NULL;
-
-                        gf_rdma_cm_handle_event_error (this);
-                        continue;
-
-                case RDMA_CM_EVENT_DISCONNECTED:
-                        this = event->id->context;
-
-                        gf_msg_debug (this->name, 0, "received disconnect "
-                                      "(me:%s peer:%s)\n",
-                                      this->myinfo.identifier,
-                                      this->peerinfo.identifier);
-
-                        rdma_ack_cm_event (event);
-                        event = NULL;
-
-                        gf_rdma_cm_handle_disconnect (this);
-                        continue;
-
-                case RDMA_CM_EVENT_DEVICE_REMOVAL:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED, "device "
-                                "removed");
-                        gf_rdma_cm_handle_device_removal (event);
-                        break;
+            case RDMA_CM_EVENT_CONNECT_REQUEST:
+                gf_rdma_cm_handle_connect_request(event);
+                break;
 
-                default:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CM_EVENT_FAILED,
-                                "unhandled event: %s, ignoring",
-                                rdma_event_str(event->event));
-                        break;
-                }
+            case RDMA_CM_EVENT_ESTABLISHED:
+                gf_rdma_cm_handle_connect_init(event);
+                break;
 
-                rdma_ack_cm_event (event);
+            case RDMA_CM_EVENT_ADDR_ERROR:
+            case RDMA_CM_EVENT_ROUTE_ERROR:
+            case RDMA_CM_EVENT_CONNECT_ERROR:
+            case RDMA_CM_EVENT_UNREACHABLE:
+            case RDMA_CM_EVENT_REJECTED:
+                this = event->id->context;
+
+                gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_CM_EVENT_FAILED,
+                       "cma event %s, "
+                       "error %d (me:%s peer:%s)\n",
+                       rdma_event_str(event->event), event->status,
+                       this->myinfo.identifier, this->peerinfo.identifier);
+
+                rdma_ack_cm_event(event);
+                event = NULL;
+
+                gf_rdma_cm_handle_event_error(this);
+                continue;
+
+            case RDMA_CM_EVENT_DISCONNECTED:
+                this = event->id->context;
+
+                gf_msg_debug(this->name, 0,
+                             "received disconnect "
+                             "(me:%s peer:%s)\n",
+                             this->myinfo.identifier,
+                             this->peerinfo.identifier);
+
+                rdma_ack_cm_event(event);
+                event = NULL;
+
+                gf_rdma_cm_handle_disconnect(this);
+                continue;
+
+            case RDMA_CM_EVENT_DEVICE_REMOVAL:
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_CM_EVENT_FAILED,
+                       "device "
+                       "removed");
+                gf_rdma_cm_handle_device_removal(event);
+                break;
+
+            default:
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_CM_EVENT_FAILED,
+                       "unhandled event: %s, ignoring",
+                       rdma_event_str(event->event));
+                break;
         }
 
-        return NULL;
-}
+        rdma_ack_cm_event(event);
+    }
 
+    return NULL;
+}
 
 static int32_t
-gf_rdma_post_send (struct ibv_qp *qp, gf_rdma_post_t *post, int32_t len)
+gf_rdma_post_send(struct ibv_qp *qp, gf_rdma_post_t *post, int32_t len)
 {
-        struct ibv_sge list = {
-                .addr = (unsigned long) post->buf,
-                .length = len,
-                .lkey = post->mr->lkey
-        };
-
-        struct ibv_send_wr wr = {
-                .wr_id      = (unsigned long) post,
-                .sg_list    = &list,
-                .num_sge    = 1,
-                .opcode     = IBV_WR_SEND,
-                .send_flags = IBV_SEND_SIGNALED,
-        }, *bad_wr;
-
-        if (!qp)
-                return EINVAL;
-
-        return ibv_post_send (qp, &wr, &bad_wr);
+    struct ibv_sge list = {.addr = (unsigned long)post->buf,
+                           .length = len,
+                           .lkey = post->mr->lkey};
+
+    struct ibv_send_wr wr =
+                           {
+                               .wr_id = (unsigned long)post,
+                               .sg_list = &list,
+                               .num_sge = 1,
+                               .opcode = IBV_WR_SEND,
+                               .send_flags = IBV_SEND_SIGNALED,
+                           },
+                       *bad_wr;
+
+    if (!qp)
+        return EINVAL;
+
+    return ibv_post_send(qp, &wr, &bad_wr);
 }
 
 int
@@ -1388,1945 +1347,1853 @@ __gf_rdma_encode_error(gf_rdma_peer_t *peer, gf_rdma_reply_info_t *reply_info,
                        struct iovec *rpchdr, gf_rdma_header_t *hdr,
                        gf_rdma_errcode_t err)
 {
-        struct rpc_msg *rpc_msg = NULL;
-
-        if (reply_info != NULL) {
-                hdr->rm_xid = hton32(reply_info->rm_xid);
-        } else {
-                rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
-                                               * only one vector.
-                                               * (which is true)
-                                               */
-                hdr->rm_xid = rpc_msg->rm_xid;
-        }
-
-        hdr->rm_vers = hton32(GF_RDMA_VERSION);
-        hdr->rm_credit = hton32(peer->send_count);
-        hdr->rm_type = hton32(GF_RDMA_ERROR);
-        hdr->rm_body.rm_error.rm_type = hton32(err);
-        if (err == ERR_VERS) {
-                hdr->rm_body.rm_error.rm_version.gf_rdma_vers_low
-                        = hton32(GF_RDMA_VERSION);
-                hdr->rm_body.rm_error.rm_version.gf_rdma_vers_high
-                        = hton32(GF_RDMA_VERSION);
-        }
-
-        return sizeof (*hdr);
+    struct rpc_msg *rpc_msg = NULL;
+
+    if (reply_info != NULL) {
+        hdr->rm_xid = hton32(reply_info->rm_xid);
+    } else {
+        rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
+                                       * only one vector.
+                                       * (which is true)
+                                       */
+        hdr->rm_xid = rpc_msg->rm_xid;
+    }
+
+    hdr->rm_vers = hton32(GF_RDMA_VERSION);
+    hdr->rm_credit = hton32(peer->send_count);
+    hdr->rm_type = hton32(GF_RDMA_ERROR);
+    hdr->rm_body.rm_error.rm_type = hton32(err);
+    if (err == ERR_VERS) {
+        hdr->rm_body.rm_error.rm_version.gf_rdma_vers_low = hton32(
+            GF_RDMA_VERSION);
+        hdr->rm_body.rm_error.rm_version.gf_rdma_vers_high = hton32(
+            GF_RDMA_VERSION);
+    }
+
+    return sizeof(*hdr);
 }
 
-
 int32_t
-__gf_rdma_send_error (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                      gf_rdma_post_t *post, gf_rdma_reply_info_t *reply_info,
-                      gf_rdma_errcode_t err)
+__gf_rdma_send_error(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                     gf_rdma_post_t *post, gf_rdma_reply_info_t *reply_info,
+                     gf_rdma_errcode_t err)
 {
-        int32_t  ret = -1, len = 0;
-
-        len = __gf_rdma_encode_error (peer, reply_info, entry->rpchdr,
-                                      (gf_rdma_header_t *)post->buf, err);
-        if (len == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encode error returned -1");
-                goto out;
-        }
-
-        gf_rdma_post_ref (post);
-
-        ret = gf_rdma_post_send (peer->qp, post, len);
-        if (!ret) {
-                ret = len;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED,
-                        "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
+    int32_t ret = -1, len = 0;
+
+    len = __gf_rdma_encode_error(peer, reply_info, entry->rpchdr,
+                                 (gf_rdma_header_t *)post->buf, err);
+    if (len == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, RDMA_MSG_ENCODE_ERROR,
+               "encode error returned -1");
+        goto out;
+    }
+
+    gf_rdma_post_ref(post);
+
+    ret = gf_rdma_post_send(peer->qp, post, len);
+    if (!ret) {
+        ret = len;
+    } else {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED,
+               "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        gf_rdma_post_unref(post);
+        __gf_rdma_disconnect(peer->trans);
+        ret = -1;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_create_read_chunks_from_vector (gf_rdma_peer_t *peer,
-                                          gf_rdma_read_chunk_t **readch_ptr,
-                                          int32_t *pos, struct iovec *vector,
-                                          int count,
-                                          gf_rdma_request_context_t *request_ctx)
+__gf_rdma_create_read_chunks_from_vector(gf_rdma_peer_t *peer,
+                                         gf_rdma_read_chunk_t **readch_ptr,
+                                         int32_t *pos, struct iovec *vector,
+                                         int count,
+                                         gf_rdma_request_context_t *request_ctx)
 {
-        int                   i      = 0;
-        gf_rdma_private_t    *priv   = NULL;
-        gf_rdma_device_t     *device = NULL;
-        struct ibv_mr        *mr     = NULL;
-        gf_rdma_read_chunk_t *readch = NULL;
-        int32_t               ret    = -1;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, readch_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *readch_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
-
-        priv = peer->trans->private;
-        device = priv->device;
-        readch = *readch_ptr;
-
-        for (i = 0; i < count; i++) {
-                readch->rc_discrim = hton32 (1);
-                readch->rc_position = hton32 (*pos);
-
-                mr = gf_rdma_get_pre_registred_mr(peer->trans,
-                                (void *)vector[i].iov_base, vector[i].iov_len);
-                if (!mr) {
-                mr = ibv_reg_mr (device->pd, vector[i].iov_base,
-                                 vector[i].iov_len,
-                                 IBV_ACCESS_REMOTE_READ);
-                }
-                if (!mr) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED,
-                                "memory registration failed (peer:%s)",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
-
-                request_ctx->mr[request_ctx->mr_count++] = mr;
-
-                readch->rc_target.rs_handle = hton32 (mr->rkey);
-                readch->rc_target.rs_length
-                        = hton32 (vector[i].iov_len);
-                readch->rc_target.rs_offset
-                        = hton64 ((uint64_t)(unsigned long)vector[i].iov_base);
-
-                *pos = *pos + vector[i].iov_len;
-                readch++;
-        }
-
-        *readch_ptr = readch;
-
-        ret = 0;
+    int i = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    struct ibv_mr *mr = NULL;
+    gf_rdma_read_chunk_t *readch = NULL;
+    int32_t ret = -1;
+
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, readch_ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *readch_ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out);
+
+    priv = peer->trans->private;
+    device = priv->device;
+    readch = *readch_ptr;
+
+    for (i = 0; i < count; i++) {
+        readch->rc_discrim = hton32(1);
+        readch->rc_position = hton32(*pos);
+
+        mr = gf_rdma_get_pre_registred_mr(
+            peer->trans, (void *)vector[i].iov_base, vector[i].iov_len);
+        if (!mr) {
+            mr = ibv_reg_mr(device->pd, vector[i].iov_base, vector[i].iov_len,
+                            IBV_ACCESS_REMOTE_READ);
+        }
+        if (!mr) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+                   RDMA_MSG_MR_ALOC_FAILED,
+                   "memory registration failed (peer:%s)",
+                   peer->trans->peerinfo.identifier);
+            goto out;
+        }
+
+        request_ctx->mr[request_ctx->mr_count++] = mr;
+
+        readch->rc_target.rs_handle = hton32(mr->rkey);
+        readch->rc_target.rs_length = hton32(vector[i].iov_len);
+        readch->rc_target.rs_offset = hton64(
+            (uint64_t)(unsigned long)vector[i].iov_base);
+
+        *pos = *pos + vector[i].iov_len;
+        readch++;
+    }
+
+    *readch_ptr = readch;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_create_read_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                              gf_rdma_chunktype_t type, uint32_t **ptr,
-                              gf_rdma_request_context_t *request_ctx)
+__gf_rdma_create_read_chunks(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                             gf_rdma_chunktype_t type, uint32_t **ptr,
+                             gf_rdma_request_context_t *request_ctx)
 {
-        int32_t            ret      = -1;
-        int                pos      = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-
-        request_ctx->iobref = iobref_ref (entry->iobref);
-
-        if (type == gf_rdma_areadch) {
-                pos = 0;
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->rpchdr,
-                                                                entry->rpchdr_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->rpchdr");
-                        goto out;
-                }
+    int32_t ret = -1;
+    int pos = 0;
+
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out);
+
+    request_ctx->iobref = iobref_ref(entry->iobref);
+
+    if (type == gf_rdma_areadch) {
+        pos = 0;
+        ret = __gf_rdma_create_read_chunks_from_vector(
+            peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->rpchdr,
+            entry->rpchdr_count, request_ctx);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
+                   "cannot create read chunks from vector "
+                   "entry->rpchdr");
+            goto out;
+        }
 
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->proghdr,
-                                                                entry->proghdr_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->proghdr");
-                }
+        ret = __gf_rdma_create_read_chunks_from_vector(
+            peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->proghdr,
+            entry->proghdr_count, request_ctx);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
+                   "cannot create read chunks from vector "
+                   "entry->proghdr");
+        }
 
-                if (entry->prog_payload_count != 0) {
-                        ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                        (gf_rdma_read_chunk_t **)ptr,
-                                                                        &pos,
-                                                                        entry->prog_payload,
-                                                                        entry->prog_payload_count,
-                                                                        request_ctx);
-                        if (ret == -1) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                        "cannot create read chunks from vector"
-                                        " entry->prog_payload");
-                        }
-                }
-        } else {
-                pos = iov_length (entry->rpchdr, entry->rpchdr_count);
-                ret = __gf_rdma_create_read_chunks_from_vector (peer,
-                                                                (gf_rdma_read_chunk_t **)ptr,
-                                                                &pos,
-                                                                entry->prog_payload,
-                                                                entry->prog_payload_count,
-                                                                request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
-                                "cannot create read chunks from vector "
-                                "entry->prog_payload");
-                }
+        if (entry->prog_payload_count != 0) {
+            ret = __gf_rdma_create_read_chunks_from_vector(
+                peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->prog_payload,
+                entry->prog_payload_count, request_ctx);
+            if (ret == -1) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
+                       "cannot create read chunks from vector"
+                       " entry->prog_payload");
+            }
+        }
+    } else {
+        pos = iov_length(entry->rpchdr, entry->rpchdr_count);
+        ret = __gf_rdma_create_read_chunks_from_vector(
+            peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->prog_payload,
+            entry->prog_payload_count, request_ctx);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_READ_CHUNK_VECTOR_FAILED,
+                   "cannot create read chunks from vector "
+                   "entry->prog_payload");
         }
+    }
 
-        /* terminate read-chunk list*/
-        **ptr = 0;
-        *ptr = *ptr + 1;
+    /* terminate read-chunk list*/
+    **ptr = 0;
+    *ptr = *ptr + 1;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_create_write_chunks_from_vector (gf_rdma_peer_t *peer,
-                                           gf_rdma_write_chunk_t **writech_ptr,
-                                           struct iovec *vector, int count,
-                                           gf_rdma_request_context_t *request_ctx)
+__gf_rdma_create_write_chunks_from_vector(
+    gf_rdma_peer_t *peer, gf_rdma_write_chunk_t **writech_ptr,
+    struct iovec *vector, int count, gf_rdma_request_context_t *request_ctx)
 {
-        int                    i       = 0;
-        gf_rdma_private_t     *priv    = NULL;
-        gf_rdma_device_t      *device  = NULL;
-        struct ibv_mr         *mr      = NULL;
-        gf_rdma_write_chunk_t *writech = NULL;
-        int32_t                ret     = -1;
+    int i = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    struct ibv_mr *mr = NULL;
+    gf_rdma_write_chunk_t *writech = NULL;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, writech_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *writech_ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, writech_ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *writech_ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out);
 
-        writech = *writech_ptr;
+    writech = *writech_ptr;
 
-        priv = peer->trans->private;
-        device = priv->device;
-
-        for (i = 0; i < count; i++) {
+    priv = peer->trans->private;
+    device = priv->device;
 
-                mr = gf_rdma_get_pre_registred_mr(peer->trans,
-                                (void *)vector[i].iov_base, vector[i].iov_len);
-                if (!mr) {
-                mr = ibv_reg_mr (device->pd, vector[i].iov_base,
-                                 vector[i].iov_len,
-                                 IBV_ACCESS_REMOTE_WRITE
-                                 | IBV_ACCESS_LOCAL_WRITE);
-                }
+    for (i = 0; i < count; i++) {
+        mr = gf_rdma_get_pre_registred_mr(
+            peer->trans, (void *)vector[i].iov_base, vector[i].iov_len);
+        if (!mr) {
+            mr = ibv_reg_mr(device->pd, vector[i].iov_base, vector[i].iov_len,
+                            IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_LOCAL_WRITE);
+        }
 
-                if (!mr) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED, "memory "
-                                "registration failed (peer:%s)",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
+        if (!mr) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+                   RDMA_MSG_MR_ALOC_FAILED,
+                   "memory "
+                   "registration failed (peer:%s)",
+                   peer->trans->peerinfo.identifier);
+            goto out;
+        }
 
-                request_ctx->mr[request_ctx->mr_count++] = mr;
+        request_ctx->mr[request_ctx->mr_count++] = mr;
 
-                writech->wc_target.rs_handle = hton32 (mr->rkey);
-                writech->wc_target.rs_length = hton32 (vector[i].iov_len);
-                writech->wc_target.rs_offset
-                        = hton64 (((uint64_t)(unsigned long)vector[i].iov_base));
+        writech->wc_target.rs_handle = hton32(mr->rkey);
+        writech->wc_target.rs_length = hton32(vector[i].iov_len);
+        writech->wc_target.rs_offset = hton64(
+            ((uint64_t)(unsigned long)vector[i].iov_base));
 
-                writech++;
-        }
+        writech++;
+    }
 
-        *writech_ptr = writech;
+    *writech_ptr = writech;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_create_write_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                               gf_rdma_chunktype_t chunk_type, uint32_t **ptr,
-                               gf_rdma_request_context_t *request_ctx)
+__gf_rdma_create_write_chunks(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                              gf_rdma_chunktype_t chunk_type, uint32_t **ptr,
+                              gf_rdma_request_context_t *request_ctx)
 {
-        int32_t                ret    = -1;
-        gf_rdma_write_array_t *warray = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-
-        if ((chunk_type == gf_rdma_replych)
-            && ((entry->msg.request.rsphdr_count != 1) ||
-                (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_BUFFER_ERROR,
-                        (entry->msg.request.rsphdr_count == 1)
-                        ? "chunktype specified as reply chunk but the vector "
-                        "specifying the buffer to be used for holding reply"
-                        " header is not correct" :
-                        "chunktype specified as reply chunk, but more than one "
-                        "buffer provided for holding reply");
-                goto out;
+    int32_t ret = -1;
+    gf_rdma_write_array_t *warray = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *ptr, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out);
+
+    if ((chunk_type == gf_rdma_replych) &&
+        ((entry->msg.request.rsphdr_count != 1) ||
+         (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_BUFFER_ERROR,
+               (entry->msg.request.rsphdr_count == 1)
+                   ? "chunktype specified as reply chunk but the vector "
+                     "specifying the buffer to be used for holding reply"
+                     " header is not correct"
+                   : "chunktype specified as reply chunk, but more than one "
+                     "buffer provided for holding reply");
+        goto out;
+    }
+
+    /*
+      if ((chunk_type == gf_rdma_writech)
+      && ((entry->msg.request.rsphdr_count == 0)
+      || (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
+      gf_msg_debug (GF_RDMA_LOG_NAME, 0,
+      "vector specifying buffer to hold the program's reply "
+      "header should also be provided when buffers are "
+      "provided for holding the program's payload in reply");
+      goto out;
+      }
+    */
+
+    if (chunk_type == gf_rdma_writech) {
+        warray = (gf_rdma_write_array_t *)*ptr;
+        warray->wc_discrim = hton32(1);
+        warray->wc_nchunks = hton32(entry->msg.request.rsp_payload_count);
+
+        *ptr = (uint32_t *)&warray->wc_array[0];
+
+        ret = __gf_rdma_create_write_chunks_from_vector(
+            peer, (gf_rdma_write_chunk_t **)ptr, entry->msg.request.rsp_payload,
+            entry->msg.request.rsp_payload_count, request_ctx);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
+                   "cannot create write chunks from vector "
+                   "entry->rpc_payload");
+            goto out;
         }
 
-/*
-  if ((chunk_type == gf_rdma_writech)
-  && ((entry->msg.request.rsphdr_count == 0)
-  || (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) {
-  gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-  "vector specifying buffer to hold the program's reply "
-  "header should also be provided when buffers are "
-  "provided for holding the program's payload in reply");
-  goto out;
-  }
-*/
-
-        if (chunk_type == gf_rdma_writech) {
-                warray = (gf_rdma_write_array_t *)*ptr;
-                warray->wc_discrim = hton32 (1);
-                warray->wc_nchunks
-                        = hton32 (entry->msg.request.rsp_payload_count);
-
-                *ptr = (uint32_t *)&warray->wc_array[0];
-
-                ret = __gf_rdma_create_write_chunks_from_vector (peer,
-                                                                 (gf_rdma_write_chunk_t **)ptr,
-                                                                 entry->msg.request.rsp_payload,
-                                                                 entry->msg.request.rsp_payload_count,
-                                                                 request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
-                                "cannot create write chunks from vector "
-                                "entry->rpc_payload");
-                        goto out;
-                }
-
-                /* terminate write chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-
-                /* no reply chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
-        } else {
-                /* no write chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
+        /* terminate write chunklist */
+        **ptr = 0;
+        *ptr = *ptr + 1;
 
-                warray = (gf_rdma_write_array_t *)*ptr;
-                warray->wc_discrim = hton32 (1);
-                warray->wc_nchunks = hton32 (entry->msg.request.rsphdr_count);
+        /* no reply chunklist */
+        **ptr = 0;
+        *ptr = *ptr + 1;
+    } else {
+        /* no write chunklist */
+        **ptr = 0;
+        *ptr = *ptr + 1;
 
-                *ptr = (uint32_t *)&warray->wc_array[0];
+        warray = (gf_rdma_write_array_t *)*ptr;
+        warray->wc_discrim = hton32(1);
+        warray->wc_nchunks = hton32(entry->msg.request.rsphdr_count);
 
-                ret = __gf_rdma_create_write_chunks_from_vector (peer,
-                                                                 (gf_rdma_write_chunk_t **)ptr,
-                                                                 entry->msg.request.rsphdr_vec,
-                                                                 entry->msg.request.rsphdr_count,
-                                                                 request_ctx);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
-                                "cannot create write chunks from vector "
-                                "entry->rpchdr");
-                        goto out;
-                }
+        *ptr = (uint32_t *)&warray->wc_array[0];
 
-                /* terminate reply chunklist */
-                **ptr = 0;
-                *ptr = *ptr + 1;
+        ret = __gf_rdma_create_write_chunks_from_vector(
+            peer, (gf_rdma_write_chunk_t **)ptr, entry->msg.request.rsphdr_vec,
+            entry->msg.request.rsphdr_count, request_ctx);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED,
+                   "cannot create write chunks from vector "
+                   "entry->rpchdr");
+            goto out;
         }
 
+        /* terminate reply chunklist */
+        **ptr = 0;
+        *ptr = *ptr + 1;
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
-
 static void
-__gf_rdma_deregister_mr (gf_rdma_device_t *device,
-                         struct ibv_mr **mr, int count)
+__gf_rdma_deregister_mr(gf_rdma_device_t *device, struct ibv_mr **mr, int count)
 {
-        gf_rdma_arena_mr    *tmp   = NULL;
-        gf_rdma_arena_mr    *dummy = NULL;
-        int                  i     = 0;
-        int                  found = 0;
-
-               if (mr == NULL) {
-                goto out;
-        }
-
-        for (i = 0; i < count; i++) {
-                 found = 0;
-                 pthread_mutex_lock (&device->all_mr_lock);
-                 {
-                         if (!list_empty(&device->all_mr)) {
-                                list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) {
-                                        if (tmp->mr == mr[i]) {
-                                                found = 1;
-                                                break;
-                                        }
-                                }
-                         }
+    gf_rdma_arena_mr *tmp = NULL;
+    gf_rdma_arena_mr *dummy = NULL;
+    int i = 0;
+    int found = 0;
+
+    if (mr == NULL) {
+        goto out;
+    }
+
+    for (i = 0; i < count; i++) {
+        found = 0;
+        pthread_mutex_lock(&device->all_mr_lock);
+        {
+            if (!list_empty(&device->all_mr)) {
+                list_for_each_entry_safe(tmp, dummy, &device->all_mr, list)
+                {
+                    if (tmp->mr == mr[i]) {
+                        found = 1;
+                        break;
+                    }
                 }
-                pthread_mutex_unlock (&device->all_mr_lock);
-                if (!found)
-                        ibv_dereg_mr (mr[i]);
-
+            }
         }
+        pthread_mutex_unlock(&device->all_mr_lock);
+        if (!found)
+            ibv_dereg_mr(mr[i]);
+    }
 
 out:
-        return;
+    return;
 }
 
-
 static int32_t
-__gf_rdma_quota_put (gf_rdma_peer_t *peer)
+__gf_rdma_quota_put(gf_rdma_peer_t *peer)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        peer->quota++;
-        ret = peer->quota;
+    peer->quota++;
+    ret = peer->quota;
 
-        if (!list_empty (&peer->ioq)) {
-                ret = __gf_rdma_ioq_churn (peer);
-        }
+    if (!list_empty(&peer->ioq)) {
+        ret = __gf_rdma_ioq_churn(peer);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_quota_put (gf_rdma_peer_t *peer)
+gf_rdma_quota_put(gf_rdma_peer_t *peer)
 {
-        int32_t            ret  = 0;
-        gf_rdma_private_t *priv = NULL;
+    int32_t ret = 0;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = peer->trans->private;
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_quota_put (peer);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
+    priv = peer->trans->private;
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        ret = __gf_rdma_quota_put(peer);
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
 
-        return ret;
+    return ret;
 }
 
-
 /* to be called with priv->mutex held */
 void
-__gf_rdma_request_context_destroy (gf_rdma_request_context_t *context)
+__gf_rdma_request_context_destroy(gf_rdma_request_context_t *context)
 {
-        gf_rdma_peer_t    *peer   = NULL;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-        int32_t            ret    = 0;
+    gf_rdma_peer_t *peer = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    int32_t ret = 0;
 
-        if (context == NULL) {
-                goto out;
-        }
-
-        peer = context->peer;
+    if (context == NULL) {
+        goto out;
+    }
 
-        priv = peer->trans->private;
-        device = priv->device;
-        __gf_rdma_deregister_mr (device, context->mr, context->mr_count);
+    peer = context->peer;
 
+    priv = peer->trans->private;
+    device = priv->device;
+    __gf_rdma_deregister_mr(device, context->mr, context->mr_count);
 
-        if (priv->connected) {
-                ret = __gf_rdma_quota_put (peer);
-                if (ret < 0) {
-                        gf_msg_debug ("rdma", 0, "failed to send message");
-                        mem_put (context);
-                        __gf_rdma_disconnect (peer->trans);
-                        goto out;
-                }
+    if (priv->connected) {
+        ret = __gf_rdma_quota_put(peer);
+        if (ret < 0) {
+            gf_msg_debug("rdma", 0, "failed to send message");
+            mem_put(context);
+            __gf_rdma_disconnect(peer->trans);
+            goto out;
         }
+    }
 
-        if (context->iobref != NULL) {
-                iobref_unref (context->iobref);
-                context->iobref = NULL;
-        }
+    if (context->iobref != NULL) {
+        iobref_unref(context->iobref);
+        context->iobref = NULL;
+    }
 
-        if (context->rsp_iobref != NULL) {
-                iobref_unref (context->rsp_iobref);
-                context->rsp_iobref = NULL;
-        }
+    if (context->rsp_iobref != NULL) {
+        iobref_unref(context->rsp_iobref);
+        context->rsp_iobref = NULL;
+    }
 
-        mem_put (context);
+    mem_put(context);
 
 out:
-        return;
+    return;
 }
 
-
 void
-gf_rdma_post_context_destroy (gf_rdma_device_t *device,
-                              gf_rdma_post_context_t *ctx)
+gf_rdma_post_context_destroy(gf_rdma_device_t *device,
+                             gf_rdma_post_context_t *ctx)
 {
-        if (ctx == NULL) {
-                goto out;
-        }
+    if (ctx == NULL) {
+        goto out;
+    }
 
-        __gf_rdma_deregister_mr (device, ctx->mr, ctx->mr_count);
+    __gf_rdma_deregister_mr(device, ctx->mr, ctx->mr_count);
 
-        if (ctx->iobref != NULL) {
-                iobref_unref (ctx->iobref);
-        }
+    if (ctx->iobref != NULL) {
+        iobref_unref(ctx->iobref);
+    }
 
-        if (ctx->hdr_iobuf != NULL) {
-                iobuf_unref (ctx->hdr_iobuf);
-        }
+    if (ctx->hdr_iobuf != NULL) {
+        iobuf_unref(ctx->hdr_iobuf);
+    }
 
-        memset (ctx, 0, sizeof (*ctx));
+    memset(ctx, 0, sizeof(*ctx));
 out:
-        return;
+    return;
 }
 
-
 int
-gf_rdma_post_unref (gf_rdma_post_t *post)
+gf_rdma_post_unref(gf_rdma_post_t *post)
 {
-        int refcount = -1;
-
-        if (post == NULL) {
-                goto out;
-        }
-
-        pthread_mutex_lock (&post->lock);
-        {
-                refcount = --post->refcount;
-        }
-        pthread_mutex_unlock (&post->lock);
-
-        if (refcount == 0) {
-                gf_rdma_post_context_destroy (post->device, &post->ctx);
-                if (post->type == GF_RDMA_SEND_POST) {
-                        gf_rdma_put_post (&post->device->sendq, post);
-                } else {
-                        gf_rdma_post_recv (post->device->srq, post);
-                }
+    int refcount = -1;
+
+    if (post == NULL) {
+        goto out;
+    }
+
+    pthread_mutex_lock(&post->lock);
+    {
+        refcount = --post->refcount;
+    }
+    pthread_mutex_unlock(&post->lock);
+
+    if (refcount == 0) {
+        gf_rdma_post_context_destroy(post->device, &post->ctx);
+        if (post->type == GF_RDMA_SEND_POST) {
+            gf_rdma_put_post(&post->device->sendq, post);
+        } else {
+            gf_rdma_post_recv(post->device->srq, post);
         }
+    }
 out:
-        return refcount;
+    return refcount;
 }
 
-
 int
-gf_rdma_post_get_refcount (gf_rdma_post_t *post)
+gf_rdma_post_get_refcount(gf_rdma_post_t *post)
 {
-        int refcount = -1;
+    int refcount = -1;
 
-        if (post == NULL) {
-                goto out;
-        }
+    if (post == NULL) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&post->lock);
-        {
-                refcount = post->refcount;
-        }
-        pthread_mutex_unlock (&post->lock);
+    pthread_mutex_lock(&post->lock);
+    {
+        refcount = post->refcount;
+    }
+    pthread_mutex_unlock(&post->lock);
 
 out:
-        return refcount;
+    return refcount;
 }
 
 gf_rdma_post_t *
-gf_rdma_post_ref (gf_rdma_post_t *post)
+gf_rdma_post_ref(gf_rdma_post_t *post)
 {
-        if (post == NULL) {
-                goto out;
-        }
+    if (post == NULL) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&post->lock);
-        {
-                post->refcount++;
-        }
-        pthread_mutex_unlock (&post->lock);
+    pthread_mutex_lock(&post->lock);
+    {
+        post->refcount++;
+    }
+    pthread_mutex_unlock(&post->lock);
 
 out:
-        return post;
+    return post;
 }
 
-
 int32_t
-__gf_rdma_ioq_churn_request (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                             gf_rdma_post_t *post)
+__gf_rdma_ioq_churn_request(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                            gf_rdma_post_t *post)
 {
-        gf_rdma_chunktype_t        rtype               = gf_rdma_noch;
-        gf_rdma_chunktype_t        wtype               = gf_rdma_noch;
-        uint64_t                   send_size           = 0;
-        gf_rdma_header_t          *hdr                 = NULL;
-        struct rpc_msg            *rpc_msg             = NULL;
-        uint32_t                  *chunkptr            = NULL;
-        char                      *buf                 = NULL;
-        int32_t                    ret                 = 0;
-        gf_rdma_private_t         *priv                = NULL;
-        gf_rdma_device_t          *device              = NULL;
-        int                        chunk_count         = 0;
-        gf_rdma_request_context_t *request_ctx         = NULL;
-        uint32_t                   prog_payload_length = 0, len = 0;
-        struct rpc_req            *rpc_req             = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out);
-
-        if ((entry->msg.request.rsphdr_count != 0)
-            && (entry->msg.request.rsp_payload_count != 0)) {
-                ret = -1;
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT,
-                        "both write-chunklist and reply-chunk cannot be "
-                        "present");
-                goto out;
-        }
-
-        post->ctx.is_request = 1;
-        priv = peer->trans->private;
-        device = priv->device;
-
-        hdr = (gf_rdma_header_t *)post->buf;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + GLUSTERFS_RDMA_MAX_HEADER_SIZE;
-
-        if (entry->prog_payload_count != 0) {
-                prog_payload_length
-                        = iov_length (entry->prog_payload,
-                                      entry->prog_payload_count);
-        }
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                rtype = gf_rdma_areadch;
-        } else if ((send_size + prog_payload_length)
-                   < GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                rtype = gf_rdma_noch;
-        } else if (entry->prog_payload_count != 0) {
-                rtype = gf_rdma_readch;
-        }
-
-        if (entry->msg.request.rsphdr_count != 0) {
-                wtype = gf_rdma_replych;
-        } else if (entry->msg.request.rsp_payload_count != 0) {
-                wtype = gf_rdma_writech;
-        }
-
-        if (rtype == gf_rdma_readch) {
-                chunk_count += entry->prog_payload_count;
-        } else if (rtype == gf_rdma_areadch) {
-                chunk_count += entry->rpchdr_count;
-                chunk_count += entry->proghdr_count;
-        }
-
-        if (wtype == gf_rdma_writech) {
-                chunk_count += entry->msg.request.rsp_payload_count;
-        } else if (wtype == gf_rdma_replych) {
-                chunk_count += entry->msg.request.rsphdr_count;
-        }
-
-        if (chunk_count > GF_RDMA_MAX_SEGMENTS) {
-                ret = -1;
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS,
-                        "chunk count(%d) exceeding maximum allowed RDMA "
-                        "segment count(%d)", chunk_count, GF_RDMA_MAX_SEGMENTS);
-                goto out;
-        }
-
-        if ((wtype != gf_rdma_noch) || (rtype != gf_rdma_noch)) {
-                request_ctx = mem_get (device->request_ctx_pool);
-                if (request_ctx == NULL) {
-                        ret = -1;
-                        goto out;
-                }
-
-                memset (request_ctx, 0, sizeof (*request_ctx));
-
-                request_ctx->pool = device->request_ctx_pool;
-                request_ctx->peer = peer;
-
-                entry->msg.request.rpc_req->conn_private = request_ctx;
-
-                if (entry->msg.request.rsp_iobref != NULL) {
-                        request_ctx->rsp_iobref
-                                = iobref_ref (entry->msg.request.rsp_iobref);
-                }
-        }
-
-        rpc_msg = (struct rpc_msg *) entry->rpchdr[0].iov_base;
-
-        hdr->rm_xid    = rpc_msg->rm_xid; /* no need of hton32(rpc_msg->rm_xid),
-                                           * since rpc_msg->rm_xid is already
-                                           * hton32ed value of actual xid
-                                           */
-        hdr->rm_vers   = hton32 (GF_RDMA_VERSION);
-        hdr->rm_credit = hton32 (peer->send_count);
-        if (rtype == gf_rdma_areadch) {
-                hdr->rm_type = hton32 (GF_RDMA_NOMSG);
-        } else {
-                hdr->rm_type   = hton32 (GF_RDMA_MSG);
-        }
-
-        chunkptr = &hdr->rm_body.rm_chunks[0];
-        if (rtype != gf_rdma_noch) {
-                ret = __gf_rdma_create_read_chunks (peer, entry, rtype,
-                                                    &chunkptr,
-                                                    request_ctx);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CREATE_READ_CHUNK_FAILED,
-                                "creation of read chunks failed");
-                        goto out;
-                }
-        } else {
-                *chunkptr++ = 0; /* no read chunks */
-        }
-
-        if (wtype != gf_rdma_noch) {
-                ret = __gf_rdma_create_write_chunks (peer, entry, wtype,
-                                                     &chunkptr,
-                                                     request_ctx);
-                if (ret != 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CREATE_WRITE_REPLAY_FAILED,
-                                "creation of write/reply chunk failed");
-                        goto out;
-                }
-        } else {
-                *chunkptr++ = 0; /* no write chunks */
-                *chunkptr++ = 0; /* no reply chunk */
+    gf_rdma_chunktype_t rtype = gf_rdma_noch;
+    gf_rdma_chunktype_t wtype = gf_rdma_noch;
+    uint64_t send_size = 0;
+    gf_rdma_header_t *hdr = NULL;
+    struct rpc_msg *rpc_msg = NULL;
+    uint32_t *chunkptr = NULL;
+    char *buf = NULL;
+    int32_t ret = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    int chunk_count = 0;
+    gf_rdma_request_context_t *request_ctx = NULL;
+    uint32_t prog_payload_length = 0, len = 0;
+    struct rpc_req *rpc_req = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, post, out);
+
+    if ((entry->msg.request.rsphdr_count != 0) &&
+        (entry->msg.request.rsp_payload_count != 0)) {
+        ret = -1;
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT,
+               "both write-chunklist and reply-chunk cannot be "
+               "present");
+        goto out;
+    }
+
+    post->ctx.is_request = 1;
+    priv = peer->trans->private;
+    device = priv->device;
+
+    hdr = (gf_rdma_header_t *)post->buf;
+
+    send_size = iov_length(entry->rpchdr, entry->rpchdr_count) +
+                iov_length(entry->proghdr, entry->proghdr_count) +
+                GLUSTERFS_RDMA_MAX_HEADER_SIZE;
+
+    if (entry->prog_payload_count != 0) {
+        prog_payload_length = iov_length(entry->prog_payload,
+                                         entry->prog_payload_count);
+    }
+
+    if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
+        rtype = gf_rdma_areadch;
+    } else if ((send_size + prog_payload_length) <
+               GLUSTERFS_RDMA_INLINE_THRESHOLD) {
+        rtype = gf_rdma_noch;
+    } else if (entry->prog_payload_count != 0) {
+        rtype = gf_rdma_readch;
+    }
+
+    if (entry->msg.request.rsphdr_count != 0) {
+        wtype = gf_rdma_replych;
+    } else if (entry->msg.request.rsp_payload_count != 0) {
+        wtype = gf_rdma_writech;
+    }
+
+    if (rtype == gf_rdma_readch) {
+        chunk_count += entry->prog_payload_count;
+    } else if (rtype == gf_rdma_areadch) {
+        chunk_count += entry->rpchdr_count;
+        chunk_count += entry->proghdr_count;
+    }
+
+    if (wtype == gf_rdma_writech) {
+        chunk_count += entry->msg.request.rsp_payload_count;
+    } else if (wtype == gf_rdma_replych) {
+        chunk_count += entry->msg.request.rsphdr_count;
+    }
+
+    if (chunk_count > GF_RDMA_MAX_SEGMENTS) {
+        ret = -1;
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS,
+               "chunk count(%d) exceeding maximum allowed RDMA "
+               "segment count(%d)",
+               chunk_count, GF_RDMA_MAX_SEGMENTS);
+        goto out;
+    }
+
+    if ((wtype != gf_rdma_noch) || (rtype != gf_rdma_noch)) {
+        request_ctx = mem_get(device->request_ctx_pool);
+        if (request_ctx == NULL) {
+            ret = -1;
+            goto out;
+        }
+
+        memset(request_ctx, 0, sizeof(*request_ctx));
+
+        request_ctx->pool = device->request_ctx_pool;
+        request_ctx->peer = peer;
+
+        entry->msg.request.rpc_req->conn_private = request_ctx;
+
+        if (entry->msg.request.rsp_iobref != NULL) {
+            request_ctx->rsp_iobref = iobref_ref(entry->msg.request.rsp_iobref);
+        }
+    }
+
+    rpc_msg = (struct rpc_msg *)entry->rpchdr[0].iov_base;
+
+    hdr->rm_xid = rpc_msg->rm_xid; /* no need of hton32(rpc_msg->rm_xid),
+                                    * since rpc_msg->rm_xid is already
+                                    * hton32ed value of actual xid
+                                    */
+    hdr->rm_vers = hton32(GF_RDMA_VERSION);
+    hdr->rm_credit = hton32(peer->send_count);
+    if (rtype == gf_rdma_areadch) {
+        hdr->rm_type = hton32(GF_RDMA_NOMSG);
+    } else {
+        hdr->rm_type = hton32(GF_RDMA_MSG);
+    }
+
+    chunkptr = &hdr->rm_body.rm_chunks[0];
+    if (rtype != gf_rdma_noch) {
+        ret = __gf_rdma_create_read_chunks(peer, entry, rtype, &chunkptr,
+                                           request_ctx);
+        if (ret != 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_CREATE_READ_CHUNK_FAILED,
+                   "creation of read chunks failed");
+            goto out;
+        }
+    } else {
+        *chunkptr++ = 0; /* no read chunks */
+    }
+
+    if (wtype != gf_rdma_noch) {
+        ret = __gf_rdma_create_write_chunks(peer, entry, wtype, &chunkptr,
+                                            request_ctx);
+        if (ret != 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_CREATE_WRITE_REPLAY_FAILED,
+                   "creation of write/reply chunk failed");
+            goto out;
         }
+    } else {
+        *chunkptr++ = 0; /* no write chunks */
+        *chunkptr++ = 0; /* no reply chunk */
+    }
 
-        buf = (char *)chunkptr;
+    buf = (char *)chunkptr;
 
-        if (rtype != gf_rdma_areadch) {
-                iov_unload (buf, entry->rpchdr, entry->rpchdr_count);
-                buf += iov_length (entry->rpchdr, entry->rpchdr_count);
+    if (rtype != gf_rdma_areadch) {
+        iov_unload(buf, entry->rpchdr, entry->rpchdr_count);
+        buf += iov_length(entry->rpchdr, entry->rpchdr_count);
 
-                iov_unload (buf, entry->proghdr, entry->proghdr_count);
-                buf += iov_length (entry->proghdr, entry->proghdr_count);
+        iov_unload(buf, entry->proghdr, entry->proghdr_count);
+        buf += iov_length(entry->proghdr, entry->proghdr_count);
 
-                if (rtype != gf_rdma_readch) {
-                        iov_unload (buf, entry->prog_payload,
-                                    entry->prog_payload_count);
-                        buf += iov_length (entry->prog_payload,
-                                           entry->prog_payload_count);
-                }
+        if (rtype != gf_rdma_readch) {
+            iov_unload(buf, entry->prog_payload, entry->prog_payload_count);
+            buf += iov_length(entry->prog_payload, entry->prog_payload_count);
         }
+    }
 
-        len = buf - post->buf;
+    len = buf - post->buf;
 
-        gf_rdma_post_ref (post);
+    gf_rdma_post_ref(post);
 
-        ret = gf_rdma_post_send (peer->qp, post, len);
-        if (!ret) {
-                ret = len;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED,
-                        "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
+    ret = gf_rdma_post_send(peer->qp, post, len);
+    if (!ret) {
+        ret = len;
+    } else {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED,
+               "gf_rdma_post_send (to %s) failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        gf_rdma_post_unref(post);
+        __gf_rdma_disconnect(peer->trans);
+        ret = -1;
+    }
 
 out:
-        if (ret == -1) {
-                rpc_req = entry->msg.request.rpc_req;
-
-                if (request_ctx != NULL) {
-                        __gf_rdma_request_context_destroy (rpc_req->conn_private);
-                }
+    if (ret == -1) {
+        rpc_req = entry->msg.request.rpc_req;
 
-                rpc_req->conn_private = NULL;
+        if (request_ctx != NULL) {
+            __gf_rdma_request_context_destroy(rpc_req->conn_private);
         }
 
-        return ret;
-}
+        rpc_req->conn_private = NULL;
+    }
 
+    return ret;
+}
 
 static void
-__gf_rdma_fill_reply_header (gf_rdma_header_t *header, struct iovec *rpchdr,
-                             gf_rdma_reply_info_t *reply_info, int credits)
+__gf_rdma_fill_reply_header(gf_rdma_header_t *header, struct iovec *rpchdr,
+                            gf_rdma_reply_info_t *reply_info, int credits)
 {
-        struct rpc_msg *rpc_msg = NULL;
-
-        if (reply_info != NULL) {
-                header->rm_xid = hton32 (reply_info->rm_xid);
-        } else {
-                rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
-                                               * only one vector.
-                                               * (which is true)
-                                               */
-                header->rm_xid = rpc_msg->rm_xid;
-        }
-
-        header->rm_type = hton32 (GF_RDMA_MSG);
-        header->rm_vers = hton32 (GF_RDMA_VERSION);
-        header->rm_credit = hton32 (credits);
-
-        header->rm_body.rm_chunks[0] = 0; /* no read chunks */
-        header->rm_body.rm_chunks[1] = 0; /* no write chunks */
-        header->rm_body.rm_chunks[2] = 0; /* no reply chunks */
-
-        return;
+    struct rpc_msg *rpc_msg = NULL;
+
+    if (reply_info != NULL) {
+        header->rm_xid = hton32(reply_info->rm_xid);
+    } else {
+        rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains
+                                       * only one vector.
+                                       * (which is true)
+                                       */
+        header->rm_xid = rpc_msg->rm_xid;
+    }
+
+    header->rm_type = hton32(GF_RDMA_MSG);
+    header->rm_vers = hton32(GF_RDMA_VERSION);
+    header->rm_credit = hton32(credits);
+
+    header->rm_body.rm_chunks[0] = 0; /* no read chunks */
+    header->rm_body.rm_chunks[1] = 0; /* no write chunks */
+    header->rm_body.rm_chunks[2] = 0; /* no reply chunks */
+
+    return;
 }
 
-
 int32_t
-__gf_rdma_send_reply_inline (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                             gf_rdma_post_t *post,
-                             gf_rdma_reply_info_t *reply_info)
+__gf_rdma_send_reply_inline(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                            gf_rdma_post_t *post,
+                            gf_rdma_reply_info_t *reply_info)
 {
-        gf_rdma_header_t *header    = NULL;
-        int32_t           send_size = 0, ret = 0;
-        char             *buf       = NULL;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + iov_length (entry->prog_payload, entry->prog_payload_count)
-                + sizeof (gf_rdma_header_t); /*
-                                              * remember, no chunklists in the
-                                              * reply
-                                              */
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
-                        "msg size (%d) is greater than maximum size "
-                        "of msg that can be sent inlined (%d)",
-                        send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD);
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        buf = (char *)&header->rm_body.rm_chunks[3];
-
-        if (entry->rpchdr_count != 0) {
-                iov_unload (buf, entry->rpchdr, entry->rpchdr_count);
-                buf += iov_length (entry->rpchdr, entry->rpchdr_count);
-        }
-
-        if (entry->proghdr_count != 0) {
-                iov_unload (buf, entry->proghdr, entry->proghdr_count);
-                buf += iov_length (entry->proghdr, entry->proghdr_count);
-        }
-
-        if (entry->prog_payload_count != 0) {
-                iov_unload (buf, entry->prog_payload,
-                            entry->prog_payload_count);
-                buf += iov_length (entry->prog_payload,
-                                   entry->prog_payload_count);
-        }
-
-        gf_rdma_post_ref (post);
+    gf_rdma_header_t *header = NULL;
+    int32_t send_size = 0, ret = 0;
+    char *buf = NULL;
+
+    send_size = iov_length(entry->rpchdr, entry->rpchdr_count) +
+                iov_length(entry->proghdr, entry->proghdr_count) +
+                iov_length(entry->prog_payload, entry->prog_payload_count) +
+                sizeof(gf_rdma_header_t); /*
+                                           * remember, no chunklists in the
+                                           * reply
+                                           */
 
-        ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf));
-        if (!ret) {
-                ret = send_size;
-        } else {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED, "posting send (to %s) "
-                        "failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                __gf_rdma_disconnect (peer->trans);
-                ret = -1;
-        }
+    if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
+        ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK);
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
+               "msg size (%d) is greater than maximum size "
+               "of msg that can be sent inlined (%d)",
+               send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD);
+        goto out;
+    }
+
+    header = (gf_rdma_header_t *)post->buf;
+
+    __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info,
+                                peer->send_count);
+
+    buf = (char *)&header->rm_body.rm_chunks[3];
+
+    if (entry->rpchdr_count != 0) {
+        iov_unload(buf, entry->rpchdr, entry->rpchdr_count);
+        buf += iov_length(entry->rpchdr, entry->rpchdr_count);
+    }
+
+    if (entry->proghdr_count != 0) {
+        iov_unload(buf, entry->proghdr, entry->proghdr_count);
+        buf += iov_length(entry->proghdr, entry->proghdr_count);
+    }
+
+    if (entry->prog_payload_count != 0) {
+        iov_unload(buf, entry->prog_payload, entry->prog_payload_count);
+        buf += iov_length(entry->prog_payload, entry->prog_payload_count);
+    }
+
+    gf_rdma_post_ref(post);
+
+    ret = gf_rdma_post_send(peer->qp, post, (buf - post->buf));
+    if (!ret) {
+        ret = send_size;
+    } else {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED,
+               "posting send (to %s) "
+               "failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        gf_rdma_post_unref(post);
+        __gf_rdma_disconnect(peer->trans);
+        ret = -1;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_reply_encode_write_chunks (gf_rdma_peer_t *peer,
-                                     uint32_t payload_size,
-                                     gf_rdma_post_t *post,
-                                     gf_rdma_reply_info_t *reply_info,
-                                     uint32_t **ptr)
+__gf_rdma_reply_encode_write_chunks(gf_rdma_peer_t *peer, uint32_t payload_size,
+                                    gf_rdma_post_t *post,
+                                    gf_rdma_reply_info_t *reply_info,
+                                    uint32_t **ptr)
 {
-        uint32_t               chunk_size   = 0;
-        int32_t                ret          = -1;
-        gf_rdma_write_array_t *target_array = NULL;
-        int                    i            = 0;
-
-        target_array = (gf_rdma_write_array_t *)*ptr;
-
-        for (i = 0; i < reply_info->wc_array->wc_nchunks; i++) {
-                chunk_size +=
-                        reply_info->wc_array->wc_array[i].wc_target.rs_length;
-        }
-
-        if (chunk_size < payload_size) {
-                gf_msg_debug (GF_RDMA_LOG_NAME, 0, "length of payload (%d) is "
-                              "exceeding the total write chunk length (%d)",
-                              payload_size, chunk_size);
-                goto out;
-        }
-
-        target_array->wc_discrim = hton32 (1);
-        for (i = 0; (i < reply_info->wc_array->wc_nchunks)
-                     && (payload_size != 0);
-             i++) {
-                target_array->wc_array[i].wc_target.rs_offset
-                        = hton64 (reply_info->wc_array->wc_array[i].wc_target.rs_offset);
-
-                target_array->wc_array[i].wc_target.rs_length
-                        = hton32 (min (payload_size,
-                                       reply_info->wc_array->wc_array[i].wc_target.rs_length));
-        }
-
-        target_array->wc_nchunks = hton32 (i);
-        target_array->wc_array[i].wc_target.rs_handle = 0; /* terminate
-                                                              chunklist */
-
-        ret = 0;
-
-        *ptr = &target_array->wc_array[i].wc_target.rs_length;
+    uint32_t chunk_size = 0;
+    int32_t ret = -1;
+    gf_rdma_write_array_t *target_array = NULL;
+    int i = 0;
+
+    target_array = (gf_rdma_write_array_t *)*ptr;
+
+    for (i = 0; i < reply_info->wc_array->wc_nchunks; i++) {
+        chunk_size += reply_info->wc_array->wc_array[i].wc_target.rs_length;
+    }
+
+    if (chunk_size < payload_size) {
+        gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                     "length of payload (%d) is "
+                     "exceeding the total write chunk length (%d)",
+                     payload_size, chunk_size);
+        goto out;
+    }
+
+    target_array->wc_discrim = hton32(1);
+    for (i = 0; (i < reply_info->wc_array->wc_nchunks) && (payload_size != 0);
+         i++) {
+        target_array->wc_array[i].wc_target.rs_offset = hton64(
+            reply_info->wc_array->wc_array[i].wc_target.rs_offset);
+
+        target_array->wc_array[i].wc_target.rs_length = hton32(
+            min(payload_size,
+                reply_info->wc_array->wc_array[i].wc_target.rs_length));
+    }
+
+    target_array->wc_nchunks = hton32(i);
+    target_array->wc_array[i].wc_target.rs_handle = 0; /* terminate
+                                                          chunklist */
+
+    ret = 0;
+
+    *ptr = &target_array->wc_array[i].wc_target.rs_length;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-__gf_rdma_register_local_mr_for_rdma (gf_rdma_peer_t *peer,
-                                      struct iovec *vector, int count,
-                                      gf_rdma_post_context_t *ctx)
+__gf_rdma_register_local_mr_for_rdma(gf_rdma_peer_t *peer, struct iovec *vector,
+                                     int count, gf_rdma_post_context_t *ctx)
 {
-        int                i      = 0;
-        int32_t            ret    = -1;
-        gf_rdma_private_t *priv   = NULL;
-        gf_rdma_device_t  *device = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ctx, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out);
-
-        priv = peer->trans->private;
-        device = priv->device;
-
-        for (i = 0; i < count; i++) {
-                /* what if the memory is registered more than once?
-                 * Assume that a single write buffer is passed to afr, which
-                 * then passes it to its children. If more than one children
-                 * happen to use rdma, then the buffer is registered more than
-                 * once.
-                 * Ib-verbs specification says that multiple registrations of
-                 * same memory location is allowed. Refer to 10.6.3.8 of
-                 * Infiniband Architecture Specification Volume 1
-                 * (Release 1.2.1)
-                 */
-                ctx->mr[ctx->mr_count] = gf_rdma_get_pre_registred_mr(
-                                peer->trans, (void *)vector[i].iov_base,
-                                vector[i].iov_len);
-
-                if (!ctx->mr[ctx->mr_count]) {
-                ctx->mr[ctx->mr_count] = ibv_reg_mr (device->pd,
-                                                     vector[i].iov_base,
-                                                     vector[i].iov_len,
-                                                     IBV_ACCESS_LOCAL_WRITE);
-                }
-                if (ctx->mr[ctx->mr_count] == NULL) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                RDMA_MSG_MR_ALOC_FAILED,
-                                "registering memory for IBV_ACCESS_LOCAL_WRITE"
-                                " failed");
-                        goto out;
-                }
+    int i = 0;
+    int32_t ret = -1;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ctx, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out);
+
+    priv = peer->trans->private;
+    device = priv->device;
+
+    for (i = 0; i < count; i++) {
+        /* what if the memory is registered more than once?
+         * Assume that a single write buffer is passed to afr, which
+         * then passes it to its children. If more than one children
+         * happen to use rdma, then the buffer is registered more than
+         * once.
+         * Ib-verbs specification says that multiple registrations of
+         * same memory location is allowed. Refer to 10.6.3.8 of
+         * Infiniband Architecture Specification Volume 1
+         * (Release 1.2.1)
+         */
+        ctx->mr[ctx->mr_count] = gf_rdma_get_pre_registred_mr(
+            peer->trans, (void *)vector[i].iov_base, vector[i].iov_len);
 
-                ctx->mr_count++;
+        if (!ctx->mr[ctx->mr_count]) {
+            ctx->mr[ctx->mr_count] = ibv_reg_mr(device->pd, vector[i].iov_base,
+                                                vector[i].iov_len,
+                                                IBV_ACCESS_LOCAL_WRITE);
+        }
+        if (ctx->mr[ctx->mr_count] == NULL) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+                   RDMA_MSG_MR_ALOC_FAILED,
+                   "registering memory for IBV_ACCESS_LOCAL_WRITE"
+                   " failed");
+            goto out;
         }
 
-        ret = 0;
+        ctx->mr_count++;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* 1. assumes xfer_len of data is pointed by vector(s) starting from vec[*idx]
  * 2. modifies vec
  */
 int32_t
-__gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post, struct iovec *vec,
-                 uint32_t xfer_len, int *idx, gf_rdma_write_chunk_t *writech)
+__gf_rdma_write(gf_rdma_peer_t *peer, gf_rdma_post_t *post, struct iovec *vec,
+                uint32_t xfer_len, int *idx, gf_rdma_write_chunk_t *writech)
 {
-        int             size    = 0, num_sge = 0, i = 0;
-        int32_t         ret     = -1;
-        struct ibv_sge *sg_list = NULL;
-        struct ibv_send_wr wr   = {
-                .opcode         = IBV_WR_RDMA_WRITE,
-                .send_flags     = IBV_SEND_SIGNALED,
-        }, *bad_wr;
-
-        if ((peer == NULL) || (writech == NULL) || (idx == NULL)
-            || (post == NULL) || (vec == NULL) || (xfer_len == 0)) {
-                goto out;
-        }
-
-        for (i = *idx; size < xfer_len; i++) {
-                size += vec[i].iov_len;
-        }
-
-        num_sge = i - *idx;
-
-        sg_list = GF_CALLOC (num_sge, sizeof (struct ibv_sge),
-                             gf_common_mt_sge);
-        if (sg_list == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        for ((i = *idx), (num_sge = 0); (xfer_len != 0); i++, num_sge++) {
-                size = min (xfer_len, vec[i].iov_len);
-
-                sg_list[num_sge].addr = (unsigned long)vec[i].iov_base;
-                sg_list[num_sge].length = size;
-                sg_list[num_sge].lkey = post->ctx.mr[i]->lkey;
-
-                xfer_len -= size;
-        }
-
-        *idx = i;
-
-        if (size < vec[i - 1].iov_len) {
-                vec[i - 1].iov_base += size;
-                vec[i - 1].iov_len -= size;
-                *idx = i - 1;
-        }
-
-        wr.sg_list = sg_list;
-        wr.num_sge = num_sge;
-        wr.wr_id = (unsigned long) gf_rdma_post_ref (post);
-        wr.wr.rdma.rkey = writech->wc_target.rs_handle;
-        wr.wr.rdma.remote_addr = writech->wc_target.rs_offset;
-
-        ret = ibv_post_send(peer->qp, &wr, &bad_wr);
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to "
-                        "client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                ret = -1;
-        }
-
-        GF_FREE (sg_list);
+    int size = 0, num_sge = 0, i = 0;
+    int32_t ret = -1;
+    struct ibv_sge *sg_list = NULL;
+    struct ibv_send_wr wr =
+                           {
+                               .opcode = IBV_WR_RDMA_WRITE,
+                               .send_flags = IBV_SEND_SIGNALED,
+                           },
+                       *bad_wr;
+
+    if ((peer == NULL) || (writech == NULL) || (idx == NULL) ||
+        (post == NULL) || (vec == NULL) || (xfer_len == 0)) {
+        goto out;
+    }
+
+    for (i = *idx; size < xfer_len; i++) {
+        size += vec[i].iov_len;
+    }
+
+    num_sge = i - *idx;
+
+    sg_list = GF_CALLOC(num_sge, sizeof(struct ibv_sge), gf_common_mt_sge);
+    if (sg_list == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    for ((i = *idx), (num_sge = 0); (xfer_len != 0); i++, num_sge++) {
+        size = min(xfer_len, vec[i].iov_len);
+
+        sg_list[num_sge].addr = (unsigned long)vec[i].iov_base;
+        sg_list[num_sge].length = size;
+        sg_list[num_sge].lkey = post->ctx.mr[i]->lkey;
+
+        xfer_len -= size;
+    }
+
+    *idx = i;
+
+    if (size < vec[i - 1].iov_len) {
+        vec[i - 1].iov_base += size;
+        vec[i - 1].iov_len -= size;
+        *idx = i - 1;
+    }
+
+    wr.sg_list = sg_list;
+    wr.num_sge = num_sge;
+    wr.wr_id = (unsigned long)gf_rdma_post_ref(post);
+    wr.wr.rdma.rkey = writech->wc_target.rs_handle;
+    wr.wr.rdma.remote_addr = writech->wc_target.rs_offset;
+
+    ret = ibv_post_send(peer->qp, &wr, &bad_wr);
+    if (ret) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_CLIENT_ERROR,
+               "rdma write to "
+               "client (%s) failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        ret = -1;
+    }
+
+    GF_FREE(sg_list);
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_do_gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                            struct iovec *vector, int count,
-                            struct iobref *iobref,
-                            gf_rdma_reply_info_t *reply_info)
+__gf_rdma_do_gf_rdma_write(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                           struct iovec *vector, int count,
+                           struct iobref *iobref,
+                           gf_rdma_reply_info_t *reply_info)
 {
-        int      i            = 0, payload_idx = 0;
-        uint32_t payload_size = 0, xfer_len = 0;
-        int32_t  ret          = -1;
+    int i = 0, payload_idx = 0;
+    uint32_t payload_size = 0, xfer_len = 0;
+    int32_t ret = -1;
 
-        if (count != 0) {
-                payload_size = iov_length (vector, count);
-        }
+    if (count != 0) {
+        payload_size = iov_length(vector, count);
+    }
 
-        if (payload_size == 0) {
-                ret = 0;
-                goto out;
-        }
+    if (payload_size == 0) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = __gf_rdma_register_local_mr_for_rdma (peer, vector, count,
-                                                    &post->ctx);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_MR_ALOC_FAILED,
-                        "registering memory region for rdma failed");
-                goto out;
-        }
+    ret = __gf_rdma_register_local_mr_for_rdma(peer, vector, count, &post->ctx);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED,
+               "registering memory region for rdma failed");
+        goto out;
+    }
 
-        post->ctx.iobref = iobref_ref (iobref);
+    post->ctx.iobref = iobref_ref(iobref);
 
-        for (i = 0; (i < reply_info->wc_array->wc_nchunks)
-                     && (payload_size != 0);
-             i++) {
-                xfer_len = min (payload_size,
-                                reply_info->wc_array->wc_array[i].wc_target.rs_length);
+    for (i = 0; (i < reply_info->wc_array->wc_nchunks) && (payload_size != 0);
+         i++) {
+        xfer_len = min(payload_size,
+                       reply_info->wc_array->wc_array[i].wc_target.rs_length);
 
-                ret = __gf_rdma_write (peer, post, vector, xfer_len,
-                                       &payload_idx,
-                                       &reply_info->wc_array->wc_array[i]);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to "
-                                "client (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                        goto out;
-                }
-
-                payload_size -= xfer_len;
+        ret = __gf_rdma_write(peer, post, vector, xfer_len, &payload_idx,
+                              &reply_info->wc_array->wc_array[i]);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_WRITE_CLIENT_ERROR,
+                   "rdma write to "
+                   "client (%s) failed",
+                   peer->trans->peerinfo.identifier);
+            goto out;
         }
 
-        ret = 0;
+        payload_size -= xfer_len;
+    }
+
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_send_reply_type_nomsg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                                 gf_rdma_post_t *post,
-                                 gf_rdma_reply_info_t *reply_info)
+__gf_rdma_send_reply_type_nomsg(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                                gf_rdma_post_t *post,
+                                gf_rdma_reply_info_t *reply_info)
 {
-        gf_rdma_header_t *header       = NULL;
-        char             *buf          = NULL;
-        uint32_t          payload_size = 0;
-        int               count        = 0, i = 0;
-        int32_t           ret          = 0;
-        struct iovec      vector[MAX_IOVEC];
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        header->rm_type = hton32 (GF_RDMA_NOMSG);
-
-        payload_size = iov_length (entry->rpchdr, entry->rpchdr_count) +
-                iov_length (entry->proghdr, entry->proghdr_count);
-
-        /* encode reply chunklist */
-        buf = (char *)&header->rm_body.rm_chunks[2];
-        ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post,
-                                                   reply_info,
-                                                   (uint32_t **)&buf);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed");
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        gf_rdma_post_ref (post);
-
-        for (i = 0; i < entry->rpchdr_count; i++) {
-                vector[count++] = entry->rpchdr[i];
-        }
-
-        for (i = 0; i < entry->proghdr_count; i++) {
-                vector[count++] = entry->proghdr[i];
-        }
-
-        ret = __gf_rdma_do_gf_rdma_write (peer, post, vector, count,
-                                          entry->iobref, reply_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer "
-                        "(%s) failed", peer->trans->peerinfo.identifier);
-                gf_rdma_post_unref (post);
-                goto out;
-        }
-
-        ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf));
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_SEND_FAILED, "posting a send request "
-                        "to client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                ret = -1;
-                gf_rdma_post_unref (post);
-        } else {
-                ret = payload_size;
-        }
+    gf_rdma_header_t *header = NULL;
+    char *buf = NULL;
+    uint32_t payload_size = 0;
+    int count = 0, i = 0;
+    int32_t ret = 0;
+    struct iovec vector[MAX_IOVEC];
+
+    header = (gf_rdma_header_t *)post->buf;
+
+    __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info,
+                                peer->send_count);
+
+    header->rm_type = hton32(GF_RDMA_NOMSG);
+
+    payload_size = iov_length(entry->rpchdr, entry->rpchdr_count) +
+                   iov_length(entry->proghdr, entry->proghdr_count);
+
+    /* encode reply chunklist */
+    buf = (char *)&header->rm_body.rm_chunks[2];
+    ret = __gf_rdma_reply_encode_write_chunks(peer, payload_size, post,
+                                              reply_info, (uint32_t **)&buf);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_ENCODE_ERROR,
+               "encoding write chunks failed");
+        ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK);
+        goto out;
+    }
+
+    gf_rdma_post_ref(post);
+
+    for (i = 0; i < entry->rpchdr_count; i++) {
+        vector[count++] = entry->rpchdr[i];
+    }
+
+    for (i = 0; i < entry->proghdr_count; i++) {
+        vector[count++] = entry->proghdr[i];
+    }
+
+    ret = __gf_rdma_do_gf_rdma_write(peer, post, vector, count, entry->iobref,
+                                     reply_info);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED,
+               "rdma write to peer "
+               "(%s) failed",
+               peer->trans->peerinfo.identifier);
+        gf_rdma_post_unref(post);
+        goto out;
+    }
+
+    ret = gf_rdma_post_send(peer->qp, post, (buf - post->buf));
+    if (ret) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED,
+               "posting a send request "
+               "to client (%s) failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        ret = -1;
+        gf_rdma_post_unref(post);
+    } else {
+        ret = payload_size;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_send_reply_type_msg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                               gf_rdma_post_t *post,
-                               gf_rdma_reply_info_t *reply_info)
+__gf_rdma_send_reply_type_msg(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                              gf_rdma_post_t *post,
+                              gf_rdma_reply_info_t *reply_info)
 {
-        gf_rdma_header_t *header       = NULL;
-        int32_t           send_size    = 0, ret = 0;
-        char             *ptr          = NULL;
-        uint32_t          payload_size = 0;
-
-        send_size = iov_length (entry->rpchdr, entry->rpchdr_count)
-                + iov_length (entry->proghdr, entry->proghdr_count)
-                + GLUSTERFS_RDMA_MAX_HEADER_SIZE;
-
-        if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
-                        "client has provided only write chunks, but the "
-                        "combined size of rpc and program header (%d) is "
-                        "exceeding the size of msg that can be sent using "
-                        "RDMA send (%d)", send_size,
-                        GLUSTERFS_RDMA_INLINE_THRESHOLD);
-
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info,
-                                     peer->send_count);
-
-        payload_size = iov_length (entry->prog_payload,
-                                   entry->prog_payload_count);
-        ptr = (char *)&header->rm_body.rm_chunks[1];
-
-        ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post,
-                                                   reply_info,
-                                                   (uint32_t **)&ptr);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed");
-                ret = __gf_rdma_send_error (peer, entry, post, reply_info,
-                                            ERR_CHUNK);
-                goto out;
-        }
-
-        *(uint32_t *)ptr = 0;          /* terminate reply chunklist */
-        ptr += sizeof (uint32_t);
-
-        gf_rdma_post_ref (post);
-
-        ret = __gf_rdma_do_gf_rdma_write (peer, post, entry->prog_payload,
-                                          entry->prog_payload_count,
-                                          entry->iobref, reply_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer "
-                        "(%s) failed", peer->trans->peerinfo.identifier);
-                gf_rdma_post_unref (post);
-                goto out;
-        }
-
-        iov_unload (ptr, entry->rpchdr, entry->rpchdr_count);
-        ptr += iov_length (entry->rpchdr, entry->rpchdr_count);
-
-        iov_unload (ptr, entry->proghdr, entry->proghdr_count);
-        ptr += iov_length (entry->proghdr, entry->proghdr_count);
-
-        ret = gf_rdma_post_send (peer->qp, post, (ptr - post->buf));
-        if (ret) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_SEND_CLIENT_ERROR,
-                        "rdma send to client (%s) failed with ret = %d (%s)",
-                        peer->trans->peerinfo.identifier, ret,
-                        (ret > 0) ? strerror (ret) : "");
-                gf_rdma_post_unref (post);
-                ret = -1;
-        } else {
-                ret = send_size + payload_size;
-        }
+    gf_rdma_header_t *header = NULL;
+    int32_t send_size = 0, ret = 0;
+    char *ptr = NULL;
+    uint32_t payload_size = 0;
+
+    send_size = iov_length(entry->rpchdr, entry->rpchdr_count) +
+                iov_length(entry->proghdr, entry->proghdr_count) +
+                GLUSTERFS_RDMA_MAX_HEADER_SIZE;
+
+    if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD,
+               "client has provided only write chunks, but the "
+               "combined size of rpc and program header (%d) is "
+               "exceeding the size of msg that can be sent using "
+               "RDMA send (%d)",
+               send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD);
+
+        ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK);
+        goto out;
+    }
+
+    header = (gf_rdma_header_t *)post->buf;
+
+    __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info,
+                                peer->send_count);
+
+    payload_size = iov_length(entry->prog_payload, entry->prog_payload_count);
+    ptr = (char *)&header->rm_body.rm_chunks[1];
+
+    ret = __gf_rdma_reply_encode_write_chunks(peer, payload_size, post,
+                                              reply_info, (uint32_t **)&ptr);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_ENCODE_ERROR,
+               "encoding write chunks failed");
+        ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK);
+        goto out;
+    }
+
+    *(uint32_t *)ptr = 0; /* terminate reply chunklist */
+    ptr += sizeof(uint32_t);
+
+    gf_rdma_post_ref(post);
+
+    ret = __gf_rdma_do_gf_rdma_write(peer, post, entry->prog_payload,
+                                     entry->prog_payload_count, entry->iobref,
+                                     reply_info);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED,
+               "rdma write to peer "
+               "(%s) failed",
+               peer->trans->peerinfo.identifier);
+        gf_rdma_post_unref(post);
+        goto out;
+    }
+
+    iov_unload(ptr, entry->rpchdr, entry->rpchdr_count);
+    ptr += iov_length(entry->rpchdr, entry->rpchdr_count);
+
+    iov_unload(ptr, entry->proghdr, entry->proghdr_count);
+    ptr += iov_length(entry->proghdr, entry->proghdr_count);
+
+    ret = gf_rdma_post_send(peer->qp, post, (ptr - post->buf));
+    if (ret) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_SEND_CLIENT_ERROR,
+               "rdma send to client (%s) failed with ret = %d (%s)",
+               peer->trans->peerinfo.identifier, ret,
+               (ret > 0) ? strerror(ret) : "");
+        gf_rdma_post_unref(post);
+        ret = -1;
+    } else {
+        ret = send_size + payload_size;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-gf_rdma_reply_info_destroy (gf_rdma_reply_info_t *reply_info)
+gf_rdma_reply_info_destroy(gf_rdma_reply_info_t *reply_info)
 {
-        if (reply_info == NULL) {
-                goto out;
-        }
+    if (reply_info == NULL) {
+        goto out;
+    }
 
-        if (reply_info->wc_array != NULL) {
-                GF_FREE (reply_info->wc_array);
-                reply_info->wc_array = NULL;
-        }
+    if (reply_info->wc_array != NULL) {
+        GF_FREE(reply_info->wc_array);
+        reply_info->wc_array = NULL;
+    }
 
-        mem_put (reply_info);
+    mem_put(reply_info);
 out:
-        return;
+    return;
 }
 
-
 gf_rdma_reply_info_t *
-gf_rdma_reply_info_alloc (gf_rdma_peer_t *peer)
+gf_rdma_reply_info_alloc(gf_rdma_peer_t *peer)
 {
-        gf_rdma_reply_info_t *reply_info = NULL;
-        gf_rdma_private_t    *priv       = NULL;
+    gf_rdma_reply_info_t *reply_info = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = peer->trans->private;
+    priv = peer->trans->private;
 
-        reply_info = mem_get (priv->device->reply_info_pool);
-        if (reply_info == NULL) {
-                goto out;
-        }
+    reply_info = mem_get(priv->device->reply_info_pool);
+    if (reply_info == NULL) {
+        goto out;
+    }
 
-        memset (reply_info, 0, sizeof (*reply_info));
-        reply_info->pool = priv->device->reply_info_pool;
+    memset(reply_info, 0, sizeof(*reply_info));
+    reply_info->pool = priv->device->reply_info_pool;
 
 out:
-        return reply_info;
+    return reply_info;
 }
 
-
 int32_t
-__gf_rdma_ioq_churn_reply (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
-                           gf_rdma_post_t *post)
+__gf_rdma_ioq_churn_reply(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry,
+                          gf_rdma_post_t *post)
 {
-        gf_rdma_reply_info_t *reply_info = NULL;
-        int32_t               ret        = -1;
-        gf_rdma_chunktype_t   type       = gf_rdma_noch;
+    gf_rdma_reply_info_t *reply_info = NULL;
+    int32_t ret = -1;
+    gf_rdma_chunktype_t type = gf_rdma_noch;
 
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out);
+    GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, post, out);
 
-        reply_info = entry->msg.reply_info;
-        if (reply_info != NULL) {
-                type = reply_info->type;
-        }
+    reply_info = entry->msg.reply_info;
+    if (reply_info != NULL) {
+        type = reply_info->type;
+    }
 
-        switch (type) {
+    switch (type) {
         case gf_rdma_noch:
-                ret = __gf_rdma_send_reply_inline (peer, entry, post,
-                                                   reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply to peer (%s) as an "
-                                "inlined rdma msg",
-                                peer->trans->peerinfo.identifier);
-                }
-                break;
+            ret = __gf_rdma_send_reply_inline(peer, entry, post, reply_info);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_SEND_REPLY_FAILED,
+                       "failed to send reply to peer (%s) as an "
+                       "inlined rdma msg",
+                       peer->trans->peerinfo.identifier);
+            }
+            break;
 
         case gf_rdma_replych:
-                ret = __gf_rdma_send_reply_type_nomsg (peer, entry, post,
-                                                       reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply to peer (%s) as "
-                                "RDMA_NOMSG", peer->trans->peerinfo.identifier);
-                }
-                break;
+            ret = __gf_rdma_send_reply_type_nomsg(peer, entry, post,
+                                                  reply_info);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_SEND_REPLY_FAILED,
+                       "failed to send reply to peer (%s) as "
+                       "RDMA_NOMSG",
+                       peer->trans->peerinfo.identifier);
+            }
+            break;
 
         case gf_rdma_writech:
-                ret = __gf_rdma_send_reply_type_msg (peer, entry, post,
-                                                     reply_info);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_SEND_REPLY_FAILED,
-                                "failed to send reply with write chunks "
-                                "to peer (%s)",
-                                peer->trans->peerinfo.identifier);
-                }
-                break;
+            ret = __gf_rdma_send_reply_type_msg(peer, entry, post, reply_info);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_SEND_REPLY_FAILED,
+                       "failed to send reply with write chunks "
+                       "to peer (%s)",
+                       peer->trans->peerinfo.identifier);
+            }
+            break;
 
         default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_CHUNK_TYPE,
-                        "invalid chunktype (%d) specified for sending reply "
-                        " (peer:%s)", type, peer->trans->peerinfo.identifier);
-                break;
-        }
-
-        if (reply_info != NULL) {
-                gf_rdma_reply_info_destroy (reply_info);
-        }
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_INVALID_CHUNK_TYPE,
+                   "invalid chunktype (%d) specified for sending reply "
+                   " (peer:%s)",
+                   type, peer->trans->peerinfo.identifier);
+            break;
+    }
+
+    if (reply_info != NULL) {
+        gf_rdma_reply_info_destroy(reply_info);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-__gf_rdma_ioq_churn_entry (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry)
+__gf_rdma_ioq_churn_entry(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry)
 {
-        int32_t            ret     = 0, quota = 0;
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_device_t  *device  = NULL;
-        gf_rdma_options_t *options = NULL;
-        gf_rdma_post_t    *post    = NULL;
-
-        priv = peer->trans->private;
-        options = &priv->options;
-        device = priv->device;
-
-        quota = __gf_rdma_quota_get (peer);
-        if (quota > 0) {
-                post = gf_rdma_get_post (&device->sendq);
-                if (post == NULL) {
-                        post = gf_rdma_new_post (peer->trans, device,
-                                                 (options->send_size + 2048),
-                                                 GF_RDMA_SEND_POST);
-                }
-
-                if (post == NULL) {
-                        ret = -1;
-                        gf_msg_callingfn (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                          RDMA_MSG_POST_SEND_FAILED,
-                                          "not able to get a post to send msg");
-                        goto out;
-                }
-
-                if (entry->is_request) {
-                        ret = __gf_rdma_ioq_churn_request (peer, entry, post);
-                        if (ret < 0) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                        "failed to process request ioq entry "
-                                        "to peer(%s)",
-                                        peer->trans->peerinfo.identifier);
-                        }
-                } else {
-                        ret = __gf_rdma_ioq_churn_reply (peer, entry, post);
-                        if (ret < 0) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                        "failed to process reply ioq entry "
-                                        "to peer (%s)",
-                                        peer->trans->peerinfo.identifier);
-                        }
-                }
+    int32_t ret = 0, quota = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    gf_rdma_options_t *options = NULL;
+    gf_rdma_post_t *post = NULL;
+
+    priv = peer->trans->private;
+    options = &priv->options;
+    device = priv->device;
+
+    quota = __gf_rdma_quota_get(peer);
+    if (quota > 0) {
+        post = gf_rdma_get_post(&device->sendq);
+        if (post == NULL) {
+            post = gf_rdma_new_post(peer->trans, device,
+                                    (options->send_size + 2048),
+                                    GF_RDMA_SEND_POST);
+        }
 
-                if (ret != 0) {
-                        __gf_rdma_ioq_entry_free (entry);
-                }
+        if (post == NULL) {
+            ret = -1;
+            gf_msg_callingfn(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                             RDMA_MSG_POST_SEND_FAILED,
+                             "not able to get a post to send msg");
+            goto out;
+        }
+
+        if (entry->is_request) {
+            ret = __gf_rdma_ioq_churn_request(peer, entry, post);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
+                       "failed to process request ioq entry "
+                       "to peer(%s)",
+                       peer->trans->peerinfo.identifier);
+            }
         } else {
-                ret = 0;
+            ret = __gf_rdma_ioq_churn_reply(peer, entry, post);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
+                       "failed to process reply ioq entry "
+                       "to peer (%s)",
+                       peer->trans->peerinfo.identifier);
+            }
+        }
+
+        if (ret != 0) {
+            __gf_rdma_ioq_entry_free(entry);
         }
+    } else {
+        ret = 0;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-__gf_rdma_ioq_churn (gf_rdma_peer_t *peer)
+__gf_rdma_ioq_churn(gf_rdma_peer_t *peer)
 {
-        gf_rdma_ioq_t *entry = NULL;
-        int32_t        ret   = 0;
+    gf_rdma_ioq_t *entry = NULL;
+    int32_t ret = 0;
 
-        while (!list_empty (&peer->ioq)) {
-                /* pick next entry */
-                entry = peer->ioq_next;
+    while (!list_empty(&peer->ioq)) {
+        /* pick next entry */
+        entry = peer->ioq_next;
 
-                ret = __gf_rdma_ioq_churn_entry (peer, entry);
+        ret = __gf_rdma_ioq_churn_entry(peer, entry);
 
-                if (ret <= 0)
-                        break;
-        }
+        if (ret <= 0)
+            break;
+    }
 
-        /*
-          list_for_each_entry_safe (entry, dummy, &peer->ioq, list) {
-          ret = __gf_rdma_ioq_churn_entry (peer, entry);
-          if (ret <= 0) {
-          break;
-          }
-          }
-        */
+    /*
+      list_for_each_entry_safe (entry, dummy, &peer->ioq, list) {
+      ret = __gf_rdma_ioq_churn_entry (peer, entry);
+      if (ret <= 0) {
+      break;
+      }
+      }
+    */
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_writev (rpc_transport_t *this, gf_rdma_ioq_t *entry)
+gf_rdma_writev(rpc_transport_t *this, gf_rdma_ioq_t *entry)
 {
-        int32_t            ret  = 0, need_append = 1;
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_peer_t    *peer = NULL;
+    int32_t ret = 0, need_append = 1;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_peer_t *peer = NULL;
 
-        priv = this->private;
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->connected) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_DISCONNECTED,
-                                "rdma is not connected to peer (%s)",
-                                this->peerinfo.identifier);
-                        ret = -1;
-                        goto unlock;
-                }
+    priv = this->private;
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        if (!priv->connected) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_PEER_DISCONNECTED,
+                   "rdma is not connected to peer (%s)",
+                   this->peerinfo.identifier);
+            ret = -1;
+            goto unlock;
+        }
 
-                peer = &priv->peer;
-                if (list_empty (&peer->ioq)) {
-                        ret = __gf_rdma_ioq_churn_entry (peer, entry);
-                        if (ret != 0) {
-                                need_append = 0;
-
-                                if (ret < 0) {
-                                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                                RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
-                                                "processing ioq entry destined"
-                                                " to (%s) failed",
-                                                this->peerinfo.identifier);
-                                }
-                        }
-                }
+        peer = &priv->peer;
+        if (list_empty(&peer->ioq)) {
+            ret = __gf_rdma_ioq_churn_entry(peer, entry);
+            if (ret != 0) {
+                need_append = 0;
 
-                if (need_append) {
-                        list_add_tail (&entry->list, &peer->ioq);
+                if (ret < 0) {
+                    gf_msg(this->name, GF_LOG_WARNING, 0,
+                           RDMA_MSG_PROC_IOQ_ENTRY_FAILED,
+                           "processing ioq entry destined"
+                           " to (%s) failed",
+                           this->peerinfo.identifier);
                 }
+            }
         }
+
+        if (need_append) {
+            list_add_tail(&entry->list, &peer->ioq);
+        }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
-        return ret;
+    pthread_mutex_unlock(&priv->write_mutex);
+    return ret;
 }
 
-
 gf_rdma_ioq_t *
-gf_rdma_ioq_new (rpc_transport_t *this, rpc_transport_data_t *data)
+gf_rdma_ioq_new(rpc_transport_t *this, rpc_transport_data_t *data)
 {
-        gf_rdma_ioq_t       *entry = NULL;
-        int                  count = 0, i = 0;
-        rpc_transport_msg_t *msg   = NULL;
-        gf_rdma_private_t   *priv  = NULL;
+    gf_rdma_ioq_t *entry = NULL;
+    int count = 0, i = 0;
+    rpc_transport_msg_t *msg = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        if ((data == NULL) || (this == NULL)) {
-                goto out;
-        }
+    if ((data == NULL) || (this == NULL)) {
+        goto out;
+    }
 
-        priv = this->private;
+    priv = this->private;
 
-        entry = mem_get (priv->device->ioq_pool);
-        if (entry == NULL) {
-                goto out;
-        }
-        memset (entry, 0, sizeof (*entry));
-        entry->pool = priv->device->ioq_pool;
-
-        if (data->is_request) {
-                msg = &data->data.req.msg;
-                if (data->data.req.rsp.rsphdr_count != 0) {
-                        for (i = 0; i < data->data.req.rsp.rsphdr_count; i++) {
-                                entry->msg.request.rsphdr_vec[i]
-                                        = data->data.req.rsp.rsphdr[i];
-                        }
+    entry = mem_get(priv->device->ioq_pool);
+    if (entry == NULL) {
+        goto out;
+    }
+    memset(entry, 0, sizeof(*entry));
+    entry->pool = priv->device->ioq_pool;
 
-                        entry->msg.request.rsphdr_count =
-                                data->data.req.rsp.rsphdr_count;
-                }
+    if (data->is_request) {
+        msg = &data->data.req.msg;
+        if (data->data.req.rsp.rsphdr_count != 0) {
+            for (i = 0; i < data->data.req.rsp.rsphdr_count; i++) {
+                entry->msg.request.rsphdr_vec[i] = data->data.req.rsp.rsphdr[i];
+            }
 
-                if (data->data.req.rsp.rsp_payload_count != 0) {
-                        for (i = 0; i < data->data.req.rsp.rsp_payload_count;
-                             i++) {
-                                entry->msg.request.rsp_payload[i]
-                                        = data->data.req.rsp.rsp_payload[i];
-                        }
+            entry->msg.request.rsphdr_count = data->data.req.rsp.rsphdr_count;
+        }
 
-                        entry->msg.request.rsp_payload_count =
-                                data->data.req.rsp.rsp_payload_count;
-                }
+        if (data->data.req.rsp.rsp_payload_count != 0) {
+            for (i = 0; i < data->data.req.rsp.rsp_payload_count; i++) {
+                entry->msg.request.rsp_payload[i] = data->data.req.rsp
+                                                        .rsp_payload[i];
+            }
 
-                entry->msg.request.rpc_req = data->data.req.rpc_req;
+            entry->msg.request.rsp_payload_count = data->data.req.rsp
+                                                       .rsp_payload_count;
+        }
 
-                if (data->data.req.rsp.rsp_iobref != NULL) {
-                        entry->msg.request.rsp_iobref
-                                = iobref_ref (data->data.req.rsp.rsp_iobref);
-                }
-        } else {
-                msg = &data->data.reply.msg;
-                entry->msg.reply_info = data->data.reply.private;
+        entry->msg.request.rpc_req = data->data.req.rpc_req;
+
+        if (data->data.req.rsp.rsp_iobref != NULL) {
+            entry->msg.request.rsp_iobref = iobref_ref(
+                data->data.req.rsp.rsp_iobref);
         }
+    } else {
+        msg = &data->data.reply.msg;
+        entry->msg.reply_info = data->data.reply.private;
+    }
 
-        entry->is_request = data->is_request;
+    entry->is_request = data->is_request;
 
-        count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
+    count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
 
-        GF_ASSERT (count <= MAX_IOVEC);
+    GF_ASSERT(count <= MAX_IOVEC);
 
-        if (msg->rpchdr != NULL) {
-                memcpy (&entry->rpchdr[0], msg->rpchdr,
-                        sizeof (struct iovec) * msg->rpchdrcount);
-                entry->rpchdr_count = msg->rpchdrcount;
-        }
+    if (msg->rpchdr != NULL) {
+        memcpy(&entry->rpchdr[0], msg->rpchdr,
+               sizeof(struct iovec) * msg->rpchdrcount);
+        entry->rpchdr_count = msg->rpchdrcount;
+    }
 
-        if (msg->proghdr != NULL) {
-                memcpy (&entry->proghdr[0], msg->proghdr,
-                        sizeof (struct iovec) * msg->proghdrcount);
-                entry->proghdr_count = msg->proghdrcount;
-        }
+    if (msg->proghdr != NULL) {
+        memcpy(&entry->proghdr[0], msg->proghdr,
+               sizeof(struct iovec) * msg->proghdrcount);
+        entry->proghdr_count = msg->proghdrcount;
+    }
 
-        if (msg->progpayload != NULL) {
-                memcpy (&entry->prog_payload[0], msg->progpayload,
-                        sizeof (struct iovec) * msg->progpayloadcount);
-                entry->prog_payload_count = msg->progpayloadcount;
-        }
+    if (msg->progpayload != NULL) {
+        memcpy(&entry->prog_payload[0], msg->progpayload,
+               sizeof(struct iovec) * msg->progpayloadcount);
+        entry->prog_payload_count = msg->progpayloadcount;
+    }
 
-        if (msg->iobref != NULL) {
-                entry->iobref = iobref_ref (msg->iobref);
-        }
+    if (msg->iobref != NULL) {
+        entry->iobref = iobref_ref(msg->iobref);
+    }
 
-        INIT_LIST_HEAD (&entry->list);
+    INIT_LIST_HEAD(&entry->list);
 
 out:
-        return entry;
+    return entry;
 }
 
-
 int32_t
-gf_rdma_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
+gf_rdma_submit_request(rpc_transport_t *this, rpc_transport_req_t *req)
 {
-        int32_t               ret   = 0;
-        gf_rdma_ioq_t        *entry = NULL;
-        rpc_transport_data_t  data  = {0, };
-        gf_rdma_private_t    *priv  = NULL;
-        gf_rdma_peer_t       *peer  = NULL;
-
-        if (req == NULL) {
-                goto out;
-        }
-
-        priv = this->private;
-        if (priv == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        peer = &priv->peer;
-        data.is_request = 1;
-        data.data.req = *req;
-/*
- * when fist message is received on a transport, quota variable will
- * initiaize  and quota_set will set to one. In gluster code client
- * process with respect to transport is the one who sends the first
- * message. Before settng quota_set variable if a submit request is
- * came on server, then the message should not send.
- */
-
-        if (priv->entity == GF_RDMA_SERVER && peer->quota_set == 0) {
-                ret = 0;
-                goto out;
-        }
+    int32_t ret = 0;
+    gf_rdma_ioq_t *entry = NULL;
+    rpc_transport_data_t data = {
+        0,
+    };
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_peer_t *peer = NULL;
+
+    if (req == NULL) {
+        goto out;
+    }
+
+    priv = this->private;
+    if (priv == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    peer = &priv->peer;
+    data.is_request = 1;
+    data.data.req = *req;
+    /*
+     * when fist message is received on a transport, quota variable will
+     * initiaize  and quota_set will set to one. In gluster code client
+     * process with respect to transport is the one who sends the first
+     * message. Before settng quota_set variable if a submit request is
+     * came on server, then the message should not send.
+     */
+
+    if (priv->entity == GF_RDMA_SERVER && peer->quota_set == 0) {
+        ret = 0;
+        goto out;
+    }
 
-        entry = gf_rdma_ioq_new (this, &data);
-        if (entry == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
-                        "getting a new ioq entry failed (peer:%s)",
-                        this->peerinfo.identifier);
-                goto out;
-        }
+    entry = gf_rdma_ioq_new(this, &data);
+    if (entry == NULL) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
+               "getting a new ioq entry failed (peer:%s)",
+               this->peerinfo.identifier);
+        goto out;
+    }
 
-        ret = gf_rdma_writev (this, entry);
+    ret = gf_rdma_writev(this, entry);
 
-        if (ret > 0) {
-                ret = 0;
-        } else if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED,
-                        "sending request to peer (%s) failed",
-                        this->peerinfo.identifier);
-                rpc_transport_disconnect (this, _gf_false);
-        }
+    if (ret > 0) {
+        ret = 0;
+    } else if (ret < 0) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED,
+               "sending request to peer (%s) failed",
+               this->peerinfo.identifier);
+        rpc_transport_disconnect(this, _gf_false);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-gf_rdma_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
+gf_rdma_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply)
 {
-        int32_t               ret   = 0;
-        gf_rdma_ioq_t        *entry = NULL;
-        rpc_transport_data_t  data  = {0, };
-
-        if (reply == NULL) {
-                goto out;
-        }
-
-        data.data.reply = *reply;
-
-        entry = gf_rdma_ioq_new (this, &data);
-        if (entry == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
-                        "getting a new ioq entry failed (peer:%s)",
-                        this->peerinfo.identifier);
-                goto out;
-        }
-
-        ret = gf_rdma_writev (this, entry);
-        if (ret > 0) {
-                ret = 0;
-        } else if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_WRITE_PEER_FAILED,
-                        "sending request to peer (%s) failed",
-                        this->peerinfo.identifier);
-                rpc_transport_disconnect (this, _gf_false);
-        }
+    int32_t ret = 0;
+    gf_rdma_ioq_t *entry = NULL;
+    rpc_transport_data_t data = {
+        0,
+    };
+
+    if (reply == NULL) {
+        goto out;
+    }
+
+    data.data.reply = *reply;
+
+    entry = gf_rdma_ioq_new(this, &data);
+    if (entry == NULL) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NEW_IOQ_ENTRY_FAILED,
+               "getting a new ioq entry failed (peer:%s)",
+               this->peerinfo.identifier);
+        goto out;
+    }
+
+    ret = gf_rdma_writev(this, entry);
+    if (ret > 0) {
+        ret = 0;
+    } else if (ret < 0) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED,
+               "sending request to peer (%s) failed",
+               this->peerinfo.identifier);
+        rpc_transport_disconnect(this, _gf_false);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-gf_rdma_register_peer (gf_rdma_device_t *device, int32_t qp_num,
-                       gf_rdma_peer_t *peer)
+gf_rdma_register_peer(gf_rdma_device_t *device, int32_t qp_num,
+                      gf_rdma_peer_t *peer)
 {
-        struct _qpent   *ent   = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
-        int              ret   = -1;
+    struct _qpent *ent = NULL;
+    gf_rdma_qpreg_t *qpreg = NULL;
+    int32_t hash = 0;
+    int ret = -1;
 
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
+    qpreg = &device->qpreg;
+    hash = qp_num % 42;
 
-        pthread_mutex_lock (&qpreg->lock);
-        {
-                ent = qpreg->ents[hash].next;
-                while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) {
-                        ent = ent->next;
-                }
-
-                if (ent->qp_num == qp_num) {
-                        ret = 0;
-                        goto unlock;
-                }
+    pthread_mutex_lock(&qpreg->lock);
+    {
+        ent = qpreg->ents[hash].next;
+        while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) {
+            ent = ent->next;
+        }
 
-                ent = (struct _qpent *) GF_CALLOC (1, sizeof (*ent),
-                                                   gf_common_mt_qpent);
-                if (ent == NULL) {
-                        goto unlock;
-                }
+        if (ent->qp_num == qp_num) {
+            ret = 0;
+            goto unlock;
+        }
 
-                /* TODO: ref reg->peer */
-                ent->peer = peer;
-                ent->next = &qpreg->ents[hash];
-                ent->prev = ent->next->prev;
-                ent->next->prev = ent;
-                ent->prev->next = ent;
-                ent->qp_num = qp_num;
-                qpreg->count++;
-                ret = 0;
+        ent = (struct _qpent *)GF_CALLOC(1, sizeof(*ent), gf_common_mt_qpent);
+        if (ent == NULL) {
+            goto unlock;
         }
+
+        /* TODO: ref reg->peer */
+        ent->peer = peer;
+        ent->next = &qpreg->ents[hash];
+        ent->prev = ent->next->prev;
+        ent->next->prev = ent;
+        ent->prev->next = ent;
+        ent->qp_num = qp_num;
+        qpreg->count++;
+        ret = 0;
+    }
 unlock:
-        pthread_mutex_unlock (&qpreg->lock);
+    pthread_mutex_unlock(&qpreg->lock);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-gf_rdma_unregister_peer (gf_rdma_device_t *device, int32_t qp_num)
+gf_rdma_unregister_peer(gf_rdma_device_t *device, int32_t qp_num)
 {
-        struct _qpent   *ent   = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
+    struct _qpent *ent = NULL;
+    gf_rdma_qpreg_t *qpreg = NULL;
+    int32_t hash = 0;
 
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
+    qpreg = &device->qpreg;
+    hash = qp_num % 42;
 
-        pthread_mutex_lock (&qpreg->lock);
-        {
-                ent = qpreg->ents[hash].next;
-                while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
-                        ent = ent->next;
-                if (ent->qp_num != qp_num) {
-                        pthread_mutex_unlock (&qpreg->lock);
-                        return;
-                }
-                ent->prev->next = ent->next;
-                ent->next->prev = ent->prev;
-                /* TODO: unref reg->peer */
-                GF_FREE (ent);
-                qpreg->count--;
-        }
-        pthread_mutex_unlock (&qpreg->lock);
+    pthread_mutex_lock(&qpreg->lock);
+    {
+        ent = qpreg->ents[hash].next;
+        while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
+            ent = ent->next;
+        if (ent->qp_num != qp_num) {
+            pthread_mutex_unlock(&qpreg->lock);
+            return;
+        }
+        ent->prev->next = ent->next;
+        ent->next->prev = ent->prev;
+        /* TODO: unref reg->peer */
+        GF_FREE(ent);
+        qpreg->count--;
+    }
+    pthread_mutex_unlock(&qpreg->lock);
 }
 
-
 static gf_rdma_peer_t *
-__gf_rdma_lookup_peer (gf_rdma_device_t *device, int32_t qp_num)
+__gf_rdma_lookup_peer(gf_rdma_device_t *device, int32_t qp_num)
 {
-        struct _qpent   *ent   = NULL;
-        gf_rdma_peer_t  *peer  = NULL;
-        gf_rdma_qpreg_t *qpreg = NULL;
-        int32_t          hash  = 0;
-
-        qpreg = &device->qpreg;
-        hash = qp_num % 42;
-        ent = qpreg->ents[hash].next;
-        while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
-                ent = ent->next;
-
-        if (ent != &qpreg->ents[hash]) {
-                peer = ent->peer;
-        }
-
-        return peer;
+    struct _qpent *ent = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    gf_rdma_qpreg_t *qpreg = NULL;
+    int32_t hash = 0;
+
+    qpreg = &device->qpreg;
+    hash = qp_num % 42;
+    ent = qpreg->ents[hash].next;
+    while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num))
+        ent = ent->next;
+
+    if (ent != &qpreg->ents[hash]) {
+        peer = ent->peer;
+    }
+
+    return peer;
 }
 
-
 static void
-__gf_rdma_destroy_qp (rpc_transport_t *this)
+__gf_rdma_destroy_qp(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        priv = this->private;
-        if (priv->peer.qp) {
-                gf_rdma_unregister_peer (priv->device, priv->peer.qp->qp_num);
-                rdma_destroy_qp (priv->peer.cm_id);
-        }
-        priv->peer.qp = NULL;
+    priv = this->private;
+    if (priv->peer.qp) {
+        gf_rdma_unregister_peer(priv->device, priv->peer.qp->qp_num);
+        rdma_destroy_qp(priv->peer.cm_id);
+    }
+    priv->peer.qp = NULL;
 
-        return;
+    return;
 }
 
-
 static int32_t
-gf_rdma_create_qp (rpc_transport_t *this)
+gf_rdma_create_qp(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv        = NULL;
-        gf_rdma_device_t  *device      = NULL;
-        int32_t            ret         = 0;
-        gf_rdma_peer_t    *peer        = NULL;
-        char              *device_name = NULL;
-
-        priv = this->private;
-
-        peer = &priv->peer;
-
-        device_name = (char *)ibv_get_device_name (peer->cm_id->verbs->device);
-        if (device_name == NULL) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get "
-                        "device_name");
-                goto out;
-        }
-
-        device = gf_rdma_get_device (this, peer->cm_id->verbs,
-                                     device_name);
-        if (device == NULL) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_DEVICE_FAILED, "cannot get device for "
-                        "device %s", device_name);
-                goto out;
-        }
-
-        if (priv->device == NULL) {
-                priv->device = device;
-        }
-
-        struct ibv_qp_init_attr init_attr = {
-                .send_cq        = device->send_cq,
-                .recv_cq        = device->recv_cq,
-                .srq            = device->srq,
-                .cap            = {
-                        .max_send_wr  = peer->send_count,
-                        .max_recv_wr  = peer->recv_count,
-                        .max_send_sge = 2,
-                        .max_recv_sge = 1
-                },
-                .qp_type = IBV_QPT_RC
-        };
-
-        ret = rdma_create_qp(peer->cm_id, device->pd, &init_attr);
-        if (ret != 0) {
-                gf_msg (peer->trans->name, GF_LOG_CRITICAL, errno,
-                        RDMA_MSG_CREAT_QP_FAILED, "%s: could not create QP",
-                        this->name);
-                ret = -1;
-                goto out;
-        }
-
-        peer->qp = peer->cm_id->qp;
-
-        ret = gf_rdma_register_peer (device, peer->qp->qp_num, peer);
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_device_t *device = NULL;
+    int32_t ret = 0;
+    gf_rdma_peer_t *peer = NULL;
+    char *device_name = NULL;
+
+    priv = this->private;
+
+    peer = &priv->peer;
+
+    device_name = (char *)ibv_get_device_name(peer->cm_id->verbs->device);
+    if (device_name == NULL) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_DEVICE_NAME_FAILED,
+               "cannot get "
+               "device_name");
+        goto out;
+    }
+
+    device = gf_rdma_get_device(this, peer->cm_id->verbs, device_name);
+    if (device == NULL) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_DEVICE_FAILED,
+               "cannot get device for "
+               "device %s",
+               device_name);
+        goto out;
+    }
+
+    if (priv->device == NULL) {
+        priv->device = device;
+    }
+
+    struct ibv_qp_init_attr init_attr = {
+        .send_cq = device->send_cq,
+        .recv_cq = device->recv_cq,
+        .srq = device->srq,
+        .cap = {.max_send_wr = peer->send_count,
+                .max_recv_wr = peer->recv_count,
+                .max_send_sge = 2,
+                .max_recv_sge = 1},
+        .qp_type = IBV_QPT_RC};
+
+    ret = rdma_create_qp(peer->cm_id, device->pd, &init_attr);
+    if (ret != 0) {
+        gf_msg(peer->trans->name, GF_LOG_CRITICAL, errno,
+               RDMA_MSG_CREAT_QP_FAILED, "%s: could not create QP", this->name);
+        ret = -1;
+        goto out;
+    }
+
+    peer->qp = peer->cm_id->qp;
+
+    ret = gf_rdma_register_peer(device, peer->qp->qp_num, peer);
 
 out:
-        if (ret == -1)
-                __gf_rdma_destroy_qp (this);
+    if (ret == -1)
+        __gf_rdma_destroy_qp(this);
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-__gf_rdma_teardown (rpc_transport_t *this)
+__gf_rdma_teardown(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_peer_t    *peer = NULL;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_peer_t *peer = NULL;
 
-        priv = this->private;
-        peer = &priv->peer;
+    priv = this->private;
+    peer = &priv->peer;
 
-        if (peer->cm_id && peer->cm_id->qp != NULL) {
-                __gf_rdma_destroy_qp (this);
-        }
+    if (peer->cm_id && peer->cm_id->qp != NULL) {
+        __gf_rdma_destroy_qp(this);
+    }
 
-        if (!list_empty (&priv->peer.ioq)) {
-                __gf_rdma_ioq_flush (peer);
-        }
+    if (!list_empty(&priv->peer.ioq)) {
+        __gf_rdma_ioq_flush(peer);
+    }
 
-        if (peer->cm_id != NULL) {
-                rdma_destroy_id (peer->cm_id);
-                peer->cm_id = NULL;
-        }
+    if (peer->cm_id != NULL) {
+        rdma_destroy_id(peer->cm_id);
+        peer->cm_id = NULL;
+    }
 
-        /* TODO: decrement cq size */
-        return 0;
+    /* TODO: decrement cq size */
+    return 0;
 }
 
-
 static int32_t
-gf_rdma_teardown (rpc_transport_t *this)
+gf_rdma_teardown(rpc_transport_t *this)
 {
-        int32_t ret = 0;
-        gf_rdma_private_t *priv = NULL;
+    int32_t ret = 0;
+    gf_rdma_private_t *priv = NULL;
 
-        if (this == NULL) {
-                goto out;
-        }
+    if (this == NULL) {
+        goto out;
+    }
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_teardown (this);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        ret = __gf_rdma_teardown(this);
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 /*
  * allocates new memory to hold write-chunklist. New memory is needed since
  * write-chunklist will be used while sending reply and the post holding initial
@@ -3334,1756 +3201,1704 @@ out:
  * event is sent to upper layers.
  */
 int32_t
-gf_rdma_get_write_chunklist (char **ptr, gf_rdma_write_array_t **write_ary)
+gf_rdma_get_write_chunklist(char **ptr, gf_rdma_write_array_t **write_ary)
 {
-        gf_rdma_write_array_t *from = NULL, *to = NULL;
-        int32_t                ret  = -1, size = 0, i = 0;
-
-        from = (gf_rdma_write_array_t *) *ptr;
-        if (from->wc_discrim == 0) {
-                ret = 0;
-                goto out;
-        }
-
-        from->wc_nchunks = ntoh32 (from->wc_nchunks);
-
-        size = sizeof (*from)
-                + (sizeof (gf_rdma_write_chunk_t) * from->wc_nchunks);
-
-        to = GF_CALLOC (1, size, gf_common_mt_char);
-        if (to == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        to->wc_discrim = ntoh32 (from->wc_discrim);
-        to->wc_nchunks = from->wc_nchunks;
+    gf_rdma_write_array_t *from = NULL, *to = NULL;
+    int32_t ret = -1, size = 0, i = 0;
 
-        for (i = 0; i < to->wc_nchunks; i++) {
-                to->wc_array[i].wc_target.rs_handle
-                        = ntoh32 (from->wc_array[i].wc_target.rs_handle);
-                to->wc_array[i].wc_target.rs_length
-                        = ntoh32 (from->wc_array[i].wc_target.rs_length);
-                to->wc_array[i].wc_target.rs_offset
-                        = ntoh64 (from->wc_array[i].wc_target.rs_offset);
-        }
-
-        *write_ary = to;
+    from = (gf_rdma_write_array_t *)*ptr;
+    if (from->wc_discrim == 0) {
         ret = 0;
-        *ptr = (char *)&from->wc_array[i].wc_target.rs_handle;
+        goto out;
+    }
+
+    from->wc_nchunks = ntoh32(from->wc_nchunks);
+
+    size = sizeof(*from) + (sizeof(gf_rdma_write_chunk_t) * from->wc_nchunks);
+
+    to = GF_CALLOC(1, size, gf_common_mt_char);
+    if (to == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    to->wc_discrim = ntoh32(from->wc_discrim);
+    to->wc_nchunks = from->wc_nchunks;
+
+    for (i = 0; i < to->wc_nchunks; i++) {
+        to->wc_array[i].wc_target.rs_handle = ntoh32(
+            from->wc_array[i].wc_target.rs_handle);
+        to->wc_array[i].wc_target.rs_length = ntoh32(
+            from->wc_array[i].wc_target.rs_length);
+        to->wc_array[i].wc_target.rs_offset = ntoh64(
+            from->wc_array[i].wc_target.rs_offset);
+    }
+
+    *write_ary = to;
+    ret = 0;
+    *ptr = (char *)&from->wc_array[i].wc_target.rs_handle;
 out:
-        return ret;
+    return ret;
 }
 
-
 /*
  * does not allocate new memory to hold read-chunklist. New memory is not
  * needed, since post is not put back to srq till we've completed all the
  * rdma-reads and hence readchunk-list can point to memory held by post.
  */
 int32_t
-gf_rdma_get_read_chunklist (char **ptr, gf_rdma_read_chunk_t **readch)
+gf_rdma_get_read_chunklist(char **ptr, gf_rdma_read_chunk_t **readch)
 {
-        int32_t               ret   = -1;
-        gf_rdma_read_chunk_t *chunk = NULL;
-        int                   i     = 0;
-
-        chunk = (gf_rdma_read_chunk_t *)*ptr;
-        if (chunk[0].rc_discrim == 0) {
-                ret = 0;
-                goto out;
-        }
+    int32_t ret = -1;
+    gf_rdma_read_chunk_t *chunk = NULL;
+    int i = 0;
 
-        for (i = 0; chunk[i].rc_discrim != 0; i++) {
-                chunk[i].rc_discrim = ntoh32 (chunk[i].rc_discrim);
-                chunk[i].rc_position = ntoh32 (chunk[i].rc_position);
-                chunk[i].rc_target.rs_handle
-                        = ntoh32 (chunk[i].rc_target.rs_handle);
-                chunk[i].rc_target.rs_length
-                        = ntoh32 (chunk[i].rc_target.rs_length);
-                chunk[i].rc_target.rs_offset
-                        = ntoh64 (chunk[i].rc_target.rs_offset);
-        }
-
-        *readch = &chunk[0];
+    chunk = (gf_rdma_read_chunk_t *)*ptr;
+    if (chunk[0].rc_discrim == 0) {
         ret = 0;
-        *ptr = (char *)&chunk[i].rc_discrim;
+        goto out;
+    }
+
+    for (i = 0; chunk[i].rc_discrim != 0; i++) {
+        chunk[i].rc_discrim = ntoh32(chunk[i].rc_discrim);
+        chunk[i].rc_position = ntoh32(chunk[i].rc_position);
+        chunk[i].rc_target.rs_handle = ntoh32(chunk[i].rc_target.rs_handle);
+        chunk[i].rc_target.rs_length = ntoh32(chunk[i].rc_target.rs_length);
+        chunk[i].rc_target.rs_offset = ntoh64(chunk[i].rc_target.rs_offset);
+    }
+
+    *readch = &chunk[0];
+    ret = 0;
+    *ptr = (char *)&chunk[i].rc_discrim;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_decode_error_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                          size_t bytes_in_post)
+gf_rdma_decode_error_msg(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                         size_t bytes_in_post)
 {
-        gf_rdma_header_t *header  = NULL;
-        struct iobuf     *iobuf   = NULL;
-        struct iobref    *iobref  = NULL;
-        int32_t           ret     = -1;
-        struct rpc_msg    rpc_msg = {0, };
-
-        header = (gf_rdma_header_t *)post->buf;
-        header->rm_body.rm_error.rm_type
-                = ntoh32 (header->rm_body.rm_error.rm_type);
-        if (header->rm_body.rm_error.rm_type == ERR_VERS) {
-                header->rm_body.rm_error.rm_version.gf_rdma_vers_low =
-                        ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_low);
-                header->rm_body.rm_error.rm_version.gf_rdma_vers_high =
-                        ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_high);
-        }
-
-        rpc_msg.rm_xid = header->rm_xid;
-        rpc_msg.rm_direction = REPLY;
-        rpc_msg.rm_reply.rp_stat = MSG_DENIED;
-
-        iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, bytes_in_post);
-        if (iobuf == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        post->ctx.iobref = iobref = iobref_new ();
-        if (iobref == NULL) {
-                ret = -1;
-                goto out;
-        }
-
-        iobref_add (iobref, iobuf);
-        iobuf_unref (iobuf);
-
-        ret = rpc_reply_to_xdr (&rpc_msg, iobuf_ptr (iobuf),
-                                iobuf_pagesize (iobuf), &post->ctx.vector[0]);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RPC_REPLY_CREATE_FAILED, "Failed to create "
-                        "RPC reply");
-                goto out;
-        }
-
-        post->ctx.count = 1;
-
-        iobuf = NULL;
-        iobref = NULL;
+    gf_rdma_header_t *header = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    int32_t ret = -1;
+    struct rpc_msg rpc_msg = {
+        0,
+    };
+
+    header = (gf_rdma_header_t *)post->buf;
+    header->rm_body.rm_error.rm_type = ntoh32(header->rm_body.rm_error.rm_type);
+    if (header->rm_body.rm_error.rm_type == ERR_VERS) {
+        header->rm_body.rm_error.rm_version.gf_rdma_vers_low = ntoh32(
+            header->rm_body.rm_error.rm_version.gf_rdma_vers_low);
+        header->rm_body.rm_error.rm_version.gf_rdma_vers_high = ntoh32(
+            header->rm_body.rm_error.rm_version.gf_rdma_vers_high);
+    }
+
+    rpc_msg.rm_xid = header->rm_xid;
+    rpc_msg.rm_direction = REPLY;
+    rpc_msg.rm_reply.rp_stat = MSG_DENIED;
+
+    iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool, bytes_in_post);
+    if (iobuf == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    post->ctx.iobref = iobref = iobref_new();
+    if (iobref == NULL) {
+        ret = -1;
+        goto out;
+    }
+
+    iobref_add(iobref, iobuf);
+    iobuf_unref(iobuf);
+
+    ret = rpc_reply_to_xdr(&rpc_msg, iobuf_ptr(iobuf), iobuf_pagesize(iobuf),
+                           &post->ctx.vector[0]);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_RPC_REPLY_CREATE_FAILED,
+               "Failed to create "
+               "RPC reply");
+        goto out;
+    }
+
+    post->ctx.count = 1;
+
+    iobuf = NULL;
+    iobref = NULL;
 
 out:
-        if (ret == -1) {
-                if (iobuf != NULL) {
-                        iobuf_unref (iobuf);
-                }
+    if (ret == -1) {
+        if (iobuf != NULL) {
+            iobuf_unref(iobuf);
+        }
 
-                if (iobref != NULL) {
-                        iobref_unref (iobref);
-                }
+        if (iobref != NULL) {
+            iobref_unref(iobref);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-gf_rdma_decode_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                    gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
+gf_rdma_decode_msg(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                   gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
 {
-        int32_t                ret        = -1;
-        gf_rdma_header_t      *header     = NULL;
-        gf_rdma_reply_info_t  *reply_info = NULL;
-        char                  *ptr        = NULL;
-        gf_rdma_write_array_t *write_ary  = NULL;
-        size_t                 header_len = 0;
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        ptr = (char *)&header->rm_body.rm_chunks[0];
-
-        ret = gf_rdma_get_read_chunklist (&ptr, readch);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_READ_CHUNK_FAILED, "cannot get read "
-                        "chunklist from msg");
-                goto out;
+    int32_t ret = -1;
+    gf_rdma_header_t *header = NULL;
+    gf_rdma_reply_info_t *reply_info = NULL;
+    char *ptr = NULL;
+    gf_rdma_write_array_t *write_ary = NULL;
+    size_t header_len = 0;
+
+    header = (gf_rdma_header_t *)post->buf;
+
+    ptr = (char *)&header->rm_body.rm_chunks[0];
+
+    ret = gf_rdma_get_read_chunklist(&ptr, readch);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_GET_READ_CHUNK_FAILED,
+               "cannot get read "
+               "chunklist from msg");
+        goto out;
+    }
+
+    /* skip terminator of read-chunklist */
+    ptr = ptr + sizeof(uint32_t);
+
+    ret = gf_rdma_get_write_chunklist(&ptr, &write_ary);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_GET_WRITE_CHUNK_FAILED,
+               "cannot get write "
+               "chunklist from msg");
+        goto out;
+    }
+
+    /* skip terminator of write-chunklist */
+    ptr = ptr + sizeof(uint32_t);
+
+    if (write_ary != NULL) {
+        reply_info = gf_rdma_reply_info_alloc(peer);
+        if (reply_info == NULL) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_REPLY_INFO_ALLOC_FAILED, "reply_info_alloc failed");
+            ret = -1;
+            goto out;
         }
 
-        /* skip terminator of read-chunklist */
-        ptr = ptr + sizeof (uint32_t);
-
-        ret = gf_rdma_get_write_chunklist (&ptr, &write_ary);
+        reply_info->type = gf_rdma_writech;
+        reply_info->wc_array = write_ary;
+        reply_info->rm_xid = header->rm_xid;
+    } else {
+        ret = gf_rdma_get_write_chunklist(&ptr, &write_ary);
         if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_GET_WRITE_CHUNK_FAILED, "cannot get write "
-                        "chunklist from msg");
-                goto out;
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_CHUNKLIST_ERROR,
+                   "cannot get reply "
+                   "chunklist from msg");
+            goto out;
         }
 
-        /* skip terminator of write-chunklist */
-        ptr = ptr + sizeof (uint32_t);
-
         if (write_ary != NULL) {
-                reply_info = gf_rdma_reply_info_alloc (peer);
-                if (reply_info == NULL) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_REPLY_INFO_ALLOC_FAILED,
-                                "reply_info_alloc failed");
-                        ret = -1;
-                        goto out;
-                }
-
-                reply_info->type = gf_rdma_writech;
-                reply_info->wc_array = write_ary;
-                reply_info->rm_xid = header->rm_xid;
-        } else {
-                ret = gf_rdma_get_write_chunklist (&ptr, &write_ary);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_CHUNKLIST_ERROR, "cannot get reply "
-                                "chunklist from msg");
-                        goto out;
-                }
-
-                if (write_ary != NULL) {
-                        reply_info = gf_rdma_reply_info_alloc (peer);
-                        if (reply_info == NULL) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_REPLY_INFO_ALLOC_FAILED,
-                                        "reply_info_alloc_failed");
-                                ret = -1;
-                                goto out;
-                        }
+            reply_info = gf_rdma_reply_info_alloc(peer);
+            if (reply_info == NULL) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_REPLY_INFO_ALLOC_FAILED,
+                       "reply_info_alloc_failed");
+                ret = -1;
+                goto out;
+            }
 
-                        reply_info->type = gf_rdma_replych;
-                        reply_info->wc_array = write_ary;
-                        reply_info->rm_xid = header->rm_xid;
-                }
+            reply_info->type = gf_rdma_replych;
+            reply_info->wc_array = write_ary;
+            reply_info->rm_xid = header->rm_xid;
         }
+    }
 
-        /* skip terminator of reply chunk */
-        ptr = ptr + sizeof (uint32_t);
-        if (header->rm_type != GF_RDMA_NOMSG) {
-                header_len = (long)ptr - (long)post->buf;
-                post->ctx.vector[0].iov_len = (bytes_in_post - header_len);
-
-                post->ctx.hdr_iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool,
-                                                  (bytes_in_post - header_len));
-                if (post->ctx.hdr_iobuf == NULL) {
-                        ret = -1;
-                        goto out;
-                }
+    /* skip terminator of reply chunk */
+    ptr = ptr + sizeof(uint32_t);
+    if (header->rm_type != GF_RDMA_NOMSG) {
+        header_len = (long)ptr - (long)post->buf;
+        post->ctx.vector[0].iov_len = (bytes_in_post - header_len);
 
-                post->ctx.vector[0].iov_base = iobuf_ptr (post->ctx.hdr_iobuf);
-                memcpy (post->ctx.vector[0].iov_base, ptr,
-                        post->ctx.vector[0].iov_len);
-                post->ctx.count = 1;
+        post->ctx.hdr_iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool,
+                                         (bytes_in_post - header_len));
+        if (post->ctx.hdr_iobuf == NULL) {
+            ret = -1;
+            goto out;
         }
 
-        post->ctx.reply_info = reply_info;
-out:
-        if (ret == -1) {
-                if (*readch != NULL) {
-                        GF_FREE (*readch);
-                        *readch = NULL;
-                }
+        post->ctx.vector[0].iov_base = iobuf_ptr(post->ctx.hdr_iobuf);
+        memcpy(post->ctx.vector[0].iov_base, ptr, post->ctx.vector[0].iov_len);
+        post->ctx.count = 1;
+    }
 
-                GF_FREE (write_ary);
+    post->ctx.reply_info = reply_info;
+out:
+    if (ret == -1) {
+        if (*readch != NULL) {
+            GF_FREE(*readch);
+            *readch = NULL;
         }
 
-        return ret;
-}
+        GF_FREE(write_ary);
+    }
 
+    return ret;
+}
 
 /* Assumes only one of either write-chunklist or a reply chunk is present */
 int32_t
-gf_rdma_decode_header (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                       gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
+gf_rdma_decode_header(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                      gf_rdma_read_chunk_t **readch, size_t bytes_in_post)
 {
-        int32_t           ret    = -1;
-        gf_rdma_header_t *header = NULL;
+    int32_t ret = -1;
+    gf_rdma_header_t *header = NULL;
 
-        header = (gf_rdma_header_t *)post->buf;
+    header = (gf_rdma_header_t *)post->buf;
 
-        header->rm_xid = ntoh32 (header->rm_xid);
-        header->rm_vers = ntoh32 (header->rm_vers);
-        header->rm_credit = ntoh32 (header->rm_credit);
-        header->rm_type = ntoh32 (header->rm_type);
+    header->rm_xid = ntoh32(header->rm_xid);
+    header->rm_vers = ntoh32(header->rm_vers);
+    header->rm_credit = ntoh32(header->rm_credit);
+    header->rm_type = ntoh32(header->rm_type);
 
-        switch (header->rm_type) {
+    switch (header->rm_type) {
         case GF_RDMA_MSG:
         case GF_RDMA_NOMSG:
-                ret = gf_rdma_decode_msg (peer, post, readch, bytes_in_post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_ENCODE_ERROR, "cannot decode msg of "
-                                "type (%d)", header->rm_type);
-                }
+            ret = gf_rdma_decode_msg(peer, post, readch, bytes_in_post);
+            if (ret < 0) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_ENCODE_ERROR,
+                       "cannot decode msg of "
+                       "type (%d)",
+                       header->rm_type);
+            }
 
-                break;
+            break;
 
         case GF_RDMA_MSGP:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type "
-                        "GF_RDMA_MSGP should not have been received");
-                ret = -1;
-                break;
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY,
+                   "rdma msg of msg-type "
+                   "GF_RDMA_MSGP should not have been received");
+            ret = -1;
+            break;
 
         case GF_RDMA_DONE:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type "
-                        "GF_RDMA_DONE should not have been received");
-                ret = -1;
-                break;
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY,
+                   "rdma msg of msg-type "
+                   "GF_RDMA_DONE should not have been received");
+            ret = -1;
+            break;
 
         case GF_RDMA_ERROR:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RDMA_ERROR_RECEIVED, "received a msg of type"
-                        " RDMA_ERROR");
-                ret = gf_rdma_decode_error_msg (peer, post, bytes_in_post);
-                break;
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_RDMA_ERROR_RECEIVED,
+                   "received a msg of type"
+                   " RDMA_ERROR");
+            ret = gf_rdma_decode_error_msg(peer, post, bytes_in_post);
+            break;
 
         default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "unknown rdma msg-type (%d)",
-                        header->rm_type);
-        }
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY,
+                   "unknown rdma msg-type (%d)", header->rm_type);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-gf_rdma_do_reads (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                  gf_rdma_read_chunk_t *readch)
+gf_rdma_do_reads(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                 gf_rdma_read_chunk_t *readch)
 {
-        int32_t             ret       = -1, i = 0, count = 0;
-        size_t              size      = 0;
-        char               *ptr       = NULL;
-        struct iobuf       *iobuf     = NULL;
-        gf_rdma_private_t  *priv      = NULL;
-        struct ibv_sge     *list      = NULL;
-        struct ibv_send_wr *wr        = NULL, *bad_wr = NULL;
-        int                 total_ref = 0;
-        priv = peer->trans->private;
-
-        for (i = 0; readch[i].rc_discrim != 0; i++) {
-                size += readch[i].rc_target.rs_length;
-        }
-
-        if (i == 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_CHUNK_TYPE, "message type specified "
-                        "as rdma-read but there are no rdma read-chunks "
-                        "present");
-                goto out;
-        }
-
-        post->ctx.gf_rdma_reads = i;
-        i = 0;
-        iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, size);
-        if (iobuf == NULL) {
-                goto out;
-        }
-
+    int32_t ret = -1, i = 0, count = 0;
+    size_t size = 0;
+    char *ptr = NULL;
+    struct iobuf *iobuf = NULL;
+    gf_rdma_private_t *priv = NULL;
+    struct ibv_sge *list = NULL;
+    struct ibv_send_wr *wr = NULL, *bad_wr = NULL;
+    int total_ref = 0;
+    priv = peer->trans->private;
+
+    for (i = 0; readch[i].rc_discrim != 0; i++) {
+        size += readch[i].rc_target.rs_length;
+    }
+
+    if (i == 0) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_CHUNK_TYPE,
+               "message type specified "
+               "as rdma-read but there are no rdma read-chunks "
+               "present");
+        goto out;
+    }
+
+    post->ctx.gf_rdma_reads = i;
+    i = 0;
+    iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool, size);
+    if (iobuf == NULL) {
+        goto out;
+    }
+
+    if (post->ctx.iobref == NULL) {
+        post->ctx.iobref = iobref_new();
         if (post->ctx.iobref == NULL) {
-                post->ctx.iobref = iobref_new ();
-                if (post->ctx.iobref == NULL) {
-                        iobuf_unref (iobuf);
-                        iobuf = NULL;
-                        goto out;
-                }
+            iobuf_unref(iobuf);
+            iobuf = NULL;
+            goto out;
         }
+    }
 
-        iobref_add (post->ctx.iobref, iobuf);
-        iobuf_unref (iobuf);
+    iobref_add(post->ctx.iobref, iobuf);
+    iobuf_unref(iobuf);
 
-        ptr = iobuf_ptr (iobuf);
-        iobuf = NULL;
+    ptr = iobuf_ptr(iobuf);
+    iobuf = NULL;
 
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->connected) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_DISCONNECTED, "transport not "
-                                "connected to peer (%s), not doing rdma reads",
-                                peer->trans->peerinfo.identifier);
-                        goto unlock;
-                }
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        if (!priv->connected) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_PEER_DISCONNECTED,
+                   "transport not "
+                   "connected to peer (%s), not doing rdma reads",
+                   peer->trans->peerinfo.identifier);
+            goto unlock;
+        }
 
-                list = GF_CALLOC (post->ctx.gf_rdma_reads,
-                                sizeof (struct ibv_sge), gf_common_mt_sge);
+        list = GF_CALLOC(post->ctx.gf_rdma_reads, sizeof(struct ibv_sge),
+                         gf_common_mt_sge);
 
-                if (list == NULL) {
-                       errno =  ENOMEM;
-                       ret = -1;
-                       goto unlock;
-                }
-                wr   = GF_CALLOC (post->ctx.gf_rdma_reads,
-                                sizeof (struct ibv_send_wr), gf_common_mt_wr);
-                if (wr == NULL) {
-                       errno =  ENOMEM;
-                       ret = -1;
-                       goto unlock;
-                }
-                for (i = 0; readch[i].rc_discrim != 0; i++) {
-                        count = post->ctx.count++;
-                        post->ctx.vector[count].iov_base = ptr;
-                        post->ctx.vector[count].iov_len
-                                = readch[i].rc_target.rs_length;
-
-                        ret = __gf_rdma_register_local_mr_for_rdma (peer,
-                                &post->ctx.vector[count], 1, &post->ctx);
-                        if (ret == -1) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                        RDMA_MSG_MR_ALOC_FAILED,
-                                        "registering local memory"
-                                       " for rdma read failed");
-                                goto unlock;
-                        }
-
-                        list[i].addr = (unsigned long)
-                                       post->ctx.vector[count].iov_base;
-                        list[i].length = post->ctx.vector[count].iov_len;
-                        list[i].lkey =
-                                post->ctx.mr[post->ctx.mr_count - 1]->lkey;
-
-                        wr[i].wr_id      =
-                                (unsigned long) gf_rdma_post_ref (post);
-                        wr[i].sg_list    = &list[i];
-                        wr[i].next       = &wr[i+1];
-                        wr[i].num_sge    = 1;
-                        wr[i].opcode     = IBV_WR_RDMA_READ;
-                        wr[i].send_flags = IBV_SEND_SIGNALED;
-                        wr[i].wr.rdma.remote_addr =
-                                readch[i].rc_target.rs_offset;
-                        wr[i].wr.rdma.rkey = readch[i].rc_target.rs_handle;
-
-                        ptr += readch[i].rc_target.rs_length;
-                        total_ref++;
-                }
-                wr[i-1].next = NULL;
-                ret = ibv_post_send (peer->qp, wr, &bad_wr);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_READ_CLIENT_ERROR, "rdma read from "
-                                "client (%s) failed with ret = %d (%s)",
-                                peer->trans->peerinfo.identifier,
-                                ret, (ret > 0) ? strerror (ret) : "");
-
-                        if (!bad_wr) {
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        for (i = 0; i < post->ctx.gf_rdma_reads; i++) {
-                                if (&wr[i] != bad_wr)
-                                        total_ref--;
-                                else
-                                        break;
-                        }
+        if (list == NULL) {
+            errno = ENOMEM;
+            ret = -1;
+            goto unlock;
+        }
+        wr = GF_CALLOC(post->ctx.gf_rdma_reads, sizeof(struct ibv_send_wr),
+                       gf_common_mt_wr);
+        if (wr == NULL) {
+            errno = ENOMEM;
+            ret = -1;
+            goto unlock;
+        }
+        for (i = 0; readch[i].rc_discrim != 0; i++) {
+            count = post->ctx.count++;
+            post->ctx.vector[count].iov_base = ptr;
+            post->ctx.vector[count].iov_len = readch[i].rc_target.rs_length;
+
+            ret = __gf_rdma_register_local_mr_for_rdma(
+                peer, &post->ctx.vector[count], 1, &post->ctx);
+            if (ret == -1) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_MR_ALOC_FAILED,
+                       "registering local memory"
+                       " for rdma read failed");
+                goto unlock;
+            }
+
+            list[i].addr = (unsigned long)post->ctx.vector[count].iov_base;
+            list[i].length = post->ctx.vector[count].iov_len;
+            list[i].lkey = post->ctx.mr[post->ctx.mr_count - 1]->lkey;
+
+            wr[i].wr_id = (unsigned long)gf_rdma_post_ref(post);
+            wr[i].sg_list = &list[i];
+            wr[i].next = &wr[i + 1];
+            wr[i].num_sge = 1;
+            wr[i].opcode = IBV_WR_RDMA_READ;
+            wr[i].send_flags = IBV_SEND_SIGNALED;
+            wr[i].wr.rdma.remote_addr = readch[i].rc_target.rs_offset;
+            wr[i].wr.rdma.rkey = readch[i].rc_target.rs_handle;
+
+            ptr += readch[i].rc_target.rs_length;
+            total_ref++;
+        }
+        wr[i - 1].next = NULL;
+        ret = ibv_post_send(peer->qp, wr, &bad_wr);
+        if (ret) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_READ_CLIENT_ERROR,
+                   "rdma read from "
+                   "client (%s) failed with ret = %d (%s)",
+                   peer->trans->peerinfo.identifier, ret,
+                   (ret > 0) ? strerror(ret) : "");
+
+            if (!bad_wr) {
+                ret = -1;
+                goto unlock;
+            }
 
-                        ret = -1;
-                }
+            for (i = 0; i < post->ctx.gf_rdma_reads; i++) {
+                if (&wr[i] != bad_wr)
+                    total_ref--;
+                else
+                    break;
+            }
 
+            ret = -1;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
+    pthread_mutex_unlock(&priv->write_mutex);
 out:
-        if (list)
-                GF_FREE (list);
-        if (wr)
-                GF_FREE (wr);
+    if (list)
+        GF_FREE(list);
+    if (wr)
+        GF_FREE(wr);
 
-        if (ret == -1) {
-                while (total_ref-- > 0)
-                        gf_rdma_post_unref (post);
+    if (ret == -1) {
+        while (total_ref-- > 0)
+            gf_rdma_post_unref(post);
+    }
 
-        }
-
-        return ret;
+    return ret;
 }
 
-
 int32_t
-gf_rdma_pollin_notify (gf_rdma_peer_t *peer, gf_rdma_post_t *post)
+gf_rdma_pollin_notify(gf_rdma_peer_t *peer, gf_rdma_post_t *post)
 {
-        int32_t                    ret             = -1;
-        enum msg_type              msg_type        = 0;
-        struct rpc_req            *rpc_req         = NULL;
-        gf_rdma_request_context_t *request_context = NULL;
-        rpc_request_info_t         request_info    = {0, };
-        gf_rdma_private_t         *priv            = NULL;
-        uint32_t                  *ptr             = NULL;
-        rpc_transport_pollin_t    *pollin          = NULL;
-
-        if ((peer == NULL) || (post == NULL)) {
-                goto out;
-        }
-
+    int32_t ret = -1;
+    enum msg_type msg_type = 0;
+    struct rpc_req *rpc_req = NULL;
+    gf_rdma_request_context_t *request_context = NULL;
+    rpc_request_info_t request_info = {
+        0,
+    };
+    gf_rdma_private_t *priv = NULL;
+    uint32_t *ptr = NULL;
+    rpc_transport_pollin_t *pollin = NULL;
+
+    if ((peer == NULL) || (post == NULL)) {
+        goto out;
+    }
+
+    if (post->ctx.iobref == NULL) {
+        post->ctx.iobref = iobref_new();
         if (post->ctx.iobref == NULL) {
-                post->ctx.iobref = iobref_new ();
-                if (post->ctx.iobref == NULL) {
-                        goto out;
-                }
-
-                /* handling the case where both hdr and payload of
-                 * GF_FOP_READ_CBK were received in a single iobuf
-                 * because of server sending entire msg as inline without
-                 * doing rdma writes.
-                 */
-                if (post->ctx.hdr_iobuf)
-                        iobref_add (post->ctx.iobref, post->ctx.hdr_iobuf);
+            goto out;
         }
 
-        pollin = rpc_transport_pollin_alloc (peer->trans,
-                                             post->ctx.vector,
-                                             post->ctx.count,
-                                             post->ctx.hdr_iobuf,
-                                             post->ctx.iobref,
-                                             post->ctx.reply_info);
-        if (pollin == NULL) {
-                goto out;
-        }
+        /* handling the case where both hdr and payload of
+         * GF_FOP_READ_CBK were received in a single iobuf
+         * because of server sending entire msg as inline without
+         * doing rdma writes.
+         */
+        if (post->ctx.hdr_iobuf)
+            iobref_add(post->ctx.iobref, post->ctx.hdr_iobuf);
+    }
 
-        ptr = (uint32_t *)pollin->vector[0].iov_base;
+    pollin = rpc_transport_pollin_alloc(peer->trans, post->ctx.vector,
+                                        post->ctx.count, post->ctx.hdr_iobuf,
+                                        post->ctx.iobref, post->ctx.reply_info);
+    if (pollin == NULL) {
+        goto out;
+    }
 
-        request_info.xid = ntoh32 (*ptr);
-        msg_type = ntoh32 (*(ptr + 1));
+    ptr = (uint32_t *)pollin->vector[0].iov_base;
 
-        if (msg_type == REPLY) {
-                ret = rpc_transport_notify (peer->trans,
-                                            RPC_TRANSPORT_MAP_XID_REQUEST,
-                                            &request_info);
-                if (ret == -1) {
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "cannot get request"
-                                      "information from rpc layer");
-                        goto out;
-                }
+    request_info.xid = ntoh32(*ptr);
+    msg_type = ntoh32(*(ptr + 1));
 
-                rpc_req = request_info.rpc_req;
-                if (rpc_req == NULL) {
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "rpc request "
-                                      "structure not found");
-                        ret = -1;
-                        goto out;
-                }
+    if (msg_type == REPLY) {
+        ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MAP_XID_REQUEST,
+                                   &request_info);
+        if (ret == -1) {
+            gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                         "cannot get request"
+                         "information from rpc layer");
+            goto out;
+        }
 
-                request_context = rpc_req->conn_private;
-                rpc_req->conn_private = NULL;
+        rpc_req = request_info.rpc_req;
+        if (rpc_req == NULL) {
+            gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                         "rpc request "
+                         "structure not found");
+            ret = -1;
+            goto out;
+        }
 
-                priv = peer->trans->private;
-                if (request_context != NULL) {
-                        pthread_mutex_lock (&priv->write_mutex);
-                        {
-                                __gf_rdma_request_context_destroy (request_context);
-                        }
-                        pthread_mutex_unlock (&priv->write_mutex);
-                } else {
-                        gf_rdma_quota_put (peer);
-                }
+        request_context = rpc_req->conn_private;
+        rpc_req->conn_private = NULL;
 
-                pollin->is_reply = 1;
+        priv = peer->trans->private;
+        if (request_context != NULL) {
+            pthread_mutex_lock(&priv->write_mutex);
+            {
+                __gf_rdma_request_context_destroy(request_context);
+            }
+            pthread_mutex_unlock(&priv->write_mutex);
+        } else {
+            gf_rdma_quota_put(peer);
         }
 
-        ret = rpc_transport_notify (peer->trans, RPC_TRANSPORT_MSG_RECEIVED,
-                                    pollin);
-        if (ret < 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        TRANS_MSG_TRANSPORT_ERROR, "transport_notify failed");
-        }
+        pollin->is_reply = 1;
+    }
+
+    ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MSG_RECEIVED, pollin);
+    if (ret < 0) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, TRANS_MSG_TRANSPORT_ERROR,
+               "transport_notify failed");
+    }
 
 out:
-        if (pollin != NULL) {
-                pollin->private = NULL;
-                rpc_transport_pollin_destroy (pollin);
-        }
+    if (pollin != NULL) {
+        pollin->private = NULL;
+        rpc_transport_pollin_destroy(pollin);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-gf_rdma_recv_reply (gf_rdma_peer_t *peer, gf_rdma_post_t *post)
+gf_rdma_recv_reply(gf_rdma_peer_t *peer, gf_rdma_post_t *post)
 {
-        int32_t                    ret          = -1;
-        gf_rdma_header_t          *header       = NULL;
-        gf_rdma_reply_info_t      *reply_info   = NULL;
-        gf_rdma_write_array_t     *wc_array     = NULL;
-        int                        i            = 0;
-        uint32_t                  *ptr          = NULL;
-        gf_rdma_request_context_t *ctx          = NULL;
-        rpc_request_info_t         request_info = {0, };
-        struct rpc_req            *rpc_req      = NULL;
-
-        header = (gf_rdma_header_t *)post->buf;
-        reply_info = post->ctx.reply_info;
-
-        /* no write chunklist, just notify upper layers */
-        if (reply_info == NULL) {
-                ret = 0;
-                goto out;
-        }
-
-        wc_array = reply_info->wc_array;
-
-        if (header->rm_type == GF_RDMA_NOMSG) {
-                post->ctx.vector[0].iov_base
-                        = (void *)(long)wc_array->wc_array[0].wc_target.rs_offset;
-                post->ctx.vector[0].iov_len
-                        = wc_array->wc_array[0].wc_target.rs_length;
-
-                post->ctx.count = 1;
-        } else {
-                for (i = 0; i < wc_array->wc_nchunks; i++) {
-                        post->ctx.vector[i + 1].iov_base
-                                = (void *)(long)wc_array->wc_array[i].wc_target.rs_offset;
-                        post->ctx.vector[i + 1].iov_len
-                                = wc_array->wc_array[i].wc_target.rs_length;
-                }
-
-                post->ctx.count += wc_array->wc_nchunks;
-        }
-
-        ptr = (uint32_t *)post->ctx.vector[0].iov_base;
-        request_info.xid = ntoh32 (*ptr);
-
-        ret = rpc_transport_notify (peer->trans,
-                                    RPC_TRANSPORT_MAP_XID_REQUEST,
-                                    &request_info);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        TRANS_MSG_TRANSPORT_ERROR, "cannot get request "
-                        "information (peer:%s) from rpc layer",
-                        peer->trans->peerinfo.identifier);
-                goto out;
-        }
+    int32_t ret = -1;
+    gf_rdma_header_t *header = NULL;
+    gf_rdma_reply_info_t *reply_info = NULL;
+    gf_rdma_write_array_t *wc_array = NULL;
+    int i = 0;
+    uint32_t *ptr = NULL;
+    gf_rdma_request_context_t *ctx = NULL;
+    rpc_request_info_t request_info = {
+        0,
+    };
+    struct rpc_req *rpc_req = NULL;
+
+    header = (gf_rdma_header_t *)post->buf;
+    reply_info = post->ctx.reply_info;
+
+    /* no write chunklist, just notify upper layers */
+    if (reply_info == NULL) {
+        ret = 0;
+        goto out;
+    }
 
-        rpc_req = request_info.rpc_req;
-        if (rpc_req == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_RPC_ST_ERROR, "rpc request structure not "
-                        "found");
-                ret = -1;
-                goto out;
-        }
+    wc_array = reply_info->wc_array;
 
-        ctx = rpc_req->conn_private;
-        if ((post->ctx.iobref == NULL) && ctx->rsp_iobref) {
-                post->ctx.iobref = iobref_ref (ctx->rsp_iobref);
-        }
+    if (header->rm_type == GF_RDMA_NOMSG) {
+        post->ctx.vector[0].iov_base = (void *)(long)wc_array->wc_array[0]
+                                           .wc_target.rs_offset;
+        post->ctx.vector[0].iov_len = wc_array->wc_array[0].wc_target.rs_length;
 
-        ret = 0;
-
-        gf_rdma_reply_info_destroy (reply_info);
+        post->ctx.count = 1;
+    } else {
+        for (i = 0; i < wc_array->wc_nchunks; i++) {
+            post->ctx.vector[i + 1].iov_base =
+                (void *)(long)wc_array->wc_array[i].wc_target.rs_offset;
+            post->ctx.vector[i + 1].iov_len = wc_array->wc_array[i]
+                                                  .wc_target.rs_length;
+        }
+
+        post->ctx.count += wc_array->wc_nchunks;
+    }
+
+    ptr = (uint32_t *)post->ctx.vector[0].iov_base;
+    request_info.xid = ntoh32(*ptr);
+
+    ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MAP_XID_REQUEST,
+                               &request_info);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, TRANS_MSG_TRANSPORT_ERROR,
+               "cannot get request "
+               "information (peer:%s) from rpc layer",
+               peer->trans->peerinfo.identifier);
+        goto out;
+    }
+
+    rpc_req = request_info.rpc_req;
+    if (rpc_req == NULL) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_RPC_ST_ERROR,
+               "rpc request structure not "
+               "found");
+        ret = -1;
+        goto out;
+    }
+
+    ctx = rpc_req->conn_private;
+    if ((post->ctx.iobref == NULL) && ctx->rsp_iobref) {
+        post->ctx.iobref = iobref_ref(ctx->rsp_iobref);
+    }
+
+    ret = 0;
+
+    gf_rdma_reply_info_destroy(reply_info);
 
 out:
-        if (ret == 0) {
-                ret = gf_rdma_pollin_notify (peer, post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_POLL_IN_NOTIFY_FAILED,
-                                "pollin notify failed");
-                }
+    if (ret == 0) {
+        ret = gf_rdma_pollin_notify(peer, post);
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_POLL_IN_NOTIFY_FAILED, "pollin notify failed");
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_recv_request (gf_rdma_peer_t *peer, gf_rdma_post_t *post,
-                      gf_rdma_read_chunk_t *readch)
+gf_rdma_recv_request(gf_rdma_peer_t *peer, gf_rdma_post_t *post,
+                     gf_rdma_read_chunk_t *readch)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        if (readch != NULL) {
-                ret = gf_rdma_do_reads (peer, post, readch);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_READ_FAILED,
-                                "rdma read from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
-        } else {
-                ret = gf_rdma_pollin_notify (peer, post);
-                if (ret == -1) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_POLL_IN_NOTIFY_FAILED,
-                                "pollin notification failed");
-                }
+    if (readch != NULL) {
+        ret = gf_rdma_do_reads(peer, post, readch);
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_PEER_READ_FAILED, "rdma read from peer (%s) failed",
+                   peer->trans->peerinfo.identifier);
         }
+    } else {
+        ret = gf_rdma_pollin_notify(peer, post);
+        if (ret == -1) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_POLL_IN_NOTIFY_FAILED,
+                   "pollin notification failed");
+        }
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-gf_rdma_process_recv (gf_rdma_peer_t *peer, struct ibv_wc *wc)
+gf_rdma_process_recv(gf_rdma_peer_t *peer, struct ibv_wc *wc)
 {
-        gf_rdma_post_t       *post     = NULL;
-        gf_rdma_read_chunk_t *readch   = NULL;
-        int                   ret      = -1;
-        uint32_t             *ptr      = NULL;
-        enum msg_type         msg_type = 0;
-        gf_rdma_header_t     *header   = NULL;
-        gf_rdma_private_t    *priv     = NULL;
-
-        post = (gf_rdma_post_t *) (long) wc->wr_id;
-        if (post == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_POST_MISSING, "no post found in successful "
-                        "work completion element");
-                goto out;
-        }
-
-        ret = gf_rdma_decode_header (peer, post, &readch, wc->byte_len);
-        if (ret == -1) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_HEADER_DECODE_FAILED, "decoding of header "
-                        "failed");
-                goto out;
-        }
-
-        header = (gf_rdma_header_t *)post->buf;
-
-        priv = peer->trans->private;
-
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                if (!priv->peer.quota_set) {
-                        priv->peer.quota_set = 1;
-
-                        /* Initially peer.quota is set to 1 as per RFC 5666. We
-                         * have to account for the quota used while sending
-                         * first msg (which may or may not be returned to pool
-                         * at this point) while deriving peer.quota from
-                         * header->rm_credit. Hence the arithmetic below,
-                         * instead of directly setting it to header->rm_credit.
-                         */
-                        priv->peer.quota = header->rm_credit
-                                - (1 - priv->peer.quota);
-                }
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
-
-        switch (header->rm_type) {
+    gf_rdma_post_t *post = NULL;
+    gf_rdma_read_chunk_t *readch = NULL;
+    int ret = -1;
+    uint32_t *ptr = NULL;
+    enum msg_type msg_type = 0;
+    gf_rdma_header_t *header = NULL;
+    gf_rdma_private_t *priv = NULL;
+
+    post = (gf_rdma_post_t *)(long)wc->wr_id;
+    if (post == NULL) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_MISSING,
+               "no post found in successful "
+               "work completion element");
+        goto out;
+    }
+
+    ret = gf_rdma_decode_header(peer, post, &readch, wc->byte_len);
+    if (ret == -1) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+               RDMA_MSG_HEADER_DECODE_FAILED,
+               "decoding of header "
+               "failed");
+        goto out;
+    }
+
+    header = (gf_rdma_header_t *)post->buf;
+
+    priv = peer->trans->private;
+
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        if (!priv->peer.quota_set) {
+            priv->peer.quota_set = 1;
+
+            /* Initially peer.quota is set to 1 as per RFC 5666. We
+             * have to account for the quota used while sending
+             * first msg (which may or may not be returned to pool
+             * at this point) while deriving peer.quota from
+             * header->rm_credit. Hence the arithmetic below,
+             * instead of directly setting it to header->rm_credit.
+             */
+            priv->peer.quota = header->rm_credit - (1 - priv->peer.quota);
+        }
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
+
+    switch (header->rm_type) {
         case GF_RDMA_MSG:
-                ptr = (uint32_t *)post->ctx.vector[0].iov_base;
-                msg_type = ntoh32 (*(ptr + 1));
-                break;
+            ptr = (uint32_t *)post->ctx.vector[0].iov_base;
+            msg_type = ntoh32(*(ptr + 1));
+            break;
 
         case GF_RDMA_NOMSG:
-                if (readch != NULL) {
-                        msg_type = CALL;
-                } else {
-                        msg_type = REPLY;
-                }
-                break;
+            if (readch != NULL) {
+                msg_type = CALL;
+            } else {
+                msg_type = REPLY;
+            }
+            break;
 
         case GF_RDMA_ERROR:
-                if (header->rm_body.rm_error.rm_type == ERR_CHUNK) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_RDMA_ERROR_RECEIVED,
-                                "peer (%s), couldn't encode or decode the msg "
-                                "properly or write chunks were not provided "
-                                "for replies that were bigger than "
-                                "RDMA_INLINE_THRESHOLD (%d)",
-                                peer->trans->peerinfo.identifier,
-                                GLUSTERFS_RDMA_INLINE_THRESHOLD);
-                        ret = gf_rdma_pollin_notify (peer, post);
-                        if (ret == -1) {
-                                gf_msg_debug (GF_RDMA_LOG_NAME, 0, "pollin "
-                                              "notification failed");
-                        }
-                        goto out;
-                } else {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
-                                TRANS_MSG_TRANSPORT_ERROR, "an error has "
-                                "happened while transmission of msg, "
-                                "disconnecting the transport");
-                        ret = -1;
-                        goto out;
+            if (header->rm_body.rm_error.rm_type == ERR_CHUNK) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_RDMA_ERROR_RECEIVED,
+                       "peer (%s), couldn't encode or decode the msg "
+                       "properly or write chunks were not provided "
+                       "for replies that were bigger than "
+                       "RDMA_INLINE_THRESHOLD (%d)",
+                       peer->trans->peerinfo.identifier,
+                       GLUSTERFS_RDMA_INLINE_THRESHOLD);
+                ret = gf_rdma_pollin_notify(peer, post);
+                if (ret == -1) {
+                    gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                                 "pollin "
+                                 "notification failed");
                 }
+                goto out;
+            } else {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
+                       TRANS_MSG_TRANSPORT_ERROR,
+                       "an error has "
+                       "happened while transmission of msg, "
+                       "disconnecting the transport");
+                ret = -1;
+                goto out;
+            }
 
         default:
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INVALID_ENTRY, "invalid rdma msg-type (%d)",
-                        header->rm_type);
-                goto out;
-        }
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY,
+                   "invalid rdma msg-type (%d)", header->rm_type);
+            goto out;
+    }
 
-        if (msg_type == CALL) {
-                ret = gf_rdma_recv_request (peer, post, readch);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_REQ_FAILED, "receiving a request"
-                                " from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
-        } else {
-                ret = gf_rdma_recv_reply (peer, post);
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_PEER_REP_FAILED, "receiving a reply "
-                                "from peer (%s) failed",
-                                peer->trans->peerinfo.identifier);
-                }
+    if (msg_type == CALL) {
+        ret = gf_rdma_recv_request(peer, post, readch);
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_PEER_REQ_FAILED,
+                   "receiving a request"
+                   " from peer (%s) failed",
+                   peer->trans->peerinfo.identifier);
+        }
+    } else {
+        ret = gf_rdma_recv_reply(peer, post);
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                   RDMA_MSG_PEER_REP_FAILED,
+                   "receiving a reply "
+                   "from peer (%s) failed",
+                   peer->trans->peerinfo.identifier);
         }
+    }
 
 out:
-        if (ret == -1) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
+    if (ret == -1) {
+        rpc_transport_disconnect(peer->trans, _gf_false);
+    }
 
-        return;
+    return;
 }
 
 void *
-gf_rdma_async_event_thread (void *context)
+gf_rdma_async_event_thread(void *context)
 {
-        struct ibv_async_event event;
-        int ret;
-
-        while (1) {
-                do {
-                        ret = ibv_get_async_event((struct ibv_context *)context,
-                                                  &event);
-
-                        if (ret && errno != EINTR) {
-                                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                                        RDMA_MSG_EVENT_ERROR, "Error getting "
-                                        "event");
-                        }
-                } while (ret && errno == EINTR);
+    struct ibv_async_event event;
+    int ret;
 
-                switch (event.event_type) {
-                case IBV_EVENT_SRQ_LIMIT_REACHED:
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_EVENT_SRQ_LIMIT_REACHED, "received "
-                                "srq_limit reached");
-                        break;
-
-                default:
-                        gf_msg_debug (GF_RDMA_LOG_NAME, 0, "event (%d) "
-                                      "received", event.event_type);
-                        break;
-                }
+    while (1) {
+        do {
+            ret = ibv_get_async_event((struct ibv_context *)context, &event);
+
+            if (ret && errno != EINTR) {
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+                       RDMA_MSG_EVENT_ERROR,
+                       "Error getting "
+                       "event");
+            }
+        } while (ret && errno == EINTR);
+
+        switch (event.event_type) {
+            case IBV_EVENT_SRQ_LIMIT_REACHED:
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_EVENT_SRQ_LIMIT_REACHED,
+                       "received "
+                       "srq_limit reached");
+                break;
 
-                ibv_ack_async_event(&event);
+            default:
+                gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                             "event (%d) "
+                             "received",
+                             event.event_type);
+                break;
         }
 
-        return 0;
-}
+        ibv_ack_async_event(&event);
+    }
 
+    return 0;
+}
 
 static void *
-gf_rdma_recv_completion_proc (void *data)
+gf_rdma_recv_completion_proc(void *data)
 {
-        struct ibv_comp_channel *chan      = NULL;
-        gf_rdma_device_t        *device    = NULL;;
-        gf_rdma_post_t          *post      = NULL;
-        gf_rdma_peer_t          *peer      = NULL;
-        struct ibv_cq           *event_cq  = NULL;
-        struct ibv_wc            wc[10]    = {{0},};
-        void                    *event_ctx = NULL;
-        int32_t                  ret       = 0;
-        int32_t                  num_wr    = 0, index = 0;
-        uint8_t                  failed    = 0;
-
-        chan = data;
-
-        while (1) {
-                failed = 0;
-                ret = ibv_get_cq_event (chan, &event_cq, &event_ctx);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_GET_CQ_FAILED,
-                                "ibv_get_cq_event failed, terminating recv "
-                                "thread %d (%d)", ret, errno);
-                        continue;
-                }
+    struct ibv_comp_channel *chan = NULL;
+    gf_rdma_device_t *device = NULL;
+    ;
+    gf_rdma_post_t *post = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    struct ibv_cq *event_cq = NULL;
+    struct ibv_wc wc[10] = {
+        {0},
+    };
+    void *event_ctx = NULL;
+    int32_t ret = 0;
+    int32_t num_wr = 0, index = 0;
+    uint8_t failed = 0;
+
+    chan = data;
+
+    while (1) {
+        failed = 0;
+        ret = ibv_get_cq_event(chan, &event_cq, &event_ctx);
+        if (ret) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_GET_CQ_FAILED,
+                   "ibv_get_cq_event failed, terminating recv "
+                   "thread %d (%d)",
+                   ret, errno);
+            continue;
+        }
 
-                device = event_ctx;
+        device = event_ctx;
 
-                ret = ibv_req_notify_cq (event_cq, 0);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
-                                "ibv_req_notify_cq on %s failed, terminating "
-                                "recv thread: %d (%d)",
-                                device->device_name, ret, errno);
-                        continue;
-                }
+        ret = ibv_req_notify_cq(event_cq, 0);
+        if (ret) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
+                   "ibv_req_notify_cq on %s failed, terminating "
+                   "recv thread: %d (%d)",
+                   device->device_name, ret, errno);
+            continue;
+        }
 
-                device = (gf_rdma_device_t *) event_ctx;
-
-                while (!failed &&
-                       (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) {
-
-                        for (index = 0; index < num_wr && !failed; index++) {
-                                post = (gf_rdma_post_t *) (long)
-                                        wc[index].wr_id;
-
-                                pthread_mutex_lock (&device->qpreg.lock);
-                                {
-                                        peer = __gf_rdma_lookup_peer (device,
-                                                           wc[index].qp_num);
-
-                                        /*
-                                         * keep a refcount on transport so that it
-                                         * does not get freed because of some error
-                                         * indicated by wc.status till we are done
-                                         * with usage of peer and thereby that of
-                                         * trans.
-                                         */
-                                        if (peer != NULL) {
-                                                rpc_transport_ref (peer->trans);
-                                        }
-                                }
-                                pthread_mutex_unlock (&device->qpreg.lock);
-
-                                if (wc[index].status != IBV_WC_SUCCESS) {
-                                        gf_msg (GF_RDMA_LOG_NAME,
-                                                GF_LOG_ERROR, 0,
-                                                RDMA_MSG_RECV_ERROR, "recv work "
-                                                "request on `%s' returned error (%d)",
-                                                device->device_name,
-                                                wc[index].status);
-                                                failed = 1;
-                                        if (peer) {
-                                                ibv_ack_cq_events (event_cq, num_wr);
-                                                rpc_transport_disconnect (peer->trans,
-                                                                          _gf_false);
-                                                rpc_transport_unref (peer->trans);
-                                        }
-
-                                        if (post) {
-                                                gf_rdma_post_unref (post);
-                                        }
-
-                                        continue;
-                                }
-
-                                if (peer) {
-                                        gf_rdma_process_recv (peer,
-                                                        &wc[index]);
-                                        rpc_transport_unref (peer->trans);
-                                } else {
-                                        gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-                                                      "could not lookup peer "
-                                                      "for qp_num: %d",
-                                                      wc[index].qp_num);
-                                }
-
-                                gf_rdma_post_unref (post);
-                        }
+        device = (gf_rdma_device_t *)event_ctx;
+
+        while (!failed && (num_wr = ibv_poll_cq(event_cq, 10, wc)) > 0) {
+            for (index = 0; index < num_wr && !failed; index++) {
+                post = (gf_rdma_post_t *)(long)wc[index].wr_id;
+
+                pthread_mutex_lock(&device->qpreg.lock);
+                {
+                    peer = __gf_rdma_lookup_peer(device, wc[index].qp_num);
+
+                    /*
+                     * keep a refcount on transport so that it
+                     * does not get freed because of some error
+                     * indicated by wc.status till we are done
+                     * with usage of peer and thereby that of
+                     * trans.
+                     */
+                    if (peer != NULL) {
+                        rpc_transport_ref(peer->trans);
+                    }
+                }
+                pthread_mutex_unlock(&device->qpreg.lock);
+
+                if (wc[index].status != IBV_WC_SUCCESS) {
+                    gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0,
+                           RDMA_MSG_RECV_ERROR,
+                           "recv work "
+                           "request on `%s' returned error (%d)",
+                           device->device_name, wc[index].status);
+                    failed = 1;
+                    if (peer) {
+                        ibv_ack_cq_events(event_cq, num_wr);
+                        rpc_transport_disconnect(peer->trans, _gf_false);
+                        rpc_transport_unref(peer->trans);
+                    }
+
+                    if (post) {
+                        gf_rdma_post_unref(post);
+                    }
+
+                    continue;
                 }
 
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_POLL_CQ_ERROR,
-                                "ibv_poll_cq on `%s' returned error "
-                                "(ret = %d, errno = %d)",
-                                device->device_name, ret, errno);
-                        continue;
+                if (peer) {
+                    gf_rdma_process_recv(peer, &wc[index]);
+                    rpc_transport_unref(peer->trans);
+                } else {
+                    gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                                 "could not lookup peer "
+                                 "for qp_num: %d",
+                                 wc[index].qp_num);
                 }
-                if (!failed)
-                        ibv_ack_cq_events (event_cq, num_wr);
+
+                gf_rdma_post_unref(post);
+            }
         }
 
-        return NULL;
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_POLL_CQ_ERROR,
+                   "ibv_poll_cq on `%s' returned error "
+                   "(ret = %d, errno = %d)",
+                   device->device_name, ret, errno);
+            continue;
+        }
+        if (!failed)
+            ibv_ack_cq_events(event_cq, num_wr);
+    }
+
+    return NULL;
 }
 
-
 void
-gf_rdma_handle_failed_send_completion (gf_rdma_peer_t *peer, struct ibv_wc *wc)
+gf_rdma_handle_failed_send_completion(gf_rdma_peer_t *peer, struct ibv_wc *wc)
 {
-        gf_rdma_post_t    *post   = NULL;
-        gf_rdma_device_t  *device = NULL;
-        gf_rdma_private_t *priv   = NULL;
-
-        if (peer != NULL) {
-                priv = peer->trans->private;
-                if (priv != NULL) {
-                        device = priv->device;
-                }
-        }
-
+    gf_rdma_post_t *post = NULL;
+    gf_rdma_device_t *device = NULL;
+    gf_rdma_private_t *priv = NULL;
 
-        post = (gf_rdma_post_t *) (long) wc->wr_id;
-
-        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                RDMA_MSG_RDMA_HANDLE_FAILED,
-                "send work request on `%s' returned error "
-                "wc.status = %d, wc.vendor_err = %d, post->buf = %p, "
-                "wc.byte_len = %d, post->reused = %d",
-                (device != NULL) ? device->device_name : NULL, wc->status,
-                wc->vendor_err, post->buf, wc->byte_len, post->reused);
-
-        if (wc->status == IBV_WC_RETRY_EXC_ERR) {
-                gf_msg ("rdma", GF_LOG_ERROR, 0, TRANS_MSG_TIMEOUT_EXCEEDED,
-                        "connection between client and server not working. "
-                        "check by running 'ibv_srq_pingpong'. also make sure "
-                        "subnet manager is running (eg: 'opensm'), or check "
-                        "if rdma port is valid (or active) by running "
-                        "'ibv_devinfo'. contact Gluster Support Team if the "
-                        "problem persists.");
-        }
-
-        if (peer) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
-
-        return;
+    if (peer != NULL) {
+        priv = peer->trans->private;
+        if (priv != NULL) {
+            device = priv->device;
+        }
+    }
+
+    post = (gf_rdma_post_t *)(long)wc->wr_id;
+
+    gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_RDMA_HANDLE_FAILED,
+           "send work request on `%s' returned error "
+           "wc.status = %d, wc.vendor_err = %d, post->buf = %p, "
+           "wc.byte_len = %d, post->reused = %d",
+           (device != NULL) ? device->device_name : NULL, wc->status,
+           wc->vendor_err, post->buf, wc->byte_len, post->reused);
+
+    if (wc->status == IBV_WC_RETRY_EXC_ERR) {
+        gf_msg("rdma", GF_LOG_ERROR, 0, TRANS_MSG_TIMEOUT_EXCEEDED,
+               "connection between client and server not working. "
+               "check by running 'ibv_srq_pingpong'. also make sure "
+               "subnet manager is running (eg: 'opensm'), or check "
+               "if rdma port is valid (or active) by running "
+               "'ibv_devinfo'. contact Gluster Support Team if the "
+               "problem persists.");
+    }
+
+    if (peer) {
+        rpc_transport_disconnect(peer->trans, _gf_false);
+    }
+
+    return;
 }
 
-
 void
-gf_rdma_handle_successful_send_completion (gf_rdma_peer_t *peer,
-                                           struct ibv_wc *wc)
+gf_rdma_handle_successful_send_completion(gf_rdma_peer_t *peer,
+                                          struct ibv_wc *wc)
 {
-        gf_rdma_post_t   *post   = NULL;
-        int               reads  = 0, ret = 0;
-        gf_rdma_header_t *header = NULL;
-
-        if (wc->opcode != IBV_WC_RDMA_READ) {
-                goto out;
-        }
+    gf_rdma_post_t *post = NULL;
+    int reads = 0, ret = 0;
+    gf_rdma_header_t *header = NULL;
 
-        post = (gf_rdma_post_t *)(long) wc->wr_id;
+    if (wc->opcode != IBV_WC_RDMA_READ) {
+        goto out;
+    }
 
-        pthread_mutex_lock (&post->lock);
-        {
-                reads = --post->ctx.gf_rdma_reads;
-        }
-        pthread_mutex_unlock (&post->lock);
+    post = (gf_rdma_post_t *)(long)wc->wr_id;
 
-        if (reads != 0) {
-                /* if it is not the last rdma read, we've got nothing to do */
-                goto out;
-        }
+    pthread_mutex_lock(&post->lock);
+    {
+        reads = --post->ctx.gf_rdma_reads;
+    }
+    pthread_mutex_unlock(&post->lock);
 
-        header = (gf_rdma_header_t *)post->buf;
+    if (reads != 0) {
+        /* if it is not the last rdma read, we've got nothing to do */
+        goto out;
+    }
 
-        if (header->rm_type == GF_RDMA_NOMSG) {
-                post->ctx.count = 1;
-                post->ctx.vector[0].iov_len += post->ctx.vector[1].iov_len;
-        }
-        /*
-         * if reads performed as vectored, then all the buffers are actually
-         * contiguous memory, so that we can use it as single vector, instead
-         * of multiple.
-         */
-        while (post->ctx.count > 2) {
-                post->ctx.vector[1].iov_len +=
-                        post->ctx.vector[post->ctx.count-1].iov_len;
-                post->ctx.count--;
-        }
+    header = (gf_rdma_header_t *)post->buf;
 
-        ret = gf_rdma_pollin_notify (peer, post);
-        if ((ret == -1) && (peer != NULL)) {
-                rpc_transport_disconnect (peer->trans, _gf_false);
-        }
+    if (header->rm_type == GF_RDMA_NOMSG) {
+        post->ctx.count = 1;
+        post->ctx.vector[0].iov_len += post->ctx.vector[1].iov_len;
+    }
+    /*
+     * if reads performed as vectored, then all the buffers are actually
+     * contiguous memory, so that we can use it as single vector, instead
+     * of multiple.
+     */
+    while (post->ctx.count > 2) {
+        post->ctx.vector[1].iov_len += post->ctx.vector[post->ctx.count - 1]
+                                           .iov_len;
+        post->ctx.count--;
+    }
+
+    ret = gf_rdma_pollin_notify(peer, post);
+    if ((ret == -1) && (peer != NULL)) {
+        rpc_transport_disconnect(peer->trans, _gf_false);
+    }
 
 out:
-        return;
+    return;
 }
 
-
 static void *
-gf_rdma_send_completion_proc (void *data)
+gf_rdma_send_completion_proc(void *data)
 {
-        struct ibv_comp_channel *chan       = NULL;
-        gf_rdma_post_t          *post       = NULL;
-        gf_rdma_peer_t          *peer       = NULL;
-        struct ibv_cq           *event_cq   = NULL;
-        void                    *event_ctx  = NULL;
-        gf_rdma_device_t        *device     = NULL;
-        struct ibv_wc            wc[10]     = {{0},};
-        char                     is_request = 0;
-        int32_t                  ret        = 0, quota_ret = 0, num_wr = 0;
-        int32_t                  index      = 0, failed = 0;
-        chan = data;
-        while (1) {
-                failed = 0;
-                ret = ibv_get_cq_event (chan, &event_cq, &event_ctx);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_GET_CQ_FAILED,
-                                "ibv_get_cq_event on failed, terminating "
-                                "send thread: %d (%d)", ret, errno);
-                        continue;
-                }
+    struct ibv_comp_channel *chan = NULL;
+    gf_rdma_post_t *post = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    struct ibv_cq *event_cq = NULL;
+    void *event_ctx = NULL;
+    gf_rdma_device_t *device = NULL;
+    struct ibv_wc wc[10] = {
+        {0},
+    };
+    char is_request = 0;
+    int32_t ret = 0, quota_ret = 0, num_wr = 0;
+    int32_t index = 0, failed = 0;
+    chan = data;
+    while (1) {
+        failed = 0;
+        ret = ibv_get_cq_event(chan, &event_cq, &event_ctx);
+        if (ret) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_GET_CQ_FAILED,
+                   "ibv_get_cq_event on failed, terminating "
+                   "send thread: %d (%d)",
+                   ret, errno);
+            continue;
+        }
+
+        device = event_ctx;
+
+        ret = ibv_req_notify_cq(event_cq, 0);
+        if (ret) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
+                   "ibv_req_notify_cq on %s failed, terminating "
+                   "send thread: %d (%d)",
+                   device->device_name, ret, errno);
+            continue;
+        }
 
-                device = event_ctx;
+        while (!failed && (num_wr = ibv_poll_cq(event_cq, 10, wc)) > 0) {
+            for (index = 0; index < num_wr && !failed; index++) {
+                post = (gf_rdma_post_t *)(long)wc[index].wr_id;
 
-                ret = ibv_req_notify_cq (event_cq, 0);
-                if (ret) {
-                        gf_msg (GF_RDMA_LOG_NAME,  GF_LOG_ERROR, errno,
-                                RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED,
-                                "ibv_req_notify_cq on %s failed, terminating "
-                                "send thread: %d (%d)",
-                                device->device_name, ret, errno);
-                        continue;
+                pthread_mutex_lock(&device->qpreg.lock);
+                {
+                    peer = __gf_rdma_lookup_peer(device, wc[index].qp_num);
+
+                    /*
+                     * keep a refcount on transport so that it
+                     * does not get freed because of some error
+                     * indicated by wc.status, till we are done
+                     * with usage of peer and thereby that of trans.
+                     */
+                    if (peer != NULL) {
+                        rpc_transport_ref(peer->trans);
+                    }
                 }
+                pthread_mutex_unlock(&device->qpreg.lock);
 
-                while (!failed &&
-                       (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) {
-                        for (index = 0; index < num_wr && !failed; index++) {
-                                post = (gf_rdma_post_t *) (long)
-                                        wc[index].wr_id;
-
-                                pthread_mutex_lock (&device->qpreg.lock);
-                                {
-                                        peer = __gf_rdma_lookup_peer (device,
-                                                        wc[index].qp_num);
-
-                                /*
-                                 * keep a refcount on transport so that it
-                                 * does not get freed because of some error
-                                 * indicated by wc.status, till we are done
-                                 * with usage of peer and thereby that of trans.
-                                 */
-                                        if (peer != NULL) {
-                                                rpc_transport_ref (peer->trans);
-                                        }
-                                }
-                                pthread_mutex_unlock (&device->qpreg.lock);
-
-                                if (wc[index].status != IBV_WC_SUCCESS) {
-                                        ibv_ack_cq_events (event_cq, num_wr);
-                                        failed = 1;
-                                        gf_rdma_handle_failed_send_completion
-                                                (peer, &wc[index]);
-                                } else {
-                                      gf_rdma_handle_successful_send_completion
-                                                (peer, &wc[index]);
-                                }
-
-                                if (post) {
-                                        is_request = post->ctx.is_request;
-
-                                        ret = gf_rdma_post_unref (post);
-                                        if ((ret == 0)
-                                        && (wc[index].status == IBV_WC_SUCCESS)
-                                        && !is_request
-                                        && (post->type == GF_RDMA_SEND_POST)
-                                        && (peer != NULL)) {
-                                        /* An GF_RDMA_RECV_POST can end up in
-                                         * gf_rdma_send_completion_proc for
-                                         * rdma-reads, and we do not take
-                                         * quota for getting an GF_RDMA_RECV_POST.
-                                         */
-
-                                        /*
-                                         * if it is request, quota is returned
-                                         * after reply has come.
-                                         */
-                                                quota_ret = gf_rdma_quota_put
-                                                        (peer);
-                                                if (quota_ret < 0) {
-                                                        gf_msg_debug ("rdma",
-                                                        0, "failed to send "
-                                                        "message");
-                                                }
-                                        }
-                                }
-
-                                if (peer) {
-                                        rpc_transport_unref (peer->trans);
-                                } else {
-                                        gf_msg_debug (GF_RDMA_LOG_NAME, 0,
-                                        "could not lookup peer for qp_num: %d",
-                                        wc[index].qp_num);
-
-                                }
+                if (wc[index].status != IBV_WC_SUCCESS) {
+                    ibv_ack_cq_events(event_cq, num_wr);
+                    failed = 1;
+                    gf_rdma_handle_failed_send_completion(peer, &wc[index]);
+                } else {
+                    gf_rdma_handle_successful_send_completion(peer, &wc[index]);
+                }
+
+                if (post) {
+                    is_request = post->ctx.is_request;
+
+                    ret = gf_rdma_post_unref(post);
+                    if ((ret == 0) && (wc[index].status == IBV_WC_SUCCESS) &&
+                        !is_request && (post->type == GF_RDMA_SEND_POST) &&
+                        (peer != NULL)) {
+                        /* An GF_RDMA_RECV_POST can end up in
+                         * gf_rdma_send_completion_proc for
+                         * rdma-reads, and we do not take
+                         * quota for getting an GF_RDMA_RECV_POST.
+                         */
+
+                        /*
+                         * if it is request, quota is returned
+                         * after reply has come.
+                         */
+                        quota_ret = gf_rdma_quota_put(peer);
+                        if (quota_ret < 0) {
+                            gf_msg_debug("rdma", 0,
+                                         "failed to send "
+                                         "message");
                         }
+                    }
                 }
 
-                if (ret < 0) {
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
-                        RDMA_MSG_IBV_POLL_CQ_ERROR,
-                        "ibv_poll_cq on `%s' returned error (ret = %d,"
-                        " errno = %d)",
-                        device->device_name, ret, errno);
-                        continue;
-               }
-               if (!failed)
-                       ibv_ack_cq_events (event_cq, num_wr);
+                if (peer) {
+                    rpc_transport_unref(peer->trans);
+                } else {
+                    gf_msg_debug(GF_RDMA_LOG_NAME, 0,
+                                 "could not lookup peer for qp_num: %d",
+                                 wc[index].qp_num);
+                }
+            }
         }
 
-        return NULL;
+        if (ret < 0) {
+            gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno,
+                   RDMA_MSG_IBV_POLL_CQ_ERROR,
+                   "ibv_poll_cq on `%s' returned error (ret = %d,"
+                   " errno = %d)",
+                   device->device_name, ret, errno);
+            continue;
+        }
+        if (!failed)
+            ibv_ack_cq_events(event_cq, num_wr);
+    }
+
+    return NULL;
 }
 
-
 static void
-gf_rdma_options_init (rpc_transport_t *this)
+gf_rdma_options_init(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv    = NULL;
-        gf_rdma_options_t *options = NULL;
-        int32_t            mtu     = 0;
-        data_t            *temp    = NULL;
-
-        /* TODO: validate arguments from options below */
-
-        priv = this->private;
-        options = &priv->options;
-        options->send_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4;  512 KB*/
-        options->recv_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4;  512 KB*/
-        options->send_count = 4096;
-        options->recv_count = 4096;
-        options->attr_timeout = GF_RDMA_TIMEOUT;
-        options->attr_retry_cnt = GF_RDMA_RETRY_CNT;
-        options->attr_rnr_retry = GF_RDMA_RNR_RETRY;
-
-        temp = dict_get (this->options, "transport.listen-backlog");
-        if (temp)
-                options->backlog = data_to_uint32 (temp);
-        else
-                options->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
-
-        temp = dict_get (this->options,
-                         "transport.rdma.work-request-send-count");
-        if (temp)
-                options->send_count = data_to_int32 (temp);
-
-        temp = dict_get (this->options,
-                         "transport.rdma.work-request-recv-count");
-        if (temp)
-                options->recv_count = data_to_int32 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-timeout");
-
-        if (temp)
-                options->attr_timeout = data_to_uint8 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-retry-cnt");
-
-        if (temp)
-                options->attr_retry_cnt = data_to_uint8 (temp);
-
-        temp = dict_get (this->options, "transport.rdma.attr-rnr-retry");
-
-        if (temp)
-                options->attr_rnr_retry = data_to_uint8 (temp);
-
-        options->port = 1;
-        temp = dict_get (this->options,
-                         "transport.rdma.port");
-        if (temp)
-                options->port = data_to_uint64 (temp);
-
-        options->mtu = mtu = IBV_MTU_2048;
-        temp = dict_get (this->options,
-                         "transport.rdma.mtu");
-        if (temp)
-                mtu = data_to_int32 (temp);
-        switch (mtu) {
-
-        case 256: options->mtu = IBV_MTU_256;
-                break;
-
-        case 512: options->mtu = IBV_MTU_512;
-                break;
-
-        case 1024: options->mtu = IBV_MTU_1024;
-                break;
-
-        case 2048: options->mtu = IBV_MTU_2048;
-                break;
-
-        case 4096: options->mtu = IBV_MTU_4096;
-                break;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_options_t *options = NULL;
+    int32_t mtu = 0;
+    data_t *temp = NULL;
+
+    /* TODO: validate arguments from options below */
+
+    priv = this->private;
+    options = &priv->options;
+    options->send_size =
+        GLUSTERFS_RDMA_INLINE_THRESHOLD; /*this->ctx->page_size * 4;  512 KB*/
+    options->recv_size =
+        GLUSTERFS_RDMA_INLINE_THRESHOLD; /*this->ctx->page_size * 4;  512 KB*/
+    options->send_count = 4096;
+    options->recv_count = 4096;
+    options->attr_timeout = GF_RDMA_TIMEOUT;
+    options->attr_retry_cnt = GF_RDMA_RETRY_CNT;
+    options->attr_rnr_retry = GF_RDMA_RNR_RETRY;
+
+    temp = dict_get(this->options, "transport.listen-backlog");
+    if (temp)
+        options->backlog = data_to_uint32(temp);
+    else
+        options->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
+
+    temp = dict_get(this->options, "transport.rdma.work-request-send-count");
+    if (temp)
+        options->send_count = data_to_int32(temp);
+
+    temp = dict_get(this->options, "transport.rdma.work-request-recv-count");
+    if (temp)
+        options->recv_count = data_to_int32(temp);
+
+    temp = dict_get(this->options, "transport.rdma.attr-timeout");
+
+    if (temp)
+        options->attr_timeout = data_to_uint8(temp);
+
+    temp = dict_get(this->options, "transport.rdma.attr-retry-cnt");
+
+    if (temp)
+        options->attr_retry_cnt = data_to_uint8(temp);
+
+    temp = dict_get(this->options, "transport.rdma.attr-rnr-retry");
+
+    if (temp)
+        options->attr_rnr_retry = data_to_uint8(temp);
+
+    options->port = 1;
+    temp = dict_get(this->options, "transport.rdma.port");
+    if (temp)
+        options->port = data_to_uint64(temp);
+
+    options->mtu = mtu = IBV_MTU_2048;
+    temp = dict_get(this->options, "transport.rdma.mtu");
+    if (temp)
+        mtu = data_to_int32(temp);
+    switch (mtu) {
+        case 256:
+            options->mtu = IBV_MTU_256;
+            break;
+
+        case 512:
+            options->mtu = IBV_MTU_512;
+            break;
+
+        case 1024:
+            options->mtu = IBV_MTU_1024;
+            break;
+
+        case 2048:
+            options->mtu = IBV_MTU_2048;
+            break;
+
+        case 4096:
+            options->mtu = IBV_MTU_4096;
+            break;
         default:
-                if (temp)
-                        gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
-                                RDMA_MSG_UNRECG_MTU_VALUE, "%s: unrecognized "
-                                "MTU value '%s', defaulting to '2048'",
-                                this->name, data_to_str (temp));
-                else
-                        gf_msg_trace (GF_RDMA_LOG_NAME, 0, "%s: defaulting "
-                                      "MTU to '2048'", this->name);
-                options->mtu = IBV_MTU_2048;
-                break;
-        }
-
-        temp = dict_get (this->options,
-                         "transport.rdma.device-name");
-        if (temp)
-                options->device_name = gf_strdup (temp->data);
-
-        return;
+            if (temp)
+                gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0,
+                       RDMA_MSG_UNRECG_MTU_VALUE,
+                       "%s: unrecognized "
+                       "MTU value '%s', defaulting to '2048'",
+                       this->name, data_to_str(temp));
+            else
+                gf_msg_trace(GF_RDMA_LOG_NAME, 0,
+                             "%s: defaulting "
+                             "MTU to '2048'",
+                             this->name);
+            options->mtu = IBV_MTU_2048;
+            break;
+    }
+
+    temp = dict_get(this->options, "transport.rdma.device-name");
+    if (temp)
+        options->device_name = gf_strdup(temp->data);
+
+    return;
 }
 
-
 gf_rdma_ctx_t *
-__gf_rdma_ctx_create (void)
+__gf_rdma_ctx_create(void)
 {
-        gf_rdma_ctx_t *rdma_ctx = NULL;
-        int            ret      = -1;
-
-        rdma_ctx = GF_CALLOC (1, sizeof (*rdma_ctx), gf_common_mt_char);
-        if (rdma_ctx == NULL) {
-                goto out;
-        }
-        pthread_mutex_init (&rdma_ctx->lock, NULL);
-        rdma_ctx->rdma_cm_event_channel = rdma_create_event_channel ();
-        if (rdma_ctx->rdma_cm_event_channel == NULL) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CM_EVENT_FAILED, "rdma_cm event channel "
-                        "creation failed");
-                goto out;
-        }
-
-        ret = gf_thread_create (&rdma_ctx->rdma_cm_thread, NULL,
-                                gf_rdma_cm_event_handler,
-                                rdma_ctx->rdma_cm_event_channel, "rdmaehan");
-        if (ret != 0) {
-                gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, ret,
-                        RDMA_MSG_CM_EVENT_FAILED, "creation of thread to "
-                        "handle rdma-cm events failed");
-                goto out;
-        }
+    gf_rdma_ctx_t *rdma_ctx = NULL;
+    int ret = -1;
+
+    rdma_ctx = GF_CALLOC(1, sizeof(*rdma_ctx), gf_common_mt_char);
+    if (rdma_ctx == NULL) {
+        goto out;
+    }
+    pthread_mutex_init(&rdma_ctx->lock, NULL);
+    rdma_ctx->rdma_cm_event_channel = rdma_create_event_channel();
+    if (rdma_ctx->rdma_cm_event_channel == NULL) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno,
+               RDMA_MSG_CM_EVENT_FAILED,
+               "rdma_cm event channel "
+               "creation failed");
+        goto out;
+    }
+
+    ret = gf_thread_create(&rdma_ctx->rdma_cm_thread, NULL,
+                           gf_rdma_cm_event_handler,
+                           rdma_ctx->rdma_cm_event_channel, "rdmaehan");
+    if (ret != 0) {
+        gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, ret, RDMA_MSG_CM_EVENT_FAILED,
+               "creation of thread to "
+               "handle rdma-cm events failed");
+        goto out;
+    }
 
 out:
-        if (ret < 0 && rdma_ctx) {
-                if (rdma_ctx->rdma_cm_event_channel != NULL) {
-                        rdma_destroy_event_channel (rdma_ctx->rdma_cm_event_channel);
-                }
-
-                GF_FREE (rdma_ctx);
-                rdma_ctx = NULL;
+    if (ret < 0 && rdma_ctx) {
+        if (rdma_ctx->rdma_cm_event_channel != NULL) {
+            rdma_destroy_event_channel(rdma_ctx->rdma_cm_event_channel);
         }
 
-        return rdma_ctx;
+        GF_FREE(rdma_ctx);
+        rdma_ctx = NULL;
+    }
+
+    return rdma_ctx;
 }
 
 static int32_t
-gf_rdma_init (rpc_transport_t *this)
+gf_rdma_init(rpc_transport_t *this)
 {
-        gf_rdma_private_t   *priv    = NULL;
-        int32_t              ret     = 0;
-        glusterfs_ctx_t     *ctx     = NULL;
-        gf_rdma_options_t   *options = NULL;
+    gf_rdma_private_t *priv = NULL;
+    int32_t ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_rdma_options_t *options = NULL;
 
-        ctx = this->ctx;
+    ctx = this->ctx;
 
-        priv = this->private;
+    priv = this->private;
 
-        ibv_fork_init ();
-        gf_rdma_options_init (this);
+    ibv_fork_init();
+    gf_rdma_options_init(this);
 
-        options = &priv->options;
-        priv->peer.send_count = options->send_count;
-        priv->peer.recv_count = options->recv_count;
-        priv->peer.send_size = options->send_size;
-        priv->peer.recv_size = options->recv_size;
-        priv->backlog = options->backlog;
+    options = &priv->options;
+    priv->peer.send_count = options->send_count;
+    priv->peer.recv_count = options->recv_count;
+    priv->peer.send_size = options->send_size;
+    priv->peer.recv_size = options->recv_size;
+    priv->backlog = options->backlog;
 
-        priv->peer.trans = this;
-        INIT_LIST_HEAD (&priv->peer.ioq);
+    priv->peer.trans = this;
+    INIT_LIST_HEAD(&priv->peer.ioq);
 
-        pthread_mutex_init (&priv->write_mutex, NULL);
-        pthread_mutex_init (&priv->recv_mutex, NULL);
-        pthread_cond_init (&priv->recv_cond, NULL);
+    pthread_mutex_init(&priv->write_mutex, NULL);
+    pthread_mutex_init(&priv->recv_mutex, NULL);
+    pthread_cond_init(&priv->recv_cond, NULL);
 
-        LOCK (&ctx->lock);
-        {
-                if (ctx->ib == NULL) {
-                        ctx->ib = __gf_rdma_ctx_create ();
-                        if (ctx->ib == NULL) {
-                                ret = -1;
-                        }
-                }
+    LOCK(&ctx->lock);
+    {
+        if (ctx->ib == NULL) {
+            ctx->ib = __gf_rdma_ctx_create();
+            if (ctx->ib == NULL) {
+                ret = -1;
+            }
         }
-        UNLOCK (&ctx->lock);
+    }
+    UNLOCK(&ctx->lock);
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait)
+gf_rdma_disconnect(rpc_transport_t *this, gf_boolean_t wait)
 {
-        gf_rdma_private_t *priv = NULL;
-        int32_t            ret  = 0;
+    gf_rdma_private_t *priv = NULL;
+    int32_t ret = 0;
 
-        priv = this->private;
-        gf_msg_callingfn (this->name, GF_LOG_DEBUG, 0,
-                          RDMA_MSG_PEER_DISCONNECTED,
-                          "disconnect called (peer:%s)",
-                          this->peerinfo.identifier);
+    priv = this->private;
+    gf_msg_callingfn(this->name, GF_LOG_DEBUG, 0, RDMA_MSG_PEER_DISCONNECTED,
+                     "disconnect called (peer:%s)", this->peerinfo.identifier);
 
-        pthread_mutex_lock (&priv->write_mutex);
-        {
-                ret = __gf_rdma_disconnect (this);
-        }
-        pthread_mutex_unlock (&priv->write_mutex);
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        ret = __gf_rdma_disconnect(this);
+    }
+    pthread_mutex_unlock(&priv->write_mutex);
 
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-gf_rdma_connect (struct rpc_transport *this, int port)
+gf_rdma_connect(struct rpc_transport *this, int port)
 {
-        gf_rdma_private_t   *priv         = NULL;
-        int32_t              ret          = 0;
-        union gf_sock_union  sock_union   = {{0, }, };
-        socklen_t            sockaddr_len = 0;
-        gf_rdma_peer_t      *peer         = NULL;
-        gf_rdma_ctx_t       *rdma_ctx     = NULL;
-        gf_boolean_t         connected    = _gf_false;
-
-        priv = this->private;
-
-        peer = &priv->peer;
-
-        rpc_transport_ref (this);
-
-        ret = gf_rdma_client_get_remote_sockaddr (this,
-                                                  &sock_union.sa,
-                                                  &sockaddr_len, port);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0, "cannot get remote address to "
-                              "connect");
-                goto out;
-        }
-
-        rdma_ctx = this->ctx->ib;
-
-        pthread_mutex_lock (&priv->write_mutex);
+    gf_rdma_private_t *priv = NULL;
+    int32_t ret = 0;
+    union gf_sock_union sock_union = {
         {
-                if (peer->cm_id != NULL) {
-                        ret = -1;
-                        errno = EINPROGRESS;
-                        connected = _gf_true;
-                        goto unlock;
-                }
+            0,
+        },
+    };
+    socklen_t sockaddr_len = 0;
+    gf_rdma_peer_t *peer = NULL;
+    gf_rdma_ctx_t *rdma_ctx = NULL;
+    gf_boolean_t connected = _gf_false;
 
-                priv->entity = GF_RDMA_CLIENT;
+    priv = this->private;
 
-                ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel,
-                                      &peer->cm_id, this, RDMA_PS_TCP);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                RDMA_MSG_CM_EVENT_FAILED, "creation of "
-                                "rdma_cm_id failed");
-                        ret = -errno;
-                        goto unlock;
-                }
+    peer = &priv->peer;
 
-                memcpy (&this->peerinfo.sockaddr, &sock_union.storage,
-                        sockaddr_len);
-                this->peerinfo.sockaddr_len = sockaddr_len;
-
-                if (port > 0)
-                        sock_union.sin.sin_port = htons (port);
-
-                ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family =
-                        ((struct sockaddr *)&this->peerinfo.sockaddr)->sa_family;
-
-                ret = gf_rdma_client_bind (this,
-                                           (struct sockaddr *)&this->myinfo.sockaddr,
-                                           &this->myinfo.sockaddr_len,
-                                           peer->cm_id);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                RDMA_MSG_CLIENT_BIND_FAILED,
-                                "client bind failed");
-                        goto unlock;
-                }
-
-                ret = rdma_resolve_addr (peer->cm_id, NULL, &sock_union.sa,
-                                         2000);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED,
-                                "rdma_resolve_addr failed");
-                        goto unlock;
-                }
+    rpc_transport_ref(this);
 
-                priv->connected = 0;
-        }
-unlock:
-        pthread_mutex_unlock (&priv->write_mutex);
+    ret = gf_rdma_client_get_remote_sockaddr(this, &sock_union.sa,
+                                             &sockaddr_len, port);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0,
+                     "cannot get remote address to "
+                     "connect");
+        goto out;
+    }
 
-out:
-        if (ret != 0) {
-                if (!connected) {
-                        gf_rdma_teardown (this);
-                }
+    rdma_ctx = this->ctx->ib;
 
-                rpc_transport_unref (this);
+    pthread_mutex_lock(&priv->write_mutex);
+    {
+        if (peer->cm_id != NULL) {
+            ret = -1;
+            errno = EINPROGRESS;
+            connected = _gf_true;
+            goto unlock;
         }
 
-        return ret;
-}
-
+        priv->entity = GF_RDMA_CLIENT;
 
-static int32_t
-gf_rdma_listen (rpc_transport_t *this)
-{
-        union gf_sock_union  sock_union   = {{0, }, };
-        socklen_t            sockaddr_len = 0;
-        gf_rdma_private_t   *priv         = NULL;
-        gf_rdma_peer_t      *peer         = NULL;
-        int                  ret          = 0;
-        gf_rdma_ctx_t       *rdma_ctx     = NULL;
-        char                 service[NI_MAXSERV], host[NI_MAXHOST];
-        int                  optval = 2;
-
-        priv = this->private;
-        peer = &priv->peer;
-
-        priv->entity = GF_RDMA_SERVER_LISTENER;
-
-        rdma_ctx = this->ctx->ib;
-
-        ret = gf_rdma_server_get_local_sockaddr (this, &sock_union.sa,
-                                                 &sockaddr_len);
+        ret = rdma_create_id(rdma_ctx->rdma_cm_event_channel, &peer->cm_id,
+                             this, RDMA_PS_TCP);
         if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_NW_ADDR_UNKNOWN,
-                        "cannot find network address of server to bind to");
-                goto err;
+            gf_msg(this->name, GF_LOG_ERROR, errno, RDMA_MSG_CM_EVENT_FAILED,
+                   "creation of "
+                   "rdma_cm_id failed");
+            ret = -errno;
+            goto unlock;
         }
 
-        ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel,
-                              &peer->cm_id, this, RDMA_PS_TCP);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_CM_EVENT_FAILED, "creation of rdma_cm_id "
-                        "failed");
-                goto err;
-        }
+        memcpy(&this->peerinfo.sockaddr, &sock_union.storage, sockaddr_len);
+        this->peerinfo.sockaddr_len = sockaddr_len;
 
-        memcpy (&this->myinfo.sockaddr, &sock_union.storage,
-                sockaddr_len);
-        this->myinfo.sockaddr_len = sockaddr_len;
+        if (port > 0)
+            sock_union.sin.sin_port = htons(port);
 
-        ret = getnameinfo ((struct sockaddr *)&this->myinfo.sockaddr,
-                           this->myinfo.sockaddr_len, host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ret,
-                        TRANS_MSG_GET_NAME_INFO_FAILED,
-                        "getnameinfo failed");
-                goto err;
-        }
+        ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family =
+            ((struct sockaddr *)&this->peerinfo.sockaddr)->sa_family;
 
-        sprintf (this->myinfo.identifier, "%s:%s", host, service);
-
-        ret = rdma_set_option(peer->cm_id, RDMA_OPTION_ID,
-                              RDMA_OPTION_ID_REUSEADDR,
-                              (void *)&optval, sizeof(optval));
+        ret = gf_rdma_client_bind(this,
+                                  (struct sockaddr *)&this->myinfo.sockaddr,
+                                  &this->myinfo.sockaddr_len, peer->cm_id);
         if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_OPTION_SET_FAILED, "rdma option set failed");
-                goto err;
+            gf_msg(this->name, GF_LOG_WARNING, errno,
+                   RDMA_MSG_CLIENT_BIND_FAILED, "client bind failed");
+            goto unlock;
         }
 
-        ret = rdma_bind_addr (peer->cm_id, &sock_union.sa);
+        ret = rdma_resolve_addr(peer->cm_id, NULL, &sock_union.sa, 2000);
         if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_RDMA_BIND_ADDR_FAILED,
-                        "rdma_bind_addr failed");
-                goto err;
+            gf_msg(this->name, GF_LOG_WARNING, errno,
+                   RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED,
+                   "rdma_resolve_addr failed");
+            goto unlock;
         }
 
-        ret = rdma_listen (peer->cm_id, priv->backlog);
+        priv->connected = 0;
+    }
+unlock:
+    pthread_mutex_unlock(&priv->write_mutex);
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        RDMA_MSG_LISTEN_FAILED,
-                        "rdma_listen failed");
-                goto err;
+out:
+    if (ret != 0) {
+        if (!connected) {
+            gf_rdma_teardown(this);
         }
 
-        rpc_transport_ref (this);
+        rpc_transport_unref(this);
+    }
 
-        ret = 0;
+    return ret;
+}
+
+static int32_t
+gf_rdma_listen(rpc_transport_t *this)
+{
+    union gf_sock_union sock_union = {
+        {
+            0,
+        },
+    };
+    socklen_t sockaddr_len = 0;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_peer_t *peer = NULL;
+    int ret = 0;
+    gf_rdma_ctx_t *rdma_ctx = NULL;
+    char service[NI_MAXSERV], host[NI_MAXHOST];
+    int optval = 2;
+
+    priv = this->private;
+    peer = &priv->peer;
+
+    priv->entity = GF_RDMA_SERVER_LISTENER;
+
+    rdma_ctx = this->ctx->ib;
+
+    ret = gf_rdma_server_get_local_sockaddr(this, &sock_union.sa,
+                                            &sockaddr_len);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NW_ADDR_UNKNOWN,
+               "cannot find network address of server to bind to");
+        goto err;
+    }
+
+    ret = rdma_create_id(rdma_ctx->rdma_cm_event_channel, &peer->cm_id, this,
+                         RDMA_PS_TCP);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_CM_EVENT_FAILED,
+               "creation of rdma_cm_id "
+               "failed");
+        goto err;
+    }
+
+    memcpy(&this->myinfo.sockaddr, &sock_union.storage, sockaddr_len);
+    this->myinfo.sockaddr_len = sockaddr_len;
+
+    ret = getnameinfo((struct sockaddr *)&this->myinfo.sockaddr,
+                      this->myinfo.sockaddr_len, host, sizeof(host), service,
+                      sizeof(service), NI_NUMERICHOST);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_NAME_INFO_FAILED,
+               "getnameinfo failed");
+        goto err;
+    }
+
+    sprintf(this->myinfo.identifier, "%s:%s", host, service);
+
+    ret = rdma_set_option(peer->cm_id, RDMA_OPTION_ID, RDMA_OPTION_ID_REUSEADDR,
+                          (void *)&optval, sizeof(optval));
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_OPTION_SET_FAILED,
+               "rdma option set failed");
+        goto err;
+    }
+
+    ret = rdma_bind_addr(peer->cm_id, &sock_union.sa);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno,
+               RDMA_MSG_RDMA_BIND_ADDR_FAILED, "rdma_bind_addr failed");
+        goto err;
+    }
+
+    ret = rdma_listen(peer->cm_id, priv->backlog);
+
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_LISTEN_FAILED,
+               "rdma_listen failed");
+        goto err;
+    }
+
+    rpc_transport_ref(this);
+
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (peer->cm_id != NULL) {
-                        rdma_destroy_id (peer->cm_id);
-                        peer->cm_id = NULL;
-                }
+    if (ret < 0) {
+        if (peer->cm_id != NULL) {
+            rdma_destroy_id(peer->cm_id);
+            peer->cm_id = NULL;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 struct rpc_transport_ops tops = {
-        .submit_request = gf_rdma_submit_request,
-        .submit_reply   = gf_rdma_submit_reply,
-        .connect        = gf_rdma_connect,
-        .disconnect     = gf_rdma_disconnect,
-        .listen         = gf_rdma_listen,
+    .submit_request = gf_rdma_submit_request,
+    .submit_reply = gf_rdma_submit_reply,
+    .connect = gf_rdma_connect,
+    .disconnect = gf_rdma_disconnect,
+    .listen = gf_rdma_listen,
 };
 
 int32_t
-init (rpc_transport_t *this)
+init(rpc_transport_t *this)
 {
-        gf_rdma_private_t *priv = NULL;
-        gf_rdma_ctx_t *rdma_ctx = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-
-        priv = GF_CALLOC (1, sizeof (*priv), gf_common_mt_rdma_private_t);
-        if (!priv)
-                return -1;
-
-        this->private = priv;
-
-        if (gf_rdma_init (this)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        RDMA_MSG_INIT_IB_DEVICE_FAILED,
-                        "Failed to initialize IB Device");
-                this->private = NULL;
-                GF_FREE (priv);
-                return -1;
-        }
-        rdma_ctx = this->ctx->ib;
-        if (!rdma_ctx)
-                return -1;
+    gf_rdma_private_t *priv = NULL;
+    gf_rdma_ctx_t *rdma_ctx = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
 
-        pthread_mutex_lock (&rdma_ctx->lock);
-        {
-                if (this->dl_handle && (++(rdma_ctx->dlcount)) == 1) {
-                        iobuf_pool = this->ctx->iobuf_pool;
-                        iobuf_pool->rdma_registration = gf_rdma_register_arena;
-                        iobuf_pool->rdma_deregistration =
-                                                      gf_rdma_deregister_arena;
-                        gf_rdma_register_iobuf_pool_with_device
-                                                (rdma_ctx->device, iobuf_pool);
-                }
-        }
-        pthread_mutex_unlock (&rdma_ctx->lock);
+    priv = GF_CALLOC(1, sizeof(*priv), gf_common_mt_rdma_private_t);
+    if (!priv)
+        return -1;
 
-        return 0;
+    this->private = priv;
+
+    if (gf_rdma_init(this)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_INIT_IB_DEVICE_FAILED,
+               "Failed to initialize IB Device");
+        this->private = NULL;
+        GF_FREE(priv);
+        return -1;
+    }
+    rdma_ctx = this->ctx->ib;
+    if (!rdma_ctx)
+        return -1;
+
+    pthread_mutex_lock(&rdma_ctx->lock);
+    {
+        if (this->dl_handle && (++(rdma_ctx->dlcount)) == 1) {
+            iobuf_pool = this->ctx->iobuf_pool;
+            iobuf_pool->rdma_registration = gf_rdma_register_arena;
+            iobuf_pool->rdma_deregistration = gf_rdma_deregister_arena;
+            gf_rdma_register_iobuf_pool_with_device(rdma_ctx->device,
+                                                    iobuf_pool);
+        }
+    }
+    pthread_mutex_unlock(&rdma_ctx->lock);
+
+    return 0;
 }
 
 int
-reconfigure (rpc_transport_t *this, dict_t *options)
+reconfigure(rpc_transport_t *this, dict_t *options)
 {
-        gf_rdma_private_t *priv          = NULL;
-        uint32_t          backlog        = 0;
-        int               ret            = -1;
-
-        GF_VALIDATE_OR_GOTO ("rdma", this, out);
-        GF_VALIDATE_OR_GOTO ("rdma", this->private, out);
-
-        priv = this->private;
-
-        if (dict_get_uint32 (options, "transport.listen-backlog",
-                             &backlog) == 0) {
-                priv->backlog = backlog;
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                        "transport.listen-backlog=%d", priv->backlog);
-        }
-        ret = 0;
+    gf_rdma_private_t *priv = NULL;
+    uint32_t backlog = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("rdma", this, out);
+    GF_VALIDATE_OR_GOTO("rdma", this->private, out);
+
+    priv = this->private;
+
+    if (dict_get_uint32(options, "transport.listen-backlog", &backlog) == 0) {
+        priv->backlog = backlog;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigued "
+               "transport.listen-backlog=%d",
+               priv->backlog);
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 void
-fini (struct rpc_transport *this)
+fini(struct rpc_transport *this)
 {
-        /* TODO: verify this function does graceful finish */
-        gf_rdma_private_t *priv = NULL;
-        struct iobuf_pool *iobuf_pool = NULL;
-        gf_rdma_ctx_t *rdma_ctx = NULL;
+    /* TODO: verify this function does graceful finish */
+    gf_rdma_private_t *priv = NULL;
+    struct iobuf_pool *iobuf_pool = NULL;
+    gf_rdma_ctx_t *rdma_ctx = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        this->private = NULL;
+    this->private = NULL;
 
-        if (priv) {
-                pthread_mutex_destroy (&priv->recv_mutex);
-                pthread_mutex_destroy (&priv->write_mutex);
+    if (priv) {
+        pthread_mutex_destroy(&priv->recv_mutex);
+        pthread_mutex_destroy(&priv->write_mutex);
 
-                gf_msg_trace (this->name, 0,
-                              "called fini on transport: %p", this);
-                GF_FREE (priv);
-        }
+        gf_msg_trace(this->name, 0, "called fini on transport: %p", this);
+        GF_FREE(priv);
+    }
 
-        rdma_ctx = this->ctx->ib;
-        if (!rdma_ctx)
-                return;
+    rdma_ctx = this->ctx->ib;
+    if (!rdma_ctx)
+        return;
 
-        pthread_mutex_lock (&rdma_ctx->lock);
-        {
-                if (this->dl_handle && (--(rdma_ctx->dlcount)) == 0) {
-                        iobuf_pool = this->ctx->iobuf_pool;
-                        gf_rdma_deregister_iobuf_pool (rdma_ctx->device);
-                        iobuf_pool->rdma_registration = NULL;
-                        iobuf_pool->rdma_deregistration = NULL;
-                }
+    pthread_mutex_lock(&rdma_ctx->lock);
+    {
+        if (this->dl_handle && (--(rdma_ctx->dlcount)) == 0) {
+            iobuf_pool = this->ctx->iobuf_pool;
+            gf_rdma_deregister_iobuf_pool(rdma_ctx->device);
+            iobuf_pool->rdma_registration = NULL;
+            iobuf_pool->rdma_deregistration = NULL;
         }
-        pthread_mutex_unlock (&rdma_ctx->lock);
+    }
+    pthread_mutex_unlock(&rdma_ctx->lock);
 
-        return;
+    return;
 }
 
 /* TODO: expand each option */
 struct volume_options options[] = {
-        { .key   = {"transport.rdma.port",
-                    "rdma-port"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 4,
-          .description = "check the option by 'ibv_devinfo'"
-        },
-        { .key   = {"transport.rdma.mtu",
-                    "rdma-mtu"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"transport.rdma.device-name",
-                    "rdma-device-name"},
-          .type  = GF_OPTION_TYPE_ANY,
-          .description = "check by 'ibv_devinfo'"
-        },
-        { .key   = {"transport.rdma.work-request-send-count",
-                    "rdma-work-request-send-count"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"transport.rdma.work-request-recv-count",
-                    "rdma-work-request-recv-count"},
-          .type  = GF_OPTION_TYPE_INT,
-        },
-        { .key   = {"remote-port",
-                    "transport.remote-port",
-                    "transport.rdma.remote-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-timeout",
-                    "rdma-attr-timeout"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-retry-cnt",
-                    "rdma-attr-retry-cnt"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.attr-rnr-retry",
-                    "rdma-attr-rnr-retry"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.listen-port", "listen-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.rdma.connect-path", "connect-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.rdma.bind-path", "bind-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.rdma.listen-path", "listen-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.address-family",
-                    "address-family"},
-          .value = {"inet", "inet6", "inet/inet6", "inet6/inet",
-                    "unix", "inet-sdp" },
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {"transport.socket.lowlat"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key = {NULL} }
-};
+    {.key = {"transport.rdma.port", "rdma-port"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 4,
+     .description = "check the option by 'ibv_devinfo'"},
+    {
+        .key = {"transport.rdma.mtu", "rdma-mtu"},
+        .type = GF_OPTION_TYPE_INT,
+    },
+    {.key = {"transport.rdma.device-name", "rdma-device-name"},
+     .type = GF_OPTION_TYPE_ANY,
+     .description = "check by 'ibv_devinfo'"},
+    {
+        .key = {"transport.rdma.work-request-send-count",
+                "rdma-work-request-send-count"},
+        .type = GF_OPTION_TYPE_INT,
+    },
+    {
+        .key = {"transport.rdma.work-request-recv-count",
+                "rdma-work-request-recv-count"},
+        .type = GF_OPTION_TYPE_INT,
+    },
+    {.key = {"remote-port", "transport.remote-port",
+             "transport.rdma.remote-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.rdma.attr-timeout", "rdma-attr-timeout"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.rdma.attr-retry-cnt", "rdma-attr-retry-cnt"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.rdma.attr-rnr-retry", "rdma-attr-rnr-retry"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.rdma.listen-port", "listen-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.rdma.connect-path", "connect-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.rdma.bind-path", "bind-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.rdma.listen-path", "listen-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.address-family", "address-family"},
+     .value = {"inet", "inet6", "inet/inet6", "inet6/inet", "unix", "inet-sdp"},
+     .type = GF_OPTION_TYPE_STR},
+    {.key = {"transport.socket.lowlat"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {NULL}}};
diff --git a/rpc/rpc-transport/socket/src/name.c b/rpc/rpc-transport/socket/src/name.c
index 34e6372a8f3..3194a7cf369 100644
--- a/rpc/rpc-transport/socket/src/name.c
+++ b/rpc/rpc-transport/socket/src/name.c
@@ -24,760 +24,729 @@
 #include "common-utils.h"
 
 static void
-_assign_port (struct sockaddr *sockaddr, uint16_t port)
+_assign_port(struct sockaddr *sockaddr, uint16_t port)
 {
-        switch (sockaddr->sa_family) {
+    switch (sockaddr->sa_family) {
         case AF_INET6:
-                ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port);
-                break;
+            ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port);
+            break;
 
         case AF_INET_SDP:
         case AF_INET:
-                ((struct sockaddr_in *)sockaddr)->sin_port = htons (port);
-                break;
-        }
+            ((struct sockaddr_in *)sockaddr)->sin_port = htons(port);
+            break;
+    }
 }
 
 static int32_t
-af_inet_bind_to_port_lt_ceiling (int fd, struct sockaddr *sockaddr,
-                                 socklen_t sockaddr_len, uint32_t ceiling)
+af_inet_bind_to_port_lt_ceiling(int fd, struct sockaddr *sockaddr,
+                                socklen_t sockaddr_len, uint32_t ceiling)
 {
 #if GF_DISABLE_PRIVPORT_TRACKING
-        _assign_port (sockaddr, 0);
-        return bind (fd, sockaddr, sockaddr_len);
+    _assign_port(sockaddr, 0);
+    return bind(fd, sockaddr, sockaddr_len);
 #else
-        int32_t         ret                             = -1;
-        uint16_t        port                            = ceiling - 1;
-        unsigned char   ports[GF_PORT_ARRAY_SIZE]       = {0,};
-        int             i                               = 0;
+    int32_t ret = -1;
+    uint16_t port = ceiling - 1;
+    unsigned char ports[GF_PORT_ARRAY_SIZE] = {
+        0,
+    };
+    int i = 0;
 
 loop:
-        ret = gf_process_reserved_ports (ports, ceiling);
+    ret = gf_process_reserved_ports(ports, ceiling);
 
-        while (port) {
-                if (port == GF_CLIENT_PORT_CEILING) {
-                        ret = -1;
-                        break;
-                }
+    while (port) {
+        if (port == GF_CLIENT_PORT_CEILING) {
+            ret = -1;
+            break;
+        }
 
-                /* ignore the reserved ports */
-                if (BIT_VALUE (ports, port)) {
-                        port--;
-                        continue;
-                }
+        /* ignore the reserved ports */
+        if (BIT_VALUE(ports, port)) {
+            port--;
+            continue;
+        }
 
-                _assign_port (sockaddr, port);
+        _assign_port(sockaddr, port);
 
-                ret = bind (fd, sockaddr, sockaddr_len);
+        ret = bind(fd, sockaddr, sockaddr_len);
 
-                if (ret == 0)
-                        break;
+        if (ret == 0)
+            break;
 
-                if (ret == -1 && errno == EACCES)
-                        break;
+        if (ret == -1 && errno == EACCES)
+            break;
 
-                port--;
-        }
+        port--;
+    }
 
-        /* In case if all the secure ports are exhausted, we are no more
-         * binding to secure ports, hence instead of getting a random
-         * port, lets define the range to restrict it from getting from
-         * ports reserved for bricks i.e from range of 49152 - 65535
-         * which further may lead to port clash */
-        if (!port) {
-                ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
-                for (i = 0; i <= ceiling; i++)
-                        BIT_CLEAR (ports, i);
-                goto loop;
-        }
+    /* In case if all the secure ports are exhausted, we are no more
+     * binding to secure ports, hence instead of getting a random
+     * port, lets define the range to restrict it from getting from
+     * ports reserved for bricks i.e from range of 49152 - 65535
+     * which further may lead to port clash */
+    if (!port) {
+        ceiling = port = GF_CLNT_INSECURE_PORT_CEILING;
+        for (i = 0; i <= ceiling; i++)
+            BIT_CLEAR(ports, i);
+        goto loop;
+    }
 
-        return ret;
+    return ret;
 #endif /* GF_DISABLE_PRIVPORT_TRACKING */
 }
 
 static int32_t
-af_unix_client_bind (rpc_transport_t *this,
-                     struct sockaddr *sockaddr,
-                     socklen_t sockaddr_len,
-                     int sock)
+af_unix_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+                    socklen_t sockaddr_len, int sock)
 {
-        data_t *path_data = NULL;
-        struct sockaddr_un *addr = NULL;
-        int32_t ret = 0;
-
-        path_data = dict_get (this->options, "transport.socket.bind-path");
-        if (path_data) {
-                char *path = data_to_str (path_data);
-                if (!path || strlen (path) > UNIX_PATH_MAX) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "bind-path not specified for unix socket, "
-                                "letting connect to assign default value");
-                        goto err;
-                }
-
-                addr = (struct sockaddr_un *) sockaddr;
-                strcpy (addr->sun_path, path);
-                ret = bind (sock, (struct sockaddr *)addr, sockaddr_len);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot bind to unix-domain socket %d (%s)",
-                                sock, strerror (errno));
-                        goto err;
-                }
-        } else {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "bind-path not specified for unix socket, "
-                        "letting connect to assign default value");
+    data_t *path_data = NULL;
+    struct sockaddr_un *addr = NULL;
+    int32_t ret = 0;
+
+    path_data = dict_get(this->options, "transport.socket.bind-path");
+    if (path_data) {
+        char *path = data_to_str(path_data);
+        if (!path || strlen(path) > UNIX_PATH_MAX) {
+            gf_log(this->name, GF_LOG_TRACE,
+                   "bind-path not specified for unix socket, "
+                   "letting connect to assign default value");
+            goto err;
+        }
+
+        addr = (struct sockaddr_un *)sockaddr;
+        strcpy(addr->sun_path, path);
+        ret = bind(sock, (struct sockaddr *)addr, sockaddr_len);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "cannot bind to unix-domain socket %d (%s)", sock,
+                   strerror(errno));
+            goto err;
         }
+    } else {
+        gf_log(this->name, GF_LOG_TRACE,
+               "bind-path not specified for unix socket, "
+               "letting connect to assign default value");
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 int32_t
-client_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family)
+client_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family)
 {
-        data_t  *address_family_data = NULL;
-        int32_t  ret                 = -1;
-
-        if (sa_family == NULL) {
-                gf_log_callingfn ("", GF_LOG_WARNING,
-                                  "sa_family argument is NULL");
-                goto out;
-        }
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (!address_family_data) {
-                data_t *remote_host_data = NULL, *connect_path_data = NULL;
-                remote_host_data = dict_get (this->options, "remote-host");
-                connect_path_data = dict_get (this->options,
-                                              "transport.socket.connect-path");
-
-                if (!(remote_host_data || connect_path_data) ||
-                    (remote_host_data && connect_path_data)) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "transport.address-family not specified. "
-                                "Could not guess default value from (remote-host:%s or "
-                                "transport.unix.connect-path:%s) options",
-                                data_to_str (remote_host_data),
-                                data_to_str (connect_path_data));
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
-
-                if (remote_host_data) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "address-family not specified, marking it as unspec "
-                                "for getaddrinfo to resolve from (remote-host: %s)",
-                                data_to_str(remote_host_data));
-                        *sa_family = AF_UNSPEC;
-                } else {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "address-family not specified, guessing it "
-                                "to be unix from (transport.unix.connect-path: %s)", data_to_str (connect_path_data));
-                        *sa_family = AF_UNIX;
-                }
-
+    data_t *address_family_data = NULL;
+    int32_t ret = -1;
+
+    if (sa_family == NULL) {
+        gf_log_callingfn("", GF_LOG_WARNING, "sa_family argument is NULL");
+        goto out;
+    }
+
+    address_family_data = dict_get(this->options, "transport.address-family");
+    if (!address_family_data) {
+        data_t *remote_host_data = NULL, *connect_path_data = NULL;
+        remote_host_data = dict_get(this->options, "remote-host");
+        connect_path_data = dict_get(this->options,
+                                     "transport.socket.connect-path");
+
+        if (!(remote_host_data || connect_path_data) ||
+            (remote_host_data && connect_path_data)) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "transport.address-family not specified. "
+                   "Could not guess default value from (remote-host:%s or "
+                   "transport.unix.connect-path:%s) options",
+                   data_to_str(remote_host_data),
+                   data_to_str(connect_path_data));
+            *sa_family = AF_UNSPEC;
+            goto out;
+        }
+
+        if (remote_host_data) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "address-family not specified, marking it as unspec "
+                   "for getaddrinfo to resolve from (remote-host: %s)",
+                   data_to_str(remote_host_data));
+            *sa_family = AF_UNSPEC;
         } else {
-                char *address_family = data_to_str (address_family_data);
-                if (!strcasecmp (address_family, "unix")) {
-                        *sa_family = AF_UNIX;
-                } else if (!strcasecmp (address_family, "inet")) {
-                        *sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        *sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        *sa_family = AF_INET_SDP;
-                } else {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "unknown address-family (%s) specified",
-                                address_family);
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "address-family not specified, guessing it "
+                   "to be unix from (transport.unix.connect-path: %s)",
+                   data_to_str(connect_path_data));
+            *sa_family = AF_UNIX;
+        }
+
+    } else {
+        char *address_family = data_to_str(address_family_data);
+        if (!strcasecmp(address_family, "unix")) {
+            *sa_family = AF_UNIX;
+        } else if (!strcasecmp(address_family, "inet")) {
+            *sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            *sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            *sa_family = AF_INET_SDP;
+        } else {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "unknown address-family (%s) specified", address_family);
+            *sa_family = AF_UNSPEC;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_inet_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
+af_inet_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len)
 {
-        dict_t *options = this->options;
-        data_t *remote_host_data = NULL;
-        data_t *remote_port_data = NULL;
-        char *remote_host = NULL;
-        uint16_t remote_port = 0;
-        struct addrinfo *addr_info = NULL;
-        int32_t ret = 0;
-
-        remote_host_data = dict_get (options, "remote-host");
-        if (remote_host_data == NULL)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-host missing in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_host = data_to_str (remote_host_data);
-        if (remote_host == NULL)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-host has data NULL in volume %s", this->name);
-                ret = -1;
-                goto err;
-        }
-
-        remote_port_data = dict_get (options, "remote-port");
-        if (remote_port_data == NULL)
-        {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "option remote-port missing in volume %s. Defaulting to %d",
-                        this->name, GF_DEFAULT_SOCKET_LISTEN_PORT);
-
-                remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
-        }
-        else
-        {
-                remote_port = data_to_uint16 (remote_port_data);
-        }
-
-        if (remote_port == (uint16_t)-1)
-        {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option remote-port has invalid port in volume %s",
-                        this->name);
-                ret = -1;
-                goto err;
-        }
-
-        /* TODO: gf_resolve is a blocking call. kick in some
-           non blocking dns techniques */
-        ret = gf_resolve_ip6 (remote_host, remote_port,
-                              sockaddr->sa_family, &this->dnscache, &addr_info);
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "DNS resolution failed on host %s", remote_host);
-                goto err;
-        }
-
-        memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
-        *sockaddr_len = addr_info->ai_addrlen;
+    dict_t *options = this->options;
+    data_t *remote_host_data = NULL;
+    data_t *remote_port_data = NULL;
+    char *remote_host = NULL;
+    uint16_t remote_port = 0;
+    struct addrinfo *addr_info = NULL;
+    int32_t ret = 0;
+
+    remote_host_data = dict_get(options, "remote-host");
+    if (remote_host_data == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option remote-host missing in volume %s", this->name);
+        ret = -1;
+        goto err;
+    }
+
+    remote_host = data_to_str(remote_host_data);
+    if (remote_host == NULL) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option remote-host has data NULL in volume %s", this->name);
+        ret = -1;
+        goto err;
+    }
+
+    remote_port_data = dict_get(options, "remote-port");
+    if (remote_port_data == NULL) {
+        gf_log(this->name, GF_LOG_TRACE,
+               "option remote-port missing in volume %s. Defaulting to %d",
+               this->name, GF_DEFAULT_SOCKET_LISTEN_PORT);
+
+        remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
+    } else {
+        remote_port = data_to_uint16(remote_port_data);
+    }
+
+    if (remote_port == (uint16_t)-1) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option remote-port has invalid port in volume %s", this->name);
+        ret = -1;
+        goto err;
+    }
+
+    /* TODO: gf_resolve is a blocking call. kick in some
+       non blocking dns techniques */
+    ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family,
+                         &this->dnscache, &addr_info);
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_ERROR, "DNS resolution failed on host %s",
+               remote_host);
+        goto err;
+    }
+
+    memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen);
+    *sockaddr_len = addr_info->ai_addrlen;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_client_get_remote_sockaddr (rpc_transport_t *this,
-                                    struct sockaddr *sockaddr,
-                                    socklen_t *sockaddr_len)
+af_unix_client_get_remote_sockaddr(rpc_transport_t *this,
+                                   struct sockaddr *sockaddr,
+                                   socklen_t *sockaddr_len)
 {
-        struct sockaddr_un *sockaddr_un = NULL;
-        char *connect_path = NULL;
-        data_t *connect_path_data = NULL;
-        int32_t ret = 0;
-
-        connect_path_data = dict_get (this->options,
-                                      "transport.socket.connect-path");
-        if (!connect_path_data) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option transport.unix.connect-path not specified for "
-                        "address-family unix");
-                ret = -1;
-                goto err;
-        }
-
-        connect_path = data_to_str (connect_path_data);
-        if (!connect_path) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "transport.unix.connect-path is null-string");
-                ret = -1;
-                goto err;
-        }
-
-        if ((strlen (connect_path) + 1)  > UNIX_PATH_MAX) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "connect-path value length %"GF_PRI_SIZET" > %d octets",
-                        strlen (connect_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
-
-        gf_log (this->name, GF_LOG_TRACE,
-                "using connect-path %s", connect_path);
-        sockaddr_un = (struct sockaddr_un *)sockaddr;
-        strcpy (sockaddr_un->sun_path, connect_path);
-        *sockaddr_len = sizeof (struct sockaddr_un);
+    struct sockaddr_un *sockaddr_un = NULL;
+    char *connect_path = NULL;
+    data_t *connect_path_data = NULL;
+    int32_t ret = 0;
+
+    connect_path_data = dict_get(this->options,
+                                 "transport.socket.connect-path");
+    if (!connect_path_data) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option transport.unix.connect-path not specified for "
+               "address-family unix");
+        ret = -1;
+        goto err;
+    }
+
+    connect_path = data_to_str(connect_path_data);
+    if (!connect_path) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "transport.unix.connect-path is null-string");
+        ret = -1;
+        goto err;
+    }
+
+    if ((strlen(connect_path) + 1) > UNIX_PATH_MAX) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "connect-path value length %" GF_PRI_SIZET " > %d octets",
+               strlen(connect_path), UNIX_PATH_MAX);
+        ret = -1;
+        goto err;
+    }
+
+    gf_log(this->name, GF_LOG_TRACE, "using connect-path %s", connect_path);
+    sockaddr_un = (struct sockaddr_un *)sockaddr;
+    strcpy(sockaddr_un->sun_path, connect_path);
+    *sockaddr_len = sizeof(struct sockaddr_un);
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_unix_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        data_t *listen_path_data = NULL;
-        char *listen_path = NULL;
-        int32_t ret = 0;
-        struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
-
-
-        listen_path_data = dict_get (this->options,
-                                     "transport.socket.listen-path");
-        if (!listen_path_data) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "missing option transport.socket.listen-path");
-                ret = -1;
-                goto err;
-        }
+    data_t *listen_path_data = NULL;
+    char *listen_path = NULL;
+    int32_t ret = 0;
+    struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
+
+    listen_path_data = dict_get(this->options, "transport.socket.listen-path");
+    if (!listen_path_data) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "missing option transport.socket.listen-path");
+        ret = -1;
+        goto err;
+    }
 
-        listen_path = data_to_str (listen_path_data);
+    listen_path = data_to_str(listen_path_data);
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX 108
 #endif
 
-        if ((strlen (listen_path) + 1)  > UNIX_PATH_MAX) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "option transport.unix.listen-path has value length "
-                        "%"GF_PRI_SIZET" > %d",
-                        strlen (listen_path), UNIX_PATH_MAX);
-                ret = -1;
-                goto err;
-        }
+    if ((strlen(listen_path) + 1) > UNIX_PATH_MAX) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "option transport.unix.listen-path has value length "
+               "%" GF_PRI_SIZET " > %d",
+               strlen(listen_path), UNIX_PATH_MAX);
+        ret = -1;
+        goto err;
+    }
 
-        sunaddr->sun_family = AF_UNIX;
-        strcpy (sunaddr->sun_path, listen_path);
-        *addr_len = sizeof (struct sockaddr_un);
+    sunaddr->sun_family = AF_UNIX;
+    strcpy(sunaddr->sun_path, listen_path);
+    *addr_len = sizeof(struct sockaddr_un);
 
 err:
-        return ret;
+    return ret;
 }
 
 static int32_t
-af_inet_server_get_local_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *addr,
-                                   socklen_t *addr_len)
+af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                  socklen_t *addr_len)
 {
-        struct addrinfo hints, *res = 0, *rp = NULL;
-        data_t *listen_port_data = NULL, *listen_host_data = NULL;
-        uint16_t listen_port = -1;
-        char service[NI_MAXSERV], *listen_host = NULL;
-        dict_t *options = NULL;
-        int32_t ret = 0;
-
-        options = this->options;
-
-        listen_port_data = dict_get (options, "transport.socket.listen-port");
-        listen_host_data = dict_get (options, "transport.socket.bind-address");
-
-        if (listen_port_data)
-        {
-                listen_port = data_to_uint16 (listen_port_data);
-        }
-
-        if (listen_port == (uint16_t) -1)
-                listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
-
-
-        if (listen_host_data)
-        {
-                listen_host = data_to_str (listen_host_data);
-        } else {
-                if (addr->sa_family == AF_INET6) {
-                        struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr;
-                        in->sin6_addr = in6addr_any;
-                        in->sin6_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in6);
-                        goto out;
-                } else if (addr->sa_family == AF_INET) {
-                        struct sockaddr_in *in = (struct sockaddr_in *) addr;
-                        in->sin_addr.s_addr = htonl(INADDR_ANY);
-                        in->sin_port = htons(listen_port);
-                        *addr_len = sizeof(struct sockaddr_in);
-                        goto out;
-                }
-        }
-
-        sprintf (service, "%d", listen_port);
-
-        memset (&hints, 0, sizeof (hints));
-        hints.ai_family = addr->sa_family;
-        hints.ai_socktype = SOCK_STREAM;
-        hints.ai_flags    = AI_PASSIVE;
-
-        ret = getaddrinfo(listen_host, service, &hints, &res);
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "getaddrinfo failed for host %s, service %s (%s)",
-                        listen_host, service, gai_strerror (ret));
-                ret = -1;
-                goto out;
-        }
-        /* IPV6 server can handle both ipv4 and ipv6 clients */
-        for (rp = res; rp != NULL; rp = rp->ai_next) {
-                if (rp->ai_addr == NULL)
-                        continue;
-                if (rp->ai_family == AF_INET6) {
-                        memcpy (addr, rp->ai_addr, rp->ai_addrlen);
-                        *addr_len = rp->ai_addrlen;
-                }
-        }
-
-        if (!(*addr_len)) {
-                memcpy (addr, res->ai_addr, res->ai_addrlen);
-                *addr_len = res->ai_addrlen;
-        }
-
-        freeaddrinfo (res);
+    struct addrinfo hints, *res = 0, *rp = NULL;
+    data_t *listen_port_data = NULL, *listen_host_data = NULL;
+    uint16_t listen_port = -1;
+    char service[NI_MAXSERV], *listen_host = NULL;
+    dict_t *options = NULL;
+    int32_t ret = 0;
+
+    options = this->options;
+
+    listen_port_data = dict_get(options, "transport.socket.listen-port");
+    listen_host_data = dict_get(options, "transport.socket.bind-address");
+
+    if (listen_port_data) {
+        listen_port = data_to_uint16(listen_port_data);
+    }
+
+    if (listen_port == (uint16_t)-1)
+        listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT;
+
+    if (listen_host_data) {
+        listen_host = data_to_str(listen_host_data);
+    } else {
+        if (addr->sa_family == AF_INET6) {
+            struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr;
+            in->sin6_addr = in6addr_any;
+            in->sin6_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in6);
+            goto out;
+        } else if (addr->sa_family == AF_INET) {
+            struct sockaddr_in *in = (struct sockaddr_in *)addr;
+            in->sin_addr.s_addr = htonl(INADDR_ANY);
+            in->sin_port = htons(listen_port);
+            *addr_len = sizeof(struct sockaddr_in);
+            goto out;
+        }
+    }
+
+    sprintf(service, "%d", listen_port);
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = addr->sa_family;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_PASSIVE;
+
+    ret = getaddrinfo(listen_host, service, &hints, &res);
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "getaddrinfo failed for host %s, service %s (%s)", listen_host,
+               service, gai_strerror(ret));
+        ret = -1;
+        goto out;
+    }
+    /* IPV6 server can handle both ipv4 and ipv6 clients */
+    for (rp = res; rp != NULL; rp = rp->ai_next) {
+        if (rp->ai_addr == NULL)
+            continue;
+        if (rp->ai_family == AF_INET6) {
+            memcpy(addr, rp->ai_addr, rp->ai_addrlen);
+            *addr_len = rp->ai_addrlen;
+        }
+    }
+
+    if (!(*addr_len)) {
+        memcpy(addr, res->ai_addr, res->ai_addrlen);
+        *addr_len = res->ai_addrlen;
+    }
+
+    freeaddrinfo(res);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-client_bind (rpc_transport_t *this,
-             struct sockaddr *sockaddr,
-             socklen_t *sockaddr_len,
-             int sock)
+client_bind(rpc_transport_t *this, struct sockaddr *sockaddr,
+            socklen_t *sockaddr_len, int sock)
 {
-        int ret = 0;
+    int ret = 0;
 
-        *sockaddr_len = sizeof (struct sockaddr_in6);
-        switch (sockaddr->sa_family)
-        {
+    *sockaddr_len = sizeof(struct sockaddr_in6);
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
         case AF_INET:
-                *sockaddr_len = sizeof (struct sockaddr_in);
+            *sockaddr_len = sizeof(struct sockaddr_in);
         /* Fall through */
         case AF_INET6:
-                if (!this->bind_insecure) {
-                        ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_CLIENT_PORT_CEILING);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "cannot bind inet socket (%d) "
-                                        "to port less than %d (%s)",
-                                        sock, GF_CLIENT_PORT_CEILING,
-                                        strerror (errno));
-                                ret = 0;
-                        }
-                } else {
-                        ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr,
-                                                               *sockaddr_len,
-                                                               GF_IANA_PRIV_PORTS_START);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "failed while binding to less than "
-                                        "%d (%s)", GF_IANA_PRIV_PORTS_START,
-                                        strerror (errno));
-                                ret = 0;
-                        }
+            if (!this->bind_insecure) {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    sock, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING);
+                if (ret == -1) {
+                    gf_log(this->name, GF_LOG_DEBUG,
+                           "cannot bind inet socket (%d) "
+                           "to port less than %d (%s)",
+                           sock, GF_CLIENT_PORT_CEILING, strerror(errno));
+                    ret = 0;
+                }
+            } else {
+                ret = af_inet_bind_to_port_lt_ceiling(
+                    sock, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START);
+                if (ret == -1) {
+                    gf_log(this->name, GF_LOG_DEBUG,
+                           "failed while binding to less than "
+                           "%d (%s)",
+                           GF_IANA_PRIV_PORTS_START, strerror(errno));
+                    ret = 0;
                 }
-                break;
+            }
+            break;
 
         case AF_UNIX:
-                *sockaddr_len = sizeof (struct sockaddr_un);
-                ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr,
-                                           *sockaddr_len, sock);
-                break;
+            *sockaddr_len = sizeof(struct sockaddr_un);
+            ret = af_unix_client_bind(this, (struct sockaddr *)sockaddr,
+                                      *sockaddr_len, sock);
+            break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address family %d", sockaddr->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address family %d",
+                   sockaddr->sa_family);
+            ret = -1;
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-socket_client_get_remote_sockaddr (rpc_transport_t *this,
-                                   struct sockaddr *sockaddr,
-                                   socklen_t *sockaddr_len,
-                                   sa_family_t *sa_family)
+socket_client_get_remote_sockaddr(rpc_transport_t *this,
+                                  struct sockaddr *sockaddr,
+                                  socklen_t *sockaddr_len,
+                                  sa_family_t *sa_family)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", sockaddr, err);
-        GF_VALIDATE_OR_GOTO ("socket", sockaddr_len, err);
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, err);
+    GF_VALIDATE_OR_GOTO("socket", sockaddr, err);
+    GF_VALIDATE_OR_GOTO("socket", sockaddr_len, err);
+    GF_VALIDATE_OR_GOTO("socket", sa_family, err);
 
-        ret = client_fill_address_family (this, &sockaddr->sa_family);
-        if (ret) {
-                ret = -1;
-                goto err;
-        }
+    ret = client_fill_address_family(this, &sockaddr->sa_family);
+    if (ret) {
+        ret = -1;
+        goto err;
+    }
 
-        *sa_family = sockaddr->sa_family;
+    *sa_family = sockaddr->sa_family;
 
-        switch (sockaddr->sa_family)
-        {
+    switch (sockaddr->sa_family) {
         case AF_INET_SDP:
-                sockaddr->sa_family = AF_INET;
+            sockaddr->sa_family = AF_INET;
         /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_client_get_remote_sockaddr (this, sockaddr,
-                                                          sockaddr_len);
-                break;
+            ret = af_inet_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len);
+            break;
 
         case AF_UNIX:
-                ret = af_unix_client_get_remote_sockaddr (this, sockaddr,
-                                                          sockaddr_len);
-                break;
+            ret = af_unix_client_get_remote_sockaddr(this, sockaddr,
+                                                     sockaddr_len);
+            break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address-family %d", sockaddr->sa_family);
-                ret = -1;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address-family %d",
+                   sockaddr->sa_family);
+            ret = -1;
+    }
 
-        if (*sa_family == AF_UNSPEC) {
-                *sa_family = sockaddr->sa_family;
-        }
+    if (*sa_family == AF_UNSPEC) {
+        *sa_family = sockaddr->sa_family;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-server_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family)
+server_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family)
 {
-        data_t  *address_family_data = NULL;
-        int32_t  ret                 = -1;
+    data_t *address_family_data = NULL;
+    int32_t ret = -1;
 
 #ifdef IPV6_DEFAULT
-        char *addr_family            = "inet6";
-        sa_family_t default_family   = AF_INET6;
+    char *addr_family = "inet6";
+    sa_family_t default_family = AF_INET6;
 #else
-        char *addr_family            = "inet";
-        sa_family_t default_family   = AF_INET;
+    char *addr_family = "inet";
+    sa_family_t default_family = AF_INET;
 #endif
 
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, out);
-
-        address_family_data = dict_get (this->options,
-                                        "transport.address-family");
-        if (address_family_data) {
-                char *address_family = NULL;
-                address_family = data_to_str (address_family_data);
-
-                if (!strcasecmp (address_family, "inet")) {
-                        *sa_family = AF_INET;
-                } else if (!strcasecmp (address_family, "inet6")) {
-                        *sa_family = AF_INET6;
-                } else if (!strcasecmp (address_family, "inet-sdp")) {
-                        *sa_family = AF_INET_SDP;
-                } else if (!strcasecmp (address_family, "unix")) {
-                        *sa_family = AF_UNIX;
-                } else {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "unknown address family (%s) specified", address_family);
-                        *sa_family = AF_UNSPEC;
-                        goto out;
-                }
+    GF_VALIDATE_OR_GOTO("socket", sa_family, out);
+
+    address_family_data = dict_get(this->options, "transport.address-family");
+    if (address_family_data) {
+        char *address_family = NULL;
+        address_family = data_to_str(address_family_data);
+
+        if (!strcasecmp(address_family, "inet")) {
+            *sa_family = AF_INET;
+        } else if (!strcasecmp(address_family, "inet6")) {
+            *sa_family = AF_INET6;
+        } else if (!strcasecmp(address_family, "inet-sdp")) {
+            *sa_family = AF_INET_SDP;
+        } else if (!strcasecmp(address_family, "unix")) {
+            *sa_family = AF_UNIX;
         } else {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "option address-family not specified, "
-                        "defaulting to %s", addr_family);
-                *sa_family = default_family;
-        }
-
-        ret = 0;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "unknown address family (%s) specified", address_family);
+            *sa_family = AF_UNSPEC;
+            goto out;
+        }
+    } else {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "option address-family not specified, "
+               "defaulting to %s",
+               addr_family);
+        *sa_family = default_family;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-socket_server_get_local_sockaddr (rpc_transport_t *this, struct sockaddr *addr,
-                                  socklen_t *addr_len, sa_family_t *sa_family)
+socket_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr,
+                                 socklen_t *addr_len, sa_family_t *sa_family)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", sa_family, err);
-        GF_VALIDATE_OR_GOTO ("socket", addr, err);
-        GF_VALIDATE_OR_GOTO ("socket", addr_len, err);
+    GF_VALIDATE_OR_GOTO("socket", sa_family, err);
+    GF_VALIDATE_OR_GOTO("socket", addr, err);
+    GF_VALIDATE_OR_GOTO("socket", addr_len, err);
 
-        ret = server_fill_address_family (this, &addr->sa_family);
-        if (ret == -1) {
-                goto err;
-        }
+    ret = server_fill_address_family(this, &addr->sa_family);
+    if (ret == -1) {
+        goto err;
+    }
 
-        *sa_family = addr->sa_family;
+    *sa_family = addr->sa_family;
 
-        switch (addr->sa_family)
-        {
+    switch (addr->sa_family) {
         case AF_INET_SDP:
-                addr->sa_family = AF_INET;
-                /* Fall through */
+            addr->sa_family = AF_INET;
+            /* Fall through */
         case AF_INET:
         case AF_INET6:
         case AF_UNSPEC:
-                ret = af_inet_server_get_local_sockaddr (this, addr, addr_len);
-                break;
+            ret = af_inet_server_get_local_sockaddr(this, addr, addr_len);
+            break;
 
         case AF_UNIX:
-                ret = af_unix_server_get_local_sockaddr (this, addr, addr_len);
-                break;
-        }
+            ret = af_unix_server_get_local_sockaddr(this, addr, addr_len);
+            break;
+    }
 
-        if (*sa_family == AF_UNSPEC) {
-                *sa_family = addr->sa_family;
-        }
+    if (*sa_family == AF_UNSPEC) {
+        *sa_family = addr->sa_family;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
 int32_t
-fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr,
-                             int32_t addr_len, char *identifier)
+fill_inet6_inet_identifiers(rpc_transport_t *this,
+                            struct sockaddr_storage *addr, int32_t addr_len,
+                            char *identifier)
 {
-        union gf_sock_union sock_union;
-
-        char    service[NI_MAXSERV] = {0,};
-        char    host[NI_MAXHOST]    = {0,};
-        int32_t ret                 = 0;
-        int32_t tmpaddr_len         = 0;
-        int32_t one_to_four         = 0;
-        int32_t four_to_eight       = 0;
-        int32_t twelve_to_sixteen   = 0;
-        int16_t eight_to_ten        = 0;
-        int16_t ten_to_twelve       = 0;
-
-        memset (&sock_union, 0, sizeof (sock_union));
-        sock_union.storage = *addr;
-        tmpaddr_len = addr_len;
-
-        if (sock_union.sa.sa_family == AF_INET6) {
-                one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
-                four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
+    union gf_sock_union sock_union;
+
+    char service[NI_MAXSERV] = {
+        0,
+    };
+    char host[NI_MAXHOST] = {
+        0,
+    };
+    int32_t ret = 0;
+    int32_t tmpaddr_len = 0;
+    int32_t one_to_four = 0;
+    int32_t four_to_eight = 0;
+    int32_t twelve_to_sixteen = 0;
+    int16_t eight_to_ten = 0;
+    int16_t ten_to_twelve = 0;
+
+    memset(&sock_union, 0, sizeof(sock_union));
+    sock_union.storage = *addr;
+    tmpaddr_len = addr_len;
+
+    if (sock_union.sa.sa_family == AF_INET6) {
+        one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0];
+        four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1];
 #ifdef GF_SOLARIS_HOST_OS
-                eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
+        eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4];
 #else
-                eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
+        eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4];
 #endif
 
 #ifdef GF_SOLARIS_HOST_OS
-                ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
+        ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5];
 #else
-                ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
+        ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5];
 #endif
 
-                twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
-
-                /* ipv4 mapped ipv6 address has
-                   bits 0-80: 0
-                   bits 80-96: 0xffff
-                   bits 96-128: ipv4 address
-                */
-
-                if (one_to_four == 0 &&
-                    four_to_eight == 0 &&
-                    eight_to_ten == 0 &&
-                    ten_to_twelve == -1) {
-                        struct sockaddr_in *in_ptr = &sock_union.sin;
-                        memset (&sock_union, 0, sizeof (sock_union));
-
-                        in_ptr->sin_family = AF_INET;
-                        in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
-                        in_ptr->sin_addr.s_addr = twelve_to_sixteen;
-                        tmpaddr_len = sizeof (*in_ptr);
-                }
-        }
+        twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3];
+
+        /* ipv4 mapped ipv6 address has
+           bits 0-80: 0
+           bits 80-96: 0xffff
+           bits 96-128: ipv4 address
+        */
+
+        if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 &&
+            ten_to_twelve == -1) {
+            struct sockaddr_in *in_ptr = &sock_union.sin;
+            memset(&sock_union, 0, sizeof(sock_union));
 
-        ret = getnameinfo (&sock_union.sa,
-                           tmpaddr_len,
-                           host, sizeof (host),
-                           service, sizeof (service),
-                           NI_NUMERICHOST | NI_NUMERICSERV);
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "getnameinfo failed (%s)", gai_strerror (ret));
+            in_ptr->sin_family = AF_INET;
+            in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port;
+            in_ptr->sin_addr.s_addr = twelve_to_sixteen;
+            tmpaddr_len = sizeof(*in_ptr);
         }
+    }
 
-        sprintf (identifier, "%s:%s", host, service);
+    ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service,
+                      sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV);
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR, "getnameinfo failed (%s)",
+               gai_strerror(ret));
+    }
 
-        return ret;
+    sprintf(identifier, "%s:%s", host, service);
+
+    return ret;
 }
 
 int32_t
-get_transport_identifiers (rpc_transport_t *this)
+get_transport_identifiers(rpc_transport_t *this)
 {
-        int32_t ret = 0;
-        char is_inet_sdp = 0;
+    int32_t ret = 0;
+    char is_inet_sdp = 0;
 
-        switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family)
-        {
+    switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) {
         case AF_INET_SDP:
-                is_inet_sdp = 1;
-                ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET;
+            is_inet_sdp = 1;
+            ((struct sockaddr *)&this->peerinfo.sockaddr)
+                ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                  ->sa_family = AF_INET;
         /* Fall through */
         case AF_INET:
-        case AF_INET6:
-        {
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->myinfo.sockaddr,
-                                                   this->myinfo.sockaddr_len,
-                                                   this->myinfo.identifier);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot fill inet/inet6 identifier for server");
-                        goto err;
-                }
-
-                ret = fill_inet6_inet_identifiers (this,
-                                                   &this->peerinfo.sockaddr,
-                                                   this->peerinfo.sockaddr_len,
-                                                   this->peerinfo.identifier);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "cannot fill inet/inet6 identifier for client");
-                        goto err;
-                }
+        case AF_INET6: {
+            ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr,
+                                              this->myinfo.sockaddr_len,
+                                              this->myinfo.identifier);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "cannot fill inet/inet6 identifier for server");
+                goto err;
+            }
+
+            ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr,
+                                              this->peerinfo.sockaddr_len,
+                                              this->peerinfo.identifier);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "cannot fill inet/inet6 identifier for client");
+                goto err;
+            }
 
-                if (is_inet_sdp) {
-                        ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP;
-                }
-        }
-        break;
+            if (is_inet_sdp) {
+                ((struct sockaddr *)&this->peerinfo.sockaddr)
+                    ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr)
+                                      ->sa_family = AF_INET_SDP;
+            }
+        } break;
 
-        case AF_UNIX:
-        {
-                struct sockaddr_un *sunaddr = NULL;
+        case AF_UNIX: {
+            struct sockaddr_un *sunaddr = NULL;
 
-                sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr;
-                strcpy (this->myinfo.identifier, sunaddr->sun_path);
+            sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr;
+            strcpy(this->myinfo.identifier, sunaddr->sun_path);
 
-                sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr;
-                strcpy (this->peerinfo.identifier, sunaddr->sun_path);
-        }
-        break;
+            sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr;
+            strcpy(this->peerinfo.identifier, sunaddr->sun_path);
+        } break;
 
         default:
-                gf_log (this->name, GF_LOG_ERROR,
-                        "unknown address family (%d)",
-                        ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family);
-                ret = -1;
-                break;
-        }
+            gf_log(this->name, GF_LOG_ERROR, "unknown address family (%d)",
+                   ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family);
+            ret = -1;
+            break;
+    }
 
 err:
-        return ret;
+    return ret;
 }
diff --git a/rpc/rpc-transport/socket/src/socket.c b/rpc/rpc-transport/socket/src/socket.c
index 2c222ce8321..b3f8b7fc580 100644
--- a/rpc/rpc-transport/socket/src/socket.c
+++ b/rpc/rpc-transport/socket/src/socket.c
@@ -42,591 +42,583 @@
 #define GF_LOG_ERRNO(errno) ((errno == ENOTCONN) ? GF_LOG_DEBUG : GF_LOG_ERROR)
 #define SA(ptr) ((struct sockaddr *)ptr)
 
-#define SSL_ENABLED_OPT     "transport.socket.ssl-enabled"
-#define SSL_OWN_CERT_OPT    "transport.socket.ssl-own-cert"
+#define SSL_ENABLED_OPT "transport.socket.ssl-enabled"
+#define SSL_OWN_CERT_OPT "transport.socket.ssl-own-cert"
 #define SSL_PRIVATE_KEY_OPT "transport.socket.ssl-private-key"
-#define SSL_CA_LIST_OPT     "transport.socket.ssl-ca-list"
-#define SSL_CERT_DEPTH_OPT  "transport.socket.ssl-cert-depth"
+#define SSL_CA_LIST_OPT "transport.socket.ssl-ca-list"
+#define SSL_CERT_DEPTH_OPT "transport.socket.ssl-cert-depth"
 #define SSL_CIPHER_LIST_OPT "transport.socket.ssl-cipher-list"
-#define SSL_DH_PARAM_OPT    "transport.socket.ssl-dh-param"
-#define SSL_EC_CURVE_OPT    "transport.socket.ssl-ec-curve"
-#define SSL_CRL_PATH_OPT    "transport.socket.ssl-crl-path"
-#define OWN_THREAD_OPT      "transport.socket.own-thread"
+#define SSL_DH_PARAM_OPT "transport.socket.ssl-dh-param"
+#define SSL_EC_CURVE_OPT "transport.socket.ssl-ec-curve"
+#define SSL_CRL_PATH_OPT "transport.socket.ssl-crl-path"
+#define OWN_THREAD_OPT "transport.socket.own-thread"
 
 /* TBD: do automake substitutions etc. (ick) to set these. */
 #if !defined(DEFAULT_ETC_SSL)
-#  ifdef GF_LINUX_HOST_OS
-#    define DEFAULT_ETC_SSL "/etc/ssl"
-#  endif
-#  ifdef GF_BSD_HOST_OS
-#    define DEFAULT_ETC_SSL "/etc/openssl"
-#  endif
-#  ifdef GF_DARWIN_HOST_OS
-#    define DEFAULT_ETC_SSL "/usr/local/etc/openssl"
-#  endif
-#  if !defined(DEFAULT_ETC_SSL)
-#    define DEFAULT_ETC_SSL "/etc/ssl"
-#  endif
+#ifdef GF_LINUX_HOST_OS
+#define DEFAULT_ETC_SSL "/etc/ssl"
+#endif
+#ifdef GF_BSD_HOST_OS
+#define DEFAULT_ETC_SSL "/etc/openssl"
+#endif
+#ifdef GF_DARWIN_HOST_OS
+#define DEFAULT_ETC_SSL "/usr/local/etc/openssl"
+#endif
+#if !defined(DEFAULT_ETC_SSL)
+#define DEFAULT_ETC_SSL "/etc/ssl"
+#endif
 #endif
 
 #if !defined(DEFAULT_CERT_PATH)
-#define DEFAULT_CERT_PATH   DEFAULT_ETC_SSL "/glusterfs.pem"
+#define DEFAULT_CERT_PATH DEFAULT_ETC_SSL "/glusterfs.pem"
 #endif
 #if !defined(DEFAULT_KEY_PATH)
-#define DEFAULT_KEY_PATH    DEFAULT_ETC_SSL "/glusterfs.key"
+#define DEFAULT_KEY_PATH DEFAULT_ETC_SSL "/glusterfs.key"
 #endif
 #if !defined(DEFAULT_CA_PATH)
-#define DEFAULT_CA_PATH     DEFAULT_ETC_SSL "/glusterfs.ca"
+#define DEFAULT_CA_PATH DEFAULT_ETC_SSL "/glusterfs.ca"
 #endif
 #if !defined(DEFAULT_VERIFY_DEPTH)
 #define DEFAULT_VERIFY_DEPTH 1
 #endif
 #define DEFAULT_CIPHER_LIST "EECDH:EDH:HIGH:!3DES:!RC4:!DES:!MD5:!aNULL:!eNULL"
-#define DEFAULT_DH_PARAM   DEFAULT_ETC_SSL "/dhparam.pem"
-#define DEFAULT_EC_CURVE   "prime256v1"
+#define DEFAULT_DH_PARAM DEFAULT_ETC_SSL "/dhparam.pem"
+#define DEFAULT_EC_CURVE "prime256v1"
 
-#define POLL_MASK_INPUT  (POLLIN | POLLPRI)
+#define POLL_MASK_INPUT (POLLIN | POLLPRI)
 #define POLL_MASK_OUTPUT (POLLOUT)
-#define POLL_MASK_ERROR  (POLLERR | POLLHUP | POLLNVAL)
-
-typedef int SSL_unary_func (SSL *);
-typedef int SSL_trinary_func (SSL *, void *, int);
-static int ssl_setup_connection_params(rpc_transport_t *this);
-
-#define __socket_proto_reset_pending(priv) do {                         \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                                                                        \
-                memset (&frag->vector, 0, sizeof (frag->vector));       \
-                frag->pending_vector = &frag->vector;                   \
-                frag->pending_vector->iov_base = frag->fragcurrent;     \
-                priv->incoming.pending_vector =  frag->pending_vector;  \
-        } while (0)
-
-
-#define __socket_proto_update_pending(priv)                             \
-        do {                                                            \
-                uint32_t remaining;                                     \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                if (frag->pending_vector->iov_len == 0) {               \
-                        remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr) \
-                                     - frag->bytes_read);               \
-                                                                        \
-                        frag->pending_vector->iov_len =                 \
-                                (remaining > frag->remaining_size)      \
-                                ? frag->remaining_size : remaining;     \
-                                                                        \
-                        frag->remaining_size -=                         \
-                                frag->pending_vector->iov_len;          \
-                }                                                       \
-        } while (0)
-
-#define __socket_proto_update_priv_after_read(priv, ret, bytes_read)    \
-        {                                                               \
-                struct gf_sock_incoming_frag *frag;                     \
-                frag = &priv->incoming.frag;                            \
-                                                                        \
-                frag->fragcurrent += bytes_read;                        \
-                frag->bytes_read += bytes_read;                         \
-                                                                        \
-                if ((ret > 0) || (frag->remaining_size != 0)) {         \
-                        if (frag->remaining_size != 0 && ret == 0) {    \
-                                __socket_proto_reset_pending (priv);    \
-                        }                                               \
-                                                                        \
-                        gf_log (this->name, GF_LOG_TRACE,               \
-                                "partial read on non-blocking socket"); \
-                                                                        \
-                        break;                                          \
-                }                                                       \
-        }
-
-#define __socket_proto_init_pending(priv,size)                          \
-        do {                                                            \
-            uint32_t remaining = 0;                                     \
-            struct gf_sock_incoming_frag *frag;                         \
-            frag = &priv->incoming.frag;                                \
-                                                                        \
-            remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr)          \
-                         - frag->bytes_read);                           \
-                                                                        \
-            __socket_proto_reset_pending (priv);                        \
-                                                                        \
-            frag->pending_vector->iov_len =                             \
-                    (remaining > size) ? size : remaining;              \
-                                                                        \
-            frag->remaining_size = (size - frag->pending_vector->iov_len); \
-                                                                        \
-            } while(0)
+#define POLL_MASK_ERROR (POLLERR | POLLHUP | POLLNVAL)
 
+typedef int
+SSL_unary_func(SSL *);
+typedef int
+SSL_trinary_func(SSL *, void *, int);
+static int
+ssl_setup_connection_params(rpc_transport_t *this);
+
+#define __socket_proto_reset_pending(priv)                                     \
+    do {                                                                       \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        memset(&frag->vector, 0, sizeof(frag->vector));                        \
+        frag->pending_vector = &frag->vector;                                  \
+        frag->pending_vector->iov_base = frag->fragcurrent;                    \
+        priv->incoming.pending_vector = frag->pending_vector;                  \
+    } while (0)
+
+#define __socket_proto_update_pending(priv)                                    \
+    do {                                                                       \
+        uint32_t remaining;                                                    \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+        if (frag->pending_vector->iov_len == 0) {                              \
+            remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) -                \
+                         frag->bytes_read);                                    \
+                                                                               \
+            frag->pending_vector->iov_len = (remaining > frag->remaining_size) \
+                                                ? frag->remaining_size         \
+                                                : remaining;                   \
+                                                                               \
+            frag->remaining_size -= frag->pending_vector->iov_len;             \
+        }                                                                      \
+    } while (0)
+
+#define __socket_proto_update_priv_after_read(priv, ret, bytes_read)           \
+    {                                                                          \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        frag->fragcurrent += bytes_read;                                       \
+        frag->bytes_read += bytes_read;                                        \
+                                                                               \
+        if ((ret > 0) || (frag->remaining_size != 0)) {                        \
+            if (frag->remaining_size != 0 && ret == 0) {                       \
+                __socket_proto_reset_pending(priv);                            \
+            }                                                                  \
+                                                                               \
+            gf_log(this->name, GF_LOG_TRACE,                                   \
+                   "partial read on non-blocking socket");                     \
+                                                                               \
+            break;                                                             \
+        }                                                                      \
+    }
+
+#define __socket_proto_init_pending(priv, size)                                \
+    do {                                                                       \
+        uint32_t remaining = 0;                                                \
+        struct gf_sock_incoming_frag *frag;                                    \
+        frag = &priv->incoming.frag;                                           \
+                                                                               \
+        remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) - frag->bytes_read); \
+                                                                               \
+        __socket_proto_reset_pending(priv);                                    \
+                                                                               \
+        frag->pending_vector->iov_len = (remaining > size) ? size : remaining; \
+                                                                               \
+        frag->remaining_size = (size - frag->pending_vector->iov_len);         \
+                                                                               \
+    } while (0)
 
 /* This will be used in a switch case and breaks from the switch case if all
  * the pending data is not read.
  */
-#define __socket_proto_read(priv, ret)                                  \
-                {                                                       \
-                size_t bytes_read = 0;                                  \
-                struct gf_sock_incoming *in;                            \
-                in = &priv->incoming;                                   \
-                                                                        \
-                __socket_proto_update_pending (priv);                   \
-                                                                        \
-                ret = __socket_readv (this,                             \
-                                      in->pending_vector, 1,            \
-                                      &in->pending_vector,              \
-                                      &in->pending_count,               \
-                                      &bytes_read);                     \
-                if (ret == -1)                                          \
-                        break;                                          \
-                __socket_proto_update_priv_after_read (priv, ret, bytes_read); \
-        }
+#define __socket_proto_read(priv, ret)                                         \
+    {                                                                          \
+        size_t bytes_read = 0;                                                 \
+        struct gf_sock_incoming *in;                                           \
+        in = &priv->incoming;                                                  \
+                                                                               \
+        __socket_proto_update_pending(priv);                                   \
+                                                                               \
+        ret = __socket_readv(this, in->pending_vector, 1, &in->pending_vector, \
+                             &in->pending_count, &bytes_read);                 \
+        if (ret == -1)                                                         \
+            break;                                                             \
+        __socket_proto_update_priv_after_read(priv, ret, bytes_read);          \
+    }
 
 struct socket_connect_error_state_ {
-        xlator_t            *this;
-        rpc_transport_t     *trans;
-        gf_boolean_t         refd;
+    xlator_t *this;
+    rpc_transport_t *trans;
+    gf_boolean_t refd;
 };
 typedef struct socket_connect_error_state_ socket_connect_error_state_t;
 
-static int socket_init (rpc_transport_t *this);
-static int __socket_nonblock (int fd);
+static int
+socket_init(rpc_transport_t *this);
+static int
+__socket_nonblock(int fd);
 
 static void
-socket_dump_info (struct sockaddr *sa, int is_server, int is_ssl, int sock,
-                  char *log_domain, char *log_label)
+socket_dump_info(struct sockaddr *sa, int is_server, int is_ssl, int sock,
+                 char *log_domain, char *log_label)
 {
-        char  addr_buf[INET6_ADDRSTRLEN+1] = {0, };
-        char *addr = NULL;
-        char *peer_type = NULL;
-        int   af = sa->sa_family;
-        int   so_error = -1;
-        socklen_t slen = sizeof(so_error);
-
-        if (af == AF_UNIX) {
-                addr = ((struct sockaddr_un *)(sa))->sun_path;
+    char addr_buf[INET6_ADDRSTRLEN + 1] = {
+        0,
+    };
+    char *addr = NULL;
+    char *peer_type = NULL;
+    int af = sa->sa_family;
+    int so_error = -1;
+    socklen_t slen = sizeof(so_error);
+
+    if (af == AF_UNIX) {
+        addr = ((struct sockaddr_un *)(sa))->sun_path;
+    } else {
+        if (af == AF_INET6) {
+            struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)(sa);
+
+            inet_ntop(af, &sin6->sin6_addr, addr_buf, sizeof(addr_buf));
+            addr = addr_buf;
         } else {
-                if (af == AF_INET6) {
-                        struct sockaddr_in6 *sin6 =
-                                (struct sockaddr_in6 *)(sa);
+            struct sockaddr_in *sin = (struct sockaddr_in *)(sa);
 
-                        inet_ntop (af, &sin6->sin6_addr, addr_buf,
-                                   sizeof (addr_buf));
-                        addr = addr_buf;
-                } else {
-                        struct sockaddr_in *sin =
-                                (struct sockaddr_in *)(sa);
-
-                        inet_ntop (af, &sin->sin_addr, addr_buf,
-                                   sizeof (addr_buf));
-                        addr = addr_buf;
-                }
+            inet_ntop(af, &sin->sin_addr, addr_buf, sizeof(addr_buf));
+            addr = addr_buf;
         }
-        if (is_server)
-                peer_type = "server";
-        else
-                peer_type = "client";
+    }
+    if (is_server)
+        peer_type = "server";
+    else
+        peer_type = "client";
 
-        getsockopt (sock, SOL_SOCKET, SO_ERROR, &so_error, &slen);
+    getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_error, &slen);
 
-        gf_log (log_domain, GF_LOG_TRACE,
-                "$$$ %s: %s (af:%d,sock:%d) %s %s (errno:%d:%s)",
-                peer_type, log_label, af, sock, addr,
-                (is_ssl ? "SSL" : "non-SSL"),
-                so_error, strerror (so_error));
+    gf_log(log_domain, GF_LOG_TRACE,
+           "$$$ %s: %s (af:%d,sock:%d) %s %s (errno:%d:%s)", peer_type,
+           log_label, af, sock, addr, (is_ssl ? "SSL" : "non-SSL"), so_error,
+           strerror(so_error));
 }
 
 static void
-ssl_dump_error_stack (const char *caller)
+ssl_dump_error_stack(const char *caller)
 {
-        unsigned long  errnum = 0;
-        char           errbuf[120] = {0, };
+    unsigned long errnum = 0;
+    char errbuf[120] = {
+        0,
+    };
 
-        /* OpenSSL docs explicitly give 120 as the error-string length. */
+    /* OpenSSL docs explicitly give 120 as the error-string length. */
 
-        while ((errnum = ERR_get_error())) {
-                ERR_error_string(errnum, errbuf);
-                gf_log(caller, GF_LOG_ERROR, "  %s", errbuf);
-        }
+    while ((errnum = ERR_get_error())) {
+        ERR_error_string(errnum, errbuf);
+        gf_log(caller, GF_LOG_ERROR, "  %s", errbuf);
+    }
 }
 
 static int
-ssl_do (rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func)
+ssl_do(rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func)
 {
-        int               r = (-1);
-        socket_private_t *priv = NULL;
-
-        GF_VALIDATE_OR_GOTO(this->name, this->private, out);
-        priv = this->private;
-
-        if (buf) {
-                if (priv->connected == -1) {
-                        /*
-                         * Fields in the SSL structure (especially
-                         * the BIO pointers) are not valid at this
-                         * point, so we'll segfault if we pass them
-                         * to SSL_read/SSL_write.
-                         */
-                        gf_log (this->name, GF_LOG_INFO,
-                                "lost connection in %s", __func__);
-                        return -1;
-                }
-                r = func (priv->ssl_ssl, buf, len);
-        } else {
-                /*
-                 * We actually need these functions to get to
-                 * priv->connected == 1.
-                 */
-                r = ((SSL_unary_func *)func)(priv->ssl_ssl);
-        }
-        switch (SSL_get_error (priv->ssl_ssl, r)) {
+    int r = (-1);
+    socket_private_t *priv = NULL;
+
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+    priv = this->private;
+
+    if (buf) {
+        if (priv->connected == -1) {
+            /*
+             * Fields in the SSL structure (especially
+             * the BIO pointers) are not valid at this
+             * point, so we'll segfault if we pass them
+             * to SSL_read/SSL_write.
+             */
+            gf_log(this->name, GF_LOG_INFO, "lost connection in %s", __func__);
+            return -1;
+        }
+        r = func(priv->ssl_ssl, buf, len);
+    } else {
+        /*
+         * We actually need these functions to get to
+         * priv->connected == 1.
+         */
+        r = ((SSL_unary_func *)func)(priv->ssl_ssl);
+    }
+    switch (SSL_get_error(priv->ssl_ssl, r)) {
         case SSL_ERROR_NONE:
         /* fall through */
         case SSL_ERROR_WANT_READ:
         /* fall through */
         case SSL_ERROR_WANT_WRITE:
-                errno = EAGAIN;
-                return r;
+            errno = EAGAIN;
+            return r;
 
         case SSL_ERROR_SYSCALL:
-                /* Sometimes SSL_ERROR_SYSCALL returns errno as
-                 * EAGAIN. In such a case we should reattempt operation
-                 * So, for now, just return the return value and the
-                 * errno as is.
-                 */
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "syscall error (probably remote disconnect) "
-                        "errno:%d:%s", errno, strerror(errno));
-                return r;
+            /* Sometimes SSL_ERROR_SYSCALL returns errno as
+             * EAGAIN. In such a case we should reattempt operation
+             * So, for now, just return the return value and the
+             * errno as is.
+             */
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "syscall error (probably remote disconnect) "
+                   "errno:%d:%s",
+                   errno, strerror(errno));
+            return r;
         default:
-                errno = EIO;
-                goto out;       /* "break" would just loop again */
-        }
+            errno = EIO;
+            goto out; /* "break" would just loop again */
+    }
 out:
-        return -1;
+    return -1;
 }
 
-#define ssl_read_one(t, b, l)  ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_read)
-#define ssl_write_one(t, b, l) ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_write)
-
+#define ssl_read_one(t, b, l)                                                  \
+    ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_read)
+#define ssl_write_one(t, b, l)                                                 \
+    ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_write)
 
 int
-ssl_setup_connection_prefix (rpc_transport_t *this)
+ssl_setup_connection_prefix(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = NULL;
-
-        GF_VALIDATE_OR_GOTO(this->name, this->private, done);
+    int ret = -1;
+    socket_private_t *priv = NULL;
 
-        priv = this->private;
-
-        if (ssl_setup_connection_params (this) < 0) {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "+ ssl_setup_connection_params() failed!");
-                goto done;
-        } else {
-                gf_log (this->name, GF_LOG_TRACE,
-                        "+ ssl_setup_connection_params() done!");
-        }
+    GF_VALIDATE_OR_GOTO(this->name, this->private, done);
 
-        priv->ssl_error_required = SSL_ERROR_NONE;
-        priv->ssl_connected = _gf_false;
-        priv->ssl_accepted = _gf_false;
-        priv->ssl_context_created = _gf_false;
+    priv = this->private;
 
-        priv->ssl_ssl = SSL_new(priv->ssl_ctx);
-        if (!priv->ssl_ssl) {
-                gf_log(this->name, GF_LOG_ERROR, "SSL_new failed");
-                ssl_dump_error_stack(this->name);
-                goto done;
-        }
+    if (ssl_setup_connection_params(this) < 0) {
+        gf_log(this->name, GF_LOG_TRACE,
+               "+ ssl_setup_connection_params() failed!");
+        goto done;
+    } else {
+        gf_log(this->name, GF_LOG_TRACE,
+               "+ ssl_setup_connection_params() done!");
+    }
+
+    priv->ssl_error_required = SSL_ERROR_NONE;
+    priv->ssl_connected = _gf_false;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_context_created = _gf_false;
+
+    priv->ssl_ssl = SSL_new(priv->ssl_ctx);
+    if (!priv->ssl_ssl) {
+        gf_log(this->name, GF_LOG_ERROR, "SSL_new failed");
+        ssl_dump_error_stack(this->name);
+        goto done;
+    }
 
-        priv->ssl_sbio = BIO_new_socket(priv->sock, BIO_NOCLOSE);
-        if (!priv->ssl_sbio) {
-                gf_log(this->name, GF_LOG_ERROR, "BIO_new_socket failed");
-                ssl_dump_error_stack(this->name);
-                goto free_ssl;
-        }
+    priv->ssl_sbio = BIO_new_socket(priv->sock, BIO_NOCLOSE);
+    if (!priv->ssl_sbio) {
+        gf_log(this->name, GF_LOG_ERROR, "BIO_new_socket failed");
+        ssl_dump_error_stack(this->name);
+        goto free_ssl;
+    }
 
-        SSL_set_bio (priv->ssl_ssl, priv->ssl_sbio, priv->ssl_sbio);
-        ret = 0;
-        goto done;
+    SSL_set_bio(priv->ssl_ssl, priv->ssl_sbio, priv->ssl_sbio);
+    ret = 0;
+    goto done;
 
 free_ssl:
-        SSL_free(priv->ssl_ssl);
-        priv->ssl_ssl = NULL;
+    SSL_free(priv->ssl_ssl);
+    priv->ssl_ssl = NULL;
 done:
-        return ret;
+    return ret;
 }
 
 static char *
-ssl_setup_connection_postfix (rpc_transport_t *this)
+ssl_setup_connection_postfix(rpc_transport_t *this)
 {
-        X509             *peer = NULL;
-        char              peer_CN[256] = "";
-        socket_private_t *priv = NULL;
-
-        GF_VALIDATE_OR_GOTO(this->name, this->private, done);
-        priv = this->private;
-
-        /* Make sure _SSL verification_ succeeded, yielding an identity. */
-        if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) {
-                goto ssl_error;
-        }
-        peer = SSL_get_peer_certificate(priv->ssl_ssl);
-        if (!peer) {
-                goto ssl_error;
-        }
-
-        SSL_set_mode(priv->ssl_ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
-
-        /* Finally, everything seems OK. */
-        X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
-                NID_commonName, peer_CN, sizeof(peer_CN)-1);
-        peer_CN[sizeof(peer_CN)-1] = '\0';
-        gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN);
-        gf_log (this->name, GF_LOG_DEBUG,
-                "SSL verification succeeded (client: %s) (server: %s)",
-                this->peerinfo.identifier, this->myinfo.identifier);
-        return gf_strdup(peer_CN);
-
-        /* Error paths. */
+    X509 *peer = NULL;
+    char peer_CN[256] = "";
+    socket_private_t *priv = NULL;
+
+    GF_VALIDATE_OR_GOTO(this->name, this->private, done);
+    priv = this->private;
+
+    /* Make sure _SSL verification_ succeeded, yielding an identity. */
+    if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) {
+        goto ssl_error;
+    }
+    peer = SSL_get_peer_certificate(priv->ssl_ssl);
+    if (!peer) {
+        goto ssl_error;
+    }
+
+    SSL_set_mode(priv->ssl_ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
+
+    /* Finally, everything seems OK. */
+    X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName,
+                              peer_CN, sizeof(peer_CN) - 1);
+    peer_CN[sizeof(peer_CN) - 1] = '\0';
+    gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN);
+    gf_log(this->name, GF_LOG_DEBUG,
+           "SSL verification succeeded (client: %s) (server: %s)",
+           this->peerinfo.identifier, this->myinfo.identifier);
+    return gf_strdup(peer_CN);
+
+    /* Error paths. */
 ssl_error:
-        gf_log (this->name, GF_LOG_ERROR,
-                "SSL connect error (client: %s) (server: %s)",
-                this->peerinfo.identifier, this->myinfo.identifier);
-        ssl_dump_error_stack(this->name);
+    gf_log(this->name, GF_LOG_ERROR,
+           "SSL connect error (client: %s) (server: %s)",
+           this->peerinfo.identifier, this->myinfo.identifier);
+    ssl_dump_error_stack(this->name);
 
-        SSL_free(priv->ssl_ssl);
-        priv->ssl_ssl = NULL;
+    SSL_free(priv->ssl_ssl);
+    priv->ssl_ssl = NULL;
 done:
-        return NULL;
+    return NULL;
 }
 
-
 int
-ssl_complete_connection (rpc_transport_t *this)
+ssl_complete_connection(rpc_transport_t *this)
 {
-        int     ret     = -1; /*  1 : implies go back to epoll_wait()
-                               *  0 : implies successful ssl connection
-                               * -1: implies continue processing current event
-                               *     as if EPOLLERR has been encountered
-                               */
-        char    *cname  = NULL;
-        int     r       = -1;
-        int     ssl_error = -1;
-        socket_private_t *priv = NULL;
-
+    int ret = -1; /*  1 : implies go back to epoll_wait()
+                   *  0 : implies successful ssl connection
+                   * -1: implies continue processing current event
+                   *     as if EPOLLERR has been encountered
+                   */
+    char *cname = NULL;
+    int r = -1;
+    int ssl_error = -1;
+    socket_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->is_server) {
-                r = SSL_accept (priv->ssl_ssl);
-        } else {
-                r = SSL_connect (priv->ssl_ssl);
-        }
+    if (priv->is_server) {
+        r = SSL_accept(priv->ssl_ssl);
+    } else {
+        r = SSL_connect(priv->ssl_ssl);
+    }
 
-        ssl_error = SSL_get_error (priv->ssl_ssl, r);
-        priv->ssl_error_required = ssl_error;
+    ssl_error = SSL_get_error(priv->ssl_ssl, r);
+    priv->ssl_error_required = ssl_error;
 
-        switch (ssl_error) {
+    switch (ssl_error) {
         case SSL_ERROR_NONE:
-                cname = ssl_setup_connection_postfix (this);
-                if (!cname) {
-                        /* we've failed to get the cname so
-                         * we must close the connection
-                         *
-                         * treat this as EPOLLERR
-                         */
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "error getting cname");
-                        errno = ECONNRESET;
-                        ret = -1;
+            cname = ssl_setup_connection_postfix(this);
+            if (!cname) {
+                /* we've failed to get the cname so
+                 * we must close the connection
+                 *
+                 * treat this as EPOLLERR
+                 */
+                gf_log(this->name, GF_LOG_TRACE, "error getting cname");
+                errno = ECONNRESET;
+                ret = -1;
+            } else {
+                this->ssl_name = cname;
+                if (priv->is_server) {
+                    priv->ssl_accepted = _gf_true;
+                    gf_log(this->name, GF_LOG_TRACE, "ssl_accepted!");
                 } else {
-                        this->ssl_name = cname;
-                        if (priv->is_server) {
-                                priv->ssl_accepted = _gf_true;
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "ssl_accepted!");
-                        } else {
-                                priv->ssl_connected = _gf_true;
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "ssl_connected!");
-                        }
-                        ret = 0;
+                    priv->ssl_connected = _gf_true;
+                    gf_log(this->name, GF_LOG_TRACE, "ssl_connected!");
                 }
-                break;
+                ret = 0;
+            }
+            break;
 
         case SSL_ERROR_WANT_READ:
         /* fall through */
         case SSL_ERROR_WANT_WRITE:
-                errno = EAGAIN;
-                break;
+            errno = EAGAIN;
+            break;
 
         case SSL_ERROR_SYSCALL:
-        /* Sometimes SSL_ERROR_SYSCALL returns with errno as EAGAIN
-         * So, we should retry the operation.
-         * So, for now, we just return the return value and errno as is.
-         */
-                break;
+            /* Sometimes SSL_ERROR_SYSCALL returns with errno as EAGAIN
+             * So, we should retry the operation.
+             * So, for now, we just return the return value and errno as is.
+             */
+            break;
 
         case SSL_ERROR_SSL:
-                /* treat this as EPOLLERR */
-                ret = -1;
-                break;
+            /* treat this as EPOLLERR */
+            ret = -1;
+            break;
 
         default:
-                /* treat this as EPOLLERR */
-                errno = EIO;
-                ret = -1;
-                break;
-        }
-        return ret;
+            /* treat this as EPOLLERR */
+            errno = EIO;
+            ret = -1;
+            break;
+    }
+    return ret;
 }
 
 static void
-ssl_teardown_connection (socket_private_t *priv)
+ssl_teardown_connection(socket_private_t *priv)
 {
-        if (priv->ssl_ssl) {
-                SSL_shutdown(priv->ssl_ssl);
-                SSL_clear(priv->ssl_ssl);
-                SSL_free(priv->ssl_ssl);
-                SSL_CTX_free(priv->ssl_ctx);
-                priv->ssl_ssl = NULL;
-                priv->ssl_ctx = NULL;
-                if (priv->ssl_private_key) {
-                        GF_FREE (priv->ssl_private_key);
-                        priv->ssl_private_key = NULL;
-                }
-                if (priv->ssl_own_cert) {
-                        GF_FREE (priv->ssl_own_cert);
-                        priv->ssl_own_cert = NULL;
-                }
-                if (priv->ssl_ca_list) {
-                        GF_FREE (priv->ssl_ca_list);
-                        priv->ssl_ca_list = NULL;
-                }
+    if (priv->ssl_ssl) {
+        SSL_shutdown(priv->ssl_ssl);
+        SSL_clear(priv->ssl_ssl);
+        SSL_free(priv->ssl_ssl);
+        SSL_CTX_free(priv->ssl_ctx);
+        priv->ssl_ssl = NULL;
+        priv->ssl_ctx = NULL;
+        if (priv->ssl_private_key) {
+            GF_FREE(priv->ssl_private_key);
+            priv->ssl_private_key = NULL;
         }
-        priv->use_ssl = _gf_false;
+        if (priv->ssl_own_cert) {
+            GF_FREE(priv->ssl_own_cert);
+            priv->ssl_own_cert = NULL;
+        }
+        if (priv->ssl_ca_list) {
+            GF_FREE(priv->ssl_ca_list);
+            priv->ssl_ca_list = NULL;
+        }
+    }
+    priv->use_ssl = _gf_false;
 }
 
-
 static ssize_t
-__socket_ssl_readv (rpc_transport_t *this, struct iovec *opvector, int opcount)
+__socket_ssl_readv(rpc_transport_t *this, struct iovec *opvector, int opcount)
 {
-        socket_private_t    *priv = NULL;
-        int                  sock = -1;
-        int                  ret = -1;
-
-        priv = this->private;
-        sock = priv->sock;
-
-        if (priv->use_ssl) {
-                gf_log (this->name, GF_LOG_TRACE, "***** reading over SSL");
-                ret = ssl_read_one (this, opvector->iov_base, opvector->iov_len);
-        } else {
-                gf_log (this->name, GF_LOG_TRACE, "***** reading over non-SSL");
-                ret = sys_readv (sock, opvector, IOV_MIN(opcount));
-        }
-
-        return ret;
+    socket_private_t *priv = NULL;
+    int sock = -1;
+    int ret = -1;
+
+    priv = this->private;
+    sock = priv->sock;
+
+    if (priv->use_ssl) {
+        gf_log(this->name, GF_LOG_TRACE, "***** reading over SSL");
+        ret = ssl_read_one(this, opvector->iov_base, opvector->iov_len);
+    } else {
+        gf_log(this->name, GF_LOG_TRACE, "***** reading over non-SSL");
+        ret = sys_readv(sock, opvector, IOV_MIN(opcount));
+    }
+
+    return ret;
 }
 
-
 static ssize_t
-__socket_ssl_read (rpc_transport_t *this, void *buf, size_t count)
+__socket_ssl_read(rpc_transport_t *this, void *buf, size_t count)
 {
-        struct iovec iov = {0, };
-        int          ret = -1;
+    struct iovec iov = {
+        0,
+    };
+    int ret = -1;
 
-        iov.iov_base = buf;
-        iov.iov_len = count;
+    iov.iov_base = buf;
+    iov.iov_len = count;
 
-        ret = __socket_ssl_readv (this, &iov, 1);
+    ret = __socket_ssl_readv(this, &iov, 1);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_cached_read (rpc_transport_t *this, struct iovec *opvector, int opcount)
+__socket_cached_read(rpc_transport_t *this, struct iovec *opvector, int opcount)
 {
-        socket_private_t   *priv = NULL;
-        struct gf_sock_incoming *in = NULL;
-        int                 req_len = -1;
-        int                 ret = -1;
-
-        priv = this->private;
-        in = &priv->incoming;
-        req_len = iov_length (opvector, opcount);
-
-        if (in->record_state == SP_STATE_READING_FRAGHDR) {
-                in->ra_read = 0;
-                in->ra_served = 0;
-                in->ra_max = 0;
-                in->ra_buf = NULL;
-                goto uncached;
-        }
-
-        if (!in->ra_max) {
-                /* first call after passing SP_STATE_READING_FRAGHDR */
-                in->ra_max = min (RPC_FRAGSIZE (in->fraghdr), GF_SOCKET_RA_MAX);
-                /* Note that the in->iobuf is the primary iobuf into which
-                   headers are read into, and in->frag.fragcurrent points to
-                   some position in the buffer. By using this itself as our
-                   read-ahead cache, we can avoid memory copies in iov_load
-                */
-                in->ra_buf = in->frag.fragcurrent;
-        }
-
-        /* fill read-ahead */
-        if (in->ra_read < in->ra_max) {
-                ret = __socket_ssl_read (this, &in->ra_buf[in->ra_read],
-                                         (in->ra_max - in->ra_read));
-                if (ret > 0)
-                        in->ra_read += ret;
-
-                /* we proceed to test if there is still cached data to
-                   be served even if readahead could not progress */
-        }
-
-        /* serve cached */
-        if (in->ra_served < in->ra_read) {
-                ret = iov_load (opvector, opcount, &in->ra_buf[in->ra_served],
-                                min (req_len, (in->ra_read - in->ra_served)));
-
-                in->ra_served += ret;
-                /* Do not read uncached and cached in the same call */
-                goto out;
-        }
-
-        if (in->ra_read < in->ra_max)
-                /* If there was no cached data to be served, (and we are
-                   guaranteed to have already performed an attempt to progress
-                   readahead above), and we have not yet read out the full
-                   readahead capacity, then bail out for now without doing
-                   the uncached read below (as that will overtake future cached
-                   read)
-                */
-                goto out;
+    socket_private_t *priv = NULL;
+    struct gf_sock_incoming *in = NULL;
+    int req_len = -1;
+    int ret = -1;
+
+    priv = this->private;
+    in = &priv->incoming;
+    req_len = iov_length(opvector, opcount);
+
+    if (in->record_state == SP_STATE_READING_FRAGHDR) {
+        in->ra_read = 0;
+        in->ra_served = 0;
+        in->ra_max = 0;
+        in->ra_buf = NULL;
+        goto uncached;
+    }
+
+    if (!in->ra_max) {
+        /* first call after passing SP_STATE_READING_FRAGHDR */
+        in->ra_max = min(RPC_FRAGSIZE(in->fraghdr), GF_SOCKET_RA_MAX);
+        /* Note that the in->iobuf is the primary iobuf into which
+           headers are read into, and in->frag.fragcurrent points to
+           some position in the buffer. By using this itself as our
+           read-ahead cache, we can avoid memory copies in iov_load
+        */
+        in->ra_buf = in->frag.fragcurrent;
+    }
+
+    /* fill read-ahead */
+    if (in->ra_read < in->ra_max) {
+        ret = __socket_ssl_read(this, &in->ra_buf[in->ra_read],
+                                (in->ra_max - in->ra_read));
+        if (ret > 0)
+            in->ra_read += ret;
+
+        /* we proceed to test if there is still cached data to
+           be served even if readahead could not progress */
+    }
+
+    /* serve cached */
+    if (in->ra_served < in->ra_read) {
+        ret = iov_load(opvector, opcount, &in->ra_buf[in->ra_served],
+                       min(req_len, (in->ra_read - in->ra_served)));
+
+        in->ra_served += ret;
+        /* Do not read uncached and cached in the same call */
+        goto out;
+    }
+
+    if (in->ra_read < in->ra_max)
+        /* If there was no cached data to be served, (and we are
+           guaranteed to have already performed an attempt to progress
+           readahead above), and we have not yet read out the full
+           readahead capacity, then bail out for now without doing
+           the uncached read below (as that will overtake future cached
+           read)
+        */
+        goto out;
 uncached:
-        ret = __socket_ssl_readv (this, opvector, opcount);
+    ret = __socket_ssl_readv(this, opvector, opcount);
 out:
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-__does_socket_rwv_error_need_logging (socket_private_t *priv, int write)
+__does_socket_rwv_error_need_logging(socket_private_t *priv, int write)
 {
-        int read = !write;
+    int read = !write;
 
-        if (priv->connected == -1) /* Didn't even connect, of course it fails */
-                return _gf_false;
+    if (priv->connected == -1) /* Didn't even connect, of course it fails */
+        return _gf_false;
 
-        if (read && (priv->read_fail_log == _gf_false))
-                return _gf_false;
+    if (read && (priv->read_fail_log == _gf_false))
+        return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 /*
@@ -637,822 +629,786 @@ __does_socket_rwv_error_need_logging (socket_private_t *priv, int write)
  */
 
 static int
-__socket_rwv (rpc_transport_t *this, struct iovec *vector, int count,
-              struct iovec **pending_vector, int *pending_count, size_t *bytes,
-              int write)
+__socket_rwv(rpc_transport_t *this, struct iovec *vector, int count,
+             struct iovec **pending_vector, int *pending_count, size_t *bytes,
+             int write)
 {
-        socket_private_t *priv = NULL;
-        int               sock = -1;
-        int               ret = -1;
-        struct iovec     *opvector = NULL;
-        int               opcount = 0;
-        int               moved = 0;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        sock = priv->sock;
-
-        opvector = vector;
-        opcount  = count;
-
-        if (bytes != NULL) {
-                *bytes = 0;
+    socket_private_t *priv = NULL;
+    int sock = -1;
+    int ret = -1;
+    struct iovec *opvector = NULL;
+    int opcount = 0;
+    int moved = 0;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    sock = priv->sock;
+
+    opvector = vector;
+    opcount = count;
+
+    if (bytes != NULL) {
+        *bytes = 0;
+    }
+
+    while (opcount > 0) {
+        if (opvector->iov_len == 0) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "would have passed zero length to read/write");
+            ++opvector;
+            --opcount;
+            continue;
+        }
+        if (priv->use_ssl && !priv->ssl_ssl) {
+            /*
+             * We could end up here with priv->ssl_ssl still NULL
+             * if (a) the connection failed and (b) some fool
+             * called other socket functions anyway.  Demoting to
+             * non-SSL might be insecure, so just fail it outright.
+             */
+            ret = -1;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "### no priv->ssl_ssl yet; ret = -1;");
+        } else if (write) {
+            if (priv->use_ssl) {
+                ret = ssl_write_one(this, opvector->iov_base,
+                                    opvector->iov_len);
+            } else {
+                ret = sys_writev(sock, opvector, IOV_MIN(opcount));
+            }
+
+            if (ret == 0 || (ret == -1 && errno == EAGAIN)) {
+                /* done for now */
+                break;
+            }
+            this->total_bytes_write += ret;
+        } else {
+            ret = __socket_cached_read(this, opvector, opcount);
+            if (ret == 0) {
+                gf_log(this->name, GF_LOG_DEBUG, "EOF on socket (errno:%d:%s)",
+                       errno, strerror(errno));
+                errno = ENODATA;
+                ret = -1;
+            }
+            if (ret == -1 && errno == EAGAIN) {
+                /* done for now */
+                break;
+            }
+            this->total_bytes_read += ret;
         }
 
-        while (opcount > 0) {
-                if (opvector->iov_len == 0) {
-                        gf_log(this->name, GF_LOG_DEBUG,
-                               "would have passed zero length to read/write");
-                        ++opvector;
-                        --opcount;
-                        continue;
-                }
-                if (priv->use_ssl && !priv->ssl_ssl) {
-                        /*
-                         * We could end up here with priv->ssl_ssl still NULL
-                         * if (a) the connection failed and (b) some fool
-                         * called other socket functions anyway.  Demoting to
-                         * non-SSL might be insecure, so just fail it outright.
-                         */
-                        ret = -1;
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "### no priv->ssl_ssl yet; ret = -1;");
-                } else if (write) {
-                        if (priv->use_ssl) {
-                                ret = ssl_write_one (this, opvector->iov_base,
-                                                     opvector->iov_len);
-                        } else {
-                                ret = sys_writev (sock, opvector, IOV_MIN(opcount));
-                        }
-
-                        if (ret == 0 || (ret == -1 && errno == EAGAIN)) {
-                                /* done for now */
-                                break;
-                        }
-                        this->total_bytes_write += ret;
-                } else {
-                        ret = __socket_cached_read (this, opvector, opcount);
-                        if (ret == 0) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "EOF on socket (errno:%d:%s)",
-                                        errno, strerror (errno));
-                                errno = ENODATA;
-                                ret = -1;
-                        }
-                        if (ret == -1 && errno == EAGAIN) {
-                                /* done for now */
-                                break;
-                        }
-                        this->total_bytes_read += ret;
-                }
-
-                if (ret == 0) {
-                        /* Mostly due to 'umount' in client */
-
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "EOF from peer %s", this->peerinfo.identifier);
-                        opcount = -1;
-                        errno = ENOTCONN;
-                        break;
-                }
-                if (ret == -1) {
-                        if (errno == EINTR)
-                                continue;
-
-                        if (__does_socket_rwv_error_need_logging (priv,
-                                                                  write)) {
-                                GF_LOG_OCCASIONALLY(priv->log_ctr, this->name,
-                                                    GF_LOG_WARNING,
-                                                    "%s on %s failed (%s)",
-                                                    write ? "writev":"readv",
-                                                    this->peerinfo.identifier,
-                                                    strerror (errno));
-                        }
-
-                        if (priv->use_ssl && priv->ssl_ssl) {
-                                ssl_dump_error_stack(this->name);
-                        }
-                        opcount = -1;
-                        break;
-                }
+        if (ret == 0) {
+            /* Mostly due to 'umount' in client */
 
-                if (bytes != NULL) {
-                        *bytes += ret;
-                }
+            gf_log(this->name, GF_LOG_DEBUG, "EOF from peer %s",
+                   this->peerinfo.identifier);
+            opcount = -1;
+            errno = ENOTCONN;
+            break;
+        }
+        if (ret == -1) {
+            if (errno == EINTR)
+                continue;
 
-                moved = 0;
+            if (__does_socket_rwv_error_need_logging(priv, write)) {
+                GF_LOG_OCCASIONALLY(priv->log_ctr, this->name, GF_LOG_WARNING,
+                                    "%s on %s failed (%s)",
+                                    write ? "writev" : "readv",
+                                    this->peerinfo.identifier, strerror(errno));
+            }
 
-                while (moved < ret) {
-                        if (!opcount) {
-                                gf_log(this->name, GF_LOG_DEBUG,
-                                       "ran out of iov, moved %d/%d",
-                                       moved, ret);
-                                goto ran_out;
-                        }
-                        if (!opvector[0].iov_len) {
-                                opvector++;
-                                opcount--;
-                                continue;
-                        }
-                        if ((ret - moved) >= opvector[0].iov_len) {
-                                moved += opvector[0].iov_len;
-                                opvector++;
-                                opcount--;
-                        } else {
-                                opvector[0].iov_len -= (ret - moved);
-                                opvector[0].iov_base += (ret - moved);
-                                moved += (ret - moved);
-                        }
-                }
+            if (priv->use_ssl && priv->ssl_ssl) {
+                ssl_dump_error_stack(this->name);
+            }
+            opcount = -1;
+            break;
         }
 
+        if (bytes != NULL) {
+            *bytes += ret;
+        }
+
+        moved = 0;
+
+        while (moved < ret) {
+            if (!opcount) {
+                gf_log(this->name, GF_LOG_DEBUG, "ran out of iov, moved %d/%d",
+                       moved, ret);
+                goto ran_out;
+            }
+            if (!opvector[0].iov_len) {
+                opvector++;
+                opcount--;
+                continue;
+            }
+            if ((ret - moved) >= opvector[0].iov_len) {
+                moved += opvector[0].iov_len;
+                opvector++;
+                opcount--;
+            } else {
+                opvector[0].iov_len -= (ret - moved);
+                opvector[0].iov_base += (ret - moved);
+                moved += (ret - moved);
+            }
+        }
+    }
+
 ran_out:
 
-        if (pending_vector)
-                *pending_vector = opvector;
+    if (pending_vector)
+        *pending_vector = opvector;
 
-        if (pending_count)
-                *pending_count = opcount;
+    if (pending_count)
+        *pending_count = opcount;
 
 out:
-        return opcount;
+    return opcount;
 }
 
-
 static int
-__socket_readv (rpc_transport_t *this, struct iovec *vector, int count,
-                struct iovec **pending_vector, int *pending_count,
-                size_t *bytes)
+__socket_readv(rpc_transport_t *this, struct iovec *vector, int count,
+               struct iovec **pending_vector, int *pending_count, size_t *bytes)
 {
-        int ret = -1;
+    int ret = -1;
 
-        ret = __socket_rwv (this, vector, count,
-                            pending_vector, pending_count, bytes, 0);
+    ret = __socket_rwv(this, vector, count, pending_vector, pending_count,
+                       bytes, 0);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_writev (rpc_transport_t *this, struct iovec *vector, int count,
-                 struct iovec **pending_vector, int *pending_count)
+__socket_writev(rpc_transport_t *this, struct iovec *vector, int count,
+                struct iovec **pending_vector, int *pending_count)
 {
-        int ret = -1;
+    int ret = -1;
 
-        ret = __socket_rwv (this, vector, count,
-                            pending_vector, pending_count, NULL, 1);
+    ret = __socket_rwv(this, vector, count, pending_vector, pending_count, NULL,
+                       1);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_shutdown (rpc_transport_t *this)
+__socket_shutdown(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = this->private;
-
-        priv->connected = -1;
-        ret = shutdown (priv->sock, SHUT_RDWR);
-        if (ret) {
-                /* its already disconnected.. no need to understand
-                   why it failed to shutdown in normal cases */
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "shutdown() returned %d. %s",
-                        ret, strerror (errno));
-        }
-
-        return ret;
+    int ret = -1;
+    socket_private_t *priv = this->private;
+
+    priv->connected = -1;
+    ret = shutdown(priv->sock, SHUT_RDWR);
+    if (ret) {
+        /* its already disconnected.. no need to understand
+           why it failed to shutdown in normal cases */
+        gf_log(this->name, GF_LOG_DEBUG, "shutdown() returned %d. %s", ret,
+               strerror(errno));
+    }
+
+    return ret;
 }
 
 static int
-__socket_teardown_connection (rpc_transport_t *this)
+__socket_teardown_connection(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = NULL;
+    int ret = -1;
+    socket_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->use_ssl)
-                ssl_teardown_connection(priv);
+    if (priv->use_ssl)
+        ssl_teardown_connection(priv);
 
-        ret = __socket_shutdown(this);
+    ret = __socket_shutdown(this);
 out:
-        return ret;
+    return ret;
 }
 
 static int
-__socket_disconnect (rpc_transport_t *this)
+__socket_disconnect(rpc_transport_t *this)
 {
-        int               ret = -1;
-        socket_private_t *priv = NULL;
+    int ret = -1;
+    socket_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        gf_log (this->name, GF_LOG_TRACE, "disconnecting %p, sock=%d",
-                this, priv->sock);
+    gf_log(this->name, GF_LOG_TRACE, "disconnecting %p, sock=%d", this,
+           priv->sock);
 
-        if (priv->sock != -1) {
-                gf_log_callingfn (this->name, GF_LOG_TRACE,
-                                  "tearing down socket connection");
-                ret = __socket_teardown_connection (this);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "__socket_teardown_connection () failed: %s",
-                                strerror (errno));
-                }
+    if (priv->sock != -1) {
+        gf_log_callingfn(this->name, GF_LOG_TRACE,
+                         "tearing down socket connection");
+        ret = __socket_teardown_connection(this);
+        if (ret) {
+            gf_log(this->name, GF_LOG_DEBUG,
+                   "__socket_teardown_connection () failed: %s",
+                   strerror(errno));
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_server_bind (rpc_transport_t *this)
+__socket_server_bind(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
-        int               opt = 1;
-        int               reuse_check_sock = -1;
-        struct sockaddr_storage   unix_addr = {0};
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    int opt = 1;
+    int reuse_check_sock = -1;
+    struct sockaddr_storage unix_addr = {0};
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        ret = setsockopt (priv->sock, SOL_SOCKET, SO_REUSEADDR,
-                          &opt, sizeof (opt));
+    ret = setsockopt(priv->sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "setsockopt() for SO_REUSEADDR failed (%s)",
-                        strerror (errno));
-        }
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "setsockopt() for SO_REUSEADDR failed (%s)", strerror(errno));
+    }
 
-        /* reuse-address doesn't work for unix type sockets */
-        if (AF_UNIX == SA (&this->myinfo.sockaddr)->sa_family) {
-                memcpy (&unix_addr, SA (&this->myinfo.sockaddr),
-                        this->myinfo.sockaddr_len);
-                reuse_check_sock = socket (AF_UNIX, SOCK_STREAM, 0);
-                if (reuse_check_sock >= 0) {
-                        ret = connect (reuse_check_sock, SA (&unix_addr),
-                                       this->myinfo.sockaddr_len);
-                        if ((ret == -1) && (ECONNREFUSED == errno)) {
-                                sys_unlink (((struct sockaddr_un *)&unix_addr)->sun_path);
-                        }
-                        sys_close (reuse_check_sock);
-                }
+    /* reuse-address doesn't work for unix type sockets */
+    if (AF_UNIX == SA(&this->myinfo.sockaddr)->sa_family) {
+        memcpy(&unix_addr, SA(&this->myinfo.sockaddr),
+               this->myinfo.sockaddr_len);
+        reuse_check_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+        if (reuse_check_sock >= 0) {
+            ret = connect(reuse_check_sock, SA(&unix_addr),
+                          this->myinfo.sockaddr_len);
+            if ((ret == -1) && (ECONNREFUSED == errno)) {
+                sys_unlink(((struct sockaddr_un *)&unix_addr)->sun_path);
+            }
+            sys_close(reuse_check_sock);
         }
+    }
 
-        ret = bind (priv->sock, (struct sockaddr *)&this->myinfo.sockaddr,
-                    this->myinfo.sockaddr_len);
+    ret = bind(priv->sock, (struct sockaddr *)&this->myinfo.sockaddr,
+               this->myinfo.sockaddr_len);
 
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "binding to %s failed: %s",
-                        this->myinfo.identifier, strerror (errno));
-                if (errno == EADDRINUSE) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Port is already in use");
-
-                        ret = -EADDRINUSE;
-                }
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_ERROR, "binding to %s failed: %s",
+               this->myinfo.identifier, strerror(errno));
+        if (errno == EADDRINUSE) {
+            gf_log(this->name, GF_LOG_ERROR, "Port is already in use");
+
+            ret = -EADDRINUSE;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_nonblock (int fd)
+__socket_nonblock(int fd)
 {
-        int flags = 0;
-        int ret = -1;
+    int flags = 0;
+    int ret = -1;
 
-        flags = fcntl (fd, F_GETFL);
+    flags = fcntl(fd, F_GETFL);
 
-        if (flags != -1)
-                ret = fcntl (fd, F_SETFL, flags | O_NONBLOCK);
+    if (flags != -1)
+        ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 
-        return ret;
+    return ret;
 }
 
 static int
-__socket_nodelay (int fd)
+__socket_nodelay(int fd)
 {
-        int     on = 1;
-        int     ret = -1;
+    int on = 1;
+    int ret = -1;
 
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY,
-                          &on, sizeof (on));
-        if (!ret)
-                gf_log (THIS->name, GF_LOG_TRACE,
-                        "NODELAY enabled for socket %d", fd);
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
+    if (!ret)
+        gf_log(THIS->name, GF_LOG_TRACE, "NODELAY enabled for socket %d", fd);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_keepalive (int fd, int family, int keepaliveintvl,
-                    int keepaliveidle, int keepalivecnt, int timeout)
+__socket_keepalive(int fd, int family, int keepaliveintvl, int keepaliveidle,
+                   int keepalivecnt, int timeout)
 {
-        int     on = 1;
-        int     ret = -1;
+    int on = 1;
+    int ret = -1;
 #if defined(TCP_USER_TIMEOUT)
-        int     timeout_ms = timeout * 1000;
+    int timeout_ms = timeout * 1000;
 #endif
 
-        ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep alive option on socket %d", fd);
-                goto err;
-        }
+    ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep alive option on socket %d", fd);
+        goto err;
+    }
 
-        if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE)
-                goto done;
+    if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE)
+        goto done;
 
 #if !defined(GF_LINUX_HOST_OS) && !defined(__NetBSD__)
 #if defined(GF_SOLARIS_HOST_OS) || defined(__FreeBSD__)
-        ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
+    ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
 #else
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
 #endif
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep alive interval on socket %d", fd);
-                goto err;
-        }
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep alive interval on socket %d", fd);
+        goto err;
+    }
 #else
-        if (family != AF_INET && family != AF_INET6)
-                goto done;
+    if (family != AF_INET && family != AF_INET6)
+        goto done;
 
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle,
-                          sizeof (keepaliveidle));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep idle %d on socket %d, %s",
-                        keepaliveidle, fd, strerror(errno));
-                goto err;
-        }
-        ret = setsockopt (fd, IPPROTO_TCP , TCP_KEEPINTVL, &keepaliveintvl,
-                          sizeof (keepaliveintvl));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING,
-                        "failed to set keep interval %d on socket %d, %s",
-                        keepaliveintvl, fd, strerror(errno));
-                goto err;
-        }
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle,
+                     sizeof(keepaliveidle));
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep idle %d on socket %d, %s", keepaliveidle, fd,
+               strerror(errno));
+        goto err;
+    }
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepaliveintvl,
+                     sizeof(keepaliveintvl));
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set keep interval %d on socket %d, %s",
+               keepaliveintvl, fd, strerror(errno));
+        goto err;
+    }
 
 #if defined(TCP_USER_TIMEOUT)
-        if (timeout_ms < 0)
-                goto done;
-        ret = setsockopt (fd, IPPROTO_TCP , TCP_USER_TIMEOUT, &timeout_ms,
-                          sizeof (timeout_ms));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING, "failed to set "
-                        "TCP_USER_TIMEOUT %d on socket %d, %s", timeout_ms, fd,
-                        strerror(errno));
-                goto err;
-        }
+    if (timeout_ms < 0)
+        goto done;
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout_ms,
+                     sizeof(timeout_ms));
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set "
+               "TCP_USER_TIMEOUT %d on socket %d, %s",
+               timeout_ms, fd, strerror(errno));
+        goto err;
+    }
 #endif
 #if defined(TCP_KEEPCNT)
-        ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt,
-                          sizeof (keepalivecnt));
-        if (ret == -1) {
-                gf_log ("socket", GF_LOG_WARNING, "failed to set "
-                        "TCP_KEEPCNT %d on socket %d, %s", keepalivecnt, fd,
-                        strerror(errno));
-                goto err;
-        }
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt,
+                     sizeof(keepalivecnt));
+    if (ret == -1) {
+        gf_log("socket", GF_LOG_WARNING,
+               "failed to set "
+               "TCP_KEEPCNT %d on socket %d, %s",
+               keepalivecnt, fd, strerror(errno));
+        goto err;
+    }
 #endif
 #endif
 
 done:
-        gf_log (THIS->name, GF_LOG_TRACE, "Keep-alive enabled for socket: %d, "
-                "(idle: %d, interval: %d, max-probes: %d, timeout: %d)",
-                fd, keepaliveidle, keepaliveintvl, keepalivecnt,
-                timeout);
+    gf_log(THIS->name, GF_LOG_TRACE,
+           "Keep-alive enabled for socket: %d, "
+           "(idle: %d, interval: %d, max-probes: %d, timeout: %d)",
+           fd, keepaliveidle, keepaliveintvl, keepalivecnt, timeout);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_connect_finish (int fd)
+__socket_connect_finish(int fd)
 {
-        int       ret = -1;
-        int       optval = 0;
-        socklen_t optlen = sizeof (int);
+    int ret = -1;
+    int optval = 0;
+    socklen_t optlen = sizeof(int);
 
-        ret = getsockopt (fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
+    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
 
-        if (ret == 0 && optval) {
-                errno = optval;
-                ret = -1;
-        }
+    if (ret == 0 && optval) {
+        errno = optval;
+        ret = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__socket_reset (rpc_transport_t *this)
+__socket_reset(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* TODO: use mem-pool on incoming data */
-
-        if (priv->incoming.iobref) {
-                iobref_unref (priv->incoming.iobref);
-                priv->incoming.iobref = NULL;
-        }
-
-        if (priv->incoming.iobuf) {
-                iobuf_unref (priv->incoming.iobuf);
-                priv->incoming.iobuf = NULL;
-        }
-
-        GF_FREE (priv->incoming.request_info);
-
-        memset (&priv->incoming, 0, sizeof (priv->incoming));
-
-        event_unregister_close (this->ctx->event_pool, priv->sock, priv->idx);
-
-        priv->sock = -1;
-        priv->idx = -1;
-        priv->connected = -1;
-        priv->ssl_connected = _gf_false;
-        priv->ssl_accepted = _gf_false;
-        priv->ssl_context_created = _gf_false;
-
-        if (priv->ssl_private_key) {
-                GF_FREE (priv->ssl_private_key);
-                priv->ssl_private_key = NULL;
-        }
-        if (priv->ssl_own_cert) {
-                GF_FREE (priv->ssl_own_cert);
-                priv->ssl_own_cert = NULL;
-        }
-        if (priv->ssl_ca_list) {
-                GF_FREE (priv->ssl_ca_list);
-                priv->ssl_ca_list = NULL;
-        }
+    socket_private_t *priv = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    /* TODO: use mem-pool on incoming data */
+
+    if (priv->incoming.iobref) {
+        iobref_unref(priv->incoming.iobref);
+        priv->incoming.iobref = NULL;
+    }
+
+    if (priv->incoming.iobuf) {
+        iobuf_unref(priv->incoming.iobuf);
+        priv->incoming.iobuf = NULL;
+    }
+
+    GF_FREE(priv->incoming.request_info);
+
+    memset(&priv->incoming, 0, sizeof(priv->incoming));
+
+    event_unregister_close(this->ctx->event_pool, priv->sock, priv->idx);
+
+    priv->sock = -1;
+    priv->idx = -1;
+    priv->connected = -1;
+    priv->ssl_connected = _gf_false;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_context_created = _gf_false;
+
+    if (priv->ssl_private_key) {
+        GF_FREE(priv->ssl_private_key);
+        priv->ssl_private_key = NULL;
+    }
+    if (priv->ssl_own_cert) {
+        GF_FREE(priv->ssl_own_cert);
+        priv->ssl_own_cert = NULL;
+    }
+    if (priv->ssl_ca_list) {
+        GF_FREE(priv->ssl_ca_list);
+        priv->ssl_ca_list = NULL;
+    }
 out:
-        return;
+    return;
 }
 
-
 static void
-socket_set_lastfrag (uint32_t *fragsize) {
-        (*fragsize) |= 0x80000000U;
+socket_set_lastfrag(uint32_t *fragsize)
+{
+    (*fragsize) |= 0x80000000U;
 }
 
-
 static void
-socket_set_frag_header_size (uint32_t size, char *haddr)
+socket_set_frag_header_size(uint32_t size, char *haddr)
 {
-        size = htonl (size);
-        memcpy (haddr, &size, sizeof (size));
+    size = htonl(size);
+    memcpy(haddr, &size, sizeof(size));
 }
 
-
 static void
-socket_set_last_frag_header_size (uint32_t size, char *haddr)
+socket_set_last_frag_header_size(uint32_t size, char *haddr)
 {
-        socket_set_lastfrag (&size);
-        socket_set_frag_header_size (size, haddr);
+    socket_set_lastfrag(&size);
+    socket_set_frag_header_size(size, haddr);
 }
 
 static struct ioq *
-__socket_ioq_new (rpc_transport_t *this, rpc_transport_msg_t *msg)
+__socket_ioq_new(rpc_transport_t *this, rpc_transport_msg_t *msg)
 {
-        struct ioq       *entry = NULL;
-        int               count = 0;
-        uint32_t          size  = 0;
+    struct ioq *entry = NULL;
+    int count = 0;
+    uint32_t size = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
 
-        /* TODO: use mem-pool */
-        entry = GF_CALLOC (1, sizeof (*entry), gf_common_mt_ioq);
-        if (!entry)
-                return NULL;
+    /* TODO: use mem-pool */
+    entry = GF_CALLOC(1, sizeof(*entry), gf_common_mt_ioq);
+    if (!entry)
+        return NULL;
 
-        count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
+    count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount;
 
-        GF_ASSERT (count <= (MAX_IOVEC - 1));
+    GF_ASSERT(count <= (MAX_IOVEC - 1));
 
-        size = iov_length (msg->rpchdr, msg->rpchdrcount)
-                + iov_length (msg->proghdr, msg->proghdrcount)
-                + iov_length (msg->progpayload, msg->progpayloadcount);
+    size = iov_length(msg->rpchdr, msg->rpchdrcount) +
+           iov_length(msg->proghdr, msg->proghdrcount) +
+           iov_length(msg->progpayload, msg->progpayloadcount);
 
-        if (size > RPC_MAX_FRAGMENT_SIZE) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "msg size (%u) bigger than the maximum allowed size on "
-                        "sockets (%u)", size, RPC_MAX_FRAGMENT_SIZE);
-                GF_FREE (entry);
-                return NULL;
-        }
+    if (size > RPC_MAX_FRAGMENT_SIZE) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "msg size (%u) bigger than the maximum allowed size on "
+               "sockets (%u)",
+               size, RPC_MAX_FRAGMENT_SIZE);
+        GF_FREE(entry);
+        return NULL;
+    }
 
-        socket_set_last_frag_header_size (size, (char *)&entry->fraghdr);
+    socket_set_last_frag_header_size(size, (char *)&entry->fraghdr);
 
-        entry->vector[0].iov_base = (char *)&entry->fraghdr;
-        entry->vector[0].iov_len = sizeof (entry->fraghdr);
-        entry->count = 1;
+    entry->vector[0].iov_base = (char *)&entry->fraghdr;
+    entry->vector[0].iov_len = sizeof(entry->fraghdr);
+    entry->count = 1;
 
-        if (msg->rpchdr != NULL) {
-                memcpy (&entry->vector[1], msg->rpchdr,
-                        sizeof (struct iovec) * msg->rpchdrcount);
-                entry->count += msg->rpchdrcount;
-        }
+    if (msg->rpchdr != NULL) {
+        memcpy(&entry->vector[1], msg->rpchdr,
+               sizeof(struct iovec) * msg->rpchdrcount);
+        entry->count += msg->rpchdrcount;
+    }
 
-        if (msg->proghdr != NULL) {
-                memcpy (&entry->vector[entry->count], msg->proghdr,
-                        sizeof (struct iovec) * msg->proghdrcount);
-                entry->count += msg->proghdrcount;
-        }
+    if (msg->proghdr != NULL) {
+        memcpy(&entry->vector[entry->count], msg->proghdr,
+               sizeof(struct iovec) * msg->proghdrcount);
+        entry->count += msg->proghdrcount;
+    }
 
-        if (msg->progpayload != NULL) {
-                memcpy (&entry->vector[entry->count], msg->progpayload,
-                        sizeof (struct iovec) * msg->progpayloadcount);
-                entry->count += msg->progpayloadcount;
-        }
+    if (msg->progpayload != NULL) {
+        memcpy(&entry->vector[entry->count], msg->progpayload,
+               sizeof(struct iovec) * msg->progpayloadcount);
+        entry->count += msg->progpayloadcount;
+    }
 
-        entry->pending_vector = entry->vector;
-        entry->pending_count  = entry->count;
+    entry->pending_vector = entry->vector;
+    entry->pending_count = entry->count;
 
-        if (msg->iobref != NULL)
-                entry->iobref = iobref_ref (msg->iobref);
+    if (msg->iobref != NULL)
+        entry->iobref = iobref_ref(msg->iobref);
 
-        INIT_LIST_HEAD (&entry->list);
+    INIT_LIST_HEAD(&entry->list);
 
 out:
-        return entry;
+    return entry;
 }
 
-
 static void
-__socket_ioq_entry_free (struct ioq *entry)
+__socket_ioq_entry_free(struct ioq *entry)
 {
-        GF_VALIDATE_OR_GOTO ("socket", entry, out);
+    GF_VALIDATE_OR_GOTO("socket", entry, out);
 
-        list_del_init (&entry->list);
-        if (entry->iobref)
-                iobref_unref (entry->iobref);
+    list_del_init(&entry->list);
+    if (entry->iobref)
+        iobref_unref(entry->iobref);
 
-        /* TODO: use mem-pool */
-        GF_FREE (entry);
+    /* TODO: use mem-pool */
+    GF_FREE(entry);
 
 out:
-        return;
+    return;
 }
 
-
 static void
-__socket_ioq_flush (rpc_transport_t *this)
+__socket_ioq_flush(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        struct ioq       *entry = NULL;
+    socket_private_t *priv = NULL;
+    struct ioq *entry = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        while (!list_empty (&priv->ioq)) {
-                entry = priv->ioq_next;
-                __socket_ioq_entry_free (entry);
-        }
+    while (!list_empty(&priv->ioq)) {
+        entry = priv->ioq_next;
+        __socket_ioq_entry_free(entry);
+    }
 
 out:
-        return;
+    return;
 }
 
-
 static int
-__socket_ioq_churn_entry (rpc_transport_t *this, struct ioq *entry, int direct)
+__socket_ioq_churn_entry(rpc_transport_t *this, struct ioq *entry, int direct)
 {
-        int               ret = -1;
+    int ret = -1;
 
-        ret = __socket_writev (this, entry->pending_vector,
-                               entry->pending_count,
-                               &entry->pending_vector,
-                               &entry->pending_count);
+    ret = __socket_writev(this, entry->pending_vector, entry->pending_count,
+                          &entry->pending_vector, &entry->pending_count);
 
-        if (ret == 0) {
-                /* current entry was completely written */
-                GF_ASSERT (entry->pending_count == 0);
-                __socket_ioq_entry_free (entry);
-        }
+    if (ret == 0) {
+        /* current entry was completely written */
+        GF_ASSERT(entry->pending_count == 0);
+        __socket_ioq_entry_free(entry);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_ioq_churn (rpc_transport_t *this)
+__socket_ioq_churn(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = 0;
-        struct ioq       *entry = NULL;
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct ioq *entry = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        while (!list_empty (&priv->ioq)) {
-                /* pick next entry */
-                entry = priv->ioq_next;
+    while (!list_empty(&priv->ioq)) {
+        /* pick next entry */
+        entry = priv->ioq_next;
 
-                ret = __socket_ioq_churn_entry (this, entry, 0);
+        ret = __socket_ioq_churn_entry(this, entry, 0);
 
-                if (ret != 0)
-                        break;
-        }
+        if (ret != 0)
+            break;
+    }
 
-        if (list_empty (&priv->ioq)) {
-                /* all pending writes done, not interested in POLLOUT */
-                priv->idx = event_select_on (this->ctx->event_pool,
-                                             priv->sock, priv->idx, -1, 0);
-        }
+    if (list_empty(&priv->ioq)) {
+        /* all pending writes done, not interested in POLLOUT */
+        priv->idx = event_select_on(this->ctx->event_pool, priv->sock,
+                                    priv->idx, -1, 0);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static gf_boolean_t
-socket_event_poll_err (rpc_transport_t *this, int gen, int idx)
+socket_event_poll_err(rpc_transport_t *this, int gen, int idx)
 {
-        socket_private_t *priv          = NULL;
-        gf_boolean_t      socket_closed = _gf_false;
+    socket_private_t *priv = NULL;
+    gf_boolean_t socket_closed = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if ((priv->gen == gen) && (priv->idx == idx)
-                    && (priv->sock != -1)) {
-                        __socket_ioq_flush (this);
-                        __socket_reset (this);
-                        socket_closed = _gf_true;
-                }
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if ((priv->gen == gen) && (priv->idx == idx) && (priv->sock != -1)) {
+            __socket_ioq_flush(this);
+            __socket_reset(this);
+            socket_closed = _gf_true;
         }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
-
-        if (socket_closed) {
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        while (priv->notify.in_progress)
-                                pthread_cond_wait (&priv->notify.cond,
-                                                   &priv->notify.lock);
-                }
-                pthread_mutex_unlock (&priv->notify.lock);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
-                rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this);
+    if (socket_closed) {
+        pthread_mutex_lock(&priv->notify.lock);
+        {
+            while (priv->notify.in_progress)
+                pthread_cond_wait(&priv->notify.cond, &priv->notify.lock);
         }
+        pthread_mutex_unlock(&priv->notify.lock);
+
+        rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, this);
+    }
 
 out:
-        return socket_closed;
+    return socket_closed;
 }
 
-
 static int
-socket_event_poll_out (rpc_transport_t *this)
+socket_event_poll_out(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        int               ret = -1;
+    socket_private_t *priv = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if (priv->connected == 1) {
-                        ret = __socket_ioq_churn (this);
-
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "__socket_ioq_churn returned -1; "
-                                        "disconnecting socket");
-                                __socket_disconnect (this);
-                        }
-                }
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected == 1) {
+            ret = __socket_ioq_churn(this);
+
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "__socket_ioq_churn returned -1; "
+                       "disconnecting socket");
+                __socket_disconnect(this);
+            }
         }
-        pthread_mutex_unlock (&priv->out_lock);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
 
-        if (ret == 0)
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_SENT, NULL);
+    if (ret == 0)
+        ret = rpc_transport_notify(this, RPC_TRANSPORT_MSG_SENT, NULL);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_simple_msg (rpc_transport_t *this)
+__socket_read_simple_msg(rpc_transport_t *this)
 {
-        int                           ret            = 0;
-        uint32_t                      remaining_size = 0;
-        size_t                        bytes_read     = 0;
-        socket_private_t             *priv           = NULL;
-        struct gf_sock_incoming      *in             = NULL;
-        struct gf_sock_incoming_frag *frag           = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    int ret = 0;
+    uint32_t remaining_size = 0;
+    size_t bytes_read = 0;
+    socket_private_t *priv = NULL;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
 
-        priv = this->private;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        in = &priv->incoming;
-        frag = &in->frag;
+    priv = this->private;
 
-        switch (frag->simple_state) {
+    in = &priv->incoming;
+    frag = &in->frag;
 
+    switch (frag->simple_state) {
         case SP_STATE_SIMPLE_MSG_INIT:
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                __socket_proto_init_pending (priv, remaining_size);
+            __socket_proto_init_pending(priv, remaining_size);
 
-                frag->simple_state = SP_STATE_READING_SIMPLE_MSG;
+            frag->simple_state = SP_STATE_READING_SIMPLE_MSG;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_SIMPLE_MSG:
-                ret = 0;
+            ret = 0;
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if (remaining_size > 0) {
-                        ret = __socket_readv (this,
-                                              in->pending_vector, 1,
-                                              &in->pending_vector,
-                                              &in->pending_count,
-                                              &bytes_read);
-                }
+            if (remaining_size > 0) {
+                ret = __socket_readv(this, in->pending_vector, 1,
+                                     &in->pending_vector, &in->pending_count,
+                                     &bytes_read);
+            }
 
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "reading from socket failed. Error (%s), "
-                                "peer (%s)", strerror (errno),
-                                this->peerinfo.identifier);
-                        break;
-                }
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "reading from socket failed. Error (%s), "
+                       "peer (%s)",
+                       strerror(errno), this->peerinfo.identifier);
+                break;
+            }
 
-                frag->bytes_read += bytes_read;
-                frag->fragcurrent += bytes_read;
+            frag->bytes_read += bytes_read;
+            frag->fragcurrent += bytes_read;
 
-                if (ret > 0) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "partial read on non-blocking socket.");
-                        break;
-                }
+            if (ret > 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "partial read on non-blocking socket.");
+                break;
+            }
 
-                if (ret == 0) {
-                        frag->simple_state =  SP_STATE_SIMPLE_MSG_INIT;
-                }
-        }
+            if (ret == 0) {
+                frag->simple_state = SP_STATE_SIMPLE_MSG_INIT;
+            }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_simple_request (rpc_transport_t *this)
+__socket_read_simple_request(rpc_transport_t *this)
 {
-        return __socket_read_simple_msg (this);
+    return __socket_read_simple_msg(this);
 }
 
-
 #define rpc_cred_addr(buf) (buf + RPC_MSGTYPE_SIZE + RPC_CALL_BODY_SIZE - 4)
 
 #define rpc_verf_addr(fragcurrent) (fragcurrent - 4)
@@ -1464,1875 +1420,1810 @@ __socket_read_simple_request (rpc_transport_t *this)
 #define rpc_procnum_addr(buf) (buf + RPC_MSGTYPE_SIZE + 12)
 
 static int
-__socket_read_vectored_request (rpc_transport_t *this, rpcsvc_vector_sizer vector_sizer)
+__socket_read_vectored_request(rpc_transport_t *this,
+                               rpcsvc_vector_sizer vector_sizer)
 {
-        socket_private_t *priv                   = NULL;
-        int               ret                    = 0;
-        uint32_t          credlen                = 0, verflen = 0;
-        char             *addr                   = NULL;
-        struct iobuf     *iobuf                  = NULL;
-        uint32_t          remaining_size         = 0;
-        ssize_t           readsize               = 0;
-        size_t            size                   = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-        sp_rpcfrag_request_state_t   *request    = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-        request = &frag->call_body.request;
-
-        switch (request->vector_state) {
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    uint32_t credlen = 0, verflen = 0;
+    char *addr = NULL;
+    struct iobuf *iobuf = NULL;
+    uint32_t remaining_size = 0;
+    ssize_t readsize = 0;
+    size_t size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    sp_rpcfrag_request_state_t *request = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+    request = &frag->call_body.request;
+
+    switch (request->vector_state) {
         case SP_STATE_VECTORED_REQUEST_INIT:
-                request->vector_sizer_state = 0;
+            request->vector_sizer_state = 0;
 
-                addr = rpc_cred_addr (iobuf_ptr (in->iobuf));
+            addr = rpc_cred_addr(iobuf_ptr(in->iobuf));
 
-                /* also read verf flavour and verflen */
-                credlen = ntoh32 (*((uint32_t *)addr))
-                        +  RPC_AUTH_FLAVOUR_N_LENGTH_SIZE;
+            /* also read verf flavour and verflen */
+            credlen = ntoh32(*((uint32_t *)addr)) +
+                      RPC_AUTH_FLAVOUR_N_LENGTH_SIZE;
 
-                __socket_proto_init_pending (priv, credlen);
+            __socket_proto_init_pending(priv, credlen);
 
-                request->vector_state = SP_STATE_READING_CREDBYTES;
+            request->vector_state = SP_STATE_READING_CREDBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_CREDBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_CREDBYTES;
+            request->vector_state = SP_STATE_READ_CREDBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_CREDBYTES:
-                addr = rpc_verf_addr (frag->fragcurrent);
-                verflen = ntoh32 (*((uint32_t *)addr));
+            addr = rpc_verf_addr(frag->fragcurrent);
+            verflen = ntoh32(*((uint32_t *)addr));
 
-                if (verflen == 0) {
-                        request->vector_state = SP_STATE_READ_VERFBYTES;
-                        goto sp_state_read_verfbytes;
-                }
-                __socket_proto_init_pending (priv, verflen);
+            if (verflen == 0) {
+                request->vector_state = SP_STATE_READ_VERFBYTES;
+                goto sp_state_read_verfbytes;
+            }
+            __socket_proto_init_pending(priv, verflen);
 
-                request->vector_state = SP_STATE_READING_VERFBYTES;
+            request->vector_state = SP_STATE_READING_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_VERFBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_VERFBYTES;
+            request->vector_state = SP_STATE_READ_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_VERFBYTES:
-sp_state_read_verfbytes:
-                /* set the base_addr 'persistently' across multiple calls
-                   into the state machine */
-                in->proghdr_base_addr = frag->fragcurrent;
+        sp_state_read_verfbytes:
+            /* set the base_addr 'persistently' across multiple calls
+               into the state machine */
+            in->proghdr_base_addr = frag->fragcurrent;
 
-                request->vector_sizer_state =
-                        vector_sizer (request->vector_sizer_state,
-                                      &readsize, in->proghdr_base_addr,
-                                      frag->fragcurrent);
-                __socket_proto_init_pending (priv, readsize);
+            request->vector_sizer_state = vector_sizer(
+                request->vector_sizer_state, &readsize, in->proghdr_base_addr,
+                frag->fragcurrent);
+            __socket_proto_init_pending(priv, readsize);
 
-                request->vector_state = SP_STATE_READING_PROGHDR;
+            request->vector_state = SP_STATE_READING_PROGHDR;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROGHDR:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_PROGHDR;
+            request->vector_state = SP_STATE_READ_PROGHDR;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_PROGHDR:
-sp_state_read_proghdr:
-                request->vector_sizer_state =
-                        vector_sizer (request->vector_sizer_state,
-                                      &readsize, in->proghdr_base_addr,
-                                      frag->fragcurrent);
-                if (readsize == 0) {
-                        request->vector_state = SP_STATE_READ_PROGHDR_XDATA;
-                        goto sp_state_read_proghdr_xdata;
-                }
+        sp_state_read_proghdr:
+            request->vector_sizer_state = vector_sizer(
+                request->vector_sizer_state, &readsize, in->proghdr_base_addr,
+                frag->fragcurrent);
+            if (readsize == 0) {
+                request->vector_state = SP_STATE_READ_PROGHDR_XDATA;
+                goto sp_state_read_proghdr_xdata;
+            }
 
-                __socket_proto_init_pending (priv, readsize);
+            __socket_proto_init_pending(priv, readsize);
 
-                request->vector_state = SP_STATE_READING_PROGHDR_XDATA;
+            request->vector_state = SP_STATE_READING_PROGHDR_XDATA;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROGHDR_XDATA:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->vector_state = SP_STATE_READ_PROGHDR;
-                /* check if the vector_sizer() has more to say */
-                goto sp_state_read_proghdr;
+            request->vector_state = SP_STATE_READ_PROGHDR;
+            /* check if the vector_sizer() has more to say */
+            goto sp_state_read_proghdr;
 
         case SP_STATE_READ_PROGHDR_XDATA:
-sp_state_read_proghdr_xdata:
-                if (in->payload_vector.iov_base == NULL) {
-
-                        size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-                        if (!iobuf) {
-                                ret = -1;
-                                break;
-                        }
-
-                        if (in->iobref == NULL) {
-                                in->iobref = iobref_new ();
-                                if (in->iobref == NULL) {
-                                        ret = -1;
-                                        iobuf_unref (iobuf);
-                                        break;
-                                }
-                        }
+        sp_state_read_proghdr_xdata:
+            if (in->payload_vector.iov_base == NULL) {
+                size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (!iobuf) {
+                    ret = -1;
+                    break;
+                }
+
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        break;
+                    }
+                }
 
-                        iobref_add (in->iobref, iobuf);
+                iobref_add(in->iobref, iobuf);
 
-                        in->payload_vector.iov_base = iobuf_ptr (iobuf);
-                        frag->fragcurrent = iobuf_ptr (iobuf);
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                frag->fragcurrent = iobuf_ptr(iobuf);
 
-                        iobuf_unref (iobuf);
-                }
+                iobuf_unref(iobuf);
+            }
 
-                request->vector_state = SP_STATE_READING_PROG;
+            request->vector_state = SP_STATE_READING_PROG;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROG:
-                /* now read the remaining rpc msg into buffer pointed by
-                 * fragcurrent
-                 */
+            /* now read the remaining rpc msg into buffer pointed by
+             * fragcurrent
+             */
 
-                ret = __socket_read_simple_msg (this);
+            ret = __socket_read_simple_msg(this);
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1) ||
-                    ((ret == 0) && (remaining_size == 0)
-                     && RPC_LASTFRAG (in->fraghdr))) {
-                        request->vector_state = SP_STATE_VECTORED_REQUEST_INIT;
-                        in->payload_vector.iov_len
-                                = ((unsigned long)frag->fragcurrent
-                                   - (unsigned long)in->payload_vector.iov_base);
-                }
-                break;
-        }
+            if ((ret == -1) || ((ret == 0) && (remaining_size == 0) &&
+                                RPC_LASTFRAG(in->fraghdr))) {
+                request->vector_state = SP_STATE_VECTORED_REQUEST_INIT;
+                in->payload_vector.iov_len = ((unsigned long)frag->fragcurrent -
+                                              (unsigned long)
+                                                  in->payload_vector.iov_base);
+            }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-__socket_read_request (rpc_transport_t *this)
+__socket_read_request(rpc_transport_t *this)
 {
-        socket_private_t *priv               = NULL;
-        uint32_t          prognum            = 0, procnum = 0, progver = 0;
-        uint32_t          remaining_size     = 0;
-        int               ret                = -1;
-        char             *buf                = NULL;
-        rpcsvc_vector_sizer     vector_sizer = NULL;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-        sp_rpcfrag_request_state_t   *request    = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-        request = &frag->call_body.request;
-
-        switch (request->header_state) {
-
+    socket_private_t *priv = NULL;
+    uint32_t prognum = 0, procnum = 0, progver = 0;
+    uint32_t remaining_size = 0;
+    int ret = -1;
+    char *buf = NULL;
+    rpcsvc_vector_sizer vector_sizer = NULL;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+    sp_rpcfrag_request_state_t *request = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+    request = &frag->call_body.request;
+
+    switch (request->header_state) {
         case SP_STATE_REQUEST_HEADER_INIT:
 
-                __socket_proto_init_pending (priv, RPC_CALL_BODY_SIZE);
+            __socket_proto_init_pending(priv, RPC_CALL_BODY_SIZE);
 
-                request->header_state = SP_STATE_READING_RPCHDR1;
+            request->header_state = SP_STATE_READING_RPCHDR1;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_RPCHDR1:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                request->header_state = SP_STATE_READ_RPCHDR1;
+            request->header_state = SP_STATE_READ_RPCHDR1;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_RPCHDR1:
-                buf = rpc_prognum_addr (iobuf_ptr (in->iobuf));
-                prognum = ntoh32 (*((uint32_t *)buf));
+            buf = rpc_prognum_addr(iobuf_ptr(in->iobuf));
+            prognum = ntoh32(*((uint32_t *)buf));
 
-                buf = rpc_progver_addr (iobuf_ptr (in->iobuf));
-                progver = ntoh32 (*((uint32_t *)buf));
+            buf = rpc_progver_addr(iobuf_ptr(in->iobuf));
+            progver = ntoh32(*((uint32_t *)buf));
 
-                buf = rpc_procnum_addr (iobuf_ptr (in->iobuf));
-                procnum = ntoh32 (*((uint32_t *)buf));
+            buf = rpc_procnum_addr(iobuf_ptr(in->iobuf));
+            procnum = ntoh32(*((uint32_t *)buf));
 
-                if (priv->is_server) {
-                        /* this check is needed as rpcsvc and rpc-clnt
-                         * actor structures are not same */
-                        vector_sizer =
-                                rpcsvc_get_program_vector_sizer ((rpcsvc_t *)this->mydata,
-                                                                 prognum, progver, procnum);
-                }
+            if (priv->is_server) {
+                /* this check is needed as rpcsvc and rpc-clnt
+                 * actor structures are not same */
+                vector_sizer = rpcsvc_get_program_vector_sizer(
+                    (rpcsvc_t *)this->mydata, prognum, progver, procnum);
+            }
 
-                if (vector_sizer) {
-                        ret = __socket_read_vectored_request (this, vector_sizer);
-                } else {
-                        ret = __socket_read_simple_request (this);
-                }
+            if (vector_sizer) {
+                ret = __socket_read_vectored_request(this, vector_sizer);
+            } else {
+                ret = __socket_read_simple_request(this);
+            }
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1)
-                    || ((ret == 0)
-                        && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        request->header_state = SP_STATE_REQUEST_HEADER_INIT;
-                }
+            if ((ret == -1) || ((ret == 0) && (remaining_size == 0) &&
+                                (RPC_LASTFRAG(in->fraghdr)))) {
+                request->header_state = SP_STATE_REQUEST_HEADER_INIT;
+            }
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_accepted_successful_reply (rpc_transport_t *this)
+__socket_read_accepted_successful_reply(rpc_transport_t *this)
 {
-        socket_private_t *priv              = NULL;
-        int               ret               = 0;
-        struct iobuf     *iobuf             = NULL;
-        gfs3_read_rsp     read_rsp          = {0, };
-        ssize_t           size              = 0;
-        ssize_t           default_read_size = 0;
-        XDR               xdr;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.accepted_success_state) {
-
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
+    gfs3_read_rsp read_rsp = {
+        0,
+    };
+    ssize_t size = 0;
+    ssize_t default_read_size = 0;
+    XDR xdr;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_success_state) {
         case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT:
-                default_read_size = xdr_sizeof ((xdrproc_t) xdr_gfs3_read_rsp,
-                                                &read_rsp);
+            default_read_size = xdr_sizeof((xdrproc_t)xdr_gfs3_read_rsp,
+                                           &read_rsp);
 
-                /* We need to store the current base address because we will
-                 * need it after a partial read. */
-                in->proghdr_base_addr = frag->fragcurrent;
+            /* We need to store the current base address because we will
+             * need it after a partial read. */
+            in->proghdr_base_addr = frag->fragcurrent;
 
-                __socket_proto_init_pending (priv, default_read_size);
+            __socket_proto_init_pending(priv, default_read_size);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_HEADER;
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_HEADER;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROC_HEADER:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                /* there can be 'xdata' in read response, figure it out */
-                default_read_size = frag->fragcurrent - in->proghdr_base_addr;
-                xdrmem_create (&xdr, in->proghdr_base_addr, default_read_size,
-                               XDR_DECODE);
+            /* there can be 'xdata' in read response, figure it out */
+            default_read_size = frag->fragcurrent - in->proghdr_base_addr;
+            xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size,
+                          XDR_DECODE);
 
-                /* This will fail if there is xdata sent from server, if not,
-                   well and good, we don't need to worry about  */
-                xdr_gfs3_read_rsp (&xdr, &read_rsp);
+            /* This will fail if there is xdata sent from server, if not,
+               well and good, we don't need to worry about  */
+            xdr_gfs3_read_rsp(&xdr, &read_rsp);
 
-                free (read_rsp.xdata.xdata_val);
+            free(read_rsp.xdata.xdata_val);
 
-                /* need to round off to proper roof (%4), as XDR packing pads
-                   the end of opaque object with '0' */
-                size = roof (read_rsp.xdata.xdata_len, 4);
+            /* need to round off to proper roof (%4), as XDR packing pads
+               the end of opaque object with '0' */
+            size = roof(read_rsp.xdata.xdata_len, 4);
 
-                if (!size) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_READ_PROC_OPAQUE;
-                        goto read_proc_opaque;
-                }
+            if (!size) {
+                frag->call_body.reply
+                    .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+                goto read_proc_opaque;
+            }
 
-                __socket_proto_init_pending (priv, size);
+            __socket_proto_init_pending(priv, size);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_OPAQUE;
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READING_PROC_OPAQUE:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_OPAQUE;
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READ_PROC_OPAQUE:
         read_proc_opaque:
-                if (in->payload_vector.iov_base == NULL) {
-
-                        size = (RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read);
-
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-                        if (iobuf == NULL) {
-                                ret = -1;
-                                goto out;
-                        }
+            if (in->payload_vector.iov_base == NULL) {
+                size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read);
 
-                        if (in->iobref == NULL) {
-                                in->iobref = iobref_new ();
-                                if (in->iobref == NULL) {
-                                        ret = -1;
-                                        iobuf_unref (iobuf);
-                                        goto out;
-                                }
-                        }
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (iobuf == NULL) {
+                    ret = -1;
+                    goto out;
+                }
 
-                        ret = iobref_add (in->iobref, iobuf);
-                        iobuf_unref (iobuf);
-                        if (ret < 0) {
-                                goto out;
-                        }
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        goto out;
+                    }
+                }
 
-                        in->payload_vector.iov_base = iobuf_ptr (iobuf);
-                        in->payload_vector.iov_len = size;
+                ret = iobref_add(in->iobref, iobuf);
+                iobuf_unref(iobuf);
+                if (ret < 0) {
+                    goto out;
                 }
 
-                frag->fragcurrent = in->payload_vector.iov_base;
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                in->payload_vector.iov_len = size;
+            }
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_HEADER;
+            frag->fragcurrent = in->payload_vector.iov_base;
 
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_HEADER;
+
+            /* fall through */
 
         case SP_STATE_READ_PROC_HEADER:
-                /* now read the entire remaining msg into new iobuf */
-                ret = __socket_read_simple_msg (this);
-                if ((ret == -1)
-                    || ((ret == 0) && RPC_LASTFRAG (in->fraghdr))) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
-                }
+            /* now read the entire remaining msg into new iobuf */
+            ret = __socket_read_simple_msg(this);
+            if ((ret == -1) || ((ret == 0) && RPC_LASTFRAG(in->fraghdr))) {
+                frag->call_body.reply.accepted_success_state =
+                    SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
+            }
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-__socket_read_accepted_successful_reply_v2 (rpc_transport_t *this)
+__socket_read_accepted_successful_reply_v2(rpc_transport_t *this)
 {
-        socket_private_t *priv              = NULL;
-        int               ret               = 0;
-        struct iobuf     *iobuf             = NULL;
-        gfx_read_rsp      read_rsp          = {0, };
-        ssize_t           size              = 0;
-        ssize_t           default_read_size = 0;
-        XDR               xdr;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.accepted_success_state) {
-
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    struct iobuf *iobuf = NULL;
+    gfx_read_rsp read_rsp = {
+        0,
+    };
+    ssize_t size = 0;
+    ssize_t default_read_size = 0;
+    XDR xdr;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_success_state) {
         case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT:
-                default_read_size = xdr_sizeof ((xdrproc_t) xdr_gfx_read_rsp,
-                                                &read_rsp);
+            default_read_size = xdr_sizeof((xdrproc_t)xdr_gfx_read_rsp,
+                                           &read_rsp);
 
-                /* We need to store the current base address because we will
-                 * need it after a partial read. */
-                in->proghdr_base_addr = frag->fragcurrent;
+            /* We need to store the current base address because we will
+             * need it after a partial read. */
+            in->proghdr_base_addr = frag->fragcurrent;
 
-                __socket_proto_init_pending (priv, default_read_size);
+            __socket_proto_init_pending(priv, default_read_size);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_HEADER;
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_HEADER;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_PROC_HEADER:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                /* there can be 'xdata' in read response, figure it out */
-                default_read_size = frag->fragcurrent - in->proghdr_base_addr;
+            /* there can be 'xdata' in read response, figure it out */
+            default_read_size = frag->fragcurrent - in->proghdr_base_addr;
 
-                xdrmem_create (&xdr, in->proghdr_base_addr, default_read_size,
-                               XDR_DECODE);
+            xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size,
+                          XDR_DECODE);
 
-                /* This will fail if there is xdata sent from server, if not,
-                   well and good, we don't need to worry about  */
-                xdr_gfx_read_rsp (&xdr, &read_rsp);
+            /* This will fail if there is xdata sent from server, if not,
+               well and good, we don't need to worry about  */
+            xdr_gfx_read_rsp(&xdr, &read_rsp);
 
-                free (read_rsp.xdata.pairs.pairs_val);
+            free(read_rsp.xdata.pairs.pairs_val);
 
-                /* need to round off to proper roof (%4), as XDR packing pads
-                   the end of opaque object with '0' */
-                size = roof (read_rsp.xdata.xdr_size, 4);
+            /* need to round off to proper roof (%4), as XDR packing pads
+               the end of opaque object with '0' */
+            size = roof(read_rsp.xdata.xdr_size, 4);
 
-                if (!size) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_READ_PROC_OPAQUE;
-                        goto read_proc_opaque;
-                }
+            if (!size) {
+                frag->call_body.reply
+                    .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+                goto read_proc_opaque;
+            }
 
-                __socket_proto_init_pending (priv, size);
+            __socket_proto_init_pending(priv, size);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READING_PROC_OPAQUE;
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READING_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READING_PROC_OPAQUE:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_OPAQUE;
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_OPAQUE;
+            /* fall through */
 
         case SP_STATE_READ_PROC_OPAQUE:
         read_proc_opaque:
-                if (in->payload_vector.iov_base == NULL) {
-
-                        size = (RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read);
+            if (in->payload_vector.iov_base == NULL) {
+                size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read);
 
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool, size);
-                        if (iobuf == NULL) {
-                                ret = -1;
-                                goto out;
-                        }
-
-                        if (in->iobref == NULL) {
-                                in->iobref = iobref_new ();
-                                if (in->iobref == NULL) {
-                                        ret = -1;
-                                        iobuf_unref (iobuf);
-                                        goto out;
-                                }
-                        }
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
+                if (iobuf == NULL) {
+                    ret = -1;
+                    goto out;
+                }
 
-                        ret = iobref_add (in->iobref, iobuf);
-                        iobuf_unref (iobuf);
-                        if (ret < 0) {
-                                goto out;
-                        }
+                if (in->iobref == NULL) {
+                    in->iobref = iobref_new();
+                    if (in->iobref == NULL) {
+                        ret = -1;
+                        iobuf_unref(iobuf);
+                        goto out;
+                    }
+                }
 
-                        in->payload_vector.iov_base = iobuf_ptr (iobuf);
-                        in->payload_vector.iov_len = size;
+                ret = iobref_add(in->iobref, iobuf);
+                iobuf_unref(iobuf);
+                if (ret < 0) {
+                    goto out;
                 }
 
-                frag->fragcurrent = in->payload_vector.iov_base;
+                in->payload_vector.iov_base = iobuf_ptr(iobuf);
+                in->payload_vector.iov_len = size;
+            }
 
-                frag->call_body.reply.accepted_success_state
-                        = SP_STATE_READ_PROC_HEADER;
+            frag->fragcurrent = in->payload_vector.iov_base;
 
-                /* fall through */
+            frag->call_body.reply
+                .accepted_success_state = SP_STATE_READ_PROC_HEADER;
+
+            /* fall through */
 
         case SP_STATE_READ_PROC_HEADER:
-                /* now read the entire remaining msg into new iobuf */
-                ret = __socket_read_simple_msg (this);
-                if ((ret == -1)
-                    || ((ret == 0) && RPC_LASTFRAG (in->fraghdr))) {
-                        frag->call_body.reply.accepted_success_state
-                                = SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
-                }
+            /* now read the entire remaining msg into new iobuf */
+            ret = __socket_read_simple_msg(this);
+            if ((ret == -1) || ((ret == 0) && RPC_LASTFRAG(in->fraghdr))) {
+                frag->call_body.reply.accepted_success_state =
+                    SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT;
+            }
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 #define rpc_reply_verflen_addr(fragcurrent) ((char *)fragcurrent - 4)
 #define rpc_reply_accept_status_addr(fragcurrent) ((char *)fragcurrent - 4)
 
 static int
-__socket_read_accepted_reply (rpc_transport_t *this)
+__socket_read_accepted_reply(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int               ret            = -1;
-        char             *buf            = NULL;
-        uint32_t          verflen        = 0, len = 0;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.accepted_state) {
-
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    char *buf = NULL;
+    uint32_t verflen = 0, len = 0;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->call_body.reply.accepted_state) {
         case SP_STATE_ACCEPTED_REPLY_INIT:
-                __socket_proto_init_pending (priv,
-                                             RPC_AUTH_FLAVOUR_N_LENGTH_SIZE);
+            __socket_proto_init_pending(priv, RPC_AUTH_FLAVOUR_N_LENGTH_SIZE);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READING_REPLY_VERFLEN;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READING_REPLY_VERFLEN;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_VERFLEN:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READ_REPLY_VERFLEN;
+            frag->call_body.reply.accepted_state = SP_STATE_READ_REPLY_VERFLEN;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_VERFLEN:
-                buf = rpc_reply_verflen_addr (frag->fragcurrent);
+            buf = rpc_reply_verflen_addr(frag->fragcurrent);
 
-                verflen = ntoh32 (*((uint32_t *) buf));
+            verflen = ntoh32(*((uint32_t *)buf));
 
-                /* also read accept status along with verf data */
-                len = verflen + RPC_ACCEPT_STATUS_LEN;
+            /* also read accept status along with verf data */
+            len = verflen + RPC_ACCEPT_STATUS_LEN;
 
-                __socket_proto_init_pending (priv, len);
+            __socket_proto_init_pending(priv, len);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READING_REPLY_VERFBYTES;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READING_REPLY_VERFBYTES;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_VERFBYTES:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->call_body.reply.accepted_state
-                        = SP_STATE_READ_REPLY_VERFBYTES;
+            frag->call_body.reply
+                .accepted_state = SP_STATE_READ_REPLY_VERFBYTES;
 
-                buf = rpc_reply_accept_status_addr (frag->fragcurrent);
+            buf = rpc_reply_accept_status_addr(frag->fragcurrent);
 
-                frag->call_body.reply.accept_status
-                        = ntoh32 (*(uint32_t *) buf);
+            frag->call_body.reply.accept_status = ntoh32(*(uint32_t *)buf);
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_VERFBYTES:
 
-                if (frag->call_body.reply.accept_status
-                    == SUCCESS) {
-                        /* Need two different methods here for different protocols
-                           Mainly because the exact XDR is used to calculate the
-                           size of response */
-                        if ((in->request_info->procnum == GFS3_OP_READ) &&
-                            (in->request_info->prognum == GLUSTER_FOP_PROGRAM) &&
-                            (in->request_info->progver == GLUSTER_FOP_VERSION_v2)) {
-                                ret = __socket_read_accepted_successful_reply_v2 (this);
-                        } else {
-                                ret = __socket_read_accepted_successful_reply (this);
-                        }
+            if (frag->call_body.reply.accept_status == SUCCESS) {
+                /* Need two different methods here for different protocols
+                   Mainly because the exact XDR is used to calculate the
+                   size of response */
+                if ((in->request_info->procnum == GFS3_OP_READ) &&
+                    (in->request_info->prognum == GLUSTER_FOP_PROGRAM) &&
+                    (in->request_info->progver == GLUSTER_FOP_VERSION_v2)) {
+                    ret = __socket_read_accepted_successful_reply_v2(this);
                 } else {
-                        /* read entire remaining msg into buffer pointed to by
-                         * fragcurrent
-                         */
-                        ret = __socket_read_simple_msg (this);
+                    ret = __socket_read_accepted_successful_reply(this);
                 }
+            } else {
+                /* read entire remaining msg into buffer pointed to by
+                 * fragcurrent
+                 */
+                ret = __socket_read_simple_msg(this);
+            }
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr)
-                        - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        frag->call_body.reply.accepted_state
-                                = SP_STATE_ACCEPTED_REPLY_INIT;
-                }
+            if ((ret == -1) || ((ret == 0) && (remaining_size == 0) &&
+                                (RPC_LASTFRAG(in->fraghdr)))) {
+                frag->call_body.reply
+                    .accepted_state = SP_STATE_ACCEPTED_REPLY_INIT;
+            }
 
-                break;
-        }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_denied_reply (rpc_transport_t *this)
+__socket_read_denied_reply(rpc_transport_t *this)
 {
-        return __socket_read_simple_msg (this);
+    return __socket_read_simple_msg(this);
 }
 
-
 #define rpc_reply_status_addr(fragcurrent) ((char *)fragcurrent - 4)
 
-
 static int
-__socket_read_vectored_reply (rpc_transport_t *this)
+__socket_read_vectored_reply(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int               ret            = 0;
-        char             *buf            = NULL;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    char *buf = NULL;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->call_body.reply.status_state) {
+    priv = this->private;
+    in = &priv->incoming;
+    frag = &in->frag;
 
+    switch (frag->call_body.reply.status_state) {
         case SP_STATE_ACCEPTED_REPLY_INIT:
-                __socket_proto_init_pending (priv, RPC_REPLY_STATUS_SIZE);
+            __socket_proto_init_pending(priv, RPC_REPLY_STATUS_SIZE);
 
-                frag->call_body.reply.status_state
-                        = SP_STATE_READING_REPLY_STATUS;
+            frag->call_body.reply.status_state = SP_STATE_READING_REPLY_STATUS;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_REPLY_STATUS:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                buf = rpc_reply_status_addr (frag->fragcurrent);
+            buf = rpc_reply_status_addr(frag->fragcurrent);
 
-                frag->call_body.reply.accept_status
-                        = ntoh32 (*((uint32_t *) buf));
+            frag->call_body.reply.accept_status = ntoh32(*((uint32_t *)buf));
 
-                frag->call_body.reply.status_state
-                        = SP_STATE_READ_REPLY_STATUS;
+            frag->call_body.reply.status_state = SP_STATE_READ_REPLY_STATUS;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READ_REPLY_STATUS:
-                if (frag->call_body.reply.accept_status == MSG_ACCEPTED) {
-                        ret = __socket_read_accepted_reply (this);
-                } else {
-                        ret = __socket_read_denied_reply (this);
-                }
-
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
-
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                        frag->call_body.reply.status_state
-                                = SP_STATE_VECTORED_REPLY_STATUS_INIT;
-                        in->payload_vector.iov_len
-                                = (unsigned long)frag->fragcurrent
-                                - (unsigned long)in->payload_vector.iov_base;
-                }
-                break;
-        }
+            if (frag->call_body.reply.accept_status == MSG_ACCEPTED) {
+                ret = __socket_read_accepted_reply(this);
+            } else {
+                ret = __socket_read_denied_reply(this);
+            }
+
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
+
+            if ((ret == -1) || ((ret == 0) && (remaining_size == 0) &&
+                                (RPC_LASTFRAG(in->fraghdr)))) {
+                frag->call_body.reply
+                    .status_state = SP_STATE_VECTORED_REPLY_STATUS_INIT;
+                in->payload_vector.iov_len = (unsigned long)frag->fragcurrent -
+                                             (unsigned long)
+                                                 in->payload_vector.iov_base;
+            }
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__socket_read_simple_reply (rpc_transport_t *this)
+__socket_read_simple_reply(rpc_transport_t *this)
 {
-        return __socket_read_simple_msg (this);
+    return __socket_read_simple_msg(this);
 }
 
 #define rpc_xid_addr(buf) (buf)
 
 static int
-__socket_read_reply (rpc_transport_t *this)
+__socket_read_reply(rpc_transport_t *this)
 {
-        socket_private_t   *priv         = NULL;
-        char               *buf          = NULL;
-        int32_t             ret          = -1;
-        rpc_request_info_t *request_info = NULL;
-        char                map_xid      = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        buf = rpc_xid_addr (iobuf_ptr (in->iobuf));
-
+    socket_private_t *priv = NULL;
+    char *buf = NULL;
+    int32_t ret = -1;
+    rpc_request_info_t *request_info = NULL;
+    char map_xid = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    buf = rpc_xid_addr(iobuf_ptr(in->iobuf));
+
+    if (in->request_info == NULL) {
+        in->request_info = GF_CALLOC(1, sizeof(*request_info),
+                                     gf_common_mt_rpc_trans_reqinfo_t);
         if (in->request_info == NULL) {
-                in->request_info = GF_CALLOC (1, sizeof (*request_info),
-                                              gf_common_mt_rpc_trans_reqinfo_t);
-                if (in->request_info == NULL) {
-                        goto out;
-                }
-
-                map_xid = 1;
+            goto out;
         }
 
-        request_info = in->request_info;
-
-        if (map_xid) {
-                request_info->xid = ntoh32 (*((uint32_t *) buf));
+        map_xid = 1;
+    }
 
-                /* release priv->lock, so as to avoid deadlock b/w conn->lock
-                 * and priv->lock, since we are doing an upcall here.
-                 */
-                frag->state = SP_STATE_NOTIFYING_XID;
-                pthread_mutex_unlock (&priv->in_lock);
-                {
-                        ret = rpc_transport_notify (this,
-                                                    RPC_TRANSPORT_MAP_XID_REQUEST,
-                                                    in->request_info);
-                }
-                pthread_mutex_lock (&priv->in_lock);
+    request_info = in->request_info;
 
-                /* Transition back to externally visible state. */
-                frag->state = SP_STATE_READ_MSGTYPE;
+    if (map_xid) {
+        request_info->xid = ntoh32(*((uint32_t *)buf));
 
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "notify for event MAP_XID failed for %s",
-                                this->peerinfo.identifier);
-                        goto out;
-                }
+        /* release priv->lock, so as to avoid deadlock b/w conn->lock
+         * and priv->lock, since we are doing an upcall here.
+         */
+        frag->state = SP_STATE_NOTIFYING_XID;
+        pthread_mutex_unlock(&priv->in_lock);
+        {
+            ret = rpc_transport_notify(this, RPC_TRANSPORT_MAP_XID_REQUEST,
+                                       in->request_info);
         }
+        pthread_mutex_lock(&priv->in_lock);
 
-        if ((request_info->prognum == GLUSTER_FOP_PROGRAM)
-            && (request_info->procnum == GF_FOP_READ)) {
-                if (map_xid && request_info->rsp.rsp_payload_count != 0) {
-                        in->iobref = iobref_ref (request_info->rsp.rsp_iobref);
-                        in->payload_vector = *request_info->rsp.rsp_payload;
-                }
+        /* Transition back to externally visible state. */
+        frag->state = SP_STATE_READ_MSGTYPE;
 
-                ret = __socket_read_vectored_reply (this);
-        } else {
-                ret = __socket_read_simple_reply (this);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "notify for event MAP_XID failed for %s",
+                   this->peerinfo.identifier);
+            goto out;
         }
+    }
+
+    if ((request_info->prognum == GLUSTER_FOP_PROGRAM) &&
+        (request_info->procnum == GF_FOP_READ)) {
+        if (map_xid && request_info->rsp.rsp_payload_count != 0) {
+            in->iobref = iobref_ref(request_info->rsp.rsp_iobref);
+            in->payload_vector = *request_info->rsp.rsp_payload;
+        }
+
+        ret = __socket_read_vectored_reply(this);
+    } else {
+        ret = __socket_read_simple_reply(this);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 /* returns the number of bytes yet to be read in a fragment */
 static int
-__socket_read_frag (rpc_transport_t *this)
+__socket_read_frag(rpc_transport_t *this)
 {
-        socket_private_t *priv           = NULL;
-        int32_t           ret            = 0;
-        char             *buf            = NULL;
-        uint32_t          remaining_size = 0;
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        switch (frag->state) {
+    socket_private_t *priv = NULL;
+    int32_t ret = 0;
+    char *buf = NULL;
+    uint32_t remaining_size = 0;
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
+
+    switch (frag->state) {
         case SP_STATE_NADA:
-                __socket_proto_init_pending (priv, RPC_MSGTYPE_SIZE);
+            __socket_proto_init_pending(priv, RPC_MSGTYPE_SIZE);
 
-                frag->state = SP_STATE_READING_MSGTYPE;
+            frag->state = SP_STATE_READING_MSGTYPE;
 
-                /* fall through */
+            /* fall through */
 
         case SP_STATE_READING_MSGTYPE:
-                __socket_proto_read (priv, ret);
+            __socket_proto_read(priv, ret);
 
-                frag->state = SP_STATE_READ_MSGTYPE;
-                /* fall through */
+            frag->state = SP_STATE_READ_MSGTYPE;
+            /* fall through */
 
         case SP_STATE_READ_MSGTYPE:
-                buf = rpc_msgtype_addr (iobuf_ptr (in->iobuf));
-                in->msg_type = ntoh32 (*((uint32_t *)buf));
-
-                if (in->msg_type == CALL) {
-                        ret = __socket_read_request (this);
-                } else if (in->msg_type == REPLY) {
-                        ret = __socket_read_reply (this);
-                } else if (in->msg_type == (msg_type_t) GF_UNIVERSAL_ANSWER) {
-                        gf_log ("rpc", GF_LOG_ERROR,
-                                "older version of protocol/process trying to "
-                                "connect from %s. use newer version on that node",
-                                this->peerinfo.identifier);
-                } else {
-                        gf_log ("rpc", GF_LOG_ERROR,
-                                "wrong MSG-TYPE (%d) received from %s",
-                                in->msg_type,
-                                this->peerinfo.identifier);
-                        ret = -1;
-                }
+            buf = rpc_msgtype_addr(iobuf_ptr(in->iobuf));
+            in->msg_type = ntoh32(*((uint32_t *)buf));
+
+            if (in->msg_type == CALL) {
+                ret = __socket_read_request(this);
+            } else if (in->msg_type == REPLY) {
+                ret = __socket_read_reply(this);
+            } else if (in->msg_type == (msg_type_t)GF_UNIVERSAL_ANSWER) {
+                gf_log("rpc", GF_LOG_ERROR,
+                       "older version of protocol/process trying to "
+                       "connect from %s. use newer version on that node",
+                       this->peerinfo.identifier);
+            } else {
+                gf_log("rpc", GF_LOG_ERROR,
+                       "wrong MSG-TYPE (%d) received from %s", in->msg_type,
+                       this->peerinfo.identifier);
+                ret = -1;
+            }
 
-                remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read;
+            remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read;
 
-                if ((ret == -1)
-                    || ((ret == 0) && (remaining_size == 0)
-                        && (RPC_LASTFRAG (in->fraghdr)))) {
-                     /* frag->state = SP_STATE_NADA; */
-                        frag->state = SP_STATE_RPCFRAG_INIT;
-                }
+            if ((ret == -1) || ((ret == 0) && (remaining_size == 0) &&
+                                (RPC_LASTFRAG(in->fraghdr)))) {
+                /* frag->state = SP_STATE_NADA; */
+                frag->state = SP_STATE_RPCFRAG_INIT;
+            }
 
-                break;
+            break;
 
         case SP_STATE_NOTIFYING_XID:
-                /* Another epoll thread is notifying higher layers
-                 *of reply's xid. */
-                errno = EAGAIN;
-                return -1;
-                break;
-
-        }
+            /* Another epoll thread is notifying higher layers
+             *of reply's xid. */
+            errno = EAGAIN;
+            return -1;
+            break;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static void
-__socket_reset_priv (socket_private_t *priv)
+__socket_reset_priv(socket_private_t *priv)
 {
-        struct gf_sock_incoming   *in    = NULL;
+    struct gf_sock_incoming *in = NULL;
 
-        /* used to reduce the indirection */
-        in = &priv->incoming;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
 
-        if (in->iobref) {
-                iobref_unref (in->iobref);
-                in->iobref = NULL;
-        }
+    if (in->iobref) {
+        iobref_unref(in->iobref);
+        in->iobref = NULL;
+    }
 
-        if (in->iobuf) {
-                iobuf_unref (in->iobuf);
-                in->iobuf = NULL;
-        }
-
-        if (in->request_info != NULL) {
-                GF_FREE (in->request_info);
-                in->request_info = NULL;
-        }
+    if (in->iobuf) {
+        iobuf_unref(in->iobuf);
+        in->iobuf = NULL;
+    }
 
-        memset (&in->payload_vector, 0,
-                sizeof (in->payload_vector));
+    if (in->request_info != NULL) {
+        GF_FREE(in->request_info);
+        in->request_info = NULL;
+    }
 
+    memset(&in->payload_vector, 0, sizeof(in->payload_vector));
 }
 
-
 static int
-__socket_proto_state_machine (rpc_transport_t *this,
-                              rpc_transport_pollin_t **pollin)
+__socket_proto_state_machine(rpc_transport_t *this,
+                             rpc_transport_pollin_t **pollin)
 {
-        int               ret    = -1;
-        socket_private_t *priv   = NULL;
-        struct iobuf     *iobuf  = NULL;
-        struct iobref    *iobref = NULL;
-        struct iovec      vector[2];
-        struct gf_sock_incoming      *in         = NULL;
-        struct gf_sock_incoming_frag *frag       = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        /* used to reduce the indirection */
-        in = &priv->incoming;
-        frag = &in->frag;
-
-        while (in->record_state != SP_STATE_COMPLETE) {
-                switch (in->record_state) {
-
-                case SP_STATE_NADA:
-                        in->total_bytes_read = 0;
-                        in->payload_vector.iov_len = 0;
-
-                        in->pending_vector = in->vector;
-                        in->pending_vector->iov_base =  &in->fraghdr;
-
-                        in->pending_vector->iov_len  = sizeof (in->fraghdr);
-
-                        in->record_state = SP_STATE_READING_FRAGHDR;
-
-                        /* fall through */
-
-                case SP_STATE_READING_FRAGHDR:
-                        ret = __socket_readv (this, in->pending_vector, 1,
-                                              &in->pending_vector,
-                                              &in->pending_count,
-                                              NULL);
-                        if (ret == -1)
-                                goto out;
-
-                        if (ret > 0) {
-                                gf_log (this->name, GF_LOG_TRACE, "partial "
-                                        "fragment header read");
-                                goto out;
-                        }
+    int ret = -1;
+    socket_private_t *priv = NULL;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec vector[2];
+    struct gf_sock_incoming *in = NULL;
+    struct gf_sock_incoming_frag *frag = NULL;
 
-                        if (ret == 0) {
-                                in->record_state = SP_STATE_READ_FRAGHDR;
-                        }
-                        /* fall through */
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-                case SP_STATE_READ_FRAGHDR:
+    priv = this->private;
+    /* used to reduce the indirection */
+    in = &priv->incoming;
+    frag = &in->frag;
 
-                        in->fraghdr = ntoh32 (in->fraghdr);
-                        in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr);
+    while (in->record_state != SP_STATE_COMPLETE) {
+        switch (in->record_state) {
+            case SP_STATE_NADA:
+                in->total_bytes_read = 0;
+                in->payload_vector.iov_len = 0;
 
-                        if (in->total_bytes_read >= GF_UNIT_GB) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
+                in->pending_vector = in->vector;
+                in->pending_vector->iov_base = &in->fraghdr;
 
-                        iobuf = iobuf_get2 (this->ctx->iobuf_pool,
-                                            (in->total_bytes_read +
-                                             sizeof (in->fraghdr)));
-                        if (!iobuf) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
+                in->pending_vector->iov_len = sizeof(in->fraghdr);
 
-                        if (in->iobuf == NULL) {
-                            /* first fragment */
-                            frag->fragcurrent = iobuf_ptr (iobuf);
-                        } else {
-                            /* second or further fragment */
-                            memcpy(iobuf_ptr (iobuf), iobuf_ptr (in->iobuf),
-                               in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr));
-                            iobuf_unref (in->iobuf);
-                            frag->fragcurrent = (char *) iobuf_ptr (iobuf) +
-                                in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr);
-                            frag->pending_vector->iov_base = frag->fragcurrent;
-                            in->pending_vector = frag->pending_vector;
-                        }
+                in->record_state = SP_STATE_READING_FRAGHDR;
 
-                        in->iobuf = iobuf;
-                        in->iobuf_size = 0;
-                        in->record_state = SP_STATE_READING_FRAG;
-                        /* fall through */
+                /* fall through */
 
-                case SP_STATE_READING_FRAG:
-                        ret = __socket_read_frag (this);
+            case SP_STATE_READING_FRAGHDR:
+                ret = __socket_readv(this, in->pending_vector, 1,
+                                     &in->pending_vector, &in->pending_count,
+                                     NULL);
+                if (ret == -1)
+                    goto out;
 
-                        if ((ret == -1) ||
-                            (frag->bytes_read != RPC_FRAGSIZE (in->fraghdr))) {
-                                goto out;
-                        }
+                if (ret > 0) {
+                    gf_log(this->name, GF_LOG_TRACE,
+                           "partial "
+                           "fragment header read");
+                    goto out;
+                }
 
-                        frag->bytes_read = 0;
+                if (ret == 0) {
+                    in->record_state = SP_STATE_READ_FRAGHDR;
+                }
+                /* fall through */
 
-                        if (!RPC_LASTFRAG (in->fraghdr)) {
-                                in->pending_vector = in->vector;
-                                in->pending_vector->iov_base = &in->fraghdr;
-                                in->pending_vector->iov_len = sizeof(in->fraghdr);
-                                in->record_state = SP_STATE_READING_FRAGHDR;
-                                break;
-                        }
+            case SP_STATE_READ_FRAGHDR:
+
+                in->fraghdr = ntoh32(in->fraghdr);
+                in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr);
+
+                if (in->total_bytes_read >= GF_UNIT_GB) {
+                    ret = -ENOMEM;
+                    goto out;
+                }
+
+                iobuf = iobuf_get2(
+                    this->ctx->iobuf_pool,
+                    (in->total_bytes_read + sizeof(in->fraghdr)));
+                if (!iobuf) {
+                    ret = -ENOMEM;
+                    goto out;
+                }
 
-                        /* we've read the entire rpc record, notify the
-                         * upper layers.
-                         */
-                        if (pollin != NULL) {
-                                int count = 0;
-                                in->iobuf_size = (in->total_bytes_read -
-                                                  in->payload_vector.iov_len);
-
-                                memset (vector, 0, sizeof (vector));
-
-                                if (in->iobref == NULL) {
-                                        in->iobref = iobref_new ();
-                                        if (in->iobref == NULL) {
-                                                ret = -1;
-                                                goto out;
-                                        }
-                                }
-
-                                vector[count].iov_base = iobuf_ptr (in->iobuf);
-                                vector[count].iov_len = in->iobuf_size;
-
-                                iobref = in->iobref;
-
-                                count++;
-
-                                if (in->payload_vector.iov_base != NULL) {
-                                        vector[count] = in->payload_vector;
-                                        count++;
-                                }
-
-                                *pollin = rpc_transport_pollin_alloc (this,
-                                                                      vector,
-                                                                      count,
-                                                                      in->iobuf,
-                                                                      iobref,
-                                                                      in->request_info);
-                                iobuf_unref (in->iobuf);
-                                in->iobuf = NULL;
-
-                                if (*pollin == NULL) {
-                                        gf_log (this->name, GF_LOG_WARNING,
-                                                "transport pollin allocation failed");
-                                        ret = -1;
-                                        goto out;
-                                }
-                                if (in->msg_type == REPLY)
-                                        (*pollin)->is_reply = 1;
-
-                                in->request_info = NULL;
+                if (in->iobuf == NULL) {
+                    /* first fragment */
+                    frag->fragcurrent = iobuf_ptr(iobuf);
+                } else {
+                    /* second or further fragment */
+                    memcpy(iobuf_ptr(iobuf), iobuf_ptr(in->iobuf),
+                           in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr));
+                    iobuf_unref(in->iobuf);
+                    frag->fragcurrent = (char *)iobuf_ptr(iobuf) +
+                                        in->total_bytes_read -
+                                        RPC_FRAGSIZE(in->fraghdr);
+                    frag->pending_vector->iov_base = frag->fragcurrent;
+                    in->pending_vector = frag->pending_vector;
+                }
+
+                in->iobuf = iobuf;
+                in->iobuf_size = 0;
+                in->record_state = SP_STATE_READING_FRAG;
+                /* fall through */
+
+            case SP_STATE_READING_FRAG:
+                ret = __socket_read_frag(this);
+
+                if ((ret == -1) ||
+                    (frag->bytes_read != RPC_FRAGSIZE(in->fraghdr))) {
+                    goto out;
+                }
+
+                frag->bytes_read = 0;
+
+                if (!RPC_LASTFRAG(in->fraghdr)) {
+                    in->pending_vector = in->vector;
+                    in->pending_vector->iov_base = &in->fraghdr;
+                    in->pending_vector->iov_len = sizeof(in->fraghdr);
+                    in->record_state = SP_STATE_READING_FRAGHDR;
+                    break;
+                }
+
+                /* we've read the entire rpc record, notify the
+                 * upper layers.
+                 */
+                if (pollin != NULL) {
+                    int count = 0;
+                    in->iobuf_size = (in->total_bytes_read -
+                                      in->payload_vector.iov_len);
+
+                    memset(vector, 0, sizeof(vector));
+
+                    if (in->iobref == NULL) {
+                        in->iobref = iobref_new();
+                        if (in->iobref == NULL) {
+                            ret = -1;
+                            goto out;
                         }
-                        in->record_state = SP_STATE_COMPLETE;
-                        break;
+                    }
 
-                case SP_STATE_COMPLETE:
-                        /* control should not reach here */
-                        gf_log (this->name, GF_LOG_WARNING, "control reached to "
-                                "SP_STATE_COMPLETE, which should not have "
-                                "happened");
-                        break;
+                    vector[count].iov_base = iobuf_ptr(in->iobuf);
+                    vector[count].iov_len = in->iobuf_size;
+
+                    iobref = in->iobref;
+
+                    count++;
+
+                    if (in->payload_vector.iov_base != NULL) {
+                        vector[count] = in->payload_vector;
+                        count++;
+                    }
+
+                    *pollin = rpc_transport_pollin_alloc(this, vector, count,
+                                                         in->iobuf, iobref,
+                                                         in->request_info);
+                    iobuf_unref(in->iobuf);
+                    in->iobuf = NULL;
+
+                    if (*pollin == NULL) {
+                        gf_log(this->name, GF_LOG_WARNING,
+                               "transport pollin allocation failed");
+                        ret = -1;
+                        goto out;
+                    }
+                    if (in->msg_type == REPLY)
+                        (*pollin)->is_reply = 1;
+
+                    in->request_info = NULL;
                 }
-        }
+                in->record_state = SP_STATE_COMPLETE;
+                break;
 
-        if (in->record_state == SP_STATE_COMPLETE) {
-                in->record_state = SP_STATE_NADA;
-                __socket_reset_priv (priv);
+            case SP_STATE_COMPLETE:
+                /* control should not reach here */
+                gf_log(this->name, GF_LOG_WARNING,
+                       "control reached to "
+                       "SP_STATE_COMPLETE, which should not have "
+                       "happened");
+                break;
         }
+    }
+
+    if (in->record_state == SP_STATE_COMPLETE) {
+        in->record_state = SP_STATE_NADA;
+        __socket_reset_priv(priv);
+    }
 
 out:
-        if ((ret == -1) && (errno == EAGAIN)) {
-                ret = 0;
-        }
+    if ((ret == -1) && (errno == EAGAIN)) {
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_proto_state_machine (rpc_transport_t *this,
-                            rpc_transport_pollin_t **pollin)
+socket_proto_state_machine(rpc_transport_t *this,
+                           rpc_transport_pollin_t **pollin)
 {
-        socket_private_t *priv = NULL;
-        int               ret = 0;
+    socket_private_t *priv = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->in_lock);
-        {
-                ret = __socket_proto_state_machine (this, pollin);
-        }
-        pthread_mutex_unlock (&priv->in_lock);
+    pthread_mutex_lock(&priv->in_lock);
+    {
+        ret = __socket_proto_state_machine(this, pollin);
+    }
+    pthread_mutex_unlock(&priv->in_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_event_poll_in (rpc_transport_t *this, gf_boolean_t notify_handled)
+socket_event_poll_in(rpc_transport_t *this, gf_boolean_t notify_handled)
 {
-        int                     ret    = -1;
-        rpc_transport_pollin_t *pollin = NULL;
-        socket_private_t       *priv = this->private;
-        glusterfs_ctx_t        *ctx  = NULL;
+    int ret = -1;
+    rpc_transport_pollin_t *pollin = NULL;
+    socket_private_t *priv = this->private;
+    glusterfs_ctx_t *ctx = NULL;
 
-        ctx = this->ctx;
+    ctx = this->ctx;
 
-        ret = socket_proto_state_machine (this, &pollin);
+    ret = socket_proto_state_machine(this, &pollin);
 
-        if (pollin) {
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        priv->notify.in_progress++;
-                }
-                pthread_mutex_unlock (&priv->notify.lock);
+    if (pollin) {
+        pthread_mutex_lock(&priv->notify.lock);
+        {
+            priv->notify.in_progress++;
         }
+        pthread_mutex_unlock(&priv->notify.lock);
+    }
 
+    if (notify_handled && (ret != -1))
+        event_handled(ctx->event_pool, priv->sock, priv->idx, priv->gen);
 
-        if (notify_handled && (ret != -1))
-                event_handled (ctx->event_pool, priv->sock, priv->idx,
-                               priv->gen);
-
-        if (pollin) {
-                ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_RECEIVED,
-                                            pollin);
+    if (pollin) {
+        ret = rpc_transport_notify(this, RPC_TRANSPORT_MSG_RECEIVED, pollin);
 
-                rpc_transport_pollin_destroy (pollin);
+        rpc_transport_pollin_destroy(pollin);
 
-                pthread_mutex_lock (&priv->notify.lock);
-                {
-                        --priv->notify.in_progress;
+        pthread_mutex_lock(&priv->notify.lock);
+        {
+            --priv->notify.in_progress;
 
-                        if (!priv->notify.in_progress)
-                                pthread_cond_signal (&priv->notify.cond);
-                }
-                pthread_mutex_unlock (&priv->notify.lock);
+            if (!priv->notify.in_progress)
+                pthread_cond_signal(&priv->notify.cond);
         }
+        pthread_mutex_unlock(&priv->notify.lock);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_connect_finish (rpc_transport_t *this)
+socket_connect_finish(rpc_transport_t *this)
 {
-        int                   ret        = -1;
-        socket_private_t     *priv       = NULL;
-        rpc_transport_event_t event      = 0;
-        char                  notify_rpc = 0;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    int ret = -1;
+    socket_private_t *priv = NULL;
+    rpc_transport_event_t event = 0;
+    char notify_rpc = 0;
 
-        priv = this->private;
-
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if (priv->connected != 0)
-                        goto unlock;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-                get_transport_identifiers (this);
+    priv = this->private;
 
-                ret = __socket_connect_finish (priv->sock);
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected != 0)
+            goto unlock;
 
-                if (ret == -1 && errno == EINPROGRESS)
-                        ret = 1;
+        get_transport_identifiers(this);
 
-                if (ret == -1 && errno != EINPROGRESS) {
-                        if (!priv->connect_finish_log) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "connection to %s failed (%s); "
-                                        "disconnecting socket",
-                                        this->peerinfo.identifier,
-                                        strerror (errno));
-                                priv->connect_finish_log = 1;
-                        }
-                        __socket_disconnect (this);
-                        goto unlock;
-                }
+        ret = __socket_connect_finish(priv->sock);
 
-                if (ret == 0) {
-                        notify_rpc = 1;
-
-                        this->myinfo.sockaddr_len =
-                                sizeof (this->myinfo.sockaddr);
-
-                        ret = getsockname (priv->sock,
-                                           SA (&this->myinfo.sockaddr),
-                                           &this->myinfo.sockaddr_len);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "getsockname on (%d) failed (%s) - "
-                                        "disconnecting socket",
-                                        priv->sock, strerror (errno));
-                                __socket_disconnect (this);
-                                event = RPC_TRANSPORT_DISCONNECT;
-                                goto unlock;
-                        }
+        if (ret == -1 && errno == EINPROGRESS)
+            ret = 1;
 
-                        priv->connected = 1;
-                        priv->connect_finish_log = 0;
-                        event = RPC_TRANSPORT_CONNECT;
-                }
+        if (ret == -1 && errno != EINPROGRESS) {
+            if (!priv->connect_finish_log) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "connection to %s failed (%s); "
+                       "disconnecting socket",
+                       this->peerinfo.identifier, strerror(errno));
+                priv->connect_finish_log = 1;
+            }
+            __socket_disconnect(this);
+            goto unlock;
         }
+
+        if (ret == 0) {
+            notify_rpc = 1;
+
+            this->myinfo.sockaddr_len = sizeof(this->myinfo.sockaddr);
+
+            ret = getsockname(priv->sock, SA(&this->myinfo.sockaddr),
+                              &this->myinfo.sockaddr_len);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "getsockname on (%d) failed (%s) - "
+                       "disconnecting socket",
+                       priv->sock, strerror(errno));
+                __socket_disconnect(this);
+                event = RPC_TRANSPORT_DISCONNECT;
+                goto unlock;
+            }
+
+            priv->connected = 1;
+            priv->connect_finish_log = 0;
+            event = RPC_TRANSPORT_CONNECT;
+        }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
-        if (notify_rpc) {
-                rpc_transport_notify (this, event, this);
-        }
+    if (notify_rpc) {
+        rpc_transport_notify(this, event, this);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-static int socket_disconnect (rpc_transport_t *this, gf_boolean_t wait);
+static int
+socket_disconnect(rpc_transport_t *this, gf_boolean_t wait);
 
 /* socket_is_connected() is for use only in socket_event_handler() */
 static inline gf_boolean_t
-socket_is_connected (rpc_transport_t *this)
+socket_is_connected(rpc_transport_t *this)
 {
-        socket_private_t *priv          = NULL;
+    socket_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->use_ssl) {
-                return priv->is_server ? priv->ssl_accepted :
-                                         priv->ssl_connected;
-        } else {
-                return priv->is_server ? priv->accepted :
-                                         priv->connected;
-        }
+    if (priv->use_ssl) {
+        return priv->is_server ? priv->ssl_accepted : priv->ssl_connected;
+    } else {
+        return priv->is_server ? priv->accepted : priv->connected;
+    }
 }
 
 static void
-ssl_rearm_event_fd (rpc_transport_t *this)
+ssl_rearm_event_fd(rpc_transport_t *this)
 {
-        socket_private_t *priv   = NULL;
-        glusterfs_ctx_t  *ctx    = NULL;
-        int               idx = -1;
-        int               gen = -1;
-        int               fd  = -1;
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        idx = priv->idx;
-        gen = priv->gen;
-        fd  = priv->sock;
-
-        if (priv->ssl_error_required == SSL_ERROR_WANT_READ)
-                event_select_on (ctx->event_pool, fd, idx, 1, -1);
-        if (priv->ssl_error_required == SSL_ERROR_WANT_WRITE)
-                event_select_on (ctx->event_pool, fd, idx, -1, 1);
-        event_handled (ctx->event_pool, fd, idx, gen);
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    if (priv->ssl_error_required == SSL_ERROR_WANT_READ)
+        event_select_on(ctx->event_pool, fd, idx, 1, -1);
+    if (priv->ssl_error_required == SSL_ERROR_WANT_WRITE)
+        event_select_on(ctx->event_pool, fd, idx, -1, 1);
+    event_handled(ctx->event_pool, fd, idx, gen);
 }
 
 static int
-ssl_handle_server_connection_attempt (rpc_transport_t *this)
+ssl_handle_server_connection_attempt(rpc_transport_t *this)
 {
-        socket_private_t *priv   = NULL;
-        glusterfs_ctx_t  *ctx    = NULL;
-        int               idx = -1;
-        int               gen = -1;
-        int               ret = -1;
-        int               fd  = -1;
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        idx = priv->idx;
-        gen = priv->gen;
-        fd  = priv->sock;
-
-        if (!priv->ssl_context_created) {
-                ret = ssl_setup_connection_prefix (this);
-                if (ret < 0) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "> ssl_setup_connection_prefix() failed!");
-                        ret = -1;
-                        goto out;
-                } else {
-                        priv->ssl_context_created = _gf_true;
-                }
-        }
-        ret = ssl_complete_connection (this);
-        if (ret == 0) {
-                /* nothing to do */
-                event_select_on (ctx->event_pool, fd, idx, 1, 0);
-                event_handled (ctx->event_pool, fd, idx, gen);
-                ret = 1;
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    if (!priv->ssl_context_created) {
+        ret = ssl_setup_connection_prefix(this);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_TRACE,
+                   "> ssl_setup_connection_prefix() failed!");
+            ret = -1;
+            goto out;
         } else {
-                if (errno == EAGAIN) {
-                        ssl_rearm_event_fd (this);
-                        ret = 1;
-                } else {
-                        ret = -1;
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "ssl_complete_connection returned error");
-                }
+            priv->ssl_context_created = _gf_true;
+        }
+    }
+    ret = ssl_complete_connection(this);
+    if (ret == 0) {
+        /* nothing to do */
+        event_select_on(ctx->event_pool, fd, idx, 1, 0);
+        event_handled(ctx->event_pool, fd, idx, gen);
+        ret = 1;
+    } else {
+        if (errno == EAGAIN) {
+            ssl_rearm_event_fd(this);
+            ret = 1;
+        } else {
+            ret = -1;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "ssl_complete_connection returned error");
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-ssl_handle_client_connection_attempt (rpc_transport_t *this)
+ssl_handle_client_connection_attempt(rpc_transport_t *this)
 {
-        socket_private_t *priv   = NULL;
-        glusterfs_ctx_t  *ctx    = NULL;
-        int               idx = -1;
-        int               ret = -1;
-        int               fd  = -1;
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        idx = priv->idx;
-        fd  = priv->sock;
-
-        /* SSL client */
-        if (priv->connect_failed) {
-                gf_log (this->name, GF_LOG_TRACE,
-                        ">>> disconnecting SSL socket");
-                ret = socket_disconnect (this, _gf_false);
-                /* Force ret to be -1, as we are officially done with
-                   this socket */
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    fd = priv->sock;
+
+    /* SSL client */
+    if (priv->connect_failed) {
+        gf_log(this->name, GF_LOG_TRACE, ">>> disconnecting SSL socket");
+        ret = socket_disconnect(this, _gf_false);
+        /* Force ret to be -1, as we are officially done with
+           this socket */
+        ret = -1;
+    } else {
+        if (!priv->ssl_context_created) {
+            ret = ssl_setup_connection_prefix(this);
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "> ssl_setup_connection_prefix() "
+                       "failed!");
                 ret = -1;
+                goto out;
+            } else {
+                priv->ssl_context_created = _gf_true;
+            }
+        }
+        ret = ssl_complete_connection(this);
+        if (ret == 0) {
+            ret = socket_connect_finish(this);
+            event_select_on(ctx->event_pool, fd, idx, 1, 0);
+            gf_log(this->name, GF_LOG_TRACE, ">>> completed client connect");
         } else {
-                if (!priv->ssl_context_created) {
-                        ret = ssl_setup_connection_prefix (this);
-                        if (ret < 0) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "> ssl_setup_connection_prefix() "
-                                        "failed!");
-                                ret = -1;
-                                goto out;
-                        } else {
-                                priv->ssl_context_created = _gf_true;
-                        }
-                }
-                ret = ssl_complete_connection (this);
-                if (ret == 0) {
-                        ret = socket_connect_finish (this);
-                        event_select_on (ctx->event_pool, fd, idx, 1, 0);
-                        gf_log (this->name, GF_LOG_TRACE,
-                                ">>> completed client connect");
-                } else {
-                        if (errno == EAGAIN) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        ">>> retrying client connect 2");
-                                ssl_rearm_event_fd (this);
-                                ret = 1;
-                        } else {
-                                /* this is a connection failure */
-                                ret = socket_connect_finish (this);
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "ssl_complete_connection "
-                                        "returned error");
-                                ret = -1;
-                        }
-                }
+            if (errno == EAGAIN) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       ">>> retrying client connect 2");
+                ssl_rearm_event_fd(this);
+                ret = 1;
+            } else {
+                /* this is a connection failure */
+                ret = socket_connect_finish(this);
+                gf_log(this->name, GF_LOG_TRACE,
+                       "ssl_complete_connection "
+                       "returned error");
+                ret = -1;
+            }
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 static int
-socket_handle_client_connection_attempt (rpc_transport_t *this)
+socket_handle_client_connection_attempt(rpc_transport_t *this)
 {
-        socket_private_t *priv   = NULL;
-        glusterfs_ctx_t  *ctx    = NULL;
-        int               idx = -1;
-        int               gen = -1;
-        int               ret = -1;
-        int               fd  = -1;
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        idx = priv->idx;
-        gen = priv->gen;
-        fd  = priv->sock;
-
-        /* non-SSL client */
-        if (priv->connect_failed) {
-                /* connect failed with some other error than
-                   EINPROGRESS or ENOENT, so nothing more to
-                   do, fail reading/writing anything even if
-                   poll_in or poll_out
-                   is set
-                   */
-                gf_log ("transport", GF_LOG_DEBUG,
-                        "connect failed with some other error "
-                        "than EINPROGRESS or ENOENT, so "
-                        "nothing more to do; disconnecting "
-                        "socket");
-                (void)socket_disconnect (this, _gf_false);
-
-                /* Force ret to be -1, as we are officially
-                 * done with this socket
-                 */
-                ret = -1;
-        } else {
-                ret = socket_connect_finish (this);
-                gf_log (this->name, GF_LOG_TRACE,
-                        "socket_connect_finish() returned %d",
-                        ret);
-                if (ret == 0 || ret == 1) {
-                        /* we don't want to do any reads or
-                         * writes on the connection yet in
-                         * socket_event_handler, so just
-                         * return 1
-                         */
-                        ret = 1;
-                        event_handled (ctx->event_pool, fd, idx, gen);
-                }
-        }
-        return ret;
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
+
+    /* non-SSL client */
+    if (priv->connect_failed) {
+        /* connect failed with some other error than
+           EINPROGRESS or ENOENT, so nothing more to
+           do, fail reading/writing anything even if
+           poll_in or poll_out
+           is set
+           */
+        gf_log("transport", GF_LOG_DEBUG,
+               "connect failed with some other error "
+               "than EINPROGRESS or ENOENT, so "
+               "nothing more to do; disconnecting "
+               "socket");
+        (void)socket_disconnect(this, _gf_false);
+
+        /* Force ret to be -1, as we are officially
+         * done with this socket
+         */
+        ret = -1;
+    } else {
+        ret = socket_connect_finish(this);
+        gf_log(this->name, GF_LOG_TRACE, "socket_connect_finish() returned %d",
+               ret);
+        if (ret == 0 || ret == 1) {
+            /* we don't want to do any reads or
+             * writes on the connection yet in
+             * socket_event_handler, so just
+             * return 1
+             */
+            ret = 1;
+            event_handled(ctx->event_pool, fd, idx, gen);
+        }
+    }
+    return ret;
 }
 
 static int
-socket_complete_connection (rpc_transport_t *this)
+socket_complete_connection(rpc_transport_t *this)
 {
-        socket_private_t *priv   = NULL;
-        glusterfs_ctx_t  *ctx    = NULL;
-        int               idx = -1;
-        int               gen = -1;
-        int               ret = -1;
-        int               fd  = -1;
+    socket_private_t *priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    int idx = -1;
+    int gen = -1;
+    int ret = -1;
+    int fd = -1;
 
-        priv = this->private;
-        ctx = this->ctx;
+    priv = this->private;
+    ctx = this->ctx;
 
-        idx = priv->idx;
-        gen = priv->gen;
-        fd  = priv->sock;
+    idx = priv->idx;
+    gen = priv->gen;
+    fd = priv->sock;
 
-        if (priv->use_ssl) {
-                if (priv->is_server) {
-                        ret = ssl_handle_server_connection_attempt (this);
-                } else {
-                        ret = ssl_handle_client_connection_attempt (this);
-                }
+    if (priv->use_ssl) {
+        if (priv->is_server) {
+            ret = ssl_handle_server_connection_attempt(this);
         } else {
-                if (priv->is_server) {
-                        /* non-SSL server: nothing much to do
-                         * connection has already been accepted in
-                         * socket_server_event_handler()
-                         */
-                        priv->accepted = _gf_true;
-                        event_handled (ctx->event_pool, fd, idx, gen);
-                        ret = 1;
-                } else {
-                        ret = socket_handle_client_connection_attempt (this);
-                }
+            ret = ssl_handle_client_connection_attempt(this);
         }
-        return ret;
+    } else {
+        if (priv->is_server) {
+            /* non-SSL server: nothing much to do
+             * connection has already been accepted in
+             * socket_server_event_handler()
+             */
+            priv->accepted = _gf_true;
+            event_handled(ctx->event_pool, fd, idx, gen);
+            ret = 1;
+        } else {
+            ret = socket_handle_client_connection_attempt(this);
+        }
+    }
+    return ret;
 }
 
 /* reads rpc_requests during pollin */
 static int
-socket_event_handler (int fd, int idx, int gen, void *data,
-                      int poll_in, int poll_out, int poll_err)
+socket_event_handler(int fd, int idx, int gen, void *data, int poll_in,
+                     int poll_out, int poll_err)
 {
-        rpc_transport_t  *this          = NULL;
-        socket_private_t *priv          = NULL;
-        int               ret           = -1;
-        glusterfs_ctx_t  *ctx           = NULL;
-        gf_boolean_t      socket_closed = _gf_false, notify_handled = _gf_false;
+    rpc_transport_t *this = NULL;
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_boolean_t socket_closed = _gf_false, notify_handled = _gf_false;
 
+    this = data;
 
-        this = data;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this->xl, out);
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->xl, out);
+    THIS = this->xl;
+    priv = this->private;
+    ctx = this->ctx;
 
-        THIS = this->xl;
-        priv = this->private;
-        ctx = this->ctx;
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        priv->idx = idx;
+        priv->gen = gen;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
+
+    gf_log(this->name, GF_LOG_TRACE, "%s (sock:%d) in:%d, out:%d, err:%d",
+           (priv->is_server ? "server" : "client"), priv->sock, poll_in,
+           poll_out, poll_err);
+
+    if (!poll_err) {
+        if (!socket_is_connected(this)) {
+            gf_log(this->name, GF_LOG_TRACE,
+                   "%s (sock:%d) socket is not connected, "
+                   "completing connection",
+                   (priv->is_server ? "server" : "client"), priv->sock);
+
+            ret = socket_complete_connection(this);
+
+            gf_log(this->name, GF_LOG_TRACE,
+                   "(sock:%d) "
+                   "socket_complete_connection() returned %d",
+                   priv->sock, ret);
+
+            if (ret > 0) {
+                gf_log(this->name, GF_LOG_TRACE,
+                       "(sock:%d) returning to wait on socket", priv->sock);
+                return 0;
+            }
+        } else {
+            char *sock_type = (priv->is_server ? "Server" : "Client");
 
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                priv->idx = idx;
-                priv->gen = gen;
+            gf_log(this->name, GF_LOG_TRACE,
+                   "%s socket (%d) is already connected", sock_type,
+                   priv->sock);
+            ret = 0;
         }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
-
-        gf_log (this->name, GF_LOG_TRACE, "%s (sock:%d) in:%d, out:%d, err:%d",
-                (priv->is_server ? "server" : "client"),
-                priv->sock, poll_in, poll_out, poll_err);
-
-        if (!poll_err) {
-                if (!socket_is_connected (this)) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "%s (sock:%d) socket is not connected, "
-                                "completing connection",
-                                (priv->is_server ? "server" : "client"),
-                                priv->sock);
-
-                        ret = socket_complete_connection (this);
-
-                        gf_log (this->name, GF_LOG_TRACE, "(sock:%d) "
-                                "socket_complete_connection() returned %d",
-                                priv->sock, ret);
-
-                        if (ret > 0) {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        "(sock:%d) returning to wait on socket",
-                                        priv->sock);
-                                return 0;
-                        }
-                } else {
-                        char *sock_type = (priv->is_server ? "Server" :
-                                                             "Client");
+    }
 
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "%s socket (%d) is already connected",
-                                sock_type, priv->sock);
-                        ret = 0;
-                }
-        }
+    if (!ret && poll_out) {
+        ret = socket_event_poll_out(this);
+        gf_log(this->name, GF_LOG_TRACE,
+               "(sock:%d) "
+               "socket_event_poll_out returned %d",
+               priv->sock, ret);
+    }
 
-        if (!ret && poll_out) {
-                ret = socket_event_poll_out (this);
-                gf_log (this->name, GF_LOG_TRACE, "(sock:%d) "
-                        "socket_event_poll_out returned %d", priv->sock, ret);
-        }
+    if (!ret && poll_in) {
+        ret = socket_event_poll_in(this, !poll_err);
+        gf_log(this->name, GF_LOG_TRACE,
+               "(sock:%d) "
+               "socket_event_poll_in returned %d",
+               priv->sock, ret);
+        notify_handled = _gf_true;
+    }
 
-        if (!ret && poll_in) {
-                ret = socket_event_poll_in (this, !poll_err);
-                gf_log (this->name, GF_LOG_TRACE, "(sock:%d) "
-                        "socket_event_poll_in returned %d", priv->sock, ret);
-                notify_handled = _gf_true;
-        }
+    if ((ret < 0) || poll_err) {
+        struct sockaddr *sa = SA(&this->peerinfo.sockaddr);
 
-        if ((ret < 0) || poll_err) {
-                struct sockaddr *sa = SA(&this->peerinfo.sockaddr);
+        if (priv->is_server &&
+            SA(&this->myinfo.sockaddr)->sa_family == AF_UNIX) {
+            sa = SA(&this->myinfo.sockaddr);
+        }
 
-                if (priv->is_server &&
-                    SA(&this->myinfo.sockaddr)->sa_family == AF_UNIX) {
-                        sa = SA(&this->myinfo.sockaddr);
-                }
+        socket_dump_info(sa, priv->is_server, priv->use_ssl, priv->sock,
+                         this->name, "disconnecting from");
 
-                socket_dump_info (sa, priv->is_server, priv->use_ssl,
-                                  priv->sock, this->name,
-                                  "disconnecting from");
+        /* Logging has happened already in earlier cases */
+        gf_log("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG),
+               "EPOLLERR - disconnecting (sock:%d) (%s)", priv->sock,
+               (priv->use_ssl ? "SSL" : "non-SSL"));
 
-                /* Logging has happened already in earlier cases */
-                gf_log ("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG),
-                        "EPOLLERR - disconnecting (sock:%d) (%s)",
-                        priv->sock, (priv->use_ssl ? "SSL" : "non-SSL"));
+        socket_closed = socket_event_poll_err(this, gen, idx);
 
-                socket_closed = socket_event_poll_err (this, gen, idx);
+        if (socket_closed)
+            rpc_transport_unref(this);
 
-                if (socket_closed)
-                        rpc_transport_unref (this);
-
-        } else if (!notify_handled) {
-                event_handled (ctx->event_pool, fd, idx, gen);
-        }
+    } else if (!notify_handled) {
+        event_handled(ctx->event_pool, fd, idx, gen);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-socket_server_event_handler (int fd, int idx, int gen, void *data,
-                             int poll_in, int poll_out, int poll_err)
+socket_server_event_handler(int fd, int idx, int gen, void *data, int poll_in,
+                            int poll_out, int poll_err)
 {
-        rpc_transport_t             *this = NULL;
-        socket_private_t        *priv = NULL;
-        int                      ret = 0;
-        int                      new_sock = -1;
-        rpc_transport_t             *new_trans = NULL;
-        struct sockaddr_storage  new_sockaddr = {0, };
-        socklen_t                addrlen = sizeof (new_sockaddr);
-        socket_private_t        *new_priv = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-
-        this = data;
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->xl, out);
-
-        THIS = this->xl;
-        priv = this->private;
-        ctx  = this->ctx;
-
-        /* NOTE:
-         * We have done away with the critical section in this function. since
-         * there's little that it helps with. There's no other code that
-         * attempts to unref the listener socket/transport from any other
-         * thread context while we are using it here.
-         */
-        priv->idx = idx;
-
-        if (poll_in) {
-                new_sock = accept (priv->sock, SA (&new_sockaddr), &addrlen);
-
-                if (ctx)
-                        event_handled (ctx->event_pool, fd, idx, gen);
-
-                if (new_sock == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "accept on %d failed (%s)",
-                                priv->sock, strerror (errno));
-                        goto out;
-                }
-
-                if (priv->nodelay && (new_sockaddr.ss_family != AF_UNIX)) {
-                        ret = __socket_nodelay (new_sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "setsockopt() failed for "
-                                        "NODELAY (%s)",
-                                        strerror (errno));
-                        }
-                }
-
-                if (priv->keepalive &&
-                                new_sockaddr.ss_family != AF_UNIX) {
-                        ret = __socket_keepalive (new_sock,
-                                                  new_sockaddr.ss_family,
-                                                  priv->keepaliveintvl,
-                                                  priv->keepaliveidle,
-                                                  priv->keepalivecnt,
-                                                  priv->timeout);
-                        if (ret == -1)
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "Failed to set keep-alive: %s",
-                                        strerror (errno));
-                }
-
-                new_trans = GF_CALLOC (1, sizeof (*new_trans),
-                                gf_common_mt_rpc_trans_t);
-                if (!new_trans) {
-                        sys_close (new_sock);
-                        goto out;
-                }
-
-                ret = pthread_mutex_init(&new_trans->lock, NULL);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "pthread_mutex_init() failed: %s",
-                                strerror (errno));
-                        sys_close (new_sock);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
-                INIT_LIST_HEAD (&new_trans->list);
-
-                new_trans->name = gf_strdup (this->name);
-
-                memcpy (&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen);
-                new_trans->peerinfo.sockaddr_len = addrlen;
-
-                new_trans->myinfo.sockaddr_len = sizeof (new_trans->myinfo.sockaddr);
-
-                ret = getsockname (new_sock, SA (&new_trans->myinfo.sockaddr),
-                                   &new_trans->myinfo.sockaddr_len);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "getsockname on %d failed (%s)",
-                                new_sock, strerror (errno));
-                        sys_close (new_sock);
-                        GF_FREE (new_trans->name);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
+    rpc_transport_t *this = NULL;
+    socket_private_t *priv = NULL;
+    int ret = 0;
+    int new_sock = -1;
+    rpc_transport_t *new_trans = NULL;
+    struct sockaddr_storage new_sockaddr = {
+        0,
+    };
+    socklen_t addrlen = sizeof(new_sockaddr);
+    socket_private_t *new_priv = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+
+    this = data;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this->xl, out);
+
+    THIS = this->xl;
+    priv = this->private;
+    ctx = this->ctx;
+
+    /* NOTE:
+     * We have done away with the critical section in this function. since
+     * there's little that it helps with. There's no other code that
+     * attempts to unref the listener socket/transport from any other
+     * thread context while we are using it here.
+     */
+    priv->idx = idx;
+
+    if (poll_in) {
+        new_sock = accept(priv->sock, SA(&new_sockaddr), &addrlen);
+
+        if (ctx)
+            event_handled(ctx->event_pool, fd, idx, gen);
+
+        if (new_sock == -1) {
+            gf_log(this->name, GF_LOG_WARNING, "accept on %d failed (%s)",
+                   priv->sock, strerror(errno));
+            goto out;
+        }
+
+        if (priv->nodelay && (new_sockaddr.ss_family != AF_UNIX)) {
+            ret = __socket_nodelay(new_sock);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "setsockopt() failed for "
+                       "NODELAY (%s)",
+                       strerror(errno));
+            }
+        }
+
+        if (priv->keepalive && new_sockaddr.ss_family != AF_UNIX) {
+            ret = __socket_keepalive(new_sock, new_sockaddr.ss_family,
+                                     priv->keepaliveintvl, priv->keepaliveidle,
+                                     priv->keepalivecnt, priv->timeout);
+            if (ret == -1)
+                gf_log(this->name, GF_LOG_WARNING,
+                       "Failed to set keep-alive: %s", strerror(errno));
+        }
+
+        new_trans = GF_CALLOC(1, sizeof(*new_trans), gf_common_mt_rpc_trans_t);
+        if (!new_trans) {
+            sys_close(new_sock);
+            goto out;
+        }
+
+        ret = pthread_mutex_init(&new_trans->lock, NULL);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "pthread_mutex_init() failed: %s", strerror(errno));
+            sys_close(new_sock);
+            GF_FREE(new_trans);
+            goto out;
+        }
+        INIT_LIST_HEAD(&new_trans->list);
 
-                get_transport_identifiers (new_trans);
-                gf_log (this->name, GF_LOG_TRACE, "XXX server:%s, client:%s",
-                        new_trans->myinfo.identifier,
-                        new_trans->peerinfo.identifier);
+        new_trans->name = gf_strdup(this->name);
 
-                ret = socket_init(new_trans);
-                if (ret != 0) {
-                        sys_close (new_sock);
-                        GF_FREE (new_trans->name);
-                        GF_FREE (new_trans);
-                        goto out;
-                }
-                new_trans->ops = this->ops;
-                new_trans->init = this->init;
-                new_trans->fini = this->fini;
-                new_trans->ctx  = ctx;
-                new_trans->xl   = this->xl;
-                new_trans->mydata = this->mydata;
-                new_trans->notify = this->notify;
-                new_trans->listener = this;
-                new_priv = new_trans->private;
-
-                if (new_sockaddr.ss_family == AF_UNIX) {
-                        new_priv->use_ssl = _gf_false;
-                } else {
-                        switch (priv->srvr_ssl) {
-                                case MGMT_SSL_ALWAYS:
-                                        /* Glusterd with secure_mgmt. */
-                                        new_priv->use_ssl = _gf_true;
-                                        break;
-                                case MGMT_SSL_COPY_IO:
-                                        /* Glusterfsd. */
-                                        new_priv->use_ssl = priv->ssl_enabled;
-                                        break;
-                                default:
-                                        new_priv->use_ssl = _gf_false;
-                        }
-                }
+        memcpy(&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen);
+        new_trans->peerinfo.sockaddr_len = addrlen;
 
-                new_priv->sock = new_sock;
+        new_trans->myinfo.sockaddr_len = sizeof(new_trans->myinfo.sockaddr);
 
-                new_priv->ssl_enabled = priv->ssl_enabled;
-                new_priv->ssl_ctx = priv->ssl_ctx;
-                new_priv->connected = 1;
-                new_priv->is_server = _gf_true;
-
-                /* set O_NONBLOCK for plain text as well as ssl connections */
-                if (!priv->bio) {
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "### use non-blocking IO");
-                        ret = __socket_nonblock (new_sock);
+        ret = getsockname(new_sock, SA(&new_trans->myinfo.sockaddr),
+                          &new_trans->myinfo.sockaddr_len);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_WARNING, "getsockname on %d failed (%s)",
+                   new_sock, strerror(errno));
+            sys_close(new_sock);
+            GF_FREE(new_trans->name);
+            GF_FREE(new_trans);
+            goto out;
+        }
+
+        get_transport_identifiers(new_trans);
+        gf_log(this->name, GF_LOG_TRACE, "XXX server:%s, client:%s",
+               new_trans->myinfo.identifier, new_trans->peerinfo.identifier);
+
+        ret = socket_init(new_trans);
+        if (ret != 0) {
+            sys_close(new_sock);
+            GF_FREE(new_trans->name);
+            GF_FREE(new_trans);
+            goto out;
+        }
+        new_trans->ops = this->ops;
+        new_trans->init = this->init;
+        new_trans->fini = this->fini;
+        new_trans->ctx = ctx;
+        new_trans->xl = this->xl;
+        new_trans->mydata = this->mydata;
+        new_trans->notify = this->notify;
+        new_trans->listener = this;
+        new_priv = new_trans->private;
+
+        if (new_sockaddr.ss_family == AF_UNIX) {
+            new_priv->use_ssl = _gf_false;
+        } else {
+            switch (priv->srvr_ssl) {
+                case MGMT_SSL_ALWAYS:
+                    /* Glusterd with secure_mgmt. */
+                    new_priv->use_ssl = _gf_true;
+                    break;
+                case MGMT_SSL_COPY_IO:
+                    /* Glusterfsd. */
+                    new_priv->use_ssl = priv->ssl_enabled;
+                    break;
+                default:
+                    new_priv->use_ssl = _gf_false;
+            }
+        }
+
+        new_priv->sock = new_sock;
+
+        new_priv->ssl_enabled = priv->ssl_enabled;
+        new_priv->ssl_ctx = priv->ssl_ctx;
+        new_priv->connected = 1;
+        new_priv->is_server = _gf_true;
+
+        /* set O_NONBLOCK for plain text as well as ssl connections */
+        if (!priv->bio) {
+            gf_log(this->name, GF_LOG_TRACE, "### use non-blocking IO");
+            ret = __socket_nonblock(new_sock);
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "NBIO on %d failed (%s)",
-                                        new_sock, strerror (errno));
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_WARNING, "NBIO on %d failed (%s)",
+                       new_sock, strerror(errno));
 
-                                sys_close (new_sock);
-                                GF_FREE (new_trans->name);
-                                GF_FREE (new_trans);
-                                goto out;
-                        }
-                }
-                /*
-                 * This is the first ref on the newly accepted
-                 * transport.
-                 */
-                rpc_transport_ref (new_trans);
-
-                {
-                        /* Take a ref on the new_trans to avoid
-                         * getting deleted when event_register()
-                         * causes socket_event_handler() to race
-                         * ahead of this path to eventually find
-                         * a disconnect and unref the transport
-                         */
-                        rpc_transport_ref (new_trans);
-
-                        /* Send a notification to RPCSVC layer
-                         * to save the new_trans in its service
-                         * list before we register the new_sock
-                         * with epoll to begin receiving notifications
-                         * for data handling.
-                         */
-                        ret = rpc_transport_notify (this, RPC_TRANSPORT_ACCEPT, new_trans);
-
-                        if (ret != -1) {
-                                new_priv->idx =
-                                        event_register (ctx->event_pool,
-                                                        new_sock,
-                                                        socket_event_handler,
-                                                        new_trans,
-                                                        1, 0);
-                                if (new_priv->idx == -1) {
-                                        ret = -1;
-                                        gf_log(this->name, GF_LOG_ERROR,
-                                               "failed to register the socket "
-                                               "with event");
-
-                                        /* event_register() could have failed for some
-                                         * reason, implying that the new_sock cannot be
-                                         * added to the epoll set. If we won't get any
-                                         * more notifications for new_sock from epoll,
-                                         * then we better remove the corresponding
-                                         * new_trans object from the RPCSVC service list.
-                                         * Since we've notified RPC service of new_trans
-                                         * before we attempted event_register(), we better
-                                         * unlink the new_trans from the RPCSVC service list
-                                         * to cleanup the stateby sending out a DISCONNECT
-                                         * notification.
-                                         */
-                                        rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, new_trans);
-                                }
-                        }
+                sys_close(new_sock);
+                GF_FREE(new_trans->name);
+                GF_FREE(new_trans);
+                goto out;
+            }
+        }
+        /*
+         * This is the first ref on the newly accepted
+         * transport.
+         */
+        rpc_transport_ref(new_trans);
 
-                        /* this rpc_transport_unref() is for managing race between
-                         * 1. socket_server_event_handler and
-                         * 2. socket_event_handler
-                         * trying to add and remove new_trans from the rpcsvc
-                         * service list
-                         * now that we are done with the notifications, lets
-                         * reduce the reference
-                         */
-                        rpc_transport_unref (new_trans);
-                }
+        {
+            /* Take a ref on the new_trans to avoid
+             * getting deleted when event_register()
+             * causes socket_event_handler() to race
+             * ahead of this path to eventually find
+             * a disconnect and unref the transport
+             */
+            rpc_transport_ref(new_trans);
+
+            /* Send a notification to RPCSVC layer
+             * to save the new_trans in its service
+             * list before we register the new_sock
+             * with epoll to begin receiving notifications
+             * for data handling.
+             */
+            ret = rpc_transport_notify(this, RPC_TRANSPORT_ACCEPT, new_trans);
+
+            if (ret != -1) {
+                new_priv->idx = event_register(ctx->event_pool, new_sock,
+                                               socket_event_handler, new_trans,
+                                               1, 0);
+                if (new_priv->idx == -1) {
+                    ret = -1;
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "failed to register the socket "
+                           "with event");
+
+                    /* event_register() could have failed for some
+                     * reason, implying that the new_sock cannot be
+                     * added to the epoll set. If we won't get any
+                     * more notifications for new_sock from epoll,
+                     * then we better remove the corresponding
+                     * new_trans object from the RPCSVC service list.
+                     * Since we've notified RPC service of new_trans
+                     * before we attempted event_register(), we better
+                     * unlink the new_trans from the RPCSVC service list
+                     * to cleanup the stateby sending out a DISCONNECT
+                     * notification.
+                     */
+                    rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT,
+                                         new_trans);
+                }
+            }
+
+            /* this rpc_transport_unref() is for managing race between
+             * 1. socket_server_event_handler and
+             * 2. socket_event_handler
+             * trying to add and remove new_trans from the rpcsvc
+             * service list
+             * now that we are done with the notifications, lets
+             * reduce the reference
+             */
+            rpc_transport_unref(new_trans);
+        }
 
-                if (ret == -1) {
-                        sys_close (new_sock);
-                        /* this unref is to actually cause the destruction of
-                         * the new_trans since we've failed at everything so far
-                         */
-                        rpc_transport_unref (new_trans);
-                }
+        if (ret == -1) {
+            sys_close(new_sock);
+            /* this unref is to actually cause the destruction of
+             * the new_trans since we've failed at everything so far
+             */
+            rpc_transport_unref(new_trans);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_disconnect (rpc_transport_t *this, gf_boolean_t wait)
+socket_disconnect(rpc_transport_t *this, gf_boolean_t wait)
 {
-        socket_private_t *priv   = NULL;
-        int               ret    = -1;
+    socket_private_t *priv = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                ret = __socket_disconnect (this);
-        }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        ret = __socket_disconnect(this);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
-void*
-socket_connect_error_cbk (void *opaque)
+void *
+socket_connect_error_cbk(void *opaque)
 {
-        socket_connect_error_state_t *arg;
+    socket_connect_error_state_t *arg;
 
-        GF_ASSERT (opaque);
+    GF_ASSERT(opaque);
 
-        arg = opaque;
-        THIS = arg->this;
+    arg = opaque;
+    THIS = arg->this;
 
-        rpc_transport_notify (arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans);
+    rpc_transport_notify(arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans);
 
-        if (arg->refd)
-                rpc_transport_unref (arg->trans);
+    if (arg->refd)
+        rpc_transport_unref(arg->trans);
 
-        GF_FREE (opaque);
-        return NULL;
+    GF_FREE(opaque);
+    return NULL;
 }
 
 static void
-socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv,
-                     uint16_t port)
+socket_fix_ssl_opts(rpc_transport_t *this, socket_private_t *priv,
+                    uint16_t port)
 {
-        if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "%s SSL for portmapper connection",
-                        priv->mgmt_ssl ? "enabling" : "disabling");
-                priv->use_ssl = priv->mgmt_ssl;
-        } else if (priv->ssl_enabled && !priv->use_ssl) {
-                gf_log(this->name, GF_LOG_DEBUG,
-                       "re-enabling SSL for I/O connection");
-                priv->use_ssl = _gf_true;
-        }
+    if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s SSL for portmapper connection",
+               priv->mgmt_ssl ? "enabling" : "disabling");
+        priv->use_ssl = priv->mgmt_ssl;
+    } else if (priv->ssl_enabled && !priv->use_ssl) {
+        gf_log(this->name, GF_LOG_DEBUG, "re-enabling SSL for I/O connection");
+        priv->use_ssl = _gf_true;
+    }
 }
 
 /*
@@ -3343,1009 +3234,968 @@ socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv,
  * as well.
  */
 static int
-connect_loop (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+connect_loop(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
 {
-        int     ret;
-        int     connect_fails   = 0;
+    int ret;
+    int connect_fails = 0;
 
-        for (;;) {
-                ret = connect (sockfd, addr, addrlen);
-                if (ret >= 0) {
-                        break;
-                }
-                if ((errno != ENOENT) || (++connect_fails >= 5)) {
-                        break;
-                }
-                sleep (1);
+    for (;;) {
+        ret = connect(sockfd, addr, addrlen);
+        if (ret >= 0) {
+            break;
+        }
+        if ((errno != ENOENT) || (++connect_fails >= 5)) {
+            break;
         }
+        sleep(1);
+    }
 
-        return ret;
+    return ret;
 }
 
 static int
-socket_connect (rpc_transport_t *this, int port)
+socket_connect(rpc_transport_t *this, int port)
 {
-        int                            ret             = -1;
-        int                            th_ret          = -1;
-        int                            sock            = -1;
-        socket_private_t              *priv            = NULL;
-        socklen_t                      sockaddr_len    = 0;
-        glusterfs_ctx_t               *ctx             = NULL;
-        sa_family_t                    sa_family       = {0, };
-        char                          *local_addr      = NULL;
-        union gf_sock_union            sock_union;
-        struct sockaddr_in            *addr            = NULL;
-        gf_boolean_t                   refd      = _gf_false;
-        socket_connect_error_state_t  *arg             = NULL;
-        pthread_t                      th_id           = {0, };
-        gf_boolean_t                   ign_enoent      = _gf_false;
-        gf_boolean_t                   connect_attempted = _gf_false;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, err);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, err);
-
-        priv = this->private;
-        ctx = this->ctx;
-
-        if (!priv) {
-                gf_log_callingfn (this->name, GF_LOG_WARNING,
-                        "connect() called on uninitialized transport");
-                goto err;
+    int ret = -1;
+    int th_ret = -1;
+    int sock = -1;
+    socket_private_t *priv = NULL;
+    socklen_t sockaddr_len = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    sa_family_t sa_family = {
+        0,
+    };
+    char *local_addr = NULL;
+    union gf_sock_union sock_union;
+    struct sockaddr_in *addr = NULL;
+    gf_boolean_t refd = _gf_false;
+    socket_connect_error_state_t *arg = NULL;
+    pthread_t th_id = {
+        0,
+    };
+    gf_boolean_t ign_enoent = _gf_false;
+    gf_boolean_t connect_attempted = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("socket", this, err);
+    GF_VALIDATE_OR_GOTO("socket", this->private, err);
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    if (!priv) {
+        gf_log_callingfn(this->name, GF_LOG_WARNING,
+                         "connect() called on uninitialized transport");
+        goto err;
+    }
+
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->sock != -1) {
+            gf_log_callingfn(this->name, GF_LOG_TRACE,
+                             "connect () called on transport "
+                             "already connected");
+            errno = EINPROGRESS;
+            ret = -1;
+            goto unlock;
         }
 
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if (priv->sock != -1) {
-                        gf_log_callingfn (this->name, GF_LOG_TRACE,
-                                          "connect () called on transport "
-                                          "already connected");
-                        errno = EINPROGRESS;
-                        ret = -1;
-                        goto unlock;
-                }
-
-                gf_log (this->name, GF_LOG_TRACE,
-                        "connecting %p, sock=%d", this, priv->sock);
-
-                ret = socket_client_get_remote_sockaddr (this, &sock_union.sa,
-                                                     &sockaddr_len, &sa_family);
-                if (ret == -1) {
-                        /* logged inside client_get_remote_sockaddr */
-                        goto unlock;
-                }
-
-                if (sa_family == AF_UNIX) {
-                        priv->ssl_enabled = _gf_false;
-                        priv->mgmt_ssl = _gf_false;
-                } else {
-                        if (port > 0) {
-                                sock_union.sin.sin_port = htons (port);
-                        }
-                        socket_fix_ssl_opts (this, priv,
-                                             ntohs(sock_union.sin.sin_port));
-                }
+        gf_log(this->name, GF_LOG_TRACE, "connecting %p, sock=%d", this,
+               priv->sock);
 
-                memcpy (&this->peerinfo.sockaddr, &sock_union.storage,
-                        sockaddr_len);
-                this->peerinfo.sockaddr_len = sockaddr_len;
+        ret = socket_client_get_remote_sockaddr(this, &sock_union.sa,
+                                                &sockaddr_len, &sa_family);
+        if (ret == -1) {
+            /* logged inside client_get_remote_sockaddr */
+            goto unlock;
+        }
 
-                priv->sock = socket (sa_family, SOCK_STREAM, 0);
-                if (priv->sock == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "socket creation failed (%s)",
-                                strerror (errno));
-                        ret = -1;
-                        goto unlock;
-                }
+        if (sa_family == AF_UNIX) {
+            priv->ssl_enabled = _gf_false;
+            priv->mgmt_ssl = _gf_false;
+        } else {
+            if (port > 0) {
+                sock_union.sin.sin_port = htons(port);
+            }
+            socket_fix_ssl_opts(this, priv, ntohs(sock_union.sin.sin_port));
+        }
 
-                /* Can't help if setting socket options fails. We can continue
-                 * working nonetheless.
-                 */
-                if (priv->windowsize != 0) {
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting receive window "
-                                        "size failed: %d: %d: %s",
-                                        priv->sock, priv->windowsize,
-                                        strerror (errno));
-                        }
+        memcpy(&this->peerinfo.sockaddr, &sock_union.storage, sockaddr_len);
+        this->peerinfo.sockaddr_len = sockaddr_len;
 
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting send window size "
-                                        "failed: %d: %d: %s",
-                                        priv->sock, priv->windowsize,
-                                        strerror (errno));
-                        }
-                }
+        priv->sock = socket(sa_family, SOCK_STREAM, 0);
+        if (priv->sock == -1) {
+            gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)",
+                   strerror(errno));
+            ret = -1;
+            goto unlock;
+        }
 
-                /* Make sure we are not vulnerable to someone setting
-                 * net.ipv6.bindv6only to 1 so that gluster services are
-                 * available over IPv4 & IPv6.
-                 */
+        /* Can't help if setting socket options fails. We can continue
+         * working nonetheless.
+         */
+        if (priv->windowsize != 0) {
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) < 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting receive window "
+                       "size failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) < 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting send window size "
+                       "failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+        }
+
+        /* Make sure we are not vulnerable to someone setting
+         * net.ipv6.bindv6only to 1 so that gluster services are
+         * available over IPv4 & IPv6.
+         */
 #ifdef IPV6_DEFAULT
-                int     disable_v6only  = 0;
-                if (setsockopt (priv->sock, IPPROTO_IPV6, IPV6_V6ONLY,
-                                (void *)&disable_v6only,
-                                sizeof (disable_v6only)) < 0) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "Error disabling sockopt IPV6_V6ONLY: \"%s\"",
-                                strerror (errno));
-                }
+        int disable_v6only = 0;
+        if (setsockopt(priv->sock, IPPROTO_IPV6, IPV6_V6ONLY,
+                       (void *)&disable_v6only, sizeof(disable_v6only)) < 0) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Error disabling sockopt IPV6_V6ONLY: \"%s\"",
+                   strerror(errno));
+        }
 #endif
 
-                if (priv->nodelay && (sa_family != AF_UNIX)) {
-                        ret = __socket_nodelay (priv->sock);
+        if (priv->nodelay && (sa_family != AF_UNIX)) {
+            ret = __socket_nodelay(priv->sock);
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NODELAY on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                        }
-                }
-
-                if (priv->keepalive && sa_family != AF_UNIX) {
-                        ret = __socket_keepalive (priv->sock,
-                                                  sa_family,
-                                                  priv->keepaliveintvl,
-                                                  priv->keepaliveidle,
-                                                  priv->keepalivecnt,
-                                                  priv->timeout);
-                        if (ret == -1)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Failed to set keep-alive: %s",
-                                        strerror (errno));
-                }
-
-                SA (&this->myinfo.sockaddr)->sa_family =
-                        SA (&this->peerinfo.sockaddr)->sa_family;
-
-                /* If a source addr is explicitly specified, use it */
-                ret = dict_get_str (this->options,
-                                    "transport.socket.source-addr",
-                                    &local_addr);
-                if (!ret && SA (&this->myinfo.sockaddr)->sa_family == AF_INET) {
-                        addr = (struct sockaddr_in *)(&this->myinfo.sockaddr);
-                        ret = inet_pton (AF_INET, local_addr,
-                                         &(addr->sin_addr.s_addr));
-                }
-
-                /* If client wants ENOENT to be ignored */
-                ign_enoent = dict_get_str_boolean (this->options,
-                                                   "transport.socket.ignore-enoent",
-                                                   _gf_false);
-
-                ret = client_bind (this, SA (&this->myinfo.sockaddr),
-                                   &this->myinfo.sockaddr_len, priv->sock);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "client bind failed: %s", strerror (errno));
-                        goto handler;
-                }
-
-                /* make socket non-blocking for all types of sockets */
-                if (!priv->bio) {
-                        ret = __socket_nonblock (priv->sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NBIO on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                                goto handler;
-                        } else {
-                                gf_log (this->name, GF_LOG_TRACE,
-                                        ">>> connect() with non-blocking IO for ALL");
-                        }
-                }
-                this->connect_failed = _gf_false;
-                priv->connect_failed = 0;
-                priv->connected = 0;
-
-                socket_dump_info (SA(&this->peerinfo.sockaddr), priv->is_server,
-                                  priv->use_ssl, priv->sock, this->name,
-                                  "connecting to");
-
-                if (ign_enoent) {
-                        ret = connect_loop (priv->sock,
-                                            SA (&this->peerinfo.sockaddr),
-                                            this->peerinfo.sockaddr_len);
-                } else {
-                        ret = connect (priv->sock,
-                                       SA (&this->peerinfo.sockaddr),
-                                       this->peerinfo.sockaddr_len);
-                }
-
-                connect_attempted = _gf_true;
-
-                if (ret == -1 && errno == ENOENT && ign_enoent) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                               "Ignore failed connection attempt on %s, (%s) ",
-                                this->peerinfo.identifier, strerror (errno));
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR, "NODELAY on %d failed (%s)",
+                       priv->sock, strerror(errno));
+            }
+        }
 
-                        /* connect failed with some other error than EINPROGRESS
-                        so, getsockopt (... SO_ERROR ...), will not catch any
-                        errors and return them to us, we need to remember this
-                        state, and take actions in socket_event_handler
-                        appropriately */
-                        /* TBD: What about ENOENT, we will do getsockopt there
-                        as well, so how is that exempt from such a problem? */
-                        priv->connect_failed = 1;
-                        this->connect_failed = _gf_true;
+        if (priv->keepalive && sa_family != AF_UNIX) {
+            ret = __socket_keepalive(priv->sock, sa_family,
+                                     priv->keepaliveintvl, priv->keepaliveidle,
+                                     priv->keepalivecnt, priv->timeout);
+            if (ret == -1)
+                gf_log(this->name, GF_LOG_ERROR, "Failed to set keep-alive: %s",
+                       strerror(errno));
+        }
 
-                        goto handler;
-                }
+        SA(&this->myinfo.sockaddr)->sa_family = SA(&this->peerinfo.sockaddr)
+                                                    ->sa_family;
 
-                if (ret == -1 && ((errno != EINPROGRESS) && (errno != ENOENT))) {
-                        /* For unix path based sockets, the socket path is
-                         * cryptic (md5sum of path) and may not be useful for
-                         * the user in debugging so log it in DEBUG
-                         */
-                        gf_log (this->name, ((sa_family == AF_UNIX) ?
-                                GF_LOG_DEBUG : GF_LOG_ERROR),
-                                "connection attempt on %s failed, (%s)",
-                                this->peerinfo.identifier, strerror (errno));
-
-                        /* connect failed with some other error than EINPROGRESS
-                        so, getsockopt (... SO_ERROR ...), will not catch any
-                        errors and return them to us, we need to remember this
-                        state, and take actions in socket_event_handler
-                        appropriately */
-                        /* TBD: What about ENOENT, we will do getsockopt there
-                        as well, so how is that exempt from such a problem? */
-                        priv->connect_failed = 1;
-
-                        goto handler;
-                } else {
-                        /* reset connect_failed so that any previous attempts
-                        state is not carried forward */
-                        priv->connect_failed = 0;
-                        ret = 0;
-                }
+        /* If a source addr is explicitly specified, use it */
+        ret = dict_get_str(this->options, "transport.socket.source-addr",
+                           &local_addr);
+        if (!ret && SA(&this->myinfo.sockaddr)->sa_family == AF_INET) {
+            addr = (struct sockaddr_in *)(&this->myinfo.sockaddr);
+            ret = inet_pton(AF_INET, local_addr, &(addr->sin_addr.s_addr));
+        }
 
-handler:
-                if (ret < 0 && !connect_attempted) {
-                        /* Ignore error from connect. epoll events
-                           should be handled in the socket handler.  shutdown(2)
-                           will result in EPOLLERR, so cleanup is done in
-                           socket_event_handler or socket_poller */
-                        shutdown (priv->sock, SHUT_RDWR);
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "@@@ client shutdown(%d, SHUT_RDWR)",
-                                priv->sock);
-                }
+        /* If client wants ENOENT to be ignored */
+        ign_enoent = dict_get_str_boolean(
+            this->options, "transport.socket.ignore-enoent", _gf_false);
 
-                priv->connected = 0;
-                priv->is_server = _gf_false;
-                rpc_transport_ref (this);
-                refd = _gf_true;
-
-                this->listener = this;
-                priv->idx = event_register (ctx->event_pool, priv->sock,
-                                            socket_event_handler,
-                                            this, 1, 1);
-                if (priv->idx == -1) {
-                        gf_log ("", GF_LOG_WARNING,
-                                "failed to register the event");
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        ret = -1;
-                }
-
-unlock:
-                sock = priv->sock;
+        ret = client_bind(this, SA(&this->myinfo.sockaddr),
+                          &this->myinfo.sockaddr_len, priv->sock);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_WARNING, "client bind failed: %s",
+                   strerror(errno));
+            goto handler;
         }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
 
-err:
-        /* if sock != -1, then cleanup is done from the event handler */
-        if (ret == -1 && sock == -1) {
-                /* Cleaup requires to send notification to upper layer which
-                   intern holds the big_lock. There can be dead-lock situation
-                   if big_lock is already held by the current thread.
-                   So transfer the ownership to separate thread for cleanup.
-                */
-                arg = GF_CALLOC (1, sizeof (*arg),
-                                 gf_sock_connect_error_state_t);
-                arg->this = THIS;
-                arg->trans = this;
-                arg->refd = refd;
-                th_ret = gf_thread_create_detached (&th_id,
-                                                    socket_connect_error_cbk,
-                                                    arg, "scleanup");
-                if (th_ret) {
-                        /* Error will be logged by gf_thread_create_attached */
-                        gf_log (this->name, GF_LOG_ERROR, "Thread creation "
-                               "failed");
-                        GF_FREE (arg);
-                        GF_ASSERT (0);
-                }
-        }
+        /* make socket non-blocking for all types of sockets */
+        if (!priv->bio) {
+            ret = __socket_nonblock(priv->sock);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR, "NBIO on %d failed (%s)",
+                       priv->sock, strerror(errno));
+                goto handler;
+            } else {
+                gf_log(this->name, GF_LOG_TRACE,
+                       ">>> connect() with non-blocking IO for ALL");
+            }
+        }
+        this->connect_failed = _gf_false;
+        priv->connect_failed = 0;
+        priv->connected = 0;
+
+        socket_dump_info(SA(&this->peerinfo.sockaddr), priv->is_server,
+                         priv->use_ssl, priv->sock, this->name,
+                         "connecting to");
+
+        if (ign_enoent) {
+            ret = connect_loop(priv->sock, SA(&this->peerinfo.sockaddr),
+                               this->peerinfo.sockaddr_len);
+        } else {
+            ret = connect(priv->sock, SA(&this->peerinfo.sockaddr),
+                          this->peerinfo.sockaddr_len);
+        }
+
+        connect_attempted = _gf_true;
+
+        if (ret == -1 && errno == ENOENT && ign_enoent) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Ignore failed connection attempt on %s, (%s) ",
+                   this->peerinfo.identifier, strerror(errno));
+
+            /* connect failed with some other error than EINPROGRESS
+            so, getsockopt (... SO_ERROR ...), will not catch any
+            errors and return them to us, we need to remember this
+            state, and take actions in socket_event_handler
+            appropriately */
+            /* TBD: What about ENOENT, we will do getsockopt there
+            as well, so how is that exempt from such a problem? */
+            priv->connect_failed = 1;
+            this->connect_failed = _gf_true;
+
+            goto handler;
+        }
+
+        if (ret == -1 && ((errno != EINPROGRESS) && (errno != ENOENT))) {
+            /* For unix path based sockets, the socket path is
+             * cryptic (md5sum of path) and may not be useful for
+             * the user in debugging so log it in DEBUG
+             */
+            gf_log(this->name,
+                   ((sa_family == AF_UNIX) ? GF_LOG_DEBUG : GF_LOG_ERROR),
+                   "connection attempt on %s failed, (%s)",
+                   this->peerinfo.identifier, strerror(errno));
+
+            /* connect failed with some other error than EINPROGRESS
+            so, getsockopt (... SO_ERROR ...), will not catch any
+            errors and return them to us, we need to remember this
+            state, and take actions in socket_event_handler
+            appropriately */
+            /* TBD: What about ENOENT, we will do getsockopt there
+            as well, so how is that exempt from such a problem? */
+            priv->connect_failed = 1;
+
+            goto handler;
+        } else {
+            /* reset connect_failed so that any previous attempts
+            state is not carried forward */
+            priv->connect_failed = 0;
+            ret = 0;
+        }
+
+    handler:
+        if (ret < 0 && !connect_attempted) {
+            /* Ignore error from connect. epoll events
+               should be handled in the socket handler.  shutdown(2)
+               will result in EPOLLERR, so cleanup is done in
+               socket_event_handler or socket_poller */
+            shutdown(priv->sock, SHUT_RDWR);
+            gf_log(this->name, GF_LOG_TRACE,
+                   "@@@ client shutdown(%d, SHUT_RDWR)", priv->sock);
+        }
+
+        priv->connected = 0;
+        priv->is_server = _gf_false;
+        rpc_transport_ref(this);
+        refd = _gf_true;
+
+        this->listener = this;
+        priv->idx = event_register(ctx->event_pool, priv->sock,
+                                   socket_event_handler, this, 1, 1);
+        if (priv->idx == -1) {
+            gf_log("", GF_LOG_WARNING, "failed to register the event");
+            sys_close(priv->sock);
+            priv->sock = -1;
+            ret = -1;
+        }
+
+    unlock:
+        sock = priv->sock;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
-        return ret;
+err:
+    /* if sock != -1, then cleanup is done from the event handler */
+    if (ret == -1 && sock == -1) {
+        /* Cleaup requires to send notification to upper layer which
+           intern holds the big_lock. There can be dead-lock situation
+           if big_lock is already held by the current thread.
+           So transfer the ownership to separate thread for cleanup.
+        */
+        arg = GF_CALLOC(1, sizeof(*arg), gf_sock_connect_error_state_t);
+        arg->this = THIS;
+        arg->trans = this;
+        arg->refd = refd;
+        th_ret = gf_thread_create_detached(&th_id, socket_connect_error_cbk,
+                                           arg, "scleanup");
+        if (th_ret) {
+            /* Error will be logged by gf_thread_create_attached */
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Thread creation "
+                   "failed");
+            GF_FREE(arg);
+            GF_ASSERT(0);
+        }
+    }
+
+    return ret;
 }
 
-
 static int
-socket_listen (rpc_transport_t *this)
+socket_listen(rpc_transport_t *this)
 {
-        socket_private_t *       priv = NULL;
-        int                      ret = -1;
-        int                      sock = -1;
-        struct sockaddr_storage  sockaddr;
-        socklen_t                sockaddr_len = 0;
-        peer_info_t             *myinfo = NULL;
-        glusterfs_ctx_t         *ctx = NULL;
-        sa_family_t              sa_family = {0, };
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv   = this->private;
-        myinfo = &this->myinfo;
-        ctx    = this->ctx;
-
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                sock = priv->sock;
-        }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
-
-        if (sock != -1)  {
-                gf_log_callingfn (this->name, GF_LOG_DEBUG,
-                                  "already listening");
-                return ret;
-        }
-
-        ret = socket_server_get_local_sockaddr (this, SA (&sockaddr),
-                                                &sockaddr_len, &sa_family);
-        if (ret == -1) {
-                return ret;
-        }
+    socket_private_t *priv = NULL;
+    int ret = -1;
+    int sock = -1;
+    struct sockaddr_storage sockaddr;
+    socklen_t sockaddr_len = 0;
+    peer_info_t *myinfo = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    sa_family_t sa_family = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    myinfo = &this->myinfo;
+    ctx = this->ctx;
+
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        sock = priv->sock;
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if (priv->sock != -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "already listening");
-                        goto unlock;
-                }
+    if (sock != -1) {
+        gf_log_callingfn(this->name, GF_LOG_DEBUG, "already listening");
+        return ret;
+    }
 
-                memcpy (&myinfo->sockaddr, &sockaddr, sockaddr_len);
-                myinfo->sockaddr_len = sockaddr_len;
+    ret = socket_server_get_local_sockaddr(this, SA(&sockaddr), &sockaddr_len,
+                                           &sa_family);
+    if (ret == -1) {
+        return ret;
+    }
 
-                priv->sock = socket (sa_family, SOCK_STREAM, 0);
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->sock != -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "already listening");
+            goto unlock;
+        }
 
-                if (priv->sock == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "socket creation failed (%s)",
-                                strerror (errno));
-                        goto unlock;
-                }
+        memcpy(&myinfo->sockaddr, &sockaddr, sockaddr_len);
+        myinfo->sockaddr_len = sockaddr_len;
 
-                /* Can't help if setting socket options fails. We can continue
-                 * working nonetheless.
-                 */
-                if (priv->windowsize != 0) {
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting receive window size "
-                                        "failed: %d: %d: %s", priv->sock,
-                                        priv->windowsize,
-                                        strerror (errno));
-                        }
+        priv->sock = socket(sa_family, SOCK_STREAM, 0);
 
-                        if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF,
-                                        &priv->windowsize,
-                                        sizeof (priv->windowsize)) < 0) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setting send window size failed:"
-                                        " %d: %d: %s", priv->sock,
-                                        priv->windowsize,
-                                        strerror (errno));
-                        }
-                }
+        if (priv->sock == -1) {
+            gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)",
+                   strerror(errno));
+            goto unlock;
+        }
 
-                if (priv->nodelay && (sa_family != AF_UNIX)) {
-                        ret = __socket_nodelay (priv->sock);
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "setsockopt() failed for NODELAY (%s)",
-                                        strerror (errno));
-                        }
-                }
+        /* Can't help if setting socket options fails. We can continue
+         * working nonetheless.
+         */
+        if (priv->windowsize != 0) {
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) < 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting receive window size "
+                       "failed: %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+
+            if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize,
+                           sizeof(priv->windowsize)) < 0) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setting send window size failed:"
+                       " %d: %d: %s",
+                       priv->sock, priv->windowsize, strerror(errno));
+            }
+        }
+
+        if (priv->nodelay && (sa_family != AF_UNIX)) {
+            ret = __socket_nodelay(priv->sock);
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "setsockopt() failed for NODELAY (%s)", strerror(errno));
+            }
+        }
 
-                if (!priv->bio) {
-                        ret = __socket_nonblock (priv->sock);
+        if (!priv->bio) {
+            ret = __socket_nonblock(priv->sock);
 
-                        if (ret == -1) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "NBIO on %d failed (%s)",
-                                        priv->sock, strerror (errno));
-                                sys_close (priv->sock);
-                                priv->sock = -1;
-                                goto unlock;
-                        }
-                }
+            if (ret == -1) {
+                gf_log(this->name, GF_LOG_ERROR, "NBIO on %d failed (%s)",
+                       priv->sock, strerror(errno));
+                sys_close(priv->sock);
+                priv->sock = -1;
+                goto unlock;
+            }
+        }
 
-                ret = __socket_server_bind (this);
+        ret = __socket_server_bind(this);
 
-                if ((ret == -EADDRINUSE) || (ret == -1)) {
-                        /* logged inside __socket_server_bind() */
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        if ((ret == -EADDRINUSE) || (ret == -1)) {
+            /* logged inside __socket_server_bind() */
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
+        }
 
-                socket_dump_info (SA(&this->myinfo.sockaddr), priv->is_server,
-                                  priv->use_ssl, priv->sock, this->name,
-                                  "listening on");
+        socket_dump_info(SA(&this->myinfo.sockaddr), priv->is_server,
+                         priv->use_ssl, priv->sock, this->name, "listening on");
 
-                ret = listen (priv->sock, priv->backlog);
+        ret = listen(priv->sock, priv->backlog);
 
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "could not set socket %d to listen mode (%s)",
-                                priv->sock, strerror (errno));
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "could not set socket %d to listen mode (%s)", priv->sock,
+                   strerror(errno));
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
+        }
 
-                rpc_transport_ref (this);
+        rpc_transport_ref(this);
 
-                priv->idx = event_register (ctx->event_pool, priv->sock,
-                                            socket_server_event_handler,
-                                            this, 1, 0);
+        priv->idx = event_register(ctx->event_pool, priv->sock,
+                                   socket_server_event_handler, this, 1, 0);
 
-                if (priv->idx == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "could not register socket %d with events",
-                                priv->sock);
-                        ret = -1;
-                        sys_close (priv->sock);
-                        priv->sock = -1;
-                        goto unlock;
-                }
+        if (priv->idx == -1) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "could not register socket %d with events", priv->sock);
+            ret = -1;
+            sys_close(priv->sock);
+            priv->sock = -1;
+            goto unlock;
         }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-socket_submit_outgoing_msg (rpc_transport_t *this, rpc_transport_msg_t *msg)
+socket_submit_outgoing_msg(rpc_transport_t *this, rpc_transport_msg_t *msg)
 {
-        int               ret           = -1;
-        char              need_poll_out = 0;
-        char              need_append   = 1;
-        struct ioq       *entry         = NULL;
-        glusterfs_ctx_t  *ctx           = NULL;
-        socket_private_t *priv          = NULL;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        priv = this->private;
-        ctx  = this->ctx;
-
-        pthread_mutex_lock (&priv->out_lock);
-        {
-                if (priv->connected != 1) {
-                        if (!priv->submit_log && !priv->connect_finish_log) {
-                                gf_log (this->name, GF_LOG_INFO,
-                                        "not connected (priv->connected = %d)",
-                                        priv->connected);
-                                priv->submit_log = 1;
-                        }
-                        goto unlock;
-                }
-
-                priv->submit_log = 0;
-                entry = __socket_ioq_new (this, msg);
-                if (!entry)
-                        goto unlock;
+    int ret = -1;
+    char need_poll_out = 0;
+    char need_append = 1;
+    struct ioq *entry = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    socket_private_t *priv = NULL;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    priv = this->private;
+    ctx = this->ctx;
+
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        if (priv->connected != 1) {
+            if (!priv->submit_log && !priv->connect_finish_log) {
+                gf_log(this->name, GF_LOG_INFO,
+                       "not connected (priv->connected = %d)", priv->connected);
+                priv->submit_log = 1;
+            }
+            goto unlock;
+        }
+
+        priv->submit_log = 0;
+        entry = __socket_ioq_new(this, msg);
+        if (!entry)
+            goto unlock;
 
-                if (list_empty (&priv->ioq)) {
-                        ret = __socket_ioq_churn_entry (this, entry, 1);
+        if (list_empty(&priv->ioq)) {
+            ret = __socket_ioq_churn_entry(this, entry, 1);
 
-                        if (ret == 0) {
-                                need_append = 0;
-                        }
-                        if (ret > 0) {
-                                need_poll_out = 1;
-                        }
-                }
+            if (ret == 0) {
+                need_append = 0;
+            }
+            if (ret > 0) {
+                need_poll_out = 1;
+            }
+        }
 
-                if (need_append) {
-                        list_add_tail (&entry->list, &priv->ioq);
-                        ret = 0;
-                }
-                if (need_poll_out) {
-                        /* first entry to wait. continue writing on POLLOUT */
-                        priv->idx = event_select_on (ctx->event_pool,
-                                                     priv->sock,
-                                                     priv->idx, -1, 1);
-                }
+        if (need_append) {
+            list_add_tail(&entry->list, &priv->ioq);
+            ret = 0;
         }
+        if (need_poll_out) {
+            /* first entry to wait. continue writing on POLLOUT */
+            priv->idx = event_select_on(ctx->event_pool, priv->sock, priv->idx,
+                                        -1, 1);
+        }
+    }
 unlock:
-        pthread_mutex_unlock (&priv->out_lock);
+    pthread_mutex_unlock(&priv->out_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-socket_submit_request (rpc_transport_t *this, rpc_transport_req_t *req)
+socket_submit_request(rpc_transport_t *this, rpc_transport_req_t *req)
 {
-        return socket_submit_outgoing_msg (this, &req->msg);
+    return socket_submit_outgoing_msg(this, &req->msg);
 }
 
 static int32_t
-socket_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply)
+socket_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply)
 {
-        return socket_submit_outgoing_msg (this, &reply->msg);
+    return socket_submit_outgoing_msg(this, &reply->msg);
 }
 
 static int32_t
-socket_getpeername (rpc_transport_t *this, char *hostname, int hostlen)
+socket_getpeername(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", hostname, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", hostname, out);
 
-        if (hostlen < (strlen (this->peerinfo.identifier) + 1)) {
-                goto out;
-        }
+    if (hostlen < (strlen(this->peerinfo.identifier) + 1)) {
+        goto out;
+    }
 
-        strcpy (hostname, this->peerinfo.identifier);
-        ret = 0;
+    strcpy(hostname, this->peerinfo.identifier);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getpeeraddr (rpc_transport_t *this, char *peeraddr, int addrlen,
-                    struct sockaddr_storage *sa, socklen_t salen)
+socket_getpeeraddr(rpc_transport_t *this, char *peeraddr, int addrlen,
+                   struct sockaddr_storage *sa, socklen_t salen)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", sa, out);
-        ret = 0;
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", sa, out);
+    ret = 0;
 
-        *sa = this->peerinfo.sockaddr;
+    *sa = this->peerinfo.sockaddr;
 
-        if (peeraddr != NULL) {
-                ret = socket_getpeername (this, peeraddr, addrlen);
-        }
+    if (peeraddr != NULL) {
+        ret = socket_getpeername(this, peeraddr, addrlen);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getmyname (rpc_transport_t *this, char *hostname, int hostlen)
+socket_getmyname(rpc_transport_t *this, char *hostname, int hostlen)
 {
-        int32_t ret = -1;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", hostname, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", hostname, out);
 
-        if (hostlen < (strlen (this->myinfo.identifier) + 1)) {
-                goto out;
-        }
+    if (hostlen < (strlen(this->myinfo.identifier) + 1)) {
+        goto out;
+    }
 
-        strcpy (hostname, this->myinfo.identifier);
-        ret = 0;
+    strcpy(hostname, this->myinfo.identifier);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 static int32_t
-socket_getmyaddr (rpc_transport_t *this, char *myaddr, int addrlen,
-                  struct sockaddr_storage *sa, socklen_t salen)
+socket_getmyaddr(rpc_transport_t *this, char *myaddr, int addrlen,
+                 struct sockaddr_storage *sa, socklen_t salen)
 {
-        int32_t ret = 0;
+    int32_t ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", sa, out);
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", sa, out);
 
-        *sa =  this->myinfo.sockaddr;
+    *sa = this->myinfo.sockaddr;
 
-        if (myaddr != NULL) {
-                ret = socket_getmyname (this, myaddr, addrlen);
-        }
+    if (myaddr != NULL) {
+        ret = socket_getmyname(this, myaddr, addrlen);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-socket_throttle (rpc_transport_t *this, gf_boolean_t onoff)
+socket_throttle(rpc_transport_t *this, gf_boolean_t onoff)
 {
-        socket_private_t *priv = NULL;
-
-        priv = this->private;
-
-        /* The way we implement throttling is by taking off
-           POLLIN event from the polled flags. This way we
-           never get called with the POLLIN event and therefore
-           will never read() any more data until throttling
-           is turned off.
-        */
-        pthread_mutex_lock (&priv->in_lock);
-        pthread_mutex_lock (&priv->out_lock);
-        {
-
-                /* Throttling is useless on a disconnected transport. In fact,
-                 * it's dangerous since priv->idx and priv->sock are set to -1
-                 * on a disconnected transport, which breaks epoll's event to
-                 * registered fd mapping. */
-
-                if (priv->connected == 1)
-                        priv->idx = event_select_on (this->ctx->event_pool,
-                                                     priv->sock,
-                                                     priv->idx, (int) !onoff,
-                                                     -1);
-        }
-        pthread_mutex_unlock (&priv->out_lock);
-        pthread_mutex_unlock (&priv->in_lock);
-        return 0;
+    socket_private_t *priv = NULL;
+
+    priv = this->private;
+
+    /* The way we implement throttling is by taking off
+       POLLIN event from the polled flags. This way we
+       never get called with the POLLIN event and therefore
+       will never read() any more data until throttling
+       is turned off.
+    */
+    pthread_mutex_lock(&priv->in_lock);
+    pthread_mutex_lock(&priv->out_lock);
+    {
+        /* Throttling is useless on a disconnected transport. In fact,
+         * it's dangerous since priv->idx and priv->sock are set to -1
+         * on a disconnected transport, which breaks epoll's event to
+         * registered fd mapping. */
+
+        if (priv->connected == 1)
+            priv->idx = event_select_on(this->ctx->event_pool, priv->sock,
+                                        priv->idx, (int)!onoff, -1);
+    }
+    pthread_mutex_unlock(&priv->out_lock);
+    pthread_mutex_unlock(&priv->in_lock);
+    return 0;
 }
 
-
 struct rpc_transport_ops tops = {
-        .listen             = socket_listen,
-        .connect            = socket_connect,
-        .disconnect         = socket_disconnect,
-        .submit_request     = socket_submit_request,
-        .submit_reply       = socket_submit_reply,
-        .get_peername       = socket_getpeername,
-        .get_peeraddr       = socket_getpeeraddr,
-        .get_myname         = socket_getmyname,
-        .get_myaddr         = socket_getmyaddr,
-        .throttle           = socket_throttle,
+    .listen = socket_listen,
+    .connect = socket_connect,
+    .disconnect = socket_disconnect,
+    .submit_request = socket_submit_request,
+    .submit_reply = socket_submit_reply,
+    .get_peername = socket_getpeername,
+    .get_peeraddr = socket_getpeeraddr,
+    .get_myname = socket_getmyname,
+    .get_myaddr = socket_getmyaddr,
+    .throttle = socket_throttle,
 };
 
 int
-reconfigure (rpc_transport_t *this, dict_t *options)
+reconfigure(rpc_transport_t *this, dict_t *options)
 {
-        socket_private_t *priv          = NULL;
-        gf_boolean_t      tmp_bool      = _gf_false;
-        char             *optstr        = NULL;
-        int               ret           = 0;
-        uint32_t          backlog       = 0;
-        uint64_t          windowsize    = 0;
-        uint32_t          timeout       = 0;
-        int               keepaliveidle  = GF_KEEPALIVE_TIME;
-        int               keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        int               keepalivecnt   = GF_KEEPALIVE_COUNT;
-
-        GF_VALIDATE_OR_GOTO ("socket", this, out);
-        GF_VALIDATE_OR_GOTO ("socket", this->private, out);
-
-        if (!this || !this->private) {
-                ret =-1;
-                goto out;
-        }
-
-        priv = this->private;
-
-        if (dict_get_str (options, "transport.socket.keepalive",
-                          &optstr) == 0) {
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.keepalive' takes only "
-                                "boolean options, not taking any action");
-                        priv->keepalive = 1;
-                        ret = -1;
-                        goto out;
-                }
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigured transport.socket.keepalive");
-
-                priv->keepalive = tmp_bool;
-        } else
-                priv->keepalive = 1;
-
-        if (dict_get_int32 (options, "transport.tcp-user-timeout",
-                            &(priv->timeout)) != 0)
-                priv->timeout = timeout;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.tcp-user-timeout=%d", priv->timeout);
-
-        if (dict_get_uint32 (options, "transport.listen-backlog",
-                             &backlog) == 0) {
-                priv->backlog = backlog;
-                gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                        "transport.listen-backlog=%d", priv->backlog);
-        }
-
-        if (dict_get_int32 (options, "transport.socket.keepalive-time",
-                            &(priv->keepaliveidle)) != 0)
-                priv->keepaliveidle = keepaliveidle;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-time=%d", priv->keepaliveidle);
-
-        if (dict_get_int32 (options,
-                            "transport.socket.keepalive-interval",
-                            &(priv->keepaliveintvl)) != 0)
-                priv->keepaliveintvl = keepaliveintvl;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-interval=%d", priv->keepaliveintvl);
-
-        if (dict_get_int32 (options, "transport.socket.keepalive-count",
-                            &(priv->keepalivecnt)) != 0)
-                priv->keepalivecnt = keepalivecnt;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.socket.keepalive-count=%d", priv->keepalivecnt);
-
-        optstr = NULL;
-        if (dict_get_str (options, "tcp-window-size",
-                          &optstr) == 0) {
-                if (gf_string2uint64 (optstr, &windowsize) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid number format: %s", optstr);
-                        goto out;
-                }
-        }
-
-        priv->windowsize = (int)windowsize;
-
-        if (dict_get (options, "non-blocking-io")) {
-                optstr = data_to_str (dict_get (options,
-                                                "non-blocking-io"));
+    socket_private_t *priv = NULL;
+    gf_boolean_t tmp_bool = _gf_false;
+    char *optstr = NULL;
+    int ret = 0;
+    uint32_t backlog = 0;
+    uint64_t windowsize = 0;
+    uint32_t timeout = 0;
+    int keepaliveidle = GF_KEEPALIVE_TIME;
+    int keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+    int keepalivecnt = GF_KEEPALIVE_COUNT;
+
+    GF_VALIDATE_OR_GOTO("socket", this, out);
+    GF_VALIDATE_OR_GOTO("socket", this->private, out);
+
+    if (!this || !this->private) {
+        ret = -1;
+        goto out;
+    }
+
+    priv = this->private;
+
+    if (dict_get_str(options, "transport.socket.keepalive", &optstr) == 0) {
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.keepalive' takes only "
+                   "boolean options, not taking any action");
+            priv->keepalive = 1;
+            ret = -1;
+            goto out;
+        }
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigured transport.socket.keepalive");
+
+        priv->keepalive = tmp_bool;
+    } else
+        priv->keepalive = 1;
 
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'non-blocking-io' takes only boolean options,"
-                                " not taking any action");
-                        tmp_bool = 1;
-                }
+    if (dict_get_int32(options, "transport.tcp-user-timeout",
+                       &(priv->timeout)) != 0)
+        priv->timeout = timeout;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigued "
+           "transport.tcp-user-timeout=%d",
+           priv->timeout);
 
-                if (!tmp_bool) {
-                        priv->bio = 1;
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "disabling non-blocking IO");
-                }
-        }
-
-        if (!priv->bio) {
-                ret = __socket_nonblock (priv->sock);
-                if (ret == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "NBIO on %d failed (%s)",
-                                priv->sock, strerror (errno));
-                        goto out;
-                }
+    if (dict_get_uint32(options, "transport.listen-backlog", &backlog) == 0) {
+        priv->backlog = backlog;
+        gf_log(this->name, GF_LOG_DEBUG,
+               "Reconfigued "
+               "transport.listen-backlog=%d",
+               priv->backlog);
+    }
+
+    if (dict_get_int32(options, "transport.socket.keepalive-time",
+                       &(priv->keepaliveidle)) != 0)
+        priv->keepaliveidle = keepaliveidle;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigued "
+           "transport.socket.keepalive-time=%d",
+           priv->keepaliveidle);
+
+    if (dict_get_int32(options, "transport.socket.keepalive-interval",
+                       &(priv->keepaliveintvl)) != 0)
+        priv->keepaliveintvl = keepaliveintvl;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigued "
+           "transport.socket.keepalive-interval=%d",
+           priv->keepaliveintvl);
+
+    if (dict_get_int32(options, "transport.socket.keepalive-count",
+                       &(priv->keepalivecnt)) != 0)
+        priv->keepalivecnt = keepalivecnt;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigued "
+           "transport.socket.keepalive-count=%d",
+           priv->keepalivecnt);
+
+    optstr = NULL;
+    if (dict_get_str(options, "tcp-window-size", &optstr) == 0) {
+        if (gf_string2uint64(optstr, &windowsize) != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s",
+                   optstr);
+            goto out;
+        }
+    }
+
+    priv->windowsize = (int)windowsize;
+
+    if (dict_get(options, "non-blocking-io")) {
+        optstr = data_to_str(dict_get(options, "non-blocking-io"));
+
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'non-blocking-io' takes only boolean options,"
+                   " not taking any action");
+            tmp_bool = 1;
+        }
+
+        if (!tmp_bool) {
+            priv->bio = 1;
+            gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO");
+        }
+    }
+
+    if (!priv->bio) {
+        ret = __socket_nonblock(priv->sock);
+        if (ret == -1) {
+            gf_log(this->name, GF_LOG_WARNING, "NBIO on %d failed (%s)",
+                   priv->sock, strerror(errno));
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
-
+    return ret;
 }
 
 #if OPENSSL_VERSION_NUMBER < 0x1010000f
-static pthread_mutex_t  *lock_array     = NULL;
+static pthread_mutex_t *lock_array = NULL;
 
 static void
-locking_func (int mode, int type, const char *file, int line)
+locking_func(int mode, int type, const char *file, int line)
 {
-        if (mode & CRYPTO_UNLOCK) {
-                pthread_mutex_unlock (&lock_array[type]);
-        } else {
-                pthread_mutex_lock (&lock_array[type]);
-        }
+    if (mode & CRYPTO_UNLOCK) {
+        pthread_mutex_unlock(&lock_array[type]);
+    } else {
+        pthread_mutex_lock(&lock_array[type]);
+    }
 }
 
 #if OPENSSL_VERSION_NUMBER >= 0x1000000f
 static void
-threadid_func (CRYPTO_THREADID *id)
+threadid_func(CRYPTO_THREADID *id)
 {
-        /*
-         * We're not supposed to know whether a pthread_t is a number or a
-         * pointer, but we definitely need an unsigned long.  Even though it
-         * happens to be an unsigned long already on Linux, do the cast just in
-         * case that's not so on another platform.  Note that this can still
-         * break if any platforms are left where a pointer is larger than an
-         * unsigned long.  In that case there's not much we can do; hopefully
-         * anyone porting to such a platform will be aware enough to notice the
-         * compile warnings about truncating the pointer value.
-         */
-        CRYPTO_THREADID_set_numeric (id, (unsigned long)pthread_self());
+    /*
+     * We're not supposed to know whether a pthread_t is a number or a
+     * pointer, but we definitely need an unsigned long.  Even though it
+     * happens to be an unsigned long already on Linux, do the cast just in
+     * case that's not so on another platform.  Note that this can still
+     * break if any platforms are left where a pointer is larger than an
+     * unsigned long.  In that case there's not much we can do; hopefully
+     * anyone porting to such a platform will be aware enough to notice the
+     * compile warnings about truncating the pointer value.
+     */
+    CRYPTO_THREADID_set_numeric(id, (unsigned long)pthread_self());
 }
-#else /* older openssl */
+#else  /* older openssl */
 static unsigned long
-legacy_threadid_func (void)
+legacy_threadid_func(void)
 {
-        /* See comments above, it applies here too. */
-        return (unsigned long)pthread_self();
+    /* See comments above, it applies here too. */
+    return (unsigned long)pthread_self();
 }
 #endif /* OPENSSL_VERSION_NUMBER >= 0x1000000f */
 #endif /* OPENSSL_VERSION_NUMBER < 0x1010000f */
 
 static void
-init_openssl_mt (void)
+init_openssl_mt(void)
 {
-        static gf_boolean_t initialized = _gf_false;
+    static gf_boolean_t initialized = _gf_false;
 
-        if (initialized) {
-                /* this only needs to be initialized once GLOBALLY no
-                   matter how many translators/sockets we end up with. */
-                return;
-        }
+    if (initialized) {
+        /* this only needs to be initialized once GLOBALLY no
+           matter how many translators/sockets we end up with. */
+        return;
+    }
 
-        SSL_library_init();
-        SSL_load_error_strings();
+    SSL_library_init();
+    SSL_load_error_strings();
 
-        initialized = _gf_true;
+    initialized = _gf_true;
 
 #if OPENSSL_VERSION_NUMBER < 0x1010000f
-        int     num_locks       = CRYPTO_num_locks();
-        int     i;
-
-        lock_array = GF_CALLOC (num_locks, sizeof(pthread_mutex_t),
-                                gf_sock_mt_lock_array);
-        if (lock_array) {
-                for (i = 0; i < num_locks; ++i) {
-                        pthread_mutex_init (&lock_array[i], NULL);
-                }
+    int num_locks = CRYPTO_num_locks();
+    int i;
+
+    lock_array = GF_CALLOC(num_locks, sizeof(pthread_mutex_t),
+                           gf_sock_mt_lock_array);
+    if (lock_array) {
+        for (i = 0; i < num_locks; ++i) {
+            pthread_mutex_init(&lock_array[i], NULL);
+        }
 #if OPENSSL_VERSION_NUMBER >= 0x1000000f
-                CRYPTO_THREADID_set_callback (threadid_func);
+        CRYPTO_THREADID_set_callback(threadid_func);
 #else /* older openssl */
-                CRYPTO_set_id_callback (legacy_threadid_func);
+        CRYPTO_set_id_callback(legacy_threadid_func);
 #endif
-                CRYPTO_set_locking_callback (locking_func);
-        }
+        CRYPTO_set_locking_callback(locking_func);
+    }
 #endif
 }
 
-static void __attribute__((destructor))
-fini_openssl_mt (void)
+static void __attribute__((destructor)) fini_openssl_mt(void)
 {
 #if OPENSSL_VERSION_NUMBER < 0x1010000f
-        int i;
+    int i;
 
-        if (!lock_array) {
-                return;
-        }
+    if (!lock_array) {
+        return;
+    }
 
-        CRYPTO_set_locking_callback(NULL);
+    CRYPTO_set_locking_callback(NULL);
 #if OPENSSL_VERSION_NUMBER >= 0x1000000f
-        CRYPTO_THREADID_set_callback (NULL);
+    CRYPTO_THREADID_set_callback(NULL);
 #else /* older openssl */
-        CRYPTO_set_id_callback (NULL);
+    CRYPTO_set_id_callback(NULL);
 #endif
 
-        for (i = 0; i < CRYPTO_num_locks(); ++i) {
-                pthread_mutex_destroy (&lock_array[i]);
-        }
+    for (i = 0; i < CRYPTO_num_locks(); ++i) {
+        pthread_mutex_destroy(&lock_array[i]);
+    }
 
-        GF_FREE (lock_array);
-        lock_array = NULL;
+    GF_FREE(lock_array);
+    lock_array = NULL;
 #endif
 
-        ERR_free_strings();
+    ERR_free_strings();
 }
 
 static int
 ssl_setup_connection_params(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        char             *optstr = NULL;
-        static int        session_id = 1;
-        int32_t           cert_depth = DEFAULT_VERIFY_DEPTH;
-        char             *cipher_list = DEFAULT_CIPHER_LIST;
-        char             *dh_param = DEFAULT_DH_PARAM;
-        char             *ec_curve = DEFAULT_EC_CURVE;
-        char             *crl_path = NULL;
-
-        priv = this->private;
-
-        if (priv->ssl_ctx != NULL) {
-                gf_log (this->name, GF_LOG_TRACE, "found old SSL context!");
-                return 0;
-        }
-
-        priv->ssl_own_cert = DEFAULT_CERT_PATH;
-        if (dict_get_str(this->options, SSL_OWN_CERT_OPT, &optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name, GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_OWN_CERT_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_own_cert = optstr;
-        }
-        priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert);
-
-        priv->ssl_private_key = DEFAULT_KEY_PATH;
-        if (dict_get_str(this->options, SSL_PRIVATE_KEY_OPT, &optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name, GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_PRIVATE_KEY_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_private_key = optstr;
-        }
-        priv->ssl_private_key = gf_strdup(priv->ssl_private_key);
-
-        priv->ssl_ca_list = DEFAULT_CA_PATH;
-        if (dict_get_str(this->options, SSL_CA_LIST_OPT, &optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name, GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_CA_LIST_OPT, SSL_ENABLED_OPT);
-                }
-                priv->ssl_ca_list = optstr;
-        }
-        priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list);
-
-        if (dict_get_str(this->options, SSL_CRL_PATH_OPT, &optstr) == 0) {
-                if (!priv->ssl_enabled) {
-                        gf_log(this->name, GF_LOG_WARNING,
-                               "%s specified without %s (ignored)",
-                               SSL_CRL_PATH_OPT, SSL_ENABLED_OPT);
-                }
-                if (strcasecmp(optstr, "NULL") == 0)
-                        crl_path = NULL;
-                else
-                        crl_path = optstr;
-        }
-
-        gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO: GF_LOG_DEBUG,
-               "SSL support on the I/O path is %s",
-               priv->ssl_enabled ? "ENABLED" : "NOT enabled");
-        gf_log(this->name, priv->mgmt_ssl ? GF_LOG_INFO: GF_LOG_DEBUG,
-               "SSL support for glusterd is %s",
-               priv->mgmt_ssl ? "ENABLED" : "NOT enabled");
-
-        if (!priv->mgmt_ssl) {
-                if (!dict_get_int32 (this->options, SSL_CERT_DEPTH_OPT, &cert_depth)) {
-                        gf_log (this->name, GF_LOG_INFO,
-                                "using certificate depth %d", cert_depth);
-                }
-        } else {
-                cert_depth = this->ctx->ssl_cert_depth;
-                gf_log (this->name, GF_LOG_INFO,
-                        "using certificate depth %d", cert_depth);
-        }
-        if (!dict_get_str (this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using cipher list %s", cipher_list);
-        }
-        if (!dict_get_str (this->options, SSL_DH_PARAM_OPT, &dh_param)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using DH parameters %s", dh_param);
-        }
-        if (!dict_get_str (this->options, SSL_EC_CURVE_OPT, &ec_curve)) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "using EC curve %s", ec_curve);
-        }
-
-        if (priv->ssl_enabled || priv->mgmt_ssl) {
-                BIO *bio = NULL;
+    socket_private_t *priv = NULL;
+    char *optstr = NULL;
+    static int session_id = 1;
+    int32_t cert_depth = DEFAULT_VERIFY_DEPTH;
+    char *cipher_list = DEFAULT_CIPHER_LIST;
+    char *dh_param = DEFAULT_DH_PARAM;
+    char *ec_curve = DEFAULT_EC_CURVE;
+    char *crl_path = NULL;
+
+    priv = this->private;
+
+    if (priv->ssl_ctx != NULL) {
+        gf_log(this->name, GF_LOG_TRACE, "found old SSL context!");
+        return 0;
+    }
+
+    priv->ssl_own_cert = DEFAULT_CERT_PATH;
+    if (dict_get_str(this->options, SSL_OWN_CERT_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_OWN_CERT_OPT,
+                   SSL_ENABLED_OPT);
+        }
+        priv->ssl_own_cert = optstr;
+    }
+    priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert);
+
+    priv->ssl_private_key = DEFAULT_KEY_PATH;
+    if (dict_get_str(this->options, SSL_PRIVATE_KEY_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_PRIVATE_KEY_OPT,
+                   SSL_ENABLED_OPT);
+        }
+        priv->ssl_private_key = optstr;
+    }
+    priv->ssl_private_key = gf_strdup(priv->ssl_private_key);
+
+    priv->ssl_ca_list = DEFAULT_CA_PATH;
+    if (dict_get_str(this->options, SSL_CA_LIST_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_CA_LIST_OPT,
+                   SSL_ENABLED_OPT);
+        }
+        priv->ssl_ca_list = optstr;
+    }
+    priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list);
+
+    if (dict_get_str(this->options, SSL_CRL_PATH_OPT, &optstr) == 0) {
+        if (!priv->ssl_enabled) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s specified without %s (ignored)", SSL_CRL_PATH_OPT,
+                   SSL_ENABLED_OPT);
+        }
+        if (strcasecmp(optstr, "NULL") == 0)
+            crl_path = NULL;
+        else
+            crl_path = optstr;
+    }
+
+    gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO : GF_LOG_DEBUG,
+           "SSL support on the I/O path is %s",
+           priv->ssl_enabled ? "ENABLED" : "NOT enabled");
+    gf_log(this->name, priv->mgmt_ssl ? GF_LOG_INFO : GF_LOG_DEBUG,
+           "SSL support for glusterd is %s",
+           priv->mgmt_ssl ? "ENABLED" : "NOT enabled");
+
+    if (!priv->mgmt_ssl) {
+        if (!dict_get_int32(this->options, SSL_CERT_DEPTH_OPT, &cert_depth)) {
+            gf_log(this->name, GF_LOG_INFO, "using certificate depth %d",
+                   cert_depth);
+        }
+    } else {
+        cert_depth = this->ctx->ssl_cert_depth;
+        gf_log(this->name, GF_LOG_INFO, "using certificate depth %d",
+               cert_depth);
+    }
+    if (!dict_get_str(this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) {
+        gf_log(this->name, GF_LOG_INFO, "using cipher list %s", cipher_list);
+    }
+    if (!dict_get_str(this->options, SSL_DH_PARAM_OPT, &dh_param)) {
+        gf_log(this->name, GF_LOG_INFO, "using DH parameters %s", dh_param);
+    }
+    if (!dict_get_str(this->options, SSL_EC_CURVE_OPT, &ec_curve)) {
+        gf_log(this->name, GF_LOG_INFO, "using EC curve %s", ec_curve);
+    }
+
+    if (priv->ssl_enabled || priv->mgmt_ssl) {
+        BIO *bio = NULL;
 
 #if HAVE_TLS_METHOD
-                priv->ssl_meth = (SSL_METHOD *)TLS_method();
+        priv->ssl_meth = (SSL_METHOD *)TLS_method();
 #elif HAVE_TLSV1_2_METHOD
-                priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method();
+        priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method();
 #else
 /*
  * Nobody should use an OpenSSL so old it does not support TLS 1.2.
@@ -4354,560 +4204,494 @@ ssl_setup_connection_params(rpc_transport_t *this)
 #ifndef USE_INSECURE_OPENSSL
 #error Old and insecure OpenSSL, use -DUSE_INSECURE_OPENSSL to use it anyway
 #endif
-                /* SSLv23_method uses highest available protocol */
-                priv->ssl_meth = SSLv23_method();
+        /* SSLv23_method uses highest available protocol */
+        priv->ssl_meth = SSLv23_method();
 #endif
-                priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth);
+        priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth);
 
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2);
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3);
 #ifdef SSL_OP_NO_TICKET
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET);
 #endif
 #ifdef SSL_OP_NO_COMPRESSION
-                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION);
 #endif
 
-                if ((bio = BIO_new_file(dh_param, "r")) == NULL) {
-                        gf_log(this->name, GF_LOG_INFO,
-                               "failed to open %s, "
-                               "DH ciphers are disabled", dh_param);
-                }
+        if ((bio = BIO_new_file(dh_param, "r")) == NULL) {
+            gf_log(this->name, GF_LOG_INFO,
+                   "failed to open %s, "
+                   "DH ciphers are disabled",
+                   dh_param);
+        }
 
-                if (bio != NULL) {
+        if (bio != NULL) {
 #ifdef HAVE_OPENSSL_DH_H
-                        DH *dh;
-                        unsigned long err;
-
-                        dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
-                        BIO_free(bio);
-                        if (dh != NULL) {
-                                SSL_CTX_set_options(priv->ssl_ctx,
-                                                    SSL_OP_SINGLE_DH_USE);
-                                SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh);
-                                DH_free(dh);
-                        } else {
-                                err = ERR_get_error();
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "failed to read DH param from %s: %s "
-                                       "DH ciphers are disabled.",
-                                       dh_param, ERR_error_string(err, NULL));
-                        }
-#else /* HAVE_OPENSSL_DH_H */
-                        BIO_free(bio);
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "OpenSSL has no DH support");
+            DH *dh;
+            unsigned long err;
+
+            dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
+            BIO_free(bio);
+            if (dh != NULL) {
+                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_DH_USE);
+                SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh);
+                DH_free(dh);
+            } else {
+                err = ERR_get_error();
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to read DH param from %s: %s "
+                       "DH ciphers are disabled.",
+                       dh_param, ERR_error_string(err, NULL));
+            }
+#else  /* HAVE_OPENSSL_DH_H */
+            BIO_free(bio);
+            gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no DH support");
 #endif /* HAVE_OPENSSL_DH_H */
-                }
+        }
 
-                if (ec_curve != NULL) {
+        if (ec_curve != NULL) {
 #ifdef HAVE_OPENSSL_ECDH_H
-                        EC_KEY *ecdh = NULL;
-                        int nid;
-                        unsigned long err;
-
-                        nid = OBJ_sn2nid(ec_curve);
-                        if (nid != 0)
-                                ecdh = EC_KEY_new_by_curve_name(nid);
-
-                        if (ecdh != NULL) {
-                                SSL_CTX_set_options(priv->ssl_ctx,
-                                                    SSL_OP_SINGLE_ECDH_USE);
-                                SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh);
-                                EC_KEY_free(ecdh);
-                        } else {
-                                err = ERR_get_error();
-                                gf_log(this->name, GF_LOG_ERROR,
-                                       "failed to load EC curve %s: %s. "
-                                       "ECDH ciphers are disabled.",
-                                       ec_curve, ERR_error_string(err, NULL));
-                        }
-#else /* HAVE_OPENSSL_ECDH_H */
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "OpenSSL has no ECDH support");
+            EC_KEY *ecdh = NULL;
+            int nid;
+            unsigned long err;
+
+            nid = OBJ_sn2nid(ec_curve);
+            if (nid != 0)
+                ecdh = EC_KEY_new_by_curve_name(nid);
+
+            if (ecdh != NULL) {
+                SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_ECDH_USE);
+                SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh);
+                EC_KEY_free(ecdh);
+            } else {
+                err = ERR_get_error();
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to load EC curve %s: %s. "
+                       "ECDH ciphers are disabled.",
+                       ec_curve, ERR_error_string(err, NULL));
+            }
+#else  /* HAVE_OPENSSL_ECDH_H */
+            gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no ECDH support");
 #endif /* HAVE_OPENSSL_ECDH_H */
-                }
+        }
 
-                /* This must be done after DH and ECDH setups */
-                if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) {
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "failed to find any valid ciphers");
-                        goto err;
-                }
+        /* This must be done after DH and ECDH setups */
+        if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to find any valid ciphers");
+            goto err;
+        }
 
-                SSL_CTX_set_options(priv->ssl_ctx,
-                                    SSL_OP_CIPHER_SERVER_PREFERENCE);
+        SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
 
-                if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx,
-                                                        priv->ssl_own_cert)) {
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "could not load our cert at %s",
-                               priv->ssl_own_cert);
-                        ssl_dump_error_stack(this->name);
-                        goto err;
-                }
+        if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx,
+                                                priv->ssl_own_cert)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load our cert at %s",
+                   priv->ssl_own_cert);
+            ssl_dump_error_stack(this->name);
+            goto err;
+        }
 
-                if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx,
-                                                 priv->ssl_private_key,
-                                                 SSL_FILETYPE_PEM)) {
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "could not load private key at %s",
-                               priv->ssl_private_key);
-                        ssl_dump_error_stack(this->name);
-                        goto err;
-                }
+        if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx, priv->ssl_private_key,
+                                         SSL_FILETYPE_PEM)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load private key at %s",
+                   priv->ssl_private_key);
+            ssl_dump_error_stack(this->name);
+            goto err;
+        }
 
-                if (!SSL_CTX_load_verify_locations(priv->ssl_ctx,
-                                                   priv->ssl_ca_list,
-                                                   crl_path)) {
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "could not load CA list");
-                        goto err;
-                }
+        if (!SSL_CTX_load_verify_locations(priv->ssl_ctx, priv->ssl_ca_list,
+                                           crl_path)) {
+            gf_log(this->name, GF_LOG_ERROR, "could not load CA list");
+            goto err;
+        }
 
-                SSL_CTX_set_verify_depth(priv->ssl_ctx, cert_depth);
+        SSL_CTX_set_verify_depth(priv->ssl_ctx, cert_depth);
 
-                if (crl_path) {
+        if (crl_path) {
 #ifdef X509_V_FLAG_CRL_CHECK_ALL
-                        X509_STORE *x509store;
+            X509_STORE *x509store;
 
-                        x509store  = SSL_CTX_get_cert_store(priv->ssl_ctx);
-                        X509_STORE_set_flags(x509store,
-                                             X509_V_FLAG_CRL_CHECK |
-                                             X509_V_FLAG_CRL_CHECK_ALL);
+            x509store = SSL_CTX_get_cert_store(priv->ssl_ctx);
+            X509_STORE_set_flags(
+                x509store, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
 #else
-                        gf_log(this->name, GF_LOG_ERROR,
-                               "OpenSSL version does not support CRL");
+            gf_log(this->name, GF_LOG_ERROR,
+                   "OpenSSL version does not support CRL");
 #endif
-                }
+        }
 
-                priv->ssl_session_id = session_id++;
-                SSL_CTX_set_session_id_context(priv->ssl_ctx,
-                                               (void *)&priv->ssl_session_id,
-                                               sizeof(priv->ssl_session_id));
+        priv->ssl_session_id = session_id++;
+        SSL_CTX_set_session_id_context(priv->ssl_ctx,
+                                       (void *)&priv->ssl_session_id,
+                                       sizeof(priv->ssl_session_id));
 
-                SSL_CTX_set_verify(priv->ssl_ctx, SSL_VERIFY_PEER, 0);
+        SSL_CTX_set_verify(priv->ssl_ctx, SSL_VERIFY_PEER, 0);
 
-                /*
-                 * Since glusterfs shares the same settings for client-side
-                 * and server-side of SSL, we need to ignore any certificate
-                 * usage specification (SSL client vs SSL server), otherwise
-                 * SSL connexions will fail with 'unsupported cerritifcate"
-                 */
-                SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY);
-        }
-        return 0;
+        /*
+         * Since glusterfs shares the same settings for client-side
+         * and server-side of SSL, we need to ignore any certificate
+         * usage specification (SSL client vs SSL server), otherwise
+         * SSL connexions will fail with 'unsupported cerritifcate"
+         */
+        SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY);
+    }
+    return 0;
 
 err:
-        return -1;
+    return -1;
 }
 
 static int
-socket_init (rpc_transport_t *this)
+socket_init(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-        gf_boolean_t      tmp_bool = 0;
-        uint64_t          windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
-        char             *optstr = NULL;
-        uint32_t          timeout = 0;
-        int               keepaliveidle  = GF_KEEPALIVE_TIME;
-        int               keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        int               keepalivecnt   = GF_KEEPALIVE_COUNT;
-        uint32_t          backlog = 0;
-
-
-        if (this->private) {
-                gf_log_callingfn (this->name, GF_LOG_ERROR,
-                                  "double init attempted");
-                return -1;
-        }
-
-        priv = GF_MALLOC (sizeof (*priv), gf_common_mt_socket_private_t);
-        if (!priv) {
-                return -1;
-        }
-        memset(priv, 0, sizeof(*priv));
-
-        this->private = priv;
-        pthread_mutex_init (&priv->in_lock, NULL);
-        pthread_mutex_init (&priv->out_lock, NULL);
-        pthread_mutex_init (&priv->cond_lock, NULL);
-        pthread_cond_init (&priv->cond, NULL);
-
-        /*GF_REF_INIT (priv, socket_poller_mayday);*/
-
-        priv->sock = -1;
-        priv->idx = -1;
-        priv->connected = -1;
-        priv->nodelay = 1;
-        priv->bio = 0;
-        priv->ssl_accepted  = _gf_false;
-        priv->ssl_connected = _gf_false;
-        priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
-        INIT_LIST_HEAD (&priv->ioq);
-        pthread_mutex_init (&priv->notify.lock, NULL);
-        pthread_cond_init (&priv->notify.cond, NULL);
-
-        /* All the below section needs 'this->options' to be present */
-        if (!this->options)
-                goto out;
-
-        if (dict_get (this->options, "non-blocking-io")) {
-                optstr = data_to_str (dict_get (this->options,
-                                                "non-blocking-io"));
-
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'non-blocking-io' takes only boolean options,"
-                                " not taking any action");
-                        tmp_bool = 1;
-                }
-
-                if (!tmp_bool) {
-                        priv->bio = 1;
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "disabling non-blocking IO");
-                }
-        }
-
-        optstr = NULL;
-
-        /* By default, we enable NODELAY */
-        if (dict_get (this->options, "transport.socket.nodelay")) {
-                optstr = data_to_str (dict_get (this->options,
-                                                "transport.socket.nodelay"));
-
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.nodelay' takes only "
-                                "boolean options, not taking any action");
-                        tmp_bool = 1;
-                }
-                if (!tmp_bool) {
-                        priv->nodelay = 0;
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "disabling nodelay");
-                }
-        }
-
-        optstr = NULL;
-        if (dict_get_str (this->options, "tcp-window-size",
-                          &optstr) == 0) {
-                if (gf_string2uint64 (optstr, &windowsize) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid number format: %s", optstr);
-                        return -1;
-                }
-        }
-
-        priv->windowsize = (int)windowsize;
-
-        optstr = NULL;
-        /* Enable Keep-alive by default. */
-        priv->keepalive = 1;
-        priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
-        priv->keepaliveidle = GF_KEEPALIVE_TIME;
-        priv->keepalivecnt = GF_KEEPALIVE_COUNT;
-        if (dict_get_str (this->options, "transport.socket.keepalive",
-                          &optstr) == 0) {
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "'transport.socket.keepalive' takes only "
-                                "boolean options, not taking any action");
-                        tmp_bool = 1;
-                }
-
-                if (!tmp_bool)
-                        priv->keepalive = 0;
-        }
-
-        if (dict_get_int32 (this->options, "transport.tcp-user-timeout",
-                            &(priv->timeout)) != 0)
-                priv->timeout = timeout;
-        gf_log (this->name, GF_LOG_DEBUG, "Configued "
-                "transport.tcp-user-timeout=%d", priv->timeout);
-
-        if (dict_get_int32 (this->options,
-                            "transport.socket.keepalive-time",
-                            &(priv->keepaliveidle)) != 0) {
-                priv->keepaliveidle = keepaliveidle;
-        }
-
-        if (dict_get_int32 (this->options,
-                            "transport.socket.keepalive-interval",
-                            &(priv->keepaliveintvl)) != 0) {
-                priv->keepaliveintvl = keepaliveintvl;
-        }
-
-        if (dict_get_int32 (this->options, "transport.socket.keepalive-count",
-                            &(priv->keepalivecnt)) != 0)
-                priv->keepalivecnt = keepalivecnt;
-        gf_log (this->name, GF_LOG_DEBUG, "Reconfigued "
-                "transport.keepalivecnt=%d", keepalivecnt);
-
-        if (dict_get_uint32 (this->options,
-                             "transport.listen-backlog",
-                             &backlog) != 0) {
-                backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
-        }
-        priv->backlog = backlog;
-
-        optstr = NULL;
-
-         /* Check if socket read failures are to be logged */
-        priv->read_fail_log = 1;
-        if (dict_get (this->options, "transport.socket.read-fail-log")) {
-                optstr = data_to_str (dict_get (this->options,
-                                                "transport.socket.read-fail-log"));
-                if (gf_string2boolean (optstr, &tmp_bool) == -1) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "'transport.socket.read-fail-log' takes only "
-                                "boolean options; logging socket read fails");
-                } else if (tmp_bool == _gf_false) {
-                        priv->read_fail_log = 0;
-                }
-        }
-
-        priv->windowsize = (int)windowsize;
-
-        priv->ssl_enabled = _gf_false;
-        if (dict_get_str(this->options, SSL_ENABLED_OPT, &optstr) == 0) {
-                if (gf_string2boolean (optstr, &priv->ssl_enabled) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid value given for ssl-enabled boolean");
-                }
-        }
-        priv->mgmt_ssl = this->ctx->secure_mgmt;
-        priv->srvr_ssl = this->ctx->secure_srvr;
+    socket_private_t *priv = NULL;
+    gf_boolean_t tmp_bool = 0;
+    uint64_t windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
+    char *optstr = NULL;
+    uint32_t timeout = 0;
+    int keepaliveidle = GF_KEEPALIVE_TIME;
+    int keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+    int keepalivecnt = GF_KEEPALIVE_COUNT;
+    uint32_t backlog = 0;
+
+    if (this->private) {
+        gf_log_callingfn(this->name, GF_LOG_ERROR, "double init attempted");
+        return -1;
+    }
 
-        ssl_setup_connection_params(this);
+    priv = GF_MALLOC(sizeof(*priv), gf_common_mt_socket_private_t);
+    if (!priv) {
+        return -1;
+    }
+    memset(priv, 0, sizeof(*priv));
+
+    this->private = priv;
+    pthread_mutex_init(&priv->in_lock, NULL);
+    pthread_mutex_init(&priv->out_lock, NULL);
+    pthread_mutex_init(&priv->cond_lock, NULL);
+    pthread_cond_init(&priv->cond, NULL);
+
+    /*GF_REF_INIT (priv, socket_poller_mayday);*/
+
+    priv->sock = -1;
+    priv->idx = -1;
+    priv->connected = -1;
+    priv->nodelay = 1;
+    priv->bio = 0;
+    priv->ssl_accepted = _gf_false;
+    priv->ssl_connected = _gf_false;
+    priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE;
+    INIT_LIST_HEAD(&priv->ioq);
+    pthread_mutex_init(&priv->notify.lock, NULL);
+    pthread_cond_init(&priv->notify.cond, NULL);
+
+    /* All the below section needs 'this->options' to be present */
+    if (!this->options)
+        goto out;
+
+    if (dict_get(this->options, "non-blocking-io")) {
+        optstr = data_to_str(dict_get(this->options, "non-blocking-io"));
+
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'non-blocking-io' takes only boolean options,"
+                   " not taking any action");
+            tmp_bool = 1;
+        }
+
+        if (!tmp_bool) {
+            priv->bio = 1;
+            gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO");
+        }
+    }
+
+    optstr = NULL;
+
+    /* By default, we enable NODELAY */
+    if (dict_get(this->options, "transport.socket.nodelay")) {
+        optstr = data_to_str(
+            dict_get(this->options, "transport.socket.nodelay"));
+
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.nodelay' takes only "
+                   "boolean options, not taking any action");
+            tmp_bool = 1;
+        }
+        if (!tmp_bool) {
+            priv->nodelay = 0;
+            gf_log(this->name, GF_LOG_DEBUG, "disabling nodelay");
+        }
+    }
+
+    optstr = NULL;
+    if (dict_get_str(this->options, "tcp-window-size", &optstr) == 0) {
+        if (gf_string2uint64(optstr, &windowsize) != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s",
+                   optstr);
+            return -1;
+        }
+    }
+
+    priv->windowsize = (int)windowsize;
+
+    optstr = NULL;
+    /* Enable Keep-alive by default. */
+    priv->keepalive = 1;
+    priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL;
+    priv->keepaliveidle = GF_KEEPALIVE_TIME;
+    priv->keepalivecnt = GF_KEEPALIVE_COUNT;
+    if (dict_get_str(this->options, "transport.socket.keepalive", &optstr) ==
+        0) {
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "'transport.socket.keepalive' takes only "
+                   "boolean options, not taking any action");
+            tmp_bool = 1;
+        }
+
+        if (!tmp_bool)
+            priv->keepalive = 0;
+    }
+
+    if (dict_get_int32(this->options, "transport.tcp-user-timeout",
+                       &(priv->timeout)) != 0)
+        priv->timeout = timeout;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Configued "
+           "transport.tcp-user-timeout=%d",
+           priv->timeout);
+
+    if (dict_get_int32(this->options, "transport.socket.keepalive-time",
+                       &(priv->keepaliveidle)) != 0) {
+        priv->keepaliveidle = keepaliveidle;
+    }
+
+    if (dict_get_int32(this->options, "transport.socket.keepalive-interval",
+                       &(priv->keepaliveintvl)) != 0) {
+        priv->keepaliveintvl = keepaliveintvl;
+    }
+
+    if (dict_get_int32(this->options, "transport.socket.keepalive-count",
+                       &(priv->keepalivecnt)) != 0)
+        priv->keepalivecnt = keepalivecnt;
+    gf_log(this->name, GF_LOG_DEBUG,
+           "Reconfigued "
+           "transport.keepalivecnt=%d",
+           keepalivecnt);
+
+    if (dict_get_uint32(this->options, "transport.listen-backlog", &backlog) !=
+        0) {
+        backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG;
+    }
+    priv->backlog = backlog;
+
+    optstr = NULL;
+
+    /* Check if socket read failures are to be logged */
+    priv->read_fail_log = 1;
+    if (dict_get(this->options, "transport.socket.read-fail-log")) {
+        optstr = data_to_str(
+            dict_get(this->options, "transport.socket.read-fail-log"));
+        if (gf_string2boolean(optstr, &tmp_bool) == -1) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "'transport.socket.read-fail-log' takes only "
+                   "boolean options; logging socket read fails");
+        } else if (tmp_bool == _gf_false) {
+            priv->read_fail_log = 0;
+        }
+    }
+
+    priv->windowsize = (int)windowsize;
+
+    priv->ssl_enabled = _gf_false;
+    if (dict_get_str(this->options, SSL_ENABLED_OPT, &optstr) == 0) {
+        if (gf_string2boolean(optstr, &priv->ssl_enabled) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "invalid value given for ssl-enabled boolean");
+        }
+    }
+    priv->mgmt_ssl = this->ctx->secure_mgmt;
+    priv->srvr_ssl = this->ctx->secure_srvr;
+
+    ssl_setup_connection_params(this);
 out:
-        this->private = priv;
-        return 0;
+    this->private = priv;
+    return 0;
 }
 
-
 void
-fini (rpc_transport_t *this)
+fini(rpc_transport_t *this)
 {
-        socket_private_t *priv = NULL;
-
-        if (!this)
-                return;
-
-        priv = this->private;
-        if (priv) {
-                if (priv->sock != -1) {
-                        pthread_mutex_lock (&priv->in_lock);
-                        pthread_mutex_lock (&priv->out_lock);
-                        {
-                                __socket_ioq_flush (this);
-                                __socket_reset (this);
-                        }
-                        pthread_mutex_unlock (&priv->out_lock);
-                        pthread_mutex_unlock (&priv->in_lock);
-                }
-                gf_log (this->name, GF_LOG_TRACE,
-                        "transport %p destroyed", this);
-
-                pthread_mutex_destroy (&priv->in_lock);
-                pthread_mutex_destroy (&priv->out_lock);
-                pthread_mutex_destroy (&priv->cond_lock);
-                pthread_cond_destroy (&priv->cond);
-                if (priv->ssl_private_key) {
-                        GF_FREE(priv->ssl_private_key);
-                }
-                if (priv->ssl_own_cert) {
-                        GF_FREE(priv->ssl_own_cert);
-                }
-                if (priv->ssl_ca_list) {
-                        GF_FREE(priv->ssl_ca_list);
-                }
-                GF_FREE (priv);
+    socket_private_t *priv = NULL;
+
+    if (!this)
+        return;
+
+    priv = this->private;
+    if (priv) {
+        if (priv->sock != -1) {
+            pthread_mutex_lock(&priv->in_lock);
+            pthread_mutex_lock(&priv->out_lock);
+            {
+                __socket_ioq_flush(this);
+                __socket_reset(this);
+            }
+            pthread_mutex_unlock(&priv->out_lock);
+            pthread_mutex_unlock(&priv->in_lock);
+        }
+        gf_log(this->name, GF_LOG_TRACE, "transport %p destroyed", this);
+
+        pthread_mutex_destroy(&priv->in_lock);
+        pthread_mutex_destroy(&priv->out_lock);
+        pthread_mutex_destroy(&priv->cond_lock);
+        pthread_cond_destroy(&priv->cond);
+        if (priv->ssl_private_key) {
+            GF_FREE(priv->ssl_private_key);
+        }
+        if (priv->ssl_own_cert) {
+            GF_FREE(priv->ssl_own_cert);
+        }
+        if (priv->ssl_ca_list) {
+            GF_FREE(priv->ssl_ca_list);
         }
+        GF_FREE(priv);
+    }
 
-        this->private = NULL;
+    this->private = NULL;
 }
 
 int32_t
-init (rpc_transport_t *this)
+init(rpc_transport_t *this)
 {
-        int ret = -1;
+    int ret = -1;
 
-        init_openssl_mt();
+    init_openssl_mt();
 
-        ret = socket_init (this);
+    ret = socket_init(this);
 
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "socket_init() failed");
-        }
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_DEBUG, "socket_init() failed");
+    }
 
-        return ret;
+    return ret;
 }
 
 struct volume_options options[] = {
-        { .key   = {"remote-port",
-                    "transport.remote-port",
-                    "transport.socket.remote-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.socket.listen-port", "listen-port"},
-          .type  = GF_OPTION_TYPE_INT
-        },
-        { .key   = {"transport.socket.bind-address", "bind-address" },
-          .type  = GF_OPTION_TYPE_INTERNET_ADDRESS
-        },
-        { .key   = {"transport.socket.connect-path", "connect-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.socket.bind-path", "bind-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.socket.listen-path", "listen-path"},
-          .type  = GF_OPTION_TYPE_ANY
-        },
-        { .key   = {"transport.address-family", "address-family"},
-          .value = {"inet", "inet6", "unix", "inet-sdp"},
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {"non-blocking-io"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {"tcp-window-size"},
-          .type  = GF_OPTION_TYPE_SIZET,
-          .op_version = {1},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "Option to set TCP SEND/RECV BUFFER SIZE",
-          .min   = GF_MIN_SOCKET_WINDOW_SIZE,
-          .max   = GF_MAX_SOCKET_WINDOW_SIZE
-        },
-        { .key   = {"transport.listen-backlog"},
-          .type  = GF_OPTION_TYPE_SIZET,
-          .op_version  = {GD_OP_VERSION_3_11_1},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "This option uses the value of backlog argument that "
-                         "defines the maximum length to which the queue of "
-                         "pending connections for socket fd may grow.",
-          .default_value = "1024",
-        },
-        { .key   = {"transport.tcp-user-timeout"},
-          .type  = GF_OPTION_TYPE_INT,
-          .op_version  = {GD_OP_VERSION_3_10_2},
-          .default_value = "0"
-        },
-        { .key   = {"transport.socket.nodelay"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "1"
-        },
-        { .key   = {"transport.socket.lowlat"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {"transport.socket.keepalive"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .op_version  = {1},
-          .default_value = "1"
-        },
-        { .key   = {"transport.socket.keepalive-interval"},
-          .type  = GF_OPTION_TYPE_INT,
-          .op_version  = {GD_OP_VERSION_3_10_2},
-          .default_value = "2"
-        },
-        { .key   = {"transport.socket.keepalive-time"},
-          .type  = GF_OPTION_TYPE_INT,
-          .op_version  = {GD_OP_VERSION_3_10_2},
-          .default_value = "20"
-        },
-        { .key   = {"transport.socket.keepalive-count"},
-          .type  = GF_OPTION_TYPE_INT,
-          .op_version  = {GD_OP_VERSION_3_10_2},
-          .default_value = "9"
-        },
-        { .key   = {"transport.socket.read-fail-log"},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {SSL_ENABLED_OPT},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {SSL_OWN_CERT_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_PRIVATE_KEY_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_CA_LIST_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_CERT_DEPTH_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_CIPHER_LIST_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_DH_PARAM_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_EC_CURVE_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {SSL_CRL_PATH_OPT},
-          .type  = GF_OPTION_TYPE_STR
-        },
-        { .key   = {OWN_THREAD_OPT},
-          .type  = GF_OPTION_TYPE_BOOL
-        },
-        { .key   = {"ssl-own-cert"},
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL certificate. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-private-key"},
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL private key. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-ca-list"},
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .type  = GF_OPTION_TYPE_STR,
-          .description = "SSL CA list. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-cert-depth"},
-          .type  = GF_OPTION_TYPE_INT,
-          .op_version  = {GD_OP_VERSION_3_6_0},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "Maximum certificate-chain depth.  If zero, the "
-                         "peer's certificate itself must be in the local "
-                         "certificate list.  Otherwise, there may be up to N "
-                         "signing certificates between the peer's and the "
-                         "local list.  Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-cipher-list"},
-          .type  = GF_OPTION_TYPE_STR,
-          .op_version  = {GD_OP_VERSION_3_6_0},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "Allowed SSL ciphers. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-dh-param"},
-          .type  = GF_OPTION_TYPE_STR,
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "DH parameters file. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-ec-curve"},
-          .type  = GF_OPTION_TYPE_STR,
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "ECDH curve name. Ignored if SSL is not enabled."
-        },
-        { .key   = {"ssl-crl-path"},
-          .type  = GF_OPTION_TYPE_STR,
-          .op_version = {GD_OP_VERSION_3_7_4},
-          .flags      = OPT_FLAG_SETTABLE,
-          .description = "Path to directory containing CRL. "
-                         "Ignored if SSL is not enabled."
-        },
-        { .key = {NULL} }
-};
+    {.key = {"remote-port", "transport.remote-port",
+             "transport.socket.remote-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.socket.listen-port", "listen-port"},
+     .type = GF_OPTION_TYPE_INT},
+    {.key = {"transport.socket.bind-address", "bind-address"},
+     .type = GF_OPTION_TYPE_INTERNET_ADDRESS},
+    {.key = {"transport.socket.connect-path", "connect-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.socket.bind-path", "bind-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.socket.listen-path", "listen-path"},
+     .type = GF_OPTION_TYPE_ANY},
+    {.key = {"transport.address-family", "address-family"},
+     .value = {"inet", "inet6", "unix", "inet-sdp"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .type = GF_OPTION_TYPE_STR},
+    {.key = {"non-blocking-io"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"tcp-window-size"},
+     .type = GF_OPTION_TYPE_SIZET,
+     .op_version = {1},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Option to set TCP SEND/RECV BUFFER SIZE",
+     .min = GF_MIN_SOCKET_WINDOW_SIZE,
+     .max = GF_MAX_SOCKET_WINDOW_SIZE},
+    {
+        .key = {"transport.listen-backlog"},
+        .type = GF_OPTION_TYPE_SIZET,
+        .op_version = {GD_OP_VERSION_3_11_1},
+        .flags = OPT_FLAG_SETTABLE,
+        .description = "This option uses the value of backlog argument that "
+                       "defines the maximum length to which the queue of "
+                       "pending connections for socket fd may grow.",
+        .default_value = "1024",
+    },
+    {.key = {"transport.tcp-user-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "0"},
+    {.key = {"transport.socket.nodelay"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "1"},
+    {.key = {"transport.socket.lowlat"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"transport.socket.keepalive"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .op_version = {1},
+     .default_value = "1"},
+    {.key = {"transport.socket.keepalive-interval"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "2"},
+    {.key = {"transport.socket.keepalive-time"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "20"},
+    {.key = {"transport.socket.keepalive-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_10_2},
+     .default_value = "9"},
+    {.key = {"transport.socket.read-fail-log"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {SSL_ENABLED_OPT}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {SSL_OWN_CERT_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_PRIVATE_KEY_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CA_LIST_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CERT_DEPTH_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CIPHER_LIST_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_DH_PARAM_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_EC_CURVE_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {SSL_CRL_PATH_OPT}, .type = GF_OPTION_TYPE_STR},
+    {.key = {OWN_THREAD_OPT}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"ssl-own-cert"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL certificate. Ignored if SSL is not enabled."},
+    {.key = {"ssl-private-key"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL private key. Ignored if SSL is not enabled."},
+    {.key = {"ssl-ca-list"},
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .type = GF_OPTION_TYPE_STR,
+     .description = "SSL CA list. Ignored if SSL is not enabled."},
+    {.key = {"ssl-cert-depth"},
+     .type = GF_OPTION_TYPE_INT,
+     .op_version = {GD_OP_VERSION_3_6_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Maximum certificate-chain depth.  If zero, the "
+                    "peer's certificate itself must be in the local "
+                    "certificate list.  Otherwise, there may be up to N "
+                    "signing certificates between the peer's and the "
+                    "local list.  Ignored if SSL is not enabled."},
+    {.key = {"ssl-cipher-list"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_6_0},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Allowed SSL ciphers. Ignored if SSL is not enabled."},
+    {.key = {"ssl-dh-param"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "DH parameters file. Ignored if SSL is not enabled."},
+    {.key = {"ssl-ec-curve"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "ECDH curve name. Ignored if SSL is not enabled."},
+    {.key = {"ssl-crl-path"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {GD_OP_VERSION_3_7_4},
+     .flags = OPT_FLAG_SETTABLE,
+     .description = "Path to directory containing CRL. "
+                    "Ignored if SSL is not enabled."},
+    {.key = {NULL}}};
diff --git a/rpc/xdr/src/msg-nfs3.c b/rpc/xdr/src/msg-nfs3.c
index 040aced6a97..d14a731b62a 100644
--- a/rpc/xdr/src/msg-nfs3.c
+++ b/rpc/xdr/src/msg-nfs3.c
@@ -18,35 +18,34 @@
 #include "xdr-generic.h"
 #include "xdr-common.h"
 
-
 /* Decode the mount path from the network message in inmsg
  * into the memory referenced by outpath.iov_base.
  * The size allocated for outpath.iov_base is outpath.iov_len.
  * The size of the path extracted from the message is returned.
  */
 ssize_t
-xdr_to_mountpath (struct iovec outpath, struct iovec inmsg)
+xdr_to_mountpath(struct iovec outpath, struct iovec inmsg)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
-        char    *mntpath = NULL;
+    XDR xdr;
+    ssize_t ret = -1;
+    char *mntpath = NULL;
 
-        if ((!outpath.iov_base) || (!inmsg.iov_base))
-                return -1;
+    if ((!outpath.iov_base) || (!inmsg.iov_base))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        mntpath = outpath.iov_base;
-        if (!xdr_dirpath (&xdr, (dirpath *)&mntpath)) {
-                ret = -1;
-                goto ret;
-        }
+    mntpath = outpath.iov_base;
+    if (!xdr_dirpath(&xdr, (dirpath *)&mntpath)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
 /* Translate the mountres3 structure in res into XDR format into memory
@@ -54,514 +53,429 @@ ret:
  * Returns the number of bytes used in encoding into XDR format.
  */
 ssize_t
-xdr_serialize_mountres3 (struct iovec outmsg, mountres3 *res)
+xdr_serialize_mountres3(struct iovec outmsg, mountres3 *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mountres3);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mountres3);
 }
 
-
 ssize_t
-xdr_serialize_mountbody (struct iovec outmsg, mountbody *mb)
+xdr_serialize_mountbody(struct iovec outmsg, mountbody *mb)
 {
-        return xdr_serialize_generic (outmsg, (void *)mb,
-                                          (xdrproc_t)xdr_mountbody);
+    return xdr_serialize_generic(outmsg, (void *)mb, (xdrproc_t)xdr_mountbody);
 }
 
 ssize_t
-xdr_serialize_mountlist (struct iovec outmsg, mountlist *ml)
+xdr_serialize_mountlist(struct iovec outmsg, mountlist *ml)
 {
-        return xdr_serialize_generic (outmsg, (void *)ml,
-                                          (xdrproc_t)xdr_mountlist);
+    return xdr_serialize_generic(outmsg, (void *)ml, (xdrproc_t)xdr_mountlist);
 }
 
-
 ssize_t
-xdr_serialize_mountstat3 (struct iovec outmsg, mountstat3 *m)
+xdr_serialize_mountstat3(struct iovec outmsg, mountstat3 *m)
 {
-        return xdr_serialize_generic (outmsg, (void *)m,
-                                          (xdrproc_t)xdr_mountstat3);
+    return xdr_serialize_generic(outmsg, (void *)m, (xdrproc_t)xdr_mountstat3);
 }
 
-
 ssize_t
-xdr_to_getattr3args (struct iovec inmsg, getattr3args *ga)
+xdr_to_getattr3args(struct iovec inmsg, getattr3args *ga)
 {
-        return xdr_to_generic (inmsg, (void *)ga,
-                                   (xdrproc_t)xdr_getattr3args);
+    return xdr_to_generic(inmsg, (void *)ga, (xdrproc_t)xdr_getattr3args);
 }
 
-
 ssize_t
-xdr_serialize_getattr3res (struct iovec outmsg, getattr3res *res)
+xdr_serialize_getattr3res(struct iovec outmsg, getattr3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_getattr3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_getattr3res);
 }
 
-
 ssize_t
-xdr_serialize_setattr3res (struct iovec outmsg, setattr3res *res)
+xdr_serialize_setattr3res(struct iovec outmsg, setattr3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_setattr3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_setattr3res);
 }
 
-
 ssize_t
-xdr_to_setattr3args (struct iovec inmsg, setattr3args *sa)
+xdr_to_setattr3args(struct iovec inmsg, setattr3args *sa)
 {
-        return xdr_to_generic (inmsg, (void *)sa,
-                                   (xdrproc_t)xdr_setattr3args);
+    return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_setattr3args);
 }
 
-
 ssize_t
-xdr_serialize_lookup3res (struct iovec outmsg, lookup3res *res)
+xdr_serialize_lookup3res(struct iovec outmsg, lookup3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_lookup3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_lookup3res);
 }
 
-
 ssize_t
-xdr_to_lookup3args (struct iovec inmsg, lookup3args *la)
+xdr_to_lookup3args(struct iovec inmsg, lookup3args *la)
 {
-        return xdr_to_generic (inmsg, (void *)la,
-                                   (xdrproc_t)xdr_lookup3args);
+    return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_lookup3args);
 }
 
-
 ssize_t
-xdr_to_access3args (struct iovec inmsg, access3args *ac)
+xdr_to_access3args(struct iovec inmsg, access3args *ac)
 {
-        return xdr_to_generic (inmsg,(void *)ac,
-                                   (xdrproc_t)xdr_access3args);
+    return xdr_to_generic(inmsg, (void *)ac, (xdrproc_t)xdr_access3args);
 }
 
-
 ssize_t
-xdr_serialize_access3res (struct iovec outmsg, access3res *res)
+xdr_serialize_access3res(struct iovec outmsg, access3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_access3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_access3res);
 }
 
-
 ssize_t
-xdr_to_readlink3args (struct iovec inmsg, readlink3args *ra)
+xdr_to_readlink3args(struct iovec inmsg, readlink3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_readlink3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_readlink3args);
 }
 
-
 ssize_t
-xdr_serialize_readlink3res (struct iovec outmsg, readlink3res *res)
+xdr_serialize_readlink3res(struct iovec outmsg, readlink3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readlink3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readlink3res);
 }
 
-
 ssize_t
-xdr_to_read3args (struct iovec inmsg, read3args *ra)
+xdr_to_read3args(struct iovec inmsg, read3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra, (xdrproc_t)xdr_read3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_read3args);
 }
 
-
 ssize_t
-xdr_serialize_read3res (struct iovec outmsg, read3res *res)
+xdr_serialize_read3res(struct iovec outmsg, read3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_read3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_read3res);
 }
 
 ssize_t
-xdr_serialize_read3res_nocopy (struct iovec outmsg, read3res *res)
+xdr_serialize_read3res_nocopy(struct iovec outmsg, read3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_read3res_nocopy);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_read3res_nocopy);
 }
 
-
 ssize_t
-xdr_to_write3args (struct iovec inmsg, write3args *wa)
+xdr_to_write3args(struct iovec inmsg, write3args *wa)
 {
-        return xdr_to_generic (inmsg, (void *)wa,(xdrproc_t)xdr_write3args);
+    return xdr_to_generic(inmsg, (void *)wa, (xdrproc_t)xdr_write3args);
 }
 
-
 ssize_t
-xdr_to_write3args_nocopy (struct iovec inmsg, write3args *wa,
-                          struct iovec *payload)
+xdr_to_write3args_nocopy(struct iovec inmsg, write3args *wa,
+                         struct iovec *payload)
 {
-        return xdr_to_generic_payload (inmsg, (void *)wa,
-                                           (xdrproc_t)xdr_write3args, payload);
+    return xdr_to_generic_payload(inmsg, (void *)wa, (xdrproc_t)xdr_write3args,
+                                  payload);
 }
 
-
 ssize_t
-xdr_serialize_write3res (struct iovec outmsg, write3res *res)
+xdr_serialize_write3res(struct iovec outmsg, write3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_write3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_write3res);
 }
 
-
 ssize_t
-xdr_to_create3args (struct iovec inmsg, create3args *ca)
+xdr_to_create3args(struct iovec inmsg, create3args *ca)
 {
-        return xdr_to_generic (inmsg, (void *)ca,
-                                   (xdrproc_t)xdr_create3args);
+    return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_create3args);
 }
 
-
 ssize_t
-xdr_serialize_create3res (struct iovec outmsg, create3res *res)
+xdr_serialize_create3res(struct iovec outmsg, create3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_create3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_create3res);
 }
 
-
 ssize_t
-xdr_serialize_mkdir3res (struct iovec outmsg, mkdir3res *res)
+xdr_serialize_mkdir3res(struct iovec outmsg, mkdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mkdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mkdir3res);
 }
 
-
 ssize_t
-xdr_to_mkdir3args (struct iovec inmsg, mkdir3args *ma)
+xdr_to_mkdir3args(struct iovec inmsg, mkdir3args *ma)
 {
-        return xdr_to_generic (inmsg, (void *)ma,
-                                   (xdrproc_t)xdr_mkdir3args);
+    return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mkdir3args);
 }
 
-
 ssize_t
-xdr_to_symlink3args (struct iovec inmsg, symlink3args *sa)
+xdr_to_symlink3args(struct iovec inmsg, symlink3args *sa)
 {
-        return xdr_to_generic (inmsg, (void *)sa,
-                                   (xdrproc_t)xdr_symlink3args);
+    return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_symlink3args);
 }
 
-
 ssize_t
-xdr_serialize_symlink3res (struct iovec outmsg, symlink3res *res)
+xdr_serialize_symlink3res(struct iovec outmsg, symlink3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_symlink3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_symlink3res);
 }
 
-
 ssize_t
-xdr_to_mknod3args (struct iovec inmsg, mknod3args *ma)
+xdr_to_mknod3args(struct iovec inmsg, mknod3args *ma)
 {
-        return xdr_to_generic (inmsg, (void *)ma,
-                                   (xdrproc_t)xdr_mknod3args);
+    return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mknod3args);
 }
 
-
 ssize_t
-xdr_serialize_mknod3res (struct iovec outmsg, mknod3res *res)
+xdr_serialize_mknod3res(struct iovec outmsg, mknod3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_mknod3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mknod3res);
 }
 
-
 ssize_t
-xdr_to_remove3args (struct iovec inmsg, remove3args *ra)
+xdr_to_remove3args(struct iovec inmsg, remove3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_remove3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_remove3args);
 }
 
-
 ssize_t
-xdr_serialize_remove3res (struct iovec outmsg, remove3res *res)
+xdr_serialize_remove3res(struct iovec outmsg, remove3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_remove3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_remove3res);
 }
 
-
 ssize_t
-xdr_to_rmdir3args (struct iovec inmsg, rmdir3args *ra)
+xdr_to_rmdir3args(struct iovec inmsg, rmdir3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_rmdir3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rmdir3args);
 }
 
-
 ssize_t
-xdr_serialize_rmdir3res (struct iovec outmsg, rmdir3res *res)
+xdr_serialize_rmdir3res(struct iovec outmsg, rmdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_rmdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_rmdir3res);
 }
 
-
 ssize_t
-xdr_serialize_rename3res (struct iovec outmsg, rename3res *res)
+xdr_serialize_rename3res(struct iovec outmsg, rename3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_rename3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_rename3res);
 }
 
-
 ssize_t
-xdr_to_rename3args (struct iovec inmsg, rename3args *ra)
+xdr_to_rename3args(struct iovec inmsg, rename3args *ra)
 {
-        return xdr_to_generic (inmsg, (void *)ra,
-                                   (xdrproc_t)xdr_rename3args);
+    return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rename3args);
 }
 
-
 ssize_t
-xdr_serialize_link3res (struct iovec outmsg, link3res *li)
+xdr_serialize_link3res(struct iovec outmsg, link3res *li)
 {
-        return xdr_serialize_generic (outmsg, (void *)li,
-                                          (xdrproc_t)xdr_link3res);
+    return xdr_serialize_generic(outmsg, (void *)li, (xdrproc_t)xdr_link3res);
 }
 
-
 ssize_t
-xdr_to_link3args (struct iovec inmsg, link3args *la)
+xdr_to_link3args(struct iovec inmsg, link3args *la)
 {
-        return xdr_to_generic (inmsg, (void *)la, (xdrproc_t)xdr_link3args);
+    return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_link3args);
 }
 
-
 ssize_t
-xdr_to_readdir3args (struct iovec inmsg, readdir3args *rd)
+xdr_to_readdir3args(struct iovec inmsg, readdir3args *rd)
 {
-        return xdr_to_generic (inmsg, (void *)rd,
-                                   (xdrproc_t)xdr_readdir3args);
+    return xdr_to_generic(inmsg, (void *)rd, (xdrproc_t)xdr_readdir3args);
 }
 
-
 ssize_t
-xdr_serialize_readdir3res (struct iovec outmsg, readdir3res *res)
+xdr_serialize_readdir3res(struct iovec outmsg, readdir3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readdir3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readdir3res);
 }
 
-
 ssize_t
-xdr_to_readdirp3args (struct iovec inmsg, readdirp3args *rp)
+xdr_to_readdirp3args(struct iovec inmsg, readdirp3args *rp)
 {
-        return xdr_to_generic (inmsg, (void *)rp,
-                                   (xdrproc_t)xdr_readdirp3args);
+    return xdr_to_generic(inmsg, (void *)rp, (xdrproc_t)xdr_readdirp3args);
 }
 
-
 ssize_t
-xdr_serialize_readdirp3res (struct iovec outmsg, readdirp3res *res)
+xdr_serialize_readdirp3res(struct iovec outmsg, readdirp3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_readdirp3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_readdirp3res);
 }
 
-
 ssize_t
-xdr_to_fsstat3args (struct iovec inmsg, fsstat3args *fa)
+xdr_to_fsstat3args(struct iovec inmsg, fsstat3args *fa)
 {
-        return xdr_to_generic (inmsg, (void *)fa,
-                                   (xdrproc_t)xdr_fsstat3args);
+    return xdr_to_generic(inmsg, (void *)fa, (xdrproc_t)xdr_fsstat3args);
 }
 
-
 ssize_t
-xdr_serialize_fsstat3res (struct iovec outmsg, fsstat3res *res)
+xdr_serialize_fsstat3res(struct iovec outmsg, fsstat3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_fsstat3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_fsstat3res);
 }
 
 ssize_t
-xdr_to_fsinfo3args (struct iovec inmsg, fsinfo3args *fi)
+xdr_to_fsinfo3args(struct iovec inmsg, fsinfo3args *fi)
 {
-        return xdr_to_generic (inmsg, (void *)fi,
-                                   (xdrproc_t)xdr_fsinfo3args);
+    return xdr_to_generic(inmsg, (void *)fi, (xdrproc_t)xdr_fsinfo3args);
 }
 
-
 ssize_t
-xdr_serialize_fsinfo3res (struct iovec outmsg, fsinfo3res *res)
+xdr_serialize_fsinfo3res(struct iovec outmsg, fsinfo3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_fsinfo3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_fsinfo3res);
 }
 
-
 ssize_t
-xdr_to_pathconf3args (struct iovec inmsg, pathconf3args *pc)
+xdr_to_pathconf3args(struct iovec inmsg, pathconf3args *pc)
 {
-        return xdr_to_generic (inmsg, (void *)pc,
-                                   (xdrproc_t)xdr_pathconf3args);}
-
+    return xdr_to_generic(inmsg, (void *)pc, (xdrproc_t)xdr_pathconf3args);
+}
 
 ssize_t
-xdr_serialize_pathconf3res (struct iovec outmsg, pathconf3res *res)
+xdr_serialize_pathconf3res(struct iovec outmsg, pathconf3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_pathconf3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_pathconf3res);
 }
 
-
 ssize_t
-xdr_to_commit3args (struct iovec inmsg, commit3args *ca)
+xdr_to_commit3args(struct iovec inmsg, commit3args *ca)
 {
-        return xdr_to_generic (inmsg, (void *)ca,
-                                   (xdrproc_t)xdr_commit3args);
+    return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_commit3args);
 }
 
-
 ssize_t
-xdr_serialize_commit3res (struct iovec outmsg, commit3res *res)
+xdr_serialize_commit3res(struct iovec outmsg, commit3res *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                          (xdrproc_t)xdr_commit3res);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_commit3res);
 }
 
-
 ssize_t
-xdr_serialize_exports (struct iovec outmsg, exports *elist)
+xdr_serialize_exports(struct iovec outmsg, exports *elist)
 {
-        XDR     xdr;
-        ssize_t  ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!outmsg.iov_base) || (!elist))
-                return -1;
+    if ((!outmsg.iov_base) || (!elist))
+        return -1;
 
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
+    xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
+                  XDR_ENCODE);
 
-        if (!xdr_exports (&xdr, elist))
-                goto ret;
+    if (!xdr_exports(&xdr, elist))
+        goto ret;
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_serialize_nfsstat3 (struct iovec outmsg, nfsstat3 *s)
+xdr_serialize_nfsstat3(struct iovec outmsg, nfsstat3 *s)
 {
-        return xdr_serialize_generic (outmsg, (void *)s,
-                                          (xdrproc_t)xdr_nfsstat3);
+    return xdr_serialize_generic(outmsg, (void *)s, (xdrproc_t)xdr_nfsstat3);
 }
 
 ssize_t
-xdr_to_nlm4_testargs (struct iovec inmsg, nlm4_testargs *args)
+xdr_to_nlm4_testargs(struct iovec inmsg, nlm4_testargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_testargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_testargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_testres (struct iovec outmsg, nlm4_testres *res)
+xdr_serialize_nlm4_testres(struct iovec outmsg, nlm4_testres *res)
 {
-        return xdr_serialize_generic (outmsg, (void*)res,
-                                      (xdrproc_t)xdr_nlm4_testres);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_nlm4_testres);
 }
 
 ssize_t
-xdr_to_nlm4_lockargs (struct iovec inmsg, nlm4_lockargs *args)
+xdr_to_nlm4_lockargs(struct iovec inmsg, nlm4_lockargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_lockargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_lockargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_res (struct iovec outmsg, nlm4_res *res)
+xdr_serialize_nlm4_res(struct iovec outmsg, nlm4_res *res)
 {
-        return xdr_serialize_generic (outmsg, (void*)res,
-                                      (xdrproc_t)xdr_nlm4_res);
+    return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_nlm4_res);
 }
 
 ssize_t
-xdr_to_nlm4_cancelargs (struct iovec inmsg, nlm4_cancargs *args)
+xdr_to_nlm4_cancelargs(struct iovec inmsg, nlm4_cancargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_cancargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_cancargs);
 }
 
 ssize_t
-xdr_to_nlm4_unlockargs (struct iovec inmsg, nlm4_unlockargs *args)
+xdr_to_nlm4_unlockargs(struct iovec inmsg, nlm4_unlockargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_unlockargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_unlockargs);
 }
 
 ssize_t
-xdr_to_nlm4_shareargs (struct iovec inmsg, nlm4_shareargs *args)
+xdr_to_nlm4_shareargs(struct iovec inmsg, nlm4_shareargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_shareargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_shareargs);
 }
 
 ssize_t
-xdr_serialize_nlm4_shareres (struct iovec outmsg, nlm4_shareres *res)
+xdr_serialize_nlm4_shareres(struct iovec outmsg, nlm4_shareres *res)
 {
-        return xdr_serialize_generic (outmsg, (void *)res,
-                                      (xdrproc_t)xdr_nlm4_shareres);
+    return xdr_serialize_generic(outmsg, (void *)res,
+                                 (xdrproc_t)xdr_nlm4_shareres);
 }
 
 ssize_t
-xdr_serialize_nlm4_testargs (struct iovec outmsg, nlm4_testargs *args)
+xdr_serialize_nlm4_testargs(struct iovec outmsg, nlm4_testargs *args)
 {
-        return xdr_serialize_generic (outmsg, (void*)args,
-                                      (xdrproc_t)xdr_nlm4_testargs);
+    return xdr_serialize_generic(outmsg, (void *)args,
+                                 (xdrproc_t)xdr_nlm4_testargs);
 }
 
 ssize_t
-xdr_to_nlm4_res (struct iovec inmsg, nlm4_res *args)
+xdr_to_nlm4_res(struct iovec inmsg, nlm4_res *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_res);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_res);
 }
 
 ssize_t
-xdr_to_nlm4_freeallargs (struct iovec inmsg, nlm4_freeallargs *args)
+xdr_to_nlm4_freeallargs(struct iovec inmsg, nlm4_freeallargs *args)
 {
-        return xdr_to_generic (inmsg, (void*)args,
-                               (xdrproc_t)xdr_nlm4_freeallargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_freeallargs);
 }
 
 ssize_t
-xdr_to_getaclargs (struct iovec inmsg, getaclargs *args)
+xdr_to_getaclargs(struct iovec inmsg, getaclargs *args)
 {
-        return xdr_to_generic (inmsg, (void *) args,
-                               (xdrproc_t)xdr_getaclargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_getaclargs);
 }
 
 ssize_t
-xdr_to_setaclargs (struct iovec inmsg, setaclargs *args)
+xdr_to_setaclargs(struct iovec inmsg, setaclargs *args)
 {
-        return xdr_to_generic (inmsg, (void *) args,
-                               (xdrproc_t)xdr_setaclargs);
+    return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_setaclargs);
 }
 
 ssize_t
-xdr_serialize_getaclreply (struct iovec inmsg, getaclreply *res)
+xdr_serialize_getaclreply(struct iovec inmsg, getaclreply *res)
 {
-        return xdr_serialize_generic (inmsg, (void *) res,
-                                      (xdrproc_t)xdr_getaclreply);
+    return xdr_serialize_generic(inmsg, (void *)res,
+                                 (xdrproc_t)xdr_getaclreply);
 }
 
 ssize_t
-xdr_serialize_setaclreply (struct iovec inmsg, setaclreply *res)
+xdr_serialize_setaclreply(struct iovec inmsg, setaclreply *res)
 {
-        return xdr_serialize_generic (inmsg, (void *) res,
-                                      (xdrproc_t)xdr_setaclreply);
+    return xdr_serialize_generic(inmsg, (void *)res,
+                                 (xdrproc_t)xdr_setaclreply);
 }
-
diff --git a/rpc/xdr/src/xdr-generic.c b/rpc/xdr/src/xdr-generic.c
index fd6fceb9425..20b54eb0a8a 100644
--- a/rpc/xdr/src/xdr-generic.c
+++ b/rpc/xdr/src/xdr-generic.c
@@ -8,118 +8,113 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "xdr-generic.h"
 
-
 ssize_t
-xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc)
+xdr_serialize_generic(struct iovec outmsg, void *res, xdrproc_t proc)
 {
-        ssize_t ret = -1;
-        XDR     xdr;
+    ssize_t ret = -1;
+    XDR xdr;
 
-        if ((!outmsg.iov_base) || (!res) || (!proc))
-                return -1;
+    if ((!outmsg.iov_base) || (!res) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
+    xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
+                  XDR_ENCODE);
 
-        if (!PROC(&xdr, res)) {
-                ret = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, res)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_encoded_length (xdr);
+    ret = xdr_encoded_length(xdr);
 
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc)
+xdr_to_generic(struct iovec inmsg, void *args, xdrproc_t proc)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
+    if ((!inmsg.iov_base) || (!args) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        if (!PROC (&xdr, args)) {
-                ret = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, args)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 ret:
-        return ret;
+    return ret;
 }
 
-
 ssize_t
-xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc,
-                        struct iovec *pendingpayload)
+xdr_to_generic_payload(struct iovec inmsg, void *args, xdrproc_t proc,
+                       struct iovec *pendingpayload)
 {
-        XDR     xdr;
-        ssize_t ret = -1;
+    XDR xdr;
+    ssize_t ret = -1;
 
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
+    if ((!inmsg.iov_base) || (!args) || (!proc))
+        return -1;
 
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
+    xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
+                  XDR_DECODE);
 
-        if (!PROC (&xdr, args)) {
-                ret  = -1;
-                goto ret;
-        }
+    if (!PROC(&xdr, args)) {
+        ret = -1;
+        goto ret;
+    }
 
-        ret = xdr_decoded_length (xdr);
+    ret = xdr_decoded_length(xdr);
 
-        if (pendingpayload) {
-                pendingpayload->iov_base = xdr_decoded_remaining_addr (xdr);
-                pendingpayload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
+    if (pendingpayload) {
+        pendingpayload->iov_base = xdr_decoded_remaining_addr(xdr);
+        pendingpayload->iov_len = xdr_decoded_remaining_len(xdr);
+    }
 
 ret:
-        return ret;
+    return ret;
 }
 
 ssize_t
-xdr_length_round_up (size_t len, size_t bufsize)
+xdr_length_round_up(size_t len, size_t bufsize)
 {
-        int     roundup = 0;
+    int roundup = 0;
 
-        roundup = len % XDR_BYTES_PER_UNIT;
-        if (roundup > 0)
-                roundup = XDR_BYTES_PER_UNIT - roundup;
+    roundup = len % XDR_BYTES_PER_UNIT;
+    if (roundup > 0)
+        roundup = XDR_BYTES_PER_UNIT - roundup;
 
-        if ((roundup > 0) && ((roundup + len) <= bufsize))
-                len += roundup;
+    if ((roundup > 0) && ((roundup + len) <= bufsize))
+        len += roundup;
 
-        return len;
+    return len;
 }
 
 int
-xdr_bytes_round_up (struct iovec *vec, size_t bufsize)
+xdr_bytes_round_up(struct iovec *vec, size_t bufsize)
 {
-        vec->iov_len = xdr_length_round_up (vec->iov_len, bufsize);
-        return 0;
+    vec->iov_len = xdr_length_round_up(vec->iov_len, bufsize);
+    return 0;
 }
 
-
 void
-xdr_vector_round_up (struct iovec *vec, int vcount, uint32_t count)
+xdr_vector_round_up(struct iovec *vec, int vcount, uint32_t count)
 {
-        uint32_t round_count = 0;
+    uint32_t round_count = 0;
 
-        round_count = xdr_length_round_up (count, 1048576);
-        round_count -= count;
-        if (round_count == 0 || vcount <= 0)
-                return;
+    round_count = xdr_length_round_up(count, 1048576);
+    round_count -= count;
+    if (round_count == 0 || vcount <= 0)
+        return;
 
-        vec[vcount-1].iov_len += round_count;
+    vec[vcount - 1].iov_len += round_count;
 }
diff --git a/rpc/xdr/src/xdr-nfs3.c b/rpc/xdr/src/xdr-nfs3.c
index 01ccb236993..aca9a299b0e 100644
--- a/rpc/xdr/src/xdr-nfs3.c
+++ b/rpc/xdr/src/xdr-nfs3.c
@@ -27,1877 +27,1881 @@
 #include "xdr-common.h"
 
 bool_t
-xdr_uint64 (XDR *xdrs, uint64 *objp)
+xdr_uint64(XDR *xdrs, uint64 *objp)
 {
-	 if (!xdr_uint64_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_int64 (XDR *xdrs, int64 *objp)
+xdr_int64(XDR *xdrs, int64 *objp)
 {
-	 if (!xdr_int64_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_int64_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_uint32 (XDR *xdrs, uint32 *objp)
+xdr_uint32(XDR *xdrs, uint32 *objp)
 {
-	 if (!xdr_uint32_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_int32 (XDR *xdrs, int32 *objp)
+xdr_int32(XDR *xdrs, int32 *objp)
 {
-	 if (!xdr_int32_t (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_int32_t(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_filename3 (XDR *xdrs, filename3 *objp)
+xdr_filename3(XDR *xdrs, filename3 *objp)
 {
-	 if (!xdr_string (xdrs, objp, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfspath3 (XDR *xdrs, nfspath3 *objp)
+xdr_nfspath3(XDR *xdrs, nfspath3 *objp)
 {
-	 if (!xdr_string (xdrs, objp, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fileid3 (XDR *xdrs, fileid3 *objp)
+xdr_fileid3(XDR *xdrs, fileid3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_cookie3 (XDR *xdrs, cookie3 *objp)
+xdr_cookie3(XDR *xdrs, cookie3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_cookieverf3 (XDR *xdrs, cookieverf3 objp)
+xdr_cookieverf3(XDR *xdrs, cookieverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_COOKIEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createverf3 (XDR *xdrs, createverf3 objp)
+xdr_createverf3(XDR *xdrs, createverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_CREATEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_writeverf3 (XDR *xdrs, writeverf3 objp)
+xdr_writeverf3(XDR *xdrs, writeverf3 objp)
 {
-	 if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_opaque(xdrs, objp, NFS3_WRITEVERFSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_uid3 (XDR *xdrs, uid3 *objp)
+xdr_uid3(XDR *xdrs, uid3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_gid3 (XDR *xdrs, gid3 *objp)
+xdr_gid3(XDR *xdrs, gid3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_size3 (XDR *xdrs, size3 *objp)
+xdr_size3(XDR *xdrs, size3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_offset3 (XDR *xdrs, offset3 *objp)
+xdr_offset3(XDR *xdrs, offset3 *objp)
 {
-	 if (!xdr_uint64 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint64(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mode3 (XDR *xdrs, mode3 *objp)
+xdr_mode3(XDR *xdrs, mode3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_count3 (XDR *xdrs, count3 *objp)
+xdr_count3(XDR *xdrs, count3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfsstat3 (XDR *xdrs, nfsstat3 *objp)
+xdr_nfsstat3(XDR *xdrs, nfsstat3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_ftype3 (XDR *xdrs, ftype3 *objp)
+xdr_ftype3(XDR *xdrs, ftype3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_specdata3 (XDR *xdrs, specdata3 *objp)
+xdr_specdata3(XDR *xdrs, specdata3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, &objp->specdata1))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->specdata2))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, &objp->specdata1))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->specdata2))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfs_fh3 (XDR *xdrs, nfs_fh3 *objp)
+xdr_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
 {
-	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
+                   (u_int *)&objp->data.data_len, NFS3_FHSIZE))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_nfstime3 (XDR *xdrs, nfstime3 *objp)
+xdr_nfstime3(XDR *xdrs, nfstime3 *objp)
 {
-	 if (!xdr_uint32 (xdrs, &objp->seconds))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->nseconds))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_uint32(xdrs, &objp->seconds))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->nseconds))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fattr3 (XDR *xdrs, fattr3 *objp)
+xdr_fattr3(XDR *xdrs, fattr3 *objp)
 {
-	 if (!xdr_ftype3 (xdrs, &objp->type))
-		 return FALSE;
-	 if (!xdr_mode3 (xdrs, &objp->mode))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->nlink))
-		 return FALSE;
-	 if (!xdr_uid3 (xdrs, &objp->uid))
-		 return FALSE;
-	 if (!xdr_gid3 (xdrs, &objp->gid))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->used))
-		 return FALSE;
-	 if (!xdr_specdata3 (xdrs, &objp->rdev))
-		 return FALSE;
-	 if (!xdr_uint64 (xdrs, &objp->fsid))
-		 return FALSE;
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->atime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->mtime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->ctime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_ftype3(xdrs, &objp->type))
+        return FALSE;
+    if (!xdr_mode3(xdrs, &objp->mode))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->nlink))
+        return FALSE;
+    if (!xdr_uid3(xdrs, &objp->uid))
+        return FALSE;
+    if (!xdr_gid3(xdrs, &objp->gid))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->used))
+        return FALSE;
+    if (!xdr_specdata3(xdrs, &objp->rdev))
+        return FALSE;
+    if (!xdr_uint64(xdrs, &objp->fsid))
+        return FALSE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->atime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->mtime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->ctime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_post_op_attr (XDR *xdrs, post_op_attr *objp)
+xdr_post_op_attr(XDR *xdrs, post_op_attr *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->attributes_follow))
-		 return FALSE;
-	switch (objp->attributes_follow) {
-	case TRUE:
-		 if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->attributes_follow))
+        return FALSE;
+    switch (objp->attributes_follow) {
+        case TRUE:
+            if (!xdr_fattr3(xdrs, &objp->post_op_attr_u.attributes))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_wcc_attr (XDR *xdrs, wcc_attr *objp)
+xdr_wcc_attr(XDR *xdrs, wcc_attr *objp)
 {
-	 if (!xdr_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->mtime))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->ctime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->mtime))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->ctime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pre_op_attr (XDR *xdrs, pre_op_attr *objp)
+xdr_pre_op_attr(XDR *xdrs, pre_op_attr *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->attributes_follow))
-		 return FALSE;
-	switch (objp->attributes_follow) {
-	case TRUE:
-		 if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->attributes_follow))
+        return FALSE;
+    switch (objp->attributes_follow) {
+        case TRUE:
+            if (!xdr_wcc_attr(xdrs, &objp->pre_op_attr_u.attributes))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_wcc_data (XDR *xdrs, wcc_data *objp)
+xdr_wcc_data(XDR *xdrs, wcc_data *objp)
 {
-	 if (!xdr_pre_op_attr (xdrs, &objp->before))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->after))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pre_op_attr(xdrs, &objp->before))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->after))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_post_op_fh3 (XDR *xdrs, post_op_fh3 *objp)
-{
-	 if (!xdr_bool (xdrs, &objp->handle_follows))
-		 return FALSE;
-	switch (objp->handle_follows) {
-	case TRUE:
-		 if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
-}
-
-bool_t
-xdr_time_how (XDR *xdrs, time_how *objp)
-{
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+xdr_post_op_fh3(XDR *xdrs, post_op_fh3 *objp)
+{
+    if (!xdr_bool(xdrs, &objp->handle_follows))
+        return FALSE;
+    switch (objp->handle_follows) {
+        case TRUE:
+            if (!xdr_nfs_fh3(xdrs, &objp->post_op_fh3_u.handle))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
+}
+
+bool_t
+xdr_time_how(XDR *xdrs, time_how *objp)
+{
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_set_mode3 (XDR *xdrs, set_mode3 *objp)
+xdr_set_mode3(XDR *xdrs, set_mode3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_mode3(xdrs, &objp->set_mode3_u.mode))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_uid3 (XDR *xdrs, set_uid3 *objp)
+xdr_set_uid3(XDR *xdrs, set_uid3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_uid3(xdrs, &objp->set_uid3_u.uid))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_gid3 (XDR *xdrs, set_gid3 *objp)
+xdr_set_gid3(XDR *xdrs, set_gid3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_gid3(xdrs, &objp->set_gid3_u.gid))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_size3 (XDR *xdrs, set_size3 *objp)
+xdr_set_size3(XDR *xdrs, set_size3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case TRUE:
-		 if (!xdr_size3 (xdrs, &objp->set_size3_u.size))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case TRUE:
+            if (!xdr_size3(xdrs, &objp->set_size3_u.size))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_atime (XDR *xdrs, set_atime *objp)
+xdr_set_atime(XDR *xdrs, set_atime *objp)
 {
-	 if (!xdr_time_how (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case SET_TO_CLIENT_TIME:
-		 if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_time_how(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case SET_TO_CLIENT_TIME:
+            if (!xdr_nfstime3(xdrs, &objp->set_atime_u.atime))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_set_mtime (XDR *xdrs, set_mtime *objp)
+xdr_set_mtime(XDR *xdrs, set_mtime *objp)
 {
-	 if (!xdr_time_how (xdrs, &objp->set_it))
-		 return FALSE;
-	switch (objp->set_it) {
-	case SET_TO_CLIENT_TIME:
-		 if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_time_how(xdrs, &objp->set_it))
+        return FALSE;
+    switch (objp->set_it) {
+        case SET_TO_CLIENT_TIME:
+            if (!xdr_nfstime3(xdrs, &objp->set_mtime_u.mtime))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_sattr3 (XDR *xdrs, sattr3 *objp)
+xdr_sattr3(XDR *xdrs, sattr3 *objp)
 {
-	 if (!xdr_set_mode3 (xdrs, &objp->mode))
-		 return FALSE;
-	 if (!xdr_set_uid3 (xdrs, &objp->uid))
-		 return FALSE;
-	 if (!xdr_set_gid3 (xdrs, &objp->gid))
-		 return FALSE;
-	 if (!xdr_set_size3 (xdrs, &objp->size))
-		 return FALSE;
-	 if (!xdr_set_atime (xdrs, &objp->atime))
-		 return FALSE;
-	 if (!xdr_set_mtime (xdrs, &objp->mtime))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_set_mode3(xdrs, &objp->mode))
+        return FALSE;
+    if (!xdr_set_uid3(xdrs, &objp->uid))
+        return FALSE;
+    if (!xdr_set_gid3(xdrs, &objp->gid))
+        return FALSE;
+    if (!xdr_set_size3(xdrs, &objp->size))
+        return FALSE;
+    if (!xdr_set_atime(xdrs, &objp->atime))
+        return FALSE;
+    if (!xdr_set_mtime(xdrs, &objp->mtime))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_diropargs3 (XDR *xdrs, diropargs3 *objp)
+xdr_diropargs3(XDR *xdrs, diropargs3 *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3args (XDR *xdrs, getattr3args *objp)
+xdr_getattr3args(XDR *xdrs, getattr3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3resok (XDR *xdrs, getattr3resok *objp)
+xdr_getattr3resok(XDR *xdrs, getattr3resok *objp)
 {
-	 if (!xdr_fattr3 (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fattr3(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_getattr3res (XDR *xdrs, getattr3res *objp)
+xdr_getattr3res(XDR *xdrs, getattr3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_getattr3resok (xdrs, &objp->getattr3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_getattr3resok(xdrs, &objp->getattr3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_sattrguard3 (XDR *xdrs, sattrguard3 *objp)
+xdr_sattrguard3(XDR *xdrs, sattrguard3 *objp)
 {
-	 if (!xdr_bool (xdrs, &objp->check))
-		 return FALSE;
-	switch (objp->check) {
-	case TRUE:
-		 if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime))
-			 return FALSE;
-		break;
-	case FALSE:
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_bool(xdrs, &objp->check))
+        return FALSE;
+    switch (objp->check) {
+        case TRUE:
+            if (!xdr_nfstime3(xdrs, &objp->sattrguard3_u.obj_ctime))
+                return FALSE;
+            break;
+        case FALSE:
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3args (XDR *xdrs, setattr3args *objp)
+xdr_setattr3args(XDR *xdrs, setattr3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_sattr3 (xdrs, &objp->new_attributes))
-		 return FALSE;
-	 if (!xdr_sattrguard3 (xdrs, &objp->guard))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_sattr3(xdrs, &objp->new_attributes))
+        return FALSE;
+    if (!xdr_sattrguard3(xdrs, &objp->guard))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3resok (XDR *xdrs, setattr3resok *objp)
+xdr_setattr3resok(XDR *xdrs, setattr3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->obj_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->obj_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3resfail (XDR *xdrs, setattr3resfail *objp)
+xdr_setattr3resfail(XDR *xdrs, setattr3resfail *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->obj_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->obj_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_setattr3res (XDR *xdrs, setattr3res *objp)
+xdr_setattr3res(XDR *xdrs, setattr3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_setattr3resok (xdrs, &objp->setattr3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_setattr3resfail (xdrs, &objp->setattr3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_setattr3resok(xdrs, &objp->setattr3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_setattr3resfail(xdrs, &objp->setattr3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3args (XDR *xdrs, lookup3args *objp)
+xdr_lookup3args(XDR *xdrs, lookup3args *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->what))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->what))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3resok (XDR *xdrs, lookup3resok *objp)
+xdr_lookup3resok(XDR *xdrs, lookup3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3resfail (XDR *xdrs, lookup3resfail *objp)
+xdr_lookup3resfail(XDR *xdrs, lookup3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_lookup3res (XDR *xdrs, lookup3res *objp)
+xdr_lookup3res(XDR *xdrs, lookup3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_lookup3resok (xdrs, &objp->lookup3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_lookup3resfail (xdrs, &objp->lookup3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_lookup3resok(xdrs, &objp->lookup3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_lookup3resfail(xdrs, &objp->lookup3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_access3args (XDR *xdrs, access3args *objp)
+xdr_access3args(XDR *xdrs, access3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->access))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->access))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3resok (XDR *xdrs, access3resok *objp)
+xdr_access3resok(XDR *xdrs, access3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->access))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->access))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3resfail (XDR *xdrs, access3resfail *objp)
+xdr_access3resfail(XDR *xdrs, access3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_access3res (XDR *xdrs, access3res *objp)
+xdr_access3res(XDR *xdrs, access3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_access3resok (xdrs, &objp->access3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_access3resfail (xdrs, &objp->access3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_access3resok(xdrs, &objp->access3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_access3resfail(xdrs, &objp->access3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3args (XDR *xdrs, readlink3args *objp)
+xdr_readlink3args(XDR *xdrs, readlink3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->symlink))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->symlink))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3resok (XDR *xdrs, readlink3resok *objp)
+xdr_readlink3resok(XDR *xdrs, readlink3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	 if (!xdr_nfspath3 (xdrs, &objp->data))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    if (!xdr_nfspath3(xdrs, &objp->data))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3resfail (XDR *xdrs, readlink3resfail *objp)
+xdr_readlink3resfail(XDR *xdrs, readlink3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readlink3res (XDR *xdrs, readlink3res *objp)
+xdr_readlink3res(XDR *xdrs, readlink3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readlink3resok (xdrs, &objp->readlink3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readlink3resfail (xdrs, &objp->readlink3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readlink3resok(xdrs, &objp->readlink3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readlink3resfail(xdrs, &objp->readlink3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_read3args (XDR *xdrs, read3args *objp)
+xdr_read3args(XDR *xdrs, read3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_read3resok_nocopy (XDR *xdrs, read3resok *objp)
+xdr_read3resok_nocopy(XDR *xdrs, read3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-         if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len))
-                 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len))
+        return FALSE;
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3resok (XDR *xdrs, read3resok *objp)
+xdr_read3resok(XDR *xdrs, read3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
+                   (u_int *)&objp->data.data_len, ~0))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_read3resfail (XDR *xdrs, read3resfail *objp)
+xdr_read3resfail(XDR *xdrs, read3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3res_nocopy (XDR *xdrs, read3res *objp)
+xdr_read3res_nocopy(XDR *xdrs, read3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_read3resok_nocopy (xdrs, &objp->read3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_read3resok_nocopy(xdrs, &objp->read3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
-
 bool_t
-xdr_read3res (XDR *xdrs, read3res *objp)
+xdr_read3res(XDR *xdrs, read3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_read3resok (xdrs, &objp->read3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_read3resok(xdrs, &objp->read3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_stable_how (XDR *xdrs, stable_how *objp)
+xdr_stable_how(XDR *xdrs, stable_how *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_write3args (XDR *xdrs, write3args *objp)
+xdr_write3args(XDR *xdrs, write3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_stable_how (xdrs, &objp->stable))
-		 return FALSE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_stable_how(xdrs, &objp->stable))
+        return FALSE;
+
+    /* Added specifically to avoid copies from the xdr buffer into
+     * the write3args structure, which will also require an already
+     * allocated buffer. That is not optimal.
+     */
+    if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len))
+        return FALSE;
 
-         /* Added specifically to avoid copies from the xdr buffer into
-          * the write3args structure, which will also require an already
-          * allocated buffer. That is not optimal.
-          */
-         if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len))
-                 return FALSE;
+    /* The remaining bytes in the xdr buffer are the bytes that need to be
+     * written. See how these bytes are extracted in the xdr_to_write3args
+     * code path. Be careful, while using the write3args structure, since
+     * only the data.data_len has been filled. The actual data is
+     * extracted in xdr_to_write3args path.
+     */
 
-         /* The remaining bytes in the xdr buffer are the bytes that need to be
-          * written. See how these bytes are extracted in the xdr_to_write3args
-          * code path. Be careful, while using the write3args structure, since
-          * only the data.data_len has been filled. The actual data is
-          * extracted in xdr_to_write3args path.
-          */
+    /*	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *)
+       &objp->data.data_len, ~0)) return FALSE;
+            */
+    return TRUE;
+}
 
-         /*	 if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
-		 return FALSE;
-                 */
-	return TRUE;
+bool_t
+xdr_write3resok(XDR *xdrs, write3resok *objp)
+{
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    if (!xdr_stable_how(xdrs, &objp->committed))
+        return FALSE;
+    if (!xdr_writeverf3(xdrs, objp->verf))
+        return FALSE;
+    return TRUE;
+}
+
+bool_t
+xdr_write3resfail(XDR *xdrs, write3resfail *objp)
+{
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    return TRUE;
+}
+
+bool_t
+xdr_write3res(XDR *xdrs, write3res *objp)
+{
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_write3resok(xdrs, &objp->write3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_write3resfail(xdrs, &objp->write3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_write3resok (XDR *xdrs, write3resok *objp)
+xdr_createmode3(XDR *xdrs, createmode3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	 if (!xdr_stable_how (xdrs, &objp->committed))
-		 return FALSE;
-	 if (!xdr_writeverf3 (xdrs, objp->verf))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_write3resfail (XDR *xdrs, write3resfail *objp)
+xdr_createhow3(XDR *xdrs, createhow3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_createmode3(xdrs, &objp->mode))
+        return FALSE;
+    switch (objp->mode) {
+        case UNCHECKED:
+        case GUARDED:
+            if (!xdr_sattr3(xdrs, &objp->createhow3_u.obj_attributes))
+                return FALSE;
+            break;
+        case EXCLUSIVE:
+            if (!xdr_createverf3(xdrs, objp->createhow3_u.verf))
+                return FALSE;
+            break;
+        default:
+            return FALSE;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_write3res (XDR *xdrs, write3res *objp)
+xdr_create3args(XDR *xdrs, create3args *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_write3resok (xdrs, &objp->write3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_write3resfail (xdrs, &objp->write3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_createhow3(xdrs, &objp->how))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createmode3 (XDR *xdrs, createmode3 *objp)
+xdr_create3resok(XDR *xdrs, create3resok *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_createhow3 (XDR *xdrs, createhow3 *objp)
+xdr_create3resfail(XDR *xdrs, create3resfail *objp)
 {
-	 if (!xdr_createmode3 (xdrs, &objp->mode))
-		 return FALSE;
-	switch (objp->mode) {
-	case UNCHECKED:
-	case GUARDED:
-		 if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes))
-			 return FALSE;
-		break;
-	case EXCLUSIVE:
-		 if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf))
-			 return FALSE;
-		break;
-	default:
-		return FALSE;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3args (XDR *xdrs, create3args *objp)
+xdr_create3res(XDR *xdrs, create3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_createhow3 (xdrs, &objp->how))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_create3resok(xdrs, &objp->create3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_create3resfail(xdrs, &objp->create3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_create3resok (XDR *xdrs, create3resok *objp)
+xdr_mkdir3args(XDR *xdrs, mkdir3args *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_sattr3(xdrs, &objp->attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3resfail (XDR *xdrs, create3resfail *objp)
+xdr_mkdir3resok(XDR *xdrs, mkdir3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_create3res (XDR *xdrs, create3res *objp)
+xdr_mkdir3resfail(XDR *xdrs, mkdir3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_create3resok (xdrs, &objp->create3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_create3resfail (xdrs, &objp->create3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3args (XDR *xdrs, mkdir3args *objp)
+xdr_mkdir3res(XDR *xdrs, mkdir3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_sattr3 (xdrs, &objp->attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_mkdir3resok(xdrs, &objp->mkdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_mkdir3resfail(xdrs, &objp->mkdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3resok (XDR *xdrs, mkdir3resok *objp)
+xdr_symlinkdata3(XDR *xdrs, symlinkdata3 *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_sattr3(xdrs, &objp->symlink_attributes))
+        return FALSE;
+    if (!xdr_nfspath3(xdrs, &objp->symlink_data))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3resfail (XDR *xdrs, mkdir3resfail *objp)
+xdr_symlink3args(XDR *xdrs, symlink3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_symlinkdata3(xdrs, &objp->symlink))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mkdir3res (XDR *xdrs, mkdir3res *objp)
+xdr_symlink3resok(XDR *xdrs, symlink3resok *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_mkdir3resok (xdrs, &objp->mkdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_mkdir3resfail (xdrs, &objp->mkdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlinkdata3 (XDR *xdrs, symlinkdata3 *objp)
+xdr_symlink3resfail(XDR *xdrs, symlink3resfail *objp)
 {
-	 if (!xdr_sattr3 (xdrs, &objp->symlink_attributes))
-		 return FALSE;
-	 if (!xdr_nfspath3 (xdrs, &objp->symlink_data))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3args (XDR *xdrs, symlink3args *objp)
+xdr_symlink3res(XDR *xdrs, symlink3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_symlinkdata3 (xdrs, &objp->symlink))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_symlink3resok(xdrs, &objp->symlink3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_symlink3resfail(xdrs, &objp->symlink3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3resok (XDR *xdrs, symlink3resok *objp)
+xdr_devicedata3(XDR *xdrs, devicedata3 *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_sattr3(xdrs, &objp->dev_attributes))
+        return FALSE;
+    if (!xdr_specdata3(xdrs, &objp->spec))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3resfail (XDR *xdrs, symlink3resfail *objp)
+xdr_mknoddata3(XDR *xdrs, mknoddata3 *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_ftype3(xdrs, &objp->type))
+        return FALSE;
+    switch (objp->type) {
+        case NF3CHR:
+        case NF3BLK:
+            if (!xdr_devicedata3(xdrs, &objp->mknoddata3_u.device))
+                return FALSE;
+            break;
+        case NF3SOCK:
+        case NF3FIFO:
+            if (!xdr_sattr3(xdrs, &objp->mknoddata3_u.pipe_attributes))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_symlink3res (XDR *xdrs, symlink3res *objp)
+xdr_mknod3args(XDR *xdrs, mknod3args *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_symlink3resok (xdrs, &objp->symlink3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_symlink3resfail (xdrs, &objp->symlink3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->where))
+        return FALSE;
+    if (!xdr_mknoddata3(xdrs, &objp->what))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_devicedata3 (XDR *xdrs, devicedata3 *objp)
+xdr_mknod3resok(XDR *xdrs, mknod3resok *objp)
 {
-	 if (!xdr_sattr3 (xdrs, &objp->dev_attributes))
-		 return FALSE;
-	 if (!xdr_specdata3 (xdrs, &objp->spec))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_fh3(xdrs, &objp->obj))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknoddata3 (XDR *xdrs, mknoddata3 *objp)
+xdr_mknod3resfail(XDR *xdrs, mknod3resfail *objp)
 {
-	 if (!xdr_ftype3 (xdrs, &objp->type))
-		 return FALSE;
-	switch (objp->type) {
-	case NF3CHR:
-	case NF3BLK:
-		 if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.device))
-			 return FALSE;
-		break;
-	case NF3SOCK:
-	case NF3FIFO:
-		 if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3args (XDR *xdrs, mknod3args *objp)
+xdr_mknod3res(XDR *xdrs, mknod3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->where))
-		 return FALSE;
-	 if (!xdr_mknoddata3 (xdrs, &objp->what))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_mknod3resok(xdrs, &objp->mknod3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_mknod3resfail(xdrs, &objp->mknod3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3resok (XDR *xdrs, mknod3resok *objp)
+xdr_remove3args(XDR *xdrs, remove3args *objp)
 {
-	 if (!xdr_post_op_fh3 (xdrs, &objp->obj))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3resfail (XDR *xdrs, mknod3resfail *objp)
+xdr_remove3resok(XDR *xdrs, remove3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mknod3res (XDR *xdrs, mknod3res *objp)
+xdr_remove3resfail(XDR *xdrs, remove3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_mknod3resok (xdrs, &objp->mknod3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_mknod3resfail (xdrs, &objp->mknod3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3args (XDR *xdrs, remove3args *objp)
+xdr_remove3res(XDR *xdrs, remove3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_remove3resok(xdrs, &objp->remove3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_remove3resfail(xdrs, &objp->remove3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_remove3resok (XDR *xdrs, remove3resok *objp)
+xdr_rmdir3args(XDR *xdrs, rmdir3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3resfail (XDR *xdrs, remove3resfail *objp)
+xdr_rmdir3resok(XDR *xdrs, rmdir3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_remove3res (XDR *xdrs, remove3res *objp)
+xdr_rmdir3resfail(XDR *xdrs, rmdir3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_remove3resok (xdrs, &objp->remove3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_remove3resfail (xdrs, &objp->remove3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->dir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3args (XDR *xdrs, rmdir3args *objp)
+xdr_rmdir3res(XDR *xdrs, rmdir3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_rmdir3resok(xdrs, &objp->rmdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_rmdir3resfail(xdrs, &objp->rmdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3resok (XDR *xdrs, rmdir3resok *objp)
+xdr_rename3args(XDR *xdrs, rename3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_diropargs3(xdrs, &objp->from))
+        return FALSE;
+    if (!xdr_diropargs3(xdrs, &objp->to))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3resfail (XDR *xdrs, rmdir3resfail *objp)
+xdr_rename3resok(XDR *xdrs, rename3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->dir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->todir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rmdir3res (XDR *xdrs, rmdir3res *objp)
+xdr_rename3resfail(XDR *xdrs, rename3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_rmdir3resok (xdrs, &objp->rmdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_rmdir3resfail (xdrs, &objp->rmdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->todir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3args (XDR *xdrs, rename3args *objp)
+xdr_rename3res(XDR *xdrs, rename3res *objp)
 {
-	 if (!xdr_diropargs3 (xdrs, &objp->from))
-		 return FALSE;
-	 if (!xdr_diropargs3 (xdrs, &objp->to))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_rename3resok(xdrs, &objp->rename3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_rename3resfail(xdrs, &objp->rename3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_rename3resok (XDR *xdrs, rename3resok *objp)
+xdr_link3args(XDR *xdrs, link3args *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->todir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_diropargs3(xdrs, &objp->link))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3resfail (XDR *xdrs, rename3resfail *objp)
+xdr_link3resok(XDR *xdrs, link3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->todir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_rename3res (XDR *xdrs, rename3res *objp)
+xdr_link3resfail(XDR *xdrs, link3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_rename3resok (xdrs, &objp->rename3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_rename3resfail (xdrs, &objp->rename3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->file_attributes))
+        return FALSE;
+    if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3args (XDR *xdrs, link3args *objp)
+xdr_link3res(XDR *xdrs, link3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_diropargs3 (xdrs, &objp->link))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_link3resok(xdrs, &objp->link3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_link3resfail(xdrs, &objp->link3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_link3resok (XDR *xdrs, link3resok *objp)
+xdr_readdir3args(XDR *xdrs, readdir3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3resfail (XDR *xdrs, link3resfail *objp)
+xdr_entry3(XDR *xdrs, entry3 *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->file_attributes))
-		 return FALSE;
-	 if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entry3),
+                     (xdrproc_t)xdr_entry3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_link3res (XDR *xdrs, link3res *objp)
+xdr_dirlist3(XDR *xdrs, dirlist3 *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_link3resok (xdrs, &objp->link3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_link3resfail (xdrs, &objp->link3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entry3),
+                     (xdrproc_t)xdr_entry3))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3args (XDR *xdrs, readdir3args *objp)
+xdr_readdir3resok(XDR *xdrs, readdir3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_dirlist3(xdrs, &objp->reply))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_entry3 (XDR *xdrs, entry3 *objp)
+xdr_readdir3resfail(XDR *xdrs, readdir3resfail *objp)
 {
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirlist3 (XDR *xdrs, dirlist3 *objp)
+xdr_readdir3res(XDR *xdrs, readdir3res *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readdir3resok(xdrs, &objp->readdir3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readdir3resfail(xdrs, &objp->readdir3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3resok (XDR *xdrs, readdir3resok *objp)
+xdr_readdirp3args(XDR *xdrs, readdirp3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_dirlist3 (xdrs, &objp->reply))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->dir))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->dircount))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->maxcount))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3resfail (XDR *xdrs, readdir3resfail *objp)
+xdr_entryp3(XDR *xdrs, entryp3 *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fileid3(xdrs, &objp->fileid))
+        return FALSE;
+    if (!xdr_filename3(xdrs, &objp->name))
+        return FALSE;
+    if (!xdr_cookie3(xdrs, &objp->cookie))
+        return FALSE;
+    if (!xdr_post_op_attr(xdrs, &objp->name_attributes))
+        return FALSE;
+    if (!xdr_post_op_fh3(xdrs, &objp->name_handle))
+        return FALSE;
+    if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entryp3),
+                     (xdrproc_t)xdr_entryp3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdir3res (XDR *xdrs, readdir3res *objp)
+xdr_dirlistp3(XDR *xdrs, dirlistp3 *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readdir3resok (xdrs, &objp->readdir3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readdir3resfail (xdrs, &objp->readdir3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entryp3),
+                     (xdrproc_t)xdr_entryp3))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->eof))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3args (XDR *xdrs, readdirp3args *objp)
+xdr_readdirp3resok(XDR *xdrs, readdirp3resok *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->dir))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->dircount))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->maxcount))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    if (!xdr_cookieverf3(xdrs, objp->cookieverf))
+        return FALSE;
+    if (!xdr_dirlistp3(xdrs, &objp->reply))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_entryp3 (XDR *xdrs, entryp3 *objp)
+xdr_readdirp3resfail(XDR *xdrs, readdirp3resfail *objp)
 {
-	 if (!xdr_fileid3 (xdrs, &objp->fileid))
-		 return FALSE;
-	 if (!xdr_filename3 (xdrs, &objp->name))
-		 return FALSE;
-	 if (!xdr_cookie3 (xdrs, &objp->cookie))
-		 return FALSE;
-	 if (!xdr_post_op_attr (xdrs, &objp->name_attributes))
-		 return FALSE;
-	 if (!xdr_post_op_fh3 (xdrs, &objp->name_handle))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entryp3), (xdrproc_t) xdr_entryp3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirlistp3 (XDR *xdrs, dirlistp3 *objp)
+xdr_readdirp3res(XDR *xdrs, readdirp3res *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryp3), (xdrproc_t) xdr_entryp3))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->eof))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_readdirp3resok(xdrs, &objp->readdirp3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_readdirp3resfail(xdrs, &objp->readdirp3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3resok (XDR *xdrs, readdirp3resok *objp)
+xdr_fsstat3args(XDR *xdrs, fsstat3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	 if (!xdr_cookieverf3 (xdrs, objp->cookieverf))
-		 return FALSE;
-	 if (!xdr_dirlistp3 (xdrs, &objp->reply))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->fsroot))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3resfail (XDR *xdrs, readdirp3resfail *objp)
+xdr_fsstat3resok(XDR *xdrs, fsstat3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->dir_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->tbytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->fbytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->abytes))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->tfiles))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->ffiles))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->afiles))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->invarsec))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_readdirp3res (XDR *xdrs, readdirp3res *objp)
+xdr_fsstat3resfail(XDR *xdrs, fsstat3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_readdirp3resok (xdrs, &objp->readdirp3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_readdirp3resfail (xdrs, &objp->readdirp3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3args (XDR *xdrs, fsstat3args *objp)
+xdr_fsstat3res(XDR *xdrs, fsstat3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->fsroot))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_fsstat3resok(xdrs, &objp->fsstat3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_fsstat3resfail(xdrs, &objp->fsstat3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3resok (XDR *xdrs, fsstat3resok *objp)
+xdr_fsinfo3args(XDR *xdrs, fsinfo3args *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->tbytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->fbytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->abytes))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->tfiles))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->ffiles))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->afiles))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->invarsec))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->fsroot))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3resfail (XDR *xdrs, fsstat3resfail *objp)
+xdr_fsinfo3resok(XDR *xdrs, fsinfo3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtpref))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->rtmult))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtpref))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->wtmult))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->dtpref))
+        return FALSE;
+    if (!xdr_size3(xdrs, &objp->maxfilesize))
+        return FALSE;
+    if (!xdr_nfstime3(xdrs, &objp->time_delta))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->properties))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsstat3res (XDR *xdrs, fsstat3res *objp)
+xdr_fsinfo3resfail(XDR *xdrs, fsinfo3resfail *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_fsstat3resok (xdrs, &objp->fsstat3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_fsstat3resfail (xdrs, &objp->fsstat3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsinfo3args (XDR *xdrs, fsinfo3args *objp)
+xdr_fsinfo3res(XDR *xdrs, fsinfo3res *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->fsroot))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_fsinfo3resok(xdrs, &objp->fsinfo3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_fsinfo3resfail(xdrs, &objp->fsinfo3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
+}
+
+bool_t
+xdr_pathconf3args(XDR *xdrs, pathconf3args *objp)
+{
+    if (!xdr_nfs_fh3(xdrs, &objp->object))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_fsinfo3resok (XDR *xdrs, fsinfo3resok *objp)
+xdr_pathconf3resok(XDR *xdrs, pathconf3resok *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtpref))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->rtmult))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtpref))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->wtmult))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->dtpref))
-		 return FALSE;
-	 if (!xdr_size3 (xdrs, &objp->maxfilesize))
-		 return FALSE;
-	 if (!xdr_nfstime3 (xdrs, &objp->time_delta))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->properties))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_fsinfo3resfail (XDR *xdrs, fsinfo3resfail *objp)
-{
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_fsinfo3res (XDR *xdrs, fsinfo3res *objp)
-{
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_fsinfo3resok (xdrs, &objp->fsinfo3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_fsinfo3resfail (xdrs, &objp->fsinfo3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
-}
-
-bool_t
-xdr_pathconf3args (XDR *xdrs, pathconf3args *objp)
-{
-	 if (!xdr_nfs_fh3 (xdrs, &objp->object))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_pathconf3resok (XDR *xdrs, pathconf3resok *objp)
-{
-	register int32_t *buf;
-
-
-	if (xdrs->x_op == XDR_ENCODE) {
-		 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->linkmax))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->name_max))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_bool (xdrs, &objp->no_trunc))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->chown_restricted))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_insensitive))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_preserving))
-				 return FALSE;
-		} else {
-			IXDR_PUT_BOOL(buf, objp->no_trunc);
-			IXDR_PUT_BOOL(buf, objp->chown_restricted);
-			IXDR_PUT_BOOL(buf, objp->case_insensitive);
-			IXDR_PUT_BOOL(buf, objp->case_preserving);
-		}
-		return TRUE;
-	} else if (xdrs->x_op == XDR_DECODE) {
-		 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->linkmax))
-			 return FALSE;
-		 if (!xdr_uint32 (xdrs, &objp->name_max))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_bool (xdrs, &objp->no_trunc))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->chown_restricted))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_insensitive))
-				 return FALSE;
-			 if (!xdr_bool (xdrs, &objp->case_preserving))
-				 return FALSE;
-		} else {
-			objp->no_trunc = IXDR_GET_BOOL(buf);
-			objp->chown_restricted = IXDR_GET_BOOL(buf);
-			objp->case_insensitive = IXDR_GET_BOOL(buf);
-			objp->case_preserving = IXDR_GET_BOOL(buf);
-		}
-	 return TRUE;
-	}
+    register int32_t *buf;
+
+    if (xdrs->x_op == XDR_ENCODE) {
+        if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->linkmax))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->name_max))
+            return FALSE;
+        buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
+        if (buf == NULL) {
+            if (!xdr_bool(xdrs, &objp->no_trunc))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->chown_restricted))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_insensitive))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_preserving))
+                return FALSE;
+        } else {
+            IXDR_PUT_BOOL(buf, objp->no_trunc);
+            IXDR_PUT_BOOL(buf, objp->chown_restricted);
+            IXDR_PUT_BOOL(buf, objp->case_insensitive);
+            IXDR_PUT_BOOL(buf, objp->case_preserving);
+        }
+        return TRUE;
+    } else if (xdrs->x_op == XDR_DECODE) {
+        if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->linkmax))
+            return FALSE;
+        if (!xdr_uint32(xdrs, &objp->name_max))
+            return FALSE;
+        buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
+        if (buf == NULL) {
+            if (!xdr_bool(xdrs, &objp->no_trunc))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->chown_restricted))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_insensitive))
+                return FALSE;
+            if (!xdr_bool(xdrs, &objp->case_preserving))
+                return FALSE;
+        } else {
+            objp->no_trunc = IXDR_GET_BOOL(buf);
+            objp->chown_restricted = IXDR_GET_BOOL(buf);
+            objp->case_insensitive = IXDR_GET_BOOL(buf);
+            objp->case_preserving = IXDR_GET_BOOL(buf);
+        }
+        return TRUE;
+    }
 
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->linkmax))
-		 return FALSE;
-	 if (!xdr_uint32 (xdrs, &objp->name_max))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->no_trunc))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->chown_restricted))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->case_insensitive))
-		 return FALSE;
-	 if (!xdr_bool (xdrs, &objp->case_preserving))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->linkmax))
+        return FALSE;
+    if (!xdr_uint32(xdrs, &objp->name_max))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->no_trunc))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->chown_restricted))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->case_insensitive))
+        return FALSE;
+    if (!xdr_bool(xdrs, &objp->case_preserving))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pathconf3resfail (XDR *xdrs, pathconf3resfail *objp)
+xdr_pathconf3resfail(XDR *xdrs, pathconf3resfail *objp)
 {
-	 if (!xdr_post_op_attr (xdrs, &objp->obj_attributes))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_pathconf3res (XDR *xdrs, pathconf3res *objp)
+xdr_pathconf3res(XDR *xdrs, pathconf3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_pathconf3resok (xdrs, &objp->pathconf3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_pathconf3resfail (xdrs, &objp->pathconf3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_pathconf3resok(xdrs, &objp->pathconf3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_pathconf3resfail(xdrs, &objp->pathconf3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_commit3args (XDR *xdrs, commit3args *objp)
+xdr_commit3args(XDR *xdrs, commit3args *objp)
 {
-	 if (!xdr_nfs_fh3 (xdrs, &objp->file))
-		 return FALSE;
-	 if (!xdr_offset3 (xdrs, &objp->offset))
-		 return FALSE;
-	 if (!xdr_count3 (xdrs, &objp->count))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_nfs_fh3(xdrs, &objp->file))
+        return FALSE;
+    if (!xdr_offset3(xdrs, &objp->offset))
+        return FALSE;
+    if (!xdr_count3(xdrs, &objp->count))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3resok (XDR *xdrs, commit3resok *objp)
+xdr_commit3resok(XDR *xdrs, commit3resok *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	 if (!xdr_writeverf3 (xdrs, objp->verf))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    if (!xdr_writeverf3(xdrs, objp->verf))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3resfail (XDR *xdrs, commit3resfail *objp)
+xdr_commit3resfail(XDR *xdrs, commit3resfail *objp)
 {
-	 if (!xdr_wcc_data (xdrs, &objp->file_wcc))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_wcc_data(xdrs, &objp->file_wcc))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_commit3res (XDR *xdrs, commit3res *objp)
+xdr_commit3res(XDR *xdrs, commit3res *objp)
 {
-	 if (!xdr_nfsstat3 (xdrs, &objp->status))
-		 return FALSE;
-	switch (objp->status) {
-	case NFS3_OK:
-		 if (!xdr_commit3resok (xdrs, &objp->commit3res_u.resok))
-			 return FALSE;
-		break;
-	default:
-		 if (!xdr_commit3resfail (xdrs, &objp->commit3res_u.resfail))
-			 return FALSE;
-		break;
-	}
-	return TRUE;
+    if (!xdr_nfsstat3(xdrs, &objp->status))
+        return FALSE;
+    switch (objp->status) {
+        case NFS3_OK:
+            if (!xdr_commit3resok(xdrs, &objp->commit3res_u.resok))
+                return FALSE;
+            break;
+        default:
+            if (!xdr_commit3resfail(xdrs, &objp->commit3res_u.resfail))
+                return FALSE;
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_fhandle3 (XDR *xdrs, fhandle3 *objp)
+xdr_fhandle3(XDR *xdrs, fhandle3 *objp)
 {
-	 if (!xdr_bytes (xdrs, (char **)&objp->fhandle3_val, (u_int *) &objp->fhandle3_len, FHSIZE3))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val,
+                   (u_int *)&objp->fhandle3_len, FHSIZE3))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_dirpath (XDR *xdrs, dirpath *objp)
+xdr_dirpath(XDR *xdrs, dirpath *objp)
 {
-	 if (!xdr_string (xdrs, objp, MNTPATHLEN))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, MNTPATHLEN))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_name (XDR *xdrs, name *objp)
+xdr_name(XDR *xdrs, name *objp)
 {
-	 if (!xdr_string (xdrs, objp, MNTNAMLEN))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_string(xdrs, objp, MNTNAMLEN))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountstat3 (XDR *xdrs, mountstat3 *objp)
+xdr_mountstat3(XDR *xdrs, mountstat3 *objp)
 {
-	 if (!xdr_enum (xdrs, (enum_t *) objp))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_enum(xdrs, (enum_t *)objp))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountres3_ok (XDR *xdrs, mountres3_ok *objp)
+xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)
 {
-	 if (!xdr_fhandle3 (xdrs, &objp->fhandle))
-		 return FALSE;
-	 if (!xdr_array (xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (u_int *) &objp->auth_flavors.auth_flavors_len, ~0,
-		sizeof (int), (xdrproc_t) xdr_int))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_fhandle3(xdrs, &objp->fhandle))
+        return FALSE;
+    if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val,
+                   (u_int *)&objp->auth_flavors.auth_flavors_len, ~0,
+                   sizeof(int), (xdrproc_t)xdr_int))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountres3 (XDR *xdrs, mountres3 *objp)
+xdr_mountres3(XDR *xdrs, mountres3 *objp)
 {
-	 if (!xdr_mountstat3 (xdrs, &objp->fhs_status))
-		 return FALSE;
-	switch (objp->fhs_status) {
-	case MNT3_OK:
-		 if (!xdr_mountres3_ok (xdrs, &objp->mountres3_u.mountinfo))
-			 return FALSE;
-		break;
-	default:
-		break;
-	}
-	return TRUE;
+    if (!xdr_mountstat3(xdrs, &objp->fhs_status))
+        return FALSE;
+    switch (objp->fhs_status) {
+        case MNT3_OK:
+            if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
+                return FALSE;
+            break;
+        default:
+            break;
+    }
+    return TRUE;
 }
 
 bool_t
-xdr_mountlist (XDR *xdrs, mountlist *objp)
+xdr_mountlist(XDR *xdrs, mountlist *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mountbody),
+                     (xdrproc_t)xdr_mountbody))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_mountbody (XDR *xdrs, mountbody *objp)
+xdr_mountbody(XDR *xdrs, mountbody *objp)
 {
-	 if (!xdr_name (xdrs, &objp->ml_hostname))
-		 return FALSE;
-	 if (!xdr_dirpath (xdrs, &objp->ml_directory))
-		 return FALSE;
-	 if (!xdr_mountlist (xdrs, &objp->ml_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_name(xdrs, &objp->ml_hostname))
+        return FALSE;
+    if (!xdr_dirpath(xdrs, &objp->ml_directory))
+        return FALSE;
+    if (!xdr_mountlist(xdrs, &objp->ml_next))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_groups (XDR *xdrs, groups *objp)
+xdr_groups(XDR *xdrs, groups *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct groupnode),
+                     (xdrproc_t)xdr_groupnode))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_groupnode (XDR *xdrs, groupnode *objp)
+xdr_groupnode(XDR *xdrs, groupnode *objp)
 {
-	 if (!xdr_name (xdrs, &objp->gr_name))
-		 return FALSE;
-	 if (!xdr_groups (xdrs, &objp->gr_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_name(xdrs, &objp->gr_name))
+        return FALSE;
+    if (!xdr_groups(xdrs, &objp->gr_next))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_exports (XDR *xdrs, exports *objp)
+xdr_exports(XDR *xdrs, exports *objp)
 {
-	 if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct exportnode),
+                     (xdrproc_t)xdr_exportnode))
+        return FALSE;
+    return TRUE;
 }
 
 bool_t
-xdr_exportnode (XDR *xdrs, exportnode *objp)
+xdr_exportnode(XDR *xdrs, exportnode *objp)
 {
-	 if (!xdr_dirpath (xdrs, &objp->ex_dir))
-		 return FALSE;
-	 if (!xdr_groups (xdrs, &objp->ex_groups))
-		 return FALSE;
-	 if (!xdr_exports (xdrs, &objp->ex_next))
-		 return FALSE;
-	return TRUE;
+    if (!xdr_dirpath(xdrs, &objp->ex_dir))
+        return FALSE;
+    if (!xdr_groups(xdrs, &objp->ex_groups))
+        return FALSE;
+    if (!xdr_exports(xdrs, &objp->ex_next))
+        return FALSE;
+    return TRUE;
 }
 
 static void
-xdr_free_groupnode (struct groupnode *group)
+xdr_free_groupnode(struct groupnode *group)
 {
-        if (!group)
-                return;
+    if (!group)
+        return;
 
-        if (group->gr_next)
-                xdr_free_groupnode (group->gr_next);
+    if (group->gr_next)
+        xdr_free_groupnode(group->gr_next);
 
-        GF_FREE (group->gr_name);
-        GF_FREE (group);
+    GF_FREE(group->gr_name);
+    GF_FREE(group);
 }
 
 void
-xdr_free_exports_list (struct exportnode *first)
+xdr_free_exports_list(struct exportnode *first)
 {
-        struct exportnode       *elist = NULL;
+    struct exportnode *elist = NULL;
 
-        if (!first)
-                return;
+    if (!first)
+        return;
 
-        while (first) {
-                elist = first->ex_next;
-                GF_FREE (first->ex_dir);
+    while (first) {
+        elist = first->ex_next;
+        GF_FREE(first->ex_dir);
 
-                xdr_free_groupnode (first->ex_groups);
-
-                GF_FREE (first);
-                first = elist;
-        }
+        xdr_free_groupnode(first->ex_groups);
 
+        GF_FREE(first);
+        first = elist;
+    }
 }
 
-
 void
-xdr_free_mountlist (mountlist ml)
+xdr_free_mountlist(mountlist ml)
 {
-        struct mountbody        *next = NULL;
+    struct mountbody *next = NULL;
 
-        if (!ml)
-                return;
+    if (!ml)
+        return;
 
-        while (ml) {
-                GF_FREE (ml->ml_hostname);
-                GF_FREE (ml->ml_directory);
-                next = ml->ml_next;
-                GF_FREE (ml);
-                ml = next;
-        }
+    while (ml) {
+        GF_FREE(ml->ml_hostname);
+        GF_FREE(ml->ml_directory);
+        next = ml->ml_next;
+        GF_FREE(ml);
+        ml = next;
+    }
 
-        return;
+    return;
 }
 
-
 /* Free statements are based on the way sunrpc xdr decoding
  * code performs memory allocations.
  */
 void
-xdr_free_write3args_nocopy (write3args *wa)
+xdr_free_write3args_nocopy(write3args *wa)
 {
-        if (!wa)
-                return;
+    if (!wa)
+        return;
 
-        FREE (wa->file.data.data_val);
+    FREE(wa->file.data.data_val);
 }
diff --git a/tests/basic/ctime/ctime-glfs-init.c b/tests/basic/ctime/ctime-glfs-init.c
index 57a3dc7820e..e4f197b8f30 100644
--- a/tests/basic/ctime/ctime-glfs-init.c
+++ b/tests/basic/ctime/ctime-glfs-init.c
@@ -10,58 +10,59 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
 
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return -1;
-        }
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return -1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto err;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto err;
+    }
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto err;
-        }
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto err;
+    }
 
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto err;
-        }
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto err;
+    }
 
-        glfs_fini (fs);
-        fs = NULL;
-        return 0;
+    glfs_fini(fs);
+    fs = NULL;
+    return 0;
 err:
-        glfs_fini (fs);
-        fs = NULL;
+    glfs_fini(fs);
+    fs = NULL;
 
-        return -1;
+    return -1;
 }
diff --git a/tests/basic/ec/ec-fast-fgetxattr.c b/tests/basic/ec/ec-fast-fgetxattr.c
index b40dda65de5..bf982151861 100644
--- a/tests/basic/ec/ec-fast-fgetxattr.c
+++ b/tests/basic/ec/ec-fast-fgetxattr.c
@@ -12,123 +12,118 @@
 int cbk_complete = 0;
 ssize_t cbk_ret_val = 0;
 int
-fill_iov (struct iovec *iov, char fillchar, int count)
+fill_iov(struct iovec *iov, char fillchar, int count)
 {
-        int ret = -1;
-
-        iov->iov_base = malloc (count + 1);
-        if (iov->iov_base == NULL) {
-                return ret;
-        } else {
-                iov->iov_len = count;
-                ret = 0;
-        }
-        memset (iov->iov_base, fillchar, count);
-        memset (iov->iov_base + count, '\0', 1);
+    int ret = -1;
 
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
         return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
 }
 
 void
-write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
-                 struct stat *poststat, void *cookie)
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
 {
-
-        if (ret < 0) {
-                fprintf (stderr, "glfs_write failed");
-        }
-        cbk_ret_val = ret;
-        cbk_complete = 1;
+    if (ret < 0) {
+        fprintf(stderr, "glfs_write failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count)
+write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
 {
-        ssize_t         ret          = -1;
-        int             flags        = O_RDWR;
-        struct iovec    iov          = {0};
-
-
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
 
-        ret = fill_iov (&iov, 'a', char_count);
-        if (ret) {
-                fprintf (stderr, "failed to create iov");
-                goto out;
-        }
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        fprintf(stderr, "failed to create iov");
+        goto out;
+    }
 
-        ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk,
-                                  NULL);
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk, NULL);
 out:
-        if (ret < 0) {
-                fprintf (stderr, "glfs_pwritev async failed");
-        }
-        return ret;
-
+    if (ret < 0) {
+        fprintf(stderr, "glfs_pwritev async failed");
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-        char       buf[1024] = {0};
-
-        if (argc != 4) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, "/tmp/ec-fgetxattr.log", 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-
-        ret = write_async (fs, fd, 16);
-        if (ret) {
-                fprintf (stderr, "write_async failed\n");
-        }
-
-        sleep (1);
-        ret = glfs_fgetxattr (fd, "trusted.glusterfs.abc", buf, sizeof buf);
-        while (cbk_complete != 1) {
-                /* ret will be -ve as xattr doesn't exist, and fgetxattr should
-                 * return waaaayyy before writev */
-                ret = 0;
-                sleep (1);
-        }
-        if (cbk_ret_val < 0) {
-                fprintf (stderr, "cbk_ret_val is -ve\n");
-                ret = -1;
-        }
-        glfs_close(fd);
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    char buf[1024] = {0};
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/tmp/ec-fgetxattr.log", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    ret = write_async(fs, fd, 16);
+    if (ret) {
+        fprintf(stderr, "write_async failed\n");
+    }
+
+    sleep(1);
+    ret = glfs_fgetxattr(fd, "trusted.glusterfs.abc", buf, sizeof buf);
+    while (cbk_complete != 1) {
+        /* ret will be -ve as xattr doesn't exist, and fgetxattr should
+         * return waaaayyy before writev */
+        ret = 0;
+        sleep(1);
+    }
+    if (cbk_ret_val < 0) {
+        fprintf(stderr, "cbk_ret_val is -ve\n");
+        ret = -1;
+    }
+    glfs_close(fd);
 
 out:
-        unlink ("/tmp/ec-fgetxattr.log");
-        glfs_fini (fs);
+    unlink("/tmp/ec-fgetxattr.log");
+    glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/ec/seek.c b/tests/basic/ec/seek.c
index 67036ad4e75..54fa6f463af 100644
--- a/tests/basic/ec/seek.c
+++ b/tests/basic/ec/seek.c
@@ -15,171 +15,168 @@ static char buffer[65536];
 static int
 parse_int(const char *text, size_t *value)
 {
-        char *ptr;
-        size_t val;
+    char *ptr;
+    size_t val;
 
-        val = strtoul(text, &ptr, 0);
-        if (*ptr != 0) {
-                return 0;
-        }
+    val = strtoul(text, &ptr, 0);
+    if (*ptr != 0) {
+        return 0;
+    }
 
-        *value = val;
+    *value = val;
 
-        return 1;
+    return 1;
 }
 
 static int
 fill_area(int fd, off_t offset, size_t size)
 {
-        size_t len;
-        ssize_t res;
-
-        while (size > 0) {
-                len = sizeof(buffer);
-                if (len > size) {
-                        len = size;
-                }
-                res = pwrite(fd, buffer, len, offset);
-                if (res < 0) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) failed: %d\n",
-                                fd, buffer, size, offset, errno);
-                        return 0;
-                }
-                if (res != len) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) didn't wrote all "
-                                "data: %lu/%lu\n",
-                                fd, buffer, size, offset, res, len);
-                        return 0;
-                }
-                offset += len;
-                size -= len;
+    size_t len;
+    ssize_t res;
+
+    while (size > 0) {
+        len = sizeof(buffer);
+        if (len > size) {
+            len = size;
+        }
+        res = pwrite(fd, buffer, len, offset);
+        if (res < 0) {
+            fprintf(stderr, "pwrite(%d, %p, %lu, %lu) failed: %d\n", fd, buffer,
+                    size, offset, errno);
+            return 0;
+        }
+        if (res != len) {
+            fprintf(stderr,
+                    "pwrite(%d, %p, %lu, %lu) didn't wrote all "
+                    "data: %lu/%lu\n",
+                    fd, buffer, size, offset, res, len);
+            return 0;
         }
+        offset += len;
+        size -= len;
+    }
 
-        return 1;
+    return 1;
 }
 
 static void
 syntax(void)
 {
-        fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
-        fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
+    fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
+    fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
 }
 
 static int
 seek_create(const char *path, int argc, char *argv[])
 {
-        size_t off, size;
-        int fd;
-        int ret = 1;
-
-        fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to create the file\n");
-                goto out;
+    size_t off, size;
+    int fd;
+    int ret = 1;
+
+    fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to create the file\n");
+        goto out;
+    }
+
+    while (argc > 0) {
+        if (!parse_int(argv[0], &off) || !parse_int(argv[1], &size)) {
+            syntax();
+            goto out_close;
         }
-
-        while (argc > 0) {
-                if (!parse_int(argv[0], &off) ||
-                    !parse_int(argv[1], &size)) {
-                        syntax();
-                        goto out_close;
-                }
-                if (!fill_area(fd, off, size)) {
-                        goto out_close;
-                }
-                argv += 2;
-                argc -= 2;
+        if (!fill_area(fd, off, size)) {
+            goto out_close;
         }
+        argv += 2;
+        argc -= 2;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out_close:
-        close(fd);
+    close(fd);
 out:
-        return ret;
+    return ret;
 }
 
 static int
 seek_scan(const char *path, const char *type, const char *pos)
 {
-        size_t off, res;
-        int fd, whence;
-        int ret = 1;
-
-        if (strcmp(type, "data") == 0) {
-                whence = SEEK_DATA;
-        } else if (strcmp(type, "hole") == 0) {
-                whence = SEEK_HOLE;
-        } else {
-                syntax();
-                goto out;
-        }
-
-        if (!parse_int(pos, &off)) {
-                syntax();
-                goto out;
+    size_t off, res;
+    int fd, whence;
+    int ret = 1;
+
+    if (strcmp(type, "data") == 0) {
+        whence = SEEK_DATA;
+    } else if (strcmp(type, "hole") == 0) {
+        whence = SEEK_HOLE;
+    } else {
+        syntax();
+        goto out;
+    }
+
+    if (!parse_int(pos, &off)) {
+        syntax();
+        goto out;
+    }
+
+    fd = open(path, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to open the file\n");
+        goto out;
+    }
+
+    res = lseek(fd, off, whence);
+    if (res == (off_t)-1) {
+        if (errno != ENXIO) {
+            fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd, off, whence,
+                    errno);
+            goto out_close;
         }
+        fprintf(stdout, "ENXIO\n");
+    } else {
+        fprintf(stdout, "%lu\n", res);
+    }
 
-        fd = open(path, O_RDWR);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to open the file\n");
-                goto out;
-        }
-
-        res = lseek(fd, off, whence);
-        if (res == (off_t)-1) {
-                if (errno != ENXIO) {
-                        fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd,
-                                off, whence, errno);
-                        goto out_close;
-                }
-                fprintf(stdout, "ENXIO\n");
-        } else {
-                fprintf(stdout, "%lu\n", res);
-        }
-
-        ret = 0;
+    ret = 0;
 
 out_close:
-        close(fd);
+    close(fd);
 out:
-        return ret;
+    return ret;
 }
 
 int
 main(int argc, char *argv[])
 {
-        int ret = 1;
+    int ret = 1;
 
-        memset(buffer, 0x55, sizeof(buffer));
+    memset(buffer, 0x55, sizeof(buffer));
 
-        if (argc < 3) {
-                syntax();
-                goto out;
-        }
+    if (argc < 3) {
+        syntax();
+        goto out;
+    }
 
-        if (strcmp(argv[1], "create") == 0) {
-                if (((argc - 3) & 1) != 0) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_create(argv[2], argc - 3, argv + 3);
-        } else if (strcmp(argv[1], "scan") == 0) {
-                if (argc != 5) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_scan(argv[2], argv[3], argv[4]);
-        } else {
-                syntax();
-                goto out;
+    if (strcmp(argv[1], "create") == 0) {
+        if (((argc - 3) & 1) != 0) {
+            syntax();
+            goto out;
+        }
+        ret = seek_create(argv[2], argc - 3, argv + 3);
+    } else if (strcmp(argv[1], "scan") == 0) {
+        if (argc != 5) {
+            syntax();
+            goto out;
         }
+        ret = seek_scan(argv[2], argv[3], argv[4]);
+    } else {
+        syntax();
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
-
diff --git a/tests/basic/fops-sanity.c b/tests/basic/fops-sanity.c
index 1e2ccde6bd8..aff72d89ca1 100644
--- a/tests/basic/fops-sanity.c
+++ b/tests/basic/fops-sanity.c
@@ -34,858 +34,904 @@
 #endif
 
 /* for fd based fops after unlink */
-int fd_based_fops_1 (char *filename);
+int
+fd_based_fops_1(char *filename);
 /* for fd based fops before unlink */
-int fd_based_fops_2 (char *filename);
+int
+fd_based_fops_2(char *filename);
 /* fops based on fd after dup */
-int dup_fd_based_fops (char *filename);
+int
+dup_fd_based_fops(char *filename);
 /* for fops based on path */
-int path_based_fops (char *filename);
+int
+path_based_fops(char *filename);
 /* for fops which operate on directory */
-int dir_based_fops (char *filename);
+int
+dir_based_fops(char *filename);
 /* for fops which operate in link files (symlinks) */
-int link_based_fops (char *filename);
+int
+link_based_fops(char *filename);
 /* to test open syscall with open modes available. */
-int test_open_modes (char *filename);
+int
+test_open_modes(char *filename);
 /* generic function which does open write and read. */
-int generic_open_read_write (char *filename, int flag, mode_t mode);
+int
+generic_open_read_write(char *filename, int flag, mode_t mode);
 
-#define OPEN_MODE   0666
+#define OPEN_MODE 0666
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret           = -1;
-        int   result        = 0;
-        char  filename[255] = {0,};
-
-        if (argc > 1)
-                strcpy(filename, argv[1]);
-        else
-                strcpy(filename, "temp-xattr-test-file");
-
-        ret = fd_based_fops_1 (strcat(filename, "_1"));
-        if (ret < 0) {
-                fprintf (stderr, "fd based file operation 1 failed\n");
-                result |= ret;
-        } else {
-                fprintf (stdout, "fd based file operation 1 passed\n");
-        }
-
-        ret = fd_based_fops_2 (strcat(filename, "_2"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "fd based file operation 2 failed\n");
-        } else {
-                fprintf (stdout, "fd based file operation 2 passed\n");
-        }
-
-        ret = dup_fd_based_fops (strcat (filename, "_3"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "dup fd based file operation failed\n");
-        } else {
-                fprintf (stdout, "dup fd based file operation passed\n");
-        }
-
-        ret = path_based_fops (strcat (filename, "_4"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "path based file operation failed\n");
-        } else {
-                fprintf (stdout, "path based file operation passed\n");
-        }
-
-        ret = dir_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "directory based file operation failed\n");
-        } else {
-                fprintf (stdout, "directory based file operation passed\n");
-        }
-
-        ret = link_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "link based file operation failed\n");
-        } else {
-                fprintf (stdout, "link based file operation passed\n");
-        }
-
-        ret = test_open_modes (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "testing modes of `open' call failed\n");
-        } else {
-                fprintf (stdout, "testing modes of `open' call passed\n");
-        }
-        return result;
+    int ret = -1;
+    int result = 0;
+    char filename[255] = {
+        0,
+    };
+
+    if (argc > 1)
+        strcpy(filename, argv[1]);
+    else
+        strcpy(filename, "temp-xattr-test-file");
+
+    ret = fd_based_fops_1(strcat(filename, "_1"));
+    if (ret < 0) {
+        fprintf(stderr, "fd based file operation 1 failed\n");
+        result |= ret;
+    } else {
+        fprintf(stdout, "fd based file operation 1 passed\n");
+    }
+
+    ret = fd_based_fops_2(strcat(filename, "_2"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "fd based file operation 2 failed\n");
+    } else {
+        fprintf(stdout, "fd based file operation 2 passed\n");
+    }
+
+    ret = dup_fd_based_fops(strcat(filename, "_3"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "dup fd based file operation failed\n");
+    } else {
+        fprintf(stdout, "dup fd based file operation passed\n");
+    }
+
+    ret = path_based_fops(strcat(filename, "_4"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "path based file operation failed\n");
+    } else {
+        fprintf(stdout, "path based file operation passed\n");
+    }
+
+    ret = dir_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "directory based file operation failed\n");
+    } else {
+        fprintf(stdout, "directory based file operation passed\n");
+    }
+
+    ret = link_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "link based file operation failed\n");
+    } else {
+        fprintf(stdout, "link based file operation passed\n");
+    }
+
+    ret = test_open_modes(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "testing modes of `open' call failed\n");
+    } else {
+        fprintf(stdout, "testing modes of `open' call passed\n");
+    }
+    return result;
 }
 
 /* Execute all possible fops on a fd which is unlinked */
 int
-fd_based_fops_1 (char *filename)
+fd_based_fops_1(char *filename)
 {
-        int         fd        = 0;
-        int         ret       = -1;
-        int         result    = 0;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (fd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-/*
- *      These metadata operations fail at the moment because kernel doesn't
- *      pass the client fd in the operation.
- *      The following bug tracks this change.
- *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
- *      ret = fchmod (fd, 0640);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fchown (fd, 10001, 10001);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
- *      if (ret < 0) {
- *              fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = flistxattr (fd, NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fremovexattr (fd, "trusted.xattr-test");
- *      if (ret < 0) {
- *              fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
- */
-
-        if (fd)
-                close(fd);
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    /*
+     *      These metadata operations fail at the moment because kernel doesn't
+     *      pass the client fd in the operation.
+     *      The following bug tracks this change.
+     *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
+     *      ret = fchmod (fd, 0640);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fchown (fd, 10001, 10001);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fsetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = flistxattr (fd, NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "flistxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "fgetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fremovexattr (fd, "trusted.xattr-test");
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fremovexattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+     */
+
+    if (fd)
+        close(fd);
+    return result;
 }
 
-
 int
-fd_based_fops_2 (char *filename)
+fd_based_fops_2(char *filename)
 {
-        int     fd              = 0;
-        int     ret             = -1;
-        int     result          = 0;
-        struct stat stbuf       = {0,};
-        char        wstr[50]    = {0,};
-        char        rstr[50]    = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my second string\n");
-        ret = write (fd, wstr, strlen (wstr));
-        if (ret < 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen (wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close (fd);
-        unlink (filename);
-
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my second string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret < 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(filename);
+
+    return result;
 }
 
 int
-path_based_fops (char *filename)
+path_based_fops(char *filename)
 {
-        int         ret              = -1;
-        int         fd               = 0;
-        int         result           = 0;
-        struct stat stbuf            = {0,};
-        char        newfilename[255] = {0,};
-        char        *hardlink        = "linkfile-hard.txt";
-        char        *symlnk          = "linkfile-soft.txt";
-        char        buf[1024]        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = truncate (filename, 0);
-        if (ret < 0) {
-                fprintf (stderr, "truncate failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (filename, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (filename, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (filename, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (filename, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (filename, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = access (filename, R_OK|W_OK);
-        if (ret < 0) {
-                fprintf (stderr, "access failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = link (filename, hardlink);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(hardlink);
-
-        ret = symlink (filename, symlnk);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-
-        ret = readlink (symlnk, buf, sizeof(buf));
-        if (ret < 0) {
-                fprintf (stderr, "readlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(symlnk);
-
-        /* Create a character special file */
-        ret = mknod ("cspecial", S_IFCHR|S_IRWXU|S_IRWXG, makedev(2,3));
-        if (ret < 0) {
-                fprintf (stderr, "cpsecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("cspecial");
-
-        ret = mknod ("bspecial", S_IFBLK|S_IRWXU|S_IRWXG, makedev(4,5));
-        if (ret < 0) {
-                fprintf (stderr, "bspecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("bspecial");
+    int ret = -1;
+    int fd = 0;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char newfilename[255] = {
+        0,
+    };
+    char *hardlink = "linkfile-hard.txt";
+    char *symlnk = "linkfile-soft.txt";
+    char buf[1024] = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = truncate(filename, 0);
+    if (ret < 0) {
+        fprintf(stderr, "truncate failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(filename, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(filename, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(filename, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(filename, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(filename, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = access(filename, R_OK | W_OK);
+    if (ret < 0) {
+        fprintf(stderr, "access failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = link(filename, hardlink);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(hardlink);
+
+    ret = symlink(filename, symlnk);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = readlink(symlnk, buf, sizeof(buf));
+    if (ret < 0) {
+        fprintf(stderr, "readlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(symlnk);
+
+    /* Create a character special file */
+    ret = mknod("cspecial", S_IFCHR | S_IRWXU | S_IRWXG, makedev(2, 3));
+    if (ret < 0) {
+        fprintf(stderr, "cpsecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("cspecial");
+
+    ret = mknod("bspecial", S_IFBLK | S_IRWXU | S_IRWXG, makedev(4, 5));
+    if (ret < 0) {
+        fprintf(stderr, "bspecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("bspecial");
 
 #ifdef linux
-        ret = mknod ("fifo", S_IFIFO|S_IRWXU|S_IRWXG, 0);
+    ret = mknod("fifo", S_IFIFO | S_IRWXU | S_IRWXG, 0);
 #else
-        ret = mkfifo ("fifo", 0);
+    ret = mkfifo("fifo", 0);
 #endif
-        if (ret < 0) {
-                fprintf (stderr, "fifo mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("fifo");
+    if (ret < 0) {
+        fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("fifo");
 
 #ifdef linux
-        ret = mknod ("sock", S_IFSOCK|S_IRWXU|S_IRWXG, 0);
-        if (ret < 0) {
-                fprintf (stderr, "sock mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
+    ret = mknod("sock", S_IFSOCK | S_IRWXU | S_IRWXG, 0);
+    if (ret < 0) {
+        fprintf(stderr, "sock mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
 #else
-        {
-                int s;
-                const char *pathname = "sock";
-                struct sockaddr_un addr;
-
-                s = socket(PF_LOCAL, SOCK_STREAM, 0);
-                memset(&addr, 0, sizeof(addr));
-                strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
-                ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
-                if (ret < 0) {
-                        fprintf (stderr, "fifo mknod failed: %s\n",
-                                 strerror(errno));
-                        result |= ret;
-                }
-                close(s);
-        }
-#endif
-        unlink("sock");
+    {
+        int s;
+        const char *pathname = "sock";
+        struct sockaddr_un addr;
 
-        strcpy (newfilename, filename);
-        strcat(newfilename, "_new");
-        ret = rename (filename, newfilename);
+        s = socket(PF_LOCAL, SOCK_STREAM, 0);
+        memset(&addr, 0, sizeof(addr));
+        strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
+        ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
         if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
+            fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+            result |= ret;
         }
-        unlink (newfilename);
-
-        if (fd)
-                close (fd);
-
-        unlink (filename);
-        return result;
+        close(s);
+    }
+#endif
+    unlink("sock");
+
+    strcpy(newfilename, filename);
+    strcat(newfilename, "_new");
+    ret = rename(filename, newfilename);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(newfilename);
+
+    if (fd)
+        close(fd);
+
+    unlink(filename);
+    return result;
 }
 
 int
-dup_fd_based_fops (char *filename)
+dup_fd_based_fops(char *filename)
 {
-        int         fd        = 0;
-        int         result    = 0;
-        int         newfd     = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        newfd = dup (fd);
-        if (newfd < 0) {
-                fprintf (stderr, "dup failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        close (fd);
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (newfd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (newfd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (newfd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (newfd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (newfd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (newfd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (newfd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (newfd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (newfd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (newfd)
-                close (newfd);
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-        return result;
+    int fd = 0;
+    int result = 0;
+    int newfd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    newfd = dup(fd);
+    if (newfd < 0) {
+        fprintf(stderr, "dup failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    close(fd);
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(newfd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(newfd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(newfd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(newfd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(newfd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(newfd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(newfd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(newfd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(newfd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (newfd)
+        close(newfd);
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+    return result;
 }
 
 int
-dir_based_fops (char *dirname)
+dir_based_fops(char *dirname)
 {
-        int            ret           = -1;
-        int            result        = 0;
-        DIR           *dp            = NULL;
-        char           buff[255]     = {0,};
-        struct dirent *dbuff         = {0,};
-        struct stat    stbuff        = {0,};
-        char           newdname[255] = {0,};
-        char          *cwd           = NULL;
-
-        ret = mkdir (dirname, 0755);
-        if (ret < 0) {
-                fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        dp = opendir (dirname);
-        if (dp == NULL) {
-                fprintf (stderr, "opendir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        dbuff = readdir (dp);
-        if (NULL == dbuff) {
-                fprintf (stderr, "readdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = closedir (dp);
-        if (ret < 0) {
-                fprintf (stderr, "closedir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (dirname, &stbuff);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (dirname, 0744);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (dirname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (dirname, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (dirname, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "/../");
-        ret = chdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "chdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        cwd = getcwd (buff, 255);
-        if (NULL == cwd) {
-                fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "new");
-        ret = rename (dirname, newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = rmdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        rmdir (dirname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    DIR *dp = NULL;
+    char buff[255] = {
+        0,
+    };
+    struct dirent *dbuff = {
+        0,
+    };
+    struct stat stbuff = {
+        0,
+    };
+    char newdname[255] = {
+        0,
+    };
+    char *cwd = NULL;
+
+    ret = mkdir(dirname, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    dp = opendir(dirname);
+    if (dp == NULL) {
+        fprintf(stderr, "opendir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    dbuff = readdir(dp);
+    if (NULL == dbuff) {
+        fprintf(stderr, "readdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = closedir(dp);
+    if (ret < 0) {
+        fprintf(stderr, "closedir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(dirname, &stbuff);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(dirname, 0744);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(dirname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(dirname, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(dirname, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(dirname, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "/../");
+    ret = chdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "chdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    cwd = getcwd(buff, 255);
+    if (NULL == cwd) {
+        fprintf(stderr, "getcwd failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "new");
+    ret = rename(dirname, newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = rmdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rmdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    rmdir(dirname);
+    return result;
 }
 
 int
-link_based_fops (char *filename)
+link_based_fops(char *filename)
 {
-        int         ret           = -1;
-        int         result        = 0;
-        int         fd            = 0;
-        char        newname[255]  = {0,};
-        char        linkname[255] = {0,};
-        struct stat lstbuf        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        strcpy (newname, filename);
-        strcat (newname, "_hlink");
-        ret = link (filename, newname);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (linkname, filename);
-        strcat (linkname, "_slink");
-        ret = symlink (newname, linkname);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lstat (linkname, &lstbuf);
-        if (ret < 0) {
-                fprintf (stderr, "lstbuf failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lchown (linkname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "lchown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = llistxattr (linkname, NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "llistxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lremovexattr (linkname, "trusted.lxattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close(fd);
-        unlink (linkname);
-        unlink (newname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    int fd = 0;
+    char newname[255] = {
+        0,
+    };
+    char linkname[255] = {
+        0,
+    };
+    struct stat lstbuf = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    strcpy(newname, filename);
+    strcat(newname, "_hlink");
+    ret = link(filename, newname);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(linkname, filename);
+    strcat(linkname, "_slink");
+    ret = symlink(newname, linkname);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lstat(linkname, &lstbuf);
+    if (ret < 0) {
+        fprintf(stderr, "lstbuf failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lchown(linkname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "lchown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = llistxattr(linkname, NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "llistxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lremovexattr(linkname, "trusted.lxattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(linkname);
+    unlink(newname);
+    return result;
 }
 
 int
-test_open_modes (char *filename)
+test_open_modes(char *filename)
 {
-        int ret         = -1;
-        int result      = 0;
-
-        ret = generic_open_read_write (filename, O_CREAT|O_WRONLY, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDONLY, OPEN_MODE);
-        if (ret != 0) {
-                fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n");
-                result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_WRONLY, 0);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_WRONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDWR, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n");
-               result |= ret;
-        }
+    int ret = -1;
+    int result = 0;
+
+    ret = generic_open_read_write(filename, O_CREAT | O_WRONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_WRONLY, 0);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_WRONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDWR, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n");
+        result |= ret;
+    }
 
 #if 0 /* undefined behaviour, unable to reliably test */
         ret = creat (filename, 0644);
@@ -897,87 +943,90 @@ test_open_modes (char *filename)
         }
 #endif
 
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC,
-                                       OPEN_MODE);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_CREAT|O_EXCL, OPEN_MODE);
-        if (0 != ret) {
-                fprintf (stderr, "flag O_CREAT|O_EXCL failed\n");
-                result |= ret;
-        }
-
-        return result;
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC,
+                                  OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_CREAT | O_EXCL, OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_EXCL failed\n");
+        result |= ret;
+    }
+
+    return result;
 }
 
 int
-generic_open_read_write (char *filename, int flag, mode_t mode)
+generic_open_read_write(char *filename, int flag, mode_t mode)
 {
-        int  fd          = 0;
-        int  ret         = -1;
-        char wstring[50] = {0,};
-        char rstring[50] = {0,};
-
-        fd = open (filename, flag, mode);
-        if (fd < 0) {
-                if (flag == (O_CREAT|O_EXCL) && errno == EEXIST) {
-                        unlink (filename);
-                        return 0;
-                }
-                else {
-                        fprintf (stderr, "open failed: %s\n", strerror (errno));
-                        return -1;
-                }
-        }
-
-        strcpy (wstring, "My string to write\n");
-        ret = write (fd, wstring, strlen(wstring));
-        if (ret <= 0) {
-                if (errno != EBADF) {
-                        fprintf (stderr, "write failed: %s\n", strerror (errno));
-                        close (fd);
-                        unlink(filename);
-                        return ret;
-                }
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                close (fd);
-                unlink(filename);
-                return ret;
-        }
-
-        ret = read (fd, rstring, strlen(wstring));
-        if (ret < 0 && flag != (O_CREAT|O_WRONLY) && flag != O_WRONLY && \
-            flag != (O_TRUNC|O_WRONLY)) {
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        /* Compare the rstring with wstring. But we do not want to return
-         * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
-         * O_TRUNC|O_RDONLY. Because in that case we are not writing
-         * anything to the file.*/
-
-        ret = memcmp (wstring, rstring, strlen (wstring));
-        if (0 != ret && flag != (O_TRUNC|O_WRONLY) && flag != O_WRONLY && \
-                                 flag != (O_CREAT|O_WRONLY) && !(flag == \
-                                 (O_CREAT|O_RDONLY) || flag == O_RDONLY \
-                                  || flag == (O_TRUNC|O_RDONLY))) {
-                fprintf (stderr, "read is returning junk\n");
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        close (fd);
-        unlink (filename);
-        return 0;
+    int fd = 0;
+    int ret = -1;
+    char wstring[50] = {
+        0,
+    };
+    char rstring[50] = {
+        0,
+    };
+
+    fd = open(filename, flag, mode);
+    if (fd < 0) {
+        if (flag == (O_CREAT | O_EXCL) && errno == EEXIST) {
+            unlink(filename);
+            return 0;
+        } else {
+            fprintf(stderr, "open failed: %s\n", strerror(errno));
+            return -1;
+        }
+    }
+
+    strcpy(wstring, "My string to write\n");
+    ret = write(fd, wstring, strlen(wstring));
+    if (ret <= 0) {
+        if (errno != EBADF) {
+            fprintf(stderr, "write failed: %s\n", strerror(errno));
+            close(fd);
+            unlink(filename);
+            return ret;
+        }
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    ret = read(fd, rstring, strlen(wstring));
+    if (ret < 0 && flag != (O_CREAT | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_TRUNC | O_WRONLY)) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    /* Compare the rstring with wstring. But we do not want to return
+     * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
+     * O_TRUNC|O_RDONLY. Because in that case we are not writing
+     * anything to the file.*/
+
+    ret = memcmp(wstring, rstring, strlen(wstring));
+    if (0 != ret && flag != (O_TRUNC | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_CREAT | O_WRONLY) &&
+        !(flag == (O_CREAT | O_RDONLY) || flag == O_RDONLY ||
+          flag == (O_TRUNC | O_RDONLY))) {
+        fprintf(stderr, "read is returning junk\n");
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    close(fd);
+    unlink(filename);
+    return 0;
 }
diff --git a/tests/basic/fuse/seek.c b/tests/basic/fuse/seek.c
index e4db41c03d7..30943ad0f33 100644
--- a/tests/basic/fuse/seek.c
+++ b/tests/basic/fuse/seek.c
@@ -17,64 +17,66 @@
 #include <unistd.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int          ret        = EXIT_SUCCESS;
-        int          fd         = -1;
-        char        *filename   = NULL;
-        struct stat  st         = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
+    int ret = EXIT_SUCCESS;
+    int fd = -1;
+    char *filename = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
 
-        if (argc != 2) {
-                fprintf (stderr, "Invalid argument, use %s <file>\n", argv[0]);
-                return EXIT_FAILURE;
-        }
-
-        filename = argv[1];
+    if (argc != 2) {
+        fprintf(stderr, "Invalid argument, use %s <file>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        fd = open (filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("open");
-                return EXIT_FAILURE;
-        }
+    filename = argv[1];
 
-        if (fstat (fd, &st)) {
-                perror ("fstat");
-                return EXIT_FAILURE;
-        }
+    fd = open(filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
 
-        while (hole_end < st.st_size) {
-                hole_start = lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO) {
-                        /* no more holes */
-                        break;
-                } else if (hole_start == -1 && errno == ENOTSUP) {
-                        /* SEEK_HOLE is not supported */
-                        perror ("lseek(SEEK_HOLE)");
-                        ret = EXIT_FAILURE;
-                        break;
-                } else if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
+    if (fstat(fd, &st)) {
+        perror("fstat");
+        return EXIT_FAILURE;
+    }
 
-                hole_end = lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                } else if (hole_end == -1 && errno == ENOTSUP) {
-                        /* SEEK_DATA is not supported */
-                        perror ("lseek(SEEK_DATA)");
-                        ret = EXIT_FAILURE;
-                        break;
-                }
+    while (hole_end < st.st_size) {
+        hole_start = lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO) {
+            /* no more holes */
+            break;
+        } else if (hole_start == -1 && errno == ENOTSUP) {
+            /* SEEK_HOLE is not supported */
+            perror("lseek(SEEK_HOLE)");
+            ret = EXIT_FAILURE;
+            break;
+        } else if (hole_start == -1) {
+            perror("no more holes");
+            break;
+        }
 
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
+        hole_end = lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
+        } else if (hole_end == -1 && errno == ENOTSUP) {
+            /* SEEK_DATA is not supported */
+            perror("lseek(SEEK_DATA)");
+            ret = EXIT_FAILURE;
+            break;
         }
 
-        close (fd);
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
+
+    close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/anonymous_fd_read_write.c b/tests/basic/gfapi/anonymous_fd_read_write.c
index 6945dd634f0..fc276ca4310 100644
--- a/tests/basic/gfapi/anonymous_fd_read_write.c
+++ b/tests/basic/gfapi/anonymous_fd_read_write.c
@@ -9,95 +9,98 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret            = 0;
-        glfs_t                  *fs            = NULL;
-        struct glfs_object      *root = NULL, *file_obj = NULL;
-        struct stat             sb             = {0, };
-        char                    readbuf[32], writebuf[32];
-        char                    *filename      = "file.txt";
-        char                    *logfile       = NULL;
-        char                    *volname       = NULL;
-        char                    *hostname      = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-
-        file_obj = glfs_h_creat (fs, root, filename, O_CREAT, 0644, &sb);
-        if (file_obj == NULL) {
-                fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
-                         filename, root, strerror (errno));
-                goto out;
-        }
-
-        /* test read/write based on anonymous fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-
-        ret = glfs_h_anonymous_write (fs, file_obj, writebuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_write", ret);
-
-        ret = glfs_h_anonymous_read (fs, file_obj, readbuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_read", ret);
-
-        if (memcmp (readbuf, writebuf, 32)) {
-                fprintf (stderr, "Failed to read what I wrote: %s %s\n", readbuf,
-                         writebuf);
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_object *root = NULL, *file_obj = NULL;
+    struct stat sb = {
+        0,
+    };
+    char readbuf[32], writebuf[32];
+    char *filename = "file.txt";
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+
+    file_obj = glfs_h_creat(fs, root, filename, O_CREAT, 0644, &sb);
+    if (file_obj == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                filename, root, strerror(errno));
+        goto out;
+    }
+
+    /* test read/write based on anonymous fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+
+    ret = glfs_h_anonymous_write(fs, file_obj, writebuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_write", ret);
+
+    ret = glfs_h_anonymous_read(fs, file_obj, readbuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_read", ret);
+
+    if (memcmp(readbuf, writebuf, 32)) {
+        fprintf(stderr, "Failed to read what I wrote: %s %s\n", readbuf,
+                writebuf);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (file_obj)
-                glfs_h_close (file_obj);
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-        if (ret)
-                exit(1);
-        exit(0);
+    if (file_obj)
+        glfs_h_close(file_obj);
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/bug-1241104.c b/tests/basic/gfapi/bug-1241104.c
index 311323f672a..78c87595a71 100644
--- a/tests/basic/gfapi/bug-1241104.c
+++ b/tests/basic/gfapi/bug-1241104.c
@@ -12,81 +12,82 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-        struct flock lock = {0, };
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
-
-	/* validate locks for negative range */
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 10;
-        lock.l_len = -9;
-
-        ret = glfs_posix_lock (fd, F_SETLK, &lock);
-        LOG_ERR ("glfs_posix_lock", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    struct flock lock = {
+        0,
+    };
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    /* validate locks for negative range */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 10;
+    lock.l_len = -9;
+
+    ret = glfs_posix_lock(fd, F_SETLK, &lock);
+    LOG_ERR("glfs_posix_lock", ret);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1283983.c b/tests/basic/gfapi/bug1283983.c
index 3334b290d9e..b920013d0e0 100644
--- a/tests/basic/gfapi/bug1283983.c
+++ b/tests/basic/gfapi/bug1283983.c
@@ -10,114 +10,113 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        char                     *filename = "/a1";
-        char                     *filename2 = "/a2";
-        struct stat               sb = {0, };
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        int                       cnt = 1;
-        struct glfs_upcall_inode *in_arg = NULL;
-        struct glfs_object       *root = NULL, *leaf = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    int cnt = 1;
+    struct glfs_upcall_inode *in_arg = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1] volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    leaf = glfs_h_creat(fs, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    leaf = glfs_h_lookupat(fs, root, filename2, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    ret = glfs_h_rename(fs, root, filename, root, filename2);
+    LOG_ERR("glfs_rename", ret);
+
+    while (cnt++ < 5) {
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+
+        /* There should not be any upcalls sent */
+        if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
+            fprintf(stderr, "Error: Upcall received(%d)\n",
+                    glfs_upcall_get_reason(cbk));
+            exit(1);
         }
 
-        hostname = argv[1]
-        volname = argv[2];
-        logfile = argv[3];
+        glfs_free(cbk);
+    }
 
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        leaf = glfs_h_creat (fs, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        leaf = glfs_h_lookupat (fs, root, filename2, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        ret = glfs_h_rename (fs, root, filename, root, filename2);
-        LOG_ERR("glfs_rename", ret);
-
-        while (cnt++ < 5) {
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                /* There should not be any upcalls sent */
-                if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
-                        fprintf (stderr, "Error: Upcall received(%d)\n",
-                                 glfs_upcall_get_reason(cbk));
-                        exit (1);
-                }
-
-                glfs_free (cbk);
-        }
-
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1291259.c b/tests/basic/gfapi/bug1291259.c
index 26fc1e01449..cd7bc65268b 100644
--- a/tests/basic/gfapi/bug1291259.c
+++ b/tests/basic/gfapi/bug1291259.c
@@ -10,174 +10,172 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 #define GLAPI_UUID_LENGTH 16
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                     *fs = NULL;
-        glfs_t                     *fs2 = NULL;
-        int                         ret = 0, i;
-        glfs_fd_t                  *fd = NULL;
-        char                       *filename = "/a1";
-        char                       *filename2 = "/a2";
-        struct                      stat sb = {0, };
-        char                       *logfile = NULL;
-        char                       *volname = NULL;
-        char                       *hostname = NULL;
-        int                         cnt = 1;
-        int                         upcall_received = 0;
-        struct glfs_upcall         *cbk = NULL;
-        struct glfs_object         *root = NULL, *leaf = NULL;
-        unsigned char               globjhdl[GFAPI_HANDLE_LENGTH];
-        unsigned char               globjhdl2[GFAPI_HANDLE_LENGTH];
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int cnt = 1;
+    int upcall_received = 0;
+    struct glfs_upcall *cbk = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+    unsigned char globjhdl[GFAPI_HANDLE_LENGTH];
+    unsigned char globjhdl2[GFAPI_HANDLE_LENGTH];
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    root = glfs_h_lookupat(fs2, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_creat(fs2, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    while (cnt++ < 5 && !upcall_received) {
+        enum glfs_upcall_reason reason = 0;
+        struct glfs_upcall_inode *in_arg = NULL;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+        if (ret)
+            goto retry;
 
+        reason = glfs_upcall_get_reason(cbk);
+        fprintf(stderr, "Upcall received(%d)\n", reason);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+            struct glfs_object *object = NULL;
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
+            in_arg = glfs_upcall_get_event(cbk);
+            object = glfs_upcall_inode_get_object(in_arg);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
+            ret = glfs_h_extract_handle(root, globjhdl + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+            ret = glfs_h_extract_handle(object, globjhdl2 + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-        fs2 = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
+            if (memcmp(globjhdl + GLAPI_UUID_LENGTH,
+                       globjhdl2 + GLAPI_UUID_LENGTH, 16)) {
+                fprintf(stderr, "Error: gfid mismatch\n");
+                exit(1);
+            }
+            upcall_received = 1;
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init", ret);
+    retry:
+        if (!upcall_received)
+            sleep(1); /* glfs_h_poll_upcall() does not block */
 
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        while (cnt++ < 5 && !upcall_received) {
-                enum glfs_upcall_reason     reason = 0;
-                struct glfs_upcall_inode   *in_arg = NULL;
-
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-                if (ret)
-                        goto retry;
-
-                reason = glfs_upcall_get_reason (cbk);
-                fprintf (stderr, "Upcall received(%d)\n", reason);
-
-                if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                        struct glfs_object *object = NULL;
-
-                        in_arg = glfs_upcall_get_event (cbk);
-                        object = glfs_upcall_inode_get_object (in_arg);
-
-                        ret = glfs_h_extract_handle (root,
-                                                     globjhdl+GLAPI_UUID_LENGTH,
-                                                     GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        ret = glfs_h_extract_handle (object,
-                                                  globjhdl2+GLAPI_UUID_LENGTH,
-                                                  GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        if (memcmp (globjhdl+GLAPI_UUID_LENGTH,
-                                    globjhdl2+GLAPI_UUID_LENGTH, 16)) {
-                                fprintf (stderr, "Error: gfid mismatch\n");
-                                exit (1);
-                        }
-                        upcall_received = 1;
-                }
-
-retry:
-                if (!upcall_received)
-                        sleep (1); /* glfs_h_poll_upcall() does not block */
-
-                if (!ret) {
-                        glfs_free (cbk);
-                        cbk = NULL;
-                }
+        if (!ret) {
+            glfs_free(cbk);
+            cbk = NULL;
         }
+    }
 
-        if (!upcall_received) {
-                fprintf (stderr, "Error: Upcall not received\n");
-                exit (1);
-        }
+    if (!upcall_received) {
+        fprintf(stderr, "Error: Upcall not received\n");
+        exit(1);
+    }
 
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1613098.c b/tests/basic/gfapi/bug1613098.c
index cdb69fdedfa..ee67e97a034 100644
--- a/tests/basic/gfapi/bug1613098.c
+++ b/tests/basic/gfapi/bug1613098.c
@@ -6,90 +6,91 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define ACL_TYPE_ACCESS	(0x8000)
+#define ACL_TYPE_ACCESS (0x8000)
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        const char     *filename = "file_tmp";
-        struct glfs_object *object = NULL;
-        acl_t          acl = NULL;
-        struct stat    sb;
-
-        if (argc != 3) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        volname = argv[1];
-        logfile = argv[2];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd = glfs_creat(fs, filename, flags, 0044);
-        if (fd == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-        glfs_close(fd);
-
-        object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
-        if (object == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", ret, out);
-        }
-
-        ret = glfs_chown(fs, filename, 99, 99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_chown", ret, out);
-
-        ret = glfs_setfsuid(99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsuid", ret, out);
-
-        ret = glfs_setfsgid(99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsgid", ret, out);
-
-        acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
-        if (acl == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out);
-        }
-
-        ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out);
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    struct glfs_object *object = NULL;
+    acl_t acl = NULL;
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd = glfs_creat(fs, filename, flags, 0044);
+    if (fd == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+    glfs_close(fd);
+
+    object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
+    if (object == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out);
+    }
+
+    ret = glfs_chown(fs, filename, 99, 99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out);
+
+    ret = glfs_setfsuid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out);
+
+    ret = glfs_setfsgid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out);
+
+    acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
+    if (acl == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
+    }
+
+    ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
 out:
-        glfs_setfsuid(0);
-        glfs_setfsgid(0);
+    glfs_setfsuid(0);
+    glfs_setfsgid(0);
 
-        if (object)
-                glfs_h_close(object);
+    if (object)
+        glfs_h_close(object);
 
-        if (fs)
-                glfs_fini(fs);
+    if (fs)
+        glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/gfapi-async-calls-test.c b/tests/basic/gfapi/gfapi-async-calls-test.c
index b9f29a44ac0..5a291c3c76b 100644
--- a/tests/basic/gfapi/gfapi-async-calls-test.c
+++ b/tests/basic/gfapi/gfapi-async-calls-test.c
@@ -9,170 +9,164 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 int cbk_complete = 0;
 int cbk_ret_val = -1;
 
 int
-fill_iov (struct iovec *iov, char fillchar, int count)
+fill_iov(struct iovec *iov, char fillchar, int count)
 {
-        int ret = -1;
-
-        iov->iov_base = malloc (count + 1);
-        if (iov->iov_base == NULL) {
-                return ret;
-        } else {
-                iov->iov_len = count;
-                ret = 0;
-        }
-        memset (iov->iov_base, fillchar, count);
-        memset (iov->iov_base + count, '\0', 1);
+    int ret = -1;
 
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
         return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
 }
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
 void
-write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
-                 struct stat *poststat, void *cookie)
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
 {
-
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-        }
-        cbk_ret_val = ret;
-        cbk_complete = 1;
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count)
+write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
 {
-        ssize_t         ret          = -1;
-        int             flags        = O_RDWR;
-        const char     *buff         = "This is from my prog\n";
-        struct iovec    iov          = {0};
-        void           *write_cookie = NULL;
-        void           *read_cookie  = NULL;
-
-
-
-        ret = fill_iov (&iov, 'a', char_count);
-        if (ret) {
-                LOG_ERR ("failed to create iov");
-                goto out;
-        }
-
-        write_cookie = strdup ("write_cookie");
-        ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk,
-                                  &write_cookie);
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    const char *buff = "This is from my prog\n";
+    struct iovec iov = {0};
+    void *write_cookie = NULL;
+    void *read_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    write_cookie = strdup("write_cookie");
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk,
+                             &write_cookie);
 out:
-        if (ret < 0) {
-                LOG_ERR ("glfs_pwritev async failed");
-        }
-        return ret;
-
+    if (ret < 0) {
+        LOG_ERR("glfs_pwritev async failed");
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
-        const char *filename = "glfs_test.txt";
-        int         flags    = (O_RDWR|O_CREAT);
-        glfs_fd_t  *glfd     = NULL;
-        int         count    = 200;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                exit(1);
-        }
-
-        ret = write_async (fs, glfd, count);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-                exit(1);
-        }
-
-        while (cbk_complete != 1) {
-                sleep(1);
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs close  failed");
-        }
-
-        /*
-         * skipping fini
-         */
-
-        if (cbk_ret_val == count)
-                return 0;
-        else
-                return -1;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    const char *filename = "glfs_test.txt";
+    int flags = (O_RDWR | O_CREAT);
+    glfs_fd_t *glfd = NULL;
+    int count = 200;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        exit(1);
+    }
+
+    ret = write_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+        exit(1);
+    }
+
+    while (cbk_complete != 1) {
+        sleep(1);
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs close  failed");
+    }
+
+    /*
+     * skipping fini
+     */
+
+    if (cbk_ret_val == count)
+        return 0;
+    else
+        return -1;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-dup.c b/tests/basic/gfapi/gfapi-dup.c
index 96f133eae33..028108e4590 100644
--- a/tests/basic/gfapi/gfapi-dup.c
+++ b/tests/basic/gfapi/gfapi-dup.c
@@ -4,81 +4,81 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        glfs_fd_t      *fd2 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        char           *hostname = NULL;
-        const char     *filename = "file_tmp";
-        const char     *buff = "An opinion should be the result of thought, "
-                                "not a substitute for it.";
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, strlen (buff), flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        fd2 = glfs_dup(fd1);
-        if (fd2 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_dup", ret, out);
-        }
-
-        ret = glfs_lseek (fd2, 0, SEEK_SET);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_lseek", ret, out);
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    const char *filename = "file_tmp";
+    const char *buff =
+        "An opinion should be the result of thought, "
+        "not a substitute for it.";
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, strlen(buff), flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    fd2 = glfs_dup(fd1);
+    if (fd2 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_dup", ret, out);
+    }
+
+    ret = glfs_lseek(fd2, 0, SEEK_SET);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_lseek", ret, out);
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fd2 != NULL)
-                glfs_close(fd2);
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fd2 != NULL)
+        glfs_close(fd2);
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-load-volfile.c b/tests/basic/gfapi/gfapi-load-volfile.c
index 79502f7a44f..fbfc6045cd7 100644
--- a/tests/basic/gfapi/gfapi-load-volfile.c
+++ b/tests/basic/gfapi/gfapi-load-volfile.c
@@ -16,50 +16,50 @@
 void
 usage(FILE *output)
 {
-	fprintf(output, "Usage: " PROGNAME " <volfile>\n");
+    fprintf(output, "Usage: " PROGNAME " <volfile>\n");
 }
 
 void
 main(int argc, char **argv)
 {
-	int ret = 0;
-	glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_t *fs = NULL;
 
-	if (argc != 2) {
-		usage(stderr);
-		exit(EXIT_FAILURE);
-	}
+    if (argc != 2) {
+        usage(stderr);
+        exit(EXIT_FAILURE);
+    }
 
-	if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
-		usage(stdout);
-		exit(EXIT_SUCCESS);
-	}
+    if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
+        usage(stdout);
+        exit(EXIT_SUCCESS);
+    }
 
-	fs = glfs_new(PROGNAME);
-	if (!fs) {
-		perror("glfs_new failed");
-		exit(EXIT_FAILURE);
-	}
+    fs = glfs_new(PROGNAME);
+    if (!fs) {
+        perror("glfs_new failed");
+        exit(EXIT_FAILURE);
+    }
 
-	glfs_set_logging(fs, PROGNAME ".log", 9);
+    glfs_set_logging(fs, PROGNAME ".log", 9);
 
-	ret = glfs_set_volfile(fs, argv[1]);
-	if (ret) {
-		perror("glfs_set_volfile failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_set_volfile(fs, argv[1]);
+    if (ret) {
+        perror("glfs_set_volfile failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = glfs_init(fs);
-	if (ret) {
-		perror("glfs_init failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_init(fs);
+    if (ret) {
+        perror("glfs_init failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = EXIT_SUCCESS;
+    ret = EXIT_SUCCESS;
 out:
-	glfs_fini(fs);
+    glfs_fini(fs);
 
-	exit(ret);
+    exit(ret);
 }
diff --git a/tests/basic/gfapi/gfapi-ssl-test.c b/tests/basic/gfapi/gfapi-ssl-test.c
index 41126bdc6db..a27b5233702 100644
--- a/tests/basic/gfapi/gfapi-ssl-test.c
+++ b/tests/basic/gfapi/gfapi-ssl-test.c
@@ -9,118 +9,116 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
 int
-glfs_test_function (const char *hostname, const char *volname,
-                    const char *logfile)
+glfs_test_function(const char *hostname, const char *volname,
+                   const char *logfile)
 {
-        int             ret      = -1;
-        int             flags    = O_CREAT | O_RDWR;
-        glfs_t         *fs       = NULL;
-        glfs_fd_t      *glfd     = NULL;
-        const char     *buff     = "This is from my prog\n";
-        const char     *filename = "glfs_test.txt";
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                goto out;
-        }
-
-        ret = glfs_write (glfd, buff, strlen (buff), flags);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
+    int ret = -1;
+    int flags = O_CREAT | O_RDWR;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    const char *buff = "This is from my prog\n";
+    const char *filename = "glfs_test.txt";
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        goto out;
+    }
+
+    ret = glfs_write(glfd, buff, strlen(buff), flags);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
 
 out:
-        ret = glfs_fini (fs);
-        if (ret) {
-                LOG_ERR ("glfs_fini failed");
-        }
+    ret = glfs_fini(fs);
+    if (ret) {
+        LOG_ERR("glfs_fini failed");
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret = 0;
-        char *hostname = NULL;
-        char *volname = NULL;
-        char *logfile = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        ret = glfs_test_function (hostname, volname, logfile);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-        }
-
-        return ret;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    ret = glfs_test_function(hostname, volname, logfile);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-trunc.c b/tests/basic/gfapi/gfapi-trunc.c
index af187e50c78..769f6cfa1d9 100644
--- a/tests/basic/gfapi/gfapi-trunc.c
+++ b/tests/basic/gfapi/gfapi-trunc.c
@@ -5,86 +5,85 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define WRITE_SIZE      4096
-#define TRUNC_SIZE      1234
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define WRITE_SIZE 4096
+#define TRUNC_SIZE 1234
 /* Make sure TRUNC_SIZE is smaller than WRITE_SIZE at compile time. */
-typedef char _size_check[WRITE_SIZE-TRUNC_SIZE];
+typedef char _size_check[WRITE_SIZE - TRUNC_SIZE];
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        const char     *filename = "file_tmp";
-        const char     buff[WRITE_SIZE];
-        struct stat    sb;
-
-        if (argc != 3) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        volname = argv[1];
-        logfile = argv[2];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, WRITE_SIZE, flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        ret = glfs_truncate (fs, filename, TRUNC_SIZE);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out);
-
-        ret = glfs_fstat (fd1, &sb);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out);
-
-        if (sb.st_size != TRUNC_SIZE) {
-                fprintf (stderr, "wrong size %jd should be %jd\n",
-                         (intmax_t)sb.st_size, (intmax_t)2048);
-                ret = -1;
-        }
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    const char buff[WRITE_SIZE];
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, WRITE_SIZE, flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    ret = glfs_truncate(fs, filename, TRUNC_SIZE);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out);
+
+    ret = glfs_fstat(fd1, &sb);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out);
+
+    if (sb.st_size != TRUNC_SIZE) {
+        fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size,
+                (intmax_t)2048);
+        ret = -1;
+    }
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fs) {
-                /*
-                 * If this fails (as it does on Special Snowflake NetBSD for no
-                 * good reason), it shouldn't affect the result of the test.
-                 */
-                (void) glfs_fini(fs);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fs) {
+        /*
+         * If this fails (as it does on Special Snowflake NetBSD for no
+         * good reason), it shouldn't affect the result of the test.
+         */
+        (void)glfs_fini(fs);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/glfd-lkowner.c b/tests/basic/gfapi/glfd-lkowner.c
index 031a076683c..ec0429dc3c4 100644
--- a/tests/basic/gfapi/glfd-lkowner.c
+++ b/tests/basic/gfapi/glfd-lkowner.c
@@ -13,200 +13,202 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-               fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 char lownera[8] = "lownera", lownerb[8] = "lownerb";
 char lownerc[8] = "lownerc";
 
-int lock_test (glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail,
-               int l1_start, int l1_len, char *l1_owner, int lo1_len,
-               int l2_start, int l2_len, char *l2_owner, int lo2_len)
+int
+lock_test(glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail, int l1_start,
+          int l1_len, char *l1_owner, int lo1_len, int l2_start, int l2_len,
+          char *l2_owner, int lo2_len)
 {
-        int ret = -1, f_ret = -1;
-        struct flock lock1 = {0, }, lock2 = {0, };
+    int ret = -1, f_ret = -1;
+    struct flock lock1 =
+                     {
+                         0,
+                     },
+                 lock2 = {
+                     0,
+                 };
 
 lock1:
-        if (!glfd1)
-                goto lock2;
+    if (!glfd1)
+        goto lock2;
 
-        /* lock on glfd1 */
-        lock1.l_type = F_WRLCK;
-        lock1.l_whence = SEEK_SET;
-        lock1.l_start = l1_start;
-        lock1.l_len = l1_len;
+    /* lock on glfd1 */
+    lock1.l_type = F_WRLCK;
+    lock1.l_whence = SEEK_SET;
+    lock1.l_start = l1_start;
+    lock1.l_len = l1_len;
 
-        ret = glfs_fd_set_lkowner (glfd1, l1_owner, lo1_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd1", ret);
+    ret = glfs_fd_set_lkowner(glfd1, l1_owner, lo1_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd1", ret);
 
-        ret = glfs_posix_lock (glfd1, F_SETLK, &lock1);
-        LOG_ERR ("glfs_posix_lock on glfd1", ret);
+    ret = glfs_posix_lock(glfd1, F_SETLK, &lock1);
+    LOG_ERR("glfs_posix_lock on glfd1", ret);
 
 lock2:
-        if (!glfd2)
-                goto out;
-
-        /* lock on glfd2 */
-        lock2.l_type = F_WRLCK;
-        lock2.l_whence = SEEK_SET;
-        lock2.l_start = l2_start;
-        lock2.l_len = l2_len;
-
-        ret = glfs_fd_set_lkowner (glfd2, l2_owner, lo2_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd2", ret);
-
-        ret = glfs_posix_lock (glfd2, F_SETLK, &lock2);
-
-        if (should_fail && ret) {
-                f_ret = 0;
-        } else if (!ret && !should_fail) {
-                f_ret = 0;
-        } else {
-                f_ret = -1;
-        }
+    if (!glfd2)
+        goto out;
+
+    /* lock on glfd2 */
+    lock2.l_type = F_WRLCK;
+    lock2.l_whence = SEEK_SET;
+    lock2.l_start = l2_start;
+    lock2.l_len = l2_len;
+
+    ret = glfs_fd_set_lkowner(glfd2, l2_owner, lo2_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd2", ret);
+
+    ret = glfs_posix_lock(glfd2, F_SETLK, &lock2);
+
+    if (should_fail && ret) {
+        f_ret = 0;
+    } else if (!ret && !should_fail) {
+        f_ret = 0;
+    } else {
+        f_ret = -1;
+    }
 out:
-        fprintf (stderr, "Lock test on glfd1 (start(%d), len(%d),"
-                         " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
-                         "lk_owner(%s)) - expected(%s) - result(%s)\n",
-                         l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
-                         (should_fail ? "FAIL" : "SUCCESS"),
-                         (ret ? "FAIL" : "SUCCESS"));
-        return f_ret;
+    fprintf(stderr,
+            "Lock test on glfd1 (start(%d), len(%d),"
+            " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
+            "lk_owner(%s)) - expected(%s) - result(%s)\n",
+            l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
+            (should_fail ? "FAIL" : "SUCCESS"), (ret ? "FAIL" : "SUCCESS"));
+    return f_ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd1 = NULL;
-        glfs_fd_t *fd2 = NULL;
-        glfs_fd_t *fd3 = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd1 = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd1 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd1 - %d\n", fd1);
-
-        fd2 = glfs_dup(fd1);
-        fprintf (stderr, "glfs-dup fd2 - %d\n", fd2);
-
-        fd3 = glfs_open(fs, filename, O_RDWR|O_SYNC);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open", ret);
-        }
-        fprintf (stderr, "glfs-open fd3 - %d\n", fd3);
-
-        /* TEST 1: Conflicting ranges, same lk_owner
-         * lock1 (0, 10, lownera)
-         * lock2 (5, 10, lownera)
-         * Expected: should not fail but get merged
-         */
-        ret = lock_test (fd1, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_1", ret);
-
-        /* TEST 2: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (5, 10, lownerb)
-         * Expected: should fail and not get merged
-         */
-        ret = lock_test (NULL, fd2, true, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_2", ret);
-
-        /* TEST 3: Different ranges, same lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (30, 10, lownera)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         30, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_3", ret);
-
-        /* TEST 4: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (50, 10, lownerb)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         50, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_4", ret);
-
-        /* TEST 5: Close fd1 & retry TEST2
-         * lock1 (not applicable)
-         * lock2 (5, 10, lownerb)
-         * Expected: should succeed now
-         */
-        ret = glfs_close(fd1);
-        LOG_ERR ("glfs_close", ret);
-
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_5", ret);
-
-        /* TEST 6: Check closing fd1 doesn't flush fd2 locks
-         * retry TEST 4 but with fd2 and fd3.
-         * lock1 (50, 10, lownerb) - already taken
-         * lock2 (55, 10, lownerc)
-         * Expected: should fail
-         */
-        ret = lock_test (NULL, fd3, true, 50, 10, lownerb, 8,
-                         55, 10, lownerc, 8);
-        LOG_ERR ("==== glfs_lock_test_6", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd1 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd1 - %d\n", fd1);
+
+    fd2 = glfs_dup(fd1);
+    fprintf(stderr, "glfs-dup fd2 - %d\n", fd2);
+
+    fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open", ret);
+    }
+    fprintf(stderr, "glfs-open fd3 - %d\n", fd3);
+
+    /* TEST 1: Conflicting ranges, same lk_owner
+     * lock1 (0, 10, lownera)
+     * lock2 (5, 10, lownera)
+     * Expected: should not fail but get merged
+     */
+    ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_1", ret);
+
+    /* TEST 2: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (5, 10, lownerb)
+     * Expected: should fail and not get merged
+     */
+    ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_2", ret);
+
+    /* TEST 3: Different ranges, same lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (30, 10, lownera)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_3", ret);
+
+    /* TEST 4: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (50, 10, lownerb)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_4", ret);
+
+    /* TEST 5: Close fd1 & retry TEST2
+     * lock1 (not applicable)
+     * lock2 (5, 10, lownerb)
+     * Expected: should succeed now
+     */
+    ret = glfs_close(fd1);
+    LOG_ERR("glfs_close", ret);
+
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_5", ret);
+
+    /* TEST 6: Check closing fd1 doesn't flush fd2 locks
+     * retry TEST 4 but with fd2 and fd3.
+     * lock1 (50, 10, lownerb) - already taken
+     * lock2 (55, 10, lownerc)
+     * Expected: should fail
+     */
+    ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8);
+    LOG_ERR("==== glfs_lock_test_6", ret);
 
 err:
-        ret = glfs_close(fd2);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd2);
+    LOG_ERR("glfs_close", ret);
 
-        ret = glfs_close(fd3);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd3);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/glfs_sysrq.c b/tests/basic/gfapi/glfs_sysrq.c
index c843c2a3559..13e06be6df2 100644
--- a/tests/basic/gfapi/glfs_sysrq.c
+++ b/tests/basic/gfapi/glfs_sysrq.c
@@ -10,52 +10,51 @@
 #include <glusterfs/api/glfs.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        /* cmdline arguments */
-        char   *host    = NULL;
-        char   *volume  = NULL;
-        char   *logfile = NULL;
-
-        /* other variables */
-        glfs_t *fs      = NULL;
-        int     ret     = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Usage: %s <host> <volume> <logfile>\n",
-                         argv[0]);
-                return -1;
-        }
-
-        host = argv[1];
-        volume = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volume);
-        if (!fs) {
-                return -1;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", host, 24007);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        /* checking of the results is easier in the script running this test */
-        glfs_sysrq (fs, GLFS_SYSRQ_HELP);
-        glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP);
-
-        glfs_fini (fs);
-
-        return 0;
+    /* cmdline arguments */
+    char *host = NULL;
+    char *volume = NULL;
+    char *logfile = NULL;
+
+    /* other variables */
+    glfs_t *fs = NULL;
+    int ret = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Usage: %s <host> <volume> <logfile>\n", argv[0]);
+        return -1;
+    }
+
+    host = argv[1];
+    volume = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volume);
+    if (!fs) {
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    /* checking of the results is easier in the script running this test */
+    glfs_sysrq(fs, GLFS_SYSRQ_HELP);
+    glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
+
+    glfs_fini(fs);
+
+    return 0;
 }
diff --git a/tests/basic/gfapi/glfs_xreaddirplus_r.c b/tests/basic/gfapi/glfs_xreaddirplus_r.c
index 17f4d1b1d57..0c4c79123eb 100644
--- a/tests/basic/gfapi/glfs_xreaddirplus_r.c
+++ b/tests/basic/gfapi/glfs_xreaddirplus_r.c
@@ -6,237 +6,237 @@
 #include <glusterfs/api/glfs-handles.h>
 #include <time.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label) do { \
-        if (!bool_var) {            \
-                fprintf (stderr, "%s : returned error (%s)\n", \
-                         func, strerror (errno)); \
-                ret = -1;                         \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label)      \
+    do {                                                                       \
+        if (!bool_var) {                                                       \
+            fprintf(stderr, "%s : returned error (%s)\n", func,                \
+                    strerror(errno));                                          \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 #define MAX_FILES_CREATE 10
-#define MAXPATHNAME      512
+#define MAXPATHNAME 512
 
 void
-assimilatetime (struct timespec *ts, struct timespec ts_st,
-                struct timespec ts_ed)
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
 {
-        if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
-                ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
-        } else {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
-                ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
-        }
-
-        if (ts->tv_nsec > 1000000000) {
-                ts->tv_nsec = ts->tv_nsec - 1000000000;
-                ts->tv_sec += 1;
-        }
-
-        return;
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
 }
 
 /*
  * Returns '%' difference between ts1 & ts2
  */
 int
-comparetime (struct timespec ts1, struct timespec ts2)
+comparetime(struct timespec ts1, struct timespec ts2)
 {
-        uint64_t ts1_n, ts2_n;
-        int pct = 0;
+    uint64_t ts1_n, ts2_n;
+    int pct = 0;
 
-        ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
-        ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
+    ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
+    ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
 
-        pct = ((ts1_n - ts2_n)*100)/ts1_n;
+    pct = ((ts1_n - ts2_n) * 100) / ts1_n;
 
-        return pct;
+    return pct;
 }
 
 int
-old_readdir (glfs_t *fs)
+old_readdir(glfs_t *fs)
 {
-        struct glfs_object     *root = NULL;
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        char buf[512];
-        struct dirent          *entry = NULL;
-        int                     ret = -1;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        root = glfs_h_lookupat (fs, NULL, "/", sb, 0);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!root, ret, out);
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) {
-                if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
-                        glhandle = glfs_h_lookupat (fs, root, "/", sb, 0);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!glhandle, ret, out);
-                }
+    struct glfs_object *root = NULL;
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    char buf[512];
+    struct dirent *entry = NULL;
+    int ret = -1;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    root = glfs_h_lookupat(fs, NULL, "/", sb, 0);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!root, ret, out);
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
+            glhandle = glfs_h_lookupat(fs, root, "/", sb, 0);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!glhandle,
+                                                  ret, out);
         }
+    }
 
-        glfs_closedir (fd);
+    glfs_closedir(fd);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-new_xreaddirplus (glfs_t *fs)
+new_xreaddirplus(glfs_t *fs)
 {
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        int                     ret = -1;
-        uint32_t                rflags = (GFAPI_XREADDIRP_STAT |
-                                          GFAPI_XREADDIRP_HANDLE);
-        struct glfs_xreaddirp_stat   *xstat = NULL;
-        struct dirent           de;
-        struct dirent          *pde = NULL;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
-        while (ret > 0 && pde != NULL) {
-                if (xstat) {
-                        sb = glfs_xreaddirplus_get_stat (xstat);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_stat", !!sb, ret, out);
-
-                        if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
-                                glhandle = glfs_xreaddirplus_get_object (xstat);
-                                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_object", !!glhandle, ret, out);
-                        }
-                }
-
-                if (xstat) {
-                        glfs_free(xstat);
-                        xstat = NULL;
-                }
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    int ret = -1;
+    uint32_t rflags = (GFAPI_XREADDIRP_STAT | GFAPI_XREADDIRP_HANDLE);
+    struct glfs_xreaddirp_stat *xstat = NULL;
+    struct dirent de;
+    struct dirent *pde = NULL;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+    while (ret > 0 && pde != NULL) {
+        if (xstat) {
+            sb = glfs_xreaddirplus_get_stat(xstat);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirplus_get_stat",
+                                                  !!sb, ret, out);
+
+            if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
+                glhandle = glfs_xreaddirplus_get_object(xstat);
+                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(
+                    "glfs_xreaddirplus_get_object", !!glhandle, ret, out);
+            }
+        }
 
-                ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+        if (xstat) {
+            glfs_free(xstat);
+            xstat = NULL;
+        }
 
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirp_r", ret, out);
+        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
 
-        }
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirp_r", ret, out);
+    }
 
-        if (xstat)
-                glfs_free(xstat);
+    if (xstat)
+        glfs_free(xstat);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret = -1;
-        glfs_t                 *fs = NULL;
-        char                   *volname = NULL;
-        char                   *logfile = NULL;
-        char                   *hostname = NULL;
-        char                   *my_file = "file_";
-        char                    my_file_name[MAXPATHNAME];
-        uint32_t                flags = O_RDWR|O_SYNC;
-        struct glfs_fd         *fd = NULL;
-        int                     i = 0;
-        int                     pct = 0;
-        struct timespec         timestamp = {0, 0}, st_timestamp, ed_timestamp;
-        struct timespec         otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
+    int ret = -1;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    char *my_file = "file_";
+    char my_file_name[MAXPATHNAME];
+    uint32_t flags = O_RDWR | O_SYNC;
+    struct glfs_fd *fd = NULL;
+    int i = 0;
+    int pct = 0;
+    struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp;
+    struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
 
-        fs = glfs_new (volname);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_new", !!fs, ret, out);
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
+    fs = glfs_new(volname);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
 
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s%d", my_file, i);
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
 
-                fd = glfs_creat(fs, my_file_name, flags, 0644);
-                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", !!fd, ret, out);
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
 
-                glfs_close (fd);
-        }
+        fd = glfs_creat(fs, my_file_name, flags, 0644);
+        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out);
 
-        /* measure performance using old readdir call and new xreaddirplus call and compare */
-        ret = clock_gettime (CLOCK_REALTIME, &ost_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+        glfs_close(fd);
+    }
 
-        ret = old_readdir (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("old_readdir", ret, out);
+    /* measure performance using old readdir call and new xreaddirplus call and
+     * compare */
+    ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &oed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = old_readdir(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out);
 
-        assimilatetime (&otimestamp, ost_timestamp, oed_timestamp);
+    ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        printf ("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                otimestamp.tv_sec, otimestamp.tv_nsec);
+    assimilatetime(&otimestamp, ost_timestamp, oed_timestamp);
 
+    printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           otimestamp.tv_sec, otimestamp.tv_nsec);
 
-        ret = clock_gettime (CLOCK_REALTIME, &st_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &st_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = new_xreaddirplus (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("new_xreaddirplus", ret, out);
+    ret = new_xreaddirplus(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &ed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        assimilatetime (&timestamp, st_timestamp, ed_timestamp);
+    assimilatetime(&timestamp, st_timestamp, ed_timestamp);
 
-        printf ("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                timestamp.tv_sec, timestamp.tv_nsec);
+    printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           timestamp.tv_sec, timestamp.tv_nsec);
 
+    pct = comparetime(otimestamp, timestamp);
+    printf("There is improvement by %d%%\n", pct);
 
-        pct = comparetime (otimestamp, timestamp);
-        printf ("There is improvement by %d%%\n", pct);
-
-        ret = 0;
+    ret = 0;
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
 
-        return ret;
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/libgfapi-fini-hang.c b/tests/basic/gfapi/libgfapi-fini-hang.c
index e192751f295..37800e3188b 100644
--- a/tests/basic/gfapi/libgfapi-fini-hang.c
+++ b/tests/basic/gfapi/libgfapi-fini-hang.c
@@ -8,56 +8,55 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d\n", func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-} while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d\n", func, ret);            \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i;
-        glfs_fd_t *fd = NULL;
-        char       readbuf[32];
-        char      *logname = NULL;
-        char      *hostname = NULL;
-        char      *volname = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-
-        if (argc < 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logname = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                exit(1);
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 0);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logname, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        /* Do not call glfs_init.
-         * glfs_fini() shouldn't hang in that case*/
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-        fprintf (stderr, "End of libgfapi_fini\n");
-
-        exit(0);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char readbuf[32];
+    char *logname = NULL;
+    char *hostname = NULL;
+    char *volname = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+
+    if (argc < 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logname = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        exit(1);
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 0);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logname, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    /* Do not call glfs_init.
+     * glfs_fini() shouldn't hang in that case*/
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
+    fprintf(stderr, "End of libgfapi_fini\n");
+
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/mandatory-lock-optimal.c b/tests/basic/gfapi/mandatory-lock-optimal.c
index 4142258c06d..34fef8d0b80 100644
--- a/tests/basic/gfapi/mandatory-lock-optimal.c
+++ b/tests/basic/gfapi/mandatory-lock-optimal.c
@@ -1,11 +1,13 @@
 /* Pre-requisites:-
  *
- * 1. Make sure that performance translators are switched off while running this test.
+ * 1. Make sure that performance translators are switched off while running this
+ * test.
  * 2. Perform the following volume set operation:
  *    # gluster volume set <VOLNAME> locks.mandatory-locking optimal
  * 3. For installation under non-standard paths, export LD_LIBRARY_PATH to
  *    automatically load exact libgfapi.so and compile this C file as follows:
- *    $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L <include path for libgfapi shared library>
+ *    $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L
+ * <include path for libgfapi shared library>
  */
 
 #include <errno.h>
@@ -70,434 +72,461 @@ off_t offset;
    Expected result : First write should fail with EAGAIN.
                      Second write should pass. */
 
-#define LOG_ERR(func, err) do {                                                         \
-        if (!fp)                                                                        \
-                fprintf (stderr, "\n%s : returned error (%s)\n", func, strerror (err)); \
-        else                                                                            \
-                fprintf (fp, "\n%s : returned error (%s)\n", func, strerror (err));     \
-        cleanup_and_exit (err);                                                         \
-} while (0)
-
-void cleanup_and_exit (int exit_status) {
-        if (exit_status || test_count != TOTAL_TEST_COUNT) {
-                fprintf (fp, "\nAborting due to some test failures.\n");
-                exit_status = 1;
-        } else
-                fprintf (fp, "\nAll tests ran successfully.\n");
-        if (fp)
-                fclose (fp);
-        if (fd)
-                glfs_close (fd);
-        if (fd1)
-                glfs_close (fd1);
-        if (fd2)
-                glfs_close (fd2);
-
-        glfs_unlink (fs1, fname);
-
-        if (fs1)
-                glfs_fini (fs1);
-        if (fs2)
-                glfs_fini (fs2);
-
-        exit (exit_status);
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!fp)                                                               \
+            fprintf(stderr, "\n%s : returned error (%s)\n", func,              \
+                    strerror(err));                                            \
+        else                                                                   \
+            fprintf(fp, "\n%s : returned error (%s)\n", func, strerror(err));  \
+        cleanup_and_exit(err);                                                 \
+    } while (0)
+
+void
+cleanup_and_exit(int exit_status)
+{
+    if (exit_status || test_count != TOTAL_TEST_COUNT) {
+        fprintf(fp, "\nAborting due to some test failures.\n");
+        exit_status = 1;
+    } else
+        fprintf(fp, "\nAll tests ran successfully.\n");
+    if (fp)
+        fclose(fp);
+    if (fd)
+        glfs_close(fd);
+    if (fd1)
+        glfs_close(fd1);
+    if (fd2)
+        glfs_close(fd2);
+
+    glfs_unlink(fs1, fname);
+
+    if (fs1)
+        glfs_fini(fs1);
+    if (fs2)
+        glfs_fini(fs2);
+
+    exit(exit_status);
 }
 
-glfs_t *new_client_create (char *hostname, char *volname, char *logfile_name) {
-        glfs_t *fs = NULL;
+glfs_t *
+new_client_create(char *hostname, char *volname, char *logfile_name)
+{
+    glfs_t *fs = NULL;
 
-        fs = glfs_new (volname);
-        if (!fs)
-                LOG_ERR ("glfs_new", errno);
+    fs = glfs_new(volname);
+    if (!fs)
+        LOG_ERR("glfs_new", errno);
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret)
-                LOG_ERR ("glfs_set_volfile_server", errno);
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret)
+        LOG_ERR("glfs_set_volfile_server", errno);
 
-        ret = glfs_set_logging (fs, logfile_name, 7);
-        if (ret)
-                LOG_ERR ("glfs_set_logging", errno);
+    ret = glfs_set_logging(fs, logfile_name, 7);
+    if (ret)
+        LOG_ERR("glfs_set_logging", errno);
 
-        ret = glfs_init (fs);
-        if (ret)
-                LOG_ERR ("glfs_init", errno);
+    ret = glfs_init(fs);
+    if (ret)
+        LOG_ERR("glfs_init", errno);
 
-        return fs;
+    return fs;
 }
 
-void run_test_1 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        /* On successful read, 0 is returned as there is no content inside the
-         * file
-         */
-        ret = glfs_read (fd2, buf1, 10, 0);
-        if (ret)
-                LOG_ERR ("glfs_read", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_1(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* On successful read, 0 is returned as there is no content inside the
+     * file
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_2 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_2(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_write (fd2, buf2, 10, 0);
-        if (ret == 10 || errno != EAGAIN)
-                LOG_ERR ("glfs_write", errno);
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_3 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        /* Still there is no content inside file. So following read should
-         * return 0
-         */
-        ret = glfs_read (fd2, buf1, 10, 0);
-        if (ret)
-                LOG_ERR ("glfs_read", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_3(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* Still there is no content inside file. So following read should
+     * return 0
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_4 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_4(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_write (fd2, buf2, 10, 0);
-        if (ret != 10)
-                LOG_ERR ("glfs_write", errno);
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_5 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_5(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_6 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_6(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
-        if (fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_7 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_7(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDWR | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDWR | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_ftruncate (fd2, 4, NULL, NULL);
-        if (ret == 0 || errno != EAGAIN)
-                LOG_ERR ("glfs_ftruncate", errno);
+    ret = glfs_ftruncate(fd2, 4, NULL, NULL);
+    if (ret == 0 || errno != EAGAIN)
+        LOG_ERR("glfs_ftruncate", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_8 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 10L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 5L;
-        lock.l_len = 2L;
-
-        ret = glfs_file_lock (fd2, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd3 = glfs_open (fs3, fname, O_RDWR | O_NONBLOCK);
-        if (!fd3)
-                LOG_ERR ("glfs_open", errno);
-
-        offset = glfs_lseek (fd3, 5L, SEEK_SET);
-        if (offset != 5)
-                LOG_ERR ("glfs_lseek", errno);
-
-        ret = glfs_write (fd3, buf2, 10, 0);
-        if (ret == 10 || errno != EAGAIN)
-                LOG_ERR ("glfs_write", errno);
-
-        offset = glfs_lseek (fd3, 8L, SEEK_SET);
-        if (offset != 8)
-                LOG_ERR ("glfs_lseek", errno);
-
-        ret = glfs_write (fd3, buf2, 10, 0);
-        if (ret != 10)
-                LOG_ERR ("glfs_write", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        ret = glfs_close (fd3);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd3 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_8(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 10L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 5L;
+    lock.l_len = 2L;
+
+    ret = glfs_file_lock(fd2, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd3 = glfs_open(fs3, fname, O_RDWR | O_NONBLOCK);
+    if (!fd3)
+        LOG_ERR("glfs_open", errno);
+
+    offset = glfs_lseek(fd3, 5L, SEEK_SET);
+    if (offset != 5)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
+
+    offset = glfs_lseek(fd3, 8L, SEEK_SET);
+    if (offset != 8)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    ret = glfs_close(fd3);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd3 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-int main (int argc, char *argv[]) {
-        char logfile[50];
-
-        if (argc != 4) {
-                fprintf (stderr, "Usage: %s <server ip/hostname> <volume name> <test log directory>\n", argv[0]);
-                return 0;
-        }
-
-        sprintf (logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log");
-        fp = fopen (logfile, "w");
-        if (!fp) {
-                fprintf (stderr, "\n%s\n", logfile);
-                LOG_ERR ("Log file creation", errno);
-        }
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-1.log");
-        fs1 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs1)
-                LOG_ERR ("client-1 creation", EINVAL);
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-2.log");
-        fs2 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs2)
-                LOG_ERR ("client-2 creation", EINVAL);
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-3.log");
-        fs3 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs3)
-                LOG_ERR ("client-3 creation", EINVAL);
-
-        fd = glfs_creat (fs1, fname, O_RDWR, 0644);
-        if (!fd)
-                LOG_ERR ("glfs_creat", errno);
-
-        test_count = 0;
-
-        run_test_1 (1);
-        run_test_2 (2);
-        run_test_3 (3);
-        run_test_4 (4);
-        run_test_5 (5);
-        run_test_6 (6);
-        run_test_7 (7);
-        run_test_8 (8);
-
-        cleanup_and_exit (0);
+int
+main(int argc, char *argv[])
+{
+    char logfile[50];
 
+    if (argc != 4) {
+        fprintf(stderr,
+                "Usage: %s <server ip/hostname> <volume name> <test log "
+                "directory>\n",
+                argv[0]);
         return 0;
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log");
+    fp = fopen(logfile, "w");
+    if (!fp) {
+        fprintf(stderr, "\n%s\n", logfile);
+        LOG_ERR("Log file creation", errno);
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-1.log");
+    fs1 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs1)
+        LOG_ERR("client-1 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-2.log");
+    fs2 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs2)
+        LOG_ERR("client-2 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-3.log");
+    fs3 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs3)
+        LOG_ERR("client-3 creation", EINVAL);
+
+    fd = glfs_creat(fs1, fname, O_RDWR, 0644);
+    if (!fd)
+        LOG_ERR("glfs_creat", errno);
+
+    test_count = 0;
+
+    run_test_1(1);
+    run_test_2(2);
+    run_test_3(3);
+    run_test_4(4);
+    run_test_5(5);
+    run_test_6(6);
+    run_test_7(7);
+    run_test_8(8);
+
+    cleanup_and_exit(0);
+
+    return 0;
 }
diff --git a/tests/basic/gfapi/seek.c b/tests/basic/gfapi/seek.c
index fb2f6361bf3..85ea9b88141 100644
--- a/tests/basic/gfapi/seek.c
+++ b/tests/basic/gfapi/seek.c
@@ -18,80 +18,82 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        glfs_t      *fs       = NULL;
-        int          ret      = 0;
-        glfs_fd_t   *fd       = NULL;
-        char        *filename = NULL;
-        char        *volname  = NULL;
-        char        *hostname = NULL;
-        struct stat  st       = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
-                                 argv[0]);
-                exit (1);
+    glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
+                argv[0]);
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    filename = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        perror("glfs_new() returned NULL");
+        return 1;
+    }
+
+    if (glfs_set_volfile_server(fs, "tcp", hostname, 24007)) {
+        perror("glfs_set_volfile_server");
+        return 1;
+    }
+
+    if (glfs_init(fs)) {
+        perror("glfs_init");
+        return 1;
+    }
+
+    fd = glfs_open(fs, filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("glfs_open");
+        return 1;
+    }
+
+    if (glfs_fstat(fd, &st)) {
+        perror("glfs_fstat");
+        return 1;
+    }
+
+    while (hole_end < st.st_size) {
+        hole_start = glfs_lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO)
+            /* no more holes */
+            break;
+        if (hole_start == -1) {
+            perror("no more holes");
+            break;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        filename = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                perror ("glfs_new() returned NULL");
-                return 1;
-        }
-
-        if (glfs_set_volfile_server (fs, "tcp", hostname, 24007)) {
-                perror ("glfs_set_volfile_server");
-                return 1;
+        hole_end = glfs_lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
         }
 
-        if (glfs_init (fs)) {
-                perror ("glfs_init");
-                return 1;
-        }
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
 
-        fd = glfs_open (fs, filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("glfs_open");
-                return 1;
-        }
+    glfs_close(fd);
 
-        if (glfs_fstat (fd, &st)) {
-                perror ("glfs_fstat");
-                return 1;
-        }
-
-        while (hole_end < st.st_size) {
-                hole_start = glfs_lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO)
-                        /* no more holes */
-                        break;
-                if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
-
-                hole_end = glfs_lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                }
-
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
-        }
-
-        glfs_close (fd);
-
-        if (fs) {
-                glfs_fini (fs);
-        }
+    if (fs) {
+        glfs_fini(fs);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/upcall-cache-invalidate.c b/tests/basic/gfapi/upcall-cache-invalidate.c
index 2014bb9dccf..078286a8956 100644
--- a/tests/basic/gfapi/upcall-cache-invalidate.c
+++ b/tests/basic/gfapi/upcall-cache-invalidate.c
@@ -9,204 +9,201 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        glfs_t                   *fs2 = NULL;
-        glfs_t                   *fs_tmp = NULL;
-        glfs_t                   *fs_tmp2 = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        glfs_fd_t                *fd2 = NULL;
-        glfs_fd_t                *fd_tmp = NULL;
-        glfs_fd_t                *fd_tmp2 = NULL;
-        char                      readbuf[32];
-        char                     *filename = "file_tmp";
-        char                     *writebuf = NULL;
-        char                     *vol_id  = NULL;
-        unsigned int              cnt = 1;
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        char                     *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *filename = "file_tmp";
+    char *writebuf = NULL;
+    char *vol_id = NULL;
+    unsigned int cnt = 1;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+    fprintf(stderr, "glfs-open fd2 - %d\n", fd2);
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
+                ret = -1;
+                LOG_ERR("glfs_write", ret);
+            } else {
+                fprintf(stderr, "glfs_write succeeded\n");
+            }
+            free(writebuf);
+        } else {
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
         }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
 
-        fs2 = glfs_new (volname);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new fs2: returned NULL\n");
-                return 1;
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
+        } else {
+            fprintf(stderr, "glfs_read: %s\n", readbuf);
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server-fs2", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging-fs2", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init-fs2", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
+        /* Open() fops seem to be not performed on server side until
+         * there are I/Os on that fd
+         */
+        if (cnt > 2) {
+            struct glfs_upcall_inode *in_arg = NULL;
+            enum glfs_upcall_reason reason = 0;
+            struct glfs_object *object = NULL;
+            uint64_t flags = 0;
+            uint64_t expire = 0;
+
+            ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+            LOG_ERR("glfs_h_poll_upcall", ret);
+
+            reason = glfs_upcall_get_reason(cbk);
+
+            /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
+            if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+                in_arg = glfs_upcall_get_event(cbk);
+
+                object = glfs_upcall_inode_get_object(in_arg);
+                flags = glfs_upcall_inode_get_flags(in_arg);
+                expire = glfs_upcall_inode_get_expire(in_arg);
+
+                fprintf(stderr,
+                        " upcall event type - %d,"
+                        " object(%p), flags(%d), "
+                        " expire_time_attr(%d)\n",
+                        reason, object, flags, expire);
+            } else {
+                fprintf(stderr, "Didn't receive upcall notify event");
                 ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
+                goto err;
+            }
 
-        fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open-fs2", ret);
+            glfs_free(cbk);
         }
-        fprintf (stderr, "glfs-open fd2 - %d\n", fd2);
-
-        do {
-                if (cnt%2) {
-                        fd_tmp = fd;
-                        fs_tmp = fs;
-                        fd_tmp2 = fd2;
-                        fs_tmp2 = fs2;
-                } else {
-                        fd_tmp = fd2;
-                        fs_tmp = fs2;
-                        fd_tmp2 = fd;
-                        fs_tmp2 = fs;
-                }
-
-                /* WRITE on fd_tmp */
-                writebuf = malloc(10);
-                if (writebuf) {
-                        memcpy (writebuf, "abcd", 4);
-                        ret = glfs_write (fd_tmp, writebuf, 4, 0);
-                        if (ret <= 0)   {
-                                ret = -1;
-                                LOG_ERR ("glfs_write", ret);
-                        } else {
-                                fprintf (stderr,
-                                         "glfs_write succeeded\n");
-                        }
-                        free(writebuf);
-                } else {
-                        fprintf (stderr,
-                                 "Could not allocate writebuf\n");
-                        return -1;
-                }
-
-                /* READ on fd_tmp2 */
-                ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
-                LOG_ERR ("glfs_lseek", ret);
-
-                memset (readbuf, 0, sizeof(readbuf));
-                ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL);
-
-                if (ret <= 0) {
-                        ret = -1;
-                        LOG_ERR ("glfs_pread", ret);
-                } else {
-                        fprintf (stderr, "glfs_read: %s\n", readbuf);
-                }
-
-                /* Open() fops seem to be not performed on server side until
-                 * there are I/Os on that fd
-                 */
-                if (cnt > 2) {
-                        struct glfs_upcall_inode *in_arg = NULL;
-                        enum glfs_upcall_reason   reason = 0;
-                        struct glfs_object       *object = NULL;
-                        uint64_t                  flags = 0;
-                        uint64_t                  expire = 0;
-
-                        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-                        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                        reason = glfs_upcall_get_reason (cbk);
-
-                        /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
-                        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                                in_arg = glfs_upcall_get_event (cbk);
-
-                                object = glfs_upcall_inode_get_object (in_arg);
-                                flags = glfs_upcall_inode_get_flags (in_arg);
-                                expire = glfs_upcall_inode_get_expire (in_arg);
-
-                                fprintf (stderr, " upcall event type - %d,"
-                                         " object(%p), flags(%d), "
-                                         " expire_time_attr(%d)\n" ,
-                                         reason, object, flags, expire);
-                        } else {
-                                fprintf (stderr,
-                                         "Didn't receive upcall notify event");
-                                ret = -1;
-                                goto err;
-                        }
-
-                        glfs_free (cbk);
-                }
-
-                sleep(5);
-        } while (++cnt < 5);
+
+        sleep(5);
+    } while (++cnt < 5);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
-        glfs_close(fd2);
-        LOG_ERR ("glfs_close-fd2", ret);
+    glfs_close(fd2);
+    LOG_ERR("glfs_close-fd2", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (fs2) {
-                ret = glfs_fini(fs2);
-                fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/upcall-register-api.c b/tests/basic/gfapi/upcall-register-api.c
index 994069c0446..78594dbb108 100644
--- a/tests/basic/gfapi/upcall-register-api.c
+++ b/tests/basic/gfapi/upcall-register-api.c
@@ -9,273 +9,278 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int upcall_recv = 0;
 
-void up_async_invalidate (struct glfs_upcall *up_arg, void *data)
+void
+up_async_invalidate(struct glfs_upcall *up_arg, void *data)
 {
-        struct glfs_upcall_inode *in_arg = NULL;
-        enum glfs_upcall_reason   reason = 0;
-        struct glfs_object       *object = NULL;
-        uint64_t                  flags = 0;
-        uint64_t                  expire = 0;
+    struct glfs_upcall_inode *in_arg = NULL;
+    enum glfs_upcall_reason reason = 0;
+    struct glfs_object *object = NULL;
+    uint64_t flags = 0;
+    uint64_t expire = 0;
 
-        if (!up_arg)
-                return;
-
-        reason = glfs_upcall_get_reason (up_arg);
-
-        /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
-
-        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                in_arg = glfs_upcall_get_event (up_arg);
-
-                object = glfs_upcall_inode_get_object (in_arg);
-                flags = glfs_upcall_inode_get_flags (in_arg);
-                expire = glfs_upcall_inode_get_expire (in_arg);
-
-                fprintf (stderr, " upcall event type - %d,"
-                                 " object(%p), flags(%d), "
-                                 " expire_time_attr(%d)\n" ,
-                                 reason, object, flags, expire);
-                upcall_recv++;
-        }
-
-        glfs_free (up_arg);
+    if (!up_arg)
         return;
-}
 
-int perform_io (glfs_t *fs, glfs_t *fs2, int cnt)
-{
-        glfs_t                   *fs_tmp = NULL;
-        glfs_t                   *fs_tmp2 = NULL;
-        glfs_fd_t                *fd_tmp = NULL;
-        glfs_fd_t                *fd_tmp2 = NULL;
-        char                      readbuf[32];
-        char                     *writebuf = NULL;
-        glfs_fd_t                *fd = NULL;
-        glfs_fd_t                *fd2 = NULL;
-        char                     *filename = "file_tmp";
-        int                       ret = -1;
-
-        if (!fs || !fs2)
-                return -1;
-
-        /* Create file from fs and open it from fs2 */
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
+    reason = glfs_upcall_get_reason(up_arg);
 
-        fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open-fs2", ret);
-        }
+    /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
 
-        do {
-                if (cnt%2) {
-                        fd_tmp = fd;
-                        fs_tmp = fs;
-                        fd_tmp2 = fd2;
-                        fs_tmp2 = fs2;
-                } else {
-                        fd_tmp = fd2;
-                        fs_tmp = fs2;
-                        fd_tmp2 = fd;
-                        fs_tmp2 = fs;
-                }
-
-                /* WRITE on fd_tmp */
-                writebuf = malloc(10);
-                if (writebuf) {
-                        memcpy (writebuf, "abcd", 4);
-                        ret = glfs_write (fd_tmp, writebuf, 4, 0);
-                        if (ret <= 0)   {
-                                ret = -1;
-                                LOG_ERR ("glfs_write", ret);
-                        }
-                        free(writebuf);
-                } else {
-                        fprintf (stderr,
-                                 "Could not allocate writebuf\n");
-                        return -1;
-                }
-
-                /* READ on fd_tmp2 */
-                ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
-                LOG_ERR ("glfs_lseek", ret);
-
-                memset (readbuf, 0, sizeof(readbuf));
-                ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL);
-
-                if (ret <= 0) {
-                        ret = -1;
-                        LOG_ERR ("glfs_pread", ret);
-                }
-
-                sleep(2);
-        } while (--cnt > 0);
+    if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+        in_arg = glfs_upcall_get_event(up_arg);
 
-        sleep(2);
+        object = glfs_upcall_inode_get_object(in_arg);
+        flags = glfs_upcall_inode_get_flags(in_arg);
+        expire = glfs_upcall_inode_get_expire(in_arg);
 
-        ret = 0;
-err:
-        glfs_close(fd);
+        fprintf(stderr,
+                " upcall event type - %d,"
+                " object(%p), flags(%d), "
+                " expire_time_attr(%d)\n",
+                reason, object, flags, expire);
+        upcall_recv++;
+    }
 
-        glfs_close(fd2);
-
-out:
-        return ret;
+    glfs_free(up_arg);
+    return;
 }
 
 int
-main (int argc, char *argv[])
+perform_io(glfs_t *fs, glfs_t *fs2, int cnt)
 {
-        glfs_t                   *fs = NULL;
-        glfs_t                   *fs2 = NULL;
-        int                       ret = 0, i;
-        char                     *vol_id  = NULL;
-        unsigned int              cnt = 5;
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        char                     *hostname = NULL;
-        int                      up_events = GLFS_EVENT_ANY;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        /* Initialize fs */
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        /* Initialize fs2 */
-        fs2 = glfs_new (volname);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new fs2: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server-fs2", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging-fs2", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init-fs2", ret);
-
-        /* Register Upcalls */
-        ret = glfs_upcall_register (fs, up_events, up_async_invalidate, NULL);
-
-        /* Check if the return mask contains the event */
-        if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
-        }
-
-        ret = glfs_upcall_register (fs2, up_events, up_async_invalidate, NULL);
-
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *writebuf = NULL;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *filename = "file_tmp";
+    int ret = -1;
+
+    if (!fs || !fs2)
+        return -1;
+
+    /* Create file from fs and open it from fs2 */
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
         }
 
-        /* Perform I/O */
-        ret = perform_io (fs, fs2, cnt);
-        LOG_ERR("perform_io", ret);
-
-        if (upcall_recv == 0) {
-                fprintf (stderr, "Upcalls are not received.\n");
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
                 ret = -1;
+                LOG_ERR("glfs_write", ret);
+            }
+            free(writebuf);
         } else {
-                fprintf (stderr, "Received %d upcalls as expected\n",
-                         upcall_recv);
-                ret = 0;
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
         }
 
-        sleep(5); /* to flush out previous upcalls if any */
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
 
-        /* Now unregister and check there are no upcall events received */
-        ret = glfs_upcall_unregister (fs, up_events);
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
 
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
         }
 
-        ret = glfs_upcall_unregister (fs2, up_events);
+        sleep(2);
+    } while (--cnt > 0);
 
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
-        }
+    sleep(2);
 
-        upcall_recv = 0;
+    ret = 0;
+err:
+    glfs_close(fd);
 
-        ret = perform_io (fs, fs2, cnt);
-        LOG_ERR("perform_io", ret);
-
-        if (upcall_recv != 0) {
-                fprintf (stderr, "%d upcalls received even after unregister.\n",
-                         upcall_recv);
-                ret = -1;
-        } else {
-                fprintf (stderr, "Post unregister, no upcalls received as"
-                         " expected\n");
-                ret = 0;
-        }
+    glfs_close(fd2);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        if (fs2) {
-                ret = glfs_fini(fs2);
-                fprintf (stderr, "glfs_fini(fs2) returned %d\n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    return ret;
 }
 
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    char *vol_id = NULL;
+    unsigned int cnt = 5;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int up_events = GLFS_EVENT_ANY;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    /* Initialize fs */
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* Initialize fs2 */
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    /* Register Upcalls */
+    ret = glfs_upcall_register(fs, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_register(fs2, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    /* Perform I/O */
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv == 0) {
+        fprintf(stderr, "Upcalls are not received.\n");
+        ret = -1;
+    } else {
+        fprintf(stderr, "Received %d upcalls as expected\n", upcall_recv);
+        ret = 0;
+    }
+
+    sleep(5); /* to flush out previous upcalls if any */
+
+    /* Now unregister and check there are no upcall events received */
+    ret = glfs_upcall_unregister(fs, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_unregister(fs2, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    upcall_recv = 0;
+
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv != 0) {
+        fprintf(stderr, "%d upcalls received even after unregister.\n",
+                upcall_recv);
+        ret = -1;
+    } else {
+        fprintf(stderr,
+                "Post unregister, no upcalls received as"
+                " expected\n");
+        ret = 0;
+    }
 
+out:
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
+}
diff --git a/tests/basic/logchecks.c b/tests/basic/logchecks.c
index a40278b0d77..86891057230 100644
--- a/tests/basic/logchecks.c
+++ b/tests/basic/logchecks.c
@@ -18,191 +18,197 @@
 #include "logchecks-messages.h"
 #include "../../libglusterfs/src/logging.h"
 
-glusterfs_ctx_t   *ctx = NULL;
+glusterfs_ctx_t *ctx = NULL;
 
-#define TEST_FILENAME           "/tmp/logchecks.log"
-#define GF_LOG_CONTROL_FILE     "/etc/glusterfs/logger.conf"
+#define TEST_FILENAME "/tmp/logchecks.log"
+#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf"
 
 int
 go_log_vargs(gf_loglevel_t level, const char *fmt, ...)
 {
-        va_list  ap;
+    va_list ap;
 
-        va_start (ap, fmt);
-        gf_msg_vplain (level, fmt, ap);
-        va_end (ap);
+    va_start(ap, fmt);
+    gf_msg_vplain(level, fmt, ap);
+    va_end(ap);
 
-        return 0;
+    return 0;
 }
 
 int
-go_log (void)
+go_log(void)
 {
-        /*** gf_msg ***/
-        gf_msg ("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
-        gf_msg ("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two",
-                42);
-        /* change criticality */
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42,
-                "Forty-Two", 42);
-
-        /*** msg_nomem ***/
-        gf_msg_nomem ("logchecks", GF_LOG_ALERT, 555);
-        gf_msg_nomem ("logchecks", GF_LOG_INFO, 555);
-
-        /*** msg_plain ***/
-        gf_msg_plain (GF_LOG_INFO, "Informational: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        gf_msg_plain (GF_LOG_ALERT, "Alert: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_vplain ***/
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_plain_nomem ***/
-        gf_msg_plain_nomem (GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
-        gf_msg_plain_nomem (GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
-
-        /*** msg_backtrace_nomem ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_backtrace_nomem (GF_LOG_INFO, 5);
-        gf_msg_backtrace_nomem (GF_LOG_ALERT, 5);
-
-        /*** gf_msg_callingfn ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
-                          "Forty-Two", 42);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
-                          "Forty-Two", 42);
-
-        /*** gf_msg_debug ***/
-        gf_msg_debug ("logchecks", 0, "Debug: Hello World!!!");
-        gf_msg_debug ("logchecks", 22, "Debug: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_trace ***/
-        gf_msg_trace ("logchecks", 0, "Trace: Hello World!!!");
-        gf_msg_trace ("logchecks", 22, "Trace: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_backtrace ***/
-        // TODO: Test with lower callstr values to check truncation
-
-        return 0;
+    /*** gf_msg ***/
+    gf_msg("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
+    gf_msg("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two", 42);
+    /* change criticality */
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42, "Forty-Two",
+           42);
+
+    /*** msg_nomem ***/
+    gf_msg_nomem("logchecks", GF_LOG_ALERT, 555);
+    gf_msg_nomem("logchecks", GF_LOG_INFO, 555);
+
+    /*** msg_plain ***/
+    gf_msg_plain(GF_LOG_INFO,
+                 "Informational: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    gf_msg_plain(GF_LOG_ALERT,
+                 "Alert: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_vplain ***/
+    go_log_vargs(GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Informational: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    go_log_vargs(GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Critical: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_plain_nomem ***/
+    gf_msg_plain_nomem(GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
+
+    /*** msg_backtrace_nomem ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_backtrace_nomem(GF_LOG_INFO, 5);
+    gf_msg_backtrace_nomem(GF_LOG_ALERT, 5);
+
+    /*** gf_msg_callingfn ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
+                     "Forty-Two", 42);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
+                     "Forty-Two", 42);
+
+    /*** gf_msg_debug ***/
+    gf_msg_debug("logchecks", 0, "Debug: Hello World!!!");
+    gf_msg_debug("logchecks", 22, "Debug: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_trace ***/
+    gf_msg_trace("logchecks", 0, "Trace: Hello World!!!");
+    gf_msg_trace("logchecks", 22, "Trace: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_backtrace ***/
+    // TODO: Test with lower callstr values to check truncation
+
+    return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                ret = -1;
-
-        unlink (GF_LOG_CONTROL_FILE);
-        creat (GF_LOG_CONTROL_FILE, O_RDONLY);
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return -1;
-
-        ret = glusterfs_globals_init (ctx);
-        if (ret) {
-                printf ("Error from glusterfs_globals_init [%s]\n",
-                        strerror (errno));
-                return ret;
-        }
-
-        /* Pre init test, message should not be printed */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
-
-        THIS->ctx = ctx;
-
-        /* TEST 1: messages before initializing the log, goes to stderr
-         * and syslog based on criticality */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 2: messages post initialization, goes to glusterlog and
-         * syslog based on severity */
-        ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
-        if (ret != 0) {
-                printf ("Error from gf_log_init [%s]\n", strerror (errno));
-                return -1;
-        }
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 3: Test rotation */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_logrotate (0);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 4: Check flush, nothing noticeable should occur :) */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_flush ();
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 5: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 6: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (ctx, GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* Reset to run with syslog */
-        gf_log_set_logformat (gf_logformat_withmsgid);
-        gf_log_set_loglevel (ctx, GF_LOG_INFO);
-
-        /* Run tests with logger changed to syslog */
-        /* TEST 7: No more gluster logs */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logger (gf_logger_syslog);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 8: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 9: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (ctx, GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        // TODO: signal crash prints, but not yet feasible here
-        // TODO: Graph printing
-        // TODO: Multi threaded logging
-
-        /* Close out the logging */
-        gf_log_fini (ctx);
-        gf_log_globals_fini ();
-
-        unlink (GF_LOG_CONTROL_FILE);
-        unlink (TEST_FILENAME);
-
-        return 0;
+    int ret = -1;
+
+    unlink(GF_LOG_CONTROL_FILE);
+    creat(GF_LOG_CONTROL_FILE, O_RDONLY);
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return -1;
+
+    ret = glusterfs_globals_init(ctx);
+    if (ret) {
+        printf("Error from glusterfs_globals_init [%s]\n", strerror(errno));
+        return ret;
+    }
+
+    /* Pre init test, message should not be printed */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
+
+    THIS->ctx = ctx;
+
+    /* TEST 1: messages before initializing the log, goes to stderr
+     * and syslog based on criticality */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 2: messages post initialization, goes to glusterlog and
+     * syslog based on severity */
+    ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
+    if (ret != 0) {
+        printf("Error from gf_log_init [%s]\n", strerror(errno));
+        return -1;
+    }
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 3: Test rotation */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_logrotate(0);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 4: Check flush, nothing noticeable should occur :) */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_flush();
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 5: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 6: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* Reset to run with syslog */
+    gf_log_set_logformat(gf_logformat_withmsgid);
+    gf_log_set_loglevel(ctx, GF_LOG_INFO);
+
+    /* Run tests with logger changed to syslog */
+    /* TEST 7: No more gluster logs */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logger(gf_logger_syslog);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 8: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 9: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    // TODO: signal crash prints, but not yet feasible here
+    // TODO: Graph printing
+    // TODO: Multi threaded logging
+
+    /* Close out the logging */
+    gf_log_fini(ctx);
+    gf_log_globals_fini();
+
+    unlink(GF_LOG_CONTROL_FILE);
+    unlink(TEST_FILENAME);
+
+    return 0;
 }
diff --git a/tests/basic/posix/zero-fill-enospace.c b/tests/basic/posix/zero-fill-enospace.c
index 7c0d31128b3..1371ff59a5f 100644
--- a/tests/basic/posix/zero-fill-enospace.c
+++ b/tests/basic/posix/zero-fill-enospace.c
@@ -3,62 +3,64 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-        int        size = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    int size = 0;
 
-        if (argc != 6) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 6) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n",
+                argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, argv[4], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, argv[4], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        size = atoi(argv[5]);
-        if (size < 0) {
-                fprintf (stderr, "Wrong size %s", argv[5]);
-                goto out;
-        }
-        ret = glfs_zerofill (fd, 0, atoi(argv[5]));
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_zerofill: returned %d\n", ret);
-                goto out;
-        }
+    size = atoi(argv[5]);
+    if (size < 0) {
+        fprintf(stderr, "Wrong size %s", argv[5]);
+        goto out;
+    }
+    ret = glfs_zerofill(fd, 0, atoi(argv[5]));
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_zerofill: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/basic/quota.c b/tests/basic/quota.c
index f69b0ea9bc5..809ceb8e54c 100644
--- a/tests/basic/quota.c
+++ b/tests/basic/quota.c
@@ -8,83 +8,82 @@
 #include <unistd.h>
 
 ssize_t
-nwrite (int fd, const void *buf, size_t count)
+nwrite(int fd, const void *buf, size_t count)
 {
-        ssize_t  ret        = 0;
-        ssize_t  written    = 0;
+    ssize_t ret = 0;
+    ssize_t written = 0;
 
-        for (written = 0; written != count; written += ret) {
-                ret = write (fd, buf + written, count - written);
-                if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+    for (written = 0; written != count; written += ret) {
+        ret = write(fd, buf + written, count - written);
+        if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = written;
+    ret = written;
 out:
-        return ret;
+    return ret;
 }
 
 int
-file_write (char *filename, int bs, int count)
+file_write(char *filename, int bs, int count)
 {
-        int  fd              = 0;
-        int  ret             = -1;
-        int  i               = 0;
-        char *buf            = NULL;
+    int fd = 0;
+    int ret = -1;
+    int i = 0;
+    char *buf = NULL;
 
-        bs = bs * 1024;
+    bs = bs * 1024;
 
-        buf = (char *) malloc (bs);
-        if (buf == NULL)
-                goto out;
+    buf = (char *)malloc(bs);
+    if (buf == NULL)
+        goto out;
 
-        memset (buf, 0, bs);
+    memset(buf, 0, bs);
 
-        fd = open (filename, O_RDWR|O_CREAT|O_SYNC, 0600);
-        while (i < count) {
-                ret = nwrite(fd, buf, bs);
-                if (ret == -1) {
-                        close (fd);
-                        goto out;
-                }
-                i++;
+    fd = open(filename, O_RDWR | O_CREAT | O_SYNC, 0600);
+    while (i < count) {
+        ret = nwrite(fd, buf, bs);
+        if (ret == -1) {
+            close(fd);
+            goto out;
         }
+        i++;
+    }
 
-        ret = fdatasync(fd);
-        if (ret) {
-                close (fd);
-                goto out;
-        }
+    ret = fdatasync(fd);
+    if (ret) {
+        close(fd);
+        goto out;
+    }
 
-        ret = close(fd);
-        if (ret)
-                goto out;
+    ret = close(fd);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (buf)
-                free (buf);
-        return ret;
+    if (buf)
+        free(buf);
+    return ret;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        if (argc != 4) {
-                printf("Usage: %s <filename> <block size in k> <count>\n",
-                        argv[0]);
-                return EXIT_FAILURE;
-        }
+    if (argc != 4) {
+        printf("Usage: %s <filename> <block size in k> <count>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        if (file_write (argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
-                perror ("write failed");
-                return EXIT_FAILURE;
-        }
+    if (file_write(argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
+        perror("write failed");
+        return EXIT_FAILURE;
+    }
 
-        return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }
diff --git a/tests/basic/tier/file_lock.c b/tests/basic/tier/file_lock.c
index 730cca92e42..20fdbc0f668 100644
--- a/tests/basic/tier/file_lock.c
+++ b/tests/basic/tier/file_lock.c
@@ -3,73 +3,70 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-
-void usage (void)
+void
+usage(void)
 {
-
-        printf ("Usage: testlock <filepath> [R|W]\n");
-        return;
+    printf("Usage: testlock <filepath> [R|W]\n");
+    return;
 }
 
-
-int main (int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        char *file_path = NULL;
-        int fd = -1;
-        struct flock lock = {0};
-        int ret = -1;
-        int c = 0;
-
-        if (argc != 3) {
-                usage ();
-                exit (1);
-        }
-
-        file_path = argv[1];
-        fd = open (file_path, O_RDWR);
-
-        if (-1 == fd) {
-                printf ("Failed to open file %s. %m\n", file_path);
-                exit (1);
-        }
-
-        /* TODO: Check for invalid input*/
-
-        if (!strcmp (argv[2], "W")) {
-                lock.l_type = F_WRLCK;
-                printf("Taking write lock\n");
-
-        } else {
-                lock.l_type = F_RDLCK;
-                printf("Taking read lock\n");
-        }
-
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-        lock.l_pid = getpid ();
-
-
-        printf ("Acquiring lock on %s\n", file_path);
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to acquire lock on %s (%m)\n", file_path);
-                close (fd);
-                exit (1);
-        }
-
-        sleep(10);
-
-        /*Unlock*/
-
-        printf ("Releasing lock on %s\n", file_path);
-        lock.l_type = F_UNLCK;
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to release lock on %s (%m)\n", file_path);
-        }
-
-        close (fd);
-        return ret;
-
+    char *file_path = NULL;
+    int fd = -1;
+    struct flock lock = {0};
+    int ret = -1;
+    int c = 0;
+
+    if (argc != 3) {
+        usage();
+        exit(1);
+    }
+
+    file_path = argv[1];
+    fd = open(file_path, O_RDWR);
+
+    if (-1 == fd) {
+        printf("Failed to open file %s. %m\n", file_path);
+        exit(1);
+    }
+
+    /* TODO: Check for invalid input*/
+
+    if (!strcmp(argv[2], "W")) {
+        lock.l_type = F_WRLCK;
+        printf("Taking write lock\n");
+
+    } else {
+        lock.l_type = F_RDLCK;
+        printf("Taking read lock\n");
+    }
+
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+    lock.l_pid = getpid();
+
+    printf("Acquiring lock on %s\n", file_path);
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret) {
+        printf("Failed to acquire lock on %s (%m)\n", file_path);
+        close(fd);
+        exit(1);
+    }
+
+    sleep(10);
+
+    /*Unlock*/
+
+    printf("Releasing lock on %s\n", file_path);
+    lock.l_type = F_UNLCK;
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret) {
+        printf("Failed to release lock on %s (%m)\n", file_path);
+    }
+
+    close(fd);
+    return ret;
 }
diff --git a/tests/bitrot/br-stub.c b/tests/bitrot/br-stub.c
index 5b862832e77..1111f710f59 100644
--- a/tests/bitrot/br-stub.c
+++ b/tests/bitrot/br-stub.c
@@ -15,179 +15,181 @@
 
 /* NOTE: no size discovery */
 int
-brstub_validate_version (char *bpath, unsigned long version)
+brstub_validate_version(char *bpath, unsigned long version)
 {
-        int ret = 0;
-        int match = 0;
-        size_t xsize = 0;
-        br_version_t *xv = NULL;
-
-        xsize = sizeof (br_version_t);
-
-        xv = calloc (1, xsize);
-        if (!xv) {
-                match = -1;
-                goto err;
-        }
-
-        ret = getxattr (bpath, "trusted.bit-rot.version", xv, xsize);
-        if (ret < 0) {
-                if (errno == ENODATA)
-                        match = -2;
-                goto err;
-        }
-
-        if (xv->ongoingversion != version) {
-                match = -3;
-                fprintf (stderr, "ongoingversion: %lu\n", xv->ongoingversion);
-        }
-        free (xv);
-
- err:
-        return match;
+    int ret = 0;
+    int match = 0;
+    size_t xsize = 0;
+    br_version_t *xv = NULL;
+
+    xsize = sizeof(br_version_t);
+
+    xv = calloc(1, xsize);
+    if (!xv) {
+        match = -1;
+        goto err;
+    }
+
+    ret = getxattr(bpath, "trusted.bit-rot.version", xv, xsize);
+    if (ret < 0) {
+        if (errno == ENODATA)
+            match = -2;
+        goto err;
+    }
+
+    if (xv->ongoingversion != version) {
+        match = -3;
+        fprintf(stderr, "ongoingversion: %lu\n", xv->ongoingversion);
+    }
+    free(xv);
+
+err:
+    return match;
 }
 
 int
-brstub_write_validation (char *filp, char *bpath, unsigned long startversion)
+brstub_write_validation(char *filp, char *bpath, unsigned long startversion)
 {
-        int fd1 = 0;
-        int fd2 = 0;
-        int ret = 0;
-        char *string = "string\n";
-
-        /* read only check */
-        fd1 = open (filp, O_RDONLY);
-        if (fd1 < 0)
-                goto err;
-        close (fd1);
-
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != -2)
-                goto err;
-
-        /* single open (write/) check */
-        fd1 = open (filp, O_RDWR);
-        if (fd1 < 0)
-                goto err;
-
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-        /**
-         * Fsync is done so that the write call has properly reached the
-         * disk. For fuse mounts write-behind xlator would have held the
-         * writes with itself and for nfs, client would have held the
-         * write in its cache. So write fop would not have triggered the
-         * versioning as it would have not reached the bit-rot-stub.
-         */
-        fsync (fd1);
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-        fsync (fd1); /* let it reach the disk */
-
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-
-        close (fd1);
-
-        /**
-         * Well, this is not a _real_ test per se . For this test to pass
-         * the inode should not get a forget() in the interim. Therefore,
-         * perform this test asap.
-         */
-
-        /* multi open (write/) check */
-        fd1 = open (filp, O_RDWR);
-        if (fd1 < 0)
-                goto err;
-        fd2 = open (filp, O_WRONLY);
-        if (fd1 < 0)
-                goto err;
-
-        ret = write (fd1, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-
-        ret = write (fd2, string, strlen (string));
-        if (ret <= 0)
-                goto err;
-
-        /* probably do a syncfs() */
-        fsync (fd1);
-        fsync (fd2);
-
-        close (fd1);
-        close (fd2);
-
-        /**
-         * incremented once per write()/write().../close()/close() sequence
-         */
-        ret = brstub_validate_version (bpath, startversion);
-        if (ret != 0)
-                goto err;
-
-        return 0;
-
- err:
-        return -1;
+    int fd1 = 0;
+    int fd2 = 0;
+    int ret = 0;
+    char *string = "string\n";
+
+    /* read only check */
+    fd1 = open(filp, O_RDONLY);
+    if (fd1 < 0)
+        goto err;
+    close(fd1);
+
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != -2)
+        goto err;
+
+    /* single open (write/) check */
+    fd1 = open(filp, O_RDWR);
+    if (fd1 < 0)
+        goto err;
+
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+    /**
+     * Fsync is done so that the write call has properly reached the
+     * disk. For fuse mounts write-behind xlator would have held the
+     * writes with itself and for nfs, client would have held the
+     * write in its cache. So write fop would not have triggered the
+     * versioning as it would have not reached the bit-rot-stub.
+     */
+    fsync(fd1);
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+    fsync(fd1); /* let it reach the disk */
+
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+
+    close(fd1);
+
+    /**
+     * Well, this is not a _real_ test per se . For this test to pass
+     * the inode should not get a forget() in the interim. Therefore,
+     * perform this test asap.
+     */
+
+    /* multi open (write/) check */
+    fd1 = open(filp, O_RDWR);
+    if (fd1 < 0)
+        goto err;
+    fd2 = open(filp, O_WRONLY);
+    if (fd1 < 0)
+        goto err;
+
+    ret = write(fd1, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+
+    ret = write(fd2, string, strlen(string));
+    if (ret <= 0)
+        goto err;
+
+    /* probably do a syncfs() */
+    fsync(fd1);
+    fsync(fd2);
+
+    close(fd1);
+    close(fd2);
+
+    /**
+     * incremented once per write()/write().../close()/close() sequence
+     */
+    ret = brstub_validate_version(bpath, startversion);
+    if (ret != 0)
+        goto err;
+
+    return 0;
+
+err:
+    return -1;
 }
 
 int
-brstub_new_object_validate (char *filp, char *brick)
+brstub_new_object_validate(char *filp, char *brick)
 {
-        int ret = 0;
-        char *fname = NULL;
-        char bpath[PATH_MAX] = {0,};
+    int ret = 0;
+    char *fname = NULL;
+    char bpath[PATH_MAX] = {
+        0,
+    };
 
-        fname = basename (filp);
-        if (!fname)
-                goto err;
+    fname = basename(filp);
+    if (!fname)
+        goto err;
 
-        (void) snprintf (bpath, PATH_MAX, "%s/%s", brick, fname);
+    (void)snprintf(bpath, PATH_MAX, "%s/%s", brick, fname);
 
-        printf ("Validating initial version..\n");
-        ret = brstub_validate_version (bpath, 2);
-        if (ret != -2) /* version _should_ be missing */
-                goto err;
+    printf("Validating initial version..\n");
+    ret = brstub_validate_version(bpath, 2);
+    if (ret != -2) /* version _should_ be missing */
+        goto err;
 
-        printf ("Validating version on modifications..\n");
-        ret = brstub_write_validation (filp, bpath, 2);
-        if (ret < 0)
-                goto err;
+    printf("Validating version on modifications..\n");
+    ret = brstub_write_validation(filp, bpath, 2);
+    if (ret < 0)
+        goto err;
 
-        return 0;
+    return 0;
 
- err:
-        return -1;
+err:
+    return -1;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int ret = 0;
-        char *filp = NULL;
-        char *brick = NULL;
+    int ret = 0;
+    char *filp = NULL;
+    char *brick = NULL;
 
-        if (argc != 3) {
-                printf ("Usage: %s <path> <brick>\n", argv[0]);
-                goto err;
-        }
+    if (argc != 3) {
+        printf("Usage: %s <path> <brick>\n", argv[0]);
+        goto err;
+    }
 
-        filp = argv[1];
-        brick = argv[2];
+    filp = argv[1];
+    brick = argv[2];
 
-        printf ("Validating object version [%s]\n", filp);
-        ret = brstub_new_object_validate (filp, brick);
-        if (ret < 0)
-                goto err;
+    printf("Validating object version [%s]\n", filp);
+    ret = brstub_new_object_validate(filp, brick);
+    if (ret < 0)
+        goto err;
 
-        return 0;
+    return 0;
 
- err:
-        return -1;
+err:
+    return -1;
 }
diff --git a/tests/bugs/access-control/bug-1051896.c b/tests/bugs/access-control/bug-1051896.c
index 27aa1559453..31799d97a71 100644
--- a/tests/bugs/access-control/bug-1051896.c
+++ b/tests/bugs/access-control/bug-1051896.c
@@ -13,85 +13,82 @@
 #include <utime.h>
 #include <sys/acl.h>
 
-int do_setfacl(const char *path, const char *options, const char *textacl)
+int
+do_setfacl(const char *path, const char *options, const char *textacl)
 {
-	int r;
-	int type;
-	acl_t acl;
-	int dob;
-	int dok;
-	int dom;
-	struct stat st;
-	char textmode[30];
+    int r;
+    int type;
+    acl_t acl;
+    int dob;
+    int dok;
+    int dom;
+    struct stat st;
+    char textmode[30];
 
-	r = 0;
-	dob = strchr(options, 'b') != (char *)NULL;
-	dok = strchr(options, 'k') != (char *)NULL;
-	dom = strchr(options, 'm') != (char *)NULL;
-	if ((dom && !textacl)
-	    || (!dom && (textacl || (!dok && !dob) ||
-                                    strchr(options, 'd')))) {
-		errno = EBADRQC; /* "bad request" */
-		r = -1;
-	} else {
-		if (dob || dok) {
-			r = acl_delete_def_file(path);
-		}
-		if (dob && !r) {
-			if (!stat(path, &st)) {
-				sprintf(textmode,
-                                        "u::%c%c%c,g::%c%c%c,o::%c%c%c",
-					(st.st_mode & 0400 ? 'r' : '-'),
-					(st.st_mode & 0200 ? 'w' : '-'),
-					(st.st_mode & 0100 ? 'x' : '-'),
-					(st.st_mode & 0040 ? 'r' : '-'),
-					(st.st_mode & 0020 ? 'w' : '-'),
-					(st.st_mode & 0010 ? 'x' : '-'),
-					(st.st_mode & 004 ? 'r' : '-'),
-					(st.st_mode & 002 ? 'w' : '-'),
-					(st.st_mode & 001 ? 'x' : '-'));
-				acl = acl_from_text(textmode);
-				if (acl) {
-					r = acl_set_file(path,
-                                                         ACL_TYPE_ACCESS, acl);
-					acl_free(acl);
-				} else
-					r = -1;
-			} else
-				r = -1;
-		}
-		if (!r && dom) {
-			if (strchr(options, 'd'))
-				type = ACL_TYPE_DEFAULT;
-			else
-				type = ACL_TYPE_ACCESS;
-			acl = acl_from_text(textacl);
-			if (acl) {
-				r = acl_set_file(path, type, acl);
-				acl_free(acl);
-			} else
-				r = -1;
-		}
-	}
-	if (r)
-		r = -errno;
-	return r;
+    r = 0;
+    dob = strchr(options, 'b') != (char *)NULL;
+    dok = strchr(options, 'k') != (char *)NULL;
+    dom = strchr(options, 'm') != (char *)NULL;
+    if ((dom && !textacl) ||
+        (!dom && (textacl || (!dok && !dob) || strchr(options, 'd')))) {
+        errno = EBADRQC; /* "bad request" */
+        r = -1;
+    } else {
+        if (dob || dok) {
+            r = acl_delete_def_file(path);
+        }
+        if (dob && !r) {
+            if (!stat(path, &st)) {
+                sprintf(textmode, "u::%c%c%c,g::%c%c%c,o::%c%c%c",
+                        (st.st_mode & 0400 ? 'r' : '-'),
+                        (st.st_mode & 0200 ? 'w' : '-'),
+                        (st.st_mode & 0100 ? 'x' : '-'),
+                        (st.st_mode & 0040 ? 'r' : '-'),
+                        (st.st_mode & 0020 ? 'w' : '-'),
+                        (st.st_mode & 0010 ? 'x' : '-'),
+                        (st.st_mode & 004 ? 'r' : '-'),
+                        (st.st_mode & 002 ? 'w' : '-'),
+                        (st.st_mode & 001 ? 'x' : '-'));
+                acl = acl_from_text(textmode);
+                if (acl) {
+                    r = acl_set_file(path, ACL_TYPE_ACCESS, acl);
+                    acl_free(acl);
+                } else
+                    r = -1;
+            } else
+                r = -1;
+        }
+        if (!r && dom) {
+            if (strchr(options, 'd'))
+                type = ACL_TYPE_DEFAULT;
+            else
+                type = ACL_TYPE_ACCESS;
+            acl = acl_from_text(textacl);
+            if (acl) {
+                r = acl_set_file(path, type, acl);
+                acl_free(acl);
+            } else
+                r = -1;
+        }
+    }
+    if (r)
+        r = -errno;
+    return r;
 }
 
-
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-	int rc = 0;
+    int rc = 0;
 
-	if (argc != 4) {
-		fprintf(stderr,
-                        "usage: ./setfacl_test <path> <options> <textacl>\n");
-		return 0;
-	}
-	rc = do_setfacl(argv[1], argv[2], argv[3]);
-	if (rc != 0) {
-		fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno));
-		return rc;
-	}
-	return 0;
+    if (argc != 4) {
+        fprintf(stderr, "usage: ./setfacl_test <path> <options> <textacl>\n");
+        return 0;
+    }
+    rc = do_setfacl(argv[1], argv[2], argv[3]);
+    if (rc != 0) {
+        fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno));
+        return rc;
+    }
+    return 0;
 }
diff --git a/tests/bugs/access-control/bug-1387241.c b/tests/bugs/access-control/bug-1387241.c
index 04e0d6ea11f..e2e843a2fda 100644
--- a/tests/bugs/access-control/bug-1387241.c
+++ b/tests/bugs/access-control/bug-1387241.c
@@ -3,15 +3,16 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        int ret = EXIT_FAILURE;
-        int fd = open(argv[1], O_RDONLY|O_TRUNC);
+    int ret = EXIT_FAILURE;
+    int fd = open(argv[1], O_RDONLY | O_TRUNC);
 
-        if (fd) {
-                ret = EXIT_SUCCESS;
-                close(fd);
-        }
+    if (fd) {
+        ret = EXIT_SUCCESS;
+        close(fd);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/cli/bug-1169302.c b/tests/bugs/cli/bug-1169302.c
index aa9f950abf2..7c6b5fbf856 100644
--- a/tests/bugs/cli/bug-1169302.c
+++ b/tests/bugs/cli/bug-1169302.c
@@ -7,72 +7,73 @@
 
 int keep_running = 1;
 
-void stop_running(int sig)
+void
+stop_running(int sig)
 {
-        if (sig == SIGTERM)
-                keep_running = 0;
+    if (sig == SIGTERM)
+        keep_running = 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t *fs = NULL;
-        int ret = 0;
-        glfs_fd_t *fd = NULL;
-        char *filename = NULL;
-        char *logfile = NULL;
-        char *host = NULL;
-
-        if (argc != 5) {
-                return -1;
-        }
-
-        host = argv[2];
-        logfile = argv[3];
-        filename = argv[4];
-
-        /* setup signal handler for exiting */
-        signal (SIGTERM, stop_running);
-
-        fs = glfs_new (argv[1]);
-        if (!fs) {
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", host, 24007);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        if (!fd) {
-                return -1;
-        }
-
-        /* sleep until SIGTERM has been received */
-        while (keep_running) {
-                sleep (1);
-        }
-
-        ret = glfs_close (fd);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        return 0;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = NULL;
+    char *logfile = NULL;
+    char *host = NULL;
+
+    if (argc != 5) {
+        return -1;
+    }
+
+    host = argv[2];
+    logfile = argv[3];
+    filename = argv[4];
+
+    /* setup signal handler for exiting */
+    signal(SIGTERM, stop_running);
+
+    fs = glfs_new(argv[1]);
+    if (!fs) {
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    if (!fd) {
+        return -1;
+    }
+
+    /* sleep until SIGTERM has been received */
+    while (keep_running) {
+        sleep(1);
+    }
+
+    ret = glfs_close(fd);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    return 0;
 }
diff --git a/tests/bugs/core/bug-834465.c b/tests/bugs/core/bug-834465.c
index 61d3deac077..33dd270b112 100644
--- a/tests/bugs/core/bug-834465.c
+++ b/tests/bugs/core/bug-834465.c
@@ -7,55 +7,54 @@
 #include <fcntl.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1;
-        char        *filename = NULL;
-        struct flock lock     = {0, };
-        int          i        = 0;
-        int          ret      = -1;
-
-        if (argc != 2) {
-                fprintf (stderr, "Usage: %s <filename> ", argv[0]);
-                goto out;
+    int fd = -1;
+    char *filename = NULL;
+    struct flock lock = {
+        0,
+    };
+    int i = 0;
+    int ret = -1;
+
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <filename> ", argv[0]);
+        goto out;
+    }
+
+    filename = argv[1];
+
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 1;
+    lock.l_len = 1;
+
+    while (i < 100) {
+        lock.l_type = F_WRLCK;
+        ret = fcntl(fd, F_SETLK, &lock);
+        if (ret < 0) {
+            fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno));
+            goto out;
         }
 
-        filename = argv[1];
-
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
+        lock.l_type = F_UNLCK;
+        ret = fcntl(fd, F_SETLK, &lock);
+        if (ret < 0) {
+            fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno));
+            goto out;
         }
 
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 1;
-        lock.l_len = 1;
-
-        while (i < 100) {
-                lock.l_type = F_WRLCK;
-                ret = fcntl (fd, F_SETLK, &lock);
-                if (ret < 0) {
-                        fprintf (stderr, "fcntl setlk failed (%s)\n",
-                                        strerror (errno));
-                        goto out;
-                }
-
-                lock.l_type = F_UNLCK;
-                ret = fcntl (fd, F_SETLK, &lock);
-                if (ret < 0) {
-                        fprintf (stderr, "fcntl setlk failed (%s)\n",
-                                        strerror (errno));
-                        goto out;
-                }
-
-                i++;
-        }
+        i++;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/distribute/bug-1193636.c b/tests/bugs/distribute/bug-1193636.c
index 438efa8e686..ea3f79a4e06 100644
--- a/tests/bugs/distribute/bug-1193636.c
+++ b/tests/bugs/distribute/bug-1193636.c
@@ -5,66 +5,64 @@
 #include <fcntl.h>
 #include <string.h>
 
+#define MY_XATTR_NAME "user.ftest"
+#define MY_XATTR_VAL "ftestval"
 
-#define MY_XATTR_NAME   "user.ftest"
-#define MY_XATTR_VAL    "ftestval"
-
-
-void usage (void)
+void
+usage(void)
 {
-        printf ("Usage : bug-1193636 <filename> <xattr_name> <op>\n");
-        printf ("   op : 0 - set, 1 - remove\n");
+    printf("Usage : bug-1193636 <filename> <xattr_name> <op>\n");
+    printf("   op : 0 - set, 1 - remove\n");
 }
 
-
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int fd;
-        int err = 0;
-        char *xattr_name = NULL;
-        int op = 0;
-
-        if (argc != 4) {
-                usage ();
-                exit (1);
-        }
-
-        op = atoi (argv[3]);
-
-        if ((op != 0) && (op != 1)) {
-                printf ("Invalid operation specified.\n");
-                usage ();
-                exit (1);
+    int fd;
+    int err = 0;
+    char *xattr_name = NULL;
+    int op = 0;
+
+    if (argc != 4) {
+        usage();
+        exit(1);
+    }
+
+    op = atoi(argv[3]);
+
+    if ((op != 0) && (op != 1)) {
+        printf("Invalid operation specified.\n");
+        usage();
+        exit(1);
+    }
+
+    xattr_name = argv[2];
+
+    fd = open(argv[1], O_RDWR);
+    if (fd == -1) {
+        printf("Failed to open file %s\n", argv[1]);
+        exit(1);
+    }
+
+    if (!op) {
+        err = fsetxattr(fd, xattr_name, MY_XATTR_VAL, strlen(MY_XATTR_VAL) + 1,
+                        XATTR_CREATE);
+
+        if (err) {
+            printf("Failed to set xattr %s: %m\n", xattr_name);
+            exit(1);
         }
 
-        xattr_name = argv[2];
+    } else {
+        err = fremovexattr(fd, xattr_name);
 
-        fd = open(argv[1], O_RDWR);
-        if (fd == -1) {
-                printf ("Failed to open file %s\n", argv[1]);
-                exit (1);
+        if (err) {
+            printf("Failed to remove xattr %s: %m\n", xattr_name);
+            exit(1);
         }
+    }
 
-        if (!op) {
-                err = fsetxattr (fd, xattr_name, MY_XATTR_VAL,
-                                 strlen (MY_XATTR_VAL) + 1, XATTR_CREATE);
+    close(fd);
 
-                if (err) {
-                        printf ("Failed to set xattr %s: %m\n", xattr_name);
-                        exit (1);
-                }
-
-        } else {
-                err = fremovexattr (fd, xattr_name);
-
-                if (err) {
-                        printf ("Failed to remove xattr %s: %m\n", xattr_name);
-                        exit (1);
-                }
-        }
-
-        close (fd);
-
-        return 0;
+    return 0;
 }
-
diff --git a/tests/bugs/distribute/bug-860663.c b/tests/bugs/distribute/bug-860663.c
index bee4e7d40b1..ca0c31ffe8f 100644
--- a/tests/bugs/distribute/bug-860663.c
+++ b/tests/bugs/distribute/bug-860663.c
@@ -6,38 +6,36 @@
 #include <err.h>
 #include <sys/param.h>
 
-int
-main(argc, argv)
-        int argc;
-        char **argv;
+int main(argc, argv) int argc;
+char **argv;
 {
-        char *basepath;
-        char path[MAXPATHLEN + 1];
-        unsigned int count;
-        int i, fd;
+    char *basepath;
+    char path[MAXPATHLEN + 1];
+    unsigned int count;
+    int i, fd;
 
-        if (argc != 3)
-                errx(1, "usage: %s path count", argv[0]);
+    if (argc != 3)
+        errx(1, "usage: %s path count", argv[0]);
 
-        basepath = argv[1];
-        count = atoi(argv[2]);
+    basepath = argv[1];
+    count = atoi(argv[2]);
 
-        if (count > 999999)
-                errx(1, "count too big");
+    if (count > 999999)
+        errx(1, "count too big");
 
-        if (strlen(basepath) > MAXPATHLEN - 6)
-                errx(1, "path too long");
+    if (strlen(basepath) > MAXPATHLEN - 6)
+        errx(1, "path too long");
 
-        for (i = 0; i < count; i++) {
-                (void)sprintf(path, "%s%06d", basepath, i);
+    for (i = 0; i < count; i++) {
+        (void)sprintf(path, "%s%06d", basepath, i);
 
-                fd = open(path, O_CREAT|O_RDWR, 0644);
-                if (fd == -1)
-                        err(1, "create %s failed", path);
+        fd = open(path, O_CREAT | O_RDWR, 0644);
+        if (fd == -1)
+            err(1, "create %s failed", path);
 
-                if (close(fd) != 0)
-                        warn("close %s failed", path);
-        }
+        if (close(fd) != 0)
+            warn("close %s failed", path);
+    }
 
-        return 0;
+    return 0;
 }
diff --git a/tests/bugs/ec/bug-1161886.c b/tests/bugs/ec/bug-1161886.c
index 1faae831898..1f12650ea6d 100644
--- a/tests/bugs/ec/bug-1161886.c
+++ b/tests/bugs/ec/bug-1161886.c
@@ -4,50 +4,50 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-
-        if (argc != 4) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, "/dev/null", 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-        glfs_close(fd);
-
-        ret = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/dev/null", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+    glfs_close(fd);
+
+    ret = 0;
 
 out:
-        glfs_fini (fs);
+    glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/fuse/bug-1126048.c b/tests/bugs/fuse/bug-1126048.c
index 01c3484172d..19165ecf6f7 100644
--- a/tests/bugs/fuse/bug-1126048.c
+++ b/tests/bugs/fuse/bug-1126048.c
@@ -12,30 +12,32 @@
  * fsync should fail without crashing the mount process.
  */
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int ret = 0;
-        int fd = 0;
-        char    *cmd = argv[1];
-        struct stat stbuf = {0, };
+    int ret = 0;
+    int fd = 0;
+    char *cmd = argv[1];
+    struct stat stbuf = {
+        0,
+    };
 
-        printf ("cmd is: %s\n", cmd);
-        fd = open("a.txt", O_CREAT|O_RDWR, 0644);
-        if (fd < 0)
-                printf ("open failed: %s\n", strerror(errno));
+    printf("cmd is: %s\n", cmd);
+    fd = open("a.txt", O_CREAT | O_RDWR, 0644);
+    if (fd < 0)
+        printf("open failed: %s\n", strerror(errno));
 
-        ret = unlink("a.txt");
-        if (ret < 0)
-                printf ("unlink failed: %s\n", strerror(errno));
-        if (write (fd, "abc", 3) < 0)
-                printf ("Not able to print %s\n", strerror (errno));
-        system(cmd);
-        sleep(1); /* No way to confirm graph switch so sleep 1 */
-        ret = fstat (fd, &stbuf);
-        if (ret < 0)
-                printf ("fstat failed %\n", strerror (errno));
-        ret = fsync(fd);
-        if (ret < 0)
-                printf ("Not able to fsync %s\n", strerror (errno));
-        return 0;
+    ret = unlink("a.txt");
+    if (ret < 0)
+        printf("unlink failed: %s\n", strerror(errno));
+    if (write(fd, "abc", 3) < 0)
+        printf("Not able to print %s\n", strerror(errno));
+    system(cmd);
+    sleep(1); /* No way to confirm graph switch so sleep 1 */
+    ret = fstat(fd, &stbuf);
+    if (ret < 0)
+        printf("fstat failed %\n", strerror(errno));
+    ret = fsync(fd);
+    if (ret < 0)
+        printf("Not able to fsync %s\n", strerror(errno));
+    return 0;
 }
diff --git a/tests/bugs/gfapi/bug-1093594.c b/tests/bugs/gfapi/bug-1093594.c
index aff271e4caf..f7a06dd5ba8 100644
--- a/tests/bugs/gfapi/bug-1093594.c
+++ b/tests/bugs/gfapi/bug-1093594.c
@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define WRITE_SIZE (128*1024)
+#define WRITE_SIZE (128 * 1024)
 #define READ_WRITE_LOOP 100
 #define FOP_LOOP_COUNT 20
 #define TEST_CASE_LOOP 20
@@ -14,304 +14,298 @@ int gfapi = 1;
 static int extension = 1;
 
 static int
-large_number_of_fops (glfs_t *fs) {
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *dir1     = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
-        char      *buf      = NULL;
-        struct stat sb      = {0, };
-
-        for (i = 0 ; i < FOP_LOOP_COUNT ; i++) {
-                ret = asprintf (&dir1, "dir%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                 strerror (errno));
-                        return ret;
-                }
-
-                extension++;
-
-                ret = glfs_mkdir (fs, dir1, 0755);
-                if (ret < 0) {
-                        fprintf (stderr, "mkdir(%s): %s\n", dir1, strerror (errno));
-                        return -1;
-                }
-
-                fd = glfs_opendir (fs, dir1);
-                if (!fd) {
-                        fprintf (stderr, "/: %s\n", strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_fsetxattr (fd, "user.dirfattr", "fsetxattr", 8, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret,
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_closedir (fd);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_closedir failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_rmdir (fs, dir1);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = asprintf (&filename1, "file%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                strerror (errno));
-                        return ret;
-                }
-
-                ret = asprintf (&filename2, "file-%d", extension);
-                if (ret < 0) {
-                        fprintf (stderr, "cannot construct filename (%s)",
-                                strerror (errno));
-                        return ret;
-                }
-
-                extension++;
-
-                fd = glfs_creat (fs, filename1, O_RDWR, 0644);
-                if (!fd) {
-                        fprintf (stderr, "%s: (%p) %s\n", filename1, fd,
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_rename (fs, filename1, filename2);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_rename failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_lstat (fs, filename2, &sb);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_lstat failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_close (fd);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_close failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_unlink (fs, filename2);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
+large_number_of_fops(glfs_t *fs)
+{
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
+    char *buf = NULL;
+    struct stat sb = {
+        0,
+    };
+
+    for (i = 0; i < FOP_LOOP_COUNT; i++) {
+        ret = asprintf(&dir1, "dir%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
         }
-}
 
-static int
-large_read_write (glfs_t *fs) {
+        extension++;
 
-        int       ret       = 0;
-        int       j         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *filename = NULL;
-        char      *buf      = NULL;
+        ret = glfs_mkdir(fs, dir1, 0755);
+        if (ret < 0) {
+            fprintf(stderr, "mkdir(%s): %s\n", dir1, strerror(errno));
+            return -1;
+        }
 
-        ret = asprintf (&filename, "filerw%d", extension);
+        fd = glfs_opendir(fs, dir1);
+        if (!fd) {
+            fprintf(stderr, "/: %s\n", strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_fsetxattr(fd, "user.dirfattr", "fsetxattr", 8, 0);
         if (ret < 0) {
-                fprintf (stderr, "cannot construct filename (%s)",
-                         strerror (errno));
-                return ret;
+            fprintf(stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret,
+                    strerror(errno));
+            return -1;
         }
 
-        extension++;
+        ret = glfs_closedir(fd);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_closedir failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
 
-        fd = glfs_creat (fs, filename, O_RDWR, 0644);
-        if (!fd) {
-                fprintf (stderr, "%s: (%p) %s\n", filename, fd,
-                        strerror (errno));
-                return -1;
+        ret = glfs_rmdir(fs, dir1);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        buf = (char *) malloc (WRITE_SIZE);
-        memset (buf, '-', WRITE_SIZE);
+        ret = asprintf(&filename1, "file%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
+        }
 
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_write (fd, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = asprintf(&filename2, "file-%d", extension);
+        if (ret < 0) {
+            fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+            return ret;
         }
 
-        fd1 = glfs_open (fs, filename, O_RDWR);
-        if (fd1 < 0) {
-                fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret,
-                        strerror (errno));
-                return -1;
+        extension++;
+
+        fd = glfs_creat(fs, filename1, O_RDWR, 0644);
+        if (!fd) {
+            fprintf(stderr, "%s: (%p) %s\n", filename1, fd, strerror(errno));
+            return -1;
         }
 
-        glfs_lseek (fd1, 0, SEEK_SET);
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_read (fd1, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = glfs_rename(fs, filename1, filename2);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_rename failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        for (j = 0; j < READ_WRITE_LOOP; j++) {
-                ret = glfs_write (fd1, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
-                                strerror (errno));
-                        return ret;
-                }
+        ret = glfs_lstat(fs, filename2, &sb);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_lstat failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        glfs_close (fd);
-        glfs_close (fd1);
-        ret = glfs_unlink (fs, filename);
+        ret = glfs_close(fd);
         if (ret < 0) {
-                fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
+            fprintf(stderr, "glfs_close failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
 
-        free (buf);
-        free (filename);
+        ret = glfs_unlink(fs, filename2);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+    }
 }
 
 static int
-volfile_change (const char *volname) {
-        int   ret = 0;
-        char *cmd = NULL, *cmd1 = NULL;
+large_read_write(glfs_t *fs)
+{
+    int ret = 0;
+    int j = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *filename = NULL;
+    char *buf = NULL;
+
+    ret = asprintf(&filename, "filerw%d", extension);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct filename (%s)", strerror(errno));
+        return ret;
+    }
 
-        ret = asprintf (&cmd, "gluster volume set %s stat-prefetch off",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+    extension++;
 
-        ret = asprintf (&cmd1, "gluster volume set %s stat-prefetch on",
-                        volname);
+    fd = glfs_creat(fs, filename, O_RDWR, 0644);
+    if (!fd) {
+        fprintf(stderr, "%s: (%p) %s\n", filename, fd, strerror(errno));
+        return -1;
+    }
+
+    buf = (char *)malloc(WRITE_SIZE);
+    memset(buf, '-', WRITE_SIZE);
+
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_write(fd, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
+            fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
 
-        ret = system (cmd);
+    fd1 = glfs_open(fs, filename, O_RDWR);
+    if (fd1 < 0) {
+        fprintf(stderr, "Open(%s): %d (%s)\n", filename, ret, strerror(errno));
+        return -1;
+    }
+
+    glfs_lseek(fd1, 0, SEEK_SET);
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_read(fd1, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "stat-prefetch off on (%s) failed", volname);
-                return ret;
+            fprintf(stderr, "Read(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
 
-        ret = system (cmd1);
+    for (j = 0; j < READ_WRITE_LOOP; j++) {
+        ret = glfs_write(fd1, buf, WRITE_SIZE, 0);
         if (ret < 0) {
-                fprintf (stderr, "stat-prefetch on on (%s) failed", volname);
-                return ret;
+            fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret,
+                    strerror(errno));
+            return ret;
         }
+    }
+
+    glfs_close(fd);
+    glfs_close(fd1);
+    ret = glfs_unlink(fs, filename);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+
+    free(buf);
+    free(filename);
+}
 
-        free (cmd);
-        free (cmd1);
+static int
+volfile_change(const char *volname)
+{
+    int ret = 0;
+    char *cmd = NULL, *cmd1 = NULL;
+
+    ret = asprintf(&cmd, "gluster volume set %s stat-prefetch off", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
         return ret;
+    }
+
+    ret = asprintf(&cmd1, "gluster volume set %s stat-prefetch on", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
+
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "stat-prefetch off on (%s) failed", volname);
+        return ret;
+    }
+
+    ret = system(cmd1);
+    if (ret < 0) {
+        fprintf(stderr, "stat-prefetch on on (%s) failed", volname);
+        return ret;
+    }
+
+    free(cmd);
+    free(cmd1);
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs       = NULL;
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *topdir   = "topdir", *filename = "file1";
-        char      *buf      = NULL;
-        char      *logfile  = NULL;
-        char      *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                        "Expect following args %s <hostname> <Vol> <log file>\n"
-                        , argv[0]);
-                return -1;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <hostname> <Vol> <log file>\n",
+                argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    logfile = argv[3];
+
+    for (i = 0; i < TEST_CASE_LOOP; i++) {
+        fs = glfs_new(argv[2]);
+        if (!fs) {
+            fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno));
+            return -1;
         }
 
-        hostname = argv[1];
-        logfile = argv[3];
-
-        for (i = 0; i < TEST_CASE_LOOP; i++) {
-                fs = glfs_new (argv[2]);
-                if (!fs) {
-                        fprintf (stderr, "glfs_new: returned NULL (%s)\n",
-                                strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n",
-                        ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_set_logging (fs, logfile, 7);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = glfs_init (fs);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_init failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
-
-                ret = large_number_of_fops (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_read_write (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = volfile_change (argv[2]);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_number_of_fops (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = large_read_write (fs);
-                if (ret < 0)
-                        return -1;
-
-                ret = glfs_fini (fs);
-                if (ret < 0) {
-                        fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                                ret, strerror (errno));
-                        return -1;
-                }
+        ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_set_logging(fs, logfile, 7);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = glfs_init(fs);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
+        }
+
+        ret = large_number_of_fops(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = large_read_write(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = volfile_change(argv[2]);
+        if (ret < 0)
+            return -1;
+
+        ret = large_number_of_fops(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = large_read_write(fs);
+        if (ret < 0)
+            return -1;
+
+        ret = glfs_fini(fs);
+        if (ret < 0) {
+            fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                    strerror(errno));
+            return -1;
         }
-        return 0;
+    }
+    return 0;
 }
diff --git a/tests/bugs/gfapi/bug-1319374.c b/tests/bugs/gfapi/bug-1319374.c
index bf2da998d6e..bd80462e3ba 100644
--- a/tests/bugs/gfapi/bug-1319374.c
+++ b/tests/bugs/gfapi/bug-1319374.c
@@ -9,122 +9,122 @@
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_file, int flag)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_file, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        if (flag == NO_INIT)
-                goto out;
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    if (flag == NO_INIT)
+        goto out;
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
 
 out:
-        return fs;
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret         = 0;
-        glfs_t    *fs1         = NULL;
-        glfs_t    *fs2         = NULL;
-        glfs_t    *fs3         = NULL;
-        char      *volname     = NULL;
-        char      *log_file    = NULL;
-        char      *hostname    = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        log_file = argv[3];
-
-        fs1 = setup_new_client (hostname, volname, log_file, NO_INIT);
-        if (!fs1) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fs2 = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs2) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fs3 = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs3) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_fini (fs3);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets
-         * triggered when 30s timer expires, hence the sleep of 31s
-         */
-        sleep (31);
-        ret = glfs_fini (fs2);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs1);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_fini (fs1);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs1 = NULL;
+    glfs_t *fs2 = NULL;
+    glfs_t *fs3 = NULL;
+    char *volname = NULL;
+    char *log_file = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
         return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    log_file = argv[3];
+
+    fs1 = setup_new_client(hostname, volname, log_file, NO_INIT);
+    if (!fs1) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fs2 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs2) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fs3 = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs3) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_fini(fs3);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets
+     * triggered when 30s timer expires, hence the sleep of 31s
+     */
+    sleep(31);
+    ret = glfs_fini(fs2);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs1);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_fini(fs1);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/gfapi/bug-1447266/1460514.c b/tests/bugs/gfapi/bug-1447266/1460514.c
index f04d2d1463f..c721559a668 100644
--- a/tests/bugs/gfapi/bug-1447266/1460514.c
+++ b/tests/bugs/gfapi/bug-1447266/1460514.c
@@ -9,135 +9,142 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret            = 0;
-        glfs_t                  *fs            = NULL;
-        struct glfs_object      *root = NULL, *dir = NULL, *subdir = NULL;
-        struct stat             sb             = {0, };
-        char                    *dirname       = "dir";
-        char                    *subdirname    = "subdir";
-        char                    *logfile       = NULL;
-        char                    *volname       = NULL;
-        char                    *hostname      = NULL;
-        unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'};
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("first attempt glfs_init", ret);
-
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        dir = glfs_h_mkdir (fs, root, dirname, 0644, &sb);
-        if (dir == NULL) {
-                 fprintf (stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        subdir = glfs_h_mkdir (fs, root, subdirname, 0644, &sb);
-        if (subdir == NULL) {
-                 fprintf (stderr, "glfs_h_mkdir: error on directory creation subdir ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-        ret = glfs_h_extract_handle (subdir, subdir_handle,
-                                             GFAPI_HANDLE_LENGTH);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n",
-                         subdirname, strerror (errno));
-                goto out;
-        }
-
-        glfs_h_close (subdir);
-        subdir = NULL;
-        glfs_h_close (dir);
-        dir = NULL;
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("second attempt glfs_init", ret);
-
-        subdir = glfs_h_create_from_handle (fs, subdir_handle, GFAPI_HANDLE_LENGTH,
-                                          &sb);
-        if (subdir == NULL) {
-                fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
-                         subdirname, subdir_handle, strerror (errno));
-                goto out;
-        }
-        dir = glfs_h_lookupat (fs, subdir, "..", &sb, 0);
-        if (dir == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_object *root = NULL, *dir = NULL, *subdir = NULL;
+    struct stat sb = {
+        0,
+    };
+    char *dirname = "dir";
+    char *subdirname = "subdir";
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'};
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("first attempt glfs_init", ret);
+
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    dir = glfs_h_mkdir(fs, root, dirname, 0644, &sb);
+    if (dir == NULL) {
+        fprintf(stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    subdir = glfs_h_mkdir(fs, root, subdirname, 0644, &sb);
+    if (subdir == NULL) {
+        fprintf(stderr,
+                "glfs_h_mkdir: error on directory creation subdir ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+    ret = glfs_h_extract_handle(subdir, subdir_handle, GFAPI_HANDLE_LENGTH);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
+                subdirname, strerror(errno));
+        goto out;
+    }
+
+    glfs_h_close(subdir);
+    subdir = NULL;
+    glfs_h_close(dir);
+    dir = NULL;
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("second attempt glfs_init", ret);
+
+    subdir = glfs_h_create_from_handle(fs, subdir_handle, GFAPI_HANDLE_LENGTH,
+                                       &sb);
+    if (subdir == NULL) {
+        fprintf(
+            stderr,
+            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
+            subdirname, subdir_handle, strerror(errno));
+        goto out;
+    }
+    dir = glfs_h_lookupat(fs, subdir, "..", &sb, 0);
+    if (dir == NULL) {
+        fprintf(stderr,
+                "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n",
+                strerror(errno));
+        goto out;
+    }
 
 out:
-        if (subdir)
-                glfs_h_close (subdir);
-        if (dir)
-                glfs_h_close (dir);
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (subdir)
+        glfs_h_close(subdir);
+    if (dir)
+        glfs_h_close(dir);
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/bugs/gfapi/bug-1447266/bug-1447266.c b/tests/bugs/gfapi/bug-1447266/bug-1447266.c
index e4b3c888a57..2b7e2d627fe 100644
--- a/tests/bugs/gfapi/bug-1447266/bug-1447266.c
+++ b/tests/bugs/gfapi/bug-1447266/bug-1447266.c
@@ -4,102 +4,104 @@
 #include <string.h>
 #include <stdlib.h>
 #define TOTAL_ARGS 4
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        char *cwd = (char *)malloc(PATH_MAX*sizeof(char *));
-        char *resolved = NULL;
-        char *result = NULL;
-        char *buf = NULL;
-        struct stat st;
-        char *path = NULL;
-        int ret;
-
-        if (argc != TOTAL_ARGS) {
-                printf ("Please give all required command line args.\n"
-                         "Format : <volname> <server_ip> <path_name>\n");
-                goto out;
-        }
-
-        glfs_t *fs = glfs_new (argv[1]);
-
-        if (fs == NULL) {
-                printf ("glfs_new: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
-        if (ret) {
-                printf ("glfs_set_volfile_server: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        path = argv[3];
-
-        ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7);
-        if (ret) {
-                printf ("glfs_set_logging: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        ret = glfs_init(fs);
-        if (ret) {
-                printf ("glfs_init: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        sleep(1);
-
-        ret = glfs_chdir(fs, path);
-        if (ret) {
-                printf ("glfs_chdir: %s\n", strerror(errno));
-                goto out;
-        }
-
-        buf = glfs_getcwd(fs, cwd, PATH_MAX);
-        if (cwd == NULL) {
-                printf ("glfs_getcwd: %s\n", strerror(errno));
-                goto out;
-        }
-
-        printf ("\ncwd = %s\n\n", cwd);
-
-        result = glfs_realpath(fs, path, resolved);
-        if (result == NULL) {
-                printf ("glfs_realpath: %s\n", strerror(errno));
-                goto out;
-        }
-
-        ret = glfs_stat(fs, path, &st);
-        if (ret) {
-                printf ("glfs_stat: %s\n", strerror(errno));
-                goto out;
-        }
-        if (cwd)
-                free(cwd);
-
-        result = glfs_realpath(fs, path, resolved);
-        if (result == NULL) {
-                printf ("glfs_realpath: %s\n", strerror(errno));
-                goto out;
-        }
-
-        ret = glfs_fini(fs);
-        if (ret) {
-                printf ("glfs_fini: %s\n", strerror(errno));
-                /* No need to fail the test for this error */
-                ret = 0;
-                goto out;
-        }
-
-        printf ("\n");
+    char *cwd = (char *)malloc(PATH_MAX * sizeof(char *));
+    char *resolved = NULL;
+    char *result = NULL;
+    char *buf = NULL;
+    struct stat st;
+    char *path = NULL;
+    int ret;
+
+    if (argc != TOTAL_ARGS) {
+        printf(
+            "Please give all required command line args.\n"
+            "Format : <volname> <server_ip> <path_name>\n");
+        goto out;
+    }
+
+    glfs_t *fs = glfs_new(argv[1]);
+
+    if (fs == NULL) {
+        printf("glfs_new: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
+    if (ret) {
+        printf("glfs_set_volfile_server: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    path = argv[3];
+
+    ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7);
+    if (ret) {
+        printf("glfs_set_logging: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret) {
+        printf("glfs_init: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    sleep(1);
+
+    ret = glfs_chdir(fs, path);
+    if (ret) {
+        printf("glfs_chdir: %s\n", strerror(errno));
+        goto out;
+    }
+
+    buf = glfs_getcwd(fs, cwd, PATH_MAX);
+    if (cwd == NULL) {
+        printf("glfs_getcwd: %s\n", strerror(errno));
+        goto out;
+    }
+
+    printf("\ncwd = %s\n\n", cwd);
+
+    result = glfs_realpath(fs, path, resolved);
+    if (result == NULL) {
+        printf("glfs_realpath: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_stat(fs, path, &st);
+    if (ret) {
+        printf("glfs_stat: %s\n", strerror(errno));
+        goto out;
+    }
+    if (cwd)
+        free(cwd);
+
+    result = glfs_realpath(fs, path, resolved);
+    if (result == NULL) {
+        printf("glfs_realpath: %s\n", strerror(errno));
+        goto out;
+    }
+
+    ret = glfs_fini(fs);
+    if (ret) {
+        printf("glfs_fini: %s\n", strerror(errno));
+        /* No need to fail the test for this error */
+        ret = 0;
+        goto out;
+    }
+
+    printf("\n");
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
index 68011171744..f38f01144d3 100644
--- a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
+++ b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c
@@ -10,156 +10,154 @@
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_fileile)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_fileile, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-        return fs;
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-write_something (glfs_t *fs)
+write_something(glfs_t *fs)
 {
-        glfs_fd_t *fd       = NULL;
-        char      *buf      = NULL;
-        int       ret       = 0;
-        int       j         = 0;
-
-        fd = glfs_creat (fs, "filename", O_RDWR, 0644);
-        if (!fd) {
-                fprintf (stderr, "%s: (%p) %s\n", "filename", fd,
-                        strerror (errno));
-                return -1;
-        }
+    glfs_fd_t *fd = NULL;
+    char *buf = NULL;
+    int ret = 0;
+    int j = 0;
+
+    fd = glfs_creat(fs, "filename", O_RDWR, 0644);
+    if (!fd) {
+        fprintf(stderr, "%s: (%p) %s\n", "filename", fd, strerror(errno));
+        return -1;
+    }
+
+    buf = (char *)malloc(WRITE_SIZE);
+    memset(buf, '-', WRITE_SIZE);
 
-        buf = (char *) malloc (WRITE_SIZE);
-        memset (buf, '-', WRITE_SIZE);
-
-        for (j = 0; j < 4; j++) {
-                ret = glfs_write (fd, buf, WRITE_SIZE, 0);
-                if (ret < 0) {
-                        fprintf (stderr, "Write(%s): %d (%s)\n", "filename", ret,
-                                strerror (errno));
-                        return ret;
-                }
-                glfs_lseek (fd, 0, SEEK_SET);
+    for (j = 0; j < 4; j++) {
+        ret = glfs_write(fd, buf, WRITE_SIZE, 0);
+        if (ret < 0) {
+            fprintf(stderr, "Write(%s): %d (%s)\n", "filename", ret,
+                    strerror(errno));
+            return ret;
         }
-        return 0;
+        glfs_lseek(fd, 0, SEEK_SET);
+    }
+    return 0;
 }
 
 static int
-volfile_change (const char *volname) {
-        int   ret = 0;
-        char *cmd = NULL, *cmd1 = NULL;
-
-        ret = asprintf (&cmd, "gluster volume set %s quick-read on",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+volfile_change(const char *volname)
+{
+    int ret = 0;
+    char *cmd = NULL, *cmd1 = NULL;
 
-        ret = asprintf (&cmd1, "gluster volume set %s quick-read off",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                return ret;
-        }
+    ret = asprintf(&cmd, "gluster volume set %s quick-read on", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read off on (%s) failed", volname);
-                return ret;
-        }
+    ret = asprintf(&cmd1, "gluster volume set %s quick-read off", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        return ret;
+    }
 
-        ret = system (cmd1);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read on on (%s) failed", volname);
-                return ret;
-        }
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read off on (%s) failed", volname);
+        return ret;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "quick-read off on (%s) failed", volname);
-                return ret;
-        }
+    ret = system(cmd1);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read on on (%s) failed", volname);
+        return ret;
+    }
 
-        free (cmd);
-        free (cmd1);
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "quick-read off on (%s) failed", volname);
         return ret;
+    }
+
+    free(cmd);
+    free(cmd1);
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret      = 0;
-        glfs_t    *fs       = NULL;
-	char       buf[100];
-        glfs_fd_t *fd       = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        fs = setup_new_client (argv[1], argv[2], argv[3]);
-	if (!fs)
-		goto error;
-
-        ret = volfile_change (argv[2]);
-        if (ret < 0)
-                goto error;
-
-        /* This is required as volfile change takes a while to reach this
-         * gfapi client and precess the graph change. Without this the issue
-         * cannot be reproduced as in cannot be tested.
-         */
-        sleep (10);
-
-	ret = write_something (fs);
-        if (ret < 0)
-                goto error;
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                goto error;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs = NULL;
+    char buf[100];
+    glfs_fd_t *fd = NULL;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
         return -1;
+    }
+
+    fs = setup_new_client(argv[1], argv[2], argv[3]);
+    if (!fs)
+        goto error;
+
+    ret = volfile_change(argv[2]);
+    if (ret < 0)
+        goto error;
+
+    /* This is required as volfile change takes a while to reach this
+     * gfapi client and precess the graph change. Without this the issue
+     * cannot be reproduced as in cannot be tested.
+     */
+    sleep(10);
+
+    ret = write_something(fs);
+    if (ret < 0)
+        goto error;
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/glusterd/bug-824753-file-locker.c b/tests/bugs/glusterd/bug-824753-file-locker.c
index 915161b626b..f5dababad30 100644
--- a/tests/bugs/glusterd/bug-824753-file-locker.c
+++ b/tests/bugs/glusterd/bug-824753-file-locker.c
@@ -5,13 +5,13 @@
 #include <unistd.h>
 #include <stdlib.h>
 
-
-int main (int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-    int              fd            = -1;
-    int              ret           = -1;
-    char             command[2048] = "";
-    char             filepath[255]     = "";
+    int fd = -1;
+    int ret = -1;
+    char command[2048] = "";
+    char filepath[255] = "";
     struct flock fl;
 
     fl.l_type = F_WRLCK;
@@ -36,7 +36,7 @@ int main (int argc, char *argv[])
              " grep %s | awk -F'..: ' '{print $1}' | grep %s:%s/%s",
              argv[1], argv[5], argv[2], argv[2], argv[3], argv[1]);
 
-    ret = system (command);
+    ret = system(command);
     close(fd);
 
     if (ret)
diff --git a/tests/bugs/glusterfs-server/bug-905864.c b/tests/bugs/glusterfs-server/bug-905864.c
index 3cc4cc5d232..f70003736e7 100644
--- a/tests/bugs/glusterfs-server/bug-905864.c
+++ b/tests/bugs/glusterfs-server/bug-905864.c
@@ -4,10 +4,9 @@
 #include <fcntl.h>
 #include <pthread.h>
 
-
-pthread_t   th[5] = {0};
+pthread_t th[5] = {0};
 void
-flock_init (struct flock *f, short int type, off_t start, off_t len)
+flock_init(struct flock *f, short int type, off_t start, off_t len)
 {
     f->l_type = type;
     f->l_start = start;
@@ -15,68 +14,70 @@ flock_init (struct flock *f, short int type, off_t start, off_t len)
 }
 
 int
-flock_range_in_steps (int fd, int is_set, short l_type,
-                      int start, int end, int step)
+flock_range_in_steps(int fd, int is_set, short l_type, int start, int end,
+                     int step)
 {
-        int         ret = 0;
-        int         i = 0;
-        struct      flock f = {0,};
+    int ret = 0;
+    int i = 0;
+    struct flock f = {
+        0,
+    };
 
-        for (i = start; i+step < end; i += step) {
-                flock_init (&f, l_type, i, step);
-                ret = fcntl (fd, (is_set) ? F_SETLKW : F_GETLK, &f);
-                if (ret) {
-                        perror ("fcntl");
-                        goto out;
-                }
+    for (i = start; i + step < end; i += step) {
+        flock_init(&f, l_type, i, step);
+        ret = fcntl(fd, (is_set) ? F_SETLKW : F_GETLK, &f);
+        if (ret) {
+            perror("fcntl");
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void *
-random_locker (void *arg)
+random_locker(void *arg)
 {
-        int         fd = *(int *)arg;
-        int         i = 0;
-        int         is_set = 0;
+    int fd = *(int *)arg;
+    int i = 0;
+    int is_set = 0;
 
-        /* use thread id to choose GETLK or SETLK operation*/
-        is_set = pthread_self () % 2;
-        (void)flock_range_in_steps (fd, is_set, F_WRLCK, 0, 400, 1);
+    /* use thread id to choose GETLK or SETLK operation*/
+    is_set = pthread_self() % 2;
+    (void)flock_range_in_steps(fd, is_set, F_WRLCK, 0, 400, 1);
 
-        return NULL;
+    return NULL;
 }
 
-
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int         fd = -1;
-        int         ret = 1;
-        int         i = 0;
-        char        *fname = NULL;
+    int fd = -1;
+    int ret = 1;
+    int i = 0;
+    char *fname = NULL;
 
-        if (argc < 2)
-                goto out;
+    if (argc < 2)
+        goto out;
 
-        fname = argv[1];
-        fd = open (fname, O_RDWR);
-        if (fd == -1) {
-                perror ("open");
-                goto out;
-        }
+    fname = argv[1];
+    fd = open(fname, O_RDWR);
+    if (fd == -1) {
+        perror("open");
+        goto out;
+    }
 
-        ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2);
-        for (i = 0; i < 5; i++) {
-                pthread_create (&th[i], NULL, random_locker, (void *) &fd);
-        }
-        ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2);
-        for (i = 0; i < 5; i++) {
-                pthread_join (th[i], NULL);
-        }
+    ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2);
+    for (i = 0; i < 5; i++) {
+        pthread_create(&th[i], NULL, random_locker, (void *)&fd);
+    }
+    ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2);
+    for (i = 0; i < 5; i++) {
+        pthread_join(th[i], NULL);
+    }
 out:
-        if (fd != -1)
-                close (fd);
+    if (fd != -1)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/glusterfs/getlk_owner.c b/tests/bugs/glusterfs/getlk_owner.c
index 85fd1042496..cbe277318c1 100644
--- a/tests/bugs/glusterfs/getlk_owner.c
+++ b/tests/bugs/glusterfs/getlk_owner.c
@@ -3,24 +3,24 @@
 #include <fcntl.h>
 #include <string.h>
 
-#define GETLK_OWNER_CHECK(f, cp, label)                     \
-    do {                                                    \
-        switch (f.l_type) {                                 \
-        case F_RDLCK:                                       \
-        case F_WRLCK:                                       \
-            ret = 1;                                        \
-            goto label;                                     \
-        case F_UNLCK:                                       \
-            if (!are_flocks_sane (&f, &cp)) {               \
-                ret = 1;                                    \
-                goto label;                                 \
-            }                                               \
-            break;                                          \
-        }                                                   \
+#define GETLK_OWNER_CHECK(f, cp, label)                                        \
+    do {                                                                       \
+        switch (f.l_type) {                                                    \
+            case F_RDLCK:                                                      \
+            case F_WRLCK:                                                      \
+                ret = 1;                                                       \
+                goto label;                                                    \
+            case F_UNLCK:                                                      \
+                if (!are_flocks_sane(&f, &cp)) {                               \
+                    ret = 1;                                                   \
+                    goto label;                                                \
+                }                                                              \
+                break;                                                         \
+        }                                                                      \
     } while (0)
 
 void
-flock_init (struct flock *f, short int type, off_t start, off_t len)
+flock_init(struct flock *f, short int type, off_t start, off_t len)
 {
     f->l_type = type;
     f->l_start = start;
@@ -28,17 +28,16 @@ flock_init (struct flock *f, short int type, off_t start, off_t len)
 }
 
 int
-flock_cp (struct flock *dst, struct flock *src)
+flock_cp(struct flock *dst, struct flock *src)
 {
-    memcpy ((void *) dst, (void *) src, sizeof (struct flock));
+    memcpy((void *)dst, (void *)src, sizeof(struct flock));
 }
 
 int
-are_flocks_sane (struct flock *src, struct flock *cpy)
+are_flocks_sane(struct flock *src, struct flock *cpy)
 {
     return ((src->l_whence == cpy->l_whence) &&
-            (src->l_start == cpy->l_start) &&
-            (src->l_len == cpy->l_len));
+            (src->l_start == cpy->l_start) && (src->l_len == cpy->l_len));
 }
 
 /*
@@ -53,68 +52,73 @@ are_flocks_sane (struct flock *src, struct flock *cpy)
  *
  * */
 
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
     int fd = -1;
     int ret = 1;
     char *fname = NULL;
-    struct flock f = {0,};
-    struct flock cp = {0,};
+    struct flock f = {
+        0,
+    };
+    struct flock cp = {
+        0,
+    };
 
     if (argc < 2)
         goto out;
 
     fname = argv[1];
-    fd = open (fname, O_RDWR);
+    fd = open(fname, O_RDWR);
     if (fd == -1) {
-        perror ("open");
+        perror("open");
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 0, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_SETLK, &f);
+    flock_init(&f, F_WRLCK, 0, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_SETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         goto out;
     }
-    if (!are_flocks_sane (&f, &cp)) {
+    if (!are_flocks_sane(&f, &cp)) {
         ret = 1;
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_SETLK, &f);
+    flock_init(&f, F_WRLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_SETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         goto out;
     }
-    if (!are_flocks_sane (&f, &cp)) {
+    if (!are_flocks_sane(&f, &cp)) {
         ret = 1;
         goto out;
     }
 
-    flock_init (&f, F_WRLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_GETLK, &f);
+    flock_init(&f, F_WRLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_GETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         return 1;
     }
-    GETLK_OWNER_CHECK (f, cp, out);
+    GETLK_OWNER_CHECK(f, cp, out);
 
-    flock_init (&f, F_RDLCK, 3, 3);
-    flock_cp (&cp, &f);
-    ret = fcntl (fd, F_GETLK, &f);
+    flock_init(&f, F_RDLCK, 3, 3);
+    flock_cp(&cp, &f);
+    ret = fcntl(fd, F_GETLK, &f);
     if (ret) {
-        perror ("fcntl");
+        perror("fcntl");
         return 1;
     }
-    GETLK_OWNER_CHECK (f, cp, out);
+    GETLK_OWNER_CHECK(f, cp, out);
 
 out:
     if (fd != -1)
-        close (fd);
+        close(fd);
     return ret;
 }
diff --git a/tests/bugs/io-cache/bug-858242.c b/tests/bugs/io-cache/bug-858242.c
index b6a412d578c..ac87a15533e 100644
--- a/tests/bugs/io-cache/bug-858242.c
+++ b/tests/bugs/io-cache/bug-858242.c
@@ -10,72 +10,75 @@
 #include <unistd.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char        *filename = NULL, *volname = NULL, *cmd = NULL;
-        char  buffer[1024]    = {0, };
-        int          fd       = -1;
-        int          ret      = -1;
-        struct stat  statbuf  = {0, };
+    char *filename = NULL, *volname = NULL, *cmd = NULL;
+    char buffer[1024] = {
+        0,
+    };
+    int fd = -1;
+    int ret = -1;
+    struct stat statbuf = {
+        0,
+    };
 
-        if (argc != 3) {
-                fprintf (stderr, "usage: %s <file-name> <volname>\n", argv[0]);
-                goto out;
-        }
+    if (argc != 3) {
+        fprintf(stderr, "usage: %s <file-name> <volname>\n", argv[0]);
+        goto out;
+    }
 
-        filename = argv[1];
-        volname = argv[2];
+    filename = argv[1];
+    volname = argv[2];
 
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
 
-        ret = write (fd, "test-content", 12);
-        if (ret < 0) {
-                fprintf (stderr, "write failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = write(fd, "test-content", 12);
+    if (ret < 0) {
+        fprintf(stderr, "write failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = fstat (fd, &statbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed (%s)", strerror (errno));
-                goto out;
-        }
+    ret = fstat(fd, &statbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed (%s)", strerror(errno));
+        goto out;
+    }
 
-        ret = asprintf (&cmd, "gluster --mode=script volume stop %s force",
-                        volname);
-        if (ret < 0) {
-                fprintf (stderr, "cannot construct cli command string (%s)",
-                         strerror (errno));
-                goto out;
-        }
+    ret = asprintf(&cmd, "gluster --mode=script volume stop %s force", volname);
+    if (ret < 0) {
+        fprintf(stderr, "cannot construct cli command string (%s)",
+                strerror(errno));
+        goto out;
+    }
 
-        ret = system (cmd);
-        if (ret < 0) {
-                fprintf (stderr, "stopping volume (%s) failed", volname);
-                goto out;
-        }
+    ret = system(cmd);
+    if (ret < 0) {
+        fprintf(stderr, "stopping volume (%s) failed", volname);
+        goto out;
+    }
 
-        sleep (3);
+    sleep(3);
 
-        ret = read (fd, buffer, 1024);
-        if (ret >= 0) {
-                fprintf (stderr, "read should've returned error, "
-                         "but is successful\n");
-                ret = -1;
-                goto out;
-        }
+    ret = read(fd, buffer, 1024);
+    if (ret >= 0) {
+        fprintf(stderr,
+                "read should've returned error, "
+                "but is successful\n");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/io-cache/bug-read-hang.c b/tests/bugs/io-cache/bug-read-hang.c
index 7709a41719d..e1fae97e7e8 100644
--- a/tests/bugs/io-cache/bug-read-hang.c
+++ b/tests/bugs/io-cache/bug-read-hang.c
@@ -9,117 +9,117 @@
 
 int count = 0;
 void
-read_cbk (glfs_fd_t *fd, ssize_t ret, void *data) {
-count++;
+read_cbk(glfs_fd_t *fd, ssize_t ret, void *data)
+{
+    count++;
 }
 
 glfs_t *
 setup_new_client(char *hostname, char *volname, char *log_file, int flag)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_file, 7);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        if (flag == NO_INIT)
-                goto out;
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_file, 7);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    if (flag == NO_INIT)
+        goto out;
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
 
 out:
-        return fs;
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret         = 0;
-        glfs_t    *fs          = NULL;
-        struct glfs_fd *fd     = NULL;
-        char      *volname     = NULL;
-        char      *log_file    = NULL;
-        char      *hostname    = NULL;
-        char      *buf = NULL;
-        struct stat stat;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <hostname> <Vol> <log file location>\n"
-                                , argv[0]);
-                return -1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        log_file = argv[3];
-
-        fs = setup_new_client (hostname, volname, log_file, 0);
-        if (!fs) {
-                fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "/: %s\n", strerror (errno));
-                return -1;
-        }
-
-        glfs_readdirplus (fd, &stat);
-
-        fd = glfs_open (fs, "/test", O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto error;
-        }
-
-        buf = (char *) malloc (5);
-
-        ret = glfs_pread (fd, buf, 5, 0, 0, NULL);
-        if (ret < 0) {
-                fprintf (stderr, "Read(%s): %d (%s)\n", "test", ret,
-                         strerror (errno));
-                return ret;
-        }
-
-        free (buf);
-        glfs_close (fd);
-
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                         ret, strerror (errno));
-                return -1;
-        }
-
-        return 0;
-error:
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_fd *fd = NULL;
+    char *volname = NULL;
+    char *log_file = NULL;
+    char *hostname = NULL;
+    char *buf = NULL;
+    struct stat stat;
+
+    if (argc != 4) {
+        fprintf(
+            stderr,
+            "Expect following args %s <hostname> <Vol> <log file location>\n",
+            argv[0]);
+        return -1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    log_file = argv[3];
+
+    fs = setup_new_client(hostname, volname, log_file, 0);
+    if (!fs) {
+        fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n",
+                strerror(errno));
+        goto error;
+    }
+
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "/: %s\n", strerror(errno));
+        return -1;
+    }
+
+    glfs_readdirplus(fd, &stat);
+
+    fd = glfs_open(fs, "/test", O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto error;
+    }
+
+    buf = (char *)malloc(5);
+
+    ret = glfs_pread(fd, buf, 5, 0, 0, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Read(%s): %d (%s)\n", "test", ret, strerror(errno));
+        return ret;
+    }
+
+    free(buf);
+    glfs_close(fd);
+
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
         return -1;
+    }
+
+    return 0;
+error:
+    return -1;
 }
diff --git a/tests/bugs/nfs/bug-1210338.c b/tests/bugs/nfs/bug-1210338.c
index 7a17b9d68ce..d4099244176 100644
--- a/tests/bugs/nfs/bug-1210338.c
+++ b/tests/bugs/nfs/bug-1210338.c
@@ -7,26 +7,25 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 
-
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret  = -1;
-        int   fd   = -1;
+    int ret = -1;
+    int fd = -1;
 
-        fd = open (argv[1], O_CREAT|O_EXCL, 0644);
+    fd = open(argv[1], O_CREAT | O_EXCL, 0644);
 
-        if (fd == -1) {
-                fprintf (stderr, "creation of the file %s failed (%s)\n", argv[1],
-                         strerror (errno));
-                goto out;
-        }
+    if (fd == -1) {
+        fprintf(stderr, "creation of the file %s failed (%s)\n", argv[1],
+                strerror(errno));
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd > 0)
-                close (fd);
+    if (fd > 0)
+        close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/posix/bug-1175711.c b/tests/bugs/posix/bug-1175711.c
index fbbea3f636b..8ab193c4014 100644
--- a/tests/bugs/posix/bug-1175711.c
+++ b/tests/bugs/posix/bug-1175711.c
@@ -6,32 +6,32 @@
 int
 main(int argc, char **argv)
 {
-        DIR *dir = NULL;
-        struct dirent *entry = NULL;
-        int ret = 0;
-        char *path = NULL;
+    DIR *dir = NULL;
+    struct dirent *entry = NULL;
+    int ret = 0;
+    char *path = NULL;
 
-        assert (argc == 2);
-        path = argv[1];
+    assert(argc == 2);
+    path = argv[1];
 
-        dir = opendir(path);
-        if (!dir) {
-                printf("opendir(%s) failed.\n", path);
-                return -1;
-        }
+    dir = opendir(path);
+    if (!dir) {
+        printf("opendir(%s) failed.\n", path);
+        return -1;
+    }
 
 #ifdef _DIRENT_HAVE_D_TYPE
-        while ((entry = readdir(dir)) != NULL) {
-                if (entry->d_type == DT_UNKNOWN) {
-                        printf("d_type found to be DT_UNKNOWN\n");
-                        ret = -1;
-                        break;
-                }
+    while ((entry = readdir(dir)) != NULL) {
+        if (entry->d_type == DT_UNKNOWN) {
+            printf("d_type found to be DT_UNKNOWN\n");
+            ret = -1;
+            break;
         }
+    }
 #endif
 
-        if (dir)
-                closedir(dir);
+    if (dir)
+        closedir(dir);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
index 325edbbed97..4ed3181d48f 100644
--- a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
+++ b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c
@@ -5,94 +5,100 @@
 #include <string.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs       = NULL;
-        int       ret       = 0;
-        int       i         = 0;
-        glfs_fd_t *fd       = NULL;
-        char      *logfile  = NULL;
-        char      *hostname = NULL;
+    glfs_t *fs = NULL;
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
 
-        if (argc != 4) {
-                fprintf (stderr,
-                        "Expect following args %s <hostname> <Vol> <log file>\n"
-                        , argv[0]);
-                return -1;
-        }
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <hostname> <Vol> <log file>\n",
+                argv[0]);
+        return -1;
+    }
 
-        hostname = argv[1];
-        logfile = argv[3];
+    hostname = argv[1];
+    logfile = argv[3];
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL (%s)\n",
-                        strerror (errno));
-                return -1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n",
-                ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_init failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
 
-        fd = glfs_opendir (fs, "/");
-        if (!fd) {
-                fprintf (stderr, "glfs_opendir failed with (%s)\n",
-                         strerror (errno));
-                return -1;
-        }
+    fd = glfs_opendir(fs, "/");
+    if (!fd) {
+        fprintf(stderr, "glfs_opendir failed with (%s)\n", strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.gfid");
-        if (ret == 0 || errno != EPERM) {
-                fprintf (stderr, "glfs_fremovexattr gfid exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.gfid");
+    if (ret == 0 || errno != EPERM) {
+        fprintf(stderr,
+                "glfs_fremovexattr gfid exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.glusterfs.volume-id");
-        if (ret == 0 || errno != EPERM) {
-                fprintf (stderr, "glfs_fremovexattr volume-id exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.glusterfs.volume-id");
+    if (ret == 0 || errno != EPERM) {
+        fprintf(stderr,
+                "glfs_fremovexattr volume-id exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fsetxattr (fd, "trusted.abc", "abc", 3, 0);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fsetxattr trusted.abc exited with ret: "
-                         "%d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fsetxattr(fd, "trusted.abc", "abc", 3, 0);
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_fsetxattr trusted.abc exited with ret: "
+                "%d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        ret = glfs_fremovexattr (fd, "trusted.abc");
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fremovexattr trusted.abc exited with "
-                         "ret: %d (%s)\n", ret, strerror (errno));
-                return -1;
-        }
+    ret = glfs_fremovexattr(fd, "trusted.abc");
+    if (ret < 0) {
+        fprintf(stderr,
+                "glfs_fremovexattr trusted.abc exited with "
+                "ret: %d (%s)\n",
+                ret, strerror(errno));
+        return -1;
+    }
 
-        (void) glfs_closedir(fd);
-        ret = glfs_fini (fs);
-        if (ret < 0) {
-                fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n",
-                        ret, strerror (errno));
-                return -1;
-        }
-        return 0;
+    (void)glfs_closedir(fd);
+    ret = glfs_fini(fs);
+    if (ret < 0) {
+        fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        return -1;
+    }
+    return 0;
 }
diff --git a/tests/bugs/protocol/bug-808400-fcntl.c b/tests/bugs/protocol/bug-808400-fcntl.c
index 87a83f317b8..a703ca5c120 100644
--- a/tests/bugs/protocol/bug-808400-fcntl.c
+++ b/tests/bugs/protocol/bug-808400-fcntl.c
@@ -12,106 +12,113 @@
 #endif
 
 int
-run_child (char *filename)
+run_child(char *filename)
 {
-        int          fd   = -1, ret = -1;
-        struct flock lock = {0, };
-        int          ppid = 0;
-
-        fd = open (filename, O_RDWR);
-        if (fd < 0) {
-                fprintf (stderr, "open failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        ppid = getppid ();
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-
-        ret = fcntl (fd, F_GETLK, &lock);
-        if (ret < 0) {
-                fprintf (stderr, "GETLK failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        if ((lock.l_type == F_UNLCK) ||
-            (ppid != lock.l_pid)) {
-                fprintf (stderr, "no locks present, though parent has held "
-                         "one\n");
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int fd = -1, ret = -1;
+    struct flock lock = {
+        0,
+    };
+    int ppid = 0;
+
+    fd = open(filename, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "open failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    ppid = getppid();
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    ret = fcntl(fd, F_GETLK, &lock);
+    if (ret < 0) {
+        fprintf(stderr, "GETLK failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    if ((lock.l_type == F_UNLCK) || (ppid != lock.l_pid)) {
+        fprintf(stderr,
+                "no locks present, though parent has held "
+                "one\n");
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1, ret = -1, status = 0;
-        char        *filename = NULL, *cmd = NULL;
-        struct stat  stbuf    = {0, };
-        struct flock lock     = {0, };
-
-        if (argc != 3) {
-                fprintf (stderr, "Usage: %s <filename> "
-                         "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]);
-                goto out;
-        }
-
-        filename = argv[1];
-        cmd = argv[2];
-
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret < 0) {
-                fprintf (stderr, "fcntl failed (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        system (cmd);
-
-        /* wait till graph switch completes */
-        ret = fstat64 (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno));
-                goto out;
-        }
-
-        sleep (10);
-
-        /* By now old-graph would be disconnected and locks should be cleaned
-         * up if they are not migrated. Check that by trying to acquire a lock
-         * on a new fd opened by another process on same file.
-         */
-        ret = fork ();
-        if (ret == 0) {
-                ret = run_child (filename);
+    int fd = -1, ret = -1, status = 0;
+    char *filename = NULL, *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    struct flock lock = {
+        0,
+    };
+
+    if (argc != 3) {
+        fprintf(stderr,
+                "Usage: %s <filename> "
+                "<gluster-cmd-to-trigger-graph-switch>\n",
+                argv[0]);
+        goto out;
+    }
+
+    filename = argv[1];
+    cmd = argv[2];
+
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret < 0) {
+        fprintf(stderr, "fcntl failed (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    system(cmd);
+
+    /* wait till graph switch completes */
+    ret = fstat64(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno));
+        goto out;
+    }
+
+    sleep(10);
+
+    /* By now old-graph would be disconnected and locks should be cleaned
+     * up if they are not migrated. Check that by trying to acquire a lock
+     * on a new fd opened by another process on same file.
+     */
+    ret = fork();
+    if (ret == 0) {
+        ret = run_child(filename);
+    } else {
+        wait(&status);
+        if (WIFEXITED(status)) {
+            ret = WEXITSTATUS(status);
         } else {
-                wait (&status);
-                if (WIFEXITED(status)) {
-                        ret = WEXITSTATUS(status);
-                } else {
-                        ret = 0;
-                }
+            ret = 0;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/protocol/bug-808400-flock.c b/tests/bugs/protocol/bug-808400-flock.c
index bd2ce8cfb01..54a507cc227 100644
--- a/tests/bugs/protocol/bug-808400-flock.c
+++ b/tests/bugs/protocol/bug-808400-flock.c
@@ -12,85 +12,89 @@
 #endif
 
 int
-run_child (char *filename)
+run_child(char *filename)
 {
-        int fd = -1, ret = -1;
+    int fd = -1, ret = -1;
 
-        fd = open (filename, O_RDWR);
-        if (fd < 0) {
-                fprintf (stderr, "open failed (%s)\n", strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "open failed (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        ret = flock (fd, LOCK_EX | LOCK_NB);
-        if ((ret == 0) || (errno != EWOULDBLOCK)) {
-                fprintf (stderr, "no locks present, though parent has held "
-                         "one\n");
-                ret = -1;
-                goto out;
-        }
+    ret = flock(fd, LOCK_EX | LOCK_NB);
+    if ((ret == 0) || (errno != EWOULDBLOCK)) {
+        fprintf(stderr,
+                "no locks present, though parent has held "
+                "one\n");
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd       = -1, ret = -1, status = 0;
-        char        *filename = NULL, *cmd = NULL;
-        struct stat  stbuf    = {0, };
+    int fd = -1, ret = -1, status = 0;
+    char *filename = NULL, *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
 
-        if (argc != 3) {
-                fprintf (stderr, "Usage: %s <filename> "
-                         "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]);
-                goto out;
-        }
+    if (argc != 3) {
+        fprintf(stderr,
+                "Usage: %s <filename> "
+                "<gluster-cmd-to-trigger-graph-switch>\n",
+                argv[0]);
+        goto out;
+    }
 
-        filename = argv[1];
-        cmd = argv[2];
+    filename = argv[1];
+    cmd = argv[2];
 
-        fd = open (filename, O_RDWR | O_CREAT, 0);
-        if (fd < 0) {
-                fprintf (stderr, "open (%s) failed (%s)\n", filename,
-                         strerror (errno));
-                goto out;
-        }
+    fd = open(filename, O_RDWR | O_CREAT, 0);
+    if (fd < 0) {
+        fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno));
+        goto out;
+    }
 
-        ret = flock (fd, LOCK_EX);
-        if (ret < 0) {
-                fprintf (stderr, "flock failed (%s)\n", strerror (errno));
-                goto out;
-        }
+    ret = flock(fd, LOCK_EX);
+    if (ret < 0) {
+        fprintf(stderr, "flock failed (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        system (cmd);
+    system(cmd);
 
-        /* wait till graph switch completes */
-        ret = fstat64 (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno));
-                goto out;
-        }
+    /* wait till graph switch completes */
+    ret = fstat64(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno));
+        goto out;
+    }
 
-        sleep (10);
+    sleep(10);
 
-        /* By now old-graph would be disconnected and locks should be cleaned
-         * up if they are not migrated. Check that by trying to acquire a lock
-         * on a new fd opened by another process on same file
-         */
-        ret = fork ();
-        if (ret == 0) {
-                ret = run_child (filename);
+    /* By now old-graph would be disconnected and locks should be cleaned
+     * up if they are not migrated. Check that by trying to acquire a lock
+     * on a new fd opened by another process on same file
+     */
+    ret = fork();
+    if (ret == 0) {
+        ret = run_child(filename);
+    } else {
+        wait(&status);
+        if (WIFEXITED(status)) {
+            ret = WEXITSTATUS(status);
         } else {
-                wait (&status);
-                if (WIFEXITED(status)) {
-                        ret = WEXITSTATUS(status);
-                } else {
-                        ret = 0;
-                }
+            ret = 0;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/bugs/quick-read/bz1523599/test_bz1523599.c b/tests/bugs/quick-read/bz1523599/test_bz1523599.c
index 843408680a7..5076a9447f3 100644
--- a/tests/bugs/quick-read/bz1523599/test_bz1523599.c
+++ b/tests/bugs/quick-read/bz1523599/test_bz1523599.c
@@ -1,7 +1,8 @@
 /*
  * ./test_bz1523599 0 vm140-111 gv0 test211 log
  * ./test_bz1523599 1 vm140-111 gv0 test211 log
- * Open - Discard - Read - Then check read information to see if the initial TEST_STR_LEN/2 bytes read zero
+ * Open - Discard - Read - Then check read information to see if the initial
+ * TEST_STR_LEN/2 bytes read zero
  */
 
 #define _GNU_SOURCE
@@ -15,182 +16,183 @@
 #define TEST_STR_LEN 2048
 
 enum fallocate_flag {
-	TEST_WRITE,
-	TEST_DISCARD,
-	TEST_ZEROFILL,
+    TEST_WRITE,
+    TEST_DISCARD,
+    TEST_ZEROFILL,
 };
 
-void print_str(char *str, int len)
+void
+print_str(char *str, int len)
 {
-	int i, addr;
-
-	printf("%07x\t", 0);
-	for (i = 0; i < len; i++) {
-		printf("%02x", str[i]);
-		if (i) {
-			if ((i + 1) % 16 == 0)
-				printf("\n%07x\t", i+1);
-			else if ((i + 1) % 4 == 0)
-				printf(" ");
-		}
-	}
-	printf("\n");
+    int i, addr;
+
+    printf("%07x\t", 0);
+    for (i = 0; i < len; i++) {
+        printf("%02x", str[i]);
+        if (i) {
+            if ((i + 1) % 16 == 0)
+                printf("\n%07x\t", i + 1);
+            else if ((i + 1) % 4 == 0)
+                printf(" ");
+        }
+    }
+    printf("\n");
 }
 
 int
 test_read(char *str, int total_length, int len_zero)
 {
-	int i;
-	int ret = 0;
-
-	for (i = 0; i < len_zero; i++) {
-		if (str[i]) {
-			fprintf(stderr, "char at position %d not zeroed out\n",
-				i);
-			ret = -EIO;
-			goto out;
-		}
-	}
-
-	for (i = len_zero; i < total_length; i++) {
-		if (str[i] != 0x11) {
-			fprintf(stderr,
-				"char at position %d does not contain pattern\n",
-				i);
-			ret = -EIO;
-			goto out;
-		}
-	}
+    int i;
+    int ret = 0;
+
+    for (i = 0; i < len_zero; i++) {
+        if (str[i]) {
+            fprintf(stderr, "char at position %d not zeroed out\n", i);
+            ret = -EIO;
+            goto out;
+        }
+    }
+
+    for (i = len_zero; i < total_length; i++) {
+        if (str[i] != 0x11) {
+            fprintf(stderr, "char at position %d does not contain pattern\n",
+                    i);
+            ret = -EIO;
+            goto out;
+        }
+    }
 out:
-	return ret;
+    return ret;
 }
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-	int opcode;
-	char *host_name, *volume_name, *file_path, *glfs_log_path;
-	glfs_t *fs = NULL;
-	glfs_fd_t *fd = NULL;
-	off_t offset = 0;
-	size_t len_zero = TEST_STR_LEN / 2;
-	char writestr[TEST_STR_LEN];
-	char readstr[TEST_STR_LEN];
-	struct iovec iov = {&readstr, TEST_STR_LEN};
-	int i;
-	int ret = 1;
-
-	for (i = 0; i < TEST_STR_LEN; i++)
-		writestr[i] = 0x11;
-	for (i = 0; i < TEST_STR_LEN; i++)
-		readstr[i] = 0x22;
-
-	if (argc != 6) {
-		fprintf(stderr,
-			"Syntax: %s <test type> <host> <volname> <file-path> <log-file>\n",
-			argv[0]);
-		return 1;
-	}
-
-	opcode = atoi(argv[1]);
-	host_name = argv[2];
-	volume_name = argv[3];
-	file_path = argv[4];
-	glfs_log_path = argv[5];
-
-	fs = glfs_new(volume_name);
-	if (!fs) {
-		perror("glfs_new");
-		return 1;
-	}
-
-	ret = glfs_set_volfile_server(fs, "tcp", host_name, 24007);
-	if (ret != 0) {
-		perror("glfs_set_volfile_server");
-		goto out;
-	}
-
-	ret = glfs_set_logging(fs, glfs_log_path, 7);
-	if (ret != 0) {
-		perror("glfs_set_logging");
-		goto out;
-	}
-
-	ret = glfs_init(fs);
-	if (ret != 0) {
-		perror("glfs_init");
-		goto out;
-	}
-
-	fd = glfs_creat(fs, file_path, O_RDWR, 0777);
-	if (fd == NULL) {
-		perror("glfs_creat");
-		ret = -1;
-		goto out;
-	}
-
-	switch (opcode) {
-		case TEST_WRITE:
-			fprintf(stderr, "Test Write\n");
-			ret = glfs_write(fd, writestr, TEST_STR_LEN, 0);
-			if (ret < 0) {
-				perror("glfs_write");
-				goto out;
-			} else if (ret != TEST_STR_LEN) {
-				fprintf(stderr, "insufficient data written %d \n", ret);
-				ret = -EIO;
-				goto out;
-			}
-			ret = 0;
-			goto out;
-		case TEST_DISCARD:
-			fprintf(stderr, "Test Discard\n");
-			ret = glfs_discard(fd, offset, len_zero);
-			if (ret < 0) {
-				if (errno == EOPNOTSUPP) {
-					fprintf(stderr, "Operation not supported\n");
-					ret = 0;
-					goto out;
-				}
-				perror("glfs_discard");
-				goto out;
-			}
-			goto test_read;
-		case TEST_ZEROFILL:
-			fprintf(stderr, "Test Zerofill\n");
-			ret = glfs_zerofill(fd, offset, len_zero);
-			if (ret < 0) {
-				if (errno == EOPNOTSUPP) {
-					fprintf(stderr, "Operation not supported\n");
-					ret = 0;
-					goto out;
-				}
-				perror("glfs_zerofill");
-				goto out;
-			}
-			goto test_read;
-		default:
-			ret = -1;
-			fprintf(stderr, "Incorrect test code %d\n", opcode);
-			goto out;
-	}
+    int opcode;
+    char *host_name, *volume_name, *file_path, *glfs_log_path;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    off_t offset = 0;
+    size_t len_zero = TEST_STR_LEN / 2;
+    char writestr[TEST_STR_LEN];
+    char readstr[TEST_STR_LEN];
+    struct iovec iov = {&readstr, TEST_STR_LEN};
+    int i;
+    int ret = 1;
+
+    for (i = 0; i < TEST_STR_LEN; i++)
+        writestr[i] = 0x11;
+    for (i = 0; i < TEST_STR_LEN; i++)
+        readstr[i] = 0x22;
+
+    if (argc != 6) {
+        fprintf(
+            stderr,
+            "Syntax: %s <test type> <host> <volname> <file-path> <log-file>\n",
+            argv[0]);
+        return 1;
+    }
+
+    opcode = atoi(argv[1]);
+    host_name = argv[2];
+    volume_name = argv[3];
+    file_path = argv[4];
+    glfs_log_path = argv[5];
+
+    fs = glfs_new(volume_name);
+    if (!fs) {
+        perror("glfs_new");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host_name, 24007);
+    if (ret != 0) {
+        perror("glfs_set_volfile_server");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, glfs_log_path, 7);
+    if (ret != 0) {
+        perror("glfs_set_logging");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        perror("glfs_init");
+        goto out;
+    }
+
+    fd = glfs_creat(fs, file_path, O_RDWR, 0777);
+    if (fd == NULL) {
+        perror("glfs_creat");
+        ret = -1;
+        goto out;
+    }
+
+    switch (opcode) {
+        case TEST_WRITE:
+            fprintf(stderr, "Test Write\n");
+            ret = glfs_write(fd, writestr, TEST_STR_LEN, 0);
+            if (ret < 0) {
+                perror("glfs_write");
+                goto out;
+            } else if (ret != TEST_STR_LEN) {
+                fprintf(stderr, "insufficient data written %d \n", ret);
+                ret = -EIO;
+                goto out;
+            }
+            ret = 0;
+            goto out;
+        case TEST_DISCARD:
+            fprintf(stderr, "Test Discard\n");
+            ret = glfs_discard(fd, offset, len_zero);
+            if (ret < 0) {
+                if (errno == EOPNOTSUPP) {
+                    fprintf(stderr, "Operation not supported\n");
+                    ret = 0;
+                    goto out;
+                }
+                perror("glfs_discard");
+                goto out;
+            }
+            goto test_read;
+        case TEST_ZEROFILL:
+            fprintf(stderr, "Test Zerofill\n");
+            ret = glfs_zerofill(fd, offset, len_zero);
+            if (ret < 0) {
+                if (errno == EOPNOTSUPP) {
+                    fprintf(stderr, "Operation not supported\n");
+                    ret = 0;
+                    goto out;
+                }
+                perror("glfs_zerofill");
+                goto out;
+            }
+            goto test_read;
+        default:
+            ret = -1;
+            fprintf(stderr, "Incorrect test code %d\n", opcode);
+            goto out;
+    }
 
 test_read:
-	ret = glfs_readv(fd, &iov, 1, 0);
-	if (ret < 0) {
-		perror("glfs_readv");
-		goto out;
-	}
+    ret = glfs_readv(fd, &iov, 1, 0);
+    if (ret < 0) {
+        perror("glfs_readv");
+        goto out;
+    }
 
-	/* printf("Read str\n"); print_str(readstr, TEST_STR_LEN); printf("\n"); */
-	ret = test_read(readstr, TEST_STR_LEN, len_zero);
+    /* printf("Read str\n"); print_str(readstr, TEST_STR_LEN); printf("\n"); */
+    ret = test_read(readstr, TEST_STR_LEN, len_zero);
 
 out:
-	if (fd)
-		glfs_close(fd);
-	glfs_fini(fs);
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
 
-	if (ret)
-		return -1;
+    if (ret)
+        return -1;
 
-	return 0;
+    return 0;
 }
diff --git a/tests/bugs/readdir-ahead/bug-1390050.c b/tests/bugs/readdir-ahead/bug-1390050.c
index 5593a1d4c0c..9578df2dd90 100644
--- a/tests/bugs/readdir-ahead/bug-1390050.c
+++ b/tests/bugs/readdir-ahead/bug-1390050.c
@@ -8,63 +8,65 @@
 #include <errno.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        const char  *glfs_dir          = NULL, *filepath = NULL;
-        DIR         *dirfd             = NULL;
-        int          filefd            = 0, ret = 0;
-        struct stat  stbuf             = {0, };
-        size_t       size_before_write = 0;
+    const char *glfs_dir = NULL, *filepath = NULL;
+    DIR *dirfd = NULL;
+    int filefd = 0, ret = 0;
+    struct stat stbuf = {
+        0,
+    };
+    size_t size_before_write = 0;
 
-        glfs_dir = argv[1];
-        filepath = argv[2];
-        dirfd = opendir (glfs_dir);
-        if (dirfd == NULL) {
-                fprintf (stderr, "opening directory failed (%s)\n",
-                         strerror (errno));
-                goto err;
-        }
+    glfs_dir = argv[1];
+    filepath = argv[2];
+    dirfd = opendir(glfs_dir);
+    if (dirfd == NULL) {
+        fprintf(stderr, "opening directory failed (%s)\n", strerror(errno));
+        goto err;
+    }
 
-        filefd = open (filepath, O_RDWR);
-        if (filefd < 0) {
-                fprintf (stderr, "open failed on path %s (%s)\n", filepath,
-                         strerror (errno));
-                goto err;
-        }
+    filefd = open(filepath, O_RDWR);
+    if (filefd < 0) {
+        fprintf(stderr, "open failed on path %s (%s)\n", filepath,
+                strerror(errno));
+        goto err;
+    }
 
-        ret = stat (filepath, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed on path %s (%s)\n", filepath,
-                         strerror (errno));
-                goto err;
-        }
+    ret = stat(filepath, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed on path %s (%s)\n", filepath,
+                strerror(errno));
+        goto err;
+    }
 
-        size_before_write = stbuf.st_size;
+    size_before_write = stbuf.st_size;
 
-        ret = write (filefd, "testdata", strlen ("testdata123") + 1);
-        if (ret <= 0) {
-                fprintf (stderr, "write failed (%s)\n", strerror (errno));
-                goto err;
-        }
+    ret = write(filefd, "testdata", strlen("testdata123") + 1);
+    if (ret <= 0) {
+        fprintf(stderr, "write failed (%s)\n", strerror(errno));
+        goto err;
+    }
 
-        while (readdir (dirfd)) {
-                /* do nothing */
-        }
+    while (readdir(dirfd)) {
+        /* do nothing */
+    }
 
-        ret = stat (filepath, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed on path %s (%s)\n",
-                         strerror (errno));
-                goto err;
-        }
+    ret = stat(filepath, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed on path %s (%s)\n", strerror(errno));
+        goto err;
+    }
 
-        if (stbuf.st_size == size_before_write) {
-                fprintf (stderr, "file size (%lu) has not changed even after "
-                         "its written to\n", stbuf.st_size);
-                goto err;
-        }
+    if (stbuf.st_size == size_before_write) {
+        fprintf(stderr,
+                "file size (%lu) has not changed even after "
+                "its written to\n",
+                stbuf.st_size);
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        return -1;
+    return -1;
 }
diff --git a/tests/bugs/replicate/bug-1250170-fsync.c b/tests/bugs/replicate/bug-1250170-fsync.c
index 421fb5c5067..21fd96594aa 100644
--- a/tests/bugs/replicate/bug-1250170-fsync.c
+++ b/tests/bugs/replicate/bug-1250170-fsync.c
@@ -7,50 +7,50 @@
 #include <unistd.h>
 #include <string.h>
 
-int main (int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        char *file = NULL;
-        int fd = -1;
-        char *buffer = NULL;
-        size_t buf_size = 0;
-        size_t written = 0;
-        int ret = 0;
-        off_t offset = 0;
-        int i = 0;
-        int loop_count = 5;
+    char *file = NULL;
+    int fd = -1;
+    char *buffer = NULL;
+    size_t buf_size = 0;
+    size_t written = 0;
+    int ret = 0;
+    off_t offset = 0;
+    int i = 0;
+    int loop_count = 5;
 
-        if (argc < 2) {
-                printf ("Usage:%s <filename>\n", argv[0]);
-                return -1;
-        }
+    if (argc < 2) {
+        printf("Usage:%s <filename>\n", argv[0]);
+        return -1;
+    }
 
-        file = argv[1];
-        buf_size = 1024;
-        buffer = malloc(buf_size);
-        if (!buffer) {
-                perror("malloc");
-                return -1;
-        }
-        memset (buffer, 'R', buf_size);
+    file = argv[1];
+    buf_size = 1024;
+    buffer = malloc(buf_size);
+    if (!buffer) {
+        perror("malloc");
+        return -1;
+    }
+    memset(buffer, 'R', buf_size);
 
-        fd = open(file, O_WRONLY);
-        if (fd == -1) {
-                perror("open");
-                return -1;
-        }
+    fd = open(file, O_WRONLY);
+    if (fd == -1) {
+        perror("open");
+        return -1;
+    }
 
-        for (i = 0; i < loop_count; i++) {
-                ret =  write (fd, buffer, buf_size);
-                if (ret == -1) {
-                        perror("write");
-                        return ret;
-                } else {
-                        written += ret;
-                }
-                offset = lseek (fd, 0 , SEEK_SET);
+    for (i = 0; i < loop_count; i++) {
+        ret = write(fd, buffer, buf_size);
+        if (ret == -1) {
+            perror("write");
+            return ret;
+        } else {
+            written += ret;
         }
+        offset = lseek(fd, 0, SEEK_SET);
+    }
 
-        free(buffer);
-        return 0;
-
+    free(buffer);
+    return 0;
 }
diff --git a/tests/bugs/shard/bug-shard-discard.c b/tests/bugs/shard/bug-shard-discard.c
index b1268278fa5..15dca6c2181 100644
--- a/tests/bugs/shard/bug-shard-discard.c
+++ b/tests/bugs/shard/bug-shard-discard.c
@@ -4,63 +4,66 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret = 0;
-        off_t      off = 0;
-        size_t     len = 0;
-        glfs_t    *fs  = NULL;
-        glfs_fd_t *fd  = NULL;
+    int ret = 0;
+    off_t off = 0;
+    size_t len = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
 
-        if (argc != 7) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 7) {
+        fprintf(
+            stderr,
+            "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n",
+            argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_set_logging (fs, argv[6], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_logging(fs, argv[6], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        off = atoi (argv[4]);
-        len = atoi (argv[5]);
+    off = atoi(argv[4]);
+    len = atoi(argv[5]);
 
-        ret = glfs_discard (fd, off, len);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_discard: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_discard(fd, off, len);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_discard: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close (fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/shard/bug-shard-zerofill.c b/tests/bugs/shard/bug-shard-zerofill.c
index c0525a58afc..ed4c8c54dc2 100644
--- a/tests/bugs/shard/bug-shard-zerofill.c
+++ b/tests/bugs/shard/bug-shard-zerofill.c
@@ -3,57 +3,58 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-
-        if (argc != 5) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, argv[4], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-
-        /* Zero-fill "foo" with 10MB of data */
-        ret = glfs_zerofill (fd, 0, 10485760);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_zerofill: returned %d\n", ret);
-                goto out;
-        }
-
-        ret = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+
+    if (argc != 5) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n",
+                argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, argv[4], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    /* Zero-fill "foo" with 10MB of data */
+    ret = glfs_zerofill(fd, 0, 10485760);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_zerofill: returned %d\n", ret);
+        goto out;
+    }
+
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/shard/shard-append-test.c b/tests/bugs/shard/shard-append-test.c
index 92dff3d078d..c7debb2b182 100644
--- a/tests/bugs/shard/shard-append-test.c
+++ b/tests/bugs/shard/shard-append-test.c
@@ -10,9 +10,10 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 /*This test tests that shard xlator handles offset in appending writes
  * correctly. This test performs writes of 1025 bytes 1025 times, in 5 threads
@@ -26,154 +27,157 @@ pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 int thread_data = '1';
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
+    int ret = -1;
+    glfs_t *fs = NULL;
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
-void*
-write_data (void *data)
+void *
+write_data(void *data)
 {
-        char           buf[1025] = {0};
-        glfs_fd_t      *glfd = NULL;
-        glfs_t         *fs       = data;
-        int            i     = 0;
-
-        pthread_mutex_lock (&lock);
-        {
-                memset(buf, thread_data, sizeof(buf));
-                thread_data++;
+    char buf[1025] = {0};
+    glfs_fd_t *glfd = NULL;
+    glfs_t *fs = data;
+    int i = 0;
+
+    pthread_mutex_lock(&lock);
+    {
+        memset(buf, thread_data, sizeof(buf));
+        thread_data++;
+    }
+    pthread_mutex_unlock(&lock);
+
+    for (i = 0; i < 1025; i++) {
+        glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND,
+                          S_IRUSR | S_IWUSR | O_SYNC);
+        if (!glfd) {
+            LOG_ERR("Failed to create file");
+            exit(1);
         }
-        pthread_mutex_unlock (&lock);
-
-        for (i = 0; i < 1025; i++) {
-                glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND,
-                                   S_IRUSR | S_IWUSR | O_SYNC);
-                if (!glfd) {
-                        LOG_ERR ("Failed to create file");
-                        exit(1);
-                }
-
-                if (glfs_write (glfd, buf, sizeof(buf), 0) < 0) {
-                        LOG_ERR ("Failed to write to file");
-                        exit(1);
-                }
-                if (glfs_close(glfd) != 0) {
-                        LOG_ERR ("Failed to close file");
-                        exit(1);
-                }
+
+        if (glfs_write(glfd, buf, sizeof(buf), 0) < 0) {
+            LOG_ERR("Failed to write to file");
+            exit(1);
         }
-        return NULL;
+        if (glfs_close(glfd) != 0) {
+            LOG_ERR("Failed to close file");
+            exit(1);
+        }
+    }
+    return NULL;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        pthread_t  tid[5] = {0};
-        char       buf[1025] = {0};
-        char       cmp_buf[1025] = {0};
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
-        glfs_fd_t  *glfd     = NULL;
-        ssize_t     bytes_read = 0;
-        ssize_t     total_bytes_read = 0;
-        int i = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        for (i = 0; i < 5; i++) {
-                pthread_create(&tid[i], NULL, write_data, fs);
-        }
-
-        for (i = 0; i < 5; i++) {
-                pthread_join(tid[i], NULL);
-        }
-        glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY);
-        if (!glfd) {
-                LOG_ERR ("Failed to open file for reading");
-                exit(1);
+    pthread_t tid[5] = {0};
+    char buf[1025] = {0};
+    char cmp_buf[1025] = {0};
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    ssize_t bytes_read = 0;
+    ssize_t total_bytes_read = 0;
+    int i = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    for (i = 0; i < 5; i++) {
+        pthread_create(&tid[i], NULL, write_data, fs);
+    }
+
+    for (i = 0; i < 5; i++) {
+        pthread_join(tid[i], NULL);
+    }
+    glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY);
+    if (!glfd) {
+        LOG_ERR("Failed to open file for reading");
+        exit(1);
+    }
+
+    while ((bytes_read = glfs_read(glfd, buf, sizeof(buf), 0)) > 0) {
+        if (bytes_read != sizeof(buf)) {
+            fprintf(stderr,
+                    "Didn't read complete data read: %zd "
+                    "expected: %lu",
+                    bytes_read, sizeof(buf));
+            exit(1);
         }
 
-        while ((bytes_read = glfs_read (glfd, buf, sizeof(buf), 0)) > 0) {
-                if (bytes_read != sizeof(buf)) {
-                        fprintf (stderr, "Didn't read complete data read: %zd "
-                                 "expected: %lu", bytes_read, sizeof(buf));
-                        exit(1);
-                }
-
-                total_bytes_read += bytes_read;
-                if (buf[0] < '1' || buf[0] >= thread_data) {
-                        fprintf(stderr, "Invalid character found: %c", buf[0]);
-                        exit(1);
-                }
-                memset(cmp_buf, buf[0], sizeof(cmp_buf));
-                if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) {
-                        LOG_ERR ("Data corrupted");
-                        exit(1);
-                }
-                memset(cmp_buf, 0, sizeof(cmp_buf));
+        total_bytes_read += bytes_read;
+        if (buf[0] < '1' || buf[0] >= thread_data) {
+            fprintf(stderr, "Invalid character found: %c", buf[0]);
+            exit(1);
         }
-
-        if (total_bytes_read != 5*1025*1025) {
-                fprintf(stderr, "Failed to read what is written, read; %zd, "
-                        "expected %zu", total_bytes_read, 5*1025*1025);
-                exit(1);
-        }
-
-        if (glfs_close(glfd) != 0) {
-                LOG_ERR ("Failed to close");
-                exit(1);
+        memset(cmp_buf, buf[0], sizeof(cmp_buf));
+        if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) {
+            LOG_ERR("Data corrupted");
+            exit(1);
         }
-        return 0;
+        memset(cmp_buf, 0, sizeof(cmp_buf));
+    }
+
+    if (total_bytes_read != 5 * 1025 * 1025) {
+        fprintf(stderr,
+                "Failed to read what is written, read; %zd, "
+                "expected %zu",
+                total_bytes_read, 5 * 1025 * 1025);
+        exit(1);
+    }
+
+    if (glfs_close(glfd) != 0) {
+        LOG_ERR("Failed to close");
+        exit(1);
+    }
+    return 0;
 }
diff --git a/tests/bugs/shard/shard-fallocate.c b/tests/bugs/shard/shard-fallocate.c
index 8745c0ece1d..3a784d3c02c 100644
--- a/tests/bugs/shard/shard-fallocate.c
+++ b/tests/bugs/shard/shard-fallocate.c
@@ -6,104 +6,107 @@
 #include <glusterfs/api/glfs-handles.h>
 
 enum fallocate_flag {
-        TEST_FALLOCATE_NONE,
-        TEST_FALLOCATE_KEEP_SIZE,
-        TEST_FALLOCATE_ZERO_RANGE,
-        TEST_FALLOCATE_PUNCH_HOLE,
-        TEST_FALLOCATE_MAX,
+    TEST_FALLOCATE_NONE,
+    TEST_FALLOCATE_KEEP_SIZE,
+    TEST_FALLOCATE_ZERO_RANGE,
+    TEST_FALLOCATE_PUNCH_HOLE,
+    TEST_FALLOCATE_MAX,
 };
 
 int
-get_fallocate_flag (int opcode)
+get_fallocate_flag(int opcode)
 {
-        int ret = 0;
+    int ret = 0;
 
-        switch (opcode) {
+    switch (opcode) {
         case TEST_FALLOCATE_NONE:
-                ret = 0;
-                break;
+            ret = 0;
+            break;
         case TEST_FALLOCATE_KEEP_SIZE:
-                ret = FALLOC_FL_KEEP_SIZE;
-                break;
+            ret = FALLOC_FL_KEEP_SIZE;
+            break;
         case TEST_FALLOCATE_ZERO_RANGE:
-                ret = FALLOC_FL_ZERO_RANGE;
-                break;
+            ret = FALLOC_FL_ZERO_RANGE;
+            break;
         case TEST_FALLOCATE_PUNCH_HOLE:
-                ret = FALLOC_FL_PUNCH_HOLE;
-                break;
+            ret = FALLOC_FL_PUNCH_HOLE;
+            break;
         default:
-                ret = -1;
-                break;
-        }
-        return ret;
+            ret = -1;
+            break;
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret = 1;
-        int        opcode = -1;
-        off_t      offset = 0;
-        size_t     len = 0;
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
+    int ret = 1;
+    int opcode = -1;
+    off_t offset = 0;
+    size_t len = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
 
-        if (argc != 8) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <opcode> <offset> <len> <file-path> <log-file>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 8) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <opcode> <offset> <len> "
+                "<file-path> <log-file>\n",
+                argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_set_logging (fs, argv[7], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_logging(fs, argv[7], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        opcode = atoi (argv[3]);
-        opcode = get_fallocate_flag (opcode);
-        if (opcode < 0) {
-                fprintf (stderr, "get_fallocate_flag: invalid flag \n");
-                goto out;
-        }
+    opcode = atoi(argv[3]);
+    opcode = get_fallocate_flag(opcode);
+    if (opcode < 0) {
+        fprintf(stderr, "get_fallocate_flag: invalid flag \n");
+        goto out;
+    }
 
-        offset = atoi (argv[4]);
-        len    = atoi (argv[5]);
+    offset = atoi(argv[4]);
+    len = atoi(argv[5]);
 
-        fd = glfs_open (fs, argv[6], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[6], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        ret = glfs_fallocate (fd, opcode, offset, len);
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_fallocate: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_fallocate(fd, opcode, offset, len);
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_fallocate: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/bugs/write-behind/bug-1058663.c b/tests/bugs/write-behind/bug-1058663.c
index 5e522e98048..aedf97d7487 100644
--- a/tests/bugs/write-behind/bug-1058663.c
+++ b/tests/bugs/write-behind/bug-1058663.c
@@ -19,101 +19,105 @@ static int sigbus_received;
 /* test for truncate()/seek()/write()/mmap()
  * There should ne no SIGBUS triggered.
  */
-void seek_write(char *filename)
+void
+seek_write(char *filename)
 {
-	int fd;
-	uint8_t *map;
-	int i;
-
-	fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
-	lseek(fd, FILE_SIZE - 1, SEEK_SET);
-	write(fd, "\xff", 1);
-
-	map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);
-	for (i = 0; i < (FILE_SIZE - 1); i++) {
-		if (map[i] != 0) /* should never be true */
-			abort();
-	}
-	munmap(map, FILE_SIZE);
-
-	close(fd);
+    int fd;
+    uint8_t *map;
+    int i;
+
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    lseek(fd, FILE_SIZE - 1, SEEK_SET);
+    write(fd, "\xff", 1);
+
+    map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);
+    for (i = 0; i < (FILE_SIZE - 1); i++) {
+        if (map[i] != 0) /* should never be true */
+            abort();
+    }
+    munmap(map, FILE_SIZE);
+
+    close(fd);
 }
 
-int read_after_eof(char *filename)
+int
+read_after_eof(char *filename)
 {
-	int ret = 0;
-	int fd;
-	char *data;
-	uint8_t *map;
-
-	fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
-	lseek(fd, FILE_SIZE - 1, SEEK_SET);
-	write(fd, "\xff", 1);
-
-	/* trigger verify that reading after EOF fails */
-	ret = read(fd, data, FILE_SIZE / 2);
-	if (ret != 0)
-		return 1;
-
-	/* map an area of 1 byte after FILE_SIZE */
-	map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE);
-	/* map[0] is an access after EOF, it should trigger SIGBUS */
-	if (map[0] != 0)
-		/* it is expected that we exit before we get here */
-		if (!sigbus_received)
-			return 1;
-	munmap(map, FILE_SIZE);
-
-	close(fd);
-
-	return ret;
+    int ret = 0;
+    int fd;
+    char *data;
+    uint8_t *map;
+
+    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
+    lseek(fd, FILE_SIZE - 1, SEEK_SET);
+    write(fd, "\xff", 1);
+
+    /* trigger verify that reading after EOF fails */
+    ret = read(fd, data, FILE_SIZE / 2);
+    if (ret != 0)
+        return 1;
+
+    /* map an area of 1 byte after FILE_SIZE */
+    map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE);
+    /* map[0] is an access after EOF, it should trigger SIGBUS */
+    if (map[0] != 0)
+        /* it is expected that we exit before we get here */
+        if (!sigbus_received)
+            return 1;
+    munmap(map, FILE_SIZE);
+
+    close(fd);
+
+    return ret;
 }
 
 /* signal handler for SIGBUS */
-void catch_sigbus(int signum)
+void
+catch_sigbus(int signum)
 {
-	switch (signum) {
+    switch (signum) {
 #ifdef __NetBSD__
-	/* Depending on architecture, we can get SIGSEGV */
-	case SIGSEGV: /* FALLTHROUGH */
+        /* Depending on architecture, we can get SIGSEGV */
+        case SIGSEGV: /* FALLTHROUGH */
 #endif
-	case SIGBUS:
-		sigbus_received++;
-		if (!expect_sigbus)
-			exit(EXIT_FAILURE);
-		if (sigbus_received >= MAX_SIGBUS)
-			exit(EXIT_SUCCESS);
-		break;
-	default:
-		printf("Unexpected signal received: %d\n", signum);
-	}
+        case SIGBUS:
+            sigbus_received++;
+            if (!expect_sigbus)
+                exit(EXIT_FAILURE);
+            if (sigbus_received >= MAX_SIGBUS)
+                exit(EXIT_SUCCESS);
+            break;
+        default:
+            printf("Unexpected signal received: %d\n", signum);
+    }
 }
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-	int i = 0;
+    int i = 0;
 
-	if (argc == 1) {
-		printf("Usage: %s <filename>\n", argv[0]);
-		return EXIT_FAILURE;
-	}
+    if (argc == 1) {
+        printf("Usage: %s <filename>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
 #ifdef __NetBSD__
-	/* Depending on architecture, we can get SIGSEGV */
-	signal(SIGSEGV, catch_sigbus);
+    /* Depending on architecture, we can get SIGSEGV */
+    signal(SIGSEGV, catch_sigbus);
 #endif
-	signal(SIGBUS, catch_sigbus);
+    signal(SIGBUS, catch_sigbus);
 
-	/* the next test should not trigger SIGBUS */
-	expect_sigbus = 0;
-	for (i = 0; i < RUN_LOOP; i++) {
-		seek_write(argv[1]);
-	}
+    /* the next test should not trigger SIGBUS */
+    expect_sigbus = 0;
+    for (i = 0; i < RUN_LOOP; i++) {
+        seek_write(argv[1]);
+    }
 
-	/* the next test should trigger SIGBUS */
-	expect_sigbus = 1;
-	if (read_after_eof(argv[1]))
-		return EXIT_FAILURE;
+    /* the next test should trigger SIGBUS */
+    expect_sigbus = 1;
+    if (read_after_eof(argv[1]))
+        return EXIT_FAILURE;
 
-	return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }
diff --git a/tests/bugs/write-behind/bug-1279730.c b/tests/bugs/write-behind/bug-1279730.c
index 535d289c582..706ae67b102 100644
--- a/tests/bugs/write-behind/bug-1279730.c
+++ b/tests/bugs/write-behind/bug-1279730.c
@@ -8,124 +8,142 @@
 #include <assert.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int          fd                = -1, ret = -1, len = 0;
-        char        *path              = NULL, buf[128] = {0, }, *cmd = NULL;
-        struct stat  stbuf             = {0, };
-        int          write_to_child[2] = {0, }, write_to_parent[2] = {0, };
+    int fd = -1, ret = -1, len = 0;
+    char *path = NULL,
+         buf[128] =
+             {
+                 0,
+             },
+         *cmd = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    int write_to_child[2] =
+        {
+            0,
+        },
+        write_to_parent[2] = {
+            0,
+        };
+
+    path = argv[1];
+    cmd = argv[2];
+
+    assert(argc == 3);
+
+    ret = pipe(write_to_child);
+    if (ret < 0) {
+        fprintf(stderr,
+                "creation of write-to-child pipe failed "
+                "(%s)\n",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = pipe(write_to_parent);
+    if (ret < 0) {
+        fprintf(stderr,
+                "creation of write-to-parent pipe failed "
+                "(%s)\n",
+                strerror(errno));
+        goto out;
+    }
+
+    ret = fork();
+    switch (ret) {
+        case 0:
+            close(write_to_child[1]);
+            close(write_to_parent[0]);
+
+            /* child, wait for instructions to execute command */
+            ret = read(write_to_child[0], buf, 128);
+            if (ret < 0) {
+                fprintf(stderr, "child: read on pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
 
-        path = argv[1];
-        cmd = argv[2];
+            system(cmd);
+
+            ret = write(write_to_parent[1], "1", 2);
+            if (ret < 0) {
+                fprintf(stderr, "child: write to pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
+            break;
 
-        assert (argc == 3);
+        case -1:
+            fprintf(stderr, "fork failed (%s)\n", strerror(errno));
+            goto out;
+
+        default:
+            close(write_to_parent[1]);
+            close(write_to_child[0]);
 
-        ret = pipe (write_to_child);
-        if (ret < 0) {
-                fprintf (stderr, "creation of write-to-child pipe failed "
-                         "(%s)\n", strerror (errno));
+            fd = open(path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU);
+            if (fd < 0) {
+                fprintf(stderr, "open failed (%s)\n", strerror(errno));
                 goto out;
-        }
+            }
+
+            len = strlen("test-content") + 1;
+            ret = write(fd, "test-content", len);
+
+            if (ret < len) {
+                fprintf(stderr, "write failed %d (%s)\n", ret, strerror(errno));
+            }
+
+            ret = pread(fd, buf, 128, 0);
+            if ((ret == len) && (strcmp(buf, "test-content") == 0)) {
+                fprintf(stderr,
+                        "read should've failed as previous "
+                        "write would've failed with EDQUOT, but its "
+                        "successful");
+                ret = -1;
+                goto out;
+            }
 
-        ret = pipe (write_to_parent);
-        if (ret < 0) {
-                fprintf (stderr, "creation of write-to-parent pipe failed "
-                         "(%s)\n", strerror (errno));
+            ret = write(write_to_child[1], "1", 2);
+            if (ret < 0) {
+                fprintf(stderr, "parent: write to pipe failed (%s)\n",
+                        strerror(errno));
                 goto out;
-        }
+            }
 
-        ret = fork ();
-        switch (ret) {
-        case 0:
-                close (write_to_child[1]);
-                close (write_to_parent[0]);
-
-                /* child, wait for instructions to execute command */
-                ret = read (write_to_child[0], buf, 128);
-                if (ret < 0) {
-                        fprintf (stderr, "child: read on pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                system (cmd);
-
-                ret = write (write_to_parent[1], "1", 2);
-                if (ret < 0) {
-                        fprintf (stderr, "child: write to pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-                break;
+            ret = read(write_to_parent[0], buf, 128);
+            if (ret < 0) {
+                fprintf(stderr, "parent: read from pipe failed (%s)\n",
+                        strerror(errno));
+                goto out;
+            }
+
+            /* this will force a sync on cached-write and now that quota
+               limit is increased, sync will be successful. ignore return
+               value as fstat would fail with EDQUOT (picked up from
+               cached-write because of previous sync failure.
+            */
+            fstat(fd, &stbuf);
+
+            ret = pread(fd, buf, 128, 0);
+            if (ret != len) {
+                fprintf(stderr,
+                        "post cmd read failed %d (data:%s) "
+                        "(error:%s)\n",
+                        ret, buf, strerror(errno));
+                goto out;
+            }
 
-        case -1:
-                fprintf (stderr, "fork failed (%s)\n", strerror (errno));
+            if (strcmp(buf, "test-content")) {
+                fprintf(stderr, "wrong data (%s)\n", buf);
                 goto out;
+            }
+    }
 
-        default:
-                close (write_to_parent[1]);
-                close (write_to_child[0]);
-
-                fd = open (path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU);
-                if (fd < 0) {
-                        fprintf (stderr, "open failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                len = strlen ("test-content") + 1;
-                ret = write (fd, "test-content", len);
-
-                if (ret < len) {
-                        fprintf (stderr, "write failed %d (%s)\n", ret,
-                                 strerror (errno));
-                }
-
-                ret = pread (fd, buf, 128, 0);
-                if ((ret == len) && (strcmp (buf, "test-content") == 0)) {
-                        fprintf (stderr, "read should've failed as previous "
-                                 "write would've failed with EDQUOT, but its "
-                                 "successful");
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = write (write_to_child[1], "1", 2);
-                if (ret < 0) {
-                        fprintf (stderr, "parent: write to pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                ret = read (write_to_parent[0], buf, 128);
-                if (ret < 0) {
-                        fprintf (stderr, "parent: read from pipe failed (%s)\n",
-                                 strerror (errno));
-                        goto out;
-                }
-
-                /* this will force a sync on cached-write and now that quota
-                   limit is increased, sync will be successful. ignore return
-                   value as fstat would fail with EDQUOT (picked up from
-                   cached-write because of previous sync failure.
-                */
-                fstat (fd, &stbuf);
-
-                ret = pread (fd, buf, 128, 0);
-                if (ret != len) {
-                        fprintf (stderr, "post cmd read failed %d (data:%s) "
-                                 "(error:%s)\n", ret, buf, strerror (errno));
-                        goto out;
-                }
-
-                if (strcmp (buf, "test-content")) {
-                        fprintf (stderr, "wrong data (%s)\n", buf);
-                        goto out;
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/tests/encryption/frag.c b/tests/encryption/frag.c
index 86da037c607..7b4510f6a4d 100644
--- a/tests/encryption/frag.c
+++ b/tests/encryption/frag.c
@@ -20,300 +20,296 @@
 #define MAX_NUM_OPS (1 << 20)
 #define MAX_FILE_SIZE (1 << 30)
 
-typedef enum {
-	READ_OP,
-	WRITE_OP,
-	TRUNC_OP,
-	LAST_OP
-} frag_op;
+typedef enum { READ_OP, WRITE_OP, TRUNC_OP, LAST_OP } frag_op;
 
 struct frag_ctx {
-	int test_fd;
-	int good_fd;
-	char *test_buf;
-	char *good_buf;
-	char *content;
-	int max_file_size;
+    int test_fd;
+    int good_fd;
+    char *test_buf;
+    char *good_buf;
+    char *content;
+    int max_file_size;
 };
 
 typedef int (*frag_op_t)(struct frag_ctx *ctx, off_t offset, size_t count);
 
-static int doread(int fd, off_t offset, size_t count,
-		  char *buf, int max_file_size)
+static int
+doread(int fd, off_t offset, size_t count, char *buf, int max_file_size)
 {
-	int ret = 0;
-	int was_read = 0;
+    int ret = 0;
+    int was_read = 0;
 
-	if (lseek(fd, offset, SEEK_SET) == -1) {
-		perror("lseek failed");
-                return -1;
-	}
-	while (count) {
-		ret = read(fd, buf + offset + was_read, count);
-		if (ret < 0)
-			return -1;
-		if (ret == 0)
-			break;
-		if (ret > count) {
-			fprintf(stderr, "READ: read more than asked\n");
-			return -1;
-		}
-		count -= ret;
-		was_read += ret;
-	}
-	return ret;
+    if (lseek(fd, offset, SEEK_SET) == -1) {
+        perror("lseek failed");
+        return -1;
+    }
+    while (count) {
+        ret = read(fd, buf + offset + was_read, count);
+        if (ret < 0)
+            return -1;
+        if (ret == 0)
+            break;
+        if (ret > count) {
+            fprintf(stderr, "READ: read more than asked\n");
+            return -1;
+        }
+        count -= ret;
+        was_read += ret;
+    }
+    return ret;
 }
 
-static int dowrite(int fd, off_t offset, size_t count, char *buf)
+static int
+dowrite(int fd, off_t offset, size_t count, char *buf)
 {
-	int ret;
+    int ret;
 
-	ret = lseek(fd, offset, SEEK_SET);
-	if (ret == -1)
-                return ret;
-	return write(fd, buf, count);
+    ret = lseek(fd, offset, SEEK_SET);
+    if (ret == -1)
+        return ret;
+    return write(fd, buf, count);
 }
 
-static int dotrunc(int fd, off_t offset)
+static int
+dotrunc(int fd, off_t offset)
 {
-	int ret;
+    int ret;
 
-	ret = ftruncate(fd, offset);
-	if (ret == -1)
-		perror("truncate failed");
-	return ret;
+    ret = ftruncate(fd, offset);
+    if (ret == -1)
+        perror("truncate failed");
+    return ret;
 }
 
-static int prepare_file(char *filename, int *fd, char **buf, int max_file_size)
+static int
+prepare_file(char *filename, int *fd, char **buf, int max_file_size)
 {
-	int ret;
+    int ret;
 
-	*buf = malloc(max_file_size);
-	if (*buf == NULL) {
-		perror("malloc failed");
-	        return -1;
-	}
-	*fd = open(filename, O_CREAT | O_RDWR, S_IRWXU);
-	if (*fd == -1) {
-		perror("open failed");
-		free(*buf);
-		*buf = NULL;
-		return -1;
-	}
-	return 0;
+    *buf = malloc(max_file_size);
+    if (*buf == NULL) {
+        perror("malloc failed");
+        return -1;
+    }
+    *fd = open(filename, O_CREAT | O_RDWR, S_IRWXU);
+    if (*fd == -1) {
+        perror("open failed");
+        free(*buf);
+        *buf = NULL;
+        return -1;
+    }
+    return 0;
 }
 
 /*
  * @offset, @count: random values from [0, max_file_size - 1]
  */
-static int frag_write(struct frag_ctx *ctx, off_t offset, size_t count)
+static int
+frag_write(struct frag_ctx *ctx, off_t offset, size_t count)
 {
-	int ret;
-	struct stat test_stbuf;
-	struct stat good_stbuf;
+    int ret;
+    struct stat test_stbuf;
+    struct stat good_stbuf;
 
-	if (offset + count > ctx->max_file_size)
-		offset = offset / 2;
-	if (offset + count > ctx->max_file_size)
-		count = count / 2;
+    if (offset + count > ctx->max_file_size)
+        offset = offset / 2;
+    if (offset + count > ctx->max_file_size)
+        count = count / 2;
 
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "WRITE: fstat of test file failed\n");
-		return -1;
-	}
-	if (offset > test_stbuf.st_size)
-		printf("writing hole\n");
+    if (fstat(ctx->test_fd, &test_stbuf)) {
+        fprintf(stderr, "WRITE: fstat of test file failed\n");
+        return -1;
+    }
+    if (offset > test_stbuf.st_size)
+        printf("writing hole\n");
 
-	ret = dowrite(ctx->test_fd, offset, count, ctx->content);
-	if (ret < 0 || ret != count){
-		fprintf(stderr, "WRITE: failed to write test file\n");
-		return -1;
-	}
-	ret = dowrite(ctx->good_fd, offset, count, ctx->content);
-	if (ret < 0 || ret != count) {
-		fprintf(stderr, "WRITE: failed to write test file\n");
-		return -1;
-	}	
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-                fprintf(stderr, "WRITE: fstat of test file failed\n");
-		return -1;
-	}
-	if (fstat(ctx->good_fd, &good_stbuf)) {
-                fprintf(stderr, "WRITE: fstat of good file failed\n");
-		return -1;
-	}
-	if (test_stbuf.st_size != good_stbuf.st_size) {
-		fprintf(stderr,
-			"READ: Bad file size %d (expected %d)\n",
-			(int)test_stbuf.st_size,
-			(int)good_stbuf.st_size);
-		return -1;
-	}
-	return 0;
+    ret = dowrite(ctx->test_fd, offset, count, ctx->content);
+    if (ret < 0 || ret != count) {
+        fprintf(stderr, "WRITE: failed to write test file\n");
+        return -1;
+    }
+    ret = dowrite(ctx->good_fd, offset, count, ctx->content);
+    if (ret < 0 || ret != count) {
+        fprintf(stderr, "WRITE: failed to write test file\n");
+        return -1;
+    }
+    if (fstat(ctx->test_fd, &test_stbuf)) {
+        fprintf(stderr, "WRITE: fstat of test file failed\n");
+        return -1;
+    }
+    if (fstat(ctx->good_fd, &good_stbuf)) {
+        fprintf(stderr, "WRITE: fstat of good file failed\n");
+        return -1;
+    }
+    if (test_stbuf.st_size != good_stbuf.st_size) {
+        fprintf(stderr, "READ: Bad file size %d (expected %d)\n",
+                (int)test_stbuf.st_size, (int)good_stbuf.st_size);
+        return -1;
+    }
+    return 0;
 }
 
 /*
  * @offset, @count: random values from [0, max_file_size - 1]
  */
-static int frag_read(struct frag_ctx *ctx, off_t offset, size_t count)
+static int
+frag_read(struct frag_ctx *ctx, off_t offset, size_t count)
 {
-	ssize_t test_ret;
-	ssize_t good_ret;
+    ssize_t test_ret;
+    ssize_t good_ret;
 
-	test_ret = doread(ctx->test_fd,
-			  offset, count, ctx->test_buf, ctx->max_file_size);
-	if (test_ret < 0) {
-		fprintf(stderr, "READ: failed to read test file\n");
-		return -1;
-	}
-	good_ret = doread(ctx->good_fd,
-			  offset, count, ctx->good_buf, ctx->max_file_size);
-	if (good_ret < 0) {
-		fprintf(stderr, "READ: failed to read good file\n");
-		return -1;
-	}
-	if (test_ret != good_ret) {
-		fprintf(stderr,
-			"READ: Bad return value %d (expected %d\n)",
-			test_ret, good_ret);
-		return -1;
-	}
-	if (memcmp(ctx->test_buf + offset, ctx->good_buf + offset, good_ret)) {
-		fprintf(stderr, "READ: bad data\n");
-		return -1;
-	}
-	return 0;
+    test_ret = doread(ctx->test_fd, offset, count, ctx->test_buf,
+                      ctx->max_file_size);
+    if (test_ret < 0) {
+        fprintf(stderr, "READ: failed to read test file\n");
+        return -1;
+    }
+    good_ret = doread(ctx->good_fd, offset, count, ctx->good_buf,
+                      ctx->max_file_size);
+    if (good_ret < 0) {
+        fprintf(stderr, "READ: failed to read good file\n");
+        return -1;
+    }
+    if (test_ret != good_ret) {
+        fprintf(stderr, "READ: Bad return value %d (expected %d\n)", test_ret,
+                good_ret);
+        return -1;
+    }
+    if (memcmp(ctx->test_buf + offset, ctx->good_buf + offset, good_ret)) {
+        fprintf(stderr, "READ: bad data\n");
+        return -1;
+    }
+    return 0;
 }
 
 /*
  * @offset: random value from [0, max_file_size - 1]
  */
-static int frag_truncate(struct frag_ctx *ctx,
-			 off_t offset, __attribute__((unused))size_t count)
+static int
+frag_truncate(struct frag_ctx *ctx, off_t offset,
+              __attribute__((unused)) size_t count)
 {
-	int ret;
-	struct stat test_stbuf;
-	struct stat good_stbuf;
+    int ret;
+    struct stat test_stbuf;
+    struct stat good_stbuf;
+
+    if (fstat(ctx->test_fd, &test_stbuf)) {
+        fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
+        return -1;
+    }
+    if (offset > test_stbuf.st_size)
+        printf("expanding truncate to %d\n", offset);
+    else if (offset < test_stbuf.st_size)
+        printf("shrinking truncate to %d\n", offset);
+    else
+        printf("trivial truncate\n");
 
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
-		return -1;
-	}
-	if (offset > test_stbuf.st_size)
-		printf("expanding truncate to %d\n", offset);
-	else if (offset < test_stbuf.st_size)
-		printf("shrinking truncate to %d\n", offset);
-	else
-		printf("trivial truncate\n");
-	
-	ret = dotrunc(ctx->test_fd, offset);
-	if (ret == -1) {
-		fprintf(stderr, "TRUNCATE: failed for test file\n");
-		return -1;
-	}
-	ret = dotrunc(ctx->good_fd, offset);
-	if (ret == -1) {
-		fprintf(stderr, "TRUNCATE: failed for good file\n");
-		return -1;
-	}
-	if (fstat(ctx->test_fd, &test_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
-		return -1;
-	}
-	if (fstat(ctx->good_fd, &good_stbuf)) {
-		fprintf(stderr, "TRUNCATE: fstat of good file failed\n");
-		return -1;
-	}
-	if (test_stbuf.st_size != good_stbuf.st_size) {
-		fprintf(stderr,
-			"TRUNCATE: bad test file size %d (expected %d)\n",
-			test_stbuf.st_size,
-			good_stbuf.st_size);
-		return -1;
-	}
-	return 0;
+    ret = dotrunc(ctx->test_fd, offset);
+    if (ret == -1) {
+        fprintf(stderr, "TRUNCATE: failed for test file\n");
+        return -1;
+    }
+    ret = dotrunc(ctx->good_fd, offset);
+    if (ret == -1) {
+        fprintf(stderr, "TRUNCATE: failed for good file\n");
+        return -1;
+    }
+    if (fstat(ctx->test_fd, &test_stbuf)) {
+        fprintf(stderr, "TRUNCATE: fstat of test file failed\n");
+        return -1;
+    }
+    if (fstat(ctx->good_fd, &good_stbuf)) {
+        fprintf(stderr, "TRUNCATE: fstat of good file failed\n");
+        return -1;
+    }
+    if (test_stbuf.st_size != good_stbuf.st_size) {
+        fprintf(stderr, "TRUNCATE: bad test file size %d (expected %d)\n",
+                test_stbuf.st_size, good_stbuf.st_size);
+        return -1;
+    }
+    return 0;
 }
 
-frag_op_t frag_ops[LAST_OP] = {
-	[READ_OP]  = frag_read,
-	[WRITE_OP] = frag_write,
-	[TRUNC_OP] = frag_truncate
-};
+frag_op_t frag_ops[LAST_OP] = {[READ_OP] = frag_read,
+                               [WRITE_OP] = frag_write,
+                               [TRUNC_OP] = frag_truncate};
 
-static void put_ctx(struct frag_ctx *ctx)
+static void
+put_ctx(struct frag_ctx *ctx)
 {
-	if (ctx->test_buf)
-		free(ctx->test_buf);
-	if (ctx->good_buf)
-		free(ctx->good_buf);
-	if (ctx->content)
-		free(ctx->content);
+    if (ctx->test_buf)
+        free(ctx->test_buf);
+    if (ctx->good_buf)
+        free(ctx->good_buf);
+    if (ctx->content)
+        free(ctx->content);
 }
 
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-	int i;
-	int ret = 0;
-	struct frag_ctx ctx;
-	char *test_filename = NULL;
-	char *good_filename = NULL;
-	int num_ops;
-	int max_file_size;
+    int i;
+    int ret = 0;
+    struct frag_ctx ctx;
+    char *test_filename = NULL;
+    char *good_filename = NULL;
+    int num_ops;
+    int max_file_size;
 
-	memset(&ctx, 0, sizeof(ctx));
-	if (argc != 5) {
-                fprintf(stderr,
-			"usage: %s <test-file-name> <good-file-name> <max-file-size> <number-of-operations>\n",
-			argv[0]);
-		ret = -1;
-                goto exit;
-        }
-	test_filename = argv[1];
-	good_filename = argv[2];
-	max_file_size = atoi(argv[3]);
-	if (max_file_size > MAX_FILE_SIZE)
-		max_file_size = MAX_FILE_SIZE;
-	num_ops = atoi(argv[4]);
-	if (num_ops > MAX_NUM_OPS)
-		num_ops = MAX_NUM_OPS;
+    memset(&ctx, 0, sizeof(ctx));
+    if (argc != 5) {
+        fprintf(stderr,
+                "usage: %s <test-file-name> <good-file-name> <max-file-size> "
+                "<number-of-operations>\n",
+                argv[0]);
+        ret = -1;
+        goto exit;
+    }
+    test_filename = argv[1];
+    good_filename = argv[2];
+    max_file_size = atoi(argv[3]);
+    if (max_file_size > MAX_FILE_SIZE)
+        max_file_size = MAX_FILE_SIZE;
+    num_ops = atoi(argv[4]);
+    if (num_ops > MAX_NUM_OPS)
+        num_ops = MAX_NUM_OPS;
 
-	ret = prepare_file(test_filename,
-			   &ctx.test_fd, &ctx.test_buf, max_file_size);
-	if (ret)
-		goto exit;
-	ret = prepare_file(good_filename,
-			   &ctx.good_fd, &ctx.good_buf, max_file_size);
-	if (ret) {
-		if (close(ctx.test_fd) == -1)
-			perror("close test_buf failed");
-		goto exit;
-	}
-	ctx.content = malloc(max_file_size);
-	if (!ctx.content) {
-		perror("malloc failed");
-		goto close;
-	}
-	ctx.max_file_size = max_file_size;
-	for (i = 0; i < max_file_size; i++)
-                ctx.content[i] = random() % 256;
+    ret = prepare_file(test_filename, &ctx.test_fd, &ctx.test_buf,
+                       max_file_size);
+    if (ret)
+        goto exit;
+    ret = prepare_file(good_filename, &ctx.good_fd, &ctx.good_buf,
+                       max_file_size);
+    if (ret) {
+        if (close(ctx.test_fd) == -1)
+            perror("close test_buf failed");
+        goto exit;
+    }
+    ctx.content = malloc(max_file_size);
+    if (!ctx.content) {
+        perror("malloc failed");
+        goto close;
+    }
+    ctx.max_file_size = max_file_size;
+    for (i = 0; i < max_file_size; i++)
+        ctx.content[i] = random() % 256;
 
-	for (i = 0; i < num_ops; i++) {
-		ret = frag_ops[random() % LAST_OP](&ctx,
-					random() % max_file_size, /* offset */
-					random() % max_file_size  /* count */);
-		if (ret)
-			break;
-	}
- close:
-	if (close(ctx.test_fd) == -1)
-		perror("close test_fd failed");
-	if (close(ctx.good_fd) == -1)
-		perror("close good_fd failed");	
- exit:
-	put_ctx(&ctx);
-	if (ret)
-		exit(1);
-	exit(0);
+    for (i = 0; i < num_ops; i++) {
+        ret = frag_ops[random() % LAST_OP](
+            &ctx, random() % max_file_size, /* offset */
+            random() % max_file_size /* count */);
+        if (ret)
+            break;
+    }
+close:
+    if (close(ctx.test_fd) == -1)
+        perror("close test_fd failed");
+    if (close(ctx.good_fd) == -1)
+        perror("close good_fd failed");
+exit:
+    put_ctx(&ctx);
+    if (ret)
+        exit(1);
+    exit(0);
 }
 
 /*
diff --git a/tests/features/glfs-lease.c b/tests/features/glfs-lease.c
index 535b3019a8c..f781f46c4ca 100644
--- a/tests/features/glfs-lease.c
+++ b/tests/features/glfs-lease.c
@@ -8,16 +8,20 @@
 #include <sys/stat.h>
 
 /* Few rules:
- * 1. A client may have multiple lease keys, but a lease key cannot be shared by multiple clients.
- * 2. Lease key can be set before open, or in glfs_lease request. A lease key set like this is
- *    valid for the lifetime of the fd, i.e. a fd cannot have multiple lease key. But a lease key
- *    can be shared across multiple fds.
+ * 1. A client may have multiple lease keys, but a lease key cannot be shared by
+ * multiple clients.
+ * 2. Lease key can be set before open, or in glfs_lease request. A lease key
+ * set like this is valid for the lifetime of the fd, i.e. a fd cannot have
+ * multiple lease key. But a lease key can be shared across multiple fds.
  */
 glfs_t *client1 = NULL, *client2 = NULL, *client3 = NULL, *client4 = NULL;
 glfs_fd_t *fd1 = NULL, *fd2 = NULL, *fd3 = NULL, *fd4 = NULL;
 FILE *log_file = NULL;
-char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1", lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
-char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {0,};
+char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1",
+     lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2";
+char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {
+                                                  0,
+};
 char *volname = NULL, *glfs_log_file = NULL;
 
 #define MAX_CLIENTS 4
@@ -28,668 +32,686 @@ char *volname = NULL, *glfs_log_file = NULL;
 #define NONE 0
 
 static void
-recall_cbk (struct glfs_lease lease, void *data);
+recall_cbk(struct glfs_lease lease, void *data);
 
 static int
-set_read_lease (glfs_fd_t *fd, char ld[])
+set_read_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, fd);
-        if (ret < 0) {
-                fprintf (log_file, "\n    RD_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Took RD_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, fd);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RD_LEASE");
+    return ret;
 }
 
 static int
-set_write_lease (glfs_fd_t *fd, char ld[])
+set_write_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RW_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    RW_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Took RW_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    RW_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Took RW_LEASE");
+    return ret;
 }
 
 static int
-get_lease (glfs_fd_t *fd, char ld[])
+get_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_GET_LEASE;
-        lease.lease_type = -1;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    GET_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        if (lease.lease_type == GLFS_RD_LEASE)
-                fprintf (log_file, "\n    Esisting Lease: RD_LEASE");
-        else if (lease.lease_type == GLFS_RW_LEASE)
-                fprintf (log_file, "\n    Esisting Lease: RW_LEASE");
-        else if (lease.lease_type == 3)
-                fprintf (log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
-        else if (lease.lease_type == 0)
-                fprintf (log_file, "\n    Esisting Lease: NONE");
-        else
-                fprintf (log_file, "\n    Existing lease type:%d", lease.lease_type);
-        return lease.lease_type;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_GET_LEASE;
+    lease.lease_type = -1;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    GET_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    if (lease.lease_type == GLFS_RD_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE");
+    else if (lease.lease_type == GLFS_RW_LEASE)
+        fprintf(log_file, "\n    Esisting Lease: RW_LEASE");
+    else if (lease.lease_type == 3)
+        fprintf(log_file, "\n    Esisting Lease: RD_LEASE|RW_LEASE");
+    else if (lease.lease_type == 0)
+        fprintf(log_file, "\n    Esisting Lease: NONE");
+    else
+        fprintf(log_file, "\n    Existing lease type:%d", lease.lease_type);
+    return lease.lease_type;
 }
 
 static int
-unlk_write_lease (glfs_fd_t *fd, char ld[])
+unlk_write_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_UNLK_LEASE;
-        lease.lease_type = GLFS_RW_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Unlocked RW_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RW_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RW_LESAE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RW_LEASE");
+    return ret;
 }
 
 static int
-unlk_read_lease (glfs_fd_t *fd, char ld[])
+unlk_read_lease(glfs_fd_t *fd, char ld[])
 {
-        struct glfs_lease lease = {0, };
-        int ret = 0;
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_UNLK_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
-
-        ret = glfs_lease (fd, &lease, &recall_cbk, NULL);
-        if (ret < 0) {
-                fprintf (log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)",
-                                ret, strerror (errno));
-                return -1;
-        }
-        fprintf (log_file, "\n    Unlocked RD_LEASE");
-        return ret;
+    struct glfs_lease lease = {
+        0,
+    };
+    int ret = 0;
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_UNLK_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE);
+
+    ret = glfs_lease(fd, &lease, &recall_cbk, NULL);
+    if (ret < 0) {
+        fprintf(log_file, "\n    Unlock RD_LEASE failed with ret: %d (%s)", ret,
+                strerror(errno));
+        return -1;
+    }
+    fprintf(log_file, "\n    Unlocked RD_LEASE");
+    return ret;
 }
 
 glfs_t *
 setup_new_client(char *volname, char *log_fileile)
 {
-        int ret = 0;
-        glfs_t *fs = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (log_file, "\nglfs_new: returned NULL (%s)\n",
-                                 strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_set_logging (fs, log_fileile, 7);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_set_logging failed with ret: %d (%s)\n",
-                                 ret, strerror (errno));
-                goto error;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                fprintf (log_file, "\nglfs_init failed with ret: %d (%s)\n",
-                                  ret, strerror (errno));
-                goto error;
-        }
-        return fs;
+    int ret = 0;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(log_file, "\nglfs_new: returned NULL (%s)\n", strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_set_logging(fs, log_fileile, 7);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        fprintf(log_file, "\nglfs_init failed with ret: %d (%s)\n", ret,
+                strerror(errno));
+        goto error;
+    }
+    return fs;
 error:
-        return NULL;
+    return NULL;
 }
 
-#define OPEN(client, flags, fd, lease_id)                                                   \
-do {                                                                                        \
-        int ret_val = 0;                                                                    \
-        ret_val = glfs_setfsleaseid (lease_id);                                          \
-        if (ret_val) {                                                                      \
-                fprintf (log_file, "\nglfs_setfsleaseid failed with ret: %d (%s)\n",        \
-                                ret, strerror (errno));                                     \
-                return -1;                                                                  \
-        }                                                                                   \
-        fd = glfs_open (client, TEST_FILE, flags);                                          \
-        if (fd == NULL) {                                                                   \
-                fprintf (log_file, "\nglfs_open failed with ret: %d (%s)\n",                \
-                                ret, strerror (errno));                                     \
-                return -1;                                                                  \
-        }                                                                                   \
-} while (0)                                                                                 \
-
-#define VERIFY_RESULT(test_case, ret, value)                                                \
-do {                                                                                        \
-        if (ret != value) {                                                                 \
-                fprintf (log_file, "\n    Testcase %d failed, ret = %d, value=%d\n", test_case, ret, value); \
-                goto error; /*test unsuccessful*/                                           \
-        }                                                                                   \
-        fprintf (log_file, "\n    Testcase %d Succeeded\n", test_case);                       \
-} while (0)                                                                                 \
+#define OPEN(client, flags, fd, lease_id)                                      \
+    do {                                                                       \
+        int ret_val = 0;                                                       \
+        ret_val = glfs_setfsleaseid(lease_id);                                 \
+        if (ret_val) {                                                         \
+            fprintf(log_file,                                                  \
+                    "\nglfs_setfsleaseid failed with ret: %d (%s)\n", ret,     \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+        fd = glfs_open(client, TEST_FILE, flags);                              \
+        if (fd == NULL) {                                                      \
+            fprintf(log_file, "\nglfs_open failed with ret: %d (%s)\n", ret,   \
+                    strerror(errno));                                          \
+            return -1;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define VERIFY_RESULT(test_case, ret, value)                                   \
+    do {                                                                       \
+        if (ret != value) {                                                    \
+            fprintf(log_file,                                                  \
+                    "\n    Testcase %d failed, ret = %d, value=%d\n",          \
+                    test_case, ret, value);                                    \
+            goto error; /*test unsuccessful*/                                  \
+        }                                                                      \
+        fprintf(log_file, "\n    Testcase %d Succeeded\n", test_case);         \
+    } while (0)
 
 static void
-recall_cbk (struct glfs_lease lease, void *data)
+recall_cbk(struct glfs_lease lease, void *data)
 {
-        int ret = -1;
-        char ld[GLFS_LEASE_ID_SIZE] = "";
+    int ret = -1;
+    char ld[GLFS_LEASE_ID_SIZE] = "";
 
-        fprintf (log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
-        memcpy (ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
-        ret = unlk_write_lease ((glfs_fd_t *)data, ld);
-        VERIFY_RESULT (500, ret, SHUD_PASS);
+    fprintf(log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id);
+    memcpy(ld, lease.lease_id, GLFS_LEASE_ID_SIZE);
+    ret = unlk_write_lease((glfs_fd_t *)data, ld);
+    VERIFY_RESULT(500, ret, SHUD_PASS);
 error:
-        return;
+    return;
 }
 
-
 static int
-testcase1_rd_lease ()
+testcase1_rd_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-	fprintf (log_file, "\n Basic test case for Read lease:");
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL);
+    fprintf(log_file, "\n Basic test case for Read lease:");
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_FAIL);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_FAIL);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, SHUD_FAIL);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_FAIL);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase2_wr_lease ()
+testcase2_wr_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for Write lease:");
-        /* Open fd on client 1 in WRonly mode */
-        OPEN (client1, O_WRONLY, fd1, lid1);
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL);
+    fprintf(log_file, "\n Basic test case for Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_WRONLY, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_FAIL);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_FAIL);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, GLFS_RW_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, GLFS_RW_LEASE);
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, SHUD_FAIL);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, SHUD_FAIL);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase3_rd_wr_lease ()
+testcase3_rd_wr_lease()
 {
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for Read Write lease:");
-        /* Open fd on client 1 in WRonly mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    fprintf(log_file, "\n Basic test case for Read Write lease:");
+    /* Open fd on client 1 in WRonly mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE));
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE));
 
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase4_rd_lease_multi_clnt ()
+testcase4_rd_lease_multi_clnt()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi client Read lease:");
+    fprintf(log_file, "\n Basic test case for multi client Read lease:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client2, O_RDONLY, fd2, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDONLY, fd2, lid2);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid2);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = get_lease (fd2, lid2);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd2, lid2);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (9, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase5_openfd_multi_lid ()
+testcase5_openfd_multi_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        glfs_fd_t *fd3      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi lid openfd check:");
+    fprintf(log_file, "\n Basic test case for multi lid openfd check:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDONLY, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDONLY, fd1, lid1);
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client2, O_RDWR, fd2, lid2);
-        OPEN (client2, O_RDWR, fd3, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
+    OPEN(client2, O_RDWR, fd3, lid2);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(
+        1, ret,
+        SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(
+        2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = glfs_close (fd3);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd3);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase6_openfd_same_lid ()
+testcase6_openfd_same_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        glfs_fd_t *fd3      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for same lid openfd check:");
+    fprintf(log_file, "\n Basic test case for same lid openfd check:");
 
-        /* Open fd on client 2 in RW mode */
-        OPEN (client1, O_RDWR, fd1, lid2);
-        OPEN (client1, O_RDWR, fd2, lid2);
+    /* Open fd on client 2 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid2);
+    OPEN(client1, O_RDWR, fd2, lid2);
 
-        ret = set_write_lease (fd1, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = set_write_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_write_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd1, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd1, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = unlk_write_lease (fd2, lid2);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_write_lease(fd2, lid2);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (6, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(6, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase7_rd_multi_lid ()
+testcase7_rd_multi_lid()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for multi lease id Read lease:");
+    fprintf(log_file, "\n Basic test case for multi lease id Read lease:");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client2, O_RDONLY, fd1, lid2);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client2, O_RDONLY, fd1, lid2);
 
-        /* Open fd on client 2 in RD mode */
-        OPEN (client2, O_RDONLY, fd2, lid3);
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
 
-        ret = set_read_lease (fd1, lid2);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid2);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = set_read_lease (fd2, lid3);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    ret = set_read_lease(fd2, lid3);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid2);
-        VERIFY_RESULT (3, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(3, ret, GLFS_RD_LEASE);
 
-        ret = unlk_read_lease (fd1, lid2);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd1, lid2);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
 
-        ret = unlk_read_lease (fd2, lid3);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = unlk_read_lease(fd2, lid3);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid2);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd1, lid2);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = get_lease (fd2, lid3);
-        VERIFY_RESULT (7, ret, NONE);
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(7, ret, NONE);
 
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (8, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(8, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (9, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(9, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase8_client_disconnect ()
+testcase8_client_disconnect()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for client disconnect cleanup");
+    fprintf(log_file, "\n Basic test case for client disconnect cleanup");
 
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
 
-        ret = set_read_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_read_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (2, ret, GLFS_RD_LEASE);
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(2, ret, GLFS_RD_LEASE);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        ret = get_lease (fd1, lid1);
-        VERIFY_RESULT (4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE));
+    ret = get_lease(fd1, lid1);
+    VERIFY_RESULT(4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE));
 
-        ret = glfs_fini (client1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
+    ret = glfs_fini(client1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
 
-        /* Open fd on client 2 in RD mode */
-        OPEN (client2, O_RDONLY, fd2, lid3);
+    /* Open fd on client 2 in RD mode */
+    OPEN(client2, O_RDONLY, fd2, lid3);
 
-        ret = get_lease (fd2, lid3);
-        VERIFY_RESULT (6, ret, NONE);
+    ret = get_lease(fd2, lid3);
+    VERIFY_RESULT(6, ret, NONE);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (7, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(7, ret, SHUD_PASS);
 
-        client1 = setup_new_client (volname, glfs_log_file);
+    client1 = setup_new_client(volname, glfs_log_file);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase9_recall_conflict_lease ()
+testcase9_recall_conflict_lease()
 {
-        struct glfs_object *obj = NULL;
-        glfs_fd_t *fd1      = NULL;
-        int        ret      = 0;
-        struct glfs_lease lease = {0, };
-
-        fprintf (log_file, "\n Basic test case for conflicting lease causing recall");
-
-        memset (&lease, 0, sizeof (lease));
-        lease.cmd = GLFS_SET_LEASE;
-        lease.lease_type = GLFS_RD_LEASE;
-        memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
-        /* Open fd on client 1 in RD mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
-
-        obj = glfs_h_lookupat (client2, NULL, TEST_FILE, NULL, 0);
-        ret = glfs_h_lease (client2, obj, &lease);
-        VERIFY_RESULT (2, ret, SHUD_FAIL);
-
-        ret = unlk_write_lease (fd1, lid1);
-        VERIFY_RESULT (5, ret, SHUD_PASS);
-
-        sleep (3);
-        ret = glfs_h_close (obj);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (4, ret, SHUD_PASS);
-
-        return 0;
+    struct glfs_object *obj = NULL;
+    glfs_fd_t *fd1 = NULL;
+    int ret = 0;
+    struct glfs_lease lease = {
+        0,
+    };
+
+    fprintf(log_file,
+            "\n Basic test case for conflicting lease causing recall");
+
+    memset(&lease, 0, sizeof(lease));
+    lease.cmd = GLFS_SET_LEASE;
+    lease.lease_type = GLFS_RD_LEASE;
+    memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE);
+    /* Open fd on client 1 in RD mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
+
+    obj = glfs_h_lookupat(client2, NULL, TEST_FILE, NULL, 0);
+    ret = glfs_h_lease(client2, obj, &lease);
+    VERIFY_RESULT(2, ret, SHUD_FAIL);
+
+    ret = unlk_write_lease(fd1, lid1);
+    VERIFY_RESULT(5, ret, SHUD_PASS);
+
+    sleep(3);
+    ret = glfs_h_close(obj);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(4, ret, SHUD_PASS);
+
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 static int
-testcase10_recall_open_conflict ()
+testcase10_recall_open_conflict()
 {
-        glfs_fd_t *fd1      = NULL;
-        glfs_fd_t *fd2      = NULL;
-        int        ret      = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    int ret = 0;
 
-        fprintf (log_file, "\n Basic test case for conflicting open causing recall");
+    fprintf(log_file, "\n Basic test case for conflicting open causing recall");
 
-        /* Open fd on client 1 in RW mode */
-        OPEN (client1, O_RDWR, fd1, lid1);
+    /* Open fd on client 1 in RW mode */
+    OPEN(client1, O_RDWR, fd1, lid1);
 
-        ret = set_write_lease (fd1, lid1);
-        VERIFY_RESULT (1, ret, SHUD_PASS);
+    ret = set_write_lease(fd1, lid1);
+    VERIFY_RESULT(1, ret, SHUD_PASS);
 
-        /* Open fd on client 1 in RW mode */
-        OPEN (client2, O_RDWR, fd2, lid2);
+    /* Open fd on client 1 in RW mode */
+    OPEN(client2, O_RDWR, fd2, lid2);
 
-        /* TODO: Check for recall cbk functionality */
-        ret = glfs_close (fd1);
-        VERIFY_RESULT (2, ret, SHUD_PASS);
+    /* TODO: Check for recall cbk functionality */
+    ret = glfs_close(fd1);
+    VERIFY_RESULT(2, ret, SHUD_PASS);
 
-        ret = glfs_close (fd2);
-        VERIFY_RESULT (3, ret, SHUD_PASS);
+    ret = glfs_close(fd2);
+    VERIFY_RESULT(3, ret, SHUD_PASS);
 
-        return 0;
+    return 0;
 error:
-        return -1;
+    return -1;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int        ret      = 0;
-        int        i        = 0;
-        glfs_fd_t *fd       = NULL;
-        glfs_fd_t *fd1      = NULL;
-        char      *topdir   = "topdir", *filename = "file1";
-        char      *buf      = NULL;
-        int        x        = 0;
-        ssize_t    xattr_size = -1;
-
-        if (argc != 4) {
-                fprintf (stderr,
-                                "Expect following args %s <Vol> <glfs client log file> <testcase log file>\n"
-                                , argv[0]);
-                return -1;
-        }
+    int ret = 0;
+    int i = 0;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *topdir = "topdir", *filename = "file1";
+    char *buf = NULL;
+    int x = 0;
+    ssize_t xattr_size = -1;
+
+    if (argc != 4) {
+        fprintf(stderr,
+                "Expect following args %s <Vol> <glfs client log file> "
+                "<testcase log file>\n",
+                argv[0]);
+        return -1;
+    }
 
-        log_file = fopen (argv[3], "w");
-	if (!log_file)
-		goto error;
+    log_file = fopen(argv[3], "w");
+    if (!log_file)
+        goto error;
 
-        volname = argv[1];
-        glfs_log_file = argv[2];
+    volname = argv[1];
+    glfs_log_file = argv[2];
 
-        /* Setup 3 clients */
-        client1 = setup_new_client (volname, glfs_log_file);
-        client2 = setup_new_client (volname, glfs_log_file);
-        client3 = setup_new_client (volname, glfs_log_file);
+    /* Setup 3 clients */
+    client1 = setup_new_client(volname, glfs_log_file);
+    client2 = setup_new_client(volname, glfs_log_file);
+    client3 = setup_new_client(volname, glfs_log_file);
 
-        ret = testcase1_rd_lease ();
-        VERIFY_RESULT (101, ret, SHUD_PASS);
+    ret = testcase1_rd_lease();
+    VERIFY_RESULT(101, ret, SHUD_PASS);
 
-        ret = testcase2_wr_lease ();
-        VERIFY_RESULT (102, ret, SHUD_PASS);
+    ret = testcase2_wr_lease();
+    VERIFY_RESULT(102, ret, SHUD_PASS);
 
-        ret = testcase3_rd_wr_lease ();
-        VERIFY_RESULT (103, ret, SHUD_PASS);
+    ret = testcase3_rd_wr_lease();
+    VERIFY_RESULT(103, ret, SHUD_PASS);
 
-        ret = testcase4_rd_lease_multi_clnt ();
-        VERIFY_RESULT (104, ret, SHUD_PASS);
+    ret = testcase4_rd_lease_multi_clnt();
+    VERIFY_RESULT(104, ret, SHUD_PASS);
 
-        ret = testcase5_openfd_multi_lid ();
-        VERIFY_RESULT (105, ret, SHUD_PASS);
+    ret = testcase5_openfd_multi_lid();
+    VERIFY_RESULT(105, ret, SHUD_PASS);
 
-        ret = testcase6_openfd_same_lid ();
-        VERIFY_RESULT (106, ret, SHUD_PASS);
+    ret = testcase6_openfd_same_lid();
+    VERIFY_RESULT(106, ret, SHUD_PASS);
 
-        ret = testcase7_rd_multi_lid ();
-        VERIFY_RESULT (107, ret, SHUD_PASS);
+    ret = testcase7_rd_multi_lid();
+    VERIFY_RESULT(107, ret, SHUD_PASS);
 
-	ret = testcase8_client_disconnect ();
-        VERIFY_RESULT (108, ret, SHUD_PASS);
+    ret = testcase8_client_disconnect();
+    VERIFY_RESULT(108, ret, SHUD_PASS);
 
-        ret = testcase9_recall_conflict_lease ();
-        VERIFY_RESULT (109, ret, SHUD_PASS);
+    ret = testcase9_recall_conflict_lease();
+    VERIFY_RESULT(109, ret, SHUD_PASS);
 
-        ret = testcase10_recall_open_conflict ();
-        VERIFY_RESULT (110, ret, SHUD_PASS);
+    ret = testcase10_recall_open_conflict();
+    VERIFY_RESULT(110, ret, SHUD_PASS);
 
-        glfs_fini (client1);
-        glfs_fini (client2);
-        glfs_fini (client3);
+    glfs_fini(client1);
+    glfs_fini(client2);
+    glfs_fini(client3);
 
-	fclose (log_file);
-        return 0;
+    fclose(log_file);
+    return 0;
 error:
-        return -1;
+    return -1;
 }
diff --git a/tests/features/mandatory-lock-forced.c b/tests/features/mandatory-lock-forced.c
index f37206845f1..4028d6c6eaf 100644
--- a/tests/features/mandatory-lock-forced.c
+++ b/tests/features/mandatory-lock-forced.c
@@ -6,133 +6,138 @@
 #include <string.h>
 #include <sys/wait.h>
 
-#define LOG_ERR(func, err) do {                                                \
-        fprintf (stderr, "%s : returned error (%s)\n", func, strerror(err));   \
-        exit (err);                                                            \
-} while (0)
-
-int       fd;
-struct    flock lock;
-char      *buf = "ten bytes!";
-char      *fname = "/mnt/glusterfs/0/mand.lock";
-int       open_flags, child, err, status, blocked = 0;
-
-int do_child (char *argv[]) {
-        /* Initialize file open flags */
-        if (strcmp (argv[2], "BLOCK") == 0)
-                open_flags = O_RDWR;
-        else if (strcmp (argv[2], "TRUNC") == 0)
-                open_flags = O_RDWR | O_TRUNC | O_NONBLOCK;
-        else if (strcmp (argv[2], "NONE") == 0)
-                open_flags = O_RDWR | O_NONBLOCK;
-        else
-                LOG_ERR ("Invalid option:", EINVAL);
-
-        /* Open the file */
-        fd = open (fname, open_flags);
-        if (fd == -1)
-                LOG_ERR ("Child open", errno);
-
-        /* Perform the file operation*/
-        if (strcmp (argv[3], "READ") == 0) {
-                buf = NULL;
-                err = read (fd, buf, 10);
-                if (err == -1)
-                        LOG_ERR ("Child read", errno);
-        } else if (strcmp (argv[3], "WRITE") == 0) {
-                err = write (fd, buf, 10);
-                if (err == -1)
-                        LOG_ERR ("Child write", errno);
-        } else if (strcmp (argv[3], "FTRUNCATE") == 0) {
-                err = ftruncate (fd, 5);
-                if (err)
-                        LOG_ERR ("Child ftruncate", errno);
-        } else
-                LOG_ERR ("Invalid operation:", EINVAL);
-
-        /* Close child fd */
-        err = close (fd);
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        fprintf(stderr, "%s : returned error (%s)\n", func, strerror(err));    \
+        exit(err);                                                             \
+    } while (0)
+
+int fd;
+struct flock lock;
+char *buf = "ten bytes!";
+char *fname = "/mnt/glusterfs/0/mand.lock";
+int open_flags, child, err, status, blocked = 0;
+
+int
+do_child(char *argv[])
+{
+    /* Initialize file open flags */
+    if (strcmp(argv[2], "BLOCK") == 0)
+        open_flags = O_RDWR;
+    else if (strcmp(argv[2], "TRUNC") == 0)
+        open_flags = O_RDWR | O_TRUNC | O_NONBLOCK;
+    else if (strcmp(argv[2], "NONE") == 0)
+        open_flags = O_RDWR | O_NONBLOCK;
+    else
+        LOG_ERR("Invalid option:", EINVAL);
+
+    /* Open the file */
+    fd = open(fname, open_flags);
+    if (fd == -1)
+        LOG_ERR("Child open", errno);
+
+    /* Perform the file operation*/
+    if (strcmp(argv[3], "READ") == 0) {
+        buf = NULL;
+        err = read(fd, buf, 10);
+        if (err == -1)
+            LOG_ERR("Child read", errno);
+    } else if (strcmp(argv[3], "WRITE") == 0) {
+        err = write(fd, buf, 10);
+        if (err == -1)
+            LOG_ERR("Child write", errno);
+    } else if (strcmp(argv[3], "FTRUNCATE") == 0) {
+        err = ftruncate(fd, 5);
         if (err)
-                LOG_ERR ("Child close", errno);
+            LOG_ERR("Child ftruncate", errno);
+    } else
+        LOG_ERR("Invalid operation:", EINVAL);
 
-        /* Exit success */
-        exit (0);
+    /* Close child fd */
+    err = close(fd);
+    if (err)
+        LOG_ERR("Child close", errno);
+
+    /* Exit success */
+    exit(0);
 }
 
-int main (int argc, char *argv[]) {
-        if (argc < 4) {
-                fprintf (stderr, "Wrong usage: Use as ./mandatory-lock "
-                                "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> "
-                                "<READ/WRITE/FTRUNCATE\n");
-                exit(EINVAL);
+int
+main(int argc, char *argv[])
+{
+    if (argc < 4) {
+        fprintf(stderr,
+                "Wrong usage: Use as ./mandatory-lock "
+                "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> "
+                "<READ/WRITE/FTRUNCATE\n");
+        exit(EINVAL);
+    }
+    /* Create an empty lock file */
+    fd = open(fname, O_CREAT | O_RDWR, 0755);
+    if (fd == -1)
+        LOG_ERR("Parent create", errno);
+
+    /* Determine the type of lock */
+    if (strcmp(argv[1], "RD_LCK") == 0)
+        lock.l_type = F_RDLCK;
+    else if (strcmp(argv[1], "WR_LCK") == 0)
+        lock.l_type = F_WRLCK;
+    else
+        LOG_ERR("Parent lock type", EINVAL);
+
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 0L;
+
+    /* Let parent acquire the initial lock */
+    err = fcntl(fd, F_SETLK, &lock);
+    if (err)
+        LOG_ERR("Parent lock", errno);
+
+    /* Now fork a child */
+    child = fork();
+    if (child == 0)
+        /* Perform the child operations */
+        do_child(argv);
+    else {
+        /* If blocking mode, then sleep for 2 seconds
+         * and wait for the child */
+        if (strcmp(argv[2], "NONE") != 0) {
+            sleep(2);
+            if (waitpid(child, &status, WNOHANG) == 0)
+                blocked = 1;
+            /* Release the parent lock so that the
+             * child can terminate */
+            lock.l_type = F_UNLCK;
+            err = fcntl(fd, F_SETLK, &lock);
+            if (err)
+                LOG_ERR("Parent unlock", errno);
         }
-        /* Create an empty lock file */
-        fd = open (fname, O_CREAT | O_RDWR, 0755);
-        if (fd == -1)
-                LOG_ERR ("Parent create", errno);
-
-        /* Determine the type of lock */
-        if (strcmp (argv[1], "RD_LCK") == 0)
-                lock.l_type = F_RDLCK;
-        else if (strcmp (argv[1], "WR_LCK") == 0)
-                lock.l_type = F_WRLCK;
-        else
-                LOG_ERR ("Parent lock type", EINVAL);
-
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 0L;
-
-        /* Let parent acquire the initial lock */
-        err = fcntl (fd, F_SETLK, &lock);
+
+        /* Wait for child to finish */
+        waitpid(child, &status, 0);
+
+        /* Close the parent fd */
+        err = close(fd);
         if (err)
-                LOG_ERR ("Parent lock", errno);
-
-        /* Now fork a child */
-        child = fork ();
-        if (child == 0)
-                /* Perform the child operations */
-                do_child (argv);
-        else {
-                /* If blocking mode, then sleep for 2 seconds
-                 * and wait for the child */
-                if (strcmp (argv[2], "NONE") != 0) {
-                        sleep (2);
-                        if (waitpid (child, &status, WNOHANG) == 0)
-                                blocked = 1;
-                        /* Release the parent lock so that the
-                         * child can terminate */
-                        lock.l_type = F_UNLCK;
-                        err = fcntl (fd, F_SETLK, &lock);
-                        if (err)
-                                LOG_ERR ("Parent unlock", errno);
-                }
-
-                /* Wait for child to finish */
-                waitpid (child, &status, 0);
-
-                /* Close the parent fd */
-                err = close (fd);
-                if (err)
-                        LOG_ERR ("Parent close", errno);
-
-                /* Remove the lock file*/
-                err = unlink (fname);
-                if (err)
-                        LOG_ERR ("Parent unlink", errno);
-
-                /* If not blocked, exit with child exit status*/
-                errno = WEXITSTATUS(status);
-
-                /* If blocked, exit with corresponding
-                 * error code */
-                if (blocked)
-                        errno = EWOULDBLOCK;
-
-                if (errno != 0)
-                        printf ("%s\n", strerror(errno));
-
-                exit (errno);
+            LOG_ERR("Parent close", errno);
 
-        }
+        /* Remove the lock file*/
+        err = unlink(fname);
+        if (err)
+            LOG_ERR("Parent unlink", errno);
+
+        /* If not blocked, exit with child exit status*/
+        errno = WEXITSTATUS(status);
+
+        /* If blocked, exit with corresponding
+         * error code */
+        if (blocked)
+            errno = EWOULDBLOCK;
+
+        if (errno != 0)
+            printf("%s\n", strerror(errno));
+
+        exit(errno);
+    }
 }
diff --git a/tests/utils/arequal-checksum.c b/tests/utils/arequal-checksum.c
index 6ab68f38db8..b51a054162b 100644
--- a/tests/utils/arequal-checksum.c
+++ b/tests/utils/arequal-checksum.c
@@ -41,605 +41,593 @@
 int debug = 0;
 
 typedef struct {
-        char test_directory[4096];
-        char **ignored_directory;
-        unsigned int directories_ignored;
+    char test_directory[4096];
+    char **ignored_directory;
+    unsigned int directories_ignored;
 } arequal_config_t;
 
 static arequal_config_t arequal_config;
 
 static error_t
-arequal_parse_opts (int key, char *arg, struct argp_state *_state);
+arequal_parse_opts(int key, char *arg, struct argp_state *_state);
 
 static struct argp_option arequal_options[] = {
-        { "ignore", 'i', "IGNORED", 0,
-          "entry in the given path to be ignored"},
-        { "path", 'p', "PATH", 0, "path where arequal has to be run"},
-        {0, 0, 0, 0, 0}
-};
-
-#define DBG(fmt ...) do {                       \
-                if (debug) {                    \
-                        fprintf (stderr, "D "); \
-                        fprintf (stderr, fmt);  \
-                }                               \
-        } while (0)
+    {"ignore", 'i', "IGNORED", 0, "entry in the given path to be ignored"},
+    {"path", 'p', "PATH", 0, "path where arequal has to be run"},
+    {0, 0, 0, 0, 0}};
+
+#define DBG(fmt...)                                                            \
+    do {                                                                       \
+        if (debug) {                                                           \
+            fprintf(stderr, "D ");                                             \
+            fprintf(stderr, fmt);                                              \
+        }                                                                      \
+    } while (0)
 
 void
-add_to_list (char *arg);
+add_to_list(char *arg);
 void
-get_absolute_path (char directory[], char *arg);
+get_absolute_path(char directory[], char *arg);
 
-static int roof(int a, int b)
+static int
+roof(int a, int b)
 {
-        return ((((a)+(b)-1)/((b)?(b):1))*(b));
+    return ((((a) + (b)-1) / ((b) ? (b) : 1)) * (b));
 }
 
 void
-add_to_list (char *arg)
+add_to_list(char *arg)
 {
-        char *string = NULL;
-        int index = 0;
+    char *string = NULL;
+    int index = 0;
 
-        index = arequal_config.directories_ignored - 1;
-        string = strdup (arg);
+    index = arequal_config.directories_ignored - 1;
+    string = strdup(arg);
 
-        if (!arequal_config.ignored_directory) {
-                arequal_config.ignored_directory = calloc (1, sizeof (char *));
-        } else
-                arequal_config.ignored_directory =
-                        realloc (arequal_config.ignored_directory,
-                                 sizeof (char *) * (index+1));
+    if (!arequal_config.ignored_directory) {
+        arequal_config.ignored_directory = calloc(1, sizeof(char *));
+    } else
+        arequal_config.ignored_directory = realloc(
+            arequal_config.ignored_directory, sizeof(char *) * (index + 1));
 
-        arequal_config.ignored_directory[index] = string;
+    arequal_config.ignored_directory[index] = string;
 }
 
 static error_t
-arequal_parse_opts (int key, char *arg, struct argp_state *_state)
+arequal_parse_opts(int key, char *arg, struct argp_state *_state)
 {
-        switch (key) {
-        case 'i':
-        {
-                arequal_config.directories_ignored++;
-                add_to_list (arg);
-        }
-        break;
-        case 'p':
-        {
-                if (arg[0] == '/')
-                        strcpy (arequal_config.test_directory, arg);
-                else
-                        get_absolute_path (arequal_config.test_directory, arg);
-
-                if (arequal_config.test_directory
-                    [strlen(arequal_config.test_directory) - 1] == '/')
-                        arequal_config.test_directory
-                                [strlen(arequal_config.test_directory) - 1] = '\0';
-        }
-        break;
+    switch (key) {
+        case 'i': {
+            arequal_config.directories_ignored++;
+            add_to_list(arg);
+        } break;
+        case 'p': {
+            if (arg[0] == '/')
+                strcpy(arequal_config.test_directory, arg);
+            else
+                get_absolute_path(arequal_config.test_directory, arg);
+
+            if (arequal_config
+                    .test_directory[strlen(arequal_config.test_directory) -
+                                    1] == '/')
+                arequal_config
+                    .test_directory[strlen(arequal_config.test_directory) - 1] =
+                    '\0';
+        } break;
 
         case ARGP_KEY_NO_ARGS:
-                break;
+            break;
         case ARGP_KEY_ARG:
-                break;
+            break;
         case ARGP_KEY_END:
-                if (_state->argc == 1) {
-                       argp_usage (_state);
-                }
+            if (_state->argc == 1) {
+                argp_usage(_state);
+            }
+    }
 
-        }
-
-        return 0;
+    return 0;
 }
 
 void
-get_absolute_path (char directory[], char *arg)
+get_absolute_path(char directory[], char *arg)
 {
-        char   cwd[4096] = {0,};
-
-        if (getcwd (cwd, sizeof (cwd)) == NULL)
-                printf ("some error in getting cwd\n");
-
-        if (strcmp (arg, ".") != 0) {
-                if (cwd[strlen(cwd)] != '/')
-                        cwd[strlen (cwd)] = '/';
-                strcat (cwd, arg);
-        }
-        strcpy (directory, cwd);
+    char cwd[4096] = {
+        0,
+    };
+
+    if (getcwd(cwd, sizeof(cwd)) == NULL)
+        printf("some error in getting cwd\n");
+
+    if (strcmp(arg, ".") != 0) {
+        if (cwd[strlen(cwd)] != '/')
+            cwd[strlen(cwd)] = '/';
+        strcat(cwd, arg);
+    }
+    strcpy(directory, cwd);
 }
 
 static struct argp argp = {
-        arequal_options,
-        arequal_parse_opts,
-        "",
-        "arequal - Tool which calculates the checksum of all the entries"
-        "present in a given directory"
-};
+    arequal_options, arequal_parse_opts, "",
+    "arequal - Tool which calculates the checksum of all the entries"
+    "present in a given directory"};
 
 /* All this runs in single thread, hence using 'global' variables */
 
-unsigned long long     avg_uid_file    = 0;
-unsigned long long     avg_uid_dir     = 0;
-unsigned long long     avg_uid_symlink = 0;
-unsigned long long     avg_uid_other   = 0;
+unsigned long long avg_uid_file = 0;
+unsigned long long avg_uid_dir = 0;
+unsigned long long avg_uid_symlink = 0;
+unsigned long long avg_uid_other = 0;
 
-unsigned long long     avg_gid_file    = 0;
-unsigned long long     avg_gid_dir     = 0;
-unsigned long long     avg_gid_symlink = 0;
-unsigned long long     avg_gid_other   = 0;
+unsigned long long avg_gid_file = 0;
+unsigned long long avg_gid_dir = 0;
+unsigned long long avg_gid_symlink = 0;
+unsigned long long avg_gid_other = 0;
 
-unsigned long long     avg_mode_file    = 0;
-unsigned long long     avg_mode_dir     = 0;
-unsigned long long     avg_mode_symlink = 0;
-unsigned long long     avg_mode_other   = 0;
+unsigned long long avg_mode_file = 0;
+unsigned long long avg_mode_dir = 0;
+unsigned long long avg_mode_symlink = 0;
+unsigned long long avg_mode_other = 0;
 
 unsigned long long global_ctime_checksum = 0;
 
+unsigned long long count_dir = 0;
+unsigned long long count_file = 0;
+unsigned long long count_symlink = 0;
+unsigned long long count_other = 0;
 
-unsigned long long      count_dir        = 0;
-unsigned long long      count_file       = 0;
-unsigned long long      count_symlink    = 0;
-unsigned long long      count_other      = 0;
+unsigned long long checksum_file1 = 0;
+unsigned long long checksum_file2 = 0;
+unsigned long long checksum_dir = 0;
+unsigned long long checksum_symlink = 0;
+unsigned long long checksum_other = 0;
 
+unsigned long long
+checksum_path(const char *path)
+{
+    unsigned long long csum = 0;
+    unsigned long long *nums = 0;
+    int len = 0;
+    int cnt = 0;
 
-unsigned long long      checksum_file1   = 0;
-unsigned long long      checksum_file2   = 0;
-unsigned long long      checksum_dir     = 0;
-unsigned long long      checksum_symlink = 0;
-unsigned long long      checksum_other   = 0;
+    len = roof(strlen(path), sizeof(csum));
+    cnt = len / sizeof(csum);
 
+    nums = __builtin_alloca(len);
+    memset(nums, 0, len);
+    strcpy((char *)nums, path);
 
-unsigned long long
-checksum_path (const char *path)
-{
-        unsigned long long   csum = 0;
-        unsigned long long  *nums = 0;
-        int                  len = 0;
-        int                  cnt = 0;
-
-        len = roof (strlen (path), sizeof (csum));
-        cnt = len / sizeof (csum);
-
-        nums = __builtin_alloca (len);
-        memset (nums, 0, len);
-        strcpy ((char *)nums, path);
-
-        while (cnt) {
-                csum ^= *nums;
-                nums++;
-                cnt--;
-        }
+    while (cnt) {
+        csum ^= *nums;
+        nums++;
+        cnt--;
+    }
 
-        return csum;
+    return csum;
 }
 
 int
-checksum_md5 (const char *path, const struct stat *sb)
+checksum_md5(const char *path, const struct stat *sb)
 {
-        uint64_t    this_data_checksum = 0;
-        FILE       *filep              = NULL;
-        char        *cmd               = NULL;
-        char        strvalue[17]       = {0,};
-        int         ret                = -1;
-        int         len                = 0;
-        const char  *pos               = NULL;
-        char        *cpos              = NULL;
-
-        /* Have to escape single-quotes in filename.
-         * First, calculate the size of the buffer I'll need.
-         */
-        for (pos = path; *pos; pos++) {
-                if ( *pos == '\'' )
-                        len += 4;
-                else
-                        len += 1;
-        }
-
-        cmd = malloc(sizeof(char) * (len + 20));
-        cmd[0] = '\0';
-
-        /* Now, build the command with single quotes escaped. */
-
-        cpos = cmd;
+    uint64_t this_data_checksum = 0;
+    FILE *filep = NULL;
+    char *cmd = NULL;
+    char strvalue[17] = {
+        0,
+    };
+    int ret = -1;
+    int len = 0;
+    const char *pos = NULL;
+    char *cpos = NULL;
+
+    /* Have to escape single-quotes in filename.
+     * First, calculate the size of the buffer I'll need.
+     */
+    for (pos = path; *pos; pos++) {
+        if (*pos == '\'')
+            len += 4;
+        else
+            len += 1;
+    }
+
+    cmd = malloc(sizeof(char) * (len + 20));
+    cmd[0] = '\0';
+
+    /* Now, build the command with single quotes escaped. */
+
+    cpos = cmd;
 #if defined(linux)
-        strcpy(cpos, "md5sum '");
-        cpos += 8;
+    strcpy(cpos, "md5sum '");
+    cpos += 8;
 #elif defined(__NetBSD__)
-        strcpy(cpos, "md5 -n '");
-        cpos += 8;
+    strcpy(cpos, "md5 -n '");
+    cpos += 8;
 #elif defined(__FreeBSD__) || defined(__APPLE__)
-        strcpy(cpos, "md5 -q '");
-        cpos += 8;
+    strcpy(cpos, "md5 -q '");
+    cpos += 8;
 #else
 #error "Please add system-specific md5 command"
 #endif
 
-        /* Add the file path, with every single quotes replaced with this sequence:
-         * '\''
-         */
-
-        for (pos = path; *pos; pos++) {
-                if ( *pos == '\'' ) {
-                        strcpy(cpos, "'\\''");
-                        cpos += 4;
-                } else {
-                        *cpos = *pos;
-                        cpos++;
-                }
-        }
-
-        /* Add on the trailing single-quote and null-terminate. */
-        strcpy(cpos, "'");
-
-        filep = popen (cmd, "r");
-        if (!filep) {
-                perror (path);
-                goto out;
-        }
-
-        if (fread (strvalue, sizeof (char), 16, filep) != 16) {
-                fprintf (stderr, "%s: short read\n", path);
-                goto out;
+    /* Add the file path, with every single quotes replaced with this sequence:
+     * '\''
+     */
+
+    for (pos = path; *pos; pos++) {
+        if (*pos == '\'') {
+            strcpy(cpos, "'\\''");
+            cpos += 4;
+        } else {
+            *cpos = *pos;
+            cpos++;
         }
-
-        this_data_checksum = strtoull (strvalue, NULL, 16);
-        if (-1 == this_data_checksum) {
-                fprintf (stderr, "%s: %s\n", strvalue, strerror (errno));
-                goto out;
-        }
-        checksum_file1 ^= this_data_checksum;
-
-        if (fread (strvalue, sizeof (char), 16, filep) != 16) {
-                fprintf (stderr, "%s: short read\n", path);
-                goto out;
-        }
-
-        this_data_checksum = strtoull (strvalue, NULL, 16);
-        if (-1 == this_data_checksum) {
-                fprintf (stderr, "%s: %s\n", strvalue, strerror (errno));
-                goto out;
-        }
-        checksum_file2 ^= this_data_checksum;
-
-        ret = 0;
+    }
+
+    /* Add on the trailing single-quote and null-terminate. */
+    strcpy(cpos, "'");
+
+    filep = popen(cmd, "r");
+    if (!filep) {
+        perror(path);
+        goto out;
+    }
+
+    if (fread(strvalue, sizeof(char), 16, filep) != 16) {
+        fprintf(stderr, "%s: short read\n", path);
+        goto out;
+    }
+
+    this_data_checksum = strtoull(strvalue, NULL, 16);
+    if (-1 == this_data_checksum) {
+        fprintf(stderr, "%s: %s\n", strvalue, strerror(errno));
+        goto out;
+    }
+    checksum_file1 ^= this_data_checksum;
+
+    if (fread(strvalue, sizeof(char), 16, filep) != 16) {
+        fprintf(stderr, "%s: short read\n", path);
+        goto out;
+    }
+
+    this_data_checksum = strtoull(strvalue, NULL, 16);
+    if (-1 == this_data_checksum) {
+        fprintf(stderr, "%s: %s\n", strvalue, strerror(errno));
+        goto out;
+    }
+    checksum_file2 ^= this_data_checksum;
+
+    ret = 0;
 out:
-        if (filep)
-                pclose (filep);
+    if (filep)
+        pclose(filep);
 
-        if (cmd)
-                free(cmd);
+    if (cmd)
+        free(cmd);
 
-        return ret;
+    return ret;
 }
 
 int
-checksum_filenames (const char *path, const struct stat *sb)
+checksum_filenames(const char *path, const struct stat *sb)
 {
-        DIR                *dirp = NULL;
-        struct dirent      *entry = NULL;
-        unsigned long long  csum = 0;
-        int                 i = 0;
-        int                 found = 0;
-
-        dirp = opendir (path);
-        if (!dirp) {
-                perror (path);
-                goto out;
-        }
-
-        errno = 0;
-        while ((entry = readdir (dirp))) {
-                /* do not calculate the checksum of the entries which user has
-                   told to ignore and proceed to other siblings.*/
-                if (arequal_config.ignored_directory) {
-                        for (i = 0;i < arequal_config.directories_ignored;i++) {
-                                if ((strcmp (entry->d_name,
-                                             arequal_config.ignored_directory[i])
-                                     == 0)) {
-                                        found = 1;
-                                        DBG ("ignoring the entry %s\n",
-                                             entry->d_name);
-                                        break;
-                                }
-                        }
-                        if (found == 1) {
-                                found = 0;
-                                continue;
-                        }
+    DIR *dirp = NULL;
+    struct dirent *entry = NULL;
+    unsigned long long csum = 0;
+    int i = 0;
+    int found = 0;
+
+    dirp = opendir(path);
+    if (!dirp) {
+        perror(path);
+        goto out;
+    }
+
+    errno = 0;
+    while ((entry = readdir(dirp))) {
+        /* do not calculate the checksum of the entries which user has
+           told to ignore and proceed to other siblings.*/
+        if (arequal_config.ignored_directory) {
+            for (i = 0; i < arequal_config.directories_ignored; i++) {
+                if ((strcmp(entry->d_name,
+                            arequal_config.ignored_directory[i]) == 0)) {
+                    found = 1;
+                    DBG("ignoring the entry %s\n", entry->d_name);
+                    break;
                 }
-                csum = checksum_path (entry->d_name);
-                checksum_dir ^= csum;
+            }
+            if (found == 1) {
+                found = 0;
+                continue;
+            }
         }
+        csum = checksum_path(entry->d_name);
+        checksum_dir ^= csum;
+    }
 
-        if (errno) {
-                perror (path);
-                goto out;
-        }
+    if (errno) {
+        perror(path);
+        goto out;
+    }
 
 out:
-        if (dirp)
-                closedir (dirp);
+    if (dirp)
+        closedir(dirp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-process_file (const char *path, const struct stat *sb)
+process_file(const char *path, const struct stat *sb)
 {
-        int    ret = 0;
+    int ret = 0;
 
-        count_file++;
+    count_file++;
 
-        avg_uid_file ^= sb->st_uid;
-        avg_gid_file ^= sb->st_gid;
-        avg_mode_file ^= sb->st_mode;
+    avg_uid_file ^= sb->st_uid;
+    avg_gid_file ^= sb->st_gid;
+    avg_mode_file ^= sb->st_mode;
 
-        ret = checksum_md5 (path, sb);
+    ret = checksum_md5(path, sb);
 
-        return ret;
+    return ret;
 }
 
-
 int
-process_dir (const char *path, const struct stat *sb)
+process_dir(const char *path, const struct stat *sb)
 {
-        unsigned long long csum = 0;
+    unsigned long long csum = 0;
 
-        count_dir++;
+    count_dir++;
 
-        avg_uid_dir ^= sb->st_uid;
-        avg_gid_dir ^= sb->st_gid;
-        avg_mode_dir ^= sb->st_mode;
+    avg_uid_dir ^= sb->st_uid;
+    avg_gid_dir ^= sb->st_gid;
+    avg_mode_dir ^= sb->st_mode;
 
-        csum = checksum_filenames (path, sb);
+    csum = checksum_filenames(path, sb);
 
-        checksum_dir ^= csum;
+    checksum_dir ^= csum;
 
-        return 0;
+    return 0;
 }
 
-
 int
-process_symlink (const char *path, const struct stat *sb)
+process_symlink(const char *path, const struct stat *sb)
 {
-        int                ret = 0;
-        char               buf[4096] = {0, };
-        unsigned long long csum = 0;
+    int ret = 0;
+    char buf[4096] = {
+        0,
+    };
+    unsigned long long csum = 0;
 
-        count_symlink++;
+    count_symlink++;
 
-        avg_uid_symlink ^= sb->st_uid;
-        avg_gid_symlink ^= sb->st_gid;
-        avg_mode_symlink ^= sb->st_mode;
+    avg_uid_symlink ^= sb->st_uid;
+    avg_gid_symlink ^= sb->st_gid;
+    avg_mode_symlink ^= sb->st_mode;
 
-        ret = readlink (path, buf, 4096);
-        if (ret < 0) {
-                perror (path);
-                goto out;
-        }
+    ret = readlink(path, buf, 4096);
+    if (ret < 0) {
+        perror(path);
+        goto out;
+    }
 
-        DBG ("readlink (%s) => %s\n", path, buf);
+    DBG("readlink (%s) => %s\n", path, buf);
 
-        csum = checksum_path (buf);
+    csum = checksum_path(buf);
 
-        DBG ("checksum_path (%s) => %llx\n", buf, csum);
+    DBG("checksum_path (%s) => %llx\n", buf, csum);
 
-        checksum_symlink ^= csum;
+    checksum_symlink ^= csum;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-process_other (const char *path, const struct stat *sb)
+process_other(const char *path, const struct stat *sb)
 {
-        count_other++;
+    count_other++;
 
-        avg_uid_other ^= sb->st_uid;
-        avg_gid_other ^= sb->st_gid;
-        avg_mode_other ^= sb->st_mode;
+    avg_uid_other ^= sb->st_uid;
+    avg_gid_other ^= sb->st_gid;
+    avg_mode_other ^= sb->st_mode;
 
-        checksum_other ^= sb->st_rdev;
+    checksum_other ^= sb->st_rdev;
 
-        return 0;
+    return 0;
 }
 
 static int
 ignore_entry(const char *bname, const char *dname)
 {
-        int i;
+    int i;
 
-	for (i  = 0; i < arequal_config.directories_ignored; i++) {
-		if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 &&
-                    strncmp(arequal_config.test_directory, dname,
-                            strlen(arequal_config.test_directory)) == 0)
-                        return 1;
-        }
+    for (i = 0; i < arequal_config.directories_ignored; i++) {
+        if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 &&
+            strncmp(arequal_config.test_directory, dname,
+                    strlen(arequal_config.test_directory)) == 0)
+            return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-process_entry (const char *path, const struct stat *sb,
-               int typeflag, struct FTW *ftwbuf)
+process_entry(const char *path, const struct stat *sb, int typeflag,
+              struct FTW *ftwbuf)
 {
-        int ret = 0;
-        char *name = NULL;
-        char *bname = NULL;
-        char *dname = NULL;
-        int  i = 0;
-
-        /* The if condition below helps in ignoring some directories in
-           the given path. If the name of the entry is one of the directory
-           names that the user told to ignore, then that directory will not
-           be processed and will return FTW_SKIP_SUBTREE to nftw which will
-           not crawl this directory and move on to other siblings.
-           Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL
-           should be passed as an argument to nftw.
-
-           This mainly helps in calculating the checksum of network filesystems
-           (client-server), where the server might have some hidden directories
-           for managing the filesystem. So to calculate the sanity of filesystem
-           one has to get the checksum of the client and then the export directory
-           of server by telling arequal to ignore some of the directories which
-           are not part of the namespace.
-        */
-
-        if (arequal_config.ignored_directory) {
+    int ret = 0;
+    char *name = NULL;
+    char *bname = NULL;
+    char *dname = NULL;
+    int i = 0;
+
+    /* The if condition below helps in ignoring some directories in
+       the given path. If the name of the entry is one of the directory
+       names that the user told to ignore, then that directory will not
+       be processed and will return FTW_SKIP_SUBTREE to nftw which will
+       not crawl this directory and move on to other siblings.
+       Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL
+       should be passed as an argument to nftw.
+
+       This mainly helps in calculating the checksum of network filesystems
+       (client-server), where the server might have some hidden directories
+       for managing the filesystem. So to calculate the sanity of filesystem
+       one has to get the checksum of the client and then the export directory
+       of server by telling arequal to ignore some of the directories which
+       are not part of the namespace.
+    */
+
+    if (arequal_config.ignored_directory) {
 #ifndef FTW_SKIP_SUBTREE
-                char *cp;
-
-                name = strdup (path);
-                dname = dirname (name);
-
-                for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) {
-                        if (ignore_entry(cp, dname)) {
-                                DBG ("ignoring %s\n", path);
-                                if (name)
-                                        free (name);
-                                return 0;
-                        }
-                }
-#else /* FTW_SKIP_SUBTREE */
-                name = strdup (path);
-
-                name[strlen(name)] = '\0';
-
-                bname = strrchr (name, '/');
-                if (bname)
-                        bname++;
-
-                dname = dirname (name);
-                if (ignore_entry(bname, dname)) {
-                                DBG ("ignoring %s\n", bname);
-                                ret = FTW_SKIP_SUBTREE;
-                                if (name)
-                                        free (name);
-                                return ret;
-                }
-#endif /* FTW_SKIP_SUBTREE */
+        char *cp;
+
+        name = strdup(path);
+        dname = dirname(name);
+
+        for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) {
+            if (ignore_entry(cp, dname)) {
+                DBG("ignoring %s\n", path);
+                if (name)
+                    free(name);
+                return 0;
+            }
         }
+#else  /* FTW_SKIP_SUBTREE */
+        name = strdup(path);
+
+        name[strlen(name)] = '\0';
+
+        bname = strrchr(name, '/');
+        if (bname)
+            bname++;
+
+        dname = dirname(name);
+        if (ignore_entry(bname, dname)) {
+            DBG("ignoring %s\n", bname);
+            ret = FTW_SKIP_SUBTREE;
+            if (name)
+                free(name);
+            return ret;
+        }
+#endif /* FTW_SKIP_SUBTREE */
+    }
 
-        DBG ("processing entry %s\n", path);
+    DBG("processing entry %s\n", path);
 
-        switch ((S_IFMT & sb->st_mode)) {
+    switch ((S_IFMT & sb->st_mode)) {
         case S_IFDIR:
-                ret = process_dir (path, sb);
-                break;
+            ret = process_dir(path, sb);
+            break;
         case S_IFREG:
-                ret = process_file (path, sb);
-                break;
+            ret = process_file(path, sb);
+            break;
         case S_IFLNK:
-                ret = process_symlink (path, sb);
-                break;
+            ret = process_symlink(path, sb);
+            break;
         default:
-                ret = process_other (path, sb);
-                break;
-        }
+            ret = process_other(path, sb);
+            break;
+    }
 
-        if (name)
-                free (name);
-        return ret;
+    if (name)
+        free(name);
+    return ret;
 }
 
-
 int
-display_counts (FILE *fp)
+display_counts(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Entry counts\n");
-        fprintf (fp, "Regular files   : %lld\n", count_file);
-        fprintf (fp, "Directories     : %lld\n", count_dir);
-        fprintf (fp, "Symbolic links  : %lld\n", count_symlink);
-        fprintf (fp, "Other           : %lld\n", count_other);
-        fprintf (fp, "Total           : %lld\n",
-                 (count_file + count_dir + count_symlink + count_other));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Entry counts\n");
+    fprintf(fp, "Regular files   : %lld\n", count_file);
+    fprintf(fp, "Directories     : %lld\n", count_dir);
+    fprintf(fp, "Symbolic links  : %lld\n", count_symlink);
+    fprintf(fp, "Other           : %lld\n", count_other);
+    fprintf(fp, "Total           : %lld\n",
+            (count_file + count_dir + count_symlink + count_other));
+
+    return 0;
 }
 
-
 int
-display_checksums (FILE *fp)
+display_checksums(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Checksums\n");
-        fprintf (fp, "Regular files   : %llx%llx\n", checksum_file1, checksum_file2);
-        fprintf (fp, "Directories     : %llx\n", checksum_dir);
-        fprintf (fp, "Symbolic links  : %llx\n", checksum_symlink);
-        fprintf (fp, "Other           : %llx\n", checksum_other);
-        fprintf (fp, "Total           : %llx\n",
-                 (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^ checksum_other));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Checksums\n");
+    fprintf(fp, "Regular files   : %llx%llx\n", checksum_file1, checksum_file2);
+    fprintf(fp, "Directories     : %llx\n", checksum_dir);
+    fprintf(fp, "Symbolic links  : %llx\n", checksum_symlink);
+    fprintf(fp, "Other           : %llx\n", checksum_other);
+    fprintf(fp, "Total           : %llx\n",
+            (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^
+             checksum_other));
+
+    return 0;
 }
 
-
 int
-display_metadata (FILE *fp)
+display_metadata(FILE *fp)
 {
-        fprintf (fp, "\n");
-        fprintf (fp, "Metadata checksums\n");
-        fprintf (fp, "Regular files   : %llx\n",
-                 (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7));
-        fprintf (fp, "Directories     : %llx\n",
-                 (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7));
-        fprintf (fp, "Symbolic links  : %llx\n",
-                 (avg_uid_symlink + 13) * (avg_gid_symlink + 11) * (avg_mode_symlink + 7));
-        fprintf (fp, "Other           : %llx\n",
-                 (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7));
-
-        return 0;
+    fprintf(fp, "\n");
+    fprintf(fp, "Metadata checksums\n");
+    fprintf(fp, "Regular files   : %llx\n",
+            (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7));
+    fprintf(fp, "Directories     : %llx\n",
+            (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7));
+    fprintf(fp, "Symbolic links  : %llx\n",
+            (avg_uid_symlink + 13) * (avg_gid_symlink + 11) *
+                (avg_mode_symlink + 7));
+    fprintf(fp, "Other           : %llx\n",
+            (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7));
+
+    return 0;
 }
 
 int
-display_stats (FILE *fp)
+display_stats(FILE *fp)
 {
-        display_counts (fp);
+    display_counts(fp);
 
-        display_metadata (fp);
+    display_metadata(fp);
 
-        display_checksums (fp);
+    display_checksums(fp);
 
-        return 0;
+    return 0;
 }
 
-
 int
 main(int argc, char *argv[])
 {
-        int  ret = 0;
-        int  i = 0;
-
-        ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
-        if (ret != 0) {
-                fprintf (stderr, "parsing arguments failed\n");
-                return -2;
-        }
-
-         /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */
-         /* the return value of the callback function */
-         /* (process_entry in this case) */
-        ret = nftw (arequal_config.test_directory, process_entry, 30,
-                    FTW_ACTIONRETVAL|FTW_PHYS|FTW_MOUNT);
-        if (ret != 0) {
-                fprintf (stderr, "ftw (%s) returned %d (%s), terminating\n",
-                         argv[1], ret, strerror (errno));
-                return 1;
-        }
-
-        display_stats (stdout);
-
-        if (arequal_config.ignored_directory) {
-                for (i = 0; i < arequal_config.directories_ignored; i++) {
-                        if (arequal_config.ignored_directory[i])
-                            free (arequal_config.ignored_directory[i]);
-                }
-                free (arequal_config.ignored_directory);
+    int ret = 0;
+    int i = 0;
+
+    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
+    if (ret != 0) {
+        fprintf(stderr, "parsing arguments failed\n");
+        return -2;
+    }
+
+    /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */
+    /* the return value of the callback function */
+    /* (process_entry in this case) */
+    ret = nftw(arequal_config.test_directory, process_entry, 30,
+               FTW_ACTIONRETVAL | FTW_PHYS | FTW_MOUNT);
+    if (ret != 0) {
+        fprintf(stderr, "ftw (%s) returned %d (%s), terminating\n", argv[1],
+                ret, strerror(errno));
+        return 1;
+    }
+
+    display_stats(stdout);
+
+    if (arequal_config.ignored_directory) {
+        for (i = 0; i < arequal_config.directories_ignored; i++) {
+            if (arequal_config.ignored_directory[i])
+                free(arequal_config.ignored_directory[i]);
         }
+        free(arequal_config.ignored_directory);
+    }
 
-        return 0;
+    return 0;
 }
diff --git a/tests/utils/changelog/get-history.c b/tests/utils/changelog/get-history.c
index 29dc60987ae..9963ab76958 100644
--- a/tests/utils/changelog/get-history.c
+++ b/tests/utils/changelog/get-history.c
@@ -27,47 +27,45 @@
 #include "changelog.h"
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int     ret          = 0;
-        unsigned long end_ts = 0;
-        int start  = 0;
-        int end    = 0;
+    int ret = 0;
+    unsigned long end_ts = 0;
+    int start = 0;
+    int end = 0;
 
-        ret = gf_changelog_init (NULL);
-        if (ret) {
-                printf ("-1");
-                fflush(stdout);
-                return -1;
-        }
-
-        ret = gf_changelog_register ("/d/backends/patchy0",
-                                     "/tmp/scratch_v1",
-                                     "/var/log/glusterfs/changes.log",
-                                     9, 5);
-        if (ret) {
-                printf ("-2");
-                fflush(stdout);
-                return -1;
-        }
+    ret = gf_changelog_init(NULL);
+    if (ret) {
+        printf("-1");
+        fflush(stdout);
+        return -1;
+    }
 
-        start = atoi(argv[1]);
-        end = atoi(argv[2]);
+    ret = gf_changelog_register("/d/backends/patchy0", "/tmp/scratch_v1",
+                                "/var/log/glusterfs/changes.log", 9, 5);
+    if (ret) {
+        printf("-2");
+        fflush(stdout);
+        return -1;
+    }
 
-        ret = gf_history_changelog ("/d/backends/patchy0/.glusterfs/changelogs",
-                                    start, end, 3, &end_ts);
-        if (ret < 0) {
-                printf ("-3");
-                fflush(stdout);
-                return -1;
-        } else if (ret == 1) {
-                printf ("1");
-                fflush(stdout);
-                return 0;
-        }
+    start = atoi(argv[1]);
+    end = atoi(argv[2]);
 
-out:
-        printf ("0");
+    ret = gf_history_changelog("/d/backends/patchy0/.glusterfs/changelogs",
+                               start, end, 3, &end_ts);
+    if (ret < 0) {
+        printf("-3");
+        fflush(stdout);
+        return -1;
+    } else if (ret == 1) {
+        printf("1");
         fflush(stdout);
         return 0;
+    }
+
+out:
+    printf("0");
+    fflush(stdout);
+    return 0;
 }
diff --git a/tools/gfind_missing_files/gcrawler.c b/tools/gfind_missing_files/gcrawler.c
index 02b644a1a77..9b3d243841c 100644
--- a/tools/gfind_missing_files/gcrawler.c
+++ b/tools/gfind_missing_files/gcrawler.c
@@ -26,23 +26,40 @@
 #define BUMP(name) INC(name, 1)
 #define DEFAULT_WORKERS 4
 
-#define NEW(x) {                              \
-        x = calloc (1, sizeof (typeof (*x))); \
-        }
-
-#define err(x ...) fprintf(stderr, x)
-#define out(x ...) fprintf(stdout, x)
-#define dbg(x ...) do { if (debug) fprintf(stdout, x); } while (0)
-#define tout(x ...) do { out("[%ld] ", pthread_self()); out(x); } while (0)
-#define terr(x ...) do { err("[%ld] ", pthread_self()); err(x); } while (0)
-#define tdbg(x ...) do { dbg("[%ld] ", pthread_self()); dbg(x); } while (0)
+#define NEW(x)                                                                 \
+    {                                                                          \
+        x = calloc(1, sizeof(typeof(*x)));                                     \
+    }
+
+#define err(x...) fprintf(stderr, x)
+#define out(x...) fprintf(stdout, x)
+#define dbg(x...)                                                              \
+    do {                                                                       \
+        if (debug)                                                             \
+            fprintf(stdout, x);                                                \
+    } while (0)
+#define tout(x...)                                                             \
+    do {                                                                       \
+        out("[%ld] ", pthread_self());                                         \
+        out(x);                                                                \
+    } while (0)
+#define terr(x...)                                                             \
+    do {                                                                       \
+        err("[%ld] ", pthread_self());                                         \
+        err(x);                                                                \
+    } while (0)
+#define tdbg(x...)                                                             \
+    do {                                                                       \
+        dbg("[%ld] ", pthread_self());                                         \
+        dbg(x);                                                                \
+    } while (0)
 
 int debug = 0;
 const char *slavemnt = NULL;
 int workers = 0;
 
 struct stats {
-        unsigned long long int cnt_skipped_gfids;
+    unsigned long long int cnt_skipped_gfids;
 };
 
 pthread_spinlock_t stats_lock;
@@ -50,518 +67,515 @@ pthread_spinlock_t stats_lock;
 struct stats stats_total;
 int stats = 0;
 
-#define INC(name, val) do {                             \
-        if (!stats)                                     \
-                break;                                  \
-        pthread_spin_lock(&stats_lock);                 \
-        {                                               \
-                stats_total.cnt_##name += val;          \
-        }                                               \
-        pthread_spin_unlock(&stats_lock);               \
-        } while (0)
+#define INC(name, val)                                                         \
+    do {                                                                       \
+        if (!stats)                                                            \
+            break;                                                             \
+        pthread_spin_lock(&stats_lock);                                        \
+        {                                                                      \
+            stats_total.cnt_##name += val;                                     \
+        }                                                                      \
+        pthread_spin_unlock(&stats_lock);                                      \
+    } while (0)
 
 void
 stats_dump()
 {
-        if (!stats)
-                return;
+    if (!stats)
+        return;
 
-        out("-------------------------------------------\n");
-        out("Skipped_Files : %10lld\n", stats_total.cnt_skipped_gfids);
-        out("-------------------------------------------\n");
+    out("-------------------------------------------\n");
+    out("Skipped_Files : %10lld\n", stats_total.cnt_skipped_gfids);
+    out("-------------------------------------------\n");
 }
 
 struct dirjob {
-        struct list_head    list;
+    struct list_head list;
 
-        char               *dirname;
+    char *dirname;
 
-        struct dirjob      *parent;
-        int                 ret;    /* final status of this subtree */
-        int                 refcnt; /* how many dirjobs have this as parent */
+    struct dirjob *parent;
+    int ret;    /* final status of this subtree */
+    int refcnt; /* how many dirjobs have this as parent */
 
-        pthread_spinlock_t  lock;
+    pthread_spinlock_t lock;
 };
 
-
 struct xwork {
-        pthread_t        cthreads[THREAD_MAX]; /* crawler threads */
-        int              count;
-        int              idle;
-        int              stop;
+    pthread_t cthreads[THREAD_MAX]; /* crawler threads */
+    int count;
+    int idle;
+    int stop;
 
-        struct dirjob    crawl;
+    struct dirjob crawl;
 
-        struct dirjob   *rootjob; /* to verify completion in xwork_fini() */
+    struct dirjob *rootjob; /* to verify completion in xwork_fini() */
 
-        pthread_mutex_t  mutex;
-        pthread_cond_t   cond;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
 };
 
-
 struct dirjob *
-dirjob_ref (struct dirjob *job)
+dirjob_ref(struct dirjob *job)
 {
-        pthread_spin_lock (&job->lock);
-        {
-                job->refcnt++;
-        }
-        pthread_spin_unlock (&job->lock);
+    pthread_spin_lock(&job->lock);
+    {
+        job->refcnt++;
+    }
+    pthread_spin_unlock(&job->lock);
 
-        return job;
+    return job;
 }
 
-
 void
-dirjob_free (struct dirjob *job)
+dirjob_free(struct dirjob *job)
 {
-        assert (list_empty (&job->list));
+    assert(list_empty(&job->list));
 
-        pthread_spin_destroy (&job->lock);
-        free (job->dirname);
-        free (job);
+    pthread_spin_destroy(&job->lock);
+    free(job->dirname);
+    free(job);
 }
 
 void
-dirjob_ret (struct dirjob *job, int err)
+dirjob_ret(struct dirjob *job, int err)
 {
-        int            ret = 0;
-        int            refcnt = 0;
-        struct dirjob *parent = NULL;
-
-        pthread_spin_lock (&job->lock);
-        {
-                refcnt = --job->refcnt;
-                job->ret = (job->ret || err);
-        }
-        pthread_spin_unlock (&job->lock);
-
-        if (refcnt == 0) {
-                ret = job->ret;
-
-                if (ret)
-                        terr ("Failed: %s (%d)\n", job->dirname, ret);
-                else
-                        tdbg ("Finished: %s\n", job->dirname);
-
-                parent = job->parent;
-                if (parent)
-                        dirjob_ret (parent, ret);
+    int ret = 0;
+    int refcnt = 0;
+    struct dirjob *parent = NULL;
+
+    pthread_spin_lock(&job->lock);
+    {
+        refcnt = --job->refcnt;
+        job->ret = (job->ret || err);
+    }
+    pthread_spin_unlock(&job->lock);
+
+    if (refcnt == 0) {
+        ret = job->ret;
+
+        if (ret)
+            terr("Failed: %s (%d)\n", job->dirname, ret);
+        else
+            tdbg("Finished: %s\n", job->dirname);
+
+        parent = job->parent;
+        if (parent)
+            dirjob_ret(parent, ret);
 
-                dirjob_free (job);
-                job = NULL;
-        }
+        dirjob_free(job);
+        job = NULL;
+    }
 }
 
-
 struct dirjob *
-dirjob_new (const char *dir, struct dirjob *parent)
+dirjob_new(const char *dir, struct dirjob *parent)
 {
-        struct dirjob *job = NULL;
+    struct dirjob *job = NULL;
 
-        NEW(job);
-        if (!job)
-                return NULL;
+    NEW(job);
+    if (!job)
+        return NULL;
 
-        job->dirname = strdup (dir);
-        if (!job->dirname) {
-                free (job);
-                return NULL;
-        }
+    job->dirname = strdup(dir);
+    if (!job->dirname) {
+        free(job);
+        return NULL;
+    }
 
-        INIT_LIST_HEAD(&job->list);
-        pthread_spin_init (&job->lock, PTHREAD_PROCESS_PRIVATE);
-        job->ret = 0;
+    INIT_LIST_HEAD(&job->list);
+    pthread_spin_init(&job->lock, PTHREAD_PROCESS_PRIVATE);
+    job->ret = 0;
 
-        if (parent)
-                job->parent = dirjob_ref (parent);
+    if (parent)
+        job->parent = dirjob_ref(parent);
 
-        job->refcnt = 1;
+    job->refcnt = 1;
 
-        return job;
+    return job;
 }
 
 void
-xwork_addcrawl (struct xwork *xwork, struct dirjob *job)
+xwork_addcrawl(struct xwork *xwork, struct dirjob *job)
 {
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                list_add_tail (&job->list, &xwork->crawl.list);
-                pthread_cond_broadcast (&xwork->cond);
-        }
-        pthread_mutex_unlock (&xwork->mutex);
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        list_add_tail(&job->list, &xwork->crawl.list);
+        pthread_cond_broadcast(&xwork->cond);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
 }
 
 int
-xwork_add (struct xwork *xwork, const char *dir, struct dirjob *parent)
+xwork_add(struct xwork *xwork, const char *dir, struct dirjob *parent)
 {
-        struct dirjob *job = NULL;
+    struct dirjob *job = NULL;
 
-        job = dirjob_new (dir, parent);
-        if (!job)
-                return -1;
+    job = dirjob_new(dir, parent);
+    if (!job)
+        return -1;
 
-        xwork_addcrawl (xwork, job);
+    xwork_addcrawl(xwork, job);
 
-        return 0;
+    return 0;
 }
 
-
 struct dirjob *
-xwork_pick (struct xwork *xwork, int block)
+xwork_pick(struct xwork *xwork, int block)
 {
-        struct dirjob *job = NULL;
-        struct list_head *head = NULL;
+    struct dirjob *job = NULL;
+    struct list_head *head = NULL;
 
-        head = &xwork->crawl.list;
+    head = &xwork->crawl.list;
 
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                for (;;) {
-                        if (xwork->stop)
-                                break;
-
-                        if (!list_empty (head)) {
-                                job = list_entry (head->next, typeof(*job),
-                                                  list);
-                                list_del_init (&job->list);
-                                break;
-                        }
-
-                        if (((xwork->count * 2) == xwork->idle) &&
-                            list_empty (&xwork->crawl.list)) {
-                                /* no outstanding jobs, and no
-                                   active workers
-                                */
-                                tdbg ("Jobless. Terminating\n");
-                                xwork->stop = 1;
-                                pthread_cond_broadcast (&xwork->cond);
-                                break;
-                        }
-
-                        if (!block)
-                                break;
-
-                        xwork->idle++;
-                        pthread_cond_wait (&xwork->cond, &xwork->mutex);
-                        xwork->idle--;
-                }
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        for (;;) {
+            if (xwork->stop)
+                break;
+
+            if (!list_empty(head)) {
+                job = list_entry(head->next, typeof(*job), list);
+                list_del_init(&job->list);
+                break;
+            }
+
+            if (((xwork->count * 2) == xwork->idle) &&
+                list_empty(&xwork->crawl.list)) {
+                /* no outstanding jobs, and no
+                   active workers
+                */
+                tdbg("Jobless. Terminating\n");
+                xwork->stop = 1;
+                pthread_cond_broadcast(&xwork->cond);
+                break;
+            }
+
+            if (!block)
+                break;
+
+            xwork->idle++;
+            pthread_cond_wait(&xwork->cond, &xwork->mutex);
+            xwork->idle--;
         }
-        pthread_mutex_unlock (&xwork->mutex);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
 
-        return job;
+    return job;
 }
 
 int
-skip_name (const char *dirname, const char *name)
+skip_name(const char *dirname, const char *name)
 {
-        if (strcmp (name, ".") == 0)
-                return 1;
+    if (strcmp(name, ".") == 0)
+        return 1;
 
-        if (strcmp (name, "..") == 0)
-                return 1;
+    if (strcmp(name, "..") == 0)
+        return 1;
 
-        if (strcmp (name, "changelogs") == 0)
-                return 1;
+    if (strcmp(name, "changelogs") == 0)
+        return 1;
 
-        if (strcmp (name, "health_check") == 0)
-                return 1;
+    if (strcmp(name, "health_check") == 0)
+        return 1;
 
-        if (strcmp (name, "indices") == 0)
-                return 1;
+    if (strcmp(name, "indices") == 0)
+        return 1;
 
-        if (strcmp (name, "landfill") == 0)
-                return 1;
+    if (strcmp(name, "landfill") == 0)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
 int
-skip_stat (struct dirjob *job, const char *name)
+skip_stat(struct dirjob *job, const char *name)
 {
-        if (job == NULL)
-                return 0;
-
-        if (strcmp (job->dirname, ".glusterfs") == 0) {
-                tdbg ("Directly adding directories under .glusterfs "
-                      "to global list: %s\n", name);
-                return 1;
-        }
+    if (job == NULL)
+        return 0;
 
-        if (job->parent != NULL) {
-                if (strcmp (job->parent->dirname, ".glusterfs") == 0) {
-                        tdbg ("Directly adding directories under .glusterfs/XX "
-                              "to global list: %s\n", name);
-                        return 1;
-                }
+    if (strcmp(job->dirname, ".glusterfs") == 0) {
+        tdbg(
+            "Directly adding directories under .glusterfs "
+            "to global list: %s\n",
+            name);
+        return 1;
+    }
+
+    if (job->parent != NULL) {
+        if (strcmp(job->parent->dirname, ".glusterfs") == 0) {
+            tdbg(
+                "Directly adding directories under .glusterfs/XX "
+                "to global list: %s\n",
+                name);
+            return 1;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-xworker_do_crawl (struct xwork *xwork, struct dirjob *job)
+xworker_do_crawl(struct xwork *xwork, struct dirjob *job)
 {
-        DIR            *dirp = NULL;
-        int             ret = -1;
-        int             boff;
-        int             plen;
-        char           *path = NULL;
-        struct dirjob  *cjob = NULL;
-        struct stat     statbuf = {0,};
-        struct dirent  *entry;
-        struct dirent   scratch[2] = {{0,},};
-        char            gfid_path[PATH_MAX] = {0,};
-
-
-        plen = strlen (job->dirname) + 256 + 2;
-        path = alloca (plen);
-
-        tdbg ("Entering: %s\n", job->dirname);
-
-        dirp = sys_opendir (job->dirname);
-        if (!dirp) {
-                terr ("opendir failed on %s (%s)\n", job->dirname,
-                     strerror (errno));
+    DIR *dirp = NULL;
+    int ret = -1;
+    int boff;
+    int plen;
+    char *path = NULL;
+    struct dirjob *cjob = NULL;
+    struct stat statbuf = {
+        0,
+    };
+    struct dirent *entry;
+    struct dirent scratch[2] = {
+        {
+            0,
+        },
+    };
+    char gfid_path[PATH_MAX] = {
+        0,
+    };
+
+    plen = strlen(job->dirname) + 256 + 2;
+    path = alloca(plen);
+
+    tdbg("Entering: %s\n", job->dirname);
+
+    dirp = sys_opendir(job->dirname);
+    if (!dirp) {
+        terr("opendir failed on %s (%s)\n", job->dirname, strerror(errno));
+        goto out;
+    }
+
+    boff = sprintf(path, "%s/", job->dirname);
+
+    for (;;) {
+        errno = 0;
+        entry = sys_readdir(dirp, scratch);
+        if (!entry || errno != 0) {
+            if (errno != 0) {
+                err("readdir(%s): %s\n", job->dirname, strerror(errno));
+                ret = errno;
                 goto out;
+            }
+            break;
         }
 
-        boff = sprintf (path, "%s/", job->dirname);
+        if (entry->d_ino == 0)
+            continue;
+
+        if (skip_name(job->dirname, entry->d_name))
+            continue;
+
+        /* It is sure that, children and grandchildren of .glusterfs
+         * are directories, just add them to global queue.
+         */
+        if (skip_stat(job, entry->d_name)) {
+            strncpy(path + boff, entry->d_name, (plen - boff));
+            cjob = dirjob_new(path, job);
+            if (!cjob) {
+                err("dirjob_new(%s): %s\n", path, strerror(errno));
+                ret = -1;
+                goto out;
+            }
+            xwork_addcrawl(xwork, cjob);
+            continue;
+        }
 
-        for (;;) {
-                errno = 0;
-                entry = sys_readdir (dirp, scratch);
-                if (!entry || errno != 0) {
-                        if (errno != 0) {
-                                err ("readdir(%s): %s\n", job->dirname,
-                                     strerror (errno));
-                                ret = errno;
-                                goto out;
-                        }
-                        break;
-                }
-
-                if (entry->d_ino == 0)
-                        continue;
-
-                if (skip_name (job->dirname, entry->d_name))
-                        continue;
-
-                /* It is sure that, children and grandchildren of .glusterfs
-                 * are directories, just add them to global queue.
-                 */
-                if (skip_stat (job, entry->d_name)) {
-                        strncpy (path + boff, entry->d_name, (plen-boff));
-                        cjob = dirjob_new (path, job);
-                        if (!cjob) {
-                                err ("dirjob_new(%s): %s\n",
-                                     path, strerror (errno));
-                                ret = -1;
-                                goto out;
-                        }
-                        xwork_addcrawl (xwork, cjob);
-                        continue;
-                }
-
-                (void) snprintf (gfid_path, sizeof(gfid_path), "%s/.gfid/%s",
-                                 slavemnt, entry->d_name);
-                ret = sys_lstat (gfid_path, &statbuf);
-
-                if (ret && errno == ENOENT) {
-                        out ("%s\n", entry->d_name);
-                        BUMP (skipped_gfids);
-                }
-
-                if (ret && errno != ENOENT) {
-                        err ("stat on slave failed(%s): %s\n",
-                             gfid_path, strerror (errno));
-                        goto out;
-                }
+        (void)snprintf(gfid_path, sizeof(gfid_path), "%s/.gfid/%s", slavemnt,
+                       entry->d_name);
+        ret = sys_lstat(gfid_path, &statbuf);
+
+        if (ret && errno == ENOENT) {
+            out("%s\n", entry->d_name);
+            BUMP(skipped_gfids);
+        }
+
+        if (ret && errno != ENOENT) {
+            err("stat on slave failed(%s): %s\n", gfid_path, strerror(errno));
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (dirp)
-                (void) sys_closedir (dirp);
+    if (dirp)
+        (void)sys_closedir(dirp);
 
-        return ret;
+    return ret;
 }
 
-
 void *
-xworker_crawl (void *data)
+xworker_crawl(void *data)
 {
-        struct xwork *xwork = data;
-        struct dirjob *job = NULL;
-        int            ret = -1;
+    struct xwork *xwork = data;
+    struct dirjob *job = NULL;
+    int ret = -1;
 
-        while ((job = xwork_pick (xwork, 0))) {
-                ret = xworker_do_crawl (xwork, job);
-                dirjob_ret (job, ret);
-        }
+    while ((job = xwork_pick(xwork, 0))) {
+        ret = xworker_do_crawl(xwork, job);
+        dirjob_ret(job, ret);
+    }
 
-        return NULL;
+    return NULL;
 }
 
 int
-xwork_fini (struct xwork *xwork, int stop)
+xwork_fini(struct xwork *xwork, int stop)
 {
-        int i = 0;
-        int ret = 0;
-        void *tret = 0;
-
-        pthread_mutex_lock (&xwork->mutex);
-        {
-                xwork->stop = (xwork->stop || stop);
-                pthread_cond_broadcast (&xwork->cond);
-        }
-        pthread_mutex_unlock (&xwork->mutex);
-
-        for (i = 0; i < xwork->count; i++) {
-                pthread_join (xwork->cthreads[i], &tret);
-                tdbg ("CThread id %ld returned %p\n",
-                      xwork->cthreads[i], tret);
-        }
-
-        if (debug) {
-                assert (xwork->rootjob->refcnt == 1);
-                dirjob_ret (xwork->rootjob, 0);
-        }
-
-        if (stats)
-                pthread_spin_destroy(&stats_lock);
-
-        return ret;
+    int i = 0;
+    int ret = 0;
+    void *tret = 0;
+
+    pthread_mutex_lock(&xwork->mutex);
+    {
+        xwork->stop = (xwork->stop || stop);
+        pthread_cond_broadcast(&xwork->cond);
+    }
+    pthread_mutex_unlock(&xwork->mutex);
+
+    for (i = 0; i < xwork->count; i++) {
+        pthread_join(xwork->cthreads[i], &tret);
+        tdbg("CThread id %ld returned %p\n", xwork->cthreads[i], tret);
+    }
+
+    if (debug) {
+        assert(xwork->rootjob->refcnt == 1);
+        dirjob_ret(xwork->rootjob, 0);
+    }
+
+    if (stats)
+        pthread_spin_destroy(&stats_lock);
+
+    return ret;
 }
 
-
 int
-xwork_init (struct xwork *xwork, int count)
+xwork_init(struct xwork *xwork, int count)
 {
-        int  i = 0;
-        int  ret = 0;
-        struct dirjob *rootjob = NULL;
+    int i = 0;
+    int ret = 0;
+    struct dirjob *rootjob = NULL;
 
-        if (stats)
-                pthread_spin_init (&stats_lock, PTHREAD_PROCESS_PRIVATE);
+    if (stats)
+        pthread_spin_init(&stats_lock, PTHREAD_PROCESS_PRIVATE);
 
-        pthread_mutex_init (&xwork->mutex, NULL);
-        pthread_cond_init (&xwork->cond, NULL);
+    pthread_mutex_init(&xwork->mutex, NULL);
+    pthread_cond_init(&xwork->cond, NULL);
 
-        INIT_LIST_HEAD (&xwork->crawl.list);
+    INIT_LIST_HEAD(&xwork->crawl.list);
 
-        rootjob = dirjob_new (".glusterfs", NULL);
-        if (debug)
-                xwork->rootjob = dirjob_ref (rootjob);
+    rootjob = dirjob_new(".glusterfs", NULL);
+    if (debug)
+        xwork->rootjob = dirjob_ref(rootjob);
 
-        xwork_addcrawl (xwork, rootjob);
+    xwork_addcrawl(xwork, rootjob);
 
-        xwork->count = count;
-        for (i = 0; i < count; i++) {
-                ret = pthread_create (&xwork->cthreads[i], NULL,
-                                      xworker_crawl, xwork);
-                if (ret)
-                        break;
-                tdbg ("Spawned crawler %d thread %ld\n", i,
-                      xwork->cthreads[i]);
-        }
+    xwork->count = count;
+    for (i = 0; i < count; i++) {
+        ret = pthread_create(&xwork->cthreads[i], NULL, xworker_crawl, xwork);
+        if (ret)
+            break;
+        tdbg("Spawned crawler %d thread %ld\n", i, xwork->cthreads[i]);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-xfind (const char *basedir)
+xfind(const char *basedir)
 {
-        struct xwork xwork;
-        int          ret = 0;
-        char         *cwd = NULL;
-
-        ret = chdir (basedir);
-        if (ret) {
-                err ("%s: %s\n", basedir, strerror (errno));
-                return ret;
-        }
+    struct xwork xwork;
+    int ret = 0;
+    char *cwd = NULL;
 
-        cwd = getcwd (0, 0);
-        if (!cwd) {
-                err ("getcwd(): %s\n", strerror (errno));
-                return -1;
-        }
+    ret = chdir(basedir);
+    if (ret) {
+        err("%s: %s\n", basedir, strerror(errno));
+        return ret;
+    }
 
-        tdbg ("Working directory: %s\n", cwd);
-        free (cwd);
+    cwd = getcwd(0, 0);
+    if (!cwd) {
+        err("getcwd(): %s\n", strerror(errno));
+        return -1;
+    }
 
-        memset (&xwork, 0, sizeof (xwork));
+    tdbg("Working directory: %s\n", cwd);
+    free(cwd);
 
-        ret = xwork_init (&xwork, workers);
-        if (ret == 0)
-                xworker_crawl (&xwork);
+    memset(&xwork, 0, sizeof(xwork));
 
-        ret = xwork_fini (&xwork, ret);
-        stats_dump ();
+    ret = xwork_init(&xwork, workers);
+    if (ret == 0)
+        xworker_crawl(&xwork);
 
-        return ret;
+    ret = xwork_fini(&xwork, ret);
+    stats_dump();
+
+    return ret;
 }
 
 static char *
-parse_and_validate_args (int argc, char *argv[])
+parse_and_validate_args(int argc, char *argv[])
 {
-        char        *basedir = NULL;
-        struct stat  d = {0, };
-        int          ret = -1;
+    char *basedir = NULL;
+    struct stat d = {
+        0,
+    };
+    int ret = -1;
 #ifndef __FreeBSD__
-        unsigned char volume_id[16];
+    unsigned char volume_id[16];
 #endif /* __FreeBSD__ */
-        char        *slv_mnt = NULL;
+    char *slv_mnt = NULL;
 
-        if (argc != 4) {
-                err ("Usage: %s <DIR> <SLAVE-VOL-MOUNT> <CRAWL-THREAD-COUNT>\n",
-                      argv[0]);
-                return NULL;
-        }
+    if (argc != 4) {
+        err("Usage: %s <DIR> <SLAVE-VOL-MOUNT> <CRAWL-THREAD-COUNT>\n",
+            argv[0]);
+        return NULL;
+    }
 
-        basedir = argv[1];
-        ret = sys_lstat (basedir, &d);
-        if (ret) {
-                err ("%s: %s\n", basedir, strerror (errno));
-                return NULL;
-        }
+    basedir = argv[1];
+    ret = sys_lstat(basedir, &d);
+    if (ret) {
+        err("%s: %s\n", basedir, strerror(errno));
+        return NULL;
+    }
 
 #ifndef __FreeBSD__
-        ret = sys_lgetxattr (basedir, "trusted.glusterfs.volume-id",
-                             volume_id, 16);
-        if (ret != 16) {
-                err ("%s:Not a valid brick path.\n", basedir);
-                return NULL;
-        }
+    ret = sys_lgetxattr(basedir, "trusted.glusterfs.volume-id", volume_id, 16);
+    if (ret != 16) {
+        err("%s:Not a valid brick path.\n", basedir);
+        return NULL;
+    }
 #endif /* __FreeBSD__ */
 
-        slv_mnt = argv[2];
-        ret = sys_lstat (slv_mnt, &d);
-        if (ret) {
-                err ("%s: %s\n", slv_mnt, strerror (errno));
-                return NULL;
-        }
-        slavemnt = argv[2];
+    slv_mnt = argv[2];
+    ret = sys_lstat(slv_mnt, &d);
+    if (ret) {
+        err("%s: %s\n", slv_mnt, strerror(errno));
+        return NULL;
+    }
+    slavemnt = argv[2];
 
-        workers = atoi(argv[3]);
-        if (workers <= 0)
-                workers = DEFAULT_WORKERS;
+    workers = atoi(argv[3]);
+    if (workers <= 0)
+        workers = DEFAULT_WORKERS;
 
-        return basedir;
+    return basedir;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        char *basedir = NULL;
+    char *basedir = NULL;
 
-        basedir = parse_and_validate_args (argc, argv);
-        if (!basedir)
-                return 1;
+    basedir = parse_and_validate_args(argc, argv);
+    if (!basedir)
+        return 1;
 
-        xfind (basedir);
+    xfind(basedir);
 
-        return 0;
+    return 0;
 }
diff --git a/tools/setgfid2path/src/main.c b/tools/setgfid2path/src/main.c
index dfa561f4f51..c9e71c12815 100644
--- a/tools/setgfid2path/src/main.c
+++ b/tools/setgfid2path/src/main.c
@@ -17,112 +17,114 @@
 #define GFID_SIZE 16
 #define GFID_XATTR_KEY "trusted.gfid"
 
-
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-        int             ret                               = 0;
-        struct stat     st;
-        char           *dname                             = NULL;
-        char           *bname                             = NULL;
-        ssize_t         ret_size                          = 0;
-        uuid_t          pgfid_raw                         = {0,};
-        char            pgfid[36]                         = "";
-        char            xxh64[GF_XXH64_DIGEST_LENGTH*2+1] = {0,};
-        char            pgfid_bname[1024]                 = {0,};
-        char           *key                               = NULL;
-        char           *val                               = NULL;
-        size_t          key_size                          = 0;
-        size_t          val_size                          = 0;
-        const char     *file_path                         = NULL;
-        char           *file_path1                        = NULL;
-        char           *file_path2                        = NULL;
-
-        if (argc != 2) {
-                fprintf (stderr, "Usage: setgfid2path <file-path>\n");
-                return -1;
-        }
-
-        ret = sys_lstat (argv[1], &st);
-        if (ret != 0) {
-                fprintf (stderr, "Invalid File Path\n");
-                return -1;
-        }
-
-        if (st.st_nlink >= MAX_GFID2PATH_LINK_SUP) {
-                fprintf (stderr,
-                         "Number of Hardlink support exceeded. "
-                         "max=%d\n", MAX_GFID2PATH_LINK_SUP);
-                return -1;
+    int ret = 0;
+    struct stat st;
+    char *dname = NULL;
+    char *bname = NULL;
+    ssize_t ret_size = 0;
+    uuid_t pgfid_raw = {
+        0,
+    };
+    char pgfid[36] = "";
+    char xxh64[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
+        0,
+    };
+    char pgfid_bname[1024] = {
+        0,
+    };
+    char *key = NULL;
+    char *val = NULL;
+    size_t key_size = 0;
+    size_t val_size = 0;
+    const char *file_path = NULL;
+    char *file_path1 = NULL;
+    char *file_path2 = NULL;
+
+    if (argc != 2) {
+        fprintf(stderr, "Usage: setgfid2path <file-path>\n");
+        return -1;
+    }
+
+    ret = sys_lstat(argv[1], &st);
+    if (ret != 0) {
+        fprintf(stderr, "Invalid File Path\n");
+        return -1;
+    }
+
+    if (st.st_nlink >= MAX_GFID2PATH_LINK_SUP) {
+        fprintf(stderr,
+                "Number of Hardlink support exceeded. "
+                "max=%d\n",
+                MAX_GFID2PATH_LINK_SUP);
+        return -1;
+    }
+
+    file_path = argv[1];
+    file_path1 = strdup(file_path);
+    file_path2 = strdup(file_path);
+
+    dname = dirname(file_path1);
+    bname = basename(file_path2);
+
+    /* Get GFID of Parent directory */
+    ret_size = sys_lgetxattr(dname, GFID_XATTR_KEY, pgfid_raw, GFID_SIZE);
+    if (ret_size != GFID_SIZE) {
+        fprintf(stderr, "Failed to get GFID of parent directory. dir=%s\n",
+                dname);
+        ret = -1;
+        goto out;
+    }
+
+    /* Convert to UUID format */
+    if (uuid_utoa_r(pgfid_raw, pgfid) == NULL) {
+        fprintf(stderr,
+                "Failed to format GFID of parent directory. "
+                "dir=%s GFID=%s\n",
+                dname, pgfid_raw);
+        ret = -1;
+        goto out;
+    }
+
+    /* Find xxhash for PGFID/BaseName */
+    snprintf(pgfid_bname, sizeof(pgfid_bname), "%s/%s", pgfid, bname);
+    gf_xxh64_wrapper((unsigned char *)pgfid_bname, strlen(pgfid_bname),
+                     GF_XXHSUM64_DEFAULT_SEED, xxh64);
+
+    key_size = SLEN(GFID2PATH_XATTR_KEY_PREFIX) + GF_XXH64_DIGEST_LENGTH * 2 +
+               1;
+    key = alloca(key_size);
+    snprintf(key, key_size, GFID2PATH_XATTR_KEY_PREFIX "%s", xxh64);
+
+    val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2;
+    val = alloca(val_size);
+    snprintf(val, val_size, "%s/%s", pgfid, bname);
+
+    /* Set the Xattr, ignore if same key xattr already exists */
+    ret = sys_lsetxattr(file_path, key, val, strlen(val), XATTR_CREATE);
+    if (ret == -1) {
+        if (errno == EEXIST) {
+            printf("Xattr already exists, ignoring..\n");
+            ret = 0;
+            goto out;
         }
 
-        file_path = argv[1];
-        file_path1 = strdup (file_path);
-        file_path2 = strdup (file_path);
-
-        dname = dirname (file_path1);
-        bname = basename (file_path2);
-
-        /* Get GFID of Parent directory */
-        ret_size = sys_lgetxattr (dname, GFID_XATTR_KEY, pgfid_raw, GFID_SIZE);
-        if (ret_size != GFID_SIZE) {
-                fprintf (stderr,
-                         "Failed to get GFID of parent directory. dir=%s\n",
-                         dname);
-                ret = -1;
-                goto out;
-        }
-
-        /* Convert to UUID format */
-        if (uuid_utoa_r (pgfid_raw, pgfid) == NULL) {
-                fprintf (stderr,
-                         "Failed to format GFID of parent directory. "
-                         "dir=%s GFID=%s\n", dname, pgfid_raw);
-                ret = -1;
-                goto out;
-        }
-
-        /* Find xxhash for PGFID/BaseName */
-        snprintf (pgfid_bname, sizeof (pgfid_bname), "%s/%s", pgfid, bname);
-        gf_xxh64_wrapper (
-                        (unsigned char *)pgfid_bname,
-                        strlen (pgfid_bname),
-                        GF_XXHSUM64_DEFAULT_SEED,
-                        xxh64
-                        );
-
-        key_size = SLEN (GFID2PATH_XATTR_KEY_PREFIX) +
-                GF_XXH64_DIGEST_LENGTH*2+1;
-        key = alloca (key_size);
-        snprintf (key, key_size, GFID2PATH_XATTR_KEY_PREFIX"%s", xxh64);
-
-        val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2;
-        val = alloca (val_size);
-        snprintf (val, val_size, "%s/%s", pgfid, bname);
-
-        /* Set the Xattr, ignore if same key xattr already exists */
-        ret = sys_lsetxattr (file_path, key, val, strlen(val), XATTR_CREATE);
-        if (ret == -1) {
-                if (errno == EEXIST) {
-                        printf ("Xattr already exists, ignoring..\n");
-                        ret = 0;
-                        goto out;
-                }
-
-                fprintf (stderr,
-                         "Failed to set gfid2path xattr. errno=%d\n error=%s",
-                         errno, strerror(errno));
-                ret = -1;
-                goto out;
-        }
+        fprintf(stderr, "Failed to set gfid2path xattr. errno=%d\n error=%s",
+                errno, strerror(errno));
+        ret = -1;
+        goto out;
+    }
 
-        printf ("Success. file=%s key=%s value=%s\n", file_path, key, val);
+    printf("Success. file=%s key=%s value=%s\n", file_path, key, val);
 
 out:
-        if (file_path1 != NULL)
-                free (file_path1);
+    if (file_path1 != NULL)
+        free(file_path1);
 
-        if (file_path2 != NULL)
-                free (file_path2);
+    if (file_path2 != NULL)
+        free(file_path2);
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-common.c b/xlators/cluster/afr/src/afr-common.c
index 3a32ebc31a4..eb0e7330a91 100644
--- a/xlators/cluster/afr/src/afr-common.c
+++ b/xlators/cluster/afr/src/afr-common.c
@@ -42,157 +42,155 @@
 #include "afr-messages.h"
 
 int32_t
-afr_quorum_errno (afr_private_t *priv)
+afr_quorum_errno(afr_private_t *priv)
 {
-        return ENOTCONN;
+    return ENOTCONN;
 }
 
 int
-afr_fav_child_reset_sink_xattrs (void *opaque);
+afr_fav_child_reset_sink_xattrs(void *opaque);
 
 int
-afr_fav_child_reset_sink_xattrs_cbk (int ret, call_frame_t *frame,
-                                     void *opaque);
+afr_fav_child_reset_sink_xattrs_cbk(int ret, call_frame_t *frame, void *opaque);
 
 static void
-afr_discover_done (call_frame_t *frame, xlator_t *this);
+afr_discover_done(call_frame_t *frame, xlator_t *this);
 
 gf_boolean_t
-afr_is_consistent_io_possible (afr_local_t *local, afr_private_t *priv,
-                               int32_t *op_errno)
-{
-        if (priv->consistent_io && local->call_count != priv->child_count) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0,
-                        AFR_MSG_SUBVOLS_DOWN, "All subvolumes are not up");
-                if (op_errno)
-                        *op_errno = ENOTCONN;
-                return _gf_false;
-        }
-        return _gf_true;
+afr_is_consistent_io_possible(afr_local_t *local, afr_private_t *priv,
+                              int32_t *op_errno)
+{
+    if (priv->consistent_io && local->call_count != priv->child_count) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOLS_DOWN,
+               "All subvolumes are not up");
+        if (op_errno)
+            *op_errno = ENOTCONN;
+        return _gf_false;
+    }
+    return _gf_true;
 }
 
 call_frame_t *
-afr_copy_frame (call_frame_t *base)
+afr_copy_frame(call_frame_t *base)
 {
-	afr_local_t *local = NULL;
-	call_frame_t *frame = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    int op_errno = 0;
 
-	frame = copy_frame (base);
-	if (!frame)
-		return NULL;
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local) {
-		AFR_STACK_DESTROY (frame);
-		return NULL;
-	}
+    frame = copy_frame(base);
+    if (!frame)
+        return NULL;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local) {
+        AFR_STACK_DESTROY(frame);
+        return NULL;
+    }
 
-	return frame;
+    return frame;
 }
 
 /* Check if an entry or inode could be undergoing a transaction. */
 gf_boolean_t
-afr_is_possibly_under_txn (afr_transaction_type type, afr_local_t *local,
-                           xlator_t *this)
-{
-        int i = 0;
-        int tmp = 0;
-	afr_private_t *priv = NULL;
-        GF_UNUSED char *key = NULL;
-
-        priv = this->private;
-
-        if (type == AFR_ENTRY_TRANSACTION)
-                key = GLUSTERFS_PARENT_ENTRYLK;
-        else if (type == AFR_DATA_TRANSACTION)
-                /*FIXME: Use GLUSTERFS_INODELK_DOM_COUNT etc. once
-                 * pl_inodelk_xattr_fill supports separate keys for different
-                 * domains.*/
-                key = GLUSTERFS_INODELK_COUNT;
-
-        for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].xdata)
-			continue;
-		if (dict_get_int32 (local->replies[i].xdata, key, &tmp) == 0)
-			if (tmp)
-				return _gf_true;
-	}
+afr_is_possibly_under_txn(afr_transaction_type type, afr_local_t *local,
+                          xlator_t *this)
+{
+    int i = 0;
+    int tmp = 0;
+    afr_private_t *priv = NULL;
+    GF_UNUSED char *key = NULL;
+
+    priv = this->private;
+
+    if (type == AFR_ENTRY_TRANSACTION)
+        key = GLUSTERFS_PARENT_ENTRYLK;
+    else if (type == AFR_DATA_TRANSACTION)
+        /*FIXME: Use GLUSTERFS_INODELK_DOM_COUNT etc. once
+         * pl_inodelk_xattr_fill supports separate keys for different
+         * domains.*/
+        key = GLUSTERFS_INODELK_COUNT;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].xdata)
+            continue;
+        if (dict_get_int32(local->replies[i].xdata, key, &tmp) == 0)
+            if (tmp)
+                return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static void
-afr_inode_ctx_destroy (afr_inode_ctx_t *ctx)
+afr_inode_ctx_destroy(afr_inode_ctx_t *ctx)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!ctx)
-                return;
+    if (!ctx)
+        return;
 
-        for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
-                GF_FREE (ctx->pre_op_done[i]);
-        }
+    for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+        GF_FREE(ctx->pre_op_done[i]);
+    }
 
-        GF_FREE (ctx);
+    GF_FREE(ctx);
 }
 
 int
-__afr_inode_ctx_get (xlator_t *this, inode_t *inode, afr_inode_ctx_t **ctx)
-{
-        uint64_t        ctx_int   = 0;
-        int             ret       = -1;
-        int             i         = -1;
-        int             num_locks = -1;
-        afr_inode_ctx_t *ictx     = NULL;
-        afr_lock_t      *lock     = NULL;
-        afr_private_t   *priv     = this->private;
-
-        ret = __inode_ctx_get (inode, this, &ctx_int);
-        if (ret == 0) {
-                *ctx = (afr_inode_ctx_t *)ctx_int;
-                return 0;
-        }
-
-        ictx = GF_CALLOC (1, sizeof (afr_inode_ctx_t), gf_afr_mt_inode_ctx_t);
-        if (!ictx)
-                goto out;
-
-        for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
-                ictx->pre_op_done[i] = GF_CALLOC (sizeof *ictx->pre_op_done[i],
-                                                  priv->child_count,
-                                                  gf_afr_mt_int32_t);
-                if (!ictx->pre_op_done[i]) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
-        }
-
-        num_locks = sizeof(ictx->lock)/sizeof(afr_lock_t);
-        for (i = 0; i < num_locks; i++) {
-                lock = &ictx->lock[i];
-                INIT_LIST_HEAD (&lock->post_op);
-                INIT_LIST_HEAD (&lock->frozen);
-                INIT_LIST_HEAD (&lock->waiting);
-                INIT_LIST_HEAD (&lock->owners);
-        }
-
-        ctx_int = (uint64_t)ictx;
-        ret = __inode_ctx_set (inode, this, &ctx_int);
-        if (ret) {
-                goto out;
-        }
-
-        ictx->spb_choice = -1;
-        ictx->read_subvol = 0;
-        ictx->write_subvol = 0;
-        ictx->lock_count = 0;
-        ret = 0;
-        *ctx = ictx;
+__afr_inode_ctx_get(xlator_t *this, inode_t *inode, afr_inode_ctx_t **ctx)
+{
+    uint64_t ctx_int = 0;
+    int ret = -1;
+    int i = -1;
+    int num_locks = -1;
+    afr_inode_ctx_t *ictx = NULL;
+    afr_lock_t *lock = NULL;
+    afr_private_t *priv = this->private;
+
+    ret = __inode_ctx_get(inode, this, &ctx_int);
+    if (ret == 0) {
+        *ctx = (afr_inode_ctx_t *)ctx_int;
+        return 0;
+    }
+
+    ictx = GF_CALLOC(1, sizeof(afr_inode_ctx_t), gf_afr_mt_inode_ctx_t);
+    if (!ictx)
+        goto out;
+
+    for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+        ictx->pre_op_done[i] = GF_CALLOC(sizeof *ictx->pre_op_done[i],
+                                         priv->child_count, gf_afr_mt_int32_t);
+        if (!ictx->pre_op_done[i]) {
+            ret = -ENOMEM;
+            goto out;
+        }
+    }
+
+    num_locks = sizeof(ictx->lock) / sizeof(afr_lock_t);
+    for (i = 0; i < num_locks; i++) {
+        lock = &ictx->lock[i];
+        INIT_LIST_HEAD(&lock->post_op);
+        INIT_LIST_HEAD(&lock->frozen);
+        INIT_LIST_HEAD(&lock->waiting);
+        INIT_LIST_HEAD(&lock->owners);
+    }
+
+    ctx_int = (uint64_t)ictx;
+    ret = __inode_ctx_set(inode, this, &ctx_int);
+    if (ret) {
+        goto out;
+    }
+
+    ictx->spb_choice = -1;
+    ictx->read_subvol = 0;
+    ictx->write_subvol = 0;
+    ictx->lock_count = 0;
+    ret = 0;
+    *ctx = ictx;
 out:
-        if (ret) {
-                afr_inode_ctx_destroy (ictx);
-        }
-        return ret;
+    if (ret) {
+        afr_inode_ctx_destroy(ictx);
+    }
+    return ret;
 }
 
 /*
@@ -226,1723 +224,1670 @@ out:
  */
 
 int
-__afr_set_in_flight_sb_status (xlator_t *this, afr_local_t *local,
-                               inode_t *inode)
-{
-        int                 i               = 0;
-        int                 txn_type        = 0;
-        int                 count           = 0;
-        int                 index           = -1;
-        uint16_t            datamap_old     = 0;
-        uint16_t            metadatamap_old = 0;
-        uint16_t            datamap         = 0;
-        uint16_t            metadatamap     = 0;
-        uint16_t            tmp_map         = 0;
-        uint16_t            mask            = 0;
-        uint32_t            event           = 0;
-        uint64_t            val             = 0;
-        afr_private_t      *priv            = NULL;
-
-        priv = this->private;
-        txn_type = local->transaction.type;
-
-        if (txn_type == AFR_DATA_TRANSACTION)
-                val = local->inode_ctx->write_subvol;
-        else
-                val = local->inode_ctx->read_subvol;
-
-        metadatamap_old = metadatamap = (val & 0x000000000000ffff);
-        datamap_old = datamap = (val & 0x00000000ffff0000) >> 16;
-        event = (val & 0xffffffff00000000) >> 32;
-
-        if (txn_type == AFR_DATA_TRANSACTION)
-                tmp_map = datamap;
-        else if (txn_type == AFR_METADATA_TRANSACTION)
-                tmp_map = metadatamap;
-
-        count = gf_bits_count (tmp_map);
-
-        if (count == 1)
-                index = gf_bits_index (tmp_map);
-
-        for (i = 0; i < priv->child_count; i++) {
-                mask = 0;
-                if (!local->transaction.failed_subvols[i])
-                        continue;
-
-                mask = 1 << i;
-                if (txn_type == AFR_METADATA_TRANSACTION)
-                        metadatamap &= ~mask;
-                else if (txn_type == AFR_DATA_TRANSACTION)
-                        datamap &= ~mask;
-        }
-
-        switch (txn_type) {
+__afr_set_in_flight_sb_status(xlator_t *this, afr_local_t *local,
+                              inode_t *inode)
+{
+    int i = 0;
+    int txn_type = 0;
+    int count = 0;
+    int index = -1;
+    uint16_t datamap_old = 0;
+    uint16_t metadatamap_old = 0;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint16_t tmp_map = 0;
+    uint16_t mask = 0;
+    uint32_t event = 0;
+    uint64_t val = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    txn_type = local->transaction.type;
+
+    if (txn_type == AFR_DATA_TRANSACTION)
+        val = local->inode_ctx->write_subvol;
+    else
+        val = local->inode_ctx->read_subvol;
+
+    metadatamap_old = metadatamap = (val & 0x000000000000ffff);
+    datamap_old = datamap = (val & 0x00000000ffff0000) >> 16;
+    event = (val & 0xffffffff00000000) >> 32;
+
+    if (txn_type == AFR_DATA_TRANSACTION)
+        tmp_map = datamap;
+    else if (txn_type == AFR_METADATA_TRANSACTION)
+        tmp_map = metadatamap;
+
+    count = gf_bits_count(tmp_map);
+
+    if (count == 1)
+        index = gf_bits_index(tmp_map);
+
+    for (i = 0; i < priv->child_count; i++) {
+        mask = 0;
+        if (!local->transaction.failed_subvols[i])
+            continue;
+
+        mask = 1 << i;
+        if (txn_type == AFR_METADATA_TRANSACTION)
+            metadatamap &= ~mask;
+        else if (txn_type == AFR_DATA_TRANSACTION)
+            datamap &= ~mask;
+    }
+
+    switch (txn_type) {
         case AFR_METADATA_TRANSACTION:
-                if ((metadatamap_old != 0) && (metadatamap == 0) &&
-                    (count == 1)) {
-                        local->transaction.in_flight_sb_errno =
-                                                local->replies[index].op_errno;
-                        local->transaction.in_flight_sb = _gf_true;
-                        metadatamap |= (1 << index);
-                }
-                if (metadatamap_old != metadatamap) {
-                        event = 0;
-                }
-                break;
+            if ((metadatamap_old != 0) && (metadatamap == 0) && (count == 1)) {
+                local->transaction.in_flight_sb_errno = local->replies[index]
+                                                            .op_errno;
+                local->transaction.in_flight_sb = _gf_true;
+                metadatamap |= (1 << index);
+            }
+            if (metadatamap_old != metadatamap) {
+                event = 0;
+            }
+            break;
 
         case AFR_DATA_TRANSACTION:
-                if ((datamap_old != 0) && (datamap == 0) && (count == 1)) {
-                        local->transaction.in_flight_sb_errno =
-                                                local->replies[index].op_errno;
-                        local->transaction.in_flight_sb = _gf_true;
-                        datamap |= (1 << index);
-                }
-                if (datamap_old != datamap)
-                        event = 0;
-                break;
+            if ((datamap_old != 0) && (datamap == 0) && (count == 1)) {
+                local->transaction.in_flight_sb_errno = local->replies[index]
+                                                            .op_errno;
+                local->transaction.in_flight_sb = _gf_true;
+                datamap |= (1 << index);
+            }
+            if (datamap_old != datamap)
+                event = 0;
+            break;
 
         default:
-                break;
-        }
+            break;
+    }
 
-        val = ((uint64_t) metadatamap) |
-                (((uint64_t) datamap) << 16) |
-                (((uint64_t) event) << 32);
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
 
-        if (txn_type == AFR_DATA_TRANSACTION)
-                local->inode_ctx->write_subvol = val;
-        local->inode_ctx->read_subvol = val;
+    if (txn_type == AFR_DATA_TRANSACTION)
+        local->inode_ctx->write_subvol = val;
+    local->inode_ctx->read_subvol = val;
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_is_symmetric_error (call_frame_t *frame, xlator_t *this)
+afr_is_symmetric_error(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int op_errno = 0;
-        int i_errno = 0;
-        gf_boolean_t matching_errors = _gf_true;
-        int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int op_errno = 0;
+    int i_errno = 0;
+    gf_boolean_t matching_errors = _gf_true;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-                if (local->replies[i].op_ret != -1) {
-                        /* Operation succeeded on at least one subvol,
-                           so it is not a failed-everywhere situation.
-                        */
-                        matching_errors = _gf_false;
-                        break;
-                }
-                i_errno = local->replies[i].op_errno;
-
-                if (i_errno == ENOTCONN) {
-                        /* ENOTCONN is not a symmetric error. We do not
-                           know if the operation was performed on the
-                           backend or not.
-                        */
-                        matching_errors = _gf_false;
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret != -1) {
+            /* Operation succeeded on at least one subvol,
+               so it is not a failed-everywhere situation.
+            */
+            matching_errors = _gf_false;
+            break;
+        }
+        i_errno = local->replies[i].op_errno;
 
-                if (!op_errno) {
-                        op_errno = i_errno;
-                } else if (op_errno != i_errno) {
-                        /* Mismatching op_errno's */
-                        matching_errors = _gf_false;
-                        break;
-                }
+        if (i_errno == ENOTCONN) {
+            /* ENOTCONN is not a symmetric error. We do not
+               know if the operation was performed on the
+               backend or not.
+            */
+            matching_errors = _gf_false;
+            break;
+        }
+
+        if (!op_errno) {
+            op_errno = i_errno;
+        } else if (op_errno != i_errno) {
+            /* Mismatching op_errno's */
+            matching_errors = _gf_false;
+            break;
         }
+    }
 
-        return matching_errors;
+    return matching_errors;
 }
 
 int
-afr_set_in_flight_sb_status (xlator_t *this, call_frame_t *frame,
-                             inode_t *inode)
+afr_set_in_flight_sb_status(xlator_t *this, call_frame_t *frame, inode_t *inode)
 {
-        int           ret    = -1;
-        afr_private_t *priv  = NULL;
-        afr_local_t   *local = NULL;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        /* If this transaction saw no failures, then exit. */
-        if (AFR_COUNT (local->transaction.failed_subvols,
-                       priv->child_count) == 0)
-                return 0;
+    /* If this transaction saw no failures, then exit. */
+    if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count) == 0)
+        return 0;
 
-        if (afr_is_symmetric_error (frame, this))
-                return 0;
+    if (afr_is_symmetric_error(frame, this))
+        return 0;
 
-        LOCK (&inode->lock);
-        {
-                ret = __afr_set_in_flight_sb_status (this, local, inode);
-        }
-        UNLOCK (&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_set_in_flight_sb_status(this, local, inode);
+    }
+    UNLOCK(&inode->lock);
 
-        return ret;
+    return ret;
 }
 
 int
-__afr_inode_read_subvol_get_small (inode_t *inode, xlator_t *this,
-				   unsigned char *data, unsigned char *metadata,
-				   int *event_p)
-{
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	uint16_t datamap = 0;
-	uint16_t metadatamap = 0;
-	uint32_t event = 0;
-	uint64_t val = 0;
-	int i = 0;
-        afr_inode_ctx_t *ctx = NULL;
-
-	priv = this->private;
-
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-	if (ret < 0)
-		return ret;
+__afr_inode_read_subvol_get_small(inode_t *inode, xlator_t *this,
+                                  unsigned char *data, unsigned char *metadata,
+                                  int *event_p)
+{
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint32_t event = 0;
+    uint64_t val = 0;
+    int i = 0;
+    afr_inode_ctx_t *ctx = NULL;
+
+    priv = this->private;
+
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret < 0)
+        return ret;
 
-        val = ctx->read_subvol;
+    val = ctx->read_subvol;
 
-	metadatamap = (val & 0x000000000000ffff);
-	datamap =     (val & 0x00000000ffff0000) >> 16;
-	event =       (val & 0xffffffff00000000) >> 32;
+    metadatamap = (val & 0x000000000000ffff);
+    datamap = (val & 0x00000000ffff0000) >> 16;
+    event = (val & 0xffffffff00000000) >> 32;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (metadata)
-			metadata[i] = (metadatamap >> i) & 1;
-		if (data)
-			data[i] = (datamap >> i) & 1;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (metadata)
+            metadata[i] = (metadatamap >> i) & 1;
+        if (data)
+            data[i] = (datamap >> i) & 1;
+    }
 
-	if (event_p)
-		*event_p = event;
-	return ret;
+    if (event_p)
+        *event_p = event;
+    return ret;
 }
 
-
 int
-__afr_inode_read_subvol_set_small (inode_t *inode, xlator_t *this,
-				   unsigned char *data, unsigned char *metadata,
-				   int event)
+__afr_inode_read_subvol_set_small(inode_t *inode, xlator_t *this,
+                                  unsigned char *data, unsigned char *metadata,
+                                  int event)
 {
-	afr_private_t *priv = NULL;
-	uint16_t datamap = 0;
-	uint16_t metadatamap = 0;
-	uint64_t val = 0;
-	int i = 0;
-        int ret = -1;
-        afr_inode_ctx_t *ctx = NULL;
+    afr_private_t *priv = NULL;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint64_t val = 0;
+    int i = 0;
+    int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-        ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                goto out;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret)
+        goto out;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (data[i])
-			datamap |= (1 << i);
-		if (metadata[i])
-			metadatamap |= (1 << i);
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (data[i])
+            datamap |= (1 << i);
+        if (metadata[i])
+            metadatamap |= (1 << i);
+    }
 
-	val = ((uint64_t) metadatamap) |
-		(((uint64_t) datamap) << 16) |
-		(((uint64_t) event) << 32);
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
 
-        ctx->read_subvol = val;
+    ctx->read_subvol = val;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__afr_inode_event_gen_reset_small (inode_t *inode, xlator_t *this)
+__afr_inode_event_gen_reset_small(inode_t *inode, xlator_t *this)
 {
-	int               ret         = -1;
-	uint16_t          datamap     = 0;
-	uint16_t          metadatamap = 0;
-	uint32_t          event       = 0;
-	uint64_t          val         = 0;
-        afr_inode_ctx_t  *ctx         = NULL;
+    int ret = -1;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint32_t event = 0;
+    uint64_t val = 0;
+    afr_inode_ctx_t *ctx = NULL;
 
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                return ret;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret)
+        return ret;
 
-        val = ctx->read_subvol;
+    val = ctx->read_subvol;
 
-	metadatamap = (val & 0x000000000000ffff) >> 0;
-	datamap =     (val & 0x00000000ffff0000) >> 16;
-	event = 0;
+    metadatamap = (val & 0x000000000000ffff) >> 0;
+    datamap = (val & 0x00000000ffff0000) >> 16;
+    event = 0;
 
-	val = ((uint64_t) metadatamap) |
-		(((uint64_t) datamap) << 16) |
-		(((uint64_t) event) << 32);
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
 
-        ctx->read_subvol = val;
+    ctx->read_subvol = val;
 
-        return ret;
+    return ret;
 }
 
-
 int
-__afr_inode_read_subvol_get (inode_t *inode, xlator_t *this,
-			     unsigned char *data, unsigned char *metadata,
-			     int *event_p)
+__afr_inode_read_subvol_get(inode_t *inode, xlator_t *this, unsigned char *data,
+                            unsigned char *metadata, int *event_p)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    int ret = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_read_subvol_get_small (inode, this, data,
-							 metadata, event_p);
-	else
-		/* TBD: allocate structure with array and read from it */
-		ret = -1;
+    if (priv->child_count <= 16)
+        ret = __afr_inode_read_subvol_get_small(inode, this, data, metadata,
+                                                event_p);
+    else
+        /* TBD: allocate structure with array and read from it */
+        ret = -1;
 
-	return ret;
+    return ret;
 }
 
 int
-__afr_inode_split_brain_choice_get (inode_t *inode, xlator_t *this,
-			            int *spb_choice)
+__afr_inode_split_brain_choice_get(inode_t *inode, xlator_t *this,
+                                   int *spb_choice)
 {
-        afr_inode_ctx_t *ctx = NULL;
-        int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret < 0)
-                return ret;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret < 0)
+        return ret;
 
-        *spb_choice = ctx->spb_choice;
-        return 0;
+    *spb_choice = ctx->spb_choice;
+    return 0;
 }
 
 int
-__afr_inode_read_subvol_set (inode_t *inode, xlator_t *this, unsigned char *data,
-			     unsigned char *metadata, int event)
+__afr_inode_read_subvol_set(inode_t *inode, xlator_t *this, unsigned char *data,
+                            unsigned char *metadata, int event)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    int ret = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_read_subvol_set_small (inode, this, data,
-							 metadata, event);
-	else
-		ret = -1;
+    if (priv->child_count <= 16)
+        ret = __afr_inode_read_subvol_set_small(inode, this, data, metadata,
+                                                event);
+    else
+        ret = -1;
 
-	return ret;
+    return ret;
 }
 
 int
-__afr_inode_split_brain_choice_set (inode_t *inode, xlator_t *this,
-                                    int spb_choice)
+__afr_inode_split_brain_choice_set(inode_t *inode, xlator_t *this,
+                                   int spb_choice)
 {
-        afr_inode_ctx_t *ctx = NULL;
-	int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-	ret = __afr_inode_ctx_get (this, inode, &ctx);
-        if (ret)
-                goto out;
+    ret = __afr_inode_ctx_get(this, inode, &ctx);
+    if (ret)
+        goto out;
 
-        ctx->spb_choice = spb_choice;
+    ctx->spb_choice = spb_choice;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__afr_inode_event_gen_reset (inode_t *inode, xlator_t *this)
+__afr_inode_event_gen_reset(inode_t *inode, xlator_t *this)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    int ret = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (priv->child_count <= 16)
-		ret = __afr_inode_event_gen_reset_small (inode, this);
-	else
-		ret = -1;
+    if (priv->child_count <= 16)
+        ret = __afr_inode_event_gen_reset_small(inode, this);
+    else
+        ret = -1;
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_inode_read_subvol_get (inode_t *inode, xlator_t *this, unsigned char *data,
-			   unsigned char *metadata, int *event_p)
+afr_inode_read_subvol_get(inode_t *inode, xlator_t *this, unsigned char *data,
+                          unsigned char *metadata, int *event_p)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-	{
-		ret = __afr_inode_read_subvol_get (inode, this, data,
-						   metadata, event_p);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_read_subvol_get(inode, this, data, metadata, event_p);
+    }
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_inode_get_readable (call_frame_t *frame, inode_t *inode, xlator_t *this,
+afr_inode_get_readable(call_frame_t *frame, inode_t *inode, xlator_t *this,
                        unsigned char *readable, int *event_p, int type)
 {
-
-        afr_private_t *priv = this->private;
-        afr_local_t *local = frame->local;
-        unsigned char *data = alloca0 (priv->child_count);
-        unsigned char *metadata = alloca0 (priv->child_count);
-        int data_count = 0;
-        int metadata_count = 0;
-        int event_generation = 0;
-        int ret = 0;
-
-        ret = afr_inode_read_subvol_get (inode, this, data, metadata,
-                                         &event_generation);
-        if (ret == -1)
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
+    unsigned char *data = alloca0(priv->child_count);
+    unsigned char *metadata = alloca0(priv->child_count);
+    int data_count = 0;
+    int metadata_count = 0;
+    int event_generation = 0;
+    int ret = 0;
+
+    ret = afr_inode_read_subvol_get(inode, this, data, metadata,
+                                    &event_generation);
+    if (ret == -1)
+        return -EIO;
+
+    data_count = AFR_COUNT(data, priv->child_count);
+    metadata_count = AFR_COUNT(metadata, priv->child_count);
+
+    if (inode->ia_type == IA_IFDIR) {
+        /* For directories, allow even if it is in data split-brain. */
+        if (type == AFR_METADATA_TRANSACTION || local->op == GF_FOP_STAT ||
+            local->op == GF_FOP_FSTAT) {
+            if (!metadata_count)
                 return -EIO;
-
-        data_count = AFR_COUNT (data, priv->child_count);
-        metadata_count = AFR_COUNT (metadata, priv->child_count);
-
-        if (inode->ia_type == IA_IFDIR) {
-                /* For directories, allow even if it is in data split-brain. */
-                if (type == AFR_METADATA_TRANSACTION ||
-                    local->op == GF_FOP_STAT || local->op == GF_FOP_FSTAT) {
-                        if (!metadata_count)
-                                return -EIO;
-                }
-        } else {
-                /* For files, abort in case of data/metadata split-brain. */
-                if (!data_count || !metadata_count) {
-                        return -EIO;
-                }
         }
-
-        if (type == AFR_METADATA_TRANSACTION && readable)
-                memcpy (readable, metadata, priv->child_count * sizeof *metadata);
-        if (type == AFR_DATA_TRANSACTION && readable) {
-                if (!data_count)
-                        memcpy (readable, local->child_up,
-                                priv->child_count * sizeof *readable);
-                else
-                        memcpy (readable, data, priv->child_count * sizeof *data);
+    } else {
+        /* For files, abort in case of data/metadata split-brain. */
+        if (!data_count || !metadata_count) {
+            return -EIO;
         }
-        if (event_p)
-                *event_p = event_generation;
-        return 0;
+    }
+
+    if (type == AFR_METADATA_TRANSACTION && readable)
+        memcpy(readable, metadata, priv->child_count * sizeof *metadata);
+    if (type == AFR_DATA_TRANSACTION && readable) {
+        if (!data_count)
+            memcpy(readable, local->child_up,
+                   priv->child_count * sizeof *readable);
+        else
+            memcpy(readable, data, priv->child_count * sizeof *data);
+    }
+    if (event_p)
+        *event_p = event_generation;
+    return 0;
 }
 
 int
-afr_inode_split_brain_choice_get (inode_t *inode, xlator_t *this,
-                                  int *spb_choice)
+afr_inode_split_brain_choice_get(inode_t *inode, xlator_t *this,
+                                 int *spb_choice)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-	LOCK(&inode->lock);
-	{
-		ret = __afr_inode_split_brain_choice_get (inode, this,
-                                                          spb_choice);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_split_brain_choice_get(inode, this, spb_choice);
+    }
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-afr_inode_read_subvol_set (inode_t *inode, xlator_t *this, unsigned char *data,
-			   unsigned char *metadata, int event)
+afr_inode_read_subvol_set(inode_t *inode, xlator_t *this, unsigned char *data,
+                          unsigned char *metadata, int event)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-	{
-		ret = __afr_inode_read_subvol_set (inode, this, data, metadata,
-						   event);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_read_subvol_set(inode, this, data, metadata, event);
+    }
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-afr_inode_split_brain_choice_set (inode_t *inode, xlator_t *this,
-                                  int spb_choice)
+afr_inode_split_brain_choice_set(inode_t *inode, xlator_t *this, int spb_choice)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-	LOCK(&inode->lock);
-	{
-		ret = __afr_inode_split_brain_choice_set (inode, this,
-                                                          spb_choice);
-	}
-	UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_split_brain_choice_set(inode, this, spb_choice);
+    }
+    UNLOCK(&inode->lock);
 out:
-	return ret;
+    return ret;
 }
 
-
 /* The caller of this should perform afr_inode_refresh, if this function
  * returns _gf_true
  */
 gf_boolean_t
-afr_is_inode_refresh_reqd (inode_t *inode, xlator_t *this,
-                           int event_gen1, int event_gen2)
+afr_is_inode_refresh_reqd(inode_t *inode, xlator_t *this, int event_gen1,
+                          int event_gen2)
 {
-        gf_boolean_t     need_refresh = _gf_false;
-        afr_inode_ctx_t  *ctx         = NULL;
-        int              ret          = -1;
+    gf_boolean_t need_refresh = _gf_false;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret)
-                        goto unlock;
-
-                need_refresh = ctx->need_refresh;
-                /* Hoping that the caller will do inode_refresh followed by
-                 * this, hence setting the need_refresh to false */
-                ctx->need_refresh = _gf_false;
-        }
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
+        if (ret)
+            goto unlock;
+
+        need_refresh = ctx->need_refresh;
+        /* Hoping that the caller will do inode_refresh followed by
+         * this, hence setting the need_refresh to false */
+        ctx->need_refresh = _gf_false;
+    }
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 
-        if (event_gen1 != event_gen2)
-                need_refresh = _gf_true;
+    if (event_gen1 != event_gen2)
+        need_refresh = _gf_true;
 out:
-        return need_refresh;
+    return need_refresh;
 }
 
-
 static int
-afr_inode_need_refresh_set (inode_t *inode, xlator_t *this)
+afr_inode_need_refresh_set(inode_t *inode, xlator_t *this)
 {
-        int               ret         = -1;
-        afr_inode_ctx_t  *ctx         = NULL;
+    int ret = -1;
+    afr_inode_ctx_t *ctx = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret)
-                        goto unlock;
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
+        if (ret)
+            goto unlock;
 
-                ctx->need_refresh = _gf_true;
-        }
+        ctx->need_refresh = _gf_true;
+    }
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_inode_event_gen_reset (inode_t *inode, xlator_t *this)
+afr_inode_event_gen_reset(inode_t *inode, xlator_t *this)
 {
-	int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_event_gen_reset (inode, this);
-        }
-        UNLOCK(&inode->lock);
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_event_gen_reset(inode, this);
+    }
+    UNLOCK(&inode->lock);
 out:
-	return ret;
+    return ret;
 }
 
 int
-afr_spb_choice_timeout_cancel (xlator_t *this, inode_t *inode)
+afr_spb_choice_timeout_cancel(xlator_t *this, inode_t *inode)
 {
-        afr_inode_ctx_t *ctx    = NULL;
-        int              ret    = -1;
+    afr_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        if (!inode)
-                return ret;
+    if (!inode)
+        return ret;
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret < 0 || !ctx) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to cancel split-brain choice timer.");
-                        goto out;
-                }
-                ctx->spb_choice = -1;
-                if (ctx->timer) {
-                        gf_timer_call_cancel (this->ctx, ctx->timer);
-                        ctx->timer = NULL;
-                }
-                ret = 0;
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
+        if (ret < 0 || !ctx) {
+            gf_msg(this->name, GF_LOG_WARNING, 0,
+                   AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+                   "Failed to cancel split-brain choice timer.");
+            goto out;
         }
+        ctx->spb_choice = -1;
+        if (ctx->timer) {
+            gf_timer_call_cancel(this->ctx, ctx->timer);
+            ctx->timer = NULL;
+        }
+        ret = 0;
+    }
 out:
-        UNLOCK(&inode->lock);
-        return ret;
+    UNLOCK(&inode->lock);
+    return ret;
 }
 
 void
-afr_set_split_brain_choice_cbk (void *data)
+afr_set_split_brain_choice_cbk(void *data)
 {
-        inode_t      *inode     = data;
-        xlator_t     *this      = THIS;
+    inode_t *inode = data;
+    xlator_t *this = THIS;
 
-        afr_spb_choice_timeout_cancel (this, inode);
-        inode_invalidate (inode);
-        inode_unref (inode);
-        return;
+    afr_spb_choice_timeout_cancel(this, inode);
+    inode_invalidate(inode);
+    inode_unref(inode);
+    return;
 }
 
-
 int
-afr_set_split_brain_choice (int ret, call_frame_t *frame, void *opaque)
-{
-        int                 op_errno         = ENOMEM;
-        afr_private_t      *priv             = NULL;
-        afr_inode_ctx_t    *ctx              = NULL;
-        inode_t            *inode            = NULL;
-        loc_t              *loc              = NULL;
-        xlator_t           *this             = NULL;
-        afr_spbc_timeout_t *data             = opaque;
-        struct              timespec delta   = {0, };
-        gf_boolean_t        timer_set        = _gf_false;
-        gf_boolean_t        timer_cancelled  = _gf_false;
-        gf_boolean_t        timer_reset      = _gf_false;
-        gf_boolean_t        need_invalidate  = _gf_true;
-        int                 old_spb_choice   = -1;
-
-        frame = data->frame;
-        loc = data->loc;
-        this = frame->this;
-        priv = this->private;
-
+afr_set_split_brain_choice(int ret, call_frame_t *frame, void *opaque)
+{
+    int op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_inode_ctx_t *ctx = NULL;
+    inode_t *inode = NULL;
+    loc_t *loc = NULL;
+    xlator_t *this = NULL;
+    afr_spbc_timeout_t *data = opaque;
+    struct timespec delta = {
+        0,
+    };
+    gf_boolean_t timer_set = _gf_false;
+    gf_boolean_t timer_cancelled = _gf_false;
+    gf_boolean_t timer_reset = _gf_false;
+    gf_boolean_t need_invalidate = _gf_true;
+    int old_spb_choice = -1;
+
+    frame = data->frame;
+    loc = data->loc;
+    this = frame->this;
+    priv = this->private;
+
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    delta.tv_sec = priv->spb_choice_timeout;
+    delta.tv_nsec = 0;
+
+    if (!loc->inode) {
+        ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (!(data->d_spb || data->m_spb)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+               "Cannot set "
+               "replica.split-brain-choice on %s. File is"
+               " not in data/metadata split-brain.",
+               uuid_utoa(loc->gfid));
+        ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /*
+     * we're ref'ing the inode before LOCK like it is done elsewhere in the
+     * code. If we ref after LOCK, coverity complains of possible deadlocks.
+     */
+    inode = inode_ref(loc->inode);
+
+    LOCK(&inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, inode, &ctx);
         if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+                   "Failed to get inode_ctx for %s", loc->name);
+            goto unlock;
         }
 
-        delta.tv_sec = priv->spb_choice_timeout;
-        delta.tv_nsec = 0;
+        old_spb_choice = ctx->spb_choice;
+        ctx->spb_choice = data->spb_child_index;
 
-        if (!loc->inode) {
-                ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        if (!(data->d_spb || data->m_spb)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR, "Cannot set "
-                        "replica.split-brain-choice on %s. File is"
-                        " not in data/metadata split-brain.",
-                        uuid_utoa (loc->gfid));
-                ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        /*
-         * we're ref'ing the inode before LOCK like it is done elsewhere in the
-         * code. If we ref after LOCK, coverity complains of possible deadlocks.
+        /* Possible changes in spb-choice :
+         *         valid to -1    : cancel timer and unref
+         *         valid to valid : cancel timer and inject new one
+         *         -1    to -1    : unref and do not do anything
+         *         -1 to valid    : inject timer
          */
-        inode = inode_ref (loc->inode);
 
-        LOCK(&inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, inode, &ctx);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to get inode_ctx for %s", loc->name);
-                        goto unlock;
+        /* ctx->timer is NULL iff previous value of
+         * ctx->spb_choice is -1
+         */
+        if (ctx->timer) {
+            if (ctx->spb_choice == -1) {
+                if (!gf_timer_call_cancel(this->ctx, ctx->timer)) {
+                    ctx->timer = NULL;
+                    timer_cancelled = _gf_true;
                 }
-
-                old_spb_choice = ctx->spb_choice;
-                ctx->spb_choice = data->spb_child_index;
-
-                /* Possible changes in spb-choice :
-                 *         valid to -1    : cancel timer and unref
-                 *         valid to valid : cancel timer and inject new one
-                 *         -1    to -1    : unref and do not do anything
-                 *         -1 to valid    : inject timer
+                /* If timer cancel failed here it means that the
+                 *  previous cbk will be executed which will set
+                 *  spb_choice to -1. So we can consider the
+                 *  'valid to -1' case to be a success
+                 *  (i.e. ret = 0) and goto unlock.
                  */
-
-                /* ctx->timer is NULL iff previous value of
-                 * ctx->spb_choice is -1
-                 */
-                if (ctx->timer) {
-                        if (ctx->spb_choice == -1) {
-                                if (!gf_timer_call_cancel (this->ctx,
-                                                            ctx->timer)) {
-                                        ctx->timer = NULL;
-                                        timer_cancelled = _gf_true;
-                                }
-                                /* If timer cancel failed here it means that the
-                                *  previous cbk will be executed which will set
-                                *  spb_choice to -1. So we can consider the
-                                *  'valid to -1' case to be a success
-                                *  (i.e. ret = 0) and goto unlock.
-                                */
-                                goto unlock;
-                        }
-                        goto reset_timer;
-                } else {
-                        if (ctx->spb_choice == -1)
-                                goto unlock;
-                        goto set_timer;
-                }
-
-reset_timer:
-                ret = gf_timer_call_cancel (this->ctx, ctx->timer);
-                if (ret != 0) {
-                        /* We need to bail out now instead of launching a new
-                         * timer. Otherwise the cbk of the previous timer event
-                         * will cancel the new ctx->timer.
-                         */
-                        ctx->spb_choice = old_spb_choice;
-                        ret = -1;
-                        op_errno = EAGAIN;
-                        goto unlock;
-                }
-                ctx->timer = NULL;
-                timer_reset = _gf_true;
-
-set_timer:
-                ctx->timer = gf_timer_call_after (this->ctx, delta,
-                                                  afr_set_split_brain_choice_cbk,
-                                                  inode);
-                if (!ctx->timer) {
-                        ctx->spb_choice = old_spb_choice;
-                        ret = -1;
-                        op_errno = ENOMEM;
-                }
-                if (!timer_reset && ctx->timer)
-                        timer_set = _gf_true;
-                if (timer_reset && !ctx->timer)
-                        timer_cancelled = _gf_true;
-                need_invalidate = _gf_false;
+                goto unlock;
+            }
+            goto reset_timer;
+        } else {
+            if (ctx->spb_choice == -1)
+                goto unlock;
+            goto set_timer;
         }
+
+    reset_timer:
+        ret = gf_timer_call_cancel(this->ctx, ctx->timer);
+        if (ret != 0) {
+            /* We need to bail out now instead of launching a new
+             * timer. Otherwise the cbk of the previous timer event
+             * will cancel the new ctx->timer.
+             */
+            ctx->spb_choice = old_spb_choice;
+            ret = -1;
+            op_errno = EAGAIN;
+            goto unlock;
+        }
+        ctx->timer = NULL;
+        timer_reset = _gf_true;
+
+    set_timer:
+        ctx->timer = gf_timer_call_after(this->ctx, delta,
+                                         afr_set_split_brain_choice_cbk, inode);
+        if (!ctx->timer) {
+            ctx->spb_choice = old_spb_choice;
+            ret = -1;
+            op_errno = ENOMEM;
+        }
+        if (!timer_reset && ctx->timer)
+            timer_set = _gf_true;
+        if (timer_reset && !ctx->timer)
+            timer_cancelled = _gf_true;
+        need_invalidate = _gf_false;
+    }
 unlock:
-        UNLOCK(&inode->lock);
-        if (!timer_set)
-                inode_unref (inode);
-        if (timer_cancelled)
-                inode_unref (inode);
-        /*
-         * We need to invalidate the inode to prevent the kernel from serving
-         * reads from an older cached value despite a change in spb_choice to
-         * a new value.
-         */
-        if (need_invalidate)
-                inode_invalidate (inode);
+    UNLOCK(&inode->lock);
+    if (!timer_set)
+        inode_unref(inode);
+    if (timer_cancelled)
+        inode_unref(inode);
+    /*
+     * We need to invalidate the inode to prevent the kernel from serving
+     * reads from an older cached value despite a change in spb_choice to
+     * a new value.
+     */
+    if (need_invalidate)
+        inode_invalidate(inode);
 out:
-        GF_FREE (data);
-        AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        return 0;
+    GF_FREE(data);
+    AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    return 0;
 }
 
 int
-afr_accused_fill (xlator_t *this, dict_t *xdata, unsigned char *accused,
-		  afr_transaction_type type)
+afr_accused_fill(xlator_t *this, dict_t *xdata, unsigned char *accused,
+                 afr_transaction_type type)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int idx = afr_index_for_transaction_type (type);
-	void *pending_raw = NULL;
-	int pending[3];
-	int ret = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int idx = afr_index_for_transaction_type(type);
+    void *pending_raw = NULL;
+    int pending[3];
+    int ret = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		ret = dict_get_ptr (xdata, priv->pending_key[i],
-				    &pending_raw);
-		if (ret) /* no pending flags */
-			continue;
-		memcpy (pending, pending_raw, sizeof(pending));
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_get_ptr(xdata, priv->pending_key[i], &pending_raw);
+        if (ret) /* no pending flags */
+            continue;
+        memcpy(pending, pending_raw, sizeof(pending));
 
-		if (ntoh32 (pending[idx]))
-			accused[i] = 1;
-	}
+        if (ntoh32(pending[idx]))
+            accused[i] = 1;
+    }
 
-	return 0;
+    return 0;
 }
 
 int
-afr_accuse_smallfiles (xlator_t *this, struct afr_reply *replies,
-		       unsigned char *data_accused)
+afr_accuse_smallfiles(xlator_t *this, struct afr_reply *replies,
+                      unsigned char *data_accused)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	uint64_t maxsize = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t maxsize = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid && replies[i].xdata &&
-                    dict_get (replies[i].xdata, GLUSTERFS_BAD_INODE))
-                        continue;
-		if (data_accused[i])
-			continue;
-		if (replies[i].poststat.ia_size > maxsize)
-			maxsize = replies[i].poststat.ia_size;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].xdata &&
+            dict_get(replies[i].xdata, GLUSTERFS_BAD_INODE))
+            continue;
+        if (data_accused[i])
+            continue;
+        if (replies[i].poststat.ia_size > maxsize)
+            maxsize = replies[i].poststat.ia_size;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (data_accused[i])
-			continue;
-                if (AFR_IS_ARBITER_BRICK(priv, i))
-                        continue;
-		if (replies[i].poststat.ia_size < maxsize)
-			data_accused[i] = 1;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_accused[i])
+            continue;
+        if (AFR_IS_ARBITER_BRICK(priv, i))
+            continue;
+        if (replies[i].poststat.ia_size < maxsize)
+            data_accused[i] = 1;
+    }
 
-	return 0;
+    return 0;
 }
 
 int
-afr_readables_fill (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                    unsigned char *data_accused,
-                    unsigned char *metadata_accused,
-                    unsigned char *data_readable,
-                    unsigned char *metadata_readable,
-                    struct afr_reply *replies)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        int i = 0;
-        int ret = 0;
-        ia_type_t ia_type = IA_INVAL;
-
-        local = frame->local;
-        priv = this->private;
+afr_readables_fill(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                   unsigned char *data_accused, unsigned char *metadata_accused,
+                   unsigned char *data_readable,
+                   unsigned char *metadata_readable, struct afr_reply *replies)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
+    int ret = 0;
+    ia_type_t ia_type = IA_INVAL;
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        data_readable[i] = 1;
+        metadata_readable[i] = 1;
+    }
+    if (AFR_IS_ARBITER_BRICK(priv, ARBITER_BRICK_INDEX)) {
+        data_readable[ARBITER_BRICK_INDEX] = 0;
+        metadata_readable[ARBITER_BRICK_INDEX] = 0;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies) { /* Lookup */
+            if (!replies[i].valid || replies[i].op_ret == -1 ||
+                (replies[i].xdata &&
+                 dict_get(replies[i].xdata, GLUSTERFS_BAD_INODE))) {
+                data_readable[i] = 0;
+                metadata_readable[i] = 0;
+                continue;
+            }
 
-        for (i = 0; i < priv->child_count; i++) {
-                data_readable[i] = 1;
-                metadata_readable[i] = 1;
-        }
-        if (AFR_IS_ARBITER_BRICK (priv, ARBITER_BRICK_INDEX)) {
-                data_readable[ARBITER_BRICK_INDEX] =  0;
-                metadata_readable[ARBITER_BRICK_INDEX] = 0;
+            xdata = replies[i].xdata;
+            ia_type = replies[i].poststat.ia_type;
+        } else { /* pre-op xattrop */
+            xdata = local->transaction.changelog_xdata[i];
+            ia_type = inode->ia_type;
         }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies) {/* Lookup */
-                        if (!replies[i].valid || replies[i].op_ret == -1 ||
-                            (replies[i].xdata && dict_get (replies[i].xdata,
-                                                        GLUSTERFS_BAD_INODE))) {
-                                data_readable[i] = 0;
-                                metadata_readable[i] = 0;
-                                continue;
-                        }
-
-                        xdata = replies[i].xdata;
-                        ia_type = replies[i].poststat.ia_type;
-                } else {/* pre-op xattrop */
-                        xdata = local->transaction.changelog_xdata[i];
-                        ia_type = inode->ia_type;
-                }
+        afr_accused_fill(this, xdata, data_accused,
+                         (ia_type == IA_IFDIR) ? AFR_ENTRY_TRANSACTION
+                                               : AFR_DATA_TRANSACTION);
 
-                afr_accused_fill (this, xdata, data_accused,
-                                  (ia_type == IA_IFDIR) ?
-                                  AFR_ENTRY_TRANSACTION : AFR_DATA_TRANSACTION);
+        afr_accused_fill(this, xdata, metadata_accused,
+                         AFR_METADATA_TRANSACTION);
+    }
 
-                afr_accused_fill (this, xdata,
-                                  metadata_accused, AFR_METADATA_TRANSACTION);
-        }
+    if (replies && ia_type != IA_INVAL && ia_type != IA_IFDIR &&
+        /* We want to accuse small files only when we know for
+         * sure that there is no IO happening. Otherwise, the
+         * ia_sizes obtained in post-refresh replies may
+         * mismatch due to a race between inode-refresh and
+         * ongoing writes, causing spurious heal launches*/
+        !afr_is_possibly_under_txn(AFR_DATA_TRANSACTION, local, this)) {
+        afr_accuse_smallfiles(this, replies, data_accused);
+    }
 
-        if (replies && ia_type != IA_INVAL && ia_type != IA_IFDIR &&
-            /* We want to accuse small files only when we know for
-             * sure that there is no IO happening. Otherwise, the
-             * ia_sizes obtained in post-refresh replies may
-             * mismatch due to a race between inode-refresh and
-             * ongoing writes, causing spurious heal launches*/
-            !afr_is_possibly_under_txn (AFR_DATA_TRANSACTION, local, this)) {
-                afr_accuse_smallfiles (this, replies, data_accused);
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_accused[i]) {
+            data_readable[i] = 0;
+            ret = 1;
         }
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (data_accused[i]) {
-                        data_readable[i] = 0;
-                        ret = 1;
-                }
-                if (metadata_accused[i]) {
-                        metadata_readable[i] = 0;
-                        ret = 1;
-                }
+        if (metadata_accused[i]) {
+            metadata_readable[i] = 0;
+            ret = 1;
         }
-        return ret;
+    }
+    return ret;
 }
 
 int
-afr_replies_interpret (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                       gf_boolean_t *start_heal)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	struct afr_reply *replies = NULL;
-	int event_generation = 0;
-	int i = 0;
-	unsigned char *data_accused = NULL;
-	unsigned char *metadata_accused = NULL;
-	unsigned char *data_readable = NULL;
-	unsigned char *metadata_readable = NULL;
-	int ret = 0;
-
-	local = frame->local;
-	priv = this->private;
-	replies = local->replies;
-	event_generation = local->event_generation;
-
-	data_accused = alloca0 (priv->child_count);
-	data_readable = alloca0 (priv->child_count);
-	metadata_accused = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-
-        ret = afr_readables_fill (frame, this, inode, data_accused,
-                                  metadata_accused, data_readable,
-                                  metadata_readable, replies);
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (start_heal && priv->child_up[i] &&
-                    (data_accused[i] || metadata_accused[i])) {
-                        *start_heal = _gf_true;
-                        break;
-                }
-        }
-	afr_inode_read_subvol_set (inode, this, data_readable,
-				   metadata_readable, event_generation);
-	return ret;
+afr_replies_interpret(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                      gf_boolean_t *start_heal)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int event_generation = 0;
+    int i = 0;
+    unsigned char *data_accused = NULL;
+    unsigned char *metadata_accused = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    priv = this->private;
+    replies = local->replies;
+    event_generation = local->event_generation;
+
+    data_accused = alloca0(priv->child_count);
+    data_readable = alloca0(priv->child_count);
+    metadata_accused = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+
+    ret = afr_readables_fill(frame, this, inode, data_accused, metadata_accused,
+                             data_readable, metadata_readable, replies);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (start_heal && priv->child_up[i] &&
+            (data_accused[i] || metadata_accused[i])) {
+            *start_heal = _gf_true;
+            break;
+        }
+    }
+    afr_inode_read_subvol_set(inode, this, data_readable, metadata_readable,
+                              event_generation);
+    return ret;
 }
 
 int
-afr_refresh_selfheal_done (int ret, call_frame_t *heal, void *opaque)
+afr_refresh_selfheal_done(int ret, call_frame_t *heal, void *opaque)
 {
-	if (heal)
-                AFR_STACK_DESTROY (heal);
-	return 0;
+    if (heal)
+        AFR_STACK_DESTROY(heal);
+    return 0;
 }
 
 int
-afr_inode_refresh_err (call_frame_t *frame, xlator_t *this)
+afr_inode_refresh_err(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int err = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int err = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].valid && !local->replies[i].op_ret) {
-			err = 0;
-			goto ret;
-		}
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && !local->replies[i].op_ret) {
+            err = 0;
+            goto ret;
+        }
+    }
 
-	err = afr_final_errno (local, priv);
+    err = afr_final_errno(local, priv);
 ret:
-	return err;
+    return err;
 }
 
 gf_boolean_t
-afr_selfheal_enabled (xlator_t *this)
+afr_selfheal_enabled(xlator_t *this)
 {
-	afr_private_t *priv = NULL;
-	gf_boolean_t data = _gf_false;
-        int ret = 0;
+    afr_private_t *priv = NULL;
+    gf_boolean_t data = _gf_false;
+    int ret = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	ret = gf_string2boolean (priv->data_self_heal, &data);
-        GF_ASSERT (!ret);
+    ret = gf_string2boolean(priv->data_self_heal, &data);
+    GF_ASSERT(!ret);
 
-	return data || priv->metadata_self_heal || priv->entry_self_heal;
+    return data || priv->metadata_self_heal || priv->entry_self_heal;
 }
 
-
 int
-afr_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
-{
-
-        call_frame_t *heal_frame = NULL;
-        afr_local_t *heal_local = NULL;
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        inode_t *inode = NULL;
-        int event_generation = 0;
-        int read_subvol = -1;
-        int op_errno = ENOMEM;
-        int ret = 0;
-
-        local = frame->local;
-        inode = local->inode;
-        priv = this->private;
-
-        if (err)
-                goto refresh_done;
-
-        if (local->op == GF_FOP_LOOKUP)
-                goto refresh_done;
-
-        ret = afr_inode_get_readable (frame, inode, this, local->readable,
-                                      &event_generation,
-                                      local->transaction.type);
-
-        if (ret == -EIO || (local->is_read_txn && !event_generation)) {
-                /* No readable subvolume even after refresh ==> splitbrain.*/
-                if (!priv->fav_child_policy) {
-                        err = EIO;
-                        goto refresh_done;
-                }
-                read_subvol = afr_sh_get_fav_by_policy (this, local->replies,
-                                                        inode, NULL);
-                if (read_subvol == -1) {
-                        err = EIO;
-                        goto refresh_done;
-                }
-
-                heal_frame = copy_frame (frame);
-                if (!heal_frame) {
-                        err = EIO;
-                        goto refresh_done;
-                }
-                heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-                heal_local = AFR_FRAME_INIT (heal_frame, op_errno);
-                if (!heal_local) {
-                        err = EIO;
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->xdata_req = dict_new();
-                if (!heal_local->xdata_req) {
-                        err = EIO;
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->heal_frame = frame;
-                ret = synctask_new (this->ctx->env,
-                                    afr_fav_child_reset_sink_xattrs,
-                                    afr_fav_child_reset_sink_xattrs_cbk,
-                                    heal_frame,
-                                    heal_frame);
-                return 0;
-        }
+afr_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
+{
+    call_frame_t *heal_frame = NULL;
+    afr_local_t *heal_local = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    int event_generation = 0;
+    int read_subvol = -1;
+    int op_errno = ENOMEM;
+    int ret = 0;
+
+    local = frame->local;
+    inode = local->inode;
+    priv = this->private;
+
+    if (err)
+        goto refresh_done;
+
+    if (local->op == GF_FOP_LOOKUP)
+        goto refresh_done;
+
+    ret = afr_inode_get_readable(frame, inode, this, local->readable,
+                                 &event_generation, local->transaction.type);
+
+    if (ret == -EIO || (local->is_read_txn && !event_generation)) {
+        /* No readable subvolume even after refresh ==> splitbrain.*/
+        if (!priv->fav_child_policy) {
+            err = EIO;
+            goto refresh_done;
+        }
+        read_subvol = afr_sh_get_fav_by_policy(this, local->replies, inode,
+                                               NULL);
+        if (read_subvol == -1) {
+            err = EIO;
+            goto refresh_done;
+        }
+
+        heal_frame = copy_frame(frame);
+        if (!heal_frame) {
+            err = EIO;
+            goto refresh_done;
+        }
+        heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
+        heal_local = AFR_FRAME_INIT(heal_frame, op_errno);
+        if (!heal_local) {
+            err = EIO;
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
+        }
+        heal_local->xdata_req = dict_new();
+        if (!heal_local->xdata_req) {
+            err = EIO;
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
+        }
+        heal_local->heal_frame = frame;
+        ret = synctask_new(this->ctx->env, afr_fav_child_reset_sink_xattrs,
+                           afr_fav_child_reset_sink_xattrs_cbk, heal_frame,
+                           heal_frame);
+        return 0;
+    }
 
 refresh_done:
-        afr_local_replies_wipe (local, this->private);
-        local->refreshfn (frame, this, err);
+    afr_local_replies_wipe(local, this->private);
+    local->refreshfn(frame, this, err);
 
-        return 0;
+    return 0;
 }
 
 static void
-afr_fill_success_replies (afr_local_t *local, afr_private_t *priv,
-                          unsigned char *replies)
+afr_fill_success_replies(afr_local_t *local, afr_private_t *priv,
+                         unsigned char *replies)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->replies[i].valid && local->replies[i].op_ret == 0)
-                        replies[i] = 1;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].op_ret == 0)
+            replies[i] = 1;
+    }
 }
 
 int
-afr_inode_refresh_done (call_frame_t *frame, xlator_t *this, int error)
-{
-	call_frame_t *heal_frame = NULL;
-	afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        gf_boolean_t start_heal = _gf_false;
-        afr_local_t *heal_local = NULL;
-        unsigned char *success_replies = NULL;
-        int op_errno = ENOMEM;
-	int ret = 0;
-
-	if (error != 0) {
-		goto refresh_done;
-	}
-
-	local = frame->local;
-        priv = this->private;
-        success_replies = alloca0 (priv->child_count);
-        afr_fill_success_replies (local, priv, success_replies);
-
-        if (!afr_has_quorum (success_replies, this)) {
-                error = afr_final_errno (frame->local, this->private);
-                if (!error)
-                        error = afr_quorum_errno(priv);
-                goto refresh_done;
-        }
-
-        if (priv->thin_arbiter_count && local->is_read_txn &&
-            AFR_COUNT (success_replies, priv->child_count) !=
-                       priv->child_count) {
-                /* We need to query the good bricks and/or thin-arbiter.*/
-                error = EINVAL;
-                goto refresh_done;
-        }
-
-	ret = afr_replies_interpret (frame, this, local->refreshinode,
-                                     &start_heal);
-
-	if (ret && afr_selfheal_enabled (this) && start_heal) {
-                heal_frame = copy_frame (frame);
-                if (!heal_frame)
-                        goto refresh_done;
-                heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-                heal_local = AFR_FRAME_INIT (heal_frame, op_errno);
-                if (!heal_local) {
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-                heal_local->refreshinode = inode_ref (local->refreshinode);
-                heal_local->heal_frame = heal_frame;
-                if (!afr_throttled_selfheal (heal_frame, this)) {
-                        AFR_STACK_DESTROY (heal_frame);
-                        goto refresh_done;
-                }
-        }
+afr_inode_refresh_done(call_frame_t *frame, xlator_t *this, int error)
+{
+    call_frame_t *heal_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t start_heal = _gf_false;
+    afr_local_t *heal_local = NULL;
+    unsigned char *success_replies = NULL;
+    int op_errno = ENOMEM;
+    int ret = 0;
+
+    if (error != 0) {
+        goto refresh_done;
+    }
+
+    local = frame->local;
+    priv = this->private;
+    success_replies = alloca0(priv->child_count);
+    afr_fill_success_replies(local, priv, success_replies);
+
+    if (!afr_has_quorum(success_replies, this)) {
+        error = afr_final_errno(frame->local, this->private);
+        if (!error)
+            error = afr_quorum_errno(priv);
+        goto refresh_done;
+    }
+
+    if (priv->thin_arbiter_count && local->is_read_txn &&
+        AFR_COUNT(success_replies, priv->child_count) != priv->child_count) {
+        /* We need to query the good bricks and/or thin-arbiter.*/
+        error = EINVAL;
+        goto refresh_done;
+    }
+
+    ret = afr_replies_interpret(frame, this, local->refreshinode, &start_heal);
+
+    if (ret && afr_selfheal_enabled(this) && start_heal) {
+        heal_frame = copy_frame(frame);
+        if (!heal_frame)
+            goto refresh_done;
+        heal_frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
+        heal_local = AFR_FRAME_INIT(heal_frame, op_errno);
+        if (!heal_local) {
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
+        }
+        heal_local->refreshinode = inode_ref(local->refreshinode);
+        heal_local->heal_frame = heal_frame;
+        if (!afr_throttled_selfheal(heal_frame, this)) {
+            AFR_STACK_DESTROY(heal_frame);
+            goto refresh_done;
+        }
+    }
 
 refresh_done:
-        afr_txn_refresh_done (frame, this, error);
+    afr_txn_refresh_done(frame, this, error);
 
-	return 0;
+    return 0;
 }
 
 void
-afr_inode_refresh_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int op_ret, int op_errno, struct iatt *buf,
-                              dict_t *xdata, struct iatt *par)
-{
-        afr_local_t *local = NULL;
-        int call_child = (long) cookie;
-        int8_t need_heal = 1;
-        int call_count = 0;
-        int ret = 0;
-
-        local = frame->local;
-        local->replies[call_child].valid = 1;
-        local->replies[call_child].op_ret = op_ret;
-        local->replies[call_child].op_errno = op_errno;
-	if (op_ret != -1) {
-		local->replies[call_child].poststat = *buf;
-		if (par)
-                        local->replies[call_child].postparent = *par;
-                if (xdata)
-		        local->replies[call_child].xdata = dict_ref (xdata);
-	}
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[call_child].need_heal = need_heal;
-        } else {
-                local->replies[call_child].need_heal = need_heal;
-        }
-
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-                ret = afr_inode_refresh_err (frame, this);
-		afr_inode_refresh_done (frame, this, ret);
-        }
-
+afr_inode_refresh_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, struct iatt *buf,
+                             dict_t *xdata, struct iatt *par)
+{
+    afr_local_t *local = NULL;
+    int call_child = (long)cookie;
+    int8_t need_heal = 1;
+    int call_count = 0;
+    int ret = 0;
+
+    local = frame->local;
+    local->replies[call_child].valid = 1;
+    local->replies[call_child].op_ret = op_ret;
+    local->replies[call_child].op_errno = op_errno;
+    if (op_ret != -1) {
+        local->replies[call_child].poststat = *buf;
+        if (par)
+            local->replies[call_child].postparent = *par;
+        if (xdata)
+            local->replies[call_child].xdata = dict_ref(xdata);
+    }
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[call_child].need_heal = need_heal;
+    } else {
+        local->replies[call_child].need_heal = need_heal;
+    }
+
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        ret = afr_inode_refresh_err(frame, this);
+        afr_inode_refresh_done(frame, this, ret);
+    }
 }
 
 int
-afr_inode_refresh_subvol_with_lookup_cbk (call_frame_t *frame, void *cookie,
-                                          xlator_t *this, int op_ret,
-                                          int op_errno, inode_t *inode,
-                                          struct iatt *buf, dict_t *xdata,
-                                          struct iatt *par)
+afr_inode_refresh_subvol_with_lookup_cbk(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int op_ret,
+                                         int op_errno, inode_t *inode,
+                                         struct iatt *buf, dict_t *xdata,
+                                         struct iatt *par)
 {
-        afr_inode_refresh_subvol_cbk (frame, cookie, this, op_ret, op_errno,
-                                      buf, xdata, par);
-	return 0;
+    afr_inode_refresh_subvol_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                                 xdata, par);
+    return 0;
 }
 
-
 int
-afr_inode_refresh_subvol_with_lookup (call_frame_t *frame, xlator_t *this,
-                                      int i, inode_t *inode, uuid_t gfid,
-                                      dict_t *xdata)
+afr_inode_refresh_subvol_with_lookup(call_frame_t *frame, xlator_t *this, int i,
+                                     inode_t *inode, uuid_t gfid, dict_t *xdata)
 {
-	loc_t loc = {0, };
-	afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	loc.inode = inode;
-        if (gf_uuid_is_null (inode->gfid) && gfid) {
-                /* To handle setattr/setxattr on yet to be linked inode from
-                 * dht */
-                gf_uuid_copy (loc.gfid, gfid);
-        } else {
-                gf_uuid_copy (loc.gfid, inode->gfid);
-        }
+    loc.inode = inode;
+    if (gf_uuid_is_null(inode->gfid) && gfid) {
+        /* To handle setattr/setxattr on yet to be linked inode from
+         * dht */
+        gf_uuid_copy(loc.gfid, gfid);
+    } else {
+        gf_uuid_copy(loc.gfid, inode->gfid);
+    }
 
-	STACK_WIND_COOKIE (frame, afr_inode_refresh_subvol_with_lookup_cbk,
-			   (void *) (long) i, priv->children[i],
-			   priv->children[i]->fops->lookup, &loc, xdata);
-	return 0;
+    STACK_WIND_COOKIE(frame, afr_inode_refresh_subvol_with_lookup_cbk,
+                      (void *)(long)i, priv->children[i],
+                      priv->children[i]->fops->lookup, &loc, xdata);
+    return 0;
 }
 
 int
-afr_inode_refresh_subvol_with_fstat_cbk (call_frame_t *frame,
-                                         void *cookie, xlator_t *this,
-                                         int32_t op_ret, int32_t op_errno,
-                                         struct iatt *buf, dict_t *xdata)
+afr_inode_refresh_subvol_with_fstat_cbk(call_frame_t *frame, void *cookie,
+                                        xlator_t *this, int32_t op_ret,
+                                        int32_t op_errno, struct iatt *buf,
+                                        dict_t *xdata)
 {
-        afr_inode_refresh_subvol_cbk (frame, cookie, this, op_ret, op_errno,
-                                      buf, xdata, NULL);
-        return 0;
+    afr_inode_refresh_subvol_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                                 xdata, NULL);
+    return 0;
 }
 
 int
-afr_inode_refresh_subvol_with_fstat (call_frame_t *frame, xlator_t *this, int i,
-			             dict_t *xdata)
+afr_inode_refresh_subvol_with_fstat(call_frame_t *frame, xlator_t *this, int i,
+                                    dict_t *xdata)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        STACK_WIND_COOKIE (frame, afr_inode_refresh_subvol_with_fstat_cbk,
-                           (void *) (long) i, priv->children[i],
-                           priv->children[i]->fops->fstat, local->fd, xdata);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_inode_refresh_subvol_with_fstat_cbk,
+                      (void *)(long)i, priv->children[i],
+                      priv->children[i]->fops->fstat, local->fd, xdata);
+    return 0;
 }
 
 int
-afr_inode_refresh_do (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
-	int i = 0;
-        int ret = 0;
-	dict_t *xdata = NULL;
-        afr_fd_ctx_t  *fd_ctx = NULL;
-        unsigned char *wind_subvols = NULL;
-
-	priv = this->private;
-	local = frame->local;
-        wind_subvols = alloca0 (priv->child_count);
-
-        afr_local_replies_wipe (local, priv);
-
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        afr_inode_refresh_done (frame, this, EINVAL);
-                        return 0;
-                }
-        }
+afr_inode_refresh_do(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int i = 0;
+    int ret = 0;
+    dict_t *xdata = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    unsigned char *wind_subvols = NULL;
 
-	xdata = dict_new ();
-	if (!xdata) {
-		afr_inode_refresh_done (frame, this, ENOMEM);
-		return 0;
-	}
+    priv = this->private;
+    local = frame->local;
+    wind_subvols = alloca0(priv->child_count);
 
-	ret = afr_xattr_req_prepare (this, xdata);
-	if (ret != 0) {
-		dict_unref (xdata);
-		afr_inode_refresh_done (frame, this, -ret);
-		return 0;
-	}
+    afr_local_replies_wipe(local, priv);
 
-        ret = dict_set_str (xdata, "link-count", GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
+    if (local->fd) {
+        fd_ctx = afr_fd_ctx_get(local->fd, this);
+        if (!fd_ctx) {
+            afr_inode_refresh_done(frame, this, EINVAL);
+            return 0;
         }
+    }
 
-        ret = dict_set_str (xdata, GLUSTERFS_INODELK_DOM_COUNT, this->name);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set inodelk-dom-count in dict ");
+    xdata = dict_new();
+    if (!xdata) {
+        afr_inode_refresh_done(frame, this, ENOMEM);
+        return 0;
+    }
 
-        }
+    ret = afr_xattr_req_prepare(this, xdata);
+    if (ret != 0) {
+        dict_unref(xdata);
+        afr_inode_refresh_done(frame, this, -ret);
+        return 0;
+    }
 
-        if (local->fd) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (local->child_up[i] &&
-                            fd_ctx->opened_on[i] == AFR_FD_OPENED)
-                                wind_subvols[i] = 1;
-                }
-        } else {
-                memcpy (wind_subvols, local->child_up,
-                        sizeof (*local->child_up) * priv->child_count);
-        }
+    ret = dict_set_str(xdata, "link-count", GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
 
-	local->call_count = AFR_COUNT (wind_subvols, priv->child_count);
+    ret = dict_set_str(xdata, GLUSTERFS_INODELK_DOM_COUNT, this->name);
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "Unable to set inodelk-dom-count in dict ");
+    }
 
-	call_count = local->call_count;
-        if (!call_count) {
-                dict_unref (xdata);
-		if (local->fd && AFR_COUNT(local->child_up, priv->child_count))
-	                afr_inode_refresh_done (frame, this, EBADFD);
-		else
-	                afr_inode_refresh_done (frame, this, ENOTCONN);
-                return 0;
+    if (local->fd) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->child_up[i] && fd_ctx->opened_on[i] == AFR_FD_OPENED)
+                wind_subvols[i] = 1;
         }
-	for (i = 0; i < priv->child_count; i++) {
-		if (!wind_subvols[i])
-			continue;
+    } else {
+        memcpy(wind_subvols, local->child_up,
+               sizeof(*local->child_up) * priv->child_count);
+    }
 
-                if (local->fd)
-                        afr_inode_refresh_subvol_with_fstat (frame, this, i,
-                                                             xdata);
-                else
-                        afr_inode_refresh_subvol_with_lookup (frame, this, i,
-                                                    local->refreshinode,
-                                                    local->refreshgfid, xdata);
+    local->call_count = AFR_COUNT(wind_subvols, priv->child_count);
 
-		if (!--call_count)
-			break;
-	}
+    call_count = local->call_count;
+    if (!call_count) {
+        dict_unref(xdata);
+        if (local->fd && AFR_COUNT(local->child_up, priv->child_count))
+            afr_inode_refresh_done(frame, this, EBADFD);
+        else
+            afr_inode_refresh_done(frame, this, ENOTCONN);
+        return 0;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!wind_subvols[i])
+            continue;
 
-	dict_unref (xdata);
+        if (local->fd)
+            afr_inode_refresh_subvol_with_fstat(frame, this, i, xdata);
+        else
+            afr_inode_refresh_subvol_with_lookup(
+                frame, this, i, local->refreshinode, local->refreshgfid, xdata);
 
-	return 0;
-}
+        if (!--call_count)
+            break;
+    }
+
+    dict_unref(xdata);
 
+    return 0;
+}
 
 int
-afr_inode_refresh (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                   uuid_t gfid, afr_inode_refresh_cbk_t refreshfn)
+afr_inode_refresh(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                  uuid_t gfid, afr_inode_refresh_cbk_t refreshfn)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	local->refreshfn = refreshfn;
+    local->refreshfn = refreshfn;
 
-	if (local->refreshinode) {
-		inode_unref (local->refreshinode);
-		local->refreshinode = NULL;
-	}
+    if (local->refreshinode) {
+        inode_unref(local->refreshinode);
+        local->refreshinode = NULL;
+    }
 
-	local->refreshinode = inode_ref (inode);
+    local->refreshinode = inode_ref(inode);
 
-        if (gfid)
-                gf_uuid_copy (local->refreshgfid, gfid);
-        else
-                gf_uuid_clear (local->refreshgfid);
+    if (gfid)
+        gf_uuid_copy(local->refreshgfid, gfid);
+    else
+        gf_uuid_clear(local->refreshgfid);
 
-	afr_inode_refresh_do (frame, this);
+    afr_inode_refresh_do(frame, this);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_xattr_req_prepare (xlator_t *this, dict_t *xattr_req)
+afr_xattr_req_prepare(xlator_t *this, dict_t *xattr_req)
 {
-        int             i           = 0;
-        afr_private_t   *priv       = NULL;
-        int             ret         = 0;
-
-        priv   = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                ret = dict_set_uint64 (xattr_req, priv->pending_key[i],
-                                       AFR_NUM_CHANGE_LOGS * sizeof(int));
-                if (ret < 0)
-                        gf_msg (this->name, GF_LOG_WARNING,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Unable to set dict value for %s",
-                                priv->pending_key[i]);
-                /* 3 = data+metadata+entry */
-        }
-        ret = dict_set_uint64 (xattr_req, AFR_DIRTY,
-			       AFR_NUM_CHANGE_LOGS * sizeof(int));
-        if (ret) {
-                gf_msg_debug (this->name, -ret, "failed to set dirty "
-                              "query flag");
-        }
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int ret = 0;
 
-        ret = dict_set_int32 (xattr_req, "list-xattr", 1);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set list-xattr in dict ");
-        }
+    priv = this->private;
 
-	return ret;
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_uint64(xattr_req, priv->pending_key[i],
+                              AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret < 0)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Unable to set dict value for %s", priv->pending_key[i]);
+        /* 3 = data+metadata+entry */
+    }
+    ret = dict_set_uint64(xattr_req, AFR_DIRTY,
+                          AFR_NUM_CHANGE_LOGS * sizeof(int));
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "failed to set dirty "
+                     "query flag");
+    }
+
+    ret = dict_set_int32(xattr_req, "list-xattr", 1);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set list-xattr in dict ");
+    }
+
+    return ret;
 }
 
 int
-afr_lookup_xattr_req_prepare (afr_local_t *local, xlator_t *this,
-                              dict_t *xattr_req, loc_t *loc)
-{
-        int     ret = -ENOMEM;
-
-        if (!local->xattr_req)
-                local->xattr_req = dict_new ();
-
-        if (!local->xattr_req)
-                goto out;
-
-        if (xattr_req && (xattr_req != local->xattr_req))
-                dict_copy (xattr_req, local->xattr_req);
-
-        ret = afr_xattr_req_prepare (this, local->xattr_req);
-
-        ret = dict_set_uint64 (local->xattr_req, GLUSTERFS_INODELK_COUNT, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_INODELK_COUNT);
-        }
-        ret = dict_set_uint64 (local->xattr_req, GLUSTERFS_ENTRYLK_COUNT, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_ENTRYLK_COUNT);
-        }
-
-        ret = dict_set_uint32 (local->xattr_req, GLUSTERFS_PARENT_ENTRYLK, 0);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "%s: Unable to set dict value for %s",
-                        loc->path, GLUSTERFS_PARENT_ENTRYLK);
-        }
-
-        ret = dict_set_str (local->xattr_req, "link-count",
-                            GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
-        }
-
-        ret = 0;
+afr_lookup_xattr_req_prepare(afr_local_t *local, xlator_t *this,
+                             dict_t *xattr_req, loc_t *loc)
+{
+    int ret = -ENOMEM;
+
+    if (!local->xattr_req)
+        local->xattr_req = dict_new();
+
+    if (!local->xattr_req)
+        goto out;
+
+    if (xattr_req && (xattr_req != local->xattr_req))
+        dict_copy(xattr_req, local->xattr_req);
+
+    ret = afr_xattr_req_prepare(this, local->xattr_req);
+
+    ret = dict_set_uint64(local->xattr_req, GLUSTERFS_INODELK_COUNT, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_INODELK_COUNT);
+    }
+    ret = dict_set_uint64(local->xattr_req, GLUSTERFS_ENTRYLK_COUNT, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_ENTRYLK_COUNT);
+    }
+
+    ret = dict_set_uint32(local->xattr_req, GLUSTERFS_PARENT_ENTRYLK, 0);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Unable to set dict value for %s", loc->path,
+               GLUSTERFS_PARENT_ENTRYLK);
+    }
+
+    ret = dict_set_str(local->xattr_req, "link-count", GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_least_pending_reads_child (afr_private_t *priv)
-{
-        int i = 0;
-        int child = 0;
-        int64_t read_iter = -1;
-        int64_t pending_read = -1;
-
-        pending_read = GF_ATOMIC_GET (priv->pending_reads[0]);
-        for (i = 1; i < priv->child_count; i++) {
-                if (AFR_IS_ARBITER_BRICK(priv, i))
-                        continue;
-                read_iter =  GF_ATOMIC_GET(priv->pending_reads[i]);
-                if (read_iter < pending_read) {
-                        pending_read = read_iter;
-                        child = i;
-                }
+afr_least_pending_reads_child(afr_private_t *priv)
+{
+    int i = 0;
+    int child = 0;
+    int64_t read_iter = -1;
+    int64_t pending_read = -1;
+
+    pending_read = GF_ATOMIC_GET(priv->pending_reads[0]);
+    for (i = 1; i < priv->child_count; i++) {
+        if (AFR_IS_ARBITER_BRICK(priv, i))
+            continue;
+        read_iter = GF_ATOMIC_GET(priv->pending_reads[i]);
+        if (read_iter < pending_read) {
+            pending_read = read_iter;
+            child = i;
         }
+    }
 
-        return child;
+    return child;
 }
 
 int
-afr_hash_child (afr_read_subvol_args_t *args, afr_private_t *priv)
+afr_hash_child(afr_read_subvol_args_t *args, afr_private_t *priv)
 {
-        uuid_t gfid_copy = {0,};
-        pid_t pid;
-        int child = -1;
+    uuid_t gfid_copy = {
+        0,
+    };
+    pid_t pid;
+    int child = -1;
 
-        switch (priv->hash_mode) {
+    switch (priv->hash_mode) {
         case 0:
-                break;
+            break;
         case 1:
-                gf_uuid_copy (gfid_copy, args->gfid);
-                child = SuperFastHash((char *)gfid_copy,
-                                      sizeof(gfid_copy)) % priv->child_count;
-                break;
+            gf_uuid_copy(gfid_copy, args->gfid);
+            child = SuperFastHash((char *)gfid_copy, sizeof(gfid_copy)) %
+                    priv->child_count;
+            break;
         case 2:
-                if (args->ia_type != IA_IFDIR) {
-                        /*
-                         * Why getpid?  Because it's one of the cheapest calls
-                         * available - faster than gethostname etc. - and
-                         * returns a constant-length value that's sure to be
-                         * shorter than a UUID. It's still very unlikely to be
-                         * the same across clients, so it still provides good
-                         * mixing.  We're not trying for perfection here. All we
-                         * need is a low probability that multiple clients
-                         * won't converge on the same subvolume.
-                         */
-                        pid = getpid();
-                        memcpy (gfid_copy, &pid, sizeof(pid));
-                }
-                child = SuperFastHash((char *)gfid_copy,
-                                      sizeof(gfid_copy)) % priv->child_count;
-                break;
+            if (args->ia_type != IA_IFDIR) {
+                /*
+                 * Why getpid?  Because it's one of the cheapest calls
+                 * available - faster than gethostname etc. - and
+                 * returns a constant-length value that's sure to be
+                 * shorter than a UUID. It's still very unlikely to be
+                 * the same across clients, so it still provides good
+                 * mixing.  We're not trying for perfection here. All we
+                 * need is a low probability that multiple clients
+                 * won't converge on the same subvolume.
+                 */
+                pid = getpid();
+                memcpy(gfid_copy, &pid, sizeof(pid));
+            }
+            child = SuperFastHash((char *)gfid_copy, sizeof(gfid_copy)) %
+                    priv->child_count;
+            break;
         case 3:
-                child = afr_least_pending_reads_child (priv);
-                break;
-        }
+            child = afr_least_pending_reads_child(priv);
+            break;
+    }
 
-        return child;
+    return child;
 }
 
 int
-afr_read_subvol_select_by_policy (inode_t *inode, xlator_t *this,
-				  unsigned char *readable,
-                                  afr_read_subvol_args_t *args)
-{
-	int             i           = 0;
-	int             read_subvol = -1;
-	afr_private_t  *priv        = NULL;
-        afr_read_subvol_args_t local_args = {0,};
-
-	priv = this->private;
-
-	/* first preference - explicitly specified or local subvolume */
-	if (priv->read_child >= 0 && readable[priv->read_child])
-                return priv->read_child;
-
-        if (inode_is_linked (inode)) {
-                gf_uuid_copy (local_args.gfid, inode->gfid);
-                local_args.ia_type = inode->ia_type;
-        } else if (args) {
-                local_args = *args;
-        }
+afr_read_subvol_select_by_policy(inode_t *inode, xlator_t *this,
+                                 unsigned char *readable,
+                                 afr_read_subvol_args_t *args)
+{
+    int i = 0;
+    int read_subvol = -1;
+    afr_private_t *priv = NULL;
+    afr_read_subvol_args_t local_args = {
+        0,
+    };
 
-	/* second preference - use hashed mode */
-        read_subvol = afr_hash_child (&local_args, priv);
-	if (read_subvol >= 0 && readable[read_subvol])
-                return read_subvol;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (readable[i])
-                return i;
-	}
+    /* first preference - explicitly specified or local subvolume */
+    if (priv->read_child >= 0 && readable[priv->read_child])
+        return priv->read_child;
 
-        /* no readable subvolumes, either split brain or all subvols down */
+    if (inode_is_linked(inode)) {
+        gf_uuid_copy(local_args.gfid, inode->gfid);
+        local_args.ia_type = inode->ia_type;
+    } else if (args) {
+        local_args = *args;
+    }
 
-        return -1;
-}
+    /* second preference - use hashed mode */
+    read_subvol = afr_hash_child(&local_args, priv);
+    if (read_subvol >= 0 && readable[read_subvol])
+        return read_subvol;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (readable[i])
+            return i;
+    }
 
+    /* no readable subvolumes, either split brain or all subvols down */
+
+    return -1;
+}
 
 int
-afr_inode_read_subvol_type_get (inode_t *inode, xlator_t *this,
-				unsigned char *readable, int *event_p,
-				int type)
+afr_inode_read_subvol_type_get(inode_t *inode, xlator_t *this,
+                               unsigned char *readable, int *event_p, int type)
 {
-	int ret = -1;
+    int ret = -1;
 
-	if (type == AFR_METADATA_TRANSACTION)
-		ret = afr_inode_read_subvol_get (inode, this, 0, readable,
-						 event_p);
-	else
-		ret = afr_inode_read_subvol_get (inode, this, readable, 0,
-						 event_p);
-	return ret;
+    if (type == AFR_METADATA_TRANSACTION)
+        ret = afr_inode_read_subvol_get(inode, this, 0, readable, event_p);
+    else
+        ret = afr_inode_read_subvol_get(inode, this, readable, 0, event_p);
+    return ret;
 }
 
 void
-afr_readables_intersect_get (inode_t *inode, xlator_t *this, int *event,
-                             unsigned char *intersection)
+afr_readables_intersect_get(inode_t *inode, xlator_t *this, int *event,
+                            unsigned char *intersection)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *data_readable = NULL;
-	unsigned char *metadata_readable = NULL;
-	unsigned char *intersect = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    unsigned char *intersect = NULL;
 
-	priv = this->private;
-	data_readable = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-	intersect = alloca0 (priv->child_count);
+    priv = this->private;
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+    intersect = alloca0(priv->child_count);
 
-	afr_inode_read_subvol_get (inode, this, data_readable,
-                                   metadata_readable, event);
+    afr_inode_read_subvol_get(inode, this, data_readable, metadata_readable,
+                              event);
 
-	AFR_INTERSECT (intersect, data_readable, metadata_readable,
-		       priv->child_count);
-        if (intersection)
-                memcpy (intersection, intersect,
-                        sizeof (*intersection) * priv->child_count);
+    AFR_INTERSECT(intersect, data_readable, metadata_readable,
+                  priv->child_count);
+    if (intersection)
+        memcpy(intersection, intersect,
+               sizeof(*intersection) * priv->child_count);
 }
 
 int
-afr_read_subvol_get (inode_t *inode, xlator_t *this, int *subvol_p,
-                     unsigned char *readables,
-		     int *event_p, afr_transaction_type type,
-                     afr_read_subvol_args_t *args)
+afr_read_subvol_get(inode_t *inode, xlator_t *this, int *subvol_p,
+                    unsigned char *readables, int *event_p,
+                    afr_transaction_type type, afr_read_subvol_args_t *args)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *readable = NULL;
-	unsigned char *intersection = NULL;
-	int subvol = -1;
-	int event = 0;
+    afr_private_t *priv = NULL;
+    unsigned char *readable = NULL;
+    unsigned char *intersection = NULL;
+    int subvol = -1;
+    int event = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	readable = alloca0 (priv->child_count);
-	intersection = alloca0 (priv->child_count);
+    readable = alloca0(priv->child_count);
+    intersection = alloca0(priv->child_count);
 
-	afr_inode_read_subvol_type_get (inode, this, readable, &event, type);
+    afr_inode_read_subvol_type_get(inode, this, readable, &event, type);
 
-        afr_readables_intersect_get (inode, this, &event, intersection);
+    afr_readables_intersect_get(inode, this, &event, intersection);
 
-	if (AFR_COUNT (intersection, priv->child_count) > 0)
-		subvol = afr_read_subvol_select_by_policy (inode, this,
-							   intersection, args);
-	else
-		subvol = afr_read_subvol_select_by_policy (inode, this,
-							   readable, args);
-	if (subvol_p)
-		*subvol_p = subvol;
-	if (event_p)
-		*event_p = event;
-        if (readables)
-                memcpy (readables, readable,
-                        sizeof (*readables) * priv->child_count);
-	return subvol;
+    if (AFR_COUNT(intersection, priv->child_count) > 0)
+        subvol = afr_read_subvol_select_by_policy(inode, this, intersection,
+                                                  args);
+    else
+        subvol = afr_read_subvol_select_by_policy(inode, this, readable, args);
+    if (subvol_p)
+        *subvol_p = subvol;
+    if (event_p)
+        *event_p = event;
+    if (readables)
+        memcpy(readables, readable, sizeof(*readables) * priv->child_count);
+    return subvol;
 }
 
-
 void
-afr_local_transaction_cleanup (afr_local_t *local, xlator_t *this)
+afr_local_transaction_cleanup(afr_local_t *local, xlator_t *this)
 {
-        afr_private_t *priv    = NULL;
-        int           i        = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        afr_matrix_cleanup (local->pending, priv->child_count);
+    afr_matrix_cleanup(local->pending, priv->child_count);
 
-        GF_FREE (local->internal_lock.locked_nodes);
+    GF_FREE(local->internal_lock.locked_nodes);
 
-        GF_FREE (local->internal_lock.lower_locked_nodes);
+    GF_FREE(local->internal_lock.lower_locked_nodes);
 
-        afr_entry_lockee_cleanup (&local->internal_lock);
+    afr_entry_lockee_cleanup(&local->internal_lock);
 
-        GF_FREE (local->transaction.pre_op);
+    GF_FREE(local->transaction.pre_op);
 
-        GF_FREE (local->transaction.pre_op_sources);
-        if (local->transaction.changelog_xdata) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->transaction.changelog_xdata[i])
-                                continue;
-                        dict_unref (local->transaction.changelog_xdata[i]);
-                }
-                GF_FREE (local->transaction.changelog_xdata);
+    GF_FREE(local->transaction.pre_op_sources);
+    if (local->transaction.changelog_xdata) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (!local->transaction.changelog_xdata[i])
+                continue;
+            dict_unref(local->transaction.changelog_xdata[i]);
         }
+        GF_FREE(local->transaction.changelog_xdata);
+    }
 
-        GF_FREE (local->transaction.failed_subvols);
+    GF_FREE(local->transaction.failed_subvols);
 
-        GF_FREE (local->transaction.basename);
-        GF_FREE (local->transaction.new_basename);
-
-        loc_wipe (&local->transaction.parent_loc);
-        loc_wipe (&local->transaction.new_parent_loc);
+    GF_FREE(local->transaction.basename);
+    GF_FREE(local->transaction.new_basename);
 
+    loc_wipe(&local->transaction.parent_loc);
+    loc_wipe(&local->transaction.new_parent_loc);
 }
 
 void
-afr_reply_wipe (struct afr_reply *reply)
+afr_reply_wipe(struct afr_reply *reply)
 {
-        if (reply->xdata) {
-                dict_unref (reply->xdata);
-                reply->xdata = NULL;
-        }
+    if (reply->xdata) {
+        dict_unref(reply->xdata);
+        reply->xdata = NULL;
+    }
 
-        if (reply->xattr) {
-                dict_unref (reply->xattr);
-                reply->xattr = NULL;
-        }
+    if (reply->xattr) {
+        dict_unref(reply->xattr);
+        reply->xattr = NULL;
+    }
 }
 
 void
-afr_replies_wipe (struct afr_reply *replies, int count)
+afr_replies_wipe(struct afr_reply *replies, int count)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < count; i++) {
-                afr_reply_wipe (&replies[i]);
-        }
+    for (i = 0; i < count; i++) {
+        afr_reply_wipe(&replies[i]);
+    }
 }
 
 void
-afr_local_replies_wipe (afr_local_t *local, afr_private_t *priv)
+afr_local_replies_wipe(afr_local_t *local, afr_private_t *priv)
 {
+    if (!local->replies)
+        return;
 
-	if (!local->replies)
-		return;
-
-        afr_replies_wipe (local->replies, priv->child_count);
+    afr_replies_wipe(local->replies, priv->child_count);
 
-	memset (local->replies, 0, sizeof(*local->replies) * priv->child_count);
+    memset(local->replies, 0, sizeof(*local->replies) * priv->child_count);
 }
 
 static gf_boolean_t
-afr_fop_lock_is_unlock (call_frame_t *frame)
+afr_fop_lock_is_unlock(call_frame_t *frame)
 {
-        afr_local_t *local = frame->local;
-        switch (local->op) {
+    afr_local_t *local = frame->local;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                if ((F_UNLCK == local->cont.inodelk.in_flock.l_type) &&
-                   (local->cont.inodelk.in_cmd == F_SETLKW ||
-                    local->cont.inodelk.in_cmd == F_SETLK))
-                        return _gf_true;
-                break;
+            if ((F_UNLCK == local->cont.inodelk.in_flock.l_type) &&
+                (local->cont.inodelk.in_cmd == F_SETLKW ||
+                 local->cont.inodelk.in_cmd == F_SETLK))
+                return _gf_true;
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                if (ENTRYLK_UNLOCK == local->cont.entrylk.in_cmd)
-                        return _gf_true;
-                break;
+            if (ENTRYLK_UNLOCK == local->cont.entrylk.in_cmd)
+                return _gf_true;
+            break;
         default:
-                return _gf_false;
-        }
-        return _gf_false;
+            return _gf_false;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_lk_is_unlock (int32_t cmd, struct gf_flock *flock)
+afr_lk_is_unlock(int32_t cmd, struct gf_flock *flock)
 {
-        switch (cmd) {
+    switch (cmd) {
         case F_RESLK_UNLCK:
-                return _gf_true;
-                break;
+            return _gf_true;
+            break;
 
 #if F_SETLKW != F_SETLKW64
         case F_SETLKW64:
@@ -1953,571 +1898,565 @@ afr_lk_is_unlock (int32_t cmd, struct gf_flock *flock)
         case F_SETLK64:
 #endif
         case F_SETLK:
-                if (F_UNLCK == flock->l_type)
-                        return _gf_true;
-                break;
+            if (F_UNLCK == flock->l_type)
+                return _gf_true;
+            break;
         default:
-                return _gf_false;
-        }
-        return _gf_false;
+            return _gf_false;
+    }
+    return _gf_false;
 }
 
 void
-afr_handle_inconsistent_fop (call_frame_t *frame, int32_t *op_ret,
-                             int32_t *op_errno)
+afr_handle_inconsistent_fop(call_frame_t *frame, int32_t *op_ret,
+                            int32_t *op_errno)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t   *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        if (!frame || !frame->this || !frame->local || !frame->this->private)
-                return;
+    if (!frame || !frame->this || !frame->local || !frame->this->private)
+        return;
 
-        if (*op_ret < 0)
-                return;
+    if (*op_ret < 0)
+        return;
 
-        /* Failing inodelk/entrylk/lk here is not a good idea because we
-         * need to cleanup the locks on the other bricks if we choose to fail
-         * the fop here. The brick may go down just after unwind happens as well
-         * so anyways the fop will fail when the next fop is sent so leaving
-         * it like this for now.*/
-        local = frame->local;
-        switch (local->op) {
+    /* Failing inodelk/entrylk/lk here is not a good idea because we
+     * need to cleanup the locks on the other bricks if we choose to fail
+     * the fop here. The brick may go down just after unwind happens as well
+     * so anyways the fop will fail when the next fop is sent so leaving
+     * it like this for now.*/
+    local = frame->local;
+    switch (local->op) {
         case GF_FOP_LOOKUP:
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
         case GF_FOP_LK:
-                return;
+            return;
         default:
-                break;
-        }
+            break;
+    }
 
-        priv = frame->this->private;
-        if (!priv->consistent_io)
-                return;
+    priv = frame->this->private;
+    if (!priv->consistent_io)
+        return;
 
-        if (local->event_generation &&
-            (local->event_generation != priv->event_generation))
-                goto inconsistent;
+    if (local->event_generation &&
+        (local->event_generation != priv->event_generation))
+        goto inconsistent;
 
-        return;
+    return;
 inconsistent:
-        *op_ret = -1;
-        *op_errno = ENOTCONN;
+    *op_ret = -1;
+    *op_errno = ENOTCONN;
 }
 
 void
-afr_local_cleanup (afr_local_t *local, xlator_t *this)
+afr_local_cleanup(afr_local_t *local, xlator_t *this)
 {
-        afr_private_t * priv = NULL;
-
-        if (!local)
-                return;
-
-	syncbarrier_destroy (&local->barrier);
-
-        afr_local_transaction_cleanup (local, this);
-
-        priv = this->private;
+    afr_private_t *priv = NULL;
 
-        loc_wipe (&local->loc);
-        loc_wipe (&local->newloc);
+    if (!local)
+        return;
 
-        if (local->fd)
-                fd_unref (local->fd);
+    syncbarrier_destroy(&local->barrier);
 
-        if (local->xattr_req)
-                dict_unref (local->xattr_req);
+    afr_local_transaction_cleanup(local, this);
 
-        if (local->xattr_rsp)
-                dict_unref (local->xattr_rsp);
+    priv = this->private;
 
-        if (local->dict)
-                dict_unref (local->dict);
+    loc_wipe(&local->loc);
+    loc_wipe(&local->newloc);
 
-        afr_local_replies_wipe (local, priv);
-	GF_FREE(local->replies);
+    if (local->fd)
+        fd_unref(local->fd);
 
-        GF_FREE (local->child_up);
+    if (local->xattr_req)
+        dict_unref(local->xattr_req);
 
-        GF_FREE (local->read_attempted);
+    if (local->xattr_rsp)
+        dict_unref(local->xattr_rsp);
 
-        GF_FREE (local->readable);
-        GF_FREE (local->readable2);
+    if (local->dict)
+        dict_unref(local->dict);
 
-	if (local->inode)
-		inode_unref (local->inode);
+    afr_local_replies_wipe(local, priv);
+    GF_FREE(local->replies);
 
-	if (local->parent)
-		inode_unref (local->parent);
+    GF_FREE(local->child_up);
 
-	if (local->parent2)
-		inode_unref (local->parent2);
+    GF_FREE(local->read_attempted);
 
-	if (local->refreshinode)
-		inode_unref (local->refreshinode);
+    GF_FREE(local->readable);
+    GF_FREE(local->readable2);
 
-        { /* getxattr */
-                GF_FREE (local->cont.getxattr.name);
-        }
+    if (local->inode)
+        inode_unref(local->inode);
 
-        { /* lk */
-                GF_FREE (local->cont.lk.locked_nodes);
-        }
+    if (local->parent)
+        inode_unref(local->parent);
 
-        { /* create */
-                if (local->cont.create.fd)
-                        fd_unref (local->cont.create.fd);
-                if (local->cont.create.params)
-                        dict_unref (local->cont.create.params);
-        }
+    if (local->parent2)
+        inode_unref(local->parent2);
 
-        { /* mknod */
-                if (local->cont.mknod.params)
-                        dict_unref (local->cont.mknod.params);
-        }
+    if (local->refreshinode)
+        inode_unref(local->refreshinode);
 
-        { /* mkdir */
-                if (local->cont.mkdir.params)
-                        dict_unref (local->cont.mkdir.params);
-        }
+    { /* getxattr */
+        GF_FREE(local->cont.getxattr.name);
+    }
 
-        { /* symlink */
-                if (local->cont.symlink.params)
-                        dict_unref (local->cont.symlink.params);
-        }
+    { /* lk */
+        GF_FREE(local->cont.lk.locked_nodes);
+    }
 
-        { /* writev */
-                GF_FREE (local->cont.writev.vector);
-                if (local->cont.writev.iobref)
-                        iobref_unref (local->cont.writev.iobref);
-        }
+    { /* create */
+        if (local->cont.create.fd)
+            fd_unref(local->cont.create.fd);
+        if (local->cont.create.params)
+            dict_unref(local->cont.create.params);
+    }
 
-        { /* setxattr */
-                if (local->cont.setxattr.dict)
-                        dict_unref (local->cont.setxattr.dict);
-        }
+    { /* mknod */
+        if (local->cont.mknod.params)
+            dict_unref(local->cont.mknod.params);
+    }
 
-        { /* fsetxattr */
-                if (local->cont.fsetxattr.dict)
-                        dict_unref (local->cont.fsetxattr.dict);
-        }
+    { /* mkdir */
+        if (local->cont.mkdir.params)
+            dict_unref(local->cont.mkdir.params);
+    }
 
-        { /* removexattr */
-                GF_FREE (local->cont.removexattr.name);
-        }
-        { /* xattrop */
-                if (local->cont.xattrop.xattr)
-                        dict_unref (local->cont.xattrop.xattr);
-        }
-        { /* symlink */
-                GF_FREE (local->cont.symlink.linkpath);
-        }
+    { /* symlink */
+        if (local->cont.symlink.params)
+            dict_unref(local->cont.symlink.params);
+    }
 
-        { /* opendir */
-                GF_FREE (local->cont.opendir.checksum);
-        }
+    { /* writev */
+        GF_FREE(local->cont.writev.vector);
+        if (local->cont.writev.iobref)
+            iobref_unref(local->cont.writev.iobref);
+    }
 
-        { /* open */
-                if (local->cont.open.fd)
-                        fd_unref (local->cont.open.fd);
-        }
+    { /* setxattr */
+        if (local->cont.setxattr.dict)
+            dict_unref(local->cont.setxattr.dict);
+    }
 
-        { /* readdirp */
-                if (local->cont.readdir.dict)
-                        dict_unref (local->cont.readdir.dict);
-        }
+    { /* fsetxattr */
+        if (local->cont.fsetxattr.dict)
+            dict_unref(local->cont.fsetxattr.dict);
+    }
 
-        { /* inodelk */
-                GF_FREE (local->cont.inodelk.volume);
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-        }
+    { /* removexattr */
+        GF_FREE(local->cont.removexattr.name);
+    }
+    { /* xattrop */
+        if (local->cont.xattrop.xattr)
+            dict_unref(local->cont.xattrop.xattr);
+    }
+    { /* symlink */
+        GF_FREE(local->cont.symlink.linkpath);
+    }
 
-        { /* entrylk */
-                GF_FREE (local->cont.entrylk.volume);
-                GF_FREE (local->cont.entrylk.basename);
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-        }
+    { /* opendir */
+        GF_FREE(local->cont.opendir.checksum);
+    }
 
-        if (local->xdata_req)
-                dict_unref (local->xdata_req);
+    { /* open */
+        if (local->cont.open.fd)
+            fd_unref(local->cont.open.fd);
+    }
 
-        if (local->xdata_rsp)
-                dict_unref (local->xdata_rsp);
+    { /* readdirp */
+        if (local->cont.readdir.dict)
+            dict_unref(local->cont.readdir.dict);
+    }
+
+    { /* inodelk */
+        GF_FREE(local->cont.inodelk.volume);
+        if (local->cont.inodelk.xdata)
+            dict_unref(local->cont.inodelk.xdata);
+    }
+
+    { /* entrylk */
+        GF_FREE(local->cont.entrylk.volume);
+        GF_FREE(local->cont.entrylk.basename);
+        if (local->cont.entrylk.xdata)
+            dict_unref(local->cont.entrylk.xdata);
+    }
+
+    if (local->xdata_req)
+        dict_unref(local->xdata_req);
+
+    if (local->xdata_rsp)
+        dict_unref(local->xdata_rsp);
 }
 
-
 int
-afr_frame_return (call_frame_t *frame)
+afr_frame_return(call_frame_t *frame)
 {
-        afr_local_t *local = NULL;
-        int          call_count = 0;
+    afr_local_t *local = NULL;
+    int call_count = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                call_count = --local->call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        call_count = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        return call_count;
+    return call_count;
 }
 
-static char *afr_ignore_xattrs[] = {
-        GF_SELINUX_XATTR_KEY,
-        QUOTA_SIZE_KEY,
-        NULL
-};
+static char *afr_ignore_xattrs[] = {GF_SELINUX_XATTR_KEY, QUOTA_SIZE_KEY, NULL};
 
 gf_boolean_t
-afr_is_xattr_ignorable (char *key)
+afr_is_xattr_ignorable(char *key)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!strncmp (key, AFR_XATTR_PREFIX, SLEN (AFR_XATTR_PREFIX)))
-                return _gf_true;
-        for (i = 0; afr_ignore_xattrs[i]; i++) {
-                if (!strcmp (key, afr_ignore_xattrs[i]))
-                       return _gf_true;
-        }
-        return _gf_false;
+    if (!strncmp(key, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX)))
+        return _gf_true;
+    for (i = 0; afr_ignore_xattrs[i]; i++) {
+        if (!strcmp(key, afr_ignore_xattrs[i]))
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_xattr_match_needed (dict_t *this, char *key1, data_t *value1, void *data)
+afr_xattr_match_needed(dict_t *this, char *key1, data_t *value1, void *data)
 {
-        /* Ignore all non-disk (i.e. virtual) xattrs right away. */
-        if (!gf_is_valid_xattr_namespace (key1))
-                return _gf_false;
+    /* Ignore all non-disk (i.e. virtual) xattrs right away. */
+    if (!gf_is_valid_xattr_namespace(key1))
+        return _gf_false;
 
-        /* Ignore on-disk xattrs that AFR doesn't need to heal. */
-        if (!afr_is_xattr_ignorable (key1))
-                return _gf_true;
+    /* Ignore on-disk xattrs that AFR doesn't need to heal. */
+    if (!afr_is_xattr_ignorable(key1))
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 gf_boolean_t
-afr_xattrs_are_equal (dict_t *dict1, dict_t *dict2)
+afr_xattrs_are_equal(dict_t *dict1, dict_t *dict2)
 {
-        return are_dicts_equal (dict1, dict2, afr_xattr_match_needed, NULL);
+    return are_dicts_equal(dict1, dict2, afr_xattr_match_needed, NULL);
 }
 
 static int
-afr_get_parent_read_subvol (xlator_t *this, inode_t *parent,
-                            struct afr_reply *replies, unsigned char *readable)
+afr_get_parent_read_subvol(xlator_t *this, inode_t *parent,
+                           struct afr_reply *replies, unsigned char *readable)
 {
-        int             i                    = 0;
-        int             par_read_subvol      = -1;
-        int             par_read_subvol_iter = -1;
-        afr_private_t  *priv                 = NULL;
-
-        priv = this->private;
+    int i = 0;
+    int par_read_subvol = -1;
+    int par_read_subvol_iter = -1;
+    afr_private_t *priv = NULL;
 
-        if (parent)
-                par_read_subvol = afr_data_subvol_get (parent, this, NULL, NULL,
-                                                       NULL, NULL);
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid)
-                        continue;
+    if (parent)
+        par_read_subvol = afr_data_subvol_get(parent, this, NULL, NULL, NULL,
+                                              NULL);
 
-                if (replies[i].op_ret < 0)
-                        continue;
-
-                if (par_read_subvol_iter == -1) {
-                        par_read_subvol_iter = i;
-                        continue;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if ((par_read_subvol_iter != par_read_subvol) && readable[i])
-                        par_read_subvol_iter = i;
+        if (replies[i].op_ret < 0)
+            continue;
 
-                if (i == par_read_subvol)
-                        par_read_subvol_iter = i;
+        if (par_read_subvol_iter == -1) {
+            par_read_subvol_iter = i;
+            continue;
         }
-        /* At the end of the for-loop, the only reason why @par_read_subvol_iter
-         * could be -1 is when this LOOKUP has failed on all sub-volumes.
-         * So it is okay to send an arbitrary subvolume (0 in this case)
-         * as parent read subvol.
-         */
-        if (par_read_subvol_iter == -1)
-                par_read_subvol_iter = 0;
 
-        return par_read_subvol_iter;
+        if ((par_read_subvol_iter != par_read_subvol) && readable[i])
+            par_read_subvol_iter = i;
+
+        if (i == par_read_subvol)
+            par_read_subvol_iter = i;
+    }
+    /* At the end of the for-loop, the only reason why @par_read_subvol_iter
+     * could be -1 is when this LOOKUP has failed on all sub-volumes.
+     * So it is okay to send an arbitrary subvolume (0 in this case)
+     * as parent read subvol.
+     */
+    if (par_read_subvol_iter == -1)
+        par_read_subvol_iter = 0;
 
+    return par_read_subvol_iter;
 }
 
 int
-afr_read_subvol_decide (inode_t *inode, xlator_t *this,
-                        afr_read_subvol_args_t *args, unsigned char *readable)
+afr_read_subvol_decide(inode_t *inode, xlator_t *this,
+                       afr_read_subvol_args_t *args, unsigned char *readable)
 {
-        int event = 0;
-        afr_private_t *priv = NULL;
-        unsigned char *intersection = NULL;
+    int event = 0;
+    afr_private_t *priv = NULL;
+    unsigned char *intersection = NULL;
 
-        priv = this->private;
-        intersection = alloca0 (priv->child_count);
+    priv = this->private;
+    intersection = alloca0(priv->child_count);
 
-        afr_readables_intersect_get (inode, this, &event, intersection);
+    afr_readables_intersect_get(inode, this, &event, intersection);
 
-        if (AFR_COUNT (intersection, priv->child_count) <= 0) {
-                /* TODO: If we have one brick with valid data_readable and
-                 * another with metadata_readable, try to send an iatt with
-                 * valid bits from both.*/
-                return -1;
-        }
+    if (AFR_COUNT(intersection, priv->child_count) <= 0) {
+        /* TODO: If we have one brick with valid data_readable and
+         * another with metadata_readable, try to send an iatt with
+         * valid bits from both.*/
+        return -1;
+    }
 
-        memcpy (readable, intersection, sizeof (*readable) * priv->child_count);
+    memcpy(readable, intersection, sizeof(*readable) * priv->child_count);
 
-        return afr_read_subvol_select_by_policy (inode, this, intersection,
-                                                 args);
+    return afr_read_subvol_select_by_policy(inode, this, intersection, args);
 }
 
 static inline int
-afr_first_up_child (call_frame_t *frame, xlator_t *this)
+afr_first_up_child(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-        int                  i     = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++)
-                if (local->replies[i].valid &&
-                    local->replies[i].op_ret == 0)
-                        return i;
-        return -1;
+    for (i = 0; i < priv->child_count; i++)
+        if (local->replies[i].valid && local->replies[i].op_ret == 0)
+            return i;
+    return -1;
 }
 
 static void
-afr_attempt_readsubvol_set (call_frame_t *frame, xlator_t *this,
-                            unsigned char *success_replies,
-                            unsigned char *data_readable, int *read_subvol)
+afr_attempt_readsubvol_set(call_frame_t *frame, xlator_t *this,
+                           unsigned char *success_replies,
+                           unsigned char *data_readable, int *read_subvol)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int spb_choice = -1;
-        int child_count = -1;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int spb_choice = -1;
+    int child_count = -1;
 
-        if (*read_subvol != -1)
-                return;
+    if (*read_subvol != -1)
+        return;
 
-        priv = this->private;
-        local = frame->local;
-        child_count = priv->child_count;
-
-        afr_inode_split_brain_choice_get (local->inode, this,
-                                          &spb_choice);
-        if ((spb_choice >= 0) &&
-            (AFR_COUNT(success_replies, child_count) == child_count)) {
-                *read_subvol = spb_choice;
-        } else if (!priv->quorum_count) {
-                *read_subvol = afr_first_up_child (frame, this);
-        } else if (priv->quorum_count &&
-                   afr_has_quorum (data_readable, this)) {
-                /* read_subvol is guaranteed to be valid if we hit this path. */
-                *read_subvol = afr_first_up_child (frame, this);
-        } else {
-               /* If quorum is enabled and we do not have a
-                  readable yet, it means all good copies are down.
-               */
-               local->op_ret = -1;
-               local->op_errno = ENOTCONN;
-               gf_msg (this->name, GF_LOG_WARNING, 0,
-                       AFR_MSG_READ_SUBVOL_ERROR, "no read "
-                       "subvols for %s", local->loc.path);
-        }
-        if (*read_subvol >= 0)
-                dict_del (local->replies[*read_subvol].xdata, GF_CONTENT_KEY);
+    priv = this->private;
+    local = frame->local;
+    child_count = priv->child_count;
+
+    afr_inode_split_brain_choice_get(local->inode, this, &spb_choice);
+    if ((spb_choice >= 0) &&
+        (AFR_COUNT(success_replies, child_count) == child_count)) {
+        *read_subvol = spb_choice;
+    } else if (!priv->quorum_count) {
+        *read_subvol = afr_first_up_child(frame, this);
+    } else if (priv->quorum_count && afr_has_quorum(data_readable, this)) {
+        /* read_subvol is guaranteed to be valid if we hit this path. */
+        *read_subvol = afr_first_up_child(frame, this);
+    } else {
+        /* If quorum is enabled and we do not have a
+           readable yet, it means all good copies are down.
+        */
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_READ_SUBVOL_ERROR,
+               "no read "
+               "subvols for %s",
+               local->loc.path);
+    }
+    if (*read_subvol >= 0)
+        dict_del(local->replies[*read_subvol].xdata, GF_CONTENT_KEY);
 }
 
 static void
-afr_lookup_done (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-	int                 i = -1;
-	int                 op_errno = 0;
-	int                 read_subvol = 0;
-        int                 par_read_subvol = 0;
-        int                 ret         = -1;
-	unsigned char      *readable = NULL;
-        unsigned char      *success_replies = NULL;
-	int                 event = 0;
-	struct afr_reply   *replies = NULL;
-	uuid_t              read_gfid = {0, };
-	gf_boolean_t        locked_entry = _gf_false;
-	gf_boolean_t        can_interpret = _gf_true;
-        inode_t            *parent = NULL;
-        ia_type_t           ia_type = IA_INVAL;
-        afr_read_subvol_args_t args = {0,};
-        char               *gfid_heal_msg = NULL;
-
-        priv  = this->private;
-        local = frame->local;
-	replies = local->replies;
-        parent = local->loc.parent;
-
-	locked_entry = afr_is_possibly_under_txn (AFR_ENTRY_TRANSACTION, local,
-                                                  this);
-
-	readable = alloca0 (priv->child_count);
-	success_replies = alloca0 (priv->child_count);
-
-	afr_inode_read_subvol_get (parent, this, readable, NULL, &event);
-        par_read_subvol = afr_get_parent_read_subvol (this, parent, replies,
-                                                      readable);
-
-	/* First, check if we have a gfid-change from somewhere,
-	   If so, propagate that so that a fresh lookup can be
-	   issued
-	*/
-        if (local->cont.lookup.needs_fresh_lookup) {
-                local->op_ret = -1;
-                local->op_errno = ESTALE;
-                goto error;
+afr_lookup_done(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = -1;
+    int op_errno = 0;
+    int read_subvol = 0;
+    int par_read_subvol = 0;
+    int ret = -1;
+    unsigned char *readable = NULL;
+    unsigned char *success_replies = NULL;
+    int event = 0;
+    struct afr_reply *replies = NULL;
+    uuid_t read_gfid = {
+        0,
+    };
+    gf_boolean_t locked_entry = _gf_false;
+    gf_boolean_t can_interpret = _gf_true;
+    inode_t *parent = NULL;
+    ia_type_t ia_type = IA_INVAL;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+    char *gfid_heal_msg = NULL;
+
+    priv = this->private;
+    local = frame->local;
+    replies = local->replies;
+    parent = local->loc.parent;
+
+    locked_entry = afr_is_possibly_under_txn(AFR_ENTRY_TRANSACTION, local,
+                                             this);
+
+    readable = alloca0(priv->child_count);
+    success_replies = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(parent, this, readable, NULL, &event);
+    par_read_subvol = afr_get_parent_read_subvol(this, parent, replies,
+                                                 readable);
+
+    /* First, check if we have a gfid-change from somewhere,
+       If so, propagate that so that a fresh lookup can be
+       issued
+    */
+    if (local->cont.lookup.needs_fresh_lookup) {
+        local->op_ret = -1;
+        local->op_errno = ESTALE;
+        goto error;
+    }
+
+    op_errno = afr_final_errno(frame->local, this->private);
+    local->op_errno = op_errno;
+
+    read_subvol = -1;
+    afr_fill_success_replies(local, priv, success_replies);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (locked_entry && replies[i].op_ret == -1 &&
+            replies[i].op_errno == ENOENT) {
+            /* Second, check entry is still
+               "underway" in creation */
+            local->op_ret = -1;
+            local->op_errno = ENOENT;
+            goto error;
         }
 
-	op_errno = afr_final_errno (frame->local, this->private);
-	local->op_errno = op_errno;
+        if (replies[i].op_ret == -1)
+            continue;
 
-	read_subvol = -1;
-        afr_fill_success_replies (local, priv, success_replies);
+        if (read_subvol == -1 || !readable[read_subvol]) {
+            read_subvol = i;
+            gf_uuid_copy(read_gfid, replies[i].poststat.ia_gfid);
+            ia_type = replies[i].poststat.ia_type;
+            local->op_ret = 0;
+        }
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
+    if (read_subvol == -1)
+        goto error;
+    /* We now have a read_subvol, which is readable[] (if there
+       were any). Next we look for GFID mismatches. We don't
+       consider a GFID mismatch as an error if read_subvol is
+       readable[] but the mismatching GFID subvol is not.
+    */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1) {
+            continue;
+        }
 
-		if (locked_entry && replies[i].op_ret == -1 &&
-		    replies[i].op_errno == ENOENT) {
-			/* Second, check entry is still
-			   "underway" in creation */
-                        local->op_ret = -1;
-                        local->op_errno = ENOENT;
-                        goto error;
-		}
+        if (!gf_uuid_compare(replies[i].poststat.ia_gfid, read_gfid))
+            continue;
 
-		if (replies[i].op_ret == -1)
-			continue;
+        can_interpret = _gf_false;
 
-		if (read_subvol == -1 || !readable[read_subvol]) {
-			read_subvol = i;
-			gf_uuid_copy (read_gfid, replies[i].poststat.ia_gfid);
-                        ia_type = replies[i].poststat.ia_type;
-			local->op_ret = 0;
-		}
-	}
+        if (locked_entry)
+            continue;
 
-        if (read_subvol == -1)
-                goto error;
-	/* We now have a read_subvol, which is readable[] (if there
-	   were any). Next we look for GFID mismatches. We don't
-	   consider a GFID mismatch as an error if read_subvol is
-	   readable[] but the mismatching GFID subvol is not.
-	*/
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid || replies[i].op_ret == -1) {
-			continue;
-		}
-
-		if (!gf_uuid_compare (replies[i].poststat.ia_gfid, read_gfid))
-                        continue;
-
-		can_interpret = _gf_false;
-
-		if (locked_entry)
-			continue;
-
-		/* Now GFIDs mismatch. It's OK as long as this subvol
-		   is not readable[] but read_subvol is */
-		if (readable[read_subvol] && !readable[i])
-			continue;
-
-                /* If we were called from glfsheal and there is still a gfid
-                 * mismatch, succeed the lookup and let glfsheal print the
-                 * response via gfid-heal-msg.*/
-                if (!dict_get_str (local->xattr_req, "gfid-heal-msg",
-                                   &gfid_heal_msg))
-                        goto cant_interpret;
-
-		/* LOG ERROR */
-		local->op_ret = -1;
-		local->op_errno = EIO;
-		goto error;
-	}
-
-	/* Forth, for the finalized GFID, pick the best subvolume
-	   to return stats from.
-	*/
-        read_subvol = -1;
-        memset (readable, 0, sizeof (*readable) * priv->child_count);
-	if (can_interpret) {
-                if (!afr_has_quorum (success_replies, this))
-                        goto cant_interpret;
-		/* It is safe to call afr_replies_interpret() because we have
-		   a response from all the UP subvolumes and all of them resolved
-		   to the same GFID
-		*/
-                gf_uuid_copy (args.gfid, read_gfid);
-                args.ia_type = ia_type;
-		ret = afr_replies_interpret (frame, this, local->inode, NULL);
-                read_subvol = afr_read_subvol_decide (local->inode, this, &args,
-                                                      readable);
-                if (read_subvol == -1)
-                        goto cant_interpret;
-                if (ret) {
-			afr_inode_event_gen_reset (local->inode, this);
-                        dict_del (local->replies[read_subvol].xdata,
-                                  GF_CONTENT_KEY);
-                }
-	} else {
-	cant_interpret:
-                afr_attempt_readsubvol_set (frame, this, success_replies,
-                                            readable, &read_subvol);
-                if (read_subvol == -1) {
-                        goto error;
-                }
-	}
+        /* Now GFIDs mismatch. It's OK as long as this subvol
+           is not readable[] but read_subvol is */
+        if (readable[read_subvol] && !readable[i])
+            continue;
 
-	afr_handle_quota_size (frame, this);
+        /* If we were called from glfsheal and there is still a gfid
+         * mismatch, succeed the lookup and let glfsheal print the
+         * response via gfid-heal-msg.*/
+        if (!dict_get_str(local->xattr_req, "gfid-heal-msg", &gfid_heal_msg))
+            goto cant_interpret;
 
-        afr_set_need_heal (this, local);
-        if (AFR_IS_ARBITER_BRICK (priv, read_subvol) && local->op_ret == 0) {
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-                gf_msg_debug(this->name, 0, "Arbiter cannot be a read subvol "
-                             "for %s", local->loc.path);
-                goto error;
+        /* LOG ERROR */
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        goto error;
+    }
+
+    /* Forth, for the finalized GFID, pick the best subvolume
+       to return stats from.
+    */
+    read_subvol = -1;
+    memset(readable, 0, sizeof(*readable) * priv->child_count);
+    if (can_interpret) {
+        if (!afr_has_quorum(success_replies, this))
+            goto cant_interpret;
+        /* It is safe to call afr_replies_interpret() because we have
+           a response from all the UP subvolumes and all of them resolved
+           to the same GFID
+        */
+        gf_uuid_copy(args.gfid, read_gfid);
+        args.ia_type = ia_type;
+        ret = afr_replies_interpret(frame, this, local->inode, NULL);
+        read_subvol = afr_read_subvol_decide(local->inode, this, &args,
+                                             readable);
+        if (read_subvol == -1)
+            goto cant_interpret;
+        if (ret) {
+            afr_inode_event_gen_reset(local->inode, this);
+            dict_del(local->replies[read_subvol].xdata, GF_CONTENT_KEY);
+        }
+    } else {
+    cant_interpret:
+        afr_attempt_readsubvol_set(frame, this, success_replies, readable,
+                                   &read_subvol);
+        if (read_subvol == -1) {
+            goto error;
         }
+    }
 
-        ret = dict_get_str (local->xattr_req, "gfid-heal-msg", &gfid_heal_msg);
-        if (!ret) {
-                ret = dict_set_str (local->replies[read_subvol].xdata,
-                                    "gfid-heal-msg", gfid_heal_msg);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_DICT_SET_FAILED,
-                                "Error setting gfid-heal-msg dict");
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                }
+    afr_handle_quota_size(frame, this);
+
+    afr_set_need_heal(this, local);
+    if (AFR_IS_ARBITER_BRICK(priv, read_subvol) && local->op_ret == 0) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg_debug(this->name, 0,
+                     "Arbiter cannot be a read subvol "
+                     "for %s",
+                     local->loc.path);
+        goto error;
+    }
+
+    ret = dict_get_str(local->xattr_req, "gfid-heal-msg", &gfid_heal_msg);
+    if (!ret) {
+        ret = dict_set_str(local->replies[read_subvol].xdata, "gfid-heal-msg",
+                           gfid_heal_msg);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting gfid-heal-msg dict");
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
         }
+    }
 
-	AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-			  local->inode, &local->replies[read_subvol].poststat,
-			  local->replies[read_subvol].xdata,
-			  &local->replies[par_read_subvol].postparent);
-        return;
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->replies[read_subvol].poststat,
+                     local->replies[read_subvol].xdata,
+                     &local->replies[par_read_subvol].postparent);
+    return;
 
 error:
-        AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno, NULL,
-                          NULL, NULL, NULL);
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno, NULL, NULL,
+                     NULL, NULL);
 }
 
 /*
@@ -2529,843 +2468,834 @@ error:
  */
 
 int
-afr_higher_errno (int32_t old_errno, int32_t new_errno)
+afr_higher_errno(int32_t old_errno, int32_t new_errno)
 {
-	if (old_errno == ENODATA || new_errno == ENODATA)
-		return ENODATA;
-        if (old_errno == ENOENT || new_errno == ENOENT)
-                return ENOENT;
-	if (old_errno == ESTALE || new_errno == ESTALE)
-		return ESTALE;
+    if (old_errno == ENODATA || new_errno == ENODATA)
+        return ENODATA;
+    if (old_errno == ENOENT || new_errno == ENOENT)
+        return ENOENT;
+    if (old_errno == ESTALE || new_errno == ESTALE)
+        return ESTALE;
 
-	return new_errno;
+    return new_errno;
 }
 
-
 int
-afr_final_errno (afr_local_t *local, afr_private_t *priv)
+afr_final_errno(afr_local_t *local, afr_private_t *priv)
 {
-	int i = 0;
-	int op_errno = 0;
-	int tmp_errno = 0;
+    int i = 0;
+    int op_errno = 0;
+    int tmp_errno = 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret >= 0)
-			continue;
-		tmp_errno = local->replies[i].op_errno;
-		op_errno = afr_higher_errno (op_errno, tmp_errno);
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret >= 0)
+            continue;
+        tmp_errno = local->replies[i].op_errno;
+        op_errno = afr_higher_errno(op_errno, tmp_errno);
+    }
 
-	return op_errno;
+    return op_errno;
 }
 
 static int32_t
-afr_local_discovery_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			 int32_t op_ret, int32_t op_errno, dict_t *dict,
-			 dict_t *xdata)
-{
-        int              ret            = 0;
-        char            *pathinfo       = NULL;
-        gf_boolean_t     is_local        = _gf_false;
-        afr_private_t   *priv           = NULL;
-        int32_t          child_index    = -1;
-
-        if (op_ret != 0) {
-                goto out;
-        }
-
-	priv = this->private;
-	child_index = (int32_t)(long)cookie;
-
-        ret = dict_get_str (dict, GF_XATTR_PATHINFO_KEY, &pathinfo);
-        if (ret != 0) {
-                goto out;
-        }
-
-        ret = glusterfs_is_local_pathinfo (pathinfo, &is_local);
-        if (ret) {
-                goto out;
-        }
-
-        /*
-         * Note that one local subvolume will override another here.  The only
-         * way to avoid that would be to retain extra information about whether
-         * the previous read_child is local, and it's just not worth it.  Even
-         * the slowest local subvolume is far preferable to a remote one.
-         */
-        if (is_local) {
-                priv->local[child_index] = 1;
-                /* Don't set arbiter as read child. */
-                if (AFR_IS_ARBITER_BRICK(priv, child_index))
-                        goto out;
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_LOCAL_CHILD, "selecting local read_child %s",
-                        priv->children[child_index]->name);
-
-                priv->read_child = child_index;
-        }
+afr_local_discovery_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *dict,
+                        dict_t *xdata)
+{
+    int ret = 0;
+    char *pathinfo = NULL;
+    gf_boolean_t is_local = _gf_false;
+    afr_private_t *priv = NULL;
+    int32_t child_index = -1;
+
+    if (op_ret != 0) {
+        goto out;
+    }
+
+    priv = this->private;
+    child_index = (int32_t)(long)cookie;
+
+    ret = dict_get_str(dict, GF_XATTR_PATHINFO_KEY, &pathinfo);
+    if (ret != 0) {
+        goto out;
+    }
+
+    ret = glusterfs_is_local_pathinfo(pathinfo, &is_local);
+    if (ret) {
+        goto out;
+    }
+
+    /*
+     * Note that one local subvolume will override another here.  The only
+     * way to avoid that would be to retain extra information about whether
+     * the previous read_child is local, and it's just not worth it.  Even
+     * the slowest local subvolume is far preferable to a remote one.
+     */
+    if (is_local) {
+        priv->local[child_index] = 1;
+        /* Don't set arbiter as read child. */
+        if (AFR_IS_ARBITER_BRICK(priv, child_index))
+            goto out;
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_LOCAL_CHILD,
+               "selecting local read_child %s",
+               priv->children[child_index]->name);
+
+        priv->read_child = child_index;
+    }
 out:
-        STACK_DESTROY(frame->root);
-        return 0;
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static void
-afr_attempt_local_discovery (xlator_t *this, int32_t child_index)
+afr_attempt_local_discovery(xlator_t *this, int32_t child_index)
 {
-        call_frame_t    *newframe = NULL;
-        loc_t            tmploc = {0,};
-        afr_private_t   *priv = this->private;
+    call_frame_t *newframe = NULL;
+    loc_t tmploc = {
+        0,
+    };
+    afr_private_t *priv = this->private;
 
-        newframe = create_frame(this,this->ctx->pool);
-        if (!newframe) {
-                return;
-        }
+    newframe = create_frame(this, this->ctx->pool);
+    if (!newframe) {
+        return;
+    }
 
-        tmploc.gfid[sizeof(tmploc.gfid)-1] = 1;
-        STACK_WIND_COOKIE (newframe, afr_local_discovery_cbk,
-                           (void *)(long)child_index,
-                           priv->children[child_index],
-                           priv->children[child_index]->fops->getxattr,
-                           &tmploc, GF_XATTR_PATHINFO_KEY, NULL);
+    tmploc.gfid[sizeof(tmploc.gfid) - 1] = 1;
+    STACK_WIND_COOKIE(newframe, afr_local_discovery_cbk,
+                      (void *)(long)child_index, priv->children[child_index],
+                      priv->children[child_index]->fops->getxattr, &tmploc,
+                      GF_XATTR_PATHINFO_KEY, NULL);
 }
 
 int
-afr_lookup_sh_metadata_wrap (void *opaque)
-{
-        call_frame_t *frame       = opaque;
-        afr_local_t  *local       = NULL;
-        xlator_t     *this        = NULL;
-        inode_t      *inode       = NULL;
-        afr_private_t *priv       = NULL;
-        struct afr_reply *replies = NULL;
-        int i= 0, first = -1;
-        int ret = -1;
-        dict_t *dict = NULL;
-
-        local = frame->local;
-        this  = frame->this;
-        priv  = this->private;
-        replies = local->replies;
-
-        for (i =0; i < priv->child_count; i++) {
-                if(!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                first = i;
-                break;
-        }
-        if (first == -1)
-                goto out;
-
-        if (afr_selfheal_metadata_by_stbuf (this, &replies[first].poststat))
-                goto out;
-
-        afr_local_replies_wipe (local, this->private);
-
-        dict = dict_new ();
-        if (!dict)
-                goto out;
-        ret = dict_set_str (dict, "link-count", GF_XATTROP_INDEX_COUNT);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "Unable to set link-count in dict ");
-        }
-
-        if (loc_is_nameless (&local->loc)) {
-                ret = afr_selfheal_unlocked_discover_on (frame, local->inode,
-                                                         local->loc.gfid,
-                                                         local->replies,
-                                                         local->child_up);
-        } else {
-                inode = afr_selfheal_unlocked_lookup_on (frame,
-                                                        local->loc.parent,
-                                                        local->loc.name,
-                                                        local->replies,
-                                                        local->child_up, dict);
-        }
-        if (inode)
-                inode_unref (inode);
+afr_lookup_sh_metadata_wrap(void *opaque)
+{
+    call_frame_t *frame = opaque;
+    afr_local_t *local = NULL;
+    xlator_t *this = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0, first = -1;
+    int ret = -1;
+    dict_t *dict = NULL;
+
+    local = frame->local;
+    this = frame->this;
+    priv = this->private;
+    replies = local->replies;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        first = i;
+        break;
+    }
+    if (first == -1)
+        goto out;
+
+    if (afr_selfheal_metadata_by_stbuf(this, &replies[first].poststat))
+        goto out;
+
+    afr_local_replies_wipe(local, this->private);
+
+    dict = dict_new();
+    if (!dict)
+        goto out;
+    ret = dict_set_str(dict, "link-count", GF_XATTROP_INDEX_COUNT);
+    if (ret) {
+        gf_msg_debug(this->name, -ret, "Unable to set link-count in dict ");
+    }
+
+    if (loc_is_nameless(&local->loc)) {
+        ret = afr_selfheal_unlocked_discover_on(frame, local->inode,
+                                                local->loc.gfid, local->replies,
+                                                local->child_up);
+    } else {
+        inode = afr_selfheal_unlocked_lookup_on(frame, local->loc.parent,
+                                                local->loc.name, local->replies,
+                                                local->child_up, dict);
+    }
+    if (inode)
+        inode_unref(inode);
 out:
-        if (loc_is_nameless (&local->loc))
-                afr_discover_done (frame, this);
-        else
-                afr_lookup_done (frame, this);
+    if (loc_is_nameless(&local->loc))
+        afr_discover_done(frame, this);
+    else
+        afr_lookup_done(frame, this);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_is_pending_set (xlator_t *this, dict_t *xdata, int type)
+afr_is_pending_set(xlator_t *this, dict_t *xdata, int type)
 {
-        int idx = -1;
-        afr_private_t *priv = NULL;
-        void *pending_raw = NULL;
-        int *pending_int = NULL;
-        int i = 0;
+    int idx = -1;
+    afr_private_t *priv = NULL;
+    void *pending_raw = NULL;
+    int *pending_int = NULL;
+    int i = 0;
 
-        priv = this->private;
-        idx = afr_index_for_transaction_type (type);
+    priv = this->private;
+    idx = afr_index_for_transaction_type(type);
 
-        if (dict_get_ptr (xdata, AFR_DIRTY, &pending_raw) == 0) {
-                if (pending_raw) {
-                        pending_int = pending_raw;
+    if (dict_get_ptr(xdata, AFR_DIRTY, &pending_raw) == 0) {
+        if (pending_raw) {
+            pending_int = pending_raw;
 
-                        if (ntoh32 (pending_int[idx]))
-                                return _gf_true;
-                }
+            if (ntoh32(pending_int[idx]))
+                return _gf_true;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (dict_get_ptr (xdata, priv->pending_key[i],
-                                  &pending_raw))
-                        continue;
-                if (!pending_raw)
-                        continue;
-                pending_int = pending_raw;
-
-                if (ntoh32 (pending_int[idx]))
-                        return _gf_true;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
+        if (!pending_raw)
+            continue;
+        pending_int = pending_raw;
 
-        return _gf_false;
+        if (ntoh32(pending_int[idx]))
+            return _gf_true;
+    }
+
+    return _gf_false;
 }
 
 static gf_boolean_t
 afr_can_start_metadata_self_heal(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        struct afr_reply *replies = NULL;
-        int i = 0, first = -1;
-        gf_boolean_t start = _gf_false;
-        struct iatt stbuf = {0, };
-
-        local = frame->local;
-        replies = local->replies;
-        priv = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0, first = -1;
+    gf_boolean_t start = _gf_false;
+    struct iatt stbuf = {
+        0,
+    };
 
-        if (!priv->metadata_self_heal)
-                return _gf_false;
+    local = frame->local;
+    replies = local->replies;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if(!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (first == -1) {
-                        first = i;
-                        stbuf = replies[i].poststat;
-                        continue;
-                }
+    if (!priv->metadata_self_heal)
+        return _gf_false;
 
-                if (afr_is_pending_set (this, replies[i].xdata,
-                                        AFR_METADATA_TRANSACTION)) {
-                        /* Let shd do the heal so that lookup is not blocked
-                         * on getting metadata lock/doing the heal */
-                        start = _gf_false;
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (first == -1) {
+            first = i;
+            stbuf = replies[i].poststat;
+            continue;
+        }
 
-                if (gf_uuid_compare (stbuf.ia_gfid, replies[i].poststat.ia_gfid)) {
-                        start = _gf_false;
-                        break;
-                }
-                if (!IA_EQUAL (stbuf, replies[i].poststat, type)) {
-                        start = _gf_false;
-                        break;
-                }
+        if (afr_is_pending_set(this, replies[i].xdata,
+                               AFR_METADATA_TRANSACTION)) {
+            /* Let shd do the heal so that lookup is not blocked
+             * on getting metadata lock/doing the heal */
+            start = _gf_false;
+            break;
+        }
 
-                /*Check if iattrs need heal*/
-                if ((!IA_EQUAL (stbuf, replies[i].poststat, uid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, gid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, prot))) {
-                        start = _gf_true;
-                        continue;
-                }
+        if (gf_uuid_compare(stbuf.ia_gfid, replies[i].poststat.ia_gfid)) {
+            start = _gf_false;
+            break;
+        }
+        if (!IA_EQUAL(stbuf, replies[i].poststat, type)) {
+            start = _gf_false;
+            break;
+        }
 
-                /*Check if xattrs need heal*/
-                if (!afr_xattrs_are_equal (replies[first].xdata,
-                                           replies[i].xdata))
-                        start = _gf_true;
+        /*Check if iattrs need heal*/
+        if ((!IA_EQUAL(stbuf, replies[i].poststat, uid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, gid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, prot))) {
+            start = _gf_true;
+            continue;
         }
 
-        return start;
+        /*Check if xattrs need heal*/
+        if (!afr_xattrs_are_equal(replies[first].xdata, replies[i].xdata))
+            start = _gf_true;
+    }
+
+    return start;
 }
 
 int
-afr_lookup_metadata_heal_check (call_frame_t *frame, xlator_t *this)
+afr_lookup_metadata_heal_check(call_frame_t *frame, xlator_t *this)
 
 {
-        call_frame_t *heal = NULL;
-        afr_local_t *local = NULL;
-        int ret            = 0;
+    call_frame_t *heal = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
-        if (!afr_can_start_metadata_self_heal (frame, this))
-                goto out;
+    local = frame->local;
+    if (!afr_can_start_metadata_self_heal(frame, this))
+        goto out;
 
-        heal = afr_frame_create (this, &ret);
-        if (!heal) {
-                ret = -ret;
-                goto out;
-        }
+    heal = afr_frame_create(this, &ret);
+    if (!heal) {
+        ret = -ret;
+        goto out;
+    }
 
-        ret = synctask_new (this->ctx->env, afr_lookup_sh_metadata_wrap,
-                            afr_refresh_selfheal_done, heal, frame);
-        if (ret)
-                goto out;
-        return ret;
+    ret = synctask_new(this->ctx->env, afr_lookup_sh_metadata_wrap,
+                       afr_refresh_selfheal_done, heal, frame);
+    if (ret)
+        goto out;
+    return ret;
 out:
-        if (loc_is_nameless (&local->loc))
-                afr_discover_done (frame, this);
-        else
-                afr_lookup_done (frame, this);
-        if (heal)
-                AFR_STACK_DESTROY (heal);
-        return ret;
+    if (loc_is_nameless(&local->loc))
+        afr_discover_done(frame, this);
+    else
+        afr_lookup_done(frame, this);
+    if (heal)
+        AFR_STACK_DESTROY(heal);
+    return ret;
 }
 
 int
-afr_lookup_selfheal_wrap (void *opaque)
+afr_lookup_selfheal_wrap(void *opaque)
 {
-        int ret = 0;
-	call_frame_t *frame = opaque;
-	afr_local_t *local = NULL;
-	xlator_t *this = NULL;
-	inode_t *inode = NULL;
-        uuid_t pargfid = {0,};
+    int ret = 0;
+    call_frame_t *frame = opaque;
+    afr_local_t *local = NULL;
+    xlator_t *this = NULL;
+    inode_t *inode = NULL;
+    uuid_t pargfid = {
+        0,
+    };
 
-	local = frame->local;
-	this = frame->this;
-        loc_pargfid (&local->loc, pargfid);
+    local = frame->local;
+    this = frame->this;
+    loc_pargfid(&local->loc, pargfid);
 
-	ret = afr_selfheal_name (frame->this, pargfid, local->loc.name,
-                                 &local->cont.lookup.gfid_req, local->xattr_req);
-        if (ret == -EIO)
-                goto unwind;
+    ret = afr_selfheal_name(frame->this, pargfid, local->loc.name,
+                            &local->cont.lookup.gfid_req, local->xattr_req);
+    if (ret == -EIO)
+        goto unwind;
 
-        afr_local_replies_wipe (local, this->private);
+    afr_local_replies_wipe(local, this->private);
 
-	inode = afr_selfheal_unlocked_lookup_on (frame, local->loc.parent,
-						 local->loc.name, local->replies,
-						 local->child_up, NULL);
-	if (inode)
-		inode_unref (inode);
+    inode = afr_selfheal_unlocked_lookup_on(frame, local->loc.parent,
+                                            local->loc.name, local->replies,
+                                            local->child_up, NULL);
+    if (inode)
+        inode_unref(inode);
 
-        afr_lookup_metadata_heal_check(frame, this);
-        return 0;
+    afr_lookup_metadata_heal_check(frame, this);
+    return 0;
 
 unwind:
-	AFR_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-afr_lookup_entry_heal (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	call_frame_t *heal = NULL;
-	int i = 0, first = -1;
-	gf_boolean_t name_state_mismatch = _gf_false;
-	struct afr_reply *replies = NULL;
-	int ret = 0;
-        unsigned char *par_readables = NULL;
-        unsigned char *success = NULL;
-        int32_t op_errno = 0;
-        uuid_t gfid = {0};
-
-	local = frame->local;
-	replies = local->replies;
-	priv = this->private;
-        par_readables = alloca0(priv->child_count);
-        success = alloca0(priv->child_count);
-
-        ret = afr_inode_read_subvol_get (local->loc.parent, this, par_readables,
-                                         NULL, NULL);
-        if (ret < 0 || AFR_COUNT (par_readables, priv->child_count) == 0) {
-                /* In this case set par_readables to all 1 so that name_heal
-                 * need checks at the end of this function will flag missing
-                 * entry when name state mismatches*/
-                memset (par_readables, 1, priv->child_count);
+afr_lookup_entry_heal(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    call_frame_t *heal = NULL;
+    int i = 0, first = -1;
+    gf_boolean_t name_state_mismatch = _gf_false;
+    struct afr_reply *replies = NULL;
+    int ret = 0;
+    unsigned char *par_readables = NULL;
+    unsigned char *success = NULL;
+    int32_t op_errno = 0;
+    uuid_t gfid = {0};
+
+    local = frame->local;
+    replies = local->replies;
+    priv = this->private;
+    par_readables = alloca0(priv->child_count);
+    success = alloca0(priv->child_count);
+
+    ret = afr_inode_read_subvol_get(local->loc.parent, this, par_readables,
+                                    NULL, NULL);
+    if (ret < 0 || AFR_COUNT(par_readables, priv->child_count) == 0) {
+        /* In this case set par_readables to all 1 so that name_heal
+         * need checks at the end of this function will flag missing
+         * entry when name state mismatches*/
+        memset(par_readables, 1, priv->child_count);
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret == 0) {
+            if (uuid_is_null(gfid)) {
+                gf_uuid_copy(gfid, replies[i].poststat.ia_gfid);
+            }
+            success[i] = 1;
+        } else {
+            if ((replies[i].op_errno != ENOTCONN) &&
+                (replies[i].op_errno != ENOENT) &&
+                (replies[i].op_errno != ESTALE)) {
+                op_errno = replies[i].op_errno;
+            }
         }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-                if (replies[i].op_ret == 0) {
-                        if (uuid_is_null (gfid)) {
-                                gf_uuid_copy (gfid,
-                                              replies[i].poststat.ia_gfid);
-                        }
-                        success[i] = 1;
-                } else {
-                        if ((replies[i].op_errno != ENOTCONN) &&
-                            (replies[i].op_errno != ENOENT) &&
-                            (replies[i].op_errno != ESTALE)) {
-                                op_errno = replies[i].op_errno;
-                        }
-                }
+        /*gfid is missing, needs heal*/
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA)) {
+            goto name_heal;
+        }
 
-                /*gfid is missing, needs heal*/
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA)) {
-                        goto name_heal;
-                }
+        if (first == -1) {
+            first = i;
+            continue;
+        }
 
-		if (first == -1) {
-			first = i;
-			continue;
-		}
-
-		if (replies[i].op_ret != replies[first].op_ret) {
-                        name_state_mismatch = _gf_true;
-		}
-
-                if (replies[i].op_ret == 0) {
-                        /* Rename after this lookup may succeed if we don't do
-                         * a name-heal and the destination may not have pending xattrs
-                         * to indicate which name is good and which is bad so always do
-                         * this heal*/
-                        if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-                                             gfid)) {
-                                goto name_heal;
-                        }
-                }
-	}
-
-        if (name_state_mismatch) {
-                if (!priv->quorum_count)
-                        goto name_heal;
-                if (!afr_has_quorum (success, this))
-                        goto name_heal;
-                if (op_errno)
-                        goto name_heal;
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!replies[i].valid)
-                                continue;
-                        if (par_readables[i] && replies[i].op_ret < 0 &&
-                            replies[i].op_errno != ENOTCONN) {
-                                goto name_heal;
-                        }
-                }
+        if (replies[i].op_ret != replies[first].op_ret) {
+            name_state_mismatch = _gf_true;
         }
 
-        goto metadata_heal;
+        if (replies[i].op_ret == 0) {
+            /* Rename after this lookup may succeed if we don't do
+             * a name-heal and the destination may not have pending xattrs
+             * to indicate which name is good and which is bad so always do
+             * this heal*/
+            if (gf_uuid_compare(replies[i].poststat.ia_gfid, gfid)) {
+                goto name_heal;
+            }
+        }
+    }
+
+    if (name_state_mismatch) {
+        if (!priv->quorum_count)
+            goto name_heal;
+        if (!afr_has_quorum(success, this))
+            goto name_heal;
+        if (op_errno)
+            goto name_heal;
+        for (i = 0; i < priv->child_count; i++) {
+            if (!replies[i].valid)
+                continue;
+            if (par_readables[i] && replies[i].op_ret < 0 &&
+                replies[i].op_errno != ENOTCONN) {
+                goto name_heal;
+            }
+        }
+    }
+
+    goto metadata_heal;
 
 name_heal:
-        heal = afr_frame_create (this, NULL);
-        if (!heal)
-                goto metadata_heal;
+    heal = afr_frame_create(this, NULL);
+    if (!heal)
+        goto metadata_heal;
 
-        ret = synctask_new (this->ctx->env, afr_lookup_selfheal_wrap,
-                            afr_refresh_selfheal_done, heal, frame);
-        if (ret) {
-                AFR_STACK_DESTROY (heal);
-                goto metadata_heal;
-        }
-        return ret;
+    ret = synctask_new(this->ctx->env, afr_lookup_selfheal_wrap,
+                       afr_refresh_selfheal_done, heal, frame);
+    if (ret) {
+        AFR_STACK_DESTROY(heal);
+        goto metadata_heal;
+    }
+    return ret;
 
 metadata_heal:
-        ret = afr_lookup_metadata_heal_check (frame, this);
+    ret = afr_lookup_metadata_heal_check(frame, this);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-		dict_t *xdata, struct iatt *postparent)
-{
-        afr_local_t *   local = NULL;
-        int             call_count      = -1;
-        int             child_index     = -1;
-        GF_UNUSED int   ret             = 0;
-	int8_t need_heal                = 1;
-
-	child_index = (long) cookie;
-
-	local = frame->local;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        /*
-         * On revalidate lookup if the gfid-changed, afr should unwind the fop
-         * with ESTALE so that a fresh lookup will be sent by the top xlator.
-         * So remember it.
-         */
-        if (xdata && dict_get (xdata, "gfid-changed"))
-                local->cont.lookup.needs_fresh_lookup = _gf_true;
+afr_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+               struct iatt *postparent)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
+    GF_UNUSED int ret = 0;
+    int8_t need_heal = 1;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    /*
+     * On revalidate lookup if the gfid-changed, afr should unwind the fop
+     * with ESTALE so that a fresh lookup will be sent by the top xlator.
+     * So remember it.
+     */
+    if (xdata && dict_get(xdata, "gfid-changed"))
+        local->cont.lookup.needs_fresh_lookup = _gf_true;
+
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[child_index].need_heal = need_heal;
+    } else {
+        local->replies[child_index].need_heal = need_heal;
+    }
+    if (op_ret != -1) {
+        local->replies[child_index].poststat = *buf;
+        local->replies[child_index].postparent = *postparent;
+        if (xdata)
+            local->replies[child_index].xdata = dict_ref(xdata);
+    }
 
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[child_index].need_heal = need_heal;
-        } else {
-                local->replies[child_index].need_heal = need_heal;
-        }
-	if (op_ret != -1) {
-		local->replies[child_index].poststat = *buf;
-		local->replies[child_index].postparent = *postparent;
-		if (xdata)
-			local->replies[child_index].xdata = dict_ref (xdata);
-	}
-
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-		afr_lookup_entry_heal (frame, this);
-        }
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        afr_lookup_entry_heal(frame, this);
+    }
 
-	return 0;
+    return 0;
 }
 
 static void
-afr_discover_unwind (call_frame_t *frame, xlator_t *this)
+afr_discover_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t       *priv  = NULL;
-        afr_local_t         *local = NULL;
-	int                 op_errno = 0;
-	int                 read_subvol = -1;
-        unsigned char *data_readable = NULL;
-        unsigned char *success_replies = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
+    int read_subvol = -1;
+    unsigned char *data_readable = NULL;
+    unsigned char *success_replies = NULL;
 
-        priv  = this->private;
-        local = frame->local;
-        data_readable = alloca0 (priv->child_count);
-        success_replies = alloca0 (priv->child_count);
+    priv = this->private;
+    local = frame->local;
+    data_readable = alloca0(priv->child_count);
+    success_replies = alloca0(priv->child_count);
 
-        afr_fill_success_replies (local, priv, success_replies);
-        if (AFR_COUNT (success_replies, priv->child_count) > 0)
-                local->op_ret = 0;
+    afr_fill_success_replies(local, priv, success_replies);
+    if (AFR_COUNT(success_replies, priv->child_count) > 0)
+        local->op_ret = 0;
 
-	op_errno = afr_final_errno (frame->local, this->private);
+    op_errno = afr_final_errno(frame->local, this->private);
 
-        if (local->op_ret < 0) {
-                AFR_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL,
-                                  NULL, NULL);
-                return;
-	}
+    if (local->op_ret < 0) {
+        AFR_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+        return;
+    }
 
-        if (!afr_has_quorum (success_replies, this))
-                goto unwind;
+    if (!afr_has_quorum(success_replies, this))
+        goto unwind;
 
-	afr_replies_interpret (frame, this, local->inode, NULL);
+    afr_replies_interpret(frame, this, local->inode, NULL);
 
-	read_subvol = afr_read_subvol_decide (local->inode, this, NULL,
-                                              data_readable);
+    read_subvol = afr_read_subvol_decide(local->inode, this, NULL,
+                                         data_readable);
 
 unwind:
-        afr_attempt_readsubvol_set (frame, this, success_replies, data_readable,
-                                    &read_subvol);
-	if (read_subvol == -1) {
-                AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                                  NULL, NULL, NULL, NULL);
-                return;
-        }
+    afr_attempt_readsubvol_set(frame, this, success_replies, data_readable,
+                               &read_subvol);
+    if (read_subvol == -1) {
+        AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno, NULL,
+                         NULL, NULL, NULL);
+        return;
+    }
 
-        if (AFR_IS_ARBITER_BRICK (priv, read_subvol) && local->op_ret == 0) {
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-	        gf_msg_debug (this->name, 0, "Arbiter cannot be a read subvol "
-                              "for %s", local->loc.path);
-        }
+    if (AFR_IS_ARBITER_BRICK(priv, read_subvol) && local->op_ret == 0) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        gf_msg_debug(this->name, 0,
+                     "Arbiter cannot be a read subvol "
+                     "for %s",
+                     local->loc.path);
+    }
 
-	AFR_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-			  local->inode, &local->replies[read_subvol].poststat,
-			  local->replies[read_subvol].xdata,
-			  &local->replies[read_subvol].postparent);
+    AFR_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->replies[read_subvol].poststat,
+                     local->replies[read_subvol].xdata,
+                     &local->replies[read_subvol].postparent);
 }
 
 static int
-afr_ta_id_file_check (void *opaque)
-{
-        afr_private_t *priv = NULL;
-        xlator_t *this = NULL;
-        loc_t loc = {0, };
-        struct iatt  stbuf = {0,};
-        dict_t *dict = NULL;
-        uuid_t  gfid = {0,};
-        fd_t *fd = NULL;
-        int ret = 0;
-
-        this = opaque;
-        priv = this->private;
-
-        ret = afr_fill_ta_loc (this, &loc);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to populate thin-arbiter loc for: %s.",
-                        loc.name);
-                goto out;
-        }
-
-        ret = syncop_lookup (priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
-                             &stbuf, 0, 0, 0);
-        if (ret == 0) {
-                goto out;
-        } else if (ret == -ENOENT) {
-                fd = fd_create (loc.inode, getpid());
-                if (!fd)
-                        goto out;
-                dict = dict_new ();
-                if (!dict)
-                        goto out;
-                gf_uuid_generate (gfid);
-                ret = dict_set_gfuuid (dict, "gfid-req", gfid, true);
-                ret = syncop_create (priv->children[THIN_ARBITER_BRICK_INDEX],
-                                     &loc, O_RDWR, 0664, fd, &stbuf, dict,
-                                     NULL);
-        }
+afr_ta_id_file_check(void *opaque)
+{
+    afr_private_t *priv = NULL;
+    xlator_t *this = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    dict_t *dict = NULL;
+    uuid_t gfid = {
+        0,
+    };
+    fd_t *fd = NULL;
+    int ret = 0;
+
+    this = opaque;
+    priv = this->private;
+
+    ret = afr_fill_ta_loc(this, &loc);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        goto out;
+    }
+
+    ret = syncop_lookup(priv->children[THIN_ARBITER_BRICK_INDEX], &loc, &stbuf,
+                        0, 0, 0);
+    if (ret == 0) {
+        goto out;
+    } else if (ret == -ENOENT) {
+        fd = fd_create(loc.inode, getpid());
+        if (!fd)
+            goto out;
+        dict = dict_new();
+        if (!dict)
+            goto out;
+        gf_uuid_generate(gfid);
+        ret = dict_set_gfuuid(dict, "gfid-req", gfid, true);
+        ret = syncop_create(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                            O_RDWR, 0664, fd, &stbuf, dict, NULL);
+    }
 
 out:
-        if (ret == 0) {
-                gf_uuid_copy (priv->ta_gfid, stbuf.ia_gfid);
-        } else {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to lookup/create thin-arbiter id file.");
-        }
-        if (dict)
-                dict_unref (dict);
-        if (fd)
-                fd_unref (fd);
-        loc_wipe (&loc);
+    if (ret == 0) {
+        gf_uuid_copy(priv->ta_gfid, stbuf.ia_gfid);
+    } else {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to lookup/create thin-arbiter id file.");
+    }
+    if (dict)
+        dict_unref(dict);
+    if (fd)
+        fd_unref(fd);
+    loc_wipe(&loc);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_ta_id_file_check_cbk (int ret, call_frame_t *ta_frame, void *opaque)
+afr_ta_id_file_check_cbk(int ret, call_frame_t *ta_frame, void *opaque)
 {
-        return 0;
+    return 0;
 }
 
 static void
-afr_discover_done (call_frame_t *frame, xlator_t *this)
+afr_discover_done(call_frame_t *frame, xlator_t *this)
 {
-        int ret = 0;
-        afr_private_t *priv = NULL;
+    int ret = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        if (!priv->thin_arbiter_count)
-                goto unwind;
-        if (!gf_uuid_is_null(priv->ta_gfid))
-                goto unwind;
+    priv = this->private;
+    if (!priv->thin_arbiter_count)
+        goto unwind;
+    if (!gf_uuid_is_null(priv->ta_gfid))
+        goto unwind;
 
-        ret = synctask_new (this->ctx->env, afr_ta_id_file_check,
-                            afr_ta_id_file_check_cbk, NULL, this);
-        if (ret)
-                goto unwind;
+    ret = synctask_new(this->ctx->env, afr_ta_id_file_check,
+                       afr_ta_id_file_check_cbk, NULL, this);
+    if (ret)
+        goto unwind;
 unwind:
-        afr_discover_unwind (frame, this);
+    afr_discover_unwind(frame, this);
 }
 
 int
-afr_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		  int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-		  dict_t *xdata, struct iatt *postparent)
-{
-        afr_local_t *   local = NULL;
-        int             call_count      = -1;
-        int             child_index     = -1;
-        GF_UNUSED int ret               = 0;
-	int8_t need_heal                = 1;
-
-	child_index = (long) cookie;
-
-	local = frame->local;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-	if (op_ret != -1) {
-		local->replies[child_index].poststat = *buf;
-		local->replies[child_index].postparent = *postparent;
-		if (xdata)
-			local->replies[child_index].xdata = dict_ref (xdata);
-	}
-
-        if (local->do_discovery && (op_ret == 0))
-                afr_attempt_local_discovery (this, child_index);
-
-        if (xdata) {
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[child_index].need_heal = need_heal;
-        } else {
-                local->replies[child_index].need_heal = need_heal;
-        }
-
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                afr_set_need_heal (this, local);
-                afr_lookup_metadata_heal_check (frame, this);
-        }
+afr_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+                 struct iatt *postparent)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
+    GF_UNUSED int ret = 0;
+    int8_t need_heal = 1;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (op_ret != -1) {
+        local->replies[child_index].poststat = *buf;
+        local->replies[child_index].postparent = *postparent;
+        if (xdata)
+            local->replies[child_index].xdata = dict_ref(xdata);
+    }
+
+    if (local->do_discovery && (op_ret == 0))
+        afr_attempt_local_discovery(this, child_index);
+
+    if (xdata) {
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[child_index].need_heal = need_heal;
+    } else {
+        local->replies[child_index].need_heal = need_heal;
+    }
+
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        afr_set_need_heal(this, local);
+        afr_lookup_metadata_heal_check(frame, this);
+    }
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_discover_do (call_frame_t *frame, xlator_t *this, int err)
-{
-	int ret = 0;
-	int i = 0;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (err) {
-		local->op_errno = err;
-		goto out;
-	}
-
-	call_count = local->call_count = AFR_COUNT (local->child_up,
-						    priv->child_count);
-
-        ret = afr_lookup_xattr_req_prepare (local, this, local->xattr_req,
-					    &local->loc);
-        if (ret) {
-                local->op_errno = -ret;
-                goto out;
-        }
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_discover_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        if (!--call_count)
-                                break;
-                }
+afr_discover_do(call_frame_t *frame, xlator_t *this, int err)
+{
+    int ret = 0;
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (err) {
+        local->op_errno = err;
+        goto out;
+    }
+
+    call_count = local->call_count = AFR_COUNT(local->child_up,
+                                               priv->child_count);
+
+    ret = afr_lookup_xattr_req_prepare(local, this, local->xattr_req,
+                                       &local->loc);
+    if (ret) {
+        local->op_errno = -ret;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(
+                frame, afr_discover_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->lookup, &local->loc, local->xattr_req);
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
+    return 0;
 }
 
-
 int
-afr_discover (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+afr_discover(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
 {
-	int op_errno = ENOMEM;
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int event = 0;
+    int op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int event = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        if (!local->call_count) {
-                op_errno = ENOTCONN;
-                goto out;
-        }
+    if (!local->call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
 
-	if (__is_root_gfid (loc->inode->gfid)) {
-		if (!this->itable)
-			this->itable = loc->inode->table;
-		if (!priv->root_inode)
-			priv->root_inode = inode_ref (loc->inode);
-
-		if (priv->choose_local && !priv->did_discovery) {
-			/* Logic to detect which subvolumes of AFR are
-			   local, in order to prefer them for reads
-			*/
-			local->do_discovery = _gf_true;
-                        priv->did_discovery = _gf_true;
-                }
-	}
+    if (__is_root_gfid(loc->inode->gfid)) {
+        if (!this->itable)
+            this->itable = loc->inode->table;
+        if (!priv->root_inode)
+            priv->root_inode = inode_ref(loc->inode);
 
-        local->op = GF_FOP_LOOKUP;
+        if (priv->choose_local && !priv->did_discovery) {
+            /* Logic to detect which subvolumes of AFR are
+               local, in order to prefer them for reads
+            */
+            local->do_discovery = _gf_true;
+            priv->did_discovery = _gf_true;
+        }
+    }
 
-        loc_copy (&local->loc, loc);
+    local->op = GF_FOP_LOOKUP;
 
-	local->inode = inode_ref (loc->inode);
+    loc_copy(&local->loc, loc);
 
-	if (xattr_req)
-		/* If xattr_req was null, afr_lookup_xattr_req_prepare() will
-		   allocate one for us */
-		local->xattr_req = dict_ref (xattr_req);
+    local->inode = inode_ref(loc->inode);
 
-	if (gf_uuid_is_null (loc->inode->gfid)) {
-		afr_discover_do (frame, this, 0);
-		return 0;
-	}
+    if (xattr_req)
+        /* If xattr_req was null, afr_lookup_xattr_req_prepare() will
+           allocate one for us */
+        local->xattr_req = dict_ref(xattr_req);
 
-	afr_read_subvol_get (loc->inode, this, NULL, NULL, &event,
-			     AFR_DATA_TRANSACTION, NULL);
+    if (gf_uuid_is_null(loc->inode->gfid)) {
+        afr_discover_do(frame, this, 0);
+        return 0;
+    }
 
-	if (afr_is_inode_refresh_reqd (loc->inode, this, event,
-                                       local->event_generation))
-		afr_inode_refresh (frame, this, loc->inode, NULL,
-                                   afr_discover_do);
-	else
-		afr_discover_do (frame, this, 0);
+    afr_read_subvol_get(loc->inode, this, NULL, NULL, &event,
+                        AFR_DATA_TRANSACTION, NULL);
 
-	return 0;
+    if (afr_is_inode_refresh_reqd(loc->inode, this, event,
+                                  local->event_generation))
+        afr_inode_refresh(frame, this, loc->inode, NULL, afr_discover_do);
+    else
+        afr_discover_do(frame, this, 0);
+
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-afr_lookup_do (call_frame_t *frame, xlator_t *this, int err)
-{
-	int ret = 0;
-	int i = 0;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int call_count = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (err < 0) {
-		local->op_errno = err;
-		ret = -1;
-		goto out;
-	}
-
-	call_count = local->call_count = AFR_COUNT (local->child_up,
-						    priv->child_count);
-
-        ret = afr_lookup_xattr_req_prepare (local, this, local->xattr_req,
-					    &local->loc);
-        if (ret) {
-                local->op_errno = -ret;
-		ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_lookup_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        if (!--call_count)
-                                break;
-                }
+afr_lookup_do(call_frame_t *frame, xlator_t *this, int err)
+{
+    int ret = 0;
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (err < 0) {
+        local->op_errno = err;
+        ret = -1;
+        goto out;
+    }
+
+    call_count = local->call_count = AFR_COUNT(local->child_up,
+                                               priv->child_count);
+
+    ret = afr_lookup_xattr_req_prepare(local, this, local->xattr_req,
+                                       &local->loc);
+    if (ret) {
+        local->op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(
+                frame, afr_lookup_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->lookup, &local->loc, local->xattr_req);
+            if (!--call_count)
+                break;
         }
-	return 0;
+    }
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
-	return 0;
+    AFR_STACK_UNWIND(lookup, frame, -1, local->op_errno, 0, 0, 0, 0);
+    return 0;
 }
 
 /*
@@ -3405,1619 +3335,1568 @@ out:
  */
 
 int
-afr_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-        afr_local_t   *local = NULL;
-        int32_t        op_errno = 0;
-	int            event = 0;
-        int            ret = 0;
-
-        if (loc_is_nameless (loc)) {
-                if (xattr_req)
-                        dict_del (xattr_req, "gfid-req");
-		afr_discover (frame, this, loc, xattr_req);
-		return 0;
-	}
-
-	if (__is_root_gfid (loc->parent->gfid)) {
-		if (!strcmp (loc->name, GF_REPLICATE_TRASH_DIR)) {
-			op_errno = EPERM;
-			goto out;
-		}
-	}
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        if (!local->call_count) {
-                op_errno = ENOTCONN;
-                goto out;
+afr_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    int event = 0;
+    int ret = 0;
+
+    if (loc_is_nameless(loc)) {
+        if (xattr_req)
+            dict_del(xattr_req, "gfid-req");
+        afr_discover(frame, this, loc, xattr_req);
+        return 0;
+    }
+
+    if (__is_root_gfid(loc->parent->gfid)) {
+        if (!strcmp(loc->name, GF_REPLICATE_TRASH_DIR)) {
+            op_errno = EPERM;
+            goto out;
         }
+    }
 
-        local->op = GF_FOP_LOOKUP;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        loc_copy (&local->loc, loc);
+    if (!local->call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
 
-	local->inode = inode_ref (loc->inode);
+    local->op = GF_FOP_LOOKUP;
 
-	if (xattr_req) {
-		/* If xattr_req was null, afr_lookup_xattr_req_prepare() will
-		   allocate one for us */
-		local->xattr_req = dict_copy_with_ref (xattr_req, NULL);
-		if (!local->xattr_req) {
-		        op_errno = ENOMEM;
-		        goto out;
-                }
-                ret = dict_get_gfuuid (local->xattr_req, "gfid-req",
-                                       &local->cont.lookup.gfid_req);
-                if (ret == 0) {
-                        dict_del (local->xattr_req, "gfid-req");
-                }
+    loc_copy(&local->loc, loc);
+
+    local->inode = inode_ref(loc->inode);
+
+    if (xattr_req) {
+        /* If xattr_req was null, afr_lookup_xattr_req_prepare() will
+           allocate one for us */
+        local->xattr_req = dict_copy_with_ref(xattr_req, NULL);
+        if (!local->xattr_req) {
+            op_errno = ENOMEM;
+            goto out;
+        }
+        ret = dict_get_gfuuid(local->xattr_req, "gfid-req",
+                              &local->cont.lookup.gfid_req);
+        if (ret == 0) {
+            dict_del(local->xattr_req, "gfid-req");
         }
+    }
 
-	afr_read_subvol_get (loc->parent, this, NULL, NULL, &event,
-			     AFR_DATA_TRANSACTION, NULL);
+    afr_read_subvol_get(loc->parent, this, NULL, NULL, &event,
+                        AFR_DATA_TRANSACTION, NULL);
 
-	if (afr_is_inode_refresh_reqd (loc->inode, this, event,
-                                       local->event_generation))
-		afr_inode_refresh (frame, this, loc->parent, NULL,
-                                   afr_lookup_do);
-	else
-		afr_lookup_do (frame, this, 0);
+    if (afr_is_inode_refresh_reqd(loc->inode, this, event,
+                                  local->event_generation))
+        afr_inode_refresh(frame, this, loc->parent, NULL, afr_lookup_do);
+    else
+        afr_lookup_do(frame, this, 0);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 void
-_afr_cleanup_fd_ctx (afr_fd_ctx_t *fd_ctx)
+_afr_cleanup_fd_ctx(afr_fd_ctx_t *fd_ctx)
 {
-        GF_FREE (fd_ctx->opened_on);
-        GF_FREE (fd_ctx);
-        return;
+    GF_FREE(fd_ctx->opened_on);
+    GF_FREE(fd_ctx);
+    return;
 }
 
 int
-afr_cleanup_fd_ctx (xlator_t *this, fd_t *fd)
+afr_cleanup_fd_ctx(xlator_t *this, fd_t *fd)
 {
-        uint64_t        ctx = 0;
-        afr_fd_ctx_t    *fd_ctx = NULL;
-        int             ret = 0;
+    uint64_t ctx = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int ret = 0;
 
-        ret = fd_ctx_get (fd, this, &ctx);
-        if (ret < 0)
-                goto out;
+    ret = fd_ctx_get(fd, this, &ctx);
+    if (ret < 0)
+        goto out;
 
-        fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+    fd_ctx = (afr_fd_ctx_t *)(long)ctx;
 
-        if (fd_ctx) {
-                _afr_cleanup_fd_ctx (fd_ctx);
-        }
+    if (fd_ctx) {
+        _afr_cleanup_fd_ctx(fd_ctx);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-afr_release (xlator_t *this, fd_t *fd)
+afr_release(xlator_t *this, fd_t *fd)
 {
-        afr_cleanup_fd_ctx (this, fd);
+    afr_cleanup_fd_ctx(this, fd);
 
-        return 0;
+    return 0;
 }
 
 afr_fd_ctx_t *
-__afr_fd_ctx_get (fd_t *fd, xlator_t *this)
+__afr_fd_ctx_get(fd_t *fd, xlator_t *this)
 {
-        uint64_t       ctx = 0;
-        int            ret = 0;
-        afr_fd_ctx_t  *fd_ctx = NULL;
+    uint64_t ctx = 0;
+    int ret = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        ret = __fd_ctx_get (fd, this, &ctx);
+    ret = __fd_ctx_get(fd, this, &ctx);
 
-        if (ret < 0) {
-                ret = __afr_fd_ctx_set (this, fd);
-                if (ret < 0)
-                        goto out;
+    if (ret < 0) {
+        ret = __afr_fd_ctx_set(this, fd);
+        if (ret < 0)
+            goto out;
 
-                ret = __fd_ctx_get (fd, this, &ctx);
-                if (ret < 0)
-                        goto out;
-        }
+        ret = __fd_ctx_get(fd, this, &ctx);
+        if (ret < 0)
+            goto out;
+    }
 
-        fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+    fd_ctx = (afr_fd_ctx_t *)(long)ctx;
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
-
 afr_fd_ctx_t *
-afr_fd_ctx_get (fd_t *fd, xlator_t *this)
+afr_fd_ctx_get(fd_t *fd, xlator_t *this)
 {
-        afr_fd_ctx_t  *fd_ctx = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        LOCK(&fd->lock);
-        {
-                fd_ctx = __afr_fd_ctx_get (fd, this);
-        }
-        UNLOCK(&fd->lock);
+    LOCK(&fd->lock);
+    {
+        fd_ctx = __afr_fd_ctx_get(fd, this);
+    }
+    UNLOCK(&fd->lock);
 
-        return fd_ctx;
+    return fd_ctx;
 }
 
-
 int
-__afr_fd_ctx_set (xlator_t *this, fd_t *fd)
+__afr_fd_ctx_set(xlator_t *this, fd_t *fd)
 {
-        afr_private_t * priv   = NULL;
-        int             ret    = -1;
-        uint64_t        ctx    = 0;
-        afr_fd_ctx_t *  fd_ctx = NULL;
-	int             i = 0;
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    uint64_t ctx = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int i = 0;
 
-        VALIDATE_OR_GOTO (this->private, out);
-        VALIDATE_OR_GOTO (fd, out);
+    VALIDATE_OR_GOTO(this->private, out);
+    VALIDATE_OR_GOTO(fd, out);
 
-        priv = this->private;
+    priv = this->private;
 
-        ret = __fd_ctx_get (fd, this, &ctx);
+    ret = __fd_ctx_get(fd, this, &ctx);
 
-        if (ret == 0)
-                goto out;
+    if (ret == 0)
+        goto out;
 
-        fd_ctx = GF_CALLOC (1, sizeof (afr_fd_ctx_t),
-                            gf_afr_mt_afr_fd_ctx_t);
-        if (!fd_ctx) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    fd_ctx = GF_CALLOC(1, sizeof(afr_fd_ctx_t), gf_afr_mt_afr_fd_ctx_t);
+    if (!fd_ctx) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        fd_ctx->opened_on = GF_CALLOC (sizeof (*fd_ctx->opened_on),
-                                       priv->child_count,
-                                       gf_afr_mt_int32_t);
-        if (!fd_ctx->opened_on) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    fd_ctx->opened_on = GF_CALLOC(sizeof(*fd_ctx->opened_on), priv->child_count,
+                                  gf_afr_mt_int32_t);
+    if (!fd_ctx->opened_on) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (fd_is_anonymous (fd))
-			fd_ctx->opened_on[i] = AFR_FD_OPENED;
-		else
-			fd_ctx->opened_on[i] = AFR_FD_NOT_OPENED;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (fd_is_anonymous(fd))
+            fd_ctx->opened_on[i] = AFR_FD_OPENED;
+        else
+            fd_ctx->opened_on[i] = AFR_FD_NOT_OPENED;
+    }
 
-	fd_ctx->readdir_subvol = -1;
+    fd_ctx->readdir_subvol = -1;
 
-        ret = __fd_ctx_set (fd, this, (uint64_t)(long) fd_ctx);
-        if (ret)
-                gf_msg_debug (this->name, 0,
-                              "failed to set fd ctx (%p)", fd);
+    ret = __fd_ctx_set(fd, this, (uint64_t)(long)fd_ctx);
+    if (ret)
+        gf_msg_debug(this->name, 0, "failed to set fd ctx (%p)", fd);
 out:
-        if (ret && fd_ctx)
-                _afr_cleanup_fd_ctx (fd_ctx);
-        return ret;
+    if (ret && fd_ctx)
+        _afr_cleanup_fd_ctx(fd_ctx);
+    return ret;
 }
 
-
 /* {{{ flush */
 
 int
-afr_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = -1;
+    afr_local_t *local = NULL;
+    int call_count = -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret != -1) {
-			local->op_ret = op_ret;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		} else {
-			local->op_errno = op_errno;
-		}
+    LOCK(&frame->lock);
+    {
+        if (op_ret != -1) {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        } else {
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-	if (call_count == 0)
-		AFR_STACK_UNWIND (flush, frame, local->op_ret,
-				  local->op_errno, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(flush, frame, local->op_ret, local->op_errno,
+                         local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_flush_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-        int           i      = 0;
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int call_count       = -1;
-
-        priv = this->private;
-        local = frame->local;
-        call_count = local->call_count;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_flush_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->flush,
-                                           local->fd, xdata);
-                        if (!--call_count)
-                                break;
-
-                }
+afr_flush_wrapper(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+{
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+
+    priv = this->private;
+    local = frame->local;
+    call_count = local->call_count;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, afr_flush_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->flush,
+                              local->fd, xdata);
+            if (!--call_count)
+                break;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-afr_local_t*
-afr_wakeup_same_fd_delayed_op (xlator_t *this, afr_lock_t *lock, fd_t *fd)
+afr_local_t *
+afr_wakeup_same_fd_delayed_op(xlator_t *this, afr_lock_t *lock, fd_t *fd)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        if (lock->delay_timer) {
-                local = list_entry(lock->post_op.next, afr_local_t,
-                                   transaction.owner_list);
-                if (fd == local->fd) {
-                        if (gf_timer_call_cancel (this->ctx,
-                                                  lock->delay_timer)) {
-                                local = NULL;
-                        } else {
-                                lock->delay_timer = NULL;
-                        }
-                } else {
-                        local = NULL;
-                }
+    if (lock->delay_timer) {
+        local = list_entry(lock->post_op.next, afr_local_t,
+                           transaction.owner_list);
+        if (fd == local->fd) {
+            if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+                local = NULL;
+            } else {
+                lock->delay_timer = NULL;
+            }
+        } else {
+            local = NULL;
         }
+    }
 
-        return local;
+    return local;
 }
 
 void
-afr_delayed_changelog_wake_resume (xlator_t *this, inode_t *inode,
-                                   call_stub_t *stub)
-{
-        afr_inode_ctx_t *ctx = NULL;
-        afr_lock_t      *lock = NULL;
-        afr_local_t     *metadata_local = NULL;
-        afr_local_t     *data_local = NULL;
-        LOCK (&inode->lock);
-        {
-                (void)__afr_inode_ctx_get (this, inode, &ctx);
-                lock = &ctx->lock[AFR_DATA_TRANSACTION];
-                data_local = afr_wakeup_same_fd_delayed_op (this, lock,
-                                                            stub->args.fd);
-                lock = &ctx->lock[AFR_METADATA_TRANSACTION];
-                metadata_local = afr_wakeup_same_fd_delayed_op (this, lock,
-                                                                stub->args.fd);
-        }
-        UNLOCK (&inode->lock);
-
-        if (data_local) {
-                data_local->transaction.resume_stub = stub;
-        } else if (metadata_local) {
-                metadata_local->transaction.resume_stub = stub;
-        } else {
-                call_resume (stub);
-        }
-        if (data_local) {
-                afr_delayed_changelog_wake_up_cbk (data_local);
-        }
-        if (metadata_local) {
-                afr_delayed_changelog_wake_up_cbk (metadata_local);
-        }
+afr_delayed_changelog_wake_resume(xlator_t *this, inode_t *inode,
+                                  call_stub_t *stub)
+{
+    afr_inode_ctx_t *ctx = NULL;
+    afr_lock_t *lock = NULL;
+    afr_local_t *metadata_local = NULL;
+    afr_local_t *data_local = NULL;
+    LOCK(&inode->lock);
+    {
+        (void)__afr_inode_ctx_get(this, inode, &ctx);
+        lock = &ctx->lock[AFR_DATA_TRANSACTION];
+        data_local = afr_wakeup_same_fd_delayed_op(this, lock, stub->args.fd);
+        lock = &ctx->lock[AFR_METADATA_TRANSACTION];
+        metadata_local = afr_wakeup_same_fd_delayed_op(this, lock,
+                                                       stub->args.fd);
+    }
+    UNLOCK(&inode->lock);
+
+    if (data_local) {
+        data_local->transaction.resume_stub = stub;
+    } else if (metadata_local) {
+        metadata_local->transaction.resume_stub = stub;
+    } else {
+        call_resume(stub);
+    }
+    if (data_local) {
+        afr_delayed_changelog_wake_up_cbk(data_local);
+    }
+    if (metadata_local) {
+        afr_delayed_changelog_wake_up_cbk(metadata_local);
+    }
 }
 
 int
-afr_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+afr_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t *local   = NULL;
-        call_stub_t *stub    = NULL;
-        int         op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_stub_t *stub = NULL;
+    int op_errno = ENOMEM;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_FLUSH;
-	if (!afr_is_consistent_io_possible (local, this->private, &op_errno))
-		goto out;
+    local->op = GF_FOP_FLUSH;
+    if (!afr_is_consistent_io_possible(local, this->private, &op_errno))
+        goto out;
 
-	local->fd = fd_ref(fd);
+    local->fd = fd_ref(fd);
 
-        stub = fop_flush_stub (frame, afr_flush_wrapper, fd, xdata);
-        if (!stub)
-                goto out;
+    stub = fop_flush_stub(frame, afr_flush_wrapper, fd, xdata);
+    if (!stub)
+        goto out;
 
-        afr_delayed_changelog_wake_resume (this, fd->inode, stub);
+    afr_delayed_changelog_wake_resume(this, fd->inode, stub);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+    return 0;
 }
 
 int
-afr_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = -1;
+    afr_local_t *local = NULL;
+    int call_count = -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == 0) {
-                        local->op_ret = 0;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		} else {
-			local->op_errno = op_errno;
-		}
+    LOCK(&frame->lock);
+    {
+        if (op_ret == 0) {
+            local->op_ret = 0;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        } else {
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-                AFR_STACK_UNWIND (fsyncdir, frame, local->op_ret,
-				  local->op_errno, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
+                         local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-	      dict_t *xdata)
-{
-	afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
-        int32_t call_count = 0;
-        int32_t op_errno = ENOMEM;
-
-	priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_FSYNCDIR;
-	if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
-
-        call_count = local->call_count;
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND (frame, afr_fsyncdir_cbk,
-                                    priv->children[i],
-                                    priv->children[i]->fops->fsyncdir,
-                                    fd, datasync, xdata);
-                        if (!--call_count)
-                                break;
-                }
+afr_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+             dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int32_t call_count = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_FSYNCDIR;
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    call_count = local->call_count;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND(frame, afr_fsyncdir_cbk, priv->children[i],
+                       priv->children[i]->fops->fsyncdir, fd, datasync, xdata);
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fsyncdir, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
 
 static int
-afr_serialized_lock_wind (call_frame_t *frame, xlator_t *this);
+afr_serialized_lock_wind(call_frame_t *frame, xlator_t *this);
 
 static gf_boolean_t
-afr_is_conflicting_lock_present (int32_t op_ret, int32_t op_errno)
+afr_is_conflicting_lock_present(int32_t op_ret, int32_t op_errno)
 {
-        if (op_ret == -1 && op_errno == EAGAIN)
-                return _gf_true;
-        return _gf_false;
+    if (op_ret == -1 && op_errno == EAGAIN)
+        return _gf_true;
+    return _gf_false;
 }
 
 static void
-afr_fop_lock_unwind (call_frame_t *frame, glusterfs_fop_t op, int32_t op_ret,
-                     int32_t op_errno, dict_t *xdata)
+afr_fop_lock_unwind(call_frame_t *frame, glusterfs_fop_t op, int32_t op_ret,
+                    int32_t op_errno, dict_t *xdata)
 {
-        switch (op) {
+    switch (op) {
         case GF_FOP_INODELK:
-                AFR_STACK_UNWIND (inodelk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(inodelk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_FINODELK:
-                AFR_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(finodelk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                AFR_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(entrylk, frame, op_ret, op_errno, xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                AFR_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, xdata);
-                break;
+            AFR_STACK_UNWIND(fentrylk, frame, op_ret, op_errno, xdata);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 }
 
 static void
-afr_fop_lock_wind (call_frame_t *frame, xlator_t *this, int child_index,
-                   int32_t (*lock_cbk) (call_frame_t *, void *, xlator_t *,
-                                        int32_t, int32_t, dict_t *))
+afr_fop_lock_wind(call_frame_t *frame, xlator_t *this, int child_index,
+                  int32_t (*lock_cbk)(call_frame_t *, void *, xlator_t *,
+                                      int32_t, int32_t, dict_t *))
 {
-        afr_local_t *local = frame->local;
-        afr_private_t *priv = this->private;
-        int i = child_index;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    int i = child_index;
 
-        switch (local->op) {
+    switch (local->op) {
         case GF_FOP_INODELK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->inodelk,
-                                   (const char *)local->cont.inodelk.volume,
-                                   &local->loc, local->cont.inodelk.cmd,
-                                   &local->cont.inodelk.flock,
-                                   local->cont.inodelk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->inodelk,
+                (const char *)local->cont.inodelk.volume, &local->loc,
+                local->cont.inodelk.cmd, &local->cont.inodelk.flock,
+                local->cont.inodelk.xdata);
+            break;
         case GF_FOP_FINODELK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->finodelk,
-                                   (const char *)local->cont.inodelk.volume,
-                                   local->fd, local->cont.inodelk.cmd,
-                                   &local->cont.inodelk.flock,
-                                   local->cont.inodelk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->finodelk,
+                (const char *)local->cont.inodelk.volume, local->fd,
+                local->cont.inodelk.cmd, &local->cont.inodelk.flock,
+                local->cont.inodelk.xdata);
+            break;
         case GF_FOP_ENTRYLK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->entrylk,
-                                   local->cont.entrylk.volume, &local->loc,
-                                   local->cont.entrylk.basename,
-                                   local->cont.entrylk.cmd,
-                                   local->cont.entrylk.type,
-                                   local->cont.entrylk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->entrylk, local->cont.entrylk.volume,
+                &local->loc, local->cont.entrylk.basename,
+                local->cont.entrylk.cmd, local->cont.entrylk.type,
+                local->cont.entrylk.xdata);
+            break;
         case GF_FOP_FENTRYLK:
-                STACK_WIND_COOKIE (frame, lock_cbk, (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->fentrylk,
-                                   local->cont.entrylk.volume, local->fd,
-                                   local->cont.entrylk.basename,
-                                   local->cont.entrylk.cmd,
-                                   local->cont.entrylk.type,
-                                   local->cont.entrylk.xdata);
-                break;
+            STACK_WIND_COOKIE(
+                frame, lock_cbk, (void *)(long)i, priv->children[i],
+                priv->children[i]->fops->fentrylk, local->cont.entrylk.volume,
+                local->fd, local->cont.entrylk.basename,
+                local->cont.entrylk.cmd, local->cont.entrylk.type,
+                local->cont.entrylk.xdata);
+            break;
         default:
-                break;
-        }
+            break;
+    }
 }
 
 void
-afr_fop_lock_proceed (call_frame_t *frame)
+afr_fop_lock_proceed(call_frame_t *frame)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = frame->this->private;
+    local = frame->local;
+    priv = frame->this->private;
 
-        if (local->fop_lock_state != AFR_FOP_LOCK_PARALLEL) {
-                afr_fop_lock_unwind (frame, local->op, local->op_ret,
-                                     local->op_errno, local->xdata_rsp);
-                return;
-        }
-        /* At least one child is up */
-        /*
-         * Non-blocking locks also need to be serialized.  Otherwise there is
-         * a chance that both the mounts which issued same non-blocking inodelk
-         * may endup not acquiring the lock on any-brick.
-         * Ex: Mount1 and Mount2
-         * request for full length lock on file f1.  Mount1 afr may acquire the
-         * partial lock on brick-1 and may not acquire the lock on brick-2
-         * because Mount2 already got the lock on brick-2, vice versa.  Since
-         * both the mounts only got partial locks, afr treats them as failure in
-         * gaining the locks and unwinds with EAGAIN errno.
-         */
-        local->op_ret = -1;
-        local->op_errno = EUCLEAN;
-        local->fop_lock_state = AFR_FOP_LOCK_SERIAL;
-        afr_local_replies_wipe (local, priv);
-        if (local->xdata_rsp)
-                dict_unref (local->xdata_rsp);
-        local->xdata_rsp = NULL;
-        switch (local->op) {
+    if (local->fop_lock_state != AFR_FOP_LOCK_PARALLEL) {
+        afr_fop_lock_unwind(frame, local->op, local->op_ret, local->op_errno,
+                            local->xdata_rsp);
+        return;
+    }
+    /* At least one child is up */
+    /*
+     * Non-blocking locks also need to be serialized.  Otherwise there is
+     * a chance that both the mounts which issued same non-blocking inodelk
+     * may endup not acquiring the lock on any-brick.
+     * Ex: Mount1 and Mount2
+     * request for full length lock on file f1.  Mount1 afr may acquire the
+     * partial lock on brick-1 and may not acquire the lock on brick-2
+     * because Mount2 already got the lock on brick-2, vice versa.  Since
+     * both the mounts only got partial locks, afr treats them as failure in
+     * gaining the locks and unwinds with EAGAIN errno.
+     */
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
+    local->fop_lock_state = AFR_FOP_LOCK_SERIAL;
+    afr_local_replies_wipe(local, priv);
+    if (local->xdata_rsp)
+        dict_unref(local->xdata_rsp);
+    local->xdata_rsp = NULL;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                local->cont.inodelk.cmd = local->cont.inodelk.in_cmd;
-                local->cont.inodelk.flock = local->cont.inodelk.in_flock;
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-                local->cont.inodelk.xdata = NULL;
-                if (local->xdata_req)
-                        local->cont.inodelk.xdata = dict_ref (local->xdata_req);
-                break;
+            local->cont.inodelk.cmd = local->cont.inodelk.in_cmd;
+            local->cont.inodelk.flock = local->cont.inodelk.in_flock;
+            if (local->cont.inodelk.xdata)
+                dict_unref(local->cont.inodelk.xdata);
+            local->cont.inodelk.xdata = NULL;
+            if (local->xdata_req)
+                local->cont.inodelk.xdata = dict_ref(local->xdata_req);
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                local->cont.entrylk.cmd = local->cont.entrylk.in_cmd;
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-                local->cont.entrylk.xdata = NULL;
-                if (local->xdata_req)
-                        local->cont.entrylk.xdata = dict_ref (local->xdata_req);
-                break;
+            local->cont.entrylk.cmd = local->cont.entrylk.in_cmd;
+            if (local->cont.entrylk.xdata)
+                dict_unref(local->cont.entrylk.xdata);
+            local->cont.entrylk.xdata = NULL;
+            if (local->xdata_req)
+                local->cont.entrylk.xdata = dict_ref(local->xdata_req);
+            break;
         default:
-                break;
-        }
-        afr_serialized_lock_wind (frame, frame->this);
+            break;
+    }
+    afr_serialized_lock_wind(frame, frame->this);
 }
 
 static int32_t
-afr_unlock_partial_lock_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret,
-                             int32_t op_errno, dict_t *xdata)
+afr_unlock_partial_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int call_count = -1;
-        int child_index = (long)cookie;
-        uuid_t  gfid = {0};
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+    int child_index = (long)cookie;
+    uuid_t gfid = {0};
 
-        local = frame->local;
-        priv = this->private;
-
-        if (op_ret < 0 && op_errno != ENOTCONN) {
-                if (local->fd)
-                        gf_uuid_copy (gfid, local->fd->inode->gfid);
-                else
-                        loc_gfid (&local->loc, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "%s: Failed to unlock %s on %s "
-                        "with lk_owner: %s", uuid_utoa (gfid),
-                        gf_fop_list[local->op],
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
+    local = frame->local;
+    priv = this->private;
+
+    if (op_ret < 0 && op_errno != ENOTCONN) {
+        if (local->fd)
+            gf_uuid_copy(gfid, local->fd->inode->gfid);
+        else
+            loc_gfid(&local->loc, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "%s: Failed to unlock %s on %s "
+               "with lk_owner: %s",
+               uuid_utoa(gfid), gf_fop_list[local->op],
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                afr_fop_lock_proceed (frame);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        afr_fop_lock_proceed(frame);
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-afr_unlock_locks_and_proceed (call_frame_t *frame, xlator_t *this,
+afr_unlock_locks_and_proceed(call_frame_t *frame, xlator_t *this,
                              int call_count)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        if (call_count == 0) {
-                afr_fop_lock_proceed (frame);
-                goto out;
-        }
+    if (call_count == 0) {
+        afr_fop_lock_proceed(frame);
+        goto out;
+    }
 
-        local = frame->local;
-        priv = this->private;
-        local->call_count = call_count;
-        switch (local->op) {
+    local = frame->local;
+    priv = this->private;
+    local->call_count = call_count;
+    switch (local->op) {
         case GF_FOP_INODELK:
         case GF_FOP_FINODELK:
-                local->cont.inodelk.flock.l_type = F_UNLCK;
-                local->cont.inodelk.cmd = F_SETLK;
-                if (local->cont.inodelk.xdata)
-                        dict_unref (local->cont.inodelk.xdata);
-                local->cont.inodelk.xdata = NULL;
-                break;
+            local->cont.inodelk.flock.l_type = F_UNLCK;
+            local->cont.inodelk.cmd = F_SETLK;
+            if (local->cont.inodelk.xdata)
+                dict_unref(local->cont.inodelk.xdata);
+            local->cont.inodelk.xdata = NULL;
+            break;
         case GF_FOP_ENTRYLK:
         case GF_FOP_FENTRYLK:
-                local->cont.entrylk.cmd = ENTRYLK_UNLOCK;
-                if (local->cont.entrylk.xdata)
-                        dict_unref (local->cont.entrylk.xdata);
-                local->cont.entrylk.xdata = NULL;
-                break;
+            local->cont.entrylk.cmd = ENTRYLK_UNLOCK;
+            if (local->cont.entrylk.xdata)
+                dict_unref(local->cont.entrylk.xdata);
+            local->cont.entrylk.xdata = NULL;
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
 
-                if (local->replies[i].op_ret == -1)
-                        continue;
+        if (local->replies[i].op_ret == -1)
+            continue;
 
-                afr_fop_lock_wind (frame, this, i, afr_unlock_partial_lock_cbk);
+        afr_fop_lock_wind(frame, this, i, afr_unlock_partial_lock_cbk);
 
-                if (!--call_count)
-                        break;
-        }
+        if (!--call_count)
+            break;
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_fop_lock_done (call_frame_t *frame, xlator_t *this)
+afr_fop_lock_done(call_frame_t *frame, xlator_t *this)
 {
-        int i = 0;
-        int lock_count = 0;
-        unsigned char *success = NULL;
+    int i = 0;
+    int lock_count = 0;
+    unsigned char *success = NULL;
 
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
-        success = alloca0(priv->child_count);
+    local = frame->local;
+    priv = this->private;
+    success = alloca0(priv->child_count);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
 
-                if (local->replies[i].op_ret == 0) {
-                        lock_count++;
-                        success[i] = 1;
-                }
+        if (local->replies[i].op_ret == 0) {
+            lock_count++;
+            success[i] = 1;
+        }
 
-                if (local->op_ret == -1 && local->op_errno == EAGAIN)
-                        continue;
+        if (local->op_ret == -1 && local->op_errno == EAGAIN)
+            continue;
 
-                if ((local->replies[i].op_ret == -1) &&
-                    (local->replies[i].op_errno == EAGAIN)) {
-                        local->op_ret = -1;
-                        local->op_errno = EAGAIN;
-                        continue;
-                }
+        if ((local->replies[i].op_ret == -1) &&
+            (local->replies[i].op_errno == EAGAIN)) {
+            local->op_ret = -1;
+            local->op_errno = EAGAIN;
+            continue;
+        }
 
-                if (local->replies[i].op_ret == 0)
-                        local->op_ret = 0;
+        if (local->replies[i].op_ret == 0)
+            local->op_ret = 0;
 
-                local->op_errno = local->replies[i].op_errno;
-        }
+        local->op_errno = local->replies[i].op_errno;
+    }
 
-        if (afr_fop_lock_is_unlock (frame))
-                goto unwind;
-
-        if (afr_is_conflicting_lock_present (local->op_ret, local->op_errno)) {
-                afr_unlock_locks_and_proceed (frame, this, lock_count);
-        } else if (priv->quorum_count && !afr_has_quorum (success, this)) {
-                local->fop_lock_state = AFR_FOP_LOCK_QUORUM_FAILED;
-                local->op_ret = -1;
-                local->op_errno = afr_final_errno (local, priv);
-                if (local->op_errno == 0)
-                        local->op_errno = afr_quorum_errno (priv);
-                afr_unlock_locks_and_proceed (frame, this, lock_count);
-        } else {
-                goto unwind;
-        }
+    if (afr_fop_lock_is_unlock(frame))
+        goto unwind;
 
-        return 0;
+    if (afr_is_conflicting_lock_present(local->op_ret, local->op_errno)) {
+        afr_unlock_locks_and_proceed(frame, this, lock_count);
+    } else if (priv->quorum_count && !afr_has_quorum(success, this)) {
+        local->fop_lock_state = AFR_FOP_LOCK_QUORUM_FAILED;
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
+        if (local->op_errno == 0)
+            local->op_errno = afr_quorum_errno(priv);
+        afr_unlock_locks_and_proceed(frame, this, lock_count);
+    } else {
+        goto unwind;
+    }
+
+    return 0;
 unwind:
-        afr_fop_lock_unwind (frame, local->op, local->op_ret,
-                             local->op_errno, local->xdata_rsp);
-        return 0;
+    afr_fop_lock_unwind(frame, local->op, local->op_ret, local->op_errno,
+                        local->xdata_rsp);
+    return 0;
 }
 
 static int
-afr_common_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_common_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int child_index = (long)cookie;
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->replies[child_index].valid = 1;
-        local->replies[child_index].op_ret = op_ret;
-        local->replies[child_index].op_errno = op_errno;
-        if (op_ret == 0 && xdata) {
-                local->replies[child_index].xdata = dict_ref (xdata);
-                LOCK (&frame->lock);
-                {
-                        if (!local->xdata_rsp)
-                                local->xdata_rsp = dict_ref (xdata);
-                }
-                UNLOCK (&frame->lock);
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (op_ret == 0 && xdata) {
+        local->replies[child_index].xdata = dict_ref(xdata);
+        LOCK(&frame->lock);
+        {
+            if (!local->xdata_rsp)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        return 0;
+        UNLOCK(&frame->lock);
+    }
+    return 0;
 }
 
 static int32_t
-afr_serialized_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_serialized_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int child_index = (long)cookie;
-        int next_child  = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = (long)cookie;
+    int next_child = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        for (next_child = child_index + 1; next_child < priv->child_count;
-             next_child++) {
-                if (local->child_up[next_child])
-                        break;
-        }
+    for (next_child = child_index + 1; next_child < priv->child_count;
+         next_child++) {
+        if (local->child_up[next_child])
+            break;
+    }
 
-        if (afr_is_conflicting_lock_present (op_ret, op_errno) ||
-            (next_child == priv->child_count)) {
-                afr_fop_lock_done (frame, this);
-        } else {
-                afr_fop_lock_wind (frame, this, next_child,
-                                   afr_serialized_lock_cbk);
-        }
+    if (afr_is_conflicting_lock_present(op_ret, op_errno) ||
+        (next_child == priv->child_count)) {
+        afr_fop_lock_done(frame, this);
+    } else {
+        afr_fop_lock_wind(frame, this, next_child, afr_serialized_lock_cbk);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_serialized_lock_wind (call_frame_t *frame, xlator_t *this)
+afr_serialized_lock_wind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local  = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        afr_fop_lock_wind (frame, this, i,
-                                           afr_serialized_lock_cbk);
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            afr_fop_lock_wind(frame, this, i, afr_serialized_lock_cbk);
+            break;
         }
-        return 0;
+    }
+    return 0;
 }
 
 static int32_t
-afr_parallel_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_parallel_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        int     call_count = 0;
+    int call_count = 0;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                afr_fop_lock_done (frame, this);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        afr_fop_lock_done(frame, this);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_parallel_lock_wind (call_frame_t *frame, xlator_t *this)
+afr_parallel_lock_wind(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local  = NULL;
-        int         call_count = 0;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
-        call_count = local->call_count;
+    priv = this->private;
+    local = frame->local;
+    call_count = local->call_count;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->child_up[i])
-                        continue;
-                afr_fop_lock_wind (frame, this, i, afr_parallel_lock_cbk);
-                if (!--call_count)
-                        break;
-        }
-        return 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
+        afr_fop_lock_wind(frame, this, i, afr_parallel_lock_cbk);
+        if (!--call_count)
+            break;
+    }
+    return 0;
 }
 
 static int
-afr_fop_handle_lock (call_frame_t *frame, xlator_t *this)
+afr_fop_handle_lock(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = frame->local;
-        int op_errno = 0;
+    afr_local_t *local = frame->local;
+    int op_errno = 0;
 
-        if (!afr_fop_lock_is_unlock (frame)) {
-                if (!afr_is_consistent_io_possible (local, this->private,
-                                                &op_errno))
-                        goto out;
+    if (!afr_fop_lock_is_unlock(frame)) {
+        if (!afr_is_consistent_io_possible(local, this->private, &op_errno))
+            goto out;
 
-                switch (local->op) {
-                case GF_FOP_INODELK:
-                case GF_FOP_FINODELK:
-                        local->cont.inodelk.cmd = F_SETLK;
-                        break;
-                case GF_FOP_ENTRYLK:
-                case GF_FOP_FENTRYLK:
-                        local->cont.entrylk.cmd = ENTRYLK_LOCK_NB;
-                        break;
-                default:
-                        break;
-                }
+        switch (local->op) {
+            case GF_FOP_INODELK:
+            case GF_FOP_FINODELK:
+                local->cont.inodelk.cmd = F_SETLK;
+                break;
+            case GF_FOP_ENTRYLK:
+            case GF_FOP_FENTRYLK:
+                local->cont.entrylk.cmd = ENTRYLK_LOCK_NB;
+                break;
+            default:
+                break;
         }
+    }
 
-        if (local->xdata_req) {
-                switch (local->op) {
-                case GF_FOP_INODELK:
-                case GF_FOP_FINODELK:
-                        local->cont.inodelk.xdata = dict_ref (local->xdata_req);
-                        break;
-                case GF_FOP_ENTRYLK:
-                case GF_FOP_FENTRYLK:
-                        local->cont.entrylk.xdata = dict_ref (local->xdata_req);
-                        break;
-                default:
-                        break;
-                }
+    if (local->xdata_req) {
+        switch (local->op) {
+            case GF_FOP_INODELK:
+            case GF_FOP_FINODELK:
+                local->cont.inodelk.xdata = dict_ref(local->xdata_req);
+                break;
+            case GF_FOP_ENTRYLK:
+            case GF_FOP_FENTRYLK:
+                local->cont.entrylk.xdata = dict_ref(local->xdata_req);
+                break;
+            default:
+                break;
         }
+    }
 
-        local->fop_lock_state = AFR_FOP_LOCK_PARALLEL;
-        afr_parallel_lock_wind (frame, this);
+    local->fop_lock_state = AFR_FOP_LOCK_PARALLEL;
+    afr_parallel_lock_wind(frame, this);
 out:
-        return -op_errno;
+    return -op_errno;
 }
 
 static int32_t
-afr_handle_inodelk (call_frame_t *frame, glusterfs_fop_t fop,
-                    const char *volume, loc_t *loc, fd_t *fd, int32_t cmd,
-                    struct gf_flock *flock, dict_t *xdata)
+afr_handle_inodelk(call_frame_t *frame, glusterfs_fop_t fop, const char *volume,
+                   loc_t *loc, fd_t *fd, int32_t cmd, struct gf_flock *flock,
+                   dict_t *xdata)
 {
-        afr_local_t *local  = NULL;
-        int32_t op_errno = ENOMEM;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = fop;
-        if (loc)
-                loc_copy (&local->loc, loc);
-        if (fd)
-                local->fd = fd_ref (fd);
-
-        local->cont.inodelk.volume = gf_strdup (volume);
-        if (!local->cont.inodelk.volume) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        local->cont.inodelk.in_cmd = cmd;
-        local->cont.inodelk.cmd = cmd;
-        local->cont.inodelk.in_flock = *flock;
-        local->cont.inodelk.flock = *flock;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-
-        op_errno = -afr_fop_handle_lock (frame, frame->this);
-        if (op_errno)
-                goto out;
-        return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = fop;
+    if (loc)
+        loc_copy(&local->loc, loc);
+    if (fd)
+        local->fd = fd_ref(fd);
+
+    local->cont.inodelk.volume = gf_strdup(volume);
+    if (!local->cont.inodelk.volume) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->cont.inodelk.in_cmd = cmd;
+    local->cont.inodelk.cmd = cmd;
+    local->cont.inodelk.in_flock = *flock;
+    local->cont.inodelk.flock = *flock;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    op_errno = -afr_fop_handle_lock(frame, frame->this);
+    if (op_errno)
+        goto out;
+    return 0;
 out:
-        afr_fop_lock_unwind (frame, fop, -1, op_errno, NULL);
+    afr_fop_lock_unwind(frame, fop, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_inodelk (call_frame_t *frame, xlator_t *this,
-             const char *volume, loc_t *loc, int32_t cmd,
-             struct gf_flock *flock, dict_t *xdata)
+afr_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        afr_handle_inodelk (frame, GF_FOP_INODELK, volume, loc, NULL, cmd,
-                            flock, xdata);
-        return 0;
+    afr_handle_inodelk(frame, GF_FOP_INODELK, volume, loc, NULL, cmd, flock,
+                       xdata);
+    return 0;
 }
 
 int32_t
-afr_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-	      int32_t cmd, struct gf_flock *flock, dict_t *xdata)
+afr_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        afr_handle_inodelk (frame, GF_FOP_FINODELK, volume, NULL, fd, cmd,
-                            flock, xdata);
-        return 0;
+    afr_handle_inodelk(frame, GF_FOP_FINODELK, volume, NULL, fd, cmd, flock,
+                       xdata);
+    return 0;
 }
 
 static int
-afr_handle_entrylk (call_frame_t *frame, glusterfs_fop_t fop,
-                    const char *volume, loc_t *loc, fd_t *fd,
-                    const char *basename, entrylk_cmd cmd,
-                    entrylk_type type, dict_t *xdata)
-{
-        afr_local_t *local  = NULL;
-        int32_t op_errno = ENOMEM;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = fop;
-        if (loc)
-                loc_copy (&local->loc, loc);
-        if (fd)
-                local->fd = fd_ref (fd);
-        local->cont.entrylk.cmd = cmd;
-        local->cont.entrylk.in_cmd = cmd;
-        local->cont.entrylk.type = type;
-        local->cont.entrylk.volume = gf_strdup (volume);
-        local->cont.entrylk.basename = gf_strdup (basename);
-        if (!local->cont.entrylk.volume || !local->cont.entrylk.basename) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-        op_errno = -afr_fop_handle_lock (frame, frame->this);
-        if (op_errno)
-                goto out;
-
-        return 0;
+afr_handle_entrylk(call_frame_t *frame, glusterfs_fop_t fop, const char *volume,
+                   loc_t *loc, fd_t *fd, const char *basename, entrylk_cmd cmd,
+                   entrylk_type type, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = fop;
+    if (loc)
+        loc_copy(&local->loc, loc);
+    if (fd)
+        local->fd = fd_ref(fd);
+    local->cont.entrylk.cmd = cmd;
+    local->cont.entrylk.in_cmd = cmd;
+    local->cont.entrylk.type = type;
+    local->cont.entrylk.volume = gf_strdup(volume);
+    local->cont.entrylk.basename = gf_strdup(basename);
+    if (!local->cont.entrylk.volume || !local->cont.entrylk.basename) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+    op_errno = -afr_fop_handle_lock(frame, frame->this);
+    if (op_errno)
+        goto out;
+
+    return 0;
 out:
-        afr_fop_lock_unwind (frame, fop, -1, op_errno, NULL);
-        return 0;
+    afr_fop_lock_unwind(frame, fop, -1, op_errno, NULL);
+    return 0;
 }
 
 int
-afr_entrylk (call_frame_t *frame, xlator_t *this, const char *volume,
-	     loc_t *loc, const char *basename, entrylk_cmd cmd,
-	     entrylk_type type, dict_t *xdata)
+afr_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata)
 {
-        afr_handle_entrylk (frame, GF_FOP_ENTRYLK, volume, loc, NULL, basename,
-                            cmd, type, xdata);
-        return 0;
+    afr_handle_entrylk(frame, GF_FOP_ENTRYLK, volume, loc, NULL, basename, cmd,
+                       type, xdata);
+    return 0;
 }
 
 int
-afr_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-              const char *basename, entrylk_cmd cmd, entrylk_type type,
-	      dict_t *xdata)
+afr_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             const char *basename, entrylk_cmd cmd, entrylk_type type,
+             dict_t *xdata)
 {
-        afr_handle_entrylk (frame, GF_FOP_FENTRYLK, volume, NULL, fd, basename,
-                            cmd, type, xdata);
-        return 0;
+    afr_handle_entrylk(frame, GF_FOP_FENTRYLK, volume, NULL, fd, basename, cmd,
+                       type, xdata);
+    return 0;
 }
 
-
 int
-afr_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-		int op_errno, struct statvfs *statvfs, dict_t *xdata)
+afr_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int call_count = 0;
-	struct statvfs *buf = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    struct statvfs *buf = NULL;
 
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
-
-                if (op_ret != 0) {
-                        local->op_errno = op_errno;
-			goto unlock;
-		}
-
-		local->op_ret = op_ret;
-
-		buf = &local->cont.statfs.buf;
-		if (local->cont.statfs.buf_set) {
-			if (statvfs->f_bavail < buf->f_bavail) {
-				*buf = *statvfs;
-				if (xdata) {
-					if (local->xdata_rsp)
-						dict_unref (local->xdata_rsp);
-					local->xdata_rsp = dict_ref (xdata);
-				}
-			}
-		} else {
-			*buf = *statvfs;
-			local->cont.statfs.buf_set = 1;
-			if (xdata)
-				local->xdata_rsp = dict_ref (xdata);
-		}
+    LOCK(&frame->lock);
+    {
+        local = frame->local;
+
+        if (op_ret != 0) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
+
+        local->op_ret = op_ret;
+
+        buf = &local->cont.statfs.buf;
+        if (local->cont.statfs.buf_set) {
+            if (statvfs->f_bavail < buf->f_bavail) {
+                *buf = *statvfs;
+                if (xdata) {
+                    if (local->xdata_rsp)
+                        dict_unref(local->xdata_rsp);
+                    local->xdata_rsp = dict_ref(xdata);
+                }
+            }
+        } else {
+            *buf = *statvfs;
+            local->cont.statfs.buf_set = 1;
+            if (xdata)
+                local->xdata_rsp = dict_ref(xdata);
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-                AFR_STACK_UNWIND (statfs, frame, local->op_ret, local->op_errno,
-                                  &local->cont.statfs.buf, local->xdata_rsp);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                         &local->cont.statfs.buf, local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-        afr_local_t   *  local       = NULL;
-	afr_private_t   *priv        = NULL;
-        int              i           = 0;
-        int              call_count = 0;
-        int32_t          op_errno    = ENOMEM;
-
-	priv = this->private;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_STATFS;
-	if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
-
-        if (priv->arbiter_count == 1 && local->child_up[ARBITER_BRICK_INDEX])
-                local->call_count--;
-        call_count = local->call_count;
-	if (!call_count) {
-		op_errno = ENOTCONN;
-		goto out;
-	}
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        if (AFR_IS_ARBITER_BRICK(priv, i))
-                                continue;
-                        STACK_WIND (frame, afr_statfs_cbk,
-                                    priv->children[i],
-                                    priv->children[i]->fops->statfs,
-                                    loc, xdata);
-                        if (!--call_count)
-                                break;
-                }
+afr_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_STATFS;
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    if (priv->arbiter_count == 1 && local->child_up[ARBITER_BRICK_INDEX])
+        local->call_count--;
+    call_count = local->call_count;
+    if (!call_count) {
+        op_errno = ENOTCONN;
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            if (AFR_IS_ARBITER_BRICK(priv, i))
+                continue;
+            STACK_WIND(frame, afr_statfs_cbk, priv->children[i],
+                       priv->children[i]->fops->statfs, loc, xdata);
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_lk_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-                   dict_t *xdata)
+afr_lk_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+                  dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = this->private;
-        int call_count = -1;
-        int child_index = (long)cookie;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = this->private;
+    int call_count = -1;
+    int child_index = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "gfid=%s: unlock failed on subvolume %s "
-                        "with lock owner %s",
-                        uuid_utoa (local->fd->inode->gfid),
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
+    if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "gfid=%s: unlock failed on subvolume %s "
+               "with lock owner %s",
+               uuid_utoa(local->fd->inode->gfid),
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  NULL, local->xdata_rsp);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno, NULL,
+                         local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_lk_unlock (call_frame_t *frame, xlator_t *this)
+afr_lk_unlock(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   * local = NULL;
-        afr_private_t * priv  = NULL;
-        int i = 0;
-        int call_count = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        call_count = afr_locked_nodes_count (local->cont.lk.locked_nodes,
-                                             priv->child_count);
+    call_count = afr_locked_nodes_count(local->cont.lk.locked_nodes,
+                                        priv->child_count);
 
-        if (call_count == 0) {
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  NULL, local->xdata_rsp);
-                return 0;
-        }
+    if (call_count == 0) {
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno, NULL,
+                         local->xdata_rsp);
+        return 0;
+    }
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        local->cont.lk.user_flock.l_type = F_UNLCK;
+    local->cont.lk.user_flock.l_type = F_UNLCK;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->cont.lk.locked_nodes[i]) {
-                        STACK_WIND_COOKIE (frame, afr_lk_unlock_cbk,
-                                    (void *) (long) i, priv->children[i],
-                                    priv->children[i]->fops->lk,
-                                    local->fd, F_SETLK,
-                                    &local->cont.lk.user_flock, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->cont.lk.locked_nodes[i]) {
+            STACK_WIND_COOKIE(frame, afr_lk_unlock_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->lk,
+                              local->fd, F_SETLK, &local->cont.lk.user_flock,
+                              NULL);
+
+            if (!--call_count)
+                break;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
-            dict_t *xdata)
+afr_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+           int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int child_index = -1;
-
-
-        local = frame->local;
-        priv  = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = -1;
 
-        child_index = (long) cookie;
+    local = frame->local;
+    priv = this->private;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        if (op_ret < 0 && op_errno == EAGAIN) {
-                local->op_ret   = -1;
-                local->op_errno = EAGAIN;
+    child_index = (long)cookie;
 
-                afr_lk_unlock (frame, this);
-                return 0;
-        }
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    if (op_ret < 0 && op_errno == EAGAIN) {
+        local->op_ret = -1;
+        local->op_errno = EAGAIN;
 
-        if (op_ret == 0) {
-                local->op_ret        = 0;
-                local->op_errno      = 0;
-                local->cont.lk.locked_nodes[child_index] = 1;
-                local->cont.lk.ret_flock = *lock;
-        }
+        afr_lk_unlock(frame, this);
+        return 0;
+    }
+
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->op_errno = 0;
+        local->cont.lk.locked_nodes[child_index] = 1;
+        local->cont.lk.ret_flock = *lock;
+    }
+
+    child_index++;
+
+    if (child_index < priv->child_count) {
+        STACK_WIND_COOKIE(frame, afr_lk_cbk, (void *)(long)child_index,
+                          priv->children[child_index],
+                          priv->children[child_index]->fops->lk, local->fd,
+                          local->cont.lk.cmd, &local->cont.lk.user_flock,
+                          local->xdata_req);
+    } else if (priv->quorum_count &&
+               !afr_has_quorum(local->cont.lk.locked_nodes, this)) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
 
-        child_index++;
-
-        if (child_index < priv->child_count) {
-                STACK_WIND_COOKIE (frame, afr_lk_cbk, (void *) (long) child_index,
-                                   priv->children[child_index],
-                                   priv->children[child_index]->fops->lk,
-                                   local->fd, local->cont.lk.cmd,
-                                   &local->cont.lk.user_flock,
-                                   local->xdata_req);
-        } else if (priv->quorum_count &&
-                   !afr_has_quorum (local->cont.lk.locked_nodes, this)) {
-                local->op_ret   = -1;
-                local->op_errno = afr_final_errno (local, priv);
-
-                afr_lk_unlock (frame, this);
-        } else {
-                if (local->op_ret < 0)
-                        local->op_errno = afr_final_errno (local, priv);
+        afr_lk_unlock(frame, this);
+    } else {
+        if (local->op_ret < 0)
+            local->op_errno = afr_final_errno(local, priv);
 
-                AFR_STACK_UNWIND (lk, frame, local->op_ret, local->op_errno,
-                                  &local->cont.lk.ret_flock, local->xdata_rsp);
-        }
+        AFR_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno,
+                         &local->cont.lk.ret_flock, local->xdata_rsp);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_lk (call_frame_t *frame, xlator_t *this,
-        fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata)
-{
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
-        int32_t op_errno = ENOMEM;
-
-        priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
-
-        local->op = GF_FOP_LK;
-        if (!afr_lk_is_unlock (cmd, flock) &&
-            !afr_is_consistent_io_possible (local, priv, &op_errno))
-                goto out;
-
-        local->cont.lk.locked_nodes = GF_CALLOC (priv->child_count,
-                                                 sizeof (*local->cont.lk.locked_nodes),
-                                                 gf_afr_mt_char);
-
-        if (!local->cont.lk.locked_nodes) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        local->fd            = fd_ref (fd);
-        local->cont.lk.cmd   = cmd;
-        local->cont.lk.user_flock = *flock;
-        local->cont.lk.ret_flock = *flock;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, afr_lk_cbk, (void *) (long) 0,
-                           priv->children[i],
-                           priv->children[i]->fops->lk,
-                           fd, cmd, flock, local->xdata_req);
-
-	return 0;
+afr_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+       struct gf_flock *flock, dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int32_t op_errno = ENOMEM;
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_LK;
+    if (!afr_lk_is_unlock(cmd, flock) &&
+        !afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    local->cont.lk.locked_nodes = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lk.locked_nodes),
+        gf_afr_mt_char);
+
+    if (!local->cont.lk.locked_nodes) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->fd = fd_ref(fd);
+    local->cont.lk.cmd = cmd;
+    local->cont.lk.user_flock = *flock;
+    local->cont.lk.ret_flock = *flock;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, afr_lk_cbk, (void *)(long)0, priv->children[i],
+                      priv->children[i]->fops->lk, fd, cmd, flock,
+                      local->xdata_req);
+
+    return 0;
 out:
-	AFR_STACK_UNWIND (lk, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_lease_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
-                      dict_t *xdata)
+afr_lease_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
+                     dict_t *xdata)
 {
-        afr_local_t  *local      = NULL;
-        int           call_count = -1;
+    afr_local_t *local = NULL;
+    int call_count = -1;
 
-        local = frame->local;
-        call_count = afr_frame_return (frame);
+    local = frame->local;
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-                AFR_STACK_UNWIND (lease, frame, local->op_ret, local->op_errno,
-                                  lease, xdata);
+    if (call_count == 0)
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno, lease,
+                         xdata);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_lease_unlock (call_frame_t *frame, xlator_t *this)
+afr_lease_unlock(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   *local      = NULL;
-        afr_private_t *priv       = NULL;
-        int            i          = 0;
-        int            call_count = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_count = 0;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        call_count = afr_locked_nodes_count (local->cont.lease.locked_nodes,
-                                             priv->child_count);
+    call_count = afr_locked_nodes_count(local->cont.lease.locked_nodes,
+                                        priv->child_count);
 
-        if (call_count == 0) {
-                AFR_STACK_UNWIND (lease, frame, local->op_ret, local->op_errno,
-                                  &local->cont.lease.ret_lease, NULL);
-                return 0;
-        }
+    if (call_count == 0) {
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno,
+                         &local->cont.lease.ret_lease, NULL);
+        return 0;
+    }
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        local->cont.lease.user_lease.cmd = GF_UNLK_LEASE;
+    local->cont.lease.user_lease.cmd = GF_UNLK_LEASE;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->cont.lease.locked_nodes[i]) {
-                        STACK_WIND (frame, afr_lease_unlock_cbk,
-                                    priv->children[i],
-                                    priv->children[i]->fops->lease,
-                                    &local->loc, &local->cont.lease.user_lease, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->cont.lease.locked_nodes[i]) {
+            STACK_WIND(frame, afr_lease_unlock_cbk, priv->children[i],
+                       priv->children[i]->fops->lease, &local->loc,
+                       &local->cont.lease.user_lease, NULL);
+
+            if (!--call_count)
+                break;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
-               dict_t *xdata)
+afr_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        afr_local_t   *local       = NULL;
-        afr_private_t *priv        = NULL;
-        int            child_index = -1;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = -1;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        child_index = (long) cookie;
+    child_index = (long)cookie;
 
-        afr_common_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        if (op_ret < 0 && op_errno == EAGAIN) {
-                local->op_ret   = -1;
-                local->op_errno = EAGAIN;
+    afr_common_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    if (op_ret < 0 && op_errno == EAGAIN) {
+        local->op_ret = -1;
+        local->op_errno = EAGAIN;
 
-                afr_lease_unlock (frame, this);
-                return 0;
-        }
+        afr_lease_unlock(frame, this);
+        return 0;
+    }
 
-        if (op_ret == 0) {
-                local->op_ret        = 0;
-                local->op_errno      = 0;
-                local->cont.lease.locked_nodes[child_index] = 1;
-                local->cont.lease.ret_lease = *lease;
-        }
+    if (op_ret == 0) {
+        local->op_ret = 0;
+        local->op_errno = 0;
+        local->cont.lease.locked_nodes[child_index] = 1;
+        local->cont.lease.ret_lease = *lease;
+    }
+
+    child_index++;
+    if (child_index < priv->child_count) {
+        STACK_WIND_COOKIE(frame, afr_lease_cbk, (void *)(long)child_index,
+                          priv->children[child_index],
+                          priv->children[child_index]->fops->lease, &local->loc,
+                          &local->cont.lease.user_lease, xdata);
+    } else if (priv->quorum_count &&
+               !afr_has_quorum(local->cont.lk.locked_nodes, this)) {
+        local->op_ret = -1;
+        local->op_errno = afr_final_errno(local, priv);
 
-        child_index++;
-        if (child_index < priv->child_count) {
-                STACK_WIND_COOKIE (frame, afr_lease_cbk, (void *) (long) child_index,
-                                   priv->children[child_index],
-                                   priv->children[child_index]->fops->lease,
-                                   &local->loc, &local->cont.lease.user_lease, xdata);
-        } else if  (priv->quorum_count &&
-                   !afr_has_quorum (local->cont.lk.locked_nodes, this)) {
-                local->op_ret   = -1;
-                local->op_errno = afr_final_errno (local, priv);
-
-                afr_lease_unlock (frame, this);
-        } else {
-                if (local->op_ret < 0)
-                        local->op_errno = afr_final_errno (local, priv);
-                AFR_STACK_UNWIND (lease, frame, local->op_ret, local->op_errno,
-                                  &local->cont.lease.ret_lease, NULL);
-        }
+        afr_lease_unlock(frame, this);
+    } else {
+        if (local->op_ret < 0)
+            local->op_errno = afr_final_errno(local, priv);
+        AFR_STACK_UNWIND(lease, frame, local->op_ret, local->op_errno,
+                         &local->cont.lease.ret_lease, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_lease (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, struct gf_lease *lease, dict_t *xdata)
+afr_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+          struct gf_lease *lease, dict_t *xdata)
 {
-        afr_private_t *priv     = NULL;
-        afr_local_t   *local    = NULL;
-        int32_t        op_errno = ENOMEM;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int32_t op_errno = ENOMEM;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_LEASE;
-        local->cont.lease.locked_nodes = GF_CALLOC (priv->child_count,
-                                                    sizeof (*local->cont.lease.locked_nodes),
-                                                    gf_afr_mt_char);
+    local->op = GF_FOP_LEASE;
+    local->cont.lease.locked_nodes = GF_CALLOC(
+        priv->child_count, sizeof(*local->cont.lease.locked_nodes),
+        gf_afr_mt_char);
 
-        if (!local->cont.lease.locked_nodes) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (!local->cont.lease.locked_nodes) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-        loc_copy (&local->loc, loc);
-        local->cont.lease.user_lease = *lease;
-        local->cont.lease.ret_lease = *lease;
+    loc_copy(&local->loc, loc);
+    local->cont.lease.user_lease = *lease;
+    local->cont.lease.ret_lease = *lease;
 
-        STACK_WIND_COOKIE (frame, afr_lease_cbk, (void *) (long) 0,
-                           priv->children[0],
-                           priv->children[0]->fops->lease,
-                           loc, lease, xdata);
+    STACK_WIND_COOKIE(frame, afr_lease_cbk, (void *)(long)0, priv->children[0],
+                      priv->children[0]->fops->lease, loc, lease, xdata);
 
-        return 0;
+    return 0;
 out:
-        AFR_STACK_UNWIND (lease, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(lease, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-        afr_local_t   *local          = NULL;
-        int            child_index    = (long)cookie;
-        int            call_count     = 0;
-        gf_boolean_t   failed         = _gf_false;
-        gf_boolean_t   succeeded      = _gf_false;
-        int            i              = 0;
-        afr_private_t *priv           = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-        local->replies[child_index].valid = 1;
-        local->replies[child_index].op_ret = op_ret;
-        local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
-
-        call_count = afr_frame_return (frame);
-        if (call_count)
-                goto out;
-        /* If any of the subvolumes failed with other than ENOTCONN
-         * return error else return success unless all the subvolumes
-         * failed.
-         * TODO: In case of failure, we need to unregister the xattrs
-         * from the other subvolumes where it succeeded (once upcall
-         * fixes the Bz-1371622)*/
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-                if (local->replies[i].op_ret < 0 &&
-                    local->replies[i].op_errno != ENOTCONN) {
-                        local->op_ret = local->replies[i].op_ret;
-                        local->op_errno = local->replies[i].op_errno;
-                        if (local->xdata_rsp)
-                                dict_unref (local->xdata_rsp);
-                        local->xdata_rsp = NULL;
-                        if (local->replies[i].xdata) {
-                                local->xdata_rsp =
-                                        dict_ref (local->replies[i].xdata);
-                        }
-                        failed = _gf_true;
-                        break;
-                }
-                if (local->replies[i].op_ret == 0) {
-                        succeeded = _gf_true;
-                        local->op_ret = 0;
-                        local->op_errno = 0;
-                        if (!local->xdata_rsp && local->replies[i].xdata) {
-                                local->xdata_rsp =
-                                        dict_ref (local->replies[i].xdata);
-                        }
-                }
+afr_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = 0;
+    gf_boolean_t failed = _gf_false;
+    gf_boolean_t succeeded = _gf_false;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
+
+    call_count = afr_frame_return(frame);
+    if (call_count)
+        goto out;
+    /* If any of the subvolumes failed with other than ENOTCONN
+     * return error else return success unless all the subvolumes
+     * failed.
+     * TODO: In case of failure, we need to unregister the xattrs
+     * from the other subvolumes where it succeeded (once upcall
+     * fixes the Bz-1371622)*/
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0 &&
+            local->replies[i].op_errno != ENOTCONN) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+            if (local->xdata_rsp)
+                dict_unref(local->xdata_rsp);
+            local->xdata_rsp = NULL;
+            if (local->replies[i].xdata) {
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+            failed = _gf_true;
+            break;
+        }
+        if (local->replies[i].op_ret == 0) {
+            succeeded = _gf_true;
+            local->op_ret = 0;
+            local->op_errno = 0;
+            if (!local->xdata_rsp && local->replies[i].xdata) {
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
         }
+    }
 
-        if (!succeeded && !failed) {
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-        }
+    if (!succeeded && !failed) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+    }
 
-        AFR_STACK_UNWIND (ipc, frame, local->op_ret, local->op_errno,
-                          local->xdata_rsp);
+    AFR_STACK_UNWIND(ipc, frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
 
 out:
-        return 0;
+    return 0;
 }
 
 int
-afr_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+afr_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        afr_local_t    *local    = NULL;
-        int32_t         op_errno = -1;
-        afr_private_t  *priv     = NULL;
-        int             i        = 0;
-        int             call_cnt = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
+    afr_local_t *local = NULL;
+    int32_t op_errno = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int call_cnt = -1;
 
-        if (op != GF_IPC_TARGET_UPCALL)
-                goto wind_default;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
 
-        VALIDATE_OR_GOTO (this->private, err);
-        priv = this->private;
+    if (op != GF_IPC_TARGET_UPCALL)
+        goto wind_default;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto err;
+    VALIDATE_OR_GOTO(this->private, err);
+    priv = this->private;
 
-        call_cnt = local->call_count;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto err;
 
-        if (xdata) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (dict_set_int8 (xdata, priv->pending_key[i], 0) < 0)
-                                goto err;
-                }
-        }
+    call_cnt = local->call_count;
 
+    if (xdata) {
         for (i = 0; i < priv->child_count; i++) {
-                if (!local->child_up[i])
-                        continue;
-
-                STACK_WIND_COOKIE (frame, afr_ipc_cbk,
-                                   (void *) (long) i,
-                                   priv->children[i],
-                                   priv->children[i]->fops->ipc,
-                                   op, xdata);
-                if (!--call_cnt)
-                        break;
+            if (dict_set_int8(xdata, priv->pending_key[i], 0) < 0)
+                goto err;
         }
-        return 0;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
+
+        STACK_WIND_COOKIE(frame, afr_ipc_cbk, (void *)(long)i,
+                          priv->children[i], priv->children[i]->fops->ipc, op,
+                          xdata);
+        if (!--call_cnt)
+            break;
+    }
+    return 0;
 
 err:
-        if (op_errno == -1)
-                op_errno = errno;
-        AFR_STACK_UNWIND (ipc, frame, -1, op_errno, NULL);
+    if (op_errno == -1)
+        op_errno = errno;
+    AFR_STACK_UNWIND(ipc, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 
 wind_default:
-        STACK_WIND (frame, default_ipc_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->ipc, op, xdata);
-        return 0;
+    STACK_WIND(frame, default_ipc_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ipc, op, xdata);
+    return 0;
 }
 
 int
-afr_forget (xlator_t *this, inode_t *inode)
+afr_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t        ctx_int = 0;
-        afr_inode_ctx_t *ctx    = NULL;
-
-        afr_spb_choice_timeout_cancel (this, inode);
-        inode_ctx_del (inode, this, &ctx_int);
-        if (!ctx_int)
-                return 0;
+    uint64_t ctx_int = 0;
+    afr_inode_ctx_t *ctx = NULL;
 
-        ctx = (afr_inode_ctx_t *)ctx_int;
-        afr_inode_ctx_destroy (ctx);
+    afr_spb_choice_timeout_cancel(this, inode);
+    inode_ctx_del(inode, this, &ctx_int);
+    if (!ctx_int)
         return 0;
+
+    ctx = (afr_inode_ctx_t *)ctx_int;
+    afr_inode_ctx_destroy(ctx);
+    return 0;
 }
 
 int
-afr_priv_dump (xlator_t *this)
-{
-        afr_private_t *priv = NULL;
-        char  key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char  key[GF_DUMP_MAX_BUF_LEN];
-        int   i = 0;
-
-
-        GF_ASSERT (this);
-        priv = this->private;
-
-        GF_ASSERT (priv);
-        snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
-        gf_proc_dump_add_section(key_prefix);
-        gf_proc_dump_write("child_count", "%u", priv->child_count);
-        for (i = 0; i < priv->child_count; i++) {
-                sprintf (key, "child_up[%d]", i);
-                gf_proc_dump_write(key, "%d", priv->child_up[i]);
-                sprintf (key, "pending_key[%d]", i);
-                gf_proc_dump_write(key, "%s", priv->pending_key[i]);
-                sprintf (key, "pending_reads[%d]", i);
-                gf_proc_dump_write(key, "%"PRId64, GF_ATOMIC_GET(priv->pending_reads[i]));
-                sprintf (key, "child_latency[%d]", i);
-                gf_proc_dump_write(key, "%"PRId64, priv->child_latency[i]);
-        }
-        gf_proc_dump_write("data_self_heal", "%s", priv->data_self_heal);
-        gf_proc_dump_write("metadata_self_heal", "%d", priv->metadata_self_heal);
-        gf_proc_dump_write("entry_self_heal", "%d", priv->entry_self_heal);
-        gf_proc_dump_write("read_child", "%d", priv->read_child);
-        gf_proc_dump_write("wait_count", "%u", priv->wait_count);
-        gf_proc_dump_write("heal-wait-queue-length", "%d",
-                           priv->heal_wait_qlen);
-        gf_proc_dump_write("heal-waiters", "%d", priv->heal_waiters);
-        gf_proc_dump_write("background-self-heal-count", "%d",
-                           priv->background_self_heal_count);
-        gf_proc_dump_write("healers", "%d", priv->healers);
-        gf_proc_dump_write("read-hash-mode", "%d", priv->hash_mode);
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                gf_proc_dump_write ("quorum-type", "auto");
-        } else if (priv->quorum_count == 0) {
-                gf_proc_dump_write ("quorum-type", "none");
-        } else {
-                gf_proc_dump_write("quorum-type", "fixed");
-                gf_proc_dump_write("quorum-count", "%d", priv->quorum_count);
-        }
-        gf_proc_dump_write("up", "%u", afr_has_quorum (priv->child_up, this));
-
-        return 0;
+afr_priv_dump(xlator_t *this)
+{
+    afr_private_t *priv = NULL;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+
+    GF_ASSERT(this);
+    priv = this->private;
+
+    GF_ASSERT(priv);
+    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
+    gf_proc_dump_add_section(key_prefix);
+    gf_proc_dump_write("child_count", "%u", priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        sprintf(key, "child_up[%d]", i);
+        gf_proc_dump_write(key, "%d", priv->child_up[i]);
+        sprintf(key, "pending_key[%d]", i);
+        gf_proc_dump_write(key, "%s", priv->pending_key[i]);
+        sprintf(key, "pending_reads[%d]", i);
+        gf_proc_dump_write(key, "%" PRId64,
+                           GF_ATOMIC_GET(priv->pending_reads[i]));
+        sprintf(key, "child_latency[%d]", i);
+        gf_proc_dump_write(key, "%" PRId64, priv->child_latency[i]);
+    }
+    gf_proc_dump_write("data_self_heal", "%s", priv->data_self_heal);
+    gf_proc_dump_write("metadata_self_heal", "%d", priv->metadata_self_heal);
+    gf_proc_dump_write("entry_self_heal", "%d", priv->entry_self_heal);
+    gf_proc_dump_write("read_child", "%d", priv->read_child);
+    gf_proc_dump_write("wait_count", "%u", priv->wait_count);
+    gf_proc_dump_write("heal-wait-queue-length", "%d", priv->heal_wait_qlen);
+    gf_proc_dump_write("heal-waiters", "%d", priv->heal_waiters);
+    gf_proc_dump_write("background-self-heal-count", "%d",
+                       priv->background_self_heal_count);
+    gf_proc_dump_write("healers", "%d", priv->healers);
+    gf_proc_dump_write("read-hash-mode", "%d", priv->hash_mode);
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        gf_proc_dump_write("quorum-type", "auto");
+    } else if (priv->quorum_count == 0) {
+        gf_proc_dump_write("quorum-type", "none");
+    } else {
+        gf_proc_dump_write("quorum-type", "fixed");
+        gf_proc_dump_write("quorum-count", "%d", priv->quorum_count);
+    }
+    gf_proc_dump_write("up", "%u", afr_has_quorum(priv->child_up, this));
+
+    return 0;
 }
 
-
 /**
  * find_child_index - find the child's index in the array of subvolumes
  * @this: AFR
@@ -5025,1974 +4904,1924 @@ afr_priv_dump (xlator_t *this)
  */
 
 static int
-find_child_index (xlator_t *this, xlator_t *child)
+find_child_index(xlator_t *this, xlator_t *child)
 {
-        afr_private_t *priv = NULL;
-        int i = -1;
+    afr_private_t *priv = NULL;
+    int i = -1;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if ((xlator_t *) child == priv->children[i])
-                        break;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if ((xlator_t *)child == priv->children[i])
+            break;
+    }
 
-        return i;
+    return i;
 }
 
 static int
-__afr_get_up_children_count (afr_private_t *priv)
+__afr_get_up_children_count(afr_private_t *priv)
 {
-        int             up_children         = 0;
-        int             i = 0;
+    int up_children = 0;
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++)
-                if (priv->child_up[i] == 1)
-                        up_children++;
+    for (i = 0; i < priv->child_count; i++)
+        if (priv->child_up[i] == 1)
+            up_children++;
 
-        return up_children;
+    return up_children;
 }
 
 glusterfs_event_t
-__afr_transform_event_from_state (afr_private_t *priv)
+__afr_transform_event_from_state(afr_private_t *priv)
 {
-        int i = 0;
-        int up_children = 0;
+    int i = 0;
+    int up_children = 0;
 
-        if (AFR_COUNT (priv->last_event, priv->child_count) ==
-                       priv->child_count)
-                /* have_heard_from_all. Let afr_notify() do the propagation. */
-                return GF_EVENT_MAXVAL;
+    if (AFR_COUNT(priv->last_event, priv->child_count) == priv->child_count)
+        /* have_heard_from_all. Let afr_notify() do the propagation. */
+        return GF_EVENT_MAXVAL;
 
-        up_children = __afr_get_up_children_count (priv);
-        /* Treat the children with pending notification, as having sent a
-         * GF_EVENT_CHILD_DOWN. i.e. set the event as GF_EVENT_SOME_DESCENDENT_DOWN,
-         * as done in afr_notify() */
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->last_event[i])
-                        continue;
-                priv->last_event[i] = GF_EVENT_SOME_DESCENDENT_DOWN;
-                priv->child_up[i] = 0;
-        }
+    up_children = __afr_get_up_children_count(priv);
+    /* Treat the children with pending notification, as having sent a
+     * GF_EVENT_CHILD_DOWN. i.e. set the event as GF_EVENT_SOME_DESCENDENT_DOWN,
+     * as done in afr_notify() */
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->last_event[i])
+            continue;
+        priv->last_event[i] = GF_EVENT_SOME_DESCENDENT_DOWN;
+        priv->child_up[i] = 0;
+    }
 
-        if (up_children)
-                /* We received at least one child up */
-                return GF_EVENT_CHILD_UP;
-        else
-                return GF_EVENT_CHILD_DOWN;
+    if (up_children)
+        /* We received at least one child up */
+        return GF_EVENT_CHILD_UP;
+    else
+        return GF_EVENT_CHILD_DOWN;
 
-        return GF_EVENT_MAXVAL;
+    return GF_EVENT_MAXVAL;
 }
 
 static void
-afr_notify_cbk (void *data)
-{
-        xlator_t *this = data;
-        afr_private_t *priv = this->private;
-        glusterfs_event_t event = GF_EVENT_MAXVAL;
-        gf_boolean_t propagate = _gf_false;
-
-        LOCK (&priv->lock);
-        {
-                if (!priv->timer) {
-                        /*
-                         * Either child_up/child_down is already sent to parent.
-                         * This is a spurious wake up.
-                         */
-                        goto unlock;
-                }
-                priv->timer = NULL;
-                event = __afr_transform_event_from_state (priv);
-                if (event != GF_EVENT_MAXVAL)
-                        propagate = _gf_true;
-        }
+afr_notify_cbk(void *data)
+{
+    xlator_t *this = data;
+    afr_private_t *priv = this->private;
+    glusterfs_event_t event = GF_EVENT_MAXVAL;
+    gf_boolean_t propagate = _gf_false;
+
+    LOCK(&priv->lock);
+    {
+        if (!priv->timer) {
+            /*
+             * Either child_up/child_down is already sent to parent.
+             * This is a spurious wake up.
+             */
+            goto unlock;
+        }
+        priv->timer = NULL;
+        event = __afr_transform_event_from_state(priv);
+        if (event != GF_EVENT_MAXVAL)
+            propagate = _gf_true;
+    }
 unlock:
-        UNLOCK (&priv->lock);
-        if (propagate)
-                default_notify (this, event, NULL);
+    UNLOCK(&priv->lock);
+    if (propagate)
+        default_notify(this, event, NULL);
 }
 
 static void
-__afr_launch_notify_timer (xlator_t *this, afr_private_t *priv)
+__afr_launch_notify_timer(xlator_t *this, afr_private_t *priv)
 {
+    struct timespec delay = {
+        0,
+    };
 
-        struct timespec delay = {0, };
-
-        gf_msg_debug (this->name, 0, "Initiating child-down timer");
-        delay.tv_sec = 10;
-        delay.tv_nsec = 0;
-        priv->timer = gf_timer_call_after (this->ctx, delay,
-                                           afr_notify_cbk, this);
-        if (priv->timer == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_TIMER_CREATE_FAIL,
-                        "Cannot create timer for delayed initialization");
-        }
+    gf_msg_debug(this->name, 0, "Initiating child-down timer");
+    delay.tv_sec = 10;
+    delay.tv_nsec = 0;
+    priv->timer = gf_timer_call_after(this->ctx, delay, afr_notify_cbk, this);
+    if (priv->timer == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_TIMER_CREATE_FAIL,
+               "Cannot create timer for delayed initialization");
+    }
 }
 
 int
-__get_heard_from_all_status (xlator_t *this)
+__get_heard_from_all_status(xlator_t *this)
 {
-        afr_private_t *priv          = this->private;
-        int           heard_from_all = 1;
-        int           i              = 0;
+    afr_private_t *priv = this->private;
+    int heard_from_all = 1;
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!priv->last_event[i]) {
-                        heard_from_all = 0;
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!priv->last_event[i]) {
+            heard_from_all = 0;
+            break;
         }
-        return heard_from_all;
+    }
+    return heard_from_all;
 }
 
 static int
-find_best_down_child (xlator_t *this)
+find_best_down_child(xlator_t *this)
 {
-        afr_private_t   *priv               = NULL;
-        int             i                   = -1;
-        int32_t         best_child          = -1;
-        int64_t         best_latency        = INT64_MAX;
+    afr_private_t *priv = NULL;
+    int i = -1;
+    int32_t best_child = -1;
+    int64_t best_latency = INT64_MAX;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->child_up[i] &&
-                    priv->child_latency[i] >= 0 &&
-                    priv->child_latency[i] < best_latency) {
-                        best_child = i;
-                        best_latency = priv->child_latency[i];
-                }
-        }
-        if (best_child >= 0) {
-                gf_msg_debug (this->name, 0, "Found best down child (%d) "
-                              "@ %ld ms latency", best_child, best_latency);
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->child_up[i] && priv->child_latency[i] >= 0 &&
+            priv->child_latency[i] < best_latency) {
+            best_child = i;
+            best_latency = priv->child_latency[i];
         }
-        return best_child;
+    }
+    if (best_child >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "Found best down child (%d) "
+                     "@ %ld ms latency",
+                     best_child, best_latency);
+    }
+    return best_child;
 }
 
 int
-find_worst_up_child (xlator_t *this)
+find_worst_up_child(xlator_t *this)
 {
-        afr_private_t   *priv               = NULL;
-        int             i                   = -1;
-        int32_t         worst_child         = -1;
-        int64_t         worst_latency       = INT64_MIN;
+    afr_private_t *priv = NULL;
+    int i = -1;
+    int32_t worst_child = -1;
+    int64_t worst_latency = INT64_MIN;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->child_up[i] &&
-                    priv->child_latency[i] >= 0 &&
-                    priv->child_latency[i] > worst_latency) {
-                        worst_child = i;
-                        worst_latency = priv->child_latency[i];
-                }
-        }
-        if (worst_child >= 0) {
-                gf_msg_debug (this->name, 0, "Found worst up child (%d)"
-                              " @ %ld ms latency", worst_child, worst_latency);
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->child_up[i] && priv->child_latency[i] >= 0 &&
+            priv->child_latency[i] > worst_latency) {
+            worst_child = i;
+            worst_latency = priv->child_latency[i];
         }
-        return worst_child;
+    }
+    if (worst_child >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "Found worst up child (%d)"
+                     " @ %ld ms latency",
+                     worst_child, worst_latency);
+    }
+    return worst_child;
 }
 
 void
-__afr_handle_ping_event (xlator_t *this, xlator_t *child_xlator,
-                const int idx, int64_t halo_max_latency_msec, int32_t *event,
-                int64_t child_latency_msec)
+__afr_handle_ping_event(xlator_t *this, xlator_t *child_xlator, const int idx,
+                        int64_t halo_max_latency_msec, int32_t *event,
+                        int64_t child_latency_msec)
 {
-        afr_private_t   *priv               = NULL;
-        int             up_children         = 0;
+    afr_private_t *priv = NULL;
+    int up_children = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        priv->child_latency[idx] = child_latency_msec;
-        gf_msg_debug (child_xlator->name, 0, "Client ping @ %ld ms",
-                      child_latency_msec);
-        if (priv->shd.iamshd)
-                return;
-
-        up_children = __afr_get_up_children_count (priv);
-
-        if (child_latency_msec > halo_max_latency_msec &&
-            priv->child_up[idx] == 1 &&
-            up_children > priv->halo_min_replicas) {
-                if ((up_children - 1) <
-                    priv->halo_min_replicas) {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                               "Overriding halo threshold, "
-                               "min replicas: %d",
-                               priv->halo_min_replicas);
-                } else {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                                "Child latency (%ld ms) "
-                                "exceeds halo threshold (%ld), "
-                                "marking child down.",
-                                child_latency_msec,
-                                halo_max_latency_msec);
-                        *event = GF_EVENT_CHILD_DOWN;
-                }
-        } else if (child_latency_msec < halo_max_latency_msec &&
-                   priv->child_up[idx] == 0) {
-                if (up_children < priv->halo_max_replicas) {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                                "Child latency (%ld ms) "
-                                "below halo threshold (%ld), "
-                                "marking child up.",
-                                child_latency_msec,
-                                halo_max_latency_msec);
-                        *event = GF_EVENT_CHILD_UP;
-                } else {
-                        gf_log (child_xlator->name, GF_LOG_INFO,
-                            "Not marking child %d up, "
-                            "max replicas (%d) reached.", idx,
-                            priv->halo_max_replicas);
-                }
+    priv->child_latency[idx] = child_latency_msec;
+    gf_msg_debug(child_xlator->name, 0, "Client ping @ %ld ms",
+                 child_latency_msec);
+    if (priv->shd.iamshd)
+        return;
+
+    up_children = __afr_get_up_children_count(priv);
+
+    if (child_latency_msec > halo_max_latency_msec &&
+        priv->child_up[idx] == 1 && up_children > priv->halo_min_replicas) {
+        if ((up_children - 1) < priv->halo_min_replicas) {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Overriding halo threshold, "
+                   "min replicas: %d",
+                   priv->halo_min_replicas);
+        } else {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Child latency (%ld ms) "
+                   "exceeds halo threshold (%ld), "
+                   "marking child down.",
+                   child_latency_msec, halo_max_latency_msec);
+            *event = GF_EVENT_CHILD_DOWN;
+        }
+    } else if (child_latency_msec < halo_max_latency_msec &&
+               priv->child_up[idx] == 0) {
+        if (up_children < priv->halo_max_replicas) {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Child latency (%ld ms) "
+                   "below halo threshold (%ld), "
+                   "marking child up.",
+                   child_latency_msec, halo_max_latency_msec);
+            *event = GF_EVENT_CHILD_UP;
+        } else {
+            gf_log(child_xlator->name, GF_LOG_INFO,
+                   "Not marking child %d up, "
+                   "max replicas (%d) reached.",
+                   idx, priv->halo_max_replicas);
         }
+    }
 }
 
 static int64_t
-afr_get_halo_latency (xlator_t *this)
+afr_get_halo_latency(xlator_t *this)
 {
-        afr_private_t *priv           = NULL;
-        int64_t halo_max_latency_msec = 0;
+    afr_private_t *priv = NULL;
+    int64_t halo_max_latency_msec = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->shd.iamshd) {
-                halo_max_latency_msec = priv->shd.halo_max_latency_msec;
-        } else if (priv->nfsd.iamnfsd) {
-                halo_max_latency_msec =
-                        priv->nfsd.halo_max_latency_msec;
-        } else {
-                halo_max_latency_msec = priv->halo_max_latency_msec;
-        }
-        gf_msg_debug (this->name, 0, "Using halo latency %ld",
-                halo_max_latency_msec);
-        return halo_max_latency_msec;
+    if (priv->shd.iamshd) {
+        halo_max_latency_msec = priv->shd.halo_max_latency_msec;
+    } else if (priv->nfsd.iamnfsd) {
+        halo_max_latency_msec = priv->nfsd.halo_max_latency_msec;
+    } else {
+        halo_max_latency_msec = priv->halo_max_latency_msec;
+    }
+    gf_msg_debug(this->name, 0, "Using halo latency %ld",
+                 halo_max_latency_msec);
+    return halo_max_latency_msec;
 }
 
 void
-__afr_handle_child_up_event (xlator_t *this, xlator_t *child_xlator,
-                const int idx, int64_t child_latency_msec,
-                int32_t *event, int32_t *call_psh, int32_t *up_child)
-{
-        afr_private_t   *priv               = NULL;
-        int             up_children         = 0;
-        int             worst_up_child      = -1;
-        int64_t         halo_max_latency_msec = afr_get_halo_latency (this);
-
-        priv = this->private;
-
-        /*
-         * This only really counts if the child was never up
-         * (value = -1) or had been down (value = 0).  See
-         * comment at GF_EVENT_CHILD_DOWN for a more detailed
-         * explanation.
-         */
-        if (priv->child_up[idx] != 1) {
-                priv->event_generation++;
-        }
-        priv->child_up[idx] = 1;
-
-        *call_psh = 1;
-        *up_child = idx;
-        up_children = __afr_get_up_children_count (priv);
-        /*
-         * If this is an _actual_ CHILD_UP event, we
-         * want to set the child_latency to MAX to indicate
-         * the child needs ping data to be available before doing child-up
-         */
-        if (child_latency_msec < 0 && priv->halo_enabled) {
-                /*set to INT64_MAX-1 so that it is found for best_down_child*/
-                priv->child_latency[idx] = AFR_HALO_MAX_LATENCY;
-        }
-
-        /*
-         * Handle the edge case where we exceed
-         * halo_min_replicas and we've got a child which is
-         * marked up as it was helping to satisfy the
-         * halo_min_replicas even though it's latency exceeds
-         * halo_max_latency_msec.
-         */
-        if (up_children > priv->halo_min_replicas) {
-                worst_up_child = find_worst_up_child (this);
-                if (worst_up_child >= 0 &&
-                    priv->child_latency[worst_up_child] >
-                    halo_max_latency_msec) {
-                        gf_msg_debug (this->name, 0, "Marking child %d down, "
-                                "doesn't meet halo threshold (%ld), and > "
-                                "halo_min_replicas (%d)",
-                                worst_up_child, halo_max_latency_msec,
-                                priv->halo_min_replicas);
-                        priv->child_up[worst_up_child] = 0;
-                        up_children--;
-                }
-        }
-
-        if (up_children > priv->halo_max_replicas &&
-            !priv->shd.iamshd) {
-                worst_up_child = find_worst_up_child (this);
-                if (worst_up_child < 0) {
-                        worst_up_child = idx;
-                }
-                priv->child_up[worst_up_child] = 0;
-                up_children--;
-                gf_msg_debug (this->name, 0, "Marking child %d down, "
-                        "up_children (%d) > halo_max_replicas (%d)",
-                        worst_up_child, up_children, priv->halo_max_replicas);
-        }
-
-        if (up_children == 1) {
-                gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOL_UP,
-                        "Subvolume '%s' came back up; "
-                        "going online.",
-                        child_xlator->name);
-                gf_event (EVENT_AFR_SUBVOL_UP, "subvol=%s", this->name);
-        } else {
-                *event = GF_EVENT_SOME_DESCENDENT_UP;
-        }
-
-        priv->last_event[idx] = *event;
+__afr_handle_child_up_event(xlator_t *this, xlator_t *child_xlator,
+                            const int idx, int64_t child_latency_msec,
+                            int32_t *event, int32_t *call_psh,
+                            int32_t *up_child)
+{
+    afr_private_t *priv = NULL;
+    int up_children = 0;
+    int worst_up_child = -1;
+    int64_t halo_max_latency_msec = afr_get_halo_latency(this);
+
+    priv = this->private;
+
+    /*
+     * This only really counts if the child was never up
+     * (value = -1) or had been down (value = 0).  See
+     * comment at GF_EVENT_CHILD_DOWN for a more detailed
+     * explanation.
+     */
+    if (priv->child_up[idx] != 1) {
+        priv->event_generation++;
+    }
+    priv->child_up[idx] = 1;
+
+    *call_psh = 1;
+    *up_child = idx;
+    up_children = __afr_get_up_children_count(priv);
+    /*
+     * If this is an _actual_ CHILD_UP event, we
+     * want to set the child_latency to MAX to indicate
+     * the child needs ping data to be available before doing child-up
+     */
+    if (child_latency_msec < 0 && priv->halo_enabled) {
+        /*set to INT64_MAX-1 so that it is found for best_down_child*/
+        priv->child_latency[idx] = AFR_HALO_MAX_LATENCY;
+    }
+
+    /*
+     * Handle the edge case where we exceed
+     * halo_min_replicas and we've got a child which is
+     * marked up as it was helping to satisfy the
+     * halo_min_replicas even though it's latency exceeds
+     * halo_max_latency_msec.
+     */
+    if (up_children > priv->halo_min_replicas) {
+        worst_up_child = find_worst_up_child(this);
+        if (worst_up_child >= 0 &&
+            priv->child_latency[worst_up_child] > halo_max_latency_msec) {
+            gf_msg_debug(this->name, 0,
+                         "Marking child %d down, "
+                         "doesn't meet halo threshold (%ld), and > "
+                         "halo_min_replicas (%d)",
+                         worst_up_child, halo_max_latency_msec,
+                         priv->halo_min_replicas);
+            priv->child_up[worst_up_child] = 0;
+            up_children--;
+        }
+    }
+
+    if (up_children > priv->halo_max_replicas && !priv->shd.iamshd) {
+        worst_up_child = find_worst_up_child(this);
+        if (worst_up_child < 0) {
+            worst_up_child = idx;
+        }
+        priv->child_up[worst_up_child] = 0;
+        up_children--;
+        gf_msg_debug(this->name, 0,
+                     "Marking child %d down, "
+                     "up_children (%d) > halo_max_replicas (%d)",
+                     worst_up_child, up_children, priv->halo_max_replicas);
+    }
+
+    if (up_children == 1) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOL_UP,
+               "Subvolume '%s' came back up; "
+               "going online.",
+               child_xlator->name);
+        gf_event(EVENT_AFR_SUBVOL_UP, "subvol=%s", this->name);
+    } else {
+        *event = GF_EVENT_SOME_DESCENDENT_UP;
+    }
+
+    priv->last_event[idx] = *event;
 }
 
 void
-__afr_handle_child_down_event (xlator_t *this, xlator_t *child_xlator,
-                int idx, int64_t child_latency_msec, int32_t *event,
-                int32_t *call_psh, int32_t *up_child)
-{
-        afr_private_t   *priv               = NULL;
-        int             i                   = 0;
-        int             up_children         = 0;
-        int             down_children       = 0;
-        int             best_down_child     = -1;
-
-        priv = this->private;
-
-        /*
-         * If a brick is down when we start, we'll get a
-         * CHILD_DOWN to indicate its initial state.  There
-         * was never a CHILD_UP in this case, so if we
-         * increment "down_count" the difference between than
-         * and "up_count" will no longer be the number of
-         * children that are currently up.  This has serious
-         * implications e.g. for quorum enforcement, so we
-         * don't increment these values unless the event
-         * represents an actual state transition between "up"
-         * (value = 1) and anything else.
-         */
-        if (priv->child_up[idx] == 1) {
-                priv->event_generation++;
-        }
-
-        /*
-         * If this is an _actual_ CHILD_DOWN event, we
-         * want to set the child_latency to < 0 to indicate
-         * the child is really disconnected.
-         */
-        if (child_latency_msec < 0) {
-                priv->child_latency[idx] = child_latency_msec;
-        }
-        priv->child_up[idx] = 0;
-
-        up_children = __afr_get_up_children_count (priv);
-        /*
-         * Handle the edge case where we need to find the
-         * next best child (to mark up) as marking this child
-         * down would cause us to fall below halo_min_replicas.
-         * We will also force the SHD to heal this child _now_
-         * as we want it to be up to date if we are going to
-         * begin using it synchronously.
-         */
-        if (up_children < priv->halo_min_replicas) {
-                best_down_child = find_best_down_child (this);
-                if (best_down_child >= 0) {
-                        gf_msg_debug (this->name, 0,
-                                "Swapping out child %d for "
-                                "child %d to satisfy halo_min_replicas (%d).",
-                                idx, best_down_child, priv->halo_min_replicas);
-                        priv->child_up[best_down_child] = 1;
-                        *call_psh = 1;
-                        *up_child = best_down_child;
-                }
-        }
-
-        for (i = 0; i < priv->child_count; i++)
-                if (priv->child_up[i] == 0)
-                        down_children++;
-        if (down_children == priv->child_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SUBVOLS_DOWN,
-                        "All subvolumes are down. Going "
-                        "offline until at least one of them "
-                        "comes back up.");
-                gf_event (EVENT_AFR_SUBVOLS_DOWN, "subvol=%s", this->name);
-        } else {
-                *event = GF_EVENT_SOME_DESCENDENT_DOWN;
-        }
-        priv->last_event[idx] = *event;
+__afr_handle_child_down_event(xlator_t *this, xlator_t *child_xlator, int idx,
+                              int64_t child_latency_msec, int32_t *event,
+                              int32_t *call_psh, int32_t *up_child)
+{
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int up_children = 0;
+    int down_children = 0;
+    int best_down_child = -1;
+
+    priv = this->private;
+
+    /*
+     * If a brick is down when we start, we'll get a
+     * CHILD_DOWN to indicate its initial state.  There
+     * was never a CHILD_UP in this case, so if we
+     * increment "down_count" the difference between than
+     * and "up_count" will no longer be the number of
+     * children that are currently up.  This has serious
+     * implications e.g. for quorum enforcement, so we
+     * don't increment these values unless the event
+     * represents an actual state transition between "up"
+     * (value = 1) and anything else.
+     */
+    if (priv->child_up[idx] == 1) {
+        priv->event_generation++;
+    }
+
+    /*
+     * If this is an _actual_ CHILD_DOWN event, we
+     * want to set the child_latency to < 0 to indicate
+     * the child is really disconnected.
+     */
+    if (child_latency_msec < 0) {
+        priv->child_latency[idx] = child_latency_msec;
+    }
+    priv->child_up[idx] = 0;
+
+    up_children = __afr_get_up_children_count(priv);
+    /*
+     * Handle the edge case where we need to find the
+     * next best child (to mark up) as marking this child
+     * down would cause us to fall below halo_min_replicas.
+     * We will also force the SHD to heal this child _now_
+     * as we want it to be up to date if we are going to
+     * begin using it synchronously.
+     */
+    if (up_children < priv->halo_min_replicas) {
+        best_down_child = find_best_down_child(this);
+        if (best_down_child >= 0) {
+            gf_msg_debug(this->name, 0,
+                         "Swapping out child %d for "
+                         "child %d to satisfy halo_min_replicas (%d).",
+                         idx, best_down_child, priv->halo_min_replicas);
+            priv->child_up[best_down_child] = 1;
+            *call_psh = 1;
+            *up_child = best_down_child;
+        }
+    }
+
+    for (i = 0; i < priv->child_count; i++)
+        if (priv->child_up[i] == 0)
+            down_children++;
+    if (down_children == priv->child_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SUBVOLS_DOWN,
+               "All subvolumes are down. Going "
+               "offline until at least one of them "
+               "comes back up.");
+        gf_event(EVENT_AFR_SUBVOLS_DOWN, "subvol=%s", this->name);
+    } else {
+        *event = GF_EVENT_SOME_DESCENDENT_DOWN;
+    }
+    priv->last_event[idx] = *event;
 }
 
 int32_t
-afr_notify (xlator_t *this, int32_t event,
-            void *data, void *data2)
-{
-        afr_private_t   *priv               = NULL;
-        xlator_t        *child_xlator       = NULL;
-        int             i                   = -1;
-        int             propagate           = 0;
-        int             had_heard_from_all  = 0;
-        int             have_heard_from_all = 0;
-        int             idx                 = -1;
-        int             ret                 = -1;
-        int             call_psh            = 0;
-        int             up_child            = -1;
-        dict_t          *input              = NULL;
-        dict_t          *output             = NULL;
-        gf_boolean_t    had_quorum          = _gf_false;
-        gf_boolean_t    has_quorum          = _gf_false;
-        struct gf_upcall *up_data           = NULL;
-        struct gf_upcall_cache_invalidation *up_ci = NULL;
-        inode_table_t  *itable              = NULL;
-        inode_t        *inode               = NULL;
-        int64_t         halo_max_latency_msec = 0;
-        int64_t         child_latency_msec   = -1;
-
-        child_xlator = (xlator_t *)data;
-
-        priv = this->private;
-
-        if (!priv)
-                return 0;
-
-        /*
-         * We need to reset this in case children come up in "staggered"
-         * fashion, so that we discover a late-arriving local subvolume.  Note
-         * that we could end up issuing N lookups to the first subvolume, and
-         * O(N^2) overall, but N is small for AFR so it shouldn't be an issue.
-         */
-        priv->did_discovery = _gf_false;
-
+afr_notify(xlator_t *this, int32_t event, void *data, void *data2)
+{
+    afr_private_t *priv = NULL;
+    xlator_t *child_xlator = NULL;
+    int i = -1;
+    int propagate = 0;
+    int had_heard_from_all = 0;
+    int have_heard_from_all = 0;
+    int idx = -1;
+    int ret = -1;
+    int call_psh = 0;
+    int up_child = -1;
+    dict_t *input = NULL;
+    dict_t *output = NULL;
+    gf_boolean_t had_quorum = _gf_false;
+    gf_boolean_t has_quorum = _gf_false;
+    struct gf_upcall *up_data = NULL;
+    struct gf_upcall_cache_invalidation *up_ci = NULL;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+    int64_t halo_max_latency_msec = 0;
+    int64_t child_latency_msec = -1;
+
+    child_xlator = (xlator_t *)data;
+
+    priv = this->private;
+
+    if (!priv)
+        return 0;
 
-        /* parent xlators don't need to know about every child_up, child_down
-         * because of afr ha. If all subvolumes go down, child_down has
-         * to be triggered. In that state when 1 subvolume comes up child_up
-         * needs to be triggered. dht optimizes revalidate lookup by sending
-         * it only to one of its subvolumes. When child up/down happens
-         * for afr's subvolumes dht should be notified by child_modified. The
-         * subsequent revalidate lookup happens on all the dht's subvolumes
-         * which triggers afr self-heals if any.
-         */
-        idx = find_child_index (this, child_xlator);
-        if (idx < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_CHILD_UP,
-                        "Received child_up from invalid subvolume");
-                goto out;
-        }
+    /*
+     * We need to reset this in case children come up in "staggered"
+     * fashion, so that we discover a late-arriving local subvolume.  Note
+     * that we could end up issuing N lookups to the first subvolume, and
+     * O(N^2) overall, but N is small for AFR so it shouldn't be an issue.
+     */
+    priv->did_discovery = _gf_false;
+
+    /* parent xlators don't need to know about every child_up, child_down
+     * because of afr ha. If all subvolumes go down, child_down has
+     * to be triggered. In that state when 1 subvolume comes up child_up
+     * needs to be triggered. dht optimizes revalidate lookup by sending
+     * it only to one of its subvolumes. When child up/down happens
+     * for afr's subvolumes dht should be notified by child_modified. The
+     * subsequent revalidate lookup happens on all the dht's subvolumes
+     * which triggers afr self-heals if any.
+     */
+    idx = find_child_index(this, child_xlator);
+    if (idx < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_CHILD_UP,
+               "Received child_up from invalid subvolume");
+        goto out;
+    }
+
+    had_quorum = priv->quorum_count && afr_has_quorum(priv->child_up, this);
+    if (priv->halo_enabled) {
+        halo_max_latency_msec = afr_get_halo_latency(this);
 
-        had_quorum = priv->quorum_count && afr_has_quorum (priv->child_up,
-                                                           this);
-        if (priv->halo_enabled) {
-                halo_max_latency_msec = afr_get_halo_latency (this);
-
-                if (event == GF_EVENT_CHILD_PING) {
-                        /* Calculates the child latency and sets event
-                         */
-                        child_latency_msec = (int64_t)(uintptr_t)data2;
-                        LOCK (&priv->lock);
-                        {
-                                __afr_handle_ping_event (this, child_xlator,
-                                        idx, halo_max_latency_msec, &event,
+        if (event == GF_EVENT_CHILD_PING) {
+            /* Calculates the child latency and sets event
+             */
+            child_latency_msec = (int64_t)(uintptr_t)data2;
+            LOCK(&priv->lock);
+            {
+                __afr_handle_ping_event(this, child_xlator, idx,
+                                        halo_max_latency_msec, &event,
                                         child_latency_msec);
-                        }
-                        UNLOCK (&priv->lock);
-                }
+            }
+            UNLOCK(&priv->lock);
         }
+    }
 
-        if (event == GF_EVENT_CHILD_PING) {
-                /* This is the only xlator that handles PING, no reason to
-                 * propagate.
-                 */
-                goto out;
-            }
+    if (event == GF_EVENT_CHILD_PING) {
+        /* This is the only xlator that handles PING, no reason to
+         * propagate.
+         */
+        goto out;
+    }
 
-        if (event == GF_EVENT_TRANSLATOR_OP) {
-                LOCK (&priv->lock);
-                {
-                        had_heard_from_all = __get_heard_from_all_status (this);
-                }
-                UNLOCK (&priv->lock);
-
-                if (!had_heard_from_all) {
-                        ret = -1;
-                } else {
-                        input = data;
-                        output = data2;
-                        ret = afr_xl_op (this, input, output);
-                }
-                goto out;
+    if (event == GF_EVENT_TRANSLATOR_OP) {
+        LOCK(&priv->lock);
+        {
+            had_heard_from_all = __get_heard_from_all_status(this);
         }
+        UNLOCK(&priv->lock);
 
-        LOCK (&priv->lock);
-        {
-                had_heard_from_all = __get_heard_from_all_status (this);
-                switch (event) {
-                case GF_EVENT_PARENT_UP:
-                        __afr_launch_notify_timer (this, priv);
-                        propagate = 1;
-                        break;
-                case GF_EVENT_CHILD_UP:
-                        __afr_handle_child_up_event (this, child_xlator,
-                                idx, child_latency_msec, &event, &call_psh,
-                                &up_child);
-                        break;
+        if (!had_heard_from_all) {
+            ret = -1;
+        } else {
+            input = data;
+            output = data2;
+            ret = afr_xl_op(this, input, output);
+        }
+        goto out;
+    }
+
+    LOCK(&priv->lock);
+    {
+        had_heard_from_all = __get_heard_from_all_status(this);
+        switch (event) {
+            case GF_EVENT_PARENT_UP:
+                __afr_launch_notify_timer(this, priv);
+                propagate = 1;
+                break;
+            case GF_EVENT_CHILD_UP:
+                __afr_handle_child_up_event(this, child_xlator, idx,
+                                            child_latency_msec, &event,
+                                            &call_psh, &up_child);
+                break;
 
-                case GF_EVENT_CHILD_DOWN:
-                        __afr_handle_child_down_event (this, child_xlator, idx,
-                                child_latency_msec, &event, &call_psh,
-                                &up_child);
-                        break;
+            case GF_EVENT_CHILD_DOWN:
+                __afr_handle_child_down_event(this, child_xlator, idx,
+                                              child_latency_msec, &event,
+                                              &call_psh, &up_child);
+                break;
 
-                case GF_EVENT_CHILD_CONNECTING:
-                        priv->last_event[idx] = event;
+            case GF_EVENT_CHILD_CONNECTING:
+                priv->last_event[idx] = event;
 
-                        break;
+                break;
+
+            case GF_EVENT_SOME_DESCENDENT_DOWN:
+                priv->last_event[idx] = event;
+                break;
+            case GF_EVENT_UPCALL:
+                up_data = (struct gf_upcall *)data;
+                if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
+                    break;
+                up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
+
+                /* Since md-cache will be aggressively filtering
+                 * lookups, the stale read issue will be more
+                 * pronounced. Hence when a pending xattr is set notify
+                 * all the md-cache clients to invalidate the existing
+                 * stat cache and send the lookup next time */
+                if (!up_ci->dict)
+                    break;
+                for (i = 0; i < priv->child_count; i++) {
+                    if (dict_get(up_ci->dict, priv->pending_key[i])) {
+                        up_ci->flags |= UP_INVAL_ATTR;
+                        itable = ((xlator_t *)this->graph->top)->itable;
+                        /*Internal processes may not have itable for top
+                         * xlator*/
+                        if (itable)
+                            inode = inode_find(itable, up_data->gfid);
+                        if (inode)
+                            afr_inode_need_refresh_set(inode, this);
 
-                case GF_EVENT_SOME_DESCENDENT_DOWN:
-                        priv->last_event[idx] = event;
-                        break;
-                case GF_EVENT_UPCALL:
-                        up_data = (struct gf_upcall *)data;
-                        if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
-                                break;
-                        up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
-
-                        /* Since md-cache will be aggressively filtering
-                         * lookups, the stale read issue will be more
-                         * pronounced. Hence when a pending xattr is set notify
-                         * all the md-cache clients to invalidate the existing
-                         * stat cache and send the lookup next time */
-                        if (!up_ci->dict)
-                                break;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (dict_get (up_ci->dict, priv->pending_key[i])) {
-                                         up_ci->flags |= UP_INVAL_ATTR;
-                                         itable = ((xlator_t *)this->graph->top)->itable;
-                                         /*Internal processes may not have itable for top xlator*/
-                                         if (itable)
-                                                 inode = inode_find (itable, up_data->gfid);
-                                         if (inode)
-                                                 afr_inode_need_refresh_set (inode, this);
-
-                                         break;
-                                }
-                        }
-                        break;
-                default:
-                        propagate = 1;
                         break;
+                    }
                 }
-                have_heard_from_all = __get_heard_from_all_status (this);
-                if (!had_heard_from_all && have_heard_from_all) {
-                        if (priv->timer) {
-                                gf_timer_call_cancel (this->ctx, priv->timer);
-                                priv->timer = NULL;
-                        }
-                        /* This is the first event which completes aggregation
-                           of events from all subvolumes. If at least one subvol
-                           had come up, propagate CHILD_UP, but only this time
-                        */
-                        event = GF_EVENT_CHILD_DOWN;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (priv->last_event[i] == GF_EVENT_CHILD_UP) {
-                                        event = GF_EVENT_CHILD_UP;
-                                        break;
-                                }
-
-                                if (priv->last_event[i] ==
-                                                GF_EVENT_CHILD_CONNECTING) {
-                                        event = GF_EVENT_CHILD_CONNECTING;
-                               /* continue to check other events for CHILD_UP */
-                                }
-                        }
-                }
+                break;
+            default:
+                propagate = 1;
+                break;
         }
-        UNLOCK (&priv->lock);
-
-        if (priv->quorum_count) {
-                has_quorum = afr_has_quorum (priv->child_up, this);
-                if (!had_quorum && has_quorum) {
-                        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_QUORUM_MET,
-                                "Client-quorum is met");
-                        gf_event  (EVENT_AFR_QUORUM_MET,
-                                   "subvol=%s", this->name);
-                }
-                if (had_quorum && !has_quorum) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_QUORUM_FAIL,
-                                "Client-quorum is not met");
-                        gf_event  (EVENT_AFR_QUORUM_FAIL, "subvol=%s",
-                                   this->name);
+        have_heard_from_all = __get_heard_from_all_status(this);
+        if (!had_heard_from_all && have_heard_from_all) {
+            if (priv->timer) {
+                gf_timer_call_cancel(this->ctx, priv->timer);
+                priv->timer = NULL;
+            }
+            /* This is the first event which completes aggregation
+               of events from all subvolumes. If at least one subvol
+               had come up, propagate CHILD_UP, but only this time
+            */
+            event = GF_EVENT_CHILD_DOWN;
+            for (i = 0; i < priv->child_count; i++) {
+                if (priv->last_event[i] == GF_EVENT_CHILD_UP) {
+                    event = GF_EVENT_CHILD_UP;
+                    break;
                 }
-        }
-
-        /* if all subvols have reported status, no need to hide anything
-           or wait for anything else. Just propagate blindly */
-        if (have_heard_from_all)
-                propagate = 1;
 
-        ret = 0;
-        if (propagate)
-                ret = default_notify (this, event, data);
-
-        if ((!had_heard_from_all) || call_psh) {
-                /* Launch self-heal on all local subvolumes if:
-                 * a) We have_heard_from_all for the first time
-                 * b) Already heard from everyone, but we now got a child-up
-                 *    event.
-                 */
-                if (have_heard_from_all && priv->shd.iamshd) {
-                        for (i = 0; i < priv->child_count; i++)
-                                if (priv->child_up[i])
-                                        afr_selfheal_childup (this, i);
+                if (priv->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
+                    event = GF_EVENT_CHILD_CONNECTING;
+                    /* continue to check other events for CHILD_UP */
                 }
+            }
+        }
+    }
+    UNLOCK(&priv->lock);
+
+    if (priv->quorum_count) {
+        has_quorum = afr_has_quorum(priv->child_up, this);
+        if (!had_quorum && has_quorum) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_QUORUM_MET,
+                   "Client-quorum is met");
+            gf_event(EVENT_AFR_QUORUM_MET, "subvol=%s", this->name);
+        }
+        if (had_quorum && !has_quorum) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
+                   "Client-quorum is not met");
+            gf_event(EVENT_AFR_QUORUM_FAIL, "subvol=%s", this->name);
+        }
+    }
+
+    /* if all subvols have reported status, no need to hide anything
+       or wait for anything else. Just propagate blindly */
+    if (have_heard_from_all)
+        propagate = 1;
+
+    ret = 0;
+    if (propagate)
+        ret = default_notify(this, event, data);
+
+    if ((!had_heard_from_all) || call_psh) {
+        /* Launch self-heal on all local subvolumes if:
+         * a) We have_heard_from_all for the first time
+         * b) Already heard from everyone, but we now got a child-up
+         *    event.
+         */
+        if (have_heard_from_all && priv->shd.iamshd) {
+            for (i = 0; i < priv->child_count; i++)
+                if (priv->child_up[i])
+                    afr_selfheal_childup(this, i);
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_local_init (afr_local_t *local, afr_private_t *priv, int32_t *op_errno)
+afr_local_init(afr_local_t *local, afr_private_t *priv, int32_t *op_errno)
 {
-        int __ret = -1;
-        local->op_ret = -1;
-        local->op_errno = EUCLEAN;
+    int __ret = -1;
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
 
-	__ret = syncbarrier_init (&local->barrier);
-        if (__ret) {
-                if (op_errno)
-                        *op_errno = __ret;
-                goto out;
-        }
+    __ret = syncbarrier_init(&local->barrier);
+    if (__ret) {
+        if (op_errno)
+            *op_errno = __ret;
+        goto out;
+    }
 
-        local->child_up = GF_CALLOC (priv->child_count,
-                                     sizeof (*local->child_up),
-                                     gf_afr_mt_char);
-        if (!local->child_up) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
+    local->child_up = GF_CALLOC(priv->child_count, sizeof(*local->child_up),
+                                gf_afr_mt_char);
+    if (!local->child_up) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    memcpy(local->child_up, priv->child_up,
+           sizeof(*local->child_up) * priv->child_count);
+    local->call_count = AFR_COUNT(local->child_up, priv->child_count);
+    if (local->call_count == 0) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOLS_DOWN,
+               "no subvolumes up");
+        if (op_errno)
+            *op_errno = ENOTCONN;
+        goto out;
+    }
 
-        memcpy (local->child_up, priv->child_up,
-                sizeof (*local->child_up) * priv->child_count);
-        local->call_count = AFR_COUNT (local->child_up, priv->child_count);
-        if (local->call_count == 0) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0,
-                        AFR_MSG_SUBVOLS_DOWN, "no subvolumes up");
-                if (op_errno)
-                        *op_errno = ENOTCONN;
-                goto out;
-        }
+    local->event_generation = priv->event_generation;
 
-	local->event_generation = priv->event_generation;
-
-	local->read_attempted = GF_CALLOC (priv->child_count, sizeof (char),
-					   gf_afr_mt_char);
-	if (!local->read_attempted) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
-
-	local->readable = GF_CALLOC (priv->child_count, sizeof (char),
-				     gf_afr_mt_char);
-	if (!local->readable) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
-
-        local->readable2 = GF_CALLOC (priv->child_count, sizeof (char),
+    local->read_attempted = GF_CALLOC(priv->child_count, sizeof(char),
                                       gf_afr_mt_char);
-        if (!local->readable2) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
+    if (!local->read_attempted) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
 
-        local->read_subvol = -1;
+    local->readable = GF_CALLOC(priv->child_count, sizeof(char),
+                                gf_afr_mt_char);
+    if (!local->readable) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
 
-	local->replies = GF_CALLOC(priv->child_count, sizeof(*local->replies),
-				   gf_afr_mt_reply_t);
-	if (!local->replies) {
-		if (op_errno)
-			*op_errno = ENOMEM;
-		goto out;
-	}
+    local->readable2 = GF_CALLOC(priv->child_count, sizeof(char),
+                                 gf_afr_mt_char);
+    if (!local->readable2) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
 
-        local->need_full_crawl = _gf_false;
+    local->read_subvol = -1;
 
-        INIT_LIST_HEAD (&local->healer);
-	return 0;
+    local->replies = GF_CALLOC(priv->child_count, sizeof(*local->replies),
+                               gf_afr_mt_reply_t);
+    if (!local->replies) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->need_full_crawl = _gf_false;
+
+    INIT_LIST_HEAD(&local->healer);
+    return 0;
 out:
-        return -1;
+    return -1;
 }
 
 int
-afr_internal_lock_init (afr_internal_lock_t *lk, size_t child_count)
+afr_internal_lock_init(afr_internal_lock_t *lk, size_t child_count)
 {
-        int             ret = -ENOMEM;
+    int ret = -ENOMEM;
 
-        lk->locked_nodes = GF_CALLOC (sizeof (*lk->locked_nodes),
-                                      child_count, gf_afr_mt_char);
-        if (NULL == lk->locked_nodes)
-                goto out;
+    lk->locked_nodes = GF_CALLOC(sizeof(*lk->locked_nodes), child_count,
+                                 gf_afr_mt_char);
+    if (NULL == lk->locked_nodes)
+        goto out;
 
-        lk->lower_locked_nodes = GF_CALLOC (sizeof (*lk->lower_locked_nodes),
-                                            child_count, gf_afr_mt_char);
-        if (NULL == lk->lower_locked_nodes)
-                goto out;
+    lk->lower_locked_nodes = GF_CALLOC(sizeof(*lk->lower_locked_nodes),
+                                       child_count, gf_afr_mt_char);
+    if (NULL == lk->lower_locked_nodes)
+        goto out;
 
-        lk->lock_op_ret   = -1;
-        lk->lock_op_errno = EUCLEAN;
+    lk->lock_op_ret = -1;
+    lk->lock_op_errno = EUCLEAN;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 void
-afr_matrix_cleanup (int32_t **matrix, unsigned int m)
+afr_matrix_cleanup(int32_t **matrix, unsigned int m)
 {
-        int             i         = 0;
+    int i = 0;
 
-        if (!matrix)
-                goto out;
-        for (i = 0; i < m; i++) {
-                GF_FREE (matrix[i]);
-        }
+    if (!matrix)
+        goto out;
+    for (i = 0; i < m; i++) {
+        GF_FREE(matrix[i]);
+    }
 
-        GF_FREE (matrix);
+    GF_FREE(matrix);
 out:
-        return;
+    return;
 }
 
-int32_t**
-afr_matrix_create (unsigned int m, unsigned int n)
+int32_t **
+afr_matrix_create(unsigned int m, unsigned int n)
 {
-        int32_t         **matrix = NULL;
-        int             i       = 0;
+    int32_t **matrix = NULL;
+    int i = 0;
 
-        matrix = GF_CALLOC (sizeof (*matrix), m, gf_afr_mt_int32_t);
-        if (!matrix)
-                goto out;
+    matrix = GF_CALLOC(sizeof(*matrix), m, gf_afr_mt_int32_t);
+    if (!matrix)
+        goto out;
 
-        for (i = 0; i < m; i++) {
-                matrix[i] = GF_CALLOC (sizeof (*matrix[i]), n,
-                                       gf_afr_mt_int32_t);
-                if (!matrix[i])
-                        goto out;
-        }
-        return matrix;
+    for (i = 0; i < m; i++) {
+        matrix[i] = GF_CALLOC(sizeof(*matrix[i]), n, gf_afr_mt_int32_t);
+        if (!matrix[i])
+            goto out;
+    }
+    return matrix;
 out:
-        afr_matrix_cleanup (matrix, m);
-        return NULL;
+    afr_matrix_cleanup(matrix, m);
+    return NULL;
 }
 
 int
-afr_transaction_local_init (afr_local_t *local, xlator_t *this)
-{
-        int            ret = -ENOMEM;
-        afr_private_t *priv = NULL;
-
-        priv = this->private;
-        ret = afr_internal_lock_init (&local->internal_lock, priv->child_count);
-        if (ret < 0)
-                goto out;
-
-        ret = -ENOMEM;
-	local->pre_op_compat = priv->pre_op_compat;
-
-        local->transaction.pre_op = GF_CALLOC (sizeof (*local->transaction.pre_op),
-                                               priv->child_count,
-                                               gf_afr_mt_char);
-        if (!local->transaction.pre_op)
-                goto out;
-
-        local->transaction.changelog_xdata =
-                GF_CALLOC (sizeof (*local->transaction.changelog_xdata),
-                           priv->child_count, gf_afr_mt_dict_t);
-        if (!local->transaction.changelog_xdata)
-                goto out;
-
-        if (priv->arbiter_count == 1) {
-                local->transaction.pre_op_sources =
-                        GF_CALLOC (sizeof (*local->transaction.pre_op_sources),
-                                   priv->child_count, gf_afr_mt_char);
-                if (!local->transaction.pre_op_sources)
-                        goto out;
-        }
-
-        local->transaction.failed_subvols = GF_CALLOC (sizeof (*local->transaction.failed_subvols),
-						       priv->child_count,
-						       gf_afr_mt_char);
-        if (!local->transaction.failed_subvols)
-                goto out;
-
-        local->pending = afr_matrix_create (priv->child_count,
-                                            AFR_NUM_CHANGE_LOGS);
-        if (!local->pending)
-                goto out;
-
-        ret = 0;
-        INIT_LIST_HEAD (&local->transaction.wait_list);
-        INIT_LIST_HEAD (&local->transaction.owner_list);
+afr_transaction_local_init(afr_local_t *local, xlator_t *this)
+{
+    int ret = -ENOMEM;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    ret = afr_internal_lock_init(&local->internal_lock, priv->child_count);
+    if (ret < 0)
+        goto out;
+
+    ret = -ENOMEM;
+    local->pre_op_compat = priv->pre_op_compat;
+
+    local->transaction.pre_op = GF_CALLOC(sizeof(*local->transaction.pre_op),
+                                          priv->child_count, gf_afr_mt_char);
+    if (!local->transaction.pre_op)
+        goto out;
+
+    local->transaction.changelog_xdata = GF_CALLOC(
+        sizeof(*local->transaction.changelog_xdata), priv->child_count,
+        gf_afr_mt_dict_t);
+    if (!local->transaction.changelog_xdata)
+        goto out;
+
+    if (priv->arbiter_count == 1) {
+        local->transaction.pre_op_sources = GF_CALLOC(
+            sizeof(*local->transaction.pre_op_sources), priv->child_count,
+            gf_afr_mt_char);
+        if (!local->transaction.pre_op_sources)
+            goto out;
+    }
+
+    local->transaction.failed_subvols = GF_CALLOC(
+        sizeof(*local->transaction.failed_subvols), priv->child_count,
+        gf_afr_mt_char);
+    if (!local->transaction.failed_subvols)
+        goto out;
+
+    local->pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!local->pending)
+        goto out;
+
+    ret = 0;
+    INIT_LIST_HEAD(&local->transaction.wait_list);
+    INIT_LIST_HEAD(&local->transaction.owner_list);
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-afr_set_low_priority (call_frame_t *frame)
+afr_set_low_priority(call_frame_t *frame)
 {
-        frame->root->pid = LOW_PRIO_PROC_PID;
+    frame->root->pid = LOW_PRIO_PROC_PID;
 }
 
-
 void
-afr_priv_destroy (afr_private_t *priv)
-{
-        int i = 0;
-        int child_count = -1;
-
-        if (!priv)
-                goto out;
-        GF_FREE (priv->last_event);
-
-        child_count = priv->child_count;
-        if (priv->thin_arbiter_count) {
-                child_count++;
-        }
-        if (priv->pending_key) {
-                for (i = 0; i < child_count; i++)
-                        GF_FREE (priv->pending_key[i]);
-        }
-
-        GF_FREE (priv->pending_reads);
-        GF_FREE (priv->local);
-        GF_FREE (priv->pending_key);
-        GF_FREE (priv->children);
-        GF_FREE (priv->child_up);
-        GF_FREE (priv->child_latency);
-        LOCK_DESTROY (&priv->lock);
-
-        GF_FREE (priv);
+afr_priv_destroy(afr_private_t *priv)
+{
+    int i = 0;
+    int child_count = -1;
+
+    if (!priv)
+        goto out;
+    GF_FREE(priv->last_event);
+
+    child_count = priv->child_count;
+    if (priv->thin_arbiter_count) {
+        child_count++;
+    }
+    if (priv->pending_key) {
+        for (i = 0; i < child_count; i++)
+            GF_FREE(priv->pending_key[i]);
+    }
+
+    GF_FREE(priv->pending_reads);
+    GF_FREE(priv->local);
+    GF_FREE(priv->pending_key);
+    GF_FREE(priv->children);
+    GF_FREE(priv->child_up);
+    GF_FREE(priv->child_latency);
+    LOCK_DESTROY(&priv->lock);
+
+    GF_FREE(priv);
 out:
-        return;
+    return;
 }
 
-int**
-afr_mark_pending_changelog (afr_private_t *priv, unsigned char *pending,
-                            dict_t *xattr, ia_type_t iat)
+int **
+afr_mark_pending_changelog(afr_private_t *priv, unsigned char *pending,
+                           dict_t *xattr, ia_type_t iat)
 {
-       int i = 0;
-       int **changelog = NULL;
-       int idx = -1;
-       int m_idx = 0;
-       int d_idx = 0;
-       int ret = 0;
+    int i = 0;
+    int **changelog = NULL;
+    int idx = -1;
+    int m_idx = 0;
+    int d_idx = 0;
+    int ret = 0;
 
-       m_idx = afr_index_for_transaction_type (AFR_METADATA_TRANSACTION);
-       d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
+    m_idx = afr_index_for_transaction_type(AFR_METADATA_TRANSACTION);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
 
-       idx = afr_index_from_ia_type (iat);
+    idx = afr_index_from_ia_type(iat);
 
-       changelog = afr_matrix_create (priv->child_count, AFR_NUM_CHANGE_LOGS);
-       if (!changelog)
-                goto out;
+    changelog = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!changelog)
+        goto out;
 
-       for (i = 0; i < priv->child_count; i++) {
-               if (!pending[i])
-                       continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!pending[i])
+            continue;
 
-               changelog[i][m_idx] = hton32(1);
-               if (idx != -1)
-                       changelog[i][idx] = hton32(1);
-                /* If the newentry marking is on a newly created directory,
-                 * then mark it with the full-heal indicator.
-                 */
-                if ((IA_ISDIR (iat)) && (priv->esh_granular))
-                        changelog[i][d_idx] = hton32(1);
-       }
-       ret = afr_set_pending_dict (priv, xattr, changelog);
-       if (ret < 0) {
-               afr_matrix_cleanup (changelog, priv->child_count);
-               return NULL;
-       }
+        changelog[i][m_idx] = hton32(1);
+        if (idx != -1)
+            changelog[i][idx] = hton32(1);
+        /* If the newentry marking is on a newly created directory,
+         * then mark it with the full-heal indicator.
+         */
+        if ((IA_ISDIR(iat)) && (priv->esh_granular))
+            changelog[i][d_idx] = hton32(1);
+    }
+    ret = afr_set_pending_dict(priv, xattr, changelog);
+    if (ret < 0) {
+        afr_matrix_cleanup(changelog, priv->child_count);
+        return NULL;
+    }
 out:
-       return changelog;
+    return changelog;
 }
 
 gf_boolean_t
-afr_decide_heal_info (afr_private_t *priv, unsigned char *sources, int source)
+afr_decide_heal_info(afr_private_t *priv, unsigned char *sources, int source)
 {
-        int sources_count = 0;
+    int sources_count = 0;
 
-        if (source < 0)
-                goto out;
+    if (source < 0)
+        goto out;
 
-        sources_count = AFR_COUNT (sources, priv->child_count);
-        if (sources_count == priv->child_count)
-                return _gf_false;
+    sources_count = AFR_COUNT(sources, priv->child_count);
+    if (sources_count == priv->child_count)
+        return _gf_false;
 out:
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-afr_selfheal_locked_metadata_inspect (call_frame_t *frame, xlator_t *this,
-                                      inode_t *inode, gf_boolean_t *msh,
-                                      gf_boolean_t *pending)
-{
-        int ret = -1;
-        unsigned char *locked_on = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        struct afr_reply *locked_replies = NULL;
-
-        afr_private_t *priv = this->private;
-
-        locked_on = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-                                    LLONG_MAX - 1, 0, locked_on);
-        {
-                if (ret == 0) {
-                        /* Not a single lock */
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN;/* all invalid responses */
-                        goto out;
-                }
-                ret = __afr_selfheal_metadata_prepare (frame, this, inode,
-                                                       locked_on, sources,
-                                                       sinks, healed_sinks,
-                                                       undid_pending,
-                                                       locked_replies,
-                                                       pending);
-                *msh = afr_decide_heal_info (priv, sources, ret);
-        }
-        afr_selfheal_uninodelk (frame, this, inode, this->name,
-                                LLONG_MAX - 1, 0, locked_on);
+afr_selfheal_locked_metadata_inspect(call_frame_t *frame, xlator_t *this,
+                                     inode_t *inode, gf_boolean_t *msh,
+                                     gf_boolean_t *pending)
+{
+    int ret = -1;
+    unsigned char *locked_on = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+
+    afr_private_t *priv = this->private;
+
+    locked_on = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                               locked_on);
+    {
+        if (ret == 0) {
+            /* Not a single lock */
+            ret = -afr_final_errno(frame->local, priv);
+            if (ret == 0)
+                ret = -ENOTCONN; /* all invalid responses */
+            goto out;
+        }
+        ret = __afr_selfheal_metadata_prepare(
+            frame, this, inode, locked_on, sources, sinks, healed_sinks,
+            undid_pending, locked_replies, pending);
+        *msh = afr_decide_heal_info(priv, sources, ret);
+    }
+    afr_selfheal_uninodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                           locked_on);
 out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-        return ret;
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
 }
 
 int
-afr_selfheal_locked_data_inspect (call_frame_t *frame, xlator_t *this,
-                                  fd_t *fd, gf_boolean_t *dsh,
-                                  gf_boolean_t *pflag)
-{
-        int ret = -1;
-        unsigned char *data_lock = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        afr_private_t   *priv = NULL;
-        struct afr_reply *locked_replies = NULL;
-        inode_t *inode = fd->inode;
-
-        priv = this->private;
-        data_lock = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-                                    0, 0, data_lock);
-        {
-                if (ret == 0) {
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN; /* all invalid responses */
-                        goto out;
-                }
-                ret = __afr_selfheal_data_prepare (frame, this, inode,
-                                                   data_lock, sources, sinks,
-                                                   healed_sinks, undid_pending,
-                                                   locked_replies, pflag);
-                *dsh = afr_decide_heal_info (priv, sources, ret);
-        }
-        afr_selfheal_uninodelk (frame, this, inode, this->name, 0, 0,
-                                data_lock);
+afr_selfheal_locked_data_inspect(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                                 gf_boolean_t *dsh, gf_boolean_t *pflag)
+{
+    int ret = -1;
+    unsigned char *data_lock = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *locked_replies = NULL;
+    inode_t *inode = fd->inode;
+
+    priv = this->private;
+    data_lock = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, inode, this->name, 0, 0, data_lock);
+    {
+        if (ret == 0) {
+            ret = -afr_final_errno(frame->local, priv);
+            if (ret == 0)
+                ret = -ENOTCONN; /* all invalid responses */
+            goto out;
+        }
+        ret = __afr_selfheal_data_prepare(frame, this, inode, data_lock,
+                                          sources, sinks, healed_sinks,
+                                          undid_pending, locked_replies, pflag);
+        *dsh = afr_decide_heal_info(priv, sources, ret);
+    }
+    afr_selfheal_uninodelk(frame, this, inode, this->name, 0, 0, data_lock);
 out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-        return ret;
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
 }
 
 int
-afr_selfheal_locked_entry_inspect (call_frame_t *frame, xlator_t *this,
-                                   inode_t *inode,
-                                   gf_boolean_t *esh, gf_boolean_t *pflag)
-{
-        int ret = -1;
-        int source = -1;
-        afr_private_t   *priv = NULL;
-        unsigned char *locked_on = NULL;
-        unsigned char *data_lock = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        struct afr_reply *locked_replies = NULL;
-        gf_boolean_t granular_locks = _gf_false;
-
-        priv = this->private;
-	if (strcmp ("granular", priv->locking_scheme) == 0)
-	        granular_locks = _gf_true;
-        locked_on = alloca0 (priv->child_count);
-        data_lock = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        if (!granular_locks) {
-                ret = afr_selfheal_tryentrylk (frame, this, inode,
-                                              priv->sh_domain, NULL, locked_on);
-        }
+afr_selfheal_locked_entry_inspect(call_frame_t *frame, xlator_t *this,
+                                  inode_t *inode, gf_boolean_t *esh,
+                                  gf_boolean_t *pflag)
+{
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    struct afr_reply *locked_replies = NULL;
+    gf_boolean_t granular_locks = _gf_false;
+
+    priv = this->private;
+    if (strcmp("granular", priv->locking_scheme) == 0)
+        granular_locks = _gf_true;
+    locked_on = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    if (!granular_locks) {
+        ret = afr_selfheal_tryentrylk(frame, this, inode, priv->sh_domain, NULL,
+                                      locked_on);
+    }
+    {
+        if (!granular_locks && ret == 0) {
+            ret = -afr_final_errno(frame->local, priv);
+            if (ret == 0)
+                ret = -ENOTCONN; /* all invalid responses */
+            goto out;
+        }
+
+        ret = afr_selfheal_entrylk(frame, this, inode, this->name, NULL,
+                                   data_lock);
         {
-                if (!granular_locks && ret == 0) {
-                        ret = -afr_final_errno (frame->local, priv);
-                        if (ret == 0)
-                                ret = -ENOTCONN;/* all invalid responses */
-                        goto out;
-                }
-
-                ret = afr_selfheal_entrylk (frame, this, inode, this->name,
-                                            NULL, data_lock);
-                {
-                        if (ret == 0) {
-                                ret = -afr_final_errno (frame->local, priv);
-                                if (ret == 0)
-                                        ret = -ENOTCONN;
-                                /* all invalid responses */
-                                goto unlock;
-                        }
-                        ret = __afr_selfheal_entry_prepare (frame, this, inode,
-                                                            data_lock, sources,
-                                                            sinks, healed_sinks,
-                                                            locked_replies,
-                                                            &source, pflag);
-                        if ((ret == 0) && source < 0)
-                                ret = -EIO;
-                        *esh = afr_decide_heal_info (priv, sources, ret);
-                }
-                afr_selfheal_unentrylk (frame, this, inode, this->name, NULL,
-                                        data_lock, NULL);
-        }
+            if (ret == 0) {
+                ret = -afr_final_errno(frame->local, priv);
+                if (ret == 0)
+                    ret = -ENOTCONN;
+                /* all invalid responses */
+                goto unlock;
+            }
+            ret = __afr_selfheal_entry_prepare(frame, this, inode, data_lock,
+                                               sources, sinks, healed_sinks,
+                                               locked_replies, &source, pflag);
+            if ((ret == 0) && source < 0)
+                ret = -EIO;
+            *esh = afr_decide_heal_info(priv, sources, ret);
+        }
+        afr_selfheal_unentrylk(frame, this, inode, this->name, NULL, data_lock,
+                               NULL);
+    }
 unlock:
-        if (!granular_locks)
-                afr_selfheal_unentrylk (frame, this, inode, priv->sh_domain,
-                                        NULL, locked_on, NULL);
+    if (!granular_locks)
+        afr_selfheal_unentrylk(frame, this, inode, priv->sh_domain, NULL,
+                               locked_on, NULL);
 out:
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-        return ret;
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
 }
 
 int
-afr_selfheal_locked_inspect (call_frame_t *frame, xlator_t *this, uuid_t gfid,
-                             inode_t **inode,
-                             gf_boolean_t *entry_selfheal,
-                             gf_boolean_t *data_selfheal,
-                             gf_boolean_t *metadata_selfheal,
-                             gf_boolean_t *pending)
-
-{
-        int ret             = -1;
-        fd_t *fd            = NULL;
-        gf_boolean_t    dsh = _gf_false;
-        gf_boolean_t    msh = _gf_false;
-        gf_boolean_t    esh = _gf_false;
-
-        ret = afr_selfheal_unlocked_inspect (frame, this, gfid, inode,
-                                             &dsh, &msh, &esh);
-        if (ret)
-                goto out;
-
-        /* For every heal type hold locks and check if it indeed needs heal */
-
-
-        /* Heal-info does an open() on the file being examined so that the
-         * current eager-lock holding client, if present, at some point sees
-         * open-fd count being > 1 and releases the eager-lock so that heal-info
-         * doesn't remain blocked forever until IO completes.
-         */
-        if ((*inode)->ia_type == IA_IFREG) {
-                ret = afr_selfheal_data_open (this, *inode, &fd);
-                if (ret < 0) {
-                        gf_msg_debug (this->name, -ret, "%s: Failed to open",
-                                      uuid_utoa ((*inode)->gfid));
-                        goto out;
-                }
+afr_selfheal_locked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,
+                            inode_t **inode, gf_boolean_t *entry_selfheal,
+                            gf_boolean_t *data_selfheal,
+                            gf_boolean_t *metadata_selfheal,
+                            gf_boolean_t *pending)
+
+{
+    int ret = -1;
+    fd_t *fd = NULL;
+    gf_boolean_t dsh = _gf_false;
+    gf_boolean_t msh = _gf_false;
+    gf_boolean_t esh = _gf_false;
+
+    ret = afr_selfheal_unlocked_inspect(frame, this, gfid, inode, &dsh, &msh,
+                                        &esh);
+    if (ret)
+        goto out;
+
+    /* For every heal type hold locks and check if it indeed needs heal */
+
+    /* Heal-info does an open() on the file being examined so that the
+     * current eager-lock holding client, if present, at some point sees
+     * open-fd count being > 1 and releases the eager-lock so that heal-info
+     * doesn't remain blocked forever until IO completes.
+     */
+    if ((*inode)->ia_type == IA_IFREG) {
+        ret = afr_selfheal_data_open(this, *inode, &fd);
+        if (ret < 0) {
+            gf_msg_debug(this->name, -ret, "%s: Failed to open",
+                         uuid_utoa((*inode)->gfid));
+            goto out;
         }
+    }
 
-        if (msh) {
-                ret = afr_selfheal_locked_metadata_inspect (frame, this,
-                                                            *inode, &msh,
-                                                            pending);
-                if (ret == -EIO)
-                        goto out;
-        }
+    if (msh) {
+        ret = afr_selfheal_locked_metadata_inspect(frame, this, *inode, &msh,
+                                                   pending);
+        if (ret == -EIO)
+            goto out;
+    }
 
-        if (dsh) {
-                ret = afr_selfheal_locked_data_inspect (frame, this, fd,
-                                                        &dsh, pending);
-                if (ret == -EIO || (ret == -EAGAIN))
-                        goto out;
-        }
+    if (dsh) {
+        ret = afr_selfheal_locked_data_inspect(frame, this, fd, &dsh, pending);
+        if (ret == -EIO || (ret == -EAGAIN))
+            goto out;
+    }
 
-        if (esh) {
-                ret = afr_selfheal_locked_entry_inspect (frame, this, *inode,
-                                                         &esh, pending);
-        }
+    if (esh) {
+        ret = afr_selfheal_locked_entry_inspect(frame, this, *inode, &esh,
+                                                pending);
+    }
 
 out:
-        *data_selfheal = dsh;
-        *entry_selfheal = esh;
-        *metadata_selfheal = msh;
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    *data_selfheal = dsh;
+    *entry_selfheal = esh;
+    *metadata_selfheal = msh;
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 
-dict_t*
-afr_set_heal_info (char *status)
+dict_t *
+afr_set_heal_info(char *status)
 {
-        dict_t *dict = NULL;
-        int    ret   = -1;
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    dict_t *dict = NULL;
+    int ret = -1;
 
-        ret = dict_set_str (dict, "heal-info", status);
-        if (ret)
-                gf_msg ("", GF_LOG_WARNING, -ret,
-                        AFR_MSG_DICT_SET_FAILED,
-                        "Failed to set heal-info key to "
-                        "%s", status);
+    dict = dict_new();
+    if (!dict) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = dict_set_str(dict, "heal-info", status);
+    if (ret)
+        gf_msg("", GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Failed to set heal-info key to "
+               "%s",
+               status);
 out:
-        return dict;
+    return dict;
 }
 
 int
-afr_get_heal_info (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        gf_boolean_t    data_selfheal     = _gf_false;
-        gf_boolean_t    metadata_selfheal = _gf_false;
-        gf_boolean_t    entry_selfheal    = _gf_false;
-        gf_boolean_t    pending           = _gf_false;
-        dict_t         *dict              = NULL;
-        int             ret               = -1;
-        int             op_errno          = 0;
-        inode_t        *inode             = NULL;
-        char           *substr            = NULL;
-        char           *status            = NULL;
-
-        ret = afr_selfheal_locked_inspect (frame, this, loc->gfid, &inode,
-                                           &entry_selfheal,
-                                           &data_selfheal, &metadata_selfheal,
-                                           &pending);
-
-        if (ret == -ENOMEM) {
-                op_errno = -ret;
-                ret = -1;
+afr_get_heal_info(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    gf_boolean_t data_selfheal = _gf_false;
+    gf_boolean_t metadata_selfheal = _gf_false;
+    gf_boolean_t entry_selfheal = _gf_false;
+    gf_boolean_t pending = _gf_false;
+    dict_t *dict = NULL;
+    int ret = -1;
+    int op_errno = 0;
+    inode_t *inode = NULL;
+    char *substr = NULL;
+    char *status = NULL;
+
+    ret = afr_selfheal_locked_inspect(frame, this, loc->gfid, &inode,
+                                      &entry_selfheal, &data_selfheal,
+                                      &metadata_selfheal, &pending);
+
+    if (ret == -ENOMEM) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    if (pending) {
+        gf_asprintf(&substr, "-pending");
+        if (!substr)
+            goto out;
+    }
+
+    if (ret == -EIO) {
+        ret = gf_asprintf(&status, "split-brain%s", substr ? substr : "");
+        if (ret < 0)
+            goto out;
+        dict = afr_set_heal_info(status);
+    } else if (ret == -EAGAIN) {
+        ret = gf_asprintf(&status, "possibly-healing%s", substr ? substr : "");
+        if (ret < 0)
+            goto out;
+        dict = afr_set_heal_info(status);
+    } else if (ret >= 0) {
+        /* value of ret = source index
+         * so ret >= 0 and at least one of the 3 booleans set to
+         * true means a source is identified; heal is required.
+         */
+        if (!data_selfheal && !entry_selfheal && !metadata_selfheal) {
+            dict = afr_set_heal_info("no-heal");
+        } else {
+            ret = gf_asprintf(&status, "heal%s", substr ? substr : "");
+            if (ret < 0)
                 goto out;
+            dict = afr_set_heal_info(status);
+        }
+    } else if (ret < 0) {
+        /* Apart from above checked -ve ret values, there are
+         * other possible ret values like ENOTCONN
+         * (returned when number of valid replies received are
+         * less than 2)
+         * in which case heal is required when one of the
+         * selfheal booleans is set.
+         */
+        if (data_selfheal || entry_selfheal || metadata_selfheal) {
+            ret = gf_asprintf(&status, "heal%s", substr ? substr : "");
+            if (ret < 0)
+                goto out;
+            dict = afr_set_heal_info(status);
         }
-
-        if (pending) {
-                gf_asprintf (&substr, "-pending");
-                if (!substr)
-                        goto out;
-        }
-
-        if (ret == -EIO) {
-                ret = gf_asprintf (&status, "split-brain%s",
-                                   substr? substr : "");
-                if (ret < 0)
-                        goto out;
-                dict = afr_set_heal_info (status);
-        } else if (ret == -EAGAIN) {
-                ret = gf_asprintf (&status, "possibly-healing%s",
-                                   substr? substr : "");
-                if (ret < 0)
-                        goto out;
-                dict = afr_set_heal_info (status);
-        } else if (ret >= 0) {
-                /* value of ret = source index
-                 * so ret >= 0 and at least one of the 3 booleans set to
-                 * true means a source is identified; heal is required.
-                 */
-                if (!data_selfheal && !entry_selfheal &&
-                    !metadata_selfheal) {
-                        dict = afr_set_heal_info ("no-heal");
-                } else {
-                        ret = gf_asprintf (&status, "heal%s",
-                                           substr? substr : "");
-                        if (ret < 0)
-                                goto out;
-                        dict = afr_set_heal_info (status);
-                }
-        } else if (ret < 0) {
-                /* Apart from above checked -ve ret values, there are
-                 * other possible ret values like ENOTCONN
-                 * (returned when number of valid replies received are
-                 * less than 2)
-                 * in which case heal is required when one of the
-                 * selfheal booleans is set.
-                 */
-                if (data_selfheal || entry_selfheal ||
-                    metadata_selfheal) {
-                        ret = gf_asprintf (&status, "heal%s",
-                                           substr? substr : "");
-                        if (ret < 0)
-                                goto out;
-                        dict = afr_set_heal_info (status);
-                }
-        }
-        ret = 0;
+    }
+    ret = 0;
 
 out:
-        AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        if (dict)
-               dict_unref (dict);
-        if (inode)
-                inode_unref (inode);
-        GF_FREE (substr);
-        return ret;
+    AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    if (dict)
+        dict_unref(dict);
+    if (inode)
+        inode_unref(inode);
+    GF_FREE(substr);
+    return ret;
 }
 
 int
-_afr_is_split_brain (call_frame_t *frame, xlator_t *this,
-                         struct afr_reply *replies,
-                         afr_transaction_type type,
-                         gf_boolean_t *spb)
-{
-        afr_private_t    *priv              = NULL;
-        uint64_t         *witness           = NULL;
-        unsigned char    *sources           = NULL;
-        unsigned char    *sinks             = NULL;
-        int               sources_count     = 0;
-        int               ret               = 0;
-
-        priv = this->private;
-
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        witness = alloca0(priv->child_count * sizeof (*witness));
-
-        ret = afr_selfheal_find_direction (frame, this, replies,
-					   type, priv->child_up, sources,
-                                           sinks, witness, NULL);
-        if (ret)
-                return ret;
+_afr_is_split_brain(call_frame_t *frame, xlator_t *this,
+                    struct afr_reply *replies, afr_transaction_type type,
+                    gf_boolean_t *spb)
+{
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    int sources_count = 0;
+    int ret = 0;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    witness = alloca0(priv->child_count * sizeof(*witness));
+
+    ret = afr_selfheal_find_direction(frame, this, replies, type,
+                                      priv->child_up, sources, sinks, witness,
+                                      NULL);
+    if (ret)
+        return ret;
 
-        sources_count = AFR_COUNT (sources, priv->child_count);
-        if (!sources_count)
-                *spb = _gf_true;
+    sources_count = AFR_COUNT(sources, priv->child_count);
+    if (!sources_count)
+        *spb = _gf_true;
 
-        return ret;
+    return ret;
 }
 
 int
-afr_is_split_brain (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                    uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb)
+afr_is_split_brain(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                   uuid_t gfid, gf_boolean_t *d_spb, gf_boolean_t *m_spb)
 {
-        int    ret                          = -1;
-        afr_private_t    *priv              = NULL;
-        struct afr_reply *replies           = NULL;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        replies = alloca0 (sizeof (*replies) * priv->child_count);
+    replies = alloca0(sizeof(*replies) * priv->child_count);
 
-        ret = afr_selfheal_unlocked_discover (frame, inode, gfid, replies);
-        if (ret)
-                goto out;
+    ret = afr_selfheal_unlocked_discover(frame, inode, gfid, replies);
+    if (ret)
+        goto out;
 
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                ret = -EAGAIN;
-                goto out;
-        }
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        ret = -EAGAIN;
+        goto out;
+    }
 
-        ret = _afr_is_split_brain (frame, this, replies,
-                                    AFR_DATA_TRANSACTION, d_spb);
-        if (ret)
-                goto out;
+    ret = _afr_is_split_brain(frame, this, replies, AFR_DATA_TRANSACTION,
+                              d_spb);
+    if (ret)
+        goto out;
 
-        ret = _afr_is_split_brain (frame, this, replies,
-                                    AFR_METADATA_TRANSACTION, m_spb);
+    ret = _afr_is_split_brain(frame, this, replies, AFR_METADATA_TRANSACTION,
+                              m_spb);
 out:
-        if (replies) {
-                afr_replies_wipe (replies, priv->child_count);
-                replies = NULL;
-        }
-        return ret;
+    if (replies) {
+        afr_replies_wipe(replies, priv->child_count);
+        replies = NULL;
+    }
+    return ret;
 }
 
 int
-afr_get_split_brain_status_cbk (int ret, call_frame_t *frame, void *opaque)
+afr_get_split_brain_status_cbk(int ret, call_frame_t *frame, void *opaque)
 {
-        GF_FREE (opaque);
-        return 0;
+    GF_FREE(opaque);
+    return 0;
 }
 
 int
-afr_get_split_brain_status (void *opaque)
-{
-        gf_boolean_t      d_spb             = _gf_false;
-        gf_boolean_t      m_spb             = _gf_false;
-        int               ret               = -1;
-        int               op_errno          = 0;
-        int               i                 = 0;
-        char             *choices           = NULL;
-        char             *status            = NULL;
-        dict_t           *dict              = NULL;
-        inode_t          *inode             = NULL;
-        afr_private_t    *priv              = NULL;
-        xlator_t         **children         = NULL;
-        call_frame_t     *frame             = NULL;
-        xlator_t         *this              = NULL;
-        loc_t            *loc               = NULL;
-        afr_spb_status_t *data              = NULL;
-
-        data     = opaque;
-        frame    = data->frame;
-        this     = frame->this;
-        loc      = data->loc;
-        priv     = this->private;
-        children = priv->children;
-
-        inode = afr_inode_find (this, loc->gfid);
-        if (!inode)
-                goto out;
-
-        dict = dict_new ();
-        if (!dict) {
-                op_errno = ENOMEM;
-                ret = -1;
-                goto out;
+afr_get_split_brain_status(void *opaque)
+{
+    gf_boolean_t d_spb = _gf_false;
+    gf_boolean_t m_spb = _gf_false;
+    int ret = -1;
+    int op_errno = 0;
+    int i = 0;
+    char *choices = NULL;
+    char *status = NULL;
+    dict_t *dict = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    loc_t *loc = NULL;
+    afr_spb_status_t *data = NULL;
+
+    data = opaque;
+    frame = data->frame;
+    this = frame->this;
+    loc = data->loc;
+    priv = this->private;
+    children = priv->children;
+
+    inode = afr_inode_find(this, loc->gfid);
+    if (!inode)
+        goto out;
+
+    dict = dict_new();
+    if (!dict) {
+        op_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    /* Calculation for string length :
+     * (child_count X length of child-name) + SLEN ("    Choices :")
+     * child-name consists of :
+     * a) 251 = max characters for volname according to GD_VOLUME_NAME_MAX
+     * b) strlen ("-client-00,") assuming 16 replicas
+     */
+    choices = alloca0(priv->child_count * (256 + SLEN("-client-00,")) +
+                      SLEN("    Choices:"));
+
+    ret = afr_is_split_brain(frame, this, inode, loc->gfid, &d_spb, &m_spb);
+    if (ret) {
+        op_errno = -ret;
+        if (ret == -EAGAIN) {
+            ret = dict_set_str(dict, GF_AFR_SBRAIN_STATUS,
+                               SBRAIN_HEAL_NO_GO_MSG);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_WARNING, -ret,
+                       AFR_MSG_DICT_SET_FAILED,
+                       "Failed to set GF_AFR_SBRAIN_STATUS in dict");
+            }
         }
+        ret = -1;
+        goto out;
+    }
 
-        /* Calculation for string length :
-        * (child_count X length of child-name) + SLEN ("    Choices :")
-        * child-name consists of :
-        * a) 251 = max characters for volname according to GD_VOLUME_NAME_MAX
-        * b) strlen ("-client-00,") assuming 16 replicas
-        */
-        choices = alloca0 (priv->child_count * (256 + SLEN ("-client-00,")) +
-                           SLEN ("    Choices:"));
-
-        ret = afr_is_split_brain (frame, this, inode, loc->gfid, &d_spb,
-                                  &m_spb);
-        if (ret) {
-                op_errno = -ret;
-                if (ret == -EAGAIN) {
-                        ret = dict_set_str (dict, GF_AFR_SBRAIN_STATUS,
-                                            SBRAIN_HEAL_NO_GO_MSG);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_WARNING,
-                                        -ret, AFR_MSG_DICT_SET_FAILED,
-                                        "Failed to set GF_AFR_SBRAIN_STATUS in dict");
-                        }
-                }
-                ret = -1;
-                goto out;
+    if (d_spb || m_spb) {
+        sprintf(choices, "    Choices:");
+        for (i = 0; i < priv->child_count; i++) {
+            strcat(choices, children[i]->name);
+            strcat(choices, ",");
         }
+        choices[strlen(choices) - 1] = '\0';
 
-        if (d_spb || m_spb) {
-                sprintf (choices, "    Choices:");
-                for (i = 0; i < priv->child_count; i++) {
-                        strcat (choices, children[i]->name);
-                        strcat (choices, ",");
-                }
-                choices[strlen (choices) - 1] = '\0';
-
-                ret = gf_asprintf (&status, "data-split-brain:%s    "
-                                    "metadata-split-brain:%s%s",
-                                    (d_spb) ? "yes" : "no",
-                                    (m_spb) ? "yes" : "no", choices);
+        ret = gf_asprintf(&status,
+                          "data-split-brain:%s    "
+                          "metadata-split-brain:%s%s",
+                          (d_spb) ? "yes" : "no", (m_spb) ? "yes" : "no",
+                          choices);
 
-                if (-1 == ret) {
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                ret = dict_set_dynstr (dict, GF_AFR_SBRAIN_STATUS, status);
-                if (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        } else {
-                ret = dict_set_str (dict, GF_AFR_SBRAIN_STATUS,
-                                    "The file is not under data or"
-                                    " metadata split-brain");
-                if (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
+        if (-1 == ret) {
+            op_errno = ENOMEM;
+            goto out;
         }
+        ret = dict_set_dynstr(dict, GF_AFR_SBRAIN_STATUS, status);
+        if (ret) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    } else {
+        ret = dict_set_str(dict, GF_AFR_SBRAIN_STATUS,
+                           "The file is not under data or"
+                           " metadata split-brain");
+        if (ret) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        if (dict)
-               dict_unref (dict);
-        if (inode)
-                inode_unref (inode);
-        return ret;
+    AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    if (dict)
+        dict_unref(dict);
+    if (inode)
+        inode_unref(inode);
+    return ret;
 }
 
 int32_t
 afr_heal_splitbrain_file(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-        int             ret               = 0;
-        int             op_errno          = 0;
-        dict_t         *dict              = NULL;
-        afr_local_t    *local             = NULL;
+    int ret = 0;
+    int op_errno = 0;
+    dict_t *dict = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        dict = dict_new ();
-        if (!dict) {
-                op_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    local = frame->local;
+    dict = dict_new();
+    if (!dict) {
+        op_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
 
-        ret = afr_selfheal_do (frame, this, loc->gfid);
+    ret = afr_selfheal_do(frame, this, loc->gfid);
 
-        if (ret == 1 || ret == 2) {
-                ret = dict_set_str (dict, "sh-fail-msg",
-                                    "File not in split-brain");
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Failed to set sh-fail-msg in dict");
-                ret = 0;
-                goto out;
-        } else {
-                if (local->xdata_rsp) {
-                        /* 'sh-fail-msg' has been set in the dict during self-heal.*/
-                        dict_copy (local->xdata_rsp, dict);
-                        ret = 0;
-                } else if (ret < 0) {
-                        op_errno = -ret;
-                        ret = -1;
-                }
+    if (ret == 1 || ret == 2) {
+        ret = dict_set_str(dict, "sh-fail-msg", "File not in split-brain");
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Failed to set sh-fail-msg in dict");
+        ret = 0;
+        goto out;
+    } else {
+        if (local->xdata_rsp) {
+            /* 'sh-fail-msg' has been set in the dict during self-heal.*/
+            dict_copy(local->xdata_rsp, dict);
+            ret = 0;
+        } else if (ret < 0) {
+            op_errno = -ret;
+            ret = -1;
         }
+    }
 
 out:
-        if (local->op == GF_FOP_GETXATTR)
-                AFR_STACK_UNWIND (getxattr, frame, ret, op_errno, dict, NULL);
-        else if (local->op == GF_FOP_SETXATTR)
-                AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        if (dict)
-                dict_unref(dict);
-        return ret;
+    if (local->op == GF_FOP_GETXATTR)
+        AFR_STACK_UNWIND(getxattr, frame, ret, op_errno, dict, NULL);
+    else if (local->op == GF_FOP_SETXATTR)
+        AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    if (dict)
+        dict_unref(dict);
+    return ret;
 }
 
 int
-afr_get_child_index_from_name (xlator_t *this, char *name)
+afr_get_child_index_from_name(xlator_t *this, char *name)
 {
-        afr_private_t *priv  = this->private;
-        int            index = -1;
+    afr_private_t *priv = this->private;
+    int index = -1;
 
-        for (index = 0; index < priv->child_count; index++) {
-                if (!strcmp (priv->children[index]->name, name))
-                        goto out;
-        }
-        index = -1;
+    for (index = 0; index < priv->child_count; index++) {
+        if (!strcmp(priv->children[index]->name, name))
+            goto out;
+    }
+    index = -1;
 out:
-        return index;
+    return index;
 }
 
 void
-afr_priv_need_heal_set (afr_private_t *priv, gf_boolean_t need_heal)
+afr_priv_need_heal_set(afr_private_t *priv, gf_boolean_t need_heal)
 {
-        LOCK (&priv->lock);
-        {
-                priv->need_heal = need_heal;
-        }
-        UNLOCK (&priv->lock);
+    LOCK(&priv->lock);
+    {
+        priv->need_heal = need_heal;
+    }
+    UNLOCK(&priv->lock);
 }
 
 void
-afr_set_need_heal (xlator_t *this, afr_local_t *local)
+afr_set_need_heal(xlator_t *this, afr_local_t *local)
 {
-        int             i         = 0;
-        afr_private_t  *priv      = this->private;
-        gf_boolean_t    need_heal = _gf_false;
+    int i = 0;
+    afr_private_t *priv = this->private;
+    gf_boolean_t need_heal = _gf_false;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->replies[i].valid && local->replies[i].need_heal) {
-                        need_heal = _gf_true;
-                        break;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].need_heal) {
+            need_heal = _gf_true;
+            break;
         }
-        afr_priv_need_heal_set (priv, need_heal);
-        return;
+    }
+    afr_priv_need_heal_set(priv, need_heal);
+    return;
 }
 
 gf_boolean_t
-afr_get_need_heal (xlator_t *this)
+afr_get_need_heal(xlator_t *this)
 {
-        afr_private_t  *priv      = this->private;
-        gf_boolean_t    need_heal = _gf_true;
+    afr_private_t *priv = this->private;
+    gf_boolean_t need_heal = _gf_true;
 
-        LOCK (&priv->lock);
-        {
-                need_heal = priv->need_heal;
-        }
-        UNLOCK (&priv->lock);
-        return need_heal;
+    LOCK(&priv->lock);
+    {
+        need_heal = priv->need_heal;
+    }
+    UNLOCK(&priv->lock);
+    return need_heal;
 }
 
 int
-afr_get_msg_id (char *op_type)
+afr_get_msg_id(char *op_type)
 {
-
-        if (!strcmp (op_type, GF_AFR_REPLACE_BRICK))
-                return AFR_MSG_REPLACE_BRICK_STATUS;
-        else if (!strcmp (op_type, GF_AFR_ADD_BRICK))
-                return AFR_MSG_ADD_BRICK_STATUS;
-        return -1;
+    if (!strcmp(op_type, GF_AFR_REPLACE_BRICK))
+        return AFR_MSG_REPLACE_BRICK_STATUS;
+    else if (!strcmp(op_type, GF_AFR_ADD_BRICK))
+        return AFR_MSG_ADD_BRICK_STATUS;
+    return -1;
 }
 
 int
-afr_fav_child_reset_sink_xattrs_cbk (int ret, call_frame_t *heal_frame,
-                                     void *opaque)
+afr_fav_child_reset_sink_xattrs_cbk(int ret, call_frame_t *heal_frame,
+                                    void *opaque)
 {
+    call_frame_t *txn_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_local_t *heal_local = NULL;
+    xlator_t *this = NULL;
 
-        call_frame_t *txn_frame = NULL;
-        afr_local_t *local = NULL;
-        afr_local_t *heal_local = NULL;
-        xlator_t *this = NULL;
-
-        heal_local = heal_frame->local;
-        txn_frame = heal_local->heal_frame;
-        local = txn_frame->local;
-        this = txn_frame->this;
+    heal_local = heal_frame->local;
+    txn_frame = heal_local->heal_frame;
+    local = txn_frame->local;
+    this = txn_frame->this;
 
-        /* Refresh the inode agan and proceed with the transaction.*/
-        afr_inode_refresh (txn_frame, this, local->inode, NULL,
-                           local->refreshfn);
+    /* Refresh the inode agan and proceed with the transaction.*/
+    afr_inode_refresh(txn_frame, this, local->inode, NULL, local->refreshfn);
 
-        AFR_STACK_DESTROY (heal_frame);
+    AFR_STACK_DESTROY(heal_frame);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_fav_child_reset_sink_xattrs (void *opaque)
-{
-        call_frame_t *heal_frame = NULL;
-        call_frame_t *txn_frame = NULL;
-        xlator_t *this = NULL;
-        gf_boolean_t d_spb = _gf_false;
-        gf_boolean_t m_spb = _gf_false;
-        afr_local_t *heal_local = NULL;
-        afr_local_t *txn_local = NULL;
-        afr_private_t *priv = NULL;
-        inode_t *inode  = NULL;
-        unsigned char *locked_on = NULL;
-        unsigned char *sources = NULL;
-        unsigned char *sinks = NULL;
-        unsigned char *healed_sinks = NULL;
-        unsigned char *undid_pending = NULL;
-        struct afr_reply *locked_replies = NULL;
-        int ret = 0;
-
-        heal_frame = (call_frame_t *) opaque;
-        heal_local = heal_frame->local;
-        txn_frame = heal_local->heal_frame;
-        txn_local = txn_frame->local;
-        this = txn_frame->this;
-        inode = txn_local->inode;
-        priv = this->private;
-        locked_on = alloca0 (priv->child_count);
-        sources = alloca0 (priv->child_count);
-        sinks = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-        locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-        ret = _afr_is_split_brain (txn_frame, this, txn_local->replies,
-                                   AFR_DATA_TRANSACTION, &d_spb);
-
-        ret = _afr_is_split_brain (txn_frame, this, txn_local->replies,
-                                   AFR_METADATA_TRANSACTION, &m_spb);
-
-        /* Take appropriate locks and reset sink xattrs. */
-        if (d_spb) {
-                ret = afr_selfheal_inodelk (heal_frame, this, inode, this->name,
-                                            0, 0, locked_on);
-                {
-                        if (ret < AFR_SH_MIN_PARTICIPANTS)
-                                goto data_unlock;
-                        ret = __afr_selfheal_data_prepare (heal_frame, this,
-                                                           inode, locked_on,
-                                                           sources, sinks,
-                                                           healed_sinks,
-                                                           undid_pending,
-                                                           locked_replies,
-                                                           NULL);
-                }
-data_unlock:
-                afr_selfheal_uninodelk (heal_frame, this, inode, this->name,
-                                        0, 0, locked_on);
-        }
-
-        if (m_spb) {
-                memset (locked_on, 0, sizeof (*locked_on) * priv->child_count);
-                memset (undid_pending, 0,
-                        sizeof (*undid_pending) * priv->child_count);
-                ret = afr_selfheal_inodelk (heal_frame, this, inode, this->name,
-                                            LLONG_MAX-1, 0, locked_on);
-                {
-                        if (ret < AFR_SH_MIN_PARTICIPANTS)
-                                goto mdata_unlock;
-                        ret = __afr_selfheal_metadata_prepare (heal_frame, this,
-                                                               inode, locked_on,
-                                                               sources, sinks,
-                                                               healed_sinks,
-                                                               undid_pending,
-                                                               locked_replies,
-                                                               NULL);
-
-                }
-mdata_unlock:
-                afr_selfheal_uninodelk (heal_frame, this, inode, this->name,
-                                        LLONG_MAX-1, 0, locked_on);
+afr_fav_child_reset_sink_xattrs(void *opaque)
+{
+    call_frame_t *heal_frame = NULL;
+    call_frame_t *txn_frame = NULL;
+    xlator_t *this = NULL;
+    gf_boolean_t d_spb = _gf_false;
+    gf_boolean_t m_spb = _gf_false;
+    afr_local_t *heal_local = NULL;
+    afr_local_t *txn_local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    unsigned char *locked_on = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    int ret = 0;
+
+    heal_frame = (call_frame_t *)opaque;
+    heal_local = heal_frame->local;
+    txn_frame = heal_local->heal_frame;
+    txn_local = txn_frame->local;
+    this = txn_frame->this;
+    inode = txn_local->inode;
+    priv = this->private;
+    locked_on = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = _afr_is_split_brain(txn_frame, this, txn_local->replies,
+                              AFR_DATA_TRANSACTION, &d_spb);
+
+    ret = _afr_is_split_brain(txn_frame, this, txn_local->replies,
+                              AFR_METADATA_TRANSACTION, &m_spb);
+
+    /* Take appropriate locks and reset sink xattrs. */
+    if (d_spb) {
+        ret = afr_selfheal_inodelk(heal_frame, this, inode, this->name, 0, 0,
+                                   locked_on);
+        {
+            if (ret < AFR_SH_MIN_PARTICIPANTS)
+                goto data_unlock;
+            ret = __afr_selfheal_data_prepare(
+                heal_frame, this, inode, locked_on, sources, sinks,
+                healed_sinks, undid_pending, locked_replies, NULL);
+        }
+    data_unlock:
+        afr_selfheal_uninodelk(heal_frame, this, inode, this->name, 0, 0,
+                               locked_on);
+    }
+
+    if (m_spb) {
+        memset(locked_on, 0, sizeof(*locked_on) * priv->child_count);
+        memset(undid_pending, 0, sizeof(*undid_pending) * priv->child_count);
+        ret = afr_selfheal_inodelk(heal_frame, this, inode, this->name,
+                                   LLONG_MAX - 1, 0, locked_on);
+        {
+            if (ret < AFR_SH_MIN_PARTICIPANTS)
+                goto mdata_unlock;
+            ret = __afr_selfheal_metadata_prepare(
+                heal_frame, this, inode, locked_on, sources, sinks,
+                healed_sinks, undid_pending, locked_replies, NULL);
         }
+    mdata_unlock:
+        afr_selfheal_uninodelk(heal_frame, this, inode, this->name,
+                               LLONG_MAX - 1, 0, locked_on);
+    }
 
-        return ret;
-
+    return ret;
 }
 
 /*
  * Concatenates the xattrs in local->replies separated by a delimiter.
  */
 int
-afr_serialize_xattrs_with_delimiter (call_frame_t *frame, xlator_t *this,
-                                     char *buf, const char *default_str,
-                                     int32_t *serz_len, char delimiter)
-{
-        afr_private_t *priv      = NULL;
-        afr_local_t   *local     = NULL;
-        char          *xattr     = NULL;
-        int            i         = 0;
-        int            len       = 0;
-        size_t         str_len   = 0;
-        int            ret       = -1;
-
-        priv = this->private;
-        local = frame->local;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid || local->replies[i].op_ret) {
-                        str_len = strlen (default_str);
-                        buf = strncat (buf, default_str, str_len);
-                        len += str_len;
-                        buf[len++] = delimiter;
-                        buf[len] = '\0';
-                } else {
-                        ret = dict_get_str (local->replies[i].xattr,
-                                            local->cont.getxattr.name, &xattr);
-                        if (ret) {
-                                gf_msg ("TEST", GF_LOG_ERROR, -ret,
-                                        AFR_MSG_DICT_GET_FAILED,
-                                        "Failed to get the node_uuid of brick "
-                                        "%d", i);
-                                goto out;
-                        }
-                        str_len = strlen (xattr);
-                        buf = strncat (buf, xattr, str_len);
-                        len += str_len;
-                        buf[len++] = delimiter;
-                        buf[len] = '\0';
-                }
-        }
-        buf[--len] = '\0'; /*remove the last delimiter*/
-        if (serz_len)
-                *serz_len = ++len;
-        ret = 0;
+afr_serialize_xattrs_with_delimiter(call_frame_t *frame, xlator_t *this,
+                                    char *buf, const char *default_str,
+                                    int32_t *serz_len, char delimiter)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    char *xattr = NULL;
+    int i = 0;
+    int len = 0;
+    size_t str_len = 0;
+    int ret = -1;
+
+    priv = this->private;
+    local = frame->local;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid || local->replies[i].op_ret) {
+            str_len = strlen(default_str);
+            buf = strncat(buf, default_str, str_len);
+            len += str_len;
+            buf[len++] = delimiter;
+            buf[len] = '\0';
+        } else {
+            ret = dict_get_str(local->replies[i].xattr,
+                               local->cont.getxattr.name, &xattr);
+            if (ret) {
+                gf_msg("TEST", GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                       "Failed to get the node_uuid of brick "
+                       "%d",
+                       i);
+                goto out;
+            }
+            str_len = strlen(xattr);
+            buf = strncat(buf, xattr, str_len);
+            len += str_len;
+            buf[len++] = delimiter;
+            buf[len] = '\0';
+        }
+    }
+    buf[--len] = '\0'; /*remove the last delimiter*/
+    if (serz_len)
+        *serz_len = ++len;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 uint64_t
-afr_write_subvol_get (call_frame_t *frame, xlator_t *this)
+afr_write_subvol_get(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        uint64_t write_subvol = 0;
+    afr_local_t *local = NULL;
+    uint64_t write_subvol = 0;
 
-        local = frame->local;
-        LOCK(&local->inode->lock);
-                write_subvol = local->inode_ctx->write_subvol;
-        UNLOCK (&local->inode->lock);
+    local = frame->local;
+    LOCK(&local->inode->lock);
+    write_subvol = local->inode_ctx->write_subvol;
+    UNLOCK(&local->inode->lock);
 
-        return write_subvol;
+    return write_subvol;
 }
 
 int
-afr_write_subvol_set (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t      *local = NULL;
-        afr_private_t    *priv  = NULL;
-        unsigned char    *data_accused = NULL;
-        unsigned char    *metadata_accused = NULL;
-        unsigned char    *data_readable = NULL;
-        unsigned char    *metadata_readable = NULL;
-        uint16_t          datamap = 0;
-        uint16_t          metadatamap = 0;
-        uint64_t          val   = 0;
-        int               event = 0;
-        int               i     = 0;
-
-        local = frame->local;
-        priv = this->private;
-        data_accused = alloca0 (priv->child_count);
-        metadata_accused = alloca0 (priv->child_count);
-        data_readable = alloca0 (priv->child_count);
-        metadata_readable = alloca0 (priv->child_count);
-        event = local->event_generation;
-
-        afr_readables_fill (frame, this, local->inode, data_accused,
-                            metadata_accused, data_readable, metadata_readable,
-                            NULL);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (data_readable[i])
-                        datamap |= (1 << i);
-                if (metadata_readable[i])
-                        metadatamap |= (1 << i);
-        }
-
-        val = ((uint64_t) metadatamap) |
-              (((uint64_t) datamap) << 16) |
-              (((uint64_t) event) << 32);
-
-        LOCK(&local->inode->lock);
-        {
-                if (local->inode_ctx->write_subvol == 0 &&
-                    local->transaction.type == AFR_DATA_TRANSACTION) {
-                        local->inode_ctx->write_subvol = val;
-                }
-        }
-        UNLOCK (&local->inode->lock);
-
-        return 0;
+afr_write_subvol_set(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *data_accused = NULL;
+    unsigned char *metadata_accused = NULL;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    uint16_t datamap = 0;
+    uint16_t metadatamap = 0;
+    uint64_t val = 0;
+    int event = 0;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+    data_accused = alloca0(priv->child_count);
+    metadata_accused = alloca0(priv->child_count);
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+    event = local->event_generation;
+
+    afr_readables_fill(frame, this, local->inode, data_accused,
+                       metadata_accused, data_readable, metadata_readable,
+                       NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (data_readable[i])
+            datamap |= (1 << i);
+        if (metadata_readable[i])
+            metadatamap |= (1 << i);
+    }
+
+    val = ((uint64_t)metadatamap) | (((uint64_t)datamap) << 16) |
+          (((uint64_t)event) << 32);
+
+    LOCK(&local->inode->lock);
+    {
+        if (local->inode_ctx->write_subvol == 0 &&
+            local->transaction.type == AFR_DATA_TRANSACTION) {
+            local->inode_ctx->write_subvol = val;
+        }
+    }
+    UNLOCK(&local->inode->lock);
+
+    return 0;
 }
 
 int
-afr_write_subvol_reset (call_frame_t *frame, xlator_t *this)
+afr_write_subvol_reset(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t      *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        LOCK(&local->inode->lock);
-        {
-                GF_ASSERT (local->inode_ctx->lock_count > 0);
-                local->inode_ctx->lock_count--;
+    local = frame->local;
+    LOCK(&local->inode->lock);
+    {
+        GF_ASSERT(local->inode_ctx->lock_count > 0);
+        local->inode_ctx->lock_count--;
 
-                if (!local->inode_ctx->lock_count)
-                        local->inode_ctx->write_subvol = 0;
-        }
-        UNLOCK(&local->inode->lock);
+        if (!local->inode_ctx->lock_count)
+            local->inode_ctx->write_subvol = 0;
+    }
+    UNLOCK(&local->inode->lock);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_set_inode_local (xlator_t *this, afr_local_t *local, inode_t *inode)
+afr_set_inode_local(xlator_t *this, afr_local_t *local, inode_t *inode)
 {
-        int ret = 0;
+    int ret = 0;
 
-        local->inode = inode_ref (inode);
-        LOCK(&local->inode->lock);
-        {
-                ret = __afr_inode_ctx_get (this, local->inode,
-                                           &local->inode_ctx);
-        }
-        UNLOCK (&local->inode->lock);
-        if (ret < 0) {
-                gf_msg_callingfn (this->name, GF_LOG_ERROR, ENOMEM,
-                                  AFR_MSG_INODE_CTX_GET_FAILED,
-                                  "Error getting inode ctx %s",
-                                  uuid_utoa (local->inode->gfid));
-        }
-        return ret;
+    local->inode = inode_ref(inode);
+    LOCK(&local->inode->lock);
+    {
+        ret = __afr_inode_ctx_get(this, local->inode, &local->inode_ctx);
+    }
+    UNLOCK(&local->inode->lock);
+    if (ret < 0) {
+        gf_msg_callingfn(
+            this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_INODE_CTX_GET_FAILED,
+            "Error getting inode ctx %s", uuid_utoa(local->inode->gfid));
+    }
+    return ret;
 }
 
 gf_boolean_t
-afr_ta_is_fop_called_from_synctask (xlator_t *this)
+afr_ta_is_fop_called_from_synctask(xlator_t *this)
 {
-        struct synctask *task      = NULL;
-        gf_lkowner_t    tmp_owner  = {0,};
+    struct synctask *task = NULL;
+    gf_lkowner_t tmp_owner = {
+        0,
+    };
 
-        task = synctask_get ();
-        if (!task)
-                return _gf_false;
+    task = synctask_get();
+    if (!task)
+        return _gf_false;
 
-        set_lk_owner_from_ptr(&tmp_owner, (void *)this);
+    set_lk_owner_from_ptr(&tmp_owner, (void *)this);
 
-        if (!is_same_lkowner (&tmp_owner, &task->frame->root->lk_owner))
-                return _gf_false;
+    if (!is_same_lkowner(&tmp_owner, &task->frame->root->lk_owner))
+        return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-afr_ta_post_op_lock (xlator_t *this, loc_t *loc)
-{
-        /*Note: At any given time, only one instance of this function must
-        * be in progress.*/
-
-        int             ret    = 0;
-        uuid_t          gfid   = {0,};
-        afr_private_t   *priv  = this->private;
-        gf_boolean_t    locked = _gf_false;
-        struct gf_flock flock1 = {0, };
-        struct gf_flock flock2 = {0, };
-        int32_t         cmd    = 0;
-
-        GF_ASSERT (afr_ta_is_fop_called_from_synctask (this));
-        flock1.l_type = F_WRLCK;
-
-        while (!locked) {
-                if (priv->shd.iamshd) {
-                        cmd = F_SETLKW;
-                        flock1.l_start = 0;
-                        flock1.l_len = 0;
-
-                } else {
-                        cmd = F_SETLK;
-                        if (priv->ta_notify_dom_lock_offset) {
-                                flock1.l_start =
-                                        priv->ta_notify_dom_lock_offset;
-                        } else {
-                                gf_uuid_generate (gfid);
-                                flock1.l_start = gfid_to_ino (gfid);
-                                if (flock1.l_start < 0)
-                                        flock1.l_start = -flock1.l_start;
-                        }
-                        flock1.l_len = 1;
-                }
-                ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                                      AFR_TA_DOM_NOTIFY, loc, cmd, &flock1,
-                                      NULL, NULL);
-                if (!ret) {
-                        locked = _gf_true;
-                        priv->ta_notify_dom_lock_offset = flock1.l_start;
-                } else if (ret == -EAGAIN) {
-                        continue;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                AFR_MSG_THIN_ARB, "Failed to get "
-                                "AFR_TA_DOM_NOTIFY lock on %s.", loc->name);
-                        goto out;
-                }
-        }
+afr_ta_post_op_lock(xlator_t *this, loc_t *loc)
+{
+    /*Note: At any given time, only one instance of this function must
+     * be in progress.*/
+
+    int ret = 0;
+    uuid_t gfid = {
+        0,
+    };
+    afr_private_t *priv = this->private;
+    gf_boolean_t locked = _gf_false;
+    struct gf_flock flock1 = {
+        0,
+    };
+    struct gf_flock flock2 = {
+        0,
+    };
+    int32_t cmd = 0;
+
+    GF_ASSERT(afr_ta_is_fop_called_from_synctask(this));
+    flock1.l_type = F_WRLCK;
+
+    while (!locked) {
+        if (priv->shd.iamshd) {
+            cmd = F_SETLKW;
+            flock1.l_start = 0;
+            flock1.l_len = 0;
 
-        flock2.l_type = F_WRLCK;
-        flock2.l_start = 0;
-        flock2.l_len = 0;
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_MODIFY, loc, F_SETLKW, &flock2,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to get AFR_TA_DOM_MODIFY lock.");
-                flock1.l_type = F_UNLCK;
-                ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                                      AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock1,
-                                      NULL, NULL);
+        } else {
+            cmd = F_SETLK;
+            if (priv->ta_notify_dom_lock_offset) {
+                flock1.l_start = priv->ta_notify_dom_lock_offset;
+            } else {
+                gf_uuid_generate(gfid);
+                flock1.l_start = gfid_to_ino(gfid);
+                if (flock1.l_start < 0)
+                    flock1.l_start = -flock1.l_start;
+            }
+            flock1.l_len = 1;
         }
+        ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                             AFR_TA_DOM_NOTIFY, loc, cmd, &flock1, NULL, NULL);
+        if (!ret) {
+            locked = _gf_true;
+            priv->ta_notify_dom_lock_offset = flock1.l_start;
+        } else if (ret == -EAGAIN) {
+            continue;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+                   "Failed to get "
+                   "AFR_TA_DOM_NOTIFY lock on %s.",
+                   loc->name);
+            goto out;
+        }
+    }
+
+    flock2.l_type = F_WRLCK;
+    flock2.l_start = 0;
+    flock2.l_len = 0;
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, loc, F_SETLKW, &flock2, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to get AFR_TA_DOM_MODIFY lock.");
+        flock1.l_type = F_UNLCK;
+        ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                             AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock1, NULL,
+                             NULL);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_ta_post_op_unlock (xlator_t *this, loc_t *loc)
-{
-        afr_private_t           *priv = this->private;
-        struct gf_flock         flock = {0, };
-        int                     ret   = 0;
-
-        GF_ASSERT (afr_ta_is_fop_called_from_synctask (this));
-        flock.l_type = F_UNLCK;
-        flock.l_start = 0;
-        flock.l_len = 0;
-
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_MODIFY, loc, F_SETLK, &flock, NULL,
-                              NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to unlock AFR_TA_DOM_MODIFY lock.");
-                goto out;
-        }
-
-        if (!priv->shd.iamshd)
-                /* Mounts (clients) will not release the AFR_TA_DOM_NOTIFY lock
-                 * in post-op as they use it as a notification mechanism. When
-                 * shd sends a lock request on TA during heal, the clients will
-                 * receive a lock-contention upcall notification upon which they
-                 * will release the AFR_TA_DOM_NOTIFY lock after completing the
-                 * in flight I/O.*/
-                goto out;
-
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to unlock AFR_TA_DOM_NOTIFY lock.");
-        }
+afr_ta_post_op_unlock(xlator_t *this, loc_t *loc)
+{
+    afr_private_t *priv = this->private;
+    struct gf_flock flock = {
+        0,
+    };
+    int ret = 0;
+
+    GF_ASSERT(afr_ta_is_fop_called_from_synctask(this));
+    flock.l_type = F_UNLCK;
+    flock.l_start = 0;
+    flock.l_len = 0;
+
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to unlock AFR_TA_DOM_MODIFY lock.");
+        goto out;
+    }
+
+    if (!priv->shd.iamshd)
+        /* Mounts (clients) will not release the AFR_TA_DOM_NOTIFY lock
+         * in post-op as they use it as a notification mechanism. When
+         * shd sends a lock request on TA during heal, the clients will
+         * receive a lock-contention upcall notification upon which they
+         * will release the AFR_TA_DOM_NOTIFY lock after completing the
+         * in flight I/O.*/
+        goto out;
+
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_NOTIFY, loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to unlock AFR_TA_DOM_NOTIFY lock.");
+    }
 out:
-        return ret;
+    return ret;
 }
 
 call_frame_t *
-afr_ta_frame_create (xlator_t *this)
+afr_ta_frame_create(xlator_t *this)
 {
-        call_frame_t *frame    = NULL;
-        void         *lk_owner = NULL;
+    call_frame_t *frame = NULL;
+    void *lk_owner = NULL;
 
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                return NULL;
-        lk_owner = (void *)this;
-        afr_set_lk_owner (frame, this, lk_owner);
-        return frame;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        return NULL;
+    lk_owner = (void *)this;
+    afr_set_lk_owner(frame, this, lk_owner);
+    return frame;
 }
diff --git a/xlators/cluster/afr/src/afr-dir-read.c b/xlators/cluster/afr/src/afr-dir-read.c
index 76d0cdfa826..4c40e85f393 100644
--- a/xlators/cluster/afr/src/afr-dir-read.c
+++ b/xlators/cluster/afr/src/afr-dir-read.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
 #include <fnmatch.h>
@@ -33,327 +32,309 @@
 #include "afr.h"
 #include "afr-transaction.h"
 
-
 int32_t
-afr_opendir_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno,
-                 fd_t *fd, dict_t *xdata)
+afr_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t   *local             = NULL;
-        int            call_count        = -1;
-        int32_t        child_index       = 0;
-	afr_fd_ctx_t  *fd_ctx = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-        child_index = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                } else {
-                        local->op_ret = op_ret;
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-                }
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int32_t child_index = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+    child_index = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+        } else {
+            local->op_ret = op_ret;
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-		AFR_STACK_UNWIND (opendir, frame, local->op_ret,
-				  local->op_errno, local->fd, NULL);
-        return 0;
+    if (call_count == 0)
+        AFR_STACK_UNWIND(opendir, frame, local->op_ret, local->op_errno,
+                         local->fd, NULL);
+    return 0;
 }
 
-
 int
-afr_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd)
+afr_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd)
 {
-        afr_private_t * priv        = NULL;
-        afr_local_t   * local       = NULL;
-        int             i           = 0;
-        int             call_count  = -1;
-        int32_t         op_errno    = ENOMEM;
-	afr_fd_ctx_t *fd_ctx = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = -1;
+    int32_t op_errno = ENOMEM;
+    afr_fd_ctx_t *fd_ctx = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_OPENDIR;
-        if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
+    local->op = GF_FOP_OPENDIR;
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
 
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		goto out;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
+        goto out;
 
-        loc_copy (&local->loc, loc);
+    loc_copy(&local->loc, loc);
 
-        local->fd    = fd_ref (fd);
-	local->fd_ctx = fd_ctx;
+    local->fd = fd_ref(fd);
+    local->fd_ctx = fd_ctx;
 
-        call_count = local->call_count;
+    call_count = local->call_count;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, afr_opendir_cbk,
-                                           (void*) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->opendir,
-                                           loc, fd, NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, afr_opendir_cbk, (void *)(long)i,
+                              priv->children[i],
+                              priv->children[i]->fops->opendir, loc, fd, NULL);
 
-                        if (!--call_count)
-                                break;
-                }
+            if (!--call_count)
+                break;
         }
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (opendir, frame, -1, op_errno, fd, NULL);
-        return 0;
+    AFR_STACK_UNWIND(opendir, frame, -1, op_errno, fd, NULL);
+    return 0;
 }
 
 static int
-afr_validate_read_subvol (inode_t *inode, xlator_t *this, int par_read_subvol)
+afr_validate_read_subvol(inode_t *inode, xlator_t *this, int par_read_subvol)
 {
-	int             gen               = 0;
-        int             entry_read_subvol = 0;
-	unsigned char  *data_readable     = NULL;
-	unsigned char  *metadata_readable = NULL;
-        afr_private_t  *priv              = NULL;
-
-        priv = this->private;
-	data_readable = alloca0 (priv->child_count);
-	metadata_readable = alloca0 (priv->child_count);
-
-	afr_inode_read_subvol_get (inode, this, data_readable,
-				   metadata_readable, &gen);
-
-        if (gen != priv->event_generation ||
-                !data_readable[par_read_subvol] ||
-                !metadata_readable[par_read_subvol])
-                return -1;
-
-        /* Once the control reaches the following statement, it means that the
-         * parent's read subvol is perfectly readable. So calling
-         * either afr_data_subvol_get() or afr_metadata_subvol_get() would
-         * yield the same result. Hence, choosing afr_data_subvol_get() below.
-         */
-
-        if (!priv->consistent_metadata)
-                return 0;
-
-        /* For an inode fetched through readdirp which is yet to be linked,
-         * inode ctx would not be initialised (yet). So this function returns
-         * -1 above due to gen being 0, which is why it is OK to pass NULL for
-         *  read_subvol_args here.
-         */
-        entry_read_subvol = afr_data_subvol_get (inode, this, NULL, NULL,
-                                                 NULL, NULL);
-        if (entry_read_subvol != par_read_subvol)
-                return -1;
-
+    int gen = 0;
+    int entry_read_subvol = 0;
+    unsigned char *data_readable = NULL;
+    unsigned char *metadata_readable = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    data_readable = alloca0(priv->child_count);
+    metadata_readable = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(inode, this, data_readable, metadata_readable,
+                              &gen);
+
+    if (gen != priv->event_generation || !data_readable[par_read_subvol] ||
+        !metadata_readable[par_read_subvol])
+        return -1;
+
+    /* Once the control reaches the following statement, it means that the
+     * parent's read subvol is perfectly readable. So calling
+     * either afr_data_subvol_get() or afr_metadata_subvol_get() would
+     * yield the same result. Hence, choosing afr_data_subvol_get() below.
+     */
+
+    if (!priv->consistent_metadata)
         return 0;
 
+    /* For an inode fetched through readdirp which is yet to be linked,
+     * inode ctx would not be initialised (yet). So this function returns
+     * -1 above due to gen being 0, which is why it is OK to pass NULL for
+     *  read_subvol_args here.
+     */
+    entry_read_subvol = afr_data_subvol_get(inode, this, NULL, NULL, NULL,
+                                            NULL);
+    if (entry_read_subvol != par_read_subvol)
+        return -1;
+
+    return 0;
 }
 
 static void
-afr_readdir_transform_entries (gf_dirent_t *subvol_entries, int subvol,
-			       gf_dirent_t *entries, fd_t *fd)
+afr_readdir_transform_entries(gf_dirent_t *subvol_entries, int subvol,
+                              gf_dirent_t *entries, fd_t *fd)
 {
-        int            ret   = -1;
-        gf_dirent_t   *entry = NULL;
-        gf_dirent_t   *tmp   = NULL;
-        xlator_t      *this  = NULL;
-        afr_private_t *priv  = NULL;
-        gf_boolean_t  need_heal = _gf_false;
-        gf_boolean_t  validate_subvol = _gf_false;
-
-        this = THIS;
-        priv = this->private;
-
-        need_heal = afr_get_need_heal (this);
-        validate_subvol = need_heal | priv->consistent_metadata;
-
-        list_for_each_entry_safe (entry, tmp, &subvol_entries->list, list) {
-                if (__is_root_gfid (fd->inode->gfid) &&
-                    !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR)) {
-			continue;
-                }
-
-		list_del_init (&entry->list);
-		list_add_tail (&entry->list, &entries->list);
-
-                if (!validate_subvol)
-                        continue;
-
-		if (entry->inode) {
-                        ret = afr_validate_read_subvol (entry->inode, this,
-                                                        subvol);
-                        if (ret == -1) {
-				inode_unref (entry->inode);
-				entry->inode = NULL;
-                                continue;
-			}
-		}
+    int ret = -1;
+    gf_dirent_t *entry = NULL;
+    gf_dirent_t *tmp = NULL;
+    xlator_t *this = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t need_heal = _gf_false;
+    gf_boolean_t validate_subvol = _gf_false;
+
+    this = THIS;
+    priv = this->private;
+
+    need_heal = afr_get_need_heal(this);
+    validate_subvol = need_heal | priv->consistent_metadata;
+
+    list_for_each_entry_safe(entry, tmp, &subvol_entries->list, list)
+    {
+        if (__is_root_gfid(fd->inode->gfid) &&
+            !strcmp(entry->d_name, GF_REPLICATE_TRASH_DIR)) {
+            continue;
         }
-}
 
+        list_del_init(&entry->list);
+        list_add_tail(&entry->list, &entries->list);
+
+        if (!validate_subvol)
+            continue;
+
+        if (entry->inode) {
+            ret = afr_validate_read_subvol(entry->inode, this, subvol);
+            if (ret == -1) {
+                inode_unref(entry->inode);
+                entry->inode = NULL;
+                continue;
+            }
+        }
+    }
+}
 
 int32_t
-afr_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		 int32_t op_ret, int32_t op_errno, gf_dirent_t *subvol_entries,
-		 dict_t *xdata)
+afr_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, gf_dirent_t *subvol_entries,
+                dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	gf_dirent_t  entries;
+    afr_local_t *local = NULL;
+    gf_dirent_t entries;
 
-	INIT_LIST_HEAD (&entries.list);
+    INIT_LIST_HEAD(&entries.list);
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0 && !local->cont.readdir.offset) {
-		/* failover only if this was first readdir, detected
-		   by offset == 0 */
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0 && !local->cont.readdir.offset) {
+        /* failover only if this was first readdir, detected
+           by offset == 0 */
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (op_ret >= 0)
-		afr_readdir_transform_entries (subvol_entries, (long) cookie,
-					       &entries, local->fd);
+    if (op_ret >= 0)
+        afr_readdir_transform_entries(subvol_entries, (long)cookie, &entries,
+                                      local->fd);
 
-        AFR_STACK_UNWIND (readdir, frame, op_ret, op_errno, &entries, xdata);
+    AFR_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, xdata);
 
-        gf_dirent_free (&entries);
+    gf_dirent_free(&entries);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_readdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-	priv = this->private;
-	local = frame->local;
-	fd_ctx = afr_fd_ctx_get (local->fd, this);
-        if (!fd_ctx) {
-                local->op_errno = EINVAL;
-                local->op_ret = -1;
-        }
-
-	if (subvol == -1 || !fd_ctx) {
-		AFR_STACK_UNWIND (readdir, frame, local->op_ret,
-				  local->op_errno, 0, 0);
-		return 0;
-	}
-
-	fd_ctx->readdir_subvol = subvol;
-
-        if (local->op == GF_FOP_READDIR)
-                STACK_WIND_COOKIE (frame, afr_readdir_cbk,
-                                   (void *) (long) subvol,
-                                   priv->children[subvol],
-                                   priv->children[subvol]->fops->readdir,
-				   local->fd, local->cont.readdir.size,
-                                   local->cont.readdir.offset,
-				   local->xdata_req);
-        else
-                STACK_WIND_COOKIE (frame, afr_readdir_cbk,
-                                   (void *) (long) subvol,
-                                   priv->children[subvol],
-                                   priv->children[subvol]->fops->readdirp,
-				   local->fd, local->cont.readdir.size,
-				   local->cont.readdir.offset,
-				   local->xdata_req);
-	return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    priv = this->private;
+    local = frame->local;
+    fd_ctx = afr_fd_ctx_get(local->fd, this);
+    if (!fd_ctx) {
+        local->op_errno = EINVAL;
+        local->op_ret = -1;
+    }
+
+    if (subvol == -1 || !fd_ctx) {
+        AFR_STACK_UNWIND(readdir, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
+
+    fd_ctx->readdir_subvol = subvol;
+
+    if (local->op == GF_FOP_READDIR)
+        STACK_WIND_COOKIE(frame, afr_readdir_cbk, (void *)(long)subvol,
+                          priv->children[subvol],
+                          priv->children[subvol]->fops->readdir, local->fd,
+                          local->cont.readdir.size, local->cont.readdir.offset,
+                          local->xdata_req);
+    else
+        STACK_WIND_COOKIE(frame, afr_readdir_cbk, (void *)(long)subvol,
+                          priv->children[subvol],
+                          priv->children[subvol]->fops->readdirp, local->fd,
+                          local->cont.readdir.size, local->cont.readdir.offset,
+                          local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-		off_t offset, int whichop, dict_t *dict)
+afr_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t offset, int whichop, dict_t *dict)
 {
-        afr_local_t   *local     = NULL;
-        int32_t       op_errno   = 0;
-	int           subvol = -1;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx) {
-	        op_errno = EINVAL;
-		goto out;
-        }
-
-	local->op = whichop;
-        local->fd = fd_ref (fd);
-        local->cont.readdir.size = size;
-	local->cont.readdir.offset = offset;
-        local->xdata_req = (dict)? dict_ref (dict) : NULL;
-
-	subvol = fd_ctx->readdir_subvol;
-
-	if (offset == 0 || subvol == -1) {
-		/* First readdir has option of failing over and selecting
-		   an appropriate read subvolume */
-		afr_read_txn (frame, this, fd->inode, afr_readdir_wind,
-			      AFR_DATA_TRANSACTION);
-	} else {
-		/* But continued readdirs MUST stick to the same subvolume
-		   without an option to failover */
-		afr_readdir_wind (frame, this, subvol);
-	}
-
-        return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    int subvol = -1;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx) {
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    local->op = whichop;
+    local->fd = fd_ref(fd);
+    local->cont.readdir.size = size;
+    local->cont.readdir.offset = offset;
+    local->xdata_req = (dict) ? dict_ref(dict) : NULL;
+
+    subvol = fd_ctx->readdir_subvol;
+
+    if (offset == 0 || subvol == -1) {
+        /* First readdir has option of failing over and selecting
+           an appropriate read subvolume */
+        afr_read_txn(frame, this, fd->inode, afr_readdir_wind,
+                     AFR_DATA_TRANSACTION);
+    } else {
+        /* But continued readdirs MUST stick to the same subvolume
+           without an option to failover */
+        afr_readdir_wind(frame, this, subvol);
+    }
+
+    return 0;
 out:
-        AFR_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-afr_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, dict_t *xdata)
+afr_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t offset, dict_t *xdata)
 {
-	afr_do_readdir (frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
+    afr_do_readdir(frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t offset, dict_t *dict)
+afr_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t offset, dict_t *dict)
 {
-        afr_do_readdir (frame, this, fd, size, offset, GF_FOP_READDIRP, dict);
+    afr_do_readdir(frame, this, fd, size, offset, GF_FOP_READDIRP, dict);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-afr_releasedir (xlator_t *this, fd_t *fd)
+afr_releasedir(xlator_t *this, fd_t *fd)
 {
-        afr_cleanup_fd_ctx (this, fd);
+    afr_cleanup_fd_ctx(this, fd);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-dir-write.c b/xlators/cluster/afr/src/afr-dir-write.c
index 0e3ae18b46a..5725b1c5cb3 100644
--- a/xlators/cluster/afr/src/afr-dir-write.c
+++ b/xlators/cluster/afr/src/afr-dir-write.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
 #include <fnmatch.h>
@@ -34,501 +33,470 @@
 #include "afr-transaction.h"
 
 void
-afr_mark_entry_pending_changelog (call_frame_t *frame, xlator_t *this);
+afr_mark_entry_pending_changelog(call_frame_t *frame, xlator_t *this);
 
 int
-afr_build_parent_loc (loc_t *parent, loc_t *child, int32_t *op_errno)
+afr_build_parent_loc(loc_t *parent, loc_t *child, int32_t *op_errno)
 {
-        int     ret = -1;
-        char    *child_path = NULL;
-
-        if (!child->parent) {
-                if (op_errno)
-                        *op_errno = EINVAL;
-                goto out;
-        }
-
-        child_path = gf_strdup (child->path);
-        if (!child_path) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
-
-        parent->path = gf_strdup (dirname (child_path));
-        if (!parent->path) {
-                if (op_errno)
-                        *op_errno = ENOMEM;
-                goto out;
-        }
-
-        parent->inode = inode_ref (child->parent);
-	gf_uuid_copy (parent->gfid, child->pargfid);
-
-        ret = 0;
+    int ret = -1;
+    char *child_path = NULL;
+
+    if (!child->parent) {
+        if (op_errno)
+            *op_errno = EINVAL;
+        goto out;
+    }
+
+    child_path = gf_strdup(child->path);
+    if (!child_path) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    parent->path = gf_strdup(dirname(child_path));
+    if (!parent->path) {
+        if (op_errno)
+            *op_errno = ENOMEM;
+        goto out;
+    }
+
+    parent->inode = inode_ref(child->parent);
+    gf_uuid_copy(parent->gfid, child->pargfid);
+
+    ret = 0;
 out:
-        GF_FREE (child_path);
+    GF_FREE(child_path);
 
-        return ret;
+    return ret;
 }
 
-
 static void
-__afr_dir_write_finalize (call_frame_t *frame, xlator_t *this)
+__afr_dir_write_finalize(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int inode_read_subvol = -1;
-	int parent_read_subvol = -1;
-	int parent2_read_subvol = -1;
-	int i = 0;
-        afr_read_subvol_args_t args = {0,};
-
-	local = frame->local;
-	priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-	        if (!local->replies[i].valid)
-	                continue;
-	        if (local->replies[i].op_ret == -1)
-	                continue;
-                gf_uuid_copy (args.gfid, local->replies[i].poststat.ia_gfid);
-                args.ia_type = local->replies[i].poststat.ia_type;
-                break;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int inode_read_subvol = -1;
+    int parent_read_subvol = -1;
+    int parent2_read_subvol = -1;
+    int i = 0;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret == -1)
+            continue;
+        gf_uuid_copy(args.gfid, local->replies[i].poststat.ia_gfid);
+        args.ia_type = local->replies[i].poststat.ia_type;
+        break;
+    }
+
+    if (local->inode) {
+        afr_replies_interpret(frame, this, local->inode, NULL);
+        inode_read_subvol = afr_data_subvol_get(local->inode, this, NULL, NULL,
+                                                NULL, &args);
+    }
+
+    if (local->parent)
+        parent_read_subvol = afr_data_subvol_get(local->parent, this, NULL,
+                                                 local->readable, NULL, NULL);
+
+    if (local->parent2)
+        parent2_read_subvol = afr_data_subvol_get(local->parent2, this, NULL,
+                                                  local->readable2, NULL, NULL);
+
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    afr_pick_error_xdata(local, priv, local->parent, local->readable,
+                         local->parent2, local->readable2);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0) {
+            if (local->inode)
+                afr_inode_event_gen_reset(local->inode, this);
+            if (local->parent)
+                afr_inode_event_gen_reset(local->parent, this);
+            if (local->parent2)
+                afr_inode_event_gen_reset(local->parent2, this);
+            continue;
         }
 
-	if (local->inode) {
-		afr_replies_interpret (frame, this, local->inode, NULL);
-		inode_read_subvol = afr_data_subvol_get (local->inode, this,
-                                                       NULL, NULL, NULL, &args);
-	}
-
-	if (local->parent)
-		parent_read_subvol = afr_data_subvol_get (local->parent, this,
-                                             NULL, local->readable, NULL, NULL);
-
-	if (local->parent2)
-		parent2_read_subvol = afr_data_subvol_get (local->parent2, this,
-                                            NULL, local->readable2, NULL, NULL);
-
-	local->op_ret = -1;
-	local->op_errno = afr_final_errno (local, priv);
-        afr_pick_error_xdata (local, priv, local->parent, local->readable,
-                              local->parent2, local->readable2);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret < 0) {
-			if (local->inode)
-				afr_inode_event_gen_reset (local->inode, this);
-			if (local->parent)
-				afr_inode_event_gen_reset (local->parent,
-							     this);
-			if (local->parent2)
-				afr_inode_event_gen_reset (local->parent2,
-							     this);
-			continue;
-		}
-
-		if (local->op_ret == -1) {
-			local->op_ret = local->replies[i].op_ret;
-			local->op_errno = local->replies[i].op_errno;
-
-			local->cont.dir_fop.buf =
-				local->replies[i].poststat;
-			local->cont.dir_fop.preparent =
-				local->replies[i].preparent;
-			local->cont.dir_fop.postparent =
-				local->replies[i].postparent;
-			local->cont.dir_fop.prenewparent =
-				local->replies[i].preparent2;
-			local->cont.dir_fop.postnewparent =
-				local->replies[i].postparent2;
-                        if (local->xdata_rsp) {
-                                dict_unref (local->xdata_rsp);
-                                local->xdata_rsp = NULL;
-                        }
-
-			if (local->replies[i].xdata)
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			continue;
-		}
-
-		if (i == inode_read_subvol) {
-			local->cont.dir_fop.buf =
-				local->replies[i].poststat;
-			if (local->replies[i].xdata) {
-				if (local->xdata_rsp)
-					dict_unref (local->xdata_rsp);
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			}
-		}
-
-		if (i == parent_read_subvol) {
-			local->cont.dir_fop.preparent =
-				local->replies[i].preparent;
-			local->cont.dir_fop.postparent =
-				local->replies[i].postparent;
-		}
-
-		if (i == parent2_read_subvol) {
-			local->cont.dir_fop.prenewparent =
-				local->replies[i].preparent2;
-			local->cont.dir_fop.postnewparent =
-				local->replies[i].postparent2;
-		}
-	}
+        if (local->op_ret == -1) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+
+            local->cont.dir_fop.buf = local->replies[i].poststat;
+            local->cont.dir_fop.preparent = local->replies[i].preparent;
+            local->cont.dir_fop.postparent = local->replies[i].postparent;
+            local->cont.dir_fop.prenewparent = local->replies[i].preparent2;
+            local->cont.dir_fop.postnewparent = local->replies[i].postparent2;
+            if (local->xdata_rsp) {
+                dict_unref(local->xdata_rsp);
+                local->xdata_rsp = NULL;
+            }
+
+            if (local->replies[i].xdata)
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            continue;
+        }
 
-}
+        if (i == inode_read_subvol) {
+            local->cont.dir_fop.buf = local->replies[i].poststat;
+            if (local->replies[i].xdata) {
+                if (local->xdata_rsp)
+                    dict_unref(local->xdata_rsp);
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+        }
 
+        if (i == parent_read_subvol) {
+            local->cont.dir_fop.preparent = local->replies[i].preparent;
+            local->cont.dir_fop.postparent = local->replies[i].postparent;
+        }
+
+        if (i == parent2_read_subvol) {
+            local->cont.dir_fop.prenewparent = local->replies[i].preparent2;
+            local->cont.dir_fop.postnewparent = local->replies[i].postparent2;
+        }
+    }
+}
 
 static void
-__afr_dir_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
-		      int op_ret, int op_errno, struct iatt *poststat,
-		      struct iatt *preparent, struct iatt *postparent,
-		      struct iatt *preparent2, struct iatt *postparent2,
-		      dict_t *xdata)
+__afr_dir_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
+                     int op_ret, int op_errno, struct iatt *poststat,
+                     struct iatt *preparent, struct iatt *postparent,
+                     struct iatt *preparent2, struct iatt *postparent2,
+                     dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	afr_fd_ctx_t *fd_ctx = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-
-	local->replies[child_index].valid = 1;
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
-
-
-	if (op_ret >= 0) {
-		if (poststat)
-			local->replies[child_index].poststat = *poststat;
-		if (preparent)
-			local->replies[child_index].preparent = *preparent;
-		if (postparent)
-			local->replies[child_index].postparent = *postparent;
-		if (preparent2)
-			local->replies[child_index].preparent2 = *preparent2;
-		if (postparent2)
-			local->replies[child_index].postparent2 = *postparent2;
-		if (fd_ctx)
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-	} else {
-		if (op_errno != ENOTEMPTY)
-			afr_transaction_fop_failed (frame, this, child_index);
-		if (fd_ctx)
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-	}
-
-        return;
+    afr_local_t *local = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+
+    local->replies[child_index].valid = 1;
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
+
+    if (op_ret >= 0) {
+        if (poststat)
+            local->replies[child_index].poststat = *poststat;
+        if (preparent)
+            local->replies[child_index].preparent = *preparent;
+        if (postparent)
+            local->replies[child_index].postparent = *postparent;
+        if (preparent2)
+            local->replies[child_index].preparent2 = *preparent2;
+        if (postparent2)
+            local->replies[child_index].postparent2 = *postparent2;
+        if (fd_ctx)
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+    } else {
+        if (op_errno != ENOTEMPTY)
+            afr_transaction_fop_failed(frame, this, child_index);
+        if (fd_ctx)
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+    }
+
+    return;
 }
 
-
 static int
-__afr_dir_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		     int op_ret, int op_errno, struct iatt *buf,
-		     struct iatt *preparent, struct iatt *postparent,
-		     struct iatt *preparent2, struct iatt *postparent2,
-                     dict_t *xdata)
+__afr_dir_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iatt *buf,
+                    struct iatt *preparent, struct iatt *postparent,
+                    struct iatt *preparent2, struct iatt *postparent2,
+                    dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_private_t *priv = NULL;
-
-        priv  = this->private;
-        local = frame->local;
-
-	LOCK (&frame->lock);
-	{
-		__afr_dir_write_fill (frame, this, child_index, op_ret,
-				      op_errno, buf, preparent, postparent,
-				      preparent2, postparent2, xdata);
-	}
-	UNLOCK (&frame->lock);
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-		__afr_dir_write_finalize (frame, this);
-
-		if (afr_txn_nothing_failed (frame, this)) {
-                        /*if it did pre-op, it will do post-op changing ctime*/
-                        if (priv->consistent_metadata &&
-                            afr_needs_changelog_update (local))
-                                afr_zero_fill_stat (local);
-                        local->transaction.unwind (frame, this);
-                }
-
-		afr_mark_entry_pending_changelog (frame, this);
-
-                afr_transaction_resume (frame, this);
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    LOCK(&frame->lock);
+    {
+        __afr_dir_write_fill(frame, this, child_index, op_ret, op_errno, buf,
+                             preparent, postparent, preparent2, postparent2,
+                             xdata);
+    }
+    UNLOCK(&frame->lock);
+    call_count = afr_frame_return(frame);
+
+    if (call_count == 0) {
+        __afr_dir_write_finalize(frame, this);
+
+        if (afr_txn_nothing_failed(frame, this)) {
+            /*if it did pre-op, it will do post-op changing ctime*/
+            if (priv->consistent_metadata && afr_needs_changelog_update(local))
+                afr_zero_fill_stat(local);
+            local->transaction.unwind(frame, this);
         }
 
-        return 0;
-}
+        afr_mark_entry_pending_changelog(frame, this);
 
+        afr_transaction_resume(frame, this);
+    }
+
+    return 0;
+}
 
 int
-afr_mark_new_entry_changelog_cbk (call_frame_t *frame, void *cookie,
-				  xlator_t *this, int op_ret, int op_errno,
-                                  dict_t *xattr, dict_t *xdata)
+afr_mark_new_entry_changelog_cbk(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int op_ret, int op_errno,
+                                 dict_t *xattr, dict_t *xdata)
 {
-        int call_count = 0;
+    int call_count = 0;
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0)
-                AFR_STACK_DESTROY (frame);
+    if (call_count == 0)
+        AFR_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 void
-afr_mark_new_entry_changelog (call_frame_t *frame, xlator_t *this)
+afr_mark_new_entry_changelog(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t  *new_frame  = NULL;
-        afr_local_t   *local      = NULL;
-        afr_local_t   *new_local  = NULL;
-        afr_private_t *priv       = NULL;
-        dict_t        *xattr      = NULL;
-        int32_t       **changelog = NULL;
-        int           i           = 0;
-        int           op_errno    = ENOMEM;
-	unsigned char *pending    = NULL;
-	int           call_count   = 0;
-
-        local = frame->local;
-        priv = this->private;
-
-        new_frame = copy_frame (frame);
-        if (!new_frame)
-                goto out;
-
-	new_local = AFR_FRAME_INIT (new_frame, op_errno);
-	if (!new_local)
-		goto out;
-
-        xattr = dict_new ();
-	if (!xattr)
-		goto out;
-
-	pending = alloca0 (priv->child_count);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->transaction.pre_op[i] &&
-		    !local->transaction.failed_subvols[i]) {
-			call_count ++;
-			continue;
-		}
-		pending[i] = 1;
-	}
-
-        changelog = afr_mark_pending_changelog (priv, pending, xattr,
-                                            local->cont.dir_fop.buf.ia_type);
-        if (!changelog)
-                goto out;
-
-        new_local->pending = changelog;
-        gf_uuid_copy (new_local->loc.gfid, local->cont.dir_fop.buf.ia_gfid);
-        new_local->loc.inode = inode_ref (local->inode);
-
-        new_local->call_count = call_count;
-
-        for (i = 0; i < priv->child_count; i++) {
-		if (pending[i])
-                        continue;
-
-                STACK_WIND_COOKIE (new_frame, afr_mark_new_entry_changelog_cbk,
-                                   (void *) (long) i, priv->children[i],
-                                   priv->children[i]->fops->xattrop,
-                                   &new_local->loc, GF_XATTROP_ADD_ARRAY,
-                                   xattr, NULL);
-		if (!--call_count)
-			break;
+    call_frame_t *new_frame = NULL;
+    afr_local_t *local = NULL;
+    afr_local_t *new_local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int32_t **changelog = NULL;
+    int i = 0;
+    int op_errno = ENOMEM;
+    unsigned char *pending = NULL;
+    int call_count = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    new_frame = copy_frame(frame);
+    if (!new_frame)
+        goto out;
+
+    new_local = AFR_FRAME_INIT(new_frame, op_errno);
+    if (!new_local)
+        goto out;
+
+    xattr = dict_new();
+    if (!xattr)
+        goto out;
+
+    pending = alloca0(priv->child_count);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] &&
+            !local->transaction.failed_subvols[i]) {
+            call_count++;
+            continue;
         }
+        pending[i] = 1;
+    }
+
+    changelog = afr_mark_pending_changelog(priv, pending, xattr,
+                                           local->cont.dir_fop.buf.ia_type);
+    if (!changelog)
+        goto out;
+
+    new_local->pending = changelog;
+    gf_uuid_copy(new_local->loc.gfid, local->cont.dir_fop.buf.ia_gfid);
+    new_local->loc.inode = inode_ref(local->inode);
+
+    new_local->call_count = call_count;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (pending[i])
+            continue;
 
-        new_frame = NULL;
+        STACK_WIND_COOKIE(new_frame, afr_mark_new_entry_changelog_cbk,
+                          (void *)(long)i, priv->children[i],
+                          priv->children[i]->fops->xattrop, &new_local->loc,
+                          GF_XATTROP_ADD_ARRAY, xattr, NULL);
+        if (!--call_count)
+            break;
+    }
+
+    new_frame = NULL;
 out:
-        if (new_frame)
-                AFR_STACK_DESTROY (new_frame);
-	if (xattr)
-		dict_unref (xattr);
-        return;
+    if (new_frame)
+        AFR_STACK_DESTROY(new_frame);
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
-
 void
-afr_mark_entry_pending_changelog (call_frame_t *frame, xlator_t *this)
+afr_mark_entry_pending_changelog(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-	int pre_op_count = 0;
-	int failed_count = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int pre_op_count = 0;
+    int failed_count = 0;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        if (local->op_ret < 0)
-		return;
+    if (local->op_ret < 0)
+        return;
 
-	if (local->op != GF_FOP_CREATE && local->op != GF_FOP_MKNOD &&
-            local->op != GF_FOP_MKDIR)
-		return;
+    if (local->op != GF_FOP_CREATE && local->op != GF_FOP_MKNOD &&
+        local->op != GF_FOP_MKDIR)
+        return;
 
-	pre_op_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
-	failed_count = AFR_COUNT (local->transaction.failed_subvols,
-				  priv->child_count);
+    pre_op_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
+    failed_count = AFR_COUNT(local->transaction.failed_subvols,
+                             priv->child_count);
 
-	if (pre_op_count == priv->child_count && !failed_count)
-		return;
+    if (pre_op_count == priv->child_count && !failed_count)
+        return;
 
-        afr_mark_new_entry_changelog (frame, this);
+    afr_mark_new_entry_changelog(frame, this);
 
-        return;
+    return;
 }
 
-
 /* {{{ create */
 
 int
-afr_create_unwind (call_frame_t *frame, xlator_t *this)
+afr_create_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
+    local = frame->local;
 
-        if (!main_frame)
-		return 0;
+    main_frame = afr_transaction_detach_fop_frame(frame);
 
-	AFR_STACK_UNWIND (create, main_frame, local->op_ret, local->op_errno,
-			  local->cont.create.fd, local->inode,
-			  &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(create, main_frame, local->op_ret, local->op_errno,
+                     local->cont.create.fd, local->inode,
+                     &local->cont.dir_fop.buf, &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_create_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     fd_t *fd, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent,
-                     dict_t *xdata)
+afr_create_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_create_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_create_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_create_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->create,
-			   &local->loc, local->cont.create.flags,
-			   local->cont.create.mode, local->umask,
-			   local->cont.create.fd, local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_create_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->create, &local->loc,
+                      local->cont.create.flags, local->cont.create.mode,
+                      local->umask, local->cont.create.fd, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-	    mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+afr_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-
-	local->fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!local->fd_ctx)
-		goto out;
-
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->op                = GF_FOP_CREATE;
-        local->cont.create.flags = flags;
-        local->fd_ctx->flags     = flags;
-        local->cont.create.mode  = mode;
-        local->cont.create.fd    = fd_ref (fd);
-        local->umask  = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->transaction.wind   = afr_create_wind;
-        local->transaction.unwind = afr_create_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-            op_errno = -ret;
-            goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+
+    local->fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!local->fd_ctx)
+        goto out;
+
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->op = GF_FOP_CREATE;
+    local->cont.create.flags = flags;
+    local->fd_ctx->flags = flags;
+    local->cont.create.mode = mode;
+    local->cont.create.fd = fd_ref(fd);
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->transaction.wind = afr_create_wind;
+    local->transaction.unwind = afr_create_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -536,516 +504,492 @@ out:
 /* {{{ mknod */
 
 int
-afr_mknod_unwind (call_frame_t *frame, xlator_t *this)
+afr_mknod_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (mknod, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(mknod, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_mknod_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_mknod_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-	return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_mknod_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_mknod_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv  = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_mknod_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->mknod,
-			   &local->loc, local->cont.mknod.mode,
-			   local->cont.mknod.dev, local->umask,
-			   local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_mknod_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->mknod, &local->loc,
+                      local->cont.mknod.mode, local->cont.mknod.dev,
+                      local->umask, local->xdata_req);
+    return 0;
 }
 
 int
-afr_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-           dev_t dev, mode_t umask, dict_t *xdata)
+afr_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t dev, mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->op               = GF_FOP_MKNOD;
-        local->cont.mknod.mode  = mode;
-        local->cont.mknod.dev   = dev;
-        local->umask = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->transaction.wind   = afr_mknod_wind;
-        local->transaction.unwind = afr_mknod_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->op = GF_FOP_MKNOD;
+    local->cont.mknod.mode = mode;
+    local->cont.mknod.dev = dev;
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->transaction.wind = afr_mknod_wind;
+    local->transaction.unwind = afr_mknod_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ mkdir */
 
-
 int
-afr_mkdir_unwind (call_frame_t *frame, xlator_t *this)
+afr_mkdir_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (mkdir, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(mkdir, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_mkdir_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_mkdir_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-	return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_mkdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_mkdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_mkdir_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->mkdir, &local->loc,
-			   local->cont.mkdir.mode, local->umask,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_mkdir_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->mkdir, &local->loc,
+                      local->cont.mkdir.mode, local->umask, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-	   mode_t umask, dict_t *xdata)
+afr_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.mkdir.mode  = mode;
-        local->umask = umask;
-
-        if (!xdata || !dict_get (xdata, "gfid-req")) {
-                op_errno = EPERM;
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, op_errno,
-                                  AFR_MSG_GFID_NULL, "mkdir: %s is received "
-                                  "without gfid-req %p", loc->path, xdata);
-	        goto out;
-        }
-
-        local->xdata_req = dict_copy_with_ref (xdata, NULL);
-        if (!local->xdata_req) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-        local->op = GF_FOP_MKDIR;
-        local->transaction.wind   = afr_mkdir_wind;
-        local->transaction.unwind = afr_mkdir_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.mkdir.mode = mode;
+    local->umask = umask;
+
+    if (!xdata || !dict_get(xdata, "gfid-req")) {
+        op_errno = EPERM;
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, op_errno,
+                         AFR_MSG_GFID_NULL,
+                         "mkdir: %s is received "
+                         "without gfid-req %p",
+                         loc->path, xdata);
+        goto out;
+    }
+
+    local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    if (!local->xdata_req) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local->op = GF_FOP_MKDIR;
+    local->transaction.wind = afr_mkdir_wind;
+    local->transaction.unwind = afr_mkdir_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ link */
 
-
 int
-afr_link_unwind (call_frame_t *frame, xlator_t *this)
+afr_link_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (link, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(link, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_link_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+afr_link_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_link_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_link_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_link_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->link,
-			   &local->loc, &local->newloc, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_link_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->link, &local->loc,
+                      &local->newloc, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-	  dict_t *xdata)
+afr_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc,    oldloc);
-        loc_copy (&local->newloc, newloc);
-
-        local->inode = inode_ref (oldloc->inode);
-	local->parent = inode_ref (newloc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_LINK;
-
-        local->transaction.wind   = afr_link_wind;
-        local->transaction.unwind = afr_link_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, newloc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (newloc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, oldloc);
+    loc_copy(&local->newloc, newloc);
+
+    local->inode = inode_ref(oldloc->inode);
+    local->parent = inode_ref(newloc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_LINK;
+
+    local->transaction.wind = afr_link_wind;
+    local->transaction.unwind = afr_link_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, newloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(newloc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL);
-        return 0;
+    AFR_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ symlink */
 
-
 int
-afr_symlink_unwind (call_frame_t *frame, xlator_t *this)
+afr_symlink_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (symlink, main_frame, local->op_ret, local->op_errno,
-			  local->inode, &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(symlink, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->cont.dir_fop.buf,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_symlink_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, inode_t *inode,
-                      struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata)
+afr_symlink_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, inode_t *inode,
+                     struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_symlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_symlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-	STACK_WIND_COOKIE (frame, afr_symlink_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->symlink,
-			   local->cont.symlink.linkpath, &local->loc,
-			   local->umask, local->xdata_req);
-        return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    STACK_WIND_COOKIE(frame, afr_symlink_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->symlink,
+                      local->cont.symlink.linkpath, &local->loc, local->umask,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-	     loc_t *loc, mode_t umask, dict_t *xdata)
+afr_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+            loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.symlink.linkpath = gf_strdup (linkpath);
-        local->umask = umask;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_SYMLINK;
-        local->transaction.wind   = afr_symlink_wind;
-        local->transaction.unwind = afr_symlink_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.symlink.linkpath = gf_strdup(linkpath);
+    local->umask = umask;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_SYMLINK;
+    local->transaction.wind = afr_symlink_wind;
+    local->transaction.unwind = afr_symlink_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(symlink, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -1053,159 +997,152 @@ out:
 /* {{{ rename */
 
 int
-afr_rename_unwind (call_frame_t *frame, xlator_t *this)
+afr_rename_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (rename, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.buf,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent,
-			  &local->cont.dir_fop.prenewparent,
-			  &local->cont.dir_fop.postnewparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(rename, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.buf, &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent,
+                     &local->cont.dir_fop.prenewparent,
+                     &local->cont.dir_fop.postnewparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_rename_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                     struct iatt *preoldparent, struct iatt *postoldparent,
-                     struct iatt *prenewparent, struct iatt *postnewparent,
-                     dict_t *xdata)
+afr_rename_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                    struct iatt *preoldparent, struct iatt *postoldparent,
+                    struct iatt *prenewparent, struct iatt *postnewparent,
+                    dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, buf,
-				    preoldparent, postoldparent, prenewparent,
-				    postnewparent, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, buf,
+                               preoldparent, postoldparent, prenewparent,
+                               postnewparent, xdata);
 }
 
-
 int
-afr_rename_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_rename_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_rename_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->rename,
-			   &local->loc, &local->newloc, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_rename_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->rename, &local->loc,
+                      &local->newloc, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-	    dict_t *xdata)
+afr_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-        int                     nlockee                 = 0;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame) {
-                op_errno = ENOMEM;
-                goto out;
-        }
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc,    oldloc);
-        loc_copy (&local->newloc, newloc);
-
-        local->inode = inode_ref (oldloc->inode);
-	local->parent = inode_ref (oldloc->parent);
-	local->parent2 = inode_ref (newloc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_RENAME;
-        local->transaction.wind   = afr_rename_wind;
-        local->transaction.unwind = afr_rename_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, oldloc,
-                                    &op_errno);
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+    int nlockee = 0;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, oldloc);
+    loc_copy(&local->newloc, newloc);
+
+    local->inode = inode_ref(oldloc->inode);
+    local->parent = inode_ref(oldloc->parent);
+    local->parent2 = inode_ref(newloc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_RENAME;
+    local->transaction.wind = afr_rename_wind;
+    local->transaction.unwind = afr_rename_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, oldloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+    ret = afr_build_parent_loc(&local->transaction.new_parent_loc, newloc,
+                               &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(oldloc->path);
+    local->transaction.new_basename = AFR_BASENAME(newloc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = nlockee = 0;
+    ret = afr_init_entry_lockee(
+        &int_lock->lockee[nlockee], local, &local->transaction.new_parent_loc,
+        local->transaction.new_basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    nlockee++;
+    ret = afr_init_entry_lockee(&int_lock->lockee[nlockee], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    nlockee++;
+    if (local->newloc.inode && IA_ISDIR(local->newloc.inode->ia_type)) {
+        ret = afr_init_entry_lockee(&int_lock->lockee[nlockee], local,
+                                    &local->newloc, NULL, priv->child_count);
         if (ret)
-                goto out;
-        ret = afr_build_parent_loc (&local->transaction.new_parent_loc, newloc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame   = frame;
-        local->transaction.basename     = AFR_BASENAME (oldloc->path);
-        local->transaction.new_basename = AFR_BASENAME (newloc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = nlockee = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.new_parent_loc,
-                                     local->transaction.new_basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
+            goto out;
 
         nlockee++;
-        if (local->newloc.inode && IA_ISDIR (local->newloc.inode->ia_type)) {
-                ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                             &local->newloc,
-                                             NULL,
-                                             priv->child_count);
-                if (ret)
-                        goto out;
-
-                nlockee++;
-        }
-        qsort (int_lock->lockee, nlockee, sizeof (*int_lock->lockee),
-               afr_entry_lockee_cmp);
-        int_lock->lockee_count = nlockee;
-
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_RENAME_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    }
+    qsort(int_lock->lockee, nlockee, sizeof(*int_lock->lockee),
+          afr_entry_lockee_cmp);
+    int_lock->lockee_count = nlockee;
+
+    ret = afr_transaction(transaction_frame, this,
+                          AFR_ENTRY_RENAME_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-			  NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 /* }}} */
@@ -1213,259 +1150,244 @@ out:
 /* {{{ unlink */
 
 int
-afr_unlink_unwind (call_frame_t *frame, xlator_t *this)
+afr_unlink_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (unlink, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(unlink, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_unlink_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+afr_unlink_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, NULL,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_unlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_unlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_unlink_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->unlink,
-			   &local->loc, local->xflag, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_unlink_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->unlink, &local->loc,
+                      local->xflag, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-	    dict_t *xdata)
+afr_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-        loc_copy (&local->loc, loc);
-        local->xflag = xflag;
-
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_UNLINK;
-        local->transaction.wind   = afr_unlink_wind;
-        local->transaction.unwind = afr_unlink_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[0], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        int_lock->lockee_count++;
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->xflag = xflag;
+
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_UNLINK;
+    local->transaction.wind = afr_unlink_wind;
+    local->transaction.unwind = afr_unlink_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[0], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    int_lock->lockee_count++;
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 /* {{{ rmdir */
 
-
-
 int
-afr_rmdir_unwind (call_frame_t *frame, xlator_t *this)
+afr_rmdir_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *main_frame = NULL;
-        afr_local_t  *local = NULL;
-
-        local = frame->local;
+    call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (rmdir, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.dir_fop.preparent,
-			  &local->cont.dir_fop.postparent, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(rmdir, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.dir_fop.preparent,
+                     &local->cont.dir_fop.postparent, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_rmdir_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+afr_rmdir_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        return __afr_dir_write_cbk (frame, cookie, this, op_ret, op_errno, NULL,
-				    preparent, postparent, NULL, NULL, xdata);
+    return __afr_dir_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                               preparent, postparent, NULL, NULL, xdata);
 }
 
-
 int
-afr_rmdir_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_rmdir_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_rmdir_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->rmdir,
-			   &local->loc, local->cont.rmdir.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_rmdir_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->rmdir, &local->loc,
+                      local->cont.rmdir.flags, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-	   dict_t *xdata)
+afr_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata)
 {
-        afr_private_t           *priv                   = NULL;
-        afr_local_t             *local                  = NULL;
-        afr_internal_lock_t     *int_lock               = NULL;
-        call_frame_t            *transaction_frame      = NULL;
-        int                     ret                     = -1;
-        int                     op_errno                = ENOMEM;
-        int                     nlockee                 = 0;
-
-        priv = this->private;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
-
-
-        loc_copy (&local->loc, loc);
-        local->inode = inode_ref (loc->inode);
-	local->parent = inode_ref (loc->parent);
-
-        local->cont.rmdir.flags = flags;
-
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
-
-	if (!local->xdata_req)
-		goto out;
-
-        local->op = GF_FOP_RMDIR;
-        local->transaction.wind   = afr_rmdir_wind;
-        local->transaction.unwind = afr_rmdir_unwind;
-
-        ret = afr_build_parent_loc (&local->transaction.parent_loc, loc,
-                                    &op_errno);
-        if (ret)
-                goto out;
-
-        local->transaction.main_frame = frame;
-        local->transaction.basename = AFR_BASENAME (loc->path);
-        int_lock = &local->internal_lock;
-
-        int_lock->lockee_count = nlockee = 0;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->transaction.parent_loc,
-                                     local->transaction.basename,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        ret = afr_init_entry_lockee (&int_lock->lockee[nlockee], local,
-                                     &local->loc,
-                                     NULL,
-                                     priv->child_count);
-        if (ret)
-                goto out;
-
-        nlockee++;
-        qsort (int_lock->lockee, nlockee, sizeof (*int_lock->lockee),
-               afr_entry_lockee_cmp);
-        int_lock->lockee_count = nlockee;
-
-        ret = afr_transaction (transaction_frame, this, AFR_ENTRY_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
+    int nlockee = 0;
+
+    priv = this->private;
+
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
+
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
+
+    loc_copy(&local->loc, loc);
+    local->inode = inode_ref(loc->inode);
+    local->parent = inode_ref(loc->parent);
+
+    local->cont.rmdir.flags = flags;
+
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
+
+    if (!local->xdata_req)
+        goto out;
+
+    local->op = GF_FOP_RMDIR;
+    local->transaction.wind = afr_rmdir_wind;
+    local->transaction.unwind = afr_rmdir_unwind;
+
+    ret = afr_build_parent_loc(&local->transaction.parent_loc, loc, &op_errno);
+    if (ret)
+        goto out;
+
+    local->transaction.main_frame = frame;
+    local->transaction.basename = AFR_BASENAME(loc->path);
+    int_lock = &local->internal_lock;
+
+    int_lock->lockee_count = nlockee = 0;
+    ret = afr_init_entry_lockee(&int_lock->lockee[nlockee], local,
+                                &local->transaction.parent_loc,
+                                local->transaction.basename, priv->child_count);
+    if (ret)
+        goto out;
+
+    nlockee++;
+    ret = afr_init_entry_lockee(&int_lock->lockee[nlockee], local, &local->loc,
+                                NULL, priv->child_count);
+    if (ret)
+        goto out;
+
+    nlockee++;
+    qsort(int_lock->lockee, nlockee, sizeof(*int_lock->lockee),
+          afr_entry_lockee_cmp);
+    int_lock->lockee_count = nlockee;
+
+    ret = afr_transaction(transaction_frame, this, AFR_ENTRY_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
diff --git a/xlators/cluster/afr/src/afr-inode-read.c b/xlators/cluster/afr/src/afr-inode-read.c
index d0b07e9064f..113e39acfe8 100644
--- a/xlators/cluster/afr/src/afr-inode-read.c
+++ b/xlators/cluster/afr/src/afr-inode-read.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
 #include <fnmatch.h>
@@ -44,146 +43,145 @@
  * */
 
 int
-afr_handle_quota_size (call_frame_t *frame, xlator_t *this)
+afr_handle_quota_size(call_frame_t *frame, xlator_t *this)
 {
-        unsigned char *readable   = NULL;
-        afr_local_t *local        = NULL;
-        afr_private_t *priv       = NULL;
-        struct afr_reply *replies = NULL;
-        int i                     = 0;
-        int ret                   = 0;
-        quota_meta_t size         = {0, };
-        quota_meta_t max_size     = {0, };
-        int readable_cnt          = 0;
-        int read_subvol           = -1;
-
-        local = frame->local;
-        priv = this->private;
-        replies = local->replies;
-
-        readable = alloca0 (priv->child_count);
-
-        afr_inode_read_subvol_get (local->inode, this, readable, 0, 0);
-
-        readable_cnt = AFR_COUNT (readable, priv->child_count);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (readable_cnt && !readable[i])
-                        continue;
-                if (!replies[i].xdata)
-                        continue;
-                ret = quota_dict_get_meta (replies[i].xdata, QUOTA_SIZE_KEY,
-                                           &size);
-                if (ret == -1)
-                        continue;
-                if (read_subvol == -1)
-                        read_subvol = i;
-                if (size.size > max_size.size ||
-                    (size.file_count + size.dir_count) >
-                    (max_size.file_count + max_size.dir_count))
-                        read_subvol = i;
-
-                if (size.size > max_size.size)
-                        max_size.size = size.size;
-                if (size.file_count > max_size.file_count)
-                        max_size.file_count = size.file_count;
-                if (size.dir_count > max_size.dir_count)
-                        max_size.dir_count = size.dir_count;
-        }
-
-        if (max_size.size == 0 && max_size.file_count == 0 &&
-            max_size.dir_count == 0)
-                return read_subvol;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (readable_cnt && !readable[i])
-                        continue;
-                if (!replies[i].xdata)
-                        continue;
-                quota_dict_set_meta (replies[i].xdata, QUOTA_SIZE_KEY,
-                                     &max_size, IA_IFDIR);
-        }
-
+    unsigned char *readable = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    int i = 0;
+    int ret = 0;
+    quota_meta_t size = {
+        0,
+    };
+    quota_meta_t max_size = {
+        0,
+    };
+    int readable_cnt = 0;
+    int read_subvol = -1;
+
+    local = frame->local;
+    priv = this->private;
+    replies = local->replies;
+
+    readable = alloca0(priv->child_count);
+
+    afr_inode_read_subvol_get(local->inode, this, readable, 0, 0);
+
+    readable_cnt = AFR_COUNT(readable, priv->child_count);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (readable_cnt && !readable[i])
+            continue;
+        if (!replies[i].xdata)
+            continue;
+        ret = quota_dict_get_meta(replies[i].xdata, QUOTA_SIZE_KEY, &size);
+        if (ret == -1)
+            continue;
+        if (read_subvol == -1)
+            read_subvol = i;
+        if (size.size > max_size.size ||
+            (size.file_count + size.dir_count) >
+                (max_size.file_count + max_size.dir_count))
+            read_subvol = i;
+
+        if (size.size > max_size.size)
+            max_size.size = size.size;
+        if (size.file_count > max_size.file_count)
+            max_size.file_count = size.file_count;
+        if (size.dir_count > max_size.dir_count)
+            max_size.dir_count = size.dir_count;
+    }
+
+    if (max_size.size == 0 && max_size.file_count == 0 &&
+        max_size.dir_count == 0)
         return read_subvol;
-}
 
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (readable_cnt && !readable[i])
+            continue;
+        if (!replies[i].xdata)
+            continue;
+        quota_dict_set_meta(replies[i].xdata, QUOTA_SIZE_KEY, &max_size,
+                            IA_IFDIR);
+    }
+
+    return read_subvol;
+}
 
 /* {{{ access */
 
 int
-afr_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, dict_t *xdata)
+afr_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (access, frame, op_ret, op_errno, xdata);
+    AFR_STACK_UNWIND(access, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_access_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_access_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (access, frame, local->op_ret,
-				  local->op_errno, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_access_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->access,
-                           &local->loc, local->cont.access.mask,
-			   local->xdata_req);
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(access, frame, local->op_ret, local->op_errno, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_access_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->access, &local->loc,
+                      local->cont.access.mask, local->xdata_req);
+    return 0;
 }
 
 int
-afr_access (call_frame_t *frame, xlator_t *this, loc_t *loc,
-	    int mask, dict_t *xdata)
+afr_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
+           dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_ACCESS;
-	loc_copy (&local->loc, loc);
-	local->cont.access.mask = mask;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_ACCESS;
+    loc_copy(&local->loc, loc);
+    local->cont.access.mask = mask;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_access_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_access_wind,
+                 AFR_METADATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (access, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(access, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -191,152 +189,139 @@ out:
 /* {{{ stat */
 
 int
-afr_stat_cbk (call_frame_t *frame, void *cookie,
-              xlator_t *this, int32_t op_ret, int32_t op_errno,
-              struct iatt *buf, dict_t *xdata)
+afr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata);
+    AFR_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_stat_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_stat_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (stat, frame, local->op_ret, local->op_errno,
-				  0, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_stat_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->stat,
-                           &local->loc, local->xdata_req);
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(
+        frame, afr_stat_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->stat, &local->loc, local->xdata_req);
+    return 0;
 }
 
 int
-afr_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+afr_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_STAT;
-	loc_copy (&local->loc, loc);
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_STAT;
+    loc_copy(&local->loc, loc);
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_stat_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_stat_wind, AFR_DATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ fstat */
 
 int
-afr_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *buf,
-               dict_t *xdata)
+afr_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata);
+    AFR_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fstat_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fstat_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-
-	priv = this->private;
-	local = frame->local;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (fstat, frame, local->op_ret, local->op_errno,
-				  0, 0);
-		return 0;
-	}
-
-        STACK_WIND_COOKIE (frame, afr_fstat_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->fstat,
-                           local->fd, local->xdata_req);
-	return 0;
-}
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno, 0, 0);
+        return 0;
+    }
 
+    STACK_WIND_COOKIE(
+        frame, afr_fstat_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->fstat, local->fd, local->xdata_req);
+    return 0;
+}
 
 int32_t
-afr_fstat (call_frame_t *frame, xlator_t *this,
-           fd_t *fd, dict_t *xdata)
+afr_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	int op_errno = 0;
+    afr_local_t *local = NULL;
+    int op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_FSTAT;
-	local->fd = fd_ref (fd);
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_FSTAT;
+    local->fd = fd_ref(fd);
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_fstat_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_fstat_wind, AFR_DATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -344,1565 +329,1484 @@ out:
 /* {{{ readlink */
 
 int
-afr_readlink_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno,
-                  const char *buf, struct iatt *sbuf, dict_t *xdata)
+afr_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, const char *buf,
+                 struct iatt *sbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (readlink, frame, op_ret, op_errno,
-			  buf, sbuf, xdata);
-	return 0;
+    AFR_STACK_UNWIND(readlink, frame, op_ret, op_errno, buf, sbuf, xdata);
+    return 0;
 }
 
 int
-afr_readlink_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readlink_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (readlink, frame, local->op_ret,
-				  local->op_errno, 0, 0, 0);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_readlink_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->readlink,
-			   &local->loc, local->cont.readlink.size,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(readlink, frame, local->op_ret, local->op_errno, 0, 0,
+                         0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_readlink_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->readlink, &local->loc,
+                      local->cont.readlink.size, local->xdata_req);
+    return 0;
+}
 
 int
-afr_readlink (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, size_t size, dict_t *xdata)
+afr_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata)
 {
-        afr_local_t   * local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_READLINK;
-        loc_copy (&local->loc, loc);
-        local->cont.readlink.size = size;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_READLINK;
+    loc_copy(&local->loc, loc);
+    local->cont.readlink.size = size;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	afr_read_txn (frame, this, loc->inode, afr_readlink_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, loc->inode, afr_readlink_wind,
+                 AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND(readlink, frame, -1, op_errno, 0, 0, 0);
+    AFR_STACK_UNWIND(readlink, frame, -1, op_errno, 0, 0, 0);
 
-	return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ getxattr */
 
 struct _xattr_key {
-        char *key;
-        struct list_head list;
+    char *key;
+    struct list_head list;
 };
 
-
 int
-__gather_xattr_keys (dict_t *dict, char *key, data_t *value,
-                     void *data)
+__gather_xattr_keys(dict_t *dict, char *key, data_t *value, void *data)
 {
-        struct list_head *  list  = data;
-        struct _xattr_key * xkey  = NULL;
-
-        if (!strncmp (key, AFR_XATTR_PREFIX,
-                      SLEN (AFR_XATTR_PREFIX))) {
+    struct list_head *list = data;
+    struct _xattr_key *xkey = NULL;
 
-                xkey = GF_MALLOC (sizeof (*xkey), gf_afr_mt_xattr_key);
-                if (!xkey)
-                        return -1;
+    if (!strncmp(key, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX))) {
+        xkey = GF_MALLOC(sizeof(*xkey), gf_afr_mt_xattr_key);
+        if (!xkey)
+            return -1;
 
-                xkey->key = key;
-                INIT_LIST_HEAD (&xkey->list);
+        xkey->key = key;
+        INIT_LIST_HEAD(&xkey->list);
 
-                list_add_tail (&xkey->list, list);
-        }
-        return 0;
+        list_add_tail(&xkey->list, list);
+    }
+    return 0;
 }
 
-
 void
-afr_filter_xattrs (dict_t *dict)
+afr_filter_xattrs(dict_t *dict)
 {
-        struct list_head   keys = {0,};
-        struct _xattr_key *key  = NULL;
-        struct _xattr_key *tmp  = NULL;
+    struct list_head keys = {
+        0,
+    };
+    struct _xattr_key *key = NULL;
+    struct _xattr_key *tmp = NULL;
 
-        INIT_LIST_HEAD (&keys);
+    INIT_LIST_HEAD(&keys);
 
-        dict_foreach (dict, __gather_xattr_keys,
-                      (void *) &keys);
+    dict_foreach(dict, __gather_xattr_keys, (void *)&keys);
 
-        list_for_each_entry_safe (key, tmp, &keys, list) {
-                dict_del (dict, key->key);
+    list_for_each_entry_safe(key, tmp, &keys, list)
+    {
+        dict_del(dict, key->key);
 
-                list_del_init (&key->list);
+        list_del_init(&key->list);
 
-                GF_FREE (key);
-        }
+        GF_FREE(key);
+    }
 }
 
-static
-gf_boolean_t
-afr_getxattr_ignorable_errnos (int32_t op_errno)
+static gf_boolean_t
+afr_getxattr_ignorable_errnos(int32_t op_errno)
 {
-        if (op_errno == ENODATA || op_errno == ENOTSUP || op_errno == ERANGE ||
-            op_errno == ENAMETOOLONG)
-                return _gf_true;
+    if (op_errno == ENODATA || op_errno == ENOTSUP || op_errno == ERANGE ||
+        op_errno == ENAMETOOLONG)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 int
-afr_getxattr_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno,
-                  dict_t *dict, dict_t *xdata)
+afr_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0 && !afr_getxattr_ignorable_errnos(op_errno)) {
-		local->op_ret = op_ret;
-		local->op_errno = op_errno;
+    if (op_ret < 0 && !afr_getxattr_ignorable_errnos(op_errno)) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (dict)
-		afr_filter_xattrs (dict);
+    if (dict)
+        afr_filter_xattrs(dict);
 
-	AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
+    AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_getxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_getxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-				  local->op_errno, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_getxattr_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->getxattr,
-			   &local->loc, local->cont.getxattr.name,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
+
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno, NULL,
+                         NULL);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, afr_getxattr_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->getxattr, &local->loc,
+                      local->cont.getxattr.name, local->xdata_req);
+    return 0;
+}
 
 int32_t
-afr_getxattr_unwind (call_frame_t *frame, int op_ret, int op_errno,
-                     dict_t *dict, dict_t *xdata)
+afr_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno, dict_t *dict,
+                    dict_t *xdata)
 
 {
-        AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_clrlk_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *dict, dict_t *xdata)
+afr_fgetxattr_clrlk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *dict,
+                        dict_t *xdata)
 {
-        afr_local_t     *local                  = NULL;
-        afr_private_t   *priv                   = NULL;
-        xlator_t        **children              = NULL;
-        dict_t          *xattr                  = NULL;
-        char            *tmp_report             = NULL;
-        char            lk_summary[1024]        = {0,};
-        int             serz_len                = 0;
-        int32_t         callcnt                 = 0;
-        long int        cky                     = 0;
-        int             ret                     = 0;
-
-        priv     = this->private;
-        children = priv->children;
-
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret == -1)
-                        local->replies[cky].op_errno = op_errno;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (local->dict) {
-                        ret = dict_get_str (dict, local->cont.getxattr.name,
-                                            &tmp_report);
-                        if (ret)
-                                goto unlock;
-                        ret = dict_set_dynstr (local->dict,
-                                               children[cky]->name,
-                                               gf_strdup (tmp_report));
-                        if (ret)
-                                goto unlock;
-                }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    dict_t *xattr = NULL;
+    char *tmp_report = NULL;
+    char lk_summary[1024] = {
+        0,
+    };
+    int serz_len = 0;
+    int32_t callcnt = 0;
+    long int cky = 0;
+    int ret = 0;
+
+    priv = this->private;
+    children = priv->children;
+
+    local = frame->local;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret == -1)
+            local->replies[cky].op_errno = op_errno;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (local->dict) {
+            ret = dict_get_str(dict, local->cont.getxattr.name, &tmp_report);
+            if (ret)
+                goto unlock;
+            ret = dict_set_dynstr(local->dict, children[cky]->name,
+                                  gf_strdup(tmp_report));
+            if (ret)
+                goto unlock;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                xattr = dict_new ();
-                if (!xattr) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       lk_summary,
-                                                       &serz_len, '\n');
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                if (serz_len == -1)
-                        snprintf (lk_summary, sizeof (lk_summary),
-                                  "No locks cleared.");
-                ret = dict_set_dynstr (xattr, local->cont.getxattr.name,
-                                       gf_strdup (lk_summary));
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                ENOMEM, AFR_MSG_DICT_SET_FAILED,
-                                "Error setting dictionary");
-                        goto unwind;
-                }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        xattr = dict_new();
+        if (!xattr) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        ret = dict_serialize_value_with_delim(local->dict, lk_summary,
+                                              &serz_len, '\n');
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        if (serz_len == -1)
+            snprintf(lk_summary, sizeof(lk_summary), "No locks cleared.");
+        ret = dict_set_dynstr(xattr, local->cont.getxattr.name,
+                              gf_strdup(lk_summary));
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting dictionary");
+            goto unwind;
+        }
 
-                op_errno = afr_final_errno (local, priv);
+        op_errno = afr_final_errno(local, priv);
 
-unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, xattr,
-                                  xdata);
-                if (xattr)
-                        dict_unref (xattr);
-        }
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
+        if (xattr)
+            dict_unref(xattr);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_getxattr_clrlk_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this, int32_t op_ret, int32_t op_errno,
-                        dict_t *dict, dict_t *xdata)
+afr_getxattr_clrlk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        afr_local_t     *local                  = NULL;
-        afr_private_t   *priv                   = NULL;
-        xlator_t        **children              = NULL;
-        dict_t          *xattr                  = NULL;
-        char            *tmp_report             = NULL;
-        char            lk_summary[1024]        = {0,};
-        int             serz_len                = 0;
-        int32_t         callcnt                 = 0;
-        long int        cky                     = 0;
-        int             ret                     = 0;
-
-        priv     = this->private;
-        children = priv->children;
-
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret == -1)
-                        local->replies[cky].op_errno = op_errno;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (local->dict) {
-                        ret = dict_get_str (dict, local->cont.getxattr.name,
-                                            &tmp_report);
-                        if (ret)
-                                goto unlock;
-                        ret = dict_set_dynstr (local->dict,
-                                               children[cky]->name,
-                                               gf_strdup (tmp_report));
-                        if (ret)
-                                goto unlock;
-                }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t **children = NULL;
+    dict_t *xattr = NULL;
+    char *tmp_report = NULL;
+    char lk_summary[1024] = {
+        0,
+    };
+    int serz_len = 0;
+    int32_t callcnt = 0;
+    long int cky = 0;
+    int ret = 0;
+
+    priv = this->private;
+    children = priv->children;
+
+    local = frame->local;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret == -1)
+            local->replies[cky].op_errno = op_errno;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (local->dict) {
+            ret = dict_get_str(dict, local->cont.getxattr.name, &tmp_report);
+            if (ret)
+                goto unlock;
+            ret = dict_set_dynstr(local->dict, children[cky]->name,
+                                  gf_strdup(tmp_report));
+            if (ret)
+                goto unlock;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                xattr = dict_new ();
-                if (!xattr) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       lk_summary,
-                                                       &serz_len, '\n');
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        goto unwind;
-                }
-                if (serz_len == -1)
-                        snprintf (lk_summary, sizeof (lk_summary),
-                                  "No locks cleared.");
-                ret = dict_set_dynstr (xattr, local->cont.getxattr.name,
-                                       gf_strdup (lk_summary));
-                if (ret) {
-                        op_ret = -1;
-                        op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                ENOMEM, AFR_MSG_DICT_SET_FAILED,
-                                "Error setting dictionary");
-                        goto unwind;
-                }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        xattr = dict_new();
+        if (!xattr) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        ret = dict_serialize_value_with_delim(local->dict, lk_summary,
+                                              &serz_len, '\n');
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto unwind;
+        }
+        if (serz_len == -1)
+            snprintf(lk_summary, sizeof(lk_summary), "No locks cleared.");
+        ret = dict_set_dynstr(xattr, local->cont.getxattr.name,
+                              gf_strdup(lk_summary));
+        if (ret) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_DICT_SET_FAILED,
+                   "Error setting dictionary");
+            goto unwind;
+        }
 
-                op_errno = afr_final_errno (local, priv);
+        op_errno = afr_final_errno(local, priv);
 
-unwind:
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata);
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
-                if (xattr)
-                        dict_unref (xattr);
-        }
+        if (xattr)
+            dict_unref(xattr);
+    }
 
-        return ret;
+    return ret;
 }
 
 /**
  * node-uuid cbk uses next child querying mechanism
  */
 int32_t
-afr_getxattr_node_uuid_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_getxattr_node_uuid_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        afr_private_t  *priv            = NULL;
-        afr_local_t    *local           = NULL;
-        xlator_t      **children        = NULL;
-        int             unwind          = 1;
-        int             curr_call_child = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    xlator_t **children = NULL;
+    int unwind = 1;
+    int curr_call_child = 0;
 
-        priv = this->private;
-        children = priv->children;
+    priv = this->private;
+    children = priv->children;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret == -1) { /** query the _next_ child */
-
-                /**
-                 * _current_ becomes _next_
-                 * If done with all children and yet no success; give up !
-                 */
-                curr_call_child = (int) ((long)cookie);
-                if (++curr_call_child == priv->child_count)
-                        goto unwind;
-
-                gf_msg_debug (this->name, op_errno,
-                              "op_ret (-1): Re-querying afr-child (%d/%d)",
-                              curr_call_child, priv->child_count);
-
-                unwind = 0;
-                STACK_WIND_COOKIE (frame, afr_getxattr_node_uuid_cbk,
-                                   (void *) (long) curr_call_child,
-                                   children[curr_call_child],
-                                   children[curr_call_child]->fops->getxattr,
-                                   &local->loc,
-                                   local->cont.getxattr.name,
-                                   local->xdata_req);
-        }
+    if (op_ret == -1) { /** query the _next_ child */
 
- unwind:
-        if (unwind)
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict,
-                                  xdata);
+        /**
+         * _current_ becomes _next_
+         * If done with all children and yet no success; give up !
+         */
+        curr_call_child = (int)((long)cookie);
+        if (++curr_call_child == priv->child_count)
+            goto unwind;
+
+        gf_msg_debug(this->name, op_errno,
+                     "op_ret (-1): Re-querying afr-child (%d/%d)",
+                     curr_call_child, priv->child_count);
+
+        unwind = 0;
+        STACK_WIND_COOKIE(
+            frame, afr_getxattr_node_uuid_cbk, (void *)(long)curr_call_child,
+            children[curr_call_child],
+            children[curr_call_child]->fops->getxattr, &local->loc,
+            local->cont.getxattr.name, local->xdata_req);
+    }
 
-        return 0;
+unwind:
+    if (unwind)
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+
+    return 0;
 }
 
 /**
  * list-node-uuids cbk returns the list of node_uuids for the subvolume.
  */
 int32_t
-afr_getxattr_list_node_uuids_cbk (call_frame_t *frame, void *cookie,
-                                  xlator_t *this, int32_t op_ret,
-                                  int32_t op_errno, dict_t *dict, dict_t *xdata)
+afr_getxattr_list_node_uuids_cbk(call_frame_t *frame, void *cookie,
+                                 xlator_t *this, int32_t op_ret,
+                                 int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        afr_local_t    *local          = NULL;
-        afr_private_t  *priv           = NULL;
-        int32_t         callcnt        = 0;
-        int             ret            = 0;
-        char           *xattr_serz     = NULL;
-        long            cky            = 0;
-        int32_t         tlen           = 0;
-
-        local = frame->local;
-        priv = this->private;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                local->replies[cky].valid = 1;
-                local->replies[cky].op_ret = op_ret;
-                local->replies[cky].op_errno = op_errno;
-
-                if (op_ret < 0)
-                        goto unlock;
-
-                local->op_ret = 0;
-
-                if (!local->xdata_rsp && xdata)
-                                local->xdata_rsp = dict_ref (xdata);
-                local->replies[cky].xattr = dict_ref (dict);
-        }
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr_serz = NULL;
+    long cky = 0;
+    int32_t tlen = 0;
+
+    local = frame->local;
+    priv = this->private;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        local->replies[cky].valid = 1;
+        local->replies[cky].op_ret = op_ret;
+        local->replies[cky].op_errno = op_errno;
+
+        if (op_ret < 0)
+            goto unlock;
+
+        local->op_ret = 0;
+
+        if (!local->xdata_rsp && xdata)
+            local->xdata_rsp = dict_ref(xdata);
+        local->replies[cky].xattr = dict_ref(dict);
+    }
 
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
+    UNLOCK(&frame->lock);
 
-                if (local->op_ret != 0) {
-                        /* All bricks gave an error. */
-                        local->op_errno = afr_final_errno (local, priv);
-                        goto unwind;
-                }
+    if (!callcnt) {
+        if (local->op_ret != 0) {
+            /* All bricks gave an error. */
+            local->op_errno = afr_final_errno(local, priv);
+            goto unwind;
+        }
 
-                /*Since we store the UUID0_STR as node uuid for down bricks and
-                 *for non zero op_ret, assigning length to  priv->child_count
-                 *number of uuids*/
-                local->cont.getxattr.xattr_len = (SLEN (UUID0_STR) + 2) *
-                                                  priv->child_count;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-                if (!local->dict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+        /*Since we store the UUID0_STR as node uuid for down bricks and
+         *for non zero op_ret, assigning length to  priv->child_count
+         *number of uuids*/
+        local->cont.getxattr.xattr_len = (SLEN(UUID0_STR) + 2) *
+                                         priv->child_count;
+
+        if (!local->dict)
+            local->dict = dict_new();
+        if (!local->dict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                xattr_serz = GF_CALLOC (local->cont.getxattr.xattr_len,
-                                        sizeof (char), gf_common_mt_char);
+        xattr_serz = GF_CALLOC(local->cont.getxattr.xattr_len, sizeof(char),
+                               gf_common_mt_char);
 
-                if (!xattr_serz) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
-
-                ret = afr_serialize_xattrs_with_delimiter (frame, this,
-                                                           xattr_serz,
-                                                           UUID0_STR, &tlen,
-                                                           ' ');
-                if (ret) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
-                ret = dict_set_dynstr (local->dict,
-                                       GF_XATTR_LIST_NODE_UUIDS_KEY,
-                                       xattr_serz);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set node_uuid key in dict");
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        local->op_ret = local->cont.getxattr.xattr_len - 1;
-                        local->op_errno = 0;
-                }
+        if (!xattr_serz) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-unwind:
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->dict,
-                                  local->xdata_rsp);
+        ret = afr_serialize_xattrs_with_delimiter(frame, this, xattr_serz,
+                                                  UUID0_STR, &tlen, ' ');
+        if (ret) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
+        ret = dict_set_dynstr(local->dict, GF_XATTR_LIST_NODE_UUIDS_KEY,
+                              xattr_serz);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set node_uuid key in dict");
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        } else {
+            local->op_ret = local->cont.getxattr.xattr_len - 1;
+            local->op_errno = 0;
         }
 
-        return ret;
-}
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->dict, local->xdata_rsp);
+    }
 
+    return ret;
+}
 
 int32_t
-afr_getxattr_quota_size_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret, int32_t op_errno,
-                             dict_t *dict, dict_t *xdata)
+afr_getxattr_quota_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *dict,
+                            dict_t *xdata)
 {
-        int         idx         = (long) cookie;
-        int         call_count  = 0;
-        afr_local_t *local      = frame->local;
-        int         read_subvol = -1;
-
-        local->replies[idx].valid = 1;
-        local->replies[idx].op_ret = op_ret;
-        local->replies[idx].op_errno = op_errno;
-        if (dict)
-                local->replies[idx].xdata = dict_ref (dict);
-        call_count = afr_frame_return (frame);
-        if (call_count == 0) {
-                local->inode = inode_ref (local->loc.inode);
-                read_subvol = afr_handle_quota_size (frame, this);
-                if (read_subvol != -1) {
-                        op_ret = local->replies[read_subvol].op_ret;
-                        op_errno = local->replies[read_subvol].op_errno;
-                        dict = local->replies[read_subvol].xdata;
-                }
-                AFR_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict,
-                                  xdata);
+    int idx = (long)cookie;
+    int call_count = 0;
+    afr_local_t *local = frame->local;
+    int read_subvol = -1;
+
+    local->replies[idx].valid = 1;
+    local->replies[idx].op_ret = op_ret;
+    local->replies[idx].op_errno = op_errno;
+    if (dict)
+        local->replies[idx].xdata = dict_ref(dict);
+    call_count = afr_frame_return(frame);
+    if (call_count == 0) {
+        local->inode = inode_ref(local->loc.inode);
+        read_subvol = afr_handle_quota_size(frame, this);
+        if (read_subvol != -1) {
+            op_ret = local->replies[read_subvol].op_ret;
+            op_errno = local->replies[read_subvol].op_errno;
+            dict = local->replies[read_subvol].xdata;
         }
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_getxattr_lockinfo_cbk (call_frame_t *frame, void *cookie,
-                           xlator_t *this, int32_t op_ret, int32_t op_errno,
-                           dict_t *dict, dict_t *xdata)
+afr_getxattr_lockinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *dict,
+                          dict_t *xdata)
 {
-        int          call_cnt     = 0, len = 0;
-        char        *lockinfo_buf = NULL;
-        dict_t      *lockinfo     = NULL, *newdict = NULL;
-        afr_local_t *local        = NULL;
+    int call_cnt = 0, len = 0;
+    char *lockinfo_buf = NULL;
+    dict_t *lockinfo = NULL, *newdict = NULL;
+    afr_local_t *local = NULL;
 
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
-
-                call_cnt = --local->call_count;
+    LOCK(&frame->lock);
+    {
+        local = frame->local;
 
-                if ((op_ret < 0) || (!dict && !xdata)) {
-                        goto unlock;
-                }
+        call_cnt = --local->call_count;
 
-                if (xdata) {
-                        if (!local->xdata_rsp) {
-                                local->xdata_rsp = dict_new ();
-                                if (!local->xdata_rsp) {
-                                        local->op_ret = -1;
-                                        local->op_errno = ENOMEM;
-                                        goto unlock;
-                                }
-                        }
-                }
+        if ((op_ret < 0) || (!dict && !xdata)) {
+            goto unlock;
+        }
 
-                if (!dict) {
-                        goto unlock;
+        if (xdata) {
+            if (!local->xdata_rsp) {
+                local->xdata_rsp = dict_new();
+                if (!local->xdata_rsp) {
+                    local->op_ret = -1;
+                    local->op_errno = ENOMEM;
+                    goto unlock;
                 }
+            }
+        }
 
-                op_ret = dict_get_ptr_and_len (dict, GF_XATTR_LOCKINFO_KEY,
-                                               (void **)&lockinfo_buf, &len);
+        if (!dict) {
+            goto unlock;
+        }
 
-                if (!lockinfo_buf) {
-                        goto unlock;
-                }
+        op_ret = dict_get_ptr_and_len(dict, GF_XATTR_LOCKINFO_KEY,
+                                      (void **)&lockinfo_buf, &len);
 
-                if (!local->dict) {
-                        local->dict = dict_new ();
-                        if (!local->dict) {
-                                local->op_ret = -1;
-                                local->op_errno = ENOMEM;
-                                goto unlock;
-                        }
-                }
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (lockinfo_buf != NULL) {
-                lockinfo = dict_new ();
-                if (lockinfo == NULL) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        op_ret = dict_unserialize (lockinfo_buf, len,
-                                                   &lockinfo);
-
-                        if (lockinfo && local->dict) {
-                                dict_copy (lockinfo, local->dict);
-                        }
-                }
+        if (!lockinfo_buf) {
+            goto unlock;
         }
 
-        if (xdata && local->xdata_rsp) {
-                dict_copy (xdata, local->xdata_rsp);
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict) {
+                local->op_ret = -1;
+                local->op_errno = ENOMEM;
+                goto unlock;
+            }
         }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!call_cnt) {
-                newdict = dict_new ();
-                if (!newdict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+    if (lockinfo_buf != NULL) {
+        lockinfo = dict_new();
+        if (lockinfo == NULL) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        } else {
+            op_ret = dict_unserialize(lockinfo_buf, len, &lockinfo);
 
-                len = dict_serialized_length (local->dict);
-                if (len <= 0) {
-                        goto unwind;
-                }
+            if (lockinfo && local->dict) {
+                dict_copy(lockinfo, local->dict);
+            }
+        }
+    }
+
+    if (xdata && local->xdata_rsp) {
+        dict_copy(xdata, local->xdata_rsp);
+    }
+
+    if (!call_cnt) {
+        newdict = dict_new();
+        if (!newdict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                lockinfo_buf = GF_CALLOC (1, len, gf_common_mt_char);
-                if (!lockinfo_buf) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+        len = dict_serialized_length(local->dict);
+        if (len <= 0) {
+            goto unwind;
+        }
 
-                op_ret = dict_serialize (local->dict, lockinfo_buf);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                }
+        lockinfo_buf = GF_CALLOC(1, len, gf_common_mt_char);
+        if (!lockinfo_buf) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                op_ret = dict_set_dynptr (newdict, GF_XATTR_LOCKINFO_KEY,
-                                          (void *)lockinfo_buf, len);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                        goto unwind;
-                }
+        op_ret = dict_serialize(local->dict, lockinfo_buf);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (getxattr, frame, op_ret,
-                                  op_errno, newdict,
-                                  local->xdata_rsp);
+        op_ret = dict_set_dynptr(newdict, GF_XATTR_LOCKINFO_KEY,
+                                 (void *)lockinfo_buf, len);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+            goto unwind;
         }
 
-        dict_unref (lockinfo);
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, op_ret, op_errno, newdict,
+                         local->xdata_rsp);
+    }
 
-        return 0;
+    dict_unref(lockinfo);
+
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_lockinfo_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_fgetxattr_lockinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        int          call_cnt     = 0, len = 0;
-        char        *lockinfo_buf = NULL;
-        dict_t      *lockinfo     = NULL, *newdict = NULL;
-        afr_local_t *local        = NULL;
+    int call_cnt = 0, len = 0;
+    char *lockinfo_buf = NULL;
+    dict_t *lockinfo = NULL, *newdict = NULL;
+    afr_local_t *local = NULL;
 
-        LOCK (&frame->lock);
-        {
-                local = frame->local;
-
-                call_cnt = --local->call_count;
+    LOCK(&frame->lock);
+    {
+        local = frame->local;
 
-                if ((op_ret < 0) || (!dict && !xdata)) {
-                        goto unlock;
-                }
+        call_cnt = --local->call_count;
 
-                if (xdata) {
-                        if (!local->xdata_rsp) {
-                                local->xdata_rsp = dict_new ();
-                                if (!local->xdata_rsp) {
-                                        local->op_ret = -1;
-                                        local->op_errno = ENOMEM;
-                                        goto unlock;
-                                }
-                        }
-                }
+        if ((op_ret < 0) || (!dict && !xdata)) {
+            goto unlock;
+        }
 
-                if (!dict) {
-                        goto unlock;
+        if (xdata) {
+            if (!local->xdata_rsp) {
+                local->xdata_rsp = dict_new();
+                if (!local->xdata_rsp) {
+                    local->op_ret = -1;
+                    local->op_errno = ENOMEM;
+                    goto unlock;
                 }
+            }
+        }
 
-                op_ret = dict_get_ptr_and_len (dict, GF_XATTR_LOCKINFO_KEY,
-                                               (void **)&lockinfo_buf, &len);
+        if (!dict) {
+            goto unlock;
+        }
 
-                if (!lockinfo_buf) {
-                        goto unlock;
-                }
+        op_ret = dict_get_ptr_and_len(dict, GF_XATTR_LOCKINFO_KEY,
+                                      (void **)&lockinfo_buf, &len);
 
-                if (!local->dict) {
-                        local->dict = dict_new ();
-                        if (!local->dict) {
-                                local->op_ret = -1;
-                                local->op_errno = ENOMEM;
-                                goto unlock;
-                        }
-                }
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-        if (lockinfo_buf != NULL) {
-                lockinfo = dict_new ();
-                if (lockinfo == NULL) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                } else {
-                        op_ret = dict_unserialize (lockinfo_buf, len,
-                                                   &lockinfo);
-
-                        if (lockinfo && local->dict) {
-                                dict_copy (lockinfo, local->dict);
-                        }
-                }
+        if (!lockinfo_buf) {
+            goto unlock;
         }
 
-        if (xdata && local->xdata_rsp) {
-                dict_copy (xdata, local->xdata_rsp);
+        if (!local->dict) {
+            local->dict = dict_new();
+            if (!local->dict) {
+                local->op_ret = -1;
+                local->op_errno = ENOMEM;
+                goto unlock;
+            }
         }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!call_cnt) {
-                newdict = dict_new ();
-                if (!newdict) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+    if (lockinfo_buf != NULL) {
+        lockinfo = dict_new();
+        if (lockinfo == NULL) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+        } else {
+            op_ret = dict_unserialize(lockinfo_buf, len, &lockinfo);
 
-                len = dict_serialized_length (local->dict);
-                if (len <= 0) {
-                        goto unwind;
-                }
+            if (lockinfo && local->dict) {
+                dict_copy(lockinfo, local->dict);
+            }
+        }
+    }
+
+    if (xdata && local->xdata_rsp) {
+        dict_copy(xdata, local->xdata_rsp);
+    }
+
+    if (!call_cnt) {
+        newdict = dict_new();
+        if (!newdict) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                lockinfo_buf = GF_CALLOC (1, len, gf_common_mt_char);
-                if (!lockinfo_buf) {
-                        local->op_ret = -1;
-                        local->op_errno = ENOMEM;
-                        goto unwind;
-                }
+        len = dict_serialized_length(local->dict);
+        if (len <= 0) {
+            goto unwind;
+        }
 
-                op_ret = dict_serialize (local->dict, lockinfo_buf);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                }
+        lockinfo_buf = GF_CALLOC(1, len, gf_common_mt_char);
+        if (!lockinfo_buf) {
+            local->op_ret = -1;
+            local->op_errno = ENOMEM;
+            goto unwind;
+        }
 
-                op_ret = dict_set_dynptr (newdict, GF_XATTR_LOCKINFO_KEY,
-                                          (void *)lockinfo_buf, len);
-                if (op_ret < 0) {
-                        local->op_ret = -1;
-                        local->op_errno = -op_ret;
-                        goto unwind;
-                }
+        op_ret = dict_serialize(local->dict, lockinfo_buf);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+        }
 
-        unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, op_ret,
-                                  op_errno, newdict,
-                                  local->xdata_rsp);
+        op_ret = dict_set_dynptr(newdict, GF_XATTR_LOCKINFO_KEY,
+                                 (void *)lockinfo_buf, len);
+        if (op_ret < 0) {
+            local->op_ret = -1;
+            local->op_errno = -op_ret;
+            goto unwind;
         }
 
-        dict_unref (lockinfo);
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, newdict,
+                         local->xdata_rsp);
+    }
 
-        return 0;
+    dict_unref(lockinfo);
+
+    return 0;
 }
 
 int32_t
-afr_fgetxattr_pathinfo_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *dict, dict_t *xdata)
+afr_fgetxattr_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
-        int          ret            = 0;
-        char        *xattr          = NULL;
-        char        *xattr_serz     = NULL;
-        char        xattr_cky[1024] = {0,};
-        dict_t      *nxattr         = NULL;
-        long         cky            = 0;
-        int32_t      padding        = 0;
-        int32_t      tlen           = 0;
-
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr = NULL;
+    char *xattr_serz = NULL;
+    char xattr_cky[1024] = {
+        0,
+    };
+    dict_t *nxattr = NULL;
+    long cky = 0;
+    int32_t padding = 0;
+    int32_t tlen = 0;
+
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
+
+    local = frame->local;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret < 0) {
+            local->op_errno = op_errno;
+        } else {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
 
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret < 0) {
-                        local->op_errno = op_errno;
-                } else {
-                        local->op_ret = op_ret;
-                        if (!local->xdata_rsp && xdata)
-                                local->xdata_rsp = dict_ref (xdata);
-                }
+        if (!dict || (op_ret < 0))
+            goto unlock;
 
-                if (!dict || (op_ret < 0))
-                        goto unlock;
-
-                if (!local->dict)
-                        local->dict = dict_new ();
-
-                if (local->dict) {
-                        ret = dict_get_str (dict,
-                                            local->cont.getxattr.name,
-                                            &xattr);
-                        if (ret)
-                                goto unlock;
-
-                        xattr = gf_strdup (xattr);
-
-                        (void)snprintf (xattr_cky, sizeof(xattr_cky), "%s-%ld",
-                                        local->cont.getxattr.name, cky);
-                        ret = dict_set_dynstr (local->dict,
-                                               xattr_cky, xattr);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR,
-                                        -ret, AFR_MSG_DICT_SET_FAILED,
-                                        "Cannot set xattr cookie key");
-                                goto unlock;
-                        }
-
-                        local->cont.getxattr.xattr_len
-                                += strlen (xattr) + 1;
-                }
+        if (!local->dict)
+            local->dict = dict_new();
+
+        if (local->dict) {
+            ret = dict_get_str(dict, local->cont.getxattr.name, &xattr);
+            if (ret)
+                goto unlock;
+
+            xattr = gf_strdup(xattr);
+
+            (void)snprintf(xattr_cky, sizeof(xattr_cky), "%s-%ld",
+                           local->cont.getxattr.name, cky);
+            ret = dict_set_dynstr(local->dict, xattr_cky, xattr);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                       "Cannot set xattr cookie key");
+                goto unlock;
+            }
+
+            local->cont.getxattr.xattr_len += strlen(xattr) + 1;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (!local->cont.getxattr.xattr_len)
-                        goto unwind;
-
-                nxattr = dict_new ();
-                if (!nxattr)
-                        goto unwind;
-
-                /* extra bytes for decorations (brackets and <>'s) */
-                padding += strlen (this->name)
-                        + SLEN (AFR_PATHINFO_HEADER) + 4;
-                local->cont.getxattr.xattr_len += (padding + 2);
-
-                xattr_serz = GF_MALLOC (local->cont.getxattr.xattr_len,
-                                        gf_common_mt_char);
-
-                if (!xattr_serz)
-                        goto unwind;
-
-                /* the xlator info */
-                int xattr_serz_len = sprintf (xattr_serz,
-                                              "(<"AFR_PATHINFO_HEADER"%s> ",
-                                              this->name);
-
-                /* actual series of pathinfo */
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       xattr_serz
-                                                       + xattr_serz_len,
-                                                       &tlen, ' ');
-                if (ret) {
-                        goto unwind;
-                }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        if (!local->cont.getxattr.xattr_len)
+            goto unwind;
 
-                /* closing part */
-                *(xattr_serz + padding + tlen) = ')';
-                *(xattr_serz + padding + tlen + 1) = '\0';
+        nxattr = dict_new();
+        if (!nxattr)
+            goto unwind;
 
-                ret = dict_set_dynstr (nxattr, local->cont.getxattr.name,
-                                       xattr_serz);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set pathinfo key in dict");
+        /* extra bytes for decorations (brackets and <>'s) */
+        padding += strlen(this->name) + SLEN(AFR_PATHINFO_HEADER) + 4;
+        local->cont.getxattr.xattr_len += (padding + 2);
 
-        unwind:
-                AFR_STACK_UNWIND (fgetxattr, frame, local->op_ret,
-                                  local->op_errno, nxattr, local->xdata_rsp);
+        xattr_serz = GF_MALLOC(local->cont.getxattr.xattr_len,
+                               gf_common_mt_char);
 
-                if (nxattr)
-                        dict_unref (nxattr);
+        if (!xattr_serz)
+            goto unwind;
+
+        /* the xlator info */
+        int xattr_serz_len = sprintf(
+            xattr_serz, "(<" AFR_PATHINFO_HEADER "%s> ", this->name);
+
+        /* actual series of pathinfo */
+        ret = dict_serialize_value_with_delim(
+            local->dict, xattr_serz + xattr_serz_len, &tlen, ' ');
+        if (ret) {
+            goto unwind;
         }
 
+        /* closing part */
+        *(xattr_serz + padding + tlen) = ')';
+        *(xattr_serz + padding + tlen + 1) = '\0';
+
+        ret = dict_set_dynstr(nxattr, local->cont.getxattr.name, xattr_serz);
+        if (ret)
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set pathinfo key in dict");
+
+    unwind:
+        AFR_STACK_UNWIND(fgetxattr, frame, local->op_ret, local->op_errno,
+                         nxattr, local->xdata_rsp);
+
+        if (nxattr)
+            dict_unref(nxattr);
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_getxattr_pathinfo_cbk (call_frame_t *frame, void *cookie,
-                           xlator_t *this, int32_t op_ret, int32_t op_errno,
-                           dict_t *dict, dict_t *xdata)
+afr_getxattr_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *dict,
+                          dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
-        int          ret            = 0;
-        char        *xattr          = NULL;
-        char        *xattr_serz     = NULL;
-        char        xattr_cky[1024] = {0,};
-        dict_t      *nxattr         = NULL;
-        long         cky            = 0;
-        int32_t      padding        = 0;
-        int32_t      tlen           = 0;
-
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
+    int ret = 0;
+    char *xattr = NULL;
+    char *xattr_serz = NULL;
+    char xattr_cky[1024] = {
+        0,
+    };
+    dict_t *nxattr = NULL;
+    long cky = 0;
+    int32_t padding = 0;
+    int32_t tlen = 0;
+
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
+
+    local = frame->local;
+    cky = (long)cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret < 0) {
+            local->op_errno = op_errno;
+        } else {
+            local->op_ret = op_ret;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
 
-        local = frame->local;
-        cky = (long) cookie;
-
-        LOCK (&frame->lock);
-                {
-                        callcnt = --local->call_count;
-
-                        if (op_ret < 0) {
-                                local->op_errno = op_errno;
-                        } else {
-                                local->op_ret = op_ret;
-                                if (!local->xdata_rsp && xdata)
-                                        local->xdata_rsp = dict_ref (xdata);
-                        }
-
-                        if (!dict || (op_ret < 0))
-                                goto unlock;
-
-                        if (!local->dict)
-                                local->dict = dict_new ();
-
-                        if (local->dict) {
-                                ret = dict_get_str (dict,
-                                                    local->cont.getxattr.name,
-                                                    &xattr);
-                                if (ret)
-                                        goto unlock;
-
-                                xattr = gf_strdup (xattr);
-
-                                (void)snprintf (xattr_cky, 1024, "%s-%ld",
-                                                local->cont.getxattr.name, cky);
-                                ret = dict_set_dynstr (local->dict,
-                                                       xattr_cky, xattr);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                -ret,
-                                                AFR_MSG_DICT_SET_FAILED,
-                                                "Cannot set xattr "
-                                                "cookie key");
-                                        goto unlock;
-                                }
-
-                                local->cont.getxattr.xattr_len += strlen (xattr) + 1;
-                        }
-                }
-unlock:
-        UNLOCK (&frame->lock);
+        if (!dict || (op_ret < 0))
+            goto unlock;
+
+        if (!local->dict)
+            local->dict = dict_new();
 
-        if (!callcnt) {
-                if (!local->cont.getxattr.xattr_len)
-                        goto unwind;
+        if (local->dict) {
+            ret = dict_get_str(dict, local->cont.getxattr.name, &xattr);
+            if (ret)
+                goto unlock;
 
-                nxattr = dict_new ();
-                if (!nxattr)
-                        goto unwind;
+            xattr = gf_strdup(xattr);
 
-                /* extra bytes for decorations (brackets and <>'s) */
-                padding += strlen (this->name) + SLEN (AFR_PATHINFO_HEADER) + 4;
-                local->cont.getxattr.xattr_len += (padding + 2);
+            (void)snprintf(xattr_cky, 1024, "%s-%ld", local->cont.getxattr.name,
+                           cky);
+            ret = dict_set_dynstr(local->dict, xattr_cky, xattr);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                       "Cannot set xattr "
+                       "cookie key");
+                goto unlock;
+            }
 
-                xattr_serz = GF_MALLOC (local->cont.getxattr.xattr_len,
-                                        gf_common_mt_char);
+            local->cont.getxattr.xattr_len += strlen(xattr) + 1;
+        }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-                if (!xattr_serz)
-                        goto unwind;
+    if (!callcnt) {
+        if (!local->cont.getxattr.xattr_len)
+            goto unwind;
 
-                /* the xlator info */
-                int xattr_serz_len = sprintf (xattr_serz,
-                                              "(<"AFR_PATHINFO_HEADER"%s> ",
-                                              this->name);
+        nxattr = dict_new();
+        if (!nxattr)
+            goto unwind;
 
-                /* actual series of pathinfo */
-                ret = dict_serialize_value_with_delim (local->dict,
-                                                       xattr_serz + xattr_serz_len,
-                                                       &tlen, ' ');
-                if (ret) {
-                        goto unwind;
-                }
+        /* extra bytes for decorations (brackets and <>'s) */
+        padding += strlen(this->name) + SLEN(AFR_PATHINFO_HEADER) + 4;
+        local->cont.getxattr.xattr_len += (padding + 2);
 
-                /* closing part */
-                *(xattr_serz + padding + tlen) = ')';
-                *(xattr_serz + padding + tlen + 1) = '\0';
+        xattr_serz = GF_MALLOC(local->cont.getxattr.xattr_len,
+                               gf_common_mt_char);
 
-                ret = dict_set_dynstr (nxattr, local->cont.getxattr.name,
-                                       xattr_serz);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "Cannot set pathinfo key in dict");
+        if (!xattr_serz)
+            goto unwind;
 
-        unwind:
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, nxattr, local->xdata_rsp);
+        /* the xlator info */
+        int xattr_serz_len = sprintf(
+            xattr_serz, "(<" AFR_PATHINFO_HEADER "%s> ", this->name);
 
-                if (nxattr)
-                        dict_unref (nxattr);
+        /* actual series of pathinfo */
+        ret = dict_serialize_value_with_delim(
+            local->dict, xattr_serz + xattr_serz_len, &tlen, ' ');
+        if (ret) {
+            goto unwind;
         }
 
+        /* closing part */
+        *(xattr_serz + padding + tlen) = ')';
+        *(xattr_serz + padding + tlen + 1) = '\0';
+
+        ret = dict_set_dynstr(nxattr, local->cont.getxattr.name, xattr_serz);
+        if (ret)
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "Cannot set pathinfo key in dict");
+
+    unwind:
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         nxattr, local->xdata_rsp);
+
+        if (nxattr)
+            dict_unref(nxattr);
+    }
+
 out:
-        return ret;
+    return ret;
 }
 
 static int
-afr_aggregate_stime_xattr (dict_t *this, char *key, data_t *value, void *data)
+afr_aggregate_stime_xattr(dict_t *this, char *key, data_t *value, void *data)
 {
-        int ret = 0;
+    int ret = 0;
 
-        if (fnmatch (GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0)
-                ret = gf_get_max_stime (THIS, data, key, value);
+    if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0)
+        ret = gf_get_max_stime(THIS, data, key, value);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_common_getxattr_stime_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this, int32_t op_ret, int32_t op_errno,
-                               dict_t *dict, dict_t *xdata)
+afr_common_getxattr_stime_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno, dict_t *dict,
+                              dict_t *xdata)
 {
-        afr_local_t *local          = NULL;
-        int32_t      callcnt        = 0;
-
-        if (!frame || !frame->local || !this) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "possible NULL deref");
-                goto out;
-        }
+    afr_local_t *local = NULL;
+    int32_t callcnt = 0;
 
-        local = frame->local;
+    if (!frame || !frame->local || !this) {
+        gf_msg("", GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG, "possible NULL deref");
+        goto out;
+    }
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
+    local = frame->local;
 
-                if (!dict || (op_ret < 0)) {
-                        local->op_errno = op_errno;
-                        goto cleanup;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (!local->dict)
-                        local->dict = dict_copy_with_ref (dict, NULL);
-                else
-                        dict_foreach (dict, afr_aggregate_stime_xattr,
-                                      local->dict);
-                local->op_ret = 0;
+        if (!dict || (op_ret < 0)) {
+            local->op_errno = op_errno;
+            goto cleanup;
         }
 
+        if (!local->dict)
+            local->dict = dict_copy_with_ref(dict, NULL);
+        else
+            dict_foreach(dict, afr_aggregate_stime_xattr, local->dict);
+        local->op_ret = 0;
+    }
+
 cleanup:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                AFR_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->dict, xdata);
-        }
+    if (!callcnt) {
+        AFR_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->dict, xdata);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 static gf_boolean_t
-afr_is_special_xattr (const char *name, fop_getxattr_cbk_t *cbk,
-                      gf_boolean_t is_fgetxattr)
+afr_is_special_xattr(const char *name, fop_getxattr_cbk_t *cbk,
+                     gf_boolean_t is_fgetxattr)
 {
-        gf_boolean_t    is_spl = _gf_true;
-
-        GF_ASSERT (cbk);
-        if (!cbk || !name) {
-                is_spl = _gf_false;
-                goto out;
+    gf_boolean_t is_spl = _gf_true;
+
+    GF_ASSERT(cbk);
+    if (!cbk || !name) {
+        is_spl = _gf_false;
+        goto out;
+    }
+
+    if (!strcmp(name, GF_XATTR_PATHINFO_KEY) ||
+        !strcmp(name, GF_XATTR_USER_PATHINFO_KEY)) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_pathinfo_cbk;
+        } else {
+            *cbk = afr_getxattr_pathinfo_cbk;
         }
-
-        if (!strcmp (name, GF_XATTR_PATHINFO_KEY) ||
-	    !strcmp (name, GF_XATTR_USER_PATHINFO_KEY)) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_pathinfo_cbk;
-                } else {
-                        *cbk = afr_getxattr_pathinfo_cbk;
-                }
-        } else if (!strncmp (name, GF_XATTR_CLRLK_CMD,
-                             SLEN (GF_XATTR_CLRLK_CMD))) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_clrlk_cbk;
-                } else {
-                        *cbk = afr_getxattr_clrlk_cbk;
-                }
-        } else if (!strncmp (name, GF_XATTR_LOCKINFO_KEY,
-                             SLEN (GF_XATTR_LOCKINFO_KEY))) {
-                if (is_fgetxattr) {
-                        *cbk = afr_fgetxattr_lockinfo_cbk;
-                } else {
-                        *cbk = afr_getxattr_lockinfo_cbk;
-                }
-        } else if (fnmatch (GF_XATTR_STIME_PATTERN, name, FNM_NOESCAPE) == 0) {
-                *cbk = afr_common_getxattr_stime_cbk;
-        } else if (strcmp (name, QUOTA_SIZE_KEY) == 0) {
-                *cbk = afr_getxattr_quota_size_cbk;
-        } else if (!strcmp (name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
-                *cbk = afr_getxattr_list_node_uuids_cbk;
+    } else if (!strncmp(name, GF_XATTR_CLRLK_CMD, SLEN(GF_XATTR_CLRLK_CMD))) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_clrlk_cbk;
+        } else {
+            *cbk = afr_getxattr_clrlk_cbk;
+        }
+    } else if (!strncmp(name, GF_XATTR_LOCKINFO_KEY,
+                        SLEN(GF_XATTR_LOCKINFO_KEY))) {
+        if (is_fgetxattr) {
+            *cbk = afr_fgetxattr_lockinfo_cbk;
         } else {
-                is_spl = _gf_false;
+            *cbk = afr_getxattr_lockinfo_cbk;
         }
+    } else if (fnmatch(GF_XATTR_STIME_PATTERN, name, FNM_NOESCAPE) == 0) {
+        *cbk = afr_common_getxattr_stime_cbk;
+    } else if (strcmp(name, QUOTA_SIZE_KEY) == 0) {
+        *cbk = afr_getxattr_quota_size_cbk;
+    } else if (!strcmp(name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
+        *cbk = afr_getxattr_list_node_uuids_cbk;
+    } else {
+        is_spl = _gf_false;
+    }
 
 out:
-        return is_spl;
+    return is_spl;
 }
 
 static void
-afr_getxattr_all_subvols (xlator_t *this, call_frame_t *frame,
-			  const char *name, loc_t *loc,
-			  fop_getxattr_cbk_t cbk)
+afr_getxattr_all_subvols(xlator_t *this, call_frame_t *frame, const char *name,
+                         loc_t *loc, fop_getxattr_cbk_t cbk)
 {
-        afr_private_t   *priv           = NULL;
-        afr_local_t     *local          = NULL;
-        int             i               = 0;
-        int             call_count      = 0;
-
-        priv     = this->private;
-
-        local = frame->local;
-        //local->call_count set in afr_local_init
-        call_count = local->call_count;
-
-        if (!strcmp (name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
-                GF_FREE (local->cont.getxattr.name);
-                local->cont.getxattr.name = gf_strdup (GF_XATTR_NODE_UUID_KEY);
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+
+    priv = this->private;
+
+    local = frame->local;
+    // local->call_count set in afr_local_init
+    call_count = local->call_count;
+
+    if (!strcmp(name, GF_XATTR_LIST_NODE_UUIDS_KEY)) {
+        GF_FREE(local->cont.getxattr.name);
+        local->cont.getxattr.name = gf_strdup(GF_XATTR_NODE_UUID_KEY);
+    }
+
+    // If up-children count is 0, afr_local_init would have failed already
+    // and the call would have unwound so not handling it here.
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, cbk, (void *)(long)i, priv->children[i],
+                              priv->children[i]->fops->getxattr, loc,
+                              local->cont.getxattr.name, NULL);
+            if (!--call_count)
+                break;
         }
-
-        //If up-children count is 0, afr_local_init would have failed already
-        //and the call would have unwound so not handling it here.
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, cbk,
-                                           (void *) (long) i, priv->children[i],
-                                           priv->children[i]->fops->getxattr,
-                                           loc, local->cont.getxattr.name,
-                                           NULL);
-                        if (!--call_count)
-                                break;
-                }
-        }
-        return;
+    }
+    return;
 }
 
 int
-afr_marker_populate_args (call_frame_t *frame, int type, int *gauge,
-                          xlator_t **subvols)
+afr_marker_populate_args(call_frame_t *frame, int type, int *gauge,
+                         xlator_t **subvols)
 {
-        xlator_t *this = frame->this;
-        afr_private_t *priv = this->private;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
 
-        memcpy (subvols, priv->children, sizeof (*subvols) * priv->child_count);
+    memcpy(subvols, priv->children, sizeof(*subvols) * priv->child_count);
 
-        if (type == MARKER_XTIME_TYPE) {
-                /*Don't error out on ENOENT/ENOTCONN */
-                gauge[MCNT_NOTFOUND] = 0;
-                gauge[MCNT_ENOTCONN] = 0;
-        }
-        return priv->child_count;
+    if (type == MARKER_XTIME_TYPE) {
+        /*Don't error out on ENOENT/ENOTCONN */
+        gauge[MCNT_NOTFOUND] = 0;
+        gauge[MCNT_ENOTCONN] = 0;
+    }
+    return priv->child_count;
 }
 
 static int
-afr_handle_heal_xattrs (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                        const char *heal_op)
+afr_handle_heal_xattrs(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                       const char *heal_op)
 {
-        int                     ret     = -1;
-        afr_spb_status_t       *data    = NULL;
+    int ret = -1;
+    afr_spb_status_t *data = NULL;
 
-        if (!strcmp (heal_op, GF_HEAL_INFO)) {
-                afr_get_heal_info (frame, this, loc);
-                ret = 0;
-                goto out;
-        }
+    if (!strcmp(heal_op, GF_HEAL_INFO)) {
+        afr_get_heal_info(frame, this, loc);
+        ret = 0;
+        goto out;
+    }
 
-        if (!strcmp (heal_op, GF_AFR_HEAL_SBRAIN)) {
-                afr_heal_splitbrain_file (frame, this, loc);
-                ret = 0;
-                goto out;
+    if (!strcmp(heal_op, GF_AFR_HEAL_SBRAIN)) {
+        afr_heal_splitbrain_file(frame, this, loc);
+        ret = 0;
+        goto out;
+    }
+
+    if (!strcmp(heal_op, GF_AFR_SBRAIN_STATUS)) {
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_spb_status_t);
+        if (!data) {
+            ret = 1;
+            goto out;
         }
-
-        if (!strcmp (heal_op, GF_AFR_SBRAIN_STATUS)) {
-                data = GF_CALLOC (1, sizeof (*data), gf_afr_mt_spb_status_t);
-                if (!data) {
-                        ret = 1;
-                        goto out;
-                }
-                data->frame = frame;
-                data->loc = loc;
-                ret = synctask_new (this->ctx->env,
-                                    afr_get_split_brain_status,
-                                    afr_get_split_brain_status_cbk,
-                                    NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_STATUS,
-                                "Failed to create"
-                                " synctask. Unable to fetch split-brain status"
-                                " for %s.", loc->name);
-                        ret = 1;
-                        goto out;
-                }
-                goto out;
+        data->frame = frame;
+        data->loc = loc;
+        ret = synctask_new(this->ctx->env, afr_get_split_brain_status,
+                           afr_get_split_brain_status_cbk, NULL, data);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN_STATUS,
+                   "Failed to create"
+                   " synctask. Unable to fetch split-brain status"
+                   " for %s.",
+                   loc->name);
+            ret = 1;
+            goto out;
         }
+        goto out;
+    }
 
 out:
-        if (ret == 1) {
-                AFR_STACK_UNWIND (getxattr, frame, -1, ENOMEM, NULL, NULL);
-                if (data)
-                        GF_FREE (data);
-                ret = 0;
-        }
-        return ret;
+    if (ret == 1) {
+        AFR_STACK_UNWIND(getxattr, frame, -1, ENOMEM, NULL, NULL);
+        if (data)
+            GF_FREE(data);
+        ret = 0;
+    }
+    return ret;
 }
 
 int32_t
-afr_getxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, const char *name, dict_t *xdata)
+afr_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+             dict_t *xdata)
 {
-        afr_private_t           *priv         = NULL;
-        afr_local_t             *local        = NULL;
-        xlator_t                **children    = NULL;
-        int                     i             = 0;
-        int32_t                 op_errno      = 0;
-        int                     ret           = -1;
-        fop_getxattr_cbk_t      cbk           = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    xlator_t **children = NULL;
+    int i = 0;
+    int32_t op_errno = 0;
+    int ret = -1;
+    fop_getxattr_cbk_t cbk = NULL;
 
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    priv = this->private;
 
-        priv     = this->private;
+    children = priv->children;
 
-        children = priv->children;
+    loc_copy(&local->loc, loc);
 
-        loc_copy (&local->loc, loc);
+    local->op = GF_FOP_GETXATTR;
 
-	local->op = GF_FOP_GETXATTR;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    if (!name)
+        goto no_name;
 
-        if (!name)
-                goto no_name;
+    local->cont.getxattr.name = gf_strdup(name);
 
-        local->cont.getxattr.name = gf_strdup (name);
+    if (!local->cont.getxattr.name) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	if (!local->cont.getxattr.name) {
-		op_errno = ENOMEM;
-		goto out;
-	}
-
-        if (!strncmp (name, AFR_XATTR_PREFIX,
-                      SLEN (AFR_XATTR_PREFIX))) {
-                op_errno = ENODATA;
-                goto out;
-        }
+    if (!strncmp(name, AFR_XATTR_PREFIX, SLEN(AFR_XATTR_PREFIX))) {
+        op_errno = ENODATA;
+        goto out;
+    }
 
-        if (cluster_handle_marker_getxattr (frame, loc, name, priv->vol_uuid,
-                                            afr_getxattr_unwind,
-                                            afr_marker_populate_args) == 0)
-                return 0;
-
-        ret = afr_handle_heal_xattrs (frame, this, &local->loc, name);
-        if (ret == 0)
-                return 0;
+    if (cluster_handle_marker_getxattr(frame, loc, name, priv->vol_uuid,
+                                       afr_getxattr_unwind,
+                                       afr_marker_populate_args) == 0)
+        return 0;
 
-        /*
-         * Heal daemons don't have IO threads ... and as a result they
-         * send this getxattr down and eventually crash :(
-         */
-        op_errno = -1;
-        GF_CHECK_XATTR_KEY_AND_GOTO(name, IO_THREADS_QUEUE_SIZE_KEY, op_errno,
-                                    out);
+    ret = afr_handle_heal_xattrs(frame, this, &local->loc, name);
+    if (ret == 0)
+        return 0;
 
-        /*
-         * Special xattrs which need responses from all subvols
-         */
-        if (afr_is_special_xattr (name, &cbk, 0)) {
-                afr_getxattr_all_subvols (this, frame, name, loc, cbk);
-                return 0;
-        }
+    /*
+     * Heal daemons don't have IO threads ... and as a result they
+     * send this getxattr down and eventually crash :(
+     */
+    op_errno = -1;
+    GF_CHECK_XATTR_KEY_AND_GOTO(name, IO_THREADS_QUEUE_SIZE_KEY, op_errno, out);
+
+    /*
+     * Special xattrs which need responses from all subvols
+     */
+    if (afr_is_special_xattr(name, &cbk, 0)) {
+        afr_getxattr_all_subvols(this, frame, name, loc, cbk);
+        return 0;
+    }
 
-        if (XATTR_IS_NODE_UUID (name)) {
-                i = 0;
-                STACK_WIND_COOKIE (frame, afr_getxattr_node_uuid_cbk,
-                                   (void *) (long) i,
-                                   children[i],
-                                   children[i]->fops->getxattr,
-                                   loc, name, xdata);
-                return 0;
-        }
+    if (XATTR_IS_NODE_UUID(name)) {
+        i = 0;
+        STACK_WIND_COOKIE(frame, afr_getxattr_node_uuid_cbk, (void *)(long)i,
+                          children[i], children[i]->fops->getxattr, loc, name,
+                          xdata);
+        return 0;
+    }
 
 no_name:
 
-	afr_read_txn (frame, this, local->loc.inode, afr_getxattr_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, local->loc.inode, afr_getxattr_wind,
+                 AFR_METADATA_TRANSACTION);
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret < 0)
-                AFR_STACK_UNWIND (getxattr, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    if (ret < 0)
+        AFR_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 /* {{{ fgetxattr */
 
-
 int32_t
-afr_fgetxattr_cbk (call_frame_t *frame, void *cookie,
-                   xlator_t *this, int32_t op_ret, int32_t op_errno,
-                   dict_t *dict, dict_t *xdata)
+afr_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	if (dict)
-		afr_filter_xattrs (dict);
+    if (dict)
+        afr_filter_xattrs(dict);
 
-	AFR_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, dict, xdata);
+    AFR_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, dict, xdata);
 
-	return 0;
+    return 0;
 }
 
 int
-afr_fgetxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fgetxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (fgetxattr, frame, local->op_ret,
-				  local->op_errno, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_fgetxattr_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fgetxattr,
-			   local->fd, local->cont.getxattr.name,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
+    local = frame->local;
+    priv = this->private;
 
-static void
-afr_fgetxattr_all_subvols (xlator_t *this, call_frame_t *frame,
-			   fop_fgetxattr_cbk_t cbk)
-{
-        afr_private_t   *priv           = NULL;
-        afr_local_t     *local          = NULL;
-        int             i               = 0;
-        int             call_count      = 0;
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(fgetxattr, frame, local->op_ret, local->op_errno, NULL,
+                         NULL);
+        return 0;
+    }
 
-        priv     = this->private;
+    STACK_WIND_COOKIE(frame, afr_fgetxattr_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fgetxattr, local->fd,
+                      local->cont.getxattr.name, local->xdata_req);
+    return 0;
+}
 
-        local = frame->local;
-        //local->call_count set in afr_local_init
-        call_count = local->call_count;
-
-        //If up-children count is 0, afr_local_init would have failed already
-        //and the call would have unwound so not handling it here.
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i]) {
-                        STACK_WIND_COOKIE (frame, cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->fgetxattr,
-                                           local->fd, local->cont.getxattr.name,
-					   NULL);
-                        if (!--call_count)
-                                break;
-                }
+static void
+afr_fgetxattr_all_subvols(xlator_t *this, call_frame_t *frame,
+                          fop_fgetxattr_cbk_t cbk)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+
+    priv = this->private;
+
+    local = frame->local;
+    // local->call_count set in afr_local_init
+    call_count = local->call_count;
+
+    // If up-children count is 0, afr_local_init would have failed already
+    // and the call would have unwound so not handling it here.
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i]) {
+            STACK_WIND_COOKIE(frame, cbk, (void *)(long)i, priv->children[i],
+                              priv->children[i]->fops->fgetxattr, local->fd,
+                              local->cont.getxattr.name, NULL);
+            if (!--call_count)
+                break;
         }
+    }
 
-        return;
+    return;
 }
 
-
 int
-afr_fgetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, const char *name, dict_t *xdata)
+afr_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+              dict_t *xdata)
 {
-        afr_local_t          *local      = NULL;
-        int32_t               op_errno   = 0;
-        fop_fgetxattr_cbk_t   cbk        = NULL;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-	local->op = GF_FOP_FGETXATTR;
-        local->fd = fd_ref (fd);
-        if (name) {
-                local->cont.getxattr.name = gf_strdup (name);
-		if (!local->cont.getxattr.name) {
-			op_errno = ENOMEM;
-			goto out;
-		}
-	}
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
-
-        /* pathinfo gets handled only in getxattr(), but we need to handle
-         * lockinfo.
-         * If we are doing fgetxattr with lockinfo as the key then we
-         * collect information from all children.
-         */
-        if (afr_is_special_xattr (name, &cbk, 1)) {
-                afr_fgetxattr_all_subvols (this, frame, cbk);
-                return 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
+    fop_fgetxattr_cbk_t cbk = NULL;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_FGETXATTR;
+    local->fd = fd_ref(fd);
+    if (name) {
+        local->cont.getxattr.name = gf_strdup(name);
+        if (!local->cont.getxattr.name) {
+            op_errno = ENOMEM;
+            goto out;
         }
+    }
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    /* pathinfo gets handled only in getxattr(), but we need to handle
+     * lockinfo.
+     * If we are doing fgetxattr with lockinfo as the key then we
+     * collect information from all children.
+     */
+    if (afr_is_special_xattr(name, &cbk, 1)) {
+        afr_fgetxattr_all_subvols(this, frame, cbk);
+        return 0;
+    }
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_fgetxattr_wind,
-		      AFR_METADATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_fgetxattr_wind,
+                 AFR_METADATA_TRANSACTION);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (fgetxattr, frame, -1, op_errno, NULL, NULL);
+    AFR_STACK_UNWIND(fgetxattr, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ readv */
 
 int
-afr_readv_cbk (call_frame_t *frame, void *cookie,
-               xlator_t *this, int32_t op_ret, int32_t op_errno,
-               struct iovec *vector, int32_t count, struct iatt *buf,
-               struct iobref *iobref, dict_t *xdata)
+afr_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iovec *vector, int32_t count,
+              struct iatt *buf, struct iobref *iobref, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = op_errno;
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-		afr_read_txn_continue (frame, this, (long) cookie);
-		return 0;
-	}
+        afr_read_txn_continue(frame, this, (long)cookie);
+        return 0;
+    }
 
-	AFR_STACK_UNWIND (readv, frame, op_ret, op_errno,
-			  vector, count, buf, iobref, xdata);
-	return 0;
+    AFR_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, buf, iobref,
+                     xdata);
+    return 0;
 }
 
-
 int
-afr_readv_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_readv_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-
-	local = frame->local;
-	priv = this->private;
-
-	if (subvol == -1) {
-		AFR_STACK_UNWIND (readv, frame, local->op_ret, local->op_errno,
-				  0, 0, 0, 0, 0);
-		return 0;
-	}
-
-	STACK_WIND_COOKIE (frame, afr_readv_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->readv,
-			   local->fd, local->cont.readv.size,
-			   local->cont.readv.offset, local->cont.readv.flags,
-			   local->xdata_req);
-	return 0;
-}
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    local = frame->local;
+    priv = this->private;
 
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(readv, frame, local->op_ret, local->op_errno, 0, 0, 0,
+                         0, 0);
+        return 0;
+    }
+
+    STACK_WIND_COOKIE(
+        frame, afr_readv_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->readv, local->fd, local->cont.readv.size,
+        local->cont.readv.offset, local->cont.readv.flags, local->xdata_req);
+    return 0;
+}
 
 int
-afr_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-	   off_t offset, uint32_t flags, dict_t *xdata)
+afr_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+          off_t offset, uint32_t flags, dict_t *xdata)
 {
-        afr_local_t   * local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-	local->op = GF_FOP_READ;
-        local->fd = fd_ref (fd);
-        local->cont.readv.size = size;
-        local->cont.readv.offset = offset;
-        local->cont.readv.flags = flags;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_READ;
+    local->fd = fd_ref(fd);
+    local->cont.readv.size = size;
+    local->cont.readv.offset = offset;
+    local->cont.readv.flags = flags;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	afr_read_txn (frame, this, fd->inode, afr_readv_wind,
-		      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_readv_wind, AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
+    AFR_STACK_UNWIND(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
 
-	return 0;
+    return 0;
 }
 
 /* }}} */
@@ -1910,77 +1814,72 @@ out:
 /* {{{ seek */
 
 int
-afr_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
+afr_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, off_t offset, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-
-                afr_read_txn_continue (frame, this, (long) cookie);
-                return 0;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-        AFR_STACK_UNWIND (seek, frame, op_ret, op_errno, offset, xdata);
+        afr_read_txn_continue(frame, this, (long)cookie);
         return 0;
-}
+    }
 
+    AFR_STACK_UNWIND(seek, frame, op_ret, op_errno, offset, xdata);
+    return 0;
+}
 
 int
-afr_seek_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_seek_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
-
-        if (subvol == -1) {
-                AFR_STACK_UNWIND (seek, frame, local->op_ret, local->op_errno,
-                                  0, NULL);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-        STACK_WIND_COOKIE (frame, afr_seek_cbk, (void *) (long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->seek,
-                           local->fd, local->cont.seek.offset,
-                           local->cont.seek.what, local->xdata_req);
+    if (subvol == -1) {
+        AFR_STACK_UNWIND(seek, frame, local->op_ret, local->op_errno, 0, NULL);
         return 0;
-}
+    }
 
+    STACK_WIND_COOKIE(
+        frame, afr_seek_cbk, (void *)(long)subvol, priv->children[subvol],
+        priv->children[subvol]->fops->seek, local->fd, local->cont.seek.offset,
+        local->cont.seek.what, local->xdata_req);
+    return 0;
+}
 
 int
-afr_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-          gf_seek_what_t what, dict_t *xdata)
+afr_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+         gf_seek_what_t what, dict_t *xdata)
 {
-        afr_local_t    *local      = NULL;
-        int32_t         op_errno   = 0;
+    afr_local_t *local = NULL;
+    int32_t op_errno = 0;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->op = GF_FOP_SEEK;
-        local->fd = fd_ref (fd);
-        local->cont.seek.offset = offset;
-        local->cont.seek.what = what;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
+    local->op = GF_FOP_SEEK;
+    local->fd = fd_ref(fd);
+    local->cont.seek.offset = offset;
+    local->cont.seek.what = what;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        afr_read_txn (frame, this, fd->inode, afr_seek_wind,
-                      AFR_DATA_TRANSACTION);
+    afr_read_txn(frame, this, fd->inode, afr_seek_wind, AFR_DATA_TRANSACTION);
 
-        return 0;
+    return 0;
 out:
-        AFR_STACK_UNWIND (seek, frame, -1, op_errno, 0, NULL);
+    AFR_STACK_UNWIND(seek, frame, -1, op_errno, 0, NULL);
 
-        return 0;
+    return 0;
 }
 /* }}} */
diff --git a/xlators/cluster/afr/src/afr-inode-write.c b/xlators/cluster/afr/src/afr-inode-write.c
index 755e928ef62..f9e2b302f8d 100644
--- a/xlators/cluster/afr/src/afr-inode-write.c
+++ b/xlators/cluster/afr/src/afr-inode-write.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include <libgen.h>
 #include <unistd.h>
 #include <fnmatch.h>
@@ -35,771 +34,736 @@
 #include "afr-messages.h"
 
 static void
-__afr_inode_write_finalize (call_frame_t *frame, xlator_t *this)
-{
-	int                       i               = 0;
-        int                       ret             = 0;
-	int                       read_subvol     = 0;
-        struct iatt              *stbuf           = NULL;
-	afr_local_t              *local           = NULL;
-	afr_private_t            *priv            = NULL;
-        afr_read_subvol_args_t    args            = {0,};
-
-	local = frame->local;
-	priv = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, local->inode, out);
-
-        /*This code needs to stay till DHT sends fops on linked
-         * inodes*/
-        if (!inode_is_linked (local->inode)) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->replies[i].valid)
-                                continue;
-                        if (local->replies[i].op_ret == -1)
-                                continue;
-                        if (!gf_uuid_is_null
-                                        (local->replies[i].poststat.ia_gfid)) {
-                                gf_uuid_copy (args.gfid,
-                                            local->replies[i].poststat.ia_gfid);
-                                args.ia_type =
-                                        local->replies[i].poststat.ia_type;
-                                break;
-                        } else {
-                                ret = dict_get_bin (local->replies[i].xdata,
-                                                    DHT_IATT_IN_XDATA_KEY,
-                                                    (void **) &stbuf);
-                                if (ret)
-                                        continue;
-                                gf_uuid_copy (args.gfid, stbuf->ia_gfid);
-                                args.ia_type = stbuf->ia_type;
-                                break;
-                        }
-                }
+__afr_inode_write_finalize(call_frame_t *frame, xlator_t *this)
+{
+    int i = 0;
+    int ret = 0;
+    int read_subvol = 0;
+    struct iatt *stbuf = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_read_subvol_args_t args = {
+        0,
+    };
+
+    local = frame->local;
+    priv = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, local->inode, out);
+
+    /*This code needs to stay till DHT sends fops on linked
+     * inodes*/
+    if (!inode_is_linked(local->inode)) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (!local->replies[i].valid)
+                continue;
+            if (local->replies[i].op_ret == -1)
+                continue;
+            if (!gf_uuid_is_null(local->replies[i].poststat.ia_gfid)) {
+                gf_uuid_copy(args.gfid, local->replies[i].poststat.ia_gfid);
+                args.ia_type = local->replies[i].poststat.ia_type;
+                break;
+            } else {
+                ret = dict_get_bin(local->replies[i].xdata,
+                                   DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+                if (ret)
+                    continue;
+                gf_uuid_copy(args.gfid, stbuf->ia_gfid);
+                args.ia_type = stbuf->ia_type;
+                break;
+            }
         }
-
-        if (local->transaction.type == AFR_METADATA_TRANSACTION) {
-                read_subvol = afr_metadata_subvol_get (local->inode, this,
-                                                       NULL, local->readable,
-                                                       NULL, &args);
-	} else {
-                read_subvol = afr_data_subvol_get (local->inode, this,
-                                                   NULL, local->readable,
-                                                   NULL, &args);
+    }
+
+    if (local->transaction.type == AFR_METADATA_TRANSACTION) {
+        read_subvol = afr_metadata_subvol_get(local->inode, this, NULL,
+                                              local->readable, NULL, &args);
+    } else {
+        read_subvol = afr_data_subvol_get(local->inode, this, NULL,
+                                          local->readable, NULL, &args);
+    }
+
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    afr_pick_error_xdata(local, priv, local->inode, local->readable, NULL,
+                         NULL);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+        if (local->replies[i].op_ret < 0)
+            continue;
+
+        /* Order of checks in the compound conditional
+           below is important.
+
+           - Highest precedence: largest op_ret
+           - Next precedence: if all op_rets are equal, read subvol
+           - Least precedence: any succeeded subvol
+        */
+        if ((local->op_ret < local->replies[i].op_ret) ||
+            ((local->op_ret == local->replies[i].op_ret) &&
+             (i == read_subvol))) {
+            local->op_ret = local->replies[i].op_ret;
+            local->op_errno = local->replies[i].op_errno;
+
+            local->cont.inode_wfop.prebuf = local->replies[i].prestat;
+            local->cont.inode_wfop.postbuf = local->replies[i].poststat;
+
+            if (local->replies[i].xdata) {
+                if (local->xdata_rsp)
+                    dict_unref(local->xdata_rsp);
+                local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            }
+            if (local->replies[i].xattr) {
+                if (local->xattr_rsp)
+                    dict_unref(local->xattr_rsp);
+                local->xattr_rsp = dict_ref(local->replies[i].xattr);
+            }
         }
+    }
 
-	local->op_ret = -1;
-	local->op_errno = afr_final_errno (local, priv);
-        afr_pick_error_xdata (local, priv, local->inode, local->readable, NULL,
-                              NULL);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->replies[i].valid)
-			continue;
-		if (local->replies[i].op_ret < 0)
-			continue;
-
-		/* Order of checks in the compound conditional
-		   below is important.
-
-		   - Highest precedence: largest op_ret
-		   - Next precedence: if all op_rets are equal, read subvol
-		   - Least precedence: any succeeded subvol
-		*/
-		if ((local->op_ret < local->replies[i].op_ret) ||
-		    ((local->op_ret == local->replies[i].op_ret) &&
-		     (i == read_subvol))) {
-
-			local->op_ret = local->replies[i].op_ret;
-			local->op_errno = local->replies[i].op_errno;
-
-			local->cont.inode_wfop.prebuf =
-				local->replies[i].prestat;
-			local->cont.inode_wfop.postbuf =
-				local->replies[i].poststat;
-
-			if (local->replies[i].xdata) {
-				if (local->xdata_rsp)
-					dict_unref (local->xdata_rsp);
-				local->xdata_rsp =
-					dict_ref (local->replies[i].xdata);
-			}
-			if (local->replies[i].xattr) {
-				if (local->xattr_rsp)
-					dict_unref (local->xattr_rsp);
-				local->xattr_rsp =
-					dict_ref (local->replies[i].xattr);
-			}
-		}
-	}
-
-        afr_set_in_flight_sb_status (this, frame, local->inode);
+    afr_set_in_flight_sb_status(this, frame, local->inode);
 out:
-        return;
+    return;
 }
 
-
 static void
-__afr_inode_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
-			int op_ret, int op_errno,
-			struct iatt *prebuf, struct iatt *postbuf,
-			dict_t *xattr, dict_t *xdata)
+__afr_inode_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
+                       int op_ret, int op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	local->replies[child_index].valid = 1;
+    local->replies[child_index].valid = 1;
 
-        if (AFR_IS_ARBITER_BRICK(priv, child_index) && op_ret == 1)
-                op_ret = iov_length (local->cont.writev.vector,
-                                     local->cont.writev.count);
+    if (AFR_IS_ARBITER_BRICK(priv, child_index) && op_ret == 1)
+        op_ret = iov_length(local->cont.writev.vector,
+                            local->cont.writev.count);
 
-	local->replies[child_index].op_ret = op_ret;
-	local->replies[child_index].op_errno = op_errno;
-        if (xdata)
-                local->replies[child_index].xdata = dict_ref (xdata);
+    local->replies[child_index].op_ret = op_ret;
+    local->replies[child_index].op_errno = op_errno;
+    if (xdata)
+        local->replies[child_index].xdata = dict_ref(xdata);
 
-	if (op_ret >= 0) {
-		if (prebuf)
-			local->replies[child_index].prestat = *prebuf;
-		if (postbuf)
-			local->replies[child_index].poststat = *postbuf;
-		if (xattr)
-			local->replies[child_index].xattr = dict_ref (xattr);
-	} else {
-		afr_transaction_fop_failed (frame, this, child_index);
-	}
+    if (op_ret >= 0) {
+        if (prebuf)
+            local->replies[child_index].prestat = *prebuf;
+        if (postbuf)
+            local->replies[child_index].poststat = *postbuf;
+        if (xattr)
+            local->replies[child_index].xattr = dict_ref(xattr);
+    } else {
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
 
-        return;
+    return;
 }
 
-
 static int
-__afr_inode_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
+__afr_inode_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                __afr_inode_write_fill (frame, this, child_index, op_ret,
-					op_errno, prebuf, postbuf, xattr,
-					xdata);
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        __afr_inode_write_fill(frame, this, child_index, op_ret, op_errno,
+                               prebuf, postbuf, xattr, xdata);
+    }
+    UNLOCK(&frame->lock);
 
-        call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-        if (call_count == 0) {
-		__afr_inode_write_finalize (frame, this);
+    if (call_count == 0) {
+        __afr_inode_write_finalize(frame, this);
 
-		if (afr_txn_nothing_failed (frame, this)) {
-                        /*if it did pre-op, it will do post-op changing ctime*/
-                        if (priv->consistent_metadata &&
-                            afr_needs_changelog_update (local))
-                                afr_zero_fill_stat (local);
-                        local->transaction.unwind (frame, this);
-                }
-
-                afr_transaction_resume (frame, this);
+        if (afr_txn_nothing_failed(frame, this)) {
+            /*if it did pre-op, it will do post-op changing ctime*/
+            if (priv->consistent_metadata && afr_needs_changelog_update(local))
+                afr_zero_fill_stat(local);
+            local->transaction.unwind(frame, this);
         }
 
-        return 0;
+        afr_transaction_resume(frame, this);
+    }
+
+    return 0;
 }
 
 /* {{{ writev */
 
 void
-afr_writev_copy_outvars (call_frame_t *src_frame, call_frame_t *dst_frame)
+afr_writev_copy_outvars(call_frame_t *src_frame, call_frame_t *dst_frame)
 {
-        afr_local_t *src_local = NULL;
-        afr_local_t *dst_local = NULL;
+    afr_local_t *src_local = NULL;
+    afr_local_t *dst_local = NULL;
 
-        src_local = src_frame->local;
-        dst_local = dst_frame->local;
+    src_local = src_frame->local;
+    dst_local = dst_frame->local;
 
-        dst_local->op_ret = src_local->op_ret;
-        dst_local->op_errno = src_local->op_errno;
-        dst_local->cont.inode_wfop.prebuf = src_local->cont.inode_wfop.prebuf;
-        dst_local->cont.inode_wfop.postbuf = src_local->cont.inode_wfop.postbuf;
-	if (src_local->xdata_rsp)
-		dst_local->xdata_rsp = dict_ref (src_local->xdata_rsp);
+    dst_local->op_ret = src_local->op_ret;
+    dst_local->op_errno = src_local->op_errno;
+    dst_local->cont.inode_wfop.prebuf = src_local->cont.inode_wfop.prebuf;
+    dst_local->cont.inode_wfop.postbuf = src_local->cont.inode_wfop.postbuf;
+    if (src_local->xdata_rsp)
+        dst_local->xdata_rsp = dict_ref(src_local->xdata_rsp);
 }
 
 void
-afr_writev_unwind (call_frame_t *frame, xlator_t *this)
+afr_writev_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = this->private;
 
-        local = frame->local;
+    local = frame->local;
 
-       if (priv->consistent_metadata)
-               afr_zero_fill_stat (local);
+    if (priv->consistent_metadata)
+        afr_zero_fill_stat(local);
 
-        AFR_STACK_UNWIND (writev, frame,
-                          local->op_ret, local->op_errno,
-                          &local->cont.inode_wfop.prebuf,
-                          &local->cont.inode_wfop.postbuf,
-                          local->xdata_rsp);
+    AFR_STACK_UNWIND(writev, frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
 }
 
-
 int
-afr_transaction_writev_unwind (call_frame_t *frame, xlator_t *this)
+afr_transaction_writev_unwind(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *fop_frame = NULL;
+    call_frame_t *fop_frame = NULL;
 
-        fop_frame = afr_transaction_detach_fop_frame (frame);
+    fop_frame = afr_transaction_detach_fop_frame(frame);
 
-        if (fop_frame) {
-                afr_writev_copy_outvars (frame, fop_frame);
-                afr_writev_unwind (fop_frame, this);
-        }
-        return 0;
+    if (fop_frame) {
+        afr_writev_copy_outvars(frame, fop_frame);
+        afr_writev_unwind(fop_frame, this);
+    }
+    return 0;
 }
 
 static void
-afr_writev_handle_short_writes (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int           i      = 0;
-
-        local = frame->local;
-        priv = this->private;
-        /*
-         * We already have the best case result of the writev calls staged
-         * as the return value. Any writev that returns some value less
-         * than the best case is now out of sync, so mark the fop as
-         * failed. Note that fops that have returned with errors have
-         * already been marked as failed.
-         */
-        for (i = 0; i < priv->child_count; i++) {
-                if ((!local->replies[i].valid) ||
-                    (local->replies[i].op_ret == -1))
-                        continue;
-
-                if (local->replies[i].op_ret < local->op_ret)
-                        afr_transaction_fop_failed (frame, this, i);
-        }
+afr_writev_handle_short_writes(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+    /*
+     * We already have the best case result of the writev calls staged
+     * as the return value. Any writev that returns some value less
+     * than the best case is now out of sync, so mark the fop as
+     * failed. Note that fops that have returned with errors have
+     * already been marked as failed.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if ((!local->replies[i].valid) || (local->replies[i].op_ret == -1))
+            continue;
+
+        if (local->replies[i].op_ret < local->op_ret)
+            afr_transaction_fop_failed(frame, this, i);
+    }
 }
 
 void
-afr_inode_write_fill (call_frame_t *frame, xlator_t *this, int child_index,
+afr_inode_write_fill(call_frame_t *frame, xlator_t *this, int child_index,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                      struct iatt *postbuf, dict_t *xdata)
 {
-        int ret = 0;
-        afr_local_t *local = frame->local;
-        uint32_t open_fd_count = 0;
-        uint32_t write_is_append = 0;
-
-        LOCK (&frame->lock);
-        {
-                __afr_inode_write_fill (frame, this, child_index, op_ret,
-					op_errno, prebuf, postbuf, NULL, xdata);
-		if (op_ret == -1 || !xdata)
-			goto unlock;
-
-		write_is_append = 0;
-		ret = dict_get_uint32 (xdata, GLUSTERFS_WRITE_IS_APPEND,
-				       &write_is_append);
-		if (ret || !write_is_append)
-			local->append_write = _gf_false;
-
-                ret = dict_get_uint32 (xdata, GLUSTERFS_ACTIVE_FD_COUNT,
-                                       &open_fd_count);
-                if (ret < 0)
-                        goto unlock;
-		if (open_fd_count > local->open_fd_count) {
-                        local->open_fd_count = open_fd_count;
-                        local->update_open_fd_count = _gf_true;
-		}
+    int ret = 0;
+    afr_local_t *local = frame->local;
+    uint32_t open_fd_count = 0;
+    uint32_t write_is_append = 0;
+
+    LOCK(&frame->lock);
+    {
+        __afr_inode_write_fill(frame, this, child_index, op_ret, op_errno,
+                               prebuf, postbuf, NULL, xdata);
+        if (op_ret == -1 || !xdata)
+            goto unlock;
+
+        write_is_append = 0;
+        ret = dict_get_uint32(xdata, GLUSTERFS_WRITE_IS_APPEND,
+                              &write_is_append);
+        if (ret || !write_is_append)
+            local->append_write = _gf_false;
+
+        ret = dict_get_uint32(xdata, GLUSTERFS_ACTIVE_FD_COUNT, &open_fd_count);
+        if (ret < 0)
+            goto unlock;
+        if (open_fd_count > local->open_fd_count) {
+            local->open_fd_count = open_fd_count;
+            local->update_open_fd_count = _gf_true;
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 }
 
 void
-afr_process_post_writev (call_frame_t *frame, xlator_t *this)
+afr_process_post_writev(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t     *local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local->stable_write && !local->append_write)
-                /* An appended write removes the necessity to
-                   fsync() the file. This is because self-heal
-                   has the logic to check for larger file when
-                   the xattrs are not reliably pointing at
-                   a stale file.
-                */
-                afr_fd_report_unstable_write (this, local);
+    if (!local->stable_write && !local->append_write)
+        /* An appended write removes the necessity to
+           fsync() the file. This is because self-heal
+           has the logic to check for larger file when
+           the xattrs are not reliably pointing at
+           a stale file.
+        */
+        afr_fd_report_unstable_write(this, local);
 
-        __afr_inode_write_finalize (frame, this);
+    __afr_inode_write_finalize(frame, this);
 
-        afr_writev_handle_short_writes (frame, this);
-
-        if (local->update_open_fd_count)
-                local->inode_ctx->open_fd_count = local->open_fd_count;
+    afr_writev_handle_short_writes(frame, this);
 
+    if (local->update_open_fd_count)
+        local->inode_ctx->open_fd_count = local->open_fd_count;
 }
 
 int
-afr_writev_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata)
+afr_writev_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
 {
-        call_frame_t    *fop_frame = NULL;
-        int child_index = (long) cookie;
-        int call_count  = -1;
-
-        afr_inode_write_fill (frame, this, child_index, op_ret, op_errno,
-                              prebuf, postbuf, xdata);
-
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                afr_process_post_writev (frame, this);
-
-                if (!afr_txn_nothing_failed (frame, this)) {
-                        //Don't unwind until post-op is complete
-                        afr_transaction_resume (frame, this);
-                } else {
-                /*
-                 * Generally inode-write fops do transaction.unwind then
-                 * transaction.resume, but writev needs to make sure that
-                 * delayed post-op frame is placed in fdctx before unwind
-                 * happens. This prevents the race of flush doing the
-                 * changelog wakeup first in fuse thread and then this
-                 * writev placing its delayed post-op frame in fdctx.
-                 * This helps flush make sure all the delayed post-ops are
-                 * completed.
-                 */
-
-                        fop_frame = afr_transaction_detach_fop_frame (frame);
-                        afr_writev_copy_outvars (frame, fop_frame);
-                        afr_transaction_resume (frame, this);
-                        afr_writev_unwind (fop_frame, this);
-                }
+    call_frame_t *fop_frame = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+
+    afr_inode_write_fill(frame, this, child_index, op_ret, op_errno, prebuf,
+                         postbuf, xdata);
+
+    call_count = afr_frame_return(frame);
+
+    if (call_count == 0) {
+        afr_process_post_writev(frame, this);
+
+        if (!afr_txn_nothing_failed(frame, this)) {
+            // Don't unwind until post-op is complete
+            afr_transaction_resume(frame, this);
+        } else {
+            /*
+             * Generally inode-write fops do transaction.unwind then
+             * transaction.resume, but writev needs to make sure that
+             * delayed post-op frame is placed in fdctx before unwind
+             * happens. This prevents the race of flush doing the
+             * changelog wakeup first in fuse thread and then this
+             * writev placing its delayed post-op frame in fdctx.
+             * This helps flush make sure all the delayed post-ops are
+             * completed.
+             */
+
+            fop_frame = afr_transaction_detach_fop_frame(frame);
+            afr_writev_copy_outvars(frame, fop_frame);
+            afr_transaction_resume(frame, this);
+            afr_writev_unwind(fop_frame, this);
         }
-        return 0;
+    }
+    return 0;
 }
 
 static int
-afr_arbiter_writev_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_arbiter_writev_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = frame->local;
-        afr_private_t *priv = this->private;
-        static char byte = 0xFF;
-        static struct iovec vector = {&byte, 1};
-        int32_t count = 1;
+    afr_local_t *local = frame->local;
+    afr_private_t *priv = this->private;
+    static char byte = 0xFF;
+    static struct iovec vector = {&byte, 1};
+    int32_t count = 1;
 
-        STACK_WIND_COOKIE (frame, afr_writev_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->writev,
-			   local->fd, &vector, count, local->cont.writev.offset,
-			   local->cont.writev.flags, local->cont.writev.iobref,
-			   local->xdata_req);
+    STACK_WIND_COOKIE(
+        frame, afr_writev_wind_cbk, (void *)(long)subvol,
+        priv->children[subvol], priv->children[subvol]->fops->writev, local->fd,
+        &vector, count, local->cont.writev.offset, local->cont.writev.flags,
+        local->cont.writev.iobref, local->xdata_req);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_writev_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_writev_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
-
-        if (AFR_IS_ARBITER_BRICK(priv, subvol)) {
-                afr_arbiter_writev_wind (frame, this, subvol);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_writev_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->writev,
-			   local->fd, local->cont.writev.vector,
-			   local->cont.writev.count, local->cont.writev.offset,
-			   local->cont.writev.flags, local->cont.writev.iobref,
-			   local->xdata_req);
+    if (AFR_IS_ARBITER_BRICK(priv, subvol)) {
+        afr_arbiter_writev_wind(frame, this, subvol);
         return 0;
-}
+    }
 
+    STACK_WIND_COOKIE(frame, afr_writev_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->writev, local->fd,
+                      local->cont.writev.vector, local->cont.writev.count,
+                      local->cont.writev.offset, local->cont.writev.flags,
+                      local->cont.writev.iobref, local->xdata_req);
+    return 0;
+}
 
 int
-afr_do_writev (call_frame_t *frame, xlator_t *this)
+afr_do_writev(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t    *transaction_frame = NULL;
-        afr_local_t     *local             = NULL;
-        int             ret   = -1;
-        int             op_errno = ENOMEM;
-
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
-
-        local = frame->local;
-        transaction_frame->local = local;
-	frame->local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	if (!AFR_FRAME_INIT (frame, op_errno))
-		goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-        local->op = GF_FOP_WRITE;
+    local = frame->local;
+    transaction_frame->local = local;
+    frame->local = NULL;
 
-        local->transaction.wind   = afr_writev_wind;
-        local->transaction.unwind = afr_transaction_writev_unwind;
+    if (!AFR_FRAME_INIT(frame, op_errno))
+        goto out;
 
-        local->transaction.main_frame = frame;
+    local->op = GF_FOP_WRITE;
 
-        if (local->fd->flags & O_APPEND) {
-               /*
-                * Backend vfs ignores the 'offset' for append mode fd so
-                * locking just the region provided for the writev does not
-                * give consistency guarantee. The actual write may happen at a
-                * completely different range than the one provided by the
-                * offset, len in the fop. So lock the entire file.
-                */
-                local->transaction.start   = 0;
-                local->transaction.len     = 0;
-        } else {
-                local->transaction.start   = local->cont.writev.offset;
-                local->transaction.len     = iov_length (local->cont.writev.vector,
-                                                         local->cont.writev.count);
-        }
+    local->transaction.wind = afr_writev_wind;
+    local->transaction.unwind = afr_transaction_writev_unwind;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-            op_errno = -ret;
-            goto out;
-        }
+    local->transaction.main_frame = frame;
 
-	return 0;
+    if (local->fd->flags & O_APPEND) {
+        /*
+         * Backend vfs ignores the 'offset' for append mode fd so
+         * locking just the region provided for the writev does not
+         * give consistency guarantee. The actual write may happen at a
+         * completely different range than the one provided by the
+         * offset, len in the fop. So lock the entire file.
+         */
+        local->transaction.start = 0;
+        local->transaction.len = 0;
+    } else {
+        local->transaction.start = local->cont.writev.offset;
+        local->transaction.len = iov_length(local->cont.writev.vector,
+                                            local->cont.writev.count);
+    }
+
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
+
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-afr_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-            struct iovec *vector, int32_t count, off_t offset,
-            uint32_t flags, struct iobref *iobref, dict_t *xdata)
+afr_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int op_errno = ENOMEM;
-        int ret = -1;
+    afr_local_t *local = NULL;
+    int op_errno = ENOMEM;
+    int ret = -1;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.writev.vector = iov_dup (vector, count);
-	if (!local->cont.writev.vector)
-		goto out;
-        local->cont.writev.count      = count;
-        local->cont.writev.offset     = offset;
-        local->cont.writev.flags      = flags;
-        local->cont.writev.iobref     = iobref_ref (iobref);
+    local->cont.writev.vector = iov_dup(vector, count);
+    if (!local->cont.writev.vector)
+        goto out;
+    local->cont.writev.count = count;
+    local->cont.writev.offset = offset;
+    local->cont.writev.flags = flags;
+    local->cont.writev.iobref = iobref_ref(iobref);
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-        if (dict_set_uint32 (local->xdata_req, GLUSTERFS_ACTIVE_FD_COUNT, 4)) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (dict_set_uint32(local->xdata_req, GLUSTERFS_ACTIVE_FD_COUNT, 4)) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	if (dict_set_uint32 (local->xdata_req, GLUSTERFS_WRITE_IS_APPEND, 4)) {
-		op_errno = ENOMEM;
-		goto out;
-	}
+    if (dict_set_uint32(local->xdata_req, GLUSTERFS_WRITE_IS_APPEND, 4)) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-	/* Set append_write to be true speculatively. If on any
-	   server it turns not be true, we unset it in the
-	   callback.
-	*/
-	local->append_write = _gf_true;
+    /* Set append_write to be true speculatively. If on any
+       server it turns not be true, we unset it in the
+       callback.
+    */
+    local->append_write = _gf_true;
 
-	/* detect here, but set it in writev_wind_cbk *after* the unstable
-	   write is performed
-	*/
-	local->stable_write = !!((fd->flags|flags)&(O_SYNC|O_DSYNC));
+    /* detect here, but set it in writev_wind_cbk *after* the unstable
+       write is performed
+    */
+    local->stable_write = !!((fd->flags | flags) & (O_SYNC | O_DSYNC));
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        afr_do_writev (frame, this);
+    afr_do_writev(frame, this);
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ truncate */
 
 int
-afr_truncate_unwind (call_frame_t *frame, xlator_t *this)
+afr_truncate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (truncate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(truncate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_truncate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
+afr_truncate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
-		local->stable_write = _gf_false;
+    if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
+        local->stable_write = _gf_false;
 
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_truncate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_truncate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_truncate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->truncate,
-			   &local->loc, local->cont.truncate.offset,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_truncate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->truncate, &local->loc,
+                      local->cont.truncate.offset, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_truncate (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, off_t offset, dict_t *xdata)
+afr_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata)
 {
-        afr_local_t   * local = NULL;
-        call_frame_t   *transaction_frame = NULL;
-	int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.truncate.offset  = offset;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.truncate.offset = offset;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-	local->transaction.wind   = afr_truncate_wind;
-        local->transaction.unwind = afr_truncate_unwind;
+    local->transaction.wind = afr_truncate_wind;
+    local->transaction.unwind = afr_truncate_unwind;
 
-        loc_copy (&local->loc, loc);
-        ret = afr_set_inode_local (this, local, loc->inode);
-        if (ret)
-                goto out;
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-        local->op = GF_FOP_TRUNCATE;
+    local->op = GF_FOP_TRUNCATE;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = offset;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = offset;
+    local->transaction.len = 0;
 
-	/* Set it true speculatively, will get reset in afr_truncate_wind_cbk
-	   if truncate was not a NOP */
-	local->stable_write = _gf_true;
+    /* Set it true speculatively, will get reset in afr_truncate_wind_cbk
+       if truncate was not a NOP */
+    local->stable_write = _gf_true;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ ftruncate */
 
-
 int
-afr_ftruncate_unwind (call_frame_t *frame, xlator_t *this)
+afr_ftruncate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (ftruncate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(ftruncate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_ftruncate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_ftruncate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
-		local->stable_write = _gf_false;
+    if (op_ret == 0 && prebuf->ia_size != postbuf->ia_size)
+        local->stable_write = _gf_false;
 
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_ftruncate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_ftruncate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_ftruncate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->ftruncate,
-			   local->fd, local->cont.ftruncate.offset,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_ftruncate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->ftruncate, local->fd,
+                      local->cont.ftruncate.offset, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-	       dict_t *xdata)
+afr_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-	call_frame_t *transaction_frame = NULL;
-	int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-        local = AFR_FRAME_INIT (transaction_frame, op_errno);
-        if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.ftruncate.offset  = offset;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.ftruncate.offset = offset;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-        local->op = GF_FOP_FTRUNCATE;
+    local->op = GF_FOP_FTRUNCATE;
 
-	local->transaction.wind   = afr_ftruncate_wind;
-        local->transaction.unwind = afr_ftruncate_unwind;
+    local->transaction.wind = afr_ftruncate_wind;
+    local->transaction.unwind = afr_ftruncate_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.ftruncate.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.ftruncate.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-	/* Set it true speculatively, will get reset in afr_ftruncate_wind_cbk
-	   if truncate was not a NOP */
-	local->stable_write = _gf_true;
+    /* Set it true speculatively, will get reset in afr_ftruncate_wind_cbk
+       if truncate was not a NOP */
+    local->stable_write = _gf_true;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	AFR_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* }}} */
@@ -807,1813 +771,1743 @@ out:
 /* {{{ setattr */
 
 int
-afr_setattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_setattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (setattr, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(setattr, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_setattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno,
-                      struct iatt *preop, struct iatt *postop, dict_t *xdata)
+afr_setattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *preop,
+                     struct iatt *postop, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      preop, postop, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, preop,
+                                 postop, NULL, xdata);
 }
 
-
 int
-afr_setattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_setattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_setattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->setattr,
-			   &local->loc, &local->cont.setattr.in_buf,
-			   local->cont.setattr.valid, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_setattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->setattr, &local->loc,
+                      &local->cont.setattr.in_buf, local->cont.setattr.valid,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *buf,
-	     int32_t valid, dict_t *xdata)
+afr_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *buf,
+            int32_t valid, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.setattr.in_buf = *buf;
-        local->cont.setattr.valid  = valid;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.setattr.in_buf = *buf;
+    local->cont.setattr.valid = valid;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_setattr_wind;
-        local->transaction.unwind = afr_setattr_unwind;
+    local->transaction.wind = afr_setattr_wind;
+    local->transaction.unwind = afr_setattr_unwind;
 
-        loc_copy (&local->loc, loc);
-        ret = afr_set_inode_local (this, local, loc->inode);
-        if (ret)
-                goto out;
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_SETATTR;
+    local->op = GF_FOP_SETATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* {{{ fsetattr */
 
 int
-afr_fsetattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fsetattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fsetattr, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fsetattr, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fsetattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno,
-                       struct iatt *preop, struct iatt *postop, dict_t *xdata)
+afr_fsetattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                      struct iatt *postop, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      preop, postop, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, preop,
+                                 postop, NULL, xdata);
 }
 
-
 int
-afr_fsetattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fsetattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fsetattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fsetattr,
-			   local->fd, &local->cont.fsetattr.in_buf,
-			   local->cont.fsetattr.valid, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fsetattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsetattr, local->fd,
+                      &local->cont.fsetattr.in_buf, local->cont.fsetattr.valid,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fsetattr (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, struct iatt *buf, int32_t valid, dict_t *xdata)
+afr_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *buf,
+             int32_t valid, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fsetattr.in_buf = *buf;
-        local->cont.fsetattr.valid  = valid;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.fsetattr.in_buf = *buf;
+    local->cont.fsetattr.valid = valid;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fsetattr_wind;
-        local->transaction.unwind = afr_fsetattr_unwind;
+    local->transaction.wind = afr_fsetattr_wind;
+    local->transaction.unwind = afr_fsetattr_unwind;
 
-        local->fd                 = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FSETATTR;
+    local->op = GF_FOP_FSETATTR;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* {{{ setxattr */
 
-
 int
-afr_setxattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_setxattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (setxattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(setxattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_setxattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_setxattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_setxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_setxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t      *local         = NULL;
-        afr_private_t    *priv          = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_setxattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->setxattr,
-			   &local->loc, local->cont.setxattr.dict,
-			   local->cont.setxattr.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_setxattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->setxattr, &local->loc,
+                      local->cont.setxattr.dict, local->cont.setxattr.flags,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_emptyb_set_pending_changelog_cbk (call_frame_t *frame, void *cookie,
-                                  xlator_t *this, int op_ret, int op_errno,
-                                  dict_t *xattr, dict_t *xdata)
+afr_emptyb_set_pending_changelog_cbk(call_frame_t *frame, void *cookie,
+                                     xlator_t *this, int op_ret, int op_errno,
+                                     dict_t *xattr, dict_t *xdata)
 
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int i, ret = 0;
-        char *op_type = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i, ret = 0;
+    char *op_type = NULL;
 
-        local = frame->local;
-        priv = this->private;
-        i = (long) cookie;
+    local = frame->local;
+    priv = this->private;
+    i = (long)cookie;
 
-        local->replies[i].valid = 1;
-        local->replies[i].op_ret = op_ret;
-        local->replies[i].op_errno = op_errno;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
 
-        ret = dict_get_str (local->xdata_req, "replicate-brick-op", &op_type);
-        if (ret)
-                goto out;
+    ret = dict_get_str(local->xdata_req, "replicate-brick-op", &op_type);
+    if (ret)
+        goto out;
 
-        gf_msg (this->name, op_ret ? GF_LOG_ERROR : GF_LOG_INFO,
-                op_ret ? op_errno : 0,
-                afr_get_msg_id (op_type),
-                "Set of pending xattr %s on"
-                " %s.", op_ret ? "failed" : "succeeded",
-                priv->children[i]->name);
+    gf_msg(this->name, op_ret ? GF_LOG_ERROR : GF_LOG_INFO,
+           op_ret ? op_errno : 0, afr_get_msg_id(op_type),
+           "Set of pending xattr %s on"
+           " %s.",
+           op_ret ? "failed" : "succeeded", priv->children[i]->name);
 
 out:
-        syncbarrier_wake (&local->barrier);
-        return 0;
+    syncbarrier_wake(&local->barrier);
+    return 0;
 }
 
 int
-afr_emptyb_set_pending_changelog (call_frame_t *frame, xlator_t *this,
-                                unsigned char *locked_nodes)
+afr_emptyb_set_pending_changelog(call_frame_t *frame, xlator_t *this,
+                                 unsigned char *locked_nodes)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int ret = 0, i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int ret = 0, i = 0;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        AFR_ONLIST (locked_nodes, frame, afr_emptyb_set_pending_changelog_cbk,
-                    xattrop, &local->loc, GF_XATTROP_ADD_ARRAY,
-                    local->xattr_req, NULL);
+    AFR_ONLIST(locked_nodes, frame, afr_emptyb_set_pending_changelog_cbk,
+               xattrop, &local->loc, GF_XATTROP_ADD_ARRAY, local->xattr_req,
+               NULL);
 
-        /* It is sufficient if xattrop was successful on one child */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-
-                if (local->replies[i].op_ret == 0) {
-                        ret = 0;
-                        goto out;
-                } else {
-                        ret = afr_higher_errno (ret,
-                                                local->replies[i].op_errno);
-                }
+    /* It is sufficient if xattrop was successful on one child */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+
+        if (local->replies[i].op_ret == 0) {
+            ret = 0;
+            goto out;
+        } else {
+            ret = afr_higher_errno(ret, local->replies[i].op_errno);
         }
+    }
 out:
-        return -ret;
+    return -ret;
 }
 
 int
-_afr_handle_empty_brick_type (xlator_t *this, call_frame_t *frame,
-                            loc_t *loc, int empty_index,
-                            afr_transaction_type type,
-                            char *op_type)
+_afr_handle_empty_brick_type(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                             int empty_index, afr_transaction_type type,
+                             char *op_type)
 {
-        int              count            = 0;
-        int              ret              = -ENOMEM;
-        int              idx              = -1;
-        int              d_idx            = -1;
-        unsigned char   *locked_nodes     = NULL;
-        afr_local_t     *local            = NULL;
-        afr_private_t   *priv             = NULL;
+    int count = 0;
+    int ret = -ENOMEM;
+    int idx = -1;
+    int d_idx = -1;
+    unsigned char *locked_nodes = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        locked_nodes = alloca0 (priv->child_count);
+    locked_nodes = alloca0(priv->child_count);
 
-        idx = afr_index_for_transaction_type (type);
-        d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
+    idx = afr_index_for_transaction_type(type);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
 
-        local->pending = afr_matrix_create (priv->child_count,
-                                            AFR_NUM_CHANGE_LOGS);
-        if (!local->pending)
-                goto out;
+    local->pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!local->pending)
+        goto out;
 
-        local->pending[empty_index][idx] = hton32 (1);
+    local->pending[empty_index][idx] = hton32(1);
 
-        if ((priv->esh_granular) && (type == AFR_ENTRY_TRANSACTION))
-                        local->pending[empty_index][d_idx] = hton32 (1);
+    if ((priv->esh_granular) && (type == AFR_ENTRY_TRANSACTION))
+        local->pending[empty_index][d_idx] = hton32(1);
 
-        local->xdata_req = dict_new ();
-        if (!local->xdata_req)
-                goto out;
+    local->xdata_req = dict_new();
+    if (!local->xdata_req)
+        goto out;
 
-        ret = dict_set_str (local->xdata_req, "replicate-brick-op", op_type);
-        if (ret)
-                goto out;
+    ret = dict_set_str(local->xdata_req, "replicate-brick-op", op_type);
+    if (ret)
+        goto out;
 
-        local->xattr_req = dict_new ();
-        if (!local->xattr_req)
-                goto out;
+    local->xattr_req = dict_new();
+    if (!local->xattr_req)
+        goto out;
 
-        ret = afr_set_pending_dict (priv, local->xattr_req, local->pending);
-        if (ret < 0)
-                goto out;
+    ret = afr_set_pending_dict(priv, local->xattr_req, local->pending);
+    if (ret < 0)
+        goto out;
 
-        if (AFR_ENTRY_TRANSACTION == type) {
-                count = afr_selfheal_entrylk (frame, this, loc->inode,
-                                              this->name, NULL, locked_nodes);
-        } else {
-                count = afr_selfheal_inodelk (frame, this, loc->inode,
-                                              this->name, LLONG_MAX - 1, 0,
-                                              locked_nodes);
-        }
+    if (AFR_ENTRY_TRANSACTION == type) {
+        count = afr_selfheal_entrylk(frame, this, loc->inode, this->name, NULL,
+                                     locked_nodes);
+    } else {
+        count = afr_selfheal_inodelk(frame, this, loc->inode, this->name,
+                                     LLONG_MAX - 1, 0, locked_nodes);
+    }
 
-        if (!count) {
-                gf_msg (this->name, GF_LOG_ERROR, EAGAIN,
-                        AFR_MSG_REPLACE_BRICK_STATUS, "Couldn't acquire lock on"
-                        " any child.");
-                ret = -EAGAIN;
-                goto unlock;
-        }
+    if (!count) {
+        gf_msg(this->name, GF_LOG_ERROR, EAGAIN, AFR_MSG_REPLACE_BRICK_STATUS,
+               "Couldn't acquire lock on"
+               " any child.");
+        ret = -EAGAIN;
+        goto unlock;
+    }
 
-        ret = afr_emptyb_set_pending_changelog (frame, this, locked_nodes);
-        if (ret)
-                goto unlock;
-        ret = 0;
+    ret = afr_emptyb_set_pending_changelog(frame, this, locked_nodes);
+    if (ret)
+        goto unlock;
+    ret = 0;
 unlock:
-        if (AFR_ENTRY_TRANSACTION == type) {
-                afr_selfheal_unentrylk (frame, this, loc->inode, this->name,
-                                        NULL, locked_nodes, NULL);
-        } else {
-                afr_selfheal_uninodelk (frame, this, loc->inode, this->name,
-                                        LLONG_MAX - 1, 0, locked_nodes);
-        }
+    if (AFR_ENTRY_TRANSACTION == type) {
+        afr_selfheal_unentrylk(frame, this, loc->inode, this->name, NULL,
+                               locked_nodes, NULL);
+    } else {
+        afr_selfheal_uninodelk(frame, this, loc->inode, this->name,
+                               LLONG_MAX - 1, 0, locked_nodes);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 void
-afr_brick_args_cleanup (void *opaque)
+afr_brick_args_cleanup(void *opaque)
 {
-        afr_empty_brick_args_t *data = NULL;
+    afr_empty_brick_args_t *data = NULL;
 
-        data = opaque;
-        loc_wipe (&data->loc);
-        GF_FREE (data);
+    data = opaque;
+    loc_wipe(&data->loc);
+    GF_FREE(data);
 }
 
 int
-_afr_handle_empty_brick_cbk (int ret, call_frame_t *frame, void *opaque)
+_afr_handle_empty_brick_cbk(int ret, call_frame_t *frame, void *opaque)
 {
-        afr_brick_args_cleanup (opaque);
-        return 0;
+    afr_brick_args_cleanup(opaque);
+    return 0;
 }
 
 int
-_afr_handle_empty_brick (void *opaque)
+_afr_handle_empty_brick(void *opaque)
 {
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int empty_index = -1;
+    int ret = -1;
+    int op_errno = ENOMEM;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    char *op_type = NULL;
+    afr_empty_brick_args_t *data = NULL;
 
-        afr_local_t     *local          = NULL;
-        afr_private_t   *priv           = NULL;
-        int              empty_index       = -1;
-        int              ret            = -1;
-        int              op_errno       = ENOMEM;
-        call_frame_t    *frame          = NULL;
-        xlator_t        *this           = NULL;
-        char            *op_type        = NULL;
-        afr_empty_brick_args_t *data  = NULL;
+    data = opaque;
+    frame = data->frame;
+    empty_index = data->empty_index;
+    op_type = data->op_type;
+    this = frame->this;
+    priv = this->private;
 
-        data = opaque;
-        frame = data->frame;
-        empty_index = data->empty_index;
-        op_type = data->op_type;
-        this = frame->this;
-        priv = this->private;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local)
-                goto out;
+    loc_copy(&local->loc, &data->loc);
 
-        loc_copy (&local->loc, &data->loc);
+    gf_msg(this->name, GF_LOG_INFO, 0, 0, "New brick is : %s",
+           priv->children[empty_index]->name);
 
-        gf_msg (this->name, GF_LOG_INFO, 0, 0, "New brick is : %s",
-                priv->children[empty_index]->name);
+    ret = _afr_handle_empty_brick_type(this, frame, &local->loc, empty_index,
+                                       AFR_METADATA_TRANSACTION, op_type);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        ret = _afr_handle_empty_brick_type (this, frame, &local->loc, empty_index,
-                                          AFR_METADATA_TRANSACTION, op_type);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        dict_unref (local->xdata_req);
-        dict_unref (local->xattr_req);
-        afr_matrix_cleanup (local->pending, priv->child_count);
-        local->pending = NULL;
-        local->xattr_req = NULL;
-        local->xdata_req = NULL;
+    dict_unref(local->xdata_req);
+    dict_unref(local->xattr_req);
+    afr_matrix_cleanup(local->pending, priv->child_count);
+    local->pending = NULL;
+    local->xattr_req = NULL;
+    local->xdata_req = NULL;
 
-        ret = _afr_handle_empty_brick_type (this, frame, &local->loc, empty_index,
-                                          AFR_ENTRY_TRANSACTION, op_type);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+    ret = _afr_handle_empty_brick_type(this, frame, &local->loc, empty_index,
+                                       AFR_ENTRY_TRANSACTION, op_type);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 out:
-        AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    return 0;
+}
+
+int
+afr_split_brain_resolve_do(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                           char *data)
+{
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    local->xdata_req = dict_new();
+
+    if (!local->xdata_req) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    ret = dict_set_int32(local->xdata_req, "heal-op",
+                         GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_str(local->xdata_req, "child-name", data);
+    if (ret) {
+        op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+    /* set spb choice to -1 whether heal succeeds or not:
+     * If heal succeeds : spb-choice should be set to -1 as
+     *                    it is no longer valid; file is not
+     *                    in split-brain anymore.
+     * If heal doesn't succeed:
+     *                    spb-choice should be set to -1
+     *                    otherwise reads will be served
+     *                    from spb-choice which is misleading.
+     */
+    ret = afr_inode_split_brain_choice_set(loc->inode, this, -1);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+               "Failed to set"
+               "split-brain choice to -1");
+    afr_heal_splitbrain_file(frame, this, loc);
+    ret = 0;
+out:
+    if (ret < 0)
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-afr_split_brain_resolve_do (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                            char *data)
+afr_get_split_brain_child_index(xlator_t *this, void *value, size_t len)
 {
-        afr_local_t    *local             = NULL;
-        int     ret                       = -1;
-        int     op_errno                  = EINVAL;
+    int spb_child_index = -1;
+    char *spb_child_str = NULL;
 
-        local = frame->local;
-        local->xdata_req = dict_new ();
+    spb_child_str = alloca0(len + 1);
+    memcpy(spb_child_str, value, len);
 
-        if (!local->xdata_req) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (!strcmp(spb_child_str, "none"))
+        return -2;
 
-        ret = dict_set_int32 (local->xdata_req, "heal-op",
-                              GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_str (local->xdata_req, "child-name", data);
-        if (ret) {
-                op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-        /* set spb choice to -1 whether heal succeeds or not:
-         * If heal succeeds : spb-choice should be set to -1 as
-         *                    it is no longer valid; file is not
-         *                    in split-brain anymore.
-         * If heal doesn't succeed:
-         *                    spb-choice should be set to -1
-         *                    otherwise reads will be served
-         *                    from spb-choice which is misleading.
-         */
-        ret = afr_inode_split_brain_choice_set (loc->inode, this, -1);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR, "Failed to set"
-                        "split-brain choice to -1");
-        afr_heal_splitbrain_file (frame, this, loc);
-        ret = 0;
-out:
-        if (ret < 0)
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-        return 0;
+    spb_child_index = afr_get_child_index_from_name(this, spb_child_str);
+    if (spb_child_index < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+               "Invalid subvol: %s", spb_child_str);
+    }
+    return spb_child_index;
 }
 
 int
-afr_get_split_brain_child_index (xlator_t *this, void *value, size_t len)
+afr_can_set_split_brain_choice(void *opaque)
 {
-        int             spb_child_index   = -1;
-        char           *spb_child_str     = NULL;
+    afr_spbc_timeout_t *data = opaque;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    loc_t *loc = NULL;
+    int ret = -1;
 
-        spb_child_str =  alloca0 (len + 1);
-        memcpy (spb_child_str, value, len);
+    frame = data->frame;
+    loc = data->loc;
+    this = frame->this;
 
-        if (!strcmp (spb_child_str, "none"))
-                return -2;
+    ret = afr_is_split_brain(frame, this, loc->inode, loc->gfid, &data->d_spb,
+                             &data->m_spb);
 
-        spb_child_index = afr_get_child_index_from_name (this,
-                                                         spb_child_str);
-        if (spb_child_index < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_SUBVOL, "Invalid subvol: %s",
-                        spb_child_str);
-        }
-        return spb_child_index;
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+               "Failed to determine if %s"
+               " is in split-brain. "
+               "Aborting split-brain-choice set.",
+               uuid_utoa(loc->gfid));
+    return ret;
 }
 
 int
-afr_can_set_split_brain_choice (void *opaque)
+afr_handle_split_brain_commands(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                                dict_t *dict)
 {
-        afr_spbc_timeout_t        *data         = opaque;
-        call_frame_t              *frame        = NULL;
-        xlator_t                  *this         = NULL;
-        loc_t                     *loc          = NULL;
-        int                        ret          = -1;
+    void *value = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_spbc_timeout_t *data = NULL;
+    int len = 0;
+    int spb_child_index = -1;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        frame = data->frame;
-        loc = data->loc;
-        this = frame->this;
+    priv = this->private;
 
-        ret = afr_is_split_brain (frame, this, loc->inode, loc->gfid,
-                                  &data->d_spb, &data->m_spb);
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local) {
+        ret = 1;
+        goto out;
+    }
 
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                        "Failed to determine if %s"
-                        " is in split-brain. "
-                        "Aborting split-brain-choice set.",
-                        uuid_utoa (loc->gfid));
-        return ret;
-}
+    local->op = GF_FOP_SETXATTR;
 
-int
-afr_handle_split_brain_commands (xlator_t *this, call_frame_t *frame,
-                                loc_t *loc, dict_t *dict)
-{
-        void           *value             = NULL;
-        afr_private_t  *priv              = NULL;
-        afr_local_t    *local             = NULL;
-        afr_spbc_timeout_t *data          = NULL;
-        int             len               = 0;
-        int             spb_child_index   = -1;
-        int             ret               = -1;
-        int             op_errno          = EINVAL;
-
-        priv = this->private;
-
-        local = AFR_FRAME_INIT (frame, op_errno);
-        if (!local) {
+    ret = dict_get_ptr_and_len(dict, GF_AFR_SBRAIN_CHOICE, &value, &len);
+    if (value) {
+        spb_child_index = afr_get_split_brain_child_index(this, value, len);
+        if (spb_child_index < 0) {
+            /* Case where value was "none" */
+            if (spb_child_index == -2)
+                spb_child_index = -1;
+            else {
                 ret = 1;
+                op_errno = EINVAL;
                 goto out;
+            }
         }
 
-        local->op = GF_FOP_SETXATTR;
-
-        ret =  dict_get_ptr_and_len (dict, GF_AFR_SBRAIN_CHOICE, &value,
-                                     &len);
-        if (value) {
-                spb_child_index = afr_get_split_brain_child_index (this, value,
-                                                                   len);
-                if (spb_child_index < 0) {
-                        /* Case where value was "none" */
-                        if (spb_child_index == -2)
-                                spb_child_index = -1;
-                        else {
-                                ret = 1;
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                }
-
-                data = GF_CALLOC (1, sizeof (*data), gf_afr_mt_spbc_timeout_t);
-                if (!data) {
-                        ret = 1;
-                        goto out;
-                }
-                data->spb_child_index = spb_child_index;
-                data->frame = frame;
-                loc_copy (&local->loc, loc);
-                data->loc = &local->loc;
-                ret = synctask_new (this->ctx->env,
-                                    afr_can_set_split_brain_choice,
-                                    afr_set_split_brain_choice, NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
-                                "Failed to create"
-                                " synctask. Aborting split-brain choice set"
-                                " for %s", loc->name);
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                ret = 0;
-                goto out;
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_spbc_timeout_t);
+        if (!data) {
+            ret = 1;
+            goto out;
         }
+        data->spb_child_index = spb_child_index;
+        data->frame = frame;
+        loc_copy(&local->loc, loc);
+        data->loc = &local->loc;
+        ret = synctask_new(this->ctx->env, afr_can_set_split_brain_choice,
+                           afr_set_split_brain_choice, NULL, data);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   AFR_MSG_SPLIT_BRAIN_CHOICE_ERROR,
+                   "Failed to create"
+                   " synctask. Aborting split-brain choice set"
+                   " for %s",
+                   loc->name);
+            ret = 1;
+            op_errno = ENOMEM;
+            goto out;
+        }
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_get_ptr_and_len (dict, GF_AFR_SBRAIN_RESOLVE, &value, &len);
-        if (value) {
-                spb_child_index = afr_get_split_brain_child_index (this, value,
-                                                                   len);
-                if (spb_child_index < 0) {
-                        ret = 1;
-                        goto out;
-                }
-
-                afr_split_brain_resolve_do (frame, this, loc,
-                                            priv->children[spb_child_index]->name);
-                ret = 0;
+    ret = dict_get_ptr_and_len(dict, GF_AFR_SBRAIN_RESOLVE, &value, &len);
+    if (value) {
+        spb_child_index = afr_get_split_brain_child_index(this, value, len);
+        if (spb_child_index < 0) {
+            ret = 1;
+            goto out;
         }
+
+        afr_split_brain_resolve_do(frame, this, loc,
+                                   priv->children[spb_child_index]->name);
+        ret = 0;
+    }
 out:
-        /* key was correct but value was invalid when ret == 1 */
-        if (ret == 1) {
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-                if (data)
-                        GF_FREE (data);
-                ret = 0;
-        }
-        return ret;
+    /* key was correct but value was invalid when ret == 1 */
+    if (ret == 1) {
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+        if (data)
+            GF_FREE(data);
+        ret = 0;
+    }
+    return ret;
 }
 
 int
-afr_handle_spb_choice_timeout (xlator_t *this, call_frame_t *frame,
-                               dict_t *dict)
+afr_handle_spb_choice_timeout(xlator_t *this, call_frame_t *frame, dict_t *dict)
 {
-        int             ret               = -1;
-        int             op_errno          = 0;
-        uint64_t        timeout           = 0;
-        afr_private_t  *priv              = NULL;
+    int ret = -1;
+    int op_errno = 0;
+    uint64_t timeout = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        ret = dict_get_uint64 (dict, GF_AFR_SPB_CHOICE_TIMEOUT, &timeout);
-        if (!ret) {
-                priv->spb_choice_timeout = timeout * 60;
-                AFR_STACK_UNWIND (setxattr, frame, ret, op_errno, NULL);
-        }
+    ret = dict_get_uint64(dict, GF_AFR_SPB_CHOICE_TIMEOUT, &timeout);
+    if (!ret) {
+        priv->spb_choice_timeout = timeout * 60;
+        AFR_STACK_UNWIND(setxattr, frame, ret, op_errno, NULL);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-afr_handle_empty_brick (xlator_t *this, call_frame_t *frame, loc_t *loc,
-                        dict_t *dict)
+afr_handle_empty_brick(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                       dict_t *dict)
 {
-        int             ret               = -1;
-        int             ab_ret            = -1;
-        int             empty_index        = -1;
-        int             op_errno          = EPERM;
-        char           *empty_brick         = NULL;
-        char           *op_type           = NULL;
-        afr_empty_brick_args_t *data        = NULL;
+    int ret = -1;
+    int ab_ret = -1;
+    int empty_index = -1;
+    int op_errno = EPERM;
+    char *empty_brick = NULL;
+    char *op_type = NULL;
+    afr_empty_brick_args_t *data = NULL;
 
-        ret =  dict_get_str (dict, GF_AFR_REPLACE_BRICK, &empty_brick);
-        if (!ret)
-                op_type = GF_AFR_REPLACE_BRICK;
+    ret = dict_get_str(dict, GF_AFR_REPLACE_BRICK, &empty_brick);
+    if (!ret)
+        op_type = GF_AFR_REPLACE_BRICK;
 
-        ab_ret = dict_get_str (dict, GF_AFR_ADD_BRICK, &empty_brick);
-        if (!ab_ret)
-                op_type = GF_AFR_ADD_BRICK;
+    ab_ret = dict_get_str(dict, GF_AFR_ADD_BRICK, &empty_brick);
+    if (!ab_ret)
+        op_type = GF_AFR_ADD_BRICK;
 
-        if (ret && ab_ret)
-                goto out;
+    if (ret && ab_ret)
+        goto out;
 
-        if (frame->root->pid != GF_CLIENT_PID_SELF_HEALD) {
-                gf_msg (this->name, GF_LOG_ERROR, EPERM,
-                        afr_get_msg_id (op_type),
-                        "'%s' is an internal extended attribute.",
-                        op_type);
-                ret = 1;
-                goto out;
+    if (frame->root->pid != GF_CLIENT_PID_SELF_HEALD) {
+        gf_msg(this->name, GF_LOG_ERROR, EPERM, afr_get_msg_id(op_type),
+               "'%s' is an internal extended attribute.", op_type);
+        ret = 1;
+        goto out;
+    }
+    empty_index = afr_get_child_index_from_name(this, empty_brick);
+
+    if (empty_index < 0) {
+        /* Didn't belong to this replica pair
+         * Just do a no-op
+         */
+        AFR_STACK_UNWIND(setxattr, frame, 0, 0, NULL);
+        return 0;
+    } else {
+        data = GF_CALLOC(1, sizeof(*data), gf_afr_mt_empty_brick_t);
+        if (!data) {
+            ret = 1;
+            op_errno = ENOMEM;
+            goto out;
         }
-        empty_index = afr_get_child_index_from_name (this, empty_brick);
-
-        if (empty_index < 0) {
-                 /* Didn't belong to this replica pair
-                  * Just do a no-op
-                  */
-                AFR_STACK_UNWIND (setxattr, frame, 0, 0, NULL);
-                return 0;
-        } else {
-                data = GF_CALLOC (1, sizeof (*data),
-                                  gf_afr_mt_empty_brick_t);
-                if (!data) {
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        goto out;
-                }
-                data->frame = frame;
-                loc_copy (&data->loc, loc);
-                data->empty_index = empty_index;
-                data->op_type = op_type;
-                ret = synctask_new (this->ctx->env,
-                                    _afr_handle_empty_brick,
-                                    _afr_handle_empty_brick_cbk,
-                                    NULL, data);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                afr_get_msg_id (op_type),
-                                "Failed to create synctask.");
-                        ret = 1;
-                        op_errno = ENOMEM;
-                        afr_brick_args_cleanup (data);
-                        goto out;
-                }
+        data->frame = frame;
+        loc_copy(&data->loc, loc);
+        data->empty_index = empty_index;
+        data->op_type = op_type;
+        ret = synctask_new(this->ctx->env, _afr_handle_empty_brick,
+                           _afr_handle_empty_brick_cbk, NULL, data);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, afr_get_msg_id(op_type),
+                   "Failed to create synctask.");
+            ret = 1;
+            op_errno = ENOMEM;
+            afr_brick_args_cleanup(data);
+            goto out;
         }
-        ret = 0;
+    }
+    ret = 0;
 out:
-        if (ret == 1) {
-                AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
-                ret = 0;
-        }
-        return ret;
+    if (ret == 1) {
+        AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+        ret = 0;
+    }
+    return ret;
 }
 
 static int
-afr_handle_special_xattr (xlator_t *this, call_frame_t *frame, loc_t *loc,
-                          dict_t *dict)
+afr_handle_special_xattr(xlator_t *this, call_frame_t *frame, loc_t *loc,
+                         dict_t *dict)
 {
-        int     ret     = -1;
+    int ret = -1;
 
-        ret = afr_handle_split_brain_commands (this, frame, loc, dict);
-        if (ret == 0)
-                goto out;
+    ret = afr_handle_split_brain_commands(this, frame, loc, dict);
+    if (ret == 0)
+        goto out;
 
-        ret = afr_handle_spb_choice_timeout (this, frame, dict);
-        if (ret == 0)
-                goto out;
+    ret = afr_handle_spb_choice_timeout(this, frame, dict);
+    if (ret == 0)
+        goto out;
 
-        /* Applicable for replace-brick and add-brick commands */
-        ret = afr_handle_empty_brick (this, frame, loc, dict);
+    /* Applicable for replace-brick and add-brick commands */
+    ret = afr_handle_empty_brick(this, frame, loc, dict);
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-	      int32_t flags, dict_t *xdata)
+afr_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+             int32_t flags, dict_t *xdata)
 {
-        afr_local_t    *local             = NULL;
-        call_frame_t   *transaction_frame = NULL;
-        int             ret               = -1;
-        int             op_errno          = EINVAL;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = EINVAL;
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.afr.*", dict, op_errno, out);
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.afr.*", dict, op_errno, out);
 
-        ret = afr_handle_special_xattr (this, frame, loc, dict);
-        if (ret == 0)
-                return 0;
+    ret = afr_handle_special_xattr(this, frame, loc, dict);
+    if (ret == 0)
+        return 0;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.setxattr.dict  = dict_ref (dict);
-        local->cont.setxattr.flags = flags;
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.setxattr.dict = dict_ref(dict);
+    local->cont.setxattr.flags = flags;
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_setxattr_wind;
-        local->transaction.unwind = afr_setxattr_unwind;
+    local->transaction.wind = afr_setxattr_wind;
+    local->transaction.unwind = afr_setxattr_unwind;
 
-        loc_copy (&local->loc, loc);
-        ret = afr_set_inode_local (this, local, loc->inode);
-        if (ret)
-                goto out;
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-	local->op = GF_FOP_SETXATTR;
+    local->op = GF_FOP_SETXATTR;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* {{{ fsetxattr */
 
-
 int
-afr_fsetxattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fsetxattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t    *local         = NULL;
-        call_frame_t   *main_frame    = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (fsetxattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fsetxattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fsetxattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_fsetxattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_fsetxattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fsetxattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t        *local       = NULL;
-        afr_private_t      *priv        = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fsetxattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fsetxattr,
-			   local->fd, local->cont.fsetxattr.dict,
-			   local->cont.fsetxattr.flags, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fsetxattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsetxattr, local->fd,
+                      local->cont.fsetxattr.dict, local->cont.fsetxattr.flags,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fsetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+afr_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+              int32_t flags, dict_t *xdata)
 {
-        afr_local_t      *local             = NULL;
-        call_frame_t     *transaction_frame = NULL;
-        int               ret               = -1;
-        int               op_errno          = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.afr.*", dict, op_errno, out);
 
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.afr.*", dict,
-                                   op_errno, out);
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.afr.*", dict, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fsetxattr.dict  = dict_ref (dict);
-        local->cont.fsetxattr.flags = flags;
+    local->cont.fsetxattr.dict = dict_ref(dict);
+    local->cont.fsetxattr.flags = flags;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fsetxattr_wind;
-        local->transaction.unwind = afr_fsetxattr_unwind;
+    local->transaction.wind = afr_fsetxattr_wind;
+    local->transaction.unwind = afr_fsetxattr_unwind;
 
-        local->fd                 = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FSETXATTR;
+    local->op = GF_FOP_FSETXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start  = LLONG_MAX - 1;
-        local->transaction.len    = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
 /* }}} */
 
-
 /* {{{ removexattr */
 
-
 int
-afr_removexattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_removexattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (removexattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(removexattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_removexattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_removexattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_removexattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_removexattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_removexattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->removexattr,
-			   &local->loc, local->cont.removexattr.name,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_removexattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->removexattr, &local->loc,
+                      local->cont.removexattr.name, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_removexattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, const char *name, dict_t *xdata)
+afr_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *name, dict_t *xdata)
 {
-        afr_local_t     *local             = NULL;
-        call_frame_t    *transaction_frame = NULL;
-        int              ret               = -1;
-        int              op_errno          = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.afr.*", name, op_errno, out);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.afr.*", name, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.removexattr.name = gf_strdup (name);
+    local->cont.removexattr.name = gf_strdup(name);
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_removexattr_wind;
-        local->transaction.unwind = afr_removexattr_unwind;
+    local->transaction.wind = afr_removexattr_wind;
+    local->transaction.unwind = afr_removexattr_unwind;
 
-        loc_copy (&local->loc, loc);
-        ret = afr_set_inode_local (this, local, loc->inode);
-        if (ret)
-                goto out;
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_REMOVEXATTR;
+    local->op = GF_FOP_REMOVEXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
-        return 0;
+    AFR_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
 /* ffremovexattr */
 int
-afr_fremovexattr_unwind (call_frame_t *frame, xlator_t *this)
+afr_fremovexattr_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fremovexattr, main_frame, local->op_ret, local->op_errno,
-			  local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fremovexattr, main_frame, local->op_ret, local->op_errno,
+                     local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fremovexattr_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+afr_fremovexattr_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, NULL, xdata);
 }
 
-
 int
-afr_fremovexattr_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fremovexattr_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fremovexattr_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fremovexattr,
-			   local->fd, local->cont.removexattr.name,
-			   local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fremovexattr_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fremovexattr, local->fd,
+                      local->cont.removexattr.name, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		  const char *name, dict_t *xdata)
+afr_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 const char *name, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.afr.*", name, op_errno, out);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.afr.*",
-                                 name, op_errno, out);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.afr.*", name, op_errno, out);
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-                goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.removexattr.name = gf_strdup (name);
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    local->cont.removexattr.name = gf_strdup(name);
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->transaction.wind   = afr_fremovexattr_wind;
-        local->transaction.unwind = afr_fremovexattr_unwind;
+    local->transaction.wind = afr_fremovexattr_wind;
+    local->transaction.unwind = afr_fremovexattr_unwind;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FREMOVEXATTR;
+    local->op = GF_FOP_FREMOVEXATTR;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
+    AFR_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fallocate_unwind (call_frame_t *frame, xlator_t *this)
+afr_fallocate_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fallocate, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(fallocate, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_fallocate_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_fallocate_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_fallocate_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fallocate_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fallocate_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fallocate,
-			   local->fd, local->cont.fallocate.mode,
-			   local->cont.fallocate.offset,
-			   local->cont.fallocate.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fallocate_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fallocate, local->fd,
+                      local->cont.fallocate.mode, local->cont.fallocate.offset,
+                      local->cont.fallocate.len, local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-               off_t offset, size_t len, dict_t *xdata)
+afr_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata)
 {
-        call_frame_t *transaction_frame = NULL;
-        afr_local_t *local = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    call_frame_t *transaction_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.fallocate.mode = mode;
-        local->cont.fallocate.offset  = offset;
-        local->cont.fallocate.len = len;
+    local->cont.fallocate.mode = mode;
+    local->cont.fallocate.offset = offset;
+    local->cont.fallocate.len = len;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_FALLOCATE;
+    local->op = GF_FOP_FALLOCATE;
 
-        local->transaction.wind   = afr_fallocate_wind;
-        local->transaction.unwind = afr_fallocate_unwind;
+    local->transaction.wind = afr_fallocate_wind;
+    local->transaction.unwind = afr_fallocate_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.fallocate.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.fallocate.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* }}} */
 
 /* {{{ discard */
 
 int
-afr_discard_unwind (call_frame_t *frame, xlator_t *this)
+afr_discard_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (discard, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(discard, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_discard_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+afr_discard_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_discard_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_discard_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_discard_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->discard,
-			   local->fd, local->cont.discard.offset,
-			   local->cont.discard.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_discard_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->discard, local->fd,
+                      local->cont.discard.offset, local->cont.discard.len,
+                      local->xdata_req);
+    return 0;
 }
 
-
 int
-afr_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             size_t len, dict_t *xdata)
+afr_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.discard.offset  = offset;
-        local->cont.discard.len = len;
+    local->cont.discard.offset = offset;
+    local->cont.discard.len = len;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_DISCARD;
+    local->op = GF_FOP_DISCARD;
 
-        local->transaction.wind   = afr_discard_wind;
-        local->transaction.unwind = afr_discard_unwind;
+    local->transaction.wind = afr_discard_wind;
+    local->transaction.unwind = afr_discard_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.discard.offset;
-        local->transaction.len     = 0;
+    local->transaction.start = local->cont.discard.offset;
+    local->transaction.len = 0;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* {{{ zerofill */
 
 int
-afr_zerofill_unwind (call_frame_t *frame, xlator_t *this)
+afr_zerofill_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (discard, main_frame, local->op_ret, local->op_errno,
-			  &local->cont.inode_wfop.prebuf,
-			  &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
-}
 
+    AFR_STACK_UNWIND(discard, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    return 0;
+}
 
 int
-afr_zerofill_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+afr_zerofill_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                       struct iatt *postbuf, dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_zerofill_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_zerofill_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_zerofill_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->zerofill,
-			   local->fd, local->cont.zerofill.offset,
-			   local->cont.zerofill.len, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_zerofill_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->zerofill, local->fd,
+                      local->cont.zerofill.offset, local->cont.zerofill.len,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+afr_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
              size_t len, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-	transaction_frame = copy_frame (frame);
-	if (!transaction_frame)
-		goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.zerofill.offset  = offset;
-        local->cont.zerofill.len = len;
+    local->cont.zerofill.offset = offset;
+    local->cont.zerofill.len = len;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	if (xdata)
-		local->xdata_req = dict_copy_with_ref (xdata, NULL);
-	else
-		local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-	if (!local->xdata_req)
-		goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->op = GF_FOP_ZEROFILL;
+    local->op = GF_FOP_ZEROFILL;
 
-        local->transaction.wind   = afr_zerofill_wind;
-        local->transaction.unwind = afr_zerofill_unwind;
+    local->transaction.wind = afr_zerofill_wind;
+    local->transaction.unwind = afr_zerofill_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        local->transaction.start   = local->cont.discard.offset;
-        local->transaction.len     = len;
+    local->transaction.start = local->cont.discard.offset;
+    local->transaction.len = len;
 
-        afr_fix_open (fd, this);
+    afr_fix_open(fd, this);
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 /* }}} */
 
 int32_t
-afr_xattrop_wind_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret, int32_t op_errno,
-                      dict_t *xattr, dict_t *xdata)
+afr_xattrop_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                     dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, xattr, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, xattr, xdata);
 }
 
 int
-afr_xattrop_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_xattrop_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_xattrop_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->xattrop,
-			   &local->loc, local->cont.xattrop.optype,
-			   local->cont.xattrop.xattr, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_xattrop_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->xattrop, &local->loc,
+                      local->cont.xattrop.optype, local->cont.xattrop.xattr,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_xattrop_unwind (call_frame_t *frame, xlator_t *this)
+afr_xattrop_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
-
-	AFR_STACK_UNWIND (xattrop, main_frame, local->op_ret, local->op_errno,
-			  local->xattr_rsp, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
+
+    AFR_STACK_UNWIND(xattrop, main_frame, local->op_ret, local->op_errno,
+                     local->xattr_rsp, local->xdata_rsp);
+    return 0;
 }
 
 int32_t
-afr_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
+afr_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.xattrop.xattr = dict_ref (xattr);
-        local->cont.xattrop.optype = optype;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->cont.xattrop.xattr = dict_ref(xattr);
+    local->cont.xattrop.optype = optype;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        local->transaction.wind   = afr_xattrop_wind;
-        local->transaction.unwind = afr_xattrop_unwind;
+    local->transaction.wind = afr_xattrop_wind;
+    local->transaction.unwind = afr_xattrop_unwind;
 
-        loc_copy (&local->loc, loc);
-        ret = afr_set_inode_local (this, local, loc->inode);
-        if (ret)
-                goto out;
+    loc_copy(&local->loc, loc);
+    ret = afr_set_inode_local(this, local, loc->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_XATTROP;
+    local->op = GF_FOP_XATTROP;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this, AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (xattrop, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int32_t
-afr_fxattrop_wind_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xattr, dict_t *xdata)
+afr_fxattrop_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                      dict_t *xdata)
 {
-	return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-				      NULL, NULL, xattr, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, NULL,
+                                 NULL, xattr, xdata);
 }
 
 int
-afr_fxattrop_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fxattrop_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	STACK_WIND_COOKIE (frame, afr_fxattrop_wind_cbk, (void *) (long) subvol,
-			   priv->children[subvol],
-			   priv->children[subvol]->fops->fxattrop,
-			   local->fd, local->cont.xattrop.optype,
-			   local->cont.xattrop.xattr, local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fxattrop_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fxattrop, local->fd,
+                      local->cont.xattrop.optype, local->cont.xattrop.xattr,
+                      local->xdata_req);
+    return 0;
 }
 
 int
-afr_fxattrop_unwind (call_frame_t *frame, xlator_t *this)
+afr_fxattrop_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *main_frame = NULL;
-
-        local = frame->local;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-	main_frame = afr_transaction_detach_fop_frame (frame);
-	if (!main_frame)
-		return 0;
+    local = frame->local;
 
-	AFR_STACK_UNWIND (fxattrop, main_frame, local->op_ret, local->op_errno,
-			  local->xattr_rsp, local->xdata_rsp);
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
         return 0;
+
+    AFR_STACK_UNWIND(fxattrop, main_frame, local->op_ret, local->op_errno,
+                     local->xattr_rsp, local->xdata_rsp);
+    return 0;
 }
 
 int32_t
-afr_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
+afr_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->cont.xattrop.xattr = dict_ref (xattr);
-        local->cont.xattrop.optype = optype;
-	if (xdata)
-		local->xdata_req = dict_ref (xdata);
+    local->cont.xattrop.xattr = dict_ref(xattr);
+    local->cont.xattrop.optype = optype;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
 
-        local->transaction.wind   = afr_fxattrop_wind;
-        local->transaction.unwind = afr_fxattrop_unwind;
+    local->transaction.wind = afr_fxattrop_wind;
+    local->transaction.unwind = afr_fxattrop_unwind;
 
-	local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-	local->op = GF_FOP_FXATTROP;
+    local->op = GF_FOP_FXATTROP;
 
-        local->transaction.main_frame = frame;
-        local->transaction.start   = LLONG_MAX - 1;
-        local->transaction.len     = 0;
+    local->transaction.main_frame = frame;
+    local->transaction.start = LLONG_MAX - 1;
+    local->transaction.len = 0;
 
-        ret = afr_transaction (transaction_frame, this,
-                               AFR_METADATA_TRANSACTION);
-        if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_METADATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fxattrop, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    AFR_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int
-afr_fsync_unwind (call_frame_t *frame, xlator_t *this)
+afr_fsync_unwind(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        call_frame_t   *main_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        main_frame = afr_transaction_detach_fop_frame (frame);
-        if (!main_frame)
-                return 0;
+    main_frame = afr_transaction_detach_fop_frame(frame);
+    if (!main_frame)
+        return 0;
 
-        AFR_STACK_UNWIND (fsync, main_frame, local->op_ret, local->op_errno,
-                          &local->cont.inode_wfop.prebuf,
-                          &local->cont.inode_wfop.postbuf, local->xdata_rsp);
+    AFR_STACK_UNWIND(fsync, main_frame, local->op_ret, local->op_errno,
+                     &local->cont.inode_wfop.prebuf,
+                     &local->cont.inode_wfop.postbuf, local->xdata_rsp);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_fsync_wind_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
+afr_fsync_wind_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-        return __afr_inode_write_cbk (frame, cookie, this, op_ret, op_errno,
-                                      prebuf, postbuf, NULL, xdata);
+    return __afr_inode_write_cbk(frame, cookie, this, op_ret, op_errno, prebuf,
+                                 postbuf, NULL, xdata);
 }
 
-
 int
-afr_fsync_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_fsync_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        STACK_WIND_COOKIE (frame, afr_fsync_wind_cbk, (void *)(long) subvol,
-                           priv->children[subvol],
-                           priv->children[subvol]->fops->fsync,
-                           local->fd, local->cont.fsync.datasync,
-                           local->xdata_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, afr_fsync_wind_cbk, (void *)(long)subvol,
+                      priv->children[subvol],
+                      priv->children[subvol]->fops->fsync, local->fd,
+                      local->cont.fsync.datasync, local->xdata_req);
+    return 0;
 }
 
 int
-afr_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-	   dict_t *xdata)
+afr_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+          dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        call_frame_t *transaction_frame = NULL;
-        int ret = -1;
-        int32_t op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    call_frame_t *transaction_frame = NULL;
+    int ret = -1;
+    int32_t op_errno = ENOMEM;
 
-        transaction_frame = copy_frame (frame);
-        if (!transaction_frame)
-                goto out;
+    transaction_frame = copy_frame(frame);
+    if (!transaction_frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (transaction_frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(transaction_frame, op_errno);
+    if (!local)
+        goto out;
 
-        if (xdata)
-                local->xdata_req = dict_copy_with_ref (xdata, NULL);
-        else
-                local->xdata_req = dict_new ();
+    if (xdata)
+        local->xdata_req = dict_copy_with_ref(xdata, NULL);
+    else
+        local->xdata_req = dict_new();
 
-        if (!local->xdata_req)
-                goto out;
+    if (!local->xdata_req)
+        goto out;
 
-        local->fd = fd_ref (fd);
-        ret = afr_set_inode_local (this, local, fd->inode);
-        if (ret)
-                goto out;
+    local->fd = fd_ref(fd);
+    ret = afr_set_inode_local(this, local, fd->inode);
+    if (ret)
+        goto out;
 
-        local->op = GF_FOP_FSYNC;
-        local->cont.fsync.datasync = datasync;
+    local->op = GF_FOP_FSYNC;
+    local->cont.fsync.datasync = datasync;
 
-	if (afr_fd_has_witnessed_unstable_write (this, fd->inode)) {
-		/* don't care. we only wanted to CLEAR the bit */
-	}
+    if (afr_fd_has_witnessed_unstable_write(this, fd->inode)) {
+        /* don't care. we only wanted to CLEAR the bit */
+    }
 
-        local->transaction.wind   = afr_fsync_wind;
-        local->transaction.unwind = afr_fsync_unwind;
+    local->transaction.wind = afr_fsync_wind;
+    local->transaction.unwind = afr_fsync_unwind;
 
-        local->transaction.main_frame = frame;
+    local->transaction.main_frame = frame;
 
-        ret = afr_transaction (transaction_frame, this, AFR_DATA_TRANSACTION);
-        if (ret < 0) {
-                op_errno = -ret;
-                goto out;
-        }
+    ret = afr_transaction(transaction_frame, this, AFR_DATA_TRANSACTION);
+    if (ret < 0) {
+        op_errno = -ret;
+        goto out;
+    }
 
-	return 0;
+    return 0;
 out:
-	if (transaction_frame)
-		AFR_STACK_DESTROY (transaction_frame);
+    if (transaction_frame)
+        AFR_STACK_DESTROY(transaction_frame);
 
-	AFR_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    AFR_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-lk-common.c b/xlators/cluster/afr/src/afr-lk-common.c
index d7ff2b01a06..95e52ff4a09 100644
--- a/xlators/cluster/afr/src/afr-lk-common.c
+++ b/xlators/cluster/afr/src/afr-lk-common.c
@@ -18,1122 +18,1075 @@
 
 #include <signal.h>
 
-
-#define LOCKED_NO       0x0        /* no lock held */
-#define LOCKED_YES      0x1        /* for DATA, METADATA, ENTRY and higher_path */
-#define LOCKED_LOWER    0x2        /* for lower path */
+#define LOCKED_NO 0x0    /* no lock held */
+#define LOCKED_YES 0x1   /* for DATA, METADATA, ENTRY and higher_path */
+#define LOCKED_LOWER 0x2 /* for lower path */
 
 int
-afr_entry_lockee_cmp (const void *l1, const void *l2)
+afr_entry_lockee_cmp(const void *l1, const void *l2)
 {
-        const afr_entry_lockee_t       *r1 = l1;
-        const afr_entry_lockee_t       *r2 = l2;
-        int                            ret = 0;
-        uuid_t                         gfid1 = {0};
-        uuid_t                         gfid2 = {0};
-
-        loc_gfid ((loc_t*)&r1->loc, gfid1);
-        loc_gfid ((loc_t*)&r2->loc, gfid2);
-        ret = gf_uuid_compare (gfid1, gfid2);
-        /*Entrylks with NULL basename are the 'smallest'*/
-        if (ret == 0) {
-                if (!r1->basename)
-                        return -1;
-                if (!r2->basename)
-                        return 1;
-                ret = strcmp (r1->basename, r2->basename);
-        }
-
-        if (ret <= 0)
-                return -1;
-        else
-                return 1;
+    const afr_entry_lockee_t *r1 = l1;
+    const afr_entry_lockee_t *r2 = l2;
+    int ret = 0;
+    uuid_t gfid1 = {0};
+    uuid_t gfid2 = {0};
+
+    loc_gfid((loc_t *)&r1->loc, gfid1);
+    loc_gfid((loc_t *)&r2->loc, gfid2);
+    ret = gf_uuid_compare(gfid1, gfid2);
+    /*Entrylks with NULL basename are the 'smallest'*/
+    if (ret == 0) {
+        if (!r1->basename)
+            return -1;
+        if (!r2->basename)
+            return 1;
+        ret = strcmp(r1->basename, r2->basename);
+    }
+
+    if (ret <= 0)
+        return -1;
+    else
+        return 1;
 }
 
-int afr_lock_blocking (call_frame_t *frame, xlator_t *this, int child_index);
+int
+afr_lock_blocking(call_frame_t *frame, xlator_t *this, int child_index);
 
 void
-afr_set_lk_owner (call_frame_t *frame, xlator_t *this, void *lk_owner)
+afr_set_lk_owner(call_frame_t *frame, xlator_t *this, void *lk_owner)
 {
-        gf_msg_trace (this->name, 0,
-                      "Setting lk-owner=%llu",
-                      (unsigned long long) (unsigned long)lk_owner);
+    gf_msg_trace(this->name, 0, "Setting lk-owner=%llu",
+                 (unsigned long long)(unsigned long)lk_owner);
 
-        set_lk_owner_from_ptr (&frame->root->lk_owner, lk_owner);
+    set_lk_owner_from_ptr(&frame->root->lk_owner, lk_owner);
 }
 
 int32_t
-internal_lock_count (call_frame_t *frame, xlator_t *this)
+internal_lock_count(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int32_t call_count = 0;
-        int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int32_t call_count = 0;
+    int i = 0;
 
-        local = frame->local;
-        priv  = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->child_up[i])
-                        ++call_count;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->child_up[i])
+            ++call_count;
+    }
 
-        return call_count;
+    return call_count;
 }
 
 int
 afr_is_inodelk_transaction(afr_transaction_type type)
 {
-        int ret = 0;
+    int ret = 0;
 
-        switch (type) {
+    switch (type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
-                ret = 1;
-                break;
+            ret = 1;
+            break;
 
         case AFR_ENTRY_RENAME_TRANSACTION:
         case AFR_ENTRY_TRANSACTION:
-                ret = 0;
-                break;
+            ret = 0;
+            break;
+    }
 
-        }
-
-        return ret;
+    return ret;
 }
 
 int
-afr_init_entry_lockee (afr_entry_lockee_t *lockee, afr_local_t *local,
-                       loc_t *loc, char *basename, int child_count)
+afr_init_entry_lockee(afr_entry_lockee_t *lockee, afr_local_t *local,
+                      loc_t *loc, char *basename, int child_count)
 {
-        int     ret     = -1;
+    int ret = -1;
 
-        loc_copy (&lockee->loc, loc);
-        lockee->basename        = (basename)? gf_strdup (basename): NULL;
-        if (basename && !lockee->basename)
-                goto out;
+    loc_copy(&lockee->loc, loc);
+    lockee->basename = (basename) ? gf_strdup(basename) : NULL;
+    if (basename && !lockee->basename)
+        goto out;
 
-        lockee->locked_count    = 0;
-        lockee->locked_nodes    = GF_CALLOC (child_count,
-                                             sizeof (*lockee->locked_nodes),
-                                             gf_afr_mt_afr_node_character);
+    lockee->locked_count = 0;
+    lockee->locked_nodes = GF_CALLOC(child_count, sizeof(*lockee->locked_nodes),
+                                     gf_afr_mt_afr_node_character);
 
-        if (!lockee->locked_nodes)
-                goto out;
+    if (!lockee->locked_nodes)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
-
+    return ret;
 }
 
 void
-afr_entry_lockee_cleanup (afr_internal_lock_t *int_lock)
+afr_entry_lockee_cleanup(afr_internal_lock_t *int_lock)
 {
-        int     i   = 0;
-
-        for (i = 0; i < int_lock->lockee_count; i++) {
-                loc_wipe (&int_lock->lockee[i].loc);
-                if (int_lock->lockee[i].basename)
-                        GF_FREE (int_lock->lockee[i].basename);
-                if (int_lock->lockee[i].locked_nodes)
-                       GF_FREE (int_lock->lockee[i].locked_nodes);
-        }
+    int i = 0;
+
+    for (i = 0; i < int_lock->lockee_count; i++) {
+        loc_wipe(&int_lock->lockee[i].loc);
+        if (int_lock->lockee[i].basename)
+            GF_FREE(int_lock->lockee[i].basename);
+        if (int_lock->lockee[i].locked_nodes)
+            GF_FREE(int_lock->lockee[i].locked_nodes);
+    }
 
-        return;
+    return;
 }
 
 static int
-initialize_entrylk_variables (call_frame_t *frame, xlator_t *this)
+initialize_entrylk_variables(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
-
-        int i = 0;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        int_lock->entrylk_lock_count = 0;
-        int_lock->lock_op_ret        = -1;
-        int_lock->lock_op_errno      = 0;
-
-        for (i = 0; i < AFR_LOCKEE_COUNT_MAX; i++) {
-                if (!int_lock->lockee[i].locked_nodes)
-                        break;
-                int_lock->lockee[i].locked_count = 0;
-                memset (int_lock->lockee[i].locked_nodes, 0,
-                        sizeof (*int_lock->lockee[i].locked_nodes) *
-                        priv->child_count);
-        }
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_private_t *priv = NULL;
 
-        return 0;
+    int i = 0;
+
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
+
+    int_lock->entrylk_lock_count = 0;
+    int_lock->lock_op_ret = -1;
+    int_lock->lock_op_errno = 0;
+
+    for (i = 0; i < AFR_LOCKEE_COUNT_MAX; i++) {
+        if (!int_lock->lockee[i].locked_nodes)
+            break;
+        int_lock->lockee[i].locked_count = 0;
+        memset(int_lock->lockee[i].locked_nodes, 0,
+               sizeof(*int_lock->lockee[i].locked_nodes) * priv->child_count);
+    }
+
+    return 0;
 }
 
 static int
-initialize_inodelk_variables (call_frame_t *frame, xlator_t *this)
+initialize_inodelk_variables(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t         *local    = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_private_t *priv = NULL;
 
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        int_lock->lock_count    = 0;
-        int_lock->lk_attempted_count = 0;
-        int_lock->lock_op_ret   = -1;
-        int_lock->lock_op_errno = 0;
+    int_lock->lock_count = 0;
+    int_lock->lk_attempted_count = 0;
+    int_lock->lock_op_ret = -1;
+    int_lock->lock_op_errno = 0;
 
-        memset (int_lock->locked_nodes, 0,
-                sizeof (*int_lock->locked_nodes) * priv->child_count);
+    memset(int_lock->locked_nodes, 0,
+           sizeof(*int_lock->locked_nodes) * priv->child_count);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_lockee_locked_nodes_count (afr_internal_lock_t *int_lock)
+afr_lockee_locked_nodes_count(afr_internal_lock_t *int_lock)
 {
-        int call_count  = 0;
-        int i           = 0;
+    int call_count = 0;
+    int i = 0;
 
-        for (i = 0; i < int_lock->lockee_count; i++)
-                call_count += int_lock->lockee[i].locked_count;
+    for (i = 0; i < int_lock->lockee_count; i++)
+        call_count += int_lock->lockee[i].locked_count;
 
-        return call_count;
+    return call_count;
 }
 
 int
-afr_locked_nodes_count (unsigned char *locked_nodes, int child_count)
+afr_locked_nodes_count(unsigned char *locked_nodes, int child_count)
 
 {
-        int i = 0;
-        int call_count = 0;
+    int i = 0;
+    int call_count = 0;
 
-        for (i = 0; i < child_count; i++) {
-                if (locked_nodes[i] & LOCKED_YES)
-                        call_count++;
-        }
+    for (i = 0; i < child_count; i++) {
+        if (locked_nodes[i] & LOCKED_YES)
+            call_count++;
+    }
 
-        return call_count;
+    return call_count;
 }
 
 /* FIXME: What if UNLOCK fails */
 static int32_t
-afr_unlock_common_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_unlock_common_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t             *local          = NULL;
-        afr_internal_lock_t     *int_lock       = NULL;
-        int                      call_count     = 0;
-        int                      ret            = 0;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    int call_count = 0;
+    int ret = 0;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        if (local->transaction.type == AFR_DATA_TRANSACTION && op_ret != 1)
-                ret = afr_write_subvol_reset (frame, this);
+    if (local->transaction.type == AFR_DATA_TRANSACTION && op_ret != 1)
+        ret = afr_write_subvol_reset(frame, this);
 
-        LOCK (&frame->lock);
-        {
-                call_count = --int_lock->lk_call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        call_count = --int_lock->lk_call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "All internal locks unlocked");
-                int_lock->lock_cbk (frame, this);
-        }
+    if (call_count == 0) {
+        gf_msg_trace(this->name, 0, "All internal locks unlocked");
+        int_lock->lock_cbk(frame, this);
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-afr_update_uninodelk (afr_local_t *local, afr_internal_lock_t *int_lock,
-                    int32_t child_index)
+afr_update_uninodelk(afr_local_t *local, afr_internal_lock_t *int_lock,
+                     int32_t child_index)
 {
-        int_lock->locked_nodes[child_index] &= LOCKED_NO;
-
+    int_lock->locked_nodes[child_index] &= LOCKED_NO;
 }
 
 static int32_t
-afr_unlock_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_unlock_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t         *local = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        int32_t             child_index = (long)cookie;
-        afr_private_t       *priv = NULL;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
-
-        priv = this->private;
-
-        if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_UNLOCK_FAIL,
-                        "path=%s gfid=%s: unlock failed on subvolume %s "
-                        "with lock owner %s", local->loc.path,
-                        loc_gfid_utoa (&(local->loc)),
-                        priv->children[child_index]->name,
-                        lkowner_utoa (&frame->root->lk_owner));
-        }
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    int32_t child_index = (long)cookie;
+    afr_private_t *priv = NULL;
 
-        afr_update_uninodelk (local, int_lock, child_index);
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        afr_unlock_common_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    priv = this->private;
 
-        return 0;
+    if (op_ret < 0 && op_errno != ENOTCONN && op_errno != EBADFD) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_UNLOCK_FAIL,
+               "path=%s gfid=%s: unlock failed on subvolume %s "
+               "with lock owner %s",
+               local->loc.path, loc_gfid_utoa(&(local->loc)),
+               priv->children[child_index]->name,
+               lkowner_utoa(&frame->root->lk_owner));
+    }
+
+    afr_update_uninodelk(local, int_lock, child_index);
+
+    afr_unlock_common_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 
+    return 0;
 }
 
 static int
-afr_unlock_inodelk (call_frame_t *frame, xlator_t *this)
+afr_unlock_inodelk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        struct gf_flock flock = {0,};
-        int call_count = 0;
-        int i = 0;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    int call_count = 0;
+    int i = 0;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
 
-        flock.l_start = int_lock->flock.l_start;
-        flock.l_len   = int_lock->flock.l_len;
-        flock.l_type  = F_UNLCK;
+    flock.l_start = int_lock->flock.l_start;
+    flock.l_len = int_lock->flock.l_len;
+    flock.l_type = F_UNLCK;
 
-        call_count = afr_locked_nodes_count (int_lock->locked_nodes,
-                                             priv->child_count);
+    call_count = afr_locked_nodes_count(int_lock->locked_nodes,
+                                        priv->child_count);
 
-        int_lock->lk_call_count = call_count;
+    int_lock->lk_call_count = call_count;
 
-        if (!call_count) {
-                GF_ASSERT (!local->transaction.do_eager_unlock);
-                gf_msg_trace (this->name, 0,
-                              "No internal locks unlocked");
+    if (!call_count) {
+        GF_ASSERT(!local->transaction.do_eager_unlock);
+        gf_msg_trace(this->name, 0, "No internal locks unlocked");
 
-                int_lock->lock_cbk (frame, this);
-                goto out;
-        }
+        int_lock->lock_cbk(frame, this);
+        goto out;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if ((int_lock->locked_nodes[i] & LOCKED_YES) != LOCKED_YES)
-                        continue;
-
-                if (local->fd) {
-                        STACK_WIND_COOKIE (frame, afr_unlock_inodelk_cbk,
-                                           (void *) (long)i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLK, &flock, NULL);
-                } else {
-                        STACK_WIND_COOKIE (frame, afr_unlock_inodelk_cbk,
-                                           (void *) (long)i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLK, &flock, NULL);
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if ((int_lock->locked_nodes[i] & LOCKED_YES) != LOCKED_YES)
+            continue;
 
-                if (!--call_count)
-                        break;
+        if (local->fd) {
+            STACK_WIND_COOKIE(
+                frame, afr_unlock_inodelk_cbk, (void *)(long)i,
+                priv->children[i], priv->children[i]->fops->finodelk,
+                int_lock->domain, local->fd, F_SETLK, &flock, NULL);
+        } else {
+            STACK_WIND_COOKIE(
+                frame, afr_unlock_inodelk_cbk, (void *)(long)i,
+                priv->children[i], priv->children[i]->fops->inodelk,
+                int_lock->domain, &local->loc, F_SETLK, &flock, NULL);
         }
+
+        if (!--call_count)
+            break;
+    }
 out:
-        return 0;
+    return 0;
 }
 
 static int32_t
-afr_unlock_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_unlock_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_local_t         *local = NULL;
-        afr_private_t       *priv  = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        int32_t             child_index = 0;
-        int                 lockee_no   = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    int32_t child_index = 0;
+    int lockee_no = 0;
 
-        priv = this->private;
-        lockee_no = (int)((long) cookie) / priv->child_count;
-        child_index = (int) ((long) cookie) % priv->child_count;
+    priv = this->private;
+    lockee_no = (int)((long)cookie) / priv->child_count;
+    child_index = (int)((long)cookie) % priv->child_count;
 
-        local = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        AFR_MSG_ENTRY_UNLOCK_FAIL,
-                        "%s: unlock failed on %s", local->loc.path,
-                        priv->children[child_index]->name);
-        }
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, AFR_MSG_ENTRY_UNLOCK_FAIL,
+               "%s: unlock failed on %s", local->loc.path,
+               priv->children[child_index]->name);
+    }
 
-        int_lock->lockee[lockee_no].locked_nodes[child_index] &= LOCKED_NO;
-        afr_unlock_common_cbk (frame, cookie, this, op_ret, op_errno, NULL);
+    int_lock->lockee[lockee_no].locked_nodes[child_index] &= LOCKED_NO;
+    afr_unlock_common_cbk(frame, cookie, this, op_ret, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 static int
-afr_unlock_entrylk (call_frame_t *frame, xlator_t *this)
+afr_unlock_entrylk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t     *int_lock       = NULL;
-        afr_local_t             *local          = NULL;
-        afr_private_t           *priv           = NULL;
-        int                     call_count      = 0;
-        int                     index           = 0;
-        int                     lockee_no       = 0;
-        int                     copies          = 0;
-        int                     i               = -1;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-        copies   = priv->child_count;
-
-        call_count = afr_lockee_locked_nodes_count (int_lock);
-
-        int_lock->lk_call_count = call_count;
-
-        if (!call_count){
-                gf_msg_trace (this->name, 0,
-                              "No internal locks unlocked");
-                int_lock->lock_cbk (frame, this);
-                goto out;
-        }
-
-        for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
-                lockee_no = i / copies;
-                index     = i % copies;
-                if (int_lock->lockee[lockee_no].locked_nodes[index] & LOCKED_YES) {
-
-                        STACK_WIND_COOKIE (frame, afr_unlock_entrylk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[index],
-                                           priv->children[index]->fops->entrylk,
-                                           int_lock->domain,
-                                           &int_lock->lockee[lockee_no].loc,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
-
-                        if (!--call_count)
-                                break;
-                }
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int index = 0;
+    int lockee_no = 0;
+    int copies = 0;
+    int i = -1;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+    copies = priv->child_count;
+
+    call_count = afr_lockee_locked_nodes_count(int_lock);
+
+    int_lock->lk_call_count = call_count;
+
+    if (!call_count) {
+        gf_msg_trace(this->name, 0, "No internal locks unlocked");
+        int_lock->lock_cbk(frame, this);
+        goto out;
+    }
+
+    for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
+        lockee_no = i / copies;
+        index = i % copies;
+        if (int_lock->lockee[lockee_no].locked_nodes[index] & LOCKED_YES) {
+            STACK_WIND_COOKIE(
+                frame, afr_unlock_entrylk_cbk, (void *)(long)i,
+                priv->children[index], priv->children[index]->fops->entrylk,
+                int_lock->domain, &int_lock->lockee[lockee_no].loc,
+                int_lock->lockee[lockee_no].basename, ENTRYLK_UNLOCK,
+                ENTRYLK_WRLCK, NULL);
+
+            if (!--call_count)
+                break;
         }
+    }
 
 out:
-        return 0;
-
+    return 0;
 }
 
 int32_t
-afr_unlock_now (call_frame_t *frame, xlator_t *this)
+afr_unlock_now(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = frame->local;
+    afr_local_t *local = frame->local;
 
-        if (afr_is_inodelk_transaction(local->transaction.type))
-                afr_unlock_inodelk (frame, this);
-        else
-                afr_unlock_entrylk (frame, this);
-        return 0;
+    if (afr_is_inodelk_transaction(local->transaction.type))
+        afr_unlock_inodelk(frame, this);
+    else
+        afr_unlock_entrylk(frame, this);
+    return 0;
 }
 
 static int32_t
-afr_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, dict_t *xdata)
 {
-        afr_internal_lock_t     *int_lock       = NULL;
-        afr_local_t             *local          = NULL;
-        afr_private_t           *priv           = NULL;
-        int                     cky             = (long) cookie;
-        int                     child_index     = 0;
-        int                     lockee_no       = 0;
-
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-        child_index = ((int)cky) % priv->child_count;
-        lockee_no   = ((int)cky) / priv->child_count;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno == ENOSYS) {
-                                /* return ENOTSUP */
-                                gf_msg (this->name, GF_LOG_ERROR, ENOSYS,
-                                        AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-                                        "subvolume does not support locking. "
-                                        "please load features/locks xlator on server");
-                                local->op_ret = op_ret;
-                                int_lock->lock_op_ret = op_ret;
-                        }
-
-                        local->op_errno              = op_errno;
-                        int_lock->lock_op_errno      = op_errno;
-                }
-
-		int_lock->lk_attempted_count++;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int cky = (long)cookie;
+    int child_index = 0;
+    int lockee_no = 0;
+
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
+
+    child_index = ((int)cky) % priv->child_count;
+    lockee_no = ((int)cky) / priv->child_count;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno == ENOSYS) {
+                /* return ENOTSUP */
+                gf_msg(this->name, GF_LOG_ERROR, ENOSYS,
+                       AFR_MSG_LOCK_XLATOR_NOT_LOADED,
+                       "subvolume does not support locking. "
+                       "please load features/locks xlator on server");
+                local->op_ret = op_ret;
+                int_lock->lock_op_ret = op_ret;
+            }
+
+            local->op_errno = op_errno;
+            int_lock->lock_op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
 
-        if ((op_ret == -1) &&
-            (op_errno == ENOSYS)) {
-                afr_unlock_now (frame, this);
-        } else {
-                if (op_ret == 0) {
-                        if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
-                            local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                                int_lock->lockee[lockee_no].locked_nodes[child_index] |= LOCKED_YES;
-                                int_lock->lockee[lockee_no].locked_count++;
-                                int_lock->entrylk_lock_count++;
-                        } else {
-                                int_lock->locked_nodes[child_index] |= LOCKED_YES;
-                                int_lock->lock_count++;
-
-                                if (local->transaction.type ==
-                                    AFR_DATA_TRANSACTION) {
-                                        LOCK(&local->inode->lock);
-                                        {
-                                                local->inode_ctx->lock_count++;
-                                        }
-                                        UNLOCK (&local->inode->lock);
-                                }
-                        }
+        int_lock->lk_attempted_count++;
+    }
+    UNLOCK(&frame->lock);
+
+    if ((op_ret == -1) && (op_errno == ENOSYS)) {
+        afr_unlock_now(frame, this);
+    } else {
+        if (op_ret == 0) {
+            if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
+                local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
+                int_lock->lockee[lockee_no]
+                    .locked_nodes[child_index] |= LOCKED_YES;
+                int_lock->lockee[lockee_no].locked_count++;
+                int_lock->entrylk_lock_count++;
+            } else {
+                int_lock->locked_nodes[child_index] |= LOCKED_YES;
+                int_lock->lock_count++;
+
+                if (local->transaction.type == AFR_DATA_TRANSACTION) {
+                    LOCK(&local->inode->lock);
+                    {
+                        local->inode_ctx->lock_count++;
+                    }
+                    UNLOCK(&local->inode->lock);
                 }
-                afr_lock_blocking (frame, this, cky + 1);
+            }
         }
+        afr_lock_blocking(frame, this, cky + 1);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-afr_blocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_blocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        return 0;
-
+    afr_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    return 0;
 }
 
 static int32_t
-afr_blocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_blocking_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_lock_cbk (frame, cookie, this, op_ret, op_errno, xdata);
-        return 0;
+    afr_lock_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    return 0;
 }
 
 static gf_boolean_t
-afr_is_entrylk (afr_transaction_type trans_type)
+afr_is_entrylk(afr_transaction_type trans_type)
 {
-        if (afr_is_inodelk_transaction (trans_type))
-                return _gf_false;
-        return _gf_true;
+    if (afr_is_inodelk_transaction(trans_type))
+        return _gf_false;
+    return _gf_true;
 }
 
 static gf_boolean_t
-_is_lock_wind_needed (afr_local_t *local, int child_index)
+_is_lock_wind_needed(afr_local_t *local, int child_index)
 {
-        if (!local->child_up[child_index])
-                return _gf_false;
+    if (!local->child_up[child_index])
+        return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 static void
 afr_log_entry_locks_failure(xlator_t *this, afr_local_t *local,
                             afr_internal_lock_t *int_lock)
 {
-        const char *fop = NULL;
-        char *pargfid = NULL;
-        const char *name = NULL;
+    const char *fop = NULL;
+    char *pargfid = NULL;
+    const char *name = NULL;
 
-        fop = gf_fop_list[local->op];
+    fop = gf_fop_list[local->op];
 
-        switch (local->op) {
+    switch (local->op) {
         case GF_FOP_LINK:
-                pargfid = uuid_utoa(local->newloc.pargfid);
-                name = local->newloc.name;
-                break;
+            pargfid = uuid_utoa(local->newloc.pargfid);
+            name = local->newloc.name;
+            break;
         default:
-                pargfid = uuid_utoa(local->loc.pargfid);
-                name = local->loc.name;
-                break;
-        }
-
-        gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_BLOCKING_LKS_FAILED,
-                "Unable to obtain sufficient blocking entry locks on at least "
-                "one child while attempting %s on {pgfid:%s, name:%s}.", fop,
-                pargfid, name);
+            pargfid = uuid_utoa(local->loc.pargfid);
+            name = local->loc.name;
+            break;
+    }
+
+    gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_BLOCKING_LKS_FAILED,
+           "Unable to obtain sufficient blocking entry locks on at least "
+           "one child while attempting %s on {pgfid:%s, name:%s}.",
+           fop, pargfid, name);
 }
 
 static gf_boolean_t
-is_blocking_locks_count_sufficient (call_frame_t *frame, xlator_t *this)
+is_blocking_locks_count_sufficient(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t  *local = NULL;
-        afr_private_t *priv = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        gf_boolean_t is_entrylk = _gf_false;
-        int child = 0;
-        int nlockee = 0;
-        int lockee_count = 0;
-        gf_boolean_t ret = _gf_true;
-
-        local = frame->local;
-        priv = this->private;
-        int_lock = &local->internal_lock;
-        lockee_count = int_lock->lockee_count;
-        is_entrylk = afr_is_entrylk (local->transaction.type);
-
-        if (!is_entrylk) {
-                if (int_lock->lock_count == 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_BLOCKING_LKS_FAILED, "Unable to obtain "
-                                "blocking inode lock on even one child for "
-                                "gfid:%s.", uuid_utoa (local->inode->gfid));
-                        return _gf_false;
-                } else {
-                        /*inodelk succeeded on at least one child. */
-                        return _gf_true;
-                }
-
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    gf_boolean_t is_entrylk = _gf_false;
+    int child = 0;
+    int nlockee = 0;
+    int lockee_count = 0;
+    gf_boolean_t ret = _gf_true;
+
+    local = frame->local;
+    priv = this->private;
+    int_lock = &local->internal_lock;
+    lockee_count = int_lock->lockee_count;
+    is_entrylk = afr_is_entrylk(local->transaction.type);
+
+    if (!is_entrylk) {
+        if (int_lock->lock_count == 0) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_BLOCKING_LKS_FAILED,
+                   "Unable to obtain "
+                   "blocking inode lock on even one child for "
+                   "gfid:%s.",
+                   uuid_utoa(local->inode->gfid));
+            return _gf_false;
         } else {
-                if (int_lock->entrylk_lock_count == 0) {
-                        afr_log_entry_locks_failure (this, local, int_lock);
-                        return _gf_false;
-                }
-                /* For FOPS that take multiple sets of locks (mkdir, rename),
-                 * there must be at least one brick on which the locks from
-                 * all lock sets were successful. */
-                for (child = 0; child < priv->child_count; child++) {
-                        ret = _gf_true;
-                        for (nlockee = 0; nlockee < lockee_count; nlockee++) {
-                                if (!(int_lock->lockee[nlockee].locked_nodes[child] & LOCKED_YES))
-                                        ret = _gf_false;
-                        }
-                        if (ret)
-                                return ret;
-                }
-                if (!ret)
-                        afr_log_entry_locks_failure (this, local, int_lock);
+            /*inodelk succeeded on at least one child. */
+            return _gf_true;
         }
 
-        return ret;
+    } else {
+        if (int_lock->entrylk_lock_count == 0) {
+            afr_log_entry_locks_failure(this, local, int_lock);
+            return _gf_false;
+        }
+        /* For FOPS that take multiple sets of locks (mkdir, rename),
+         * there must be at least one brick on which the locks from
+         * all lock sets were successful. */
+        for (child = 0; child < priv->child_count; child++) {
+            ret = _gf_true;
+            for (nlockee = 0; nlockee < lockee_count; nlockee++) {
+                if (!(int_lock->lockee[nlockee].locked_nodes[child] &
+                      LOCKED_YES))
+                    ret = _gf_false;
+            }
+            if (ret)
+                return ret;
+        }
+        if (!ret)
+            afr_log_entry_locks_failure(this, local, int_lock);
+    }
 
+    return ret;
 }
 
 int
-afr_lock_blocking (call_frame_t *frame, xlator_t *this, int cookie)
+afr_lock_blocking(call_frame_t *frame, xlator_t *this, int cookie)
 {
-        afr_internal_lock_t *int_lock    = NULL;
-        afr_local_t         *local       = NULL;
-        afr_private_t       *priv        = NULL;
-        struct gf_flock flock = {0,};
-        uint64_t ctx = 0;
-        int ret = 0;
-        int child_index = 0;
-        int lockee_no   = 0;
-        gf_boolean_t is_entrylk = _gf_false;
-
-        local         = frame->local;
-        int_lock      = &local->internal_lock;
-        priv          = this->private;
-        child_index   = cookie % priv->child_count;
-        lockee_no     = cookie / priv->child_count;
-        is_entrylk    = afr_is_entrylk (local->transaction.type);
-
-
-        if (!is_entrylk) {
-                flock.l_start = int_lock->flock.l_start;
-                flock.l_len   = int_lock->flock.l_len;
-                flock.l_type  = int_lock->flock.l_type;
-        }
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    uint64_t ctx = 0;
+    int ret = 0;
+    int child_index = 0;
+    int lockee_no = 0;
+    gf_boolean_t is_entrylk = _gf_false;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+    child_index = cookie % priv->child_count;
+    lockee_no = cookie / priv->child_count;
+    is_entrylk = afr_is_entrylk(local->transaction.type);
+
+    if (!is_entrylk) {
+        flock.l_start = int_lock->flock.l_start;
+        flock.l_len = int_lock->flock.l_len;
+        flock.l_type = int_lock->flock.l_type;
+    }
 
-        if (local->fd) {
-                ret = fd_ctx_get (local->fd, this, &ctx);
+    if (local->fd) {
+        ret = fd_ctx_get(local->fd, this, &ctx);
 
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_FD_CTX_GET_FAILED,
+                   "unable to get fd ctx for fd=%p", local->fd);
 
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
 
-                        afr_unlock_now (frame, this);
+            afr_unlock_now(frame, this);
 
-                        return 0;
-                }
+            return 0;
         }
+    }
 
-        if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
-                if (!is_blocking_locks_count_sufficient (frame, this)) {
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
+    if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
+        if (!is_blocking_locks_count_sufficient(frame, this)) {
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
 
-                        afr_unlock_now(frame, this);
+            afr_unlock_now(frame, this);
 
-                        return 0;
-                }
+            return 0;
         }
+    }
 
-        if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
-                /* we're done locking */
+    if (int_lock->lk_expected_count == int_lock->lk_attempted_count) {
+        /* we're done locking */
 
-                gf_msg_debug (this->name, 0,
-                              "we're done locking");
+        gf_msg_debug(this->name, 0, "we're done locking");
 
-                int_lock->lock_op_ret = 0;
-                int_lock->lock_cbk (frame, this);
-                return 0;
-        }
+        int_lock->lock_op_ret = 0;
+        int_lock->lock_cbk(frame, this);
+        return 0;
+    }
 
-        if (!_is_lock_wind_needed (local, child_index)) {
-                afr_lock_blocking (frame, this, cookie + 1);
-                return 0;
-        }
+    if (!_is_lock_wind_needed(local, child_index)) {
+        afr_lock_blocking(frame, this, cookie + 1);
+        return 0;
+    }
 
-        switch (local->transaction.type) {
+    switch (local->transaction.type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
 
-                if (local->fd) {
-                        STACK_WIND_COOKIE (frame, afr_blocking_inodelk_cbk,
-                                           (void *) (long) child_index,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLKW, &flock, NULL);
-
-                } else {
-                        STACK_WIND_COOKIE (frame, afr_blocking_inodelk_cbk,
-                                           (void *) (long) child_index,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLKW, &flock, NULL);
-                }
+            if (local->fd) {
+                STACK_WIND_COOKIE(
+                    frame, afr_blocking_inodelk_cbk, (void *)(long)child_index,
+                    priv->children[child_index],
+                    priv->children[child_index]->fops->finodelk,
+                    int_lock->domain, local->fd, F_SETLKW, &flock, NULL);
 
-                break;
+            } else {
+                STACK_WIND_COOKIE(
+                    frame, afr_blocking_inodelk_cbk, (void *)(long)child_index,
+                    priv->children[child_index],
+                    priv->children[child_index]->fops->inodelk,
+                    int_lock->domain, &local->loc, F_SETLKW, &flock, NULL);
+            }
+
+            break;
 
         case AFR_ENTRY_RENAME_TRANSACTION:
         case AFR_ENTRY_TRANSACTION:
-                /*Accounting for child_index increments on 'down'
-                 *and 'fd-less' children */
-
-                if (local->fd) {
-                        STACK_WIND_COOKIE (frame, afr_blocking_entrylk_cbk,
-                                           (void *) (long) cookie,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->fentrylk,
-                                           int_lock->domain, local->fd,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                } else {
-                        STACK_WIND_COOKIE (frame, afr_blocking_entrylk_cbk,
-                                           (void *) (long) cookie,
-                                           priv->children[child_index],
-                                           priv->children[child_index]->fops->entrylk,
-                                           int_lock->domain,
-                                           &int_lock->lockee[lockee_no].loc,
-                                           int_lock->lockee[lockee_no].basename,
-                                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-                }
-
-                break;
-        }
-
-        return 0;
+            /*Accounting for child_index increments on 'down'
+             *and 'fd-less' children */
+
+            if (local->fd) {
+                STACK_WIND_COOKIE(frame, afr_blocking_entrylk_cbk,
+                                  (void *)(long)cookie,
+                                  priv->children[child_index],
+                                  priv->children[child_index]->fops->fentrylk,
+                                  int_lock->domain, local->fd,
+                                  int_lock->lockee[lockee_no].basename,
+                                  ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+            } else {
+                STACK_WIND_COOKIE(
+                    frame, afr_blocking_entrylk_cbk, (void *)(long)cookie,
+                    priv->children[child_index],
+                    priv->children[child_index]->fops->entrylk,
+                    int_lock->domain, &int_lock->lockee[lockee_no].loc,
+                    int_lock->lockee[lockee_no].basename, ENTRYLK_LOCK,
+                    ENTRYLK_WRLCK, NULL);
+            }
+
+            break;
+    }
+
+    return 0;
 }
 
 int32_t
-afr_blocking_lock (call_frame_t *frame, xlator_t *this)
+afr_blocking_lock(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        int                  up_count = 0;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int up_count = 0;
 
-        priv     = this->private;
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    priv = this->private;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        switch (local->transaction.type) {
+    switch (local->transaction.type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
-                initialize_inodelk_variables (frame, this);
-                break;
+            initialize_inodelk_variables(frame, this);
+            break;
 
         case AFR_ENTRY_RENAME_TRANSACTION:
         case AFR_ENTRY_TRANSACTION:
-                up_count = AFR_COUNT (local->child_up, priv->child_count);
-                int_lock->lk_call_count = int_lock->lk_expected_count
-                                        = (int_lock->lockee_count *
-                                           up_count);
-                initialize_entrylk_variables (frame, this);
-                break;
-        }
+            up_count = AFR_COUNT(local->child_up, priv->child_count);
+            int_lock->lk_call_count = int_lock->lk_expected_count =
+                (int_lock->lockee_count * up_count);
+            initialize_entrylk_variables(frame, this);
+            break;
+    }
 
-        afr_lock_blocking (frame, this, 0);
+    afr_lock_blocking(frame, this, 0);
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-afr_nonblocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_nonblocking_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        int call_count          = 0;
-        int child_index         = (long) cookie;
-        int copies              = 0;
-        int index               = 0;
-        int lockee_no           = 0;
-        afr_private_t       *priv = NULL;
-
-        priv = this->private;
-
-        copies = priv->child_count;
-        index = child_index % copies;
-        lockee_no = child_index / copies;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-
-	LOCK (&frame->lock);
-	{
-		if (op_ret < 0 ) {
-			if (op_errno == ENOSYS) {
-                        /* return ENOTSUP */
-			        gf_msg (this->name, GF_LOG_ERROR,
-                                        ENOSYS, AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-                                        "subvolume does not support "
-                                        "locking. please load features/locks"
-                                        " xlator on server");
-				local->op_ret         = op_ret;
-				int_lock->lock_op_ret = op_ret;
-
-				int_lock->lock_op_errno      = op_errno;
-				local->op_errno              = op_errno;
-			}
-		} else if (op_ret == 0) {
-			int_lock->lockee[lockee_no].locked_nodes[index] |= \
-				LOCKED_YES;
-			int_lock->lockee[lockee_no].locked_count++;
-			int_lock->entrylk_lock_count++;
-		}
-
-                call_count = --int_lock->lk_call_count;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    int child_index = (long)cookie;
+    int copies = 0;
+    int index = 0;
+    int lockee_no = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    copies = priv->child_count;
+    index = child_index % copies;
+    lockee_no = child_index / copies;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret < 0) {
+            if (op_errno == ENOSYS) {
+                /* return ENOTSUP */
+                gf_msg(this->name, GF_LOG_ERROR, ENOSYS,
+                       AFR_MSG_LOCK_XLATOR_NOT_LOADED,
+                       "subvolume does not support "
+                       "locking. please load features/locks"
+                       " xlator on server");
+                local->op_ret = op_ret;
+                int_lock->lock_op_ret = op_ret;
+
+                int_lock->lock_op_errno = op_errno;
+                local->op_errno = op_errno;
+            }
+        } else if (op_ret == 0) {
+            int_lock->lockee[lockee_no].locked_nodes[index] |= LOCKED_YES;
+            int_lock->lockee[lockee_no].locked_count++;
+            int_lock->entrylk_lock_count++;
         }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Last locking reply received");
-                /* all locks successful. Proceed to call FOP */
-                if (int_lock->entrylk_lock_count ==
-                                int_lock->lk_expected_count) {
-                        gf_msg_trace (this->name, 0,
-                                      "All servers locked. Calling the cbk");
-                        int_lock->lock_op_ret = 0;
-                        int_lock->lock_cbk (frame, this);
-                }
-                /* Not all locks were successful. Unlock and try locking
-                   again, this time with serially blocking locks */
-                else {
-                        gf_msg_trace (this->name, 0,
-                                      "%d servers locked. Trying again "
-                                      "with blocking calls",
-                                      int_lock->lock_count);
-
-                        afr_unlock_now(frame, this);
-                }
+
+        call_count = --int_lock->lk_call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        gf_msg_trace(this->name, 0, "Last locking reply received");
+        /* all locks successful. Proceed to call FOP */
+        if (int_lock->entrylk_lock_count == int_lock->lk_expected_count) {
+            gf_msg_trace(this->name, 0, "All servers locked. Calling the cbk");
+            int_lock->lock_op_ret = 0;
+            int_lock->lock_cbk(frame, this);
+        }
+        /* Not all locks were successful. Unlock and try locking
+           again, this time with serially blocking locks */
+        else {
+            gf_msg_trace(this->name, 0,
+                         "%d servers locked. Trying again "
+                         "with blocking calls",
+                         int_lock->lock_count);
+
+            afr_unlock_now(frame, this);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_nonblocking_entrylk (call_frame_t *frame, xlator_t *this)
+afr_nonblocking_entrylk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock   = NULL;
-        afr_local_t         *local      = NULL;
-        afr_private_t       *priv       = NULL;
-        afr_fd_ctx_t        *fd_ctx     = NULL;
-        int                 copies      = 0;
-        int                 index       = 0;
-        int                 lockee_no   = 0;
-        int32_t             call_count  = 0;
-        int i = 0;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        copies = priv->child_count;
-        initialize_entrylk_variables (frame, this);
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int copies = 0;
+    int index = 0;
+    int lockee_no = 0;
+    int32_t call_count = 0;
+    int i = 0;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+
+    copies = priv->child_count;
+    initialize_entrylk_variables(frame, this);
+
+    if (local->fd) {
+        fd_ctx = afr_fd_ctx_get(local->fd, this);
+        if (!fd_ctx) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_FD_CTX_GET_FAILED,
+                   "unable to get fd ctx for fd=%p", local->fd);
+
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
+            local->op_errno = EINVAL;
+            int_lock->lock_op_errno = EINVAL;
+
+            afr_unlock_now(frame, this);
+            return -1;
+        }
 
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
-                        local->op_errno         = EINVAL;
-                        int_lock->lock_op_errno = EINVAL;
-
-			afr_unlock_now (frame, this);
-                        return -1;
-                }
+        call_count = int_lock->lockee_count * internal_lock_count(frame, this);
+        int_lock->lk_call_count = call_count;
+        int_lock->lk_expected_count = call_count;
 
-                call_count = int_lock->lockee_count * internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
+        if (!call_count) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_INFO_COMMON,
+                   "fd not open on any subvolumes. aborting.");
+            afr_unlock_now(frame, this);
+            goto out;
+        }
 
-                if (!call_count) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_INFO_COMMON,
-                                "fd not open on any subvolumes. aborting.");
-                        afr_unlock_now (frame, this);
-                        goto out;
-                }
+        /* Send non-blocking entrylk calls only on up children
+           and where the fd has been opened */
+        for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
+            index = i % copies;
+            lockee_no = i / copies;
+            if (local->child_up[index]) {
+                STACK_WIND_COOKIE(frame, afr_nonblocking_entrylk_cbk,
+                                  (void *)(long)i, priv->children[index],
+                                  priv->children[index]->fops->fentrylk,
+                                  this->name, local->fd,
+                                  int_lock->lockee[lockee_no].basename,
+                                  ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+                if (!--call_count)
+                    break;
+            }
+        }
+    } else {
+        call_count = int_lock->lockee_count * internal_lock_count(frame, this);
+        int_lock->lk_call_count = call_count;
+        int_lock->lk_expected_count = call_count;
 
-                /* Send non-blocking entrylk calls only on up children
-                   and where the fd has been opened */
-                for (i = 0; i < int_lock->lockee_count*priv->child_count; i++) {
-                        index = i%copies;
-                        lockee_no = i/copies;
-                        if (local->child_up[index]) {
-                                STACK_WIND_COOKIE (frame, afr_nonblocking_entrylk_cbk,
-                                                   (void *) (long) i,
-                                                   priv->children[index],
-                                                   priv->children[index]->fops->fentrylk,
-                                                   this->name, local->fd,
-                                                   int_lock->lockee[lockee_no].basename,
-                                                   ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                                                   NULL);
-                                if (!--call_count)
-                                        break;
-                        }
-                }
-        } else {
-                call_count = int_lock->lockee_count * internal_lock_count (frame, this);
-                int_lock->lk_call_count = call_count;
-                int_lock->lk_expected_count = call_count;
-
-                for (i = 0; i < int_lock->lockee_count*priv->child_count; i++) {
-                        index = i%copies;
-                        lockee_no = i/copies;
-                        if (local->child_up[index]) {
-                                STACK_WIND_COOKIE (frame, afr_nonblocking_entrylk_cbk,
-                                                   (void *) (long) i,
-                                                   priv->children[index],
-                                                   priv->children[index]->fops->entrylk,
-                                                   this->name, &int_lock->lockee[lockee_no].loc,
-                                                   int_lock->lockee[lockee_no].basename,
-                                                   ENTRYLK_LOCK_NB, ENTRYLK_WRLCK,
-                                                   NULL);
-
-                                if (!--call_count)
-                                        break;
-                        }
-                }
+        for (i = 0; i < int_lock->lockee_count * priv->child_count; i++) {
+            index = i % copies;
+            lockee_no = i / copies;
+            if (local->child_up[index]) {
+                STACK_WIND_COOKIE(frame, afr_nonblocking_entrylk_cbk,
+                                  (void *)(long)i, priv->children[index],
+                                  priv->children[index]->fops->entrylk,
+                                  this->name, &int_lock->lockee[lockee_no].loc,
+                                  int_lock->lockee[lockee_no].basename,
+                                  ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+
+                if (!--call_count)
+                    break;
+            }
         }
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-afr_nonblocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+afr_nonblocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        afr_internal_lock_t *int_lock    = NULL;
-        afr_local_t         *local       = NULL;
-        int                  call_count  = 0;
-        int                  child_index = (long) cookie;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    int call_count = 0;
+    int child_index = (long)cookie;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        if (op_ret == 0 && local->transaction.type == AFR_DATA_TRANSACTION) {
-                LOCK (&local->inode->lock);
-                {
-                        local->inode_ctx->lock_count++;
-                }
-                UNLOCK (&local->inode->lock);
+    if (op_ret == 0 && local->transaction.type == AFR_DATA_TRANSACTION) {
+        LOCK(&local->inode->lock);
+        {
+            local->inode_ctx->lock_count++;
         }
+        UNLOCK(&local->inode->lock);
+    }
 
-        LOCK (&frame->lock);
-        {
-		if (op_ret < 0) {
-			if (op_errno == ENOSYS) {
-				/* return ENOTSUP */
-		                gf_msg (this->name, GF_LOG_ERROR, ENOSYS,
-                                        AFR_MSG_LOCK_XLATOR_NOT_LOADED,
-					"subvolume does not support "
-                                        "locking. please load features/locks"
-                                        " xlator on server");
-				local->op_ret                = op_ret;
-				int_lock->lock_op_ret        = op_ret;
-				int_lock->lock_op_errno      = op_errno;
-				local->op_errno              = op_errno;
-			}
-		} else {
-			int_lock->locked_nodes[child_index] |= LOCKED_YES;
-			int_lock->lock_count++;
-		}
-
-                call_count = --int_lock->lk_call_count;
+    LOCK(&frame->lock);
+    {
+        if (op_ret < 0) {
+            if (op_errno == ENOSYS) {
+                /* return ENOTSUP */
+                gf_msg(this->name, GF_LOG_ERROR, ENOSYS,
+                       AFR_MSG_LOCK_XLATOR_NOT_LOADED,
+                       "subvolume does not support "
+                       "locking. please load features/locks"
+                       " xlator on server");
+                local->op_ret = op_ret;
+                int_lock->lock_op_ret = op_ret;
+                int_lock->lock_op_errno = op_errno;
+                local->op_errno = op_errno;
+            }
+        } else {
+            int_lock->locked_nodes[child_index] |= LOCKED_YES;
+            int_lock->lock_count++;
         }
-        UNLOCK (&frame->lock);
-
-        if (call_count == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Last inode locking reply received");
-                /* all locks successful. Proceed to call FOP */
-                if (int_lock->lock_count == int_lock->lk_expected_count) {
-                        gf_msg_trace (this->name, 0,
-                                      "All servers locked. Calling the cbk");
-                        int_lock->lock_op_ret = 0;
-                        int_lock->lock_cbk (frame, this);
-                }
-                /* Not all locks were successful. Unlock and try locking
-                   again, this time with serially blocking locks */
-                else {
-                        gf_msg_trace (this->name, 0,
-                                      "%d servers locked. "
-                                      "Trying again with blocking calls",
-                                      int_lock->lock_count);
-
-                        afr_unlock_now(frame, this);
-                }
+
+        call_count = --int_lock->lk_call_count;
+    }
+    UNLOCK(&frame->lock);
+
+    if (call_count == 0) {
+        gf_msg_trace(this->name, 0, "Last inode locking reply received");
+        /* all locks successful. Proceed to call FOP */
+        if (int_lock->lock_count == int_lock->lk_expected_count) {
+            gf_msg_trace(this->name, 0, "All servers locked. Calling the cbk");
+            int_lock->lock_op_ret = 0;
+            int_lock->lock_cbk(frame, this);
+        }
+        /* Not all locks were successful. Unlock and try locking
+           again, this time with serially blocking locks */
+        else {
+            gf_msg_trace(this->name, 0,
+                         "%d servers locked. "
+                         "Trying again with blocking calls",
+                         int_lock->lock_count);
+
+            afr_unlock_now(frame, this);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_nonblocking_inodelk (call_frame_t *frame, xlator_t *this)
+afr_nonblocking_inodelk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-        afr_private_t       *priv     = NULL;
-        afr_fd_ctx_t        *fd_ctx   = NULL;
-        int32_t             call_count = 0;
-        int                 i          = 0;
-        int                 ret        = 0;
-
-        local    = frame->local;
-        int_lock = &local->internal_lock;
-        priv     = this->private;
-
-        initialize_inodelk_variables (frame, this);
-
-        if (local->fd) {
-                fd_ctx = afr_fd_ctx_get (local->fd, this);
-                if (!fd_ctx) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_FD_CTX_GET_FAILED,
-                                "unable to get fd ctx for fd=%p",
-                                local->fd);
-
-                        local->op_ret           = -1;
-                        int_lock->lock_op_ret   = -1;
-                        local->op_errno         = EINVAL;
-                        int_lock->lock_op_errno = EINVAL;
-
-			afr_unlock_now (frame, this);
-                        ret = -1;
-                        goto out;
-                }
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int32_t call_count = 0;
+    int i = 0;
+    int ret = 0;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    priv = this->private;
+
+    initialize_inodelk_variables(frame, this);
+
+    if (local->fd) {
+        fd_ctx = afr_fd_ctx_get(local->fd, this);
+        if (!fd_ctx) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_FD_CTX_GET_FAILED,
+                   "unable to get fd ctx for fd=%p", local->fd);
+
+            local->op_ret = -1;
+            int_lock->lock_op_ret = -1;
+            local->op_errno = EINVAL;
+            int_lock->lock_op_errno = EINVAL;
+
+            afr_unlock_now(frame, this);
+            ret = -1;
+            goto out;
         }
+    }
 
-        call_count = internal_lock_count (frame, this);
-        int_lock->lk_call_count = call_count;
-        int_lock->lk_expected_count = call_count;
+    call_count = internal_lock_count(frame, this);
+    int_lock->lk_call_count = call_count;
+    int_lock->lk_expected_count = call_count;
 
-        if (!call_count) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_SUBVOLS_DOWN,
-                        "All bricks are down, aborting.");
-                afr_unlock_now (frame, this);
-                goto out;
-        }
+    if (!call_count) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SUBVOLS_DOWN,
+               "All bricks are down, aborting.");
+        afr_unlock_now(frame, this);
+        goto out;
+    }
 
-        /* Send non-blocking inodelk calls only on up children
-           and where the fd has been opened */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->child_up[i])
-                        continue;
-
-                if (local->fd) {
-                        STACK_WIND_COOKIE (frame, afr_nonblocking_inodelk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->finodelk,
-                                           int_lock->domain, local->fd,
-                                           F_SETLK, &int_lock->flock, NULL);
-                } else {
-
-                        STACK_WIND_COOKIE (frame, afr_nonblocking_inodelk_cbk,
-                                           (void *) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->inodelk,
-                                           int_lock->domain, &local->loc,
-                                           F_SETLK, &int_lock->flock, NULL);
-                }
-                if (!--call_count)
-                        break;
+    /* Send non-blocking inodelk calls only on up children
+       and where the fd has been opened */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->child_up[i])
+            continue;
+
+        if (local->fd) {
+            STACK_WIND_COOKIE(
+                frame, afr_nonblocking_inodelk_cbk, (void *)(long)i,
+                priv->children[i], priv->children[i]->fops->finodelk,
+                int_lock->domain, local->fd, F_SETLK, &int_lock->flock, NULL);
+        } else {
+            STACK_WIND_COOKIE(
+                frame, afr_nonblocking_inodelk_cbk, (void *)(long)i,
+                priv->children[i], priv->children[i]->fops->inodelk,
+                int_lock->domain, &local->loc, F_SETLK, &int_lock->flock, NULL);
         }
+        if (!--call_count)
+            break;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-afr_unlock (call_frame_t *frame, xlator_t *this)
+afr_unlock(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        afr_lock_t  *lock  = NULL;
-
-        local = frame->local;
-
-        if (!local->transaction.eager_lock_on)
-                goto out;
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        LOCK (&local->inode->lock);
-        {
-                list_del_init (&local->transaction.owner_list);
-                if (list_empty (&lock->owners) && list_empty (&lock->post_op)) {
-                        local->transaction.do_eager_unlock = _gf_true;
-        /*TODO: Need to get metadata use on_disk and inherit/uninherit
-         *GF_ASSERT (!local->inode_ctx->on_disk[local->transaction.type]);
-         *GF_ASSERT (!local->inode_ctx->inherited[local->transaction.type]);
-        */
-                        GF_ASSERT (lock->release);
-                }
-        }
-        UNLOCK (&local->inode->lock);
-        if (!local->transaction.do_eager_unlock) {
-                local->internal_lock.lock_cbk (frame, this);
-                return 0;
+    afr_local_t *local = NULL;
+    afr_lock_t *lock = NULL;
+
+    local = frame->local;
+
+    if (!local->transaction.eager_lock_on)
+        goto out;
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        list_del_init(&local->transaction.owner_list);
+        if (list_empty(&lock->owners) && list_empty(&lock->post_op)) {
+            local->transaction.do_eager_unlock = _gf_true;
+            /*TODO: Need to get metadata use on_disk and inherit/uninherit
+             *GF_ASSERT (!local->inode_ctx->on_disk[local->transaction.type]);
+             *GF_ASSERT (!local->inode_ctx->inherited[local->transaction.type]);
+             */
+            GF_ASSERT(lock->release);
         }
+    }
+    UNLOCK(&local->inode->lock);
+    if (!local->transaction.do_eager_unlock) {
+        local->internal_lock.lock_cbk(frame, this);
+        return 0;
+    }
 
 out:
-        afr_unlock_now (frame, this);
-        return 0;
+    afr_unlock_now(frame, this);
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-open.c b/xlators/cluster/afr/src/afr-open.c
index 3057deed604..a202d528ec8 100644
--- a/xlators/cluster/afr/src/afr-open.c
+++ b/xlators/cluster/afr/src/afr-open.c
@@ -36,336 +36,318 @@
 #include "afr-dir-write.h"
 #include "afr-transaction.h"
 
-
 gf_boolean_t
-afr_is_fd_fixable (fd_t *fd)
+afr_is_fd_fixable(fd_t *fd)
 {
-        if (!fd || !fd->inode)
-                return _gf_false;
-        else if (fd_is_anonymous (fd))
-                return _gf_false;
-        else if (gf_uuid_is_null (fd->inode->gfid))
-                return _gf_false;
-
-        return _gf_true;
+    if (!fd || !fd->inode)
+        return _gf_false;
+    else if (fd_is_anonymous(fd))
+        return _gf_false;
+    else if (gf_uuid_is_null(fd->inode->gfid))
+        return _gf_false;
+
+    return _gf_true;
 }
 
-
 int
-afr_open_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
+afr_open_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                       struct iatt *postbuf, dict_t *xdata)
 {
-        afr_local_t * local = frame->local;
+    afr_local_t *local = frame->local;
 
-        AFR_STACK_UNWIND (open, frame, local->op_ret, local->op_errno,
-                          local->fd, xdata);
-        return 0;
+    AFR_STACK_UNWIND(open, frame, local->op_ret, local->op_errno, local->fd,
+                     xdata);
+    return 0;
 }
 
 int
-afr_open_cbk (call_frame_t *frame, void *cookie,
-              xlator_t *this, int32_t op_ret, int32_t op_errno,
-              fd_t *fd, dict_t *xdata)
+afr_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        afr_local_t   *local           = NULL;
-        int           call_count       = -1;
-        int           child_index      = (long) cookie;
-        afr_fd_ctx_t  *fd_ctx          = NULL;
-
-        local = frame->local;
-	fd_ctx = local->fd_ctx;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-			fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                } else {
-                        local->op_ret = op_ret;
-			fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-			if (!local->xdata_rsp && xdata)
-				local->xdata_rsp = dict_ref (xdata);
-                }
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = (long)cookie;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    local = frame->local;
+    fd_ctx = local->fd_ctx;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
+        } else {
+            local->op_ret = op_ret;
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
+            if (!local->xdata_rsp && xdata)
+                local->xdata_rsp = dict_ref(xdata);
         }
-        UNLOCK (&frame->lock);
-
-        call_count = afr_frame_return (frame);
-
-        if (call_count == 0) {
-                if ((fd_ctx->flags & O_TRUNC) && (local->op_ret >= 0)) {
-                        STACK_WIND (frame, afr_open_ftruncate_cbk,
-                                    this, this->fops->ftruncate,
-                                    fd, 0, NULL);
-                } else {
-                        AFR_STACK_UNWIND (open, frame, local->op_ret,
-                                          local->op_errno, local->cont.open.fd,
-                                          local->xdata_rsp);
-                }
+    }
+    UNLOCK(&frame->lock);
+
+    call_count = afr_frame_return(frame);
+
+    if (call_count == 0) {
+        if ((fd_ctx->flags & O_TRUNC) && (local->op_ret >= 0)) {
+            STACK_WIND(frame, afr_open_ftruncate_cbk, this,
+                       this->fops->ftruncate, fd, 0, NULL);
+        } else {
+            AFR_STACK_UNWIND(open, frame, local->op_ret, local->op_errno,
+                             local->cont.open.fd, local->xdata_rsp);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_open_continue (call_frame_t *frame, xlator_t *this, int err)
+afr_open_continue(call_frame_t *frame, xlator_t *this, int err)
 {
-        afr_local_t   *local     = NULL;
-        afr_private_t *priv      = NULL;
-        int           call_count = 0;
-        int           i          = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = 0;
+    int i = 0;
 
-        local  = frame->local;
-        priv   = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        if (err) {
-                AFR_STACK_UNWIND (open, frame, -1, err, NULL, NULL);
-        } else {
-                local->call_count = AFR_COUNT (local->child_up,
-                                               priv->child_count);
-                call_count = local->call_count;
-
-                for (i = 0; i < priv->child_count; i++) {
-                        if (local->child_up[i]) {
-                                STACK_WIND_COOKIE (frame, afr_open_cbk,
-                                                   (void *)(long)i,
-                                                   priv->children[i],
-                                                  priv->children[i]->fops->open,
-                                                   &local->loc,
-                                            (local->cont.open.flags & ~O_TRUNC),
-                                                   local->cont.open.fd,
-                                                   local->xdata_req);
-                                if (!--call_count)
-                                        break;
-                        }
-                }
+    if (err) {
+        AFR_STACK_UNWIND(open, frame, -1, err, NULL, NULL);
+    } else {
+        local->call_count = AFR_COUNT(local->child_up, priv->child_count);
+        call_count = local->call_count;
+
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->child_up[i]) {
+                STACK_WIND_COOKIE(frame, afr_open_cbk, (void *)(long)i,
+                                  priv->children[i],
+                                  priv->children[i]->fops->open, &local->loc,
+                                  (local->cont.open.flags & ~O_TRUNC),
+                                  local->cont.open.fd, local->xdata_req);
+                if (!--call_count)
+                    break;
+            }
         }
-        return 0;
+    }
+    return 0;
 }
 
 int
-afr_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-          fd_t *fd, dict_t *xdata)
+afr_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+         fd_t *fd, dict_t *xdata)
 {
-        afr_private_t *priv            = NULL;
-        afr_local_t   *local           = NULL;
-        int           spb_choice       = 0;
-        int           event_generation = 0;
-        int           ret              = 0;
-        int32_t       op_errno         = 0;
-        afr_fd_ctx_t  *fd_ctx          = NULL;
-
-        //We can't let truncation to happen outside transaction.
-
-        priv = this->private;
-
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
-
-        local->op = GF_FOP_OPEN;
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx) {
-		op_errno = ENOMEM;
-		goto out;
-	}
-
-        if (!afr_is_consistent_io_possible (local, priv, &op_errno))
-		goto out;
-
-        local->inode = inode_ref (loc->inode);
-        loc_copy (&local->loc, loc);
-	local->fd_ctx = fd_ctx;
-	fd_ctx->flags = flags;
-        if (xdata)
-                local->xdata_req = dict_ref (xdata);
-
-        local->cont.open.flags = flags;
-        local->cont.open.fd = fd_ref (fd);
-
-        ret = afr_inode_get_readable (frame, local->inode, this,
-                                      NULL, &event_generation,
-                                      AFR_DATA_TRANSACTION);
-        if ((ret < 0) &&
-            (afr_inode_split_brain_choice_get (local->inode,
-                                             this, &spb_choice) == 0) &&
-            spb_choice < 0) {
-                afr_inode_refresh (frame, this, local->inode,
-                                   local->inode->gfid, afr_open_continue);
-        } else {
-                afr_open_continue (frame, this, 0);
-        }
-
-	return 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int spb_choice = 0;
+    int event_generation = 0;
+    int ret = 0;
+    int32_t op_errno = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+
+    // We can't let truncation to happen outside transaction.
+
+    priv = this->private;
+
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
+
+    local->op = GF_FOP_OPEN;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx) {
+        op_errno = ENOMEM;
+        goto out;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &op_errno))
+        goto out;
+
+    local->inode = inode_ref(loc->inode);
+    loc_copy(&local->loc, loc);
+    local->fd_ctx = fd_ctx;
+    fd_ctx->flags = flags;
+    if (xdata)
+        local->xdata_req = dict_ref(xdata);
+
+    local->cont.open.flags = flags;
+    local->cont.open.fd = fd_ref(fd);
+
+    ret = afr_inode_get_readable(frame, local->inode, this, NULL,
+                                 &event_generation, AFR_DATA_TRANSACTION);
+    if ((ret < 0) &&
+        (afr_inode_split_brain_choice_get(local->inode, this, &spb_choice) ==
+         0) &&
+        spb_choice < 0) {
+        afr_inode_refresh(frame, this, local->inode, local->inode->gfid,
+                          afr_open_continue);
+    } else {
+        afr_open_continue(frame, this, 0);
+    }
+
+    return 0;
 out:
-	AFR_STACK_UNWIND (open, frame, -1, op_errno, fd, NULL);
+    AFR_STACK_UNWIND(open, frame, -1, op_errno, fd, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_openfd_fix_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, fd_t *fd,
-                         dict_t *xdata)
+afr_openfd_fix_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, fd_t *fd,
+                        dict_t *xdata)
 {
-        afr_local_t   *local      = NULL;
-        afr_private_t *priv       = NULL;
-        afr_fd_ctx_t  *fd_ctx     = NULL;
-        int           call_count  = 0;
-        int           child_index = (long) cookie;
-
-        priv     = this->private;
-        local    = frame->local;
-
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    int call_count = 0;
+    int child_index = (long)cookie;
+
+    priv = this->private;
+    local = frame->local;
+
+    if (op_ret >= 0) {
+        gf_msg_debug(this->name, 0,
+                     "fd for %s opened "
+                     "successfully on subvolume %s",
+                     local->loc.path, priv->children[child_index]->name);
+    } else {
+        gf_msg(this->name, fop_log_level(GF_FOP_OPEN, op_errno), op_errno,
+               AFR_MSG_OPEN_FAIL,
+               "Failed to open %s on "
+               "subvolume %s",
+               local->loc.path, priv->children[child_index]->name);
+    }
+
+    fd_ctx = local->fd_ctx;
+
+    LOCK(&local->fd->lock);
+    {
         if (op_ret >= 0) {
-                gf_msg_debug (this->name, 0, "fd for %s opened "
-                              "successfully on subvolume %s", local->loc.path,
-                              priv->children[child_index]->name);
+            fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
         } else {
-                gf_msg (this->name, fop_log_level (GF_FOP_OPEN, op_errno),
-                        op_errno, AFR_MSG_OPEN_FAIL, "Failed to open %s on "
-                        "subvolume %s", local->loc.path,
-                        priv->children[child_index]->name);
+            fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
         }
+    }
+    UNLOCK(&local->fd->lock);
 
-        fd_ctx = local->fd_ctx;
+    call_count = afr_frame_return(frame);
+    if (call_count == 0)
+        AFR_STACK_DESTROY(frame);
 
-        LOCK (&local->fd->lock);
-        {
-                if (op_ret >= 0) {
-                        fd_ctx->opened_on[child_index] = AFR_FD_OPENED;
-                } else {
-                        fd_ctx->opened_on[child_index] = AFR_FD_NOT_OPENED;
-                }
-        }
-        UNLOCK (&local->fd->lock);
+    return 0;
+}
 
-        call_count = afr_frame_return (frame);
-        if (call_count == 0)
-                AFR_STACK_DESTROY (frame);
+static int
+afr_fd_ctx_need_open(fd_t *fd, xlator_t *this, unsigned char *need_open)
+{
+    afr_fd_ctx_t *fd_ctx = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int count = 0;
 
+    priv = this->private;
+
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
         return 0;
-}
 
+    LOCK(&fd->lock);
+    {
+        for (i = 0; i < priv->child_count; i++) {
+            if (fd_ctx->opened_on[i] == AFR_FD_NOT_OPENED &&
+                priv->child_up[i]) {
+                fd_ctx->opened_on[i] = AFR_FD_OPENING;
+                need_open[i] = 1;
+                count++;
+            } else {
+                need_open[i] = 0;
+            }
+        }
+    }
+    UNLOCK(&fd->lock);
 
-static int
-afr_fd_ctx_need_open (fd_t *fd, xlator_t *this, unsigned char *need_open)
-{
-	afr_fd_ctx_t *fd_ctx = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int count = 0;
-
-	priv = this->private;
-
-	fd_ctx = afr_fd_ctx_get (fd, this);
-	if (!fd_ctx)
-		return 0;
-
-	LOCK (&fd->lock);
-	{
-		for (i = 0; i < priv->child_count; i++) {
-			if (fd_ctx->opened_on[i] == AFR_FD_NOT_OPENED &&
-			    priv->child_up[i]) {
-				fd_ctx->opened_on[i] = AFR_FD_OPENING;
-				need_open[i] = 1;
-				count++;
-			} else {
-				need_open[i] = 0;
-			}
-		}
-	}
-	UNLOCK (&fd->lock);
-
-	return count;
+    return count;
 }
 
-
 void
-afr_fix_open (fd_t *fd, xlator_t *this)
+afr_fix_open(fd_t *fd, xlator_t *this)
 {
-        afr_private_t *priv    = NULL;
-        int           i        = 0;
-        call_frame_t  *frame   = NULL;
-        afr_local_t   *local   = NULL;
-        int           ret      = -1;
-        int32_t       op_errno = 0;
-        afr_fd_ctx_t  *fd_ctx  = NULL;
-	unsigned char *need_open = NULL;
-	int call_count = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = -1;
+    int32_t op_errno = 0;
+    afr_fd_ctx_t *fd_ctx = NULL;
+    unsigned char *need_open = NULL;
+    int call_count = 0;
 
-        priv  = this->private;
+    priv = this->private;
 
-        if (!afr_is_fd_fixable (fd))
-                goto out;
+    if (!afr_is_fd_fixable(fd))
+        goto out;
 
-        fd_ctx = afr_fd_ctx_get (fd, this);
-        if (!fd_ctx)
-                goto out;
+    fd_ctx = afr_fd_ctx_get(fd, this);
+    if (!fd_ctx)
+        goto out;
 
-	need_open = alloca0 (priv->child_count);
+    need_open = alloca0(priv->child_count);
 
-	call_count = afr_fd_ctx_need_open (fd, this, need_open);
-	if (!call_count)
-		goto out;
+    call_count = afr_fd_ctx_need_open(fd, this, need_open);
+    if (!call_count)
+        goto out;
 
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-	local = AFR_FRAME_INIT (frame, op_errno);
-	if (!local)
-		goto out;
+    local = AFR_FRAME_INIT(frame, op_errno);
+    if (!local)
+        goto out;
 
-        local->loc.inode = inode_ref (fd->inode);
-        ret = loc_path (&local->loc, NULL);
-        if (ret < 0)
-                goto out;
+    local->loc.inode = inode_ref(fd->inode);
+    ret = loc_path(&local->loc, NULL);
+    if (ret < 0)
+        goto out;
 
-        local->fd = fd_ref (fd);
-	local->fd_ctx = fd_ctx;
+    local->fd = fd_ref(fd);
+    local->fd_ctx = fd_ctx;
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        gf_msg_debug (this->name, 0, "need open count: %d",
-                      call_count);
+    gf_msg_debug(this->name, 0, "need open count: %d", call_count);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!need_open[i])
-                        continue;
-
-                if (IA_IFDIR == fd->inode->ia_type) {
-                        gf_msg_debug (this->name, 0,
-                                      "opening fd for dir %s on subvolume %s",
-                                      local->loc.path, priv->children[i]->name);
-
-                        STACK_WIND_COOKIE (frame, afr_openfd_fix_open_cbk,
-                                           (void*) (long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->opendir,
-                                           &local->loc, local->fd,
-                                           NULL);
-                } else {
-                        gf_msg_debug (this->name, 0,
-                                      "opening fd for file %s on subvolume %s",
-                                      local->loc.path, priv->children[i]->name);
-
-                        STACK_WIND_COOKIE (frame, afr_openfd_fix_open_cbk,
-                                           (void *)(long) i,
-                                           priv->children[i],
-                                           priv->children[i]->fops->open,
-                                           &local->loc,
-                                           fd_ctx->flags & (~O_TRUNC),
-                                           local->fd, NULL);
-                }
-
-		if (!--call_count)
-			break;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!need_open[i])
+            continue;
+
+        if (IA_IFDIR == fd->inode->ia_type) {
+            gf_msg_debug(this->name, 0, "opening fd for dir %s on subvolume %s",
+                         local->loc.path, priv->children[i]->name);
+
+            STACK_WIND_COOKIE(frame, afr_openfd_fix_open_cbk, (void *)(long)i,
+                              priv->children[i],
+                              priv->children[i]->fops->opendir, &local->loc,
+                              local->fd, NULL);
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "opening fd for file %s on subvolume %s",
+                         local->loc.path, priv->children[i]->name);
+
+            STACK_WIND_COOKIE(frame, afr_openfd_fix_open_cbk, (void *)(long)i,
+                              priv->children[i], priv->children[i]->fops->open,
+                              &local->loc, fd_ctx->flags & (~O_TRUNC),
+                              local->fd, NULL);
         }
 
-	return;
+        if (!--call_count)
+            break;
+    }
+
+    return;
 out:
-        if (frame)
-                AFR_STACK_DESTROY (frame);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 }
diff --git a/xlators/cluster/afr/src/afr-read-txn.c b/xlators/cluster/afr/src/afr-read-txn.c
index 945c050da03..1df39c35fce 100644
--- a/xlators/cluster/afr/src/afr-read-txn.c
+++ b/xlators/cluster/afr/src/afr-read-txn.c
@@ -13,347 +13,343 @@
 #include "afr-messages.h"
 
 void
-afr_pending_read_increment (afr_private_t *priv, int child_index)
+afr_pending_read_increment(afr_private_t *priv, int child_index)
 {
-        if (child_index < 0 || child_index > priv->child_count)
-                return;
+    if (child_index < 0 || child_index > priv->child_count)
+        return;
 
-        GF_ATOMIC_INC(priv->pending_reads[child_index]);
+    GF_ATOMIC_INC(priv->pending_reads[child_index]);
 }
 
 void
-afr_pending_read_decrement (afr_private_t *priv, int child_index)
+afr_pending_read_decrement(afr_private_t *priv, int child_index)
 {
-        if (child_index < 0 || child_index > priv->child_count)
-                return;
+    if (child_index < 0 || child_index > priv->child_count)
+        return;
 
-        GF_ATOMIC_DEC(priv->pending_reads[child_index]);
+    GF_ATOMIC_DEC(priv->pending_reads[child_index]);
 }
 
 static gf_boolean_t
-afr_ta_dict_contains_pending_xattr (dict_t *dict, afr_private_t *priv,
-                                    int child)
+afr_ta_dict_contains_pending_xattr(dict_t *dict, afr_private_t *priv, int child)
 {
-        int     *pending                     = NULL;
-        int     ret                          = 0;
-        int     i                            = 0;
-
-        ret = dict_get_ptr (dict, priv->pending_key[child], (void *)&pending);
-        if (ret == 0) {
-                for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
-                        /* Not doing a ntoh32(pending) as we just want to check
-                         * if it is non-zero or not. */
-                        if (pending[i]) {
-                                return _gf_true;
-                        }
-                }
+    int *pending = NULL;
+    int ret = 0;
+    int i = 0;
+
+    ret = dict_get_ptr(dict, priv->pending_key[child], (void *)&pending);
+    if (ret == 0) {
+        for (i = 0; i < AFR_NUM_CHANGE_LOGS; i++) {
+            /* Not doing a ntoh32(pending) as we just want to check
+             * if it is non-zero or not. */
+            if (pending[i]) {
+                return _gf_true;
+            }
         }
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 void
-afr_read_txn_wind (call_frame_t *frame, xlator_t *this, int subvol)
+afr_read_txn_wind(call_frame_t *frame, xlator_t *this, int subvol)
 {
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        afr_pending_read_decrement (priv, local->read_subvol);
-        local->read_subvol = subvol;
-        afr_pending_read_increment (priv, subvol);
-        local->readfn (frame, this, subvol);
+    afr_pending_read_decrement(priv, local->read_subvol);
+    local->read_subvol = subvol;
+    afr_pending_read_increment(priv, subvol);
+    local->readfn(frame, this, subvol);
 }
 
 int
-afr_read_txn_next_subvol (call_frame_t *frame, xlator_t *this)
+afr_read_txn_next_subvol(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	int subvol = -1;
-
-	local = frame->local;
-	priv = this->private;
-
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!local->readable[i]) {
-			/* don't even bother trying here.
-			   just mark as attempted and move on. */
-			local->read_attempted[i] = 1;
-			continue;
-		}
-
-		if (!local->read_attempted[i]) {
-			subvol = i;
-			break;
-		}
-	}
-
-	/* If no more subvols were available for reading, we leave
-	   @subvol as -1, which is an indication we have run out of
-	   readable subvols. */
-	if (subvol != -1)
-		local->read_attempted[subvol] = 1;
-	afr_read_txn_wind (frame, this, subvol);
-
-	return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int subvol = -1;
+
+    local = frame->local;
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->readable[i]) {
+            /* don't even bother trying here.
+               just mark as attempted and move on. */
+            local->read_attempted[i] = 1;
+            continue;
+        }
+
+        if (!local->read_attempted[i]) {
+            subvol = i;
+            break;
+        }
+    }
+
+    /* If no more subvols were available for reading, we leave
+       @subvol as -1, which is an indication we have run out of
+       readable subvols. */
+    if (subvol != -1)
+        local->read_attempted[subvol] = 1;
+    afr_read_txn_wind(frame, this, subvol);
+
+    return 0;
 }
 
 static int
-afr_ta_read_txn_done (int ret, call_frame_t *ta_frame, void *opaque)
+afr_ta_read_txn_done(int ret, call_frame_t *ta_frame, void *opaque)
 {
-        STACK_DESTROY(ta_frame->root);
-        return 0;
+    STACK_DESTROY(ta_frame->root);
+    return 0;
 }
 
 static int
-afr_ta_read_txn (void *opaque)
+afr_ta_read_txn(void *opaque)
 {
-        call_frame_t    *frame             = NULL;
-        xlator_t        *this              = NULL;
-        int             read_subvol        = -1;
-        int             up_child           = AFR_CHILD_UNKNOWN;
-        int             possible_bad_child = AFR_CHILD_UNKNOWN;
-        int             ret                = 0;
-        int             op_errno           = ENOMEM;
-        afr_local_t     *local             = NULL;
-        afr_private_t   *priv              = NULL;
-        struct gf_flock flock              = {0, };
-        dict_t          *xdata_req         = NULL;
-        dict_t          *xdata_rsp         = NULL;
-        int             **pending          = NULL;
-        loc_t           loc                = {0,};
-
-        frame = (call_frame_t *)opaque;
-        this = frame->this;
-        local = frame->local;
-        priv = this->private;
-
-        if (local->child_up[AFR_CHILD_ZERO]) {
-                up_child = AFR_CHILD_ZERO;
-                possible_bad_child = AFR_CHILD_ONE;
-        } else if (local->child_up[AFR_CHILD_ONE]) {
-                up_child = AFR_CHILD_ONE;
-                possible_bad_child = AFR_CHILD_ZERO;
-        }
-
-        GF_ASSERT (up_child != AFR_CHILD_UNKNOWN);
-
-        /* Query the up_child to see if it blames the down one. */
-        xdata_req = dict_new();
-        if (!xdata_req)
-                goto out;
-
-        pending = afr_matrix_create (priv->child_count, AFR_NUM_CHANGE_LOGS);
-        if (!pending)
-                goto out;
-
-        ret = afr_set_pending_dict (priv, xdata_req, pending);
-        if (ret < 0)
-                goto out;
-
-        if (local->fd) {
-                ret = syncop_fxattrop (priv->children[up_child], local->fd,
-                                       GF_XATTROP_ADD_ARRAY, xdata_req, NULL,
-                                       &xdata_rsp, NULL);
-        } else {
-               ret = syncop_xattrop (priv->children[up_child], &local->loc,
-                                     GF_XATTROP_ADD_ARRAY, xdata_req, NULL,
-                                     &xdata_rsp, NULL);
-        }
-        if (ret || !xdata_rsp) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed xattrop for gfid %s on %s",
-                        uuid_utoa (local->inode->gfid),
-                        priv->children[up_child]->name);
-                op_errno = -ret;
-                goto out;
-        }
-
-        if (afr_ta_dict_contains_pending_xattr (xdata_rsp, priv,
-                                                possible_bad_child)) {
-                read_subvol = up_child;
-                goto out;
-        }
-        dict_unref (xdata_rsp);
-        /* Query thin-arbiter to see if it blames any data brick. */
-        ret = afr_fill_ta_loc (this, &loc);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to populate thin-arbiter loc for: %s.",
-                        loc.name);
-                goto out;
-        }
-        flock.l_type = F_WRLCK;/*start and length are already zero. */
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_MODIFY, &loc, F_SETLKW, &flock,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "gfid:%s: Failed to get AFR_TA_DOM_MODIFY lock on %s.",
-                        uuid_utoa (local->inode->gfid),
-                        priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
-                op_errno = -ret;
-                goto out;
-        }
-
-        ret = syncop_xattrop (priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    int read_subvol = -1;
+    int up_child = AFR_CHILD_UNKNOWN;
+    int possible_bad_child = AFR_CHILD_UNKNOWN;
+    int ret = 0;
+    int op_errno = ENOMEM;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    dict_t *xdata_req = NULL;
+    dict_t *xdata_rsp = NULL;
+    int **pending = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    frame = (call_frame_t *)opaque;
+    this = frame->this;
+    local = frame->local;
+    priv = this->private;
+
+    if (local->child_up[AFR_CHILD_ZERO]) {
+        up_child = AFR_CHILD_ZERO;
+        possible_bad_child = AFR_CHILD_ONE;
+    } else if (local->child_up[AFR_CHILD_ONE]) {
+        up_child = AFR_CHILD_ONE;
+        possible_bad_child = AFR_CHILD_ZERO;
+    }
+
+    GF_ASSERT(up_child != AFR_CHILD_UNKNOWN);
+
+    /* Query the up_child to see if it blames the down one. */
+    xdata_req = dict_new();
+    if (!xdata_req)
+        goto out;
+
+    pending = afr_matrix_create(priv->child_count, AFR_NUM_CHANGE_LOGS);
+    if (!pending)
+        goto out;
+
+    ret = afr_set_pending_dict(priv, xdata_req, pending);
+    if (ret < 0)
+        goto out;
+
+    if (local->fd) {
+        ret = syncop_fxattrop(priv->children[up_child], local->fd,
                               GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
                               NULL);
-        if (ret || !xdata_rsp) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "gfid:%s: Failed xattrop on %s.",
-                        uuid_utoa (local->inode->gfid),
-                        priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
-                op_errno = -ret;
-                goto unlock;
-        }
-
-        if (!afr_ta_dict_contains_pending_xattr(xdata_rsp, priv, up_child)) {
-                read_subvol = up_child;
-        } else {
-                gf_msg (this->name, GF_LOG_ERROR, EIO, AFR_MSG_THIN_ARB,
-                        "Failing read for gfid %s since good brick %s is down",
-                        uuid_utoa (local->inode->gfid),
-                        priv->children[possible_bad_child]->name);
-                op_errno = EIO;
-        }
+    } else {
+        ret = syncop_xattrop(priv->children[up_child], &local->loc,
+                             GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
+                             NULL);
+    }
+    if (ret || !xdata_rsp) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed xattrop for gfid %s on %s",
+               uuid_utoa(local->inode->gfid), priv->children[up_child]->name);
+        op_errno = -ret;
+        goto out;
+    }
+
+    if (afr_ta_dict_contains_pending_xattr(xdata_rsp, priv,
+                                           possible_bad_child)) {
+        read_subvol = up_child;
+        goto out;
+    }
+    dict_unref(xdata_rsp);
+    /* Query thin-arbiter to see if it blames any data brick. */
+    ret = afr_fill_ta_loc(this, &loc);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        goto out;
+    }
+    flock.l_type = F_WRLCK; /*start and length are already zero. */
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, &loc, F_SETLKW, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed to get AFR_TA_DOM_MODIFY lock on %s.",
+               uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+        op_errno = -ret;
+        goto out;
+    }
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                         GF_XATTROP_ADD_ARRAY, xdata_req, NULL, &xdata_rsp,
+                         NULL);
+    if (ret || !xdata_rsp) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed xattrop on %s.", uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+        op_errno = -ret;
+        goto unlock;
+    }
+
+    if (!afr_ta_dict_contains_pending_xattr(xdata_rsp, priv, up_child)) {
+        read_subvol = up_child;
+    } else {
+        gf_msg(this->name, GF_LOG_ERROR, EIO, AFR_MSG_THIN_ARB,
+               "Failing read for gfid %s since good brick %s is down",
+               uuid_utoa(local->inode->gfid),
+               priv->children[possible_bad_child]->name);
+        op_errno = EIO;
+    }
 
 unlock:
-        flock.l_type = F_UNLCK;
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_MODIFY, &loc, F_SETLK, &flock,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "gfid:%s: Failed to unlock AFR_TA_DOM_MODIFY lock on "
-                        "%s.", uuid_utoa (local->inode->gfid),
-                        priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
-        }
+    flock.l_type = F_UNLCK;
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_MODIFY, &loc, F_SETLK, &flock, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "gfid:%s: Failed to unlock AFR_TA_DOM_MODIFY lock on "
+               "%s.",
+               uuid_utoa(local->inode->gfid),
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX]);
+    }
 out:
-        if (xdata_req)
-                dict_unref(xdata_req);
-        if (xdata_rsp)
-                dict_unref(xdata_rsp);
-        if (pending)
-                afr_matrix_cleanup (pending, priv->child_count);
-        loc_wipe (&loc);
-
-        if (read_subvol == -1) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-        }
-        afr_read_txn_wind (frame, this, read_subvol);
-        return ret;
+    if (xdata_req)
+        dict_unref(xdata_req);
+    if (xdata_rsp)
+        dict_unref(xdata_rsp);
+    if (pending)
+        afr_matrix_cleanup(pending, priv->child_count);
+    loc_wipe(&loc);
+
+    if (read_subvol == -1) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
+    afr_read_txn_wind(frame, this, read_subvol);
+    return ret;
 }
 
 void
-afr_ta_read_txn_synctask (call_frame_t *frame, xlator_t *this)
+afr_ta_read_txn_synctask(call_frame_t *frame, xlator_t *this)
 {
-        call_frame_t *ta_frame  = NULL;
-        afr_local_t  *local     = NULL;
-        int          ret        = 0;
-
-        local = frame->local;
-        ta_frame = afr_ta_frame_create(this);
-        if (!ta_frame) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                goto out;
-        }
-        ret = synctask_new (this->ctx->env, afr_ta_read_txn,
-                            afr_ta_read_txn_done, ta_frame, frame);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        AFR_MSG_THIN_ARB, "Failed to launch "
-                        "afr_ta_read_txn synctask for gfid %s.",
-                        uuid_utoa(local->inode->gfid));
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                STACK_DESTROY(ta_frame->root);
-                goto out;
-        }
-        return;
+    call_frame_t *ta_frame = NULL;
+    afr_local_t *local = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    ta_frame = afr_ta_frame_create(this);
+    if (!ta_frame) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        goto out;
+    }
+    ret = synctask_new(this->ctx->env, afr_ta_read_txn, afr_ta_read_txn_done,
+                       ta_frame, frame);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, AFR_MSG_THIN_ARB,
+               "Failed to launch "
+               "afr_ta_read_txn synctask for gfid %s.",
+               uuid_utoa(local->inode->gfid));
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        STACK_DESTROY(ta_frame->root);
+        goto out;
+    }
+    return;
 out:
-        afr_read_txn_wind (frame, this, -1);
+    afr_read_txn_wind(frame, this, -1);
 }
 
 int
-afr_read_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
+afr_read_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
 {
-        afr_private_t   *priv           = NULL;
-        afr_local_t     *local          = NULL;
-        int             read_subvol     = -1;
-        inode_t         *inode          = NULL;
-        int             ret             = -1;
-        int             spb_choice      = -1;
-
-	local = frame->local;
-	inode = local->inode;
-        priv = this->private;
-
-        if (err) {
-                if (!priv->thin_arbiter_count)
-                        goto readfn;
-                if (err != EINVAL)
-                        goto readfn;
-                /* We need to query the good bricks and/or thin-arbiter.*/
-                afr_ta_read_txn_synctask (frame, this);
-                return 0;
-        }
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int read_subvol = -1;
+    inode_t *inode = NULL;
+    int ret = -1;
+    int spb_choice = -1;
+
+    local = frame->local;
+    inode = local->inode;
+    priv = this->private;
+
+    if (err) {
+        if (!priv->thin_arbiter_count)
+            goto readfn;
+        if (err != EINVAL)
+            goto readfn;
+        /* We need to query the good bricks and/or thin-arbiter.*/
+        afr_ta_read_txn_synctask(frame, this);
+        return 0;
+    }
 
-	read_subvol = afr_read_subvol_select_by_policy (inode, this,
-							local->readable, NULL);
-	if (read_subvol == -1) {
-                err = EIO;
-                goto readfn;
-        }
+    read_subvol = afr_read_subvol_select_by_policy(inode, this, local->readable,
+                                                   NULL);
+    if (read_subvol == -1) {
+        err = EIO;
+        goto readfn;
+    }
 
-	if (local->read_attempted[read_subvol]) {
-		afr_read_txn_next_subvol (frame, this);
-		return 0;
-	}
+    if (local->read_attempted[read_subvol]) {
+        afr_read_txn_next_subvol(frame, this);
+        return 0;
+    }
 
-	local->read_attempted[read_subvol] = 1;
+    local->read_attempted[read_subvol] = 1;
 readfn:
-        if (read_subvol == -1) {
-                ret = afr_inode_split_brain_choice_get (inode, this,
-                                                        &spb_choice);
-                if ((ret == 0) && spb_choice >= 0)
-                        read_subvol = spb_choice;
-        }
-
-        if (read_subvol == -1) {
-                AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN (-1, err);
-        }
-        afr_read_txn_wind (frame, this, read_subvol);
-
-	return 0;
+    if (read_subvol == -1) {
+        ret = afr_inode_split_brain_choice_get(inode, this, &spb_choice);
+        if ((ret == 0) && spb_choice >= 0)
+            read_subvol = spb_choice;
+    }
+
+    if (read_subvol == -1) {
+        AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, err);
+    }
+    afr_read_txn_wind(frame, this, read_subvol);
+
+    return 0;
 }
 
 int
-afr_read_txn_continue (call_frame_t *frame, xlator_t *this, int subvol)
+afr_read_txn_continue(call_frame_t *frame, xlator_t *this, int subvol)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-	if (!local->refreshed) {
-		local->refreshed = _gf_true;
-		afr_inode_refresh (frame, this, local->inode, NULL,
-				   afr_read_txn_refresh_done);
-	} else {
-		afr_read_txn_next_subvol (frame, this);
-	}
+    if (!local->refreshed) {
+        local->refreshed = _gf_true;
+        afr_inode_refresh(frame, this, local->inode, NULL,
+                          afr_read_txn_refresh_done);
+    } else {
+        afr_read_txn_next_subvol(frame, this);
+    }
 
-	return 0;
+    return 0;
 }
 
-
 /* afr_read_txn_wipe:
 
    clean internal variables in @local in order to make
@@ -362,24 +358,24 @@ afr_read_txn_continue (call_frame_t *frame, xlator_t *this, int subvol)
 */
 
 void
-afr_read_txn_wipe (call_frame_t *frame, xlator_t *this)
+afr_read_txn_wipe(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	local->readfn = NULL;
+    local->readfn = NULL;
 
-	if (local->inode)
-		inode_unref (local->inode);
+    if (local->inode)
+        inode_unref(local->inode);
 
-	for (i = 0; i < priv->child_count; i++) {
-		local->read_attempted[i] = 0;
-		local->readable[i] = 0;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        local->read_attempted[i] = 0;
+        local->readable[i] = 0;
+    }
 }
 
 /*
@@ -410,92 +406,94 @@ afr_read_txn_wipe (call_frame_t *frame, xlator_t *this)
 */
 
 int
-afr_read_txn (call_frame_t *frame, xlator_t *this, inode_t *inode,
-	      afr_read_txn_wind_t readfn, afr_transaction_type type)
+afr_read_txn(call_frame_t *frame, xlator_t *this, inode_t *inode,
+             afr_read_txn_wind_t readfn, afr_transaction_type type)
 {
-        afr_local_t     *local           = NULL;
-        afr_private_t   *priv            = NULL;
-        unsigned char   *data            = NULL;
-        unsigned char   *metadata        = NULL;
-        int             read_subvol      = -1;
-        int             event_generation = 0;
-        int             ret              = -1;
-
-	priv = this->private;
-	local = frame->local;
-        data = alloca0 (priv->child_count);
-        metadata = alloca0 (priv->child_count);
-
-	afr_read_txn_wipe (frame, this);
-
-	local->readfn = readfn;
-	local->inode = inode_ref (inode);
-        local->is_read_txn = _gf_true;
-        local->transaction.type = type;
-
-        if (priv->quorum_count && !afr_has_quorum (local->child_up, this)) {
-                local->op_ret = -1;
-                local->op_errno = afr_quorum_errno(priv);
-                goto read;
-        }
-
-        if (!afr_is_consistent_io_possible (local, priv, &local->op_errno)) {
-                local->op_ret = -1;
-                goto read;
-        }
-
-        if (priv->thin_arbiter_count &&
-            AFR_COUNT (local->child_up, priv->child_count) !=
-                       priv->child_count) {
-                afr_ta_read_txn_synctask (frame, this);
-                return 0;
-        }
-
-        ret = afr_inode_read_subvol_get (inode, this, data, metadata,
-                                         &event_generation);
-	if (ret == -1)
-		/* very first transaction on this inode */
-		goto refresh;
-        AFR_INTERSECT (local->readable, data, metadata, priv->child_count);
-
-        gf_msg_debug (this->name, 0, "%s: generation now vs cached: %d, "
-                      "%d", uuid_utoa (inode->gfid), local->event_generation,
-                      event_generation);
-	if (afr_is_inode_refresh_reqd (inode, this, local->event_generation,
-                                       event_generation))
-		/* servers have disconnected / reconnected, and possibly
-		   rebooted, very likely changing the state of freshness
-		   of copies */
-		goto refresh;
-
-	read_subvol = afr_read_subvol_select_by_policy (inode, this,
-							local->readable, NULL);
-
-	if (read_subvol < 0 || read_subvol > priv->child_count) {
-	        gf_msg_debug (this->name, 0, "Unreadable subvolume %d found "
-                       "with event generation %d for gfid %s.",
-                        read_subvol, event_generation, uuid_utoa(inode->gfid));
-		goto refresh;
-	}
-
-	if (!local->child_up[read_subvol]) {
-		/* should never happen, just in case */
-	        gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_READ_SUBVOL_ERROR, "subvolume %d is the "
-			"read subvolume in this generation, but is not up",
-			read_subvol);
-		goto refresh;
-	}
-
-	local->read_attempted[read_subvol] = 1;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char *data = NULL;
+    unsigned char *metadata = NULL;
+    int read_subvol = -1;
+    int event_generation = 0;
+    int ret = -1;
+
+    priv = this->private;
+    local = frame->local;
+    data = alloca0(priv->child_count);
+    metadata = alloca0(priv->child_count);
+
+    afr_read_txn_wipe(frame, this);
+
+    local->readfn = readfn;
+    local->inode = inode_ref(inode);
+    local->is_read_txn = _gf_true;
+    local->transaction.type = type;
+
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this)) {
+        local->op_ret = -1;
+        local->op_errno = afr_quorum_errno(priv);
+        goto read;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &local->op_errno)) {
+        local->op_ret = -1;
+        goto read;
+    }
+
+    if (priv->thin_arbiter_count &&
+        AFR_COUNT(local->child_up, priv->child_count) != priv->child_count) {
+        afr_ta_read_txn_synctask(frame, this);
+        return 0;
+    }
+
+    ret = afr_inode_read_subvol_get(inode, this, data, metadata,
+                                    &event_generation);
+    if (ret == -1)
+        /* very first transaction on this inode */
+        goto refresh;
+    AFR_INTERSECT(local->readable, data, metadata, priv->child_count);
+
+    gf_msg_debug(this->name, 0,
+                 "%s: generation now vs cached: %d, "
+                 "%d",
+                 uuid_utoa(inode->gfid), local->event_generation,
+                 event_generation);
+    if (afr_is_inode_refresh_reqd(inode, this, local->event_generation,
+                                  event_generation))
+        /* servers have disconnected / reconnected, and possibly
+           rebooted, very likely changing the state of freshness
+           of copies */
+        goto refresh;
+
+    read_subvol = afr_read_subvol_select_by_policy(inode, this, local->readable,
+                                                   NULL);
+
+    if (read_subvol < 0 || read_subvol > priv->child_count) {
+        gf_msg_debug(this->name, 0,
+                     "Unreadable subvolume %d found "
+                     "with event generation %d for gfid %s.",
+                     read_subvol, event_generation, uuid_utoa(inode->gfid));
+        goto refresh;
+    }
+
+    if (!local->child_up[read_subvol]) {
+        /* should never happen, just in case */
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_READ_SUBVOL_ERROR,
+               "subvolume %d is the "
+               "read subvolume in this generation, but is not up",
+               read_subvol);
+        goto refresh;
+    }
+
+    local->read_attempted[read_subvol] = 1;
 
 read:
-	afr_read_txn_wind (frame, this, read_subvol);
+    afr_read_txn_wind(frame, this, read_subvol);
 
-	return 0;
+    return 0;
 
 refresh:
-	afr_inode_refresh (frame, this, inode, NULL, afr_read_txn_refresh_done);
+    afr_inode_refresh(frame, this, inode, NULL, afr_read_txn_refresh_done);
 
-	return 0;
+    return 0;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-common.c b/xlators/cluster/afr/src/afr-self-heal-common.c
index be5dd327c9d..c48c47683c3 100644
--- a/xlators/cluster/afr/src/afr-self-heal-common.c
+++ b/xlators/cluster/afr/src/afr-self-heal-common.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "byte-order.h"
@@ -17,757 +16,767 @@
 #include "events.h"
 
 void
-afr_heal_synctask (xlator_t *this, afr_local_t *local);
+afr_heal_synctask(xlator_t *this, afr_local_t *local);
 
 int
-afr_lookup_and_heal_gfid (xlator_t *this, inode_t *parent, const char *name,
-                          inode_t *inode, struct afr_reply *replies,
-                          int source,  unsigned char *sources, void *gfid)
-{
-        afr_private_t *priv = NULL;
-        call_frame_t   *frame    = NULL;
-        afr_local_t *local = NULL;
-        unsigned char *wind_on = NULL;
-        ia_type_t ia_type = IA_INVAL;
-        dict_t *xdata = NULL;
-        loc_t loc = {0, };
-        int ret = 0;
-        int i = 0;
-
-        priv = this->private;
-        wind_on = alloca0 (priv->child_count);
-        ia_type = replies[source].poststat.ia_type;
-        if ((ia_type == IA_INVAL) &&
-            (AFR_COUNT(sources, priv->child_count) == priv->child_count)) {
-                /* If a file is present on some bricks of the replica but parent
-                 * dir does not have pending xattrs, all bricks are sources and
-                 * the 'source' we  selected earlier might be one where the file
-                 * is not actually present. Hence check if file is present in
-                 * any of the sources.*/
-                for (i = 0; i < priv->child_count; i++) {
-                        if (i == source)
-                                continue;
-                        if (sources[i] && replies[i].valid &&
-                            replies[i].op_ret == 0) {
-                                ia_type = replies[i].poststat.ia_type;
-                                break;
-                        }
-                }
-        }
-
-        /* gfid heal on those subvolumes that do not have gfid associated
-         * with the inode and update those replies.
-         */
+afr_lookup_and_heal_gfid(xlator_t *this, inode_t *parent, const char *name,
+                         inode_t *inode, struct afr_reply *replies, int source,
+                         unsigned char *sources, void *gfid)
+{
+    afr_private_t *priv = NULL;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    unsigned char *wind_on = NULL;
+    ia_type_t ia_type = IA_INVAL;
+    dict_t *xdata = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
+    int i = 0;
+
+    priv = this->private;
+    wind_on = alloca0(priv->child_count);
+    ia_type = replies[source].poststat.ia_type;
+    if ((ia_type == IA_INVAL) &&
+        (AFR_COUNT(sources, priv->child_count) == priv->child_count)) {
+        /* If a file is present on some bricks of the replica but parent
+         * dir does not have pending xattrs, all bricks are sources and
+         * the 'source' we  selected earlier might be one where the file
+         * is not actually present. Hence check if file is present in
+         * any of the sources.*/
         for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-                if (!gf_uuid_is_null (replies[i].poststat.ia_gfid) ||
-                    replies[i].poststat.ia_type != ia_type)
-                        continue;
-
-                wind_on[i] = 1;
+            if (i == source)
+                continue;
+            if (sources[i] && replies[i].valid && replies[i].op_ret == 0) {
+                ia_type = replies[i].poststat.ia_type;
+                break;
+            }
         }
+    }
 
-        if (AFR_COUNT(wind_on, priv->child_count) == 0)
-                return 0;
+    /* gfid heal on those subvolumes that do not have gfid associated
+     * with the inode and update those replies.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
+        if (!gf_uuid_is_null(replies[i].poststat.ia_gfid) ||
+            replies[i].poststat.ia_type != ia_type)
+            continue;
 
-        xdata = dict_new ();
-        if (!xdata) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = dict_set_gfuuid (xdata, "gfid-req", gfid, true);
-        if (ret) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        wind_on[i] = 1;
+    }
 
-        frame = afr_frame_create (this, &ret);
-        if (!frame) {
-                ret = -ret;
-                goto out;
-        }
+    if (AFR_COUNT(wind_on, priv->child_count) == 0)
+        return 0;
 
-        local = frame->local;
-        loc.parent = inode_ref (parent);
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.name = name;
-        loc.inode = inode_ref (inode);
+    xdata = dict_new();
+    if (!xdata) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        AFR_ONLIST (wind_on, frame, afr_selfheal_discover_cbk, lookup,
-                    &loc, xdata);
+    ret = dict_set_gfuuid(xdata, "gfid-req", gfid, true);
+    if (ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!wind_on[i])
-                        continue;
-                afr_reply_wipe (&replies[i]);
-                afr_reply_copy (&replies[i], &local->replies[i]);
-        }
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    local = frame->local;
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
+
+    AFR_ONLIST(wind_on, frame, afr_selfheal_discover_cbk, lookup, &loc, xdata);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!wind_on[i])
+            continue;
+        afr_reply_wipe(&replies[i]);
+        afr_reply_copy(&replies[i], &local->replies[i]);
+    }
 out:
-        loc_wipe (&loc);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        if (xdata)
-                dict_unref (xdata);
+    loc_wipe(&loc);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    if (xdata)
+        dict_unref(xdata);
 
-        return ret;
+    return ret;
 }
 
 int
-afr_gfid_sbrain_source_from_src_brick (xlator_t *this,
-                                       struct afr_reply *replies,
-                                       char *src_brick)
+afr_gfid_sbrain_source_from_src_brick(xlator_t *this, struct afr_reply *replies,
+                                      char *src_brick)
 {
-        int             i        = 0;
-        afr_private_t  *priv     = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (strcmp (priv->children[i]->name, src_brick) == 0)
-                        return i;
-        }
-        return -1;
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (strcmp(priv->children[i]->name, src_brick) == 0)
+            return i;
+    }
+    return -1;
 }
 
 int
-afr_selfheal_gfid_mismatch_by_majority (struct afr_reply *replies,
-                                        int child_count)
-{
-        int             j                  = 0;
-        int             i                  = 0;
-        int             src                = -1;
-        int             votes[child_count];
-
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-
-                votes[i] = 1;
-                for (j = i+1; j < child_count; j++) {
-                        if ((!gf_uuid_compare (replies[i].poststat.ia_gfid,
-                            replies[j].poststat.ia_gfid)))
-                                votes[i]++;
-                        if (votes[i] > child_count / 2) {
-                                src = i;
-                                goto out;
-                        }
-                }
+afr_selfheal_gfid_mismatch_by_majority(struct afr_reply *replies,
+                                       int child_count)
+{
+    int j = 0;
+    int i = 0;
+    int src = -1;
+    int votes[child_count];
+
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+
+        votes[i] = 1;
+        for (j = i + 1; j < child_count; j++) {
+            if ((!gf_uuid_compare(replies[i].poststat.ia_gfid,
+                                  replies[j].poststat.ia_gfid)))
+                votes[i]++;
+            if (votes[i] > child_count / 2) {
+                src = i;
+                goto out;
+            }
         }
+    }
 
 out:
-        return src;
+    return src;
 }
 
-int afr_gfid_sbrain_source_from_bigger_file (struct afr_reply *replies,
-                                             int child_count)
+int
+afr_gfid_sbrain_source_from_bigger_file(struct afr_reply *replies,
+                                        int child_count)
 {
-        int       i       = 0;
-        int       src     = -1;
-        uint64_t  size    = 0;
+    int i = 0;
+    int src = -1;
+    uint64_t size = 0;
 
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret == -1)
-                        continue;
-                if (size < replies[i].poststat.ia_size) {
-                        src = i;
-                        size = replies[i].poststat.ia_size;
-                } else if (replies[i].poststat.ia_size == size) {
-                        src = -1;
-                }
-        }
-        return src;
-}
-
-int afr_gfid_sbrain_source_from_latest_mtime (struct afr_reply *replies,
-                                              int child_count)
-{
-        int       i             = 0;
-        int       src           = -1;
-        uint32_t  mtime         = 0;
-        uint32_t  mtime_nsec    = 0;
-
-        for (i = 0; i < child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-                if ((mtime < replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
-                        src = i;
-                        mtime = replies[i].poststat.ia_mtime;
-                        mtime_nsec = replies[i].poststat.ia_mtime_nsec;
-                } else if ((mtime == replies[i].poststat.ia_mtime) &&
-                           (mtime_nsec == replies[i].poststat.ia_mtime_nsec)) {
-                        src = -1;
-                }
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret == -1)
+            continue;
+        if (size < replies[i].poststat.ia_size) {
+            src = i;
+            size = replies[i].poststat.ia_size;
+        } else if (replies[i].poststat.ia_size == size) {
+            src = -1;
         }
-        return src;
+    }
+    return src;
 }
 
 int
-afr_gfid_split_brain_source (xlator_t *this, struct afr_reply *replies,
-                             inode_t *inode, uuid_t pargfid, const char *bname,
-                             int src_idx, int child_idx,
-                             unsigned char *locked_on, int *src, dict_t *xdata)
-{
-        afr_private_t   *priv      = NULL;
-        char             g1[64]    = {0,};
-        char             g2[64]    = {0,};
-        int              up_count  = 0;
-        int              heal_op   = -1;
-        int              ret       = -1;
-        char            *src_brick = NULL;
-
-        *src = -1;
-        priv = this->private;
-        up_count = AFR_COUNT (locked_on, priv->child_count);
-        if (up_count != priv->child_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
-                        "All the bricks should be up to resolve the gfid split "
-                        "barin");
-                if (xdata) {
-                        ret = dict_set_str (xdata, "gfid-heal-msg", "All the "
-                                            "bricks should be up to resolve the"
-                                            " gfid split barin");
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_DICT_SET_FAILED, "Error setting"
-                                        " gfid-heal-msg dict");
-                }
-                goto out;
+afr_gfid_sbrain_source_from_latest_mtime(struct afr_reply *replies,
+                                         int child_count)
+{
+    int i = 0;
+    int src = -1;
+    uint32_t mtime = 0;
+    uint32_t mtime_nsec = 0;
+
+    for (i = 0; i < child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
+        if ((mtime < replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
+            src = i;
+            mtime = replies[i].poststat.ia_mtime;
+            mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+        } else if ((mtime == replies[i].poststat.ia_mtime) &&
+                   (mtime_nsec == replies[i].poststat.ia_mtime_nsec)) {
+            src = -1;
         }
+    }
+    return src;
+}
 
+int
+afr_gfid_split_brain_source(xlator_t *this, struct afr_reply *replies,
+                            inode_t *inode, uuid_t pargfid, const char *bname,
+                            int src_idx, int child_idx,
+                            unsigned char *locked_on, int *src, dict_t *xdata)
+{
+    afr_private_t *priv = NULL;
+    char g1[64] = {
+        0,
+    };
+    char g2[64] = {
+        0,
+    };
+    int up_count = 0;
+    int heal_op = -1;
+    int ret = -1;
+    char *src_brick = NULL;
+
+    *src = -1;
+    priv = this->private;
+    up_count = AFR_COUNT(locked_on, priv->child_count);
+    if (up_count != priv->child_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+               "All the bricks should be up to resolve the gfid split "
+               "barin");
         if (xdata) {
-                ret = dict_get_int32 (xdata, "heal-op", &heal_op);
-                if (ret)
-                        goto fav_child;
-        } else {
-                goto fav_child;
+            ret = dict_set_str(xdata, "gfid-heal-msg",
+                               "All the "
+                               "bricks should be up to resolve the"
+                               " gfid split barin");
+            if (ret)
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                       "Error setting"
+                       " gfid-heal-msg dict");
         }
+        goto out;
+    }
 
-        switch (heal_op) {
+    if (xdata) {
+        ret = dict_get_int32(xdata, "heal-op", &heal_op);
+        if (ret)
+            goto fav_child;
+    } else {
+        goto fav_child;
+    }
+
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                *src = afr_gfid_sbrain_source_from_bigger_file (replies,
-                                                                priv->child_count);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No bigger file");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "No bigger file");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                " setting gfid-heal-msg dict");
-                        }
+            *src = afr_gfid_sbrain_source_from_bigger_file(replies,
+                                                           priv->child_count);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "No bigger file");
+                if (xdata) {
+                    ret = dict_set_str(xdata, "gfid-heal-msg",
+                                       "No bigger file");
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               " setting gfid-heal-msg dict");
                 }
-                break;
+            }
+            break;
 
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                *src = afr_gfid_sbrain_source_from_latest_mtime (replies,
-                                                                 priv->child_count);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No difference in mtime");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "No difference in mtime");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                "setting gfid-heal-msg dict");
-                        }
+            *src = afr_gfid_sbrain_source_from_latest_mtime(replies,
+                                                            priv->child_count);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "No difference in mtime");
+                if (xdata) {
+                    ret = dict_set_str(xdata, "gfid-heal-msg",
+                                       "No difference in mtime");
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               "setting gfid-heal-msg dict");
                 }
-                break;
+            }
+            break;
 
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (xdata, "child-name", &src_brick);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Error getting the source "
-                                "brick");
-                        break;
-                }
-                *src = afr_gfid_sbrain_source_from_src_brick (this, replies,
-                                                              src_brick);
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Error getting the source "
-                                "brick");
-                        if (xdata) {
-                                ret = dict_set_str (xdata, "gfid-heal-msg",
-                                                    "Error getting the source "
-                                                    "brick");
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                AFR_MSG_DICT_SET_FAILED, "Error"
-                                                " setting gfid-heal-msg dict");
-                        }
-                }
+            ret = dict_get_str(xdata, "child-name", &src_brick);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Error getting the source "
+                       "brick");
                 break;
+            }
+            *src = afr_gfid_sbrain_source_from_src_brick(this, replies,
+                                                         src_brick);
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Error getting the source "
+                       "brick");
+                if (xdata) {
+                    ret = dict_set_str(xdata, "gfid-heal-msg",
+                                       "Error getting the source "
+                                       "brick");
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error"
+                               " setting gfid-heal-msg dict");
+                }
+            }
+            break;
 
         default:
-                break;
-        }
-        goto out;
+            break;
+    }
+    goto out;
 
 fav_child:
-        switch (priv->fav_child_policy) {
+    switch (priv->fav_child_policy) {
         case AFR_FAV_CHILD_BY_SIZE:
-                *src = afr_sh_fav_by_size (this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_size(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_MTIME:
-                *src = afr_sh_fav_by_mtime (this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_mtime(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_CTIME:
-                *src = afr_sh_fav_by_ctime(this, replies, inode);
-                break;
+            *src = afr_sh_fav_by_ctime(this, replies, inode);
+            break;
         case AFR_FAV_CHILD_BY_MAJORITY:
-                if (priv->child_count != 2)
-                        *src = afr_selfheal_gfid_mismatch_by_majority (replies,
-                                                                       priv->child_count);
-                else
-                        *src = -1;
-
-                if (*src == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "No majority to resolve "
-                                "gfid split brain");
-                }
-                break;
+            if (priv->child_count != 2)
+                *src = afr_selfheal_gfid_mismatch_by_majority(
+                    replies, priv->child_count);
+            else
+                *src = -1;
+
+            if (*src == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "No majority to resolve "
+                       "gfid split brain");
+            }
+            break;
         default:
-                break;
-        }
+            break;
+    }
 
 out:
-        if (*src == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
-                        "Gfid mismatch detected for <gfid:%s>/%s>, %s on %s and"
-                        " %s on %s.", uuid_utoa (pargfid), bname,
-                        uuid_utoa_r (replies[child_idx].poststat.ia_gfid, g1),
-                        priv->children[child_idx]->name,
-                        uuid_utoa_r (replies[src_idx].poststat.ia_gfid, g2),
-                        priv->children[src_idx]->name);
-                gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=gfid;file="
-                          "<gfid:%s>/%s>;count=2;child-%d=%s;gfid-%d=%s;"
-                          "child-%d=%s;gfid-%d=%s", this->name,
-                          uuid_utoa (pargfid), bname, child_idx,
-                          priv->children[child_idx]->name, child_idx,
-                          uuid_utoa_r (replies[child_idx].poststat.ia_gfid, g1),
-                          src_idx, priv->children[src_idx]->name, src_idx,
-                          uuid_utoa_r (replies[src_idx].poststat.ia_gfid, g2));
-                return -1;
-        }
-        return 0;
+    if (*src == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+               "Gfid mismatch detected for <gfid:%s>/%s>, %s on %s and"
+               " %s on %s.",
+               uuid_utoa(pargfid), bname,
+               uuid_utoa_r(replies[child_idx].poststat.ia_gfid, g1),
+               priv->children[child_idx]->name,
+               uuid_utoa_r(replies[src_idx].poststat.ia_gfid, g2),
+               priv->children[src_idx]->name);
+        gf_event(EVENT_AFR_SPLIT_BRAIN,
+                 "subvol=%s;type=gfid;file="
+                 "<gfid:%s>/%s>;count=2;child-%d=%s;gfid-%d=%s;"
+                 "child-%d=%s;gfid-%d=%s",
+                 this->name, uuid_utoa(pargfid), bname, child_idx,
+                 priv->children[child_idx]->name, child_idx,
+                 uuid_utoa_r(replies[child_idx].poststat.ia_gfid, g1), src_idx,
+                 priv->children[src_idx]->name, src_idx,
+                 uuid_utoa_r(replies[src_idx].poststat.ia_gfid, g2));
+        return -1;
+    }
+    return 0;
 }
 
-
 int
-afr_selfheal_post_op_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			  int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+afr_selfheal_post_op_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-	local = frame->local;
+    local = frame->local;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
-	syncbarrier_wake (&local->barrier);
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    syncbarrier_wake(&local->barrier);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_post_op (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      int subvol, dict_t *xattr, dict_t *xdata)
+afr_selfheal_post_op(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     int subvol, dict_t *xattr, dict_t *xdata)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	loc_t loc = {0, };
-        int ret = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-	STACK_WIND (frame, afr_selfheal_post_op_cbk, priv->children[subvol],
-		    priv->children[subvol]->fops->xattrop, &loc,
-		    GF_XATTROP_ADD_ARRAY, xattr, xdata);
+    STACK_WIND(frame, afr_selfheal_post_op_cbk, priv->children[subvol],
+               priv->children[subvol]->fops->xattrop, &loc,
+               GF_XATTROP_ADD_ARRAY, xattr, xdata);
 
-	syncbarrier_wait (&local->barrier, 1);
-        if (local->op_ret < 0)
-                ret = -local->op_errno;
+    syncbarrier_wait(&local->barrier, 1);
+    if (local->op_ret < 0)
+        ret = -local->op_errno;
 
-        loc_wipe (&loc);
-        local->op_ret = 0;
+    loc_wipe(&loc);
+    local->op_ret = 0;
 
-	return ret;
+    return ret;
 }
 
 int
-afr_check_stale_error (struct afr_reply *replies, afr_private_t *priv)
+afr_check_stale_error(struct afr_reply *replies, afr_private_t *priv)
 {
-        int i = 0;
-        int op_errno = 0;
-        int tmp_errno = 0;
-        int stale_count = 0;
+    int i = 0;
+    int op_errno = 0;
+    int tmp_errno = 0;
+    int stale_count = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                tmp_errno = replies[i].op_errno;
-                if (tmp_errno == ENOENT || tmp_errno == ESTALE) {
-                        op_errno = afr_higher_errno (op_errno, tmp_errno);
-                        stale_count++;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        tmp_errno = replies[i].op_errno;
+        if (tmp_errno == ENOENT || tmp_errno == ESTALE) {
+            op_errno = afr_higher_errno(op_errno, tmp_errno);
+            stale_count++;
         }
-        if (stale_count != priv->child_count)
-                return -ENOTCONN;
-        else
-                return -op_errno;
+    }
+    if (stale_count != priv->child_count)
+        return -ENOTCONN;
+    else
+        return -op_errno;
 }
 
 int
-afr_sh_generic_fop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-          int op_ret, int op_errno, struct iatt *pre, struct iatt *post,
-          dict_t *xdata)
+afr_sh_generic_fop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, struct iatt *pre,
+                       struct iatt *post, dict_t *xdata)
 {
-        int i = (long) cookie;
-        afr_local_t *local = NULL;
+    int i = (long)cookie;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->replies[i].valid = 1;
-        local->replies[i].op_ret = op_ret;
-        local->replies[i].op_errno = op_errno;
-        if (pre)
-                local->replies[i].prestat = *pre;
-        if (post)
-                local->replies[i].poststat = *post;
-        if (xdata)
-                local->replies[i].xdata = dict_ref (xdata);
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (pre)
+        local->replies[i].prestat = *pre;
+    if (post)
+        local->replies[i].poststat = *post;
+    if (xdata)
+        local->replies[i].xdata = dict_ref(xdata);
 
-        syncbarrier_wake (&local->barrier);
+    syncbarrier_wake(&local->barrier);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_selfheal_restore_time (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                           int source, unsigned char *healed_sinks,
-                           struct afr_reply *replies)
+afr_selfheal_restore_time(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          int source, unsigned char *healed_sinks,
+                          struct afr_reply *replies)
 {
-        loc_t loc = {0, };
+    loc_t loc = {
+        0,
+    };
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-        AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, setattr, &loc,
-                    &replies[source].poststat,
-                    (GF_SET_ATTR_ATIME|GF_SET_ATTR_MTIME), NULL);
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, setattr, &loc,
+               &replies[source].poststat,
+               (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME), NULL);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return 0;
+    return 0;
 }
 
 dict_t *
-afr_selfheal_output_xattr (xlator_t *this, gf_boolean_t is_full_crawl,
-                           afr_transaction_type type, int *output_dirty,
-                           int **output_matrix, int subvol,
-                           int **full_heal_mtx_out)
-{
-	int                j     = 0;
-	int                idx   = 0;
-	int                d_idx = 0;
-	int                ret   = 0;
-	int               *raw   = 0;
-	dict_t            *xattr = NULL;
-	afr_private_t     *priv  = NULL;
-
-	priv = this->private;
-	idx = afr_index_for_transaction_type (type);
-        d_idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
-
-	xattr = dict_new ();
-	if (!xattr)
-		return NULL;
-
-	/* clear dirty */
-	raw = GF_CALLOC (sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
-	if (!raw)
-		goto err;
-
-	raw[idx] = hton32 (output_dirty[subvol]);
-	ret = dict_set_bin (xattr, AFR_DIRTY, raw,
-			    sizeof(int) * AFR_NUM_CHANGE_LOGS);
-	if (ret) {
-                GF_FREE (raw);
-		goto err;
-        }
+afr_selfheal_output_xattr(xlator_t *this, gf_boolean_t is_full_crawl,
+                          afr_transaction_type type, int *output_dirty,
+                          int **output_matrix, int subvol,
+                          int **full_heal_mtx_out)
+{
+    int j = 0;
+    int idx = 0;
+    int d_idx = 0;
+    int ret = 0;
+    int *raw = 0;
+    dict_t *xattr = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    idx = afr_index_for_transaction_type(type);
+    d_idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
+
+    xattr = dict_new();
+    if (!xattr)
+        return NULL;
 
-	/* clear/set pending */
-	for (j = 0; j < priv->child_count; j++) {
-		raw = GF_CALLOC (sizeof(int), AFR_NUM_CHANGE_LOGS,
-				 gf_afr_mt_int32_t);
-		if (!raw)
-			goto err;
-
-		raw[idx] = hton32 (output_matrix[subvol][j]);
-                if (is_full_crawl)
-                        raw[d_idx] = hton32 (full_heal_mtx_out[subvol][j]);
-
-		ret = dict_set_bin (xattr, priv->pending_key[j],
-				    raw, sizeof(int) * AFR_NUM_CHANGE_LOGS);
-		if (ret) {
-                        GF_FREE (raw);
-			goto err;
-                }
-	}
+    /* clear dirty */
+    raw = GF_CALLOC(sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
+    if (!raw)
+        goto err;
+
+    raw[idx] = hton32(output_dirty[subvol]);
+    ret = dict_set_bin(xattr, AFR_DIRTY, raw,
+                       sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret) {
+        GF_FREE(raw);
+        goto err;
+    }
+
+    /* clear/set pending */
+    for (j = 0; j < priv->child_count; j++) {
+        raw = GF_CALLOC(sizeof(int), AFR_NUM_CHANGE_LOGS, gf_afr_mt_int32_t);
+        if (!raw)
+            goto err;
+
+        raw[idx] = hton32(output_matrix[subvol][j]);
+        if (is_full_crawl)
+            raw[d_idx] = hton32(full_heal_mtx_out[subvol][j]);
+
+        ret = dict_set_bin(xattr, priv->pending_key[j], raw,
+                           sizeof(int) * AFR_NUM_CHANGE_LOGS);
+        if (ret) {
+            GF_FREE(raw);
+            goto err;
+        }
+    }
 
-	return xattr;
+    return xattr;
 err:
-	if (xattr)
-		dict_unref (xattr);
-	return NULL;
+    if (xattr)
+        dict_unref(xattr);
+    return NULL;
 }
 
-
 int
-afr_selfheal_undo_pending (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			   unsigned char *sources, unsigned char *sinks,
-			   unsigned char *healed_sinks,
-                           unsigned char *undid_pending,
-                           afr_transaction_type type, struct afr_reply *replies,
-                           unsigned char *locked_on)
-{
-	afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-	int i = 0;
-	int j = 0;
-	unsigned char *pending = NULL;
-	int *input_dirty = NULL;
-	int **input_matrix = NULL;
-	int **full_heal_mtx_in = NULL;
-	int **full_heal_mtx_out = NULL;
-	int *output_dirty = NULL;
-	int **output_matrix = NULL;
-	dict_t *xattr = NULL;
-	dict_t *xdata = NULL;
-
-	priv = this->private;
-        local = frame->local;
-
-	pending = alloca0 (priv->child_count);
-
-	input_dirty = alloca0 (priv->child_count * sizeof (int));
-	input_matrix = ALLOC_MATRIX (priv->child_count, int);
-	full_heal_mtx_in = ALLOC_MATRIX (priv->child_count, int);
-	full_heal_mtx_out = ALLOC_MATRIX (priv->child_count, int);
-	output_dirty = alloca0 (priv->child_count * sizeof (int));
-	output_matrix = ALLOC_MATRIX (priv->child_count, int);
-
-        xdata = dict_new ();
-        if (!xdata)
-                return -1;
+afr_selfheal_undo_pending(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                          unsigned char *sources, unsigned char *sinks,
+                          unsigned char *healed_sinks,
+                          unsigned char *undid_pending,
+                          afr_transaction_type type, struct afr_reply *replies,
+                          unsigned char *locked_on)
+{
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int j = 0;
+    unsigned char *pending = NULL;
+    int *input_dirty = NULL;
+    int **input_matrix = NULL;
+    int **full_heal_mtx_in = NULL;
+    int **full_heal_mtx_out = NULL;
+    int *output_dirty = NULL;
+    int **output_matrix = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    pending = alloca0(priv->child_count);
+
+    input_dirty = alloca0(priv->child_count * sizeof(int));
+    input_matrix = ALLOC_MATRIX(priv->child_count, int);
+    full_heal_mtx_in = ALLOC_MATRIX(priv->child_count, int);
+    full_heal_mtx_out = ALLOC_MATRIX(priv->child_count, int);
+    output_dirty = alloca0(priv->child_count * sizeof(int));
+    output_matrix = ALLOC_MATRIX(priv->child_count, int);
+
+    xdata = dict_new();
+    if (!xdata)
+        return -1;
 
-	afr_selfheal_extract_xattr (this, replies, type, input_dirty,
-				    input_matrix);
-
-        if (local->need_full_crawl)
-                afr_selfheal_extract_xattr (this, replies, AFR_DATA_TRANSACTION,
-                                            NULL, full_heal_mtx_in);
-
-	for (i = 0; i < priv->child_count; i++)
-		if (sinks[i] && !healed_sinks[i])
-			pending[i] = 1;
-
-	for (i = 0; i < priv->child_count; i++) {
-		for (j = 0; j < priv->child_count; j++) {
-			if (pending[j]) {
-				output_matrix[i][j] = 1;
-                                if (type == AFR_ENTRY_TRANSACTION)
-                                        full_heal_mtx_out[i][j] = 1;
-			} else if (locked_on[j]) {
-				output_matrix[i][j] = -input_matrix[i][j];
-                                if (type == AFR_ENTRY_TRANSACTION)
-                                        full_heal_mtx_out[i][j] = -full_heal_mtx_in[i][j];
-                        }
-		}
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!pending[i])
-			output_dirty[i] = -input_dirty[i];
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!locked_on[i])
-			/* perform post-op only on subvols we had locked
-			   and inspected on.
-			*/
-			continue;
-                if (undid_pending[i])
-                        /* We already unset the pending xattrs in
-                         * _afr_fav_child_reset_sink_xattrs(). */
-                        continue;
-
-		xattr = afr_selfheal_output_xattr (this, local->need_full_crawl,
-                                                   type, output_dirty,
-                                                   output_matrix, i,
-                                                   full_heal_mtx_out);
-		if (!xattr) {
-			continue;
-		}
-
-                if ((type == AFR_ENTRY_TRANSACTION) && (priv->esh_granular)) {
-                        if (xdata &&
-                            dict_set_int8 (xdata, GF_XATTROP_PURGE_INDEX, 1))
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        AFR_MSG_DICT_SET_FAILED, "Failed to set"
-                                        " dict value for %s",
-                                        GF_XATTROP_PURGE_INDEX);
-                }
+    afr_selfheal_extract_xattr(this, replies, type, input_dirty, input_matrix);
+
+    if (local->need_full_crawl)
+        afr_selfheal_extract_xattr(this, replies, AFR_DATA_TRANSACTION, NULL,
+                                   full_heal_mtx_in);
 
-		afr_selfheal_post_op (frame, this, inode, i, xattr, xdata);
-		dict_unref (xattr);
-	}
+    for (i = 0; i < priv->child_count; i++)
+        if (sinks[i] && !healed_sinks[i])
+            pending[i] = 1;
+
+    for (i = 0; i < priv->child_count; i++) {
+        for (j = 0; j < priv->child_count; j++) {
+            if (pending[j]) {
+                output_matrix[i][j] = 1;
+                if (type == AFR_ENTRY_TRANSACTION)
+                    full_heal_mtx_out[i][j] = 1;
+            } else if (locked_on[j]) {
+                output_matrix[i][j] = -input_matrix[i][j];
+                if (type == AFR_ENTRY_TRANSACTION)
+                    full_heal_mtx_out[i][j] = -full_heal_mtx_in[i][j];
+            }
+        }
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!pending[i])
+            output_dirty[i] = -input_dirty[i];
+    }
 
-	return 0;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!locked_on[i])
+            /* perform post-op only on subvols we had locked
+               and inspected on.
+            */
+            continue;
+        if (undid_pending[i])
+            /* We already unset the pending xattrs in
+             * _afr_fav_child_reset_sink_xattrs(). */
+            continue;
+
+        xattr = afr_selfheal_output_xattr(this, local->need_full_crawl, type,
+                                          output_dirty, output_matrix, i,
+                                          full_heal_mtx_out);
+        if (!xattr) {
+            continue;
+        }
+
+        if ((type == AFR_ENTRY_TRANSACTION) && (priv->esh_granular)) {
+            if (xdata && dict_set_int8(xdata, GF_XATTROP_PURGE_INDEX, 1))
+                gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_DICT_SET_FAILED,
+                       "Failed to set"
+                       " dict value for %s",
+                       GF_XATTROP_PURGE_INDEX);
+        }
+
+        afr_selfheal_post_op(frame, this, inode, i, xattr, xdata);
+        dict_unref(xattr);
+    }
+
+    if (xdata)
+        dict_unref(xdata);
+
+    return 0;
 }
 
 void
-afr_reply_copy (struct afr_reply *dst, struct afr_reply *src)
-{
-	dict_t *xdata = NULL;
-
-        dst->valid = src->valid;
-	dst->op_ret = src->op_ret;
-	dst->op_errno = src->op_errno;
-	dst->prestat = src->prestat;
-	dst->poststat = src->poststat;
-	dst->preparent = src->preparent;
-	dst->postparent = src->postparent;
-	dst->preparent2 = src->preparent2;
-	dst->postparent2 = src->postparent2;
-	if (src->xdata)
-		xdata = dict_ref (src->xdata);
-	else
-		xdata = NULL;
-	if (dst->xdata)
-		dict_unref (dst->xdata);
-	dst->xdata = xdata;
-        if (xdata && dict_get_str_boolean (xdata, "fips-mode-rchecksum",
-            _gf_false) == _gf_true) {
-                memcpy (dst->checksum, src->checksum, SHA256_DIGEST_LENGTH);
-        } else {
-                memcpy (dst->checksum, src->checksum, MD5_DIGEST_LENGTH);
-        }
-        dst->fips_mode_rchecksum = src->fips_mode_rchecksum;
+afr_reply_copy(struct afr_reply *dst, struct afr_reply *src)
+{
+    dict_t *xdata = NULL;
+
+    dst->valid = src->valid;
+    dst->op_ret = src->op_ret;
+    dst->op_errno = src->op_errno;
+    dst->prestat = src->prestat;
+    dst->poststat = src->poststat;
+    dst->preparent = src->preparent;
+    dst->postparent = src->postparent;
+    dst->preparent2 = src->preparent2;
+    dst->postparent2 = src->postparent2;
+    if (src->xdata)
+        xdata = dict_ref(src->xdata);
+    else
+        xdata = NULL;
+    if (dst->xdata)
+        dict_unref(dst->xdata);
+    dst->xdata = xdata;
+    if (xdata && dict_get_str_boolean(xdata, "fips-mode-rchecksum",
+                                      _gf_false) == _gf_true) {
+        memcpy(dst->checksum, src->checksum, SHA256_DIGEST_LENGTH);
+    } else {
+        memcpy(dst->checksum, src->checksum, MD5_DIGEST_LENGTH);
+    }
+    dst->fips_mode_rchecksum = src->fips_mode_rchecksum;
 }
 
 void
-afr_replies_copy (struct afr_reply *dst, struct afr_reply *src, int count)
+afr_replies_copy(struct afr_reply *dst, struct afr_reply *src, int count)
 {
-	int i = 0;
+    int i = 0;
 
-	if (dst == src)
-		return;
+    if (dst == src)
+        return;
 
-	for (i = 0; i < count; i++) {
-                afr_reply_copy (&dst[i], &src[i]);
-	}
+    for (i = 0; i < count; i++) {
+        afr_reply_copy(&dst[i], &src[i]);
+    }
 }
 
 int
-afr_selfheal_fill_dirty (xlator_t *this, int *dirty, int subvol,
-			 int idx, dict_t *xdata)
+afr_selfheal_fill_dirty(xlator_t *this, int *dirty, int subvol, int idx,
+                        dict_t *xdata)
 {
-	void *pending_raw = NULL;
-	int pending[3] = {0, };
+    void *pending_raw = NULL;
+    int pending[3] = {
+        0,
+    };
 
-        if (!dirty)
-                return 0;
+    if (!dirty)
+        return 0;
 
-	if (dict_get_ptr (xdata, AFR_DIRTY, &pending_raw))
-		return -1;
+    if (dict_get_ptr(xdata, AFR_DIRTY, &pending_raw))
+        return -1;
 
-	if (!pending_raw)
-		return -1;
+    if (!pending_raw)
+        return -1;
 
-	memcpy (pending, pending_raw, sizeof(pending));
+    memcpy(pending, pending_raw, sizeof(pending));
 
-	dirty[subvol] = ntoh32 (pending[idx]);
+    dirty[subvol] = ntoh32(pending[idx]);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_fill_matrix (xlator_t *this, int **matrix, int subvol,
-			  int idx, dict_t *xdata)
+afr_selfheal_fill_matrix(xlator_t *this, int **matrix, int subvol, int idx,
+                         dict_t *xdata)
 {
-	int i = 0;
-	void *pending_raw = NULL;
-	int pending[3] = {0, };
-	afr_private_t *priv = NULL;
+    int i = 0;
+    void *pending_raw = NULL;
+    int pending[3] = {
+        0,
+    };
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-        if (!matrix)
-                return 0;
+    if (!matrix)
+        return 0;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (dict_get_ptr (xdata, priv->pending_key[i], &pending_raw))
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
 
-		if (!pending_raw)
-			continue;
+        if (!pending_raw)
+            continue;
 
-		memcpy (pending, pending_raw, sizeof(pending));
+        memcpy(pending, pending_raw, sizeof(pending));
 
-		matrix[subvol][i] = ntoh32 (pending[idx]);
-	}
+        matrix[subvol][i] = ntoh32(pending[idx]);
+    }
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_extract_xattr (xlator_t *this, struct afr_reply *replies,
-			    afr_transaction_type type, int *dirty, int **matrix)
+afr_selfheal_extract_xattr(xlator_t *this, struct afr_reply *replies,
+                           afr_transaction_type type, int *dirty, int **matrix)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	dict_t *xdata = NULL;
-	int idx = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    dict_t *xdata = NULL;
+    int idx = -1;
 
-	idx = afr_index_for_transaction_type (type);
+    idx = afr_index_for_transaction_type(type);
 
-	priv = this->private;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-		if (!replies[i].xdata)
-			continue;
+        if (!replies[i].xdata)
+            continue;
 
-		xdata = replies[i].xdata;
+        xdata = replies[i].xdata;
 
-		afr_selfheal_fill_dirty (this, dirty, i, idx, xdata);
-		afr_selfheal_fill_matrix (this, matrix, i, idx, xdata);
-	}
+        afr_selfheal_fill_dirty(this, dirty, i, idx, xdata);
+        afr_selfheal_fill_matrix(this, matrix, i, idx, xdata);
+    }
 
-	return 0;
+    return 0;
 }
 
 /*
@@ -777,573 +786,547 @@ afr_selfheal_extract_xattr (xlator_t *this, struct afr_reply *replies,
  * This can happen if data was directly modified in the backend or for snapshots
  */
 void
-afr_mark_largest_file_as_source (xlator_t *this, unsigned char *sources,
-                                 struct afr_reply *replies)
+afr_mark_largest_file_as_source(xlator_t *this, unsigned char *sources,
+                                struct afr_reply *replies)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint64_t size = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t size = 0;
 
-        /* Find source with biggest file size */
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (!replies[i].valid || replies[i].op_ret != 0) {
-                        sources[i] = 0;
-                        continue;
-                }
-                if (size <= replies[i].poststat.ia_size) {
-                        size = replies[i].poststat.ia_size;
-                }
+    /* Find source with biggest file size */
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (!replies[i].valid || replies[i].op_ret != 0) {
+            sources[i] = 0;
+            continue;
         }
-
-        /* Mark sources with less size as not source */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (size > replies[i].poststat.ia_size)
-                        sources[i] = 0;
+        if (size <= replies[i].poststat.ia_size) {
+            size = replies[i].poststat.ia_size;
         }
+    }
+
+    /* Mark sources with less size as not source */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (size > replies[i].poststat.ia_size)
+            sources[i] = 0;
+    }
 }
 
 void
-afr_mark_latest_mtime_file_as_source (xlator_t *this, unsigned char *sources,
-                                 struct afr_reply *replies)
-{
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint32_t mtime = 0;
-        uint32_t mtime_nsec = 0;
-
-        priv = this->private;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (!replies[i].valid || replies[i].op_ret != 0) {
-                        sources[i] = 0;
-                        continue;
-                }
-                if ((mtime < replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
-                        mtime = replies[i].poststat.ia_mtime;
-                        mtime_nsec = replies[i].poststat.ia_mtime_nsec;
-                }
-        }
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if ((mtime > replies[i].poststat.ia_mtime) ||
-                    ((mtime == replies[i].poststat.ia_mtime) &&
-                     (mtime_nsec > replies[i].poststat.ia_mtime_nsec))) {
-                        sources[i] = 0;
-                }
-        }
+afr_mark_latest_mtime_file_as_source(xlator_t *this, unsigned char *sources,
+                                     struct afr_reply *replies)
+{
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint32_t mtime = 0;
+    uint32_t mtime_nsec = 0;
+
+    priv = this->private;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (!replies[i].valid || replies[i].op_ret != 0) {
+            sources[i] = 0;
+            continue;
+        }
+        if ((mtime < replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec < replies[i].poststat.ia_mtime_nsec))) {
+            mtime = replies[i].poststat.ia_mtime;
+            mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+        }
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if ((mtime > replies[i].poststat.ia_mtime) ||
+            ((mtime == replies[i].poststat.ia_mtime) &&
+             (mtime_nsec > replies[i].poststat.ia_mtime_nsec))) {
+            sources[i] = 0;
+        }
+    }
 }
 
 void
-afr_mark_active_sinks (xlator_t *this, unsigned char *sources,
-                       unsigned char *locked_on, unsigned char *sinks)
+afr_mark_active_sinks(xlator_t *this, unsigned char *sources,
+                      unsigned char *locked_on, unsigned char *sinks)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i] && locked_on[i])
-                        sinks[i] = 1;
-                else
-                        sinks[i] = 0;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] && locked_on[i])
+            sinks[i] = 1;
+        else
+            sinks[i] = 0;
+    }
 }
 
 gf_boolean_t
-afr_dict_contains_heal_op (call_frame_t *frame)
+afr_dict_contains_heal_op(call_frame_t *frame)
 {
-        afr_local_t   *local     = NULL;
-        dict_t        *xdata_req = NULL;
-        int            ret       = 0;
-        int            heal_op   = -1;
+    afr_local_t *local = NULL;
+    dict_t *xdata_req = NULL;
+    int ret = 0;
+    int heal_op = -1;
 
-        local = frame->local;
-        xdata_req = local->xdata_req;
-        ret = dict_get_int32 (xdata_req, "heal-op", &heal_op);
-        if (ret)
-                return _gf_false;
-        if (local->xdata_rsp == NULL) {
-                local->xdata_rsp = dict_new();
-                if (!local->xdata_rsp)
-                        return _gf_true;
-        }
-        ret = dict_set_str (local->xdata_rsp, "sh-fail-msg",
-                            "File not in split-brain");
+    local = frame->local;
+    xdata_req = local->xdata_req;
+    ret = dict_get_int32(xdata_req, "heal-op", &heal_op);
+    if (ret)
+        return _gf_false;
+    if (local->xdata_rsp == NULL) {
+        local->xdata_rsp = dict_new();
+        if (!local->xdata_rsp)
+            return _gf_true;
+    }
+    ret = dict_set_str(local->xdata_rsp, "sh-fail-msg",
+                       "File not in split-brain");
 
-        return _gf_true;
+    return _gf_true;
 }
 
 gf_boolean_t
-afr_can_decide_split_brain_source_sinks (struct afr_reply *replies,
-                                         int child_count)
+afr_can_decide_split_brain_source_sinks(struct afr_reply *replies,
+                                        int child_count)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < child_count; i++)
-                if (replies[i].valid != 1 || replies[i].op_ret != 0)
-                        return _gf_false;
+    for (i = 0; i < child_count; i++)
+        if (replies[i].valid != 1 || replies[i].op_ret != 0)
+            return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-afr_mark_split_brain_source_sinks_by_heal_op (call_frame_t *frame,
-                                   xlator_t *this, unsigned char *sources,
-                                   unsigned char *sinks,
-                                   unsigned char *healed_sinks,
-                                   unsigned char *locked_on,
-                                   struct afr_reply *replies,
-                                   afr_transaction_type type, int heal_op)
-{
-        afr_local_t   *local     = NULL;
-        afr_private_t *priv      = NULL;
-        dict_t        *xdata_req = NULL;
-        dict_t        *xdata_rsp = NULL;
-        int            ret       = 0;
-        int            i         = 0;
-        char          *name      = NULL;
-        int            source     = -1;
-
-        local = frame->local;
-        priv = this->private;
-        xdata_req = local->xdata_req;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (locked_on[i])
-                        if (sources[i] || !sinks[i] || !healed_sinks[i]) {
-                                ret = -1;
-                                goto out;
-                        }
-        }
-        if (local->xdata_rsp == NULL) {
-                local->xdata_rsp = dict_new();
-                if (!local->xdata_rsp) {
-                        ret = -1;
-                        goto out;
-                }
-        }
-        xdata_rsp = local->xdata_rsp;
-
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                    SBRAIN_HEAL_NO_GO_MSG);
+afr_mark_split_brain_source_sinks_by_heal_op(
+    call_frame_t *frame, xlator_t *this, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type, int heal_op)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata_req = NULL;
+    dict_t *xdata_rsp = NULL;
+    int ret = 0;
+    int i = 0;
+    char *name = NULL;
+    int source = -1;
+
+    local = frame->local;
+    priv = this->private;
+    xdata_req = local->xdata_req;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (locked_on[i])
+            if (sources[i] || !sinks[i] || !healed_sinks[i]) {
                 ret = -1;
                 goto out;
-        }
+            }
+    }
+    if (local->xdata_rsp == NULL) {
+        local->xdata_rsp = dict_new();
+        if (!local->xdata_rsp) {
+            ret = -1;
+            goto out;
+        }
+    }
+    xdata_rsp = local->xdata_rsp;
+
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        ret = dict_set_str(xdata_rsp, "sh-fail-msg", SBRAIN_HEAL_NO_GO_MSG);
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0 ; i < priv->child_count; i++)
-                if (locked_on[i])
-                        sources[i] = 1;
-        switch (heal_op) {
+    for (i = 0; i < priv->child_count; i++)
+        if (locked_on[i])
+            sources[i] = 1;
+    switch (heal_op) {
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BIGGER_FILE:
-                if (type == AFR_METADATA_TRANSACTION) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Use source-brick option to"
-                                            " heal metadata split-brain");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                afr_mark_largest_file_as_source (this, sources, replies);
-                if (AFR_COUNT (sources, priv->child_count) != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "No bigger file");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                break;
+            if (type == AFR_METADATA_TRANSACTION) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg",
+                                   "Use source-brick option to"
+                                   " heal metadata split-brain");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            afr_mark_largest_file_as_source(this, sources, replies);
+            if (AFR_COUNT(sources, priv->child_count) != 1) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg", "No bigger file");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_LATEST_MTIME:
-                if (type == AFR_METADATA_TRANSACTION) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Use source-brick option to"
-                                            " heal metadata split-brain");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                afr_mark_latest_mtime_file_as_source (this, sources, replies);
-                if (AFR_COUNT (sources, priv->child_count) != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "No difference in mtime");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                break;
+            if (type == AFR_METADATA_TRANSACTION) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg",
+                                   "Use source-brick option to"
+                                   " heal metadata split-brain");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            afr_mark_latest_mtime_file_as_source(this, sources, replies);
+            if (AFR_COUNT(sources, priv->child_count) != 1) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg",
+                                   "No difference in mtime");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            break;
         case GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK:
-                ret = dict_get_str (xdata_req, "child-name", &name);
-                if (ret)
-                        goto out;
-                source = afr_get_child_index_from_name (this, name);
-                if (source < 0) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Invalid brick name");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                if (locked_on[source] != 1) {
-                        ret = dict_set_str (xdata_rsp, "sh-fail-msg",
-                                            "Brick is not up");
-                        if (!ret)
-                                ret = -1;
-                        goto out;
-                }
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                sources[source] = 1;
-                break;
-        default:
-                ret = -1;
+            ret = dict_get_str(xdata_req, "child-name", &name);
+            if (ret)
                 goto out;
-        }
-        for (i = 0 ; i < priv->child_count; i++) {
-                if (sources[i]) {
-                        source = i;
-                        break;
-                }
-        }
-        sinks[source] = 0;
-        healed_sinks[source] = 0;
-        ret = source;
+            source = afr_get_child_index_from_name(this, name);
+            if (source < 0) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg",
+                                   "Invalid brick name");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            if (locked_on[source] != 1) {
+                ret = dict_set_str(xdata_rsp, "sh-fail-msg", "Brick is not up");
+                if (!ret)
+                    ret = -1;
+                goto out;
+            }
+            memset(sources, 0, sizeof(*sources) * priv->child_count);
+            sources[source] = 1;
+            break;
+        default:
+            ret = -1;
+            goto out;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            break;
+        }
+    }
+    sinks[source] = 0;
+    healed_sinks[source] = 0;
+    ret = source;
 out:
-        if (ret < 0)
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-        return ret;
-
+    if (ret < 0)
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+    return ret;
 }
 
 int
-afr_sh_fav_by_majority (xlator_t *this, struct afr_reply *replies,
-                        inode_t *inode)
-{
-        afr_private_t   *priv;
-        int             vote_count = -1;
-        int             fav_child = -1;
-        int             i = 0;
-        int             k = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "mtime_sec = %ld, size = %lu for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_mtime,
-                                replies[i].poststat.ia_size,
-                                uuid_utoa (inode->gfid));
-                                vote_count = 0;
-                        for (k = 0; k < priv->child_count; k++) {
-                                if ((replies[k].poststat.ia_mtime ==
-                                     replies[i].poststat.ia_mtime) &&
-                                    (replies[k].poststat.ia_size ==
-                                     replies[i].poststat.ia_size)
-                                   ) {
-                                        vote_count++;
-                                }
-                        }
-                        if (vote_count > priv->child_count/2) {
-                                fav_child = i;
-                                break;
-                        }
+afr_sh_fav_by_majority(xlator_t *this, struct afr_reply *replies,
+                       inode_t *inode)
+{
+    afr_private_t *priv;
+    int vote_count = -1;
+    int fav_child = -1;
+    int i = 0;
+    int k = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s "
+                         "mtime_sec = %ld, size = %lu for gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_mtime,
+                         replies[i].poststat.ia_size, uuid_utoa(inode->gfid));
+            vote_count = 0;
+            for (k = 0; k < priv->child_count; k++) {
+                if ((replies[k].poststat.ia_mtime ==
+                     replies[i].poststat.ia_mtime) &&
+                    (replies[k].poststat.ia_size ==
+                     replies[i].poststat.ia_size)) {
+                    vote_count++;
                 }
+            }
+            if (vote_count > priv->child_count / 2) {
+                fav_child = i;
+                break;
+            }
         }
-        return fav_child;
+    }
+    return fav_child;
 }
 
 /*
  * afr_sh_fav_by_mtime: Choose favorite child by mtime.
  */
 int
-afr_sh_fav_by_mtime (xlator_t *this, struct afr_reply *replies, inode_t *inode)
-{
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint32_t cmp_mtime = 0;
-        uint32_t cmp_mtime_nsec = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "mtime = %ld, mtime_nsec = %d for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_mtime,
-                                replies[i].poststat.ia_mtime_nsec,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_mtime > cmp_mtime) {
-                                cmp_mtime = replies[i].poststat.ia_mtime;
-                                cmp_mtime_nsec =
-                                        replies[i].poststat.ia_mtime_nsec;
-                                fav_child = i;
-                        } else if ((replies[i].poststat.ia_mtime == cmp_mtime)
-                                    && (replies[i].poststat.ia_mtime_nsec >
-                                    cmp_mtime_nsec)) {
-                                cmp_mtime = replies[i].poststat.ia_mtime;
-                                cmp_mtime_nsec =
-                                        replies[i].poststat.ia_mtime_nsec;
-                                fav_child = i;
-                        }
-                }
-        }
-        return fav_child;
+afr_sh_fav_by_mtime(xlator_t *this, struct afr_reply *replies, inode_t *inode)
+{
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint32_t cmp_mtime = 0;
+    uint32_t cmp_mtime_nsec = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s "
+                         "mtime = %ld, mtime_nsec = %d for gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_mtime,
+                         replies[i].poststat.ia_mtime_nsec,
+                         uuid_utoa(inode->gfid));
+            if (replies[i].poststat.ia_mtime > cmp_mtime) {
+                cmp_mtime = replies[i].poststat.ia_mtime;
+                cmp_mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+                fav_child = i;
+            } else if ((replies[i].poststat.ia_mtime == cmp_mtime) &&
+                       (replies[i].poststat.ia_mtime_nsec > cmp_mtime_nsec)) {
+                cmp_mtime = replies[i].poststat.ia_mtime;
+                cmp_mtime_nsec = replies[i].poststat.ia_mtime_nsec;
+                fav_child = i;
+            }
+        }
+    }
+    return fav_child;
 }
 
 /*
  * afr_sh_fav_by_ctime: Choose favorite child by ctime.
  */
 int
-afr_sh_fav_by_ctime (xlator_t *this, struct afr_reply *replies, inode_t *inode)
-{
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint32_t cmp_ctime = 0;
-        uint32_t cmp_ctime_nsec = 0;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "ctime = %ld, ctime_nsec = %d for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_ctime,
-                                replies[i].poststat.ia_ctime_nsec,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_ctime > cmp_ctime) {
-                                cmp_ctime = replies[i].poststat.ia_ctime;
-                                cmp_ctime_nsec =
-                                        replies[i].poststat.ia_ctime_nsec;
-                                fav_child = i;
-                        } else if ((replies[i].poststat.ia_ctime == cmp_ctime)
-                                    && (replies[i].poststat.ia_ctime_nsec >
-                                    cmp_ctime_nsec)) {
-                                cmp_ctime = replies[i].poststat.ia_ctime;
-                                cmp_ctime_nsec =
-                                        replies[i].poststat.ia_ctime_nsec;
-                                fav_child = i;
-                        }
-                }
-        }
-        return fav_child;
+afr_sh_fav_by_ctime(xlator_t *this, struct afr_reply *replies, inode_t *inode)
+{
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint32_t cmp_ctime = 0;
+    uint32_t cmp_ctime_nsec = 0;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s "
+                         "ctime = %ld, ctime_nsec = %d for gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_ctime,
+                         replies[i].poststat.ia_ctime_nsec,
+                         uuid_utoa(inode->gfid));
+            if (replies[i].poststat.ia_ctime > cmp_ctime) {
+                cmp_ctime = replies[i].poststat.ia_ctime;
+                cmp_ctime_nsec = replies[i].poststat.ia_ctime_nsec;
+                fav_child = i;
+            } else if ((replies[i].poststat.ia_ctime == cmp_ctime) &&
+                       (replies[i].poststat.ia_ctime_nsec > cmp_ctime_nsec)) {
+                cmp_ctime = replies[i].poststat.ia_ctime;
+                cmp_ctime_nsec = replies[i].poststat.ia_ctime_nsec;
+                fav_child = i;
+            }
+        }
+    }
+    return fav_child;
 }
 
 /*
  * afr_sh_fav_by_size: Choose favorite child by size.
  */
 int
-afr_sh_fav_by_size (xlator_t *this, struct afr_reply *replies, inode_t *inode)
+afr_sh_fav_by_size(xlator_t *this, struct afr_reply *replies, inode_t *inode)
 {
-        afr_private_t *priv;
-        int fav_child = -1;
-        int i = 0;
-        uint64_t cmp_sz = 0;
+    afr_private_t *priv;
+    int fav_child = -1;
+    int i = 0;
+    uint64_t cmp_sz = 0;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (replies[i].valid == 1) {
-                        gf_msg_debug (this->name, 0, "Child:%s "
-                                "file size = %lu for gfid %s",
-                                priv->children[i]->name,
-                                replies[i].poststat.ia_size,
-                                uuid_utoa (inode->gfid));
-                        if (replies[i].poststat.ia_size > cmp_sz) {
-                                cmp_sz = replies[i].poststat.ia_size;
-                                fav_child = i;
-                        }
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid == 1) {
+            gf_msg_debug(this->name, 0,
+                         "Child:%s "
+                         "file size = %lu for gfid %s",
+                         priv->children[i]->name, replies[i].poststat.ia_size,
+                         uuid_utoa(inode->gfid));
+            if (replies[i].poststat.ia_size > cmp_sz) {
+                cmp_sz = replies[i].poststat.ia_size;
+                fav_child = i;
+            }
         }
-        return fav_child;
+    }
+    return fav_child;
 }
 
 int
-afr_sh_get_fav_by_policy (xlator_t *this, struct afr_reply *replies,
-                          inode_t *inode, char **policy_str)
+afr_sh_get_fav_by_policy(xlator_t *this, struct afr_reply *replies,
+                         inode_t *inode, char **policy_str)
 {
-        afr_private_t *priv = NULL;
-        int fav_child = -1;
+    afr_private_t *priv = NULL;
+    int fav_child = -1;
 
-        priv = this->private;
-        if (!afr_can_decide_split_brain_source_sinks (replies,
-                                                      priv->child_count)) {
-                return -1;
-        }
+    priv = this->private;
+    if (!afr_can_decide_split_brain_source_sinks(replies, priv->child_count)) {
+        return -1;
+    }
 
-        switch (priv->fav_child_policy) {
+    switch (priv->fav_child_policy) {
         case AFR_FAV_CHILD_BY_SIZE:
-                fav_child = afr_sh_fav_by_size (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "SIZE";
-                }
-                break;
+            fav_child = afr_sh_fav_by_size(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "SIZE";
+            }
+            break;
         case AFR_FAV_CHILD_BY_CTIME:
-                fav_child = afr_sh_fav_by_ctime (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "CTIME";
-                }
-                break;
+            fav_child = afr_sh_fav_by_ctime(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "CTIME";
+            }
+            break;
         case AFR_FAV_CHILD_BY_MTIME:
-                fav_child = afr_sh_fav_by_mtime (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "MTIME";
-                }
-                break;
+            fav_child = afr_sh_fav_by_mtime(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "MTIME";
+            }
+            break;
         case AFR_FAV_CHILD_BY_MAJORITY:
-                fav_child = afr_sh_fav_by_majority (this, replies, inode);
-                if (policy_str && fav_child >= 0) {
-                        *policy_str = "MAJORITY";
-                }
-                break;
+            fav_child = afr_sh_fav_by_majority(this, replies, inode);
+            if (policy_str && fav_child >= 0) {
+                *policy_str = "MAJORITY";
+            }
+            break;
         case AFR_FAV_CHILD_NONE:
         default:
-                break;
-        }
+            break;
+    }
 
-        return fav_child;
+    return fav_child;
 }
 
 int
-afr_mark_split_brain_source_sinks_by_policy (call_frame_t *frame,
-                                             xlator_t *this,
-                                             inode_t *inode,
-                                             unsigned char *sources,
-                                             unsigned char *sinks,
-                                             unsigned char *healed_sinks,
-                                             unsigned char *locked_on,
-                                             struct afr_reply *replies,
-                                             afr_transaction_type type)
-{
-        afr_private_t *priv = NULL;
-        int fav_child = -1;
-        char mtime_str[256];
-        char ctime_str[256];
-        char *policy_str = NULL;
-        struct tm *tm_ptr;
-        time_t time;
-
-        priv = this->private;
-
-        fav_child = afr_sh_get_fav_by_policy (this, replies, inode,
-                                              &policy_str);
-        if (fav_child > priv->child_count - 1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_SBRAIN_FAV_CHILD_POLICY, "Invalid child (%d) "
-                        "selected by policy %s.", fav_child, policy_str);
-        } else if (fav_child >= 0) {
-                time = replies[fav_child].poststat.ia_mtime;
-                tm_ptr = localtime (&time);
-                strftime (mtime_str, sizeof (mtime_str), "%Y-%m-%d %H:%M:%S",
-                          tm_ptr);
-                time = replies[fav_child].poststat.ia_ctime;
-                tm_ptr = localtime (&time);
-                strftime (ctime_str, sizeof (ctime_str), "%Y-%m-%d %H:%M:%S",
-                          tm_ptr);
-
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_SBRAIN_FAV_CHILD_POLICY, "Source %s "
-                        "selected as authentic to resolve conflicting "
-                         "data in file (gfid:%s) by %s (%lu bytes @ %s mtime, "
-                         "%s ctime).",
-                         priv->children[fav_child]->name,
-                         uuid_utoa (inode->gfid),
-                         policy_str,
-                         replies[fav_child].poststat.ia_size,
-                         mtime_str,
-                         ctime_str);
-
-                sources[fav_child] = 1;
-                sinks[fav_child] = 0;
-                healed_sinks[fav_child] = 0;
-        }
-        return fav_child;
+afr_mark_split_brain_source_sinks_by_policy(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type)
+{
+    afr_private_t *priv = NULL;
+    int fav_child = -1;
+    char mtime_str[256];
+    char ctime_str[256];
+    char *policy_str = NULL;
+    struct tm *tm_ptr;
+    time_t time;
+
+    priv = this->private;
+
+    fav_child = afr_sh_get_fav_by_policy(this, replies, inode, &policy_str);
+    if (fav_child > priv->child_count - 1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+               "Invalid child (%d) "
+               "selected by policy %s.",
+               fav_child, policy_str);
+    } else if (fav_child >= 0) {
+        time = replies[fav_child].poststat.ia_mtime;
+        tm_ptr = localtime(&time);
+        strftime(mtime_str, sizeof(mtime_str), "%Y-%m-%d %H:%M:%S", tm_ptr);
+        time = replies[fav_child].poststat.ia_ctime;
+        tm_ptr = localtime(&time);
+        strftime(ctime_str, sizeof(ctime_str), "%Y-%m-%d %H:%M:%S", tm_ptr);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SBRAIN_FAV_CHILD_POLICY,
+               "Source %s "
+               "selected as authentic to resolve conflicting "
+               "data in file (gfid:%s) by %s (%lu bytes @ %s mtime, "
+               "%s ctime).",
+               priv->children[fav_child]->name, uuid_utoa(inode->gfid),
+               policy_str, replies[fav_child].poststat.ia_size, mtime_str,
+               ctime_str);
+
+        sources[fav_child] = 1;
+        sinks[fav_child] = 0;
+        healed_sinks[fav_child] = 0;
+    }
+    return fav_child;
 }
 
 gf_boolean_t
-afr_is_file_empty_on_all_children (afr_private_t *priv,
-                                   struct afr_reply *replies)
+afr_is_file_empty_on_all_children(afr_private_t *priv,
+                                  struct afr_reply *replies)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if ((!replies[i].valid) || (replies[i].op_ret != 0) ||
-                    (replies[i].poststat.ia_size != 0))
-                        return _gf_false;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if ((!replies[i].valid) || (replies[i].op_ret != 0) ||
+            (replies[i].poststat.ia_size != 0))
+            return _gf_false;
+    }
 
-        return _gf_true;
+    return _gf_true;
 }
 
 int
-afr_mark_source_sinks_if_file_empty (xlator_t *this, unsigned char *sources,
-                                     unsigned char *sinks,
-                                     unsigned char *healed_sinks,
-                                     unsigned char *locked_on,
-                                     struct afr_reply *replies,
-                                     afr_transaction_type type)
-{
-        int source = -1;
-        int i = 0;
-        afr_private_t *priv = this->private;
-        struct iatt stbuf = {0, };
-
-        if ((AFR_COUNT (locked_on, priv->child_count) < priv->child_count) ||
-            (afr_success_count(replies, priv->child_count) < priv->child_count))
-                return -1;
+afr_mark_source_sinks_if_file_empty(xlator_t *this, unsigned char *sources,
+                                    unsigned char *sinks,
+                                    unsigned char *healed_sinks,
+                                    unsigned char *locked_on,
+                                    struct afr_reply *replies,
+                                    afr_transaction_type type)
+{
+    int source = -1;
+    int i = 0;
+    afr_private_t *priv = this->private;
+    struct iatt stbuf = {
+        0,
+    };
+
+    if ((AFR_COUNT(locked_on, priv->child_count) < priv->child_count) ||
+        (afr_success_count(replies, priv->child_count) < priv->child_count))
+        return -1;
 
-        if (type == AFR_DATA_TRANSACTION) {
-                if (!afr_is_file_empty_on_all_children(priv, replies))
-                                return -1;
-                goto mark;
-        }
-
-        /*For AFR_METADATA_TRANSACTION, metadata must be same on all bricks.*/
-        stbuf = replies[0].poststat;
-        for (i = 1; i < priv->child_count; i++) {
-                if ((!IA_EQUAL (stbuf, replies[i].poststat, type)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, uid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, gid)) ||
-                    (!IA_EQUAL (stbuf, replies[i].poststat, prot)))
-                        return -1;
-        }
-        for (i = 1; i < priv->child_count; i++) {
-                if (!afr_xattrs_are_equal (replies[0].xdata,
-                                           replies[i].xdata))
-                        return -1;
-        }
+    if (type == AFR_DATA_TRANSACTION) {
+        if (!afr_is_file_empty_on_all_children(priv, replies))
+            return -1;
+        goto mark;
+    }
+
+    /*For AFR_METADATA_TRANSACTION, metadata must be same on all bricks.*/
+    stbuf = replies[0].poststat;
+    for (i = 1; i < priv->child_count; i++) {
+        if ((!IA_EQUAL(stbuf, replies[i].poststat, type)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, uid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, gid)) ||
+            (!IA_EQUAL(stbuf, replies[i].poststat, prot)))
+            return -1;
+    }
+    for (i = 1; i < priv->child_count; i++) {
+        if (!afr_xattrs_are_equal(replies[0].xdata, replies[i].xdata))
+            return -1;
+    }
 
 mark:
-        /* data/metadata is same on all bricks. Pick one of them as source. Rest
-         * are sinks.*/
-        for (i = 0 ; i < priv->child_count; i++) {
-                if (source == -1) {
-                        source = i;
-                        sources[i] = 1;
-                        sinks[i] = 0;
-                        healed_sinks[i] = 0;
-                        continue;
-                }
-                sources[i] = 0;
-                sinks[i] = 1;
-                healed_sinks[i] = 1;
+    /* data/metadata is same on all bricks. Pick one of them as source. Rest
+     * are sinks.*/
+    for (i = 0; i < priv->child_count; i++) {
+        if (source == -1) {
+            source = i;
+            sources[i] = 1;
+            sinks[i] = 0;
+            healed_sinks[i] = 0;
+            continue;
         }
+        sources[i] = 0;
+        sinks[i] = 1;
+        healed_sinks[i] = 1;
+    }
 
-        return source;
+    return source;
 }
 
 /* Return a source depending on the type of heal_op, and set sources[source],
@@ -1354,171 +1337,156 @@ mark:
  * sinks[node] are 1. This should be the case if the file is in split-brain.
  */
 int
-afr_mark_split_brain_source_sinks (call_frame_t *frame, xlator_t *this,
-                                   inode_t *inode,
-                                   unsigned char *sources,
-                                   unsigned char *sinks,
-                                   unsigned char *healed_sinks,
-                                   unsigned char *locked_on,
-                                   struct afr_reply *replies,
-                                   afr_transaction_type type)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        dict_t *xdata_req = NULL;
-        int heal_op = -1;
-        int ret = -1;
-        int source = -1;
-
-        local = frame->local;
-        priv = this->private;
-        xdata_req = local->xdata_req;
-
-        source = afr_mark_source_sinks_if_file_empty (this, sources, sinks,
-                                                      healed_sinks, locked_on,
-                                                      replies, type);
-        if (source >= 0)
-                return source;
-
-        ret = dict_get_int32 (xdata_req, "heal-op", &heal_op);
-        if (ret)
-                goto autoheal;
-
-        source = afr_mark_split_brain_source_sinks_by_heal_op (frame, this,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                            type, heal_op);
+afr_mark_split_brain_source_sinks(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    struct afr_reply *replies, afr_transaction_type type)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata_req = NULL;
+    int heal_op = -1;
+    int ret = -1;
+    int source = -1;
+
+    local = frame->local;
+    priv = this->private;
+    xdata_req = local->xdata_req;
+
+    source = afr_mark_source_sinks_if_file_empty(
+        this, sources, sinks, healed_sinks, locked_on, replies, type);
+    if (source >= 0)
         return source;
 
+    ret = dict_get_int32(xdata_req, "heal-op", &heal_op);
+    if (ret)
+        goto autoheal;
+
+    source = afr_mark_split_brain_source_sinks_by_heal_op(
+        frame, this, sources, sinks, healed_sinks, locked_on, replies, type,
+        heal_op);
+    return source;
+
 autoheal:
-        /* Automatically heal if fav_child_policy is set. */
-        if (priv->fav_child_policy != AFR_FAV_CHILD_NONE) {
-                source = afr_mark_split_brain_source_sinks_by_policy (frame,
-                                                                      this,
-                                                                      inode,
-                                                                      sources,
-                                                                      sinks,
-                                                                   healed_sinks,
-                                                                      locked_on,
-                                                                      replies,
-                                                                      type);
-                if (source != -1) {
-                        ret = dict_set_int32 (xdata_req, "fav-child-policy", 1);
-                        if (ret)
-                                return -1;
-                }
+    /* Automatically heal if fav_child_policy is set. */
+    if (priv->fav_child_policy != AFR_FAV_CHILD_NONE) {
+        source = afr_mark_split_brain_source_sinks_by_policy(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, type);
+        if (source != -1) {
+            ret = dict_set_int32(xdata_req, "fav-child-policy", 1);
+            if (ret)
+                return -1;
         }
+    }
 
-        return source;
+    return source;
 }
 
 int
-_afr_fav_child_reset_sink_xattrs (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, int source,
-                                  unsigned char *healed_sinks,
-                                  unsigned char *undid_pending,
-                                  afr_transaction_type type,
-                                  unsigned char *locked_on,
-                                  struct afr_reply *replies)
+_afr_fav_child_reset_sink_xattrs(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, int source,
+                                 unsigned char *healed_sinks,
+                                 unsigned char *undid_pending,
+                                 afr_transaction_type type,
+                                 unsigned char *locked_on,
+                                 struct afr_reply *replies)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int *input_dirty = NULL;
-        int **input_matrix = NULL;
-	int *output_dirty = NULL;
-	int **output_matrix = NULL;
-        dict_t *xattr = NULL;
-        dict_t *xdata = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int *input_dirty = NULL;
+    int **input_matrix = NULL;
+    int *output_dirty = NULL;
+    int **output_matrix = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        if (!dict_get (local->xdata_req, "fav-child-policy"))
-                return 0;
+    if (!dict_get(local->xdata_req, "fav-child-policy"))
+        return 0;
 
-        xdata = dict_new();
-        if (!xdata)
-                return -1;
+    xdata = dict_new();
+    if (!xdata)
+        return -1;
 
-        input_dirty = alloca0 (priv->child_count * sizeof (int));
-	input_matrix = ALLOC_MATRIX (priv->child_count, int);
-	output_dirty = alloca0 (priv->child_count * sizeof (int));
-	output_matrix = ALLOC_MATRIX (priv->child_count, int);
+    input_dirty = alloca0(priv->child_count * sizeof(int));
+    input_matrix = ALLOC_MATRIX(priv->child_count, int);
+    output_dirty = alloca0(priv->child_count * sizeof(int));
+    output_matrix = ALLOC_MATRIX(priv->child_count, int);
 
-        afr_selfheal_extract_xattr (this, replies, type, input_dirty,
-                                    input_matrix);
+    afr_selfheal_extract_xattr(this, replies, type, input_dirty, input_matrix);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == source || !healed_sinks[i])
-                        continue;
-                output_dirty[i] = -input_dirty[i];
-                output_matrix[i][source] = -input_matrix[i][source];
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || !healed_sinks[i])
+            continue;
+        output_dirty[i] = -input_dirty[i];
+        output_matrix[i][source] = -input_matrix[i][source];
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!healed_sinks[i] || !locked_on[i])
-                        continue;
-                xattr = afr_selfheal_output_xattr (this, _gf_false, type,
-                                                   output_dirty, output_matrix,
-                                                   i, NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i] || !locked_on[i])
+            continue;
+        xattr = afr_selfheal_output_xattr(this, _gf_false, type, output_dirty,
+                                          output_matrix, i, NULL);
 
-                afr_selfheal_post_op (frame, this, inode, i, xattr, xdata);
+        afr_selfheal_post_op(frame, this, inode, i, xattr, xdata);
 
-                undid_pending[i] = 1;
-                dict_unref (xattr);
-        }
+        undid_pending[i] = 1;
+        dict_unref(xattr);
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    if (xdata)
+        dict_unref(xdata);
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_does_witness_exist (xlator_t *this, uint64_t *witness)
+afr_does_witness_exist(xlator_t *this, uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (witness[i])
-                        return _gf_true;
-        }
-        return _gf_false;
+    for (i = 0; i < priv->child_count; i++) {
+        if (witness[i])
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 unsigned int
-afr_get_quorum_count (afr_private_t *priv)
+afr_get_quorum_count(afr_private_t *priv)
 {
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                return priv->child_count/2 + 1;
-        } else {
-                return priv->quorum_count;
-        }
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        return priv->child_count / 2 + 1;
+    } else {
+        return priv->quorum_count;
+    }
 }
 
 void
-afr_selfheal_post_op_failure_accounting (afr_private_t *priv, char *accused,
-                                         unsigned char *sources,
-                                         unsigned char *locked_on)
+afr_selfheal_post_op_failure_accounting(afr_private_t *priv, char *accused,
+                                        unsigned char *sources,
+                                        unsigned char *locked_on)
 {
-        int i = 0;
-        unsigned int  quorum_count = 0;
+    int i = 0;
+    unsigned int quorum_count = 0;
 
-        if (AFR_COUNT (sources, priv->child_count) != 0)
-                return;
+    if (AFR_COUNT(sources, priv->child_count) != 0)
+        return;
 
-        quorum_count = afr_get_quorum_count (priv);
-        for (i = 0; i < priv->child_count; i++) {
-                if ((accused[i] < quorum_count) && locked_on[i]) {
-                        sources[i] = 1;
-                }
+    quorum_count = afr_get_quorum_count(priv);
+    for (i = 0; i < priv->child_count; i++) {
+        if ((accused[i] < quorum_count) && locked_on[i]) {
+            sources[i] = 1;
         }
-        return;
+    }
+    return;
 }
 
 /*
@@ -1541,663 +1509,675 @@ afr_selfheal_post_op_failure_accounting (afr_private_t *priv, char *accused,
  */
 
 int
-afr_selfheal_find_direction (call_frame_t *frame, xlator_t *this,
-                             struct afr_reply *replies,
-                             afr_transaction_type type,
-                             unsigned char *locked_on, unsigned char *sources,
-                             unsigned char *sinks, uint64_t *witness,
-                             gf_boolean_t *pflag)
-{
-        afr_private_t *priv = NULL;
-        int i = 0;
-        int j = 0;
-        int *dirty = NULL; /* Denotes if dirty xattr is set */
-        int **matrix = NULL;/* Changelog matrix */
-        char *accused = NULL;/* Accused others without any self-accusal */
-        char *pending = NULL;/* Have pending operations on others */
-        char *self_accused = NULL; /* Accused itself */
-        int min_participants = -1;
-
-	priv = this->private;
-
-	dirty = alloca0 (priv->child_count * sizeof (int));
-	accused = alloca0 (priv->child_count);
-        pending = alloca0 (priv->child_count);
-        self_accused = alloca0 (priv->child_count);
-	matrix = ALLOC_MATRIX(priv->child_count, int);
-        memset (witness, 0, sizeof (*witness) * priv->child_count);
-
-	/* First construct the pending matrix for further analysis */
-	afr_selfheal_extract_xattr (this, replies, type, dirty, matrix);
-
-        if (pflag) {
-                for (i = 0; i < priv->child_count; i++) {
-                        for (j = 0; j < priv->child_count; j++)
-                                if (matrix[i][j])
-                                        *pflag = _gf_true;
-                        if (*pflag)
-                                break;
-                }
-        }
-
-        if (type == AFR_DATA_TRANSACTION) {
-                min_participants = priv->child_count;
-        } else {
-                min_participants = AFR_SH_MIN_PARTICIPANTS;
+afr_selfheal_find_direction(call_frame_t *frame, xlator_t *this,
+                            struct afr_reply *replies,
+                            afr_transaction_type type, unsigned char *locked_on,
+                            unsigned char *sources, unsigned char *sinks,
+                            uint64_t *witness, gf_boolean_t *pflag)
+{
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int j = 0;
+    int *dirty = NULL;         /* Denotes if dirty xattr is set */
+    int **matrix = NULL;       /* Changelog matrix */
+    char *accused = NULL;      /* Accused others without any self-accusal */
+    char *pending = NULL;      /* Have pending operations on others */
+    char *self_accused = NULL; /* Accused itself */
+    int min_participants = -1;
+
+    priv = this->private;
+
+    dirty = alloca0(priv->child_count * sizeof(int));
+    accused = alloca0(priv->child_count);
+    pending = alloca0(priv->child_count);
+    self_accused = alloca0(priv->child_count);
+    matrix = ALLOC_MATRIX(priv->child_count, int);
+    memset(witness, 0, sizeof(*witness) * priv->child_count);
+
+    /* First construct the pending matrix for further analysis */
+    afr_selfheal_extract_xattr(this, replies, type, dirty, matrix);
+
+    if (pflag) {
+        for (i = 0; i < priv->child_count; i++) {
+            for (j = 0; j < priv->child_count; j++)
+                if (matrix[i][j])
+                    *pflag = _gf_true;
+            if (*pflag)
+                break;
         }
-        if (afr_success_count (replies,
-                               priv->child_count) < min_participants) {
-                /* Treat this just like locks not being acquired */
-                return -ENOTCONN;
+    }
+
+    if (type == AFR_DATA_TRANSACTION) {
+        min_participants = priv->child_count;
+    } else {
+        min_participants = AFR_SH_MIN_PARTICIPANTS;
+    }
+    if (afr_success_count(replies, priv->child_count) < min_participants) {
+        /* Treat this just like locks not being acquired */
+        return -ENOTCONN;
+    }
+
+    /* short list all self-accused */
+    for (i = 0; i < priv->child_count; i++) {
+        if (matrix[i][i])
+            self_accused[i] = 1;
+    }
+
+    /* Next short list all accused to exclude them from being sources */
+    /* Self-accused can't accuse others as they are FOOLs */
+    for (i = 0; i < priv->child_count; i++) {
+        for (j = 0; j < priv->child_count; j++) {
+            if (matrix[i][j]) {
+                if (!self_accused[i])
+                    accused[j] += 1;
+                if (i != j)
+                    pending[i] += 1;
+            }
         }
+    }
 
-        /* short list all self-accused */
+    /* Short list all non-accused as sources */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!accused[i] && locked_on[i])
+            sources[i] = 1;
+        else
+            sources[i] = 0;
+    }
+
+    /* Everyone accused by non-self-accused sources are sinks */
+    memset(sinks, 0, priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (self_accused[i])
+            continue;
+        for (j = 0; j < priv->child_count; j++) {
+            if (matrix[i][j])
+                sinks[j] = 1;
+        }
+    }
+
+    /* For breaking ties provide with number of fops they witnessed */
+
+    /*
+     * count the pending fops witnessed from itself to others when it is
+     * self-accused
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!self_accused[i])
+            continue;
+        for (j = 0; j < priv->child_count; j++) {
+            if (i == j)
+                continue;
+            witness[i] += matrix[i][j];
+        }
+    }
+
+    if (type == AFR_DATA_TRANSACTION)
+        afr_selfheal_post_op_failure_accounting(priv, accused, sources,
+                                                locked_on);
+
+    /* If no sources, all locked nodes are sinks - split brain */
+    if (AFR_COUNT(sources, priv->child_count) == 0) {
         for (i = 0; i < priv->child_count; i++) {
-                if (matrix[i][i])
-                        self_accused[i] = 1;
+            if (locked_on[i])
+                sinks[i] = 1;
         }
+    }
 
-	/* Next short list all accused to exclude them from being sources */
-        /* Self-accused can't accuse others as they are FOOLs */
-	for (i = 0; i < priv->child_count; i++) {
-		for (j = 0; j < priv->child_count; j++) {
-                        if (matrix[i][j]) {
-                                if (!self_accused[i])
-                                        accused[j] += 1;
-                                if (i != j)
-                                        pending[i] += 1;
-                         }
-		}
-	}
-
-	/* Short list all non-accused as sources */
-	for (i = 0; i < priv->child_count; i++) {
-		if (!accused[i] && locked_on[i])
-			sources[i] = 1;
-                else
-                        sources[i] = 0;
-	}
-
-        /* Everyone accused by non-self-accused sources are sinks */
-        memset (sinks, 0, priv->child_count);
+    /* One more class of witness similar to dirty in v2 is where no pending
+     * exists but we have self-accusing markers. This can happen in afr-v1
+     * if the brick crashes just after doing xattrop on self but
+     * before xattrop on the other xattrs on the brick in pre-op. */
+    if (AFR_COUNT(pending, priv->child_count) == 0) {
         for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (self_accused[i])
-                        continue;
-                for (j = 0; j < priv->child_count; j++) {
-                        if (matrix[i][j])
-                                sinks[j] = 1;
-                }
+            if (self_accused[i])
+                witness[i] += matrix[i][i];
         }
-
-        /* For breaking ties provide with number of fops they witnessed */
-
-        /*
-         * count the pending fops witnessed from itself to others when it is
-         * self-accused
+    } else {
+        /* In afr-v1 if a file is self-accused and has pending
+         * operations on others then it is similar to 'dirty' in afr-v2.
+         * Consider such cases as witness.
          */
         for (i = 0; i < priv->child_count; i++) {
-                if (!self_accused[i])
-                        continue;
-                for (j = 0; j < priv->child_count; j++) {
-                        if (i == j)
-                                continue;
-                        witness[i] += matrix[i][j];
-                }
+            if (self_accused[i] && pending[i])
+                witness[i] += matrix[i][i];
         }
+    }
 
-        if (type == AFR_DATA_TRANSACTION)
-                afr_selfheal_post_op_failure_accounting (priv, accused,
-                                                         sources, locked_on);
+    /* count the number of dirty fops witnessed */
+    for (i = 0; i < priv->child_count; i++)
+        witness[i] += dirty[i];
 
-         /* If no sources, all locked nodes are sinks - split brain */
-         if (AFR_COUNT (sources, priv->child_count) == 0) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (locked_on[i])
-                                sinks[i] = 1;
-                }
-        }
-
-        /* One more class of witness similar to dirty in v2 is where no pending
-         * exists but we have self-accusing markers. This can happen in afr-v1
-         * if the brick crashes just after doing xattrop on self but
-         * before xattrop on the other xattrs on the brick in pre-op. */
-        if (AFR_COUNT (pending, priv->child_count) == 0) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (self_accused[i])
-                                witness[i] += matrix[i][i];
-                }
-        } else {
-                /* In afr-v1 if a file is self-accused and has pending
-                 * operations on others then it is similar to 'dirty' in afr-v2.
-                 * Consider such cases as witness.
-                 */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (self_accused[i] && pending[i])
-                                witness[i] += matrix[i][i];
-                }
-        }
-
-
-        /* count the number of dirty fops witnessed */
-        for (i = 0; i < priv->child_count; i++)
-                witness[i] += dirty[i];
-
-	return 0;
+    return 0;
 }
 
 void
-afr_log_selfheal (uuid_t gfid, xlator_t *this, int ret, char *type,
-                  int source, unsigned char *sources,
-                  unsigned char *healed_sinks)
-{
-        char *status = NULL;
-        char *sinks_str = NULL;
-        char *p = NULL;
-        char *sources_str = NULL;
-        char *q = NULL;
-        afr_private_t *priv = NULL;
-        gf_loglevel_t loglevel = GF_LOG_NONE;
-        int i = 0;
-
-        priv = this->private;
-        sinks_str = alloca0 (priv->child_count * 8);
-        p = sinks_str;
-        sources_str = alloca0 (priv->child_count * 8);
-        q = sources_str;
-        for (i = 0; i < priv->child_count; i++) {
-                if (healed_sinks[i])
-                        p += sprintf (p, "%d ", i);
-                if (sources[i]) {
-                        if (source == i) {
-                                q += sprintf (q, "[%d] ", i);
-                        } else {
-                                q += sprintf (q, "%d ", i);
-                        }
-                }
-        }
-
-        if (ret < 0) {
-                status = "Failed";
-                loglevel = GF_LOG_DEBUG;
-        } else {
-                status = "Completed";
-                loglevel = GF_LOG_INFO;
-        }
-
-        gf_msg (this->name, loglevel, 0,
-                AFR_MSG_SELF_HEAL_INFO, "%s %s selfheal on %s. "
-                "sources=%s sinks=%s", status, type, uuid_utoa (gfid),
-                sources_str, sinks_str);
+afr_log_selfheal(uuid_t gfid, xlator_t *this, int ret, char *type, int source,
+                 unsigned char *sources, unsigned char *healed_sinks)
+{
+    char *status = NULL;
+    char *sinks_str = NULL;
+    char *p = NULL;
+    char *sources_str = NULL;
+    char *q = NULL;
+    afr_private_t *priv = NULL;
+    gf_loglevel_t loglevel = GF_LOG_NONE;
+    int i = 0;
+
+    priv = this->private;
+    sinks_str = alloca0(priv->child_count * 8);
+    p = sinks_str;
+    sources_str = alloca0(priv->child_count * 8);
+    q = sources_str;
+    for (i = 0; i < priv->child_count; i++) {
+        if (healed_sinks[i])
+            p += sprintf(p, "%d ", i);
+        if (sources[i]) {
+            if (source == i) {
+                q += sprintf(q, "[%d] ", i);
+            } else {
+                q += sprintf(q, "%d ", i);
+            }
+        }
+    }
+
+    if (ret < 0) {
+        status = "Failed";
+        loglevel = GF_LOG_DEBUG;
+    } else {
+        status = "Completed";
+        loglevel = GF_LOG_INFO;
+    }
+
+    gf_msg(this->name, loglevel, 0, AFR_MSG_SELF_HEAL_INFO,
+           "%s %s selfheal on %s. "
+           "sources=%s sinks=%s",
+           status, type, uuid_utoa(gfid), sources_str, sinks_str);
 }
 
 int
-afr_selfheal_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			   int op_ret, int op_errno, inode_t *inode,
-			   struct iatt *buf, dict_t *xdata, struct iatt *parbuf)
-{
-	afr_local_t *local = NULL;
-	int i = -1;
-        GF_UNUSED int ret = -1;
-	int8_t need_heal = 1;
-
-	local = frame->local;
-	i = (long) cookie;
-
-	local->replies[i].valid = 1;
-	local->replies[i].op_ret = op_ret;
-	local->replies[i].op_errno = op_errno;
-	if (buf)
-		local->replies[i].poststat = *buf;
-	if (parbuf)
-		local->replies[i].postparent = *parbuf;
-	if (xdata) {
-		local->replies[i].xdata = dict_ref (xdata);
-                ret = dict_get_int8 (xdata, "link-count", &need_heal);
-                local->replies[i].need_heal = need_heal;
-        } else {
-                local->replies[i].need_heal = need_heal;
-        }
-
-	syncbarrier_wake (&local->barrier);
-
-	return 0;
+afr_selfheal_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xdata, struct iatt *parbuf)
+{
+    afr_local_t *local = NULL;
+    int i = -1;
+    GF_UNUSED int ret = -1;
+    int8_t need_heal = 1;
+
+    local = frame->local;
+    i = (long)cookie;
+
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
+    if (buf)
+        local->replies[i].poststat = *buf;
+    if (parbuf)
+        local->replies[i].postparent = *parbuf;
+    if (xdata) {
+        local->replies[i].xdata = dict_ref(xdata);
+        ret = dict_get_int8(xdata, "link-count", &need_heal);
+        local->replies[i].need_heal = need_heal;
+    } else {
+        local->replies[i].need_heal = need_heal;
+    }
+
+    syncbarrier_wake(&local->barrier);
+
+    return 0;
 }
 
-
 inode_t *
-afr_selfheal_unlocked_lookup_on (call_frame_t *frame, inode_t *parent,
-				 const char *name, struct afr_reply *replies,
-				 unsigned char *lookup_on, dict_t *xattr)
-{
-	loc_t loc = {0, };
-	dict_t *xattr_req = NULL;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	inode_t *inode = NULL;
-
-	local = frame->local;
-	priv = frame->this->private;
-
-	xattr_req = dict_new ();
-	if (!xattr_req)
-		return NULL;
+afr_selfheal_unlocked_lookup_on(call_frame_t *frame, inode_t *parent,
+                                const char *name, struct afr_reply *replies,
+                                unsigned char *lookup_on, dict_t *xattr)
+{
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr_req = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+
+    local = frame->local;
+    priv = frame->this->private;
+
+    xattr_req = dict_new();
+    if (!xattr_req)
+        return NULL;
 
-        if (xattr)
-                dict_copy (xattr, xattr_req);
+    if (xattr)
+        dict_copy(xattr, xattr_req);
 
-	if (afr_xattr_req_prepare (frame->this, xattr_req) != 0) {
-		dict_unref (xattr_req);
-		return NULL;
-	}
+    if (afr_xattr_req_prepare(frame->this, xattr_req) != 0) {
+        dict_unref(xattr_req);
+        return NULL;
+    }
 
-	inode = inode_new (parent->table);
-	if (!inode) {
-		dict_unref (xattr_req);
-		return NULL;
-	}
+    inode = inode_new(parent->table);
+    if (!inode) {
+        dict_unref(xattr_req);
+        return NULL;
+    }
 
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, parent->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
 
-	AFR_ONLIST (lookup_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
-		    xattr_req);
+    AFR_ONLIST(lookup_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               xattr_req);
 
-	afr_replies_copy (replies, local->replies, priv->child_count);
+    afr_replies_copy(replies, local->replies, priv->child_count);
 
-	loc_wipe (&loc);
-	dict_unref (xattr_req);
+    loc_wipe(&loc);
+    dict_unref(xattr_req);
 
-	return inode;
+    return inode;
 }
 
 int
-afr_selfheal_unlocked_discover_on (call_frame_t *frame, inode_t *inode,
-				   uuid_t gfid, struct afr_reply *replies,
-				   unsigned char *discover_on)
+afr_selfheal_unlocked_discover_on(call_frame_t *frame, inode_t *inode,
+                                  uuid_t gfid, struct afr_reply *replies,
+                                  unsigned char *discover_on)
 {
-	loc_t loc = {0, };
-	dict_t *xattr_req = NULL;
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr_req = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-	local = frame->local;
-	priv = frame->this->private;
+    local = frame->local;
+    priv = frame->this->private;
 
-	xattr_req = dict_new ();
-	if (!xattr_req)
-		return -ENOMEM;
+    xattr_req = dict_new();
+    if (!xattr_req)
+        return -ENOMEM;
 
-	if (afr_xattr_req_prepare (frame->this, xattr_req) != 0) {
-		dict_unref (xattr_req);
-		return -ENOMEM;
-	}
+    if (afr_xattr_req_prepare(frame->this, xattr_req) != 0) {
+        dict_unref(xattr_req);
+        return -ENOMEM;
+    }
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, gfid);
 
-	AFR_ONLIST (discover_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
-		    xattr_req);
+    AFR_ONLIST(discover_on, frame, afr_selfheal_discover_cbk, lookup, &loc,
+               xattr_req);
 
-	afr_replies_copy (replies, local->replies, priv->child_count);
+    afr_replies_copy(replies, local->replies, priv->child_count);
 
-	loc_wipe (&loc);
-	dict_unref (xattr_req);
+    loc_wipe(&loc);
+    dict_unref(xattr_req);
 
-	return 0;
+    return 0;
 }
 
 int
-afr_selfheal_unlocked_discover (call_frame_t *frame, inode_t *inode,
-				uuid_t gfid, struct afr_reply *replies)
+afr_selfheal_unlocked_discover(call_frame_t *frame, inode_t *inode, uuid_t gfid,
+                               struct afr_reply *replies)
 {
-	afr_private_t *priv = NULL;
+    afr_private_t *priv = NULL;
 
-	priv = frame->this->private;
+    priv = frame->this->private;
 
-	return afr_selfheal_unlocked_discover_on (frame, inode, gfid, replies,
-						  priv->child_up);
+    return afr_selfheal_unlocked_discover_on(frame, inode, gfid, replies,
+                                             priv->child_up);
 }
 
 unsigned int
-afr_success_count (struct afr_reply *replies, unsigned int count)
+afr_success_count(struct afr_reply *replies, unsigned int count)
 {
-        int     i = 0;
-        unsigned int success = 0;
+    int i = 0;
+    unsigned int success = 0;
 
-        for (i = 0; i < count; i++)
-                if (replies[i].valid && replies[i].op_ret == 0)
-                        success++;
-        return success;
+    for (i = 0; i < count; i++)
+        if (replies[i].valid && replies[i].op_ret == 0)
+            success++;
+    return success;
 }
 
 int
-afr_selfheal_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		       int op_ret, int op_errno, dict_t *xdata)
+afr_selfheal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-	int i = 0;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-	local = frame->local;
-	i = (long) cookie;
+    local = frame->local;
+    i = (long)cookie;
 
-	local->replies[i].valid = 1;
-	local->replies[i].op_ret = op_ret;
-	local->replies[i].op_errno = op_errno;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
 
-	syncbarrier_wake (&local->barrier);
+    syncbarrier_wake(&local->barrier);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_locked_fill (call_frame_t *frame, xlator_t *this,
-                 unsigned char *locked_on)
+afr_locked_fill(call_frame_t *frame, xlator_t *this, unsigned char *locked_on)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int count = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int count = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].valid && local->replies[i].op_ret == 0) {
-			locked_on[i] = 1;
-			count++;
-		} else {
-			locked_on[i] = 0;
-		}
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].valid && local->replies[i].op_ret == 0) {
+            locked_on[i] = 1;
+            count++;
+        } else {
+            locked_on[i] = 0;
+        }
+    }
 
-	return count;
+    return count;
 }
 
-
 int
-afr_selfheal_tryinodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, off_t off, size_t size,
-			 unsigned char *locked_on)
+afr_selfheal_tryinodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, off_t off, size_t size,
+                        unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		    &loc, F_SETLK, &flock, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_inodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, off_t off, size_t size,
-		      unsigned char *locked_on)
+afr_selfheal_inodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, off_t off, size_t size,
+                     unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
-	afr_local_t *local = NULL;
-	int i = 0;
-	afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		    &loc, F_SETLK, &flock, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].op_ret == -1 &&
-		    local->replies[i].op_errno == EAGAIN) {
-			afr_locked_fill (frame, this, locked_on);
-			afr_selfheal_uninodelk (frame, this, inode, dom, off,
-						size, locked_on);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == -1 &&
+            local->replies[i].op_errno == EAGAIN) {
+            afr_locked_fill(frame, this, locked_on);
+            afr_selfheal_uninodelk(frame, this, inode, dom, off, size,
+                                   locked_on);
 
-			AFR_SEQ (frame, afr_selfheal_lock_cbk, inodelk, dom,
-				 &loc, F_SETLKW, &flock, NULL);
-			break;
-		}
-	}
+            AFR_SEQ(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLKW,
+                    &flock, NULL);
+            break;
+        }
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 static void
-afr_get_lock_and_eagain_counts (afr_private_t *priv, struct afr_reply *replies,
-                                int *lock_count, int *eagain_count)
-{
-	int i = 0;
-
-	for (i = 0; i < priv->child_count; i++) {
-	        if (!replies[i].valid)
-	                continue;
-	        if (replies[i].op_ret == 0) {
-	                (*lock_count)++;
-                } else if (replies[i].op_ret == -1 &&
-		         replies[i].op_errno == EAGAIN) {
-		        (*eagain_count)++;
-                }
-	}
+afr_get_lock_and_eagain_counts(afr_private_t *priv, struct afr_reply *replies,
+                               int *lock_count, int *eagain_count)
+{
+    int i = 0;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret == 0) {
+            (*lock_count)++;
+        } else if (replies[i].op_ret == -1 && replies[i].op_errno == EAGAIN) {
+            (*eagain_count)++;
+        }
+    }
 }
 
 /*Do blocking locks if number of locks acquired is majority and there were some
  * EAGAINs. Useful for odd-way replication*/
 int
-afr_selfheal_tie_breaker_inodelk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, off_t off,
-                                  size_t size, unsigned char *locked_on)
+afr_selfheal_tie_breaker_inodelk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, off_t off,
+                                 size_t size, unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int lock_count = 0;
-	int eagain_count = 0;
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int lock_count = 0;
+    int eagain_count = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	flock.l_type = F_WRLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    flock.l_type = F_WRLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, inodelk, dom,
-		   &loc, F_SETLK, &flock, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLK, &flock,
+              NULL);
 
-        afr_get_lock_and_eagain_counts (priv, local->replies, &lock_count,
-                                        &eagain_count);
+    afr_get_lock_and_eagain_counts(priv, local->replies, &lock_count,
+                                   &eagain_count);
 
-	if (lock_count > priv->child_count/2 && eagain_count) {
-                afr_locked_fill (frame, this, locked_on);
-                afr_selfheal_uninodelk (frame, this, inode, dom, off,
-                                        size, locked_on);
+    if (lock_count > priv->child_count / 2 && eagain_count) {
+        afr_locked_fill(frame, this, locked_on);
+        afr_selfheal_uninodelk(frame, this, inode, dom, off, size, locked_on);
 
-                AFR_SEQ (frame, afr_selfheal_lock_cbk, inodelk, dom,
-                         &loc, F_SETLKW, &flock, NULL);
-        }
+        AFR_SEQ(frame, afr_selfheal_lock_cbk, inodelk, dom, &loc, F_SETLKW,
+                &flock, NULL);
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 int
-afr_selfheal_uninodelk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, off_t off, size_t size,
-			const unsigned char *locked_on)
+afr_selfheal_uninodelk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, off_t off, size_t size,
+                       const unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	struct gf_flock flock = {0, };
+    loc_t loc = {
+        0,
+    };
+    struct gf_flock flock = {
+        0,
+    };
 
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    flock.l_type = F_UNLCK;
+    flock.l_start = off;
+    flock.l_len = size;
 
-	flock.l_type = F_UNLCK;
-	flock.l_start = off;
-	flock.l_len = size;
+    AFR_ONLIST(locked_on, frame, afr_selfheal_lock_cbk, inodelk, dom, &loc,
+               F_SETLK, &flock, NULL);
 
-	AFR_ONLIST (locked_on, frame, afr_selfheal_lock_cbk, inodelk,
-		    dom, &loc, F_SETLK, &flock, NULL);
+    loc_wipe(&loc);
 
-	loc_wipe (&loc);
-
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_tryentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			 char *dom, const char *name, unsigned char *locked_on)
+afr_selfheal_tryentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                        char *dom, const char *name, unsigned char *locked_on)
 {
-	loc_t loc = {0,};
+    loc_t loc = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom,
-		   &loc, name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_entrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-		      char *dom, const char *name, unsigned char *locked_on)
+afr_selfheal_entrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                     char *dom, const char *name, unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	afr_local_t *local = NULL;
-	int i = 0;
-	afr_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
-		   name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->replies[i].op_ret == -1 &&
-		    local->replies[i].op_errno == EAGAIN) {
-			afr_locked_fill (frame, this, locked_on);
-			afr_selfheal_unentrylk (frame, this, inode, dom, name,
-						locked_on, NULL);
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->replies[i].op_ret == -1 &&
+            local->replies[i].op_errno == EAGAIN) {
+            afr_locked_fill(frame, this, locked_on);
+            afr_selfheal_unentrylk(frame, this, inode, dom, name, locked_on,
+                                   NULL);
 
-			AFR_SEQ (frame, afr_selfheal_lock_cbk, entrylk, dom,
-				 &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-			break;
-		}
-	}
+            AFR_SEQ(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+                    ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+            break;
+        }
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
 int
-afr_selfheal_tie_breaker_entrylk (call_frame_t *frame, xlator_t *this,
-                                  inode_t *inode, char *dom, const char *name,
-                                  unsigned char *locked_on)
+afr_selfheal_tie_breaker_entrylk(call_frame_t *frame, xlator_t *this,
+                                 inode_t *inode, char *dom, const char *name,
+                                 unsigned char *locked_on)
 {
-	loc_t loc = {0,};
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int lock_count = 0;
-	int eagain_count = 0;
+    loc_t loc = {
+        0,
+    };
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int lock_count = 0;
+    int eagain_count = 0;
 
-	priv = this->private;
-	local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONALL (frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
-		   name, ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
+    AFR_ONALL(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+              ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL);
 
-        afr_get_lock_and_eagain_counts (priv, local->replies, &lock_count,
-                                        &eagain_count);
+    afr_get_lock_and_eagain_counts(priv, local->replies, &lock_count,
+                                   &eagain_count);
 
-	if (lock_count > priv->child_count/2 && eagain_count) {
-                afr_locked_fill (frame, this, locked_on);
-                afr_selfheal_unentrylk (frame, this, inode, dom, name,
-                                        locked_on, NULL);
+    if (lock_count > priv->child_count / 2 && eagain_count) {
+        afr_locked_fill(frame, this, locked_on);
+        afr_selfheal_unentrylk(frame, this, inode, dom, name, locked_on, NULL);
 
-                AFR_SEQ (frame, afr_selfheal_lock_cbk, entrylk, dom,
-                         &loc, name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
-	}
+        AFR_SEQ(frame, afr_selfheal_lock_cbk, entrylk, dom, &loc, name,
+                ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+    }
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return afr_locked_fill (frame, this, locked_on);
+    return afr_locked_fill(frame, this, locked_on);
 }
 
-
 int
-afr_selfheal_unentrylk (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			char *dom, const char *name, unsigned char *locked_on,
-                        dict_t *xdata)
+afr_selfheal_unentrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                       char *dom, const char *name, unsigned char *locked_on,
+                       dict_t *xdata)
 {
-	loc_t loc = {0,};
+    loc_t loc = {
+        0,
+    };
 
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
 
-	AFR_ONLIST (locked_on, frame, afr_selfheal_lock_cbk, entrylk,
-		    dom, &loc, name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, xdata);
+    AFR_ONLIST(locked_on, frame, afr_selfheal_lock_cbk, entrylk, dom, &loc,
+               name, ENTRYLK_UNLOCK, ENTRYLK_WRLCK, xdata);
 
-	loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_is_data_set (xlator_t *this, dict_t *xdata)
+afr_is_data_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_DATA_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_DATA_TRANSACTION);
 }
 
 gf_boolean_t
-afr_is_metadata_set (xlator_t *this, dict_t *xdata)
+afr_is_metadata_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_METADATA_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_METADATA_TRANSACTION);
 }
 
 gf_boolean_t
-afr_is_entry_set (xlator_t *this, dict_t *xdata)
+afr_is_entry_set(xlator_t *this, dict_t *xdata)
 {
-	return afr_is_pending_set (this, xdata, AFR_ENTRY_TRANSACTION);
+    return afr_is_pending_set(this, xdata, AFR_ENTRY_TRANSACTION);
 }
 
 /*
@@ -2210,317 +2190,307 @@ afr_is_entry_set (xlator_t *this, dict_t *xdata)
  */
 
 int
-afr_selfheal_unlocked_inspect (call_frame_t *frame, xlator_t *this,
-			       uuid_t gfid, inode_t **link_inode,
-			       gf_boolean_t *data_selfheal,
-			       gf_boolean_t *metadata_selfheal,
-			       gf_boolean_t *entry_selfheal)
-{
-	afr_private_t *priv = NULL;
-        inode_t *inode = NULL;
-	int i = 0;
-	int valid_cnt = 0;
-	struct iatt first = {0, };
-        int first_idx = 0;
-	struct afr_reply *replies = NULL;
-	int ret = -1;
-
-	priv = this->private;
-
-        inode = afr_inode_find (this, gfid);
-        if (!inode)
-                goto out;
+afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,
+                              inode_t **link_inode, gf_boolean_t *data_selfheal,
+                              gf_boolean_t *metadata_selfheal,
+                              gf_boolean_t *entry_selfheal)
+{
+    afr_private_t *priv = NULL;
+    inode_t *inode = NULL;
+    int i = 0;
+    int valid_cnt = 0;
+    struct iatt first = {
+        0,
+    };
+    int first_idx = 0;
+    struct afr_reply *replies = NULL;
+    int ret = -1;
+
+    priv = this->private;
+
+    inode = afr_inode_find(this, gfid);
+    if (!inode)
+        goto out;
 
-	replies = alloca0 (sizeof (*replies) * priv->child_count);
+    replies = alloca0(sizeof(*replies) * priv->child_count);
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, gfid, replies);
-	if (ret)
-                goto out;
+    ret = afr_selfheal_unlocked_discover(frame, inode, gfid, replies);
+    if (ret)
+        goto out;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-		if (replies[i].op_ret == -1)
-			continue;
-
-                /* The data segment of the changelog can be non-zero to indicate
-                 * the directory needs a full heal. So the check below ensures
-                 * it's not a directory before setting the data_selfheal boolean.
-                 */
-		if (data_selfheal && !IA_ISDIR (replies[i].poststat.ia_type) &&
-                    afr_is_data_set (this, replies[i].xdata))
-			*data_selfheal = _gf_true;
-
-		if (metadata_selfheal &&
-                    afr_is_metadata_set (this, replies[i].xdata))
-			*metadata_selfheal = _gf_true;
-
-		if (entry_selfheal && afr_is_entry_set (this, replies[i].xdata))
-			*entry_selfheal = _gf_true;
-
-		valid_cnt++;
-		if (valid_cnt == 1) {
-			first = replies[i].poststat;
-                        first_idx = i;
-			continue;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, type)) {
-		        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN,
-				"TYPE mismatch %d vs %d on %s for gfid:%s",
-				(int) first.ia_type,
-				(int) replies[i].poststat.ia_type,
-				priv->children[i]->name,
-				uuid_utoa (replies[i].poststat.ia_gfid));
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;"
-                                "type=file;gfid=%s;"
-                                "ia_type-%d=%s;ia_type-%d=%s",
-                                this->name,
-                                uuid_utoa (replies[i].poststat.ia_gfid),
-                                first_idx,
-                                gf_inode_type_to_str (first.ia_type), i,
-                            gf_inode_type_to_str (replies[i].poststat.ia_type));
-                        ret = -EIO;
-                        goto out;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, uid)) {
-		        gf_msg_debug (this->name, 0,
-				      "UID mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) first.ia_uid,
-				      (int) replies[i].poststat.ia_uid,
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, gid)) {
-		        gf_msg_debug (this->name, 0,
-				      "GID mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) first.ia_uid,
-				      (int) replies[i].poststat.ia_uid,
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (!IA_EQUAL (first, replies[i].poststat, prot)) {
-		        gf_msg_debug (this->name, 0,
-			              "MODE mismatch "
-                                      "%d vs %d on %s for gfid:%s",
-				      (int) st_mode_from_ia (first.ia_prot, 0),
-				      (int) st_mode_from_ia
-                                      (replies[i].poststat.ia_prot, 0),
-				      priv->children[i]->name,
-				      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (metadata_selfheal)
-                                *metadata_selfheal = _gf_true;
-		}
-
-		if (IA_ISREG(first.ia_type) &&
-		    !IA_EQUAL (first, replies[i].poststat, size)) {
-		        gf_msg_debug (this->name, 0,
-                                      "SIZE mismatch "
-                                      "%lld vs %lld on %s for gfid:%s",
-                                      (long long) first.ia_size,
-                                      (long long) replies[i].poststat.ia_size,
-                                      priv->children[i]->name,
-                                      uuid_utoa (replies[i].poststat.ia_gfid));
-
-                        if (data_selfheal)
-                                *data_selfheal = _gf_true;
-		}
-	}
-
-	if (valid_cnt > 0 && link_inode) {
-		*link_inode = inode_link (inode, NULL, NULL, &first);
-                if (!*link_inode) {
-                        ret = -EINVAL;
-                        goto out;
-                }
-        } else if (valid_cnt < 2) {
-                ret = afr_check_stale_error (replies, priv);
-                goto out;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret == -1)
+            continue;
 
-        ret = 0;
+        /* The data segment of the changelog can be non-zero to indicate
+         * the directory needs a full heal. So the check below ensures
+         * it's not a directory before setting the data_selfheal boolean.
+         */
+        if (data_selfheal && !IA_ISDIR(replies[i].poststat.ia_type) &&
+            afr_is_data_set(this, replies[i].xdata))
+            *data_selfheal = _gf_true;
+
+        if (metadata_selfheal && afr_is_metadata_set(this, replies[i].xdata))
+            *metadata_selfheal = _gf_true;
+
+        if (entry_selfheal && afr_is_entry_set(this, replies[i].xdata))
+            *entry_selfheal = _gf_true;
+
+        valid_cnt++;
+        if (valid_cnt == 1) {
+            first = replies[i].poststat;
+            first_idx = i;
+            continue;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, type)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                   "TYPE mismatch %d vs %d on %s for gfid:%s",
+                   (int)first.ia_type, (int)replies[i].poststat.ia_type,
+                   priv->children[i]->name,
+                   uuid_utoa(replies[i].poststat.ia_gfid));
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "subvol=%s;"
+                     "type=file;gfid=%s;"
+                     "ia_type-%d=%s;ia_type-%d=%s",
+                     this->name, uuid_utoa(replies[i].poststat.ia_gfid),
+                     first_idx, gf_inode_type_to_str(first.ia_type), i,
+                     gf_inode_type_to_str(replies[i].poststat.ia_type));
+            ret = -EIO;
+            goto out;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, uid)) {
+            gf_msg_debug(this->name, 0,
+                         "UID mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)first.ia_uid, (int)replies[i].poststat.ia_uid,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, gid)) {
+            gf_msg_debug(this->name, 0,
+                         "GID mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)first.ia_uid, (int)replies[i].poststat.ia_uid,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (!IA_EQUAL(first, replies[i].poststat, prot)) {
+            gf_msg_debug(this->name, 0,
+                         "MODE mismatch "
+                         "%d vs %d on %s for gfid:%s",
+                         (int)st_mode_from_ia(first.ia_prot, 0),
+                         (int)st_mode_from_ia(replies[i].poststat.ia_prot, 0),
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (metadata_selfheal)
+                *metadata_selfheal = _gf_true;
+        }
+
+        if (IA_ISREG(first.ia_type) &&
+            !IA_EQUAL(first, replies[i].poststat, size)) {
+            gf_msg_debug(this->name, 0,
+                         "SIZE mismatch "
+                         "%lld vs %lld on %s for gfid:%s",
+                         (long long)first.ia_size,
+                         (long long)replies[i].poststat.ia_size,
+                         priv->children[i]->name,
+                         uuid_utoa(replies[i].poststat.ia_gfid));
+
+            if (data_selfheal)
+                *data_selfheal = _gf_true;
+        }
+    }
+
+    if (valid_cnt > 0 && link_inode) {
+        *link_inode = inode_link(inode, NULL, NULL, &first);
+        if (!*link_inode) {
+            ret = -EINVAL;
+            goto out;
+        }
+    } else if (valid_cnt < 2) {
+        ret = afr_check_stale_error(replies, priv);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (inode)
-                inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-afr_inode_find (xlator_t *this, uuid_t gfid)
+afr_inode_find(xlator_t *this, uuid_t gfid)
 {
-	inode_table_t *table = NULL;
-	inode_t *inode = NULL;
+    inode_table_t *table = NULL;
+    inode_t *inode = NULL;
 
-	table = this->itable;
-	if (!table)
-		return NULL;
+    table = this->itable;
+    if (!table)
+        return NULL;
 
-	inode = inode_find (table, gfid);
-	if (inode)
-		return inode;
+    inode = inode_find(table, gfid);
+    if (inode)
+        return inode;
 
-	inode = inode_new (table);
-	if (!inode)
-		return NULL;
+    inode = inode_new(table);
+    if (!inode)
+        return NULL;
 
-	gf_uuid_copy (inode->gfid, gfid);
+    gf_uuid_copy(inode->gfid, gfid);
 
-	return inode;
+    return inode;
 }
 
-
 call_frame_t *
-afr_frame_create (xlator_t *this, int32_t *op_errno)
+afr_frame_create(xlator_t *this, int32_t *op_errno)
 {
-	call_frame_t *frame    = NULL;
-	afr_local_t  *local    = NULL;
-	pid_t         pid      = GF_CLIENT_PID_SELF_HEALD;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    pid_t pid = GF_CLIENT_PID_SELF_HEALD;
 
-	frame = create_frame (this, this->ctx->pool);
-	if (!frame)
-		return NULL;
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        return NULL;
 
-	local = AFR_FRAME_INIT (frame, (*op_errno));
-	if (!local) {
-		STACK_DESTROY (frame->root);
-		return NULL;
-	}
+    local = AFR_FRAME_INIT(frame, (*op_errno));
+    if (!local) {
+        STACK_DESTROY(frame->root);
+        return NULL;
+    }
 
-	syncopctx_setfspid (&pid);
+    syncopctx_setfspid(&pid);
 
-	frame->root->pid = pid;
+    frame->root->pid = pid;
 
-	afr_set_lk_owner (frame, this, frame->root);
+    afr_set_lk_owner(frame, this, frame->root);
 
-	return frame;
+    return frame;
 }
 
 int
-afr_selfheal_newentry_mark (call_frame_t *frame, xlator_t *this, inode_t *inode,
-			    int source, struct afr_reply *replies,
-			    unsigned char *sources, unsigned char *newentry)
+afr_selfheal_newentry_mark(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                           int source, struct afr_reply *replies,
+                           unsigned char *sources, unsigned char *newentry)
 {
-	int ret = 0;
-	int i = 0;
-	afr_private_t *priv = NULL;
-	dict_t *xattr = NULL;
-	int **changelog = NULL;
+    int ret = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int **changelog = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	gf_uuid_copy (inode->gfid, replies[source].poststat.ia_gfid);
+    gf_uuid_copy(inode->gfid, replies[source].poststat.ia_gfid);
 
-	xattr = dict_new();
-	if (!xattr)
-		return -ENOMEM;
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
 
-        changelog = afr_mark_pending_changelog (priv, newentry, xattr,
-                                            replies[source].poststat.ia_type);
+    changelog = afr_mark_pending_changelog(priv, newentry, xattr,
+                                           replies[source].poststat.ia_type);
 
-        if (!changelog) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    if (!changelog) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!sources[i])
-			continue;
-		ret |= afr_selfheal_post_op (frame, this, inode, i, xattr,
-                                             NULL);
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        ret |= afr_selfheal_post_op(frame, this, inode, i, xattr, NULL);
+    }
 out:
-        if (changelog)
-                afr_matrix_cleanup (changelog, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
-	return ret;
+    if (changelog)
+        afr_matrix_cleanup(changelog, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
+    return ret;
 }
 
 int
-afr_selfheal_do (call_frame_t *frame, xlator_t *this, uuid_t gfid)
-{
-	int           ret               = -1;
-        int           entry_ret         = 1;
-        int           metadata_ret      = 1;
-        int           data_ret          = 1;
-        int           or_ret            = 0;
-        inode_t      *inode             = NULL;
-        fd_t         *fd                = NULL;
-	gf_boolean_t  data_selfheal     = _gf_false;
-	gf_boolean_t  metadata_selfheal = _gf_false;
-	gf_boolean_t  entry_selfheal    = _gf_false;
-        afr_private_t *priv            = NULL;
-        gf_boolean_t dataheal_enabled   = _gf_false;
-
-        priv = this->private;
-
-        ret = gf_string2boolean (priv->data_self_heal, &dataheal_enabled);
-        if (ret)
-                goto out;
+afr_selfheal_do(call_frame_t *frame, xlator_t *this, uuid_t gfid)
+{
+    int ret = -1;
+    int entry_ret = 1;
+    int metadata_ret = 1;
+    int data_ret = 1;
+    int or_ret = 0;
+    inode_t *inode = NULL;
+    fd_t *fd = NULL;
+    gf_boolean_t data_selfheal = _gf_false;
+    gf_boolean_t metadata_selfheal = _gf_false;
+    gf_boolean_t entry_selfheal = _gf_false;
+    afr_private_t *priv = NULL;
+    gf_boolean_t dataheal_enabled = _gf_false;
+
+    priv = this->private;
+
+    ret = gf_string2boolean(priv->data_self_heal, &dataheal_enabled);
+    if (ret)
+        goto out;
 
-	ret = afr_selfheal_unlocked_inspect (frame, this, gfid, &inode,
-					     &data_selfheal,
-					     &metadata_selfheal,
-					     &entry_selfheal);
-	if (ret)
-		goto out;
+    ret = afr_selfheal_unlocked_inspect(frame, this, gfid, &inode,
+                                        &data_selfheal, &metadata_selfheal,
+                                        &entry_selfheal);
+    if (ret)
+        goto out;
 
-        if (!(data_selfheal || metadata_selfheal || entry_selfheal)) {
-                ret = 2;
-                goto out;
-        }
+    if (!(data_selfheal || metadata_selfheal || entry_selfheal)) {
+        ret = 2;
+        goto out;
+    }
 
-        if (inode->ia_type == IA_IFREG) {
-                ret = afr_selfheal_data_open (this, inode, &fd);
-                if (!fd) {
-                        ret = -EIO;
-                        goto out;
-                }
+    if (inode->ia_type == IA_IFREG) {
+        ret = afr_selfheal_data_open(this, inode, &fd);
+        if (!fd) {
+            ret = -EIO;
+            goto out;
         }
+    }
 
-	if (data_selfheal && dataheal_enabled)
-                data_ret = afr_selfheal_data (frame, this, fd);
+    if (data_selfheal && dataheal_enabled)
+        data_ret = afr_selfheal_data(frame, this, fd);
 
-	if (metadata_selfheal && priv->metadata_self_heal)
-                metadata_ret = afr_selfheal_metadata (frame, this, inode);
+    if (metadata_selfheal && priv->metadata_self_heal)
+        metadata_ret = afr_selfheal_metadata(frame, this, inode);
 
-	if (entry_selfheal && priv->entry_self_heal)
-                entry_ret = afr_selfheal_entry (frame, this, inode);
+    if (entry_selfheal && priv->entry_self_heal)
+        entry_ret = afr_selfheal_entry(frame, this, inode);
 
-        or_ret = (data_ret | metadata_ret | entry_ret);
+    or_ret = (data_ret | metadata_ret | entry_ret);
 
-        if (data_ret == -EIO || metadata_ret == -EIO || entry_ret == -EIO)
-                ret = -EIO;
-        else if (data_ret == 1 && metadata_ret == 1 && entry_ret == 1)
-                ret = 1;
-        else if (or_ret < 0)
-                ret = or_ret;
-        else
-                ret = 0;
+    if (data_ret == -EIO || metadata_ret == -EIO || entry_ret == -EIO)
+        ret = -EIO;
+    else if (data_ret == 1 && metadata_ret == 1 && entry_ret == 1)
+        ret = 1;
+    else if (or_ret < 0)
+        ret = or_ret;
+    else
+        ret = 0;
 
 out:
-        if (inode)
-                inode_unref (inode);
-        if (fd)
-                fd_unref (fd);
-        return ret;
+    if (inode)
+        inode_unref(inode);
+    if (fd)
+        fd_unref(fd);
+    return ret;
 }
 /*
  * This is the entry point for healing a given GFID. The return values for this
@@ -2532,160 +2502,160 @@ out:
  */
 
 int
-afr_selfheal (xlator_t *this, uuid_t gfid)
+afr_selfheal(xlator_t *this, uuid_t gfid)
 {
-        int           ret   = -1;
-	call_frame_t *frame = NULL;
-        afr_local_t *local = NULL;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
 
-	frame = afr_frame_create (this, NULL);
-	if (!frame)
-		return ret;
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        return ret;
 
-        local = frame->local;
-        local->xdata_req = dict_new();
+    local = frame->local;
+    local->xdata_req = dict_new();
 
-        ret = afr_selfheal_do (frame, this, gfid);
+    ret = afr_selfheal_do(frame, this, gfid);
 
-	if (frame)
-		AFR_STACK_DESTROY (frame);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 
-	return ret;
+    return ret;
 }
 
-afr_local_t*
-__afr_dequeue_heals (afr_private_t *priv)
+afr_local_t *
+__afr_dequeue_heals(afr_private_t *priv)
 {
-        afr_local_t *local = NULL;
+    afr_local_t *local = NULL;
 
-        if (list_empty (&priv->heal_waiting))
-                goto none;
-        if ((priv->background_self_heal_count > 0) &&
-            (priv->healers >= priv->background_self_heal_count))
-                goto none;
+    if (list_empty(&priv->heal_waiting))
+        goto none;
+    if ((priv->background_self_heal_count > 0) &&
+        (priv->healers >= priv->background_self_heal_count))
+        goto none;
 
-        local = list_entry (priv->heal_waiting.next, afr_local_t, healer);
-        priv->heal_waiters--;
-        GF_ASSERT (priv->heal_waiters >= 0);
-        list_del_init(&local->healer);
-        list_add(&local->healer, &priv->healing);
-        priv->healers++;
-        return local;
+    local = list_entry(priv->heal_waiting.next, afr_local_t, healer);
+    priv->heal_waiters--;
+    GF_ASSERT(priv->heal_waiters >= 0);
+    list_del_init(&local->healer);
+    list_add(&local->healer, &priv->healing);
+    priv->healers++;
+    return local;
 none:
-        gf_msg_debug (THIS->name, 0, "Nothing dequeued. "
-                      "Num healers: %d, Num Waiters: %d",
-                      priv->healers, priv->heal_waiters);
-        return NULL;
+    gf_msg_debug(THIS->name, 0,
+                 "Nothing dequeued. "
+                 "Num healers: %d, Num Waiters: %d",
+                 priv->healers, priv->heal_waiters);
+    return NULL;
 }
 
 int
-afr_refresh_selfheal_wrap (void *opaque)
+afr_refresh_selfheal_wrap(void *opaque)
 {
-        call_frame_t *heal_frame = opaque;
-        afr_local_t *local = heal_frame->local;
-        int ret = 0;
+    call_frame_t *heal_frame = opaque;
+    afr_local_t *local = heal_frame->local;
+    int ret = 0;
 
-        ret = afr_selfheal (heal_frame->this, local->refreshinode->gfid);
-        return ret;
+    ret = afr_selfheal(heal_frame->this, local->refreshinode->gfid);
+    return ret;
 }
 
 int
-afr_refresh_heal_done (int ret, call_frame_t *frame, void *opaque)
-{
-        call_frame_t *heal_frame = opaque;
-        xlator_t *this = heal_frame->this;
-        afr_private_t *priv = this->private;
-        afr_local_t *local = heal_frame->local;
-
-        LOCK (&priv->lock);
-        {
-                list_del_init(&local->healer);
-                priv->healers--;
-                GF_ASSERT (priv->healers >= 0);
-                local = __afr_dequeue_heals (priv);
-        }
-        UNLOCK (&priv->lock);
+afr_refresh_heal_done(int ret, call_frame_t *frame, void *opaque)
+{
+    call_frame_t *heal_frame = opaque;
+    xlator_t *this = heal_frame->this;
+    afr_private_t *priv = this->private;
+    afr_local_t *local = heal_frame->local;
 
-        AFR_STACK_DESTROY (heal_frame);
+    LOCK(&priv->lock);
+    {
+        list_del_init(&local->healer);
+        priv->healers--;
+        GF_ASSERT(priv->healers >= 0);
+        local = __afr_dequeue_heals(priv);
+    }
+    UNLOCK(&priv->lock);
 
-        if (local)
-                afr_heal_synctask (this, local);
-        return 0;
+    AFR_STACK_DESTROY(heal_frame);
 
+    if (local)
+        afr_heal_synctask(this, local);
+    return 0;
 }
 
 void
-afr_heal_synctask (xlator_t *this, afr_local_t *local)
+afr_heal_synctask(xlator_t *this, afr_local_t *local)
 {
-        int ret = 0;
-        call_frame_t *heal_frame = NULL;
+    int ret = 0;
+    call_frame_t *heal_frame = NULL;
 
-        heal_frame = local->heal_frame;
-        ret = synctask_new (this->ctx->env, afr_refresh_selfheal_wrap,
-                            afr_refresh_heal_done, heal_frame, heal_frame);
-        if (ret < 0)
-                /* Heal not launched. Will be queued when the next inode
-                 * refresh happens and shd hasn't healed it yet. */
-                afr_refresh_heal_done (ret, heal_frame, heal_frame);
+    heal_frame = local->heal_frame;
+    ret = synctask_new(this->ctx->env, afr_refresh_selfheal_wrap,
+                       afr_refresh_heal_done, heal_frame, heal_frame);
+    if (ret < 0)
+        /* Heal not launched. Will be queued when the next inode
+         * refresh happens and shd hasn't healed it yet. */
+        afr_refresh_heal_done(ret, heal_frame, heal_frame);
 }
 
 gf_boolean_t
-afr_throttled_selfheal (call_frame_t *frame, xlator_t *this)
-{
-        gf_boolean_t can_heal = _gf_true;
-        afr_private_t *priv = this->private;
-        afr_local_t *local = frame->local;
-
-        LOCK (&priv->lock);
-        {
-                if ((priv->background_self_heal_count > 0) &&
-                    (priv->heal_wait_qlen + priv->background_self_heal_count) >
-                    (priv->heal_waiters + priv->healers)) {
-                        list_add_tail(&local->healer, &priv->heal_waiting);
-                        priv->heal_waiters++;
-                        local = __afr_dequeue_heals (priv);
-                } else {
-                        can_heal = _gf_false;
-                }
-        }
-        UNLOCK (&priv->lock);
-
-        if (can_heal) {
-                if (local)
-                        afr_heal_synctask (this, local);
-                else
-                        gf_msg_debug (this->name, 0, "Max number of heals are "
-                                      "pending, background self-heal rejected.");
+afr_throttled_selfheal(call_frame_t *frame, xlator_t *this)
+{
+    gf_boolean_t can_heal = _gf_true;
+    afr_private_t *priv = this->private;
+    afr_local_t *local = frame->local;
+
+    LOCK(&priv->lock);
+    {
+        if ((priv->background_self_heal_count > 0) &&
+            (priv->heal_wait_qlen + priv->background_self_heal_count) >
+                (priv->heal_waiters + priv->healers)) {
+            list_add_tail(&local->healer, &priv->heal_waiting);
+            priv->heal_waiters++;
+            local = __afr_dequeue_heals(priv);
+        } else {
+            can_heal = _gf_false;
         }
+    }
+    UNLOCK(&priv->lock);
+
+    if (can_heal) {
+        if (local)
+            afr_heal_synctask(this, local);
+        else
+            gf_msg_debug(this->name, 0,
+                         "Max number of heals are "
+                         "pending, background self-heal rejected.");
+    }
 
-        return can_heal;
+    return can_heal;
 }
 
 int
-afr_choose_source_by_policy (afr_private_t *priv, unsigned char *sources,
-                             afr_transaction_type type)
+afr_choose_source_by_policy(afr_private_t *priv, unsigned char *sources,
+                            afr_transaction_type type)
 {
-        int source = -1;
-        int i      = 0;
+    int source = -1;
+    int i = 0;
 
-        /* Give preference to local child to save on bandwidth */
-        for (i = 0; i < priv->child_count; i++) {
-                if (priv->local[i] && sources[i]) {
-                        if ((type == AFR_DATA_TRANSACTION) &&
-                            AFR_IS_ARBITER_BRICK (priv, i))
-                                continue;
+    /* Give preference to local child to save on bandwidth */
+    for (i = 0; i < priv->child_count; i++) {
+        if (priv->local[i] && sources[i]) {
+            if ((type == AFR_DATA_TRANSACTION) && AFR_IS_ARBITER_BRICK(priv, i))
+                continue;
 
-                        source = i;
-                        goto out;
-                }
+            source = i;
+            goto out;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i]) {
-                        source = i;
-                        goto out;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            goto out;
         }
+    }
 out:
-        return source;
+    return source;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-data.c b/xlators/cluster/afr/src/afr-self-heal-data.c
index c83ef0b7e30..a477fae8039 100644
--- a/xlators/cluster/afr/src/afr-self-heal-data.c
+++ b/xlators/cluster/afr/src/afr-self-heal-data.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "byte-order.h"
@@ -17,596 +16,571 @@
 #include "events.h"
 
 enum {
-	AFR_SELFHEAL_DATA_FULL = 0,
-	AFR_SELFHEAL_DATA_DIFF,
+    AFR_SELFHEAL_DATA_FULL = 0,
+    AFR_SELFHEAL_DATA_DIFF,
 };
 
-
 #define HAS_HOLES(i) ((i->ia_blocks * 512) < (i->ia_size))
 static int
-__checksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int op_ret, int op_errno, uint32_t weak, uint8_t *strong,
-		dict_t *xdata)
+__checksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, uint32_t weak, uint8_t *strong, dict_t *xdata)
 {
-	afr_local_t *local = NULL;
-        struct afr_reply *replies = NULL;
-	int i = (long) cookie;
-
-	local = frame->local;
-        replies = local->replies;
-
-	replies[i].valid = 1;
-	replies[i].op_ret = op_ret;
-	replies[i].op_errno = op_errno;
-        if (xdata) {
-                replies[i].buf_has_zeroes = dict_get_str_boolean (xdata,
-                                                   "buf-has-zeroes", _gf_false);
-                replies[i].fips_mode_rchecksum = dict_get_str_boolean (xdata,
-                                              "fips-mode-rchecksum", _gf_false);
-        }
-	if (strong) {
-                if (replies[i].fips_mode_rchecksum) {
-                        memcpy (local->replies[i].checksum, strong,
-                                SHA256_DIGEST_LENGTH);
-                } else {
-                        memcpy (local->replies[i].checksum, strong,
-                                MD5_DIGEST_LENGTH);
-                }
+    afr_local_t *local = NULL;
+    struct afr_reply *replies = NULL;
+    int i = (long)cookie;
+
+    local = frame->local;
+    replies = local->replies;
+
+    replies[i].valid = 1;
+    replies[i].op_ret = op_ret;
+    replies[i].op_errno = op_errno;
+    if (xdata) {
+        replies[i].buf_has_zeroes = dict_get_str_boolean(
+            xdata, "buf-has-zeroes", _gf_false);
+        replies[i].fips_mode_rchecksum = dict_get_str_boolean(
+            xdata, "fips-mode-rchecksum", _gf_false);
+    }
+    if (strong) {
+        if (replies[i].fips_mode_rchecksum) {
+            memcpy(local->replies[i].checksum, strong, SHA256_DIGEST_LENGTH);
+        } else {
+            memcpy(local->replies[i].checksum, strong, MD5_DIGEST_LENGTH);
         }
+    }
 
-	syncbarrier_wake (&local->barrier);
-	return 0;
+    syncbarrier_wake(&local->barrier);
+    return 0;
 }
 
 static gf_boolean_t
-__afr_can_skip_data_block_heal (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                                int source, unsigned char *healed_sinks,
-				off_t offset, size_t size,
-                                struct iatt *poststat)
+__afr_can_skip_data_block_heal(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               int source, unsigned char *healed_sinks,
+                               off_t offset, size_t size, struct iatt *poststat)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	unsigned char *wind_subvols = NULL;
-        gf_boolean_t checksum_match = _gf_true;
-        struct afr_reply *replies = NULL;
-        dict_t *xdata = NULL;
-	int i = 0;
-
-	priv = this->private;
-	local = frame->local;
-        replies = local->replies;
-
-        xdata = dict_new();
-        if (!xdata)
-                goto out;
-        if (dict_set_int32 (xdata, "check-zero-filled", 1)) {
-                dict_unref (xdata);
-                goto out;
-        }
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    unsigned char *wind_subvols = NULL;
+    gf_boolean_t checksum_match = _gf_true;
+    struct afr_reply *replies = NULL;
+    dict_t *xdata = NULL;
+    int i = 0;
+
+    priv = this->private;
+    local = frame->local;
+    replies = local->replies;
+
+    xdata = dict_new();
+    if (!xdata)
+        goto out;
+    if (dict_set_int32(xdata, "check-zero-filled", 1)) {
+        dict_unref(xdata);
+        goto out;
+    }
+
+    wind_subvols = alloca0(priv->child_count);
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || healed_sinks[i])
+            wind_subvols[i] = 1;
+    }
+
+    AFR_ONLIST(wind_subvols, frame, __checksum_cbk, rchecksum, fd, offset, size,
+               xdata);
+    if (xdata)
+        dict_unref(xdata);
+
+    if (!replies[source].valid || replies[source].op_ret != 0)
+        return _gf_false;
 
-	wind_subvols = alloca0 (priv->child_count);
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source || healed_sinks[i])
-			wind_subvols[i] = 1;
-	}
-
-	AFR_ONLIST (wind_subvols, frame, __checksum_cbk, rchecksum, fd,
-		    offset, size, xdata);
-        if (xdata)
-                dict_unref (xdata);
-
-	if (!replies[source].valid || replies[source].op_ret != 0)
-		return _gf_false;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source)
-			continue;
-                if (replies[i].valid) {
-                        if (memcmp (replies[source].checksum,
-                                    replies[i].checksum,
-                                    replies[source].fips_mode_rchecksum ?
-                                    SHA256_DIGEST_LENGTH : MD5_DIGEST_LENGTH)) {
-                                checksum_match = _gf_false;
-                                break;
-                        }
-                }
-	}
-
-        if (checksum_match) {
-                if (HAS_HOLES (poststat))
-                        return _gf_true;
-
-                /* For non-sparse files, we might be better off writing the
-                 * zeroes to sinks to avoid mismatch of disk-usage in bricks. */
-                if (local->replies[source].buf_has_zeroes)
-                        return _gf_false;
-                else
-                        return _gf_true;
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source)
+            continue;
+        if (replies[i].valid) {
+            if (memcmp(replies[source].checksum, replies[i].checksum,
+                       replies[source].fips_mode_rchecksum
+                           ? SHA256_DIGEST_LENGTH
+                           : MD5_DIGEST_LENGTH)) {
+                checksum_match = _gf_false;
+                break;
+            }
         }
+    }
+
+    if (checksum_match) {
+        if (HAS_HOLES(poststat))
+            return _gf_true;
+
+        /* For non-sparse files, we might be better off writing the
+         * zeroes to sinks to avoid mismatch of disk-usage in bricks. */
+        if (local->replies[source].buf_has_zeroes)
+            return _gf_false;
+        else
+            return _gf_true;
+    }
 out:
-        return _gf_false;
+    return _gf_false;
 }
 
-
 static gf_boolean_t
-__afr_is_sink_zero_filled (xlator_t *this, fd_t *fd, size_t size,
-                           off_t offset, int sink)
+__afr_is_sink_zero_filled(xlator_t *this, fd_t *fd, size_t size, off_t offset,
+                          int sink)
 {
-        afr_private_t *priv   = NULL;
-        struct iobref *iobref = NULL;
-        struct iovec  *iovec  = NULL;
-        int            count  = 0;
-        int            ret    = 0;
-        gf_boolean_t   zero_filled   = _gf_false;
-
-        priv = this->private;
-        ret = syncop_readv (priv->children[sink], fd, size, offset, 0, &iovec,
-                            &count, &iobref, NULL, NULL, NULL);
-        if (ret < 0)
-                goto out;
-        ret = iov_0filled (iovec, count);
-        if (!ret)
-                zero_filled = _gf_true;
+    afr_private_t *priv = NULL;
+    struct iobref *iobref = NULL;
+    struct iovec *iovec = NULL;
+    int count = 0;
+    int ret = 0;
+    gf_boolean_t zero_filled = _gf_false;
+
+    priv = this->private;
+    ret = syncop_readv(priv->children[sink], fd, size, offset, 0, &iovec,
+                       &count, &iobref, NULL, NULL, NULL);
+    if (ret < 0)
+        goto out;
+    ret = iov_0filled(iovec, count);
+    if (!ret)
+        zero_filled = _gf_true;
 out:
-        if (iovec)
-                GF_FREE (iovec);
-        if (iobref)
-                iobref_unref (iobref);
-        return zero_filled;
+    if (iovec)
+        GF_FREE(iovec);
+    if (iobref)
+        iobref_unref(iobref);
+    return zero_filled;
 }
 
 static int
-__afr_selfheal_data_read_write (call_frame_t *frame, xlator_t *this, fd_t *fd,
-				int source, unsigned char *healed_sinks,
-				off_t offset, size_t size,
-				struct afr_reply *replies, int type)
+__afr_selfheal_data_read_write(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               int source, unsigned char *healed_sinks,
+                               off_t offset, size_t size,
+                               struct afr_reply *replies, int type)
 {
-	struct iovec *iovec = NULL;
-	int count = 0;
-	struct iobref *iobref = NULL;
-	int ret = 0;
-	int i = 0;
-	afr_private_t *priv = NULL;
-
-	priv = this->private;
-
-	ret = syncop_readv (priv->children[source], fd, size, offset, 0,
-                           &iovec, &count, &iobref, NULL, NULL, NULL);
-	if (ret <= 0)
-		return ret;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!healed_sinks[i])
-			continue;
-
-		/*
-		 * TODO: Use fiemap() and discard() to heal holes
-		 * in the future.
-		 *
-		 * For now,
-		 *
-		 * - if the source had any holes at all,
-		 * AND
-		 * - if we are writing past the original file size
-		 *   of the sink
-		 * AND
-		 * - is NOT the last block of the source file. if
-		 *   the block contains EOF, it has to be written
-		 *   in order to set the file size even if the
-		 *   last block is 0-filled.
-		 * AND
-		 * - if the read buffer is filled with only 0's
-		 *
-		 * then, skip writing to this source. We don't depend
-		 * on the write to happen to update the size as we
-		 * have performed an ftruncate() upfront anyways.
-		 */
-#define is_last_block(o,b,s) ((s >= o) && (s <= (o + b)))
-		if (HAS_HOLES ((&replies[source].poststat)) &&
-		    offset >= replies[i].poststat.ia_size &&
-		    !is_last_block (offset, size,
-				    replies[source].poststat.ia_size) &&
-		    (iov_0filled (iovec, count) == 0))
-			continue;
-
-                /* Avoid filling up sparse regions of the sink with 0-filled
-                 * writes.*/
-                if (type == AFR_SELFHEAL_DATA_FULL &&
-                    HAS_HOLES ((&replies[source].poststat)) &&
-                    ((offset + size) <= replies[i].poststat.ia_size) &&
-                    (iov_0filled (iovec, count) == 0) &&
-                    __afr_is_sink_zero_filled (this, fd, size, offset, i)) {
-                                continue;
-                }
-
-		ret = syncop_writev (priv->children[i], fd, iovec, count,
-                                    offset, iobref, 0, NULL, NULL, NULL, NULL);
-		if (ret != iov_length (iovec, count)) {
-			/* write() failed on this sink. unset the corresponding
-			   member in sinks[] (which is healed_sinks[] in the
-			   caller) so that this server does NOT get considered
-			   as successfully healed.
-			*/
-			healed_sinks[i] = 0;
-		}
-	}
-        if (iovec)
-                GF_FREE (iovec);
-	if (iobref)
-		iobref_unref (iobref);
-
-	return ret;
+    struct iovec *iovec = NULL;
+    int count = 0;
+    struct iobref *iobref = NULL;
+    int ret = 0;
+    int i = 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    ret = syncop_readv(priv->children[source], fd, size, offset, 0, &iovec,
+                       &count, &iobref, NULL, NULL, NULL);
+    if (ret <= 0)
+        return ret;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
+
+            /*
+             * TODO: Use fiemap() and discard() to heal holes
+             * in the future.
+             *
+             * For now,
+             *
+             * - if the source had any holes at all,
+             * AND
+             * - if we are writing past the original file size
+             *   of the sink
+             * AND
+             * - is NOT the last block of the source file. if
+             *   the block contains EOF, it has to be written
+             *   in order to set the file size even if the
+             *   last block is 0-filled.
+             * AND
+             * - if the read buffer is filled with only 0's
+             *
+             * then, skip writing to this source. We don't depend
+             * on the write to happen to update the size as we
+             * have performed an ftruncate() upfront anyways.
+             */
+#define is_last_block(o, b, s) ((s >= o) && (s <= (o + b)))
+        if (HAS_HOLES((&replies[source].poststat)) &&
+            offset >= replies[i].poststat.ia_size &&
+            !is_last_block(offset, size, replies[source].poststat.ia_size) &&
+            (iov_0filled(iovec, count) == 0))
+            continue;
+
+        /* Avoid filling up sparse regions of the sink with 0-filled
+         * writes.*/
+        if (type == AFR_SELFHEAL_DATA_FULL &&
+            HAS_HOLES((&replies[source].poststat)) &&
+            ((offset + size) <= replies[i].poststat.ia_size) &&
+            (iov_0filled(iovec, count) == 0) &&
+            __afr_is_sink_zero_filled(this, fd, size, offset, i)) {
+            continue;
+        }
+
+        ret = syncop_writev(priv->children[i], fd, iovec, count, offset, iobref,
+                            0, NULL, NULL, NULL, NULL);
+        if (ret != iov_length(iovec, count)) {
+            /* write() failed on this sink. unset the corresponding
+               member in sinks[] (which is healed_sinks[] in the
+               caller) so that this server does NOT get considered
+               as successfully healed.
+            */
+            healed_sinks[i] = 0;
+        }
+    }
+    if (iovec)
+        GF_FREE(iovec);
+    if (iobref)
+        iobref_unref(iobref);
+
+    return ret;
 }
 
 static int
-afr_selfheal_data_block (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			 int source, unsigned char *healed_sinks, off_t offset,
-			 size_t size, int type, struct afr_reply *replies)
+afr_selfheal_data_block(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        int source, unsigned char *healed_sinks, off_t offset,
+                        size_t size, int type, struct afr_reply *replies)
 {
-	int ret = -1;
-	int sink_count = 0;
-	afr_private_t *priv = NULL;
-	unsigned char *data_lock = NULL;
-
-	priv = this->private;
-	sink_count = AFR_COUNT (healed_sinks, priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name,
-				    offset, size, data_lock);
-	{
-		if (ret < sink_count) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		if (type == AFR_SELFHEAL_DATA_DIFF &&
-		    __afr_can_skip_data_block_heal (frame, this, fd, source,
-					            healed_sinks, offset, size,
-                                                   &replies[source].poststat)) {
-			ret = 0;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data_read_write (frame, this, fd, source,
-						      healed_sinks, offset, size,
-						      replies, type);
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name,
-				offset, size, data_lock);
-	return ret;
-}
+    int ret = -1;
+    int sink_count = 0;
+    afr_private_t *priv = NULL;
+    unsigned char *data_lock = NULL;
+
+    priv = this->private;
+    sink_count = AFR_COUNT(healed_sinks, priv->child_count);
+    data_lock = alloca0(priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, offset, size,
+                               data_lock);
+    {
+        if (ret < sink_count) {
+            ret = -ENOTCONN;
+            goto unlock;
+        }
 
+        if (type == AFR_SELFHEAL_DATA_DIFF &&
+            __afr_can_skip_data_block_heal(frame, this, fd, source,
+                                           healed_sinks, offset, size,
+                                           &replies[source].poststat)) {
+            ret = 0;
+            goto unlock;
+        }
 
+        ret = __afr_selfheal_data_read_write(
+            frame, this, fd, source, healed_sinks, offset, size, replies, type);
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, offset, size,
+                           data_lock);
+    return ret;
+}
 
 static int
-afr_selfheal_data_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			 unsigned char *healed_sinks)
+afr_selfheal_data_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                        unsigned char *healed_sinks)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-        if (!priv->ensure_durability)
-                return 0;
-
-	AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, fsync, fd, 0,
-                    NULL);
-
-	for (i = 0; i < priv->child_count; i++)
-		if (healed_sinks[i] && local->replies[i].op_ret != 0)
-			/* fsync() failed. Do NOT consider this server
-			   as successfully healed. Mark it so.
-			*/
-			healed_sinks[i] = 0;
-	return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (!priv->ensure_durability)
+        return 0;
+
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, fsync, fd, 0, NULL);
+
+    for (i = 0; i < priv->child_count; i++)
+        if (healed_sinks[i] && local->replies[i].op_ret != 0)
+            /* fsync() failed. Do NOT consider this server
+               as successfully healed. Mark it so.
+            */
+            healed_sinks[i] = 0;
+    return 0;
 }
 
 static int
-afr_data_self_heal_type_get (afr_private_t *priv, unsigned char *healed_sinks,
-                             int source, struct afr_reply *replies)
+afr_data_self_heal_type_get(afr_private_t *priv, unsigned char *healed_sinks,
+                            int source, struct afr_reply *replies)
 {
-        int type = AFR_SELFHEAL_DATA_FULL;
-        int i = 0;
-
-        if (priv->data_self_heal_algorithm == NULL) {
-                type = AFR_SELFHEAL_DATA_FULL;
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!healed_sinks[i] && i != source)
-                                continue;
-                        if (replies[i].poststat.ia_size) {
-                                type = AFR_SELFHEAL_DATA_DIFF;
-                                break;
-                        }
-                }
-        } else if (strcmp (priv->data_self_heal_algorithm, "full") == 0) {
-                type = AFR_SELFHEAL_DATA_FULL;
-        } else if (strcmp (priv->data_self_heal_algorithm, "diff") == 0) {
+    int type = AFR_SELFHEAL_DATA_FULL;
+    int i = 0;
+
+    if (priv->data_self_heal_algorithm == NULL) {
+        type = AFR_SELFHEAL_DATA_FULL;
+        for (i = 0; i < priv->child_count; i++) {
+            if (!healed_sinks[i] && i != source)
+                continue;
+            if (replies[i].poststat.ia_size) {
                 type = AFR_SELFHEAL_DATA_DIFF;
+                break;
+            }
         }
-        return type;
+    } else if (strcmp(priv->data_self_heal_algorithm, "full") == 0) {
+        type = AFR_SELFHEAL_DATA_FULL;
+    } else if (strcmp(priv->data_self_heal_algorithm, "diff") == 0) {
+        type = AFR_SELFHEAL_DATA_DIFF;
+    }
+    return type;
 }
 
 static int
-afr_selfheal_data_do (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		      int source, unsigned char *healed_sinks,
-		      struct afr_reply *replies)
+afr_selfheal_data_do(call_frame_t *frame, xlator_t *this, fd_t *fd, int source,
+                     unsigned char *healed_sinks, struct afr_reply *replies)
 {
-	afr_private_t *priv = NULL;
-	off_t off = 0;
-	size_t block = 0;
-	int type = AFR_SELFHEAL_DATA_FULL;
-	int ret = -1;
-	call_frame_t *iter_frame = NULL;
-        unsigned char arbiter_sink_status = 0;
-
-	priv = this->private;
-        if (priv->arbiter_count) {
-                arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
-                healed_sinks[ARBITER_BRICK_INDEX] = 0;
+    afr_private_t *priv = NULL;
+    off_t off = 0;
+    size_t block = 0;
+    int type = AFR_SELFHEAL_DATA_FULL;
+    int ret = -1;
+    call_frame_t *iter_frame = NULL;
+    unsigned char arbiter_sink_status = 0;
+
+    priv = this->private;
+    if (priv->arbiter_count) {
+        arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
+        healed_sinks[ARBITER_BRICK_INDEX] = 0;
+    }
+
+    block = 128 * 1024 * priv->data_self_heal_window_size;
+
+    type = afr_data_self_heal_type_get(priv, healed_sinks, source, replies);
+
+    iter_frame = afr_copy_frame(frame);
+    if (!iter_frame) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    for (off = 0; off < replies[source].poststat.ia_size; off += block) {
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            ret = -ENOTCONN;
+            goto out;
         }
 
-        block = 128 * 1024 * priv->data_self_heal_window_size;
-
-        type = afr_data_self_heal_type_get (priv, healed_sinks, source,
-                                            replies);
+        ret = afr_selfheal_data_block(iter_frame, this, fd, source,
+                                      healed_sinks, off, block, type, replies);
+        if (ret < 0)
+            goto out;
 
-	iter_frame = afr_copy_frame (frame);
-	if (!iter_frame) {
-                ret = -ENOMEM;
-                goto out;
+        AFR_STACK_RESET(iter_frame);
+        if (iter_frame->local == NULL) {
+            ret = -ENOTCONN;
+            goto out;
         }
+    }
 
-	for (off = 0; off < replies[source].poststat.ia_size; off += block) {
-                if (AFR_COUNT (healed_sinks, priv->child_count) == 0) {
-                        ret = -ENOTCONN;
-                        goto out;
-                }
-
-		ret = afr_selfheal_data_block (iter_frame, this, fd, source,
-					       healed_sinks, off, block, type,
-					       replies);
-		if (ret < 0)
-			goto out;
-
-		AFR_STACK_RESET (iter_frame);
-		if (iter_frame->local == NULL) {
-		        ret = -ENOTCONN;
-		        goto out;
-                }
-	}
-
-	ret = afr_selfheal_data_fsync (frame, this, fd, healed_sinks);
+    ret = afr_selfheal_data_fsync(frame, this, fd, healed_sinks);
 
 out:
-        if (arbiter_sink_status)
-                healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
+    if (arbiter_sink_status)
+        healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
 
-	if (iter_frame)
-		AFR_STACK_DESTROY (iter_frame);
-	return ret;
+    if (iter_frame)
+        AFR_STACK_DESTROY(iter_frame);
+    return ret;
 }
 
-
 static int
-__afr_selfheal_truncate_sinks (call_frame_t *frame, xlator_t *this,
-			       fd_t *fd, unsigned char *healed_sinks,
-			       uint64_t size)
+__afr_selfheal_truncate_sinks(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                              unsigned char *healed_sinks, uint64_t size)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        unsigned char arbiter_sink_status = 0;
-	int i = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-        if (priv->arbiter_count) {
-                arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
-                healed_sinks[ARBITER_BRICK_INDEX] = 0;
-        }
-
-	AFR_ONLIST (healed_sinks, frame, afr_sh_generic_fop_cbk, ftruncate, fd,
-                    size, NULL);
-
-	for (i = 0; i < priv->child_count; i++)
-		if (healed_sinks[i] && local->replies[i].op_ret == -1)
-			/* truncate() failed. Do NOT consider this server
-			   as successfully healed. Mark it so.
-			*/
-			healed_sinks[i] = 0;
-
-        if (arbiter_sink_status)
-                healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
-	return 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    unsigned char arbiter_sink_status = 0;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    if (priv->arbiter_count) {
+        arbiter_sink_status = healed_sinks[ARBITER_BRICK_INDEX];
+        healed_sinks[ARBITER_BRICK_INDEX] = 0;
+    }
+
+    AFR_ONLIST(healed_sinks, frame, afr_sh_generic_fop_cbk, ftruncate, fd, size,
+               NULL);
+
+    for (i = 0; i < priv->child_count; i++)
+        if (healed_sinks[i] && local->replies[i].op_ret == -1)
+            /* truncate() failed. Do NOT consider this server
+               as successfully healed. Mark it so.
+            */
+            healed_sinks[i] = 0;
+
+    if (arbiter_sink_status)
+        healed_sinks[ARBITER_BRICK_INDEX] = arbiter_sink_status;
+    return 0;
 }
 
 gf_boolean_t
-afr_has_source_witnesses (xlator_t *this, unsigned char *sources,
-                          uint64_t *witness)
+afr_has_source_witnesses(xlator_t *this, unsigned char *sources,
+                         uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i] && witness[i])
-                        return _gf_true;
-        }
-        return _gf_false;
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i] && witness[i])
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_does_size_mismatch (xlator_t *this, unsigned char *sources,
-                        struct afr_reply *replies)
+afr_does_size_mismatch(xlator_t *this, unsigned char *sources,
+                       struct afr_reply *replies)
 {
-        int     i = 0;
-        afr_private_t *priv = NULL;
-        struct iatt *min = NULL;
-        struct iatt *max = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    struct iatt *min = NULL;
+    struct iatt *max = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if (replies[i].op_ret < 0)
-                        continue;
+        if (replies[i].op_ret < 0)
+            continue;
 
-                if (!sources[i])
-                        continue;
+        if (!sources[i])
+            continue;
 
-                if (AFR_IS_ARBITER_BRICK (priv, i) &&
-                    (replies[i].poststat.ia_size == 0))
-                        continue;
+        if (AFR_IS_ARBITER_BRICK(priv, i) && (replies[i].poststat.ia_size == 0))
+            continue;
 
-                if (!min)
-                        min = &replies[i].poststat;
+        if (!min)
+            min = &replies[i].poststat;
 
-                if (!max)
-                        max = &replies[i].poststat;
+        if (!max)
+            max = &replies[i].poststat;
 
-                if (min->ia_size > replies[i].poststat.ia_size)
-                        min = &replies[i].poststat;
+        if (min->ia_size > replies[i].poststat.ia_size)
+            min = &replies[i].poststat;
 
-                if (max->ia_size < replies[i].poststat.ia_size)
-                        max = &replies[i].poststat;
-        }
+        if (max->ia_size < replies[i].poststat.ia_size)
+            max = &replies[i].poststat;
+    }
 
-        if (min && max) {
-                if (min->ia_size != max->ia_size)
-                        return _gf_true;
-        }
+    if (min && max) {
+        if (min->ia_size != max->ia_size)
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static void
-afr_mark_biggest_witness_as_source (xlator_t *this, unsigned char *sources,
-                                    uint64_t *witness)
+afr_mark_biggest_witness_as_source(xlator_t *this, unsigned char *sources,
+                                   uint64_t *witness)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        uint64_t biggest_witness = 0;
-
-        priv = this->private;
-        /* Find source with biggest witness count */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (biggest_witness < witness[i])
-                        biggest_witness = witness[i];
-        }
-
-        /* Mark files with less witness count as not source */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-                if (witness[i] < biggest_witness)
-                        sources[i] = 0;
-        }
-
-        return;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    uint64_t biggest_witness = 0;
+
+    priv = this->private;
+    /* Find source with biggest witness count */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (biggest_witness < witness[i])
+            biggest_witness = witness[i];
+    }
+
+    /* Mark files with less witness count as not source */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+        if (witness[i] < biggest_witness)
+            sources[i] = 0;
+    }
+
+    return;
 }
 
 /* This is a tie breaker function. Only one source be assigned here */
 static void
-afr_mark_newest_file_as_source (xlator_t *this, unsigned char *sources,
-                                struct afr_reply *replies)
+afr_mark_newest_file_as_source(xlator_t *this, unsigned char *sources,
+                               struct afr_reply *replies)
 {
-        int i = 0;
-        afr_private_t *priv = NULL;
-        int source = -1;
-        uint32_t max_ctime = 0;
-
-        priv = this->private;
-        /* Find source with latest ctime */
-        for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
-
-                if (max_ctime <= replies[i].poststat.ia_ctime) {
-                        source = i;
-                        max_ctime = replies[i].poststat.ia_ctime;
-                }
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    uint32_t max_ctime = 0;
+
+    priv = this->private;
+    /* Find source with latest ctime */
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
+
+        if (max_ctime <= replies[i].poststat.ia_ctime) {
+            source = i;
+            max_ctime = replies[i].poststat.ia_ctime;
         }
+    }
 
-        /* Only mark one of the files as source to break ties */
-        memset (sources, 0, sizeof (*sources) * priv->child_count);
-        sources[source] = 1;
+    /* Only mark one of the files as source to break ties */
+    memset(sources, 0, sizeof(*sources) * priv->child_count);
+    sources[source] = 1;
 }
 
 static int
-__afr_selfheal_data_finalize_source (call_frame_t *frame, xlator_t *this,
-                                     inode_t *inode,
-                                     unsigned char *sources,
-                                     unsigned char *sinks,
-				     unsigned char *healed_sinks,
-				     unsigned char *locked_on,
-				     unsigned char *undid_pending,
-				     struct afr_reply *replies,
-                                     uint64_t *witness)
+__afr_selfheal_data_finalize_source(
+    call_frame_t *frame, xlator_t *this, inode_t *inode, unsigned char *sources,
+    unsigned char *sinks, unsigned char *healed_sinks, unsigned char *locked_on,
+    unsigned char *undid_pending, struct afr_reply *replies, uint64_t *witness)
 {
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count) {
-		/* split brain */
-                source = afr_mark_split_brain_source_sinks (frame, this, inode,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                          AFR_DATA_TRANSACTION);
-                if (source < 0) {
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=data;"
-                                 "file=%s", this->name, uuid_utoa(inode->gfid));
-                        return -EIO;
-                }
-
-                _afr_fav_child_reset_sink_xattrs (frame, this, inode, source,
-                                                 healed_sinks, undid_pending,
-                                                 AFR_DATA_TRANSACTION,
-                                                 locked_on, replies);
-                goto out;
-	}
-
-        /* No split brain at this point. If we were called from
-         * afr_heal_splitbrain_file(), abort.*/
-        if (afr_dict_contains_heal_op(frame))
-                return -EIO;
-
-        /* If there are no witnesses/size-mismatches on sources we are done*/
-        if (!afr_does_size_mismatch (this, sources, replies) &&
-            !afr_has_source_witnesses (this, sources, witness))
-                goto out;
-
-        afr_mark_largest_file_as_source (this, sources, replies);
-        afr_mark_biggest_witness_as_source (this, sources, witness);
-        afr_mark_newest_file_as_source (this, sources, replies);
-        if (priv->arbiter_count)
-                /* Choose non-arbiter brick as source for empty files. */
-                afr_mark_source_sinks_if_file_empty (this, sources, sinks,
-                                                     healed_sinks, locked_on,
-                                                     replies,
-                                                     AFR_DATA_TRANSACTION);
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count) {
+        /* split brain */
+        source = afr_mark_split_brain_source_sinks(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, AFR_DATA_TRANSACTION);
+        if (source < 0) {
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "subvol=%s;type=data;"
+                     "file=%s",
+                     this->name, uuid_utoa(inode->gfid));
+            return -EIO;
+        }
+
+        _afr_fav_child_reset_sink_xattrs(
+            frame, this, inode, source, healed_sinks, undid_pending,
+            AFR_DATA_TRANSACTION, locked_on, replies);
+        goto out;
+    }
+
+    /* No split brain at this point. If we were called from
+     * afr_heal_splitbrain_file(), abort.*/
+    if (afr_dict_contains_heal_op(frame))
+        return -EIO;
+
+    /* If there are no witnesses/size-mismatches on sources we are done*/
+    if (!afr_does_size_mismatch(this, sources, replies) &&
+        !afr_has_source_witnesses(this, sources, witness))
+        goto out;
+
+    afr_mark_largest_file_as_source(this, sources, replies);
+    afr_mark_biggest_witness_as_source(this, sources, witness);
+    afr_mark_newest_file_as_source(this, sources, replies);
+    if (priv->arbiter_count)
+        /* Choose non-arbiter brick as source for empty files. */
+        afr_mark_source_sinks_if_file_empty(this, sources, sinks, healed_sinks,
+                                            locked_on, replies,
+                                            AFR_DATA_TRANSACTION);
 
 out:
-        afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_DATA_TRANSACTION);
+    afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+    source = afr_choose_source_by_policy(priv, sources, AFR_DATA_TRANSACTION);
 
-	return source;
+    return source;
 }
 
 /*
@@ -619,296 +593,287 @@ out:
  * for self-healing, or -1 if no healing is necessary/split brain.
  */
 int
-__afr_selfheal_data_prepare (call_frame_t *frame, xlator_t *this,
-                             inode_t *inode, unsigned char *locked_on,
-                             unsigned char *sources, unsigned char *sinks,
-                             unsigned char *healed_sinks,
-                             unsigned char *undid_pending,
-			     struct afr_reply *replies, gf_boolean_t *pflag)
+__afr_selfheal_data_prepare(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                            unsigned char *locked_on, unsigned char *sources,
+                            unsigned char *sinks, unsigned char *healed_sinks,
+                            unsigned char *undid_pending,
+                            struct afr_reply *replies, gf_boolean_t *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        uint64_t *witness = NULL;
-
-	priv = this->private;
-
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-
-        if (ret)
-                return ret;
-
-        witness = alloca0(priv->child_count * sizeof (*witness));
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_DATA_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_data_finalize_source (frame, this, inode,
-                                                      sources, sinks,
-                                                      healed_sinks,
-                                                      locked_on, undid_pending,
-                                                      replies, witness);
-	if (source < 0)
-		return -EIO;
-
-	return source;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
+
+    priv = this->private;
+
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+
+    if (ret)
+        return ret;
+
+    witness = alloca0(priv->child_count * sizeof(*witness));
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_DATA_TRANSACTION, locked_on, sources,
+                                      sinks, witness, pflag);
+    if (ret)
+        return ret;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    source = __afr_selfheal_data_finalize_source(
+        frame, this, inode, sources, sinks, healed_sinks, locked_on,
+        undid_pending, replies, witness);
+    if (source < 0)
+        return -EIO;
+
+    return source;
 }
 
-
 static int
-__afr_selfheal_data (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		     unsigned char *locked_on)
+__afr_selfheal_data(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    unsigned char *locked_on)
 {
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *data_lock = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *undid_pending = NULL;
-	struct afr_reply *locked_replies = NULL;
-	int source = -1;
-        gf_boolean_t did_sh = _gf_true;
-        gf_boolean_t is_arbiter_the_only_sink = _gf_false;
-        gf_boolean_t empty_file = _gf_false;
-
-	priv = this->private;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-        undid_pending = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name, 0, 0,
-				    data_lock);
-	{
-		if (ret < priv->child_count) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "self-heal as only %d number "
-                                      "of subvolumes "
-                                      "could be locked",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data_prepare (frame, this, fd->inode,
-                                                   data_lock, sources, sinks,
-                                                   healed_sinks, undid_pending,
-                                                   locked_replies, NULL);
-		if (ret < 0)
-			goto unlock;
-
-                if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-		source = ret;
-
-                if (AFR_IS_ARBITER_BRICK(priv, source)) {
-                        empty_file = afr_is_file_empty_on_all_children (priv,
-                                                                locked_replies);
-                        if (empty_file)
-                                goto restore_time;
-
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                if (priv->arbiter_count &&
-                    AFR_COUNT (healed_sinks, priv->child_count) == 1 &&
-                    healed_sinks[ARBITER_BRICK_INDEX]) {
-                        is_arbiter_the_only_sink = _gf_true;
-                        goto restore_time;
-                }
-
-		ret = __afr_selfheal_truncate_sinks (frame, this, fd, healed_sinks,
-						     locked_replies[source].poststat.ia_size);
-		if (ret < 0)
-			goto unlock;
-
-		ret = 0;
-
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name, 0, 0,
-				data_lock);
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    int source = -1;
+    gf_boolean_t did_sh = _gf_true;
+    gf_boolean_t is_arbiter_the_only_sink = _gf_false;
+    gf_boolean_t empty_file = _gf_false;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, 0, 0,
+                               data_lock);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "self-heal as only %d number "
+                         "of subvolumes "
+                         "could be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_data_prepare(frame, this, fd->inode, data_lock,
+                                          sources, sinks, healed_sinks,
+                                          undid_pending, locked_replies, NULL);
         if (ret < 0)
-		goto out;
+            goto unlock;
 
-        if (!did_sh)
-                goto out;
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
+        }
 
-	ret = afr_selfheal_data_do (frame, this, fd, source, healed_sinks,
-				    locked_replies);
-	if (ret)
-                goto out;
+        source = ret;
+
+        if (AFR_IS_ARBITER_BRICK(priv, source)) {
+            empty_file = afr_is_file_empty_on_all_children(priv,
+                                                           locked_replies);
+            if (empty_file)
+                goto restore_time;
+
+            did_sh = _gf_false;
+            goto unlock;
+        }
+
+        if (priv->arbiter_count &&
+            AFR_COUNT(healed_sinks, priv->child_count) == 1 &&
+            healed_sinks[ARBITER_BRICK_INDEX]) {
+            is_arbiter_the_only_sink = _gf_true;
+            goto restore_time;
+        }
+
+        ret = __afr_selfheal_truncate_sinks(
+            frame, this, fd, healed_sinks,
+            locked_replies[source].poststat.ia_size);
+        if (ret < 0)
+            goto unlock;
+
+        ret = 0;
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, 0, 0, data_lock);
+    if (ret < 0)
+        goto out;
+
+    if (!did_sh)
+        goto out;
+
+    ret = afr_selfheal_data_do(frame, this, fd, source, healed_sinks,
+                               locked_replies);
+    if (ret)
+        goto out;
 restore_time:
-	afr_selfheal_restore_time (frame, this, fd->inode, source,
-					healed_sinks, locked_replies);
-
-        if (!is_arbiter_the_only_sink || !empty_file) {
-                ret = afr_selfheal_inodelk (frame, this, fd->inode, this->name,
-                                            0, 0, data_lock);
-                if (ret < priv->child_count) {
-                        ret = -ENOTCONN;
-                        did_sh = _gf_false;
-                        goto skip_undo_pending;
-                }
+    afr_selfheal_restore_time(frame, this, fd->inode, source, healed_sinks,
+                              locked_replies);
+
+    if (!is_arbiter_the_only_sink || !empty_file) {
+        ret = afr_selfheal_inodelk(frame, this, fd->inode, this->name, 0, 0,
+                                   data_lock);
+        if (ret < priv->child_count) {
+            ret = -ENOTCONN;
+            did_sh = _gf_false;
+            goto skip_undo_pending;
         }
-        ret = afr_selfheal_undo_pending (frame, this, fd->inode,
-                                         sources, sinks, healed_sinks,
-                                         undid_pending, AFR_DATA_TRANSACTION,
-                                         locked_replies, data_lock);
+    }
+    ret = afr_selfheal_undo_pending(
+        frame, this, fd->inode, sources, sinks, healed_sinks, undid_pending,
+        AFR_DATA_TRANSACTION, locked_replies, data_lock);
 skip_undo_pending:
-	afr_selfheal_uninodelk (frame, this, fd->inode, this->name, 0, 0,
-				data_lock);
+    afr_selfheal_uninodelk(frame, this, fd->inode, this->name, 0, 0, data_lock);
 out:
 
-        if (did_sh)
-                afr_log_selfheal (fd->inode->gfid, this, ret, "data", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
+    if (did_sh)
+        afr_log_selfheal(fd->inode->gfid, this, ret, "data", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
 
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
 int
-afr_selfheal_data_open_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            fd_t *fd, dict_t *xdata)
+afr_selfheal_data_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, fd_t *fd,
+                           dict_t *xdata)
 {
-        afr_local_t *local = NULL;
-        int         i      = (long) cookie;
+    afr_local_t *local = NULL;
+    int i = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->replies[i].valid = 1;
-        local->replies[i].op_ret = op_ret;
-        local->replies[i].op_errno = op_errno;
+    local->replies[i].valid = 1;
+    local->replies[i].op_ret = op_ret;
+    local->replies[i].op_errno = op_errno;
 
-        syncbarrier_wake (&local->barrier);
+    syncbarrier_wake(&local->barrier);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_selfheal_data_open (xlator_t *this, inode_t *inode, fd_t **fd)
+afr_selfheal_data_open(xlator_t *this, inode_t *inode, fd_t **fd)
 {
-        int           ret      = 0;
-        fd_t          *fd_tmp  = NULL;
-        loc_t         loc      = {0,};
-        call_frame_t  *frame   = NULL;
-        afr_local_t   *local   = NULL;
-        afr_private_t *priv    = NULL;
-        int           i        = 0;
-
-        priv = this->private;
-
-	fd_tmp = fd_create (inode, 0);
-	if (!fd_tmp)
-		return -ENOMEM;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-        frame = afr_frame_create (this, &ret);
-        if (!frame) {
-                ret = -ret;
-                fd_unref (fd_tmp);
-                goto out;
+    int ret = 0;
+    fd_t *fd_tmp = NULL;
+    loc_t loc = {
+        0,
+    };
+    call_frame_t *frame = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    priv = this->private;
+
+    fd_tmp = fd_create(inode, 0);
+    if (!fd_tmp)
+        return -ENOMEM;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        fd_unref(fd_tmp);
+        goto out;
+    }
+    local = frame->local;
+
+    AFR_ONLIST(local->child_up, frame, afr_selfheal_data_open_cbk, open, &loc,
+               O_RDWR | O_LARGEFILE, fd_tmp, NULL);
+
+    ret = -ENOTCONN;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+
+        if (local->replies[i].op_ret < 0) {
+            ret = -local->replies[i].op_errno;
+            continue;
         }
-        local = frame->local;
-
-        AFR_ONLIST (local->child_up, frame, afr_selfheal_data_open_cbk, open,
-                    &loc, O_RDWR|O_LARGEFILE, fd_tmp, NULL);
-
-        ret = -ENOTCONN;
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
 
-                if (local->replies[i].op_ret < 0) {
-                        ret = -local->replies[i].op_errno;
-                        continue;
-                }
+        ret = 0;
+        break;
+    }
 
-                ret = 0;
-                break;
-        }
-
-	if (ret < 0) {
-		fd_unref (fd_tmp);
-                goto out;
-	} else {
-		fd_bind (fd_tmp);
-	}
+    if (ret < 0) {
+        fd_unref(fd_tmp);
+        goto out;
+    } else {
+        fd_bind(fd_tmp);
+    }
 
-        *fd = fd_tmp;
+    *fd = fd_tmp;
 out:
-        loc_wipe (&loc);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-	return ret;
+    loc_wipe(&loc);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-afr_selfheal_data (call_frame_t *frame, xlator_t *this, fd_t *fd)
+afr_selfheal_data(call_frame_t *frame, xlator_t *this, fd_t *fd)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *locked_on = NULL;
-	int ret = 0;
-        inode_t *inode = fd->inode;
-
-	priv = this->private;
-
-	locked_on = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_tie_breaker_inodelk (frame, this, inode,
-	                                        priv->sh_domain, 0, 0,
-				                locked_on);
-	{
-		if (ret < priv->child_count) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "self-heal as only %d number of "
-                                      "subvolumes could be locked",
-                                      uuid_utoa (fd->inode->gfid),
-                                ret);
-			/* Either less than two subvols available, or another
-			   selfheal (from another server) is in progress. Skip
-			   for now in any case there isn't anything to do.
-			*/
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_data (frame, this, fd, locked_on);
-	}
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    int ret = 0;
+    inode_t *inode = fd->inode;
+
+    priv = this->private;
+
+    locked_on = alloca0(priv->child_count);
+
+    ret = afr_selfheal_tie_breaker_inodelk(frame, this, inode, priv->sh_domain,
+                                           0, 0, locked_on);
+    {
+        if (ret < priv->child_count) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "self-heal as only %d number of "
+                         "subvolumes could be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            /* Either less than two subvols available, or another
+               selfheal (from another server) is in progress. Skip
+               for now in any case there isn't anything to do.
+            */
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_data(frame, this, fd, locked_on);
+    }
 unlock:
-	afr_selfheal_uninodelk (frame, this, inode, priv->sh_domain, 0, 0,
-	                        locked_on);
+    afr_selfheal_uninodelk(frame, this, inode, priv->sh_domain, 0, 0,
+                           locked_on);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-entry.c b/xlators/cluster/afr/src/afr-self-heal-entry.c
index e6022cc939b..bf7a6b9d1e8 100644
--- a/xlators/cluster/afr/src/afr-self-heal-entry.c
+++ b/xlators/cluster/afr/src/afr-self-heal-entry.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "byte-order.h"
@@ -18,1105 +17,1090 @@
 #include "events.h"
 
 static int
-afr_selfheal_entry_delete (xlator_t *this, inode_t *dir, const char *name,
-                           inode_t *inode, int child, struct afr_reply *replies)
+afr_selfheal_entry_delete(xlator_t *this, inode_t *dir, const char *name,
+                          inode_t *inode, int child, struct afr_reply *replies)
 {
-	afr_private_t *priv = NULL;
-	xlator_t *subvol = NULL;
-	int ret = 0;
-	loc_t loc = {0, };
-	char g[64];
-
-	priv = this->private;
-
-	subvol = priv->children[child];
-
-	loc.parent = inode_ref (dir);
-	gf_uuid_copy (loc.pargfid, dir->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
-
-	if (replies[child].valid && replies[child].op_ret == 0) {
-		switch (replies[child].poststat.ia_type) {
-		case IA_IFDIR:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-				"expunging dir %s/%s (%s) on %s",
-				uuid_utoa (dir->gfid), name,
-				uuid_utoa_r (replies[child].poststat.ia_gfid, g),
-				subvol->name);
-			ret = syncop_rmdir (subvol, &loc, 1, NULL, NULL);
-			break;
-		default:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-				"expunging file %s/%s (%s) on %s",
-				uuid_utoa (dir->gfid), name,
-				uuid_utoa_r (replies[child].poststat.ia_gfid, g),
-				subvol->name);
-			ret = syncop_unlink (subvol, &loc, NULL, NULL);
-			break;
-		}
-	}
-
-	loc_wipe (&loc);
-
-	return ret;
+    afr_private_t *priv = NULL;
+    xlator_t *subvol = NULL;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    char g[64];
+
+    priv = this->private;
+
+    subvol = priv->children[child];
+
+    loc.parent = inode_ref(dir);
+    gf_uuid_copy(loc.pargfid, dir->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
+
+    if (replies[child].valid && replies[child].op_ret == 0) {
+        switch (replies[child].poststat.ia_type) {
+            case IA_IFDIR:
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                       "expunging dir %s/%s (%s) on %s", uuid_utoa(dir->gfid),
+                       name, uuid_utoa_r(replies[child].poststat.ia_gfid, g),
+                       subvol->name);
+                ret = syncop_rmdir(subvol, &loc, 1, NULL, NULL);
+                break;
+            default:
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                       "expunging file %s/%s (%s) on %s", uuid_utoa(dir->gfid),
+                       name, uuid_utoa_r(replies[child].poststat.ia_gfid, g),
+                       subvol->name);
+                ret = syncop_unlink(subvol, &loc, NULL, NULL);
+                break;
+        }
+    }
+
+    loc_wipe(&loc);
+
+    return ret;
 }
 
 int
-afr_selfheal_recreate_entry (call_frame_t *frame, int dst, int source,
-                             unsigned char *sources, inode_t *dir,
-                             const char *name, inode_t *inode,
-                             struct afr_reply *replies)
+afr_selfheal_recreate_entry(call_frame_t *frame, int dst, int source,
+                            unsigned char *sources, inode_t *dir,
+                            const char *name, inode_t *inode,
+                            struct afr_reply *replies)
 {
-	int ret = 0;
-	loc_t loc = {0,};
-	loc_t srcloc = {0,};
-        xlator_t *this = frame->this;
-	afr_private_t *priv = NULL;
-	dict_t *xdata = NULL;
-	struct iatt *iatt = NULL;
-	char *linkname = NULL;
-	mode_t mode = 0;
-	struct iatt newent = {0,};
-        unsigned char *newentry = NULL;
-
-        priv = this->private;
-	iatt = &replies[source].poststat;
-        if (iatt->ia_type == IA_INVAL || gf_uuid_is_null (iatt->ia_gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_SELF_HEAL_FAILED,
-                        "Invalid ia_type (%d) or gfid(%s). source brick=%d, "
-                        "pargfid=%s, name=%s", iatt->ia_type,
-                        uuid_utoa(iatt->ia_gfid), source,
-                        uuid_utoa(dir->gfid), name);
-                ret = -EINVAL;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    loc_t srcloc = {
+        0,
+    };
+    xlator_t *this = frame->this;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    struct iatt *iatt = NULL;
+    char *linkname = NULL;
+    mode_t mode = 0;
+    struct iatt newent = {
+        0,
+    };
+    unsigned char *newentry = NULL;
+
+    priv = this->private;
+    iatt = &replies[source].poststat;
+    if (iatt->ia_type == IA_INVAL || gf_uuid_is_null(iatt->ia_gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SELF_HEAL_FAILED,
+               "Invalid ia_type (%d) or gfid(%s). source brick=%d, "
+               "pargfid=%s, name=%s",
+               iatt->ia_type, uuid_utoa(iatt->ia_gfid), source,
+               uuid_utoa(dir->gfid), name);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata)
+        return -ENOMEM;
+    newentry = alloca0(priv->child_count);
+    loc.parent = inode_ref(dir);
+    gf_uuid_copy(loc.pargfid, dir->gfid);
+    loc.name = name;
+    loc.inode = inode_ref(inode);
+
+    ret = afr_selfheal_entry_delete(this, dir, name, inode, dst, replies);
+    if (ret)
+        goto out;
+
+    ret = dict_set_gfuuid(xdata, "gfid-req", replies[source].poststat.ia_gfid,
+                          true);
+    if (ret)
+        goto out;
+
+    srcloc.inode = inode_ref(inode);
+    gf_uuid_copy(srcloc.gfid, iatt->ia_gfid);
+    if (iatt->ia_type != IA_IFDIR)
+        ret = syncop_lookup(priv->children[dst], &srcloc, 0, 0, 0, 0);
+    if (iatt->ia_type == IA_IFDIR || ret == -ENOENT || ret == -ESTALE) {
+        newentry[dst] = 1;
+        ret = afr_selfheal_newentry_mark(frame, this, inode, source, replies,
+                                         sources, newentry);
+        if (ret)
+            goto out;
+    }
+
+    mode = st_mode_from_ia(iatt->ia_prot, iatt->ia_type);
+
+    switch (iatt->ia_type) {
+        case IA_IFDIR:
+            ret = syncop_mkdir(priv->children[dst], &loc, mode, 0, xdata, NULL);
+            break;
+        case IA_IFLNK:
+            if (!newentry[dst]) {
+                ret = syncop_link(priv->children[dst], &srcloc, &loc, &newent,
+                                  NULL, NULL);
+            } else {
+                ret = syncop_readlink(priv->children[source], &srcloc,
+                                      &linkname, 4096, NULL, NULL);
+                if (ret <= 0)
+                    goto out;
+                ret = syncop_symlink(priv->children[dst], &loc, linkname, NULL,
+                                     xdata, NULL);
+            }
+            break;
+        default:
+            ret = dict_set_int32(xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
+            if (ret)
                 goto out;
-        }
-
-	xdata = dict_new();
-	if (!xdata)
-		return -ENOMEM;
-        newentry = alloca0 (priv->child_count);
-	loc.parent = inode_ref (dir);
-	gf_uuid_copy (loc.pargfid, dir->gfid);
-	loc.name = name;
-	loc.inode = inode_ref (inode);
-
-	ret = afr_selfheal_entry_delete (this, dir, name, inode, dst, replies);
-	if (ret)
-		goto out;
-
-	ret = dict_set_gfuuid (xdata, "gfid-req",
-                               replies[source].poststat.ia_gfid, true);
-	if (ret)
-		goto out;
-
-	srcloc.inode = inode_ref (inode);
-	gf_uuid_copy (srcloc.gfid, iatt->ia_gfid);
-        if (iatt->ia_type != IA_IFDIR)
-                ret = syncop_lookup (priv->children[dst], &srcloc, 0, 0, 0, 0);
-        if (iatt->ia_type == IA_IFDIR || ret == -ENOENT || ret == -ESTALE) {
-                newentry[dst] = 1;
-                ret = afr_selfheal_newentry_mark (frame, this, inode, source,
-                                                  replies, sources, newentry);
-                if (ret)
-                        goto out;
-        }
-
-	mode = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
-
-	switch (iatt->ia_type) {
-	case IA_IFDIR:
-		ret = syncop_mkdir (priv->children[dst], &loc, mode, 0,
-                                    xdata, NULL);
-		break;
-	case IA_IFLNK:
-		if (!newentry[dst]) {
-			ret = syncop_link (priv->children[dst], &srcloc, &loc,
-					   &newent, NULL, NULL);
-		} else {
-			ret = syncop_readlink (priv->children[source], &srcloc,
-					       &linkname, 4096, NULL, NULL);
-			if (ret <= 0)
-				goto out;
-			ret = syncop_symlink (priv->children[dst], &loc,
-                                              linkname, NULL, xdata, NULL);
-                }
-		break;
-	default:
-		ret = dict_set_int32 (xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
-		if (ret)
-			goto out;
-		ret = syncop_mknod (priv->children[dst], &loc, mode,
-                    makedev (ia_major(iatt->ia_rdev), ia_minor (iatt->ia_rdev)),
-                    &newent, xdata, NULL);
-		break;
-	}
+            ret = syncop_mknod(
+                priv->children[dst], &loc, mode,
+                makedev(ia_major(iatt->ia_rdev), ia_minor(iatt->ia_rdev)),
+                &newent, xdata, NULL);
+            break;
+    }
 
 out:
-	if (xdata)
-		dict_unref (xdata);
-	GF_FREE (linkname);
-	loc_wipe (&loc);
-	loc_wipe (&srcloc);
-	return ret;
+    if (xdata)
+        dict_unref(xdata);
+    GF_FREE(linkname);
+    loc_wipe(&loc);
+    loc_wipe(&srcloc);
+    return ret;
 }
 
 static int
-__afr_selfheal_heal_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			    char *name, inode_t *inode, int source,
-			    unsigned char *sources, unsigned char *healed_sinks,
-			    unsigned char *locked_on, struct afr_reply *replies)
+__afr_selfheal_heal_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                           char *name, inode_t *inode, int source,
+                           unsigned char *sources, unsigned char *healed_sinks,
+                           unsigned char *locked_on, struct afr_reply *replies)
 {
-	int ret = 0;
-	afr_private_t *priv = NULL;
-	int i = 0;
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    int i = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	if (!replies[source].valid)
-		return -EIO;
+    if (!replies[source].valid)
+        return -EIO;
 
-        /* Skip healing this entry if the last lookup on it failed for reasons
-         * other than ENOENT.
-         */
-        if ((replies[source].op_ret < 0) &&
-            (replies[source].op_errno != ENOENT))
-                return -replies[source].op_errno;
-
-        if (replies[source].op_ret == 0) {
-                ret = afr_lookup_and_heal_gfid (this, fd->inode, name,
-                                                inode, replies, source, sources,
-                                             &replies[source].poststat.ia_gfid);
-                if (ret)
-                        return ret;
+    /* Skip healing this entry if the last lookup on it failed for reasons
+     * other than ENOENT.
+     */
+    if ((replies[source].op_ret < 0) && (replies[source].op_errno != ENOENT))
+        return -replies[source].op_errno;
+
+    if (replies[source].op_ret == 0) {
+        ret = afr_lookup_and_heal_gfid(this, fd->inode, name, inode, replies,
+                                       source, sources,
+                                       &replies[source].poststat.ia_gfid);
+        if (ret)
+            return ret;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
+        if (replies[source].op_ret == -1 &&
+            replies[source].op_errno == ENOENT) {
+            ret = afr_selfheal_entry_delete(this, fd->inode, name, inode, i,
+                                            replies);
+        } else {
+            if (!gf_uuid_compare(replies[i].poststat.ia_gfid,
+                                 replies[source].poststat.ia_gfid))
+                continue;
+
+            ret = afr_selfheal_recreate_entry(frame, i, source, sources,
+                                              fd->inode, name, inode, replies);
         }
+        if (ret < 0)
+            break;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!healed_sinks[i])
-			continue;
-		if (replies[source].op_ret == -1 &&
-		    replies[source].op_errno == ENOENT) {
-			ret = afr_selfheal_entry_delete (this, fd->inode, name,
-                                                         inode, i, replies);
-                } else {
-			if (!gf_uuid_compare (replies[i].poststat.ia_gfid,
-					   replies[source].poststat.ia_gfid))
-				continue;
-
-			ret = afr_selfheal_recreate_entry (frame, i, source,
-                                                           sources, fd->inode,
-                                                           name, inode,
-							   replies);
-                }
-		if (ret < 0)
-			break;
-	}
-
-	return ret;
+    return ret;
 }
 
 static int
-afr_selfheal_detect_gfid_and_type_mismatch (xlator_t *this,
-                                            struct afr_reply *replies,
-                                            inode_t *inode,
-                                            uuid_t pargfid,
-                                            char *bname, int src_idx,
-                                            unsigned char *locked_on,
-                                            int *src)
+afr_selfheal_detect_gfid_and_type_mismatch(xlator_t *this,
+                                           struct afr_reply *replies,
+                                           inode_t *inode, uuid_t pargfid,
+                                           char *bname, int src_idx,
+                                           unsigned char *locked_on, int *src)
 {
-        int             i        = 0;
-        int             ret      = -1;
-        afr_private_t  *priv     = NULL;
-        void *gfid               = NULL;
-        ia_type_t ia_type        = IA_INVAL;
-
-        priv = this->private;
-        gfid = &replies[src_idx].poststat.ia_gfid;
-        ia_type = replies[src_idx].poststat.ia_type;
+    int i = 0;
+    int ret = -1;
+    afr_private_t *priv = NULL;
+    void *gfid = NULL;
+    ia_type_t ia_type = IA_INVAL;
+
+    priv = this->private;
+    gfid = &replies[src_idx].poststat.ia_gfid;
+    ia_type = replies[src_idx].poststat.ia_type;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == src_idx)
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        if (gf_uuid_compare(gfid, replies[i].poststat.ia_gfid) &&
+            (ia_type == replies[i].poststat.ia_type)) {
+            ret = afr_gfid_split_brain_source(this, replies, inode, pargfid,
+                                              bname, src_idx, i, locked_on, src,
+                                              NULL);
+            if (ret)
+                gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Skipping conservative merge on the "
+                       "file.");
+            return ret;
+        }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == src_idx)
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                if (gf_uuid_compare (gfid, replies[i].poststat.ia_gfid) &&
-                    (ia_type == replies[i].poststat.ia_type)) {
-                        ret = afr_gfid_split_brain_source (this, replies, inode,
-                                                           pargfid, bname,
-                                                           src_idx, i,
-                                                           locked_on, src,
-                                                           NULL);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_SPLIT_BRAIN,
-                                        "Skipping conservative merge on the "
-                                        "file.");
-                        return ret;
-                }
-
-                if (ia_type != replies[i].poststat.ia_type) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_SPLIT_BRAIN, "Type mismatch detected "
-                                "for <gfid:%s>/%s>, %s on %s and %s on %s. "
-                                "Skipping conservative merge on the file.",
-                                uuid_utoa (pargfid), bname,
-                                gf_inode_type_to_str (replies[i].poststat.ia_type),
-                                priv->children[i]->name,
-                                gf_inode_type_to_str (replies[src_idx].poststat.ia_type),
-                                priv->children[src_idx]->name);
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;type=file;"
-                                  "file=<gfid:%s>/%s>;count=2;child-%d=%s;type-"
-                                  "%d=%s;child-%d=%s;type-%d=%s",
-                                  this->name, uuid_utoa (pargfid), bname, i,
-                                  priv->children[i]->name, i,
-                                  gf_inode_type_to_str(replies[i].poststat.ia_type),
-                                  src_idx, priv->children[src_idx]->name, src_idx,
-                                  gf_inode_type_to_str(replies[src_idx].poststat.ia_type));
-                        return -1;
-                }
+        if (ia_type != replies[i].poststat.ia_type) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_SPLIT_BRAIN,
+                   "Type mismatch detected "
+                   "for <gfid:%s>/%s>, %s on %s and %s on %s. "
+                   "Skipping conservative merge on the file.",
+                   uuid_utoa(pargfid), bname,
+                   gf_inode_type_to_str(replies[i].poststat.ia_type),
+                   priv->children[i]->name,
+                   gf_inode_type_to_str(replies[src_idx].poststat.ia_type),
+                   priv->children[src_idx]->name);
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "subvol=%s;type=file;"
+                     "file=<gfid:%s>/%s>;count=2;child-%d=%s;type-"
+                     "%d=%s;child-%d=%s;type-%d=%s",
+                     this->name, uuid_utoa(pargfid), bname, i,
+                     priv->children[i]->name, i,
+                     gf_inode_type_to_str(replies[i].poststat.ia_type), src_idx,
+                     priv->children[src_idx]->name, src_idx,
+                     gf_inode_type_to_str(replies[src_idx].poststat.ia_type));
+            return -1;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-__afr_selfheal_merge_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-			     char *name, inode_t *inode, unsigned char *sources,
-			     unsigned char *healed_sinks, unsigned char *locked_on,
-			     struct afr_reply *replies)
+__afr_selfheal_merge_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            char *name, inode_t *inode, unsigned char *sources,
+                            unsigned char *healed_sinks,
+                            unsigned char *locked_on, struct afr_reply *replies)
 {
-        int             ret       = 0;
-        int             i         = 0;
-        int             source    = -1;
-        int             src       = -1;
-        afr_private_t  *priv      = NULL;
+    int ret = 0;
+    int i = 0;
+    int source = -1;
+    int src = -1;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            source = i;
+            break;
+        }
+    }
 
-	priv = this->private;
+    if (source == -1) {
+        /* entry got deleted in the mean time? */
+        return 0;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-		if (replies[i].valid && replies[i].op_ret == 0) {
-			source = i;
-			break;
-		}
-	}
-
-	if (source == -1) {
-		/* entry got deleted in the mean time? */
-		return 0;
-	}
-
-        /* Set all the sources as 1, otheriwse newentry_mark won't be set */
-	for (i = 0; i < priv->child_count; i++) {
-		if (replies[i].valid && replies[i].op_ret == 0) {
-			sources[i] = 1;
-		}
-	}
-
-        ret = afr_lookup_and_heal_gfid (this, fd->inode, name, inode, replies,
-                                        source, sources,
-                                        &replies[source].poststat.ia_gfid);
-        if (ret)
-                return ret;
+    /* Set all the sources as 1, otheriwse newentry_mark won't be set */
+    for (i = 0; i < priv->child_count; i++) {
+        if (replies[i].valid && replies[i].op_ret == 0) {
+            sources[i] = 1;
+        }
+    }
 
-        /* In case of type mismatch / unable to resolve gfid mismatch on the
-         * entry, return -1.*/
-        ret = afr_selfheal_detect_gfid_and_type_mismatch (this, replies, inode,
-                                                          fd->inode->gfid,
-                                                          name, source,
-                                                          locked_on, &src);
+    ret = afr_lookup_and_heal_gfid(this, fd->inode, name, inode, replies,
+                                   source, sources,
+                                   &replies[source].poststat.ia_gfid);
+    if (ret)
+        return ret;
 
-        if (ret < 0)
-                return ret;
-        if (src != -1) {
-                source = src;
-                for (i = 0; i < priv->child_count; i++) {
-                        if (i != src && replies[i].valid &&
-                            gf_uuid_compare (replies[src].poststat.ia_gfid,
-                            replies[i].poststat.ia_gfid)) {
-                                sources[i] = 0;
-                        }
-                }
+    /* In case of type mismatch / unable to resolve gfid mismatch on the
+     * entry, return -1.*/
+    ret = afr_selfheal_detect_gfid_and_type_mismatch(
+        this, replies, inode, fd->inode->gfid, name, source, locked_on, &src);
+
+    if (ret < 0)
+        return ret;
+    if (src != -1) {
+        source = src;
+        for (i = 0; i < priv->child_count; i++) {
+            if (i != src && replies[i].valid &&
+                gf_uuid_compare(replies[src].poststat.ia_gfid,
+                                replies[i].poststat.ia_gfid)) {
+                sources[i] = 0;
+            }
         }
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (i == source || !healed_sinks[i])
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source || !healed_sinks[i])
+            continue;
 
-                if (src != -1) {
-                        if (!gf_uuid_compare (replies[src].poststat.ia_gfid,
-                                              replies[i].poststat.ia_gfid))
-                                continue;
-                } else if (replies[i].op_errno != ENOENT) {
-			continue;
-                }
+        if (src != -1) {
+            if (!gf_uuid_compare(replies[src].poststat.ia_gfid,
+                                 replies[i].poststat.ia_gfid))
+                continue;
+        } else if (replies[i].op_errno != ENOENT) {
+            continue;
+        }
 
-		ret |= afr_selfheal_recreate_entry (frame, i, source, sources,
-                                                    fd->inode, name, inode,
-                                                    replies);
-	}
+        ret |= afr_selfheal_recreate_entry(frame, i, source, sources, fd->inode,
+                                           name, inode, replies);
+    }
 
-	return ret;
+    return ret;
 }
 
-
 static int
-__afr_selfheal_entry_dirent (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             char *name, inode_t *inode, int source,
-                             unsigned char *sources, unsigned char *healed_sinks,
-                             unsigned char *locked_on,
-                             struct afr_reply *replies)
+__afr_selfheal_entry_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            char *name, inode_t *inode, int source,
+                            unsigned char *sources, unsigned char *healed_sinks,
+                            unsigned char *locked_on, struct afr_reply *replies)
 {
-	int ret = -1;
-
-	if (source < 0)
-		ret = __afr_selfheal_merge_dirent (frame, this, fd, name, inode,
-						   sources, healed_sinks,
-						   locked_on, replies);
-	else
-		ret = __afr_selfheal_heal_dirent (frame, this, fd, name, inode,
-						  source, sources, healed_sinks,
-						  locked_on, replies);
-	return ret;
+    int ret = -1;
+
+    if (source < 0)
+        ret = __afr_selfheal_merge_dirent(frame, this, fd, name, inode, sources,
+                                          healed_sinks, locked_on, replies);
+    else
+        ret = __afr_selfheal_heal_dirent(frame, this, fd, name, inode, source,
+                                         sources, healed_sinks, locked_on,
+                                         replies);
+    return ret;
 }
 
 static gf_boolean_t
-is_full_heal_marker_present (xlator_t *this, dict_t *xdata, int idx)
+is_full_heal_marker_present(xlator_t *this, dict_t *xdata, int idx)
 {
-        int                  i           = 0;
-        int                  pending[3]  = {0,};
-        void                *pending_raw = NULL;
-        afr_private_t       *priv        = NULL;
+    int i = 0;
+    int pending[3] = {
+        0,
+    };
+    void *pending_raw = NULL;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!xdata)
-                return _gf_false;
+    if (!xdata)
+        return _gf_false;
 
-        /* Iterate over each of the priv->pending_keys[] elements and then
-         * see if any of them have data segment non-zero. If they do, return
-         * true. Else return false.
-         */
-        for (i = 0; i < priv->child_count; i++) {
-                if (dict_get_ptr (xdata, priv->pending_key[i], &pending_raw))
-                        continue;
+    /* Iterate over each of the priv->pending_keys[] elements and then
+     * see if any of them have data segment non-zero. If they do, return
+     * true. Else return false.
+     */
+    for (i = 0; i < priv->child_count; i++) {
+        if (dict_get_ptr(xdata, priv->pending_key[i], &pending_raw))
+            continue;
 
-                if (!pending_raw)
-                        continue;
+        if (!pending_raw)
+            continue;
 
-                memcpy (pending, pending_raw, sizeof (pending));
-                if (ntoh32 (pending[idx]))
-                        return _gf_true;
-        }
+        memcpy(pending, pending_raw, sizeof(pending));
+        if (ntoh32(pending[idx]))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_need_full_heal (xlator_t *this, struct afr_reply *replies, int source,
-                    unsigned char *healed_sinks, afr_transaction_type type)
+afr_need_full_heal(xlator_t *this, struct afr_reply *replies, int source,
+                   unsigned char *healed_sinks, afr_transaction_type type)
 {
-        int                i     = 0;
-        int                idx   = 0;
-        afr_private_t     *priv  = NULL;
+    int i = 0;
+    int idx = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!priv->esh_granular)
-                return _gf_true;
+    if (!priv->esh_granular)
+        return _gf_true;
 
-        if (type != AFR_ENTRY_TRANSACTION)
-                return _gf_true;
+    if (type != AFR_ENTRY_TRANSACTION)
+        return _gf_true;
 
-        priv = this->private;
-        idx = afr_index_for_transaction_type (AFR_DATA_TRANSACTION);
+    priv = this->private;
+    idx = afr_index_for_transaction_type(AFR_DATA_TRANSACTION);
 
-        /* If there is a clear source, check whether the full-heal-indicator
-         * is present in its xdata. Otherwise, we need to examine all the
-         * participating bricks and then figure if *even* one of them has a
-         * full-heal-indicator.
-         */
+    /* If there is a clear source, check whether the full-heal-indicator
+     * is present in its xdata. Otherwise, we need to examine all the
+     * participating bricks and then figure if *even* one of them has a
+     * full-heal-indicator.
+     */
 
-        if (source != -1) {
-                if (is_full_heal_marker_present (this, replies[source].xdata,
-                                                 idx))
-                        return _gf_true;
-        }
+    if (source != -1) {
+        if (is_full_heal_marker_present(this, replies[source].xdata, idx))
+            return _gf_true;
+    }
 
-        /* else ..*/
+    /* else ..*/
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!healed_sinks[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!healed_sinks[i])
+            continue;
 
-                if (is_full_heal_marker_present (this, replies[i].xdata, idx))
-                        return _gf_true;
-        }
+        if (is_full_heal_marker_present(this, replies[i].xdata, idx))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static int
-__afr_selfheal_entry_finalize_source (xlator_t *this, unsigned char *sources,
-				      unsigned char *healed_sinks,
-                                      unsigned char *locked_on,
-                                      struct afr_reply *replies,
-                                      uint64_t *witness)
+__afr_selfheal_entry_finalize_source(xlator_t *this, unsigned char *sources,
+                                     unsigned char *healed_sinks,
+                                     unsigned char *locked_on,
+                                     struct afr_reply *replies,
+                                     uint64_t *witness)
 {
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
 
-	priv = this->private;
+    priv = this->private;
 
-	sources_count = AFR_COUNT (sources, priv->child_count);
+    sources_count = AFR_COUNT(sources, priv->child_count);
 
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count || afr_does_witness_exist (this, witness)) {
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count || afr_does_witness_exist(this, witness)) {
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+        afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+        return -1;
+    }
 
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-		return -1;
-	}
-
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_ENTRY_TRANSACTION);
-	return source;
+    source = afr_choose_source_by_policy(priv, sources, AFR_ENTRY_TRANSACTION);
+    return source;
 }
 
 int
-__afr_selfheal_entry_prepare (call_frame_t *frame, xlator_t *this,
-                              inode_t *inode, unsigned char *locked_on,
-                              unsigned char *sources, unsigned char *sinks,
-                              unsigned char *healed_sinks,
-			      struct afr_reply *replies, int *source_p,
-                              gf_boolean_t *pflag)
+__afr_selfheal_entry_prepare(call_frame_t *frame, xlator_t *this,
+                             inode_t *inode, unsigned char *locked_on,
+                             unsigned char *sources, unsigned char *sinks,
+                             unsigned char *healed_sinks,
+                             struct afr_reply *replies, int *source_p,
+                             gf_boolean_t *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        uint64_t *witness = NULL;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    uint64_t *witness = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-        if (ret)
-                return ret;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_ENTRY_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_entry_finalize_source (this, sources,
-                                                       healed_sinks,
-						       locked_on, replies,
-                                                       witness);
-
-	if (source < 0) {
-		/* If source is < 0 (typically split-brain), we perform a
-		   conservative merge of entries rather than erroring out */
-	}
-	*source_p = source;
-
-	return ret;
-}
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+    if (ret)
+        return ret;
 
-static int
-afr_selfheal_entry_dirent (call_frame_t *frame, xlator_t *this,
-                           fd_t *fd, char *name, inode_t *parent_idx_inode,
-                           xlator_t *subvol, gf_boolean_t full_crawl)
-{
-        int                ret          = 0;
-        int                source       = -1;
-        unsigned char     *locked_on    = NULL;
-        unsigned char     *sources      = NULL;
-        unsigned char     *sinks        = NULL;
-        unsigned char     *healed_sinks = NULL;
-        inode_t           *inode        = NULL;
-        struct afr_reply  *replies      = NULL;
-        struct afr_reply  *par_replies  = NULL;
-        afr_private_t     *priv         = NULL;
-        dict_t            *xattr        = NULL;
-
-	priv = this->private;
-
-        xattr = dict_new ();
-        if (!xattr)
-                return -ENOMEM;
-        ret = dict_set_int32 (xattr, GF_GFIDLESS_LOOKUP, 1);
-        if (ret) {
-                dict_unref (xattr);
-                return -1;
-        }
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_ENTRY_TRANSACTION, locked_on, sources,
+                                      sinks, witness, pflag);
+    if (ret)
+        return ret;
 
-        sources = alloca0 (priv->child_count);
-        sinks   = alloca0 (priv->child_count);
-        healed_sinks = alloca0 (priv->child_count);
-	locked_on = alloca0 (priv->child_count);
-
-	replies = alloca0 (priv->child_count * sizeof(*replies));
-	par_replies = alloca0 (priv->child_count * sizeof(*par_replies));
-
-        ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-                                    locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes "
-                                      " could be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret, this->name);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-                ret = __afr_selfheal_entry_prepare (frame, this, fd->inode,
-                                                    locked_on,
-                                                    sources, sinks,
-                                                    healed_sinks, par_replies,
-                                                    &source, NULL);
-                if (ret < 0)
-                        goto unlock;
-
-		inode = afr_selfheal_unlocked_lookup_on (frame, fd->inode, name,
-							 replies, locked_on,
-                                                         xattr);
-		if (!inode) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_entry_dirent (frame, this, fd, name, inode,
-						   source, sources, healed_sinks,
-						   locked_on, replies);
-
-                if ((ret == 0) && (priv->esh_granular) && parent_idx_inode) {
-                        ret = afr_shd_index_purge (subvol, parent_idx_inode,
-                                                   name, inode->ia_type);
-                        /* Why is ret force-set to 0? We do not care about
-                         * index purge failing for full heal as it is quite
-                         * possible during replace-brick that not all files
-                         * and directories have their name indices present in
-                         * entry-changes/.
-                         */
-                        ret = 0;
-                }
-	}
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
 
-unlock:
-        afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-                                locked_on, NULL);
-	if (inode)
-		inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-        if (par_replies)
-                afr_replies_wipe (par_replies, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
-
-	return ret;
-}
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
 
+    source = __afr_selfheal_entry_finalize_source(this, sources, healed_sinks,
+                                                  locked_on, replies, witness);
 
-static inode_t *
-afr_shd_entry_changes_index_inode (xlator_t *this, xlator_t *subvol,
-                                   uuid_t pargfid)
+    if (source < 0) {
+        /* If source is < 0 (typically split-brain), we perform a
+           conservative merge of entries rather than erroring out */
+    }
+    *source_p = source;
+
+    return ret;
+}
+
+static int
+afr_selfheal_entry_dirent(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                          char *name, inode_t *parent_idx_inode,
+                          xlator_t *subvol, gf_boolean_t full_crawl)
 {
-        int             ret         = -1;
-        void           *index_gfid  = NULL;
-        loc_t           rootloc     = {0,};
-        loc_t           loc         = {0,};
-        dict_t         *xattr       = NULL;
-        inode_t        *inode       = NULL;
-        struct iatt     iatt        = {0,};
-
-        rootloc.inode = inode_ref (this->itable->root);
-        gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
-
-        ret = syncop_getxattr (subvol, &rootloc, &xattr,
-                               GF_XATTROP_ENTRY_CHANGES_GFID, NULL, NULL);
-        if (ret || !xattr) {
-                errno = -ret;
-                goto out;
+    int ret = 0;
+    int source = -1;
+    unsigned char *locked_on = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    inode_t *inode = NULL;
+    struct afr_reply *replies = NULL;
+    struct afr_reply *par_replies = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+
+    priv = this->private;
+
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
+    ret = dict_set_int32(xattr, GF_GFIDLESS_LOOKUP, 1);
+    if (ret) {
+        dict_unref(xattr);
+        return -1;
+    }
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    locked_on = alloca0(priv->child_count);
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+    par_replies = alloca0(priv->child_count * sizeof(*par_replies));
+
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               locked_on);
+    {
+        if (ret < AFR_SH_MIN_PARTICIPANTS) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes "
+                         " could be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, this->name);
+            ret = -ENOTCONN;
+            goto unlock;
         }
 
-        ret = dict_get_ptr (xattr, GF_XATTROP_ENTRY_CHANGES_GFID, &index_gfid);
-        if (ret) {
-                errno = EINVAL;
-                goto out;
-        }
+        ret = __afr_selfheal_entry_prepare(frame, this, fd->inode, locked_on,
+                                           sources, sinks, healed_sinks,
+                                           par_replies, &source, NULL);
+        if (ret < 0)
+            goto unlock;
 
-        loc.inode = inode_new (this->itable);
-        if (!loc.inode) {
-                errno = ENOMEM;
-                goto out;
+        inode = afr_selfheal_unlocked_lookup_on(frame, fd->inode, name, replies,
+                                                locked_on, xattr);
+        if (!inode) {
+            ret = -ENOMEM;
+            goto unlock;
         }
 
-        gf_uuid_copy (loc.pargfid, index_gfid);
-        loc.name = gf_strdup (uuid_utoa (pargfid));
-
-        ret = syncop_lookup (subvol, &loc, &iatt, NULL, NULL, NULL);
-        if (ret < 0) {
-                errno = -ret;
-                goto out;
+        ret = __afr_selfheal_entry_dirent(frame, this, fd, name, inode, source,
+                                          sources, healed_sinks, locked_on,
+                                          replies);
+
+        if ((ret == 0) && (priv->esh_granular) && parent_idx_inode) {
+            ret = afr_shd_index_purge(subvol, parent_idx_inode, name,
+                                      inode->ia_type);
+            /* Why is ret force-set to 0? We do not care about
+             * index purge failing for full heal as it is quite
+             * possible during replace-brick that not all files
+             * and directories have their name indices present in
+             * entry-changes/.
+             */
+            ret = 0;
         }
+    }
 
-        inode = inode_link (loc.inode, NULL, NULL, &iatt);
+unlock:
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL, locked_on,
+                           NULL);
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    if (par_replies)
+        afr_replies_wipe(par_replies, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
+
+    return ret;
+}
+
+static inode_t *
+afr_shd_entry_changes_index_inode(xlator_t *this, xlator_t *subvol,
+                                  uuid_t pargfid)
+{
+    int ret = -1;
+    void *index_gfid = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    inode_t *inode = NULL;
+    struct iatt iatt = {
+        0,
+    };
+
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
+
+    ret = syncop_getxattr(subvol, &rootloc, &xattr,
+                          GF_XATTROP_ENTRY_CHANGES_GFID, NULL, NULL);
+    if (ret || !xattr) {
+        errno = -ret;
+        goto out;
+    }
+
+    ret = dict_get_ptr(xattr, GF_XATTROP_ENTRY_CHANGES_GFID, &index_gfid);
+    if (ret) {
+        errno = EINVAL;
+        goto out;
+    }
+
+    loc.inode = inode_new(this->itable);
+    if (!loc.inode) {
+        errno = ENOMEM;
+        goto out;
+    }
+
+    gf_uuid_copy(loc.pargfid, index_gfid);
+    loc.name = gf_strdup(uuid_utoa(pargfid));
+
+    ret = syncop_lookup(subvol, &loc, &iatt, NULL, NULL, NULL);
+    if (ret < 0) {
+        errno = -ret;
+        goto out;
+    }
+
+    inode = inode_link(loc.inode, NULL, NULL, &iatt);
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        loc_wipe (&rootloc);
-        GF_FREE ((char *)loc.name);
-        loc_wipe (&loc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&rootloc);
+    GF_FREE((char *)loc.name);
+    loc_wipe(&loc);
 
-        return inode;
+    return inode;
 }
 
 static int
-afr_selfheal_entry_do_subvol (call_frame_t *frame, xlator_t *this,
-                              fd_t *fd, int child)
+afr_selfheal_entry_do_subvol(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                             int child)
 {
-	int ret = 0;
-	gf_dirent_t entries;
-	gf_dirent_t *entry = NULL;
-	off_t offset = 0;
-	call_frame_t *iter_frame = NULL;
-	xlator_t *subvol = NULL;
-	afr_private_t *priv = NULL;
-        gf_boolean_t mismatch = _gf_false;
-        afr_local_t *local = NULL;
-        loc_t loc = {0,};
-
-	priv = this->private;
-	subvol = priv->children[child];
-
-	INIT_LIST_HEAD (&entries.list);
-
-        local = frame->local;
-
-	iter_frame = afr_copy_frame (frame);
-	if (!iter_frame)
-		return -ENOMEM;
-
-        loc.inode = afr_shd_entry_changes_index_inode (this, subvol,
-                                                       fd->inode->gfid);
-
-	while ((ret = syncop_readdir (subvol, fd, 131072, offset, &entries,
-                                      NULL, NULL))) {
-		if (ret > 0)
-			ret = 0;
-		list_for_each_entry (entry, &entries.list, list) {
-			offset = entry->d_off;
-
-			if (!strcmp (entry->d_name, ".") ||
-			    !strcmp (entry->d_name, ".."))
-				continue;
-
-			if (__is_root_gfid (fd->inode->gfid) &&
-			    !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR))
-				continue;
-
-			ret = afr_selfheal_entry_dirent (iter_frame, this, fd,
-                                                         entry->d_name,
-                                                         loc.inode, subvol,
-                                                        local->need_full_crawl);
-			AFR_STACK_RESET (iter_frame);
-			if (iter_frame->local == NULL) {
-                                ret = -ENOTCONN;
-                                break;
-                        }
-
-                        if (ret == -1) {
-                                /* gfid or type mismatch. */
-                                mismatch = _gf_true;
-                                ret = 0;
-                        }
-			if (ret)
-				break;
-		}
-
-		gf_dirent_free (&entries);
-		if (ret)
-			break;
-	}
-
-        loc_wipe (&loc);
-
-	AFR_STACK_DESTROY (iter_frame);
-        if (mismatch == _gf_true)
-                /* undo pending will be skipped */
-                ret = -1;
-	return ret;
-}
+    int ret = 0;
+    gf_dirent_t entries;
+    gf_dirent_t *entry = NULL;
+    off_t offset = 0;
+    call_frame_t *iter_frame = NULL;
+    xlator_t *subvol = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t mismatch = _gf_false;
+    afr_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    priv = this->private;
+    subvol = priv->children[child];
+
+    INIT_LIST_HEAD(&entries.list);
+
+    local = frame->local;
+
+    iter_frame = afr_copy_frame(frame);
+    if (!iter_frame)
+        return -ENOMEM;
+
+    loc.inode = afr_shd_entry_changes_index_inode(this, subvol,
+                                                  fd->inode->gfid);
+
+    while ((ret = syncop_readdir(subvol, fd, 131072, offset, &entries, NULL,
+                                 NULL))) {
+        if (ret > 0)
+            ret = 0;
+        list_for_each_entry(entry, &entries.list, list)
+        {
+            offset = entry->d_off;
 
-static int
-afr_selfheal_entry_granular_dirent (xlator_t *subvol, gf_dirent_t *entry,
-                                    loc_t *parent, void *data)
-{
-        int                      ret  = 0;
-        loc_t                    loc  = {0,};
-        struct iatt              iatt = {0,};
-        afr_granular_esh_args_t *args = data;
-
-        /* Look up the actual inode associated with entry. If the lookup returns
-         * ESTALE or ENOENT, then it means we have a stale index. Remove it.
-         * This is analogous to the check in afr_shd_index_heal() except that
-         * here it is achieved through LOOKUP and in afr_shd_index_heal() through
-         * a GETXATTR.
-         */
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
+
+            if (__is_root_gfid(fd->inode->gfid) &&
+                !strcmp(entry->d_name, GF_REPLICATE_TRASH_DIR))
+                continue;
 
-        loc.inode = inode_new (args->xl->itable);
-        loc.parent = inode_ref (args->heal_fd->inode);
-        gf_uuid_copy (loc.pargfid, loc.parent->gfid);
-        loc.name = entry->d_name;
-
-        ret = syncop_lookup (args->xl, &loc, &iatt, NULL, NULL, NULL);
-        if ((ret == -ENOENT) || (ret == -ESTALE)) {
-                /* The name indices under the pgfid index dir are guaranteed
-                 * to be regular files. Hence the hardcoding.
-                 */
-                afr_shd_index_purge (subvol, parent->inode, entry->d_name,
-                                     IA_IFREG);
+            ret = afr_selfheal_entry_dirent(iter_frame, this, fd, entry->d_name,
+                                            loc.inode, subvol,
+                                            local->need_full_crawl);
+            AFR_STACK_RESET(iter_frame);
+            if (iter_frame->local == NULL) {
+                ret = -ENOTCONN;
+                break;
+            }
+
+            if (ret == -1) {
+                /* gfid or type mismatch. */
+                mismatch = _gf_true;
                 ret = 0;
-                goto out;
+            }
+            if (ret)
+                break;
         }
-        /* TBD: afr_shd_zero_xattrop? */
 
-        ret = afr_selfheal_entry_dirent (args->frame, args->xl, args->heal_fd,
-                                         entry->d_name, parent->inode, subvol,
-                                         _gf_false);
-        AFR_STACK_RESET (args->frame);
-        if (args->frame->local == NULL)
-                ret = -ENOTCONN;
+        gf_dirent_free(&entries);
+        if (ret)
+            break;
+    }
 
-        if (ret == -1)
-                args->mismatch = _gf_true;
+    loc_wipe(&loc);
 
-out:
-        loc_wipe (&loc);
-        return 0;
+    AFR_STACK_DESTROY(iter_frame);
+    if (mismatch == _gf_true)
+        /* undo pending will be skipped */
+        ret = -1;
+    return ret;
 }
 
 static int
-afr_selfheal_entry_granular (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             int subvol_idx, gf_boolean_t is_src)
+afr_selfheal_entry_granular_dirent(xlator_t *subvol, gf_dirent_t *entry,
+                                   loc_t *parent, void *data)
 {
-        int                         ret    = 0;
-        loc_t                       loc    = {0,};
-        xlator_t                   *subvol = NULL;
-        afr_private_t              *priv   = NULL;
-        afr_granular_esh_args_t     args   = {0,};
-
-        priv = this->private;
-        subvol = priv->children[subvol_idx];
-
-        args.frame = afr_copy_frame (frame);
-        args.xl = this;
-        /* args.heal_fd represents the fd associated with the original directory
-         * on which entry heal is being attempted.
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    afr_granular_esh_args_t *args = data;
+
+    /* Look up the actual inode associated with entry. If the lookup returns
+     * ESTALE or ENOENT, then it means we have a stale index. Remove it.
+     * This is analogous to the check in afr_shd_index_heal() except that
+     * here it is achieved through LOOKUP and in afr_shd_index_heal() through
+     * a GETXATTR.
+     */
+
+    loc.inode = inode_new(args->xl->itable);
+    loc.parent = inode_ref(args->heal_fd->inode);
+    gf_uuid_copy(loc.pargfid, loc.parent->gfid);
+    loc.name = entry->d_name;
+
+    ret = syncop_lookup(args->xl, &loc, &iatt, NULL, NULL, NULL);
+    if ((ret == -ENOENT) || (ret == -ESTALE)) {
+        /* The name indices under the pgfid index dir are guaranteed
+         * to be regular files. Hence the hardcoding.
          */
-        args.heal_fd = fd;
+        afr_shd_index_purge(subvol, parent->inode, entry->d_name, IA_IFREG);
+        ret = 0;
+        goto out;
+    }
+    /* TBD: afr_shd_zero_xattrop? */
+
+    ret = afr_selfheal_entry_dirent(args->frame, args->xl, args->heal_fd,
+                                    entry->d_name, parent->inode, subvol,
+                                    _gf_false);
+    AFR_STACK_RESET(args->frame);
+    if (args->frame->local == NULL)
+        ret = -ENOTCONN;
+
+    if (ret == -1)
+        args->mismatch = _gf_true;
 
-        /* @subvol here represents the subvolume of AFR where
-         * indices/entry-changes/<pargfid> will be processed
+out:
+    loc_wipe(&loc);
+    return 0;
+}
+
+static int
+afr_selfheal_entry_granular(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                            int subvol_idx, gf_boolean_t is_src)
+{
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    xlator_t *subvol = NULL;
+    afr_private_t *priv = NULL;
+    afr_granular_esh_args_t args = {
+        0,
+    };
+
+    priv = this->private;
+    subvol = priv->children[subvol_idx];
+
+    args.frame = afr_copy_frame(frame);
+    args.xl = this;
+    /* args.heal_fd represents the fd associated with the original directory
+     * on which entry heal is being attempted.
+     */
+    args.heal_fd = fd;
+
+    /* @subvol here represents the subvolume of AFR where
+     * indices/entry-changes/<pargfid> will be processed
+     */
+    loc.inode = afr_shd_entry_changes_index_inode(this, subvol,
+                                                  fd->inode->gfid);
+    if (!loc.inode) {
+        /* If granular heal failed on the sink (as it might sometimes
+         * because it is the src that would mostly contain the granular
+         * changelogs and the sink's entry-changes would be empty),
+         * do not treat heal as failure.
          */
-        loc.inode = afr_shd_entry_changes_index_inode (this, subvol,
-                                                       fd->inode->gfid);
-        if (!loc.inode) {
-                /* If granular heal failed on the sink (as it might sometimes
-                 * because it is the src that would mostly contain the granular
-                 * changelogs and the sink's entry-changes would be empty),
-                 * do not treat heal as failure.
-                 */
-                if (is_src)
-                        return -errno;
-                else
-                        return 0;
-        }
+        if (is_src)
+            return -errno;
+        else
+            return 0;
+    }
 
-        ret = syncop_dir_scan (subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
-                               &args, afr_selfheal_entry_granular_dirent);
+    ret = syncop_dir_scan(subvol, &loc, GF_CLIENT_PID_SELF_HEALD, &args,
+                          afr_selfheal_entry_granular_dirent);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (args.mismatch == _gf_true)
-                ret = -1;
+    if (args.mismatch == _gf_true)
+        ret = -1;
 
-        return ret;
+    return ret;
 }
 
 static int
-afr_selfheal_entry_do (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		       int source, unsigned char *sources,
-		       unsigned char *healed_sinks)
+afr_selfheal_entry_do(call_frame_t *frame, xlator_t *this, fd_t *fd, int source,
+                      unsigned char *sources, unsigned char *healed_sinks)
 {
-	int i                   = 0;
-	int ret                 = 0;
-        gf_boolean_t   mismatch = _gf_false;
-        afr_local_t   *local    = NULL;
-	afr_private_t *priv     = NULL;
-
-	priv = this->private;
-        local = frame->local;
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                AFR_MSG_SELF_HEAL_INFO, "performing entry selfheal on %s",
-		uuid_utoa (fd->inode->gfid));
-
-	for (i = 0; i < priv->child_count; i++) {
-                /* Expunge */
-		if (!healed_sinks[i])
-			continue;
-
-                if (!local->need_full_crawl)
-                /* Why call afr_selfheal_entry_granular() on a "healed sink",
-                 * given that it is the source that contains the granular
-                 * indices?
-                 * If the index for this directory is non-existent or empty on
-                 * this subvol (=> clear sink), then it will return early
-                 * without failure status.
-                 * If the index is non-empty and it is yet a 'healed sink', then
-                 * it is due to a split-brain in which case we anyway need to
-                 * crawl the indices/entry-changes/pargfid directory.
-                 */
-                        ret = afr_selfheal_entry_granular (frame, this, fd, i,
-                                                           _gf_false);
-                else
-                        ret = afr_selfheal_entry_do_subvol (frame, this, fd, i);
-
-                if (ret == -1) {
-                        /* gfid or type mismatch. */
-                        mismatch = _gf_true;
-                        ret = 0;
-                }
-                if (ret)
-                        break;
-	}
-
-        if (!ret && source != -1) {
-                /* Impunge */
-                if (local->need_full_crawl)
-                        ret = afr_selfheal_entry_do_subvol (frame, this, fd,
-                                                            source);
-                else
-                        ret = afr_selfheal_entry_granular (frame, this, fd,
-                                                           source, _gf_true);
+    int i = 0;
+    int ret = 0;
+    gf_boolean_t mismatch = _gf_false;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    local = frame->local;
+
+    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+           "performing entry selfheal on %s", uuid_utoa(fd->inode->gfid));
+
+    for (i = 0; i < priv->child_count; i++) {
+        /* Expunge */
+        if (!healed_sinks[i])
+            continue;
+
+        if (!local->need_full_crawl)
+            /* Why call afr_selfheal_entry_granular() on a "healed sink",
+             * given that it is the source that contains the granular
+             * indices?
+             * If the index for this directory is non-existent or empty on
+             * this subvol (=> clear sink), then it will return early
+             * without failure status.
+             * If the index is non-empty and it is yet a 'healed sink', then
+             * it is due to a split-brain in which case we anyway need to
+             * crawl the indices/entry-changes/pargfid directory.
+             */
+            ret = afr_selfheal_entry_granular(frame, this, fd, i, _gf_false);
+        else
+            ret = afr_selfheal_entry_do_subvol(frame, this, fd, i);
+
+        if (ret == -1) {
+            /* gfid or type mismatch. */
+            mismatch = _gf_true;
+            ret = 0;
         }
+        if (ret)
+            break;
+    }
 
-        if (mismatch == _gf_true)
-                /* undo pending will be skipped */
-                ret = -1;
-	return ret;
+    if (!ret && source != -1) {
+        /* Impunge */
+        if (local->need_full_crawl)
+            ret = afr_selfheal_entry_do_subvol(frame, this, fd, source);
+        else
+            ret = afr_selfheal_entry_granular(frame, this, fd, source,
+                                              _gf_true);
+    }
+
+    if (mismatch == _gf_true)
+        /* undo pending will be skipped */
+        ret = -1;
+    return ret;
 }
 
 static int
-__afr_selfheal_entry (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		      unsigned char *locked_on)
+__afr_selfheal_entry(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                     unsigned char *locked_on)
 {
-	int                     ret                   = -1;
-	int                     source                = -1;
-	unsigned char          *sources               = NULL;
-	unsigned char          *sinks                 = NULL;
-	unsigned char          *data_lock             = NULL;
-        unsigned char          *postop_lock           = NULL;
-	unsigned char          *healed_sinks          = NULL;
-	unsigned char          *undid_pending         = NULL;
-	struct afr_reply       *locked_replies        = NULL;
-        afr_local_t            *local                 = NULL;
-	afr_private_t          *priv                  = NULL;
-        gf_boolean_t            did_sh                = _gf_true;
-
-	priv = this->private;
-        local = frame->local;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	undid_pending = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-        postop_lock = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-				    data_lock);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes could "
-                                      "be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid), ret,
-                                      this->name);
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_entry_prepare (frame, this, fd->inode,
-                                                    data_lock, sources, sinks,
-                                                    healed_sinks,
-						    locked_replies, &source,
-                                                    NULL);
-                if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                local->need_full_crawl = afr_need_full_heal (this,
-                                                             locked_replies,
-                                                             source,
-                                                             healed_sinks,
-                                                         AFR_ENTRY_TRANSACTION);
-	}
-unlock:
-	afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-				data_lock, NULL);
-	if (ret < 0)
-		goto out;
+    int ret = -1;
+    int source = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *postop_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t did_sh = _gf_true;
+
+    priv = this->private;
+    local = frame->local;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+    postop_lock = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               data_lock);
+    {
+        if (ret < AFR_SH_MIN_PARTICIPANTS) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes could "
+                         "be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, this->name);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
 
-        if (!did_sh)
-                goto out;
+        ret = __afr_selfheal_entry_prepare(frame, this, fd->inode, data_lock,
+                                           sources, sinks, healed_sinks,
+                                           locked_replies, &source, NULL);
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
+        }
 
-	ret = afr_selfheal_entry_do (frame, this, fd, source, sources,
-                                     healed_sinks);
-	if (ret)
-		goto out;
-
-        /* Take entrylks in xlator domain before doing post-op (undo-pending) in
-         * entry self-heal. This is to prevent a parallel name self-heal on
-         * an entry under @fd->inode from reading pending xattrs while it is
-         * being modified by SHD after entry sh below, given that
-         * name self-heal takes locks ONLY in xlator domain and is free to read
-         * pending changelog in the absence of the following locking.
-         */
-        ret = afr_selfheal_entrylk (frame, this, fd->inode, this->name, NULL,
-                                    postop_lock);
-        {
-                if (AFR_CMP (data_lock, postop_lock, priv->child_count) != 0) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "post-op after entry self-heal as %d "
-                                      "sub-volumes, as opposed to %d, "
-                                      "could be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid),
-                                      ret, AFR_COUNT (data_lock,
-                                      priv->child_count), this->name);
-                        ret = -ENOTCONN;
-                        goto postop_unlock;
-                }
-
-                ret = afr_selfheal_undo_pending (frame, this, fd->inode,
-                                                 sources, sinks, healed_sinks,
-                                                 undid_pending,
-                                                 AFR_ENTRY_TRANSACTION,
-                                                 locked_replies, postop_lock);
+        local->need_full_crawl = afr_need_full_heal(
+            this, locked_replies, source, healed_sinks, AFR_ENTRY_TRANSACTION);
+    }
+unlock:
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL, data_lock,
+                           NULL);
+    if (ret < 0)
+        goto out;
+
+    if (!did_sh)
+        goto out;
+
+    ret = afr_selfheal_entry_do(frame, this, fd, source, sources, healed_sinks);
+    if (ret)
+        goto out;
+
+    /* Take entrylks in xlator domain before doing post-op (undo-pending) in
+     * entry self-heal. This is to prevent a parallel name self-heal on
+     * an entry under @fd->inode from reading pending xattrs while it is
+     * being modified by SHD after entry sh below, given that
+     * name self-heal takes locks ONLY in xlator domain and is free to read
+     * pending changelog in the absence of the following locking.
+     */
+    ret = afr_selfheal_entrylk(frame, this, fd->inode, this->name, NULL,
+                               postop_lock);
+    {
+        if (AFR_CMP(data_lock, postop_lock, priv->child_count) != 0) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "post-op after entry self-heal as %d "
+                         "sub-volumes, as opposed to %d, "
+                         "could be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret,
+                         AFR_COUNT(data_lock, priv->child_count), this->name);
+            ret = -ENOTCONN;
+            goto postop_unlock;
         }
+
+        ret = afr_selfheal_undo_pending(
+            frame, this, fd->inode, sources, sinks, healed_sinks, undid_pending,
+            AFR_ENTRY_TRANSACTION, locked_replies, postop_lock);
+    }
 postop_unlock:
-        afr_selfheal_unentrylk (frame, this, fd->inode, this->name, NULL,
-                                postop_lock, NULL);
+    afr_selfheal_unentrylk(frame, this, fd->inode, this->name, NULL,
+                           postop_lock, NULL);
 out:
-        if (did_sh)
-                afr_log_selfheal (fd->inode->gfid, this, ret, "entry", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
-
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-	return ret;
+    if (did_sh)
+        afr_log_selfheal(fd->inode->gfid, this, ret, "entry", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
+
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
 }
 
-
 static fd_t *
-afr_selfheal_data_opendir (xlator_t *this, inode_t *inode)
+afr_selfheal_data_opendir(xlator_t *this, inode_t *inode)
 {
-	loc_t loc = {0,};
-	int ret = 0;
-	fd_t *fd = NULL;
-
-	fd = fd_create (inode, 0);
-	if (!fd)
-		return NULL;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-	ret = syncop_opendir (this, &loc, fd, NULL, NULL);
-	if (ret) {
-		fd_unref (fd);
-		fd = NULL;
-	} else {
-		fd_bind (fd);
-	}
-
-	loc_wipe (&loc);
-        return fd;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
+    fd_t *fd = NULL;
+
+    fd = fd_create(inode, 0);
+    if (!fd)
+        return NULL;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    ret = syncop_opendir(this, &loc, fd, NULL, NULL);
+    if (ret) {
+        fd_unref(fd);
+        fd = NULL;
+    } else {
+        fd_bind(fd);
+    }
+
+    loc_wipe(&loc);
+    return fd;
 }
 
-
 int
-afr_selfheal_entry (call_frame_t *frame, xlator_t *this, inode_t *inode)
+afr_selfheal_entry(call_frame_t *frame, xlator_t *this, inode_t *inode)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *locked_on = NULL;
-	fd_t *fd = NULL;
-	int ret = 0;
-
-	priv = this->private;
-
-	fd = afr_selfheal_data_opendir (this, inode);
-	if (!fd)
-		return -EIO;
-
-	locked_on = alloca0 (priv->child_count);
-
-	ret = afr_selfheal_tie_breaker_entrylk (frame, this, inode,
-	                                        priv->sh_domain, NULL,
-                                                locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-                        gf_msg_debug (this->name, 0, "%s: Skipping "
-                                      "entry self-heal as only %d sub-volumes could "
-                                      "be locked in %s domain",
-                                      uuid_utoa (fd->inode->gfid), ret,
-                                      priv->sh_domain);
-			/* Either less than two subvols available, or another
-			   selfheal (from another server) is in progress. Skip
-			   for now in any case there isn't anything to do.
-			*/
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-                ret = __afr_selfheal_entry (frame, this, fd, locked_on);
-	}
+    afr_private_t *priv = NULL;
+    unsigned char *locked_on = NULL;
+    fd_t *fd = NULL;
+    int ret = 0;
+
+    priv = this->private;
+
+    fd = afr_selfheal_data_opendir(this, inode);
+    if (!fd)
+        return -EIO;
+
+    locked_on = alloca0(priv->child_count);
+
+    ret = afr_selfheal_tie_breaker_entrylk(frame, this, inode, priv->sh_domain,
+                                           NULL, locked_on);
+    {
+        if (ret < AFR_SH_MIN_PARTICIPANTS) {
+            gf_msg_debug(this->name, 0,
+                         "%s: Skipping "
+                         "entry self-heal as only %d sub-volumes could "
+                         "be locked in %s domain",
+                         uuid_utoa(fd->inode->gfid), ret, priv->sh_domain);
+            /* Either less than two subvols available, or another
+               selfheal (from another server) is in progress. Skip
+               for now in any case there isn't anything to do.
+            */
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_entry(frame, this, fd, locked_on);
+    }
 unlock:
-	afr_selfheal_unentrylk (frame, this, inode, priv->sh_domain, NULL,
-                                locked_on, NULL);
+    afr_selfheal_unentrylk(frame, this, inode, priv->sh_domain, NULL, locked_on,
+                           NULL);
 
-	if (fd)
-		fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-metadata.c b/xlators/cluster/afr/src/afr-self-heal-metadata.c
index 199f8961480..be6e574b6ca 100644
--- a/xlators/cluster/afr/src/afr-self-heal-metadata.c
+++ b/xlators/cluster/afr/src/afr-self-heal-metadata.c
@@ -8,109 +8,108 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "byte-order.h"
 #include "protocol-common.h"
 #include "events.h"
 
-#define AFR_HEAL_ATTR (GF_SET_ATTR_UID|GF_SET_ATTR_GID|GF_SET_ATTR_MODE)
+#define AFR_HEAL_ATTR (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE)
 
 static gf_boolean_t
-_afr_ignorable_key_match (dict_t *d, char *k, data_t *val, void *mdata)
+_afr_ignorable_key_match(dict_t *d, char *k, data_t *val, void *mdata)
 {
-        return afr_is_xattr_ignorable (k);
+    return afr_is_xattr_ignorable(k);
 }
 
 void
-afr_delete_ignorable_xattrs (dict_t *xattr)
+afr_delete_ignorable_xattrs(dict_t *xattr)
 {
-        dict_foreach_match (xattr, _afr_ignorable_key_match, NULL,
-                            dict_remove_foreach_fn, NULL);
+    dict_foreach_match(xattr, _afr_ignorable_key_match, NULL,
+                       dict_remove_foreach_fn, NULL);
 }
 
 int
-__afr_selfheal_metadata_do (call_frame_t *frame, xlator_t *this, inode_t *inode,
-                            int source, unsigned char *healed_sinks,
-                            struct afr_reply *locked_replies)
+__afr_selfheal_metadata_do(call_frame_t *frame, xlator_t *this, inode_t *inode,
+                           int source, unsigned char *healed_sinks,
+                           struct afr_reply *locked_replies)
 {
-	int ret = -1;
-	loc_t loc = {0,};
-	dict_t *xattr = NULL;
-	dict_t *old_xattr = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-
-	priv = this->private;
-
-	loc.inode = inode_ref (inode);
-	gf_uuid_copy (loc.gfid, inode->gfid);
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                AFR_MSG_SELF_HEAL_INFO, "performing metadata selfheal on %s",
-		uuid_utoa (inode->gfid));
-
-	ret = syncop_getxattr (priv->children[source], &loc, &xattr, NULL,
-                               NULL, NULL);
-	if (ret < 0) {
-		ret = -EIO;
-                goto out;
-	}
-
-	afr_delete_ignorable_xattrs (xattr);
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (old_xattr) {
-                        dict_unref (old_xattr);
-                        old_xattr = NULL;
-                }
-
-		if (!healed_sinks[i])
-			continue;
-
-		ret = syncop_setattr (priv->children[i], &loc,
-				      &locked_replies[source].poststat,
-				      AFR_HEAL_ATTR, NULL, NULL, NULL, NULL);
-		if (ret)
-			healed_sinks[i] = 0;
-
-		ret = syncop_getxattr (priv->children[i], &loc, &old_xattr, 0,
-                                       NULL, NULL);
-		if (old_xattr) {
-			afr_delete_ignorable_xattrs (old_xattr);
-			ret = syncop_removexattr (priv->children[i], &loc, "",
-						  old_xattr, NULL);
-                        if (ret)
-                                healed_sinks[i] = 0;
-		}
-
-		ret = syncop_setxattr (priv->children[i], &loc, xattr, 0, NULL,
-                                       NULL);
-		if (ret)
-			healed_sinks[i] = 0;
-	}
-        ret = 0;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    dict_t *old_xattr = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+
+    priv = this->private;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+           "performing metadata selfheal on %s", uuid_utoa(inode->gfid));
+
+    ret = syncop_getxattr(priv->children[source], &loc, &xattr, NULL, NULL,
+                          NULL);
+    if (ret < 0) {
+        ret = -EIO;
+        goto out;
+    }
+
+    afr_delete_ignorable_xattrs(xattr);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (old_xattr) {
+            dict_unref(old_xattr);
+            old_xattr = NULL;
+        }
+
+        if (!healed_sinks[i])
+            continue;
+
+        ret = syncop_setattr(priv->children[i], &loc,
+                             &locked_replies[source].poststat, AFR_HEAL_ATTR,
+                             NULL, NULL, NULL, NULL);
+        if (ret)
+            healed_sinks[i] = 0;
+
+        ret = syncop_getxattr(priv->children[i], &loc, &old_xattr, 0, NULL,
+                              NULL);
+        if (old_xattr) {
+            afr_delete_ignorable_xattrs(old_xattr);
+            ret = syncop_removexattr(priv->children[i], &loc, "", old_xattr,
+                                     NULL);
+            if (ret)
+                healed_sinks[i] = 0;
+        }
+
+        ret = syncop_setxattr(priv->children[i], &loc, xattr, 0, NULL, NULL);
+        if (ret)
+            healed_sinks[i] = 0;
+    }
+    ret = 0;
 
 out:
-	loc_wipe (&loc);
-	if (xattr)
-		dict_unref (xattr);
-        if (old_xattr)
-                dict_unref (old_xattr);
+    loc_wipe(&loc);
+    if (xattr)
+        dict_unref(xattr);
+    if (old_xattr)
+        dict_unref(old_xattr);
 
-	return ret;
+    return ret;
 }
 
 static uint64_t
 mtime_ns(struct iatt *ia)
 {
-        uint64_t ret;
+    uint64_t ret;
 
-        ret = (((uint64_t)(ia->ia_mtime)) * 1000000000)
-            + (uint64_t)(ia->ia_mtime_nsec);
+    ret = (((uint64_t)(ia->ia_mtime)) * 1000000000) +
+          (uint64_t)(ia->ia_mtime_nsec);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -123,382 +122,367 @@ mtime_ns(struct iatt *ia)
  * the source with the most recent modification date.
  */
 static int
-afr_dirtime_splitbrain_source (call_frame_t *frame, xlator_t *this,
-                               struct afr_reply *replies,
-                               unsigned char *locked_on)
+afr_dirtime_splitbrain_source(call_frame_t *frame, xlator_t *this,
+                              struct afr_reply *replies,
+                              unsigned char *locked_on)
 {
-        afr_private_t *priv  = NULL;
-        int            source = -1;
-        struct iatt    source_ia;
-        struct iatt    child_ia;
-        uint64_t       mtime = 0;
-        int            i;
-        int            ret   = -1;
-
-        priv = this->private;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!locked_on[i])
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                if (mtime_ns(&replies[i].poststat) <= mtime)
-                        continue;
-
-                mtime = mtime_ns(&replies[i].poststat);
-                source = i;
-        }
-
-        if (source == -1)
-                goto out;
-
-        source_ia = replies[source].poststat;
-        if (source_ia.ia_type != IA_IFDIR)
-                goto out;
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (i == source)
-                        continue;
-
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret != 0)
-                        continue;
-
-                child_ia = replies[i].poststat;
-
-                if (!IA_EQUAL(source_ia, child_ia, gfid) ||
-                    !IA_EQUAL(source_ia, child_ia, type) ||
-                    !IA_EQUAL(source_ia, child_ia, prot) ||
-                    !IA_EQUAL(source_ia, child_ia, uid) ||
-                    !IA_EQUAL(source_ia, child_ia, gid) ||
-                    !afr_xattrs_are_equal (replies[source].xdata,
-                                           replies[i].xdata))
-                        goto out;
-        }
-
-        /*
-         * Metadata split brain is just about [amc]time
-         * We return our source.
-         */
-        ret = source;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    struct iatt source_ia;
+    struct iatt child_ia;
+    uint64_t mtime = 0;
+    int i;
+    int ret = -1;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!locked_on[i])
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        if (mtime_ns(&replies[i].poststat) <= mtime)
+            continue;
+
+        mtime = mtime_ns(&replies[i].poststat);
+        source = i;
+    }
+
+    if (source == -1)
+        goto out;
+
+    source_ia = replies[source].poststat;
+    if (source_ia.ia_type != IA_IFDIR)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (i == source)
+            continue;
+
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret != 0)
+            continue;
+
+        child_ia = replies[i].poststat;
+
+        if (!IA_EQUAL(source_ia, child_ia, gfid) ||
+            !IA_EQUAL(source_ia, child_ia, type) ||
+            !IA_EQUAL(source_ia, child_ia, prot) ||
+            !IA_EQUAL(source_ia, child_ia, uid) ||
+            !IA_EQUAL(source_ia, child_ia, gid) ||
+            !afr_xattrs_are_equal(replies[source].xdata, replies[i].xdata))
+            goto out;
+    }
+
+    /*
+     * Metadata split brain is just about [amc]time
+     * We return our source.
+     */
+    ret = source;
 out:
-        return ret;
+    return ret;
 }
 
-
 /*
  * Look for mismatching uid/gid or mode or user xattrs even if
  * AFR xattrs don't say so, and pick one arbitrarily as winner. */
 
 static int
-__afr_selfheal_metadata_finalize_source (call_frame_t *frame, xlator_t *this,
-                                         inode_t *inode,
-                                         unsigned char *sources,
-                                         unsigned char *sinks,
-					 unsigned char *healed_sinks,
-					 unsigned char *undid_pending,
-					 unsigned char *locked_on,
-					 struct afr_reply *replies)
+__afr_selfheal_metadata_finalize_source(call_frame_t *frame, xlator_t *this,
+                                        inode_t *inode, unsigned char *sources,
+                                        unsigned char *sinks,
+                                        unsigned char *healed_sinks,
+                                        unsigned char *undid_pending,
+                                        unsigned char *locked_on,
+                                        struct afr_reply *replies)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	struct iatt srcstat = {0, };
-	int source = -1;
-	int sources_count = 0;
-
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-	    || !sources_count) {
-
-                source = afr_mark_split_brain_source_sinks (frame, this, inode,
-                                                            sources, sinks,
-                                                            healed_sinks,
-                                                            locked_on, replies,
-                                                      AFR_METADATA_TRANSACTION);
-                if (source >= 0) {
-                        _afr_fav_child_reset_sink_xattrs (frame, this, inode,
-                                                         source, healed_sinks,
-                                                         undid_pending,
-                                                       AFR_METADATA_TRANSACTION,
-                                                         locked_on, replies);
-                        goto out;
-                }
-
-		/* If this is a directory mtime/ctime only split brain
-		   use the most recent */
-		source = afr_dirtime_splitbrain_source (frame, this,
-							replies, locked_on);
-		if (source != -1) {
-		        gf_msg (this->name, GF_LOG_INFO, 0,
-                                AFR_MSG_SPLIT_BRAIN, "clear time "
-				"split brain on %s",
-				 uuid_utoa (replies[source].poststat.ia_gfid));
-			sources[source] = 1;
-			healed_sinks[source] = 0;
-                        goto out;
-		}
-
-		if (!priv->metadata_splitbrain_forced_heal) {
-                        gf_event (EVENT_AFR_SPLIT_BRAIN, "subvol=%s;"
-                                  "type=metadata;file=%s",
-                                  this->name, uuid_utoa(inode->gfid));
-			return -EIO;
-		}
-
-		/* Metadata split brain, select one subvol
-		   arbitrarily */
-		for (i = 0; i < priv->child_count; i++) {
-			if (locked_on[i] && healed_sinks[i]) {
-				sources[i] = 1;
-				healed_sinks[i] = 0;
-				break;
-			}
-		}
-	}
-
-        /* No split brain at this point. If we were called from
-         * afr_heal_splitbrain_file(), abort.*/
-        if (afr_dict_contains_heal_op(frame))
-                return -EIO;
-
-        source = afr_choose_source_by_policy (priv, sources,
-                                              AFR_METADATA_TRANSACTION);
-        srcstat = replies[source].poststat;
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!sources[i] || i == source)
-			continue;
-		if (!IA_EQUAL (srcstat, replies[i].poststat, type) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, uid) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, gid) ||
-		    !IA_EQUAL (srcstat, replies[i].poststat, prot)) {
-                        gf_msg_debug (this->name, 0, "%s: iatt mismatch "
-                                      "for source(%d) vs (%d)",
-                                      uuid_utoa
-                                      (replies[source].poststat.ia_gfid),
-                                      source, i);
-			sources[i] = 0;
-			healed_sinks[i] = 1;
-		}
-	}
-
-        for (i =0; i < priv->child_count; i++) {
-		if (!sources[i] || i == source)
-			continue;
-                if (!afr_xattrs_are_equal (replies[source].xdata,
-                                           replies[i].xdata)) {
-                        gf_msg_debug (this->name, 0, "%s: xattr mismatch "
-                                      "for source(%d) vs (%d)",
-                                      uuid_utoa
-                                      (replies[source].poststat.ia_gfid),
-                                      source, i);
-                        sources[i] = 0;
-                        healed_sinks[i] = 1;
-                }
+    int i = 0;
+    afr_private_t *priv = NULL;
+    struct iatt srcstat = {
+        0,
+    };
+    int source = -1;
+    int sources_count = 0;
+
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count) {
+        source = afr_mark_split_brain_source_sinks(
+            frame, this, inode, sources, sinks, healed_sinks, locked_on,
+            replies, AFR_METADATA_TRANSACTION);
+        if (source >= 0) {
+            _afr_fav_child_reset_sink_xattrs(
+                frame, this, inode, source, healed_sinks, undid_pending,
+                AFR_METADATA_TRANSACTION, locked_on, replies);
+            goto out;
+        }
+
+        /* If this is a directory mtime/ctime only split brain
+           use the most recent */
+        source = afr_dirtime_splitbrain_source(frame, this, replies, locked_on);
+        if (source != -1) {
+            gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SPLIT_BRAIN,
+                   "clear time "
+                   "split brain on %s",
+                   uuid_utoa(replies[source].poststat.ia_gfid));
+            sources[source] = 1;
+            healed_sinks[source] = 0;
+            goto out;
         }
 
+        if (!priv->metadata_splitbrain_forced_heal) {
+            gf_event(EVENT_AFR_SPLIT_BRAIN,
+                     "subvol=%s;"
+                     "type=metadata;file=%s",
+                     this->name, uuid_utoa(inode->gfid));
+            return -EIO;
+        }
+
+        /* Metadata split brain, select one subvol
+           arbitrarily */
+        for (i = 0; i < priv->child_count; i++) {
+            if (locked_on[i] && healed_sinks[i]) {
+                sources[i] = 1;
+                healed_sinks[i] = 0;
+                break;
+            }
+        }
+    }
+
+    /* No split brain at this point. If we were called from
+     * afr_heal_splitbrain_file(), abort.*/
+    if (afr_dict_contains_heal_op(frame))
+        return -EIO;
+
+    source = afr_choose_source_by_policy(priv, sources,
+                                         AFR_METADATA_TRANSACTION);
+    srcstat = replies[source].poststat;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] || i == source)
+            continue;
+        if (!IA_EQUAL(srcstat, replies[i].poststat, type) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, uid) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, gid) ||
+            !IA_EQUAL(srcstat, replies[i].poststat, prot)) {
+            gf_msg_debug(this->name, 0,
+                         "%s: iatt mismatch "
+                         "for source(%d) vs (%d)",
+                         uuid_utoa(replies[source].poststat.ia_gfid), source,
+                         i);
+            sources[i] = 0;
+            healed_sinks[i] = 1;
+        }
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i] || i == source)
+            continue;
+        if (!afr_xattrs_are_equal(replies[source].xdata, replies[i].xdata)) {
+            gf_msg_debug(this->name, 0,
+                         "%s: xattr mismatch "
+                         "for source(%d) vs (%d)",
+                         uuid_utoa(replies[source].poststat.ia_gfid), source,
+                         i);
+            sources[i] = 0;
+            healed_sinks[i] = 1;
+        }
+    }
+
 out:
-        afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-	return source;
+    afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+    return source;
 }
 
-
 int
-__afr_selfheal_metadata_prepare (call_frame_t *frame, xlator_t *this, inode_t *inode,
-				 unsigned char *locked_on, unsigned char *sources,
-				 unsigned char *sinks, unsigned char *healed_sinks,
-                                 unsigned char *undid_pending,
-				 struct afr_reply *replies, gf_boolean_t *pflag)
+__afr_selfheal_metadata_prepare(call_frame_t *frame, xlator_t *this,
+                                inode_t *inode, unsigned char *locked_on,
+                                unsigned char *sources, unsigned char *sinks,
+                                unsigned char *healed_sinks,
+                                unsigned char *undid_pending,
+                                struct afr_reply *replies, gf_boolean_t *pflag)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-	int i = 0;
-        uint64_t *witness = NULL;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    uint64_t *witness = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	ret = afr_selfheal_unlocked_discover (frame, inode, inode->gfid,
-					      replies);
-        if (ret)
-                return ret;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-        ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_METADATA_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           pflag);
-	if (ret)
-		return ret;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-        /* If any source has witness, pick first
-         * witness source and make everybody else sinks */
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i] && witness[i]) {
-                        source = i;
-                        break;
-                }
-        }
+    ret = afr_selfheal_unlocked_discover(frame, inode, inode->gfid, replies);
+    if (ret)
+        return ret;
 
-        if (source != -1) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (i != source && sources[i]) {
-                                sources[i] = 0;
-                                healed_sinks[i] = 1;
-                        }
-                }
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_METADATA_TRANSACTION, locked_on,
+                                      sources, sinks, witness, pflag);
+    if (ret)
+        return ret;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    /* If any source has witness, pick first
+     * witness source and make everybody else sinks */
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i] && witness[i]) {
+            source = i;
+            break;
         }
+    }
 
-	source = __afr_selfheal_metadata_finalize_source (frame, this, inode,
-                                                          sources, sinks,
-                                                          healed_sinks,
-                                                          undid_pending,
-                                                          locked_on, replies);
+    if (source != -1) {
+        for (i = 0; i < priv->child_count; i++) {
+            if (i != source && sources[i]) {
+                sources[i] = 0;
+                healed_sinks[i] = 1;
+            }
+        }
+    }
 
-	if (source < 0)
-		return -EIO;
+    source = __afr_selfheal_metadata_finalize_source(
+        frame, this, inode, sources, sinks, healed_sinks, undid_pending,
+        locked_on, replies);
 
-	return source;
-}
+    if (source < 0)
+        return -EIO;
 
-int
-afr_selfheal_metadata (call_frame_t *frame, xlator_t *this, inode_t *inode)
-{
-	afr_private_t *priv = NULL;
-	int ret = -1;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *data_lock = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *undid_pending = NULL;
-	struct afr_reply *locked_replies = NULL;
-        gf_boolean_t did_sh = _gf_true;
-	int source = -1;
-
-	priv = this->private;
-
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-	undid_pending = alloca0 (priv->child_count);
-	data_lock = alloca0 (priv->child_count);
-
-	locked_replies = alloca0 (sizeof (*locked_replies) * priv->child_count);
-
-	ret = afr_selfheal_inodelk (frame, this, inode, this->name,
-				    LLONG_MAX - 1, 0, data_lock);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_metadata_prepare (frame, this, inode,
-                                                       data_lock, sources,
-                                                       sinks, healed_sinks,
-                                                       undid_pending,
-						       locked_replies, NULL);
-		if (ret < 0)
-			goto unlock;
-
-		source = ret;
-
-                if (AFR_COUNT (healed_sinks, priv->child_count) == 0) {
-                        did_sh = _gf_false;
-                        goto unlock;
-                }
-
-                ret = __afr_selfheal_metadata_do (frame, this, inode, source,
-                                                  healed_sinks, locked_replies);
-                if (ret)
-                        goto unlock;
-
-                /* Restore atime/mtime for files that don't need data heal as
-                 * restoring timestamps happens only as a part of data-heal.
-                 */
-                if (!IA_ISREG (locked_replies[source].poststat.ia_type))
-                        afr_selfheal_restore_time (frame, this, inode, source,
-                                                  healed_sinks, locked_replies);
-
-                ret = afr_selfheal_undo_pending (frame, this, inode, sources,
-                                                 sinks, healed_sinks,
-                                                 undid_pending,
-                                                 AFR_METADATA_TRANSACTION,
-                                                 locked_replies, data_lock);
-	}
-unlock:
-	afr_selfheal_uninodelk (frame, this, inode, this->name,
-				LLONG_MAX -1, 0, data_lock);
-
-        if (did_sh)
-                afr_log_selfheal (inode->gfid, this, ret, "metadata", source,
-                                  sources, healed_sinks);
-        else
-                ret = 1;
-
-        if (locked_replies)
-                afr_replies_wipe (locked_replies, priv->child_count);
-	return ret;
+    return source;
 }
 
 int
-afr_selfheal_metadata_by_stbuf (xlator_t *this, struct iatt *stbuf)
+afr_selfheal_metadata(call_frame_t *frame, xlator_t *this, inode_t *inode)
 {
-        inode_t      *inode      = NULL;
-        inode_t      *link_inode = NULL;
-        call_frame_t *frame      = NULL;
-        int          ret         = 0;
-
-        if (gf_uuid_is_null (stbuf->ia_gfid)) {
-                ret = -EINVAL;
-                goto out;
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *data_lock = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *undid_pending = NULL;
+    struct afr_reply *locked_replies = NULL;
+    gf_boolean_t did_sh = _gf_true;
+    int source = -1;
+
+    priv = this->private;
+
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+    undid_pending = alloca0(priv->child_count);
+    data_lock = alloca0(priv->child_count);
+
+    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);
+
+    ret = afr_selfheal_inodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                               data_lock);
+    {
+        if (ret < AFR_SH_MIN_PARTICIPANTS) {
+            ret = -ENOTCONN;
+            goto unlock;
         }
 
-        inode = inode_new (this->itable);
-        if (!inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        ret = __afr_selfheal_metadata_prepare(
+            frame, this, inode, data_lock, sources, sinks, healed_sinks,
+            undid_pending, locked_replies, NULL);
+        if (ret < 0)
+            goto unlock;
 
-        link_inode = inode_link (inode, NULL, NULL, stbuf);
-        if (!link_inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        source = ret;
 
-        frame = afr_frame_create (this, &ret);
-        if (!frame) {
-                ret = -ret;
-                goto out;
+        if (AFR_COUNT(healed_sinks, priv->child_count) == 0) {
+            did_sh = _gf_false;
+            goto unlock;
         }
 
-        ret = afr_selfheal_metadata (frame, this, link_inode);
+        ret = __afr_selfheal_metadata_do(frame, this, inode, source,
+                                         healed_sinks, locked_replies);
+        if (ret)
+            goto unlock;
+
+        /* Restore atime/mtime for files that don't need data heal as
+         * restoring timestamps happens only as a part of data-heal.
+         */
+        if (!IA_ISREG(locked_replies[source].poststat.ia_type))
+            afr_selfheal_restore_time(frame, this, inode, source, healed_sinks,
+                                      locked_replies);
+
+        ret = afr_selfheal_undo_pending(
+            frame, this, inode, sources, sinks, healed_sinks, undid_pending,
+            AFR_METADATA_TRANSACTION, locked_replies, data_lock);
+    }
+unlock:
+    afr_selfheal_uninodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,
+                           data_lock);
+
+    if (did_sh)
+        afr_log_selfheal(inode->gfid, this, ret, "metadata", source, sources,
+                         healed_sinks);
+    else
+        ret = 1;
+
+    if (locked_replies)
+        afr_replies_wipe(locked_replies, priv->child_count);
+    return ret;
+}
+
+int
+afr_selfheal_metadata_by_stbuf(xlator_t *this, struct iatt *stbuf)
+{
+    inode_t *inode = NULL;
+    inode_t *link_inode = NULL;
+    call_frame_t *frame = NULL;
+    int ret = 0;
+
+    if (gf_uuid_is_null(stbuf->ia_gfid)) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    inode = inode_new(this->itable);
+    if (!inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    link_inode = inode_link(inode, NULL, NULL, stbuf);
+    if (!link_inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    frame = afr_frame_create(this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    ret = afr_selfheal_metadata(frame, this, link_inode);
 out:
-        if (inode)
-                inode_unref (inode);
-        if (link_inode)
-                inode_unref (link_inode);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        return ret;
+    if (inode)
+        inode_unref(inode);
+    if (link_inode)
+        inode_unref(link_inode);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heal-name.c b/xlators/cluster/afr/src/afr-self-heal-name.c
index 0a5be29d5ee..39aacee6ecf 100644
--- a/xlators/cluster/afr/src/afr-self-heal-name.c
+++ b/xlators/cluster/afr/src/afr-self-heal-name.c
@@ -8,696 +8,667 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "events.h"
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "afr-messages.h"
 
 int
-__afr_selfheal_assign_gfid (xlator_t *this, inode_t *parent, uuid_t pargfid,
-                            const char *bname, inode_t *inode,
-                            struct afr_reply *replies, void *gfid,
-                            unsigned char *locked_on, int source,
-                            unsigned char *sources, gf_boolean_t is_gfid_absent)
+__afr_selfheal_assign_gfid(xlator_t *this, inode_t *parent, uuid_t pargfid,
+                           const char *bname, inode_t *inode,
+                           struct afr_reply *replies, void *gfid,
+                           unsigned char *locked_on, int source,
+                           unsigned char *sources, gf_boolean_t is_gfid_absent)
 {
-	int             ret          = 0;
-        int             up_count     = 0;
-        int             locked_count = 0;
-	afr_private_t  *priv         = NULL;
+    int ret = 0;
+    int up_count = 0;
+    int locked_count = 0;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
+    priv = this->private;
 
-	gf_uuid_copy (parent->gfid, pargfid);
+    gf_uuid_copy(parent->gfid, pargfid);
 
-        if (is_gfid_absent) {
-                /* Ensure all children of AFR are up before performing gfid heal, to
-                 * guard against the possibility of gfid split brain. */
+    if (is_gfid_absent) {
+        /* Ensure all children of AFR are up before performing gfid heal, to
+         * guard against the possibility of gfid split brain. */
 
-                up_count = AFR_COUNT (priv->child_up, priv->child_count);
-                if (up_count != priv->child_count) {
-                        ret = -EIO;
-                        goto out;
-                }
+        up_count = AFR_COUNT(priv->child_up, priv->child_count);
+        if (up_count != priv->child_count) {
+            ret = -EIO;
+            goto out;
+        }
 
-                locked_count = AFR_COUNT (locked_on, priv->child_count);
-                if (locked_count != priv->child_count) {
-                        ret = -EIO;
-                        goto out;
-                }
+        locked_count = AFR_COUNT(locked_on, priv->child_count);
+        if (locked_count != priv->child_count) {
+            ret = -EIO;
+            goto out;
         }
+    }
 
-        afr_lookup_and_heal_gfid (this, parent, bname, inode, replies, source,
-                                  sources, gfid);
+    afr_lookup_and_heal_gfid(this, parent, bname, inode, replies, source,
+                             sources, gfid);
 
 out:
-	return ret;
+    return ret;
 }
 
 int
-__afr_selfheal_name_impunge (call_frame_t *frame, xlator_t *this,
-                             inode_t *parent, uuid_t pargfid,
-                             const char *bname, inode_t *inode,
-                             struct afr_reply *replies, int gfid_idx)
+__afr_selfheal_name_impunge(call_frame_t *frame, xlator_t *this,
+                            inode_t *parent, uuid_t pargfid, const char *bname,
+                            inode_t *inode, struct afr_reply *replies,
+                            int gfid_idx)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-        int ret = 0;
-        unsigned char *sources = NULL;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int ret = 0;
+    unsigned char *sources = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-	sources = alloca0 (priv->child_count);
+    sources = alloca0(priv->child_count);
 
-	gf_uuid_copy (parent->gfid, pargfid);
+    gf_uuid_copy(parent->gfid, pargfid);
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[gfid_idx].poststat.ia_gfid) == 0) {
-                        sources[i] = 1;
-			continue;
-                }
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[gfid_idx].poststat.ia_gfid) == 0) {
+            sources[i] = 1;
+            continue;
         }
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (sources[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i])
+            continue;
 
-		ret |= afr_selfheal_recreate_entry (frame, i, gfid_idx, sources,
-                                                    parent, bname, inode,
-                                                    replies);
-	}
+        ret |= afr_selfheal_recreate_entry(frame, i, gfid_idx, sources, parent,
+                                           bname, inode, replies);
+    }
 
-	return ret;
+    return ret;
 }
 
-
 int
-__afr_selfheal_name_expunge (xlator_t *this, inode_t *parent, uuid_t pargfid,
-                             const char *bname, inode_t *inode,
-			     struct afr_reply *replies)
+__afr_selfheal_name_expunge(xlator_t *this, inode_t *parent, uuid_t pargfid,
+                            const char *bname, inode_t *inode,
+                            struct afr_reply *replies)
 {
-	loc_t loc = {0, };
-	int i = 0;
-	afr_private_t *priv = NULL;
-	char g[64];
-	int ret = 0;
-
-	priv = this->private;
-
-	loc.parent = inode_ref (parent);
-	gf_uuid_copy (loc.pargfid, pargfid);
-	loc.name = bname;
-	loc.inode = inode_ref (inode);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
-
-		if (replies[i].op_ret)
-			continue;
-
-		switch (replies[i].poststat.ia_type) {
-		case IA_IFDIR:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-			        "expunging dir %s/%s (%s) on %s",
-			        uuid_utoa (pargfid), bname,
-			        uuid_utoa_r (replies[i].poststat.ia_gfid, g),
-			        priv->children[i]->name);
-
-			ret |= syncop_rmdir (priv->children[i], &loc, 1, NULL,
-                                             NULL);
-			break;
-		default:
-		        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                AFR_MSG_EXPUNGING_FILE_OR_DIR,
-		                "expunging file %s/%s (%s) on %s",
-			        uuid_utoa (pargfid), bname,
-			        uuid_utoa_r (replies[i].poststat.ia_gfid, g),
-			        priv->children[i]->name);
-
-			ret |= syncop_unlink (priv->children[i], &loc, NULL,
-                                              NULL);
-			break;
-		}
-	}
-
-	loc_wipe (&loc);
-
-	return ret;
+    loc_t loc = {
+        0,
+    };
+    int i = 0;
+    afr_private_t *priv = NULL;
+    char g[64];
+    int ret = 0;
+
+    priv = this->private;
+
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, pargfid);
+    loc.name = bname;
+    loc.inode = inode_ref(inode);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret)
+            continue;
+
+        switch (replies[i].poststat.ia_type) {
+            case IA_IFDIR:
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                       "expunging dir %s/%s (%s) on %s", uuid_utoa(pargfid),
+                       bname, uuid_utoa_r(replies[i].poststat.ia_gfid, g),
+                       priv->children[i]->name);
+
+                ret |= syncop_rmdir(priv->children[i], &loc, 1, NULL, NULL);
+                break;
+            default:
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       AFR_MSG_EXPUNGING_FILE_OR_DIR,
+                       "expunging file %s/%s (%s) on %s", uuid_utoa(pargfid),
+                       bname, uuid_utoa_r(replies[i].poststat.ia_gfid, g),
+                       priv->children[i]->name);
+
+                ret |= syncop_unlink(priv->children[i], &loc, NULL, NULL);
+                break;
+        }
+    }
 
+    loc_wipe(&loc);
+
+    return ret;
 }
 
 /* This function is to be called after ensuring that there is no gfid mismatch
  * for the inode across multiple sources
  */
 static int
-afr_selfheal_gfid_idx_get (xlator_t *this, struct afr_reply *replies,
-                           unsigned char *sources)
+afr_selfheal_gfid_idx_get(xlator_t *this, struct afr_reply *replies,
+                          unsigned char *sources)
 {
-        int             i        =  0;
-        int             gfid_idx = -1;
-        afr_private_t  *priv     =  NULL;
+    int i = 0;
+    int gfid_idx = -1;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-                if (!sources[i])
-                        continue;
+        if (!sources[i])
+            continue;
 
-                if (gf_uuid_is_null (replies[i].poststat.ia_gfid))
-                        continue;
+        if (gf_uuid_is_null(replies[i].poststat.ia_gfid))
+            continue;
 
-                gfid_idx = i;
-                break;
-        }
-        return gfid_idx;
+        gfid_idx = i;
+        break;
+    }
+    return gfid_idx;
 }
 
 static gf_boolean_t
-afr_selfheal_name_need_heal_check (xlator_t *this, struct afr_reply *replies)
+afr_selfheal_name_need_heal_check(xlator_t *this, struct afr_reply *replies)
 {
-        int             i           = 0;
-	int             first_idx   = -1;
-        gf_boolean_t    need_heal   = _gf_false;
-        afr_private_t  *priv        = NULL;
-
-        priv = this->private;
+    int i = 0;
+    int first_idx = -1;
+    gf_boolean_t need_heal = _gf_false;
+    afr_private_t *priv = NULL;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
+    priv = this->private;
 
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA))
-                        need_heal = _gf_true;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-		if (first_idx == -1) {
-			first_idx = i;
-			continue;
-		}
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA))
+            need_heal = _gf_true;
 
-		if (replies[i].op_ret != replies[first_idx].op_ret)
-			need_heal = _gf_true;
+        if (first_idx == -1) {
+            first_idx = i;
+            continue;
+        }
 
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[first_idx].poststat.ia_gfid))
-			need_heal = _gf_true;
+        if (replies[i].op_ret != replies[first_idx].op_ret)
+            need_heal = _gf_true;
 
-                if ((replies[i].op_ret == 0) &&
-                    (gf_uuid_is_null(replies[i].poststat.ia_gfid)))
-                        need_heal = _gf_true;
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[first_idx].poststat.ia_gfid))
+            need_heal = _gf_true;
 
-	}
+        if ((replies[i].op_ret == 0) &&
+            (gf_uuid_is_null(replies[i].poststat.ia_gfid)))
+            need_heal = _gf_true;
+    }
 
-        return need_heal;
+    return need_heal;
 }
 
 static int
-afr_selfheal_name_type_mismatch_check (xlator_t *this, struct afr_reply *replies,
-                                       int source, unsigned char *sources,
-                                       uuid_t pargfid, const char *bname)
+afr_selfheal_name_type_mismatch_check(xlator_t *this, struct afr_reply *replies,
+                                      int source, unsigned char *sources,
+                                      uuid_t pargfid, const char *bname)
 {
-        int             i           = 0;
-        int             type_idx    = -1;
-        ia_type_t       inode_type  = IA_INVAL;
-        ia_type_t       inode_type1 = IA_INVAL;
-        afr_private_t  *priv        = NULL;
+    int i = 0;
+    int type_idx = -1;
+    ia_type_t inode_type = IA_INVAL;
+    ia_type_t inode_type1 = IA_INVAL;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
 
-                if (replies[i].poststat.ia_type == IA_INVAL)
-                        continue;
+        if (replies[i].poststat.ia_type == IA_INVAL)
+            continue;
 
-                if (inode_type == IA_INVAL) {
-                        inode_type = replies[i].poststat.ia_type;
-                        type_idx = i;
-                        continue;
-                }
-                inode_type1 = replies[i].poststat.ia_type;
-                if (sources[i] || source == -1) {
-                        if ((sources[type_idx] || source == -1) &&
-                            (inode_type != inode_type1)) {
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        AFR_MSG_SPLIT_BRAIN,
-                                        "Type mismatch for <gfid:%s>/%s: "
-                                        "%s on %s and %s on %s",
-                                        uuid_utoa(pargfid), bname,
-                                        gf_inode_type_to_str (inode_type1),
-                                        priv->children[i]->name,
-                                        gf_inode_type_to_str (inode_type),
-                                        priv->children[type_idx]->name);
-                                gf_event (EVENT_AFR_SPLIT_BRAIN,
-                                         "subvol=%s;type=file;"
-                                         "file=<gfid:%s>/%s;count=2;"
-                                         "child-%d=%s;type-%d=%s;child-%d=%s;"
-                                         "type-%d=%s", this->name,
-                                         uuid_utoa (pargfid), bname, i,
-                                         priv->children[i]->name, i,
-                                         gf_inode_type_to_str (inode_type1),
-                                         type_idx,
-                                         priv->children[type_idx]->name,
-                                         type_idx,
-                                         gf_inode_type_to_str (inode_type));
-                                return -EIO;
-                        }
-                        inode_type = replies[i].poststat.ia_type;
-                        type_idx = i;
-                }
+        if (inode_type == IA_INVAL) {
+            inode_type = replies[i].poststat.ia_type;
+            type_idx = i;
+            continue;
         }
-        return 0;
+        inode_type1 = replies[i].poststat.ia_type;
+        if (sources[i] || source == -1) {
+            if ((sources[type_idx] || source == -1) &&
+                (inode_type != inode_type1)) {
+                gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_SPLIT_BRAIN,
+                       "Type mismatch for <gfid:%s>/%s: "
+                       "%s on %s and %s on %s",
+                       uuid_utoa(pargfid), bname,
+                       gf_inode_type_to_str(inode_type1),
+                       priv->children[i]->name,
+                       gf_inode_type_to_str(inode_type),
+                       priv->children[type_idx]->name);
+                gf_event(EVENT_AFR_SPLIT_BRAIN,
+                         "subvol=%s;type=file;"
+                         "file=<gfid:%s>/%s;count=2;"
+                         "child-%d=%s;type-%d=%s;child-%d=%s;"
+                         "type-%d=%s",
+                         this->name, uuid_utoa(pargfid), bname, i,
+                         priv->children[i]->name, i,
+                         gf_inode_type_to_str(inode_type1), type_idx,
+                         priv->children[type_idx]->name, type_idx,
+                         gf_inode_type_to_str(inode_type));
+                return -EIO;
+            }
+            inode_type = replies[i].poststat.ia_type;
+            type_idx = i;
+        }
+    }
+    return 0;
 }
 
 static int
-afr_selfheal_name_gfid_mismatch_check (xlator_t *this, struct afr_reply *replies,
-                                       int source, unsigned char *sources,
-                                       int *gfid_idx, uuid_t pargfid,
-                                       const char *bname, inode_t *inode,
-                                       unsigned char *locked_on, dict_t *xdata)
+afr_selfheal_name_gfid_mismatch_check(xlator_t *this, struct afr_reply *replies,
+                                      int source, unsigned char *sources,
+                                      int *gfid_idx, uuid_t pargfid,
+                                      const char *bname, inode_t *inode,
+                                      unsigned char *locked_on, dict_t *xdata)
 {
-        int             i             = 0;
-	int             gfid_idx_iter = -1;
-        int             ret           = -1;
-        void           *gfid          = NULL;
-        void           *gfid1         = NULL;
-        afr_private_t  *priv          = NULL;
-
-        priv = this->private;
-
-	for (i = 0; i < priv->child_count; i++) {
-                if (!replies[i].valid || replies[i].op_ret != 0)
-                        continue;
-
-		if (gf_uuid_is_null (replies[i].poststat.ia_gfid))
-			continue;
-
-		if (!gfid) {
-			gfid = &replies[i].poststat.ia_gfid;
-			gfid_idx_iter = i;
-			continue;
-		}
-
-                gfid1 = &replies[i].poststat.ia_gfid;
-		if (sources[i] || source == -1) {
-			if ((sources[gfid_idx_iter] || source == -1) &&
-			    gf_uuid_compare (gfid, gfid1)) {
-                                ret = afr_gfid_split_brain_source (this,
-                                                                   replies,
-                                                                   inode,
-                                                                   pargfid,
-                                                                   bname,
-                                                                   gfid_idx_iter,
-                                                                   i, locked_on,
-                                                                   gfid_idx,
-                                                                   xdata);
-                                if (!ret && *gfid_idx >= 0) {
-                                        ret = dict_set_str (xdata,
-                                                             "gfid-heal-msg",
-                                                             "GFID split-brain "
-                                                             "resolved");
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                        GF_LOG_ERROR, 0,
-                                                        AFR_MSG_DICT_SET_FAILED,
-                                                        "Error setting gfid-"
-                                                        "heal-msg dict");
-                                }
-                                return ret;
-			}
-                        gfid = &replies[i].poststat.ia_gfid;
-			gfid_idx_iter = i;
-		}
-	}
-
-        *gfid_idx = gfid_idx_iter;
-        return 0;
+    int i = 0;
+    int gfid_idx_iter = -1;
+    int ret = -1;
+    void *gfid = NULL;
+    void *gfid1 = NULL;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid || replies[i].op_ret != 0)
+            continue;
+
+        if (gf_uuid_is_null(replies[i].poststat.ia_gfid))
+            continue;
+
+        if (!gfid) {
+            gfid = &replies[i].poststat.ia_gfid;
+            gfid_idx_iter = i;
+            continue;
+        }
+
+        gfid1 = &replies[i].poststat.ia_gfid;
+        if (sources[i] || source == -1) {
+            if ((sources[gfid_idx_iter] || source == -1) &&
+                gf_uuid_compare(gfid, gfid1)) {
+                ret = afr_gfid_split_brain_source(this, replies, inode, pargfid,
+                                                  bname, gfid_idx_iter, i,
+                                                  locked_on, gfid_idx, xdata);
+                if (!ret && *gfid_idx >= 0) {
+                    ret = dict_set_str(xdata, "gfid-heal-msg",
+                                       "GFID split-brain "
+                                       "resolved");
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               AFR_MSG_DICT_SET_FAILED,
+                               "Error setting gfid-"
+                               "heal-msg dict");
+                }
+                return ret;
+            }
+            gfid = &replies[i].poststat.ia_gfid;
+            gfid_idx_iter = i;
+        }
+    }
+
+    *gfid_idx = gfid_idx_iter;
+    return 0;
 }
 
 static gf_boolean_t
-afr_selfheal_name_source_empty_check (xlator_t *this, struct afr_reply *replies,
-                                      unsigned char *sources, int source)
+afr_selfheal_name_source_empty_check(xlator_t *this, struct afr_reply *replies,
+                                     unsigned char *sources, int source)
 {
-	int             i               = 0;
-	afr_private_t  *priv            = NULL;
-	gf_boolean_t    source_is_empty = _gf_true;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    gf_boolean_t source_is_empty = _gf_true;
 
-	priv = this->private;
+    priv = this->private;
 
-        if (source == -1) {
-                source_is_empty = _gf_false;
-                goto out;
-        }
+    if (source == -1) {
+        source_is_empty = _gf_false;
+        goto out;
+    }
 
-	for (i = 0; i < priv->child_count; i++) {
-                if (!sources[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!sources[i])
+            continue;
 
-                if (replies[i].op_ret == -1 && replies[i].op_errno == ENOENT)
-                        continue;
+        if (replies[i].op_ret == -1 && replies[i].op_errno == ENOENT)
+            continue;
 
-                source_is_empty = _gf_false;
-                break;
-	}
+        source_is_empty = _gf_false;
+        break;
+    }
 out:
-        return source_is_empty;
+    return source_is_empty;
 }
 
 int
-__afr_selfheal_name_do (call_frame_t *frame, xlator_t *this, inode_t *parent,
-                        uuid_t pargfid, const char *bname, inode_t *inode,
-                        unsigned char *sources, unsigned char *sinks,
-			unsigned char *healed_sinks, int source,
-			unsigned char *locked_on, struct afr_reply *replies,
-                        void *gfid_req, dict_t *xdata)
+__afr_selfheal_name_do(call_frame_t *frame, xlator_t *this, inode_t *parent,
+                       uuid_t pargfid, const char *bname, inode_t *inode,
+                       unsigned char *sources, unsigned char *sinks,
+                       unsigned char *healed_sinks, int source,
+                       unsigned char *locked_on, struct afr_reply *replies,
+                       void *gfid_req, dict_t *xdata)
 {
-	int             gfid_idx        = -1;
-        int             ret             = -1;
-	void           *gfid            = NULL;
-	gf_boolean_t    source_is_empty = _gf_true;
-	gf_boolean_t    need_heal       = _gf_false;
-        gf_boolean_t    is_gfid_absent  = _gf_false;
-
-        need_heal = afr_selfheal_name_need_heal_check (this, replies);
-	if (!need_heal)
-		return 0;
-
-        source_is_empty = afr_selfheal_name_source_empty_check (this, replies,
-                                                                sources,
-                                                                source);
-	if (source_is_empty) {
-		ret = __afr_selfheal_name_expunge (this, parent, pargfid,
-						    bname, inode, replies);
-                if (ret == -EIO)
-                        ret = -1;
-                return ret;
-        }
+    int gfid_idx = -1;
+    int ret = -1;
+    void *gfid = NULL;
+    gf_boolean_t source_is_empty = _gf_true;
+    gf_boolean_t need_heal = _gf_false;
+    gf_boolean_t is_gfid_absent = _gf_false;
+
+    need_heal = afr_selfheal_name_need_heal_check(this, replies);
+    if (!need_heal)
+        return 0;
 
-        ret = afr_selfheal_name_type_mismatch_check (this, replies, source,
-                                                     sources, pargfid, bname);
-        if (ret)
-                return ret;
+    source_is_empty = afr_selfheal_name_source_empty_check(this, replies,
+                                                           sources, source);
+    if (source_is_empty) {
+        ret = __afr_selfheal_name_expunge(this, parent, pargfid, bname, inode,
+                                          replies);
+        if (ret == -EIO)
+            ret = -1;
+        return ret;
+    }
 
-        ret = afr_selfheal_name_gfid_mismatch_check (this, replies, source,
-                                                     sources, &gfid_idx,
-                                                     pargfid, bname, inode,
-                                                     locked_on, xdata);
-        if (ret)
-                return ret;
+    ret = afr_selfheal_name_type_mismatch_check(this, replies, source, sources,
+                                                pargfid, bname);
+    if (ret)
+        return ret;
 
-	if (gfid_idx == -1) {
-                if (!gfid_req || gf_uuid_is_null (gfid_req))
-                        return -1;
-                gfid = gfid_req;
-        } else {
-                gfid = &replies[gfid_idx].poststat.ia_gfid;
-        }
+    ret = afr_selfheal_name_gfid_mismatch_check(this, replies, source, sources,
+                                                &gfid_idx, pargfid, bname,
+                                                inode, locked_on, xdata);
+    if (ret)
+        return ret;
 
-        is_gfid_absent = (gfid_idx == -1) ? _gf_true : _gf_false;
-	ret = __afr_selfheal_assign_gfid (this, parent, pargfid, bname, inode,
-                                          replies, gfid, locked_on, source,
-                                          sources, is_gfid_absent);
-        if (ret)
-                return ret;
+    if (gfid_idx == -1) {
+        if (!gfid_req || gf_uuid_is_null(gfid_req))
+            return -1;
+        gfid = gfid_req;
+    } else {
+        gfid = &replies[gfid_idx].poststat.ia_gfid;
+    }
+
+    is_gfid_absent = (gfid_idx == -1) ? _gf_true : _gf_false;
+    ret = __afr_selfheal_assign_gfid(this, parent, pargfid, bname, inode,
+                                     replies, gfid, locked_on, source, sources,
+                                     is_gfid_absent);
+    if (ret)
+        return ret;
 
-        if (gfid_idx == -1) {
-                gfid_idx = afr_selfheal_gfid_idx_get (this, replies, sources);
-                if (gfid_idx == -1)
-                        return -1;
-        }
+    if (gfid_idx == -1) {
+        gfid_idx = afr_selfheal_gfid_idx_get(this, replies, sources);
+        if (gfid_idx == -1)
+            return -1;
+    }
 
-	ret = __afr_selfheal_name_impunge (frame, this, parent, pargfid,
-                                           bname, inode, replies, gfid_idx);
-        if (ret == -EIO)
-                ret = -1;
+    ret = __afr_selfheal_name_impunge(frame, this, parent, pargfid, bname,
+                                      inode, replies, gfid_idx);
+    if (ret == -EIO)
+        ret = -1;
 
-        return ret;
+    return ret;
 }
 
-
 int
-__afr_selfheal_name_finalize_source (xlator_t *this, unsigned char *sources,
-				     unsigned char *healed_sinks,
-				     unsigned char *locked_on,
-                                     uint64_t *witness)
+__afr_selfheal_name_finalize_source(xlator_t *this, unsigned char *sources,
+                                    unsigned char *healed_sinks,
+                                    unsigned char *locked_on, uint64_t *witness)
 {
-	int i = 0;
-	afr_private_t *priv = NULL;
-	int source = -1;
-	int sources_count = 0;
-
-	priv = this->private;
-
-	sources_count = AFR_COUNT (sources, priv->child_count);
-
-	if ((AFR_CMP (locked_on, healed_sinks, priv->child_count) == 0)
-            || !sources_count || afr_does_witness_exist (this, witness)) {
-                memset (sources, 0, sizeof (*sources) * priv->child_count);
-                afr_mark_active_sinks (this, sources, locked_on, healed_sinks);
-		return -1;
-	}
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (sources[i]) {
-			source = i;
-			break;
-		}
-	}
-
-	return source;
+    int i = 0;
+    afr_private_t *priv = NULL;
+    int source = -1;
+    int sources_count = 0;
+
+    priv = this->private;
+
+    sources_count = AFR_COUNT(sources, priv->child_count);
+
+    if ((AFR_CMP(locked_on, healed_sinks, priv->child_count) == 0) ||
+        !sources_count || afr_does_witness_exist(this, witness)) {
+        memset(sources, 0, sizeof(*sources) * priv->child_count);
+        afr_mark_active_sinks(this, sources, locked_on, healed_sinks);
+        return -1;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (sources[i]) {
+            source = i;
+            break;
+        }
+    }
+
+    return source;
 }
 
 int
-__afr_selfheal_name_prepare (call_frame_t *frame, xlator_t *this, inode_t *parent,
-			     uuid_t pargfid, unsigned char *locked_on,
-			     unsigned char *sources, unsigned char *sinks,
-			     unsigned char *healed_sinks, int *source_p)
+__afr_selfheal_name_prepare(call_frame_t *frame, xlator_t *this,
+                            inode_t *parent, uuid_t pargfid,
+                            unsigned char *locked_on, unsigned char *sources,
+                            unsigned char *sinks, unsigned char *healed_sinks,
+                            int *source_p)
 {
-	int ret = -1;
-	int source = -1;
-	afr_private_t *priv = NULL;
-        struct afr_reply *replies = NULL;
-        uint64_t *witness = NULL;
-
-	priv = this->private;
-
-        replies = alloca0 (priv->child_count * sizeof(*replies));
-
-	ret = afr_selfheal_unlocked_discover (frame, parent, pargfid, replies);
-	if (ret)
-		goto out;
-
-        witness = alloca0 (sizeof (*witness) * priv->child_count);
-	ret = afr_selfheal_find_direction (frame, this, replies,
-					   AFR_ENTRY_TRANSACTION,
-					   locked_on, sources, sinks, witness,
-                                           NULL);
-	if (ret)
-		goto out;
-
-        /* Initialize the healed_sinks[] array optimistically to
-           the intersection of to-be-healed (i.e sinks[]) and
-           the list of servers which are up (i.e locked_on[]).
-
-           As we encounter failures in the healing process, we
-           will unmark the respective servers in the healed_sinks[]
-           array.
-        */
-        AFR_INTERSECT (healed_sinks, sinks, locked_on, priv->child_count);
-
-	source = __afr_selfheal_name_finalize_source (this, sources,
-                                                      healed_sinks,
-						      locked_on, witness);
-	if (source < 0) {
-		/* If source is < 0 (typically split-brain), we perform a
-		   conservative merge of entries rather than erroring out */
-	}
-	*source_p = source;
+    int ret = -1;
+    int source = -1;
+    afr_private_t *priv = NULL;
+    struct afr_reply *replies = NULL;
+    uint64_t *witness = NULL;
+
+    priv = this->private;
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+
+    ret = afr_selfheal_unlocked_discover(frame, parent, pargfid, replies);
+    if (ret)
+        goto out;
+
+    witness = alloca0(sizeof(*witness) * priv->child_count);
+    ret = afr_selfheal_find_direction(frame, this, replies,
+                                      AFR_ENTRY_TRANSACTION, locked_on, sources,
+                                      sinks, witness, NULL);
+    if (ret)
+        goto out;
+
+    /* Initialize the healed_sinks[] array optimistically to
+       the intersection of to-be-healed (i.e sinks[]) and
+       the list of servers which are up (i.e locked_on[]).
+
+       As we encounter failures in the healing process, we
+       will unmark the respective servers in the healed_sinks[]
+       array.
+    */
+    AFR_INTERSECT(healed_sinks, sinks, locked_on, priv->child_count);
+
+    source = __afr_selfheal_name_finalize_source(this, sources, healed_sinks,
+                                                 locked_on, witness);
+    if (source < 0) {
+        /* If source is < 0 (typically split-brain), we perform a
+           conservative merge of entries rather than erroring out */
+    }
+    *source_p = source;
 
 out:
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_selfheal_name_do (call_frame_t *frame, xlator_t *this, inode_t *parent,
-		      uuid_t pargfid, const char *bname, void *gfid_req,
-                      dict_t *xdata)
+afr_selfheal_name_do(call_frame_t *frame, xlator_t *this, inode_t *parent,
+                     uuid_t pargfid, const char *bname, void *gfid_req,
+                     dict_t *xdata)
 {
-	afr_private_t *priv = NULL;
-	unsigned char *sources = NULL;
-	unsigned char *sinks = NULL;
-	unsigned char *healed_sinks = NULL;
-	unsigned char *locked_on = NULL;
-	int source = -1;
-        struct afr_reply *replies = NULL;
-	int ret = -1;
-	inode_t *inode = NULL;
-        dict_t *xattr = NULL;
-
-        xattr = dict_new ();
-        if (!xattr)
-                return -ENOMEM;
-
-        ret = dict_set_int32 (xattr, GF_GFIDLESS_LOOKUP, 1);
-        if (ret) {
-                dict_unref (xattr);
-                return -1;
+    afr_private_t *priv = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *sinks = NULL;
+    unsigned char *healed_sinks = NULL;
+    unsigned char *locked_on = NULL;
+    int source = -1;
+    struct afr_reply *replies = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+    dict_t *xattr = NULL;
+
+    xattr = dict_new();
+    if (!xattr)
+        return -ENOMEM;
+
+    ret = dict_set_int32(xattr, GF_GFIDLESS_LOOKUP, 1);
+    if (ret) {
+        dict_unref(xattr);
+        return -1;
+    }
+
+    priv = this->private;
+
+    locked_on = alloca0(priv->child_count);
+    sources = alloca0(priv->child_count);
+    sinks = alloca0(priv->child_count);
+    healed_sinks = alloca0(priv->child_count);
+
+    replies = alloca0(priv->child_count * sizeof(*replies));
+
+    ret = afr_selfheal_entrylk(frame, this, parent, this->name, bname,
+                               locked_on);
+    {
+        if (ret < AFR_SH_MIN_PARTICIPANTS) {
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __afr_selfheal_name_prepare(frame, this, parent, pargfid,
+                                          locked_on, sources, sinks,
+                                          healed_sinks, &source);
+        if (ret)
+            goto unlock;
+
+        inode = afr_selfheal_unlocked_lookup_on(frame, parent, bname, replies,
+                                                locked_on, xattr);
+        if (!inode) {
+            ret = -ENOMEM;
+            goto unlock;
         }
 
-	priv = this->private;
-
-	locked_on = alloca0 (priv->child_count);
-	sources = alloca0 (priv->child_count);
-	sinks = alloca0 (priv->child_count);
-	healed_sinks = alloca0 (priv->child_count);
-
-	replies = alloca0 (priv->child_count * sizeof(*replies));
-
-	ret = afr_selfheal_entrylk (frame, this, parent, this->name, bname,
-				    locked_on);
-	{
-		if (ret < AFR_SH_MIN_PARTICIPANTS) {
-			ret = -ENOTCONN;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_name_prepare (frame, this, parent, pargfid,
-						   locked_on, sources, sinks,
-						   healed_sinks, &source);
-		if (ret)
-			goto unlock;
-
-                inode = afr_selfheal_unlocked_lookup_on (frame, parent, bname,
-						         replies, locked_on,
-                                                         xattr);
-		if (!inode) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-
-		ret = __afr_selfheal_name_do (frame, this, parent, pargfid,
-                                              bname, inode, sources, sinks,
-                                              healed_sinks, source, locked_on,
-                                              replies, gfid_req, xdata);
-	}
+        ret = __afr_selfheal_name_do(frame, this, parent, pargfid, bname, inode,
+                                     sources, sinks, healed_sinks, source,
+                                     locked_on, replies, gfid_req, xdata);
+    }
 unlock:
-	afr_selfheal_unentrylk (frame, this, parent, this->name, bname,
-				locked_on, NULL);
-	if (inode)
-		inode_unref (inode);
+    afr_selfheal_unentrylk(frame, this, parent, this->name, bname, locked_on,
+                           NULL);
+    if (inode)
+        inode_unref(inode);
 
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-        if (xattr)
-                dict_unref (xattr);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    if (xattr)
+        dict_unref(xattr);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_selfheal_name_unlocked_inspect (call_frame_t *frame, xlator_t *this,
-				    inode_t *parent, uuid_t pargfid,
-				    const char *bname, gf_boolean_t *need_heal)
+afr_selfheal_name_unlocked_inspect(call_frame_t *frame, xlator_t *this,
+                                   inode_t *parent, uuid_t pargfid,
+                                   const char *bname, gf_boolean_t *need_heal)
 {
-	afr_private_t *priv = NULL;
-	int i = 0;
-	struct afr_reply *replies = NULL;
-	inode_t *inode = NULL;
-	int first_idx = -1;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    struct afr_reply *replies = NULL;
+    inode_t *inode = NULL;
+    int first_idx = -1;
 
-	priv = this->private;
+    priv = this->private;
 
-	replies = alloca0 (sizeof (*replies) * priv->child_count);
+    replies = alloca0(sizeof(*replies) * priv->child_count);
 
-	inode = afr_selfheal_unlocked_lookup_on (frame, parent, bname,
-						 replies, priv->child_up, NULL);
-	if (!inode)
-		return -ENOMEM;
+    inode = afr_selfheal_unlocked_lookup_on(frame, parent, bname, replies,
+                                            priv->child_up, NULL);
+    if (!inode)
+        return -ENOMEM;
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (!replies[i].valid)
-			continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if ((replies[i].op_ret == -1) &&
-                    (replies[i].op_errno == ENODATA)) {
-                        *need_heal = _gf_true;
-                        break;
-                }
+        if ((replies[i].op_ret == -1) && (replies[i].op_errno == ENODATA)) {
+            *need_heal = _gf_true;
+            break;
+        }
 
-		if (first_idx == -1) {
-			first_idx = i;
-			continue;
-		}
+        if (first_idx == -1) {
+            first_idx = i;
+            continue;
+        }
 
-		if (replies[i].op_ret != replies[first_idx].op_ret) {
-			*need_heal = _gf_true;
-                        break;
-                }
+        if (replies[i].op_ret != replies[first_idx].op_ret) {
+            *need_heal = _gf_true;
+            break;
+        }
 
-		if (gf_uuid_compare (replies[i].poststat.ia_gfid,
-				  replies[first_idx].poststat.ia_gfid)) {
-			*need_heal = _gf_true;
-                        break;
-                }
-	}
+        if (gf_uuid_compare(replies[i].poststat.ia_gfid,
+                            replies[first_idx].poststat.ia_gfid)) {
+            *need_heal = _gf_true;
+            break;
+        }
+    }
 
-	if (inode)
-		inode_unref (inode);
-        if (replies)
-                afr_replies_wipe (replies, priv->child_count);
-	return 0;
+    if (inode)
+        inode_unref(inode);
+    if (replies)
+        afr_replies_wipe(replies, priv->child_count);
+    return 0;
 }
 
 int
-afr_selfheal_name (xlator_t *this, uuid_t pargfid, const char *bname,
-                   void *gfid_req, dict_t *xdata)
+afr_selfheal_name(xlator_t *this, uuid_t pargfid, const char *bname,
+                  void *gfid_req, dict_t *xdata)
 {
-	inode_t *parent = NULL;
-	call_frame_t *frame = NULL;
-	int ret = -1;
-	gf_boolean_t need_heal = _gf_false;
-
-	parent = afr_inode_find (this, pargfid);
-	if (!parent)
-		goto out;
-
-	frame = afr_frame_create (this, NULL);
-	if (!frame)
-		goto out;
-
-	ret = afr_selfheal_name_unlocked_inspect (frame, this, parent, pargfid,
-						  bname, &need_heal);
-	if (ret)
-		goto out;
-
-	if (need_heal) {
-		ret = afr_selfheal_name_do (frame, this, parent, pargfid, bname,
-                                            gfid_req, xdata);
-                if (ret)
-                        goto out;
-        }
+    inode_t *parent = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -1;
+    gf_boolean_t need_heal = _gf_false;
+
+    parent = afr_inode_find(this, pargfid);
+    if (!parent)
+        goto out;
+
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        goto out;
+
+    ret = afr_selfheal_name_unlocked_inspect(frame, this, parent, pargfid,
+                                             bname, &need_heal);
+    if (ret)
+        goto out;
+
+    if (need_heal) {
+        ret = afr_selfheal_name_do(frame, this, parent, pargfid, bname,
+                                   gfid_req, xdata);
+        if (ret)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-	if (parent)
-		inode_unref (parent);
-	if (frame)
-		AFR_STACK_DESTROY (frame);
+    if (parent)
+        inode_unref(parent);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
 
-	return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr-self-heald.c b/xlators/cluster/afr/src/afr-self-heald.c
index 1f7ae7bb43d..0cf01a041b4 100644
--- a/xlators/cluster/afr/src/afr-self-heald.c
+++ b/xlators/cluster/afr/src/afr-self-heald.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "afr.h"
 #include "afr-self-heal.h"
 #include "afr-self-heald.h"
@@ -17,1378 +16,1334 @@
 #include "afr-messages.h"
 #include "byte-order.h"
 
-#define SHD_INODE_LRU_LIMIT          2048
-#define AFR_EH_SPLIT_BRAIN_LIMIT     1024
-#define AFR_STATISTICS_HISTORY_SIZE    50
-
-
-#define ASSERT_LOCAL(this, healer)				\
-	if (!afr_shd_is_subvol_local(this, healer->subvol)) {	\
-		healer->local = _gf_false;			\
-		if (safe_break (healer)) {			\
-			break;					\
-		} else {					\
-			continue;				\
-		}						\
-	} else {						\
-		healer->local = _gf_true;			\
-	}
-
-
-#define NTH_INDEX_HEALER(this, n) &((((afr_private_t *)this->private))->shd.index_healers[n])
-#define NTH_FULL_HEALER(this, n) &((((afr_private_t *)this->private))->shd.full_healers[n])
+#define SHD_INODE_LRU_LIMIT 2048
+#define AFR_EH_SPLIT_BRAIN_LIMIT 1024
+#define AFR_STATISTICS_HISTORY_SIZE 50
+
+#define ASSERT_LOCAL(this, healer)                                             \
+    if (!afr_shd_is_subvol_local(this, healer->subvol)) {                      \
+        healer->local = _gf_false;                                             \
+        if (safe_break(healer)) {                                              \
+            break;                                                             \
+        } else {                                                               \
+            continue;                                                          \
+        }                                                                      \
+    } else {                                                                   \
+        healer->local = _gf_true;                                              \
+    }
+
+#define NTH_INDEX_HEALER(this, n)                                              \
+    &((((afr_private_t *)this->private))->shd.index_healers[n])
+#define NTH_FULL_HEALER(this, n)                                               \
+    &((((afr_private_t *)this->private))->shd.full_healers[n])
 
 char *
-afr_subvol_name (xlator_t *this, int subvol)
+afr_subvol_name(xlator_t *this, int subvol)
 {
-	afr_private_t *priv = NULL;
+    afr_private_t *priv = NULL;
 
-	priv = this->private;
-	if (subvol < 0 || subvol > priv->child_count)
-		return NULL;
+    priv = this->private;
+    if (subvol < 0 || subvol > priv->child_count)
+        return NULL;
 
-	return priv->children[subvol]->name;
+    return priv->children[subvol]->name;
 }
 
-
 void
-afr_destroy_crawl_event_data (void *data)
+afr_destroy_crawl_event_data(void *data)
 {
-        return;
+    return;
 }
 
-
 void
-afr_destroy_shd_event_data (void *data)
+afr_destroy_shd_event_data(void *data)
 {
-	shd_event_t *shd_event = data;
-
-	if (!shd_event)
-		return;
-	GF_FREE (shd_event->path);
+    shd_event_t *shd_event = data;
 
+    if (!shd_event)
         return;
-}
+    GF_FREE(shd_event->path);
 
+    return;
+}
 
 gf_boolean_t
-afr_shd_is_subvol_local (xlator_t *this, int subvol)
+afr_shd_is_subvol_local(xlator_t *this, int subvol)
 {
-	afr_private_t *priv    = NULL;
-	gf_boolean_t  is_local = _gf_false;
-        loc_t         loc      = {0, };
-
-        loc.inode = this->itable->root;
-        gf_uuid_copy (loc.gfid, loc.inode->gfid);
-	priv = this->private;
-        syncop_is_subvol_local(priv->children[subvol], &loc, &is_local);
-        return is_local;
+    afr_private_t *priv = NULL;
+    gf_boolean_t is_local = _gf_false;
+    loc_t loc = {
+        0,
+    };
+
+    loc.inode = this->itable->root;
+    gf_uuid_copy(loc.gfid, loc.inode->gfid);
+    priv = this->private;
+    syncop_is_subvol_local(priv->children[subvol], &loc, &is_local);
+    return is_local;
 }
 
-
 int
-__afr_shd_healer_wait (struct subvol_healer *healer)
+__afr_shd_healer_wait(struct subvol_healer *healer)
 {
-	afr_private_t *priv = NULL;
-	struct timespec wait_till = {0, };
-	int ret = 0;
+    afr_private_t *priv = NULL;
+    struct timespec wait_till = {
+        0,
+    };
+    int ret = 0;
 
-	priv = healer->this->private;
+    priv = healer->this->private;
 
 disabled_loop:
-	wait_till.tv_sec = time (NULL) + priv->shd.timeout;
+    wait_till.tv_sec = time(NULL) + priv->shd.timeout;
 
-	while (!healer->rerun) {
-		ret = pthread_cond_timedwait (&healer->cond,
-					      &healer->mutex,
-					      &wait_till);
-		if (ret == ETIMEDOUT)
-			break;
-	}
+    while (!healer->rerun) {
+        ret = pthread_cond_timedwait(&healer->cond, &healer->mutex, &wait_till);
+        if (ret == ETIMEDOUT)
+            break;
+    }
 
-	ret = healer->rerun;
-	healer->rerun = 0;
+    ret = healer->rerun;
+    healer->rerun = 0;
 
-	if (!priv->shd.enabled)
-		goto disabled_loop;
+    if (!priv->shd.enabled)
+        goto disabled_loop;
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_shd_healer_wait (struct subvol_healer *healer)
+afr_shd_healer_wait(struct subvol_healer *healer)
 {
-	int ret = 0;
+    int ret = 0;
 
-	pthread_mutex_lock (&healer->mutex);
-	{
-		ret = __afr_shd_healer_wait (healer);
-	}
-	pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_lock(&healer->mutex);
+    {
+        ret = __afr_shd_healer_wait(healer);
+    }
+    pthread_mutex_unlock(&healer->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-safe_break (struct subvol_healer *healer)
+safe_break(struct subvol_healer *healer)
 {
-	gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-	pthread_mutex_lock (&healer->mutex);
-	{
-		if (healer->rerun)
-			goto unlock;
+    pthread_mutex_lock(&healer->mutex);
+    {
+        if (healer->rerun)
+            goto unlock;
 
-		healer->running = _gf_false;
-		ret = _gf_true;
-	}
+        healer->running = _gf_false;
+        ret = _gf_true;
+    }
 unlock:
-	pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_unlock(&healer->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 inode_t *
-afr_shd_inode_find (xlator_t *this, xlator_t *subvol, uuid_t gfid)
+afr_shd_inode_find(xlator_t *this, xlator_t *subvol, uuid_t gfid)
 {
-        int          ret       = 0;
-        uint64_t     val       = IA_INVAL;
-        dict_t       *xdata    = NULL;
-        dict_t       *rsp_dict = NULL;
-        inode_t      *inode    = NULL;
-
-        xdata = dict_new ();
-        if (!xdata)
-                goto out;
-
-        ret = dict_set_int8 (xdata, GF_INDEX_IA_TYPE_GET_REQ, 1);
+    int ret = 0;
+    uint64_t val = IA_INVAL;
+    dict_t *xdata = NULL;
+    dict_t *rsp_dict = NULL;
+    inode_t *inode = NULL;
+
+    xdata = dict_new();
+    if (!xdata)
+        goto out;
+
+    ret = dict_set_int8(xdata, GF_INDEX_IA_TYPE_GET_REQ, 1);
+    if (ret)
+        goto out;
+
+    ret = syncop_inode_find(this, subvol, gfid, &inode, xdata, &rsp_dict);
+    if (ret < 0)
+        goto out;
+
+    if (rsp_dict) {
+        ret = dict_get_uint64(rsp_dict, GF_INDEX_IA_TYPE_GET_RSP, &val);
         if (ret)
-                goto out;
-
-	ret = syncop_inode_find (this, subvol, gfid, &inode,
-                                 xdata, &rsp_dict);
-	if (ret < 0)
-		goto out;
-
-        if (rsp_dict) {
-                ret = dict_get_uint64 (rsp_dict, GF_INDEX_IA_TYPE_GET_RSP,
-                                       &val);
-                if (ret)
-                        goto out;
-        }
-        ret = inode_ctx_set2 (inode, subvol, 0, &val);
+            goto out;
+    }
+    ret = inode_ctx_set2(inode, subvol, 0, &val);
 out:
-        if (ret && inode) {
-                inode_unref (inode);
-                inode = NULL;
-        }
-        if (xdata)
-                dict_unref (xdata);
-        if (rsp_dict)
-                dict_unref (rsp_dict);
-	return inode;
+    if (ret && inode) {
+        inode_unref(inode);
+        inode = NULL;
+    }
+    if (xdata)
+        dict_unref(xdata);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
+    return inode;
 }
 
-inode_t*
-afr_shd_index_inode (xlator_t *this, xlator_t *subvol, char *vgfid)
+inode_t *
+afr_shd_index_inode(xlator_t *this, xlator_t *subvol, char *vgfid)
 {
-	loc_t rootloc = {0, };
-	inode_t *inode = NULL;
-	int ret = 0;
-	dict_t *xattr = NULL;
-	void *index_gfid = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    inode_t *inode = NULL;
+    int ret = 0;
+    dict_t *xattr = NULL;
+    void *index_gfid = NULL;
 
-	rootloc.inode = inode_ref (this->itable->root);
-	gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
 
-	ret = syncop_getxattr (subvol, &rootloc, &xattr,
-			       vgfid, NULL, NULL);
-	if (ret || !xattr) {
-		errno = -ret;
-		goto out;
-	}
+    ret = syncop_getxattr(subvol, &rootloc, &xattr, vgfid, NULL, NULL);
+    if (ret || !xattr) {
+        errno = -ret;
+        goto out;
+    }
 
-	ret = dict_get_ptr (xattr, vgfid, &index_gfid);
-	if (ret)
-		goto out;
+    ret = dict_get_ptr(xattr, vgfid, &index_gfid);
+    if (ret)
+        goto out;
 
-        gf_msg_debug (this->name, 0, "%s dir gfid for %s: %s",
-	              vgfid, subvol->name, uuid_utoa (index_gfid));
+    gf_msg_debug(this->name, 0, "%s dir gfid for %s: %s", vgfid, subvol->name,
+                 uuid_utoa(index_gfid));
 
-	inode = afr_shd_inode_find (this, subvol, index_gfid);
+    inode = afr_shd_inode_find(this, subvol, index_gfid);
 
 out:
-	loc_wipe (&rootloc);
+    loc_wipe(&rootloc);
 
-	if (xattr)
-		dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-	return inode;
+    return inode;
 }
 
 int
-afr_shd_index_purge (xlator_t *subvol, inode_t *inode, char *name,
-                     ia_type_t type)
+afr_shd_index_purge(xlator_t *subvol, inode_t *inode, char *name,
+                    ia_type_t type)
 {
-	int    ret = 0;
-	loc_t  loc = {0,};
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
 
-	loc.parent = inode_ref (inode);
-	loc.name = name;
+    loc.parent = inode_ref(inode);
+    loc.name = name;
 
-        if (IA_ISDIR (type))
-                ret = syncop_rmdir (subvol, &loc, 1, NULL, NULL);
-        else
-                ret = syncop_unlink (subvol, &loc, NULL, NULL);
+    if (IA_ISDIR(type))
+        ret = syncop_rmdir(subvol, &loc, 1, NULL, NULL);
+    else
+        ret = syncop_unlink(subvol, &loc, NULL, NULL);
 
-	loc_wipe (&loc);
-	return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 void
-afr_shd_zero_xattrop (xlator_t *this, uuid_t gfid)
+afr_shd_zero_xattrop(xlator_t *this, uuid_t gfid)
 {
-
-        call_frame_t *frame = NULL;
-        inode_t *inode = NULL;
-        afr_private_t *priv = NULL;
-        dict_t  *xattr = NULL;
-        int ret = 0;
-        int i = 0;
-        int raw[AFR_NUM_CHANGE_LOGS] = {0};
-
-        priv = this->private;
-        frame = afr_frame_create (this, NULL);
-        if (!frame)
-                goto out;
-        inode = afr_inode_find (this, gfid);
-        if (!inode)
-                goto out;
-        xattr = dict_new();
-        if (!xattr)
-                goto out;
-        ret = dict_set_static_bin (xattr, AFR_DIRTY, raw,
-                                   sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    call_frame_t *frame = NULL;
+    inode_t *inode = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int ret = 0;
+    int i = 0;
+    int raw[AFR_NUM_CHANGE_LOGS] = {0};
+
+    priv = this->private;
+    frame = afr_frame_create(this, NULL);
+    if (!frame)
+        goto out;
+    inode = afr_inode_find(this, gfid);
+    if (!inode)
+        goto out;
+    xattr = dict_new();
+    if (!xattr)
+        goto out;
+    ret = dict_set_static_bin(xattr, AFR_DIRTY, raw,
+                              sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret)
+        goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], raw,
+                                  sizeof(int) * AFR_NUM_CHANGE_LOGS);
         if (ret)
-                goto out;
-        for (i = 0; i < priv->child_count; i++) {
-                ret = dict_set_static_bin (xattr, priv->pending_key[i], raw,
-                                           sizeof(int) * AFR_NUM_CHANGE_LOGS);
-                if (ret)
-                        goto out;
-        }
+            goto out;
+    }
 
-        /*Send xattrop to all bricks. Doing a lookup to see if bricks are up or
-        * has valid repies for this gfid seems a bit of an overkill.*/
-        for (i = 0; i < priv->child_count; i++)
-                afr_selfheal_post_op (frame, this, inode, i, xattr, NULL);
+    /*Send xattrop to all bricks. Doing a lookup to see if bricks are up or
+     * has valid repies for this gfid seems a bit of an overkill.*/
+    for (i = 0; i < priv->child_count; i++)
+        afr_selfheal_post_op(frame, this, inode, i, xattr, NULL);
 
 out:
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-        if (inode)
-                inode_unref (inode);
-        if (xattr)
-                dict_unref (xattr);
-        return;
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    if (inode)
+        inode_unref(inode);
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
 int
-afr_shd_selfheal_name (struct subvol_healer *healer, int child, uuid_t parent,
-		       const char *bname)
+afr_shd_selfheal_name(struct subvol_healer *healer, int child, uuid_t parent,
+                      const char *bname)
 {
-	int ret = -1;
+    int ret = -1;
 
-	ret = afr_selfheal_name (THIS, parent, bname, NULL, NULL);
+    ret = afr_selfheal_name(THIS, parent, bname, NULL, NULL);
 
-	return ret;
+    return ret;
 }
 
 int
-afr_shd_selfheal (struct subvol_healer *healer, int child, uuid_t gfid)
+afr_shd_selfheal(struct subvol_healer *healer, int child, uuid_t gfid)
 {
-	int ret = 0;
-	eh_t *eh = NULL;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	shd_event_t *shd_event = NULL;
-	char *path = NULL;
-	xlator_t *subvol = NULL;
-	xlator_t *this = NULL;
-	crawl_event_t *crawl_event = NULL;
-
-	this = healer->this;
-	priv = this->private;
-	shd = &priv->shd;
-	crawl_event = &healer->crawl_event;
-
-	subvol = priv->children[child];
-
-        //If this fails with ENOENT/ESTALE index is stale
-        ret = syncop_gfid_to_path (this->itable, subvol, gfid, &path);
-        if (ret < 0)
-                return ret;
-
-	ret = afr_selfheal (this, gfid);
-
-        LOCK (&priv->lock);
-        {
-                if (ret == -EIO) {
-                        eh = shd->split_brain;
-                        crawl_event->split_brain_count++;
-                } else if (ret < 0) {
-                        crawl_event->heal_failed_count++;
-                } else if (ret == 0) {
-                        crawl_event->healed_count++;
-                }
+    int ret = 0;
+    eh_t *eh = NULL;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    shd_event_t *shd_event = NULL;
+    char *path = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    crawl_event_t *crawl_event = NULL;
+
+    this = healer->this;
+    priv = this->private;
+    shd = &priv->shd;
+    crawl_event = &healer->crawl_event;
+
+    subvol = priv->children[child];
+
+    // If this fails with ENOENT/ESTALE index is stale
+    ret = syncop_gfid_to_path(this->itable, subvol, gfid, &path);
+    if (ret < 0)
+        return ret;
+
+    ret = afr_selfheal(this, gfid);
+
+    LOCK(&priv->lock);
+    {
+        if (ret == -EIO) {
+            eh = shd->split_brain;
+            crawl_event->split_brain_count++;
+        } else if (ret < 0) {
+            crawl_event->heal_failed_count++;
+        } else if (ret == 0) {
+            crawl_event->healed_count++;
         }
-        UNLOCK (&priv->lock);
+    }
+    UNLOCK(&priv->lock);
 
-	if (eh) {
-		shd_event = GF_CALLOC (1, sizeof(*shd_event),
-				       gf_afr_mt_shd_event_t);
-		if (!shd_event)
-                        goto out;
+    if (eh) {
+        shd_event = GF_CALLOC(1, sizeof(*shd_event), gf_afr_mt_shd_event_t);
+        if (!shd_event)
+            goto out;
 
-		shd_event->child = child;
-		shd_event->path = path;
+        shd_event->child = child;
+        shd_event->path = path;
 
-		if (eh_save_history (eh, shd_event) < 0)
-                        goto out;
+        if (eh_save_history(eh, shd_event) < 0)
+            goto out;
 
-                shd_event = NULL;
-                path = NULL;
-	}
+        shd_event = NULL;
+        path = NULL;
+    }
 out:
-        GF_FREE (shd_event);
-        GF_FREE (path);
-	return ret;
+    GF_FREE(shd_event);
+    GF_FREE(path);
+    return ret;
 }
 
-
 void
-afr_shd_sweep_prepare (struct subvol_healer *healer)
+afr_shd_sweep_prepare(struct subvol_healer *healer)
 {
-	crawl_event_t *event = NULL;
+    crawl_event_t *event = NULL;
 
-	event = &healer->crawl_event;
+    event = &healer->crawl_event;
 
-	event->healed_count = 0;
-	event->split_brain_count = 0;
-	event->heal_failed_count = 0;
+    event->healed_count = 0;
+    event->split_brain_count = 0;
+    event->heal_failed_count = 0;
 
-	time (&event->start_time);
-	event->end_time = 0;
+    time(&event->start_time);
+    event->end_time = 0;
 }
 
-
 void
-afr_shd_sweep_done (struct subvol_healer *healer)
+afr_shd_sweep_done(struct subvol_healer *healer)
 {
-	crawl_event_t *event = NULL;
-	crawl_event_t *history = NULL;
-	afr_self_heald_t *shd = NULL;
+    crawl_event_t *event = NULL;
+    crawl_event_t *history = NULL;
+    afr_self_heald_t *shd = NULL;
 
-	event = &healer->crawl_event;
-	shd = &(((afr_private_t *)healer->this->private)->shd);
+    event = &healer->crawl_event;
+    shd = &(((afr_private_t *)healer->this->private)->shd);
 
-	time (&event->end_time);
-	history = memdup (event, sizeof (*event));
-	event->start_time = 0;
+    time(&event->end_time);
+    history = memdup(event, sizeof(*event));
+    event->start_time = 0;
 
-	if (!history)
-		return;
+    if (!history)
+        return;
 
-	if (eh_save_history (shd->statistics[healer->subvol], history) < 0)
-		GF_FREE (history);
+    if (eh_save_history(shd->statistics[healer->subvol], history) < 0)
+        GF_FREE(history);
 }
 
 int
-afr_shd_index_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                    void *data)
+afr_shd_index_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                   void *data)
 {
-        struct subvol_healer *healer = data;
-        afr_private_t        *priv   = NULL;
-        uuid_t               gfid    = {0};
-        int                  ret     = 0;
-        uint64_t             val     = IA_INVAL;
+    struct subvol_healer *healer = data;
+    afr_private_t *priv = NULL;
+    uuid_t gfid = {0};
+    int ret = 0;
+    uint64_t val = IA_INVAL;
 
-        priv = healer->this->private;
-        if (!priv->shd.enabled)
-                return -EBUSY;
+    priv = healer->this->private;
+    if (!priv->shd.enabled)
+        return -EBUSY;
 
-        gf_msg_debug (healer->this->name, 0, "got entry: %s from %s",
-                      entry->d_name, priv->children[healer->subvol]->name);
+    gf_msg_debug(healer->this->name, 0, "got entry: %s from %s", entry->d_name,
+                 priv->children[healer->subvol]->name);
 
-        ret = gf_uuid_parse (entry->d_name, gfid);
-        if (ret)
-                return 0;
+    ret = gf_uuid_parse(entry->d_name, gfid);
+    if (ret)
+        return 0;
 
-        inode_ctx_get2 (parent->inode, subvol, NULL, &val);
+    inode_ctx_get2(parent->inode, subvol, NULL, &val);
 
-        ret = afr_shd_selfheal (healer, healer->subvol, gfid);
+    ret = afr_shd_selfheal(healer, healer->subvol, gfid);
 
-        if (ret == -ENOENT || ret == -ESTALE)
-                afr_shd_index_purge (subvol, parent->inode, entry->d_name, val);
+    if (ret == -ENOENT || ret == -ESTALE)
+        afr_shd_index_purge(subvol, parent->inode, entry->d_name, val);
 
-        if (ret == 2)
-                /* If bricks crashed in pre-op after creating indices/xattrop
-                 * link but before setting afr changelogs, we end up with stale
-                 * xattrop links but zero changelogs. Remove such entries by
-                 * sending a post-op with zero changelogs.
-                 */
-                afr_shd_zero_xattrop (healer->this, gfid);
+    if (ret == 2)
+        /* If bricks crashed in pre-op after creating indices/xattrop
+         * link but before setting afr changelogs, we end up with stale
+         * xattrop links but zero changelogs. Remove such entries by
+         * sending a post-op with zero changelogs.
+         */
+        afr_shd_zero_xattrop(healer->this, gfid);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_shd_index_sweep (struct subvol_healer *healer, char *vgfid)
+afr_shd_index_sweep(struct subvol_healer *healer, char *vgfid)
 {
-	loc_t         loc     = {0};
-	afr_private_t *priv   = NULL;
-	int           ret     = 0;
-	xlator_t      *subvol = NULL;
-	dict_t        *xdata  = NULL;
-        call_frame_t  *frame  = NULL;
-
-	priv = healer->this->private;
-	subvol = priv->children[healer->subvol];
-
-        frame = afr_frame_create (healer->this, &ret);
-        if (!frame) {
-                ret = -ret;
-                goto out;
-        }
-
-	loc.inode = afr_shd_index_inode (healer->this, subvol, vgfid);
-	if (!loc.inode) {
-	        gf_msg (healer->this->name, GF_LOG_WARNING,
-                        0, AFR_MSG_INDEX_DIR_GET_FAILED,
-		        "unable to get index-dir on %s", subvol->name);
-		ret = -errno;
-	        goto out;
-	}
-
-        xdata = dict_new ();
-        if (!xdata || dict_set_int32 (xdata, "get-gfid-type", 1)) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = syncop_mt_dir_scan (frame, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
-                                  healer, afr_shd_index_heal, xdata,
-                                 priv->shd.max_threads, priv->shd.wait_qlength);
-
-        if (ret == 0)
-                ret = healer->crawl_event.healed_count;
+    loc_t loc = {0};
+    afr_private_t *priv = NULL;
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    dict_t *xdata = NULL;
+    call_frame_t *frame = NULL;
+
+    priv = healer->this->private;
+    subvol = priv->children[healer->subvol];
+
+    frame = afr_frame_create(healer->this, &ret);
+    if (!frame) {
+        ret = -ret;
+        goto out;
+    }
+
+    loc.inode = afr_shd_index_inode(healer->this, subvol, vgfid);
+    if (!loc.inode) {
+        gf_msg(healer->this->name, GF_LOG_WARNING, 0,
+               AFR_MSG_INDEX_DIR_GET_FAILED, "unable to get index-dir on %s",
+               subvol->name);
+        ret = -errno;
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata || dict_set_int32(xdata, "get-gfid-type", 1)) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_mt_dir_scan(frame, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
+                             healer, afr_shd_index_heal, xdata,
+                             priv->shd.max_threads, priv->shd.wait_qlength);
+
+    if (ret == 0)
+        ret = healer->crawl_event.healed_count;
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        if (xdata)
-                dict_unref (xdata);
-        if (frame)
-                AFR_STACK_DESTROY (frame);
-	return ret;
+    if (xdata)
+        dict_unref(xdata);
+    if (frame)
+        AFR_STACK_DESTROY(frame);
+    return ret;
 }
 
 int
-afr_shd_index_sweep_all (struct subvol_healer *healer)
+afr_shd_index_sweep_all(struct subvol_healer *healer)
 {
-        int            ret    = 0;
-        int            count  = 0;
-
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_INDEX_GFID);
-        if (ret < 0)
-                goto out;
-        count = ret;
-
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_DIRTY_GFID);
-        if (ret < 0)
-                goto out;
-        count += ret;
-
-        ret = afr_shd_index_sweep (healer, GF_XATTROP_ENTRY_CHANGES_GFID);
-        if (ret < 0)
-                goto out;
-        count += ret;
+    int ret = 0;
+    int count = 0;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_INDEX_GFID);
+    if (ret < 0)
+        goto out;
+    count = ret;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_DIRTY_GFID);
+    if (ret < 0)
+        goto out;
+    count += ret;
+
+    ret = afr_shd_index_sweep(healer, GF_XATTROP_ENTRY_CHANGES_GFID);
+    if (ret < 0)
+        goto out;
+    count += ret;
 out:
-        if (ret < 0)
-                return ret;
-        else
-                return count;
+    if (ret < 0)
+        return ret;
+    else
+        return count;
 }
 
 int
-afr_shd_full_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                   void *data)
+afr_shd_full_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                  void *data)
 {
-        struct subvol_healer *healer = data;
-        xlator_t             *this   = healer->this;
-        afr_private_t        *priv   = NULL;
+    struct subvol_healer *healer = data;
+    xlator_t *this = healer->this;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
-        if (!priv->shd.enabled)
-                return -EBUSY;
+    priv = this->private;
+    if (!priv->shd.enabled)
+        return -EBUSY;
 
-        afr_shd_selfheal_name (healer, healer->subvol,
-                               parent->inode->gfid, entry->d_name);
+    afr_shd_selfheal_name(healer, healer->subvol, parent->inode->gfid,
+                          entry->d_name);
 
-        afr_shd_selfheal (healer, healer->subvol, entry->d_stat.ia_gfid);
+    afr_shd_selfheal(healer, healer->subvol, entry->d_stat.ia_gfid);
 
-        return 0;
+    return 0;
 }
 
 int
-afr_shd_full_sweep (struct subvol_healer *healer, inode_t *inode)
+afr_shd_full_sweep(struct subvol_healer *healer, inode_t *inode)
 {
-        afr_private_t *priv = NULL;
-        loc_t          loc  = {0};
-
-        priv = healer->this->private;
-        loc.inode = inode;
-        return syncop_ftw (priv->children[healer->subvol], &loc,
-                           GF_CLIENT_PID_SELF_HEALD, healer,
-                           afr_shd_full_heal);
+    afr_private_t *priv = NULL;
+    loc_t loc = {0};
+
+    priv = healer->this->private;
+    loc.inode = inode;
+    return syncop_ftw(priv->children[healer->subvol], &loc,
+                      GF_CLIENT_PID_SELF_HEALD, healer, afr_shd_full_heal);
 }
 
 void
-afr_shd_ta_set_xattrs (xlator_t *this, loc_t *loc, dict_t **xdata,
-                       int healer)
+afr_shd_ta_set_xattrs(xlator_t *this, loc_t *loc, dict_t **xdata, int healer)
 {
-        afr_private_t   *priv                          = NULL;
-        dict_t          *xattr                         = NULL;
-        struct gf_flock  flock                         = {0, };
-        gf_boolean_t     need_xattrop                  = _gf_false;
-        void            *pending_raw                   = NULL;
-        int             *raw                           = NULL;
-        int              pending[AFR_NUM_CHANGE_LOGS]  = {0,};
-        int              i                             = 0;
-        int              j                             = 0;
-        int              val                           = 0;
-        int              ret                           = 0;
-
-        priv = this->private;
-
-        xattr = dict_new ();
-        if (!xattr) {
-                goto out;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    gf_boolean_t need_xattrop = _gf_false;
+    void *pending_raw = NULL;
+    int *raw = NULL;
+    int pending[AFR_NUM_CHANGE_LOGS] = {
+        0,
+    };
+    int i = 0;
+    int j = 0;
+    int val = 0;
+    int ret = 0;
+
+    priv = this->private;
+
+    xattr = dict_new();
+    if (!xattr) {
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        raw = GF_CALLOC(AFR_NUM_CHANGE_LOGS, sizeof(int), gf_afr_mt_int32_t);
+        if (!raw) {
+            goto out;
         }
 
-        for (i = 0; i < priv->child_count; i++) {
-                raw = GF_CALLOC (AFR_NUM_CHANGE_LOGS, sizeof(int),
-                                 gf_afr_mt_int32_t);
-                if (!raw) {
-                        goto out;
-                }
-
-                ret = dict_get_ptr (*xdata, priv->pending_key[i], &pending_raw);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                AFR_MSG_DICT_GET_FAILED, "Error getting value "
-                                "of pending key %s", priv->pending_key[i]);
-                        GF_FREE (raw);
-                        goto out;
-                }
-
-                memcpy (pending, pending_raw, sizeof (pending));
-                for (j = 0; j < AFR_NUM_CHANGE_LOGS; j++) {
-                        val = ntoh32 (pending[j]);
-                        if (val) {
-                                if (i == healer) {
-                                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                                AFR_MSG_THIN_ARB, "I am "
-                                                "not the good shd. Skipping. "
-                                                "SHD = %d.", healer);
-                                        GF_FREE (raw);
-                                        goto out;
-                                }
-                                need_xattrop = _gf_true;
-                                raw[j] = hton32 (-val);
-                        }
-                }
+        ret = dict_get_ptr(*xdata, priv->pending_key[i], &pending_raw);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+                   "Error getting value "
+                   "of pending key %s",
+                   priv->pending_key[i]);
+            GF_FREE(raw);
+            goto out;
+        }
 
-                ret = dict_set_bin (xattr, priv->pending_key[i], raw,
-                                    AFR_NUM_CHANGE_LOGS * sizeof (int));
-                if (ret) {
-                        GF_FREE (raw);
-                        goto out;
+        memcpy(pending, pending_raw, sizeof(pending));
+        for (j = 0; j < AFR_NUM_CHANGE_LOGS; j++) {
+            val = ntoh32(pending[j]);
+            if (val) {
+                if (i == healer) {
+                    gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_THIN_ARB,
+                           "I am "
+                           "not the good shd. Skipping. "
+                           "SHD = %d.",
+                           healer);
+                    GF_FREE(raw);
+                    goto out;
                 }
-
-                memset (pending, 0, sizeof (pending));
+                need_xattrop = _gf_true;
+                raw[j] = hton32(-val);
+            }
         }
 
-        if (!need_xattrop) {
-                goto out;
+        ret = dict_set_bin(xattr, priv->pending_key[i], raw,
+                           AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret) {
+            GF_FREE(raw);
+            goto out;
         }
 
-        flock.l_type = F_WRLCK;
-        flock.l_start = 0;
-        flock.l_len = 0;
+        memset(pending, 0, sizeof(pending));
+    }
 
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_NOTIFY, loc, F_SETLKW, &flock,
-                              NULL, NULL);
-        if (ret)
-                goto out;
+    if (!need_xattrop) {
+        goto out;
+    }
 
-        ret = syncop_xattrop (priv->children[THIN_ARBITER_BRICK_INDEX], loc,
-                              GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Xattrop failed.");
+    flock.l_type = F_WRLCK;
+    flock.l_start = 0;
+    flock.l_len = 0;
+
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_NOTIFY, loc, F_SETLKW, &flock, NULL, NULL);
+    if (ret)
+        goto out;
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Xattrop failed.");
 
-        flock.l_type = F_UNLCK;
-        syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                        AFR_TA_DOM_NOTIFY, loc, F_SETLKW, &flock, NULL, NULL);
+    flock.l_type = F_UNLCK;
+    syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX], AFR_TA_DOM_NOTIFY,
+                   loc, F_SETLKW, &flock, NULL, NULL);
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        return;
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
 void
-afr_shd_ta_get_xattrs (xlator_t *this, loc_t *loc, dict_t **xdata)
+afr_shd_ta_get_xattrs(xlator_t *this, loc_t *loc, dict_t **xdata)
 {
-	afr_private_t   *priv   = NULL;
-        dict_t          *xattr  = NULL;
-        struct iatt      stbuf  = {0,};
-        int             *raw    = NULL;
-	int              ret    = 0;
-        int              i      = 0;
-
-        priv = this->private;
-
-        loc->parent = inode_ref (this->itable->root);
-        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
-        loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
-        loc->inode = inode_new (loc->parent->table);
-        if (!loc->inode) {
-                goto out;
-        }
-
-        ret = syncop_lookup (priv->children[THIN_ARBITER_BRICK_INDEX], loc,
-                             &stbuf, 0, 0, 0);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed lookup on file %s.", loc->name);
-                goto out;
-        }
-
-        gf_uuid_copy (priv->ta_gfid, stbuf.ia_gfid);
-        gf_uuid_copy (loc->gfid, priv->ta_gfid);
-
-        xattr = dict_new ();
-        if (!xattr) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_GET_FAILED,
-                        "Failed to create dict.");
-                goto out;
-        }
-
-        for (i = 0; i < priv->child_count; i++) {
-                raw = GF_CALLOC (AFR_NUM_CHANGE_LOGS, sizeof(int),
-                                 gf_afr_mt_int32_t);
-                if (!raw) {
-                        goto out;
-                }
-
-                ret = dict_set_bin (xattr, priv->pending_key[i], raw,
-                                    AFR_NUM_CHANGE_LOGS * sizeof (int));
-                if (ret) {
-                        GF_FREE (raw);
-                        goto out;
-                }
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    int *raw = NULL;
+    int ret = 0;
+    int i = 0;
+
+    priv = this->private;
+
+    loc->parent = inode_ref(this->itable->root);
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
+    loc->inode = inode_new(loc->parent->table);
+    if (!loc->inode) {
+        goto out;
+    }
+
+    ret = syncop_lookup(priv->children[THIN_ARBITER_BRICK_INDEX], loc, &stbuf,
+                        0, 0, 0);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed lookup on file %s.", loc->name);
+        goto out;
+    }
+
+    gf_uuid_copy(priv->ta_gfid, stbuf.ia_gfid);
+    gf_uuid_copy(loc->gfid, priv->ta_gfid);
+
+    xattr = dict_new();
+    if (!xattr) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_GET_FAILED,
+               "Failed to create dict.");
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        raw = GF_CALLOC(AFR_NUM_CHANGE_LOGS, sizeof(int), gf_afr_mt_int32_t);
+        if (!raw) {
+            goto out;
         }
 
-        ret = syncop_xattrop (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              loc, GF_XATTROP_ADD_ARRAY, xattr, NULL, xdata,
-                              NULL);
+        ret = dict_set_bin(xattr, priv->pending_key[i], raw,
+                           AFR_NUM_CHANGE_LOGS * sizeof(int));
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Xattrop failed.");
-                goto out;
+            GF_FREE(raw);
+            goto out;
         }
-        if (!(*xdata))
-                gf_msg (this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_GET_FAILED,
-                        "Xdata response is empty.");
+    }
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Xattrop failed.");
+        goto out;
+    }
+    if (!(*xdata))
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_GET_FAILED,
+               "Xdata response is empty.");
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-        return;
+    if (xattr)
+        dict_unref(xattr);
+    return;
 }
 
 void *
-afr_shd_index_healer (void *data)
+afr_shd_index_healer(void *data)
 {
-	struct subvol_healer *healer = NULL;
-	xlator_t *this = NULL;
-	int ret = 0;
-	afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        loc_t loc = {0, };
-
-	healer = data;
-	THIS = this = healer->this;
-	priv = this->private;
-
-	for (;;) {
-		afr_shd_healer_wait (healer);
-
-		ASSERT_LOCAL(this, healer);
-		priv->local[healer->subvol] = healer->local;
-
-                if (priv->thin_arbiter_count) {
-                        loc_wipe (&loc);
-                        afr_shd_ta_get_xattrs (this, &loc, &xdata);
-                }
-
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    loc_t loc = {
+        0,
+    };
+
+    healer = data;
+    THIS = this = healer->this;
+    priv = this->private;
+
+    for (;;) {
+        afr_shd_healer_wait(healer);
+
+        ASSERT_LOCAL(this, healer);
+        priv->local[healer->subvol] = healer->local;
+
+        if (priv->thin_arbiter_count) {
+            loc_wipe(&loc);
+            afr_shd_ta_get_xattrs(this, &loc, &xdata);
+        }
 
-		do {
-		        gf_msg_debug (this->name, 0,
-		                      "starting index sweep on subvol %s",
-			              afr_subvol_name (this, healer->subvol));
-
-			afr_shd_sweep_prepare (healer);
-
-                        ret = afr_shd_index_sweep_all (healer);
-
-			afr_shd_sweep_done (healer);
-			/*
-			  As long as at least one gfid was
-			  healed, keep retrying. We may have
-			  just healed a directory and thereby
-			  created entries for other gfids which
-			  could not be healed thus far.
-			*/
-
-		        gf_msg_debug (this->name, 0,
-			              "finished index sweep on subvol %s",
-			              afr_subvol_name (this, healer->subvol));
-			/*
-			  Give a pause before retrying to avoid a busy loop
-			  in case the only entry in index is because of
-			  an ongoing I/O.
-			*/
-			sleep (1);
-		} while (ret > 0);
-
-                if (xdata && !healer->crawl_event.heal_failed_count) {
-                        afr_shd_ta_set_xattrs (this, &loc, &xdata,
-                                               healer->subvol);
-                        dict_unref (xdata);
-                        xdata = NULL;
-                }
-	}
+        do {
+            gf_msg_debug(this->name, 0, "starting index sweep on subvol %s",
+                         afr_subvol_name(this, healer->subvol));
+
+            afr_shd_sweep_prepare(healer);
+
+            ret = afr_shd_index_sweep_all(healer);
+
+            afr_shd_sweep_done(healer);
+            /*
+              As long as at least one gfid was
+              healed, keep retrying. We may have
+              just healed a directory and thereby
+              created entries for other gfids which
+              could not be healed thus far.
+            */
+
+            gf_msg_debug(this->name, 0, "finished index sweep on subvol %s",
+                         afr_subvol_name(this, healer->subvol));
+            /*
+              Give a pause before retrying to avoid a busy loop
+              in case the only entry in index is because of
+              an ongoing I/O.
+            */
+            sleep(1);
+        } while (ret > 0);
+
+        if (xdata && !healer->crawl_event.heal_failed_count) {
+            afr_shd_ta_set_xattrs(this, &loc, &xdata, healer->subvol);
+            dict_unref(xdata);
+            xdata = NULL;
+        }
+    }
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-	return NULL;
+    return NULL;
 }
 
-
 void *
-afr_shd_full_healer (void *data)
+afr_shd_full_healer(void *data)
 {
-	struct subvol_healer *healer = NULL;
-	xlator_t *this = NULL;
-	int run = 0;
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+    int run = 0;
 
-	healer = data;
-	THIS = this = healer->this;
+    healer = data;
+    THIS = this = healer->this;
 
-	for (;;) {
-		pthread_mutex_lock (&healer->mutex);
-		{
-			run = __afr_shd_healer_wait (healer);
-			if (!run)
-				healer->running = _gf_false;
-		}
-		pthread_mutex_unlock (&healer->mutex);
+    for (;;) {
+        pthread_mutex_lock(&healer->mutex);
+        {
+            run = __afr_shd_healer_wait(healer);
+            if (!run)
+                healer->running = _gf_false;
+        }
+        pthread_mutex_unlock(&healer->mutex);
 
-		if (!run)
-			break;
+        if (!run)
+            break;
 
-		ASSERT_LOCAL(this, healer);
+        ASSERT_LOCAL(this, healer);
 
-	        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
-		        "starting full sweep on subvol %s",
-		        afr_subvol_name (this, healer->subvol));
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+               "starting full sweep on subvol %s",
+               afr_subvol_name(this, healer->subvol));
 
-		afr_shd_sweep_prepare (healer);
+        afr_shd_sweep_prepare(healer);
 
-		afr_shd_full_sweep (healer, this->itable->root);
+        afr_shd_full_sweep(healer, this->itable->root);
 
-		afr_shd_sweep_done (healer);
+        afr_shd_sweep_done(healer);
 
-	        gf_msg (this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
-		        "finished full sweep on subvol %s",
-		        afr_subvol_name (this, healer->subvol));
-	}
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_SELF_HEAL_INFO,
+               "finished full sweep on subvol %s",
+               afr_subvol_name(this, healer->subvol));
+    }
 
-	return NULL;
+    return NULL;
 }
 
-
 int
-afr_shd_healer_init (xlator_t *this, struct subvol_healer *healer)
+afr_shd_healer_init(xlator_t *this, struct subvol_healer *healer)
 {
-	int ret = 0;
+    int ret = 0;
 
-	ret = pthread_mutex_init (&healer->mutex, NULL);
-	if (ret)
-		goto out;
+    ret = pthread_mutex_init(&healer->mutex, NULL);
+    if (ret)
+        goto out;
 
-	ret = pthread_cond_init (&healer->cond, NULL);
-	if (ret)
-		goto out;
+    ret = pthread_cond_init(&healer->cond, NULL);
+    if (ret)
+        goto out;
 
-	healer->this = this;
-	healer->running = _gf_false;
-	healer->rerun = _gf_false;
-	healer->local = _gf_false;
+    healer->this = this;
+    healer->running = _gf_false;
+    healer->rerun = _gf_false;
+    healer->local = _gf_false;
 out:
-	return ret;
+    return ret;
 }
 
-
 int
-afr_shd_healer_spawn (xlator_t *this, struct subvol_healer *healer,
-		      void *(threadfn)(void *))
+afr_shd_healer_spawn(xlator_t *this, struct subvol_healer *healer,
+                     void *(threadfn)(void *))
 {
-	int ret = 0;
-
-	pthread_mutex_lock (&healer->mutex);
-	{
-		if (healer->running) {
-			pthread_cond_signal (&healer->cond);
-		} else {
-			ret = gf_thread_create (&healer->thread, NULL,
-						threadfn, healer, "shdheal");
-			if (ret)
-				goto unlock;
-			healer->running = 1;
-		}
-
-		healer->rerun = 1;
-	}
+    int ret = 0;
+
+    pthread_mutex_lock(&healer->mutex);
+    {
+        if (healer->running) {
+            pthread_cond_signal(&healer->cond);
+        } else {
+            ret = gf_thread_create(&healer->thread, NULL, threadfn, healer,
+                                   "shdheal");
+            if (ret)
+                goto unlock;
+            healer->running = 1;
+        }
+
+        healer->rerun = 1;
+    }
 unlock:
-	pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_unlock(&healer->mutex);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_shd_full_healer_spawn (xlator_t *this, int subvol)
+afr_shd_full_healer_spawn(xlator_t *this, int subvol)
 {
-	return afr_shd_healer_spawn (this, NTH_FULL_HEALER (this, subvol),
-				     afr_shd_full_healer);
+    return afr_shd_healer_spawn(this, NTH_FULL_HEALER(this, subvol),
+                                afr_shd_full_healer);
 }
 
-
 int
-afr_shd_index_healer_spawn (xlator_t *this, int subvol)
+afr_shd_index_healer_spawn(xlator_t *this, int subvol)
 {
-	return afr_shd_healer_spawn (this, NTH_INDEX_HEALER (this, subvol),
-				     afr_shd_index_healer);
+    return afr_shd_healer_spawn(this, NTH_INDEX_HEALER(this, subvol),
+                                afr_shd_index_healer);
 }
 
-
 int
-afr_shd_dict_add_crawl_event (xlator_t *this, dict_t *output,
-			      crawl_event_t *crawl_event)
+afr_shd_dict_add_crawl_event(xlator_t *this, dict_t *output,
+                             crawl_event_t *crawl_event)
 {
-        int             ret = 0;
-        uint64_t        count = 0;
-        char            key[256] = {0};
-        int             xl_id = 0;
-        uint64_t        healed_count = 0;
-        uint64_t        split_brain_count = 0;
-        uint64_t        heal_failed_count = 0;
-        char            *start_time_str = 0;
-        char            *end_time_str = NULL;
-        char            *crawl_type = NULL;
-        int             progress = -1;
-	int             child = -1;
-
-	child = crawl_event->child;
-        healed_count = crawl_event->healed_count;
-        split_brain_count = crawl_event->split_brain_count;
-        heal_failed_count = crawl_event->heal_failed_count;
-        crawl_type = crawl_event->crawl_type;
-
-	if (!crawl_event->start_time)
-		goto out;
-
-        start_time_str = gf_strdup (ctime (&crawl_event->start_time));
-
-	if (crawl_event->end_time)
-		end_time_str = gf_strdup (ctime (&crawl_event->end_time));
-
-        ret = dict_get_int32 (output, this->name, &xl_id);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_GET_FAILED, "xl does not have id");
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "statistics-%d-%d-count", xl_id, child);
-        ret = dict_get_uint64 (output, key, &count);
-
-
-        snprintf (key, sizeof (key), "statistics_healed_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64(output, key, healed_count);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_healed_count to output");
-                goto out;
-	}
-
-        snprintf (key, sizeof (key), "statistics_sb_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64 (output, key, split_brain_count);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_split_brain_count to output");
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "statistics_crawl_type-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_str (output, key, crawl_type);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-	                "Could not add statistics_crawl_type to output");
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "statistics_heal_failed_cnt-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_uint64 (output, key, heal_failed_count);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-	                "Could not add statistics_healed_failed_count to output");
-                goto out;
-        }
-
-        snprintf (key, sizeof (key), "statistics_strt_time-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        ret = dict_set_dynstr (output, key, start_time_str);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_crawl_start_time to output");
-                goto out;
-        } else {
-		start_time_str = NULL;
-	}
-
-	if (!end_time_str)
-                progress = 1;
-        else
-                progress = 0;
-
-        snprintf (key, sizeof (key), "statistics_end_time-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-        if (!end_time_str)
-                end_time_str = gf_strdup ("Could not determine the end time");
-        ret = dict_set_dynstr (output, key, end_time_str);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_crawl_end_time to output");
-                goto out;
-        } else {
-		end_time_str = NULL;
-	}
-
-        snprintf (key, sizeof (key), "statistics_inprogress-%d-%d-%"PRIu64,
-                  xl_id, child, count);
-
-        ret = dict_set_int32 (output, key, progress);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not add statistics_inprogress to output");
-                goto out;
-        }
-
-	snprintf (key, sizeof (key), "statistics-%d-%d-count", xl_id, child);
-	ret = dict_set_uint64 (output, key, count + 1);
-	if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-		        "Could not increment the counter.");
-                goto out;
-	}
+    int ret = 0;
+    uint64_t count = 0;
+    char key[256] = {0};
+    int xl_id = 0;
+    uint64_t healed_count = 0;
+    uint64_t split_brain_count = 0;
+    uint64_t heal_failed_count = 0;
+    char *start_time_str = 0;
+    char *end_time_str = NULL;
+    char *crawl_type = NULL;
+    int progress = -1;
+    int child = -1;
+
+    child = crawl_event->child;
+    healed_count = crawl_event->healed_count;
+    split_brain_count = crawl_event->split_brain_count;
+    heal_failed_count = crawl_event->heal_failed_count;
+    crawl_type = crawl_event->crawl_type;
+
+    if (!crawl_event->start_time)
+        goto out;
+
+    start_time_str = gf_strdup(ctime(&crawl_event->start_time));
+
+    if (crawl_event->end_time)
+        end_time_str = gf_strdup(ctime(&crawl_event->end_time));
+
+    ret = dict_get_int32(output, this->name, &xl_id);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+               "xl does not have id");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics-%d-%d-count", xl_id, child);
+    ret = dict_get_uint64(output, key, &count);
+
+    snprintf(key, sizeof(key), "statistics_healed_cnt-%d-%d-%" PRIu64, xl_id,
+             child, count);
+    ret = dict_set_uint64(output, key, healed_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_healed_count to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_sb_cnt-%d-%d-%" PRIu64, xl_id, child,
+             count);
+    ret = dict_set_uint64(output, key, split_brain_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_split_brain_count to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_crawl_type-%d-%d-%" PRIu64, xl_id,
+             child, count);
+    ret = dict_set_str(output, key, crawl_type);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_type to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_heal_failed_cnt-%d-%d-%" PRIu64,
+             xl_id, child, count);
+    ret = dict_set_uint64(output, key, heal_failed_count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_healed_failed_count to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics_strt_time-%d-%d-%" PRIu64, xl_id,
+             child, count);
+    ret = dict_set_dynstr(output, key, start_time_str);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_start_time to output");
+        goto out;
+    } else {
+        start_time_str = NULL;
+    }
+
+    if (!end_time_str)
+        progress = 1;
+    else
+        progress = 0;
+
+    snprintf(key, sizeof(key), "statistics_end_time-%d-%d-%" PRIu64, xl_id,
+             child, count);
+    if (!end_time_str)
+        end_time_str = gf_strdup("Could not determine the end time");
+    ret = dict_set_dynstr(output, key, end_time_str);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_crawl_end_time to output");
+        goto out;
+    } else {
+        end_time_str = NULL;
+    }
+
+    snprintf(key, sizeof(key), "statistics_inprogress-%d-%d-%" PRIu64, xl_id,
+             child, count);
+
+    ret = dict_set_int32(output, key, progress);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not add statistics_inprogress to output");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "statistics-%d-%d-count", xl_id, child);
+    ret = dict_set_uint64(output, key, count + 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not increment the counter.");
+        goto out;
+    }
 out:
-	GF_FREE (start_time_str);
-	GF_FREE (end_time_str);
-        return ret;
+    GF_FREE(start_time_str);
+    GF_FREE(end_time_str);
+    return ret;
 }
 
-
 int
-afr_shd_dict_add_path (xlator_t *this, dict_t *output, int child, char *path,
-		       struct timeval *tv)
+afr_shd_dict_add_path(xlator_t *this, dict_t *output, int child, char *path,
+                      struct timeval *tv)
 {
-        int             ret = -1;
-        uint64_t        count = 0;
-        char            key[256] = {0};
-        int             xl_id = 0;
-
-        ret = dict_get_int32 (output, this->name, &xl_id);
+    int ret = -1;
+    uint64_t count = 0;
+    char key[256] = {0};
+    int xl_id = 0;
+
+    ret = dict_get_int32(output, this->name, &xl_id);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_GET_FAILED,
+               "xl does not have id");
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "%d-%d-count", xl_id, child);
+    ret = dict_get_uint64(output, key, &count);
+
+    snprintf(key, sizeof(key), "%d-%d-%" PRIu64, xl_id, child, count);
+    ret = dict_set_dynstr(output, key, path);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "%s: Could not add to output", path);
+        goto out;
+    }
+
+    if (tv) {
+        snprintf(key, sizeof(key), "%d-%d-%" PRIu64 "-time", xl_id, child,
+                 count);
+        ret = dict_set_uint32(output, key, tv->tv_sec);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_GET_FAILED, "xl does not have id");
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+                   "%s: Could not set time", path);
+            goto out;
         }
+    }
 
-        snprintf (key, sizeof (key), "%d-%d-count", xl_id, child);
-        ret = dict_get_uint64 (output, key, &count);
+    snprintf(key, sizeof(key), "%d-%d-count", xl_id, child);
 
-        snprintf (key, sizeof (key), "%d-%d-%"PRIu64, xl_id, child, count);
-	ret = dict_set_dynstr (output, key, path);
+    ret = dict_set_uint64(output, key, count + 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_DICT_SET_FAILED,
+               "Could not increment count");
+        goto out;
+    }
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        AFR_MSG_DICT_SET_FAILED, "%s: Could not add to output",
-                        path);
-                goto out;
-        }
-
-	if (tv) {
-		snprintf (key, sizeof (key), "%d-%d-%"PRIu64"-time", xl_id,
-			  child, count);
-		ret = dict_set_uint32 (output, key, tv->tv_sec);
-		if (ret) {
-		        gf_msg (this->name, GF_LOG_ERROR,
-                                -ret, AFR_MSG_DICT_SET_FAILED,
-                                "%s: Could not set time",
-			        path);
-			goto out;
-		}
-	}
-
-        snprintf (key, sizeof (key), "%d-%d-count", xl_id, child);
-
-        ret = dict_set_uint64 (output, key, count + 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        -ret, AFR_MSG_DICT_SET_FAILED,
-                        "Could not increment count");
-                goto out;
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-afr_add_shd_event (circular_buffer_t *cb, void *data)
+afr_add_shd_event(circular_buffer_t *cb, void *data)
 {
-	dict_t *output = NULL;
-	xlator_t *this = THIS;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	shd_event_t *shd_event = NULL;
-	char *path = NULL;
-
-	output = data;
-	priv = this->private;
-	shd = &priv->shd;
-	shd_event = cb->data;
-
-	if (!shd->index_healers[shd_event->child].local)
-		return 0;
-
-	path = gf_strdup (shd_event->path);
-	if (!path)
-		return -ENOMEM;
-
-	afr_shd_dict_add_path (this, output, shd_event->child, path,
-			       &cb->tv);
-	return 0;
+    dict_t *output = NULL;
+    xlator_t *this = THIS;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    shd_event_t *shd_event = NULL;
+    char *path = NULL;
+
+    output = data;
+    priv = this->private;
+    shd = &priv->shd;
+    shd_event = cb->data;
+
+    if (!shd->index_healers[shd_event->child].local)
+        return 0;
+
+    path = gf_strdup(shd_event->path);
+    if (!path)
+        return -ENOMEM;
+
+    afr_shd_dict_add_path(this, output, shd_event->child, path, &cb->tv);
+    return 0;
 }
 
 int
-afr_add_crawl_event (circular_buffer_t *cb, void *data)
+afr_add_crawl_event(circular_buffer_t *cb, void *data)
 {
-	dict_t *output = NULL;
-	xlator_t *this = THIS;
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	crawl_event_t *crawl_event = NULL;
-
-	output = data;
-	priv = this->private;
-	shd = &priv->shd;
-	crawl_event = cb->data;
-
-	if (!shd->index_healers[crawl_event->child].local)
-		return 0;
+    dict_t *output = NULL;
+    xlator_t *this = THIS;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    crawl_event_t *crawl_event = NULL;
+
+    output = data;
+    priv = this->private;
+    shd = &priv->shd;
+    crawl_event = cb->data;
+
+    if (!shd->index_healers[crawl_event->child].local)
+        return 0;
 
-	afr_shd_dict_add_crawl_event (this, output, crawl_event);
+    afr_shd_dict_add_crawl_event(this, output, crawl_event);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_selfheal_daemon_init (xlator_t *this)
+afr_selfheal_daemon_init(xlator_t *this)
 {
-	afr_private_t *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	int ret = -1;
-	int i = 0;
-
-	priv = this->private;
-	shd = &priv->shd;
-
-	this->itable = inode_table_new (SHD_INODE_LRU_LIMIT, this);
-	if (!this->itable)
-		goto out;
-
-	shd->index_healers = GF_CALLOC (sizeof(*shd->index_healers),
-					priv->child_count,
-					gf_afr_mt_subvol_healer_t);
-	if (!shd->index_healers)
-		goto out;
-
-	for (i = 0; i < priv->child_count; i++) {
-		shd->index_healers[i].subvol = i;
-		ret = afr_shd_healer_init (this, &shd->index_healers[i]);
-		if (ret)
-			goto out;
-	}
-
-	shd->full_healers = GF_CALLOC (sizeof(*shd->full_healers),
-				       priv->child_count,
-				       gf_afr_mt_subvol_healer_t);
-	if (!shd->full_healers)
-		goto out;
-	for (i = 0; i < priv->child_count; i++) {
-		shd->full_healers[i].subvol = i;
-		ret = afr_shd_healer_init (this, &shd->full_healers[i]);
-		if (ret)
-			goto out;
-	}
-
-	shd->split_brain = eh_new (AFR_EH_SPLIT_BRAIN_LIMIT, _gf_false,
-				   afr_destroy_shd_event_data);
-	if (!shd->split_brain)
-		goto out;
-
-        shd->statistics = GF_CALLOC (sizeof(eh_t *), priv->child_count,
-				     gf_common_mt_eh_t);
-        if (!shd->statistics)
-                goto out;
-
-        for (i = 0; i < priv->child_count ; i++) {
-                shd->statistics[i] = eh_new (AFR_STATISTICS_HISTORY_SIZE,
-					     _gf_false,
-					     afr_destroy_crawl_event_data);
-                if (!shd->statistics[i])
-                        goto out;
-		shd->full_healers[i].crawl_event.child = i;
-		shd->full_healers[i].crawl_event.crawl_type = "FULL";
-		shd->index_healers[i].crawl_event.child = i;
-		shd->index_healers[i].crawl_event.crawl_type = "INDEX";
-        }
-
-	ret = 0;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    int ret = -1;
+    int i = 0;
+
+    priv = this->private;
+    shd = &priv->shd;
+
+    this->itable = inode_table_new(SHD_INODE_LRU_LIMIT, this);
+    if (!this->itable)
+        goto out;
+
+    shd->index_healers = GF_CALLOC(sizeof(*shd->index_healers),
+                                   priv->child_count,
+                                   gf_afr_mt_subvol_healer_t);
+    if (!shd->index_healers)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        shd->index_healers[i].subvol = i;
+        ret = afr_shd_healer_init(this, &shd->index_healers[i]);
+        if (ret)
+            goto out;
+    }
+
+    shd->full_healers = GF_CALLOC(sizeof(*shd->full_healers), priv->child_count,
+                                  gf_afr_mt_subvol_healer_t);
+    if (!shd->full_healers)
+        goto out;
+    for (i = 0; i < priv->child_count; i++) {
+        shd->full_healers[i].subvol = i;
+        ret = afr_shd_healer_init(this, &shd->full_healers[i]);
+        if (ret)
+            goto out;
+    }
+
+    shd->split_brain = eh_new(AFR_EH_SPLIT_BRAIN_LIMIT, _gf_false,
+                              afr_destroy_shd_event_data);
+    if (!shd->split_brain)
+        goto out;
+
+    shd->statistics = GF_CALLOC(sizeof(eh_t *), priv->child_count,
+                                gf_common_mt_eh_t);
+    if (!shd->statistics)
+        goto out;
+
+    for (i = 0; i < priv->child_count; i++) {
+        shd->statistics[i] = eh_new(AFR_STATISTICS_HISTORY_SIZE, _gf_false,
+                                    afr_destroy_crawl_event_data);
+        if (!shd->statistics[i])
+            goto out;
+        shd->full_healers[i].crawl_event.child = i;
+        shd->full_healers[i].crawl_event.crawl_type = "FULL";
+        shd->index_healers[i].crawl_event.child = i;
+        shd->index_healers[i].crawl_event.crawl_type = "INDEX";
+    }
+
+    ret = 0;
 out:
-	return ret;
+    return ret;
 }
 
-
 int
-afr_selfheal_childup (xlator_t *this, int subvol)
+afr_selfheal_childup(xlator_t *this, int subvol)
 {
-	afr_shd_index_healer_spawn (this, subvol);
+    afr_shd_index_healer_spawn(this, subvol);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_shd_get_index_count (xlator_t *this, int i, uint64_t *count)
+afr_shd_get_index_count(xlator_t *this, int i, uint64_t *count)
 {
-	afr_private_t *priv = NULL;
-	xlator_t *subvol = NULL;
-	loc_t rootloc = {0, };
-	dict_t *xattr = NULL;
-	int ret = -1;
+    afr_private_t *priv = NULL;
+    xlator_t *subvol = NULL;
+    loc_t rootloc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+    int ret = -1;
 
-	priv = this->private;
-	subvol = priv->children[i];
+    priv = this->private;
+    subvol = priv->children[i];
 
-	rootloc.inode = inode_ref (this->itable->root);
-	gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
 
-	ret = syncop_getxattr (subvol, &rootloc, &xattr,
-			       GF_XATTROP_INDEX_COUNT, NULL, NULL);
-	if (ret < 0)
-		goto out;
+    ret = syncop_getxattr(subvol, &rootloc, &xattr, GF_XATTROP_INDEX_COUNT,
+                          NULL, NULL);
+    if (ret < 0)
+        goto out;
 
-	ret = dict_get_uint64 (xattr, GF_XATTROP_INDEX_COUNT, count);
-	if (ret)
-		goto out;
+    ret = dict_get_uint64(xattr, GF_XATTROP_INDEX_COUNT, count);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (xattr)
-                dict_unref (xattr);
-	loc_wipe (&rootloc);
+    if (xattr)
+        dict_unref(xattr);
+    loc_wipe(&rootloc);
 
-	return ret;
+    return ret;
 }
 
-
 int
-afr_xl_op (xlator_t *this, dict_t *input, dict_t *output)
+afr_xl_op(xlator_t *this, dict_t *input, dict_t *output)
 {
-        gf_xl_afr_op_t   op = GF_SHD_OP_INVALID;
-        int              ret = 0;
-        int              xl_id = 0;
-	afr_private_t   *priv = NULL;
-	afr_self_heald_t *shd = NULL;
-	struct subvol_healer *healer = NULL;
-	int i = 0;
-	char key[64];
-	int op_ret = 0;
-	uint64_t cnt = 0;
-
-	priv = this->private;
-	shd = &priv->shd;
-
-        ret = dict_get_int32 (input, "xl-op", (int32_t*)&op);
-        if (ret)
-                goto out;
-        ret = dict_get_int32 (input, this->name, &xl_id);
-        if (ret)
-                goto out;
-        ret = dict_set_int32 (output, this->name, xl_id);
-        if (ret)
-                goto out;
-        switch (op) {
+    gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
+    int ret = 0;
+    int xl_id = 0;
+    afr_private_t *priv = NULL;
+    afr_self_heald_t *shd = NULL;
+    struct subvol_healer *healer = NULL;
+    int i = 0;
+    char key[64];
+    int op_ret = 0;
+    uint64_t cnt = 0;
+
+    priv = this->private;
+    shd = &priv->shd;
+
+    ret = dict_get_int32(input, "xl-op", (int32_t *)&op);
+    if (ret)
+        goto out;
+    ret = dict_get_int32(input, this->name, &xl_id);
+    if (ret)
+        goto out;
+    ret = dict_set_int32(output, this->name, xl_id);
+    if (ret)
+        goto out;
+    switch (op) {
         case GF_SHD_OP_HEAL_INDEX:
-		op_ret = 0;
-
-		for (i = 0; i < priv->child_count; i++) {
-			healer = &shd->index_healers[i];
-			snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-
-			if (!priv->child_up[i]) {
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-                                op_ret = -1;
-			} else if (AFR_COUNT (priv->child_up,
-					      priv->child_count) < 2) {
-				ret = dict_set_str (output, key,
-						    "< 2 bricks in replica are up");
-                                op_ret = -1;
-			} else if (!afr_shd_is_subvol_local (this, healer->subvol)) {
-				ret = dict_set_str (output, key,
-						    "Brick is remote");
-			} else {
-				ret = dict_set_str (output, key,
-						    "Started self-heal");
-				afr_shd_index_healer_spawn (this, i);
-			}
-		}
-                break;
+            op_ret = 0;
+
+            for (i = 0; i < priv->child_count; i++) {
+                healer = &shd->index_healers[i];
+                snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+
+                if (!priv->child_up[i]) {
+                    ret = dict_set_str(output, key, "Brick is not connected");
+                    op_ret = -1;
+                } else if (AFR_COUNT(priv->child_up, priv->child_count) < 2) {
+                    ret = dict_set_str(output, key,
+                                       "< 2 bricks in replica are up");
+                    op_ret = -1;
+                } else if (!afr_shd_is_subvol_local(this, healer->subvol)) {
+                    ret = dict_set_str(output, key, "Brick is remote");
+                } else {
+                    ret = dict_set_str(output, key, "Started self-heal");
+                    afr_shd_index_healer_spawn(this, i);
+                }
+            }
+            break;
         case GF_SHD_OP_HEAL_FULL:
-		op_ret = -1;
-
-		for (i = 0; i < priv->child_count; i++) {
-			healer = &shd->full_healers[i];
-			snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-
-			if (!priv->child_up[i]) {
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-			} else if (AFR_COUNT (priv->child_up,
-					      priv->child_count) < 2) {
-				ret = dict_set_str (output, key,
-						    "< 2 bricks in replica are up");
-			} else if (!afr_shd_is_subvol_local (this, healer->subvol)) {
-				ret = dict_set_str (output, key,
-						    "Brick is remote");
-			} else {
-				ret = dict_set_str (output, key,
-						    "Started self-heal");
-				afr_shd_full_healer_spawn (this, i);
-				op_ret = 0;
-			}
-		}
-                break;
+            op_ret = -1;
+
+            for (i = 0; i < priv->child_count; i++) {
+                healer = &shd->full_healers[i];
+                snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+
+                if (!priv->child_up[i]) {
+                    ret = dict_set_str(output, key, "Brick is not connected");
+                } else if (AFR_COUNT(priv->child_up, priv->child_count) < 2) {
+                    ret = dict_set_str(output, key,
+                                       "< 2 bricks in replica are up");
+                } else if (!afr_shd_is_subvol_local(this, healer->subvol)) {
+                    ret = dict_set_str(output, key, "Brick is remote");
+                } else {
+                    ret = dict_set_str(output, key, "Started self-heal");
+                    afr_shd_full_healer_spawn(this, i);
+                    op_ret = 0;
+                }
+            }
+            break;
         case GF_SHD_OP_INDEX_SUMMARY:
-                /* this case has been handled in glfs-heal.c */
-                break;
+            /* this case has been handled in glfs-heal.c */
+            break;
         case GF_SHD_OP_HEALED_FILES:
         case GF_SHD_OP_HEAL_FAILED_FILES:
-                for (i = 0; i < priv->child_count; i++) {
-                        snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-                        ret = dict_set_str (output, key, "Operation Not "
-                                            "Supported");
-                }
-                break;
+            for (i = 0; i < priv->child_count; i++) {
+                snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+                ret = dict_set_str(output, key,
+                                   "Operation Not "
+                                   "Supported");
+            }
+            break;
         case GF_SHD_OP_SPLIT_BRAIN_FILES:
-		eh_dump (shd->split_brain, output, afr_add_shd_event);
-                break;
+            eh_dump(shd->split_brain, output, afr_add_shd_event);
+            break;
         case GF_SHD_OP_STATISTICS:
-		for (i = 0; i < priv->child_count; i++) {
-			eh_dump (shd->statistics[i], output,
-				 afr_add_crawl_event);
-			afr_shd_dict_add_crawl_event (this, output,
-						      &shd->index_healers[i].crawl_event);
-			afr_shd_dict_add_crawl_event (this, output,
-						      &shd->full_healers[i].crawl_event);
-		}
-                break;
+            for (i = 0; i < priv->child_count; i++) {
+                eh_dump(shd->statistics[i], output, afr_add_crawl_event);
+                afr_shd_dict_add_crawl_event(
+                    this, output, &shd->index_healers[i].crawl_event);
+                afr_shd_dict_add_crawl_event(this, output,
+                                             &shd->full_healers[i].crawl_event);
+            }
+            break;
         case GF_SHD_OP_STATISTICS_HEAL_COUNT:
         case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA:
-		op_ret = -1;
-
-		for (i = 0; i < priv->child_count; i++) {
-			if (!priv->child_up[i]) {
-				snprintf (key, sizeof (key), "%d-%d-status",
-                                          xl_id, i);
-				ret = dict_set_str (output, key,
-						    "Brick is not connected");
-			} else {
-				snprintf (key, sizeof (key), "%d-%d-hardlinks",
-                                          xl_id, i);
-				ret = afr_shd_get_index_count (this, i, &cnt);
-				if (ret == 0) {
-					ret = dict_set_uint64 (output, key, cnt);
-				}
-				op_ret = 0;
-			}
-		}
-
-                break;
+            op_ret = -1;
+
+            for (i = 0; i < priv->child_count; i++) {
+                if (!priv->child_up[i]) {
+                    snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+                    ret = dict_set_str(output, key, "Brick is not connected");
+                } else {
+                    snprintf(key, sizeof(key), "%d-%d-hardlinks", xl_id, i);
+                    ret = afr_shd_get_index_count(this, i, &cnt);
+                    if (ret == 0) {
+                        ret = dict_set_uint64(output, key, cnt);
+                    }
+                    op_ret = 0;
+                }
+            }
+
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_INVALID_ARG, "Unknown set op %d", op);
-                break;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_ARG,
+                   "Unknown set op %d", op);
+            break;
+    }
 out:
-        dict_del (output, this->name);
-        return op_ret;
+    dict_del(output, this->name);
+    return op_ret;
 }
diff --git a/xlators/cluster/afr/src/afr-transaction.c b/xlators/cluster/afr/src/afr-transaction.c
index 9c587db0562..3a542ceca43 100644
--- a/xlators/cluster/afr/src/afr-transaction.c
+++ b/xlators/cluster/afr/src/afr-transaction.c
@@ -21,57 +21,57 @@
 #include <signal.h>
 
 typedef enum {
-        AFR_TRANSACTION_PRE_OP,
-        AFR_TRANSACTION_POST_OP,
+    AFR_TRANSACTION_PRE_OP,
+    AFR_TRANSACTION_POST_OP,
 } afr_xattrop_type_t;
 
 static void
-afr_lock_resume_shared (struct list_head *list);
+afr_lock_resume_shared(struct list_head *list);
 
 void
-__afr_transaction_wake_shared (afr_local_t *local, struct list_head *shared);
+__afr_transaction_wake_shared(afr_local_t *local, struct list_head *shared);
 
 void
-afr_changelog_post_op (call_frame_t *frame, xlator_t *this);
+afr_changelog_post_op(call_frame_t *frame, xlator_t *this);
 
 int
-afr_changelog_post_op_safe (call_frame_t *frame, xlator_t *this);
+afr_changelog_post_op_safe(call_frame_t *frame, xlator_t *this);
 
 gf_boolean_t
-afr_changelog_pre_op_uninherit (call_frame_t *frame, xlator_t *this);
+afr_changelog_pre_op_uninherit(call_frame_t *frame, xlator_t *this);
 
 gf_boolean_t
-afr_changelog_pre_op_update (call_frame_t *frame, xlator_t *this);
+afr_changelog_pre_op_update(call_frame_t *frame, xlator_t *this);
 
 int
-afr_changelog_call_count (afr_transaction_type type,
-                          unsigned char *pre_op_subvols,
-                          unsigned char *failed_subvols,
-                          unsigned int child_count);
+afr_changelog_call_count(afr_transaction_type type,
+                         unsigned char *pre_op_subvols,
+                         unsigned char *failed_subvols,
+                         unsigned int child_count);
 int
-afr_changelog_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-		  afr_changelog_resume_t changelog_resume,
-                  afr_xattrop_type_t op);
+afr_changelog_do(call_frame_t *frame, xlator_t *this, dict_t *xattr,
+                 afr_changelog_resume_t changelog_resume,
+                 afr_xattrop_type_t op);
 
 void
-afr_zero_fill_stat (afr_local_t *local)
-{
-        if (!local)
-                return;
-        if (local->transaction.type == AFR_DATA_TRANSACTION ||
-            local->transaction.type == AFR_METADATA_TRANSACTION) {
-                gf_zero_fill_stat (&local->cont.inode_wfop.prebuf);
-                gf_zero_fill_stat (&local->cont.inode_wfop.postbuf);
-        } else if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
-                   local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                gf_zero_fill_stat (&local->cont.dir_fop.buf);
-                gf_zero_fill_stat (&local->cont.dir_fop.preparent);
-                gf_zero_fill_stat (&local->cont.dir_fop.postparent);
-                if (local->transaction.type == AFR_ENTRY_TRANSACTION)
-                        return;
-                gf_zero_fill_stat (&local->cont.dir_fop.prenewparent);
-                gf_zero_fill_stat (&local->cont.dir_fop.postnewparent);
-        }
+afr_zero_fill_stat(afr_local_t *local)
+{
+    if (!local)
+        return;
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION) {
+        gf_zero_fill_stat(&local->cont.inode_wfop.prebuf);
+        gf_zero_fill_stat(&local->cont.inode_wfop.postbuf);
+    } else if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
+               local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
+        gf_zero_fill_stat(&local->cont.dir_fop.buf);
+        gf_zero_fill_stat(&local->cont.dir_fop.preparent);
+        gf_zero_fill_stat(&local->cont.dir_fop.postparent);
+        if (local->transaction.type == AFR_ENTRY_TRANSACTION)
+            return;
+        gf_zero_fill_stat(&local->cont.dir_fop.prenewparent);
+        gf_zero_fill_stat(&local->cont.dir_fop.postnewparent);
+    }
 }
 
 /* In case of errors afr needs to choose which xdata from lower xlators it needs
@@ -79,2483 +79,2402 @@ afr_zero_fill_stat (afr_local_t *local)
  * any good subvols which failed. Give preference to errnos other than
  * ENOTCONN even if the child is source */
 void
-afr_pick_error_xdata (afr_local_t *local, afr_private_t *priv,
-                      inode_t *inode1, unsigned char *readable1,
-                      inode_t *inode2, unsigned char *readable2)
-{
-        int     s = -1;/*selection*/
-        int     i = 0;
-        unsigned char *readable = NULL;
-
-        if (local->xdata_rsp) {
-                dict_unref (local->xdata_rsp);
-                local->xdata_rsp = NULL;
-        }
-
-        readable = alloca0 (priv->child_count * sizeof (*readable));
-        if (inode2 && readable2) {/*rename fop*/
-                AFR_INTERSECT (readable, readable1, readable2,
-                               priv->child_count);
-        } else {
-                memcpy (readable, readable1,
-                        sizeof (*readable) * priv->child_count);
-        }
-
+afr_pick_error_xdata(afr_local_t *local, afr_private_t *priv, inode_t *inode1,
+                     unsigned char *readable1, inode_t *inode2,
+                     unsigned char *readable2)
+{
+    int s = -1; /*selection*/
+    int i = 0;
+    unsigned char *readable = NULL;
+
+    if (local->xdata_rsp) {
+        dict_unref(local->xdata_rsp);
+        local->xdata_rsp = NULL;
+    }
+
+    readable = alloca0(priv->child_count * sizeof(*readable));
+    if (inode2 && readable2) { /*rename fop*/
+        AFR_INTERSECT(readable, readable1, readable2, priv->child_count);
+    } else {
+        memcpy(readable, readable1, sizeof(*readable) * priv->child_count);
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->replies[i].valid)
+            continue;
+
+        if (local->replies[i].op_ret >= 0)
+            continue;
+
+        if (local->replies[i].op_errno == ENOTCONN)
+            continue;
+
+        /*Order is important in the following condition*/
+        if ((s < 0) || (!readable[s] && readable[i]))
+            s = i;
+    }
+
+    if (s != -1 && local->replies[s].xdata) {
+        local->xdata_rsp = dict_ref(local->replies[s].xdata);
+    } else if (s == -1) {
         for (i = 0; i < priv->child_count; i++) {
-                if (!local->replies[i].valid)
-                        continue;
-
-                if (local->replies[i].op_ret >= 0)
-                        continue;
+            if (!local->replies[i].valid)
+                continue;
 
-                if (local->replies[i].op_errno == ENOTCONN)
-                        continue;
+            if (local->replies[i].op_ret >= 0)
+                continue;
 
-                /*Order is important in the following condition*/
-                if ((s < 0) || (!readable[s] && readable[i]))
-                        s = i;
-        }
-
-        if (s != -1 && local->replies[s].xdata) {
-                local->xdata_rsp = dict_ref (local->replies[s].xdata);
-        } else if (s == -1) {
-                for (i = 0; i < priv->child_count; i++) {
-                        if (!local->replies[i].valid)
-                                continue;
-
-                        if (local->replies[i].op_ret >= 0)
-                                continue;
-
-                        if (!local->replies[i].xdata)
-                                continue;
-                        local->xdata_rsp = dict_ref (local->replies[i].xdata);
-                        break;
-                }
+            if (!local->replies[i].xdata)
+                continue;
+            local->xdata_rsp = dict_ref(local->replies[i].xdata);
+            break;
         }
+    }
 }
 
 gf_boolean_t
-afr_needs_changelog_update (afr_local_t *local)
+afr_needs_changelog_update(afr_local_t *local)
 {
-        if (local->transaction.type == AFR_DATA_TRANSACTION)
-                return _gf_true;
-        if (!local->optimistic_change_log)
-                return _gf_true;
-        return _gf_false;
+    if (local->transaction.type == AFR_DATA_TRANSACTION)
+        return _gf_true;
+    if (!local->optimistic_change_log)
+        return _gf_true;
+    return _gf_false;
 }
 
 gf_boolean_t
-afr_changelog_has_quorum (afr_local_t *local, xlator_t *this)
+afr_changelog_has_quorum(afr_local_t *local, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        int i = 0;
-        unsigned char *success_children = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    unsigned char *success_children = NULL;
 
-        priv = this->private;
-        success_children = alloca0 (priv->child_count);
+    priv = this->private;
+    success_children = alloca0(priv->child_count);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.failed_subvols[i]) {
-                        success_children[i] = 1;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.failed_subvols[i]) {
+            success_children[i] = 1;
         }
+    }
 
-        if (afr_has_quorum (success_children, this)) {
-                return _gf_true;
-        }
+    if (afr_has_quorum(success_children, this)) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
-
 gf_boolean_t
-afr_is_write_subvol_valid (call_frame_t *frame, xlator_t *this)
+afr_is_write_subvol_valid(call_frame_t *frame, xlator_t *this)
 {
-        int i = 0;
-        afr_local_t *local = NULL;
-        afr_private_t *priv  = NULL;
-        uint64_t write_subvol = 0;
-        unsigned char *writable = NULL;
-        uint16_t datamap = 0;
+    int i = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    uint64_t write_subvol = 0;
+    unsigned char *writable = NULL;
+    uint16_t datamap = 0;
 
-        local = frame->local;
-        priv = this->private;
-        writable = alloca0 (priv->child_count);
+    local = frame->local;
+    priv = this->private;
+    writable = alloca0(priv->child_count);
 
-        write_subvol = afr_write_subvol_get (frame, this);
-        datamap = (write_subvol & 0x00000000ffff0000) >> 16;
-        for (i = 0; i < priv->child_count; i++) {
-                if (datamap & (1 << i))
-                        writable[i] = 1;
+    write_subvol = afr_write_subvol_get(frame, this);
+    datamap = (write_subvol & 0x00000000ffff0000) >> 16;
+    for (i = 0; i < priv->child_count; i++) {
+        if (datamap & (1 << i))
+            writable[i] = 1;
 
-                if (writable[i] && !local->transaction.failed_subvols[i])
-                        return _gf_true;
-        }
+        if (writable[i] && !local->transaction.failed_subvols[i])
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int
-afr_transaction_fop (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int call_count = -1;
-        unsigned char *failed_subvols = NULL;
-        int i = 0;
-
-        local = frame->local;
-        priv = this->private;
-
-        failed_subvols = local->transaction.failed_subvols;
-        call_count = priv->child_count - AFR_COUNT (failed_subvols,
-                                                    priv->child_count);
-        /* Fail if pre-op did not succeed on quorum no. of bricks. */
-        if (!afr_changelog_has_quorum (local, this) || !call_count) {
-                local->op_ret = -1;
-                /* local->op_errno is already captured in changelog cbk. */
-                afr_transaction_resume (frame, this);
-                return 0;
-        }
+afr_transaction_fop(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int call_count = -1;
+    unsigned char *failed_subvols = NULL;
+    int i = 0;
+
+    local = frame->local;
+    priv = this->private;
+
+    failed_subvols = local->transaction.failed_subvols;
+    call_count = priv->child_count -
+                 AFR_COUNT(failed_subvols, priv->child_count);
+    /* Fail if pre-op did not succeed on quorum no. of bricks. */
+    if (!afr_changelog_has_quorum(local, this) || !call_count) {
+        local->op_ret = -1;
+        /* local->op_errno is already captured in changelog cbk. */
+        afr_transaction_resume(frame, this);
+        return 0;
+    }
 
-        /* Fail if at least one writeable brick isn't up.*/
-        if (local->transaction.type == AFR_DATA_TRANSACTION &&
-            !afr_is_write_subvol_valid (frame, this)) {
-                local->op_ret = -1;
-                local->op_errno = EIO;
-                afr_transaction_resume (frame, this);
-                return 0;
-        }
+    /* Fail if at least one writeable brick isn't up.*/
+    if (local->transaction.type == AFR_DATA_TRANSACTION &&
+        !afr_is_write_subvol_valid(frame, this)) {
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        afr_transaction_resume(frame, this);
+        return 0;
+    }
 
-        local->call_count = call_count;
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i] && !failed_subvols[i]) {
-			local->transaction.wind (frame, this, i);
+    local->call_count = call_count;
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] && !failed_subvols[i]) {
+            local->transaction.wind(frame, this, i);
 
-                        if (!--call_count)
-                                break;
-                }
+            if (!--call_count)
+                break;
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-afr_transaction_done (call_frame_t *frame, xlator_t *this)
+afr_transaction_done(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   *local      = NULL;
-        afr_private_t *priv       = NULL;
-        gf_boolean_t  unwind      = _gf_false;
-        afr_lock_t    *lock       = NULL;
-        afr_local_t   *lock_local = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t unwind = _gf_false;
+    afr_lock_t *lock = NULL;
+    afr_local_t *lock_local = NULL;
 
-        priv  = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        if (priv->consistent_metadata) {
-                LOCK (&frame->lock);
-                {
-                        unwind = (local->transaction.main_frame != NULL);
-                }
-                UNLOCK (&frame->lock);
-                if (unwind)/*It definitely did post-op*/
-                        afr_zero_fill_stat (local);
+    if (priv->consistent_metadata) {
+        LOCK(&frame->lock);
+        {
+            unwind = (local->transaction.main_frame != NULL);
         }
+        UNLOCK(&frame->lock);
+        if (unwind) /*It definitely did post-op*/
+            afr_zero_fill_stat(local);
+    }
 
-        if (local->transaction.do_eager_unlock) {
-                lock = &local->inode_ctx->lock[local->transaction.type];
-                LOCK (&local->inode->lock);
-                {
-                        lock->acquired = _gf_false;
-                        lock->release = _gf_false;
-                        list_splice_init (&lock->frozen,
-                                          &lock->waiting);
-                        if (list_empty (&lock->waiting))
-                                goto unlock;
-                        lock_local = list_entry (lock->waiting.next,
-                                                 afr_local_t,
-                                                transaction.wait_list);
-                        list_del_init (&lock_local->transaction.wait_list);
-                        list_add (&lock_local->transaction.owner_list,
-                                  &lock->owners);
-                }
-unlock:
-                UNLOCK (&local->inode->lock);
-        }
-        if (lock_local) {
-                afr_lock (lock_local->transaction.frame,
-                          lock_local->transaction.frame->this);
-        }
-        local->transaction.unwind (frame, this);
+    if (local->transaction.do_eager_unlock) {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        LOCK(&local->inode->lock);
+        {
+            lock->acquired = _gf_false;
+            lock->release = _gf_false;
+            list_splice_init(&lock->frozen, &lock->waiting);
+            if (list_empty(&lock->waiting))
+                goto unlock;
+            lock_local = list_entry(lock->waiting.next, afr_local_t,
+                                    transaction.wait_list);
+            list_del_init(&lock_local->transaction.wait_list);
+            list_add(&lock_local->transaction.owner_list, &lock->owners);
+        }
+    unlock:
+        UNLOCK(&local->inode->lock);
+    }
+    if (lock_local) {
+        afr_lock(lock_local->transaction.frame,
+                 lock_local->transaction.frame->this);
+    }
+    local->transaction.unwind(frame, this);
 
-        AFR_STACK_DESTROY (frame);
+    AFR_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
 static void
-afr_lock_fail_shared (afr_local_t *local, struct list_head *list)
-{
-        afr_local_t *each = NULL;
-
-        while (!list_empty(list)) {
-                each = list_entry (list->next, afr_local_t,
-                                   transaction.wait_list);
-                list_del_init(&each->transaction.wait_list);
-                each->op_ret = -1;
-                each->op_errno = local->op_errno;
-                afr_transaction_done (each->transaction.frame,
-                                      each->transaction.frame->this);
-        }
+afr_lock_fail_shared(afr_local_t *local, struct list_head *list)
+{
+    afr_local_t *each = NULL;
+
+    while (!list_empty(list)) {
+        each = list_entry(list->next, afr_local_t, transaction.wait_list);
+        list_del_init(&each->transaction.wait_list);
+        each->op_ret = -1;
+        each->op_errno = local->op_errno;
+        afr_transaction_done(each->transaction.frame,
+                             each->transaction.frame->this);
+    }
 }
 
 static void
-afr_handle_lock_acquire_failure (afr_local_t *local, gf_boolean_t locked)
+afr_handle_lock_acquire_failure(afr_local_t *local, gf_boolean_t locked)
 {
-        struct list_head shared;
-        afr_lock_t *lock = NULL;
+    struct list_head shared;
+    afr_lock_t *lock = NULL;
 
-        if (!local->transaction.eager_lock_on)
-                goto out;
+    if (!local->transaction.eager_lock_on)
+        goto out;
 
-        lock = &local->inode_ctx->lock[local->transaction.type];
+    lock = &local->inode_ctx->lock[local->transaction.type];
 
-        INIT_LIST_HEAD (&shared);
-        LOCK (&local->inode->lock);
-        {
-                lock->release = _gf_true;
-                list_splice_init (&lock->waiting, &shared);
-        }
-        UNLOCK (&local->inode->lock);
+    INIT_LIST_HEAD(&shared);
+    LOCK(&local->inode->lock);
+    {
+        lock->release = _gf_true;
+        list_splice_init(&lock->waiting, &shared);
+    }
+    UNLOCK(&local->inode->lock);
 
-        afr_lock_fail_shared (local, &shared);
-        local->transaction.do_eager_unlock = _gf_true;
+    afr_lock_fail_shared(local, &shared);
+    local->transaction.do_eager_unlock = _gf_true;
 out:
-        if (locked) {
-                local->internal_lock.lock_cbk = afr_transaction_done;
-                afr_unlock (local->transaction.frame,
-                            local->transaction.frame->this);
-        } else {
-                afr_transaction_done (local->transaction.frame,
-                                      local->transaction.frame->this);
-        }
+    if (locked) {
+        local->internal_lock.lock_cbk = afr_transaction_done;
+        afr_unlock(local->transaction.frame, local->transaction.frame->this);
+    } else {
+        afr_transaction_done(local->transaction.frame,
+                             local->transaction.frame->this);
+    }
 }
 
-call_frame_t*
-afr_transaction_detach_fop_frame (call_frame_t *frame)
+call_frame_t *
+afr_transaction_detach_fop_frame(call_frame_t *frame)
 {
-        afr_local_t *   local = NULL;
-        call_frame_t   *fop_frame = NULL;
+    afr_local_t *local = NULL;
+    call_frame_t *fop_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        afr_handle_inconsistent_fop (frame, &local->op_ret, &local->op_errno);
-        LOCK (&frame->lock);
-        {
-                fop_frame = local->transaction.main_frame;
-                local->transaction.main_frame = NULL;
-        }
-        UNLOCK (&frame->lock);
+    afr_handle_inconsistent_fop(frame, &local->op_ret, &local->op_errno);
+    LOCK(&frame->lock);
+    {
+        fop_frame = local->transaction.main_frame;
+        local->transaction.main_frame = NULL;
+    }
+    UNLOCK(&frame->lock);
 
-        return fop_frame;
+    return fop_frame;
 }
 
-
 static void
-afr_save_lk_owner (call_frame_t *frame)
+afr_save_lk_owner(call_frame_t *frame)
 {
-        afr_local_t * local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->saved_lk_owner = frame->root->lk_owner;
+    local->saved_lk_owner = frame->root->lk_owner;
 }
 
-
 static void
-afr_restore_lk_owner (call_frame_t *frame)
+afr_restore_lk_owner(call_frame_t *frame)
 {
-        afr_local_t * local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        frame->root->lk_owner = local->saved_lk_owner;
+    frame->root->lk_owner = local->saved_lk_owner;
 }
 
 void
-__mark_all_success (call_frame_t *frame, xlator_t *this)
+__mark_all_success(call_frame_t *frame, xlator_t *this)
 {
-	afr_private_t *priv = NULL;
-	afr_local_t *local = NULL;
-	int i;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	for (i = 0; i < priv->child_count; i++) {
-		local->transaction.failed_subvols[i] = 0;
-	}
+    for (i = 0; i < priv->child_count; i++) {
+        local->transaction.failed_subvols[i] = 0;
+    }
 }
 
 void
-afr_compute_pre_op_sources (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        afr_transaction_type type = -1;
-        dict_t *xdata = NULL;
-        int **matrix = NULL;
-        int idx = -1;
-        int i = 0;
-        int j = 0;
-
-        priv = this->private;
-        local = frame->local;
-        type = local->transaction.type;
-        idx = afr_index_for_transaction_type (type);
-        matrix = ALLOC_MATRIX (priv->child_count, int);
-
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.changelog_xdata[i])
-                        continue;
-                xdata = local->transaction.changelog_xdata[i];
-                afr_selfheal_fill_matrix (this, matrix, i, idx, xdata);
-        }
-
-        memset (local->transaction.pre_op_sources, 1, priv->child_count);
-
-        /*If lock or pre-op failed on a brick, it is not a source. */
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.failed_subvols[i])
-                        local->transaction.pre_op_sources[i] = 0;
-        }
-
-        /* If brick is blamed by others, it is not a source. */
-        for (i = 0; i < priv->child_count; i++)
-                for (j = 0; j < priv->child_count; j++)
-                        if (matrix[i][j] != 0)
-                                local->transaction.pre_op_sources[j] = 0;
+afr_compute_pre_op_sources(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_transaction_type type = -1;
+    dict_t *xdata = NULL;
+    int **matrix = NULL;
+    int idx = -1;
+    int i = 0;
+    int j = 0;
+
+    priv = this->private;
+    local = frame->local;
+    type = local->transaction.type;
+    idx = afr_index_for_transaction_type(type);
+    matrix = ALLOC_MATRIX(priv->child_count, int);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.changelog_xdata[i])
+            continue;
+        xdata = local->transaction.changelog_xdata[i];
+        afr_selfheal_fill_matrix(this, matrix, i, idx, xdata);
+    }
+
+    memset(local->transaction.pre_op_sources, 1, priv->child_count);
+
+    /*If lock or pre-op failed on a brick, it is not a source. */
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i])
+            local->transaction.pre_op_sources[i] = 0;
+    }
+
+    /* If brick is blamed by others, it is not a source. */
+    for (i = 0; i < priv->child_count; i++)
+        for (j = 0; j < priv->child_count; j++)
+            if (matrix[i][j] != 0)
+                local->transaction.pre_op_sources[j] = 0;
 }
 
 gf_boolean_t
-afr_has_arbiter_fop_cbk_quorum (call_frame_t *frame)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        xlator_t *this = NULL;
-        gf_boolean_t fop_failed = _gf_false;
-        unsigned char *pre_op_sources = NULL;
-        int i = 0;
-
-        local = frame->local;
-        this = frame->this;
-        priv  = this->private;
-        pre_op_sources = local->transaction.pre_op_sources;
-
-        /* If the fop failed on the brick, it is not a source. */
-        for (i = 0; i < priv->child_count; i++)
-                if (local->transaction.failed_subvols[i])
-                        pre_op_sources[i] = 0;
-
-        switch (AFR_COUNT (pre_op_sources, priv->child_count)) {
+afr_has_arbiter_fop_cbk_quorum(call_frame_t *frame)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    xlator_t *this = NULL;
+    gf_boolean_t fop_failed = _gf_false;
+    unsigned char *pre_op_sources = NULL;
+    int i = 0;
+
+    local = frame->local;
+    this = frame->this;
+    priv = this->private;
+    pre_op_sources = local->transaction.pre_op_sources;
+
+    /* If the fop failed on the brick, it is not a source. */
+    for (i = 0; i < priv->child_count; i++)
+        if (local->transaction.failed_subvols[i])
+            pre_op_sources[i] = 0;
+
+    switch (AFR_COUNT(pre_op_sources, priv->child_count)) {
         case 1:
-                if (pre_op_sources[ARBITER_BRICK_INDEX])
-                        fop_failed = _gf_true;
-                break;
-        case 0:
+            if (pre_op_sources[ARBITER_BRICK_INDEX])
                 fop_failed = _gf_true;
-                break;
-        }
+            break;
+        case 0:
+            fop_failed = _gf_true;
+            break;
+    }
 
-        if (fop_failed)
-                return _gf_false;
+    if (fop_failed)
+        return _gf_false;
 
-        return _gf_true;
+    return _gf_true;
 }
 
 void
-afr_txn_arbitrate_fop (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t *local = NULL;
-        afr_private_t *priv = NULL;
-        int pre_op_sources_count = 0;
-        int i = 0;
-
-        priv = this->private;
-        local = frame->local;
-
-        afr_compute_pre_op_sources (frame, this);
-        pre_op_sources_count = AFR_COUNT (local->transaction.pre_op_sources,
-                                          priv->child_count);
-
-        /* If arbiter is the only source, do not proceed. */
-        if (pre_op_sources_count < 2 &&
-            local->transaction.pre_op_sources[ARBITER_BRICK_INDEX]) {
-                local->op_ret = -1;
-                local->op_errno =  ENOTCONN;
-                for (i = 0; i < priv->child_count; i++)
-                        local->transaction.failed_subvols[i] = 1;
-        }
+afr_txn_arbitrate_fop(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int pre_op_sources_count = 0;
+    int i = 0;
 
-        afr_transaction_fop (frame, this);
+    priv = this->private;
+    local = frame->local;
 
-        return;
+    afr_compute_pre_op_sources(frame, this);
+    pre_op_sources_count = AFR_COUNT(local->transaction.pre_op_sources,
+                                     priv->child_count);
+
+    /* If arbiter is the only source, do not proceed. */
+    if (pre_op_sources_count < 2 &&
+        local->transaction.pre_op_sources[ARBITER_BRICK_INDEX]) {
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        for (i = 0; i < priv->child_count; i++)
+            local->transaction.failed_subvols[i] = 1;
+    }
+
+    afr_transaction_fop(frame, this);
+
+    return;
 }
 
 int
-afr_transaction_perform_fop (call_frame_t *frame, xlator_t *this)
-{
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int           i      = 0;
-        int           ret    = 0;
-        int     failure_count = 0;
-        struct list_head shared;
-        afr_lock_t *lock = NULL;
-
-        local = frame->local;
-        priv = this->private;
-
-        INIT_LIST_HEAD (&shared);
-        if (local->transaction.type == AFR_DATA_TRANSACTION &&
-            !local->transaction.inherited) {
-                ret = afr_write_subvol_set (frame, this);
-                if (ret) {
-                        /*act as if operation failed on all subvols*/
-                        local->op_ret = -1;
-                        local->op_errno = -ret;
-                        for (i = 0; i < priv->child_count; i++)
-                                local->transaction.failed_subvols[i] = 1;
-                }
-        }
-
-	if (local->pre_op_compat)
-		/* old mode, pre-op was done as afr_changelog_do()
-		   just now, before OP */
-		afr_changelog_pre_op_update (frame, this);
-
-        if (!local->transaction.eager_lock_on ||
-            local->transaction.inherited)
-                goto fop;
-        failure_count = AFR_COUNT (local->transaction.failed_subvols,
-                                   priv->child_count);
-        if (failure_count == priv->child_count) {
-                afr_handle_lock_acquire_failure (local, _gf_true);
-                return 0;
-        } else {
-                lock = &local->inode_ctx->lock[local->transaction.type];
-                LOCK (&local->inode->lock);
-                {
-                        lock->acquired = _gf_true;
-                        __afr_transaction_wake_shared (local, &shared);
-                }
-                UNLOCK (&local->inode->lock);
+afr_transaction_perform_fop(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    int ret = 0;
+    int failure_count = 0;
+    struct list_head shared;
+    afr_lock_t *lock = NULL;
+
+    local = frame->local;
+    priv = this->private;
+
+    INIT_LIST_HEAD(&shared);
+    if (local->transaction.type == AFR_DATA_TRANSACTION &&
+        !local->transaction.inherited) {
+        ret = afr_write_subvol_set(frame, this);
+        if (ret) {
+            /*act as if operation failed on all subvols*/
+            local->op_ret = -1;
+            local->op_errno = -ret;
+            for (i = 0; i < priv->child_count; i++)
+                local->transaction.failed_subvols[i] = 1;
+        }
+    }
+
+    if (local->pre_op_compat)
+        /* old mode, pre-op was done as afr_changelog_do()
+           just now, before OP */
+        afr_changelog_pre_op_update(frame, this);
+
+    if (!local->transaction.eager_lock_on || local->transaction.inherited)
+        goto fop;
+    failure_count = AFR_COUNT(local->transaction.failed_subvols,
+                              priv->child_count);
+    if (failure_count == priv->child_count) {
+        afr_handle_lock_acquire_failure(local, _gf_true);
+        return 0;
+    } else {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        LOCK(&local->inode->lock);
+        {
+            lock->acquired = _gf_true;
+            __afr_transaction_wake_shared(local, &shared);
         }
+        UNLOCK(&local->inode->lock);
+    }
 
 fop:
-        /*  Perform fops with the lk-owner from top xlator.
-         *  Eg: lk-owner of posix-lk and flush should be same,
-         *  flush cant clear the  posix-lks without that lk-owner.
-         */
-        afr_save_lk_owner (frame);
-        frame->root->lk_owner =
-                local->transaction.main_frame->root->lk_owner;
+    /*  Perform fops with the lk-owner from top xlator.
+     *  Eg: lk-owner of posix-lk and flush should be same,
+     *  flush cant clear the  posix-lks without that lk-owner.
+     */
+    afr_save_lk_owner(frame);
+    frame->root->lk_owner = local->transaction.main_frame->root->lk_owner;
 
-        if (priv->arbiter_count == 1) {
-                afr_txn_arbitrate_fop (frame, this);
-        } else {
-                afr_transaction_fop (frame, this);
-        }
+    if (priv->arbiter_count == 1) {
+        afr_txn_arbitrate_fop(frame, this);
+    } else {
+        afr_transaction_fop(frame, this);
+    }
 
-        afr_lock_resume_shared (&shared);
-	return 0;
+    afr_lock_resume_shared(&shared);
+    return 0;
 }
 
 int
-afr_set_pending_dict (afr_private_t *priv, dict_t *xattr, int **pending)
+afr_set_pending_dict(afr_private_t *priv, dict_t *xattr, int **pending)
 {
-        int i = 0;
-        int ret = 0;
-
-        for (i = 0; i < priv->child_count; i++) {
+    int i = 0;
+    int ret = 0;
 
-                ret = dict_set_static_bin (xattr, priv->pending_key[i],
-					   pending[i],
-					   AFR_NUM_CHANGE_LOGS * sizeof (int));
-                /* 3 = data+metadata+entry */
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i], pending[i],
+                                  AFR_NUM_CHANGE_LOGS * sizeof(int));
+        /* 3 = data+metadata+entry */
 
-                if (ret)
-                        break;
-        }
+        if (ret)
+            break;
+    }
 
-        return ret;
+    return ret;
 }
 
 /* {{{ pending */
 
 int
-afr_changelog_post_op_done (call_frame_t *frame, xlator_t *this)
+afr_changelog_post_op_done(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-        afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
 
-	local = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        /* Fail the FOP if post-op did not succeed on quorum no. of bricks. */
-        if (!afr_changelog_has_quorum (local, this)) {
-                local->op_ret = -1;
-                /*local->op_errno is already captured in changelog cbk*/
-        }
+    /* Fail the FOP if post-op did not succeed on quorum no. of bricks. */
+    if (!afr_changelog_has_quorum(local, this)) {
+        local->op_ret = -1;
+        /*local->op_errno is already captured in changelog cbk*/
+    }
 
-	if (local->transaction.resume_stub) {
-		call_resume (local->transaction.resume_stub);
-		local->transaction.resume_stub = NULL;
-	}
+    if (local->transaction.resume_stub) {
+        call_resume(local->transaction.resume_stub);
+        local->transaction.resume_stub = NULL;
+    }
 
-        int_lock->lock_cbk = afr_transaction_done;
-        afr_unlock (frame, this);
+    int_lock->lock_cbk = afr_transaction_done;
+    afr_unlock(frame, this);
 
-	return 0;
+    return 0;
 }
 
-
-unsigned char*
-afr_locked_nodes_get (afr_transaction_type type, afr_internal_lock_t *int_lock)
+unsigned char *
+afr_locked_nodes_get(afr_transaction_type type, afr_internal_lock_t *int_lock)
 {
-        unsigned char *locked_nodes = NULL;
-        switch (type) {
+    unsigned char *locked_nodes = NULL;
+    switch (type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
-                locked_nodes = int_lock->locked_nodes;
-        break;
+            locked_nodes = int_lock->locked_nodes;
+            break;
 
         case AFR_ENTRY_TRANSACTION:
         case AFR_ENTRY_RENAME_TRANSACTION:
-                /*Because same set of subvols participate in all lockee
-                 * entities*/
-                locked_nodes = int_lock->lockee[0].locked_nodes;
-        break;
-        }
-        return locked_nodes;
+            /*Because same set of subvols participate in all lockee
+             * entities*/
+            locked_nodes = int_lock->lockee[0].locked_nodes;
+            break;
+    }
+    return locked_nodes;
 }
 
-
 int
-afr_changelog_call_count (afr_transaction_type type,
-			  unsigned char *pre_op_subvols,
-                          unsigned char *failed_subvols,
-			  unsigned int child_count)
+afr_changelog_call_count(afr_transaction_type type,
+                         unsigned char *pre_op_subvols,
+                         unsigned char *failed_subvols,
+                         unsigned int child_count)
 {
-        int i = 0;
-        int call_count = 0;
+    int i = 0;
+    int call_count = 0;
 
-        for (i = 0; i < child_count; i++) {
-                if (pre_op_subvols[i] && !failed_subvols[i]) {
-                        call_count++;
-                }
+    for (i = 0; i < child_count; i++) {
+        if (pre_op_subvols[i] && !failed_subvols[i]) {
+            call_count++;
         }
+    }
 
-        if (type == AFR_ENTRY_RENAME_TRANSACTION)
-                call_count *= 2;
+    if (type == AFR_ENTRY_RENAME_TRANSACTION)
+        call_count *= 2;
 
-        return call_count;
+    return call_count;
 }
 
-
 gf_boolean_t
-afr_txn_nothing_failed (call_frame_t *frame, xlator_t *this)
+afr_txn_nothing_failed(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-        afr_local_t *local = NULL;
-        int i = 0;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
+    int i = 0;
 
-        local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        if (priv->thin_arbiter_count) {
-                /* We need to perform post-op even if 1 data brick was down
-                 * before the txn started.*/
-                if (AFR_COUNT (local->transaction.failed_subvols,
-                               priv->child_count))
-                        return _gf_false;
-        }
+    if (priv->thin_arbiter_count) {
+        /* We need to perform post-op even if 1 data brick was down
+         * before the txn started.*/
+        if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count))
+            return _gf_false;
+    }
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i] &&
-                    local->transaction.failed_subvols[i])
-                        return _gf_false;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i] &&
+            local->transaction.failed_subvols[i])
+            return _gf_false;
+    }
 
-        return _gf_true;
+    return _gf_true;
 }
 
 void
-afr_handle_symmetric_errors (call_frame_t *frame, xlator_t *this)
+afr_handle_symmetric_errors(call_frame_t *frame, xlator_t *this)
 {
-	if (afr_is_symmetric_error (frame, this))
-		__mark_all_success (frame, this);
+    if (afr_is_symmetric_error(frame, this))
+        __mark_all_success(frame, this);
 }
 
 gf_boolean_t
-afr_has_quorum (unsigned char *subvols, xlator_t *this)
-{
-        unsigned int  quorum_count = 0;
-        afr_private_t *priv  = NULL;
-        unsigned int  up_children_count = 0;
-
-        priv = this->private;
-        up_children_count = AFR_COUNT (subvols, priv->child_count);
-
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                /*
-                 * Special case for auto-quorum with an even number of nodes.
-                 *
-                 * A replica set with even count N can only handle the same
-                 * number of failures as odd N-1 before losing "vanilla"
-                 * quorum, and the probability of more simultaneous failures is
-                 * actually higher.  For example, with a 1% chance of failure
-                 * we'd have a 0.03% chance of two simultaneous failures with
-                 * N=3 but a 0.06% chance with N=4.  However, the special case
-                 * is necessary for N=2 because there's no real quorum in that
-                 * case (i.e. can't normally survive *any* failures).  In that
-                 * case, we treat the first node as a tie-breaker, allowing
-                 * quorum to be retained in some cases while still honoring the
-                 * all-important constraint that there can not simultaneously
-                 * be two partitioned sets of nodes each believing they have
-                 * quorum.  Of two equally sized sets, the one without that
-                 * first node will lose.
-                 *
-                 * It turns out that the special case is beneficial for higher
-                 * values of N as well.  Continuing the example above, the
-                 * probability of losing quorum with N=4 and this type of
-                 * quorum is (very) slightly lower than with N=3 and vanilla
-                 * quorum.  The difference becomes even more pronounced with
-                 * higher N.  Therefore, even though such replica counts are
-                 * unlikely to be seen in practice, we might as well use the
-                 * "special" quorum then as well.
-                 */
-                if ((up_children_count * 2) == priv->child_count) {
-                        return subvols[0];
-                }
-        }
+afr_has_quorum(unsigned char *subvols, xlator_t *this)
+{
+    unsigned int quorum_count = 0;
+    afr_private_t *priv = NULL;
+    unsigned int up_children_count = 0;
 
-        if (priv->quorum_count == AFR_QUORUM_AUTO) {
-                quorum_count = priv->child_count/2 + 1;
-        } else {
-                quorum_count = priv->quorum_count;
+    priv = this->private;
+    up_children_count = AFR_COUNT(subvols, priv->child_count);
+
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        /*
+         * Special case for auto-quorum with an even number of nodes.
+         *
+         * A replica set with even count N can only handle the same
+         * number of failures as odd N-1 before losing "vanilla"
+         * quorum, and the probability of more simultaneous failures is
+         * actually higher.  For example, with a 1% chance of failure
+         * we'd have a 0.03% chance of two simultaneous failures with
+         * N=3 but a 0.06% chance with N=4.  However, the special case
+         * is necessary for N=2 because there's no real quorum in that
+         * case (i.e. can't normally survive *any* failures).  In that
+         * case, we treat the first node as a tie-breaker, allowing
+         * quorum to be retained in some cases while still honoring the
+         * all-important constraint that there can not simultaneously
+         * be two partitioned sets of nodes each believing they have
+         * quorum.  Of two equally sized sets, the one without that
+         * first node will lose.
+         *
+         * It turns out that the special case is beneficial for higher
+         * values of N as well.  Continuing the example above, the
+         * probability of losing quorum with N=4 and this type of
+         * quorum is (very) slightly lower than with N=3 and vanilla
+         * quorum.  The difference becomes even more pronounced with
+         * higher N.  Therefore, even though such replica counts are
+         * unlikely to be seen in practice, we might as well use the
+         * "special" quorum then as well.
+         */
+        if ((up_children_count * 2) == priv->child_count) {
+            return subvols[0];
         }
+    }
 
-        if (up_children_count >= quorum_count)
-                return _gf_true;
+    if (priv->quorum_count == AFR_QUORUM_AUTO) {
+        quorum_count = priv->child_count / 2 + 1;
+    } else {
+        quorum_count = priv->quorum_count;
+    }
 
-        return _gf_false;
+    if (up_children_count >= quorum_count)
+        return _gf_true;
+
+    return _gf_false;
 }
 
 static gf_boolean_t
-afr_has_fop_quorum (call_frame_t *frame)
+afr_has_fop_quorum(call_frame_t *frame)
 {
-        xlator_t        *this = frame->this;
-        afr_local_t     *local = frame->local;
-        unsigned char *locked_nodes = NULL;
+    xlator_t *this = frame->this;
+    afr_local_t *local = frame->local;
+    unsigned char *locked_nodes = NULL;
 
-        locked_nodes = afr_locked_nodes_get (local->transaction.type,
-                                             &local->internal_lock);
-        return afr_has_quorum (locked_nodes, this);
+    locked_nodes = afr_locked_nodes_get(local->transaction.type,
+                                        &local->internal_lock);
+    return afr_has_quorum(locked_nodes, this);
 }
 
 static gf_boolean_t
-afr_has_fop_cbk_quorum (call_frame_t *frame)
+afr_has_fop_cbk_quorum(call_frame_t *frame)
 {
-        afr_local_t   *local   = frame->local;
-        xlator_t      *this    = frame->this;
-        afr_private_t *priv    = this->private;
-        unsigned char *success = alloca0(priv->child_count);
-        int           i        = 0;
+    afr_local_t *local = frame->local;
+    xlator_t *this = frame->this;
+    afr_private_t *priv = this->private;
+    unsigned char *success = alloca0(priv->child_count);
+    int i = 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i])
-                        if (!local->transaction.failed_subvols[i])
-                                success[i] = 1;
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i])
+            if (!local->transaction.failed_subvols[i])
+                success[i] = 1;
+    }
 
-        return afr_has_quorum (success, this);
+    return afr_has_quorum(success, this);
 }
 
 gf_boolean_t
-afr_need_dirty_marking (call_frame_t *frame, xlator_t *this)
+afr_need_dirty_marking(call_frame_t *frame, xlator_t *this)
 {
-        afr_private_t           *priv           = this->private;
-        afr_local_t             *local          = NULL;
-        gf_boolean_t            need_dirty      = _gf_false;
+    afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    gf_boolean_t need_dirty = _gf_false;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!priv->quorum_count || !local->optimistic_change_log)
-                return _gf_false;
+    if (!priv->quorum_count || !local->optimistic_change_log)
+        return _gf_false;
 
-        if (local->transaction.type == AFR_DATA_TRANSACTION ||
-            local->transaction.type == AFR_METADATA_TRANSACTION)
-                return _gf_false;
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION)
+        return _gf_false;
 
-        if (AFR_COUNT (local->transaction.failed_subvols, priv->child_count) ==
-            priv->child_count)
-                return _gf_false;
+    if (AFR_COUNT(local->transaction.failed_subvols, priv->child_count) ==
+        priv->child_count)
+        return _gf_false;
 
-        if (priv->arbiter_count) {
-                if (!afr_has_arbiter_fop_cbk_quorum (frame))
-                        need_dirty = _gf_true;
-        } else if (!afr_has_fop_cbk_quorum (frame)) {
-                need_dirty = _gf_true;
-        }
+    if (priv->arbiter_count) {
+        if (!afr_has_arbiter_fop_cbk_quorum(frame))
+            need_dirty = _gf_true;
+    } else if (!afr_has_fop_cbk_quorum(frame)) {
+        need_dirty = _gf_true;
+    }
 
-        return need_dirty;
+    return need_dirty;
 }
 
 void
-afr_handle_quorum (call_frame_t *frame, xlator_t *this)
+afr_handle_quorum(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t   *local = NULL;
-        afr_private_t *priv  = NULL;
-        int           i      = 0;
-        const char    *file  = NULL;
-        uuid_t        gfid   = {0};
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    const char *file = NULL;
+    uuid_t gfid = {0};
 
-        local = frame->local;
-        priv  = frame->this->private;
+    local = frame->local;
+    priv = frame->this->private;
 
-        if (priv->quorum_count == 0)
-                return;
-
-        /* If the fop already failed return right away to preserve errno */
-        if (local->op_ret == -1)
-                return;
+    if (priv->quorum_count == 0)
+        return;
 
-        /*
-         * Network split may happen just after the fops are unwound, so check
-         * if the fop succeeded in a way it still follows quorum. If it doesn't,
-         * mark the fop as failure, mark the changelogs so it reflects that
-         * failure.
-         *
-         * Scenario:
-         * There are 3 mounts on 3 machines(node1, node2, node3) all writing to
-         * single file. Network split happened in a way that node1 can't see
-         * node2, node3. Node2, node3 both of them can't see node1. Now at the
-         * time of sending write all the bricks are up. Just after write fop is
-         * wound on node1, network split happens. Node1 thinks write fop failed
-         * on node2, node3 so marks pending changelog for those 2 extended
-         * attributes on node1. Node2, node3 thinks writes failed on node1 so
-         * they mark pending changelog for node1. When the network is stable
-         * again the file already is in split-brain. These checks prevent
-         * marking pending changelog on other subvolumes if the fop doesn't
-         * succeed in a way it is still following quorum. So with this fix what
-         * is happening is, node1 will have all pending changelog(FOOL) because
-         * the write succeeded only on node1 but failed on node2, node3 so
-         * instead of marking pending changelogs on node2, node3 it just treats
-         * the fop as failure and goes into DIRTY state. Where as node2, node3
-         * say they are sources and have pending changelog to node1 so there is
-         * no split-brain with the fix. The problem is eliminated completely.
-         */
+    /* If the fop already failed return right away to preserve errno */
+    if (local->op_ret == -1)
+        return;
 
-        if (priv->arbiter_count) {
-                if (afr_has_arbiter_fop_cbk_quorum (frame))
-                        return;
-        } else if (afr_has_fop_cbk_quorum (frame)) {
-                return;
-        }
+    /*
+     * Network split may happen just after the fops are unwound, so check
+     * if the fop succeeded in a way it still follows quorum. If it doesn't,
+     * mark the fop as failure, mark the changelogs so it reflects that
+     * failure.
+     *
+     * Scenario:
+     * There are 3 mounts on 3 machines(node1, node2, node3) all writing to
+     * single file. Network split happened in a way that node1 can't see
+     * node2, node3. Node2, node3 both of them can't see node1. Now at the
+     * time of sending write all the bricks are up. Just after write fop is
+     * wound on node1, network split happens. Node1 thinks write fop failed
+     * on node2, node3 so marks pending changelog for those 2 extended
+     * attributes on node1. Node2, node3 thinks writes failed on node1 so
+     * they mark pending changelog for node1. When the network is stable
+     * again the file already is in split-brain. These checks prevent
+     * marking pending changelog on other subvolumes if the fop doesn't
+     * succeed in a way it is still following quorum. So with this fix what
+     * is happening is, node1 will have all pending changelog(FOOL) because
+     * the write succeeded only on node1 but failed on node2, node3 so
+     * instead of marking pending changelogs on node2, node3 it just treats
+     * the fop as failure and goes into DIRTY state. Where as node2, node3
+     * say they are sources and have pending changelog to node1 so there is
+     * no split-brain with the fix. The problem is eliminated completely.
+     */
+
+    if (priv->arbiter_count) {
+        if (afr_has_arbiter_fop_cbk_quorum(frame))
+            return;
+    } else if (afr_has_fop_cbk_quorum(frame)) {
+        return;
+    }
 
-        if (afr_need_dirty_marking (frame, this))
-                goto set_response;
+    if (afr_need_dirty_marking(frame, this))
+        goto set_response;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.pre_op[i])
-                        afr_transaction_fop_failed (frame, frame->this, i);
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.pre_op[i])
+            afr_transaction_fop_failed(frame, frame->this, i);
+    }
 
 set_response:
-        local->op_ret = -1;
-        local->op_errno = afr_final_errno (local, priv);
-        if (local->op_errno == 0)
-                local->op_errno = afr_quorum_errno (priv);
-
-        if (local->fd) {
-                gf_uuid_copy (gfid, local->fd->inode->gfid);
-                file = uuid_utoa (gfid);
-        } else {
-                loc_path (&local->loc, local->loc.name);
-                file = local->loc.path;
-        }
-
-        gf_msg (frame->this->name, GF_LOG_WARNING, local->op_errno,
-                AFR_MSG_QUORUM_FAIL, "%s: Failing %s as quorum is not met",
-                file, gf_fop_list[local->op]);
-
-        switch (local->transaction.type) {
+    local->op_ret = -1;
+    local->op_errno = afr_final_errno(local, priv);
+    if (local->op_errno == 0)
+        local->op_errno = afr_quorum_errno(priv);
+
+    if (local->fd) {
+        gf_uuid_copy(gfid, local->fd->inode->gfid);
+        file = uuid_utoa(gfid);
+    } else {
+        loc_path(&local->loc, local->loc.name);
+        file = local->loc.path;
+    }
+
+    gf_msg(frame->this->name, GF_LOG_WARNING, local->op_errno,
+           AFR_MSG_QUORUM_FAIL, "%s: Failing %s as quorum is not met", file,
+           gf_fop_list[local->op]);
+
+    switch (local->transaction.type) {
         case AFR_ENTRY_TRANSACTION:
         case AFR_ENTRY_RENAME_TRANSACTION:
-                afr_pick_error_xdata (local, priv, local->parent,
-                                      local->readable, local->parent2,
-                                      local->readable2);
-                break;
+            afr_pick_error_xdata(local, priv, local->parent, local->readable,
+                                 local->parent2, local->readable2);
+            break;
         default:
-                afr_pick_error_xdata (local, priv, local->inode,
-                                      local->readable, NULL, NULL);
-                break;
-        }
+            afr_pick_error_xdata(local, priv, local->inode, local->readable,
+                                 NULL, NULL);
+            break;
+    }
 }
 
 int
-afr_fill_ta_loc (xlator_t *this, loc_t *loc)
-{
-        afr_private_t *priv = NULL;
-
-        priv = this->private;
-        loc->parent = inode_ref (priv->root_inode);
-        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
-        loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
-        gf_uuid_copy (loc->gfid, priv->ta_gfid);
-        loc->inode = inode_new (loc->parent->table);
-        if (!loc->inode) {
-                loc_wipe(loc);
-                return -ENOMEM;
-        }
-        return 0;
+afr_fill_ta_loc(xlator_t *this, loc_t *loc)
+{
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    loc->parent = inode_ref(priv->root_inode);
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+    loc->name = priv->pending_key[THIN_ARBITER_BRICK_INDEX];
+    gf_uuid_copy(loc->gfid, priv->ta_gfid);
+    loc->inode = inode_new(loc->parent->table);
+    if (!loc->inode) {
+        loc_wipe(loc);
+        return -ENOMEM;
+    }
+    return 0;
 }
 
 int
-afr_changelog_thin_arbiter_post_op (xlator_t *this, afr_local_t *local)
-{
-        int ret = 0;
-        afr_private_t *priv = NULL;
-        dict_t *xattr = NULL;
-        int failed_count = 0;
-        struct gf_flock flock = {0, };
-        loc_t loc = {0,};
-        int i = 0;
+afr_changelog_thin_arbiter_post_op(xlator_t *this, afr_local_t *local)
+{
+    int ret = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xattr = NULL;
+    int failed_count = 0;
+    struct gf_flock flock = {
+        0,
+    };
+    loc_t loc = {
+        0,
+    };
+    int i = 0;
+
+    priv = this->private;
+    if (!priv->thin_arbiter_count)
+        return 0;
 
-        priv = this->private;
-        if (!priv->thin_arbiter_count)
-                return 0;
+    failed_count = AFR_COUNT(local->transaction.failed_subvols,
+                             priv->child_count);
+    if (!failed_count)
+        return 0;
 
+    GF_ASSERT(failed_count == 1);
+    ret = afr_fill_ta_loc(this, &loc);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Failed to populate thin-arbiter loc for: %s.", loc.name);
+        goto out;
+    }
+
+    xattr = dict_new();
+    if (!xattr) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    for (i = 0; i < priv->child_count; i++) {
+        ret = dict_set_static_bin(xattr, priv->pending_key[i],
+                                  local->pending[i],
+                                  AFR_NUM_CHANGE_LOGS * sizeof(int));
+        if (ret)
+            goto out;
+    }
+
+    flock.l_type = F_WRLCK;
+    flock.l_start = 0;
+    flock.l_len = 0;
+
+    /*TODO: Convert to two domain locking. */
+    ret = syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX],
+                         AFR_TA_DOM_NOTIFY, &loc, F_SETLKW, &flock, NULL, NULL);
+    if (ret)
+        goto out;
+
+    ret = syncop_xattrop(priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
+                         GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
+
+    if (ret == -EINVAL) {
+        gf_msg(this->name, GF_LOG_INFO, -ret, AFR_MSG_THIN_ARB,
+               "Thin-arbiter has denied post-op on %s for gfid %s.",
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX],
+               uuid_utoa(local->inode->gfid));
+
+    } else if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
+               "Post-op on thin-arbiter id file %s failed for gfid %s.",
+               priv->pending_key[THIN_ARBITER_BRICK_INDEX],
+               uuid_utoa(local->inode->gfid));
+    }
+    flock.l_type = F_UNLCK;
+    syncop_inodelk(priv->children[THIN_ARBITER_BRICK_INDEX], AFR_TA_DOM_NOTIFY,
+                   &loc, F_SETLK, &flock, NULL, NULL);
+out:
+    if (xattr)
+        dict_unref(xattr);
 
-        failed_count = AFR_COUNT (local->transaction.failed_subvols,
-                                  priv->child_count);
-        if (!failed_count)
-                return 0;
+    return ret;
+}
 
-        GF_ASSERT (failed_count == 1);
-        ret = afr_fill_ta_loc (this, &loc);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Failed to populate thin-arbiter loc for: %s.",
-                        loc.name);
-                goto out;
-        }
+int
+afr_changelog_post_op_now(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    afr_local_t *local = NULL;
+    dict_t *xattr = NULL;
+    int i = 0;
+    int ret = 0;
+    int idx = 0;
+    int nothing_failed = 1;
+    gf_boolean_t need_undirty = _gf_false;
+
+    afr_handle_quorum(frame, this);
+    local = frame->local;
+    idx = afr_index_for_transaction_type(local->transaction.type);
+
+    xattr = dict_new();
+    if (!xattr) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
 
-        xattr = dict_new ();
-        if (!xattr) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        for (i = 0; i < priv->child_count; i++) {
-                ret = dict_set_static_bin (xattr, priv->pending_key[i],
-                                           local->pending[i],
-                                           AFR_NUM_CHANGE_LOGS * sizeof (int));
-                if (ret)
-                        goto out;
+    nothing_failed = afr_txn_nothing_failed(frame, this);
+
+    if (afr_changelog_pre_op_uninherit(frame, this))
+        need_undirty = _gf_false;
+    else
+        need_undirty = _gf_true;
+
+    if (local->op_ret < 0 && !nothing_failed) {
+        if (afr_need_dirty_marking(frame, this)) {
+            local->dirty[idx] = hton32(1);
+            goto set_dirty;
         }
 
-        flock.l_type = F_WRLCK;
-        flock.l_start = 0;
-        flock.l_len = 0;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
 
-        /*TODO: Convert to two domain locking. */
-        ret = syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                              AFR_TA_DOM_NOTIFY, &loc, F_SETLKW, &flock,
-                              NULL, NULL);
-        if (ret)
-                goto out;
+    if (nothing_failed && !need_undirty) {
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
+
+    if (local->transaction.in_flight_sb) {
+        local->op_ret = -1;
+        local->op_errno = local->transaction.in_flight_sb_errno;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.failed_subvols[i])
+            local->pending[i][idx] = hton32(1);
+    }
+
+    ret = afr_set_pending_dict(priv, xattr, local->pending);
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
 
-        ret = syncop_xattrop (priv->children[THIN_ARBITER_BRICK_INDEX], &loc,
-                              GF_XATTROP_ADD_ARRAY, xattr, NULL, NULL, NULL);
+    ret = afr_changelog_thin_arbiter_post_op(this, local);
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = -ret;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
 
-        if (ret == -EINVAL) {
-                gf_msg (this->name, GF_LOG_INFO, -ret, AFR_MSG_THIN_ARB,
-                        "Thin-arbiter has denied post-op on %s for gfid %s.",
-                        priv->pending_key[THIN_ARBITER_BRICK_INDEX],
-                        uuid_utoa (local->inode->gfid));
+    if (need_undirty)
+        local->dirty[idx] = hton32(-1);
+    else
+        local->dirty[idx] = hton32(0);
 
-        } else if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, AFR_MSG_THIN_ARB,
-                        "Post-op on thin-arbiter id file %s failed for gfid %s.",
-                        priv->pending_key[THIN_ARBITER_BRICK_INDEX],
-                        uuid_utoa (local->inode->gfid));
-        }
-        flock.l_type = F_UNLCK;
-        syncop_inodelk (priv->children[THIN_ARBITER_BRICK_INDEX],
-                        AFR_TA_DOM_NOTIFY, &loc, F_SETLK, &flock, NULL, NULL);
+set_dirty:
+    ret = dict_set_static_bin(xattr, AFR_DIRTY, local->dirty,
+                              sizeof(int) * AFR_NUM_CHANGE_LOGS);
+    if (ret) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        afr_changelog_post_op_done(frame, this);
+        goto out;
+    }
+
+    afr_changelog_do(frame, this, xattr, afr_changelog_post_op_done,
+                     AFR_TRANSACTION_POST_OP);
 out:
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return 0;
 }
 
-int
-afr_changelog_post_op_now (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t           *priv           = this->private;
-        afr_local_t             *local          = NULL;
-        dict_t                  *xattr          = NULL;
-        int                     i               = 0;
-        int                     ret             = 0;
-        int                     idx             = 0;
-        int                     nothing_failed  = 1;
-        gf_boolean_t            need_undirty    = _gf_false;
-
-        afr_handle_quorum (frame, this);
-        local = frame->local;
-        idx = afr_index_for_transaction_type (local->transaction.type);
-
-        xattr = dict_new ();
-        if (!xattr) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                afr_changelog_post_op_done (frame, this);
-                goto out;
-        }
+gf_boolean_t
+afr_changelog_pre_op_uninherit(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_inode_ctx_t *ctx = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-        nothing_failed = afr_txn_nothing_failed (frame, this);
+    local = frame->local;
+    priv = this->private;
+    ctx = local->inode_ctx;
 
-	if (afr_changelog_pre_op_uninherit (frame, this))
-		need_undirty = _gf_false;
-	else
-		need_undirty = _gf_true;
+    type = afr_index_for_transaction_type(local->transaction.type);
+    if (type != AFR_DATA_TRANSACTION)
+        return !local->transaction.dirtied;
 
-        if (local->op_ret < 0 && !nothing_failed) {
-                if (afr_need_dirty_marking (frame, this)) {
-                        local->dirty[idx] = hton32(1);
-                        goto set_dirty;
-                }
+    if (local->transaction.no_uninherit)
+        return _gf_false;
 
-                afr_changelog_post_op_done (frame, this);
-                goto out;
-        }
+    /* This function must be idempotent. So check if we
+       were called before and return the same answer again.
 
-	if (nothing_failed && !need_undirty) {
-		afr_changelog_post_op_done (frame, this);
-                goto out;
-	}
+       It is important to keep this function idempotent for
+       the call in afr_changelog_post_op_safe() to not have
+       side effects on the call from afr_changelog_post_op_now()
+    */
+    if (local->transaction.uninherit_done)
+        return local->transaction.uninherit_value;
 
-        if (local->transaction.in_flight_sb) {
-                local->op_ret = -1;
-                local->op_errno = local->transaction.in_flight_sb_errno;
-                afr_changelog_post_op_done (frame, this);
-                goto out;
+    LOCK(&local->inode->lock);
+    {
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->transaction.pre_op[i] != ctx->pre_op_done[type][i]) {
+                ret = !local->transaction.dirtied;
+                goto unlock;
+            }
+        }
+
+        if (ctx->inherited[type]) {
+            ret = _gf_true;
+            ctx->inherited[type]--;
+        } else if (ctx->on_disk[type]) {
+            ret = _gf_false;
+            ctx->on_disk[type]--;
+        } else {
+            /* ASSERT */
+            ret = _gf_false;
         }
 
-	for (i = 0; i < priv->child_count; i++) {
-		if (local->transaction.failed_subvols[i])
-			local->pending[i][idx] = hton32(1);
-	}
-
-	ret = afr_set_pending_dict (priv, xattr, local->pending);
-	if (ret < 0) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-        ret = afr_changelog_thin_arbiter_post_op (this, local);
-        if (ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = -ret;
-		afr_changelog_post_op_done (frame, this);
-                goto out;
+        if (!ctx->inherited[type] && !ctx->on_disk[type]) {
+            for (i = 0; i < priv->child_count; i++)
+                ctx->pre_op_done[type][i] = 0;
         }
-
-        if (need_undirty)
-		local->dirty[idx] = hton32(-1);
-	else
-		local->dirty[idx] = hton32(0);
-
-set_dirty:
-	ret = dict_set_static_bin (xattr, AFR_DIRTY, local->dirty,
-				   sizeof(int) * AFR_NUM_CHANGE_LOGS);
-	if (ret) {
-		local->op_ret = -1;
-		local->op_errno = ENOMEM;
-		afr_changelog_post_op_done (frame, this);
-		goto out;
-	}
-
-        afr_changelog_do (frame, this, xattr, afr_changelog_post_op_done,
-                          AFR_TRANSACTION_POST_OP);
-out:
-	if (xattr)
-                dict_unref (xattr);
-
-        return 0;
-}
-
-
-gf_boolean_t
-afr_changelog_pre_op_uninherit (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        afr_inode_ctx_t *ctx = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	int type = 0;
-
-	local = frame->local;
-	priv = this->private;
-        ctx = local->inode_ctx;
-
-	type = afr_index_for_transaction_type (local->transaction.type);
-	if (type != AFR_DATA_TRANSACTION)
-		return !local->transaction.dirtied;
-
-	if (local->transaction.no_uninherit)
-		return _gf_false;
-
-	/* This function must be idempotent. So check if we
-	   were called before and return the same answer again.
-
-	   It is important to keep this function idempotent for
-	   the call in afr_changelog_post_op_safe() to not have
-	   side effects on the call from afr_changelog_post_op_now()
-	*/
-	if (local->transaction.uninherit_done)
-		return local->transaction.uninherit_value;
-
-	LOCK(&local->inode->lock);
-	{
-		for (i = 0; i < priv->child_count; i++) {
-			if (local->transaction.pre_op[i] !=
-			    ctx->pre_op_done[type][i]) {
-				ret = !local->transaction.dirtied;
-				goto unlock;
-			}
-		}
-
-		if (ctx->inherited[type]) {
-			ret = _gf_true;
-			ctx->inherited[type]--;
-		} else if (ctx->on_disk[type]) {
-			ret = _gf_false;
-			ctx->on_disk[type]--;
-		} else {
-			/* ASSERT */
-			ret = _gf_false;
-		}
-
-		if (!ctx->inherited[type] && !ctx->on_disk[type]) {
-			for (i = 0; i < priv->child_count; i++)
-				ctx->pre_op_done[type][i] = 0;
-		}
-	}
+    }
 unlock:
-	UNLOCK(&local->inode->lock);
+    UNLOCK(&local->inode->lock);
 
-	local->transaction.uninherit_done = _gf_true;
-	local->transaction.uninherit_value = ret;
+    local->transaction.uninherit_done = _gf_true;
+    local->transaction.uninherit_value = ret;
 
-	return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-afr_changelog_pre_op_inherit (call_frame_t *frame, xlator_t *this)
+afr_changelog_pre_op_inherit(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	int type = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-	if (local->transaction.type != AFR_DATA_TRANSACTION)
-		return _gf_false;
+    if (local->transaction.type != AFR_DATA_TRANSACTION)
+        return _gf_false;
 
-	type = afr_index_for_transaction_type (local->transaction.type);
+    type = afr_index_for_transaction_type(local->transaction.type);
 
-	LOCK(&local->inode->lock);
-	{
-		if (!local->inode_ctx->on_disk[type]) {
-			/* nothing to inherit yet */
-			ret = _gf_false;
-			goto unlock;
-		}
+    LOCK(&local->inode->lock);
+    {
+        if (!local->inode_ctx->on_disk[type]) {
+            /* nothing to inherit yet */
+            ret = _gf_false;
+            goto unlock;
+        }
 
-		for (i = 0; i < priv->child_count; i++) {
-			if (local->transaction.pre_op[i] !=
-			    local->inode_ctx->pre_op_done[type][i]) {
-				/* either inherit exactly, or don't */
-				ret = _gf_false;
-				goto unlock;
-			}
-		}
+        for (i = 0; i < priv->child_count; i++) {
+            if (local->transaction.pre_op[i] !=
+                local->inode_ctx->pre_op_done[type][i]) {
+                /* either inherit exactly, or don't */
+                ret = _gf_false;
+                goto unlock;
+            }
+        }
 
-		local->inode_ctx->inherited[type]++;
+        local->inode_ctx->inherited[type]++;
 
-		ret = _gf_true;
+        ret = _gf_true;
 
-		local->transaction.inherited = _gf_true;
-	}
+        local->transaction.inherited = _gf_true;
+    }
 unlock:
-	UNLOCK(&local->inode->lock);
+    UNLOCK(&local->inode->lock);
 
-	return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-afr_changelog_pre_op_update (call_frame_t *frame, xlator_t *this)
-{
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-	int i = 0;
-	gf_boolean_t ret = _gf_false;
-	int type = 0;
-
-	local = frame->local;
-	priv = this->private;
-
-        if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
-            local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION)
-                return _gf_false;
-
-	if (local->transaction.inherited)
-		/* was already inherited in afr_changelog_pre_op */
-		return _gf_false;
-
-	if (!local->transaction.dirtied)
-		return _gf_false;
-
-        if (!afr_txn_nothing_failed (frame, this))
-		return _gf_false;
-
-	type = afr_index_for_transaction_type (local->transaction.type);
-
-	ret = _gf_false;
-
-	LOCK(&local->inode->lock);
-	{
-		if (!local->inode_ctx->on_disk[type]) {
-			for (i = 0; i < priv->child_count; i++)
-				local->inode_ctx->pre_op_done[type][i] =
-                                        (!local->transaction.failed_subvols[i]);
-		} else {
-			for (i = 0; i < priv->child_count; i++)
-				if (local->inode_ctx->pre_op_done[type][i] !=
-				    (!local->transaction.failed_subvols[i])) {
-					local->transaction.no_uninherit = 1;
-					goto unlock;
-				}
-		}
-		local->inode_ctx->on_disk[type]++;
-
-		ret = _gf_true;
-	}
-unlock:
-	UNLOCK(&local->inode->lock);
+afr_changelog_pre_op_update(call_frame_t *frame, xlator_t *this)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
+    int type = 0;
 
-	return ret;
-}
+    local = frame->local;
+    priv = this->private;
 
+    if (local->transaction.type == AFR_ENTRY_TRANSACTION ||
+        local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION)
+        return _gf_false;
 
-int
-afr_changelog_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
-{
-        afr_local_t *local = NULL;
-        int call_count = -1;
-        int child_index = -1;
+    if (local->transaction.inherited)
+        /* was already inherited in afr_changelog_pre_op */
+        return _gf_false;
 
-        local = frame->local;
-        child_index = (long) cookie;
+    if (!local->transaction.dirtied)
+        return _gf_false;
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                afr_transaction_fop_failed (frame, this, child_index);
-        }
+    if (!afr_txn_nothing_failed(frame, this))
+        return _gf_false;
 
-        if (xattr)
-                local->transaction.changelog_xdata[child_index] = dict_ref (xattr);
+    type = afr_index_for_transaction_type(local->transaction.type);
 
-        call_count = afr_frame_return (frame);
+    ret = _gf_false;
 
-        if (call_count == 0) {
-                local->transaction.changelog_resume (frame, this);
+    LOCK(&local->inode->lock);
+    {
+        if (!local->inode_ctx->on_disk[type]) {
+            for (i = 0; i < priv->child_count; i++)
+                local->inode_ctx->pre_op_done[type][i] =
+                    (!local->transaction.failed_subvols[i]);
+        } else {
+            for (i = 0; i < priv->child_count; i++)
+                if (local->inode_ctx->pre_op_done[type][i] !=
+                    (!local->transaction.failed_subvols[i])) {
+                    local->transaction.no_uninherit = 1;
+                    goto unlock;
+                }
         }
+        local->inode_ctx->on_disk[type]++;
 
-        return 0;
+        ret = _gf_true;
+    }
+unlock:
+    UNLOCK(&local->inode->lock);
+
+    return ret;
 }
 
-void
-afr_changelog_populate_xdata (call_frame_t *frame, afr_xattrop_type_t op,
-                              dict_t **xdata, dict_t **newloc_xdata)
-{
-        int              i                    = 0;
-        int              ret                  = 0;
-        char            *key                  = NULL;
-        const char      *name                 = NULL;
-        dict_t          *xdata1               = NULL;
-        dict_t          *xdata2               = NULL;
-        xlator_t        *this                 = NULL;
-        afr_local_t     *local                = NULL;
-        afr_private_t   *priv                 = NULL;
-        gf_boolean_t     need_entry_key_set   = _gf_true;
-
-        local = frame->local;
-        this = THIS;
-        priv = this->private;
-
-        if (local->transaction.type == AFR_DATA_TRANSACTION ||
-            local->transaction.type == AFR_METADATA_TRANSACTION)
-                goto out;
+int
+afr_changelog_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, dict_t *xattr, dict_t *xdata)
+{
+    afr_local_t *local = NULL;
+    int call_count = -1;
+    int child_index = -1;
 
-        if (!priv->esh_granular)
-                goto out;
+    local = frame->local;
+    child_index = (long)cookie;
 
-        xdata1 = dict_new();
-        if (!xdata1)
-                goto out;
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
+
+    if (xattr)
+        local->transaction.changelog_xdata[child_index] = dict_ref(xattr);
 
-        name = local->loc.name;
-        if (local->op == GF_FOP_LINK)
-                name = local->newloc.name;
+    call_count = afr_frame_return(frame);
 
-        switch (op) {
+    if (call_count == 0) {
+        local->transaction.changelog_resume(frame, this);
+    }
+
+    return 0;
+}
+
+void
+afr_changelog_populate_xdata(call_frame_t *frame, afr_xattrop_type_t op,
+                             dict_t **xdata, dict_t **newloc_xdata)
+{
+    int i = 0;
+    int ret = 0;
+    char *key = NULL;
+    const char *name = NULL;
+    dict_t *xdata1 = NULL;
+    dict_t *xdata2 = NULL;
+    xlator_t *this = NULL;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t need_entry_key_set = _gf_true;
+
+    local = frame->local;
+    this = THIS;
+    priv = this->private;
+
+    if (local->transaction.type == AFR_DATA_TRANSACTION ||
+        local->transaction.type == AFR_METADATA_TRANSACTION)
+        goto out;
+
+    if (!priv->esh_granular)
+        goto out;
+
+    xdata1 = dict_new();
+    if (!xdata1)
+        goto out;
+
+    name = local->loc.name;
+    if (local->op == GF_FOP_LINK)
+        name = local->newloc.name;
+
+    switch (op) {
         case AFR_TRANSACTION_PRE_OP:
-                key = GF_XATTROP_ENTRY_IN_KEY;
-                break;
+            key = GF_XATTROP_ENTRY_IN_KEY;
+            break;
         case AFR_TRANSACTION_POST_OP:
-                if (afr_txn_nothing_failed (frame, this)) {
-                        key = GF_XATTROP_ENTRY_OUT_KEY;
-                        for (i = 0; i < priv->child_count; i++) {
-                                if (!local->transaction.failed_subvols[i])
-                                        continue;
-                                need_entry_key_set = _gf_false;
-                                break;
-                        }
-                        /* If the transaction itself did not fail and there
-                         * are no failed subvolumes, check whether the fop
-                         * failed due to a symmetric error. If it did, do
-                         * not set the ENTRY_OUT xattr which would end up
-                         * deleting a name index which was created possibly by
-                         * an earlier entry txn that may have failed on some
-                         * of the sub-volumes.
-                         */
-                        if (local->op_ret)
-                                need_entry_key_set = _gf_false;
-                } else {
-                        key = GF_XATTROP_ENTRY_IN_KEY;
+            if (afr_txn_nothing_failed(frame, this)) {
+                key = GF_XATTROP_ENTRY_OUT_KEY;
+                for (i = 0; i < priv->child_count; i++) {
+                    if (!local->transaction.failed_subvols[i])
+                        continue;
+                    need_entry_key_set = _gf_false;
+                    break;
                 }
-                break;
-        }
+                /* If the transaction itself did not fail and there
+                 * are no failed subvolumes, check whether the fop
+                 * failed due to a symmetric error. If it did, do
+                 * not set the ENTRY_OUT xattr which would end up
+                 * deleting a name index which was created possibly by
+                 * an earlier entry txn that may have failed on some
+                 * of the sub-volumes.
+                 */
+                if (local->op_ret)
+                    need_entry_key_set = _gf_false;
+            } else {
+                key = GF_XATTROP_ENTRY_IN_KEY;
+            }
+            break;
+    }
 
-        if (need_entry_key_set) {
-                ret = dict_set_str (xdata1, key, (char *)name);
-                if (ret)
-                        gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_DICT_SET_FAILED,
-                                "%s/%s: Could not set %s key during xattrop",
-                                uuid_utoa (local->loc.pargfid), local->loc.name,
-                                key);
-                if (local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
-                        xdata2 = dict_new ();
-                        if (!xdata2)
-                                goto out;
-
-                        ret = dict_set_str (xdata2, key,
-                                            (char *)local->newloc.name);
-                        if (ret)
-                                gf_msg (THIS->name, GF_LOG_ERROR, 0,
-                                        AFR_MSG_DICT_SET_FAILED,
-                                        "%s/%s: Could not set %s key during "
-                                        "xattrop",
-                                        uuid_utoa (local->newloc.pargfid),
-                                        local->newloc.name, key);
-                }
+    if (need_entry_key_set) {
+        ret = dict_set_str(xdata1, key, (char *)name);
+        if (ret)
+            gf_msg(THIS->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                   "%s/%s: Could not set %s key during xattrop",
+                   uuid_utoa(local->loc.pargfid), local->loc.name, key);
+        if (local->transaction.type == AFR_ENTRY_RENAME_TRANSACTION) {
+            xdata2 = dict_new();
+            if (!xdata2)
+                goto out;
+
+            ret = dict_set_str(xdata2, key, (char *)local->newloc.name);
+            if (ret)
+                gf_msg(THIS->name, GF_LOG_ERROR, 0, AFR_MSG_DICT_SET_FAILED,
+                       "%s/%s: Could not set %s key during "
+                       "xattrop",
+                       uuid_utoa(local->newloc.pargfid), local->newloc.name,
+                       key);
         }
+    }
 
-        *xdata = xdata1;
-        *newloc_xdata = xdata2;
-        xdata1 = xdata2 = NULL;
+    *xdata = xdata1;
+    *newloc_xdata = xdata2;
+    xdata1 = xdata2 = NULL;
 out:
-        if (xdata1)
-                dict_unref (xdata1);
-        return;
+    if (xdata1)
+        dict_unref(xdata1);
+    return;
 }
 
 int
-afr_changelog_prepare (xlator_t *this, call_frame_t *frame, int *call_count,
-                       afr_changelog_resume_t changelog_resume,
-                       afr_xattrop_type_t op, dict_t **xdata,
-                       dict_t **newloc_xdata)
+afr_changelog_prepare(xlator_t *this, call_frame_t *frame, int *call_count,
+                      afr_changelog_resume_t changelog_resume,
+                      afr_xattrop_type_t op, dict_t **xdata,
+                      dict_t **newloc_xdata)
 {
-        afr_private_t *priv  = NULL;
-        afr_local_t   *local = NULL;
+    afr_private_t *priv = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        *call_count = afr_changelog_call_count (local->transaction.type,
-                                               local->transaction.pre_op,
-                                              local->transaction.failed_subvols,
-                                               priv->child_count);
+    *call_count = afr_changelog_call_count(
+        local->transaction.type, local->transaction.pre_op,
+        local->transaction.failed_subvols, priv->child_count);
 
-        if (*call_count == 0) {
-                changelog_resume (frame, this);
-                return -1;
-        }
+    if (*call_count == 0) {
+        changelog_resume(frame, this);
+        return -1;
+    }
 
-        afr_changelog_populate_xdata (frame, op, xdata, newloc_xdata);
-        local->call_count = *call_count;
+    afr_changelog_populate_xdata(frame, op, xdata, newloc_xdata);
+    local->call_count = *call_count;
 
-        local->transaction.changelog_resume = changelog_resume;
-        return 0;
+    local->transaction.changelog_resume = changelog_resume;
+    return 0;
 }
 
 int
-afr_changelog_do (call_frame_t *frame, xlator_t *this, dict_t *xattr,
-		  afr_changelog_resume_t changelog_resume,
-                  afr_xattrop_type_t op)
+afr_changelog_do(call_frame_t *frame, xlator_t *this, dict_t *xattr,
+                 afr_changelog_resume_t changelog_resume, afr_xattrop_type_t op)
 {
-	afr_local_t *local = NULL;
-	afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        dict_t *newloc_xdata = NULL;
-	int i = 0;
-	int call_count = 0;
-        int ret = 0;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    dict_t *newloc_xdata = NULL;
+    int i = 0;
+    int call_count = 0;
+    int ret = 0;
 
-	local = frame->local;
-	priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (local->transaction.changelog_xdata[i]) {
-                        dict_unref (local->transaction.changelog_xdata[i]);
-                        local->transaction.changelog_xdata[i] = NULL;
-                }
+    for (i = 0; i < priv->child_count; i++) {
+        if (local->transaction.changelog_xdata[i]) {
+            dict_unref(local->transaction.changelog_xdata[i]);
+            local->transaction.changelog_xdata[i] = NULL;
         }
+    }
 
-        ret = afr_changelog_prepare (this, frame, &call_count, changelog_resume,
-                                     op, &xdata, &newloc_xdata);
+    ret = afr_changelog_prepare(this, frame, &call_count, changelog_resume, op,
+                                &xdata, &newloc_xdata);
 
-        if (ret)
-                return 0;
+    if (ret)
+        return 0;
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op[i] ||
-                    local->transaction.failed_subvols[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.pre_op[i] ||
+            local->transaction.failed_subvols[i])
+            continue;
 
-                switch (local->transaction.type) {
-                case AFR_DATA_TRANSACTION:
-                case AFR_METADATA_TRANSACTION:
-                        if (!local->fd) {
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->xattrop,
-						   &local->loc,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        } else {
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->fxattrop,
-						   local->fd,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        }
-			break;
-                case AFR_ENTRY_RENAME_TRANSACTION:
-
-			STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-					   (void *) (long) i,
-					   priv->children[i],
-					   priv->children[i]->fops->xattrop,
-					   &local->transaction.new_parent_loc,
-					   GF_XATTROP_ADD_ARRAY, xattr,
-					   newloc_xdata);
-                        call_count--;
+        switch (local->transaction.type) {
+            case AFR_DATA_TRANSACTION:
+            case AFR_METADATA_TRANSACTION:
+                if (!local->fd) {
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->xattrop,
+                        &local->loc, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                } else {
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->fxattrop,
+                        local->fd, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                }
+                break;
+            case AFR_ENTRY_RENAME_TRANSACTION:
+
+                STACK_WIND_COOKIE(frame, afr_changelog_cbk, (void *)(long)i,
+                                  priv->children[i],
+                                  priv->children[i]->fops->xattrop,
+                                  &local->transaction.new_parent_loc,
+                                  GF_XATTROP_ADD_ARRAY, xattr, newloc_xdata);
+                call_count--;
 
                 /* fall through */
 
-                case AFR_ENTRY_TRANSACTION:
-                        if (local->fd)
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->fxattrop,
-						   local->fd,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-                        else
-                                STACK_WIND_COOKIE (frame, afr_changelog_cbk,
-						   (void *) (long) i,
-						   priv->children[i],
-						   priv->children[i]->fops->xattrop,
-						   &local->transaction.parent_loc,
-						   GF_XATTROP_ADD_ARRAY, xattr,
-						   xdata);
-			break;
-		}
-
-                if (!--call_count)
-                        break;
+            case AFR_ENTRY_TRANSACTION:
+                if (local->fd)
+                    STACK_WIND_COOKIE(
+                        frame, afr_changelog_cbk, (void *)(long)i,
+                        priv->children[i], priv->children[i]->fops->fxattrop,
+                        local->fd, GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                else
+                    STACK_WIND_COOKIE(frame, afr_changelog_cbk, (void *)(long)i,
+                                      priv->children[i],
+                                      priv->children[i]->fops->xattrop,
+                                      &local->transaction.parent_loc,
+                                      GF_XATTROP_ADD_ARRAY, xattr, xdata);
+                break;
         }
 
-        if (xdata)
-                dict_unref (xdata);
-        if (newloc_xdata)
-                dict_unref (newloc_xdata);
-	return 0;
+        if (!--call_count)
+            break;
+    }
+
+    if (xdata)
+        dict_unref(xdata);
+    if (newloc_xdata)
+        dict_unref(newloc_xdata);
+    return 0;
 }
 
 static void
-afr_init_optimistic_changelog_for_txn (xlator_t *this, afr_local_t *local)
+afr_init_optimistic_changelog_for_txn(xlator_t *this, afr_local_t *local)
 {
-        int                locked_count   = 0;
-        afr_private_t     *priv           = NULL;
+    int locked_count = 0;
+    afr_private_t *priv = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        locked_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
-        if (priv->optimistic_change_log && locked_count == priv->child_count)
-                local->optimistic_change_log = 1;
+    locked_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
+    if (priv->optimistic_change_log && locked_count == priv->child_count)
+        local->optimistic_change_log = 1;
 
-        return;
+    return;
 }
 
 int
-afr_changelog_pre_op (call_frame_t *frame, xlator_t *this)
-{
-        afr_private_t * priv = this->private;
-        int i = 0;
-        int ret = 0;
-        int call_count = 0;
-	int op_errno = 0;
-        afr_local_t *local = NULL;
-        afr_internal_lock_t *int_lock = NULL;
-        unsigned char       *locked_nodes = NULL;
-	int idx = -1;
-	gf_boolean_t pre_nop = _gf_true;
-	dict_t *xdata_req = NULL;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
-	idx = afr_index_for_transaction_type (local->transaction.type);
-
-        locked_nodes = afr_locked_nodes_get (local->transaction.type, int_lock);
-
-	for (i = 0; i < priv->child_count; i++) {
-		if (locked_nodes[i]) {
-			local->transaction.pre_op[i] = 1;
-			call_count++;
-		} else {
-                        local->transaction.failed_subvols[i] = 1;
-                }
-	}
-
-        afr_init_optimistic_changelog_for_txn (this, local);
-
-        if (afr_changelog_pre_op_inherit (frame, this))
-                goto next;
-
-        /* This condition should not be met with present code, as
-         * transaction.done will be called if locks are not acquired on even a
-         * single node.
-         */
-        if (call_count == 0) {
-		op_errno = ENOTCONN;
-		goto err;
-	}
-
-        /* Check if the fop can be performed on at least
-         * quorum number of nodes.
-         */
-        if (priv->quorum_count && !afr_has_fop_quorum (frame)) {
-                op_errno = int_lock->lock_op_errno;
-                if (op_errno == 0)
-                        op_errno = afr_quorum_errno (priv);
-                goto err;
+afr_changelog_pre_op(call_frame_t *frame, xlator_t *this)
+{
+    afr_private_t *priv = this->private;
+    int i = 0;
+    int ret = 0;
+    int call_count = 0;
+    int op_errno = 0;
+    afr_local_t *local = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    unsigned char *locked_nodes = NULL;
+    int idx = -1;
+    gf_boolean_t pre_nop = _gf_true;
+    dict_t *xdata_req = NULL;
+
+    local = frame->local;
+    int_lock = &local->internal_lock;
+    idx = afr_index_for_transaction_type(local->transaction.type);
+
+    locked_nodes = afr_locked_nodes_get(local->transaction.type, int_lock);
+
+    for (i = 0; i < priv->child_count; i++) {
+        if (locked_nodes[i]) {
+            local->transaction.pre_op[i] = 1;
+            call_count++;
+        } else {
+            local->transaction.failed_subvols[i] = 1;
+        }
+    }
+
+    afr_init_optimistic_changelog_for_txn(this, local);
+
+    if (afr_changelog_pre_op_inherit(frame, this))
+        goto next;
+
+    /* This condition should not be met with present code, as
+     * transaction.done will be called if locks are not acquired on even a
+     * single node.
+     */
+    if (call_count == 0) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Check if the fop can be performed on at least
+     * quorum number of nodes.
+     */
+    if (priv->quorum_count && !afr_has_fop_quorum(frame)) {
+        op_errno = int_lock->lock_op_errno;
+        if (op_errno == 0)
+            op_errno = afr_quorum_errno(priv);
+        goto err;
+    }
+
+    xdata_req = dict_new();
+    if (!xdata_req) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (call_count < priv->child_count)
+        pre_nop = _gf_false;
+
+    /* Set an all-zero pending changelog so that in the cbk, we can get the
+     * current on-disk values. In a replica 3 volume with arbiter enabled,
+     * these values are needed to arrive at a go/ no-go of the fop phase to
+     * avoid ending up in split-brain.*/
+
+    ret = afr_set_pending_dict(priv, xdata_req, local->pending);
+    if (ret < 0) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (afr_needs_changelog_update(local)) {
+        local->dirty[idx] = hton32(1);
+
+        ret = dict_set_static_bin(xdata_req, AFR_DIRTY, local->dirty,
+                                  sizeof(int) * AFR_NUM_CHANGE_LOGS);
+        if (ret) {
+            op_errno = ENOMEM;
+            goto err;
         }
 
-	xdata_req = dict_new();
-	if (!xdata_req) {
-		op_errno = ENOMEM;
-		goto err;
-	}
-
-        if (call_count < priv->child_count)
-                pre_nop = _gf_false;
-
-        /* Set an all-zero pending changelog so that in the cbk, we can get the
-         * current on-disk values. In a replica 3 volume with arbiter enabled,
-         * these values are needed to arrive at a go/ no-go of the fop phase to
-         * avoid ending up in split-brain.*/
-
-        ret = afr_set_pending_dict (priv, xdata_req, local->pending);
-	if (ret < 0) {
-		op_errno = ENOMEM;
-		goto err;
-	}
-
-	if (afr_needs_changelog_update (local)) {
-
-		local->dirty[idx] = hton32(1);
-
-		ret = dict_set_static_bin (xdata_req, AFR_DIRTY, local->dirty,
-					   sizeof(int) * AFR_NUM_CHANGE_LOGS);
-		if (ret) {
-			op_errno = ENOMEM;
-			goto err;
-		}
+        pre_nop = _gf_false;
+        local->transaction.dirtied = 1;
+    }
 
-		pre_nop = _gf_false;
-		local->transaction.dirtied = 1;
-	}
+    if (pre_nop)
+        goto next;
 
-	if (pre_nop)
-		goto next;
+    if (!local->pre_op_compat) {
+        dict_copy(xdata_req, local->xdata_req);
+        goto next;
+    }
 
-	if (!local->pre_op_compat) {
-		dict_copy (xdata_req, local->xdata_req);
-		goto next;
-	}
+    afr_changelog_do(frame, this, xdata_req, afr_transaction_perform_fop,
+                     AFR_TRANSACTION_PRE_OP);
 
-        afr_changelog_do (frame, this, xdata_req, afr_transaction_perform_fop,
-                          AFR_TRANSACTION_PRE_OP);
+    if (xdata_req)
+        dict_unref(xdata_req);
 
-	if (xdata_req)
-		dict_unref (xdata_req);
-
-	return 0;
+    return 0;
 next:
-	afr_transaction_perform_fop (frame, this);
+    afr_transaction_perform_fop(frame, this);
 
-	if (xdata_req)
-		dict_unref (xdata_req);
+    if (xdata_req)
+        dict_unref(xdata_req);
 
-        return 0;
+    return 0;
 err:
-	local->internal_lock.lock_cbk = afr_transaction_done;
-	local->op_ret = -1;
-	local->op_errno = op_errno;
+    local->internal_lock.lock_cbk = afr_transaction_done;
+    local->op_ret = -1;
+    local->op_errno = op_errno;
 
-        afr_handle_lock_acquire_failure (local, _gf_true);
+    afr_handle_lock_acquire_failure(local, _gf_true);
 
-	if (xdata_req)
-		dict_unref (xdata_req);
+    if (xdata_req)
+        dict_unref(xdata_req);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_post_nonblocking_inodelk_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_nonblocking_inodelk_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        /* Initiate blocking locks if non-blocking has failed */
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg_debug (this->name, 0,
-                              "Non blocking inodelks failed. Proceeding to blocking");
-                int_lock->lock_cbk = afr_internal_lock_finish;
-                afr_blocking_lock (frame, this);
-        } else {
+    /* Initiate blocking locks if non-blocking has failed */
+    if (int_lock->lock_op_ret < 0) {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking inodelks failed. Proceeding to blocking");
+        int_lock->lock_cbk = afr_internal_lock_finish;
+        afr_blocking_lock(frame, this);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking inodelks done. Proceeding to FOP");
+        afr_internal_lock_finish(frame, this);
+    }
 
-                gf_msg_debug (this->name, 0,
-                              "Non blocking inodelks done. Proceeding to FOP");
-                afr_internal_lock_finish (frame, this);
-        }
-
-        return 0;
+    return 0;
 }
 
-
 int
-afr_post_nonblocking_entrylk_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_nonblocking_entrylk_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
-
-        local = frame->local;
-        int_lock = &local->internal_lock;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        /* Initiate blocking locks if non-blocking has failed */
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg_debug (this->name, 0,
-                              "Non blocking entrylks failed. Proceeding to blocking");
-                int_lock->lock_cbk = afr_internal_lock_finish;
-                afr_blocking_lock (frame, this);
-        } else {
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-                gf_msg_debug (this->name, 0,
-                              "Non blocking entrylks done. Proceeding to FOP");
+    /* Initiate blocking locks if non-blocking has failed */
+    if (int_lock->lock_op_ret < 0) {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking entrylks failed. Proceeding to blocking");
+        int_lock->lock_cbk = afr_internal_lock_finish;
+        afr_blocking_lock(frame, this);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Non blocking entrylks done. Proceeding to FOP");
 
-                afr_internal_lock_finish (frame, this);
-        }
+        afr_internal_lock_finish(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_post_blocking_rename_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_blocking_rename_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        if (int_lock->lock_op_ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        AFR_MSG_BLOCKING_LKS_FAILED,
-                        "Blocking entrylks failed.");
-
-                afr_transaction_done (frame, this);
-        } else {
+    if (int_lock->lock_op_ret < 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, AFR_MSG_BLOCKING_LKS_FAILED,
+               "Blocking entrylks failed.");
 
-                gf_msg_debug (this->name, 0,
-                              "Blocking entrylks done. Proceeding to FOP");
+        afr_transaction_done(frame, this);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Blocking entrylks done. Proceeding to FOP");
 
-                afr_internal_lock_finish (frame, this);
-        }
-        return 0;
+        afr_internal_lock_finish(frame, this);
+    }
+    return 0;
 }
 
 int
-afr_post_lower_unlock_cbk (call_frame_t *frame, xlator_t *this)
+afr_post_lower_unlock_cbk(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        GF_ASSERT (!int_lock->higher_locked);
+    GF_ASSERT(!int_lock->higher_locked);
 
-        int_lock->lock_cbk = afr_post_blocking_rename_cbk;
-        afr_blocking_lock (frame, this);
+    int_lock->lock_cbk = afr_post_blocking_rename_cbk;
+    afr_blocking_lock(frame, this);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_set_transaction_flock (xlator_t *this, afr_local_t *local)
+afr_set_transaction_flock(xlator_t *this, afr_local_t *local)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_private_t       *priv     = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_private_t *priv = NULL;
 
-        int_lock = &local->internal_lock;
-        priv = this->private;
+    int_lock = &local->internal_lock;
+    priv = this->private;
 
-        if ((priv->arbiter_count || local->transaction.eager_lock_on ||
-             priv->full_lock) &&
-            local->transaction.type == AFR_DATA_TRANSACTION) {
-                /*Lock entire file to avoid network split brains.*/
-                int_lock->flock.l_len   = 0;
-                int_lock->flock.l_start = 0;
-        } else {
-                int_lock->flock.l_len   = local->transaction.len;
-                int_lock->flock.l_start = local->transaction.start;
-        }
-        int_lock->flock.l_type  = F_WRLCK;
+    if ((priv->arbiter_count || local->transaction.eager_lock_on ||
+         priv->full_lock) &&
+        local->transaction.type == AFR_DATA_TRANSACTION) {
+        /*Lock entire file to avoid network split brains.*/
+        int_lock->flock.l_len = 0;
+        int_lock->flock.l_start = 0;
+    } else {
+        int_lock->flock.l_len = local->transaction.len;
+        int_lock->flock.l_start = local->transaction.start;
+    }
+    int_lock->flock.l_type = F_WRLCK;
 
-        return 0;
+    return 0;
 }
 
 int
-afr_lock (call_frame_t *frame, xlator_t *this)
+afr_lock(call_frame_t *frame, xlator_t *this)
 {
-        afr_internal_lock_t *int_lock = NULL;
-        afr_local_t         *local    = NULL;
+    afr_internal_lock_t *int_lock = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
-        int_lock = &local->internal_lock;
+    local = frame->local;
+    int_lock = &local->internal_lock;
 
-        int_lock->domain = this->name;
+    int_lock->domain = this->name;
 
-        switch (local->transaction.type) {
+    switch (local->transaction.type) {
         case AFR_DATA_TRANSACTION:
         case AFR_METADATA_TRANSACTION:
-                afr_set_transaction_flock (this, local);
+            afr_set_transaction_flock(this, local);
 
-                int_lock->lock_cbk = afr_post_nonblocking_inodelk_cbk;
+            int_lock->lock_cbk = afr_post_nonblocking_inodelk_cbk;
 
-                afr_nonblocking_inodelk (frame, this);
-                break;
+            afr_nonblocking_inodelk(frame, this);
+            break;
 
         case AFR_ENTRY_RENAME_TRANSACTION:
 
-                int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
-                afr_nonblocking_entrylk (frame, this);
-                break;
+            int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
+            afr_nonblocking_entrylk(frame, this);
+            break;
 
         case AFR_ENTRY_TRANSACTION:
-                int_lock->lk_basename = local->transaction.basename;
-                if (local->transaction.parent_loc.path)
-                        int_lock->lk_loc = &local->transaction.parent_loc;
-                else
-                        GF_ASSERT (local->fd);
+            int_lock->lk_basename = local->transaction.basename;
+            if (local->transaction.parent_loc.path)
+                int_lock->lk_loc = &local->transaction.parent_loc;
+            else
+                GF_ASSERT(local->fd);
 
-                int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
-                afr_nonblocking_entrylk (frame, this);
-                break;
-        }
+            int_lock->lock_cbk = afr_post_nonblocking_entrylk_cbk;
+            afr_nonblocking_entrylk(frame, this);
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
 static gf_boolean_t
-afr_locals_overlap (afr_local_t *local1, afr_local_t *local2)
+afr_locals_overlap(afr_local_t *local1, afr_local_t *local2)
 {
-        uint64_t start1 = local1->transaction.start;
-        uint64_t start2 = local2->transaction.start;
-        uint64_t end1 = 0;
-        uint64_t end2 = 0;
+    uint64_t start1 = local1->transaction.start;
+    uint64_t start2 = local2->transaction.start;
+    uint64_t end1 = 0;
+    uint64_t end2 = 0;
 
-        if (local1->transaction.len)
-                end1 = start1 + local1->transaction.len - 1;
-        else
-                end1 = ULLONG_MAX;
+    if (local1->transaction.len)
+        end1 = start1 + local1->transaction.len - 1;
+    else
+        end1 = ULLONG_MAX;
 
-        if (local2->transaction.len)
-                end2 = start2 + local2->transaction.len - 1;
-        else
-                end2 = ULLONG_MAX;
+    if (local2->transaction.len)
+        end2 = start2 + local2->transaction.len - 1;
+    else
+        end2 = ULLONG_MAX;
 
-        return ((end1 >= start2) && (end2 >= start1));
+    return ((end1 >= start2) && (end2 >= start1));
 }
 
 gf_boolean_t
-afr_has_lock_conflict (afr_local_t *local, gf_boolean_t waitlist_check)
-{
-        afr_local_t     *each = NULL;
-        afr_lock_t      *lock = NULL;
-
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        /*
-         * Once full file lock is acquired in eager-lock phase, overlapping
-         * writes do not compete for inode-locks, instead are transferred to the
-         * next writes. Because of this overlapping writes are not ordered.
-         * This can cause inconsistencies in replication.
-         * Example:
-         * Two overlapping writes w1, w2 are sent in parallel on same fd
-         * in two threads t1, t2.
-         * Both threads can execute afr_writev_wind in the following manner.
-         * t1 winds w1 on brick-0
-         * t2 winds w2 on brick-0
-         * t2 winds w2 on brick-1
-         * t1 winds w1 on brick-1
-         *
-         * This check makes sure the locks are not transferred for
-         * overlapping writes.
-         */
-        list_for_each_entry (each, &lock->owners, transaction.owner_list) {
-                if (afr_locals_overlap (each, local)) {
-                        return _gf_true;
-                }
-        }
-
-        if (!waitlist_check)
-                return _gf_false;
-        list_for_each_entry (each, &lock->waiting, transaction.wait_list) {
-                if (afr_locals_overlap (each, local)) {
-                        return _gf_true;
-                }
-        }
+afr_has_lock_conflict(afr_local_t *local, gf_boolean_t waitlist_check)
+{
+    afr_local_t *each = NULL;
+    afr_lock_t *lock = NULL;
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    /*
+     * Once full file lock is acquired in eager-lock phase, overlapping
+     * writes do not compete for inode-locks, instead are transferred to the
+     * next writes. Because of this overlapping writes are not ordered.
+     * This can cause inconsistencies in replication.
+     * Example:
+     * Two overlapping writes w1, w2 are sent in parallel on same fd
+     * in two threads t1, t2.
+     * Both threads can execute afr_writev_wind in the following manner.
+     * t1 winds w1 on brick-0
+     * t2 winds w2 on brick-0
+     * t2 winds w2 on brick-1
+     * t1 winds w1 on brick-1
+     *
+     * This check makes sure the locks are not transferred for
+     * overlapping writes.
+     */
+    list_for_each_entry(each, &lock->owners, transaction.owner_list)
+    {
+        if (afr_locals_overlap(each, local)) {
+            return _gf_true;
+        }
+    }
+
+    if (!waitlist_check)
         return _gf_false;
+    list_for_each_entry(each, &lock->waiting, transaction.wait_list)
+    {
+        if (afr_locals_overlap(each, local)) {
+            return _gf_true;
+        }
+    }
+    return _gf_false;
 }
 
-
 /* }}} */
 static void
-afr_copy_inodelk_vars (afr_internal_lock_t *dst, afr_internal_lock_t *src,
-                       xlator_t *this)
+afr_copy_inodelk_vars(afr_internal_lock_t *dst, afr_internal_lock_t *src,
+                      xlator_t *this)
 {
-        afr_private_t *priv = this->private;
+    afr_private_t *priv = this->private;
 
-        dst->domain = src->domain;
-        dst->flock.l_len  = src->flock.l_len;
-        dst->flock.l_start  = src->flock.l_start;
-        dst->flock.l_type  = src->flock.l_type;
-        dst->lock_count = src->lock_count;
-        memcpy (dst->locked_nodes, src->locked_nodes,
-                priv->child_count * sizeof (*dst->locked_nodes));
+    dst->domain = src->domain;
+    dst->flock.l_len = src->flock.l_len;
+    dst->flock.l_start = src->flock.l_start;
+    dst->flock.l_type = src->flock.l_type;
+    dst->lock_count = src->lock_count;
+    memcpy(dst->locked_nodes, src->locked_nodes,
+           priv->child_count * sizeof(*dst->locked_nodes));
 }
 
 void
-__afr_transaction_wake_shared (afr_local_t *local, struct list_head *shared)
-{
-        gf_boolean_t conflict = _gf_false;
-        afr_local_t *each = NULL;
-        afr_lock_t *lock = &local->inode_ctx->lock[local->transaction.type];
-
-        while (!conflict) {
-                if (list_empty (&lock->waiting))
-                        return;
-                each = list_entry(lock->waiting.next, afr_local_t,
-                                  transaction.wait_list);
-                if (afr_has_lock_conflict (each, _gf_false)) {
-                        conflict = _gf_true;
-                }
-                if (conflict && !list_empty (&lock->owners))
-                        return;
-                afr_copy_inodelk_vars (&each->internal_lock,
-                                       &local->internal_lock,
-                                       each->transaction.frame->this);
-                list_move_tail (&each->transaction.wait_list, shared);
-                list_add_tail(&each->transaction.owner_list, &lock->owners);
+__afr_transaction_wake_shared(afr_local_t *local, struct list_head *shared)
+{
+    gf_boolean_t conflict = _gf_false;
+    afr_local_t *each = NULL;
+    afr_lock_t *lock = &local->inode_ctx->lock[local->transaction.type];
+
+    while (!conflict) {
+        if (list_empty(&lock->waiting))
+            return;
+        each = list_entry(lock->waiting.next, afr_local_t,
+                          transaction.wait_list);
+        if (afr_has_lock_conflict(each, _gf_false)) {
+            conflict = _gf_true;
         }
+        if (conflict && !list_empty(&lock->owners))
+            return;
+        afr_copy_inodelk_vars(&each->internal_lock, &local->internal_lock,
+                              each->transaction.frame->this);
+        list_move_tail(&each->transaction.wait_list, shared);
+        list_add_tail(&each->transaction.owner_list, &lock->owners);
+    }
 }
 
 static void
-afr_lock_resume_shared (struct list_head *list)
+afr_lock_resume_shared(struct list_head *list)
 {
-        afr_local_t *each = NULL;
+    afr_local_t *each = NULL;
 
-        while (!list_empty(list)) {
-                each = list_entry(list->next, afr_local_t,
-                                  transaction.wait_list);
-                list_del_init(&each->transaction.wait_list);
-                afr_changelog_pre_op (each->transaction.frame,
-                                      each->transaction.frame->this);
-        }
+    while (!list_empty(list)) {
+        each = list_entry(list->next, afr_local_t, transaction.wait_list);
+        list_del_init(&each->transaction.wait_list);
+        afr_changelog_pre_op(each->transaction.frame,
+                             each->transaction.frame->this);
+    }
 }
 
 int
-afr_internal_lock_finish (call_frame_t *frame, xlator_t *this)
+afr_internal_lock_finish(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = frame->local;
-        afr_lock_t   *lock  = NULL;
+    afr_local_t *local = frame->local;
+    afr_lock_t *lock = NULL;
 
-
-        local->internal_lock.lock_cbk = NULL;
-        if (!local->transaction.eager_lock_on) {
-                if (local->internal_lock.lock_op_ret < 0) {
-                        afr_transaction_done (frame, this);
-                        return 0;
-                }
-                afr_changelog_pre_op (frame, this);
+    local->internal_lock.lock_cbk = NULL;
+    if (!local->transaction.eager_lock_on) {
+        if (local->internal_lock.lock_op_ret < 0) {
+            afr_transaction_done(frame, this);
+            return 0;
+        }
+        afr_changelog_pre_op(frame, this);
+    } else {
+        lock = &local->inode_ctx->lock[local->transaction.type];
+        if (local->internal_lock.lock_op_ret < 0) {
+            afr_handle_lock_acquire_failure(local, _gf_false);
         } else {
-                lock = &local->inode_ctx->lock[local->transaction.type];
-                if (local->internal_lock.lock_op_ret < 0) {
-                        afr_handle_lock_acquire_failure (local, _gf_false);
-                } else {
-                        lock->event_generation = local->event_generation;
-                        afr_changelog_pre_op (frame, this);
-                }
+            lock->event_generation = local->event_generation;
+            afr_changelog_pre_op(frame, this);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-afr_are_multiple_fds_opened (afr_local_t *local, xlator_t *this)
+afr_are_multiple_fds_opened(afr_local_t *local, xlator_t *this)
 {
-        /* Lets say mount1 has eager-lock(full-lock) and after the eager-lock
-         * is taken mount2 opened the same file, it won't be able to
-         * perform any data operations until mount1 releases eager-lock.
-         * To avoid such scenario do not enable eager-lock for this transaction
-         * if open-fd-count is > 1
-         */
+    /* Lets say mount1 has eager-lock(full-lock) and after the eager-lock
+     * is taken mount2 opened the same file, it won't be able to
+     * perform any data operations until mount1 releases eager-lock.
+     * To avoid such scenario do not enable eager-lock for this transaction
+     * if open-fd-count is > 1
+     */
 
-        if (local->inode_ctx->open_fd_count > 1)
-                return _gf_true;
+    if (local->inode_ctx->open_fd_count > 1)
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
-
 gf_boolean_t
-afr_is_delayed_changelog_post_op_needed (call_frame_t *frame, xlator_t *this,
-                                         int delay)
-{
-        afr_local_t  *local = NULL;
-        afr_lock_t   *lock  = NULL;
-        gf_boolean_t res    = _gf_false;
-
-        local = frame->local;
-        lock = &local->inode_ctx->lock[local->transaction.type];
-
-        if (!afr_txn_nothing_failed (frame, this)) {
-                lock->release = _gf_true;
-                goto out;
-        }
-
-        if (afr_are_multiple_fds_opened (local, this)) {
-                lock->release = _gf_true;
-                goto out;
-        }
-
-        if (!list_empty (&lock->owners))
-                goto out;
-        else
-                GF_ASSERT (list_empty (&lock->waiting));
-
-        if (lock->release) {
-                goto out;
-        }
-
-        if (!delay) {
-                goto out;
-        }
-
-        if ((local->op != GF_FOP_WRITE) &&
-            (local->op != GF_FOP_FXATTROP)) {
-                /*Only allow writes but shard does [f]xattrops on writes, so
-                 * they are fine too*/
-                goto out;
-        }
-
-        res = _gf_true;
+afr_is_delayed_changelog_post_op_needed(call_frame_t *frame, xlator_t *this,
+                                        int delay)
+{
+    afr_local_t *local = NULL;
+    afr_lock_t *lock = NULL;
+    gf_boolean_t res = _gf_false;
+
+    local = frame->local;
+    lock = &local->inode_ctx->lock[local->transaction.type];
+
+    if (!afr_txn_nothing_failed(frame, this)) {
+        lock->release = _gf_true;
+        goto out;
+    }
+
+    if (afr_are_multiple_fds_opened(local, this)) {
+        lock->release = _gf_true;
+        goto out;
+    }
+
+    if (!list_empty(&lock->owners))
+        goto out;
+    else
+        GF_ASSERT(list_empty(&lock->waiting));
+
+    if (lock->release) {
+        goto out;
+    }
+
+    if (!delay) {
+        goto out;
+    }
+
+    if ((local->op != GF_FOP_WRITE) && (local->op != GF_FOP_FXATTROP)) {
+        /*Only allow writes but shard does [f]xattrops on writes, so
+         * they are fine too*/
+        goto out;
+    }
+
+    res = _gf_true;
 out:
-        return res;
+    return res;
 }
 
-
 void
-afr_delayed_changelog_wake_up_cbk (void *data)
-{
-        afr_lock_t  *lock  = NULL;
-        afr_local_t *local = data;
-        afr_local_t *timer_local = NULL;
-        struct list_head shared;
-
-        INIT_LIST_HEAD (&shared);
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        LOCK (&local->inode->lock);
-        {
-                timer_local = list_entry(lock->post_op.next,
-                                         afr_local_t,
-                                        transaction.owner_list);
-                if (list_empty (&lock->owners) && (local == timer_local)) {
-                        GF_ASSERT (list_empty (&lock->waiting));
-                        /*Last owner*/
-                        lock->release = _gf_true;
-                        lock->delay_timer = NULL;
-                }
-        }
-        UNLOCK (&local->inode->lock);
-        afr_changelog_post_op_now (local->transaction.frame,
-                                   local->transaction.frame->this);
+afr_delayed_changelog_wake_up_cbk(void *data)
+{
+    afr_lock_t *lock = NULL;
+    afr_local_t *local = data;
+    afr_local_t *timer_local = NULL;
+    struct list_head shared;
+
+    INIT_LIST_HEAD(&shared);
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        timer_local = list_entry(lock->post_op.next, afr_local_t,
+                                 transaction.owner_list);
+        if (list_empty(&lock->owners) && (local == timer_local)) {
+            GF_ASSERT(list_empty(&lock->waiting));
+            /*Last owner*/
+            lock->release = _gf_true;
+            lock->delay_timer = NULL;
+        }
+    }
+    UNLOCK(&local->inode->lock);
+    afr_changelog_post_op_now(local->transaction.frame,
+                              local->transaction.frame->this);
 }
 
-
 /* SET operation */
 int
-afr_fd_report_unstable_write (xlator_t *this, afr_local_t *local)
+afr_fd_report_unstable_write(xlator_t *this, afr_local_t *local)
 {
-        LOCK(&local->inode->lock);
-        {
-                local->inode_ctx->witnessed_unstable_write = _gf_true;
-        }
-        UNLOCK(&local->inode->lock);
+    LOCK(&local->inode->lock);
+    {
+        local->inode_ctx->witnessed_unstable_write = _gf_true;
+    }
+    UNLOCK(&local->inode->lock);
 
-        return 0;
+    return 0;
 }
 
 /* TEST and CLEAR operation */
 gf_boolean_t
-afr_fd_has_witnessed_unstable_write (xlator_t *this, inode_t *inode)
+afr_fd_has_witnessed_unstable_write(xlator_t *this, inode_t *inode)
 {
-        afr_inode_ctx_t *ctx = NULL;
-        gf_boolean_t witness = _gf_false;
+    afr_inode_ctx_t *ctx = NULL;
+    gf_boolean_t witness = _gf_false;
 
-        LOCK(&inode->lock);
-        {
-                (void)__afr_inode_ctx_get (this, inode, &ctx);
+    LOCK(&inode->lock);
+    {
+        (void)__afr_inode_ctx_get(this, inode, &ctx);
 
-                if (ctx->witnessed_unstable_write) {
-                        witness = _gf_true;
-                        ctx->witnessed_unstable_write = _gf_false;
-                }
+        if (ctx->witnessed_unstable_write) {
+            witness = _gf_true;
+            ctx->witnessed_unstable_write = _gf_false;
         }
-        UNLOCK (&inode->lock);
+    }
+    UNLOCK(&inode->lock);
 
-        return witness;
+    return witness;
 }
 
-
 int
-afr_changelog_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *pre,
-                         struct iatt *post, dict_t *xdata)
+afr_changelog_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *pre,
+                        struct iatt *post, dict_t *xdata)
 {
-        afr_private_t *priv = NULL;
-        int child_index = (long) cookie;
-        int call_count = -1;
-        afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int child_index = (long)cookie;
+    int call_count = -1;
+    afr_local_t *local = NULL;
 
-        priv = this->private;
-        local = frame->local;
+    priv = this->private;
+    local = frame->local;
 
-        if (op_ret != 0) {
-                /* Failure of fsync() is as good as failure of previous
-                   write(). So treat it like one.
-		*/
-                gf_msg (this->name, GF_LOG_WARNING,
-                        op_errno, AFR_MSG_FSYNC_FAILED,
-                        "fsync(%s) failed on subvolume %s. Transaction was %s",
-                        uuid_utoa (local->fd->inode->gfid),
-                        priv->children[child_index]->name,
-                        gf_fop_list[local->op]);
+    if (op_ret != 0) {
+        /* Failure of fsync() is as good as failure of previous
+           write(). So treat it like one.
+        */
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, AFR_MSG_FSYNC_FAILED,
+               "fsync(%s) failed on subvolume %s. Transaction was %s",
+               uuid_utoa(local->fd->inode->gfid),
+               priv->children[child_index]->name, gf_fop_list[local->op]);
 
-                afr_transaction_fop_failed (frame, this, child_index);
-	}
+        afr_transaction_fop_failed(frame, this, child_index);
+    }
 
-	call_count = afr_frame_return (frame);
+    call_count = afr_frame_return(frame);
 
-	if (call_count == 0)
-		afr_changelog_post_op_now (frame, this);
+    if (call_count == 0)
+        afr_changelog_post_op_now(frame, this);
 
-	return 0;
+    return 0;
 }
 
-
 int
-afr_changelog_fsync (call_frame_t *frame, xlator_t *this)
+afr_changelog_fsync(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t *local = NULL;
-        int i = 0;
-        int call_count = 0;
-        afr_private_t *priv = NULL;
-        dict_t *xdata = NULL;
-        GF_UNUSED int ret = -1;
+    afr_local_t *local = NULL;
+    int i = 0;
+    int call_count = 0;
+    afr_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    GF_UNUSED int ret = -1;
 
-        local = frame->local;
-        priv = this->private;
+    local = frame->local;
+    priv = this->private;
 
-        call_count = AFR_COUNT (local->transaction.pre_op, priv->child_count);
+    call_count = AFR_COUNT(local->transaction.pre_op, priv->child_count);
 
-        if (!call_count) {
-                /* will go straight to unlock */
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    if (!call_count) {
+        /* will go straight to unlock */
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        local->call_count = call_count;
+    local->call_count = call_count;
 
-        xdata = dict_new();
-        if (xdata)
-                ret = dict_set_int32 (xdata, "batch-fsync", 1);
+    xdata = dict_new();
+    if (xdata)
+        ret = dict_set_int32(xdata, "batch-fsync", 1);
 
-        for (i = 0; i < priv->child_count; i++) {
-                if (!local->transaction.pre_op[i])
-                        continue;
+    for (i = 0; i < priv->child_count; i++) {
+        if (!local->transaction.pre_op[i])
+            continue;
 
-                STACK_WIND_COOKIE (frame, afr_changelog_fsync_cbk,
-				   (void *) (long) i, priv->children[i],
-				   priv->children[i]->fops->fsync, local->fd,
-				   1, xdata);
-                if (!--call_count)
-                        break;
-        }
+        STACK_WIND_COOKIE(frame, afr_changelog_fsync_cbk, (void *)(long)i,
+                          priv->children[i], priv->children[i]->fops->fsync,
+                          local->fd, 1, xdata);
+        if (!--call_count)
+            break;
+    }
 
-        if (xdata)
-                dict_unref (xdata);
+    if (xdata)
+        dict_unref(xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-afr_changelog_post_op_safe (call_frame_t *frame, xlator_t *this)
+afr_changelog_post_op_safe(call_frame_t *frame, xlator_t *this)
 {
-	afr_local_t    *local = NULL;
-        afr_private_t  *priv = NULL;
-
-	local = frame->local;
-        priv = this->private;
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
 
-        if (!local->fd || local->transaction.type != AFR_DATA_TRANSACTION) {
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    local = frame->local;
+    priv = this->private;
 
-        if (afr_changelog_pre_op_uninherit (frame, this) &&
-	    afr_txn_nothing_failed (frame, this)) {
-                /* just detected that this post-op is about to
-                   be optimized away as a new write() has
-                   already piggybacked on this frame's changelog.
-                   */
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
+    if (!local->fd || local->transaction.type != AFR_DATA_TRANSACTION) {
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        /* Calling afr_changelog_post_op_now() now will result in
-           issuing ->[f]xattrop().
-
-           Performing a hard POST-OP (->[f]xattrop() FOP) is a more
-           responsible operation that what it might appear on the surface.
-
-           The changelog of a file (in the xattr of the file on the server)
-           stores information (pending count) about the state of the file
-           on the OTHER server. This changelog is blindly trusted, and must
-           therefore be updated in such a way it remains trustworthy. This
-           implies that decrementing the pending count (essentially "clearing
-           the dirty flag") must be done STRICTLY after we are sure that the
-           operation on the other server has reached stable storage.
-
-           While the backend filesystem on that server will eventually flush
-           it to stable storage, we (being in userspace) have no mechanism
-           to get notified when the write became "stable".
-
-           This means we need take matter into our own hands and issue an
-           fsync() EVEN IF THE APPLICATION WAS PERFORMING UNSTABLE WRITES,
-           and get an acknowledgement for it. And we need to wait for the
-           fsync() acknowledgement before initiating the hard POST-OP.
-
-           However if the FD itself was opened in O_SYNC or O_DSYNC then
-           we are already guaranteed that the writes were made stable as
-           part of the FOP itself. The same holds true for NFS stable
-           writes which happen on an anonymous FD with O_DSYNC or O_SYNC
-           flag set in the writev() @flags param. For all other write types,
-           mark a flag in the fdctx whenever an unstable write is witnessed.
+    if (afr_changelog_pre_op_uninherit(frame, this) &&
+        afr_txn_nothing_failed(frame, this)) {
+        /* just detected that this post-op is about to
+           be optimized away as a new write() has
+           already piggybacked on this frame's changelog.
            */
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
+
+    /* Calling afr_changelog_post_op_now() now will result in
+       issuing ->[f]xattrop().
+
+       Performing a hard POST-OP (->[f]xattrop() FOP) is a more
+       responsible operation that what it might appear on the surface.
+
+       The changelog of a file (in the xattr of the file on the server)
+       stores information (pending count) about the state of the file
+       on the OTHER server. This changelog is blindly trusted, and must
+       therefore be updated in such a way it remains trustworthy. This
+       implies that decrementing the pending count (essentially "clearing
+       the dirty flag") must be done STRICTLY after we are sure that the
+       operation on the other server has reached stable storage.
+
+       While the backend filesystem on that server will eventually flush
+       it to stable storage, we (being in userspace) have no mechanism
+       to get notified when the write became "stable".
+
+       This means we need take matter into our own hands and issue an
+       fsync() EVEN IF THE APPLICATION WAS PERFORMING UNSTABLE WRITES,
+       and get an acknowledgement for it. And we need to wait for the
+       fsync() acknowledgement before initiating the hard POST-OP.
+
+       However if the FD itself was opened in O_SYNC or O_DSYNC then
+       we are already guaranteed that the writes were made stable as
+       part of the FOP itself. The same holds true for NFS stable
+       writes which happen on an anonymous FD with O_DSYNC or O_SYNC
+       flag set in the writev() @flags param. For all other write types,
+       mark a flag in the fdctx whenever an unstable write is witnessed.
+       */
+
+    if (!afr_fd_has_witnessed_unstable_write(this, local->inode)) {
+        afr_changelog_post_op_now(frame, this);
+        return 0;
+    }
 
-        if (!afr_fd_has_witnessed_unstable_write (this, local->inode)) {
-                afr_changelog_post_op_now (frame, this);
-                return 0;
-        }
-
-        /* Check whether users want durability and perform fsync/post-op
-         * accordingly.
-         */
-        if (priv->ensure_durability) {
-                /* Time to fsync() */
-                afr_changelog_fsync (frame, this);
-        } else {
-                afr_changelog_post_op_now (frame, this);
-        }
+    /* Check whether users want durability and perform fsync/post-op
+     * accordingly.
+     */
+    if (priv->ensure_durability) {
+        /* Time to fsync() */
+        afr_changelog_fsync(frame, this);
+    } else {
+        afr_changelog_post_op_now(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 void
-afr_changelog_post_op (call_frame_t *frame, xlator_t *this)
-{
-	struct timespec delta   = {0, };
-	afr_private_t   *priv   = NULL;
-	afr_local_t     *local  = frame->local;
-        afr_lock_t      *lock   = NULL;
-        gf_boolean_t    post_op = _gf_true;
-        struct list_head  shared;
-
-	priv = this->private;
-	delta.tv_sec = priv->post_op_delay_secs;
-	delta.tv_nsec = 0;
-
-        INIT_LIST_HEAD (&shared);
-        if (!local->transaction.eager_lock_on)
-                goto out;
-
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        LOCK (&local->inode->lock);
-	{
-                list_del_init (&local->transaction.owner_list);
-                list_add (&local->transaction.owner_list, &lock->post_op);
-                __afr_transaction_wake_shared (local, &shared);
-
-                if (!afr_is_delayed_changelog_post_op_needed (frame, this,
-                                                              delta.tv_sec)) {
-                        if (list_empty (&lock->owners))
-                                lock->release = _gf_true;
-                        goto unlock;
-                }
-
-                GF_ASSERT (lock->delay_timer == NULL);
-		lock->delay_timer = gf_timer_call_after (this->ctx, delta,
-                                              afr_delayed_changelog_wake_up_cbk,
-                                              local);
-                if (!lock->delay_timer) {
-                        lock->release = _gf_true;
-                } else {
-                        post_op = _gf_false;
-                }
+afr_changelog_post_op(call_frame_t *frame, xlator_t *this)
+{
+    struct timespec delta = {
+        0,
+    };
+    afr_private_t *priv = NULL;
+    afr_local_t *local = frame->local;
+    afr_lock_t *lock = NULL;
+    gf_boolean_t post_op = _gf_true;
+    struct list_head shared;
+
+    priv = this->private;
+    delta.tv_sec = priv->post_op_delay_secs;
+    delta.tv_nsec = 0;
+
+    INIT_LIST_HEAD(&shared);
+    if (!local->transaction.eager_lock_on)
+        goto out;
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    LOCK(&local->inode->lock);
+    {
+        list_del_init(&local->transaction.owner_list);
+        list_add(&local->transaction.owner_list, &lock->post_op);
+        __afr_transaction_wake_shared(local, &shared);
+
+        if (!afr_is_delayed_changelog_post_op_needed(frame, this,
+                                                     delta.tv_sec)) {
+            if (list_empty(&lock->owners))
+                lock->release = _gf_true;
+            goto unlock;
+        }
 
-	}
+        GF_ASSERT(lock->delay_timer == NULL);
+        lock->delay_timer = gf_timer_call_after(
+            this->ctx, delta, afr_delayed_changelog_wake_up_cbk, local);
+        if (!lock->delay_timer) {
+            lock->release = _gf_true;
+        } else {
+            post_op = _gf_false;
+        }
+    }
 unlock:
-        UNLOCK (&local->inode->lock);
+    UNLOCK(&local->inode->lock);
 
-        if (!list_empty (&shared)) {
-                afr_lock_resume_shared (&shared);
-        }
+    if (!list_empty(&shared)) {
+        afr_lock_resume_shared(&shared);
+    }
 
 out:
-        if (post_op) {
-                if (!local->transaction.eager_lock_on || lock->release) {
-                        afr_changelog_post_op_safe (frame, this);
-                } else {
-                        afr_changelog_post_op_now (frame, this);
-                }
+    if (post_op) {
+        if (!local->transaction.eager_lock_on || lock->release) {
+            afr_changelog_post_op_safe(frame, this);
+        } else {
+            afr_changelog_post_op_now(frame, this);
         }
+    }
 }
 
 int
-afr_transaction_resume (call_frame_t *frame, xlator_t *this)
+afr_transaction_resume(call_frame_t *frame, xlator_t *this)
 {
-        afr_local_t         *local    = NULL;
+    afr_local_t *local = NULL;
 
-        local    = frame->local;
+    local = frame->local;
 
-        afr_restore_lk_owner (frame);
+    afr_restore_lk_owner(frame);
 
-        afr_handle_symmetric_errors (frame, this);
+    afr_handle_symmetric_errors(frame, this);
 
-	if (!local->pre_op_compat)
-		/* new mode, pre-op was done along
-		   with OP */
-		afr_changelog_pre_op_update (frame, this);
+    if (!local->pre_op_compat)
+        /* new mode, pre-op was done along
+           with OP */
+        afr_changelog_pre_op_update(frame, this);
 
-        afr_changelog_post_op (frame, this);
+    afr_changelog_post_op(frame, this);
 
-        return 0;
+    return 0;
 }
 
-
 /**
  * afr_transaction_fop_failed - inform that an fop failed
  */
 
 void
-afr_transaction_fop_failed (call_frame_t *frame, xlator_t *this,
-                            int child_index)
+afr_transaction_fop_failed(call_frame_t *frame, xlator_t *this, int child_index)
 {
-        afr_local_t *   local = NULL;
+    afr_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-	local->transaction.failed_subvols[child_index] = 1;
+    local->transaction.failed_subvols[child_index] = 1;
 }
 
 static gf_boolean_t
-__need_previous_lock_unlocked (afr_local_t *local)
+__need_previous_lock_unlocked(afr_local_t *local)
 {
-        afr_lock_t      *lock = NULL;
+    afr_lock_t *lock = NULL;
 
-        if (!local->transaction.eager_lock_on)
-                return _gf_true;
+    if (!local->transaction.eager_lock_on)
+        return _gf_true;
 
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        if (!lock->acquired)
-                return _gf_false;
-        if (lock->acquired && lock->event_generation != local->event_generation)
-                return _gf_true;
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    if (!lock->acquired)
         return _gf_false;
+    if (lock->acquired && lock->event_generation != local->event_generation)
+        return _gf_true;
+    return _gf_false;
 }
 
 void
-__afr_eager_lock_handle (afr_local_t *local, gf_boolean_t *take_lock,
-                         gf_boolean_t *do_pre_op, afr_local_t **timer_local)
-{
-        afr_lock_t      *lock = NULL;
-        afr_local_t     *owner_local = NULL;
-        xlator_t        *this = local->transaction.frame->this;
-
-        if (local->fd && !afr_are_multiple_fds_opened (local, this)) {
-                local->transaction.eager_lock_on = _gf_true;
-                afr_set_lk_owner (local->transaction.frame, this, local->inode);
-        }
-
-        lock = &local->inode_ctx->lock[local->transaction.type];
-        if (__need_previous_lock_unlocked (local)) {
-                if (!list_empty (&lock->owners)) {
-                        lock->release = _gf_true;
-                } else if (lock->delay_timer) {
-                        lock->release = _gf_true;
-                        if (gf_timer_call_cancel (this->ctx,
-                                                  lock->delay_timer)) {
-                                /* It will be put in frozen list
-                                 * in the code flow below*/
-                        } else {
-                                *timer_local = list_entry(lock->post_op.next,
-                                                          afr_local_t,
-                                                        transaction.owner_list);
-                                lock->delay_timer = NULL;
-                        }
-                }
-                if (!local->transaction.eager_lock_on)
-                        goto out;
-        }
-
-        if (lock->release) {
-                list_add_tail (&local->transaction.wait_list,
-                               &lock->frozen);
-                *take_lock = _gf_false;
-                goto out;
-        }
-
-        if (lock->delay_timer) {
-                *take_lock = _gf_false;
-                if (gf_timer_call_cancel (this->ctx,
-                                          lock->delay_timer)) {
-                        list_add_tail (&local->transaction.wait_list,
-                                       &lock->frozen);
-                } else {
-                        *timer_local = list_entry(lock->post_op.next,
-                                                  afr_local_t,
-                                                  transaction.owner_list);
-                        afr_copy_inodelk_vars (&local->internal_lock,
-                                               &(*timer_local)->internal_lock,
-                                               this);
-                        lock->delay_timer = NULL;
-                        *do_pre_op = _gf_true;
-                        list_add_tail (&local->transaction.owner_list,
-                                       &lock->owners);
-                }
-                goto out;
-        }
-
-        if (!list_empty (&lock->owners)) {
-                if (!lock->acquired ||
-                    afr_has_lock_conflict (local, _gf_true)) {
-                        list_add_tail (&local->transaction.wait_list,
-                                       &lock->waiting);
-                        *take_lock = _gf_false;
-                        goto out;
-                }
-                owner_local = list_entry (lock->owners.next,
-                                          afr_local_t,
+__afr_eager_lock_handle(afr_local_t *local, gf_boolean_t *take_lock,
+                        gf_boolean_t *do_pre_op, afr_local_t **timer_local)
+{
+    afr_lock_t *lock = NULL;
+    afr_local_t *owner_local = NULL;
+    xlator_t *this = local->transaction.frame->this;
+
+    if (local->fd && !afr_are_multiple_fds_opened(local, this)) {
+        local->transaction.eager_lock_on = _gf_true;
+        afr_set_lk_owner(local->transaction.frame, this, local->inode);
+    }
+
+    lock = &local->inode_ctx->lock[local->transaction.type];
+    if (__need_previous_lock_unlocked(local)) {
+        if (!list_empty(&lock->owners)) {
+            lock->release = _gf_true;
+        } else if (lock->delay_timer) {
+            lock->release = _gf_true;
+            if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+                /* It will be put in frozen list
+                 * in the code flow below*/
+            } else {
+                *timer_local = list_entry(lock->post_op.next, afr_local_t,
                                           transaction.owner_list);
-                afr_copy_inodelk_vars (&local->internal_lock,
-                                       &owner_local->internal_lock,
-                                       this);
-                *take_lock = _gf_false;
-                *do_pre_op = _gf_true;
+                lock->delay_timer = NULL;
+            }
         }
-
-        if (lock->acquired)
-                GF_ASSERT (!(*take_lock));
-        list_add_tail (&local->transaction.owner_list, &lock->owners);
+        if (!local->transaction.eager_lock_on)
+            goto out;
+    }
+
+    if (lock->release) {
+        list_add_tail(&local->transaction.wait_list, &lock->frozen);
+        *take_lock = _gf_false;
+        goto out;
+    }
+
+    if (lock->delay_timer) {
+        *take_lock = _gf_false;
+        if (gf_timer_call_cancel(this->ctx, lock->delay_timer)) {
+            list_add_tail(&local->transaction.wait_list, &lock->frozen);
+        } else {
+            *timer_local = list_entry(lock->post_op.next, afr_local_t,
+                                      transaction.owner_list);
+            afr_copy_inodelk_vars(&local->internal_lock,
+                                  &(*timer_local)->internal_lock, this);
+            lock->delay_timer = NULL;
+            *do_pre_op = _gf_true;
+            list_add_tail(&local->transaction.owner_list, &lock->owners);
+        }
+        goto out;
+    }
+
+    if (!list_empty(&lock->owners)) {
+        if (!lock->acquired || afr_has_lock_conflict(local, _gf_true)) {
+            list_add_tail(&local->transaction.wait_list, &lock->waiting);
+            *take_lock = _gf_false;
+            goto out;
+        }
+        owner_local = list_entry(lock->owners.next, afr_local_t,
+                                 transaction.owner_list);
+        afr_copy_inodelk_vars(&local->internal_lock,
+                              &owner_local->internal_lock, this);
+        *take_lock = _gf_false;
+        *do_pre_op = _gf_true;
+    }
+
+    if (lock->acquired)
+        GF_ASSERT(!(*take_lock));
+    list_add_tail(&local->transaction.owner_list, &lock->owners);
 out:
-        return;
+    return;
 }
 
 void
-afr_transaction_start (afr_local_t *local, xlator_t *this)
+afr_transaction_start(afr_local_t *local, xlator_t *this)
 {
-        afr_private_t   *priv = NULL;
-        gf_boolean_t    take_lock  = _gf_true;
-        gf_boolean_t    do_pre_op  = _gf_false;
-        afr_local_t     *timer_local = NULL;
+    afr_private_t *priv = NULL;
+    gf_boolean_t take_lock = _gf_true;
+    gf_boolean_t do_pre_op = _gf_false;
+    afr_local_t *timer_local = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (local->transaction.type != AFR_DATA_TRANSACTION &&
-            local->transaction.type != AFR_METADATA_TRANSACTION)
-                goto lock_phase;
+    if (local->transaction.type != AFR_DATA_TRANSACTION &&
+        local->transaction.type != AFR_METADATA_TRANSACTION)
+        goto lock_phase;
 
-        if (!priv->eager_lock)
-                goto lock_phase;
+    if (!priv->eager_lock)
+        goto lock_phase;
 
-        LOCK (&local->inode->lock);
-        {
-                __afr_eager_lock_handle (local, &take_lock, &do_pre_op,
-                                         &timer_local);
-        }
-        UNLOCK (&local->inode->lock);
+    LOCK(&local->inode->lock);
+    {
+        __afr_eager_lock_handle(local, &take_lock, &do_pre_op, &timer_local);
+    }
+    UNLOCK(&local->inode->lock);
 lock_phase:
-        if (!local->transaction.eager_lock_on) {
-                afr_set_lk_owner (local->transaction.frame, this,
-                                  local->transaction.frame->root);
-        }
-
-
-        if (take_lock) {
-                afr_lock (local->transaction.frame, this);
-        } else if (do_pre_op) {
-                afr_changelog_pre_op (local->transaction.frame, this);
-        }
-        /*Always call delayed_changelog_wake_up_cbk after calling pre-op above
-         * so that any inheriting can happen*/
-        if (timer_local)
-                afr_delayed_changelog_wake_up_cbk (timer_local);
+    if (!local->transaction.eager_lock_on) {
+        afr_set_lk_owner(local->transaction.frame, this,
+                         local->transaction.frame->root);
+    }
+
+    if (take_lock) {
+        afr_lock(local->transaction.frame, this);
+    } else if (do_pre_op) {
+        afr_changelog_pre_op(local->transaction.frame, this);
+    }
+    /*Always call delayed_changelog_wake_up_cbk after calling pre-op above
+     * so that any inheriting can happen*/
+    if (timer_local)
+        afr_delayed_changelog_wake_up_cbk(timer_local);
 }
 
 int
-afr_write_txn_refresh_done (call_frame_t *frame, xlator_t *this, int err)
+afr_write_txn_refresh_done(call_frame_t *frame, xlator_t *this, int err)
 {
-        afr_local_t   *local           = frame->local;
+    afr_local_t *local = frame->local;
 
-        if (err) {
-                AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, err);
-                goto fail;
-        }
+    if (err) {
+        AFR_SET_ERROR_AND_CHECK_SPLIT_BRAIN(-1, err);
+        goto fail;
+    }
 
-        afr_transaction_start (local, this);
-        return 0;
+    afr_transaction_start(local, this);
+    return 0;
 fail:
-        local->transaction.unwind (frame, this);
-        AFR_STACK_DESTROY (frame);
-        return 0;
+    local->transaction.unwind(frame, this);
+    AFR_STACK_DESTROY(frame);
+    return 0;
 }
 
 int
-afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
-{
-        afr_local_t   *local           = NULL;
-        afr_private_t *priv            = NULL;
-        int           ret              = -1;
-        int           event_generation = 0;
-
-        local = frame->local;
-        priv  = this->private;
-        local->transaction.frame = frame;
-
-        local->transaction.type   = type;
-
-        if (priv->quorum_count && !afr_has_quorum (local->child_up, this)) {
-                ret = -afr_quorum_errno(priv);
-                goto out;
-        }
-
-        if (!afr_is_consistent_io_possible (local, priv, &ret)) {
-                ret = -ret; /*op_errno to ret conversion*/
-                goto out;
-        }
-
-        ret = afr_transaction_local_init (local, this);
-        if (ret < 0)
-                goto out;
-
-
-        if (type != AFR_METADATA_TRANSACTION) {
-                goto txn_start;
-        }
-
-        ret = afr_inode_get_readable (frame, local->inode, this,
-                                      local->readable, &event_generation, type);
-        if (ret < 0 || afr_is_inode_refresh_reqd (local->inode, this,
-                                                  priv->event_generation,
-                                                  event_generation)) {
-                afr_inode_refresh (frame, this, local->inode, local->loc.gfid,
-                                   afr_write_txn_refresh_done);
-                ret = 0;
-                goto out;
-        }
+afr_transaction(call_frame_t *frame, xlator_t *this, afr_transaction_type type)
+{
+    afr_local_t *local = NULL;
+    afr_private_t *priv = NULL;
+    int ret = -1;
+    int event_generation = 0;
+
+    local = frame->local;
+    priv = this->private;
+    local->transaction.frame = frame;
+
+    local->transaction.type = type;
+
+    if (priv->quorum_count && !afr_has_quorum(local->child_up, this)) {
+        ret = -afr_quorum_errno(priv);
+        goto out;
+    }
+
+    if (!afr_is_consistent_io_possible(local, priv, &ret)) {
+        ret = -ret; /*op_errno to ret conversion*/
+        goto out;
+    }
+
+    ret = afr_transaction_local_init(local, this);
+    if (ret < 0)
+        goto out;
+
+    if (type != AFR_METADATA_TRANSACTION) {
+        goto txn_start;
+    }
+
+    ret = afr_inode_get_readable(frame, local->inode, this, local->readable,
+                                 &event_generation, type);
+    if (ret < 0 ||
+        afr_is_inode_refresh_reqd(local->inode, this, priv->event_generation,
+                                  event_generation)) {
+        afr_inode_refresh(frame, this, local->inode, local->loc.gfid,
+                          afr_write_txn_refresh_done);
+        ret = 0;
+        goto out;
+    }
 
 txn_start:
-        ret = 0;
-        afr_transaction_start (local, this);
+    ret = 0;
+    afr_transaction_start(local, this);
 out:
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/afr/src/afr.c b/xlators/cluster/afr/src/afr.c
index bde9a97a4e7..568293cdf2c 100644
--- a/xlators/cluster/afr/src/afr.c
+++ b/xlators/cluster/afr/src/afr.c
@@ -21,1196 +21,1135 @@
 struct volume_options options[];
 
 static char *afr_favorite_child_policies[AFR_FAV_CHILD_POLICY_MAX + 1] = {
-        [AFR_FAV_CHILD_NONE] = "none",
-        [AFR_FAV_CHILD_BY_SIZE] = "size",
-        [AFR_FAV_CHILD_BY_CTIME] = "ctime",
-        [AFR_FAV_CHILD_BY_MTIME] = "mtime",
-        [AFR_FAV_CHILD_BY_MAJORITY] = "majority",
-        [AFR_FAV_CHILD_POLICY_MAX] = NULL,
+    [AFR_FAV_CHILD_NONE] = "none",
+    [AFR_FAV_CHILD_BY_SIZE] = "size",
+    [AFR_FAV_CHILD_BY_CTIME] = "ctime",
+    [AFR_FAV_CHILD_BY_MTIME] = "mtime",
+    [AFR_FAV_CHILD_BY_MAJORITY] = "majority",
+    [AFR_FAV_CHILD_POLICY_MAX] = NULL,
 };
 
 int32_t
-notify (xlator_t *this, int32_t event,
-        void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        int ret = -1;
-        va_list         ap;
-        void *data2 = NULL;
+    int ret = -1;
+    va_list ap;
+    void *data2 = NULL;
 
-        va_start (ap, data);
-        data2 = va_arg (ap, dict_t*);
-        va_end (ap);
-        ret = afr_notify (this, event, data, data2);
+    va_start(ap, data);
+    data2 = va_arg(ap, dict_t *);
+    va_end(ap);
+    ret = afr_notify(this, event, data, data2);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
-
-        if (!this)
-                return ret;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_afr_mt_end + 1);
+    if (!this)
+        return ret;
 
-        if (ret != 0) {
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_afr_mt_end + 1);
 
+    if (ret != 0) {
         return ret;
-}
+    }
 
+    return ret;
+}
 
 int
-xlator_subvolume_index (xlator_t *this, xlator_t *subvol)
+xlator_subvolume_index(xlator_t *this, xlator_t *subvol)
 {
-        int index = -1;
-        int i = 0;
-        xlator_list_t *list = NULL;
-
-        list = this->children;
-
-        while (list) {
-                if (subvol == list->xlator ||
-                    strcmp (subvol->name, list->xlator->name) == 0) {
-                        index = i;
-                        break;
-                }
-                list = list->next;
-                i++;
+    int index = -1;
+    int i = 0;
+    xlator_list_t *list = NULL;
+
+    list = this->children;
+
+    while (list) {
+        if (subvol == list->xlator ||
+            strcmp(subvol->name, list->xlator->name) == 0) {
+            index = i;
+            break;
         }
+        list = list->next;
+        i++;
+    }
 
-        return index;
+    return index;
 }
 
 static void
-fix_quorum_options (xlator_t *this, afr_private_t *priv, char *qtype,
-                    dict_t *options)
+fix_quorum_options(xlator_t *this, afr_private_t *priv, char *qtype,
+                   dict_t *options)
 {
-
-        if (dict_get (options, "quorum-type") == NULL) {
-                /* If user doesn't configure anything enable auto-quorum if the
-                 * replica has more than two subvolumes */
-                if (priv->child_count > 2)
-                        qtype = "auto";
-        }
-
-        if (priv->quorum_count && strcmp (qtype, "fixed")) {
-                gf_msg (this->name,GF_LOG_WARNING, 0, AFR_MSG_QUORUM_OVERRIDE,
-                       "quorum-type %s overriding quorum-count %u",
-                       qtype, priv->quorum_count);
-        }
-
-        if (!strcmp (qtype, "none")) {
-                priv->quorum_count = 0;
-        } else if (!strcmp (qtype, "auto")) {
-                priv->quorum_count = AFR_QUORUM_AUTO;
-        }
-
+    if (dict_get(options, "quorum-type") == NULL) {
+        /* If user doesn't configure anything enable auto-quorum if the
+         * replica has more than two subvolumes */
+        if (priv->child_count > 2)
+            qtype = "auto";
+    }
+
+    if (priv->quorum_count && strcmp(qtype, "fixed")) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_OVERRIDE,
+               "quorum-type %s overriding quorum-count %u", qtype,
+               priv->quorum_count);
+    }
+
+    if (!strcmp(qtype, "none")) {
+        priv->quorum_count = 0;
+    } else if (!strcmp(qtype, "auto")) {
+        priv->quorum_count = AFR_QUORUM_AUTO;
+    }
 }
 
 int
-afr_set_favorite_child_policy (afr_private_t *priv, char *policy)
+afr_set_favorite_child_policy(afr_private_t *priv, char *policy)
 {
-        int index = -1;
+    int index = -1;
 
-        index = gf_get_index_by_elem (afr_favorite_child_policies, policy);
-        if (index  < 0 || index >= AFR_FAV_CHILD_POLICY_MAX)
-                return -1;
+    index = gf_get_index_by_elem(afr_favorite_child_policies, policy);
+    if (index < 0 || index >= AFR_FAV_CHILD_POLICY_MAX)
+        return -1;
 
-        priv->fav_child_policy = index;
+    priv->fav_child_policy = index;
 
-        return 0;
+    return 0;
 }
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        afr_private_t *priv        = NULL;
-        xlator_t      *read_subvol = NULL;
-        int            read_subvol_index = -1;
-        int            ret         = -1;
-        int            index       = -1;
-        char          *qtype       = NULL;
-        char          *fav_child_policy = NULL;
-        gf_boolean_t   consistent_io = _gf_false;
-        gf_boolean_t   choose_local_old = _gf_false;
-
-        priv = this->private;
+    afr_private_t *priv = NULL;
+    xlator_t *read_subvol = NULL;
+    int read_subvol_index = -1;
+    int ret = -1;
+    int index = -1;
+    char *qtype = NULL;
+    char *fav_child_policy = NULL;
+    gf_boolean_t consistent_io = _gf_false;
+    gf_boolean_t choose_local_old = _gf_false;
 
-	GF_OPTION_RECONF ("afr-dirty-xattr",
-			  priv->afr_dirty, options, str,
-			  out);
+    priv = this->private;
 
-	GF_OPTION_RECONF ("metadata-splitbrain-forced-heal",
-			  priv->metadata_splitbrain_forced_heal, options, bool,
-			  out);
+    GF_OPTION_RECONF("afr-dirty-xattr", priv->afr_dirty, options, str, out);
 
-        GF_OPTION_RECONF ("background-self-heal-count",
-                          priv->background_self_heal_count, options, uint32,
-                          out);
+    GF_OPTION_RECONF("metadata-splitbrain-forced-heal",
+                     priv->metadata_splitbrain_forced_heal, options, bool, out);
 
-        GF_OPTION_RECONF ("heal-wait-queue-length",
-                          priv->heal_wait_qlen, options, uint32, out);
+    GF_OPTION_RECONF("background-self-heal-count",
+                     priv->background_self_heal_count, options, uint32, out);
 
+    GF_OPTION_RECONF("heal-wait-queue-length", priv->heal_wait_qlen, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("metadata-self-heal",
-                          priv->metadata_self_heal, options, bool, out);
+    GF_OPTION_RECONF("metadata-self-heal", priv->metadata_self_heal, options,
+                     bool, out);
 
-        GF_OPTION_RECONF ("data-self-heal", priv->data_self_heal, options, str,
-                          out);
+    GF_OPTION_RECONF("data-self-heal", priv->data_self_heal, options, str, out);
 
-        GF_OPTION_RECONF ("entry-self-heal", priv->entry_self_heal, options,
-                          bool, out);
+    GF_OPTION_RECONF("entry-self-heal", priv->entry_self_heal, options, bool,
+                     out);
 
-        GF_OPTION_RECONF ("data-self-heal-window-size",
-                          priv->data_self_heal_window_size, options,
-                          uint32, out);
+    GF_OPTION_RECONF("data-self-heal-window-size",
+                     priv->data_self_heal_window_size, options, uint32, out);
 
-        GF_OPTION_RECONF ("data-self-heal-algorithm",
-                          priv->data_self_heal_algorithm, options, str, out);
+    GF_OPTION_RECONF("data-self-heal-algorithm", priv->data_self_heal_algorithm,
+                     options, str, out);
 
-        GF_OPTION_RECONF ("halo-enabled",
-                          priv->halo_enabled, options, bool,
-                          out);
+    GF_OPTION_RECONF("halo-enabled", priv->halo_enabled, options, bool, out);
 
-        GF_OPTION_RECONF ("halo-shd-max-latency",
-                          priv->shd.halo_max_latency_msec, options, uint32,
-                          out);
+    GF_OPTION_RECONF("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
+                     options, uint32, out);
 
-        GF_OPTION_RECONF ("halo-nfsd-max-latency",
-                          priv->nfsd.halo_max_latency_msec, options, uint32,
-                          out);
+    GF_OPTION_RECONF("halo-nfsd-max-latency", priv->nfsd.halo_max_latency_msec,
+                     options, uint32, out);
 
-        GF_OPTION_RECONF ("halo-max-latency", priv->halo_max_latency_msec,
-                          options, uint32, out);
+    GF_OPTION_RECONF("halo-max-latency", priv->halo_max_latency_msec, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("halo-max-replicas", priv->halo_max_replicas, options,
-                              uint32, out);
+    GF_OPTION_RECONF("halo-max-replicas", priv->halo_max_replicas, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("halo-min-replicas", priv->halo_min_replicas, options,
-                              uint32, out);
+    GF_OPTION_RECONF("halo-min-replicas", priv->halo_min_replicas, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("read-subvolume", read_subvol, options, xlator, out);
+    GF_OPTION_RECONF("read-subvolume", read_subvol, options, xlator, out);
 
-        choose_local_old = priv->choose_local;
-        GF_OPTION_RECONF ("choose-local", priv->choose_local, options, bool,
-                          out);
+    choose_local_old = priv->choose_local;
+    GF_OPTION_RECONF("choose-local", priv->choose_local, options, bool, out);
 
-        if (choose_local_old != priv->choose_local) {
-                priv->read_child = -1;
-                if (choose_local_old == _gf_false)
-                        priv->did_discovery = _gf_false;
-        }
-
-        GF_OPTION_RECONF ("read-hash-mode", priv->hash_mode,
-                          options, uint32, out);
-
-        if (read_subvol) {
-                index = xlator_subvolume_index (this, read_subvol);
-                if (index == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL, "%s not a subvolume",
-                                read_subvol->name);
-                        goto out;
-                }
-                priv->read_child = index;
+    if (choose_local_old != priv->choose_local) {
+        priv->read_child = -1;
+        if (choose_local_old == _gf_false)
+            priv->did_discovery = _gf_false;
+    }
+
+    GF_OPTION_RECONF("read-hash-mode", priv->hash_mode, options, uint32, out);
+
+    if (read_subvol) {
+        index = xlator_subvolume_index(this, read_subvol);
+        if (index == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%s not a subvolume", read_subvol->name);
+            goto out;
         }
-
-        GF_OPTION_RECONF ("read-subvolume-index",read_subvol_index, options,int32,out);
-
-        if (read_subvol_index >-1) {
-                index=read_subvol_index;
-                if (index >= priv->child_count) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL,
-                                "%d not a subvolume-index", index);
-                        goto out;
-                }
-                priv->read_child = index;
+        priv->read_child = index;
+    }
+
+    GF_OPTION_RECONF("read-subvolume-index", read_subvol_index, options, int32,
+                     out);
+
+    if (read_subvol_index > -1) {
+        index = read_subvol_index;
+        if (index >= priv->child_count) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%d not a subvolume-index", index);
+            goto out;
         }
+        priv->read_child = index;
+    }
 
-        GF_OPTION_RECONF ("pre-op-compat", priv->pre_op_compat, options, bool,
-                          out);
-        GF_OPTION_RECONF ("locking-scheme", priv->locking_scheme, options, str,
-                          out);
-        GF_OPTION_RECONF ("full-lock", priv->full_lock, options, bool, out);
-        GF_OPTION_RECONF ("granular-entry-heal", priv->esh_granular, options,
-                          bool, out);
+    GF_OPTION_RECONF("pre-op-compat", priv->pre_op_compat, options, bool, out);
+    GF_OPTION_RECONF("locking-scheme", priv->locking_scheme, options, str, out);
+    GF_OPTION_RECONF("full-lock", priv->full_lock, options, bool, out);
+    GF_OPTION_RECONF("granular-entry-heal", priv->esh_granular, options, bool,
+                     out);
 
-        GF_OPTION_RECONF ("eager-lock", priv->eager_lock, options, bool, out);
-        GF_OPTION_RECONF ("quorum-type", qtype, options, str, out);
-        GF_OPTION_RECONF ("quorum-count", priv->quorum_count, options,
-                          uint32, out);
-        fix_quorum_options (this, priv, qtype, options);
-        if (priv->quorum_count && !afr_has_quorum (priv->child_up, this))
-                gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
-                        "Client-quorum is not met");
+    GF_OPTION_RECONF("eager-lock", priv->eager_lock, options, bool, out);
+    GF_OPTION_RECONF("quorum-type", qtype, options, str, out);
+    GF_OPTION_RECONF("quorum-count", priv->quorum_count, options, uint32, out);
+    fix_quorum_options(this, priv, qtype, options);
+    if (priv->quorum_count && !afr_has_quorum(priv->child_up, this))
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_QUORUM_FAIL,
+               "Client-quorum is not met");
 
+    GF_OPTION_RECONF("post-op-delay-secs", priv->post_op_delay_secs, options,
+                     uint32, out);
 
-	GF_OPTION_RECONF ("post-op-delay-secs", priv->post_op_delay_secs, options,
-			  uint32, out);
+    GF_OPTION_RECONF(AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, options,
+                     size_uint64, out);
+    /* Reset this so we re-discover in case the topology changed.  */
+    GF_OPTION_RECONF("ensure-durability", priv->ensure_durability, options,
+                     bool, out);
 
-        GF_OPTION_RECONF (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size,
-                          options, size_uint64, out);
-        /* Reset this so we re-discover in case the topology changed.  */
-        GF_OPTION_RECONF ("ensure-durability", priv->ensure_durability, options,
-                          bool, out);
+    GF_OPTION_RECONF("self-heal-daemon", priv->shd.enabled, options, bool, out);
 
-	GF_OPTION_RECONF ("self-heal-daemon", priv->shd.enabled, options,
-			  bool, out);
+    GF_OPTION_RECONF("iam-self-heal-daemon", priv->shd.iamshd, options, bool,
+                     out);
 
-	GF_OPTION_RECONF ("iam-self-heal-daemon", priv->shd.iamshd, options,
-			  bool, out);
+    GF_OPTION_RECONF("heal-timeout", priv->shd.timeout, options, int32, out);
 
-        GF_OPTION_RECONF ("heal-timeout", priv->shd.timeout, options,
-                          int32, out);
+    GF_OPTION_RECONF("consistent-metadata", priv->consistent_metadata, options,
+                     bool, out);
 
-        GF_OPTION_RECONF ("consistent-metadata", priv->consistent_metadata,
-                          options, bool, out);
+    GF_OPTION_RECONF("shd-max-threads", priv->shd.max_threads, options, uint32,
+                     out);
 
-        GF_OPTION_RECONF ("shd-max-threads", priv->shd.max_threads,
-                          options, uint32, out);
+    GF_OPTION_RECONF("shd-wait-qlength", priv->shd.wait_qlength, options,
+                     uint32, out);
 
-        GF_OPTION_RECONF ("shd-wait-qlength", priv->shd.wait_qlength,
-                          options, uint32, out);
-
-        GF_OPTION_RECONF ("favorite-child-policy", fav_child_policy, options,
-                          str, out);
-        if (afr_set_favorite_child_policy (priv, fav_child_policy) == -1)
-                goto out;
+    GF_OPTION_RECONF("favorite-child-policy", fav_child_policy, options, str,
+                     out);
+    if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
+        goto out;
 
-        priv->did_discovery = _gf_false;
+    priv->did_discovery = _gf_false;
 
-        GF_OPTION_RECONF ("consistent-io", consistent_io, options, bool, out);
-        if (priv->quorum_count != 0)
-                consistent_io = _gf_false;
-        priv->consistent_io = consistent_io;
+    GF_OPTION_RECONF("consistent-io", consistent_io, options, bool, out);
+    if (priv->quorum_count != 0)
+        consistent_io = _gf_false;
+    priv->consistent_io = consistent_io;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
-
+    return ret;
 }
 
 static int
-afr_pending_xattrs_init (afr_private_t *priv, xlator_t *this)
+afr_pending_xattrs_init(afr_private_t *priv, xlator_t *this)
 {
-        int ret = -1;
-        int i = 0;
-        char *ptr = NULL;
-        char *ptr1 = NULL;
-        char *xattrs_list = NULL;
-        xlator_list_t *trav = NULL;
-        int child_count = -1;
-
-        trav = this->children;
-        child_count = priv->child_count;
-        if (priv->thin_arbiter_count) {
-                /* priv->pending_key[THIN_ARBITER_BRICK_INDEX] is used as the
-                 * name of the thin arbiter file for persistence across add/
-                 * removal of DHT subvols.*/
-                child_count++;
-        }
+    int ret = -1;
+    int i = 0;
+    char *ptr = NULL;
+    char *ptr1 = NULL;
+    char *xattrs_list = NULL;
+    xlator_list_t *trav = NULL;
+    int child_count = -1;
+
+    trav = this->children;
+    child_count = priv->child_count;
+    if (priv->thin_arbiter_count) {
+        /* priv->pending_key[THIN_ARBITER_BRICK_INDEX] is used as the
+         * name of the thin arbiter file for persistence across add/
+         * removal of DHT subvols.*/
+        child_count++;
+    }
+
+    GF_OPTION_INIT("afr-pending-xattr", xattrs_list, str, out);
+    priv->pending_key = GF_CALLOC(sizeof(*priv->pending_key), child_count,
+                                  gf_afr_mt_char);
+    if (!priv->pending_key) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    if (!xattrs_list) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_NO_CHANGELOG,
+               "Unable to fetch afr-pending-xattr option from volfile."
+               " Falling back to using client translator names. ");
 
-        GF_OPTION_INIT ("afr-pending-xattr", xattrs_list, str, out);
-        priv->pending_key = GF_CALLOC (sizeof (*priv->pending_key),
-                                       child_count, gf_afr_mt_char);
-        if (!priv->pending_key) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        if (!xattrs_list) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, AFR_MSG_NO_CHANGELOG,
-                        "Unable to fetch afr-pending-xattr option from volfile."
-                        " Falling back to using client translator names. ");
-
-                while (i < child_count) {
-                        ret = gf_asprintf (&priv->pending_key[i], "%s.%s",
-                                           AFR_XATTR_PREFIX,
-                                           trav->xlator->name);
-                        if (ret == -1) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                        trav = trav->next;
-                        i++;
-                }
-                ret = 0;
-                goto out;
-        }
-
-        ptr = ptr1 = gf_strdup (xattrs_list);
-        if (!ptr) {
+        while (i < child_count) {
+            ret = gf_asprintf(&priv->pending_key[i], "%s.%s", AFR_XATTR_PREFIX,
+                              trav->xlator->name);
+            if (ret == -1) {
                 ret = -ENOMEM;
                 goto out;
-        }
-        for (i = 0, ptr = strtok (ptr, ","); ptr; ptr = strtok (NULL, ",")) {
-                ret = gf_asprintf (&priv->pending_key[i], "%s.%s",
-                                   AFR_XATTR_PREFIX, ptr);
-                if (ret == -1) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
-                i++;
+            }
+            trav = trav->next;
+            i++;
         }
         ret = 0;
+        goto out;
+    }
+
+    ptr = ptr1 = gf_strdup(xattrs_list);
+    if (!ptr) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    for (i = 0, ptr = strtok(ptr, ","); ptr; ptr = strtok(NULL, ",")) {
+        ret = gf_asprintf(&priv->pending_key[i], "%s.%s", AFR_XATTR_PREFIX,
+                          ptr);
+        if (ret == -1) {
+            ret = -ENOMEM;
+            goto out;
+        }
+        i++;
+    }
+    ret = 0;
 
 out:
-        GF_FREE (ptr1);
-        return ret;
-
+    GF_FREE(ptr1);
+    return ret;
 }
 
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        afr_private_t *priv        = NULL;
-        int            child_count = 0;
-        xlator_list_t *trav        = NULL;
-        int            i           = 0;
-        int            ret         = -1;
-        GF_UNUSED int  op_errno    = 0;
-        xlator_t      *read_subvol = NULL;
-        int            read_subvol_index = -1;
-        char          *qtype       = NULL;
-        char          *fav_child_policy = NULL;
-        char          *thin_arbiter = NULL;
-
-        if (!this->children) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        AFR_MSG_CHILD_MISCONFIGURED,
-                        "replicate translator needs more than one "
-                        "subvolume defined.");
-                return -1;
-        }
-
-        if (!this->parents) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        AFR_MSG_VOL_MISCONFIGURED, "Volume is dangling.");
-        }
-
-	this->private = GF_CALLOC (1, sizeof (afr_private_t),
-                                   gf_afr_mt_afr_private_t);
-        if (!this->private)
-                goto out;
-
-        priv = this->private;
-        LOCK_INIT (&priv->lock);
-
-        child_count = xlator_subvolume_count (this);
-
-        priv->child_count = child_count;
-
-        priv->read_child = -1;
-
-        GF_OPTION_INIT ("arbiter-count", priv->arbiter_count, uint32, out);
-        GF_OPTION_INIT ("thin-arbiter", thin_arbiter, str, out);
-        if (thin_arbiter && strlen(thin_arbiter) > 0) {
-                priv->thin_arbiter_count = 1;
-                priv->child_count--;
-                priv->ta_bad_child_index = AFR_CHILD_UNKNOWN;
-                priv->ta_notify_dom_lock_offset = 0;
+    afr_private_t *priv = NULL;
+    int child_count = 0;
+    xlator_list_t *trav = NULL;
+    int i = 0;
+    int ret = -1;
+    GF_UNUSED int op_errno = 0;
+    xlator_t *read_subvol = NULL;
+    int read_subvol_index = -1;
+    char *qtype = NULL;
+    char *fav_child_policy = NULL;
+    char *thin_arbiter = NULL;
+
+    if (!this->children) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_CHILD_MISCONFIGURED,
+               "replicate translator needs more than one "
+               "subvolume defined.");
+        return -1;
+    }
+
+    if (!this->parents) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, AFR_MSG_VOL_MISCONFIGURED,
+               "Volume is dangling.");
+    }
+
+    this->private = GF_CALLOC(1, sizeof(afr_private_t),
+                              gf_afr_mt_afr_private_t);
+    if (!this->private)
+        goto out;
+
+    priv = this->private;
+    LOCK_INIT(&priv->lock);
+
+    child_count = xlator_subvolume_count(this);
+
+    priv->child_count = child_count;
+
+    priv->read_child = -1;
+
+    GF_OPTION_INIT("arbiter-count", priv->arbiter_count, uint32, out);
+    GF_OPTION_INIT("thin-arbiter", thin_arbiter, str, out);
+    if (thin_arbiter && strlen(thin_arbiter) > 0) {
+        priv->thin_arbiter_count = 1;
+        priv->child_count--;
+        priv->ta_bad_child_index = AFR_CHILD_UNKNOWN;
+        priv->ta_notify_dom_lock_offset = 0;
+    }
+    INIT_LIST_HEAD(&priv->healing);
+    INIT_LIST_HEAD(&priv->heal_waiting);
+
+    priv->spb_choice_timeout = AFR_DEFAULT_SPB_CHOICE_TIMEOUT;
+
+    GF_OPTION_INIT("afr-dirty-xattr", priv->afr_dirty, str, out);
+
+    GF_OPTION_INIT("metadata-splitbrain-forced-heal",
+                   priv->metadata_splitbrain_forced_heal, bool, out);
+
+    GF_OPTION_INIT("read-subvolume", read_subvol, xlator, out);
+    if (read_subvol) {
+        priv->read_child = xlator_subvolume_index(this, read_subvol);
+        if (priv->read_child == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%s not a subvolume", read_subvol->name);
+            goto out;
         }
-        INIT_LIST_HEAD (&priv->healing);
-        INIT_LIST_HEAD (&priv->heal_waiting);
-
-        priv->spb_choice_timeout = AFR_DEFAULT_SPB_CHOICE_TIMEOUT;
-
-	GF_OPTION_INIT ("afr-dirty-xattr", priv->afr_dirty, str, out);
-
-	GF_OPTION_INIT ("metadata-splitbrain-forced-heal",
-			priv->metadata_splitbrain_forced_heal, bool, out);
-
-        GF_OPTION_INIT ("read-subvolume", read_subvol, xlator, out);
-        if (read_subvol) {
-                priv->read_child = xlator_subvolume_index (this, read_subvol);
-                if (priv->read_child == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL, "%s not a subvolume",
-                                read_subvol->name);
-                        goto out;
-                }
-        }
-        GF_OPTION_INIT ("read-subvolume-index",read_subvol_index,int32,out);
-        if (read_subvol_index > -1) {
-                if (read_subvol_index >= priv->child_count) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                AFR_MSG_INVALID_SUBVOL,
-                                "%d not a subvolume-index", read_subvol_index);
-                        goto out;
-                }
-                priv->read_child = read_subvol_index;
+    }
+    GF_OPTION_INIT("read-subvolume-index", read_subvol_index, int32, out);
+    if (read_subvol_index > -1) {
+        if (read_subvol_index >= priv->child_count) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, AFR_MSG_INVALID_SUBVOL,
+                   "%d not a subvolume-index", read_subvol_index);
+            goto out;
         }
-        GF_OPTION_INIT ("choose-local", priv->choose_local, bool, out);
-
-        priv->pending_reads = GF_CALLOC (sizeof(*priv->pending_reads),
-                                         priv->child_count, gf_afr_mt_atomic_t);
-
-        GF_OPTION_INIT ("read-hash-mode", priv->hash_mode, uint32, out);
+        priv->read_child = read_subvol_index;
+    }
+    GF_OPTION_INIT("choose-local", priv->choose_local, bool, out);
 
-        priv->favorite_child = -1;
+    priv->pending_reads = GF_CALLOC(sizeof(*priv->pending_reads),
+                                    priv->child_count, gf_afr_mt_atomic_t);
 
-        GF_OPTION_INIT ("favorite-child-policy", fav_child_policy, str, out);
-        if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
-                goto out;
-
-        GF_OPTION_INIT ("shd-max-threads", priv->shd.max_threads,
-                         uint32, out);
-
-        GF_OPTION_INIT ("shd-wait-qlength", priv->shd.wait_qlength,
-                         uint32, out);
+    GF_OPTION_INIT("read-hash-mode", priv->hash_mode, uint32, out);
 
-        GF_OPTION_INIT ("background-self-heal-count",
-                        priv->background_self_heal_count, uint32, out);
+    priv->favorite_child = -1;
 
-        GF_OPTION_INIT ("heal-wait-queue-length",
-                        priv->heal_wait_qlen, uint32, out);
+    GF_OPTION_INIT("favorite-child-policy", fav_child_policy, str, out);
+    if (afr_set_favorite_child_policy(priv, fav_child_policy) == -1)
+        goto out;
 
-        GF_OPTION_INIT ("data-self-heal", priv->data_self_heal, str, out);
+    GF_OPTION_INIT("shd-max-threads", priv->shd.max_threads, uint32, out);
 
-        GF_OPTION_INIT ("data-self-heal-algorithm",
-                        priv->data_self_heal_algorithm, str, out);
+    GF_OPTION_INIT("shd-wait-qlength", priv->shd.wait_qlength, uint32, out);
 
-        GF_OPTION_INIT ("data-self-heal-window-size",
-                        priv->data_self_heal_window_size, uint32, out);
+    GF_OPTION_INIT("background-self-heal-count",
+                   priv->background_self_heal_count, uint32, out);
 
-        GF_OPTION_INIT ("metadata-self-heal", priv->metadata_self_heal, bool,
-                        out);
+    GF_OPTION_INIT("heal-wait-queue-length", priv->heal_wait_qlen, uint32, out);
 
-        GF_OPTION_INIT ("entry-self-heal", priv->entry_self_heal, bool, out);
+    GF_OPTION_INIT("data-self-heal", priv->data_self_heal, str, out);
 
-        GF_OPTION_INIT ("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
-                        uint32, out);
+    GF_OPTION_INIT("data-self-heal-algorithm", priv->data_self_heal_algorithm,
+                   str, out);
 
-        GF_OPTION_INIT ("halo-max-latency", priv->halo_max_latency_msec,
-                        uint32, out);
-        GF_OPTION_INIT ("halo-max-replicas", priv->halo_max_replicas, uint32,
-                        out);
-        GF_OPTION_INIT ("halo-min-replicas", priv->halo_min_replicas, uint32,
-                        out);
+    GF_OPTION_INIT("data-self-heal-window-size",
+                   priv->data_self_heal_window_size, uint32, out);
 
-        GF_OPTION_INIT ("halo-enabled",
-                        priv->halo_enabled, bool, out);
+    GF_OPTION_INIT("metadata-self-heal", priv->metadata_self_heal, bool, out);
 
-        GF_OPTION_INIT ("halo-nfsd-max-latency",
-                        priv->nfsd.halo_max_latency_msec, uint32, out);
+    GF_OPTION_INIT("entry-self-heal", priv->entry_self_heal, bool, out);
 
-        GF_OPTION_INIT ("iam-nfs-daemon", priv->nfsd.iamnfsd, bool, out);
+    GF_OPTION_INIT("halo-shd-max-latency", priv->shd.halo_max_latency_msec,
+                   uint32, out);
 
-        GF_OPTION_INIT ("optimistic-change-log", priv->optimistic_change_log,
-                        bool, out);
+    GF_OPTION_INIT("halo-max-latency", priv->halo_max_latency_msec, uint32,
+                   out);
+    GF_OPTION_INIT("halo-max-replicas", priv->halo_max_replicas, uint32, out);
+    GF_OPTION_INIT("halo-min-replicas", priv->halo_min_replicas, uint32, out);
 
-        GF_OPTION_INIT ("pre-op-compat", priv->pre_op_compat, bool, out);
-        GF_OPTION_INIT ("locking-scheme", priv->locking_scheme, str, out);
-        GF_OPTION_INIT ("full-lock", priv->full_lock, bool, out);
-        GF_OPTION_INIT ("granular-entry-heal", priv->esh_granular, bool, out);
+    GF_OPTION_INIT("halo-enabled", priv->halo_enabled, bool, out);
 
-        GF_OPTION_INIT ("eager-lock", priv->eager_lock, bool, out);
-        GF_OPTION_INIT ("quorum-type", qtype, str, out);
-        GF_OPTION_INIT ("quorum-count", priv->quorum_count, uint32, out);
-        GF_OPTION_INIT (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size_uint64,
-                        out);
-        fix_quorum_options (this, priv, qtype, this->options);
+    GF_OPTION_INIT("halo-nfsd-max-latency", priv->nfsd.halo_max_latency_msec,
+                   uint32, out);
 
-	GF_OPTION_INIT ("post-op-delay-secs", priv->post_op_delay_secs, uint32, out);
-        GF_OPTION_INIT ("ensure-durability", priv->ensure_durability, bool,
-                        out);
+    GF_OPTION_INIT("iam-nfs-daemon", priv->nfsd.iamnfsd, bool, out);
 
-	GF_OPTION_INIT ("self-heal-daemon", priv->shd.enabled, bool, out);
+    GF_OPTION_INIT("optimistic-change-log", priv->optimistic_change_log, bool,
+                   out);
 
-	GF_OPTION_INIT ("iam-self-heal-daemon", priv->shd.iamshd, bool, out);
-        GF_OPTION_INIT ("heal-timeout", priv->shd.timeout, int32, out);
+    GF_OPTION_INIT("pre-op-compat", priv->pre_op_compat, bool, out);
+    GF_OPTION_INIT("locking-scheme", priv->locking_scheme, str, out);
+    GF_OPTION_INIT("full-lock", priv->full_lock, bool, out);
+    GF_OPTION_INIT("granular-entry-heal", priv->esh_granular, bool, out);
 
-        GF_OPTION_INIT ("consistent-metadata", priv->consistent_metadata, bool,
-                        out);
-        GF_OPTION_INIT ("consistent-io", priv->consistent_io, bool, out);
+    GF_OPTION_INIT("eager-lock", priv->eager_lock, bool, out);
+    GF_OPTION_INIT("quorum-type", qtype, str, out);
+    GF_OPTION_INIT("quorum-count", priv->quorum_count, uint32, out);
+    GF_OPTION_INIT(AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size_uint64,
+                   out);
+    fix_quorum_options(this, priv, qtype, this->options);
 
-        if (priv->quorum_count != 0)
-                priv->consistent_io = _gf_false;
+    GF_OPTION_INIT("post-op-delay-secs", priv->post_op_delay_secs, uint32, out);
+    GF_OPTION_INIT("ensure-durability", priv->ensure_durability, bool, out);
 
-        priv->wait_count = 1;
+    GF_OPTION_INIT("self-heal-daemon", priv->shd.enabled, bool, out);
 
-        priv->local = GF_CALLOC (sizeof (unsigned char), child_count,
-                                 gf_afr_mt_char);
-        if (!priv->local) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    GF_OPTION_INIT("iam-self-heal-daemon", priv->shd.iamshd, bool, out);
+    GF_OPTION_INIT("heal-timeout", priv->shd.timeout, int32, out);
 
-        priv->child_up = GF_CALLOC (sizeof (unsigned char), child_count,
-                                    gf_afr_mt_char);
+    GF_OPTION_INIT("consistent-metadata", priv->consistent_metadata, bool, out);
+    GF_OPTION_INIT("consistent-io", priv->consistent_io, bool, out);
 
-        priv->child_latency = GF_MALLOC (sizeof (*priv->child_latency)
-                                         * child_count,
-                                         gf_afr_mt_child_latency_t);
+    if (priv->quorum_count != 0)
+        priv->consistent_io = _gf_false;
 
-        if (!priv->child_up || !priv->child_latency) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        /*Initialize to -ve ping timeout so that they are not considered
-         * in child-up events until ping-event comes*/
-        for (i = 0; i < child_count; i++)
-                priv->child_latency[i] = -1;
-
-        priv->children = GF_CALLOC (sizeof (xlator_t *), child_count,
-                                    gf_afr_mt_xlator_t);
-        if (!priv->children) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    priv->wait_count = 1;
 
-        ret = afr_pending_xattrs_init (priv, this);
-        if (ret)
-                goto out;
+    priv->local = GF_CALLOC(sizeof(unsigned char), child_count, gf_afr_mt_char);
+    if (!priv->local) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        trav = this->children;
-        i = 0;
-        while (i < child_count) {
-                priv->children[i] = trav->xlator;
-                trav = trav->next;
-                i++;
-        }
+    priv->child_up = GF_CALLOC(sizeof(unsigned char), child_count,
+                               gf_afr_mt_char);
 
-        ret = gf_asprintf (&priv->sh_domain, AFR_SH_DATA_DOMAIN_FMT,
-                           this->name);
-        if (-1 == ret) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    priv->child_latency = GF_MALLOC(sizeof(*priv->child_latency) * child_count,
+                                    gf_afr_mt_child_latency_t);
 
-        priv->last_event = GF_CALLOC (child_count, sizeof (*priv->last_event),
-                                      gf_afr_mt_int32_t);
-        if (!priv->last_event) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    if (!priv->child_up || !priv->child_latency) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    /*Initialize to -ve ping timeout so that they are not considered
+     * in child-up events until ping-event comes*/
+    for (i = 0; i < child_count; i++)
+        priv->child_latency[i] = -1;
 
-	ret = afr_selfheal_daemon_init (this);
-	if (ret) {
-		ret = -ENOMEM;
-		goto out;
-	}
+    priv->children = GF_CALLOC(sizeof(xlator_t *), child_count,
+                               gf_afr_mt_xlator_t);
+    if (!priv->children) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        /* keep more local here as we may need them for self-heal etc */
-        this->local_pool = mem_pool_new (afr_local_t, 512);
-        if (!this->local_pool) {
-                ret = -1;
-                goto out;
-        }
+    ret = afr_pending_xattrs_init(priv, this);
+    if (ret)
+        goto out;
 
-        priv->root_inode = NULL;
+    trav = this->children;
+    i = 0;
+    while (i < child_count) {
+        priv->children[i] = trav->xlator;
+        trav = trav->next;
+        i++;
+    }
 
-        ret = 0;
+    ret = gf_asprintf(&priv->sh_domain, AFR_SH_DATA_DOMAIN_FMT, this->name);
+    if (-1 == ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    priv->last_event = GF_CALLOC(child_count, sizeof(*priv->last_event),
+                                 gf_afr_mt_int32_t);
+    if (!priv->last_event) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = afr_selfheal_daemon_init(this);
+    if (ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    /* keep more local here as we may need them for self-heal etc */
+    this->local_pool = mem_pool_new(afr_local_t, 512);
+    if (!this->local_pool) {
+        ret = -1;
+        goto out;
+    }
+
+    priv->root_inode = NULL;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        afr_private_t *priv = NULL;
-
-        priv = this->private;
-        LOCK (&priv->lock);
-        if (priv->timer != NULL) {
-                gf_timer_call_cancel(this->ctx, priv->timer);
-                priv->timer = NULL;
-        }
-        UNLOCK (&priv->lock);
-        this->private = NULL;
-        afr_priv_destroy (priv);
-        //if (this->itable);//I don't see any destroy func
-
-        return 0;
+    afr_private_t *priv = NULL;
+
+    priv = this->private;
+    LOCK(&priv->lock);
+    if (priv->timer != NULL) {
+        gf_timer_call_cancel(this->ctx, priv->timer);
+        priv->timer = NULL;
+    }
+    UNLOCK(&priv->lock);
+    this->private = NULL;
+    afr_priv_destroy(priv);
+    // if (this->itable);//I don't see any destroy func
+
+    return 0;
 }
 
-
 struct xlator_fops fops = {
-        .lookup      = afr_lookup,
-        .lk          = afr_lk,
-        .flush       = afr_flush,
-        .statfs      = afr_statfs,
-        .fsyncdir    = afr_fsyncdir,
-        .inodelk     = afr_inodelk,
-        .finodelk    = afr_finodelk,
-        .entrylk     = afr_entrylk,
-        .fentrylk    = afr_fentrylk,
-        .ipc         = afr_ipc,
-        .lease       = afr_lease,
-
-        /* inode read */
-        .access      = afr_access,
-        .stat        = afr_stat,
-        .fstat       = afr_fstat,
-        .readlink    = afr_readlink,
-        .getxattr    = afr_getxattr,
-        .fgetxattr   = afr_fgetxattr,
-        .readv       = afr_readv,
-
-        /* inode write */
-        .writev      = afr_writev,
-        .truncate    = afr_truncate,
-        .ftruncate   = afr_ftruncate,
-        .setxattr    = afr_setxattr,
-        .fsetxattr   = afr_fsetxattr,
-        .setattr     = afr_setattr,
-        .fsetattr    = afr_fsetattr,
-        .removexattr = afr_removexattr,
-        .fremovexattr = afr_fremovexattr,
-        .fallocate   = afr_fallocate,
-        .discard     = afr_discard,
-        .zerofill    = afr_zerofill,
-        .xattrop     = afr_xattrop,
-        .fxattrop    = afr_fxattrop,
-        .fsync       = afr_fsync,
-
-        /*inode open*/
-        .opendir     = afr_opendir,
-        .open        = afr_open,
-
-        /* dir read */
-        .readdir     = afr_readdir,
-        .readdirp    = afr_readdirp,
-
-        /* dir write */
-        .create      = afr_create,
-        .mknod       = afr_mknod,
-        .mkdir       = afr_mkdir,
-        .unlink      = afr_unlink,
-        .rmdir       = afr_rmdir,
-        .link        = afr_link,
-        .symlink     = afr_symlink,
-        .rename      = afr_rename,
+    .lookup = afr_lookup,
+    .lk = afr_lk,
+    .flush = afr_flush,
+    .statfs = afr_statfs,
+    .fsyncdir = afr_fsyncdir,
+    .inodelk = afr_inodelk,
+    .finodelk = afr_finodelk,
+    .entrylk = afr_entrylk,
+    .fentrylk = afr_fentrylk,
+    .ipc = afr_ipc,
+    .lease = afr_lease,
+
+    /* inode read */
+    .access = afr_access,
+    .stat = afr_stat,
+    .fstat = afr_fstat,
+    .readlink = afr_readlink,
+    .getxattr = afr_getxattr,
+    .fgetxattr = afr_fgetxattr,
+    .readv = afr_readv,
+
+    /* inode write */
+    .writev = afr_writev,
+    .truncate = afr_truncate,
+    .ftruncate = afr_ftruncate,
+    .setxattr = afr_setxattr,
+    .fsetxattr = afr_fsetxattr,
+    .setattr = afr_setattr,
+    .fsetattr = afr_fsetattr,
+    .removexattr = afr_removexattr,
+    .fremovexattr = afr_fremovexattr,
+    .fallocate = afr_fallocate,
+    .discard = afr_discard,
+    .zerofill = afr_zerofill,
+    .xattrop = afr_xattrop,
+    .fxattrop = afr_fxattrop,
+    .fsync = afr_fsync,
+
+    /*inode open*/
+    .opendir = afr_opendir,
+    .open = afr_open,
+
+    /* dir read */
+    .readdir = afr_readdir,
+    .readdirp = afr_readdirp,
+
+    /* dir write */
+    .create = afr_create,
+    .mknod = afr_mknod,
+    .mkdir = afr_mkdir,
+    .unlink = afr_unlink,
+    .rmdir = afr_rmdir,
+    .link = afr_link,
+    .symlink = afr_symlink,
+    .rename = afr_rename,
 };
 
-
 struct xlator_dumpops dumpops = {
-        .priv       = afr_priv_dump,
+    .priv = afr_priv_dump,
 };
 
-
 struct xlator_cbks cbks = {
-        .release     = afr_release,
-        .releasedir  = afr_releasedir,
-        .forget      = afr_forget,
+    .release = afr_release,
+    .releasedir = afr_releasedir,
+    .forget = afr_forget,
 };
 
-
 struct volume_options options[] = {
-        { .key  = {"read-subvolume" },
-          .type = GF_OPTION_TYPE_XLATOR,
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. Afr will prefer the one specified using "
-                         "this option if it is not stale. Option value must be "
-                         "one of the xlator names of the children. "
-                         "Ex: <volname>-client-0 till "
-                         "<volname>-client-<number-of-bricks - 1>"
-        },
-        { .key  = {"read-subvolume-index" },
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "-1",
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. AFR will prefer the one specified using "
-                         "this option if it is not stale. allowed options"
-                         " include -1 till replica-count - 1"
-        },
-        { .key = {"read-hash-mode" },
-          .type = GF_OPTION_TYPE_INT,
-          .min = 0,
-          .max = 3,
-          .default_value = "1",
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "inode-read fops happen only on one of the bricks in "
-                         "replicate. AFR will prefer the one computed using "
-                         "the method specified using this option.\n"
-                         "0 = first readable child of AFR, starting from 1st child.\n"
-                         "1 = hash by GFID of file (all clients use "
-                                                    "same subvolume).\n"
-                         "2 = hash by GFID of file and client PID.\n"
-                         "3 = brick having the least outstanding read requests."
-        },
-        { .key  = {"choose-local" },
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "true",
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Choose a local subvolume (i.e. Brick) to read from"
-	                 " if read-subvolume is not explicitly set.",
-        },
-        { .key  = {"background-self-heal-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = 256,
-          .default_value = "8",
-          .validate = GF_OPT_VALIDATE_MIN,
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This specifies the number of per client self-heal "
-                         "jobs that can perform parallel heals in the "
-                         "background."
-        },
-        { .key   = {"halo-shd-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "99999",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "Maximum latency for shd halo replication in msec."
-        },
-        { .key   = {"halo-enabled"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "False",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "Enable Halo (geo) replication mode."
-        },
-        { .key   = {"halo-nfsd-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "5",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "Maximum latency for nfsd halo replication in msec."
-        },
-        { .key   = {"halo-max-latency"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = AFR_HALO_MAX_LATENCY,
-          .default_value = "5",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "Maximum latency for halo replication in msec."
-        },
-        { .key   = {"halo-max-replicas"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "99999",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "The maximum number of halo replicas; replicas"
-                          " beyond this value will be written asynchronously"
-                          "via the SHD."
-        },
-        { .key   = {"halo-min-replicas"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 99999,
-          .default_value = "2",
-          .op_version = {GD_OP_VERSION_3_11_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate", "halo"},
-          .description = "The minimmum number of halo replicas, before adding "
-                          "out of region replicas."
-         },
-         { .key  = {"heal-wait-queue-length"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = 10000, /*Around 100MB with sizeof(afr_local_t)= 10496 bytes*/
-          .default_value = "128",
-          .validate = GF_OPT_VALIDATE_MIN,
-          .op_version = {GD_OP_VERSION_3_7_10},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This specifies the number of heals that can be queued"
-                         " for the parallel background self heal jobs."
-        },
-        { .key  = {"data-self-heal"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = {"1", "on", "yes", "true", "enable",
-                    "0", "off", "no", "false", "disable",
-                    "open"},
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description   = "Using this option we can enable/disable data "
-                           "self-heal on the file. \"open\" means data "
-                           "self-heal action will only be triggered by file "
-                           "open operations."
-        },
-        { .key  = {"data-self-heal-algorithm"},
-          .type = GF_OPTION_TYPE_STR,
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description   = "Select between \"full\", \"diff\". The "
-                           "\"full\" algorithm copies the entire file from "
-                           "source to sink. The \"diff\" algorithm copies to "
-                           "sink only those blocks whose checksums don't match "
-                           "with those of source. If no option is configured "
-                           "the option is chosen dynamically as follows: "
-                           "If the file does not exist on one of the sinks "
-                           "or empty file exists or if the source file size is "
-                           "about the same as page size the entire file will "
-                           "be read and written i.e \"full\" algo, "
-                           "otherwise \"diff\" algo is chosen.",
-          .value = { "diff", "full"}
-        },
-        { .key  = {"data-self-heal-window-size"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 1,
-          .max  = 1024,
-          .default_value = "1",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Maximum number blocks per file for which self-heal "
-                         "process would be applied simultaneously."
-        },
-        { .key  = {"metadata-self-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          /*.validate_fn = validate_replica*/
-          .description = "Using this option we can enable/disable metadata "
-                         "i.e. Permissions, ownerships, xattrs self-heal on "
-                         "the file/directory."
-        },
-        { .key  = {"entry-self-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          /*.validate_fn = validate_replica*/
-          .description = "Using this option we can enable/disable entry "
-                         "self-heal on the directory."
-        },
-        { .key  = {"data-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option exists only for backward compatibility "
-                         "and configuring it doesn't have any effect"
-        },
-        { .key  = {"metadata-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option exists only for backward compatibility "
-                         "and configuring it doesn't have any effect"
-        },
-        { .key  = {"entry-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option exists only for backward compatibility "
-                         "and configuring it doesn't have any effect"
-        },
-        { .key  = {"optimistic-change-log"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Entry/Metadata fops will not perform "
-                         "pre fop changelog operations in afr transaction "
-                         "if this option is enabled."
-        },
-        { .key = {"inodelk-trace"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Enabling this option logs inode lock/unlocks"
-        },
-        { .key = {"entrylk-trace"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Enabling this option logs entry lock/unlocks"
-        },
-	{ .key = {"pre-op-compat"},
-	  .type = GF_OPTION_TYPE_BOOL,
-	  .default_value = "on",
-	  .description = "Use separate pre-op xattrop() FOP rather than "
-	                 "overloading xdata of the OP"
-	},
-        { .key = {"eager-lock"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Enable/Disable eager lock for replica volume. "
-                         "Lock phase of a transaction has two sub-phases. "
-                         "First is an attempt to acquire locks in parallel by "
-                         "broadcasting non-blocking lock requests. If lock "
-                         "acquisition fails on any server, then the held locks "
-                         "are unlocked and we revert to a blocking locks mode "
-                         "sequentially on one server after another.  If this "
-                         "option is enabled the initial broadcasting lock "
-                         "request attempts to acquire a full lock on the entire file. "
-                         "If this fails, we revert back to the sequential "
-                         "\"regional\" blocking locks as before. In the case "
-                         "where such an \"eager\" lock is granted in the "
-                         "non-blocking phase, it gives rise to an opportunity "
-                         "for optimization. i.e, if the next write transaction "
-                         "on the same FD arrives before the unlock phase of "
-                         "the first transaction, it \"takes over\" the full "
-                         "file lock. Similarly if yet another data transaction "
-                         "arrives before the unlock phase of the \"optimized\" "
-                         "transaction, that in turn \"takes over\" the lock as "
-                         "well. The actual unlock now happens at the end of "
-                         "the last \"optimized\" transaction."
-
-        },
-        { .key = {"self-heal-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-          .tags = {"replicate"},
-          /*.validate_fn   = validate_replica_heal_enable_disable*/
-          .description = "This option applies to only self-heal-daemon. "
-                         "Index directory crawl and automatic healing of files "
-                         "will not be performed if this option is turned off."
-        },
-        { .key = {"iam-self-heal-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option differentiates if the replicate "
-                         "translator is running as part of self-heal-daemon "
-                         "or not."
-        },
-        { .key = {"iam-nfs-daemon"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option differentiates if the replicate "
-                         "translator is running as part of an NFS daemon "
-                         "or not."
-        },
-        { .key = {"quorum-type"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = { "none", "auto", "fixed"},
-          .default_value = "none",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          /*.option = quorum-type*/
-          .description = "If value is \"fixed\" only allow writes if "
-                         "quorum-count bricks are present.  If value is "
-                         "\"auto\" only allow writes if more than half of "
-                         "bricks, or exactly half including the first, are "
-                         "present.",
-        },
-        { .key = {"quorum-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .min = 1,
-          .max = INT_MAX,
-          .default_value = 0,
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          /*.option = quorum-count*/
-          /*.validate_fn = validate_quorum_count*/
-          .description = "If quorum-type is \"fixed\" only allow writes if "
-                         "this many bricks are present.  Other quorum types "
-                         "will OVERWRITE this value.",
-        },
-        { .key = {"quorum-reads"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .op_version = {GD_OP_VERSION_3_7_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option has been removed. Reads are not allowed "
-                          "if quorum is not met.",
-        },
-        { .key  = {"node-uuid"},
-          .type = GF_OPTION_TYPE_STR,
-          .description = "Local glusterd uuid string, used in starting "
-                         "self-heal-daemon so that it can crawl only on "
-                         "local index directories.",
-        },
-        { .key  = {"post-op-delay-secs"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 0,
-          .max  = INT_MAX,
-          .default_value = "1",
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Time interval induced artificially before "
-	                 "post-operation phase of the transaction to "
-                         "enhance overlap of adjacent write operations.",
-        },
-        { .key = {AFR_SH_READDIR_SIZE_KEY},
-          .type = GF_OPTION_TYPE_SIZET,
-          .description = "readdirp size for performing entry self-heal",
-          .min = 1024,
-          .max = 131072,
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-          .tags = {"replicate"},
-          .default_value = "1KB",
-        },
-        { .key = {"ensure-durability"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .op_version = {3},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Afr performs fsyncs for transactions if this "
-                         "option is on to make sure the changelogs/data is "
-                         "written to the disk",
-          .default_value = "on",
-        },
-	{ .key = {"afr-dirty-xattr"},
-	  .type = GF_OPTION_TYPE_STR,
-	  .default_value = AFR_DIRTY_DEFAULT,
-	},
-	{ .key = {"afr-pending-xattr"},
-	  .type = GF_OPTION_TYPE_STR,
-          .description = "Comma separated list of xattrs that are used to  "
-                         "capture information on pending heals."
-	},
-	{ .key = {"metadata-splitbrain-forced-heal"},
-	  .type = GF_OPTION_TYPE_BOOL,
-	  .default_value = "off",
-	},
-        { .key  = {"heal-timeout"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 5,
-          .max  = INT_MAX,
-          .default_value = "600",
-          .op_version = {2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "time interval for checking the need to self-heal "
-                         "in self-heal-daemon"
-        },
-        { .key = {"consistent-metadata"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .op_version = {GD_OP_VERSION_3_7_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "If this option is enabled, readdirp will force "
-                         "lookups on those entries read whose read child is "
-                         "not the same as that of the parent. This will "
-                         "guarantee that all read operations on a file serve "
-                         "attributes from the same subvol as long as it holds "
-                         " a good copy of the file/dir.",
-        },
-        { .key = {"arbiter-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .description = "subset of child_count. Has to be 0 or 1."
-        },
-        { .key = {"thin-arbiter"},
-          .type = GF_OPTION_TYPE_STR,
-          .op_version = {GD_OP_VERSION_4_1_0},
-          .flags = OPT_FLAG_SETTABLE,
-          .tags = {"replicate"},
-          .description = "contains host:path of thin abriter brick",
-        },
-        { .key   = {"shd-max-threads"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 64,
-          .default_value = "1",
-          .op_version = {GD_OP_VERSION_3_7_12},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "Maximum number of parallel heals SHD can do per "
-                          "local brick. This can substantially lower heal times"
-                          ", but can also crush your bricks if you don't have "
-                          "the storage hardware to support this."
-        },
-        { .key   = {"shd-wait-qlength"},
-          .type  = GF_OPTION_TYPE_INT,
-          .min   = 1,
-          .max   = 655536,
-          .default_value = "1024",
-          .op_version = {GD_OP_VERSION_3_7_12},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option can be used to control number of heals"
-                          " that can wait in SHD per subvolume",
-        },
-        { .key = {"locking-scheme"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = { "full", "granular"},
-          .default_value = "full",
-          .op_version = {GD_OP_VERSION_3_7_12},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "If this option is set to granular, self-heal will "
-                         "stop being compatible with afr-v1, which helps afr "
-                         "be more granular while self-healing",
-        },
-        { .key = {"full-lock"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "yes",
-          .op_version = {GD_OP_VERSION_3_13_2},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-          .tags = {"replicate"},
-          .description = "If this option is disabled, then the IOs will take "
-                         "range locks same as versions till 3.13.1."
-        },
-        { .key = {"granular-entry-heal"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .op_version = {GD_OP_VERSION_3_8_0},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "If this option is enabled, self-heal will resort to "
-                         "granular way of recording changelogs and doing entry "
-                         "self-heal.",
-        },
-        { .key   = {"favorite-child-policy"},
-          .type  = GF_OPTION_TYPE_STR,
-          .value = {"none", "size", "ctime", "mtime", "majority"},
-          .default_value = "none",
-          .op_version = {GD_OP_VERSION_3_7_12},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option can be used to automatically resolve "
-                         "split-brains using various policies without user "
-                         "intervention. \"size\" picks the file with the "
-                         "biggest size as the source. \"ctime\" and \"mtime\" "
-                         "pick the file with the latest ctime and mtime "
-                         "respectively as the source. \"majority\" picks a file"
-                         " with identical mtime and size in more than half the "
-                         "number of bricks in the replica.",
-        },
-        { .key = {"consistent-io"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "If this option is enabled, i/o will fail even if "
-                         "one of the bricks is down in the replicas",
-        },
-        { .key   = {"use-compound-fops"},
-          .type  = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .op_version = {GD_OP_VERSION_3_8_4},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-          .tags = {"replicate"},
-          .description = "This option exists only for backward compatibility "
-                         "and configuring it doesn't have any effect"
-        },
-        { .key  = {NULL} },
+    {.key = {"read-subvolume"},
+     .type = GF_OPTION_TYPE_XLATOR,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "inode-read fops happen only on one of the bricks in "
+                    "replicate. Afr will prefer the one specified using "
+                    "this option if it is not stale. Option value must be "
+                    "one of the xlator names of the children. "
+                    "Ex: <volname>-client-0 till "
+                    "<volname>-client-<number-of-bricks - 1>"},
+    {.key = {"read-subvolume-index"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "-1",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "inode-read fops happen only on one of the bricks in "
+                    "replicate. AFR will prefer the one specified using "
+                    "this option if it is not stale. allowed options"
+                    " include -1 till replica-count - 1"},
+    {.key = {"read-hash-mode"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 3,
+     .default_value = "1",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description =
+         "inode-read fops happen only on one of the bricks in "
+         "replicate. AFR will prefer the one computed using "
+         "the method specified using this option.\n"
+         "0 = first readable child of AFR, starting from 1st child.\n"
+         "1 = hash by GFID of file (all clients use "
+         "same subvolume).\n"
+         "2 = hash by GFID of file and client PID.\n"
+         "3 = brick having the least outstanding read requests."},
+    {
+        .key = {"choose-local"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "true",
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Choose a local subvolume (i.e. Brick) to read from"
+                       " if read-subvolume is not explicitly set.",
+    },
+    {.key = {"background-self-heal-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 256,
+     .default_value = "8",
+     .validate = GF_OPT_VALIDATE_MIN,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This specifies the number of per client self-heal "
+                    "jobs that can perform parallel heals in the "
+                    "background."},
+    {.key = {"halo-shd-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "99999",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for shd halo replication in msec."},
+    {.key = {"halo-enabled"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "False",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Enable Halo (geo) replication mode."},
+    {.key = {"halo-nfsd-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "5",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for nfsd halo replication in msec."},
+    {.key = {"halo-max-latency"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = AFR_HALO_MAX_LATENCY,
+     .default_value = "5",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "Maximum latency for halo replication in msec."},
+    {.key = {"halo-max-replicas"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "99999",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "The maximum number of halo replicas; replicas"
+                    " beyond this value will be written asynchronously"
+                    "via the SHD."},
+    {.key = {"halo-min-replicas"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 99999,
+     .default_value = "2",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate", "halo"},
+     .description = "The minimmum number of halo replicas, before adding "
+                    "out of region replicas."},
+    {.key = {"heal-wait-queue-length"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 10000, /*Around 100MB with sizeof(afr_local_t)= 10496 bytes*/
+     .default_value = "128",
+     .validate = GF_OPT_VALIDATE_MIN,
+     .op_version = {GD_OP_VERSION_3_7_10},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This specifies the number of heals that can be queued"
+                    " for the parallel background self heal jobs."},
+    {.key = {"data-self-heal"},
+     .type = GF_OPTION_TYPE_STR,
+     .value = {"1", "on", "yes", "true", "enable", "0", "off", "no", "false",
+               "disable", "open"},
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Using this option we can enable/disable data "
+                    "self-heal on the file. \"open\" means data "
+                    "self-heal action will only be triggered by file "
+                    "open operations."},
+    {.key = {"data-self-heal-algorithm"},
+     .type = GF_OPTION_TYPE_STR,
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Select between \"full\", \"diff\". The "
+                    "\"full\" algorithm copies the entire file from "
+                    "source to sink. The \"diff\" algorithm copies to "
+                    "sink only those blocks whose checksums don't match "
+                    "with those of source. If no option is configured "
+                    "the option is chosen dynamically as follows: "
+                    "If the file does not exist on one of the sinks "
+                    "or empty file exists or if the source file size is "
+                    "about the same as page size the entire file will "
+                    "be read and written i.e \"full\" algo, "
+                    "otherwise \"diff\" algo is chosen.",
+     .value = {"diff", "full"}},
+    {.key = {"data-self-heal-window-size"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 1024,
+     .default_value = "1",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Maximum number blocks per file for which self-heal "
+                    "process would be applied simultaneously."},
+    {.key = {"metadata-self-heal"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     /*.validate_fn = validate_replica*/
+     .description = "Using this option we can enable/disable metadata "
+                    "i.e. Permissions, ownerships, xattrs self-heal on "
+                    "the file/directory."},
+    {.key = {"entry-self-heal"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     /*.validate_fn = validate_replica*/
+     .description = "Using this option we can enable/disable entry "
+                    "self-heal on the directory."},
+    {.key = {"data-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"metadata-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"entry-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {"optimistic-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Entry/Metadata fops will not perform "
+                    "pre fop changelog operations in afr transaction "
+                    "if this option is enabled."},
+    {.key = {"inodelk-trace"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Enabling this option logs inode lock/unlocks"},
+    {.key = {"entrylk-trace"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Enabling this option logs entry lock/unlocks"},
+    {.key = {"pre-op-compat"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Use separate pre-op xattrop() FOP rather than "
+                    "overloading xdata of the OP"},
+    {.key = {"eager-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description =
+         "Enable/Disable eager lock for replica volume. "
+         "Lock phase of a transaction has two sub-phases. "
+         "First is an attempt to acquire locks in parallel by "
+         "broadcasting non-blocking lock requests. If lock "
+         "acquisition fails on any server, then the held locks "
+         "are unlocked and we revert to a blocking locks mode "
+         "sequentially on one server after another.  If this "
+         "option is enabled the initial broadcasting lock "
+         "request attempts to acquire a full lock on the entire file. "
+         "If this fails, we revert back to the sequential "
+         "\"regional\" blocking locks as before. In the case "
+         "where such an \"eager\" lock is granted in the "
+         "non-blocking phase, it gives rise to an opportunity "
+         "for optimization. i.e, if the next write transaction "
+         "on the same FD arrives before the unlock phase of "
+         "the first transaction, it \"takes over\" the full "
+         "file lock. Similarly if yet another data transaction "
+         "arrives before the unlock phase of the \"optimized\" "
+         "transaction, that in turn \"takes over\" the lock as "
+         "well. The actual unlock now happens at the end of "
+         "the last \"optimized\" transaction."
+
+    },
+    {.key = {"self-heal-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {1},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+     .tags = {"replicate"},
+     /*.validate_fn   = validate_replica_heal_enable_disable*/
+     .description = "This option applies to only self-heal-daemon. "
+                    "Index directory crawl and automatic healing of files "
+                    "will not be performed if this option is turned off."},
+    {.key = {"iam-self-heal-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option differentiates if the replicate "
+                    "translator is running as part of self-heal-daemon "
+                    "or not."},
+    {.key = {"iam-nfs-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option differentiates if the replicate "
+                    "translator is running as part of an NFS daemon "
+                    "or not."},
+    {
+        .key = {"quorum-type"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"none", "auto", "fixed"},
+        .default_value = "none",
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        /*.option = quorum-type*/
+        .description = "If value is \"fixed\" only allow writes if "
+                       "quorum-count bricks are present.  If value is "
+                       "\"auto\" only allow writes if more than half of "
+                       "bricks, or exactly half including the first, are "
+                       "present.",
+    },
+    {
+        .key = {"quorum-count"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 1,
+        .max = INT_MAX,
+        .default_value = 0,
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        /*.option = quorum-count*/
+        /*.validate_fn = validate_quorum_count*/
+        .description = "If quorum-type is \"fixed\" only allow writes if "
+                       "this many bricks are present.  Other quorum types "
+                       "will OVERWRITE this value.",
+    },
+    {
+        .key = {"quorum-reads"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_7_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option has been removed. Reads are not allowed "
+                       "if quorum is not met.",
+    },
+    {
+        .key = {"node-uuid"},
+        .type = GF_OPTION_TYPE_STR,
+        .description = "Local glusterd uuid string, used in starting "
+                       "self-heal-daemon so that it can crawl only on "
+                       "local index directories.",
+    },
+    {
+        .key = {"post-op-delay-secs"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 0,
+        .max = INT_MAX,
+        .default_value = "1",
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Time interval induced artificially before "
+                       "post-operation phase of the transaction to "
+                       "enhance overlap of adjacent write operations.",
+    },
+    {
+        .key = {AFR_SH_READDIR_SIZE_KEY},
+        .type = GF_OPTION_TYPE_SIZET,
+        .description = "readdirp size for performing entry self-heal",
+        .min = 1024,
+        .max = 131072,
+        .op_version = {2},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+        .tags = {"replicate"},
+        .default_value = "1KB",
+    },
+    {
+        .key = {"ensure-durability"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .op_version = {3},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "Afr performs fsyncs for transactions if this "
+                       "option is on to make sure the changelogs/data is "
+                       "written to the disk",
+        .default_value = "on",
+    },
+    {
+        .key = {"afr-dirty-xattr"},
+        .type = GF_OPTION_TYPE_STR,
+        .default_value = AFR_DIRTY_DEFAULT,
+    },
+    {.key = {"afr-pending-xattr"},
+     .type = GF_OPTION_TYPE_STR,
+     .description = "Comma separated list of xattrs that are used to  "
+                    "capture information on pending heals."},
+    {
+        .key = {"metadata-splitbrain-forced-heal"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+    },
+    {.key = {"heal-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 5,
+     .max = INT_MAX,
+     .default_value = "600",
+     .op_version = {2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "time interval for checking the need to self-heal "
+                    "in self-heal-daemon"},
+    {
+        .key = {"consistent-metadata"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_7_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is enabled, readdirp will force "
+                       "lookups on those entries read whose read child is "
+                       "not the same as that of the parent. This will "
+                       "guarantee that all read operations on a file serve "
+                       "attributes from the same subvol as long as it holds "
+                       " a good copy of the file/dir.",
+    },
+    {.key = {"arbiter-count"},
+     .type = GF_OPTION_TYPE_INT,
+     .description = "subset of child_count. Has to be 0 or 1."},
+    {
+        .key = {"thin-arbiter"},
+        .type = GF_OPTION_TYPE_STR,
+        .op_version = {GD_OP_VERSION_4_1_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"replicate"},
+        .description = "contains host:path of thin abriter brick",
+    },
+    {.key = {"shd-max-threads"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 64,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_3_7_12},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "Maximum number of parallel heals SHD can do per "
+                    "local brick. This can substantially lower heal times"
+                    ", but can also crush your bricks if you don't have "
+                    "the storage hardware to support this."},
+    {
+        .key = {"shd-wait-qlength"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 1,
+        .max = 655536,
+        .default_value = "1024",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option can be used to control number of heals"
+                       " that can wait in SHD per subvolume",
+    },
+    {
+        .key = {"locking-scheme"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"full", "granular"},
+        .default_value = "full",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is set to granular, self-heal will "
+                       "stop being compatible with afr-v1, which helps afr "
+                       "be more granular while self-healing",
+    },
+    {.key = {"full-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "yes",
+     .op_version = {GD_OP_VERSION_3_13_2},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+     .tags = {"replicate"},
+     .description = "If this option is disabled, then the IOs will take "
+                    "range locks same as versions till 3.13.1."},
+    {
+        .key = {"granular-entry-heal"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .op_version = {GD_OP_VERSION_3_8_0},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "If this option is enabled, self-heal will resort to "
+                       "granular way of recording changelogs and doing entry "
+                       "self-heal.",
+    },
+    {
+        .key = {"favorite-child-policy"},
+        .type = GF_OPTION_TYPE_STR,
+        .value = {"none", "size", "ctime", "mtime", "majority"},
+        .default_value = "none",
+        .op_version = {GD_OP_VERSION_3_7_12},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+        .tags = {"replicate"},
+        .description = "This option can be used to automatically resolve "
+                       "split-brains using various policies without user "
+                       "intervention. \"size\" picks the file with the "
+                       "biggest size as the source. \"ctime\" and \"mtime\" "
+                       "pick the file with the latest ctime and mtime "
+                       "respectively as the source. \"majority\" picks a file"
+                       " with identical mtime and size in more than half the "
+                       "number of bricks in the replica.",
+    },
+    {
+        .key = {"consistent-io"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "no",
+        .description = "If this option is enabled, i/o will fail even if "
+                       "one of the bricks is down in the replicas",
+    },
+    {.key = {"use-compound-fops"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .op_version = {GD_OP_VERSION_3_8_4},
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"replicate"},
+     .description = "This option exists only for backward compatibility "
+                    "and configuring it doesn't have any effect"},
+    {.key = {NULL}},
 };
diff --git a/xlators/cluster/dht/src/dht-common.c b/xlators/cluster/dht/src/dht-common.c
index 129acbef0b5..f43a10bec2f 100644
--- a/xlators/cluster/dht/src/dht-common.c
+++ b/xlators/cluster/dht/src/dht-common.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
 
 #include "glusterfs.h"
@@ -27,258 +26,237 @@
 
 int run_defrag = 0;
 
-
-
-int dht_link2 (xlator_t *this, xlator_t *dst_node, call_frame_t *frame,
-               int ret);
-
 int
-dht_removexattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                  int ret);
+dht_link2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
 
 int
-dht_setxattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-               int ret);
-
+dht_removexattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame,
+                 int ret);
 
 int
-dht_rmdir_readdirp_do (call_frame_t *readdirp_frame, xlator_t *this);
-
+dht_setxattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
 
 int
-dht_common_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *dict,
-                        dict_t *xdata);
+dht_rmdir_readdirp_do(call_frame_t *readdirp_frame, xlator_t *this);
 
 int
-dht_set_file_xattr_req (xlator_t *this, loc_t *loc, dict_t *xattr_req);
+dht_common_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata);
 
 int
-dht_set_dir_xattr_req (xlator_t *this,  loc_t *loc, dict_t *xattr_req);
+dht_set_file_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req);
 
 int
-dht_do_fresh_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc);
+dht_set_dir_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req);
 
+int
+dht_do_fresh_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc);
 
 /* Sets the blocks and size values to fixed values. This is to be called
  * only for dirs. The caller is responsible for checking the type
  */
-int32_t dht_set_fixed_dir_stat (struct iatt *stat)
+int32_t
+dht_set_fixed_dir_stat(struct iatt *stat)
 {
-        if (stat) {
-                stat->ia_blocks = DHT_DIR_STAT_BLOCKS;
-                stat->ia_size = DHT_DIR_STAT_SIZE;
-                return 0;
-        }
-        return -1;
+    if (stat) {
+        stat->ia_blocks = DHT_DIR_STAT_BLOCKS;
+        stat->ia_size = DHT_DIR_STAT_SIZE;
+        return 0;
+    }
+    return -1;
 }
 
-
 /* Set both DHT_IATT_IN_XDATA_KEY and DHT_MODE_IN_XDATA_KEY
  * Use DHT_MODE_IN_XDATA_KEY if available. Else fall back to
  * DHT_IATT_IN_XDATA_KEY
  */
-int dht_request_iatt_in_xdata (xlator_t *this, dict_t *xattr_req)
+int
+dht_request_iatt_in_xdata(xlator_t *this, dict_t *xattr_req)
 {
-        int ret = -1;
+    int ret = -1;
 
-        ret = dict_set_int8 (xattr_req, DHT_MODE_IN_XDATA_KEY, 1);
-        ret = dict_set_int8 (xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+    ret = dict_set_int8(xattr_req, DHT_MODE_IN_XDATA_KEY, 1);
+    ret = dict_set_int8(xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
 
-        /* At least one call succeeded */
-        return ret;
+    /* At least one call succeeded */
+    return ret;
 }
 
-
 /* Get both DHT_IATT_IN_XDATA_KEY and DHT_MODE_IN_XDATA_KEY
  * Use DHT_MODE_IN_XDATA_KEY if available, else fall back to
  * DHT_IATT_IN_XDATA_KEY
  * This will return a dummy iatt with only the mode and type set
  */
-int dht_read_iatt_from_xdata (xlator_t *this, dict_t *xdata,
-                              struct iatt *stbuf)
+int
+dht_read_iatt_from_xdata(xlator_t *this, dict_t *xdata, struct iatt *stbuf)
 {
-        int ret = -1;
-        int32_t mode = 0;
+    int ret = -1;
+    int32_t mode = 0;
 
-        ret = dict_get_int32 (xdata, DHT_MODE_IN_XDATA_KEY, &mode);
+    ret = dict_get_int32(xdata, DHT_MODE_IN_XDATA_KEY, &mode);
 
-        if (ret) {
-                ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY,
-                                    (void **)&stbuf);
-        } else {
-                stbuf->ia_prot = ia_prot_from_st_mode (mode);
-                stbuf->ia_type = ia_type_from_st_mode (mode);
-        }
+    if (ret) {
+        ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+    } else {
+        stbuf->ia_prot = ia_prot_from_st_mode(mode);
+        stbuf->ia_type = ia_type_from_st_mode(mode);
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_rmdir_unlock (call_frame_t *frame, xlator_t *this);
-
-char *xattrs_to_heal[] = {
-        "user.",
-        POSIX_ACL_ACCESS_XATTR,
-        POSIX_ACL_DEFAULT_XATTR,
-        QUOTA_LIMIT_KEY,
-        QUOTA_LIMIT_OBJECTS_KEY,
-        GF_SELINUX_XATTR_KEY,
-        NULL
-};
+dht_rmdir_unlock(call_frame_t *frame, xlator_t *this);
 
+char *xattrs_to_heal[] = {"user.",
+                          POSIX_ACL_ACCESS_XATTR,
+                          POSIX_ACL_DEFAULT_XATTR,
+                          QUOTA_LIMIT_KEY,
+                          QUOTA_LIMIT_OBJECTS_KEY,
+                          GF_SELINUX_XATTR_KEY,
+                          NULL};
 
-char *dht_dbg_vxattrs[] = {
-        DHT_DBG_HASHED_SUBVOL_PATTERN,
-        NULL
-};
+char *dht_dbg_vxattrs[] = {DHT_DBG_HASHED_SUBVOL_PATTERN, NULL};
 
 /* Return true if key exists in array
-*/
+ */
 static gf_boolean_t
-dht_match_xattr (const char *key)
+dht_match_xattr(const char *key)
 {
-        return gf_get_index_by_elem (xattrs_to_heal, (char *)key) >= 0;
+    return gf_get_index_by_elem(xattrs_to_heal, (char *)key) >= 0;
 }
 
 int
-dht_aggregate_quota_xattr (dict_t *dst, char *key, data_t *value)
+dht_aggregate_quota_xattr(dict_t *dst, char *key, data_t *value)
 {
-        int              ret            = -1;
-        quota_meta_t    *meta_dst       = NULL;
-        quota_meta_t    *meta_src       = NULL;
-        int64_t         *size           = NULL;
-        int64_t          dst_dir_count  = 0;
-        int64_t          src_dir_count  = 0;
-
-        if (value == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DATA_NULL, "data value is NULL");
-                ret = -1;
-                goto out;
-        }
+    int ret = -1;
+    quota_meta_t *meta_dst = NULL;
+    quota_meta_t *meta_src = NULL;
+    int64_t *size = NULL;
+    int64_t dst_dir_count = 0;
+    int64_t src_dir_count = 0;
 
-        ret = dict_get_bin (dst, key, (void **)&meta_dst);
+    if (value == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DATA_NULL,
+               "data value is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_bin(dst, key, (void **)&meta_dst);
+    if (ret < 0) {
+        meta_dst = GF_CALLOC(1, sizeof(quota_meta_t), gf_common_quota_meta_t);
+        if (meta_dst == NULL) {
+            gf_msg("dht", GF_LOG_WARNING, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            ret = -1;
+            goto out;
+        }
+        ret = dict_set_bin(dst, key, meta_dst, sizeof(quota_meta_t));
         if (ret < 0) {
-                meta_dst = GF_CALLOC (1, sizeof (quota_meta_t),
-                                      gf_common_quota_meta_t);
-                if (meta_dst == NULL) {
-                        gf_msg ("dht", GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_NO_MEMORY,
-                                "Memory allocation failed");
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_bin (dst, key, meta_dst,
-                                    sizeof (quota_meta_t));
-                if (ret < 0) {
-                        gf_msg ("dht", GF_LOG_WARNING, EINVAL,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "dht aggregate dict set failed");
-                        GF_FREE (meta_dst);
-                        ret = -1;
-                        goto out;
-                }
+            gf_msg("dht", GF_LOG_WARNING, EINVAL, DHT_MSG_DICT_SET_FAILED,
+                   "dht aggregate dict set failed");
+            GF_FREE(meta_dst);
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (value->len > sizeof (int64_t)) {
-                meta_src = data_to_bin (value);
+    if (value->len > sizeof(int64_t)) {
+        meta_src = data_to_bin(value);
 
-                meta_dst->size = hton64 (ntoh64 (meta_dst->size) +
-                                         ntoh64 (meta_src->size));
-                meta_dst->file_count = hton64 (ntoh64 (meta_dst->file_count) +
-                                               ntoh64 (meta_src->file_count));
+        meta_dst->size = hton64(ntoh64(meta_dst->size) +
+                                ntoh64(meta_src->size));
+        meta_dst->file_count = hton64(ntoh64(meta_dst->file_count) +
+                                      ntoh64(meta_src->file_count));
 
-                if (value->len > (2 * sizeof (int64_t))) {
-                        dst_dir_count = ntoh64 (meta_dst->dir_count);
-                        src_dir_count = ntoh64 (meta_src->dir_count);
+        if (value->len > (2 * sizeof(int64_t))) {
+            dst_dir_count = ntoh64(meta_dst->dir_count);
+            src_dir_count = ntoh64(meta_src->dir_count);
 
-                        if (src_dir_count > dst_dir_count)
-                                meta_dst->dir_count = meta_src->dir_count;
-                } else {
-                        meta_dst->dir_count = 0;
-                }
+            if (src_dir_count > dst_dir_count)
+                meta_dst->dir_count = meta_src->dir_count;
         } else {
-                size = data_to_bin (value);
-                meta_dst->size = hton64 (ntoh64 (meta_dst->size) +
-                                         ntoh64 (*size));
+            meta_dst->dir_count = 0;
         }
+    } else {
+        size = data_to_bin(value);
+        meta_dst->size = hton64(ntoh64(meta_dst->size) + ntoh64(*size));
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-int add_opt(char **optsp, const char *opt)
+int
+add_opt(char **optsp, const char *opt)
 {
-        char *newopts = NULL;
-        unsigned oldsize = 0;
-        unsigned newsize = 0;
+    char *newopts = NULL;
+    unsigned oldsize = 0;
+    unsigned newsize = 0;
 
-        if (*optsp == NULL)
-                newopts = gf_strdup (opt);
-        else {
-                oldsize = strlen (*optsp);
-                newsize = oldsize + 1 + strlen (opt) + 1;
-                newopts = GF_REALLOC (*optsp, newsize);
-                if (newopts)
-                        sprintf (newopts + oldsize, ",%s", opt);
-        }
-        if (newopts == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Error to add choices in buffer in add_opt");
-                return -1;
-        }
-        *optsp = newopts;
-        return 0;
+    if (*optsp == NULL)
+        newopts = gf_strdup(opt);
+    else {
+        oldsize = strlen(*optsp);
+        newsize = oldsize + 1 + strlen(opt) + 1;
+        newopts = GF_REALLOC(*optsp, newsize);
+        if (newopts)
+            sprintf(newopts + oldsize, ",%s", opt);
+    }
+    if (newopts == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+               "Error to add choices in buffer in add_opt");
+        return -1;
+    }
+    *optsp = newopts;
+    return 0;
 }
 
 /* Return Choice list from Split brain status */
 static char *
-getChoices (const char *value)
+getChoices(const char *value)
 {
-        int i = 0;
-        char *ptr = NULL;
-        char *tok = NULL;
-        char *result = NULL;
-        char *newval = NULL;
+    int i = 0;
+    char *ptr = NULL;
+    char *tok = NULL;
+    char *result = NULL;
+    char *newval = NULL;
 
-        ptr = strstr (value, "Choices:");
-        if (!ptr) {
-                result = ptr;
-                goto out;
-        }
+    ptr = strstr(value, "Choices:");
+    if (!ptr) {
+        result = ptr;
+        goto out;
+    }
 
-        newval = gf_strdup (ptr);
-        if (!newval) {
-                result = newval;
-                goto out;
-        }
+    newval = gf_strdup(ptr);
+    if (!newval) {
+        result = newval;
+        goto out;
+    }
 
-        tok = strtok (newval, ":");
-        if (!tok) {
-                result = tok;
-                goto out;
-        }
+    tok = strtok(newval, ":");
+    if (!tok) {
+        result = tok;
+        goto out;
+    }
 
-        while (tok) {
-                i++;
-                if (i == 2)
-                        break;
-                tok = strtok (NULL, ":");
-        }
+    while (tok) {
+        i++;
+        if (i == 2)
+            break;
+        tok = strtok(NULL, ":");
+    }
 
-        result = gf_strdup (tok);
+    result = gf_strdup(tok);
 
 out:
-        if (newval)
-                GF_FREE (newval);
+    if (newval)
+        GF_FREE(newval);
 
-        return result;
+    return result;
 }
 
 /* This function prepare a list of choices for key
@@ -291,248 +269,226 @@ out:
 */
 
 int
-dht_aggregate_split_brain_xattr (dict_t *dst, char *key, data_t *value)
+dht_aggregate_split_brain_xattr(dict_t *dst, char *key, data_t *value)
 {
+    int ret = 0;
+    char *oldvalue = NULL;
+    char *old_choice = NULL;
+    char *new_choice = NULL;
+    char *full_choice = NULL;
+    char *status = NULL;
 
-        int              ret            = 0;
-        char            *oldvalue       = NULL;
-        char            *old_choice     = NULL;
-        char            *new_choice     = NULL;
-        char            *full_choice    = NULL;
-        char            *status         = NULL;
+    if (value == NULL) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DATA_NULL,
+               "GF_AFR_SBRAIN_STATUS value is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_str(dst, key, &oldvalue);
+    if (ret)
+        goto out;
 
-        if (value == NULL) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DATA_NULL,
-                        "GF_AFR_SBRAIN_STATUS value is NULL");
+    /* skip code that is irrelevant if !oldvalue */
+    if (!oldvalue)
+        goto out;
+
+    if (strstr(oldvalue, "not")) {
+        gf_msg_debug("dht", 0, "Need to update split-brain status in dict");
+        ret = -1;
+        goto out;
+    }
+    if (strstr(oldvalue, "metadata-split-brain:yes") &&
+        (strstr(oldvalue, "data-split-brain:no"))) {
+        if (strstr(value->data, "not")) {
+            gf_msg_debug("dht", 0, "No need to update split-brain status");
+            ret = 0;
+            goto out;
+        }
+        if (strstr(value->data, "yes") &&
+            (strncmp(oldvalue, value->data, strlen(oldvalue)))) {
+            old_choice = getChoices(oldvalue);
+            if (!old_choice) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to get choices");
                 ret = -1;
                 goto out;
-        }
+            }
 
-        ret = dict_get_str (dst, key, &oldvalue);
-        if (ret)
+            ret = add_opt(&full_choice, old_choice);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to add choices");
+                ret = -1;
                 goto out;
+            }
 
-        /* skip code that is irrelevant if !oldvalue */
-        if (!oldvalue)
+            new_choice = getChoices(value->data);
+            if (!new_choice) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to get choices");
+                ret = -1;
                 goto out;
+            }
 
-        if (strstr (oldvalue, "not")) {
-                gf_msg_debug ("dht", 0,
-                              "Need to update split-brain status in dict");
+            ret = add_opt(&full_choice, new_choice);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to add choices ");
                 ret = -1;
                 goto out;
+            }
+            ret = gf_asprintf(&status,
+                              "data-split-brain:%s    "
+                              "metadata-split-brain:%s   Choices:%s",
+                              "no", "yes", full_choice);
+
+            if (-1 == ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_NO_MEMORY,
+                       "Error to prepare status ");
+                goto out;
+            }
+            ret = dict_set_dynstr(dst, key, status);
+            if (ret) {
+                gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set full choice");
+            }
         }
-        if (strstr (oldvalue, "metadata-split-brain:yes")
-            && (strstr (oldvalue, "data-split-brain:no"))) {
-                if (strstr (value->data, "not")) {
-                        gf_msg_debug ("dht", 0,
-                                      "No need to update split-brain status");
-                        ret = 0;
-                        goto out;
-                }
-                if (strstr (value->data, "yes") &&
-                        (strncmp (oldvalue, value->data, strlen(oldvalue)))) {
-                        old_choice = getChoices (oldvalue);
-                        if (!old_choice) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Error to get choices");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = add_opt (&full_choice, old_choice);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                         DHT_MSG_NO_MEMORY,
-                                         "Error to add choices");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        new_choice = getChoices (value->data);
-                        if (!new_choice) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Error to get choices");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        ret = add_opt (&full_choice, new_choice);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                       DHT_MSG_NO_MEMORY,
-                                       "Error to add choices ");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = gf_asprintf (&status,
-                                           "data-split-brain:%s    "
-                                           "metadata-split-brain:%s   Choices:%s",
-                                           "no", "yes", full_choice);
-
-                        if (-1 == ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                                 DHT_MSG_NO_MEMORY,
-                                                "Error to prepare status ");
-                                        goto out;
-                                }
-                        ret = dict_set_dynstr (dst, key, status);
-                        if (ret) {
-                                gf_msg ("dht", GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set full choice");
-                        }
-                }
-        }
+    }
 
 out:
-        if (old_choice)
-                GF_FREE (old_choice);
-        if (new_choice)
-                GF_FREE (new_choice);
-        if (full_choice)
-                GF_FREE (full_choice);
+    if (old_choice)
+        GF_FREE(old_choice);
+    if (new_choice)
+        GF_FREE(new_choice);
+    if (full_choice)
+        GF_FREE(full_choice);
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_aggregate (dict_t *this, char *key, data_t *value, void *data)
+dht_aggregate(dict_t *this, char *key, data_t *value, void *data)
 {
-        dict_t          *dst            = NULL;
-        int32_t          ret            = -1;
-        data_t          *dict_data      = NULL;
+    dict_t *dst = NULL;
+    int32_t ret = -1;
+    data_t *dict_data = NULL;
 
-        dst = data;
+    dst = data;
 
-        /* compare split brain xattr only */
-        if (strcmp (key, GF_AFR_SBRAIN_STATUS) == 0) {
-                ret = dht_aggregate_split_brain_xattr(dst, key, value);
+    /* compare split brain xattr only */
+    if (strcmp(key, GF_AFR_SBRAIN_STATUS) == 0) {
+        ret = dht_aggregate_split_brain_xattr(dst, key, value);
+        if (!ret)
+            goto out;
+    } else if (strcmp(key, QUOTA_SIZE_KEY) == 0) {
+        ret = dht_aggregate_quota_xattr(dst, key, value);
+        if (ret) {
+            gf_msg("dht", GF_LOG_WARNING, 0,
+                   DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED,
+                   "Failed to aggregate quota xattr");
+        }
+        goto out;
+    } else if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0) {
+        ret = gf_get_min_stime(THIS, dst, key, value);
+        goto out;
+    } else {
+        /* compare user xattrs only */
+        if (!strncmp(key, "user.", SLEN("user."))) {
+            ret = dict_lookup(dst, key, &dict_data);
+            if (!ret && dict_data && value) {
+                ret = is_data_equal(dict_data, value);
                 if (!ret)
-                        goto out;
-        } else if (strcmp (key, QUOTA_SIZE_KEY) == 0) {
-                ret = dht_aggregate_quota_xattr (dst, key, value);
-                if (ret) {
-                        gf_msg ("dht", GF_LOG_WARNING, 0,
-                                DHT_MSG_AGGREGATE_QUOTA_XATTR_FAILED,
-                                "Failed to aggregate quota xattr");
-                }
-                goto out;
-        } else if (fnmatch (GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0) {
-                ret = gf_get_min_stime (THIS, dst, key, value);
-                goto out;
-        } else {
-                /* compare user xattrs only */
-                if (!strncmp (key, "user.", SLEN ("user."))) {
-                        ret = dict_lookup (dst, key, &dict_data);
-                        if (!ret && dict_data && value) {
-                                ret = is_data_equal (dict_data, value);
-                                if (!ret)
-                                        gf_msg_debug ("dht", 0,
-                                                      "xattr mismatch for %s",
-                                                      key);
-                        }
-                }
+                    gf_msg_debug("dht", 0, "xattr mismatch for %s", key);
+            }
         }
+    }
 
-        ret = dict_set (dst, key, value);
-        if (ret) {
-                gf_msg ("dht", GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        key);
-        }
+    ret = dict_set(dst, key, value);
+    if (ret) {
+        gf_msg("dht", GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s", key);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-dht_aggregate_xattr (dict_t *dst, dict_t *src)
+dht_aggregate_xattr(dict_t *dst, dict_t *src)
 {
-        if ((dst == NULL) || (src == NULL)) {
-                goto out;
-        }
+    if ((dst == NULL) || (src == NULL)) {
+        goto out;
+    }
 
-        dict_foreach (src, dht_aggregate, dst);
+    dict_foreach(src, dht_aggregate, dst);
 out:
-        return;
+    return;
 }
 
 /* Code to save hashed subvol on inode ctx as a mds subvol
-*/
+ */
 int
-dht_inode_ctx_mdsvol_set (inode_t *inode, xlator_t *this, xlator_t *mds_subvol)
+dht_inode_ctx_mdsvol_set(inode_t *inode, xlator_t *this, xlator_t *mds_subvol)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
-        uint64_t                 ctx_int        = 0;
-        gf_boolean_t             ctx_free       = _gf_false;
-
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+    uint64_t ctx_int = 0;
+    gf_boolean_t ctx_free = _gf_false;
 
-        LOCK (&inode->lock);
-        {
-                ret = __inode_ctx_get (inode, this , &ctx_int);
-                if (ctx_int) {
-                        ctx = (dht_inode_ctx_t *)ctx_int;
-                        ctx->mds_subvol = mds_subvol;
-                } else {
-                        ctx = GF_CALLOC (1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
-                        if (!ctx)
-                                goto unlock;
-                        ctx->mds_subvol = mds_subvol;
-                        ctx_free        = _gf_true;
-                        ctx_int = (long) ctx;
-                        ret =  __inode_ctx_set (inode, this, &ctx_int);
-                }
-        }
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get(inode, this, &ctx_int);
+        if (ctx_int) {
+            ctx = (dht_inode_ctx_t *)ctx_int;
+            ctx->mds_subvol = mds_subvol;
+        } else {
+            ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+            if (!ctx)
+                goto unlock;
+            ctx->mds_subvol = mds_subvol;
+            ctx_free = _gf_true;
+            ctx_int = (long)ctx;
+            ret = __inode_ctx_set(inode, this, &ctx_int);
+        }
+    }
 unlock:
-        UNLOCK (&inode->lock);
-        if (ret && ctx_free)
-                GF_FREE (ctx);
-        return ret;
+    UNLOCK(&inode->lock);
+    if (ret && ctx_free)
+        GF_FREE(ctx);
+    return ret;
 }
 
 /*Code to get mds subvol from inode ctx */
 
 int
-dht_inode_ctx_mdsvol_get (inode_t *inode, xlator_t *this, xlator_t **mdsvol)
+dht_inode_ctx_mdsvol_get(inode_t *inode, xlator_t *this, xlator_t **mdsvol)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        if (!mdsvol)
-                return ret;
+    if (!mdsvol)
+        return ret;
 
-        if (__is_root_gfid(inode->gfid)) {
-                (*mdsvol) = FIRST_CHILD (this);
-                return 0;
-        }
+    if (__is_root_gfid(inode->gfid)) {
+        (*mdsvol) = FIRST_CHILD(this);
+        return 0;
+    }
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (!ret && ctx) {
-                if (ctx->mds_subvol) {
-                        *mdsvol = ctx->mds_subvol;
-                        ret = 0;
-                } else {
-                        ret = -1;
-                }
+    if (!ret && ctx) {
+        if (ctx->mds_subvol) {
+            *mdsvol = ctx->mds_subvol;
+            ret = 0;
+        } else {
+            ret = -1;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
-
-
 /* TODO:
    - use volumename in xattr instead of "dht"
    - use NS locks
@@ -540,293 +496,277 @@ dht_inode_ctx_mdsvol_get (inode_t *inode, xlator_t *this, xlator_t **mdsvol)
    - complete linkfile selfheal
 */
 
-
 int
-dht_lookup_selfheal_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xdata)
+dht_lookup_selfheal_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        dht_conf_t   *conf   = NULL;
-        int           ret = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
 
-        local = frame->local;
-        conf  = this->private;
-        ret = op_ret;
+    local = frame->local;
+    conf = this->private;
+    ret = op_ret;
 
-        FRAME_SU_UNDO (frame, dht_local_t);
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-        if (ret == 0) {
-                layout = local->selfheal.layout;
-                ret = dht_layout_set (this, local->inode, layout);
-        }
+    if (ret == 0) {
+        layout = local->selfheal.layout;
+        ret = dht_layout_set(this, local->inode, layout);
+    }
 
-        dht_inode_ctx_time_update (local->inode, this, &local->stbuf, 1);
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           &local->postparent, 1);
-        }
+    dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, &local->postparent,
+                                  1);
+    }
 
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        dht_set_fixed_dir_stat (&local->postparent);
-        /* Delete mds xattr at the time of STACK UNWIND */
-        GF_REMOVE_INTERNAL_XATTR (conf->mds_xattr_key, local->xattr);
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    dht_set_fixed_dir_stat(&local->postparent);
+    /* Delete mds xattr at the time of STACK UNWIND */
+    GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
 
-        DHT_STACK_UNWIND (lookup, frame, ret, local->op_errno, local->inode,
-                          &local->stbuf, local->xattr, &local->postparent);
+    DHT_STACK_UNWIND(lookup, frame, ret, local->op_errno, local->inode,
+                     &local->stbuf, local->xattr, &local->postparent);
 
 out:
-        return ret;
-}
-
-int
-dht_discover_complete (xlator_t *this, call_frame_t *discover_frame)
-{
-        dht_local_t     *local           = NULL;
-        dht_local_t     *heal_local      = NULL;
-        call_frame_t    *main_frame      = NULL;
-        call_frame_t    *heal_frame      = NULL;
-        int              op_errno        = 0;
-        int              ret             = -1;
-        dht_layout_t    *layout          = NULL;
-        dht_conf_t      *conf            = NULL;
-        uint32_t         vol_commit_hash = 0;
-        xlator_t        *source          = NULL;
-        int              heal_path       = 0;
-        int              error_while_marking_mds   = 0;
-        int              i               = 0;
-        loc_t            loc             = {0 };
-        int8_t           is_read_only    = 0, layout_anomalies = 0;
-        char             gfid_local[GF_UUID_BUF_SIZE] = {0};
-
-        local = discover_frame->local;
-        layout = local->layout;
-        conf = this->private;
-        gf_uuid_unparse(local->gfid, gfid_local);
-
-        LOCK(&discover_frame->lock);
-        {
-                main_frame = local->main_frame;
-                local->main_frame = NULL;
-        }
-        UNLOCK(&discover_frame->lock);
-
-        if (!main_frame)
-                return 0;
-
-        /* Code to update all extended attributed from
-           subvol to local->xattr on that internal xattr has found
-        */
-        if (conf->subvolume_cnt == 1)
-                local->need_xattr_heal = 0;
-        if (local->need_xattr_heal && (local->mds_xattr)) {
-                dht_dir_set_heal_xattr (this, local, local->xattr,
-                                        local->mds_xattr, NULL, NULL);
-                dict_unref (local->mds_xattr);
-                local->mds_xattr = NULL;
-        }
-
-        ret = dict_get_int8 (local->xattr_req, QUOTA_READ_ONLY_KEY,
-                             &is_read_only);
-        if (ret < 0)
-                gf_msg_debug (this->name, 0, "key = %s not present in dict",
-                              QUOTA_READ_ONLY_KEY);
-
-        if (local->file_count && local->dir_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_FILE_TYPE_MISMATCH,
-                        "path %s exists as a file on one subvolume "
-                        "and directory on another. "
-                        "Please fix it manually",
-                        local->loc.path);
-                op_errno = EIO;
-                goto out;
-        }
-
-        if (local->cached_subvol) {
-                ret = dht_layout_preset (this, local->cached_subvol,
-                                         local->inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_SET_FAILED,
-                                "failed to set layout for subvolume %s",
-                                local->cached_subvol ? local->cached_subvol->name : "<nil>");
-                        op_errno = EINVAL;
-                        goto out;
-                }
-        } else {
-                ret = dht_layout_normalize (this, &local->loc, layout);
-                if ((ret < 0) || ((ret > 0) && (local->op_ret != 0))) {
-                        /* either the layout is incorrect or the directory is
-                         * not found even in one subvolume.
-                         */
-                        gf_msg_debug (this->name, 0,
-                                      "normalizing failed on %s "
-                                      "(overlaps/holes present: %s, "
-                                      "ENOENT errors: %d)", local->loc.path,
-                                      (ret < 0) ? "yes" : "no", (ret > 0) ? ret : 0);
-                        layout_anomalies = 1;
-                } else if (local->inode) {
-                        dht_layout_set (this, local->inode, layout);
-                }
-        }
+    return ret;
+}
+
+int
+dht_discover_complete(xlator_t *this, call_frame_t *discover_frame)
+{
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *main_frame = NULL;
+    call_frame_t *heal_frame = NULL;
+    int op_errno = 0;
+    int ret = -1;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    uint32_t vol_commit_hash = 0;
+    xlator_t *source = NULL;
+    int heal_path = 0;
+    int error_while_marking_mds = 0;
+    int i = 0;
+    loc_t loc = {0};
+    int8_t is_read_only = 0, layout_anomalies = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+
+    local = discover_frame->local;
+    layout = local->layout;
+    conf = this->private;
+    gf_uuid_unparse(local->gfid, gfid_local);
+
+    LOCK(&discover_frame->lock);
+    {
+        main_frame = local->main_frame;
+        local->main_frame = NULL;
+    }
+    UNLOCK(&discover_frame->lock);
+
+    if (!main_frame)
+        return 0;
+
+    /* Code to update all extended attributed from
+       subvol to local->xattr on that internal xattr has found
+    */
+    if (conf->subvolume_cnt == 1)
+        local->need_xattr_heal = 0;
+    if (local->need_xattr_heal && (local->mds_xattr)) {
+        dht_dir_set_heal_xattr(this, local, local->xattr, local->mds_xattr,
+                               NULL, NULL);
+        dict_unref(local->mds_xattr);
+        local->mds_xattr = NULL;
+    }
+
+    ret = dict_get_int8(local->xattr_req, QUOTA_READ_ONLY_KEY, &is_read_only);
+    if (ret < 0)
+        gf_msg_debug(this->name, 0, "key = %s not present in dict",
+                     QUOTA_READ_ONLY_KEY);
+
+    if (local->file_count && local->dir_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+               "path %s exists as a file on one subvolume "
+               "and directory on another. "
+               "Please fix it manually",
+               local->loc.path);
+        op_errno = EIO;
+        goto out;
+    }
 
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (local->xattr,
-                                       conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
+    if (local->cached_subvol) {
+        ret = dht_layout_preset(this, local->cached_subvol, local->inode);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_SET_FAILED,
+                   "failed to set layout for subvolume %s",
+                   local->cached_subvol ? local->cached_subvol->name : "<nil>");
+            op_errno = EINVAL;
+            goto out;
+        }
+    } else {
+        ret = dht_layout_normalize(this, &local->loc, layout);
+        if ((ret < 0) || ((ret > 0) && (local->op_ret != 0))) {
+            /* either the layout is incorrect or the directory is
+             * not found even in one subvolume.
+             */
+            gf_msg_debug(this->name, 0,
+                         "normalizing failed on %s "
+                         "(overlaps/holes present: %s, "
+                         "ENOENT errors: %d)",
+                         local->loc.path, (ret < 0) ? "yes" : "no",
+                         (ret > 0) ? ret : 0);
+            layout_anomalies = 1;
+        } else if (local->inode) {
+            dht_layout_set(this, local->inode, layout);
+        }
+    }
+
+    if (!conf->vch_forced) {
+        ret = dict_get_uint32(local->xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
         }
+    }
 
-        if (IA_ISDIR (local->stbuf.ia_type) && !is_read_only) {
-                for (i = 0; i < layout->cnt; i++) {
-                       if (!source && !layout->list[i].err)
-                                source = layout->list[i].xlator;
-                        if (layout->list[i].err == ENOENT ||
-                            layout->list[i].err == ESTALE) {
-                                heal_path = 1;
-                        }
-
-                        if (source && heal_path)
-                                break;
-                }
-        }
+    if (IA_ISDIR(local->stbuf.ia_type) && !is_read_only) {
+        for (i = 0; i < layout->cnt; i++) {
+            if (!source && !layout->list[i].err)
+                source = layout->list[i].xlator;
+            if (layout->list[i].err == ENOENT ||
+                layout->list[i].err == ESTALE) {
+                heal_path = 1;
+            }
 
-        if (IA_ISDIR (local->stbuf.ia_type)) {
-                /* Call function to save hashed subvol on inode ctx if
-                   internal mds xattr is not present and all subvols are up
-                */
-                if (!local->op_ret && !__is_root_gfid (local->stbuf.ia_gfid))
-                        (void) dht_common_mark_mdsxattr (discover_frame,
-                                                         &error_while_marking_mds, 1);
-
-                if (local->need_xattr_heal && !heal_path) {
-                        local->need_xattr_heal = 0;
-                        ret =  dht_dir_xattr_heal (this, local);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_ERROR,
-                                        ret,
-                                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                        "xattr heal failed for "
-                                        "directory  gfid is %s ",
-                                        gfid_local);
-                }
+            if (source && heal_path)
+                break;
         }
+    }
 
-        if (source && (heal_path || layout_anomalies || error_while_marking_mds)) {
-                gf_uuid_copy (loc.gfid, local->gfid);
-                if (gf_uuid_is_null (loc.gfid)) {
-                        goto done;
-                }
-
-                if (local->inode)
-                        loc.inode = inode_ref (local->inode);
-                else
-                        goto done;
-
-               heal_frame = create_frame (this, this->ctx->pool);
-               if (heal_frame) {
-                        heal_local = dht_local_init (heal_frame, &loc,
-                                                     NULL, 0);
-                        if (!heal_local)
-                                goto cleanup;
-
-                        gf_uuid_copy (heal_local->gfid, local->gfid);
-                        heal_frame->cookie = source;
-                        heal_local->xattr = dict_ref (local->xattr);
-                        heal_local->stbuf = local->stbuf;
-                        heal_local->postparent = local->postparent;
-                        heal_local->inode = inode_ref (loc.inode);
-                        heal_local->main_frame = main_frame;
-                        FRAME_SU_DO (heal_frame, dht_local_t);
-                        ret = synctask_new (this->ctx->env,
-                                            dht_heal_full_path,
-                                            dht_heal_full_path_done,
-                                            heal_frame, heal_frame);
-                        if (!ret) {
-                                loc_wipe (&loc);
-                                return 0;
-                        }
-                        /*
-                         * Failed to spawn the synctask. Returning
-                         * with out doing heal.
-                         */
-cleanup:
-                        loc_wipe (&loc);
-                        DHT_STACK_DESTROY (heal_frame);
-                }
-
-        }
+    if (IA_ISDIR(local->stbuf.ia_type)) {
+        /* Call function to save hashed subvol on inode ctx if
+           internal mds xattr is not present and all subvols are up
+        */
+        if (!local->op_ret && !__is_root_gfid(local->stbuf.ia_gfid))
+            (void)dht_common_mark_mdsxattr(discover_frame,
+                                           &error_while_marking_mds, 1);
+
+        if (local->need_xattr_heal && !heal_path) {
+            local->need_xattr_heal = 0;
+            ret = dht_dir_xattr_heal(this, local);
+            if (ret)
+                gf_msg(this->name, GF_LOG_ERROR, ret,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "xattr heal failed for "
+                       "directory  gfid is %s ",
+                       gfid_local);
+        }
+    }
+
+    if (source && (heal_path || layout_anomalies || error_while_marking_mds)) {
+        gf_uuid_copy(loc.gfid, local->gfid);
+        if (gf_uuid_is_null(loc.gfid)) {
+            goto done;
+        }
+
+        if (local->inode)
+            loc.inode = inode_ref(local->inode);
+        else
+            goto done;
+
+        heal_frame = create_frame(this, this->ctx->pool);
+        if (heal_frame) {
+            heal_local = dht_local_init(heal_frame, &loc, NULL, 0);
+            if (!heal_local)
+                goto cleanup;
+
+            gf_uuid_copy(heal_local->gfid, local->gfid);
+            heal_frame->cookie = source;
+            heal_local->xattr = dict_ref(local->xattr);
+            heal_local->stbuf = local->stbuf;
+            heal_local->postparent = local->postparent;
+            heal_local->inode = inode_ref(loc.inode);
+            heal_local->main_frame = main_frame;
+            FRAME_SU_DO(heal_frame, dht_local_t);
+            ret = synctask_new(this->ctx->env, dht_heal_full_path,
+                               dht_heal_full_path_done, heal_frame, heal_frame);
+            if (!ret) {
+                loc_wipe(&loc);
+                return 0;
+            }
+            /*
+             * Failed to spawn the synctask. Returning
+             * with out doing heal.
+             */
+        cleanup:
+            loc_wipe(&loc);
+            DHT_STACK_DESTROY(heal_frame);
+        }
+    }
 done:
-        dht_set_fixed_dir_stat (&local->postparent);
-        /* Delete mds xattr at the time of STACK UNWIND */
-        if (local->xattr)
-                GF_REMOVE_INTERNAL_XATTR (conf->mds_xattr_key, local->xattr);
+    dht_set_fixed_dir_stat(&local->postparent);
+    /* Delete mds xattr at the time of STACK UNWIND */
+    if (local->xattr)
+        GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
 
-        DHT_STACK_UNWIND (lookup, main_frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
-        return 0;
+    DHT_STACK_UNWIND(lookup, main_frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (lookup, main_frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
+    DHT_STACK_UNWIND(lookup, main_frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_common_mark_mdsxattr_cbk (call_frame_t *frame, void *cookie,
-                              xlator_t *this, int op_ret, int op_errno,
-                              dict_t *xdata)
+dht_common_mark_mdsxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev  = cookie;
-        int           ret   = -1;
-        dht_conf_t   *conf  = 0;
-        dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = cookie;
+    int ret = -1;
+    dht_conf_t *conf = 0;
+    dht_layout_t *layout = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, frame, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
 
-        local = frame->local;
-        conf = this->private;
-        layout = local->selfheal.layout;
+    local = frame->local;
+    conf = this->private;
+    layout = local->selfheal.layout;
 
-        if (op_ret) {
-                gf_msg_debug (this->name, op_ret,
-                              "Failed to set %s on the MDS %s for path %s. ",
-                               conf->mds_xattr_key, prev->name, local->loc.path);
-        } else {
-                /* Save mds subvol on inode ctx */
-                ret = dht_inode_ctx_mdsvol_set (local->inode, this, prev);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SET_INODE_CTX_FAILED,
-                                "Failed to set mds subvol on inode ctx"
-                                " %s for %s ", prev->name,
-                                local->loc.path);
-                }
-        }
-        if (!local->mds_heal_fresh_lookup && layout) {
-                dht_selfheal_dir_setattr (frame, &local->loc, &local->stbuf,
-                                          0xffffffff, layout);
-        }
+    if (op_ret) {
+        gf_msg_debug(this->name, op_ret,
+                     "Failed to set %s on the MDS %s for path %s. ",
+                     conf->mds_xattr_key, prev->name, local->loc.path);
+    } else {
+        /* Save mds subvol on inode ctx */
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set mds subvol on inode ctx"
+                   " %s for %s ",
+                   prev->name, local->loc.path);
+        }
+    }
+    if (!local->mds_heal_fresh_lookup && layout) {
+        dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf, 0xffffffff,
+                                 layout);
+    }
 out:
-        if (local && local->mds_heal_fresh_lookup)
-                DHT_STACK_DESTROY (frame);
-        return 0;
+    if (local && local->mds_heal_fresh_lookup)
+        DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
-
 /* Common function call by revalidate/selfheal code path to populate
    internal xattr if it is not present, mark_during_fresh_lookup value
    determines either function is call by revalidate_cbk(discover_complete)
@@ -842,1508 +782,1416 @@ out:
    penalty.
 */
 int
-dht_common_mark_mdsxattr (call_frame_t *frame, int *errst, int mark_during_fresh_lookup)
-{
-        dht_local_t  *local          = NULL;
-        xlator_t     *this           = NULL;
-        xlator_t     *hashed_subvol  = NULL;
-        int           ret            = 0;
-        int           i              = 0;
-        dict_t       *xattrs         = NULL;
-        char          gfid_local[GF_UUID_BUF_SIZE] = {0,};
-        int32_t       zero[1]        = {0};
-        dht_conf_t   *conf           = 0;
-        dht_layout_t *layout         = NULL;
-        dht_local_t  *copy_local     = NULL;
-        call_frame_t *xattr_frame    = NULL;
-        gf_boolean_t  vol_down       = _gf_false;
-
-        this = frame->this;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
-
-        local = frame->local;
-        conf = this->private;
-        layout = local->selfheal.layout;
-        local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
-        gf_uuid_unparse(local->gfid, gfid_local);
-
-        /* Code to update hashed subvol consider as a mds subvol
-           and wind a setxattr call on hashed subvol to update
-           internal xattr
+dht_common_mark_mdsxattr(call_frame_t *frame, int *errst,
+                         int mark_during_fresh_lookup)
+{
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *hashed_subvol = NULL;
+    int ret = 0;
+    int i = 0;
+    dict_t *xattrs = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+    int32_t zero[1] = {0};
+    dht_conf_t *conf = 0;
+    dht_layout_t *layout = NULL;
+    dht_local_t *copy_local = NULL;
+    call_frame_t *xattr_frame = NULL;
+    gf_boolean_t vol_down = _gf_false;
+
+    this = frame->this;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+
+    local = frame->local;
+    conf = this->private;
+    layout = local->selfheal.layout;
+    local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
+    gf_uuid_unparse(local->gfid, gfid_local);
+
+    /* Code to update hashed subvol consider as a mds subvol
+       and wind a setxattr call on hashed subvol to update
+       internal xattr
+    */
+    if (!local->xattr || !dict_get(local->xattr, conf->mds_xattr_key)) {
+        /* It means no internal MDS xattr has been set yet
+         */
+        /* Check the status of all subvol are up while call
+           this function call by lookup code path
         */
-        if (!local->xattr || !dict_get (local->xattr, conf->mds_xattr_key)) {
-                /* It means no internal MDS xattr has been set yet
-                */
-                /* Check the status of all subvol are up while call
-                   this function call by lookup code path
-                */
-                if (mark_during_fresh_lookup) {
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                if (!conf->subvolume_status[i]) {
-                                        vol_down = _gf_true;
-                                        break;
-                                }
-                        }
-                        if (vol_down) {
-                                gf_msg_debug (this->name, 0,
-                                              "subvol %s is down. Unable to "
-                                              " save mds subvol on inode for "
-                                              " path %s gfid is %s " ,
-                                              conf->subvolumes[i]->name,
-                                              local->loc.path, gfid_local);
-                                goto out;
-                        }
+        if (mark_during_fresh_lookup) {
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (!conf->subvolume_status[i]) {
+                    vol_down = _gf_true;
+                    break;
                 }
+            }
+            if (vol_down) {
+                gf_msg_debug(this->name, 0,
+                             "subvol %s is down. Unable to "
+                             " save mds subvol on inode for "
+                             " path %s gfid is %s ",
+                             conf->subvolumes[i]->name, local->loc.path,
+                             gfid_local);
+                goto out;
+            }
+        }
 
-                /* Calculate hashed subvol based on inode and parent node
-                */
-                hashed_subvol = dht_inode_get_hashed_subvol (local->inode, this,
-                                                             &local->loc);
-                if (!hashed_subvol) {
-                        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get hashed subvol for path %s"
-                                "gfid is %s ",
-                                local->loc.path, gfid_local);
-                        (*errst) = 1;
-                        ret = -1;
-                        goto out;
-                }
-                xattrs = dict_new ();
-                if (!xattrs) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "dict_new failed");
-                        ret = -1;
-                        goto out;
-                }
-                /* Add internal MDS xattr on disk for hashed subvol
-                */
-                ret = dht_dict_set_array (xattrs, conf->mds_xattr_key,
-                                          zero, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary"
-                                "  value:key = %s for "
-                                "path %s", conf->mds_xattr_key,
-                                local->loc.path);
-                        ret = -1;
-                        goto out;
-                }
-                /* Create a new frame to wind a call only while
-                   this function call by revalidate_cbk code path
-                   To wind a call parallel need to create a new frame
-                */
-                if (mark_during_fresh_lookup) {
-                        xattr_frame = create_frame (this, this->ctx->pool);
-                        if (!xattr_frame) {
-                                ret = -1;
-                                goto out;
-                        }
-                        copy_local = dht_local_init (xattr_frame, &(local->loc),
-                                                     NULL, 0);
-                        if (!copy_local) {
-                                ret = -1;
-                                DHT_STACK_DESTROY (xattr_frame);
-                                goto out;
-                        }
-                        copy_local->stbuf = local->stbuf;
-                        copy_local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
-                        if (!copy_local->inode)
-                                copy_local->inode = inode_ref (local->inode);
-                        gf_uuid_copy (copy_local->loc.gfid, local->gfid);
-                        FRAME_SU_DO (xattr_frame, dht_local_t);
-                        STACK_WIND_COOKIE (xattr_frame, dht_common_mark_mdsxattr_cbk,
-                                           hashed_subvol, hashed_subvol,
-                                           hashed_subvol->fops->setxattr,
-                                           &local->loc, xattrs, 0, NULL);
-                } else {
-                        STACK_WIND_COOKIE (frame,
-                                           dht_common_mark_mdsxattr_cbk,
-                                           (void *)hashed_subvol,
-                                           hashed_subvol,
-                                           hashed_subvol->fops->setxattr,
-                                           &local->loc, xattrs, 0,
-                                           NULL);
-                }
-        } else {
-                gf_msg_debug (this->name, 0,
-                              "internal xattr %s is present on subvol"
-                              "on path %s gfid is %s " , conf->mds_xattr_key,
-                               local->loc.path, gfid_local);
-                if (!mark_during_fresh_lookup)
-                        dht_selfheal_dir_setattr (frame, &local->loc,
-                                                  &local->stbuf, 0xffffffff,
-                                                  layout);
+        /* Calculate hashed subvol based on inode and parent node
+         */
+        hashed_subvol = dht_inode_get_hashed_subvol(local->inode, this,
+                                                    &local->loc);
+        if (!hashed_subvol) {
+            gf_msg(this->name, GF_LOG_DEBUG, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for path %s"
+                   "gfid is %s ",
+                   local->loc.path, gfid_local);
+            (*errst) = 1;
+            ret = -1;
+            goto out;
+        }
+        xattrs = dict_new();
+        if (!xattrs) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "dict_new failed");
+            ret = -1;
+            goto out;
         }
+        /* Add internal MDS xattr on disk for hashed subvol
+         */
+        ret = dht_dict_set_array(xattrs, conf->mds_xattr_key, zero, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary"
+                   "  value:key = %s for "
+                   "path %s",
+                   conf->mds_xattr_key, local->loc.path);
+            ret = -1;
+            goto out;
+        }
+        /* Create a new frame to wind a call only while
+           this function call by revalidate_cbk code path
+           To wind a call parallel need to create a new frame
+        */
+        if (mark_during_fresh_lookup) {
+            xattr_frame = create_frame(this, this->ctx->pool);
+            if (!xattr_frame) {
+                ret = -1;
+                goto out;
+            }
+            copy_local = dht_local_init(xattr_frame, &(local->loc), NULL, 0);
+            if (!copy_local) {
+                ret = -1;
+                DHT_STACK_DESTROY(xattr_frame);
+                goto out;
+            }
+            copy_local->stbuf = local->stbuf;
+            copy_local->mds_heal_fresh_lookup = mark_during_fresh_lookup;
+            if (!copy_local->inode)
+                copy_local->inode = inode_ref(local->inode);
+            gf_uuid_copy(copy_local->loc.gfid, local->gfid);
+            FRAME_SU_DO(xattr_frame, dht_local_t);
+            STACK_WIND_COOKIE(xattr_frame, dht_common_mark_mdsxattr_cbk,
+                              hashed_subvol, hashed_subvol,
+                              hashed_subvol->fops->setxattr, &local->loc,
+                              xattrs, 0, NULL);
+        } else {
+            STACK_WIND_COOKIE(frame, dht_common_mark_mdsxattr_cbk,
+                              (void *)hashed_subvol, hashed_subvol,
+                              hashed_subvol->fops->setxattr, &local->loc,
+                              xattrs, 0, NULL);
+        }
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "internal xattr %s is present on subvol"
+                     "on path %s gfid is %s ",
+                     conf->mds_xattr_key, local->loc.path, gfid_local);
+        if (!mark_during_fresh_lookup)
+            dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf,
+                                     0xffffffff, layout);
+    }
 
 out:
-        if (xattrs)
-                dict_unref (xattrs);
-        return ret;
-}
-
-
-int
-dht_discover_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno,
-                  inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                  struct iatt *postparent)
-{
-        dht_local_t  *local                   = NULL;
-        int           this_call_cnt           = 0;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        int           ret                     = -1;
-        int           is_dir                  = 0;
-        int32_t       check_mds               = 0;
-        int           is_linkfile             = 0;
-        int           attempt_unwind          = 0;
-        dht_conf_t   *conf                    = 0;
-        char          gfid_local[GF_UUID_BUF_SIZE] = {0};
-        char          gfid_node[GF_UUID_BUF_SIZE]  = {0};
-        int32_t       mds_xattr_val[1]             = {0};
-        int           errst                        = 0;
-
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
+    if (xattrs)
+        dict_unref(xattrs);
+    return ret;
+}
+
+int
+dht_discover_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, inode_t *inode, struct iatt *stbuf,
+                 dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int32_t check_mds = 0;
+    int is_linkfile = 0;
+    int attempt_unwind = 0;
+    dht_conf_t *conf = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_node[GF_UUID_BUF_SIZE] = {0};
+    int32_t mds_xattr_val[1] = {0};
+    int errst = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    layout = local->layout;
+
+    /* Check if the gfid is different for file from other node */
+    if (!op_ret && gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
+        gf_uuid_unparse(local->gfid, gfid_local);
 
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on %s, gfid local = %s"
+               "gfid other = %s",
+               local->loc.path, prev->name, gfid_local, gfid_node);
+    }
 
-        layout = local->layout;
+    LOCK(&frame->lock);
+    {
+        /* TODO: assert equal mode on stbuf->st_mode and
+           local->stbuf->st_mode
 
+           else mkdir/chmod/chown and fix
+        */
 
-        /* Check if the gfid is different for file from other node */
-        if (!op_ret && gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                   "%s: failed to merge layouts for subvol %s", local->loc.path,
+                   prev->name);
 
-                gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
-                gf_uuid_unparse(local->gfid, gfid_local);
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno,
+                         "lookup of %s on %s returned error", local->loc.path,
+                         prev->name);
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on %s, gfid local = %s"
-                        "gfid other = %s",
-                        local->loc.path, prev->name,
-                        gfid_local, gfid_node);
+            goto unlock;
         }
 
+        is_linkfile = check_is_linkfile(inode, stbuf, xattr,
+                                        conf->link_xattr_name);
+        is_dir = check_is_dir(inode, stbuf, xattr);
 
-        LOCK (&frame->lock);
-        {
-                /* TODO: assert equal mode on stbuf->st_mode and
-                   local->stbuf->st_mode
-
-                   else mkdir/chmod/chown and fix
-                */
-
-                ret = dht_layout_merge (this, layout, prev,
-                                        op_ret, op_errno, xattr);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_MERGE_FAILED,
-                                "%s: failed to merge layouts for subvol %s",
-                                local->loc.path, prev->name);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "lookup of %s on %s returned error",
-                                      local->loc.path, prev->name);
-
-                        goto unlock;
-                }
-
-                is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                                 conf->link_xattr_name);
-                is_dir = check_is_dir (inode, stbuf, xattr);
-
-                if (is_dir) {
-                        local->dir_count ++;
-                } else {
-                        local->file_count ++;
-
-                        if (!is_linkfile && !local->cached_subvol) {
-                                /* real file */
-                                /* Ok, we somehow managed to find a file on
-                                 * more than one subvol. ignore this or we
-                                 * will end up overwriting information while a
-                                 * a thread is potentially unwinding from
-                                 * dht_discover_complete
-                                 */
-                                local->cached_subvol = prev;
-                                attempt_unwind = 1;
-                        } else {
-                                goto unlock;
-                        }
-                }
-
-                local->op_ret = 0;
-
-                if (local->xattr == NULL) {
-                        local->xattr = dict_ref (xattr);
-                } else {
-                        /* Don't aggregate for files. See BZ#1484113 */
-                        if (is_dir)
-                                dht_aggregate_xattr (local->xattr, xattr);
-                }
+        if (is_dir) {
+            local->dir_count++;
+        } else {
+            local->file_count++;
+
+            if (!is_linkfile && !local->cached_subvol) {
+                /* real file */
+                /* Ok, we somehow managed to find a file on
+                 * more than one subvol. ignore this or we
+                 * will end up overwriting information while a
+                 * a thread is potentially unwinding from
+                 * dht_discover_complete
+                 */
+                local->cached_subvol = prev;
+                attempt_unwind = 1;
+            } else {
+                goto unlock;
+            }
+        }
 
-                if (local->inode == NULL)
-                        local->inode = inode_ref (inode);
+        local->op_ret = 0;
 
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-                dht_iatt_merge (this, &local->postparent, postparent);
+        if (local->xattr == NULL) {
+            local->xattr = dict_ref(xattr);
+        } else {
+            /* Don't aggregate for files. See BZ#1484113 */
+            if (is_dir)
+                dht_aggregate_xattr(local->xattr, xattr);
+        }
 
-                if (!dict_get (xattr, conf->mds_xattr_key)) {
-                        goto unlock;
-                } else {
-                        gf_msg_debug (this->name, 0,
-                                      "internal xattr %s is present on subvol"
-                                      "on path %s gfid is %s " ,
-                                      conf->mds_xattr_key,
-                                      local->loc.path, gfid_local);
-                }
-                check_mds = dht_dict_get_array (xattr, conf->mds_xattr_key,
-                                                mds_xattr_val, 1, &errst);
-                /* save mds subvol on inode ctx */
-                ret = dht_inode_ctx_mdsvol_set (local->inode, this,
-                                                prev);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SET_INODE_CTX_FAILED,
-                                "Failed to set hashed subvol for %s vol is %s",
-                                local->loc.path, prev->name);
-                }
+        if (local->inode == NULL)
+            local->inode = inode_ref(inode);
 
-                if ((check_mds < 0) && !errst) {
-                        local->mds_xattr = dict_ref (xattr);
-                        gf_msg_debug (this->name, 0,
-                                      "Value of %s is not zero on mds subvol"
-                                      "so xattr needs to be healed on non mds"
-                                      " path is %s and vol name is %s "
-                                      " gfid is %s" ,
-                                      conf->mds_xattr_key,
-                                      local->loc.path,
-                                      prev->name, gfid_local);
-                        local->need_xattr_heal = 1;
-                        local->mds_subvol  = prev;
-                }
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->postparent, postparent);
 
-        }
+        if (!dict_get(xattr, conf->mds_xattr_key)) {
+            goto unlock;
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "internal xattr %s is present on subvol"
+                         "on path %s gfid is %s ",
+                         conf->mds_xattr_key, local->loc.path, gfid_local);
+        }
+        check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                       mds_xattr_val, 1, &errst);
+        /* save mds subvol on inode ctx */
+        ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set hashed subvol for %s vol is %s",
+                   local->loc.path, prev->name);
+        }
+
+        if ((check_mds < 0) && !errst) {
+            local->mds_xattr = dict_ref(xattr);
+            gf_msg_debug(this->name, 0,
+                         "Value of %s is not zero on mds subvol"
+                         "so xattr needs to be healed on non mds"
+                         " path is %s and vol name is %s "
+                         " gfid is %s",
+                         conf->mds_xattr_key, local->loc.path, prev->name,
+                         gfid_local);
+            local->need_xattr_heal = 1;
+            local->mds_subvol = prev;
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 out:
-        /* Make sure, the thread executing dht_discover_complete is the one
-         * which calls STACK_DESTROY (frame). In the case of "attempt_unwind",
-         * this makes sure that the thread don't call dht_frame_return, till
-         * call to dht_discover_complete is done.
-         */
-        if (attempt_unwind) {
-                dht_discover_complete (this, frame);
-        }
+    /* Make sure, the thread executing dht_discover_complete is the one
+     * which calls STACK_DESTROY (frame). In the case of "attempt_unwind",
+     * this makes sure that the thread don't call dht_frame_return, till
+     * call to dht_discover_complete is done.
+     */
+    if (attempt_unwind) {
+        dht_discover_complete(this, frame);
+    }
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt) && !attempt_unwind) {
-                dht_discover_complete (this, frame);
-        }
+    if (is_last_call(this_call_cnt) && !attempt_unwind) {
+        dht_discover_complete(this, frame);
+    }
 
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_DESTROY (frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_do_discover (call_frame_t *frame, xlator_t *this, loc_t *loc)
+dht_do_discover(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-        int          ret;
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf = NULL;
-        int          call_cnt = 0;
-        int          op_errno = EINVAL;
-        int          i = 0;
-        call_frame_t *discover_frame = NULL;
+    int ret;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int op_errno = EINVAL;
+    int i = 0;
+    call_frame_t *discover_frame = NULL;
 
-        conf = this->private;
-        local = frame->local;
+    conf = this->private;
+    local = frame->local;
 
-        ret = dht_set_file_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                goto err;
-        }
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        goto err;
+    }
 
-        ret = dht_set_dir_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                goto err;
-        }
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        goto err;
+    }
 
-        if (loc_is_root (loc)) {
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->commithash_xattr_name,
-                                       sizeof(uint32_t));
-        }
+    if (loc_is_root(loc)) {
+        ret = dict_set_uint32(local->xattr_req, conf->commithash_xattr_name,
+                              sizeof(uint32_t));
+    }
 
-        call_cnt        = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
 
-        if (!local->layout) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    if (!local->layout) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        gf_uuid_copy (local->gfid, loc->gfid);
+    gf_uuid_copy(local->gfid, loc->gfid);
 
-        discover_frame = copy_frame (frame);
-        if (!discover_frame) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    discover_frame = copy_frame(frame);
+    if (!discover_frame) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        discover_frame->local = local;
-        frame->local = NULL;
-        local->main_frame = frame;
+    discover_frame->local = local;
+    frame->local = NULL;
+    local->main_frame = frame;
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (discover_frame, dht_discover_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(discover_frame, dht_discover_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, &local->loc,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* Get the value of key from dict in the bytewise and save in array after
    convert from network byte order to host byte order
 */
 int32_t
-dht_dict_get_array (dict_t *dict, char *key, int32_t value[], int32_t size, int *errst)
-{
-        void    *ptr          = NULL;
-        int32_t len           = -1;
-        int32_t vindex        = -1;
-        int32_t err           = -1;
-        int     ret          = 0;
-
-        if (dict == NULL) {
-                (*errst) = -1;
-                return -EINVAL;
-        }
-        err = dict_get_ptr_and_len(dict, key, &ptr, &len);
-        if (err != 0) {
-                (*errst) = -1;
-                return err;
-        }
-
-        if (len != (size * sizeof (int32_t))) {
-                (*errst) = -1;
-                return -EINVAL;
-        }
-
-        for (vindex = 0; vindex < size; vindex++) {
-                value[vindex] = ntoh32(*((int32_t *)ptr + vindex));
-                if (value[vindex] < 0)
-                        ret = -1;
-        }
-
-        return ret;
+dht_dict_get_array(dict_t *dict, char *key, int32_t value[], int32_t size,
+                   int *errst)
+{
+    void *ptr = NULL;
+    int32_t len = -1;
+    int32_t vindex = -1;
+    int32_t err = -1;
+    int ret = 0;
+
+    if (dict == NULL) {
+        (*errst) = -1;
+        return -EINVAL;
+    }
+    err = dict_get_ptr_and_len(dict, key, &ptr, &len);
+    if (err != 0) {
+        (*errst) = -1;
+        return err;
+    }
+
+    if (len != (size * sizeof(int32_t))) {
+        (*errst) = -1;
+        return -EINVAL;
+    }
+
+    for (vindex = 0; vindex < size; vindex++) {
+        value[vindex] = ntoh32(*((int32_t *)ptr + vindex));
+        if (value[vindex] < 0)
+            ret = -1;
+    }
+
+    return ret;
 }
 
-
 /* Code to call syntask to heal custom xattr from hashed subvol
    to non hashed subvol
 */
 int
-dht_dir_xattr_heal (xlator_t *this, dht_local_t *local)
+dht_dir_xattr_heal(xlator_t *this, dht_local_t *local)
 {
-        dht_local_t  *copy_local                  = NULL;
-        call_frame_t *copy                        = NULL;
-        int          ret                          = -1;
-        char         gfid_local[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *copy_local = NULL;
+    call_frame_t *copy = NULL;
+    int ret = -1;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
 
-        if (gf_uuid_is_null (local->gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                        "No gfid exists for path %s "
-                        "so healing xattr is not possible",
-                        local->loc.path);
-                goto out;
-        }
-
-        gf_uuid_unparse(local->gfid, gfid_local);
-        copy = create_frame (this, this->ctx->pool);
-        if (copy) {
-                copy_local = dht_local_init (copy, &(local->loc), NULL, 0);
-                if (!copy_local) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                "Memory allocation failed "
-                                "for path %s gfid %s ",
-                                local->loc.path, gfid_local);
-                        DHT_STACK_DESTROY (copy);
-                } else {
-                        copy_local->stbuf = local->stbuf;
-                        gf_uuid_copy (copy_local->loc.gfid, local->gfid);
-                        copy_local->mds_subvol = local->mds_subvol;
-                        FRAME_SU_DO (copy, dht_local_t);
-                        ret = synctask_new (this->ctx->env, dht_dir_heal_xattrs,
-                                            dht_dir_heal_xattrs_done,
-                                            copy, copy);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                        "Synctask creation failed to heal xattr "
-                                        "for path %s gfid %s ",
-                                        local->loc.path, gfid_local);
-                                DHT_STACK_DESTROY (copy);
-                        }
-                }
+    if (gf_uuid_is_null(local->gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+               "No gfid exists for path %s "
+               "so healing xattr is not possible",
+               local->loc.path);
+        goto out;
+    }
+
+    gf_uuid_unparse(local->gfid, gfid_local);
+    copy = create_frame(this, this->ctx->pool);
+    if (copy) {
+        copy_local = dht_local_init(copy, &(local->loc), NULL, 0);
+        if (!copy_local) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                   DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                   "Memory allocation failed "
+                   "for path %s gfid %s ",
+                   local->loc.path, gfid_local);
+            DHT_STACK_DESTROY(copy);
+        } else {
+            copy_local->stbuf = local->stbuf;
+            gf_uuid_copy(copy_local->loc.gfid, local->gfid);
+            copy_local->mds_subvol = local->mds_subvol;
+            FRAME_SU_DO(copy, dht_local_t);
+            ret = synctask_new(this->ctx->env, dht_dir_heal_xattrs,
+                               dht_dir_heal_xattrs_done, copy, copy);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "Synctask creation failed to heal xattr "
+                       "for path %s gfid %s ",
+                       local->loc.path, gfid_local);
+                DHT_STACK_DESTROY(copy);
+            }
         }
+    }
 out:
-        return ret;
-}
-
+    return ret;
+}
+
+int
+dht_lookup_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int32_t check_mds = 0;
+    int errst = 0;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_node[GF_UUID_BUF_SIZE] = {0};
+    int32_t mds_xattr_val[1] = {0};
+    call_frame_t *copy = NULL;
+    dht_local_t *copy_local = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    layout = local->layout;
+
+    if (!op_ret && gf_uuid_is_null(local->gfid)) {
+        memcpy(local->gfid, stbuf->ia_gfid, 16);
+    }
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid_local);
+    }
 
+    /* Check if the gfid is different for file from other node */
+    if (!op_ret && gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
 
-int
-dht_lookup_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                    struct iatt *postparent)
-{
-        dht_local_t  *local                   = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           this_call_cnt           = 0;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        int           ret                     = -1;
-        int           is_dir                  = 0;
-        int32_t       check_mds               = 0;
-        int           errst                   = 0;
-        char          gfid_local[GF_UUID_BUF_SIZE] = {0};
-        char          gfid_node[GF_UUID_BUF_SIZE]  = {0};
-        int32_t       mds_xattr_val[1]                 = {0};
-        call_frame_t *copy                         = NULL;
-        dht_local_t  *copy_local                   = NULL;
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on %s."
+               " gfid local = %s, gfid subvol = %s",
+               local->loc.path, prev->name, gfid_local, gfid_node);
+    }
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
+    LOCK(&frame->lock);
+    {
+        /* TODO: assert equal mode on stbuf->st_mode and
+           local->stbuf->st_mode
 
-        local = frame->local;
-        prev  = cookie;
-        conf  = this->private;
+           else mkdir/chmod/chown and fix
+        */
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
 
-        layout = local->layout;
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno,
+                         "lookup of %s on %s returned error", local->loc.path,
+                         prev->name);
 
-        if (!op_ret && gf_uuid_is_null (local->gfid)) {
-                memcpy (local->gfid, stbuf->ia_gfid, 16);
+            goto unlock;
         }
-        if (!gf_uuid_is_null(local->gfid)) {
-                gf_uuid_unparse(local->gfid, gfid_local);
-        }
-
-        /* Check if the gfid is different for file from other node */
-        if (!op_ret && gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
 
-                gf_uuid_unparse(stbuf->ia_gfid, gfid_node);
+        is_dir = check_is_dir(inode, stbuf, xattr);
+        if (!is_dir) {
+            gf_msg_debug(this->name, 0,
+                         "lookup of %s on %s returned non"
+                         "dir 0%o"
+                         "calling lookup_everywhere",
+                         local->loc.path, prev->name, stbuf->ia_type);
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on %s."
-                        " gfid local = %s, gfid subvol = %s",
-                        local->loc.path, prev->name,
-                        gfid_local, gfid_node);
+            local->need_selfheal = 1;
+            goto unlock;
         }
 
-        LOCK (&frame->lock);
-        {
-                /* TODO: assert equal mode on stbuf->st_mode and
-                   local->stbuf->st_mode
-
-                   else mkdir/chmod/chown and fix
-                */
-                ret = dht_layout_merge (this, layout, prev, op_ret, op_errno,
-                                        xattr);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "lookup of %s on %s returned error",
-                                      local->loc.path, prev->name);
-
-                        goto unlock;
-                }
-
-                is_dir = check_is_dir (inode, stbuf, xattr);
-                if (!is_dir) {
-
-                        gf_msg_debug (this->name, 0,
-                                      "lookup of %s on %s returned non"
-                                      "dir 0%o"
-                                      "calling lookup_everywhere",
-                                      local->loc.path, prev->name,
-                                      stbuf->ia_type);
-
-                        local->need_selfheal = 1;
-                        goto unlock;
-                }
-
-                local->op_ret = 0;
-                if (local->xattr == NULL) {
-                        local->xattr = dict_ref (xattr);
-                } else {
-                        dht_aggregate_xattr (local->xattr, xattr);
-                }
-
-                if (dict_get (xattr, conf->mds_xattr_key)) {
-                        local->mds_subvol  = prev;
-                        local->mds_stbuf.ia_gid = stbuf->ia_gid;
-                        local->mds_stbuf.ia_uid = stbuf->ia_uid;
-                        local->mds_stbuf.ia_prot = stbuf->ia_prot;
-                }
+        local->op_ret = 0;
+        if (local->xattr == NULL) {
+            local->xattr = dict_ref(xattr);
+        } else {
+            dht_aggregate_xattr(local->xattr, xattr);
+        }
 
-                if (local->stbuf.ia_type != IA_INVAL) {
-                        if (!__is_root_gfid (stbuf->ia_gfid) &&
-                            ((local->stbuf.ia_gid != stbuf->ia_gid) ||
-                            (local->stbuf.ia_uid != stbuf->ia_uid) ||
-                            (is_permission_different (&local->stbuf.ia_prot,
-                                                      &stbuf->ia_prot)))) {
-                                local->need_attrheal = 1;
-                        }
-                }
+        if (dict_get(xattr, conf->mds_xattr_key)) {
+            local->mds_subvol = prev;
+            local->mds_stbuf.ia_gid = stbuf->ia_gid;
+            local->mds_stbuf.ia_uid = stbuf->ia_uid;
+            local->mds_stbuf.ia_prot = stbuf->ia_prot;
+        }
 
-                if (local->inode == NULL)
-                        local->inode = inode_ref (inode);
+        if (local->stbuf.ia_type != IA_INVAL) {
+            if (!__is_root_gfid(stbuf->ia_gfid) &&
+                ((local->stbuf.ia_gid != stbuf->ia_gid) ||
+                 (local->stbuf.ia_uid != stbuf->ia_uid) ||
+                 (is_permission_different(&local->stbuf.ia_prot,
+                                          &stbuf->ia_prot)))) {
+                local->need_attrheal = 1;
+            }
+        }
 
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-                dht_iatt_merge (this, &local->postparent, postparent);
+        if (local->inode == NULL)
+            local->inode = inode_ref(inode);
 
-                if (!dict_get (xattr, conf->mds_xattr_key)) {
-                        gf_msg_debug (this->name, 0,
-                                      "Internal xattr %s is not present "
-                                      " on path %s gfid is %s " ,
-                                      conf->mds_xattr_key,
-                                      local->loc.path, gfid_local);
-                        goto unlock;
-                } else {
-                        /* Save mds subvol on inode ctx */
-                        ret = dht_inode_ctx_mdsvol_set (local->inode, this,
-                                                        prev);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_SET_INODE_CTX_FAILED,
-                                        "Failed to set hashed subvol for %s vol is %s",
-                                        local->loc.path, prev->name);
-                         }
-                }
-                check_mds = dht_dict_get_array (xattr, conf->mds_xattr_key,
-                                                mds_xattr_val, 1, &errst);
-                if ((check_mds < 0) && !errst) {
-                        local->mds_xattr = dict_ref (xattr);
-                        gf_msg_debug (this->name, 0,
-                                      "Value of %s is not zero on hashed subvol "
-                                      "so xattr needs to be heal on non hashed"
-                                      " path is %s and vol name is %s "
-                                      " gfid is %s" ,
-                                      conf->mds_xattr_key,
-                                      local->loc.path,
-                                      prev->name, gfid_local);
-                        local->need_xattr_heal = 1;
-                        local->mds_subvol  = prev;
-                }
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->postparent, postparent);
 
+        if (!dict_get(xattr, conf->mds_xattr_key)) {
+            gf_msg_debug(this->name, 0,
+                         "Internal xattr %s is not present "
+                         " on path %s gfid is %s ",
+                         conf->mds_xattr_key, local->loc.path, gfid_local);
+            goto unlock;
+        } else {
+            /* Save mds subvol on inode ctx */
+            ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0,
+                       DHT_MSG_SET_INODE_CTX_FAILED,
+                       "Failed to set hashed subvol for %s vol is %s",
+                       local->loc.path, prev->name);
+            }
         }
+        check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                       mds_xattr_val, 1, &errst);
+        if ((check_mds < 0) && !errst) {
+            local->mds_xattr = dict_ref(xattr);
+            gf_msg_debug(this->name, 0,
+                         "Value of %s is not zero on hashed subvol "
+                         "so xattr needs to be heal on non hashed"
+                         " path is %s and vol name is %s "
+                         " gfid is %s",
+                         conf->mds_xattr_key, local->loc.path, prev->name,
+                         gfid_local);
+            local->need_xattr_heal = 1;
+            local->mds_subvol = prev;
+        }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                /* No need to call xattr heal code if volume count is 1
-                */
-                if (conf->subvolume_cnt == 1)
-                        local->need_xattr_heal = 0;
+    if (is_last_call(this_call_cnt)) {
+        /* No need to call xattr heal code if volume count is 1
+         */
+        if (conf->subvolume_cnt == 1)
+            local->need_xattr_heal = 0;
 
-                /* Code to update all extended attributed from hashed subvol
-                   to local->xattr
-                */
-                if (local->need_xattr_heal && (local->mds_xattr)) {
-                        dht_dir_set_heal_xattr (this, local, local->xattr,
-                                                local->mds_xattr, NULL, NULL);
-                        dict_unref (local->mds_xattr);
-                        local->mds_xattr = NULL;
-                }
+        /* Code to update all extended attributed from hashed subvol
+           to local->xattr
+        */
+        if (local->need_xattr_heal && (local->mds_xattr)) {
+            dht_dir_set_heal_xattr(this, local, local->xattr, local->mds_xattr,
+                                   NULL, NULL);
+            dict_unref(local->mds_xattr);
+            local->mds_xattr = NULL;
+        }
 
-                if (local->need_selfheal) {
-                        local->need_selfheal = 0;
-                        dht_lookup_everywhere (frame, this, &local->loc);
-                        return 0;
-                }
+        if (local->need_selfheal) {
+            local->need_selfheal = 0;
+            dht_lookup_everywhere(frame, this, &local->loc);
+            return 0;
+        }
 
-                if (local->op_ret == 0) {
-                        ret = dht_layout_normalize (this, &local->loc, layout);
+        if (local->op_ret == 0) {
+            ret = dht_layout_normalize(this, &local->loc, layout);
 
-                        if (ret != 0) {
-                                gf_msg_debug (this->name, 0,
-                                              "fixing assignment on %s",
-                                              local->loc.path);
-                                goto selfheal;
-                        }
+            if (ret != 0) {
+                gf_msg_debug(this->name, 0, "fixing assignment on %s",
+                             local->loc.path);
+                goto selfheal;
+            }
 
-                        dht_layout_set (this, local->inode, layout);
-                        if (!dict_get (local->xattr, conf->mds_xattr_key) ||
-                            local->need_xattr_heal)
-                                goto selfheal;
-                }
+            dht_layout_set(this, local->inode, layout);
+            if (!dict_get(local->xattr, conf->mds_xattr_key) ||
+                local->need_xattr_heal)
+                goto selfheal;
+        }
 
-                if (local->inode) {
-                        dht_inode_ctx_time_update (local->inode, this,
-                                                   &local->stbuf, 1);
-                }
+        if (local->inode) {
+            dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+        }
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
 
-                if (local->need_attrheal) {
-                        local->need_attrheal = 0;
-                        if (!__is_root_gfid (inode->gfid)) {
-                                local->stbuf.ia_gid = local->mds_stbuf.ia_gid;
-                                local->stbuf.ia_uid = local->mds_stbuf.ia_uid;
-                                local->stbuf.ia_prot = local->mds_stbuf.ia_prot;
-                        }
-                        copy = create_frame (this, this->ctx->pool);
-                        if (copy) {
-                                copy_local = dht_local_init (copy, &local->loc,
-                                                             NULL, 0);
-                                if (!copy_local) {
-                                        DHT_STACK_DESTROY (copy);
-                                        goto skip_attr_heal;
-                                }
-                                copy_local->stbuf = local->stbuf;
-                                gf_uuid_copy (copy_local->loc.gfid,
-                                              local->stbuf.ia_gfid);
-                                copy_local->mds_stbuf = local->mds_stbuf;
-                                copy_local->mds_subvol = local->mds_subvol;
-                                copy->local = copy_local;
-                                FRAME_SU_DO (copy, dht_local_t);
-                                ret = synctask_new (this->ctx->env,
-                                                    dht_dir_attr_heal,
-                                                    dht_dir_attr_heal_done,
-                                                    copy, copy);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                                DHT_MSG_DIR_ATTR_HEAL_FAILED,
-                                                "Synctask creation failed to heal attr "
-                                                "for path %s gfid %s ",
-                                                local->loc.path, local->gfid);
-                                        DHT_STACK_DESTROY (copy);
-                                }
-                        }
+        if (local->need_attrheal) {
+            local->need_attrheal = 0;
+            if (!__is_root_gfid(inode->gfid)) {
+                local->stbuf.ia_gid = local->mds_stbuf.ia_gid;
+                local->stbuf.ia_uid = local->mds_stbuf.ia_uid;
+                local->stbuf.ia_prot = local->mds_stbuf.ia_prot;
+            }
+            copy = create_frame(this, this->ctx->pool);
+            if (copy) {
+                copy_local = dht_local_init(copy, &local->loc, NULL, 0);
+                if (!copy_local) {
+                    DHT_STACK_DESTROY(copy);
+                    goto skip_attr_heal;
+                }
+                copy_local->stbuf = local->stbuf;
+                gf_uuid_copy(copy_local->loc.gfid, local->stbuf.ia_gfid);
+                copy_local->mds_stbuf = local->mds_stbuf;
+                copy_local->mds_subvol = local->mds_subvol;
+                copy->local = copy_local;
+                FRAME_SU_DO(copy, dht_local_t);
+                ret = synctask_new(this->ctx->env, dht_dir_attr_heal,
+                                   dht_dir_attr_heal_done, copy, copy);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                           DHT_MSG_DIR_ATTR_HEAL_FAILED,
+                           "Synctask creation failed to heal attr "
+                           "for path %s gfid %s ",
+                           local->loc.path, local->gfid);
+                    DHT_STACK_DESTROY(copy);
                 }
-
-skip_attr_heal:
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                /* Delete mds xattr at the time of STACK UNWIND */
-                if (local->xattr)
-                        GF_REMOVE_INTERNAL_XATTR (conf->mds_xattr_key, local->xattr);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                                  local->inode, &local->stbuf, local->xattr,
-                                  &local->postparent);
+            }
         }
 
-        return 0;
+    skip_attr_heal:
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        /* Delete mds xattr at the time of STACK UNWIND */
+        if (local->xattr)
+            GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+    }
+
+    return 0;
 
 selfheal:
-        FRAME_SU_DO (frame, dht_local_t);
-        ret = dht_selfheal_directory (frame, dht_lookup_selfheal_cbk,
-                                      &local->loc, layout);
+    FRAME_SU_DO(frame, dht_local_t);
+    ret = dht_selfheal_directory(frame, dht_lookup_selfheal_cbk, &local->loc,
+                                 layout);
 out:
-        return ret;
-}
+    return ret;
+}
+
+int
+is_permission_different(ia_prot_t *prot1, ia_prot_t *prot2)
+{
+    if ((prot1->owner.read != prot2->owner.read) ||
+        (prot1->owner.write != prot2->owner.write) ||
+        (prot1->owner.exec != prot2->owner.exec) ||
+        (prot1->group.read != prot2->group.read) ||
+        (prot1->group.write != prot2->group.write) ||
+        (prot1->group.exec != prot2->group.exec) ||
+        (prot1->other.read != prot2->other.read) ||
+        (prot1->other.write != prot2->other.write) ||
+        (prot1->other.exec != prot2->other.exec) ||
+        (prot1->suid != prot2->suid) || (prot1->sgid != prot2->sgid) ||
+        (prot1->sticky != prot2->sticky)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int
+dht_revalidate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
+                   dict_t *xattr, struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int is_dir = 0;
+    int is_linkfile = 0;
+    int follow_link = 0;
+    call_frame_t *copy = NULL;
+    dht_local_t *copy_local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    uint32_t vol_commit_hash = 0;
+    xlator_t *subvol = NULL;
+    int32_t check_mds = 0;
+    int errst = 0;
+    int32_t mds_xattr_val[1] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", cookie, err);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-int
-is_permission_different (ia_prot_t *prot1, ia_prot_t *prot2)
-{
-        if ((prot1->owner.read != prot2->owner.read) ||
-            (prot1->owner.write != prot2->owner.write) ||
-            (prot1->owner.exec != prot2->owner.exec) ||
-            (prot1->group.read != prot2->group.read) ||
-            (prot1->group.write != prot2->group.write) ||
-            (prot1->group.exec != prot2->group.exec) ||
-            (prot1->other.read != prot2->other.read) ||
-            (prot1->other.write != prot2->other.write) ||
-            (prot1->other.exec != prot2->other.exec) ||
-            (prot1->suid != prot2->suid) ||
-            (prot1->sgid != prot2->sgid) ||
-            (prot1->sticky != prot2->sticky)) {
-                return 1;
-        } else {
-                return 0;
+    if (!conf->vch_forced) {
+        ret = dict_get_uint32(xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
         }
-}
-
-int
-dht_revalidate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                    struct iatt *postparent)
-{
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev          = NULL;
-        dht_layout_t *layout        = NULL;
-        dht_conf_t   *conf          = NULL;
-        int           ret  = -1;
-        int           is_dir = 0;
-        int           is_linkfile = 0;
-        int           follow_link = 0;
-        call_frame_t *copy          = NULL;
-        dht_local_t  *copy_local    = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0};
-        uint32_t      vol_commit_hash = 0;
-        xlator_t      *subvol = NULL;
-        int32_t       check_mds       = 0;
-        int           errst           = 0;
-        int32_t       mds_xattr_val[1] = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, err);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, err);
+    }
 
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
-        if (!conf)
-                goto out;
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (xattr, conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
+    LOCK(&frame->lock);
+    {
+        if (gf_uuid_is_null(local->gfid)) {
+            memcpy(local->gfid, local->loc.gfid, 16);
         }
 
-        gf_uuid_unparse (local->loc.gfid, gfid);
+        gf_msg_debug(this->name, op_errno,
+                     "revalidate lookup of %s "
+                     "returned with op_ret %d",
+                     local->loc.path, op_ret);
 
-        LOCK (&frame->lock);
-        {
-                if (gf_uuid_is_null (local->gfid)) {
-                        memcpy (local->gfid, local->loc.gfid, 16);
-                }
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+
+            if ((op_errno != ENOTCONN) && (op_errno != ENOENT) &&
+                (op_errno != ESTALE)) {
+                gf_msg(this->name, GF_LOG_INFO, op_errno,
+                       DHT_MSG_REVALIDATE_CBK_INFO,
+                       "Revalidate: subvolume %s for %s "
+                       "(gfid = %s) returned -1",
+                       prev->name, local->loc.path, gfid);
+            }
+            if (op_errno == ESTALE) {
+                /* propagate the ESTALE to parent.
+                 * setting local->return_estale would send
+                 * ESTALE to parent. */
+                local->return_estale = 1;
+            }
+
+            /* if it is ENOENT, we may have to do a
+             * 'lookup_everywhere()' to make sure
+             * the file is not migrated */
+            if (op_errno == ENOENT) {
+                if (IA_ISREG(local->loc.inode->ia_type)) {
+                    gf_msg_debug(this->name, 0,
+                                 "found ENOENT for %s. "
+                                 "Setting "
+                                 "need_lookup_everywhere"
+                                 " flag to 1",
+                                 local->loc.path);
 
-                gf_msg_debug (this->name, op_errno,
-                              "revalidate lookup of %s "
-                              "returned with op_ret %d",
-                              local->loc.path, op_ret);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-
-                        if ((op_errno != ENOTCONN)
-                            && (op_errno != ENOENT)
-                            && (op_errno != ESTALE)) {
-                                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                                        DHT_MSG_REVALIDATE_CBK_INFO,
-                                        "Revalidate: subvolume %s for %s "
-                                        "(gfid = %s) returned -1",
-                                        prev->name, local->loc.path,
-                                        gfid);
-                        }
-                        if (op_errno == ESTALE) {
-                                /* propagate the ESTALE to parent.
-                                 * setting local->return_estale would send
-                                 * ESTALE to parent. */
-                                local->return_estale = 1;
-                        }
-
-                        /* if it is ENOENT, we may have to do a
-                         * 'lookup_everywhere()' to make sure
-                         * the file is not migrated */
-                        if (op_errno == ENOENT) {
-                                if (IA_ISREG (local->loc.inode->ia_type)) {
-
-                                        gf_msg_debug (this->name, 0,
-                                                      "found ENOENT for %s. "
-                                                      "Setting "
-                                                      "need_lookup_everywhere"
-                                                      " flag to 1",
-                                                      local->loc.path);
-
-                                        local->need_lookup_everywhere = 1;
-                                }
-                        }
-                        goto unlock;
+                    local->need_lookup_everywhere = 1;
                 }
+            }
+            goto unlock;
+        }
+
+        if ((!IA_ISINVAL(local->inode->ia_type)) &&
+            stbuf->ia_type != local->inode->ia_type) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+                   "mismatching filetypes 0%o v/s 0%o for %s,"
+                   " gfid = %s",
+                   (stbuf->ia_type), (local->inode->ia_type), local->loc.path,
+                   gfid);
 
-                if ((!IA_ISINVAL(local->inode->ia_type)) &&
-                    stbuf->ia_type != local->inode->ia_type) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_FILE_TYPE_MISMATCH,
-                                "mismatching filetypes 0%o v/s 0%o for %s,"
-                                " gfid = %s",
-                                (stbuf->ia_type), (local->inode->ia_type),
-                                local->loc.path, gfid);
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
 
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
+            goto unlock;
+        }
+
+        layout = local->layout;
 
-                        goto unlock;
+        is_dir = check_is_dir(inode, stbuf, xattr);
+        is_linkfile = check_is_linkfile(inode, stbuf, xattr,
+                                        conf->link_xattr_name);
+        if (is_linkfile) {
+            follow_link = 1;
+            goto unlock;
+        }
+        if (is_dir) {
+            ret = dht_dir_has_layout(xattr, conf->xattr_name);
+            if (ret >= 0) {
+                if (is_greater_time(local->stbuf.ia_ctime,
+                                    local->stbuf.ia_ctime_nsec, stbuf->ia_ctime,
+                                    stbuf->ia_ctime_nsec)) {
+                    /* Choose source */
+                    local->prebuf.ia_gid = stbuf->ia_gid;
+                    local->prebuf.ia_uid = stbuf->ia_uid;
+
+                    if (__is_root_gfid(stbuf->ia_gfid))
+                        local->prebuf.ia_prot = stbuf->ia_prot;
+                }
+            }
 
+            if (local->stbuf.ia_type != IA_INVAL) {
+                if ((local->stbuf.ia_gid != stbuf->ia_gid) ||
+                    (local->stbuf.ia_uid != stbuf->ia_uid) ||
+                    is_permission_different(&local->stbuf.ia_prot,
+                                            &stbuf->ia_prot)) {
+                    local->need_selfheal = 1;
                 }
+            }
 
-                layout = local->layout;
+            if (!dict_get(xattr, conf->mds_xattr_key)) {
+                gf_msg_debug(this->name, 0,
+                             "internal xattr %s is not present"
+                             " on path %s gfid is %s ",
+                             conf->mds_xattr_key, local->loc.path, gfid);
+            } else {
+                check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                               mds_xattr_val, 1, &errst);
+                local->mds_subvol = prev;
+                local->mds_stbuf.ia_gid = stbuf->ia_gid;
+                local->mds_stbuf.ia_uid = stbuf->ia_uid;
+                local->mds_stbuf.ia_prot = stbuf->ia_prot;
 
-                is_dir = check_is_dir (inode, stbuf, xattr);
-                is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                                 conf->link_xattr_name);
-                if (is_linkfile) {
-                        follow_link = 1;
-                        goto unlock;
+                /* save mds subvol on inode ctx */
+                ret = dht_inode_ctx_mdsvol_set(local->inode, this, prev);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           DHT_MSG_SET_INODE_CTX_FAILED,
+                           "Failed to set MDS subvol for %s vol is %s",
+                           local->loc.path, prev->name);
                 }
-                if (is_dir) {
-                        ret = dht_dir_has_layout (xattr, conf->xattr_name);
-                        if (ret >= 0) {
-                                if (is_greater_time(local->stbuf.ia_ctime,
-                                                    local->stbuf.ia_ctime_nsec,
-                                                    stbuf->ia_ctime,
-                                                    stbuf->ia_ctime_nsec)) {
-                                        /* Choose source */
-                                        local->prebuf.ia_gid = stbuf->ia_gid;
-                                        local->prebuf.ia_uid = stbuf->ia_uid;
-
-                                        if (__is_root_gfid (stbuf->ia_gfid))
-                                                local->prebuf.ia_prot = stbuf->ia_prot;
-                                }
-                        }
-
-                        if (local->stbuf.ia_type != IA_INVAL)
-                        {
-                                if ((local->stbuf.ia_gid != stbuf->ia_gid) ||
-                                    (local->stbuf.ia_uid != stbuf->ia_uid) ||
-                                     is_permission_different (&local->stbuf.ia_prot,
-                                                              &stbuf->ia_prot)) {
-                                        local->need_selfheal = 1;
-                                }
-                        }
-
-                        if (!dict_get (xattr, conf->mds_xattr_key)) {
-                                gf_msg_debug (this->name, 0,
-                                              "internal xattr %s is not present"
-                                              " on path %s gfid is %s " ,
-                                              conf->mds_xattr_key,
-                                              local->loc.path, gfid);
-                        } else {
-                                check_mds = dht_dict_get_array (xattr, conf->mds_xattr_key,
-                                                                mds_xattr_val, 1, &errst);
-                                local->mds_subvol  = prev;
-                                local->mds_stbuf.ia_gid = stbuf->ia_gid;
-                                local->mds_stbuf.ia_uid = stbuf->ia_uid;
-                                local->mds_stbuf.ia_prot = stbuf->ia_prot;
-
-                                /* save mds subvol on inode ctx */
-                                ret = dht_inode_ctx_mdsvol_set (local->inode, this,
-                                                                prev);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_SET_INODE_CTX_FAILED,
-                                                "Failed to set MDS subvol for %s vol is %s",
-                                                local->loc.path, prev->name);
-                                }
-                                if ((check_mds < 0) && !errst) {
-                                        local->mds_xattr = dict_ref (xattr);
-                                        gf_msg_debug (this->name, 0,
-                                                      "Value of %s is not zero on "
-                                                      "hashed subvol so xattr needs to"
-                                                      " be healed on non hashed"
-                                                      " path is %s and vol name is %s "
-                                                      " gfid is %s" ,
-                                                      conf->mds_xattr_key,
-                                                      local->loc.path,
-                                                      prev->name, gfid);
-                                        local->need_xattr_heal = 1;
-                                }
-                        }
-                        ret = dht_layout_dir_mismatch (this, layout,
-                                                       prev, &local->loc,
-                                                       xattr);
-                        if (ret != 0) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_LAYOUT_MISMATCH,
-                                        "Mismatching layouts for %s, gfid = %s",
-                                        local->loc.path, gfid);
-
-                                local->layout_mismatch = 1;
-
-                                goto unlock;
-                        }
+                if ((check_mds < 0) && !errst) {
+                    local->mds_xattr = dict_ref(xattr);
+                    gf_msg_debug(this->name, 0,
+                                 "Value of %s is not zero on "
+                                 "hashed subvol so xattr needs to"
+                                 " be healed on non hashed"
+                                 " path is %s and vol name is %s "
+                                 " gfid is %s",
+                                 conf->mds_xattr_key, local->loc.path,
+                                 prev->name, gfid);
+                    local->need_xattr_heal = 1;
                 }
+            }
+            ret = dht_layout_dir_mismatch(this, layout, prev, &local->loc,
+                                          xattr);
+            if (ret != 0) {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_MISMATCH,
+                       "Mismatching layouts for %s, gfid = %s", local->loc.path,
+                       gfid);
 
+                local->layout_mismatch = 1;
 
-                /* Update stbuf from the servers where layout is present. This
-                 * is an indication that the server is not a newly added brick.
-                 * Merging stbuf from newly added brick may result in the added
-                 * brick being the source of heal for uid/gid */
-                if (!is_dir || (is_dir &&
-                    dht_dir_has_layout (xattr, conf->xattr_name) >= 0)
-                    || conf->subvolume_cnt == 1) {
+                goto unlock;
+            }
+        }
 
-                        dht_iatt_merge (this, &local->stbuf, stbuf);
-                        dht_iatt_merge (this, &local->postparent, postparent);
-                } else {
-                        /* copy the gfid anyway */
-                        gf_uuid_copy (local->stbuf.ia_gfid, stbuf->ia_gfid);
-                }
+        /* Update stbuf from the servers where layout is present. This
+         * is an indication that the server is not a newly added brick.
+         * Merging stbuf from newly added brick may result in the added
+         * brick being the source of heal for uid/gid */
+        if (!is_dir ||
+            (is_dir && dht_dir_has_layout(xattr, conf->xattr_name) >= 0) ||
+            conf->subvolume_cnt == 1) {
+            dht_iatt_merge(this, &local->stbuf, stbuf);
+            dht_iatt_merge(this, &local->postparent, postparent);
+        } else {
+            /* copy the gfid anyway */
+            gf_uuid_copy(local->stbuf.ia_gfid, stbuf->ia_gfid);
+        }
 
-                local->op_ret = 0;
+        local->op_ret = 0;
 
-                if (!local->xattr) {
-                        local->xattr = dict_ref (xattr);
-                } else if (is_dir) {
-                        dht_aggregate_xattr (local->xattr, xattr);
-                }
+        if (!local->xattr) {
+            local->xattr = dict_ref(xattr);
+        } else if (is_dir) {
+            dht_aggregate_xattr(local->xattr, xattr);
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (follow_link) {
-                gf_uuid_copy (local->gfid, stbuf->ia_gfid);
+    if (follow_link) {
+        gf_uuid_copy(local->gfid, stbuf->ia_gfid);
 
-                subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
-                if (!subvol) {
-                        op_errno = ESTALE;
-                        local->op_ret = -1;
-                } else {
-
-                        STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk,
-                                           subvol, subvol, subvol->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                        return 0;
-                }
+        subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
+        if (!subvol) {
+            op_errno = ESTALE;
+            local->op_ret = -1;
+        } else {
+            STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                              subvol->fops->lookup, &local->loc,
+                              local->xattr_req);
+            return 0;
         }
+    }
 
 out:
-        this_call_cnt = dht_frame_return (frame);
-
-        if (is_last_call (this_call_cnt)) {
-                if (!IA_ISDIR (local->stbuf.ia_type)
-                    && (local->hashed_subvol != local->cached_subvol)
-                    && (local->stbuf.ia_nlink == 1)
-                    && (conf && conf->unhashed_sticky_bit)) {
-                        local->stbuf.ia_prot.sticky = 1;
-                }
-                /* No need to call heal code if volume count is 1
+    this_call_cnt = dht_frame_return(frame);
+
+    if (is_last_call(this_call_cnt)) {
+        if (!IA_ISDIR(local->stbuf.ia_type) &&
+            (local->hashed_subvol != local->cached_subvol) &&
+            (local->stbuf.ia_nlink == 1) &&
+            (conf && conf->unhashed_sticky_bit)) {
+            local->stbuf.ia_prot.sticky = 1;
+        }
+        /* No need to call heal code if volume count is 1
+         */
+        if (conf->subvolume_cnt == 1)
+            local->need_xattr_heal = 0;
+
+        if (IA_ISDIR(local->stbuf.ia_type)) {
+            /* Code to update all extended attributed from hashed
+               subvol to local->xattr and call heal code to heal
+               custom xattr from hashed subvol to non-hashed subvol
+            */
+            if (local->need_xattr_heal && (local->mds_xattr)) {
+                dht_dir_set_heal_xattr(this, local, local->xattr,
+                                       local->mds_xattr, NULL, NULL);
+                dict_unref(local->mds_xattr);
+                local->mds_xattr = NULL;
+                local->need_xattr_heal = 0;
+                ret = dht_dir_xattr_heal(this, local);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, ret,
+                           DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                           "xattr heal failed for directory %s "
+                           " gfid %s ",
+                           local->loc.path, gfid);
+            } else {
+                /* Call function to save hashed subvol on inode
+                   ctx if internal mds xattr is not present and
+                   all subvols are up
                 */
-                if (conf->subvolume_cnt == 1)
-                        local->need_xattr_heal = 0;
-
-                if (IA_ISDIR (local->stbuf.ia_type)) {
-                        /* Code to update all extended attributed from hashed
-                           subvol to local->xattr and call heal code to heal
-                           custom xattr from hashed subvol to non-hashed subvol
-                        */
-                        if (local->need_xattr_heal && (local->mds_xattr)) {
-                                dht_dir_set_heal_xattr (this, local,
-                                                        local->xattr,
-                                                        local->mds_xattr, NULL,
-                                                        NULL);
-                                dict_unref (local->mds_xattr);
-                                local->mds_xattr = NULL;
-                                local->need_xattr_heal = 0;
-                                ret =  dht_dir_xattr_heal (this, local);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                ret, DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                                "xattr heal failed for directory %s "
-                                                " gfid %s ", local->loc.path,
-                                                gfid);
-                        } else {
-                                /* Call function to save hashed subvol on inode
-                                   ctx if internal mds xattr is not present and
-                                   all subvols are up
-                                */
-                                if (inode && !__is_root_gfid (inode->gfid) &&
-                                    (!local->op_ret))
-                                        (void) dht_common_mark_mdsxattr (frame, NULL, 1);
-                        }
-                }
-                if (local->need_selfheal) {
-                        local->need_selfheal = 0;
-                        if (!__is_root_gfid (inode->gfid)) {
-                                gf_uuid_copy (local->gfid, local->mds_stbuf.ia_gfid);
-                                local->stbuf.ia_gid = local->mds_stbuf.ia_gid;
-                                local->stbuf.ia_uid = local->mds_stbuf.ia_uid;
-                                local->stbuf.ia_prot = local->mds_stbuf.ia_prot;
-                        } else {
-                                gf_uuid_copy (local->gfid, local->stbuf.ia_gfid);
-                                local->stbuf.ia_gid = local->prebuf.ia_gid;
-                                local->stbuf.ia_uid = local->prebuf.ia_uid;
-                                local->stbuf.ia_prot = local->prebuf.ia_prot;
-                        }
-
-                        copy = create_frame (this, this->ctx->pool);
-                        if (copy) {
-                                copy_local = dht_local_init (copy, &local->loc,
-                                                             NULL, 0);
-                                if (!copy_local) {
-                                        DHT_STACK_DESTROY (copy);
-                                        goto cont;
-                                }
-                                copy_local->stbuf = local->stbuf;
-                                copy_local->mds_stbuf = local->mds_stbuf;
-                                copy_local->mds_subvol = local->mds_subvol;
-                                copy->local = copy_local;
-                                FRAME_SU_DO (copy, dht_local_t);
-                                ret = synctask_new (this->ctx->env,
-                                                    dht_dir_attr_heal,
-                                                    dht_dir_attr_heal_done,
-                                                    copy, copy);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                                DHT_MSG_DIR_ATTR_HEAL_FAILED,
-                                                "Synctask creation failed to heal attr "
-                                                "for path %s gfid %s ",
-                                                local->loc.path, local->gfid);
-                                        DHT_STACK_DESTROY (copy);
-                                }
-                        }
-                }
-cont:
-                if (local->layout_mismatch) {
-                        /* Found layout mismatch in the directory, need to
-                           fix this in the inode context */
-                        dht_layout_unref (this, local->layout);
-                        local->layout = NULL;
-                        dht_lookup_directory (frame, this, &local->loc);
-                        return 0;
-                }
+                if (inode && !__is_root_gfid(inode->gfid) && (!local->op_ret))
+                    (void)dht_common_mark_mdsxattr(frame, NULL, 1);
+            }
+        }
+        if (local->need_selfheal) {
+            local->need_selfheal = 0;
+            if (!__is_root_gfid(inode->gfid)) {
+                gf_uuid_copy(local->gfid, local->mds_stbuf.ia_gfid);
+                local->stbuf.ia_gid = local->mds_stbuf.ia_gid;
+                local->stbuf.ia_uid = local->mds_stbuf.ia_uid;
+                local->stbuf.ia_prot = local->mds_stbuf.ia_prot;
+            } else {
+                gf_uuid_copy(local->gfid, local->stbuf.ia_gfid);
+                local->stbuf.ia_gid = local->prebuf.ia_gid;
+                local->stbuf.ia_uid = local->prebuf.ia_uid;
+                local->stbuf.ia_prot = local->prebuf.ia_prot;
+            }
 
-                if (local->need_lookup_everywhere) {
-                        /* As the current layout gave ENOENT error, we would
-                           need a new layout */
-                        dht_layout_unref (this, local->layout);
-                        local->layout = NULL;
-
-                        /* We know that current cached subvol is no more
-                           valid, get the new one */
-                        local->cached_subvol = NULL;
-                        dht_lookup_everywhere (frame, this, &local->loc);
-                        return 0;
-                }
-                if (local->return_estale) {
-                        local->op_ret = -1;
-                        local->op_errno = ESTALE;
+            copy = create_frame(this, this->ctx->pool);
+            if (copy) {
+                copy_local = dht_local_init(copy, &local->loc, NULL, 0);
+                if (!copy_local) {
+                    DHT_STACK_DESTROY(copy);
+                    goto cont;
+                }
+                copy_local->stbuf = local->stbuf;
+                copy_local->mds_stbuf = local->mds_stbuf;
+                copy_local->mds_subvol = local->mds_subvol;
+                copy->local = copy_local;
+                FRAME_SU_DO(copy, dht_local_t);
+                ret = synctask_new(this->ctx->env, dht_dir_attr_heal,
+                                   dht_dir_attr_heal_done, copy, copy);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                           DHT_MSG_DIR_ATTR_HEAL_FAILED,
+                           "Synctask creation failed to heal attr "
+                           "for path %s gfid %s ",
+                           local->loc.path, local->gfid);
+                    DHT_STACK_DESTROY(copy);
                 }
+            }
+        }
+    cont:
+        if (local->layout_mismatch) {
+            /* Found layout mismatch in the directory, need to
+               fix this in the inode context */
+            dht_layout_unref(this, local->layout);
+            local->layout = NULL;
+            dht_lookup_directory(frame, this, &local->loc);
+            return 0;
+        }
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        if (local->need_lookup_everywhere) {
+            /* As the current layout gave ENOENT error, we would
+               need a new layout */
+            dht_layout_unref(this, local->layout);
+            local->layout = NULL;
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-
-                /* local->stbuf is updated only from subvols which have a layout
-                 * The reason is to avoid choosing attr heal source from newly
-                 * added bricks. In case e.g we have only one subvol and for
-                 * some reason layout is not present on it, then local->stbuf
-                 * will be EINVAL. This is an indication that the subvols
-                 * active in the cluster do not have layouts on disk.
-                 * Unwind with ESTALE to trigger a fresh lookup */
-                if (is_dir && local->stbuf.ia_type == IA_INVAL) {
-                        local->op_ret = -1;
-                        local->op_errno = ESTALE;
-                }
-                /* Delete mds xattr at the time of STACK UNWIND */
-                if (local->xattr)
-                        GF_REMOVE_INTERNAL_XATTR (conf->mds_xattr_key, local->xattr);
+            /* We know that current cached subvol is no more
+               valid, get the new one */
+            local->cached_subvol = NULL;
+            dht_lookup_everywhere(frame, this, &local->loc);
+            return 0;
+        }
+        if (local->return_estale) {
+            local->op_ret = -1;
+            local->op_errno = ESTALE;
+        }
 
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                                  local->inode, &local->stbuf, local->xattr,
-                                  &local->postparent);
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
 
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+
+        /* local->stbuf is updated only from subvols which have a layout
+         * The reason is to avoid choosing attr heal source from newly
+         * added bricks. In case e.g we have only one subvol and for
+         * some reason layout is not present on it, then local->stbuf
+         * will be EINVAL. This is an indication that the subvols
+         * active in the cluster do not have layouts on disk.
+         * Unwind with ESTALE to trigger a fresh lookup */
+        if (is_dir && local->stbuf.ia_type == IA_INVAL) {
+            local->op_ret = -1;
+            local->op_errno = ESTALE;
+        }
+        /* Delete mds xattr at the time of STACK UNWIND */
+        if (local->xattr)
+            GF_REMOVE_INTERNAL_XATTR(conf->mds_xattr_key, local->xattr);
+
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+    }
+
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_lookup_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this,
-                                int32_t op_ret, int32_t op_errno,
-                                inode_t *inode, struct iatt *stbuf,
-                                struct iatt *preparent, struct iatt *postparent,
-                                dict_t *xdata)
+dht_lookup_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               inode_t *inode, struct iatt *stbuf,
+                               struct iatt *preparent, struct iatt *postparent,
+                               dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *cached_subvol = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-
-        local = frame->local;
-        cached_subvol = local->cached_subvol;
-        conf = this->private;
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
 
-        gf_uuid_unparse(local->loc.gfid, gfid);
+    local = frame->local;
+    cached_subvol = local->cached_subvol;
+    conf = this->private;
 
-        if (local->locked)
-                dht_unlock_namespace (frame, &local->lock[0]);
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        ret = dht_layout_preset (this, local->cached_subvol, local->loc.inode);
-        if (ret < 0) {
-                gf_msg_debug (this->name, EINVAL,
-                              "Failed to set layout for subvolume %s, "
-                              "(gfid = %s)",
-                              cached_subvol ? cached_subvol->name : "<nil>",
-                              gfid);
-                local->op_ret = -1;
-                local->op_errno = EINVAL;
-                goto unwind;
-        }
+    if (local->locked)
+        dht_unlock_namespace(frame, &local->lock[0]);
 
-        local->op_ret = 0;
-        if ((local->stbuf.ia_nlink == 1)
-            && (conf && conf->unhashed_sticky_bit)) {
-                local->stbuf.ia_prot.sticky = 1;
-        }
+    ret = dht_layout_preset(this, local->cached_subvol, local->loc.inode);
+    if (ret < 0) {
+        gf_msg_debug(this->name, EINVAL,
+                     "Failed to set layout for subvolume %s, "
+                     "(gfid = %s)",
+                     cached_subvol ? cached_subvol->name : "<nil>", gfid);
+        local->op_ret = -1;
+        local->op_errno = EINVAL;
+        goto unwind;
+    }
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+    local->op_ret = 0;
+    if ((local->stbuf.ia_nlink == 1) && (conf && conf->unhashed_sticky_bit)) {
+        local->stbuf.ia_prot.sticky = 1;
+    }
 
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
 unwind:
-        gf_msg_debug (this->name, 0,
-                      "creation of linkto on hashed subvol:%s, "
-                      "returned with op_ret %d and op_errno %d: %s",
-                      local->hashed_subvol->name,
-                      op_ret, op_errno, uuid_utoa (local->loc.gfid));
+    gf_msg_debug(this->name, 0,
+                 "creation of linkto on hashed subvol:%s, "
+                 "returned with op_ret %d and op_errno %d: %s",
+                 local->hashed_subvol->name, op_ret, op_errno,
+                 uuid_utoa(local->loc.gfid));
 
-        if (local->linked == _gf_true)
-                dht_linkfile_attr_heal (frame, this);
+    if (local->linked == _gf_true)
+        dht_linkfile_attr_heal(frame, this);
 
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        dht_set_fixed_dir_stat (&local->postparent);
-
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_lookup_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       struct iatt *preparent, struct iatt *postparent,
-                       dict_t *xdata)
+dht_lookup_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        const char      *path =  NULL;
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        local =  (dht_local_t*)frame->local;
-        path = local->loc.path;
-        FRAME_SU_UNDO (frame, dht_local_t);
+    local = (dht_local_t *)frame->local;
+    path = local->loc.path;
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO, "lookup_unlink returned with "
-                "op_ret -> %d and op-errno -> %d for %s", op_ret, op_errno,
-                ((path == NULL)? "null" : path ));
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "lookup_unlink returned with "
+           "op_ret -> %d and op-errno -> %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_lookup_everywhere_done (frame, this);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_lookup_everywhere_done(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_lookup_unlink_of_false_linkto_cbk (call_frame_t *frame, void *cookie,
-                                       xlator_t *this, int op_ret, int op_errno,
-                                       struct iatt *preparent,
-                                       struct iatt *postparent, dict_t *xdata)
+dht_lookup_unlink_of_false_linkto_cbk(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int op_ret, int op_errno,
+                                      struct iatt *preparent,
+                                      struct iatt *postparent, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        const char      *path =  NULL;
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        local =  (dht_local_t*)frame->local;
-        path = local->loc.path;
-
-        FRAME_SU_UNDO (frame, dht_local_t);
+    local = (dht_local_t *)frame->local;
+    path = local->loc.path;
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO, "lookup_unlink returned with "
-                "op_ret -> %d and op-errno -> %d for %s", op_ret, op_errno,
-                ((path == NULL)? "null" : path ));
+    FRAME_SU_UNDO(frame, dht_local_t);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "lookup_unlink returned with "
+           "op_ret -> %d and op-errno -> %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-                if (op_ret == 0) {
-                        dht_lookup_everywhere_done (frame, this);
-                } else {
-                       /*When dht_lookup_everywhere is performed, one cached
-                         *and one hashed file was found and hashed file does
-                         *not point to the above mentioned cached node. So it
-                         *was considered as stale and an unlink was performed.
-                         *But unlink fails. So may be rebalance is in progress.
-                        *now ideally we have two data-files. One obtained during
-                         *lookup_everywhere and one where unlink-failed. So
-                         *at this point in time we cannot decide which one to
-                         *choose because there are chances of first cached
-                         *file is truncated after rebalance and if it is chosen
-                        *as cached node, application will fail. So return EIO.*/
-
-                        if (op_errno == EBUSY) {
-
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_UNLINK_FAILED,
-                                        "Could not unlink the linkto file as "
-                                        "either fd is open and/or linkto xattr "
-                                        "is set for %s",
-                                        ((path == NULL)? "null":path));
-
-                        }
-                        DHT_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL,
-                                          NULL, NULL);
-
-                }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (op_ret == 0) {
+            dht_lookup_everywhere_done(frame, this);
+        } else {
+            /*When dht_lookup_everywhere is performed, one cached
+             *and one hashed file was found and hashed file does
+             *not point to the above mentioned cached node. So it
+             *was considered as stale and an unlink was performed.
+             *But unlink fails. So may be rebalance is in progress.
+             *now ideally we have two data-files. One obtained during
+             *lookup_everywhere and one where unlink-failed. So
+             *at this point in time we cannot decide which one to
+             *choose because there are chances of first cached
+             *file is truncated after rebalance and if it is chosen
+             *as cached node, application will fail. So return EIO.*/
+
+            if (op_errno == EBUSY) {
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_UNLINK_FAILED,
+                       "Could not unlink the linkto file as "
+                       "either fd is open and/or linkto xattr "
+                       "is set for %s",
+                       ((path == NULL) ? "null" : path));
+            }
+            DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_lookup_unlink_stale_linkto_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata)
+dht_lookup_unlink_stale_linkto_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int op_ret, int op_errno,
+                                   struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata)
 {
+    dht_local_t *local = NULL;
+    const char *path = NULL;
 
-        dht_local_t     *local = NULL;
-        const char      *path  = NULL;
-
-        /* NOTE:
-         * If stale file unlink fails either there is an open-fd or is not an
-         * dht-linkto-file then posix_unlink returns EBUSY, which is overwritten
-         *  to ENOENT
-         */
+    /* NOTE:
+     * If stale file unlink fails either there is an open-fd or is not an
+     * dht-linkto-file then posix_unlink returns EBUSY, which is overwritten
+     *  to ENOENT
+     */
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local && local->loc.path)
-                path = local->loc.path;
+    if (local && local->loc.path)
+        path = local->loc.path;
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_UNLINK_LOOKUP_INFO,
-                "Returned with op_ret %d and "
-                "op_errno %d for %s", op_ret, op_errno,
-                ((path==NULL)?"null":path));
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_UNLINK_LOOKUP_INFO,
+           "Returned with op_ret %d and "
+           "op_errno %d for %s",
+           op_ret, op_errno, ((path == NULL) ? "null" : path));
 
-        FRAME_SU_UNDO (frame, dht_local_t);
-        DHT_STACK_UNWIND (lookup, frame, -1, ENOENT, NULL, NULL, NULL,
-                          NULL);
+    FRAME_SU_UNDO(frame, dht_local_t);
+    DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fill_dict_to_avoid_unlink_of_migrating_file (dict_t *dict) {
-
-        int                      ret = 0;
-        xlator_t                *this           = NULL;
-        char                    *linktoskip_key = NULL;
-
-        this    = THIS;
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
+dht_fill_dict_to_avoid_unlink_of_migrating_file(dict_t *dict)
+{
+    int ret = 0;
+    xlator_t *this = NULL;
+    char *linktoskip_key = NULL;
 
-        if (dht_is_tier_xlator (this))
-                linktoskip_key = TIER_SKIP_NON_LINKTO_UNLINK;
-        else
-                linktoskip_key = DHT_SKIP_NON_LINKTO_UNLINK;
+    this = THIS;
+    GF_VALIDATE_OR_GOTO("dht", this, err);
 
-        ret = dict_set_int32 (dict, linktoskip_key, 1);
+    if (dht_is_tier_xlator(this))
+        linktoskip_key = TIER_SKIP_NON_LINKTO_UNLINK;
+    else
+        linktoskip_key = DHT_SKIP_NON_LINKTO_UNLINK;
 
-        if (ret)
-                goto err;
+    ret = dict_set_int32(dict, linktoskip_key, 1);
 
-        ret =  dict_set_int32 (dict, DHT_SKIP_OPEN_FD_UNLINK, 1);
+    if (ret)
+        goto err;
 
-        if (ret)
-                goto err;
+    ret = dict_set_int32(dict, DHT_SKIP_OPEN_FD_UNLINK, 1);
 
+    if (ret)
+        goto err;
 
-        return 0;
+    return 0;
 
 err:
-        return -1;
-
+    return -1;
 }
 
 int32_t
-dht_linkfile_create_lookup_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno, inode_t *inode,
-                                struct iatt *buf, dict_t *xdata,
-                                struct iatt *postparent)
-{
-        dht_local_t *local                      = NULL;
-        int          call_cnt                   = 0, ret = 0;
-        xlator_t    *subvol                     = NULL;
-        uuid_t       gfid                       = {0, };
-        char         gfid_str[GF_UUID_BUF_SIZE] = {0};
-
-        subvol = cookie;
-        local = frame->local;
+dht_linkfile_create_lookup_cbk(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               inode_t *inode, struct iatt *buf, dict_t *xdata,
+                               struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int call_cnt = 0, ret = 0;
+    xlator_t *subvol = NULL;
+    uuid_t gfid = {
+        0,
+    };
+    char gfid_str[GF_UUID_BUF_SIZE] = {0};
+
+    subvol = cookie;
+    local = frame->local;
+
+    if (subvol == local->hashed_subvol) {
+        if ((op_ret == 0) || (op_errno != ENOENT))
+            local->dont_create_linkto = _gf_true;
+    } else {
+        if (gf_uuid_is_null(local->gfid))
+            gf_uuid_copy(gfid, local->loc.gfid);
+        else
+            gf_uuid_copy(gfid, local->gfid);
+
+        if ((op_ret == 0) && gf_uuid_compare(gfid, buf->ia_gfid)) {
+            gf_uuid_unparse(gfid, gfid_str);
+            gf_msg_debug(this->name, 0,
+                         "gfid (%s) different on cached subvol "
+                         "(%s) and looked up inode (%s), not "
+                         "creating linkto",
+                         uuid_utoa(buf->ia_gfid), subvol->name, gfid_str);
+            local->dont_create_linkto = _gf_true;
+        } else if (op_ret == -1) {
+            local->dont_create_linkto = _gf_true;
+        }
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->dont_create_linkto)
+            goto no_linkto;
+        else {
+            gf_msg_debug(this->name, 0,
+                         "Creating linkto file on %s(hash) to "
+                         "%s on %s (gfid = %s)",
+                         local->hashed_subvol->name, local->loc.path,
+                         local->cached_subvol->name, gfid);
 
-        if (subvol == local->hashed_subvol) {
-                if ((op_ret == 0) || (op_errno != ENOENT))
-                        local->dont_create_linkto = _gf_true;
-        } else {
-                if (gf_uuid_is_null (local->gfid))
-                        gf_uuid_copy (gfid, local->loc.gfid);
-                else
-                        gf_uuid_copy (gfid, local->gfid);
-
-                if ((op_ret == 0) && gf_uuid_compare (gfid, buf->ia_gfid)) {
-                        gf_uuid_unparse (gfid, gfid_str);
-                        gf_msg_debug (this->name, 0,
-                                      "gfid (%s) different on cached subvol "
-                                      "(%s) and looked up inode (%s), not "
-                                      "creating linkto",
-                                      uuid_utoa (buf->ia_gfid), subvol->name,
-                                      gfid_str);
-                        local->dont_create_linkto = _gf_true;
-                } else if (op_ret == -1) {
-                        local->dont_create_linkto = _gf_true;
-                }
-        }
+            ret = dht_linkfile_create(frame, dht_lookup_linkfile_create_cbk,
+                                      this, local->cached_subvol,
+                                      local->hashed_subvol, &local->loc);
 
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                if (local->dont_create_linkto)
-                        goto no_linkto;
-                else {
-                        gf_msg_debug (this->name, 0,
-                                      "Creating linkto file on %s(hash) to "
-                                      "%s on %s (gfid = %s)",
-                                      local->hashed_subvol->name,
-                                      local->loc.path,
-                                      local->cached_subvol->name, gfid);
-
-                        ret = dht_linkfile_create
-                                (frame, dht_lookup_linkfile_create_cbk,
-                                 this, local->cached_subvol,
-                                 local->hashed_subvol, &local->loc);
-
-                        if (ret < 0)
-                                goto no_linkto;
-                }
+            if (ret < 0)
+                goto no_linkto;
         }
+    }
 
-        return 0;
+    return 0;
 
 no_linkto:
-        gf_msg_debug (this->name, 0,
-                      "skipped linkto creation (path:%s) (gfid:%s) "
-                      "(hashed-subvol:%s) (cached-subvol:%s)",
-                      local->loc.path, gfid_str, local->hashed_subvol->name,
-                      local->cached_subvol->name);
-
-        dht_lookup_linkfile_create_cbk (frame, NULL, this, 0, 0,
-                                        local->loc.inode, &local->stbuf,
-                                        &local->preparent, &local->postparent,
-                                        local->xattr);
-        return 0;
-}
+    gf_msg_debug(this->name, 0,
+                 "skipped linkto creation (path:%s) (gfid:%s) "
+                 "(hashed-subvol:%s) (cached-subvol:%s)",
+                 local->loc.path, gfid_str, local->hashed_subvol->name,
+                 local->cached_subvol->name);
 
+    dht_lookup_linkfile_create_cbk(frame, NULL, this, 0, 0, local->loc.inode,
+                                   &local->stbuf, &local->preparent,
+                                   &local->postparent, local->xattr);
+    return 0;
+}
 
 int32_t
-dht_call_lookup_linkfile_create (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *xdata)
+dht_call_lookup_linkfile_create(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local          = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0};
-        int          i              = 0;
-        xlator_t    *subvol         = NULL;
-
-        local = frame->local;
-        if (gf_uuid_is_null (local->gfid))
-                gf_uuid_unparse (local->loc.gfid, gfid);
-        else
-                gf_uuid_unparse (local->gfid, gfid);
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int i = 0;
+    xlator_t *subvol = NULL;
 
-        if (op_ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "protecting namespace failed, skipping linkto "
-                        "creation (path:%s)(gfid:%s)(hashed-subvol:%s)"
-                        "(cached-subvol:%s)", local->loc.path, gfid,
-                        local->hashed_subvol->name, local->cached_subvol->name);
-                goto err;
-        }
+    local = frame->local;
+    if (gf_uuid_is_null(local->gfid))
+        gf_uuid_unparse(local->loc.gfid, gfid);
+    else
+        gf_uuid_unparse(local->gfid, gfid);
 
-        local->locked = _gf_true;
+    if (op_ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "protecting namespace failed, skipping linkto "
+               "creation (path:%s)(gfid:%s)(hashed-subvol:%s)"
+               "(cached-subvol:%s)",
+               local->loc.path, gfid, local->hashed_subvol->name,
+               local->cached_subvol->name);
+        goto err;
+    }
 
+    local->locked = _gf_true;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        for (i = 0; i < 2; i++) {
-                subvol = (subvol == NULL) ? local->hashed_subvol
-                        : local->cached_subvol;
+    for (i = 0; i < 2; i++) {
+        subvol = (subvol == NULL) ? local->hashed_subvol : local->cached_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_linkfile_create_lookup_cbk,
-                                   subvol, subvol, subvol->fops->lookup,
-                                   &local->loc, NULL);
-        }
+        STACK_WIND_COOKIE(frame, dht_linkfile_create_lookup_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, NULL);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_lookup_linkfile_create_cbk (frame, NULL, this, 0, 0,
-                                        local->loc.inode,
-                                        &local->stbuf, &local->preparent,
-                                        &local->postparent, local->xattr);
-        return 0;
+    dht_lookup_linkfile_create_cbk(frame, NULL, this, 0, 0, local->loc.inode,
+                                   &local->stbuf, &local->preparent,
+                                   &local->postparent, local->xattr);
+    return 0;
 }
 
 /* Rebalance is performed from cached_node to hashed_node. Initial cached_node
@@ -2387,760 +2235,693 @@ err:
  */
 
 int
-dht_lookup_everywhere_done (call_frame_t *frame, xlator_t *this)
-{
-        int           ret                        = 0;
-        dht_local_t  *local                      = NULL;
-        xlator_t     *hashed_subvol              = NULL;
-        xlator_t     *cached_subvol              = NULL;
-        dht_layout_t *layout                     = NULL;
-        char gfid[GF_UUID_BUF_SIZE]              = {0};
-        gf_boolean_t  found_non_linkto_on_hashed = _gf_false;
-
-        local = frame->local;
-        hashed_subvol = local->hashed_subvol;
-        cached_subvol = local->cached_subvol;
+dht_lookup_everywhere_done(call_frame_t *frame, xlator_t *this)
+{
+    int ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_layout_t *layout = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    gf_boolean_t found_non_linkto_on_hashed = _gf_false;
+
+    local = frame->local;
+    hashed_subvol = local->hashed_subvol;
+    cached_subvol = local->cached_subvol;
+
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    if (local->file_count && local->dir_count) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_FILE_TYPE_MISMATCH,
+               "path %s (gfid = %s)exists as a file on one "
+               "subvolume and directory on another. "
+               "Please fix it manually",
+               local->loc.path, gfid);
+        DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL, NULL, NULL);
+        return 0;
+    }
+
+    if (local->dir_count) {
+        dht_lookup_directory(frame, this, &local->loc);
+        return 0;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "STATUS: hashed_subvol %s "
+                 "cached_subvol %s",
+                 (hashed_subvol == NULL) ? "null" : hashed_subvol->name,
+                 (cached_subvol == NULL) ? "null" : cached_subvol->name);
+
+    if (!cached_subvol) {
+        if (local->skip_unlink.handle_valid_link && hashed_subvol) {
+            /*Purpose of "DHT_SKIP_NON_LINKTO_UNLINK":
+             * If this lookup is performed by rebalance and this
+             * rebalance process detected hashed file and by
+             * the time it sends the lookup request to cached node,
+             * file got migrated and now at initial hashed_node,
+             * final migrated file is present. With current logic,
+             * because this process fails to find the cached_node,
+             * it will unlink the file at initial hashed_node.
+             *
+             * So we avoid this by setting key, and checking at the
+             * posix_unlink that unlink the file only if file is a
+             * linkto file and not a migrated_file.
+             */
+
+            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
+                local->xattr_req);
+
+            if (ret) {
+                /* If for some reason, setting key in the dict
+                 * fails, return with ENOENT, as with respect to
+                 * this process, it detected only a stale link
+                 * file.
+                 *
+                 * Next lookup will delete it.
+                 *
+                 * Performing deletion of stale link file when
+                 * setting key in dict fails, may cause the data
+                 * loss because of the above mentioned race.
+                 */
 
-        gf_uuid_unparse (local->loc.gfid, gfid);
-
-        if (local->file_count && local->dir_count) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_FILE_TYPE_MISMATCH,
-                        "path %s (gfid = %s)exists as a file on one "
-                        "subvolume and directory on another. "
-                        "Please fix it manually",
-                        local->loc.path, gfid);
-                DHT_STACK_UNWIND (lookup, frame, -1, EIO, NULL, NULL, NULL,
-                                  NULL);
-                return 0;
-        }
+                DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL,
+                                 NULL);
+            } else {
+                local->skip_unlink.handle_valid_link = _gf_false;
 
-        if (local->dir_count) {
-                dht_lookup_directory (frame, this, &local->loc);
-                return 0;
-        }
-
-        gf_msg_debug (this->name, 0, "STATUS: hashed_subvol %s "
-                      "cached_subvol %s",
-                      (hashed_subvol == NULL)?"null":hashed_subvol->name,
-                      (cached_subvol == NULL)?"null":cached_subvol->name);
+                gf_msg_debug(this->name, 0,
+                             "No Cached was found and "
+                             "unlink on hashed was skipped"
+                             " so performing now: %s",
+                             local->loc.path);
+                FRAME_SU_DO(frame, dht_local_t);
+                STACK_WIND(frame, dht_lookup_unlink_stale_linkto_cbk,
+                           hashed_subvol, hashed_subvol->fops->unlink,
+                           &local->loc, 0, local->xattr_req);
+            }
 
-        if (!cached_subvol) {
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "There was no cached file and  "
+                         "unlink on hashed is not skipped %s",
+                         local->loc.path);
 
-                if (local->skip_unlink.handle_valid_link && hashed_subvol) {
-
-                        /*Purpose of "DHT_SKIP_NON_LINKTO_UNLINK":
-                         * If this lookup is performed by rebalance and this
-                         * rebalance process detected hashed file and by
-                         * the time it sends the lookup request to cached node,
-                         * file got migrated and now at initial hashed_node,
-                         * final migrated file is present. With current logic,
-                         * because this process fails to find the cached_node,
-                         * it will unlink the file at initial hashed_node.
-                         *
-                         * So we avoid this by setting key, and checking at the
-                         * posix_unlink that unlink the file only if file is a
-                         * linkto file and not a migrated_file.
-                         */
-
-
-                        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                              (local->xattr_req);
-
-                        if (ret) {
-                                /* If for some reason, setting key in the dict
-                                 * fails, return with ENOENT, as with respect to
-                                 * this process, it detected only a stale link
-                                 * file.
-                                 *
-                                 * Next lookup will delete it.
-                                 *
-                                 * Performing deletion of stale link file when
-                                 * setting key in dict fails, may cause the data
-                                 * loss because of the above mentioned race.
-                                 */
-
-
-                                DHT_STACK_UNWIND (lookup, frame, -1, ENOENT,
-                                                  NULL, NULL, NULL, NULL);
-                        } else {
-                                local->skip_unlink.handle_valid_link = _gf_false;
-
-                                gf_msg_debug (this->name, 0,
-                                              "No Cached was found and "
-                                              "unlink on hashed was skipped"
-                                              " so performing now: %s",
-                                              local->loc.path);
-                                FRAME_SU_DO (frame, dht_local_t);
-                                STACK_WIND (frame,
-                                            dht_lookup_unlink_stale_linkto_cbk,
-                                            hashed_subvol,
-                                            hashed_subvol->fops->unlink,
-                                            &local->loc, 0, local->xattr_req);
-                        }
-
-                } else  {
-
-                        gf_msg_debug (this->name, 0,
-                                      "There was no cached file and  "
-                                      "unlink on hashed is not skipped %s",
-                                      local->loc.path);
-
-                        DHT_STACK_UNWIND (lookup, frame, -1, ENOENT,
-                                          NULL, NULL, NULL, NULL);
-                }
-                return 0;
+            DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL, NULL);
         }
+        return 0;
+    }
 
-        /* At the time of dht_lookup, no file was found on hashed and that is
-         * why dht_lookup_everywhere is called, but by the time
-         * dht_lookup_everywhere
-         * reached to server, file might have already migrated. In that case we
-         * will find a migrated file at the hashed_node. In this case store the
-         * layout in context and return successfully.
-         */
-
-        if (hashed_subvol || local->need_lookup_everywhere) {
-
-                if (local->need_lookup_everywhere) {
-
-                        found_non_linkto_on_hashed = _gf_true;
-
-                } else if ((local->file_count == 1) &&
-                            (hashed_subvol == cached_subvol)) {
-
-                        gf_msg_debug (this->name, 0,
-                                      "found cached file on hashed subvolume "
-                                      "so store in context and return for %s",
-                                      local->loc.path);
+    /* At the time of dht_lookup, no file was found on hashed and that is
+     * why dht_lookup_everywhere is called, but by the time
+     * dht_lookup_everywhere
+     * reached to server, file might have already migrated. In that case we
+     * will find a migrated file at the hashed_node. In this case store the
+     * layout in context and return successfully.
+     */
 
-                        found_non_linkto_on_hashed = _gf_true;
-                }
+    if (hashed_subvol || local->need_lookup_everywhere) {
+        if (local->need_lookup_everywhere) {
+            found_non_linkto_on_hashed = _gf_true;
 
-                if (found_non_linkto_on_hashed)
-                        goto preset_layout;
+        } else if ((local->file_count == 1) &&
+                   (hashed_subvol == cached_subvol)) {
+            gf_msg_debug(this->name, 0,
+                         "found cached file on hashed subvolume "
+                         "so store in context and return for %s",
+                         local->loc.path);
 
+            found_non_linkto_on_hashed = _gf_true;
         }
 
+        if (found_non_linkto_on_hashed)
+            goto preset_layout;
+    }
 
-        if (hashed_subvol) {
-                if (local->skip_unlink.handle_valid_link == _gf_true) {
-                        if (cached_subvol == local->skip_unlink.hash_links_to) {
-
-                             if (gf_uuid_compare (local->skip_unlink.cached_gfid,
-                                               local->skip_unlink.hashed_gfid)){
-
-                                        /*GFID different, return error*/
-                                        DHT_STACK_UNWIND (lookup, frame, -1,
-                                                          ESTALE, NULL, NULL,
-                                                          NULL, NULL);
-
-                                        return 0;
-                                }
-
-                                ret = dht_layout_preset (this, cached_subvol,
-                                                         local->loc.inode);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                                "Could not set pre-set layout "
-                                                "for subvolume %s",
-                                                cached_subvol->name);
-                                }
-
-                                local->op_ret = (ret == 0) ? ret : -1;
-                                local->op_errno = (ret == 0) ? ret : EINVAL;
-
-                                /* Presence of local->cached_subvol validates
-                                 * that lookup from cached node is successful
-                                 */
-
-                                if (!local->op_ret && local->loc.parent) {
-                                        dht_inode_ctx_time_update
-                                                (local->loc.parent, this,
-                                                 &local->postparent, 1);
-                                }
-
-                                gf_msg_debug (this->name, 0,
-                                              "Skipped unlinking linkto file "
-                                              "on the hashed subvolume. "
-                                              "Returning success as it is a "
-                                              "valid linkto file. Path:%s"
-                                              ,local->loc.path);
+    if (hashed_subvol) {
+        if (local->skip_unlink.handle_valid_link == _gf_true) {
+            if (cached_subvol == local->skip_unlink.hash_links_to) {
+                if (gf_uuid_compare(local->skip_unlink.cached_gfid,
+                                    local->skip_unlink.hashed_gfid)) {
+                    /*GFID different, return error*/
+                    DHT_STACK_UNWIND(lookup, frame, -1, ESTALE, NULL, NULL,
+                                     NULL, NULL);
 
-                                goto unwind_hashed_and_cached;
-                        } else {
-
-                               local->skip_unlink.handle_valid_link = _gf_false;
-
-                               gf_msg_debug (this->name, 0,
-                                             "Linkto file found on hashed "
-                                             "subvol "
-                                             "and data file found on cached "
-                                             "subvolume. But linkto points to "
-                                             "different cached subvolume (%s) "
-                                             "path %s",
-                                            (local->skip_unlink.hash_links_to ?
-                                        local->skip_unlink.hash_links_to->name :
-                                             " <nil>"), local->loc.path);
-
-                               if (local->skip_unlink.opend_fd_count == 0) {
+                    return 0;
+                }
 
+                ret = dht_layout_preset(this, cached_subvol, local->loc.inode);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_INFO, 0,
+                           DHT_MSG_LAYOUT_PRESET_FAILED,
+                           "Could not set pre-set layout "
+                           "for subvolume %s",
+                           cached_subvol->name);
+                }
 
-                          ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                                  (local->xattr_req);
+                local->op_ret = (ret == 0) ? ret : -1;
+                local->op_errno = (ret == 0) ? ret : EINVAL;
 
+                /* Presence of local->cached_subvol validates
+                 * that lookup from cached node is successful
+                 */
 
-                                        if (ret) {
-                                          DHT_STACK_UNWIND (lookup, frame, -1,
-                                                            EIO, NULL, NULL,
-                                                            NULL, NULL);
-                                        } else {
-                                                local->call_cnt = 1;
-                                                FRAME_SU_DO (frame, dht_local_t);
-                                                STACK_WIND (frame,
-                                          dht_lookup_unlink_of_false_linkto_cbk,
-                                                    hashed_subvol,
-                                                    hashed_subvol->fops->unlink,
-                                                    &local->loc, 0,
-                                                    local->xattr_req);
-                                        }
+                if (!local->op_ret && local->loc.parent) {
+                    dht_inode_ctx_time_update(local->loc.parent, this,
+                                              &local->postparent, 1);
+                }
 
-                                        return 0;
+                gf_msg_debug(this->name, 0,
+                             "Skipped unlinking linkto file "
+                             "on the hashed subvolume. "
+                             "Returning success as it is a "
+                             "valid linkto file. Path:%s",
+                             local->loc.path);
 
-                                }
-                        }
+                goto unwind_hashed_and_cached;
+            } else {
+                local->skip_unlink.handle_valid_link = _gf_false;
 
+                gf_msg_debug(this->name, 0,
+                             "Linkto file found on hashed "
+                             "subvol "
+                             "and data file found on cached "
+                             "subvolume. But linkto points to "
+                             "different cached subvolume (%s) "
+                             "path %s",
+                             (local->skip_unlink.hash_links_to
+                                  ? local->skip_unlink.hash_links_to->name
+                                  : " <nil>"),
+                             local->loc.path);
+
+                if (local->skip_unlink.opend_fd_count == 0) {
+                    ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
+                        local->xattr_req);
+
+                    if (ret) {
+                        DHT_STACK_UNWIND(lookup, frame, -1, EIO, NULL, NULL,
+                                         NULL, NULL);
+                    } else {
+                        local->call_cnt = 1;
+                        FRAME_SU_DO(frame, dht_local_t);
+                        STACK_WIND(frame, dht_lookup_unlink_of_false_linkto_cbk,
+                                   hashed_subvol, hashed_subvol->fops->unlink,
+                                   &local->loc, 0, local->xattr_req);
+                    }
+
+                    return 0;
                 }
+            }
         }
-
+    }
 
 preset_layout:
 
-        if (found_non_linkto_on_hashed) {
-
-                if (local->need_lookup_everywhere) {
-                        if (gf_uuid_compare (local->gfid, local->inode->gfid)) {
-                                /* GFID different, return error */
-                                DHT_STACK_UNWIND (lookup, frame, -1, ENOENT,
-                                                  NULL, NULL, NULL, NULL);
-                                return 0;
-                        }
-                }
-
-                local->op_ret = 0;
-                local->op_errno = 0;
-                layout = dht_layout_for_subvol (this, cached_subvol);
-                if (!layout) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "%s: no pre-set layout for subvolume %s,"
-                                " gfid = %s",
-                                local->loc.path, (cached_subvol ?
-                                                  cached_subvol->name :
-                                                  "<nil>"), gfid);
-                }
-
-                ret = dht_layout_set (this, local->inode, layout);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "%s: failed to set layout for subvol %s, "
-                                "gfid = %s",
-                                local->loc.path, (cached_subvol ?
-                                                  cached_subvol->name :
-                                                  "<nil>"), gfid);
-                }
-
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
-
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret,
-                                  local->op_errno, local->inode,
-                                  &local->stbuf, local->xattr,
-                                  &local->postparent);
+    if (found_non_linkto_on_hashed) {
+        if (local->need_lookup_everywhere) {
+            if (gf_uuid_compare(local->gfid, local->inode->gfid)) {
+                /* GFID different, return error */
+                DHT_STACK_UNWIND(lookup, frame, -1, ENOENT, NULL, NULL, NULL,
+                                 NULL);
                 return 0;
+            }
         }
 
-        if (!hashed_subvol) {
-
-                gf_msg_debug (this->name, 0,
-                              "Cannot create linkfile for %s on %s: "
-                              "hashed subvolume cannot be found, gfid = %s.",
-                              local->loc.path, cached_subvol->name, gfid);
+        local->op_ret = 0;
+        local->op_errno = 0;
+        layout = dht_layout_for_subvol(this, cached_subvol);
+        if (!layout) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                   "%s: no pre-set layout for subvolume %s,"
+                   " gfid = %s",
+                   local->loc.path,
+                   (cached_subvol ? cached_subvol->name : "<nil>"), gfid);
+        }
 
-                local->op_ret = 0;
-                local->op_errno = 0;
+        ret = dht_layout_set(this, local->inode, layout);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                   "%s: failed to set layout for subvol %s, "
+                   "gfid = %s",
+                   local->loc.path,
+                   (cached_subvol ? cached_subvol->name : "<nil>"), gfid);
+        }
 
-                ret = dht_layout_preset (frame->this, cached_subvol,
-                                         local->inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                "Failed to set layout for subvol %s"
-                                ", gfid = %s",
-                                cached_subvol ? cached_subvol->name :
-                                "<nil>", gfid);
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
-                }
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
+        return 0;
+    }
 
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (lookup, frame, local->op_ret,
-                                  local->op_errno, local->inode,
-                                  &local->stbuf, local->xattr,
-                                  &local->postparent);
-                return 0;
-        }
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "Cannot create linkfile for %s on %s: "
+                     "hashed subvolume cannot be found, gfid = %s.",
+                     local->loc.path, cached_subvol->name, gfid);
 
-        if (frame->root->op != GF_FOP_RENAME) {
-                local->current = &local->lock[0];
-                ret = dht_protect_namespace (frame, &local->loc, hashed_subvol,
-                                             &local->current->ns,
-                                             dht_call_lookup_linkfile_create);
-        } else {
-                gf_msg_debug (this->name, 0,
-                              "Creating linkto file on %s(hash) to %s on %s "
-                              "(gfid = %s)",
-                              hashed_subvol->name, local->loc.path,
-                              cached_subvol->name, gfid);
+        local->op_ret = 0;
+        local->op_errno = 0;
 
-                ret = dht_linkfile_create (frame,
-                                           dht_lookup_linkfile_create_cbk, this,
-                                           cached_subvol, hashed_subvol,
-                                           &local->loc);
+        ret = dht_layout_preset(frame->this, cached_subvol, local->inode);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+                   "Failed to set layout for subvol %s"
+                   ", gfid = %s",
+                   cached_subvol ? cached_subvol->name : "<nil>", gfid);
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
         }
 
-        return ret;
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
+        }
 
-unwind_hashed_and_cached:
-        DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (lookup, frame, local->op_ret, local->op_errno,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                         local->inode, &local->stbuf, local->xattr,
+                         &local->postparent);
         return 0;
-}
-
-int
-dht_lookup_everywhere_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno,
-                           inode_t *inode, struct iatt *buf, dict_t *xattr,
-                           struct iatt *postparent)
-{
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev          = NULL;
-        int           is_linkfile   = 0;
-        int           is_dir        = 0;
-        loc_t        *loc           = NULL;
-        xlator_t     *link_subvol   = NULL;
-        int           ret           = -1;
-        int32_t       fd_count      = 0;
-        dht_conf_t   *conf          = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-        dict_t       *dict_req      = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-
-        local  = frame->local;
-        loc    = &local->loc;
-        conf   = this->private;
-
-        prev   = cookie;
-
-        gf_msg_debug (this->name, 0,
-                      "returned with op_ret %d and op_errno %d (%s) "
-                      "from subvol %s", op_ret, op_errno, loc->path,
-                      prev->name);
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno != ENOENT)
-                                local->op_errno = op_errno;
-                        goto unlock;
-                }
-
-                if (gf_uuid_is_null (local->gfid))
-                        gf_uuid_copy (local->gfid, buf->ia_gfid);
+    }
 
-                gf_uuid_unparse(local->gfid, gfid);
+    if (frame->root->op != GF_FOP_RENAME) {
+        local->current = &local->lock[0];
+        ret = dht_protect_namespace(frame, &local->loc, hashed_subvol,
+                                    &local->current->ns,
+                                    dht_call_lookup_linkfile_create);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Creating linkto file on %s(hash) to %s on %s "
+                     "(gfid = %s)",
+                     hashed_subvol->name, local->loc.path, cached_subvol->name,
+                     gfid);
+
+        ret = dht_linkfile_create(frame, dht_lookup_linkfile_create_cbk, this,
+                                  cached_subvol, hashed_subvol, &local->loc);
+    }
+
+    return ret;
 
-                if (gf_uuid_compare (local->gfid, buf->ia_gfid)) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "%s: gfid differs on subvolume %s,"
-                                " gfid local = %s, gfid node = %s",
-                                loc->path, prev->name, gfid,
-                                uuid_utoa(buf->ia_gfid));
-                }
+unwind_hashed_and_cached:
+    DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                     local->inode, &local->stbuf, local->xattr,
+                     &local->postparent);
+    return 0;
+}
+
+int
+dht_lookup_everywhere_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, inode_t *inode,
+                          struct iatt *buf, dict_t *xattr,
+                          struct iatt *postparent)
+{
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int is_linkfile = 0;
+    int is_dir = 0;
+    loc_t *loc = NULL;
+    xlator_t *link_subvol = NULL;
+    int ret = -1;
+    int32_t fd_count = 0;
+    dht_conf_t *conf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dict_t *dict_req = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+
+    local = frame->local;
+    loc = &local->loc;
+    conf = this->private;
+
+    prev = cookie;
+
+    gf_msg_debug(this->name, 0,
+                 "returned with op_ret %d and op_errno %d (%s) "
+                 "from subvol %s",
+                 op_ret, op_errno, loc->path, prev->name);
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno != ENOENT)
+                local->op_errno = op_errno;
+            goto unlock;
+        }
 
-                is_linkfile = check_is_linkfile (inode, buf, xattr,
-                                                 conf->link_xattr_name);
-
-                if (is_linkfile) {
-                        link_subvol = dht_linkfile_subvol (this, inode, buf,
-                                                           xattr);
-                        gf_msg_debug (this->name, 0,
-                                      "found on %s linkfile %s (-> %s)",
-                                      prev->name, loc->path,
-                                      link_subvol ? link_subvol->name : "''");
-                        goto unlock;
-                }
+        if (gf_uuid_is_null(local->gfid))
+            gf_uuid_copy(local->gfid, buf->ia_gfid);
 
-                is_dir = check_is_dir (inode, buf, xattr);
+        gf_uuid_unparse(local->gfid, gfid);
 
-                /* non linkfile GFID takes precedence but don't overwrite
-                 gfid if we have already found a cached file*/
-                if (!local->cached_subvol)
-                        gf_uuid_copy (local->gfid, buf->ia_gfid);
+        if (gf_uuid_compare(local->gfid, buf->ia_gfid)) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+                   "%s: gfid differs on subvolume %s,"
+                   " gfid local = %s, gfid node = %s",
+                   loc->path, prev->name, gfid, uuid_utoa(buf->ia_gfid));
+        }
 
-                if (is_dir) {
-                        local->dir_count++;
+        is_linkfile = check_is_linkfile(inode, buf, xattr,
+                                        conf->link_xattr_name);
 
-                        gf_msg_debug (this->name, 0,
-                                      "found on %s directory %s",
-                                      prev->name, loc->path);
-                } else {
-                        local->file_count++;
-
-                        gf_msg_debug (this->name, 0,
-                                      "found cached file on %s for %s",
-                                      prev->name, loc->path);
-
-                        if (!local->cached_subvol) {
-                                /* found one file */
-                                dht_iatt_merge (this, &local->stbuf, buf);
-
-                                local->xattr = dict_ref (xattr);
-                                local->cached_subvol = prev;
-
-                                gf_msg_debug (this->name, 0,
-                                              "storing cached on %s file"
-                                              " %s", prev->name, loc->path);
-
-                                dht_iatt_merge (this, &local->postparent,
-                                                postparent);
-
-                                gf_uuid_copy (local->skip_unlink.cached_gfid,
-                                           buf->ia_gfid);
-                        } else {
-                                /* This is where we need 'rename' both entries logic */
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_FILE_ON_MULT_SUBVOL,
-                                        "multiple subvolumes (%s and %s) have "
-                                        "file %s (preferably rename the file "
-                                        "in the backend,and do a fresh lookup)",
-                                        local->cached_subvol->name,
-                                        prev->name, local->loc.path);
-                        }
-                }
+        if (is_linkfile) {
+            link_subvol = dht_linkfile_subvol(this, inode, buf, xattr);
+            gf_msg_debug(this->name, 0, "found on %s linkfile %s (-> %s)",
+                         prev->name, loc->path,
+                         link_subvol ? link_subvol->name : "''");
+            goto unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        if (is_linkfile) {
-                ret = dict_get_int32 (xattr, GLUSTERFS_OPEN_FD_COUNT, &fd_count);
+        is_dir = check_is_dir(inode, buf, xattr);
 
-                /*  Any linkto file found on the non-hashed subvolume should
-                 *  be unlinked (performed in the "else if" block below)
-                 *
-                 *  But if a linkto file is found on hashed subvolume, it may be
-                 *  pointing to valid cached node. So unlinking of linkto
-                 *  file on hashed subvolume is skipped and inside
-                 *  dht_lookup_everywhere_done, checks are performed. If this
-                 *  linkto file is found as stale linkto file, it is deleted
-                 *  otherwise unlink is skipped.
-                 */
+        /* non linkfile GFID takes precedence but don't overwrite
+         gfid if we have already found a cached file*/
+        if (!local->cached_subvol)
+            gf_uuid_copy(local->gfid, buf->ia_gfid);
 
-                if (local->hashed_subvol && local->hashed_subvol == prev) {
-
-                        local->skip_unlink.handle_valid_link = _gf_true;
-                        local->skip_unlink.opend_fd_count = fd_count;
-                        local->skip_unlink.hash_links_to = link_subvol;
-                        gf_uuid_copy (local->skip_unlink.hashed_gfid,
-                                   buf->ia_gfid);
-
-                        gf_msg_debug (this->name, 0, "Found"
-                                      " one linkto file on hashed subvol %s "
-                                      "for %s: Skipping unlinking till "
-                                      "everywhere_done", prev->name,
-                                      loc->path);
-
-                } else if (!ret && (fd_count == 0)) {
-
-                        dict_req = dict_new ();
-
-                        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                              (dict_req);
-
-                        if (ret) {
-
-                                /* Skip unlinking for dict_failure
-                                 *File is found as a linkto file on non-hashed,
-                                 *subvolume. In the current implementation,
-                                 *finding a linkto-file on non-hashed does not
-                                 *always implies that it is stale. So deletion
-                                 *of file should be done only when both fd is
-                                 *closed and linkto-xattr is set. In case of
-                                 *dict_set failure, avoid skipping of file.
-                                 *NOTE: dht_frame_return should get called for
-                                 *      this block.
-                                 */
-
-                                dict_unref (dict_req);
-
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_SUBVOL_INFO,
-                                        "attempting deletion of stale linkfile "
-                                        "%s on %s (hashed subvol is %s)",
-                                        loc->path, prev->name,
-                                        (local->hashed_subvol?
-                                        local->hashed_subvol->name : "<null>"));
-                                /* *
-                                 * These stale files may be created using root
-                                 * user. Hence deletion will work only with
-                                 * root.
-                                 */
-                                FRAME_SU_DO (frame, dht_local_t);
-                                STACK_WIND (frame, dht_lookup_unlink_cbk,
-                                            prev, prev->fops->unlink, loc,
-                                            0, dict_req);
-
-                                dict_unref (dict_req);
-
-                                return 0;
-                        }
-                }
-        }
+        if (is_dir) {
+            local->dir_count++;
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_lookup_everywhere_done (frame, this);
-        }
+            gf_msg_debug(this->name, 0, "found on %s directory %s", prev->name,
+                         loc->path);
+        } else {
+            local->file_count++;
 
-out:
-        return ret;
-}
+            gf_msg_debug(this->name, 0, "found cached file on %s for %s",
+                         prev->name, loc->path);
 
+            if (!local->cached_subvol) {
+                /* found one file */
+                dht_iatt_merge(this, &local->stbuf, buf);
 
-int
-dht_lookup_everywhere (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        dht_conf_t     *conf = NULL;
-        dht_local_t    *local = NULL;
-        int             i = 0;
-        int             call_cnt = 0;
+                local->xattr = dict_ref(xattr);
+                local->cached_subvol = prev;
+
+                gf_msg_debug(this->name, 0,
+                             "storing cached on %s file"
+                             " %s",
+                             prev->name, loc->path);
+
+                dht_iatt_merge(this, &local->postparent, postparent);
+
+                gf_uuid_copy(local->skip_unlink.cached_gfid, buf->ia_gfid);
+            } else {
+                /* This is where we need 'rename' both entries logic */
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_FILE_ON_MULT_SUBVOL,
+                       "multiple subvolumes (%s and %s) have "
+                       "file %s (preferably rename the file "
+                       "in the backend,and do a fresh lookup)",
+                       local->cached_subvol->name, prev->name, local->loc.path);
+            }
+        }
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-        GF_VALIDATE_OR_GOTO ("dht", loc, out);
+    if (is_linkfile) {
+        ret = dict_get_int32(xattr, GLUSTERFS_OPEN_FD_COUNT, &fd_count);
 
-        conf = this->private;
-        local = frame->local;
+        /*  Any linkto file found on the non-hashed subvolume should
+         *  be unlinked (performed in the "else if" block below)
+         *
+         *  But if a linkto file is found on hashed subvolume, it may be
+         *  pointing to valid cached node. So unlinking of linkto
+         *  file on hashed subvolume is skipped and inside
+         *  dht_lookup_everywhere_done, checks are performed. If this
+         *  linkto file is found as stale linkto file, it is deleted
+         *  otherwise unlink is skipped.
+         */
 
-        call_cnt = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+        if (local->hashed_subvol && local->hashed_subvol == prev) {
+            local->skip_unlink.handle_valid_link = _gf_true;
+            local->skip_unlink.opend_fd_count = fd_count;
+            local->skip_unlink.hash_links_to = link_subvol;
+            gf_uuid_copy(local->skip_unlink.hashed_gfid, buf->ia_gfid);
+
+            gf_msg_debug(this->name, 0,
+                         "Found"
+                         " one linkto file on hashed subvol %s "
+                         "for %s: Skipping unlinking till "
+                         "everywhere_done",
+                         prev->name, loc->path);
+
+        } else if (!ret && (fd_count == 0)) {
+            dict_req = dict_new();
+
+            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(dict_req);
+
+            if (ret) {
+                /* Skip unlinking for dict_failure
+                 *File is found as a linkto file on non-hashed,
+                 *subvolume. In the current implementation,
+                 *finding a linkto-file on non-hashed does not
+                 *always implies that it is stale. So deletion
+                 *of file should be done only when both fd is
+                 *closed and linkto-xattr is set. In case of
+                 *dict_set failure, avoid skipping of file.
+                 *NOTE: dht_frame_return should get called for
+                 *      this block.
+                 */
 
-        if (!local->inode)
-                local->inode = inode_ref (loc->inode);
+                dict_unref(dict_req);
+
+            } else {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                       "attempting deletion of stale linkfile "
+                       "%s on %s (hashed subvol is %s)",
+                       loc->path, prev->name,
+                       (local->hashed_subvol ? local->hashed_subvol->name
+                                             : "<null>"));
+                /* *
+                 * These stale files may be created using root
+                 * user. Hence deletion will work only with
+                 * root.
+                 */
+                FRAME_SU_DO(frame, dht_local_t);
+                STACK_WIND(frame, dht_lookup_unlink_cbk, prev,
+                           prev->fops->unlink, loc, 0, dict_req);
 
-        gf_msg_debug (this->name, 0,
-                      "winding lookup call to %d subvols", call_cnt);
+                dict_unref(dict_req);
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_lookup_everywhere_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   loc, local->xattr_req);
+                return 0;
+            }
         }
+    }
+
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_lookup_everywhere_done(frame, this);
+    }
 
-        return 0;
 out:
-        DHT_STACK_UNWIND (lookup, frame, -1, EINVAL, NULL, NULL, NULL, NULL);
-err:
-        return -1;
+    return ret;
 }
 
-
 int
-dht_lookup_linkfile_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int op_ret, int op_errno,
-                         inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                         struct iatt *postparent)
+dht_lookup_everywhere(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-        xlator_t     *prev          = NULL;
-        dht_local_t  *local         = NULL;
-        xlator_t     *subvol        = NULL;
-        loc_t        *loc           = NULL;
-        dht_conf_t   *conf          = NULL;
-        int           ret           = 0;
-        char          gfid[GF_UUID_BUF_SIZE]     = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, unwind);
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    int call_cnt = 0;
 
-        prev   = cookie;
-        subvol = prev;
-        conf   = this->private;
-        local  = frame->local;
-        loc    = &local->loc;
-
-        gf_uuid_unparse(loc->gfid, gfid);
-
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "Lookup of %s on %s (following linkfile) failed "
-                        ",gfid = %s", local->loc.path, subvol->name, gfid);
-
-                /* If cached subvol returned ENOTCONN, do not do
-                lookup_everywhere. We need to make sure linkfile does not get
-                removed, which can take away the namespace, and subvol is
-                anyways down. */
-
-                local->cached_subvol = NULL;
-                if (op_errno != ENOTCONN)
-                        goto err;
-                else
-                        goto unwind;
-        }
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+    GF_VALIDATE_OR_GOTO("dht", loc, out);
 
-        if (check_is_dir (inode, stbuf, xattr)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "Lookup of %s on %s (following linkfile) reached dir,"
-                        " gfid = %s", local->loc.path, subvol->name, gfid);
-                goto err;
-        }
+    conf = this->private;
+    local = frame->local;
 
-        if (check_is_linkfile (inode, stbuf, xattr, conf->link_xattr_name)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LINK_FILE_LOOKUP_INFO,
-                        "lookup of %s on %s (following linkfile) reached link,"
-                        "gfid = %s", local->loc.path, subvol->name, gfid);
-                goto err;
-        }
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        if (gf_uuid_compare (local->gfid, stbuf->ia_gfid)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on data file on %s,"
-                        " gfid local = %s, gfid node = %s ",
-                        local->loc.path, subvol->name, gfid,
-                        uuid_utoa(stbuf->ia_gfid));
-                goto err;
-        }
+    if (!local->inode)
+        local->inode = inode_ref(loc->inode);
 
-        if ((stbuf->ia_nlink == 1)
-            && (conf && conf->unhashed_sticky_bit)) {
-                stbuf->ia_prot.sticky = 1;
-        }
+    gf_msg_debug(this->name, 0, "winding lookup call to %d subvols", call_cnt);
 
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LAYOUT_PRESET_FAILED,
-                        "Failed to set layout for subvolume %s,"
-                        "gfid = %s", prev->name, gfid);
-                op_ret   = -1;
-                op_errno = EINVAL;
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_lookup_everywhere_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, loc,
+                          local->xattr_req);
+    }
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+    return 0;
+out:
+    DHT_STACK_UNWIND(lookup, frame, -1, EINVAL, NULL, NULL, NULL, NULL);
+err:
+    return -1;
+}
+
+int
+dht_lookup_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, dict_t *xattr,
+                        struct iatt *postparent)
+{
+    xlator_t *prev = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    loc_t *loc = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, unwind);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, unwind);
+    GF_VALIDATE_OR_GOTO("dht", this->private, unwind);
+    GF_VALIDATE_OR_GOTO("dht", cookie, unwind);
+
+    prev = cookie;
+    subvol = prev;
+    conf = this->private;
+    local = frame->local;
+    loc = &local->loc;
+
+    gf_uuid_unparse(loc->gfid, gfid);
+
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "Lookup of %s on %s (following linkfile) failed "
+               ",gfid = %s",
+               local->loc.path, subvol->name, gfid);
+
+        /* If cached subvol returned ENOTCONN, do not do
+        lookup_everywhere. We need to make sure linkfile does not get
+        removed, which can take away the namespace, and subvol is
+        anyways down. */
+
+        local->cached_subvol = NULL;
+        if (op_errno != ENOTCONN)
+            goto err;
+        else
+            goto unwind;
+    }
+
+    if (check_is_dir(inode, stbuf, xattr)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "Lookup of %s on %s (following linkfile) reached dir,"
+               " gfid = %s",
+               local->loc.path, subvol->name, gfid);
+        goto err;
+    }
+
+    if (check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LINK_FILE_LOOKUP_INFO,
+               "lookup of %s on %s (following linkfile) reached link,"
+               "gfid = %s",
+               local->loc.path, subvol->name, gfid);
+        goto err;
+    }
+
+    if (gf_uuid_compare(local->gfid, stbuf->ia_gfid)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on data file on %s,"
+               " gfid local = %s, gfid node = %s ",
+               local->loc.path, subvol->name, gfid, uuid_utoa(stbuf->ia_gfid));
+        goto err;
+    }
+
+    if ((stbuf->ia_nlink == 1) && (conf && conf->unhashed_sticky_bit)) {
+        stbuf->ia_prot.sticky = 1;
+    }
+
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+               "Failed to set layout for subvolume %s,"
+               "gfid = %s",
+               prev->name, gfid);
+        op_ret = -1;
+        op_errno = EINVAL;
+    }
+
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
 unwind:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
-                          postparent);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     postparent);
 
-        return 0;
+    return 0;
 
 err:
-        dht_lookup_everywhere (frame, this, loc);
+    dht_lookup_everywhere(frame, this, loc);
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-dht_lookup_directory (call_frame_t *frame, xlator_t *this, loc_t *loc)
+dht_lookup_directory(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-        int           call_cnt = 0;
-        int           i = 0;
-        dht_conf_t   *conf = NULL;
-        dht_local_t  *local = NULL;
-        int           ret = 0;
+    int call_cnt = 0;
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, unwind);
-        GF_VALIDATE_OR_GOTO ("dht", loc, unwind);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, unwind);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, unwind);
+    GF_VALIDATE_OR_GOTO("dht", this->private, unwind);
+    GF_VALIDATE_OR_GOTO("dht", loc, unwind);
 
-        conf = this->private;
-        local = frame->local;
-
-        call_cnt        = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+    conf = this->private;
+    local = frame->local;
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
-        if (!local->layout) {
-                goto unwind;
-        }
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        if (local->xattr != NULL) {
-                dict_unref (local->xattr);
-                local->xattr = NULL;
-        }
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
+    if (!local->layout) {
+        goto unwind;
+    }
 
-        if (!gf_uuid_is_null (local->gfid)) {
-                ret = dict_set_gfuuid (local->xattr_req, "gfid-req",
-                                       local->gfid, true);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:"
-                                " key = gfid-req", local->loc.path);
-        }
+    if (local->xattr != NULL) {
+        dict_unref(local->xattr);
+        local->xattr = NULL;
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
-        }
-        return 0;
+    if (!gf_uuid_is_null(local->gfid)) {
+        ret = dict_set_gfuuid(local->xattr_req, "gfid-req", local->gfid, true);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: Failed to set dictionary value:"
+                   " key = gfid-req",
+                   local->loc.path);
+    }
+
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(
+            frame, dht_lookup_dir_cbk, conf->subvolumes[i], conf->subvolumes[i],
+            conf->subvolumes[i]->fops->lookup, &local->loc, local->xattr_req);
+    }
+    return 0;
 unwind:
-        DHT_STACK_UNWIND (lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
+    DHT_STACK_UNWIND(lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
 out:
-        return 0;
-
+    return 0;
 }
 
 /* Code to get hashed subvol based on inode and loc
@@ -3149,246 +2930,230 @@ out:
 */
 
 xlator_t *
-dht_inode_get_hashed_subvol (inode_t *inode, xlator_t *this, loc_t *loc)
-{
-        char                    *path           = NULL;
-        loc_t                    populate_loc   = {0, };
-        char                    *name           = NULL;
-        xlator_t                *hash_subvol    = NULL;
-
-        if (!inode)
-                return hash_subvol;
-
-        if (loc && loc->parent && loc->path) {
-                if (!loc->name) {
-                        name = strrchr (loc->path, '/');
-                        if (name) {
-                                loc->name = name + 1;
-                        } else {
-                                goto out;
-                        }
-                }
-                hash_subvol = dht_subvol_get_hashed (this, loc);
+dht_inode_get_hashed_subvol(inode_t *inode, xlator_t *this, loc_t *loc)
+{
+    char *path = NULL;
+    loc_t populate_loc = {
+        0,
+    };
+    char *name = NULL;
+    xlator_t *hash_subvol = NULL;
+
+    if (!inode)
+        return hash_subvol;
+
+    if (loc && loc->parent && loc->path) {
+        if (!loc->name) {
+            name = strrchr(loc->path, '/');
+            if (name) {
+                loc->name = name + 1;
+            } else {
                 goto out;
+            }
         }
+        hash_subvol = dht_subvol_get_hashed(this, loc);
+        goto out;
+    }
 
-        if (!gf_uuid_is_null (inode->gfid)) {
-                populate_loc.inode = inode_ref (inode);
-                populate_loc.parent = inode_parent (populate_loc.inode,
-                                                    NULL, NULL);
-                inode_path (populate_loc.inode, NULL, &path);
+    if (!gf_uuid_is_null(inode->gfid)) {
+        populate_loc.inode = inode_ref(inode);
+        populate_loc.parent = inode_parent(populate_loc.inode, NULL, NULL);
+        inode_path(populate_loc.inode, NULL, &path);
 
-                if (!path)
-                        goto out;
+        if (!path)
+            goto out;
 
-                populate_loc.path = path;
-                if (!populate_loc.name && populate_loc.path) {
-                        name = strrchr (populate_loc.path, '/');
-                        if (name) {
-                                populate_loc.name = name + 1;
+        populate_loc.path = path;
+        if (!populate_loc.name && populate_loc.path) {
+            name = strrchr(populate_loc.path, '/');
+            if (name) {
+                populate_loc.name = name + 1;
 
-                        } else {
-                                goto out;
-                        }
-                }
-                hash_subvol = dht_subvol_get_hashed (this, &populate_loc);
+            } else {
+                goto out;
+            }
         }
+        hash_subvol = dht_subvol_get_hashed(this, &populate_loc);
+    }
 out:
-        if (populate_loc.inode)
-                loc_wipe (&populate_loc);
-        return hash_subvol;
-}
-
-
-int
-dht_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno,
-                inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                struct iatt *postparent)
-{
-        char          is_linkfile   = 0;
-        char          is_dir        = 0;
-        xlator_t     *subvol        = NULL;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        loc_t        *loc           = NULL;
-        xlator_t     *prev          = NULL;
-        int           ret           = 0;
-        dht_layout_t *parent_layout = NULL;
-        uint32_t      vol_commit_hash = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, out);
-
-        conf  = this->private;
-
-        prev  = cookie;
-        local = frame->local;
-        loc   = &local->loc;
+    if (populate_loc.inode)
+        loc_wipe(&populate_loc);
+    return hash_subvol;
+}
+
+int
+dht_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, inode_t *inode, struct iatt *stbuf, dict_t *xattr,
+               struct iatt *postparent)
+{
+    char is_linkfile = 0;
+    char is_dir = 0;
+    xlator_t *subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    xlator_t *prev = NULL;
+    int ret = 0;
+    dht_layout_t *parent_layout = NULL;
+    uint32_t vol_commit_hash = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", this->private, out);
+
+    conf = this->private;
+
+    prev = cookie;
+    local = frame->local;
+    loc = &local->loc;
+
+    /* This is required for handling stale linkfile deletion,
+     * or any more call which happens from this 'loc'.
+     */
+    if (!op_ret && gf_uuid_is_null(local->gfid))
+        memcpy(local->gfid, stbuf->ia_gfid, 16);
+
+    gf_msg_debug(this->name, op_errno,
+                 "fresh_lookup returned for %s with op_ret %d", loc->path,
+                 op_ret);
+
+    if (!conf->vch_forced) {
+        ret = dict_get_uint32(xattr, conf->commithash_xattr_name,
+                              &vol_commit_hash);
+        if (ret == 0) {
+            conf->vol_commit_hash = vol_commit_hash;
+        }
+    }
 
-        /* This is required for handling stale linkfile deletion,
-         * or any more call which happens from this 'loc'.
-         */
-        if (!op_ret && gf_uuid_is_null (local->gfid))
-                memcpy (local->gfid, stbuf->ia_gfid, 16);
-
-        gf_msg_debug (this->name, op_errno,
-                      "fresh_lookup returned for %s with op_ret %d",
-                      loc->path, op_ret);
-
-        if (!conf->vch_forced) {
-                ret = dict_get_uint32 (xattr, conf->commithash_xattr_name,
-                                       &vol_commit_hash);
-                if (ret == 0) {
-                        conf->vol_commit_hash = vol_commit_hash;
-                }
+    if (ENTRY_MISSING(op_ret, op_errno)) {
+        if (1 == conf->subvolume_cnt) {
+            /* No need to lookup again */
+            goto out;
         }
 
-        if (ENTRY_MISSING (op_ret, op_errno)) {
+        gf_msg_debug(this->name, 0, "Entry %s missing on subvol %s", loc->path,
+                     prev->name);
 
-                if (1 == conf->subvolume_cnt) {
-                        /* No need to lookup again */
-                        goto out;
-                }
+        /* lookup-optimize supersedes lookup-unhashed settings,
+         *   - so if it is set, do not process search_unhashed
+         *   - except, in the case of rebalance daemon, we want to
+         *     force the lookup_everywhere behavior */
+        if (!conf->defrag && conf->lookup_optimize && loc->parent) {
+            ret = dht_inode_ctx_layout_get(loc->parent, this, &parent_layout);
+            if (ret || !parent_layout ||
+                (parent_layout->commit_hash != conf->vol_commit_hash)) {
+                gf_msg_debug(this->name, 0,
+                             "hashes don't match (ret - %d,"
+                             " parent_layout - %p, parent_hash - %x,"
+                             " vol_hash - %x), do global lookup",
+                             ret, parent_layout,
+                             (parent_layout ? parent_layout->commit_hash : -1),
+                             conf->vol_commit_hash);
+                local->op_errno = ENOENT;
+                dht_lookup_everywhere(frame, this, loc);
+                return 0;
+            }
+        } else {
+            if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_ON) {
+                local->op_errno = ENOENT;
+                dht_lookup_everywhere(frame, this, loc);
+                return 0;
+            }
 
-                gf_msg_debug (this->name, 0,
-                              "Entry %s missing on subvol %s",
-                              loc->path, prev->name);
-
-                /* lookup-optimize supersedes lookup-unhashed settings,
-                 *   - so if it is set, do not process search_unhashed
-                 *   - except, in the case of rebalance daemon, we want to
-                 *     force the lookup_everywhere behavior */
-                if (!conf->defrag && conf->lookup_optimize && loc->parent) {
-                        ret = dht_inode_ctx_layout_get (loc->parent, this,
-                                                        &parent_layout);
-                        if (ret || !parent_layout ||
-                            (parent_layout->commit_hash !=
-                             conf->vol_commit_hash)) {
-                                gf_msg_debug (this->name, 0,
-                                              "hashes don't match (ret - %d,"
-                                              " parent_layout - %p, parent_hash - %x,"
-                                              " vol_hash - %x), do global lookup",
-                                              ret, parent_layout,
-                                              (parent_layout ?
-                                              parent_layout->commit_hash : -1),
-                                              conf->vol_commit_hash);
-                                local->op_errno = ENOENT;
-                                dht_lookup_everywhere (frame, this, loc);
-                                return 0;
-                        }
-                } else {
-                        if (conf->search_unhashed ==
-                            GF_DHT_LOOKUP_UNHASHED_ON) {
-                                local->op_errno = ENOENT;
-                                dht_lookup_everywhere (frame, this, loc);
-                                return 0;
-                        }
-
-                        if ((conf->search_unhashed ==
-                            GF_DHT_LOOKUP_UNHASHED_AUTO) &&
-                            (loc->parent)) {
-                                ret = dht_inode_ctx_layout_get (loc->parent,
-                                                                this,
-                                                                &parent_layout);
-                                if (ret || !parent_layout)
-                                        goto out;
-                                if (parent_layout->search_unhashed) {
-                                        local->op_errno = ENOENT;
-                                        dht_lookup_everywhere (frame, this,
-                                                               loc);
-                                        return 0;
-                                }
-                        }
+            if ((conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) &&
+                (loc->parent)) {
+                ret = dht_inode_ctx_layout_get(loc->parent, this,
+                                               &parent_layout);
+                if (ret || !parent_layout)
+                    goto out;
+                if (parent_layout->search_unhashed) {
+                    local->op_errno = ENOENT;
+                    dht_lookup_everywhere(frame, this, loc);
+                    return 0;
                 }
+            }
         }
+    }
 
-        if (op_ret == 0) {
-                is_dir      = check_is_dir (inode, stbuf, xattr);
-                if (is_dir) {
-                        local->inode = inode_ref (inode);
-                        local->xattr = dict_ref (xattr);
-                }
+    if (op_ret == 0) {
+        is_dir = check_is_dir(inode, stbuf, xattr);
+        if (is_dir) {
+            local->inode = inode_ref(inode);
+            local->xattr = dict_ref(xattr);
         }
+    }
 
-        if (is_dir || (op_ret == -1 && op_errno == ENOTCONN)) {
-                dht_lookup_directory (frame, this, &local->loc);
-                return 0;
-        }
+    if (is_dir || (op_ret == -1 && op_errno == ENOTCONN)) {
+        dht_lookup_directory(frame, this, &local->loc);
+        return 0;
+    }
 
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, op_errno,
-                              "Lookup of %s for subvolume"
-                              " %s failed", loc->path,
-                              prev->name);
-                goto out;
-        }
+    if (op_ret == -1) {
+        gf_msg_debug(this->name, op_errno,
+                     "Lookup of %s for subvolume"
+                     " %s failed",
+                     loc->path, prev->name);
+        goto out;
+    }
 
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
 
-        if (!is_linkfile) {
-                /* non-directory and not a linkfile */
+    if (!is_linkfile) {
+        /* non-directory and not a linkfile */
 
-                ret = dht_layout_preset (this, prev, inode);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LAYOUT_PRESET_FAILED,
-                                "could not set pre-set layout for subvolume %s",
-                                prev->name);
-                        op_ret   = -1;
-                        op_errno = EINVAL;
-                        goto out;
-                }
-                goto out;
+        ret = dht_layout_preset(this, prev, inode);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_PRESET_FAILED,
+                   "could not set pre-set layout for subvolume %s", prev->name);
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto out;
         }
+        goto out;
+    }
 
-        subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
-        if (!subvol) {
-
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO, "linkfile not having link "
-                        "subvol for %s", loc->path);
+    subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "linkfile not having link "
+               "subvol for %s",
+               loc->path);
 
-                gf_msg_debug (this->name, 0,
-                              "linkfile not having link subvolume. path=%s",
-                              loc->path);
-                dht_lookup_everywhere (frame, this, loc);
-                return 0;
-        }
+        gf_msg_debug(this->name, 0,
+                     "linkfile not having link subvolume. path=%s", loc->path);
+        dht_lookup_everywhere(frame, this, loc);
+        return 0;
+    }
 
-        gf_msg_debug (this->name, 0,
-                      "Calling lookup on linkto target %s for path %s",
-                      subvol->name, loc->path);
+    gf_msg_debug(this->name, 0,
+                 "Calling lookup on linkto target %s for path %s", subvol->name,
+                 loc->path);
 
-        STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk, subvol,
-                           subvol, subvol->fops->lookup,
-                           &local->loc, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                      subvol->fops->lookup, &local->loc, local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        /*
-         * FIXME: postparent->ia_size and postparent->st_blocks do not have
-         * correct values. since, postparent corresponds to a directory these
-         * two members should have values equal to sum of corresponding values
-         * from each of the subvolume. See dht_iatt_merge for reference.
-         */
-
-        if (!op_ret && local && local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
-
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
-                          postparent);
+    /*
+     * FIXME: postparent->ia_size and postparent->st_blocks do not have
+     * correct values. since, postparent corresponds to a directory these
+     * two members should have values equal to sum of corresponding values
+     * from each of the subvolume. See dht_iatt_merge for reference.
+     */
+
+    if (!op_ret && local && local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     postparent);
 err:
-        return 0;
+    return 0;
 }
 
 /* For directories, check if acl xattrs have been requested (by the acl xlator),
@@ -3396,3537 +3161,3339 @@ err:
  * perform proper self-healing of dirs
  */
 void
-dht_check_and_set_acl_xattr_req (xlator_t *this, dict_t *xattr_req)
+dht_check_and_set_acl_xattr_req(xlator_t *this, dict_t *xattr_req)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        GF_ASSERT (xattr_req);
+    GF_ASSERT(xattr_req);
 
-        if (!dict_get (xattr_req, POSIX_ACL_ACCESS_XATTR)) {
-                ret = dict_set_int8 (xattr_req, POSIX_ACL_ACCESS_XATTR, 0);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s",
-                                POSIX_ACL_ACCESS_XATTR);
-        }
+    if (!dict_get(xattr_req, POSIX_ACL_ACCESS_XATTR)) {
+        ret = dict_set_int8(xattr_req, POSIX_ACL_ACCESS_XATTR, 0);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value:key = %s",
+                   POSIX_ACL_ACCESS_XATTR);
+    }
 
-        if (!dict_get (xattr_req, POSIX_ACL_DEFAULT_XATTR)) {
-                ret = dict_set_int8 (xattr_req, POSIX_ACL_DEFAULT_XATTR, 0);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s",
-                                POSIX_ACL_DEFAULT_XATTR);
-        }
+    if (!dict_get(xattr_req, POSIX_ACL_DEFAULT_XATTR)) {
+        ret = dict_set_int8(xattr_req, POSIX_ACL_DEFAULT_XATTR, 0);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value:key = %s",
+                   POSIX_ACL_DEFAULT_XATTR);
+    }
 
-        return;
+    return;
 }
 
-
 /* for directories, we need the following info:
  * the layout : trusted.glusterfs.dht
  * the mds information : trusted.glusterfs.dht.mds
  * the acl info: See above
  */
 int
-dht_set_dir_xattr_req (xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-        int ret   = -EINVAL;
-        dht_conf_t *conf = NULL;
-
-        conf = this->private;
-        if (!conf) {
-                goto err;
+dht_set_dir_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    int ret = -EINVAL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    if (!conf) {
+        goto err;
+    }
+
+    if (!xattr_req) {
+        goto err;
+    }
+
+    /* Xattr to get the layout for a directory
+     */
+    ret = dict_set_uint32(xattr_req, conf->xattr_name, 4 * 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->xattr_name, loc->path);
+        goto err;
+    }
+
+    /*Non-fatal failure */
+    ret = dict_set_uint32(xattr_req, conf->mds_xattr_key, 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->mds_xattr_key, loc->path);
+    }
+
+    dht_check_and_set_acl_xattr_req(this, xattr_req);
+    ret = 0;
+err:
+    return ret;
+}
+
+int
+dht_set_file_xattr_req(xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+    int ret = -EINVAL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    if (!conf) {
+        goto err;
+    }
+
+    if (!xattr_req) {
+        goto err;
+    }
+
+    /* Used to check whether this is a linkto file.
+     */
+    ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->link_xattr_name, loc->path);
+        goto err;
+    }
+
+    /* This is used to make sure we don't unlink linkto files
+     * which are the target of an ongoing file migration.
+     */
+    ret = dict_set_uint32(xattr_req, GLUSTERFS_OPEN_FD_COUNT, 4);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               GLUSTERFS_OPEN_FD_COUNT, loc->path);
+        goto err;
+    }
+
+    ret = 0;
+err:
+    return ret;
+}
+
+int
+dht_do_revalidate(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+    int gen = 0;
+
+    conf = this->private;
+    if (!conf) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0,
+                     "path = %s. No layout found in the inode ctx.", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Generation number has changed. This layout may be stale. */
+    if (layout->gen && (layout->gen < conf->gen)) {
+        gen = layout->gen;
+        dht_layout_unref(this, local->layout);
+        local->layout = NULL;
+        local->cached_subvol = NULL;
+
+        gf_msg_debug(this->name, 0,
+                     "path = %s. In memory layout may be stale."
+                     "(layout->gen (%d) is less than "
+                     "conf->gen (%d)). Calling fresh lookup.",
+                     loc->path, gen, conf->gen);
+
+        dht_do_fresh_lookup(frame, this, loc);
+        return 0;
+    }
+
+    local->inode = inode_ref(loc->inode);
+
+    /* Since we don't know whether this has changed,
+     * request all xattrs*/
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    if (IA_ISDIR(local->inode->ia_type)) {
+        ret = dht_inode_ctx_mdsvol_get(local->inode, this, &mds_subvol);
+        if (ret || !mds_subvol) {
+            gf_msg_debug(this->name, 0, "path = %s. No mds subvol in inode ctx",
+                         local->loc.path);
         }
+        local->mds_subvol = mds_subvol;
+        local->call_cnt = conf->subvolume_cnt;
+        call_cnt = local->call_cnt;
 
-        if (!xattr_req) {
-                goto err;
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_revalidate_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, loc,
+                              local->xattr_req);
         }
+        return 0;
+    }
 
-        /* Xattr to get the layout for a directory
-         */
-        ret = dict_set_uint32 (xattr_req, conf->xattr_name, 4 * 4);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value:key = %s for "
-                        "path %s", conf->xattr_name, loc->path);
-                goto err;
-         }
+    /* If not a dir, this should be 1 */
+    local->call_cnt = layout->cnt;
+    call_cnt = local->call_cnt;
 
-        /*Non-fatal failure */
-        ret = dict_set_uint32 (xattr_req, conf->mds_xattr_key, 4);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value:key = %s for "
-                        "path %s", conf->mds_xattr_key, loc->path);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
 
-        dht_check_and_set_acl_xattr_req (this, xattr_req);
-        ret = 0;
-err:
-        return ret;
-}
+        gf_msg_debug(this->name, 0,
+                     "path = %s. Calling "
+                     "revalidate lookup on %s",
+                     loc->path, subvol->name);
 
+        STACK_WIND_COOKIE(frame, dht_revalidate_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, local->xattr_req);
+    }
+    return 0;
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
+}
+
+int
+dht_do_fresh_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc)
+{
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int call_cnt = 0;
+    int i = 0;
+
+    conf = this->private;
+    if (!conf) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Since we don't know whether this is a file or a directory,
+     * request all xattrs*/
+    ret = dht_set_file_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    ret = dht_set_dir_xattr_req(this, loc, local->xattr_req);
+    if (ret) {
+        op_errno = -ret;
+        goto err;
+    }
+
+    /* This should have been set in dht_lookup */
+    hashed_subvol = local->hashed_subvol;
+
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "%s: no subvolume in layout for path, "
+                     "checking on all the subvols to see if "
+                     "it is a directory",
+                     loc->path);
 
-int dht_set_file_xattr_req (xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-        int ret   = -EINVAL;
-        dht_conf_t *conf = NULL;
+        call_cnt = conf->subvolume_cnt;
+        local->call_cnt = call_cnt;
 
-        conf = this->private;
-        if (!conf) {
-                goto err;
+        local->layout = dht_layout_new(this, conf->subvolume_cnt);
+        if (!local->layout) {
+            op_errno = ENOMEM;
+            goto err;
         }
 
-        if (!xattr_req) {
-                goto err;
-        }
+        gf_msg_debug(this->name, 0,
+                     "%s: Found null hashed subvol. Calling lookup"
+                     " on all nodes.",
+                     loc->path);
 
-        /* Used to check whether this is a linkto file.
-         */
-        ret = dict_set_uint32 (xattr_req,
-                               conf->link_xattr_name, 256);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value:key = %s for "
-                        "path %s", conf->link_xattr_name, loc->path);
-                goto err;
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_lookup_dir_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
         }
+        return 0;
+    }
 
-        /* This is used to make sure we don't unlink linkto files
-         * which are the target of an ongoing file migration.
-         */
-        ret = dict_set_uint32 (xattr_req,
-                               GLUSTERFS_OPEN_FD_COUNT, 4);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value:key = %s for "
-                        "path %s", GLUSTERFS_OPEN_FD_COUNT, loc->path);
-                goto err;
-        }
+    /* if we have the hashed_subvol, send the lookup there first so
+     * as to see whether we have a file or a directory */
+    gf_msg_debug(this->name, 0,
+                 "Calling fresh lookup for %s on"
+                 " %s",
+                 loc->path, hashed_subvol->name);
 
-        ret = 0;
+    STACK_WIND_COOKIE(frame, dht_lookup_cbk, hashed_subvol, hashed_subvol,
+                      hashed_subvol->fops->lookup, loc, local->xattr_req);
+    return 0;
 err:
-        return ret;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
-
 int
-dht_do_revalidate (call_frame_t *frame, xlator_t *this, loc_t *loc)
+dht_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
 {
-        xlator_t     *subvol = NULL;
-        xlator_t     *mds_subvol = NULL;
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret    = -1;
-        int           op_errno = -1;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-        int           gen = 0;
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    loc_t new_loc = {
+        0,
+    };
 
-        conf = this->private;
-        if (!conf) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        local = frame->local;
-        if (!local) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    conf = this->private;
+    if (!conf)
+        goto err;
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "path = %s. No layout found in the inode ctx.",
-                              loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        /* Generation number has changed. This layout may be stale. */
-        if (layout->gen && (layout->gen < conf->gen)) {
-                gen = layout->gen;
-                dht_layout_unref (this, local->layout);
-                local->layout = NULL;
-                local->cached_subvol = NULL;
-
-                gf_msg_debug(this->name, 0,
-                             "path = %s. In memory layout may be stale."
-                             "(layout->gen (%d) is less than "
-                             "conf->gen (%d)). Calling fresh lookup.",
-                             loc->path, gen, conf->gen);
+    local = dht_local_init(frame, loc, NULL, GF_FOP_LOOKUP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-                dht_do_fresh_lookup (frame, this, loc);
-                return 0;
-        }
+    ret = dht_filter_loc_subvol_key(this, loc, &new_loc, &hashed_subvol);
+    if (ret) {
+        loc_wipe(&local->loc);
+        ret = loc_dup(&new_loc, &local->loc);
 
-        local->inode = inode_ref (loc->inode);
+        /* we no longer need 'new_loc' entries */
+        loc_wipe(&new_loc);
 
-        /* Since we don't know whether this has changed,
-         * request all xattrs*/
-        ret = dht_set_file_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                op_errno = -ret;
-                goto err;
+        /* check if loc_dup() is successful */
+        if (ret == -1) {
+            op_errno = errno;
+            gf_msg_debug(this->name, errno,
+                         "copying location failed for path=%s", loc->path);
+            goto err;
         }
+    }
 
-        ret = dht_set_dir_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                op_errno = -ret;
-                goto err;
-        }
+    if (xattr_req) {
+        local->xattr_req = dict_ref(xattr_req);
+    } else {
+        local->xattr_req = dict_new();
+    }
 
-        if (IA_ISDIR (local->inode->ia_type)) {
-                ret = dht_inode_ctx_mdsvol_get (local->inode, this,
-                                                &mds_subvol);
-                if (ret || !mds_subvol) {
-                        gf_msg_debug (this->name, 0,
-                                      "path = %s. No mds subvol in inode ctx",
-                                      local->loc.path);
-                }
-                local->mds_subvol = mds_subvol;
-                local->call_cnt = conf->subvolume_cnt;
-                call_cnt = local->call_cnt;
-
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_revalidate_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->lookup,
-                                           loc, local->xattr_req);
-                }
-                return 0;
-        }
+    /* Nameless lookup */
 
-        /* If not a dir, this should be 1 */
-        local->call_cnt = layout->cnt;
-        call_cnt = local->call_cnt;
+    if (gf_uuid_is_null(loc->pargfid) && !gf_uuid_is_null(loc->gfid) &&
+        !__is_root_gfid(loc->inode->gfid)) {
+        local->cached_subvol = NULL;
+        dht_do_discover(frame, this, loc);
+        return 0;
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = layout->list[i].xlator;
+    if (loc_is_root(loc)) {
+        ret = dict_set_uint32(local->xattr_req, conf->commithash_xattr_name,
+                              sizeof(uint32_t));
+    }
 
-                gf_msg_debug (this->name, 0, "path = %s. Calling "
-                              "revalidate lookup on %s",
-                              loc->path, subvol->name);
+    if (!hashed_subvol)
+        hashed_subvol = dht_subvol_get_hashed(this, loc);
+    local->hashed_subvol = hashed_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_revalidate_cbk, subvol,
-                                   subvol, subvol->fops->lookup,
-                                   &local->loc, local->xattr_req);
-        }
+    /* The entry has been looked up before and has an inode_ctx set
+     */
+    if (is_revalidate(loc)) {
+        dht_do_revalidate(frame, this, loc);
         return 0;
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
+    } else {
+        dht_do_fresh_lookup(frame, this, loc);
         return 0;
-}
-
-int
-dht_do_fresh_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc)
-{
-        int           ret    = -1;
-        dht_conf_t   *conf  = NULL;
-        xlator_t     *hashed_subvol = NULL;
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        int           call_cnt = 0;
-        int           i        = 0;
-
-        conf = this->private;
-        if (!conf) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        local = frame->local;
-        if (!local) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        /* Since we don't know whether this is a file or a directory,
-         * request all xattrs*/
-        ret = dht_set_file_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                op_errno = -ret;
-                goto err;
-        }
-
-        ret = dht_set_dir_xattr_req (this, loc, local->xattr_req);
-        if (ret) {
-                op_errno = -ret;
-                goto err;
-        }
-
-        /* This should have been set in dht_lookup */
-        hashed_subvol = local->hashed_subvol;
-
-        if (!hashed_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "%s: no subvolume in layout for path, "
-                              "checking on all the subvols to see if "
-                              "it is a directory", loc->path);
-
-                call_cnt   = conf->subvolume_cnt;
-                local->call_cnt = call_cnt;
-
-                local->layout = dht_layout_new (this,
-                                                conf->subvolume_cnt);
-                if (!local->layout) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-
-                gf_msg_debug (this->name, 0,
-                              "%s: Found null hashed subvol. Calling lookup"
-                              " on all nodes.", loc->path);
+    }
 
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                }
-                return 0;
-        }
-
-        /* if we have the hashed_subvol, send the lookup there first so
-         * as to see whether we have a file or a directory */
-        gf_msg_debug (this->name, 0, "Calling fresh lookup for %s on"
-                      " %s", loc->path, hashed_subvol->name);
-
-        STACK_WIND_COOKIE (frame, dht_lookup_cbk, hashed_subvol,
-                           hashed_subvol, hashed_subvol->fops->lookup,
-                           loc, local->xattr_req);
-        return 0;
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_lookup (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, dict_t *xattr_req)
+dht_unlink_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t     *hashed_subvol = NULL;
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret    = -1;
-        int           op_errno = -1;
-        loc_t         new_loc = {0,};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        conf = this->private;
-        if (!conf)
-                goto err;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_LOOKUP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        ret = dht_filter_loc_subvol_key (this, loc, &new_loc,
-                                         &hashed_subvol);
-        if (ret) {
-                loc_wipe (&local->loc);
-                ret = loc_dup (&new_loc, &local->loc);
-
-                /* we no longer need 'new_loc' entries */
-                loc_wipe (&new_loc);
-
-                /* check if loc_dup() is successful */
-                if (ret == -1) {
-                        op_errno = errno;
-                        gf_msg_debug (this->name, errno,
-                                      "copying location failed for path=%s",
-                                      loc->path);
-                        goto err;
-                }
-        }
-
-        if (xattr_req) {
-                local->xattr_req = dict_ref (xattr_req);
-        } else {
-                local->xattr_req = dict_new ();
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
-        /* Nameless lookup */
+    local = frame->local;
+    prev = cookie;
 
-        if (gf_uuid_is_null (loc->pargfid) && !gf_uuid_is_null (loc->gfid) &&
-            !__is_root_gfid (loc->inode->gfid)) {
-                local->cached_subvol = NULL;
-                dht_do_discover (frame, this, loc);
-                return 0;
-        }
-
-        if (loc_is_root (loc)) {
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->commithash_xattr_name,
-                                       sizeof(uint32_t));
+    LOCK(&frame->lock);
+    {
+        if ((op_ret == -1) &&
+            !((op_errno == ENOENT) || (op_errno == ENOTCONN))) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink link: subvolume %s"
+                         " returned -1",
+                         prev->name);
+            goto unlock;
         }
 
-        if (!hashed_subvol)
-                hashed_subvol = dht_subvol_get_hashed (this, loc);
-        local->hashed_subvol = hashed_subvol;
-
+        local->op_ret = 0;
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        /* The entry has been looked up before and has an inode_ctx set
-         */
-        if (is_revalidate (loc)) {
-                dht_do_revalidate (frame, this, loc);
-                return 0;
-        } else  {
-                dht_do_fresh_lookup (frame, this, loc);
-                return 0;
-        }
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return 0;
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
-        return 0;
+    return 0;
 }
 
 int
-dht_unlink_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+dht_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *preparent, struct iatt *postparent,
+               dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *prev           = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *hashed_subvol = NULL;
 
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if ((op_ret == -1) && !((op_errno == ENOENT) ||
-                                        (op_errno == ENOTCONN))) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink link: subvolume %s"
-                                      " returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
 
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno != ENOENT) {
+                local->op_ret = -1;
+                local->op_errno = op_errno;
+            } else {
                 local->op_ret = 0;
+            }
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink: subvolume %s returned -1", prev->name);
+            goto unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
-
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
 
-        return 0;
-}
-
-int
-dht_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t     *local          = NULL;
-        xlator_t        *prev           = NULL;
-        xlator_t        *hashed_subvol  = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno != ENOENT) {
-                                local->op_ret   = -1;
-                                local->op_errno = op_errno;
-                        } else {
-                                local->op_ret = 0;
-                        }
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink: subvolume %s returned -1",
-                                       prev->name);
-                        goto unlock;
-                }
-
-                local->op_ret = 0;
+        local->op_ret = 0;
 
-                local->postparent = *postparent;
-                local->preparent = *preparent;
+        local->postparent = *postparent;
+        local->preparent = *preparent;
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->preparent, 0);
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->preparent, 0);
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (!local->op_ret) {
-                hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
-                if (hashed_subvol && hashed_subvol != local->cached_subvol) {
-                        /*
-                         * If hashed and cached are different, then we need
-                         * to unlink linkfile from hashed subvol if data
-                         * file is deleted successfully
-                         */
-                         STACK_WIND_COOKIE (frame, dht_unlink_linkfile_cbk,
-                                            hashed_subvol, hashed_subvol,
-                                            hashed_subvol->fops->unlink,
-                                            &local->loc, local->flags, xdata);
-                         return 0;
-                }
+    if (!local->op_ret) {
+        hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
+        if (hashed_subvol && hashed_subvol != local->cached_subvol) {
+            /*
+             * If hashed and cached are different, then we need
+             * to unlink linkfile from hashed subvol if data
+             * file is deleted successfully
+             */
+            STACK_WIND_COOKIE(frame, dht_unlink_linkfile_cbk, hashed_subvol,
+                              hashed_subvol, hashed_subvol->fops->unlink,
+                              &local->loc, local->flags, xdata);
+            return 0;
         }
+    }
 
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return 0;
+    return 0;
 }
 
 static int
-dht_common_setxattr_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_common_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-         DHT_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-         return 0;
+    DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
-
 static int
-dht_fix_layout_setxattr_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret, int32_t op_errno,
-                             dict_t *xdata)
+dht_fix_layout_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t   *local   = NULL;
-        dht_layout_t  *layout  = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
 
-        if (op_ret == 0) {
+    if (op_ret == 0) {
+        /* update the layout in the inode ctx */
+        local = frame->local;
+        layout = local->selfheal.layout;
 
-                /* update the layout in the inode ctx */
-                local = frame->local;
-                layout = local->selfheal.layout;
+        dht_layout_set(this, local->loc.inode, layout);
+    }
 
-                dht_layout_set (this, local->loc.inode, layout);
-        }
-
-         DHT_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-         return 0;
+    DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int
-dht_err_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int op_ret, int op_errno, dict_t *xdata)
+dht_err_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+            int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
 
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto unlock;
         }
+
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                if ((local->fop == GF_FOP_SETXATTR) ||
-                    (local->fop == GF_FOP_FSETXATTR)) {
-                        DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                          local->op_errno, NULL);
-                }
-                if ((local->fop == GF_FOP_REMOVEXATTR) ||
-                    (local->fop == GF_FOP_FREMOVEXATTR)) {
-                        DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                          local->op_errno, NULL);
-                }
+    UNLOCK(&frame->lock);
+
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if ((local->fop == GF_FOP_SETXATTR) ||
+            (local->fop == GF_FOP_FSETXATTR)) {
+            DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                             NULL);
+        }
+        if ((local->fop == GF_FOP_REMOVEXATTR) ||
+            (local->fop == GF_FOP_FREMOVEXATTR)) {
+            DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                             NULL);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 /* Set the value[] of key into dict after convert from
    host byte order to network byte order
 */
-int32_t dht_dict_set_array (dict_t *dict, char *key, int32_t value[],
-                            int32_t size)
+int32_t
+dht_dict_set_array(dict_t *dict, char *key, int32_t value[], int32_t size)
 {
-        int         ret = -1;
-        int32_t   *ptr = NULL;
-        int32_t     vindex;
+    int ret = -1;
+    int32_t *ptr = NULL;
+    int32_t vindex;
 
-        if (value == NULL) {
-                return -EINVAL;
-        }
+    if (value == NULL) {
+        return -EINVAL;
+    }
 
-        ptr = GF_MALLOC(sizeof(int32_t) * size, gf_common_mt_char);
-        if (ptr == NULL) {
-                return -ENOMEM;
-        }
-        for (vindex = 0; vindex < size; vindex++) {
-                ptr[vindex] = hton32(value[vindex]);
-        }
-        ret = dict_set_bin(dict, key, ptr, sizeof(int32_t) * size);
-        if (ret)
-                GF_FREE (ptr);
-        return ret;
+    ptr = GF_MALLOC(sizeof(int32_t) * size, gf_common_mt_char);
+    if (ptr == NULL) {
+        return -ENOMEM;
+    }
+    for (vindex = 0; vindex < size; vindex++) {
+        ptr[vindex] = hton32(value[vindex]);
+    }
+    ret = dict_set_bin(dict, key, ptr, sizeof(int32_t) * size);
+    if (ret)
+        GF_FREE(ptr);
+    return ret;
 }
 
 int
-dht_common_mds_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+dht_common_mds_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, dict_t *dict,
+                           dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        call_frame_t  *prev  = cookie;
+    dht_local_t *local = NULL;
+    call_frame_t *prev = cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret)
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->this->name);
+    if (op_ret)
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
 
-         if (local->fop == GF_FOP_SETXATTR) {
-                DHT_STACK_UNWIND (setxattr, frame, 0, op_errno, local->xdata);
-         }
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, 0, op_errno, local->xdata);
+    }
 
-         if (local->fop == GF_FOP_FSETXATTR) {
-                DHT_STACK_UNWIND (fsetxattr, frame, 0, op_errno, local->xdata);
-         }
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, 0, op_errno, local->xdata);
+    }
 
-         if (local->fop == GF_FOP_REMOVEXATTR) {
-                DHT_STACK_UNWIND (removexattr, frame, 0, op_errno, NULL);
-         }
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, 0, op_errno, NULL);
+    }
 
-         if (local->fop == GF_FOP_FREMOVEXATTR) {
-                DHT_STACK_UNWIND (fremovexattr, frame, 0, op_errno, NULL);
-         }
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, 0, op_errno, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* Code to wind a xattrop call to add 1 on current mds internal xattr
    value
 */
 int
-dht_setxattr_non_mds_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        int           ret           = 0;
-        dict_t        *xattrop      = NULL;
-        int32_t       addone[1]     = {1};
-        call_frame_t  *prev         = NULL;
-        dht_conf_t    *conf         = NULL;
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        LOCK (&frame->lock);
-        {
-             if (op_ret && !local->op_ret) {
-                        local->op_ret = op_ret;
-                        local->op_errno = op_errno;
-                         gf_msg_debug (this->name, op_errno,
-                                       "subvolume %s returned -1",
-                                       prev->this->name);
-             }
-        }
-        UNLOCK (&frame->lock);
-        this_call_cnt = dht_frame_return (frame);
-
-        if (is_last_call (this_call_cnt)) {
-                if (!local->op_ret) {
-                        xattrop = dict_new ();
-                        if (!xattrop) {
-                                gf_msg (this->name, GF_LOG_ERROR,
-                                        DHT_MSG_NO_MEMORY, 0,
-                                        "dictionary creation failed");
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = dht_dict_set_array (xattrop,
-                                                  conf->mds_xattr_key,
-                                                  addone, 1);
-                        if (ret != 0) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "dictionary set array failed ");
-                                ret = -1;
-                                goto out;
-                        }
-                        if ((local->fop == GF_FOP_SETXATTR) ||
-                            (local->fop == GF_FOP_REMOVEXATTR)) {
-                                STACK_WIND (frame, dht_common_mds_xattrop_cbk,
-                                            local->mds_subvol,
-                                            local->mds_subvol->fops->xattrop,
-                                            &local->loc, GF_XATTROP_ADD_ARRAY,
-                                            xattrop, NULL);
-                        } else {
-                                STACK_WIND (frame, dht_common_mds_xattrop_cbk,
-                                            local->mds_subvol,
-                                            local->mds_subvol->fops->fxattrop,
-                                            local->fd, GF_XATTROP_ADD_ARRAY,
-                                            xattrop, NULL);
-                        }
-                } else  {
-                        if (local->fop == GF_FOP_SETXATTR) {
-                                DHT_STACK_UNWIND (setxattr, frame, 0, 0, local->xdata);
-                        }
-
-                        if (local->fop == GF_FOP_FSETXATTR) {
-                                DHT_STACK_UNWIND (fsetxattr, frame, 0, 0, local->xdata);
-                        }
-
-                        if (local->fop == GF_FOP_REMOVEXATTR) {
-                                DHT_STACK_UNWIND (removexattr, frame, 0, 0, NULL);
-                        }
-
-                        if (local->fop == GF_FOP_FREMOVEXATTR) {
-                                DHT_STACK_UNWIND (fremovexattr, frame, 0, 0, NULL);
-                        }
-                }
-        }
-out:
-        if (xattrop)
-                dict_unref (xattrop);
-        if (ret) {
-                if (local->fop == GF_FOP_SETXATTR) {
-                        DHT_STACK_UNWIND (setxattr, frame, 0, 0, local->xdata);
-                }
-
-                if (local->fop == GF_FOP_FSETXATTR) {
-                        DHT_STACK_UNWIND (fsetxattr, frame, 0, 0, local->xdata);
-                }
-
-                if (local->fop == GF_FOP_REMOVEXATTR) {
-                        DHT_STACK_UNWIND (removexattr, frame, 0, 0, NULL);
-                }
-
-                if (local->fop == GF_FOP_FREMOVEXATTR) {
-                        DHT_STACK_UNWIND (fremovexattr, frame, 0, 0, NULL);
-                }
-        }
-        return 0;
-}
-
-
-int
-dht_setxattr_mds_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, dict_t *xdata)
+dht_setxattr_non_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        call_frame_t *prev = NULL;
-        xlator_t     *mds_subvol = NULL;
-        int i = 0;
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-        mds_subvol = local->mds_subvol;
-
-        if (op_ret == -1) {
-                local->op_ret  = op_ret;
-                local->op_errno = op_errno;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->this->name);
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int ret = 0;
+    dict_t *xattrop = NULL;
+    int32_t addone[1] = {1};
+    call_frame_t *prev = NULL;
+    dht_conf_t *conf = NULL;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret && !local->op_ret) {
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->this->name);
+        }
+    }
+    UNLOCK(&frame->lock);
+    this_call_cnt = dht_frame_return(frame);
+
+    if (is_last_call(this_call_cnt)) {
+        if (!local->op_ret) {
+            xattrop = dict_new();
+            if (!xattrop) {
+                gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+                       "dictionary creation failed");
+                ret = -1;
                 goto out;
-        }
-
-        local->op_ret = 0;
-        local->call_cnt = conf->subvolume_cnt - 1;
-        local->xdata    = dict_ref (xdata);
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (mds_subvol && (mds_subvol == conf->subvolumes[i]))
-                        continue;
-                if (local->fop == GF_FOP_SETXATTR) {
-                        STACK_WIND (frame, dht_setxattr_non_mds_cbk,
-                                    conf->subvolumes[i],
-                                    conf->subvolumes[i]->fops->setxattr,
-                                    &local->loc, local->xattr,
-                                    local->flags, local->xattr_req);
-                }
+            }
+            ret = dht_dict_set_array(xattrop, conf->mds_xattr_key, addone, 1);
+            if (ret != 0) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                       "dictionary set array failed ");
+                ret = -1;
+                goto out;
+            }
+            if ((local->fop == GF_FOP_SETXATTR) ||
+                (local->fop == GF_FOP_REMOVEXATTR)) {
+                STACK_WIND(frame, dht_common_mds_xattrop_cbk, local->mds_subvol,
+                           local->mds_subvol->fops->xattrop, &local->loc,
+                           GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+            } else {
+                STACK_WIND(frame, dht_common_mds_xattrop_cbk, local->mds_subvol,
+                           local->mds_subvol->fops->fxattrop, local->fd,
+                           GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+            }
+        } else {
+            if (local->fop == GF_FOP_SETXATTR) {
+                DHT_STACK_UNWIND(setxattr, frame, 0, 0, local->xdata);
+            }
 
-                if (local->fop == GF_FOP_FSETXATTR) {
-                        STACK_WIND (frame, dht_setxattr_non_mds_cbk,
-                                    conf->subvolumes[i],
-                                    conf->subvolumes[i]->fops->fsetxattr,
-                                    local->fd, local->xattr,
-                                    local->flags, local->xattr_req);
-                }
+            if (local->fop == GF_FOP_FSETXATTR) {
+                DHT_STACK_UNWIND(fsetxattr, frame, 0, 0, local->xdata);
+            }
 
-                if (local->fop == GF_FOP_REMOVEXATTR) {
-                        STACK_WIND (frame, dht_setxattr_non_mds_cbk,
-                                    conf->subvolumes[i],
-                                    conf->subvolumes[i]->fops->removexattr,
-                                    &local->loc, local->key,
-                                    local->xattr_req);
-                }
+            if (local->fop == GF_FOP_REMOVEXATTR) {
+                DHT_STACK_UNWIND(removexattr, frame, 0, 0, NULL);
+            }
 
-                if (local->fop == GF_FOP_FREMOVEXATTR) {
-                        STACK_WIND (frame, dht_setxattr_non_mds_cbk,
-                                    conf->subvolumes[i],
-                                    conf->subvolumes[i]->fops->fremovexattr,
-                                    local->fd, local->key,
-                                    local->xattr_req);
-                }
+            if (local->fop == GF_FOP_FREMOVEXATTR) {
+                DHT_STACK_UNWIND(fremovexattr, frame, 0, 0, NULL);
+            }
         }
-
-        return 0;
+    }
 out:
+    if (xattrop)
+        dict_unref(xattrop);
+    if (ret) {
         if (local->fop == GF_FOP_SETXATTR) {
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                  local->op_errno, xdata);
+            DHT_STACK_UNWIND(setxattr, frame, 0, 0, local->xdata);
         }
 
         if (local->fop == GF_FOP_FSETXATTR) {
-                DHT_STACK_UNWIND (fsetxattr, frame, local->op_ret,
-                                  local->op_errno, xdata);
+            DHT_STACK_UNWIND(fsetxattr, frame, 0, 0, local->xdata);
         }
 
         if (local->fop == GF_FOP_REMOVEXATTR) {
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
+            DHT_STACK_UNWIND(removexattr, frame, 0, 0, NULL);
         }
 
         if (local->fop == GF_FOP_FREMOVEXATTR) {
-                DHT_STACK_UNWIND (fremovexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
+            DHT_STACK_UNWIND(fremovexattr, frame, 0, 0, NULL);
         }
-
-        return 0;
+    }
+    return 0;
 }
 
 int
-dht_xattrop_mds_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+dht_setxattr_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        call_frame_t *prev = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    call_frame_t *prev = NULL;
+    xlator_t *mds_subvol = NULL;
+    int i = 0;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    mds_subvol = local->mds_subvol;
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                local->op_ret   = op_ret;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->this->name);
-                goto out;
-        }
+    if (op_ret == -1) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
+        goto out;
+    }
 
+    local->op_ret = 0;
+    local->call_cnt = conf->subvolume_cnt - 1;
+    local->xdata = dict_ref(xdata);
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol && (mds_subvol == conf->subvolumes[i]))
+            continue;
         if (local->fop == GF_FOP_SETXATTR) {
-                STACK_WIND (frame, dht_setxattr_mds_cbk,
-                            local->mds_subvol,
-                            local->mds_subvol->fops->setxattr,
-                            &local->loc, local->xattr,
-                            local->flags, local->xattr_req);
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->setxattr, &local->loc,
+                       local->xattr, local->flags, local->xattr_req);
         }
 
         if (local->fop == GF_FOP_FSETXATTR) {
-                STACK_WIND (frame, dht_setxattr_mds_cbk,
-                            local->mds_subvol,
-                            local->mds_subvol->fops->fsetxattr,
-                            local->fd, local->xattr,
-                            local->flags, local->xattr_req);
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->fsetxattr, local->fd,
+                       local->xattr, local->flags, local->xattr_req);
         }
 
         if (local->fop == GF_FOP_REMOVEXATTR) {
-                STACK_WIND (frame, dht_setxattr_mds_cbk,
-                            local->mds_subvol,
-                            local->mds_subvol->fops->removexattr,
-                            &local->loc, local->key,
-                            local->xattr_req);
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->removexattr, &local->loc,
+                       local->key, local->xattr_req);
         }
 
         if (local->fop == GF_FOP_FREMOVEXATTR) {
-                STACK_WIND (frame, dht_setxattr_mds_cbk,
-                            local->mds_subvol,
-                            local->mds_subvol->fops->fremovexattr,
-                            local->fd, local->key,
-                            local->xattr_req);
+            STACK_WIND(frame, dht_setxattr_non_mds_cbk, conf->subvolumes[i],
+                       conf->subvolumes[i]->fops->fremovexattr, local->fd,
+                       local->key, local->xattr_req);
         }
+    }
 
+    return 0;
+out:
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+    }
 
-        return 0;
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+    }
+
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
+
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
+
+    return 0;
+}
+
+int
+dht_xattrop_mds_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    call_frame_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        local->op_ret = op_ret;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->this->name);
+        goto out;
+    }
+
+    if (local->fop == GF_FOP_SETXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->setxattr, &local->loc, local->xattr,
+                   local->flags, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_FSETXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->fsetxattr, local->fd, local->xattr,
+                   local->flags, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->removexattr, &local->loc,
+                   local->key, local->xattr_req);
+    }
+
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        STACK_WIND(frame, dht_setxattr_mds_cbk, local->mds_subvol,
+                   local->mds_subvol->fops->fremovexattr, local->fd, local->key,
+                   local->xattr_req);
+    }
+
+    return 0;
 out:
-        if (local->fop == GF_FOP_SETXATTR) {
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                  local->op_errno, xdata);
-        }
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+    }
 
-        if (local->fop == GF_FOP_FSETXATTR) {
-                DHT_STACK_UNWIND (fsetxattr, frame, local->op_ret,
-                                  local->op_errno, xdata);
-        }
+    if (local->fop == GF_FOP_FSETXATTR) {
+        DHT_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
+                         xdata);
+    }
 
-        if (local->fop == GF_FOP_REMOVEXATTR) {
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
-        }
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
 
-        if (local->fop == GF_FOP_FREMOVEXATTR) {
-                DHT_STACK_UNWIND (fremovexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
-        }
+    if (local->fop == GF_FOP_FREMOVEXATTR) {
+        DHT_STACK_UNWIND(fremovexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 static void
-fill_layout_info (dht_layout_t *layout, char *buf)
+fill_layout_info(dht_layout_t *layout, char *buf)
 {
-        int i = 0;
-        char tmp_buf[128] = {0,};
+    int i = 0;
+    char tmp_buf[128] = {
+        0,
+    };
 
-        for (i = 0; i < layout->cnt; i++) {
-                snprintf (tmp_buf, sizeof (tmp_buf), "(%s %u %u)",
-                          layout->list[i].xlator->name,
-                          layout->list[i].start,
-                          layout->list[i].stop);
-                if (i)
-                        strcat (buf, " ");
-                strcat (buf, tmp_buf);
-        }
+    for (i = 0; i < layout->cnt; i++) {
+        snprintf(tmp_buf, sizeof(tmp_buf), "(%s %u %u)",
+                 layout->list[i].xlator->name, layout->list[i].start,
+                 layout->list[i].stop);
+        if (i)
+            strcat(buf, " ");
+        strcat(buf, tmp_buf);
+    }
 }
 
 static void
-dht_fill_pathinfo_xattr (xlator_t *this, dht_local_t *local,
-                         char *xattr_buf, int32_t alloc_len,
-                         int flag, char *layout_buf)
-{
-        if (flag) {
-                if (local->xattr_val) {
-                        snprintf (xattr_buf, alloc_len,
-                          "((<"DHT_PATHINFO_HEADER"%s> %s) (%s-layout %s))",
-                          this->name, local->xattr_val, this->name,
-                          layout_buf);
-                } else {
-                        snprintf (xattr_buf, alloc_len, "(%s-layout %s)",
-                          this->name, layout_buf);
-                }
-        } else if (local->xattr_val) {
-                snprintf (xattr_buf, alloc_len,
-                          "(<"DHT_PATHINFO_HEADER"%s> %s)",
-                          this->name, local->xattr_val);
+dht_fill_pathinfo_xattr(xlator_t *this, dht_local_t *local, char *xattr_buf,
+                        int32_t alloc_len, int flag, char *layout_buf)
+{
+    if (flag) {
+        if (local->xattr_val) {
+            snprintf(xattr_buf, alloc_len,
+                     "((<" DHT_PATHINFO_HEADER "%s> %s) (%s-layout %s))",
+                     this->name, local->xattr_val, this->name, layout_buf);
         } else {
-                xattr_buf[0] = '\0';
+            snprintf(xattr_buf, alloc_len, "(%s-layout %s)", this->name,
+                     layout_buf);
         }
+    } else if (local->xattr_val) {
+        snprintf(xattr_buf, alloc_len, "(<" DHT_PATHINFO_HEADER "%s> %s)",
+                 this->name, local->xattr_val);
+    } else {
+        xattr_buf[0] = '\0';
+    }
 }
 
 int
-dht_vgetxattr_alloc_and_fill (dht_local_t *local, dict_t *xattr, xlator_t *this,
-                              int op_errno)
+dht_vgetxattr_alloc_and_fill(dht_local_t *local, dict_t *xattr, xlator_t *this,
+                             int op_errno)
 {
-        int      ret       = -1;
-        char    *value     = NULL;
+    int ret = -1;
+    char *value = NULL;
 
-        ret = dict_get_str (xattr, local->xsel, &value);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "Subvolume %s returned -1", this->name);
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto out;
-        }
+    ret = dict_get_str(xattr, local->xsel, &value);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_GET_XATTR_FAILED,
+               "Subvolume %s returned -1", this->name);
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto out;
+    }
 
-        local->alloc_len += strlen(value);
+    local->alloc_len += strlen(value);
 
+    if (!local->xattr_val) {
+        local->alloc_len += (SLEN(DHT_PATHINFO_HEADER) + 10);
+        local->xattr_val = GF_MALLOC(local->alloc_len, gf_common_mt_char);
         if (!local->xattr_val) {
-                local->alloc_len += (SLEN (DHT_PATHINFO_HEADER) + 10);
-                local->xattr_val = GF_MALLOC (local->alloc_len,
-                                              gf_common_mt_char);
-                if (!local->xattr_val) {
-                        ret = -1;
-                        goto out;
-                }
-                local->xattr_val[0] = '\0';
-        }
-
-        int plen = strlen (local->xattr_val);
-        if (plen) {
-                /* extra byte(s) for \0 to be safe */
-                local->alloc_len += (plen + 2);
-                local->xattr_val = GF_REALLOC (local->xattr_val,
-                                               local->alloc_len);
-                if (!local->xattr_val) {
-                        ret = -1;
-                        goto out;
-                }
+            ret = -1;
+            goto out;
         }
+        local->xattr_val[0] = '\0';
+    }
 
-        (void) strcat (local->xattr_val, value);
-        (void) strcat (local->xattr_val, " ");
-        local->op_ret = 0;
+    int plen = strlen(local->xattr_val);
+    if (plen) {
+        /* extra byte(s) for \0 to be safe */
+        local->alloc_len += (plen + 2);
+        local->xattr_val = GF_REALLOC(local->xattr_val, local->alloc_len);
+        if (!local->xattr_val) {
+            ret = -1;
+            goto out;
+        }
+    }
 
-        ret = 0;
+    (void)strcat(local->xattr_val, value);
+    (void)strcat(local->xattr_val, " ");
+    local->op_ret = 0;
 
- out:
-        return ret;
+    ret = 0;
+
+out:
+    return ret;
 }
 
 int
-dht_vgetxattr_fill_and_set (dht_local_t *local, dict_t **dict, xlator_t *this,
-                            gf_boolean_t flag)
+dht_vgetxattr_fill_and_set(dht_local_t *local, dict_t **dict, xlator_t *this,
+                           gf_boolean_t flag)
 {
-        int   ret             = -1;
-        char *xattr_buf       = NULL;
-        char layout_buf[8192] = {0,};
-
-        if (flag)
-                fill_layout_info (local->layout, layout_buf);
+    int ret = -1;
+    char *xattr_buf = NULL;
+    char layout_buf[8192] = {
+        0,
+    };
 
-        *dict = dict_new ();
-        if (!*dict)
-                goto out;
-
-        local->xattr_val[strlen (local->xattr_val) - 1] = '\0';
+    if (flag)
+        fill_layout_info(local->layout, layout_buf);
 
-        /* we would need max this many bytes to create xattr string
-         * extra 40 bytes is just an estimated amount of additional
-         * space required as we include translator name and some
-         * spaces, brackets etc. when forming the pathinfo string.
-         *
-         * For node-uuid we just don't have all the pretty formatting,
-         * but since this is a generic routine for pathinfo & node-uuid
-         * we don't have conditional space allocation and try to be
-         * generic
-         */
-        local->alloc_len += (2 * strlen (this->name))
-                + strlen (layout_buf)
-                + 40;
-        xattr_buf = GF_MALLOC (local->alloc_len, gf_common_mt_char);
-        if (!xattr_buf)
-                goto out;
-
-        if (XATTR_IS_PATHINFO (local->xsel)) {
-                (void) dht_fill_pathinfo_xattr (this, local, xattr_buf,
-                                                local->alloc_len, flag,
-                                                layout_buf);
-        } else if ((XATTR_IS_NODE_UUID (local->xsel))
-                   || (XATTR_IS_NODE_UUID_LIST (local->xsel))) {
-                (void) snprintf (xattr_buf, local->alloc_len, "%s",
-                                 local->xattr_val);
-        } else {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "Unknown local->xsel (%s)", local->xsel);
-                GF_FREE (xattr_buf);
-                goto out;
-        }
-
-        ret = dict_set_dynstr (*dict, local->xsel, xattr_buf);
-        if (ret)
-                GF_FREE (xattr_buf);
-        GF_FREE (local->xattr_val);
+    *dict = dict_new();
+    if (!*dict)
+        goto out;
 
- out:
-        return ret;
-}
+    local->xattr_val[strlen(local->xattr_val) - 1] = '\0';
+
+    /* we would need max this many bytes to create xattr string
+     * extra 40 bytes is just an estimated amount of additional
+     * space required as we include translator name and some
+     * spaces, brackets etc. when forming the pathinfo string.
+     *
+     * For node-uuid we just don't have all the pretty formatting,
+     * but since this is a generic routine for pathinfo & node-uuid
+     * we don't have conditional space allocation and try to be
+     * generic
+     */
+    local->alloc_len += (2 * strlen(this->name)) + strlen(layout_buf) + 40;
+    xattr_buf = GF_MALLOC(local->alloc_len, gf_common_mt_char);
+    if (!xattr_buf)
+        goto out;
 
+    if (XATTR_IS_PATHINFO(local->xsel)) {
+        (void)dht_fill_pathinfo_xattr(this, local, xattr_buf, local->alloc_len,
+                                      flag, layout_buf);
+    } else if ((XATTR_IS_NODE_UUID(local->xsel)) ||
+               (XATTR_IS_NODE_UUID_LIST(local->xsel))) {
+        (void)snprintf(xattr_buf, local->alloc_len, "%s", local->xattr_val);
+    } else {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GET_XATTR_FAILED,
+               "Unknown local->xsel (%s)", local->xsel);
+        GF_FREE(xattr_buf);
+        goto out;
+    }
 
-int
-dht_find_local_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
-{
-        dht_local_t  *local         = NULL;
-        dht_conf_t   *conf          = NULL;
-        xlator_t     *prev          = NULL;
-        int           this_call_cnt = 0;
-        int           ret           = 0;
-        char         *uuid_str      = NULL;
-        char         *uuid_list     = NULL;
-        char         *next_uuid_str = NULL;
-        char         *saveptr       = NULL;
-        uuid_t        node_uuid     = {0,};
-        char         *uuid_list_copy = NULL;
-        int           count          = 0;
-        int           i              = 0;
-        int           index          = 0;
-        int           found          = 0;
-        nodeuuid_info_t *tmp_ptr     = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
+    ret = dict_set_dynstr(*dict, local->xsel, xattr_buf);
+    if (ret)
+        GF_FREE(xattr_buf);
+    GF_FREE(local->xattr_val);
 
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        VALIDATE_OR_GOTO (conf->defrag, out);
-
-        gf_msg_debug (this->name, 0, "subvol %s returned", prev->name);
-
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-                if (op_ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_GET_XATTR_FAILED,
-                                "getxattr err for dir");
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
+out:
+    return ret;
+}
+
+int
+dht_find_local_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
+    int ret = 0;
+    char *uuid_str = NULL;
+    char *uuid_list = NULL;
+    char *next_uuid_str = NULL;
+    char *saveptr = NULL;
+    uuid_t node_uuid = {
+        0,
+    };
+    char *uuid_list_copy = NULL;
+    int count = 0;
+    int i = 0;
+    int index = 0;
+    int found = 0;
+    nodeuuid_info_t *tmp_ptr = NULL;
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    VALIDATE_OR_GOTO(conf->defrag, out);
+
+    gf_msg_debug(this->name, 0, "subvol %s returned", prev->name);
+
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+        if (op_ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_GET_XATTR_FAILED,
+                   "getxattr err for dir");
+            local->op_ret = -1;
+            local->op_errno = op_errno;
+            goto unlock;
+        }
 
-                ret = dict_get_str (xattr, local->xsel, &uuid_list);
+        ret = dict_get_str(xattr, local->xsel, &uuid_list);
 
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_GET_FAILED,
-                                "Failed to get %s", local->xsel);
-                        local->op_ret = -1;
-                        local->op_errno = EINVAL;
-                        goto unlock;
-                }
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_GET_FAILED,
+                   "Failed to get %s", local->xsel);
+            local->op_ret = -1;
+            local->op_errno = EINVAL;
+            goto unlock;
+        }
 
-                /* As DHT will not know details of its child xlators
-                 * we need to parse this twice to get the count first
-                 * and allocate memory later.
-                 */
-                count = 0;
-                index = conf->local_subvols_cnt;
-
-                uuid_list_copy = gf_strdup (uuid_list);
-
-                for (uuid_str = strtok_r (uuid_list, " ", &saveptr);
-                     uuid_str;
-                     uuid_str = next_uuid_str) {
-
-                        next_uuid_str = strtok_r (NULL, " ", &saveptr);
-                        if (gf_uuid_parse (uuid_str, node_uuid)) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_UUID_PARSE_ERROR,
-                                        "Failed to parse uuid"
-                                        " for %s", prev->name);
-                                local->op_ret = -1;
-                                local->op_errno = EINVAL;
-                                goto unlock;
-                        }
-
-                        count++;
-                        if (gf_uuid_compare (node_uuid, conf->defrag->node_uuid)) {
-                                gf_msg_debug (this->name, 0, "subvol %s does not"
-                                              "belong to this node",
-                                              prev->name);
-                        } else {
-
-                                /* handle multiple bricks of the same replica
-                                 * on the same node */
-                                if (found)
-                                        continue;
-                                conf->local_subvols[(conf->local_subvols_cnt)++]
-                                                = prev;
-                                found = 1;
-                                gf_msg_debug (this->name, 0, "subvol %s belongs to"
-                                              " this node", prev->name);
-                        }
-                }
+        /* As DHT will not know details of its child xlators
+         * we need to parse this twice to get the count first
+         * and allocate memory later.
+         */
+        count = 0;
+        index = conf->local_subvols_cnt;
+
+        uuid_list_copy = gf_strdup(uuid_list);
+
+        for (uuid_str = strtok_r(uuid_list, " ", &saveptr); uuid_str;
+             uuid_str = next_uuid_str) {
+            next_uuid_str = strtok_r(NULL, " ", &saveptr);
+            if (gf_uuid_parse(uuid_str, node_uuid)) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UUID_PARSE_ERROR,
+                       "Failed to parse uuid"
+                       " for %s",
+                       prev->name);
+                local->op_ret = -1;
+                local->op_errno = EINVAL;
+                goto unlock;
+            }
 
-                if (!found) {
-                        local->op_ret = 0;
-                        goto unlock;
-                }
+            count++;
+            if (gf_uuid_compare(node_uuid, conf->defrag->node_uuid)) {
+                gf_msg_debug(this->name, 0,
+                             "subvol %s does not"
+                             "belong to this node",
+                             prev->name);
+            } else {
+                /* handle multiple bricks of the same replica
+                 * on the same node */
+                if (found)
+                    continue;
+                conf->local_subvols[(conf->local_subvols_cnt)++] = prev;
+                found = 1;
+                gf_msg_debug(this->name, 0,
+                             "subvol %s belongs to"
+                             " this node",
+                             prev->name);
+            }
+        }
 
-                conf->local_nodeuuids[index].count = count;
-                conf->local_nodeuuids[index].elements
-                               = GF_CALLOC (count, sizeof (nodeuuid_info_t), 1);
+        if (!found) {
+            local->op_ret = 0;
+            goto unlock;
+        }
 
-                /* The node-uuids are guaranteed to be returned in the same
-                 * order as the bricks
-                 * A null node-uuid is returned for a brick that is down.
-                 */
+        conf->local_nodeuuids[index].count = count;
+        conf->local_nodeuuids[index].elements = GF_CALLOC(
+            count, sizeof(nodeuuid_info_t), 1);
 
-                saveptr = NULL;
-                i = 0;
+        /* The node-uuids are guaranteed to be returned in the same
+         * order as the bricks
+         * A null node-uuid is returned for a brick that is down.
+         */
 
-                for (uuid_str = strtok_r (uuid_list_copy, " ", &saveptr);
-                     uuid_str;
-                     uuid_str = next_uuid_str) {
+        saveptr = NULL;
+        i = 0;
 
-                        next_uuid_str = strtok_r (NULL, " ", &saveptr);
-                        tmp_ptr = &(conf->local_nodeuuids[index].elements[i]);
-                        gf_uuid_parse (uuid_str, tmp_ptr->uuid);
+        for (uuid_str = strtok_r(uuid_list_copy, " ", &saveptr); uuid_str;
+             uuid_str = next_uuid_str) {
+            next_uuid_str = strtok_r(NULL, " ", &saveptr);
+            tmp_ptr = &(conf->local_nodeuuids[index].elements[i]);
+            gf_uuid_parse(uuid_str, tmp_ptr->uuid);
 
-                        if (!gf_uuid_compare (tmp_ptr->uuid,
-                                              conf->defrag->node_uuid)) {
-                                tmp_ptr->info = REBAL_NODEUUID_MINE;
-                        }
-                        i++;
-                        tmp_ptr = NULL;
-                }
+            if (!gf_uuid_compare(tmp_ptr->uuid, conf->defrag->node_uuid)) {
+                tmp_ptr->info = REBAL_NODEUUID_MINE;
+            }
+            i++;
+            tmp_ptr = NULL;
         }
+    }
 
-        local->op_ret = 0;
- unlock:
-        UNLOCK (&frame->lock);
+    local->op_ret = 0;
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!is_last_call (this_call_cnt))
-                goto out;
+    if (!is_last_call(this_call_cnt))
+        goto out;
 
-        if (local->op_ret == -1) {
-                goto unwind;
-        }
+    if (local->op_ret == -1) {
+        goto unwind;
+    }
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, xattr, xdata);
-        goto out;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, xattr, xdata);
+    goto out;
 
- unwind:
+unwind:
 
-        GF_FREE (conf->local_nodeuuids[index].elements);
-        conf->local_nodeuuids[index].elements = NULL;
+    GF_FREE(conf->local_nodeuuids[index].elements);
+    conf->local_nodeuuids[index].elements = NULL;
 
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno, NULL, xdata);
- out:
-        GF_FREE (uuid_list_copy);
-        return 0;
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, xdata);
+out:
+    GF_FREE(uuid_list_copy);
+    return 0;
 }
 
 int
-dht_vgetxattr_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+dht_vgetxattr_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        int          ret           = 0;
-        dht_local_t *local         = NULL;
-        int          this_call_cnt = 0;
-        dict_t      *dict          = NULL;
+    int ret = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    dict_t *dict = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-                if (op_ret < 0) {
-                        if (op_errno != ENOTCONN) {
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_GET_XATTR_FAILED,
-                                        "getxattr err for dir");
-                                local->op_ret = -1;
-                                local->op_errno = op_errno;
-                        }
-
-                        goto unlock;
-                }
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+        if (op_ret < 0) {
+            if (op_errno != ENOTCONN) {
+                gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                       DHT_MSG_GET_XATTR_FAILED, "getxattr err for dir");
+                local->op_ret = -1;
+                local->op_errno = op_errno;
+            }
 
-                ret = dht_vgetxattr_alloc_and_fill (local, xattr, this,
-                                                    op_errno);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "alloc or fill failure");
+            goto unlock;
         }
- unlock:
-        UNLOCK (&frame->lock);
 
-        if (!is_last_call (this_call_cnt))
-                goto out;
+        ret = dht_vgetxattr_alloc_and_fill(local, xattr, this, op_errno);
+        if (ret)
+            gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_DICT_SET_FAILED,
+                   "alloc or fill failure");
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        /* -- last call: do patch ups -- */
+    if (!is_last_call(this_call_cnt))
+        goto out;
 
-        if (local->op_ret == -1) {
-                goto unwind;
-        }
+    /* -- last call: do patch ups -- */
 
-        ret = dht_vgetxattr_fill_and_set (local, &dict, this, _gf_true);
-        if (ret)
-                goto unwind;
+    if (local->op_ret == -1) {
+        goto unwind;
+    }
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, dict, xdata);
-        goto cleanup;
+    ret = dht_vgetxattr_fill_and_set(local, &dict, this, _gf_true);
+    if (ret)
+        goto unwind;
 
- unwind:
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno, NULL, NULL);
- cleanup:
-        if (dict)
-                dict_unref (dict);
- out:
-        return 0;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, dict, xdata);
+    goto cleanup;
+
+unwind:
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, NULL);
+cleanup:
+    if (dict)
+        dict_unref(dict);
+out:
+    return 0;
 }
 
 int
-dht_vgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+dht_vgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        dht_local_t  *local         = NULL;
-        int           ret           = 0;
-        dict_t       *dict          = NULL;
-        xlator_t     *prev          = NULL;
-        gf_boolean_t  flag          = _gf_true;
+    dht_local_t *local = NULL;
+    int ret = 0;
+    dict_t *dict = NULL;
+    xlator_t *prev = NULL;
+    gf_boolean_t flag = _gf_true;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "vgetxattr: Subvolume %s returned -1",
-                         prev->name);
-                goto unwind;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_GET_XATTR_FAILED,
+               "vgetxattr: Subvolume %s returned -1", prev->name);
+        goto unwind;
+    }
 
-        ret = dht_vgetxattr_alloc_and_fill (local, xattr, this,
-                                            op_errno);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Allocation or fill failure");
-                goto unwind;
-        }
+    ret = dht_vgetxattr_alloc_and_fill(local, xattr, this, op_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+               "Allocation or fill failure");
+        goto unwind;
+    }
 
-        flag = (local->layout->cnt > 1) ? _gf_true : _gf_false;
+    flag = (local->layout->cnt > 1) ? _gf_true : _gf_false;
 
-        ret = dht_vgetxattr_fill_and_set (local, &dict, this, flag);
-        if (ret)
-                goto unwind;
+    ret = dht_vgetxattr_fill_and_set(local, &dict, this, flag);
+    if (ret)
+        goto unwind;
 
-        DHT_STACK_UNWIND (getxattr, frame, 0, 0, dict, xdata);
-        goto cleanup;
+    DHT_STACK_UNWIND(getxattr, frame, 0, 0, dict, xdata);
+    goto cleanup;
 
- unwind:
-        DHT_STACK_UNWIND (getxattr, frame, -1, local->op_errno,
-                          NULL, NULL);
- cleanup:
-        if (dict)
-                dict_unref (dict);
+unwind:
+    DHT_STACK_UNWIND(getxattr, frame, -1, local->op_errno, NULL, NULL);
+cleanup:
+    if (dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_linkinfo_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
+dht_linkinfo_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
 {
-        int   ret   = 0;
-        char *value = NULL;
+    int ret = 0;
+    char *value = NULL;
 
-        if (op_ret != -1) {
-                ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &value);
-                if (!ret) {
-                        ret = dict_set_str (xattr, GF_XATTR_LINKINFO_KEY, value);
-                        if (!ret)
-                                gf_msg_trace (this->name, 0,
-                                              "failed to set linkinfo");
-                }
+    if (op_ret != -1) {
+        ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &value);
+        if (!ret) {
+            ret = dict_set_str(xattr, GF_XATTR_LINKINFO_KEY, value);
+            if (!ret)
+                gf_msg_trace(this->name, 0, "failed to set linkinfo");
         }
+    }
 
-        DHT_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata);
+    DHT_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_mds_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+dht_mds_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
-        dht_conf_t      *conf = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
-        VALIDATE_OR_GOTO (this->private, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
+    VALIDATE_OR_GOTO(this->private, out);
 
-        conf = this->private;
-        local = frame->local;
+    conf = this->private;
+    local = frame->local;
 
-        if (!xattr || (op_ret == -1)) {
-                local->op_ret = op_ret;
-                goto out;
-        }
-        if (dict_get (xattr, conf->xattr_name)) {
-                dict_del (xattr, conf->xattr_name);
-        }
-        local->op_ret = 0;
+    if (!xattr || (op_ret == -1)) {
+        local->op_ret = op_ret;
+        goto out;
+    }
+    if (dict_get(xattr, conf->xattr_name)) {
+        dict_del(xattr, conf->xattr_name);
+    }
+    local->op_ret = 0;
 
-        if (!local->xattr) {
-                local->xattr = dict_copy_with_ref (xattr, NULL);
-        }
+    if (!local->xattr) {
+        local->xattr = dict_copy_with_ref(xattr, NULL);
+    }
 
 out:
-        DHT_STACK_UNWIND (getxattr, frame, local->op_ret, op_errno,
-                          local->xattr, xdata);
-        return 0;
+    DHT_STACK_UNWIND(getxattr, frame, local->op_ret, op_errno, local->xattr,
+                     xdata);
+    return 0;
 }
 
-
 int
-dht_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+dht_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
-        dht_conf_t      *conf = NULL;
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
-        VALIDATE_OR_GOTO (this->private, out);
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
-        local = frame->local;
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
+    VALIDATE_OR_GOTO(this->private, out);
 
-        LOCK (&frame->lock);
-        {
-                if (!xattr || (op_ret == -1)) {
-                        local->op_ret = op_ret;
-                        goto unlock;
-                }
+    conf = this->private;
+    local = frame->local;
 
-                if (dict_get (xattr, conf->xattr_name)) {
-                        dict_del (xattr, conf->xattr_name);
-                }
+    LOCK(&frame->lock);
+    {
+        if (!xattr || (op_ret == -1)) {
+            local->op_ret = op_ret;
+            goto unlock;
+        }
 
-                if (dict_get (xattr,  conf->mds_xattr_key)) {
-                        dict_del (xattr, conf->mds_xattr_key);
-                }
+        if (dict_get(xattr, conf->xattr_name)) {
+            dict_del(xattr, conf->xattr_name);
+        }
 
-                /* filter out following two xattrs that need not
-                 * be visible on the mount point for geo-rep -
-                 * trusted.tier.fix.layout.complete and
-                 * trusted.tier.tier-dht.commithash
-                 */
+        if (dict_get(xattr, conf->mds_xattr_key)) {
+            dict_del(xattr, conf->mds_xattr_key);
+        }
 
-                if (dict_get (xattr, conf->commithash_xattr_name)) {
-                        dict_del (xattr, conf->commithash_xattr_name);
-                }
+        /* filter out following two xattrs that need not
+         * be visible on the mount point for geo-rep -
+         * trusted.tier.fix.layout.complete and
+         * trusted.tier.tier-dht.commithash
+         */
 
-                if (frame->root->pid >= 0 && dht_is_tier_xlator (this)) {
-                        dict_del(xattr, GF_XATTR_TIER_LAYOUT_FIXED_KEY);
-                }
+        if (dict_get(xattr, conf->commithash_xattr_name)) {
+            dict_del(xattr, conf->commithash_xattr_name);
+        }
 
-                if (frame->root->pid >= 0) {
-                        GF_REMOVE_INTERNAL_XATTR
-                                ("trusted.glusterfs.quota*", xattr);
-                        GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
-                }
+        if (frame->root->pid >= 0 && dht_is_tier_xlator(this)) {
+            dict_del(xattr, GF_XATTR_TIER_LAYOUT_FIXED_KEY);
+        }
 
-                local->op_ret = 0;
+        if (frame->root->pid >= 0) {
+            GF_REMOVE_INTERNAL_XATTR("trusted.glusterfs.quota*", xattr);
+            GF_REMOVE_INTERNAL_XATTR("trusted.pgfid*", xattr);
+        }
 
-                if (!local->xattr) {
-                        local->xattr = dict_copy_with_ref (xattr, NULL);
-                } else {
-                        dht_aggregate_xattr (local->xattr, xattr);
-                }
+        local->op_ret = 0;
 
+        if (!local->xattr) {
+            local->xattr = dict_copy_with_ref(xattr, NULL);
+        } else {
+            dht_aggregate_xattr(local->xattr, xattr);
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 out:
-        if (is_last_call (this_call_cnt)) {
-
-                /* If we have a valid xattr received from any one of the
-                 * subvolume, let's return it */
-                if (local->xattr) {
-                        local->op_ret = 0;
-                }
-
-                DHT_STACK_UNWIND (getxattr, frame, local->op_ret, op_errno,
-                                  local->xattr, NULL);
+    if (is_last_call(this_call_cnt)) {
+        /* If we have a valid xattr received from any one of the
+         * subvolume, let's return it */
+        if (local->xattr) {
+            local->op_ret = 0;
         }
-        return 0;
+
+        DHT_STACK_UNWIND(getxattr, frame, local->op_ret, op_errno, local->xattr,
+                         NULL);
+    }
+    return 0;
 }
 
 int32_t
-dht_getxattr_unwind (call_frame_t *frame,
-                     int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+dht_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno, dict_t *dict,
+                    dict_t *xdata)
 {
-        DHT_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    DHT_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int
-dht_getxattr_get_real_filename_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    dict_t *xattr, dict_t *xdata)
+dht_getxattr_get_real_filename_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int op_ret, int op_errno,
+                                   dict_t *xattr, dict_t *xdata)
 {
-        int             this_call_cnt = 0;
-        dht_local_t     *local = NULL;
+    int this_call_cnt = 0;
+    dht_local_t *local = NULL;
 
+    local = frame->local;
 
-        local = frame->local;
+    LOCK(&frame->lock);
+    {
+        if (local->op_errno == ENODATA || local->op_errno == EOPNOTSUPP) {
+            /* Nothing to do here, we have already found
+             * a subvol which does not have the get_real_filename
+             * optimization. If condition is for simple logic.
+             */
+            goto unlock;
+        }
 
-        LOCK (&frame->lock);
-        {
-                if (local->op_errno == ENODATA ||
-                    local->op_errno == EOPNOTSUPP) {
-                        /* Nothing to do here, we have already found
-                         * a subvol which does not have the get_real_filename
-                         * optimization. If condition is for simple logic.
-                         */
-                        goto unlock;
-                }
+        if (op_ret == -1) {
+            if (op_errno == ENODATA || op_errno == EOPNOTSUPP) {
+                /* This subvol does not have the optimization.
+                 * Better let the user know we don't support it.
+                 * Remove previous results if any.
+                 */
 
-                if (op_ret == -1) {
-
-                        if (op_errno == ENODATA || op_errno == EOPNOTSUPP) {
-                                /* This subvol does not have the optimization.
-                                 * Better let the user know we don't support it.
-                                 * Remove previous results if any.
-                                 */
-
-                                if (local->xattr) {
-                                        dict_unref (local->xattr);
-                                        local->xattr = NULL;
-                                }
-
-                                if (local->xattr_req) {
-                                        dict_unref (local->xattr_req);
-                                        local->xattr_req = NULL;
-                                }
-
-                                local->op_ret = op_ret;
-                                local->op_errno = op_errno;
-                                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                        DHT_MSG_UPGRADE_BRICKS, "At least "
-                                        "one of the bricks does not support "
-                                        "this operation. Please upgrade all "
-                                        "bricks.");
-                                goto unlock;
-                        }
-
-                        if (op_errno == ENOENT) {
-                                /* Do nothing, our defaults are set to this.
-                                 */
-                                goto unlock;
-                        }
-
-                        /* This is a place holder for every other error
-                         * case. I am not sure of how to interpret
-                         * ENOTCONN etc. As of now, choosing to ignore
-                         * down subvol and return a good result(if any)
-                         * from other subvol.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                DHT_MSG_GET_XATTR_FAILED,
-                                "Failed to get real filename.");
-                        goto unlock;
+                if (local->xattr) {
+                    dict_unref(local->xattr);
+                    local->xattr = NULL;
+                }
 
+                if (local->xattr_req) {
+                    dict_unref(local->xattr_req);
+                    local->xattr_req = NULL;
                 }
 
+                local->op_ret = op_ret;
+                local->op_errno = op_errno;
+                gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                       DHT_MSG_UPGRADE_BRICKS,
+                       "At least "
+                       "one of the bricks does not support "
+                       "this operation. Please upgrade all "
+                       "bricks.");
+                goto unlock;
+            }
 
-                /* This subvol has the required file.
-                 * There could be other subvols which have returned
-                 * success already, choosing to return the latest good
-                 * result.
+            if (op_errno == ENOENT) {
+                /* Do nothing, our defaults are set to this.
                  */
-                if (local->xattr)
-                        dict_unref (local->xattr);
-                local->xattr = dict_ref (xattr);
+                goto unlock;
+            }
 
-                if (local->xattr_req) {
-                        dict_unref (local->xattr_req);
-                        local->xattr_req = NULL;
-                }
-                if (xdata)
-                        local->xattr_req = dict_ref (xdata);
+            /* This is a place holder for every other error
+             * case. I am not sure of how to interpret
+             * ENOTCONN etc. As of now, choosing to ignore
+             * down subvol and return a good result(if any)
+             * from other subvol.
+             */
+            gf_msg(this->name, GF_LOG_WARNING, op_errno,
+                   DHT_MSG_GET_XATTR_FAILED, "Failed to get real filename.");
+            goto unlock;
+        }
+
+        /* This subvol has the required file.
+         * There could be other subvols which have returned
+         * success already, choosing to return the latest good
+         * result.
+         */
+        if (local->xattr)
+            dict_unref(local->xattr);
+        local->xattr = dict_ref(xattr);
 
-                local->op_ret = op_ret;
-                local->op_errno = 0;
-                gf_msg_debug (this->name, 0, "Found a matching "
-                              "file.");
+        if (local->xattr_req) {
+            dict_unref(local->xattr_req);
+            local->xattr_req = NULL;
         }
-unlock:
-        UNLOCK (&frame->lock);
+        if (xdata)
+            local->xattr_req = dict_ref(xdata);
 
+        local->op_ret = op_ret;
+        local->op_errno = 0;
+        gf_msg_debug(this->name, 0,
+                     "Found a matching "
+                     "file.");
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (getxattr, frame, local->op_ret,
-                                  local->op_errno, local->xattr,
-                                  local->xattr_req);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(getxattr, frame, local->op_ret, local->op_errno,
+                         local->xattr, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_getxattr_get_real_filename (call_frame_t *frame, xlator_t *this,
-                                loc_t *loc, const char *key, dict_t *xdata)
+dht_getxattr_get_real_filename(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                               const char *key, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
-        int              i = 0;
-        dht_layout_t    *layout = NULL;
-        int              cnt = 0;
-        xlator_t        *subvol = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_layout_t *layout = NULL;
+    int cnt = 0;
+    xlator_t *subvol = NULL;
 
+    local = frame->local;
+    layout = local->layout;
 
-        local = frame->local;
-        layout = local->layout;
+    cnt = local->call_cnt = layout->cnt;
 
-        cnt = local->call_cnt = layout->cnt;
+    local->op_ret = -1;
+    local->op_errno = ENOENT;
 
-        local->op_ret = -1;
-        local->op_errno = ENOENT;
-
-        for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_get_real_filename_cbk,
-                            subvol, subvol->fops->getxattr,
-                            loc, key, xdata);
-        }
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_get_real_filename_cbk, subvol,
+                   subvol->fops->getxattr, loc, key, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_marker_populate_args (call_frame_t *frame, int type, int *gauge,
-                          xlator_t **subvols)
+dht_marker_populate_args(call_frame_t *frame, int type, int *gauge,
+                         xlator_t **subvols)
 {
-        dht_local_t *local = NULL;
-        int         i = 0;
-        dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_layout_t *layout = NULL;
 
-        local  = frame->local;
-        layout = local->layout;
+    local = frame->local;
+    layout = local->layout;
 
-        for (i = 0; i < layout->cnt; i++)
-                subvols[i] = layout->list[i].xlator;
+    for (i = 0; i < layout->cnt; i++)
+        subvols[i] = layout->list[i].xlator;
 
-        return layout->cnt;
+    return layout->cnt;
 }
 
-
 int
-dht_is_debug_xattr_key (char **array, char *key)
+dht_is_debug_xattr_key(char **array, char *key)
 {
-        int     i = 0;
+    int i = 0;
 
-        for (i = 0; array[i]; i++) {
-                if (fnmatch (array[i], key, FNM_NOESCAPE) == 0)
-                        return i;
-        }
+    for (i = 0; array[i]; i++) {
+        if (fnmatch(array[i], key, FNM_NOESCAPE) == 0)
+            return i;
+    }
 
-        return -1;
+    return -1;
 }
 
-
 /* Note we already have frame->local initialised here*/
 
 int
-dht_handle_debug_getxattr (call_frame_t *frame, xlator_t *this,
-                           loc_t *loc, const char *key)
+dht_handle_debug_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                          const char *key)
 {
-        dht_local_t  *local         = NULL;
-        int           ret           = -1;
-        int           op_errno      = ENODATA;
-        char         *value         = NULL;
-        loc_t         file_loc      = {0};
-        const char    *name         = NULL;
-
-        local = frame->local;
-        if (!key) {
-                op_errno = EINVAL;
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    int ret = -1;
+    int op_errno = ENODATA;
+    char *value = NULL;
+    loc_t file_loc = {0};
+    const char *name = NULL;
 
-        if (dht_is_debug_xattr_key (dht_dbg_vxattrs, (char *)key) == -1) {
-                goto out;
-        }
+    local = frame->local;
+    if (!key) {
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        local->xattr = dict_new ();
-        if (!local->xattr) {
-                op_errno = ENOMEM;
-                goto out;
-        }
+    if (dht_is_debug_xattr_key(dht_dbg_vxattrs, (char *)key) == -1) {
+        goto out;
+    }
 
-        if (strncmp (key, DHT_DBG_HASHED_SUBVOL_KEY,
-                     SLEN (DHT_DBG_HASHED_SUBVOL_KEY)) == 0) {
+    local->xattr = dict_new();
+    if (!local->xattr) {
+        op_errno = ENOMEM;
+        goto out;
+    }
 
-                name = key + strlen(DHT_DBG_HASHED_SUBVOL_KEY);
-                if (strlen(name) == 0) {
-                        op_errno = EINVAL;
-                        goto out;
-                }
+    if (strncmp(key, DHT_DBG_HASHED_SUBVOL_KEY,
+                SLEN(DHT_DBG_HASHED_SUBVOL_KEY)) == 0) {
+        name = key + strlen(DHT_DBG_HASHED_SUBVOL_KEY);
+        if (strlen(name) == 0) {
+            op_errno = EINVAL;
+            goto out;
+        }
 
-                ret = dht_build_child_loc (this, &file_loc, loc, (char *)name);
-                if (ret) {
-                        op_errno = ENOMEM;
-                        goto out;
-                }
+        ret = dht_build_child_loc(this, &file_loc, loc, (char *)name);
+        if (ret) {
+            op_errno = ENOMEM;
+            goto out;
+        }
 
-                local->hashed_subvol = dht_subvol_get_hashed (this, &file_loc);
-                if (local->hashed_subvol == NULL) {
-                        op_errno = ENODATA;
-                        goto out;
-                }
+        local->hashed_subvol = dht_subvol_get_hashed(this, &file_loc);
+        if (local->hashed_subvol == NULL) {
+            op_errno = ENODATA;
+            goto out;
+        }
 
-                value = gf_strdup (local->hashed_subvol->name);
-                if (!value) {
-                        op_errno = ENOMEM;
-                        goto out;
-                }
+        value = gf_strdup(local->hashed_subvol->name);
+        if (!value) {
+            op_errno = ENOMEM;
+            goto out;
+        }
 
-                ret = dict_set_dynstr (local->xattr,  (char *)key, value);
-                if (ret < 0) {
-                        op_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-                ret = 0;
-                goto out;
+        ret = dict_set_dynstr(local->xattr, (char *)key, value);
+        if (ret < 0) {
+            op_errno = -ret;
+            ret = -1;
+            goto out;
         }
+        ret = 0;
+        goto out;
+    }
 
 out:
-	loc_wipe (&file_loc);
-        DHT_STACK_UNWIND (getxattr, frame, ret, op_errno, local->xattr, NULL);
-        return 0;
+    loc_wipe(&file_loc);
+    DHT_STACK_UNWIND(getxattr, frame, ret, op_errno, local->xattr, NULL);
+    return 0;
 }
 
-
 int
-dht_getxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, const char *key, dict_t *xdata)
-#define DHT_IS_DIR(layout)  (layout->cnt > 1)
-{
-
-        xlator_t     *subvol        = NULL;
-        xlator_t     *hashed_subvol = NULL;
-        xlator_t     *mds_subvol    = NULL;
-        xlator_t     *cached_subvol = NULL;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        dht_layout_t *layout        = NULL;
-        int           op_errno      = -1;
-        int           i             = 0;
-        int           cnt           = 0;
-        char         *node_uuid_key = NULL;
-        int           ret           = -1;
-
-        GF_CHECK_XATTR_KEY_AND_GOTO (key, IO_THREADS_QUEUE_SIZE_KEY,
-                                     op_errno, err);
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf   = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_GETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LAYOUT_NULL,
-                        "Layout is NULL");
-                op_errno = ENOENT;
-                goto err;
+dht_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *key,
+             dict_t *xdata)
+#define DHT_IS_DIR(layout) (layout->cnt > 1)
+{
+    xlator_t *subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int cnt = 0;
+    char *node_uuid_key = NULL;
+    int ret = -1;
+
+    GF_CHECK_XATTR_KEY_AND_GOTO(key, IO_THREADS_QUEUE_SIZE_KEY, op_errno, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_GETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_NULL,
+               "Layout is NULL");
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    /* skip over code which is irrelevant without a valid key */
+    if (!key)
+        goto no_key;
+
+    local->key = gf_strdup(key);
+    if (!local->key) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (strncmp(key, conf->mds_xattr_key, strlen(key)) == 0) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    /* skip over code which is irrelevant if !DHT_IS_DIR(layout) */
+    if (!DHT_IS_DIR(layout))
+        goto no_dht_is_dir;
+
+    if ((strncmp(key, GF_XATTR_GET_REAL_FILENAME_KEY,
+                 SLEN(GF_XATTR_GET_REAL_FILENAME_KEY)) == 0) &&
+        DHT_IS_DIR(layout)) {
+        dht_getxattr_get_real_filename(frame, this, loc, key, xdata);
+        return 0;
+    }
+
+    if (!strcmp(key, GF_REBAL_FIND_LOCAL_SUBVOL)) {
+        ret = gf_asprintf(&node_uuid_key, "%s", GF_XATTR_LIST_NODE_UUIDS_KEY);
+        if (ret == -1 || !node_uuid_key) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+                   "Failed to copy node uuid key");
+            op_errno = ENOMEM;
+            goto err;
+        }
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", node_uuid_key);
+        cnt = local->call_cnt = conf->subvolume_cnt;
+        for (i = 0; i < cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_find_local_subvol_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              node_uuid_key, xdata);
         }
+        if (node_uuid_key)
+            GF_FREE(node_uuid_key);
+        return 0;
+    }
 
-        /* skip over code which is irrelevant without a valid key */
-        if (!key)
-                goto no_key;
-
-        local->key = gf_strdup (key);
-        if (!local->key) {
-                op_errno = ENOMEM;
-                goto err;
+    if (!strcmp(key, GF_REBAL_OLD_FIND_LOCAL_SUBVOL)) {
+        ret = gf_asprintf(&node_uuid_key, "%s", GF_XATTR_NODE_UUID_KEY);
+        if (ret == -1 || !node_uuid_key) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+                   "Failed to copy node uuid key");
+            op_errno = ENOMEM;
+            goto err;
         }
-
-        if (strncmp (key, conf->mds_xattr_key, strlen(key)) == 0) {
-                op_errno = ENOTSUP;
-                goto err;
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", node_uuid_key);
+        cnt = local->call_cnt = conf->subvolume_cnt;
+        for (i = 0; i < cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_find_local_subvol_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              node_uuid_key, xdata);
+        }
+        if (node_uuid_key)
+            GF_FREE(node_uuid_key);
+        return 0;
+    }
+
+    /* for file use cached subvolume (obviously!): see if {}
+     * below
+     * for directory:
+     *  wind to all subvolumes and exclude subvolumes which
+     *  return ENOTCONN (in callback)
+     *
+     * NOTE: Don't trust inode here, as that may not be valid
+     *       (until inode_link() happens)
+     */
+
+    if (XATTR_IS_PATHINFO(key) || (strcmp(key, GF_XATTR_NODE_UUID_KEY) == 0) ||
+        (strcmp(key, GF_XATTR_LIST_NODE_UUIDS_KEY) == 0)) {
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", key);
+        cnt = local->call_cnt = layout->cnt;
+        for (i = 0; i < cnt; i++) {
+            subvol = layout->list[i].xlator;
+            STACK_WIND(frame, dht_vgetxattr_dir_cbk, subvol,
+                       subvol->fops->getxattr, loc, key, xdata);
         }
+        return 0;
+    }
 
-        /* skip over code which is irrelevant if !DHT_IS_DIR(layout) */
-        if (!DHT_IS_DIR(layout))
-                goto no_dht_is_dir;
-
-        if ((strncmp (key, GF_XATTR_GET_REAL_FILENAME_KEY,
-                      SLEN (GF_XATTR_GET_REAL_FILENAME_KEY)) == 0)
-            && DHT_IS_DIR(layout)) {
-                dht_getxattr_get_real_filename (frame, this, loc, key, xdata);
-                return 0;
-        }
+no_dht_is_dir:
+    /* node-uuid or pathinfo for files */
+    if (XATTR_IS_PATHINFO(key) || (strcmp(key, GF_XATTR_NODE_UUID_KEY) == 0)) {
+        cached_subvol = local->cached_subvol;
+        (void)snprintf(local->xsel, sizeof(local->xsel), "%s", key);
+        local->call_cnt = 1;
+        STACK_WIND_COOKIE(frame, dht_vgetxattr_cbk, cached_subvol,
+                          cached_subvol, cached_subvol->fops->getxattr, loc,
+                          key, xdata);
 
-        if (!strcmp (key, GF_REBAL_FIND_LOCAL_SUBVOL)) {
-                ret = gf_asprintf (&node_uuid_key, "%s",
-                                   GF_XATTR_LIST_NODE_UUIDS_KEY);
-                if (ret == -1 || !node_uuid_key) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_NO_MEMORY,
-                                "Failed to copy node uuid key");
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                (void) snprintf (local->xsel, sizeof (local->xsel), "%s",
-                                 node_uuid_key);
-                cnt = local->call_cnt = conf->subvolume_cnt;
-                for (i = 0; i < cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_find_local_subvol_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, node_uuid_key, xdata);
-                }
-                if (node_uuid_key)
-                        GF_FREE (node_uuid_key);
-                return 0;
-        }
+        return 0;
+    }
 
-        if (!strcmp (key, GF_REBAL_OLD_FIND_LOCAL_SUBVOL)) {
-                ret = gf_asprintf (&node_uuid_key, "%s",
-                                   GF_XATTR_NODE_UUID_KEY);
-                if (ret == -1 || !node_uuid_key) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_NO_MEMORY,
-                                "Failed to copy node uuid key");
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                (void) snprintf (local->xsel, sizeof (local->xsel), "%s",
-                                 node_uuid_key);
-                cnt = local->call_cnt = conf->subvolume_cnt;
-                for (i = 0; i < cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_find_local_subvol_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, node_uuid_key, xdata);
-                }
-                if (node_uuid_key)
-                        GF_FREE (node_uuid_key);
-                return 0;
+    if (strcmp(key, GF_XATTR_LINKINFO_KEY) == 0) {
+        hashed_subvol = dht_subvol_get_hashed(this, loc);
+        if (!hashed_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        /* for file use cached subvolume (obviously!): see if {}
-         * below
-         * for directory:
-         *  wind to all subvolumes and exclude subvolumes which
-         *  return ENOTCONN (in callback)
-         *
-         * NOTE: Don't trust inode here, as that may not be valid
-         *       (until inode_link() happens)
-         */
-
-        if (XATTR_IS_PATHINFO (key)
-            || (strcmp (key, GF_XATTR_NODE_UUID_KEY) == 0)
-            || (strcmp (key, GF_XATTR_LIST_NODE_UUIDS_KEY) == 0)) {
-                (void) snprintf (local->xsel, sizeof (local->xsel), "%s", key);
-                cnt = local->call_cnt = layout->cnt;
-                for (i = 0; i < cnt; i++) {
-                        subvol = layout->list[i].xlator;
-                        STACK_WIND (frame, dht_vgetxattr_dir_cbk,
-                                    subvol, subvol->fops->getxattr,
-                                    loc, key, xdata);
-                }
-                return 0;
+        cached_subvol = dht_subvol_get_cached(this, loc->inode);
+        if (!cached_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_CACHED_SUBVOL_GET_FAILED,
+                   "Failed to get cached subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-no_dht_is_dir:
-        /* node-uuid or pathinfo for files */
-        if (XATTR_IS_PATHINFO (key)
-            || (strcmp (key, GF_XATTR_NODE_UUID_KEY) == 0)) {
-                cached_subvol = local->cached_subvol;
-                (void) snprintf (local->xsel, sizeof (local->xsel), "%s", key);
-                local->call_cnt = 1;
-                STACK_WIND_COOKIE (frame, dht_vgetxattr_cbk, cached_subvol,
-                                   cached_subvol, cached_subvol->fops->getxattr,
-                                   loc, key, xdata);
-
-                return 0;
+        if (hashed_subvol == cached_subvol) {
+            op_errno = ENODATA;
+            goto err;
         }
 
-        if (strcmp (key, GF_XATTR_LINKINFO_KEY) == 0) {
-
-                hashed_subvol = dht_subvol_get_hashed (this, loc);
-                if (!hashed_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get hashed subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                cached_subvol = dht_subvol_get_cached (this, loc->inode);
-                if (!cached_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_CACHED_SUBVOL_GET_FAILED,
-                                "Failed to get cached subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (hashed_subvol == cached_subvol) {
-                        op_errno = ENODATA;
-                        goto err;
-                }
-
-                STACK_WIND (frame, dht_linkinfo_getxattr_cbk, hashed_subvol,
-                            hashed_subvol->fops->getxattr, loc,
-                            GF_XATTR_PATHINFO_KEY, xdata);
-                return 0;
-        }
+        STACK_WIND(frame, dht_linkinfo_getxattr_cbk, hashed_subvol,
+                   hashed_subvol->fops->getxattr, loc, GF_XATTR_PATHINFO_KEY,
+                   xdata);
+        return 0;
+    }
 
-	if (dht_is_debug_xattr_key (dht_dbg_vxattrs, (char *)key) >= 0) {
-                dht_handle_debug_getxattr (frame, this, loc, key);
-                return 0;
-        }
+    if (dht_is_debug_xattr_key(dht_dbg_vxattrs, (char *)key) >= 0) {
+        dht_handle_debug_getxattr(frame, this, loc, key);
+        return 0;
+    }
 
 no_key:
-        if (cluster_handle_marker_getxattr (frame, loc, key, conf->vol_uuid,
-                                            dht_getxattr_unwind,
-                                            dht_marker_populate_args) == 0)
-                return 0;
+    if (cluster_handle_marker_getxattr(frame, loc, key, conf->vol_uuid,
+                                       dht_getxattr_unwind,
+                                       dht_marker_populate_args) == 0)
+        return 0;
 
-        if (DHT_IS_DIR(layout)) {
-                local->call_cnt = conf->subvolume_cnt;
-                cnt = conf->subvolume_cnt;
-                ret = dht_inode_ctx_mdsvol_get (loc->inode, this, &mds_subvol);
-                if (!mds_subvol) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Cannot determine MDS, fetching xattr %s randomly"
-                                " from a subvol for path %s ", key, loc->path);
-                } else {
-                        /* TODO need to handle it, As of now we are
-                           choosing availability instead of chossing
-                           consistencty, in case of mds_subvol is
-                           down winding a getxattr call on other subvol
-                           and return xattr
-                        */
-                        local->mds_subvol = mds_subvol;
-                        for (i = 0; i < cnt; i++) {
-                                if (conf->subvolumes[i] == mds_subvol) {
-                                        if (!conf->subvolume_status[i]) {
-                                                gf_msg (this->name,
-                                                        GF_LOG_INFO, 0,
-                                                        DHT_MSG_HASHED_SUBVOL_DOWN,
-                                                        "MDS %s is down for path"
-                                                        " path %s so fetching xattr "
-                                                        "%s randomly from a subvol ",
-                                                        local->mds_subvol->name,
-                                                        loc->path, key);
-                                                ret = 1;
-                                        }
-                                }
-                        }
+    if (DHT_IS_DIR(layout)) {
+        local->call_cnt = conf->subvolume_cnt;
+        cnt = conf->subvolume_cnt;
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+        if (!mds_subvol) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Cannot determine MDS, fetching xattr %s randomly"
+                   " from a subvol for path %s ",
+                   key, loc->path);
+        } else {
+            /* TODO need to handle it, As of now we are
+               choosing availability instead of chossing
+               consistencty, in case of mds_subvol is
+               down winding a getxattr call on other subvol
+               and return xattr
+            */
+            local->mds_subvol = mds_subvol;
+            for (i = 0; i < cnt; i++) {
+                if (conf->subvolumes[i] == mds_subvol) {
+                    if (!conf->subvolume_status[i]) {
+                        gf_msg(this->name, GF_LOG_INFO, 0,
+                               DHT_MSG_HASHED_SUBVOL_DOWN,
+                               "MDS %s is down for path"
+                               " path %s so fetching xattr "
+                               "%s randomly from a subvol ",
+                               local->mds_subvol->name, loc->path, key);
+                        ret = 1;
+                    }
                 }
+            }
+        }
 
-                if (!ret && key && local->mds_subvol && dht_match_xattr (key)) {
-                        STACK_WIND (frame, dht_mds_getxattr_cbk,
-                                    local->mds_subvol,
-                                    local->mds_subvol->fops->getxattr,
-                                    loc, key, xdata);
+        if (!ret && key && local->mds_subvol && dht_match_xattr(key)) {
+            STACK_WIND(frame, dht_mds_getxattr_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->getxattr, loc, key, xdata);
 
-                        return 0;
-                }
-        } else {
-                cnt = local->call_cnt  = 1;
+            return 0;
         }
+    } else {
+        cnt = local->call_cnt = 1;
+    }
 
-        for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_cbk,
-                            subvol, subvol->fops->getxattr,
-                            loc, key, xdata);
-        }
-        return 0;
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_cbk, subvol, subvol->fops->getxattr, loc,
+                   key, xdata);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (getxattr, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 #undef DHT_IS_DIR
 
 int
-dht_fgetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, const char *key, dict_t *xdata)
-{
-        xlator_t     *subvol        = NULL;
-        dht_local_t  *local         = NULL;
-        dht_layout_t *layout        = NULL;
-        int           op_errno      = -1;
-        int           i             = 0;
-        int           cnt           = 0;
-        xlator_t      *mds_subvol = NULL;
-        int           ret           = -1;
-        dht_conf_t    *conf         = NULL;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FGETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-
-                goto err;
+dht_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+              dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int cnt = 0;
+    xlator_t *mds_subvol = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FGETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_NULL,
+               "Layout is NULL");
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    if (key) {
+        local->key = gf_strdup(key);
+        if (!local->key) {
+            op_errno = ENOMEM;
+            goto err;
         }
+    }
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LAYOUT_NULL,
-                        "Layout is NULL");
-                op_errno = ENOENT;
-                goto err;
-        }
+    if (fd->inode)
+        gf_uuid_unparse(fd->inode->gfid, gfid);
 
-        if (key) {
-                local->key = gf_strdup (key);
-                if (!local->key) {
-                        op_errno = ENOMEM;
-                        goto err;
+    if ((fd->inode->ia_type == IA_IFDIR) && key &&
+        (strncmp(key, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) !=
+         0)) {
+        local->call_cnt = conf->subvolume_cnt;
+        cnt = conf->subvolume_cnt;
+        ret = dht_inode_ctx_mdsvol_get(fd->inode, this, &mds_subvol);
+
+        if (!mds_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "cannot determine MDS, fetching xattr %s "
+                   " randomly from a subvol for gfid %s ",
+                   key, gfid);
+        } else {
+            /* TODO need to handle it, As of now we are
+               choosing availability instead of chossing
+               consistencty, in case of hashed_subvol is
+               down winding a getxattr call on other subvol
+               and return xattr
+            */
+            local->mds_subvol = mds_subvol;
+            for (i = 0; i < cnt; i++) {
+                if (conf->subvolumes[i] == mds_subvol) {
+                    if (!conf->subvolume_status[i]) {
+                        gf_msg(this->name, GF_LOG_WARNING, 0,
+                               DHT_MSG_HASHED_SUBVOL_DOWN,
+                               "MDS subvolume %s is down"
+                               " for gfid %s so fetching xattr "
+                               " %s randomly from a subvol ",
+                               local->mds_subvol->name, gfid, key);
+                        ret = 1;
+                    }
                 }
+            }
         }
 
-        if (fd->inode)
-                gf_uuid_unparse(fd->inode->gfid, gfid);
-
-        if ((fd->inode->ia_type == IA_IFDIR)
-            && key
-            && (strncmp (key, GF_XATTR_LOCKINFO_KEY,
-                         SLEN (GF_XATTR_LOCKINFO_KEY)) != 0)) {
-                local->call_cnt = conf->subvolume_cnt;
-                cnt             = conf->subvolume_cnt;
-                ret = dht_inode_ctx_mdsvol_get (fd->inode, this, &mds_subvol);
-
-                if (!mds_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "cannot determine MDS, fetching xattr %s "
-                                " randomly from a subvol for gfid %s ",
-                                key, gfid);
-                } else {
-                        /* TODO need to handle it, As of now we are
-                           choosing availability instead of chossing
-                           consistencty, in case of hashed_subvol is
-                           down winding a getxattr call on other subvol
-                           and return xattr
-                        */
-                        local->mds_subvol = mds_subvol;
-                        for (i = 0; i < cnt; i++) {
-                                if (conf->subvolumes[i] == mds_subvol) {
-                                        if (!conf->subvolume_status[i]) {
-                                                gf_msg (this->name,
-                                                        GF_LOG_WARNING, 0,
-                                                        DHT_MSG_HASHED_SUBVOL_DOWN,
-                                                        "MDS subvolume %s is down"
-                                                        " for gfid %s so fetching xattr "
-                                                        " %s randomly from a subvol ",
-                                                        local->mds_subvol->name,
-                                                        gfid, key);
-                                                ret = 1;
-                                        }
-                                }
-                        }
-                }
-
-                if (!ret && key && local->mds_subvol &&
-                    dht_match_xattr (key)) {
-                        STACK_WIND (frame, dht_mds_getxattr_cbk,
-                                    local->mds_subvol,
-                                    local->mds_subvol->fops->fgetxattr,
-                                    fd, key, NULL);
+        if (!ret && key && local->mds_subvol && dht_match_xattr(key)) {
+            STACK_WIND(frame, dht_mds_getxattr_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->fgetxattr, fd, key, NULL);
 
-                        return 0;
-                }
-
-        } else {
-                cnt = local->call_cnt  = 1;
+            return 0;
         }
 
+    } else {
+        cnt = local->call_cnt = 1;
+    }
 
-        for (i = 0; i < cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND (frame, dht_getxattr_cbk,
-                            subvol, subvol->fops->fgetxattr,
-                            fd, key, NULL);
-        }
-        return 0;
+    for (i = 0; i < cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND(frame, dht_getxattr_cbk, subvol, subvol->fops->fgetxattr, fd,
+                   key, NULL);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fgetxattr, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fgetxattr, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_file_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xdata)
+dht_file_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, dict_t *xdata)
 {
-        int           ret     = -1;
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        struct iatt  *stbuf   = NULL;
-        inode_t      *inode   = NULL;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
-
-        local = frame->local;
-        prev = cookie;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    struct iatt *stbuf = NULL;
+    inode_t *inode = NULL;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
 
-        local->op_errno = op_errno;
+    local = frame->local;
+    prev = cookie;
 
-        if ((local->fop == GF_FOP_FSETXATTR) &&
-            op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    local->op_errno = op_errno;
 
-        if ((op_ret == -1) && !dht_inode_missing (op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1.",
-                              prev->name);
-                goto out;
-        }
+    if ((local->fop == GF_FOP_FSETXATTR) && op_ret == -1 &&
+        (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if (local->call_cnt != 1)
-                goto out;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1.",
+                     prev->name);
+        goto out;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
+    if (local->call_cnt != 1)
+        goto out;
 
-        if ((!op_ret) && !stbuf) {
-                goto out;
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
 
-        local->op_ret = op_ret;
-        local->rebalance.target_op_fn = dht_setxattr2;
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+    if ((!op_ret) && !stbuf) {
+        goto out;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+    local->op_ret = op_ret;
+    local->rebalance.target_op_fn = dht_setxattr2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        /* Phase 1 of migration */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                ret = dht_inode_ctx_get_mig_info (this, inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        dht_setxattr2 (this, subvol2, frame, 0);
-                        return 0;
-                }
+    /* Phase 1 of migration */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        ret = dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            dht_setxattr2(this, subvol2, frame, 0);
+            return 0;
         }
 
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
 out:
 
-        if (local->fop == GF_FOP_SETXATTR) {
-                DHT_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
-        } else {
-                DHT_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata);
-        }
+    if (local->fop == GF_FOP_SETXATTR) {
+        DHT_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
+    } else {
+        DHT_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* Function is call by dict_foreach_fnmatch if key is match with
    user.* and set boolean flag to true
 */
 static int
-dht_is_user_xattr (dict_t *this, char *key, data_t *value, void *data)
+dht_is_user_xattr(dict_t *this, char *key, data_t *value, void *data)
 {
-        gf_boolean_t *user_xattr_found = data;
-        *user_xattr_found = _gf_true;
-        return 0;
+    gf_boolean_t *user_xattr_found = data;
+    *user_xattr_found = _gf_true;
+    return 0;
 }
 
-
 /* Common code to wind a (f)(set|remove)xattr call to set xattr on directory
-*/
+ */
 int
-dht_dir_common_set_remove_xattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                                 fd_t *fd, dict_t *xattr, int flags, dict_t *xdata,
-                                 int *op_errno)
-
-{
-        dict_t       *xattrop             = NULL;
-        int32_t       subone[1]            = {-1};
-        gf_boolean_t  uxattr_key_found     = _gf_false;
-        xlator_t     *mds_subvol          = NULL;
-        xlator_t     *travvol              = NULL;
-        dht_conf_t   *conf                = NULL;
-        int           ret                  = -1;
-        int           i                    = 0;
-        int           call_cnt             = 0;
-        dht_local_t  *local                = NULL;
-        char          gfid_local[GF_UUID_BUF_SIZE] = {0};
-
-        conf = this->private;
-        local    = frame->local;
-        call_cnt = conf->subvolume_cnt;
-        local->flags = flags;
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                gf_uuid_unparse(local->gfid, gfid_local);
-        }
-
-        if ((local->fop == GF_FOP_SETXATTR) ||
-            (local->fop == GF_FOP_FSETXATTR)) {
-                /* Check if any user xattr present in xattr
-                */
-                dict_foreach_fnmatch (xattr, "user*", dht_is_user_xattr,
-                                      &uxattr_key_found);
-
-                /* Check if any custom key xattr present in dict xattr
-                   and start index from 1 because user xattr already
-                   checked in previous line
-                */
-                for (i = 1; xattrs_to_heal[i]; i++)
-                        if (dict_get (xattr, xattrs_to_heal[i]))
-                                uxattr_key_found = _gf_true;
-        }
+dht_dir_common_set_remove_xattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                                fd_t *fd, dict_t *xattr, int flags,
+                                dict_t *xdata, int *op_errno)
+
+{
+    dict_t *xattrop = NULL;
+    int32_t subone[1] = {-1};
+    gf_boolean_t uxattr_key_found = _gf_false;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *travvol = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int i = 0;
+    int call_cnt = 0;
+    dht_local_t *local = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+
+    conf = this->private;
+    local = frame->local;
+    call_cnt = conf->subvolume_cnt;
+    local->flags = flags;
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid_local);
+    }
 
-        if ((local->fop == GF_FOP_REMOVEXATTR) ||
-            (local->fop == GF_FOP_FREMOVEXATTR)) {
-                /* Check if any custom key xattr present in local->key
-                */
-                for (i = 0; xattrs_to_heal[i]; i++)
-                        if (strstr (local->key, xattrs_to_heal[i]))
-                                uxattr_key_found = _gf_true;
-        }
+    if ((local->fop == GF_FOP_SETXATTR) || (local->fop == GF_FOP_FSETXATTR)) {
+        /* Check if any user xattr present in xattr
+         */
+        dict_foreach_fnmatch(xattr, "user*", dht_is_user_xattr,
+                             &uxattr_key_found);
 
-        /* If there is no custom key xattr present or gfid is root
-           or call_cnt is 1 then wind a (f)setxattr call on all subvols
+        /* Check if any custom key xattr present in dict xattr
+           and start index from 1 because user xattr already
+           checked in previous line
         */
-        if (!uxattr_key_found || __is_root_gfid (local->gfid) || call_cnt == 1) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        travvol = conf->subvolumes[i];
-                        if ((local->fop == GF_FOP_SETXATTR) ||
-                            (local->fop == GF_FOP_FSETXATTR)) {
-                                if (fd) {
-                                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                                           travvol, travvol,
-                                                           travvol->fops->fsetxattr,
-                                                           fd, xattr, flags, xdata);
-                                } else {
-                                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                                           travvol, travvol,
-                                                           travvol->fops->setxattr,
-                                                           loc, xattr, flags, xdata);
-                                }
-                        }
-
-                        if ((local->fop == GF_FOP_REMOVEXATTR) ||
-                            (local->fop == GF_FOP_FREMOVEXATTR)) {
-                                if (fd) {
-                                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                                           travvol, travvol,
-                                                           travvol->fops->fremovexattr,
-                                                           fd, local->key, local->xattr_req);
-                                } else {
-                                        STACK_WIND_COOKIE (frame, dht_err_cbk,
-                                                           travvol, travvol,
-                                                           travvol->fops->removexattr,
-                                                           loc, local->key, local->xattr_req);
-                                }
-                        }
-                }
-
-                return 0;
-        }
-
-        /* Calculate hash subvol based on inode and parent inode
+        for (i = 1; xattrs_to_heal[i]; i++)
+            if (dict_get(xattr, xattrs_to_heal[i]))
+                uxattr_key_found = _gf_true;
+    }
+
+    if ((local->fop == GF_FOP_REMOVEXATTR) ||
+        (local->fop == GF_FOP_FREMOVEXATTR)) {
+        /* Check if any custom key xattr present in local->key
          */
-        if (fd) {
-                ret = dht_inode_ctx_mdsvol_get (fd->inode, this, &mds_subvol);
-        } else {
-                ret = dht_inode_ctx_mdsvol_get (loc->inode, this, &mds_subvol);
-        }
-        if (ret || !mds_subvol) {
+        for (i = 0; xattrs_to_heal[i]; i++)
+            if (strstr(local->key, xattrs_to_heal[i]))
+                uxattr_key_found = _gf_true;
+    }
+
+    /* If there is no custom key xattr present or gfid is root
+       or call_cnt is 1 then wind a (f)setxattr call on all subvols
+    */
+    if (!uxattr_key_found || __is_root_gfid(local->gfid) || call_cnt == 1) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            travvol = conf->subvolumes[i];
+            if ((local->fop == GF_FOP_SETXATTR) ||
+                (local->fop == GF_FOP_FSETXATTR)) {
                 if (fd) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get mds subvol for fd %p"
-                                "gfid is %s ", fd, gfid_local);
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->fsetxattr, fd, xattr,
+                                      flags, xdata);
                 } else {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get mds subvol for path %s"
-                                "gfid is %s ", loc->path, gfid_local);
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->setxattr, loc, xattr,
+                                      flags, xdata);
                 }
-                (*op_errno) = ENOENT;
-                goto err;
-        }
-
-        local->mds_subvol = mds_subvol;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] ==  mds_subvol) {
-                        if (!conf->subvolume_status[i]) {
-                                gf_msg (this->name, GF_LOG_WARNING,
-                                        0, DHT_MSG_HASHED_SUBVOL_DOWN,
-                                        "MDS subvol is down for path "
-                                        " %s gfid is %s Unable to set xattr " ,
-                                        local->loc.path, gfid_local);
-                                (*op_errno) = ENOTCONN;
-                                goto err;
-                        }
-                }
-        }
+            }
 
-        if (uxattr_key_found) {
-                xattrop = dict_new ();
-                if (!xattrop) {
-                        gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY,
-                                0, "dictionary creation failed for path %s "
-                                "for gfid is %s ", local->loc.path, gfid_local);
-                        (*op_errno) = ENOMEM;
-                        goto err;
-                }
-                local->xattr = dict_ref (xattr);
-                /* Subtract current MDS xattr value to -1 , value of MDS
-                   xattr represents no. of times xattr modification failed
-                   on non MDS subvols.
-                */
-                ret = dht_dict_set_array (xattrop, conf->mds_xattr_key, subone, 1);
-                if (ret != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
-                                "dictionary set array failed for path %s "
-                                "for gfid is %s ", local->loc.path, gfid_local);
-                        if (xattrop)
-                                dict_unref (xattrop);
-                        (*op_errno) = ret;
-                        goto err;
-                }
-                /* Wind a xattrop call to use ref counting approach
-                   update mds xattr to -1 before update xattr on
-                   hashed subvol and update mds xattr to +1 after update
-                   xattr on all non hashed subvol
-                */
+            if ((local->fop == GF_FOP_REMOVEXATTR) ||
+                (local->fop == GF_FOP_FREMOVEXATTR)) {
                 if (fd) {
-                        STACK_WIND (frame, dht_xattrop_mds_cbk,
-                                    local->mds_subvol,
-                                    local->mds_subvol->fops->fxattrop,
-                                     fd, GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->fremovexattr, fd,
+                                      local->key, local->xattr_req);
                 } else {
-                        STACK_WIND (frame, dht_xattrop_mds_cbk,
-                                    local->mds_subvol,
-                                    local->mds_subvol->fops->xattrop,
-                                    loc, GF_XATTROP_ADD_ARRAY,
-                                    xattrop, NULL);
+                    STACK_WIND_COOKIE(frame, dht_err_cbk, travvol, travvol,
+                                      travvol->fops->removexattr, loc,
+                                      local->key, local->xattr_req);
                 }
-                if (xattrop)
-                        dict_unref (xattrop);
+            }
         }
 
         return 0;
-err:
-        return -1;
-}
-
-
-int
-dht_fsetxattr (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, dict_t *xattr, int flags, dict_t *xdata)
-{
-        xlator_t     *subvol   = NULL;
-        dht_local_t  *local    = NULL;
-        int           op_errno = EINVAL;
-        dht_conf_t   *conf     = NULL;
-        dht_layout_t *layout   = NULL;
-        int           ret      = -1;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        if (!conf->defrag)
-                GF_IF_INTERNAL_XATTR_GOTO (conf->wild_xattr_name, xattr,
-                                           op_errno, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    }
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for fd=%p", fd);
-                op_errno = EINVAL;
+    /* Calculate hash subvol based on inode and parent inode
+     */
+    if (fd) {
+        ret = dht_inode_ctx_mdsvol_get(fd->inode, this, &mds_subvol);
+    } else {
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+    }
+    if (ret || !mds_subvol) {
+        if (fd) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get mds subvol for fd %p"
+                   "gfid is %s ",
+                   fd, gfid_local);
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get mds subvol for path %s"
+                   "gfid is %s ",
+                   loc->path, gfid_local);
+        }
+        (*op_errno) = ENOENT;
+        goto err;
+    }
+
+    local->mds_subvol = mds_subvol;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == mds_subvol) {
+            if (!conf->subvolume_status[i]) {
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_HASHED_SUBVOL_DOWN,
+                       "MDS subvol is down for path "
+                       " %s gfid is %s Unable to set xattr ",
+                       local->loc.path, gfid_local);
+                (*op_errno) = ENOTCONN;
                 goto err;
+            }
         }
-
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
-        local->call_cnt = call_cnt = layout->cnt;
-
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                local->hashed_subvol = NULL;
-                ret = dht_dir_common_set_remove_xattr (frame, this, NULL, fd,
-                                                       xattr, flags, xdata, &op_errno);
-                if (ret)
-                        goto err;
+    }
+
+    if (uxattr_key_found) {
+        xattrop = dict_new();
+        if (!xattrop) {
+            gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+                   "dictionary creation failed for path %s "
+                   "for gfid is %s ",
+                   local->loc.path, gfid_local);
+            (*op_errno) = ENOMEM;
+            goto err;
+        }
+        local->xattr = dict_ref(xattr);
+        /* Subtract current MDS xattr value to -1 , value of MDS
+           xattr represents no. of times xattr modification failed
+           on non MDS subvols.
+        */
+        ret = dht_dict_set_array(xattrop, conf->mds_xattr_key, subone, 1);
+        if (ret != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "dictionary set array failed for path %s "
+                   "for gfid is %s ",
+                   local->loc.path, gfid_local);
+            if (xattrop)
+                dict_unref(xattrop);
+            (*op_errno) = ret;
+            goto err;
+        }
+        /* Wind a xattrop call to use ref counting approach
+           update mds xattr to -1 before update xattr on
+           hashed subvol and update mds xattr to +1 after update
+           xattr on all non hashed subvol
+        */
+        if (fd) {
+            STACK_WIND(frame, dht_xattrop_mds_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->fxattrop, fd,
+                       GF_XATTROP_ADD_ARRAY, xattrop, NULL);
         } else {
+            STACK_WIND(frame, dht_xattrop_mds_cbk, local->mds_subvol,
+                       local->mds_subvol->fops->xattrop, loc,
+                       GF_XATTROP_ADD_ARRAY, xattrop, NULL);
+        }
+        if (xattrop)
+            dict_unref(xattrop);
+    }
 
-                local->call_cnt = 1;
-                local->rebalance.xattr = dict_ref (xattr);
-                local->rebalance.flags = flags;
-
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg_debug (this->name, 0,
-                                      "Failed to set dictionary key %s for fd=%p",
-                                      DHT_IATT_IN_XDATA_KEY, fd);
-                }
+    return 0;
+err:
+    return -1;
+}
+
+int
+dht_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xattr,
+              int flags, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    if (!conf->defrag)
+        GF_IF_INTERNAL_XATTR_GOTO(conf->wild_xattr_name, xattr, op_errno, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+    local->call_cnt = call_cnt = layout->cnt;
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, NULL, fd, xattr,
+                                              flags, xdata, &op_errno);
+        if (ret)
+            goto err;
+    } else {
+        local->call_cnt = 1;
+        local->rebalance.xattr = dict_ref(xattr);
+        local->rebalance.flags = flags;
 
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, fd, xattr,
-                                   flags, local->xattr_req);
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to set dictionary key %s for fd=%p",
+                         DHT_IATT_IN_XDATA_KEY, fd);
         }
-        return 0;
+
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->fsetxattr, fd, xattr, flags,
+                          local->xattr_req);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_checking_pathinfo_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xattr,
-                           dict_t *xdata)
+dht_checking_pathinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, dict_t *xattr,
+                          dict_t *xdata)
 {
-        int           i     = -1;
-        int           ret   = -1;
-        char         *value = NULL;
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        xlator_t     *prev  = NULL;
-        int           this_call_cnt = 0;
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
+    int i = -1;
+    int ret = -1;
+    char *value = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
 
-        if (op_ret == -1)
-                goto out;
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
 
+    if (op_ret == -1)
+        goto out;
 
-        ret = dict_get_str (xattr, GF_XATTR_PATHINFO_KEY, &value);
-        if (ret)
-                goto out;
+    ret = dict_get_str(xattr, GF_XATTR_PATHINFO_KEY, &value);
+    if (ret)
+        goto out;
 
-        if (!strcmp (value, local->key)) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvolumes[i] == prev)
-                                conf->decommissioned_bricks[i] = prev;
-                }
+    if (!strcmp(value, local->key)) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == prev)
+                conf->decommissioned_bricks[i] = prev;
         }
+    }
 
 out:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret, ENOTSUP, NULL);
-        }
-        return 0;
-
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, ENOTSUP, NULL);
+    }
+    return 0;
 }
 
-
 int
-dht_setxattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_setxattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t  *local  = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto err;
+    if (!frame || !frame->local)
+        goto err;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                  local->op_errno, local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto err;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
+    if (subvol == NULL)
+        goto err;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        if (local->fop == GF_FOP_SETXATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->setxattr, &local->loc,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, local->fd,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_SETXATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->setxattr, &local->loc,
+                          local->rebalance.xattr, local->rebalance.flags,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->fsetxattr, local->fd,
+                          local->rebalance.xattr, local->rebalance.flags,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (setxattr, frame, (local ? local->op_ret : -1),
-                          op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(setxattr, frame, (local ? local->op_ret : -1), op_errno,
+                     NULL);
+    return 0;
 }
 
 int
-dht_nuke_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+dht_nuke_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, NULL);
+    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, NULL);
+    return 0;
+}
+
+int
+dht_nuke_dir(call_frame_t *frame, xlator_t *this, loc_t *loc, data_t *tmp)
+{
+    if (!IA_ISDIR(loc->inode->ia_type)) {
+        DHT_STACK_UNWIND(setxattr, frame, -1, ENOTSUP, NULL);
         return 0;
-}
-
-int
-dht_nuke_dir (call_frame_t *frame, xlator_t *this, loc_t *loc, data_t *tmp)
-{
-        if (!IA_ISDIR(loc->inode->ia_type)) {
-                DHT_STACK_UNWIND (setxattr, frame, -1, ENOTSUP, NULL);
-                return 0;
+    }
+
+    /* Setxattr didn't need the parent, but rmdir does. */
+    loc->parent = inode_parent(loc->inode, NULL, NULL);
+    if (!loc->parent) {
+        DHT_STACK_UNWIND(setxattr, frame, -1, ENOENT, NULL);
+        return 0;
+    }
+    gf_uuid_copy(loc->pargfid, loc->parent->gfid);
+
+    if (!loc->name && loc->path) {
+        loc->name = strrchr(loc->path, '/');
+        if (loc->name) {
+            ++(loc->name);
         }
+    }
 
-        /* Setxattr didn't need the parent, but rmdir does. */
-        loc->parent = inode_parent (loc->inode, NULL, NULL);
-        if (!loc->parent) {
-                DHT_STACK_UNWIND (setxattr, frame, -1, ENOENT, NULL);
-                return 0;
-        }
-        gf_uuid_copy (loc->pargfid, loc->parent->gfid);
+    /*
+     * We do this instead of calling dht_rmdir_do directly for two reasons.
+     * The first is that we want to reuse all of the initialization that
+     * dht_rmdir does, so if it ever changes we'll just follow along.  The
+     * second (i.e. why we don't use STACK_WIND_TAIL) is so that we don't
+     * obscure the fact that we came in via this path instead of a genuine
+     * rmdir.  That makes debugging just a tiny bit easier.
+     */
+    STACK_WIND(frame, dht_nuke_dir_cbk, this, this->fops->rmdir, loc, 1, NULL);
 
-        if (!loc->name && loc->path) {
-                loc->name = strrchr (loc->path, '/');
-                if (loc->name) {
-                        ++(loc->name);
-                }
-        }
-
-        /*
-         * We do this instead of calling dht_rmdir_do directly for two reasons.
-         * The first is that we want to reuse all of the initialization that
-         * dht_rmdir does, so if it ever changes we'll just follow along.  The
-         * second (i.e. why we don't use STACK_WIND_TAIL) is so that we don't
-         * obscure the fact that we came in via this path instead of a genuine
-         * rmdir.  That makes debugging just a tiny bit easier.
-         */
-        STACK_WIND (frame, dht_nuke_dir_cbk, this, this->fops->rmdir,
-                    loc, 1, NULL);
-
-        return 0;
+    return 0;
 }
 
-
 int
-dht_setxattr (call_frame_t *frame, xlator_t *this,
-              loc_t *loc, dict_t *xattr, int flags, dict_t *xdata)
+dht_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr,
+             int flags, dict_t *xdata)
 {
-        xlator_t     *subvol   = NULL;
-        dht_local_t  *local    = NULL;
-        dht_conf_t   *conf     = NULL;
-        dht_methods_t *methods = NULL;
-        dht_layout_t *layout   = NULL;
-        int           i        = 0;
-        int           op_errno = EINVAL;
-        int           ret      = -1;
-        data_t       *tmp      = NULL;
-        uint32_t      dir_spread = 0;
-        char          value[4096] = {0,};
-        gf_dht_migrate_data_type_t forced_rebalance = GF_DHT_MIGRATE_DATA;
-        int           call_cnt = 0;
-        uint32_t      new_hash = 0;
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int op_errno = EINVAL;
+    int ret = -1;
+    data_t *tmp = NULL;
+    uint32_t dir_spread = 0;
+    char value[4096] = {
+        0,
+    };
+    gf_dht_migrate_data_type_t forced_rebalance = GF_DHT_MIGRATE_DATA;
+    int call_cnt = 0;
+    uint32_t new_hash = 0;
 
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
 
-        conf   = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
-
-        methods = &(conf->methods);
-
-        /* Rebalance daemon is allowed to set internal keys */
-        if (!conf->defrag)
-                GF_IF_INTERNAL_XATTR_GOTO (conf->wild_xattr_name, xattr,
-                                           op_errno, err);
+    methods = &(conf->methods);
+
+    /* Rebalance daemon is allowed to set internal keys */
+    if (!conf->defrag)
+        GF_IF_INTERNAL_XATTR_GOTO(conf->wild_xattr_name, xattr, op_errno, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SETXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->call_cnt = call_cnt = layout->cnt;
+    tmp = dict_get(xattr, conf->mds_xattr_key);
+    if (tmp) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    tmp = dict_get(xattr, GF_XATTR_FILE_MIGRATE_KEY);
+    if (tmp) {
+        if (IA_ISDIR(loc->inode->ia_type)) {
+            op_errno = ENOTSUP;
+            goto err;
+        }
+
+        /* TODO: need to interpret the 'value' for more meaning
+           (ie, 'target' subvolume given there, etc) */
+        memcpy(value, tmp->data, tmp->len);
+        if (strcmp(value, "force") == 0)
+            forced_rebalance = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+
+        if (conf->decommission_in_progress)
+            forced_rebalance = GF_DHT_MIGRATE_HARDLINK;
+
+        if (!loc->path) {
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (!local->loc.name)
+            local->loc.name = strrchr(local->loc.path, '/') + 1;
+
+        if (!local->loc.parent)
+            local->loc.parent = inode_parent(local->loc.inode, NULL, NULL);
+
+        if ((!local->loc.name) || (!local->loc.parent)) {
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (gf_uuid_is_null(local->loc.pargfid))
+            gf_uuid_copy(local->loc.pargfid, local->loc.parent->gfid);
+
+        methods->migration_get_dst_subvol(this, local);
+
+        if (!local->rebalance.target_node) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get hashed subvol for %s", loc->path);
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        local->rebalance.from_subvol = local->cached_subvol;
+
+        if (local->rebalance.target_node == local->rebalance.from_subvol) {
+            op_errno = EEXIST;
+            goto err;
+        }
+        if (local->rebalance.target_node) {
+            local->flags = forced_rebalance;
+
+            /* Flag to suggest its a tiering migration
+             * The reason for this dic key-value is that
+             * promotions and demotions are multithreaded
+             * so the original frame from gf_defrag_start()
+             * is not carried. A new frame will be created when
+             * we do syncop_setxattr(). This does not have the
+             * frame->root->pid of the original frame. So we pass
+             * this dic key-value when we do syncop_setxattr() to do
+             * data migration and set the frame->root->pid to
+             * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
+             * calling dht_start_rebalance_task() */
+            tmp = dict_get(xattr, TIERING_MIGRATION_KEY);
+            if (tmp)
+                frame->root->pid = GF_CLIENT_PID_TIER_DEFRAG;
+            else
+                frame->root->pid = GF_CLIENT_PID_DEFRAG;
+
+            ret = dht_start_rebalance_task(this, frame);
+            if (!ret)
+                return 0;
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SETXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+                   "%s: failed to create a new rebalance synctask", loc->path);
         }
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s",
-                              loc->path);
-                op_errno = EINVAL;
-                goto err;
+    tmp = dict_get(xattr, "decommission-brick");
+    if (tmp) {
+        /* This operation should happen only on '/' */
+        if (!__is_root_gfid(loc->inode->gfid)) {
+            op_errno = ENOTSUP;
+            goto err;
         }
 
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+        memcpy(value, tmp->data, min(tmp->len, 4095));
+        local->key = gf_strdup(value);
+        local->call_cnt = conf->subvolume_cnt;
 
-        local->call_cnt = call_cnt = layout->cnt;
-        tmp = dict_get (xattr, conf->mds_xattr_key);
-        if (tmp) {
-                op_errno = ENOTSUP;
-                goto err;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            /* Get the pathinfo, and then compare */
+            STACK_WIND_COOKIE(frame, dht_checking_pathinfo_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->getxattr, loc,
+                              GF_XATTR_PATHINFO_KEY, NULL);
         }
+        return 0;
+    }
 
-        tmp = dict_get (xattr, GF_XATTR_FILE_MIGRATE_KEY);
-        if (tmp) {
-
-                if (IA_ISDIR (loc->inode->ia_type)) {
-                        op_errno = ENOTSUP;
-                        goto err;
-                }
-
-                /* TODO: need to interpret the 'value' for more meaning
-                   (ie, 'target' subvolume given there, etc) */
-                memcpy (value, tmp->data, tmp->len);
-                if (strcmp (value, "force") == 0)
-                       forced_rebalance =
-                                GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
-
-                if (conf->decommission_in_progress)
-                        forced_rebalance = GF_DHT_MIGRATE_HARDLINK;
-
-                if (!loc->path) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (!local->loc.name)
-                        local->loc.name = strrchr (local->loc.path, '/')+1;
-
-                if (!local->loc.parent)
-                        local->loc.parent =
-                                inode_parent(local->loc.inode, NULL, NULL);
-
-                if ((!local->loc.name) || (!local->loc.parent)) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (gf_uuid_is_null (local->loc.pargfid))
-                        gf_uuid_copy (local->loc.pargfid, local->loc.parent->gfid);
-
-                methods->migration_get_dst_subvol(this, local);
-
-                if (!local->rebalance.target_node) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get hashed subvol for %s",
-                                loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                local->rebalance.from_subvol = local->cached_subvol;
+    tmp = dict_get(xattr, GF_XATTR_FIX_LAYOUT_KEY);
+    if (tmp) {
+        ret = dict_get_uint32(xattr, "new-commit-hash", &new_hash);
+        if (ret == 0) {
+            gf_msg_debug(this->name, 0,
+                         "updating commit hash for %s from %u to %u",
+                         uuid_utoa(loc->gfid), layout->commit_hash, new_hash);
+            layout->commit_hash = new_hash;
 
-                if (local->rebalance.target_node == local->rebalance.from_subvol) {
-                        op_errno = EEXIST;
-                        goto err;
-                }
-                if (local->rebalance.target_node) {
-                        local->flags = forced_rebalance;
-
-                        /* Flag to suggest its a tiering migration
-                         * The reason for this dic key-value is that
-                         * promotions and demotions are multithreaded
-                         * so the original frame from gf_defrag_start()
-                         * is not carried. A new frame will be created when
-                         * we do syncop_setxattr(). This does not have the
-                         * frame->root->pid of the original frame. So we pass
-                         * this dic key-value when we do syncop_setxattr() to do
-                         * data migration and set the frame->root->pid to
-                         * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
-                         * calling dht_start_rebalance_task() */
-                        tmp = dict_get (xattr, TIERING_MIGRATION_KEY);
-                        if (tmp)
-                                frame->root->pid = GF_CLIENT_PID_TIER_DEFRAG;
-                        else
-                                frame->root->pid = GF_CLIENT_PID_DEFRAG;
-
-                        ret = dht_start_rebalance_task (this, frame);
-                        if (!ret)
-                                return 0;
-
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_REBALANCE_START_FAILED,
-                                "%s: failed to create a new rebalance synctask",
-                                loc->path);
-                }
-                op_errno = EINVAL;
+            ret = dht_update_commit_hash_for_layout(frame);
+            if (ret) {
+                op_errno = ENOTCONN;
                 goto err;
-
+            }
+            return ret;
         }
 
-        tmp = dict_get (xattr, "decommission-brick");
-        if (tmp) {
-                /* This operation should happen only on '/' */
-                if (!__is_root_gfid (loc->inode->gfid)) {
-                        op_errno = ENOTSUP;
-                        goto err;
-                }
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_FIX_LAYOUT_INFO,
+               "fixing the layout of %s", loc->path);
 
-                memcpy (value, tmp->data, min (tmp->len, 4095));
-                local->key = gf_strdup (value);
-                local->call_cnt = conf->subvolume_cnt;
-
-                for (i = 0 ; i < conf->subvolume_cnt; i++) {
-                        /* Get the pathinfo, and then compare */
-                        STACK_WIND_COOKIE (frame, dht_checking_pathinfo_cbk,
-                                           conf->subvolumes[i], conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->getxattr,
-                                           loc, GF_XATTR_PATHINFO_KEY, NULL);
-                }
-                return 0;
+        ret = dht_fix_directory_layout(frame, dht_fix_layout_setxattr_cbk,
+                                       layout);
+        if (ret) {
+            op_errno = ENOTCONN;
+            goto err;
         }
+        return ret;
+    }
 
-        tmp = dict_get (xattr, GF_XATTR_FIX_LAYOUT_KEY);
-        if (tmp) {
-                ret = dict_get_uint32(xattr, "new-commit-hash", &new_hash);
-                if (ret == 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "updating commit hash for %s from %u to %u",
-                                      uuid_utoa(loc->gfid),
-                                      layout->commit_hash, new_hash);
-                        layout->commit_hash = new_hash;
-
-                        ret = dht_update_commit_hash_for_layout (frame);
-                        if (ret) {
-                                op_errno = ENOTCONN;
-                                goto err;
-                        }
-                        return ret;
-                }
-
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_FIX_LAYOUT_INFO,
-                        "fixing the layout of %s", loc->path);
-
-                ret = dht_fix_directory_layout (frame,
-                                                dht_fix_layout_setxattr_cbk,
-                                                layout);
-                if (ret) {
-                        op_errno = ENOTCONN;
-                        goto err;
-                }
-                return ret;
-        }
+    tmp = dict_get(xattr, "distribute.directory-spread-count");
+    if (tmp) {
+        /* Setxattr value is packed as 'binary', not string */
+        memcpy(value, tmp->data, min(tmp->len, 4095));
+        ret = gf_string2uint32(value, &dir_spread);
+        if (!ret && ((dir_spread <= conf->subvolume_cnt) && (dir_spread > 0))) {
+            layout->spread_cnt = dir_spread;
 
-        tmp = dict_get (xattr, "distribute.directory-spread-count");
-        if (tmp) {
-                /* Setxattr value is packed as 'binary', not string */
-                memcpy (value, tmp->data, min (tmp->len, 4095));
-                ret = gf_string2uint32 (value, &dir_spread);
-                if (!ret && ((dir_spread <= conf->subvolume_cnt) &&
-                             (dir_spread > 0))) {
-                        layout->spread_cnt = dir_spread;
-
-                        ret = dht_fix_directory_layout (frame,
-                                                        dht_common_setxattr_cbk,
-                                                        layout);
-                        if (ret) {
-                                op_errno = ENOTCONN;
-                                goto err;
-                        }
-                        return ret;
-                }
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_OPERATION_NOT_SUP,
-                        "wrong 'directory-spread-count' value (%s)", value);
-                op_errno = ENOTSUP;
+            ret = dht_fix_directory_layout(frame, dht_common_setxattr_cbk,
+                                           layout);
+            if (ret) {
+                op_errno = ENOTCONN;
                 goto err;
-        }
-
-        tmp = dict_get (xattr, "glusterfs.dht.nuke");
-        if (tmp) {
-                return dht_nuke_dir (frame, this, loc, tmp);
-        }
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
-
-        if (IA_ISDIR (loc->inode->ia_type)) {
-                local->hashed_subvol = NULL;
-                ret = dht_dir_common_set_remove_xattr (frame, this, loc, NULL,
-                                                       xattr, flags, xdata, &op_errno);
-                if (ret)
-                        goto err;
-        } else {
+            }
+            return ret;
+        }
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_OPERATION_NOT_SUP,
+               "wrong 'directory-spread-count' value (%s)", value);
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    tmp = dict_get(xattr, "glusterfs.dht.nuke");
+    if (tmp) {
+        return dht_nuke_dir(frame, this, loc, tmp);
+    }
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, loc, NULL, xattr,
+                                              flags, xdata, &op_errno);
+        if (ret)
+            goto err;
+    } else {
+        local->rebalance.xattr = dict_ref(xattr);
+        local->rebalance.flags = flags;
+        local->call_cnt = 1;
 
-                local->rebalance.xattr = dict_ref (xattr);
-                local->rebalance.flags = flags;
-                local->call_cnt = 1;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
 
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                          subvol->fops->setxattr, loc, xattr, flags,
+                          local->xattr_req);
+    }
 
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->setxattr, loc, xattr,
-                                   flags, local->xattr_req);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-
-
 int
-dht_file_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, dict_t *xdata)
+dht_file_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        int           ret     = -1;
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        struct iatt  *stbuf   = NULL;
-        inode_t      *inode   = NULL;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    struct iatt *stbuf = NULL;
+    inode_t *inode = NULL;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        local->op_errno = op_errno;
-
-        if ((local->fop == GF_FOP_FREMOVEXATTR) &&
-            (op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    local->op_errno = op_errno;
 
-        if ((op_ret == -1) && !dht_inode_missing (op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
+    if ((local->fop == GF_FOP_FREMOVEXATTR) && (op_ret == -1) &&
+        (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if (local->call_cnt != 1)
-                goto out;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
+    if (local->call_cnt != 1)
+        goto out;
 
-        if ((!op_ret) && !stbuf) {
-                goto out;
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
 
-        local->op_ret = 0;
+    if ((!op_ret) && !stbuf) {
+        goto out;
+    }
 
-        local->rebalance.target_op_fn = dht_removexattr2;
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+    local->op_ret = 0;
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+    local->rebalance.target_op_fn = dht_removexattr2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        /* Phase 1 of migration */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                ret = dht_inode_ctx_get_mig_info (this, inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        dht_removexattr2 (this, subvol2, frame, 0);
-                        return 0;
-                }
+    /* Phase 1 of migration */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        ret = dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            dht_removexattr2(this, subvol2, frame, 0);
+            return 0;
         }
 
-out:
-        if (local->fop == GF_FOP_REMOVEXATTR) {
-                DHT_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata);
-        } else {
-                DHT_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata);
-        }
-        return 0;
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
+out:
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        DHT_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata);
+    } else {
+        DHT_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
+    }
+    return 0;
 }
 
 int
-dht_removexattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                  int ret)
+dht_removexattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
-
-        if (!frame || !frame->local)
-                goto err;
-
-        local = frame->local;
-        op_errno = local->op_errno;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (!frame || !frame->local)
+        goto err;
 
-        if (we_are_not_migrating (ret)) {
+    local = frame->local;
+    op_errno = local->op_errno;
 
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, local->rebalance.xdata);
-                return 0;
-        }
+    local->call_cnt = 2; /* This is the second attempt */
 
-        if (subvol == NULL)
-                goto err;
-
-        if (local->fop == GF_FOP_REMOVEXATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->removexattr,
-                                   &local->loc, local->key, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr,
-                                   local->fd, local->key, local->xattr_req);
-        }
-
-        return 0;
-
-err:
-        DHT_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         local->rebalance.xdata);
         return 0;
-}
-
-
-int
-dht_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    }
 
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    if (subvol == NULL)
+        goto err;
 
-                local->op_ret = 0;
-        }
-unlock:
-        UNLOCK (&frame->lock);
+    if (local->fop == GF_FOP_REMOVEXATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->removexattr, &local->loc, local->key,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->fremovexattr, local->fd, local->key,
+                          local->xattr_req);
+    }
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (removexattr, frame, local->op_ret,
-                                  local->op_errno, NULL);
-        }
+    return 0;
 
-        return 0;
+err:
+    DHT_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_removexattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, const char *key, dict_t *xdata)
+dht_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           call_cnt = 0;
-        dht_conf_t   *conf = NULL;
-        int           ret = 0;
-
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        conf = this->private;
+    local = frame->local;
+    prev = cookie;
 
-        GF_IF_NATIVE_XATTR_GOTO (conf->wild_xattr_name, key, op_errno, err);
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_REMOVEXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!local->layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto unlock;
         }
-        local->xattr_req = (xdata) ? dict_ref (xdata) : dict_new ();
 
-        local->call_cnt = call_cnt = layout->cnt;
-        local->key = gf_strdup (key);
+        local->op_ret = 0;
+    }
+unlock:
+    UNLOCK(&frame->lock);
+
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(removexattr, frame, local->op_ret, local->op_errno,
+                         NULL);
+    }
+
+    return 0;
+}
+
+int
+dht_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *key, dict_t *xdata)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    GF_IF_NATIVE_XATTR_GOTO(conf->wild_xattr_name, key, op_errno, err);
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_REMOVEXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!local->layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
+
+    local->call_cnt = call_cnt = layout->cnt;
+    local->key = gf_strdup(key);
+
+    if (key && (strncmp(key, conf->mds_xattr_key, strlen(key)) == 0)) {
+        op_errno = ENOTSUP;
+        goto err;
+    }
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, loc, NULL, NULL, 0,
+                                              local->xattr_req, &op_errno);
+        if (ret)
+            goto err;
 
-        if (key &&
-            (strncmp (key, conf->mds_xattr_key, strlen(key)) == 0)) {
-                op_errno = ENOTSUP;
-                goto err;
+    } else {
+        local->call_cnt = 1;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to "
+                   "set dictionary key %s for %s",
+                   DHT_IATT_IN_XDATA_KEY, loc->path);
         }
 
-        if (IA_ISDIR (loc->inode->ia_type)) {
-                local->hashed_subvol = NULL;
-                ret = dht_dir_common_set_remove_xattr (frame, this, loc, NULL,
-                                                       NULL, 0, local->xattr_req, &op_errno);
-                if (ret)
-                        goto err;
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->removexattr, loc, key,
+                          local->xattr_req);
+    }
 
-        } else {
-
-                local->call_cnt = 1;
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED, "Failed to "
-                                "set dictionary key %s for %s",
-                                DHT_IATT_IN_XDATA_KEY, loc->path);
-                }
-
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->removexattr, loc, key,
-                                   local->xattr_req);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fremovexattr (call_frame_t *frame, xlator_t *this,
-                  fd_t *fd, const char *key, dict_t *xdata)
+dht_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key,
+                 dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           call_cnt = 0;
-        dht_conf_t   *conf = 0;
-        int           ret = 0;
-
-
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        GF_IF_NATIVE_XATTR_GOTO (conf->wild_xattr_name, key, op_errno, err);
-
-        VALIDATE_OR_GOTO (frame, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FREMOVEXATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for inode=%s",
-                              uuid_utoa (fd->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = 0;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    GF_IF_NATIVE_XATTR_GOTO(conf->wild_xattr_name, key, op_errno, err);
+
+    VALIDATE_OR_GOTO(frame, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FREMOVEXATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for inode=%s",
+                     uuid_utoa(fd->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!local->layout) {
+        gf_msg_debug(this->name, 0, "no layout for inode=%s",
+                     uuid_utoa(fd->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+    local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+
+    local->call_cnt = call_cnt = layout->cnt;
+    local->key = gf_strdup(key);
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        local->hashed_subvol = NULL;
+        ret = dht_dir_common_set_remove_xattr(frame, this, NULL, fd, NULL, 0,
+                                              local->xattr_req, &op_errno);
+        if (ret)
+            goto err;
 
-        layout = local->layout;
-        if (!local->layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for inode=%s",
-                              uuid_utoa (fd->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
+    } else {
+        local->call_cnt = 1;
+        ret = dict_set_int8(local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to "
+                   "set dictionary key %s for fd=%p",
+                   DHT_IATT_IN_XDATA_KEY, fd);
         }
-        local->xattr_req = xdata ? dict_ref (xdata) : dict_new ();
-
-        local->call_cnt = call_cnt = layout->cnt;
-        local->key = gf_strdup (key);
-
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                local->hashed_subvol = NULL;
-                ret = dht_dir_common_set_remove_xattr (frame, this, NULL, fd,
-                                                       NULL, 0, local->xattr_req, &op_errno);
-                if (ret)
-                        goto err;
-
-        } else {
-
-                local->call_cnt = 1;
-                ret = dict_set_int8 (local->xattr_req, DHT_IATT_IN_XDATA_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED, "Failed to "
-                                "set dictionary key %s for fd=%p",
-                                DHT_IATT_IN_XDATA_KEY, fd);
-                }
 
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr, fd, key,
-                                   local->xattr_req);
-        }
+        STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                          subvol->fops->fremovexattr, fd, key,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fd_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_fd_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+           int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    local = frame->local;
+    prev = cookie;
 
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto unlock;
         }
+
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (open, frame, local->op_ret, local->op_errno,
-                                  local->fd, NULL);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(open, frame, local->op_ret, local->op_errno, local->fd,
+                         NULL);
 
-        return 0;
+    return 0;
 }
 
 /*
  * dht_normalize_stats -
  */
 void
-dht_normalize_stats (struct statvfs *buf, unsigned long bsize,
-                     unsigned long frsize)
+dht_normalize_stats(struct statvfs *buf, unsigned long bsize,
+                    unsigned long frsize)
 {
-        double factor = 0;
+    double factor = 0;
 
-        if (buf->f_bsize != bsize) {
-                buf->f_bsize = bsize;
-        }
-
-        if (buf->f_frsize != frsize) {
-                factor = ((double) buf->f_frsize) / frsize;
-                buf->f_frsize = frsize;
-                buf->f_blocks = (fsblkcnt_t) (factor * buf->f_blocks);
-                buf->f_bfree  = (fsblkcnt_t) (factor * buf->f_bfree);
-                buf->f_bavail = (fsblkcnt_t) (factor * buf->f_bavail);
+    if (buf->f_bsize != bsize) {
+        buf->f_bsize = bsize;
+    }
 
-        }
+    if (buf->f_frsize != frsize) {
+        factor = ((double)buf->f_frsize) / frsize;
+        buf->f_frsize = frsize;
+        buf->f_blocks = (fsblkcnt_t)(factor * buf->f_blocks);
+        buf->f_bfree = (fsblkcnt_t)(factor * buf->f_bfree);
+        buf->f_bavail = (fsblkcnt_t)(factor * buf->f_bavail);
+    }
 }
 
 int
-dht_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct statvfs *statvfs,
-                dict_t *xdata)
+dht_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
+    gf_boolean_t event = _gf_false;
+    qdstatfs_action_t action = qdstatfs_action_OFF;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int bsize = 0;
+    int frsize = 0;
+    GF_UNUSED int ret = 0;
+    unsigned long new_usage = 0;
+    unsigned long cur_usage = 0;
 
-        gf_boolean_t            event              = _gf_false;
-        qdstatfs_action_t       action             = qdstatfs_action_OFF;
-        dht_local_t *           local              = NULL;
-        int                     this_call_cnt      = 0;
-        int                     bsize              = 0;
-        int                     frsize             = 0;
-        GF_UNUSED int           ret                = 0;
-        unsigned long           new_usage          = 0;
-        unsigned long           cur_usage          = 0;
+    local = frame->local;
+    GF_ASSERT(local);
 
-        local = frame->local;
-        GF_ASSERT (local);
+    if (xdata)
+        ret = dict_get_int8(xdata, "quota-deem-statfs", (int8_t *)&event);
 
-        if (xdata)
-                ret = dict_get_int8 (xdata, "quota-deem-statfs",
-                                     (int8_t *)&event);
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-                if (!statvfs) {
-                        op_errno = EINVAL;
-                        local->op_ret = -1;
-                        goto unlock;
-                }
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            goto unlock;
+        }
+        if (!statvfs) {
+            op_errno = EINVAL;
+            local->op_ret = -1;
+            goto unlock;
+        }
+        local->op_ret = 0;
 
-                if (local->quota_deem_statfs) {
-                        if (event == _gf_true) {
-                                action = qdstatfs_action_COMPARE;
-                        } else {
-                                action = qdstatfs_action_NEGLECT;
-                        }
-                } else {
-                        if (event == _gf_true) {
-                                action = qdstatfs_action_REPLACE;
-                                local->quota_deem_statfs = _gf_true;
-                        }
-                }
+        if (local->quota_deem_statfs) {
+            if (event == _gf_true) {
+                action = qdstatfs_action_COMPARE;
+            } else {
+                action = qdstatfs_action_NEGLECT;
+            }
+        } else {
+            if (event == _gf_true) {
+                action = qdstatfs_action_REPLACE;
+                local->quota_deem_statfs = _gf_true;
+            }
+        }
 
-                if (local->quota_deem_statfs) {
-                        switch (action) {
-                        case qdstatfs_action_NEGLECT:
-                                goto unlock;
-
-                        case qdstatfs_action_REPLACE:
-                                local->statvfs = *statvfs;
-                                goto unlock;
-
-                        case qdstatfs_action_COMPARE:
-                                new_usage = statvfs->f_blocks -
-                                             statvfs->f_bfree;
-                                cur_usage = local->statvfs.f_blocks -
-                                             local->statvfs.f_bfree;
-
-                                /* Take the max of the usage from subvols */
-                                if (new_usage >= cur_usage)
-                                        local->statvfs = *statvfs;
-                                goto unlock;
-
-                        default:
-                                break;
-                        }
-                }
+        if (local->quota_deem_statfs) {
+            switch (action) {
+                case qdstatfs_action_NEGLECT:
+                    goto unlock;
 
-                if (local->statvfs.f_bsize != 0) {
-                        bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
-                        frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
-                        dht_normalize_stats(&local->statvfs, bsize, frsize);
-                        dht_normalize_stats(statvfs, bsize, frsize);
-                } else {
-                        local->statvfs.f_bsize    = statvfs->f_bsize;
-                        local->statvfs.f_frsize   = statvfs->f_frsize;
-                }
+                case qdstatfs_action_REPLACE:
+                    local->statvfs = *statvfs;
+                    goto unlock;
 
-                local->statvfs.f_blocks  += statvfs->f_blocks;
-                local->statvfs.f_bfree   += statvfs->f_bfree;
-                local->statvfs.f_bavail  += statvfs->f_bavail;
-                local->statvfs.f_files   += statvfs->f_files;
-                local->statvfs.f_ffree   += statvfs->f_ffree;
-                local->statvfs.f_favail  += statvfs->f_favail;
-                local->statvfs.f_fsid     = statvfs->f_fsid;
-                local->statvfs.f_flag     = statvfs->f_flag;
-                local->statvfs.f_namemax  = statvfs->f_namemax;
+                case qdstatfs_action_COMPARE:
+                    new_usage = statvfs->f_blocks - statvfs->f_bfree;
+                    cur_usage = local->statvfs.f_blocks -
+                                local->statvfs.f_bfree;
 
+                    /* Take the max of the usage from subvols */
+                    if (new_usage >= cur_usage)
+                        local->statvfs = *statvfs;
+                    goto unlock;
 
+                default:
+                    break;
+            }
         }
-unlock:
-        UNLOCK (&frame->lock);
 
+        if (local->statvfs.f_bsize != 0) {
+            bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
+            frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
+            dht_normalize_stats(&local->statvfs, bsize, frsize);
+            dht_normalize_stats(statvfs, bsize, frsize);
+        } else {
+            local->statvfs.f_bsize = statvfs->f_bsize;
+            local->statvfs.f_frsize = statvfs->f_frsize;
+        }
+
+        local->statvfs.f_blocks += statvfs->f_blocks;
+        local->statvfs.f_bfree += statvfs->f_bfree;
+        local->statvfs.f_bavail += statvfs->f_bavail;
+        local->statvfs.f_files += statvfs->f_files;
+        local->statvfs.f_ffree += statvfs->f_ffree;
+        local->statvfs.f_favail += statvfs->f_favail;
+        local->statvfs.f_fsid = statvfs->f_fsid;
+        local->statvfs.f_flag = statvfs->f_flag;
+        local->statvfs.f_namemax = statvfs->f_namemax;
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (statfs, frame, local->op_ret, local->op_errno,
-                                  &local->statvfs, xdata);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                         &local->statvfs, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dht_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        inode_t          *inode         = NULL;
-        inode_table_t    *itable        = NULL;
-        uuid_t            root_gfid     = {0, };
-        loc_t         newloc = {0, };
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    inode_t *inode = NULL;
+    inode_table_t *itable = NULL;
+    uuid_t root_gfid = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        conf = this->private;
+    conf = this->private;
 
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_STATFS);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        if (loc->inode && !IA_ISDIR (loc->inode->ia_type)) {
-                itable = loc->inode->table;
-                if (!itable) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_STATFS);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-                loc = &local->loc2;
-                root_gfid[15] = 1;
+    if (loc->inode && !IA_ISDIR(loc->inode->ia_type)) {
+        itable = loc->inode->table;
+        if (!itable) {
+            op_errno = EINVAL;
+            goto err;
+        }
 
-                inode = inode_find (itable, root_gfid);
-                if (!inode) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
+        loc = &local->loc2;
+        root_gfid[15] = 1;
 
-                dht_build_root_loc (inode, &newloc);
-                loc = &newloc;
+        inode = inode_find(itable, root_gfid);
+        if (!inode) {
+            op_errno = EINVAL;
+            goto err;
         }
 
-        local->call_cnt = conf->subvolume_cnt;
+        dht_build_root_loc(inode, &newloc);
+        loc = &newloc;
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND (frame, dht_statfs_cbk,
-                            conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->statfs, loc,
-                            xdata);
-        }
-        return 0;
+    local->call_cnt = conf->subvolume_cnt;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND(frame, dht_statfs_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->statfs, loc, xdata);
+    }
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-             dict_t *xdata)
+dht_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+            dict_t *xdata)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        int           ret = 0;
-        gf_boolean_t  new_xdata = _gf_false;
-        xlator_t    **subvolumes = NULL;
-        int           call_count = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_OPENDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->first_up_subvol = dht_first_up_subvol (this);
-
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int ret = 0;
+    gf_boolean_t new_xdata = _gf_false;
+    xlator_t **subvolumes = NULL;
+    int call_count = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_OPENDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->first_up_subvol = dht_first_up_subvol(this);
+
+    if (!xdata) {
+        xdata = dict_new();
         if (!xdata) {
-                xdata = dict_new ();
-                if (!xdata) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                new_xdata = _gf_true;
+            op_errno = ENOMEM;
+            goto err;
+        }
+        new_xdata = _gf_true;
+    }
+
+    ret = dict_set_uint32(xdata, conf->link_xattr_name, 256);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value : key = %s",
+               conf->link_xattr_name);
+
+    /* dht_readdirp will wind to all subvols so open has to be sent to
+     * all subvols whether or not conf->local_subvols is set */
+
+    call_count = local->call_cnt = conf->subvolume_cnt;
+    subvolumes = conf->subvolumes;
+
+    /* In case of parallel-readdir, the readdir-ahead will be loaded
+     * below dht, in this case, if we want to enable or disable SKIP_DIRs
+     * it has to be done in opendir, so that prefetching logic in
+     * readdir-ahead, honors it */
+    for (i = 0; i < call_count; i++) {
+        if (conf->readdir_optimize == _gf_true) {
+            if (subvolumes[i] != local->first_up_subvol) {
+                ret = dict_set_int32(xdata, GF_READDIR_SKIP_DIRS, 1);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary"
+                           " value :key = %s, ret:%d",
+                           GF_READDIR_SKIP_DIRS, ret);
+            }
         }
 
-        ret = dict_set_uint32 (xdata, conf->link_xattr_name, 256);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value : key = %s",
-                        conf->link_xattr_name);
-
-        /* dht_readdirp will wind to all subvols so open has to be sent to
-         * all subvols whether or not conf->local_subvols is set */
-
-        call_count = local->call_cnt = conf->subvolume_cnt;
-        subvolumes = conf->subvolumes;
-
-        /* In case of parallel-readdir, the readdir-ahead will be loaded
-         * below dht, in this case, if we want to enable or disable SKIP_DIRs
-         * it has to be done in opendir, so that prefetching logic in
-         * readdir-ahead, honors it */
-        for (i = 0; i < call_count; i++) {
-                if (conf->readdir_optimize == _gf_true) {
-                        if (subvolumes[i] != local->first_up_subvol) {
-                                ret = dict_set_int32 (xdata,
-                                                      GF_READDIR_SKIP_DIRS, 1);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_DICT_SET_FAILED,
-                                                "Failed to set dictionary"
-                                                " value :key = %s, ret:%d",
-                                                GF_READDIR_SKIP_DIRS, ret);
-                                }
-                }
+        STACK_WIND_COOKIE(frame, dht_fd_cbk, subvolumes[i], subvolumes[i],
+                          subvolumes[i]->fops->opendir, loc, fd, xdata);
+        dict_del(xdata, GF_READDIR_SKIP_DIRS);
+    }
 
-                STACK_WIND_COOKIE (frame, dht_fd_cbk,
-                                   subvolumes[i],
-                                   subvolumes[i],
-                                   subvolumes[i]->fops->opendir,
-                                   loc, fd, xdata);
-                dict_del (xdata, GF_READDIR_SKIP_DIRS);
-        }
+    if (new_xdata)
+        dict_unref(xdata);
 
-        if (new_xdata)
-                dict_unref (xdata);
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (opendir, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(opendir, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* dht_readdirp_cbk creates a new dentry and dentry->inode is not assigned.
    This functions assigns an inode if all of the following conditions are true:
 
@@ -6937,3807 +6504,3589 @@ err:
 */
 
 void
-dht_populate_inode_for_dentry (xlator_t *this, xlator_t *subvol,
-                               gf_dirent_t *entry, gf_dirent_t *orig_entry)
+dht_populate_inode_for_dentry(xlator_t *this, xlator_t *subvol,
+                              gf_dirent_t *entry, gf_dirent_t *orig_entry)
 {
-        dht_layout_t *layout = NULL;
-        int           ret    = 0;
-        loc_t         loc    = {0, };
-
-        if (gf_uuid_is_null (orig_entry->d_stat.ia_gfid)) {
-                /* this skips the '..' entry for the root of the volume */
-                return;
-        }
+    dht_layout_t *layout = NULL;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
 
-        gf_uuid_copy (loc.gfid, orig_entry->d_stat.ia_gfid);
-        loc.inode = inode_ref (orig_entry->inode);
+    if (gf_uuid_is_null(orig_entry->d_stat.ia_gfid)) {
+        /* this skips the '..' entry for the root of the volume */
+        return;
+    }
 
-        if (is_revalidate (&loc)) {
-                goto out;
-        }
+    gf_uuid_copy(loc.gfid, orig_entry->d_stat.ia_gfid);
+    loc.inode = inode_ref(orig_entry->inode);
 
-        layout = dht_layout_new (this, 1);
-        if (!layout)
-                goto out;
+    if (is_revalidate(&loc)) {
+        goto out;
+    }
 
-        ret = dht_layout_merge (this, layout, subvol, 0, 0, orig_entry->dict);
-        if (!ret) {
-                ret = dht_layout_normalize (this, &loc, layout);
-                if (ret == 0) {
-                        dht_layout_set (this, orig_entry->inode, layout);
-                        entry->inode = inode_ref (orig_entry->inode);
-                        layout = NULL;
-                }
+    layout = dht_layout_new(this, 1);
+    if (!layout)
+        goto out;
 
+    ret = dht_layout_merge(this, layout, subvol, 0, 0, orig_entry->dict);
+    if (!ret) {
+        ret = dht_layout_normalize(this, &loc, layout);
+        if (ret == 0) {
+            dht_layout_set(this, orig_entry->inode, layout);
+            entry->inode = inode_ref(orig_entry->inode);
+            layout = NULL;
         }
+    }
 
-        if (layout)
-                dht_layout_unref (this, layout);
+    if (layout)
+        dht_layout_unref(this, layout);
 
 out:
-        loc_wipe (&loc);
-        return;
+    loc_wipe(&loc);
+    return;
 }
 
-
 /* Posix returns op_errno = ENOENT to indicate that there are no more entries
  */
 int
-dht_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
-{
-        dht_local_t             *local = NULL;
-        gf_dirent_t              entries;
-        gf_dirent_t             *orig_entry = NULL;
-        gf_dirent_t             *entry = NULL;
-        xlator_t                *prev = NULL;
-        xlator_t                *next_subvol = NULL;
-        off_t                    next_offset = 0;
-        int                      count = 0;
-        dht_layout_t            *layout = NULL;
-        dht_conf_t              *conf   = NULL;
-        dht_methods_t           *methods = NULL;
-        xlator_t                *subvol = 0;
-        xlator_t                *hashed_subvol = 0;
-        int                      ret    = 0;
-        int                      readdir_optimize = 0;
-        inode_table_t           *itable = NULL;
-        inode_t                 *inode = NULL;
-        gf_boolean_t             skip_hashed_check = _gf_false;
-
-        INIT_LIST_HEAD (&entries.list);
-
-        prev = cookie;
-        local = frame->local;
-        itable = local->fd ? local->fd->inode->table : NULL;
+dht_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *next_subvol = NULL;
+    off_t next_offset = 0;
+    int count = 0;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    xlator_t *subvol = 0;
+    xlator_t *hashed_subvol = 0;
+    int ret = 0;
+    int readdir_optimize = 0;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+    gf_boolean_t skip_hashed_check = _gf_false;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    prev = cookie;
+    local = frame->local;
+    itable = local->fd ? local->fd->inode->table : NULL;
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
+
+    methods = &(conf->methods);
+
+    if (op_ret <= 0) {
+        goto done;
+    }
+
+    /* Why aren't we skipping DHT entirely in case of a single subvol?
+     * Because if this was a larger volume earlier and all but one subvol
+     * was removed, there might be stale linkto files on the subvol.
+     */
+    if (conf->subvolume_cnt == 1) {
+        /* return all directory and file entries except
+         * linkto files for a single child DHT
+         */
+        skip_hashed_check = _gf_true;
+    }
 
-        conf  = this->private;
-        GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
+    if (!local->layout)
+        local->layout = dht_layout_get(this, local->fd->inode);
 
-        methods = &(conf->methods);
+    layout = local->layout;
 
-        if (op_ret <= 0) {
-                goto done;
-        }
+    /* We have seen crashes in while running "rm -rf" on tier volumes
+       when the layout was NULL on the hot tier. This will skip the
+       entries on the subvol without a layout, hence preventing the crash
+       but rmdir might fail with "directory not empty" errors*/
 
-        /* Why aren't we skipping DHT entirely in case of a single subvol?
-         * Because if this was a larger volume earlier and all but one subvol
-         * was removed, there might be stale linkto files on the subvol.
-         */
-        if (conf->subvolume_cnt == 1) {
-                /* return all directory and file entries except
-                 * linkto files for a single child DHT
-                 */
-                skip_hashed_check = _gf_true;
-        }
-
-        if (!local->layout)
-                local->layout = dht_layout_get (this, local->fd->inode);
+    if (layout == NULL)
+        goto done;
 
-        layout = local->layout;
+    if (conf->readdir_optimize == _gf_true)
+        readdir_optimize = 1;
 
-        /* We have seen crashes in while running "rm -rf" on tier volumes
-           when the layout was NULL on the hot tier. This will skip the
-           entries on the subvol without a layout, hence preventing the crash
-           but rmdir might fail with "directory not empty" errors*/
-
-        if (layout == NULL)
-                goto done;
+    gf_msg_debug(this->name, 0, "Processing entries from %s", prev->name);
 
-        if (conf->readdir_optimize == _gf_true)
-                readdir_optimize = 1;
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        next_offset = orig_entry->d_off;
 
-        gf_msg_debug (this->name, 0, "Processing entries from %s",
-                      prev->name);
+        gf_msg_debug(this->name, 0, "%s: entry = %s, type = %d", prev->name,
+                     orig_entry->d_name, orig_entry->d_type);
 
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                next_offset = orig_entry->d_off;
+        if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
+            /*stat failed somewhere- ignore this entry*/
+            gf_msg_debug(this->name, EINVAL,
+                         "Invalid stat, ignoring entry "
+                         "%s gfid %s",
+                         orig_entry->d_name,
+                         uuid_utoa(orig_entry->d_stat.ia_gfid));
+            continue;
+        }
 
-                gf_msg_debug (this->name, 0, "%s: entry = %s, type = %d",
-                              prev->name, orig_entry->d_name,
-                              orig_entry->d_type);
+        if (check_is_linkfile(NULL, (&orig_entry->d_stat), orig_entry->dict,
+                              conf->link_xattr_name)) {
+            gf_msg_debug(this->name, 0, "%s: %s is a linkto file", prev->name,
+                         orig_entry->d_name);
+            continue;
+        }
 
-                if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
-                        /*stat failed somewhere- ignore this entry*/
-                        gf_msg_debug (this->name, EINVAL,
-                                      "Invalid stat, ignoring entry "
-                                      "%s gfid %s", orig_entry->d_name,
-                                      uuid_utoa (orig_entry->d_stat.ia_gfid));
-                        continue;
-                }
+        if (skip_hashed_check) {
+            goto list;
+        }
 
-                if (check_is_linkfile (NULL, (&orig_entry->d_stat),
-                                       orig_entry->dict,
-                                       conf->link_xattr_name)) {
-                        gf_msg_debug (this->name, 0, "%s: %s is a linkto file",
-                                      prev->name, orig_entry->d_name);
-                        continue;
-                }
+        if (check_is_dir(NULL, (&orig_entry->d_stat), NULL)) {
+            /*Directory entries filtering :
+             * a) If rebalance is running, pick from first_up_subvol
+             * b) (rebalance not running)hashed subvolume is NULL or
+             * down then filter in first_up_subvolume. Other wise the
+             * corresponding hashed subvolume will take care of the
+             * directory entry.
+             */
+            if (readdir_optimize) {
+                if (prev == local->first_up_subvol)
+                    goto list;
+                else
+                    continue;
+            }
 
-                if (skip_hashed_check) {
-                        goto list;
-                }
+            hashed_subvol = methods->layout_search(this, layout,
+                                                   orig_entry->d_name);
 
-                if (check_is_dir (NULL, (&orig_entry->d_stat), NULL)) {
+            if (prev == hashed_subvol)
+                goto list;
+            if ((hashed_subvol && dht_subvol_status(conf, hashed_subvol)) ||
+                (prev != local->first_up_subvol))
+                continue;
 
-                /*Directory entries filtering :
-                 * a) If rebalance is running, pick from first_up_subvol
-                 * b) (rebalance not running)hashed subvolume is NULL or
-                 * down then filter in first_up_subvolume. Other wise the
-                 * corresponding hashed subvolume will take care of the
-                 * directory entry.
-                 */
-                        if (readdir_optimize) {
-                                if (prev == local->first_up_subvol)
-                                        goto list;
-                                else
-                                        continue;
+            goto list;
+        }
 
-                        }
+    list:
+        entry = gf_dirent_for_name(orig_entry->d_name);
+        if (!entry) {
+            goto unwind;
+        }
 
-                        hashed_subvol = methods->layout_search (this, layout,
-                                                         orig_entry->d_name);
+        /* Do this if conf->search_unhashed is set to "auto" */
+        if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) {
+            subvol = methods->layout_search(this, layout, orig_entry->d_name);
+            if (!subvol || (subvol != prev)) {
+                /* TODO: Count the number of entries which need
+                   linkfile to prove its existence in fs */
+                layout->search_unhashed++;
+            }
+        }
 
-                        if (prev == hashed_subvol)
-                                goto list;
-                        if ((hashed_subvol
-                             && dht_subvol_status (conf, hashed_subvol))
-                            || (prev != local->first_up_subvol))
-                                continue;
+        entry->d_off = orig_entry->d_off;
+        entry->d_stat = orig_entry->d_stat;
+        entry->d_ino = orig_entry->d_ino;
+        entry->d_type = orig_entry->d_type;
+        entry->d_len = orig_entry->d_len;
 
-                        goto list;
-                }
+        if (orig_entry->dict)
+            entry->dict = dict_ref(orig_entry->dict);
 
-list:
-                entry = gf_dirent_for_name (orig_entry->d_name);
-                if (!entry) {
-                        goto unwind;
-                }
+        /* making sure we set the inode ctx right with layout,
+           currently possible only for non-directories, so for
+           directories don't set entry inodes */
+        if (IA_ISDIR(entry->d_stat.ia_type)) {
+            entry->d_stat.ia_blocks = DHT_DIR_STAT_BLOCKS;
+            entry->d_stat.ia_size = DHT_DIR_STAT_SIZE;
+            if (orig_entry->inode) {
+                dht_inode_ctx_time_update(orig_entry->inode, this,
+                                          &entry->d_stat, 1);
 
-                /* Do this if conf->search_unhashed is set to "auto" */
-                if (conf->search_unhashed == GF_DHT_LOOKUP_UNHASHED_AUTO) {
-                        subvol = methods->layout_search (this, layout,
-                                                         orig_entry->d_name);
-                        if (!subvol || (subvol != prev)) {
-                                /* TODO: Count the number of entries which need
-                                   linkfile to prove its existence in fs */
-                                layout->search_unhashed++;
-                        }
+                if (conf->subvolume_cnt == 1) {
+                    dht_populate_inode_for_dentry(this, prev, entry,
+                                                  orig_entry);
                 }
-
-                entry->d_off  = orig_entry->d_off;
-                entry->d_stat = orig_entry->d_stat;
-                entry->d_ino  = orig_entry->d_ino;
-                entry->d_type = orig_entry->d_type;
-                entry->d_len  = orig_entry->d_len;
-
-                if (orig_entry->dict)
-                        entry->dict = dict_ref (orig_entry->dict);
-
-                /* making sure we set the inode ctx right with layout,
-                   currently possible only for non-directories, so for
-                   directories don't set entry inodes */
-                if (IA_ISDIR(entry->d_stat.ia_type)) {
-                        entry->d_stat.ia_blocks = DHT_DIR_STAT_BLOCKS;
-                        entry->d_stat.ia_size = DHT_DIR_STAT_SIZE;
-                        if (orig_entry->inode) {
-                                dht_inode_ctx_time_update (orig_entry->inode,
-                                                           this, &entry->d_stat,
-                                                           1);
-
-                                if (conf->subvolume_cnt == 1) {
-                                        dht_populate_inode_for_dentry (this,
-                                                                       prev,
-                                                                       entry,
-                                                                       orig_entry);
-                                }
-
-                        }
-                } else {
-                        if (orig_entry->inode) {
-                                ret = dht_layout_preset (this, prev,
-                                                         orig_entry->inode);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                                DHT_MSG_LAYOUT_SET_FAILED,
-                                                "failed to link the layout "
-                                                "in inode for %s",
-                                                orig_entry->d_name);
-
-                                entry->inode = inode_ref (orig_entry->inode);
-                        } else if (itable) {
-                                /*
-                                 * orig_entry->inode might be null if any upper
-                                 * layer xlators below client set to null, to
-                                 * force a lookup on the inode even if the inode
-                                 * is present in the inode table. In that case
-                                 * we just update the ctx to make sure we didn't
-                                 * missed anything.
-                                 */
-                                inode = inode_find (itable,
-                                                    orig_entry->d_stat.ia_gfid);
-                                if (inode) {
-                                        ret = dht_layout_preset
-                                                            (this, prev,
-                                                             inode);
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                     GF_LOG_WARNING, 0,
-                                                     DHT_MSG_LAYOUT_SET_FAILED,
-                                                     "failed to link the layout"
-                                                     " in inode for %s",
-                                                     orig_entry->d_name);
-                                        inode_unref (inode);
-                                        inode = NULL;
-                                }
-                        }
+            }
+        } else {
+            if (orig_entry->inode) {
+                ret = dht_layout_preset(this, prev, orig_entry->inode);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_WARNING, 0,
+                           DHT_MSG_LAYOUT_SET_FAILED,
+                           "failed to link the layout "
+                           "in inode for %s",
+                           orig_entry->d_name);
+
+                entry->inode = inode_ref(orig_entry->inode);
+            } else if (itable) {
+                /*
+                 * orig_entry->inode might be null if any upper
+                 * layer xlators below client set to null, to
+                 * force a lookup on the inode even if the inode
+                 * is present in the inode table. In that case
+                 * we just update the ctx to make sure we didn't
+                 * missed anything.
+                 */
+                inode = inode_find(itable, orig_entry->d_stat.ia_gfid);
+                if (inode) {
+                    ret = dht_layout_preset(this, prev, inode);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_WARNING, 0,
+                               DHT_MSG_LAYOUT_SET_FAILED,
+                               "failed to link the layout"
+                               " in inode for %s",
+                               orig_entry->d_name);
+                    inode_unref(inode);
+                    inode = NULL;
                 }
+            }
+        }
 
-                gf_msg_debug (this->name, 0, "%s: Adding entry = %s",
-                              prev->name, entry->d_name);
+        gf_msg_debug(this->name, 0, "%s: Adding entry = %s", prev->name,
+                     entry->d_name);
 
-                list_add_tail (&entry->list, &entries.list);
-                count++;
-        }
+        list_add_tail(&entry->list, &entries.list);
+        count++;
+    }
 
 done:
 
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         * Possible values:
-         * op_ret == 0 and op_errno != 0
-         *   if op_errno != ENOENT : Error.Unwind.
-         *   if op_errno == ENOENT : There are no more entries on this subvol.
-         *                           Move to the next one.
-         * op_ret > 0 and count == 0 :
-         *    The subvol returned entries to dht but all were stripped out.
-         *    For example, if they were linkto files or dirs where
-         *    hashed_subvol != prev. Try to get some entries by winding
-         *    to the next subvol. This can be dangerous if parallel readdir
-         *    is enabled as it grows the stack.
-         *
-         * op_ret > 0 and count > 0:
-         *   We found some entries. Unwind even if the buffer is not full.
-         *
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     * Possible values:
+     * op_ret == 0 and op_errno != 0
+     *   if op_errno != ENOENT : Error.Unwind.
+     *   if op_errno == ENOENT : There are no more entries on this subvol.
+     *                           Move to the next one.
+     * op_ret > 0 and count == 0 :
+     *    The subvol returned entries to dht but all were stripped out.
+     *    For example, if they were linkto files or dirs where
+     *    hashed_subvol != prev. Try to get some entries by winding
+     *    to the next subvol. This can be dangerous if parallel readdir
+     *    is enabled as it grows the stack.
+     *
+     * op_ret > 0 and count > 0:
+     *   We found some entries. Unwind even if the buffer is not full.
+     *
+     */
+
+    op_ret = count;
+    if (count == 0) {
+        /* non-zero next_offset means that
+         * EOF is not yet hit on the current subvol
          */
+        if ((next_offset == 0) || (op_errno == ENOENT)) {
+            next_offset = 0;
+            next_subvol = dht_subvol_next(this, prev);
+        } else {
+            next_subvol = prev;
+        }
 
-        op_ret = count;
-        if (count == 0) {
-                /* non-zero next_offset means that
-                 * EOF is not yet hit on the current subvol
-                 */
-                if ((next_offset == 0) || (op_errno == ENOENT)) {
-                        next_offset = 0;
-                        next_subvol = dht_subvol_next (this, prev);
-                } else {
-                        next_subvol = prev;
-                }
-
-                if (!next_subvol) {
-                        goto unwind;
-                }
-
-                if (conf->readdir_optimize == _gf_true) {
-                        if (next_subvol != local->first_up_subvol) {
-                                ret = dict_set_int32 (local->xattr,
-                                                      GF_READDIR_SKIP_DIRS, 1);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_DICT_SET_FAILED,
-                                                "Failed to set dictionary value"
-                                                ":key = %s",
-                                                GF_READDIR_SKIP_DIRS );
-                        } else {
-                                 dict_del (local->xattr,
-                                           GF_READDIR_SKIP_DIRS);
-                        }
-                }
+        if (!next_subvol) {
+            goto unwind;
+        }
 
-                STACK_WIND_COOKIE (frame, dht_readdirp_cbk, next_subvol,
-                                   next_subvol, next_subvol->fops->readdirp,
-                                   local->fd, local->size,
-                                   next_offset, local->xattr);
-                return 0;
+        if (conf->readdir_optimize == _gf_true) {
+            if (next_subvol != local->first_up_subvol) {
+                ret = dict_set_int32(local->xattr, GF_READDIR_SKIP_DIRS, 1);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary value"
+                           ":key = %s",
+                           GF_READDIR_SKIP_DIRS);
+            } else {
+                dict_del(local->xattr, GF_READDIR_SKIP_DIRS);
+            }
         }
 
+        STACK_WIND_COOKIE(frame, dht_readdirp_cbk, next_subvol, next_subvol,
+                          next_subvol->fops->readdirp, local->fd, local->size,
+                          next_offset, local->xattr);
+        return 0;
+    }
+
 unwind:
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         */
-        if (op_ret < 0)
-                op_ret = 0;
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
+    if (op_ret < 0)
+        op_ret = 0;
 
-        if (prev != dht_last_up_subvol (this))
-                op_errno = 0;
+    if (prev != dht_last_up_subvol(this))
+        op_errno = 0;
 
-        DHT_STACK_UNWIND (readdirp, frame, op_ret, op_errno,
-                          &entries, NULL);
+    DHT_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &entries, NULL);
 
-        gf_dirent_free (&entries);
-        return 0;
+    gf_dirent_free(&entries);
+    return 0;
 }
 
-
 int
-dht_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, gf_dirent_t *orig_entries,
-                 dict_t *xdata)
+dht_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        gf_dirent_t   entries;
-        gf_dirent_t  *orig_entry = NULL;
-        gf_dirent_t  *entry = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *next_subvol = NULL;
-        off_t         next_offset = 0;
-        int           count = 0;
-        dht_layout_t *layout = 0;
-        xlator_t     *subvol = 0;
-        dht_conf_t   *conf = NULL;
-        dht_methods_t *methods = NULL;
-        gf_boolean_t   skip_hashed_check = _gf_false;
-
-        INIT_LIST_HEAD (&entries.list);
-
-        prev = cookie;
-        local = frame->local;
+    dht_local_t *local = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *next_subvol = NULL;
+    off_t next_offset = 0;
+    int count = 0;
+    dht_layout_t *layout = 0;
+    xlator_t *subvol = 0;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
+    gf_boolean_t skip_hashed_check = _gf_false;
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, done);
+    INIT_LIST_HEAD(&entries.list);
 
-        methods = &(conf->methods);
+    prev = cookie;
+    local = frame->local;
 
-        if (op_ret <= 0)
-                goto done;
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, done);
 
-        if (!local->layout)
-                local->layout = dht_layout_get (this, local->fd->inode);
+    methods = &(conf->methods);
 
-        layout = local->layout;
+    if (op_ret <= 0)
+        goto done;
 
-        gf_msg_debug (this->name, 0, "Processing entries from %s",
-                      prev->name);
+    if (!local->layout)
+        local->layout = dht_layout_get(this, local->fd->inode);
 
-        if (conf->subvolume_cnt == 1) {
-                /*return everything*/
-                skip_hashed_check = _gf_true;
-                count = op_ret;
-                goto done;
-        }
+    layout = local->layout;
+
+    gf_msg_debug(this->name, 0, "Processing entries from %s", prev->name);
 
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                next_offset = orig_entry->d_off;
+    if (conf->subvolume_cnt == 1) {
+        /*return everything*/
+        skip_hashed_check = _gf_true;
+        count = op_ret;
+        goto done;
+    }
 
-                gf_msg_debug (this->name, 0, "%s: entry = %s, type = %d",
-                              prev->name, orig_entry->d_name,
-                              orig_entry->d_type);
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        next_offset = orig_entry->d_off;
 
-                subvol = methods->layout_search (this, layout,
-                                                 orig_entry->d_name);
+        gf_msg_debug(this->name, 0, "%s: entry = %s, type = %d", prev->name,
+                     orig_entry->d_name, orig_entry->d_type);
 
-                if (!subvol || (subvol == prev)) {
-                        entry = gf_dirent_for_name (orig_entry->d_name);
-                        if (!entry) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "Memory allocation failed ");
-                                goto unwind;
-                        }
+        subvol = methods->layout_search(this, layout, orig_entry->d_name);
 
-                        entry->d_off  = orig_entry->d_off;
-                        entry->d_ino  = orig_entry->d_ino;
-                        entry->d_type = orig_entry->d_type;
-                        entry->d_len  = orig_entry->d_len;
+        if (!subvol || (subvol == prev)) {
+            entry = gf_dirent_for_name(orig_entry->d_name);
+            if (!entry) {
+                gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                       "Memory allocation failed ");
+                goto unwind;
+            }
 
-                        gf_msg_debug (this->name, 0, "%s: Adding = entry %s",
-                                      prev->name, entry->d_name);
+            entry->d_off = orig_entry->d_off;
+            entry->d_ino = orig_entry->d_ino;
+            entry->d_type = orig_entry->d_type;
+            entry->d_len = orig_entry->d_len;
 
-                        list_add_tail (&entry->list, &entries.list);
-                        count++;
-                }
+            gf_msg_debug(this->name, 0, "%s: Adding = entry %s", prev->name,
+                         entry->d_name);
+
+            list_add_tail(&entry->list, &entries.list);
+            count++;
         }
+    }
 done:
-        op_ret = count;
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         */
-        if (count == 0) {
-                if ((next_offset == 0) || (op_errno == ENOENT)) {
-                        next_offset = 0;
-                        next_subvol = dht_subvol_next (this, prev);
-                } else {
-                        next_subvol = prev;
-                }
-
-                if (!next_subvol) {
-                        goto unwind;
-                }
+    op_ret = count;
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
+    if (count == 0) {
+        if ((next_offset == 0) || (op_errno == ENOENT)) {
+            next_offset = 0;
+            next_subvol = dht_subvol_next(this, prev);
+        } else {
+            next_subvol = prev;
+        }
 
-                STACK_WIND_COOKIE (frame, dht_readdir_cbk, next_subvol,
-                                   next_subvol, next_subvol->fops->readdir,
-                                   local->fd, local->size,
-                                   next_offset, NULL);
-                return 0;
+        if (!next_subvol) {
+            goto unwind;
         }
 
+        STACK_WIND_COOKIE(frame, dht_readdir_cbk, next_subvol, next_subvol,
+                          next_subvol->fops->readdir, local->fd, local->size,
+                          next_offset, NULL);
+        return 0;
+    }
+
 unwind:
-        /* We need to ensure that only the last subvolume's end-of-directory
-         * notification is respected so that directory reading does not stop
-         * before all subvolumes have been read. That could happen because the
-         * posix for each subvolume sends a ENOENT on end-of-directory but in
-         * distribute we're not concerned only with a posix's view of the
-         * directory but the aggregated namespace' view of the directory.
-         */
+    /* We need to ensure that only the last subvolume's end-of-directory
+     * notification is respected so that directory reading does not stop
+     * before all subvolumes have been read. That could happen because the
+     * posix for each subvolume sends a ENOENT on end-of-directory but in
+     * distribute we're not concerned only with a posix's view of the
+     * directory but the aggregated namespace' view of the directory.
+     */
 
-        if (prev != dht_last_up_subvol (this))
-                op_errno = 0;
+    if (prev != dht_last_up_subvol(this))
+        op_errno = 0;
 
-        if (!skip_hashed_check) {
-                DHT_STACK_UNWIND (readdir, frame, op_ret, op_errno,
-                                  &entries, NULL);
-                gf_dirent_free (&entries);
+    if (!skip_hashed_check) {
+        DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, NULL);
+        gf_dirent_free(&entries);
 
-        } else {
-                DHT_STACK_UNWIND (readdir, frame, op_ret, op_errno,
-                                  orig_entries, NULL);
-        }
-        return 0;
+    } else {
+        DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, orig_entries, NULL);
+    }
+    return 0;
 }
 
-
 int
-dht_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                off_t yoff, int whichop, dict_t *dict)
+dht_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t yoff, int whichop, dict_t *dict)
 {
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        xlator_t     *xvol = NULL;
-        int           ret = 0;
-        dht_conf_t   *conf = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, NULL, whichop);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->fd = fd_ref (fd);
-        local->size = size;
-        local->xattr_req = (dict)? dict_ref (dict) : NULL;
-        local->first_up_subvol = dht_first_up_subvol (this);
-        local->op_ret = -1;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    xlator_t *xvol = NULL;
+    int ret = 0;
+    dht_conf_t *conf = NULL;
 
-        dht_deitransform (this, yoff, &xvol);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        /* TODO: do proper readdir */
-        if (whichop == GF_FOP_READDIRP) {
-                if (dict)
-                        local->xattr = dict_ref (dict);
-                else
-                        local->xattr = dict_new ();
+    conf = this->private;
 
-                if (local->xattr) {
-                        ret = dict_set_uint32 (local->xattr,
-                                               conf->link_xattr_name, 256);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set dictionary value"
-                                        " : key = %s",
-                                        conf->link_xattr_name);
+    local = dht_local_init(frame, NULL, NULL, whichop);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-                        if (conf->readdir_optimize == _gf_true) {
-                                if (xvol != local->first_up_subvol) {
-                                        ret = dict_set_int32 (local->xattr,
-                                                       GF_READDIR_SKIP_DIRS, 1);
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                        GF_LOG_ERROR, 0,
-                                                        DHT_MSG_DICT_SET_FAILED,
-                                                        "Failed to set "
-                                                        "dictionary value: "
-                                                        "key = %s",
-                                                        GF_READDIR_SKIP_DIRS);
-                                } else {
-                                        dict_del (local->xattr,
-                                                  GF_READDIR_SKIP_DIRS);
-                                }
-                        }
-
-                        if (conf->subvolume_cnt == 1) {
-                                ret = dict_set_uint32 (local->xattr,
-                                                       conf->xattr_name, 4 * 4);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_WARNING,
-                                                ENOMEM,
-                                                DHT_MSG_DICT_SET_FAILED,
-                                                "Failed to set dictionary "
-                                                "value:key = %s ",
-                                                conf->xattr_name);
-                                }
-                        }
+    local->fd = fd_ref(fd);
+    local->size = size;
+    local->xattr_req = (dict) ? dict_ref(dict) : NULL;
+    local->first_up_subvol = dht_first_up_subvol(this);
+    local->op_ret = -1;
 
+    dht_deitransform(this, yoff, &xvol);
 
+    /* TODO: do proper readdir */
+    if (whichop == GF_FOP_READDIRP) {
+        if (dict)
+            local->xattr = dict_ref(dict);
+        else
+            local->xattr = dict_new();
+
+        if (local->xattr) {
+            ret = dict_set_uint32(local->xattr, conf->link_xattr_name, 256);
+            if (ret)
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set dictionary value"
+                       " : key = %s",
+                       conf->link_xattr_name);
+
+            if (conf->readdir_optimize == _gf_true) {
+                if (xvol != local->first_up_subvol) {
+                    ret = dict_set_int32(local->xattr, GF_READDIR_SKIP_DIRS, 1);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_ERROR, 0,
+                               DHT_MSG_DICT_SET_FAILED,
+                               "Failed to set "
+                               "dictionary value: "
+                               "key = %s",
+                               GF_READDIR_SKIP_DIRS);
+                } else {
+                    dict_del(local->xattr, GF_READDIR_SKIP_DIRS);
                 }
+            }
 
-                STACK_WIND_COOKIE (frame, dht_readdirp_cbk, xvol, xvol,
-                                   xvol->fops->readdirp, fd, size, yoff,
-                                   local->xattr);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_readdir_cbk, xvol, xvol,
-                                   xvol->fops->readdir, fd, size, yoff,
-                                   local->xattr);
+            if (conf->subvolume_cnt == 1) {
+                ret = dict_set_uint32(local->xattr, conf->xattr_name, 4 * 4);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
+                           DHT_MSG_DICT_SET_FAILED,
+                           "Failed to set dictionary "
+                           "value:key = %s ",
+                           conf->xattr_name);
+                }
+            }
         }
 
-        return 0;
+        STACK_WIND_COOKIE(frame, dht_readdirp_cbk, xvol, xvol,
+                          xvol->fops->readdirp, fd, size, yoff, local->xattr);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_readdir_cbk, xvol, xvol,
+                          xvol->fops->readdir, fd, size, yoff, local->xattr);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t yoff, dict_t *xdata)
+dht_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t yoff, dict_t *xdata)
 {
-        int          op = GF_FOP_READDIR;
-        dht_conf_t  *conf = NULL;
-        int          i = 0;
+    int op = GF_FOP_READDIR;
+    dht_conf_t *conf = NULL;
+    int i = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->subvolume_status[i]) {
-                        op = GF_FOP_READDIRP;
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            op = GF_FOP_READDIRP;
+            break;
         }
+    }
 
-        if (conf->use_readdirp)
-                op = GF_FOP_READDIRP;
+    if (conf->use_readdirp)
+        op = GF_FOP_READDIRP;
 
 out:
-        dht_do_readdir (frame, this, fd, size, yoff, op, 0);
-        return 0;
+    dht_do_readdir(frame, this, fd, size, yoff, op, 0);
+    return 0;
 }
 
 int
-dht_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t yoff, dict_t *dict)
+dht_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t yoff, dict_t *dict)
 {
-        dht_do_readdir (frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
-        return 0;
+    dht_do_readdir(frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
+    return 0;
 }
 
-
-
 int
-dht_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, dict_t *xdata)
+dht_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1)
-                        local->op_errno = op_errno;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1)
+            local->op_errno = op_errno;
 
-                if (op_ret == 0)
-                        local->op_ret = 0;
-        }
-        UNLOCK (&frame->lock);
+        if (op_ret == 0)
+            local->op_ret = 0;
+    }
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt))
-                DHT_STACK_UNWIND (fsyncdir, frame, local->op_ret,
-                                  local->op_errno, xdata);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
+                         xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              int datasync, dict_t *xdata)
+dht_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
+             dict_t *xdata)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        conf = this->private;
+    conf = this->private;
 
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_FSYNCDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_FSYNCDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->fd = fd_ref (fd);
-        local->call_cnt = conf->subvolume_cnt;
+    local->fd = fd_ref(fd);
+    local->call_cnt = conf->subvolume_cnt;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND (frame, dht_fsyncdir_cbk,
-                            conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->fsyncdir,
-                            fd, datasync, xdata);
-        }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND(frame, dht_fsyncdir_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->fsyncdir, fd, datasync, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsyncdir, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_newfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno,
-                 inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+dht_newfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, inode_t *inode, struct iatt *stbuf,
+                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        dht_local_t  *local = NULL;
-
+    xlator_t *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        if (op_ret == -1)
-                goto out;
-
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        prev = cookie;
-
-        if (local->loc.parent) {
-
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+    if (op_ret == -1)
+        goto out;
 
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret < 0) {
-                gf_msg_debug (this->name, EINVAL,
-                              "could not set pre-set layout for subvolume %s",
-                              prev? prev->name: NULL);
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-        if (local->linked == _gf_true)
-                dht_linkfile_attr_heal (frame, this);
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    prev = cookie;
+
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret < 0) {
+        gf_msg_debug(this->name, EINVAL,
+                     "could not set pre-set layout for subvolume %s",
+                     prev ? prev->name : NULL);
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+    if (local->linked == _gf_true)
+        dht_linkfile_attr_heal(frame, this);
 out:
-        /*
-         * FIXME: ia_size and st_blocks of preparent and postparent do not have
-         * correct values. since, preparent and postparent buffers correspond
-         * to a directory these two members should have values equal to sum of
-         * corresponding values from each of the subvolume.
-         * See dht_iatt_merge for reference.
-         */
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (postparent);
-        dht_set_fixed_dir_stat (preparent);
-
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                /* store op_errno for failure case*/
-                local->op_errno = op_errno;
-                local->refresh_layout_unlock (frame, this, op_ret, 1);
+    /*
+     * FIXME: ia_size and st_blocks of preparent and postparent do not have
+     * correct values. since, preparent and postparent buffers correspond
+     * to a directory these two members should have values equal to sum of
+     * corresponding values from each of the subvolume.
+     * See dht_iatt_merge for reference.
+     */
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(postparent);
+    dht_set_fixed_dir_stat(preparent);
+
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        /* store op_errno for failure case*/
+        local->op_errno = op_errno;
+        local->refresh_layout_unlock(frame, this, op_ret, 1);
 
-                if (op_ret == 0) {
-                        DHT_STACK_UNWIND (mknod, frame, op_ret, op_errno,
-                                          inode, stbuf, preparent, postparent,
-                                          xdata);
-                }
-        } else {
-                DHT_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode,
-                                  stbuf, preparent, postparent, xdata);
+        if (op_ret == 0) {
+            DHT_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, stbuf,
+                             preparent, postparent, xdata);
         }
+    } else {
+        DHT_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, stbuf,
+                         preparent, postparent, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mknod_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this,
-                               int32_t op_ret, int32_t op_errno,
-                               inode_t *inode, struct iatt *stbuf,
-                               struct iatt *preparent, struct iatt *postparent,
-                               dict_t *xdata)
+dht_mknod_linkfile_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno, inode_t *inode,
+                              struct iatt *stbuf, struct iatt *preparent,
+                              struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *cached_subvol  = NULL;
-        dht_conf_t      *conf           = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local || !local->cached_subvol) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (!local || !local->cached_subvol) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        conf = this->private;
-        if (!conf) {
-                local->op_errno =  EINVAL;
-                op_errno = EINVAL;
-                goto err;
-        }
+    conf = this->private;
+    if (!conf) {
+        local->op_errno = EINVAL;
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
+    cached_subvol = local->cached_subvol;
 
-        if (local->params) {
-                 dict_del (local->params, conf->link_xattr_name);
-                 dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
+    if (local->params) {
+        dict_del(local->params, conf->link_xattr_name);
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)cached_subvol,
-                           cached_subvol, cached_subvol->fops->mknod,
-                           &local->loc, local->mode, local->rdev, local->umask,
-                           local->params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)cached_subvol,
+                      cached_subvol, cached_subvol->fops->mknod, &local->loc,
+                      local->mode, local->rdev, local->umask, local->params);
 
-        return 0;
+    return 0;
 err:
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        } else {
-                DHT_STACK_UNWIND (mknod, frame, -1,
-                                  op_errno, NULL, NULL, NULL,
-                                  NULL, NULL);
-        }
-        return 0;
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    } else {
+        DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                         NULL);
+    }
+    return 0;
 }
 
 int
-dht_mknod_wind_to_avail_subvol (call_frame_t *frame, xlator_t *this,
-                                 xlator_t *subvol, loc_t *loc, dev_t rdev,
-                                 mode_t mode, mode_t umask, dict_t *params)
+dht_mknod_wind_to_avail_subvol(call_frame_t *frame, xlator_t *this,
+                               xlator_t *subvol, loc_t *loc, dev_t rdev,
+                               mode_t mode, mode_t umask, dict_t *params)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *avail_subvol   = NULL;
-
-        local = frame->local;
+    dht_local_t *local = NULL;
+    xlator_t *avail_subvol = NULL;
 
-        if (!dht_is_subvol_filled (this, subvol)) {
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path,
-                              subvol->name);
+    local = frame->local;
 
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol,
-                                   subvol, subvol->fops->mknod, loc, mode,
-                                   rdev, umask, params);
-        } else {
-                avail_subvol = dht_free_disk_available_subvol (this, subvol, local);
+    if (!dht_is_subvol_filled(this, subvol)) {
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-                if (avail_subvol != subvol) {
-                        local->params = dict_ref (params);
-                        local->rdev = rdev;
-                        local->mode = mode;
-                        local->umask = umask;
-                        local->cached_subvol = avail_subvol;
-                        local->hashed_subvol = subvol;
+        STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                          subvol->fops->mknod, loc, mode, rdev, umask, params);
+    } else {
+        avail_subvol = dht_free_disk_available_subvol(this, subvol, local);
 
-                        gf_msg_debug (this->name, 0,
-                                      "creating %s on %s (link at %s)", loc->path,
-                                      avail_subvol->name, subvol->name);
+        if (avail_subvol != subvol) {
+            local->params = dict_ref(params);
+            local->rdev = rdev;
+            local->mode = mode;
+            local->umask = umask;
+            local->cached_subvol = avail_subvol;
+            local->hashed_subvol = subvol;
 
-                        dht_linkfile_create (frame,
-                                             dht_mknod_linkfile_create_cbk,
-                                             this, avail_subvol, subvol, loc);
+            gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)",
+                         loc->path, avail_subvol->name, subvol->name);
 
-                        goto out;
-                }
+            dht_linkfile_create(frame, dht_mknod_linkfile_create_cbk, this,
+                                avail_subvol, subvol, loc);
 
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path, subvol->name);
+            goto out;
+        }
 
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk,
-                                   (void *)subvol, subvol,
-                                   subvol->fops->mknod, loc, mode,
-                                   rdev, umask, params);
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-        }
+        STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                          subvol->fops->mknod, loc, mode, rdev, umask, params);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-dht_mknod_do (call_frame_t *frame)
+dht_mknod_do(call_frame_t *frame)
 {
-        dht_local_t     *local          = NULL;
-        dht_layout_t    *refreshed      = NULL;
-        xlator_t        *subvol         = NULL;
-        xlator_t        *this           = NULL;
-        dht_conf_t      *conf           = NULL;
-        dht_methods_t   *methods        = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *refreshed = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        this = THIS;
+    this = THIS;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        /* We don't need parent_loc anymore */
-        loc_wipe (&local->loc);
+    /* We don't need parent_loc anymore */
+    loc_wipe(&local->loc);
 
-        loc_copy (&local->loc, &local->loc2);
+    loc_copy(&local->loc, &local->loc2);
 
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc2);
 
-        refreshed = local->selfheal.refreshed_layout;
+    refreshed = local->selfheal.refreshed_layout;
 
-        subvol = methods->layout_search (this, refreshed, local->loc.name);
+    subvol = methods->layout_search(this, refreshed, local->loc.name);
 
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED, "no subvolume in "
-                        "layout for path=%s", local->loc.path);
-                local->op_errno = ENOENT;
-                goto err;
-        }
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in "
+               "layout for path=%s",
+               local->loc.path);
+        local->op_errno = ENOENT;
+        goto err;
+    }
 
-        dht_mknod_wind_to_avail_subvol (frame, this, subvol, &local->loc,
-                                         local->rdev, local->mode,
-                                         local->umask, local->params);
-        return 0;
+    dht_mknod_wind_to_avail_subvol(frame, this, subvol, &local->loc,
+                                   local->rdev, local->mode, local->umask,
+                                   local->params);
+    return 0;
 err:
-        local->refresh_layout_unlock (frame, this, -1, 1);
+    local->refresh_layout_unlock(frame, this, -1, 1);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-dht_mknod_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_mknod_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
-dht_mknod_finish (call_frame_t *frame, xlator_t *this, int op_ret,
-                  int invoke_cbk)
-{
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
-
-        local = frame->local;
-        lock_count = dht_lock_count (local->lock[0].layout.parent_layout.locks,
-                                     local->lock[0].layout.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
-
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
-
-        lock_local->lock[0].layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
-        lock_local->lock[0].layout.parent_layout.lk_count = local->lock[0].layout.parent_layout.lk_count;
-
-        local->lock[0].layout.parent_layout.locks = NULL;
-        local->lock[0].layout.parent_layout.lk_count = 0;
-
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].layout.parent_layout.locks,
-                            lock_local->lock[0].layout.parent_layout.lk_count,
-                            dht_mknod_unlock_cbk);
-        lock_frame = NULL;
+dht_mknod_finish(call_frame_t *frame, xlator_t *this, int op_ret,
+                 int invoke_cbk)
+{
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
+
+    local = frame->local;
+    lock_count = dht_lock_count(local->lock[0].layout.parent_layout.locks,
+                                local->lock[0].layout.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
+
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
+
+    lock_local->lock[0]
+        .layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
+    lock_local->lock[0].layout.parent_layout.lk_count =
+        local->lock[0].layout.parent_layout.lk_count;
+
+    local->lock[0].layout.parent_layout.locks = NULL;
+    local->lock[0].layout.parent_layout.lk_count = 0;
+
+    dht_unlock_inodelk(lock_frame,
+                       lock_local->lock[0].layout.parent_layout.locks,
+                       lock_local->lock[0].layout.parent_layout.lk_count,
+                       dht_mknod_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        if (op_ret == 0)
-                return 0;
-
-        DHT_STACK_UNWIND (mknod, frame, op_ret, local->op_errno, NULL, NULL,
-                          NULL, NULL, NULL);
+    if (op_ret == 0)
         return 0;
+
+    DHT_STACK_UNWIND(mknod, frame, op_ret, local->op_errno, NULL, NULL, NULL,
+                     NULL, NULL);
+    return 0;
 }
 
 int32_t
-dht_mknod_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_mknod_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                gf_msg ("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
-                        "mknod lock failed for file: %s", local->loc2.name);
+    if (op_ret < 0) {
+        gf_msg("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+               "mknod lock failed for file: %s", local->loc2.name);
 
-                local->op_errno = op_errno;
+        local->op_errno = op_errno;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_mknod_finish;
+    local->refresh_layout_unlock = dht_mknod_finish;
 
-        local->refresh_layout_done = dht_mknod_do;
+    local->refresh_layout_done = dht_mknod_do;
 
-        dht_refresh_layout (frame);
+    dht_refresh_layout(frame);
 
-        return 0;
+    return 0;
 err:
-        dht_mknod_finish (frame, this, -1, 0);
-        return 0;
+    dht_mknod_finish(frame, this, -1, 0);
+    return 0;
 }
 
 int32_t
-dht_mknod_lock (call_frame_t *frame, xlator_t *subvol)
+dht_mknod_lock(call_frame_t *frame, xlator_t *subvol)
 {
-        dht_local_t     *local          = NULL;
-        int              count  = 1,    ret = -1;
-        dht_lock_t     **lk_array       = NULL;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-        local = frame->local;
+    local = frame->local;
 
-        lk_array = GF_CALLOC (count, sizeof (*lk_array), gf_common_mt_pointer);
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
 
-        if (lk_array == NULL)
-                goto err;
+    if (lk_array == NULL)
+        goto err;
 
-        lk_array[0] = dht_lock_new (frame->this, subvol, &local->loc, F_RDLCK,
-                                    DHT_LAYOUT_HEAL_DOMAIN, NULL,
-                                    IGNORE_ENOENT_ESTALE);
+    lk_array[0] = dht_lock_new(frame->this, subvol, &local->loc, F_RDLCK,
+                               DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                               IGNORE_ENOENT_ESTALE);
 
-        if (lk_array[0] == NULL)
-                goto err;
+    if (lk_array[0] == NULL)
+        goto err;
 
-        local->lock[0].layout.parent_layout.locks = lk_array;
-        local->lock[0].layout.parent_layout.lk_count = count;
+    local->lock[0].layout.parent_layout.locks = lk_array;
+    local->lock[0].layout.parent_layout.lk_count = count;
 
-        ret = dht_blocking_inodelk (frame, lk_array, count, dht_mknod_lock_cbk);
+    ret = dht_blocking_inodelk(frame, lk_array, count, dht_mknod_lock_cbk);
 
-        if (ret < 0) {
-                local->lock[0].layout.parent_layout.locks = NULL;
-                local->lock[0].layout.parent_layout.lk_count = 0;
-                goto err;
-        }
+    if (ret < 0) {
+        local->lock[0].layout.parent_layout.locks = NULL;
+        local->lock[0].layout.parent_layout.lk_count = 0;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_refresh_parent_layout_resume (call_frame_t *frame, xlator_t *this, int ret,
-                                  int invoke_cbk)
+dht_refresh_parent_layout_resume(call_frame_t *frame, xlator_t *this, int ret,
+                                 int invoke_cbk)
 {
-        dht_local_t  *local        = NULL, *parent_local = NULL;
-        call_stub_t  *stub         = NULL;
-        call_frame_t *parent_frame = NULL;
+    dht_local_t *local = NULL, *parent_local = NULL;
+    call_stub_t *stub = NULL;
+    call_frame_t *parent_frame = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        stub = local->stub;
-        local->stub = NULL;
+    stub = local->stub;
+    local->stub = NULL;
 
-        parent_frame = stub->frame;
-        parent_local = parent_frame->local;
+    parent_frame = stub->frame;
+    parent_local = parent_frame->local;
 
-        if (ret < 0) {
-                parent_local->op_ret = -1;
-                parent_local->op_errno = local->op_errno
-                        ? local->op_errno : EIO;
-        } else {
-                parent_local->op_ret = 0;
-        }
+    if (ret < 0) {
+        parent_local->op_ret = -1;
+        parent_local->op_errno = local->op_errno ? local->op_errno : EIO;
+    } else {
+        parent_local->op_ret = 0;
+    }
 
-        call_resume (stub);
+    call_resume(stub);
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_refresh_parent_layout_done (call_frame_t *frame)
+dht_refresh_parent_layout_done(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        int          ret   = 0;
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->op_ret < 0) {
-                ret = -1;
-                goto resume;
-        }
+    if (local->op_ret < 0) {
+        ret = -1;
+        goto resume;
+    }
 
-        dht_layout_set (frame->this, local->loc.inode,
-                        local->selfheal.refreshed_layout);
+    dht_layout_set(frame->this, local->loc.inode,
+                   local->selfheal.refreshed_layout);
 
 resume:
-        dht_refresh_parent_layout_resume (frame, frame->this, ret, 1);
-        return 0;
+    dht_refresh_parent_layout_resume(frame, frame->this, ret, 1);
+    return 0;
 }
 
-
 int
-dht_handle_parent_layout_change (xlator_t *this, call_stub_t *stub)
+dht_handle_parent_layout_change(xlator_t *this, call_stub_t *stub)
 {
-        call_frame_t *refresh_frame = NULL, *frame = NULL;
-        dht_local_t  *refresh_local = NULL, *local = NULL;
+    call_frame_t *refresh_frame = NULL, *frame = NULL;
+    dht_local_t *refresh_local = NULL, *local = NULL;
 
-        frame = stub->frame;
-        local = frame->local;
+    frame = stub->frame;
+    local = frame->local;
 
-        refresh_frame = copy_frame (frame);
-        refresh_local = dht_local_init (refresh_frame, NULL, NULL,
-                                        stub->fop);
+    refresh_frame = copy_frame(frame);
+    refresh_local = dht_local_init(refresh_frame, NULL, NULL, stub->fop);
 
-        refresh_local->loc.inode = inode_ref (local->loc.parent);
-        gf_uuid_copy (refresh_local->loc.gfid, local->loc.parent->gfid);
+    refresh_local->loc.inode = inode_ref(local->loc.parent);
+    gf_uuid_copy(refresh_local->loc.gfid, local->loc.parent->gfid);
 
-        refresh_local->stub = stub;
+    refresh_local->stub = stub;
 
-        refresh_local->refresh_layout_unlock = dht_refresh_parent_layout_resume;
-        refresh_local->refresh_layout_done = dht_refresh_parent_layout_done;
+    refresh_local->refresh_layout_unlock = dht_refresh_parent_layout_resume;
+    refresh_local->refresh_layout_done = dht_refresh_parent_layout_done;
 
-        dht_refresh_layout (refresh_frame);
-        return 0;
+    dht_refresh_layout(refresh_frame);
+    return 0;
 }
 
 int32_t
-dht_call_mkdir_stub (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_call_mkdir_stub(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        call_stub_t *stub  = NULL;
+    dht_local_t *local = NULL;
+    call_stub_t *stub = NULL;
 
-        local = frame->local;
-        stub = local->stub;
-        local->stub = NULL;
+    local = frame->local;
+    stub = local->stub;
+    local->stub = NULL;
 
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-        } else {
-                local->op_ret = 0;
-        }
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    } else {
+        local->op_ret = 0;
+    }
 
-        call_resume (stub);
+    call_resume(stub);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-dht_guard_parent_layout_and_namespace (xlator_t *subvol, call_stub_t *stub)
+dht_guard_parent_layout_and_namespace(xlator_t *subvol, call_stub_t *stub)
 {
-        dht_local_t   *local                  = NULL;
-        int            ret                    = -1;
-        loc_t         *loc                    = NULL;
-        xlator_t      *hashed_subvol          = NULL, *this = NULL;;
-        call_frame_t  *frame                  = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int32_t       *parent_disk_layout     = NULL;
-        dht_layout_t  *parent_layout          = NULL;
-        dht_conf_t    *conf                   = NULL;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    loc_t *loc = NULL;
+    xlator_t *hashed_subvol = NULL, *this = NULL;
+    ;
+    call_frame_t *frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t *parent_disk_layout = NULL;
+    dht_layout_t *parent_layout = NULL;
+    dht_conf_t *conf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", stub, err);
+    GF_VALIDATE_OR_GOTO("dht", stub, err);
 
-        frame = stub->frame;
-        this = frame->this;
+    frame = stub->frame;
+    this = frame->this;
 
-        conf = this->private;
+    conf = this->private;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->stub = stub;
+    local->stub = stub;
 
-        /* TODO: recheck whether we should lock on src or dst if we do similar
-         * stale layout checks for rename.
-         */
-        loc = &stub->args.loc;
+    /* TODO: recheck whether we should lock on src or dst if we do similar
+     * stale layout checks for rename.
+     */
+    loc = &stub->args.loc;
 
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
 
+    if (local->params == NULL) {
+        local->params = dict_new();
         if (local->params == NULL) {
-                local->params = dict_new ();
-                if (local->params == NULL) {
-                        local->op_errno = ENOMEM;
-                        gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                                DHT_MSG_PARENT_LAYOUT_CHANGED,
-                                "%s (%s/%s) (path: %s): "
-                                "dict allocation failed",
-                                gf_fop_list[stub->fop],
-                                pgfid, loc->name, loc->path);
-                        goto err;
-                }
-        }
-
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                local->op_errno = EINVAL;
+            local->op_errno = ENOMEM;
+            gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+                   DHT_MSG_PARENT_LAYOUT_CHANGED,
+                   "%s (%s/%s) (path: %s): "
+                   "dict allocation failed",
+                   gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+            goto err;
+        }
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        local->op_errno = EINVAL;
+
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "hashed subvolume not found",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_layout = dht_layout_get(this, loc->parent);
+
+    ret = dht_disk_layout_extract_for_subvol(this, parent_layout, hashed_subvol,
+                                             &parent_disk_layout);
+    if (ret == -1) {
+        local->op_errno = EINVAL;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "extracting in-memory layout of parent failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    memcpy((void *)local->parent_disk_layout, (void *)parent_disk_layout,
+           sizeof(local->parent_disk_layout));
+
+    dht_layout_unref(this, parent_layout);
+    parent_layout = NULL;
+
+    ret = dict_set_str(local->params, GF_PREOP_PARENT_KEY, conf->xattr_name);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting %s key in params dictionary failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path,
+               GF_PREOP_PARENT_KEY);
+        goto err;
+    }
+
+    ret = dict_set_bin(local->params, conf->xattr_name, parent_disk_layout,
+                       4 * 4);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "%s (%s/%s) (path: %s): "
+               "setting parent-layout in params dictionary failed. ",
+               gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_disk_layout = NULL;
+    local->hashed_subvol = hashed_subvol;
+
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, loc, hashed_subvol, &local->current->ns,
+                                dht_call_mkdir_stub);
+    if (ret < 0)
+        goto err;
+
+    return 0;
+err:
 
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "hashed subvolume not found", gf_fop_list[stub->fop],
-                        pgfid, loc->name, loc->path);
-                goto err;
-        }
+    if (parent_disk_layout != NULL)
+        GF_FREE(parent_disk_layout);
 
-        parent_layout = dht_layout_get (this, loc->parent);
+    if (parent_layout != NULL)
+        dht_layout_unref(this, parent_layout);
 
-        ret = dht_disk_layout_extract_for_subvol (this, parent_layout,
-                                                  hashed_subvol,
-                                                  &parent_disk_layout);
-        if (ret == -1) {
-                local->op_errno = EINVAL;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "extracting in-memory layout of parent failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        memcpy ((void *)local->parent_disk_layout, (void *)parent_disk_layout,
-                sizeof (local->parent_disk_layout));
-
-        dht_layout_unref (this, parent_layout);
-        parent_layout = NULL;
+    return -1;
+}
 
-        ret = dict_set_str (local->params, GF_PREOP_PARENT_KEY,
-                            conf->xattr_name);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "setting %s key in params dictionary failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path,
-                        GF_PREOP_PARENT_KEY);
-                goto err;
-        }
+int
+dht_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          dev_t rdev, mode_t umask, dict_t *params)
+{
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    int i = 0;
+    int ret = 0;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
 
-        ret = dict_set_bin (local->params, conf->xattr_name, parent_disk_layout,
-                            4 * 4);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "%s (%s/%s) (path: %s): "
-                        "setting parent-layout in params dictionary failed. ",
-                        gf_fop_list[stub->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        parent_disk_layout = NULL;
-        local->hashed_subvol = hashed_subvol;
+    conf = this->private;
 
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, loc, hashed_subvol,
-                                     &local->current->ns, dht_call_mkdir_stub);
-        if (ret < 0)
-                goto err;
+    dht_get_du_info(frame, this, loc);
 
-        return 0;
-err:
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKNOD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (parent_disk_layout != NULL)
-                GF_FREE (parent_disk_layout);
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = EIO;
+        goto err;
+    }
 
-        if (parent_layout != NULL)
-                dht_layout_unref (this, parent_layout);
+    /* Post remove-brick, the client layout may not be in sync with
+     * disk layout because of lack of lookup. Hence,a mknod call
+     * may fall on the decommissioned brick.  Hence, if the
+     * hashed_subvol is part of decommissioned bricks  list, do a
+     * lookup on parent dir. If a fix-layout is already done by the
+     * remove-brick process, the parent directory layout will be in
+     * sync with that of the disk. If fix-layout is still ending
+     * on the parent directory, we can let the file get created on
+     * the decommissioned brick which will be eventually migrated to
+     * non-decommissioned brick based on the new layout.
+     */
 
-        return -1;
-}
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == subvol) {
+                gf_msg_debug(this->name, 0,
+                             "hashed subvol:%s is "
+                             "part of decommission brick list for "
+                             "file: %s",
+                             subvol->name, loc->path);
+
+                /* dht_refresh_layout needs directory info in
+                 * local->loc. Hence, storing the parent_loc in
+                 * local->loc and storing the create context in
+                 * local->loc2. We will restore this information
+                 * in dht_creation do */
+
+                ret = loc_copy(&local->loc2, &local->loc);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                           "loc_copy failed %s", loc->path);
 
-int
-dht_mknod (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, mode_t mode, dev_t rdev, mode_t umask, dict_t *params)
-{
-        xlator_t       *subvol     = NULL;
-        int             op_errno   = -1;
-        int             i          = 0;
-        int             ret        = 0;
-        dht_local_t    *local      = NULL;
-        dht_conf_t     *conf       = NULL;
+                    goto err;
+                }
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+                local->params = dict_ref(params);
+                local->rdev = rdev;
+                local->mode = mode;
+                local->umask = umask;
 
-        conf = this->private;
+                loc_wipe(&local->loc);
 
-        dht_get_du_info (frame, this, loc);
+                ret = dht_build_parent_loc(this, &local->loc, loc, &op_errno);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKNOD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_LOC_FAILED,
+                           "parent loc build failed");
+                    goto err;
+                }
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = EIO;
-                goto err;
-        }
+                ret = dht_mknod_lock(frame, subvol);
 
-        /* Post remove-brick, the client layout may not be in sync with
-        * disk layout because of lack of lookup. Hence,a mknod call
-        * may fall on the decommissioned brick.  Hence, if the
-        * hashed_subvol is part of decommissioned bricks  list, do a
-        * lookup on parent dir. If a fix-layout is already done by the
-        * remove-brick process, the parent directory layout will be in
-        * sync with that of the disk. If fix-layout is still ending
-        * on the parent directory, we can let the file get created on
-        * the decommissioned brick which will be eventually migrated to
-        * non-decommissioned brick based on the new layout.
-        */
+                if (ret < 0) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+                           "locking parent failed");
+                    goto err;
+                }
 
-        if (conf->decommission_subvols_cnt) {
-            for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i] &&
-                        conf->decommissioned_bricks[i] == subvol) {
-
-                        gf_msg_debug (this->name, 0, "hashed subvol:%s is "
-                                      "part of decommission brick list for "
-                                      "file: %s", subvol->name, loc->path);
-
-                        /* dht_refresh_layout needs directory info in
-                         * local->loc. Hence, storing the parent_loc in
-                         * local->loc and storing the create context in
-                         * local->loc2. We will restore this information
-                         * in dht_creation do */
-
-                        ret = loc_copy (&local->loc2, &local->loc);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "loc_copy failed %s", loc->path);
-
-                                goto err;
-                        }
-
-                        local->params = dict_ref (params);
-                        local->rdev = rdev;
-                        local->mode = mode;
-                        local->umask = umask;
-
-                        loc_wipe (&local->loc);
-
-                        ret = dht_build_parent_loc (this, &local->loc, loc,
-                                                                 &op_errno);
-
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_LOC_FAILED,
-                                        "parent loc build failed");
-                                goto err;
-                        }
-
-                        ret = dht_mknod_lock (frame, subvol);
-
-                        if (ret < 0) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INODE_LK_ERROR,
-                                        "locking parent failed");
-                                goto err;
-                        }
-
-                        goto done;
-               }
+                goto done;
             }
         }
+    }
 
-        dht_mknod_wind_to_avail_subvol (frame, this, subvol, loc, rdev, mode,
-                                        umask, params);
+    dht_mknod_wind_to_avail_subvol(frame, this, subvol, loc, rdev, mode, umask,
+                                   params);
 
 done:
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (mknod, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_symlink (call_frame_t *frame, xlator_t *this,
-             const char *linkname, loc_t *loc, mode_t umask, dict_t *params)
+dht_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
+            loc_t *loc, mode_t umask, dict_t *params)
 {
-        xlator_t    *subvol = NULL;
-        int          op_errno = -1;
-        dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SYMLINK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SYMLINK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = EIO;
-                goto err;
-        }
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = EIO;
+        goto err;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol, subvol,
-                           subvol->fops->symlink, linkname, loc, umask,
-                           params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                      subvol->fops->symlink, linkname, loc, umask, params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (link, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-            dict_t *xdata)
+dht_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata)
 {
-        xlator_t    *cached_subvol = NULL;
-        int          op_errno = -1;
-        dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_UNLINK);
-        if (!local) {
-                op_errno = ENOMEM;
+    local = dht_local_init(frame, loc, NULL, GF_FOP_UNLINK);
+    if (!local) {
+        op_errno = ENOMEM;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    cached_subvol = local->cached_subvol;
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        local->flags = xflag;
-        STACK_WIND_COOKIE (frame, dht_unlink_cbk, cached_subvol, cached_subvol,
-                           cached_subvol->fops->unlink, loc, xflag, xdata);
+    local->flags = xflag;
+    STACK_WIND_COOKIE(frame, dht_unlink_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->unlink, loc, xflag, xdata);
 
-        return 0;
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-
-        return 0;
-}
-
-int
-dht_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno,
-              inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-              struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           ret = -1;
-        gf_boolean_t  stbuf_merged = _gf_false;
-        xlator_t     *subvol = NULL;
-        call_frame_t *cleanup_frame = NULL;
-        dht_local_t  *cleanup_local = NULL;
-
-        local = frame->local;
-
-        if (op_ret == -1) {
-                /* Remove the linkto if exists */
-                if (local->linked) {
-                        cleanup_frame = create_frame (this, this->ctx->pool);
-                        if (cleanup_frame) {
-                                cleanup_local = dht_local_init (cleanup_frame,
-                                                                &local->loc2,
-                                                                NULL, 0);
-                                if (!cleanup_local || !local->link_subvol) {
-                                        DHT_STACK_DESTROY (cleanup_frame);
-                                        goto out;
-                                }
-                                cleanup_local->link_subvol = local->link_subvol;
-                                FRAME_SU_DO (cleanup_frame, dht_local_t);
-                                ret = synctask_new (this->ctx->env,
-                                                    dht_remove_stale_linkto,
-                                                    dht_remove_stale_linkto_cbk,
-                                                    cleanup_frame,
-                                                    cleanup_frame);
-                        }
-                }
-                /* No continuation on DHT inode missing errors, as we should
-                 * then have a good stbuf that states P2 happened. We would
-                 * get inode missing if, the file completed migrated between
-                 * the lookup and the link call */
-                goto out;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+
+    return 0;
+}
+
+int
+dht_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, inode_t *inode, struct iatt *stbuf,
+             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+{
+    dht_local_t *local = NULL;
+    int ret = -1;
+    gf_boolean_t stbuf_merged = _gf_false;
+    xlator_t *subvol = NULL;
+    call_frame_t *cleanup_frame = NULL;
+    dht_local_t *cleanup_local = NULL;
+
+    local = frame->local;
+
+    if (op_ret == -1) {
+        /* Remove the linkto if exists */
+        if (local->linked) {
+            cleanup_frame = create_frame(this, this->ctx->pool);
+            if (cleanup_frame) {
+                cleanup_local = dht_local_init(cleanup_frame, &local->loc2,
+                                               NULL, 0);
+                if (!cleanup_local || !local->link_subvol) {
+                    DHT_STACK_DESTROY(cleanup_frame);
+                    goto out;
+                }
+                cleanup_local->link_subvol = local->link_subvol;
+                FRAME_SU_DO(cleanup_frame, dht_local_t);
+                ret = synctask_new(this->ctx->env, dht_remove_stale_linkto,
+                                   dht_remove_stale_linkto_cbk, cleanup_frame,
+                                   cleanup_frame);
+            }
         }
-
-        /* Update parent on success, even if P1/2 checks are positive.
-         * The second call on success will further update the parent */
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
-
-        /* Update linkto attrs, if this is the first call and non-P2,
-         * if we detect P2 then we need to trust the attrs from the
-         * second call, not the first */
-        if (local->linked == _gf_true &&
-            ((local->call_cnt == 1 && !IS_DHT_MIGRATION_PHASE2 (stbuf))
-             || (local->call_cnt != 1 &&
-                 IS_DHT_MIGRATION_PHASE2 (&local->stbuf)))) {
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-                stbuf_merged = _gf_true;
-                dht_linkfile_attr_heal (frame, this);
-        }
-
-        /* No further P1/2 checks if we are in the second iteration of
-         * the call */
-        if (local->call_cnt != 1) {
-                goto out;
+        /* No continuation on DHT inode missing errors, as we should
+         * then have a good stbuf that states P2 happened. We would
+         * get inode missing if, the file completed migrated between
+         * the lookup and the link call */
+        goto out;
+    }
+
+    /* Update parent on success, even if P1/2 checks are positive.
+     * The second call on success will further update the parent */
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
+
+    /* Update linkto attrs, if this is the first call and non-P2,
+     * if we detect P2 then we need to trust the attrs from the
+     * second call, not the first */
+    if (local->linked == _gf_true &&
+        ((local->call_cnt == 1 && !IS_DHT_MIGRATION_PHASE2(stbuf)) ||
+         (local->call_cnt != 1 && IS_DHT_MIGRATION_PHASE2(&local->stbuf)))) {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        stbuf_merged = _gf_true;
+        dht_linkfile_attr_heal(frame, this);
+    }
+
+    /* No further P1/2 checks if we are in the second iteration of
+     * the call */
+    if (local->call_cnt != 1) {
+        goto out;
+    } else {
+        /* Preserve the return values, in case the migration decides
+         * to recreate the link on the same subvol that the current
+         * hased for the link was created on. */
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+        if (!stbuf_merged) {
+            dht_iatt_merge(this, &local->stbuf, stbuf);
+            stbuf_merged = _gf_true;
+        }
+
+        local->inode = inode_ref(inode);
+    }
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    local->rebalance.target_op_fn = dht_link2;
+    dht_set_local_rebalance(this, local, stbuf, preparent, postparent, xdata);
+
+    /* Check if the rebalance phase2 is true */
+    if (IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        ret = dht_inode_ctx_get_mig_info(this, local->loc.inode, NULL, &subvol);
+        if (!subvol) {
+            /* Phase 2 of migration */
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
+                return 0;
         } else {
-                /* Preserve the return values, in case the migration decides
-                 * to recreate the link on the same subvol that the current
-                 * hased for the link was created on. */
-                dht_iatt_merge (this, &local->preparent, preparent);
-                dht_iatt_merge (this, &local->postparent, postparent);
-                if (!stbuf_merged) {
-                        dht_iatt_merge (this, &local->stbuf, stbuf);
-                        stbuf_merged = _gf_true;
-                }
-
-                local->inode = inode_ref (inode);
-        }
-
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
-        local->rebalance.target_op_fn = dht_link2;
-        dht_set_local_rebalance (this, local, stbuf, preparent,
-                                 postparent, xdata);
-
-        /* Check if the rebalance phase2 is true */
-        if (IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-                ret = dht_inode_ctx_get_mig_info (this, local->loc.inode, NULL,
-                                                  &subvol);
-                if (!subvol) {
-                        /* Phase 2 of migration */
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        dht_link2 (this, subvol, frame, 0);
-                        return 0;
-                }
-        }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (stbuf)) {
-                ret = dht_inode_ctx_get_mig_info (this, local->loc.inode, NULL,
-                                                  &subvol);
-                if (subvol) {
-                        dht_link2 (this, subvol, frame, 0);
-                        return 0;
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+            dht_link2(this, subvol, frame, 0);
+            return 0;
+        }
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(stbuf)) {
+        ret = dht_inode_ctx_get_mig_info(this, local->loc.inode, NULL, &subvol);
+        if (subvol) {
+            dht_link2(this, subvol, frame, 0);
+            return 0;
+        }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno, inode, stbuf,
-                          preparent, postparent, NULL);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_link2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_link2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local  = NULL;
-        int          op_errno = EINVAL;
-
-        local = frame->local;
-        if (!local)
-                goto err;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        op_errno = local->op_errno;
+    local = frame->local;
+    if (!local)
+        goto err;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                dht_set_fixed_dir_stat (&local->preparent);
-                dht_set_fixed_dir_stat (&local->postparent);
+    op_errno = local->op_errno;
 
-                DHT_STACK_UNWIND (link, frame, local->op_ret, op_errno,
-                                  local->inode,
-                                  &local->stbuf, &local->preparent,
-                                  &local->postparent, NULL);
-                return 0;
-        }
-
-        if (subvol == NULL) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        /* Second call to create link file could result in EEXIST as the
-         * first call created the linkto in the currently
-         * migrating subvol, which could be the new hashed subvol */
-        if (local->link_subvol == subvol) {
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
-                dht_set_fixed_dir_stat (&local->preparent);
-                dht_set_fixed_dir_stat (&local->postparent);
-                DHT_STACK_UNWIND (link, frame, 0, 0, local->inode,
-                                  &local->stbuf, &local->preparent,
-                                  &local->postparent, NULL);
-
-                return 0;
-        }
-
-        local->call_cnt = 2;
-
-        STACK_WIND (frame, dht_link_cbk, subvol, subvol->fops->link,
-                    &local->loc, &local->loc2, local->xattr_req);
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        dht_set_fixed_dir_stat(&local->preparent);
+        dht_set_fixed_dir_stat(&local->postparent);
 
+        DHT_STACK_UNWIND(link, frame, local->op_ret, op_errno, local->inode,
+                         &local->stbuf, &local->preparent, &local->postparent,
+                         NULL);
         return 0;
-err:
-        DHT_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+    }
 
-        return 0;
-}
+    if (subvol == NULL) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-int
-dht_link_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       inode_t *inode, struct iatt *stbuf,
-                       struct iatt *preparent, struct iatt *postparent,
-                       dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        xlator_t     *srcvol = NULL;
+    /* Second call to create link file could result in EEXIST as the
+     * first call created the linkto in the currently
+     * migrating subvol, which could be the new hashed subvol */
+    if (local->link_subvol == subvol) {
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
+        dht_set_fixed_dir_stat(&local->preparent);
+        dht_set_fixed_dir_stat(&local->postparent);
+        DHT_STACK_UNWIND(link, frame, 0, 0, local->inode, &local->stbuf,
+                         &local->preparent, &local->postparent, NULL);
 
-        if (op_ret == -1)
-                goto err;
+        return 0;
+    }
 
-        local = frame->local;
-        srcvol = local->linkfile.srcvol;
+    local->call_cnt = 2;
 
-        STACK_WIND (frame, dht_link_cbk, srcvol, srcvol->fops->link,
-                    &local->loc, &local->loc2, local->xattr_req);
-
-        return 0;
+    STACK_WIND(frame, dht_link_cbk, subvol, subvol->fops->link, &local->loc,
+               &local->loc2, local->xattr_req);
 
+    return 0;
 err:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno, inode, stbuf, preparent,
-                          postparent, xdata);
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_link (call_frame_t *frame, xlator_t *this,
-          loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+dht_link_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *stbuf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t    *cached_subvol = NULL;
-        xlator_t    *hashed_subvol = NULL;
-        int          op_errno = -1;
-        int          ret = -1;
-        dht_local_t *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (newloc, err);
+    dht_local_t *local = NULL;
+    xlator_t *srcvol = NULL;
 
-        local = dht_local_init (frame, oldloc, NULL, GF_FOP_LINK);
-        if (!local) {
-                op_errno = ENOMEM;
+    if (op_ret == -1)
+        goto err;
 
-                goto err;
-        }
-        local->call_cnt = 1;
+    local = frame->local;
+    srcvol = local->linkfile.srcvol;
 
-        cached_subvol = local->cached_subvol;
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", oldloc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
+    STACK_WIND(frame, dht_link_cbk, srcvol, srcvol->fops->link, &local->loc,
+               &local->loc2, local->xattr_req);
 
-        hashed_subvol = dht_subvol_get_hashed (this, newloc);
-        if (!hashed_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              newloc->path);
-                op_errno = EIO;
-                goto err;
-        }
+    return 0;
 
-        ret = loc_copy (&local->loc2, newloc);
-        if (ret == -1) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (hashed_subvol != cached_subvol) {
-                gf_uuid_copy (local->gfid, oldloc->inode->gfid);
-                dht_linkfile_create (frame, dht_link_linkfile_cbk, this,
-                                     cached_subvol, hashed_subvol, newloc);
-        } else {
-                STACK_WIND (frame, dht_link_cbk,
-                            cached_subvol, cached_subvol->fops->link,
-                            oldloc, newloc, xdata);
-        }
-
-        return 0;
+err:
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, xdata);
+
+    return 0;
+}
+
+int
+dht_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+         dict_t *xdata)
+{
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    int op_errno = -1;
+    int ret = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    local = dht_local_init(frame, oldloc, NULL, GF_FOP_LINK);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+    local->call_cnt = 1;
+
+    cached_subvol = local->cached_subvol;
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     oldloc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, newloc);
+    if (!hashed_subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     newloc->path);
+        op_errno = EIO;
+        goto err;
+    }
+
+    ret = loc_copy(&local->loc2, newloc);
+    if (ret == -1) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (hashed_subvol != cached_subvol) {
+        gf_uuid_copy(local->gfid, oldloc->inode->gfid);
+        dht_linkfile_create(frame, dht_link_linkfile_cbk, this, cached_subvol,
+                            hashed_subvol, newloc);
+    } else {
+        STACK_WIND(frame, dht_link_cbk, cached_subvol,
+                   cached_subvol->fops->link, oldloc, newloc, xdata);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno,
-                fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+dht_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
+               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        dht_local_t  *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        if (op_ret == -1)
-                goto out;
+    if (op_ret == -1)
+        goto out;
 
-        prev = cookie;
+    prev = cookie;
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
 
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
-        ret = dht_fd_ctx_set (this, fd, prev);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0, "Possible fd leak. "
-                              "Could not set fd ctx for subvol %s",
-                              prev->name);
-        }
+    ret = dht_fd_ctx_set(this, fd, prev);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0,
+                     "Possible fd leak. "
+                     "Could not set fd ctx for subvol %s",
+                     prev->name);
+    }
 
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0, "could not set preset layout for subvol %s",
+                     prev->name);
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0,
-                              "could not set preset layout for subvol %s",
-                              prev->name);
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (local->linked == _gf_true) {
-                local->stbuf = *stbuf;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    if (local->linked == _gf_true) {
+        local->stbuf = *stbuf;
+        dht_linkfile_attr_heal(frame, this);
+    }
 out:
 
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        dht_set_fixed_dir_stat (preparent);
-        dht_set_fixed_dir_stat (postparent);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    dht_set_fixed_dir_stat(preparent);
+    dht_set_fixed_dir_stat(postparent);
 
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                /* store op_errno for failure case*/
-                local->op_errno = op_errno;
-                local->refresh_layout_unlock (frame, this, op_ret, 1);
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        /* store op_errno for failure case*/
+        local->op_errno = op_errno;
+        local->refresh_layout_unlock(frame, this, op_ret, 1);
 
-                if (op_ret == 0) {
-                        DHT_STACK_UNWIND (create, frame, op_ret, op_errno, fd,
-                                          inode, stbuf, preparent, postparent,
-                                          xdata);
-                }
-        } else {
-                DHT_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode,
-                                  stbuf, preparent, postparent, xdata);
+        if (op_ret == 0) {
+            DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
+                             preparent, postparent, xdata);
         }
-        return 0;
+    } else {
+        DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
+                         preparent, postparent, xdata);
+    }
+    return 0;
 }
 
 int
-dht_create_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this,
-                                int32_t op_ret, int32_t op_errno,
-                                inode_t *inode, struct iatt *stbuf,
-                                struct iatt *preparent, struct iatt *postparent,
-                                dict_t *xdata)
+dht_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                               xlator_t *this, int32_t op_ret, int32_t op_errno,
+                               inode_t *inode, struct iatt *stbuf,
+                               struct iatt *preparent, struct iatt *postparent,
+                               dict_t *xdata)
 {
-        dht_local_t     *local             = NULL;
-        xlator_t        *cached_subvol     = NULL;
-        dht_conf_t      *conf              = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
 
-        local = frame->local;
-        if (!local) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        conf = this->private;
-        if (!conf) {
-                local->op_errno = EINVAL;
-                op_errno = EINVAL;
-                goto err;
-        }
+    conf = this->private;
+    if (!conf) {
+        local->op_errno = EINVAL;
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        cached_subvol = local->cached_subvol;
+    cached_subvol = local->cached_subvol;
 
-        if (local->params) {
-                dict_del (local->params, conf->link_xattr_name);
-                dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
+    if (local->params) {
+        dict_del(local->params, conf->link_xattr_name);
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, cached_subvol,
-                           cached_subvol, cached_subvol->fops->create,
-                           &local->loc, local->flags, local->mode,
-                           local->umask, local->fd, local->params);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->create, &local->loc, local->flags,
+                      local->mode, local->umask, local->fd, local->params);
 
-        return 0;
+    return 0;
 err:
-        if (local && local->lock[0].layout.parent_layout.locks) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        } else {
-                DHT_STACK_UNWIND (create, frame, -1,
-                                  op_errno, NULL, NULL, NULL,
-                                  NULL, NULL, NULL);
-        }
-        return 0;
+    if (local && local->lock[0].layout.parent_layout.locks) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    } else {
+        DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                         NULL, NULL);
+    }
+    return 0;
 }
 
 int
-dht_create_wind_to_avail_subvol (call_frame_t *frame, xlator_t *this,
-                                 xlator_t *subvol, loc_t *loc, int32_t flags,
-                                 mode_t mode, mode_t umask, fd_t *fd,
-                                 dict_t *params)
+dht_create_wind_to_avail_subvol(call_frame_t *frame, xlator_t *this,
+                                xlator_t *subvol, loc_t *loc, int32_t flags,
+                                mode_t mode, mode_t umask, fd_t *fd,
+                                dict_t *params)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *avail_subvol   = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *avail_subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!dht_is_subvol_filled (this, subvol)) {
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path,
-                              subvol->name);
+    if (!dht_is_subvol_filled(this, subvol)) {
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create,
-                                   loc, flags, mode, umask, fd, params);
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, loc, flags, mode, umask, fd,
+                          params);
 
-        } else {
-                avail_subvol = dht_free_disk_available_subvol (this, subvol, local);
+    } else {
+        avail_subvol = dht_free_disk_available_subvol(this, subvol, local);
 
-                if (avail_subvol != subvol) {
-                        local->params = dict_ref (params);
-                        local->flags = flags;
-                        local->mode = mode;
-                        local->umask = umask;
-                        local->cached_subvol = avail_subvol;
-                        local->hashed_subvol = subvol;
+        if (avail_subvol != subvol) {
+            local->params = dict_ref(params);
+            local->flags = flags;
+            local->mode = mode;
+            local->umask = umask;
+            local->cached_subvol = avail_subvol;
+            local->hashed_subvol = subvol;
 
-                        gf_msg_debug (this->name, 0,
-                                      "creating %s on %s (link at %s)", loc->path,
-                                      avail_subvol->name, subvol->name);
+            gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)",
+                         loc->path, avail_subvol->name, subvol->name);
 
-                        dht_linkfile_create (frame, dht_create_linkfile_create_cbk,
-                                             this, avail_subvol, subvol, loc);
+            dht_linkfile_create(frame, dht_create_linkfile_create_cbk, this,
+                                avail_subvol, subvol, loc);
 
-                        goto out;
-                }
+            goto out;
+        }
 
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path, subvol->name);
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     subvol->name);
 
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create,
-                                   loc, flags, mode, umask, fd, params);
-        }
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, loc, flags, mode, umask, fd,
+                          params);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_build_parent_loc (xlator_t *this, loc_t *parent, loc_t *child,
-                      int32_t *op_errno)
+dht_build_parent_loc(xlator_t *this, loc_t *parent, loc_t *child,
+                     int32_t *op_errno)
 {
-        inode_table_t   *table = NULL;
-        int     ret = -1;
+    inode_table_t *table = NULL;
+    int ret = -1;
 
-        if (!parent || !child) {
-                if (op_errno)
-                        *op_errno = EINVAL;
-                goto out;
-        }
+    if (!parent || !child) {
+        if (op_errno)
+            *op_errno = EINVAL;
+        goto out;
+    }
 
-        if (child->parent) {
-                parent->inode = inode_ref (child->parent);
-                if (!parent->inode) {
-                        if (op_errno)
-                                *op_errno = EINVAL;
-                        goto out;
-                }
+    if (child->parent) {
+        parent->inode = inode_ref(child->parent);
+        if (!parent->inode) {
+            if (op_errno)
+                *op_errno = EINVAL;
+            goto out;
+        }
 
-                gf_uuid_copy (parent->gfid, child->pargfid);
+        gf_uuid_copy(parent->gfid, child->pargfid);
 
-                ret = 0;
+        ret = 0;
 
-                goto out;
-        } else {
-                if (gf_uuid_is_null (child->pargfid)) {
-                        if (op_errno)
-                                *op_errno = EINVAL;
-                        goto out;
-                }
+        goto out;
+    } else {
+        if (gf_uuid_is_null(child->pargfid)) {
+            if (op_errno)
+                *op_errno = EINVAL;
+            goto out;
+        }
 
-                table = this->itable;
+        table = this->itable;
 
-                if (!table) {
-                        if (op_errno) {
-                                *op_errno = EINVAL;
-                                goto out;
-                        }
-                }
+        if (!table) {
+            if (op_errno) {
+                *op_errno = EINVAL;
+                goto out;
+            }
+        }
 
-                parent->inode = inode_find (table, child->pargfid);
+        parent->inode = inode_find(table, child->pargfid);
 
-                if (!parent->inode) {
-                         if (op_errno) {
-                                *op_errno = EINVAL;
-                                goto out;
-                        }
-                }
+        if (!parent->inode) {
+            if (op_errno) {
+                *op_errno = EINVAL;
+                goto out;
+            }
+        }
 
-                gf_uuid_copy (parent->gfid, child->pargfid);
+        gf_uuid_copy(parent->gfid, child->pargfid);
 
-                ret = 0;
-        }
+        ret = 0;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-dht_create_do (call_frame_t *frame)
+dht_create_do(call_frame_t *frame)
 {
-        dht_local_t     *local          = NULL;
-        dht_layout_t    *refreshed      = NULL;
-        xlator_t        *subvol         = NULL;
-        xlator_t        *this           = NULL;
-        dht_conf_t      *conf           = NULL;
-        dht_methods_t   *methods        = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *refreshed = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        this = THIS;
+    this = THIS;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO (this->name, conf, err);
+    GF_VALIDATE_OR_GOTO(this->name, conf, err);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        /* We don't need parent_loc anymore */
-        loc_wipe (&local->loc);
+    /* We don't need parent_loc anymore */
+    loc_wipe(&local->loc);
 
-        loc_copy (&local->loc, &local->loc2);
+    loc_copy(&local->loc, &local->loc2);
 
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc2);
 
-        refreshed = local->selfheal.refreshed_layout;
+    refreshed = local->selfheal.refreshed_layout;
 
-        subvol = methods->layout_search (this, refreshed, local->loc.name);
+    subvol = methods->layout_search(this, refreshed, local->loc.name);
 
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED, "no subvolume in "
-                        "layout for path=%s", local->loc.path);
-                local->op_errno = ENOENT;
-                goto err;
-        }
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in "
+               "layout for path=%s",
+               local->loc.path);
+        local->op_errno = ENOENT;
+        goto err;
+    }
 
-        dht_create_wind_to_avail_subvol (frame, this, subvol, &local->loc,
-                                         local->flags, local->mode,
-                                         local->umask, local->fd, local->params);
-        return 0;
+    dht_create_wind_to_avail_subvol(frame, this, subvol, &local->loc,
+                                    local->flags, local->mode, local->umask,
+                                    local->fd, local->params);
+    return 0;
 err:
-        local->refresh_layout_unlock (frame, this, -1, 1);
+    local->refresh_layout_unlock(frame, this, -1, 1);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-dht_create_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_create_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
-dht_create_finish (call_frame_t *frame, xlator_t *this, int op_ret,
-                   int invoke_cbk)
+dht_create_finish(call_frame_t *frame, xlator_t *this, int op_ret,
+                  int invoke_cbk)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
-
-        local = frame->local;
-        lock_count = dht_lock_count (local->lock[0].layout.parent_layout.locks,
-                                     local->lock[0].layout.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
-
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
-
-        lock_local->lock[0].layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
-        lock_local->lock[0].layout.parent_layout.lk_count = local->lock[0].layout.parent_layout.lk_count;
-
-        local->lock[0].layout.parent_layout.locks = NULL;
-	local->lock[0].layout.parent_layout.lk_count = 0;
-
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].layout.parent_layout.locks,
-                            lock_local->lock[0].layout.parent_layout.lk_count,
-                            dht_create_unlock_cbk);
-        lock_frame = NULL;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
+
+    local = frame->local;
+    lock_count = dht_lock_count(local->lock[0].layout.parent_layout.locks,
+                                local->lock[0].layout.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
+
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
+
+    lock_local->lock[0]
+        .layout.parent_layout.locks = local->lock[0].layout.parent_layout.locks;
+    lock_local->lock[0].layout.parent_layout.lk_count =
+        local->lock[0].layout.parent_layout.lk_count;
+
+    local->lock[0].layout.parent_layout.locks = NULL;
+    local->lock[0].layout.parent_layout.lk_count = 0;
+
+    dht_unlock_inodelk(lock_frame,
+                       lock_local->lock[0].layout.parent_layout.locks,
+                       lock_local->lock[0].layout.parent_layout.lk_count,
+                       dht_create_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
-
-        if (op_ret == 0)
-                return 0;
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        DHT_STACK_UNWIND (create, frame, op_ret, local->op_errno, NULL, NULL,
-                          NULL, NULL, NULL, NULL);
+    if (op_ret == 0)
         return 0;
+
+    DHT_STACK_UNWIND(create, frame, op_ret, local->op_errno, NULL, NULL, NULL,
+                     NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-dht_create_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_create_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                gf_msg ("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
-                        "Create lock failed for file: %s", local->loc2.name);
+    if (op_ret < 0) {
+        gf_msg("DHT", GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+               "Create lock failed for file: %s", local->loc2.name);
 
-                local->op_errno = op_errno;
+        local->op_errno = op_errno;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_create_finish;
+    local->refresh_layout_unlock = dht_create_finish;
 
-        local->refresh_layout_done = dht_create_do;
+    local->refresh_layout_done = dht_create_do;
 
-        dht_refresh_layout (frame);
+    dht_refresh_layout(frame);
 
-        return 0;
+    return 0;
 err:
-        dht_create_finish (frame, this, -1, 0);
-        return 0;
+    dht_create_finish(frame, this, -1, 0);
+    return 0;
 }
 
 int32_t
-dht_create_lock (call_frame_t *frame, xlator_t *subvol)
+dht_create_lock(call_frame_t *frame, xlator_t *subvol)
 {
-        dht_local_t     *local          = NULL;
-        int              count  = 1,    ret = -1;
-        dht_lock_t     **lk_array       = NULL;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-        local = frame->local;
+    local = frame->local;
 
-        lk_array = GF_CALLOC (count, sizeof (*lk_array), gf_common_mt_pointer);
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
 
-        if (lk_array == NULL)
-                goto err;
+    if (lk_array == NULL)
+        goto err;
 
-        lk_array[0] = dht_lock_new (frame->this, subvol, &local->loc, F_RDLCK,
-                                    DHT_LAYOUT_HEAL_DOMAIN, NULL,
-                                    IGNORE_ENOENT_ESTALE);
+    lk_array[0] = dht_lock_new(frame->this, subvol, &local->loc, F_RDLCK,
+                               DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                               IGNORE_ENOENT_ESTALE);
 
-        if (lk_array[0] == NULL)
-                goto err;
+    if (lk_array[0] == NULL)
+        goto err;
 
-        local->lock[0].layout.parent_layout.locks = lk_array;
-        local->lock[0].layout.parent_layout.lk_count = count;
+    local->lock[0].layout.parent_layout.locks = lk_array;
+    local->lock[0].layout.parent_layout.lk_count = count;
 
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    dht_create_lock_cbk);
+    ret = dht_blocking_inodelk(frame, lk_array, count, dht_create_lock_cbk);
 
-        if (ret < 0) {
-                local->lock[0].layout.parent_layout.locks = NULL;
-                local->lock[0].layout.parent_layout.lk_count = 0;
-                goto err;
-        }
+    if (ret < 0) {
+        local->lock[0].layout.parent_layout.locks = NULL;
+        local->lock[0].layout.parent_layout.lk_count = 0;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_create (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, int32_t flags, mode_t mode,
-            mode_t umask, fd_t *fd, dict_t *params)
+dht_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
 {
-        int             op_errno           = -1;
-        xlator_t       *subvol             = NULL;
-        xlator_t       *hashed_subvol      = NULL;
-        dht_local_t    *local              = NULL;
-        int             i                  = 0;
-        dht_conf_t     *conf               = NULL;
-        int             ret                = 0;
+    int op_errno = -1;
+    xlator_t *subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_local_t *local = NULL;
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        conf = this->private;
+    conf = this->private;
 
-        dht_get_du_info (frame, this, loc);
+    dht_get_du_info(frame, this, loc);
 
-        local = dht_local_init (frame, loc, fd, GF_FOP_CREATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (dht_filter_loc_subvol_key (this, loc, &local->loc,
-                                       &subvol)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO,
-                        "creating %s on %s (got create on %s)",
-                        local->loc.path, subvol->name, loc->path);
+    if (dht_filter_loc_subvol_key(this, loc, &local->loc, &subvol)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "creating %s on %s (got create on %s)", local->loc.path,
+               subvol->name, loc->path);
 
-                /* Since lookup-optimize is enabled by default, we need
-                 * to create the linkto file if required.
-                 * Note this does not check for decommisioned bricks
-                 * and min-free-disk limits as this is a debugging tool
-                 * and not expected to be used in production.
-                 */
-                hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
-
-                if (hashed_subvol && (hashed_subvol != subvol)) {
-                        /* Create the linkto file and then the data file */
-                        local->params = dict_ref (params);
-                        local->flags = flags;
-                        local->mode = mode;
-                        local->umask = umask;
-                        local->cached_subvol = subvol;
-                        local->hashed_subvol = hashed_subvol;
-
-                        dht_linkfile_create (frame,
-                                             dht_create_linkfile_create_cbk,
-                                             this, subvol, hashed_subvol,
-                                             &local->loc);
-                        goto done;
+        /* Since lookup-optimize is enabled by default, we need
+         * to create the linkto file if required.
+         * Note this does not check for decommisioned bricks
+         * and min-free-disk limits as this is a debugging tool
+         * and not expected to be used in production.
+         */
+        hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
+
+        if (hashed_subvol && (hashed_subvol != subvol)) {
+            /* Create the linkto file and then the data file */
+            local->params = dict_ref(params);
+            local->flags = flags;
+            local->mode = mode;
+            local->umask = umask;
+            local->cached_subvol = subvol;
+            local->hashed_subvol = hashed_subvol;
+
+            dht_linkfile_create(frame, dht_create_linkfile_create_cbk, this,
+                                subvol, hashed_subvol, &local->loc);
+            goto done;
+        }
+        /* We either don't have a hashed subvol or the hashed subvol is
+         * the same as the one specified. No need to create the linkto
+         * file as we expect a lookup everywhere if there are problems
+         * with the parent layout
+         */
+        STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                          subvol->fops->create, &local->loc, flags, mode, umask,
+                          fd, params);
+        goto done;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume in layout for path=%s", loc->path);
+
+        op_errno = EIO;
+        goto err;
+    }
+
+    /* Post remove-brick, the client layout may not be in sync with
+     * disk layout because of lack of lookup. Hence,a create call
+     * may fall on the decommissioned brick.  Hence, if the
+     * hashed_subvol is part of decommissioned bricks  list, do a
+     * lookup on parent dir. If a fix-layout is already done by the
+     * remove-brick process, the parent directory layout will be in
+     * sync with that of the disk. If fix-layout is still ending
+     * on the parent directory, we can let the file get created on
+     * the decommissioned brick which will be eventually migrated to
+     * non-decommissioned brick based on the new layout.
+     */
+
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == subvol) {
+                gf_msg_debug(this->name, 0,
+                             "hashed subvol:%s is "
+                             "part of decommission brick list for "
+                             "file: %s",
+                             subvol->name, loc->path);
+
+                /* dht_refresh_layout needs directory info in
+                 * local->loc. Hence, storing the parent_loc in
+                 * local->loc and storing the create context in
+                 * local->loc2. We will restore this information
+                 * in dht_creation do */
+
+                ret = loc_copy(&local->loc2, &local->loc);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                           "loc_copy failed %s", loc->path);
+
+                    goto err;
                 }
-                /* We either don't have a hashed subvol or the hashed subvol is
-                 * the same as the one specified. No need to create the linkto
-                 * file as we expect a lookup everywhere if there are problems
-                 * with the parent layout
-                 */
-                STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                                   subvol, subvol->fops->create, &local->loc,
-                                   flags, mode, umask, fd, params);
-                goto done;
-        }
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "no subvolume in layout for path=%s",
-                        loc->path);
+                local->params = dict_ref(params);
+                local->flags = flags;
+                local->mode = mode;
+                local->umask = umask;
 
-                op_errno = EIO;
-                goto err;
-        }
+                loc_wipe(&local->loc);
 
-       /* Post remove-brick, the client layout may not be in sync with
-        * disk layout because of lack of lookup. Hence,a create call
-        * may fall on the decommissioned brick.  Hence, if the
-        * hashed_subvol is part of decommissioned bricks  list, do a
-        * lookup on parent dir. If a fix-layout is already done by the
-        * remove-brick process, the parent directory layout will be in
-        * sync with that of the disk. If fix-layout is still ending
-        * on the parent directory, we can let the file get created on
-        * the decommissioned brick which will be eventually migrated to
-        * non-decommissioned brick based on the new layout.
-        */
+                ret = dht_build_parent_loc(this, &local->loc, loc, &op_errno);
 
-        if (conf->decommission_subvols_cnt) {
-            for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i] &&
-                        conf->decommissioned_bricks[i] == subvol) {
-
-                        gf_msg_debug (this->name, 0, "hashed subvol:%s is "
-                                      "part of decommission brick list for "
-                                      "file: %s", subvol->name, loc->path);
-
-                        /* dht_refresh_layout needs directory info in
-                         * local->loc. Hence, storing the parent_loc in
-                         * local->loc and storing the create context in
-                         * local->loc2. We will restore this information
-                         * in dht_creation do */
-
-                        ret = loc_copy (&local->loc2, &local->loc);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY,
-                                        "loc_copy failed %s", loc->path);
-
-                                goto err;
-                        }
-
-                        local->params = dict_ref (params);
-                        local->flags = flags;
-                        local->mode = mode;
-                        local->umask = umask;
-
-                        loc_wipe (&local->loc);
-
-                        ret = dht_build_parent_loc (this, &local->loc, loc,
-                                                                 &op_errno);
-
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_LOC_FAILED,
-                                        "parent loc build failed");
-                                goto err;
-                        }
-
-                        ret = dht_create_lock (frame, subvol);
-
-                        if (ret < 0) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INODE_LK_ERROR,
-                                        "locking parent failed");
-                                goto err;
-                        }
-
-                        goto done;
-               }
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_LOC_FAILED,
+                           "parent loc build failed");
+                    goto err;
+                }
+
+                ret = dht_create_lock(frame, subvol);
+
+                if (ret < 0) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INODE_LK_ERROR,
+                           "locking parent failed");
+                    goto err;
+                }
+
+                goto done;
             }
         }
+    }
 
-
-        dht_create_wind_to_avail_subvol (frame, this, subvol, loc, flags, mode,
-                                         umask, fd, params);
+    dht_create_wind_to_avail_subvol(frame, this, subvol, loc, flags, mode,
+                                    umask, fd, params);
 done:
-        return 0;
+    return 0;
 
 err:
 
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_mkdir_selfheal_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_mkdir_selfheal_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
 
-        local = frame->local;
-        layout = local->selfheal.layout;
+    local = frame->local;
+    layout = local->selfheal.layout;
 
-        FRAME_SU_UNDO (frame, dht_local_t);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    FRAME_SU_UNDO(frame, dht_local_t);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        if (op_ret == 0) {
-                dht_layout_set (this, local->inode, layout);
+    if (op_ret == 0) {
+        dht_layout_set(this, local->inode, layout);
 
-                dht_inode_ctx_time_update (local->inode, this,
-                                           &local->stbuf, 1);
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->preparent, 0);
+        dht_inode_ctx_time_update(local->inode, this, &local->stbuf, 1);
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->preparent, 0);
 
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
+    }
 
-        DHT_STACK_UNWIND (mkdir, frame, op_ret, op_errno,
-                          local->inode, &local->stbuf, &local->preparent,
-                          &local->postparent, NULL);
+    DHT_STACK_UNWIND(mkdir, frame, op_ret, op_errno, local->inode,
+                     &local->stbuf, &local->preparent, &local->postparent,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf,
-               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+dht_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, inode_t *inode, struct iatt *stbuf,
+              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        int           ret = -1;
-        gf_boolean_t subvol_filled = _gf_false;
-        gf_boolean_t dir_exists = _gf_false;
-        xlator_t     *prev = NULL;
-        dht_layout_t *layout = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-        layout = local->layout;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int ret = -1;
+    gf_boolean_t subvol_filled = _gf_false;
+    gf_boolean_t dir_exists = _gf_false;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
 
-        subvol_filled = dht_is_subvol_filled (this, prev);
+    local = frame->local;
+    prev = cookie;
+    layout = local->layout;
 
-        LOCK (&frame->lock);
-        {
-                if (subvol_filled && (op_ret != -1)) {
-                        ret = dht_layout_merge (this, layout, prev,
-                                                -1, ENOSPC, NULL);
-                } else {
-                        if (op_ret == -1 && op_errno == EEXIST) {
-                                /* Very likely just a race between mkdir and
-                                   self-heal (from lookup of a concurrent mkdir
-                                   attempt).
-                                   Ignore error for now. layout setting will
-                                   anyways fail if this was a different (old)
-                                   pre-existing different directory.
-                                */
-                                op_ret = 0;
-                                dir_exists = _gf_true;
-                        }
-                        ret = dht_layout_merge (this, layout, prev,
-                                                op_ret, op_errno, NULL);
-                }
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LAYOUT_MERGE_FAILED,
-                                "%s: failed to merge layouts for subvol %s",
-                                local->loc.path, prev->name);
-
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
+    subvol_filled = dht_is_subvol_filled(this, prev);
 
-                if (dir_exists)
-                        goto unlock;
+    LOCK(&frame->lock);
+    {
+        if (subvol_filled && (op_ret != -1)) {
+            ret = dht_layout_merge(this, layout, prev, -1, ENOSPC, NULL);
+        } else {
+            if (op_ret == -1 && op_errno == EEXIST) {
+                /* Very likely just a race between mkdir and
+                   self-heal (from lookup of a concurrent mkdir
+                   attempt).
+                   Ignore error for now. layout setting will
+                   anyways fail if this was a different (old)
+                   pre-existing different directory.
+                */
+                op_ret = 0;
+                dir_exists = _gf_true;
+            }
+            ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, NULL);
+        }
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+                   "%s: failed to merge layouts for subvol %s", local->loc.path,
+                   prev->name);
 
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-                dht_iatt_merge (this, &local->preparent, preparent);
-                dht_iatt_merge (this, &local->postparent, postparent);
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
+
+        if (dir_exists)
+            goto unlock;
+
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                /*Unlock entrylk and inodelk once mkdir is done on all subvols*/
-                dht_unlock_namespace (frame, &local->lock[0]);
-                FRAME_SU_DO (frame, dht_local_t);
-                dht_selfheal_new_directory (frame, dht_mkdir_selfheal_cbk,
-                                            layout);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        /*Unlock entrylk and inodelk once mkdir is done on all subvols*/
+        dht_unlock_namespace(frame, &local->lock[0]);
+        FRAME_SU_DO(frame, dht_local_t);
+        dht_selfheal_new_directory(frame, dht_mkdir_selfheal_cbk, layout);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir_hashed_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int op_ret, int op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata);
+dht_mkdir_hashed_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata);
 
 int
-dht_mkdir_helper (call_frame_t *frame, xlator_t *this,
-                  loc_t *loc, mode_t mode, mode_t umask, dict_t *params)
+dht_mkdir_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                 mode_t umask, dict_t *params)
 {
-        dht_local_t  *local                   = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           op_errno                = -1, ret = -1;
-        xlator_t     *hashed_subvol           = NULL;
-        int32_t      *parent_disk_layout      = NULL;
-        dht_layout_t *parent_layout           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
-
-        conf = this->private;
-        local = frame->local;
-
-        if (local->op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): refreshing parent layout "
-                        "failed.", pgfid, loc->name,
-                        loc->path);
-
-                op_errno = local->op_errno;
-                goto err;
-        }
-
-        local->op_ret = -1;
-
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                gf_msg_debug (this->name, 0,
-                              "mkdir (%s/%s) (path: %s): hashed subvol not "
-                              "found", pgfid, loc->name, loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        local->hashed_subvol = hashed_subvol;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1, ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    int32_t *parent_disk_layout = NULL;
+    dht_layout_t *parent_layout = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
 
-        parent_layout = dht_layout_get (this, loc->parent);
-
-        ret = dht_disk_layout_extract_for_subvol (this, parent_layout,
-                                                  hashed_subvol,
-                                                  &parent_disk_layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, EIO,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "extracting in-memory layout of parent failed. ",
-                        pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        if (memcmp (local->parent_disk_layout, parent_disk_layout,
-                    sizeof (local->parent_disk_layout)) == 0) {
-                gf_msg (this->name, GF_LOG_WARNING, EIO,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): loop detected. "
-                        "parent layout didn't change even though "
-                        "previous attempt of mkdir failed because of "
-                        "in-memory layout not matching with that on disk.",
-                        pgfid, loc->name, loc->path);
-                op_errno = EIO;
-                goto err;
-        }
-
-        memcpy ((void *)local->parent_disk_layout, (void *)parent_disk_layout,
-                sizeof (local->parent_disk_layout));
-
-        dht_layout_unref (this, parent_layout);
-        parent_layout = NULL;
-
-        ret = dict_set_str (params, GF_PREOP_PARENT_KEY, conf->xattr_name);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "setting %s key in params dictionary failed. ",
-                        pgfid, loc->name, loc->path, GF_PREOP_PARENT_KEY);
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        ret = dict_set_bin (params, conf->xattr_name, parent_disk_layout,
-                            4 * 4);
-        if (ret < 0) {
-                local->op_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "setting parent-layout in params dictionary failed. "
-                        "mkdir (%s/%s) (path: %s)", pgfid, loc->name,
-                        loc->path);
-                goto err;
-        }
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
 
-        parent_disk_layout = NULL;
+    conf = this->private;
+    local = frame->local;
 
-        STACK_WIND_COOKIE (frame, dht_mkdir_hashed_cbk, hashed_subvol,
-                           hashed_subvol, hashed_subvol->fops->mkdir,
-                           loc, mode, umask, params);
+    if (local->op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): refreshing parent layout "
+               "failed.",
+               pgfid, loc->name, loc->path);
 
-        return 0;
+        op_errno = local->op_errno;
+        goto err;
+    }
+
+    local->op_ret = -1;
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        gf_msg_debug(this->name, 0,
+                     "mkdir (%s/%s) (path: %s): hashed subvol not "
+                     "found",
+                     pgfid, loc->name, loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    local->hashed_subvol = hashed_subvol;
+
+    parent_layout = dht_layout_get(this, loc->parent);
+
+    ret = dht_disk_layout_extract_for_subvol(this, parent_layout, hashed_subvol,
+                                             &parent_disk_layout);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, EIO, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "extracting in-memory layout of parent failed. ",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    if (memcmp(local->parent_disk_layout, parent_disk_layout,
+               sizeof(local->parent_disk_layout)) == 0) {
+        gf_msg(this->name, GF_LOG_WARNING, EIO, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): loop detected. "
+               "parent layout didn't change even though "
+               "previous attempt of mkdir failed because of "
+               "in-memory layout not matching with that on disk.",
+               pgfid, loc->name, loc->path);
+        op_errno = EIO;
+        goto err;
+    }
+
+    memcpy((void *)local->parent_disk_layout, (void *)parent_disk_layout,
+           sizeof(local->parent_disk_layout));
+
+    dht_layout_unref(this, parent_layout);
+    parent_layout = NULL;
+
+    ret = dict_set_str(params, GF_PREOP_PARENT_KEY, conf->xattr_name);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "setting %s key in params dictionary failed. ",
+               pgfid, loc->name, loc->path, GF_PREOP_PARENT_KEY);
+        goto err;
+    }
+
+    ret = dict_set_bin(params, conf->xattr_name, parent_disk_layout, 4 * 4);
+    if (ret < 0) {
+        local->op_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "setting parent-layout in params dictionary failed. "
+               "mkdir (%s/%s) (path: %s)",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    parent_disk_layout = NULL;
+
+    STACK_WIND_COOKIE(frame, dht_mkdir_hashed_cbk, hashed_subvol, hashed_subvol,
+                      hashed_subvol->fops->mkdir, loc, mode, umask, params);
+
+    return 0;
 
 err:
-        dht_unlock_namespace (frame, &local->lock[0]);
+    dht_unlock_namespace(frame, &local->lock[0]);
 
-        op_errno = local ? local->op_errno : op_errno;
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+    op_errno = local ? local->op_errno : op_errno;
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        if (parent_disk_layout != NULL)
-                GF_FREE (parent_disk_layout);
+    if (parent_disk_layout != NULL)
+        GF_FREE(parent_disk_layout);
 
-        if (parent_layout != NULL)
-                dht_layout_unref (this, parent_layout);
+    if (parent_layout != NULL)
+        dht_layout_unref(this, parent_layout);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir_hashed_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int op_ret, int op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+dht_mkdir_hashed_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local                   = NULL;
-        int           ret                     = -1;
-        xlator_t     *prev                    = NULL;
-        dht_layout_t *layout                  = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           i                       = 0;
-        xlator_t     *hashed_subvol           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        gf_boolean_t  parent_layout_changed   = _gf_false;
-        call_stub_t  *stub                    = NULL;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *hashed_subvol = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    gf_boolean_t parent_layout_changed = _gf_false;
+    call_stub_t *stub = NULL;
 
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        local = frame->local;
-        prev  = cookie;
-        layout = local->layout;
-        conf = this->private;
-        hashed_subvol = local->hashed_subvol;
+    local = frame->local;
+    prev = cookie;
+    layout = local->layout;
+    conf = this->private;
+    hashed_subvol = local->hashed_subvol;
 
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
 
-        if (gf_uuid_is_null (local->loc.gfid) && !op_ret)
-                gf_uuid_copy (local->loc.gfid, stbuf->ia_gfid);
+    if (gf_uuid_is_null(local->loc.gfid) && !op_ret)
+        gf_uuid_copy(local->loc.gfid, stbuf->ia_gfid);
 
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-
-                parent_layout_changed = (xdata && dict_get (xdata, GF_PREOP_CHECK_FAILED))
-                        ? 1 : 0;
-                if (parent_layout_changed) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_PARENT_LAYOUT_CHANGED,
-                                "mkdir (%s/%s) (path: %s): parent layout "
-                                "changed. Attempting a refresh and then a "
-                                "retry", pgfid, local->loc.name,
-                                local->loc.path);
-
-                        stub = fop_mkdir_stub (frame, dht_mkdir_helper,
-                                               &local->loc, local->mode,
-                                               local->umask, local->params);
-                        if (stub == NULL) {
-                                goto err;
-                        }
-
-                        dht_handle_parent_layout_change (this, stub);
-                        stub = NULL;
-
-                        return 0;
-                }
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
 
+        parent_layout_changed = (xdata &&
+                                 dict_get(xdata, GF_PREOP_CHECK_FAILED))
+                                    ? 1
+                                    : 0;
+        if (parent_layout_changed) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_PARENT_LAYOUT_CHANGED,
+                   "mkdir (%s/%s) (path: %s): parent layout "
+                   "changed. Attempting a refresh and then a "
+                   "retry",
+                   pgfid, local->loc.name, local->loc.path);
+
+            stub = fop_mkdir_stub(frame, dht_mkdir_helper, &local->loc,
+                                  local->mode, local->umask, local->params);
+            if (stub == NULL) {
                 goto err;
-        }
-
-        dict_del (local->params, GF_PREOP_PARENT_KEY);
-        dict_del (local->params, conf->xattr_name);
+            }
 
-        if (dht_is_subvol_filled (this, hashed_subvol))
-                ret = dht_layout_merge (this, layout, prev,
-                                        -1, ENOSPC, NULL);
-        else
-                ret = dht_layout_merge (this, layout, prev,
-                                        op_ret, op_errno, NULL);
+            dht_handle_parent_layout_change(this, stub);
+            stub = NULL;
+
+            return 0;
+        }
+
+        goto err;
+    }
+
+    dict_del(local->params, GF_PREOP_PARENT_KEY);
+    dict_del(local->params, conf->xattr_name);
+
+    if (dht_is_subvol_filled(this, hashed_subvol))
+        ret = dht_layout_merge(this, layout, prev, -1, ENOSPC, NULL);
+    else
+        ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, NULL);
+
+    /* TODO: we may have to return from the function
+       if layout merge fails. For now, lets just log an error */
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+               "%s: failed to merge layouts for subvol %s", local->loc.path,
+               prev->name);
+
+    local->op_ret = 0;
+
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preparent, preparent);
+    dht_iatt_merge(this, &local->postparent, postparent);
+
+    local->call_cnt = conf->subvolume_cnt - 1;
+    /* Delete internal mds xattr from params dict to avoid store
+      internal mds xattr on other subvols
+    */
+    dict_del(local->params, conf->mds_xattr_key);
+
+    if (gf_uuid_is_null(local->loc.gfid))
+        gf_uuid_copy(local->loc.gfid, stbuf->ia_gfid);
+
+    /* Set hashed subvol as a mds subvol on inode ctx */
+    /*if (!local->inode)
+            local->inode  = inode_ref (inode);
+    */
+    ret = dht_inode_ctx_mdsvol_set(local->inode, this, hashed_subvol);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+               "Failed to set hashed subvol for %s on inode vol is %s",
+               local->loc.path, hashed_subvol->name);
+    }
+
+    if (local->call_cnt == 0) {
+        /*Unlock namespace lock once mkdir is done on all subvols*/
+        dht_unlock_namespace(frame, &local->lock[0]);
+        FRAME_SU_DO(frame, dht_local_t);
+        dht_selfheal_directory(frame, dht_mkdir_selfheal_cbk, &local->loc,
+                               layout);
+        return 0;
+    }
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == hashed_subvol)
+            continue;
+        STACK_WIND_COOKIE(frame, dht_mkdir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i], conf->subvolumes[i]->fops->mkdir,
+                          &local->loc, local->mode, local->umask,
+                          local->params);
+    }
+
+    return 0;
+err:
+    if (local->op_ret != 0) {
+        dht_unlock_namespace(frame, &local->lock[0]);
+    }
 
-        /* TODO: we may have to return from the function
-           if layout merge fails. For now, lets just log an error */
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "%s: failed to merge layouts for subvol %s",
-                        local->loc.path, prev->name);
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        local->op_ret = 0;
+    return 0;
+}
 
-        dht_iatt_merge (this, &local->stbuf, stbuf);
-        dht_iatt_merge (this, &local->preparent, preparent);
-        dht_iatt_merge (this, &local->postparent, postparent);
+int
+dht_mkdir_guard_parent_layout_cbk(call_frame_t *frame, xlator_t *this,
+                                  loc_t *loc, mode_t mode, mode_t umask,
+                                  dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = 0;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = -1;
+    int32_t zero[1] = {0};
 
-        local->call_cnt = conf->subvolume_cnt - 1;
-        /* Delete internal mds xattr from params dict to avoid store
-          internal mds xattr on other subvols
-        */
-        dict_del (local->params, conf->mds_xattr_key);
+    local = frame->local;
+    conf = this->private;
 
-        if (gf_uuid_is_null (local->loc.gfid))
-                gf_uuid_copy (local->loc.gfid, stbuf->ia_gfid);
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
 
-        /* Set hashed subvol as a mds subvol on inode ctx */
-        /*if (!local->inode)
-                local->inode  = inode_ref (inode);
-        */
-        ret = dht_inode_ctx_mdsvol_set (local->inode, this, hashed_subvol);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
-                        "Failed to set hashed subvol for %s on inode vol is %s",
-                        local->loc.path, hashed_subvol->name);
-        }
+    if (local->op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "Acquiring lock on parent to guard against "
+               "layout-change failed.",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
 
-        if (local->call_cnt == 0) {
-                /*Unlock namespace lock once mkdir is done on all subvols*/
-                dht_unlock_namespace (frame, &local->lock[0]);
-                FRAME_SU_DO (frame, dht_local_t);
-                dht_selfheal_directory (frame, dht_mkdir_selfheal_cbk,
-                                        &local->loc, layout);
-                return 0;
-        }
+    local->op_ret = -1;
+    /* Add internal MDS xattr on disk for hashed subvol
+     */
+    ret = dht_dict_set_array(params, conf->mds_xattr_key, zero, 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value:key = %s for "
+               "path %s",
+               conf->mds_xattr_key, loc->path);
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == hashed_subvol)
-                        continue;
-                STACK_WIND_COOKIE (frame, dht_mkdir_cbk, conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->mkdir,
-                                   &local->loc, local->mode, local->umask,
-                                   local->params);
-        }
+    STACK_WIND_COOKIE(frame, dht_mkdir_hashed_cbk, local->hashed_subvol,
+                      local->hashed_subvol, local->hashed_subvol->fops->mkdir,
+                      loc, mode, umask, params);
 
-        return 0;
+    return 0;
 err:
-        if (local->op_ret != 0) {
-                dht_unlock_namespace (frame, &local->lock[0]);
-        }
+    DHT_STACK_UNWIND(mkdir, frame, -1, local->op_errno, NULL, NULL, NULL, NULL,
+                     NULL);
+
+    return 0;
+}
+
+int
+dht_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+          mode_t umask, dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = EINVAL, ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    call_stub_t *stub = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    conf = this->private;
+
+    if (!params || !dict_get(params, "gfid-req")) {
+        op_errno = EPERM;
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, op_errno,
+                         DHT_MSG_GFID_NULL,
+                         "mkdir: %s is received "
+                         "without gfid-req %p",
+                         loc->path, params);
+        goto err;
+    }
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        gf_msg_debug(this->name, 0, "hashed subvol not found for %s",
+                     loc->path);
+        local->op_errno = EIO;
+        goto err;
+    }
+
+    local->hashed_subvol = hashed_subvol;
+    local->mode = mode;
+    local->umask = umask;
+    if (params)
+        local->params = dict_ref(params);
+
+    local->inode = inode_ref(loc->inode);
+
+    local->layout = dht_layout_new(this, conf->subvolume_cnt);
+    if (!local->layout) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* set the newly created directory hash to the commit hash
+     * if the configuration option is set. If configuration option
+     * is not set, the older clients may still be connecting to the
+     * volume and hence we need to preserve the 1 in disk[0] part of the
+     * layout xattr */
+    if (conf->lookup_optimize)
+        local->layout->commit_hash = conf->vol_commit_hash;
+    else
+        local->layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+
+    stub = fop_mkdir_stub(frame, dht_mkdir_guard_parent_layout_cbk, loc, mode,
+                          umask, params);
+    if (stub == NULL) {
+        gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "creating stub failed.",
+               pgfid, loc->name, loc->path);
+        local->op_errno = ENOMEM;
+        goto err;
+    }
+
+    ret = dht_guard_parent_layout_and_namespace(this, stub);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s) cannot wind lock request to "
+               "guard parent layout",
+               pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    return 0;
 
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+err:
+    op_errno = local ? local->op_errno : op_errno;
+    DHT_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir_guard_parent_layout_cbk (call_frame_t *frame, xlator_t *this,
-                                   loc_t *loc, mode_t mode, mode_t umask,
-                                   dict_t *params)
+dht_rmdir_selfheal_cbk(call_frame_t *heal_frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t *local                    = NULL;
-        dht_conf_t  *conf                     = 0;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int          ret                      = -1;
-        int32_t      zero[1]                  = {0};
-
-        local = frame->local;
-        conf  = this->private;
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *main_frame = NULL;
 
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
-
-        if (local->op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "Acquiring lock on parent to guard against "
-                        "layout-change failed.", pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        local->op_ret = -1;
-        /* Add internal MDS xattr on disk for hashed subvol
-        */
-        ret = dht_dict_set_array (params, conf->mds_xattr_key, zero, 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value:key = %s for "
-                        "path %s", conf->mds_xattr_key, loc->path);
-        }
+    heal_local = heal_frame->local;
+    main_frame = heal_local->main_frame;
+    local = main_frame->local;
 
-        STACK_WIND_COOKIE (frame, dht_mkdir_hashed_cbk, local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->mkdir,
-                           loc, mode, umask, params);
+    DHT_STACK_DESTROY(heal_frame);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        return 0;
-err:
-        DHT_STACK_UNWIND (mkdir, frame, -1, local->op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+    DHT_STACK_UNWIND(rmdir, main_frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_mkdir (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, mode_t mode, mode_t umask, dict_t *params)
+dht_rmdir_hashed_subvol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int op_ret, int op_errno, struct iatt *preparent,
+                            struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local                   = NULL;
-        dht_conf_t   *conf                    = NULL;
-        int           op_errno                = EINVAL, ret = -1;
-        xlator_t     *hashed_subvol           = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        call_stub_t  *stub                    = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        gf_uuid_unparse (loc->parent->gfid, pgfid);
+    dht_local_t *local = NULL;
+    dht_local_t *heal_local = NULL;
+    call_frame_t *heal_frame = NULL;
+    dht_conf_t *conf = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        conf = this->private;
-
-        if (!params || !dict_get (params, "gfid-req")) {
-                op_errno = EPERM;
-                gf_msg_callingfn (this->name, GF_LOG_WARNING, op_errno,
-                                  DHT_MSG_GFID_NULL, "mkdir: %s is received "
-                                  "without gfid-req %p", loc->path, params);
-                goto err;
-        }
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
 
-        dht_get_du_info (frame, this, loc);
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            local->op_ret = -1;
+            if (conf->subvolume_cnt != 1) {
+                if (op_errno != ENOENT && op_errno != EACCES &&
+                    op_errno != ESTALE) {
+                    local->need_selfheal = 1;
+                }
+            }
 
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                gf_msg_debug (this->name, 0,
-                              "hashed subvol not found for %s",
-                              loc->path);
-                local->op_errno = EIO;
-                goto err;
+            gf_msg_debug(this->name, op_errno,
+                         "rmdir on %s for %s failed "
+                         "(gfid = %s)",
+                         prev->name, local->loc.path, gfid);
+            goto unlock;
         }
 
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        local->hashed_subvol = hashed_subvol;
-        local->mode = mode;
-        local->umask = umask;
-        if (params)
-                local->params = dict_ref (params);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (local->need_selfheal) {
+            dht_rmdir_unlock(frame, this);
+            local->layout = dht_layout_get(this, local->loc.inode);
 
-        local->inode  = inode_ref (loc->inode);
+            /* TODO: neater interface needed below */
+            local->stbuf.ia_type = local->loc.inode->ia_type;
 
-        local->layout = dht_layout_new (this, conf->subvolume_cnt);
-        if (!local->layout) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+            gf_uuid_copy(local->gfid, local->loc.inode->gfid);
 
-        /* set the newly created directory hash to the commit hash
-         * if the configuration option is set. If configuration option
-         * is not set, the older clients may still be connecting to the
-         * volume and hence we need to preserve the 1 in disk[0] part of the
-         * layout xattr */
-        if (conf->lookup_optimize)
-                local->layout->commit_hash = conf->vol_commit_hash;
-        else
-                local->layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+            /* Use a different frame or else the rmdir op_ret is
+             * overwritten by that of the selfheal */
 
+            heal_frame = copy_frame(frame);
 
-        stub = fop_mkdir_stub (frame, dht_mkdir_guard_parent_layout_cbk, loc,
-                               mode, umask, params);
-        if (stub == NULL) {
-                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "creating stub failed.", pgfid, loc->name, loc->path);
-                local->op_errno = ENOMEM;
+            if (heal_frame == NULL) {
                 goto err;
-        }
+            }
 
-        ret = dht_guard_parent_layout_and_namespace (this, stub);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s) cannot wind lock request to "
-                        "guard parent layout", pgfid, loc->name, loc->path);
+            heal_local = dht_local_init(heal_frame, &local->loc, NULL, 0);
+            if (!heal_local) {
+                DHT_STACK_DESTROY(heal_frame);
                 goto err;
-        }
-
-        return 0;
-
-err:
-        op_errno = local ? local->op_errno : op_errno;
-        DHT_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL);
+            }
 
-        return 0;
-}
+            heal_local->inode = inode_ref(local->loc.inode);
+            heal_local->main_frame = frame;
+            gf_uuid_copy(heal_local->gfid, local->loc.inode->gfid);
 
+            dht_selfheal_restore(heal_frame, dht_rmdir_selfheal_cbk,
+                                 &heal_local->loc, heal_local->layout);
+            return 0;
+        } else {
+            if (local->loc.parent) {
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->preparent, 0);
 
-int
-dht_rmdir_selfheal_cbk (call_frame_t *heal_frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *main_frame = NULL;
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->postparent, 1);
+            }
 
-        heal_local = heal_frame->local;
-        main_frame = heal_local->main_frame;
-        local = main_frame->local;
+            dht_set_fixed_dir_stat(&local->preparent);
+            dht_set_fixed_dir_stat(&local->postparent);
 
-        DHT_STACK_DESTROY (heal_frame);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+            dht_rmdir_unlock(frame, this);
+            DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                             &local->preparent, &local->postparent, NULL);
+        }
+    }
 
-        DHT_STACK_UNWIND (rmdir, main_frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
+    return 0;
 
-        return 0;
+err:
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
-
 int
-dht_rmdir_hashed_subvol_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int op_ret, int op_errno, struct iatt *preparent,
-                             struct iatt *postparent, dict_t *xdata)
+dht_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iatt *preparent, struct iatt *postparent,
+              dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *heal_frame = NULL;
-        dht_conf_t   *conf = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int done = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *heal_local = NULL;
+    call_frame_t *heal_frame = NULL;
+    int ret = -1;
 
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
+    local = frame->local;
+    prev = cookie;
 
-        gf_uuid_unparse(local->loc.gfid, gfid);
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
+                local->op_errno = op_errno;
+                local->op_ret = -1;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        local->op_ret   = -1;
-                        if (conf->subvolume_cnt != 1) {
-                                if (op_errno != ENOENT && op_errno != EACCES
-                                    && op_errno != ESTALE) {
-                                        local->need_selfheal = 1;
-                                }
-                        }
-
-                        gf_msg_debug (this->name, op_errno,
-                                      "rmdir on %s for %s failed "
-                                      "(gfid = %s)",
-                                      prev->name, local->loc.path,
-                                      gfid);
-                        goto unlock;
-                }
+                if (op_errno != EACCES)
+                    local->need_selfheal = 1;
+            }
 
-                dht_iatt_merge (this, &local->preparent, preparent);
-                dht_iatt_merge (this, &local->postparent, postparent);
+            gf_uuid_unparse(local->loc.gfid, gfid);
 
+            gf_msg_debug(this->name, op_errno,
+                         "rmdir on %s for %s failed."
+                         "(gfid = %s)",
+                         prev->name, local->loc.path, gfid);
+            goto unlock;
         }
+
+        /* Track if rmdir succeeded on at least one subvol*/
+        local->fop_succeeded = 1;
+        dht_iatt_merge(this, &local->preparent, preparent);
+        dht_iatt_merge(this, &local->postparent, postparent);
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-               if (local->need_selfheal) {
-                        dht_rmdir_unlock (frame, this);
-                        local->layout =
-                                dht_layout_get (this, local->loc.inode);
-
-                        /* TODO: neater interface needed below */
-                        local->stbuf.ia_type = local->loc.inode->ia_type;
-
-                        gf_uuid_copy (local->gfid, local->loc.inode->gfid);
-
-                        /* Use a different frame or else the rmdir op_ret is
-                         * overwritten by that of the selfheal */
-
-                        heal_frame = copy_frame (frame);
-
-                        if (heal_frame == NULL) {
-                                goto err;
-                        }
-
-                        heal_local = dht_local_init (heal_frame,
-                                                     &local->loc,
-                                                     NULL, 0);
-                        if (!heal_local) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
-
-                        heal_local->inode = inode_ref (local->loc.inode);
-                        heal_local->main_frame = frame;
-                        gf_uuid_copy (heal_local->gfid, local->loc.inode->gfid);
-
-                        dht_selfheal_restore (heal_frame,
-                                              dht_rmdir_selfheal_cbk,
-                                              &heal_local->loc,
-                                              heal_local->layout);
-                        return 0;
-               } else {
-
-                        if (local->loc.parent) {
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->preparent,
-                                                           0);
-
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->postparent,
-                                                           1);
-                        }
-
-                        dht_set_fixed_dir_stat (&local->preparent);
-                        dht_set_fixed_dir_stat (&local->postparent);
-
-                        dht_rmdir_unlock (frame, this);
-                        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-               }
-        }
+    UNLOCK(&frame->lock);
 
-        return 0;
+    this_call_cnt = dht_frame_return(frame);
 
-err:
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                          local->op_errno, NULL, NULL, NULL);
-        return 0;
+    /* if local->hashed_subvol, we are yet to wind to hashed_subvol. */
+    if (local->hashed_subvol && (this_call_cnt == 1)) {
+        done = 1;
+    } else if (!local->hashed_subvol && !this_call_cnt) {
+        done = 1;
+    }
 
-}
+    if (done) {
+        if (local->need_selfheal && local->fop_succeeded) {
+            dht_rmdir_unlock(frame, this);
+            local->layout = dht_layout_get(this, local->loc.inode);
 
+            /* TODO: neater interface needed below */
+            local->stbuf.ia_type = local->loc.inode->ia_type;
 
-int
-dht_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, struct iatt *preparent,
-               struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-        int           done = 0;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
-        dht_local_t  *heal_local = NULL;
-        call_frame_t *heal_frame = NULL;
-        int           ret        = -1;
+            gf_uuid_copy(local->gfid, local->loc.inode->gfid);
+            heal_frame = copy_frame(frame);
+            if (heal_frame == NULL) {
+                goto err;
+            }
 
-        local = frame->local;
-        prev  = cookie;
+            heal_local = dht_local_init(heal_frame, &local->loc, NULL, 0);
+            if (!heal_local) {
+                DHT_STACK_DESTROY(heal_frame);
+                goto err;
+            }
 
+            heal_local->inode = inode_ref(local->loc.inode);
+            heal_local->main_frame = frame;
+            gf_uuid_copy(heal_local->gfid, local->loc.inode->gfid);
+            ret = dht_selfheal_restore(heal_frame, dht_rmdir_selfheal_cbk,
+                                       &heal_local->loc, heal_local->layout);
+            if (ret) {
+                DHT_STACK_DESTROY(heal_frame);
+                goto err;
+            }
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
-                                local->op_errno = op_errno;
-                                local->op_ret = -1;
+        } else if (this_call_cnt) {
+            /* If non-hashed subvol's have responded, proceed */
+            if (local->op_ret == 0) {
+                /* Delete the dir from the hashed subvol if:
+                 * The fop succeeded on at least one subvol
+                 *  and did not fail on any
+                 *  or
+                 *  The fop failed with ENOENT/ESTALE on
+                 *  all subvols */
+
+                STACK_WIND_COOKIE(frame, dht_rmdir_hashed_subvol_cbk,
+                                  local->hashed_subvol, local->hashed_subvol,
+                                  local->hashed_subvol->fops->rmdir,
+                                  &local->loc, local->flags, NULL);
+            } else {
+                /* hashed-subvol was non-NULL and rmdir failed on
+                 * all non hashed-subvols. Unwind rmdir with
+                 * local->op_ret and local->op_errno. */
+                dht_rmdir_unlock(frame, this);
+                DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                                 &local->preparent, &local->postparent, NULL);
 
-                                if (op_errno != EACCES)
-                                        local->need_selfheal = 1;
-                        }
+                return 0;
+            }
+        } else if (!this_call_cnt) {
+            /* All subvol's have responded, proceed */
 
-                        gf_uuid_unparse(local->loc.gfid, gfid);
+            if (local->loc.parent) {
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->preparent, 0);
 
-                        gf_msg_debug (this->name, op_errno,
-                                      "rmdir on %s for %s failed."
-                                      "(gfid = %s)",
-                                      prev->name, local->loc.path,
-                                      gfid);
-                        goto unlock;
-                }
+                dht_inode_ctx_time_update(local->loc.parent, this,
+                                          &local->postparent, 1);
+            }
 
-                /* Track if rmdir succeeded on at least one subvol*/
-                local->fop_succeeded = 1;
-                dht_iatt_merge (this, &local->preparent, preparent);
-                dht_iatt_merge (this, &local->postparent, postparent);
-        }
-unlock:
-        UNLOCK (&frame->lock);
-
-
-        this_call_cnt = dht_frame_return (frame);
-
-        /* if local->hashed_subvol, we are yet to wind to hashed_subvol. */
-        if (local->hashed_subvol && (this_call_cnt == 1)) {
-                done = 1;
-        } else if (!local->hashed_subvol && !this_call_cnt) {
-                done = 1;
-        }
-
-
-        if (done) {
-                if (local->need_selfheal && local->fop_succeeded) {
-                        dht_rmdir_unlock (frame, this);
-                        local->layout =
-                                dht_layout_get (this, local->loc.inode);
-
-                        /* TODO: neater interface needed below */
-                        local->stbuf.ia_type = local->loc.inode->ia_type;
-
-                        gf_uuid_copy (local->gfid, local->loc.inode->gfid);
-                        heal_frame = copy_frame (frame);
-                        if (heal_frame == NULL) {
-                                goto err;
-                        }
-
-                        heal_local = dht_local_init (heal_frame, &local->loc,
-                                                     NULL, 0);
-                        if (!heal_local) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
-
-                        heal_local->inode = inode_ref (local->loc.inode);
-                        heal_local->main_frame = frame;
-                        gf_uuid_copy (heal_local->gfid, local->loc.inode->gfid);
-                        ret = dht_selfheal_restore (heal_frame,
-                                                    dht_rmdir_selfheal_cbk,
-                                                    &heal_local->loc,
-                                                    heal_local->layout);
-                        if (ret) {
-                                DHT_STACK_DESTROY (heal_frame);
-                                goto err;
-                        }
-
-                } else if (this_call_cnt) {
-                        /* If non-hashed subvol's have responded, proceed */
-                        if (local->op_ret == 0) {
-                                /* Delete the dir from the hashed subvol if:
-                                 * The fop succeeded on at least one subvol
-                                 *  and did not fail on any
-                                 *  or
-                                 *  The fop failed with ENOENT/ESTALE on
-                                 *  all subvols */
-
-                                STACK_WIND_COOKIE (frame, dht_rmdir_hashed_subvol_cbk,
-                                                   local->hashed_subvol,
-                                                   local->hashed_subvol,
-                                                   local->hashed_subvol->fops->rmdir,
-                                                   &local->loc, local->flags, NULL);
-                        } else {
-                         /* hashed-subvol was non-NULL and rmdir failed on
-                          * all non hashed-subvols. Unwind rmdir with
-                          * local->op_ret and local->op_errno. */
-                                dht_rmdir_unlock (frame, this);
-                                DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-
-                                return 0;
-
-                        }
-                } else if (!this_call_cnt) {
-                        /* All subvol's have responded, proceed */
-
-                        if (local->loc.parent) {
-
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->preparent,
-                                                           0);
-
-                                dht_inode_ctx_time_update (local->loc.parent,
-                                                           this,
-                                                           &local->postparent,
-                                                           1);
-
-                        }
-
-                        dht_set_fixed_dir_stat (&local->preparent);
-                        dht_set_fixed_dir_stat (&local->postparent);
-
-                        dht_rmdir_unlock (frame, this);
-                        DHT_STACK_UNWIND (rmdir, frame, local->op_ret,
-                                          local->op_errno, &local->preparent,
-                                          &local->postparent, NULL);
-                }
+            dht_set_fixed_dir_stat(&local->preparent);
+            dht_set_fixed_dir_stat(&local->postparent);
+
+            dht_rmdir_unlock(frame, this);
+            DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                             &local->preparent, &local->postparent, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (rmdir, frame, -1, local->op_errno, NULL, NULL, NULL);
-        return 0;
-
+    DHT_STACK_UNWIND(rmdir, frame, -1, local->op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_rmdir_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rmdir_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
 int
-dht_rmdir_unlock (call_frame_t *frame, xlator_t *this)
+dht_rmdir_unlock(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[0].ns.directory_ns);
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[0].ns.directory_ns);
 
-        /* Unlock inodelk */
-        lock_count = dht_lock_count (local->lock[0].ns.parent_layout.locks,
-                                     local->lock[0].ns.parent_layout.lk_count);
+    /* Unlock inodelk */
+    lock_count = dht_lock_count(local->lock[0].ns.parent_layout.locks,
+                                local->lock[0].ns.parent_layout.lk_count);
 
-        if (lock_count == 0)
-                goto done;
+    if (lock_count == 0)
+        goto done;
 
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL)
-                goto done;
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL)
+        goto done;
 
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL)
-                goto done;
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL)
+        goto done;
 
-        lock_local->lock[0].ns.parent_layout.locks = local->lock[0].ns.parent_layout.locks;
-        lock_local->lock[0].ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
+    lock_local->lock[0].ns.parent_layout.locks = local->lock[0]
+                                                     .ns.parent_layout.locks;
+    lock_local->lock[0]
+        .ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
 
-        local->lock[0].ns.parent_layout.locks = NULL;
-        local->lock[0].ns.parent_layout.lk_count = 0;
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].ns.parent_layout.locks,
-                            lock_local->lock[0].ns.parent_layout.lk_count,
-                            dht_rmdir_unlock_cbk);
-        lock_frame = NULL;
+    local->lock[0].ns.parent_layout.locks = NULL;
+    local->lock[0].ns.parent_layout.lk_count = 0;
+    dht_unlock_inodelk(lock_frame, lock_local->lock[0].ns.parent_layout.locks,
+                       lock_local->lock[0].ns.parent_layout.lk_count,
+                       dht_rmdir_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rmdir_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rmdir_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        int           i     = 0;
-        xlator_t     *hashed_subvol;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *hashed_subvol;
 
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        conf = this->private;
-        local = frame->local;
+    conf = this->private;
+    local = frame->local;
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed rmdir for %s)",
-                        local->loc.path);
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed rmdir for %s)",
+               local->loc.path);
 
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        hashed_subvol = local->hashed_subvol;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (hashed_subvol &&
-                    (hashed_subvol == conf->subvolumes[i]))
-                        continue;
+    hashed_subvol = local->hashed_subvol;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (hashed_subvol && (hashed_subvol == conf->subvolumes[i]))
+            continue;
 
-                STACK_WIND_COOKIE (frame, dht_rmdir_cbk, conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->rmdir,
-                                   &local->loc, local->flags, NULL);
-        }
+        STACK_WIND_COOKIE(frame, dht_rmdir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i], conf->subvolumes[i]->fops->rmdir,
+                          &local->loc, local->flags, NULL);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rmdir_do (call_frame_t *frame, xlator_t *this)
+dht_rmdir_do(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-        xlator_t     *hashed_subvol = NULL;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    xlator_t *hashed_subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        VALIDATE_OR_GOTO (this->private, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        conf = this->private;
-        local = frame->local;
+    conf = this->private;
+    local = frame->local;
 
-        if (local->op_ret == -1)
-                goto err;
+    if (local->op_ret == -1)
+        goto err;
 
-        local->call_cnt = conf->subvolume_cnt;
+    local->call_cnt = conf->subvolume_cnt;
 
-        /* first remove from non-hashed_subvol */
-        hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
+    /* first remove from non-hashed_subvol */
+    hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
 
-        if (!hashed_subvol) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
+    if (!hashed_subvol) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "Failed to get hashed subvol for %s (gfid = %s)",
-                        local->loc.path, gfid);
-        } else {
-                local->hashed_subvol = hashed_subvol;
-        }
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "Failed to get hashed subvol for %s (gfid = %s)",
+               local->loc.path, gfid);
+    } else {
+        local->hashed_subvol = hashed_subvol;
+    }
 
-        /* When DHT has only 1 child */
-        if (conf->subvolume_cnt == 1) {
-                STACK_WIND_COOKIE (frame, dht_rmdir_hashed_subvol_cbk,
-                                   conf->subvolumes[0], conf->subvolumes[0],
-                                   conf->subvolumes[0]->fops->rmdir,
-                                   &local->loc, local->flags, NULL);
-                return 0;
-        }
+    /* When DHT has only 1 child */
+    if (conf->subvolume_cnt == 1) {
+        STACK_WIND_COOKIE(frame, dht_rmdir_hashed_subvol_cbk,
+                          conf->subvolumes[0], conf->subvolumes[0],
+                          conf->subvolumes[0]->fops->rmdir, &local->loc,
+                          local->flags, NULL);
+        return 0;
+    }
 
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, &local->loc, local->hashed_subvol,
-                                     &local->current->ns, dht_rmdir_lock_cbk);
-        if (ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = errno ? errno : EINVAL;
-                goto err;
-        }
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, &local->loc, local->hashed_subvol,
+                                &local->current->ns, dht_rmdir_lock_cbk);
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = errno ? errno : EINVAL;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        DHT_STACK_UNWIND (rmdir, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
-        return 0;
+    DHT_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
+    return 0;
 }
 
-
 int
-dht_rmdir_linkfile_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                               int op_ret, int op_errno, struct iatt *preparent,
-                               struct iatt *postparent, dict_t *xdata)
+dht_rmdir_linkfile_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int op_ret, int op_errno, struct iatt *preparent,
+                              struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t    *local = NULL;
-        xlator_t       *prev = NULL;
-        xlator_t       *src = NULL;
-        call_frame_t   *readdirp_frame = NULL;
-        dht_local_t    *readdirp_local = NULL;
-        int             this_call_cnt = 0;
-        char gfid[GF_UUID_BUF_SIZE] ={0};
-
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local  = frame->local;
-        prev   = cookie;
-        src    = prev;
+    local = frame->local;
+    prev = cookie;
+    src = prev;
 
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
 
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
+    gf_uuid_unparse(local->loc.gfid, gfid);
 
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        if (op_ret == 0) {
-                gf_msg_trace (this->name, 0,
-                              "Unlinked linkfile %s on %s, gfid = %s",
-                              local->loc.path, src->name, gfid);
-        } else {
-                if (op_errno != ENOENT) {
-                        readdirp_local->op_ret   = -1;
-                        readdirp_local->op_errno = op_errno;
-                }
-                gf_msg_debug (this->name, op_errno,
-                              "Unlink of %s on %s failed. (gfid = %s)",
-                              local->loc.path, src->name, gfid);
+    if (op_ret == 0) {
+        gf_msg_trace(this->name, 0, "Unlinked linkfile %s on %s, gfid = %s",
+                     local->loc.path, src->name, gfid);
+    } else {
+        if (op_errno != ENOENT) {
+            readdirp_local->op_ret = -1;
+            readdirp_local->op_errno = op_errno;
         }
+        gf_msg_debug(this->name, op_errno,
+                     "Unlink of %s on %s failed. (gfid = %s)", local->loc.path,
+                     src->name, gfid);
+    }
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
+    this_call_cnt = dht_frame_return(readdirp_frame);
 
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_readdirp_do (readdirp_frame, this);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_readdirp_do(readdirp_frame, this);
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
 int
-dht_rmdir_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, inode_t *inode,
-                      struct iatt *stbuf, dict_t *xattr, struct iatt *parent)
+dht_rmdir_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, inode_t *inode,
+                     struct iatt *stbuf, dict_t *xattr, struct iatt *parent)
 {
-        dht_local_t    *local = NULL;
-        xlator_t       *prev = NULL;
-        xlator_t       *src = NULL;
-        call_frame_t   *readdirp_frame = NULL;
-        dht_local_t    *readdirp_local = NULL;
-        int             this_call_cnt = 0;
-        dht_conf_t     *conf = this->private;
-        char               gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        prev  = cookie;
-        src   = prev;
+    local = frame->local;
+    prev = cookie;
+    src = prev;
 
-        gf_msg_debug (this->name, 0, "dht_rmdir_lookup_cbk %s",
-                      local->loc.path);
+    gf_msg_debug(this->name, 0, "dht_rmdir_lookup_cbk %s", local->loc.path);
 
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
 
-        if (op_ret != 0) {
+    if (op_ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_FILE_LOOKUP_FAILED,
+               "lookup failed for %s on %s  (type=0%o)", local->loc.path,
+               src->name, stbuf->ia_type);
+        goto err;
+    }
 
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_FILE_LOOKUP_FAILED,
-                        "lookup failed for %s on %s  (type=0%o)",
-                        local->loc.path, src->name, stbuf->ia_type);
-                goto err;
-        }
-
-        if (!check_is_linkfile (inode, stbuf, xattr, conf->link_xattr_name)) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = ENOTEMPTY;
+    if (!check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = ENOTEMPTY;
 
-                gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NOT_LINK_FILE_ERROR,
-                        "%s on %s is not a linkfile (type=0%o, gfid = %s)",
-                        local->loc.path, src->name, stbuf->ia_type, gfid);
-                goto err;
-        }
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NOT_LINK_FILE_ERROR,
+               "%s on %s is not a linkfile (type=0%o, gfid = %s)",
+               local->loc.path, src->name, stbuf->ia_type, gfid);
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_rmdir_linkfile_unlink_cbk, src,
-                           src, src->fops->unlink, &local->loc, 0, NULL);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rmdir_linkfile_unlink_cbk, src, src,
+                      src->fops->unlink, &local->loc, 0, NULL);
+    return 0;
 err:
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_rmdir_readdirp_do (readdirp_frame, this);
-        }
+    this_call_cnt = dht_frame_return(readdirp_frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_rmdir_readdirp_do(readdirp_frame, this);
+    }
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
 int
-dht_rmdir_cached_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int op_ret, int op_errno, inode_t *inode,
-                             struct iatt *stbuf, dict_t *xattr,
-                             struct iatt *parent)
+dht_rmdir_cached_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int op_ret, int op_errno, inode_t *inode,
+                            struct iatt *stbuf, dict_t *xattr,
+                            struct iatt *parent)
 {
-        dht_local_t    *local             = NULL;
-        xlator_t       *src               = NULL;
-        call_frame_t   *readdirp_frame    = NULL;
-        dht_local_t    *readdirp_local    = NULL;
-        int             this_call_cnt     = 0;
-        dht_conf_t     *conf              = this->private;
-        dict_t         *xattrs            = NULL;
-        int             ret               = 0;
+    dht_local_t *local = NULL;
+    xlator_t *src = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    dht_local_t *readdirp_local = NULL;
+    int this_call_cnt = 0;
+    dht_conf_t *conf = this->private;
+    dict_t *xattrs = NULL;
+    int ret = 0;
 
-        local = frame->local;
-        src   = local->hashed_subvol;
+    local = frame->local;
+    src = local->hashed_subvol;
 
+    /* main_frame here is the readdirp_frame */
 
-        /* main_frame here is the readdirp_frame */
+    readdirp_frame = local->main_frame;
+    readdirp_local = readdirp_frame->local;
 
-        readdirp_frame = local->main_frame;
-        readdirp_local = readdirp_frame->local;
+    gf_msg_debug(this->name, 0, "returning for %s ", local->loc.path);
 
-        gf_msg_debug (this->name, 0, "returning for %s ",
-                      local->loc.path);
+    if (op_ret == 0) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = ENOTEMPTY;
 
-        if (op_ret == 0) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = ENOTEMPTY;
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_ERROR,
+               "%s found on cached subvol %s", local->loc.path, src->name);
+        goto err;
+    } else if (op_errno != ENOENT) {
+        readdirp_local->op_ret = -1;
+        readdirp_local->op_errno = op_errno;
 
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_ERROR,
-                        "%s found on cached subvol %s",
-                        local->loc.path, src->name);
-                goto err;
-        } else if (op_errno != ENOENT) {
-                readdirp_local->op_ret  = -1;
-                readdirp_local->op_errno = op_errno;
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_SUBVOL_ERROR,
-                        "%s not found on cached subvol %s",
-                        local->loc.path, src->name);
-                goto err;
-        }
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_SUBVOL_ERROR,
+               "%s not found on cached subvol %s", local->loc.path, src->name);
+        goto err;
+    }
 
-        xattrs = dict_new ();
-        if (!xattrs) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dict_new failed");
-                goto err;
-        }
+    xattrs = dict_new();
+    if (!xattrs) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dict_new failed");
+        goto err;
+    }
 
-        ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        conf->link_xattr_name);
-                if (xattrs)
-                        dict_unref (xattrs);
-                goto err;
-        }
-        STACK_WIND_COOKIE (frame, dht_rmdir_lookup_cbk, src, src,
-                           src->fops->lookup, &local->loc, xattrs);
+    ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s",
+               conf->link_xattr_name);
         if (xattrs)
-                dict_unref (xattrs);
-
-        return 0;
+            dict_unref(xattrs);
+        goto err;
+    }
+    STACK_WIND_COOKIE(frame, dht_rmdir_lookup_cbk, src, src, src->fops->lookup,
+                      &local->loc, xattrs);
+    if (xattrs)
+        dict_unref(xattrs);
+
+    return 0;
 err:
 
-        this_call_cnt = dht_frame_return (readdirp_frame);
+    this_call_cnt = dht_frame_return(readdirp_frame);
 
-        /* Once all the lookups/unlinks etc have returned, proceed to wind
-         * readdirp on the subvol again until no entries are returned.
-         * This is required if there are more entries than can be returned
-         * in a single readdirp call.
-         */
+    /* Once all the lookups/unlinks etc have returned, proceed to wind
+     * readdirp on the subvol again until no entries are returned.
+     * This is required if there are more entries than can be returned
+     * in a single readdirp call.
+     */
 
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_readdirp_do (readdirp_frame, this);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_readdirp_do(readdirp_frame, this);
 
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
-
 int
-dht_rmdir_is_subvol_empty (call_frame_t *frame, xlator_t *this,
-                           gf_dirent_t *entries, xlator_t *src)
+dht_rmdir_is_subvol_empty(call_frame_t *frame, xlator_t *this,
+                          gf_dirent_t *entries, xlator_t *src)
 {
-        int                 ret          = 0;
-        int                 build_ret    = 0;
-        gf_dirent_t        *trav         = NULL;
-        call_frame_t       *lookup_frame = NULL;
-        dht_local_t        *lookup_local = NULL;
-        dht_local_t        *local        = NULL;
-        dict_t             *xattrs       = NULL;
-        dht_conf_t         *conf         = this->private;
-        xlator_t           *subvol       = NULL;
-        char                gfid[GF_UUID_BUF_SIZE] = {0};
-        int                 count        = 0;
-        gf_boolean_t        unwind        = _gf_false;
-
-
-        local = frame->local;
+    int ret = 0;
+    int build_ret = 0;
+    gf_dirent_t *trav = NULL;
+    call_frame_t *lookup_frame = NULL;
+    dht_local_t *lookup_local = NULL;
+    dht_local_t *local = NULL;
+    dict_t *xattrs = NULL;
+    dht_conf_t *conf = this->private;
+    xlator_t *subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int count = 0;
+    gf_boolean_t unwind = _gf_false;
 
-        list_for_each_entry (trav, &entries->list, list) {
-                if (strcmp (trav->d_name, ".") == 0)
-                        continue;
-                if (strcmp (trav->d_name, "..") == 0)
-                        continue;
-                if (check_is_linkfile (NULL, (&trav->d_stat), trav->dict,
-                                              conf->link_xattr_name)) {
-                        count++;
-                        continue;
-                }
+    local = frame->local;
 
-                /* this entry is either a directory which is neither "." nor "..",
-                   or a non directory which is not a linkfile. the directory is to
-                   be treated as non-empty
-                */
-                return 0;
+    list_for_each_entry(trav, &entries->list, list)
+    {
+        if (strcmp(trav->d_name, ".") == 0)
+            continue;
+        if (strcmp(trav->d_name, "..") == 0)
+            continue;
+        if (check_is_linkfile(NULL, (&trav->d_stat), trav->dict,
+                              conf->link_xattr_name)) {
+            count++;
+            continue;
         }
 
-        xattrs = dict_new ();
-        if (!xattrs) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dict_new failed");
-                return -1;
-        }
+        /* this entry is either a directory which is neither "." nor "..",
+           or a non directory which is not a linkfile. the directory is to
+           be treated as non-empty
+        */
+        return 0;
+    }
 
-        ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        conf->link_xattr_name);
+    xattrs = dict_new();
+    if (!xattrs) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dict_new failed");
+        return -1;
+    }
 
-                if (xattrs)
-                        dict_unref (xattrs);
-                return -1;
-        }
+    ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s",
+               conf->link_xattr_name);
 
-        local->call_cnt = count;
-        ret = 0;
+        if (xattrs)
+            dict_unref(xattrs);
+        return -1;
+    }
 
-        list_for_each_entry (trav, &entries->list, list) {
-                if (strcmp (trav->d_name, ".") == 0)
-                        continue;
-                if (strcmp (trav->d_name, "..") == 0)
-                        continue;
+    local->call_cnt = count;
+    ret = 0;
 
-                lookup_frame = copy_frame (frame);
+    list_for_each_entry(trav, &entries->list, list)
+    {
+        if (strcmp(trav->d_name, ".") == 0)
+            continue;
+        if (strcmp(trav->d_name, "..") == 0)
+            continue;
 
-                if (!lookup_frame) {
-                        /* out of memory, let the rmdir fail
-                           (as non-empty, unfortunately) */
-                        goto err;
-                }
+        lookup_frame = copy_frame(frame);
 
-                lookup_local = dht_local_init (lookup_frame, NULL, NULL,
-                                               GF_FOP_LOOKUP);
-                if (!lookup_local) {
-                        goto err;
-                }
+        if (!lookup_frame) {
+            /* out of memory, let the rmdir fail
+               (as non-empty, unfortunately) */
+            goto err;
+        }
 
-                lookup_frame->local = lookup_local;
-                lookup_local->main_frame = frame;
-                lookup_local->hashed_subvol = src;
+        lookup_local = dht_local_init(lookup_frame, NULL, NULL, GF_FOP_LOOKUP);
+        if (!lookup_local) {
+            goto err;
+        }
 
-                build_ret = dht_build_child_loc (this, &lookup_local->loc,
-                                                 &local->loc, trav->d_name);
-                if (build_ret != 0)
-                        goto err;
+        lookup_frame->local = lookup_local;
+        lookup_local->main_frame = frame;
+        lookup_local->hashed_subvol = src;
 
-                gf_uuid_copy (lookup_local->loc.gfid, trav->d_stat.ia_gfid);
+        build_ret = dht_build_child_loc(this, &lookup_local->loc, &local->loc,
+                                        trav->d_name);
+        if (build_ret != 0)
+            goto err;
 
-                gf_uuid_unparse(lookup_local->loc.gfid, gfid);
+        gf_uuid_copy(lookup_local->loc.gfid, trav->d_stat.ia_gfid);
 
-                gf_msg_trace (this->name, 0,
-                              "looking up %s on subvolume %s, gfid = %s",
-                              lookup_local->loc.path, src->name, gfid);
+        gf_uuid_unparse(lookup_local->loc.gfid, gfid);
 
-                subvol = dht_linkfile_subvol (this, NULL, &trav->d_stat,
-                                              trav->dict);
-                if (!subvol) {
+        gf_msg_trace(this->name, 0, "looking up %s on subvolume %s, gfid = %s",
+                     lookup_local->loc.path, src->name, gfid);
 
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_INVALID_LINKFILE,
-                                "Linkfile does not have link subvolume. "
-                                "path = %s, gfid = %s",
-                                lookup_local->loc.path, gfid);
+        subvol = dht_linkfile_subvol(this, NULL, &trav->d_stat, trav->dict);
+        if (!subvol) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_INVALID_LINKFILE,
+                   "Linkfile does not have link subvolume. "
+                   "path = %s, gfid = %s",
+                   lookup_local->loc.path, gfid);
 
-                        gf_msg_debug (this->name, 0,
-                                      "looking up %s on subvol %s, gfid = %s",
-                                      lookup_local->loc.path, src->name, gfid);
+            gf_msg_debug(this->name, 0, "looking up %s on subvol %s, gfid = %s",
+                         lookup_local->loc.path, src->name, gfid);
 
-                        STACK_WIND_COOKIE (lookup_frame, dht_rmdir_lookup_cbk,
-                                           src, src, src->fops->lookup,
-                                           &lookup_local->loc, xattrs);
-                } else {
-                        gf_msg_debug (this->name, 0,
-                                      "Looking up linkfile target %s on "
-                                      " subvol %s, gfid = %s",
-                                      lookup_local->loc.path, subvol->name,
-                                      gfid);
-
-                        STACK_WIND (lookup_frame, dht_rmdir_cached_lookup_cbk,
-                                    subvol, subvol->fops->lookup,
-                                    &lookup_local->loc, xattrs);
-                }
-                ret++;
+            STACK_WIND_COOKIE(lookup_frame, dht_rmdir_lookup_cbk, src, src,
+                              src->fops->lookup, &lookup_local->loc, xattrs);
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "Looking up linkfile target %s on "
+                         " subvol %s, gfid = %s",
+                         lookup_local->loc.path, subvol->name, gfid);
 
-                lookup_frame = NULL;
-                lookup_local = NULL;
+            STACK_WIND(lookup_frame, dht_rmdir_cached_lookup_cbk, subvol,
+                       subvol->fops->lookup, &lookup_local->loc, xattrs);
         }
+        ret++;
 
-        if (xattrs)
-                dict_unref (xattrs);
+        lookup_frame = NULL;
+        lookup_local = NULL;
+    }
 
-        return ret;
+    if (xattrs)
+        dict_unref(xattrs);
+
+    return ret;
 err:
-        if (xattrs)
-                dict_unref (xattrs);
+    if (xattrs)
+        dict_unref(xattrs);
 
-        if (lookup_frame)
-                DHT_STACK_DESTROY (lookup_frame);
+    if (lookup_frame)
+        DHT_STACK_DESTROY(lookup_frame);
 
-        /* Handle the case where the wound calls have unwound before the
-         * loop processing is done
-         */
+    /* Handle the case where the wound calls have unwound before the
+     * loop processing is done
+     */
 
-        LOCK (&frame->lock);
-        {
-                local->op_ret = -1;
-                local->op_errno = ENOTEMPTY;
+    LOCK(&frame->lock);
+    {
+        local->op_ret = -1;
+        local->op_errno = ENOTEMPTY;
 
-                local->call_cnt -= (count - ret);
-                if (!local->call_cnt)
-                        unwind = _gf_true;
-        }
-        UNLOCK (&frame->lock);
+        local->call_cnt -= (count - ret);
+        if (!local->call_cnt)
+            unwind = _gf_true;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!unwind) {
-                return ret;
-        }
-        return 0;
+    if (!unwind) {
+        return ret;
+    }
+    return 0;
 }
 
-
-
 /*
  * No more entries on this subvol. Proceed to the actual rmdir operation.
  */
 
 void
-dht_rmdir_readdirp_done (call_frame_t *readdirp_frame, xlator_t *this)
+dht_rmdir_readdirp_done(call_frame_t *readdirp_frame, xlator_t *this)
 {
+    call_frame_t *main_frame = NULL;
+    dht_local_t *main_local = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        call_frame_t      *main_frame    = NULL;
-        dht_local_t       *main_local         = NULL;
-        dht_local_t       *local         = NULL;
-        int                this_call_cnt = 0;
-
+    local = readdirp_frame->local;
+    main_frame = local->main_frame;
+    main_local = main_frame->local;
 
-        local = readdirp_frame->local;
-        main_frame = local->main_frame;
-        main_local = main_frame->local;
+    /* At least one readdirp failed.
+     * This is a bit hit or miss - if readdirp failed on more than
+     * one subvol, we don't know which error is returned.
+     */
+    if (local->op_ret == -1) {
+        main_local->op_ret = local->op_ret;
+        main_local->op_errno = local->op_errno;
+    }
 
-        /* At least one readdirp failed.
-         * This is a bit hit or miss - if readdirp failed on more than
-         * one subvol, we don't know which error is returned.
-         */
-        if (local->op_ret == -1) {
-                main_local->op_ret = local->op_ret;
-                main_local->op_errno = local->op_errno;
-        }
+    this_call_cnt = dht_frame_return(main_frame);
 
-        this_call_cnt = dht_frame_return (main_frame);
+    if (is_last_call(this_call_cnt))
+        dht_rmdir_do(main_frame, this);
 
-        if (is_last_call (this_call_cnt))
-                dht_rmdir_do (main_frame, this);
-
-
-        DHT_STACK_DESTROY (readdirp_frame);
+    DHT_STACK_DESTROY(readdirp_frame);
 }
 
-
-
 int
-dht_rmdir_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, gf_dirent_t *entries,
-                        dict_t *xdata)
+dht_rmdir_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, gf_dirent_t *entries,
+                       dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *src = NULL;
-        int           ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src = NULL;
+    int ret = 0;
 
+    local = frame->local;
+    prev = cookie;
+    src = prev;
 
-        local = frame->local;
-        prev  = cookie;
-        src   = prev;
-
-        if (op_ret > 2) {
-                ret = dht_rmdir_is_subvol_empty (frame, this, entries, src);
-
-                switch (ret) {
-                case 0: /* non linkfiles exist */
-                        gf_msg_trace (this->name, 0,
-                                      "readdir on %s for %s returned %d "
-                                      "entries", prev->name,
-                                      local->loc.path, op_ret);
-                        local->op_ret = -1;
-                        local->op_errno = ENOTEMPTY;
-                        goto done;
-                default:
-                        /* @ret number of linkfiles are getting unlinked */
-                        gf_msg_trace (this->name, 0,
-                                      "readdir on %s for %s found %d "
-                                      "linkfiles", prev->name,
-                                      local->loc.path, ret);
-                        break;
-                }
+    if (op_ret > 2) {
+        ret = dht_rmdir_is_subvol_empty(frame, this, entries, src);
 
+        switch (ret) {
+            case 0: /* non linkfiles exist */
+                gf_msg_trace(this->name, 0,
+                             "readdir on %s for %s returned %d "
+                             "entries",
+                             prev->name, local->loc.path, op_ret);
+                local->op_ret = -1;
+                local->op_errno = ENOTEMPTY;
+                goto done;
+            default:
+                /* @ret number of linkfiles are getting unlinked */
+                gf_msg_trace(this->name, 0,
+                             "readdir on %s for %s found %d "
+                             "linkfiles",
+                             prev->name, local->loc.path, ret);
+                break;
         }
+    }
 
-
-        if (ret) {
-                return 0;
-        }
+    if (ret) {
+        return 0;
+    }
 
 done:
-        /* readdirp failed or no linkto files were found on this subvol */
+    /* readdirp failed or no linkto files were found on this subvol */
 
-        dht_rmdir_readdirp_done (frame, this);
-        return 0;
+    dht_rmdir_readdirp_done(frame, this);
+    return 0;
 }
 
 /* Keep sending readdirp on the subvol until it returns no more entries
@@ -10746,214 +10095,202 @@ done:
  */
 
 int
-dht_rmdir_readdirp_do (call_frame_t *readdirp_frame, xlator_t *this)
+dht_rmdir_readdirp_do(call_frame_t *readdirp_frame, xlator_t *this)
 {
-        dht_local_t *local  = NULL;
-
-        local = readdirp_frame->local;
-
-        if (local->op_ret == -1) {
-                /* there is no point doing another readdirp on this
-                 * subvol . */
-                dht_rmdir_readdirp_done (readdirp_frame, this);
-                return 0;
-        }
-
-        STACK_WIND_COOKIE (readdirp_frame, dht_rmdir_readdirp_cbk,
-                           local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->readdirp,
-                           local->fd, 4096, 0, local->xattr);
+    dht_local_t *local = NULL;
 
+    local = readdirp_frame->local;
 
+    if (local->op_ret == -1) {
+        /* there is no point doing another readdirp on this
+         * subvol . */
+        dht_rmdir_readdirp_done(readdirp_frame, this);
         return 0;
+    }
 
-}
+    STACK_WIND_COOKIE(readdirp_frame, dht_rmdir_readdirp_cbk,
+                      local->hashed_subvol, local->hashed_subvol,
+                      local->hashed_subvol->fops->readdirp, local->fd, 4096, 0,
+                      local->xattr);
 
+    return 0;
+}
 
 int
-dht_rmdir_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_rmdir_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local         = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev          = NULL;
-        int           ret           = 0;
-        dht_conf_t   *conf          = this->private;
-        dict_t       *dict          = NULL;
-        int           i             = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-        dht_local_t  *readdirp_local = NULL;
-        call_frame_t *readdirp_frame = NULL;
-        int           cnt           = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
+    int ret = 0;
+    dht_conf_t *conf = this->private;
+    dict_t *dict = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *readdirp_local = NULL;
+    call_frame_t *readdirp_frame = NULL;
+    int cnt = 0;
 
-        local = frame->local;
-        prev  = cookie;
+    local = frame->local;
+    prev = cookie;
 
+    this_call_cnt = dht_frame_return(frame);
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
-
-                gf_msg_debug (this->name, op_errno,
-                              "opendir on %s for %s failed, "
-                              "gfid = %s,",
-                              prev->name, local->loc.path, gfid);
-                if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                }
-                goto err;
+        gf_msg_debug(this->name, op_errno,
+                     "opendir on %s for %s failed, "
+                     "gfid = %s,",
+                     prev->name, local->loc.path, gfid);
+        if ((op_errno != ENOENT) && (op_errno != ESTALE)) {
+            local->op_ret = -1;
+            local->op_errno = op_errno;
         }
+        goto err;
+    }
 
-        if (!is_last_call (this_call_cnt))
-                return 0;
-
-        if (local->op_ret == -1)
-                goto err;
-
-        fd_bind (fd);
+    if (!is_last_call(this_call_cnt))
+        return 0;
 
-        dict = dict_new ();
-        if (!dict) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                goto err;
-        }
+    if (local->op_ret == -1)
+        goto err;
 
-        ret = dict_set_uint32 (dict, conf->link_xattr_name, 256);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value:key = %s",
-                        local->loc.path, conf->link_xattr_name);
-
-        cnt = local->call_cnt = conf->subvolume_cnt;
+    fd_bind(fd);
 
+    dict = dict_new();
+    if (!dict) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        goto err;
+    }
 
-        /* Create a separate frame per subvol as we might need
-         * to resend readdirp multiple times to get all the
-         * entries.
-         */
+    ret = dict_set_uint32(dict, conf->link_xattr_name, 256);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: Failed to set dictionary value:key = %s", local->loc.path,
+               conf->link_xattr_name);
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
+    cnt = local->call_cnt = conf->subvolume_cnt;
 
-                readdirp_frame = copy_frame (frame);
+    /* Create a separate frame per subvol as we might need
+     * to resend readdirp multiple times to get all the
+     * entries.
+     */
 
-                if (!readdirp_frame) {
-                        cnt--;
-                        /* Reduce the local->call_cnt as well */
-                        (void) dht_frame_return (frame);
-                        continue;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        readdirp_frame = copy_frame(frame);
 
-                readdirp_local = dht_local_init (readdirp_frame, &local->loc,
-                                                 local->fd, 0);
+        if (!readdirp_frame) {
+            cnt--;
+            /* Reduce the local->call_cnt as well */
+            (void)dht_frame_return(frame);
+            continue;
+        }
 
-                if (!readdirp_local) {
-                        DHT_STACK_DESTROY (readdirp_frame);
-                        cnt--;
-                        /* Reduce the local->call_cnt as well */
-                        dht_frame_return (frame);
-                        continue;
-                }
-                readdirp_local->main_frame = frame;
-                readdirp_local->op_ret = 0;
-                readdirp_local->xattr = dict_ref (dict);
-                /* overload this field to save the subvol info */
-                readdirp_local->hashed_subvol = conf->subvolumes[i];
+        readdirp_local = dht_local_init(readdirp_frame, &local->loc, local->fd,
+                                        0);
 
-                STACK_WIND_COOKIE (readdirp_frame, dht_rmdir_readdirp_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->readdirp,
-                                   readdirp_local->fd, 4096, 0,
-                                   readdirp_local->xattr);
+        if (!readdirp_local) {
+            DHT_STACK_DESTROY(readdirp_frame);
+            cnt--;
+            /* Reduce the local->call_cnt as well */
+            dht_frame_return(frame);
+            continue;
         }
+        readdirp_local->main_frame = frame;
+        readdirp_local->op_ret = 0;
+        readdirp_local->xattr = dict_ref(dict);
+        /* overload this field to save the subvol info */
+        readdirp_local->hashed_subvol = conf->subvolumes[i];
 
-        if (dict)
-                dict_unref (dict);
+        STACK_WIND_COOKIE(readdirp_frame, dht_rmdir_readdirp_cbk,
+                          conf->subvolumes[i], conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->readdirp,
+                          readdirp_local->fd, 4096, 0, readdirp_local->xattr);
+    }
 
-        /* Could not wind readdirp to any subvol */
+    if (dict)
+        dict_unref(dict);
 
-        if (!cnt)
-                goto err;
+    /* Could not wind readdirp to any subvol */
 
-        return 0;
+    if (!cnt)
+        goto err;
+
+    return 0;
 
 err:
-        if (is_last_call (this_call_cnt)) {
-                dht_rmdir_do (frame, this);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_rmdir_do(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-           dict_t *xdata)
+dht_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata)
 {
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (this->private, err);
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
 
-        conf = this->private;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(this->private, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_RMDIR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    conf = this->private;
 
-        local->call_cnt = conf->subvolume_cnt;
-        local->op_ret   = 0;
-        local->fop_succeeded = 0;
+    local = dht_local_init(frame, loc, NULL, GF_FOP_RMDIR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->flags = flags;
+    local->call_cnt = conf->subvolume_cnt;
+    local->op_ret = 0;
+    local->fop_succeeded = 0;
 
-        local->fd = fd_create (local->loc.inode, frame->root->pid);
-        if (!local->fd) {
+    local->flags = flags;
 
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local->fd = fd_create(local->loc.inode, frame->root->pid);
+    if (!local->fd) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (flags) {
-                return dht_rmdir_do (frame, this);
-        }
+    if (flags) {
+        return dht_rmdir_do(frame, this);
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_rmdir_opendir_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->opendir,
-                                   loc, local->fd, NULL);
-        }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_rmdir_opendir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->opendir, loc, local->fd,
+                          NULL);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rmdir, frame, -1, op_errno,
-                          NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_entrylk_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        DHT_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata);
-        return 0;
+    DHT_STACK_UNWIND(entrylk, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 /* TODO
@@ -10961,765 +10298,735 @@ dht_entrylk_cbk (call_frame_t *frame, void *cookie,
  * as described in the bug 1311002.
  */
 int
-dht_entrylk (call_frame_t *frame, xlator_t *this,
-             const char *volume, loc_t *loc, const char *basename,
-             entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+dht_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        local = dht_local_init (frame, loc, NULL, GF_FOP_ENTRYLK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, NULL, GF_FOP_ENTRYLK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_uuid_unparse(loc->gfid, gfid);
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_uuid_unparse(loc->gfid, gfid);
-
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s, "
-                              "gfid = %s", loc->path, gfid);
-                op_errno = EINVAL;
-                goto err;
-        }
+        gf_msg_debug(this->name, 0,
+                     "no cached subvolume for path=%s, "
+                     "gfid = %s",
+                     loc->path, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        local->call_cnt = 1;
+    local->call_cnt = 1;
 
-        STACK_WIND (frame, dht_entrylk_cbk,
-                    subvol, subvol->fops->entrylk,
-                    volume, loc, basename, cmd, type, xdata);
+    STACK_WIND(frame, dht_entrylk_cbk, subvol, subvol->fops->entrylk, volume,
+               loc, basename, cmd, type, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (entrylk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(entrylk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fentrylk_cbk (call_frame_t *frame, void *cookie,
-                  xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        DHT_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fentrylk, frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_fentrylk (call_frame_t *frame, xlator_t *this,
-              const char *volume, fd_t *fd, const char *basename,
-              entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+dht_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             const char *basename, entrylk_cmd cmd, entrylk_type type,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        char               gfid[GF_UUID_BUF_SIZE] = {0};
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO(fd->inode, err);
+    gf_uuid_unparse(fd->inode->gfid, gfid);
 
-        gf_uuid_unparse(fd->inode->gfid, gfid);
+    subvol = dht_subvol_get_cached(this, fd->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0,
+                     "No cached subvolume for fd=%p,"
+                     " gfid = %s",
+                     fd, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        subvol = dht_subvol_get_cached (this, fd->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "No cached subvolume for fd=%p,"
-                              " gfid = %s", fd, gfid);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        STACK_WIND (frame, dht_fentrylk_cbk,
-                    subvol, subvol->fops->fentrylk,
-                    volume, fd, basename, cmd, type, xdata);
+    STACK_WIND(frame, dht_fentrylk_cbk, subvol, subvol->fops->fentrylk, volume,
+               fd, basename, cmd, type, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fentrylk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fentrylk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-dht_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local                   = NULL;
-        int           this_call_cnt           = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret < 0 && op_errno != ENOTCONN) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-                local->op_ret = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret < 0 && op_errno != ENOTCONN) {
+            local->op_errno = op_errno;
+            goto unlock;
         }
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (ipc, frame, local->op_ret, local->op_errno,
-                                  NULL);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(ipc, frame, local->op_ret, local->op_errno, NULL);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-dht_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+dht_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        dht_local_t  *local    = NULL;
-        int           op_errno = EINVAL;
-        dht_conf_t   *conf     = NULL;
-        int           call_cnt = 0;
-        int           i        = 0;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int i = 0;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
 
-        if (op != GF_IPC_TARGET_UPCALL)
-                goto wind_default;
+    if (op != GF_IPC_TARGET_UPCALL)
+        goto wind_default;
 
-        VALIDATE_OR_GOTO (this->private, err);
-        conf = this->private;
+    VALIDATE_OR_GOTO(this->private, err);
+    conf = this->private;
 
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_IPC);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_IPC);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        call_cnt        = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
 
-        if (xdata) {
-                if (dict_set_int8 (xdata, conf->xattr_name, 0) < 0)
-                        goto err;
-        }
+    if (xdata) {
+        if (dict_set_int8(xdata, conf->xattr_name, 0) < 0)
+            goto err;
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND (frame, dht_ipc_cbk, conf->subvolumes[i],
-                            conf->subvolumes[i]->fops->ipc, op, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND(frame, dht_ipc_cbk, conf->subvolumes[i],
+                   conf->subvolumes[i]->fops->ipc, op, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (ipc, frame, -1, op_errno, NULL);
+    DHT_STACK_UNWIND(ipc, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 
 wind_default:
-        STACK_WIND (frame, default_ipc_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->ipc, op, xdata);
-        return 0;
+    STACK_WIND(frame, default_ipc_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ipc, op, xdata);
+    return 0;
 }
 
-
 int
-dht_forget (xlator_t *this, inode_t *inode)
+dht_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t        ctx_int = 0;
-        dht_inode_ctx_t *ctx    = NULL;
-        dht_layout_t *layout = NULL;
+    uint64_t ctx_int = 0;
+    dht_inode_ctx_t *ctx = NULL;
+    dht_layout_t *layout = NULL;
 
-        inode_ctx_del (inode, this, &ctx_int);
+    inode_ctx_del(inode, this, &ctx_int);
 
-        if (!ctx_int)
-                return 0;
+    if (!ctx_int)
+        return 0;
 
-        ctx = (dht_inode_ctx_t *) (long) ctx_int;
+    ctx = (dht_inode_ctx_t *)(long)ctx_int;
 
-        layout = ctx->layout;
-        ctx->layout = NULL;
-        dht_layout_unref (this, layout);
-        GF_FREE (ctx);
+    layout = ctx->layout;
+    ctx->layout = NULL;
+    dht_layout_unref(this, layout);
+    GF_FREE(ctx);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_notify (xlator_t *this, int event, void *data, ...)
+dht_notify(xlator_t *this, int event, void *data, ...)
 {
-        xlator_t                *subvol = NULL;
-        int                      cnt    = -1;
-        int                      i      = -1;
-        dht_conf_t              *conf   = NULL;
-        int                      ret    = -1;
-        int                      propagate = 0;
+    xlator_t *subvol = NULL;
+    int cnt = -1;
+    int i = -1;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int propagate = 0;
 
-        int                      had_heard_from_all = 0;
-        int                      have_heard_from_all = 0;
-        struct timeval           time = {0,};
-        gf_defrag_info_t        *defrag = NULL;
-        dict_t                  *dict   = NULL;
-        gf_defrag_type           cmd    = 0;
-        dict_t                  *output = NULL;
-        va_list                  ap;
-        dht_methods_t           *methods = NULL;
-        struct gf_upcall        *up_data = NULL;
-        struct gf_upcall_cache_invalidation *up_ci = NULL;
+    int had_heard_from_all = 0;
+    int have_heard_from_all = 0;
+    struct timeval time = {
+        0,
+    };
+    gf_defrag_info_t *defrag = NULL;
+    dict_t *dict = NULL;
+    gf_defrag_type cmd = 0;
+    dict_t *output = NULL;
+    va_list ap;
+    dht_methods_t *methods = NULL;
+    struct gf_upcall *up_data = NULL;
+    struct gf_upcall_cache_invalidation *up_ci = NULL;
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        /* had all subvolumes reported status once till now? */
-        had_heard_from_all = 1;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->last_event[i]) {
-                        had_heard_from_all = 0;
-                }
+    /* had all subvolumes reported status once till now? */
+    had_heard_from_all = 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->last_event[i]) {
+            had_heard_from_all = 0;
         }
+    }
 
-        switch (event) {
+    switch (event) {
         case GF_EVENT_CHILD_UP:
-                subvol = data;
+            subvol = data;
 
-                conf->gen++;
+            conf->gen++;
 
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
+            }
 
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_UP bad "
-                                      "subvolume %s",
-                                      subvol->name);
-                        break;
-                }
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_UP bad "
+                             "subvolume %s",
+                             subvol->name);
+                break;
+            }
 
-                gettimeofday (&time, NULL);
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->subvolume_status[cnt] = 1;
-                        conf->last_event[cnt] = event;
-                        conf->subvol_up_time[cnt] = time.tv_sec;
-                }
-                UNLOCK (&conf->subvolume_lock);
+            gettimeofday(&time, NULL);
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->subvolume_status[cnt] = 1;
+                conf->last_event[cnt] = event;
+                conf->subvol_up_time[cnt] = time.tv_sec;
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                /* one of the node came back up, do a stat update */
-                dht_get_du_info_for_subvol (this, cnt);
+            /* one of the node came back up, do a stat update */
+            dht_get_du_info_for_subvol(this, cnt);
 
-                break;
+            break;
 
         case GF_EVENT_SOME_DESCENDENT_UP:
-                subvol = data;
-                conf->gen++;
-                propagate = 1;
+            subvol = data;
+            conf->gen++;
+            propagate = 1;
 
-                break;
+            break;
 
         case GF_EVENT_SOME_DESCENDENT_DOWN:
-                subvol = data;
-                propagate = 1;
+            subvol = data;
+            propagate = 1;
 
-                break;
+            break;
 
         case GF_EVENT_CHILD_DOWN:
-                subvol = data;
-
-                if (conf->assert_no_child_down) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_CHILD_DOWN,
-                                "Received CHILD_DOWN. Exiting");
-                        if (conf->defrag) {
-                                gf_defrag_stop (conf,
-                                                GF_DEFRAG_STATUS_FAILED, NULL);
-                        } else {
-                                kill (getpid(), SIGTERM);
-                        }
-                }
-
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
-                }
+            subvol = data;
 
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_DOWN bad "
-                                      "subvolume %s", subvol->name);
-                        break;
+            if (conf->assert_no_child_down) {
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_CHILD_DOWN,
+                       "Received CHILD_DOWN. Exiting");
+                if (conf->defrag) {
+                    gf_defrag_stop(conf, GF_DEFRAG_STATUS_FAILED, NULL);
+                } else {
+                    kill(getpid(), SIGTERM);
                 }
+            }
 
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->subvolume_status[cnt] = 0;
-                        conf->last_event[cnt] = event;
-                        conf->subvol_up_time[cnt] = 0;
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
-                UNLOCK (&conf->subvolume_lock);
+            }
 
-                for (i = 0; i < conf->subvolume_cnt; i++)
-                        if (conf->last_event[i] != event)
-                                event = GF_EVENT_SOME_DESCENDENT_DOWN;
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_DOWN bad "
+                             "subvolume %s",
+                             subvol->name);
                 break;
+            }
 
-        case GF_EVENT_CHILD_CONNECTING:
-                subvol = data;
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->subvolume_status[cnt] = 0;
+                conf->last_event[cnt] = event;
+                conf->subvol_up_time[cnt] = 0;
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (subvol == conf->subvolumes[i]) {
-                                cnt = i;
-                                break;
-                        }
-                }
+            for (i = 0; i < conf->subvolume_cnt; i++)
+                if (conf->last_event[i] != event)
+                    event = GF_EVENT_SOME_DESCENDENT_DOWN;
+            break;
 
-                if (cnt == -1) {
-                        gf_msg_debug (this->name, 0,
-                                      "got GF_EVENT_CHILD_CONNECTING"
-                                      " bad subvolume %s",
-                                      subvol->name);
-                        break;
-                }
+        case GF_EVENT_CHILD_CONNECTING:
+            subvol = data;
 
-                LOCK (&conf->subvolume_lock);
-                {
-                        conf->last_event[cnt] = event;
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (subvol == conf->subvolumes[i]) {
+                    cnt = i;
+                    break;
                 }
-                UNLOCK (&conf->subvolume_lock);
+            }
 
+            if (cnt == -1) {
+                gf_msg_debug(this->name, 0,
+                             "got GF_EVENT_CHILD_CONNECTING"
+                             " bad subvolume %s",
+                             subvol->name);
                 break;
-        case GF_EVENT_VOLUME_DEFRAG:
-        {
-                if (!conf->defrag) {
-                        return ret;
-                }
-                defrag = conf->defrag;
+            }
 
-                dict = data;
-                va_start (ap, data);
-                output = va_arg (ap, dict_t*);
+            LOCK(&conf->subvolume_lock);
+            {
+                conf->last_event[cnt] = event;
+            }
+            UNLOCK(&conf->subvolume_lock);
 
-                ret = dict_get_int32 (dict, "rebalance-command",
-                                      (int32_t*)&cmd);
-                if (ret) {
-                        va_end (ap);
-                        return ret;
-                }
-                LOCK (&defrag->lock);
-                {
-                        if (defrag->is_exiting)
-                                goto unlock;
-                        if ((cmd == GF_DEFRAG_CMD_STATUS) ||
-                            (cmd == GF_DEFRAG_CMD_STATUS_TIER) ||
-                            (cmd == GF_DEFRAG_CMD_DETACH_STATUS))
-                                gf_defrag_status_get (conf, output);
-                        else if (cmd == GF_DEFRAG_CMD_START_DETACH_TIER)
-                                gf_defrag_start_detach_tier(defrag);
-                        else if (cmd == GF_DEFRAG_CMD_DETACH_START)
-                                defrag->cmd = GF_DEFRAG_CMD_DETACH_START;
-                        else if (cmd == GF_DEFRAG_CMD_STOP ||
-                                 cmd == GF_DEFRAG_CMD_STOP_DETACH_TIER ||
-                                 cmd == GF_DEFRAG_CMD_DETACH_STOP)
-                                gf_defrag_stop (conf,
-                                                GF_DEFRAG_STATUS_STOPPED, output);
-                        else if (cmd == GF_DEFRAG_CMD_PAUSE_TIER)
-                                ret = gf_defrag_pause_tier (this, defrag);
-                        else if (cmd == GF_DEFRAG_CMD_RESUME_TIER)
-                                ret = gf_defrag_resume_tier (this, defrag);
-                }
-unlock:
-                UNLOCK (&defrag->lock);
-                va_end (ap);
+            break;
+        case GF_EVENT_VOLUME_DEFRAG: {
+            if (!conf->defrag) {
                 return ret;
-                break;
+            }
+            defrag = conf->defrag;
+
+            dict = data;
+            va_start(ap, data);
+            output = va_arg(ap, dict_t *);
+
+            ret = dict_get_int32(dict, "rebalance-command", (int32_t *)&cmd);
+            if (ret) {
+                va_end(ap);
+                return ret;
+            }
+            LOCK(&defrag->lock);
+            {
+                if (defrag->is_exiting)
+                    goto unlock;
+                if ((cmd == GF_DEFRAG_CMD_STATUS) ||
+                    (cmd == GF_DEFRAG_CMD_STATUS_TIER) ||
+                    (cmd == GF_DEFRAG_CMD_DETACH_STATUS))
+                    gf_defrag_status_get(conf, output);
+                else if (cmd == GF_DEFRAG_CMD_START_DETACH_TIER)
+                    gf_defrag_start_detach_tier(defrag);
+                else if (cmd == GF_DEFRAG_CMD_DETACH_START)
+                    defrag->cmd = GF_DEFRAG_CMD_DETACH_START;
+                else if (cmd == GF_DEFRAG_CMD_STOP ||
+                         cmd == GF_DEFRAG_CMD_STOP_DETACH_TIER ||
+                         cmd == GF_DEFRAG_CMD_DETACH_STOP)
+                    gf_defrag_stop(conf, GF_DEFRAG_STATUS_STOPPED, output);
+                else if (cmd == GF_DEFRAG_CMD_PAUSE_TIER)
+                    ret = gf_defrag_pause_tier(this, defrag);
+                else if (cmd == GF_DEFRAG_CMD_RESUME_TIER)
+                    ret = gf_defrag_resume_tier(this, defrag);
+            }
+        unlock:
+            UNLOCK(&defrag->lock);
+            va_end(ap);
+            return ret;
+            break;
         }
         case GF_EVENT_UPCALL:
-                up_data = (struct gf_upcall *)data;
-                if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
-                        break;
-                up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
-
-                /* Since md-cache will be aggressively filtering lookups,
-                 * the stale layout issue will be more pronounced. Hence
-                 * when a layout xattr is changed by the rebalance process
-                 * notify all the md-cache clients to invalidate the existing
-                 * stat cache and send the lookup next time*/
-                if (up_ci->dict && dict_get (up_ci->dict, conf->xattr_name))
-                        up_ci->flags |= UP_EXPLICIT_LOOKUP;
-
-                /* TODO: Instead of invalidating iatt, update the new
-                 * hashed/cached subvolume in dht inode_ctx */
-                if (IS_DHT_LINKFILE_MODE (&up_ci->stat))
-                        up_ci->flags |= UP_EXPLICIT_LOOKUP;
-
-                propagate = 1;
+            up_data = (struct gf_upcall *)data;
+            if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION)
                 break;
+            up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
+
+            /* Since md-cache will be aggressively filtering lookups,
+             * the stale layout issue will be more pronounced. Hence
+             * when a layout xattr is changed by the rebalance process
+             * notify all the md-cache clients to invalidate the existing
+             * stat cache and send the lookup next time*/
+            if (up_ci->dict && dict_get(up_ci->dict, conf->xattr_name))
+                up_ci->flags |= UP_EXPLICIT_LOOKUP;
+
+            /* TODO: Instead of invalidating iatt, update the new
+             * hashed/cached subvolume in dht inode_ctx */
+            if (IS_DHT_LINKFILE_MODE(&up_ci->stat))
+                up_ci->flags |= UP_EXPLICIT_LOOKUP;
+
+            propagate = 1;
+            break;
         default:
-                propagate = 1;
-                break;
-        }
-
+            propagate = 1;
+            break;
+    }
+
+    /* have all subvolumes reported status once by now? */
+    have_heard_from_all = 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->last_event[i])
+            have_heard_from_all = 0;
+    }
+
+    /* if all subvols have reported status, no need to hide anything
+       or wait for anything else. Just propagate blindly */
+    if (have_heard_from_all) {
+        propagate = 1;
+    }
+
+    if (!had_heard_from_all && have_heard_from_all) {
+        /* This is the first event which completes aggregation
+           of events from all subvolumes. If at least one subvol
+           had come up, propagate CHILD_UP, but only this time
+        */
+        event = GF_EVENT_CHILD_DOWN;
 
-        /* have all subvolumes reported status once by now? */
-        have_heard_from_all = 1;
         for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->last_event[i])
-                        have_heard_from_all = 0;
-        }
-
-        /* if all subvols have reported status, no need to hide anything
-           or wait for anything else. Just propagate blindly */
-        if (have_heard_from_all) {
-                propagate = 1;
+            if (conf->last_event[i] == GF_EVENT_CHILD_UP) {
+                event = GF_EVENT_CHILD_UP;
+                break;
+            }
 
+            if (conf->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
+                event = GF_EVENT_CHILD_CONNECTING;
+                /* continue to check other events for CHILD_UP */
+            }
         }
 
-
-        if (!had_heard_from_all && have_heard_from_all) {
-                /* This is the first event which completes aggregation
-                   of events from all subvolumes. If at least one subvol
-                   had come up, propagate CHILD_UP, but only this time
-                */
-                event = GF_EVENT_CHILD_DOWN;
-
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->last_event[i] == GF_EVENT_CHILD_UP) {
-                                event = GF_EVENT_CHILD_UP;
-                                break;
-                        }
-
-                        if (conf->last_event[i] == GF_EVENT_CHILD_CONNECTING) {
-                                event = GF_EVENT_CHILD_CONNECTING;
-                                /* continue to check other events for CHILD_UP */
-                        }
-                }
-
-                /* Rebalance is started with assert_no_child_down. So we do
-                 * not need to handle CHILD_DOWN event here.
-                 *
-                 * If there is a graph switch, we should not restart the
-                 * rebalance daemon. Use 'run_defrag' to indicate if the
-                 * thread has already started.
-                 */
-                 if (conf->defrag && !run_defrag) {
-                        if (methods->migration_needed(this)) {
-                                run_defrag = 1;
-                                ret = gf_thread_create(&conf->defrag->th,
-                                                       NULL,
-                                                       gf_defrag_start, this,
-                                                       "dhtdg");
-                                if (ret) {
-                                        GF_FREE (conf->defrag);
-                                        conf->defrag = NULL;
-                                        kill (getpid(), SIGTERM);
-                                }
-                        }
+        /* Rebalance is started with assert_no_child_down. So we do
+         * not need to handle CHILD_DOWN event here.
+         *
+         * If there is a graph switch, we should not restart the
+         * rebalance daemon. Use 'run_defrag' to indicate if the
+         * thread has already started.
+         */
+        if (conf->defrag && !run_defrag) {
+            if (methods->migration_needed(this)) {
+                run_defrag = 1;
+                ret = gf_thread_create(&conf->defrag->th, NULL, gf_defrag_start,
+                                       this, "dhtdg");
+                if (ret) {
+                    GF_FREE(conf->defrag);
+                    conf->defrag = NULL;
+                    kill(getpid(), SIGTERM);
                 }
+            }
         }
+    }
 
-        ret = 0;
-        if (propagate)
-                ret = default_notify (this, event, data);
+    ret = 0;
+    if (propagate)
+        ret = default_notify(this, event, data);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_inode_ctx_layout_get (inode_t *inode, xlator_t *this, dht_layout_t **layout)
+dht_inode_ctx_layout_get(inode_t *inode, xlator_t *this, dht_layout_t **layout)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (!ret && ctx) {
-                if (ctx->layout) {
-                        if (layout)
-                                *layout = ctx->layout;
-                        ret = 0;
-                } else {
-                        ret = -1;
-                }
+    if (!ret && ctx) {
+        if (ctx->layout) {
+            if (layout)
+                *layout = ctx->layout;
+            ret = 0;
+        } else {
+            ret = -1;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-dht_log_new_layout_for_dir_selfheal (xlator_t *this, loc_t *loc,
-                                 dht_layout_t *layout)
-{
+dht_log_new_layout_for_dir_selfheal(xlator_t *this, loc_t *loc,
+                                    dht_layout_t *layout)
+{
+    char string[2048] = {0};
+    char *output_string = NULL;
+    int len = 0;
+    int off = 0;
+    int i = 0;
+    gf_loglevel_t log_level = gf_log_get_loglevel();
+    int ret = 0;
+
+    if (log_level < GF_LOG_INFO)
+        return;
 
-        char                    string[2048] = {0};
-        char                  *output_string = NULL;
-        int                              len = 0;
-        int                              off = 0;
-        int                                i = 0;
-        gf_loglevel_t             log_level = gf_log_get_loglevel();
-        int                              ret = 0;
+    if (!layout)
+        return;
 
-        if (log_level < GF_LOG_INFO)
-                return;
+    if (!layout->cnt)
+        return;
 
-        if (!layout)
-                return;
+    if (!loc)
+        return;
 
-        if (!layout->cnt)
-                return;
+    if (!loc->path)
+        return;
 
-        if (!loc)
-                return;
+    ret = snprintf(string, sizeof(string), "Setting layout of %s with ",
+                   loc->path);
 
-        if (!loc->path)
-                return;
+    if (ret < 0)
+        return;
 
-        ret = snprintf (string, sizeof (string), "Setting layout of %s with ",
-                        loc->path);
+    len += ret;
+
+    /* Calculation  of total length of the string required to calloc
+     * output_string. Log includes subvolume-name, start-range, end-range and
+     * err value.
+     *
+     * This log will help to debug cases where:
+     * a) Different processes set different layout of a directory.
+     * b) Error captured in lookup, which will be filled in layout->err
+     * (like ENOENT, ESTALE etc)
+     */
+
+    for (i = 0; i < layout->cnt; i++) {
+        ret = snprintf(string, sizeof(string),
+                       "[Subvol_name: %s, Err: %d , Start: "
+                       "%" PRIu32 " , Stop: %" PRIu32 " , Hash: %" PRIu32
+                       " ], ",
+                       layout->list[i].xlator->name, layout->list[i].err,
+                       layout->list[i].start, layout->list[i].stop,
+                       layout->list[i].commit_hash);
 
         if (ret < 0)
-                return;
+            return;
 
         len += ret;
+    }
 
-       /* Calculation  of total length of the string required to calloc
-        * output_string. Log includes subvolume-name, start-range, end-range and
-        * err value.
-        *
-        * This log will help to debug cases where:
-        * a) Different processes set different layout of a directory.
-        * b) Error captured in lookup, which will be filled in layout->err
-        * (like ENOENT, ESTALE etc)
-        */
-
-        for (i = 0; i < layout->cnt; i++) {
+    len++;
 
-                ret  = snprintf (string, sizeof (string),
-                                 "[Subvol_name: %s, Err: %d , Start: "
-                                 "%"PRIu32 " , Stop: %"PRIu32 " , Hash: %"
-                                 PRIu32 " ], ",
-                                 layout->list[i].xlator->name,
-                                 layout->list[i].err, layout->list[i].start,
-                                 layout->list[i].stop,
-                                 layout->list[i].commit_hash);
+    output_string = GF_MALLOC(len + 1, gf_common_mt_char);
 
-                if (ret < 0)
-                        return;
-
-                len += ret;
-
-        }
+    if (!output_string)
+        return;
 
-        len++;
+    ret = snprintf(output_string, len + 1, "Setting layout of %s with ",
+                   loc->path);
 
-        output_string = GF_MALLOC (len + 1, gf_common_mt_char);
+    if (ret < 0)
+        goto err;
 
-        if (!output_string)
-                return;
+    off += ret;
 
-        ret = snprintf (output_string, len + 1, "Setting layout of %s with ",
-                        loc->path);
+    for (i = 0; i < layout->cnt; i++) {
+        ret = snprintf(output_string + off, len - off,
+                       "[Subvol_name: %s, Err: %d , Start: "
+                       "%" PRIu32 " , Stop: %" PRIu32 " , Hash: %" PRIu32
+                       " ], ",
+                       layout->list[i].xlator->name, layout->list[i].err,
+                       layout->list[i].start, layout->list[i].stop,
+                       layout->list[i].commit_hash);
 
         if (ret < 0)
-                goto err;
+            goto err;
 
         off += ret;
+    }
 
-
-        for (i = 0; i < layout->cnt; i++) {
-
-                ret  =  snprintf (output_string + off, len - off,
-                                  "[Subvol_name: %s, Err: %d , Start: "
-                                  "%"PRIu32 " , Stop: %"PRIu32 " , Hash: %"
-                                  PRIu32  " ], ",
-                                  layout->list[i].xlator->name,
-                                  layout->list[i].err, layout->list[i].start,
-                                  layout->list[i].stop,
-                                  layout->list[i].commit_hash);
-
-                if (ret < 0)
-                        goto err;
-
-                off += ret;
-
-        }
-
-        gf_msg (this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_FIXED_LAYOUT,
-                "%s", output_string);
+    gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_FIXED_LAYOUT, "%s",
+           output_string);
 
 err:
-        GF_FREE (output_string);
+    GF_FREE(output_string);
 }
 
-int32_t dht_migration_get_dst_subvol(xlator_t *this, dht_local_t  *local)
+int32_t
+dht_migration_get_dst_subvol(xlator_t *this, dht_local_t *local)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!local)
-                goto out;
+    if (!local)
+        goto out;
 
-        local->rebalance.target_node =
-                dht_subvol_get_hashed (this, &local->loc);
+    local->rebalance.target_node = dht_subvol_get_hashed(this, &local->loc);
 
-        if (local->rebalance.target_node)
-                ret = 0;
+    if (local->rebalance.target_node)
+        ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-int32_t dht_migration_needed(xlator_t *this)
+int32_t
+dht_migration_needed(xlator_t *this)
 {
-        gf_defrag_info_t        *defrag = NULL;
-        dht_conf_t              *conf   = NULL;
-        int                      ret = 0;
+    gf_defrag_info_t *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO ("dht", conf, out);
-        GF_VALIDATE_OR_GOTO ("dht", conf->defrag, out);
+    GF_VALIDATE_OR_GOTO("dht", conf, out);
+    GF_VALIDATE_OR_GOTO("dht", conf->defrag, out);
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
-            (defrag->cmd != GF_DEFRAG_CMD_START_DETACH_TIER))
-                ret = 1;
+    if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
+        (defrag->cmd != GF_DEFRAG_CMD_START_DETACH_TIER))
+        ret = 1;
 
 out:
-        return ret;
+    return ret;
 }
 
-
-
 /*
 This function should not be called more then once during a FOP
 handling path. It is valid only for for ops on files
 */
-int32_t dht_set_local_rebalance (xlator_t *this, dht_local_t *local,
-                                 struct iatt *stbuf,
-                                 struct iatt *prebuf, struct iatt *postbuf,
-                                 dict_t *xdata)
+int32_t
+dht_set_local_rebalance(xlator_t *this, dht_local_t *local, struct iatt *stbuf,
+                        struct iatt *prebuf, struct iatt *postbuf,
+                        dict_t *xdata)
 {
+    if (!local)
+        return -1;
 
-        if (!local)
-                return -1;
-
-        if (local->rebalance.set) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_REBAL_STRUCT_SET,
-                        "local->rebalance already set");
-        }
-
+    if (local->rebalance.set) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_REBAL_STRUCT_SET,
+               "local->rebalance already set");
+    }
 
-        if (stbuf)
-                memcpy (&local->rebalance.stbuf, stbuf, sizeof (struct iatt));
+    if (stbuf)
+        memcpy(&local->rebalance.stbuf, stbuf, sizeof(struct iatt));
 
-        if (prebuf)
-                memcpy (&local->rebalance.prebuf, prebuf, sizeof (struct iatt));
+    if (prebuf)
+        memcpy(&local->rebalance.prebuf, prebuf, sizeof(struct iatt));
 
-        if (postbuf)
-                memcpy (&local->rebalance.postbuf, postbuf,
-                        sizeof (struct iatt));
+    if (postbuf)
+        memcpy(&local->rebalance.postbuf, postbuf, sizeof(struct iatt));
 
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        local->rebalance.set = 1;
+    local->rebalance.set = 1;
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-dht_is_tier_xlator (xlator_t *this)
+dht_is_tier_xlator(xlator_t *this)
 {
-
-        if (strcmp (this->type, "cluster/tier") == 0)
-                return _gf_true;
-        return _gf_false;
+    if (strcmp(this->type, "cluster/tier") == 0)
+        return _gf_true;
+    return _gf_false;
 }
 
 int32_t
-dht_release (xlator_t *this, fd_t *fd)
+dht_release(xlator_t *this, fd_t *fd)
 {
-        return dht_fd_ctx_destroy (this, fd);
+    return dht_fd_ctx_destroy(this, fd);
 }
 
 int
-dht_remove_stale_linkto (void *data)
+dht_remove_stale_linkto(void *data)
 {
-        call_frame_t    *frame = NULL;
-        dht_local_t     *local = NULL;
-        xlator_t        *this  = NULL;
-        dict_t          *xdata_in = NULL;
-        int             ret = 0;
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    dict_t *xdata_in = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", data, out);
+    GF_VALIDATE_OR_GOTO("dht", data, out);
 
-        frame = data;
-        local = frame->local;
-        this = frame->this;
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        GF_VALIDATE_OR_GOTO ("dht", local->link_subvol, out);
+    frame = data;
+    local = frame->local;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    GF_VALIDATE_OR_GOTO("dht", local->link_subvol, out);
 
-        xdata_in = dict_new ();
-        if (!xdata_in)
-                goto out;
-
-        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file (xdata_in);
-        if (ret) {
-                  gf_msg (this->name, GF_LOG_WARNING, -ret, 0,
-                                "Failed to set keys for stale linkto"
-                                "deletion on path %s", local->loc.path);
-                  goto out;
-        }
-
-        ret = syncop_unlink (local->link_subvol, &local->loc, xdata_in, NULL);
-        if (ret) {
-                  gf_msg (this->name, GF_LOG_WARNING, -ret, 0,
-                                "Removal of linkto failed"
-                                " on path %s at subvol %s",
-                                local->loc.path, local->link_subvol->name);
+    xdata_in = dict_new();
+    if (!xdata_in)
+        goto out;
 
-        }
+    ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(xdata_in);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, 0,
+               "Failed to set keys for stale linkto"
+               "deletion on path %s",
+               local->loc.path);
+        goto out;
+    }
+
+    ret = syncop_unlink(local->link_subvol, &local->loc, xdata_in, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, 0,
+               "Removal of linkto failed"
+               " on path %s at subvol %s",
+               local->loc.path, local->link_subvol->name);
+    }
 out:
-        if (xdata_in)
-                dict_unref (xdata_in);
-        return ret;
+    if (xdata_in)
+        dict_unref(xdata_in);
+    return ret;
 }
 
 int
-dht_remove_stale_linkto_cbk (int ret, call_frame_t *sync_frame, void *data)
+dht_remove_stale_linkto_cbk(int ret, call_frame_t *sync_frame, void *data)
 {
-        DHT_STACK_DESTROY (sync_frame);
-        return 0;
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-diskusage.c b/xlators/cluster/dht/src/dht-diskusage.c
index f109615e52c..13eaabae1c1 100644
--- a/xlators/cluster/dht/src/dht-diskusage.c
+++ b/xlators/cluster/dht/src/dht-diskusage.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
 
 #include "glusterfs.h"
@@ -20,493 +19,477 @@
 #include <sys/time.h>
 #include "events.h"
 
-
 int
-dht_du_info_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		 int op_ret, int op_errno, struct statvfs *statvfs,
-                 dict_t *xdata)
+dht_du_info_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
-	dht_conf_t    *conf         = NULL;
-	xlator_t      *prev          = NULL;
-	int            this_call_cnt = 0;
-	int            i = 0;
-	double         percent = 0;
-	double         percent_inodes = 0;
-	uint64_t       bytes = 0;
-        uint32_t       bpc;     /* blocks per chunk */
-        uint32_t       chunks   = 0;
-
-	conf = this->private;
-	prev = cookie;
-
-	if (op_ret == -1 || !statvfs) {
-		gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_GET_DISK_INFO_ERROR,
-			"failed to get disk info from %s", prev->name);
-		goto out;
-	}
-
-	if (statvfs->f_blocks) {
-		percent = (statvfs->f_bavail * 100) / statvfs->f_blocks;
-		bytes = (statvfs->f_bavail * statvfs->f_frsize);
-                /*
-                 * A 32-bit count of 1MB chunks allows a maximum brick size of
-                 * ~4PB.  It's possible that we could see a single local FS
-                 * bigger than that some day, but this code is likely to be
-                 * irrelevant by then.  Meanwhile, it's more important to keep
-                 * the chunk size small so the layout-calculation code that
-                 * uses this value can be tested on normal machines.
-                 */
-                bpc = (1 << 20) / statvfs->f_bsize;
-                chunks = (statvfs->f_blocks + bpc - 1) / bpc;
-	}
-
-	if (statvfs->f_files) {
-		percent_inodes = (statvfs->f_ffree * 100) / statvfs->f_files;
-	} else {
-                /*
-                 * Set percent inodes to 100 for dynamically allocated inode
-                 * filesystems. The rationale is that distribute need not
-                 * worry about total inodes; rather, let the 'create()' be
-                 * scheduled on the hashed subvol regardless of the total
-                 * inodes.
-		 */
-		percent_inodes = 100;
-	}
-
-	LOCK (&conf->subvolume_lock);
-	{
-		for (i = 0; i < conf->subvolume_cnt; i++)
-			if (prev == conf->subvolumes[i]) {
-				conf->du_stats[i].avail_percent = percent;
-				conf->du_stats[i].avail_space   = bytes;
-				conf->du_stats[i].avail_inodes  = percent_inodes;
-                                conf->du_stats[i].chunks        = chunks;
-                                conf->du_stats[i].total_blocks  = statvfs->f_blocks;
-                                conf->du_stats[i].avail_blocks  = statvfs->f_bavail;
-                                conf->du_stats[i].frsize        = statvfs->f_frsize;
-
-                                gf_msg_debug (this->name, 0,
-				              "subvolume '%s': avail_percent "
-					      "is: %.2f and avail_space "
-                                              "is: %" PRIu64" and avail_inodes"
-                                              " is: %.2f",
-					      prev->name,
-					      conf->du_stats[i].avail_percent,
-					      conf->du_stats[i].avail_space,
-					      conf->du_stats[i].avail_inodes);
-                                break;  /* no point in looping further */
-			}
-	}
-	UNLOCK (&conf->subvolume_lock);
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
+    int i = 0;
+    double percent = 0;
+    double percent_inodes = 0;
+    uint64_t bytes = 0;
+    uint32_t bpc; /* blocks per chunk */
+    uint32_t chunks = 0;
+
+    conf = this->private;
+    prev = cookie;
+
+    if (op_ret == -1 || !statvfs) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno,
+               DHT_MSG_GET_DISK_INFO_ERROR, "failed to get disk info from %s",
+               prev->name);
+        goto out;
+    }
+
+    if (statvfs->f_blocks) {
+        percent = (statvfs->f_bavail * 100) / statvfs->f_blocks;
+        bytes = (statvfs->f_bavail * statvfs->f_frsize);
+        /*
+         * A 32-bit count of 1MB chunks allows a maximum brick size of
+         * ~4PB.  It's possible that we could see a single local FS
+         * bigger than that some day, but this code is likely to be
+         * irrelevant by then.  Meanwhile, it's more important to keep
+         * the chunk size small so the layout-calculation code that
+         * uses this value can be tested on normal machines.
+         */
+        bpc = (1 << 20) / statvfs->f_bsize;
+        chunks = (statvfs->f_blocks + bpc - 1) / bpc;
+    }
+
+    if (statvfs->f_files) {
+        percent_inodes = (statvfs->f_ffree * 100) / statvfs->f_files;
+    } else {
+        /*
+         * Set percent inodes to 100 for dynamically allocated inode
+         * filesystems. The rationale is that distribute need not
+         * worry about total inodes; rather, let the 'create()' be
+         * scheduled on the hashed subvol regardless of the total
+         * inodes.
+         */
+        percent_inodes = 100;
+    }
+
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++)
+            if (prev == conf->subvolumes[i]) {
+                conf->du_stats[i].avail_percent = percent;
+                conf->du_stats[i].avail_space = bytes;
+                conf->du_stats[i].avail_inodes = percent_inodes;
+                conf->du_stats[i].chunks = chunks;
+                conf->du_stats[i].total_blocks = statvfs->f_blocks;
+                conf->du_stats[i].avail_blocks = statvfs->f_bavail;
+                conf->du_stats[i].frsize = statvfs->f_frsize;
+
+                gf_msg_debug(this->name, 0,
+                             "subvolume '%s': avail_percent "
+                             "is: %.2f and avail_space "
+                             "is: %" PRIu64
+                             " and avail_inodes"
+                             " is: %.2f",
+                             prev->name, conf->du_stats[i].avail_percent,
+                             conf->du_stats[i].avail_space,
+                             conf->du_stats[i].avail_inodes);
+                break; /* no point in looping further */
+            }
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-	this_call_cnt = dht_frame_return (frame);
-	if (is_last_call (this_call_cnt))
-		DHT_STACK_DESTROY (frame);
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt))
+        DHT_STACK_DESTROY(frame);
 
-	return 0;
+    return 0;
 }
 
 int
-dht_get_du_info_for_subvol (xlator_t *this, int subvol_idx)
+dht_get_du_info_for_subvol(xlator_t *this, int subvol_idx)
 {
-	dht_conf_t    *conf         = NULL;
-	call_frame_t  *statfs_frame = NULL;
-	dht_local_t   *statfs_local = NULL;
-	call_pool_t   *pool         = NULL;
-	loc_t          tmp_loc      = {0,};
-
-	conf = this->private;
-	pool = this->ctx->pool;
-
-	statfs_frame = create_frame (this, pool);
-	if (!statfs_frame) {
-		goto err;
-	}
-
-	/* local->fop value is not used in this case */
-	statfs_local = dht_local_init (statfs_frame, NULL, NULL,
-				       GF_FOP_MAXVALUE);
-	if (!statfs_local) {
-		goto err;
-	}
-
-        /* make it root gfid, should be enough to get the proper info back */
-        tmp_loc.gfid[15] = 1;
-
-	statfs_local->call_cnt = 1;
-	STACK_WIND_COOKIE (statfs_frame, dht_du_info_cbk,
-		           conf->subvolumes[subvol_idx],
-                           conf->subvolumes[subvol_idx],
-		           conf->subvolumes[subvol_idx]->fops->statfs,
-		           &tmp_loc, NULL);
-
-	return 0;
+    dht_conf_t *conf = NULL;
+    call_frame_t *statfs_frame = NULL;
+    dht_local_t *statfs_local = NULL;
+    call_pool_t *pool = NULL;
+    loc_t tmp_loc = {
+        0,
+    };
+
+    conf = this->private;
+    pool = this->ctx->pool;
+
+    statfs_frame = create_frame(this, pool);
+    if (!statfs_frame) {
+        goto err;
+    }
+
+    /* local->fop value is not used in this case */
+    statfs_local = dht_local_init(statfs_frame, NULL, NULL, GF_FOP_MAXVALUE);
+    if (!statfs_local) {
+        goto err;
+    }
+
+    /* make it root gfid, should be enough to get the proper info back */
+    tmp_loc.gfid[15] = 1;
+
+    statfs_local->call_cnt = 1;
+    STACK_WIND_COOKIE(
+        statfs_frame, dht_du_info_cbk, conf->subvolumes[subvol_idx],
+        conf->subvolumes[subvol_idx],
+        conf->subvolumes[subvol_idx]->fops->statfs, &tmp_loc, NULL);
+
+    return 0;
 err:
-	if (statfs_frame)
-		DHT_STACK_DESTROY (statfs_frame);
+    if (statfs_frame)
+        DHT_STACK_DESTROY(statfs_frame);
 
-	return -1;
+    return -1;
 }
 
 int
-dht_get_du_info (call_frame_t *frame, xlator_t *this, loc_t *loc)
+dht_get_du_info(call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-	int            i            = 0;
-        int            ret          = -1;
-	dht_conf_t    *conf         = NULL;
-	call_frame_t  *statfs_frame = NULL;
-	dht_local_t   *statfs_local = NULL;
-	struct timeval tv           = {0,};
-        loc_t          tmp_loc      = {0,};
-
-	conf  = this->private;
-
-	gettimeofday (&tv, NULL);
-
-        /* make it root gfid, should be enough to get the proper
-           info back */
-        tmp_loc.gfid[15] = 1;
-
-	if (tv.tv_sec > (conf->refresh_interval
-			 + conf->last_stat_fetch.tv_sec)) {
-
-		statfs_frame = copy_frame (frame);
-		if (!statfs_frame) {
-			goto err;
-		}
-
-		/* In this case, 'local->fop' is not used */
-		statfs_local = dht_local_init (statfs_frame, loc, NULL,
-					       GF_FOP_MAXVALUE);
-		if (!statfs_local) {
-			goto err;
-		}
-
-                statfs_local->params = dict_new ();
-                if (!statfs_local->params)
-                        goto err;
-
-                ret = dict_set_int8 (statfs_local->params,
-                                     GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set "
-                                GF_INTERNAL_IGNORE_DEEM_STATFS" in dict");
-                        goto err;
-                }
+    int i = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    call_frame_t *statfs_frame = NULL;
+    dht_local_t *statfs_local = NULL;
+    struct timeval tv = {
+        0,
+    };
+    loc_t tmp_loc = {
+        0,
+    };
+
+    conf = this->private;
+
+    gettimeofday(&tv, NULL);
+
+    /* make it root gfid, should be enough to get the proper
+       info back */
+    tmp_loc.gfid[15] = 1;
+
+    if (tv.tv_sec > (conf->refresh_interval + conf->last_stat_fetch.tv_sec)) {
+        statfs_frame = copy_frame(frame);
+        if (!statfs_frame) {
+            goto err;
+        }
+
+        /* In this case, 'local->fop' is not used */
+        statfs_local = dht_local_init(statfs_frame, loc, NULL, GF_FOP_MAXVALUE);
+        if (!statfs_local) {
+            goto err;
+        }
+
+        statfs_local->params = dict_new();
+        if (!statfs_local->params)
+            goto err;
+
+        ret = dict_set_int8(statfs_local->params,
+                            GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
+            goto err;
+        }
+
+        statfs_local->call_cnt = conf->subvolume_cnt;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            STACK_WIND_COOKIE(statfs_frame, dht_du_info_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->statfs, &tmp_loc,
+                              statfs_local->params);
+        }
 
-		statfs_local->call_cnt = conf->subvolume_cnt;
-		for (i = 0; i < conf->subvolume_cnt; i++) {
-			STACK_WIND_COOKIE (statfs_frame, dht_du_info_cbk,
-				           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-				           conf->subvolumes[i]->fops->statfs,
-				           &tmp_loc, statfs_local->params);
-		}
-
-		conf->last_stat_fetch.tv_sec = tv.tv_sec;
-	}
-	return 0;
+        conf->last_stat_fetch.tv_sec = tv.tv_sec;
+    }
+    return 0;
 err:
-	if (statfs_frame)
-		DHT_STACK_DESTROY (statfs_frame);
+    if (statfs_frame)
+        DHT_STACK_DESTROY(statfs_frame);
 
-	return -1;
+    return -1;
 }
 
-
 gf_boolean_t
-dht_is_subvol_filled (xlator_t *this, xlator_t *subvol)
+dht_is_subvol_filled(xlator_t *this, xlator_t *subvol)
 {
-	int         i = 0;
-        char      vol_name[256];
-	dht_conf_t *conf = NULL;
-	gf_boolean_t subvol_filled_inodes = _gf_false;
-	gf_boolean_t subvol_filled_space = _gf_false;
-	gf_boolean_t is_subvol_filled = _gf_false;
-        double usage = 0;
-
-	conf = this->private;
-
-	/* Check for values above specified percent or free disk */
-	LOCK (&conf->subvolume_lock);
-	{
-		for (i = 0; i < conf->subvolume_cnt; i++) {
-			if (subvol == conf->subvolumes[i]) {
-				if (conf->disk_unit == 'p') {
-					if (conf->du_stats[i].avail_percent <
-					    conf->min_free_disk) {
-						subvol_filled_space = _gf_true;
-						break;
-					}
-
-				} else {
-					if (conf->du_stats[i].avail_space <
-					    conf->min_free_disk) {
-						subvol_filled_space = _gf_true;
-						break;
-					}
-				}
-				if (conf->du_stats[i].avail_inodes <
-				    conf->min_free_inodes) {
-					subvol_filled_inodes = _gf_true;
-					break;
-				}
-			}
-		}
-	}
-	UNLOCK (&conf->subvolume_lock);
-
-	if (subvol_filled_space && conf->subvolume_status[i]) {
-		if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
-                        usage = 100 - conf->du_stats[i].avail_percent;
-
-			gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_SUBVOL_INSUFF_SPACE,
-				"disk space on subvolume '%s' is getting "
-				"full (%.2f %%), consider adding more bricks",
-				subvol->name, usage);
-
-                        strncpy(vol_name, this->name, sizeof(vol_name));
-                        vol_name[(strlen(this->name)-4)] = '\0';
-
-                        gf_event(EVENT_DHT_DISK_USAGE,
-                                 "volume=%s;subvol=%s;usage=%.2f %%",
-                                 vol_name, subvol->name, usage);
-		}
-	}
-
-	if (subvol_filled_inodes && conf->subvolume_status[i]) {
-		if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
-                        usage = 100 - conf->du_stats[i].avail_inodes;
-			gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                                DHT_MSG_SUBVOL_INSUFF_INODES,
-				"inodes on subvolume '%s' are at "
-				"(%.2f %%), consider adding more bricks",
-				subvol->name, usage);
-
-                        strncpy(vol_name, this->name, sizeof(vol_name));
-                        vol_name[(strlen(this->name)-4)] = '\0';
-
-                        gf_event(EVENT_DHT_INODES_USAGE,
-                                 "volume=%s;subvol=%s;usage=%.2f %%",
-                                  vol_name, subvol->name, usage);
-		}
-	}
-
-	is_subvol_filled = (subvol_filled_space || subvol_filled_inodes);
-
-	return is_subvol_filled;
-}
+    int i = 0;
+    char vol_name[256];
+    dht_conf_t *conf = NULL;
+    gf_boolean_t subvol_filled_inodes = _gf_false;
+    gf_boolean_t subvol_filled_space = _gf_false;
+    gf_boolean_t is_subvol_filled = _gf_false;
+    double usage = 0;
+
+    conf = this->private;
+
+    /* Check for values above specified percent or free disk */
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (subvol == conf->subvolumes[i]) {
+                if (conf->disk_unit == 'p') {
+                    if (conf->du_stats[i].avail_percent < conf->min_free_disk) {
+                        subvol_filled_space = _gf_true;
+                        break;
+                    }
+
+                } else {
+                    if (conf->du_stats[i].avail_space < conf->min_free_disk) {
+                        subvol_filled_space = _gf_true;
+                        break;
+                    }
+                }
+                if (conf->du_stats[i].avail_inodes < conf->min_free_inodes) {
+                    subvol_filled_inodes = _gf_true;
+                    break;
+                }
+            }
+        }
+    }
+    UNLOCK(&conf->subvolume_lock);
 
+    if (subvol_filled_space && conf->subvolume_status[i]) {
+        if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
+            usage = 100 - conf->du_stats[i].avail_percent;
 
-/*Get the best subvolume to create the file in*/
-xlator_t *
-dht_free_disk_available_subvol (xlator_t *this, xlator_t *subvol,
-                                dht_local_t *local)
-{
-	xlator_t   *avail_subvol = NULL;
-	dht_conf_t *conf = NULL;
-        dht_layout_t *layout = NULL;
-        loc_t      *loc = NULL;
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+                   "disk space on subvolume '%s' is getting "
+                   "full (%.2f %%), consider adding more bricks",
+                   subvol->name, usage);
 
-	conf = this->private;
-        if (!local)
-                goto out;
-        loc = &local->loc;
-        if (!local->layout) {
-                layout = dht_layout_get (this, loc->parent);
-
-                if (!layout) {
-                        gf_msg_debug (this->name, 0,
-                                      "Missing layout. path=%s,"
-                                      " parent gfid = %s", loc->path,
-                                      uuid_utoa (loc->parent->gfid));
-                        goto out;
-                }
-        } else {
-                layout = dht_layout_ref (this, local->layout);
-        }
+            strncpy(vol_name, this->name, sizeof(vol_name));
+            vol_name[(strlen(this->name) - 4)] = '\0';
 
-        LOCK (&conf->subvolume_lock);
-	{
-                avail_subvol = dht_subvol_with_free_space_inodes(this, subvol, NULL,
-                                                                 layout, 0);
-                if(!avail_subvol)
-                {
-                        avail_subvol = dht_subvol_maxspace_nonzeroinode(this,
-                                                                        subvol,
-                                                                        layout);
-                }
+            gf_event(EVENT_DHT_DISK_USAGE, "volume=%s;subvol=%s;usage=%.2f %%",
+                     vol_name, subvol->name, usage);
+        }
+    }
+
+    if (subvol_filled_inodes && conf->subvolume_status[i]) {
+        if (!(conf->du_stats[i].log++ % (GF_UNIVERSAL_ANSWER * 10))) {
+            usage = 100 - conf->du_stats[i].avail_inodes;
+            gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_SUBVOL_INSUFF_INODES,
+                   "inodes on subvolume '%s' are at "
+                   "(%.2f %%), consider adding more bricks",
+                   subvol->name, usage);
+
+            strncpy(vol_name, this->name, sizeof(vol_name));
+            vol_name[(strlen(this->name) - 4)] = '\0';
+
+            gf_event(EVENT_DHT_INODES_USAGE,
+                     "volume=%s;subvol=%s;usage=%.2f %%", vol_name,
+                     subvol->name, usage);
+        }
+    }
 
-	}
-	UNLOCK (&conf->subvolume_lock);
-out:
-	if (!avail_subvol) {
-		gf_msg_debug (this->name, 0,
-		              "No subvolume has enough free space \
-                              and/or inodes to create");
-                avail_subvol = subvol;
-	}
+    is_subvol_filled = (subvol_filled_space || subvol_filled_inodes);
 
-        if (layout)
-                dht_layout_unref (this, layout);
-	return avail_subvol;
+    return is_subvol_filled;
 }
 
-static inline
-int32_t dht_subvol_has_err (dht_conf_t *conf, xlator_t *this, xlator_t *ignore,
-                            dht_layout_t *layout)
+/*Get the best subvolume to create the file in*/
+xlator_t *
+dht_free_disk_available_subvol(xlator_t *this, xlator_t *subvol,
+                               dht_local_t *local)
 {
-        int ret = -1;
-        int i   = 0;
-
-        if (!this || !layout)
-                goto out;
-
-        /* this check is meant for rebalance process. The source of the file
-         * should be ignored for space check */
-        if (this == ignore) {
-                goto out;
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    loc_t *loc = NULL;
+
+    conf = this->private;
+    if (!local)
+        goto out;
+    loc = &local->loc;
+    if (!local->layout) {
+        layout = dht_layout_get(this, loc->parent);
+
+        if (!layout) {
+            gf_msg_debug(this->name, 0,
+                         "Missing layout. path=%s,"
+                         " parent gfid = %s",
+                         loc->path, uuid_utoa(loc->parent->gfid));
+            goto out;
+        }
+    } else {
+        layout = dht_layout_ref(this, local->layout);
+    }
+
+    LOCK(&conf->subvolume_lock);
+    {
+        avail_subvol = dht_subvol_with_free_space_inodes(this, subvol, NULL,
+                                                         layout, 0);
+        if (!avail_subvol) {
+            avail_subvol = dht_subvol_maxspace_nonzeroinode(this, subvol,
+                                                            layout);
         }
+    }
+    UNLOCK(&conf->subvolume_lock);
+out:
+    if (!avail_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "No subvolume has enough free space \
+                              and/or inodes to create");
+        avail_subvol = subvol;
+    }
 
+    if (layout)
+        dht_layout_unref(this, layout);
+    return avail_subvol;
+}
 
-        /* check if subvol has layout errors, before selecting it */
-        for (i = 0; i < layout->cnt; i++) {
-                if (!strcmp (layout->list[i].xlator->name, this->name) &&
-                     (layout->list[i].err != 0)) {
-                        ret = -1;
-                        goto out;
-                }
+static inline int32_t
+dht_subvol_has_err(dht_conf_t *conf, xlator_t *this, xlator_t *ignore,
+                   dht_layout_t *layout)
+{
+    int ret = -1;
+    int i = 0;
+
+    if (!this || !layout)
+        goto out;
+
+    /* this check is meant for rebalance process. The source of the file
+     * should be ignored for space check */
+    if (this == ignore) {
+        goto out;
+    }
+
+    /* check if subvol has layout errors, before selecting it */
+    for (i = 0; i < layout->cnt; i++) {
+        if (!strcmp(layout->list[i].xlator->name, this->name) &&
+            (layout->list[i].err != 0)) {
+            ret = -1;
+            goto out;
         }
+    }
 
-        /* discard decommissioned subvol */
-        if (conf->decommission_subvols_cnt) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->decommissioned_bricks[i] &&
-                            conf->decommissioned_bricks[i] == this) {
-                                ret = -1;
-                                goto out;
-                        }
-                }
+    /* discard decommissioned subvol */
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == this) {
+                ret = -1;
+                goto out;
+            }
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /*Get subvolume which has both space and inodes more than the min criteria*/
 xlator_t *
-dht_subvol_with_free_space_inodes(xlator_t *this, xlator_t *subvol, xlator_t *ignore,
-                                  dht_layout_t *layout, uint64_t filesize)
+dht_subvol_with_free_space_inodes(xlator_t *this, xlator_t *subvol,
+                                  xlator_t *ignore, dht_layout_t *layout,
+                                  uint64_t filesize)
 {
-        int i = 0;
-        double max = 0;
-        double max_inodes = 0;
-        int    ignore_subvol = 0;
-        uint64_t total_blocks = 0;
-        uint64_t avail_blocks = 0;
-        uint64_t frsize = 0;
-        double   post_availspace = 0;
-        double   post_percent = 0;
-
-        xlator_t *avail_subvol = NULL;
-        dht_conf_t *conf = NULL;
-
-        conf = this->private;
-
-        for(i=0; i < conf->subvolume_cnt; i++) {
-                /* check if subvol has layout errors and also it is not a
-                 * decommissioned brick, before selecting it */
-                ignore_subvol = dht_subvol_has_err (conf, conf->subvolumes[i],
-                                                    ignore, layout);
-                if (ignore_subvol)
-                        continue;
-
-                if ((conf->disk_unit == 'p') &&
-                    (conf->du_stats[i].avail_percent > conf->min_free_disk) &&
-                    (conf->du_stats[i].avail_inodes  > conf->min_free_inodes)) {
-                        if ((conf->du_stats[i].avail_inodes > max_inodes) ||
-                            (conf->du_stats[i].avail_percent > max)) {
-                                max = conf->du_stats[i].avail_percent;
-                                max_inodes = conf->du_stats[i].avail_inodes;
-                                avail_subvol = conf->subvolumes[i];
-                                total_blocks = conf->du_stats[i].total_blocks;
-                                avail_blocks = conf->du_stats[i].avail_blocks;
-                                frsize       = conf->du_stats[i].frsize;
-                        }
-                }
-
-                if ((conf->disk_unit != 'p') &&
-                    (conf->du_stats[i].avail_space > conf->min_free_disk) &&
-                    (conf->du_stats[i].avail_inodes  > conf->min_free_inodes)) {
-                        if ((conf->du_stats[i].avail_inodes > max_inodes) ||
-                            (conf->du_stats[i].avail_space > max)) {
-                                max = conf->du_stats[i].avail_space;
-                                max_inodes = conf->du_stats[i].avail_inodes;
-                                avail_subvol = conf->subvolumes[i];
-                        }
-                }
+    int i = 0;
+    double max = 0;
+    double max_inodes = 0;
+    int ignore_subvol = 0;
+    uint64_t total_blocks = 0;
+    uint64_t avail_blocks = 0;
+    uint64_t frsize = 0;
+    double post_availspace = 0;
+    double post_percent = 0;
+
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        /* check if subvol has layout errors and also it is not a
+         * decommissioned brick, before selecting it */
+        ignore_subvol = dht_subvol_has_err(conf, conf->subvolumes[i], ignore,
+                                           layout);
+        if (ignore_subvol)
+            continue;
+
+        if ((conf->disk_unit == 'p') &&
+            (conf->du_stats[i].avail_percent > conf->min_free_disk) &&
+            (conf->du_stats[i].avail_inodes > conf->min_free_inodes)) {
+            if ((conf->du_stats[i].avail_inodes > max_inodes) ||
+                (conf->du_stats[i].avail_percent > max)) {
+                max = conf->du_stats[i].avail_percent;
+                max_inodes = conf->du_stats[i].avail_inodes;
+                avail_subvol = conf->subvolumes[i];
+                total_blocks = conf->du_stats[i].total_blocks;
+                avail_blocks = conf->du_stats[i].avail_blocks;
+                frsize = conf->du_stats[i].frsize;
+            }
         }
 
-        if (avail_subvol) {
-                if (conf->disk_unit == 'p') {
-                        post_availspace = (avail_blocks * frsize) - filesize;
-                        post_percent = (post_availspace * 100) / (total_blocks * frsize);
-                        if (post_percent < conf->min_free_disk)
-                                avail_subvol = NULL;
-                }
-                if (conf->disk_unit != 'p') {
-                        if ((max - filesize) < conf->min_free_disk)
-                                avail_subvol = NULL;
-                }
+        if ((conf->disk_unit != 'p') &&
+            (conf->du_stats[i].avail_space > conf->min_free_disk) &&
+            (conf->du_stats[i].avail_inodes > conf->min_free_inodes)) {
+            if ((conf->du_stats[i].avail_inodes > max_inodes) ||
+                (conf->du_stats[i].avail_space > max)) {
+                max = conf->du_stats[i].avail_space;
+                max_inodes = conf->du_stats[i].avail_inodes;
+                avail_subvol = conf->subvolumes[i];
+            }
         }
+    }
+
+    if (avail_subvol) {
+        if (conf->disk_unit == 'p') {
+            post_availspace = (avail_blocks * frsize) - filesize;
+            post_percent = (post_availspace * 100) / (total_blocks * frsize);
+            if (post_percent < conf->min_free_disk)
+                avail_subvol = NULL;
+        }
+        if (conf->disk_unit != 'p') {
+            if ((max - filesize) < conf->min_free_disk)
+                avail_subvol = NULL;
+        }
+    }
 
-        return avail_subvol;
+    return avail_subvol;
 }
 
-
 /* Get subvol which has at least one inode and maximum space */
 xlator_t *
-dht_subvol_maxspace_nonzeroinode (xlator_t *this, xlator_t *subvol,
-                                  dht_layout_t *layout)
+dht_subvol_maxspace_nonzeroinode(xlator_t *this, xlator_t *subvol,
+                                 dht_layout_t *layout)
 {
-        int         i = 0;
-        double      max = 0;
-        int         ignore_subvol = 0;
-
-        xlator_t   *avail_subvol = NULL;
-        dht_conf_t *conf = NULL;
-
-        conf = this->private;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                /* check if subvol has layout errors and also it is not a
-                 * decommissioned brick, before selecting it*/
-
-                ignore_subvol = dht_subvol_has_err (conf, conf->subvolumes[i], NULL,
-                                                    layout);
-                if (ignore_subvol)
-                        continue;
-
-                if (conf->disk_unit == 'p') {
-                        if ((conf->du_stats[i].avail_percent > max)
-                            && (conf->du_stats[i].avail_inodes > 0 )) {
-                                max = conf->du_stats[i].avail_percent;
-                                avail_subvol = conf->subvolumes[i];
-                        }
-               } else {
-                         if ((conf->du_stats[i].avail_space > max)
-                            && (conf->du_stats[i].avail_inodes > 0)) {
-                                 max = conf->du_stats[i].avail_space;
-                                 avail_subvol = conf->subvolumes[i];
-                         }
-               }
+    int i = 0;
+    double max = 0;
+    int ignore_subvol = 0;
+
+    xlator_t *avail_subvol = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        /* check if subvol has layout errors and also it is not a
+         * decommissioned brick, before selecting it*/
+
+        ignore_subvol = dht_subvol_has_err(conf, conf->subvolumes[i], NULL,
+                                           layout);
+        if (ignore_subvol)
+            continue;
+
+        if (conf->disk_unit == 'p') {
+            if ((conf->du_stats[i].avail_percent > max) &&
+                (conf->du_stats[i].avail_inodes > 0)) {
+                max = conf->du_stats[i].avail_percent;
+                avail_subvol = conf->subvolumes[i];
+            }
+        } else {
+            if ((conf->du_stats[i].avail_space > max) &&
+                (conf->du_stats[i].avail_inodes > 0)) {
+                max = conf->du_stats[i].avail_space;
+                avail_subvol = conf->subvolumes[i];
+            }
         }
+    }
 
-        return avail_subvol;
+    return avail_subvol;
 }
diff --git a/xlators/cluster/dht/src/dht-hashfn.c b/xlators/cluster/dht/src/dht-hashfn.c
index f8e614a40aa..2f15c0370cc 100644
--- a/xlators/cluster/dht/src/dht-hashfn.c
+++ b/xlators/cluster/dht/src/dht-hashfn.c
@@ -8,104 +8,98 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "glusterfs.h"
 #include "xlator.h"
 #include "dht-common.h"
 #include "hashfn.h"
 
-
 int
-dht_hash_compute_internal (int type, const char *name, uint32_t *hash_p)
+dht_hash_compute_internal(int type, const char *name, uint32_t *hash_p)
 {
-        int      ret = 0;
-        uint32_t hash = 0;
+    int ret = 0;
+    uint32_t hash = 0;
 
-        switch (type) {
+    switch (type) {
         case DHT_HASH_TYPE_DM:
         case DHT_HASH_TYPE_DM_USER:
-                hash = gf_dm_hashfn (name, strlen (name));
-                break;
+            hash = gf_dm_hashfn(name, strlen(name));
+            break;
         default:
-                ret = -1;
-                break;
-        }
+            ret = -1;
+            break;
+    }
 
-        if (ret == 0) {
-                *hash_p = hash;
-        }
+    if (ret == 0) {
+        *hash_p = hash;
+    }
 
-        return ret;
+    return ret;
 }
 
-
-static
-gf_boolean_t
-dht_munge_name (const char *original, char *modified,
-                size_t len, regex_t *re)
+static gf_boolean_t
+dht_munge_name(const char *original, char *modified, size_t len, regex_t *re)
 {
-        regmatch_t  matches[2] = {{0}, };
-        size_t      new_len    = 0;
-        int         ret        = 0;
-
-        ret = regexec(re, original, 2, matches, 0);
-
-        if (ret != REG_NOMATCH) {
-                if (matches[1].rm_so != -1) {
-                        new_len = matches[1].rm_eo - matches[1].rm_so;
-                        /* Equal would fail due to the NUL at the end. */
-                        if (new_len < len) {
-                                memcpy (modified,original+matches[1].rm_so,
-                                        new_len);
-                                modified[new_len] = '\0';
-                                return _gf_true;
-                        }
-                }
+    regmatch_t matches[2] = {
+        {0},
+    };
+    size_t new_len = 0;
+    int ret = 0;
+
+    ret = regexec(re, original, 2, matches, 0);
+
+    if (ret != REG_NOMATCH) {
+        if (matches[1].rm_so != -1) {
+            new_len = matches[1].rm_eo - matches[1].rm_so;
+            /* Equal would fail due to the NUL at the end. */
+            if (new_len < len) {
+                memcpy(modified, original + matches[1].rm_so, new_len);
+                modified[new_len] = '\0';
+                return _gf_true;
+            }
         }
+    }
 
-        /* This is guaranteed safe because of how the dest was allocated. */
-        strcpy(modified, original);
-        return _gf_false;
+    /* This is guaranteed safe because of how the dest was allocated. */
+    strcpy(modified, original);
+    return _gf_false;
 }
 
 int
-dht_hash_compute (xlator_t *this, int type, const char *name, uint32_t *hash_p)
+dht_hash_compute(xlator_t *this, int type, const char *name, uint32_t *hash_p)
 {
-        char            *rsync_friendly_name    = NULL;
-        dht_conf_t      *priv                   = NULL;
-        size_t           len                    = 0;
-        gf_boolean_t     munged                 = _gf_false;
-
-        priv = this->private;
-
-        LOCK (&priv->lock);
-        {
-                if (priv->extra_regex_valid) {
-                        len = strlen(name) + 1;
-                        rsync_friendly_name = alloca(len);
-                        munged = dht_munge_name (name, rsync_friendly_name, len,
-                                                 &priv->extra_regex);
-                }
-
-                if (!munged && priv->rsync_regex_valid) {
-                        len = strlen(name) + 1;
-                        rsync_friendly_name = alloca(len);
-                        gf_msg_trace (this->name, 0, "trying regex for %s",
-                                      name);
-                        munged = dht_munge_name (name, rsync_friendly_name, len,
-                                                 &priv->rsync_regex);
-                        if (munged) {
-                                gf_msg_debug (this->name, 0,
-                                              "munged down to %s",
-                                              rsync_friendly_name);
-                        }
-                }
+    char *rsync_friendly_name = NULL;
+    dht_conf_t *priv = NULL;
+    size_t len = 0;
+    gf_boolean_t munged = _gf_false;
+
+    priv = this->private;
+
+    LOCK(&priv->lock);
+    {
+        if (priv->extra_regex_valid) {
+            len = strlen(name) + 1;
+            rsync_friendly_name = alloca(len);
+            munged = dht_munge_name(name, rsync_friendly_name, len,
+                                    &priv->extra_regex);
         }
-        UNLOCK (&priv->lock);
 
-        if (!munged) {
-                rsync_friendly_name = (char *)name;
+        if (!munged && priv->rsync_regex_valid) {
+            len = strlen(name) + 1;
+            rsync_friendly_name = alloca(len);
+            gf_msg_trace(this->name, 0, "trying regex for %s", name);
+            munged = dht_munge_name(name, rsync_friendly_name, len,
+                                    &priv->rsync_regex);
+            if (munged) {
+                gf_msg_debug(this->name, 0, "munged down to %s",
+                             rsync_friendly_name);
+            }
         }
+    }
+    UNLOCK(&priv->lock);
+
+    if (!munged) {
+        rsync_friendly_name = (char *)name;
+    }
 
-        return dht_hash_compute_internal (type, rsync_friendly_name, hash_p);
+    return dht_hash_compute_internal(type, rsync_friendly_name, hash_p);
 }
diff --git a/xlators/cluster/dht/src/dht-helper.c b/xlators/cluster/dht/src/dht-helper.c
index 403f0a0f514..6d6ec24729d 100644
--- a/xlators/cluster/dht/src/dht-helper.c
+++ b/xlators/cluster/dht/src/dht-helper.c
@@ -8,266 +8,249 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "glusterfs.h"
 #include "xlator.h"
 #include "dht-common.h"
 #include "dht-lock.h"
 
 static void
-dht_free_fd_ctx (dht_fd_ctx_t *fd_ctx)
+dht_free_fd_ctx(dht_fd_ctx_t *fd_ctx)
 {
-        GF_FREE (fd_ctx);
+    GF_FREE(fd_ctx);
 }
 
-
 int32_t
-dht_fd_ctx_destroy (xlator_t *this, fd_t *fd)
+dht_fd_ctx_destroy(xlator_t *this, fd_t *fd)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int32_t       ret     = -1;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int32_t ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
 
-        ret = fd_ctx_del (fd, this, &value);
-        if (ret) {
-                goto out;
-        }
+    ret = fd_ctx_del(fd, this, &value);
+    if (ret) {
+        goto out;
+    }
 
-        fd_ctx = (dht_fd_ctx_t *)value;
-        if (fd_ctx) {
-                GF_REF_PUT (fd_ctx);
-        }
+    fd_ctx = (dht_fd_ctx_t *)value;
+    if (fd_ctx) {
+        GF_REF_PUT(fd_ctx);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__dht_fd_ctx_set (xlator_t *this, fd_t *fd, xlator_t *dst)
+__dht_fd_ctx_set(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int           ret     = -1;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
 
-        fd_ctx = GF_CALLOC (1, sizeof (*fd_ctx), gf_dht_mt_fd_ctx_t);
+    fd_ctx = GF_CALLOC(1, sizeof(*fd_ctx), gf_dht_mt_fd_ctx_t);
 
-        if (!fd_ctx) {
-                goto out;
-        }
+    if (!fd_ctx) {
+        goto out;
+    }
 
-        fd_ctx->opened_on_dst = (uint64_t) dst;
-        GF_REF_INIT (fd_ctx, dht_free_fd_ctx);
+    fd_ctx->opened_on_dst = (uint64_t)dst;
+    GF_REF_INIT(fd_ctx, dht_free_fd_ctx);
 
-        value = (uint64_t) fd_ctx;
+    value = (uint64_t)fd_ctx;
 
-        ret = __fd_ctx_set (fd, this, value);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_FD_CTX_SET_FAILED,
-                        "Failed to set fd ctx in fd=0x%p", fd);
-                GF_REF_PUT (fd_ctx);
-        }
+    ret = __fd_ctx_set(fd, this, value);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_FD_CTX_SET_FAILED,
+               "Failed to set fd ctx in fd=0x%p", fd);
+        GF_REF_PUT(fd_ctx);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_fd_ctx_set (xlator_t *this, fd_t *fd, xlator_t *dst)
+dht_fd_ctx_set(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        uint64_t      value   = 0;
-        int           ret     = -1;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
-
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, this, &value);
-                if (ret && value) {
-
-                        fd_ctx = (dht_fd_ctx_t *) value;
-                        if (fd_ctx->opened_on_dst == (uint64_t) dst)  {
-                                /* This could happen due to racing
-                                 * check_progress tasks*/
-                                goto unlock;
-                        } else {
-                                /* This would be a big problem*/
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_INVALID_VALUE,
-                                        "Different dst found in the fd ctx");
-
-                                /* Overwrite and hope for the best*/
-                                fd_ctx->opened_on_dst = (uint64_t)dst;
-                                goto unlock;
-                        }
+    dht_fd_ctx_t *fd_ctx = NULL;
+    uint64_t value = 0;
+    int ret = -1;
+
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
+
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, this, &value);
+        if (ret && value) {
+            fd_ctx = (dht_fd_ctx_t *)value;
+            if (fd_ctx->opened_on_dst == (uint64_t)dst) {
+                /* This could happen due to racing
+                 * check_progress tasks*/
+                goto unlock;
+            } else {
+                /* This would be a big problem*/
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_VALUE,
+                       "Different dst found in the fd ctx");
 
-                }
-                ret = __dht_fd_ctx_set (this, fd, dst);
+                /* Overwrite and hope for the best*/
+                fd_ctx->opened_on_dst = (uint64_t)dst;
+                goto unlock;
+            }
         }
+        ret = __dht_fd_ctx_set(this, fd, dst);
+    }
 unlock:
-        UNLOCK (&fd->lock);
+    UNLOCK(&fd->lock);
 out:
-        return ret;
+    return ret;
 }
 
-
-
-static
-dht_fd_ctx_t *
-dht_fd_ctx_get (xlator_t *this, fd_t *fd)
+static dht_fd_ctx_t *
+dht_fd_ctx_get(xlator_t *this, fd_t *fd)
 {
-        dht_fd_ctx_t *fd_ctx  = NULL;
-        int           ret     = -1;
-        uint64_t      tmp_val = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, fd, out);
-
-        LOCK (&fd->lock);
-        {
-                ret = __fd_ctx_get (fd, this, &tmp_val);
-                if ((ret < 0) || (tmp_val == 0)) {
-                        UNLOCK (&fd->lock);
-                        goto out;
-                }
+    dht_fd_ctx_t *fd_ctx = NULL;
+    int ret = -1;
+    uint64_t tmp_val = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, fd, out);
 
-                fd_ctx = (dht_fd_ctx_t *)tmp_val;
-                GF_REF_GET (fd_ctx);
+    LOCK(&fd->lock);
+    {
+        ret = __fd_ctx_get(fd, this, &tmp_val);
+        if ((ret < 0) || (tmp_val == 0)) {
+            UNLOCK(&fd->lock);
+            goto out;
         }
-        UNLOCK (&fd->lock);
+
+        fd_ctx = (dht_fd_ctx_t *)tmp_val;
+        GF_REF_GET(fd_ctx);
+    }
+    UNLOCK(&fd->lock);
 
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
 gf_boolean_t
-dht_fd_open_on_dst (xlator_t *this, fd_t *fd, xlator_t *dst)
+dht_fd_open_on_dst(xlator_t *this, fd_t *fd, xlator_t *dst)
 {
-        dht_fd_ctx_t  *fd_ctx  = NULL;
-        gf_boolean_t   opened  = _gf_false;
+    dht_fd_ctx_t *fd_ctx = NULL;
+    gf_boolean_t opened = _gf_false;
 
-        fd_ctx = dht_fd_ctx_get (this, fd);
+    fd_ctx = dht_fd_ctx_get(this, fd);
 
-        if (fd_ctx) {
-                if (fd_ctx->opened_on_dst == (uint64_t) dst) {
-                        opened = _gf_true;
-                }
-                GF_REF_PUT (fd_ctx);
+    if (fd_ctx) {
+        if (fd_ctx->opened_on_dst == (uint64_t)dst) {
+            opened = _gf_true;
         }
+        GF_REF_PUT(fd_ctx);
+    }
 
-        return opened;
+    return opened;
 }
 
-
 void
-dht_free_mig_info (void *data)
+dht_free_mig_info(void *data)
 {
-        dht_migrate_info_t *miginfo = NULL;
+    dht_migrate_info_t *miginfo = NULL;
 
-        miginfo = data;
-        GF_FREE (miginfo);
+    miginfo = data;
+    GF_FREE(miginfo);
 
-        return;
+    return;
 }
 
 static int
-dht_inode_ctx_set_mig_info (xlator_t *this, inode_t *inode,
-                            xlator_t *src_subvol, xlator_t *dst_subvol)
+dht_inode_ctx_set_mig_info(xlator_t *this, inode_t *inode, xlator_t *src_subvol,
+                           xlator_t *dst_subvol)
 {
-        dht_migrate_info_t *miginfo = NULL;
-        uint64_t            value   = 0;
-        int                 ret     = -1;
+    dht_migrate_info_t *miginfo = NULL;
+    uint64_t value = 0;
+    int ret = -1;
 
-        miginfo = GF_CALLOC (1, sizeof (*miginfo), gf_dht_mt_miginfo_t);
-        if (miginfo == NULL)
-                goto out;
+    miginfo = GF_CALLOC(1, sizeof(*miginfo), gf_dht_mt_miginfo_t);
+    if (miginfo == NULL)
+        goto out;
 
-        miginfo->src_subvol = src_subvol;
-        miginfo->dst_subvol = dst_subvol;
-        GF_REF_INIT (miginfo, dht_free_mig_info);
+    miginfo->src_subvol = src_subvol;
+    miginfo->dst_subvol = dst_subvol;
+    GF_REF_INIT(miginfo, dht_free_mig_info);
 
-        value = (uint64_t) miginfo;
+    value = (uint64_t)miginfo;
 
-        ret = inode_ctx_set1 (inode, this, &value);
-        if (ret < 0) {
-                GF_REF_PUT (miginfo);
-        }
+    ret = inode_ctx_set1(inode, this, &value);
+    if (ret < 0) {
+        GF_REF_PUT(miginfo);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_inode_ctx_get_mig_info (xlator_t *this, inode_t *inode,
-                            xlator_t **src_subvol, xlator_t **dst_subvol)
+dht_inode_ctx_get_mig_info(xlator_t *this, inode_t *inode,
+                           xlator_t **src_subvol, xlator_t **dst_subvol)
 {
-        int                 ret         = -1;
-        uint64_t            tmp_miginfo = 0;
-        dht_migrate_info_t *miginfo     = NULL;
-
-        LOCK (&inode->lock);
-        {
-                ret =  __inode_ctx_get1 (inode, this, &tmp_miginfo);
-                if ((ret < 0) || (tmp_miginfo == 0)) {
-                        UNLOCK (&inode->lock);
-                        goto out;
-                }
+    int ret = -1;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
 
-                miginfo = (dht_migrate_info_t *)tmp_miginfo;
-                GF_REF_GET (miginfo);
+    LOCK(&inode->lock);
+    {
+        ret = __inode_ctx_get1(inode, this, &tmp_miginfo);
+        if ((ret < 0) || (tmp_miginfo == 0)) {
+            UNLOCK(&inode->lock);
+            goto out;
         }
-        UNLOCK (&inode->lock);
 
-        if (src_subvol)
-                *src_subvol = miginfo->src_subvol;
+        miginfo = (dht_migrate_info_t *)tmp_miginfo;
+        GF_REF_GET(miginfo);
+    }
+    UNLOCK(&inode->lock);
+
+    if (src_subvol)
+        *src_subvol = miginfo->src_subvol;
 
-        if (dst_subvol)
-                *dst_subvol = miginfo->dst_subvol;
+    if (dst_subvol)
+        *dst_subvol = miginfo->dst_subvol;
 
-        GF_REF_PUT (miginfo);
+    GF_REF_PUT(miginfo);
 
 out:
-        return ret;
+    return ret;
 }
 
 gf_boolean_t
-dht_mig_info_is_invalid (xlator_t *current, xlator_t *src_subvol,
-                      xlator_t *dst_subvol)
+dht_mig_info_is_invalid(xlator_t *current, xlator_t *src_subvol,
+                        xlator_t *dst_subvol)
 {
-
-/* Not set
- */
-        if (!src_subvol || !dst_subvol)
-                return _gf_true;
-
-/* Invalid scenarios:
- * The src_subvol does not match the subvol on which the current op was sent
- * so the cached subvol has changed between the last mig_info_set and now.
- * src_subvol == dst_subvol. The file was migrated without any FOP detecting
- * a P2 so the old dst is now the current subvol.
- *
- * There is still one scenario where the info could be outdated - if
- * file has undergone multiple migrations and ends up on the same src_subvol
- * on which the mig_info was first set.
- */
-        if ((current == dst_subvol) || (current != src_subvol))
-                return _gf_true;
-
-        return _gf_false;
+    /* Not set
+     */
+    if (!src_subvol || !dst_subvol)
+        return _gf_true;
+
+    /* Invalid scenarios:
+     * The src_subvol does not match the subvol on which the current op was sent
+     * so the cached subvol has changed between the last mig_info_set and now.
+     * src_subvol == dst_subvol. The file was migrated without any FOP detecting
+     * a P2 so the old dst is now the current subvol.
+     *
+     * There is still one scenario where the info could be outdated - if
+     * file has undergone multiple migrations and ends up on the same src_subvol
+     * on which the mig_info was first set.
+     */
+    if ((current == dst_subvol) || (current != src_subvol))
+        return _gf_true;
+
+    return _gf_false;
 }
 
-
-
 /* Used to check if fd fops have the fd opened on the cached subvol
  * This is required when:
  * 1. an fd is opened on FILE1 on subvol1
@@ -279,337 +262,304 @@ dht_mig_info_is_invalid (xlator_t *current, xlator_t *src_subvol,
  *
  */
 
-
 int
-dht_check_and_open_fd_on_subvol_complete (int ret, call_frame_t *frame,
-                                          void *data)
+dht_check_and_open_fd_on_subvol_complete(int ret, call_frame_t *frame,
+                                         void *data)
 {
-        glusterfs_fop_t     fop     = 0;
-        dht_local_t        *local   = NULL;
-        xlator_t           *subvol  = NULL;
-        xlator_t           *this  = NULL;
-        fd_t               *fd      = NULL;
-        int                 op_errno = -1;
-
-        local = frame->local;
-        this = frame->this;
-        fop = local->fop;
-        subvol = local->cached_subvol;
-        fd = local->fd;
-
-        if (ret) {
-                op_errno = local->op_errno;
-                goto handle_err;
-        }
-
-        switch (fop) {
-
+    glusterfs_fop_t fop = 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *this = NULL;
+    fd_t *fd = NULL;
+    int op_errno = -1;
+
+    local = frame->local;
+    this = frame->this;
+    fop = local->fop;
+    subvol = local->cached_subvol;
+    fd = local->fd;
+
+    if (ret) {
+        op_errno = local->op_errno;
+        goto handle_err;
+    }
+
+    switch (fop) {
         case GF_FOP_WRITE:
-                STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol, subvol,
-                                   subvol->fops->writev, fd,
-                                   local->rebalance.vector,
-                                   local->rebalance.count,
-                                   local->rebalance.offset,
-                                   local->rebalance.flags,
-                                   local->rebalance.iobref, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                              subvol->fops->writev, fd, local->rebalance.vector,
+                              local->rebalance.count, local->rebalance.offset,
+                              local->rebalance.flags, local->rebalance.iobref,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FLUSH:
-                STACK_WIND (frame, dht_flush_cbk, subvol,
-                            subvol->fops->flush, fd, local->xattr_req);
-                break;
+            STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, fd,
+                       local->xattr_req);
+            break;
 
         case GF_FOP_FSETATTR:
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, fd,
-                                   &local->rebalance.stbuf,
-                                   local->rebalance.flags,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                              subvol->fops->fsetattr, fd,
+                              &local->rebalance.stbuf, local->rebalance.flags,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_ZEROFILL:
-                STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                                   subvol->fops->zerofill, fd,
-                                   local->rebalance.offset,
-                                   local->rebalance.size, local->xattr_req);
+            STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                              subvol->fops->zerofill, fd,
+                              local->rebalance.offset, local->rebalance.size,
+                              local->xattr_req);
 
-                break;
+            break;
 
         case GF_FOP_DISCARD:
-                STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                                   subvol->fops->discard, local->fd,
-                                   local->rebalance.offset,
-                                   local->rebalance.size,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                              subvol->fops->discard, local->fd,
+                              local->rebalance.offset, local->rebalance.size,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FALLOCATE:
-                STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                                   subvol->fops->fallocate, fd,
-                                   local->rebalance.flags,
-                                   local->rebalance.offset,
-                                   local->rebalance.size,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                              subvol->fops->fallocate, fd,
+                              local->rebalance.flags, local->rebalance.offset,
+                              local->rebalance.size, local->xattr_req);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->ftruncate, fd,
-                                   local->rebalance.offset, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                              subvol->fops->ftruncate, fd,
+                              local->rebalance.offset, local->xattr_req);
+            break;
 
         case GF_FOP_FSYNC:
-                STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                                   subvol->fops->fsync, local->fd,
-                                   local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol,
+                              subvol->fops->fsync, local->fd,
+                              local->rebalance.flags, local->xattr_req);
+            break;
 
         case GF_FOP_READ:
-                STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                            local->fd, local->rebalance.size,
-                            local->rebalance.offset,
-                            local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv,
+                       local->fd, local->rebalance.size,
+                       local->rebalance.offset, local->rebalance.flags,
+                       local->xattr_req);
+            break;
 
         case GF_FOP_FSTAT:
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol,
-                                   subvol, subvol->fops->fstat, fd,
-                                   local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                              subvol->fops->fstat, fd, local->xattr_req);
+            break;
 
         case GF_FOP_FSETXATTR:
-                STACK_WIND_COOKIE (frame, dht_file_setxattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetxattr, local->fd,
-                                   local->rebalance.xattr,
-                                   local->rebalance.flags, local->xattr_req);
-                break;
+            STACK_WIND_COOKIE(frame, dht_file_setxattr_cbk, subvol, subvol,
+                              subvol->fops->fsetxattr, local->fd,
+                              local->rebalance.xattr, local->rebalance.flags,
+                              local->xattr_req);
+            break;
 
         case GF_FOP_FREMOVEXATTR:
-                STACK_WIND_COOKIE (frame, dht_file_removexattr_cbk, subvol,
-                                   subvol, subvol->fops->fremovexattr,
-                                   local->fd, local->key, local->xattr_req);
+            STACK_WIND_COOKIE(frame, dht_file_removexattr_cbk, subvol, subvol,
+                              subvol->fops->fremovexattr, local->fd, local->key,
+                              local->xattr_req);
 
-                break;
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_UNKNOWN_FOP,
-                        "Unknown FOP on fd (%p) on file %s @ %s",
-                        fd, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                break;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UNKNOWN_FOP,
+                   "Unknown FOP on fd (%p) on file %s @ %s", fd,
+                   uuid_utoa(fd->inode->gfid), subvol->name);
+            break;
+    }
 
-        }
+    goto out;
 
-        goto out;
-
-        /* Could not open the fd on the dst. Unwind */
+    /* Could not open the fd on the dst. Unwind */
 
 handle_err:
 
-        switch (fop) {
-
+    switch (fop) {
         case GF_FOP_WRITE:
-                DHT_STACK_UNWIND (writev, frame, -1,
-                                  op_errno, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FLUSH:
-                DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+            break;
 
         case GF_FOP_FSETATTR:
-                DHT_STACK_UNWIND (fsetattr, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_ZEROFILL:
-                DHT_STACK_UNWIND (zerofill, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_DISCARD:
-                DHT_STACK_UNWIND (discard, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FALLOCATE:
-                DHT_STACK_UNWIND (fallocate, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FTRUNCATE:
-                DHT_STACK_UNWIND (ftruncate, frame, -1, op_errno,
-                                  NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_FSYNC:
-                DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+            break;
 
         case GF_FOP_READ:
-                DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL,
-                                  0, NULL, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL,
+                             NULL);
+            break;
 
         case GF_FOP_FSTAT:
-                DHT_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
-                break;
+            DHT_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
+            break;
 
         case GF_FOP_FSETXATTR:
-                DHT_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
+            break;
 
         case GF_FOP_FREMOVEXATTR:
-                DHT_STACK_UNWIND (fremovexattr, frame, -1, op_errno, NULL);
-                break;
+            DHT_STACK_UNWIND(fremovexattr, frame, -1, op_errno, NULL);
+            break;
 
         default:
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_UNKNOWN_FOP,
-                        "Unknown FOP on fd (%p) on file %s @ %s",
-                        fd, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                break;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_UNKNOWN_FOP,
+                   "Unknown FOP on fd (%p) on file %s @ %s", fd,
+                   uuid_utoa(fd->inode->gfid), subvol->name);
+            break;
+    }
 
 out:
 
-        return 0;
-
+    return 0;
 }
 
-
 /* Check once again if the fd has been opened on the cached subvol.
  * If not, open and update the fd_ctx.
  */
 
 int
-dht_check_and_open_fd_on_subvol_task (void *data)
+dht_check_and_open_fd_on_subvol_task(void *data)
 {
-        loc_t          loc        = {0,};
-        int            ret        = -1;
-        call_frame_t  *frame      = NULL;
-        dht_local_t   *local      = NULL;
-        fd_t          *fd         = NULL;
-        xlator_t      *this       = NULL;
-        xlator_t      *subvol     = NULL;
-
-
-        frame = data;
-        local = frame->local;
-        this = THIS;
-        fd = local->fd;
-        subvol = local->cached_subvol;
-
-        local->fd_checked = _gf_true;
-
-        if (fd_is_anonymous (fd) || dht_fd_open_on_dst (this, fd, subvol)) {
-                ret = 0;
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0,
-                      "Opening fd (%p, flags=0%o) on file %s @ %s",
-                      fd, fd->flags, uuid_utoa (fd->inode->gfid),
-                      subvol->name);
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    fd_t *fd = NULL;
+    xlator_t *this = NULL;
+    xlator_t *subvol = NULL;
+
+    frame = data;
+    local = frame->local;
+    this = THIS;
+    fd = local->fd;
+    subvol = local->cached_subvol;
+
+    local->fd_checked = _gf_true;
+
+    if (fd_is_anonymous(fd) || dht_fd_open_on_dst(this, fd, subvol)) {
+        ret = 0;
+        goto out;
+    }
 
+    gf_msg_debug(this->name, 0, "Opening fd (%p, flags=0%o) on file %s @ %s",
+                 fd, fd->flags, uuid_utoa(fd->inode->gfid), subvol->name);
 
-        loc.inode = inode_ref (fd->inode);
-        gf_uuid_copy (loc.gfid, fd->inode->gfid);
+    loc.inode = inode_ref(fd->inode);
+    gf_uuid_copy(loc.gfid, fd->inode->gfid);
 
-        /* Open this on the dst subvol */
+    /* Open this on the dst subvol */
 
-        SYNCTASK_SETID(0, 0);
+    SYNCTASK_SETID(0, 0);
 
-        ret = syncop_open (subvol, &loc,
-                           (fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
-                           fd, NULL, NULL);
+    ret = syncop_open(subvol, &loc, (fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                      fd, NULL, NULL);
 
-        if (ret < 0) {
-
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_OPEN_FD_ON_DST_FAILED,
-                        "Failed to open the fd"
-                        " (%p, flags=0%o) on file %s @ %s",
-                        fd, fd->flags, uuid_utoa (fd->inode->gfid),
-                        subvol->name);
-                /* This can happen if the cached subvol was updated in the
-                 * inode_ctx and the fd was opened on the new cached suvol
-                 * after this fop was wound on the old cached subvol.
-                 * As we do not close the fd on the old subvol (a leak)
-                 * don't treat ENOENT as an error and allow the phase1/phase2
-                 * checks to handle it.
-                 */
-
-                if ((-ret != ENOENT) && (-ret != ESTALE)) {
-                        local->op_errno = -ret;
-                        ret = -1;
-                } else {
-                        ret = 0;
-                }
-
-                local->op_errno = -ret;
-                ret = -1;
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_OPEN_FD_ON_DST_FAILED,
+               "Failed to open the fd"
+               " (%p, flags=0%o) on file %s @ %s",
+               fd, fd->flags, uuid_utoa(fd->inode->gfid), subvol->name);
+        /* This can happen if the cached subvol was updated in the
+         * inode_ctx and the fd was opened on the new cached suvol
+         * after this fop was wound on the old cached subvol.
+         * As we do not close the fd on the old subvol (a leak)
+         * don't treat ENOENT as an error and allow the phase1/phase2
+         * checks to handle it.
+         */
 
+        if ((-ret != ENOENT) && (-ret != ESTALE)) {
+            local->op_errno = -ret;
+            ret = -1;
         } else {
-                dht_fd_ctx_set (this, fd, subvol);
+            ret = 0;
         }
 
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
+        local->op_errno = -ret;
+        ret = -1;
+
+    } else {
+        dht_fd_ctx_set(this, fd, subvol);
+    }
+
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
-
 int
-dht_check_and_open_fd_on_subvol (xlator_t *this, call_frame_t *frame)
+dht_check_and_open_fd_on_subvol(xlator_t *this, call_frame_t *frame)
 {
-        int ret            = -1;
-        dht_local_t *local = NULL;
-
-/*
-        if (dht_fd_open_on_dst (this, fd, subvol))
-                goto out;
-*/
-        local = frame->local;
-
-        ret = synctask_new (this->ctx->env,
-                            dht_check_and_open_fd_on_subvol_task,
-                            dht_check_and_open_fd_on_subvol_complete,
-                            frame, frame);
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0,
-                        "Failed to create synctask"
-                        " to check and open fd=%p", local->fd);
-        }
-
-        return ret;
+    int ret = -1;
+    dht_local_t *local = NULL;
+
+    /*
+            if (dht_fd_open_on_dst (this, fd, subvol))
+                    goto out;
+    */
+    local = frame->local;
+
+    ret = synctask_new(this->ctx->env, dht_check_and_open_fd_on_subvol_task,
+                       dht_check_and_open_fd_on_subvol_complete, frame, frame);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+               "Failed to create synctask"
+               " to check and open fd=%p",
+               local->fd);
+    }
+
+    return ret;
 }
 
-
-
 int
-dht_frame_return (call_frame_t *frame)
+dht_frame_return(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        int          this_call_cnt = -1;
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
 
-        if (!frame)
-                return -1;
+    if (!frame)
+        return -1;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                this_call_cnt = --local->call_cnt;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        this_call_cnt = --local->call_cnt;
+    }
+    UNLOCK(&frame->lock);
 
-        return this_call_cnt;
+    return this_call_cnt;
 }
 
 /*
@@ -622,652 +572,636 @@ dht_frame_return (call_frame_t *frame)
  */
 
 int
-dht_filter_loc_subvol_key (xlator_t *this, loc_t *loc, loc_t *new_loc,
-                           xlator_t **subvol)
+dht_filter_loc_subvol_key(xlator_t *this, loc_t *loc, loc_t *new_loc,
+                          xlator_t **subvol)
 {
-        char          *new_name  = NULL;
-        char          *new_path  = NULL;
-        xlator_list_t *trav      = NULL;
-        char           key[1024] = {0,};
-        int            ret       = 0; /* not found */
-        int            keylen    = 0;
-        int            name_len  = 0;
-        int            path_len  = 0;
-
-        /* Why do other tasks if first required 'char' itself is not there */
-        if (!new_loc || !loc || !loc->name || !strchr (loc->name, '@')) {
-                /* Skip the GF_FREE checks here */
-                return ret;
-        }
-
-        trav = this->children;
-        while (trav) {
-                keylen = snprintf (key, sizeof (key), "*@%s:%s", this->name,
-                                   trav->xlator->name);
-                /* Ignore '*' */
-                keylen = keylen - 1;
-                if (fnmatch (key, loc->name, FNM_NOESCAPE) == 0) {
-                        name_len = strlen (loc->name) - keylen;
-                        new_name = GF_MALLOC(name_len + 1,
-                                             gf_common_mt_char);
-                        if (!new_name)
-                                goto out;
-                        if (fnmatch (key, loc->path, FNM_NOESCAPE) == 0) {
-                                path_len = strlen (loc->path) - keylen;
-                                new_path = GF_MALLOC(path_len + 1,
-                                                     gf_common_mt_char);
-                                if (!new_path)
-                                        goto out;
-                                snprintf (new_path, path_len + 1,
-                                          "%s", loc->path);
-                        }
-                        snprintf (new_name, name_len + 1, "%s",
-                                  loc->name);
-
-                        if (new_loc) {
-                                new_loc->path   = ((new_path) ? new_path:
-                                                   gf_strdup (loc->path));
-                                new_loc->name   = new_name;
-                                new_loc->inode  = inode_ref (loc->inode);
-                                new_loc->parent = inode_ref (loc->parent);
-                        }
-                        *subvol         = trav->xlator;
-                        ret = 1;  /* success */
-                        goto out;
-                }
-                trav = trav->next;
-        }
-out:
-        if (!ret) {
-                /* !success */
-                GF_FREE (new_path);
-                GF_FREE (new_name);
-        }
+    char *new_name = NULL;
+    char *new_path = NULL;
+    xlator_list_t *trav = NULL;
+    char key[1024] = {
+        0,
+    };
+    int ret = 0; /* not found */
+    int keylen = 0;
+    int name_len = 0;
+    int path_len = 0;
+
+    /* Why do other tasks if first required 'char' itself is not there */
+    if (!new_loc || !loc || !loc->name || !strchr(loc->name, '@')) {
+        /* Skip the GF_FREE checks here */
         return ret;
+    }
+
+    trav = this->children;
+    while (trav) {
+        keylen = snprintf(key, sizeof(key), "*@%s:%s", this->name,
+                          trav->xlator->name);
+        /* Ignore '*' */
+        keylen = keylen - 1;
+        if (fnmatch(key, loc->name, FNM_NOESCAPE) == 0) {
+            name_len = strlen(loc->name) - keylen;
+            new_name = GF_MALLOC(name_len + 1, gf_common_mt_char);
+            if (!new_name)
+                goto out;
+            if (fnmatch(key, loc->path, FNM_NOESCAPE) == 0) {
+                path_len = strlen(loc->path) - keylen;
+                new_path = GF_MALLOC(path_len + 1, gf_common_mt_char);
+                if (!new_path)
+                    goto out;
+                snprintf(new_path, path_len + 1, "%s", loc->path);
+            }
+            snprintf(new_name, name_len + 1, "%s", loc->name);
+
+            if (new_loc) {
+                new_loc->path = ((new_path) ? new_path : gf_strdup(loc->path));
+                new_loc->name = new_name;
+                new_loc->inode = inode_ref(loc->inode);
+                new_loc->parent = inode_ref(loc->parent);
+            }
+            *subvol = trav->xlator;
+            ret = 1; /* success */
+            goto out;
+        }
+        trav = trav->next;
+    }
+out:
+    if (!ret) {
+        /* !success */
+        GF_FREE(new_path);
+        GF_FREE(new_name);
+    }
+    return ret;
 }
 
 static xlator_t *
 dht_get_subvol_from_id(xlator_t *this, int client_id)
 {
-        xlator_t   *xl   = NULL;
-        dht_conf_t *conf = NULL;
-        char       *sid  = NULL;
-        int32_t     ret  = -1;
-
-        conf = this->private;
-
-        ret = gf_asprintf(&sid, "%d", client_id);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_ASPRINTF_FAILED, "asprintf failed while "
-                        "fetching subvol from the id");
-                goto out;
-        }
+    xlator_t *xl = NULL;
+    dht_conf_t *conf = NULL;
+    char *sid = NULL;
+    int32_t ret = -1;
+
+    conf = this->private;
+
+    ret = gf_asprintf(&sid, "%d", client_id);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_ASPRINTF_FAILED,
+               "asprintf failed while "
+               "fetching subvol from the id");
+        goto out;
+    }
 
-        if (dict_get_ptr(conf->leaf_to_subvol, sid, (void **) &xl))
-                xl = NULL;
+    if (dict_get_ptr(conf->leaf_to_subvol, sid, (void **)&xl))
+        xl = NULL;
 
-        GF_FREE (sid);
+    GF_FREE(sid);
 
 out:
-        return xl;
-
+    return xl;
 }
 
 int
-dht_deitransform (xlator_t *this, uint64_t y, xlator_t **subvol_p)
+dht_deitransform(xlator_t *this, uint64_t y, xlator_t **subvol_p)
 {
-        int         client_id = 0;
-        xlator_t   *subvol = 0;
-        dht_conf_t *conf = NULL;
+    int client_id = 0;
+    xlator_t *subvol = 0;
+    dht_conf_t *conf = NULL;
 
-        if (!this->private)
-                return -1;
+    if (!this->private)
+        return -1;
 
-        conf = this->private;
+    conf = this->private;
 
-        client_id = gf_deitransform(this, y);
+    client_id = gf_deitransform(this, y);
 
-        subvol = dht_get_subvol_from_id(this, client_id);
+    subvol = dht_get_subvol_from_id(this, client_id);
 
-        if (!subvol)
-                subvol = conf->subvolumes[0];
+    if (!subvol)
+        subvol = conf->subvolumes[0];
 
-        if (subvol_p)
-                *subvol_p = subvol;
+    if (subvol_p)
+        *subvol_p = subvol;
 
-        return 0;
+    return 0;
 }
 
 void
-dht_local_wipe (xlator_t *this, dht_local_t *local)
+dht_local_wipe(xlator_t *this, dht_local_t *local)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!local)
-                return;
+    if (!local)
+        return;
 
-        loc_wipe (&local->loc);
-        loc_wipe (&local->loc2);
-        loc_wipe (&local->loc2_copy);
+    loc_wipe(&local->loc);
+    loc_wipe(&local->loc2);
+    loc_wipe(&local->loc2_copy);
 
-        if (local->xattr)
-                dict_unref (local->xattr);
+    if (local->xattr)
+        dict_unref(local->xattr);
 
-        if (local->inode)
-                inode_unref (local->inode);
+    if (local->inode)
+        inode_unref(local->inode);
 
-        if (local->layout) {
-                dht_layout_unref (this, local->layout);
-                local->layout = NULL;
-        }
+    if (local->layout) {
+        dht_layout_unref(this, local->layout);
+        local->layout = NULL;
+    }
 
-        loc_wipe (&local->linkfile.loc);
+    loc_wipe(&local->linkfile.loc);
 
-        if (local->linkfile.xattr)
-                dict_unref (local->linkfile.xattr);
+    if (local->linkfile.xattr)
+        dict_unref(local->linkfile.xattr);
 
-        if (local->linkfile.inode)
-                inode_unref (local->linkfile.inode);
+    if (local->linkfile.inode)
+        inode_unref(local->linkfile.inode);
 
-        if (local->fd) {
-                fd_unref (local->fd);
-                local->fd = NULL;
-        }
+    if (local->fd) {
+        fd_unref(local->fd);
+        local->fd = NULL;
+    }
 
-        if (local->params) {
-                dict_unref (local->params);
-                local->params = NULL;
-        }
+    if (local->params) {
+        dict_unref(local->params);
+        local->params = NULL;
+    }
 
-        if (local->xattr_req)
-                dict_unref (local->xattr_req);
-        if (local->mds_xattr)
-                dict_unref (local->mds_xattr);
-        if (local->xdata)
-                dict_unref (local->xdata);
+    if (local->xattr_req)
+        dict_unref(local->xattr_req);
+    if (local->mds_xattr)
+        dict_unref(local->mds_xattr);
+    if (local->xdata)
+        dict_unref(local->xdata);
 
-        if (local->selfheal.layout) {
-                dht_layout_unref (this, local->selfheal.layout);
-                local->selfheal.layout = NULL;
-        }
+    if (local->selfheal.layout) {
+        dht_layout_unref(this, local->selfheal.layout);
+        local->selfheal.layout = NULL;
+    }
 
-        if (local->selfheal.refreshed_layout) {
-                dht_layout_unref (this, local->selfheal.refreshed_layout);
-                local->selfheal.refreshed_layout = NULL;
-        }
+    if (local->selfheal.refreshed_layout) {
+        dht_layout_unref(this, local->selfheal.refreshed_layout);
+        local->selfheal.refreshed_layout = NULL;
+    }
 
-        for (i = 0; i < 2; i++) {
-                dht_lock_array_free (local->lock[i].ns.parent_layout.locks,
-                                     local->lock[i].ns.parent_layout.lk_count);
+    for (i = 0; i < 2; i++) {
+        dht_lock_array_free(local->lock[i].ns.parent_layout.locks,
+                            local->lock[i].ns.parent_layout.lk_count);
 
-                GF_FREE (local->lock[i].ns.parent_layout.locks);
+        GF_FREE(local->lock[i].ns.parent_layout.locks);
 
-                dht_lock_array_free (local->lock[i].ns.directory_ns.locks,
-                                     local->lock[i].ns.directory_ns.lk_count);
-                GF_FREE (local->lock[i].ns.directory_ns.locks);
-        }
+        dht_lock_array_free(local->lock[i].ns.directory_ns.locks,
+                            local->lock[i].ns.directory_ns.lk_count);
+        GF_FREE(local->lock[i].ns.directory_ns.locks);
+    }
 
-        GF_FREE (local->key);
+    GF_FREE(local->key);
 
-        if (local->rebalance.xdata)
-                dict_unref (local->rebalance.xdata);
+    if (local->rebalance.xdata)
+        dict_unref(local->rebalance.xdata);
 
-        if (local->rebalance.xattr)
-                dict_unref (local->rebalance.xattr);
+    if (local->rebalance.xattr)
+        dict_unref(local->rebalance.xattr);
 
-        if (local->rebalance.dict)
-                dict_unref (local->rebalance.dict);
+    if (local->rebalance.dict)
+        dict_unref(local->rebalance.dict);
 
-        GF_FREE (local->rebalance.vector);
+    GF_FREE(local->rebalance.vector);
 
-        if (local->rebalance.iobref)
-                iobref_unref (local->rebalance.iobref);
+    if (local->rebalance.iobref)
+        iobref_unref(local->rebalance.iobref);
 
-        if (local->stub) {
-                call_stub_destroy (local->stub);
-                local->stub = NULL;
-        }
+    if (local->stub) {
+        call_stub_destroy(local->stub);
+        local->stub = NULL;
+    }
 
-        if (local->ret_cache)
-                GF_FREE (local->ret_cache);
+    if (local->ret_cache)
+        GF_FREE(local->ret_cache);
 
-        mem_put (local);
+    mem_put(local);
 }
 
-
 dht_local_t *
-dht_local_init (call_frame_t *frame, loc_t *loc, fd_t *fd, glusterfs_fop_t fop)
+dht_local_init(call_frame_t *frame, loc_t *loc, fd_t *fd, glusterfs_fop_t fop)
 {
-        dht_local_t *local = NULL;
-        inode_t     *inode = NULL;
-        int          ret   = 0;
+    dht_local_t *local = NULL;
+    inode_t *inode = NULL;
+    int ret = 0;
 
-        local = mem_get0 (THIS->local_pool);
-        if (!local)
-                goto out;
+    local = mem_get0(THIS->local_pool);
+    if (!local)
+        goto out;
 
-        if (loc) {
-                ret = loc_copy (&local->loc, loc);
-                if (ret)
-                        goto out;
+    if (loc) {
+        ret = loc_copy(&local->loc, loc);
+        if (ret)
+            goto out;
 
-                inode = loc->inode;
-        }
+        inode = loc->inode;
+    }
 
-        if (fd) {
-                local->fd = fd_ref (fd);
-                if (!inode)
-                        inode = fd->inode;
-        }
+    if (fd) {
+        local->fd = fd_ref(fd);
+        if (!inode)
+            inode = fd->inode;
+    }
 
-        local->op_ret   = -1;
-        local->op_errno = EUCLEAN;
-        local->fop      = fop;
+    local->op_ret = -1;
+    local->op_errno = EUCLEAN;
+    local->fop = fop;
 
-        if (inode) {
-                local->layout   = dht_layout_get (frame->this, inode);
-                local->cached_subvol = dht_subvol_get_cached (frame->this,
-                                                              inode);
-        }
+    if (inode) {
+        local->layout = dht_layout_get(frame->this, inode);
+        local->cached_subvol = dht_subvol_get_cached(frame->this, inode);
+    }
 
-        frame->local = local;
+    frame->local = local;
 
 out:
-        if (ret) {
-                if (local)
-                        mem_put (local);
-                local = NULL;
-        }
-        return local;
+    if (ret) {
+        if (local)
+            mem_put(local);
+        local = NULL;
+    }
+    return local;
 }
 
 xlator_t *
-dht_first_up_subvol (xlator_t *this)
+dht_first_up_subvol(xlator_t *this)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *child = NULL;
-        int         i = 0;
-        time_t      time = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *child = NULL;
+    int i = 0;
+    time_t time = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        LOCK (&conf->subvolume_lock);
-        {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvol_up_time[i]) {
-                                if (!time) {
-                                        time = conf->subvol_up_time[i];
-                                        child = conf->subvolumes[i];
-                                } else if (time > conf->subvol_up_time[i]) {
-                                        time  = conf->subvol_up_time[i];
-                                        child = conf->subvolumes[i];
-                                }
-                        }
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvol_up_time[i]) {
+                if (!time) {
+                    time = conf->subvol_up_time[i];
+                    child = conf->subvolumes[i];
+                } else if (time > conf->subvol_up_time[i]) {
+                    time = conf->subvol_up_time[i];
+                    child = conf->subvolumes[i];
                 }
+            }
         }
-        UNLOCK (&conf->subvolume_lock);
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return child;
+    return child;
 }
 
 xlator_t *
-dht_last_up_subvol (xlator_t *this)
+dht_last_up_subvol(xlator_t *this)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *child = NULL;
-        int         i = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *child = NULL;
+    int i = 0;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        LOCK (&conf->subvolume_lock);
-        {
-                for (i = conf->subvolume_cnt-1; i >= 0; i--) {
-                        if (conf->subvolume_status[i]) {
-                                child = conf->subvolumes[i];
-                                break;
-                        }
-                }
+    LOCK(&conf->subvolume_lock);
+    {
+        for (i = conf->subvolume_cnt - 1; i >= 0; i--) {
+            if (conf->subvolume_status[i]) {
+                child = conf->subvolumes[i];
+                break;
+            }
         }
-        UNLOCK (&conf->subvolume_lock);
+    }
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return child;
+    return child;
 }
 
 xlator_t *
-dht_subvol_get_hashed (xlator_t *this, loc_t *loc)
+dht_subvol_get_hashed(xlator_t *this, loc_t *loc)
 {
-        dht_layout_t *layout = NULL;
-        xlator_t     *subvol = NULL;
-        dht_conf_t *conf = NULL;
-        dht_methods_t *methods = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *subvol = NULL;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc, out);
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        if (__is_root_gfid (loc->gfid)) {
-                subvol = dht_first_up_subvol (this);
-                goto out;
-        }
+    if (__is_root_gfid(loc->gfid)) {
+        subvol = dht_first_up_subvol(this);
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO (this->name, loc->parent, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc->name, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc->parent, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc->name, out);
 
-        layout = dht_layout_get (this, loc->parent);
+    layout = dht_layout_get(this, loc->parent);
 
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "Missing layout. path=%s, parent gfid =%s",
-                              loc->path, uuid_utoa (loc->parent->gfid));
-                goto out;
-        }
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "Missing layout. path=%s, parent gfid =%s",
+                     loc->path, uuid_utoa(loc->parent->gfid));
+        goto out;
+    }
 
-        subvol = methods->layout_search (this, layout, loc->name);
+    subvol = methods->layout_search(this, layout, loc->name);
 
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "No hashed subvolume for path=%s",
-                              loc->path);
-                goto out;
-        }
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "No hashed subvolume for path=%s",
+                     loc->path);
+        goto out;
+    }
 
 out:
-        if (layout) {
-                dht_layout_unref (this, layout);
-        }
+    if (layout) {
+        dht_layout_unref(this, layout);
+    }
 
-        return subvol;
+    return subvol;
 }
 
-
 xlator_t *
-dht_subvol_get_cached (xlator_t *this, inode_t *inode)
+dht_subvol_get_cached(xlator_t *this, inode_t *inode)
 {
-        dht_layout_t *layout = NULL;
-        xlator_t     *subvol = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *subvol = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        layout = dht_layout_get (this, inode);
+    layout = dht_layout_get(this, inode);
 
-        if (!layout) {
-                goto out;
-        }
+    if (!layout) {
+        goto out;
+    }
 
-        subvol = layout->list[0].xlator;
+    subvol = layout->list[0].xlator;
 
 out:
-        if (layout) {
-                dht_layout_unref (this, layout);
-        }
+    if (layout) {
+        dht_layout_unref(this, layout);
+    }
 
-        return subvol;
+    return subvol;
 }
 
-
 xlator_t *
-dht_subvol_next (xlator_t *this, xlator_t *prev)
+dht_subvol_next(xlator_t *this, xlator_t *prev)
 {
-        dht_conf_t *conf = NULL;
-        int         i = 0;
-        xlator_t   *next = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *next = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == prev) {
-                        if ((i + 1) < conf->subvolume_cnt)
-                                next = conf->subvolumes[i + 1];
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == prev) {
+            if ((i + 1) < conf->subvolume_cnt)
+                next = conf->subvolumes[i + 1];
+            break;
         }
+    }
 
 out:
-        return next;
+    return next;
 }
 
 /* This func wraps around, if prev is actually the last subvol.
  */
 xlator_t *
-dht_subvol_next_available (xlator_t *this, xlator_t *prev)
+dht_subvol_next_available(xlator_t *this, xlator_t *prev)
 {
-        dht_conf_t *conf = NULL;
-        int         i = 0;
-        xlator_t   *next = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *next = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == prev) {
-                        /* if prev is last in conf->subvolumes, then wrap
-                         * around.
-                         */
-                        if ((i + 1) < conf->subvolume_cnt) {
-                                next = conf->subvolumes[i + 1];
-                        } else {
-                                next = conf->subvolumes[0];
-                        }
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == prev) {
+            /* if prev is last in conf->subvolumes, then wrap
+             * around.
+             */
+            if ((i + 1) < conf->subvolume_cnt) {
+                next = conf->subvolumes[i + 1];
+            } else {
+                next = conf->subvolumes[0];
+            }
+            break;
         }
+    }
 
 out:
-        return next;
+    return next;
 }
 int
-dht_subvol_cnt (xlator_t *this, xlator_t *subvol)
+dht_subvol_cnt(xlator_t *this, xlator_t *subvol)
 {
-        int i = 0;
-        int ret = -1;
-        dht_conf_t *conf = NULL;
+    int i = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (subvol == conf->subvolumes[i]) {
-                        ret = i;
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (subvol == conf->subvolumes[i]) {
+            ret = i;
+            break;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
+#define set_if_greater(a, b)                                                   \
+    do {                                                                       \
+        if ((a) < (b))                                                         \
+            (a) = (b);                                                         \
+    } while (0)
 
-#define set_if_greater(a, b) do {               \
-                if ((a) < (b))                  \
-                        (a) = (b);              \
-        } while (0)
-
-
-#define set_if_greater_time(a, an, b, bn) do {                          \
-                if (((a) < (b)) || (((a) == (b)) && ((an) < (bn)))){    \
-                        (a) = (b);                                      \
-                        (an) = (bn);                                    \
-                }                                                       \
-        } while (0)                                                     \
-
+#define set_if_greater_time(a, an, b, bn)                                      \
+    do {                                                                       \
+        if (((a) < (b)) || (((a) == (b)) && ((an) < (bn)))) {                  \
+            (a) = (b);                                                         \
+            (an) = (bn);                                                       \
+        }                                                                      \
+    } while (0)
 
 int
-dht_iatt_merge (xlator_t *this, struct iatt *to, struct iatt *from)
+dht_iatt_merge(xlator_t *this, struct iatt *to, struct iatt *from)
 {
-        if (!from || !to)
-                return 0;
-
-        to->ia_dev      = from->ia_dev;
-
-        gf_uuid_copy (to->ia_gfid, from->ia_gfid);
-
-        to->ia_ino      = from->ia_ino;
-        to->ia_prot     = from->ia_prot;
-        to->ia_type     = from->ia_type;
-        to->ia_nlink    = from->ia_nlink;
-        to->ia_rdev     = from->ia_rdev;
-        to->ia_size    += from->ia_size;
-        to->ia_blksize  = from->ia_blksize;
-        to->ia_blocks  += from->ia_blocks;
-
-        if (IA_ISDIR (from->ia_type)) {
-                to->ia_blocks = DHT_DIR_STAT_BLOCKS;
-                to->ia_size = DHT_DIR_STAT_SIZE;
-        }
-        set_if_greater (to->ia_uid, from->ia_uid);
-        set_if_greater (to->ia_gid, from->ia_gid);
-
-        set_if_greater_time(to->ia_atime, to->ia_atime_nsec,
-                            from->ia_atime, from->ia_atime_nsec);
-        set_if_greater_time (to->ia_mtime, to->ia_mtime_nsec,
-                             from->ia_mtime, from->ia_mtime_nsec);
-        set_if_greater_time (to->ia_ctime, to->ia_ctime_nsec,
-                             from->ia_ctime, from->ia_ctime_nsec);
-
+    if (!from || !to)
         return 0;
+
+    to->ia_dev = from->ia_dev;
+
+    gf_uuid_copy(to->ia_gfid, from->ia_gfid);
+
+    to->ia_ino = from->ia_ino;
+    to->ia_prot = from->ia_prot;
+    to->ia_type = from->ia_type;
+    to->ia_nlink = from->ia_nlink;
+    to->ia_rdev = from->ia_rdev;
+    to->ia_size += from->ia_size;
+    to->ia_blksize = from->ia_blksize;
+    to->ia_blocks += from->ia_blocks;
+
+    if (IA_ISDIR(from->ia_type)) {
+        to->ia_blocks = DHT_DIR_STAT_BLOCKS;
+        to->ia_size = DHT_DIR_STAT_SIZE;
+    }
+    set_if_greater(to->ia_uid, from->ia_uid);
+    set_if_greater(to->ia_gid, from->ia_gid);
+
+    set_if_greater_time(to->ia_atime, to->ia_atime_nsec, from->ia_atime,
+                        from->ia_atime_nsec);
+    set_if_greater_time(to->ia_mtime, to->ia_mtime_nsec, from->ia_mtime,
+                        from->ia_mtime_nsec);
+    set_if_greater_time(to->ia_ctime, to->ia_ctime_nsec, from->ia_ctime,
+                        from->ia_ctime_nsec);
+
+    return 0;
 }
 
 int
-dht_build_child_loc (xlator_t *this, loc_t *child, loc_t *parent, char *name)
+dht_build_child_loc(xlator_t *this, loc_t *child, loc_t *parent, char *name)
 {
-        if (!child) {
-                goto err;
-        }
+    if (!child) {
+        goto err;
+    }
 
-        if (strcmp (parent->path, "/") == 0)
-                gf_asprintf ((char **)&child->path, "/%s", name);
-        else
-                gf_asprintf ((char **)&child->path, "%s/%s", parent->path, name);
+    if (strcmp(parent->path, "/") == 0)
+        gf_asprintf((char **)&child->path, "/%s", name);
+    else
+        gf_asprintf((char **)&child->path, "%s/%s", parent->path, name);
 
-        if (!child->path) {
-                goto err;
-        }
+    if (!child->path) {
+        goto err;
+    }
 
-        child->name = strrchr (child->path, '/');
-        if (child->name)
-                child->name++;
+    child->name = strrchr(child->path, '/');
+    if (child->name)
+        child->name++;
 
-        child->parent = inode_ref (parent->inode);
-        child->inode = inode_new (parent->inode->table);
+    child->parent = inode_ref(parent->inode);
+    child->inode = inode_new(parent->inode->table);
 
-        if (!child->inode) {
-                goto err;
-        }
+    if (!child->inode) {
+        goto err;
+    }
 
-        return 0;
+    return 0;
 err:
-        if (child) {
-            loc_wipe (child);
-        }
-        return -1;
+    if (child) {
+        loc_wipe(child);
+    }
+    return -1;
 }
 
 int
-dht_init_local_subvolumes (xlator_t *this, dht_conf_t *conf)
+dht_init_local_subvolumes(xlator_t *this, dht_conf_t *conf)
 {
-        xlator_list_t *subvols = NULL;
-        int            cnt = 0;
+    xlator_list_t *subvols = NULL;
+    int cnt = 0;
 
-        if (!conf)
-                return -1;
+    if (!conf)
+        return -1;
 
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                cnt++;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        cnt++;
 
-        conf->local_subvols = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                        gf_dht_mt_xlator_t);
+    conf->local_subvols = GF_CALLOC(cnt, sizeof(xlator_t *),
+                                    gf_dht_mt_xlator_t);
 
-        /* FIX FIX : do this dynamically*/
-        conf->local_nodeuuids = GF_CALLOC (cnt,
-                                           sizeof (subvol_nodeuuids_info_t),
-                                           gf_dht_nodeuuids_t);
+    /* FIX FIX : do this dynamically*/
+    conf->local_nodeuuids = GF_CALLOC(cnt, sizeof(subvol_nodeuuids_info_t),
+                                      gf_dht_nodeuuids_t);
 
-        if (!conf->local_subvols || !conf->local_nodeuuids) {
-                return -1;
-        }
+    if (!conf->local_subvols || !conf->local_nodeuuids) {
+        return -1;
+    }
 
-        conf->local_subvols_cnt = 0;
+    conf->local_subvols_cnt = 0;
 
-        return 0;
+    return 0;
 }
 
 int
-dht_init_subvolumes (xlator_t *this, dht_conf_t *conf)
+dht_init_subvolumes(xlator_t *this, dht_conf_t *conf)
 {
-        xlator_list_t *subvols = NULL;
-        int            cnt = 0;
+    xlator_list_t *subvols = NULL;
+    int cnt = 0;
 
-        if (!conf)
-                return -1;
+    if (!conf)
+        return -1;
 
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                cnt++;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        cnt++;
 
-        conf->subvolumes = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                      gf_dht_mt_xlator_t);
-        if (!conf->subvolumes) {
-                return -1;
-        }
-        conf->subvolume_cnt = cnt;
+    conf->subvolumes = GF_CALLOC(cnt, sizeof(xlator_t *), gf_dht_mt_xlator_t);
+    if (!conf->subvolumes) {
+        return -1;
+    }
+    conf->subvolume_cnt = cnt;
 
-        conf->local_subvols_cnt = 0;
+    conf->local_subvols_cnt = 0;
 
-        dht_set_subvol_range(this);
+    dht_set_subvol_range(this);
 
-        cnt = 0;
-        for (subvols = this->children; subvols; subvols = subvols->next)
-                conf->subvolumes[cnt++] = subvols->xlator;
+    cnt = 0;
+    for (subvols = this->children; subvols; subvols = subvols->next)
+        conf->subvolumes[cnt++] = subvols->xlator;
 
-        conf->subvolume_status = GF_CALLOC (cnt, sizeof (char),
-                                            gf_dht_mt_char);
-        if (!conf->subvolume_status) {
-                return -1;
-        }
+    conf->subvolume_status = GF_CALLOC(cnt, sizeof(char), gf_dht_mt_char);
+    if (!conf->subvolume_status) {
+        return -1;
+    }
 
-        conf->last_event = GF_CALLOC (cnt, sizeof (int),
-                                      gf_dht_mt_char);
-        if (!conf->last_event) {
-                return -1;
-        }
+    conf->last_event = GF_CALLOC(cnt, sizeof(int), gf_dht_mt_char);
+    if (!conf->last_event) {
+        return -1;
+    }
 
-        conf->subvol_up_time = GF_CALLOC (cnt, sizeof (time_t),
-                                          gf_dht_mt_subvol_time);
-        if (!conf->subvol_up_time) {
-                return -1;
-        }
+    conf->subvol_up_time = GF_CALLOC(cnt, sizeof(time_t),
+                                     gf_dht_mt_subvol_time);
+    if (!conf->subvol_up_time) {
+        return -1;
+    }
 
-        conf->du_stats = GF_CALLOC (conf->subvolume_cnt, sizeof (dht_du_t),
-                                    gf_dht_mt_dht_du_t);
-        if (!conf->du_stats) {
-                return -1;
-        }
+    conf->du_stats = GF_CALLOC(conf->subvolume_cnt, sizeof(dht_du_t),
+                               gf_dht_mt_dht_du_t);
+    if (!conf->du_stats) {
+        return -1;
+    }
 
-        conf->decommissioned_bricks = GF_CALLOC (cnt, sizeof (xlator_t *),
-                                                 gf_dht_mt_xlator_t);
-        if (!conf->decommissioned_bricks) {
-                return -1;
-        }
+    conf->decommissioned_bricks = GF_CALLOC(cnt, sizeof(xlator_t *),
+                                            gf_dht_mt_xlator_t);
+    if (!conf->decommissioned_bricks) {
+        return -1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 /*
  op_ret values :
   0 : Success.
@@ -1276,270 +1210,263 @@ dht_init_subvolumes (xlator_t *this, dht_conf_t *conf)
 */
 
 static int
-dht_migration_complete_check_done (int op_ret, call_frame_t *frame, void *data)
+dht_migration_complete_check_done(int op_ret, call_frame_t *frame, void *data)
 {
-        dht_local_t *local  = NULL;
-        xlator_t    *subvol = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret != 0)
-                goto out;
+    if (op_ret != 0)
+        goto out;
 
-        if (local->cached_subvol == NULL) {
-                local->op_errno = EINVAL;
-                goto out;
-        }
+    if (local->cached_subvol == NULL) {
+        local->op_errno = EINVAL;
+        goto out;
+    }
 
-        subvol = local->cached_subvol;
+    subvol = local->cached_subvol;
 
 out:
-        local->rebalance.target_op_fn (THIS, subvol, frame, op_ret);
+    local->rebalance.target_op_fn(THIS, subvol, frame, op_ret);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_migration_complete_check_task (void *data)
+dht_migration_complete_check_task(void *data)
 {
-        int                 ret         = -1;
-        xlator_t           *src_node    = NULL;
-        xlator_t           *dst_node    = NULL, *linkto_target = NULL;
-        dht_local_t        *local       = NULL;
-        dict_t             *dict        = NULL;
-        struct iatt         stbuf       = {0,};
-        xlator_t           *this        = NULL;
-        call_frame_t       *frame       = NULL;
-        loc_t               tmp_loc     = {0,};
-        char               *path        = NULL;
-        dht_conf_t         *conf        = NULL;
-        inode_t            *inode       = NULL;
-        fd_t               *iter_fd     = NULL;
-        fd_t               *tmp         = NULL;
-        uint64_t            tmp_miginfo = 0;
-        dht_migrate_info_t *miginfo     = NULL;
-        int                 open_failed = 0;
-
-        this  = THIS;
-        frame = data;
-        local = frame->local;
-        conf = this->private;
-
-        src_node = local->cached_subvol;
-
-        if (!local->loc.inode && !local->fd) {
-                local->op_errno = EINVAL;
-                goto out;
-        }
-
-        inode = (!local->fd) ? local->loc.inode : local->fd->inode;
-
-        /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
-         * as root:root. If a fd is already open, access check won't be done*/
-
-        if (!local->loc.inode) {
-                ret = syncop_fgetxattr (src_node, local->fd, &dict,
-                                        conf->link_xattr_name, NULL, NULL);
-        } else {
-                SYNCTASK_SETID (0, 0);
-                ret = syncop_getxattr (src_node, &local->loc, &dict,
-                                       conf->link_xattr_name, NULL, NULL);
-                SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-        }
-
-
-        /*
-         * Each DHT xlator layer has its own name for the linkto xattr.
-         * If the file mode bits indicate the the file is being migrated but
-         * this layer's linkto xattr is not set, it means that another
-         * DHT layer is migrating the file. In this case, return 1 so
-         * the mode bits can be passed on to the higher layer for appropriate
-         * action.
-         */
-        if (-ret == ENODATA) {
-                /* This DHT translator is not migrating this file */
-
-                ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-                if (tmp_miginfo) {
-
-                        /* This can be a problem if the file was
-                         * migrated by two different layers. Raise
-                         * a warning here.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_HAS_MIGINFO,
-                                "%s: Found miginfo in the inode ctx",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid));
-
-                        miginfo = (void *)tmp_miginfo;
-                        GF_REF_PUT (miginfo);
-                }
-                ret = 1;
-                goto out;
-        }
+    int ret = -1;
+    xlator_t *src_node = NULL;
+    xlator_t *dst_node = NULL, *linkto_target = NULL;
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    xlator_t *this = NULL;
+    call_frame_t *frame = NULL;
+    loc_t tmp_loc = {
+        0,
+    };
+    char *path = NULL;
+    dht_conf_t *conf = NULL;
+    inode_t *inode = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *tmp = NULL;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
+    int open_failed = 0;
+
+    this = THIS;
+    frame = data;
+    local = frame->local;
+    conf = this->private;
+
+    src_node = local->cached_subvol;
+
+    if (!local->loc.inode && !local->fd) {
+        local->op_errno = EINVAL;
+        goto out;
+    }
 
-        if (!ret)
-                linkto_target = dht_linkfile_subvol (this, NULL, NULL, dict);
+    inode = (!local->fd) ? local->loc.inode : local->fd->inode;
 
-        if (local->loc.inode) {
-                loc_copy (&tmp_loc, &local->loc);
-        } else {
-                tmp_loc.inode = inode_ref (inode);
-                gf_uuid_copy (tmp_loc.gfid, inode->gfid);
-        }
+    /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
+     * as root:root. If a fd is already open, access check won't be done*/
 
-        ret = syncop_lookup (this, &tmp_loc, &stbuf, 0, 0, 0);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_FILE_LOOKUP_FAILED,
-                        "%s: failed to lookup the file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        this->name);
-                local->op_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+    if (!local->loc.inode) {
+        ret = syncop_fgetxattr(src_node, local->fd, &dict,
+                               conf->link_xattr_name, NULL, NULL);
+    } else {
+        SYNCTASK_SETID(0, 0);
+        ret = syncop_getxattr(src_node, &local->loc, &dict,
+                              conf->link_xattr_name, NULL, NULL);
+        SYNCTASK_SETID(frame->root->uid, frame->root->gid);
+    }
+
+    /*
+     * Each DHT xlator layer has its own name for the linkto xattr.
+     * If the file mode bits indicate the the file is being migrated but
+     * this layer's linkto xattr is not set, it means that another
+     * DHT layer is migrating the file. In this case, return 1 so
+     * the mode bits can be passed on to the higher layer for appropriate
+     * action.
+     */
+    if (-ret == ENODATA) {
+        /* This DHT translator is not migrating this file */
+
+        ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+        if (tmp_miginfo) {
+            /* This can be a problem if the file was
+             * migrated by two different layers. Raise
+             * a warning here.
+             */
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HAS_MIGINFO,
+                   "%s: Found miginfo in the inode ctx",
+                   tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid));
+
+            miginfo = (void *)tmp_miginfo;
+            GF_REF_PUT(miginfo);
+        }
+        ret = 1;
+        goto out;
+    }
+
+    if (!ret)
+        linkto_target = dht_linkfile_subvol(this, NULL, NULL, dict);
+
+    if (local->loc.inode) {
+        loc_copy(&tmp_loc, &local->loc);
+    } else {
+        tmp_loc.inode = inode_ref(inode);
+        gf_uuid_copy(tmp_loc.gfid, inode->gfid);
+    }
+
+    ret = syncop_lookup(this, &tmp_loc, &stbuf, 0, 0, 0);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_FILE_LOOKUP_FAILED,
+               "%s: failed to lookup the file on %s",
+               tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+               this->name);
+        local->op_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    dst_node = dht_subvol_get_cached(this, tmp_loc.inode);
+    if (linkto_target && dst_node != linkto_target) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_LINKFILE,
+               "linkto target (%s) is "
+               "different from cached-subvol (%s). Treating %s as "
+               "destination subvol",
+               linkto_target->name, dst_node->name, dst_node->name);
+    }
+
+    if (gf_uuid_compare(stbuf.ia_gfid, tmp_loc.inode->gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on the target file on %s",
+               tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+               dst_node->name);
+        ret = -1;
+        local->op_errno = EIO;
+        goto out;
+    }
 
-        dst_node = dht_subvol_get_cached (this, tmp_loc.inode);
-        if (linkto_target && dst_node != linkto_target) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_INVALID_LINKFILE,
-                        "linkto target (%s) is "
-                        "different from cached-subvol (%s). Treating %s as "
-                        "destination subvol", linkto_target->name,
-                        dst_node->name, dst_node->name);
-        }
+    /* update local. A layout is set in inode-ctx in lookup already */
 
-        if (gf_uuid_compare (stbuf.ia_gfid, tmp_loc.inode->gfid)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "%s: gfid different on the target file on %s",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid), dst_node->name);
-                ret = -1;
-                local->op_errno = EIO;
-                goto out;
-        }
+    dht_layout_unref(this, local->layout);
 
-        /* update local. A layout is set in inode-ctx in lookup already */
+    local->layout = dht_layout_get(frame->this, inode);
+    local->cached_subvol = dst_node;
 
-        dht_layout_unref (this, local->layout);
+    ret = 0;
 
-        local->layout   = dht_layout_get (frame->this, inode);
-        local->cached_subvol = dst_node;
+    /* once we detect the migration complete, the inode-ctx2 is no more
+       required.. delete the ctx and also, it means, open() already
+       done on all the fd of inode */
+    ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+    if (tmp_miginfo) {
+        miginfo = (void *)tmp_miginfo;
+        GF_REF_PUT(miginfo);
+        goto out;
+    }
+
+    /* perform 'open()' on all the fd's present on the inode */
+    if (tmp_loc.path == NULL) {
+        inode_path(inode, NULL, &path);
+        if (path)
+            tmp_loc.path = path;
+    }
+
+    LOCK(&inode->lock);
+
+    if (list_empty(&inode->fd_list))
+        goto unlock;
+
+    /* perform open as root:root. There is window between linkfile
+     * creation(root:root) and setattr with the correct uid/gid
+     */
+    SYNCTASK_SETID(0, 0);
+
+    /* It's possible that we are the last user of iter_fd after each
+     * iteration. In this case the fd_unref() of iter_fd at the end of
+     * the loop will cause the destruction of the fd. So we need to
+     * iterate the list safely because iter_fd cannot be trusted.
+     */
+    list_for_each_entry_safe(iter_fd, tmp, &inode->fd_list, inode_list)
+    {
+        if (fd_is_anonymous(iter_fd))
+            continue;
+
+        if (dht_fd_open_on_dst(this, iter_fd, dst_node))
+            continue;
+
+        /* We need to release the inode->lock before calling
+         * syncop_open() to avoid possible deadlocks. However this
+         * can cause the iter_fd to be released by other threads.
+         * To avoid this, we take a reference before releasing the
+         * lock.
+         */
+        __fd_ref(iter_fd);
 
-        ret = 0;
+        UNLOCK(&inode->lock);
 
-        /* once we detect the migration complete, the inode-ctx2 is no more
-           required.. delete the ctx and also, it means, open() already
-           done on all the fd of inode */
-        ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-        if (tmp_miginfo) {
-                miginfo = (void *)tmp_miginfo;
-                GF_REF_PUT (miginfo);
-                goto out;
+        /* flags for open are stripped down to allow following the
+         * new location of the file, otherwise we can get EEXIST or
+         * truncate the file again as rebalance is moving the data */
+        ret = syncop_open(dst_node, &tmp_loc,
+                          (iter_fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                          iter_fd, NULL, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret,
+                   DHT_MSG_OPEN_FD_ON_DST_FAILED,
+                   "failed"
+                   " to open the fd"
+                   " (%p, flags=0%o) on file %s @ %s",
+                   iter_fd, iter_fd->flags, path, dst_node->name);
+
+            open_failed = 1;
+            local->op_errno = -ret;
+            ret = -1;
+        } else {
+            dht_fd_ctx_set(this, iter_fd, dst_node);
         }
 
-        /* perform 'open()' on all the fd's present on the inode */
-        if (tmp_loc.path == NULL) {
-                inode_path (inode, NULL, &path);
-                if (path)
-                        tmp_loc.path = path;
-        }
+        fd_unref(iter_fd);
 
         LOCK(&inode->lock);
+    }
 
-        if (list_empty (&inode->fd_list))
-                goto unlock;
-
-        /* perform open as root:root. There is window between linkfile
-         * creation(root:root) and setattr with the correct uid/gid
-         */
-        SYNCTASK_SETID(0, 0);
-
-        /* It's possible that we are the last user of iter_fd after each
-         * iteration. In this case the fd_unref() of iter_fd at the end of
-         * the loop will cause the destruction of the fd. So we need to
-         * iterate the list safely because iter_fd cannot be trusted.
-         */
-        list_for_each_entry_safe (iter_fd, tmp, &inode->fd_list, inode_list) {
-
-                if (fd_is_anonymous (iter_fd))
-                        continue;
-
-                if (dht_fd_open_on_dst (this, iter_fd, dst_node))
-                        continue;
-
-                /* We need to release the inode->lock before calling
-                 * syncop_open() to avoid possible deadlocks. However this
-                 * can cause the iter_fd to be released by other threads.
-                 * To avoid this, we take a reference before releasing the
-                 * lock.
-                 */
-                __fd_ref(iter_fd);
-
-                UNLOCK(&inode->lock);
-
-                /* flags for open are stripped down to allow following the
-                 * new location of the file, otherwise we can get EEXIST or
-                 * truncate the file again as rebalance is moving the data */
-                ret = syncop_open (dst_node, &tmp_loc,
-                                   (iter_fd->flags &
-                                   ~(O_CREAT | O_EXCL | O_TRUNC)),
-                                   iter_fd, NULL, NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_OPEN_FD_ON_DST_FAILED, "failed"
-                                " to open the fd"
-                                " (%p, flags=0%o) on file %s @ %s",
-                                iter_fd, iter_fd->flags, path,
-                                dst_node->name);
-
-                        open_failed = 1;
-                        local->op_errno = -ret;
-                        ret = -1;
-                } else {
-                        dht_fd_ctx_set (this, iter_fd, dst_node);
-                }
-
-                fd_unref(iter_fd);
-
-                LOCK(&inode->lock);
-        }
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-
-        if (open_failed) {
-                ret = -1;
-                goto unlock;
-        }
-        ret = 0;
+    if (open_failed) {
+        ret = -1;
+        goto unlock;
+    }
+    ret = 0;
 
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        loc_wipe (&tmp_loc);
+    loc_wipe(&tmp_loc);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_rebalance_complete_check (xlator_t *this, call_frame_t *frame)
+dht_rebalance_complete_check(xlator_t *this, call_frame_t *frame)
 {
-        int         ret     = -1;
-
-        ret = synctask_new (this->ctx->env, dht_migration_complete_check_task,
-                            dht_migration_complete_check_done,
-                            frame, frame);
-        return ret;
+    int ret = -1;
 
+    ret = synctask_new(this->ctx->env, dht_migration_complete_check_task,
+                       dht_migration_complete_check_done, frame, frame);
+    return ret;
 }
 
 /* During 'in-progress' state, both nodes should have the file */
@@ -1550,790 +1477,777 @@ dht_rebalance_complete_check (xlator_t *this, call_frame_t *frame)
   1 : File is being migrated but not by this DHT layer.
 */
 static int
-dht_inprogress_check_done (int op_ret, call_frame_t *frame, void *data)
+dht_inprogress_check_done(int op_ret, call_frame_t *frame, void *data)
 {
-        dht_local_t *local      = NULL;
-        xlator_t    *dst_subvol = NULL, *src_subvol = NULL;
-        inode_t     *inode      = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *dst_subvol = NULL, *src_subvol = NULL;
+    inode_t *inode = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret != 0)
-                goto out;
+    if (op_ret != 0)
+        goto out;
 
-        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    inode = local->loc.inode ? local->loc.inode : local->fd->inode;
 
-        dht_inode_ctx_get_mig_info (THIS, inode, &src_subvol, &dst_subvol);
-        if (dht_mig_info_is_invalid (local->cached_subvol,
-                                     src_subvol, dst_subvol)) {
-                dst_subvol = dht_subvol_get_cached (THIS, inode);
-                if (!dst_subvol) {
-                        local->op_errno = EINVAL;
-                        goto out;
-                }
+    dht_inode_ctx_get_mig_info(THIS, inode, &src_subvol, &dst_subvol);
+    if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol, dst_subvol)) {
+        dst_subvol = dht_subvol_get_cached(THIS, inode);
+        if (!dst_subvol) {
+            local->op_errno = EINVAL;
+            goto out;
         }
+    }
 
 out:
-        local->rebalance.target_op_fn (THIS, dst_subvol, frame, op_ret);
+    local->rebalance.target_op_fn(THIS, dst_subvol, frame, op_ret);
 
-        return 0;
+    return 0;
 }
 
 static int
-dht_rebalance_inprogress_task (void *data)
+dht_rebalance_inprogress_task(void *data)
 {
-        int           ret             = -1;
-        xlator_t     *src_node        = NULL;
-        xlator_t     *dst_node        = NULL;
-        dht_local_t  *local           = NULL;
-        dict_t       *dict            = NULL;
-        call_frame_t *frame           = NULL;
-        xlator_t     *this            = NULL;
-        char         *path            = NULL;
-        struct iatt   stbuf           = {0,};
-        loc_t         tmp_loc         = {0,};
-        dht_conf_t   *conf            = NULL;
-        inode_t      *inode           = NULL;
-        fd_t         *iter_fd         = NULL;
-        fd_t         *tmp             = NULL;
-        int           open_failed     = 0;
-        uint64_t      tmp_miginfo     = 0;
-        dht_migrate_info_t *miginfo   = NULL;
-
-
-        this  = THIS;
-        frame = data;
-        local = frame->local;
-        conf = this->private;
-
-        src_node = local->cached_subvol;
-
-        if (!local->loc.inode && !local->fd)
-                goto out;
+    int ret = -1;
+    xlator_t *src_node = NULL;
+    xlator_t *dst_node = NULL;
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    char *path = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    loc_t tmp_loc = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+    inode_t *inode = NULL;
+    fd_t *iter_fd = NULL;
+    fd_t *tmp = NULL;
+    int open_failed = 0;
+    uint64_t tmp_miginfo = 0;
+    dht_migrate_info_t *miginfo = NULL;
+
+    this = THIS;
+    frame = data;
+    local = frame->local;
+    conf = this->private;
+
+    src_node = local->cached_subvol;
+
+    if (!local->loc.inode && !local->fd)
+        goto out;
 
-        inode = (!local->fd) ? local->loc.inode : local->fd->inode;
+    inode = (!local->fd) ? local->loc.inode : local->fd->inode;
 
-        /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
-         * as root:root. If a fd is already open, access check won't be done*/
-        if (local->loc.inode) {
-                SYNCTASK_SETID (0, 0);
-                ret = syncop_getxattr (src_node, &local->loc, &dict,
-                                       conf->link_xattr_name, NULL, NULL);
-                SYNCTASK_SETID (frame->root->uid, frame->root->gid);
-        } else {
-                ret = syncop_fgetxattr (src_node, local->fd, &dict,
-                                        conf->link_xattr_name, NULL, NULL);
-        }
+    /* getxattr on cached_subvol for 'linkto' value. Do path based getxattr
+     * as root:root. If a fd is already open, access check won't be done*/
+    if (local->loc.inode) {
+        SYNCTASK_SETID(0, 0);
+        ret = syncop_getxattr(src_node, &local->loc, &dict,
+                              conf->link_xattr_name, NULL, NULL);
+        SYNCTASK_SETID(frame->root->uid, frame->root->gid);
+    } else {
+        ret = syncop_fgetxattr(src_node, local->fd, &dict,
+                               conf->link_xattr_name, NULL, NULL);
+    }
+
+    /*
+     * Each DHT xlator layer has its own name for the linkto xattr.
+     * If the file mode bits indicate the the file is being migrated but
+     * this layer's linkto xattr is not present, it means that another
+     * DHT layer is migrating the file. In this case, return 1 so
+     * the mode bits can be passed on to the higher layer for appropriate
+     * action.
+     */
+
+    if (-ret == ENODATA) {
+        /* This DHT layer is not migrating this file */
+        ret = inode_ctx_reset1(inode, this, &tmp_miginfo);
+        if (tmp_miginfo) {
+            /* This can be a problem if the file was
+             * migrated by two different layers. Raise
+             * a warning here.
+             */
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HAS_MIGINFO,
+                   "%s: Found miginfo in the inode ctx",
+                   tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid));
+            miginfo = (void *)tmp_miginfo;
+            GF_REF_PUT(miginfo);
+        }
+        ret = 1;
+        goto out;
+    }
 
-        /*
-         * Each DHT xlator layer has its own name for the linkto xattr.
-         * If the file mode bits indicate the the file is being migrated but
-         * this layer's linkto xattr is not present, it means that another
-         * DHT layer is migrating the file. In this case, return 1 so
-         * the mode bits can be passed on to the higher layer for appropriate
-         * action.
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_GET_XATTR_FAILED,
+               "%s: failed to get the 'linkto' xattr", local->loc.path);
+        ret = -1;
+        goto out;
+    }
+
+    dst_node = dht_linkfile_subvol(this, NULL, NULL, dict);
+    if (!dst_node) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_NOT_FOUND,
+               "%s: failed to get the 'linkto' xattr from dict",
+               local->loc.path);
+        ret = -1;
+        goto out;
+    }
+
+    local->rebalance.target_node = dst_node;
+
+    if (local->loc.inode) {
+        loc_copy(&tmp_loc, &local->loc);
+    } else {
+        tmp_loc.inode = inode_ref(inode);
+        gf_uuid_copy(tmp_loc.gfid, inode->gfid);
+    }
+
+    /* lookup on dst */
+    ret = syncop_lookup(dst_node, &tmp_loc, &stbuf, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret,
+               DHT_MSG_FILE_LOOKUP_ON_DST_FAILED,
+               "%s: failed to lookup the file on %s",
+               tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+               dst_node->name);
+        ret = -1;
+        goto out;
+    }
+
+    if (gf_uuid_compare(stbuf.ia_gfid, tmp_loc.inode->gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+               "%s: gfid different on the target file on %s",
+               tmp_loc.path ? tmp_loc.path : uuid_utoa(tmp_loc.gfid),
+               dst_node->name);
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
+
+    if (tmp_loc.path == NULL) {
+        inode_path(inode, NULL, &path);
+        if (path)
+            tmp_loc.path = path;
+    }
+
+    LOCK(&inode->lock);
+
+    if (list_empty(&inode->fd_list))
+        goto unlock;
+
+    /* perform open as root:root. There is window between linkfile
+     * creation(root:root) and setattr with the correct uid/gid
+     */
+    SYNCTASK_SETID(0, 0);
+
+    /* It's possible that we are the last user of iter_fd after each
+     * iteration. In this case the fd_unref() of iter_fd at the end of
+     * the loop will cause the destruction of the fd. So we need to
+     * iterate the list safely because iter_fd cannot be trusted.
+     */
+    list_for_each_entry_safe(iter_fd, tmp, &inode->fd_list, inode_list)
+    {
+        if (fd_is_anonymous(iter_fd))
+            continue;
+
+        if (dht_fd_open_on_dst(this, iter_fd, dst_node))
+            continue;
+
+        /* We need to release the inode->lock before calling
+         * syncop_open() to avoid possible deadlocks. However this
+         * can cause the iter_fd to be released by other threads.
+         * To avoid this, we take a reference before releasing the
+         * lock.
          */
+        __fd_ref(iter_fd);
 
-        if (-ret == ENODATA) {
-                /* This DHT layer is not migrating this file */
-                ret = inode_ctx_reset1 (inode, this, &tmp_miginfo);
-                if (tmp_miginfo) {
-                        /* This can be a problem if the file was
-                         * migrated by two different layers. Raise
-                         * a warning here.
-                         */
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_HAS_MIGINFO,
-                                "%s: Found miginfo in the inode ctx",
-                                tmp_loc.path ? tmp_loc.path :
-                                uuid_utoa (tmp_loc.gfid));
-                        miginfo = (void *)tmp_miginfo;
-                        GF_REF_PUT (miginfo);
-                }
-                ret = 1;
-                goto out;
-        }
+        UNLOCK(&inode->lock);
 
+        /* flags for open are stripped down to allow following the
+         * new location of the file, otherwise we can get EEXIST or
+         * truncate the file again as rebalance is moving the data */
+        ret = syncop_open(dst_node, &tmp_loc,
+                          (iter_fd->flags & ~(O_CREAT | O_EXCL | O_TRUNC)),
+                          iter_fd, NULL, NULL);
         if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_GET_XATTR_FAILED,
-                        "%s: failed to get the 'linkto' xattr",
-                        local->loc.path);
-                ret = -1;
-                goto out;
-        }
-
-        dst_node = dht_linkfile_subvol (this, NULL, NULL, dict);
-        if (!dst_node) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SUBVOL_NOT_FOUND,
-                        "%s: failed to get the 'linkto' xattr from dict",
-                        local->loc.path);
-                ret = -1;
-                goto out;
-        }
-
-        local->rebalance.target_node = dst_node;
-
-        if (local->loc.inode) {
-                loc_copy (&tmp_loc, &local->loc);
+            gf_msg(this->name, GF_LOG_ERROR, -ret,
+                   DHT_MSG_OPEN_FD_ON_DST_FAILED,
+                   "failed to send open "
+                   "the fd (%p, flags=0%o) on file %s @ %s",
+                   iter_fd, iter_fd->flags, path, dst_node->name);
+            ret = -1;
+            open_failed = 1;
         } else {
-                tmp_loc.inode = inode_ref (inode);
-                gf_uuid_copy (tmp_loc.gfid, inode->gfid);
+            /* Potential fd leak if this fails here as it will be
+               reopened at the next Phase1/2 check */
+            dht_fd_ctx_set(this, iter_fd, dst_node);
         }
 
-        /* lookup on dst */
-        ret = syncop_lookup (dst_node, &tmp_loc, &stbuf, NULL,
-                             NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_FILE_LOOKUP_ON_DST_FAILED,
-                        "%s: failed to lookup the file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        dst_node->name);
-                ret = -1;
-                goto out;
-        }
-
-        if (gf_uuid_compare (stbuf.ia_gfid, tmp_loc.inode->gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "%s: gfid different on the target file on %s",
-                        tmp_loc.path ? tmp_loc.path : uuid_utoa (tmp_loc.gfid),
-                        dst_node->name);
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
-
-        if (tmp_loc.path == NULL) {
-                inode_path (inode, NULL, &path);
-                if (path)
-                        tmp_loc.path = path;
-        }
+        fd_unref(iter_fd);
 
         LOCK(&inode->lock);
+    }
 
-        if (list_empty (&inode->fd_list))
-                goto unlock;
-
-        /* perform open as root:root. There is window between linkfile
-         * creation(root:root) and setattr with the correct uid/gid
-         */
-        SYNCTASK_SETID (0, 0);
-
-        /* It's possible that we are the last user of iter_fd after each
-         * iteration. In this case the fd_unref() of iter_fd at the end of
-         * the loop will cause the destruction of the fd. So we need to
-         * iterate the list safely because iter_fd cannot be trusted.
-         */
-        list_for_each_entry_safe (iter_fd, tmp, &inode->fd_list, inode_list) {
-                if (fd_is_anonymous (iter_fd))
-                        continue;
-
-                if (dht_fd_open_on_dst (this, iter_fd, dst_node))
-                        continue;
-
-                /* We need to release the inode->lock before calling
-                 * syncop_open() to avoid possible deadlocks. However this
-                 * can cause the iter_fd to be released by other threads.
-                 * To avoid this, we take a reference before releasing the
-                 * lock.
-                 */
-                __fd_ref(iter_fd);
-
-                UNLOCK(&inode->lock);
-
-                /* flags for open are stripped down to allow following the
-                 * new location of the file, otherwise we can get EEXIST or
-                 * truncate the file again as rebalance is moving the data */
-                ret = syncop_open (dst_node, &tmp_loc,
-                                  (iter_fd->flags &
-                                   ~(O_CREAT | O_EXCL | O_TRUNC)),
-                                   iter_fd, NULL, NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_OPEN_FD_ON_DST_FAILED,
-                                "failed to send open "
-                                "the fd (%p, flags=0%o) on file %s @ %s",
-                                iter_fd, iter_fd->flags, path,
-                                dst_node->name);
-                        ret = -1;
-                        open_failed = 1;
-                } else {
-                        /* Potential fd leak if this fails here as it will be
-                           reopened at the next Phase1/2 check */
-                        dht_fd_ctx_set (this, iter_fd, dst_node);
-                }
-
-                fd_unref(iter_fd);
-
-                LOCK(&inode->lock);
-        }
-
-        SYNCTASK_SETID (frame->root->uid, frame->root->gid);
+    SYNCTASK_SETID(frame->root->uid, frame->root->gid);
 
 unlock:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 
-        if (open_failed) {
-                ret = -1;
-                goto out;
-        }
+    if (open_failed) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dht_inode_ctx_set_mig_info (this, inode, src_node, dst_node);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SET_INODE_CTX_FAILED,
-                        "%s: failed to set inode-ctx target file at %s",
-                        local->loc.path, dst_node->name);
-                goto out;
-        }
+    ret = dht_inode_ctx_set_mig_info(this, inode, src_node, dst_node);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+               "%s: failed to set inode-ctx target file at %s", local->loc.path,
+               dst_node->name);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (dict) {
-                dict_unref (dict);
-        }
+    if (dict) {
+        dict_unref(dict);
+    }
 
-        loc_wipe (&tmp_loc);
-        return ret;
+    loc_wipe(&tmp_loc);
+    return ret;
 }
 
 int
-dht_rebalance_in_progress_check (xlator_t *this, call_frame_t *frame)
+dht_rebalance_in_progress_check(xlator_t *this, call_frame_t *frame)
 {
+    int ret = -1;
 
-        int         ret     = -1;
-
-        ret = synctask_new (this->ctx->env, dht_rebalance_inprogress_task,
-                            dht_inprogress_check_done,
-                            frame, frame);
-        return ret;
+    ret = synctask_new(this->ctx->env, dht_rebalance_inprogress_task,
+                       dht_inprogress_check_done, frame, frame);
+    return ret;
 }
 
 int
-dht_inode_ctx_layout_set (inode_t *inode, xlator_t *this,
-                          dht_layout_t *layout_int)
+dht_inode_ctx_layout_set(inode_t *inode, xlator_t *this,
+                         dht_layout_t *layout_int)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
-
-        ret = dht_inode_ctx_get (inode, this, &ctx);
-        if (!ret && ctx) {
-                ctx->layout = layout_int;
-        } else {
-                ctx = GF_CALLOC (1, sizeof (*ctx), gf_dht_mt_inode_ctx_t);
-                if (!ctx)
-                        return ret;
-                ctx->layout = layout_int;
-        }
-
-        ret = dht_inode_ctx_set (inode, this, ctx);
-
-        return ret;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+
+    ret = dht_inode_ctx_get(inode, this, &ctx);
+    if (!ret && ctx) {
+        ctx->layout = layout_int;
+    } else {
+        ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+        if (!ctx)
+            return ret;
+        ctx->layout = layout_int;
+    }
+
+    ret = dht_inode_ctx_set(inode, this, ctx);
+
+    return ret;
 }
 
-
 void
-dht_inode_ctx_time_set (inode_t *inode, xlator_t *this, struct iatt *stat)
+dht_inode_ctx_time_set(inode_t *inode, xlator_t *this, struct iatt *stat)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        dht_stat_time_t         *time           = 0;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    dht_stat_time_t *time = 0;
+    int ret = -1;
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (ret)
-		return;
+    if (ret)
+        return;
 
-        time = &ctx->time;
+    time = &ctx->time;
 
-	time->mtime      = stat->ia_mtime;
-	time->mtime_nsec = stat->ia_mtime_nsec;
+    time->mtime = stat->ia_mtime;
+    time->mtime_nsec = stat->ia_mtime_nsec;
 
-	time->ctime      = stat->ia_ctime;
-	time->ctime_nsec = stat->ia_ctime_nsec;
+    time->ctime = stat->ia_ctime;
+    time->ctime_nsec = stat->ia_ctime_nsec;
 
-	time->atime      = stat->ia_atime;
-	time->atime_nsec = stat->ia_atime_nsec;
+    time->atime = stat->ia_atime;
+    time->atime_nsec = stat->ia_atime_nsec;
 
-	return;
+    return;
 }
 
-
 int
-dht_inode_ctx_time_update (inode_t *inode, xlator_t *this, struct iatt *stat,
-                           int32_t post)
+dht_inode_ctx_time_update(inode_t *inode, xlator_t *this, struct iatt *stat,
+                          int32_t post)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        dht_stat_time_t         *time           = 0;
-        int                      ret            = -1;
+    dht_inode_ctx_t *ctx = NULL;
+    dht_stat_time_t *time = 0;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO (this->name, stat, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, stat, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        ret = dht_inode_ctx_get (inode, this, &ctx);
+    ret = dht_inode_ctx_get(inode, this, &ctx);
 
-        if (ret) {
-                ctx = GF_CALLOC (1, sizeof (*ctx), gf_dht_mt_inode_ctx_t);
-                if (!ctx)
-                        return -1;
-        }
+    if (ret) {
+        ctx = GF_CALLOC(1, sizeof(*ctx), gf_dht_mt_inode_ctx_t);
+        if (!ctx)
+            return -1;
+    }
 
-        time = &ctx->time;
+    time = &ctx->time;
 
-        DHT_UPDATE_TIME(time->mtime, time->mtime_nsec,
-                        stat->ia_mtime, stat->ia_mtime_nsec, inode, post);
-        DHT_UPDATE_TIME(time->ctime, time->ctime_nsec,
-                        stat->ia_ctime, stat->ia_ctime_nsec, inode, post);
-        DHT_UPDATE_TIME(time->atime, time->atime_nsec,
-                        stat->ia_atime, stat->ia_atime_nsec, inode, post);
+    DHT_UPDATE_TIME(time->mtime, time->mtime_nsec, stat->ia_mtime,
+                    stat->ia_mtime_nsec, inode, post);
+    DHT_UPDATE_TIME(time->ctime, time->ctime_nsec, stat->ia_ctime,
+                    stat->ia_ctime_nsec, inode, post);
+    DHT_UPDATE_TIME(time->atime, time->atime_nsec, stat->ia_atime,
+                    stat->ia_atime_nsec, inode, post);
 
-        ret = dht_inode_ctx_set (inode, this, ctx);
+    ret = dht_inode_ctx_set(inode, this, ctx);
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_inode_ctx_get (inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx)
+dht_inode_ctx_get(inode_t *inode, xlator_t *this, dht_inode_ctx_t **ctx)
 {
-        int             ret     = -1;
-        uint64_t        ctx_int = 0;
+    int ret = -1;
+    uint64_t ctx_int = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        ret = inode_ctx_get (inode, this, &ctx_int);
+    ret = inode_ctx_get(inode, this, &ctx_int);
 
-        if (ret)
-                return ret;
+    if (ret)
+        return ret;
 
-        if (ctx)
-                *ctx = (dht_inode_ctx_t *) ctx_int;
+    if (ctx)
+        *ctx = (dht_inode_ctx_t *)ctx_int;
 out:
-        return ret;
+    return ret;
 }
 
-int dht_inode_ctx_set (inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx)
+int
+dht_inode_ctx_set(inode_t *inode, xlator_t *this, dht_inode_ctx_t *ctx)
 {
-        int             ret = -1;
-        uint64_t        ctx_int = 0;
+    int ret = -1;
+    uint64_t ctx_int = 0;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
-        GF_VALIDATE_OR_GOTO (this->name, ctx, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, ctx, out);
 
-        ctx_int = (long)ctx;
-        ret = inode_ctx_set (inode, this, &ctx_int);
+    ctx_int = (long)ctx;
+    ret = inode_ctx_set(inode, this, &ctx_int);
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_subvol_status (dht_conf_t *conf, xlator_t *subvol)
+dht_subvol_status(dht_conf_t *conf, xlator_t *subvol)
 {
-        int i;
+    int i;
 
-        for (i=0 ; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == subvol) {
-                        return conf->subvolume_status[i];
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == subvol) {
+            return conf->subvolume_status[i];
         }
-        return 0;
+    }
+    return 0;
 }
 
-inode_t*
-dht_heal_path (xlator_t *this, char *path, inode_table_t *itable)
+inode_t *
+dht_heal_path(xlator_t *this, char *path, inode_table_t *itable)
 {
-        int             ret             = -1;
-        struct iatt     iatt            = {0, };
-        inode_t        *linked_inode    = NULL;
-        loc_t           loc             = {0, };
-        char           *bname           = NULL;
-        char           *save_ptr        = NULL;
-        uuid_t          gfid            = {0, };
-        char           *tmp_path        = NULL;
-
-
-        tmp_path = gf_strdup (path);
-        if (!tmp_path) {
-                goto out;
-        }
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *linked_inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    char *bname = NULL;
+    char *save_ptr = NULL;
+    uuid_t gfid = {
+        0,
+    };
+    char *tmp_path = NULL;
+
+    tmp_path = gf_strdup(path);
+    if (!tmp_path) {
+        goto out;
+    }
 
-        memset (gfid, 0, 16);
-        gfid[15] = 1;
+    memset(gfid, 0, 16);
+    gfid[15] = 1;
 
-        gf_uuid_copy (loc.pargfid, gfid);
-        loc.parent = inode_ref (itable->root);
+    gf_uuid_copy(loc.pargfid, gfid);
+    loc.parent = inode_ref(itable->root);
 
-        bname = strtok_r (tmp_path, "/",  &save_ptr);
+    bname = strtok_r(tmp_path, "/", &save_ptr);
 
-        /* sending a lookup on parent directory,
-         * Eg:  if  path is like /a/b/c/d/e/f/g/
-         * then we will send a lookup on a first and then b,c,d,etc
-         */
+    /* sending a lookup on parent directory,
+     * Eg:  if  path is like /a/b/c/d/e/f/g/
+     * then we will send a lookup on a first and then b,c,d,etc
+     */
 
-        while (bname) {
-                linked_inode = NULL;
-                loc.inode = inode_grep (itable, loc.parent, bname);
-                if (loc.inode == NULL) {
-                        loc.inode = inode_new (itable);
-                        if (loc.inode == NULL) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                } else {
-                        /*
-                         * Inode is already populated in the inode table.
-                         * Which means we already looked up the inode and
-                         * linked with a dentry. So that we will skip
-                         * lookup on this entry, and proceed to next.
-                         */
-                        linked_inode = loc.inode;
-                        bname = strtok_r (NULL, "/",  &save_ptr);
-                        inode_unref (loc.parent);
-                        if (!bname) {
-                                goto out;
-                        }
-                        loc.parent = loc.inode;
-                        gf_uuid_copy (loc.pargfid, loc.inode->gfid);
-                        loc.inode = NULL;
-                        continue;
-                }
+    while (bname) {
+        linked_inode = NULL;
+        loc.inode = inode_grep(itable, loc.parent, bname);
+        if (loc.inode == NULL) {
+            loc.inode = inode_new(itable);
+            if (loc.inode == NULL) {
+                ret = -ENOMEM;
+                goto out;
+            }
+        } else {
+            /*
+             * Inode is already populated in the inode table.
+             * Which means we already looked up the inode and
+             * linked with a dentry. So that we will skip
+             * lookup on this entry, and proceed to next.
+             */
+            linked_inode = loc.inode;
+            bname = strtok_r(NULL, "/", &save_ptr);
+            inode_unref(loc.parent);
+            if (!bname) {
+                goto out;
+            }
+            loc.parent = loc.inode;
+            gf_uuid_copy(loc.pargfid, loc.inode->gfid);
+            loc.inode = NULL;
+            continue;
+        }
 
-                loc.name = bname;
-                ret = loc_path (&loc, bname);
+        loc.name = bname;
+        ret = loc_path(&loc, bname);
 
-                ret = syncop_lookup (this, &loc, &iatt, NULL, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_DIR_SELFHEAL_FAILED,
-                                "Healing of path %s failed on subvolume %s for "
-                                "directory %s", path, this->name, bname);
-                        goto out;
-                }
+        ret = syncop_lookup(this, &loc, &iatt, NULL, NULL, NULL);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_SELFHEAL_FAILED,
+                   "Healing of path %s failed on subvolume %s for "
+                   "directory %s",
+                   path, this->name, bname);
+            goto out;
+        }
 
-                linked_inode = inode_link (loc.inode, loc.parent, bname, &iatt);
-                if (!linked_inode)
-                        goto out;
+        linked_inode = inode_link(loc.inode, loc.parent, bname, &iatt);
+        if (!linked_inode)
+            goto out;
 
-                loc_wipe (&loc);
-                gf_uuid_copy (loc.pargfid, linked_inode->gfid);
-                loc.inode = NULL;
+        loc_wipe(&loc);
+        gf_uuid_copy(loc.pargfid, linked_inode->gfid);
+        loc.inode = NULL;
 
-                bname = strtok_r (NULL, "/",  &save_ptr);
-                if (bname)
-                        loc.parent = linked_inode;
-        }
+        bname = strtok_r(NULL, "/", &save_ptr);
+        if (bname)
+            loc.parent = linked_inode;
+    }
 out:
-        inode_ref (linked_inode);
-        loc_wipe (&loc);
-        GF_FREE (tmp_path);
+    inode_ref(linked_inode);
+    loc_wipe(&loc);
+    GF_FREE(tmp_path);
 
-        return linked_inode;
+    return linked_inode;
 }
 
-
 int
-dht_heal_full_path (void *data)
+dht_heal_full_path(void *data)
 {
-        call_frame_t            *heal_frame     = data;
-        dht_local_t             *local          = NULL;
-        loc_t                    loc            = {0, };
-        dict_t                  *dict           = NULL;
-        char                    *path           = NULL;
-        int                      ret            = -1;
-        xlator_t                *source         = NULL;
-        xlator_t                *this           = NULL;
-        inode_table_t           *itable         = NULL;
-        inode_t                 *inode          = NULL;
-        inode_t                 *tmp_inode      = NULL;
-
-        GF_VALIDATE_OR_GOTO ("DHT", heal_frame, out);
-
-        local = heal_frame->local;
-        this = heal_frame->this;
-        source = heal_frame->cookie;
-        heal_frame->cookie = NULL;
-        gf_uuid_copy (loc.gfid, local->gfid);
-
-        if (local->loc.inode)
-                loc.inode = inode_ref (local->loc.inode);
-        else
-                goto out;
-
-        itable = loc.inode->table;
-        ret = syncop_getxattr (source, &loc, &dict,
-                       GET_ANCESTRY_PATH_KEY, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_INFO, -ret,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Failed to get path from subvol %s. Aborting "
-                        "directory healing.", source->name);
-                goto out;
-        }
+    call_frame_t *heal_frame = data;
+    dht_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
+    dict_t *dict = NULL;
+    char *path = NULL;
+    int ret = -1;
+    xlator_t *source = NULL;
+    xlator_t *this = NULL;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+    inode_t *tmp_inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("DHT", heal_frame, out);
+
+    local = heal_frame->local;
+    this = heal_frame->this;
+    source = heal_frame->cookie;
+    heal_frame->cookie = NULL;
+    gf_uuid_copy(loc.gfid, local->gfid);
+
+    if (local->loc.inode)
+        loc.inode = inode_ref(local->loc.inode);
+    else
+        goto out;
 
-        ret = dict_get_str (dict, GET_ANCESTRY_PATH_KEY, &path);
-        if (path) {
-                inode = dht_heal_path (this, path, itable);
-                if (inode && inode != local->inode) {
-                        /*
-                         * if inode returned by heal function is different
-                         * from what we passed, which means a racing thread
-                         * already linked a different inode for dentry.
-                         * So we will update our local->inode, so that we can
-                         * retrurn proper inode.
-                         */
-                        tmp_inode = local->inode;
-                        local->inode = inode;
-                        inode_unref (tmp_inode);
-                        tmp_inode = NULL;
-                } else {
-                        inode_unref (inode);
-                }
+    itable = loc.inode->table;
+    ret = syncop_getxattr(source, &loc, &dict, GET_ANCESTRY_PATH_KEY, NULL,
+                          NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_SELFHEAL_FAILED,
+               "Failed to get path from subvol %s. Aborting "
+               "directory healing.",
+               source->name);
+        goto out;
+    }
+
+    ret = dict_get_str(dict, GET_ANCESTRY_PATH_KEY, &path);
+    if (path) {
+        inode = dht_heal_path(this, path, itable);
+        if (inode && inode != local->inode) {
+            /*
+             * if inode returned by heal function is different
+             * from what we passed, which means a racing thread
+             * already linked a different inode for dentry.
+             * So we will update our local->inode, so that we can
+             * retrurn proper inode.
+             */
+            tmp_inode = local->inode;
+            local->inode = inode;
+            inode_unref(tmp_inode);
+            tmp_inode = NULL;
+        } else {
+            inode_unref(inode);
         }
+    }
 
 out:
-        loc_wipe (&loc);
-        if (dict)
-                dict_unref (dict);
-        return 0;
+    loc_wipe(&loc);
+    if (dict)
+        dict_unref(dict);
+    return 0;
 }
 
 int
-dht_heal_full_path_done (int op_ret, call_frame_t *heal_frame, void *data)
+dht_heal_full_path_done(int op_ret, call_frame_t *heal_frame, void *data)
 {
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+
+    local = heal_frame->local;
+    main_frame = local->main_frame;
+    local->main_frame = NULL;
+    this = heal_frame->this;
+
+    dht_set_fixed_dir_stat(&local->postparent);
+    if (local->need_xattr_heal) {
+        local->need_xattr_heal = 0;
+        ret = dht_dir_xattr_heal(this, local);
+        if (ret)
+            gf_msg(this->name, GF_LOG_ERROR, ret, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                   "xattr heal failed for directory  %s ", local->loc.path);
+    }
 
-        call_frame_t            *main_frame       = NULL;
-        dht_local_t             *local            = NULL;
-        xlator_t                *this             = NULL;
-        int                     ret               = -1;
-
-        local = heal_frame->local;
-        main_frame = local->main_frame;
-        local->main_frame = NULL;
-        this = heal_frame->this;
-
-        dht_set_fixed_dir_stat (&local->postparent);
-        if (local->need_xattr_heal) {
-                local->need_xattr_heal = 0;
-                ret =  dht_dir_xattr_heal (this, local);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_ERROR, ret,
-                                DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                "xattr heal failed for directory  %s ",
-                                local->loc.path);
-        }
-
-        DHT_STACK_UNWIND (lookup, main_frame, 0, 0,
-                          local->inode, &local->stbuf, local->xattr,
-                          &local->postparent);
+    DHT_STACK_UNWIND(lookup, main_frame, 0, 0, local->inode, &local->stbuf,
+                     local->xattr, &local->postparent);
 
-        DHT_STACK_DESTROY (heal_frame);
-        return 0;
+    DHT_STACK_DESTROY(heal_frame);
+    return 0;
 }
 
 /* This function must be called inside an inode lock */
 int
-__dht_lock_subvol_set (inode_t *inode, xlator_t *this,
-                       xlator_t *lock_subvol)
+__dht_lock_subvol_set(inode_t *inode, xlator_t *this, xlator_t *lock_subvol)
 {
-        dht_inode_ctx_t         *ctx            = NULL;
-        int                      ret            = -1;
-        uint64_t                 value          = 0;
+    dht_inode_ctx_t *ctx = NULL;
+    int ret = -1;
+    uint64_t value = 0;
 
-        GF_VALIDATE_OR_GOTO (this->name, inode, out);
+    GF_VALIDATE_OR_GOTO(this->name, inode, out);
 
-        ret = __inode_ctx_get0 (inode, this, &value);
-        if (ret || !value) {
-                return -1;
-        }
+    ret = __inode_ctx_get0(inode, this, &value);
+    if (ret || !value) {
+        return -1;
+    }
 
-        ctx = (dht_inode_ctx_t *) value;
-        ctx->lock_subvol = lock_subvol;
+    ctx = (dht_inode_ctx_t *)value;
+    ctx->lock_subvol = lock_subvol;
 out:
-        return ret;
+    return ret;
 }
 
-xlator_t*
-dht_get_lock_subvolume (xlator_t *this, struct gf_flock *lock,
-                        dht_local_t *local)
+xlator_t *
+dht_get_lock_subvolume(xlator_t *this, struct gf_flock *lock,
+                       dht_local_t *local)
 {
-        xlator_t                *subvol                  = NULL;
-        inode_t                 *inode                   = NULL;
-        int32_t                  ret                     = -1;
-        uint64_t                 value                   = 0;
-        xlator_t                *cached_subvol           = NULL;
-        dht_inode_ctx_t         *ctx                     = NULL;
-        char                     gfid[GF_UUID_BUF_SIZE]  = {0};
-
-        GF_VALIDATE_OR_GOTO (this->name, lock, out);
-        GF_VALIDATE_OR_GOTO (this->name, local, out);
+    xlator_t *subvol = NULL;
+    inode_t *inode = NULL;
+    int32_t ret = -1;
+    uint64_t value = 0;
+    xlator_t *cached_subvol = NULL;
+    dht_inode_ctx_t *ctx = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        cached_subvol = local->cached_subvol;
+    GF_VALIDATE_OR_GOTO(this->name, lock, out);
+    GF_VALIDATE_OR_GOTO(this->name, local, out);
 
-        if (local->loc.inode || local->fd) {
-                inode = local->loc.inode ? local->loc.inode : local->fd->inode;
-        }
+    cached_subvol = local->cached_subvol;
 
-        if (!inode)
-                goto out;
+    if (local->loc.inode || local->fd) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    }
 
-        if (!(IA_ISDIR (inode->ia_type) || IA_ISINVAL (inode->ia_type))) {
-                /*
-                 * We may get non-linked inode for directories as part
-                 * of the selfheal code path. So checking  for IA_INVAL
-                 * type also. This will only happen for directory.
-                 */
-                subvol = local->cached_subvol;
-                goto out;
-        }
+    if (!inode)
+        goto out;
 
-        if (lock->l_type != F_UNLCK) {
-                /*
-                 * inode purging might happen on NFS between a lk
-                 * and unlk. Due to this lk and unlk might be sent
-                 * to different subvols.
-                 * So during a lock request, taking a ref on inode
-                 * to prevent inode purging. inode unref will happen
-                 * in unlock cbk code path.
-                 */
-                inode_ref (inode);
-        }
+    if (!(IA_ISDIR(inode->ia_type) || IA_ISINVAL(inode->ia_type))) {
+        /*
+         * We may get non-linked inode for directories as part
+         * of the selfheal code path. So checking  for IA_INVAL
+         * type also. This will only happen for directory.
+         */
+        subvol = local->cached_subvol;
+        goto out;
+    }
 
-        LOCK (&inode->lock);
-                ret = __inode_ctx_get0 (inode, this, &value);
-                if (!ret && value) {
-                        ctx = (dht_inode_ctx_t *) value;
-                        subvol = ctx->lock_subvol;
-                }
-                if (!subvol && lock->l_type != F_UNLCK && cached_subvol) {
-                        ret = __dht_lock_subvol_set (inode, this,
-                                                     cached_subvol);
-                        if (ret) {
-                                gf_uuid_unparse(inode->gfid, gfid);
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_SET_INODE_CTX_FAILED,
-                                        "Failed to set lock_subvol in "
-                                        "inode ctx for gfid %s",
-                                        gfid);
-                                goto unlock;
-                        }
-                        subvol = cached_subvol;
-                }
+    if (lock->l_type != F_UNLCK) {
+        /*
+         * inode purging might happen on NFS between a lk
+         * and unlk. Due to this lk and unlk might be sent
+         * to different subvols.
+         * So during a lock request, taking a ref on inode
+         * to prevent inode purging. inode unref will happen
+         * in unlock cbk code path.
+         */
+        inode_ref(inode);
+    }
+
+    LOCK(&inode->lock);
+    ret = __inode_ctx_get0(inode, this, &value);
+    if (!ret && value) {
+        ctx = (dht_inode_ctx_t *)value;
+        subvol = ctx->lock_subvol;
+    }
+    if (!subvol && lock->l_type != F_UNLCK && cached_subvol) {
+        ret = __dht_lock_subvol_set(inode, this, cached_subvol);
+        if (ret) {
+            gf_uuid_unparse(inode->gfid, gfid);
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SET_INODE_CTX_FAILED,
+                   "Failed to set lock_subvol in "
+                   "inode ctx for gfid %s",
+                   gfid);
+            goto unlock;
+        }
+        subvol = cached_subvol;
+    }
 unlock:
-        UNLOCK (&inode->lock);
-        if (!subvol && inode && lock->l_type != F_UNLCK) {
-                inode_unref (inode);
-        }
+    UNLOCK(&inode->lock);
+    if (!subvol && inode && lock->l_type != F_UNLCK) {
+        inode_unref(inode);
+    }
 out:
-        return subvol;
+    return subvol;
 }
 
 int
-dht_lk_inode_unref (call_frame_t *frame, int32_t op_ret)
+dht_lk_inode_unref(call_frame_t *frame, int32_t op_ret)
 {
-        int                     ret                     = -1;
-        dht_local_t            *local                   = NULL;
-        inode_t                *inode                   = NULL;
-        xlator_t               *this                    = NULL;
-        char                    gfid[GF_UUID_BUF_SIZE]  = {0};
+    int ret = -1;
+    dht_local_t *local = NULL;
+    inode_t *inode = NULL;
+    xlator_t *this = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        this = frame->this;
+    local = frame->local;
+    this = frame->this;
 
-        if (local->loc.inode || local->fd) {
-                inode = local->loc.inode ? local->loc.inode : local->fd->inode;
-        }
-        if (!inode) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LOCK_INODE_UNREF_FAILED,
-                        "Found a NULL inode. Failed to unref the inode");
-                goto out;
-        }
+    if (local->loc.inode || local->fd) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+    }
+    if (!inode) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LOCK_INODE_UNREF_FAILED,
+               "Found a NULL inode. Failed to unref the inode");
+        goto out;
+    }
 
-        if (!(IA_ISDIR (inode->ia_type) || IA_ISINVAL (inode->ia_type))) {
-                ret = 0;
-                goto out;
-        }
+    if (!(IA_ISDIR(inode->ia_type) || IA_ISINVAL(inode->ia_type))) {
+        ret = 0;
+        goto out;
+    }
 
-        switch (local->lock_type) {
+    switch (local->lock_type) {
         case F_RDLCK:
         case F_WRLCK:
-                if (op_ret) {
-                        gf_uuid_unparse(inode->gfid, gfid);
-                        gf_msg_debug (this->name, 0,
-                                "lock request failed for gfid %s", gfid);
-                        inode_unref (inode);
-                        goto out;
-                }
-                break;
+            if (op_ret) {
+                gf_uuid_unparse(inode->gfid, gfid);
+                gf_msg_debug(this->name, 0, "lock request failed for gfid %s",
+                             gfid);
+                inode_unref(inode);
+                goto out;
+            }
+            break;
 
         case F_UNLCK:
-                if (!op_ret) {
-                        inode_unref (inode);
-                } else {
-                        gf_uuid_unparse(inode->gfid, gfid);
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_LOCK_INODE_UNREF_FAILED,
-                                "Unlock request failed for gfid %s."
-                                "Failed to unref the inode", gfid);
-                        goto out;
-                }
+            if (!op_ret) {
+                inode_unref(inode);
+            } else {
+                gf_uuid_unparse(inode->gfid, gfid);
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_LOCK_INODE_UNREF_FAILED,
+                       "Unlock request failed for gfid %s."
+                       "Failed to unref the inode",
+                       gfid);
+                goto out;
+            }
         default:
-                break;
-        }
-        ret = 0;
+            break;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* Code to update custom extended attributes from src dict to dst dict
-*/
+ */
 void
-dht_dir_set_heal_xattr (xlator_t *this, dht_local_t *local, dict_t *dst,
-                        dict_t *src, int *uret, int *uflag)
+dht_dir_set_heal_xattr(xlator_t *this, dht_local_t *local, dict_t *dst,
+                       dict_t *src, int *uret, int *uflag)
 {
-        int               ret                 = -1;
-        data_t           *keyval              = NULL;
-        int               luret               = -1;
-        int               luflag              = -1;
-        int               i                   = 0;
-
-        if (!src || !dst) {
-                gf_msg (this->name, GF_LOG_WARNING, EINVAL,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "src or dst is NULL. Failed to set "
-                        " dictionary value for path %s",
-                        local->loc.path);
-                return;
-        }
-        /* Check if any user xattr present in src dict and set
-           it to dst dict
-        */
-        luret = dict_foreach_fnmatch (src, "user.*",
-                                      dht_set_user_xattr, dst);
-        /* Check if any other custom xattr present in src dict
-           and set it to dst dict, here index start from 1 because
-           user xattr already checked in previous statement
-        */
-        for (i = 1; xattrs_to_heal[i]; i++) {
-                keyval = dict_get (src, xattrs_to_heal[i]);
-                if (keyval) {
-                        luflag = 1;
-                        ret = dict_set (dst, xattrs_to_heal[i], keyval);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set dictionary value:key = %s for "
-                                        "path %s", xattrs_to_heal[i],
-                                        local->loc.path);
-                        keyval = NULL;
-                }
-        }
-        if (uret)
-                (*uret) = luret;
-        if (uflag)
-                (*uflag) = luflag;
+    int ret = -1;
+    data_t *keyval = NULL;
+    int luret = -1;
+    int luflag = -1;
+    int i = 0;
+
+    if (!src || !dst) {
+        gf_msg(this->name, GF_LOG_WARNING, EINVAL, DHT_MSG_DICT_SET_FAILED,
+               "src or dst is NULL. Failed to set "
+               " dictionary value for path %s",
+               local->loc.path);
+        return;
+    }
+    /* Check if any user xattr present in src dict and set
+       it to dst dict
+    */
+    luret = dict_foreach_fnmatch(src, "user.*", dht_set_user_xattr, dst);
+    /* Check if any other custom xattr present in src dict
+       and set it to dst dict, here index start from 1 because
+       user xattr already checked in previous statement
+    */
+    for (i = 1; xattrs_to_heal[i]; i++) {
+        keyval = dict_get(src, xattrs_to_heal[i]);
+        if (keyval) {
+            luflag = 1;
+            ret = dict_set(dst, xattrs_to_heal[i], keyval);
+            if (ret)
+                gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
+                       DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set dictionary value:key = %s for "
+                       "path %s",
+                       xattrs_to_heal[i], local->loc.path);
+            keyval = NULL;
+        }
+    }
+    if (uret)
+        (*uret) = luret;
+    if (uflag)
+        (*uflag) = luflag;
 }
diff --git a/xlators/cluster/dht/src/dht-inode-read.c b/xlators/cluster/dht/src/dht-inode-read.c
index 53215a3d34d..f2be5120e37 100644
--- a/xlators/cluster/dht/src/dht-inode-read.c
+++ b/xlators/cluster/dht/src/dht-inode-read.c
@@ -10,1544 +10,1475 @@
 
 #include "dht-common.h"
 
-int dht_access2 (xlator_t *this, xlator_t *dst_node,
-                 call_frame_t *frame, int ret);
-int dht_readv2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
-int dht_attr2 (xlator_t *this, xlator_t *dst_node,
-               call_frame_t *frame, int ret);
-int dht_open2 (xlator_t *this, xlator_t *dst_node,
-               call_frame_t *frame, int ret);
-int dht_flush2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
-int dht_lk2 (xlator_t *this, xlator_t *dst_node,
-             call_frame_t *frame, int ret);
-int dht_fsync2 (xlator_t *this, xlator_t *dst_node,
-                call_frame_t *frame, int ret);
 int
-dht_common_xattrop2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                     int ret);
+dht_access2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_readv2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_attr2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_open2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_flush2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_lk2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_fsync2(xlator_t *this, xlator_t *dst_node, call_frame_t *frame, int ret);
+int
+dht_common_xattrop2(xlator_t *this, xlator_t *subvol, call_frame_t *frame,
+                    int ret);
 
 int
-dht_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = 0;
-
-        local = frame->local;
-        prev = cookie;
-
-        local->op_errno = op_errno;
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        /* Update ctx if the fd has been opened on the target*/
-        if (!op_ret && (local->call_cnt == 1)) {
-                dht_fd_ctx_set (this, fd, prev);
-                goto out;
-        }
-
-        if (!op_ret || (local->call_cnt != 1))
-                goto out;
-
-        /* rebalance would have happened */
-        local->rebalance.target_op_fn = dht_open2;
-        ret = dht_rebalance_complete_check (this, frame);
-        if (!ret)
-                return 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = 0;
+
+    local = frame->local;
+    prev = cookie;
+
+    local->op_errno = op_errno;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    /* Update ctx if the fd has been opened on the target*/
+    if (!op_ret && (local->call_cnt == 1)) {
+        dht_fd_ctx_set(this, fd, prev);
+        goto out;
+    }
+
+    if (!op_ret || (local->call_cnt != 1))
+        goto out;
+
+    /* rebalance would have happened */
+    local->rebalance.target_op_fn = dht_open2;
+    ret = dht_rebalance_complete_check(this, frame);
+    if (!ret)
+        return 0;
 
 out:
-        DHT_STACK_UNWIND (open, frame, op_ret, op_errno, local->fd, xdata);
+    DHT_STACK_UNWIND(open, frame, op_ret, op_errno, local->fd, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_open2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_open2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This DHT layer is not migrating the file */
-                DHT_STACK_UNWIND (open, frame, -1, local->op_errno,
-                                  NULL, local->rebalance.xdata);
-                return 0;
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        }
+    if (we_are_not_migrating(ret)) {
+        /* This DHT layer is not migrating the file */
+        DHT_STACK_UNWIND(open, frame, -1, local->op_errno, NULL,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND_COOKIE (frame, dht_open_cbk, subvol, subvol,
-                           subvol->fops->open, &local->loc,
-                           local->rebalance.flags, local->fd, local->xattr_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_open_cbk, subvol, subvol, subvol->fops->open,
+                      &local->loc, local->rebalance.flags, local->fd,
+                      local->xattr_req);
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (open, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_open (call_frame_t *frame, xlator_t *this,
-          loc_t *loc, int flags, fd_t *fd, dict_t *xdata)
+dht_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, fd_t *fd,
+         dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_OPEN);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->rebalance.flags = flags;
-        local->call_cnt = 1;
+    local = dht_local_init(frame, loc, fd, GF_FOP_OPEN);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_open_cbk, subvol, subvol,
-                           subvol->fops->open, loc, flags, fd, xdata);
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        return 0;
+    local->rebalance.flags = flags;
+    local->call_cnt = 1;
+
+    STACK_WIND_COOKIE(frame, dht_open_cbk, subvol, subvol, subvol->fops->open,
+                      loc, flags, fd, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (open, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_file_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int op_ret, int op_errno, struct iatt *stbuf, dict_t *xdata)
+dht_file_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *stbuf, dict_t *xdata)
 {
-        xlator_t     *subvol1 = 0;
-        xlator_t     *subvol2 = 0;
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        inode_t      *inode = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        if ((local->fop == GF_FOP_FSTAT) && (op_ret == -1)
-             && (op_errno == EBADF) && !(local->fd_checked)) {
-
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        if (local->call_cnt != 1)
-                goto out;
+    xlator_t *subvol1 = 0;
+    xlator_t *subvol2 = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    if ((local->fop == GF_FOP_FSTAT) && (op_ret == -1) && (op_errno == EBADF) &&
+        !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-        local->op_ret = op_ret;
-
-        /* Check if the rebalance phase2 is true */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-
-                local->rebalance.target_op_fn = dht_attr2;
-                dht_set_local_rebalance (this, local, NULL, NULL,
-                                         stbuf, xdata);
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
-
-                dht_inode_ctx_get_mig_info (this, inode, &subvol1, &subvol2);
-                if (dht_mig_info_is_invalid (local->cached_subvol,
-                                             subvol1, subvol2)){
-                        /* Phase 2 of migration */
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        /* it is a non-fd op or it is an fd based Fop and
-                           opened on the dst.*/
-                       if (local->fd &&
-                           !dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                ret = dht_rebalance_complete_check (this, frame);
-                                if (!ret)
-                                        return 0;
-                        } else {
-                                dht_attr2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1)
+        goto out;
+
+    local->op_errno = op_errno;
+    local->op_ret = op_ret;
+
+    /* Check if the rebalance phase2 is true */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        local->rebalance.target_op_fn = dht_attr2;
+        dht_set_local_rebalance(this, local, NULL, NULL, stbuf, xdata);
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
+
+        dht_inode_ctx_get_mig_info(this, inode, &subvol1, &subvol2);
+        if (dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            /* Phase 2 of migration */
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            /* it is a non-fd op or it is an fd based Fop and
+               opened on the dst.*/
+            if (local->fd && !dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                ret = dht_rebalance_complete_check(this, frame);
+                if (!ret)
+                    return 0;
+            } else {
+                dht_attr2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        DHT_STACK_UNWIND (stat, frame, op_ret, op_errno, stbuf, xdata);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    DHT_STACK_UNWIND(stat, frame, op_ret, op_errno, stbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
 int
-dht_attr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_attr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
-
-        local = frame->local;
-        if (!local)
-                goto out;
-
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (stat, frame, local->op_ret, op_errno,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
-
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    if (!local)
+        goto out;
+
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(stat, frame, local->op_ret, op_errno,
+                         &local->rebalance.postbuf, local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        if (local->fop == GF_FOP_FSTAT) {
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->fstat, local->fd,
-                                   local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, &local->loc,
-                                   local->xattr_req);
-        }
+    if (local->fop == GF_FOP_FSTAT) {
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, local->fd, local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, &local->loc, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int
-dht_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno, struct iatt *stbuf, dict_t *xdata)
+dht_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, struct iatt *stbuf, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
 
-                        goto unlock;
-                }
+            goto unlock;
+        }
 
-                dht_iatt_merge (this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->stbuf, stbuf);
 
-                local->op_ret = 0;
-        }
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 out:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                DHT_STACK_UNWIND (stat, frame, local->op_ret, local->op_errno,
-                                  &local->stbuf, xdata);
-        }
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        DHT_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
+                         &local->stbuf, xdata);
+    }
 err:
-        return 0;
+    return 0;
 }
 
 int
-dht_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dht_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_STAT);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (loc->inode->ia_type)) {
-                local->call_cnt = 1;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_STAT);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(loc->inode->ia_type)) {
+        local->call_cnt = 1;
 
-                subvol = local->cached_subvol;
+        subvol = local->cached_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, loc, xdata);
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, loc, xdata);
 
-                return 0;
-        }
+        return 0;
+    }
 
-        local->call_cnt = call_cnt = layout->cnt;
+    local->call_cnt = call_cnt = layout->cnt;
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = layout->list[i].xlator;
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
 
-                STACK_WIND_COOKIE (frame, dht_attr_cbk, subvol, subvol,
-                                   subvol->fops->stat, loc, xdata);
-        }
+        STACK_WIND_COOKIE(frame, dht_attr_cbk, subvol, subvol,
+                          subvol->fops->stat, loc, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dht_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSTAT);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0,
-                        "no layout for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (fd->inode->ia_type)) {
-                local->call_cnt = 1;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSTAT);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(fd->inode->ia_type)) {
+        local->call_cnt = 1;
 
-                subvol = local->cached_subvol;
+        subvol = local->cached_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_file_attr_cbk, subvol,
-                                   subvol, subvol->fops->fstat, fd,
-                                   xdata);
-                return 0;
-        }
+        STACK_WIND_COOKIE(frame, dht_file_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, fd, xdata);
+        return 0;
+    }
 
-        local->call_cnt = call_cnt = layout->cnt;
+    local->call_cnt = call_cnt = layout->cnt;
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = layout->list[i].xlator;
-                STACK_WIND_COOKIE (frame, dht_attr_cbk, subvol, subvol,
-                                   subvol->fops->fstat, fd, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        subvol = layout->list[i].xlator;
+        STACK_WIND_COOKIE(frame, dht_attr_cbk, subvol, subvol,
+                          subvol->fops->fstat, fd, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno,
-               struct iovec *vector, int count, struct iatt *stbuf,
-               struct iobref *iobref, dict_t *xdata)
+dht_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iovec *vector, int count, struct iatt *stbuf,
+              struct iobref *iobref, dict_t *xdata)
 {
-        dht_local_t *local      = NULL;
-        int          ret        = 0;
-        xlator_t    *src_subvol = 0;
-        xlator_t    *dst_subvol = 0;
-
-        local = frame->local;
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    int ret = 0;
+    xlator_t *src_subvol = 0;
+    xlator_t *dst_subvol = 0;
+
+    local = frame->local;
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /* This is already second try, no need for re-check */
+    if (local->call_cnt != 1)
+        goto out;
+
+    if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        /* This is already second try, no need for re-check */
-        if (local->call_cnt != 1)
-                goto out;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno))
+        goto out;
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
+    local->op_errno = op_errno;
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(stbuf)) {
+        local->op_ret = op_ret;
+        local->rebalance.target_op_fn = dht_readv2;
+        dht_set_local_rebalance(this, local, NULL, NULL, stbuf, xdata);
+        /* File would be migrated to other node */
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                         &dst_subvol);
+
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret)
                 return 0;
+        } else {
+            /* value is already set in fd_ctx, that means no need
+               to check for whether its complete or not. */
+            dht_readv2(this, dst_subvol, frame, 0);
+            return 0;
         }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno))
-                goto out;
-
-
-        local->op_errno = op_errno;
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (stbuf)) {
-
-                local->op_ret = op_ret;
-                local->rebalance.target_op_fn = dht_readv2;
-                dht_set_local_rebalance (this, local, NULL, NULL,
-                                         stbuf, xdata);
-                /* File would be migrated to other node */
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &src_subvol,
-                                                  &dst_subvol);
-
-                if (dht_mig_info_is_invalid (local->cached_subvol,
-                                             src_subvol, dst_subvol)
-                        || !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
-
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        /* value is already set in fd_ctx, that means no need
-                           to check for whether its complete or not. */
-                        dht_readv2 (this, dst_subvol, frame, 0);
-                        return 0;
-                }
-        }
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        DHT_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count, stbuf,
-                          iobref, xdata);
+    DHT_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, stbuf,
+                     iobref, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_readv2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_readv2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local  = NULL;
-        int          op_errno = EINVAL;
-
-        local = frame->local;
-        if (!local)
-                goto out;
-
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (readv, frame, local->op_ret, op_errno,
-                                  NULL, 0, &local->rebalance.postbuf,
-                                  NULL, local->rebalance.xdata);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
+
+    local = frame->local;
+    if (!local)
+        goto out;
+
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(readv, frame, local->op_ret, op_errno, NULL, 0,
+                         &local->rebalance.postbuf, NULL,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                    local->fd, local->rebalance.size, local->rebalance.offset,
-                    local->rebalance.flags, local->xattr_req);
+    STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv, local->fd,
+               local->rebalance.size, local->rebalance.offset,
+               local->rebalance.flags, local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int
-dht_readv (call_frame_t *frame, xlator_t *this,
-           fd_t *fd, size_t size, off_t off, uint32_t flags, dict_t *xdata)
+dht_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t off,
+          uint32_t flags, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_READ);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local = dht_local_init(frame, NULL, fd, GF_FOP_READ);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->rebalance.offset = off;
-        local->rebalance.size   = size;
-        local->rebalance.flags  = flags;
-        local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_readv_cbk, subvol, subvol->fops->readv,
-                    local->fd, local->rebalance.size,
-                    local->rebalance.offset,
-                    local->rebalance.flags, local->xattr_req);
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        return 0;
+    local->rebalance.offset = off;
+    local->rebalance.size = size;
+    local->rebalance.flags = flags;
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_readv_cbk, subvol, subvol->fops->readv, local->fd,
+               local->rebalance.size, local->rebalance.offset,
+               local->rebalance.flags, local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, dict_t *xdata)
+dht_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, dict_t *xdata)
 {
-        int          ret = -1;
-        dht_local_t *local = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *prev = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        if (!prev)
-                goto out;
-        if (local->call_cnt != 1)
-                goto out;
-        if ((op_ret == -1) && ((op_errno == ENOTCONN) ||
-                dht_inode_missing(op_errno)) &&
-                IA_ISDIR(local->loc.inode->ia_type)) {
-                subvol = dht_subvol_next_available (this, prev);
-                if (!subvol)
-                        goto out;
-
-                /* check if we are done with visiting every node */
-                if (subvol == local->cached_subvol) {
-                        goto out;
-                }
-
-                STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                                   subvol->fops->access, &local->loc,
-                                   local->rebalance.flags, NULL);
-                return 0;
-        }
-        if ((op_ret == -1) && dht_inode_missing(op_errno) &&
-                !(IA_ISDIR(local->loc.inode->ia_type))) {
-                /* File would be migrated to other node */
-                local->op_errno = op_errno;
-                local->rebalance.target_op_fn = dht_access2;
-                ret = dht_rebalance_complete_check (frame->this, frame);
-                if (!ret)
-                        return 0;
-        }
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (!prev)
+        goto out;
+    if (local->call_cnt != 1)
+        goto out;
+    if ((op_ret == -1) &&
+        ((op_errno == ENOTCONN) || dht_inode_missing(op_errno)) &&
+        IA_ISDIR(local->loc.inode->ia_type)) {
+        subvol = dht_subvol_next_available(this, prev);
+        if (!subvol)
+            goto out;
+
+        /* check if we are done with visiting every node */
+        if (subvol == local->cached_subvol) {
+            goto out;
+        }
+
+        STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                          subvol->fops->access, &local->loc,
+                          local->rebalance.flags, NULL);
+        return 0;
+    }
+    if ((op_ret == -1) && dht_inode_missing(op_errno) &&
+        !(IA_ISDIR(local->loc.inode->ia_type))) {
+        /* File would be migrated to other node */
+        local->op_errno = op_errno;
+        local->rebalance.target_op_fn = dht_access2;
+        ret = dht_rebalance_complete_check(frame->this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STACK_UNWIND (access, frame, op_ret, op_errno, xdata);
-        return 0;
+    DHT_STACK_UNWIND(access, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int
-dht_access2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_access2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int          op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int op_errno = EINVAL;
 
-        local = frame->local;
-        if (!local)
-                goto out;
+    local = frame->local;
+    if (!local)
+        goto out;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
 
-                DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
-                return 0;
-        }
+        DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                           subvol->fops->access, &local->loc,
-                           local->rebalance.flags, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                      subvol->fops->access, &local->loc, local->rebalance.flags,
+                      local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-            dict_t *xdata)
+dht_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+           dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_ACCESS);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.flags = mask;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_access_cbk, subvol, subvol,
-                           subvol->fops->access, loc, mask, xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_ACCESS);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.flags = mask;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_access_cbk, subvol, subvol,
+                      subvol->fops->access, loc, mask, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (access, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(access, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, dict_t *xdata)
+dht_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, dict_t *xdata)
 {
-        dht_local_t     *local  = NULL;
-        xlator_t        *subvol = 0;
-        int             ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = 0;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (local->call_cnt != 1)
-                goto out;
+    if (local->call_cnt != 1)
+        goto out;
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_flush2;
+    local->rebalance.target_op_fn = dht_flush2;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        /* If context is set, then send flush() it to the destination */
-        dht_inode_ctx_get_mig_info (this, local->fd->inode, NULL, &subvol);
-        if (subvol && dht_fd_open_on_dst (this, local->fd, subvol)) {
-                dht_flush2 (this, subvol, frame, 0);
-                return 0;
-        }
+    /* If context is set, then send flush() it to the destination */
+    dht_inode_ctx_get_mig_info(this, local->fd->inode, NULL, &subvol);
+    if (subvol && dht_fd_open_on_dst(this, local->fd, subvol)) {
+        dht_flush2(this, subvol, frame, 0);
+        return 0;
+    }
 
-        if (op_errno == EREMOTE) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret) {
-                        return 0;
-                }
+    if (op_errno == EREMOTE) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret) {
+            return 0;
         }
+    }
 
 out:
-        DHT_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata);
+    DHT_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_flush2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_flush2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND (frame, dht_flush_cbk,
-                    subvol, subvol->fops->flush, local->fd,
-                    local->xattr_req);
+    STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, local->fd,
+               local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-        return 0;
+    DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-dht_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dht_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FLUSH);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FLUSH);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        STACK_WIND (frame, dht_flush_cbk,
-                    subvol, subvol->fops->flush, fd, local->xattr_req);
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_flush_cbk, subvol, subvol->fops->flush, fd,
+               local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
-               dict_t *xdata)
+dht_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+              dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        inode_t      *inode = NULL;
-        xlator_t     *src_subvol = 0;
-        xlator_t     *dst_subvol = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    inode_t *inode = NULL;
+    xlator_t *src_subvol = 0;
+    xlator_t *dst_subvol = 0;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if (op_ret == -1 && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
+    if (op_ret == -1 && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
 
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
-                }
-                goto out;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
+        goto out;
+    }
 
-        local->op_ret = op_ret;
-        inode = local->fd->inode;
+    local->op_ret = op_ret;
+    inode = local->fd->inode;
 
-        local->rebalance.target_op_fn = dht_fsync2;
-        dht_set_local_rebalance (this, local, NULL, prebuf,
-                                 postbuf, xdata);
+    local->rebalance.target_op_fn = dht_fsync2;
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-                dht_inode_ctx_get_mig_info (this, inode, &src_subvol, &dst_subvol);
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-                if (dht_mig_info_is_invalid (local->cached_subvol, src_subvol,
-                                     dst_subvol) ||
-                      !dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
 
-                        ret = dht_rebalance_in_progress_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        dht_fsync2 (this, dst_subvol, frame, 0);
-                        return 0;
-                }
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_in_progress_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            dht_fsync2(this, dst_subvol, frame, 0);
+            return 0;
         }
-
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (fsync, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fsync2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_fsync2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
-
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
-
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (fsync, frame, local->op_ret,
-                                  op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
+
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
+
+    local = frame->local;
+    op_errno = local->op_errno;
+
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(fsync, frame, local->op_ret, op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                           subvol->fops->fsync, local->fd,
-                           local->rebalance.flags, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol, subvol->fops->fsync,
+                      local->fd, local->rebalance.flags, local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
-           dict_t *xdata)
+dht_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync,
+          dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSYNC);
-        if (!local) {
-                op_errno = ENOMEM;
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSYNC);
+    if (!local) {
+        op_errno = ENOMEM;
 
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-        local->call_cnt = 1;
-        local->rebalance.flags = datasync;
+    local->call_cnt = 1;
+    local->rebalance.flags = datasync;
 
-        subvol = local->cached_subvol;
+    subvol = local->cached_subvol;
 
-        STACK_WIND_COOKIE (frame, dht_fsync_cbk, subvol, subvol,
-                           subvol->fops->fsync, local->fd,
-                           local->rebalance.flags, local->xattr_req);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_fsync_cbk, subvol, subvol, subvol->fops->fsync,
+                      local->fd, local->rebalance.flags, local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 /* TODO: for 'lk()' call, we need some other special error, may be ESTALE to
    indicate that lock migration happened on the fd, so we can consider it as
    phase 2 of migration */
 int
-dht_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-            int op_ret, int op_errno, struct gf_flock *flock, dict_t *xdata)
+dht_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+           int op_errno, struct gf_flock *flock, dict_t *xdata)
 {
-        dht_local_t     *local  = NULL;
-        int             ret     = -1;
-        xlator_t        *subvol = NULL;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    xlator_t *subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        if (local->call_cnt != 1)
-                goto out;
+    if (local->call_cnt != 1)
+        goto out;
 
-        local->rebalance.target_op_fn = dht_lk2;
+    local->rebalance.target_op_fn = dht_lk2;
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
 
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
-
-        if (op_errno == EREMOTE) {
-                dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                            NULL, &subvol);
-                if (subvol && dht_fd_open_on_dst (this, local->fd, subvol)) {
-                        dht_lk2 (this, subvol, frame, 0);
-                        return 0;
-                } else {
-                        ret = dht_rebalance_complete_check (this, frame);
-                        if (!ret) {
-                                return 0;
-                        }
-                }
+    if (op_errno == EREMOTE) {
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, NULL, &subvol);
+        if (subvol && dht_fd_open_on_dst(this, local->fd, subvol)) {
+            dht_lk2(this, subvol, frame, 0);
+            return 0;
+        } else {
+            ret = dht_rebalance_complete_check(this, frame);
+            if (!ret) {
+                return 0;
+            }
         }
+    }
 
 out:
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (lk, frame, op_ret, op_errno, flock, xdata);
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(lk, frame, op_ret, op_errno, flock, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_lk2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_lk2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND (frame, dht_lk_cbk, subvol, subvol->fops->lk, local->fd,
-                    local->rebalance.lock_cmd, &local->rebalance.flock,
-                    local->xattr_req);
+    STACK_WIND(frame, dht_lk_cbk, subvol, subvol->fops->lk, local->fd,
+               local->rebalance.lock_cmd, &local->rebalance.flock,
+               local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (lk, frame, -1, op_errno, NULL,  NULL);
-        return 0;
+    DHT_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int
-dht_lk (call_frame_t *frame, xlator_t *this,
-        fd_t *fd, int cmd, struct gf_flock *flock, dict_t *xdata)
+dht_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int cmd,
+       struct gf_flock *flock, dict_t *xdata)
 {
-        xlator_t        *lock_subvol    = NULL;
-        int             op_errno        = -1;
-        dht_local_t     *local          = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_LK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->lock_type = flock->l_type;
-        lock_subvol = dht_get_lock_subvolume (this, flock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for path=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-/*
-        local->cached_subvol = lock_subvol;
-        ret = dht_check_and_open_fd_on_subvol (this, frame);
-        if (ret)
-                goto err;
-*/
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        local->rebalance.flock = *flock;
-        local->rebalance.lock_cmd = cmd;
-
-        local->call_cnt = 1;
-
-        STACK_WIND (frame, dht_lk_cbk, lock_subvol, lock_subvol->fops->lk, fd,
-                    cmd, flock, xdata);
-
-        return 0;
+    xlator_t *lock_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_LK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->lock_type = flock->l_type;
+    lock_subvol = dht_get_lock_subvolume(this, flock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for path=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /*
+            local->cached_subvol = lock_subvol;
+            ret = dht_check_and_open_fd_on_subvol (this, frame);
+            if (ret)
+                    goto err;
+    */
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->rebalance.flock = *flock;
+    local->rebalance.lock_cmd = cmd;
+
+    local->call_cnt = 1;
+
+    STACK_WIND(frame, dht_lk_cbk, lock_subvol, lock_subvol->fops->lk, fd, cmd,
+               flock, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lk, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int op_ret, int op_errno, struct gf_lease *lease, dict_t *xdata)
+dht_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, struct gf_lease *lease, dict_t *xdata)
 {
-        DHT_STACK_UNWIND (lease, frame, op_ret, op_errno, lease, xdata);
+    DHT_STACK_UNWIND(lease, frame, op_ret, op_errno, lease, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_lease (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, struct gf_lease *lease, dict_t *xdata)
+dht_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+          struct gf_lease *lease, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        subvol = dht_subvol_get_cached (this, loc->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
 
-        /* TODO: for rebalance, we need to preserve the fop arguments */
-        STACK_WIND (frame, dht_lease_cbk, subvol, subvol->fops->lease,
-                    loc, lease, xdata);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        return 0;
+    subvol = dht_subvol_get_cached(this, loc->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* TODO: for rebalance, we need to preserve the fop arguments */
+    STACK_WIND(frame, dht_lease_cbk, subvol, subvol->fops->lease, loc, lease,
+               xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lease, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lease, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* Symlinks are currently not migrated, so no need for any check here */
 int
-dht_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, const char *path,
-                  struct iatt *stbuf, dict_t *xdata)
+dht_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, const char *path, struct iatt *stbuf,
+                 dict_t *xdata)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (op_ret == -1)
-                goto err;
+    local = frame->local;
+    if (op_ret == -1)
+        goto err;
 
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-        }
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+    }
 
 err:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
-        DHT_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, stbuf, xdata);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
+    DHT_STACK_UNWIND(readlink, frame, op_ret, op_errno, path, stbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-              dict_t *xdata)
+dht_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_READLINK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        STACK_WIND (frame, dht_readlink_cbk,
-                    subvol, subvol->fops->readlink,
-                    loc, size, xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_READLINK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    STACK_WIND(frame, dht_readlink_cbk, subvol, subvol->fops->readlink, loc,
+               size, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readlink, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_common_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *dict,
-                        dict_t *xdata)
+dht_common_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
-        dht_local_t  *local          = NULL;
-        call_frame_t *call_frame     = NULL;
-        xlator_t     *prev           = NULL;
-        xlator_t     *src_subvol     = NULL;
-        xlator_t     *dst_subvol     = NULL;
-        struct iatt   stbuf          = {0,};
-        int           ret            = -1;
-        inode_t      *inode          = NULL;
-
-        local = frame->local;
-        call_frame = cookie;
-        prev = call_frame->this;
-
-        local->op_errno = op_errno;
-
-        if ((op_ret == -1) && !dht_inode_missing (op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1.",
-                              prev->name);
-                goto out;
-        }
-
-        if (local->call_cnt != 1)
-                goto out;
-
-        ret = dht_read_iatt_from_xdata (this, xdata, &stbuf);
-
-        if ((!op_ret) && (ret)) {
-                /* This is a potential problem and can cause corruption
-                 * with sharding.
-                 * Oh well. We tried.
-                 */
-                goto out;
-        }
-
-        local->op_ret = op_ret;
-        local->rebalance.target_op_fn = dht_common_xattrop2;
-        if (xdata)
-                local->rebalance.xdata = dict_ref (xdata);
-
-        if (dict)
-                local->rebalance.dict = dict_ref (dict);
-
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (&stbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (&stbuf)) {
-
-                inode = local->loc.inode ? local->loc.inode : local->fd->inode;
-                dht_inode_ctx_get_mig_info (this, inode, &src_subvol,
-                                            &dst_subvol);
-
-                if (dht_mig_info_is_invalid (local->cached_subvol, src_subvol,
-                                             dst_subvol) ||
-                      !dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
-
-                        ret = dht_rebalance_in_progress_check (this, frame);
-                        if (!ret)
-                                return 0;
-                } else {
-                        dht_common_xattrop2 (this, dst_subvol, frame, 0);
-                        return 0;
-                }
+    dht_local_t *local = NULL;
+    call_frame_t *call_frame = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    int ret = -1;
+    inode_t *inode = NULL;
+
+    local = frame->local;
+    call_frame = cookie;
+    prev = call_frame->this;
+
+    local->op_errno = op_errno;
+
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1.",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1)
+        goto out;
+
+    ret = dht_read_iatt_from_xdata(this, xdata, &stbuf);
+
+    if ((!op_ret) && (ret)) {
+        /* This is a potential problem and can cause corruption
+         * with sharding.
+         * Oh well. We tried.
+         */
+        goto out;
+    }
+
+    local->op_ret = op_ret;
+    local->rebalance.target_op_fn = dht_common_xattrop2;
+    if (xdata)
+        local->rebalance.xdata = dict_ref(xdata);
+
+    if (dict)
+        local->rebalance.dict = dict_ref(dict);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(&stbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(&stbuf)) {
+        inode = local->loc.inode ? local->loc.inode : local->fd->inode;
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
+
+        if (dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                    dst_subvol) ||
+            !dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+            ret = dht_rebalance_in_progress_check(this, frame);
+            if (!ret)
+                return 0;
+        } else {
+            dht_common_xattrop2(this, dst_subvol, frame, 0);
+            return 0;
         }
-
+    }
 
 out:
-        if (local->fop == GF_FOP_XATTROP) {
-                DHT_STACK_UNWIND (xattrop, frame, op_ret, op_errno,
-                                  dict, xdata);
-        } else {
-                DHT_STACK_UNWIND (fxattrop, frame, op_ret, op_errno,
-                                  dict, xdata);
-        }
+    if (local->fop == GF_FOP_XATTROP) {
+        DHT_STACK_UNWIND(xattrop, frame, op_ret, op_errno, dict, xdata);
+    } else {
+        DHT_STACK_UNWIND(fxattrop, frame, op_ret, op_errno, dict, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_common_xattrop2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame,
-                     int ret)
+dht_common_xattrop2(xlator_t *this, xlator_t *subvol, call_frame_t *frame,
+                    int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
-
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
-
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                if (local->fop == GF_FOP_XATTROP) {
-                        DHT_STACK_UNWIND (xattrop, frame, local->op_ret,
-                                          op_errno, local->rebalance.dict,
-                                          local->rebalance.xdata);
-                } else {
-                        DHT_STACK_UNWIND (fxattrop, frame, local->op_ret,
-                                          op_errno, local->rebalance.dict,
-                                          local->rebalance.xdata);
-                }
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-                return 0;
-        }
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        if (subvol == NULL)
-                goto out;
-
-        local->call_cnt = 2; /* This is the second attempt */
+    local = frame->local;
+    op_errno = local->op_errno;
 
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
         if (local->fop == GF_FOP_XATTROP) {
-                STACK_WIND (frame, dht_common_xattrop_cbk, subvol,
-                            subvol->fops->xattrop, &local->loc,
-                            local->rebalance.flags, local->rebalance.xattr,
-                            local->xattr_req);
+            DHT_STACK_UNWIND(xattrop, frame, local->op_ret, op_errno,
+                             local->rebalance.dict, local->rebalance.xdata);
         } else {
-                STACK_WIND (frame, dht_common_xattrop_cbk, subvol,
-                            subvol->fops->fxattrop, local->fd,
-                            local->rebalance.flags, local->rebalance.xattr,
-                            local->xattr_req);
+            DHT_STACK_UNWIND(fxattrop, frame, local->op_ret, op_errno,
+                             local->rebalance.dict, local->rebalance.xdata);
         }
 
         return 0;
+    }
+
+    if (subvol == NULL)
+        goto out;
+
+    local->call_cnt = 2; /* This is the second attempt */
+
+    if (local->fop == GF_FOP_XATTROP) {
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol, subvol->fops->xattrop,
+                   &local->loc, local->rebalance.flags, local->rebalance.xattr,
+                   local->xattr_req);
+    } else {
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol,
+                   subvol->fops->fxattrop, local->fd, local->rebalance.flags,
+                   local->rebalance.xattr, local->xattr_req);
+    }
+
+    return 0;
 
 out:
 
-        /* If local is unavailable we could be unwinding the wrong
-         * function here */
+    /* If local is unavailable we could be unwinding the wrong
+     * function here */
 
-        if (local && (local->fop == GF_FOP_XATTROP)) {
-                DHT_STACK_UNWIND (xattrop, frame, -1, op_errno, NULL, NULL);
-        } else {
-                DHT_STACK_UNWIND (fxattrop, frame, -1, op_errno, NULL, NULL);
-        }
-        return 0;
+    if (local && (local->fop == GF_FOP_XATTROP)) {
+        DHT_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
+    } else {
+        DHT_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
+    }
+    return 0;
 }
 
-
 int
-dht_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+dht_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        DHT_STACK_UNWIND (xattrop, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    DHT_STACK_UNWIND(xattrop, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int
-dht_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dht_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        xlator_t     *subvol   = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local    = NULL;
-        int           ret      = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_XATTROP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for gfid=%s",
-                              uuid_utoa (loc->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        /* Todo : Handle dirs as well. At the moment the only xlator above dht
-         * that uses xattrop is sharding and that is only for files */
-
-        if (IA_ISDIR (loc->inode->ia_type)) {
-                STACK_WIND (frame, dht_xattrop_cbk, subvol,
-                            subvol->fops->xattrop, loc, flags, dict, xdata);
-
-        } else {
-                local->xattr_req = xdata ? dict_ref(xdata) : dict_new ();
-                local->call_cnt = 1;
-
-                local->rebalance.xattr = dict_ref (dict);
-                local->rebalance.flags = flags;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_XATTROP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for gfid=%s",
+                     uuid_utoa(loc->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /* Todo : Handle dirs as well. At the moment the only xlator above dht
+     * that uses xattrop is sharding and that is only for files */
+
+    if (IA_ISDIR(loc->inode->ia_type)) {
+        STACK_WIND(frame, dht_xattrop_cbk, subvol, subvol->fops->xattrop, loc,
+                   flags, dict, xdata);
+
+    } else {
+        local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+        local->call_cnt = 1;
 
-                ret = dht_request_iatt_in_xdata (this, local->xattr_req);
+        local->rebalance.xattr = dict_ref(dict);
+        local->rebalance.flags = flags;
 
-                if (ret) {
-                        gf_msg_debug (this->name, 0,
-                                      "Failed to set dictionary key %s file=%s",
-                                      DHT_IATT_IN_XDATA_KEY, loc->path);
-                }
+        ret = dht_request_iatt_in_xdata(this, local->xattr_req);
 
-                STACK_WIND (frame, dht_common_xattrop_cbk, subvol,
-                            subvol->fops->xattrop, loc,
-                            local->rebalance.flags, local->rebalance.xattr,
-                            local->xattr_req);
+        if (ret) {
+            gf_msg_debug(this->name, 0,
+                         "Failed to set dictionary key %s file=%s",
+                         DHT_IATT_IN_XDATA_KEY, loc->path);
         }
 
-        return 0;
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol, subvol->fops->xattrop,
+                   loc, local->rebalance.flags, local->rebalance.xattr,
+                   local->xattr_req);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (xattrop, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(xattrop, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+dht_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        DHT_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    DHT_STACK_UNWIND(fxattrop, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
-
 int
-dht_fxattrop (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dht_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local    = NULL;
-        int           ret      = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        subvol = dht_subvol_get_cached (this, fd->inode);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FXATTROP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        /* Todo : Handle dirs as well. At the moment the only xlator above dht
-         * that uses xattrop is sharding and that is only for files */
-
-        if (IA_ISDIR (fd->inode->ia_type)) {
-                STACK_WIND (frame, dht_fxattrop_cbk, subvol,
-                            subvol->fops->fxattrop, fd, flags, dict, xdata);
-
-        } else {
-                local->xattr_req = xdata ? dict_ref(xdata) : dict_new ();
-                local->call_cnt = 1;
-
-                local->rebalance.xattr = dict_ref (dict);
-                local->rebalance.flags = flags;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    subvol = dht_subvol_get_cached(this, fd->inode);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FXATTROP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* Todo : Handle dirs as well. At the moment the only xlator above dht
+     * that uses xattrop is sharding and that is only for files */
+
+    if (IA_ISDIR(fd->inode->ia_type)) {
+        STACK_WIND(frame, dht_fxattrop_cbk, subvol, subvol->fops->fxattrop, fd,
+                   flags, dict, xdata);
+
+    } else {
+        local->xattr_req = xdata ? dict_ref(xdata) : dict_new();
+        local->call_cnt = 1;
 
-                ret = dht_request_iatt_in_xdata (this, local->xattr_req);
+        local->rebalance.xattr = dict_ref(dict);
+        local->rebalance.flags = flags;
 
-                if (ret) {
-                        gf_msg_debug (this->name, 0,
-                                      "Failed to set dictionary key %s fd=%p",
-                                      DHT_IATT_IN_XDATA_KEY, fd);
-                }
+        ret = dht_request_iatt_in_xdata(this, local->xattr_req);
 
-                STACK_WIND (frame, dht_common_xattrop_cbk, subvol,
-                            subvol->fops->fxattrop, fd,
-                            local->rebalance.flags, local->rebalance.xattr,
-                            local->xattr_req);
+        if (ret) {
+            gf_msg_debug(this->name, 0, "Failed to set dictionary key %s fd=%p",
+                         DHT_IATT_IN_XDATA_KEY, fd);
         }
 
-        return 0;
+        STACK_WIND(frame, dht_common_xattrop_cbk, subvol,
+                   subvol->fops->fxattrop, fd, local->rebalance.flags,
+                   local->rebalance.xattr, local->xattr_req);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fxattrop, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fxattrop, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* Currently no translators on top of 'distribute' will be using
@@ -1555,116 +1486,108 @@ err:
  */
 
 int
-dht_inodelk_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (inodelk, frame, op_ret, op_errno, xdata);
-        return 0;
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(inodelk, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int32_t
-dht_inodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-             loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+dht_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+            int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        xlator_t        *lock_subvol            = NULL;
-        int              op_errno               = -1;
-        dht_local_t     *local                  = NULL;
+    xlator_t *lock_subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_INODELK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = dht_local_init(frame, loc, NULL, GF_FOP_INODELK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->lock_type = lock->l_type;
-        lock_subvol = dht_get_lock_subvolume (this, lock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local->lock_type = lock->l_type;
+    lock_subvol = dht_get_lock_subvolume(this, lock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        local->call_cnt = 1;
+    local->call_cnt = 1;
 
-        STACK_WIND (frame, dht_inodelk_cbk,
-                    lock_subvol, lock_subvol->fops->inodelk,
-                    volume, loc, cmd, lock, xdata);
+    STACK_WIND(frame, dht_inodelk_cbk, lock_subvol, lock_subvol->fops->inodelk,
+               volume, loc, cmd, lock, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (inodelk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(inodelk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 
 {
-        dht_lk_inode_unref (frame, op_ret);
-        DHT_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata);
-        return 0;
+    dht_lk_inode_unref(frame, op_ret);
+    DHT_STACK_UNWIND(finodelk, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int
-dht_finodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-              fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+dht_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+             int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        xlator_t     *lock_subvol       = NULL;
-        dht_local_t  *local             = NULL;
-        int           op_errno          = -1;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_INODELK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->call_cnt = 1;
-        local->lock_type = lock->l_type;
-
-        lock_subvol = dht_get_lock_subvolume (this, lock, local);
-        if (!lock_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no lock subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-/*
-        local->cached_subvol = lock_subvol;
-        ret = dht_check_and_open_fd_on_subvol (this, frame);
-        if (ret)
-                goto err;
-*/
-        STACK_WIND (frame, dht_finodelk_cbk, lock_subvol,
-                    lock_subvol->fops->finodelk,
-                    volume, fd, cmd, lock, xdata);
-
-        return 0;
+    xlator_t *lock_subvol = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_INODELK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->call_cnt = 1;
+    local->lock_type = lock->l_type;
+
+    lock_subvol = dht_get_lock_subvolume(this, lock, local);
+    if (!lock_subvol) {
+        gf_msg_debug(this->name, 0, "no lock subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    /*
+            local->cached_subvol = lock_subvol;
+            ret = dht_check_and_open_fd_on_subvol (this, frame);
+            if (ret)
+                    goto err;
+    */
+    STACK_WIND(frame, dht_finodelk_cbk, lock_subvol,
+               lock_subvol->fops->finodelk, volume, fd, cmd, lock, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (finodelk, frame, -1, op_errno, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(finodelk, frame, -1, op_errno, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-inode-write.c b/xlators/cluster/dht/src/dht-inode-write.c
index 4b4f2c2d4a3..d0d12fd7658 100644
--- a/xlators/cluster/dht/src/dht-inode-write.c
+++ b/xlators/cluster/dht/src/dht-inode-write.c
@@ -8,1487 +8,1401 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "dht-common.h"
 
-int dht_writev2 (xlator_t *this, xlator_t *subvol,
-                 call_frame_t *frame, int ret);
-int dht_truncate2 (xlator_t *this, xlator_t *subvol,
-                   call_frame_t *frame, int ret);
-int dht_setattr2 (xlator_t *this, xlator_t *subvol,
-                  call_frame_t *frame, int ret);
-int dht_fallocate2 (xlator_t *this, xlator_t *subvol,
-                    call_frame_t *frame, int ret);
-int dht_discard2 (xlator_t *this, xlator_t *subvol,
-                  call_frame_t *frame, int ret);
-int dht_zerofill2 (xlator_t *this, xlator_t *subvol,
-                   call_frame_t *frame, int ret);
+int
+dht_writev2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+int
+dht_truncate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+int
+dht_setattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+int
+dht_fallocate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+int
+dht_discard2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
+int
+dht_zerofill2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret);
 
 int
-dht_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+               dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        xlator_t    *prev = NULL;
-        int          ret   = -1;
-        xlator_t    *subvol1 = NULL;
-        xlator_t    *subvol2 = NULL;
-
-        local = frame->local;
-        prev = cookie;
-
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        /* writev fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could be a valid bad fd error.
-         */
-
-        if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *subvol1 = NULL;
+    xlator_t *subvol2 = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    /* writev fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could be a valid bad fd error.
+     */
+
+    if (op_ret == -1 && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if (op_ret == -1 && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, 0,
-                              "subvolume %s returned -1 (%s)",
-                              prev->name, strerror (op_errno));
-                goto out;
+    if (op_ret == -1 && !dht_inode_missing(op_errno)) {
+        local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, 0, "subvolume %s returned -1 (%s)", prev->name,
+                     strerror(op_errno));
+        goto out;
+    }
+
+    if (local->call_cnt != 1) {
+        /* preserve the modes of source */
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        if (local->call_cnt != 1) {
-                /* preserve the modes of source */
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_writev2;
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    /* We might need to pass the stbuf information to the higher DHT
+     * layer for appropriate handling.
+     */
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        if (!dht_is_tier_xlator(this)) {
+            if (!local->xattr_req) {
+                local->xattr_req = dict_new();
+                if (!local->xattr_req) {
+                    gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+                           "insufficient memory");
+                    local->op_errno = ENOMEM;
+                    local->op_ret = -1;
+                    goto out;
                 }
+            }
+
+            ret = dict_set_uint32(local->xattr_req,
+                                  GF_PROTECT_FROM_EXTERNAL_WRITES, 1);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_DICT_SET_FAILED, 0,
+                       "Failed to set key %s in dictionary",
+                       GF_PROTECT_FROM_EXTERNAL_WRITES);
+                local->op_errno = ENOMEM;
+                local->op_ret = -1;
                 goto out;
+            }
         }
 
-        local->rebalance.target_op_fn = dht_writev2;
-
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
-
-        /* We might need to pass the stbuf information to the higher DHT
-         * layer for appropriate handling.
-         */
-
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
-
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                if (!dht_is_tier_xlator (this)) {
-                        if (!local->xattr_req) {
-                                local->xattr_req = dict_new ();
-                                if (!local->xattr_req) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                DHT_MSG_NO_MEMORY,
-                                                ENOMEM, "insufficient memory");
-                                        local->op_errno = ENOMEM;
-                                        local->op_ret = -1;
-                                        goto out;
-                                }
-                        }
-
-                        ret = dict_set_uint32 (local->xattr_req,
-                                               GF_PROTECT_FROM_EXTERNAL_WRITES,
-                                               1);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR,
-                                        DHT_MSG_DICT_SET_FAILED, 0,
-                                        "Failed to set key %s in dictionary",
-                                        GF_PROTECT_FROM_EXTERNAL_WRITES);
-                                local->op_errno = ENOMEM;
-                                local->op_ret = -1;
-                                goto out;
-                        }
-                }
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
-
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        if (dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                dht_writev2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &subvol1,
+                                         &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            if (dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                dht_writev2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf,
-                          xdata);
+    DHT_STACK_UNWIND(writev, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_writev2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_writev2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if ((frame == NULL) || (frame->local == NULL))
-                goto out;
+    if ((frame == NULL) || (frame->local == NULL))
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (writev, frame, local->op_ret,
-                                  local->op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(writev, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (subvol == NULL)
+        goto out;
 
-        STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol,
-                           subvol, subvol->fops->writev,
-                           local->fd, local->rebalance.vector,
-                           local->rebalance.count,
-                           local->rebalance.offset, local->rebalance.flags,
-                           local->rebalance.iobref, local->xattr_req);
+    local->call_cnt = 2; /* This is the second attempt */
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                      subvol->fops->writev, local->fd, local->rebalance.vector,
+                      local->rebalance.count, local->rebalance.offset,
+                      local->rebalance.flags, local->rebalance.iobref,
+                      local->xattr_req);
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-            struct iovec *vector, int count, off_t off, uint32_t flags,
-            struct iobref *iobref, dict_t *xdata)
+dht_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+           int count, off_t off, uint32_t flags, struct iobref *iobref,
+           dict_t *xdata)
 {
-        xlator_t     *subvol   = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local    = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_WRITE);
-        if (!local) {
-
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        local->rebalance.vector = iov_dup (vector, count);
-        local->rebalance.offset = off;
-        local->rebalance.count = count;
-        local->rebalance.flags = flags;
-        local->rebalance.iobref = iobref_ref (iobref);
-        local->call_cnt = 1;
-
-        STACK_WIND_COOKIE (frame, dht_writev_cbk, subvol, subvol,
-                           subvol->fops->writev, fd,
-                           local->rebalance.vector,
-                           local->rebalance.count,
-                           local->rebalance.offset,
-                           local->rebalance.flags,
-                           local->rebalance.iobref, local->xattr_req);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_WRITE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    local->rebalance.vector = iov_dup(vector, count);
+    local->rebalance.offset = off;
+    local->rebalance.count = count;
+    local->rebalance.flags = flags;
+    local->rebalance.iobref = iobref_ref(iobref);
+    local->call_cnt = 1;
+
+    STACK_WIND_COOKIE(frame, dht_writev_cbk, subvol, subvol,
+                      subvol->fops->writev, fd, local->rebalance.vector,
+                      local->rebalance.count, local->rebalance.offset,
+                      local->rebalance.flags, local->rebalance.iobref,
+                      local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-
 int
-dht_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
+dht_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata)
 {
-        dht_local_t  *local      = NULL;
-        xlator_t     *prev       = NULL;
-        int           ret        = -1;
-        xlator_t     *src_subvol = NULL;
-        xlator_t     *dst_subvol = NULL;
-        inode_t      *inode      = NULL;
-
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* Needs to be checked only for ftruncate.
-         * ftruncate fails with EBADF/EINVAL if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+    inode_t *inode = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* Needs to be checked only for ftruncate.
+     * ftruncate fails with EBADF/EINVAL if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+
+    if ((local->fop == GF_FOP_FTRUNCATE) && (op_ret == -1) &&
+        ((op_errno == EBADF) || (op_errno == EINVAL)) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        if ((local->fop == GF_FOP_FTRUNCATE) && (op_ret == -1)
-             && ((op_errno == EBADF) || (op_errno == EINVAL))
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
+        goto out;
+    }
 
-                goto out;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
+        goto out;
+    }
 
+    local->rebalance.target_op_fn = dht_truncate2;
 
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
-                }
-                goto out;
-        }
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        local->rebalance.target_op_fn = dht_truncate2;
+    /* We might need to pass the stbuf information to the higher DHT
+     * layer for appropriate handling.
+     */
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-        /* We might need to pass the stbuf information to the higher DHT
-         * layer for appropriate handling.
-         */
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+        inode = (local->fd) ? local->fd->inode : local->loc.inode;
 
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
-
-                inode = (local->fd) ? local->fd->inode : local->loc.inode;
-
-                dht_inode_ctx_get_mig_info (this, inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              src_subvol, dst_subvol)) {
-                        if ((!local->fd) || ((local->fd) &&
-                            dht_fd_open_on_dst (this, local->fd, dst_subvol))) {
-                                dht_truncate2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        dht_inode_ctx_get_mig_info(this, inode, &src_subvol, &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if ((!local->fd) ||
+                ((local->fd) &&
+                 dht_fd_open_on_dst(this, local->fd, dst_subvol))) {
+                dht_truncate2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (truncate, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(truncate, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
-
 int
-dht_truncate2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_truncate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        /* This dht xlator is not migrating the file  */
-        if (we_are_not_migrating (ret)) {
-
-                DHT_STACK_UNWIND (truncate, frame, local->op_ret,
-                                  local->op_errno, &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    /* This dht xlator is not migrating the file  */
+    if (we_are_not_migrating(ret)) {
+        DHT_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        if (local->fop == GF_FOP_TRUNCATE) {
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->truncate, &local->loc,
-                                   local->rebalance.offset, local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                                   subvol->fops->ftruncate, local->fd,
-                                   local->rebalance.offset, local->xattr_req);
-        }
+    if (local->fop == GF_FOP_TRUNCATE) {
+        STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                          subvol->fops->truncate, &local->loc,
+                          local->rebalance.offset, local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                          subvol->fops->ftruncate, local->fd,
+                          local->rebalance.offset, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-              dict_t *xdata)
+dht_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+             dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_TRUNCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.offset = offset;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for gfid=%s",
-                              uuid_utoa (loc->inode->gfid));
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                           subvol->fops->truncate, loc, offset, xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_TRUNCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.offset = offset;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for gfid=%s",
+                     uuid_utoa(loc->inode->gfid));
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                      subvol->fops->truncate, loc, offset, xdata);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               dict_t *xdata)
+dht_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FTRUNCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->rebalance.offset = offset;
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_truncate_cbk, subvol, subvol,
-                           subvol->fops->ftruncate, fd,
-                           local->rebalance.offset, local->xattr_req);
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FTRUNCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.offset = offset;
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_truncate_cbk, subvol, subvol,
+                      subvol->fops->ftruncate, fd, local->rebalance.offset,
+                      local->xattr_req);
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int op_ret, int op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
+dht_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                  int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                  dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        xlator_t    *src_subvol = NULL;
-        xlator_t    *dst_subvol = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* fallocate fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* fallocate fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+
+    if ((op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-        local->rebalance.target_op_fn = dht_fallocate2;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+        goto out;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
-
-                dht_inode_ctx_get_mig_info (this, local->fd->inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              src_subvol, dst_subvol)) {
-                        if (dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
-                                dht_fallocate2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+    local->rebalance.target_op_fn = dht_fallocate2;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                   &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if (dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+                dht_fallocate2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (fallocate, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(fallocate, frame, op_ret, op_errno, prebuf, postbuf,
+                     xdata);
 err:
-        return 0;
+    return 0;
 }
 
 int
-dht_fallocate2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_fallocate2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (fallocate, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(fallocate, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (subvol == NULL)
+        goto out;
 
-	STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                           subvol->fops->fallocate, local->fd,
-                           local->rebalance.flags, local->rebalance.offset,
-		           local->rebalance.size, local->xattr_req);
+    local->call_cnt = 2; /* This is the second attempt */
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                      subvol->fops->fallocate, local->fd,
+                      local->rebalance.flags, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-	      off_t offset, size_t len, dict_t *xdata)
+dht_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+              off_t offset, size_t len, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FALLOCATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-	local->rebalance.flags = mode;
-        local->rebalance.offset = offset;
-	local->rebalance.size = len;
-
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        STACK_WIND_COOKIE (frame, dht_fallocate_cbk, subvol, subvol,
-                           subvol->fops->fallocate, fd,
-                           local->rebalance.flags,
-                           local->rebalance.offset,
-                           local->rebalance.size,
-                           local->xattr_req);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FALLOCATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->rebalance.flags = mode;
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
+
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_fallocate_cbk, subvol, subvol,
+                      subvol->fops->fallocate, fd, local->rebalance.flags,
+                      local->rebalance.offset, local->rebalance.size,
+                      local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
-        xlator_t    *src_subvol = NULL;
-        xlator_t    *dst_subvol = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-
-        /* discard fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *src_subvol = NULL;
+    xlator_t *dst_subvol = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* discard fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+    if ((op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_discard2;
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
 
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
+        goto out;
+    }
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
-
-                dht_inode_ctx_get_mig_info (this, local->fd->inode, &src_subvol,
-                                            &dst_subvol);
-                if (!dht_mig_info_is_invalid(local->cached_subvol,
-                                             src_subvol, dst_subvol)) {
-                        if (dht_fd_open_on_dst (this, local->fd, dst_subvol)) {
-                                dht_discard2 (this, dst_subvol, frame, 0);
-                                return 0;
-                        }
-                }
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_discard2;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        dht_inode_ctx_get_mig_info(this, local->fd->inode, &src_subvol,
+                                   &dst_subvol);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, src_subvol,
+                                     dst_subvol)) {
+            if (dht_fd_open_on_dst(this, local->fd, dst_subvol)) {
+                dht_discard2(this, dst_subvol, frame, 0);
+                return 0;
+            }
         }
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (discard, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(discard, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
 int
-dht_discard2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_discard2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (discard, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(discard, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
+    if (subvol == NULL)
+        goto out;
 
-	STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                           subvol->fops->discard, local->fd,
-                           local->rebalance.offset, local->rebalance.size,
-		           local->xattr_req);
+    local->call_cnt = 2; /* This is the second attempt */
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                      subvol->fops->discard, local->fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-	    size_t len, dict_t *xdata)
+dht_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            size_t len, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        int           op_errno = -1;
-        dht_local_t  *local = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_DISCARD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        local->rebalance.offset = offset;
-	local->rebalance.size = len;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, fd, GF_FOP_DISCARD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
 
-        STACK_WIND_COOKIE (frame, dht_discard_cbk, subvol, subvol,
-                           subvol->fops->discard, fd,
-                           local->rebalance.offset,
-                           local->rebalance.size,
-                           local->xattr_req);
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    STACK_WIND_COOKIE(frame, dht_discard_cbk, subvol, subvol,
+                      subvol->fops->discard, fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *prebuf,
-                struct iatt *postbuf, dict_t *xdata)
+dht_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, struct iatt *prebuf, struct iatt *postbuf,
+                 dict_t *xdata)
 {
-        dht_local_t  *local   = NULL;
-        xlator_t     *prev    = NULL;
-        int           ret     = -1;
-        xlator_t     *subvol1 = NULL, *subvol2 = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-        GF_VALIDATE_OR_GOTO ("dht", cookie, out);
-
-        local = frame->local;
-        prev = cookie;
-
-        /* zerofill fails with EBADF if dht has not yet opened the fd
-         * on the cached subvol. This could happen if the file was migrated
-         * and a lookup updated the cached subvol in the inode ctx.
-         * We only check once as this could actually be a valid error.
-         */
-        if ((op_ret == -1) && (op_errno == EBADF)
-             && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                local->op_errno = op_errno;
-                local->op_ret = -1;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        if (local->call_cnt != 1) {
-                if (local->stbuf.ia_blocks) {
-                        dht_iatt_merge (this, postbuf, &local->stbuf);
-                        dht_iatt_merge (this, prebuf, &local->prebuf);
-                }
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    xlator_t *subvol1 = NULL, *subvol2 = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+    GF_VALIDATE_OR_GOTO("dht", cookie, out);
+
+    local = frame->local;
+    prev = cookie;
+
+    /* zerofill fails with EBADF if dht has not yet opened the fd
+     * on the cached subvol. This could happen if the file was migrated
+     * and a lookup updated the cached subvol in the inode ctx.
+     * We only check once as this could actually be a valid error.
+     */
+    if ((op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->rebalance.target_op_fn = dht_zerofill2;
-        local->op_ret = op_ret;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
         local->op_errno = op_errno;
-
-        dht_set_local_rebalance (this, local, NULL, prebuf, postbuf, xdata);
-
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
+        local->op_ret = -1;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    if (local->call_cnt != 1) {
+        if (local->stbuf.ia_blocks) {
+            dht_iatt_merge(this, postbuf, &local->stbuf);
+            dht_iatt_merge(this, prebuf, &local->prebuf);
         }
-
-        /* Check if the rebalance phase1 is true */
-        if (IS_DHT_MIGRATION_PHASE1 (postbuf)) {
-                dht_iatt_merge (this, &local->stbuf, postbuf);
-                dht_iatt_merge (this, &local->prebuf, prebuf);
-
-                ret = dht_inode_ctx_get_mig_info (this, local->fd->inode,
-                                                  &subvol1, &subvol2);
-                if (!dht_mig_info_is_invalid (local->cached_subvol,
-                                              subvol1, subvol2)) {
-                        if (dht_fd_open_on_dst (this, local->fd, subvol2)) {
-                                dht_zerofill2 (this, subvol2, frame, 0);
-                                return 0;
-                        }
-                }
-
-                ret = dht_rebalance_in_progress_check (this, frame);
-                if (!ret)
-                        return 0;
+        goto out;
+    }
+
+    local->rebalance.target_op_fn = dht_zerofill2;
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
+
+    dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
+
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
+    /* Check if the rebalance phase1 is true */
+    if (IS_DHT_MIGRATION_PHASE1(postbuf)) {
+        dht_iatt_merge(this, &local->stbuf, postbuf);
+        dht_iatt_merge(this, &local->prebuf, prebuf);
+
+        ret = dht_inode_ctx_get_mig_info(this, local->fd->inode, &subvol1,
+                                         &subvol2);
+        if (!dht_mig_info_is_invalid(local->cached_subvol, subvol1, subvol2)) {
+            if (dht_fd_open_on_dst(this, local->fd, subvol2)) {
+                dht_zerofill2(this, subvol2, frame, 0);
+                return 0;
+            }
         }
 
+        ret = dht_rebalance_in_progress_check(this, frame);
+        if (!ret)
+            return 0;
+    }
+
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (zerofill, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(zerofill, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 err:
-        return 0;
+    return 0;
 }
 
 int
-dht_zerofill2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_zerofill2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
+    local = frame->local;
 
-        op_errno = local->op_errno;
+    op_errno = local->op_errno;
 
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (zerofill, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(zerofill, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
 
-                return 0;
-        }
+        return 0;
+    }
 
-        if (subvol == NULL)
-                goto out;
+    if (subvol == NULL)
+        goto out;
 
-        local->call_cnt = 2; /* This is the second attempt */
+    local->call_cnt = 2; /* This is the second attempt */
 
-        STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                           subvol->fops->zerofill,
-                           local->fd, local->rebalance.offset,
-                           local->rebalance.size, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                      subvol->fops->zerofill, local->fd,
+                      local->rebalance.offset, local->rebalance.size,
+                      local->xattr_req);
 
-        return 0;
+    return 0;
 
 out:
 
-        DHT_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-dht_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            off_t len, dict_t *xdata)
+dht_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             off_t len, dict_t *xdata)
 {
-        xlator_t     *subvol       = NULL;
-        int           op_errno     = -1;
-        dht_local_t  *local        = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_ZEROFILL);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
 
-        local->rebalance.offset = offset;
-        local->rebalance.size = len;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        local->call_cnt = 1;
-        subvol = local->cached_subvol;
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    local = dht_local_init(frame, NULL, fd, GF_FOP_ZEROFILL);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
+    local->rebalance.offset = offset;
+    local->rebalance.size = len;
 
-        STACK_WIND_COOKIE (frame, dht_zerofill_cbk, subvol, subvol,
-                           subvol->fops->zerofill, fd,
-                           local->rebalance.offset,
-                           local->rebalance.size, local->xattr_req);
+    local->call_cnt = 1;
+    subvol = local->cached_subvol;
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        return 0;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    STACK_WIND_COOKIE(frame, dht_zerofill_cbk, subvol, subvol,
+                      subvol->fops->zerofill, fd, local->rebalance.offset,
+                      local->rebalance.size, local->xattr_req);
 
-        return 0;
-}
+    return 0;
 
+err:
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
 
+    return 0;
+}
 
 /* handle cases of migration here for 'setattr()' calls */
 int
-dht_file_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+dht_file_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int ret = -1;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        local->op_errno = op_errno;
-
-        if ((local->fop == GF_FOP_FSETATTR) &&
-            (op_ret == -1) && (op_errno == EBADF) && !(local->fd_checked)) {
-                ret = dht_check_and_open_fd_on_subvol (this, frame);
-                if (ret)
-                        goto out;
-                return 0;
-        }
-
-        if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
+    local->op_errno = op_errno;
 
-        if (local->call_cnt != 1)
-                goto out;
+    if ((local->fop == GF_FOP_FSETATTR) && (op_ret == -1) &&
+        (op_errno == EBADF) && !(local->fd_checked)) {
+        ret = dht_check_and_open_fd_on_subvol(this, frame);
+        if (ret)
+            goto out;
+        return 0;
+    }
 
-        local->op_ret = op_ret;
-        local->op_errno = op_errno;
+    if ((op_ret == -1) && !dht_inode_missing(op_errno)) {
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
 
-        local->rebalance.target_op_fn = dht_setattr2;
+    if (local->call_cnt != 1)
+        goto out;
 
+    local->op_ret = op_ret;
+    local->op_errno = op_errno;
 
-        /* Phase 2 of migration */
-        if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2 (postbuf)) {
+    local->rebalance.target_op_fn = dht_setattr2;
 
-                dht_set_local_rebalance (this, local, NULL, prebuf,
-                                         postbuf, xdata);
+    /* Phase 2 of migration */
+    if ((op_ret == -1) || IS_DHT_MIGRATION_PHASE2(postbuf)) {
+        dht_set_local_rebalance(this, local, NULL, prebuf, postbuf, xdata);
 
-                ret = dht_rebalance_complete_check (this, frame);
-                if (!ret)
-                        return 0;
-        }
+        ret = dht_rebalance_complete_check(this, frame);
+        if (!ret)
+            return 0;
+    }
 
-        /* At the end of the migration process, whatever 'attr' we
-           have on source file will be migrated to destination file
-           in one shot, hence we don't need to check for in progress
-           state here (ie, PHASE1) */
+    /* At the end of the migration process, whatever 'attr' we
+       have on source file will be migrated to destination file
+       in one shot, hence we don't need to check for in progress
+       state here (ie, PHASE1) */
 out:
-        DHT_STRIP_PHASE1_FLAGS (postbuf);
-        DHT_STRIP_PHASE1_FLAGS (prebuf);
+    DHT_STRIP_PHASE1_FLAGS(postbuf);
+    DHT_STRIP_PHASE1_FLAGS(prebuf);
 
-        DHT_STACK_UNWIND (setattr, frame, op_ret, op_errno,
-                          prebuf, postbuf, xdata);
+    DHT_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_setattr2 (xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
+dht_setattr2(xlator_t *this, xlator_t *subvol, call_frame_t *frame, int ret)
 {
-        dht_local_t *local    = NULL;
-        int32_t      op_errno = EINVAL;
+    dht_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
 
-        if (!frame || !frame->local)
-                goto out;
+    if (!frame || !frame->local)
+        goto out;
 
-        local = frame->local;
-        op_errno = local->op_errno;
-
-        if (we_are_not_migrating (ret)) {
-                /* This dht xlator is not migrating the file. Unwind and
-                 * pass on the original mode bits so the higher DHT layer
-                 * can handle this.
-                 */
-                DHT_STACK_UNWIND (setattr, frame, local->op_ret,
-                                  local->op_errno,
-                                  &local->rebalance.prebuf,
-                                  &local->rebalance.postbuf,
-                                  local->rebalance.xdata);
-                return 0;
-        }
+    local = frame->local;
+    op_errno = local->op_errno;
 
-        if (subvol == NULL)
-                goto out;
+    if (we_are_not_migrating(ret)) {
+        /* This dht xlator is not migrating the file. Unwind and
+         * pass on the original mode bits so the higher DHT layer
+         * can handle this.
+         */
+        DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                         &local->rebalance.prebuf, &local->rebalance.postbuf,
+                         local->rebalance.xdata);
+        return 0;
+    }
 
-        local->call_cnt = 2; /* This is the second attempt */
-
-        if (local->fop == GF_FOP_SETATTR) {
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->setattr, &local->loc,
-                                   &local->rebalance.stbuf, local->rebalance.flags,
-                                   local->xattr_req);
-        } else {
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, local->fd,
-                                   &local->rebalance.stbuf, local->rebalance.flags,
-                                   local->xattr_req);
-        }
+    if (subvol == NULL)
+        goto out;
 
-        return 0;
+    local->call_cnt = 2; /* This is the second attempt */
+
+    if (local->fop == GF_FOP_SETATTR) {
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->setattr, &local->loc,
+                          &local->rebalance.stbuf, local->rebalance.flags,
+                          local->xattr_req);
+    } else {
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->fsetattr, local->fd,
+                          &local->rebalance.stbuf, local->rebalance.flags,
+                          local->xattr_req);
+    }
+
+    return 0;
 
 out:
-        DHT_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 /* Keep the existing code same for all the cases other than regular file */
 int
-dht_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, struct iatt *statpre,
-                 struct iatt *statpost, dict_t *xdata)
+dht_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *statpre, struct iatt *statpost,
+                dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-
-
-        local = frame->local;
-        prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        gf_msg_debug (this->name, op_errno,
-                                      "subvolume %s returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-                dht_iatt_merge (this, &local->prebuf, statpre);
-                dht_iatt_merge (this, &local->stbuf, statpost);
+    local = frame->local;
+    prev = cookie;
 
-                local->op_ret = 0;
-                local->op_errno = 0;
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                         prev->name);
+            goto unlock;
         }
+
+        dht_iatt_merge(this, &local->prebuf, statpre);
+        dht_iatt_merge(this, &local->stbuf, statpost);
+
+        local->op_ret = 0;
+        local->op_errno = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-		if (local->op_ret == 0)
-			dht_inode_ctx_time_set (local->loc.inode, this,
-						&local->stbuf);
-                DHT_STACK_UNWIND (setattr, frame, local->op_ret, local->op_errno,
-                                  &local->prebuf, &local->stbuf, xdata);
-	}
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (local->op_ret == 0)
+            dht_inode_ctx_time_set(local->loc.inode, this, &local->stbuf);
+        DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                         &local->prebuf, &local->stbuf, xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 /* Keep the existing code same for all the cases other than regular file */
 int
-dht_non_mds_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *statpre,
-                         struct iatt *statpost, dict_t *xdata)
+dht_non_mds_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, struct iatt *statpre,
+                        struct iatt *statpost, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
-        xlator_t     *prev = NULL;
-
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        gf_msg (this->name, op_errno, 0,
-                                0, "subvolume %s returned -1",
-                                prev->name);
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            gf_msg(this->name, op_errno, 0, 0, "subvolume %s returned -1",
+                   prev->name);
 
-                        goto unlock;
-                }
+            goto unlock;
+        }
 
-                dht_iatt_merge (this, &local->prebuf, statpre);
-                dht_iatt_merge (this, &local->stbuf, statpost);
+        dht_iatt_merge(this, &local->prebuf, statpre);
+        dht_iatt_merge(this, &local->stbuf, statpost);
 
-                local->op_ret = 0;
-                local->op_errno = 0;
-        }
+        local->op_ret = 0;
+        local->op_errno = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                dht_inode_ctx_time_set (local->loc.inode, this, &local->stbuf);
-                DHT_STACK_UNWIND (setattr, frame, 0, 0,
-                                  &local->prebuf, &local->stbuf, xdata);
-	}
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        dht_inode_ctx_time_set(local->loc.inode, this, &local->stbuf);
+        DHT_STACK_UNWIND(setattr, frame, 0, 0, &local->prebuf, &local->stbuf,
+                         xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
-
-
-
-
 int
-dht_mds_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, struct iatt *statpre,
-                     struct iatt *statpost, dict_t *xdata)
+dht_mds_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, struct iatt *statpre,
+                    struct iatt *statpost, dict_t *xdata)
 
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *mds_subvol = NULL;
-        struct iatt  loc_stbuf = {0,};
-        int i = 0;
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-        mds_subvol = local->mds_subvol;
-
-        if (op_ret == -1) {
-                local->op_ret  = op_ret;
-                local->op_errno = op_errno;
-                gf_msg_debug (this->name, op_errno,
-                              "subvolume %s returned -1",
-                              prev->name);
-                goto out;
-        }
-
-        local->op_ret = 0;
-        loc_stbuf = local->stbuf;
-        dht_iatt_merge (this, &local->prebuf, statpre);
-        dht_iatt_merge (this, &local->stbuf, statpost);
-
-        local->call_cnt = conf->subvolume_cnt - 1;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (mds_subvol == conf->subvolumes[i])
-                        continue;
-                STACK_WIND_COOKIE (frame, dht_non_mds_setattr_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->setattr,
-                                   &local->loc, &loc_stbuf,
-                                   local->valid, local->xattr_req);
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *mds_subvol = NULL;
+    struct iatt loc_stbuf = {
+        0,
+    };
+    int i = 0;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    mds_subvol = local->mds_subvol;
+
+    if (op_ret == -1) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        gf_msg_debug(this->name, op_errno, "subvolume %s returned -1",
+                     prev->name);
+        goto out;
+    }
+
+    local->op_ret = 0;
+    loc_stbuf = local->stbuf;
+    dht_iatt_merge(this, &local->prebuf, statpre);
+    dht_iatt_merge(this, &local->stbuf, statpost);
+
+    local->call_cnt = conf->subvolume_cnt - 1;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol == conf->subvolumes[i])
+            continue;
+        STACK_WIND_COOKIE(frame, dht_non_mds_setattr_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->setattr, &local->loc,
+                          &loc_stbuf, local->valid, local->xattr_req);
+    }
+
+    return 0;
 out:
-        DHT_STACK_UNWIND (setattr, frame, local->op_ret, local->op_errno,
-                          &local->prebuf, &local->stbuf, xdata);
+    DHT_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                     &local->prebuf, &local->stbuf, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             struct iatt *stbuf, int32_t valid, dict_t *xdata)
+dht_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+            int32_t valid, dict_t *xdata)
 {
-        xlator_t     *subvol     = NULL;
-        xlator_t     *mds_subvol = NULL;
-        dht_layout_t *layout     = NULL;
-        dht_local_t  *local      = NULL;
-        int           op_errno   = -1;
-        int           i          = -1;
-        int           ret        = -1;
-        int           call_cnt   = 0;
-        dht_conf_t   *conf       = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        conf = this->private;
-        local = dht_local_init (frame, loc, NULL, GF_FOP_SETATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (!layout_is_sane (layout)) {
-                gf_msg_debug (this->name, 0,
-                              "layout is not sane for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (loc->inode->ia_type)) {
-                /* in the regular file _cbk(), we need to check for
-                   migration possibilities */
-                local->rebalance.stbuf = *stbuf;
-                local->rebalance.flags = valid;
-                local->call_cnt = 1;
-                subvol = local->cached_subvol;
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int ret = -1;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    conf = this->private;
+    local = dht_local_init(frame, loc, NULL, GF_FOP_SETATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for path=%s", loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (!layout_is_sane(layout)) {
+        gf_msg_debug(this->name, 0, "layout is not sane for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(loc->inode->ia_type)) {
+        /* in the regular file _cbk(), we need to check for
+           migration possibilities */
+        local->rebalance.stbuf = *stbuf;
+        local->rebalance.flags = valid;
+        local->call_cnt = 1;
+        subvol = local->cached_subvol;
 
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->setattr, loc, stbuf,
-                                   valid, xdata);
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->setattr, loc, stbuf, valid, xdata);
 
-                return 0;
+        return 0;
+    }
+
+    local->call_cnt = call_cnt = layout->cnt;
+
+    if (IA_ISDIR(loc->inode->ia_type) && !__is_root_gfid(loc->inode->gfid) &&
+        call_cnt != 1) {
+        ret = dht_inode_ctx_mdsvol_get(loc->inode, this, &mds_subvol);
+        if (ret || !mds_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+                   "Failed to get mds subvol for path %s", local->loc.path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        local->call_cnt = call_cnt = layout->cnt;
-
-        if (IA_ISDIR (loc->inode->ia_type) &&
-            !__is_root_gfid (loc->inode->gfid) && call_cnt != 1) {
-                ret = dht_inode_ctx_mdsvol_get (loc->inode, this, &mds_subvol);
-                if (ret || !mds_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                                "Failed to get mds subvol for path %s",
-                                local->loc.path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                local->mds_subvol = mds_subvol;
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvolumes[i] ==  mds_subvol) {
-                                if (!conf->subvolume_status[i]) {
-                                        gf_msg (this->name, GF_LOG_WARNING,
-                                                layout->list[i].err,
-                                                DHT_MSG_HASHED_SUBVOL_DOWN,
-                                                "MDS subvol is down for path "
-                                                " %s Unable to set attr " ,
-                                                local->loc.path);
-                                        op_errno = ENOTCONN;
-                                        goto err;
-                                }
-                        }
-                }
-                local->valid = valid;
-                local->stbuf = *stbuf;
-
-                STACK_WIND_COOKIE (frame, dht_mds_setattr_cbk,
-                                   local->mds_subvol,
-                                   local->mds_subvol,
-                                   local->mds_subvol->fops->setattr,
-                                   loc, stbuf, valid, xdata);
-                return 0;
-        } else {
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_setattr_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->setattr,
-                                           loc, stbuf, valid, xdata);
+        local->mds_subvol = mds_subvol;
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == mds_subvol) {
+                if (!conf->subvolume_status[i]) {
+                    gf_msg(this->name, GF_LOG_WARNING, layout->list[i].err,
+                           DHT_MSG_HASHED_SUBVOL_DOWN,
+                           "MDS subvol is down for path "
+                           " %s Unable to set attr ",
+                           local->loc.path);
+                    op_errno = ENOTCONN;
+                    goto err;
                 }
+            }
         }
+        local->valid = valid;
+        local->stbuf = *stbuf;
 
+        STACK_WIND_COOKIE(frame, dht_mds_setattr_cbk, local->mds_subvol,
+                          local->mds_subvol, local->mds_subvol->fops->setattr,
+                          loc, stbuf, valid, xdata);
         return 0;
+    } else {
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_setattr_cbk, layout->list[i].xlator,
+                              layout->list[i].xlator,
+                              layout->list[i].xlator->fops->setattr, loc, stbuf,
+                              valid, xdata);
+        }
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
-              int32_t valid, dict_t *xdata)
+dht_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
+             int32_t valid, dict_t *xdata)
 {
-        xlator_t     *subvol = NULL;
-        dht_layout_t *layout = NULL;
-        dht_local_t  *local  = NULL;
-        int           op_errno = -1;
-        int           i = -1;
-        int           call_cnt = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        local = dht_local_init (frame, NULL, fd, GF_FOP_FSETATTR);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        layout = local->layout;
-        if (!layout) {
-                gf_msg_debug (this->name, 0,
-                              "no layout for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
+    xlator_t *subvol = NULL;
+    dht_layout_t *layout = NULL;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    int i = -1;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    local = dht_local_init(frame, NULL, fd, GF_FOP_FSETATTR);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    layout = local->layout;
+    if (!layout) {
+        gf_msg_debug(this->name, 0, "no layout for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (!layout_is_sane(layout)) {
+        gf_msg_debug(this->name, 0, "layout is not sane for fd=%p", fd);
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (IA_ISREG(fd->inode->ia_type)) {
+        /* in the regular file _cbk(), we need to check for
+           migration possibilities */
+        local->rebalance.stbuf = *stbuf;
+        local->rebalance.flags = valid;
+        local->call_cnt = 1;
+        subvol = local->cached_subvol;
 
-        if (!layout_is_sane (layout)) {
-                gf_msg_debug (this->name, 0,
-                              "layout is not sane for fd=%p", fd);
-                op_errno = EINVAL;
-                goto err;
-        }
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (IA_ISREG (fd->inode->ia_type)) {
-                /* in the regular file _cbk(), we need to check for
-                   migration possibilities */
-                local->rebalance.stbuf = *stbuf;
-                local->rebalance.flags = valid;
-                local->call_cnt = 1;
-                subvol = local->cached_subvol;
-
-                STACK_WIND_COOKIE (frame, dht_file_setattr_cbk, subvol,
-                                   subvol, subvol->fops->fsetattr, fd,
-                                   &local->rebalance.stbuf,
-                                   local->rebalance.flags,
-                                   local->xattr_req);
-                return 0;
-        }
+        STACK_WIND_COOKIE(frame, dht_file_setattr_cbk, subvol, subvol,
+                          subvol->fops->fsetattr, fd, &local->rebalance.stbuf,
+                          local->rebalance.flags, local->xattr_req);
+        return 0;
+    }
 
-        local->call_cnt = call_cnt = layout->cnt;
+    local->call_cnt = call_cnt = layout->cnt;
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_setattr_cbk,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator,
-                                   layout->list[i].xlator->fops->fsetattr,
-                                   fd, stbuf, valid, xdata);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_setattr_cbk, layout->list[i].xlator,
+                          layout->list[i].xlator,
+                          layout->list[i].xlator->fops->fsetattr, fd, stbuf,
+                          valid, xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-layout.c b/xlators/cluster/dht/src/dht-layout.c
index 97b98e01451..43746bc63b9 100644
--- a/xlators/cluster/dht/src/dht-layout.c
+++ b/xlators/cluster/dht/src/dht-layout.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "glusterfs.h"
 #include "xlator.h"
 #include "dht-common.h"
@@ -16,862 +15,814 @@
 #include "dht-messages.h"
 #include "unittest/unittest.h"
 
+#define layout_base_size (sizeof(dht_layout_t))
 
-#define layout_base_size (sizeof (dht_layout_t))
-
-#define layout_entry_size (sizeof ((dht_layout_t *)NULL)->list[0])
+#define layout_entry_size (sizeof((dht_layout_t *)NULL)->list[0])
 
 #define layout_size(cnt) (layout_base_size + (cnt * layout_entry_size))
 
 dht_layout_t *
-dht_layout_new (xlator_t *this, int cnt)
+dht_layout_new(xlator_t *this, int cnt)
 {
-        dht_layout_t *layout = NULL;
-        dht_conf_t   *conf = NULL;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = NULL;
 
-        REQUIRE(NULL != this);
-        REQUIRE(cnt >= 0);
+    REQUIRE(NULL != this);
+    REQUIRE(cnt >= 0);
 
-        conf = this->private;
+    conf = this->private;
 
-        layout = GF_CALLOC (1, layout_size (cnt),
-                            gf_dht_mt_dht_layout_t);
-        if (!layout) {
-                goto out;
-        }
+    layout = GF_CALLOC(1, layout_size(cnt), gf_dht_mt_dht_layout_t);
+    if (!layout) {
+        goto out;
+    }
 
-        layout->type = DHT_HASH_TYPE_DM;
-        layout->cnt = cnt;
+    layout->type = DHT_HASH_TYPE_DM;
+    layout->cnt = cnt;
 
-        if (conf) {
-                layout->spread_cnt = conf->dir_spread_cnt;
-                layout->gen = conf->gen;
-        }
+    if (conf) {
+        layout->spread_cnt = conf->dir_spread_cnt;
+        layout->gen = conf->gen;
+    }
 
-        GF_ATOMIC_INIT (layout->ref, 1);
+    GF_ATOMIC_INIT(layout->ref, 1);
 
-        ENSURE(NULL != layout);
-        ENSURE(layout->type == DHT_HASH_TYPE_DM);
-        ENSURE(layout->cnt == cnt);
-        ENSURE(GF_ATOMIC_GET (layout->ref) == 1);
+    ENSURE(NULL != layout);
+    ENSURE(layout->type == DHT_HASH_TYPE_DM);
+    ENSURE(layout->cnt == cnt);
+    ENSURE(GF_ATOMIC_GET(layout->ref) == 1);
 out:
-        return layout;
+    return layout;
 }
 
-
 dht_layout_t *
-dht_layout_get (xlator_t *this, inode_t *inode)
+dht_layout_get(xlator_t *this, inode_t *inode)
 {
-        dht_layout_t *layout = NULL;
-        int           ret = 0;
-
-        ret = dht_inode_ctx_layout_get (inode, this, &layout);
-        if ((!ret) && layout) {
-                GF_ATOMIC_INC (layout->ref);
-        }
-        return layout;
+    dht_layout_t *layout = NULL;
+    int ret = 0;
+
+    ret = dht_inode_ctx_layout_get(inode, this, &layout);
+    if ((!ret) && layout) {
+        GF_ATOMIC_INC(layout->ref);
+    }
+    return layout;
 }
 
-
 int
-dht_layout_set (xlator_t *this, inode_t *inode, dht_layout_t *layout)
+dht_layout_set(xlator_t *this, inode_t *inode, dht_layout_t *layout)
 {
-        dht_conf_t   *conf = NULL;
-        int           oldret = -1;
-        int           ret = -1;
-        dht_layout_t *old_layout;
-
-        conf = this->private;
-        if (!conf || !layout)
-                goto out;
-
-        LOCK (&conf->layout_lock);
-        {
-                oldret = dht_inode_ctx_layout_get (inode, this, &old_layout);
-                if (layout)
-                        GF_ATOMIC_INC (layout->ref);
-                ret = dht_inode_ctx_layout_set (inode, this, layout);
-        }
-        UNLOCK (&conf->layout_lock);
-
-        if (!oldret) {
-                dht_layout_unref (this, old_layout);
-        }
-        if (ret)
-                GF_ATOMIC_DEC (layout->ref);
+    dht_conf_t *conf = NULL;
+    int oldret = -1;
+    int ret = -1;
+    dht_layout_t *old_layout;
+
+    conf = this->private;
+    if (!conf || !layout)
+        goto out;
+
+    LOCK(&conf->layout_lock);
+    {
+        oldret = dht_inode_ctx_layout_get(inode, this, &old_layout);
+        if (layout)
+            GF_ATOMIC_INC(layout->ref);
+        ret = dht_inode_ctx_layout_set(inode, this, layout);
+    }
+    UNLOCK(&conf->layout_lock);
+
+    if (!oldret) {
+        dht_layout_unref(this, old_layout);
+    }
+    if (ret)
+        GF_ATOMIC_DEC(layout->ref);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-dht_layout_unref (xlator_t *this, dht_layout_t *layout)
+dht_layout_unref(xlator_t *this, dht_layout_t *layout)
 {
-        int          ref = 0;
+    int ref = 0;
 
-        if (!layout || layout->preset || !this->private)
-                return;
+    if (!layout || layout->preset || !this->private)
+        return;
 
-        ref = GF_ATOMIC_DEC (layout->ref);
+    ref = GF_ATOMIC_DEC(layout->ref);
 
-        if (!ref)
-                GF_FREE (layout);
+    if (!ref)
+        GF_FREE(layout);
 }
 
-
 dht_layout_t *
-dht_layout_ref (xlator_t *this, dht_layout_t *layout)
+dht_layout_ref(xlator_t *this, dht_layout_t *layout)
 {
-        if (layout->preset || !this->private)
-                return layout;
+    if (layout->preset || !this->private)
+        return layout;
 
-        GF_ATOMIC_INC (layout->ref);
+    GF_ATOMIC_INC(layout->ref);
 
-        return layout;
+    return layout;
 }
 
-
 xlator_t *
-dht_layout_search (xlator_t *this, dht_layout_t *layout, const char *name)
+dht_layout_search(xlator_t *this, dht_layout_t *layout, const char *name)
 {
-        uint32_t   hash = 0;
-        xlator_t  *subvol = NULL;
-        int        i = 0;
-        int        ret = 0;
-
-        ret = dht_hash_compute (this, layout->type, name, &hash);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_COMPUTE_HASH_FAILED,
-                        "hash computation failed for type=%d name=%s",
-                        layout->type, name);
-                goto out;
-        }
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].start <= hash
-                    && layout->list[i].stop >= hash) {
-                        subvol = layout->list[i].xlator;
-                        break;
-                }
-        }
-
-        if (!subvol) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "no subvolume for hash (value) = %u", hash);
-        }
+    uint32_t hash = 0;
+    xlator_t *subvol = NULL;
+    int i = 0;
+    int ret = 0;
+
+    ret = dht_hash_compute(this, layout->type, name, &hash);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_COMPUTE_HASH_FAILED,
+               "hash computation failed for type=%d name=%s", layout->type,
+               name);
+        goto out;
+    }
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].start <= hash && layout->list[i].stop >= hash) {
+            subvol = layout->list[i].xlator;
+            break;
+        }
+    }
+
+    if (!subvol) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "no subvolume for hash (value) = %u", hash);
+    }
 
 out:
-        return subvol;
+    return subvol;
 }
 
-
 dht_layout_t *
-dht_layout_for_subvol (xlator_t *this, xlator_t *subvol)
+dht_layout_for_subvol(xlator_t *this, xlator_t *subvol)
 {
-        dht_conf_t   *conf = NULL;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == subvol) {
-                        layout = conf->file_layouts[i];
-                        break;
-                }
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+
+    conf = this->private;
+    if (!conf)
+        goto out;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == subvol) {
+            layout = conf->file_layouts[i];
+            break;
         }
+    }
 
 out:
-        return layout;
+    return layout;
 }
 
-
 int
-dht_layouts_init (xlator_t *this, dht_conf_t *conf)
+dht_layouts_init(xlator_t *this, dht_conf_t *conf)
 {
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           ret = -1;
-
-        if (!conf)
-                goto out;
-
-        conf->file_layouts = GF_CALLOC (conf->subvolume_cnt,
-                                        sizeof (dht_layout_t *),
-                                        gf_dht_mt_dht_layout_t);
-        if (!conf->file_layouts) {
-                goto out;
-        }
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int ret = -1;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                layout = dht_layout_new (this, 1);
+    if (!conf)
+        goto out;
 
-                if (!layout) {
-                        goto out;
-                }
-
-                layout->preset = 1;
+    conf->file_layouts = GF_CALLOC(conf->subvolume_cnt, sizeof(dht_layout_t *),
+                                   gf_dht_mt_dht_layout_t);
+    if (!conf->file_layouts) {
+        goto out;
+    }
 
-                layout->list[0].xlator = conf->subvolumes[i];
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        layout = dht_layout_new(this, 1);
 
-                conf->file_layouts[i] = layout;
+        if (!layout) {
+            goto out;
         }
 
-        ret = 0;
+        layout->preset = 1;
+
+        layout->list[0].xlator = conf->subvolumes[i];
+
+        conf->file_layouts[i] = layout;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_disk_layout_extract (xlator_t *this, dht_layout_t *layout,
-                         int pos, int32_t **disk_layout_p)
+dht_disk_layout_extract(xlator_t *this, dht_layout_t *layout, int pos,
+                        int32_t **disk_layout_p)
 {
-        int      ret = -1;
-        int32_t *disk_layout = NULL;
+    int ret = -1;
+    int32_t *disk_layout = NULL;
 
-        disk_layout = GF_CALLOC (5, sizeof (int),
-                                 gf_dht_mt_int32_t);
-        if (!disk_layout) {
-                goto out;
-        }
+    disk_layout = GF_CALLOC(5, sizeof(int), gf_dht_mt_int32_t);
+    if (!disk_layout) {
+        goto out;
+    }
 
-        disk_layout[0] = hton32 (layout->list[pos].commit_hash);
-        disk_layout[1] = hton32 (layout->type);
-        disk_layout[2] = hton32 (layout->list[pos].start);
-        disk_layout[3] = hton32 (layout->list[pos].stop);
+    disk_layout[0] = hton32(layout->list[pos].commit_hash);
+    disk_layout[1] = hton32(layout->type);
+    disk_layout[2] = hton32(layout->list[pos].start);
+    disk_layout[3] = hton32(layout->list[pos].stop);
 
-        if (disk_layout_p)
-                *disk_layout_p = disk_layout;
-        else
-                GF_FREE (disk_layout);
+    if (disk_layout_p)
+        *disk_layout_p = disk_layout;
+    else
+        GF_FREE(disk_layout);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_disk_layout_extract_for_subvol (xlator_t *this, dht_layout_t *layout,
-                                    xlator_t *subvol, int32_t **disk_layout_p)
+dht_disk_layout_extract_for_subvol(xlator_t *this, dht_layout_t *layout,
+                                   xlator_t *subvol, int32_t **disk_layout_p)
 {
-        int i = 0;
+    int i = 0;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol)
-                        break;
-        }
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol)
+            break;
+    }
 
-        if (i == layout->cnt)
-                return -1;
+    if (i == layout->cnt)
+        return -1;
 
-        return dht_disk_layout_extract (this, layout, i, disk_layout_p);
+    return dht_disk_layout_extract(this, layout, i, disk_layout_p);
 }
 
 int
-dht_disk_layout_merge (xlator_t *this, dht_layout_t *layout,
-		       int pos, void *disk_layout_raw, int disk_layout_len)
+dht_disk_layout_merge(xlator_t *this, dht_layout_t *layout, int pos,
+                      void *disk_layout_raw, int disk_layout_len)
 {
-        int      type = 0;
-        int      start_off = 0;
-        int      stop_off = 0;
-        int      commit_hash = 0;
-        int      disk_layout[4];
+    int type = 0;
+    int start_off = 0;
+    int stop_off = 0;
+    int commit_hash = 0;
+    int disk_layout[4];
 
-	if (!disk_layout_raw) {
-		gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "error no layout on disk for merge");
-		return -1;
-	}
+    if (!disk_layout_raw) {
+        gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+               "error no layout on disk for merge");
+        return -1;
+    }
 
-	GF_ASSERT (disk_layout_len == sizeof (disk_layout));
+    GF_ASSERT(disk_layout_len == sizeof(disk_layout));
 
-        memcpy (disk_layout, disk_layout_raw, disk_layout_len);
+    memcpy(disk_layout, disk_layout_raw, disk_layout_len);
 
-        type = ntoh32 (disk_layout[1]);
-	switch (type) {
+    type = ntoh32(disk_layout[1]);
+    switch (type) {
         case DHT_HASH_TYPE_DM_USER:
-                gf_msg_debug (this->name, 0, "found user-set layout");
-                layout->type = type;
-                /* Fall through. */
-	case DHT_HASH_TYPE_DM:
-		break;
+            gf_msg_debug(this->name, 0, "found user-set layout");
+            layout->type = type;
+            /* Fall through. */
+        case DHT_HASH_TYPE_DM:
+            break;
         default:
-		gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_INVALID_DISK_LAYOUT,
-			"Invalid disk layout: "
-                        "Catastrophic error layout with unknown type found %d",
-			disk_layout[1]);
-		return -1;
-	}
-
-        commit_hash = ntoh32 (disk_layout[0]);
-        start_off = ntoh32 (disk_layout[2]);
-        stop_off  = ntoh32 (disk_layout[3]);
-
-        layout->list[pos].commit_hash = commit_hash;
-        layout->list[pos].start = start_off;
-        layout->list[pos].stop  = stop_off;
-
-        gf_msg_trace (this->name, 0,
-                      "merged to layout: %u - %u (type %d, hash %d) from %s",
-                      start_off, stop_off, commit_hash, type,
-                      layout->list[pos].xlator->name);
-
-        return 0;
+            gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_INVALID_DISK_LAYOUT,
+                   "Invalid disk layout: "
+                   "Catastrophic error layout with unknown type found %d",
+                   disk_layout[1]);
+            return -1;
+    }
+
+    commit_hash = ntoh32(disk_layout[0]);
+    start_off = ntoh32(disk_layout[2]);
+    stop_off = ntoh32(disk_layout[3]);
+
+    layout->list[pos].commit_hash = commit_hash;
+    layout->list[pos].start = start_off;
+    layout->list[pos].stop = stop_off;
+
+    gf_msg_trace(
+        this->name, 0, "merged to layout: %u - %u (type %d, hash %d) from %s",
+        start_off, stop_off, commit_hash, type, layout->list[pos].xlator->name);
+
+    return 0;
 }
 
 int
-dht_layout_merge (xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
-                  int op_ret, int op_errno, dict_t *xattr)
+dht_layout_merge(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                 int op_ret, int op_errno, dict_t *xattr)
 {
-        int         i     = 0;
-        int         ret   = -1;
-        int         err   = -1;
-        void       *disk_layout_raw = NULL;
-        int         disk_layout_len = 0;
-        dht_conf_t *conf = this->private;
-
-        if (op_ret != 0) {
-                err = op_errno;
-        }
+    int i = 0;
+    int ret = -1;
+    int err = -1;
+    void *disk_layout_raw = NULL;
+    int disk_layout_len = 0;
+    dht_conf_t *conf = this->private;
 
-        if (!layout)
-                goto out;
+    if (op_ret != 0) {
+        err = op_errno;
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == NULL) {
-                        layout->list[i].err    = err;
-                        layout->list[i].xlator = subvol;
-                        break;
-                }
-        }
+    if (!layout)
+        goto out;
 
-        if (op_ret != 0) {
-                ret = 0;
-                goto out;
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == NULL) {
+            layout->list[i].err = err;
+            layout->list[i].xlator = subvol;
+            break;
         }
+    }
 
-        if (xattr) {
-                /* during lookup and not mkdir */
-                ret = dict_get_ptr_and_len (xattr, conf->xattr_name,
-					    &disk_layout_raw, &disk_layout_len);
-        }
+    if (op_ret != 0) {
+        ret = 0;
+        goto out;
+    }
 
-        if (ret != 0) {
-                layout->list[i].err = 0;
-                gf_msg_trace (this->name, 0,
-                              "Missing disk layout on %s. err = %d",
-                              subvol->name, err);
-                ret = 0;
-                goto out;
-        }
+    if (xattr) {
+        /* during lookup and not mkdir */
+        ret = dict_get_ptr_and_len(xattr, conf->xattr_name, &disk_layout_raw,
+                                   &disk_layout_len);
+    }
 
-        ret = dht_disk_layout_merge (this, layout, i, disk_layout_raw,
-				     disk_layout_len);
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_MERGE_FAILED,
-                        "layout merge from subvolume %s failed",
-                        subvol->name);
-                goto out;
-        }
+    if (ret != 0) {
+        layout->list[i].err = 0;
+        gf_msg_trace(this->name, 0, "Missing disk layout on %s. err = %d",
+                     subvol->name, err);
+        ret = 0;
+        goto out;
+    }
 
-        if (layout->commit_hash == 0) {
-                layout->commit_hash = layout->list[i].commit_hash;
-        } else if (layout->commit_hash != layout->list[i].commit_hash) {
-                layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
-        }
+    ret = dht_disk_layout_merge(this, layout, i, disk_layout_raw,
+                                disk_layout_len);
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_MERGE_FAILED,
+               "layout merge from subvolume %s failed", subvol->name);
+        goto out;
+    }
 
-        layout->list[i].err = 0;
+    if (layout->commit_hash == 0) {
+        layout->commit_hash = layout->list[i].commit_hash;
+    } else if (layout->commit_hash != layout->list[i].commit_hash) {
+        layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+    }
+
+    layout->list[i].err = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
 void
-dht_layout_entry_swap (dht_layout_t *layout, int i, int j)
+dht_layout_entry_swap(dht_layout_t *layout, int i, int j)
 {
-        uint32_t  start_swap = 0;
-        uint32_t  stop_swap = 0;
-        uint32_t  commit_hash_swap = 0;
-        xlator_t *xlator_swap = 0;
-        int       err_swap = 0;
-
-        start_swap  = layout->list[i].start;
-        stop_swap   = layout->list[i].stop;
-        xlator_swap = layout->list[i].xlator;
-        err_swap    = layout->list[i].err;
-        commit_hash_swap = layout->list[i].commit_hash;
-
-        layout->list[i].start  = layout->list[j].start;
-        layout->list[i].stop   = layout->list[j].stop;
-        layout->list[i].xlator = layout->list[j].xlator;
-        layout->list[i].err    = layout->list[j].err;
-        layout->list[i].commit_hash = layout->list[j].commit_hash;
-
-        layout->list[j].start  = start_swap;
-        layout->list[j].stop   = stop_swap;
-        layout->list[j].xlator = xlator_swap;
-        layout->list[j].err    = err_swap;
-        layout->list[j].commit_hash = commit_hash_swap;
+    uint32_t start_swap = 0;
+    uint32_t stop_swap = 0;
+    uint32_t commit_hash_swap = 0;
+    xlator_t *xlator_swap = 0;
+    int err_swap = 0;
+
+    start_swap = layout->list[i].start;
+    stop_swap = layout->list[i].stop;
+    xlator_swap = layout->list[i].xlator;
+    err_swap = layout->list[i].err;
+    commit_hash_swap = layout->list[i].commit_hash;
+
+    layout->list[i].start = layout->list[j].start;
+    layout->list[i].stop = layout->list[j].stop;
+    layout->list[i].xlator = layout->list[j].xlator;
+    layout->list[i].err = layout->list[j].err;
+    layout->list[i].commit_hash = layout->list[j].commit_hash;
+
+    layout->list[j].start = start_swap;
+    layout->list[j].stop = stop_swap;
+    layout->list[j].xlator = xlator_swap;
+    layout->list[j].err = err_swap;
+    layout->list[j].commit_hash = commit_hash_swap;
 }
 
 void
-dht_layout_range_swap (dht_layout_t *layout, int i, int j)
+dht_layout_range_swap(dht_layout_t *layout, int i, int j)
 {
-        uint32_t  start_swap = 0;
-        uint32_t  stop_swap = 0;
+    uint32_t start_swap = 0;
+    uint32_t stop_swap = 0;
 
-        start_swap  = layout->list[i].start;
-        stop_swap   = layout->list[i].stop;
+    start_swap = layout->list[i].start;
+    stop_swap = layout->list[i].stop;
 
-        layout->list[i].start  = layout->list[j].start;
-        layout->list[i].stop   = layout->list[j].stop;
+    layout->list[i].start = layout->list[j].start;
+    layout->list[i].stop = layout->list[j].stop;
 
-        layout->list[j].start  = start_swap;
-        layout->list[j].stop   = stop_swap;
+    layout->list[j].start = start_swap;
+    layout->list[j].stop = stop_swap;
 }
 
 int64_t
-dht_layout_entry_cmp_volname (dht_layout_t *layout, int i, int j)
+dht_layout_entry_cmp_volname(dht_layout_t *layout, int i, int j)
 {
-        return (strcmp (layout->list[i].xlator->name,
-                        layout->list[j].xlator->name));
+    return (strcmp(layout->list[i].xlator->name, layout->list[j].xlator->name));
 }
 
 gf_boolean_t
-dht_is_subvol_in_layout (dht_layout_t *layout, xlator_t *xlator)
+dht_is_subvol_in_layout(dht_layout_t *layout, xlator_t *xlator)
 {
-        int i = 0;
-
-        for (i = 0; i < layout->cnt; i++) {
-                /* Check if xlator is already part of layout, and layout is
-                 * non-zero. */
-                if (!strcmp (layout->list[i].xlator->name, xlator->name)) {
-                        if (layout->list[i].start != layout->list[i].stop)
-                                return _gf_true;
-                        break;
-                }
-        }
-        return _gf_false;
+    int i = 0;
+
+    for (i = 0; i < layout->cnt; i++) {
+        /* Check if xlator is already part of layout, and layout is
+         * non-zero. */
+        if (!strcmp(layout->list[i].xlator->name, xlator->name)) {
+            if (layout->list[i].start != layout->list[i].stop)
+                return _gf_true;
+            break;
+        }
+    }
+    return _gf_false;
 }
 
 int64_t
-dht_layout_entry_cmp (dht_layout_t *layout, int i, int j)
+dht_layout_entry_cmp(dht_layout_t *layout, int i, int j)
 {
-        int64_t diff = 0;
+    int64_t diff = 0;
 
-        /* swap zero'ed out layouts to front, if needed */
-        if (!layout->list[j].start && !layout->list[j].stop) {
-                diff = (int64_t) layout->list[i].stop
-                       - (int64_t) layout->list[j].stop;
-                       goto out;
-        }
-        diff = (int64_t) layout->list[i].start
-                - (int64_t) layout->list[j].start;
+    /* swap zero'ed out layouts to front, if needed */
+    if (!layout->list[j].start && !layout->list[j].stop) {
+        diff = (int64_t)layout->list[i].stop - (int64_t)layout->list[j].stop;
+        goto out;
+    }
+    diff = (int64_t)layout->list[i].start - (int64_t)layout->list[j].start;
 
 out:
-        return diff;
+    return diff;
 }
 
-
 int
-dht_layout_sort (dht_layout_t *layout)
+dht_layout_sort(dht_layout_t *layout)
 {
-        int       i = 0;
-        int       j = 0;
-        int64_t   ret = 0;
+    int i = 0;
+    int j = 0;
+    int64_t ret = 0;
 
-        /* TODO: O(n^2) -- bad bad */
+    /* TODO: O(n^2) -- bad bad */
 
-        for (i = 0; i < layout->cnt - 1; i++) {
-                for (j = i + 1; j < layout->cnt; j++) {
-                        ret = dht_layout_entry_cmp (layout, i, j);
-                        if (ret > 0)
-                                dht_layout_entry_swap (layout, i, j);
-                }
+    for (i = 0; i < layout->cnt - 1; i++) {
+        for (j = i + 1; j < layout->cnt; j++) {
+            ret = dht_layout_entry_cmp(layout, i, j);
+            if (ret > 0)
+                dht_layout_entry_swap(layout, i, j);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_layout_sort_volname (dht_layout_t *layout)
+dht_layout_sort_volname(dht_layout_t *layout)
 {
-        int       i = 0;
-        int       j = 0;
-        int64_t   ret = 0;
+    int i = 0;
+    int j = 0;
+    int64_t ret = 0;
 
-        /* TODO: O(n^2) -- bad bad */
+    /* TODO: O(n^2) -- bad bad */
 
-        for (i = 0; i < layout->cnt - 1; i++) {
-                for (j = i + 1; j < layout->cnt; j++) {
-                        ret = dht_layout_entry_cmp_volname (layout, i, j);
-                        if (ret > 0)
-                                dht_layout_entry_swap (layout, i, j);
-                }
+    for (i = 0; i < layout->cnt - 1; i++) {
+        for (j = i + 1; j < layout->cnt; j++) {
+            ret = dht_layout_entry_cmp_volname(layout, i, j);
+            if (ret > 0)
+                dht_layout_entry_swap(layout, i, j);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_layout_anomalies (xlator_t *this, loc_t *loc, dht_layout_t *layout,
-                      uint32_t *holes_p, uint32_t *overlaps_p,
-                      uint32_t *missing_p, uint32_t *down_p, uint32_t *misc_p,
-                      uint32_t *no_space_p)
+dht_layout_anomalies(xlator_t *this, loc_t *loc, dht_layout_t *layout,
+                     uint32_t *holes_p, uint32_t *overlaps_p,
+                     uint32_t *missing_p, uint32_t *down_p, uint32_t *misc_p,
+                     uint32_t *no_space_p)
 {
-        uint32_t    overlaps = 0;
-        uint32_t    missing  = 0;
-        uint32_t    down     = 0;
-        uint32_t    misc     = 0;
-        uint32_t    hole_cnt = 0;
-        uint32_t    overlap_cnt = 0;
-        int         i = 0;
-        int         ret = 0;
-        uint32_t    prev_stop = 0;
-        uint32_t    last_stop = 0;
-        char        is_virgin = 1;
-        uint32_t    no_space  = 0;
-
-        /* This function scans through the layout spread of a directory to
-           check if there are any anomalies. Prior to calling this function
-           the layout entries should be sorted in the ascending order.
-
-           If the layout entry has err != 0
-                then increment the corresponding anomaly.
-           else
-                if (start of the current layout entry > stop + 1 of previous
-                   non erroneous layout entry)
-                        then it indicates a hole in the layout
-                if (start of the current layout entry < stop + 1 of previous
-                    non erroneous layout entry)
-                         then it indicates an overlap in the layout
-        */
-        last_stop = layout->list[0].start - 1;
-        prev_stop = last_stop;
-
-        for (i = 0; i < layout->cnt; i++) {
-                switch (layout->list[i].err) {
-                case -1:
-                case ENOENT:
-                case ESTALE:
-                        missing++;
-                        continue;
-                case ENOTCONN:
-                        down++;
-                        continue;
-                case ENOSPC:
-                        no_space++;
-                        continue;
-                case 0:
-                        /* if err == 0 and start == stop, then it is a non misc++;
-                         * participating subvolume(spread-cnt). Then, do not
-                         * check for anomalies. If start != stop, then treat it
-                         * as misc err */
-                        if (layout->list[i].start == layout->list[i].stop) {
-                                continue;
-                        }
-                        break;
-                default:
-                        misc++;
-                        continue;
-                 }
-
-                is_virgin = 0;
-
-                if ((prev_stop + 1) < layout->list[i].start) {
-                        hole_cnt++;
+    uint32_t overlaps = 0;
+    uint32_t missing = 0;
+    uint32_t down = 0;
+    uint32_t misc = 0;
+    uint32_t hole_cnt = 0;
+    uint32_t overlap_cnt = 0;
+    int i = 0;
+    int ret = 0;
+    uint32_t prev_stop = 0;
+    uint32_t last_stop = 0;
+    char is_virgin = 1;
+    uint32_t no_space = 0;
+
+    /* This function scans through the layout spread of a directory to
+       check if there are any anomalies. Prior to calling this function
+       the layout entries should be sorted in the ascending order.
+
+       If the layout entry has err != 0
+            then increment the corresponding anomaly.
+       else
+            if (start of the current layout entry > stop + 1 of previous
+               non erroneous layout entry)
+                    then it indicates a hole in the layout
+            if (start of the current layout entry < stop + 1 of previous
+                non erroneous layout entry)
+                     then it indicates an overlap in the layout
+    */
+    last_stop = layout->list[0].start - 1;
+    prev_stop = last_stop;
+
+    for (i = 0; i < layout->cnt; i++) {
+        switch (layout->list[i].err) {
+            case -1:
+            case ENOENT:
+            case ESTALE:
+                missing++;
+                continue;
+            case ENOTCONN:
+                down++;
+                continue;
+            case ENOSPC:
+                no_space++;
+                continue;
+            case 0:
+                /* if err == 0 and start == stop, then it is a non misc++;
+                 * participating subvolume(spread-cnt). Then, do not
+                 * check for anomalies. If start != stop, then treat it
+                 * as misc err */
+                if (layout->list[i].start == layout->list[i].stop) {
+                    continue;
                 }
+                break;
+            default:
+                misc++;
+                continue;
+        }
 
-                if ((prev_stop + 1) > layout->list[i].start) {
-                        overlap_cnt++;
-                        overlaps += ((prev_stop + 1) - layout->list[i].start);
-                }
-                prev_stop = layout->list[i].stop;
+        is_virgin = 0;
+
+        if ((prev_stop + 1) < layout->list[i].start) {
+            hole_cnt++;
         }
 
-        if ((last_stop - prev_stop) || is_virgin)
-                hole_cnt++;
+        if ((prev_stop + 1) > layout->list[i].start) {
+            overlap_cnt++;
+            overlaps += ((prev_stop + 1) - layout->list[i].start);
+        }
+        prev_stop = layout->list[i].stop;
+    }
 
-        if (holes_p)
-                *holes_p = hole_cnt;
+    if ((last_stop - prev_stop) || is_virgin)
+        hole_cnt++;
 
-        if (overlaps_p)
-                *overlaps_p = overlap_cnt;
+    if (holes_p)
+        *holes_p = hole_cnt;
 
-        if (missing_p)
-                *missing_p = missing;
+    if (overlaps_p)
+        *overlaps_p = overlap_cnt;
 
-        if (down_p)
-                *down_p = down;
+    if (missing_p)
+        *missing_p = missing;
 
-        if (misc_p)
-                *misc_p = misc;
+    if (down_p)
+        *down_p = down;
 
-        if (no_space_p)
-                *no_space_p = no_space;
+    if (misc_p)
+        *misc_p = misc;
 
-        return ret;
-}
+    if (no_space_p)
+        *no_space_p = no_space;
 
+    return ret;
+}
 
 int
-dht_layout_missing_dirs (dht_layout_t *layout)
+dht_layout_missing_dirs(dht_layout_t *layout)
 {
-        int i = 0, missing = 0;
+    int i = 0, missing = 0;
 
-        if (layout == NULL)
-                goto out;
+    if (layout == NULL)
+        goto out;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if ((layout->list[i].err == ENOENT)
-                    || ((layout->list[i].err == -1)
-                        && (layout->list[i].start == 0)
-                        && (layout->list[i].stop == 0))) {
-                        missing++;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if ((layout->list[i].err == ENOENT) ||
+            ((layout->list[i].err == -1) && (layout->list[i].start == 0) &&
+             (layout->list[i].stop == 0))) {
+            missing++;
         }
+    }
 
 out:
-        return missing;
+    return missing;
 }
 
-
 int
-dht_layout_normalize (xlator_t *this, loc_t *loc, dht_layout_t *layout)
+dht_layout_normalize(xlator_t *this, loc_t *loc, dht_layout_t *layout)
 {
-        int          ret   = 0;
-        uint32_t     holes = 0;
-        uint32_t     overlaps = 0;
-        uint32_t     missing = 0;
-        uint32_t     down = 0;
-        uint32_t     misc = 0, missing_dirs = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        ret = dht_layout_sort (layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_SORT_FAILED,
-                        "sort failed?! how the ....");
-                goto out;
-        }
-
-        gf_uuid_unparse(loc->gfid, gfid);
-
-        ret = dht_layout_anomalies (this, loc, layout,
-                                    &holes, &overlaps,
-                                    &missing, &down, &misc, NULL);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_FIND_LAYOUT_ANOMALIES_ERROR,
-                        "Error finding anomalies in %s, gfid = %s",
-                        loc->path, gfid);
-                goto out;
-        }
-
-        if (holes || overlaps) {
-                if (missing == layout->cnt) {
-                        gf_msg_debug (this->name, 0,
-                                      "Directory %s looked up first time"
-                                      " gfid = %s", loc->path, gfid);
-                } else {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_ANOMALIES_INFO,
-                                "Found anomalies in %s (gfid = %s). "
-                                "Holes=%d overlaps=%d",
-                                loc->path, gfid, holes, overlaps );
-                }
-                ret = -1;
-        }
-
-        if (ret >= 0) {
-                missing_dirs = dht_layout_missing_dirs (layout);
-                /* TODO During DHT selfheal rewrite (almost) find a better place
-                 * to detect this - probably in dht_layout_anomalies()
-                 */
-                if (missing_dirs > 0)
-                        ret += missing_dirs;
-        }
+    int ret = 0;
+    uint32_t holes = 0;
+    uint32_t overlaps = 0;
+    uint32_t missing = 0;
+    uint32_t down = 0;
+    uint32_t misc = 0, missing_dirs = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    ret = dht_layout_sort(layout);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_SORT_FAILED,
+               "sort failed?! how the ....");
+        goto out;
+    }
+
+    gf_uuid_unparse(loc->gfid, gfid);
+
+    ret = dht_layout_anomalies(this, loc, layout, &holes, &overlaps, &missing,
+                               &down, &misc, NULL);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, 0,
+               DHT_MSG_FIND_LAYOUT_ANOMALIES_ERROR,
+               "Error finding anomalies in %s, gfid = %s", loc->path, gfid);
+        goto out;
+    }
+
+    if (holes || overlaps) {
+        if (missing == layout->cnt) {
+            gf_msg_debug(this->name, 0,
+                         "Directory %s looked up first time"
+                         " gfid = %s",
+                         loc->path, gfid);
+        } else {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_ANOMALIES_INFO,
+                   "Found anomalies in %s (gfid = %s). "
+                   "Holes=%d overlaps=%d",
+                   loc->path, gfid, holes, overlaps);
+        }
+        ret = -1;
+    }
+
+    if (ret >= 0) {
+        missing_dirs = dht_layout_missing_dirs(layout);
+        /* TODO During DHT selfheal rewrite (almost) find a better place
+         * to detect this - probably in dht_layout_anomalies()
+         */
+        if (missing_dirs > 0)
+            ret += missing_dirs;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_dir_has_layout (dict_t *xattr, char *name)
+dht_dir_has_layout(dict_t *xattr, char *name)
 {
+    void *disk_layout_raw = NULL;
 
-        void     *disk_layout_raw = NULL;
-
-        return dict_get_ptr (xattr, name, &disk_layout_raw);
+    return dict_get_ptr(xattr, name, &disk_layout_raw);
 }
 
 int
-dht_layout_dir_mismatch (xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
-                         loc_t *loc, dict_t *xattr)
+dht_layout_dir_mismatch(xlator_t *this, dht_layout_t *layout, xlator_t *subvol,
+                        loc_t *loc, dict_t *xattr)
 {
-        int         idx = 0;
-        int         pos = -1;
-        int         ret = 0;
-        int         err = 0;
-        int         dict_ret = 0;
-        int32_t     disk_layout[4];
-        void       *disk_layout_raw = NULL;
-        uint32_t    start_off = -1;
-        uint32_t    stop_off = -1;
-        uint32_t    commit_hash = -1;
-        dht_conf_t *conf = this->private;
-        char        gfid[GF_UUID_BUF_SIZE] = {0};
-
-        if(loc && loc->inode)
-                gf_uuid_unparse(loc->inode->gfid, gfid);
-
-        for (idx = 0; idx < layout->cnt; idx++) {
-                if (layout->list[idx].xlator == subvol) {
-                        pos = idx;
-                        break;
-                }
-        }
-
-        if (pos == -1) {
-                if (loc) {
-                        gf_msg_debug (this->name, 0,
-                                      "%s - no layout info for subvolume %s",
-                                      loc ? loc->path : "path not found",
-                                      subvol->name);
-                }
-                ret = 1;
-                goto out;
-        }
-
-        err = layout->list[pos].err;
-
-        if (!xattr) {
-                if (err == 0) {
-                        if (loc) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DICT_GET_FAILED,
-                                        "%s: xattr dictionary is NULL",
-                                        loc->path);
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DICT_GET_FAILED,
-                                        "path not found: "
-                                        "xattr dictionary is NULL");
-                        }
-                        ret = -1;
-                }
-                goto out;
-        }
-
-        dict_ret = dict_get_ptr (xattr, conf->xattr_name,
-                                 &disk_layout_raw);
-
-        if (dict_ret < 0) {
-                if (err == 0 && layout->list[pos].stop) {
-                        if (loc) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DISK_LAYOUT_MISSING,
-                                    "%s: Disk layout missing, gfid = %s",
-                                    loc->path, gfid);
-                        } else {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DISK_LAYOUT_MISSING,
-                                        "path not found: "
-                                        "Disk layout missing, gfid = %s",
-                                        gfid);
-                        }
-                        ret = -1;
-                }
-                goto out;
-        }
-
-        memcpy (disk_layout, disk_layout_raw, sizeof (disk_layout));
-
-        start_off = ntoh32 (disk_layout[2]);
-        stop_off  = ntoh32 (disk_layout[3]);
-        commit_hash = ntoh32 (disk_layout[0]);
-
-        if ((layout->list[pos].start != start_off)
-            || (layout->list[pos].stop != stop_off)
-            || (layout->list[pos].commit_hash != commit_hash)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LAYOUT_INFO,
-                        "subvol: %s; inode layout - %"PRIu32" - %"PRIu32
-                        " - %"PRIu32"; "
-                        "disk layout - %"PRIu32" - %"PRIu32" - %"PRIu32,
-                        layout->list[pos].xlator->name,
-                        layout->list[pos].start, layout->list[pos].stop,
-                        layout->list[pos].commit_hash,
-                        start_off, stop_off, commit_hash);
-                ret = 1;
-        } else {
-                ret = 0;
-        }
+    int idx = 0;
+    int pos = -1;
+    int ret = 0;
+    int err = 0;
+    int dict_ret = 0;
+    int32_t disk_layout[4];
+    void *disk_layout_raw = NULL;
+    uint32_t start_off = -1;
+    uint32_t stop_off = -1;
+    uint32_t commit_hash = -1;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    if (loc && loc->inode)
+        gf_uuid_unparse(loc->inode->gfid, gfid);
+
+    for (idx = 0; idx < layout->cnt; idx++) {
+        if (layout->list[idx].xlator == subvol) {
+            pos = idx;
+            break;
+        }
+    }
+
+    if (pos == -1) {
+        if (loc) {
+            gf_msg_debug(this->name, 0, "%s - no layout info for subvolume %s",
+                         loc ? loc->path : "path not found", subvol->name);
+        }
+        ret = 1;
+        goto out;
+    }
+
+    err = layout->list[pos].err;
+
+    if (!xattr) {
+        if (err == 0) {
+            if (loc) {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_DICT_GET_FAILED,
+                       "%s: xattr dictionary is NULL", loc->path);
+            } else {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_DICT_GET_FAILED,
+                       "path not found: "
+                       "xattr dictionary is NULL");
+            }
+            ret = -1;
+        }
+        goto out;
+    }
+
+    dict_ret = dict_get_ptr(xattr, conf->xattr_name, &disk_layout_raw);
+
+    if (dict_ret < 0) {
+        if (err == 0 && layout->list[pos].stop) {
+            if (loc) {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_DISK_LAYOUT_MISSING,
+                       "%s: Disk layout missing, gfid = %s", loc->path, gfid);
+            } else {
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_DISK_LAYOUT_MISSING,
+                       "path not found: "
+                       "Disk layout missing, gfid = %s",
+                       gfid);
+            }
+            ret = -1;
+        }
+        goto out;
+    }
+
+    memcpy(disk_layout, disk_layout_raw, sizeof(disk_layout));
+
+    start_off = ntoh32(disk_layout[2]);
+    stop_off = ntoh32(disk_layout[3]);
+    commit_hash = ntoh32(disk_layout[0]);
+
+    if ((layout->list[pos].start != start_off) ||
+        (layout->list[pos].stop != stop_off) ||
+        (layout->list[pos].commit_hash != commit_hash)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LAYOUT_INFO,
+               "subvol: %s; inode layout - %" PRIu32 " - %" PRIu32 " - %" PRIu32
+               "; "
+               "disk layout - %" PRIu32 " - %" PRIu32 " - %" PRIu32,
+               layout->list[pos].xlator->name, layout->list[pos].start,
+               layout->list[pos].stop, layout->list[pos].commit_hash, start_off,
+               stop_off, commit_hash);
+        ret = 1;
+    } else {
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-dht_layout_preset (xlator_t *this, xlator_t *subvol, inode_t *inode)
+dht_layout_preset(xlator_t *this, xlator_t *subvol, inode_t *inode)
 {
-        dht_layout_t *layout = NULL;
-        int           ret = -1;
-        dht_conf_t   *conf = NULL;
-
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-
-        layout = dht_layout_for_subvol (this, subvol);
-        if (!layout) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_NO_LAYOUT_INFO,
-                        "no pre-set layout for subvolume %s",
-                        subvol ? subvol->name : "<nil>");
-                ret = -1;
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0, "file = %s, subvol = %s",
-                      uuid_utoa (inode->gfid), subvol ? subvol->name : "<nil>");
-
-        LOCK (&conf->layout_lock);
-        {
-                dht_inode_ctx_layout_set (inode, this, layout);
-        }
-
-        UNLOCK (&conf->layout_lock);
-
-        ret = 0;
+    dht_layout_t *layout = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    if (!conf)
+        goto out;
+
+    layout = dht_layout_for_subvol(this, subvol);
+    if (!layout) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_NO_LAYOUT_INFO,
+               "no pre-set layout for subvolume %s",
+               subvol ? subvol->name : "<nil>");
+        ret = -1;
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0, "file = %s, subvol = %s",
+                 uuid_utoa(inode->gfid), subvol ? subvol->name : "<nil>");
+
+    LOCK(&conf->layout_lock);
+    {
+        dht_inode_ctx_layout_set(inode, this, layout);
+    }
+
+    UNLOCK(&conf->layout_lock);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_layout_index_for_subvol (dht_layout_t *layout, xlator_t *subvol)
+dht_layout_index_for_subvol(dht_layout_t *layout, xlator_t *subvol)
 {
-        int i = 0, ret = -1;
+    int i = 0, ret = -1;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol) {
-                        ret = i;
-                        break;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol) {
+            ret = i;
+            break;
         }
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-linkfile.c b/xlators/cluster/dht/src/dht-linkfile.c
index a6d994b4157..eb1695f7e05 100644
--- a/xlators/cluster/dht/src/dht-linkfile.c
+++ b/xlators/cluster/dht/src/dht-linkfile.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "glusterfs.h"
 #include "xlator.h"
 #include "compat.h"
@@ -16,343 +15,325 @@
 #include "dht-messages.h"
 
 int
-dht_linkfile_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno,
-                         inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                         struct iatt *postparent)
+dht_linkfile_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, dict_t *xattr,
+                        struct iatt *postparent)
 {
-        char          is_linkfile   = 0;
-        dht_conf_t   *conf          = NULL;
-        dht_local_t  *local         = NULL;
-        xlator_t     *prev          = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        prev = cookie;
-        conf = this->private;
-
-        if (op_ret)
-                goto out;
-
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
-        if (!is_linkfile)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NOT_LINK_FILE_ERROR,
-                        "got non-linkfile %s:%s, gfid = %s",
-                        prev->name, local->loc.path, gfid);
+    char is_linkfile = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    if (op_ret)
+        goto out;
+
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
+    if (!is_linkfile)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NOT_LINK_FILE_ERROR,
+               "got non-linkfile %s:%s, gfid = %s", prev->name, local->loc.path,
+               gfid);
 out:
-        local->linkfile.linkfile_cbk (frame, cookie, this, op_ret, op_errno,
-                                      inode, stbuf, postparent, postparent,
-                                      xattr);
-        return 0;
+    local->linkfile.linkfile_cbk(frame, cookie, this, op_ret, op_errno, inode,
+                                 stbuf, postparent, postparent, xattr);
+    return 0;
 }
 
 #define is_equal(a, b) ((a) == (b))
 int
-dht_linkfile_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, inode_t *inode,
-                         struct iatt *stbuf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+dht_linkfile_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *subvol = NULL;
-        dict_t       *xattrs = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret = -1;
-
-        local = frame->local;
-
-        if (!op_ret)
-                local->linked = _gf_true;
-
-        FRAME_SU_UNDO (frame, dht_local_t);
-
-        if (op_ret && (op_errno == EEXIST)) {
-                conf = this->private;
-                subvol = cookie;
-                if (!subvol)
-                        goto out;
-                xattrs = dict_new ();
-                if (!xattrs)
-                        goto out;
-                ret = dict_set_uint32 (xattrs, conf->link_xattr_name, 256);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value. key : %s",
-                                conf->link_xattr_name);
-                        goto out;
-                }
-
-                STACK_WIND_COOKIE (frame, dht_linkfile_lookup_cbk, subvol,
-                                   subvol, subvol->fops->lookup, &local->linkfile.loc,
-                                   xattrs);
-                if (xattrs)
-                        dict_unref (xattrs);
-                return 0;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    dict_t *xattrs = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+
+    local = frame->local;
+
+    if (!op_ret)
+        local->linked = _gf_true;
+
+    FRAME_SU_UNDO(frame, dht_local_t);
+
+    if (op_ret && (op_errno == EEXIST)) {
+        conf = this->private;
+        subvol = cookie;
+        if (!subvol)
+            goto out;
+        xattrs = dict_new();
+        if (!xattrs)
+            goto out;
+        ret = dict_set_uint32(xattrs, conf->link_xattr_name, 256);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value. key : %s",
+                   conf->link_xattr_name);
+            goto out;
         }
-out:
-        local->linkfile.linkfile_cbk (frame, cookie, this, op_ret, op_errno,
-                                      inode, stbuf, preparent, postparent,
-                                      xdata);
+
+        STACK_WIND_COOKIE(frame, dht_linkfile_lookup_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->linkfile.loc, xattrs);
         if (xattrs)
-                dict_unref (xattrs);
+            dict_unref(xattrs);
         return 0;
+    }
+out:
+    local->linkfile.linkfile_cbk(frame, cookie, this, op_ret, op_errno, inode,
+                                 stbuf, preparent, postparent, xdata);
+    if (xattrs)
+        dict_unref(xattrs);
+    return 0;
 }
 
-
 int
-dht_linkfile_create (call_frame_t *frame, fop_mknod_cbk_t linkfile_cbk,
-                     xlator_t *this,
-                     xlator_t *tovol, xlator_t *fromvol, loc_t *loc)
+dht_linkfile_create(call_frame_t *frame, fop_mknod_cbk_t linkfile_cbk,
+                    xlator_t *this, xlator_t *tovol, xlator_t *fromvol,
+                    loc_t *loc)
 {
-        dht_local_t *local = NULL;
-        dict_t      *dict = NULL;
-        int          need_unref = 0;
-        int          ret = 0;
-        dht_conf_t  *conf = this->private;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        local->linkfile.linkfile_cbk = linkfile_cbk;
-        local->linkfile.srcvol = tovol;
-        loc_copy (&local->linkfile.loc, loc);
-
-        local->linked = _gf_false;
-
-        dict = local->params;
-        if (!dict) {
-                dict = dict_new ();
-                if (!dict)
-                        goto out;
-                need_unref = 1;
-        }
-
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                gf_uuid_unparse(local->gfid, gfid);
-
-                ret = dict_set_gfuuid (dict, "gfid-req", local->gfid, true);
-                if (ret)
-                        gf_msg ("dht-linkfile", GF_LOG_INFO, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value: "
-                                "key = gfid-req, gfid = %s ", loc->path, gfid);
-        } else {
-                gf_uuid_unparse(loc->gfid, gfid);
-        }
-
-        ret = dict_set_str (dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    dht_local_t *local = NULL;
+    dict_t *dict = NULL;
+    int need_unref = 0;
+    int ret = 0;
+    dht_conf_t *conf = this->private;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    local->linkfile.linkfile_cbk = linkfile_cbk;
+    local->linkfile.srcvol = tovol;
+    loc_copy(&local->linkfile.loc, loc);
+
+    local->linked = _gf_false;
+
+    dict = local->params;
+    if (!dict) {
+        dict = dict_new();
+        if (!dict)
+            goto out;
+        need_unref = 1;
+    }
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        gf_uuid_unparse(local->gfid, gfid);
+
+        ret = dict_set_gfuuid(dict, "gfid-req", local->gfid, true);
         if (ret)
-                gf_msg ("dht-linkfile", GF_LOG_INFO, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        GLUSTERFS_INTERNAL_FOP_KEY, gfid);
-
-        ret = dict_set_str (dict, conf->link_xattr_name, tovol->name);
-
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_CREATE_LINK_FAILED,
-                        "%s: failed to initialize linkfile data, gfid = %s",
-                        loc->path, gfid);
-                goto out;
-        }
-
-        local->link_subvol = fromvol;
-        /* Always create as root:root. dht_linkfile_attr_heal fixes the
-         * ownsership */
-        FRAME_SU_DO (frame, dht_local_t);
-        STACK_WIND_COOKIE (frame, dht_linkfile_create_cbk, fromvol, fromvol,
-                           fromvol->fops->mknod, loc,
-                           S_IFREG | DHT_LINKFILE_MODE, 0, 0, dict);
-
-        if (need_unref && dict)
-                dict_unref (dict);
-
-        return 0;
+            gf_msg("dht-linkfile", GF_LOG_INFO, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: Failed to set dictionary value: "
+                   "key = gfid-req, gfid = %s ",
+                   loc->path, gfid);
+    } else {
+        gf_uuid_unparse(loc->gfid, gfid);
+    }
+
+    ret = dict_set_str(dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    if (ret)
+        gf_msg("dht-linkfile", GF_LOG_INFO, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: Failed to set dictionary value: key = %s,"
+               " gfid = %s",
+               loc->path, GLUSTERFS_INTERNAL_FOP_KEY, gfid);
+
+    ret = dict_set_str(dict, conf->link_xattr_name, tovol->name);
+
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_INFO, 0, DHT_MSG_CREATE_LINK_FAILED,
+               "%s: failed to initialize linkfile data, gfid = %s", loc->path,
+               gfid);
+        goto out;
+    }
+
+    local->link_subvol = fromvol;
+    /* Always create as root:root. dht_linkfile_attr_heal fixes the
+     * ownsership */
+    FRAME_SU_DO(frame, dht_local_t);
+    STACK_WIND_COOKIE(frame, dht_linkfile_create_cbk, fromvol, fromvol,
+                      fromvol->fops->mknod, loc, S_IFREG | DHT_LINKFILE_MODE, 0,
+                      0, dict);
+
+    if (need_unref && dict)
+        dict_unref(dict);
+
+    return 0;
 out:
-        local->linkfile.linkfile_cbk (frame, frame->this, frame->this, -1, ENOMEM,
-                                      loc->inode, NULL, NULL, NULL, NULL);
+    local->linkfile.linkfile_cbk(frame, frame->this, frame->this, -1, ENOMEM,
+                                 loc->inode, NULL, NULL, NULL, NULL);
 
-        if (need_unref && dict)
-                dict_unref (dict);
+    if (need_unref && dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_linkfile_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno,
-                         struct iatt *preparent, struct iatt *postparent,
-                         dict_t *xdata)
+dht_linkfile_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        struct iatt *preparent, struct iatt *postparent,
+                        dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        xlator_t      *subvol = NULL;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        subvol = cookie;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
+    local = frame->local;
+    subvol = cookie;
 
-        if (op_ret == -1) {
-
-                gf_uuid_unparse(local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_UNLINK_FAILED,
-                        "Unlinking linkfile %s (gfid = %s)on "
-                        "subvolume %s failed ",
-                        local->loc.path, gfid, subvol->name);
-        }
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_UNLINK_FAILED,
+               "Unlinking linkfile %s (gfid = %s)on "
+               "subvolume %s failed ",
+               local->loc.path, gfid, subvol->name);
+    }
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_linkfile_unlink (call_frame_t *frame, xlator_t *this,
-                     xlator_t *subvol, loc_t *loc)
+dht_linkfile_unlink(call_frame_t *frame, xlator_t *this, xlator_t *subvol,
+                    loc_t *loc)
 {
-        call_frame_t *unlink_frame = NULL;
-        dht_local_t  *unlink_local = NULL;
+    call_frame_t *unlink_frame = NULL;
+    dht_local_t *unlink_local = NULL;
 
-        unlink_frame = copy_frame (frame);
-        if (!unlink_frame) {
-                goto err;
-        }
+    unlink_frame = copy_frame(frame);
+    if (!unlink_frame) {
+        goto err;
+    }
 
-        /* Using non-fop value here, as anyways, 'local->fop' is not used in
-           this particular case */
-        unlink_local = dht_local_init (unlink_frame, loc, NULL,
-                                       GF_FOP_MAXVALUE);
-        if (!unlink_local) {
-                goto err;
-        }
+    /* Using non-fop value here, as anyways, 'local->fop' is not used in
+       this particular case */
+    unlink_local = dht_local_init(unlink_frame, loc, NULL, GF_FOP_MAXVALUE);
+    if (!unlink_local) {
+        goto err;
+    }
 
-        STACK_WIND_COOKIE (unlink_frame, dht_linkfile_unlink_cbk, subvol,
-                           subvol, subvol->fops->unlink,
-                           &unlink_local->loc, 0, NULL);
+    STACK_WIND_COOKIE(unlink_frame, dht_linkfile_unlink_cbk, subvol, subvol,
+                      subvol->fops->unlink, &unlink_local->loc, 0, NULL);
 
-        return 0;
+    return 0;
 err:
-        if (unlink_frame)
-                DHT_STACK_DESTROY (unlink_frame);
+    if (unlink_frame)
+        DHT_STACK_DESTROY(unlink_frame);
 
-        return -1;
+    return -1;
 }
 
-
 xlator_t *
-dht_linkfile_subvol (xlator_t *this, inode_t *inode, struct iatt *stbuf,
-                     dict_t *xattr)
+dht_linkfile_subvol(xlator_t *this, inode_t *inode, struct iatt *stbuf,
+                    dict_t *xattr)
 {
-        dht_conf_t *conf = NULL;
-        xlator_t   *subvol = NULL;
-        void       *volname = NULL;
-        int         i = 0, ret = 0;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    void *volname = NULL;
+    int i = 0, ret = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!xattr)
-                goto out;
+    if (!xattr)
+        goto out;
 
-        ret = dict_get_ptr (xattr, conf->link_xattr_name, &volname);
+    ret = dict_get_ptr(xattr, conf->link_xattr_name, &volname);
 
-        if ((-1 == ret) || !volname)
-                goto out;
+    if ((-1 == ret) || !volname)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (strcmp (conf->subvolumes[i]->name, (char *)volname) == 0) {
-                        subvol = conf->subvolumes[i];
-                        break;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (strcmp(conf->subvolumes[i]->name, (char *)volname) == 0) {
+            subvol = conf->subvolumes[i];
+            break;
         }
+    }
 
 out:
-        return subvol;
+    return subvol;
 }
 
 int
-dht_linkfile_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int op_ret, int op_errno, struct iatt *statpre,
-                          struct iatt *statpost, dict_t *xdata)
+dht_linkfile_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int op_ret, int op_errno, struct iatt *statpre,
+                         struct iatt *statpost, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        loc_t *loc = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
 
-        local = frame->local;
-        loc = &local->loc;
+    local = frame->local;
+    loc = &local->loc;
 
-        if (op_ret)
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_SETATTR_FAILED,
-                        "Failed to set attr uid/gid on %s"
-                        " :<gfid:%s> ",
-                        (loc->path? loc->path: "NULL"),
-                        uuid_utoa(local->gfid));
+    if (op_ret)
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_SETATTR_FAILED,
+               "Failed to set attr uid/gid on %s"
+               " :<gfid:%s> ",
+               (loc->path ? loc->path : "NULL"), uuid_utoa(local->gfid));
 
-        DHT_STACK_DESTROY (frame);
+    DHT_STACK_DESTROY(frame);
 
-       return 0;
+    return 0;
 }
 
 int
-dht_linkfile_attr_heal (call_frame_t *frame, xlator_t *this)
+dht_linkfile_attr_heal(call_frame_t *frame, xlator_t *this)
 {
-        int           ret         = -1;
-        call_frame_t  *copy       = NULL;
-        dht_local_t   *local      = NULL;
-        dht_local_t   *copy_local = NULL;
-        xlator_t      *subvol     = NULL;
-        struct iatt   stbuf       = {0,};
-        dict_t        *xattr      = NULL;
-
-        local = frame->local;
-
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        GF_VALIDATE_OR_GOTO ("dht", local->link_subvol, out);
-
-        if (local->stbuf.ia_type == IA_INVAL)
-                return 0;
+    int ret = -1;
+    call_frame_t *copy = NULL;
+    dht_local_t *local = NULL;
+    dht_local_t *copy_local = NULL;
+    xlator_t *subvol = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    local = frame->local;
+
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    GF_VALIDATE_OR_GOTO("dht", local->link_subvol, out);
+
+    if (local->stbuf.ia_type == IA_INVAL)
+        return 0;
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    DHT_MARK_FOP_INTERNAL(xattr);
 
-        gf_uuid_copy (local->loc.gfid, local->stbuf.ia_gfid);
+    gf_uuid_copy(local->loc.gfid, local->stbuf.ia_gfid);
 
-        copy = copy_frame (frame);
+    copy = copy_frame(frame);
 
-        if (!copy)
-                goto out;
+    if (!copy)
+        goto out;
 
-       copy_local = dht_local_init (copy, &local->loc, NULL, 0);
+    copy_local = dht_local_init(copy, &local->loc, NULL, 0);
 
-       if (!copy_local)
-               goto out;
+    if (!copy_local)
+        goto out;
 
-        stbuf = local->stbuf;
-        subvol = local->link_subvol;
+    stbuf = local->stbuf;
+    subvol = local->link_subvol;
 
-        copy->local = copy_local;
+    copy->local = copy_local;
 
-        FRAME_SU_DO (copy, dht_local_t);
+    FRAME_SU_DO(copy, dht_local_t);
 
-        STACK_WIND (copy, dht_linkfile_setattr_cbk, subvol,
-                    subvol->fops->setattr, &copy_local->loc,
-                    &stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID), xattr);
-        ret = 0;
+    STACK_WIND(copy, dht_linkfile_setattr_cbk, subvol, subvol->fops->setattr,
+               &copy_local->loc, &stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
+               xattr);
+    ret = 0;
 out:
-        if ((ret < 0) && (copy))
-                DHT_STACK_DESTROY (copy);
+    if ((ret < 0) && (copy))
+        DHT_STACK_DESTROY(copy);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-lock.c b/xlators/cluster/dht/src/dht-lock.c
index 3f389eafa75..f9bac4f97c8 100644
--- a/xlators/cluster/dht/src/dht-lock.c
+++ b/xlators/cluster/dht/src/dht-lock.c
@@ -11,1252 +11,1265 @@
 #include "dht-lock.h"
 
 static char *
-dht_lock_asprintf (dht_lock_t *lock)
+dht_lock_asprintf(dht_lock_t *lock)
 {
-        char *lk_buf                = NULL;
-        char gfid[GF_UUID_BUF_SIZE] = {0, };
+    char *lk_buf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
 
-        if (lock == NULL)
-                goto out;
+    if (lock == NULL)
+        goto out;
 
-        uuid_utoa_r (lock->loc.gfid, gfid);
+    uuid_utoa_r(lock->loc.gfid, gfid);
 
-        gf_asprintf (&lk_buf, "%s:%s", lock->xl->name, gfid);
+    gf_asprintf(&lk_buf, "%s:%s", lock->xl->name, gfid);
 
 out:
-        return lk_buf;
+    return lk_buf;
 }
 
 static void
-dht_log_lk_array (char *name, gf_loglevel_t log_level, dht_lock_t **lk_array,
-                  int count)
+dht_log_lk_array(char *name, gf_loglevel_t log_level, dht_lock_t **lk_array,
+                 int count)
 {
-        int   i      = 0;
-        char *lk_buf = NULL;
+    int i = 0;
+    char *lk_buf = NULL;
 
-        if ((lk_array == NULL) || (count == 0))
-                goto out;
+    if ((lk_array == NULL) || (count == 0))
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lk_buf = dht_lock_asprintf (lk_array[i]);
-                if (!lk_buf)
-                        goto out;
+    for (i = 0; i < count; i++) {
+        lk_buf = dht_lock_asprintf(lk_array[i]);
+        if (!lk_buf)
+            goto out;
 
-                gf_msg (name, log_level, 0, DHT_MSG_LK_ARRAY_INFO,
-                        "%d. %s", i, lk_buf);
-                GF_FREE (lk_buf);
-        }
+        gf_msg(name, log_level, 0, DHT_MSG_LK_ARRAY_INFO, "%d. %s", i, lk_buf);
+        GF_FREE(lk_buf);
+    }
 
 out:
-        return;
+    return;
 }
 
 static void
-dht_lock_stack_destroy (call_frame_t *lock_frame, dht_lock_type_t lk)
+dht_lock_stack_destroy(call_frame_t *lock_frame, dht_lock_type_t lk)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        if (lk == DHT_INODELK) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-        } else {
-                local->lock[0].ns.directory_ns.locks = NULL;
-                local->lock[0].ns.directory_ns.lk_count = 0;
-        }
+    if (lk == DHT_INODELK) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+    } else {
+        local->lock[0].ns.directory_ns.locks = NULL;
+        local->lock[0].ns.directory_ns.lk_count = 0;
+    }
 
-        DHT_STACK_DESTROY (lock_frame);
-        return;
+    DHT_STACK_DESTROY(lock_frame);
+    return;
 }
 
 static void
-dht_lock_free (dht_lock_t *lock)
+dht_lock_free(dht_lock_t *lock)
 {
-        if (lock == NULL)
-                goto out;
+    if (lock == NULL)
+        goto out;
 
-        loc_wipe (&lock->loc);
-        GF_FREE (lock->domain);
-        GF_FREE (lock->basename);
-        mem_put (lock);
+    loc_wipe(&lock->loc);
+    GF_FREE(lock->domain);
+    GF_FREE(lock->basename);
+    mem_put(lock);
 
 out:
-        return;
+    return;
 }
 
 static void
-dht_set_lkowner (dht_lock_t **lk_array, int count, gf_lkowner_t *lkowner)
+dht_set_lkowner(dht_lock_t **lk_array, int count, gf_lkowner_t *lkowner)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!lk_array || !lkowner)
-                goto out;
+    if (!lk_array || !lkowner)
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lk_array[i]->lk_owner = *lkowner;
-        }
+    for (i = 0; i < count; i++) {
+        lk_array[i]->lk_owner = *lkowner;
+    }
 
 out:
-        return;
+    return;
 }
 
 static int
-dht_lock_request_cmp (const void *val1, const void *val2)
+dht_lock_request_cmp(const void *val1, const void *val2)
 {
-        dht_lock_t *lock1 = NULL;
-        dht_lock_t *lock2 = NULL;
-        int         ret   = -1;
+    dht_lock_t *lock1 = NULL;
+    dht_lock_t *lock2 = NULL;
+    int ret = -1;
 
-        lock1 = *(dht_lock_t **)val1;
-        lock2 = *(dht_lock_t **)val2;
+    lock1 = *(dht_lock_t **)val1;
+    lock2 = *(dht_lock_t **)val2;
 
-        GF_VALIDATE_OR_GOTO ("dht-locks", lock1, out);
-        GF_VALIDATE_OR_GOTO ("dht-locks", lock2, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", lock1, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", lock2, out);
 
-        ret = strcmp (lock1->xl->name, lock2->xl->name);
+    ret = strcmp(lock1->xl->name, lock2->xl->name);
 
-        if (ret == 0) {
-                ret = gf_uuid_compare (lock1->loc.gfid, lock2->loc.gfid);
-        }
+    if (ret == 0) {
+        ret = gf_uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-dht_lock_order_requests (dht_lock_t **locks, int count)
+dht_lock_order_requests(dht_lock_t **locks, int count)
 {
-        int        ret     = -1;
+    int ret = -1;
 
-        if (!locks || !count)
-                goto out;
+    if (!locks || !count)
+        goto out;
 
-        qsort (locks, count, sizeof (*locks), dht_lock_request_cmp);
-        ret = 0;
+    qsort(locks, count, sizeof(*locks), dht_lock_request_cmp);
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-dht_lock_array_free (dht_lock_t **lk_array, int count)
+dht_lock_array_free(dht_lock_t **lk_array, int count)
 {
-        int            i       = 0;
-        dht_lock_t    *lock    = NULL;
+    int i = 0;
+    dht_lock_t *lock = NULL;
 
-        if (lk_array == NULL)
-                goto out;
+    if (lk_array == NULL)
+        goto out;
 
-        for (i = 0; i < count; i++) {
-                lock = lk_array[i];
-                lk_array[i] = NULL;
-                dht_lock_free (lock);
-        }
+    for (i = 0; i < count; i++) {
+        lock = lk_array[i];
+        lk_array[i] = NULL;
+        dht_lock_free(lock);
+    }
 
 out:
-        return;
+    return;
 }
 
 int32_t
-dht_lock_count (dht_lock_t **lk_array, int lk_count)
+dht_lock_count(dht_lock_t **lk_array, int lk_count)
 {
-        int i = 0, locked = 0;
+    int i = 0, locked = 0;
 
-        if ((lk_array == NULL) || (lk_count == 0))
-                goto out;
+    if ((lk_array == NULL) || (lk_count == 0))
+        goto out;
 
-        for (i = 0; i < lk_count; i++) {
-                if (lk_array[i]->locked)
-                        locked++;
-        }
+    for (i = 0; i < lk_count; i++) {
+        if (lk_array[i]->locked)
+            locked++;
+    }
 out:
-        return locked;
+    return locked;
 }
 
 static call_frame_t *
-dht_lock_frame (call_frame_t *parent_frame)
+dht_lock_frame(call_frame_t *parent_frame)
 {
-        call_frame_t *lock_frame = NULL;
+    call_frame_t *lock_frame = NULL;
 
-        lock_frame = copy_frame (parent_frame);
-        if (lock_frame == NULL)
-                goto out;
+    lock_frame = copy_frame(parent_frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        set_lk_owner_from_ptr (&lock_frame->root->lk_owner, parent_frame->root);
+    set_lk_owner_from_ptr(&lock_frame->root->lk_owner, parent_frame->root);
 
 out:
-        return lock_frame;
+    return lock_frame;
 }
 
 dht_lock_t *
-dht_lock_new (xlator_t *this, xlator_t *xl, loc_t *loc, short type,
-              const char *domain, const char *basename,
-              dht_reaction_type_t do_on_failure)
+dht_lock_new(xlator_t *this, xlator_t *xl, loc_t *loc, short type,
+             const char *domain, const char *basename,
+             dht_reaction_type_t do_on_failure)
 {
-        dht_conf_t *conf = NULL;
-        dht_lock_t *lock = NULL;
-
-        conf = this->private;
-
-        lock = mem_get0 (conf->lock_pool);
-        if (lock == NULL)
-                goto out;
-
-        lock->xl = xl;
-        lock->type = type;
-        lock->do_on_failure = do_on_failure;
-
-        lock->domain = gf_strdup (domain);
-        if (lock->domain == NULL) {
-                dht_lock_free (lock);
-                lock = NULL;
-                goto out;
+    dht_conf_t *conf = NULL;
+    dht_lock_t *lock = NULL;
+
+    conf = this->private;
+
+    lock = mem_get0(conf->lock_pool);
+    if (lock == NULL)
+        goto out;
+
+    lock->xl = xl;
+    lock->type = type;
+    lock->do_on_failure = do_on_failure;
+
+    lock->domain = gf_strdup(domain);
+    if (lock->domain == NULL) {
+        dht_lock_free(lock);
+        lock = NULL;
+        goto out;
+    }
+
+    if (basename) {
+        lock->basename = gf_strdup(basename);
+        if (lock->basename == NULL) {
+            dht_lock_free(lock);
+            lock = NULL;
+            goto out;
         }
-
-        if (basename) {
-                lock->basename = gf_strdup (basename);
-                if (lock->basename == NULL) {
-                        dht_lock_free (lock);
-                        lock = NULL;
-                        goto out;
-                }
-        }
-
-        /* Fill only inode and gfid.
-           posix and protocol/server give preference to pargfid/basename over
-           gfid/inode for resolution if all the three parameters of loc_t are
-           present. I want to avoid the following hypothetical situation:
-
-           1. rebalance did a lookup on a dentry and got a gfid.
-           2. rebalance acquires lock on loc_t which was filled with gfid and
-              path (pargfid/bname) from step 1.
-           3. somebody deleted and recreated the same file
-           4. rename on the same path acquires lock on loc_t which now points
-              to a different inode (and hence gets the lock).
-           5. rebalance continues to migrate file (note that not all fops done
-              by rebalance during migration are inode/gfid based Eg., unlink)
-           6. rename continues.
-        */
-        lock->loc.inode = inode_ref (loc->inode);
-        loc_gfid (loc, lock->loc.gfid);
+    }
+
+    /* Fill only inode and gfid.
+       posix and protocol/server give preference to pargfid/basename over
+       gfid/inode for resolution if all the three parameters of loc_t are
+       present. I want to avoid the following hypothetical situation:
+
+       1. rebalance did a lookup on a dentry and got a gfid.
+       2. rebalance acquires lock on loc_t which was filled with gfid and
+          path (pargfid/bname) from step 1.
+       3. somebody deleted and recreated the same file
+       4. rename on the same path acquires lock on loc_t which now points
+          to a different inode (and hence gets the lock).
+       5. rebalance continues to migrate file (note that not all fops done
+          by rebalance during migration are inode/gfid based Eg., unlink)
+       6. rename continues.
+    */
+    lock->loc.inode = inode_ref(loc->inode);
+    loc_gfid(loc, lock->loc.gfid);
 
 out:
-        return lock;
+    return lock;
 }
 
 static int
-dht_local_entrylk_init (call_frame_t *frame, dht_lock_t **lk_array,
-                     int lk_count, fop_entrylk_cbk_t entrylk_cbk)
+dht_local_entrylk_init(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                       fop_entrylk_cbk_t entrylk_cbk)
 {
-        int          ret   = -1;
-        dht_local_t *local = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local == NULL) {
-                local = dht_local_init (frame, NULL, NULL, 0);
-        }
+    if (local == NULL) {
+        local = dht_local_init(frame, NULL, NULL, 0);
+    }
 
-        if (local == NULL) {
-                goto out;
-        }
+    if (local == NULL) {
+        goto out;
+    }
 
-        local->lock[0].ns.directory_ns.entrylk_cbk = entrylk_cbk;
-        local->lock[0].ns.directory_ns.locks = lk_array;
-        local->lock[0].ns.directory_ns.lk_count = lk_count;
+    local->lock[0].ns.directory_ns.entrylk_cbk = entrylk_cbk;
+    local->lock[0].ns.directory_ns.locks = lk_array;
+    local->lock[0].ns.directory_ns.lk_count = lk_count;
 
-        ret = dht_lock_order_requests (local->lock[0].ns.directory_ns.locks,
-                                       local->lock[0].ns.directory_ns.lk_count);
-        if (ret < 0)
-                goto out;
+    ret = dht_lock_order_requests(local->lock[0].ns.directory_ns.locks,
+                                  local->lock[0].ns.directory_ns.lk_count);
+    if (ret < 0)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-dht_entrylk_done (call_frame_t *lock_frame)
+dht_entrylk_done(call_frame_t *lock_frame)
 {
-        fop_entrylk_cbk_t  entrylk_cbk = NULL;
-        call_frame_t      *main_frame  = NULL;
-        dht_local_t       *local       = NULL;
+    fop_entrylk_cbk_t entrylk_cbk = NULL;
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
-        main_frame = local->main_frame;
+    local = lock_frame->local;
+    main_frame = local->main_frame;
 
-        local->lock[0].ns.directory_ns.locks = NULL;
-        local->lock[0].ns.directory_ns.lk_count = 0;
+    local->lock[0].ns.directory_ns.locks = NULL;
+    local->lock[0].ns.directory_ns.lk_count = 0;
 
-        entrylk_cbk = local->lock[0].ns.directory_ns.entrylk_cbk;
-        local->lock[0].ns.directory_ns.entrylk_cbk = NULL;
+    entrylk_cbk = local->lock[0].ns.directory_ns.entrylk_cbk;
+    local->lock[0].ns.directory_ns.entrylk_cbk = NULL;
 
-        entrylk_cbk (main_frame, NULL, main_frame->this,
-                     local->lock[0].ns.directory_ns.op_ret,
-                     local->lock[0].ns.directory_ns.op_errno, NULL);
+    entrylk_cbk(main_frame, NULL, main_frame->this,
+                local->lock[0].ns.directory_ns.op_ret,
+                local->lock[0].ns.directory_ns.op_errno, NULL);
 
-        dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
-        return;
+    dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
+    return;
 }
 
 static int32_t
-dht_unlock_entrylk_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_entrylk_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        gf_uuid_unparse (local->lock[0].ns.directory_ns.locks[0]->loc.inode->gfid, gfid);
-
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "unlock failed on gfid: %s, stale lock might be left "
-                        "in DHT_LAYOUT_HEAL_DOMAIN", gfid);
-        }
-
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    gf_uuid_unparse(local->lock[0].ns.directory_ns.locks[0]->loc.inode->gfid,
+                    gfid);
+
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "unlock failed on gfid: %s, stale lock might be left "
+               "in DHT_LAYOUT_HEAL_DOMAIN",
+               gfid);
+    }
+
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 static int32_t
-dht_unlock_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                  = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        lk_index = (long) cookie;
+    lk_index = (long)cookie;
 
-        local = frame->local;
+    local = frame->local;
 
-        uuid_utoa_r (local->lock[0].ns.directory_ns.locks[lk_index]->loc.gfid, gfid);
+    uuid_utoa_r(local->lock[0].ns.directory_ns.locks[lk_index]->loc.gfid, gfid);
 
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "unlocking failed on %s:%s",
-                        local->lock[0].ns.directory_ns.locks[lk_index]->xl->name,
-                        gfid);
-        } else {
-                local->lock[0].ns.directory_ns.locks[lk_index]->locked = 0;
-        }
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLOCKING_FAILED,
+               "unlocking failed on %s:%s",
+               local->lock[0].ns.directory_ns.locks[lk_index]->xl->name, gfid);
+    } else {
+        local->lock[0].ns.directory_ns.locks[lk_index]->locked = 0;
+    }
 
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                dht_entrylk_done (frame);
-        }
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        dht_entrylk_done(frame);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-dht_unlock_entrylk (call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
-                     fop_entrylk_cbk_t entrylk_cbk)
+dht_unlock_entrylk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                   fop_entrylk_cbk_t entrylk_cbk)
 {
-        dht_local_t     *local      = NULL;
-        int              ret        = -1 , i = 0;
-        call_frame_t    *lock_frame = NULL;
-        int              call_cnt   = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, entrylk_cbk, done);
-
-        call_cnt = dht_lock_count (lk_array, lk_count);
-        if (call_cnt == 0) {
-                ret = 0;
-                goto done;
-        }
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "cannot allocate a frame, not unlocking following "
-                        "entrylks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-                goto done;
-        }
-
-        ret = dht_local_entrylk_init (lock_frame, lk_array, lk_count,
-                                      entrylk_cbk);
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "storing locks in local failed, not unlocking "
-                        "following entrylks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-
-                goto done;
-        }
+    dht_local_t *local = NULL;
+    int ret = -1, i = 0;
+    call_frame_t *lock_frame = NULL;
+    int call_cnt = 0;
 
-        local = lock_frame->local;
-        local->main_frame = frame;
-        local->call_cnt = call_cnt;
-
-        for (i = 0; i < local->lock[0].ns.directory_ns.lk_count; i++) {
-                if (!local->lock[0].ns.directory_ns.locks[i]->locked)
-                        continue;
-
-                lock_frame->root->lk_owner = local->lock[0].ns.directory_ns.locks[i]->lk_owner;
-                STACK_WIND_COOKIE (lock_frame, dht_unlock_entrylk_cbk,
-                                   (void *)(long)i,
-                                   local->lock[0].ns.directory_ns.locks[i]->xl,
-                                   local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
-                                   local->lock[0].ns.directory_ns.locks[i]->domain,
-                                   &local->lock[0].ns.directory_ns.locks[i]->loc,
-                                   local->lock[0].ns.directory_ns.locks[i]->basename,
-                                   ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
-                if (!--call_cnt)
-                        break;
-        }
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, entrylk_cbk, done);
 
-        return 0;
+    call_cnt = dht_lock_count(lk_array, lk_count);
+    if (call_cnt == 0) {
+        ret = 0;
+        goto done;
+    }
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+               "cannot allocate a frame, not unlocking following "
+               "entrylks:");
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+        goto done;
+    }
+
+    ret = dht_local_entrylk_init(lock_frame, lk_array, lk_count, entrylk_cbk);
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+               "storing locks in local failed, not unlocking "
+               "following entrylks:");
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+
+        goto done;
+    }
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+    local->call_cnt = call_cnt;
+
+    for (i = 0; i < local->lock[0].ns.directory_ns.lk_count; i++) {
+        if (!local->lock[0].ns.directory_ns.locks[i]->locked)
+            continue;
+
+        lock_frame->root
+            ->lk_owner = local->lock[0].ns.directory_ns.locks[i]->lk_owner;
+        STACK_WIND_COOKIE(
+            lock_frame, dht_unlock_entrylk_cbk, (void *)(long)i,
+            local->lock[0].ns.directory_ns.locks[i]->xl,
+            local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
+            local->lock[0].ns.directory_ns.locks[i]->domain,
+            &local->lock[0].ns.directory_ns.locks[i]->loc,
+            local->lock[0].ns.directory_ns.locks[i]->basename, ENTRYLK_UNLOCK,
+            ENTRYLK_WRLCK, NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 
 done:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
 
-        /* no locks acquired, invoke entrylk_cbk */
-        if (ret == 0)
-                entrylk_cbk (frame, NULL, frame->this, 0, 0, NULL);
+    /* no locks acquired, invoke entrylk_cbk */
+    if (ret == 0)
+        entrylk_cbk(frame, NULL, frame->this, 0, 0, NULL);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_unlock_entrylk_wrapper (call_frame_t *frame, dht_elock_wrap_t *entrylk)
+dht_unlock_entrylk_wrapper(call_frame_t *frame, dht_elock_wrap_t *entrylk)
 {
-        dht_local_t  *local                   = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame              = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int           ret                     = 0;
-
-        local = frame->local;
-
-        if (!entrylk || !entrylk->locks)
-                goto out;
-
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "copy frame failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
-
-        lock_local = dht_local_init (lock_frame, NULL, NULL, 0);
-        if (lock_local == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "local creation failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
-
-        lock_frame->local = lock_local;
-
-        lock_local->lock[0].ns.directory_ns.locks = entrylk->locks;
-        lock_local->lock[0].ns.directory_ns.lk_count = entrylk->lk_count;
-        entrylk->locks = NULL;
-        entrylk->lk_count = 0;
-
-        ret = dht_unlock_entrylk (lock_frame,
-                                  lock_local->lock[0].ns.directory_ns.locks,
-                                  lock_local->lock[0].ns.directory_ns.lk_count,
-                                  dht_unlock_entrylk_done);
-        if (ret)
-                goto done;
-
-        lock_frame = NULL;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+
+    local = frame->local;
+
+    if (!entrylk || !entrylk->locks)
+        goto out;
+
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "copy frame failed",
+               pgfid, local->loc.name, local->loc.path);
+        goto done;
+    }
+
+    lock_local = dht_local_init(lock_frame, NULL, NULL, 0);
+    if (lock_local == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "local creation failed",
+               pgfid, local->loc.name, local->loc.path);
+        goto done;
+    }
+
+    lock_frame->local = lock_local;
+
+    lock_local->lock[0].ns.directory_ns.locks = entrylk->locks;
+    lock_local->lock[0].ns.directory_ns.lk_count = entrylk->lk_count;
+    entrylk->locks = NULL;
+    entrylk->lk_count = 0;
+
+    ret = dht_unlock_entrylk(
+        lock_frame, lock_local->lock[0].ns.directory_ns.locks,
+        lock_local->lock[0].ns.directory_ns.lk_count, dht_unlock_entrylk_done);
+    if (ret)
+        goto done;
+
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 static int
-dht_entrylk_cleanup_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_entrylk_cleanup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_entrylk_done (frame);
-        return 0;
+    dht_entrylk_done(frame);
+    return 0;
 }
 
 static void
-dht_entrylk_cleanup (call_frame_t *lock_frame)
+dht_entrylk_cleanup(call_frame_t *lock_frame)
 {
-        dht_lock_t  **lk_array = NULL;
-        int           lk_count = 0, lk_acquired = 0;
-        dht_local_t  *local    = NULL;
+    dht_lock_t **lk_array = NULL;
+    int lk_count = 0, lk_acquired = 0;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        lk_array = local->lock[0].ns.directory_ns.locks;
-        lk_count = local->lock[0].ns.directory_ns.lk_count;
+    lk_array = local->lock[0].ns.directory_ns.locks;
+    lk_count = local->lock[0].ns.directory_ns.lk_count;
 
-        lk_acquired = dht_lock_count (lk_array, lk_count);
-        if (lk_acquired != 0) {
-                dht_unlock_entrylk (lock_frame, lk_array, lk_count,
-                                     dht_entrylk_cleanup_cbk);
-        } else {
-                dht_entrylk_done (lock_frame);
-        }
+    lk_acquired = dht_lock_count(lk_array, lk_count);
+    if (lk_acquired != 0) {
+        dht_unlock_entrylk(lock_frame, lk_array, lk_count,
+                           dht_entrylk_cleanup_cbk);
+    } else {
+        dht_entrylk_done(lock_frame);
+    }
 
-        return;
+    return;
 }
 
-
 static int32_t
-dht_blocking_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_blocking_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int          lk_index = 0;
-        int          i        = 0;
-        dht_local_t *local    = NULL;
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret == 0) {
-                local->lock[0].ns.directory_ns.locks[lk_index]->locked = _gf_true;
-        } else {
-                switch (op_errno) {
-                case ESTALE:
-                case ENOENT:
-                        if (local->lock[0].ns.directory_ns.locks[lk_index]->do_on_failure != IGNORE_ENOENT_ESTALE) {
-                                local->lock[0].ns.directory_ns.op_ret = -1;
-                                local->lock[0].ns.directory_ns.op_errno = op_errno;
-                                goto cleanup;
-                        }
-                        break;
-                default:
-                        local->lock[0].ns.directory_ns.op_ret = -1;
-                        local->lock[0].ns.directory_ns.op_errno = op_errno;
-                        goto cleanup;
+    int lk_index = 0;
+    int i = 0;
+    dht_local_t *local = NULL;
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret == 0) {
+        local->lock[0].ns.directory_ns.locks[lk_index]->locked = _gf_true;
+    } else {
+        switch (op_errno) {
+            case ESTALE:
+            case ENOENT:
+                if (local->lock[0]
+                        .ns.directory_ns.locks[lk_index]
+                        ->do_on_failure != IGNORE_ENOENT_ESTALE) {
+                    local->lock[0].ns.directory_ns.op_ret = -1;
+                    local->lock[0].ns.directory_ns.op_errno = op_errno;
+                    goto cleanup;
                 }
+                break;
+            default:
+                local->lock[0].ns.directory_ns.op_ret = -1;
+                local->lock[0].ns.directory_ns.op_errno = op_errno;
+                goto cleanup;
         }
+    }
 
-        if (lk_index == (local->lock[0].ns.directory_ns.lk_count - 1)) {
-                for (i = 0; (i < local->lock[0].ns.directory_ns.lk_count) &&
-                     (!local->lock[0].ns.directory_ns.locks[i]->locked); i++)
-                        ;
+    if (lk_index == (local->lock[0].ns.directory_ns.lk_count - 1)) {
+        for (i = 0; (i < local->lock[0].ns.directory_ns.lk_count) &&
+                    (!local->lock[0].ns.directory_ns.locks[i]->locked);
+             i++)
+            ;
 
-                if (i == local->lock[0].ns.directory_ns.lk_count) {
-                        local->lock[0].ns.directory_ns.op_ret = -1;
-                        local->lock[0].ns.directory_ns.op_errno = op_errno;
-                }
-
-                dht_entrylk_done (frame);
-        } else {
-                dht_blocking_entrylk_rec (frame, ++lk_index);
+        if (i == local->lock[0].ns.directory_ns.lk_count) {
+            local->lock[0].ns.directory_ns.op_ret = -1;
+            local->lock[0].ns.directory_ns.op_errno = op_errno;
         }
 
-        return 0;
+        dht_entrylk_done(frame);
+    } else {
+        dht_blocking_entrylk_rec(frame, ++lk_index);
+    }
+
+    return 0;
 
 cleanup:
-        dht_entrylk_cleanup (frame);
+    dht_entrylk_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 void
-dht_blocking_entrylk_rec (call_frame_t *frame, int i)
+dht_blocking_entrylk_rec(call_frame_t *frame, int i)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        STACK_WIND_COOKIE (frame, dht_blocking_entrylk_cbk,
-                           (void *) (long) i,
-                           local->lock[0].ns.directory_ns.locks[i]->xl,
-                           local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
-                           local->lock[0].ns.directory_ns.locks[i]->domain,
-                           &local->lock[0].ns.directory_ns.locks[i]->loc,
-                           local->lock[0].ns.directory_ns.locks[i]->basename,
-                           ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
+    STACK_WIND_COOKIE(
+        frame, dht_blocking_entrylk_cbk, (void *)(long)i,
+        local->lock[0].ns.directory_ns.locks[i]->xl,
+        local->lock[0].ns.directory_ns.locks[i]->xl->fops->entrylk,
+        local->lock[0].ns.directory_ns.locks[i]->domain,
+        &local->lock[0].ns.directory_ns.locks[i]->loc,
+        local->lock[0].ns.directory_ns.locks[i]->basename, ENTRYLK_LOCK,
+        ENTRYLK_WRLCK, NULL);
 
-        return;
+    return;
 }
 
 int
-dht_blocking_entrylk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, fop_entrylk_cbk_t entrylk_cbk)
+dht_blocking_entrylk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_entrylk_cbk_t entrylk_cbk)
 {
-        int           ret        = -1;
-        call_frame_t *lock_frame = NULL;
-        dht_local_t  *local      = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, entrylk_cbk, out);
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL)
-                goto out;
-
-        ret = dht_local_entrylk_init (lock_frame, lk_array, lk_count,
-                                      entrylk_cbk);
-        if (ret < 0) {
-                goto out;
-        }
+    int ret = -1;
+    call_frame_t *lock_frame = NULL;
+    dht_local_t *local = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, entrylk_cbk, out);
 
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        local = lock_frame->local;
-        local->main_frame = frame;
+    ret = dht_local_entrylk_init(lock_frame, lk_array, lk_count, entrylk_cbk);
+    if (ret < 0) {
+        goto out;
+    }
 
-        dht_blocking_entrylk_rec (lock_frame, 0);
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
 
-        return 0;
+    local = lock_frame->local;
+    local->main_frame = frame;
+
+    dht_blocking_entrylk_rec(lock_frame, 0);
+
+    return 0;
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_ENTRYLK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_ENTRYLK);
 
-        return -1;
+    return -1;
 }
 
 static int
-dht_local_inodelk_init (call_frame_t *frame, dht_lock_t **lk_array,
-                     int lk_count, fop_inodelk_cbk_t inodelk_cbk)
+dht_local_inodelk_init(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                       fop_inodelk_cbk_t inodelk_cbk)
 {
-        int          ret   = -1;
-        dht_local_t *local = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local == NULL) {
-                local = dht_local_init (frame, NULL, NULL, 0);
-        }
+    if (local == NULL) {
+        local = dht_local_init(frame, NULL, NULL, 0);
+    }
 
-        if (local == NULL) {
-                goto out;
-        }
+    if (local == NULL) {
+        goto out;
+    }
 
-        local->lock[0].layout.my_layout.inodelk_cbk = inodelk_cbk;
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = lk_count;
+    local->lock[0].layout.my_layout.inodelk_cbk = inodelk_cbk;
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = lk_count;
 
-        ret = dht_lock_order_requests (local->lock[0].layout.my_layout.locks,
-                                       local->lock[0].layout.my_layout.lk_count);
-        if (ret < 0)
-                goto out;
+    ret = dht_lock_order_requests(local->lock[0].layout.my_layout.locks,
+                                  local->lock[0].layout.my_layout.lk_count);
+    if (ret < 0)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static void
-dht_inodelk_done (call_frame_t *lock_frame)
+dht_inodelk_done(call_frame_t *lock_frame)
 {
-        fop_inodelk_cbk_t  inodelk_cbk = NULL;
-        call_frame_t      *main_frame  = NULL;
-        dht_local_t       *local       = NULL;
+    fop_inodelk_cbk_t inodelk_cbk = NULL;
+    call_frame_t *main_frame = NULL;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
-        main_frame = local->main_frame;
+    local = lock_frame->local;
+    main_frame = local->main_frame;
 
-        local->lock[0].layout.my_layout.locks = NULL;
-        local->lock[0].layout.my_layout.lk_count = 0;
+    local->lock[0].layout.my_layout.locks = NULL;
+    local->lock[0].layout.my_layout.lk_count = 0;
 
-        inodelk_cbk = local->lock[0].layout.my_layout.inodelk_cbk;
-        local->lock[0].layout.my_layout.inodelk_cbk = NULL;
+    inodelk_cbk = local->lock[0].layout.my_layout.inodelk_cbk;
+    local->lock[0].layout.my_layout.inodelk_cbk = NULL;
 
-        inodelk_cbk (main_frame, NULL, main_frame->this,
-                     local->lock[0].layout.my_layout.op_ret,
-                     local->lock[0].layout.my_layout.op_errno, NULL);
+    inodelk_cbk(main_frame, NULL, main_frame->this,
+                local->lock[0].layout.my_layout.op_ret,
+                local->lock[0].layout.my_layout.op_errno, NULL);
 
-        dht_lock_stack_destroy (lock_frame, DHT_INODELK);
-        return;
+    dht_lock_stack_destroy(lock_frame, DHT_INODELK);
+    return;
 }
 
 static int32_t
-dht_unlock_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                  = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret < 0) {
-                uuid_utoa_r (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
-                             gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "unlocking failed on %s:%s",
-                        local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
-                        gfid);
-        } else {
-                local->lock[0].layout.my_layout.locks[lk_index]->locked = 0;
-        }
-
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                dht_inodelk_done (frame);
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret < 0) {
+        uuid_utoa_r(local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
+                    gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLOCKING_FAILED,
+               "unlocking failed on %s:%s",
+               local->lock[0].layout.my_layout.locks[lk_index]->xl->name, gfid);
+    } else {
+        local->lock[0].layout.my_layout.locks[lk_index]->locked = 0;
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        dht_inodelk_done(frame);
+    }
+
+    return 0;
 }
 
 static int32_t
-dht_unlock_inodelk_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_unlock_inodelk_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        gf_uuid_unparse (local->lock[0].layout.my_layout.locks[0]->loc.inode->gfid, gfid);
-
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "unlock failed on gfid: %s, stale lock might be left "
-                        "in DHT_LAYOUT_HEAL_DOMAIN", gfid);
-        }
-
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    gf_uuid_unparse(local->lock[0].layout.my_layout.locks[0]->loc.inode->gfid,
+                    gfid);
+
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "unlock failed on gfid: %s, stale lock might be left "
+               "in DHT_LAYOUT_HEAL_DOMAIN",
+               gfid);
+    }
+
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
-dht_unlock_inodelk (call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
-                     fop_inodelk_cbk_t inodelk_cbk)
+dht_unlock_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                   fop_inodelk_cbk_t inodelk_cbk)
 {
-        dht_local_t     *local      = NULL;
-        struct gf_flock  flock      = {0,};
-        int              ret        = -1 , i = 0;
-        call_frame_t    *lock_frame = NULL;
-        int              call_cnt   = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, done);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, done);
-
-        call_cnt = dht_lock_count (lk_array, lk_count);
-        if (call_cnt == 0) {
-                ret = 0;
-                goto done;
-        }
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "cannot allocate a frame, not unlocking following "
-                        "locks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-                goto done;
-        }
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_UNLOCKING_FAILED,
-                        "storing locks in local failed, not unlocking "
-                        "following locks:");
-
-                dht_log_lk_array (frame->this->name, GF_LOG_WARNING, lk_array,
-                                  lk_count);
-
-                goto done;
-        }
-
-        local = lock_frame->local;
-        local->main_frame = frame;
-        local->call_cnt = call_cnt;
-
-        flock.l_type = F_UNLCK;
-
-        for (i = 0; i < local->lock[0].layout.my_layout.lk_count; i++) {
-                if (!local->lock[0].layout.my_layout.locks[i]->locked)
-                        continue;
-
-                lock_frame->root->lk_owner = local->lock[0].layout.my_layout.locks[i]->lk_owner;
-                STACK_WIND_COOKIE (lock_frame, dht_unlock_inodelk_cbk,
-                                   (void *)(long)i,
-                                   local->lock[0].layout.my_layout.locks[i]->xl,
-                                   local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                                   local->lock[0].layout.my_layout.locks[i]->domain,
-                                   &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK,
-                                   &flock, NULL);
-                if (!--call_cnt)
-                        break;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+    int ret = -1, i = 0;
+    call_frame_t *lock_frame = NULL;
+    int call_cnt = 0;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, done);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, done);
+
+    call_cnt = dht_lock_count(lk_array, lk_count);
+    if (call_cnt == 0) {
+        ret = 0;
+        goto done;
+    }
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+               "cannot allocate a frame, not unlocking following "
+               "locks:");
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+        goto done;
+    }
+
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+               "storing locks in local failed, not unlocking "
+               "following locks:");
+
+        dht_log_lk_array(frame->this->name, GF_LOG_WARNING, lk_array, lk_count);
+
+        goto done;
+    }
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+    local->call_cnt = call_cnt;
+
+    flock.l_type = F_UNLCK;
+
+    for (i = 0; i < local->lock[0].layout.my_layout.lk_count; i++) {
+        if (!local->lock[0].layout.my_layout.locks[i]->locked)
+            continue;
+
+        lock_frame->root
+            ->lk_owner = local->lock[0].layout.my_layout.locks[i]->lk_owner;
+        STACK_WIND_COOKIE(
+            lock_frame, dht_unlock_inodelk_cbk, (void *)(long)i,
+            local->lock[0].layout.my_layout.locks[i]->xl,
+            local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+            local->lock[0].layout.my_layout.locks[i]->domain,
+            &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK, &flock,
+            NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 
 done:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        /* no locks acquired, invoke inodelk_cbk */
-        if (ret == 0)
-                inodelk_cbk (frame, NULL, frame->this, 0, 0, NULL);
+    /* no locks acquired, invoke inodelk_cbk */
+    if (ret == 0)
+        inodelk_cbk(frame, NULL, frame->this, 0, 0, NULL);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_unlock_inodelk_wrapper (call_frame_t *frame, dht_ilock_wrap_t *inodelk)
+dht_unlock_inodelk_wrapper(call_frame_t *frame, dht_ilock_wrap_t *inodelk)
 {
-        dht_local_t  *local                   = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame              = NULL;
-        char          pgfid[GF_UUID_BUF_SIZE] = {0};
-        int           ret                     = 0;
-
-        local = frame->local;
-
-        if (!inodelk || !inodelk->locks)
-                goto out;
-
-        gf_uuid_unparse (local->loc.parent->gfid, pgfid);
-
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "copy frame failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
-
-        lock_local = dht_local_init (lock_frame, NULL, NULL, 0);
-        if (lock_local == NULL) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, ENOMEM,
-                        DHT_MSG_PARENT_LAYOUT_CHANGED,
-                        "mkdir (%s/%s) (path: %s): "
-                        "local creation failed", pgfid, local->loc.name,
-                        local->loc.path);
-                goto done;
-        }
-
-        lock_frame->local = lock_local;
-
-        lock_local->lock[0].layout.my_layout.locks = inodelk->locks;
-        lock_local->lock[0].layout.my_layout.lk_count = inodelk->lk_count;
-        inodelk->locks = NULL;
-        inodelk->lk_count = 0;
-
-        ret = dht_unlock_inodelk (lock_frame,
-                                  lock_local->lock[0].layout.my_layout.locks,
-                                  lock_local->lock[0].layout.my_layout.lk_count,
-                                  dht_unlock_inodelk_done);
-
-        if (ret)
-                goto done;
-
-        lock_frame = NULL;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+
+    local = frame->local;
+
+    if (!inodelk || !inodelk->locks)
+        goto out;
+
+    gf_uuid_unparse(local->loc.parent->gfid, pgfid);
+
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "copy frame failed",
+               pgfid, local->loc.name, local->loc.path);
+        goto done;
+    }
+
+    lock_local = dht_local_init(lock_frame, NULL, NULL, 0);
+    if (lock_local == NULL) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, ENOMEM,
+               DHT_MSG_PARENT_LAYOUT_CHANGED,
+               "mkdir (%s/%s) (path: %s): "
+               "local creation failed",
+               pgfid, local->loc.name, local->loc.path);
+        goto done;
+    }
+
+    lock_frame->local = lock_local;
+
+    lock_local->lock[0].layout.my_layout.locks = inodelk->locks;
+    lock_local->lock[0].layout.my_layout.lk_count = inodelk->lk_count;
+    inodelk->locks = NULL;
+    inodelk->lk_count = 0;
+
+    ret = dht_unlock_inodelk(
+        lock_frame, lock_local->lock[0].layout.my_layout.locks,
+        lock_local->lock[0].layout.my_layout.lk_count, dht_unlock_inodelk_done);
+
+    if (ret)
+        goto done;
+
+    lock_frame = NULL;
 
 done:
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 static int
-dht_inodelk_cleanup_cbk (call_frame_t *frame, void *cookie,
-                         xlator_t *this, int32_t op_ret, int32_t op_errno,
-                         dict_t *xdata)
+dht_inodelk_cleanup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_inodelk_done (frame);
-        return 0;
+    dht_inodelk_done(frame);
+    return 0;
 }
 
 static void
-dht_inodelk_cleanup (call_frame_t *lock_frame)
+dht_inodelk_cleanup(call_frame_t *lock_frame)
 {
-        dht_lock_t  **lk_array = NULL;
-        int           lk_count = 0, lk_acquired = 0;
-        dht_local_t  *local    = NULL;
+    dht_lock_t **lk_array = NULL;
+    int lk_count = 0, lk_acquired = 0;
+    dht_local_t *local = NULL;
 
-        local = lock_frame->local;
+    local = lock_frame->local;
 
-        lk_array = local->lock[0].layout.my_layout.locks;
-        lk_count = local->lock[0].layout.my_layout.lk_count;
+    lk_array = local->lock[0].layout.my_layout.locks;
+    lk_count = local->lock[0].layout.my_layout.lk_count;
 
-        lk_acquired = dht_lock_count (lk_array, lk_count);
-        if (lk_acquired != 0) {
-                dht_unlock_inodelk (lock_frame, lk_array, lk_count,
-                                     dht_inodelk_cleanup_cbk);
-        } else {
-                dht_inodelk_done (lock_frame);
-        }
+    lk_acquired = dht_lock_count(lk_array, lk_count);
+    if (lk_acquired != 0) {
+        dht_unlock_inodelk(lock_frame, lk_array, lk_count,
+                           dht_inodelk_cleanup_cbk);
+    } else {
+        dht_inodelk_done(lock_frame);
+    }
 
-        return;
+    return;
 }
 
 static int32_t
-dht_nonblocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_nonblocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                   = NULL;
-        int          lk_index               = 0, call_cnt = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_local_t *local = NULL;
+    int lk_index = 0, call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        local = frame->local;
-        lk_index = (long) cookie;
+    local = frame->local;
+    lk_index = (long)cookie;
 
-        if (op_ret == -1) {
-                local->lock[0].layout.my_layout.op_ret = -1;
-                local->lock[0].layout.my_layout.op_errno = op_errno;
-
-                if (local && local->lock[0].layout.my_layout.locks[lk_index]) {
-                        uuid_utoa_r (local->lock[0].layout.my_layout.locks[lk_index]->loc.inode->gfid,
-                                     gfid);
+    if (op_ret == -1) {
+        local->lock[0].layout.my_layout.op_ret = -1;
+        local->lock[0].layout.my_layout.op_errno = op_errno;
 
-                        gf_msg_debug (this->name, op_errno,
-                                      "inodelk failed on gfid: %s "
-                                      "subvolume: %s", gfid,
-                                      local->lock[0].layout.my_layout.locks[lk_index]->xl->name);
-                }
+        if (local && local->lock[0].layout.my_layout.locks[lk_index]) {
+            uuid_utoa_r(local->lock[0]
+                            .layout.my_layout.locks[lk_index]
+                            ->loc.inode->gfid,
+                        gfid);
 
-                goto out;
+            gf_msg_debug(
+                this->name, op_errno,
+                "inodelk failed on gfid: %s "
+                "subvolume: %s",
+                gfid,
+                local->lock[0].layout.my_layout.locks[lk_index]->xl->name);
         }
 
-        local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
+        goto out;
+    }
 
-out:
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                if (local->lock[0].layout.my_layout.op_ret < 0) {
-                        dht_inodelk_cleanup (frame);
-                        return 0;
-                }
+    local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
 
-                dht_inodelk_done (frame);
+out:
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->lock[0].layout.my_layout.op_ret < 0) {
+            dht_inodelk_cleanup(frame);
+            return 0;
         }
 
-        return 0;
+        dht_inodelk_done(frame);
+    }
+
+    return 0;
 }
 
 int
-dht_nonblocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                         int lk_count, fop_inodelk_cbk_t inodelk_cbk)
+dht_nonblocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array,
+                        int lk_count, fop_inodelk_cbk_t inodelk_cbk)
 {
-        struct gf_flock  flock      = {0,};
-        int              i          = 0, ret = 0;
-        dht_local_t     *local      = NULL;
-        call_frame_t    *lock_frame = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, out);
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL)
-                goto out;
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                goto out;
-        }
+    struct gf_flock flock = {
+        0,
+    };
+    int i = 0, ret = 0;
+    dht_local_t *local = NULL;
+    call_frame_t *lock_frame = NULL;
 
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, out);
 
-        local = lock_frame->local;
-        local->main_frame = frame;
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL)
+        goto out;
 
-        local->call_cnt = lk_count;
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        goto out;
+    }
 
-        for (i = 0; i < lk_count; i++) {
-                flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
 
-                STACK_WIND_COOKIE (lock_frame, dht_nonblocking_inodelk_cbk,
-                                   (void *) (long) i,
-                                   local->lock[0].layout.my_layout.locks[i]->xl,
-                                   local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                                   local->lock[0].layout.my_layout.locks[i]->domain,
-                                   &local->lock[0].layout.my_layout.locks[i]->loc,
-                                   F_SETLK,
-                                   &flock, NULL);
-        }
+    local = lock_frame->local;
+    local->main_frame = frame;
+
+    local->call_cnt = lk_count;
+
+    for (i = 0; i < lk_count; i++) {
+        flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+
+        STACK_WIND_COOKIE(
+            lock_frame, dht_nonblocking_inodelk_cbk, (void *)(long)i,
+            local->lock[0].layout.my_layout.locks[i]->xl,
+            local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+            local->lock[0].layout.my_layout.locks[i]->domain,
+            &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLK, &flock,
+            NULL);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        return -1;
+    return -1;
 }
 
 static int32_t
-dht_blocking_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_blocking_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int                  lk_index       = 0;
-        int                  i              = 0;
-        dht_local_t         *local          = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0,};
-        dht_reaction_type_t  reaction       = 0;
-
-        lk_index = (long) cookie;
-
-        local = frame->local;
-        if (op_ret == 0) {
-                local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
-        } else {
-                switch (op_errno) {
-                case ESTALE:
-                case ENOENT:
-                        reaction = local->lock[0].layout.my_layout.locks[lk_index]->do_on_failure;
-                        if ((reaction != IGNORE_ENOENT_ESTALE) &&
-                            (reaction != IGNORE_ENOENT_ESTALE_EIO)) {
-                                gf_uuid_unparse (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid, gfid);
-                                local->lock[0].layout.my_layout.op_ret = -1;
-                                local->lock[0].layout.my_layout.op_errno = op_errno;
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_INODELK_FAILED,
-                                        "inodelk failed on subvol %s. gfid:%s",
-                                        local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
-                                        gfid);
-                                goto cleanup;
-                        }
-                        break;
-                case EIO:
-                        reaction = local->lock[0].layout.my_layout.locks[lk_index]->do_on_failure;
-                        if (reaction != IGNORE_ENOENT_ESTALE_EIO) {
-                                gf_uuid_unparse (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid, gfid);
-                                local->lock[0].layout.my_layout.op_ret = -1;
-                                local->lock[0].layout.my_layout.op_errno = op_errno;
-                                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                        DHT_MSG_INODELK_FAILED,
-                                        "inodelk failed on subvol %s. gfid:%s",
-                                        local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
-                                        gfid);
-                                goto cleanup;
-                        }
-                        break;
-
-                default:
-                        gf_uuid_unparse (local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid, gfid);
-                        local->lock[0].layout.my_layout.op_ret = -1;
-                        local->lock[0].layout.my_layout.op_errno = op_errno;
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_INODELK_FAILED,
-                                "inodelk failed on subvol %s, gfid:%s",
-                                local->lock[0].layout.my_layout.locks[lk_index]->xl->name, gfid);
-                        goto cleanup;
+    int lk_index = 0;
+    int i = 0;
+    dht_local_t *local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+    dht_reaction_type_t reaction = 0;
+
+    lk_index = (long)cookie;
+
+    local = frame->local;
+    if (op_ret == 0) {
+        local->lock[0].layout.my_layout.locks[lk_index]->locked = _gf_true;
+    } else {
+        switch (op_errno) {
+            case ESTALE:
+            case ENOENT:
+                reaction = local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->do_on_failure;
+                if ((reaction != IGNORE_ENOENT_ESTALE) &&
+                    (reaction != IGNORE_ENOENT_ESTALE_EIO)) {
+                    gf_uuid_unparse(local->lock[0]
+                                        .layout.my_layout.locks[lk_index]
+                                        ->loc.gfid,
+                                    gfid);
+                    local->lock[0].layout.my_layout.op_ret = -1;
+                    local->lock[0].layout.my_layout.op_errno = op_errno;
+                    gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                           DHT_MSG_INODELK_FAILED,
+                           "inodelk failed on subvol %s. gfid:%s",
+                           local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->xl->name,
+                           gfid);
+                    goto cleanup;
                 }
-        }
+                break;
+            case EIO:
+                reaction = local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->do_on_failure;
+                if (reaction != IGNORE_ENOENT_ESTALE_EIO) {
+                    gf_uuid_unparse(local->lock[0]
+                                        .layout.my_layout.locks[lk_index]
+                                        ->loc.gfid,
+                                    gfid);
+                    local->lock[0].layout.my_layout.op_ret = -1;
+                    local->lock[0].layout.my_layout.op_errno = op_errno;
+                    gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                           DHT_MSG_INODELK_FAILED,
+                           "inodelk failed on subvol %s. gfid:%s",
+                           local->lock[0]
+                               .layout.my_layout.locks[lk_index]
+                               ->xl->name,
+                           gfid);
+                    goto cleanup;
+                }
+                break;
 
-        if (lk_index == (local->lock[0].layout.my_layout.lk_count - 1)) {
-                for (i = 0; (i < local->lock[0].layout.my_layout.lk_count) &&
-                     (!local->lock[0].layout.my_layout.locks[i]->locked); i++)
-                        ;
+            default:
+                gf_uuid_unparse(
+                    local->lock[0].layout.my_layout.locks[lk_index]->loc.gfid,
+                    gfid);
+                local->lock[0].layout.my_layout.op_ret = -1;
+                local->lock[0].layout.my_layout.op_errno = op_errno;
+                gf_msg(
+                    this->name, GF_LOG_ERROR, op_errno, DHT_MSG_INODELK_FAILED,
+                    "inodelk failed on subvol %s, gfid:%s",
+                    local->lock[0].layout.my_layout.locks[lk_index]->xl->name,
+                    gfid);
+                goto cleanup;
+        }
+    }
 
-                if (i == local->lock[0].layout.my_layout.lk_count) {
-                        local->lock[0].layout.my_layout.op_ret = -1;
-                        local->lock[0].layout.my_layout.op_errno = op_errno;
-                }
+    if (lk_index == (local->lock[0].layout.my_layout.lk_count - 1)) {
+        for (i = 0; (i < local->lock[0].layout.my_layout.lk_count) &&
+                    (!local->lock[0].layout.my_layout.locks[i]->locked);
+             i++)
+            ;
 
-                dht_inodelk_done (frame);
-        } else {
-                dht_blocking_inodelk_rec (frame, ++lk_index);
+        if (i == local->lock[0].layout.my_layout.lk_count) {
+            local->lock[0].layout.my_layout.op_ret = -1;
+            local->lock[0].layout.my_layout.op_errno = op_errno;
         }
 
-        return 0;
+        dht_inodelk_done(frame);
+    } else {
+        dht_blocking_inodelk_rec(frame, ++lk_index);
+    }
+
+    return 0;
 
 cleanup:
-        dht_inodelk_cleanup (frame);
+    dht_inodelk_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 void
-dht_blocking_inodelk_rec (call_frame_t *frame, int i)
+dht_blocking_inodelk_rec(call_frame_t *frame, int i)
 {
-        dht_local_t     *local = NULL;
-        struct gf_flock  flock = {0,};
+    dht_local_t *local = NULL;
+    struct gf_flock flock = {
+        0,
+    };
 
-        local = frame->local;
+    local = frame->local;
 
-        flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
+    flock.l_type = local->lock[0].layout.my_layout.locks[i]->type;
 
-        STACK_WIND_COOKIE (frame, dht_blocking_inodelk_cbk,
-                           (void *) (long) i,
-                           local->lock[0].layout.my_layout.locks[i]->xl,
-                           local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
-                           local->lock[0].layout.my_layout.locks[i]->domain,
-                           &local->lock[0].layout.my_layout.locks[i]->loc,
-                           F_SETLKW,
-                           &flock, NULL);
+    STACK_WIND_COOKIE(
+        frame, dht_blocking_inodelk_cbk, (void *)(long)i,
+        local->lock[0].layout.my_layout.locks[i]->xl,
+        local->lock[0].layout.my_layout.locks[i]->xl->fops->inodelk,
+        local->lock[0].layout.my_layout.locks[i]->domain,
+        &local->lock[0].layout.my_layout.locks[i]->loc, F_SETLKW, &flock, NULL);
 
-        return;
+    return;
 }
 
 int
-dht_blocking_inodelk (call_frame_t *frame, dht_lock_t **lk_array,
-                      int lk_count, fop_inodelk_cbk_t inodelk_cbk)
+dht_blocking_inodelk(call_frame_t *frame, dht_lock_t **lk_array, int lk_count,
+                     fop_inodelk_cbk_t inodelk_cbk)
 {
-        int           ret                       = -1;
-        call_frame_t *lock_frame                = NULL;
-        dht_local_t  *local                     = NULL;
-        dht_local_t  *tmp_local                 = NULL;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lk_array, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, inodelk_cbk, out);
-
-        tmp_local = frame->local;
-
-        lock_frame = dht_lock_frame (frame);
-        if (lock_frame == NULL) {
-                gf_uuid_unparse (tmp_local->loc.gfid, gfid);
-                gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_LOCK_FRAME_FAILED,
-                        "memory allocation failed for lock_frame. gfid:%s"
-                        " path:%s", gfid, tmp_local->loc.path);
-                goto out;
-        }
-
-        ret = dht_local_inodelk_init (lock_frame, lk_array, lk_count,
-                                      inodelk_cbk);
-        if (ret < 0) {
-                gf_uuid_unparse (tmp_local->loc.gfid, gfid);
-                gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_LOCAL_LOCK_INIT_FAILED,
-                        "dht_local_lock_init failed, gfid: %s path:%s", gfid,
-                        tmp_local->loc.path);
-                goto out;
-        }
-
-        dht_set_lkowner (lk_array, lk_count, &lock_frame->root->lk_owner);
-
-        local = lock_frame->local;
-        local->main_frame = frame;
-
-        dht_blocking_inodelk_rec (lock_frame, 0);
-
-        return 0;
+    int ret = -1;
+    call_frame_t *lock_frame = NULL;
+    dht_local_t *local = NULL;
+    dht_local_t *tmp_local = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lk_array, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, inodelk_cbk, out);
+
+    tmp_local = frame->local;
+
+    lock_frame = dht_lock_frame(frame);
+    if (lock_frame == NULL) {
+        gf_uuid_unparse(tmp_local->loc.gfid, gfid);
+        gf_msg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_LOCK_FRAME_FAILED,
+               "memory allocation failed for lock_frame. gfid:%s"
+               " path:%s",
+               gfid, tmp_local->loc.path);
+        goto out;
+    }
+
+    ret = dht_local_inodelk_init(lock_frame, lk_array, lk_count, inodelk_cbk);
+    if (ret < 0) {
+        gf_uuid_unparse(tmp_local->loc.gfid, gfid);
+        gf_msg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_LOCAL_LOCK_INIT_FAILED,
+               "dht_local_lock_init failed, gfid: %s path:%s", gfid,
+               tmp_local->loc.path);
+        goto out;
+    }
+
+    dht_set_lkowner(lk_array, lk_count, &lock_frame->root->lk_owner);
+
+    local = lock_frame->local;
+    local->main_frame = frame;
+
+    dht_blocking_inodelk_rec(lock_frame, 0);
+
+    return 0;
 out:
-        if (lock_frame)
-                dht_lock_stack_destroy (lock_frame, DHT_INODELK);
+    if (lock_frame)
+        dht_lock_stack_destroy(lock_frame, DHT_INODELK);
 
-        return -1;
+    return -1;
 }
 
 void
-dht_unlock_namespace (call_frame_t *frame, dht_dir_transaction_t *lock)
+dht_unlock_namespace(call_frame_t *frame, dht_dir_transaction_t *lock)
 {
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, lock, out);
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, lock, out);
 
-        dht_unlock_entrylk_wrapper (frame, &lock->ns.directory_ns);
-        dht_unlock_inodelk_wrapper (frame, &lock->ns.parent_layout);
+    dht_unlock_entrylk_wrapper(frame, &lock->ns.directory_ns);
+    dht_unlock_inodelk_wrapper(frame, &lock->ns.parent_layout);
 
 out:
-        return;
+    return;
 }
 
 static int32_t
-dht_protect_namespace_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_protect_namespace_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local    = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (op_ret != 0)
-                dht_unlock_inodelk_wrapper (frame,
-                                            &local->current->ns.parent_layout);
+    local = frame->local;
+    if (op_ret != 0)
+        dht_unlock_inodelk_wrapper(frame, &local->current->ns.parent_layout);
 
-        local->current->ns.ns_cbk (frame, cookie, this, op_ret, op_errno,
-                                   xdata);
-        return 0;
+    local->current->ns.ns_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-dht_blocking_entrylk_after_inodelk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int32_t op_ret,
-                                    int32_t op_errno, dict_t *xdata)
+dht_blocking_entrylk_after_inodelk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t           *local                   = NULL;
-        int                    ret                     = -1;
-        loc_t                 *loc                     = NULL;
-        dht_lock_t           **lk_array                = NULL;
-        char                   pgfid[GF_UUID_BUF_SIZE] = {0};
-        int                    count                   = 0;
-        dht_elock_wrap_t      *entrylk                 = NULL;
-
-        local = frame->local;
-        entrylk = &local->current->ns.directory_ns;
-
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        loc = &entrylk->locks[0]->loc;
-        gf_uuid_unparse (loc->gfid, pgfid);
-
-        local->op_ret = 0;
-        lk_array = entrylk->locks;
-        count = entrylk->lk_count;
-
-        ret = dht_blocking_entrylk (frame, lk_array, count,
-                                    dht_protect_namespace_cbk);
-
-        if (ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = EIO;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_ENTRYLK_ERROR,
-                        "%s (%s/%s): "
-                        "dht_blocking_entrylk failed after taking inodelk",
-                        gf_fop_list[local->fop], pgfid,
-                        entrylk->locks[0]->basename);
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int ret = -1;
+    loc_t *loc = NULL;
+    dht_lock_t **lk_array = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int count = 0;
+    dht_elock_wrap_t *entrylk = NULL;
+
+    local = frame->local;
+    entrylk = &local->current->ns.directory_ns;
+
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    loc = &entrylk->locks[0]->loc;
+    gf_uuid_unparse(loc->gfid, pgfid);
+
+    local->op_ret = 0;
+    lk_array = entrylk->locks;
+    count = entrylk->lk_count;
+
+    ret = dht_blocking_entrylk(frame, lk_array, count,
+                               dht_protect_namespace_cbk);
+
+    if (ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_ENTRYLK_ERROR,
+               "%s (%s/%s): "
+               "dht_blocking_entrylk failed after taking inodelk",
+               gf_fop_list[local->fop], pgfid, entrylk->locks[0]->basename);
+        goto err;
+    }
+
+    return 0;
 
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-                entrylk->locks = NULL;
-                entrylk->lk_count = 0;
-        }
-
-        /* Unlock inodelk. No harm calling unlock twice */
-        dht_unlock_inodelk_wrapper (frame, &local->current->ns.parent_layout);
-        /* Call ns_cbk. It will take care of unwinding */
-        local->current->ns.ns_cbk (frame, NULL, this, local->op_ret,
-                                   local->op_errno, NULL);
-        return 0;
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+        entrylk->locks = NULL;
+        entrylk->lk_count = 0;
+    }
+
+    /* Unlock inodelk. No harm calling unlock twice */
+    dht_unlock_inodelk_wrapper(frame, &local->current->ns.parent_layout);
+    /* Call ns_cbk. It will take care of unwinding */
+    local->current->ns.ns_cbk(frame, NULL, this, local->op_ret, local->op_errno,
+                              NULL);
+    return 0;
 }
 
 /* Given the loc and the subvol, this routine takes the inodelk on
@@ -1265,137 +1278,131 @@ err:
  * and then entrylk serially.
  */
 int
-dht_protect_namespace (call_frame_t *frame, loc_t *loc,
-                       xlator_t *subvol,
-                       struct dht_namespace *ns,
-                       fop_entrylk_cbk_t ns_cbk)
+dht_protect_namespace(call_frame_t *frame, loc_t *loc, xlator_t *subvol,
+                      struct dht_namespace *ns, fop_entrylk_cbk_t ns_cbk)
 {
-        dht_ilock_wrap_t  *inodelk                 = NULL;
-        dht_elock_wrap_t  *entrylk                 = NULL;
-        dht_lock_t       **lk_array                = NULL;
-        dht_local_t       *local                   = NULL;
-        xlator_t          *this                    = NULL;
-        loc_t              parent                  = {0,};
-        int                ret                     = -1;
-        char               pgfid[GF_UUID_BUF_SIZE] = {0};
-        int32_t            op_errno                = 0;
-        int                count                   = 1;
-
-        GF_VALIDATE_OR_GOTO ("dht-locks", frame, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, loc, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, loc->parent, out);
-        GF_VALIDATE_OR_GOTO (frame->this->name, subvol, out);
-
-        local = frame->local;
-        this = frame->this;
-
-        inodelk = &ns->parent_layout;
-        entrylk = &ns->directory_ns;
-
-        /* Initialize entrylk_cbk and parent loc */
-        ns->ns_cbk = ns_cbk;
-
-        ret = dht_build_parent_loc (this, &parent, loc, &op_errno);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_LOC_FAILED, "gfid:%s (name:%s) (path: %s): "
-                        "parent loc build failed", loc->gfid, loc->name,
-                         loc->path);
-                goto out;
-        }
-        gf_uuid_unparse (parent.gfid, pgfid);
-
-        /* Alloc inodelk */
-        inodelk->locks = GF_CALLOC (count, sizeof (*lk_array),
-                                    gf_common_mt_pointer);
-        if (inodelk->locks == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "calloc failure",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto out;
-        }
-
-        inodelk->locks[0] = dht_lock_new (this, subvol, &parent, F_RDLCK,
-                                          DHT_LAYOUT_HEAL_DOMAIN, NULL,
-                                          FAIL_ON_ANY_ERROR);
-        if (inodelk->locks[0] == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "inodelk: lock allocation failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-        inodelk->lk_count = count;
-
-        /* Allock entrylk */
-        entrylk->locks = GF_CALLOC (count, sizeof (*lk_array),
-                                    gf_common_mt_pointer);
-        if (entrylk->locks == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "entrylk: calloc failure",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-
-                goto err;
-        }
-
-        entrylk->locks[0] = dht_lock_new (this, subvol, &parent, F_WRLCK,
-                                          DHT_ENTRY_SYNC_DOMAIN, loc->name,
-                                          FAIL_ON_ANY_ERROR);
-        if (entrylk->locks[0] == NULL) {
-                local->op_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_NO_MEMORY,
-                        "%s (%s/%s) (path: %s): "
-                        "entrylk: lock allocation failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-
-                goto err;
-        }
-        entrylk->lk_count = count;
-
-        /* Take read inodelk on parent. If it is successful, take write entrylk
-         * on name in cbk.
-         */
-        lk_array = inodelk->locks;
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    dht_blocking_entrylk_after_inodelk);
-        if (ret < 0) {
-                local->op_errno = EIO;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_INODELK_ERROR,
-                        "%s (%s/%s) (path: %s): "
-                        "dht_blocking_inodelk failed",
-                        gf_fop_list[local->fop], pgfid, loc->name, loc->path);
-                goto err;
-        }
-
-        loc_wipe (&parent);
-
-        return 0;
+    dht_ilock_wrap_t *inodelk = NULL;
+    dht_elock_wrap_t *entrylk = NULL;
+    dht_lock_t **lk_array = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    loc_t parent = {
+        0,
+    };
+    int ret = -1;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t op_errno = 0;
+    int count = 1;
+
+    GF_VALIDATE_OR_GOTO("dht-locks", frame, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, loc, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, loc->parent, out);
+    GF_VALIDATE_OR_GOTO(frame->this->name, subvol, out);
+
+    local = frame->local;
+    this = frame->this;
+
+    inodelk = &ns->parent_layout;
+    entrylk = &ns->directory_ns;
+
+    /* Initialize entrylk_cbk and parent loc */
+    ns->ns_cbk = ns_cbk;
+
+    ret = dht_build_parent_loc(this, &parent, loc, &op_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, op_errno, DHT_MSG_LOC_FAILED,
+               "gfid:%s (name:%s) (path: %s): "
+               "parent loc build failed",
+               loc->gfid, loc->name, loc->path);
+        goto out;
+    }
+    gf_uuid_unparse(parent.gfid, pgfid);
+
+    /* Alloc inodelk */
+    inodelk->locks = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (inodelk->locks == NULL) {
+        local->op_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno, DHT_MSG_NO_MEMORY,
+               "%s (%s/%s) (path: %s): "
+               "calloc failure",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+        goto out;
+    }
+
+    inodelk->locks[0] = dht_lock_new(this, subvol, &parent, F_RDLCK,
+                                     DHT_LAYOUT_HEAL_DOMAIN, NULL,
+                                     FAIL_ON_ANY_ERROR);
+    if (inodelk->locks[0] == NULL) {
+        local->op_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno, DHT_MSG_NO_MEMORY,
+               "%s (%s/%s) (path: %s): "
+               "inodelk: lock allocation failed",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+    inodelk->lk_count = count;
+
+    /* Allock entrylk */
+    entrylk->locks = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (entrylk->locks == NULL) {
+        local->op_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno, DHT_MSG_NO_MEMORY,
+               "%s (%s/%s) (path: %s): "
+               "entrylk: calloc failure",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+
+        goto err;
+    }
+
+    entrylk->locks[0] = dht_lock_new(this, subvol, &parent, F_WRLCK,
+                                     DHT_ENTRY_SYNC_DOMAIN, loc->name,
+                                     FAIL_ON_ANY_ERROR);
+    if (entrylk->locks[0] == NULL) {
+        local->op_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno, DHT_MSG_NO_MEMORY,
+               "%s (%s/%s) (path: %s): "
+               "entrylk: lock allocation failed",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+
+        goto err;
+    }
+    entrylk->lk_count = count;
+
+    /* Take read inodelk on parent. If it is successful, take write entrylk
+     * on name in cbk.
+     */
+    lk_array = inodelk->locks;
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_blocking_entrylk_after_inodelk);
+    if (ret < 0) {
+        local->op_errno = EIO;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_INODELK_ERROR,
+               "%s (%s/%s) (path: %s): "
+               "dht_blocking_inodelk failed",
+               gf_fop_list[local->fop], pgfid, loc->name, loc->path);
+        goto err;
+    }
+
+    loc_wipe(&parent);
+
+    return 0;
 err:
-        if (entrylk->locks != NULL) {
-                dht_lock_array_free (entrylk->locks, count);
-                GF_FREE (entrylk->locks);
-                entrylk->locks = NULL;
-                entrylk->lk_count = 0;
-        }
+    if (entrylk->locks != NULL) {
+        dht_lock_array_free(entrylk->locks, count);
+        GF_FREE(entrylk->locks);
+        entrylk->locks = NULL;
+        entrylk->lk_count = 0;
+    }
 
-        if (inodelk->locks != NULL) {
-                dht_lock_array_free (inodelk->locks, count);
-                GF_FREE (inodelk->locks);
-                inodelk->locks = NULL;
-                inodelk->lk_count = 0;
-        }
+    if (inodelk->locks != NULL) {
+        dht_lock_array_free(inodelk->locks, count);
+        GF_FREE(inodelk->locks);
+        inodelk->locks = NULL;
+        inodelk->lk_count = 0;
+    }
 
-        loc_wipe (&parent);
+    loc_wipe(&parent);
 out:
-        return -1;
+    return -1;
 }
diff --git a/xlators/cluster/dht/src/dht-rebalance.c b/xlators/cluster/dht/src/dht-rebalance.c
index 9983429acec..7a2539dc5f5 100644
--- a/xlators/cluster/dht/src/dht-rebalance.c
+++ b/xlators/cluster/dht/src/dht-rebalance.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "tier.h"
 #include "dht-common.h"
 #include "xlator.h"
@@ -18,244 +17,230 @@
 #include <signal.h>
 #include "events.h"
 
-#define GF_DISK_SECTOR_SIZE              512
-#define DHT_REBALANCE_PID               4242 /* Change it if required */
-#define DHT_REBALANCE_BLKSIZE           (1024 * 1024)  /* 1 MB */
-#define MAX_MIGRATE_QUEUE_COUNT          500
-#define MIN_MIGRATE_QUEUE_COUNT          200
-#define MAX_REBAL_TYPE_SIZE               16
-#define FILE_CNT_INTERVAL                600 /* 10 mins */
-#define ESTIMATE_START_INTERVAL          600 /* 10 mins */
-#define HARDLINK_MIG_INPROGRESS          -2
-#define SKIP_MIGRATION_FD_POSITIVE       -3
+#define GF_DISK_SECTOR_SIZE 512
+#define DHT_REBALANCE_PID 4242              /* Change it if required */
+#define DHT_REBALANCE_BLKSIZE (1024 * 1024) /* 1 MB */
+#define MAX_MIGRATE_QUEUE_COUNT 500
+#define MIN_MIGRATE_QUEUE_COUNT 200
+#define MAX_REBAL_TYPE_SIZE 16
+#define FILE_CNT_INTERVAL 600       /* 10 mins */
+#define ESTIMATE_START_INTERVAL 600 /* 10 mins */
+#define HARDLINK_MIG_INPROGRESS -2
+#define SKIP_MIGRATION_FD_POSITIVE -3
 #ifndef MAX
-#define MAX(a, b) (((a) > (b))?(a):(b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
-
-#define GF_CRAWL_INDEX_MOVE(idx, sv_cnt)  {     \
-                idx++;                          \
-                idx %= sv_cnt;                  \
-        }
+#define GF_CRAWL_INDEX_MOVE(idx, sv_cnt)                                       \
+    {                                                                          \
+        idx++;                                                                 \
+        idx %= sv_cnt;                                                         \
+    }
 
 uint64_t g_totalfiles = 0;
 uint64_t g_totalsize = 0;
 
-
 void
-gf_defrag_free_dir_dfmeta (struct dir_dfmeta *meta, int local_subvols_cnt)
+gf_defrag_free_dir_dfmeta(struct dir_dfmeta *meta, int local_subvols_cnt)
 {
-        int     i = 0;
+    int i = 0;
 
-        if (meta) {
-                for (i = 0; i < local_subvols_cnt; i++) {
-                        gf_dirent_free (&meta->equeue[i]);
-                }
-
-                GF_FREE (meta->equeue);
-                GF_FREE (meta->head);
-                GF_FREE (meta->iterator);
-                GF_FREE (meta->offset_var);
-                GF_FREE (meta->fetch_entries);
-                GF_FREE (meta);
+    if (meta) {
+        for (i = 0; i < local_subvols_cnt; i++) {
+            gf_dirent_free(&meta->equeue[i]);
         }
+
+        GF_FREE(meta->equeue);
+        GF_FREE(meta->head);
+        GF_FREE(meta->iterator);
+        GF_FREE(meta->offset_var);
+        GF_FREE(meta->fetch_entries);
+        GF_FREE(meta);
+    }
 }
 
 void
-gf_defrag_free_container (struct dht_container *container)
+gf_defrag_free_container(struct dht_container *container)
 {
-        if (container) {
-                gf_dirent_entry_free (container->df_entry);
+    if (container) {
+        gf_dirent_entry_free(container->df_entry);
 
-                if (container->parent_loc) {
-                        loc_wipe (container->parent_loc);
-                }
+        if (container->parent_loc) {
+            loc_wipe(container->parent_loc);
+        }
 
-                GF_FREE (container->parent_loc);
+        GF_FREE(container->parent_loc);
 
-                GF_FREE (container);
-        }
+        GF_FREE(container);
+    }
 }
 
 void
-dht_set_global_defrag_error (gf_defrag_info_t *defrag, int ret)
+dht_set_global_defrag_error(gf_defrag_info_t *defrag, int ret)
 {
-        LOCK (&defrag->lock);
-        {
-                defrag->global_error = ret;
-        }
-        UNLOCK (&defrag->lock);
-        return;
+    LOCK(&defrag->lock);
+    {
+        defrag->global_error = ret;
+    }
+    UNLOCK(&defrag->lock);
+    return;
 }
 
-
 static gf_boolean_t
-dht_is_tier_command (int cmd) {
-
-        gf_boolean_t is_tier = _gf_false;
+dht_is_tier_command(int cmd)
+{
+    gf_boolean_t is_tier = _gf_false;
 
-        switch (cmd) {
+    switch (cmd) {
         case GF_DEFRAG_CMD_START_TIER:
         case GF_DEFRAG_CMD_STATUS_TIER:
         case GF_DEFRAG_CMD_START_DETACH_TIER:
         case GF_DEFRAG_CMD_STOP_DETACH_TIER:
         case GF_DEFRAG_CMD_PAUSE_TIER:
         case GF_DEFRAG_CMD_RESUME_TIER:
-                is_tier = _gf_true;
-                break;
+            is_tier = _gf_true;
+            break;
         default:
-                break;
-        }
-        return is_tier;
-
+            break;
+    }
+    return is_tier;
 }
 
-
 static int
-dht_send_rebalance_event (xlator_t *this, int cmd, gf_defrag_status_t status)
+dht_send_rebalance_event(xlator_t *this, int cmd, gf_defrag_status_t status)
 {
-        int ret = -1;
-        char *volname = NULL;
-        char *tmpstr  = NULL;
-        char *ptr = NULL;
-        char *suffix = "-dht";
-        dht_conf_t   *conf = NULL;
-        gf_defrag_info_t *defrag = NULL;
-        int len = 0;
-
-        eventtypes_t event = EVENT_LAST;
-
-        switch (status) {
+    int ret = -1;
+    char *volname = NULL;
+    char *tmpstr = NULL;
+    char *ptr = NULL;
+    char *suffix = "-dht";
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    int len = 0;
+
+    eventtypes_t event = EVENT_LAST;
+
+    switch (status) {
         case GF_DEFRAG_STATUS_COMPLETE:
-                event = EVENT_VOLUME_REBALANCE_COMPLETE;
-                break;
+            event = EVENT_VOLUME_REBALANCE_COMPLETE;
+            break;
         case GF_DEFRAG_STATUS_FAILED:
-                event = EVENT_VOLUME_REBALANCE_FAILED;
-                break;
+            event = EVENT_VOLUME_REBALANCE_FAILED;
+            break;
         case GF_DEFRAG_STATUS_STOPPED:
-                event = EVENT_VOLUME_REBALANCE_STOP;
-                break;
+            event = EVENT_VOLUME_REBALANCE_STOP;
+            break;
         default:
-                break;
-
-        }
-
-        if (dht_is_tier_command (cmd)) {
-                /* We should have the tier volume name*/
-                conf = this->private;
-                defrag = conf->defrag;
-                volname = defrag->tier_conf.volname;
-        } else {
-                /* DHT volume */
-                len = strlen (this->name) - strlen (suffix);
-                tmpstr = gf_strdup (this->name);
-                if (tmpstr) {
-                        ptr = tmpstr + len;
-                        if (!strcmp (ptr, suffix)) {
-                                tmpstr[len] = '\0';
-                                volname = tmpstr;
-                        }
-                }
-        }
+            break;
+    }
 
-        if (!volname) {
-                /* Better than nothing */
-                volname = this->name;
-        }
-
-        if (event != EVENT_LAST) {
-                gf_event (event, "volume=%s", volname);
-        }
-
-        GF_FREE (tmpstr);
-        return ret;
+    if (dht_is_tier_command(cmd)) {
+        /* We should have the tier volume name*/
+        conf = this->private;
+        defrag = conf->defrag;
+        volname = defrag->tier_conf.volname;
+    } else {
+        /* DHT volume */
+        len = strlen(this->name) - strlen(suffix);
+        tmpstr = gf_strdup(this->name);
+        if (tmpstr) {
+            ptr = tmpstr + len;
+            if (!strcmp(ptr, suffix)) {
+                tmpstr[len] = '\0';
+                volname = tmpstr;
+            }
+        }
+    }
+
+    if (!volname) {
+        /* Better than nothing */
+        volname = this->name;
+    }
+
+    if (event != EVENT_LAST) {
+        gf_event(event, "volume=%s", volname);
+    }
+
+    GF_FREE(tmpstr);
+    return ret;
 }
 
-
 static void
-dht_strip_out_acls (dict_t *dict)
+dht_strip_out_acls(dict_t *dict)
 {
-        if (dict) {
-                dict_del (dict, "trusted.SGI_ACL_FILE");
-                dict_del (dict, POSIX_ACL_ACCESS_XATTR);
-        }
+    if (dict) {
+        dict_del(dict, "trusted.SGI_ACL_FILE");
+        dict_del(dict, POSIX_ACL_ACCESS_XATTR);
+    }
 }
 
-
-
 static int
-dht_write_with_holes (xlator_t *to, fd_t *fd, struct iovec *vec, int count,
-                      int32_t size, off_t offset, struct iobref *iobref,
-                      int *fop_errno)
+dht_write_with_holes(xlator_t *to, fd_t *fd, struct iovec *vec, int count,
+                     int32_t size, off_t offset, struct iobref *iobref,
+                     int *fop_errno)
 {
-        int i            = 0;
-        int ret          = -1;
-        int start_idx    = 0;
-        int tmp_offset   = 0;
-        int write_needed = 0;
-        int buf_len      = 0;
-        int size_pending = 0;
-        char *buf        = NULL;
-
-        /* loop through each vector */
-        for (i = 0; i < count; i++) {
-                buf = vec[i].iov_base;
-                buf_len = vec[i].iov_len;
-
-                for (start_idx = 0; (start_idx + GF_DISK_SECTOR_SIZE) <= buf_len;
-                     start_idx += GF_DISK_SECTOR_SIZE) {
-
-                        if (mem_0filled (buf + start_idx, GF_DISK_SECTOR_SIZE) != 0) {
-                                write_needed = 1;
-                                continue;
-                        }
-
-                        if (write_needed) {
-                                ret = syncop_write (to, fd, (buf + tmp_offset),
-                                                    (start_idx - tmp_offset),
-                                                    (offset + tmp_offset),
-                                                    iobref, 0, NULL, NULL);
-                                /* 'path' will be logged in calling function */
-                                if (ret < 0) {
-                                        gf_log (THIS->name, GF_LOG_WARNING,
-                                                "failed to write (%s)",
-                                                strerror (-ret));
-                                        *fop_errno = -ret;
-                                        ret = -1;
-                                        goto out;
-                                }
-
-                                write_needed = 0;
-                        }
-                        tmp_offset = start_idx + GF_DISK_SECTOR_SIZE;
+    int i = 0;
+    int ret = -1;
+    int start_idx = 0;
+    int tmp_offset = 0;
+    int write_needed = 0;
+    int buf_len = 0;
+    int size_pending = 0;
+    char *buf = NULL;
+
+    /* loop through each vector */
+    for (i = 0; i < count; i++) {
+        buf = vec[i].iov_base;
+        buf_len = vec[i].iov_len;
+
+        for (start_idx = 0; (start_idx + GF_DISK_SECTOR_SIZE) <= buf_len;
+             start_idx += GF_DISK_SECTOR_SIZE) {
+            if (mem_0filled(buf + start_idx, GF_DISK_SECTOR_SIZE) != 0) {
+                write_needed = 1;
+                continue;
+            }
+
+            if (write_needed) {
+                ret = syncop_write(
+                    to, fd, (buf + tmp_offset), (start_idx - tmp_offset),
+                    (offset + tmp_offset), iobref, 0, NULL, NULL);
+                /* 'path' will be logged in calling function */
+                if (ret < 0) {
+                    gf_log(THIS->name, GF_LOG_WARNING, "failed to write (%s)",
+                           strerror(-ret));
+                    *fop_errno = -ret;
+                    ret = -1;
+                    goto out;
                 }
 
-                if ((start_idx < buf_len) || write_needed) {
-                        /* This means, last chunk is not yet written.. write it */
-                        ret = syncop_write (to, fd, (buf + tmp_offset),
-                                            (buf_len - tmp_offset),
-                                            (offset + tmp_offset), iobref, 0,
-                                            NULL, NULL);
-                        if (ret < 0) {
-                                /* 'path' will be logged in calling function */
-                                gf_log (THIS->name, GF_LOG_WARNING,
-                                        "failed to write (%s)",
-                                        strerror (-ret));
-                                *fop_errno = -ret;
-                                ret = -1;
-                                goto out;
-                        }
-                }
+                write_needed = 0;
+            }
+            tmp_offset = start_idx + GF_DISK_SECTOR_SIZE;
+        }
 
-                size_pending = (size - buf_len);
-                if (!size_pending)
-                        break;
+        if ((start_idx < buf_len) || write_needed) {
+            /* This means, last chunk is not yet written.. write it */
+            ret = syncop_write(to, fd, (buf + tmp_offset),
+                               (buf_len - tmp_offset), (offset + tmp_offset),
+                               iobref, 0, NULL, NULL);
+            if (ret < 0) {
+                /* 'path' will be logged in calling function */
+                gf_log(THIS->name, GF_LOG_WARNING, "failed to write (%s)",
+                       strerror(-ret));
+                *fop_errno = -ret;
+                ret = -1;
+                goto out;
+            }
         }
 
-        ret = size;
-out:
-        return ret;
+        size_pending = (size - buf_len);
+        if (!size_pending)
+            break;
+    }
 
+    ret = size;
+out:
+    return ret;
 }
 
 /*
@@ -294,323 +279,318 @@ be converted to "0" in dht_migrate_file.
 */
 
 int32_t
-gf_defrag_handle_hardlink (xlator_t *this, loc_t *loc, int *fop_errno)
+gf_defrag_handle_hardlink(xlator_t *this, loc_t *loc, int *fop_errno)
 {
-        int32_t                 ret             = -1;
-        xlator_t               *cached_subvol   = NULL;
-        xlator_t               *hashed_subvol   = NULL;
-        xlator_t               *linkto_subvol   = NULL;
-        data_t                 *data            = NULL;
-        struct iatt             iatt            = {0,};
-        int32_t                 op_errno        = 0;
-        dht_conf_t             *conf            = NULL;
-        gf_loglevel_t          loglevel         = 0;
-        dict_t                 *link_xattr      = NULL;
-        dict_t                 *dict            = NULL;
-        dict_t                 *xattr_rsp       = NULL;
-        struct iatt             stbuf                   = {0,};
-
+    int32_t ret = -1;
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *linkto_subvol = NULL;
+    data_t *data = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    int32_t op_errno = 0;
+    dht_conf_t *conf = NULL;
+    gf_loglevel_t loglevel = 0;
+    dict_t *link_xattr = NULL;
+    dict_t *dict = NULL;
+    dict_t *xattr_rsp = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+
+    *fop_errno = EINVAL;
+
+    GF_VALIDATE_OR_GOTO("defrag", loc, out);
+    GF_VALIDATE_OR_GOTO("defrag", loc->name, out);
+    GF_VALIDATE_OR_GOTO("defrag", this, out);
+    GF_VALIDATE_OR_GOTO("defrag", this->private, out);
+
+    conf = this->private;
+
+    if (gf_uuid_is_null(loc->pargfid)) {
+        gf_msg("", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "loc->pargfid is NULL for %s",
+               loc->path);
         *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    if (gf_uuid_is_null(loc->gfid)) {
+        gf_msg("", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "loc->gfid is NULL for %s",
+               loc->path);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
 
-        GF_VALIDATE_OR_GOTO ("defrag", loc, out);
-        GF_VALIDATE_OR_GOTO ("defrag", loc->name, out);
-        GF_VALIDATE_OR_GOTO ("defrag", this, out);
-        GF_VALIDATE_OR_GOTO ("defrag", this->private, out);
-
-        conf = this->private;
-
-        if (gf_uuid_is_null (loc->pargfid)) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "loc->pargfid is NULL for %s", loc->path);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        if (gf_uuid_is_null (loc->gfid)) {
-                gf_msg ("", GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "loc->gfid is NULL for %s", loc->path);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        link_xattr = dict_new ();
-        if (!link_xattr) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                goto out;
-        }
-
-        /*
-          Parallel migration can lead to migration of the hard link multiple
-          times which can lead to data loss. Hence, adding a fresh lookup to
-          decide whether migration is required or not.
-
-          Elaborating the scenario for let say 10 hardlinks [link{1..10}]:
-              Let say the first hard link "link1"  does the setxattr of the
-          new hashed subvolume info on the cached file. As there are multiple
-          threads working, we might have already all the links created on the
-          new hashed by the time we reach hardlink let say link5. Now the
-          number of links on hashed is equal to that of cached. Hence, file
-          migration will happen for link6.
-
-                 Cached                                 Hashed
-          --------T link6                        rwxrwxrwx   link6
-
-          Now post above state all the link file on the cached will be zero
-          byte linkto files. Hence, if we still do migration for the following
-          files link{7..10}, we will end up migrating 0 data leading to data
-          loss.
-                Hence, a lookup can make sure whether we need to migrate the
-          file or not.
-        */
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "could not allocate memory for dict");
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
+    link_xattr = dict_new();
+    if (!link_xattr) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        goto out;
+    }
+
+    /*
+      Parallel migration can lead to migration of the hard link multiple
+      times which can lead to data loss. Hence, adding a fresh lookup to
+      decide whether migration is required or not.
+
+      Elaborating the scenario for let say 10 hardlinks [link{1..10}]:
+          Let say the first hard link "link1"  does the setxattr of the
+      new hashed subvolume info on the cached file. As there are multiple
+      threads working, we might have already all the links created on the
+      new hashed by the time we reach hardlink let say link5. Now the
+      number of links on hashed is equal to that of cached. Hence, file
+      migration will happen for link6.
+
+             Cached                                 Hashed
+      --------T link6                        rwxrwxrwx   link6
+
+      Now post above state all the link file on the cached will be zero
+      byte linkto files. Hence, if we still do migration for the following
+      files link{7..10}, we will end up migrating 0 data leading to data
+      loss.
+            Hence, a lookup can make sure whether we need to migrate the
+      file or not.
+    */
+
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "could not allocate memory for dict");
+        goto out;
+    }
+
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to set 'linkto' key in dict",
+               loc->path);
+        goto out;
+    }
+
+    ret = syncop_lookup(this, loc, &stbuf, NULL, dict, &xattr_rsp);
+    if (ret) {
+        /*Ignore ENOENT and ESTALE as file might have been
+          migrated already*/
+        if (-ret == ENOENT || -ret == ESTALE) {
+            ret = -2;
+            goto out;
+        }
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:%s lookup failed with ret = %d", loc->path,
+               ret);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    cached_subvol = dht_subvol_get_cached(this, loc->inode);
+    if (!cached_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "Failed to get cached subvol"
+               " for %s on %s",
+               loc->name, this->name);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (!hashed_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :"
+               "Failed to get hashed subvol"
+               " for %s on %s",
+               loc->name, this->name);
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    /* Hardlink migration happens only with remove-brick. So this condition will
+     * be true only when the migration has happened. In case hardlinks are
+     * migrated for rebalance case, remove this check. Having this check here
+     * avoid redundant calls below*/
+    if (hashed_subvol == cached_subvol) {
+        ret = -2;
+        goto out;
+    }
+
+    gf_log(this->name, GF_LOG_INFO,
+           "Attempting to migrate hardlink %s "
+           "with gfid %s from %s -> %s",
+           loc->name, uuid_utoa(loc->gfid), cached_subvol->name,
+           hashed_subvol->name);
+
+    data = dict_get(xattr_rsp, conf->link_xattr_name);
+    /* set linkto on cached -> hashed if not present, else link it */
+    if (!data) {
+        ret = dict_set_str(link_xattr, conf->link_xattr_name,
+                           hashed_subvol->name);
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed :"
+                   "Failed to set dictionary value:"
+                   " key = %s for %s",
+                   conf->link_xattr_name, loc->name);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_lookup (this, loc, &stbuf, NULL, dict, &xattr_rsp);
+        ret = syncop_setxattr(cached_subvol, loc, link_xattr, 0, NULL, NULL);
         if (ret) {
-                /*Ignore ENOENT and ESTALE as file might have been
-                  migrated already*/
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        ret = -2;
-                        goto out;
-                }
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:%s lookup failed with ret = %d",
-                        loc->path, ret);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        cached_subvol = dht_subvol_get_cached (this, loc->inode);
-        if (!cached_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "Failed to get cached subvol"
-                        " for %s on %s", loc->name, this->name);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed :"
+                   "Linkto setxattr failed %s -> %s",
+                   cached_subvol->name, loc->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (!hashed_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :"
-                        "Failed to get hashed subvol"
-                        " for %s on %s", loc->name, this->name);
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        /* Hardlink migration happens only with remove-brick. So this condition will
-         * be true only when the migration has happened. In case hardlinks are migrated
-         * for rebalance case, remove this check. Having this check here avoid redundant
-         * calls below*/
-        if (hashed_subvol == cached_subvol) {
-                ret = -2;
-                goto out;
-        }
-
-        gf_log (this->name, GF_LOG_INFO, "Attempting to migrate hardlink %s "
-                "with gfid %s from %s -> %s", loc->name, uuid_utoa (loc->gfid),
-                cached_subvol->name, hashed_subvol->name);
-
-        data = dict_get (xattr_rsp, conf->link_xattr_name);
-        /* set linkto on cached -> hashed if not present, else link it */
-        if (!data) {
-                ret = dict_set_str (link_xattr, conf->link_xattr_name,
-                                    hashed_subvol->name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed :"
-                                "Failed to set dictionary value:"
-                                " key = %s for %s",
-                                conf->link_xattr_name, loc->name);
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_setxattr (cached_subvol, loc, link_xattr, 0, NULL,
-                                       NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed :"
-                                "Linkto setxattr failed %s -> %s",
-                                cached_subvol->name,
-                                loc->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
+        gf_msg_debug(this->name, 0,
+                     "hardlink target subvol created on %s "
+                     ",cached %s, file %s",
+                     hashed_subvol->name, cached_subvol->name, loc->path);
 
-                gf_msg_debug (this->name, 0, "hardlink target subvol created on %s "
-                              ",cached %s, file %s",
-                              hashed_subvol->name, cached_subvol->name, loc->path);
-
-                ret = -2;
-                goto out;
+        ret = -2;
+        goto out;
+    } else {
+        linkto_subvol = dht_linkfile_subvol(this, NULL, NULL, xattr_rsp);
+        if (!linkto_subvol) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_ERROR,
+                   "Failed to get "
+                   "linkto subvol for %s",
+                   loc->name);
         } else {
-                linkto_subvol = dht_linkfile_subvol (this, NULL, NULL, xattr_rsp);
-                if (!linkto_subvol) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SUBVOL_ERROR,
-                                "Failed to get "
-                                "linkto subvol for %s", loc->name);
-                } else {
-                        hashed_subvol = linkto_subvol;
-                }
-
-                ret = syncop_link (hashed_subvol, loc, loc, &iatt, NULL, NULL);
-                if  (ret) {
-                        op_errno = -ret;
-                        ret = -1;
-
-                        loglevel = (op_errno == EEXIST) ? GF_LOG_DEBUG : \
-                                    GF_LOG_ERROR;
-                        gf_msg (this->name, loglevel, op_errno,
-                                DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED,
-                                "link of %s -> %s"
-                                " failed on  subvol %s", loc->name,
-                                uuid_utoa(loc->gfid),
-                                hashed_subvol->name);
-                        if (op_errno != EEXIST) {
-                                *fop_errno = op_errno;
-                                goto out;
-                        }
-                } else {
-                        gf_msg_debug (this->name, 0, "syncop_link successful for"
-                                      " hardlink %s on subvol %s, cached %s", loc->path,
-                                      hashed_subvol->name, cached_subvol->name);
-
-                }
+            hashed_subvol = linkto_subvol;
         }
 
-        ret = syncop_lookup (hashed_subvol, loc, &iatt, NULL, NULL, NULL);
+        ret = syncop_link(hashed_subvol, loc, loc, &iatt, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed :Failed lookup %s on %s ",
-                        loc->name, hashed_subvol->name);
-
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
+            op_errno = -ret;
+            ret = -1;
+
+            loglevel = (op_errno == EEXIST) ? GF_LOG_DEBUG : GF_LOG_ERROR;
+            gf_msg(this->name, loglevel, op_errno,
+                   DHT_MSG_MIGRATE_HARDLINK_FILE_FAILED,
+                   "link of %s -> %s"
+                   " failed on  subvol %s",
+                   loc->name, uuid_utoa(loc->gfid), hashed_subvol->name);
+            if (op_errno != EEXIST) {
+                *fop_errno = op_errno;
+                goto out;
+            }
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "syncop_link successful for"
+                         " hardlink %s on subvol %s, cached %s",
+                         loc->path, hashed_subvol->name, cached_subvol->name);
         }
+    }
 
-        /* There is a race where on the target subvol for the hardlink
-         * (note: hash subvol for the hardlink might differ from this), some
-         * other client(non-rebalance) would have created a linkto file for that
-         * hardlink as part of lookup. So let say there are 10 hardlinks, on the
-         * 5th hardlink it self the hardlinks might have migrated. Now for
-         * (6..10th) hardlinks the cached and target would be same as the file
-         * has already migrated. Hence this check is needed  */
-        if (cached_subvol == hashed_subvol) {
-                gf_msg_debug (this->name, 0, "source %s and destination %s "
-                             "for hardlink %s are same", cached_subvol->name,
-                             hashed_subvol->name, loc->path);
-                ret = -2;
-                goto out;
-        }
+    ret = syncop_lookup(hashed_subvol, loc, &iatt, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed :Failed lookup %s on %s ", loc->name,
+               hashed_subvol->name);
 
-        if (iatt.ia_nlink == stbuf.ia_nlink) {
-                ret = dht_migrate_file (this, loc, cached_subvol, hashed_subvol,
-                                        GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS,
-                                        fop_errno);
-                if (ret) {
-                        goto out;
-                }
-        }
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* There is a race where on the target subvol for the hardlink
+     * (note: hash subvol for the hardlink might differ from this), some
+     * other client(non-rebalance) would have created a linkto file for that
+     * hardlink as part of lookup. So let say there are 10 hardlinks, on the
+     * 5th hardlink it self the hardlinks might have migrated. Now for
+     * (6..10th) hardlinks the cached and target would be same as the file
+     * has already migrated. Hence this check is needed  */
+    if (cached_subvol == hashed_subvol) {
+        gf_msg_debug(this->name, 0,
+                     "source %s and destination %s "
+                     "for hardlink %s are same",
+                     cached_subvol->name, hashed_subvol->name, loc->path);
         ret = -2;
+        goto out;
+    }
+
+    if (iatt.ia_nlink == stbuf.ia_nlink) {
+        ret = dht_migrate_file(this, loc, cached_subvol, hashed_subvol,
+                               GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS, fop_errno);
+        if (ret) {
+            goto out;
+        }
+    }
+    ret = -2;
 out:
-        if (link_xattr)
-                dict_unref (link_xattr);
+    if (link_xattr)
+        dict_unref(link_xattr);
 
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
-
-
 static int
-__check_file_has_hardlink (xlator_t *this, loc_t *loc,
-                           struct iatt *stbuf, dict_t *xattrs, int flags,
-                           gf_defrag_info_t *defrag, dht_conf_t *conf, int *fop_errno)
+__check_file_has_hardlink(xlator_t *this, loc_t *loc, struct iatt *stbuf,
+                          dict_t *xattrs, int flags, gf_defrag_info_t *defrag,
+                          dht_conf_t *conf, int *fop_errno)
 {
-       int ret = 0;
+    int ret = 0;
 
-       if (flags == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS) {
-                ret = 0;
-                return ret;
-       }
-       if (stbuf->ia_nlink > 1) {
-                /* support for decomission */
-                if (flags == GF_DHT_MIGRATE_HARDLINK) {
-                        synclock_lock (&conf->link_lock);
-                        ret = gf_defrag_handle_hardlink
-                                (this, loc, fop_errno);
-                        synclock_unlock (&conf->link_lock);
-                        /*
-                        Returning zero will force the file to be remigrated.
-                        Checkout gf_defrag_handle_hardlink for more information.
-                        */
-                        if (ret && ret != -2) {
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "Migrate file failed:"
-                                        "%s: failed to migrate file with link",
-                                        loc->path);
-                        }
-                } else {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migration skipped for:"
-                                "%s: file has hardlinks", loc->path);
-                        *fop_errno = ENOTSUP;
-                        ret = 1;
-                }
-       }
+    if (flags == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS) {
+        ret = 0;
+        return ret;
+    }
+    if (stbuf->ia_nlink > 1) {
+        /* support for decomission */
+        if (flags == GF_DHT_MIGRATE_HARDLINK) {
+            synclock_lock(&conf->link_lock);
+            ret = gf_defrag_handle_hardlink(this, loc, fop_errno);
+            synclock_unlock(&conf->link_lock);
+            /*
+            Returning zero will force the file to be remigrated.
+            Checkout gf_defrag_handle_hardlink for more information.
+            */
+            if (ret && ret != -2) {
+                gf_msg(this->name, GF_LOG_WARNING, 0,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "Migrate file failed:"
+                       "%s: failed to migrate file with link",
+                       loc->path);
+            }
+        } else {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migration skipped for:"
+                   "%s: file has hardlinks",
+                   loc->path);
+            *fop_errno = ENOTSUP;
+            ret = 1;
+        }
+    }
 
-       return ret;
+    return ret;
 }
 
-
 /*
      return values
      0 : File will be migrated
@@ -620,964 +600,911 @@ __check_file_has_hardlink (xlator_t *this, loc_t *loc,
     -1 : failure
 */
 static int
-__is_file_migratable (xlator_t *this, loc_t *loc,
-                      struct iatt *stbuf, dict_t *xattrs, int flags,
-                      gf_defrag_info_t *defrag, dht_conf_t *conf,
-                      int *fop_errno)
+__is_file_migratable(xlator_t *this, loc_t *loc, struct iatt *stbuf,
+                     dict_t *xattrs, int flags, gf_defrag_info_t *defrag,
+                     dht_conf_t *conf, int *fop_errno)
 {
-        int ret = -1;
-        int lock_count = 0;
-
-        if (IA_ISDIR (stbuf->ia_type)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: migrate-file called on directory", loc->path);
-                *fop_errno = EISDIR;
-                ret = -1;
-                goto out;
-        }
-
-        if (!conf->lock_migration_enabled) {
-                ret = dict_get_int32 (xattrs, GLUSTERFS_POSIXLK_COUNT,
-                                      &lock_count);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: Unable to get lock count for file",
-                                loc->path);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (lock_count) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: %s: File has locks."
-                                " Skipping file migration", loc->path);
-                        *fop_errno = ENOTSUP;
-                        ret = 1;
-                        goto out;
-                }
-        }
+    int ret = -1;
+    int lock_count = 0;
+
+    if (IA_ISDIR(stbuf->ia_type)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: migrate-file called on directory",
+               loc->path);
+        *fop_errno = EISDIR;
+        ret = -1;
+        goto out;
+    }
 
-        /* Check if file has hardlink*/
-        ret = __check_file_has_hardlink (this, loc, stbuf, xattrs,
-                                         flags, defrag, conf, fop_errno);
+    if (!conf->lock_migration_enabled) {
+        ret = dict_get_int32(xattrs, GLUSTERFS_POSIXLK_COUNT, &lock_count);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: Unable to get lock count for file",
+                   loc->path);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+
+        if (lock_count) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: %s: File has locks."
+                   " Skipping file migration",
+                   loc->path);
+            *fop_errno = ENOTSUP;
+            ret = 1;
+            goto out;
+        }
+    }
+
+    /* Check if file has hardlink*/
+    ret = __check_file_has_hardlink(this, loc, stbuf, xattrs, flags, defrag,
+                                    conf, fop_errno);
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-__dht_rebalance_create_dst_file (xlator_t *this, xlator_t *to, xlator_t *from,
-                                 loc_t *loc, struct iatt *stbuf, fd_t **dst_fd,
-                                 int *fop_errno)
+__dht_rebalance_create_dst_file(xlator_t *this, xlator_t *to, xlator_t *from,
+                                loc_t *loc, struct iatt *stbuf, fd_t **dst_fd,
+                                int *fop_errno)
 {
-        int          ret  = -1;
-        int          ret2 = -1;
-        fd_t        *fd   = NULL;
-        struct iatt  new_stbuf = {0,};
-        struct iatt  check_stbuf= {0,};
-        dht_conf_t  *conf = NULL;
-        dict_t      *dict = NULL;
-        dict_t      *xdata = NULL;
-
-        conf = this->private;
+    int ret = -1;
+    int ret2 = -1;
+    fd_t *fd = NULL;
+    struct iatt new_stbuf = {
+        0,
+    };
+    struct iatt check_stbuf = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+    dict_t *dict = NULL;
+    dict_t *xdata = NULL;
+
+    conf = this->private;
+
+    dict = dict_new();
+    if (!dict) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "dictionary allocation failed for"
+               "path:%s",
+               loc->path);
+        goto out;
+    }
+    ret = dict_set_gfuuid(dict, "gfid-req", stbuf->ia_gfid, true);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: failed to set dictionary value: key = gfid-req", loc->path);
+        goto out;
+    }
+
+    ret = dict_set_str(dict, conf->link_xattr_name, from->name);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: failed to set dictionary value: key = %s ", loc->path,
+               conf->link_xattr_name);
+        goto out;
+    }
+
+    fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+    if (!fd) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: fd create failed (destination)", loc->path);
+        goto out;
+    }
 
-        dict = dict_new ();
-        if (!dict) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY, "dictionary allocation failed for"
-                        "path:%s", loc->path);
-                goto out;
-        }
-        ret = dict_set_gfuuid (dict, "gfid-req", stbuf->ia_gfid, true);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: failed to set dictionary value: key = gfid-req",
-                        loc->path);
-                goto out;
+    if (!!dht_is_tier_xlator(this)) {
+        xdata = dict_new();
+        if (!xdata) {
+            *fop_errno = ENOMEM;
+            ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
+                   DHT_MSG_MIGRATE_FILE_FAILED, "%s: dict_new failed)",
+                   loc->path);
+            goto out;
         }
 
-        ret = dict_set_str (dict, conf->link_xattr_name, from->name);
+        ret = dict_set_int32(xdata, GF_CLEAN_WRITE_PROTECTION, 1);
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "%s: failed to set dictionary value: key = %s ",
-                        loc->path, conf->link_xattr_name);
-                goto out;
-        }
-
-        fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-        if (!fd) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: fd create failed (destination)",
-                        loc->path);
-                goto out;
-        }
-
-        if (!!dht_is_tier_xlator (this)) {
-                xdata = dict_new ();
-                if (!xdata) {
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: dict_new failed)",
-                                loc->path);
-                        goto out;
-                }
-
-                ret = dict_set_int32 (xdata, GF_CLEAN_WRITE_PROTECTION, 1);
-                if (ret) {
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: failed to set dictionary value: key = %s ",
-                                loc->path, GF_CLEAN_WRITE_PROTECTION);
-                        goto out;
-                }
-        }
-
-        ret = syncop_lookup (to, loc, &new_stbuf, NULL, xdata, NULL);
-        if (!ret) {
-                /* File exits in the destination, check if gfid matches */
-                if (gf_uuid_compare (stbuf->ia_gfid, new_stbuf.ia_gfid) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "file %s exists in %s with different gfid",
-                                loc->path, to->name);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-        }
-        if ((ret < 0) && (-ret != ENOENT)) {
-                /* File exists in destination, but not accessible */
-                gf_msg (THIS->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to lookup file",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        /* Create the destination with LINKFILE mode, and linkto xattr,
-           if the linkfile already exists, just open the file */
-        if (!ret) {
-                /*
-                 * File already present, just open the file.
-                 */
-                ret = syncop_open (to, loc, O_RDWR, fd, NULL, NULL);
-                 if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "failed to open %s on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                 }
-        } else {
-                ret = syncop_create (to, loc, O_RDWR, DHT_LINKFILE_MODE, fd,
-                                     &new_stbuf, dict, NULL);
-                 if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "failed to create %s on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-        }
-
-        fd_bind (fd);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: failed to set dictionary value: key = %s ", loc->path,
+                   GF_CLEAN_WRITE_PROTECTION);
+            goto out;
+        }
+    }
+
+    ret = syncop_lookup(to, loc, &new_stbuf, NULL, xdata, NULL);
+    if (!ret) {
+        /* File exits in the destination, check if gfid matches */
+        if (gf_uuid_compare(stbuf->ia_gfid, new_stbuf.ia_gfid) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+                   "file %s exists in %s with different gfid", loc->path,
+                   to->name);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+    }
+    if ((ret < 0) && (-ret != ENOENT)) {
+        /* File exists in destination, but not accessible */
+        gf_msg(THIS->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to lookup file", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        /*Reason of doing lookup after create again:
-         *In the create, there is some time-gap between opening fd at the
-         *server (posix_layer) and binding it in server (incrementing fd count),
-         *so if in that time-gap, if other process sends unlink considering it
-         *as a linkto file, because inode->fd count will be 0, so file will be
-         *unlinked at the backend. And because further operations are performed
-         *on fd, so though migration will be done but will end with no file
-         *at  the backend.
+    /* Create the destination with LINKFILE mode, and linkto xattr,
+       if the linkfile already exists, just open the file */
+    if (!ret) {
+        /*
+         * File already present, just open the file.
          */
-
-        ret = syncop_lookup (to, loc, &check_stbuf, NULL, NULL, NULL);
-        if (!ret) {
-
-                if (gf_uuid_compare (stbuf->ia_gfid, check_stbuf.ia_gfid) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_GFID_MISMATCH,
-                                "file %s exists in %s with different gfid,"
-                                "found in lookup after create",
-                                loc->path, to->name);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
+        ret = syncop_open(to, loc, O_RDWR, fd, NULL, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to open %s on %s", loc->path, to->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    } else {
+        ret = syncop_create(to, loc, O_RDWR, DHT_LINKFILE_MODE, fd, &new_stbuf,
+                            dict, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to create %s on %s", loc->path, to->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    fd_bind(fd);
+
+    /*Reason of doing lookup after create again:
+     *In the create, there is some time-gap between opening fd at the
+     *server (posix_layer) and binding it in server (incrementing fd count),
+     *so if in that time-gap, if other process sends unlink considering it
+     *as a linkto file, because inode->fd count will be 0, so file will be
+     *unlinked at the backend. And because further operations are performed
+     *on fd, so though migration will be done but will end with no file
+     *at  the backend.
+     */
+
+    ret = syncop_lookup(to, loc, &check_stbuf, NULL, NULL, NULL);
+    if (!ret) {
+        if (gf_uuid_compare(stbuf->ia_gfid, check_stbuf.ia_gfid) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_GFID_MISMATCH,
+                   "file %s exists in %s with different gfid,"
+                   "found in lookup after create",
+                   loc->path, to->name);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    if (-ret == ENOENT) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: file does not exist"
+               "on %s",
+               loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_fsetattr(to, fd, stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
+                          NULL, NULL, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "chown failed for %s on %s", loc->path, to->name);
+    }
+
+    /* No need to bother about 0 byte size files */
+    if (stbuf->ia_size > 0) {
+        if (conf->use_fallocate) {
+            ret = syncop_fallocate(to, fd, 0, 0, stbuf->ia_size, NULL, NULL);
+            if (ret < 0) {
+                if (ret == -EOPNOTSUPP || ret == -EINVAL || ret == -ENOSYS) {
+                    conf->use_fallocate = _gf_false;
+                } else {
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_MIGRATE_FILE_FAILED,
+                           "fallocate failed for %s on %s", loc->path,
+                           to->name);
+
+                    *fop_errno = -ret;
+
+                    /* fallocate does not release the space
+                     * in some cases
+                     */
+                    ret2 = syncop_ftruncate(to, fd, 0, NULL, NULL, NULL, NULL);
+                    if (ret2 < 0) {
+                        gf_msg(this->name, GF_LOG_WARNING, -ret2,
+                               DHT_MSG_MIGRATE_FILE_FAILED,
+                               "ftruncate failed for "
+                               "%s on %s",
+                               loc->path, to->name);
+                    }
+                    goto out;
                 }
-
+            }
         }
 
-        if (-ret == ENOENT) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED, "%s: file does not exist"
-                        "on %s", loc->path, to->name);
+        if (!conf->use_fallocate) {
+            ret = syncop_ftruncate(to, fd, stbuf->ia_size, NULL, NULL, NULL,
+                                   NULL);
+            if (ret < 0) {
                 *fop_errno = -ret;
-                ret = -1;
-                goto out;
+                gf_msg(this->name, GF_LOG_WARNING, -ret,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "ftruncate failed for %s on %s", loc->path, to->name);
+            }
         }
+    }
 
-        ret = syncop_fsetattr (to, fd, stbuf,
-                               (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
-                                NULL, NULL, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "chown failed for %s on %s",
-                        loc->path, to->name);
-        }
+    /* success */
+    ret = 0;
 
-        /* No need to bother about 0 byte size files */
-        if (stbuf->ia_size > 0) {
-                if (conf->use_fallocate) {
-                        ret = syncop_fallocate (to, fd, 0, 0, stbuf->ia_size,
-                                                NULL, NULL);
-                        if (ret < 0) {
-                                if (ret == -EOPNOTSUPP || ret == -EINVAL ||
-                                    ret == -ENOSYS) {
-                                        conf->use_fallocate = _gf_false;
-                                } else {
-                                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "fallocate failed for %s on %s",
-                                                loc->path, to->name);
-
-                                        *fop_errno = -ret;
-
-                                        /* fallocate does not release the space
-                                         * in some cases
-                                         */
-                                        ret2 = syncop_ftruncate (to, fd, 0,
-                                                                 NULL, NULL,
-                                                                 NULL, NULL);
-                                        if (ret2 < 0) {
-                                                gf_msg (this->name,
-                                                        GF_LOG_WARNING, -ret2,
-                                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                                        "ftruncate failed for "
-                                                        "%s on %s",
-                                                        loc->path, to->name);
-                                        }
-                                        goto out;
-                                }
-                        }
-                }
-
-                if (!conf->use_fallocate) {
-                        ret = syncop_ftruncate (to, fd, stbuf->ia_size, NULL,
-                                                NULL, NULL, NULL);
-                        if (ret < 0) {
-                                *fop_errno = -ret;
-                                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "ftruncate failed for %s on %s",
-                                        loc->path, to->name);
-                        }
-                }
-        }
-
-        /* success */
-        ret = 0;
-
-        if (dst_fd)
-                *dst_fd = fd;
+    if (dst_fd)
+        *dst_fd = fd;
 
 out:
-        if (ret) {
-                if (fd) {
-                        fd_unref (fd);
-                }
+    if (ret) {
+        if (fd) {
+            fd_unref(fd);
         }
-        if (dict)
-                dict_unref (dict);
-
-        if (xdata)
-                dict_unref (dict);
+    }
+    if (dict)
+        dict_unref(dict);
 
+    if (xdata)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 static int
-__dht_check_free_space (xlator_t *this, xlator_t *to, xlator_t *from,
-                        loc_t *loc, struct iatt *stbuf, int flag,
-                        dht_conf_t *conf, gf_boolean_t *target_changed,
-                        xlator_t **new_subvol, int *fop_errno)
+__dht_check_free_space(xlator_t *this, xlator_t *to, xlator_t *from, loc_t *loc,
+                       struct iatt *stbuf, int flag, dht_conf_t *conf,
+                       gf_boolean_t *target_changed, xlator_t **new_subvol,
+                       int *fop_errno)
 {
-        struct statvfs  src_statfs = {0,};
-        struct statvfs  dst_statfs = {0,};
-        int             ret        = -1;
-        dict_t         *xdata      = NULL;
-        dht_layout_t   *layout     = NULL;
-        uint64_t        src_statfs_blocks = 1;
-        uint64_t        dst_statfs_blocks = 1;
-        double          dst_post_availspacepercent = 0;
-        double          src_post_availspacepercent = 0;
-        uint64_t        file_blocks = 0;
-        uint64_t        src_total_blocks = 0;
-        uint64_t        dst_total_blocks = 0;
-
-        xdata = dict_new ();
-        if (!xdata) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY,
-                        "failed to allocate dictionary");
-                goto out;
-        }
-
-        ret = dict_set_int8 (xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set "
-                        GF_INTERNAL_IGNORE_DEEM_STATFS" in dict");
-                ret = -1;
-                *fop_errno = ENOMEM;
-                goto out;
-        }
-
-        ret = syncop_statfs (from, loc, &src_statfs, xdata, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to get statfs of %s on %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_statfs (to, loc, &dst_statfs, xdata, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to get statfs of %s on %s",
-                        loc->path, to->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0, "min_free_disk - %f , block available - "
-                      "%lu , block size - %lu ", conf->min_free_disk,
-                      dst_statfs.f_bavail, dst_statfs.f_bsize);
-
-        dst_statfs_blocks = dst_statfs.f_bavail *
-                            (dst_statfs.f_frsize /
-                            GF_DISK_SECTOR_SIZE);
-
-        src_statfs_blocks = src_statfs.f_bavail *
-                            (src_statfs.f_frsize /
-                            GF_DISK_SECTOR_SIZE);
-
-        dst_total_blocks = dst_statfs.f_blocks *
-                           (dst_statfs.f_frsize /
-                           GF_DISK_SECTOR_SIZE);
-
-        src_total_blocks = src_statfs.f_blocks *
-                           (src_statfs.f_frsize /
-                           GF_DISK_SECTOR_SIZE);
-
-        /* if force option is given, do not check for space @ dst.
-         * Check only if space is avail for the file */
-        if (flag != GF_DHT_MIGRATE_DATA)
-                goto check_avail_space;
-
-        /* Check:
-           During rebalance `migrate-data` - Destination subvol experiences
-           a `reduction` in 'blocks' of free space, at the same time source
-           subvol gains certain 'blocks' of free space. A valid check is
-           necessary here to avoid erroneous move to destination where
-           the space could be scantily available.
-           With heterogeneous brick support, an actual space comparison could
-           prevent any files being migrated to newly added bricks if they are
-           smaller then the free space available on the existing bricks.
-         */
-        if (stbuf) {
-                if (!conf->use_fallocate) {
-                        file_blocks = stbuf->ia_size + GF_DISK_SECTOR_SIZE - 1;
-                        file_blocks /= GF_DISK_SECTOR_SIZE;
-
-                        if (file_blocks >= dst_statfs_blocks) {
-                                dst_statfs_blocks = 0;
-                        } else {
-                                dst_statfs_blocks -= file_blocks;
-                        }
-                }
-
-                src_post_availspacepercent =
-                        ((src_statfs_blocks + file_blocks) * 100) / src_total_blocks;
-
-                dst_post_availspacepercent =
-                        (dst_statfs_blocks * 100) / dst_total_blocks;
-
-                if (dst_post_availspacepercent < src_post_availspacepercent) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "data movement of file "
-                                "{blocks:%"PRIu64" name:(%s)} would result in "
-                                "dst node (%s:%"PRIu64") having lower disk "
-                                "space than the source node (%s:%"PRIu64")"
-                                ".Skipping file.", stbuf->ia_blocks, loc->path,
-                                to->name, dst_statfs_blocks, from->name,
-                                src_statfs_blocks);
-
-                        /* this is not a 'failure', but we don't want to
-                           consider this as 'success' too :-/ */
-                        *fop_errno = ENOSPC;
-                        ret = 1;
-                        goto out;
-                }
-        }
+    struct statvfs src_statfs = {
+        0,
+    };
+    struct statvfs dst_statfs = {
+        0,
+    };
+    int ret = -1;
+    dict_t *xdata = NULL;
+    dht_layout_t *layout = NULL;
+    uint64_t src_statfs_blocks = 1;
+    uint64_t dst_statfs_blocks = 1;
+    double dst_post_availspacepercent = 0;
+    double src_post_availspacepercent = 0;
+    uint64_t file_blocks = 0;
+    uint64_t src_total_blocks = 0;
+    uint64_t dst_total_blocks = 0;
+
+    xdata = dict_new();
+    if (!xdata) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "failed to allocate dictionary");
+        goto out;
+    }
+
+    ret = dict_set_int8(xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
+        ret = -1;
+        *fop_errno = ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_statfs(from, loc, &src_statfs, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to get statfs of %s on %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_statfs(to, loc, &dst_statfs, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to get statfs of %s on %s", loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0,
+                 "min_free_disk - %f , block available - "
+                 "%lu , block size - %lu ",
+                 conf->min_free_disk, dst_statfs.f_bavail, dst_statfs.f_bsize);
+
+    dst_statfs_blocks = dst_statfs.f_bavail *
+                        (dst_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    src_statfs_blocks = src_statfs.f_bavail *
+                        (src_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    dst_total_blocks = dst_statfs.f_blocks *
+                       (dst_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    src_total_blocks = src_statfs.f_blocks *
+                       (src_statfs.f_frsize / GF_DISK_SECTOR_SIZE);
+
+    /* if force option is given, do not check for space @ dst.
+     * Check only if space is avail for the file */
+    if (flag != GF_DHT_MIGRATE_DATA)
+        goto check_avail_space;
+
+    /* Check:
+       During rebalance `migrate-data` - Destination subvol experiences
+       a `reduction` in 'blocks' of free space, at the same time source
+       subvol gains certain 'blocks' of free space. A valid check is
+       necessary here to avoid erroneous move to destination where
+       the space could be scantily available.
+       With heterogeneous brick support, an actual space comparison could
+       prevent any files being migrated to newly added bricks if they are
+       smaller then the free space available on the existing bricks.
+     */
+    if (stbuf) {
+        if (!conf->use_fallocate) {
+            file_blocks = stbuf->ia_size + GF_DISK_SECTOR_SIZE - 1;
+            file_blocks /= GF_DISK_SECTOR_SIZE;
+
+            if (file_blocks >= dst_statfs_blocks) {
+                dst_statfs_blocks = 0;
+            } else {
+                dst_statfs_blocks -= file_blocks;
+            }
+        }
+
+        src_post_availspacepercent = ((src_statfs_blocks + file_blocks) * 100) /
+                                     src_total_blocks;
+
+        dst_post_availspacepercent = (dst_statfs_blocks * 100) /
+                                     dst_total_blocks;
+
+        if (dst_post_availspacepercent < src_post_availspacepercent) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "data movement of file "
+                   "{blocks:%" PRIu64
+                   " name:(%s)} would result in "
+                   "dst node (%s:%" PRIu64
+                   ") having lower disk "
+                   "space than the source node (%s:%" PRIu64
+                   ")"
+                   ".Skipping file.",
+                   stbuf->ia_blocks, loc->path, to->name, dst_statfs_blocks,
+                   from->name, src_statfs_blocks);
+
+            /* this is not a 'failure', but we don't want to
+               consider this as 'success' too :-/ */
+            *fop_errno = ENOSPC;
+            ret = 1;
+            goto out;
+        }
+    }
 
 check_avail_space:
-        if (conf->disk_unit == 'p' && dst_statfs.f_blocks) {
-                dst_post_availspacepercent =
-                        (dst_statfs_blocks * 100) / dst_total_blocks;
-
-                gf_msg_debug (this->name, 0, "file : %s, post_availspacepercent"
-                              " : %lf f_bavail : %lu min-free-disk: %lf",
-                              loc->path, dst_post_availspacepercent,
-                              dst_statfs.f_bavail, conf->min_free_disk);
-
-                if (dst_post_availspacepercent < conf->min_free_disk) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0, 0,
-                                "Write will cross min-free-disk for "
-                                "file - %s on subvol - %s. Looking "
-                                "for new subvol", loc->path, to->name);
-
-                        goto find_new_subvol;
-                } else {
-                        ret = 0;
-                        goto out;
-                }
+    if (conf->disk_unit == 'p' && dst_statfs.f_blocks) {
+        dst_post_availspacepercent = (dst_statfs_blocks * 100) /
+                                     dst_total_blocks;
+
+        gf_msg_debug(this->name, 0,
+                     "file : %s, post_availspacepercent"
+                     " : %lf f_bavail : %lu min-free-disk: %lf",
+                     loc->path, dst_post_availspacepercent, dst_statfs.f_bavail,
+                     conf->min_free_disk);
+
+        if (dst_post_availspacepercent < conf->min_free_disk) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, 0,
+                   "Write will cross min-free-disk for "
+                   "file - %s on subvol - %s. Looking "
+                   "for new subvol",
+                   loc->path, to->name);
+
+            goto find_new_subvol;
+        } else {
+            ret = 0;
+            goto out;
         }
+    }
 
-        if (conf->disk_unit != 'p') {
-                if ((dst_statfs_blocks * GF_DISK_SECTOR_SIZE) <
-                                                      conf->min_free_disk) {
-                        gf_msg_debug (this->name, 0, "file : %s,  destination "
-                                      "frsize: %lu f_bavail : %lu "
-                                      "min-free-disk: %lf", loc->path,
-                                      dst_statfs.f_frsize, dst_statfs.f_bavail,
-                                      conf->min_free_disk);
+    if (conf->disk_unit != 'p') {
+        if ((dst_statfs_blocks * GF_DISK_SECTOR_SIZE) < conf->min_free_disk) {
+            gf_msg_debug(this->name, 0,
+                         "file : %s,  destination "
+                         "frsize: %lu f_bavail : %lu "
+                         "min-free-disk: %lf",
+                         loc->path, dst_statfs.f_frsize, dst_statfs.f_bavail,
+                         conf->min_free_disk);
 
-                        gf_msg (this->name, GF_LOG_WARNING, 0, 0, "write will"
-                                " cross min-free-disk for file - %s on subvol -"
-                                " %s. looking for new subvol", loc->path,
-                                to->name);
+            gf_msg(this->name, GF_LOG_WARNING, 0, 0,
+                   "write will"
+                   " cross min-free-disk for file - %s on subvol -"
+                   " %s. looking for new subvol",
+                   loc->path, to->name);
 
-                        goto find_new_subvol;
+            goto find_new_subvol;
 
-                } else {
-                        ret = 0;
-                        goto out;
-                }
+        } else {
+            ret = 0;
+            goto out;
         }
+    }
 
 find_new_subvol:
-        layout = dht_layout_get (this, loc->parent);
-        if (!layout) {
-                gf_log (this->name, GF_LOG_ERROR, "Layout is NULL");
-                *fop_errno = EINVAL;
-                ret = -1;
-                goto out;
-        }
-
-        *new_subvol = dht_subvol_with_free_space_inodes (this, to, from, layout,
-                                                         stbuf->ia_size);
-        if ((!(*new_subvol)) || (*new_subvol == from)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_SUBVOL_INSUFF_SPACE, "Could not find any subvol"
-                        " with space accommodating the file - %s. Consider "
-                        "adding bricks", loc->path);
-
-                *target_changed = _gf_false;
-                *fop_errno = ENOSPC;
-                ret = -1;
-        } else {
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "new target found - %s"
-                        " for file - %s", (*new_subvol)->name, loc->path);
-                *target_changed = _gf_true;
-                ret = 0;
-        }
+    layout = dht_layout_get(this, loc->parent);
+    if (!layout) {
+        gf_log(this->name, GF_LOG_ERROR, "Layout is NULL");
+        *fop_errno = EINVAL;
+        ret = -1;
+        goto out;
+    }
+
+    *new_subvol = dht_subvol_with_free_space_inodes(this, to, from, layout,
+                                                    stbuf->ia_size);
+    if ((!(*new_subvol)) || (*new_subvol == from)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+               "Could not find any subvol"
+               " with space accommodating the file - %s. Consider "
+               "adding bricks",
+               loc->path);
+
+        *target_changed = _gf_false;
+        *fop_errno = ENOSPC;
+        ret = -1;
+    } else {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "new target found - %s"
+               " for file - %s",
+               (*new_subvol)->name, loc->path);
+        *target_changed = _gf_true;
+        ret = 0;
+    }
 
 out:
-        if (xdata)
-                dict_unref (xdata);
-        return ret;
+    if (xdata)
+        dict_unref(xdata);
+    return ret;
 }
 
 static int
-__dht_rebalance_migrate_data (xlator_t *this, gf_defrag_info_t *defrag,
-                              xlator_t *from, xlator_t *to, fd_t *src,
-                              fd_t *dst, uint64_t ia_size, int hole_exists,
-                              int *fop_errno)
+__dht_rebalance_migrate_data(xlator_t *this, gf_defrag_info_t *defrag,
+                             xlator_t *from, xlator_t *to, fd_t *src, fd_t *dst,
+                             uint64_t ia_size, int hole_exists, int *fop_errno)
 {
-        int            ret    = 0;
-        int            count  = 0;
-        off_t          offset = 0;
-        struct iovec  *vector = NULL;
-        struct iobref *iobref = NULL;
-        uint64_t       total  = 0;
-        size_t         read_size = 0;
-        dict_t        *xdata = NULL;
-        dht_conf_t    *conf  = NULL;
-
-        conf = this->private;
-        /* if file size is '0', no need to enter this loop */
-        while (total < ia_size) {
-                read_size = (((ia_size - total) > DHT_REBALANCE_BLKSIZE) ?
-                             DHT_REBALANCE_BLKSIZE : (ia_size - total));
-
-                ret = syncop_readv (from, src, read_size,
-                                    offset, 0, &vector, &count, &iobref, NULL,
-                                    NULL, NULL);
-                if (!ret || (ret < 0)) {
-                        *fop_errno = -ret;
-                        break;
-                }
-
-                if (hole_exists) {
-                        ret = dht_write_with_holes (to, dst, vector, count,
-                                                    ret, offset, iobref,
-                                                    fop_errno);
-                } else {
-                        if (!conf->force_migration &&
-                            !dht_is_tier_xlator (this)) {
-                                xdata = dict_new ();
-                                if (!xdata) {
-                                        gf_msg ("dht", GF_LOG_ERROR, 0,
-                                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "insufficient memory");
-                                        ret = -1;
-                                        *fop_errno = ENOMEM;
-                                        break;
-                                }
-
-                                /* Fail this write and abort rebalance if we
-                                 * detect a write from client since migration of
-                                 * this file started. This is done to avoid
-                                 * potential data corruption due to out of order
-                                 * writes from rebalance and client to the same
-                                 * region (as compared between src and dst
-                                 * files). See
-                                 * https://github.com/gluster/glusterfs/issues/308
-                                 * for more details.
-                                 */
-                                ret = dict_set_int32 (xdata,
-                                                      GF_AVOID_OVERWRITE, 1);
-                                if (ret) {
-                                        gf_msg ("dht", GF_LOG_ERROR, 0,
-                                                ENOMEM, "failed to set dict");
-                                        ret = -1;
-                                        *fop_errno = ENOMEM;
-                                        break;
-                                }
-
-                        }
-
-                        ret = syncop_writev (to, dst, vector, count,
-                                             offset, iobref, 0, NULL, NULL,
-                                             xdata, NULL);
-                        if (ret < 0) {
-                                *fop_errno = -ret;
-                        }
-                }
-
-                if ((defrag && defrag->cmd == GF_DEFRAG_CMD_START_TIER) &&
-                    (gf_defrag_get_pause_state (&defrag->tier_conf) != TIER_RUNNING)) {
-                        gf_msg ("tier", GF_LOG_INFO, 0,
-                                DHT_MSG_TIER_PAUSED,
-                                "Migrate file paused");
-                        ret = -1;
+    int ret = 0;
+    int count = 0;
+    off_t offset = 0;
+    struct iovec *vector = NULL;
+    struct iobref *iobref = NULL;
+    uint64_t total = 0;
+    size_t read_size = 0;
+    dict_t *xdata = NULL;
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+    /* if file size is '0', no need to enter this loop */
+    while (total < ia_size) {
+        read_size = (((ia_size - total) > DHT_REBALANCE_BLKSIZE)
+                         ? DHT_REBALANCE_BLKSIZE
+                         : (ia_size - total));
+
+        ret = syncop_readv(from, src, read_size, offset, 0, &vector, &count,
+                           &iobref, NULL, NULL, NULL);
+        if (!ret || (ret < 0)) {
+            *fop_errno = -ret;
+            break;
+        }
+
+        if (hole_exists) {
+            ret = dht_write_with_holes(to, dst, vector, count, ret, offset,
+                                       iobref, fop_errno);
+        } else {
+            if (!conf->force_migration && !dht_is_tier_xlator(this)) {
+                xdata = dict_new();
+                if (!xdata) {
+                    gf_msg("dht", GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                           "insufficient memory");
+                    ret = -1;
+                    *fop_errno = ENOMEM;
+                    break;
                 }
 
-                if (ret < 0) {
-                        break;
+                /* Fail this write and abort rebalance if we
+                 * detect a write from client since migration of
+                 * this file started. This is done to avoid
+                 * potential data corruption due to out of order
+                 * writes from rebalance and client to the same
+                 * region (as compared between src and dst
+                 * files). See
+                 * https://github.com/gluster/glusterfs/issues/308
+                 * for more details.
+                 */
+                ret = dict_set_int32(xdata, GF_AVOID_OVERWRITE, 1);
+                if (ret) {
+                    gf_msg("dht", GF_LOG_ERROR, 0, ENOMEM,
+                           "failed to set dict");
+                    ret = -1;
+                    *fop_errno = ENOMEM;
+                    break;
                 }
+            }
 
-                offset += ret;
-                total += ret;
-
-                GF_FREE (vector);
-                if (iobref)
-                        iobref_unref (iobref);
-                iobref = NULL;
-                vector = NULL;
-        }
-        if (iobref)
-                iobref_unref (iobref);
-        GF_FREE (vector);
-
-        if (ret >= 0)
-                ret = 0;
-        else
-                ret = -1;
-
-        if (xdata) {
-                dict_unref (xdata);
+            ret = syncop_writev(to, dst, vector, count, offset, iobref, 0, NULL,
+                                NULL, xdata, NULL);
+            if (ret < 0) {
+                *fop_errno = -ret;
+            }
         }
 
-        return ret;
-}
-
-
-static int
-__dht_rebalance_open_src_file (xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
-                               struct iatt *stbuf, fd_t **src_fd,
-                               gf_boolean_t *clean_src, int *fop_errno)
-{
-
-        int          ret  = 0;
-        fd_t        *fd   = NULL;
-        dict_t      *dict = NULL;
-        struct iatt  iatt = {0,};
-        dht_conf_t  *conf = NULL;
-
-        conf = this->private;
-
-        *clean_src = _gf_false;
-
-        fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-        if (!fd) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: fd create failed (source)", loc->path);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
+        if ((defrag && defrag->cmd == GF_DEFRAG_CMD_START_TIER) &&
+            (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING)) {
+            gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_TIER_PAUSED,
+                   "Migrate file paused");
+            ret = -1;
         }
 
-        ret = syncop_open (from, loc, O_RDWR, fd, NULL, NULL);
         if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to open file %s on %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
+            break;
         }
 
-        fd_bind (fd);
-
-        if (src_fd)
-                *src_fd = fd;
+        offset += ret;
+        total += ret;
 
+        GF_FREE(vector);
+        if (iobref)
+            iobref_unref(iobref);
+        iobref = NULL;
+        vector = NULL;
+    }
+    if (iobref)
+        iobref_unref(iobref);
+    GF_FREE(vector);
+
+    if (ret >= 0)
+        ret = 0;
+    else
         ret = -1;
-        dict = dict_new ();
-        if (!dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: Could not allocate memory for dict", loc->path);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
 
-        ret = dict_set_str (dict, conf->link_xattr_name, to->name);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to set xattr in dict for %s (linkto:%s)",
-                        loc->path, to->name);
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
+    if (xdata) {
+        dict_unref(xdata);
+    }
 
-        /* Once the migration starts, the source should have 'linkto' key set
-           to show which is the target, so other clients can work around it */
-        ret = syncop_setxattr (from, loc, dict, 0, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to set xattr on %s in %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+    return ret;
+}
 
-        /* Reset source mode/xattr if migration fails*/
-        *clean_src = _gf_true;
+static int
+__dht_rebalance_open_src_file(xlator_t *this, xlator_t *from, xlator_t *to,
+                              loc_t *loc, struct iatt *stbuf, fd_t **src_fd,
+                              gf_boolean_t *clean_src, int *fop_errno)
+{
+    int ret = 0;
+    fd_t *fd = NULL;
+    dict_t *dict = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dht_conf_t *conf = NULL;
+
+    conf = this->private;
+
+    *clean_src = _gf_false;
+
+    fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+    if (!fd) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: fd create failed (source)", loc->path);
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_open(from, loc, O_RDWR, fd, NULL, NULL);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to open file %s on %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-        /* mode should be (+S+T) to indicate migration is in progress */
-        iatt.ia_prot = stbuf->ia_prot;
-        iatt.ia_type = stbuf->ia_type;
-        iatt.ia_prot.sticky = 1;
-        iatt.ia_prot.sgid = 1;
+    fd_bind(fd);
 
-        ret = syncop_setattr (from, loc, &iatt, GF_SET_ATTR_MODE, NULL, NULL,
-                              NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "failed to set mode on %s in %s",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+    if (src_fd)
+        *src_fd = fd;
 
-        /* success */
-        ret = 0;
+    ret = -1;
+    dict = dict_new();
+    if (!dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: Could not allocate memory for dict", loc->path);
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_str(dict, conf->link_xattr_name, to->name);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set xattr in dict for %s (linkto:%s)", loc->path,
+               to->name);
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+
+    /* Once the migration starts, the source should have 'linkto' key set
+       to show which is the target, so other clients can work around it */
+    ret = syncop_setxattr(from, loc, dict, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to set xattr on %s in %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* Reset source mode/xattr if migration fails*/
+    *clean_src = _gf_true;
+
+    /* mode should be (+S+T) to indicate migration is in progress */
+    iatt.ia_prot = stbuf->ia_prot;
+    iatt.ia_type = stbuf->ia_type;
+    iatt.ia_prot.sticky = 1;
+    iatt.ia_prot.sgid = 1;
+
+    ret = syncop_setattr(from, loc, &iatt, GF_SET_ATTR_MODE, NULL, NULL, NULL,
+                         NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "failed to set mode on %s in %s", loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* success */
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int
-migrate_special_files (xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
-                       struct iatt *buf, int *fop_errno)
+migrate_special_files(xlator_t *this, xlator_t *from, xlator_t *to, loc_t *loc,
+                      struct iatt *buf, int *fop_errno)
 {
-        int          ret      = -1;
-        dict_t      *rsp_dict = NULL;
-        dict_t      *dict     = NULL;
-        char        *link     = NULL;
-        struct iatt  stbuf    = {0,};
-        dht_conf_t  *conf     = this->private;
-
-        dict = dict_new ();
-        if (!dict) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                goto out;
-        }
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
-        if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
-        }
-
-        /* check in the destination if the file is link file */
-        ret = syncop_lookup (to, loc, &stbuf, NULL, dict, &rsp_dict);
-        if ((ret < 0) && (-ret != ENOENT)) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: lookup failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
-
-        /* we no more require this key */
-        dict_del (dict, conf->link_xattr_name);
-
-        /* file exists in target node, only if it is 'linkfile' its valid,
-           otherwise, error out */
-        if (!ret) {
-                if (!check_is_linkfile (loc->inode, &stbuf, rsp_dict,
-                                        conf->link_xattr_name)) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: file exists in destination", loc->path);
-                        *fop_errno = EINVAL;
-                        ret = -1;
-                        goto out;
-                }
-
-                /* as file is linkfile, delete it */
-                ret = syncop_unlink (to, loc, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to delete the linkfile",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-        /* Set the gfid of the source file in dict */
-        ret = dict_set_gfuuid (dict, "gfid-req", buf->ia_gfid, true);
+    int ret = -1;
+    dict_t *rsp_dict = NULL;
+    dict_t *dict = NULL;
+    char *link = NULL;
+    struct iatt stbuf = {
+        0,
+    };
+    dht_conf_t *conf = this->private;
+
+    dict = dict_new();
+    if (!dict) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        goto out;
+    }
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_log(this->name, GF_LOG_ERROR,
+               "%s: failed to set 'linkto' key in dict", loc->path);
+        goto out;
+    }
+
+    /* check in the destination if the file is link file */
+    ret = syncop_lookup(to, loc, &stbuf, NULL, dict, &rsp_dict);
+    if ((ret < 0) && (-ret != ENOENT)) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: lookup failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* we no more require this key */
+    dict_del(dict, conf->link_xattr_name);
+
+    /* file exists in target node, only if it is 'linkfile' its valid,
+       otherwise, error out */
+    if (!ret) {
+        if (!check_is_linkfile(loc->inode, &stbuf, rsp_dict,
+                               conf->link_xattr_name)) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: file exists in destination", loc->path);
+            *fop_errno = EINVAL;
+            ret = -1;
+            goto out;
+        }
+
+        /* as file is linkfile, delete it */
+        ret = syncop_unlink(to, loc, NULL, NULL);
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s: failed to set gfid in dict for create", loc->path);
-                goto out;
-        }
-
-        /* Create the file in target */
-        if (IA_ISLNK (buf->ia_type)) {
-                /* Handle symlinks separately */
-                ret = syncop_readlink (from, loc, &link, buf->ia_size, NULL,
-                                       NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: readlink on symlink failed",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_symlink (to, loc, link, 0, dict, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: creating symlink failed",
-                                loc->path);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                goto done;
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to delete the linkfile", loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+    }
+
+    /* Set the gfid of the source file in dict */
+    ret = dict_set_gfuuid(dict, "gfid-req", buf->ia_gfid, true);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_log(this->name, GF_LOG_ERROR,
+               "%s: failed to set gfid in dict for create", loc->path);
+        goto out;
+    }
+
+    /* Create the file in target */
+    if (IA_ISLNK(buf->ia_type)) {
+        /* Handle symlinks separately */
+        ret = syncop_readlink(from, loc, &link, buf->ia_size, NULL, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: readlink on symlink failed", loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_mknod (to, loc, st_mode_from_ia (buf->ia_prot,
-                                                      buf->ia_type),
-                            makedev (ia_major (buf->ia_rdev),
-                                     ia_minor (buf->ia_rdev)), 0, dict, NULL);
+        ret = syncop_symlink(to, loc, link, 0, dict, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: mknod failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED, "%s: creating symlink failed",
+                   loc->path);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        }
+
+        goto done;
+    }
+
+    ret = syncop_mknod(to, loc, st_mode_from_ia(buf->ia_prot, buf->ia_type),
+                       makedev(ia_major(buf->ia_rdev), ia_minor(buf->ia_rdev)),
+                       0, dict, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: mknod failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
 done:
-        ret = syncop_setattr (to, loc, buf,
-                              (GF_SET_ATTR_MTIME |
-                               GF_SET_ATTR_UID | GF_SET_ATTR_GID |
-                               GF_SET_ATTR_MODE), NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to perform setattr on %s",
-                        loc->path, to->name);
-                *fop_errno = -ret;
-        }
-
-        ret = syncop_unlink (from, loc, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: unlink failed",
-                        loc->path);
-                *fop_errno = -ret;
-                ret = -1;
-        }
+    ret = syncop_setattr(to, loc, buf,
+                         (GF_SET_ATTR_MTIME | GF_SET_ATTR_UID |
+                          GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
+                         NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to perform setattr on %s", loc->path, to->name);
+        *fop_errno = -ret;
+    }
+
+    ret = syncop_unlink(from, loc, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: unlink failed", loc->path);
+        *fop_errno = -ret;
+        ret = -1;
+    }
 
 out:
-        GF_FREE (link);
-        if (dict)
-                dict_unref (dict);
+    GF_FREE(link);
+    if (dict)
+        dict_unref(dict);
 
-        if (rsp_dict)
-                dict_unref (rsp_dict);
+    if (rsp_dict)
+        dict_unref(rsp_dict);
 
-        return ret;
+    return ret;
 }
 
 static int
-__dht_migration_cleanup_src_file (xlator_t *this, loc_t *loc, fd_t *fd,
-                                  xlator_t *from, ia_prot_t *src_ia_prot)
+__dht_migration_cleanup_src_file(xlator_t *this, loc_t *loc, fd_t *fd,
+                                 xlator_t *from, ia_prot_t *src_ia_prot)
 {
-        int ret                       = -1;
-        dht_conf_t     *conf          = NULL;
-        struct iatt     new_stbuf     = {0,};
-
-        if (!this || !fd || !from || !src_ia_prot) {
-                goto out;
-        }
-
-        conf = this->private;
-
-        /*Revert source mode and xattr changes*/
-        ret = syncop_fstat (from, fd, &new_stbuf, NULL, NULL);
-        if (ret < 0) {
-                /* Failed to get the stat info */
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file cleanup failed: failed to fstat "
-                        "file %s on %s ", loc->path, from->name);
-                ret = -1;
-                goto out;
-        }
-
-
-        /* Remove the sticky bit and sgid bit set, reset it to 0*/
-        if (!src_ia_prot->sticky)
-                new_stbuf.ia_prot.sticky = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    struct iatt new_stbuf = {
+        0,
+    };
+
+    if (!this || !fd || !from || !src_ia_prot) {
+        goto out;
+    }
+
+    conf = this->private;
+
+    /*Revert source mode and xattr changes*/
+    ret = syncop_fstat(from, fd, &new_stbuf, NULL, NULL);
+    if (ret < 0) {
+        /* Failed to get the stat info */
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file cleanup failed: failed to fstat "
+               "file %s on %s ",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
 
-        if (!src_ia_prot->sgid)
-                new_stbuf.ia_prot.sgid = 0;
+    /* Remove the sticky bit and sgid bit set, reset it to 0*/
+    if (!src_ia_prot->sticky)
+        new_stbuf.ia_prot.sticky = 0;
 
-        ret = syncop_fsetattr (from, fd, &new_stbuf,
-                               (GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
-                               NULL, NULL, NULL, NULL);
+    if (!src_ia_prot->sgid)
+        new_stbuf.ia_prot.sgid = 0;
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file cleanup failed:"
-                        "%s: failed to perform fsetattr on %s ",
-                        loc->path, from->name);
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_fsetattr(from, fd, &new_stbuf,
+                          (GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL, NULL,
+                          NULL, NULL);
 
-        ret = syncop_fremovexattr (from, fd, conf->link_xattr_name, 0, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to remove linkto xattr on %s (%s)",
-                        loc->path, from->name, strerror (-ret));
-                ret = -1;
-                goto out;
-        }
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file cleanup failed:"
+               "%s: failed to perform fsetattr on %s ",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_fremovexattr(from, fd, conf->link_xattr_name, 0, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to remove linkto xattr on %s (%s)", loc->path,
+               from->name, strerror(-ret));
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
-
-
 /*
   return values:
 
@@ -1586,1098 +1513,1078 @@ out:
     1 : not a failure, but we can't migrate data as of now
 */
 int
-dht_migrate_file (xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
-                  int flag, int *fop_errno)
+dht_migrate_file(xlator_t *this, loc_t *loc, xlator_t *from, xlator_t *to,
+                 int flag, int *fop_errno)
 {
-        int                     ret                     = -1;
-        struct iatt             new_stbuf               = {0,};
-        struct iatt             stbuf                   = {0,};
-        struct iatt             empty_iatt              = {0,};
-        ia_prot_t               src_ia_prot             = {0,};
-        fd_t                    *src_fd                 = NULL;
-        fd_t                    *dst_fd                 = NULL;
-        dict_t                  *dict                   = NULL;
-        dict_t                  *xattr                  = NULL;
-        dict_t                  *xattr_rsp              = NULL;
-        int                     file_has_holes          = 0;
-        dht_conf_t              *conf                   = this->private;
-        int                     rcvd_enoent_from_src    = 0;
-        struct gf_flock         flock                   = {0, };
-        struct gf_flock         plock                   = {0, };
-        loc_t                   tmp_loc                 = {0, };
-        loc_t                   parent_loc              = {0, };
-        gf_boolean_t            inodelk_locked          = _gf_false;
-        gf_boolean_t            entrylk_locked          = _gf_false;
-        gf_boolean_t            p_locked                = _gf_false;
-        int                     lk_ret                  = -1;
-        gf_defrag_info_t        *defrag                 =  NULL;
-        gf_boolean_t            clean_src               = _gf_false;
-        gf_boolean_t            clean_dst               = _gf_false;
-        int                     log_level               = GF_LOG_INFO;
-        gf_boolean_t            delete_src_linkto       = _gf_true;
-        lock_migration_info_t   locklist;
-        dict_t                  *meta_dict              = NULL;
-        gf_boolean_t            meta_locked             = _gf_false;
-        gf_boolean_t            target_changed          = _gf_false;
-        xlator_t                *new_target             = NULL;
-        xlator_t                *old_target             = NULL;
-        xlator_t                *hashed_subvol          = NULL;
-        fd_t                    *linkto_fd              = NULL;
-
-
-        if (from == to) {
-                gf_msg_debug (this->name, 0, "destination and source are same. file %s"
-                              " might have migrated already", loc->path);
-                ret = 0;
-                goto out;
-        }
+    int ret = -1;
+    struct iatt new_stbuf = {
+        0,
+    };
+    struct iatt stbuf = {
+        0,
+    };
+    struct iatt empty_iatt = {
+        0,
+    };
+    ia_prot_t src_ia_prot = {
+        0,
+    };
+    fd_t *src_fd = NULL;
+    fd_t *dst_fd = NULL;
+    dict_t *dict = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xattr_rsp = NULL;
+    int file_has_holes = 0;
+    dht_conf_t *conf = this->private;
+    int rcvd_enoent_from_src = 0;
+    struct gf_flock flock = {
+        0,
+    };
+    struct gf_flock plock = {
+        0,
+    };
+    loc_t tmp_loc = {
+        0,
+    };
+    loc_t parent_loc = {
+        0,
+    };
+    gf_boolean_t inodelk_locked = _gf_false;
+    gf_boolean_t entrylk_locked = _gf_false;
+    gf_boolean_t p_locked = _gf_false;
+    int lk_ret = -1;
+    gf_defrag_info_t *defrag = NULL;
+    gf_boolean_t clean_src = _gf_false;
+    gf_boolean_t clean_dst = _gf_false;
+    int log_level = GF_LOG_INFO;
+    gf_boolean_t delete_src_linkto = _gf_true;
+    lock_migration_info_t locklist;
+    dict_t *meta_dict = NULL;
+    gf_boolean_t meta_locked = _gf_false;
+    gf_boolean_t target_changed = _gf_false;
+    xlator_t *new_target = NULL;
+    xlator_t *old_target = NULL;
+    xlator_t *hashed_subvol = NULL;
+    fd_t *linkto_fd = NULL;
+
+    if (from == to) {
+        gf_msg_debug(this->name, 0,
+                     "destination and source are same. file %s"
+                     " might have migrated already",
+                     loc->path);
+        ret = 0;
+        goto out;
+    }
 
-        /* If defrag is NULL, it should be assumed that migration is triggered
-         * from client */
-        defrag = conf->defrag;
+    /* If defrag is NULL, it should be assumed that migration is triggered
+     * from client */
+    defrag = conf->defrag;
 
-        /* migration of files from clients is restricted to non-tiered clients
-         * for now */
-        if (!defrag && dht_is_tier_xlator (this)) {
-                ret = ENOTSUP;
-                goto out;
-        }
+    /* migration of files from clients is restricted to non-tiered clients
+     * for now */
+    if (!defrag && dht_is_tier_xlator(this)) {
+        ret = ENOTSUP;
+        goto out;
+    }
 
-        if (defrag && defrag->tier_conf.is_tier)
-                log_level = GF_LOG_TRACE;
+    if (defrag && defrag->tier_conf.is_tier)
+        log_level = GF_LOG_TRACE;
 
-        gf_log (this->name,
-                log_level, "%s: attempting to move from %s to %s",
-                loc->path, from->name, to->name);
+    gf_log(this->name, log_level, "%s: attempting to move from %s to %s",
+           loc->path, from->name, to->name);
 
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                *fop_errno = ENOMEM;
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "Could not allocate memory for dict");
-                goto out;
-        }
-        ret = dict_set_int32 (dict, conf->link_xattr_name, 256);
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        *fop_errno = ENOMEM;
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "Could not allocate memory for dict");
+        goto out;
+    }
+    ret = dict_set_int32(dict, conf->link_xattr_name, 256);
+    if (ret) {
+        *fop_errno = ENOMEM;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to set 'linkto' key in dict",
+               loc->path);
+        goto out;
+    }
+
+    /* Do not migrate file in case lock migration is not enabled on the
+     * volume*/
+    if (!conf->lock_migration_enabled) {
+        ret = dict_set_int32(dict, GLUSTERFS_POSIXLK_COUNT, sizeof(int32_t));
         if (ret) {
-                *fop_errno = ENOMEM;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to set 'linkto' key in dict", loc->path);
-                goto out;
-        }
-
-        /* Do not migrate file in case lock migration is not enabled on the
-         * volume*/
-        if (!conf->lock_migration_enabled) {
-                ret = dict_set_int32 (dict,
-                                 GLUSTERFS_POSIXLK_COUNT, sizeof(int32_t));
-                if (ret) {
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: %s: failed to "
-                                "set "GLUSTERFS_POSIXLK_COUNT" key in dict",
-                                loc->path);
-                        goto out;
-                }
-        } else {
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "locks will be migrated"
-                        " for file: %s", loc->path);
-        }
-
-        ret = dht_build_parent_loc (this, &parent_loc, loc, fop_errno);
-        if (ret < 0) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to build parent loc, which is needed to "
-                        "acquire entrylk to synchronize with renames on this "
-                        "path. Skipping migration", loc->path);
-                goto out;
-        }
-
-        hashed_subvol = dht_subvol_get_hashed (this, loc);
-        if (hashed_subvol == NULL) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, EINVAL,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: cannot find hashed subvol which is needed to "
-                        "synchronize with renames on this path. "
-                        "Skipping migration", loc->path);
-                goto out;
-        }
-
-        flock.l_type = F_WRLCK;
-
-        tmp_loc.inode = inode_ref (loc->inode);
-        gf_uuid_copy (tmp_loc.gfid, loc->gfid);
-        tmp_loc.path = gf_strdup(loc->path);
-
-        /* this inodelk happens with flock.owner being zero. But to synchronize
-         * hardlink migration we need to have different lkowner for each migration
-         * Filed a bug here: https://bugzilla.redhat.com/show_bug.cgi?id=1468202 to
-         * track the fix for this. Currently synclock takes care of synchronizing
-         * hardlink migration. Once this bug is fixed we can avoid taking synclock */
-        ret = syncop_inodelk (from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc, F_SETLKW,
-                              &flock, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "migrate file failed: "
-                        "%s: failed to lock file on %s",
-                        loc->path, from->name);
-                goto out;
-        }
-
-        inodelk_locked = _gf_true;
-
-        /* dht_rename has changed to use entrylk on hashed subvol for
-         * synchronization. So, rebalance too has to acquire an entrylk on
-         * hashed subvol.
-         */
-        ret = syncop_entrylk (hashed_subvol, DHT_ENTRY_SYNC_DOMAIN, &parent_loc,
-                              loc->name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL,
-                              NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to acquire entrylk on subvol %s",
-                        loc->path, hashed_subvol->name);
-                goto out;
-        }
-
-        entrylk_locked = _gf_true;
-
-        /* Phase 1 - Data migration is in progress from now on */
-        ret = syncop_lookup (from, loc, &stbuf, NULL, dict, &xattr_rsp);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: %s: failed to "
+                   "set " GLUSTERFS_POSIXLK_COUNT " key in dict",
+                   loc->path);
+            goto out;
+        }
+    } else {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "locks will be migrated"
+               " for file: %s",
+               loc->path);
+    }
+
+    ret = dht_build_parent_loc(this, &parent_loc, loc, fop_errno);
+    if (ret < 0) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to build parent loc, which is needed to "
+               "acquire entrylk to synchronize with renames on this "
+               "path. Skipping migration",
+               loc->path);
+        goto out;
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, loc);
+    if (hashed_subvol == NULL) {
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, EINVAL, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: cannot find hashed subvol which is needed to "
+               "synchronize with renames on this path. "
+               "Skipping migration",
+               loc->path);
+        goto out;
+    }
+
+    flock.l_type = F_WRLCK;
+
+    tmp_loc.inode = inode_ref(loc->inode);
+    gf_uuid_copy(tmp_loc.gfid, loc->gfid);
+    tmp_loc.path = gf_strdup(loc->path);
+
+    /* this inodelk happens with flock.owner being zero. But to synchronize
+     * hardlink migration we need to have different lkowner for each migration
+     * Filed a bug here: https://bugzilla.redhat.com/show_bug.cgi?id=1468202 to
+     * track the fix for this. Currently synclock takes care of synchronizing
+     * hardlink migration. Once this bug is fixed we can avoid taking synclock
+     */
+    ret = syncop_inodelk(from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc, F_SETLKW,
+                         &flock, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "migrate file failed: "
+               "%s: failed to lock file on %s",
+               loc->path, from->name);
+        goto out;
+    }
+
+    inodelk_locked = _gf_true;
+
+    /* dht_rename has changed to use entrylk on hashed subvol for
+     * synchronization. So, rebalance too has to acquire an entrylk on
+     * hashed subvol.
+     */
+    ret = syncop_entrylk(hashed_subvol, DHT_ENTRY_SYNC_DOMAIN, &parent_loc,
+                         loc->name, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to acquire entrylk on subvol %s", loc->path,
+               hashed_subvol->name);
+        goto out;
+    }
+
+    entrylk_locked = _gf_true;
+
+    /* Phase 1 - Data migration is in progress from now on */
+    ret = syncop_lookup(from, loc, &stbuf, NULL, dict, &xattr_rsp);
+    if (ret) {
+        *fop_errno = -ret;
+        ret = -1;
+        gf_msg(this->name, GF_LOG_ERROR, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: lookup failed on %s",
+               loc->path, from->name);
+        goto out;
+    }
+
+    /* preserve source mode, so set the same to the destination */
+    src_ia_prot = stbuf.ia_prot;
+
+    /* Check if file can be migrated */
+    ret = __is_file_migratable(this, loc, &stbuf, xattr_rsp, flag, defrag, conf,
+                               fop_errno);
+    if (ret) {
+        if (ret == HARDLINK_MIG_INPROGRESS)
+            ret = 0;
+        goto out;
+    }
+
+    /* Take care of the special files */
+    if (!IA_ISREG(stbuf.ia_type)) {
+        /* Special files */
+        ret = migrate_special_files(this, from, to, loc, &stbuf, fop_errno);
+        goto out;
+    }
+
+    /* create the destination, with required modes/xattr */
+    ret = __dht_rebalance_create_dst_file(this, to, from, loc, &stbuf, &dst_fd,
+                                          fop_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+               "Create dst failed"
+               " on - %s for file - %s",
+               to->name, loc->path);
+        goto out;
+    }
+
+    clean_dst = _gf_true;
+
+    ret = __dht_check_free_space(this, to, from, loc, &stbuf, flag, conf,
+                                 &target_changed, &new_target, fop_errno);
+    if (target_changed) {
+        /* Can't handle for hardlinks. Marking this as failure */
+        if (flag == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS || stbuf.ia_nlink > 1) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_INSUFF_SPACE,
+                   "Exiting migration for"
+                   " file - %s. flag - %d, stbuf.ia_nlink - %d",
+                   loc->path, flag, stbuf.ia_nlink);
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncop_ftruncate(to, dst_fd, 0, NULL, NULL, NULL, NULL);
         if (ret) {
-                *fop_errno = -ret;
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: lookup failed on %s",
-                        loc->path, from->name);
-               goto out;
+            gf_log(this->name, GF_LOG_WARNING,
+                   "%s: failed to perform truncate on %s (%s)", loc->path,
+                   to->name, strerror(-ret));
         }
 
-        /* preserve source mode, so set the same to the destination */
-        src_ia_prot = stbuf.ia_prot;
+        syncop_close(dst_fd);
+        dst_fd = NULL;
 
-        /* Check if file can be migrated */
-        ret = __is_file_migratable (this, loc, &stbuf, xattr_rsp, flag, defrag, conf,
-                                    fop_errno);
-        if (ret) {
-                if (ret == HARDLINK_MIG_INPROGRESS)
-                        ret = 0;
-                goto out;
-        }
+        old_target = to;
+        to = new_target;
 
-        /* Take care of the special files */
-        if (!IA_ISREG (stbuf.ia_type)) {
-                /* Special files */
-                ret = migrate_special_files (this, from, to, loc, &stbuf,
-                                             fop_errno);
-                goto out;
-        }
+        clean_dst = _gf_false;
 
-        /* create the destination, with required modes/xattr */
-        ret = __dht_rebalance_create_dst_file (this, to, from, loc, &stbuf,
-                                               &dst_fd, fop_errno);
+        /* if the file migration is successful to this new target, then
+         * update the xattr on the old destination to point the new
+         * destination. We need to do update this only post migration
+         * as in case of failure the linkto needs to point to the source
+         * subvol */
+        ret = __dht_rebalance_create_dst_file(this, to, from, loc, &stbuf,
+                                              &dst_fd, fop_errno);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0, "Create dst failed"
-                        " on - %s for file - %s", to->name, loc->path);
-                goto out;
-        }
-
-        clean_dst = _gf_true;
-
-        ret = __dht_check_free_space (this, to, from, loc, &stbuf, flag, conf,
-                                      &target_changed, &new_target, fop_errno);
-        if (target_changed) {
-                /* Can't handle for hardlinks. Marking this as failure */
-                if (flag == GF_DHT_MIGRATE_HARDLINK_IN_PROGRESS || stbuf.ia_nlink > 1) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SUBVOL_INSUFF_SPACE, "Exiting migration for"
-                                " file - %s. flag - %d, stbuf.ia_nlink - %d",
-                               loc->path,  flag, stbuf.ia_nlink);
-                        ret = -1;
-                        goto out;
-                }
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Create dst failed"
+                   " on - %s for file - %s",
+                   to->name, loc->path);
+            goto out;
+        } else {
+            gf_msg(this->name, GF_LOG_INFO, 0, 0,
+                   "destination for file "
+                   "- %s is changed to - %s",
+                   loc->path, to->name);
+            clean_dst = _gf_true;
+        }
+    }
+
+    if (ret) {
+        goto out;
+    }
+
+    /* Open the source, and also update mode/xattr */
+    ret = __dht_rebalance_open_src_file(this, from, to, loc, &stbuf, &src_fd,
+                                        &clean_src, fop_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: failed to open %s on %s", loc->path,
+               from->name);
+        goto out;
+    }
+
+    /* TODO: move all xattr related operations to fd based operations */
+    ret = syncop_listxattr(from, loc, &xattr, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, *fop_errno,
+               DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to get xattr from %s",
+               loc->path, from->name);
+        ret = -1;
+        goto out;
+    }
+
+    /* Copying posix acls to the linkto file messes up the permissions*/
+    dht_strip_out_acls(xattr);
+
+    /* Remove the linkto xattr as we don't want to overwrite the value
+     * set on the dst.
+     */
+    dict_del(xattr, conf->link_xattr_name);
+
+    /* We need to error out if this fails as having the wrong shard xattrs
+     * set on the dst could cause data corruption
+     */
+    ret = syncop_fsetxattr(to, dst_fd, xattr, 0, NULL, NULL);
+    if (ret < 0) {
+        *fop_errno = -ret;
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to set xattr on %s", loc->path, to->name);
+        ret = -1;
+        goto out;
+    }
 
+    if (xattr_rsp) {
+        /* we no more require this key */
+        dict_del(dict, conf->link_xattr_name);
+        dict_unref(xattr_rsp);
+    }
+
+    ret = syncop_fstat(from, src_fd, &stbuf, dict, &xattr_rsp);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:failed to lookup %s on %s ", loc->path,
+               from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
+
+    /* Check again if file has hardlink */
+    ret = __check_file_has_hardlink(this, loc, &stbuf, xattr_rsp, flag, defrag,
+                                    conf, fop_errno);
+    if (ret) {
+        if (ret == HARDLINK_MIG_INPROGRESS)
+            ret = 0;
+        goto out;
+    }
+    /* Try to preserve 'holes' while migrating data */
+    if (stbuf.ia_size > (stbuf.ia_blocks * GF_DISK_SECTOR_SIZE))
+        file_has_holes = 1;
+
+    ret = __dht_rebalance_migrate_data(this, defrag, from, to, src_fd, dst_fd,
+                                       stbuf.ia_size, file_has_holes,
+                                       fop_errno);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: %s: failed to migrate data", loc->path);
 
-                ret = syncop_ftruncate (to, dst_fd, 0, NULL, NULL, NULL, NULL);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "%s: failed to perform truncate on %s (%s)",
-                                loc->path, to->name, strerror (-ret));
-                }
+        ret = -1;
+        goto out;
+    }
+
+    /* TODO: Sync the locks */
+
+    ret = syncop_fsync(to, dst_fd, 0, NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "%s: failed to fsync on %s (%s)",
+               loc->path, to->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* Phase 2 - Data-Migration Complete, Housekeeping updates pending */
+
+    ret = syncop_fstat(from, src_fd, &new_stbuf, NULL, NULL);
+    if (ret < 0) {
+        /* Failed to get the stat info */
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: failed to fstat file %s on %s ", loc->path,
+               from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-                syncop_close (dst_fd);
-                dst_fd = NULL;
+    /* Lock the entire source file to prevent clients from taking a
+       lock on it as dht_lk does not handle file migration.
 
-                old_target = to;
-                to = new_target;
+       This still leaves a small window where conflicting locks can
+       be granted to different clients. If client1 requests a blocking
+       lock on the src file, it will be granted after the migrating
+       process releases its lock. If client2 requests a lock on the dst
+       data file, it will also be granted, but all FOPs will be redirected
+       to the dst data file.
+    */
 
-                clean_dst = _gf_false;
+    /* Take meta lock  */
 
+    if (conf->lock_migration_enabled) {
+        meta_dict = dict_new();
+        if (!meta_dict) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "dict_new failed");
 
-                /* if the file migration is successful to this new target, then
-                 * update the xattr on the old destination to point the new
-                 * destination. We need to do update this only post migration
-                 * as in case of failure the linkto needs to point to the source
-                 * subvol */
-                ret = __dht_rebalance_create_dst_file (this, to, from, loc, &stbuf,
-                                                       &dst_fd, fop_errno);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "Create dst failed"
-                                " on - %s for file - %s", to->name, loc->path);
-                        goto out;
-                } else {
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0, "destination for file "
-                                "- %s is changed to - %s", loc->path, to->name);
-                        clean_dst = _gf_true;
-                }
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
+        ret = dict_set_str(meta_dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
         if (ret) {
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value: key = %s,"
+                   " path = %s",
+                   GLUSTERFS_INTERNAL_FOP_KEY, loc->path);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        /* Open the source, and also update mode/xattr */
-        ret = __dht_rebalance_open_src_file (this, from, to, loc, &stbuf, &src_fd,
-                                             &clean_src, fop_errno);
+        ret = dict_set_int32(meta_dict, GF_META_LOCK_KEY, 1);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: failed to open %s on %s",
-                        loc->path, from->name);
-                goto out;
-        }
-
-        /* TODO: move all xattr related operations to fd based operations */
-        ret = syncop_listxattr (from, loc, &xattr, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, *fop_errno,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to get xattr from %s",
-                        loc->path, from->name);
-                ret = -1;
-                goto out;
-        }
-
-        /* Copying posix acls to the linkto file messes up the permissions*/
-        dht_strip_out_acls (xattr);
-
-        /* Remove the linkto xattr as we don't want to overwrite the value
-         * set on the dst.
-         */
-        dict_del (xattr, conf->link_xattr_name);
-
-        /* We need to error out if this fails as having the wrong shard xattrs
-         * set on the dst could cause data corruption
-         */
-        ret = syncop_fsetxattr (to, dst_fd, xattr, 0, NULL, NULL);
-        if (ret < 0) {
-                *fop_errno = -ret;
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to set xattr on %s",
-                        loc->path, to->name);
-                ret = -1;
-                goto out;
-        }
-
-        if (xattr_rsp) {
-                /* we no more require this key */
-                dict_del (dict, conf->link_xattr_name);
-                dict_unref (xattr_rsp);
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_fstat (from, src_fd, &stbuf, dict, &xattr_rsp);
+        ret = syncop_setxattr(from, loc, meta_dict, 0, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:failed to lookup %s on %s ",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto out;
-        }
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace syncop_setxattr metalock failed");
 
-        /* Check again if file has hardlink */
-        ret = __check_file_has_hardlink (this, loc, &stbuf, xattr_rsp,
-                                         flag, defrag, conf, fop_errno);
-        if (ret) {
-                if (ret == HARDLINK_MIG_INPROGRESS)
-                        ret = 0;
-                goto out;
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        } else {
+            meta_locked = _gf_true;
         }
-        /* Try to preserve 'holes' while migrating data */
-        if (stbuf.ia_size > (stbuf.ia_blocks * GF_DISK_SECTOR_SIZE))
-                file_has_holes = 1;
+    }
 
+    if (!conf->lock_migration_enabled) {
+        plock.l_type = F_WRLCK;
+        plock.l_start = 0;
+        plock.l_len = 0;
+        plock.l_whence = SEEK_SET;
 
-        ret = __dht_rebalance_migrate_data (this, defrag, from, to,
-                                            src_fd, dst_fd, stbuf.ia_size,
-                                            file_has_holes, fop_errno);
+        ret = syncop_lk(from, src_fd, F_SETLK, &plock, NULL, NULL);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: %s: failed to migrate data",
-                        loc->path);
-
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: Failed to lock on %s",
+                   loc->path, from->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
 
-        /* TODO: Sync the locks */
+        p_locked = _gf_true;
 
-        ret = syncop_fsync (to, dst_fd, 0, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to fsync on %s (%s)",
-                        loc->path, to->name, strerror (-ret));
-                *fop_errno = -ret;
-        }
+    } else {
+        INIT_LIST_HEAD(&locklist.list);
 
+        ret = syncop_getactivelk(from, loc, &locklist, NULL, NULL);
+        if (ret == 0) {
+            gf_log(this->name, GF_LOG_INFO, "No active locks on:%s", loc->path);
 
-        /* Phase 2 - Data-Migration Complete, Housekeeping updates pending */
+        } else if (ret > 0) {
+            ret = syncop_setactivelk(to, loc, &locklist, NULL, NULL);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, -ret,
+                       DHT_MSG_LOCK_MIGRATION_FAILED, "write lock failed on:%s",
+                       loc->path);
 
-        ret = syncop_fstat (from, src_fd, &new_stbuf, NULL, NULL);
-        if (ret < 0) {
-                /* Failed to get the stat info */
-                gf_msg ( this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: failed to fstat file %s on %s ",
-                        loc->path, from->name);
                 *fop_errno = -ret;
                 ret = -1;
-                goto out;
-        }
-
-        /* Lock the entire source file to prevent clients from taking a
-           lock on it as dht_lk does not handle file migration.
-
-           This still leaves a small window where conflicting locks can
-           be granted to different clients. If client1 requests a blocking
-           lock on the src file, it will be granted after the migrating
-           process releases its lock. If client2 requests a lock on the dst
-           data file, it will also be granted, but all FOPs will be redirected
-           to the dst data file.
-        */
-
-        /* Take meta lock  */
-
-        if (conf->lock_migration_enabled) {
-                meta_dict = dict_new ();
-                if (!meta_dict) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "dict_new failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_set_str (meta_dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value: key = %s,"
-                                " path = %s", GLUSTERFS_INTERNAL_FOP_KEY,
-                                 loc->path);
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_set_int32 (meta_dict, GF_META_LOCK_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_setxattr (from, loc, meta_dict, 0, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace syncop_setxattr metalock failed");
-
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                } else {
-                        meta_locked = _gf_true;
-                }
-        }
-
-        if (!conf->lock_migration_enabled) {
-                plock.l_type = F_WRLCK;
-                plock.l_start = 0;
-                plock.l_len = 0;
-                plock.l_whence = SEEK_SET;
-
-                ret = syncop_lk (from, src_fd, F_SETLK, &plock, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: Failed to lock on %s",
-                                loc->path, from->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-
-                p_locked = _gf_true;
-
+                goto metaunlock;
+            }
         } else {
-
-                INIT_LIST_HEAD (&locklist.list);
-
-                ret = syncop_getactivelk (from, loc, &locklist, NULL, NULL);
-                if (ret == 0) {
-                        gf_log (this->name, GF_LOG_INFO, "No active locks on:%s"
-                                , loc->path);
-
-                } else if (ret > 0) {
-
-                        ret = syncop_setactivelk (to, loc, &locklist, NULL,
-                                                  NULL);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                        DHT_MSG_LOCK_MIGRATION_FAILED,
-                                        "write lock failed on:%s", loc->path);
-
-                                *fop_errno = -ret;
-                                ret = -1;
-                                goto metaunlock;
-                        }
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_LOCK_MIGRATION_FAILED,
-                                "getactivelk failed for file: %s", loc->path);
-                        *fop_errno = -ret;
-                }
-        }
-
-
-        /* source would have both sticky bit and sgid bit set, reset it to 0,
-           and set the source permission on destination, if it was not set
-           prior to setting rebalance-modes in source  */
-        if (!src_ia_prot.sticky)
-                new_stbuf.ia_prot.sticky = 0;
-
-        if (!src_ia_prot.sgid)
-                new_stbuf.ia_prot.sgid = 0;
-
-        /* TODO: if the source actually had sticky bit, or sgid bit set,
-           we are not handling it */
-
-        ret = syncop_fsetattr (to, dst_fd, &new_stbuf,
-                               (GF_SET_ATTR_UID | GF_SET_ATTR_GID |
-                                GF_SET_ATTR_MODE), NULL, NULL, NULL, NULL);
+            gf_msg(this->name, GF_LOG_ERROR, -ret,
+                   DHT_MSG_LOCK_MIGRATION_FAILED,
+                   "getactivelk failed for file: %s", loc->path);
+            *fop_errno = -ret;
+        }
+    }
+
+    /* source would have both sticky bit and sgid bit set, reset it to 0,
+       and set the source permission on destination, if it was not set
+       prior to setting rebalance-modes in source  */
+    if (!src_ia_prot.sticky)
+        new_stbuf.ia_prot.sticky = 0;
+
+    if (!src_ia_prot.sgid)
+        new_stbuf.ia_prot.sgid = 0;
+
+    /* TODO: if the source actually had sticky bit, or sgid bit set,
+       we are not handling it */
+
+    ret = syncop_fsetattr(
+        to, dst_fd, &new_stbuf,
+        (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL, NULL,
+        NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to perform setattr on %s ",
+               loc->path, to->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto metaunlock;
+    }
+
+    /* Because 'futimes' is not portable */
+    ret = syncop_setattr(to, loc, &new_stbuf,
+                         (GF_SET_ATTR_MTIME | GF_SET_ATTR_ATIME), NULL, NULL,
+                         NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform setattr on %s ", loc->path, to->name);
+        *fop_errno = -ret;
+    }
+
+    if (target_changed) {
+        dict_del(dict, GLUSTERFS_POSIXLK_COUNT);
+        ret = dict_set_str(dict, conf->link_xattr_name, to->name);
         if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, to->name);
-                *fop_errno = -ret;
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set xattr in dict for %s (linkto:%s)", loc->path,
+                   to->name);
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
+        }
+
+        ret = syncop_setxattr(old_target, loc, dict, 0, NULL, NULL);
+        if (ret && -ret != ESTALE && -ret != ENOENT) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "failed to set xattr on %s in %s", loc->path,
+                   old_target->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
+        } else if (-ret == ESTALE || -ret == ENOENT) {
+            /* The failure ESTALE indicates that the linkto
+             * file on the hashed subvol might have been deleted.
+             * In this case will create a linkto file with new target
+             * as linkto xattr value*/
+            linkto_fd = fd_create(loc->inode, DHT_REBALANCE_PID);
+            if (!linkto_fd) {
+                gf_msg(this->name, GF_LOG_ERROR, errno,
+                       DHT_MSG_MIGRATE_FILE_FAILED, "%s: fd create failed",
+                       loc->path);
+                *fop_errno = ENOMEM;
                 ret = -1;
-                goto metaunlock;
-        }
-
-        /* Because 'futimes' is not portable */
-        ret = syncop_setattr (to, loc, &new_stbuf,
-                              (GF_SET_ATTR_MTIME | GF_SET_ATTR_ATIME),
-                              NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, to->name);
+                goto out;
+            }
+            ret = syncop_create(old_target, loc, O_RDWR, DHT_LINKFILE_MODE,
+                                linkto_fd, NULL, dict, NULL);
+            if (ret != 0 && -ret != EEXIST && -ret != ESTALE) {
                 *fop_errno = -ret;
-        }
-
-        if (target_changed) {
-                dict_del (dict, GLUSTERFS_POSIXLK_COUNT);
-                ret = dict_set_str (dict, conf->link_xattr_name, to->name);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "failed to set xattr in dict for %s (linkto:%s)",
-                                loc->path, to->name);
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_setxattr (old_target, loc, dict, 0, NULL, NULL);
-                if (ret && -ret != ESTALE && -ret != ENOENT) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "failed to set xattr on %s in %s",
-                                loc->path, old_target->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                } else if (-ret == ESTALE || -ret == ENOENT) {
-                       /* The failure ESTALE indicates that the linkto
-                        * file on the hashed subvol might have been deleted.
-                        * In this case will create a linkto file with new target
-                        * as linkto xattr value*/
-                        linkto_fd = fd_create (loc->inode, DHT_REBALANCE_PID);
-                        if (!linkto_fd) {
-                                gf_msg (this->name, GF_LOG_ERROR, errno,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "%s: fd create failed", loc->path);
-                                *fop_errno = ENOMEM;
-                                ret = -1;
-                                goto out;
-                        }
-                        ret = syncop_create (old_target, loc, O_RDWR,
-                                             DHT_LINKFILE_MODE, linkto_fd,
-                                             NULL, dict, NULL);
-                        if (ret != 0 && -ret != EEXIST && -ret != ESTALE) {
-                                *fop_errno = -ret;
-                                ret = -1;
-                                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                        DHT_MSG_MIGRATE_FILE_FAILED,
-                                        "failed to create linkto file on %s in %s",
-                                        loc->path, old_target->name);
-                                goto out;
-                        } else if (ret == 0) {
-                                ret = syncop_fsetattr (old_target, linkto_fd, &stbuf,
-                                                       (GF_SET_ATTR_UID | GF_SET_ATTR_GID),
-                                                       NULL, NULL, NULL, NULL);
-                                if (ret < 0) {
-                                        *fop_errno = -ret;
-                                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                                "chown failed for %s on %s",
-                                                loc->path, old_target->name);
-                                }
-                        }
+                ret = -1;
+                gf_msg(this->name, GF_LOG_ERROR, -ret,
+                       DHT_MSG_MIGRATE_FILE_FAILED,
+                       "failed to create linkto file on %s in %s", loc->path,
+                       old_target->name);
+                goto out;
+            } else if (ret == 0) {
+                ret = syncop_fsetattr(old_target, linkto_fd, &stbuf,
+                                      (GF_SET_ATTR_UID | GF_SET_ATTR_GID), NULL,
+                                      NULL, NULL, NULL);
+                if (ret < 0) {
+                    *fop_errno = -ret;
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_MIGRATE_FILE_FAILED,
+                           "chown failed for %s on %s", loc->path,
+                           old_target->name);
                 }
-        }
-
-        clean_dst = _gf_false;
-
-        /* Posix acls are not set on DHT linkto files as part of the initial
-         * initial xattrs set on the dst file, so these need
-         * to be set on the dst file after the linkto attrs are removed.
-         * TODO: Optimize this.
-         */
-        if (xattr) {
-                dict_unref (xattr);
-                xattr = NULL;
-        }
-
-        /* Set only the Posix ACLs this time */
-        ret = syncop_getxattr (from, loc, &xattr, POSIX_ACL_ACCESS_XATTR,
-                               NULL, NULL);
+            }
+        }
+    }
+
+    clean_dst = _gf_false;
+
+    /* Posix acls are not set on DHT linkto files as part of the initial
+     * initial xattrs set on the dst file, so these need
+     * to be set on the dst file after the linkto attrs are removed.
+     * TODO: Optimize this.
+     */
+    if (xattr) {
+        dict_unref(xattr);
+        xattr = NULL;
+    }
+
+    /* Set only the Posix ACLs this time */
+    ret = syncop_getxattr(from, loc, &xattr, POSIX_ACL_ACCESS_XATTR, NULL,
+                          NULL);
+    if (ret < 0) {
+        if ((-ret != ENODATA) && (-ret != ENOATTR)) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: failed to get xattr from %s",
+                   loc->path, from->name);
+            *fop_errno = -ret;
+        }
+    } else {
+        ret = syncop_setxattr(to, loc, xattr, 0, NULL, NULL);
         if (ret < 0) {
-                if ((-ret != ENODATA) && (-ret != ENOATTR)) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: failed to get xattr from %s",
-                                loc->path, from->name);
-                        *fop_errno = -ret;
-                }
+            /* Potential problem here where Posix ACLs will
+             * not be set on the target file */
+
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed:"
+                   "%s: failed to set xattr on %s",
+                   loc->path, to->name);
+            *fop_errno = -ret;
+        }
+    }
+
+    /* store size of previous migrated file  */
+    if (defrag && defrag->tier_conf.is_tier) {
+        if (from != TIER_HASHED_SUBVOL) {
+            defrag->tier_conf.st_last_promoted_size = stbuf.ia_size;
         } else {
-                ret = syncop_setxattr (to, loc, xattr, 0, NULL, NULL);
-                if (ret < 0) {
-                        /* Potential problem here where Posix ACLs will
-                         * not be set on the target file */
-
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed:"
-                                "%s: failed to set xattr on %s",
-                                loc->path, to->name);
-                        *fop_errno = -ret;
-                }
-        }
-
-        /* store size of previous migrated file  */
-        if (defrag && defrag->tier_conf.is_tier) {
-                if (from != TIER_HASHED_SUBVOL) {
-                        defrag->tier_conf.st_last_promoted_size = stbuf.ia_size;
-                } else {
-                        /* Don't delete the linkto file on the hashed subvol */
-                        delete_src_linkto = _gf_false;
-                        defrag->tier_conf.st_last_demoted_size = stbuf.ia_size;
-                }
-        }
-
-        /* The src file is being unlinked after this so we don't need
-           to clean it up */
-        clean_src = _gf_false;
-
-        /* Make the source as a linkfile first before deleting it */
-        empty_iatt.ia_prot.sticky = 1;
-        ret = syncop_fsetattr (from, src_fd, &empty_iatt,
-                               GF_SET_ATTR_MODE, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed:"
-                        "%s: failed to perform setattr on %s ",
-                        loc->path, from->name);
-                *fop_errno = -ret;
-                ret = -1;
-                goto metaunlock;
-        }
-
-       /* Free up the data blocks on the source node, as the whole
-           file is migrated */
-        ret = syncop_ftruncate (from, src_fd, 0, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform truncate on %s (%s)",
-                        loc->path, from->name, strerror (-ret));
-                *fop_errno = -ret;
-        }
-
-        /* remove the 'linkto' xattr from the destination */
-        ret = syncop_fremovexattr (to, dst_fd, conf->link_xattr_name, 0, NULL);
+            /* Don't delete the linkto file on the hashed subvol */
+            delete_src_linkto = _gf_false;
+            defrag->tier_conf.st_last_demoted_size = stbuf.ia_size;
+        }
+    }
+
+    /* The src file is being unlinked after this so we don't need
+       to clean it up */
+    clean_src = _gf_false;
+
+    /* Make the source as a linkfile first before deleting it */
+    empty_iatt.ia_prot.sticky = 1;
+    ret = syncop_fsetattr(from, src_fd, &empty_iatt, GF_SET_ATTR_MODE, NULL,
+                          NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed:"
+               "%s: failed to perform setattr on %s ",
+               loc->path, from->name);
+        *fop_errno = -ret;
+        ret = -1;
+        goto metaunlock;
+    }
+
+    /* Free up the data blocks on the source node, as the whole
+        file is migrated */
+    ret = syncop_ftruncate(from, src_fd, 0, NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform truncate on %s (%s)", loc->path,
+               from->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* remove the 'linkto' xattr from the destination */
+    ret = syncop_fremovexattr(to, dst_fd, conf->link_xattr_name, 0, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "%s: failed to perform removexattr on %s (%s)", loc->path,
+               to->name, strerror(-ret));
+        *fop_errno = -ret;
+    }
+
+    /* Do a stat and check the gfid before unlink */
+
+    /*
+     * Cached file changes its state from non-linkto to linkto file after
+     * migrating data. If lookup from any other mount-point is performed,
+     * converted-linkto-cached file will be treated as a stale and will be
+     * unlinked. But by this time, file is already migrated. So further
+     * failure because of ENOENT should  not be treated as error
+     */
+
+    ret = syncop_stat(from, loc, &empty_iatt, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "%s: failed to do a stat on %s", loc->path, from->name);
+
+        if (-ret != ENOENT) {
+            *fop_errno = -ret;
+            ret = -1;
+            goto metaunlock;
+        }
+
+        rcvd_enoent_from_src = 1;
+    }
+
+    if ((gf_uuid_compare(empty_iatt.ia_gfid, loc->gfid) == 0) &&
+        (!rcvd_enoent_from_src) && delete_src_linkto) {
+        /* take out the source from namespace */
+        ret = syncop_unlink(from, loc, NULL, NULL);
         if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to perform removexattr on %s (%s)",
-                        loc->path, to->name, strerror (-ret));
-                *fop_errno = -ret;
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to perform unlink on %s", loc->path, from->name);
+            *fop_errno = -ret;
+            ret = -1;
+            goto metaunlock;
         }
+    }
 
-        /* Do a stat and check the gfid before unlink */
-
-        /*
-         * Cached file changes its state from non-linkto to linkto file after
-         * migrating data. If lookup from any other mount-point is performed,
-         * converted-linkto-cached file will be treated as a stale and will be
-         * unlinked. But by this time, file is already migrated. So further
-         * failure because of ENOENT should  not be treated as error
-         */
+    ret = syncop_lookup(this, loc, NULL, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg_debug(this->name, -ret,
+                     "%s: failed to lookup the file on subvolumes", loc->path);
+        *fop_errno = -ret;
+    }
 
-        ret = syncop_stat (from, loc, &empty_iatt, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "%s: failed to do a stat on %s",
-                        loc->path, from->name);
-
-                if (-ret != ENOENT) {
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto metaunlock;
-                }
-
-                rcvd_enoent_from_src = 1;
-        }
+    gf_msg(this->name, log_level, 0, DHT_MSG_MIGRATE_FILE_COMPLETE,
+           "completed migration of %s from subvolume %s to %s", loc->path,
+           from->name, to->name);
 
-
-        if ((gf_uuid_compare (empty_iatt.ia_gfid, loc->gfid) == 0 ) &&
-            (!rcvd_enoent_from_src) && delete_src_linkto) {
-                /* take out the source from namespace */
-                ret = syncop_unlink (from, loc, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to perform unlink on %s",
-                                loc->path, from->name);
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto metaunlock;
-                }
-        }
-
-        ret = syncop_lookup (this, loc, NULL, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg_debug (this->name, -ret,
-                              "%s: failed to lookup the file on subvolumes",
-                              loc->path);
-                *fop_errno = -ret;
-        }
-
-        gf_msg (this->name, log_level, 0,
-                DHT_MSG_MIGRATE_FILE_COMPLETE,
-                "completed migration of %s from subvolume %s to %s",
-                loc->path, from->name, to->name);
-
-        ret = 0;
+    ret = 0;
 
 metaunlock:
 
-        if (conf->lock_migration_enabled && meta_locked) {
+    if (conf->lock_migration_enabled && meta_locked) {
+        dict_del(meta_dict, GF_META_LOCK_KEY);
 
-                dict_del (meta_dict, GF_META_LOCK_KEY);
-
-                ret = dict_set_int32 (meta_dict, GF_META_UNLOCK_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (clean_dst == _gf_false)
-                        ret = dict_set_int32 (meta_dict, "status", 1);
-                else
-                        ret = dict_set_int32 (meta_dict, "status", 0);
-
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace dict_set failed");
-
-                        *fop_errno = ENOMEM;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = syncop_setxattr (from, loc, meta_dict, 0, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Trace syncop_setxattr meta unlock failed");
-
-                        *fop_errno = -ret;
-                        ret = -1;
-                        goto out;
-                }
-        }
-
-out:
-        if (clean_src) {
-                /* Revert source mode and xattr changes*/
-                lk_ret = __dht_migration_cleanup_src_file (this, loc, src_fd,
-                                                        from, &src_ia_prot);
-                if (lk_ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to cleanup source file on %s",
-                                loc->path, from->name);
-                }
-        }
+        ret = dict_set_int32(meta_dict, GF_META_UNLOCK_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
 
-        /* reset the destination back to 0 */
-        if (clean_dst) {
-                lk_ret = syncop_ftruncate (to, dst_fd, 0, NULL, NULL,
-                                           NULL, NULL);
-                if (lk_ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "Migrate file failed: "
-                                "%s: failed to reset target size back to 0",
-                                loc->path);
-                }
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        if (inodelk_locked) {
-                flock.l_type = F_UNLCK;
+        if (clean_dst == _gf_false)
+            ret = dict_set_int32(meta_dict, "status", 1);
+        else
+            ret = dict_set_int32(meta_dict, "status", 0);
 
-                lk_ret = syncop_inodelk (from, DHT_FILE_MIGRATE_DOMAIN,
-                                         &tmp_loc, F_SETLK, &flock, NULL, NULL);
-                if (lk_ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to unlock file on %s",
-                                loc->path, from->name);
-                }
-        }
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace dict_set failed");
 
-        if (entrylk_locked) {
-                lk_ret = syncop_entrylk (hashed_subvol, DHT_ENTRY_SYNC_DOMAIN,
-                                         &parent_loc, loc->name, ENTRYLK_UNLOCK,
-                                         ENTRYLK_UNLOCK, NULL, NULL);
-                if (lk_ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to unlock entrylk on %s",
-                                loc->path, hashed_subvol->name);
-                }
+            *fop_errno = ENOMEM;
+            ret = -1;
+            goto out;
         }
 
-        if (p_locked) {
-                plock.l_type = F_UNLCK;
-                lk_ret = syncop_lk (from, src_fd, F_SETLK, &plock, NULL, NULL);
+        ret = syncop_setxattr(from, loc, meta_dict, 0, NULL, NULL);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Trace syncop_setxattr meta unlock failed");
 
-                if (lk_ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "%s: failed to unlock file on %s",
-                                loc->path, from->name);
-                }
+            *fop_errno = -ret;
+            ret = -1;
+            goto out;
         }
+    }
 
-        if (!dht_is_tier_xlator (this)) {
-                lk_ret = syncop_removexattr (to, loc,
-                                             GF_PROTECT_FROM_EXTERNAL_WRITES,
-                                             NULL, NULL);
-                if (lk_ret && (lk_ret != -ENODATA) && (lk_ret != -ENOATTR)) {
-                        gf_msg (this->name, GF_LOG_WARNING, -lk_ret, 0,
-                                "%s: removexattr failed key %s", loc->path,
-                                GF_PROTECT_FROM_EXTERNAL_WRITES);
-                }
+out:
+    if (clean_src) {
+        /* Revert source mode and xattr changes*/
+        lk_ret = __dht_migration_cleanup_src_file(this, loc, src_fd, from,
+                                                  &src_ia_prot);
+        if (lk_ret) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to cleanup source file on %s", loc->path,
+                   from->name);
+        }
+    }
+
+    /* reset the destination back to 0 */
+    if (clean_dst) {
+        lk_ret = syncop_ftruncate(to, dst_fd, 0, NULL, NULL, NULL, NULL);
+        if (lk_ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "Migrate file failed: "
+                   "%s: failed to reset target size back to 0",
+                   loc->path);
+        }
+    }
+
+    if (inodelk_locked) {
+        flock.l_type = F_UNLCK;
+
+        lk_ret = syncop_inodelk(from, DHT_FILE_MIGRATE_DOMAIN, &tmp_loc,
+                                F_SETLK, &flock, NULL, NULL);
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock file on %s", loc->path, from->name);
+        }
+    }
+
+    if (entrylk_locked) {
+        lk_ret = syncop_entrylk(hashed_subvol, DHT_ENTRY_SYNC_DOMAIN,
+                                &parent_loc, loc->name, ENTRYLK_UNLOCK,
+                                ENTRYLK_UNLOCK, NULL, NULL);
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock entrylk on %s", loc->path,
+                   hashed_subvol->name);
+        }
+    }
+
+    if (p_locked) {
+        plock.l_type = F_UNLCK;
+        lk_ret = syncop_lk(from, src_fd, F_SETLK, &plock, NULL, NULL);
+
+        if (lk_ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "%s: failed to unlock file on %s", loc->path, from->name);
+        }
+    }
+
+    if (!dht_is_tier_xlator(this)) {
+        lk_ret = syncop_removexattr(to, loc, GF_PROTECT_FROM_EXTERNAL_WRITES,
+                                    NULL, NULL);
+        if (lk_ret && (lk_ret != -ENODATA) && (lk_ret != -ENOATTR)) {
+            gf_msg(this->name, GF_LOG_WARNING, -lk_ret, 0,
+                   "%s: removexattr failed key %s", loc->path,
+                   GF_PROTECT_FROM_EXTERNAL_WRITES);
         }
+    }
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        if (xattr)
-                dict_unref (xattr);
-        if (xattr_rsp)
-                dict_unref (xattr_rsp);
+    if (xattr)
+        dict_unref(xattr);
+    if (xattr_rsp)
+        dict_unref(xattr_rsp);
 
-        if (dst_fd)
-                syncop_close (dst_fd);
-        if (src_fd)
-                syncop_close (src_fd);
-        if (linkto_fd)
-                syncop_close (linkto_fd);
+    if (dst_fd)
+        syncop_close(dst_fd);
+    if (src_fd)
+        syncop_close(src_fd);
+    if (linkto_fd)
+        syncop_close(linkto_fd);
 
-        loc_wipe (&tmp_loc);
-        loc_wipe (&parent_loc);
+    loc_wipe(&tmp_loc);
+    loc_wipe(&parent_loc);
 
-        return ret;
+    return ret;
 }
 
 static int
-rebalance_task (void *data)
+rebalance_task(void *data)
 {
-        int           ret   = -1;
-        dht_local_t  *local = NULL;
-        call_frame_t *frame = NULL;
-        int           fop_errno = 0;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    call_frame_t *frame = NULL;
+    int fop_errno = 0;
 
-        frame = data;
+    frame = data;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* This function is 'synchrounous', hence if it returns,
-           we are done with the task */
-        ret = dht_migrate_file (THIS, &local->loc, local->rebalance.from_subvol,
-                                local->rebalance.target_node, local->flags,
-                                &fop_errno);
+    /* This function is 'synchrounous', hence if it returns,
+       we are done with the task */
+    ret = dht_migrate_file(THIS, &local->loc, local->rebalance.from_subvol,
+                           local->rebalance.target_node, local->flags,
+                           &fop_errno);
 
-        return ret;
+    return ret;
 }
 
 static int
-rebalance_task_completion (int op_ret, call_frame_t *sync_frame, void *data)
+rebalance_task_completion(int op_ret, call_frame_t *sync_frame, void *data)
 {
-        int32_t       op_errno   = EINVAL;
-
-        if (op_ret == -1) {
-                /* Failure of migration process, mostly due to write process.
-                   as we can't preserve the exact errno, lets say there was
-                   no space to migrate-data
-                */
-                op_errno = ENOSPC;
-        } else if (op_ret == 1) {
-                /* migration didn't happen, but is not a failure, let the user
-                   understand that he doesn't have permission to migrate the
-                   file.
-                */
-                op_ret = -1;
-                op_errno = EPERM;
-        } else if (op_ret != 0) {
-                op_errno = -op_ret;
-                op_ret = -1;
-        }
+    int32_t op_errno = EINVAL;
 
-        DHT_STACK_UNWIND (setxattr, sync_frame, op_ret, op_errno, NULL);
-        return 0;
+    if (op_ret == -1) {
+        /* Failure of migration process, mostly due to write process.
+           as we can't preserve the exact errno, lets say there was
+           no space to migrate-data
+        */
+        op_errno = ENOSPC;
+    } else if (op_ret == 1) {
+        /* migration didn't happen, but is not a failure, let the user
+           understand that he doesn't have permission to migrate the
+           file.
+        */
+        op_ret = -1;
+        op_errno = EPERM;
+    } else if (op_ret != 0) {
+        op_errno = -op_ret;
+        op_ret = -1;
+    }
+
+    DHT_STACK_UNWIND(setxattr, sync_frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
 int
-dht_start_rebalance_task (xlator_t *this, call_frame_t *frame)
+dht_start_rebalance_task(xlator_t *this, call_frame_t *frame)
 {
-        int           ret   = -1;
+    int ret = -1;
 
-        ret = synctask_new (this->ctx->env, rebalance_task,
-                            rebalance_task_completion,
-                            frame, frame);
-        return ret;
+    ret = synctask_new(this->ctx->env, rebalance_task,
+                       rebalance_task_completion, frame, frame);
+    return ret;
 }
 
-
 int
-gf_listener_stop (xlator_t *this)
+gf_listener_stop(xlator_t *this)
 {
-        glusterfs_ctx_t  *ctx = NULL;
-        cmd_args_t       *cmd_args = NULL;
-        int              ret = 0;
-
-        ctx = this->ctx;
-        GF_ASSERT (ctx);
-        cmd_args = &ctx->cmd_args;
-        if (cmd_args->sock_file) {
-                ret = sys_unlink (cmd_args->sock_file);
-                if (ret && (ENOENT == errno)) {
-                        ret = 0;
-                }
-        }
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        DHT_MSG_SOCKET_ERROR,
-                        "Failed to unlink listener "
-                        "socket %s", cmd_args->sock_file);
-        }
-        return ret;
+    glusterfs_ctx_t *ctx = NULL;
+    cmd_args_t *cmd_args = NULL;
+    int ret = 0;
+
+    ctx = this->ctx;
+    GF_ASSERT(ctx);
+    cmd_args = &ctx->cmd_args;
+    if (cmd_args->sock_file) {
+        ret = sys_unlink(cmd_args->sock_file);
+        if (ret && (ENOENT == errno)) {
+            ret = 0;
+        }
+    }
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, DHT_MSG_SOCKET_ERROR,
+               "Failed to unlink listener "
+               "socket %s",
+               cmd_args->sock_file);
+    }
+    return ret;
 }
 
 void
-dht_build_root_inode (xlator_t *this, inode_t **inode)
+dht_build_root_inode(xlator_t *this, inode_t **inode)
 {
-        inode_table_t    *itable        = NULL;
-        uuid_t            root_gfid     = {0, };
+    inode_table_t *itable = NULL;
+    uuid_t root_gfid = {
+        0,
+    };
 
-        itable = inode_table_new (0, this);
-        if (!itable)
-                return;
+    itable = inode_table_new(0, this);
+    if (!itable)
+        return;
 
-        root_gfid[15] = 1;
-        *inode = inode_find (itable, root_gfid);
+    root_gfid[15] = 1;
+    *inode = inode_find(itable, root_gfid);
 }
 
 void
-dht_build_root_loc (inode_t *inode, loc_t *loc)
+dht_build_root_loc(inode_t *inode, loc_t *loc)
 {
-        loc->path = "/";
-        loc->inode = inode;
-        loc->inode->ia_type = IA_IFDIR;
-        memset (loc->gfid, 0, 16);
-        loc->gfid[15] = 1;
+    loc->path = "/";
+    loc->inode = inode;
+    loc->inode->ia_type = IA_IFDIR;
+    memset(loc->gfid, 0, 16);
+    loc->gfid[15] = 1;
 }
 
 /* return values: 1 -> error, bug ignore and continue
                   0 -> proceed
                  -1 -> error, handle it */
 int32_t
-gf_defrag_handle_migrate_error (int32_t op_errno, gf_defrag_info_t *defrag)
+gf_defrag_handle_migrate_error(int32_t op_errno, gf_defrag_info_t *defrag)
 {
-        int ret = 0;
-        /* if errno is not ENOTCONN, we can still continue
-           with rebalance process */
-        if (op_errno != ENOTCONN) {
-                ret = 1;
-                goto out;
-        }
-
-        if (op_errno == ENOTCONN) {
-                /* Most probably mount point went missing (mostly due
-                   to a brick down), say rebalance failure to user,
-                   let him restart it if everything is fine */
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    /* if errno is not ENOTCONN, we can still continue
+       with rebalance process */
+    if (op_errno != ENOTCONN) {
+        ret = 1;
+        goto out;
+    }
+
+    if (op_errno == ENOTCONN) {
+        /* Most probably mount point went missing (mostly due
+           to a brick down), say rebalance failure to user,
+           let him restart it if everything is fine */
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        ret = -1;
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-gf_defrag_pattern_match (gf_defrag_info_t *defrag, char *name, uint64_t size)
+gf_defrag_pattern_match(gf_defrag_info_t *defrag, char *name, uint64_t size)
 {
-        gf_defrag_pattern_list_t *trav = NULL;
-        gf_boolean_t               match = _gf_false;
-        gf_boolean_t               ret = _gf_false;
+    gf_defrag_pattern_list_t *trav = NULL;
+    gf_boolean_t match = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        GF_VALIDATE_OR_GOTO ("dht", defrag, out);
+    GF_VALIDATE_OR_GOTO("dht", defrag, out);
 
-        trav = defrag->defrag_pattern;
-        while (trav) {
-                if (!fnmatch (trav->path_pattern, name, FNM_NOESCAPE)) {
-                        match = _gf_true;
-                        break;
-                }
-                trav = trav->next;
+    trav = defrag->defrag_pattern;
+    while (trav) {
+        if (!fnmatch(trav->path_pattern, name, FNM_NOESCAPE)) {
+            match = _gf_true;
+            break;
         }
+        trav = trav->next;
+    }
 
-        if ((match == _gf_true) && (size >= trav->size))
-                ret = _gf_true;
+    if ((match == _gf_true) && (size >= trav->size))
+        ret = _gf_true;
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
-int dht_dfreaddirp_done (dht_dfoffset_ctx_t *offset_var, int cnt) {
-
-        int i;
-        int result = 1;
+int
+dht_dfreaddirp_done(dht_dfoffset_ctx_t *offset_var, int cnt)
+{
+    int i;
+    int result = 1;
 
-        for (i = 0; i < cnt; i++) {
-                if (offset_var[i].readdir_done == 0) {
-                        result = 0;
-                        break;
-                }
+    for (i = 0; i < cnt; i++) {
+        if (offset_var[i].readdir_done == 0) {
+            result = 0;
+            break;
         }
-        return result;
+    }
+    return result;
 }
 
-int static
-gf_defrag_ctx_subvols_init (dht_dfoffset_ctx_t *offset_var, xlator_t *this) {
-
-        int i;
-        dht_conf_t *conf = NULL;
+int static gf_defrag_ctx_subvols_init(dht_dfoffset_ctx_t *offset_var,
+                                      xlator_t *this)
+{
+    int i;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!conf)
-               return -1;
+    if (!conf)
+        return -1;
 
-        for (i = 0; i < conf->local_subvols_cnt; i++) {
-               offset_var[i].this = conf->local_subvols[i];
-               offset_var[i].offset = (off_t) 0;
-               offset_var[i].readdir_done = 0;
-        }
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        offset_var[i].this = conf->local_subvols[i];
+        offset_var[i].offset = (off_t)0;
+        offset_var[i].readdir_done = 0;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-dht_get_first_non_null_index (subvol_nodeuuids_info_t *entry)
+dht_get_first_non_null_index(subvol_nodeuuids_info_t *entry)
 {
-        int      i        = 0;
-        int      index    = 0;
+    int i = 0;
+    int index = 0;
 
-        for (i = 0; i < entry->count; i++) {
-                if (!gf_uuid_is_null (entry->elements[i].uuid)) {
-                        index = i;
-                        goto out;
-                }
+    for (i = 0; i < entry->count; i++) {
+        if (!gf_uuid_is_null(entry->elements[i].uuid)) {
+            index = i;
+            goto out;
         }
+    }
 
-        if (i == entry->count) {
-                index = -1;
-        }
+    if (i == entry->count) {
+        index = -1;
+    }
 out:
-        return index;
+    return index;
 }
 
-
 /* Return value
  * 0 : this node does not migrate the file
  * 1 : this node migrates the file
@@ -2688,1022 +2595,986 @@ out:
  */
 
 int
-gf_defrag_should_i_migrate (xlator_t *this, int local_subvol_index, uuid_t gfid)
+gf_defrag_should_i_migrate(xlator_t *this, int local_subvol_index, uuid_t gfid)
 {
-        int         ret               = 0;
-        int         i                 = local_subvol_index;
-        char       *str               = NULL;
-        uint32_t    hashval           = 0;
-        int32_t     index             = 0;
-        dht_conf_t *conf              = NULL;
-        char        buf[UUID_CANONICAL_FORM_LEN + 1] = {0, };
-        subvol_nodeuuids_info_t *entry = NULL;
-
-
-        conf = this->private;
-
-        /* Pure distribute. A subvol in this case
-            will be handled by only one node */
-
-        entry = &(conf->local_nodeuuids[i]);
-        if (entry->count == 1) {
-                return 1;
-        }
-
-        str = uuid_utoa_r (gfid, buf);
-        ret = dht_hash_compute (this, 0, str, &hashval);
-        if (ret == 0) {
-                index = (hashval % entry->count);
-                if (entry->elements[index].info
-                                 == REBAL_NODEUUID_MINE) {
-                        /* Index matches this node's nodeuuid.*/
-                        ret = 1;
-                        goto out;
-                }
-
-                /* Brick down - some other node has to migrate these files*/
-                if (gf_uuid_is_null (entry->elements[index].uuid)) {
-                        /* Fall back to the first non-null index */
-                        index = dht_get_first_non_null_index (entry);
-
-                        if (index == -1) {
-                                /* None of the bricks in the subvol are up.
-                                 * CHILD_DOWN will kill the process soon */
+    int ret = 0;
+    int i = local_subvol_index;
+    char *str = NULL;
+    uint32_t hashval = 0;
+    int32_t index = 0;
+    dht_conf_t *conf = NULL;
+    char buf[UUID_CANONICAL_FORM_LEN + 1] = {
+        0,
+    };
+    subvol_nodeuuids_info_t *entry = NULL;
+
+    conf = this->private;
+
+    /* Pure distribute. A subvol in this case
+        will be handled by only one node */
+
+    entry = &(conf->local_nodeuuids[i]);
+    if (entry->count == 1) {
+        return 1;
+    }
+
+    str = uuid_utoa_r(gfid, buf);
+    ret = dht_hash_compute(this, 0, str, &hashval);
+    if (ret == 0) {
+        index = (hashval % entry->count);
+        if (entry->elements[index].info == REBAL_NODEUUID_MINE) {
+            /* Index matches this node's nodeuuid.*/
+            ret = 1;
+            goto out;
+        }
+
+        /* Brick down - some other node has to migrate these files*/
+        if (gf_uuid_is_null(entry->elements[index].uuid)) {
+            /* Fall back to the first non-null index */
+            index = dht_get_first_non_null_index(entry);
+
+            if (index == -1) {
+                /* None of the bricks in the subvol are up.
+                 * CHILD_DOWN will kill the process soon */
 
-                                return 0;
-                        }
+                return 0;
+            }
 
-                        if (entry->elements[index].info == REBAL_NODEUUID_MINE) {
-                                /* Index matches this node's nodeuuid.*/
-                                ret = 1;
-                                goto out;
-                        }
-                }
+            if (entry->elements[index].info == REBAL_NODEUUID_MINE) {
+                /* Index matches this node's nodeuuid.*/
+                ret = 1;
+                goto out;
+            }
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-gf_defrag_migrate_single_file (void *opaque)
+gf_defrag_migrate_single_file(void *opaque)
 {
-        xlator_t                *this           = NULL;
-        dht_conf_t              *conf           = NULL;
-        gf_defrag_info_t        *defrag         = NULL;
-        int                      ret            = 0;
-        gf_dirent_t             *entry          = NULL;
-        struct timeval           start          = {0,};
-        loc_t                    entry_loc      = {0,};
-        loc_t                   *loc            = NULL;
-        struct iatt              iatt           = {0,};
-        dict_t                  *migrate_data   = NULL;
-        struct timeval           end            = {0,};
-        double                   elapsed        = {0,};
-        struct dht_container    *rebal_entry    = NULL;
-        inode_t                 *inode          = NULL;
-        xlator_t                *hashed_subvol  = NULL;
-        xlator_t                *cached_subvol  = NULL;
-        call_frame_t            *statfs_frame   = NULL;
-        xlator_t                *old_THIS       = NULL;
-        data_t                  *tmp            = NULL;
-        int                      fop_errno      = 0;
-        gf_dht_migrate_data_type_t rebal_type   = GF_DHT_MIGRATE_DATA;
-        char                     value[MAX_REBAL_TYPE_SIZE]    = {0,};
-        struct iatt             *iatt_ptr       = NULL;
-        gf_boolean_t            update_skippedcount = _gf_true;
-        int                     i = 0;
-
-        rebal_entry = (struct dht_container *)opaque;
-        if (!rebal_entry) {
-                gf_log ("DHT", GF_LOG_ERROR, "rebal_entry is NULL");
-                ret = -1;
-                goto out;
-        }
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    int ret = 0;
+    gf_dirent_t *entry = NULL;
+    struct timeval start = {
+        0,
+    };
+    loc_t entry_loc = {
+        0,
+    };
+    loc_t *loc = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    dict_t *migrate_data = NULL;
+    struct timeval end = {
+        0,
+    };
+    double elapsed = {
+        0,
+    };
+    struct dht_container *rebal_entry = NULL;
+    inode_t *inode = NULL;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    call_frame_t *statfs_frame = NULL;
+    xlator_t *old_THIS = NULL;
+    data_t *tmp = NULL;
+    int fop_errno = 0;
+    gf_dht_migrate_data_type_t rebal_type = GF_DHT_MIGRATE_DATA;
+    char value[MAX_REBAL_TYPE_SIZE] = {
+        0,
+    };
+    struct iatt *iatt_ptr = NULL;
+    gf_boolean_t update_skippedcount = _gf_true;
+    int i = 0;
+
+    rebal_entry = (struct dht_container *)opaque;
+    if (!rebal_entry) {
+        gf_log("DHT", GF_LOG_ERROR, "rebal_entry is NULL");
+        ret = -1;
+        goto out;
+    }
 
-        this = rebal_entry->this;
+    this = rebal_entry->this;
 
-        conf = this->private;
+    conf = this->private;
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        loc = rebal_entry->parent_loc;
+    loc = rebal_entry->parent_loc;
 
-        migrate_data = rebal_entry->migrate_data;
+    migrate_data = rebal_entry->migrate_data;
 
-        entry = rebal_entry->df_entry;
-        iatt_ptr = &entry->d_stat;
+    entry = rebal_entry->df_entry;
+    iatt_ptr = &entry->d_stat;
 
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                ret = -1;
-                goto out;
-        }
-
-        if (defrag->stats == _gf_true) {
-                gettimeofday (&start, NULL);
-        }
-
-        if (defrag->defrag_pattern &&
-            (gf_defrag_pattern_match (defrag, entry->d_name,
-                                      entry->d_stat.ia_size) == _gf_false)) {
-                gf_log (this->name, GF_LOG_ERROR, "pattern_match failed");
-                goto out;
-        }
-
-        memset (&entry_loc, 0, sizeof (entry_loc));
-
-        ret = dht_build_child_loc (this, &entry_loc, loc, entry->d_name);
-        if (ret) {
-                LOCK (&defrag->lock);
-                {
-                        defrag->total_failures += 1;
-                }
-                UNLOCK (&defrag->lock);
+    if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+        ret = -1;
+        goto out;
+    }
 
-                ret = 0;
+    if (defrag->stats == _gf_true) {
+        gettimeofday(&start, NULL);
+    }
 
-                gf_log (this->name, GF_LOG_ERROR, "Child loc build failed");
+    if (defrag->defrag_pattern &&
+        (gf_defrag_pattern_match(defrag, entry->d_name,
+                                 entry->d_stat.ia_size) == _gf_false)) {
+        gf_log(this->name, GF_LOG_ERROR, "pattern_match failed");
+        goto out;
+    }
 
-                goto out;
-        }
+    memset(&entry_loc, 0, sizeof(entry_loc));
 
-        if (!gf_defrag_should_i_migrate (this, rebal_entry->local_subvol_index,
-                                         entry->d_stat.ia_gfid)) {
-                gf_msg_debug (this->name, 0, "Don't migrate %s ",
-                              entry_loc.path);
-                goto out;
+    ret = dht_build_child_loc(this, &entry_loc, loc, entry->d_name);
+    if (ret) {
+        LOCK(&defrag->lock);
+        {
+            defrag->total_failures += 1;
         }
+        UNLOCK(&defrag->lock);
 
-        gf_uuid_copy (entry_loc.gfid, entry->d_stat.ia_gfid);
+        ret = 0;
 
-        gf_uuid_copy (entry_loc.pargfid, loc->gfid);
+        gf_log(this->name, GF_LOG_ERROR, "Child loc build failed");
 
-        ret = syncop_lookup (this, &entry_loc, &iatt, NULL, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_MIGRATE_FILE_FAILED,
-                        "Migrate file failed: %s lookup failed",
-                        entry_loc.path);
-
-                /* Increase failure count only for remove-brick op, so that
-                 * user is warned to check the removed-brick for any files left
-                 * unmigrated
-                 */
-                if (conf->decommission_subvols_cnt) {
-                        LOCK (&defrag->lock);
-                        {
-                                defrag->total_failures += 1;
-                        }
-                        UNLOCK (&defrag->lock);
-                }
+        goto out;
+    }
 
-                ret = 0;
-                goto out;
-        }
+    if (!gf_defrag_should_i_migrate(this, rebal_entry->local_subvol_index,
+                                    entry->d_stat.ia_gfid)) {
+        gf_msg_debug(this->name, 0, "Don't migrate %s ", entry_loc.path);
+        goto out;
+    }
 
-        iatt_ptr = &iatt;
+    gf_uuid_copy(entry_loc.gfid, entry->d_stat.ia_gfid);
 
-        hashed_subvol = dht_subvol_get_hashed (this, &entry_loc);
-        if (!hashed_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "Failed to get hashed subvol for %s",
-                        entry_loc.path);
-                ret = 0;
-                goto out;
-        }
-
-        cached_subvol = dht_subvol_get_cached (this, entry_loc.inode);
-        if (!cached_subvol) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_CACHED_SUBVOL_GET_FAILED,
-                        "Failed to get cached subvol for %s",
-                        entry_loc.path);
-
-                ret = 0;
-                goto out;
-        }
+    gf_uuid_copy(entry_loc.pargfid, loc->gfid);
 
-        if (hashed_subvol == cached_subvol) {
-                ret = 0;
-                goto out;
-        }
+    ret = syncop_lookup(this, &entry_loc, &iatt, NULL, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_MIGRATE_FILE_FAILED,
+               "Migrate file failed: %s lookup failed", entry_loc.path);
 
-        inode = inode_link (entry_loc.inode, entry_loc.parent, entry->d_name, &iatt);
-        inode_unref (entry_loc.inode);
-        /* use the inode returned by inode_link */
-        entry_loc.inode = inode;
-
-        old_THIS = THIS;
-        THIS = this;
-        statfs_frame = create_frame (this, this->ctx->pool);
-        if (!statfs_frame) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
-                        "Insufficient memory. Frame creation failed");
-                ret = -1;
-                goto out;
+        /* Increase failure count only for remove-brick op, so that
+         * user is warned to check the removed-brick for any files left
+         * unmigrated
+         */
+        if (conf->decommission_subvols_cnt) {
+            LOCK(&defrag->lock);
+            {
+                defrag->total_failures += 1;
+            }
+            UNLOCK(&defrag->lock);
         }
 
-        /* async statfs information for honoring min-free-disk */
-        dht_get_du_info (statfs_frame, this, loc);
-        THIS = old_THIS;
+        ret = 0;
+        goto out;
+    }
 
-        tmp = dict_get (migrate_data, GF_XATTR_FILE_MIGRATE_KEY);
-        if (tmp) {
-                memcpy (value, tmp->data, tmp->len);
-                if (strcmp (value, "force") == 0)
-                        rebal_type = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+    iatt_ptr = &iatt;
 
-                if (conf->decommission_in_progress)
-                        rebal_type = GF_DHT_MIGRATE_HARDLINK;
-        }
+    hashed_subvol = dht_subvol_get_hashed(this, &entry_loc);
+    if (!hashed_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "Failed to get hashed subvol for %s", entry_loc.path);
+        ret = 0;
+        goto out;
+    }
 
-        ret = dht_migrate_file (this, &entry_loc, cached_subvol,
-                                hashed_subvol, rebal_type, &fop_errno);
-        if (ret == 1) {
-                if (fop_errno == ENOSPC) {
-                        gf_msg_debug (this->name, 0, "migrate-data skipped for"
-                                      " %s due to space constraints",
-                                      entry_loc.path);
-
-                        /* For remove-brick case if the source is not one of the
-                        * removed-brick, do not mark the error as failure */
-                        if (conf->decommission_subvols_cnt) {
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (conf->decommissioned_bricks[i] == cached_subvol) {
-                                                LOCK (&defrag->lock);
-                                                {
-                                                    defrag->total_failures += 1;
-                                                    update_skippedcount = _gf_false;
-                                                }
-                                                UNLOCK (&defrag->lock);
-
-                                                break;
-                                        }
-                                }
-                        }
+    cached_subvol = dht_subvol_get_cached(this, entry_loc.inode);
+    if (!cached_subvol) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_CACHED_SUBVOL_GET_FAILED,
+               "Failed to get cached subvol for %s", entry_loc.path);
 
-                        if (update_skippedcount) {
-                                LOCK (&defrag->lock);
-                                {
-                                        defrag->skipped += 1;
-                                }
-                                UNLOCK (&defrag->lock);
-
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_MIGRATE_FILE_SKIPPED,
-                                        "File migration skipped for %s.",
-                                        entry_loc.path);
-                        }
+        ret = 0;
+        goto out;
+    }
 
-                } else if (fop_errno == ENOTSUP) {
-                        gf_msg_debug (this->name, 0, "migrate-data skipped for"
-                                      " hardlink %s ", entry_loc.path);
-                        LOCK (&defrag->lock);
+    if (hashed_subvol == cached_subvol) {
+        ret = 0;
+        goto out;
+    }
+
+    inode = inode_link(entry_loc.inode, entry_loc.parent, entry->d_name, &iatt);
+    inode_unref(entry_loc.inode);
+    /* use the inode returned by inode_link */
+    entry_loc.inode = inode;
+
+    old_THIS = THIS;
+    THIS = this;
+    statfs_frame = create_frame(this, this->ctx->pool);
+    if (!statfs_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+               "Insufficient memory. Frame creation failed");
+        ret = -1;
+        goto out;
+    }
+
+    /* async statfs information for honoring min-free-disk */
+    dht_get_du_info(statfs_frame, this, loc);
+    THIS = old_THIS;
+
+    tmp = dict_get(migrate_data, GF_XATTR_FILE_MIGRATE_KEY);
+    if (tmp) {
+        memcpy(value, tmp->data, tmp->len);
+        if (strcmp(value, "force") == 0)
+            rebal_type = GF_DHT_MIGRATE_DATA_EVEN_IF_LINK_EXISTS;
+
+        if (conf->decommission_in_progress)
+            rebal_type = GF_DHT_MIGRATE_HARDLINK;
+    }
+
+    ret = dht_migrate_file(this, &entry_loc, cached_subvol, hashed_subvol,
+                           rebal_type, &fop_errno);
+    if (ret == 1) {
+        if (fop_errno == ENOSPC) {
+            gf_msg_debug(this->name, 0,
+                         "migrate-data skipped for"
+                         " %s due to space constraints",
+                         entry_loc.path);
+
+            /* For remove-brick case if the source is not one of the
+             * removed-brick, do not mark the error as failure */
+            if (conf->decommission_subvols_cnt) {
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (conf->decommissioned_bricks[i] == cached_subvol) {
+                        LOCK(&defrag->lock);
                         {
-                                defrag->skipped += 1;
+                            defrag->total_failures += 1;
+                            update_skippedcount = _gf_false;
                         }
-                        UNLOCK (&defrag->lock);
+                        UNLOCK(&defrag->lock);
 
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_MIGRATE_FILE_SKIPPED,
-                                "File migration skipped for %s.",
-                                entry_loc.path);
+                        break;
+                    }
                 }
+            }
 
-                ret = 0;
-                goto out;
-        } else if (ret < 0) {
-                if (fop_errno != EEXIST) {
-                        gf_msg (this->name, GF_LOG_ERROR, fop_errno,
-                                DHT_MSG_MIGRATE_FILE_FAILED,
-                                "migrate-data failed for %s", entry_loc.path);
-
-                        LOCK (&defrag->lock);
-                        {
-                                defrag->total_failures += 1;
-                        }
-                        UNLOCK (&defrag->lock);
-
+            if (update_skippedcount) {
+                LOCK(&defrag->lock);
+                {
+                    defrag->skipped += 1;
                 }
+                UNLOCK(&defrag->lock);
 
-                ret = gf_defrag_handle_migrate_error (fop_errno, defrag);
+                gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_MIGRATE_FILE_SKIPPED,
+                       "File migration skipped for %s.", entry_loc.path);
+            }
 
-                if (!ret) {
-                        gf_msg(this->name, GF_LOG_ERROR, fop_errno,
-                               DHT_MSG_MIGRATE_FILE_FAILED,
-                               "migrate-data on %s failed:", entry_loc.path);
-                } else if (ret == 1) {
-                        ret = 0;
-                }
+        } else if (fop_errno == ENOTSUP) {
+            gf_msg_debug(this->name, 0,
+                         "migrate-data skipped for"
+                         " hardlink %s ",
+                         entry_loc.path);
+            LOCK(&defrag->lock);
+            {
+                defrag->skipped += 1;
+            }
+            UNLOCK(&defrag->lock);
 
-                goto out;
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_MIGRATE_FILE_SKIPPED,
+                   "File migration skipped for %s.", entry_loc.path);
         }
 
-        LOCK (&defrag->lock);
-        {
-                defrag->total_files += 1;
-                defrag->total_data += iatt.ia_size;
-        }
-        UNLOCK (&defrag->lock);
-
-        if (defrag->stats == _gf_true) {
-                gettimeofday (&end, NULL);
-                elapsed = (end.tv_sec - start.tv_sec) * 1e6 +
-                          (end.tv_usec - start.tv_usec);
-                gf_log (this->name, GF_LOG_INFO, "Migration of "
-                        "file:%s size:%"PRIu64" bytes took %.2f"
-                        "secs and ret: %d", entry_loc.name,
-                        iatt.ia_size, elapsed/1e6, ret);
+        ret = 0;
+        goto out;
+    } else if (ret < 0) {
+        if (fop_errno != EEXIST) {
+            gf_msg(this->name, GF_LOG_ERROR, fop_errno,
+                   DHT_MSG_MIGRATE_FILE_FAILED, "migrate-data failed for %s",
+                   entry_loc.path);
+
+            LOCK(&defrag->lock);
+            {
+                defrag->total_failures += 1;
+            }
+            UNLOCK(&defrag->lock);
         }
 
+        ret = gf_defrag_handle_migrate_error(fop_errno, defrag);
+
+        if (!ret) {
+            gf_msg(this->name, GF_LOG_ERROR, fop_errno,
+                   DHT_MSG_MIGRATE_FILE_FAILED,
+                   "migrate-data on %s failed:", entry_loc.path);
+        } else if (ret == 1) {
+            ret = 0;
+        }
+
+        goto out;
+    }
+
+    LOCK(&defrag->lock);
+    {
+        defrag->total_files += 1;
+        defrag->total_data += iatt.ia_size;
+    }
+    UNLOCK(&defrag->lock);
+
+    if (defrag->stats == _gf_true) {
+        gettimeofday(&end, NULL);
+        elapsed = (end.tv_sec - start.tv_sec) * 1e6 +
+                  (end.tv_usec - start.tv_usec);
+        gf_log(this->name, GF_LOG_INFO,
+               "Migration of "
+               "file:%s size:%" PRIu64
+               " bytes took %.2f"
+               "secs and ret: %d",
+               entry_loc.name, iatt.ia_size, elapsed / 1e6, ret);
+    }
+
 out:
-        if (statfs_frame) {
-                STACK_DESTROY (statfs_frame->root);
-        }
+    if (statfs_frame) {
+        STACK_DESTROY(statfs_frame->root);
+    }
 
-        if (iatt_ptr) {
-                LOCK (&defrag->lock);
-                {
-                        defrag->size_processed += iatt_ptr->ia_size;
-                }
-                UNLOCK (&defrag->lock);
+    if (iatt_ptr) {
+        LOCK(&defrag->lock);
+        {
+            defrag->size_processed += iatt_ptr->ia_size;
         }
-        loc_wipe (&entry_loc);
-
-        return ret;
+        UNLOCK(&defrag->lock);
+    }
+    loc_wipe(&entry_loc);
 
+    return ret;
 }
 
 void *
-gf_defrag_task (void *opaque)
+gf_defrag_task(void *opaque)
 {
-        struct list_head        *q_head         = NULL;
-        struct dht_container    *iterator       = NULL;
-        gf_defrag_info_t        *defrag         = NULL;
-        int                      ret            = 0;
-        pid_t                    pid            = GF_CLIENT_PID_DEFRAG;
-
-        defrag = (gf_defrag_info_t *)opaque;
-        if (!defrag) {
-                gf_msg ("dht", GF_LOG_ERROR, 0, 0, "defrag is NULL");
-                goto out;
+    struct list_head *q_head = NULL;
+    struct dht_container *iterator = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    int ret = 0;
+    pid_t pid = GF_CLIENT_PID_DEFRAG;
+
+    defrag = (gf_defrag_info_t *)opaque;
+    if (!defrag) {
+        gf_msg("dht", GF_LOG_ERROR, 0, 0, "defrag is NULL");
+        goto out;
+    }
+
+    syncopctx_setfspid(&pid);
+
+    q_head = &(defrag->queue[0].list);
+
+    /* The following while loop will dequeue one entry from the defrag->queue
+       under lock. We will update the defrag->global_error only when there
+       is an error which is critical to stop the rebalance process. The stop
+       message will be intimated to other migrator threads by setting the
+       defrag->defrag_status to GF_DEFRAG_STATUS_FAILED.
+
+       In defrag->queue, a low watermark (MIN_MIGRATE_QUEUE_COUNT) is
+       maintained so that crawler does not starve the file migration
+       workers and a high watermark (MAX_MIGRATE_QUEUE_COUNT) so that
+       crawler does not go far ahead in filling up the queue.
+     */
+
+    while (_gf_true) {
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
+            pthread_cond_broadcast(&defrag->parallel_migration_cond);
+            goto out;
         }
 
-        syncopctx_setfspid (&pid);
+        pthread_mutex_lock(&defrag->dfq_mutex);
+        {
+            /*Throttle down:
+              If the reconfigured count is less than current thread
+              count, then the current thread will sleep */
+
+            /*TODO: Need to refactor the following block to work
+             *under defrag->lock. For now access
+             * defrag->current_thread_count and rthcount under
+             * dfq_mutex lock */
+            while (!defrag->crawl_done && (defrag->recon_thread_count <
+                                           defrag->current_thread_count)) {
+                defrag->current_thread_count--;
+                gf_msg_debug("DHT", 0,
+                             "Thread sleeping. "
+                             "current thread count: %d",
+                             defrag->current_thread_count);
+
+                pthread_cond_wait(&defrag->df_wakeup_thread,
+                                  &defrag->dfq_mutex);
+
+                defrag->current_thread_count++;
+                gf_msg_debug("DHT", 0,
+                             "Thread wokeup. "
+                             "current thread count: %d",
+                             defrag->current_thread_count);
+            }
+
+            if (defrag->q_entry_count) {
+                iterator = list_entry(q_head->next, typeof(*iterator), list);
+
+                gf_msg_debug("DHT", 0,
+                             "picking entry "
+                             "%s",
+                             iterator->df_entry->d_name);
+
+                list_del_init(&(iterator->list));
+
+                defrag->q_entry_count--;
+
+                if ((defrag->q_entry_count < MIN_MIGRATE_QUEUE_COUNT) &&
+                    defrag->wakeup_crawler) {
+                    pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
+                }
+                pthread_mutex_unlock(&defrag->dfq_mutex);
+                ret = gf_defrag_migrate_single_file((void *)iterator);
 
-        q_head = &(defrag->queue[0].list);
+                /*Critical errors: ENOTCONN and ENOSPACE*/
+                if (ret) {
+                    dht_set_global_defrag_error(defrag, ret);
 
-       /* The following while loop will dequeue one entry from the defrag->queue
-          under lock. We will update the defrag->global_error only when there
-          is an error which is critical to stop the rebalance process. The stop
-          message will be intimated to other migrator threads by setting the
-          defrag->defrag_status to GF_DEFRAG_STATUS_FAILED.
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-          In defrag->queue, a low watermark (MIN_MIGRATE_QUEUE_COUNT) is
-          maintained so that crawler does not starve the file migration
-          workers and a high watermark (MAX_MIGRATE_QUEUE_COUNT) so that
-          crawler does not go far ahead in filling up the queue.
-        */
+                    pthread_cond_broadcast(&defrag->rebalance_crawler_alarm);
 
-        while (_gf_true) {
+                    pthread_cond_broadcast(&defrag->parallel_migration_cond);
 
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        pthread_cond_broadcast (
-                                &defrag->rebalance_crawler_alarm);
-                        pthread_cond_broadcast (
-                                &defrag->parallel_migration_cond);
-                        goto out;
+                    goto out;
                 }
 
-                pthread_mutex_lock (&defrag->dfq_mutex);
-                {
-
-                        /*Throttle down:
-                          If the reconfigured count is less than current thread
-                          count, then the current thread will sleep */
-
-                        /*TODO: Need to refactor the following block to work
-                         *under defrag->lock. For now access
-                         * defrag->current_thread_count and rthcount under
-                         * dfq_mutex lock */
-                        while (!defrag->crawl_done &&
-                              (defrag->recon_thread_count <
-                                        defrag->current_thread_count)) {
-                                defrag->current_thread_count--;
-                                gf_msg_debug ("DHT", 0, "Thread sleeping. "
-                                              "current thread count: %d",
-                                              defrag->current_thread_count);
-
-                                pthread_cond_wait (
-                                           &defrag->df_wakeup_thread,
-                                           &defrag->dfq_mutex);
-
-                                defrag->current_thread_count++;
-                                gf_msg_debug ("DHT", 0, "Thread wokeup. "
-                                              "current thread count: %d",
-                                              defrag->current_thread_count);
-
-                        }
+                gf_defrag_free_container(iterator);
+
+                continue;
+            } else {
+                /* defrag->crawl_done flag is set means crawling
+                 file system is done and hence a list_empty when
+                 the above flag is set indicates there are no more
+                 entries to be added to the queue and rebalance is
+                 finished */
+
+                if (!defrag->crawl_done) {
+                    defrag->current_thread_count--;
+                    gf_msg_debug("DHT", 0,
+                                 "Thread "
+                                 "sleeping while  waiting "
+                                 "for migration entries. "
+                                 "current thread  count:%d",
+                                 defrag->current_thread_count);
+
+                    pthread_cond_wait(&defrag->parallel_migration_cond,
+                                      &defrag->dfq_mutex);
+                }
 
-                        if (defrag->q_entry_count) {
-                                iterator = list_entry (q_head->next,
-                                                typeof(*iterator), list);
-
-                                gf_msg_debug ("DHT", 0, "picking entry "
-                                              "%s", iterator->df_entry->d_name);
-
-                                list_del_init (&(iterator->list));
-
-                                defrag->q_entry_count--;
-
-                                if ((defrag->q_entry_count <
-                                        MIN_MIGRATE_QUEUE_COUNT) &&
-                                        defrag->wakeup_crawler) {
-                                        pthread_cond_broadcast (
-                                              &defrag->rebalance_crawler_alarm);
-                                }
-                                pthread_mutex_unlock (&defrag->dfq_mutex);
-                                ret = gf_defrag_migrate_single_file
-                                                        ((void *)iterator);
-
-                                /*Critical errors: ENOTCONN and ENOSPACE*/
-                                if (ret) {
-                                        dht_set_global_defrag_error
-                                                         (defrag, ret);
-
-                                        defrag->defrag_status =
-                                                       GF_DEFRAG_STATUS_FAILED;
-
-                                        pthread_cond_broadcast (
-                                             &defrag->rebalance_crawler_alarm);
-
-                                        pthread_cond_broadcast (
-                                             &defrag->parallel_migration_cond);
-
-                                        goto out;
-                                }
-
-                                gf_defrag_free_container (iterator);
-
-                                continue;
-                        } else {
-
-                        /* defrag->crawl_done flag is set means crawling
-                         file system is done and hence a list_empty when
-                         the above flag is set indicates there are no more
-                         entries to be added to the queue and rebalance is
-                         finished */
-
-                                if (!defrag->crawl_done) {
-
-                                        defrag->current_thread_count--;
-                                        gf_msg_debug ("DHT", 0, "Thread "
-                                                      "sleeping while  waiting "
-                                                      "for migration entries. "
-                                                      "current thread  count:%d",
-                                                      defrag->current_thread_count);
-
-                                        pthread_cond_wait (
-                                           &defrag->parallel_migration_cond,
-                                           &defrag->dfq_mutex);
-                                }
-
-                                if (defrag->crawl_done &&
-                                                 !defrag->q_entry_count) {
-                                        defrag->current_thread_count++;
-                                        gf_msg_debug ("DHT", 0, "Exiting thread");
-
-                                        pthread_cond_broadcast (
-                                             &defrag->parallel_migration_cond);
-                                        goto unlock;
-                                } else {
-                                        defrag->current_thread_count++;
-                                        gf_msg_debug ("DHT", 0, "Thread woke up"
-                                                      " as found migrating entries. "
-                                                      "current thread count:%d",
-                                                      defrag->current_thread_count);
-
-                                        pthread_mutex_unlock
-                                                 (&defrag->dfq_mutex);
-                                        continue;
-                                }
-                        }
+                if (defrag->crawl_done && !defrag->q_entry_count) {
+                    defrag->current_thread_count++;
+                    gf_msg_debug("DHT", 0, "Exiting thread");
 
+                    pthread_cond_broadcast(&defrag->parallel_migration_cond);
+                    goto unlock;
+                } else {
+                    defrag->current_thread_count++;
+                    gf_msg_debug("DHT", 0,
+                                 "Thread woke up"
+                                 " as found migrating entries. "
+                                 "current thread count:%d",
+                                 defrag->current_thread_count);
+
+                    pthread_mutex_unlock(&defrag->dfq_mutex);
+                    continue;
                 }
-unlock:
-                pthread_mutex_unlock (&defrag->dfq_mutex);
-                break;
+            }
         }
+    unlock:
+        pthread_mutex_unlock(&defrag->dfq_mutex);
+        break;
+    }
 out:
-        return NULL;
+    return NULL;
 }
 
-int static
-gf_defrag_get_entry (xlator_t *this, int i, struct dht_container **container,
-                     loc_t *loc, dht_conf_t *conf, gf_defrag_info_t *defrag,
-                     fd_t *fd, dict_t *migrate_data,
-                     struct dir_dfmeta *dir_dfmeta, dict_t *xattr_req,
-                     int *should_commit_hash, int *perrno)
+int static gf_defrag_get_entry(xlator_t *this, int i,
+                               struct dht_container **container, loc_t *loc,
+                               dht_conf_t *conf, gf_defrag_info_t *defrag,
+                               fd_t *fd, dict_t *migrate_data,
+                               struct dir_dfmeta *dir_dfmeta, dict_t *xattr_req,
+                               int *should_commit_hash, int *perrno)
 {
-        int                     ret             = -1;
-        char                    is_linkfile     = 0;
-        gf_dirent_t            *df_entry        = NULL;
-        struct dht_container   *tmp_container   = NULL;
+    int ret = -1;
+    char is_linkfile = 0;
+    gf_dirent_t *df_entry = NULL;
+    struct dht_container *tmp_container = NULL;
 
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                ret = -1;
-                goto out;
-        }
-
-        if (dir_dfmeta->offset_var[i].readdir_done == 1) {
-                ret = 0;
-                goto out;
-        }
-
-        if (dir_dfmeta->fetch_entries[i] == 1) {
-                ret = syncop_readdirp (conf->local_subvols[i], fd, 131072,
-                                       dir_dfmeta->offset_var[i].offset,
-                                       &(dir_dfmeta->equeue[i]),
-                                       xattr_req, NULL);
-                if (ret == 0) {
-                        dir_dfmeta->offset_var[i].readdir_done = 1;
-                        ret = 0;
-                        goto out;
-                }
-
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_WARNING, -ret,
-                                DHT_MSG_MIGRATE_DATA_FAILED,
-                                "Readdirp failed. Aborting data migration for "
-                                "directory: %s", loc->path);
-                        *perrno = -ret;
-                        ret = -1;
-                        goto out;
-                }
+    if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+        ret = -1;
+        goto out;
+    }
 
-                if (list_empty (&(dir_dfmeta->equeue[i].list))) {
-                        dir_dfmeta->offset_var[i].readdir_done = 1;
-                        ret = 0;
-                        goto out;
-                }
+    if (dir_dfmeta->offset_var[i].readdir_done == 1) {
+        ret = 0;
+        goto out;
+    }
 
-                dir_dfmeta->fetch_entries[i] = 0;
+    if (dir_dfmeta->fetch_entries[i] == 1) {
+        ret = syncop_readdirp(conf->local_subvols[i], fd, 131072,
+                              dir_dfmeta->offset_var[i].offset,
+                              &(dir_dfmeta->equeue[i]), xattr_req, NULL);
+        if (ret == 0) {
+            dir_dfmeta->offset_var[i].readdir_done = 1;
+            ret = 0;
+            goto out;
         }
 
-        while (1) {
-
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        ret = -1;
-                        goto out;
-                }
-
-                df_entry = list_entry (dir_dfmeta->iterator[i]->next,
-                                       typeof (*df_entry), list);
-
-                if (&df_entry->list == dir_dfmeta->head[i]) {
-                        gf_dirent_free (&(dir_dfmeta->equeue[i]));
-                        INIT_LIST_HEAD (&(dir_dfmeta->equeue[i].list));
-                        dir_dfmeta->fetch_entries[i] = 1;
-                        dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
-                        ret = 0;
-                        goto out;
-                }
-
-                dir_dfmeta->iterator[i] = dir_dfmeta->iterator[i]->next;
-
-                dir_dfmeta->offset_var[i].offset = df_entry->d_off;
-                if (!strcmp (df_entry->d_name, ".") ||
-                    !strcmp (df_entry->d_name, ".."))
-                        continue;
-
-                if (IA_ISDIR (df_entry->d_stat.ia_type)) {
-                        defrag->size_processed += df_entry->d_stat.ia_size;
-                        continue;
-                }
-
-                defrag->num_files_lookedup++;
-
-                if (defrag->defrag_pattern &&
-                    (gf_defrag_pattern_match (defrag, df_entry->d_name,
-                                              df_entry->d_stat.ia_size)
-                     == _gf_false)) {
-                        defrag->size_processed += df_entry->d_stat.ia_size;
-                        continue;
-                }
-
-                is_linkfile = check_is_linkfile (NULL, &df_entry->d_stat,
-                                                 df_entry->dict,
-                                                 conf->link_xattr_name);
-
-                if (is_linkfile) {
-                        /* No need to add linkto file to the queue for
-                           migration. Only the actual data file need to
-                           be checked for migration criteria.
-                        */
-
-                        gf_msg_debug (this->name, 0, "Skipping linkfile"
-                                      " %s on subvol: %s", df_entry->d_name,
-                                      conf->local_subvols[i]->name);
-                        continue;
-                }
-
-                /*Build Container Structure */
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_WARNING, -ret,
+                   DHT_MSG_MIGRATE_DATA_FAILED,
+                   "Readdirp failed. Aborting data migration for "
+                   "directory: %s",
+                   loc->path);
+            *perrno = -ret;
+            ret = -1;
+            goto out;
+        }
 
-                tmp_container =  GF_CALLOC (1, sizeof(struct dht_container),
-                                            gf_dht_mt_container_t);
-                if (!tmp_container) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for container");
-                        ret = -1;
-                        goto out;
-                }
-                tmp_container->df_entry = gf_dirent_for_name (df_entry->d_name);
-                if (!tmp_container->df_entry) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for df_entry");
-                        ret = -1;
-                        goto out;
-                }
+        if (list_empty(&(dir_dfmeta->equeue[i].list))) {
+            dir_dfmeta->offset_var[i].readdir_done = 1;
+            ret = 0;
+            goto out;
+        }
 
-                tmp_container->local_subvol_index = i;
+        dir_dfmeta->fetch_entries[i] = 0;
+    }
 
-                tmp_container->df_entry->d_stat = df_entry->d_stat;
+    while (1) {
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            ret = -1;
+            goto out;
+        }
 
-                tmp_container->df_entry->d_ino  = df_entry->d_ino;
+        df_entry = list_entry(dir_dfmeta->iterator[i]->next, typeof(*df_entry),
+                              list);
 
-                tmp_container->df_entry->d_type = df_entry->d_type;
+        if (&df_entry->list == dir_dfmeta->head[i]) {
+            gf_dirent_free(&(dir_dfmeta->equeue[i]));
+            INIT_LIST_HEAD(&(dir_dfmeta->equeue[i].list));
+            dir_dfmeta->fetch_entries[i] = 1;
+            dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
+            ret = 0;
+            goto out;
+        }
 
-                tmp_container->df_entry->d_len  = df_entry->d_len;
+        dir_dfmeta->iterator[i] = dir_dfmeta->iterator[i]->next;
 
-                tmp_container->parent_loc = GF_CALLOC(1, sizeof(*loc),
-                                                      gf_dht_mt_loc_t);
-                if (!tmp_container->parent_loc) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to allocate "
-                                "memory for loc");
-                        ret = -1;
-                        goto out;
-                }
+        dir_dfmeta->offset_var[i].offset = df_entry->d_off;
+        if (!strcmp(df_entry->d_name, ".") || !strcmp(df_entry->d_name, ".."))
+            continue;
 
+        if (IA_ISDIR(df_entry->d_stat.ia_type)) {
+            defrag->size_processed += df_entry->d_stat.ia_size;
+            continue;
+        }
 
-                ret = loc_copy (tmp_container->parent_loc, loc);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "loc_copy failed");
-                        ret = -1;
-                        goto out;
-                }
+        defrag->num_files_lookedup++;
 
-                tmp_container->migrate_data = migrate_data;
+        if (defrag->defrag_pattern &&
+            (gf_defrag_pattern_match(defrag, df_entry->d_name,
+                                     df_entry->d_stat.ia_size) == _gf_false)) {
+            defrag->size_processed += df_entry->d_stat.ia_size;
+            continue;
+        }
 
-                tmp_container->this = this;
+        is_linkfile = check_is_linkfile(NULL, &df_entry->d_stat, df_entry->dict,
+                                        conf->link_xattr_name);
 
-                if (df_entry->dict)
-                        tmp_container->df_entry->dict =
-                                        dict_ref (df_entry->dict);
+        if (is_linkfile) {
+            /* No need to add linkto file to the queue for
+               migration. Only the actual data file need to
+               be checked for migration criteria.
+            */
 
-               /*Build Container Structure >> END*/
+            gf_msg_debug(this->name, 0,
+                         "Skipping linkfile"
+                         " %s on subvol: %s",
+                         df_entry->d_name, conf->local_subvols[i]->name);
+            continue;
+        }
 
-                ret = 0;
-                goto out;
+        /*Build Container Structure */
 
+        tmp_container = GF_CALLOC(1, sizeof(struct dht_container),
+                                  gf_dht_mt_container_t);
+        if (!tmp_container) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for container");
+            ret = -1;
+            goto out;
         }
-
-out:
-        if (ret == 0) {
-                *container = tmp_container;
-        } else {
-                if (tmp_container) {
-                        gf_defrag_free_container (tmp_container);
-                }
+        tmp_container->df_entry = gf_dirent_for_name(df_entry->d_name);
+        if (!tmp_container->df_entry) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for df_entry");
+            ret = -1;
+            goto out;
         }
 
-        return ret;
-}
+        tmp_container->local_subvol_index = i;
 
-int
-gf_defrag_process_dir (xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
-                       dict_t *migrate_data, int *perrno)
-{
-        int                      ret               = -1;
-        fd_t                    *fd                = NULL;
-        dht_conf_t              *conf              = NULL;
-        gf_dirent_t              entries;
-        dict_t                  *xattr_req         = NULL;
-        struct timeval           dir_start         = {0,};
-        struct timeval           end               = {0,};
-        double                   elapsed           = {0,};
-        int                      local_subvols_cnt = 0;
-        int                      i                 = 0;
-        int                      j                 = 0;
-        struct  dht_container   *container         = NULL;
-        int                      ldfq_count        = 0;
-        int                      dfc_index         = 0;
-        int                      throttle_up       = 0;
-        struct dir_dfmeta       *dir_dfmeta        = NULL;
-        int                      should_commit_hash = 1;
-
-        gf_log (this->name, GF_LOG_INFO, "migrate data called on %s",
-                loc->path);
-        gettimeofday (&dir_start, NULL);
+        tmp_container->df_entry->d_stat = df_entry->d_stat;
 
-        conf = this->private;
-        local_subvols_cnt = conf->local_subvols_cnt;
+        tmp_container->df_entry->d_ino = df_entry->d_ino;
 
-        if (!local_subvols_cnt) {
-                ret = 0;
-                goto out;
-        }
+        tmp_container->df_entry->d_type = df_entry->d_type;
 
-        fd = fd_create (loc->inode, defrag->pid);
-        if (!fd) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to create fd");
-                ret = -1;
-                goto out;
-        }
+        tmp_container->df_entry->d_len = df_entry->d_len;
 
-        ret = syncop_opendir (this, loc, fd, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_MIGRATE_DATA_FAILED,
-                        "Migrate data failed: Failed to open dir %s",
-                        loc->path);
-                *perrno = -ret;
-                ret = -1;
-                goto out;
+        tmp_container->parent_loc = GF_CALLOC(1, sizeof(*loc), gf_dht_mt_loc_t);
+        if (!tmp_container->parent_loc) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to allocate "
+                   "memory for loc");
+            ret = -1;
+            goto out;
         }
 
-        fd_bind (fd);
-        dir_dfmeta = GF_CALLOC (1, sizeof (*dir_dfmeta),
-                                                gf_common_mt_pointer);
-        if (!dir_dfmeta) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta is NULL");
-                ret = -1;
-                goto out;
+        ret = loc_copy(tmp_container->parent_loc, loc);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR, "loc_copy failed");
+            ret = -1;
+            goto out;
         }
 
+        tmp_container->migrate_data = migrate_data;
 
-        dir_dfmeta->head = GF_CALLOC (local_subvols_cnt,
-                                      sizeof (*(dir_dfmeta->head)),
-                                      gf_common_mt_pointer);
-        if (!dir_dfmeta->head) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta->head is NULL");
-                ret = -1;
-                goto out;
-        }
+        tmp_container->this = this;
 
-        dir_dfmeta->iterator = GF_CALLOC (local_subvols_cnt,
-                                          sizeof (*(dir_dfmeta->iterator)),
-                                          gf_common_mt_pointer);
-        if (!dir_dfmeta->iterator) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->iterator is NULL");
-                ret = -1;
-                goto out;
-        }
+        if (df_entry->dict)
+            tmp_container->df_entry->dict = dict_ref(df_entry->dict);
 
-        dir_dfmeta->equeue = GF_CALLOC (local_subvols_cnt, sizeof (entries),
-                                        gf_dht_mt_dirent_t);
-        if (!dir_dfmeta->equeue) {
-                gf_log (this->name, GF_LOG_ERROR, "dir_dfmeta->equeue is NULL");
-                ret = -1;
-                goto out;
-        }
+        /*Build Container Structure >> END*/
 
-        dir_dfmeta->offset_var = GF_CALLOC (local_subvols_cnt,
-                                            sizeof (dht_dfoffset_ctx_t),
-                                            gf_dht_mt_octx_t);
-        if (!dir_dfmeta->offset_var) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->offset_var is NULL");
-                ret = -1;
-                goto out;
-        }
-        ret = gf_defrag_ctx_subvols_init (dir_dfmeta->offset_var, this);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "dht_dfoffset_ctx_t"
-                        "initialization failed");
-                ret = -1;
-                goto out;
-        }
-
-        dir_dfmeta->fetch_entries = GF_CALLOC (local_subvols_cnt,
-                                               sizeof (int), gf_common_mt_int);
-        if (!dir_dfmeta->fetch_entries) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dir_dfmeta->fetch_entries is NULL");
-                ret = -1;
-                goto out;
-        }
-
-        for (i = 0; i < local_subvols_cnt ; i++) {
-                INIT_LIST_HEAD (&(dir_dfmeta->equeue[i].list));
-                dir_dfmeta->head[i]          = &(dir_dfmeta->equeue[i].list);
-                dir_dfmeta->iterator[i]      = dir_dfmeta->head[i];
-                dir_dfmeta->fetch_entries[i] = 1;
-        }
+        ret = 0;
+        goto out;
+    }
 
-        xattr_req = dict_new ();
-        if (!xattr_req) {
-               gf_log (this->name, GF_LOG_ERROR, "dict_new failed");
-               ret = -1;
-               goto out;
+out:
+    if (ret == 0) {
+        *container = tmp_container;
+    } else {
+        if (tmp_container) {
+            gf_defrag_free_container(tmp_container);
         }
+    }
 
-        ret = dict_set_uint32 (xattr_req,
-                               conf->link_xattr_name, 256);
-        if (ret) {
-               gf_log (this->name, GF_LOG_ERROR, "failed to set dict for "
-                       "key: %s", conf->link_xattr_name);
-               ret = -1;
-               goto out;
-        }
+    return ret;
+}
 
-        /*
-         Job: Read entries from each local subvol and store the entries
-              in equeue array of linked list. Now pick one entry from the
-              equeue array in a round robin basis and add them to defrag Queue.
-        */
+int
+gf_defrag_process_dir(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                      dict_t *migrate_data, int *perrno)
+{
+    int ret = -1;
+    fd_t *fd = NULL;
+    dht_conf_t *conf = NULL;
+    gf_dirent_t entries;
+    dict_t *xattr_req = NULL;
+    struct timeval dir_start = {
+        0,
+    };
+    struct timeval end = {
+        0,
+    };
+    double elapsed = {
+        0,
+    };
+    int local_subvols_cnt = 0;
+    int i = 0;
+    int j = 0;
+    struct dht_container *container = NULL;
+    int ldfq_count = 0;
+    int dfc_index = 0;
+    int throttle_up = 0;
+    struct dir_dfmeta *dir_dfmeta = NULL;
+    int should_commit_hash = 1;
+
+    gf_log(this->name, GF_LOG_INFO, "migrate data called on %s", loc->path);
+    gettimeofday(&dir_start, NULL);
+
+    conf = this->private;
+    local_subvols_cnt = conf->local_subvols_cnt;
+
+    if (!local_subvols_cnt) {
+        ret = 0;
+        goto out;
+    }
 
-        while (!dht_dfreaddirp_done(dir_dfmeta->offset_var,
-                                         local_subvols_cnt)) {
+    fd = fd_create(loc->inode, defrag->pid);
+    if (!fd) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to create fd");
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_opendir(this, loc, fd, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_MIGRATE_DATA_FAILED,
+               "Migrate data failed: Failed to open dir %s", loc->path);
+        *perrno = -ret;
+        ret = -1;
+        goto out;
+    }
 
-                pthread_mutex_lock (&defrag->dfq_mutex);
-                {
+    fd_bind(fd);
+    dir_dfmeta = GF_CALLOC(1, sizeof(*dir_dfmeta), gf_common_mt_pointer);
+    if (!dir_dfmeta) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta is NULL");
+        ret = -1;
+        goto out;
+    }
 
-                      /*Throttle up: If reconfigured count is higher than
-                        current thread count, wake up the sleeping threads
-                        TODO: Need to refactor this. Instead of making the
-                        thread sleep and wake, we should terminate and spawn
-                        threads on-demand*/
-
-                        if (defrag->recon_thread_count >
-                                         defrag->current_thread_count) {
-                                throttle_up =
-                                        (defrag->recon_thread_count -
-                                            defrag->current_thread_count);
-                                for (j = 0; j < throttle_up; j++) {
-                                        pthread_cond_signal (
-                                             &defrag->df_wakeup_thread);
-                                }
+    dir_dfmeta->head = GF_CALLOC(local_subvols_cnt, sizeof(*(dir_dfmeta->head)),
+                                 gf_common_mt_pointer);
+    if (!dir_dfmeta->head) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->head is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    dir_dfmeta->iterator = GF_CALLOC(local_subvols_cnt,
+                                     sizeof(*(dir_dfmeta->iterator)),
+                                     gf_common_mt_pointer);
+    if (!dir_dfmeta->iterator) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->iterator is NULL");
+        ret = -1;
+        goto out;
+    }
 
-                        }
+    dir_dfmeta->equeue = GF_CALLOC(local_subvols_cnt, sizeof(entries),
+                                   gf_dht_mt_dirent_t);
+    if (!dir_dfmeta->equeue) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->equeue is NULL");
+        ret = -1;
+        goto out;
+    }
 
-                        while (defrag->q_entry_count >
-                                        MAX_MIGRATE_QUEUE_COUNT) {
-                                defrag->wakeup_crawler = 1;
-                                pthread_cond_wait (
-                                        &defrag->rebalance_crawler_alarm,
-                                        &defrag->dfq_mutex);
-                        }
+    dir_dfmeta->offset_var = GF_CALLOC(
+        local_subvols_cnt, sizeof(dht_dfoffset_ctx_t), gf_dht_mt_octx_t);
+    if (!dir_dfmeta->offset_var) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->offset_var is NULL");
+        ret = -1;
+        goto out;
+    }
+    ret = gf_defrag_ctx_subvols_init(dir_dfmeta->offset_var, this);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "dht_dfoffset_ctx_t"
+               "initialization failed");
+        ret = -1;
+        goto out;
+    }
 
-                       ldfq_count = defrag->q_entry_count;
+    dir_dfmeta->fetch_entries = GF_CALLOC(local_subvols_cnt, sizeof(int),
+                                          gf_common_mt_int);
+    if (!dir_dfmeta->fetch_entries) {
+        gf_log(this->name, GF_LOG_ERROR, "dir_dfmeta->fetch_entries is NULL");
+        ret = -1;
+        goto out;
+    }
+
+    for (i = 0; i < local_subvols_cnt; i++) {
+        INIT_LIST_HEAD(&(dir_dfmeta->equeue[i].list));
+        dir_dfmeta->head[i] = &(dir_dfmeta->equeue[i].list);
+        dir_dfmeta->iterator[i] = dir_dfmeta->head[i];
+        dir_dfmeta->fetch_entries[i] = 1;
+    }
+
+    xattr_req = dict_new();
+    if (!xattr_req) {
+        gf_log(this->name, GF_LOG_ERROR, "dict_new failed");
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set dict for "
+               "key: %s",
+               conf->link_xattr_name);
+        ret = -1;
+        goto out;
+    }
 
-                       if (defrag->wakeup_crawler) {
-                               defrag->wakeup_crawler = 0;
-                       }
+    /*
+     Job: Read entries from each local subvol and store the entries
+          in equeue array of linked list. Now pick one entry from the
+          equeue array in a round robin basis and add them to defrag Queue.
+    */
 
+    while (!dht_dfreaddirp_done(dir_dfmeta->offset_var, local_subvols_cnt)) {
+        pthread_mutex_lock(&defrag->dfq_mutex);
+        {
+            /*Throttle up: If reconfigured count is higher than
+              current thread count, wake up the sleeping threads
+              TODO: Need to refactor this. Instead of making the
+              thread sleep and wake, we should terminate and spawn
+              threads on-demand*/
+
+            if (defrag->recon_thread_count > defrag->current_thread_count) {
+                throttle_up = (defrag->recon_thread_count -
+                               defrag->current_thread_count);
+                for (j = 0; j < throttle_up; j++) {
+                    pthread_cond_signal(&defrag->df_wakeup_thread);
                 }
-                pthread_mutex_unlock (&defrag->dfq_mutex);
-
-                while (ldfq_count <= MAX_MIGRATE_QUEUE_COUNT &&
-                       !dht_dfreaddirp_done(dir_dfmeta->offset_var,
-                                               local_subvols_cnt)) {
+            }
 
-                        ret = gf_defrag_get_entry (this, dfc_index, &container,
-                                                   loc, conf, defrag, fd,
-                                                   migrate_data, dir_dfmeta,
-                                                   xattr_req,
-                                                   &should_commit_hash, perrno);
+            while (defrag->q_entry_count > MAX_MIGRATE_QUEUE_COUNT) {
+                defrag->wakeup_crawler = 1;
+                pthread_cond_wait(&defrag->rebalance_crawler_alarm,
+                                  &defrag->dfq_mutex);
+            }
 
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_WARNING, "Found "
-                                        "error from gf_defrag_get_entry");
+            ldfq_count = defrag->q_entry_count;
 
-                                ret = -1;
-                                goto out;
-                        }
-
-                        /* Check if we got an entry, else we need to move the
-                           index to the next subvol */
-                        if (!container) {
-                                GF_CRAWL_INDEX_MOVE(dfc_index,
-                                                    local_subvols_cnt);
-                                continue;
-                        }
+            if (defrag->wakeup_crawler) {
+                defrag->wakeup_crawler = 0;
+            }
+        }
+        pthread_mutex_unlock(&defrag->dfq_mutex);
 
-                        /* Q this entry in the dfq */
-                        pthread_mutex_lock (&defrag->dfq_mutex);
-                        {
-                                list_add_tail (&container->list,
-                                        &(defrag->queue[0].list));
-                                defrag->q_entry_count++;
-                                ldfq_count = defrag->q_entry_count;
-
-                                gf_msg_debug (this->name, 0, "added "
-                                              "file:%s parent:%s to the queue ",
-                                              container->df_entry->d_name,
-                                              container->parent_loc->path);
-
-                                pthread_cond_signal (
-                                        &defrag->parallel_migration_cond);
-                        }
-                        pthread_mutex_unlock (&defrag->dfq_mutex);
+        while (
+            ldfq_count <= MAX_MIGRATE_QUEUE_COUNT &&
+            !dht_dfreaddirp_done(dir_dfmeta->offset_var, local_subvols_cnt)) {
+            ret = gf_defrag_get_entry(this, dfc_index, &container, loc, conf,
+                                      defrag, fd, migrate_data, dir_dfmeta,
+                                      xattr_req, &should_commit_hash, perrno);
 
-                        GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
-                }
-        }
+            if (ret) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "Found "
+                       "error from gf_defrag_get_entry");
 
-        gettimeofday (&end, NULL);
-        elapsed = (end.tv_sec - dir_start.tv_sec) * 1e6 +
-                  (end.tv_usec - dir_start.tv_usec);
-        gf_log (this->name, GF_LOG_INFO, "Migration operation on dir %s took "
-                "%.2f secs", loc->path, elapsed/1e6);
-        ret = 0;
+                ret = -1;
+                goto out;
+            }
+
+            /* Check if we got an entry, else we need to move the
+               index to the next subvol */
+            if (!container) {
+                GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
+                continue;
+            }
+
+            /* Q this entry in the dfq */
+            pthread_mutex_lock(&defrag->dfq_mutex);
+            {
+                list_add_tail(&container->list, &(defrag->queue[0].list));
+                defrag->q_entry_count++;
+                ldfq_count = defrag->q_entry_count;
+
+                gf_msg_debug(this->name, 0,
+                             "added "
+                             "file:%s parent:%s to the queue ",
+                             container->df_entry->d_name,
+                             container->parent_loc->path);
+
+                pthread_cond_signal(&defrag->parallel_migration_cond);
+            }
+            pthread_mutex_unlock(&defrag->dfq_mutex);
+
+            GF_CRAWL_INDEX_MOVE(dfc_index, local_subvols_cnt);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+    elapsed = (end.tv_sec - dir_start.tv_sec) * 1e6 +
+              (end.tv_usec - dir_start.tv_usec);
+    gf_log(this->name, GF_LOG_INFO,
+           "Migration operation on dir %s took "
+           "%.2f secs",
+           loc->path, elapsed / 1e6);
+    ret = 0;
 out:
 
-        gf_defrag_free_dir_dfmeta (dir_dfmeta, local_subvols_cnt);
+    gf_defrag_free_dir_dfmeta(dir_dfmeta, local_subvols_cnt);
 
-        if (xattr_req)
-                dict_unref(xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        if (fd)
-                fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-        if (ret == 0 && should_commit_hash == 0) {
-                ret = 2;
-        }
+    if (ret == 0 && should_commit_hash == 0) {
+        ret = 2;
+    }
 
-        /* It does not matter if it errored out - this number is
-         * used to calculate rebalance estimated time to complete.
-         * No locking required as dirs are processed by a single thread.
-         */
-        defrag->num_dirs_processed++;
-        return ret;
+    /* It does not matter if it errored out - this number is
+     * used to calculate rebalance estimated time to complete.
+     * No locking required as dirs are processed by a single thread.
+     */
+    defrag->num_dirs_processed++;
+    return ret;
 }
 int
-gf_defrag_settle_hash (xlator_t *this, gf_defrag_info_t *defrag,
-                       loc_t *loc, dict_t *fix_layout)
+gf_defrag_settle_hash(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                      dict_t *fix_layout)
 {
-        int     ret;
-        dht_conf_t *conf = NULL;
-        /*
-         * Now we're ready to update the directory commit hash for the volume
-         * root, so that hash miscompares and broadcast lookups can stop.
-         * However, we want to skip that if fix-layout is all we did.  In
-         * that case, we want the miscompares etc. to continue until a real
-         * rebalance is complete.
-         */
-        if (defrag->cmd == GF_DEFRAG_CMD_START_LAYOUT_FIX
-            || defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-            defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-                return 0;
-        }
-
-        conf = this->private;
-        if (!conf) {
-                /*Uh oh
-                 */
-                return -1;
-        }
+    int ret;
+    dht_conf_t *conf = NULL;
+    /*
+     * Now we're ready to update the directory commit hash for the volume
+     * root, so that hash miscompares and broadcast lookups can stop.
+     * However, we want to skip that if fix-layout is all we did.  In
+     * that case, we want the miscompares etc. to continue until a real
+     * rebalance is complete.
+     */
+    if (defrag->cmd == GF_DEFRAG_CMD_START_LAYOUT_FIX ||
+        defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
+        defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
+        return 0;
+    }
 
-        if (conf->local_subvols_cnt == 0 || !conf->lookup_optimize) {
-                /* Commit hash updates are only done on local subvolumes and
-                 * only when lookup optimization is needed (for older client
-                 * support)
-                 */
-                return 0;
-        }
+    conf = this->private;
+    if (!conf) {
+        /*Uh oh
+         */
+        return -1;
+    }
 
-        ret = dict_set_uint32 (fix_layout, "new-commit-hash",
-                               defrag->new_commit_hash);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set new-commit-hash");
-                return -1;
-        }
+    if (conf->local_subvols_cnt == 0 || !conf->lookup_optimize) {
+        /* Commit hash updates are only done on local subvolumes and
+         * only when lookup optimization is needed (for older client
+         * support)
+         */
+        return 0;
+    }
 
-        ret = syncop_setxattr (this, loc, fix_layout, 0, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_LAYOUT_FIX_FAILED,
-                        "fix layout on %s failed", loc->path);
+    ret = dict_set_uint32(fix_layout, "new-commit-hash",
+                          defrag->new_commit_hash);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to set new-commit-hash");
+        return -1;
+    }
 
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        /* Dir most likely is deleted */
-                        return 0;
-                }
+    ret = syncop_setxattr(this, loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+               "fix layout on %s failed", loc->path);
 
-                return -1;
+        if (-ret == ENOENT || -ret == ESTALE) {
+            /* Dir most likely is deleted */
+            return 0;
         }
 
-        /* TBD: find more efficient solution than adding/deleting every time */
-        dict_del(fix_layout, "new-commit-hash");
-
-        return 0;
-}
+        return -1;
+    }
 
+    /* TBD: find more efficient solution than adding/deleting every time */
+    dict_del(fix_layout, "new-commit-hash");
 
+    return 0;
+}
 
 /* Function for doing a named lookup on file inodes during an attach tier
  * So that a hardlink lookup heal i.e gfid to parent gfid lookup heal
@@ -3717,1721 +3588,1672 @@ gf_defrag_settle_hash (xlator_t *this, gf_defrag_info_t *defrag,
  * eventual consistency
  * */
 int
-gf_fix_layout_tier_attach_lookup (xlator_t *this,
-                                 loc_t *parent_loc,
+gf_fix_layout_tier_attach_lookup(xlator_t *this, loc_t *parent_loc,
                                  gf_dirent_t *file_dentry)
 {
-        int                      ret            = -1;
-        dict_t                  *lookup_xdata   = NULL;
-        dht_conf_t              *conf           = NULL;
-        loc_t                    file_loc       = {0,};
-        struct iatt              iatt           = {0,};
+    int ret = -1;
+    dict_t *lookup_xdata = NULL;
+    dht_conf_t *conf = NULL;
+    loc_t file_loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
 
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
+    GF_VALIDATE_OR_GOTO("tier", this, out);
 
-        GF_VALIDATE_OR_GOTO (this->name, parent_loc, out);
+    GF_VALIDATE_OR_GOTO(this->name, parent_loc, out);
 
-        GF_VALIDATE_OR_GOTO (this->name, file_dentry, out);
+    GF_VALIDATE_OR_GOTO(this->name, file_dentry, out);
 
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
-
-        if (!parent_loc->inode) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s parent is NULL", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
-        }
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
+    if (!parent_loc->inode) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "%s/%s parent is NULL", parent_loc->path, file_dentry->d_name);
+        goto out;
+    }
 
-        conf   = this->private;
+    conf = this->private;
 
-        loc_wipe (&file_loc);
+    loc_wipe(&file_loc);
 
-        if (gf_uuid_is_null (file_dentry->d_stat.ia_gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s gfid not present", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
-        }
+    if (gf_uuid_is_null(file_dentry->d_stat.ia_gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "%s/%s gfid not present", parent_loc->path, file_dentry->d_name);
+        goto out;
+    }
 
-        gf_uuid_copy (file_loc.gfid, file_dentry->d_stat.ia_gfid);
-
-        if (gf_uuid_is_null (parent_loc->gfid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "%s/%s"
-                        " gfid not present", parent_loc->path,
-                        file_dentry->d_name);
-                goto out;
-        }
+    gf_uuid_copy(file_loc.gfid, file_dentry->d_stat.ia_gfid);
 
-        gf_uuid_copy (file_loc.pargfid, parent_loc->gfid);
+    if (gf_uuid_is_null(parent_loc->gfid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "%s/%s"
+               " gfid not present",
+               parent_loc->path, file_dentry->d_name);
+        goto out;
+    }
 
+    gf_uuid_copy(file_loc.pargfid, parent_loc->gfid);
 
-        ret = dht_build_child_loc (this, &file_loc, parent_loc,
-                                                file_dentry->d_name);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Child loc build failed");
-                ret = -1;
-                goto out;
-        }
-
-        lookup_xdata = dict_new ();
-        if (!lookup_xdata) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed creating lookup dict for %s",
-                        file_dentry->d_name);
-                goto out;
-        }
-
-        ret = dict_set_int32 (lookup_xdata, CTR_ATTACH_TIER_LOOKUP, 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to set lookup flag");
-                goto out;
-        }
-
-        gf_uuid_copy (file_loc.parent->gfid, parent_loc->gfid);
-
-        /* Sending lookup to cold tier only */
-        ret = syncop_lookup (conf->subvolumes[0], &file_loc, &iatt,
-                        NULL, lookup_xdata, NULL);
-        if (ret) {
-                /* If the file does not exist on the cold tier than it must */
-                /* have been discovered on the hot tier. This is not an error. */
-                gf_msg (this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                        "%s lookup to cold tier on attach heal failed", file_loc.path);
-                goto out;
-        }
-
-        ret = 0;
+    ret = dht_build_child_loc(this, &file_loc, parent_loc, file_dentry->d_name);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Child loc build failed");
+        ret = -1;
+        goto out;
+    }
+
+    lookup_xdata = dict_new();
+    if (!lookup_xdata) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed creating lookup dict for %s", file_dentry->d_name);
+        goto out;
+    }
+
+    ret = dict_set_int32(lookup_xdata, CTR_ATTACH_TIER_LOOKUP, 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to set lookup flag");
+        goto out;
+    }
+
+    gf_uuid_copy(file_loc.parent->gfid, parent_loc->gfid);
+
+    /* Sending lookup to cold tier only */
+    ret = syncop_lookup(conf->subvolumes[0], &file_loc, &iatt, NULL,
+                        lookup_xdata, NULL);
+    if (ret) {
+        /* If the file does not exist on the cold tier than it must */
+        /* have been discovered on the hot tier. This is not an error. */
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "%s lookup to cold tier on attach heal failed", file_loc.path);
+        goto out;
+    }
+
+    ret = 0;
 
 out:
 
-        loc_wipe (&file_loc);
+    loc_wipe(&file_loc);
 
-        if (lookup_xdata)
-                dict_unref (lookup_xdata);
+    if (lookup_xdata)
+        dict_unref(lookup_xdata);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_defrag_fix_layout (xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
-                  dict_t *fix_layout, dict_t *migrate_data)
+gf_defrag_fix_layout(xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc,
+                     dict_t *fix_layout, dict_t *migrate_data)
 {
-        int                      ret            = -1;
-        loc_t                    entry_loc      = {0,};
-        fd_t                    *fd             = NULL;
-        gf_dirent_t              entries;
-        gf_dirent_t             *tmp            = NULL;
-        gf_dirent_t             *entry          = NULL;
-        gf_boolean_t             free_entries   = _gf_false;
-        off_t                    offset         = 0;
-        struct iatt              iatt           = {0,};
-        inode_t                 *linked_inode   = NULL, *inode = NULL;
-        dht_conf_t              *conf           = NULL;
-        int                      should_commit_hash = 1;
-        int                      perrno         = 0;
-
-        conf = this->private;
-        if (!conf) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = syncop_lookup (this, loc, &iatt, NULL, NULL, NULL);
-        if (ret) {
-                if (strcmp (loc->path, "/") == 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "lookup failed for:%s", loc->path);
-
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
+    int ret = -1;
+    loc_t entry_loc = {
+        0,
+    };
+    fd_t *fd = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *tmp = NULL;
+    gf_dirent_t *entry = NULL;
+    gf_boolean_t free_entries = _gf_false;
+    off_t offset = 0;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *linked_inode = NULL, *inode = NULL;
+    dht_conf_t *conf = NULL;
+    int should_commit_hash = 1;
+    int perrno = 0;
+
+    conf = this->private;
+    if (!conf) {
+        ret = -1;
+        goto out;
+    }
 
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "Dir:%s renamed or removed. Skipping",
-                                loc->path);
-                        if (conf->decommission_subvols_cnt) {
-                                defrag->total_failures++;
-                        }
-                        ret = 0;
-                        goto out;
-                } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                "lookup failed for:%s", loc->path);
+    ret = syncop_lookup(this, loc, &iatt, NULL, NULL, NULL);
+    if (ret) {
+        if (strcmp(loc->path, "/") == 0) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "lookup failed for:%s", loc->path);
 
-                        defrag->total_failures++;
-                        goto out;
-                }
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
 
-        fd = fd_create (loc->inode, defrag->pid);
-        if (!fd) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to create fd");
-                ret = -1;
-                goto out;
-        }
+        if (-ret == ENOENT || -ret == ESTALE) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "Dir:%s renamed or removed. Skipping", loc->path);
+            if (conf->decommission_subvols_cnt) {
+                defrag->total_failures++;
+            }
+            ret = 0;
+            goto out;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_LOOKUP_FAILED,
+                   "lookup failed for:%s", loc->path);
 
-        ret = syncop_opendir (this, loc, fd, NULL, NULL);
-        if (ret) {
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        if (conf->decommission_subvols_cnt) {
-                                defrag->total_failures++;
-                        }
-                        ret = 0;
-                        goto out;
-                }
+            defrag->total_failures++;
+            goto out;
+        }
+    }
 
-                gf_log (this->name, GF_LOG_ERROR, "Failed to open dir %s, "
-                        "err:%d", loc->path, -ret);
+    fd = fd_create(loc->inode, defrag->pid);
+    if (!fd) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to create fd");
+        ret = -1;
+        goto out;
+    }
 
-                ret = -1;
-                goto out;
+    ret = syncop_opendir(this, loc, fd, NULL, NULL);
+    if (ret) {
+        if (-ret == ENOENT || -ret == ESTALE) {
+            if (conf->decommission_subvols_cnt) {
+                defrag->total_failures++;
+            }
+            ret = 0;
+            goto out;
         }
 
-        fd_bind (fd);
-        INIT_LIST_HEAD (&entries.list);
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to open dir %s, "
+               "err:%d",
+               loc->path, -ret);
 
-        while ((ret = syncop_readdirp (this, fd, 131072, offset, &entries,
-                                       NULL, NULL)) != 0)
-        {
-                if (ret < 0) {
-                        if (-ret == ENOENT || -ret == ESTALE) {
-                                if (conf->decommission_subvols_cnt) {
-                                        defrag->total_failures++;
-                                }
-                                ret = 0;
-                                goto out;
-                        }
+        ret = -1;
+        goto out;
+    }
 
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_READDIR_ERROR, "readdirp failed for "
-                                "path %s. Aborting fix-layout", loc->path);
+    fd_bind(fd);
+    INIT_LIST_HEAD(&entries.list);
 
-                        ret = -1;
-                        goto out;
+    while ((ret = syncop_readdirp(this, fd, 131072, offset, &entries, NULL,
+                                  NULL)) != 0) {
+        if (ret < 0) {
+            if (-ret == ENOENT || -ret == ESTALE) {
+                if (conf->decommission_subvols_cnt) {
+                    defrag->total_failures++;
                 }
+                ret = 0;
+                goto out;
+            }
 
-                if (list_empty (&entries.list))
-                        break;
-
-                free_entries = _gf_true;
-
-                list_for_each_entry_safe (entry, tmp, &entries.list, list) {
-                        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                                ret = 1;
-                                goto out;
-                        }
-
-                        offset = entry->d_off;
-
-                        if (!strcmp (entry->d_name, ".") ||
-                            !strcmp (entry->d_name, ".."))
-                                continue;
-                        if (!IA_ISDIR (entry->d_stat.ia_type)) {
-
-                                /* If its a fix layout during the attach
-                                 * tier operation do lookups on files
-                                 * on cold subvolume so that there is a
-                                 * CTR DB Lookup Heal triggered on existing
-                                 * data.
-                                 * */
-                                if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                                        gf_fix_layout_tier_attach_lookup
-                                                (this, loc, entry);
-                                }
-
-                                continue;
-                        }
-                        loc_wipe (&entry_loc);
-
-                        ret = dht_build_child_loc (this, &entry_loc, loc,
-                                                  entry->d_name);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR, "Child loc"
-                                        " build failed for entry: %s",
-                                        entry->d_name);
-
-                                if (conf->decommission_in_progress) {
-                                        defrag->defrag_status =
-                                        GF_DEFRAG_STATUS_FAILED;
-
-                                        goto out;
-                                } else {
-                                        should_commit_hash = 0;
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_READDIR_ERROR,
+                   "readdirp failed for "
+                   "path %s. Aborting fix-layout",
+                   loc->path);
 
-                                        continue;
-                                }
-                        }
+            ret = -1;
+            goto out;
+        }
 
-                        if (gf_uuid_is_null (entry->d_stat.ia_gfid)) {
-                                gf_log (this->name, GF_LOG_ERROR, "%s/%s"
-                                        " gfid not present", loc->path,
-                                         entry->d_name);
-                                continue;
-                        }
+        if (list_empty(&entries.list))
+            break;
 
+        free_entries = _gf_true;
 
-                        gf_uuid_copy (entry_loc.gfid, entry->d_stat.ia_gfid);
+        list_for_each_entry_safe(entry, tmp, &entries.list, list)
+        {
+            if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+                ret = 1;
+                goto out;
+            }
+
+            offset = entry->d_off;
+
+            if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
+                continue;
+            if (!IA_ISDIR(entry->d_stat.ia_type)) {
+                /* If its a fix layout during the attach
+                 * tier operation do lookups on files
+                 * on cold subvolume so that there is a
+                 * CTR DB Lookup Heal triggered on existing
+                 * data.
+                 * */
+                if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
+                    gf_fix_layout_tier_attach_lookup(this, loc, entry);
+                }
 
-                        /*In case the gfid stored in the inode by inode_link
-                         * and the gfid obtained in the lookup differs, then
-                         * client3_3_lookup_cbk will return ESTALE and proper
-                         * error will be captured
-                         */
+                continue;
+            }
+            loc_wipe(&entry_loc);
 
-                        linked_inode = inode_link (entry_loc.inode, loc->inode,
-                                                   entry->d_name,
-                                                   &entry->d_stat);
+            ret = dht_build_child_loc(this, &entry_loc, loc, entry->d_name);
+            if (ret) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "Child loc"
+                       " build failed for entry: %s",
+                       entry->d_name);
 
-                        inode = entry_loc.inode;
-                        entry_loc.inode = linked_inode;
-                        inode_unref (inode);
+                if (conf->decommission_in_progress) {
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-                        if (gf_uuid_is_null (loc->gfid)) {
-                                gf_log (this->name, GF_LOG_ERROR, "%s/%s"
-                                        " gfid not present", loc->path,
-                                         entry->d_name);
-                                continue;
-                        }
+                    goto out;
+                } else {
+                    should_commit_hash = 0;
 
-                        gf_uuid_copy (entry_loc.pargfid, loc->gfid);
-
-                        ret = syncop_lookup (this, &entry_loc, &iatt, NULL,
-                                             NULL, NULL);
-                        if (ret) {
-                                if (-ret == ENOENT || -ret == ESTALE) {
-                                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                                "Dir:%s renamed or removed. "
-                                                "Skipping", loc->path);
-                                        ret = 0;
-                                        if (conf->decommission_subvols_cnt) {
-                                                defrag->total_failures++;
-                                        }
-                                        continue;
-                                } else {
-                                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                                DHT_MSG_DIR_LOOKUP_FAILED,
-                                                "lookup failed for:%s",
-                                                entry_loc.path);
-
-                                        defrag->total_failures++;
-
-                                        if (conf->decommission_in_progress) {
-                                                defrag->defrag_status =
-                                                GF_DEFRAG_STATUS_FAILED;
-                                                ret = -1;
-                                                goto out;
-                                        } else {
-                                                should_commit_hash = 0;
-                                                continue;
-                                        }
-                                }
-                        }
+                    continue;
+                }
+            }
+
+            if (gf_uuid_is_null(entry->d_stat.ia_gfid)) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "%s/%s"
+                       " gfid not present",
+                       loc->path, entry->d_name);
+                continue;
+            }
+
+            gf_uuid_copy(entry_loc.gfid, entry->d_stat.ia_gfid);
+
+            /*In case the gfid stored in the inode by inode_link
+             * and the gfid obtained in the lookup differs, then
+             * client3_3_lookup_cbk will return ESTALE and proper
+             * error will be captured
+             */
+
+            linked_inode = inode_link(entry_loc.inode, loc->inode,
+                                      entry->d_name, &entry->d_stat);
+
+            inode = entry_loc.inode;
+            entry_loc.inode = linked_inode;
+            inode_unref(inode);
+
+            if (gf_uuid_is_null(loc->gfid)) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "%s/%s"
+                       " gfid not present",
+                       loc->path, entry->d_name);
+                continue;
+            }
+
+            gf_uuid_copy(entry_loc.pargfid, loc->gfid);
+
+            ret = syncop_lookup(this, &entry_loc, &iatt, NULL, NULL, NULL);
+            if (ret) {
+                if (-ret == ENOENT || -ret == ESTALE) {
+                    gf_msg(this->name, GF_LOG_INFO, -ret,
+                           DHT_MSG_DIR_LOOKUP_FAILED,
+                           "Dir:%s renamed or removed. "
+                           "Skipping",
+                           loc->path);
+                    ret = 0;
+                    if (conf->decommission_subvols_cnt) {
+                        defrag->total_failures++;
+                    }
+                    continue;
+                } else {
+                    gf_msg(this->name, GF_LOG_ERROR, -ret,
+                           DHT_MSG_DIR_LOOKUP_FAILED, "lookup failed for:%s",
+                           entry_loc.path);
 
-                        /* A return value of 2 means, either process_dir or
-                         * lookup of a dir failed. Hence, don't commit hash
-                         * for the current directory*/
+                    defrag->total_failures++;
 
-                        ret = gf_defrag_fix_layout (this, defrag, &entry_loc,
-                                                    fix_layout, migrate_data);
+                    if (conf->decommission_in_progress) {
+                        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+                        ret = -1;
+                        goto out;
+                    } else {
+                        should_commit_hash = 0;
+                        continue;
+                    }
+                }
+            }
 
-                        if (ret && ret != 2) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_LAYOUT_FIX_FAILED,
-                                        "Fix layout failed for %s",
-                                        entry_loc.path);
+            /* A return value of 2 means, either process_dir or
+             * lookup of a dir failed. Hence, don't commit hash
+             * for the current directory*/
 
-                                defrag->total_failures++;
+            ret = gf_defrag_fix_layout(this, defrag, &entry_loc, fix_layout,
+                                       migrate_data);
 
-                                if (conf->decommission_in_progress) {
-                                        defrag->defrag_status =
-                                        GF_DEFRAG_STATUS_FAILED;
+            if (ret && ret != 2) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LAYOUT_FIX_FAILED,
+                       "Fix layout failed for %s", entry_loc.path);
 
-                                        goto out;
-                                } else {
-                                        /* Let's not commit-hash if
-                                         * gf_defrag_fix_layout failed*/
-                                        continue;
-                                }
-                        }
-                }
+                defrag->total_failures++;
 
-                gf_dirent_free (&entries);
-                free_entries = _gf_false;
-                INIT_LIST_HEAD (&entries.list);
-        }
+                if (conf->decommission_in_progress) {
+                    defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
 
-        ret = syncop_setxattr (this, loc, fix_layout, 0, NULL, NULL);
-        if (ret) {
-                if (-ret == ENOENT || -ret == ESTALE) {
-                        gf_msg (this->name, GF_LOG_INFO, -ret,
-                                DHT_MSG_LAYOUT_FIX_FAILED,
-                                "Setxattr failed. Dir %s "
-                                "renamed or removed",
-                                loc->path);
-                        if (conf->decommission_subvols_cnt) {
-                                defrag->total_failures++;
-                        }
-                        ret = 0;
+                    goto out;
                 } else {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_LAYOUT_FIX_FAILED,
-                                "Setxattr failed for %s",
-                                loc->path);
+                    /* Let's not commit-hash if
+                     * gf_defrag_fix_layout failed*/
+                    continue;
+                }
+            }
+        }
+
+        gf_dirent_free(&entries);
+        free_entries = _gf_false;
+        INIT_LIST_HEAD(&entries.list);
+    }
+
+    ret = syncop_setxattr(this, loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        if (-ret == ENOENT || -ret == ESTALE) {
+            gf_msg(this->name, GF_LOG_INFO, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+                   "Setxattr failed. Dir %s "
+                   "renamed or removed",
+                   loc->path);
+            if (conf->decommission_subvols_cnt) {
+                defrag->total_failures++;
+            }
+            ret = 0;
+        } else {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LAYOUT_FIX_FAILED,
+                   "Setxattr failed for %s", loc->path);
 
-                        defrag->total_failures++;
+            defrag->total_failures++;
 
-                        if (conf->decommission_in_progress) {
-                                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                                ret = -1;
-                                goto out;
-                        }
-                 }
+            if (conf->decommission_in_progress) {
+                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+                ret = -1;
+                goto out;
+            }
         }
+    }
 
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
-            (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX)) {
-                ret = gf_defrag_process_dir (this, defrag, loc, migrate_data,
-                                             &perrno);
-
-                if (ret && (ret != 2)) {
-                        if (perrno == ENOENT || perrno == ESTALE) {
-                                ret = 0;
-                                goto out;
-                        } else {
-
-                                defrag->total_failures++;
+    if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
+        (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX)) {
+        ret = gf_defrag_process_dir(this, defrag, loc, migrate_data, &perrno);
 
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DEFRAG_PROCESS_DIR_FAILED,
-                                        "gf_defrag_process_dir failed for "
-                                        "directory: %s", loc->path);
+        if (ret && (ret != 2)) {
+            if (perrno == ENOENT || perrno == ESTALE) {
+                ret = 0;
+                goto out;
+            } else {
+                defrag->total_failures++;
 
-                                if (conf->decommission_in_progress) {
-                                        goto out;
-                                }
+                gf_msg(this->name, GF_LOG_ERROR, 0,
+                       DHT_MSG_DEFRAG_PROCESS_DIR_FAILED,
+                       "gf_defrag_process_dir failed for "
+                       "directory: %s",
+                       loc->path);
 
-                                should_commit_hash = 0;
-                        }
-                } else if (ret == 2) {
-                        should_commit_hash = 0;
+                if (conf->decommission_in_progress) {
+                    goto out;
                 }
-        }
 
-        gf_msg_trace (this->name, 0, "fix layout called on %s", loc->path);
+                should_commit_hash = 0;
+            }
+        } else if (ret == 2) {
+            should_commit_hash = 0;
+        }
+    }
 
-        if (should_commit_hash &&
-            gf_defrag_settle_hash (this, defrag, loc, fix_layout) != 0) {
+    gf_msg_trace(this->name, 0, "fix layout called on %s", loc->path);
 
-                defrag->total_failures++;
+    if (should_commit_hash &&
+        gf_defrag_settle_hash(this, defrag, loc, fix_layout) != 0) {
+        defrag->total_failures++;
 
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_SETTLE_HASH_FAILED,
-                        "Settle hash failed for %s",
-                         loc->path);
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SETTLE_HASH_FAILED,
+               "Settle hash failed for %s", loc->path);
 
-                ret = -1;
+        ret = -1;
 
-                if (conf->decommission_in_progress) {
-                        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                        goto out;
-                }
+        if (conf->decommission_in_progress) {
+            defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (free_entries)
-                gf_dirent_free (&entries);
+    if (free_entries)
+        gf_dirent_free(&entries);
 
-        loc_wipe (&entry_loc);
+    loc_wipe(&entry_loc);
 
-        if (fd)
-                fd_unref (fd);
+    if (fd)
+        fd_unref(fd);
 
-        if (ret == 0 && should_commit_hash == 0) {
-                ret = 2;
-        }
-
-        return ret;
+    if (ret == 0 && should_commit_hash == 0) {
+        ret = 2;
+    }
 
+    return ret;
 }
 
-
-
 /******************************************************************************
  *                      Tier background Fix layout functions
  ******************************************************************************/
 /* This is the background tier fixlayout thread */
 void *
-gf_tier_do_fix_layout (void *args)
+gf_tier_do_fix_layout(void *args)
 {
-        gf_tier_fix_layout_arg_t *tier_fix_layout_arg   =  args;
-        int                 ret                         = -1;
-        xlator_t            *this                       = NULL;
-        dht_conf_t          *conf                       = NULL;
-        gf_defrag_info_t    *defrag                     = NULL;
-        dict_t              *dict                       = NULL;
-        loc_t               loc                         = {0,};
-        struct iatt         iatt                        = {0,};
-        struct iatt         parent                      = {0,};
-
-        GF_VALIDATE_OR_GOTO ("tier", tier_fix_layout_arg, out);
-        GF_VALIDATE_OR_GOTO ("tier", tier_fix_layout_arg->this, out);
-        this = tier_fix_layout_arg->this;
-
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-        GF_VALIDATE_OR_GOTO (this->name, defrag->root_inode, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, tier_fix_layout_arg->fix_layout, out);
-
-
-        /* Get Root loc_t */
-        dht_build_root_loc (defrag->root_inode, &loc);
-        ret = syncop_lookup (this, &loc, &iatt, &parent, NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Lookup on root failed.");
-                ret = -1;
-                goto out;
-        }
-
-
-        /* Start the crawl */
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS, "Tiering Fixlayout started");
-
-        ret = gf_defrag_fix_layout (this, defrag, &loc,
-                                    tier_fix_layout_arg->fix_layout, NULL);
-        if (ret && ret != 2) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_FAILED,
-                        "Tiering fixlayout failed.");
-                ret = -1;
-                goto out;
-        }
-
-        if (ret != 2 && gf_defrag_settle_hash
-                        (this, defrag, &loc,
-                                tier_fix_layout_arg->fix_layout) != 0) {
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
-        }
-
-        dict = dict_new ();
-        if (!dict) {
-                ret = -1;
-                goto out;
-        }
+    gf_tier_fix_layout_arg_t *tier_fix_layout_arg = args;
+    int ret = -1;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    dict_t *dict = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    struct iatt parent = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("tier", tier_fix_layout_arg, out);
+    GF_VALIDATE_OR_GOTO("tier", tier_fix_layout_arg->this, out);
+    this = tier_fix_layout_arg->this;
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+    defrag = conf->defrag;
+    GF_VALIDATE_OR_GOTO(this->name, defrag, out);
+    GF_VALIDATE_OR_GOTO(this->name, defrag->root_inode, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, tier_fix_layout_arg->fix_layout, out);
+
+    /* Get Root loc_t */
+    dht_build_root_loc(defrag->root_inode, &loc);
+    ret = syncop_lookup(this, &loc, &iatt, &parent, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_REBALANCE_START_FAILED,
+               "Lookup on root failed.");
+        ret = -1;
+        goto out;
+    }
+
+    /* Start the crawl */
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+           "Tiering Fixlayout started");
+
+    ret = gf_defrag_fix_layout(this, defrag, &loc,
+                               tier_fix_layout_arg->fix_layout, NULL);
+    if (ret && ret != 2) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_FAILED,
+               "Tiering fixlayout failed.");
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_str (dict, GF_XATTR_TIER_LAYOUT_FIXED_KEY, "yes");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_FAILED,
-                        "Failed to set dictionary value: key = %s",
-                        GF_XATTR_TIER_LAYOUT_FIXED_KEY);
-                ret = -1;
-                goto out;
-        }
+    if (ret != 2 &&
+        gf_defrag_settle_hash(this, defrag, &loc,
+                              tier_fix_layout_arg->fix_layout) != 0) {
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        /* Marking the completion of tiering fix layout via a xattr on root */
-        ret = syncop_setxattr (this, &loc, dict, 0, NULL, NULL);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to set tiering fix "
-                        "layout completed xattr on %s", loc.path);
-                ret = -1;
-                goto out;
-        }
+    dict = dict_new();
+    if (!dict) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_set_str(dict, GF_XATTR_TIER_LAYOUT_FIXED_KEY, "yes");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_FAILED,
+               "Failed to set dictionary value: key = %s",
+               GF_XATTR_TIER_LAYOUT_FIXED_KEY);
+        ret = -1;
+        goto out;
+    }
+
+    /* Marking the completion of tiering fix layout via a xattr on root */
+    ret = syncop_setxattr(this, &loc, dict, 0, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to set tiering fix "
+               "layout completed xattr on %s",
+               loc.path);
+        ret = -1;
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && defrag)
-                defrag->total_failures++;
+    if (ret && defrag)
+        defrag->total_failures++;
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return NULL;
+    return NULL;
 }
 
 int
-gf_tier_start_fix_layout (xlator_t *this,
-                         loc_t *loc,
-                         gf_defrag_info_t *defrag,
+gf_tier_start_fix_layout(xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag,
                          dict_t *fix_layout)
 {
-        int ret                                       = -1;
-        dict_t  *tier_dict                            = NULL;
-        gf_tier_fix_layout_arg_t *tier_fix_layout_arg = NULL;
-
-        tier_dict = dict_new ();
-        if (!tier_dict) {
-                gf_log ("tier", GF_LOG_ERROR, "Tier fix layout failed :"
-                        "Creation of tier_dict failed");
-                ret = -1;
-                goto out;
-        }
-
-        /* Check if layout is fixed already */
-        ret = syncop_getxattr (this, loc, &tier_dict,
-                                GF_XATTR_TIER_LAYOUT_FIXED_KEY,
-                                NULL, NULL);
-        if (ret != 0) {
-
-                tier_fix_layout_arg = &defrag->tier_conf.tier_fix_layout_arg;
-
-                /*Fill crawl arguments */
-                tier_fix_layout_arg->this = this;
-                tier_fix_layout_arg->fix_layout = fix_layout;
-
-                /* Spawn the fix layout thread so that its done in the
-                 * background */
-                ret = gf_thread_create (&tier_fix_layout_arg->thread_id, NULL,
-                                        gf_tier_do_fix_layout,
-                                        tier_fix_layout_arg, "tierfixl");
-                if (ret) {
-                        gf_log ("tier", GF_LOG_ERROR, "Thread creation failed. "
-                                "Background fix layout for tiering will not "
-                                "work.");
-                        defrag->total_failures++;
-                        goto out;
-                }
-        }
-        ret = 0;
+    int ret = -1;
+    dict_t *tier_dict = NULL;
+    gf_tier_fix_layout_arg_t *tier_fix_layout_arg = NULL;
+
+    tier_dict = dict_new();
+    if (!tier_dict) {
+        gf_log("tier", GF_LOG_ERROR,
+               "Tier fix layout failed :"
+               "Creation of tier_dict failed");
+        ret = -1;
+        goto out;
+    }
+
+    /* Check if layout is fixed already */
+    ret = syncop_getxattr(this, loc, &tier_dict, GF_XATTR_TIER_LAYOUT_FIXED_KEY,
+                          NULL, NULL);
+    if (ret != 0) {
+        tier_fix_layout_arg = &defrag->tier_conf.tier_fix_layout_arg;
+
+        /*Fill crawl arguments */
+        tier_fix_layout_arg->this = this;
+        tier_fix_layout_arg->fix_layout = fix_layout;
+
+        /* Spawn the fix layout thread so that its done in the
+         * background */
+        ret = gf_thread_create(&tier_fix_layout_arg->thread_id, NULL,
+                               gf_tier_do_fix_layout, tier_fix_layout_arg,
+                               "tierfixl");
+        if (ret) {
+            gf_log("tier", GF_LOG_ERROR,
+                   "Thread creation failed. "
+                   "Background fix layout for tiering will not "
+                   "work.");
+            defrag->total_failures++;
+            goto out;
+        }
+    }
+    ret = 0;
 out:
-        if (tier_dict)
-                dict_unref (tier_dict);
+    if (tier_dict)
+        dict_unref(tier_dict);
 
-        return ret;
+    return ret;
 }
 
 void
-gf_tier_clear_fix_layout (xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
+gf_tier_clear_fix_layout(xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
 {
-        int ret         = -1;
-        dict_t *dict    = NULL;
-
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc, out);
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-
-        /* Check if background fixlayout is completed. This is not
-         * multi-process safe i.e there is a possibility that by the time
-         * we move to remove the xattr there it might have been cleared by some
-         * other detach process from other node. We ignore the error if such
-         * a thing happens */
-        ret = syncop_getxattr (this, loc, &dict,
-                        GF_XATTR_TIER_LAYOUT_FIXED_KEY, NULL, NULL);
-        if (ret) {
-                /* Background fixlayout not complete - nothing to clear*/
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Unable to retrieve fixlayout xattr."
-                        "Assume background fix layout not complete");
-                goto out;
-        }
-
-        ret = syncop_removexattr (this, loc, GF_XATTR_TIER_LAYOUT_FIXED_KEY,
-                                  NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Failed removing tier fix layout "
-                        "xattr from %s", loc->path);
-                goto out;
-        }
-        ret = 0;
+    int ret = -1;
+    dict_t *dict = NULL;
+
+    GF_VALIDATE_OR_GOTO("tier", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc, out);
+    GF_VALIDATE_OR_GOTO(this->name, defrag, out);
+
+    /* Check if background fixlayout is completed. This is not
+     * multi-process safe i.e there is a possibility that by the time
+     * we move to remove the xattr there it might have been cleared by some
+     * other detach process from other node. We ignore the error if such
+     * a thing happens */
+    ret = syncop_getxattr(this, loc, &dict, GF_XATTR_TIER_LAYOUT_FIXED_KEY,
+                          NULL, NULL);
+    if (ret) {
+        /* Background fixlayout not complete - nothing to clear*/
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_LOG_TIER_STATUS,
+               "Unable to retrieve fixlayout xattr."
+               "Assume background fix layout not complete");
+        goto out;
+    }
+
+    ret = syncop_removexattr(this, loc, GF_XATTR_TIER_LAYOUT_FIXED_KEY, NULL,
+                             NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_LOG_TIER_STATUS,
+               "Failed removing tier fix layout "
+               "xattr from %s",
+               loc->path);
+        goto out;
+    }
+    ret = 0;
 out:
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 }
 
 void
-gf_tier_wait_fix_lookup (gf_defrag_info_t *defrag) {
-        if (defrag->tier_conf.tier_fix_layout_arg.thread_id) {
-                pthread_join (defrag->tier_conf.tier_fix_layout_arg.thread_id,
-                        NULL);
-        }
+gf_tier_wait_fix_lookup(gf_defrag_info_t *defrag)
+{
+    if (defrag->tier_conf.tier_fix_layout_arg.thread_id) {
+        pthread_join(defrag->tier_conf.tier_fix_layout_arg.thread_id, NULL);
+    }
 }
 /******************Tier background Fix layout functions END********************/
 
 int
-dht_init_local_subvols_and_nodeuuids (xlator_t *this, dht_conf_t *conf,
-                                      loc_t *loc)
+dht_init_local_subvols_and_nodeuuids(xlator_t *this, dht_conf_t *conf,
+                                     loc_t *loc)
 {
-
-        dict_t                  *dict         = NULL;
-        gf_defrag_info_t        *defrag       = NULL;
-        uuid_t                  *uuid_ptr     = NULL;
-        int                      ret          = -1;
-        int                      i            = 0;
-        int                      j            = 0;
-
-        defrag = conf->defrag;
-
-        if (defrag->cmd != GF_DEFRAG_CMD_START_TIER) {
-                /* Find local subvolumes */
-                ret = syncop_getxattr (this, loc, &dict,
-                                       GF_REBAL_FIND_LOCAL_SUBVOL,
-                                       NULL, NULL);
-                if (ret && (ret != -ENODATA)) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret, 0, "local "
-                                "subvolume determination failed with error: %d",
-                                -ret);
-                        ret = -1;
-                        goto out;
-                 }
-
-        if (!ret)
-                goto out;
+    dict_t *dict = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    uuid_t *uuid_ptr = NULL;
+    int ret = -1;
+    int i = 0;
+    int j = 0;
+
+    defrag = conf->defrag;
+
+    if (defrag->cmd != GF_DEFRAG_CMD_START_TIER) {
+        /* Find local subvolumes */
+        ret = syncop_getxattr(this, loc, &dict, GF_REBAL_FIND_LOCAL_SUBVOL,
+                              NULL, NULL);
+        if (ret && (ret != -ENODATA)) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret, 0,
+                   "local "
+                   "subvolume determination failed with error: %d",
+                   -ret);
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_getxattr (this, loc, &dict,
-                               GF_REBAL_OLD_FIND_LOCAL_SUBVOL,
-                               NULL, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, 0, "local "
-                        "subvolume determination failed with error: %d",
-                        -ret);
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+        if (!ret)
+            goto out;
+    }
+
+    ret = syncop_getxattr(this, loc, &dict, GF_REBAL_OLD_FIND_LOCAL_SUBVOL,
+                          NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, 0,
+               "local "
+               "subvolume determination failed with error: %d",
+               -ret);
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        if (ret) {
-                return ret;
-        }
+    if (ret) {
+        return ret;
+    }
 
-        for (i = 0 ; i < conf->local_subvols_cnt; i++) {
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "local subvol: "
-                        "%s", conf->local_subvols[i]->name);
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "local subvol: "
+               "%s",
+               conf->local_subvols[i]->name);
 
-                for (j = 0; j < conf->local_nodeuuids[i].count; j++) {
-                        uuid_ptr = &(conf->local_nodeuuids[i].elements[j].uuid);
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                                "node uuid : %s",
-                                uuid_utoa(*uuid_ptr));
-                }
+        for (j = 0; j < conf->local_nodeuuids[i].count; j++) {
+            uuid_ptr = &(conf->local_nodeuuids[i].elements[j].uuid);
+            gf_msg(this->name, GF_LOG_INFO, 0, 0, "node uuid : %s",
+                   uuid_utoa(*uuid_ptr));
         }
+    }
 
-        return ret;
+    return ret;
 }
 
-
 /* Functions for the rebalance estimates feature */
 
 uint64_t
-gf_defrag_subvol_file_size (xlator_t *this, loc_t *root_loc)
+gf_defrag_subvol_file_size(xlator_t *this, loc_t *root_loc)
 {
-        int ret = -1;
-        struct statvfs buf = {0,};
+    int ret = -1;
+    struct statvfs buf = {
+        0,
+    };
 
-        if (!this)
-                return 0;
+    if (!this)
+        return 0;
 
-        ret = syncop_statfs (this, root_loc, &buf, NULL, NULL);
-        if (ret) {
-                /* Aargh! */
-                return 0;
-        }
-        return ((buf.f_blocks - buf.f_bfree) * buf.f_frsize);
+    ret = syncop_statfs(this, root_loc, &buf, NULL, NULL);
+    if (ret) {
+        /* Aargh! */
+        return 0;
+    }
+    return ((buf.f_blocks - buf.f_bfree) * buf.f_frsize);
 }
 
 uint64_t
-gf_defrag_total_file_size (xlator_t *this, loc_t *root_loc)
+gf_defrag_total_file_size(xlator_t *this, loc_t *root_loc)
 {
-        dht_conf_t    *conf  = NULL;
-        int            i     = 0;
-        uint64_t       size_files = 0;
-        uint64_t       total_size = 0;
-
-        conf = this->private;
-        if (!conf) {
-                return 0;
-        }
-
-        for (i = 0 ; i < conf->local_subvols_cnt; i++) {
-                size_files = gf_defrag_subvol_file_size (conf->local_subvols[i],
-                                                         root_loc);
-                total_size += size_files;
-                gf_msg (this->name, GF_LOG_INFO, 0, 0, "local subvol: %s,"
-                        "cnt = %"PRIu64, conf->local_subvols[i]->name,
-                        size_files);
-        }
-
-        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                "Total size files = %"PRIu64, total_size);
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    uint64_t size_files = 0;
+    uint64_t total_size = 0;
 
-        return total_size;
+    conf = this->private;
+    if (!conf) {
+        return 0;
+    }
+
+    for (i = 0; i < conf->local_subvols_cnt; i++) {
+        size_files = gf_defrag_subvol_file_size(conf->local_subvols[i],
+                                                root_loc);
+        total_size += size_files;
+        gf_msg(this->name, GF_LOG_INFO, 0, 0,
+               "local subvol: %s,"
+               "cnt = %" PRIu64,
+               conf->local_subvols[i]->name, size_files);
+    }
+
+    gf_msg(this->name, GF_LOG_INFO, 0, 0, "Total size files = %" PRIu64,
+           total_size);
+
+    return total_size;
 }
 
-
-static void*
-dht_file_counter_thread (void *args)
+static void *
+dht_file_counter_thread(void *args)
 {
-        gf_defrag_info_t *defrag      = NULL;
-        loc_t root_loc                = {0,};
-        struct timespec time_to_wait  = {0,};
-        struct timeval now            = {0,};
-        uint64_t tmp_size             = 0;
-
-
-        if (!args)
-                return NULL;
-
-        defrag = (gf_defrag_info_t *) args;
-        dht_build_root_loc (defrag->root_inode, &root_loc);
-
-        while (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED) {
-
-                gettimeofday (&now, NULL);
-                time_to_wait.tv_sec = now.tv_sec + 600;
-                time_to_wait.tv_nsec = 0;
+    gf_defrag_info_t *defrag = NULL;
+    loc_t root_loc = {
+        0,
+    };
+    struct timespec time_to_wait = {
+        0,
+    };
+    struct timeval now = {
+        0,
+    };
+    uint64_t tmp_size = 0;
+
+    if (!args)
+        return NULL;
 
+    defrag = (gf_defrag_info_t *)args;
+    dht_build_root_loc(defrag->root_inode, &root_loc);
 
-                pthread_mutex_lock (&defrag->fc_mutex);
-                pthread_cond_timedwait (&defrag->fc_wakeup_cond,
-                                        &defrag->fc_mutex,
-                                        &time_to_wait);
+    while (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED) {
+        gettimeofday(&now, NULL);
+        time_to_wait.tv_sec = now.tv_sec + 600;
+        time_to_wait.tv_nsec = 0;
 
-                pthread_mutex_unlock (&defrag->fc_mutex);
+        pthread_mutex_lock(&defrag->fc_mutex);
+        pthread_cond_timedwait(&defrag->fc_wakeup_cond, &defrag->fc_mutex,
+                               &time_to_wait);
 
+        pthread_mutex_unlock(&defrag->fc_mutex);
 
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
-                        break;
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
+            break;
 
-                tmp_size = gf_defrag_total_file_size (defrag->this,
-                                                         &root_loc);
+        tmp_size = gf_defrag_total_file_size(defrag->this, &root_loc);
 
-                gf_log ("dht", GF_LOG_INFO,
-                        "tmp data size =%"PRIu64,
-                        tmp_size);
+        gf_log("dht", GF_LOG_INFO, "tmp data size =%" PRIu64, tmp_size);
 
-                if (!tmp_size) {
-                        gf_msg ("dht", GF_LOG_ERROR, 0, 0, "Failed to get "
-                                "the total data size. Unable to estimate "
-                                "time to complete rebalance.");
-                } else {
-                        g_totalsize = tmp_size;
-                        gf_msg_debug ("dht", 0,
-                                      "total data size =%"PRIu64,
-                                      g_totalsize);
-                }
+        if (!tmp_size) {
+            gf_msg("dht", GF_LOG_ERROR, 0, 0,
+                   "Failed to get "
+                   "the total data size. Unable to estimate "
+                   "time to complete rebalance.");
+        } else {
+            g_totalsize = tmp_size;
+            gf_msg_debug("dht", 0, "total data size =%" PRIu64, g_totalsize);
         }
+    }
 
-        return NULL;
+    return NULL;
 }
 
 int
-gf_defrag_estimates_cleanup (xlator_t *this, gf_defrag_info_t *defrag,
-                             pthread_t filecnt_thread)
+gf_defrag_estimates_cleanup(xlator_t *this, gf_defrag_info_t *defrag,
+                            pthread_t filecnt_thread)
 {
-        int ret   = -1;
-
-        /* Wake up the filecounter thread.
-         * By now the defrag status will no longer be
-         * GF_DEFRAG_STATUS_STARTED so the thread will exit the loop.
-         */
-        pthread_mutex_lock (&defrag->fc_mutex);
-        {
-                pthread_cond_broadcast (&defrag->fc_wakeup_cond);
-        }
-        pthread_mutex_unlock (&defrag->fc_mutex);
-
-        ret = pthread_join (filecnt_thread, NULL);
-        if (ret) {
-                gf_msg ("dht", GF_LOG_ERROR, ret, 0,
-                        "file_counter_thread: pthread_join failed.");
-                ret = -1;
-        }
-        return ret;
+    int ret = -1;
+
+    /* Wake up the filecounter thread.
+     * By now the defrag status will no longer be
+     * GF_DEFRAG_STATUS_STARTED so the thread will exit the loop.
+     */
+    pthread_mutex_lock(&defrag->fc_mutex);
+    {
+        pthread_cond_broadcast(&defrag->fc_wakeup_cond);
+    }
+    pthread_mutex_unlock(&defrag->fc_mutex);
+
+    ret = pthread_join(filecnt_thread, NULL);
+    if (ret) {
+        gf_msg("dht", GF_LOG_ERROR, ret, 0,
+               "file_counter_thread: pthread_join failed.");
+        ret = -1;
+    }
+    return ret;
 }
 
-
 int
-gf_defrag_estimates_init (xlator_t *this, loc_t *loc,
-                          pthread_t *filecnt_thread)
+gf_defrag_estimates_init(xlator_t *this, loc_t *loc, pthread_t *filecnt_thread)
 {
-        int                      ret            = -1;
-        dht_conf_t              *conf           = NULL;
-        gf_defrag_info_t        *defrag         = NULL;
-
-        conf = this->private;
-        defrag = conf->defrag;
-
-        g_totalsize = gf_defrag_total_file_size (this, loc);
-        if (!g_totalsize) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, 0, "Failed to get "
-                        "the total data size. Unable to estimate "
-                        "time to complete rebalance.");
-                goto out;
-        }
-
-        ret = gf_thread_create (filecnt_thread, NULL,
-                                &dht_file_counter_thread,
-                                (void *)defrag, "dhtfcnt");
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, ret, 0, "Failed to "
-                        "create the file counter thread ");
-                ret = -1;
-                goto out;
-        }
-        ret = 0;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+
+    conf = this->private;
+    defrag = conf->defrag;
+
+    g_totalsize = gf_defrag_total_file_size(this, loc);
+    if (!g_totalsize) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+               "Failed to get "
+               "the total data size. Unable to estimate "
+               "time to complete rebalance.");
+        goto out;
+    }
+
+    ret = gf_thread_create(filecnt_thread, NULL, &dht_file_counter_thread,
+                           (void *)defrag, "dhtfcnt");
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, ret, 0,
+               "Failed to "
+               "create the file counter thread ");
+        ret = -1;
+        goto out;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Init and cleanup functions for parallel file migration*/
 int
-gf_defrag_parallel_migration_init (xlator_t *this, gf_defrag_info_t *defrag,
-                                   pthread_t **tid_array, int *thread_index)
+gf_defrag_parallel_migration_init(xlator_t *this, gf_defrag_info_t *defrag,
+                                  pthread_t **tid_array, int *thread_index)
 {
-        int            ret                      = -1;
-        int            thread_spawn_count       = 0;
-        int            index                    = 0;
-        pthread_t     *tid                      = NULL;
-        char           thread_name[GF_THREAD_NAMEMAX] = {0,};
-
-        if (!defrag)
-                goto out;
-
-        /* Initialize global entry queue */
-        defrag->queue = GF_CALLOC (1, sizeof (struct dht_container),
-                                   gf_dht_mt_container_t);
-
-        if (!defrag->queue) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, 0,
-                        "Failed to initialise migration queue");
-                ret = -1;
-                goto out;
-        }
+    int ret = -1;
+    int thread_spawn_count = 0;
+    int index = 0;
+    pthread_t *tid = NULL;
+    char thread_name[GF_THREAD_NAMEMAX] = {
+        0,
+    };
+
+    if (!defrag)
+        goto out;
+
+    /* Initialize global entry queue */
+    defrag->queue = GF_CALLOC(1, sizeof(struct dht_container),
+                              gf_dht_mt_container_t);
+
+    if (!defrag->queue) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, 0,
+               "Failed to initialise migration queue");
+        ret = -1;
+        goto out;
+    }
 
-        INIT_LIST_HEAD (&(defrag->queue[0].list));
+    INIT_LIST_HEAD(&(defrag->queue[0].list));
 
-        thread_spawn_count = MAX (MAX_REBAL_THREADS, 4);
+    thread_spawn_count = MAX(MAX_REBAL_THREADS, 4);
 
-        gf_msg_debug (this->name, 0, "thread_spawn_count: %d",
-                      thread_spawn_count);
+    gf_msg_debug(this->name, 0, "thread_spawn_count: %d", thread_spawn_count);
 
-        tid = GF_CALLOC (thread_spawn_count, sizeof (pthread_t),
-                         gf_common_mt_pthread_t);
-        if (!tid) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,  0,
-                        "Failed to create migration threads");
-                ret = -1;
-                goto out;
-        }
-        defrag->current_thread_count = thread_spawn_count;
-
-        /*Spawn Threads Here*/
-        while (index < thread_spawn_count) {
-                snprintf (thread_name, sizeof(thread_name),
-                          "dhtmig%d", ((index + 1) & 0x3ff));
-                ret = gf_thread_create (&(tid[index]), NULL,
-                                        &gf_defrag_task, (void *)defrag,
-                                        thread_name);
-                if (ret != 0) {
-                        gf_msg ("DHT", GF_LOG_ERROR, ret, 0,
-                                "Thread[%d] creation failed. ",
-                                 index);
-                         ret = -1;
-                         goto out;
-                } else {
-                        gf_log ("DHT", GF_LOG_INFO, "Thread[%d] "
-                                "creation successful", index);
-                }
-                index++;
+    tid = GF_CALLOC(thread_spawn_count, sizeof(pthread_t),
+                    gf_common_mt_pthread_t);
+    if (!tid) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, 0,
+               "Failed to create migration threads");
+        ret = -1;
+        goto out;
+    }
+    defrag->current_thread_count = thread_spawn_count;
+
+    /*Spawn Threads Here*/
+    while (index < thread_spawn_count) {
+        snprintf(thread_name, sizeof(thread_name), "dhtmig%d",
+                 ((index + 1) & 0x3ff));
+        ret = gf_thread_create(&(tid[index]), NULL, &gf_defrag_task,
+                               (void *)defrag, thread_name);
+        if (ret != 0) {
+            gf_msg("DHT", GF_LOG_ERROR, ret, 0, "Thread[%d] creation failed. ",
+                   index);
+            ret = -1;
+            goto out;
+        } else {
+            gf_log("DHT", GF_LOG_INFO,
+                   "Thread[%d] "
+                   "creation successful",
+                   index);
         }
+        index++;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        *thread_index = index;
-        *tid_array = tid;
+    *thread_index = index;
+    *tid_array = tid;
 
-        return ret;
+    return ret;
 }
 
 int
-gf_defrag_parallel_migration_cleanup (gf_defrag_info_t *defrag,
-                                      pthread_t *tid_array, int thread_index)
+gf_defrag_parallel_migration_cleanup(gf_defrag_info_t *defrag,
+                                     pthread_t *tid_array, int thread_index)
 {
-        int ret          = -1;
-        int i            =  0;
+    int ret = -1;
+    int i = 0;
 
-        if (!defrag)
-                goto out;
+    if (!defrag)
+        goto out;
 
-        /* Wake up all migration threads */
-        pthread_mutex_lock (&defrag->dfq_mutex);
-        {
-                defrag->crawl_done = 1;
+    /* Wake up all migration threads */
+    pthread_mutex_lock(&defrag->dfq_mutex);
+    {
+        defrag->crawl_done = 1;
 
-                pthread_cond_broadcast (&defrag->parallel_migration_cond);
-                pthread_cond_broadcast (&defrag->df_wakeup_thread);
-        }
-        pthread_mutex_unlock (&defrag->dfq_mutex);
+        pthread_cond_broadcast(&defrag->parallel_migration_cond);
+        pthread_cond_broadcast(&defrag->df_wakeup_thread);
+    }
+    pthread_mutex_unlock(&defrag->dfq_mutex);
 
-        /*Wait for all the threads to complete their task*/
-        for (i = 0; i < thread_index; i++) {
-                pthread_join (tid_array[i], NULL);
-        }
+    /*Wait for all the threads to complete their task*/
+    for (i = 0; i < thread_index; i++) {
+        pthread_join(tid_array[i], NULL);
+    }
 
-        GF_FREE (tid_array);
+    GF_FREE(tid_array);
 
-        /* Cleanup the migration queue */
-        if (defrag->queue) {
-                gf_dirent_free (defrag->queue[0].df_entry);
-                INIT_LIST_HEAD (&(defrag->queue[0].list));
-        }
+    /* Cleanup the migration queue */
+    if (defrag->queue) {
+        gf_dirent_free(defrag->queue[0].df_entry);
+        INIT_LIST_HEAD(&(defrag->queue[0].list));
+    }
 
-        GF_FREE (defrag->queue);
+    GF_FREE(defrag->queue);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-gf_defrag_start_crawl (void *data)
+gf_defrag_start_crawl(void *data)
 {
-        xlator_t                *this                   = NULL;
-        dht_conf_t              *conf                   = NULL;
-        gf_defrag_info_t        *defrag                 = NULL;
-        dict_t                  *fix_layout             = NULL;
-        dict_t                  *migrate_data           = NULL;
-        dict_t                  *status                 = NULL;
-        glusterfs_ctx_t         *ctx                    = NULL;
-        dht_methods_t           *methods                = NULL;
-        call_frame_t            *statfs_frame           = NULL;
-        xlator_t                *old_THIS               = NULL;
-        int                      ret                    = -1;
-        loc_t                    loc                    = {0,};
-        struct iatt              iatt                   = {0,};
-        struct iatt              parent                 = {0,};
-        int                      thread_index           = 0;
-        pthread_t               *tid                    = NULL;
-        pthread_t                filecnt_thread;
-        gf_boolean_t             is_tier_detach         = _gf_false;
-        gf_boolean_t             fc_thread_started      = _gf_false;
-
-        this = data;
-        if (!this)
-                goto exit;
-
-        ctx = this->ctx;
-        if (!ctx)
-                goto exit;
-
-        conf = this->private;
-        if (!conf)
-                goto exit;
-
-        defrag = conf->defrag;
-        if (!defrag)
-                goto exit;
-
-        gettimeofday (&defrag->start_time, NULL);
-        dht_build_root_inode (this, &defrag->root_inode);
-        if (!defrag->root_inode)
-                goto out;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    dict_t *fix_layout = NULL;
+    dict_t *migrate_data = NULL;
+    dict_t *status = NULL;
+    glusterfs_ctx_t *ctx = NULL;
+    dht_methods_t *methods = NULL;
+    call_frame_t *statfs_frame = NULL;
+    xlator_t *old_THIS = NULL;
+    int ret = -1;
+    loc_t loc = {
+        0,
+    };
+    struct iatt iatt = {
+        0,
+    };
+    struct iatt parent = {
+        0,
+    };
+    int thread_index = 0;
+    pthread_t *tid = NULL;
+    pthread_t filecnt_thread;
+    gf_boolean_t is_tier_detach = _gf_false;
+    gf_boolean_t fc_thread_started = _gf_false;
+
+    this = data;
+    if (!this)
+        goto exit;
+
+    ctx = this->ctx;
+    if (!ctx)
+        goto exit;
+
+    conf = this->private;
+    if (!conf)
+        goto exit;
+
+    defrag = conf->defrag;
+    if (!defrag)
+        goto exit;
+
+    gettimeofday(&defrag->start_time, NULL);
+    dht_build_root_inode(this, &defrag->root_inode);
+    if (!defrag->root_inode)
+        goto out;
+
+    dht_build_root_loc(defrag->root_inode, &loc);
+
+    /* fix-layout on '/' first */
+
+    ret = syncop_lookup(this, &loc, &iatt, &parent, NULL, NULL);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_REBALANCE_START_FAILED,
+               "Failed to start rebalance: look up on / failed");
+        ret = -1;
+        goto out;
+    }
 
-        dht_build_root_loc (defrag->root_inode, &loc);
+    old_THIS = THIS;
+    THIS = this;
 
-        /* fix-layout on '/' first */
+    statfs_frame = create_frame(this, this->ctx->pool);
+    if (!statfs_frame) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
+               "Insufficient memory. Frame creation failed");
+        ret = -1;
+        goto out;
+    }
 
-        ret = syncop_lookup (this, &loc, &iatt, &parent, NULL, NULL);
+    /* async statfs update for honoring min-free-disk */
+    dht_get_du_info(statfs_frame, this, &loc);
+    THIS = old_THIS;
 
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Failed to start rebalance: look up on / failed");
-                ret = -1;
-                goto out;
-        }
+    fix_layout = dict_new();
+    if (!fix_layout) {
+        ret = -1;
+        goto out;
+    }
+
+    /*
+     * Unfortunately, we can't do special xattrs (like fix.layout) and
+     * real ones in the same call currently, and changing it seems
+     * riskier than just doing two calls.
+     */
+
+    gf_log(this->name, GF_LOG_INFO, "%s using commit hash %u", __func__,
+           conf->vol_commit_hash);
+
+    ret = dict_set_uint32(fix_layout, conf->commithash_xattr_name,
+                          conf->vol_commit_hash);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Failed to set %s",
+               conf->commithash_xattr_name);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
+
+    ret = syncop_setxattr(this, &loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Failed to set commit hash on %s. "
+               "Rebalance cannot proceed.",
+               loc.path);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
+
+    /* We now return to our regularly scheduled program. */
+
+    ret = dict_set_str(fix_layout, GF_XATTR_FIX_LAYOUT_KEY, "yes");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+               "Failed to start rebalance:"
+               "Failed to set dictionary value: key = %s",
+               GF_XATTR_FIX_LAYOUT_KEY);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        old_THIS = THIS;
-        THIS = this;
+    defrag->new_commit_hash = conf->vol_commit_hash;
 
-        statfs_frame = create_frame (this, this->ctx->pool);
-        if (!statfs_frame) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, ENOMEM,
-                        "Insufficient memory. Frame creation failed");
-                ret = -1;
-                goto out;
-        }
+    ret = syncop_setxattr(this, &loc, fix_layout, 0, NULL, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_REBALANCE_FAILED,
+               "fix layout on %s failed", loc.path);
+        defrag->total_failures++;
+        ret = -1;
+        goto out;
+    }
 
-        /* async statfs update for honoring min-free-disk */
-        dht_get_du_info (statfs_frame, this, &loc);
-        THIS = old_THIS;
+    if (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX) {
+        /* We need to migrate files */
 
-        fix_layout = dict_new ();
-        if (!fix_layout) {
-                ret = -1;
-                goto out;
+        migrate_data = dict_new();
+        if (!migrate_data) {
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
-
-        /*
-         * Unfortunately, we can't do special xattrs (like fix.layout) and
-         * real ones in the same call currently, and changing it seems
-         * riskier than just doing two calls.
-         */
-
-        gf_log (this->name, GF_LOG_INFO, "%s using commit hash %u",
-                __func__, conf->vol_commit_hash);
-
-        ret = dict_set_uint32 (fix_layout, conf->commithash_xattr_name,
-                               conf->vol_commit_hash);
+        ret = dict_set_str(
+            migrate_data, GF_XATTR_FILE_MIGRATE_KEY,
+            (defrag->cmd == GF_DEFRAG_CMD_START_FORCE) ? "force" : "non-force");
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set %s", conf->commithash_xattr_name);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
 
-        ret = syncop_setxattr (this, &loc, fix_layout, 0, NULL, NULL);
+        ret = dht_init_local_subvols_and_nodeuuids(this, conf, &loc);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to set commit hash on %s. "
-                        "Rebalance cannot proceed.",
-                        loc.path);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            ret = -1;
+            goto out;
         }
 
-        /* We now return to our regularly scheduled program. */
-
-        ret = dict_set_str (fix_layout, GF_XATTR_FIX_LAYOUT_KEY, "yes");
+        /* Initialise the structures required for parallel migration */
+        ret = gf_defrag_parallel_migration_init(this, defrag, &tid,
+                                                &thread_index);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Failed to start rebalance:"
-                        "Failed to set dictionary value: key = %s",
-                        GF_XATTR_FIX_LAYOUT_KEY);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, 0, "Aborting rebalance.");
+            goto out;
         }
 
-        defrag->new_commit_hash = conf->vol_commit_hash;
-
-        ret = syncop_setxattr (this, &loc, fix_layout, 0, NULL, NULL);
+        ret = gf_defrag_estimates_init(this, &loc, &filecnt_thread);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_REBALANCE_FAILED,
-                        "fix layout on %s failed",
-                        loc.path);
-                defrag->total_failures++;
-                ret = -1;
-                goto out;
-        }
-
-        if (defrag->cmd != GF_DEFRAG_CMD_START_LAYOUT_FIX) {
-                /* We need to migrate files */
-
-                migrate_data = dict_new ();
-                if (!migrate_data) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-                ret = dict_set_str (migrate_data, GF_XATTR_FILE_MIGRATE_KEY,
-                        (defrag->cmd == GF_DEFRAG_CMD_START_FORCE)
-                        ?  "force" : "non-force");
-                if (ret) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dht_init_local_subvols_and_nodeuuids (this, conf, &loc);
-                if (ret) {
-                        ret = -1;
-                        goto out;
-                }
-
-                /* Initialise the structures required for parallel migration */
-                ret = gf_defrag_parallel_migration_init (this, defrag, &tid,
-                                                         &thread_index);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0, 0,
-                                "Aborting rebalance.");
-                        goto out;
-                }
-
-                ret = gf_defrag_estimates_init (this, &loc, &filecnt_thread);
-                if (ret) {
-                        /* Not a fatal error. Allow the rebalance to proceed*/
-                        ret = 0;
-                } else {
-                        fc_thread_started = _gf_true;
-                }
-        }
-
-
-        if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                /* Fix layout for attach tier */
-                ret = gf_tier_start_fix_layout (this, &loc, defrag, fix_layout);
-                if (ret) {
-                        goto out;
-                }
-
-                methods = &(conf->methods);
-
-                /* Calling tier_start of tier.c */
-                methods->migration_other(this, defrag);
-                if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-                    defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-
-                        ret = dict_set_str (migrate_data,
-                                            GF_XATTR_FILE_MIGRATE_KEY,
-                                            "force");
-                        if (ret)
-                                goto out;
-
-                }
+            /* Not a fatal error. Allow the rebalance to proceed*/
+            ret = 0;
         } else {
-                ret = gf_defrag_fix_layout (this, defrag, &loc, fix_layout,
-                                    migrate_data);
-                if (ret && ret != 2) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (ret != 2 && gf_defrag_settle_hash
-                        (this, defrag, &loc, fix_layout) != 0) {
-                        defrag->total_failures++;
-                        ret = -1;
-                        goto out;
-                }
-
-                if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-                    defrag->cmd == GF_DEFRAG_CMD_DETACH_START)
-                        is_tier_detach = _gf_true;
-
+            fc_thread_started = _gf_true;
         }
+    }
 
-        gf_log ("DHT", GF_LOG_INFO, "crawling file-system completed");
-out:
-
-        /* We are here means crawling the entire file system is done
-           or something failed. Set defrag->crawl_done flag to intimate
-           the migrator threads to exhaust the defrag->queue and terminate*/
-
+    if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
+        /* Fix layout for attach tier */
+        ret = gf_tier_start_fix_layout(this, &loc, defrag, fix_layout);
         if (ret) {
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+            goto out;
         }
 
+        methods = &(conf->methods);
 
-        if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
-                /* Wait for the tier fixlayout to
-                 * complete if its was started.*/
-                 gf_tier_wait_fix_lookup (defrag);
-        }
-
-        if (is_tier_detach && ret == 0) {
-                /* If it was a detach remove the tier fix-layout
-                * xattr on root. Ignoring the failure, as nothing has to be
-                * done, logging is done in gf_tier_clear_fix_layout */
-                gf_tier_clear_fix_layout (this, &loc, defrag);
-        }
-
-        gf_defrag_parallel_migration_cleanup (defrag, tid, thread_index);
-
-        if ((defrag->defrag_status != GF_DEFRAG_STATUS_STOPPED) &&
-            (defrag->defrag_status != GF_DEFRAG_STATUS_FAILED)) {
-                defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
+        /* Calling tier_start of tier.c */
+        methods->migration_other(this, defrag);
+        if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
+            defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
+            ret = dict_set_str(migrate_data, GF_XATTR_FILE_MIGRATE_KEY,
+                               "force");
+            if (ret)
+                goto out;
         }
-
-        if (fc_thread_started) {
-                gf_defrag_estimates_cleanup (this, defrag, filecnt_thread);
+    } else {
+        ret = gf_defrag_fix_layout(this, defrag, &loc, fix_layout,
+                                   migrate_data);
+        if (ret && ret != 2) {
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
 
-        dht_send_rebalance_event (this, defrag->cmd, defrag->defrag_status);
-
-        LOCK (&defrag->lock);
-        {
-                status = dict_new ();
-                gf_defrag_status_get (conf, status);
-                if (ctx && ctx->notify)
-                        ctx->notify (GF_EN_DEFRAG_STATUS, status);
-                if (status)
-                        dict_unref (status);
-                defrag->is_exiting = 1;
+        if (ret != 2 &&
+            gf_defrag_settle_hash(this, defrag, &loc, fix_layout) != 0) {
+            defrag->total_failures++;
+            ret = -1;
+            goto out;
         }
-        UNLOCK (&defrag->lock);
 
+        if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
+            defrag->cmd == GF_DEFRAG_CMD_DETACH_START)
+            is_tier_detach = _gf_true;
+    }
 
-        GF_FREE (defrag);
-        conf->defrag = NULL;
-
-        if (migrate_data)
-                dict_unref (migrate_data);
+    gf_log("DHT", GF_LOG_INFO, "crawling file-system completed");
+out:
 
-        if (statfs_frame) {
-                STACK_DESTROY (statfs_frame->root);
-        }
+    /* We are here means crawling the entire file system is done
+       or something failed. Set defrag->crawl_done flag to intimate
+       the migrator threads to exhaust the defrag->queue and terminate*/
+
+    if (ret) {
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+    }
+
+    if (defrag->cmd == GF_DEFRAG_CMD_START_TIER) {
+        /* Wait for the tier fixlayout to
+         * complete if its was started.*/
+        gf_tier_wait_fix_lookup(defrag);
+    }
+
+    if (is_tier_detach && ret == 0) {
+        /* If it was a detach remove the tier fix-layout
+         * xattr on root. Ignoring the failure, as nothing has to be
+         * done, logging is done in gf_tier_clear_fix_layout */
+        gf_tier_clear_fix_layout(this, &loc, defrag);
+    }
+
+    gf_defrag_parallel_migration_cleanup(defrag, tid, thread_index);
+
+    if ((defrag->defrag_status != GF_DEFRAG_STATUS_STOPPED) &&
+        (defrag->defrag_status != GF_DEFRAG_STATUS_FAILED)) {
+        defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
+    }
+
+    if (fc_thread_started) {
+        gf_defrag_estimates_cleanup(this, defrag, filecnt_thread);
+    }
+
+    dht_send_rebalance_event(this, defrag->cmd, defrag->defrag_status);
+
+    LOCK(&defrag->lock);
+    {
+        status = dict_new();
+        gf_defrag_status_get(conf, status);
+        if (ctx && ctx->notify)
+            ctx->notify(GF_EN_DEFRAG_STATUS, status);
+        if (status)
+            dict_unref(status);
+        defrag->is_exiting = 1;
+    }
+    UNLOCK(&defrag->lock);
+
+    GF_FREE(defrag);
+    conf->defrag = NULL;
+
+    if (migrate_data)
+        dict_unref(migrate_data);
+
+    if (statfs_frame) {
+        STACK_DESTROY(statfs_frame->root);
+    }
 exit:
-        return ret;
+    return ret;
 }
 
-
-
 static int
-gf_defrag_done  (int ret, call_frame_t *sync_frame, void *data)
+gf_defrag_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        gf_listener_stop (sync_frame->this);
+    gf_listener_stop(sync_frame->this);
 
-        STACK_DESTROY (sync_frame->root);
-        kill (getpid(), SIGTERM);
-        return 0;
+    STACK_DESTROY(sync_frame->root);
+    kill(getpid(), SIGTERM);
+    return 0;
 }
 
 void *
-gf_defrag_start (void *data)
+gf_defrag_start(void *data)
 {
-        int                      ret    = -1;
-        call_frame_t            *frame  = NULL;
-        dht_conf_t              *conf   = NULL;
-        gf_defrag_info_t        *defrag = NULL;
-        xlator_t                *this  = NULL;
-        xlator_t                *old_THIS = NULL;
-
-        this = data;
-        conf = this->private;
-        if (!conf)
-                goto out;
+    int ret = -1;
+    call_frame_t *frame = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    xlator_t *this = NULL;
+    xlator_t *old_THIS = NULL;
 
-        defrag = conf->defrag;
-        if (!defrag)
-                goto out;
+    this = data;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+    defrag = conf->defrag;
+    if (!defrag)
+        goto out;
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-        frame->root->pid = GF_CLIENT_PID_DEFRAG;
+    frame->root->pid = GF_CLIENT_PID_DEFRAG;
 
-        defrag->pid = frame->root->pid;
+    defrag->pid = frame->root->pid;
 
-        defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
+    defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
 
-        old_THIS = THIS;
-        THIS = this;
-        ret = synctask_new (this->ctx->env, gf_defrag_start_crawl,
-                            gf_defrag_done, frame, this);
+    old_THIS = THIS;
+    THIS = this;
+    ret = synctask_new(this->ctx->env, gf_defrag_start_crawl, gf_defrag_done,
+                       frame, this);
 
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_REBALANCE_START_FAILED,
-                        "Could not create task for rebalance");
-        THIS = old_THIS;
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_REBALANCE_START_FAILED,
+               "Could not create task for rebalance");
+    THIS = old_THIS;
 out:
-        return NULL;
+    return NULL;
 }
 
-
 uint64_t
-gf_defrag_get_estimates_based_on_size (dht_conf_t *conf)
+gf_defrag_get_estimates_based_on_size(dht_conf_t *conf)
 {
-        gf_defrag_info_t *defrag = NULL;
-        double            rate_processed = 0;
-        uint64_t          total_processed = 0;
-        uint64_t          tmp_count = 0;
-        uint64_t          time_to_complete = 0;
-        struct            timeval now = {0,};
-        double            elapsed = 0;
+    gf_defrag_info_t *defrag = NULL;
+    double rate_processed = 0;
+    uint64_t total_processed = 0;
+    uint64_t tmp_count = 0;
+    uint64_t time_to_complete = 0;
+    struct timeval now = {
+        0,
+    };
+    double elapsed = 0;
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        if (!g_totalsize)
-                goto out;
+    if (!g_totalsize)
+        goto out;
 
-        gettimeofday (&now, NULL);
-        elapsed = now.tv_sec - defrag->start_time.tv_sec;
+    gettimeofday(&now, NULL);
+    elapsed = now.tv_sec - defrag->start_time.tv_sec;
 
-        /* Don't calculate the estimates for the first 10 minutes.
-         * It is unlikely to be accurate and estimates are not required
-         * if the process finishes in less than 10 mins.
-         */
+    /* Don't calculate the estimates for the first 10 minutes.
+     * It is unlikely to be accurate and estimates are not required
+     * if the process finishes in less than 10 mins.
+     */
 
-        if (elapsed < ESTIMATE_START_INTERVAL) {
-                gf_msg (THIS->name, GF_LOG_INFO, 0, 0,
-                        "Rebalance estimates will not be available for the "
-                        "first %d seconds.", ESTIMATE_START_INTERVAL);
+    if (elapsed < ESTIMATE_START_INTERVAL) {
+        gf_msg(THIS->name, GF_LOG_INFO, 0, 0,
+               "Rebalance estimates will not be available for the "
+               "first %d seconds.",
+               ESTIMATE_START_INTERVAL);
 
-                goto out;
-        }
+        goto out;
+    }
 
-        total_processed = defrag->size_processed;
+    total_processed = defrag->size_processed;
 
-        /* rate at which files processed */
-        rate_processed = (total_processed)/elapsed;
+    /* rate at which files processed */
+    rate_processed = (total_processed) / elapsed;
 
-        tmp_count = g_totalsize;
+    tmp_count = g_totalsize;
 
-        if (rate_processed) {
-                time_to_complete = (tmp_count)/rate_processed;
+    if (rate_processed) {
+        time_to_complete = (tmp_count) / rate_processed;
 
-        } else {
-                gf_msg (THIS->name, GF_LOG_ERROR, 0, 0,
-                        "Unable to calculate estimated time for rebalance");
-        }
+    } else {
+        gf_msg(THIS->name, GF_LOG_ERROR, 0, 0,
+               "Unable to calculate estimated time for rebalance");
+    }
 
-        gf_log (THIS->name, GF_LOG_INFO,
-                "TIME: (size) total_processed=%"PRIu64" tmp_cnt = %"PRIu64","
-                "rate_processed=%f, elapsed = %f", total_processed, tmp_count,
-                rate_processed, elapsed);
+    gf_log(THIS->name, GF_LOG_INFO,
+           "TIME: (size) total_processed=%" PRIu64 " tmp_cnt = %" PRIu64
+           ","
+           "rate_processed=%f, elapsed = %f",
+           total_processed, tmp_count, rate_processed, elapsed);
 
 out:
-        return time_to_complete;
+    return time_to_complete;
 }
 
-
 int
-gf_defrag_status_get (dht_conf_t *conf, dict_t *dict)
+gf_defrag_status_get(dht_conf_t *conf, dict_t *dict)
 {
-        int      ret    = 0;
-        uint64_t files  = 0;
-        uint64_t size   = 0;
-        uint64_t lookup = 0;
-        uint64_t failures = 0;
-        uint64_t skipped = 0;
-        uint64_t promoted = 0;
-        uint64_t demoted = 0;
-        char    *status = "";
-        double   elapsed = 0;
-        struct timeval end = {0,};
-        uint64_t time_to_complete = 0;
-        uint64_t time_left = 0;
-        gf_defrag_info_t *defrag = conf->defrag;
-
-        if (!defrag)
-                goto out;
-
-        ret = 0;
-        if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED)
-                goto out;
-
-        files  = defrag->total_files;
-        size   = defrag->total_data;
-        lookup = defrag->num_files_lookedup;
-        failures = defrag->total_failures;
-        skipped = defrag->skipped;
-        promoted = defrag->total_files_promoted;
-        demoted = defrag->total_files_demoted;
-
-        gettimeofday (&end, NULL);
-
-        elapsed = end.tv_sec - defrag->start_time.tv_sec;
-
-
-        /* The rebalance is still in progress */
-
-        if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER)
-            && (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED)) {
-
-                time_to_complete = gf_defrag_get_estimates_based_on_size (conf);
-
-                if (time_to_complete && (time_to_complete > elapsed))
-                        time_left = time_to_complete - elapsed;
-
-                gf_log (THIS->name, GF_LOG_INFO,
-                        "TIME: Estimated total time to complete (size)= %"PRIu64
-                        " seconds, seconds left = %"PRIu64"",
-                        time_to_complete, time_left);
-        }
-
-        if (!dict)
-                goto log;
-
-        ret = dict_set_uint64 (dict, "promoted", promoted);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set promoted count");
-
-        ret = dict_set_uint64 (dict, "demoted", demoted);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set demoted count");
-
-        ret = dict_set_uint64 (dict, "files", files);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set file count");
-
-        ret = dict_set_uint64 (dict, "size", size);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set size of xfer");
-
-        ret = dict_set_uint64 (dict, "lookups", lookup);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set lookedup file count");
-
-
-        ret = dict_set_int32 (dict, "status", defrag->defrag_status);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set status");
-
-        ret = dict_set_double (dict, "run-time", elapsed);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set run-time");
-
-        ret = dict_set_uint64 (dict, "failures", failures);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set failure count");
-
-        ret = dict_set_uint64 (dict, "skipped", skipped);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set skipped file count");
-
-        ret = dict_set_uint64 (dict, "time-left", time_left);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to set time-left");
+    int ret = 0;
+    uint64_t files = 0;
+    uint64_t size = 0;
+    uint64_t lookup = 0;
+    uint64_t failures = 0;
+    uint64_t skipped = 0;
+    uint64_t promoted = 0;
+    uint64_t demoted = 0;
+    char *status = "";
+    double elapsed = 0;
+    struct timeval end = {
+        0,
+    };
+    uint64_t time_to_complete = 0;
+    uint64_t time_left = 0;
+    gf_defrag_info_t *defrag = conf->defrag;
+
+    if (!defrag)
+        goto out;
+
+    ret = 0;
+    if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED)
+        goto out;
+
+    files = defrag->total_files;
+    size = defrag->total_data;
+    lookup = defrag->num_files_lookedup;
+    failures = defrag->total_failures;
+    skipped = defrag->skipped;
+    promoted = defrag->total_files_promoted;
+    demoted = defrag->total_files_demoted;
+
+    gettimeofday(&end, NULL);
+
+    elapsed = end.tv_sec - defrag->start_time.tv_sec;
+
+    /* The rebalance is still in progress */
+
+    if ((defrag->cmd != GF_DEFRAG_CMD_START_TIER) &&
+        (defrag->defrag_status == GF_DEFRAG_STATUS_STARTED)) {
+        time_to_complete = gf_defrag_get_estimates_based_on_size(conf);
+
+        if (time_to_complete && (time_to_complete > elapsed))
+            time_left = time_to_complete - elapsed;
+
+        gf_log(THIS->name, GF_LOG_INFO,
+               "TIME: Estimated total time to complete (size)= %" PRIu64
+               " seconds, seconds left = %" PRIu64 "",
+               time_to_complete, time_left);
+    }
+
+    if (!dict)
+        goto log;
+
+    ret = dict_set_uint64(dict, "promoted", promoted);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set promoted count");
+
+    ret = dict_set_uint64(dict, "demoted", demoted);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set demoted count");
+
+    ret = dict_set_uint64(dict, "files", files);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set file count");
+
+    ret = dict_set_uint64(dict, "size", size);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set size of xfer");
+
+    ret = dict_set_uint64(dict, "lookups", lookup);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set lookedup file count");
+
+    ret = dict_set_int32(dict, "status", defrag->defrag_status);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set status");
+
+    ret = dict_set_double(dict, "run-time", elapsed);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set run-time");
+
+    ret = dict_set_uint64(dict, "failures", failures);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set failure count");
+
+    ret = dict_set_uint64(dict, "skipped", skipped);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set skipped file count");
+
+    ret = dict_set_uint64(dict, "time-left", time_left);
+    if (ret)
+        gf_log(THIS->name, GF_LOG_WARNING, "failed to set time-left");
 
 log:
-        switch (defrag->defrag_status) {
+    switch (defrag->defrag_status) {
         case GF_DEFRAG_STATUS_NOT_STARTED:
-                status = "not started";
-                break;
+            status = "not started";
+            break;
         case GF_DEFRAG_STATUS_STARTED:
-                status = "in progress";
-                break;
+            status = "in progress";
+            break;
         case GF_DEFRAG_STATUS_STOPPED:
-                status = "stopped";
-                break;
+            status = "stopped";
+            break;
         case GF_DEFRAG_STATUS_COMPLETE:
-                status = "completed";
-                break;
+            status = "completed";
+            break;
         case GF_DEFRAG_STATUS_FAILED:
-                status = "failed";
-                break;
+            status = "failed";
+            break;
         default:
-                break;
-        }
-
-        gf_msg (THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
-                "Rebalance is %s. Time taken is %.2f secs",
-                status, elapsed);
-        gf_msg (THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
-                "Files migrated: %"PRIu64", size: %"
-                PRIu64", lookups: %"PRIu64", failures: %"PRIu64", skipped: "
-                "%"PRIu64, files, size, lookup, failures, skipped);
+            break;
+    }
+
+    gf_msg(THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
+           "Rebalance is %s. Time taken is %.2f secs", status, elapsed);
+    gf_msg(THIS->name, GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STATUS,
+           "Files migrated: %" PRIu64 ", size: %" PRIu64 ", lookups: %" PRIu64
+           ", failures: %" PRIu64
+           ", skipped: "
+           "%" PRIu64,
+           files, size, lookup, failures, skipped);
 out:
-        return 0;
+    return 0;
 }
 
 void
-gf_defrag_set_pause_state (gf_tier_conf_t *tier_conf, tier_pause_state_t state)
+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);
+    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)
+gf_defrag_get_pause_state(gf_tier_conf_t *tier_conf)
 {
-        int state;
+    int state;
 
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-        state = tier_conf->pause_state;
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
+    pthread_mutex_lock(&tier_conf->pause_mutex);
+    state = tier_conf->pause_state;
+    pthread_mutex_unlock(&tier_conf->pause_mutex);
 
-        return state;
+    return state;
 }
 
 tier_pause_state_t
-gf_defrag_check_pause_tier (gf_tier_conf_t *tier_conf)
+gf_defrag_check_pause_tier(gf_tier_conf_t *tier_conf)
 {
-        int woke = 0;
-        int state  = -1;
+    int woke = 0;
+    int state = -1;
 
-        pthread_mutex_lock (&tier_conf->pause_mutex);
+    pthread_mutex_lock(&tier_conf->pause_mutex);
 
-        if (tier_conf->pause_state == TIER_RUNNING)
-                goto out;
+    if (tier_conf->pause_state == TIER_RUNNING)
+        goto out;
 
-        if (tier_conf->pause_state == TIER_PAUSED)
-                goto out;
+    if (tier_conf->pause_state == TIER_PAUSED)
+        goto out;
 
-        if (tier_conf->promote_in_progress ||
-            tier_conf->demote_in_progress)
-                goto out;
+    if (tier_conf->promote_in_progress || tier_conf->demote_in_progress)
+        goto out;
 
-        tier_conf->pause_state = TIER_PAUSED;
+    tier_conf->pause_state = TIER_PAUSED;
 
-        if (tier_conf->pause_synctask) {
-                synctask_wake (tier_conf->pause_synctask);
-                tier_conf->pause_synctask = 0;
-                woke = 1;
-        }
+    if (tier_conf->pause_synctask) {
+        synctask_wake(tier_conf->pause_synctask);
+        tier_conf->pause_synctask = 0;
+        woke = 1;
+    }
 
-        gf_msg ("tier", GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "woken %d", woke);
+    gf_msg("tier", GF_LOG_DEBUG, 0, DHT_MSG_TIER_PAUSED, "woken %d", woke);
 
-        gf_event (EVENT_TIER_PAUSE, "vol=%s", tier_conf->volname);
+    gf_event(EVENT_TIER_PAUSE, "vol=%s", tier_conf->volname);
 out:
-        state = tier_conf->pause_state;
+    state = tier_conf->pause_state;
 
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
+    pthread_mutex_unlock(&tier_conf->pause_mutex);
 
-        return state;
+    return state;
 }
 
 void
-gf_defrag_pause_tier_timeout (void *data)
+gf_defrag_pause_tier_timeout(void *data)
 {
-        xlator_t         *this                  = NULL;
-        dht_conf_t       *conf                  = NULL;
-        gf_defrag_info_t *defrag                = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
 
-        this   = (xlator_t *) data;
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
+    this = (xlator_t *)data;
+    GF_VALIDATE_OR_GOTO("tier", this, out);
 
-        conf   = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
 
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
+    defrag = conf->defrag;
+    GF_VALIDATE_OR_GOTO(this->name, defrag, out);
 
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Request pause timer timeout");
+    gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_TIER_PAUSED,
+           "Request pause timer timeout");
 
-        gf_defrag_check_pause_tier (&defrag->tier_conf);
+    gf_defrag_check_pause_tier(&defrag->tier_conf);
 
 out:
-        return;
+    return;
 }
 
 int
-gf_defrag_pause_tier (xlator_t *this, gf_defrag_info_t *defrag)
+gf_defrag_pause_tier(xlator_t *this, gf_defrag_info_t *defrag)
 {
-        int             ret         = 0;
-        struct timespec delta       = {0,};
-        int             delay       = 2;
-
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
-                goto out;
-
-        /*
-         * Set flag requesting to pause tiering. Wait 'delay' seconds for
-         * tiering to actually stop as indicated by the pause state
-         * before returning success or failure.
-         */
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_REQUEST_PAUSE);
-
-        /*
-         * 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,
-                DHT_MSG_TIER_PAUSED,
-                "Request pause tier");
-
-        defrag->tier_conf.pause_synctask = synctask_get ();
-        delta.tv_sec  = delay;
-        delta.tv_nsec = 0;
-        defrag->tier_conf.pause_timer =
-                gf_timer_call_after (this->ctx, delta,
-                                     gf_defrag_pause_tier_timeout,
-                                     this);
-
-        synctask_yield (defrag->tier_conf.pause_synctask);
-
-        if (gf_defrag_get_pause_state (&defrag->tier_conf) == TIER_PAUSED)
-                goto out;
-
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
-
-        ret = -1;
+    int ret = 0;
+    struct timespec delta = {
+        0,
+    };
+    int delay = 2;
+
+    if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED)
+        goto out;
+
+    /*
+     * Set flag requesting to pause tiering. Wait 'delay' seconds for
+     * tiering to actually stop as indicated by the pause state
+     * before returning success or failure.
+     */
+    gf_defrag_set_pause_state(&defrag->tier_conf, TIER_REQUEST_PAUSE);
+
+    /*
+     * 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, DHT_MSG_TIER_PAUSED,
+           "Request pause tier");
+
+    defrag->tier_conf.pause_synctask = synctask_get();
+    delta.tv_sec = delay;
+    delta.tv_nsec = 0;
+    defrag->tier_conf.pause_timer = gf_timer_call_after(
+        this->ctx, delta, gf_defrag_pause_tier_timeout, this);
+
+    synctask_yield(defrag->tier_conf.pause_synctask);
+
+    if (gf_defrag_get_pause_state(&defrag->tier_conf) == TIER_PAUSED)
+        goto out;
+
+    gf_defrag_set_pause_state(&defrag->tier_conf, TIER_RUNNING);
+
+    ret = -1;
 out:
 
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Pause tiering ret=%d", ret);
+    gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_TIER_PAUSED,
+           "Pause tiering ret=%d", ret);
 
-        return ret;
+    return ret;
 }
 
 int
-gf_defrag_resume_tier (xlator_t *this, gf_defrag_info_t *defrag)
+gf_defrag_resume_tier(xlator_t *this, gf_defrag_info_t *defrag)
 {
-        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                DHT_MSG_TIER_RESUME,
-                "Pause end. Resume tiering");
+    gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_TIER_RESUME,
+           "Pause end. Resume tiering");
 
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
+    gf_defrag_set_pause_state(&defrag->tier_conf, TIER_RUNNING);
 
-        gf_event (EVENT_TIER_RESUME, "vol=%s", defrag->tier_conf.volname);
+    gf_event(EVENT_TIER_RESUME, "vol=%s", defrag->tier_conf.volname);
 
-        return 0;
+    return 0;
 }
 
 int
-gf_defrag_start_detach_tier (gf_defrag_info_t *defrag)
+gf_defrag_start_detach_tier(gf_defrag_info_t *defrag)
 {
-        defrag->cmd = GF_DEFRAG_CMD_START_DETACH_TIER;
+    defrag->cmd = GF_DEFRAG_CMD_START_DETACH_TIER;
 
-        return 0;
+    return 0;
 }
 
 int
-gf_defrag_stop (dht_conf_t *conf, gf_defrag_status_t status,
-                dict_t *output)
+gf_defrag_stop(dht_conf_t *conf, gf_defrag_status_t status, dict_t *output)
 {
-        /* TODO: set a variable 'stop_defrag' here, it should be checked
-           in defrag loop */
-        int     ret = -1;
-        gf_defrag_info_t *defrag = conf->defrag;
+    /* TODO: set a variable 'stop_defrag' here, it should be checked
+       in defrag loop */
+    int ret = -1;
+    gf_defrag_info_t *defrag = conf->defrag;
 
-        GF_ASSERT (defrag);
+    GF_ASSERT(defrag);
 
-        if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED) {
-                goto out;
-        }
+    if (defrag->defrag_status == GF_DEFRAG_STATUS_NOT_STARTED) {
+        goto out;
+    }
 
-        gf_msg ("", GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STOPPED,
-                "Received stop command on rebalance");
-        defrag->defrag_status = status;
+    gf_msg("", GF_LOG_INFO, 0, DHT_MSG_REBALANCE_STOPPED,
+           "Received stop command on rebalance");
+    defrag->defrag_status = status;
 
-        if (output)
-                gf_defrag_status_get (conf, output);
-        ret = 0;
+    if (output)
+        gf_defrag_status_get(conf, output);
+    ret = 0;
 out:
-        gf_msg_debug ("", 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug("", 0, "Returning %d", ret);
+    return ret;
 }
diff --git a/xlators/cluster/dht/src/dht-rename.c b/xlators/cluster/dht/src/dht-rename.c
index 295d95232ec..45808a2bfa6 100644
--- a/xlators/cluster/dht/src/dht-rename.c
+++ b/xlators/cluster/dht/src/dht-rename.c
@@ -17,483 +17,450 @@
 #include "dht-lock.h"
 #include "defaults.h"
 
-int dht_rename_unlock (call_frame_t *frame, xlator_t *this);
+int
+dht_rename_unlock(call_frame_t *frame, xlator_t *this);
 int32_t
-dht_rename_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata);
+dht_rename_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata);
 
 int
-dht_rename_unlock_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+dht_rename_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        dht_set_fixed_dir_stat (&local->preoldparent);
-        dht_set_fixed_dir_stat (&local->postoldparent);
-        dht_set_fixed_dir_stat (&local->preparent);
-        dht_set_fixed_dir_stat (&local->postparent);
+    dht_set_fixed_dir_stat(&local->preoldparent);
+    dht_set_fixed_dir_stat(&local->postoldparent);
+    dht_set_fixed_dir_stat(&local->preparent);
+    dht_set_fixed_dir_stat(&local->postparent);
 
-        if (IA_ISREG (local->stbuf.ia_type))
-                DHT_STRIP_PHASE1_FLAGS (&local->stbuf);
+    if (IA_ISREG(local->stbuf.ia_type))
+        DHT_STRIP_PHASE1_FLAGS(&local->stbuf);
 
-        DHT_STACK_UNWIND (rename, frame, local->op_ret, local->op_errno,
-                          &local->stbuf, &local->preoldparent,
-                          &local->postoldparent, &local->preparent,
-                          &local->postparent, local->xattr);
-        return 0;
+    DHT_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
+                     &local->stbuf, &local->preoldparent, &local->postoldparent,
+                     &local->preparent, &local->postparent, local->xattr);
+    return 0;
 }
 
 static void
-dht_rename_dir_unlock_src (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock_src(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        dht_unlock_namespace (frame, &local->lock[0]);
-        return;
+    local = frame->local;
+    dht_unlock_namespace(frame, &local->lock[0]);
+    return;
 }
 
 static void
-dht_rename_dir_unlock_dst (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock_dst(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
-        int          op_ret                     = -1;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[1].ns.directory_ns);
-
-        /* Unlock inodelk */
-        op_ret = dht_unlock_inodelk (frame,
-                                     local->lock[1].ns.parent_layout.locks,
-                                     local->lock[1].ns.parent_layout.lk_count,
-                                     dht_rename_unlock_cbk);
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                if (IA_ISREG (local->stbuf.ia_type))
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s:%s %s:%s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->src_cached->name,
-                                local->loc2.path, dst_gfid,
-                                local->dst_cached ?
-                                local->dst_cached->name : NULL);
-                else
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s %s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->loc2.path, dst_gfid);
-
-                dht_rename_unlock_cbk (frame, NULL, this, 0, 0, NULL);
-        }
+    dht_local_t *local = NULL;
+    int op_ret = -1;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[1].ns.directory_ns);
+
+    /* Unlock inodelk */
+    op_ret = dht_unlock_inodelk(frame, local->lock[1].ns.parent_layout.locks,
+                                local->lock[1].ns.parent_layout.lk_count,
+                                dht_rename_unlock_cbk);
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        if (IA_ISREG(local->stbuf.ia_type))
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s:%s %s:%s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->src_cached->name,
+                   local->loc2.path, dst_gfid,
+                   local->dst_cached ? local->dst_cached->name : NULL);
+        else
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s %s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->loc2.path, dst_gfid);
 
-        return;
+        dht_rename_unlock_cbk(frame, NULL, this, 0, 0, NULL);
+    }
+
+    return;
 }
 
 static int
-dht_rename_dir_unlock (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_unlock(call_frame_t *frame, xlator_t *this)
 {
-
-        dht_rename_dir_unlock_src (frame, this);
-        dht_rename_dir_unlock_dst (frame, this);
-        return 0;
+    dht_rename_dir_unlock_src(frame, this);
+    dht_rename_dir_unlock_dst(frame, this);
+    return 0;
 }
 int
-dht_rename_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
+dht_rename_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
 {
-        dht_conf_t  *conf                    = NULL;
-        dht_local_t *local                   = NULL;
-        int          this_call_cnt           = 0;
-        xlator_t    *prev                    = NULL;
-        int          i                       = 0;
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        int          subvol_cnt              = -1;
-
-        conf = this->private;
-        local = frame->local;
-        prev = cookie;
-        subvol_cnt = dht_subvol_cnt (this, prev);
-        local->ret_cache[subvol_cnt] = op_ret;
-
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_RENAME_FAILED,
-                        "Rename %s -> %s on %s failed, (gfid = %s)",
-                        local->loc.path, local->loc2.path,
-                        prev->name, gfid);
-
-                local->op_ret   = op_ret;
-                local->op_errno = op_errno;
-                goto unwind;
-        }
-        /* TODO: construct proper stbuf for dir */
-        /*
-         * FIXME: is this the correct way to build stbuf and
-         * parent bufs?
-         */
-        dht_iatt_merge (this, &local->stbuf, stbuf);
-        dht_iatt_merge (this, &local->preoldparent, preoldparent);
-        dht_iatt_merge (this, &local->postoldparent, postoldparent);
-        dht_iatt_merge (this, &local->preparent, prenewparent);
-        dht_iatt_merge (this, &local->postparent, postnewparent);
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int subvol_cnt = -1;
+
+    conf = this->private;
+    local = frame->local;
+    prev = cookie;
+    subvol_cnt = dht_subvol_cnt(this, prev);
+    local->ret_cache[subvol_cnt] = op_ret;
+
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+               "Rename %s -> %s on %s failed, (gfid = %s)", local->loc.path,
+               local->loc2.path, prev->name, gfid);
+
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        goto unwind;
+    }
+    /* TODO: construct proper stbuf for dir */
+    /*
+     * FIXME: is this the correct way to build stbuf and
+     * parent bufs?
+     */
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preoldparent, preoldparent);
+    dht_iatt_merge(this, &local->postoldparent, postoldparent);
+    dht_iatt_merge(this, &local->preparent, prenewparent);
+    dht_iatt_merge(this, &local->postparent, postnewparent);
 
 unwind:
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                /* We get here with local->call_cnt == 0. Which means
-                 * we are the only one executing this code, there is
-                 * no contention. Therefore it's safe to manipulate or
-                 * deref local->call_cnt directly (without locking).
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        /* We get here with local->call_cnt == 0. Which means
+         * we are the only one executing this code, there is
+         * no contention. Therefore it's safe to manipulate or
+         * deref local->call_cnt directly (without locking).
+         */
+        if (local->ret_cache[conf->subvolume_cnt] == 0) {
+            /* count errant subvols in last field of ret_cache */
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                if (local->ret_cache[i] != 0)
+                    ++local->ret_cache[conf->subvolume_cnt];
+            }
+            if (local->ret_cache[conf->subvolume_cnt]) {
+                /* undoing the damage:
+                 * for all subvolumes, where rename
+                 * succeeded, we perform the reverse operation
                  */
-                if (local->ret_cache[conf->subvolume_cnt] == 0) {
-                        /* count errant subvols in last field of ret_cache */
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                if (local->ret_cache[i] != 0)
-                                        ++local->ret_cache[conf->subvolume_cnt];
-                        }
-                        if (local->ret_cache[conf->subvolume_cnt]) {
-                                /* undoing the damage:
-                                 * for all subvolumes, where rename
-                                 * succeeded, we perform the reverse operation
-                                 */
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (local->ret_cache[i] == 0)
-                                                ++local->call_cnt;
-                                }
-                                for (i = 0; i < conf->subvolume_cnt; i++) {
-                                        if (local->ret_cache[i])
-                                                continue;
-
-                                        STACK_WIND (frame,
-                                                    dht_rename_dir_cbk,
-                                                    conf->subvolumes[i],
-                                                    conf->subvolumes[i]->fops->rename,
-                                                    &local->loc2, &local->loc,
-                                                    NULL);
-                                }
-
-                                return 0;
-                        }
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (local->ret_cache[i] == 0)
+                        ++local->call_cnt;
                 }
+                for (i = 0; i < conf->subvolume_cnt; i++) {
+                    if (local->ret_cache[i])
+                        continue;
 
-                WIPE (&local->preoldparent);
-                WIPE (&local->postoldparent);
-                WIPE (&local->preparent);
-                WIPE (&local->postparent);
+                    STACK_WIND(frame, dht_rename_dir_cbk, conf->subvolumes[i],
+                               conf->subvolumes[i]->fops->rename, &local->loc2,
+                               &local->loc, NULL);
+                }
 
-                dht_rename_dir_unlock (frame, this);
+                return 0;
+            }
         }
 
-        return 0;
-}
+        WIPE(&local->preoldparent);
+        WIPE(&local->postoldparent);
+        WIPE(&local->preparent);
+        WIPE(&local->postparent);
 
+        dht_rename_dir_unlock(frame, this);
+    }
+
+    return 0;
+}
 
 int
-dht_rename_hashed_dir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                           struct iatt *preoldparent,
-                           struct iatt *postoldparent,
-                           struct iatt *prenewparent,
-                           struct iatt *postnewparent, dict_t *xdata)
+dht_rename_hashed_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                          struct iatt *preoldparent, struct iatt *postoldparent,
+                          struct iatt *prenewparent, struct iatt *postnewparent,
+                          dict_t *xdata)
 {
-        dht_conf_t   *conf = NULL;
-        dht_local_t  *local = NULL;
-        int           call_cnt = 0;
-        xlator_t     *prev = NULL;
-        int           i = 0;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        conf = this->private;
-        local = frame->local;
-        prev = cookie;
-
-
-        if (op_ret == -1) {
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_RENAME_FAILED,
-                        "rename %s -> %s on %s failed, (gfid = %s) ",
-                        local->loc.path, local->loc2.path,
-                        prev->name, gfid);
-
-                local->op_ret   = op_ret;
-                local->op_errno = op_errno;
-                goto unwind;
-        }
-        /* TODO: construct proper stbuf for dir */
-        /*
-         * FIXME: is this the correct way to build stbuf and
-         * parent bufs?
-         */
-        dht_iatt_merge (this, &local->stbuf, stbuf);
-        dht_iatt_merge (this, &local->preoldparent, preoldparent);
-        dht_iatt_merge (this, &local->postoldparent, postoldparent);
-        dht_iatt_merge (this, &local->preparent, prenewparent);
-        dht_iatt_merge (this, &local->postparent, postnewparent);
-
-        call_cnt = local->call_cnt = conf->subvolume_cnt - 1;
-
-        if (!local->call_cnt)
-                goto unwind;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->subvolumes[i] == local->dst_hashed)
-                        continue;
-                STACK_WIND_COOKIE (frame, dht_rename_dir_cbk,
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->rename,
-                                   &local->loc, &local->loc2, NULL);
-                if (!--call_cnt)
-                        break;
-        }
-
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    int call_cnt = 0;
+    xlator_t *prev = NULL;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    conf = this->private;
+    local = frame->local;
+    prev = cookie;
+
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
 
-        return 0;
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+               "rename %s -> %s on %s failed, (gfid = %s) ", local->loc.path,
+               local->loc2.path, prev->name, gfid);
+
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+        goto unwind;
+    }
+    /* TODO: construct proper stbuf for dir */
+    /*
+     * FIXME: is this the correct way to build stbuf and
+     * parent bufs?
+     */
+    dht_iatt_merge(this, &local->stbuf, stbuf);
+    dht_iatt_merge(this, &local->preoldparent, preoldparent);
+    dht_iatt_merge(this, &local->postoldparent, postoldparent);
+    dht_iatt_merge(this, &local->preparent, prenewparent);
+    dht_iatt_merge(this, &local->postparent, postnewparent);
+
+    call_cnt = local->call_cnt = conf->subvolume_cnt - 1;
+
+    if (!local->call_cnt)
+        goto unwind;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->subvolumes[i] == local->dst_hashed)
+            continue;
+        STACK_WIND_COOKIE(
+            frame, dht_rename_dir_cbk, conf->subvolumes[i], conf->subvolumes[i],
+            conf->subvolumes[i]->fops->rename, &local->loc, &local->loc2, NULL);
+        if (!--call_cnt)
+            break;
+    }
+
+    return 0;
 unwind:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_dir_do (call_frame_t *frame, xlator_t *this)
+dht_rename_dir_do(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->op_ret == -1)
-                goto err;
+    if (local->op_ret == -1)
+        goto err;
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-        STACK_WIND_COOKIE (frame, dht_rename_hashed_dir_cbk, local->dst_hashed,
-                           local->dst_hashed,
-                           local->dst_hashed->fops->rename,
-                           &local->loc, &local->loc2, NULL);
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rename_hashed_dir_cbk, local->dst_hashed,
+                      local->dst_hashed, local->dst_hashed->fops->rename,
+                      &local->loc, &local->loc2, NULL);
+    return 0;
 
 err:
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, gf_dirent_t *entries,
-                        dict_t *xdata)
+dht_rename_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, gf_dirent_t *entries,
+                       dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-
-        if (op_ret > 2) {
-                gf_msg_trace (this->name, 0,
-                              "readdir on %s for %s returned %d entries",
-                              prev->name, local->loc.path, op_ret);
-                local->op_ret = -1;
-                local->op_errno = ENOTEMPTY;
-        }
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
 
-        this_call_cnt = dht_frame_return (frame);
+    local = frame->local;
+    prev = cookie;
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_dir_do (frame, this);
-        }
+    if (op_ret > 2) {
+        gf_msg_trace(this->name, 0, "readdir on %s for %s returned %d entries",
+                     prev->name, local->loc.path, op_ret);
+        local->op_ret = -1;
+        local->op_errno = ENOTEMPTY;
+    }
 
-        return 0;
-}
+    this_call_cnt = dht_frame_return(frame);
 
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_dir_do(frame, this);
+    }
+
+    return 0;
+}
 
 int
-dht_rename_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
+dht_rename_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = -1;
-        xlator_t     *prev = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        prev  = cookie;
-
+    dht_local_t *local = NULL;
+    int this_call_cnt = -1;
+    xlator_t *prev = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        if (op_ret == -1) {
+    local = frame->local;
+    prev = cookie;
 
-                gf_uuid_unparse(local->loc.inode->gfid, gfid);
-                gf_msg (this->name, GF_LOG_INFO, op_errno,
-                        DHT_MSG_OPENDIR_FAILED,
-                        "opendir on %s for %s failed,(gfid = %s) ",
-                        prev->name, local->loc.path, gfid);
-                goto err;
-        }
+    if (op_ret == -1) {
+        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+        gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_OPENDIR_FAILED,
+               "opendir on %s for %s failed,(gfid = %s) ", prev->name,
+               local->loc.path, gfid);
+        goto err;
+    }
 
-        fd_bind (fd);
-        STACK_WIND_COOKIE (frame, dht_rename_readdir_cbk, prev, prev,
-                           prev->fops->readdir, local->fd, 4096, 0, NULL);
+    fd_bind(fd);
+    STACK_WIND_COOKIE(frame, dht_rename_readdir_cbk, prev, prev,
+                      prev->fops->readdir, local->fd, 4096, 0, NULL);
 
-        return 0;
+    return 0;
 
 err:
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_dir_do (frame, this);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_dir_do(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_dir_lock2_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+dht_rename_dir_lock2_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        dht_conf_t  *conf                       = NULL;
-        int          i                          = 0;
-
-        local = frame->local;
-        conf = this->private;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed"
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        local->fd = fd_create (local->loc.inode, frame->root->pid);
-        if (!local->fd) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->op_ret = 0;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_conf_t *conf = NULL;
+    int i = 0;
+
+    local = frame->local;
+    conf = this->private;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    local->fd = fd_create(local->loc.inode, frame->root->pid);
+    if (!local->fd) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->op_ret = 0;
+
+    if (!local->dst_cached) {
+        dht_rename_dir_do(frame, this);
+        return 0;
+    }
 
-        if (!local->dst_cached) {
-                dht_rename_dir_do (frame, this);
-                return 0;
-        }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_rename_opendir_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->opendir, &local->loc2,
+                          local->fd, NULL);
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_rename_opendir_cbk,
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->opendir,
-                                   &local->loc2, local->fd, NULL);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        /* No harm in calling an extra unlock */
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    /* No harm in calling an extra unlock */
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
 int
-dht_rename_dir_lock1_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rename_dir_lock1_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        int          ret                        = 0;
-        loc_t       *loc                        = NULL;
-        xlator_t    *subvol                     = NULL;
-
-        local = frame->local;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring entrylk after inodelk failed"
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        if (local->current == &local->lock[0]) {
-                loc = &local->loc2;
-                subvol = local->dst_hashed;
-                local->current = &local->lock[1];
-        } else {
-                loc = &local->loc;
-                subvol = local->src_hashed;
-                local->current = &local->lock[0];
-        }
-        ret = dht_protect_namespace (frame, loc, subvol, &local->current->ns,
-                                     dht_rename_dir_lock2_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+
+    local = frame->local;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring entrylk after inodelk failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    if (local->current == &local->lock[0]) {
+        loc = &local->loc2;
+        subvol = local->dst_hashed;
+        local->current = &local->lock[1];
+    } else {
+        loc = &local->loc;
+        subvol = local->src_hashed;
+        local->current = &local->lock[0];
+    }
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_dir_lock2_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 err:
-        /* No harm in calling an extra unlock */
-        dht_rename_dir_unlock (frame, this);
-        return 0;
+    /* No harm in calling an extra unlock */
+    dht_rename_dir_unlock(frame, this);
+    return 0;
 }
 
-
 /*
  * If the hashed subvolumes of both source and dst are the different,
  * lock in dictionary order of hashed subvol->name. This is important
@@ -506,1566 +473,1471 @@ err:
  *
  */
 static void
-dht_order_rename_lock (call_frame_t *frame, loc_t **loc, xlator_t **subvol)
+dht_order_rename_lock(call_frame_t *frame, loc_t **loc, xlator_t **subvol)
 {
-        int ret                 = 0;
-        dht_local_t   *local    = NULL;
-        char           src[GF_UUID_BNAME_BUF_SIZE] = {0};
-        char           dst[GF_UUID_BNAME_BUF_SIZE] = {0};
-
-
-        local = frame->local;
-
-        if (local->src_hashed->name == local->dst_hashed->name) {
-                ret = 0;
-        } else {
-                ret = strcmp (local->src_hashed->name, local->dst_hashed->name);
-        }
-
-        if (ret == 0) {
-
-                /* hashed subvols are the same for src and dst */
-                /* Entrylks need to be ordered*/
-                if (local->loc.pargfid)
-                        uuid_utoa_r (local->loc.pargfid, src);
-                else if (local->loc.parent)
-                        uuid_utoa_r (local->loc.parent->gfid, src);
-
-                strcat (src, local->loc.name);
-
-                if (local->loc2.pargfid)
-                        uuid_utoa_r (local->loc2.pargfid, dst);
-                else if (local->loc2.parent)
-                        uuid_utoa_r (local->loc2.parent->gfid, dst);
-
-                strcat (dst, local->loc2.name);
-                ret = strcmp (src, dst);
-        }
-
-        if (ret <= 0) {
-                /*inodelk in dictionary order of hashed subvol names*/
-                /*entrylk in dictionary order of gfid/basename */
-                local->current = &local->lock[0];
-                *loc = &local->loc;
-                *subvol = local->src_hashed;
-
-        } else {
-                local->current = &local->lock[1];
-                *loc = &local->loc2;
-                *subvol = local->dst_hashed;
-        }
-
-        return;
+    int ret = 0;
+    dht_local_t *local = NULL;
+    char src[GF_UUID_BNAME_BUF_SIZE] = {0};
+    char dst[GF_UUID_BNAME_BUF_SIZE] = {0};
+
+    local = frame->local;
+
+    if (local->src_hashed->name == local->dst_hashed->name) {
+        ret = 0;
+    } else {
+        ret = strcmp(local->src_hashed->name, local->dst_hashed->name);
+    }
+
+    if (ret == 0) {
+        /* hashed subvols are the same for src and dst */
+        /* Entrylks need to be ordered*/
+        if (local->loc.pargfid)
+            uuid_utoa_r(local->loc.pargfid, src);
+        else if (local->loc.parent)
+            uuid_utoa_r(local->loc.parent->gfid, src);
+
+        strcat(src, local->loc.name);
+
+        if (local->loc2.pargfid)
+            uuid_utoa_r(local->loc2.pargfid, dst);
+        else if (local->loc2.parent)
+            uuid_utoa_r(local->loc2.parent->gfid, dst);
+
+        strcat(dst, local->loc2.name);
+        ret = strcmp(src, dst);
+    }
+
+    if (ret <= 0) {
+        /*inodelk in dictionary order of hashed subvol names*/
+        /*entrylk in dictionary order of gfid/basename */
+        local->current = &local->lock[0];
+        *loc = &local->loc;
+        *subvol = local->src_hashed;
+
+    } else {
+        local->current = &local->lock[1];
+        *loc = &local->loc2;
+        *subvol = local->dst_hashed;
+    }
+
+    return;
 }
 
 int
-dht_rename_dir (call_frame_t *frame, xlator_t *this)
+dht_rename_dir(call_frame_t *frame, xlator_t *this)
 {
-        dht_conf_t    *conf         = NULL;
-        dht_local_t   *local        = NULL;
-        loc_t         *loc          = NULL;
-        xlator_t      *subvol       = NULL;
-        int            i            = 0;
-        int            ret          = 0;
-        int            op_errno     = -1;
-
-        conf = frame->this->private;
-        local = frame->local;
-
-        local->ret_cache = GF_CALLOC (conf->subvolume_cnt + 1, sizeof (int),
-                                      gf_dht_ret_cache_t);
-
-        if (local->ret_cache == NULL) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->call_cnt = conf->subvolume_cnt;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->subvolume_status[i]) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_RENAME_FAILED,
-                                "Rename dir failed: subvolume down (%s)",
-                                conf->subvolumes[i]->name);
-                        op_errno = ENOTCONN;
-                        goto err;
-                }
-        }
-
-
-        /* Locks on src and dst needs to ordered which otherwise might cause
-         * deadlocks when rename (src, dst) and rename (dst, src) is done from
-         * two different clients
-         */
-        dht_order_rename_lock (frame, &loc, &subvol);
-
-        /* Rename must take locks on src to avoid lookup selfheal from
-         * recreating src on those subvols where the rename was successful.
-         * The locks can't be issued parallel as two different clients might
-         * attempt same rename command and be in dead lock.
-         */
-        ret = dht_protect_namespace (frame, loc, subvol,
-                                     &local->current->ns,
-                                     dht_rename_dir_lock1_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        return 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+    int i = 0;
+    int ret = 0;
+    int op_errno = -1;
+
+    conf = frame->this->private;
+    local = frame->local;
+
+    local->ret_cache = GF_CALLOC(conf->subvolume_cnt + 1, sizeof(int),
+                                 gf_dht_ret_cache_t);
+
+    if (local->ret_cache == NULL) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->call_cnt = conf->subvolume_cnt;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+                   "Rename dir failed: subvolume down (%s)",
+                   conf->subvolumes[i]->name);
+            op_errno = ENOTCONN;
+            goto err;
+        }
+    }
+
+    /* Locks on src and dst needs to ordered which otherwise might cause
+     * deadlocks when rename (src, dst) and rename (dst, src) is done from
+     * two different clients
+     */
+    dht_order_rename_lock(frame, &loc, &subvol);
+
+    /* Rename must take locks on src to avoid lookup selfheal from
+     * recreating src on those subvols where the rename was successful.
+     * The locks can't be issued parallel as two different clients might
+     * attempt same rename command and be in dead lock.
+     */
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_dir_lock1_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                          NULL, NULL);
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 static int
-dht_rename_track_for_changelog (xlator_t *this, dict_t *xattr,
-                                loc_t *oldloc, loc_t *newloc)
+dht_rename_track_for_changelog(xlator_t *this, dict_t *xattr, loc_t *oldloc,
+                               loc_t *newloc)
 {
-        int ret        = -1;
-        dht_changelog_rename_info_t *info = NULL;
-        char *name     = NULL;
-        int len1       = 0;
-        int len2       = 0;
-        int size       = 0;
-
-        if (!xattr || !oldloc || !newloc || !this)
-                return ret;
-
-        len1 = strlen (oldloc->name) + 1;
-        len2 = strlen (newloc->name) + 1;
-        size = sizeof (dht_changelog_rename_info_t) + len1 + len2;
-
-        info = GF_CALLOC (size, sizeof(char), gf_common_mt_char);
-        if (!info) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to calloc memory");
-                return ret;
-        }
+    int ret = -1;
+    dht_changelog_rename_info_t *info = NULL;
+    char *name = NULL;
+    int len1 = 0;
+    int len2 = 0;
+    int size = 0;
+
+    if (!xattr || !oldloc || !newloc || !this)
+        return ret;
 
-        gf_uuid_copy (info->old_pargfid, oldloc->pargfid);
-        gf_uuid_copy (info->new_pargfid, newloc->pargfid);
-
-        info->oldname_len = len1;
-        info->newname_len = len2;
-        strncpy (info->buffer, oldloc->name, len1);
-        name = info->buffer + len1;
-        strncpy (name, newloc->name, len2);
-
-        ret = dict_set_bin (xattr, DHT_CHANGELOG_RENAME_OP_KEY,
-                            info, size);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value: key = %s,"
-                        " path = %s", DHT_CHANGELOG_RENAME_OP_KEY,
-                        oldloc->name);
-                GF_FREE (info);
-        }
+    len1 = strlen(oldloc->name) + 1;
+    len2 = strlen(newloc->name) + 1;
+    size = sizeof(dht_changelog_rename_info_t) + len1 + len2;
 
+    info = GF_CALLOC(size, sizeof(char), gf_common_mt_char);
+    if (!info) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to calloc memory");
         return ret;
+    }
+
+    gf_uuid_copy(info->old_pargfid, oldloc->pargfid);
+    gf_uuid_copy(info->new_pargfid, newloc->pargfid);
+
+    info->oldname_len = len1;
+    info->newname_len = len2;
+    strncpy(info->buffer, oldloc->name, len1);
+    name = info->buffer + len1;
+    strncpy(name, newloc->name, len2);
+
+    ret = dict_set_bin(xattr, DHT_CHANGELOG_RENAME_OP_KEY, info, size);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value: key = %s,"
+               " path = %s",
+               DHT_CHANGELOG_RENAME_OP_KEY, oldloc->name);
+        GF_FREE(info);
+    }
+
+    return ret;
 }
 
-
-
-#define DHT_MARKER_DONT_ACCOUNT(xattr) do {                             \
-                int tmp = -1;                                                  \
-                if (!xattr) {                                                  \
-                        xattr = dict_new ();                                   \
-                        if (!xattr)                                            \
-                                break;                                         \
-                }                                                              \
-                tmp = dict_set_str (xattr, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY,  \
-                                    "yes");                                    \
-                if (tmp) {                                                     \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,                    \
-                                DHT_MSG_DICT_SET_FAILED,                       \
-                                "Failed to set dictionary value: key = %s,"    \
-                                " path = %s",GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, \
-                                local->loc.path);                             \
-                }                                                              \
-        }while (0)
-
-
-#define DHT_CHANGELOG_TRACK_AS_RENAME(xattr, oldloc, newloc) do {            \
-                int tmp = -1;                                                \
-                if (!xattr) {                                                \
-                        xattr = dict_new ();                                 \
-                        if (!xattr) {                                        \
-                                gf_msg (this->name, GF_LOG_ERROR, 0,         \
-                                        DHT_MSG_DICT_SET_FAILED,             \
-                                        "Failed to create dictionary to "    \
-                                        "track rename");                     \
-                                break;                                       \
-                        }                                                    \
-                }                                                            \
-                                                                             \
-                tmp = dht_rename_track_for_changelog (this, xattr,           \
-                                oldloc, newloc);                             \
-                                                                             \
-                if (tmp) {                                                   \
-                        gf_msg (this->name, GF_LOG_ERROR, 0,                 \
-                                DHT_MSG_DICT_SET_FAILED,                     \
-                                "Failed to set dictionary value: key = %s,"  \
-                                " path = %s", DHT_CHANGELOG_RENAME_OP_KEY,   \
-                                (oldloc)->path);                             \
-                }                                                            \
-        } while (0)
-
+#define DHT_MARKER_DONT_ACCOUNT(xattr)                                         \
+    do {                                                                       \
+        int tmp = -1;                                                          \
+        if (!xattr) {                                                          \
+            xattr = dict_new();                                                \
+            if (!xattr)                                                        \
+                break;                                                         \
+        }                                                                      \
+        tmp = dict_set_str(xattr, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, "yes");   \
+        if (tmp) {                                                             \
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,       \
+                   "Failed to set dictionary value: key = %s,"                 \
+                   " path = %s",                                               \
+                   GLUSTERFS_MARKER_DONT_ACCOUNT_KEY, local->loc.path);        \
+        }                                                                      \
+    } while (0)
+
+#define DHT_CHANGELOG_TRACK_AS_RENAME(xattr, oldloc, newloc)                   \
+    do {                                                                       \
+        int tmp = -1;                                                          \
+        if (!xattr) {                                                          \
+            xattr = dict_new();                                                \
+            if (!xattr) {                                                      \
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,   \
+                       "Failed to create dictionary to "                       \
+                       "track rename");                                        \
+                break;                                                         \
+            }                                                                  \
+        }                                                                      \
+                                                                               \
+        tmp = dht_rename_track_for_changelog(this, xattr, oldloc, newloc);     \
+                                                                               \
+        if (tmp) {                                                             \
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,       \
+                   "Failed to set dictionary value: key = %s,"                 \
+                   " path = %s",                                               \
+                   DHT_CHANGELOG_RENAME_OP_KEY, (oldloc)->path);               \
+        }                                                                      \
+    } while (0)
 
 int
-dht_rename_unlock (call_frame_t *frame, xlator_t *this)
+dht_rename_unlock(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
-        int          op_ret                     = -1;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        dht_ilock_wrap_t inodelk_wrapper        = {0, };
-
-        local = frame->local;
-        inodelk_wrapper.locks = local->rename_inodelk_backward_compatible;
-        inodelk_wrapper.lk_count = local->rename_inodelk_bc_count;
-
-        op_ret = dht_unlock_inodelk_wrapper (frame, &inodelk_wrapper);
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                if (IA_ISREG (local->stbuf.ia_type))
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s:%s %s:%s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->src_cached->name,
-                                local->loc2.path, dst_gfid,
-                                local->dst_cached ?
-                                local->dst_cached->name : NULL);
-                else
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_UNLOCKING_FAILED,
-                                "winding unlock inodelk failed "
-                                "rename (%s:%s %s:%s), "
-                                "stale locks left on bricks",
-                                local->loc.path, src_gfid,
-                                local->loc2.path, dst_gfid);
-        }
-
-        dht_unlock_namespace (frame, &local->lock[0]);
-        dht_unlock_namespace (frame, &local->lock[1]);
-
-        dht_rename_unlock_cbk (frame, NULL, this, local->op_ret,
-                               local->op_errno, NULL);
-        return 0;
+    dht_local_t *local = NULL;
+    int op_ret = -1;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dht_ilock_wrap_t inodelk_wrapper = {
+        0,
+    };
+
+    local = frame->local;
+    inodelk_wrapper.locks = local->rename_inodelk_backward_compatible;
+    inodelk_wrapper.lk_count = local->rename_inodelk_bc_count;
+
+    op_ret = dht_unlock_inodelk_wrapper(frame, &inodelk_wrapper);
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        if (IA_ISREG(local->stbuf.ia_type))
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s:%s %s:%s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->src_cached->name,
+                   local->loc2.path, dst_gfid,
+                   local->dst_cached ? local->dst_cached->name : NULL);
+        else
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_UNLOCKING_FAILED,
+                   "winding unlock inodelk failed "
+                   "rename (%s:%s %s:%s), "
+                   "stale locks left on bricks",
+                   local->loc.path, src_gfid, local->loc2.path, dst_gfid);
+    }
+
+    dht_unlock_namespace(frame, &local->lock[0]);
+    dht_unlock_namespace(frame, &local->lock[1]);
+
+    dht_rename_unlock_cbk(frame, NULL, this, local->op_ret, local->op_errno,
+                          NULL);
+    return 0;
 }
 
 int
-dht_rename_done (call_frame_t *frame, xlator_t *this)
+dht_rename_done(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t *local                      = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (local->linked == _gf_true) {
-                local->linked = _gf_false;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    if (local->linked == _gf_true) {
+        local->linked = _gf_false;
+        dht_linkfile_attr_heal(frame, this);
+    }
 
-        dht_rename_unlock (frame, this);
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
 int
-dht_rename_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
+dht_rename_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        int           this_call_cnt = 0;
-
-        local = frame->local;
-        prev  = cookie;
-
-        FRAME_SU_UNDO (frame, dht_local_t);
-        if (!local) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_INVALID_VALUE,
-                        "!local, should not happen");
-                goto out;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    int this_call_cnt = 0;
 
-        this_call_cnt = dht_frame_return (frame);
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_UNLINK_FAILED,
-                        "%s: Rename: unlink on %s failed ",
-                        local->loc.path, prev->name);
-        }
+    FRAME_SU_UNDO(frame, dht_local_t);
+    if (!local) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_VALUE,
+               "!local, should not happen");
+        goto out;
+    }
 
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_rename_done (frame, this);
-        }
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_UNLINK_FAILED,
+               "%s: Rename: unlink on %s failed ", local->loc.path, prev->name);
+    }
+
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
+
+    if (is_last_call(this_call_cnt)) {
+        dht_rename_done(frame, this);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
 int
-dht_rename_cleanup (call_frame_t *frame)
+dht_rename_cleanup(call_frame_t *frame)
 {
-        dht_local_t *local                  = NULL;
-        xlator_t    *this                   = NULL;
-        xlator_t    *src_hashed             = NULL;
-        xlator_t    *src_cached             = NULL;
-        xlator_t    *dst_hashed             = NULL;
-        xlator_t    *dst_cached             = NULL;
-        int          call_cnt               = 0;
-        dict_t      *xattr                  = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        this  = frame->this;
-
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-
-        if (src_cached == dst_cached)
-                goto nolinks;
-
-        if (local->linked && (dst_hashed != src_hashed) &&
-            (dst_hashed != src_cached)) {
-                call_cnt++;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    int call_cnt = 0;
+    dict_t *xattr = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-        if (local->added_link && (src_cached != dst_hashed)) {
-                call_cnt++;
-        }
+    local = frame->local;
+    this = frame->this;
 
-        local->call_cnt = call_cnt;
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-        if (!call_cnt)
-                goto nolinks;
+    if (src_cached == dst_cached)
+        goto nolinks;
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    if (local->linked && (dst_hashed != src_hashed) &&
+        (dst_hashed != src_cached)) {
+        call_cnt++;
+    }
 
-        gf_uuid_unparse(local->loc.inode->gfid, gfid);
+    if (local->added_link && (src_cached != dst_hashed)) {
+        call_cnt++;
+    }
 
-        if (local->linked && (dst_hashed != src_hashed) &&
-                        (dst_hashed != src_cached)) {
-                dict_t *xattr_new = NULL;
+    local->call_cnt = call_cnt;
 
-                gf_msg_trace (this->name, 0,
-                              "unlinking linkfile %s @ %s => %s, (gfid = %s)",
-                              local->loc.path, dst_hashed->name,
-                              src_cached->name, gfid);
+    if (!call_cnt)
+        goto nolinks;
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+    DHT_MARK_FOP_INTERNAL(xattr);
 
+    gf_uuid_unparse(local->loc.inode->gfid, gfid);
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+    if (local->linked && (dst_hashed != src_hashed) &&
+        (dst_hashed != src_cached)) {
+        dict_t *xattr_new = NULL;
 
-                FRAME_SU_DO (frame, dht_local_t);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, dst_hashed,
-                                   dst_hashed, dst_hashed->fops->unlink,
-                                   &local->loc, 0, xattr_new);
+        gf_msg_trace(this->name, 0,
+                     "unlinking linkfile %s @ %s => %s, (gfid = %s)",
+                     local->loc.path, dst_hashed->name, src_cached->name, gfid);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
-        }
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-        if (local->added_link && (src_cached != dst_hashed)) {
-                dict_t *xattr_new = NULL;
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-                gf_msg_trace (this->name, 0,
-                              "unlinking link %s => %s (%s), (gfid = %s)",
-                              local->loc.path, local->loc2.path,
-                              src_cached->name, gfid);
+        FRAME_SU_DO(frame, dht_local_t);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, dst_hashed, dst_hashed,
+                          dst_hashed->fops->unlink, &local->loc, 0, xattr_new);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-                if (gf_uuid_compare (local->loc.pargfid,
-                                  local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
-                /* *
-                 * The link to file is created using root permission.
-                 * Hence deletion should happen using root. Otherwise
-                 * it will fail.
-                 */
-                FRAME_SU_DO (frame, dht_local_t);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_cached,
-                                   src_cached, src_cached->fops->unlink,
-                                   &local->loc2, 0, xattr_new);
+    if (local->added_link && (src_cached != dst_hashed)) {
+        dict_t *xattr_new = NULL;
+
+        gf_msg_trace(this->name, 0, "unlinking link %s => %s (%s), (gfid = %s)",
+                     local->loc.path, local->loc2.path, src_cached->name, gfid);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
+        xattr_new = dict_copy_with_ref(xattr, NULL);
+
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
         }
+        /* *
+         * The link to file is created using root permission.
+         * Hence deletion should happen using root. Otherwise
+         * it will fail.
+         */
+        FRAME_SU_DO(frame, dht_local_t);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_cached, src_cached,
+                          src_cached->fops->unlink, &local->loc2, 0, xattr_new);
 
-        if (xattr)
-                dict_unref (xattr);
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-        return 0;
+    if (xattr)
+        dict_unref(xattr);
+
+    return 0;
 
 nolinks:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-        dht_rename_unlock (frame, this);
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
-
 int
-dht_rename_unlink (call_frame_t *frame, xlator_t *this)
+dht_rename_unlink(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *src_hashed = NULL;
-        xlator_t     *src_cached = NULL;
-        xlator_t     *dst_hashed = NULL;
-        xlator_t     *dst_cached = NULL;
-        xlator_t     *rename_subvol = NULL;
-        dict_t       *xattr     = NULL;
-
-        local = frame->local;
-
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-
-        local->call_cnt = 0;
-
-        /* NOTE: rename_subvol is the same subvolume from which dht_rename_cbk
-         * is called. since rename has already happened on rename_subvol,
-         * unlink shouldn't be sent for oldpath (either linkfile or cached-file)
-         * on rename_subvol. */
-        if (src_cached == dst_cached)
-                rename_subvol = src_cached;
-        else
-                rename_subvol = dst_hashed;
+    dht_local_t *local = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *rename_subvol = NULL;
+    dict_t *xattr = NULL;
 
-        /* TODO: delete files in background */
+    local = frame->local;
 
-        if (src_cached != dst_hashed && src_cached != dst_cached)
-                local->call_cnt++;
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-        if (src_hashed != rename_subvol && src_hashed != src_cached)
-                local->call_cnt++;
+    local->call_cnt = 0;
 
-        if (dst_cached && dst_cached != dst_hashed && dst_cached != src_cached)
-                local->call_cnt++;
+    /* NOTE: rename_subvol is the same subvolume from which dht_rename_cbk
+     * is called. since rename has already happened on rename_subvol,
+     * unlink shouldn't be sent for oldpath (either linkfile or cached-file)
+     * on rename_subvol. */
+    if (src_cached == dst_cached)
+        rename_subvol = src_cached;
+    else
+        rename_subvol = dst_hashed;
 
-        if (local->call_cnt == 0)
-                goto unwind;
+    /* TODO: delete files in background */
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    if (src_cached != dst_hashed && src_cached != dst_cached)
+        local->call_cnt++;
 
-        if (src_cached != dst_hashed && src_cached != dst_cached) {
-                dict_t *xattr_new = NULL;
+    if (src_hashed != rename_subvol && src_hashed != src_cached)
+        local->call_cnt++;
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+    if (dst_cached && dst_cached != dst_hashed && dst_cached != src_cached)
+        local->call_cnt++;
 
-                gf_msg_trace (this->name, 0,
-                              "deleting old src datafile %s @ %s",
-                              local->loc.path, src_cached->name);
+    if (local->call_cnt == 0)
+        goto unwind;
 
-                if (gf_uuid_compare (local->loc.pargfid,
-                                     local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
+    DHT_MARK_FOP_INTERNAL(xattr);
+
+    if (src_cached != dst_hashed && src_cached != dst_cached) {
+        dict_t *xattr_new = NULL;
 
-                DHT_CHANGELOG_TRACK_AS_RENAME(xattr_new, &local->loc,
-                                              &local->loc2);
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_cached,
-                                   src_cached, src_cached->fops->unlink,
-                                   &local->loc, 0, xattr_new);
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
+        gf_msg_trace(this->name, 0, "deleting old src datafile %s @ %s",
+                     local->loc.path, src_cached->name);
+
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
         }
 
-        if (src_hashed != rename_subvol && src_hashed != src_cached) {
-                dict_t *xattr_new = NULL;
+        DHT_CHANGELOG_TRACK_AS_RENAME(xattr_new, &local->loc, &local->loc2);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_cached, src_cached,
+                          src_cached->fops->unlink, &local->loc, 0, xattr_new);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
 
-                gf_msg_trace (this->name, 0,
-                              "deleting old src linkfile %s @ %s",
-                              local->loc.path, src_hashed->name);
+    if (src_hashed != rename_subvol && src_hashed != src_cached) {
+        dict_t *xattr_new = NULL;
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, src_hashed,
-                                   src_hashed, src_hashed->fops->unlink,
-                                   &local->loc, 0, xattr_new);
+        gf_msg_trace(this->name, 0, "deleting old src linkfile %s @ %s",
+                     local->loc.path, src_hashed->name);
 
-                dict_unref (xattr_new);
-                xattr_new = NULL;
-        }
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-        if (dst_cached &&
-            (dst_cached != dst_hashed) &&
-            (dst_cached != src_cached)) {
-                gf_msg_trace (this->name, 0,
-                              "deleting old dst datafile %s @ %s",
-                              local->loc2.path, dst_cached->name);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, src_hashed, src_hashed,
+                          src_hashed->fops->unlink, &local->loc, 0, xattr_new);
 
-                STACK_WIND_COOKIE (frame, dht_rename_unlink_cbk, dst_cached,
-                                   dst_cached, dst_cached->fops->unlink,
-                                   &local->loc2, 0, xattr);
-        }
-        if (xattr)
-                dict_unref (xattr);
-        return 0;
+        dict_unref(xattr_new);
+        xattr_new = NULL;
+    }
+
+    if (dst_cached && (dst_cached != dst_hashed) &&
+        (dst_cached != src_cached)) {
+        gf_msg_trace(this->name, 0, "deleting old dst datafile %s @ %s",
+                     local->loc2.path, dst_cached->name);
+
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_cbk, dst_cached, dst_cached,
+                          dst_cached->fops->unlink, &local->loc2, 0, xattr);
+    }
+    if (xattr)
+        dict_unref(xattr);
+    return 0;
 
 unwind:
-        WIPE (&local->preoldparent);
-        WIPE (&local->postoldparent);
-        WIPE (&local->preparent);
-        WIPE (&local->postparent);
+    WIPE(&local->preoldparent);
+    WIPE(&local->postoldparent);
+    WIPE(&local->preparent);
+    WIPE(&local->postparent);
 
-        dht_rename_done (frame, this);
+    dht_rename_done(frame, this);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_links_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             inode_t *inode, struct iatt *stbuf,
-                             struct iatt *preparent, struct iatt *postparent,
-                             dict_t *xdata)
+dht_rename_links_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, inode_t *inode,
+                            struct iatt *stbuf, struct iatt *preparent,
+                            struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t *prev = NULL;
-        dht_local_t  *local = NULL;
-
-        prev = cookie;
-        local = frame->local;
-
-        /* TODO: Handle this case in lookup-optimize */
-        if (op_ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_CREATE_LINK_FAILED,
-                        "link/file %s on %s failed",
-                        local->loc.path, prev->name);
-        }
+    xlator_t *prev = NULL;
+    dht_local_t *local = NULL;
 
-        if (local->linked == _gf_true) {
-                local->linked = _gf_false;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    prev = cookie;
+    local = frame->local;
 
-        dht_rename_unlink (frame, this);
-        return 0;
-}
+    /* TODO: Handle this case in lookup-optimize */
+    if (op_ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_CREATE_LINK_FAILED,
+               "link/file %s on %s failed", local->loc.path, prev->name);
+    }
+
+    if (local->linked == _gf_true) {
+        local->linked = _gf_false;
+        dht_linkfile_attr_heal(frame, this);
+    }
 
+    dht_rename_unlink(frame, this);
+    return 0;
+}
 
 int
-dht_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
-                struct iatt *preoldparent, struct iatt *postoldparent,
-                struct iatt *prenewparent, struct iatt *postnewparent,
-                dict_t *xdata)
+dht_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+               struct iatt *preoldparent, struct iatt *postoldparent,
+               struct iatt *prenewparent, struct iatt *postnewparent,
+               dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *src_cached = NULL;
-        xlator_t     *dst_hashed = NULL;
-        xlator_t     *dst_cached = NULL;
-        loc_t         link_loc  = {0};
-
-        local = frame->local;
-        prev = cookie;
-
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-
-        if (local->linked == _gf_true)
-                FRAME_SU_UNDO (frame, dht_local_t);
-
-        /* It is a critical failure iff we fail to rename the cached file
-         * if the rename of the linkto failed, it is not a critical failure,
-         * and we do not want to lose the created hard link for the new
-         * name as that could have been read by other clients.
-         *
-         * NOTE: If another client is attempting the same oldname -> newname
-         * rename, and finds both file names as existing, and are hard links
-         * to each other, then FUSE would send in an unlink for oldname. In
-         * this time duration if we treat the linkto as a critical error and
-         * unlink the newname we created, we would have effectively lost the
-         * file to rename operations.
-         *
-         * Repercussions of treating this as a non-critical error is that
-         * we could leave behind a stale linkto file and/or not create the new
-         * linkto file, the second case would be rectified by a subsequent
-         * lookup, the first case by a rebalance, like for all stale linkto
-         * files */
-
-        if (op_ret == -1) {
-                /* Critical failure: unable to rename the cached file */
-                if (prev == src_cached) {
-                        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                                DHT_MSG_RENAME_FAILED,
-                                "%s: Rename on %s failed, (gfid = %s) ",
-                                local->loc.path, prev->name,
-                                local->loc.inode ?
-                                uuid_utoa(local->loc.inode->gfid):"");
-                        local->op_ret   = op_ret;
-                        local->op_errno = op_errno;
-                        goto cleanup;
-                } else {
-                        /* Non-critical failure, unable to rename the linkto
-                         * file
-                         */
-                        gf_msg (this->name, GF_LOG_INFO, op_errno,
-                                DHT_MSG_RENAME_FAILED,
-                                "%s: Rename (linkto file) on %s failed, "
-                                "(gfid = %s) ",
-                                local->loc.path, prev->name,
-                                local->loc.inode ?
-                                uuid_utoa(local->loc.inode->gfid):"");
-                }
-        }
-        if (xdata) {
-                if (!local->xattr)
-                        local->xattr = dict_ref (xdata);
-                else
-                        local->xattr = dict_copy_with_ref (xdata, local->xattr);
-        }
-
-        /* Merge attrs only from src_cached. In case there of src_cached !=
-         * dst_hashed, this ignores linkfile attrs. */
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    loc_t link_loc = {0};
+
+    local = frame->local;
+    prev = cookie;
+
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
+
+    if (local->linked == _gf_true)
+        FRAME_SU_UNDO(frame, dht_local_t);
+
+    /* It is a critical failure iff we fail to rename the cached file
+     * if the rename of the linkto failed, it is not a critical failure,
+     * and we do not want to lose the created hard link for the new
+     * name as that could have been read by other clients.
+     *
+     * NOTE: If another client is attempting the same oldname -> newname
+     * rename, and finds both file names as existing, and are hard links
+     * to each other, then FUSE would send in an unlink for oldname. In
+     * this time duration if we treat the linkto as a critical error and
+     * unlink the newname we created, we would have effectively lost the
+     * file to rename operations.
+     *
+     * Repercussions of treating this as a non-critical error is that
+     * we could leave behind a stale linkto file and/or not create the new
+     * linkto file, the second case would be rectified by a subsequent
+     * lookup, the first case by a rebalance, like for all stale linkto
+     * files */
+
+    if (op_ret == -1) {
+        /* Critical failure: unable to rename the cached file */
         if (prev == src_cached) {
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-                dht_iatt_merge (this, &local->preoldparent, preoldparent);
-                dht_iatt_merge (this, &local->postoldparent, postoldparent);
-                dht_iatt_merge (this, &local->preparent, prenewparent);
-                dht_iatt_merge (this, &local->postparent, postnewparent);
-        }
-
-        /* Create the linkto file for the dst file */
-        if ((src_cached == dst_cached) && (dst_hashed != dst_cached)) {
-
-                loc_copy (&link_loc, &local->loc2);
-                if (link_loc.inode)
-                        inode_unref (link_loc.inode);
-                link_loc.inode = inode_ref (local->loc.inode);
-                gf_uuid_copy (local->gfid, local->loc.inode->gfid);
-                gf_uuid_copy (link_loc.gfid, local->loc.inode->gfid);
-
-                dht_linkfile_create (frame, dht_rename_links_create_cbk,
-                                     this, src_cached, dst_hashed,
-                                     &link_loc);
-                return 0;
-        }
-
-        dht_rename_unlink (frame, this);
+            gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_RENAME_FAILED,
+                   "%s: Rename on %s failed, (gfid = %s) ", local->loc.path,
+                   prev->name,
+                   local->loc.inode ? uuid_utoa(local->loc.inode->gfid) : "");
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
+            goto cleanup;
+        } else {
+            /* Non-critical failure, unable to rename the linkto
+             * file
+             */
+            gf_msg(this->name, GF_LOG_INFO, op_errno, DHT_MSG_RENAME_FAILED,
+                   "%s: Rename (linkto file) on %s failed, "
+                   "(gfid = %s) ",
+                   local->loc.path, prev->name,
+                   local->loc.inode ? uuid_utoa(local->loc.inode->gfid) : "");
+        }
+    }
+    if (xdata) {
+        if (!local->xattr)
+            local->xattr = dict_ref(xdata);
+        else
+            local->xattr = dict_copy_with_ref(xdata, local->xattr);
+    }
+
+    /* Merge attrs only from src_cached. In case there of src_cached !=
+     * dst_hashed, this ignores linkfile attrs. */
+    if (prev == src_cached) {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+        dht_iatt_merge(this, &local->preoldparent, preoldparent);
+        dht_iatt_merge(this, &local->postoldparent, postoldparent);
+        dht_iatt_merge(this, &local->preparent, prenewparent);
+        dht_iatt_merge(this, &local->postparent, postnewparent);
+    }
+
+    /* Create the linkto file for the dst file */
+    if ((src_cached == dst_cached) && (dst_hashed != dst_cached)) {
+        loc_copy(&link_loc, &local->loc2);
+        if (link_loc.inode)
+            inode_unref(link_loc.inode);
+        link_loc.inode = inode_ref(local->loc.inode);
+        gf_uuid_copy(local->gfid, local->loc.inode->gfid);
+        gf_uuid_copy(link_loc.gfid, local->loc.inode->gfid);
+
+        dht_linkfile_create(frame, dht_rename_links_create_cbk, this,
+                            src_cached, dst_hashed, &link_loc);
         return 0;
+    }
+
+    dht_rename_unlink(frame, this);
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_do_rename (call_frame_t *frame)
+dht_do_rename(call_frame_t *frame)
 {
-        dht_local_t *local         = NULL;
-        xlator_t    *dst_hashed    = NULL;
-        xlator_t    *src_cached    = NULL;
-        xlator_t    *dst_cached    = NULL;
-        xlator_t    *this          = NULL;
-        xlator_t    *rename_subvol = NULL;
-
-        local = frame->local;
-        this  = frame->this;
-
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
-        src_cached = local->src_cached;
-
-        if (src_cached == dst_cached)
-                rename_subvol = src_cached;
-        else
-                rename_subvol = dst_hashed;
-
-        if ((src_cached != dst_hashed) && (rename_subvol == dst_hashed)) {
-                DHT_MARKER_DONT_ACCOUNT(local->xattr_req);
-        }
-
-        if (rename_subvol == src_cached) {
-                DHT_CHANGELOG_TRACK_AS_RENAME(local->xattr_req, &local->loc,
-                                              &local->loc2);
-        }
-
-        gf_msg_trace (this->name, 0,
-                      "renaming %s => %s (%s)",
-                      local->loc.path, local->loc2.path, rename_subvol->name);
-
-        if (local->linked == _gf_true)
-                FRAME_SU_DO (frame, dht_local_t);
-        STACK_WIND_COOKIE (frame, dht_rename_cbk, rename_subvol, rename_subvol,
-                           rename_subvol->fops->rename, &local->loc,
-                           &local->loc2, local->xattr_req);
-        return 0;
+    dht_local_t *local = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *this = NULL;
+    xlator_t *rename_subvol = NULL;
+
+    local = frame->local;
+    this = frame->this;
+
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
+    src_cached = local->src_cached;
+
+    if (src_cached == dst_cached)
+        rename_subvol = src_cached;
+    else
+        rename_subvol = dst_hashed;
+
+    if ((src_cached != dst_hashed) && (rename_subvol == dst_hashed)) {
+        DHT_MARKER_DONT_ACCOUNT(local->xattr_req);
+    }
+
+    if (rename_subvol == src_cached) {
+        DHT_CHANGELOG_TRACK_AS_RENAME(local->xattr_req, &local->loc,
+                                      &local->loc2);
+    }
+
+    gf_msg_trace(this->name, 0, "renaming %s => %s (%s)", local->loc.path,
+                 local->loc2.path, rename_subvol->name);
+
+    if (local->linked == _gf_true)
+        FRAME_SU_DO(frame, dht_local_t);
+    STACK_WIND_COOKIE(frame, dht_rename_cbk, rename_subvol, rename_subvol,
+                      rename_subvol->fops->rename, &local->loc, &local->loc2,
+                      local->xattr_req);
+    return 0;
 }
 
 int
-dht_rename_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+dht_rename_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
-        local = frame->local;
-        prev = cookie;
+    local = frame->local;
+    prev = cookie;
 
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, 0,
-                              "link/file on %s failed (%s)",
-                              prev->name, strerror (op_errno));
-                local->op_ret   = -1;
-                local->op_errno = op_errno;
-                local->added_link = _gf_false;
-        } else
-                dht_iatt_merge (this, &local->stbuf, stbuf);
+    if (op_ret == -1) {
+        gf_msg_debug(this->name, 0, "link/file on %s failed (%s)", prev->name,
+                     strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        local->added_link = _gf_false;
+    } else
+        dht_iatt_merge(this, &local->stbuf, stbuf);
 
-        if (local->op_ret == -1)
-                goto cleanup;
+    if (local->op_ret == -1)
+        goto cleanup;
 
-        dht_do_rename (frame);
+    dht_do_rename(frame);
 
-        return 0;
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_linkto_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stbuf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+dht_rename_linkto_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, inode_t *inode,
+                      struct iatt *stbuf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
-        xlator_t        *prev = NULL;
-        xlator_t        *src_cached = NULL;
-        dict_t          *xattr = NULL;
-
-        local = frame->local;
-        DHT_MARK_FOP_INTERNAL (xattr);
-        prev = cookie;
-        src_cached = local->src_cached;
-
-        if (op_ret == -1) {
-                gf_msg_debug (this->name, 0,
-                              "link/file on %s failed (%s)",
-                              prev->name, strerror (op_errno));
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-        }
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *src_cached = NULL;
+    dict_t *xattr = NULL;
 
-        /* If linkto creation failed move to failure cleanup code,
-        * instead of continuing with creating the link file */
-        if (local->op_ret != 0) {
-                goto cleanup;
-        }
+    local = frame->local;
+    DHT_MARK_FOP_INTERNAL(xattr);
+    prev = cookie;
+    src_cached = local->src_cached;
 
-        gf_msg_trace (this->name, 0,
-                      "link %s => %s (%s)", local->loc.path,
-                      local->loc2.path, src_cached->name);
-        if (gf_uuid_compare (local->loc.pargfid,
-                                local->loc2.pargfid) == 0) {
-                DHT_MARKER_DONT_ACCOUNT(xattr);
-        }
+    if (op_ret == -1) {
+        gf_msg_debug(this->name, 0, "link/file on %s failed (%s)", prev->name,
+                     strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
 
-        local->added_link = _gf_true;
+    /* If linkto creation failed move to failure cleanup code,
+     * instead of continuing with creating the link file */
+    if (local->op_ret != 0) {
+        goto cleanup;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_rename_link_cbk, src_cached, src_cached,
-                           src_cached->fops->link, &local->loc, &local->loc2,
-                           xattr);
+    gf_msg_trace(this->name, 0, "link %s => %s (%s)", local->loc.path,
+                 local->loc2.path, src_cached->name);
+    if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+        DHT_MARKER_DONT_ACCOUNT(xattr);
+    }
 
-        if (xattr)
-                dict_unref (xattr);
+    local->added_link = _gf_true;
 
-        return 0;
+    STACK_WIND_COOKIE(frame, dht_rename_link_cbk, src_cached, src_cached,
+                      src_cached->fops->link, &local->loc, &local->loc2, xattr);
+
+    if (xattr)
+        dict_unref(xattr);
+
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_unlink_links_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             struct iatt *preparent, struct iatt *postparent,
-                             dict_t *xdata)
+dht_rename_unlink_links_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno,
+                            struct iatt *preparent, struct iatt *postparent,
+                            dict_t *xdata)
 {
-	dht_local_t  *local = NULL;
-	xlator_t     *prev = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
 
+    local = frame->local;
+    prev = cookie;
 
-	local = frame->local;
-	prev = cookie;
+    if ((op_ret == -1) && (op_errno != ENOENT)) {
+        gf_msg_debug(this->name, 0, "unlink of %s on %s failed (%s)",
+                     local->loc2.path, prev->name, strerror(op_errno));
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+    }
 
-	if ((op_ret == -1) && (op_errno != ENOENT)) {
-		gf_msg_debug (this->name, 0,
-		              "unlink of %s on %s failed (%s)",
-			      local->loc2.path, prev->name,
-                              strerror (op_errno));
-		local->op_ret   = -1;
-		local->op_errno = op_errno;
-	}
+    if (local->op_ret == -1)
+        goto cleanup;
 
-        if (local->op_ret == -1)
-                goto cleanup;
+    dht_do_rename(frame);
 
-        dht_do_rename (frame);
-
-	return 0;
+    return 0;
 
 cleanup:
-        dht_rename_cleanup (frame);
+    dht_rename_cleanup(frame);
 
-	return 0;
+    return 0;
 }
 
-
 int
-dht_rename_create_links (call_frame_t *frame)
+dht_rename_create_links(call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        xlator_t    *this = NULL;
-        xlator_t    *src_hashed = NULL;
-        xlator_t    *src_cached = NULL;
-        xlator_t    *dst_hashed = NULL;
-        xlator_t    *dst_cached = NULL;
-        int          call_cnt = 0;
-        dict_t      *xattr = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *src_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    int call_cnt = 0;
+    dict_t *xattr = NULL;
 
+    local = frame->local;
+    this = frame->this;
 
-        local = frame->local;
-        this  = frame->this;
+    src_hashed = local->src_hashed;
+    src_cached = local->src_cached;
+    dst_hashed = local->dst_hashed;
+    dst_cached = local->dst_cached;
 
-        src_hashed = local->src_hashed;
-        src_cached = local->src_cached;
-        dst_hashed = local->dst_hashed;
-        dst_cached = local->dst_cached;
+    DHT_MARK_FOP_INTERNAL(xattr);
 
-        DHT_MARK_FOP_INTERNAL (xattr);
+    if (src_cached == dst_cached) {
+        dict_t *xattr_new = NULL;
 
-        if (src_cached == dst_cached) {
-                dict_t *xattr_new = NULL;
+        if (dst_hashed == dst_cached)
+            goto nolinks;
 
-                if (dst_hashed == dst_cached)
-                        goto nolinks;
+        xattr_new = dict_copy_with_ref(xattr, NULL);
 
-                xattr_new = dict_copy_with_ref (xattr, NULL);
+        gf_msg_trace(this->name, 0, "unlinking dst linkfile %s @ %s",
+                     local->loc2.path, dst_hashed->name);
 
-		gf_msg_trace (this->name, 0,
-		              "unlinking dst linkfile %s @ %s",
-			      local->loc2.path, dst_hashed->name);
+        DHT_MARKER_DONT_ACCOUNT(xattr_new);
 
-                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+        STACK_WIND_COOKIE(frame, dht_rename_unlink_links_cbk, dst_hashed,
+                          dst_hashed, dst_hashed->fops->unlink, &local->loc2, 0,
+                          xattr_new);
 
-		STACK_WIND_COOKIE (frame, dht_rename_unlink_links_cbk,
-                                   dst_hashed, dst_hashed,
-			           dst_hashed->fops->unlink, &local->loc2, 0,
-			           xattr_new);
-
-                dict_unref (xattr_new);
-                if (xattr)
-                        dict_unref (xattr);
-
-                return 0;
-        }
+        dict_unref(xattr_new);
+        if (xattr)
+            dict_unref(xattr);
 
-        if (src_cached != dst_hashed) {
-                /* needed to create the link file */
-                call_cnt++;
-                if (dst_hashed != src_hashed)
-                        /* needed to create the linkto file */
-                        call_cnt ++;
+        return 0;
+    }
+
+    if (src_cached != dst_hashed) {
+        /* needed to create the link file */
+        call_cnt++;
+        if (dst_hashed != src_hashed)
+            /* needed to create the linkto file */
+            call_cnt++;
+    }
+
+    /* We should not have any failures post the link creation, as this
+     * introduces the newname into the namespace. Clients could have cached
+     * the existence of the newname and may start taking actions based on
+     * the same. Hence create the linkto first, and then attempt the link.
+     *
+     * NOTE: If another client is attempting the same oldname -> newname
+     * rename, and finds both file names as existing, and are hard links
+     * to each other, then FUSE would send in an unlink for oldname. In
+     * this time duration if we treat the linkto as a critical error and
+     * unlink the newname we created, we would have effectively lost the
+     * file to rename operations. */
+    if (dst_hashed != src_hashed && src_cached != dst_hashed) {
+        gf_msg_trace(this->name, 0, "linkfile %s @ %s => %s", local->loc.path,
+                     dst_hashed->name, src_cached->name);
+
+        memcpy(local->gfid, local->loc.inode->gfid, 16);
+        dht_linkfile_create(frame, dht_rename_linkto_cbk, this, src_cached,
+                            dst_hashed, &local->loc);
+    } else if (src_cached != dst_hashed) {
+        dict_t *xattr_new = NULL;
+
+        xattr_new = dict_copy_with_ref(xattr, NULL);
+
+        gf_msg_trace(this->name, 0, "link %s => %s (%s)", local->loc.path,
+                     local->loc2.path, src_cached->name);
+        if (gf_uuid_compare(local->loc.pargfid, local->loc2.pargfid) == 0) {
+            DHT_MARKER_DONT_ACCOUNT(xattr_new);
         }
 
-        /* We should not have any failures post the link creation, as this
-         * introduces the newname into the namespace. Clients could have cached
-         * the existence of the newname and may start taking actions based on
-         * the same. Hence create the linkto first, and then attempt the link.
-         *
-         * NOTE: If another client is attempting the same oldname -> newname
-         * rename, and finds both file names as existing, and are hard links
-         * to each other, then FUSE would send in an unlink for oldname. In
-         * this time duration if we treat the linkto as a critical error and
-         * unlink the newname we created, we would have effectively lost the
-         * file to rename operations. */
-        if (dst_hashed != src_hashed && src_cached != dst_hashed) {
-                gf_msg_trace (this->name, 0,
-                              "linkfile %s @ %s => %s",
-                              local->loc.path, dst_hashed->name,
-                              src_cached->name);
-
-                memcpy (local->gfid, local->loc.inode->gfid, 16);
-                dht_linkfile_create (frame, dht_rename_linkto_cbk, this,
-                                     src_cached, dst_hashed, &local->loc);
-        } else if (src_cached != dst_hashed) {
-                dict_t *xattr_new = NULL;
-
-                xattr_new = dict_copy_with_ref (xattr, NULL);
-
-                gf_msg_trace (this->name, 0,
-                              "link %s => %s (%s)", local->loc.path,
-                              local->loc2.path, src_cached->name);
-                if (gf_uuid_compare (local->loc.pargfid,
-                                  local->loc2.pargfid) == 0) {
-                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
-                }
+        local->added_link = _gf_true;
 
-                local->added_link = _gf_true;
+        STACK_WIND_COOKIE(frame, dht_rename_link_cbk, src_cached, src_cached,
+                          src_cached->fops->link, &local->loc, &local->loc2,
+                          xattr_new);
 
-                STACK_WIND_COOKIE (frame, dht_rename_link_cbk, src_cached,
-                                   src_cached, src_cached->fops->link,
-                                   &local->loc, &local->loc2, xattr_new);
-
-                dict_unref (xattr_new);
-        }
+        dict_unref(xattr_new);
+    }
 
 nolinks:
-        if (!call_cnt) {
-                /* skip to next step */
-                dht_do_rename (frame);
-        }
-        if (xattr)
-                dict_unref (xattr);
-
-        return 0;
+    if (!call_cnt) {
+        /* skip to next step */
+        dht_do_rename(frame);
+    }
+    if (xattr)
+        dict_unref(xattr);
+
+    return 0;
 }
 
 int
-dht_rename_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                       struct iatt *postparent)
+dht_rename_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *stbuf, dict_t *xattr,
+                      struct iatt *postparent)
 {
-        dht_local_t *local                              = NULL;
-        int          call_cnt                           = 0;
-        dht_conf_t  *conf                               = NULL;
-        char         gfid_local[GF_UUID_BUF_SIZE]       = {0};
-        char         gfid_server[GF_UUID_BUF_SIZE]      = {0};
-        int          child_index                        = -1;
-        gf_boolean_t is_src                             = _gf_false;
-        loc_t       *loc                                = NULL;
-
-
-        child_index = (long)cookie;
-
-        local = frame->local;
-        conf = this->private;
-
-        is_src = (child_index == 0);
+    dht_local_t *local = NULL;
+    int call_cnt = 0;
+    dht_conf_t *conf = NULL;
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+    char gfid_server[GF_UUID_BUF_SIZE] = {0};
+    int child_index = -1;
+    gf_boolean_t is_src = _gf_false;
+    loc_t *loc = NULL;
+
+    child_index = (long)cookie;
+
+    local = frame->local;
+    conf = this->private;
+
+    is_src = (child_index == 0);
+    if (is_src)
+        loc = &local->loc;
+    else
+        loc = &local->loc2;
+
+    if (op_ret >= 0) {
         if (is_src)
-                loc = &local->loc;
-        else
-                loc = &local->loc2;
-
-        if (op_ret >= 0) {
-                if (is_src)
-                        local->src_cached
-                                = dht_subvol_get_cached (this,
-                                                         local->loc.inode);
-                else {
-                        if (loc->inode)
-                                gf_uuid_unparse (loc->inode->gfid, gfid_local);
-
-                        gf_msg_debug (this->name, 0,
-                                      "dst_cached before lookup: %s, "
-                                      "(path:%s)(gfid:%s),",
-                                      local->loc2.path,
-                                      local->dst_cached
-                                      ? local->dst_cached->name :
-                                      NULL,
-                                      local->dst_cached ? gfid_local : NULL);
-
-                        local->dst_cached
-                                = dht_subvol_get_cached (this,
-                                                         local->loc2_copy.inode);
-
-                        gf_uuid_unparse (stbuf->ia_gfid, gfid_local);
-
-                        gf_msg_debug (this->name, GF_LOG_WARNING,
-                                      "dst_cached after lookup: %s, "
-                                      "(path:%s)(gfid:%s)",
-                                      local->loc2.path,
-                                      local->dst_cached
-                                      ? local->dst_cached->name :
-                                      NULL,
-                                      local->dst_cached ? gfid_local : NULL);
-
-
-                        if ((local->loc2.inode == NULL)
-                            || gf_uuid_compare (stbuf->ia_gfid,
-                                                local->loc2.inode->gfid)) {
-                                if (local->loc2.inode != NULL) {
-                                        inode_unlink (local->loc2.inode,
-                                                      local->loc2.parent,
-                                                      local->loc2.name);
-                                        inode_unref (local->loc2.inode);
-                                }
-
-                                local->loc2.inode
-                                        = inode_link (local->loc2_copy.inode,
-                                                      local->loc2_copy.parent,
-                                                      local->loc2_copy.name,
-                                                      stbuf);
-                                gf_uuid_copy (local->loc2.gfid,
-                                              stbuf->ia_gfid);
-                        }
+            local->src_cached = dht_subvol_get_cached(this, local->loc.inode);
+        else {
+            if (loc->inode)
+                gf_uuid_unparse(loc->inode->gfid, gfid_local);
+
+            gf_msg_debug(this->name, 0,
+                         "dst_cached before lookup: %s, "
+                         "(path:%s)(gfid:%s),",
+                         local->loc2.path,
+                         local->dst_cached ? local->dst_cached->name : NULL,
+                         local->dst_cached ? gfid_local : NULL);
+
+            local->dst_cached = dht_subvol_get_cached(this,
+                                                      local->loc2_copy.inode);
+
+            gf_uuid_unparse(stbuf->ia_gfid, gfid_local);
+
+            gf_msg_debug(this->name, GF_LOG_WARNING,
+                         "dst_cached after lookup: %s, "
+                         "(path:%s)(gfid:%s)",
+                         local->loc2.path,
+                         local->dst_cached ? local->dst_cached->name : NULL,
+                         local->dst_cached ? gfid_local : NULL);
+
+            if ((local->loc2.inode == NULL) ||
+                gf_uuid_compare(stbuf->ia_gfid, local->loc2.inode->gfid)) {
+                if (local->loc2.inode != NULL) {
+                    inode_unlink(local->loc2.inode, local->loc2.parent,
+                                 local->loc2.name);
+                    inode_unref(local->loc2.inode);
                 }
-        }
 
-        if (op_ret < 0) {
-                if (is_src) {
-                        /* The meaning of is_linkfile is overloaded here. For locking
-                         * to work properly both rebalance and rename should acquire
-                         * lock on datafile. The reason for sending this lookup is to
-                         * find out whether we've acquired a lock on data file.
-                         * Between the lookup before rename and this rename, the
-                         * file could be migrated by a rebalance process and now this
-                         * file this might be a linkto file. We verify that by sending
-                         * this lookup. However, if this lookup fails we cannot really
-                         * say whether we've acquired lock on a datafile or linkto file.
-                         * So, we act conservatively and _assume_
-                         * that this is a linkfile and fail the rename operation.
-                         */
-                        local->is_linkfile = _gf_true;
-                        local->op_errno = op_errno;
-                } else {
-                        if (local->dst_cached)
-                                gf_msg_debug (this->name, op_errno,
-                                              "file %s (gfid:%s) was present "
-                                              "(hashed-subvol=%s, "
-                                              "cached-subvol=%s) before rename,"
-                                              " but lookup failed",
-                                              local->loc2.path,
-                                              uuid_utoa (local->loc2.inode->gfid),
-                                              local->dst_hashed->name,
-                                              local->dst_cached->name);
-                        if (dht_inode_missing (op_errno))
-                                local->dst_cached = NULL;
-                }
-        } else if (is_src && xattr && check_is_linkfile (inode, stbuf, xattr,
-                                               conf->link_xattr_name)) {
-                local->is_linkfile = _gf_true;
-                /* Found linkto file instead of data file, passdown ENOENT
-                 * based on the above comment */
-                local->op_errno = ENOENT;
-        }
-
-        if (!local->is_linkfile && (op_ret >= 0) &&
-            gf_uuid_compare (loc->gfid, stbuf->ia_gfid)) {
-                gf_uuid_unparse (loc->gfid, gfid_local);
-                gf_uuid_unparse (stbuf->ia_gfid, gfid_server);
-
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_GFID_MISMATCH,
-                        "path:%s, received a different gfid, local_gfid= %s"
-                        " server_gfid: %s",
-                        local->loc.path, gfid_local, gfid_server);
-
-                /* Will passdown ENOENT anyway since the file we sent on
-                 * rename is replaced with a different file */
-                local->op_errno = ENOENT;
-                /* Since local->is_linkfile is used here to detect failure,
-                 * marking this to true */
-                local->is_linkfile = _gf_true;
-        }
-
-        call_cnt = dht_frame_return (frame);
-        if (is_last_call (call_cnt)) {
-                if (local->is_linkfile) {
-                        local->op_ret = -1;
-                        goto fail;
-                }
-
-                dht_rename_create_links (frame);
-        }
-
-        return 0;
+                local->loc2.inode = inode_link(local->loc2_copy.inode,
+                                               local->loc2_copy.parent,
+                                               local->loc2_copy.name, stbuf);
+                gf_uuid_copy(local->loc2.gfid, stbuf->ia_gfid);
+            }
+        }
+    }
+
+    if (op_ret < 0) {
+        if (is_src) {
+            /* The meaning of is_linkfile is overloaded here. For locking
+             * to work properly both rebalance and rename should acquire
+             * lock on datafile. The reason for sending this lookup is to
+             * find out whether we've acquired a lock on data file.
+             * Between the lookup before rename and this rename, the
+             * file could be migrated by a rebalance process and now this
+             * file this might be a linkto file. We verify that by sending
+             * this lookup. However, if this lookup fails we cannot really
+             * say whether we've acquired lock on a datafile or linkto file.
+             * So, we act conservatively and _assume_
+             * that this is a linkfile and fail the rename operation.
+             */
+            local->is_linkfile = _gf_true;
+            local->op_errno = op_errno;
+        } else {
+            if (local->dst_cached)
+                gf_msg_debug(this->name, op_errno,
+                             "file %s (gfid:%s) was present "
+                             "(hashed-subvol=%s, "
+                             "cached-subvol=%s) before rename,"
+                             " but lookup failed",
+                             local->loc2.path,
+                             uuid_utoa(local->loc2.inode->gfid),
+                             local->dst_hashed->name, local->dst_cached->name);
+            if (dht_inode_missing(op_errno))
+                local->dst_cached = NULL;
+        }
+    } else if (is_src && xattr &&
+               check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name)) {
+        local->is_linkfile = _gf_true;
+        /* Found linkto file instead of data file, passdown ENOENT
+         * based on the above comment */
+        local->op_errno = ENOENT;
+    }
+
+    if (!local->is_linkfile && (op_ret >= 0) &&
+        gf_uuid_compare(loc->gfid, stbuf->ia_gfid)) {
+        gf_uuid_unparse(loc->gfid, gfid_local);
+        gf_uuid_unparse(stbuf->ia_gfid, gfid_server);
+
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_GFID_MISMATCH,
+               "path:%s, received a different gfid, local_gfid= %s"
+               " server_gfid: %s",
+               local->loc.path, gfid_local, gfid_server);
+
+        /* Will passdown ENOENT anyway since the file we sent on
+         * rename is replaced with a different file */
+        local->op_errno = ENOENT;
+        /* Since local->is_linkfile is used here to detect failure,
+         * marking this to true */
+        local->is_linkfile = _gf_true;
+    }
+
+    call_cnt = dht_frame_return(frame);
+    if (is_last_call(call_cnt)) {
+        if (local->is_linkfile) {
+            local->op_ret = -1;
+            goto fail;
+        }
+
+        dht_rename_create_links(frame);
+    }
+
+    return 0;
 fail:
-        dht_rename_unlock (frame, this);
-        return 0;
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
 int
-dht_rename_file_lock1_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rename_file_lock1_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        int          ret                        = 0;
-        loc_t       *loc                        = NULL;
-        xlator_t    *subvol                     = NULL;
-
-        local = frame->local;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "protecting namespace of %s failed"
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->current == &local->lock[0] ? local->loc.path
-                        : local->loc2.path,
-                        local->loc.path, src_gfid, local->src_hashed->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_hashed ? local->dst_hashed->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        if (local->current == &local->lock[0]) {
-                loc = &local->loc2;
-                subvol = local->dst_hashed;
-                local->current = &local->lock[1];
-        } else {
-                loc = &local->loc;
-                subvol = local->src_hashed;
-                local->current = &local->lock[0];
-        }
-
-        ret = dht_protect_namespace (frame, loc, subvol, &local->current->ns,
-                                     dht_rename_lock_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
+
+    local = frame->local;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "protecting namespace of %s failed"
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->current == &local->lock[0] ? local->loc.path
+                                                 : local->loc2.path,
+               local->loc.path, src_gfid, local->src_hashed->name,
+               local->loc2.path, dst_gfid,
+               local->dst_hashed ? local->dst_hashed->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    if (local->current == &local->lock[0]) {
+        loc = &local->loc2;
+        subvol = local->dst_hashed;
+        local->current = &local->lock[1];
+    } else {
+        loc = &local->loc;
+        subvol = local->src_hashed;
+        local->current = &local->lock[0];
+    }
+
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_lock_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    return 0;
 err:
-        /* No harm in calling an extra unlock */
-        dht_rename_unlock (frame, this);
-        return 0;
+    /* No harm in calling an extra unlock */
+    dht_rename_unlock(frame, this);
+    return 0;
 }
 
 int32_t
-dht_rename_file_protect_namespace (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int32_t op_ret,
-                                   int32_t op_errno, dict_t *xdata)
+dht_rename_file_protect_namespace(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local                     = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        int          ret                        = 0;
-        loc_t       *loc                        = NULL;
-        xlator_t    *subvol                     = NULL;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    int ret = 0;
+    loc_t *loc = NULL;
+    xlator_t *subvol = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
 
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
 
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "acquiring inodelk failed "
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->loc.path, src_gfid, local->src_cached->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_cached ? local->dst_cached->name : NULL);
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "acquiring inodelk failed "
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->loc.path, src_gfid, local->src_cached->name,
+               local->loc2.path, dst_gfid,
+               local->dst_cached ? local->dst_cached->name : NULL);
 
-                local->op_ret = -1;
-                local->op_errno = op_errno;
+        local->op_ret = -1;
+        local->op_errno = op_errno;
 
-                goto err;
-        }
+        goto err;
+    }
 
-        /* Locks on src and dst needs to ordered which otherwise might cause
-         * deadlocks when rename (src, dst) and rename (dst, src) is done from
-         * two different clients
-         */
-        dht_order_rename_lock (frame, &loc, &subvol);
+    /* Locks on src and dst needs to ordered which otherwise might cause
+     * deadlocks when rename (src, dst) and rename (dst, src) is done from
+     * two different clients
+     */
+    dht_order_rename_lock(frame, &loc, &subvol);
 
-        ret = dht_protect_namespace (frame, loc, subvol,
-                                     &local->current->ns,
-                                     dht_rename_file_lock1_cbk);
-        if (ret < 0) {
-                op_errno = EINVAL;
-                goto err;
-        }
+    ret = dht_protect_namespace(frame, loc, subvol, &local->current->ns,
+                                dht_rename_file_lock1_cbk);
+    if (ret < 0) {
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        return 0;
+    return 0;
 
 err:
-        /* Its fine to call unlock even when no locks are acquired, as we check
-         * for lock->locked before winding a unlock call.
-         */
-        dht_rename_unlock (frame, this);
+    /* Its fine to call unlock even when no locks are acquired, as we check
+     * for lock->locked before winding a unlock call.
+     */
+    dht_rename_unlock(frame, this);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-dht_rename_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_rename_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t *local                      = NULL;
-        char         src_gfid[GF_UUID_BUF_SIZE] = {0};
-        char         dst_gfid[GF_UUID_BUF_SIZE] = {0};
-        dict_t      *xattr_req                  = NULL;
-        dht_conf_t  *conf                       = NULL;
-        int          i                          = 0;
-        xlator_t    *subvol                     = NULL;
-        dht_lock_t  *lock                       = NULL;
-
-        local = frame->local;
-        conf = this->private;
-
-        if (op_ret < 0) {
-                uuid_utoa_r (local->loc.inode->gfid, src_gfid);
-
-                if (local->loc2.inode)
-                        uuid_utoa_r (local->loc2.inode->gfid, dst_gfid);
-
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_INODE_LK_ERROR,
-                        "protecting namespace of %s failed. "
-                        "rename (%s:%s:%s %s:%s:%s)",
-                        local->current == &local->lock[0] ? local->loc.path
-                        : local->loc2.path,
-                        local->loc.path, src_gfid, local->src_hashed->name,
-                        local->loc2.path, dst_gfid,
-                        local->dst_hashed ? local->dst_hashed->name : NULL);
-
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-
-                goto done;
+    dht_local_t *local = NULL;
+    char src_gfid[GF_UUID_BUF_SIZE] = {0};
+    char dst_gfid[GF_UUID_BUF_SIZE] = {0};
+    dict_t *xattr_req = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    xlator_t *subvol = NULL;
+    dht_lock_t *lock = NULL;
+
+    local = frame->local;
+    conf = this->private;
+
+    if (op_ret < 0) {
+        uuid_utoa_r(local->loc.inode->gfid, src_gfid);
+
+        if (local->loc2.inode)
+            uuid_utoa_r(local->loc2.inode->gfid, dst_gfid);
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_INODE_LK_ERROR,
+               "protecting namespace of %s failed. "
+               "rename (%s:%s:%s %s:%s:%s)",
+               local->current == &local->lock[0] ? local->loc.path
+                                                 : local->loc2.path,
+               local->loc.path, src_gfid, local->src_hashed->name,
+               local->loc2.path, dst_gfid,
+               local->dst_hashed ? local->dst_hashed->name : NULL);
+
+        local->op_ret = -1;
+        local->op_errno = op_errno;
+
+        goto done;
+    }
+
+    xattr_req = dict_new();
+    if (xattr_req == NULL) {
+        local->op_ret = -1;
+        local->op_errno = ENOMEM;
+        goto done;
+    }
+
+    op_ret = dict_set_uint32(xattr_req, conf->link_xattr_name, 256);
+    if (op_ret < 0) {
+        local->op_ret = -1;
+        local->op_errno = -op_ret;
+        goto done;
+    }
+
+    /* dst_cached might've changed. This normally happens for two reasons:
+     * 1. rebalance migrated dst
+     * 2. Another parallel rename was done overwriting dst
+     *
+     * Doing a lookup on local->loc2 when dst exists, but is associated
+     * with a different gfid will result in an ESTALE error. So, do a fresh
+     * lookup with a new inode on dst-path and handle change of dst-cached
+     * in the cbk. Also, to identify dst-cached changes we do a lookup on
+     * "this" rather than the subvol.
+     */
+    loc_copy(&local->loc2_copy, &local->loc2);
+    inode_unref(local->loc2_copy.inode);
+    local->loc2_copy.inode = inode_new(local->loc.inode->table);
+
+    /* Why not use local->lock.locks[?].loc for lookup post lock phase
+     * ---------------------------------------------------------------
+     * "layout.parent_layout.locks[?].loc" does not have the name and pargfid
+     * populated.
+     * Reason: If we had populated the name and pargfid, server might
+     * resolve to a successful lookup even if there is a file with same name
+     * with a different gfid(unlink & create) as server does name based
+     * resolution on first priority. And this can result in operating on a
+     * different inode entirely.
+     *
+     * Now consider a scenario where source file was renamed by some other
+     * client to a new name just before this lock was granted. So if a
+     * lookup would be done on local->lock[0].layout.parent_layout.locks[?].loc,
+     * server will send success even if the entry was renamed (since server will
+     * do a gfid based resolution). So once a lock is granted, make sure the
+     * file exists with the name that the client requested with.
+     * */
+
+    local->call_cnt = 2;
+    for (i = 0; i < 2; i++) {
+        if (i == 0) {
+            lock = local->rename_inodelk_backward_compatible[0];
+            if (gf_uuid_compare(local->loc.gfid, lock->loc.gfid) == 0)
+                subvol = lock->xl;
+            else {
+                lock = local->rename_inodelk_backward_compatible[1];
+                subvol = lock->xl;
+            }
+        } else {
+            subvol = this;
         }
 
-        xattr_req = dict_new ();
-        if (xattr_req == NULL) {
-                local->op_ret = -1;
-                local->op_errno = ENOMEM;
-                goto done;
-        }
+        STACK_WIND_COOKIE(frame, dht_rename_lookup_cbk, (void *)(long)i, subvol,
+                          subvol->fops->lookup,
+                          (i == 0) ? &local->loc : &local->loc2_copy,
+                          xattr_req);
+    }
 
-        op_ret = dict_set_uint32 (xattr_req,
-                                  conf->link_xattr_name, 256);
-        if (op_ret < 0) {
-                local->op_ret = -1;
-                local->op_errno = -op_ret;
-                goto done;
-        }
-
-        /* dst_cached might've changed. This normally happens for two reasons:
-         * 1. rebalance migrated dst
-         * 2. Another parallel rename was done overwriting dst
-         *
-         * Doing a lookup on local->loc2 when dst exists, but is associated
-         * with a different gfid will result in an ESTALE error. So, do a fresh
-         * lookup with a new inode on dst-path and handle change of dst-cached
-         * in the cbk. Also, to identify dst-cached changes we do a lookup on
-         * "this" rather than the subvol.
-         */
-        loc_copy (&local->loc2_copy, &local->loc2);
-        inode_unref (local->loc2_copy.inode);
-        local->loc2_copy.inode = inode_new (local->loc.inode->table);
-
-        /* Why not use local->lock.locks[?].loc for lookup post lock phase
-         * ---------------------------------------------------------------
-         * "layout.parent_layout.locks[?].loc" does not have the name and pargfid
-         * populated.
-         * Reason: If we had populated the name and pargfid, server might
-         * resolve to a successful lookup even if there is a file with same name
-         * with a different gfid(unlink & create) as server does name based
-         * resolution on first priority. And this can result in operating on a
-         * different inode entirely.
-         *
-         * Now consider a scenario where source file was renamed by some other
-         * client to a new name just before this lock was granted. So if a
-         * lookup would be done on local->lock[0].layout.parent_layout.locks[?].loc,
-         * server will send success even if the entry was renamed (since server will
-         * do a gfid based resolution). So once a lock is granted, make sure the file
-         * exists with the name that the client requested with.
-         * */
-
-        local->call_cnt = 2;
-        for (i = 0; i < 2; i++) {
-                if (i == 0) {
-                        lock = local->rename_inodelk_backward_compatible[0];
-                        if (gf_uuid_compare (local->loc.gfid,
-                                             lock->loc.gfid) == 0)
-                                subvol = lock->xl;
-                        else {
-                                lock = local->rename_inodelk_backward_compatible[1];
-                                subvol = lock->xl;
-                        }
-                } else {
-                        subvol = this;
-                }
-
-                STACK_WIND_COOKIE (frame, dht_rename_lookup_cbk,
-                                   (void *)(long)i, subvol,
-                                   subvol->fops->lookup,
-                                   (i == 0) ? &local->loc : &local->loc2_copy,
-                                   xattr_req);
-        }
-
-        dict_unref (xattr_req);
-        return 0;
+    dict_unref(xattr_req);
+    return 0;
 
 done:
-        /* Its fine to call unlock even when no locks are acquired, as we check
-         * for lock->locked before winding a unlock call.
-         */
-        dht_rename_unlock (frame, this);
+    /* Its fine to call unlock even when no locks are acquired, as we check
+     * for lock->locked before winding a unlock call.
+     */
+    dht_rename_unlock(frame, this);
 
-        if (xattr_req)
-                dict_unref (xattr_req);
+    if (xattr_req)
+        dict_unref(xattr_req);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_rename_lock (call_frame_t *frame)
+dht_rename_lock(call_frame_t *frame)
 {
-        dht_local_t  *local    = NULL;
-        int           count    = 1, ret = -1;
-        dht_lock_t  **lk_array = NULL;
-
-        local = frame->local;
-
-        if (local->dst_cached)
-                count++;
-
-        lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                              gf_common_mt_pointer);
-        if (lk_array == NULL)
-                goto err;
-
-        lk_array[0] = dht_lock_new (frame->this, local->src_cached, &local->loc,
-                                    F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL,
-                                    FAIL_ON_ANY_ERROR);
-        if (lk_array[0] == NULL)
-                goto err;
-
-        if (local->dst_cached) {
-                /* dst might be removed by the time inodelk reaches bricks,
-                 * which can result in ESTALE errors. POSIX imposes no
-                 * restriction for dst to be present for renames to be
-                 * successful. So, we'll ignore ESTALE errors. As far as
-                 * synchronization on dst goes, we'll achieve the same by
-                 * holding entrylk on parent directory of dst in the namespace
-                 * of basename(dst). Also, there might not be quorum in cluster
-                 * xlators like EC/disperse on errno, in which case they return
-                 * EIO. For eg., in a disperse (4 + 2), 3 might return success
-                 * and three might return ESTALE. Disperse, having no Quorum
-                 * unwinds inodelk with EIO. So, ignore EIO too.
-                 */
-                lk_array[1] = dht_lock_new (frame->this, local->dst_cached,
-                                            &local->loc2, F_WRLCK,
-                                            DHT_FILE_MIGRATE_DOMAIN, NULL,
-                                            IGNORE_ENOENT_ESTALE_EIO);
-                if (lk_array[1] == NULL)
-                        goto err;
-        }
-
-        local->rename_inodelk_backward_compatible = lk_array;
-        local->rename_inodelk_bc_count = count;
-
-        /* retaining inodelks for the sake of backward compatibility. Please
-         * make sure to remove this inodelk once all of 3.10, 3.12 and 3.13
-         * reach EOL. Better way of getting synchronization would be to acquire
-         * entrylks on src and dst parent directories in the namespace of
-         * basenames of src and dst
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1;
+    dht_lock_t **lk_array = NULL;
+
+    local = frame->local;
+
+    if (local->dst_cached)
+        count++;
+
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_pointer);
+    if (lk_array == NULL)
+        goto err;
+
+    lk_array[0] = dht_lock_new(frame->this, local->src_cached, &local->loc,
+                               F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL,
+                               FAIL_ON_ANY_ERROR);
+    if (lk_array[0] == NULL)
+        goto err;
+
+    if (local->dst_cached) {
+        /* dst might be removed by the time inodelk reaches bricks,
+         * which can result in ESTALE errors. POSIX imposes no
+         * restriction for dst to be present for renames to be
+         * successful. So, we'll ignore ESTALE errors. As far as
+         * synchronization on dst goes, we'll achieve the same by
+         * holding entrylk on parent directory of dst in the namespace
+         * of basename(dst). Also, there might not be quorum in cluster
+         * xlators like EC/disperse on errno, in which case they return
+         * EIO. For eg., in a disperse (4 + 2), 3 might return success
+         * and three might return ESTALE. Disperse, having no Quorum
+         * unwinds inodelk with EIO. So, ignore EIO too.
          */
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    dht_rename_file_protect_namespace);
-        if (ret < 0) {
-                local->rename_inodelk_backward_compatible = NULL;
-                local->rename_inodelk_bc_count = 0;
-                goto err;
-        }
-
-        return 0;
+        lk_array[1] = dht_lock_new(frame->this, local->dst_cached, &local->loc2,
+                                   F_WRLCK, DHT_FILE_MIGRATE_DOMAIN, NULL,
+                                   IGNORE_ENOENT_ESTALE_EIO);
+        if (lk_array[1] == NULL)
+            goto err;
+    }
+
+    local->rename_inodelk_backward_compatible = lk_array;
+    local->rename_inodelk_bc_count = count;
+
+    /* retaining inodelks for the sake of backward compatibility. Please
+     * make sure to remove this inodelk once all of 3.10, 3.12 and 3.13
+     * reach EOL. Better way of getting synchronization would be to acquire
+     * entrylks on src and dst parent directories in the namespace of
+     * basenames of src and dst
+     */
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_rename_file_protect_namespace);
+    if (ret < 0) {
+        local->rename_inodelk_backward_compatible = NULL;
+        local->rename_inodelk_bc_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (lk_array != NULL) {
-                int tmp_count = 0, i = 0;
+    if (lk_array != NULL) {
+        int tmp_count = 0, i = 0;
 
-                for (i = 0; (i < count) && (lk_array[i]); i++, tmp_count++);
+        for (i = 0; (i < count) && (lk_array[i]); i++, tmp_count++)
+            ;
 
-                dht_lock_array_free (lk_array, tmp_count);
-                GF_FREE (lk_array);
-        }
+        dht_lock_array_free(lk_array, tmp_count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_rename (call_frame_t *frame, xlator_t *this,
-            loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+dht_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata)
 {
-        xlator_t    *src_cached             = NULL;
-        xlator_t    *src_hashed             = NULL;
-        xlator_t    *dst_cached             = NULL;
-        xlator_t    *dst_hashed             = NULL;
-        int          op_errno               = -1;
-        int          ret                    = -1;
-        dht_local_t *local                  = NULL;
-        dht_conf_t  *conf                   = NULL;
-        char         gfid[GF_UUID_BUF_SIZE] = {0};
-        char         newgfid[GF_UUID_BUF_SIZE] = {0};
-        gf_boolean_t free_xdata             = _gf_false;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (newloc, err);
-
-        conf = this->private;
-
-        if (conf->subvolume_cnt == 1) {
-                if (!IA_ISDIR (oldloc->inode->ia_type)) {
-                        if (!xdata) {
-                                free_xdata = _gf_true;
-                        }
-                        DHT_CHANGELOG_TRACK_AS_RENAME(xdata, oldloc, newloc);
-                }
-                default_rename (frame, this, oldloc, newloc, xdata);
-                if (free_xdata && xdata) {
-                        dict_unref(xdata);
-                        xdata = NULL;
-                }
-                return 0;
-        }
-
-        gf_uuid_unparse(oldloc->inode->gfid, gfid);
-
-        src_hashed = dht_subvol_get_hashed (this, oldloc);
-        if (!src_hashed) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No hashed subvolume in layout for path=%s,"
-                        "(gfid = %s)", oldloc->path, gfid);
-                op_errno = EINVAL;
-                goto err;
+    xlator_t *src_cached = NULL;
+    xlator_t *src_hashed = NULL;
+    xlator_t *dst_cached = NULL;
+    xlator_t *dst_hashed = NULL;
+    int op_errno = -1;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    char newgfid[GF_UUID_BUF_SIZE] = {0};
+    gf_boolean_t free_xdata = _gf_false;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    conf = this->private;
+
+    if (conf->subvolume_cnt == 1) {
+        if (!IA_ISDIR(oldloc->inode->ia_type)) {
+            if (!xdata) {
+                free_xdata = _gf_true;
+            }
+            DHT_CHANGELOG_TRACK_AS_RENAME(xdata, oldloc, newloc);
+        }
+        default_rename(frame, this, oldloc, newloc, xdata);
+        if (free_xdata && xdata) {
+            dict_unref(xdata);
+            xdata = NULL;
         }
-
-        src_cached = dht_subvol_get_cached (this, oldloc->inode);
-        if (!src_cached) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No cached subvolume for path = %s,"
-                        "(gfid = %s)", oldloc->path, gfid);
-
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        dst_hashed = dht_subvol_get_hashed (this, newloc);
-        if (!dst_hashed) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_RENAME_FAILED,
-                        "No hashed subvolume in layout for path=%s",
-                        newloc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (newloc->inode)
-                dst_cached = dht_subvol_get_cached (this, newloc->inode);
-
-        local = dht_local_init (frame, oldloc, NULL, GF_FOP_RENAME);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        /* cached_subvol will be set from dht_local_init, reset it to NULL,
-           as the logic of handling rename is different  */
-        local->cached_subvol = NULL;
-
-        ret = loc_copy (&local->loc2, newloc);
-        if (ret == -1) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        local->src_hashed = src_hashed;
-        local->src_cached = src_cached;
-        local->dst_hashed = dst_hashed;
-        local->dst_cached = dst_cached;
-        if (xdata)
-                local->xattr_req = dict_ref (xdata);
-
-        if (newloc->inode)
-                gf_uuid_unparse(newloc->inode->gfid, newgfid);
-
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_RENAME_INFO,
-                "renaming %s (%s) (hash=%s/cache=%s) => %s (%s) "
-                "(hash=%s/cache=%s) ",
-                oldloc->path, gfid, src_hashed->name, src_cached->name,
-                newloc->path, newloc->inode ? newgfid : NULL, dst_hashed->name,
-                dst_cached ? dst_cached->name : "<nul>");
-
-        if (IA_ISDIR (oldloc->inode->ia_type)) {
-                dht_rename_dir (frame, this);
-        } else {
-                local->op_ret = 0;
-                ret = dht_rename_lock (frame);
-                if (ret < 0) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
+        return 0;
+    }
+
+    gf_uuid_unparse(oldloc->inode->gfid, gfid);
+
+    src_hashed = dht_subvol_get_hashed(this, oldloc);
+    if (!src_hashed) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No hashed subvolume in layout for path=%s,"
+               "(gfid = %s)",
+               oldloc->path, gfid);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    src_cached = dht_subvol_get_cached(this, oldloc->inode);
+    if (!src_cached) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No cached subvolume for path = %s,"
+               "(gfid = %s)",
+               oldloc->path, gfid);
+
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    dst_hashed = dht_subvol_get_hashed(this, newloc);
+    if (!dst_hashed) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_FAILED,
+               "No hashed subvolume in layout for path=%s", newloc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (newloc->inode)
+        dst_cached = dht_subvol_get_cached(this, newloc->inode);
+
+    local = dht_local_init(frame, oldloc, NULL, GF_FOP_RENAME);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    /* cached_subvol will be set from dht_local_init, reset it to NULL,
+       as the logic of handling rename is different  */
+    local->cached_subvol = NULL;
+
+    ret = loc_copy(&local->loc2, newloc);
+    if (ret == -1) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->src_hashed = src_hashed;
+    local->src_cached = src_cached;
+    local->dst_hashed = dst_hashed;
+    local->dst_cached = dst_cached;
+    if (xdata)
+        local->xattr_req = dict_ref(xdata);
+
+    if (newloc->inode)
+        gf_uuid_unparse(newloc->inode->gfid, newgfid);
+
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_RENAME_INFO,
+           "renaming %s (%s) (hash=%s/cache=%s) => %s (%s) "
+           "(hash=%s/cache=%s) ",
+           oldloc->path, gfid, src_hashed->name, src_cached->name, newloc->path,
+           newloc->inode ? newgfid : NULL, dst_hashed->name,
+           dst_cached ? dst_cached->name : "<nul>");
+
+    if (IA_ISDIR(oldloc->inode->ia_type)) {
+        dht_rename_dir(frame, this);
+    } else {
+        local->op_ret = 0;
+        ret = dht_rename_lock(frame);
+        if (ret < 0) {
+            op_errno = ENOMEM;
+            goto err;
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                          NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/dht-selfheal.c b/xlators/cluster/dht/src/dht-selfheal.c
index 5d5c8e86ddf..e17f96698bd 100644
--- a/xlators/cluster/dht/src/dht-selfheal.c
+++ b/xlators/cluster/dht/src/dht-selfheal.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "glusterfs.h"
 #include "xlator.h"
 #include "dht-common.h"
@@ -16,2736 +15,2640 @@
 #include "dht-lock.h"
 #include "glusterfs-acl.h"
 
-#define DHT_SET_LAYOUT_RANGE(layout,i,srt,chunk,path)    do {           \
-                layout->list[i].start = srt;                            \
-                layout->list[i].stop  = srt + chunk - 1;                \
-                layout->list[i].commit_hash = layout->commit_hash;      \
-                                                                        \
-                gf_msg_trace (this->name, 0,                            \
-                              "gave fix: %u - %u, with commit-hash %u"  \
-                              " on %s for %s",                          \
-                              layout->list[i].start,                    \
-                              layout->list[i].stop,                     \
-                              layout->list[i].commit_hash,              \
-                              layout->list[i].xlator->name, path);      \
-        } while (0)
-
-#define DHT_RESET_LAYOUT_RANGE(layout)    do {                          \
-                int cnt = 0;                                            \
-                for (cnt = 0; cnt < layout->cnt; cnt++ ) {              \
-                        layout->list[cnt].start = 0;                    \
-                        layout->list[cnt].stop  = 0;                    \
-                }                                                       \
-        } while (0)
+#define DHT_SET_LAYOUT_RANGE(layout, i, srt, chunk, path)                      \
+    do {                                                                       \
+        layout->list[i].start = srt;                                           \
+        layout->list[i].stop = srt + chunk - 1;                                \
+        layout->list[i].commit_hash = layout->commit_hash;                     \
+                                                                               \
+        gf_msg_trace(this->name, 0,                                            \
+                     "gave fix: %u - %u, with commit-hash %u"                  \
+                     " on %s for %s",                                          \
+                     layout->list[i].start, layout->list[i].stop,              \
+                     layout->list[i].commit_hash,                              \
+                     layout->list[i].xlator->name, path);                      \
+    } while (0)
+
+#define DHT_RESET_LAYOUT_RANGE(layout)                                         \
+    do {                                                                       \
+        int cnt = 0;                                                           \
+        for (cnt = 0; cnt < layout->cnt; cnt++) {                              \
+            layout->list[cnt].start = 0;                                       \
+            layout->list[cnt].stop = 0;                                        \
+        }                                                                      \
+    } while (0)
 
 int
-dht_selfheal_layout_lock (call_frame_t *frame, dht_layout_t *layout,
-                          gf_boolean_t newdir,
-                          dht_selfheal_layout_t healer,
-                          dht_need_heal_t should_heal);
+dht_selfheal_layout_lock(call_frame_t *frame, dht_layout_t *layout,
+                         gf_boolean_t newdir, dht_selfheal_layout_t healer,
+                         dht_need_heal_t should_heal);
 
 static uint32_t
-dht_overlap_calc (dht_layout_t *old, int o, dht_layout_t *new, int n)
+dht_overlap_calc(dht_layout_t *old, int o, dht_layout_t *new, int n)
 {
-	if (o >= old->cnt || n >= new->cnt)
-		return 0;
+    if (o >= old->cnt || n >= new->cnt)
+        return 0;
 
-	if (old->list[o].err > 0 || new->list[n].err > 0)
-		return 0;
+    if (old->list[o].err > 0 || new->list[n].err > 0)
+        return 0;
 
-        if (old->list[o].start == old->list[o].stop) {
-                return 0;
-        }
+    if (old->list[o].start == old->list[o].stop) {
+        return 0;
+    }
 
-        if (new->list[n].start == new->list[n].stop) {
-                return 0;
-        }
+    if (new->list[n].start == new->list[n].stop) {
+        return 0;
+    }
 
-	if ((old->list[o].start > new->list[n].stop) ||
-	    (old->list[o].stop < new->list[n].start))
-		return 0;
+    if ((old->list[o].start > new->list[n].stop) ||
+        (old->list[o].stop < new->list[n].start))
+        return 0;
 
-	return min (old->list[o].stop, new->list[n].stop) -
-	        max (old->list[o].start, new->list[n].start) + 1;
+    return min(old->list[o].stop, new->list[n].stop) -
+           max(old->list[o].start, new->list[n].start) + 1;
 }
 
 int
-dht_selfheal_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_selfheal_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        DHT_STACK_DESTROY (frame);
-        return 0;
+    DHT_STACK_DESTROY(frame);
+    return 0;
 }
 
 int
-dht_selfheal_dir_finish (call_frame_t *frame, xlator_t *this, int ret,
-                         int invoke_cbk)
+dht_selfheal_dir_finish(call_frame_t *frame, xlator_t *this, int ret,
+                        int invoke_cbk)
 {
-        dht_local_t  *local      = NULL, *lock_local = NULL;
-        call_frame_t *lock_frame = NULL;
-        int           lock_count = 0;
+    dht_local_t *local = NULL, *lock_local = NULL;
+    call_frame_t *lock_frame = NULL;
+    int lock_count = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* Unlock entrylk */
-        dht_unlock_entrylk_wrapper (frame, &local->lock[0].ns.directory_ns);
+    /* Unlock entrylk */
+    dht_unlock_entrylk_wrapper(frame, &local->lock[0].ns.directory_ns);
 
-        /* Unlock inodelk */
-        lock_count = dht_lock_count (local->lock[0].ns.parent_layout.locks,
-                                     local->lock[0].ns.parent_layout.lk_count);
-        if (lock_count == 0)
-                goto done;
+    /* Unlock inodelk */
+    lock_count = dht_lock_count(local->lock[0].ns.parent_layout.locks,
+                                local->lock[0].ns.parent_layout.lk_count);
+    if (lock_count == 0)
+        goto done;
 
-        lock_frame = copy_frame (frame);
-        if (lock_frame == NULL) {
-                goto done;
-        }
+    lock_frame = copy_frame(frame);
+    if (lock_frame == NULL) {
+        goto done;
+    }
 
-        lock_local = dht_local_init (lock_frame, &local->loc, NULL,
-                                     lock_frame->root->op);
-        if (lock_local == NULL) {
-                goto done;
-        }
+    lock_local = dht_local_init(lock_frame, &local->loc, NULL,
+                                lock_frame->root->op);
+    if (lock_local == NULL) {
+        goto done;
+    }
 
-        lock_local->lock[0].ns.parent_layout.locks = local->lock[0].ns.parent_layout.locks;
-        lock_local->lock[0].ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
+    lock_local->lock[0].ns.parent_layout.locks = local->lock[0]
+                                                     .ns.parent_layout.locks;
+    lock_local->lock[0]
+        .ns.parent_layout.lk_count = local->lock[0].ns.parent_layout.lk_count;
 
-        local->lock[0].ns.parent_layout.locks = NULL;
-        local->lock[0].ns.parent_layout.lk_count = 0;
+    local->lock[0].ns.parent_layout.locks = NULL;
+    local->lock[0].ns.parent_layout.lk_count = 0;
 
-        dht_unlock_inodelk (lock_frame,
-                            lock_local->lock[0].ns.parent_layout.locks,
-                            lock_local->lock[0].ns.parent_layout.lk_count,
-                            dht_selfheal_unlock_cbk);
-        lock_frame = NULL;
+    dht_unlock_inodelk(lock_frame, lock_local->lock[0].ns.parent_layout.locks,
+                       lock_local->lock[0].ns.parent_layout.lk_count,
+                       dht_selfheal_unlock_cbk);
+    lock_frame = NULL;
 
 done:
-        if (invoke_cbk)
-                local->selfheal.dir_cbk (frame, NULL, frame->this, ret,
-                                         local->op_errno, NULL);
-        if (lock_frame != NULL) {
-                DHT_STACK_DESTROY (lock_frame);
-        }
+    if (invoke_cbk)
+        local->selfheal.dir_cbk(frame, NULL, frame->this, ret, local->op_errno,
+                                NULL);
+    if (lock_frame != NULL) {
+        DHT_STACK_DESTROY(lock_frame);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_refresh_layout_done (call_frame_t *frame)
+dht_refresh_layout_done(call_frame_t *frame)
 {
-        int                    ret         = -1;
-        dht_layout_t          *refreshed   = NULL, *heal = NULL;
-        dht_local_t           *local       = NULL;
-        dht_need_heal_t        should_heal = NULL;
-        dht_selfheal_layout_t  healer      = NULL;
+    int ret = -1;
+    dht_layout_t *refreshed = NULL, *heal = NULL;
+    dht_local_t *local = NULL;
+    dht_need_heal_t should_heal = NULL;
+    dht_selfheal_layout_t healer = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        refreshed = local->selfheal.refreshed_layout;
-        heal = local->selfheal.layout;
+    refreshed = local->selfheal.refreshed_layout;
+    heal = local->selfheal.layout;
 
-        healer = local->selfheal.healer;
-        should_heal = local->selfheal.should_heal;
+    healer = local->selfheal.healer;
+    should_heal = local->selfheal.should_heal;
 
-        ret = dht_layout_sort (refreshed);
-        if (ret == -1) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_SORT_FAILED,
-                        "sorting the layout failed");
-                goto err;
-        }
+    ret = dht_layout_sort(refreshed);
+    if (ret == -1) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_SORT_FAILED,
+               "sorting the layout failed");
+        goto err;
+    }
 
-        if (should_heal (frame, &heal, &refreshed)) {
-                healer (frame, &local->loc, heal);
-        } else {
-                local->selfheal.layout = NULL;
-                local->selfheal.refreshed_layout = NULL;
-                local->selfheal.layout = refreshed;
+    if (should_heal(frame, &heal, &refreshed)) {
+        healer(frame, &local->loc, heal);
+    } else {
+        local->selfheal.layout = NULL;
+        local->selfheal.refreshed_layout = NULL;
+        local->selfheal.layout = refreshed;
 
-                dht_layout_unref (frame->this, heal);
+        dht_layout_unref(frame->this, heal);
 
-                dht_selfheal_dir_finish (frame, frame->this, 0, 1);
-        }
+        dht_selfheal_dir_finish(frame, frame->this, 0, 1);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, frame->this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, frame->this, -1, 1);
+    return 0;
 }
 
 int
-dht_refresh_layout_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, inode_t *inode,
-                        struct iatt *stbuf, dict_t *xattr,
-                        struct iatt *postparent)
+dht_refresh_layout_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, inode_t *inode,
+                       struct iatt *stbuf, dict_t *xattr,
+                       struct iatt *postparent)
 {
-        dht_local_t  *local                     = NULL;
-        int           this_call_cnt             = 0;
-        xlator_t     *prev                      = NULL;
-        dht_layout_t *layout                    = NULL;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, err);
-        GF_VALIDATE_OR_GOTO ("dht", this->private, err);
-
-        local = frame->local;
-        prev  = cookie;
-
-        layout = local->selfheal.refreshed_layout;
-
-        LOCK (&frame->lock);
-        {
-                op_ret = dht_layout_merge (this, layout, prev,
-                                           op_ret, op_errno, xattr);
-
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-
-                if (op_ret == -1) {
-                        gf_uuid_unparse (local->loc.gfid, gfid);
-                        local->op_errno = op_errno;
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                DHT_MSG_FILE_LOOKUP_FAILED,
-                                "lookup of %s on %s returned error, gfid: %s",
-                                local->loc.path, prev->name, gfid);
-
-                        goto unlock;
-                }
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    xlator_t *prev = NULL;
+    dht_layout_t *layout = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
 
-                local->op_ret = 0;
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, err);
+    GF_VALIDATE_OR_GOTO("dht", this->private, err);
+
+    local = frame->local;
+    prev = cookie;
+
+    layout = local->selfheal.refreshed_layout;
+
+    LOCK(&frame->lock);
+    {
+        op_ret = dht_layout_merge(this, layout, prev, op_ret, op_errno, xattr);
+
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+
+        if (op_ret == -1) {
+            gf_uuid_unparse(local->loc.gfid, gfid);
+            local->op_errno = op_errno;
+            gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                   DHT_MSG_FILE_LOOKUP_FAILED,
+                   "lookup of %s on %s returned error, gfid: %s",
+                   local->loc.path, prev->name, gfid);
+
+            goto unlock;
         }
-unlock:
-        UNLOCK (&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+        local->op_ret = 0;
+    }
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (is_last_call (this_call_cnt)) {
-                if (local->op_ret == 0) {
-                        local->refresh_layout_done (frame);
-                } else {
-                        goto err;
-                }
+    this_call_cnt = dht_frame_return(frame);
 
+    if (is_last_call(this_call_cnt)) {
+        if (local->op_ret == 0) {
+            local->refresh_layout_done(frame);
+        } else {
+            goto err;
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        if (local) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        }
-        return 0;
+    if (local) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    }
+    return 0;
 }
 
 int
-dht_refresh_layout (call_frame_t *frame)
+dht_refresh_layout(call_frame_t *frame)
 {
-        int          call_cnt                   = 0;
-        int          i                          = 0, ret = -1;
-        dht_conf_t  *conf                       = NULL;
-        dht_local_t *local                      = NULL;
-        xlator_t    *this                       = NULL;
-        char         gfid[GF_UUID_BUF_SIZE]     = {0,};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, out);
-        GF_VALIDATE_OR_GOTO ("dht", frame->local, out);
-
-        this = frame->this;
-        conf = this->private;
-        local = frame->local;
-
-        call_cnt = conf->subvolume_cnt;
-        local->call_cnt = call_cnt;
-        local->op_ret = -1;
-
-        if (local->selfheal.refreshed_layout) {
-                dht_layout_unref (this, local->selfheal.refreshed_layout);
-                local->selfheal.refreshed_layout = NULL;
-        }
-
-        local->selfheal.refreshed_layout = dht_layout_new (this,
-                                                           conf->subvolume_cnt);
-        if (!local->selfheal.refreshed_layout) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "mem allocation for layout failed, path:%s gfid:%s",
-                        local->loc.path, gfid);
-                goto out;
-        }
+    int call_cnt = 0;
+    int i = 0, ret = -1;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("dht", frame, out);
+    GF_VALIDATE_OR_GOTO("dht", frame->local, out);
+
+    this = frame->this;
+    conf = this->private;
+    local = frame->local;
+
+    call_cnt = conf->subvolume_cnt;
+    local->call_cnt = call_cnt;
+    local->op_ret = -1;
+
+    if (local->selfheal.refreshed_layout) {
+        dht_layout_unref(this, local->selfheal.refreshed_layout);
+        local->selfheal.refreshed_layout = NULL;
+    }
+
+    local->selfheal.refreshed_layout = dht_layout_new(this,
+                                                      conf->subvolume_cnt);
+    if (!local->selfheal.refreshed_layout) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "mem allocation for layout failed, path:%s gfid:%s",
+               local->loc.path, gfid);
+        goto out;
+    }
 
-        if (local->xattr != NULL) {
-                dict_del (local->xattr, conf->xattr_name);
-        }
+    if (local->xattr != NULL) {
+        dict_del(local->xattr, conf->xattr_name);
+    }
 
+    if (local->xattr_req == NULL) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        local->xattr_req = dict_new();
         if (local->xattr_req == NULL) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                local->xattr_req = dict_new ();
-                if (local->xattr_req == NULL) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY,
-                                "dict mem allocation failed, path:%s gfid:%s",
-                                local->loc.path, gfid);
-                        goto out;
-                }
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "dict mem allocation failed, path:%s gfid:%s",
+                   local->loc.path, gfid);
+            goto out;
         }
+    }
 
-        if (dict_get (local->xattr_req, conf->xattr_name) == 0) {
-                ret = dict_set_uint32 (local->xattr_req, conf->xattr_name,
-                                       4 * 4);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:key = %s",
-                                local->loc.path, conf->xattr_name);
-        }
+    if (dict_get(local->xattr_req, conf->xattr_name) == 0) {
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: Failed to set dictionary value:key = %s",
+                   local->loc.path, conf->xattr_name);
+    }
 
-        for (i = 0; i < call_cnt; i++) {
-                STACK_WIND_COOKIE (frame, dht_refresh_layout_cbk,
-                                   conf->subvolumes[i], conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->lookup,
-                                   &local->loc, local->xattr_req);
-        }
+    for (i = 0; i < call_cnt; i++) {
+        STACK_WIND_COOKIE(frame, dht_refresh_layout_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->lookup, &local->loc,
+                          local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 out:
-        if (local) {
-                local->refresh_layout_unlock (frame, this, -1, 1);
-        }
-        return 0;
+    if (local) {
+        local->refresh_layout_unlock(frame, this, -1, 1);
+    }
+    return 0;
 }
 
-
 int32_t
-dht_selfheal_layout_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
+dht_selfheal_layout_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t     *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (!local) {
-                goto err;
-        }
+    if (!local) {
+        goto err;
+    }
 
-        if (op_ret < 0) {
-                local->op_errno = op_errno;
-                goto err;
-        }
+    if (op_ret < 0) {
+        local->op_errno = op_errno;
+        goto err;
+    }
 
-        local->refresh_layout_unlock = dht_selfheal_dir_finish;
-        local->refresh_layout_done = dht_refresh_layout_done;
+    local->refresh_layout_unlock = dht_selfheal_dir_finish;
+    local->refresh_layout_done = dht_refresh_layout_done;
 
-        dht_refresh_layout (frame);
-        return 0;
+    dht_refresh_layout(frame);
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-
 gf_boolean_t
-dht_should_heal_layout (call_frame_t *frame, dht_layout_t **heal,
-                        dht_layout_t **ondisk)
+dht_should_heal_layout(call_frame_t *frame, dht_layout_t **heal,
+                       dht_layout_t **ondisk)
 {
-        gf_boolean_t  fixit = _gf_true;
-        dht_local_t  *local = NULL;
-        int           ret   = -1, heal_missing_dirs = 0;
-
-        local = frame->local;
-
-        if ((heal == NULL) || (*heal == NULL) || (ondisk == NULL)
-            || (*ondisk == NULL))
-                goto out;
-
-        ret = dht_layout_anomalies (frame->this, &local->loc, *ondisk,
-                                    &local->selfheal.hole_cnt,
-                                    &local->selfheal.overlaps_cnt,
-                                    &local->selfheal.missing_cnt,
-                                    &local->selfheal.down,
-                                    &local->selfheal.misc, NULL);
-
-        if (ret < 0)
-                goto out;
-
-        /* Directories might've been created as part of this self-heal. We've to
-         * sync non-layout xattrs and set range 0-0 on new directories
+    gf_boolean_t fixit = _gf_true;
+    dht_local_t *local = NULL;
+    int ret = -1, heal_missing_dirs = 0;
+
+    local = frame->local;
+
+    if ((heal == NULL) || (*heal == NULL) || (ondisk == NULL) ||
+        (*ondisk == NULL))
+        goto out;
+
+    ret = dht_layout_anomalies(
+        frame->this, &local->loc, *ondisk, &local->selfheal.hole_cnt,
+        &local->selfheal.overlaps_cnt, &local->selfheal.missing_cnt,
+        &local->selfheal.down, &local->selfheal.misc, NULL);
+
+    if (ret < 0)
+        goto out;
+
+    /* Directories might've been created as part of this self-heal. We've to
+     * sync non-layout xattrs and set range 0-0 on new directories
+     */
+    heal_missing_dirs = local->selfheal.force_mkdir
+                            ? local->selfheal.force_mkdir
+                            : dht_layout_missing_dirs(*heal);
+
+    if ((local->selfheal.hole_cnt == 0) &&
+        (local->selfheal.overlaps_cnt == 0) && heal_missing_dirs) {
+        dht_layout_t *tmp = NULL;
+
+        /* Just added a brick and need to set 0-0 range on this brick.
+         * But ondisk layout is well-formed. So, swap layouts "heal" and
+         * "ondisk". Now "ondisk" layout will be used for healing
+         * xattrs. If there are any non-participating subvols in
+         * "ondisk" layout, dht_selfheal_dir_xattr_persubvol will set
+         * 0-0 and non-layout xattrs. This way we won't end up in
+         * "corrupting" already set and well-formed "ondisk" layout.
          */
-        heal_missing_dirs = local->selfheal.force_mkdir
-                ? local->selfheal.force_mkdir : dht_layout_missing_dirs (*heal);
-
-        if ((local->selfheal.hole_cnt == 0)
-            && (local->selfheal.overlaps_cnt == 0) && heal_missing_dirs) {
-                dht_layout_t *tmp = NULL;
-
-                /* Just added a brick and need to set 0-0 range on this brick.
-                 * But ondisk layout is well-formed. So, swap layouts "heal" and
-                 * "ondisk". Now "ondisk" layout will be used for healing
-                 * xattrs. If there are any non-participating subvols in
-                 * "ondisk" layout, dht_selfheal_dir_xattr_persubvol will set
-                 * 0-0 and non-layout xattrs. This way we won't end up in
-                 * "corrupting" already set and well-formed "ondisk" layout.
-                 */
-                tmp = *heal;
-                *heal = *ondisk;
-                *ondisk = tmp;
-
-                /* Current selfheal code, heals non-layout xattrs only after
-                 * an add-brick. In fact non-layout xattrs are considered as
-                 * secondary citizens which are healed only if layout xattrs
-                 * need to be healed. This is wrong, since for eg., quota can be
-                 * set when layout is well-formed, but a node is down. Also,
-                 * just for healing non-layout xattrs, we don't need locking.
-                 * This issue is _NOT FIXED_ by this patch.
-                 */
-        }
+        tmp = *heal;
+        *heal = *ondisk;
+        *ondisk = tmp;
+
+        /* Current selfheal code, heals non-layout xattrs only after
+         * an add-brick. In fact non-layout xattrs are considered as
+         * secondary citizens which are healed only if layout xattrs
+         * need to be healed. This is wrong, since for eg., quota can be
+         * set when layout is well-formed, but a node is down. Also,
+         * just for healing non-layout xattrs, we don't need locking.
+         * This issue is _NOT FIXED_ by this patch.
+         */
+    }
 
-        fixit = (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt
-                 || heal_missing_dirs);
+    fixit = (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt ||
+             heal_missing_dirs);
 
 out:
-        return fixit;
+    return fixit;
 }
 
 int
-dht_layout_span (dht_layout_t *layout)
+dht_layout_span(dht_layout_t *layout)
 {
-        int i = 0, count = 0;
+    int i = 0, count = 0;
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err)
-                        continue;
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err)
+            continue;
 
-                if (layout->list[i].start != layout->list[i].stop)
-                        count++;
-        }
+        if (layout->list[i].start != layout->list[i].stop)
+            count++;
+    }
 
-        return count;
+    return count;
 }
 
 int
-dht_decommissioned_bricks_in_layout (xlator_t *this, dht_layout_t *layout)
+dht_decommissioned_bricks_in_layout(xlator_t *this, dht_layout_t *layout)
 {
-        dht_conf_t *conf  = NULL;
-        int         count = 0, i = 0, j = 0;
+    dht_conf_t *conf = NULL;
+    int count = 0, i = 0, j = 0;
 
-        if ((this == NULL) || (layout == NULL))
-                goto out;
+    if ((this == NULL) || (layout == NULL))
+        goto out;
 
-        conf = this->private;
+    conf = this->private;
 
-        for (i = 0; i < layout->cnt; i++) {
-                for (j = 0; j < conf->subvolume_cnt; j++) {
-                        if (conf->decommissioned_bricks[j] &&
-                            conf->decommissioned_bricks[j]
-                            == layout->list[i].xlator) {
-                                count++;
-                        }
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        for (j = 0; j < conf->subvolume_cnt; j++) {
+            if (conf->decommissioned_bricks[j] &&
+                conf->decommissioned_bricks[j] == layout->list[i].xlator) {
+                count++;
+            }
         }
+    }
 
 out:
-        return count;
+    return count;
 }
 
 dht_distribution_type_t
-dht_distribution_type (xlator_t *this, dht_layout_t *layout)
+dht_distribution_type(xlator_t *this, dht_layout_t *layout)
 {
-        dht_distribution_type_t type        = GF_DHT_EQUAL_DISTRIBUTION;
-        int                     i           = 0;
-        uint32_t                start_range = 0, range = 0, diff = 0;
+    dht_distribution_type_t type = GF_DHT_EQUAL_DISTRIBUTION;
+    int i = 0;
+    uint32_t start_range = 0, range = 0, diff = 0;
 
-        if ((this == NULL) || (layout == NULL) || (layout->cnt < 1)) {
-                goto out;
-        }
+    if ((this == NULL) || (layout == NULL) || (layout->cnt < 1)) {
+        goto out;
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (start_range == 0) {
-                        start_range = layout->list[i].stop
-                                - layout->list[i].start;
-                        continue;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (start_range == 0) {
+            start_range = layout->list[i].stop - layout->list[i].start;
+            continue;
+        }
 
-                range = layout->list[i].stop - layout->list[i].start;
-                diff = (range >= start_range)
-                        ? range - start_range
-                        : start_range - range;
+        range = layout->list[i].stop - layout->list[i].start;
+        diff = (range >= start_range) ? range - start_range
+                                      : start_range - range;
 
-                if ((range != 0) && (diff > layout->cnt)) {
-                        type = GF_DHT_WEIGHTED_DISTRIBUTION;
-                        break;
-                }
+        if ((range != 0) && (diff > layout->cnt)) {
+            type = GF_DHT_WEIGHTED_DISTRIBUTION;
+            break;
         }
+    }
 
 out:
-        return type;
+    return type;
 }
 
 gf_boolean_t
-dht_should_fix_layout (call_frame_t *frame, dht_layout_t **inmem,
-                       dht_layout_t **ondisk)
+dht_should_fix_layout(call_frame_t *frame, dht_layout_t **inmem,
+                      dht_layout_t **ondisk)
 {
-        gf_boolean_t             fixit                 = _gf_true;
-
-        dht_local_t             *local                 = NULL;
-        int                      layout_span           = 0;
-        int                      decommissioned_bricks = 0;
-        int                      ret                   = 0;
-        dht_conf_t              *conf                  = NULL;
-        dht_distribution_type_t  inmem_dist_type       = 0;
-        dht_distribution_type_t  ondisk_dist_type      = 0;
-
-        conf = frame->this->private;
-
-        local = frame->local;
-
-        if ((inmem == NULL) || (*inmem == NULL) || (ondisk == NULL)
-            || (*ondisk == NULL))
-                goto out;
-
-        ret = dht_layout_anomalies (frame->this, &local->loc, *ondisk,
-                                    &local->selfheal.hole_cnt,
-                                    &local->selfheal.overlaps_cnt, NULL,
-                                    &local->selfheal.down,
-                                    &local->selfheal.misc, NULL);
-        if (ret < 0) {
-                fixit = _gf_false;
-                goto out;
-        }
-
-        if (local->selfheal.down || local->selfheal.misc) {
-                fixit = _gf_false;
-                goto out;
-        }
-
-        if (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt)
-                goto out;
-
-        /* If commit hashes are being updated, let it through */
-        if ((*inmem)->commit_hash != (*ondisk)->commit_hash)
-                goto out;
-
-        layout_span = dht_layout_span (*ondisk);
-
-        decommissioned_bricks
-                = dht_decommissioned_bricks_in_layout (frame->this,
-                                                       *ondisk);
-        inmem_dist_type = dht_distribution_type (frame->this, *inmem);
-        ondisk_dist_type = dht_distribution_type (frame->this, *ondisk);
-
-        if ((decommissioned_bricks == 0)
-            && (layout_span == (conf->subvolume_cnt
-                                - conf->decommission_subvols_cnt))
-            && (inmem_dist_type == ondisk_dist_type))
-                fixit = _gf_false;
+    gf_boolean_t fixit = _gf_true;
+
+    dht_local_t *local = NULL;
+    int layout_span = 0;
+    int decommissioned_bricks = 0;
+    int ret = 0;
+    dht_conf_t *conf = NULL;
+    dht_distribution_type_t inmem_dist_type = 0;
+    dht_distribution_type_t ondisk_dist_type = 0;
+
+    conf = frame->this->private;
+
+    local = frame->local;
+
+    if ((inmem == NULL) || (*inmem == NULL) || (ondisk == NULL) ||
+        (*ondisk == NULL))
+        goto out;
+
+    ret = dht_layout_anomalies(
+        frame->this, &local->loc, *ondisk, &local->selfheal.hole_cnt,
+        &local->selfheal.overlaps_cnt, NULL, &local->selfheal.down,
+        &local->selfheal.misc, NULL);
+    if (ret < 0) {
+        fixit = _gf_false;
+        goto out;
+    }
+
+    if (local->selfheal.down || local->selfheal.misc) {
+        fixit = _gf_false;
+        goto out;
+    }
+
+    if (local->selfheal.hole_cnt || local->selfheal.overlaps_cnt)
+        goto out;
+
+    /* If commit hashes are being updated, let it through */
+    if ((*inmem)->commit_hash != (*ondisk)->commit_hash)
+        goto out;
+
+    layout_span = dht_layout_span(*ondisk);
+
+    decommissioned_bricks = dht_decommissioned_bricks_in_layout(frame->this,
+                                                                *ondisk);
+    inmem_dist_type = dht_distribution_type(frame->this, *inmem);
+    ondisk_dist_type = dht_distribution_type(frame->this, *ondisk);
+
+    if ((decommissioned_bricks == 0) &&
+        (layout_span ==
+         (conf->subvolume_cnt - conf->decommission_subvols_cnt)) &&
+        (inmem_dist_type == ondisk_dist_type))
+        fixit = _gf_false;
 
 out:
 
-        return fixit;
+    return fixit;
 }
 
 int
-dht_selfheal_layout_lock (call_frame_t *frame, dht_layout_t *layout,
-                          gf_boolean_t newdir,
-                          dht_selfheal_layout_t healer,
-                          dht_need_heal_t should_heal)
+dht_selfheal_layout_lock(call_frame_t *frame, dht_layout_t *layout,
+                         gf_boolean_t newdir, dht_selfheal_layout_t healer,
+                         dht_need_heal_t should_heal)
 {
-        dht_local_t   *local    = NULL;
-        int            count    = 1, ret = -1, i = 0;
-        dht_lock_t   **lk_array = NULL;
-        dht_conf_t    *conf     = NULL;
-        dht_layout_t  *tmp      = NULL;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
-
-        local = frame->local;
-
-        conf = frame->this->private;
-
-        local->selfheal.healer = healer;
-        local->selfheal.should_heal = should_heal;
-
-        tmp = local->selfheal.layout;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
-        dht_layout_unref (frame->this, tmp);
-
-        if (!newdir) {
-                count = conf->subvolume_cnt;
-
-                lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                                      gf_common_mt_char);
-                if (lk_array == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg ("dht", GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path: %s", gfid,
-                                local->loc.path);
-                        goto err;
-                }
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0;
+    dht_lock_t **lk_array = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *tmp = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
 
-                for (i = 0; i < count; i++) {
-                        lk_array[i] = dht_lock_new (frame->this,
-                                                    conf->subvolumes[i],
-                                                    &local->loc, F_WRLCK,
-                                                    DHT_LAYOUT_HEAL_DOMAIN,
-                                                    NULL,
-                                                    FAIL_ON_ANY_ERROR);
-                        if (lk_array[i] == NULL) {
-                                gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                                gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                        DHT_MSG_NO_MEMORY, "mem allocation "
-                                        "failed for lk_array, gfid:%s path:%s",
-                                        gfid, local->loc.path);
-                                goto err;
-                        }
-                }
-        } else {
-                count = 1;
-                lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                                      gf_common_mt_char);
-                if (lk_array == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path:%s",
-                                gfid, local->loc.path);
-                        goto err;
-                }
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
 
-                lk_array[0] = dht_lock_new (frame->this, local->hashed_subvol,
-                                            &local->loc, F_WRLCK,
-                                            DHT_LAYOUT_HEAL_DOMAIN, NULL,
-                                            FAIL_ON_ANY_ERROR);
-                if (lk_array[0] == NULL) {
-                        gf_uuid_unparse (local->stbuf.ia_gfid, gfid);
-                        gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY, "mem allocation failed for "
-                                "lk_array, gfid:%s path:%s", gfid,
-                                local->loc.path);
-                        goto err;
-                }
-        }
+    local = frame->local;
 
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = count;
+    conf = frame->this->private;
 
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    dht_selfheal_layout_lock_cbk);
-        if (ret < 0) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-                goto err;
+    local->selfheal.healer = healer;
+    local->selfheal.should_heal = should_heal;
+
+    tmp = local->selfheal.layout;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
+    dht_layout_unref(frame->this, tmp);
+
+    if (!newdir) {
+        count = conf->subvolume_cnt;
+
+        lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+        if (lk_array == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_msg("dht", GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "mem allocation failed for "
+                   "lk_array, gfid:%s path: %s",
+                   gfid, local->loc.path);
+            goto err;
         }
 
-        return 0;
+        for (i = 0; i < count; i++) {
+            lk_array[i] = dht_lock_new(
+                frame->this, conf->subvolumes[i], &local->loc, F_WRLCK,
+                DHT_LAYOUT_HEAL_DOMAIN, NULL, FAIL_ON_ANY_ERROR);
+            if (lk_array[i] == NULL) {
+                gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+                gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                       "mem allocation "
+                       "failed for lk_array, gfid:%s path:%s",
+                       gfid, local->loc.path);
+                goto err;
+            }
+        }
+    } else {
+        count = 1;
+        lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+        if (lk_array == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "mem allocation failed for "
+                   "lk_array, gfid:%s path:%s",
+                   gfid, local->loc.path);
+            goto err;
+        }
+
+        lk_array[0] = dht_lock_new(frame->this, local->hashed_subvol,
+                                   &local->loc, F_WRLCK, DHT_LAYOUT_HEAL_DOMAIN,
+                                   NULL, FAIL_ON_ANY_ERROR);
+        if (lk_array[0] == NULL) {
+            gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+            gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "mem allocation failed for "
+                   "lk_array, gfid:%s path:%s",
+                   gfid, local->loc.path);
+            goto err;
+        }
+    }
+
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = count;
+
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_selfheal_layout_lock_cbk);
+    if (ret < 0) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
 
 int
-dht_selfheal_dir_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int op_ret, int op_errno, dict_t *xdata)
+dht_selfheal_dir_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, dict_t *xdata)
 {
-        dht_local_t  *local                     = NULL;
-        xlator_t     *subvol                    = NULL;
-        struct iatt  *stbuf                     = NULL;
-        int           i                         = 0;
-        int           ret                       = 0;
-        dht_layout_t *layout                    = NULL;
-        int           err                       = 0;
-        int           this_call_cnt             = 0;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0};
-
-        local = frame->local;
-        layout = local->selfheal.layout;
-        subvol = cookie;
-
-        if (op_ret == 0) {
-                err = 0;
-        } else {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "layout setxattr failed on %s, path:%s gfid:%s",
-                        subvol->name, local->loc.path, gfid);
-                err = op_errno;
-        }
-
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
-        if (ret < 0) {
-                gf_uuid_unparse (local->loc.gfid, gfid);
-                gf_msg_debug (this->name, 0, "key = %s not present in dict"
-                              ", path:%s gfid:%s", DHT_IATT_IN_XDATA_KEY,
-                              local->loc.path, gfid);
-        }
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    struct iatt *stbuf = NULL;
+    int i = 0;
+    int ret = 0;
+    dht_layout_t *layout = NULL;
+    int err = 0;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    layout = local->selfheal.layout;
+    subvol = cookie;
+
+    if (op_ret == 0) {
+        err = 0;
+    } else {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, op_errno,
+               DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+               "layout setxattr failed on %s, path:%s gfid:%s", subvol->name,
+               local->loc.path, gfid);
+        err = op_errno;
+    }
+
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+    if (ret < 0) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg_debug(this->name, 0,
+                     "key = %s not present in dict"
+                     ", path:%s gfid:%s",
+                     DHT_IATT_IN_XDATA_KEY, local->loc.path, gfid);
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].xlator == subvol) {
-                        layout->list[i].err = err;
-                        break;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].xlator == subvol) {
+            layout->list[i].err = err;
+            break;
         }
+    }
 
-        LOCK (&frame->lock);
-        {
-                dht_iatt_merge (this, &local->stbuf, stbuf);
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        dht_iatt_merge(this, &local->stbuf, stbuf);
+    }
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_selfheal_dir_finish (frame, this, 0, 1);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_selfheal_dir_finish(frame, this, 0, 1);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* Code is required to set user xattr to local->xattr
-*/
+ */
 int
-dht_set_user_xattr (dict_t *dict, char *k, data_t *v, void *data)
+dht_set_user_xattr(dict_t *dict, char *k, data_t *v, void *data)
 {
-        dict_t          *set_xattr          = data;
-        int              ret                = -1;
+    dict_t *set_xattr = data;
+    int ret = -1;
 
-        ret = dict_set (set_xattr, k, v);
-        return ret;
+    ret = dict_set(set_xattr, k, v);
+    return ret;
 }
 
-
 int
-dht_selfheal_dir_xattr_persubvol (call_frame_t *frame, loc_t *loc,
-                                  dht_layout_t *layout, int i,
-                                  xlator_t *req_subvol)
+dht_selfheal_dir_xattr_persubvol(call_frame_t *frame, loc_t *loc,
+                                 dht_layout_t *layout, int i,
+                                 xlator_t *req_subvol)
 {
-        xlator_t          *subvol = NULL;
-        dict_t            *xattr = NULL;
-        dict_t            *xdata = NULL;
-        int                ret = 0;
-        xlator_t          *this = NULL;
-        int32_t           *disk_layout = NULL;
-        dht_local_t       *local = NULL;
-        dht_conf_t        *conf = NULL;
-        data_t            *data = NULL;
-        char              gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local = frame->local;
-        if (req_subvol)
-                subvol = req_subvol;
-        else
-                subvol = layout->list[i].xlator;
-        this = frame->this;
-
-        GF_VALIDATE_OR_GOTO ("", this, err);
-        GF_VALIDATE_OR_GOTO (this->name, layout, err);
-        GF_VALIDATE_OR_GOTO (this->name, local, err);
-        GF_VALIDATE_OR_GOTO (this->name, subvol, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        xattr = dict_new ();
-        if (!xattr) {
-                goto err;
-        }
-
-        xdata = dict_new ();
-        if (!xdata)
-                goto err;
-
-        ret = dict_set_str (xdata, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        GLUSTERFS_INTERNAL_FOP_KEY, gfid);
-                goto err;
-        }
-
-        ret = dict_set_int8 (xdata, DHT_IATT_IN_XDATA_KEY, 1);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                        "%s: Failed to set dictionary value: key = %s,"
-                        " gfid = %s", loc->path,
-                        DHT_IATT_IN_XDATA_KEY, gfid);
-                goto err;
-        }
-
-        gf_uuid_unparse(loc->inode->gfid, gfid);
-
-        ret = dht_disk_layout_extract (this, layout, i, &disk_layout);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory self heal xattr failed:"
-                        " %s: (subvol %s) Failed to extract disk layout,"
-                        " gfid = %s", loc->path, subvol->name, gfid);
-                goto err;
-        }
-
-        ret = dict_set_bin (xattr, conf->xattr_name, disk_layout, 4 * 4);
-        if (ret == -1) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory self heal xattr failed:"
-                        "%s: (subvol %s) Failed to set xattr dictionary,"
-                        " gfid = %s", loc->path, subvol->name, gfid);
-                goto err;
-        }
-        disk_layout = NULL;
-
-        gf_msg_trace (this->name, 0,
-                      "setting hash range %u - %u (type %d) on subvolume %s"
-                      " for %s", layout->list[i].start, layout->list[i].stop,
-                      layout->type, subvol->name, loc->path);
-
-        if (local->xattr) {
-                data = dict_get (local->xattr, QUOTA_LIMIT_KEY);
-                if (data) {
-                        ret = dict_add (xattr, QUOTA_LIMIT_KEY, data);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "%s: Failed to set dictionary value:"
-                                        " key = %s",
-                                        loc->path, QUOTA_LIMIT_KEY);
-                        }
-                }
-                data = dict_get (local->xattr, QUOTA_LIMIT_OBJECTS_KEY);
-                if (data) {
-                        ret = dict_add (xattr, QUOTA_LIMIT_OBJECTS_KEY, data);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "%s: Failed to set dictionary value:"
-                                        " key = %s",
-                                        loc->path, QUOTA_LIMIT_OBJECTS_KEY);
-                        }
-                }
-        }
-
-        if (!gf_uuid_is_null (local->gfid))
-                gf_uuid_copy (loc->gfid, local->gfid);
-
-        STACK_WIND_COOKIE (frame, dht_selfheal_dir_xattr_cbk,
-                    (void *) subvol, subvol, subvol->fops->setxattr,
-                    loc, xattr, 0, xdata);
-
-        dict_unref (xattr);
-        dict_unref (xdata);
-
-        return 0;
+    xlator_t *subvol = NULL;
+    dict_t *xattr = NULL;
+    dict_t *xdata = NULL;
+    int ret = 0;
+    xlator_t *this = NULL;
+    int32_t *disk_layout = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    data_t *data = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    if (req_subvol)
+        subvol = req_subvol;
+    else
+        subvol = layout->list[i].xlator;
+    this = frame->this;
+
+    GF_VALIDATE_OR_GOTO("", this, err);
+    GF_VALIDATE_OR_GOTO(this->name, layout, err);
+    GF_VALIDATE_OR_GOTO(this->name, local, err);
+    GF_VALIDATE_OR_GOTO(this->name, subvol, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    xattr = dict_new();
+    if (!xattr) {
+        goto err;
+    }
+
+    xdata = dict_new();
+    if (!xdata)
+        goto err;
+
+    ret = dict_set_str(xdata, GLUSTERFS_INTERNAL_FOP_KEY, "yes");
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: Failed to set dictionary value: key = %s,"
+               " gfid = %s",
+               loc->path, GLUSTERFS_INTERNAL_FOP_KEY, gfid);
+        goto err;
+    }
+
+    ret = dict_set_int8(xdata, DHT_IATT_IN_XDATA_KEY, 1);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "%s: Failed to set dictionary value: key = %s,"
+               " gfid = %s",
+               loc->path, DHT_IATT_IN_XDATA_KEY, gfid);
+        goto err;
+    }
+
+    gf_uuid_unparse(loc->inode->gfid, gfid);
+
+    ret = dht_disk_layout_extract(this, layout, i, &disk_layout);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+               "Directory self heal xattr failed:"
+               " %s: (subvol %s) Failed to extract disk layout,"
+               " gfid = %s",
+               loc->path, subvol->name, gfid);
+        goto err;
+    }
+
+    ret = dict_set_bin(xattr, conf->xattr_name, disk_layout, 4 * 4);
+    if (ret == -1) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+               "Directory self heal xattr failed:"
+               "%s: (subvol %s) Failed to set xattr dictionary,"
+               " gfid = %s",
+               loc->path, subvol->name, gfid);
+        goto err;
+    }
+    disk_layout = NULL;
+
+    gf_msg_trace(this->name, 0,
+                 "setting hash range %u - %u (type %d) on subvolume %s"
+                 " for %s",
+                 layout->list[i].start, layout->list[i].stop, layout->type,
+                 subvol->name, loc->path);
+
+    if (local->xattr) {
+        data = dict_get(local->xattr, QUOTA_LIMIT_KEY);
+        if (data) {
+            ret = dict_add(xattr, QUOTA_LIMIT_KEY, data);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                       "%s: Failed to set dictionary value:"
+                       " key = %s",
+                       loc->path, QUOTA_LIMIT_KEY);
+            }
+        }
+        data = dict_get(local->xattr, QUOTA_LIMIT_OBJECTS_KEY);
+        if (data) {
+            ret = dict_add(xattr, QUOTA_LIMIT_OBJECTS_KEY, data);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                       "%s: Failed to set dictionary value:"
+                       " key = %s",
+                       loc->path, QUOTA_LIMIT_OBJECTS_KEY);
+            }
+        }
+    }
+
+    if (!gf_uuid_is_null(local->gfid))
+        gf_uuid_copy(loc->gfid, local->gfid);
+
+    STACK_WIND_COOKIE(frame, dht_selfheal_dir_xattr_cbk, (void *)subvol, subvol,
+                      subvol->fops->setxattr, loc, xattr, 0, xdata);
+
+    dict_unref(xattr);
+    dict_unref(xdata);
+
+    return 0;
 
 err:
-        if (xattr)
-                dict_unref (xattr);
-        if (xdata)
-                dict_unref (xdata);
+    if (xattr)
+        dict_unref(xattr);
+    if (xdata)
+        dict_unref(xdata);
 
-        GF_FREE (disk_layout);
+    GF_FREE(disk_layout);
 
-        dht_selfheal_dir_xattr_cbk (frame, (void *) subvol, frame->this,
-                                    -1, ENOMEM, NULL);
-        return 0;
+    dht_selfheal_dir_xattr_cbk(frame, (void *)subvol, frame->this, -1, ENOMEM,
+                               NULL);
+    return 0;
 }
 
 int
-dht_fix_dir_xattr (call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
+dht_fix_dir_xattr(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local = NULL;
-        int          i = 0;
-        int          count = 0;
-        xlator_t    *this = NULL;
-        dht_conf_t  *conf = NULL;
-        dht_layout_t *dummy = NULL;
-
-        local = frame->local;
-        this = frame->this;
-        conf = this->private;
-
-        gf_msg_debug (this->name, 0,
-                      "%s: Writing the new range for all subvolumes",
-                      loc->path);
-
-        local->call_cnt = count = conf->subvolume_cnt;
-
-        if (gf_log_get_loglevel () >= GF_LOG_DEBUG)
-                dht_log_new_layout_for_dir_selfheal (this, loc, layout);
-
-        for (i = 0; i < layout->cnt; i++) {
-                dht_selfheal_dir_xattr_persubvol (frame, loc, layout, i, NULL);
-
-                if (--count == 0)
-                        goto out;
-        }
-        /* if we are here, subvolcount > layout_count. subvols-per-directory
-         * option might be set here. We need to clear out layout from the
-         * non-participating subvolumes, else it will result in overlaps */
-        dummy = dht_layout_new (this, 1);
-        if (!dummy)
-                goto out;
-        dummy->commit_hash = layout->commit_hash;
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        if (--count == 0)
-                                break;
-                }
-        }
-
-        dht_layout_unref (this, dummy);
+    dht_local_t *local = NULL;
+    int i = 0;
+    int count = 0;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *dummy = NULL;
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    gf_msg_debug(this->name, 0, "%s: Writing the new range for all subvolumes",
+                 loc->path);
+
+    local->call_cnt = count = conf->subvolume_cnt;
+
+    if (gf_log_get_loglevel() >= GF_LOG_DEBUG)
+        dht_log_new_layout_for_dir_selfheal(this, loc, layout);
+
+    for (i = 0; i < layout->cnt; i++) {
+        dht_selfheal_dir_xattr_persubvol(frame, loc, layout, i, NULL);
+
+        if (--count == 0)
+            goto out;
+    }
+    /* if we are here, subvolcount > layout_count. subvols-per-directory
+     * option might be set here. We need to clear out layout from the
+     * non-participating subvolumes, else it will result in overlaps */
+    dummy = dht_layout_new(this, 1);
+    if (!dummy)
+        goto out;
+    dummy->commit_hash = layout->commit_hash;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            dht_selfheal_dir_xattr_persubvol(frame, loc, dummy, 0,
+                                             conf->subvolumes[i]);
+            if (--count == 0)
+                break;
+        }
+    }
+
+    dht_layout_unref(this, dummy);
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_selfheal_dir_xattr (call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
+dht_selfheal_dir_xattr(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local = NULL;
-        int          missing_xattr = 0;
-        int          i = 0;
-        xlator_t    *this = NULL;
-        dht_conf_t   *conf = NULL;
-        dht_layout_t *dummy = NULL;
-        char          gfid[GF_UUID_BUF_SIZE] = {0,};
-
-        local = frame->local;
-        this = frame->this;
-        conf = this->private;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop) {
-                        /* err != -1 would mean xattr present on the directory
-                         * or the directory is non existent.
-                         * !layout->list[i].stop would mean layout absent
-                         */
-
-                        continue;
-                }
-                missing_xattr++;
-        }
-        /* Also account for subvolumes with no-layout. Used for zero'ing out
-         * the layouts and for setting quota key's if present */
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        missing_xattr++;
-                }
-        }
-        gf_msg_trace (this->name, 0,
-                      "%d subvolumes missing xattr for %s",
-                      missing_xattr, loc->path);
-
-        if (missing_xattr == 0) {
-                dht_selfheal_dir_finish (frame, this, 0, 1);
-                return 0;
-        }
-
-        local->call_cnt = missing_xattr;
-
-        if (gf_log_get_loglevel () >= GF_LOG_DEBUG)
-                dht_log_new_layout_for_dir_selfheal (this, loc, layout);
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err != -1 || !layout->list[i].stop)
-                        continue;
-
-                dht_selfheal_dir_xattr_persubvol (frame, loc, layout, i, NULL);
-
-                if (--missing_xattr == 0)
-                        break;
-        }
-        dummy = dht_layout_new (this, 1);
-        if (!dummy) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "failed to allocate dummy layout, path:%s gfid:%s",
-                        loc->path, gfid);
-                goto out;
-        }
-        for (i = 0; i < conf->subvolume_cnt && missing_xattr; i++) {
-                if (_gf_false ==
-                    dht_is_subvol_in_layout (layout, conf->subvolumes[i])) {
-                        dht_selfheal_dir_xattr_persubvol (frame, loc, dummy, 0,
-                                                          conf->subvolumes[i]);
-                        missing_xattr--;
-                }
-        }
-
-        dht_layout_unref (this, dummy);
-out:
+    dht_local_t *local = NULL;
+    int missing_xattr = 0;
+    int i = 0;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *dummy = NULL;
+    char gfid[GF_UUID_BUF_SIZE] = {
+        0,
+    };
+
+    local = frame->local;
+    this = frame->this;
+    conf = this->private;
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err != -1 || !layout->list[i].stop) {
+            /* err != -1 would mean xattr present on the directory
+             * or the directory is non existent.
+             * !layout->list[i].stop would mean layout absent
+             */
+
+            continue;
+        }
+        missing_xattr++;
+    }
+    /* Also account for subvolumes with no-layout. Used for zero'ing out
+     * the layouts and for setting quota key's if present */
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            missing_xattr++;
+        }
+    }
+    gf_msg_trace(this->name, 0, "%d subvolumes missing xattr for %s",
+                 missing_xattr, loc->path);
+
+    if (missing_xattr == 0) {
+        dht_selfheal_dir_finish(frame, this, 0, 1);
         return 0;
+    }
+
+    local->call_cnt = missing_xattr;
+
+    if (gf_log_get_loglevel() >= GF_LOG_DEBUG)
+        dht_log_new_layout_for_dir_selfheal(this, loc, layout);
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err != -1 || !layout->list[i].stop)
+            continue;
+
+        dht_selfheal_dir_xattr_persubvol(frame, loc, layout, i, NULL);
+
+        if (--missing_xattr == 0)
+            break;
+    }
+    dummy = dht_layout_new(this, 1);
+    if (!dummy) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "failed to allocate dummy layout, path:%s gfid:%s", loc->path,
+               gfid);
+        goto out;
+    }
+    for (i = 0; i < conf->subvolume_cnt && missing_xattr; i++) {
+        if (_gf_false == dht_is_subvol_in_layout(layout, conf->subvolumes[i])) {
+            dht_selfheal_dir_xattr_persubvol(frame, loc, dummy, 0,
+                                             conf->subvolumes[i]);
+            missing_xattr--;
+        }
+    }
+
+    dht_layout_unref(this, dummy);
+out:
+    return 0;
 }
 
 gf_boolean_t
-dht_is_subvol_part_of_layout (dht_layout_t *layout, xlator_t *xlator)
+dht_is_subvol_part_of_layout(dht_layout_t *layout, xlator_t *xlator)
 {
-        int               i = 0;
-        gf_boolean_t    ret = _gf_false;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (!strcmp (layout->list[i].xlator->name, xlator->name)) {
-                        ret = _gf_true;
-                        break;
+    int i = 0;
+    gf_boolean_t ret = _gf_false;
 
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        if (!strcmp(layout->list[i].xlator->name, xlator->name)) {
+            ret = _gf_true;
+            break;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-dht_layout_index_from_conf (dht_layout_t *layout, xlator_t *xlator)
+dht_layout_index_from_conf(dht_layout_t *layout, xlator_t *xlator)
 {
-        int i = -1;
-        int j = 0;
+    int i = -1;
+    int j = 0;
 
-        for (j = 0; j < layout->cnt; j++) {
-                if (!strcmp (layout->list[j].xlator->name, xlator->name)) {
-                        i = j;
-                        break;
-                }
+    for (j = 0; j < layout->cnt; j++) {
+        if (!strcmp(layout->list[j].xlator->name, xlator->name)) {
+            i = j;
+            break;
         }
+    }
 
-        return i;
+    return i;
 }
 
 int
-dht_selfheal_dir_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int op_ret, int op_errno, struct iatt *statpre,
-                              struct iatt *statpost, dict_t *xdata)
+dht_selfheal_dir_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, struct iatt *statpre,
+                             struct iatt *statpost, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
-        int            this_call_cnt = 0, ret = -1;
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    int this_call_cnt = 0, ret = -1;
 
-        local  = frame->local;
-        layout = local->selfheal.layout;
+    local = frame->local;
+    layout = local->selfheal.layout;
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                if (!local->heal_layout) {
-                        gf_msg_trace (this->name, 0,
-                                      "Skip heal layout for %s gfid = %s ",
-                                      local->loc.path, uuid_utoa(local->gfid));
+    if (is_last_call(this_call_cnt)) {
+        if (!local->heal_layout) {
+            gf_msg_trace(this->name, 0, "Skip heal layout for %s gfid = %s ",
+                         local->loc.path, uuid_utoa(local->gfid));
 
-                        dht_selfheal_dir_finish (frame, this, 0, 1);
-                        return 0;
-                }
-                ret = dht_selfheal_layout_lock (frame, layout, _gf_false,
-                                                dht_selfheal_dir_xattr,
-                                                dht_should_heal_layout);
+            dht_selfheal_dir_finish(frame, this, 0, 1);
+            return 0;
+        }
+        ret = dht_selfheal_layout_lock(frame, layout, _gf_false,
+                                       dht_selfheal_dir_xattr,
+                                       dht_should_heal_layout);
 
-                if (ret < 0) {
-                        dht_selfheal_dir_finish (frame, this, -1, 1);
-                }
+        if (ret < 0) {
+            dht_selfheal_dir_finish(frame, this, -1, 1);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-dht_selfheal_dir_setattr (call_frame_t *frame, loc_t *loc, struct iatt *stbuf,
-                          int32_t valid, dht_layout_t *layout)
+dht_selfheal_dir_setattr(call_frame_t *frame, loc_t *loc, struct iatt *stbuf,
+                         int32_t valid, dht_layout_t *layout)
 {
-        int           missing_attr = 0;
-        int           i     = 0, ret = -1;
-        dht_local_t  *local = NULL;
-        xlator_t     *this = NULL;
-        int           cnt  = 0;
-
-        local = frame->local;
-        this = frame->this;
+    int missing_attr = 0;
+    int i = 0, ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+    int cnt = 0;
+
+    local = frame->local;
+    this = frame->this;
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err == -1)
+            missing_attr++;
+    }
+
+    if (missing_attr == 0) {
+        if (!local->heal_layout) {
+            gf_msg_trace(this->name, 0, "Skip heal layout for %s gfid = %s ",
+                         loc->path, uuid_utoa(loc->gfid));
+            dht_selfheal_dir_finish(frame, this, 0, 1);
+            return 0;
+        }
+        ret = dht_selfheal_layout_lock(frame, layout, _gf_false,
+                                       dht_selfheal_dir_xattr,
+                                       dht_should_heal_layout);
 
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err == -1)
-                        missing_attr++;
+        if (ret < 0) {
+            dht_selfheal_dir_finish(frame, this, -1, 1);
         }
 
-        if (missing_attr == 0) {
-                if (!local->heal_layout) {
-                        gf_msg_trace (this->name, 0,
-                                      "Skip heal layout for %s gfid = %s ",
-                                      loc->path, uuid_utoa(loc->gfid));
-                        dht_selfheal_dir_finish (frame, this, 0, 1);
-                        return 0;
-                }
-                ret = dht_selfheal_layout_lock (frame, layout, _gf_false,
-                                                dht_selfheal_dir_xattr,
-                                                dht_should_heal_layout);
-
-                if (ret < 0) {
-                        dht_selfheal_dir_finish (frame, this, -1, 1);
-                }
-
-                return 0;
-        }
+        return 0;
+    }
 
-        local->call_cnt = missing_attr;
-        cnt = layout->cnt;
+    local->call_cnt = missing_attr;
+    cnt = layout->cnt;
 
-        for (i = 0; i < cnt; i++) {
-                if (layout->list[i].err == -1) {
-                        gf_msg_trace (this->name, 0,
-                                      "%s: setattr on subvol %s, gfid = %s",
-                                      loc->path, layout->list[i].xlator->name,
-                                      uuid_utoa(loc->gfid));
+    for (i = 0; i < cnt; i++) {
+        if (layout->list[i].err == -1) {
+            gf_msg_trace(this->name, 0, "%s: setattr on subvol %s, gfid = %s",
+                         loc->path, layout->list[i].xlator->name,
+                         uuid_utoa(loc->gfid));
 
-                        STACK_WIND (frame, dht_selfheal_dir_setattr_cbk,
-                                    layout->list[i].xlator,
-                                    layout->list[i].xlator->fops->setattr,
-                                    loc, stbuf, valid, NULL);
-                }
+            STACK_WIND(
+                frame, dht_selfheal_dir_setattr_cbk, layout->list[i].xlator,
+                layout->list[i].xlator->fops->setattr, loc, stbuf, valid, NULL);
         }
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_selfheal_dir_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int op_ret, int op_errno,
-                            inode_t *inode, struct iatt *stbuf,
-                            struct iatt *preparent, struct iatt *postparent,
-                            dict_t *xdata)
+dht_selfheal_dir_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, inode_t *inode,
+                           struct iatt *stbuf, struct iatt *preparent,
+                           struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        dht_layout_t  *layout = NULL;
-        xlator_t      *prev = NULL;
-        xlator_t      *subvol = NULL;
-        int            i = 0, ret = -1;
-        int            this_call_cnt = 0;
-        char           gfid[GF_UUID_BUF_SIZE] = {0};
-
-        local  = frame->local;
-        layout = local->selfheal.layout;
-        prev   = cookie;
-        subvol = prev;
-
-        if ((op_ret == 0) || ((op_ret == -1) && (op_errno == EEXIST))) {
-                for (i = 0; i < layout->cnt; i++) {
-                        if (layout->list[i].xlator == subvol) {
-                                layout->list[i].err = -1;
-                                break;
-                        }
-                }
+    dht_local_t *local = NULL;
+    dht_layout_t *layout = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *subvol = NULL;
+    int i = 0, ret = -1;
+    int this_call_cnt = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    local = frame->local;
+    layout = local->selfheal.layout;
+    prev = cookie;
+    subvol = prev;
+
+    if ((op_ret == 0) || ((op_ret == -1) && (op_errno == EEXIST))) {
+        for (i = 0; i < layout->cnt; i++) {
+            if (layout->list[i].xlator == subvol) {
+                layout->list[i].err = -1;
+                break;
+            }
         }
+    }
 
-        if (op_ret) {
-                gf_uuid_unparse(local->loc.gfid, gfid);
-                gf_msg (this->name, ((op_errno == EEXIST) ? GF_LOG_DEBUG :
-                                     GF_LOG_WARNING),
-                        op_errno, DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed: path = %s, gfid = %s",
-                        local->loc.path, gfid );
-                goto out;
-        }
-        dht_iatt_merge (this, &local->preparent, preparent);
-        dht_iatt_merge (this, &local->postparent, postparent);
-        ret = 0;
+    if (op_ret) {
+        gf_uuid_unparse(local->loc.gfid, gfid);
+        gf_msg(this->name,
+               ((op_errno == EEXIST) ? GF_LOG_DEBUG : GF_LOG_WARNING), op_errno,
+               DHT_MSG_DIR_SELFHEAL_FAILED,
+               "Directory selfheal failed: path = %s, gfid = %s",
+               local->loc.path, gfid);
+        goto out;
+    }
+    dht_iatt_merge(this, &local->preparent, preparent);
+    dht_iatt_merge(this, &local->postparent, postparent);
+    ret = 0;
 
 out:
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_selfheal_dir_finish (frame, this, ret, 0);
-                dht_selfheal_dir_setattr (frame, &local->loc, &local->stbuf, 0xffffff, layout);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_selfheal_dir_finish(frame, this, ret, 0);
+        dht_selfheal_dir_setattr(frame, &local->loc, &local->stbuf, 0xffffff,
+                                 layout);
+    }
 
-        return 0;
+    return 0;
 }
 
 void
-dht_selfheal_dir_mkdir_setacl (dict_t *xattr, dict_t *dict)
+dht_selfheal_dir_mkdir_setacl(dict_t *xattr, dict_t *dict)
 {
-        data_t          *acl_default = NULL;
-        data_t          *acl_access = NULL;
-        xlator_t        *this = NULL;
-        int     ret = -1;
-
-        GF_ASSERT (xattr);
-        GF_ASSERT (dict);
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        acl_default = dict_get (xattr, POSIX_ACL_DEFAULT_XATTR);
-
-        if (!acl_default) {
-                gf_msg_debug (this->name, 0,
-                              "ACL_DEFAULT xattr not present");
-                goto cont;
-        }
-        ret = dict_set (dict, POSIX_ACL_DEFAULT_XATTR, acl_default);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        POSIX_ACL_DEFAULT_XATTR);
+    data_t *acl_default = NULL;
+    data_t *acl_access = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+
+    GF_ASSERT(xattr);
+    GF_ASSERT(dict);
+
+    this = THIS;
+    GF_ASSERT(this);
+
+    acl_default = dict_get(xattr, POSIX_ACL_DEFAULT_XATTR);
+
+    if (!acl_default) {
+        gf_msg_debug(this->name, 0, "ACL_DEFAULT xattr not present");
+        goto cont;
+    }
+    ret = dict_set(dict, POSIX_ACL_DEFAULT_XATTR, acl_default);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value.key = %s",
+               POSIX_ACL_DEFAULT_XATTR);
 cont:
-        acl_access = dict_get (xattr, POSIX_ACL_ACCESS_XATTR);
-        if (!acl_access) {
-                gf_msg_debug (this->name, 0,
-                              "ACL_ACCESS xattr not present");
-                goto out;
-        }
-        ret = dict_set (dict, POSIX_ACL_ACCESS_XATTR, acl_access);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        POSIX_ACL_ACCESS_XATTR);
+    acl_access = dict_get(xattr, POSIX_ACL_ACCESS_XATTR);
+    if (!acl_access) {
+        gf_msg_debug(this->name, 0, "ACL_ACCESS xattr not present");
+        goto out;
+    }
+    ret = dict_set(dict, POSIX_ACL_ACCESS_XATTR, acl_access);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value.key = %s",
+               POSIX_ACL_ACCESS_XATTR);
 
 out:
-        return;
+    return;
 }
 
-
 void
-dht_selfheal_dir_mkdir_setquota (dict_t *src, dict_t *dst)
+dht_selfheal_dir_mkdir_setquota(dict_t *src, dict_t *dst)
 {
-        data_t           *quota_limit_key = NULL;
-        data_t           *quota_limit_obj_key = NULL;
-        xlator_t        *this = NULL;
-        int     ret = -1;
-
-        GF_ASSERT (src);
-        GF_ASSERT (dst);
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        quota_limit_key = dict_get (src, QUOTA_LIMIT_KEY);
-        if (!quota_limit_key) {
-                gf_msg_debug (this->name, 0,
-                              "QUOTA_LIMIT_KEY xattr not present");
-                goto cont;
-        }
-        ret = dict_set(dst, QUOTA_LIMIT_KEY, quota_limit_key);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        QUOTA_LIMIT_KEY);
+    data_t *quota_limit_key = NULL;
+    data_t *quota_limit_obj_key = NULL;
+    xlator_t *this = NULL;
+    int ret = -1;
+
+    GF_ASSERT(src);
+    GF_ASSERT(dst);
+
+    this = THIS;
+    GF_ASSERT(this);
+
+    quota_limit_key = dict_get(src, QUOTA_LIMIT_KEY);
+    if (!quota_limit_key) {
+        gf_msg_debug(this->name, 0, "QUOTA_LIMIT_KEY xattr not present");
+        goto cont;
+    }
+    ret = dict_set(dst, QUOTA_LIMIT_KEY, quota_limit_key);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value.key = %s", QUOTA_LIMIT_KEY);
 
 cont:
-        quota_limit_obj_key = dict_get (src, QUOTA_LIMIT_OBJECTS_KEY);
-        if (!quota_limit_obj_key) {
-                gf_msg_debug (this->name, 0,
-                              "QUOTA_LIMIT_OBJECTS_KEY xattr not present");
-                goto out;
-        }
-        ret = dict_set (dst, QUOTA_LIMIT_OBJECTS_KEY, quota_limit_obj_key);
-        if (ret)
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value.key = %s",
-                        QUOTA_LIMIT_OBJECTS_KEY);
+    quota_limit_obj_key = dict_get(src, QUOTA_LIMIT_OBJECTS_KEY);
+    if (!quota_limit_obj_key) {
+        gf_msg_debug(this->name, 0,
+                     "QUOTA_LIMIT_OBJECTS_KEY xattr not present");
+        goto out;
+    }
+    ret = dict_set(dst, QUOTA_LIMIT_OBJECTS_KEY, quota_limit_obj_key);
+    if (ret)
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value.key = %s",
+               QUOTA_LIMIT_OBJECTS_KEY);
 
 out:
-        return;
+    return;
 }
 
-
-
-
-
 int
-dht_selfheal_dir_mkdir_lookup_done (call_frame_t *frame, xlator_t *this)
+dht_selfheal_dir_mkdir_lookup_done(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        int           i     = 0;
-        dict_t       *dict = NULL;
-        dht_layout_t  *layout = NULL;
-        loc_t        *loc   = NULL;
-        int           cnt   = 0;
-        int          ret    = -1;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = frame->local;
-        layout = local->layout;
-        loc    = &local->loc;
-
-        if (!gf_uuid_is_null (local->gfid)) {
-                dict = dict_new ();
-                if (!dict)
-                        return -1;
-
-                ret = dict_set_gfuuid (dict, "gfid-req", local->gfid, true);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "%s: Failed to set dictionary value:"
-                                " key = gfid-req", loc->path);
-        } else if (local->params) {
-                /* Send the dictionary from higher layers directly */
-
-                dict = dict_ref (local->params);
-        }
-        /* Code to update all extended attributed from local->xattr
-           to dict
-        */
-        dht_dir_set_heal_xattr (this, local, dict, local->xattr, NULL,
-                                NULL);
+    dht_local_t *local = NULL;
+    int i = 0;
+    dict_t *dict = NULL;
+    dht_layout_t *layout = NULL;
+    loc_t *loc = NULL;
+    int cnt = 0;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(this->private, err);
+
+    local = frame->local;
+    layout = local->layout;
+    loc = &local->loc;
+
+    if (!gf_uuid_is_null(local->gfid)) {
+        dict = dict_new();
+        if (!dict)
+            return -1;
+
+        ret = dict_set_gfuuid(dict, "gfid-req", local->gfid, true);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "%s: Failed to set dictionary value:"
+                   " key = gfid-req",
+                   loc->path);
+    } else if (local->params) {
+        /* Send the dictionary from higher layers directly */
+
+        dict = dict_ref(local->params);
+    }
+    /* Code to update all extended attributed from local->xattr
+       to dict
+    */
+    dht_dir_set_heal_xattr(this, local, dict, local->xattr, NULL, NULL);
+
+    if (!dict) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "dict is NULL, need to make sure gfids are same");
+        dict = dict_new();
+        if (!dict)
+            return -1;
+    }
+    ret = dict_set_flag(dict, GF_INTERNAL_CTX_KEY, GF_DHT_HEAL_DIR);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value for"
+               " key = %s at path: %s",
+               GF_INTERNAL_CTX_KEY, loc->path);
+        /* We can still continue. As heal can still happen
+         * unless quota limits have reached for the dir.
+         */
+    }
 
-        if (!dict) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "dict is NULL, need to make sure gfids are same");
-                dict = dict_new ();
-                if (!dict)
-                        return -1;
-        }
-        ret = dict_set_flag (dict, GF_INTERNAL_CTX_KEY, GF_DHT_HEAL_DIR);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value for"
-                        " key = %s at path: %s",
-                        GF_INTERNAL_CTX_KEY, loc->path);
-                /* We can still continue. As heal can still happen
-                 * unless quota limits have reached for the dir.
-                 */
-        }
+    cnt = layout->cnt;
+    for (i = 0; i < cnt; i++) {
+        if (layout->list[i].err == ESTALE || layout->list[i].err == ENOENT ||
+            local->selfheal.force_mkdir) {
+            gf_msg_debug(this->name, 0, "Creating directory %s on subvol %s",
+                         loc->path, layout->list[i].xlator->name);
 
-        cnt = layout->cnt;
-        for (i = 0; i < cnt; i++) {
-                if (layout->list[i].err == ESTALE ||
-                    layout->list[i].err == ENOENT ||
-                    local->selfheal.force_mkdir) {
-                        gf_msg_debug (this->name, 0,
-                                      "Creating directory %s on subvol %s",
-                                      loc->path, layout->list[i].xlator->name);
-
-                        STACK_WIND_COOKIE (frame, dht_selfheal_dir_mkdir_cbk,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator,
-                                           layout->list[i].xlator->fops->mkdir,
-                                           loc,
-                                           st_mode_from_ia (local->stbuf.ia_prot,
-                                                            local->stbuf.ia_type),
-                                           0, dict);
-                }
+            STACK_WIND_COOKIE(
+                frame, dht_selfheal_dir_mkdir_cbk, layout->list[i].xlator,
+                layout->list[i].xlator, layout->list[i].xlator->fops->mkdir,
+                loc,
+                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
+                dict);
         }
+    }
 
-        if (dict)
-                dict_unref (dict);
+    if (dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
 int
-dht_selfheal_dir_mkdir_lookup_cbk (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int op_ret, int op_errno,
-                                   inode_t *inode, struct iatt *stbuf,
-                                   dict_t *xattr, struct iatt *postparent)
+dht_selfheal_dir_mkdir_lookup_cbk(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int op_ret, int op_errno,
+                                  inode_t *inode, struct iatt *stbuf,
+                                  dict_t *xattr, struct iatt *postparent)
 {
-        dht_local_t  *local = NULL;
-        int           i     = 0;
-        int           this_call_cnt = 0;
-        int           missing_dirs = 0;
-        dht_layout_t  *layout = NULL;
-        dht_conf_t    *conf   = 0;
-        loc_t         *loc    = NULL;
-        int           check_mds = 0;
-        int           errst     = 0;
-        int32_t       mds_xattr_val[1] = {0};
-        char          gfid_local[GF_UUID_BUF_SIZE] = {0};
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        local = frame->local;
-        layout = local->layout;
-        loc = &local->loc;
-        conf = this->private;
-
-        if (local->gfid)
-                gf_uuid_unparse(local->gfid, gfid_local);
-
-        this_call_cnt = dht_frame_return (frame);
-
-        LOCK (&frame->lock);
-        {
-                if ((op_ret < 0) &&
-                    (op_errno == ENOENT || op_errno == ESTALE)) {
-                        local->selfheal.hole_cnt = !local->selfheal.hole_cnt ? 1
-                                                : local->selfheal.hole_cnt + 1;
-                }
-
-                if (!op_ret) {
-                        dht_iatt_merge (this, &local->stbuf, stbuf);
-                }
-                check_mds = dht_dict_get_array (xattr, conf->mds_xattr_key,
-                                                mds_xattr_val, 1, &errst);
-                if (dict_get (xattr, conf->mds_xattr_key) && check_mds && !errst) {
-                        dict_unref (local->xattr);
-                        local->xattr = dict_ref (xattr);
-                }
+    dht_local_t *local = NULL;
+    int i = 0;
+    int this_call_cnt = 0;
+    int missing_dirs = 0;
+    dht_layout_t *layout = NULL;
+    dht_conf_t *conf = 0;
+    loc_t *loc = NULL;
+    int check_mds = 0;
+    int errst = 0;
+    int32_t mds_xattr_val[1] = {0};
+    char gfid_local[GF_UUID_BUF_SIZE] = {0};
+
+    VALIDATE_OR_GOTO(this->private, err);
+
+    local = frame->local;
+    layout = local->layout;
+    loc = &local->loc;
+    conf = this->private;
+
+    if (local->gfid)
+        gf_uuid_unparse(local->gfid, gfid_local);
+
+    this_call_cnt = dht_frame_return(frame);
+
+    LOCK(&frame->lock);
+    {
+        if ((op_ret < 0) && (op_errno == ENOENT || op_errno == ESTALE)) {
+            local->selfheal.hole_cnt = !local->selfheal.hole_cnt
+                                           ? 1
+                                           : local->selfheal.hole_cnt + 1;
+        }
+
+        if (!op_ret) {
+            dht_iatt_merge(this, &local->stbuf, stbuf);
+        }
+        check_mds = dht_dict_get_array(xattr, conf->mds_xattr_key,
+                                       mds_xattr_val, 1, &errst);
+        if (dict_get(xattr, conf->mds_xattr_key) && check_mds && !errst) {
+            dict_unref(local->xattr);
+            local->xattr = dict_ref(xattr);
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if (is_last_call(this_call_cnt)) {
+        if (local->selfheal.hole_cnt == layout->cnt) {
+            gf_msg_debug(this->name, op_errno,
+                         "Lookup failed, an rmdir could have "
+                         "deleted this entry %s",
+                         loc->name);
+            local->op_errno = op_errno;
+            goto err;
+        } else {
+            for (i = 0; i < layout->cnt; i++) {
+                if (layout->list[i].err == ENOENT ||
+                    layout->list[i].err == ESTALE ||
+                    local->selfheal.force_mkdir)
+                    missing_dirs++;
+            }
+
+            if (missing_dirs == 0) {
+                dht_selfheal_dir_finish(frame, this, 0, 0);
+                dht_selfheal_dir_setattr(frame, loc, &local->stbuf, 0xffffffff,
+                                         layout);
+                return 0;
+            }
 
+            local->call_cnt = missing_dirs;
+            dht_selfheal_dir_mkdir_lookup_done(frame, this);
         }
-        UNLOCK (&frame->lock);
-
-        if (is_last_call (this_call_cnt)) {
-                if (local->selfheal.hole_cnt == layout->cnt) {
-                        gf_msg_debug (this->name, op_errno,
-                                      "Lookup failed, an rmdir could have "
-                                      "deleted this entry %s", loc->name);
-                        local->op_errno = op_errno;
-                        goto err;
-                } else {
-                        for (i = 0; i < layout->cnt; i++) {
-                                if (layout->list[i].err == ENOENT ||
-                                    layout->list[i].err == ESTALE ||
-                                    local->selfheal.force_mkdir)
-                                        missing_dirs++;
-                        }
-
-                        if (missing_dirs == 0) {
-                                dht_selfheal_dir_finish (frame, this, 0, 0);
-                                dht_selfheal_dir_setattr (frame, loc,
-                                                          &local->stbuf,
-                                                          0xffffffff, layout);
-                                return 0;
-                        }
-
-                        local->call_cnt = missing_dirs;
-                        dht_selfheal_dir_mkdir_lookup_done (frame, this);
-                }
-        }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
-
 int
-dht_selfheal_dir_mkdir_lock_cbk (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *xdata)
+dht_selfheal_dir_mkdir_lock_cbk(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        dht_conf_t   *conf  = NULL;
-        int           i     = 0;
-        int           ret   = -1;
-        xlator_t     *mds_subvol = NULL;
-
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-        local = frame->local;
-        mds_subvol = local->mds_subvol;
-
-        local->call_cnt = conf->subvolume_cnt;
-
-        if (op_ret < 0) {
-
-                /* We get this error when the directory entry was not created
-                 * on a newky attached tier subvol. Hence proceed and do mkdir
-                 * on the tier subvol.
-                 */
-                if (op_errno == EINVAL) {
-                        local->call_cnt = 1;
-                        dht_selfheal_dir_mkdir_lookup_done (frame, this);
-                        return 0;
-                }
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+    int ret = -1;
+    xlator_t *mds_subvol = NULL;
 
-                gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                        DHT_MSG_ENTRYLK_ERROR,
-                        "acquiring entrylk after inodelk failed for %s",
-                        local->loc.path);
+    VALIDATE_OR_GOTO(this->private, err);
 
-                local->op_errno = op_errno;
-                goto err;
-        }
+    conf = this->private;
+    local = frame->local;
+    mds_subvol = local->mds_subvol;
 
-        /* After getting locks, perform lookup again to ensure that the
-           directory was not deleted by a racing rmdir
-        */
-        if (!local->xattr_req)
-                local->xattr_req = dict_new ();
-
-        ret = dict_set_int32 (local->xattr_req, "list-xattr", 1);
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary key list-xattr value "
-                        " for path %s ", local->loc.path);
+    local->call_cnt = conf->subvolume_cnt;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (mds_subvol && conf->subvolumes[i] == mds_subvol) {
-                        STACK_WIND_COOKIE (frame,
-                                           dht_selfheal_dir_mkdir_lookup_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                } else {
-                       STACK_WIND_COOKIE (frame,
-                                          dht_selfheal_dir_mkdir_lookup_cbk,
-                                          conf->subvolumes[i],
-                                          conf->subvolumes[i],
-                                          conf->subvolumes[i]->fops->lookup,
-                                          &local->loc, NULL);
-                }
+    if (op_ret < 0) {
+        /* We get this error when the directory entry was not created
+         * on a newky attached tier subvol. Hence proceed and do mkdir
+         * on the tier subvol.
+         */
+        if (op_errno == EINVAL) {
+            local->call_cnt = 1;
+            dht_selfheal_dir_mkdir_lookup_done(frame, this);
+            return 0;
+        }
+
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, DHT_MSG_ENTRYLK_ERROR,
+               "acquiring entrylk after inodelk failed for %s",
+               local->loc.path);
+
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    /* After getting locks, perform lookup again to ensure that the
+       directory was not deleted by a racing rmdir
+    */
+    if (!local->xattr_req)
+        local->xattr_req = dict_new();
+
+    ret = dict_set_int32(local->xattr_req, "list-xattr", 1);
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary key list-xattr value "
+               " for path %s ",
+               local->loc.path);
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (mds_subvol && conf->subvolumes[i] == mds_subvol) {
+            STACK_WIND_COOKIE(frame, dht_selfheal_dir_mkdir_lookup_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
+        } else {
+            STACK_WIND_COOKIE(frame, dht_selfheal_dir_mkdir_lookup_cbk,
+                              conf->subvolumes[i], conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              NULL);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        dht_selfheal_dir_finish (frame, this, -1, 1);
-        return 0;
+    dht_selfheal_dir_finish(frame, this, -1, 1);
+    return 0;
 }
 
 int
-dht_selfheal_dir_mkdir (call_frame_t *frame, loc_t *loc,
-                        dht_layout_t *layout, int force)
+dht_selfheal_dir_mkdir(call_frame_t *frame, loc_t *loc, dht_layout_t *layout,
+                       int force)
 {
-        int           missing_dirs = 0;
-        int           i     = 0;
-        int           ret   = -1;
-        dht_local_t  *local = NULL;
-        xlator_t     *this  = NULL;
-
-        local = frame->local;
-        this = frame->this;
-
-        local->selfheal.force_mkdir = force;
-        local->selfheal.hole_cnt = 0;
-
-        for (i = 0; i < layout->cnt; i++) {
-                if (layout->list[i].err == ENOENT || force)
-                        missing_dirs++;
-        }
-
-        if (missing_dirs == 0) {
-                if (!__is_root_gfid (local->stbuf.ia_gfid)) {
-                        if (local->need_xattr_heal) {
-                                local->need_xattr_heal = 0;
-                                ret =  dht_dir_xattr_heal (this, local);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                ret,
-                                                DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                                "xattr heal failed for "
-                                                "directory  %s gfid %s ",
-                                                local->loc.path,
-                                                local->gfid);
-                        } else {
-                                if (!gf_uuid_is_null (local->gfid))
-                                        gf_uuid_copy (loc->gfid, local->gfid);
-
-                                ret = dht_common_mark_mdsxattr (frame, NULL, 0);
-                                if (!ret)
-                                        return 0;
-
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                        "Failed to set mds xattr "
-                                        "for directory  %s gfid %s ",
-                                        local->loc.path, local->gfid);
-                        }
-                }
-                dht_selfheal_dir_setattr (frame, loc, &local->stbuf,
-                                          0xffffffff, layout);
-                return 0;
-        }
-
-        if (local->hashed_subvol == NULL)
-                local->hashed_subvol = dht_subvol_get_hashed (this, loc);
-
-        if (local->hashed_subvol == NULL) {
-                local->op_errno = EINVAL;
-                gf_msg (this->name, GF_LOG_WARNING, local->op_errno,
-                        DHT_MSG_HASHED_SUBVOL_GET_FAILED,
-                        "(%s/%s) (path: %s): "
-                        "hashed subvolume not found", loc->pargfid, loc->name,
-                        loc->path);
-                goto err;
-        }
-
-        local->current = &local->lock[0];
-        ret = dht_protect_namespace (frame, loc, local->hashed_subvol,
-                                     &local->current->ns,
-                                     dht_selfheal_dir_mkdir_lock_cbk);
-
-        if (ret < 0)
-                goto err;
-
+    int missing_dirs = 0;
+    int i = 0;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *this = NULL;
+
+    local = frame->local;
+    this = frame->this;
+
+    local->selfheal.force_mkdir = force;
+    local->selfheal.hole_cnt = 0;
+
+    for (i = 0; i < layout->cnt; i++) {
+        if (layout->list[i].err == ENOENT || force)
+            missing_dirs++;
+    }
+
+    if (missing_dirs == 0) {
+        if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+            if (local->need_xattr_heal) {
+                local->need_xattr_heal = 0;
+                ret = dht_dir_xattr_heal(this, local);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_ERROR, ret,
+                           DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                           "xattr heal failed for "
+                           "directory  %s gfid %s ",
+                           local->loc.path, local->gfid);
+            } else {
+                if (!gf_uuid_is_null(local->gfid))
+                    gf_uuid_copy(loc->gfid, local->gfid);
+
+                ret = dht_common_mark_mdsxattr(frame, NULL, 0);
+                if (!ret)
+                    return 0;
+
+                gf_msg(this->name, GF_LOG_INFO, 0,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "Failed to set mds xattr "
+                       "for directory  %s gfid %s ",
+                       local->loc.path, local->gfid);
+            }
+        }
+        dht_selfheal_dir_setattr(frame, loc, &local->stbuf, 0xffffffff, layout);
         return 0;
+    }
+
+    if (local->hashed_subvol == NULL)
+        local->hashed_subvol = dht_subvol_get_hashed(this, loc);
+
+    if (local->hashed_subvol == NULL) {
+        local->op_errno = EINVAL;
+        gf_msg(this->name, GF_LOG_WARNING, local->op_errno,
+               DHT_MSG_HASHED_SUBVOL_GET_FAILED,
+               "(%s/%s) (path: %s): "
+               "hashed subvolume not found",
+               loc->pargfid, loc->name, loc->path);
+        goto err;
+    }
+
+    local->current = &local->lock[0];
+    ret = dht_protect_namespace(frame, loc, local->hashed_subvol,
+                                &local->current->ns,
+                                dht_selfheal_dir_mkdir_lock_cbk);
+
+    if (ret < 0)
+        goto err;
+
+    return 0;
 err:
-        return -1;
+    return -1;
 }
 
 int
-dht_selfheal_layout_alloc_start (xlator_t *this, loc_t *loc,
-                                 dht_layout_t *layout)
+dht_selfheal_layout_alloc_start(xlator_t *this, loc_t *loc,
+                                dht_layout_t *layout)
 {
-        int         start                               = 0;
-        uint32_t    hashval                             = 0;
-        int         ret                                 = 0;
-        const char *str                                 = NULL;
-        dht_conf_t *conf                                = NULL;
-        char           buf[UUID_CANONICAL_FORM_LEN + 1] = {0, };
-
-        conf = this->private;
-
-        if (conf->randomize_by_gfid) {
-                str = uuid_utoa_r (loc->gfid, buf);
-        } else {
-                str = loc->path;
-        }
-
-        ret = dht_hash_compute (this, layout->type, str, &hashval);
-        if (ret == 0) {
-                start = (hashval % layout->cnt);
-        }
-
-        return start;
+    int start = 0;
+    uint32_t hashval = 0;
+    int ret = 0;
+    const char *str = NULL;
+    dht_conf_t *conf = NULL;
+    char buf[UUID_CANONICAL_FORM_LEN + 1] = {
+        0,
+    };
+
+    conf = this->private;
+
+    if (conf->randomize_by_gfid) {
+        str = uuid_utoa_r(loc->gfid, buf);
+    } else {
+        str = loc->path;
+    }
+
+    ret = dht_hash_compute(this, layout->type, str, &hashval);
+    if (ret == 0) {
+        start = (hashval % layout->cnt);
+    }
+
+    return start;
 }
 
 static int
-dht_get_layout_count (xlator_t *this, dht_layout_t *layout, int new_layout)
+dht_get_layout_count(xlator_t *this, dht_layout_t *layout, int new_layout)
 {
-        int i = 0;
-        int j = 0;
-        int err = 0;
-        int count = 0;
-        dht_conf_t *conf = NULL;
-
-        /* Gets in use only for replace-brick, remove-brick */
-        conf = this->private;
+    int i = 0;
+    int j = 0;
+    int err = 0;
+    int count = 0;
+    dht_conf_t *conf = NULL;
+
+    /* Gets in use only for replace-brick, remove-brick */
+    conf = this->private;
+    for (i = 0; i < layout->cnt; i++) {
+        for (j = 0; j < conf->subvolume_cnt; j++) {
+            if (conf->decommissioned_bricks[j] &&
+                conf->decommissioned_bricks[j] == layout->list[i].xlator) {
+                layout->list[i].err = EINVAL;
+                break;
+            }
+        }
+    }
+
+    for (i = 0; i < layout->cnt; i++) {
+        err = layout->list[i].err;
+        if (err == -1 || err == 0 || err == ENOENT) {
+            /* Take this with a pinch of salt. The behaviour seems
+             * to be slightly different when this function is
+             * invoked from mkdir codepath. For eg., err == 0 in
+             * mkdir codepath means directory created but xattr
+             * is not set yet.
+             */
+
+            /* Setting list[i].err = -1 is an indication for
+               dht_selfheal_layout_new_directory() to assign
+               a range. We set it to -1 based on any one of
+               the three criteria:
+
+               - err == -1 already, which means directory
+                 existed but layout was not set on it.
+
+               - err == 0, which means directory exists and
+                 has an old layout piece which will be
+                 overwritten now.
+
+               - err == ENOENT, which means directory does
+                 not exist (possibly racing with mkdir or
+                 finishing half done mkdir). The missing
+                 directory will be attempted to be recreated.
+            */
+            count++;
+            if (!err)
+                layout->list[i].err = -1;
+        }
+    }
+
+    /* no subvolume has enough space, but can't stop directory creation */
+    if (!count || !new_layout) {
         for (i = 0; i < layout->cnt; i++) {
-                for (j = 0; j < conf->subvolume_cnt; j++) {
-                        if (conf->decommissioned_bricks[j] &&
-                            conf->decommissioned_bricks[j] == layout->list[i].xlator) {
-                                layout->list[i].err = EINVAL;
-                                break;
-                        }
-                }
-        }
-
-        for (i = 0; i < layout->cnt; i++) {
-                err = layout->list[i].err;
-                if (err == -1 || err == 0 || err == ENOENT) {
-                        /* Take this with a pinch of salt. The behaviour seems
-                         * to be slightly different when this function is
-                         * invoked from mkdir codepath. For eg., err == 0 in
-                         * mkdir codepath means directory created but xattr
-                         * is not set yet.
-                         */
-
-			/* Setting list[i].err = -1 is an indication for
-			   dht_selfheal_layout_new_directory() to assign
-			   a range. We set it to -1 based on any one of
-			   the three criteria:
-
-			   - err == -1 already, which means directory
-			     existed but layout was not set on it.
-
-			   - err == 0, which means directory exists and
-			     has an old layout piece which will be
-			     overwritten now.
-
-			   - err == ENOENT, which means directory does
-			     not exist (possibly racing with mkdir or
-			     finishing half done mkdir). The missing
-			     directory will be attempted to be recreated.
-			*/
-                        count++;
-			if (!err)
-				layout->list[i].err = -1;
-                }
-        }
-
-        /* no subvolume has enough space, but can't stop directory creation */
-        if (!count || !new_layout) {
-                for (i = 0; i < layout->cnt; i++) {
-                        err = layout->list[i].err;
-                        if (err == ENOSPC) {
-                                layout->list[i].err = -1;
-                                count++;
-                        }
-                }
-        }
-
-        /* if layout->spread_cnt is set, check if it is <= available
-         * subvolumes (down brick and decommissioned bricks are considered
-         * un-availbale). Else return count (available up bricks) */
-        count = ((layout->spread_cnt &&
-                 (layout->spread_cnt <= count)) ?
-                 layout->spread_cnt : ((count) ? count : 1));
-
-        return count;
+            err = layout->list[i].err;
+            if (err == ENOSPC) {
+                layout->list[i].err = -1;
+                count++;
+            }
+        }
+    }
+
+    /* if layout->spread_cnt is set, check if it is <= available
+     * subvolumes (down brick and decommissioned bricks are considered
+     * un-availbale). Else return count (available up bricks) */
+    count = ((layout->spread_cnt && (layout->spread_cnt <= count))
+                 ? layout->spread_cnt
+                 : ((count) ? count : 1));
+
+    return count;
 }
 
+void
+dht_selfheal_layout_new_directory(call_frame_t *frame, loc_t *loc,
+                                  dht_layout_t *new_layout);
 
-void dht_selfheal_layout_new_directory (call_frame_t *frame, loc_t *loc,
-					dht_layout_t *new_layout);
-
-void dht_layout_entry_swap (dht_layout_t *layout, int i, int j);
-void dht_layout_range_swap (dht_layout_t *layout, int i, int j);
+void
+dht_layout_entry_swap(dht_layout_t *layout, int i, int j);
+void
+dht_layout_range_swap(dht_layout_t *layout, int i, int j);
 
 /*
  * It's a bit icky using local variables in a macro, but it makes the rest
  * of the code a lot clearer.
  */
-#define OV_ENTRY(x,y)      table[x*new->cnt+y]
+#define OV_ENTRY(x, y) table[x * new->cnt + y]
 
 void
-dht_selfheal_layout_maximize_overlap (call_frame_t *frame, loc_t *loc,
-				      dht_layout_t *new, dht_layout_t *old)
+dht_selfheal_layout_maximize_overlap(call_frame_t *frame, loc_t *loc,
+                                     dht_layout_t *new, dht_layout_t *old)
 {
-	int           i            = 0;
-	int           j            = 0;
-	uint32_t      curr_overlap = 0;
-	uint32_t      max_overlap  = 0;
-	int           max_overlap_idx = -1;
-	uint32_t      overlap      = 0;
-        uint32_t     *table = NULL;
-
-	dht_layout_sort_volname (old);
-	/* Now both old_layout->list[] and new_layout->list[]
-	   are match the same xlators/subvolumes. i.e,
-	   old_layout->[i] and new_layout->[i] are referring
-	   to the same subvolumes
-	*/
-
-        /* Build a table of overlaps between new[i] and old[j]. */
-        table = alloca(sizeof(overlap)*old->cnt*new->cnt);
-        if (!table) {
-                return;
-        }
-        memset(table,0,sizeof(overlap)*old->cnt*new->cnt);
-        for (i = 0; i < new->cnt; ++i) {
-                for (j = 0; j < old->cnt; ++j) {
-                        OV_ENTRY(i,j) = dht_overlap_calc(old,j,new,i);
-                }
-        }
-
-	for (i = 0; i < new->cnt; i++) {
-		if (new->list[i].err > 0) {
-			/* Subvol might be marked for decommission
-			   with EINVAL, or some other serious error
-			   marked with positive errno.
-			*/
-			continue;
-                }
-
-                max_overlap = 0;
-                max_overlap_idx = i;
-                for (j = (i + 1); j < new->cnt; ++j) {
-                        if (new->list[j].err > 0) {
-			        /* Subvol might be marked for decommission
-			        with EINVAL, or some other serious error
-			        marked with positive errno.
-			        */
-			        continue;
-                        }
-                        /* Calculate the overlap now. */
-                        curr_overlap = OV_ENTRY(i,i) + OV_ENTRY(j,j);
-                        /* Calculate the overlap after the proposed swap. */
-                        overlap = OV_ENTRY(i,j) + OV_ENTRY(j,i);
-                        /* Are we better than status quo? */
-                        if (overlap > curr_overlap) {
-                                overlap -= curr_overlap;
-                                /* Are we better than the previous choice? */
-                                if (overlap > max_overlap) {
-                                        max_overlap = overlap;
-                                        max_overlap_idx = j;
-                                }
-                        }
-                }
-
-		if (max_overlap_idx != i) {
- 			dht_layout_range_swap (new, i, max_overlap_idx);
-                        /* Need to swap the table values too. */
-                        for (j = 0; j < old->cnt; ++j) {
-                                overlap = OV_ENTRY(i,j);
-                                OV_ENTRY(i,j) = OV_ENTRY(max_overlap_idx,j);
-                                OV_ENTRY(max_overlap_idx,j) = overlap;
-                        }
-                }
-	}
+    int i = 0;
+    int j = 0;
+    uint32_t curr_overlap = 0;
+    uint32_t max_overlap = 0;
+    int max_overlap_idx = -1;
+    uint32_t overlap = 0;
+    uint32_t *table = NULL;
+
+    dht_layout_sort_volname(old);
+    /* Now both old_layout->list[] and new_layout->list[]
+       are match the same xlators/subvolumes. i.e,
+       old_layout->[i] and new_layout->[i] are referring
+       to the same subvolumes
+    */
+
+    /* Build a table of overlaps between new[i] and old[j]. */
+    table = alloca(sizeof(overlap) * old->cnt * new->cnt);
+    if (!table) {
+        return;
+    }
+    memset(table, 0, sizeof(overlap) * old->cnt * new->cnt);
+    for (i = 0; i < new->cnt; ++i) {
+        for (j = 0; j < old->cnt; ++j) {
+            OV_ENTRY(i, j) = dht_overlap_calc(old, j, new, i);
+        }
+    }
+
+    for (i = 0; i < new->cnt; i++) {
+        if (new->list[i].err > 0) {
+            /* Subvol might be marked for decommission
+               with EINVAL, or some other serious error
+               marked with positive errno.
+            */
+            continue;
+        }
+
+        max_overlap = 0;
+        max_overlap_idx = i;
+        for (j = (i + 1); j < new->cnt; ++j) {
+            if (new->list[j].err > 0) {
+                /* Subvol might be marked for decommission
+                with EINVAL, or some other serious error
+                marked with positive errno.
+                */
+                continue;
+            }
+            /* Calculate the overlap now. */
+            curr_overlap = OV_ENTRY(i, i) + OV_ENTRY(j, j);
+            /* Calculate the overlap after the proposed swap. */
+            overlap = OV_ENTRY(i, j) + OV_ENTRY(j, i);
+            /* Are we better than status quo? */
+            if (overlap > curr_overlap) {
+                overlap -= curr_overlap;
+                /* Are we better than the previous choice? */
+                if (overlap > max_overlap) {
+                    max_overlap = overlap;
+                    max_overlap_idx = j;
+                }
+            }
+        }
+
+        if (max_overlap_idx != i) {
+            dht_layout_range_swap(new, i, max_overlap_idx);
+            /* Need to swap the table values too. */
+            for (j = 0; j < old->cnt; ++j) {
+                overlap = OV_ENTRY(i, j);
+                OV_ENTRY(i, j) = OV_ENTRY(max_overlap_idx, j);
+                OV_ENTRY(max_overlap_idx, j) = overlap;
+            }
+        }
+    }
 }
 
-
 dht_layout_t *
-dht_fix_layout_of_directory (call_frame_t *frame, loc_t *loc,
-                             dht_layout_t *layout)
+dht_fix_layout_of_directory(call_frame_t *frame, loc_t *loc,
+                            dht_layout_t *layout)
 {
-        int           i                         = 0;
-        xlator_t     *this                      = NULL;
-        dht_layout_t *new_layout                = NULL;
-        dht_conf_t   *priv                      = NULL;
-        dht_local_t  *local                     = NULL;
-        uint32_t      subvol_down               = 0;
-        int           ret                       = 0;
-        gf_boolean_t  maximize_overlap          = _gf_true;
-        char          gfid[GF_UUID_BUF_SIZE]    = {0};
-
-        this  = frame->this;
-        priv  = this->private;
-        local = frame->local;
-
-        if (layout->type == DHT_HASH_TYPE_DM_USER) {
-                gf_msg_debug (THIS->name, 0, "leaving %s alone",
-                              loc->path);
-                goto done;
-        }
-
-        new_layout = dht_layout_new (this, priv->subvolume_cnt);
-        if (!new_layout) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                        "mem allocation failed for new_layout, path:%s gfid:%s",
-                        loc->path, gfid);
-                goto done;
-        }
-
-        /* If a subvolume is down, do not re-write the layout. */
-        ret = dht_layout_anomalies (this, loc, layout, NULL, NULL, NULL,
-                                    &subvol_down, NULL, NULL);
-
-        if (subvol_down || (ret == -1)) {
-                gf_uuid_unparse (loc->gfid, gfid);
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_LAYOUT_FIX_FAILED,
-                        "Layout fix failed: %u subvolume(s) are down"
-                        ". Skipping fix layout. path:%s gfid:%s", subvol_down,
-                        loc->path, gfid);
-                GF_FREE (new_layout);
-                return NULL;
-        }
-
-        for (i = 0; i < new_layout->cnt; i++) {
-		if (layout->list[i].err != ENOSPC)
-			new_layout->list[i].err = layout->list[i].err;
-		else
-			new_layout->list[i].err = -1;
-
-		new_layout->list[i].xlator = layout->list[i].xlator;
-        }
-
-        new_layout->commit_hash = layout->commit_hash;
-
-        if (priv->du_stats) {
-                for (i = 0; i < priv->subvolume_cnt; ++i) {
-                        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                                DHT_MSG_SUBVOL_INFO,
-                                "subvolume %d (%s): %u chunks, path:%s", i,
-                                priv->subvolumes[i]->name,
-                                priv->du_stats[i].chunks, loc->path);
-
-                        /* Maximize overlap if the bricks are all the same
-                         *  size.
-                         * This is probably not going to be very common on
-                         * live setups but will benefit our regression tests
-                         */
-                        if (i && (priv->du_stats[i].chunks
-                                  != priv->du_stats[0].chunks)) {
-                                maximize_overlap = _gf_false;
-                        }
-                }
-        } else {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_NO_DISK_USAGE_STATUS, "no du stats ?!?");
-        }
-
-	/* First give it a layout as though it is a new directory. This
-	   ensures rotation to kick in */
-        dht_layout_sort_volname (new_layout);
-	dht_selfheal_layout_new_directory (frame, loc, new_layout);
-
-
-        /* Maximize overlap if weighted-rebalance is disabled */
-        if (!priv->do_weighting)
-                maximize_overlap = _gf_true;
-
-	/* Now selectively re-assign ranges only when it helps */
-        if (maximize_overlap) {
-                dht_selfheal_layout_maximize_overlap (frame, loc, new_layout,
-                                                      layout);
-        }
+    int i = 0;
+    xlator_t *this = NULL;
+    dht_layout_t *new_layout = NULL;
+    dht_conf_t *priv = NULL;
+    dht_local_t *local = NULL;
+    uint32_t subvol_down = 0;
+    int ret = 0;
+    gf_boolean_t maximize_overlap = _gf_true;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    this = frame->this;
+    priv = this->private;
+    local = frame->local;
+
+    if (layout->type == DHT_HASH_TYPE_DM_USER) {
+        gf_msg_debug(THIS->name, 0, "leaving %s alone", loc->path);
+        goto done;
+    }
+
+    new_layout = dht_layout_new(this, priv->subvolume_cnt);
+    if (!new_layout) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "mem allocation failed for new_layout, path:%s gfid:%s",
+               loc->path, gfid);
+        goto done;
+    }
+
+    /* If a subvolume is down, do not re-write the layout. */
+    ret = dht_layout_anomalies(this, loc, layout, NULL, NULL, NULL,
+                               &subvol_down, NULL, NULL);
+
+    if (subvol_down || (ret == -1)) {
+        gf_uuid_unparse(loc->gfid, gfid);
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_LAYOUT_FIX_FAILED,
+               "Layout fix failed: %u subvolume(s) are down"
+               ". Skipping fix layout. path:%s gfid:%s",
+               subvol_down, loc->path, gfid);
+        GF_FREE(new_layout);
+        return NULL;
+    }
+
+    for (i = 0; i < new_layout->cnt; i++) {
+        if (layout->list[i].err != ENOSPC)
+            new_layout->list[i].err = layout->list[i].err;
+        else
+            new_layout->list[i].err = -1;
+
+        new_layout->list[i].xlator = layout->list[i].xlator;
+    }
+
+    new_layout->commit_hash = layout->commit_hash;
+
+    if (priv->du_stats) {
+        for (i = 0; i < priv->subvolume_cnt; ++i) {
+            gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_SUBVOL_INFO,
+                   "subvolume %d (%s): %u chunks, path:%s", i,
+                   priv->subvolumes[i]->name, priv->du_stats[i].chunks,
+                   loc->path);
+
+            /* Maximize overlap if the bricks are all the same
+             *  size.
+             * This is probably not going to be very common on
+             * live setups but will benefit our regression tests
+             */
+            if (i && (priv->du_stats[i].chunks != priv->du_stats[0].chunks)) {
+                maximize_overlap = _gf_false;
+            }
+        }
+    } else {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_NO_DISK_USAGE_STATUS,
+               "no du stats ?!?");
+    }
+
+    /* First give it a layout as though it is a new directory. This
+       ensures rotation to kick in */
+    dht_layout_sort_volname(new_layout);
+    dht_selfheal_layout_new_directory(frame, loc, new_layout);
+
+    /* Maximize overlap if weighted-rebalance is disabled */
+    if (!priv->do_weighting)
+        maximize_overlap = _gf_true;
+
+    /* Now selectively re-assign ranges only when it helps */
+    if (maximize_overlap) {
+        dht_selfheal_layout_maximize_overlap(frame, loc, new_layout, layout);
+    }
 done:
-        if (new_layout) {
-
-                /* Make sure the extra 'ref' for existing layout is removed */
-                dht_layout_unref (this, local->layout);
+    if (new_layout) {
+        /* Make sure the extra 'ref' for existing layout is removed */
+        dht_layout_unref(this, local->layout);
 
-                local->layout = new_layout;
-        }
+        local->layout = new_layout;
+    }
 
-        return local->layout;
+    return local->layout;
 }
 
-
 /*
  * Having to call this 2x for each entry in the layout is pretty horrible, but
  * that's what all of this layout-sorting nonsense gets us.
  */
 uint32_t
-dht_get_chunks_from_xl (xlator_t *parent, xlator_t *child)
+dht_get_chunks_from_xl(xlator_t *parent, xlator_t *child)
 {
-        dht_conf_t      *priv   = parent->private;
-        xlator_list_t   *trav;
-        uint32_t        index   = 0;
+    dht_conf_t *priv = parent->private;
+    xlator_list_t *trav;
+    uint32_t index = 0;
 
-        if (!priv->du_stats) {
-                return 0;
-        }
+    if (!priv->du_stats) {
+        return 0;
+    }
 
-        for (trav = parent->children; trav; trav = trav->next) {
-                if (trav->xlator == child) {
-                        return priv->du_stats[index].chunks;
-                }
-                ++index;
+    for (trav = parent->children; trav; trav = trav->next) {
+        if (trav->xlator == child) {
+            return priv->du_stats[index].chunks;
         }
+        ++index;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 void
-dht_selfheal_layout_new_directory (call_frame_t *frame, loc_t *loc,
-                                   dht_layout_t *layout)
+dht_selfheal_layout_new_directory(call_frame_t *frame, loc_t *loc,
+                                  dht_layout_t *layout)
 {
-        xlator_t    *this = NULL;
-        double       chunk = 0;
-        int          i = 0;
-        uint32_t     start = 0;
-        int          bricks_to_use = 0;
-        int          err = 0;
-        int          start_subvol = 0;
-        uint32_t     curr_size;
-        uint32_t     range_size;
-        uint64_t     total_size = 0;
-        int          real_i;
-        dht_conf_t   *priv;
-        gf_boolean_t weight_by_size;
-        int          bricks_used = 0;
-
-        this = frame->this;
-        priv = this->private;
-        weight_by_size = priv->do_weighting;
-
-        bricks_to_use = dht_get_layout_count (this, layout, 1);
-        GF_ASSERT (bricks_to_use > 0);
-
-        bricks_used = 0;
-        for (i = 0; i < layout->cnt; ++i) {
-                err = layout->list[i].err;
-                if ((err != -1) && (err != ENOENT)) {
-                        continue;
-                }
-                curr_size = dht_get_chunks_from_xl (this,
-                                                    layout->list[i].xlator);
-                if (!curr_size) {
-                        weight_by_size = _gf_false;
-                        break;
-                }
-                total_size += curr_size;
-                if (++bricks_used >= bricks_to_use) {
-                        break;
-                }
-        }
-
-        if (weight_by_size && total_size) {
-                /* We know total_size is not zero. */
-                chunk = ((double) 0xffffffff) / ((double) total_size);
-                gf_msg_debug (this->name, 0,
-                              "chunk size = 0xffffffff / %lu = %f",
-                              total_size, chunk);
-        }
-        else {
-                weight_by_size = _gf_false;
-                chunk = ((unsigned long) 0xffffffff) / bricks_to_use;
+    xlator_t *this = NULL;
+    double chunk = 0;
+    int i = 0;
+    uint32_t start = 0;
+    int bricks_to_use = 0;
+    int err = 0;
+    int start_subvol = 0;
+    uint32_t curr_size;
+    uint32_t range_size;
+    uint64_t total_size = 0;
+    int real_i;
+    dht_conf_t *priv;
+    gf_boolean_t weight_by_size;
+    int bricks_used = 0;
+
+    this = frame->this;
+    priv = this->private;
+    weight_by_size = priv->do_weighting;
+
+    bricks_to_use = dht_get_layout_count(this, layout, 1);
+    GF_ASSERT(bricks_to_use > 0);
+
+    bricks_used = 0;
+    for (i = 0; i < layout->cnt; ++i) {
+        err = layout->list[i].err;
+        if ((err != -1) && (err != ENOENT)) {
+            continue;
+        }
+        curr_size = dht_get_chunks_from_xl(this, layout->list[i].xlator);
+        if (!curr_size) {
+            weight_by_size = _gf_false;
+            break;
+        }
+        total_size += curr_size;
+        if (++bricks_used >= bricks_to_use) {
+            break;
+        }
+    }
+
+    if (weight_by_size && total_size) {
+        /* We know total_size is not zero. */
+        chunk = ((double)0xffffffff) / ((double)total_size);
+        gf_msg_debug(this->name, 0, "chunk size = 0xffffffff / %lu = %f",
+                     total_size, chunk);
+    } else {
+        weight_by_size = _gf_false;
+        chunk = ((unsigned long)0xffffffff) / bricks_to_use;
+    }
+
+    start_subvol = dht_selfheal_layout_alloc_start(this, loc, layout);
+
+    /* clear out the range, as we are re-computing here */
+    DHT_RESET_LAYOUT_RANGE(layout);
+
+    /*
+     * OK, what's this "real_i" stuff about?  This used to be two loops -
+     * from start_subvol to layout->cnt-1, then from 0 to start_subvol-1.
+     * That way is practically an open invitation to bugs when only one
+     * of the loops is updated.  Using real_i and modulo operators to make
+     * it one loop avoids this problem.  Remember, folks: it's everyone's
+     * responsibility to help stamp out copy/paste abuse.
+     */
+    bricks_used = 0;
+    for (real_i = 0; real_i < layout->cnt; real_i++) {
+        i = (real_i + start_subvol) % layout->cnt;
+        err = layout->list[i].err;
+        if ((err != -1) && (err != ENOENT)) {
+            continue;
+        }
+        if (weight_by_size) {
+            curr_size = dht_get_chunks_from_xl(this, layout->list[i].xlator);
+            if (!curr_size) {
+                continue;
+            }
+        } else {
+            curr_size = 1;
         }
-
-        start_subvol = dht_selfheal_layout_alloc_start (this, loc, layout);
-
-        /* clear out the range, as we are re-computing here */
-        DHT_RESET_LAYOUT_RANGE (layout);
-
-        /*
-         * OK, what's this "real_i" stuff about?  This used to be two loops -
-         * from start_subvol to layout->cnt-1, then from 0 to start_subvol-1.
-         * That way is practically an open invitation to bugs when only one
-         * of the loops is updated.  Using real_i and modulo operators to make
-         * it one loop avoids this problem.  Remember, folks: it's everyone's
-         * responsibility to help stamp out copy/paste abuse.
-         */
-        bricks_used = 0;
-        for (real_i = 0; real_i < layout->cnt; real_i++) {
-                i = (real_i + start_subvol) % layout->cnt;
-                err = layout->list[i].err;
-                if ((err != -1) && (err != ENOENT)) {
-                        continue;
-                }
-                if (weight_by_size) {
-                        curr_size = dht_get_chunks_from_xl (this,
-                                layout->list[i].xlator);
-                        if (!curr_size) {
-                                continue;
-                        }
-                }
-                else {
-                        curr_size = 1;
-                }
-                range_size = chunk * curr_size;
-                gf_msg_debug (this->name, 0,
-                              "assigning range size 0x%x to %s",
-                              range_size,
-                              layout->list[i].xlator->name);
-                DHT_SET_LAYOUT_RANGE(layout, i, start, range_size,
-                                     loc->path);
-                if (++bricks_used >= bricks_to_use) {
-                        layout->list[i].stop = 0xffffffff;
-                        goto done;
-                }
-                start += range_size;
+        range_size = chunk * curr_size;
+        gf_msg_debug(this->name, 0, "assigning range size 0x%x to %s",
+                     range_size, layout->list[i].xlator->name);
+        DHT_SET_LAYOUT_RANGE(layout, i, start, range_size, loc->path);
+        if (++bricks_used >= bricks_to_use) {
+            layout->list[i].stop = 0xffffffff;
+            goto done;
         }
+        start += range_size;
+    }
 
 done:
-        return;
+    return;
 }
 
 int
-dht_selfheal_dir_getafix (call_frame_t *frame, loc_t *loc,
-                          dht_layout_t *layout)
+dht_selfheal_dir_getafix(call_frame_t *frame, loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local = NULL;
-        uint32_t     holes = 0;
-        int          ret = -1;
-        int          i = -1;
-        uint32_t     overlaps = 0;
-
-        local = frame->local;
-
-        holes = local->selfheal.hole_cnt;
-        overlaps = local->selfheal.overlaps_cnt;
-
-        if (holes || overlaps) {
-                /* If the layout has anomalies which would change the hash
-                 * ranges, then we need to reset the commit_hash for this
-                 * directory, as the layout would change and things may not
-                 * be in place as expected */
-                layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
-                dht_selfheal_layout_new_directory (frame, loc, layout);
-                ret = 0;
-        }
+    dht_local_t *local = NULL;
+    uint32_t holes = 0;
+    int ret = -1;
+    int i = -1;
+    uint32_t overlaps = 0;
+
+    local = frame->local;
+
+    holes = local->selfheal.hole_cnt;
+    overlaps = local->selfheal.overlaps_cnt;
+
+    if (holes || overlaps) {
+        /* If the layout has anomalies which would change the hash
+         * ranges, then we need to reset the commit_hash for this
+         * directory, as the layout would change and things may not
+         * be in place as expected */
+        layout->commit_hash = DHT_LAYOUT_HASH_INVALID;
+        dht_selfheal_layout_new_directory(frame, loc, layout);
+        ret = 0;
+    }
 
-        for (i = 0; i < layout->cnt; i++) {
-                /* directory not present */
-                if (layout->list[i].err == ENOENT) {
-                        ret = 0;
-                        break;
-                }
+    for (i = 0; i < layout->cnt; i++) {
+        /* directory not present */
+        if (layout->list[i].err == ENOENT) {
+            ret = 0;
+            break;
         }
+    }
 
-        /* TODO: give a fix to these non-virgins */
+    /* TODO: give a fix to these non-virgins */
 
-        return ret;
+    return ret;
 }
 
 int
-dht_selfheal_new_directory (call_frame_t *frame,
-                            dht_selfheal_dir_cbk_t dir_cbk,
-                            dht_layout_t *layout)
+dht_selfheal_new_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                           dht_layout_t *layout)
 {
-        dht_local_t *local                   = NULL;
-        int          ret                     = 0;
-        inode_t     *linked_inode            = NULL, *inode = NULL;
-        loc_t       *loc                     = NULL;
-        char         pgfid[GF_UUID_BUF_SIZE] = {0};
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        int32_t      op_errno                = EIO;
-
-        local = frame->local;
-
-        loc = &local->loc;
-
-        gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
-        gf_uuid_unparse(loc->parent->gfid, pgfid);
-
-        linked_inode = inode_link (loc->inode, loc->parent, loc->name,
-                                   &local->stbuf);
-        if (!linked_inode) {
-                gf_msg (frame->this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "linking inode failed (%s/%s) => %s",
-                        pgfid, loc->name, gfid);
-                ret = -1;
-                goto out;
-        }
-
-        inode = loc->inode;
-        loc->inode = linked_inode;
-        inode_unref (inode);
-
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
-
-        dht_layout_sort_volname (layout);
-        dht_selfheal_layout_new_directory (frame, &local->loc, layout);
-
-        op_errno = ENOMEM;
-        ret = dht_selfheal_layout_lock (frame, layout, _gf_true,
-                                        dht_selfheal_dir_xattr,
-                                        dht_should_heal_layout);
+    dht_local_t *local = NULL;
+    int ret = 0;
+    inode_t *linked_inode = NULL, *inode = NULL;
+    loc_t *loc = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t op_errno = EIO;
+
+    local = frame->local;
+
+    loc = &local->loc;
+
+    gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+    gf_uuid_unparse(loc->parent->gfid, pgfid);
+
+    linked_inode = inode_link(loc->inode, loc->parent, loc->name,
+                              &local->stbuf);
+    if (!linked_inode) {
+        gf_msg(frame->this->name, GF_LOG_WARNING, 0,
+               DHT_MSG_DIR_SELFHEAL_FAILED,
+               "linking inode failed (%s/%s) => %s", pgfid, loc->name, gfid);
+        ret = -1;
+        goto out;
+    }
+
+    inode = loc->inode;
+    loc->inode = linked_inode;
+    inode_unref(inode);
+
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
+
+    dht_layout_sort_volname(layout);
+    dht_selfheal_layout_new_directory(frame, &local->loc, layout);
+
+    op_errno = ENOMEM;
+    ret = dht_selfheal_layout_lock(frame, layout, _gf_true,
+                                   dht_selfheal_dir_xattr,
+                                   dht_should_heal_layout);
 
 out:
-        if (ret < 0) {
-                dir_cbk (frame, NULL, frame->this, -1, op_errno, NULL);
-        }
+    if (ret < 0) {
+        dir_cbk(frame, NULL, frame->this, -1, op_errno, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_fix_directory_layout (call_frame_t *frame,
-                          dht_selfheal_dir_cbk_t dir_cbk,
-                          dht_layout_t *layout)
+dht_fix_directory_layout(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                         dht_layout_t *layout)
 {
-        dht_local_t  *local      = NULL;
-        dht_layout_t *tmp_layout = NULL;
-        int           ret        = 0;
+    dht_local_t *local = NULL;
+    dht_layout_t *tmp_layout = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
 
-        /* No layout sorting required here */
-        tmp_layout = dht_fix_layout_of_directory (frame, &local->loc, layout);
-        if (!tmp_layout) {
-                return -1;
-        }
+    /* No layout sorting required here */
+    tmp_layout = dht_fix_layout_of_directory(frame, &local->loc, layout);
+    if (!tmp_layout) {
+        return -1;
+    }
 
-        ret = dht_selfheal_layout_lock (frame, tmp_layout, _gf_false,
-                                        dht_fix_dir_xattr,
-                                        dht_should_fix_layout);
+    ret = dht_selfheal_layout_lock(frame, tmp_layout, _gf_false,
+                                   dht_fix_dir_xattr, dht_should_fix_layout);
 
-        return ret;
+    return ret;
 }
 
-
 int
-dht_selfheal_directory (call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
-                        loc_t *loc, dht_layout_t *layout)
+dht_selfheal_directory(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                       loc_t *loc, dht_layout_t *layout)
 {
-        dht_local_t *local                   = NULL;
-        uint32_t     down                    = 0;
-        uint32_t     misc                    = 0;
-        int          ret                     = 0;
-        xlator_t    *this                    = NULL;
-        char         pgfid[GF_UUID_BUF_SIZE] = {0};
-        char         gfid[GF_UUID_BUF_SIZE]  = {0};
-        inode_t     *linked_inode            = NULL, *inode = NULL;
-
-        local = frame->local;
-        this = frame->this;
-
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (this, layout);
-
-        if (!__is_root_gfid (local->stbuf.ia_gfid)) {
-                gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
-                gf_uuid_unparse(loc->parent->gfid, pgfid);
-
-                linked_inode = inode_link (loc->inode, loc->parent, loc->name,
-                                           &local->stbuf);
-                if (!linked_inode) {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_FAILED,
-                                "linking inode failed (%s/%s) => %s",
-                                pgfid, loc->name, gfid);
-                        ret = 0;
-                        goto sorry_no_fix;
-                }
+    dht_local_t *local = NULL;
+    uint32_t down = 0;
+    uint32_t misc = 0;
+    int ret = 0;
+    xlator_t *this = NULL;
+    char pgfid[GF_UUID_BUF_SIZE] = {0};
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    inode_t *linked_inode = NULL, *inode = NULL;
+
+    local = frame->local;
+    this = frame->this;
+
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(this, layout);
+
+    if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+        gf_uuid_unparse(local->stbuf.ia_gfid, gfid);
+        gf_uuid_unparse(loc->parent->gfid, pgfid);
 
-                inode = loc->inode;
-                loc->inode = linked_inode;
-                inode_unref (inode);
+        linked_inode = inode_link(loc->inode, loc->parent, loc->name,
+                                  &local->stbuf);
+        if (!linked_inode) {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_SELFHEAL_FAILED,
+                   "linking inode failed (%s/%s) => %s", pgfid, loc->name,
+                   gfid);
+            ret = 0;
+            goto sorry_no_fix;
         }
 
-        dht_layout_anomalies (this, loc, layout,
-                              &local->selfheal.hole_cnt,
-                              &local->selfheal.overlaps_cnt,
-                              &local->selfheal.missing_cnt,
-                              &local->selfheal.down,
-                              &local->selfheal.misc, NULL);
-
-        down     = local->selfheal.down;
-        misc     = local->selfheal.misc;
-
-        if (down) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed: %d subvolumes down."
-                        "Not fixing. path = %s, gfid = %s",
-                        down, loc->path, gfid);
-                ret = 0;
-                goto sorry_no_fix;
-        }
+        inode = loc->inode;
+        loc->inode = linked_inode;
+        inode_unref(inode);
+    }
+
+    dht_layout_anomalies(this, loc, layout, &local->selfheal.hole_cnt,
+                         &local->selfheal.overlaps_cnt,
+                         &local->selfheal.missing_cnt, &local->selfheal.down,
+                         &local->selfheal.misc, NULL);
+
+    down = local->selfheal.down;
+    misc = local->selfheal.misc;
+
+    if (down) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_SELFHEAL_FAILED,
+               "Directory selfheal failed: %d subvolumes down."
+               "Not fixing. path = %s, gfid = %s",
+               down, loc->path, gfid);
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        if (misc) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_SELFHEAL_FAILED,
-                        "Directory selfheal failed : %d subvolumes "
-                        "have unrecoverable errors. path = %s, gfid = %s",
-                        misc, loc->path, gfid);
+    if (misc) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_SELFHEAL_FAILED,
+               "Directory selfheal failed : %d subvolumes "
+               "have unrecoverable errors. path = %s, gfid = %s",
+               misc, loc->path, gfid);
 
-                ret = 0;
-                goto sorry_no_fix;
-        }
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        dht_layout_sort_volname (layout);
-        local->heal_layout = _gf_true;
+    dht_layout_sort_volname(layout);
+    local->heal_layout = _gf_true;
 
-        /* Ignore return value as it can be inferred from result of
-         * dht_layout_anomalies
-         */
-        dht_selfheal_dir_getafix (frame, loc, layout);
+    /* Ignore return value as it can be inferred from result of
+     * dht_layout_anomalies
+     */
+    dht_selfheal_dir_getafix(frame, loc, layout);
 
-        if (!(local->selfheal.hole_cnt || local->selfheal.overlaps_cnt ||
-              local->selfheal.missing_cnt)) {
-                local->heal_layout = _gf_false;
-        }
+    if (!(local->selfheal.hole_cnt || local->selfheal.overlaps_cnt ||
+          local->selfheal.missing_cnt)) {
+        local->heal_layout = _gf_false;
+    }
 
-        ret = dht_selfheal_dir_mkdir (frame, loc, layout, 0);
-        if (ret < 0) {
-                ret = 0;
-                goto sorry_no_fix;
-        }
+    ret = dht_selfheal_dir_mkdir(frame, loc, layout, 0);
+    if (ret < 0) {
+        ret = 0;
+        goto sorry_no_fix;
+    }
 
-        return 0;
+    return 0;
 
 sorry_no_fix:
-        /* TODO: need to put appropriate local->op_errno */
-        dht_selfheal_dir_finish (frame, this, ret, 1);
+    /* TODO: need to put appropriate local->op_errno */
+    dht_selfheal_dir_finish(frame, this, ret, 1);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_selfheal_restore (call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
-                      loc_t *loc, dht_layout_t *layout)
+dht_selfheal_restore(call_frame_t *frame, dht_selfheal_dir_cbk_t dir_cbk,
+                     loc_t *loc, dht_layout_t *layout)
 {
-        int          ret = 0;
-        dht_local_t *local    = NULL;
+    int ret = 0;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        local->selfheal.dir_cbk = dir_cbk;
-        local->selfheal.layout = dht_layout_ref (frame->this, layout);
+    local->selfheal.dir_cbk = dir_cbk;
+    local->selfheal.layout = dht_layout_ref(frame->this, layout);
 
-        ret = dht_selfheal_dir_mkdir (frame, loc, layout, 1);
+    ret = dht_selfheal_dir_mkdir(frame, loc, layout, 1);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_dir_heal_xattrs (void *data)
+dht_dir_heal_xattrs(void *data)
 {
-        call_frame_t    *frame          = NULL;
-        dht_local_t     *local          = NULL;
-        xlator_t        *subvol         = NULL;
-        xlator_t        *mds_subvol     = NULL;
-        xlator_t        *this           = NULL;
-        dht_conf_t      *conf           = NULL;
-        dict_t          *user_xattr     = NULL;
-        dict_t          *internal_xattr = NULL;
-        dict_t          *mds_xattr   = NULL;
-        dict_t          *xdata          = NULL;
-        int              call_cnt       = 0;
-        int              ret            = -1;
-        int              uret           = 0;
-        int              uflag          = 0;
-        int              i              = 0;
-        int              xattr_hashed   = 0;
-        char     gfid[GF_UUID_BUF_SIZE] = {0};
-        int32_t    allzero[1]           = {0};
-
-        GF_VALIDATE_OR_GOTO ("dht", data, out);
-
-        frame = data;
-        local = frame->local;
-        this = frame->this;
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, local, out);
-        mds_subvol = local->mds_subvol;
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-        gf_uuid_unparse(local->loc.gfid, gfid);
-
-        if (!mds_subvol) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                        "No mds subvol for %s gfid = %s",
-                        local->loc.path, gfid);
-                goto out;
-        }
-
-        if ((local->loc.inode && gf_uuid_is_null (local->loc.inode->gfid)) ||
-            gf_uuid_is_null (local->loc.gfid)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                        "No gfid present so skip heal for path %s gfid = %s",
-                        local->loc.path, gfid);
-                goto out;
-        }
-
-        internal_xattr = dict_new ();
-        if (!internal_xattr) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
-                        "dictionary creation failed");
-                goto out;
-        }
-        xdata = dict_new ();
-        if (!xdata) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
-                        "dictionary creation failed");
-                goto out;
-        }
-
-        call_cnt = conf->subvolume_cnt;
-
-        user_xattr = dict_new ();
-        if (!user_xattr) {
-                gf_msg (this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
-                        "dictionary creation failed");
-                goto out;
-        }
-
-        ret = syncop_listxattr (local->mds_subvol, &local->loc,
-                                &mds_xattr, NULL, NULL);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                        "failed to list xattrs for "
-                        "%s: on %s ",
-                        local->loc.path, local->mds_subvol->name);
-        }
-
-        if (!mds_xattr)
-                goto out;
-
-        dht_dir_set_heal_xattr (this, local, user_xattr, mds_xattr,
-                                &uret, &uflag);
-
-        /* To set quota related xattr need to set GLUSTERFS_INTERNAL_FOP_KEY
-         * key value to 1
-         */
-        if (dict_get (user_xattr, QUOTA_LIMIT_KEY) ||
-            dict_get (user_xattr, QUOTA_LIMIT_OBJECTS_KEY)) {
-                ret = dict_set_int32 (xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value: key = %s,"
-                                " path = %s", GLUSTERFS_INTERNAL_FOP_KEY,
-                                 local->loc.path);
-                        goto out;
-                }
-        }
-        if (uret <= 0 && !uflag)
-                goto out;
-
-        for (i = 0; i < call_cnt; i++) {
-                subvol = conf->subvolumes[i];
-                if (subvol == mds_subvol)
-                        continue;
-                if (uret || uflag) {
-                        ret = syncop_setxattr (subvol, &local->loc, user_xattr,
-                                               0, xdata, NULL);
-                        if (ret) {
-                                xattr_hashed = 1;
-                                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                        DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                        "Directory xattr heal failed. Failed to set"
-                                        "user xattr on path %s on "
-                                        "subvol %s, gfid = %s ",
-                                        local->loc.path, subvol->name, gfid);
-                        }
-                }
-        }
-        /* After heal all custom xattr reset internal MDS xattr to 0 */
-        if (!xattr_hashed) {
-                ret = dht_dict_set_array (internal_xattr,
-                                          conf->mds_xattr_key,
-                                          allzero, 1);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_WARNING, ENOMEM,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dictionary value:key = %s for "
-                                "path %s", conf->mds_xattr_key,
-                                local->loc.path);
-                        goto out;
-                }
-                ret = syncop_setxattr (mds_subvol, &local->loc, internal_xattr,
-                                       0, NULL, NULL);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_XATTR_HEAL_FAILED,
-                                "Failed to reset internal xattr "
-                                "on path %s on subvol %s"
-                                "gfid = %s ", local->loc.path,
-                                mds_subvol->name, gfid);
-                }
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    dict_t *user_xattr = NULL;
+    dict_t *internal_xattr = NULL;
+    dict_t *mds_xattr = NULL;
+    dict_t *xdata = NULL;
+    int call_cnt = 0;
+    int ret = -1;
+    int uret = 0;
+    int uflag = 0;
+    int i = 0;
+    int xattr_hashed = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+    int32_t allzero[1] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", data, out);
+
+    frame = data;
+    local = frame->local;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, local, out);
+    mds_subvol = local->mds_subvol;
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+    gf_uuid_unparse(local->loc.gfid, gfid);
+
+    if (!mds_subvol) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+               "No mds subvol for %s gfid = %s", local->loc.path, gfid);
+        goto out;
+    }
+
+    if ((local->loc.inode && gf_uuid_is_null(local->loc.inode->gfid)) ||
+        gf_uuid_is_null(local->loc.gfid)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+               "No gfid present so skip heal for path %s gfid = %s",
+               local->loc.path, gfid);
+        goto out;
+    }
+
+    internal_xattr = dict_new();
+    if (!internal_xattr) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+               "dictionary creation failed");
+        goto out;
+    }
+    xdata = dict_new();
+    if (!xdata) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+               "dictionary creation failed");
+        goto out;
+    }
+
+    call_cnt = conf->subvolume_cnt;
+
+    user_xattr = dict_new();
+    if (!user_xattr) {
+        gf_msg(this->name, GF_LOG_ERROR, DHT_MSG_NO_MEMORY, 0,
+               "dictionary creation failed");
+        goto out;
+    }
+
+    ret = syncop_listxattr(local->mds_subvol, &local->loc, &mds_xattr, NULL,
+                           NULL);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_XATTR_HEAL_FAILED,
+               "failed to list xattrs for "
+               "%s: on %s ",
+               local->loc.path, local->mds_subvol->name);
+    }
+
+    if (!mds_xattr)
+        goto out;
+
+    dht_dir_set_heal_xattr(this, local, user_xattr, mds_xattr, &uret, &uflag);
+
+    /* To set quota related xattr need to set GLUSTERFS_INTERNAL_FOP_KEY
+     * key value to 1
+     */
+    if (dict_get(user_xattr, QUOTA_LIMIT_KEY) ||
+        dict_get(user_xattr, QUOTA_LIMIT_OBJECTS_KEY)) {
+        ret = dict_set_int32(xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value: key = %s,"
+                   " path = %s",
+                   GLUSTERFS_INTERNAL_FOP_KEY, local->loc.path);
+            goto out;
+        }
+    }
+    if (uret <= 0 && !uflag)
+        goto out;
+
+    for (i = 0; i < call_cnt; i++) {
+        subvol = conf->subvolumes[i];
+        if (subvol == mds_subvol)
+            continue;
+        if (uret || uflag) {
+            ret = syncop_setxattr(subvol, &local->loc, user_xattr, 0, xdata,
+                                  NULL);
+            if (ret) {
+                xattr_hashed = 1;
+                gf_msg(this->name, GF_LOG_ERROR, -ret,
+                       DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                       "Directory xattr heal failed. Failed to set"
+                       "user xattr on path %s on "
+                       "subvol %s, gfid = %s ",
+                       local->loc.path, subvol->name, gfid);
+            }
+        }
+    }
+    /* After heal all custom xattr reset internal MDS xattr to 0 */
+    if (!xattr_hashed) {
+        ret = dht_dict_set_array(internal_xattr, conf->mds_xattr_key, allzero,
+                                 1);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_WARNING, ENOMEM, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dictionary value:key = %s for "
+                   "path %s",
+                   conf->mds_xattr_key, local->loc.path);
+            goto out;
+        }
+        ret = syncop_setxattr(mds_subvol, &local->loc, internal_xattr, 0, NULL,
+                              NULL);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, -ret,
+                   DHT_MSG_DIR_XATTR_HEAL_FAILED,
+                   "Failed to reset internal xattr "
+                   "on path %s on subvol %s"
+                   "gfid = %s ",
+                   local->loc.path, mds_subvol->name, gfid);
         }
+    }
 
 out:
-        if (user_xattr)
-                dict_unref (user_xattr);
-        if (mds_xattr)
-                dict_unref (mds_xattr);
-        if (internal_xattr)
-                dict_unref (internal_xattr);
-        if (xdata)
-                dict_unref (xdata);
-        return 0;
+    if (user_xattr)
+        dict_unref(user_xattr);
+    if (mds_xattr)
+        dict_unref(mds_xattr);
+    if (internal_xattr)
+        dict_unref(internal_xattr);
+    if (xdata)
+        dict_unref(xdata);
+    return 0;
 }
 
-
 int
-dht_dir_heal_xattrs_done (int ret, call_frame_t *sync_frame, void *data)
+dht_dir_heal_xattrs_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        DHT_STACK_DESTROY (sync_frame);
-        return 0;
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
 }
 
-
 int
-dht_dir_attr_heal (void *data)
+dht_dir_attr_heal(void *data)
 {
-        call_frame_t    *frame      = NULL;
-        dht_local_t     *local      = NULL;
-        xlator_t        *subvol     = NULL;
-        xlator_t        *mds_subvol = NULL;
-        xlator_t        *this       = NULL;
-        dht_conf_t      *conf  = NULL;
-        int              call_cnt = 0;
-        int              ret   = -1;
-        int              i     = 0;
-        char             gfid[GF_UUID_BUF_SIZE] = {0};
-
-
-        GF_VALIDATE_OR_GOTO ("dht", data, out);
-
-        frame = data;
-        local = frame->local;
-        mds_subvol = local->mds_subvol;
-        this = frame->this;
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", local, out);
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO ("dht", conf, out);
-
-        call_cnt = conf->subvolume_cnt;
-
-        if (!__is_root_gfid (local->stbuf.ia_gfid) && (!mds_subvol)) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DIR_ATTR_HEAL_FAILED,
-                        "No mds subvol for %s gfid = %s",
-                        local->loc.path, gfid);
-                goto out;
-        }
-
-        if (!__is_root_gfid (local->stbuf.ia_gfid)) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->subvolumes[i] ==  mds_subvol) {
-                                if (!conf->subvolume_status[i]) {
-                                        gf_msg (this->name, GF_LOG_ERROR,
-                                                0,  DHT_MSG_HASHED_SUBVOL_DOWN,
-                                                "mds subvol is down for path "
-                                                " %s gfid is %s Unable to set xattr " ,
-                                                local->loc.path, gfid);
-                                        goto out;
-                                }
-                        }
-                }
+    call_frame_t *frame = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *mds_subvol = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    int call_cnt = 0;
+    int ret = -1;
+    int i = 0;
+    char gfid[GF_UUID_BUF_SIZE] = {0};
+
+    GF_VALIDATE_OR_GOTO("dht", data, out);
+
+    frame = data;
+    local = frame->local;
+    mds_subvol = local->mds_subvol;
+    this = frame->this;
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", local, out);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO("dht", conf, out);
+
+    call_cnt = conf->subvolume_cnt;
+
+    if (!__is_root_gfid(local->stbuf.ia_gfid) && (!mds_subvol)) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DIR_ATTR_HEAL_FAILED,
+               "No mds subvol for %s gfid = %s", local->loc.path, gfid);
+        goto out;
+    }
+
+    if (!__is_root_gfid(local->stbuf.ia_gfid)) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->subvolumes[i] == mds_subvol) {
+                if (!conf->subvolume_status[i]) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           DHT_MSG_HASHED_SUBVOL_DOWN,
+                           "mds subvol is down for path "
+                           " %s gfid is %s Unable to set xattr ",
+                           local->loc.path, gfid);
+                    goto out;
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < call_cnt; i++) {
+        subvol = conf->subvolumes[i];
+        if (!subvol || subvol == mds_subvol)
+            continue;
+        if (__is_root_gfid(local->stbuf.ia_gfid)) {
+            ret = syncop_setattr(
+                subvol, &local->loc, &local->stbuf,
+                (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL,
+                NULL, NULL, NULL);
+        } else {
+            ret = syncop_setattr(
+                subvol, &local->loc, &local->mds_stbuf,
+                (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE), NULL,
+                NULL, NULL, NULL);
         }
 
-        for (i = 0; i < call_cnt; i++) {
-                subvol = conf->subvolumes[i];
-                if (!subvol || subvol == mds_subvol)
-                        continue;
-                if (__is_root_gfid (local->stbuf.ia_gfid)) {
-                        ret = syncop_setattr (subvol, &local->loc, &local->stbuf,
-                                              (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
-                                              NULL, NULL, NULL, NULL);
-                } else {
-                        ret = syncop_setattr (subvol, &local->loc, &local->mds_stbuf,
-                                              (GF_SET_ATTR_UID | GF_SET_ATTR_GID | GF_SET_ATTR_MODE),
-                                              NULL, NULL, NULL, NULL);
-                }
-
-                if (ret) {
-                        gf_uuid_unparse(local->loc.gfid, gfid);
+        if (ret) {
+            gf_uuid_unparse(local->loc.gfid, gfid);
 
-                        gf_msg (this->name, GF_LOG_ERROR, -ret,
-                                DHT_MSG_DIR_ATTR_HEAL_FAILED,
-                                "Directory attr heal failed. Failed to set"
-                                " uid/gid on path %s on subvol %s, gfid = %s ",
-                                local->loc.path, subvol->name, gfid);
-                }
+            gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_DIR_ATTR_HEAL_FAILED,
+                   "Directory attr heal failed. Failed to set"
+                   " uid/gid on path %s on subvol %s, gfid = %s ",
+                   local->loc.path, subvol->name, gfid);
         }
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int
-dht_dir_attr_heal_done (int ret, call_frame_t *sync_frame, void *data)
+dht_dir_attr_heal_done(int ret, call_frame_t *sync_frame, void *data)
 {
-        DHT_STACK_DESTROY (sync_frame);
-        return 0;
+    DHT_STACK_DESTROY(sync_frame);
+    return 0;
 }
 
 /* EXIT: dht_update_commit_hash_for_layout */
 int
-dht_update_commit_hash_for_layout_done (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *xdata)
+dht_update_commit_hash_for_layout_done(call_frame_t *frame, void *cookie,
+                                       xlator_t *this, int32_t op_ret,
+                                       int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        /* preserve oldest error */
-        if (op_ret && !local->op_ret) {
-                local->op_ret = op_ret;
-                local->op_errno = op_errno;
-        }
+    /* preserve oldest error */
+    if (op_ret && !local->op_ret) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+    }
 
-        DHT_STACK_UNWIND (setxattr, frame, local->op_ret,
-                          local->op_errno, NULL);
+    DHT_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-dht_update_commit_hash_for_layout_unlock (call_frame_t *frame, xlator_t *this)
+dht_update_commit_hash_for_layout_unlock(call_frame_t *frame, xlator_t *this)
 {
-        dht_local_t  *local = NULL;
-        int ret = 0;
+    dht_local_t *local = NULL;
+    int ret = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        ret = dht_unlock_inodelk (frame, local->lock[0].layout.my_layout.locks,
-                                   local->lock[0].layout.my_layout.lk_count,
-                                   dht_update_commit_hash_for_layout_done);
-        if (ret < 0) {
-                /* preserve oldest error, just ... */
-                if (!local->op_ret) {
-                        local->op_errno = errno;
-                        local->op_ret = -1;
-                }
+    ret = dht_unlock_inodelk(frame, local->lock[0].layout.my_layout.locks,
+                             local->lock[0].layout.my_layout.lk_count,
+                             dht_update_commit_hash_for_layout_done);
+    if (ret < 0) {
+        /* preserve oldest error, just ... */
+        if (!local->op_ret) {
+            local->op_errno = errno;
+            local->op_ret = -1;
+        }
 
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Winding unlock failed: stale locks left on brick"
-                        " %s", local->loc.path);
+        gf_msg(this->name, GF_LOG_WARNING, errno,
+               DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+               "Winding unlock failed: stale locks left on brick"
+               " %s",
+               local->loc.path);
 
-                dht_update_commit_hash_for_layout_done (frame, NULL, this,
-                                                        0, 0, NULL);
-        }
+        dht_update_commit_hash_for_layout_done(frame, NULL, this, 0, 0, NULL);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_update_commit_hash_for_layout_cbk (call_frame_t *frame, void *cookie,
-                                       xlator_t *this, int op_ret,
-                                       int op_errno, dict_t *xdata)
+dht_update_commit_hash_for_layout_cbk(call_frame_t *frame, void *cookie,
+                                      xlator_t *this, int op_ret, int op_errno,
+                                      dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        int           this_call_cnt = 0;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        /* store first failure, just because */
-        if (op_ret && !local->op_ret) {
-                local->op_ret = op_ret;
-                local->op_errno = op_errno;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    /* store first failure, just because */
+    if (op_ret && !local->op_ret) {
+        local->op_ret = op_ret;
+        local->op_errno = op_errno;
+    }
+    UNLOCK(&frame->lock);
 
-        this_call_cnt = dht_frame_return (frame);
+    this_call_cnt = dht_frame_return(frame);
 
-        if (is_last_call (this_call_cnt)) {
-                dht_update_commit_hash_for_layout_unlock (frame, this);
-        }
+    if (is_last_call(this_call_cnt)) {
+        dht_update_commit_hash_for_layout_unlock(frame, this);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-dht_update_commit_hash_for_layout_resume (call_frame_t *frame, void *cookie,
-                                          xlator_t *this, int32_t op_ret,
-                                          int32_t op_errno, dict_t *xdata)
+dht_update_commit_hash_for_layout_resume(call_frame_t *frame, void *cookie,
+                                         xlator_t *this, int32_t op_ret,
+                                         int32_t op_errno, dict_t *xdata)
 {
-        dht_local_t   *local = NULL;
-        int            count = 1, ret = -1, i = 0, j = 0;
-        dht_conf_t    *conf = NULL;
-        dht_layout_t  *layout = NULL;
-        int32_t       *disk_layout = NULL;
-        dict_t        **xattr = NULL;
-
-        local = frame->local;
-        conf = frame->this->private;
-        count = conf->local_subvols_cnt;
-        layout = local->layout;
-
-        if (op_ret < 0) {
-                goto err_done;
-        }
-
-        /* We precreate the xattr list as we cannot change call count post the
-         * first wind as we may never continue from there. So we finish prep
-         * work before winding the setxattrs */
-        xattr = GF_CALLOC (count, sizeof (*xattr), gf_common_mt_char);
-        if (!xattr) {
-                local->op_errno = errno;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0, j = 0;
+    dht_conf_t *conf = NULL;
+    dht_layout_t *layout = NULL;
+    int32_t *disk_layout = NULL;
+    dict_t **xattr = NULL;
+
+    local = frame->local;
+    conf = frame->this->private;
+    count = conf->local_subvols_cnt;
+    layout = local->layout;
+
+    if (op_ret < 0) {
+        goto err_done;
+    }
+
+    /* We precreate the xattr list as we cannot change call count post the
+     * first wind as we may never continue from there. So we finish prep
+     * work before winding the setxattrs */
+    xattr = GF_CALLOC(count, sizeof(*xattr), gf_common_mt_char);
+    if (!xattr) {
+        local->op_errno = errno;
+
+        gf_msg(this->name, GF_LOG_WARNING, errno,
+               DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+               "Directory commit hash update failed:"
+               " %s: Allocation failed",
+               local->loc.path);
+
+        goto err;
+    }
+
+    for (i = 0; i < count; i++) {
+        /* find the layout index for the subvolume */
+        ret = dht_layout_index_for_subvol(layout, conf->local_subvols[i]);
+        if (ret < 0) {
+            local->op_errno = ENOENT;
 
-                gf_msg (this->name, GF_LOG_WARNING, errno,
-                        DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                        "Directory commit hash update failed:"
-                        " %s: Allocation failed", local->loc.path);
+            gf_msg(this->name, GF_LOG_WARNING, 0,
+                   DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+                   "Directory commit hash update failed:"
+                   " %s: (subvol %s) Failed to find disk layout",
+                   local->loc.path, conf->local_subvols[i]->name);
 
-                goto err;
+            goto err;
         }
+        j = ret;
 
-        for (i = 0; i < count; i++) {
-                /* find the layout index for the subvolume */
-                ret = dht_layout_index_for_subvol (layout,
-                                                   conf->local_subvols[i]);
-                if (ret < 0) {
-                        local->op_errno = ENOENT;
-
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: (subvol %s) Failed to find disk layout",
-                                local->loc.path, conf->local_subvols[i]->name);
-
-                        goto err;
-                }
-                j = ret;
-
-                /* update the commit hash for the layout */
-                layout->list[j].commit_hash = layout->commit_hash;
+        /* update the commit hash for the layout */
+        layout->list[j].commit_hash = layout->commit_hash;
 
-                /* extract the current layout */
-                ret = dht_disk_layout_extract (this, layout, j, &disk_layout);
-                if (ret == -1) {
-                        local->op_errno = errno;
-
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: (subvol %s) Failed to extract disk"
-                                " layout", local->loc.path,
-                                conf->local_subvols[i]->name);
+        /* extract the current layout */
+        ret = dht_disk_layout_extract(this, layout, j, &disk_layout);
+        if (ret == -1) {
+            local->op_errno = errno;
 
-                        goto err;
-                }
+            gf_msg(this->name, GF_LOG_WARNING, errno,
+                   DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+                   "Directory commit hash update failed:"
+                   " %s: (subvol %s) Failed to extract disk"
+                   " layout",
+                   local->loc.path, conf->local_subvols[i]->name);
 
-                xattr[i] = dict_new ();
-                if (!xattr[i]) {
-                        local->op_errno = errno;
+            goto err;
+        }
 
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory commit hash update failed:"
-                                " %s: Allocation failed", local->loc.path);
+        xattr[i] = dict_new();
+        if (!xattr[i]) {
+            local->op_errno = errno;
 
-                        goto err;
-                }
+            gf_msg(this->name, GF_LOG_WARNING, errno,
+                   DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+                   "Directory commit hash update failed:"
+                   " %s: Allocation failed",
+                   local->loc.path);
 
-                ret = dict_set_bin (xattr[i], conf->xattr_name,
-                                    disk_layout, 4 * 4);
-                if (ret != 0) {
-                        local->op_errno = ENOMEM;
+            goto err;
+        }
 
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
-                                "Directory self heal xattr failed:"
-                                "%s: (subvol %s) Failed to set xattr"
-                                " dictionary,", local->loc.path,
-                                conf->local_subvols[i]->name);
+        ret = dict_set_bin(xattr[i], conf->xattr_name, disk_layout, 4 * 4);
+        if (ret != 0) {
+            local->op_errno = ENOMEM;
 
-                        goto err;
-                }
-                disk_layout = NULL;
+            gf_msg(this->name, GF_LOG_WARNING, 0,
+                   DHT_MSG_DIR_SELFHEAL_XATTR_FAILED,
+                   "Directory self heal xattr failed:"
+                   "%s: (subvol %s) Failed to set xattr"
+                   " dictionary,",
+                   local->loc.path, conf->local_subvols[i]->name);
 
-                gf_msg_trace (this->name, 0,
-                              "setting commit hash %u on subvolume %s"
-                              " for %s", layout->list[j].commit_hash,
-                              conf->local_subvols[i]->name, local->loc.path);
+            goto err;
         }
+        disk_layout = NULL;
 
-        /* wind the setting of the commit hash across the local subvols */
-        local->call_cnt = count;
-        local->op_ret = 0;
-        local->op_errno = 0;
+        gf_msg_trace(this->name, 0,
+                     "setting commit hash %u on subvolume %s"
+                     " for %s",
+                     layout->list[j].commit_hash, conf->local_subvols[i]->name,
+                     local->loc.path);
+    }
+
+    /* wind the setting of the commit hash across the local subvols */
+    local->call_cnt = count;
+    local->op_ret = 0;
+    local->op_errno = 0;
+    for (i = 0; i < count; i++) {
+        STACK_WIND(frame, dht_update_commit_hash_for_layout_cbk,
+                   conf->local_subvols[i],
+                   conf->local_subvols[i]->fops->setxattr, &local->loc,
+                   xattr[i], 0, NULL);
+    }
+    for (i = 0; i < count; i++)
+        dict_unref(xattr[i]);
+    GF_FREE(xattr);
+
+    return 0;
+err:
+    if (xattr) {
         for (i = 0; i < count; i++) {
-                STACK_WIND (frame, dht_update_commit_hash_for_layout_cbk,
-                            conf->local_subvols[i],
-                            conf->local_subvols[i]->fops->setxattr,
-                            &local->loc, xattr[i], 0, NULL);
-
+            if (xattr[i])
+                dict_unref(xattr[i]);
         }
-        for (i = 0; i < count; i++)
-                dict_unref (xattr[i]);
-        GF_FREE (xattr);
-
-        return 0;
-err:
-        if (xattr) {
-                for (i = 0; i < count; i++) {
-                        if (xattr[i])
-                                dict_unref (xattr[i]);
-                }
 
-                GF_FREE (xattr);
-        }
+        GF_FREE(xattr);
+    }
 
-        GF_FREE (disk_layout);
+    GF_FREE(disk_layout);
 
-        local->op_ret = -1;
+    local->op_ret = -1;
 
-        dht_update_commit_hash_for_layout_unlock (frame, this);
+    dht_update_commit_hash_for_layout_unlock(frame, this);
 
-        return 0;
+    return 0;
 err_done:
-        local->op_ret = -1;
+    local->op_ret = -1;
 
-        dht_update_commit_hash_for_layout_done (frame, NULL, this, 0, 0, NULL);
+    dht_update_commit_hash_for_layout_done(frame, NULL, this, 0, 0, NULL);
 
-        return 0;
+    return 0;
 }
 
 /* ENTER: dht_update_commit_hash_for_layout (see EXIT above)
@@ -2762,55 +2665,52 @@ err_done:
  *  - Unlock and return.
  */
 int
-dht_update_commit_hash_for_layout (call_frame_t *frame)
+dht_update_commit_hash_for_layout(call_frame_t *frame)
 {
-        dht_local_t   *local = NULL;
-        int            count = 1, ret = -1, i = 0;
-        dht_lock_t   **lk_array = NULL;
-        dht_conf_t    *conf = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", frame, err);
-        GF_VALIDATE_OR_GOTO (frame->this->name, frame->local, err);
-
-        local = frame->local;
-        conf = frame->this->private;
-
-        if (!conf->defrag)
-                goto err;
-
-        count = conf->local_subvols_cnt;
-        lk_array = GF_CALLOC (count, sizeof (*lk_array),
-                              gf_common_mt_char);
-        if (lk_array == NULL)
-                goto err;
-
-        for (i = 0; i < count; i++) {
-                lk_array[i] = dht_lock_new (frame->this,
-                                            conf->local_subvols[i],
-                                            &local->loc, F_WRLCK,
-                                            DHT_LAYOUT_HEAL_DOMAIN, NULL,
-                                            FAIL_ON_ANY_ERROR);
-                if (lk_array[i] == NULL)
-                        goto err;
-        }
-
-        local->lock[0].layout.my_layout.locks = lk_array;
-        local->lock[0].layout.my_layout.lk_count = count;
-
-        ret = dht_blocking_inodelk (frame, lk_array, count,
-                                    dht_update_commit_hash_for_layout_resume);
-        if (ret < 0) {
-                local->lock[0].layout.my_layout.locks = NULL;
-                local->lock[0].layout.my_layout.lk_count = 0;
-                goto err;
-        }
-
-        return 0;
+    dht_local_t *local = NULL;
+    int count = 1, ret = -1, i = 0;
+    dht_lock_t **lk_array = NULL;
+    dht_conf_t *conf = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", frame, err);
+    GF_VALIDATE_OR_GOTO(frame->this->name, frame->local, err);
+
+    local = frame->local;
+    conf = frame->this->private;
+
+    if (!conf->defrag)
+        goto err;
+
+    count = conf->local_subvols_cnt;
+    lk_array = GF_CALLOC(count, sizeof(*lk_array), gf_common_mt_char);
+    if (lk_array == NULL)
+        goto err;
+
+    for (i = 0; i < count; i++) {
+        lk_array[i] = dht_lock_new(frame->this, conf->local_subvols[i],
+                                   &local->loc, F_WRLCK, DHT_LAYOUT_HEAL_DOMAIN,
+                                   NULL, FAIL_ON_ANY_ERROR);
+        if (lk_array[i] == NULL)
+            goto err;
+    }
+
+    local->lock[0].layout.my_layout.locks = lk_array;
+    local->lock[0].layout.my_layout.lk_count = count;
+
+    ret = dht_blocking_inodelk(frame, lk_array, count,
+                               dht_update_commit_hash_for_layout_resume);
+    if (ret < 0) {
+        local->lock[0].layout.my_layout.locks = NULL;
+        local->lock[0].layout.my_layout.lk_count = 0;
+        goto err;
+    }
+
+    return 0;
 err:
-        if (lk_array != NULL) {
-                dht_lock_array_free (lk_array, count);
-                GF_FREE (lk_array);
-        }
+    if (lk_array != NULL) {
+        dht_lock_array_free(lk_array, count);
+        GF_FREE(lk_array);
+    }
 
-        return -1;
+    return -1;
 }
diff --git a/xlators/cluster/dht/src/dht-shared.c b/xlators/cluster/dht/src/dht-shared.c
index b5f790b111b..5fd97130d22 100644
--- a/xlators/cluster/dht/src/dht-shared.c
+++ b/xlators/cluster/dht/src/dht-shared.c
@@ -8,36 +8,32 @@
   cases as published by the Free Software Foundation.
 */
 
-
 /* TODO: add NS locking */
 #include "statedump.h"
 #include "dht-common.h"
 #include "dht-messages.h"
 
 #ifndef MAX
-#define MAX(a, b) (((a) > (b))?(a):(b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
-#define GF_DECIDE_DEFRAG_THROTTLE_COUNT(throttle_count, conf) {         \
-                                                                        \
-                pthread_mutex_lock (&conf->defrag->dfq_mutex);          \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "lazy"))              \
-                        conf->defrag->recon_thread_count = 1;           \
-                                                                        \
-                throttle_count =                                        \
-                    MAX ((sysconf(_SC_NPROCESSORS_ONLN) - 4), 4);       \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "normal"))            \
-                        conf->defrag->recon_thread_count =              \
-                                                 (throttle_count / 2);  \
-                                                                        \
-                if (!strcasecmp (conf->dthrottle, "aggressive"))        \
-                        conf->defrag->recon_thread_count =              \
-                                                 throttle_count;        \
-                                                                        \
-                pthread_mutex_unlock (&conf->defrag->dfq_mutex);        \
-        }                                                               \
+#define GF_DECIDE_DEFRAG_THROTTLE_COUNT(throttle_count, conf)                  \
+    {                                                                          \
+        pthread_mutex_lock(&conf->defrag->dfq_mutex);                          \
+                                                                               \
+        if (!strcasecmp(conf->dthrottle, "lazy"))                              \
+            conf->defrag->recon_thread_count = 1;                              \
+                                                                               \
+        throttle_count = MAX((sysconf(_SC_NPROCESSORS_ONLN) - 4), 4);          \
+                                                                               \
+        if (!strcasecmp(conf->dthrottle, "normal"))                            \
+            conf->defrag->recon_thread_count = (throttle_count / 2);           \
+                                                                               \
+        if (!strcasecmp(conf->dthrottle, "aggressive"))                        \
+            conf->defrag->recon_thread_count = throttle_count;                 \
+                                                                               \
+        pthread_mutex_unlock(&conf->defrag->dfq_mutex);                        \
+    }
 
 /* TODO:
    - use volumename in xattr instead of "dht"
@@ -50,1189 +46,1158 @@ struct volume_options options[];
 extern dht_methods_t dht_methods;
 
 void
-dht_layout_dump (dht_layout_t  *layout, const char *prefix)
+dht_layout_dump(dht_layout_t *layout, const char *prefix)
 {
-
-        char    key[GF_DUMP_MAX_BUF_LEN];
-        int     i = 0;
-
-        if (!layout)
-                goto out;
-        if (!prefix)
-                goto out;
-
-        gf_proc_dump_build_key(key, prefix, "cnt");
-        gf_proc_dump_write(key, "%d", layout->cnt);
-        gf_proc_dump_build_key(key, prefix, "preset");
-        gf_proc_dump_write(key, "%d", layout->preset);
-        gf_proc_dump_build_key(key, prefix, "gen");
-        gf_proc_dump_write(key, "%d", layout->gen);
-        if (layout->type != IA_INVAL) {
-                gf_proc_dump_build_key(key, prefix, "inode type");
-                gf_proc_dump_write(key, "%d", layout->type);
-        }
-
-        if  (!IA_ISDIR (layout->type))
-                goto out;
-
-        for (i = 0; i < layout->cnt; i++) {
-                gf_proc_dump_build_key(key, prefix,"list[%d].err", i);
-                gf_proc_dump_write(key, "%d", layout->list[i].err);
-                gf_proc_dump_build_key(key, prefix,"list[%d].start", i);
-                gf_proc_dump_write(key, "%u", layout->list[i].start);
-                gf_proc_dump_build_key(key, prefix,"list[%d].stop", i);
-                gf_proc_dump_write(key, "%u", layout->list[i].stop);
-                if (layout->list[i].xlator) {
-                        gf_proc_dump_build_key(key, prefix,
-                                               "list[%d].xlator.type", i);
-                        gf_proc_dump_write(key, "%s",
-                                           layout->list[i].xlator->type);
-                        gf_proc_dump_build_key(key, prefix,
-                                               "list[%d].xlator.name", i);
-                        gf_proc_dump_write(key, "%s",
-                                           layout->list[i].xlator->name);
-                }
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+
+    if (!layout)
+        goto out;
+    if (!prefix)
+        goto out;
+
+    gf_proc_dump_build_key(key, prefix, "cnt");
+    gf_proc_dump_write(key, "%d", layout->cnt);
+    gf_proc_dump_build_key(key, prefix, "preset");
+    gf_proc_dump_write(key, "%d", layout->preset);
+    gf_proc_dump_build_key(key, prefix, "gen");
+    gf_proc_dump_write(key, "%d", layout->gen);
+    if (layout->type != IA_INVAL) {
+        gf_proc_dump_build_key(key, prefix, "inode type");
+        gf_proc_dump_write(key, "%d", layout->type);
+    }
+
+    if (!IA_ISDIR(layout->type))
+        goto out;
+
+    for (i = 0; i < layout->cnt; i++) {
+        gf_proc_dump_build_key(key, prefix, "list[%d].err", i);
+        gf_proc_dump_write(key, "%d", layout->list[i].err);
+        gf_proc_dump_build_key(key, prefix, "list[%d].start", i);
+        gf_proc_dump_write(key, "%u", layout->list[i].start);
+        gf_proc_dump_build_key(key, prefix, "list[%d].stop", i);
+        gf_proc_dump_write(key, "%u", layout->list[i].stop);
+        if (layout->list[i].xlator) {
+            gf_proc_dump_build_key(key, prefix, "list[%d].xlator.type", i);
+            gf_proc_dump_write(key, "%s", layout->list[i].xlator->type);
+            gf_proc_dump_build_key(key, prefix, "list[%d].xlator.name", i);
+            gf_proc_dump_write(key, "%s", layout->list[i].xlator->name);
         }
+    }
 
 out:
-        return;
+    return;
 }
 
-
 int32_t
-dht_priv_dump (xlator_t *this)
+dht_priv_dump(xlator_t *this)
 {
-        char            key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char            key[GF_DUMP_MAX_BUF_LEN];
-        int             i = 0;
-        dht_conf_t      *conf = NULL;
-        int             ret = -1;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
 
-        if (!this)
-                goto out;
+    if (!this)
+        goto out;
 
-        conf = this->private;
-        if (!conf)
-                goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        ret = TRY_LOCK(&conf->subvolume_lock);
-        if (ret != 0) {
-                return ret;
+    ret = TRY_LOCK(&conf->subvolume_lock);
+    if (ret != 0) {
+        return ret;
+    }
+
+    gf_proc_dump_add_section("xlator.cluster.dht.%s.priv", this->name);
+    gf_proc_dump_build_key(key_prefix, "xlator.cluster.dht", "%s.priv",
+                           this->name);
+    gf_proc_dump_write("subvol_cnt", "%d", conf->subvolume_cnt);
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        snprintf(key, sizeof(key), "subvolumes[%d]", i);
+        gf_proc_dump_write(key, "%s.%s", conf->subvolumes[i]->type,
+                           conf->subvolumes[i]->name);
+        if (conf->file_layouts && conf->file_layouts[i]) {
+            snprintf(key, sizeof(key), "file_layouts[%d]", i);
+            dht_layout_dump(conf->file_layouts[i], key);
         }
-
-        gf_proc_dump_add_section("xlator.cluster.dht.%s.priv", this->name);
-        gf_proc_dump_build_key(key_prefix,"xlator.cluster.dht","%s.priv",
-                               this->name);
-        gf_proc_dump_write("subvol_cnt","%d", conf->subvolume_cnt);
+        if (conf->dir_layouts && conf->dir_layouts[i]) {
+            snprintf(key, sizeof(key), "dir_layouts[%d]", i);
+            dht_layout_dump(conf->dir_layouts[i], key);
+        }
+        if (conf->subvolume_status) {
+            snprintf(key, sizeof(key), "subvolume_status[%d]", i);
+            gf_proc_dump_write(key, "%d", (int)conf->subvolume_status[i]);
+        }
+    }
+
+    gf_proc_dump_write("search_unhashed", "%d", conf->search_unhashed);
+    gf_proc_dump_write("gen", "%d", conf->gen);
+    gf_proc_dump_write("min_free_disk", "%lf", conf->min_free_disk);
+    gf_proc_dump_write("min_free_inodes", "%lf", conf->min_free_inodes);
+    gf_proc_dump_write("disk_unit", "%c", conf->disk_unit);
+    gf_proc_dump_write("refresh_interval", "%d", conf->refresh_interval);
+    gf_proc_dump_write("unhashed_sticky_bit", "%d", conf->unhashed_sticky_bit);
+    gf_proc_dump_write("use-readdirp", "%d", conf->use_readdirp);
+
+    if (conf->du_stats && conf->subvolume_status) {
         for (i = 0; i < conf->subvolume_cnt; i++) {
-                snprintf (key, sizeof (key), "subvolumes[%d]", i);
-                gf_proc_dump_write(key, "%s.%s", conf->subvolumes[i]->type,
-                                   conf->subvolumes[i]->name);
-                if (conf->file_layouts && conf->file_layouts[i]){
-                        snprintf (key, sizeof (key), "file_layouts[%d]", i);
-                        dht_layout_dump(conf->file_layouts[i], key);
-                }
-                if (conf->dir_layouts && conf->dir_layouts[i]) {
-                        snprintf (key, sizeof (key), "dir_layouts[%d]", i);
-                        dht_layout_dump(conf->dir_layouts[i], key);
-                }
-                if (conf->subvolume_status) {
-
-                        snprintf (key, sizeof (key), "subvolume_status[%d]", i);
-                        gf_proc_dump_write(key, "%d",
-                                           (int)conf->subvolume_status[i]);
-                }
+            if (!conf->subvolume_status[i])
+                continue;
 
-        }
+            snprintf(key, sizeof(key), "subvolumes[%d]", i);
+            gf_proc_dump_write(key, "%s", conf->subvolumes[i]->name);
+
+            snprintf(key, sizeof(key), "du_stats[%d].avail_percent", i);
+            gf_proc_dump_write(key, "%lf", conf->du_stats[i].avail_percent);
+
+            snprintf(key, sizeof(key), "du_stats[%d].avail_space", i);
+            gf_proc_dump_write(key, "%lu", conf->du_stats[i].avail_space);
 
-        gf_proc_dump_write("search_unhashed", "%d", conf->search_unhashed);
-        gf_proc_dump_write("gen", "%d", conf->gen);
-        gf_proc_dump_write("min_free_disk", "%lf", conf->min_free_disk);
-        gf_proc_dump_write("min_free_inodes", "%lf", conf->min_free_inodes);
-        gf_proc_dump_write("disk_unit", "%c", conf->disk_unit);
-        gf_proc_dump_write("refresh_interval", "%d", conf->refresh_interval);
-        gf_proc_dump_write("unhashed_sticky_bit", "%d", conf->unhashed_sticky_bit);
-        gf_proc_dump_write("use-readdirp", "%d", conf->use_readdirp);
-
-        if (conf->du_stats && conf->subvolume_status) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (!conf->subvolume_status[i])
-                                continue;
-
-                        snprintf (key, sizeof (key), "subvolumes[%d]", i);
-                        gf_proc_dump_write (key, "%s",
-                                            conf->subvolumes[i]->name);
-
-                        snprintf (key, sizeof (key),
-                                  "du_stats[%d].avail_percent", i);
-                        gf_proc_dump_write (key, "%lf",
-                                            conf->du_stats[i].avail_percent);
-
-                        snprintf (key, sizeof (key), "du_stats[%d].avail_space",
-                                  i);
-                        gf_proc_dump_write (key, "%lu",
-                                            conf->du_stats[i].avail_space);
-
-                        snprintf (key, sizeof (key),
-                                  "du_stats[%d].avail_inodes", i);
-                        gf_proc_dump_write (key, "%lf",
-                                            conf->du_stats[i].avail_inodes);
-
-                        snprintf (key, sizeof (key), "du_stats[%d].log", i);
-                        gf_proc_dump_write (key, "%lu",
-                                            conf->du_stats[i].log);
-                }
+            snprintf(key, sizeof(key), "du_stats[%d].avail_inodes", i);
+            gf_proc_dump_write(key, "%lf", conf->du_stats[i].avail_inodes);
+
+            snprintf(key, sizeof(key), "du_stats[%d].log", i);
+            gf_proc_dump_write(key, "%lu", conf->du_stats[i].log);
         }
+    }
 
-        if (conf->last_stat_fetch.tv_sec)
-                gf_proc_dump_write("last_stat_fetch", "%s",
-                                    ctime(&conf->last_stat_fetch.tv_sec));
+    if (conf->last_stat_fetch.tv_sec)
+        gf_proc_dump_write("last_stat_fetch", "%s",
+                           ctime(&conf->last_stat_fetch.tv_sec));
 
-        UNLOCK(&conf->subvolume_lock);
+    UNLOCK(&conf->subvolume_lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-dht_inodectx_dump (xlator_t *this, inode_t *inode)
+dht_inodectx_dump(xlator_t *this, inode_t *inode)
 {
-        int             ret = -1;
-        dht_layout_t    *layout = NULL;
+    int ret = -1;
+    dht_layout_t *layout = NULL;
 
-        if (!this)
-                goto out;
-        if (!inode)
-                goto out;
+    if (!this)
+        goto out;
+    if (!inode)
+        goto out;
 
-        ret = dht_inode_ctx_layout_get (inode, this, &layout);
+    ret = dht_inode_ctx_layout_get(inode, this, &layout);
 
-        if ((ret != 0) || !layout)
-                return ret;
+    if ((ret != 0) || !layout)
+        return ret;
 
-        gf_proc_dump_add_section("xlator.cluster.dht.%s.inode", this->name);
-        dht_layout_dump(layout, "layout");
+    gf_proc_dump_add_section("xlator.cluster.dht.%s.inode", this->name);
+    dht_layout_dump(layout, "layout");
 
 out:
-        return ret;
+    return ret;
 }
 
 void
-dht_fini (xlator_t *this)
+dht_fini(xlator_t *this)
 {
-        int         i = 0;
-        dht_conf_t *conf = NULL;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-
-        conf = this->private;
-        this->private = NULL;
-        if (conf) {
-                if (conf->file_layouts) {
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                GF_FREE (conf->file_layouts[i]);
-                        }
-                        GF_FREE (conf->file_layouts);
-                }
-
-                dict_unref(conf->leaf_to_subvol);
-
-                /* allocated in dht_init_subvolumes() */
-                GF_FREE (conf->subvolumes);
-                GF_FREE (conf->subvolume_status);
-                GF_FREE (conf->last_event);
-                GF_FREE (conf->subvol_up_time);
-                GF_FREE (conf->du_stats);
-                GF_FREE (conf->decommissioned_bricks);
-
-                /* allocated in dht_init() */
-                GF_FREE (conf->mds_xattr_key);
-                GF_FREE (conf->link_xattr_name);
-                GF_FREE (conf->commithash_xattr_name);
-                GF_FREE (conf->wild_xattr_name);
-
-                /* allocated in dht_init_regex() */
-                if (conf->rsync_regex_valid)
-                        regfree (&conf->rsync_regex);
-                if (conf->extra_regex_valid)
-                        regfree (&conf->extra_regex);
-
-                synclock_destroy (&conf->link_lock);
-
-                if (conf->lock_pool)
-                        mem_pool_destroy (conf->lock_pool);
-
-                GF_FREE (conf);
+    int i = 0;
+    dht_conf_t *conf = NULL;
+
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+
+    conf = this->private;
+    this->private = NULL;
+    if (conf) {
+        if (conf->file_layouts) {
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                GF_FREE(conf->file_layouts[i]);
+            }
+            GF_FREE(conf->file_layouts);
         }
+
+        dict_unref(conf->leaf_to_subvol);
+
+        /* allocated in dht_init_subvolumes() */
+        GF_FREE(conf->subvolumes);
+        GF_FREE(conf->subvolume_status);
+        GF_FREE(conf->last_event);
+        GF_FREE(conf->subvol_up_time);
+        GF_FREE(conf->du_stats);
+        GF_FREE(conf->decommissioned_bricks);
+
+        /* allocated in dht_init() */
+        GF_FREE(conf->mds_xattr_key);
+        GF_FREE(conf->link_xattr_name);
+        GF_FREE(conf->commithash_xattr_name);
+        GF_FREE(conf->wild_xattr_name);
+
+        /* allocated in dht_init_regex() */
+        if (conf->rsync_regex_valid)
+            regfree(&conf->rsync_regex);
+        if (conf->extra_regex_valid)
+            regfree(&conf->extra_regex);
+
+        synclock_destroy(&conf->link_lock);
+
+        if (conf->lock_pool)
+            mem_pool_destroy(conf->lock_pool);
+
+        GF_FREE(conf);
+    }
 out:
-        return;
+    return;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
 
-        ret = xlator_mem_acct_init (this, gf_dht_mt_end + 1);
+    ret = xlator_mem_acct_init(this, gf_dht_mt_end + 1);
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_NO_MEMORY,
-                        "Memory accounting init failed");
-                return ret;
-        }
-out:
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_NO_MEMORY,
+               "Memory accounting init failed");
         return ret;
+    }
+out:
+    return ret;
 }
 
-
 int
-dht_parse_decommissioned_bricks (xlator_t *this, dht_conf_t *conf,
-                                 const char *bricks)
+dht_parse_decommissioned_bricks(xlator_t *this, dht_conf_t *conf,
+                                const char *bricks)
 {
-        int         i  = 0;
-        int         ret  = -1;
-        char       *tmpstr = NULL;
-        char       *dup_brick = NULL;
-        char       *node = NULL;
-
-        if (!conf || !bricks)
-                goto out;
-
-        dup_brick = gf_strdup (bricks);
-        node = strtok_r (dup_brick, ",", &tmpstr);
-        while (node) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (!strcmp (conf->subvolumes[i]->name, node)) {
-                                conf->decommissioned_bricks[i] =
-                                        conf->subvolumes[i];
-                                        conf->decommission_subvols_cnt++;
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_SUBVOL_DECOMMISSION_INFO,
-                                        "decommissioning subvolume %s",
-                                        conf->subvolumes[i]->name);
-                                break;
-                        }
-                }
-                if (i == conf->subvolume_cnt) {
-                        /* Wrong node given. */
-                        goto out;
-                }
-                node = strtok_r (NULL, ",", &tmpstr);
+    int i = 0;
+    int ret = -1;
+    char *tmpstr = NULL;
+    char *dup_brick = NULL;
+    char *node = NULL;
+
+    if (!conf || !bricks)
+        goto out;
+
+    dup_brick = gf_strdup(bricks);
+    node = strtok_r(dup_brick, ",", &tmpstr);
+    while (node) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (!strcmp(conf->subvolumes[i]->name, node)) {
+                conf->decommissioned_bricks[i] = conf->subvolumes[i];
+                conf->decommission_subvols_cnt++;
+                gf_msg(this->name, GF_LOG_INFO, 0,
+                       DHT_MSG_SUBVOL_DECOMMISSION_INFO,
+                       "decommissioning subvolume %s",
+                       conf->subvolumes[i]->name);
+                break;
+            }
         }
+        if (i == conf->subvolume_cnt) {
+            /* Wrong node given. */
+            goto out;
+        }
+        node = strtok_r(NULL, ",", &tmpstr);
+    }
 
-        ret = 0;
-        conf->decommission_in_progress = 1;
+    ret = 0;
+    conf->decommission_in_progress = 1;
 out:
-        GF_FREE (dup_brick);
+    GF_FREE(dup_brick);
 
-        return ret;
+    return ret;
 }
 
 int
-dht_decommissioned_remove (xlator_t *this, dht_conf_t *conf)
+dht_decommissioned_remove(xlator_t *this, dht_conf_t *conf)
 {
-        int         i  = 0;
-        int         ret  = -1;
+    int i = 0;
+    int ret = -1;
 
-        if (!conf)
-                goto out;
+    if (!conf)
+        goto out;
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (conf->decommissioned_bricks[i]) {
-                        conf->decommissioned_bricks[i] = NULL;
-                        conf->decommission_subvols_cnt--;
-                }
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (conf->decommissioned_bricks[i]) {
+            conf->decommissioned_bricks[i] = NULL;
+            conf->decommission_subvols_cnt--;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
 
-        return ret;
+    return ret;
 }
 void
-dht_init_regex (xlator_t *this, dict_t *odict, char *name,
-                regex_t *re, gf_boolean_t *re_valid, dht_conf_t *conf)
+dht_init_regex(xlator_t *this, dict_t *odict, char *name, regex_t *re,
+               gf_boolean_t *re_valid, dht_conf_t *conf)
 {
-        char       *temp_str = NULL;
+    char *temp_str = NULL;
 
-        if (dict_get_str (odict, name, &temp_str) != 0) {
-                if (strcmp(name,"rsync-hash-regex")) {
-                        return;
-                }
-                temp_str = "^\\.(.+)\\.[^.]+$";
+    if (dict_get_str(odict, name, &temp_str) != 0) {
+        if (strcmp(name, "rsync-hash-regex")) {
+            return;
+        }
+        temp_str = "^\\.(.+)\\.[^.]+$";
+    }
+
+    LOCK(&conf->lock);
+    {
+        if (*re_valid) {
+            regfree(re);
+            *re_valid = _gf_false;
+        }
+
+        if (!strcmp(temp_str, "none")) {
+            goto unlock;
         }
 
-        LOCK (&conf->lock);
-        {
-                if (*re_valid) {
-                        regfree(re);
-                        *re_valid = _gf_false;
-                }
-
-                if (!strcmp(temp_str, "none")) {
-                        goto unlock;
-                }
-
-                if (regcomp(re, temp_str, REG_EXTENDED) == 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "using regex %s = %s", name, temp_str);
-                        *re_valid = _gf_true;
-                } else {
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_REGEX_INFO,
-                                "compiling regex %s failed", temp_str);
-                }
+        if (regcomp(re, temp_str, REG_EXTENDED) == 0) {
+            gf_msg_debug(this->name, 0, "using regex %s = %s", name, temp_str);
+            *re_valid = _gf_true;
+        } else {
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_REGEX_INFO,
+                   "compiling regex %s failed", temp_str);
         }
+    }
 unlock:
-        UNLOCK (&conf->lock);
+    UNLOCK(&conf->lock);
 }
 
 int
 dht_set_subvol_range(xlator_t *this)
 {
-        int ret = -1;
-        dht_conf_t *conf = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!conf)
-                goto out;
+    if (!conf)
+        goto out;
 
-        conf->leaf_to_subvol = dict_new();
-        if (!conf->leaf_to_subvol)
-                goto out;
+    conf->leaf_to_subvol = dict_new();
+    if (!conf->leaf_to_subvol)
+        goto out;
 
-        ret = glusterfs_reachable_leaves(this, conf->leaf_to_subvol);
+    ret = glusterfs_reachable_leaves(this, conf->leaf_to_subvol);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_configure_throttle (xlator_t *this, dht_conf_t *conf, char *temp_str)
+dht_configure_throttle(xlator_t *this, dht_conf_t *conf, char *temp_str)
 {
-        int     rebal_thread_count      = 0;
-        int     ret                     = 0;
-
-        pthread_mutex_lock (&conf->defrag->dfq_mutex);
-        {
-        if (!strcasecmp (temp_str, "lazy")) {
-                conf->defrag->recon_thread_count = 1;
-        } else if (!strcasecmp (temp_str, "normal")) {
-                conf->defrag->recon_thread_count = 2;
-        } else if (!strcasecmp (temp_str, "aggressive")) {
-                conf->defrag->recon_thread_count = MAX (MAX_REBAL_THREADS - 4, 4);
-        } else if ((gf_string2int (temp_str, &rebal_thread_count) == 0)) {
-                if ((rebal_thread_count > 0) && (rebal_thread_count <= MAX_REBAL_THREADS)) {
-                        gf_msg (this->name, GF_LOG_INFO, 0, 0,
-                                "rebal thread count configured to %d",
-                                rebal_thread_count);
-                                conf->defrag->recon_thread_count = rebal_thread_count;
-                } else {
-                        gf_msg(this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION,
-                                "Invalid option: Reconfigure: "
-                                "rebal-throttle should be "
-                                "within range of 0 and maximum number of"
-                                " cores available");
-                                ret = -1;
-                                pthread_mutex_unlock (&conf->defrag->dfq_mutex);
-                                goto out;
-                }
+    int rebal_thread_count = 0;
+    int ret = 0;
+
+    pthread_mutex_lock(&conf->defrag->dfq_mutex);
+    {
+        if (!strcasecmp(temp_str, "lazy")) {
+            conf->defrag->recon_thread_count = 1;
+        } else if (!strcasecmp(temp_str, "normal")) {
+            conf->defrag->recon_thread_count = 2;
+        } else if (!strcasecmp(temp_str, "aggressive")) {
+            conf->defrag->recon_thread_count = MAX(MAX_REBAL_THREADS - 4, 4);
+        } else if ((gf_string2int(temp_str, &rebal_thread_count) == 0)) {
+            if ((rebal_thread_count > 0) &&
+                (rebal_thread_count <= MAX_REBAL_THREADS)) {
+                gf_msg(this->name, GF_LOG_INFO, 0, 0,
+                       "rebal thread count configured to %d",
+                       rebal_thread_count);
+                conf->defrag->recon_thread_count = rebal_thread_count;
+            } else {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option: Reconfigure: "
+                       "rebal-throttle should be "
+                       "within range of 0 and maximum number of"
+                       " cores available");
+                ret = -1;
+                pthread_mutex_unlock(&conf->defrag->dfq_mutex);
+                goto out;
+            }
         } else {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_INVALID_OPTION,
-                        "Invalid option: Reconfigure: "
-                        "rebal-throttle should be {lazy|normal|aggressive}"
-                        " or a number up to the number of cores available,"
-                        " not (%s), defaulting to (%d)",
-                        temp_str, conf->dthrottle);
-                        ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option: Reconfigure: "
+                   "rebal-throttle should be {lazy|normal|aggressive}"
+                   " or a number up to the number of cores available,"
+                   " not (%s), defaulting to (%d)",
+                   temp_str, conf->dthrottle);
+            ret = -1;
         }
-        }
-        pthread_mutex_unlock (&conf->defrag->dfq_mutex);
+    }
+    pthread_mutex_unlock(&conf->defrag->dfq_mutex);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-dht_reconfigure (xlator_t *this, dict_t *options)
+dht_reconfigure(xlator_t *this, dict_t *options)
 {
-        dht_conf_t      *conf = NULL;
-        char            *temp_str = NULL;
-        gf_boolean_t     search_unhashed;
-        int              ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, out);
-        GF_VALIDATE_OR_GOTO ("dht", options, out);
-
-        conf = this->private;
-        if (!conf)
-                return 0;
-
-        if (dict_get_str (options, "lookup-unhashed", &temp_str) == 0) {
-                /* If option is not "auto", other options _should_ be boolean*/
-                if (strcasecmp (temp_str, "auto")) {
-                        if (!gf_string2boolean (temp_str, &search_unhashed)) {
-                                gf_msg_debug(this->name, 0, "Reconfigure: "
-                                             "lookup-unhashed reconfigured(%s)",
-                                             temp_str);
-                                conf->search_unhashed = search_unhashed;
-                        } else {
-                                gf_msg(this->name, GF_LOG_ERROR, 0,
-                                       DHT_MSG_INVALID_OPTION,
-                                       "Invalid option: Reconfigure: "
-                                       "lookup-unhashed should be boolean,"
-                                       " not (%s), defaulting to (%d)",
-                                       temp_str, conf->search_unhashed);
-                                ret = -1;
-                                goto out;
-                        }
-                } else {
-                        gf_msg_debug(this->name, 0, "Reconfigure:"
-                                     " lookup-unhashed reconfigured auto ");
-                        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
-                }
-        }
+    dht_conf_t *conf = NULL;
+    char *temp_str = NULL;
+    gf_boolean_t search_unhashed;
+    int ret = -1;
 
-        GF_OPTION_RECONF ("lookup-optimize", conf->lookup_optimize, options,
-                          bool, out);
+    GF_VALIDATE_OR_GOTO("dht", this, out);
+    GF_VALIDATE_OR_GOTO("dht", options, out);
 
-        GF_OPTION_RECONF ("min-free-disk", conf->min_free_disk, options,
-                          percent_or_size, out);
-        /* option can be any one of percent or bytes */
-        conf->disk_unit = 0;
-        if (conf->min_free_disk < 100.0)
-                conf->disk_unit = 'p';
+    conf = this->private;
+    if (!conf)
+        return 0;
 
-        GF_OPTION_RECONF ("min-free-inodes", conf->min_free_inodes, options,
-                          percent, out);
+    if (dict_get_str(options, "lookup-unhashed", &temp_str) == 0) {
+        /* If option is not "auto", other options _should_ be boolean*/
+        if (strcasecmp(temp_str, "auto")) {
+            if (!gf_string2boolean(temp_str, &search_unhashed)) {
+                gf_msg_debug(this->name, 0,
+                             "Reconfigure: "
+                             "lookup-unhashed reconfigured(%s)",
+                             temp_str);
+                conf->search_unhashed = search_unhashed;
+            } else {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option: Reconfigure: "
+                       "lookup-unhashed should be boolean,"
+                       " not (%s), defaulting to (%d)",
+                       temp_str, conf->search_unhashed);
+                ret = -1;
+                goto out;
+            }
+        } else {
+            gf_msg_debug(this->name, 0,
+                         "Reconfigure:"
+                         " lookup-unhashed reconfigured auto ");
+            conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
+        }
+    }
 
-        GF_OPTION_RECONF ("directory-layout-spread", conf->dir_spread_cnt,
-                          options, uint32, out);
+    GF_OPTION_RECONF("lookup-optimize", conf->lookup_optimize, options, bool,
+                     out);
 
-        GF_OPTION_RECONF ("readdir-optimize", conf->readdir_optimize, options,
-                          bool, out);
-        GF_OPTION_RECONF ("randomize-hash-range-by-gfid",
-                          conf->randomize_by_gfid,
-                          options, bool, out);
+    GF_OPTION_RECONF("min-free-disk", conf->min_free_disk, options,
+                     percent_or_size, out);
+    /* option can be any one of percent or bytes */
+    conf->disk_unit = 0;
+    if (conf->min_free_disk < 100.0)
+        conf->disk_unit = 'p';
 
-        GF_OPTION_RECONF ("lock-migration", conf->lock_migration_enabled,
-                          options, bool, out);
+    GF_OPTION_RECONF("min-free-inodes", conf->min_free_inodes, options, percent,
+                     out);
 
-        GF_OPTION_RECONF ("force-migration", conf->force_migration,
-                          options, bool, out);
+    GF_OPTION_RECONF("directory-layout-spread", conf->dir_spread_cnt, options,
+                     uint32, out);
 
+    GF_OPTION_RECONF("readdir-optimize", conf->readdir_optimize, options, bool,
+                     out);
+    GF_OPTION_RECONF("randomize-hash-range-by-gfid", conf->randomize_by_gfid,
+                     options, bool, out);
 
-        if (conf->defrag) {
-                if (dict_get_str (options, "rebal-throttle", &temp_str) == 0) {
-                        ret = dht_configure_throttle (this, conf, temp_str);
-                        if (ret == -1)
-                                goto out;
-                }
-        }
+    GF_OPTION_RECONF("lock-migration", conf->lock_migration_enabled, options,
+                     bool, out);
 
-        if (conf->defrag) {
-                conf->defrag->lock_migration_enabled =
-                                        conf->lock_migration_enabled;
-        }
+    GF_OPTION_RECONF("force-migration", conf->force_migration, options, bool,
+                     out);
 
-        if (conf->defrag) {
-                GF_OPTION_RECONF ("rebalance-stats", conf->defrag->stats,
-                                  options, bool, out);
+    if (conf->defrag) {
+        if (dict_get_str(options, "rebal-throttle", &temp_str) == 0) {
+            ret = dht_configure_throttle(this, conf, temp_str);
+            if (ret == -1)
+                goto out;
         }
+    }
+
+    if (conf->defrag) {
+        conf->defrag->lock_migration_enabled = conf->lock_migration_enabled;
+    }
+
+    if (conf->defrag) {
+        GF_OPTION_RECONF("rebalance-stats", conf->defrag->stats, options, bool,
+                         out);
+    }
+
+    if (dict_get_str(options, "decommissioned-bricks", &temp_str) == 0) {
+        ret = dht_parse_decommissioned_bricks(this, conf, temp_str);
+        if (ret == -1)
+            goto out;
+    } else {
+        ret = dht_decommissioned_remove(this, conf);
+        if (ret == -1)
+            goto out;
+    }
+
+    dht_init_regex(this, options, "rsync-hash-regex", &conf->rsync_regex,
+                   &conf->rsync_regex_valid, conf);
+    dht_init_regex(this, options, "extra-hash-regex", &conf->extra_regex,
+                   &conf->extra_regex_valid, conf);
+
+    GF_OPTION_RECONF("weighted-rebalance", conf->do_weighting, options, bool,
+                     out);
+
+    GF_OPTION_RECONF("use-readdirp", conf->use_readdirp, options, bool, out);
+    ret = 0;
+out:
+    return ret;
+}
 
-        if (dict_get_str (options, "decommissioned-bricks", &temp_str) == 0) {
-                ret = dht_parse_decommissioned_bricks (this, conf, temp_str);
-                if (ret == -1)
-                        goto out;
-        } else {
-                ret = dht_decommissioned_remove (this, conf);
-                if (ret == -1)
-                        goto out;
+static int
+gf_defrag_pattern_list_fill(xlator_t *this, gf_defrag_info_t *defrag,
+                            char *data)
+{
+    int ret = -1;
+    char *tmp_str = NULL;
+    char *tmp_str1 = NULL;
+    char *dup_str = NULL;
+    char *num = NULL;
+    char *pattern_str = NULL;
+    char *pattern = NULL;
+    gf_defrag_pattern_list_t *temp_list = NULL;
+    gf_defrag_pattern_list_t *pattern_list = NULL;
+
+    if (!this || !defrag || !data)
+        goto out;
+
+    /* Get the pattern for pattern list. "pattern:<optional-size>"
+     * eg: *avi, *pdf:10MB, *:1TB
+     */
+    pattern_str = strtok_r(data, ",", &tmp_str);
+    while (pattern_str) {
+        dup_str = gf_strdup(pattern_str);
+        pattern_list = GF_CALLOC(1, sizeof(gf_defrag_pattern_list_t), 1);
+        if (!pattern_list) {
+            goto out;
         }
+        pattern = strtok_r(dup_str, ":", &tmp_str1);
+        num = strtok_r(NULL, ":", &tmp_str1);
+        if (!pattern)
+            goto out;
+        if (!num) {
+            if (gf_string2bytesize_uint64(pattern, &pattern_list->size) == 0) {
+                pattern = "*";
+            }
+        } else if (gf_string2bytesize_uint64(num, &pattern_list->size) != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option. Defrag pattern:"
+                   " Invalid number format \"%s\"",
+                   num);
+            goto out;
+        }
+        memcpy(pattern_list->path_pattern, pattern, strlen(dup_str));
 
-        dht_init_regex (this, options, "rsync-hash-regex",
-                        &conf->rsync_regex, &conf->rsync_regex_valid, conf);
-        dht_init_regex (this, options, "extra-hash-regex",
-                        &conf->extra_regex, &conf->extra_regex_valid, conf);
+        if (!defrag->defrag_pattern)
+            temp_list = NULL;
+        else
+            temp_list = defrag->defrag_pattern;
 
-        GF_OPTION_RECONF ("weighted-rebalance", conf->do_weighting, options,
-                          bool, out);
+        pattern_list->next = temp_list;
 
-        GF_OPTION_RECONF ("use-readdirp", conf->use_readdirp, options,
-                          bool, out);
-        ret = 0;
-out:
-        return ret;
-}
+        defrag->defrag_pattern = pattern_list;
+        pattern_list = NULL;
 
-static int
-gf_defrag_pattern_list_fill (xlator_t *this, gf_defrag_info_t *defrag, char *data)
-{
-        int                    ret = -1;
-        char                  *tmp_str = NULL;
-        char                  *tmp_str1 = NULL;
-        char                  *dup_str = NULL;
-        char                  *num = NULL;
-        char                  *pattern_str = NULL;
-        char                  *pattern = NULL;
-        gf_defrag_pattern_list_t *temp_list = NULL;
-        gf_defrag_pattern_list_t *pattern_list = NULL;
-
-        if (!this || !defrag || !data)
-                goto out;
+        GF_FREE(dup_str);
+        dup_str = NULL;
 
-        /* Get the pattern for pattern list. "pattern:<optional-size>"
-         * eg: *avi, *pdf:10MB, *:1TB
-         */
-        pattern_str = strtok_r (data, ",", &tmp_str);
-        while (pattern_str) {
-                dup_str = gf_strdup (pattern_str);
-                pattern_list = GF_CALLOC (1, sizeof (gf_defrag_pattern_list_t),
-                                        1);
-                if (!pattern_list) {
-                        goto out;
-                }
-                pattern = strtok_r (dup_str, ":", &tmp_str1);
-                num = strtok_r (NULL, ":", &tmp_str1);
-                if (!pattern)
-                        goto out;
-                if (!num) {
-                        if (gf_string2bytesize_uint64(pattern, &pattern_list->size)
-                             == 0) {
-                                pattern = "*";
-                        }
-                } else if (gf_string2bytesize_uint64 (num, &pattern_list->size) != 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION,
-                                "Invalid option. Defrag pattern:"
-                                " Invalid number format \"%s\"", num);
-                        goto out;
-                }
-                memcpy (pattern_list->path_pattern, pattern, strlen (dup_str));
-
-                if (!defrag->defrag_pattern)
-                        temp_list = NULL;
-                else
-                        temp_list = defrag->defrag_pattern;
-
-                pattern_list->next = temp_list;
-
-                defrag->defrag_pattern = pattern_list;
-                pattern_list = NULL;
-
-                GF_FREE (dup_str);
-                dup_str = NULL;
-
-                pattern_str = strtok_r (NULL, ",", &tmp_str);
-        }
+        pattern_str = strtok_r(NULL, ",", &tmp_str);
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret)
-                GF_FREE (pattern_list);
-        GF_FREE (dup_str);
+    if (ret)
+        GF_FREE(pattern_list);
+    GF_FREE(dup_str);
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-dht_init_methods (xlator_t *this)
+dht_init_methods(xlator_t *this)
 {
-        int ret                  = -1;
-        dht_conf_t      *conf    = NULL;
-        dht_methods_t   *methods = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
+    GF_VALIDATE_OR_GOTO("dht", this, err);
 
-        conf = this->private;
-        methods = &(conf->methods);
+    conf = this->private;
+    methods = &(conf->methods);
 
-        methods->migration_get_dst_subvol = dht_migration_get_dst_subvol;
-        methods->migration_needed = dht_migration_needed;
-        methods->migration_other  = NULL;
-        methods->layout_search    = dht_layout_search;
+    methods->migration_get_dst_subvol = dht_migration_get_dst_subvol;
+    methods->migration_needed = dht_migration_needed;
+    methods->migration_other = NULL;
+    methods->layout_search = dht_layout_search;
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-dht_init (xlator_t *this)
+dht_init(xlator_t *this)
 {
-        dht_conf_t                      *conf           = NULL;
-        char                            *temp_str       = NULL;
-        int                              ret            = -1;
-        int                              i              = 0;
-        gf_defrag_info_t                *defrag         = NULL;
-        int                              cmd            = 0;
-        char                            *node_uuid      = NULL;
-        uint32_t                         commit_hash    = 0;
-
-        GF_VALIDATE_OR_GOTO ("dht", this, err);
-
-        if (!this->children) {
-                gf_msg (this->name, GF_LOG_CRITICAL, 0,
-                        DHT_MSG_INVALID_CONFIGURATION,
-                        "Distribute needs more than one subvolume");
-                return -1;
-        }
-
-        if (!this->parents) {
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_INVALID_CONFIGURATION,
-                        "dangling volume. check volfile");
-        }
-
-        conf = GF_CALLOC (1, sizeof (*conf), gf_dht_mt_dht_conf_t);
-        if (!conf) {
-                goto err;
-        }
-
-        LOCK_INIT (&conf->subvolume_lock);
-        LOCK_INIT (&conf->layout_lock);
-        LOCK_INIT (&conf->lock);
-        synclock_init (&conf->link_lock, SYNC_LOCK_DEFAULT);
-
-        /* We get the commit-hash to set only for rebalance process */
-        if (dict_get_uint32 (this->options,
-                             "commit-hash", &commit_hash) == 0) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_COMMIT_HASH_INFO, "%s using commit hash %u",
-                        __func__, commit_hash);
-                conf->vol_commit_hash = commit_hash;
-                conf->vch_forced = _gf_true;
-        }
-
-        ret = dict_get_int32 (this->options, "rebalance-cmd", &cmd);
-
-        if (cmd) {
-                defrag = GF_CALLOC (1, sizeof (gf_defrag_info_t),
-                                    gf_defrag_info_mt);
-
-                GF_VALIDATE_OR_GOTO (this->name, defrag, err);
-
-                LOCK_INIT (&defrag->lock);
-
-                defrag->is_exiting = 0;
-
-                conf->defrag = defrag;
-                defrag->this = this;
-
-                ret = dict_get_str (this->options, "node-uuid", &node_uuid);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_CONFIGURATION,
-                                "Invalid volume configuration: "
-                                "node-uuid not specified");
-                        goto err;
-                }
+    dht_conf_t *conf = NULL;
+    char *temp_str = NULL;
+    int ret = -1;
+    int i = 0;
+    gf_defrag_info_t *defrag = NULL;
+    int cmd = 0;
+    char *node_uuid = NULL;
+    uint32_t commit_hash = 0;
+
+    GF_VALIDATE_OR_GOTO("dht", this, err);
+
+    if (!this->children) {
+        gf_msg(this->name, GF_LOG_CRITICAL, 0, DHT_MSG_INVALID_CONFIGURATION,
+               "Distribute needs more than one subvolume");
+        return -1;
+    }
 
-                if (gf_uuid_parse (node_uuid, defrag->node_uuid)) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INVALID_OPTION, "Invalid option:"
-                                " Cannot parse glusterd node uuid");
-                        goto err;
-                }
+    if (!this->parents) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_INVALID_CONFIGURATION,
+               "dangling volume. check volfile");
+    }
 
-                defrag->cmd = cmd;
+    conf = GF_CALLOC(1, sizeof(*conf), gf_dht_mt_dht_conf_t);
+    if (!conf) {
+        goto err;
+    }
 
-                defrag->stats = _gf_false;
+    LOCK_INIT(&conf->subvolume_lock);
+    LOCK_INIT(&conf->layout_lock);
+    LOCK_INIT(&conf->lock);
+    synclock_init(&conf->link_lock, SYNC_LOCK_DEFAULT);
 
-                defrag->queue = NULL;
+    /* We get the commit-hash to set only for rebalance process */
+    if (dict_get_uint32(this->options, "commit-hash", &commit_hash) == 0) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_COMMIT_HASH_INFO,
+               "%s using commit hash %u", __func__, commit_hash);
+        conf->vol_commit_hash = commit_hash;
+        conf->vch_forced = _gf_true;
+    }
 
-                defrag->crawl_done = 0;
+    ret = dict_get_int32(this->options, "rebalance-cmd", &cmd);
 
-                defrag->global_error = 0;
+    if (cmd) {
+        defrag = GF_CALLOC(1, sizeof(gf_defrag_info_t), gf_defrag_info_mt);
 
-                defrag->q_entry_count = 0;
+        GF_VALIDATE_OR_GOTO(this->name, defrag, err);
 
-                defrag->wakeup_crawler = 0;
+        LOCK_INIT(&defrag->lock);
 
-                pthread_mutex_init (&defrag->dfq_mutex, 0);
-                pthread_cond_init  (&defrag->parallel_migration_cond, 0);
-                pthread_cond_init  (&defrag->rebalance_crawler_alarm, 0);
-                pthread_cond_init  (&defrag->df_wakeup_thread, 0);
+        defrag->is_exiting = 0;
 
-                pthread_mutex_init (&defrag->fc_mutex, 0);
-                pthread_cond_init  (&defrag->fc_wakeup_cond, 0);
+        conf->defrag = defrag;
+        defrag->this = this;
 
-                defrag->global_error = 0;
+        ret = dict_get_str(this->options, "node-uuid", &node_uuid);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_CONFIGURATION,
+                   "Invalid volume configuration: "
+                   "node-uuid not specified");
+            goto err;
         }
 
-        conf->use_fallocate = 1;
-
-        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_ON;
-        if (dict_get_str (this->options, "lookup-unhashed", &temp_str) == 0) {
-                /* If option is not "auto", other options _should_ be boolean */
-                if (strcasecmp (temp_str, "auto")) {
-                        gf_boolean_t    search_unhashed_bool;
-                        ret = gf_string2boolean (temp_str, &search_unhashed_bool);
-                        if (ret == -1) {
-                                goto err;
-                        }
-                        conf->search_unhashed = search_unhashed_bool
-                                              ? GF_DHT_LOOKUP_UNHASHED_ON
-                                              : GF_DHT_LOOKUP_UNHASHED_OFF;
-                }
-                else {
-                        conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
-                }
+        if (gf_uuid_parse(node_uuid, defrag->node_uuid)) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                   "Invalid option:"
+                   " Cannot parse glusterd node uuid");
+            goto err;
         }
 
-        GF_OPTION_INIT ("lookup-optimize", conf->lookup_optimize, bool, err);
+        defrag->cmd = cmd;
 
-        GF_OPTION_INIT ("unhashed-sticky-bit", conf->unhashed_sticky_bit, bool,
-                        err);
+        defrag->stats = _gf_false;
 
-        GF_OPTION_INIT ("use-readdirp", conf->use_readdirp, bool, err);
+        defrag->queue = NULL;
 
-        GF_OPTION_INIT ("min-free-disk", conf->min_free_disk, percent_or_size,
-                        err);
+        defrag->crawl_done = 0;
 
-        GF_OPTION_INIT ("min-free-inodes", conf->min_free_inodes, percent,
-                        err);
+        defrag->global_error = 0;
 
-        conf->dir_spread_cnt = conf->subvolume_cnt;
-        GF_OPTION_INIT ("directory-layout-spread", conf->dir_spread_cnt,
-                        uint32, err);
+        defrag->q_entry_count = 0;
 
-        GF_OPTION_INIT ("assert-no-child-down", conf->assert_no_child_down,
-                        bool, err);
+        defrag->wakeup_crawler = 0;
 
-        GF_OPTION_INIT ("readdir-optimize", conf->readdir_optimize, bool, err);
+        pthread_mutex_init(&defrag->dfq_mutex, 0);
+        pthread_cond_init(&defrag->parallel_migration_cond, 0);
+        pthread_cond_init(&defrag->rebalance_crawler_alarm, 0);
+        pthread_cond_init(&defrag->df_wakeup_thread, 0);
 
+        pthread_mutex_init(&defrag->fc_mutex, 0);
+        pthread_cond_init(&defrag->fc_wakeup_cond, 0);
 
-        GF_OPTION_INIT ("lock-migration", conf->lock_migration_enabled,
-                         bool, err);
+        defrag->global_error = 0;
+    }
 
-        GF_OPTION_INIT ("force-migration", conf->force_migration,
-                        bool, err);
+    conf->use_fallocate = 1;
 
+    conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_ON;
+    if (dict_get_str(this->options, "lookup-unhashed", &temp_str) == 0) {
+        /* If option is not "auto", other options _should_ be boolean */
+        if (strcasecmp(temp_str, "auto")) {
+            gf_boolean_t search_unhashed_bool;
+            ret = gf_string2boolean(temp_str, &search_unhashed_bool);
+            if (ret == -1) {
+                goto err;
+            }
+            conf->search_unhashed = search_unhashed_bool
+                                        ? GF_DHT_LOOKUP_UNHASHED_ON
+                                        : GF_DHT_LOOKUP_UNHASHED_OFF;
+        } else {
+            conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO;
+        }
+    }
 
-        if (defrag) {
-              defrag->lock_migration_enabled = conf->lock_migration_enabled;
+    GF_OPTION_INIT("lookup-optimize", conf->lookup_optimize, bool, err);
 
-              GF_OPTION_INIT ("rebalance-stats", defrag->stats, bool, err);
-                if (dict_get_str (this->options, "rebalance-filter", &temp_str)
-                    == 0) {
-                        if (gf_defrag_pattern_list_fill (this, defrag, temp_str)
-                            == -1) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_INVALID_OPTION,
-                                        "Invalid option:"
-                                        " Cannot parse rebalance-filter (%s)",
-                                        temp_str);
+    GF_OPTION_INIT("unhashed-sticky-bit", conf->unhashed_sticky_bit, bool, err);
 
-                                goto err;
-                        }
-                }
-        }
+    GF_OPTION_INIT("use-readdirp", conf->use_readdirp, bool, err);
 
-        /* option can be any one of percent or bytes */
-        conf->disk_unit = 0;
-        if (conf->min_free_disk < 100)
-                conf->disk_unit = 'p';
+    GF_OPTION_INIT("min-free-disk", conf->min_free_disk, percent_or_size, err);
 
-        ret = dht_init_subvolumes (this, conf);
-        if (ret == -1) {
-                goto err;
-        }
+    GF_OPTION_INIT("min-free-inodes", conf->min_free_inodes, percent, err);
 
-        if (cmd) {
-                ret = dht_init_local_subvolumes (this, conf);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_INIT_LOCAL_SUBVOL_FAILED,
-                                "dht_init_local_subvolumes failed");
-                        goto err;
-                }
-        }
+    conf->dir_spread_cnt = conf->subvolume_cnt;
+    GF_OPTION_INIT("directory-layout-spread", conf->dir_spread_cnt, uint32,
+                   err);
 
-        if (dict_get_str (this->options, "decommissioned-bricks", &temp_str) == 0) {
-                ret = dht_parse_decommissioned_bricks (this, conf, temp_str);
-                if (ret == -1)
-                        goto err;
-        }
+    GF_OPTION_INIT("assert-no-child-down", conf->assert_no_child_down, bool,
+                   err);
 
-        dht_init_regex (this, this->options, "rsync-hash-regex",
-                        &conf->rsync_regex, &conf->rsync_regex_valid, conf);
-        dht_init_regex (this, this->options, "extra-hash-regex",
-                        &conf->extra_regex, &conf->extra_regex_valid, conf);
+    GF_OPTION_INIT("readdir-optimize", conf->readdir_optimize, bool, err);
 
-        ret = dht_layouts_init (this, conf);
-        if (ret == -1) {
-                goto err;
-        }
+    GF_OPTION_INIT("lock-migration", conf->lock_migration_enabled, bool, err);
+
+    GF_OPTION_INIT("force-migration", conf->force_migration, bool, err);
 
+    if (defrag) {
+        defrag->lock_migration_enabled = conf->lock_migration_enabled;
 
-        conf->gen = 1;
+        GF_OPTION_INIT("rebalance-stats", defrag->stats, bool, err);
+        if (dict_get_str(this->options, "rebalance-filter", &temp_str) == 0) {
+            if (gf_defrag_pattern_list_fill(this, defrag, temp_str) == -1) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INVALID_OPTION,
+                       "Invalid option:"
+                       " Cannot parse rebalance-filter (%s)",
+                       temp_str);
 
-        this->local_pool = mem_pool_new (dht_local_t, 512);
-        if (!this->local_pool) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY,
-                        " DHT initialisation failed. "
-                        "failed to create local_t's memory pool");
                 goto err;
+            }
         }
-
-        GF_OPTION_INIT ("randomize-hash-range-by-gfid",
-                        conf->randomize_by_gfid, bool, err);
-
-        if (defrag) {
-                GF_OPTION_INIT ("rebal-throttle", temp_str, str, err);
-                if (temp_str) {
-                        ret = dht_configure_throttle (this, conf, temp_str);
-                        if (ret == -1)
-                                goto err;
-                }
+    }
+
+    /* option can be any one of percent or bytes */
+    conf->disk_unit = 0;
+    if (conf->min_free_disk < 100)
+        conf->disk_unit = 'p';
+
+    ret = dht_init_subvolumes(this, conf);
+    if (ret == -1) {
+        goto err;
+    }
+
+    if (cmd) {
+        ret = dht_init_local_subvolumes(this, conf);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_INIT_LOCAL_SUBVOL_FAILED,
+                   "dht_init_local_subvolumes failed");
+            goto err;
         }
-
-        GF_OPTION_INIT ("xattr-name", conf->xattr_name, str, err);
-        gf_asprintf (&conf->mds_xattr_key, "%s."DHT_MDS_STR, conf->xattr_name);
-        gf_asprintf (&conf->link_xattr_name, "%s."DHT_LINKFILE_STR,
-                     conf->xattr_name);
-        gf_asprintf (&conf->commithash_xattr_name, "%s."DHT_COMMITHASH_STR,
-                     conf->xattr_name);
-        gf_asprintf (&conf->wild_xattr_name, "%s*", conf->xattr_name);
-        if (!conf->link_xattr_name || !conf->wild_xattr_name) {
+    }
+
+    if (dict_get_str(this->options, "decommissioned-bricks", &temp_str) == 0) {
+        ret = dht_parse_decommissioned_bricks(this, conf, temp_str);
+        if (ret == -1)
+            goto err;
+    }
+
+    dht_init_regex(this, this->options, "rsync-hash-regex", &conf->rsync_regex,
+                   &conf->rsync_regex_valid, conf);
+    dht_init_regex(this, this->options, "extra-hash-regex", &conf->extra_regex,
+                   &conf->extra_regex_valid, conf);
+
+    ret = dht_layouts_init(this, conf);
+    if (ret == -1) {
+        goto err;
+    }
+
+    conf->gen = 1;
+
+    this->local_pool = mem_pool_new(dht_local_t, 512);
+    if (!this->local_pool) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               " DHT initialisation failed. "
+               "failed to create local_t's memory pool");
+        goto err;
+    }
+
+    GF_OPTION_INIT("randomize-hash-range-by-gfid", conf->randomize_by_gfid,
+                   bool, err);
+
+    if (defrag) {
+        GF_OPTION_INIT("rebal-throttle", temp_str, str, err);
+        if (temp_str) {
+            ret = dht_configure_throttle(this, conf, temp_str);
+            if (ret == -1)
                 goto err;
         }
+    }
 
-        GF_OPTION_INIT ("weighted-rebalance", conf->do_weighting, bool, err);
+    GF_OPTION_INIT("xattr-name", conf->xattr_name, str, err);
+    gf_asprintf(&conf->mds_xattr_key, "%s." DHT_MDS_STR, conf->xattr_name);
+    gf_asprintf(&conf->link_xattr_name, "%s." DHT_LINKFILE_STR,
+                conf->xattr_name);
+    gf_asprintf(&conf->commithash_xattr_name, "%s." DHT_COMMITHASH_STR,
+                conf->xattr_name);
+    gf_asprintf(&conf->wild_xattr_name, "%s*", conf->xattr_name);
+    if (!conf->link_xattr_name || !conf->wild_xattr_name) {
+        goto err;
+    }
 
-        conf->lock_pool = mem_pool_new (dht_lock_t, 512);
-        if (!conf->lock_pool) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_INIT_FAILED,
-                        "failed to create lock mem_pool, failing "
-                        "initialization");
-                goto err;
-        }
+    GF_OPTION_INIT("weighted-rebalance", conf->do_weighting, bool, err);
 
-        this->private = conf;
+    conf->lock_pool = mem_pool_new(dht_lock_t, 512);
+    if (!conf->lock_pool) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_INIT_FAILED,
+               "failed to create lock mem_pool, failing "
+               "initialization");
+        goto err;
+    }
 
-        if (dht_set_subvol_range(this))
-                goto err;
+    this->private = conf;
 
-        if (dht_init_methods (this))
-                goto err;
+    if (dht_set_subvol_range(this))
+        goto err;
 
-        return 0;
+    if (dht_init_methods(this))
+        goto err;
+
+    return 0;
 
 err:
-        if (conf) {
-                if (conf->file_layouts) {
-                        for (i = 0; i < conf->subvolume_cnt; i++) {
-                                GF_FREE (conf->file_layouts[i]);
-                        }
-                        GF_FREE (conf->file_layouts);
-                }
+    if (conf) {
+        if (conf->file_layouts) {
+            for (i = 0; i < conf->subvolume_cnt; i++) {
+                GF_FREE(conf->file_layouts[i]);
+            }
+            GF_FREE(conf->file_layouts);
+        }
 
-                GF_FREE (conf->subvolumes);
+        GF_FREE(conf->subvolumes);
 
-                GF_FREE (conf->subvolume_status);
+        GF_FREE(conf->subvolume_status);
 
-                GF_FREE (conf->du_stats);
+        GF_FREE(conf->du_stats);
 
-                GF_FREE (conf->defrag);
+        GF_FREE(conf->defrag);
 
-                GF_FREE (conf->xattr_name);
-                GF_FREE (conf->link_xattr_name);
-                GF_FREE (conf->wild_xattr_name);
-                GF_FREE (conf->mds_xattr_key);
+        GF_FREE(conf->xattr_name);
+        GF_FREE(conf->link_xattr_name);
+        GF_FREE(conf->wild_xattr_name);
+        GF_FREE(conf->mds_xattr_key);
 
-                if (conf->lock_pool)
-                        mem_pool_destroy (conf->lock_pool);
+        if (conf->lock_pool)
+            mem_pool_destroy(conf->lock_pool);
 
-                GF_FREE (conf);
-        }
+        GF_FREE(conf);
+    }
 
-        return -1;
+    return -1;
 }
 
-
 struct volume_options options[] = {
-        { .key  = {"lookup-unhashed"},
-          .value = {"auto", "yes", "no", "enable", "disable", "1", "0",
-                    "on", "off"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "on",
-          .description = "This option if set to ON, does a lookup through "
-          "all the sub-volumes, in case a lookup didn't return any result "
-          "from the hash subvolume. If set to OFF, it does not do a lookup "
-          "on the remaining subvolumes.",
-          .op_version = {1},
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-          .level = OPT_STATUS_BASIC,
-        },
-        { .key = {"lookup-optimize"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "This option if set to ON enables the optimization "
-          "of -ve lookups, by not doing a lookup on non-hashed subvolumes for "
-          "files, in case the hashed subvolume does not return any result. "
-          "This option disregards the lookup-unhashed setting, when enabled.",
-          .op_version = {GD_OP_VERSION_3_7_2},
-          .level = OPT_STATUS_ADVANCED,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key  = {"min-free-disk"},
-          .type = GF_OPTION_TYPE_PERCENT_OR_SIZET,
-          .default_value = "10%",
-          .description = "Percentage/Size of disk space, after which the "
-          "process starts balancing out the cluster, and logs will appear "
-          "in log files",
-          .op_version = {1},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key  = {"min-free-inodes"},
-          .type = GF_OPTION_TYPE_PERCENT,
-          .default_value = "5%",
-          .description = "after system has only N% of inodes, warnings "
-          "starts to appear in log files",
-          .op_version = {1},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key = {"unhashed-sticky-bit"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-        },
-        { .key = {"use-readdirp"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "This option if set to ON, forces the use of "
-          "readdirp, and hence also displays the stats of the files.",
-          .level = OPT_STATUS_ADVANCED,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key = {"assert-no-child-down"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option if set to ON, in the event of "
-          "CHILD_DOWN, will call exit."
-        },
-        { .key  = {"directory-layout-spread"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 1,
-          .validate = GF_OPT_VALIDATE_MIN,
-          .description = "Specifies the directory layout spread. Takes number "
-                         "of subvolumes as default value.",
-
-          .op_version = {2},
-        },
-        { .key  = {"decommissioned-bricks"},
-          .type = GF_OPTION_TYPE_ANY,
-          .description = "This option if set to ON, decommissions "
-          "the brick, so that no new data is allowed to be created "
-          "on that brick.",
-          .level = OPT_STATUS_ADVANCED,
-        },
-        { .key  = {"rebalance-cmd"},
-          .type = GF_OPTION_TYPE_INT,
-        },
-        { .key = {"commit-hash"},
-          .type = GF_OPTION_TYPE_INT,
-        },
-        { .key = {"node-uuid"},
-          .type = GF_OPTION_TYPE_STR,
-        },
-        { .key = {"rebalance-stats"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option if set to ON displays and logs the "
-          " time taken for migration of each file, during the rebalance "
-          "process. If set to OFF, the rebalance logs will only display the "
-          "time spent in each directory.",
-          .op_version = {2},
-          .level = OPT_STATUS_BASIC,
-        },
-        { .key = {"readdir-optimize"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "This option if set to ON enables the optimization "
-          "that allows DHT to requests non-first subvolumes to filter out "
-          "directory entries.",
-          .op_version = {1},
-          .level = OPT_STATUS_ADVANCED,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key = {"rsync-hash-regex"},
-          .type = GF_OPTION_TYPE_STR,
-          /* Setting a default here doesn't work.  See dht_init_regex. */
-          .description = "Regular expression for stripping temporary-file "
-          "suffix and prefix used by rsync, to prevent relocation when the "
-          "file is renamed.",
-          .op_version = {3},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key = {"extra-hash-regex"},
-          .type = GF_OPTION_TYPE_STR,
-          /* Setting a default here doesn't work.  See dht_init_regex. */
-          .description = "Regular expression for stripping temporary-file "
-          "suffix and prefix used by an application, to prevent relocation when "
-          "the file is renamed.",
-          .op_version = {3},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-        { .key = {"rebalance-filter"},
-          .type = GF_OPTION_TYPE_STR,
-        },
-
-        { .key = {"xattr-name"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "trusted.glusterfs.dht",
-          .description = "Base for extended attributes used by this "
-          "translator instance, to avoid conflicts with others above or "
-          "below it.",
-          .op_version = {3},
-        },
-
-        { .key = {"weighted-rebalance"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "When enabled, files will be allocated to bricks "
-          "with a probability proportional to their size.  Otherwise, all "
-          "bricks will have the same probability (legacy behavior).",
-          .op_version  = {GD_OP_VERSION_3_6_0},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-
-        /* NUFA option */
-        { .key  = {"local-volume-name"},
-          .type = GF_OPTION_TYPE_XLATOR
-        },
-
-        /* tier options */
-        { .key  = {"tier-pause"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-        },
-
-        { .key  = {"tier-promote-frequency"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "120",
-        },
-
-        { .key  = {"tier-demote-frequency"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "3600",
-        },
-
-        { .key  = {"write-freq-threshold"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0",
-        },
-
-        { .key  = {"read-freq-threshold"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0",
-        },
-        { .key         = {"watermark-hi"},
-          .type = GF_OPTION_TYPE_PERCENT,
-          .default_value = "90",
-        },
-        { .key         = {"watermark-low"},
-          .type = GF_OPTION_TYPE_PERCENT,
-          .default_value = "75",
-        },
-        { .key         = {"tier-mode"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "test",
-        },
-        { .key         = {"tier-compact"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-        },
-        { .key         = {"tier-hot-compact-frequency"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "604800",
-          .description = "Frequency to compact DBs on hot tier in system"
-        },
-        { .key         = {"tier-cold-compact-frequency"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "604800",
-          .description = "Frequency to compact DBs on cold tier in system"
-        },
-        { .key         = {"tier-max-mb"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "4000",
-        },
-        { .key         = {"tier-max-promote-file-size"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0",
-        },
-        { .key         = {"tier-max-files"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "10000",
-        },
-        { .key         = {"tier-query-limit"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "100",
-        },
-        /* switch option */
-        { .key  = {"pattern.switch.case"},
-          .type = GF_OPTION_TYPE_ANY
-        },
-
-        { .key =  {"randomize-hash-range-by-gfid"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Use gfid of directory to determine the subvolume "
-          "from which hash ranges are allocated starting with 0. "
-          "Note that we still use a directory/file's name to determine the "
-          "subvolume to which it hashes",
-          .op_version  = {GD_OP_VERSION_3_6_0},
-        },
-
-        { .key =  {"rebal-throttle"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "normal",
-          .description = " Sets the maximum number of parallel file migrations "
-                         "allowed on a node during the rebalance operation. The"
-                         " default value is normal and allows a max of "
-                         "[($(processing units) - 4) / 2), 2]  files to be "
-                         "migrated at a time. Lazy will allow only one file to "
-                         "be migrated at a time and aggressive will allow "
-                         "max of [($(processing units) - 4) / 2), 4]",
-          .op_version  = {GD_OP_VERSION_3_7_0},
-          .level = OPT_STATUS_BASIC,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-
-        },
-
-        { .key =  {"lock-migration"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = " If enabled this feature will migrate the posix locks"
-                         " associated with a file during rebalance",
-          .op_version  = {GD_OP_VERSION_3_8_0},
-          .level = OPT_STATUS_ADVANCED,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-
-        { .key =  {"force-migration"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "If disabled, rebalance will not migrate files that "
-                         "are being written to by an application",
-          .op_version  = {GD_OP_VERSION_4_0_0},
-          .level = OPT_STATUS_ADVANCED,
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
-        },
-
-        { .key  = {NULL} },
+    {
+        .key = {"lookup-unhashed"},
+        .value = {"auto", "yes", "no", "enable", "disable", "1", "0", "on",
+                  "off"},
+        .type = GF_OPTION_TYPE_STR,
+        .default_value = "on",
+        .description =
+            "This option if set to ON, does a lookup through "
+            "all the sub-volumes, in case a lookup didn't return any result "
+            "from the hash subvolume. If set to OFF, it does not do a lookup "
+            "on the remaining subvolumes.",
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+        .level = OPT_STATUS_BASIC,
+    },
+    {.key = {"lookup-optimize"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description =
+         "This option if set to ON enables the optimization "
+         "of -ve lookups, by not doing a lookup on non-hashed subvolumes for "
+         "files, in case the hashed subvolume does not return any result. "
+         "This option disregards the lookup-unhashed setting, when enabled.",
+     .op_version = {GD_OP_VERSION_3_7_2},
+     .level = OPT_STATUS_ADVANCED,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {.key = {"min-free-disk"},
+     .type = GF_OPTION_TYPE_PERCENT_OR_SIZET,
+     .default_value = "10%",
+     .description =
+         "Percentage/Size of disk space, after which the "
+         "process starts balancing out the cluster, and logs will appear "
+         "in log files",
+     .op_version = {1},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {.key = {"min-free-inodes"},
+     .type = GF_OPTION_TYPE_PERCENT,
+     .default_value = "5%",
+     .description = "after system has only N% of inodes, warnings "
+                    "starts to appear in log files",
+     .op_version = {1},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {
+        .key = {"unhashed-sticky-bit"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+    },
+    {.key = {"use-readdirp"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "This option if set to ON, forces the use of "
+                    "readdirp, and hence also displays the stats of the files.",
+     .level = OPT_STATUS_ADVANCED,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {.key = {"assert-no-child-down"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option if set to ON, in the event of "
+                    "CHILD_DOWN, will call exit."},
+    {
+        .key = {"directory-layout-spread"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 1,
+        .validate = GF_OPT_VALIDATE_MIN,
+        .description = "Specifies the directory layout spread. Takes number "
+                       "of subvolumes as default value.",
+
+        .op_version = {2},
+    },
+    {
+        .key = {"decommissioned-bricks"},
+        .type = GF_OPTION_TYPE_ANY,
+        .description =
+            "This option if set to ON, decommissions "
+            "the brick, so that no new data is allowed to be created "
+            "on that brick.",
+        .level = OPT_STATUS_ADVANCED,
+    },
+    {
+        .key = {"rebalance-cmd"},
+        .type = GF_OPTION_TYPE_INT,
+    },
+    {
+        .key = {"commit-hash"},
+        .type = GF_OPTION_TYPE_INT,
+    },
+    {
+        .key = {"node-uuid"},
+        .type = GF_OPTION_TYPE_STR,
+    },
+    {
+        .key = {"rebalance-stats"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+        .description =
+            "This option if set to ON displays and logs the "
+            " time taken for migration of each file, during the rebalance "
+            "process. If set to OFF, the rebalance logs will only display the "
+            "time spent in each directory.",
+        .op_version = {2},
+        .level = OPT_STATUS_BASIC,
+    },
+    {.key = {"readdir-optimize"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description =
+         "This option if set to ON enables the optimization "
+         "that allows DHT to requests non-first subvolumes to filter out "
+         "directory entries.",
+     .op_version = {1},
+     .level = OPT_STATUS_ADVANCED,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {.key = {"rsync-hash-regex"},
+     .type = GF_OPTION_TYPE_STR,
+     /* Setting a default here doesn't work.  See dht_init_regex. */
+     .description =
+         "Regular expression for stripping temporary-file "
+         "suffix and prefix used by rsync, to prevent relocation when the "
+         "file is renamed.",
+     .op_version = {3},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {.key = {"extra-hash-regex"},
+     .type = GF_OPTION_TYPE_STR,
+     /* Setting a default here doesn't work.  See dht_init_regex. */
+     .description =
+         "Regular expression for stripping temporary-file "
+         "suffix and prefix used by an application, to prevent relocation when "
+         "the file is renamed.",
+     .op_version = {3},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+    {
+        .key = {"rebalance-filter"},
+        .type = GF_OPTION_TYPE_STR,
+    },
+
+    {
+        .key = {"xattr-name"},
+        .type = GF_OPTION_TYPE_STR,
+        .default_value = "trusted.glusterfs.dht",
+        .description =
+            "Base for extended attributes used by this "
+            "translator instance, to avoid conflicts with others above or "
+            "below it.",
+        .op_version = {3},
+    },
+
+    {.key = {"weighted-rebalance"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description =
+         "When enabled, files will be allocated to bricks "
+         "with a probability proportional to their size.  Otherwise, all "
+         "bricks will have the same probability (legacy behavior).",
+     .op_version = {GD_OP_VERSION_3_6_0},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+
+    /* NUFA option */
+    {.key = {"local-volume-name"}, .type = GF_OPTION_TYPE_XLATOR},
+
+    /* tier options */
+    {
+        .key = {"tier-pause"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+    },
+
+    {
+        .key = {"tier-promote-frequency"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "120",
+    },
+
+    {
+        .key = {"tier-demote-frequency"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "3600",
+    },
+
+    {
+        .key = {"write-freq-threshold"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "0",
+    },
+
+    {
+        .key = {"read-freq-threshold"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "0",
+    },
+    {
+        .key = {"watermark-hi"},
+        .type = GF_OPTION_TYPE_PERCENT,
+        .default_value = "90",
+    },
+    {
+        .key = {"watermark-low"},
+        .type = GF_OPTION_TYPE_PERCENT,
+        .default_value = "75",
+    },
+    {
+        .key = {"tier-mode"},
+        .type = GF_OPTION_TYPE_STR,
+        .default_value = "test",
+    },
+    {
+        .key = {"tier-compact"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+    },
+    {.key = {"tier-hot-compact-frequency"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "604800",
+     .description = "Frequency to compact DBs on hot tier in system"},
+    {.key = {"tier-cold-compact-frequency"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "604800",
+     .description = "Frequency to compact DBs on cold tier in system"},
+    {
+        .key = {"tier-max-mb"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "4000",
+    },
+    {
+        .key = {"tier-max-promote-file-size"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "0",
+    },
+    {
+        .key = {"tier-max-files"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "10000",
+    },
+    {
+        .key = {"tier-query-limit"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "100",
+    },
+    /* switch option */
+    {.key = {"pattern.switch.case"}, .type = GF_OPTION_TYPE_ANY},
+
+    {
+        .key = {"randomize-hash-range-by-gfid"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+        .description =
+            "Use gfid of directory to determine the subvolume "
+            "from which hash ranges are allocated starting with 0. "
+            "Note that we still use a directory/file's name to determine the "
+            "subvolume to which it hashes",
+        .op_version = {GD_OP_VERSION_3_6_0},
+    },
+
+    {.key = {"rebal-throttle"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "normal",
+     .description = " Sets the maximum number of parallel file migrations "
+                    "allowed on a node during the rebalance operation. The"
+                    " default value is normal and allows a max of "
+                    "[($(processing units) - 4) / 2), 2]  files to be "
+                    "migrated at a time. Lazy will allow only one file to "
+                    "be migrated at a time and aggressive will allow "
+                    "max of [($(processing units) - 4) / 2), 4]",
+     .op_version = {GD_OP_VERSION_3_7_0},
+     .level = OPT_STATUS_BASIC,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC
+
+    },
+
+    {.key = {"lock-migration"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = " If enabled this feature will migrate the posix locks"
+                    " associated with a file during rebalance",
+     .op_version = {GD_OP_VERSION_3_8_0},
+     .level = OPT_STATUS_ADVANCED,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+
+    {.key = {"force-migration"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "If disabled, rebalance will not migrate files that "
+                    "are being written to by an application",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .level = OPT_STATUS_ADVANCED,
+     .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+
+    {.key = {NULL}},
 };
diff --git a/xlators/cluster/dht/src/dht.c b/xlators/cluster/dht/src/dht.c
index 90962636d18..677905f236e 100644
--- a/xlators/cluster/dht/src/dht.c
+++ b/xlators/cluster/dht/src/dht.c
@@ -8,78 +8,72 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "statedump.h"
 #include "dht-common.h"
 
-class_methods_t class_methods = {
-        .init           = dht_init,
-        .fini           = dht_fini,
-        .reconfigure    = dht_reconfigure,
-        .notify         = dht_notify
-};
+class_methods_t class_methods = {.init = dht_init,
+                                 .fini = dht_fini,
+                                 .reconfigure = dht_reconfigure,
+                                 .notify = dht_notify};
 
 struct xlator_fops fops = {
-        .ipc         = dht_ipc,
-        .lookup      = dht_lookup,
-        .mknod       = dht_mknod,
-        .create      = dht_create,
+    .ipc = dht_ipc,
+    .lookup = dht_lookup,
+    .mknod = dht_mknod,
+    .create = dht_create,
 
-        .open        = dht_open,
-        .statfs      = dht_statfs,
-        .opendir     = dht_opendir,
-        .readdir     = dht_readdir,
-        .readdirp    = dht_readdirp,
-        .fsyncdir    = dht_fsyncdir,
-        .symlink     = dht_symlink,
-        .unlink      = dht_unlink,
-        .link        = dht_link,
-        .mkdir       = dht_mkdir,
-        .rmdir       = dht_rmdir,
-        .rename      = dht_rename,
-        .entrylk     = dht_entrylk,
-        .fentrylk    = dht_fentrylk,
+    .open = dht_open,
+    .statfs = dht_statfs,
+    .opendir = dht_opendir,
+    .readdir = dht_readdir,
+    .readdirp = dht_readdirp,
+    .fsyncdir = dht_fsyncdir,
+    .symlink = dht_symlink,
+    .unlink = dht_unlink,
+    .link = dht_link,
+    .mkdir = dht_mkdir,
+    .rmdir = dht_rmdir,
+    .rename = dht_rename,
+    .entrylk = dht_entrylk,
+    .fentrylk = dht_fentrylk,
 
-        /* Inode read operations */
-        .stat        = dht_stat,
-        .fstat       = dht_fstat,
-        .access      = dht_access,
-        .readlink    = dht_readlink,
-        .getxattr    = dht_getxattr,
-        .fgetxattr    = dht_fgetxattr,
-        .readv       = dht_readv,
-        .flush       = dht_flush,
-        .fsync       = dht_fsync,
-        .inodelk     = dht_inodelk,
-        .finodelk    = dht_finodelk,
-        .lk          = dht_lk,
-        .lease       = dht_lease,
+    /* Inode read operations */
+    .stat = dht_stat,
+    .fstat = dht_fstat,
+    .access = dht_access,
+    .readlink = dht_readlink,
+    .getxattr = dht_getxattr,
+    .fgetxattr = dht_fgetxattr,
+    .readv = dht_readv,
+    .flush = dht_flush,
+    .fsync = dht_fsync,
+    .inodelk = dht_inodelk,
+    .finodelk = dht_finodelk,
+    .lk = dht_lk,
+    .lease = dht_lease,
 
-        /* Inode write operations */
-        .fremovexattr = dht_fremovexattr,
-        .removexattr = dht_removexattr,
-        .setxattr    = dht_setxattr,
-        .fsetxattr   = dht_fsetxattr,
-        .truncate    = dht_truncate,
-        .ftruncate   = dht_ftruncate,
-        .writev      = dht_writev,
-        .xattrop     = dht_xattrop,
-        .fxattrop    = dht_fxattrop,
-        .setattr     = dht_setattr,
-        .fsetattr    = dht_fsetattr,
-	.fallocate   = dht_fallocate,
-	.discard     = dht_discard,
-        .zerofill    = dht_zerofill,
+    /* Inode write operations */
+    .fremovexattr = dht_fremovexattr,
+    .removexattr = dht_removexattr,
+    .setxattr = dht_setxattr,
+    .fsetxattr = dht_fsetxattr,
+    .truncate = dht_truncate,
+    .ftruncate = dht_ftruncate,
+    .writev = dht_writev,
+    .xattrop = dht_xattrop,
+    .fxattrop = dht_fxattrop,
+    .setattr = dht_setattr,
+    .fsetattr = dht_fsetattr,
+    .fallocate = dht_fallocate,
+    .discard = dht_discard,
+    .zerofill = dht_zerofill,
 };
 
 struct xlator_dumpops dumpops = {
-        .priv = dht_priv_dump,
-        .inodectx = dht_inodectx_dump,
+    .priv = dht_priv_dump,
+    .inodectx = dht_inodectx_dump,
 };
 
-
-struct xlator_cbks cbks = {
-        .release    = dht_release,
-//      .releasedir = dht_releasedir,
-        .forget     = dht_forget
-};
+struct xlator_cbks cbks = {.release = dht_release,
+                           //      .releasedir = dht_releasedir,
+                           .forget = dht_forget};
diff --git a/xlators/cluster/dht/src/nufa.c b/xlators/cluster/dht/src/nufa.c
index afa446584ba..b8077f972d1 100644
--- a/xlators/cluster/dht/src/nufa.c
+++ b/xlators/cluster/dht/src/nufa.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "dht-common.h"
 
 /* TODO: all 'TODO's in dht.c holds good */
@@ -16,673 +15,633 @@
 extern struct volume_options options[];
 
 int
-nufa_local_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno,
-                       inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                       struct iatt *postparent)
+nufa_local_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *stbuf, dict_t *xattr,
+                      struct iatt *postparent)
 {
-        xlator_t     *subvol      = NULL;
-        char          is_linkfile = 0;
-        char          is_dir      = 0;
-        dht_conf_t   *conf        = NULL;
-        dht_local_t  *local       = NULL;
-        loc_t        *loc         = NULL;
-        int           i           = 0;
-        xlator_t     *prev        = NULL;
-        int           call_cnt    = 0;
-        int           ret         = 0;
-
-        conf  = this->private;
-
-        prev  = cookie;
-        local = frame->local;
-        loc   = &local->loc;
-
-        if (ENTRY_MISSING (op_ret, op_errno)) {
-                if (conf->search_unhashed) {
-                        local->op_errno = ENOENT;
-                        dht_lookup_everywhere (frame, this, loc);
-                        return 0;
-                }
+    xlator_t *subvol = NULL;
+    char is_linkfile = 0;
+    char is_dir = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    int i = 0;
+    xlator_t *prev = NULL;
+    int call_cnt = 0;
+    int ret = 0;
+
+    conf = this->private;
+
+    prev = cookie;
+    local = frame->local;
+    loc = &local->loc;
+
+    if (ENTRY_MISSING(op_ret, op_errno)) {
+        if (conf->search_unhashed) {
+            local->op_errno = ENOENT;
+            dht_lookup_everywhere(frame, this, loc);
+            return 0;
         }
-
-        if (op_ret == -1)
-                goto out;
-
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
-        is_dir      = check_is_dir (inode, stbuf, xattr);
-
-        if (!is_dir && !is_linkfile) {
-                /* non-directory and not a linkfile */
-                ret = dht_layout_preset (this, prev, inode);
-                if (ret < 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "could not set pre-set layout for subvol"
-                                      " %s", prev->name);
-                        op_ret   = -1;
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                goto out;
+    }
+
+    if (op_ret == -1)
+        goto out;
+
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
+    is_dir = check_is_dir(inode, stbuf, xattr);
+
+    if (!is_dir && !is_linkfile) {
+        /* non-directory and not a linkfile */
+        ret = dht_layout_preset(this, prev, inode);
+        if (ret < 0) {
+            gf_msg_debug(this->name, 0,
+                         "could not set pre-set layout for subvol"
+                         " %s",
+                         prev->name);
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (is_dir) {
-                call_cnt        = conf->subvolume_cnt;
-                local->call_cnt = call_cnt;
-
-                local->inode = inode_ref (inode);
-                local->xattr = dict_ref (xattr);
-
-                local->op_ret = 0;
-                local->op_errno = 0;
-
-                local->layout = dht_layout_new (this, conf->subvolume_cnt);
-                if (!local->layout) {
-                        op_ret   = -1;
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                }
-        }
+        goto out;
+    }
 
-        if (is_linkfile) {
-                subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
+    if (is_dir) {
+        call_cnt = conf->subvolume_cnt;
+        local->call_cnt = call_cnt;
 
-                if (!subvol) {
-                        gf_msg_debug (this->name, 0,
-                                      "linkfile has no link subvolume. path=%s",
-                                      loc->path);
-                        dht_lookup_everywhere (frame, this, loc);
-                        return 0;
-                }
+        local->inode = inode_ref(inode);
+        local->xattr = dict_ref(xattr);
 
-                STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk, subvol,
-                                   subvol, subvol->fops->lookup,
-                                   &local->loc, local->xattr_req);
+        local->op_ret = 0;
+        local->op_errno = 0;
+
+        local->layout = dht_layout_new(this, conf->subvolume_cnt);
+        if (!local->layout) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            goto err;
         }
 
-        return 0;
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_lookup_dir_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
+        }
+    }
 
-out:
-        if (!local->hashed_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              local->loc.path);
-                local->op_errno = ENOENT;
-                dht_lookup_everywhere (frame, this, loc);
-                return 0;
+    if (is_linkfile) {
+        subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
+
+        if (!subvol) {
+            gf_msg_debug(this->name, 0,
+                         "linkfile has no link subvolume. path=%s", loc->path);
+            dht_lookup_everywhere(frame, this, loc);
+            return 0;
         }
 
-        STACK_WIND_COOKIE (frame, dht_lookup_cbk, local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->lookup,
-                           &local->loc, local->xattr_req);
+        STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, local->xattr_req);
+    }
 
+    return 0;
+
+out:
+    if (!local->hashed_subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     local->loc.path);
+        local->op_errno = ENOENT;
+        dht_lookup_everywhere(frame, this, loc);
         return 0;
+    }
+
+    STACK_WIND_COOKIE(frame, dht_lookup_cbk, local->hashed_subvol,
+                      local->hashed_subvol, local->hashed_subvol->fops->lookup,
+                      &local->loc, local->xattr_req);
+
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno,
-                          inode, stbuf, xattr, postparent);
-        return 0;
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     postparent);
+    return 0;
 }
 
 int
-nufa_lookup (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, dict_t *xattr_req)
+nufa_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
 {
-        xlator_t     *hashed_subvol = NULL;
-        xlator_t     *subvol = NULL;
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret    = -1;
-        int           op_errno = -1;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_LOOKUP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_LOOKUP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (xattr_req) {
+        local->xattr_req = dict_ref(xattr_req);
+    } else {
+        local->xattr_req = dict_new();
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
+
+    local->hashed_subvol = hashed_subvol;
+
+    if (is_revalidate(loc)) {
+        layout = local->layout;
+        if (!layout) {
+            gf_msg_debug(this->name, 0,
+                         "revalidate lookup without cache. "
+                         "path=%s",
+                         loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (xattr_req) {
-                local->xattr_req = dict_ref (xattr_req);
-        } else {
-                local->xattr_req = dict_new ();
+        if (layout->gen && (layout->gen < conf->gen)) {
+            gf_msg_debug(this->name, 0, "incomplete layout failure for path=%s",
+                         loc->path);
+            dht_layout_unref(this, local->layout);
+            goto do_fresh_lookup;
         }
 
-        hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
-
-        local->hashed_subvol = hashed_subvol;
-
-        if (is_revalidate (loc)) {
-                layout = local->layout;
-                if (!layout) {
-                        gf_msg_debug (this->name, 0,
-                                      "revalidate lookup without cache. "
-                                      "path=%s", loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (layout->gen && (layout->gen < conf->gen)) {
-                        gf_msg_debug (this->name, 0,
-                                      "incomplete layout failure for path=%s",
-                                      loc->path);
-                        dht_layout_unref (this, local->layout);
-                        goto do_fresh_lookup;
-                }
-
-                local->inode = inode_ref (loc->inode);
-
-                local->call_cnt = layout->cnt;
-                call_cnt = local->call_cnt;
-
-                /* NOTE: we don't require 'trusted.glusterfs.dht.linkto' attribute,
-                 *       revalidates directly go to the cached-subvolume.
-                 */
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dict value.");
-                        op_errno = -1;
-                        goto err;
-                }
-
-                for (i = 0; i < layout->cnt; i++) {
-                        subvol = layout->list[i].xlator;
-
-                        STACK_WIND_COOKIE (frame, dht_revalidate_cbk, subvol,
-                                           subvol, subvol->fops->lookup,
-                                           loc, local->xattr_req);
-
-                        if (!--call_cnt)
-                                break;
-                }
-        } else {
-        do_fresh_lookup:
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dict value.");
-                        op_errno = -1;
-                        goto err;
-                }
-
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->link_xattr_name, 256);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "Failed to set dict value.");
-                        op_errno = -1;
-                        goto err;
-                }
-
-                /* Send it to only local volume */
-                STACK_WIND_COOKIE (frame, nufa_local_lookup_cbk,
-                                   ((xlator_t *)conf->private),
-                                   ((xlator_t *)conf->private),
-                                   ((xlator_t *)conf->private)->fops->lookup,
-                                   loc, local->xattr_req);
-        }
+        local->inode = inode_ref(loc->inode);
 
-        return 0;
+        local->call_cnt = layout->cnt;
+        call_cnt = local->call_cnt;
 
-err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL);
-        return 0;
-}
+        /* NOTE: we don't require 'trusted.glusterfs.dht.linkto' attribute,
+         *       revalidates directly go to the cached-subvolume.
+         */
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dict value.");
+            op_errno = -1;
+            goto err;
+        }
 
-int
-nufa_create_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int op_ret, int op_errno,
-                                 inode_t *inode, struct iatt *stbuf,
-                                 struct iatt *preparent,
-                                 struct iatt *postparent, dict_t *xdata)
-{
-        dht_local_t  *local = NULL;
+        for (i = 0; i < layout->cnt; i++) {
+            subvol = layout->list[i].xlator;
 
-        local = frame->local;
+            STACK_WIND_COOKIE(frame, dht_revalidate_cbk, subvol, subvol,
+                              subvol->fops->lookup, loc, local->xattr_req);
 
-        if (op_ret == -1)
-                goto err;
+            if (!--call_cnt)
+                break;
+        }
+    } else {
+    do_fresh_lookup:
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dict value.");
+            op_errno = -1;
+            goto err;
+        }
+
+        ret = dict_set_uint32(local->xattr_req, conf->link_xattr_name, 256);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+                   "Failed to set dict value.");
+            op_errno = -1;
+            goto err;
+        }
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, local->cached_subvol,
-                           local->cached_subvol, local->cached_subvol->fops->create,
-                           &local->loc, local->flags, local->mode, local->umask,
-                           local->fd, local->params);
+        /* Send it to only local volume */
+        STACK_WIND_COOKIE(
+            frame, nufa_local_lookup_cbk, ((xlator_t *)conf->private),
+            ((xlator_t *)conf->private),
+            ((xlator_t *)conf->private)->fops->lookup, loc, local->xattr_req);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (create, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL, NULL);
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-nufa_create (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, int32_t flags, mode_t mode,
-             mode_t umask, fd_t *fd, dict_t *params)
+nufa_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int op_ret, int op_errno,
+                                inode_t *inode, struct iatt *stbuf,
+                                struct iatt *preparent, struct iatt *postparent,
+                                dict_t *xdata)
 {
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf  = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *avail_subvol = NULL;
-        int          op_errno = -1;
+    dht_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
+    local = frame->local;
 
-        conf  = this->private;
+    if (op_ret == -1)
+        goto err;
 
-        dht_get_du_info (frame, this, loc);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, local->cached_subvol,
+                      local->cached_subvol, local->cached_subvol->fops->create,
+                      &local->loc, local->flags, local->mode, local->umask,
+                      local->fd, local->params);
 
-        local = dht_local_init (frame, loc, fd, GF_FOP_CREATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    return 0;
 
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        avail_subvol = conf->private;
-        if (dht_is_subvol_filled (this, (xlator_t *)conf->private)) {
-                avail_subvol =
-                        dht_free_disk_available_subvol (this,
-                                                        (xlator_t *)conf->private,
-                                                        local);
-        }
+err:
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
+}
 
-        if (subvol != avail_subvol) {
-                /* create a link file instead of actual file */
-                local->params = dict_ref (params);
-                local->mode = mode;
-                local->flags = flags;
-                local->umask = umask;
-                local->cached_subvol = avail_subvol;
-                dht_linkfile_create (frame, nufa_create_linkfile_create_cbk,
-                                     this, avail_subvol, subvol, loc);
-                return 0;
-        }
+int
+nufa_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+            mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
+{
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *avail_subvol = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    avail_subvol = conf->private;
+    if (dht_is_subvol_filled(this, (xlator_t *)conf->private)) {
+        avail_subvol = dht_free_disk_available_subvol(
+            this, (xlator_t *)conf->private, local);
+    }
+
+    if (subvol != avail_subvol) {
+        /* create a link file instead of actual file */
+        local->params = dict_ref(params);
+        local->mode = mode;
+        local->flags = flags;
+        local->umask = umask;
+        local->cached_subvol = avail_subvol;
+        dht_linkfile_create(frame, nufa_create_linkfile_create_cbk, this,
+                            avail_subvol, subvol, loc);
+        return 0;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, subvol,
-                           subvol, subvol->fops->create,
-                           loc, flags, mode, umask, fd, params);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                      subvol->fops->create, loc, flags, mode, umask, fd,
+                      params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (create, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-nufa_mknod_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, inode_t *inode,
-                         struct iatt *stbuf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+nufa_mknod_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (!local || !local->cached_subvol) {
-                op_errno = EINVAL;
-                op_ret = -1;
-                goto err;
-        }
+    local = frame->local;
+    if (!local || !local->cached_subvol) {
+        op_errno = EINVAL;
+        op_ret = -1;
+        goto err;
+    }
 
-        if (op_ret >= 0) {
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk,
-                            (void *)local->cached_subvol, local->cached_subvol,
-                            local->cached_subvol->fops->mknod,
-                            &local->loc, local->mode, local->rdev,
-                            local->umask, local->params);
+    if (op_ret >= 0) {
+        STACK_WIND_COOKIE(
+            frame, dht_newfile_cbk, (void *)local->cached_subvol,
+            local->cached_subvol, local->cached_subvol->fops->mknod,
+            &local->loc, local->mode, local->rdev, local->umask, local->params);
 
-                return 0;
-        }
+        return 0;
+    }
 err:
-        WIPE (postparent);
-        WIPE (preparent);
+    WIPE(postparent);
+    WIPE(preparent);
 
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno,
-                          inode, stbuf, preparent, postparent, xdata);
-        return 0;
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, xdata);
+    return 0;
 }
 
-
 int
-nufa_mknod (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, mode_t mode, dev_t rdev, mode_t umask, dict_t *params)
+nufa_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+           dev_t rdev, mode_t umask, dict_t *params)
 {
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf  = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *avail_subvol = NULL;
-        int          op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf  = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKNOD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        /* Consider the disksize in consideration */
-        avail_subvol = conf->private;
-        if (dht_is_subvol_filled (this, (xlator_t *)conf->private)) {
-                avail_subvol =
-                        dht_free_disk_available_subvol (this,
-                                                        (xlator_t *)conf->private,
-                                                        local);
-        }
-
-        if (avail_subvol != subvol) {
-                /* Create linkfile first */
-
-                local->params = dict_ref (params);
-                local->mode = mode;
-                local->umask = umask;
-                local->rdev = rdev;
-                local->cached_subvol = avail_subvol;
-
-                dht_linkfile_create (frame, nufa_mknod_linkfile_cbk, this,
-                                     avail_subvol, subvol, loc);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *avail_subvol = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKNOD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    /* Consider the disksize in consideration */
+    avail_subvol = conf->private;
+    if (dht_is_subvol_filled(this, (xlator_t *)conf->private)) {
+        avail_subvol = dht_free_disk_available_subvol(
+            this, (xlator_t *)conf->private, local);
+    }
+
+    if (avail_subvol != subvol) {
+        /* Create linkfile first */
+
+        local->params = dict_ref(params);
+        local->mode = mode;
+        local->umask = umask;
+        local->rdev = rdev;
+        local->cached_subvol = avail_subvol;
+
+        dht_linkfile_create(frame, nufa_mknod_linkfile_cbk, this, avail_subvol,
+                            subvol, loc);
+        return 0;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol, subvol,
-                           subvol->fops->mknod, loc, mode, rdev, umask,
-                           params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                      subvol->fops->mknod, loc, mode, rdev, umask, params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (mknod, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 gf_boolean_t
-same_first_part (char *str1, char term1, char *str2, char term2)
+same_first_part(char *str1, char term1, char *str2, char term2)
 {
-        gf_boolean_t    ended1;
-        gf_boolean_t    ended2;
-
-        for (;;) {
-                ended1 = ((*str1 == '\0') || (*str1 == term1));
-                ended2 = ((*str2 == '\0') || (*str2 == term2));
-                if (ended1 && ended2) {
-                        return _gf_true;
-                }
-                if (ended1 || ended2 || (*str1 != *str2)) {
-                        return _gf_false;
-                }
-                ++str1;
-                ++str2;
+    gf_boolean_t ended1;
+    gf_boolean_t ended2;
+
+    for (;;) {
+        ended1 = ((*str1 == '\0') || (*str1 == term1));
+        ended2 = ((*str2 == '\0') || (*str2 == term2));
+        if (ended1 && ended2) {
+            return _gf_true;
         }
+        if (ended1 || ended2 || (*str1 != *str2)) {
+            return _gf_false;
+        }
+        ++str1;
+        ++str2;
+    }
 }
 
 typedef struct nufa_args {
-        xlator_t    *this;
-        char        *volname;
-        gf_boolean_t addr_match;
+    xlator_t *this;
+    char *volname;
+    gf_boolean_t addr_match;
 } nufa_args_t;
 
 static void
-nufa_find_local_brick (xlator_t *xl, void *data)
+nufa_find_local_brick(xlator_t *xl, void *data)
 {
-        nufa_args_t     *args = data;
-        xlator_t        *this = args->this;
-        char            *local_volname = args->volname;
-        gf_boolean_t    addr_match = args->addr_match;
-        char            *brick_host = NULL;
-        dht_conf_t      *conf = this->private;
-        int             ret = -1;
-
-        /*This means a local subvol was already found. We pick the first brick
-         * that is local*/
-        if (conf->private)
-                return;
-
-        if (strcmp (xl->name, local_volname) == 0) {
-                conf->private = xl;
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO,
-                        "Using specified subvol %s",
-                        local_volname);
-                return;
-        }
-
-        if (!addr_match)
-                return;
-
-        ret = dict_get_str (xl->options, "remote-host", &brick_host);
-        if ((ret == 0) &&
-            (gf_is_same_address (local_volname, brick_host) ||
-             gf_is_local_addr (brick_host))) {
-                conf->private = xl;
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO, "Using the first local "
-                        "subvol %s", xl->name);
-                return;
-        }
-
+    nufa_args_t *args = data;
+    xlator_t *this = args->this;
+    char *local_volname = args->volname;
+    gf_boolean_t addr_match = args->addr_match;
+    char *brick_host = NULL;
+    dht_conf_t *conf = this->private;
+    int ret = -1;
+
+    /*This means a local subvol was already found. We pick the first brick
+     * that is local*/
+    if (conf->private)
+        return;
+
+    if (strcmp(xl->name, local_volname) == 0) {
+        conf->private = xl;
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "Using specified subvol %s", local_volname);
+        return;
+    }
+
+    if (!addr_match)
+        return;
+
+    ret = dict_get_str(xl->options, "remote-host", &brick_host);
+    if ((ret == 0) && (gf_is_same_address(local_volname, brick_host) ||
+                       gf_is_local_addr(brick_host))) {
+        conf->private = xl;
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "Using the first local "
+               "subvol %s",
+               xl->name);
+        return;
+    }
 }
 
 static void
-nufa_to_dht (xlator_t *this)
+nufa_to_dht(xlator_t *this)
 {
-        GF_ASSERT (this);
-        GF_ASSERT (this->fops);
+    GF_ASSERT(this);
+    GF_ASSERT(this->fops);
 
-        this->fops->lookup = dht_lookup;
-        this->fops->create = dht_create;
-        this->fops->mknod  = dht_mknod;
+    this->fops->lookup = dht_lookup;
+    this->fops->create = dht_create;
+    this->fops->mknod = dht_mknod;
 }
 
 int
-nufa_find_local_subvol (xlator_t *this,
-                        void (*fn) (xlator_t *each, void* data), void *data)
+nufa_find_local_subvol(xlator_t *this, void (*fn)(xlator_t *each, void *data),
+                       void *data)
 {
-        int             ret = -1;
-        dht_conf_t      *conf = this->private;
-        xlator_list_t   *trav = NULL;
-        xlator_t        *parent = NULL;
-        xlator_t        *candidate = NULL;
-
-        xlator_foreach_depth_first (this, fn, data);
-        if (!conf->private) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_BRICK_ERROR, "Couldn't find a local "
-                        "brick");
-                return -1;
+    int ret = -1;
+    dht_conf_t *conf = this->private;
+    xlator_list_t *trav = NULL;
+    xlator_t *parent = NULL;
+    xlator_t *candidate = NULL;
+
+    xlator_foreach_depth_first(this, fn, data);
+    if (!conf->private) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_BRICK_ERROR,
+               "Couldn't find a local "
+               "brick");
+        return -1;
+    }
+
+    candidate = conf->private;
+    trav = candidate->parents;
+    while (trav) {
+        parent = trav->xlator;
+        if (strcmp(parent->type, "cluster/nufa") == 0) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+                   "Found local subvol, "
+                   "%s",
+                   candidate->name);
+            ret = 0;
+            conf->private = candidate;
+            break;
         }
 
-        candidate = conf->private;
-        trav = candidate->parents;
-        while (trav) {
-
-                parent = trav->xlator;
-                if (strcmp (parent->type, "cluster/nufa") == 0) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_SUBVOL_INFO, "Found local subvol, "
-                                "%s", candidate->name);
-                        ret = 0;
-                        conf->private = candidate;
-                        break;
-                }
-
-                candidate = parent;
-                trav = parent->parents;
-        }
+        candidate = parent;
+        trav = parent->parents;
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nufa_init (xlator_t *this)
+nufa_init(xlator_t *this)
 {
-        data_t        *data = NULL;
-        char          *local_volname = NULL;
-        int            ret = -1;
-        char           my_hostname[256];
-        gf_boolean_t   addr_match = _gf_false;
-        nufa_args_t    args = {0, };
-
-        ret = dht_init(this);
-        if (ret) {
-                return ret;
-        }
-
-        if ((data = dict_get (this->options, "local-volume-name"))) {
-                local_volname = data->data;
-
-        } else {
-                addr_match = _gf_true;
-                local_volname = "localhost";
-                ret = gethostname (my_hostname, 256);
-                if (ret == 0)
-                        local_volname = my_hostname;
-
-                else
-                        gf_msg (this->name, GF_LOG_WARNING, errno,
-                                DHT_MSG_GET_HOSTNAME_FAILED,
-                                "could not find hostname");
-
-        }
-
-        args.this = this;
-        args.volname = local_volname;
-        args.addr_match = addr_match;
-        ret = nufa_find_local_subvol (this, nufa_find_local_brick, &args);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_SUBVOL_INFO,
-                        "Unable to find local subvolume, switching "
-                        "to dht mode");
-                nufa_to_dht (this);
-        }
-        return 0;
+    data_t *data = NULL;
+    char *local_volname = NULL;
+    int ret = -1;
+    char my_hostname[256];
+    gf_boolean_t addr_match = _gf_false;
+    nufa_args_t args = {
+        0,
+    };
+
+    ret = dht_init(this);
+    if (ret) {
+        return ret;
+    }
+
+    if ((data = dict_get(this->options, "local-volume-name"))) {
+        local_volname = data->data;
+
+    } else {
+        addr_match = _gf_true;
+        local_volname = "localhost";
+        ret = gethostname(my_hostname, 256);
+        if (ret == 0)
+            local_volname = my_hostname;
+
+        else
+            gf_msg(this->name, GF_LOG_WARNING, errno,
+                   DHT_MSG_GET_HOSTNAME_FAILED, "could not find hostname");
+    }
+
+    args.this = this;
+    args.volname = local_volname;
+    args.addr_match = addr_match;
+    ret = nufa_find_local_subvol(this, nufa_find_local_brick, &args);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_SUBVOL_INFO,
+               "Unable to find local subvolume, switching "
+               "to dht mode");
+        nufa_to_dht(this);
+    }
+    return 0;
 }
 
 dht_methods_t dht_methods = {
-        .migration_get_dst_subvol = dht_migration_get_dst_subvol,
-        .migration_needed = dht_migration_needed,
-        .layout_search   = dht_layout_search,
-};
-
-class_methods_t class_methods = {
-        .init           = nufa_init,
-        .fini           = dht_fini,
-        .reconfigure    = dht_reconfigure,
-        .notify         = dht_notify
+    .migration_get_dst_subvol = dht_migration_get_dst_subvol,
+    .migration_needed = dht_migration_needed,
+    .layout_search = dht_layout_search,
 };
 
+class_methods_t class_methods = {.init = nufa_init,
+                                 .fini = dht_fini,
+                                 .reconfigure = dht_reconfigure,
+                                 .notify = dht_notify};
 
 struct xlator_fops fops = {
-        .lookup      = nufa_lookup,
-        .create      = nufa_create,
-        .mknod       = nufa_mknod,
-
-        .stat        = dht_stat,
-        .fstat       = dht_fstat,
-        .truncate    = dht_truncate,
-        .ftruncate   = dht_ftruncate,
-        .access      = dht_access,
-        .readlink    = dht_readlink,
-        .setxattr    = dht_setxattr,
-        .getxattr    = dht_getxattr,
-        .removexattr = dht_removexattr,
-        .open        = dht_open,
-        .readv       = dht_readv,
-        .writev      = dht_writev,
-        .flush       = dht_flush,
-        .fsync       = dht_fsync,
-        .statfs      = dht_statfs,
-        .lk          = dht_lk,
-        .opendir     = dht_opendir,
-        .readdir     = dht_readdir,
-        .readdirp    = dht_readdirp,
-        .fsyncdir    = dht_fsyncdir,
-        .symlink     = dht_symlink,
-        .unlink      = dht_unlink,
-        .link        = dht_link,
-        .mkdir       = dht_mkdir,
-        .rmdir       = dht_rmdir,
-        .rename      = dht_rename,
-        .inodelk     = dht_inodelk,
-        .finodelk    = dht_finodelk,
-        .entrylk     = dht_entrylk,
-        .fentrylk    = dht_fentrylk,
-        .xattrop     = dht_xattrop,
-        .fxattrop    = dht_fxattrop,
-        .setattr     = dht_setattr,
+    .lookup = nufa_lookup,
+    .create = nufa_create,
+    .mknod = nufa_mknod,
+
+    .stat = dht_stat,
+    .fstat = dht_fstat,
+    .truncate = dht_truncate,
+    .ftruncate = dht_ftruncate,
+    .access = dht_access,
+    .readlink = dht_readlink,
+    .setxattr = dht_setxattr,
+    .getxattr = dht_getxattr,
+    .removexattr = dht_removexattr,
+    .open = dht_open,
+    .readv = dht_readv,
+    .writev = dht_writev,
+    .flush = dht_flush,
+    .fsync = dht_fsync,
+    .statfs = dht_statfs,
+    .lk = dht_lk,
+    .opendir = dht_opendir,
+    .readdir = dht_readdir,
+    .readdirp = dht_readdirp,
+    .fsyncdir = dht_fsyncdir,
+    .symlink = dht_symlink,
+    .unlink = dht_unlink,
+    .link = dht_link,
+    .mkdir = dht_mkdir,
+    .rmdir = dht_rmdir,
+    .rename = dht_rename,
+    .inodelk = dht_inodelk,
+    .finodelk = dht_finodelk,
+    .entrylk = dht_entrylk,
+    .fentrylk = dht_fentrylk,
+    .xattrop = dht_xattrop,
+    .fxattrop = dht_fxattrop,
+    .setattr = dht_setattr,
 };
 
-
-struct xlator_cbks cbks = {
-        .forget     = dht_forget
-};
+struct xlator_cbks cbks = {.forget = dht_forget};
diff --git a/xlators/cluster/dht/src/switch.c b/xlators/cluster/dht/src/switch.c
index 8b66a09b822..ca9bfce5a8e 100644
--- a/xlators/cluster/dht/src/switch.c
+++ b/xlators/cluster/dht/src/switch.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "dht-common.h"
 #include "dht-mem-types.h"
 
@@ -20,907 +19,853 @@
 extern struct volume_options options[];
 
 struct switch_sched_array {
-        xlator_t *xl;
-        int32_t   eligible;
-        int32_t   considered;
+    xlator_t *xl;
+    int32_t eligible;
+    int32_t considered;
 };
 
 /* Select one of this struct based on the path's pattern match */
 struct switch_struct {
-        struct switch_struct      *next;
-        struct switch_sched_array *array;
-        int32_t                    node_index; /* Index of the node in
-                                                  this pattern. */
-        int32_t                    num_child;  /* Total num of child nodes
-                                                  with this pattern. */
-        char                       path_pattern[256];
+    struct switch_struct *next;
+    struct switch_sched_array *array;
+    int32_t node_index; /* Index of the node in
+                           this pattern. */
+    int32_t num_child;  /* Total num of child nodes
+                           with this pattern. */
+    char path_pattern[256];
 };
 
 /* TODO: all 'TODO's in dht.c holds good */
 /* This function should return child node as '*:subvolumes' is inserterd */
 
 static int32_t
-gf_switch_valid_child (xlator_t *this, const char *child)
+gf_switch_valid_child(xlator_t *this, const char *child)
 {
-        xlator_list_t *children = NULL;
-        int32_t        ret = 0;
-
-        children = this->children;
-        while (children) {
-                if (!strcmp (child, children->xlator->name)) {
-                        ret = 1;
-                        break;
-                }
-                children = children->next;
+    xlator_list_t *children = NULL;
+    int32_t ret = 0;
+
+    children = this->children;
+    while (children) {
+        if (!strcmp(child, children->xlator->name)) {
+            ret = 1;
+            break;
         }
+        children = children->next;
+    }
 
-        return ret;
+    return ret;
 }
 
 static xlator_t *
-get_switch_matching_subvol (const char *path, dht_conf_t *conf,
-                            xlator_t *hashed_subvol)
+get_switch_matching_subvol(const char *path, dht_conf_t *conf,
+                           xlator_t *hashed_subvol)
 {
-        struct switch_struct *cond      = NULL;
-        struct switch_struct *trav      = NULL;
-        char                 *pathname  = NULL;
-        int                   idx       = 0;
-        xlator_t             *subvol    = NULL;
-
-        cond = conf->private;
-        subvol = hashed_subvol;
-        if (!cond)
-                goto out;
-
-        pathname = gf_strdup (path);
-        if (!pathname)
-                goto out;
-
-        trav = cond;
-        while (trav) {
-                if (fnmatch (trav->path_pattern,
-                             pathname, FNM_NOESCAPE) == 0) {
-                        for (idx = 0; idx < trav->num_child; idx++) {
-                                if (trav->array[idx].xl == hashed_subvol)
-                                        goto out;
-                        }
-                        idx = trav->node_index++;
-                        trav->node_index %= trav->num_child;
-                        subvol = trav->array[idx].xl;
-                        goto out;
-                }
-                trav = trav->next;
+    struct switch_struct *cond = NULL;
+    struct switch_struct *trav = NULL;
+    char *pathname = NULL;
+    int idx = 0;
+    xlator_t *subvol = NULL;
+
+    cond = conf->private;
+    subvol = hashed_subvol;
+    if (!cond)
+        goto out;
+
+    pathname = gf_strdup(path);
+    if (!pathname)
+        goto out;
+
+    trav = cond;
+    while (trav) {
+        if (fnmatch(trav->path_pattern, pathname, FNM_NOESCAPE) == 0) {
+            for (idx = 0; idx < trav->num_child; idx++) {
+                if (trav->array[idx].xl == hashed_subvol)
+                    goto out;
+            }
+            idx = trav->node_index++;
+            trav->node_index %= trav->num_child;
+            subvol = trav->array[idx].xl;
+            goto out;
         }
+        trav = trav->next;
+    }
 out:
-        GF_FREE (pathname);
+    GF_FREE(pathname);
 
-        return subvol;
+    return subvol;
 }
 
-
 int
-switch_local_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno,
-                         inode_t *inode, struct iatt *stbuf, dict_t *xattr,
-                         struct iatt *postparent)
+switch_local_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int op_ret, int op_errno, inode_t *inode,
+                        struct iatt *stbuf, dict_t *xattr,
+                        struct iatt *postparent)
 {
-        xlator_t     *subvol      = NULL;
-        char          is_linkfile = 0;
-        char          is_dir      = 0;
-        dht_conf_t   *conf        = NULL;
-        dht_local_t  *local       = NULL;
-        loc_t        *loc         = NULL;
-        int           i           = 0;
-        xlator_t     *prev        = NULL;
-        int           call_cnt    = 0;
-        int           ret         = 0;
-
-        conf  = this->private;
-
-        prev  = cookie;
-        local = frame->local;
-        loc   = &local->loc;
-
-        if (ENTRY_MISSING (op_ret, op_errno)) {
-                if (conf->search_unhashed) {
-                        local->op_errno = ENOENT;
-                        dht_lookup_everywhere (frame, this, loc);
-                        return 0;
-                }
+    xlator_t *subvol = NULL;
+    char is_linkfile = 0;
+    char is_dir = 0;
+    dht_conf_t *conf = NULL;
+    dht_local_t *local = NULL;
+    loc_t *loc = NULL;
+    int i = 0;
+    xlator_t *prev = NULL;
+    int call_cnt = 0;
+    int ret = 0;
+
+    conf = this->private;
+
+    prev = cookie;
+    local = frame->local;
+    loc = &local->loc;
+
+    if (ENTRY_MISSING(op_ret, op_errno)) {
+        if (conf->search_unhashed) {
+            local->op_errno = ENOENT;
+            dht_lookup_everywhere(frame, this, loc);
+            return 0;
         }
-
-        if (op_ret == -1)
-                goto out;
-
-        is_linkfile = check_is_linkfile (inode, stbuf, xattr,
-                                         conf->link_xattr_name);
-        is_dir      = check_is_dir (inode, stbuf, xattr);
-
-        if (!is_dir && !is_linkfile) {
-                /* non-directory and not a linkfile */
-
-                ret = dht_layout_preset (this, prev, inode);
-                if (ret < 0) {
-                        gf_msg_debug (this->name, 0,
-                                      "could not set pre-set layout "
-                                      "for subvol %s",
-                                      prev->name);
-                        op_ret   = -1;
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                goto out;
+    }
+
+    if (op_ret == -1)
+        goto out;
+
+    is_linkfile = check_is_linkfile(inode, stbuf, xattr, conf->link_xattr_name);
+    is_dir = check_is_dir(inode, stbuf, xattr);
+
+    if (!is_dir && !is_linkfile) {
+        /* non-directory and not a linkfile */
+
+        ret = dht_layout_preset(this, prev, inode);
+        if (ret < 0) {
+            gf_msg_debug(this->name, 0,
+                         "could not set pre-set layout "
+                         "for subvol %s",
+                         prev->name);
+            op_ret = -1;
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (is_dir) {
-                call_cnt        = conf->subvolume_cnt;
-                local->call_cnt = call_cnt;
+        goto out;
+    }
 
-                local->inode = inode_ref (inode);
-                local->xattr = dict_ref (xattr);
+    if (is_dir) {
+        call_cnt = conf->subvolume_cnt;
+        local->call_cnt = call_cnt;
 
-                local->op_ret = 0;
-                local->op_errno = 0;
+        local->inode = inode_ref(inode);
+        local->xattr = dict_ref(xattr);
 
-                local->layout = dht_layout_new (this, conf->subvolume_cnt);
-                if (!local->layout) {
-                        op_ret   = -1;
-                        op_errno = ENOMEM;
-                        gf_msg_debug (this->name, 0,
-                                      "memory allocation failed :(");
-                        goto err;
-                }
+        local->op_ret = 0;
+        local->op_errno = 0;
 
-                for (i = 0; i < call_cnt; i++) {
-                        STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i],
-                                           conf->subvolumes[i]->fops->lookup,
-                                           &local->loc, local->xattr_req);
-                }
+        local->layout = dht_layout_new(this, conf->subvolume_cnt);
+        if (!local->layout) {
+            op_ret = -1;
+            op_errno = ENOMEM;
+            gf_msg_debug(this->name, 0, "memory allocation failed :(");
+            goto err;
         }
 
-        if (is_linkfile) {
-                subvol = dht_linkfile_subvol (this, inode, stbuf, xattr);
+        for (i = 0; i < call_cnt; i++) {
+            STACK_WIND_COOKIE(frame, dht_lookup_dir_cbk, conf->subvolumes[i],
+                              conf->subvolumes[i],
+                              conf->subvolumes[i]->fops->lookup, &local->loc,
+                              local->xattr_req);
+        }
+    }
 
-                if (!subvol) {
-                        gf_msg_debug (this->name, 0,
-                                      "linkfile has no link subvolume.path=%s",
-                                      loc->path);
-                        dht_lookup_everywhere (frame, this, loc);
-                        return 0;
-                }
+    if (is_linkfile) {
+        subvol = dht_linkfile_subvol(this, inode, stbuf, xattr);
 
-                STACK_WIND_COOKIE (frame, dht_lookup_linkfile_cbk, subvol,
-                                   subvol, subvol->fops->lookup,
-                                   &local->loc, local->xattr_req);
+        if (!subvol) {
+            gf_msg_debug(this->name, 0,
+                         "linkfile has no link subvolume.path=%s", loc->path);
+            dht_lookup_everywhere(frame, this, loc);
+            return 0;
         }
 
-        return 0;
+        STACK_WIND_COOKIE(frame, dht_lookup_linkfile_cbk, subvol, subvol,
+                          subvol->fops->lookup, &local->loc, local->xattr_req);
+    }
+
+    return 0;
 
 out:
-        if (!local->hashed_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              local->loc.path);
-                local->op_errno = ENOENT;
-                dht_lookup_everywhere (frame, this, loc);
-                return 0;
-        }
+    if (!local->hashed_subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     local->loc.path);
+        local->op_errno = ENOENT;
+        dht_lookup_everywhere(frame, this, loc);
+        return 0;
+    }
 
-        STACK_WIND_COOKIE (frame, dht_lookup_cbk, local->hashed_subvol,
-                           local->hashed_subvol,
-                           local->hashed_subvol->fops->lookup,
-                           &local->loc, local->xattr_req);
+    STACK_WIND_COOKIE(frame, dht_lookup_cbk, local->hashed_subvol,
+                      local->hashed_subvol, local->hashed_subvol->fops->lookup,
+                      &local->loc, local->xattr_req);
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (lookup, frame, op_ret, op_errno,
-                          inode, stbuf, xattr, NULL);
-        return 0;
+    DHT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, xattr,
+                     NULL);
+    return 0;
 }
 
 int
-switch_lookup (call_frame_t *frame, xlator_t *this,
-               loc_t *loc, dict_t *xattr_req)
+switch_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc,
+              dict_t *xattr_req)
 {
-        xlator_t     *hashed_subvol = NULL;
-        xlator_t     *cached_subvol = NULL;
-        xlator_t     *subvol = NULL;
-        dht_local_t  *local  = NULL;
-        dht_conf_t   *conf = NULL;
-        int           ret    = -1;
-        int           op_errno = -1;
-        dht_layout_t *layout = NULL;
-        int           i = 0;
-        int           call_cnt = 0;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_LOOKUP);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    xlator_t *hashed_subvol = NULL;
+    xlator_t *cached_subvol = NULL;
+    xlator_t *subvol = NULL;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    int op_errno = -1;
+    dht_layout_t *layout = NULL;
+    int i = 0;
+    int call_cnt = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_LOOKUP);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (xattr_req) {
+        local->xattr_req = dict_ref(xattr_req);
+    } else {
+        local->xattr_req = dict_new();
+    }
+
+    hashed_subvol = dht_subvol_get_hashed(this, &local->loc);
+    cached_subvol = local->cached_subvol;
+
+    local->hashed_subvol = hashed_subvol;
+
+    if (is_revalidate(loc)) {
+        layout = local->layout;
+        if (!layout) {
+            gf_msg_debug(this->name, 0,
+                         "revalidate lookup without cache. path=%s", loc->path);
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (xattr_req) {
-                local->xattr_req = dict_ref (xattr_req);
-        } else {
-                local->xattr_req = dict_new ();
+        if (layout->gen && (layout->gen < conf->gen)) {
+            gf_msg_debug(this->name, 0, "incomplete layout failure for path=%s",
+                         loc->path);
+            dht_layout_unref(this, local->layout);
+            goto do_fresh_lookup;
         }
 
-        hashed_subvol = dht_subvol_get_hashed (this, &local->loc);
-        cached_subvol = local->cached_subvol;
+        local->inode = inode_ref(loc->inode);
 
-        local->hashed_subvol = hashed_subvol;
+        local->call_cnt = layout->cnt;
+        call_cnt = local->call_cnt;
 
-        if (is_revalidate (loc)) {
-                layout = local->layout;
-                if (!layout) {
-                        gf_msg_debug(this->name, 0,
-                                     "revalidate lookup without cache. path=%s",
-                                     loc->path);
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                if (layout->gen && (layout->gen < conf->gen)) {
-                        gf_msg_debug (this->name, 0,
-                                      "incomplete layout failure for path=%s",
-                                      loc->path);
-                        dht_layout_unref (this, local->layout);
-                        goto do_fresh_lookup;
-                }
-
-                local->inode    = inode_ref (loc->inode);
-
-                local->call_cnt = layout->cnt;
-                call_cnt = local->call_cnt;
+        /* NOTE: we don't require 'trusted.glusterfs.dht.linkto'
+         * attribute, revalidates directly go to the cached-subvolume.
+         */
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret < 0)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "failed to set dict value for %s", conf->xattr_name);
 
-                /* NOTE: we don't require 'trusted.glusterfs.dht.linkto'
-                 * attribute, revalidates directly go to the cached-subvolume.
-                 */
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret < 0)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "failed to set dict value for %s",
-                                conf->xattr_name);
+        for (i = 0; i < layout->cnt; i++) {
+            subvol = layout->list[i].xlator;
 
-                for (i = 0; i < layout->cnt; i++) {
-                        subvol = layout->list[i].xlator;
+            STACK_WIND_COOKIE(frame, dht_revalidate_cbk, subvol, subvol,
+                              subvol->fops->lookup, loc, local->xattr_req);
 
-                        STACK_WIND_COOKIE (frame, dht_revalidate_cbk, subvol,
-                                           subvol, subvol->fops->lookup,
-                                           loc, local->xattr_req);
+            if (!--call_cnt)
+                break;
+        }
+    } else {
+    do_fresh_lookup:
+        ret = dict_set_uint32(local->xattr_req, conf->xattr_name, 4 * 4);
+        if (ret < 0)
+            gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                   "failed to set dict value for %s", conf->xattr_name);
+
+        ret = dict_set_uint32(local->xattr_req, conf->link_xattr_name, 256);
+        if (ret < 0)
+            gf_msg(this->name, GF_LOG_WARNING, EINVAL, DHT_MSG_DICT_SET_FAILED,
+                   "failed to set dict value for %s", conf->link_xattr_name);
+
+        if (!hashed_subvol) {
+            gf_msg_debug(this->name, 0,
+                         "no subvolume in layout for path=%s, "
+                         "checking on all the subvols to see if "
+                         "it is a directory",
+                         loc->path);
+            call_cnt = conf->subvolume_cnt;
+            local->call_cnt = call_cnt;
+
+            local->layout = dht_layout_new(this, conf->subvolume_cnt);
+            if (!local->layout) {
+                op_errno = ENOMEM;
+                goto err;
+            }
+
+            for (i = 0; i < call_cnt; i++) {
+                STACK_WIND_COOKIE(frame, dht_lookup_dir_cbk,
+                                  conf->subvolumes[i], conf->subvolumes[i],
+                                  conf->subvolumes[i]->fops->lookup,
+                                  &local->loc, local->xattr_req);
+            }
+            return 0;
+        }
 
-                        if (!--call_cnt)
-                                break;
-                }
+        /*  */
+        cached_subvol = get_switch_matching_subvol(loc->path, conf,
+                                                   hashed_subvol);
+        if (cached_subvol == hashed_subvol) {
+            STACK_WIND_COOKIE(frame, dht_lookup_cbk, hashed_subvol,
+                              hashed_subvol, hashed_subvol->fops->lookup, loc,
+                              local->xattr_req);
         } else {
-        do_fresh_lookup:
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->xattr_name, 4 * 4);
-                if (ret < 0)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "failed to set dict value for %s",
-                                conf->xattr_name);
-
-                ret = dict_set_uint32 (local->xattr_req,
-                                       conf->link_xattr_name, 256);
-                if (ret < 0)
-                        gf_msg (this->name, GF_LOG_WARNING, EINVAL,
-                                DHT_MSG_DICT_SET_FAILED,
-                                "failed to set dict value for %s",
-                                conf->link_xattr_name);
-
-                if (!hashed_subvol) {
-                        gf_msg_debug (this->name, 0,
-                                      "no subvolume in layout for path=%s, "
-                                      "checking on all the subvols to see if "
-                                      "it is a directory", loc->path);
-                        call_cnt        = conf->subvolume_cnt;
-                        local->call_cnt = call_cnt;
-
-                        local->layout = dht_layout_new (this,
-                                                        conf->subvolume_cnt);
-                        if (!local->layout) {
-                                op_errno = ENOMEM;
-                                goto err;
-                        }
-
-                        for (i = 0; i < call_cnt; i++) {
-                                STACK_WIND_COOKIE (frame, dht_lookup_dir_cbk,
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i],
-                                                   conf->subvolumes[i]->fops->lookup,
-                                                   &local->loc, local->xattr_req);
-                        }
-                        return 0;
-                }
-
-                /*  */
-                cached_subvol = get_switch_matching_subvol (loc->path, conf,
-                                                            hashed_subvol);
-                if (cached_subvol == hashed_subvol) {
-                        STACK_WIND_COOKIE (frame, dht_lookup_cbk, hashed_subvol,
-                                           hashed_subvol,
-                                           hashed_subvol->fops->lookup,
-                                           loc, local->xattr_req);
-                } else {
-                        STACK_WIND_COOKIE (frame, switch_local_lookup_cbk,
-                                           cached_subvol, cached_subvol,
-                                           cached_subvol->fops->lookup,
-                                           loc, local->xattr_req);
-                }
+            STACK_WIND_COOKIE(frame, switch_local_lookup_cbk, cached_subvol,
+                              cached_subvol, cached_subvol->fops->lookup, loc,
+                              local->xattr_req);
         }
+    }
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (lookup, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL);
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-switch_create_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int op_ret, int op_errno,
-                                   inode_t *inode, struct iatt *stbuf,
-                                   struct iatt *preparent,
-                                   struct iatt *postparent, dict_t *xdata)
+switch_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int op_ret, int op_errno,
+                                  inode_t *inode, struct iatt *stbuf,
+                                  struct iatt *preparent,
+                                  struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        if (op_ret == -1)
-                goto err;
+    if (op_ret == -1)
+        goto err;
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, local->cached_subvol,
-                           local->cached_subvol, local->cached_subvol->fops->create,
-                           &local->loc, local->flags, local->mode, local->umask,
-                           local->fd, local->params);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, local->cached_subvol,
+                      local->cached_subvol, local->cached_subvol->fops->create,
+                      &local->loc, local->flags, local->mode, local->umask,
+                      local->fd, local->params);
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (create, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 int
-switch_create (call_frame_t *frame, xlator_t *this,
-               loc_t *loc, int32_t flags, mode_t mode,
-               mode_t umask, fd_t *fd, dict_t *params)
+switch_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+              mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
 {
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf  = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *avail_subvol = NULL;
-        int          op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf  = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_CREATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        avail_subvol = get_switch_matching_subvol (loc->path, conf, subvol);
-        if (dht_is_subvol_filled (this, avail_subvol)) {
-                avail_subvol =
-                        dht_free_disk_available_subvol (this, avail_subvol,
-                                                        local);
-        }
-
-        if (subvol != avail_subvol) {
-                /* create a link file instead of actual file */
-                local->mode = mode;
-                local->flags = flags;
-                local->umask = umask;
-                local->cached_subvol = avail_subvol;
-                dht_linkfile_create (frame, switch_create_linkfile_create_cbk,
-                                     this, avail_subvol, subvol, loc);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *avail_subvol = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    avail_subvol = get_switch_matching_subvol(loc->path, conf, subvol);
+    if (dht_is_subvol_filled(this, avail_subvol)) {
+        avail_subvol = dht_free_disk_available_subvol(this, avail_subvol,
+                                                      local);
+    }
+
+    if (subvol != avail_subvol) {
+        /* create a link file instead of actual file */
+        local->mode = mode;
+        local->flags = flags;
+        local->umask = umask;
+        local->cached_subvol = avail_subvol;
+        dht_linkfile_create(frame, switch_create_linkfile_create_cbk, this,
+                            avail_subvol, subvol, loc);
+        return 0;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_create_cbk, subvol, subvol,
-                           subvol->fops->create, loc, flags, mode, umask, fd,
-                           params);
+    STACK_WIND_COOKIE(frame, dht_create_cbk, subvol, subvol,
+                      subvol->fops->create, loc, flags, mode, umask, fd,
+                      params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (create, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-switch_mknod_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, inode_t *inode,
-                           struct iatt *stbuf, struct iatt *preparent,
-                           struct iatt *postparent, dict_t *xdata)
+switch_mknod_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int op_ret, int op_errno, inode_t *inode,
+                          struct iatt *stbuf, struct iatt *preparent,
+                          struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
+    dht_local_t *local = NULL;
 
-        local = frame->local;
-        if (!local || !local->cached_subvol) {
-                op_errno = EINVAL;
-                op_ret = -1;
-                goto err;
-        }
+    local = frame->local;
+    if (!local || !local->cached_subvol) {
+        op_errno = EINVAL;
+        op_ret = -1;
+        goto err;
+    }
 
-        if (op_ret >= 0) {
-                STACK_WIND_COOKIE (frame, dht_newfile_cbk,
-                            (void *)local->cached_subvol, local->cached_subvol,
-                            local->cached_subvol->fops->mknod,
-                            &local->loc, local->mode, local->rdev,
-                            local->umask, local->params);
+    if (op_ret >= 0) {
+        STACK_WIND_COOKIE(
+            frame, dht_newfile_cbk, (void *)local->cached_subvol,
+            local->cached_subvol, local->cached_subvol->fops->mknod,
+            &local->loc, local->mode, local->rdev, local->umask, local->params);
 
-                return 0;
-        }
-err:
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno,
-                          inode, stbuf, preparent, postparent, xdata);
         return 0;
+    }
+err:
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, xdata);
+    return 0;
 }
 
-
 int
-switch_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-              dev_t rdev, mode_t umask, dict_t *params)
+switch_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+             dev_t rdev, mode_t umask, dict_t *params)
 {
-        dht_local_t *local = NULL;
-        dht_conf_t  *conf  = NULL;
-        xlator_t    *subvol = NULL;
-        xlator_t    *avail_subvol = NULL;
-        int          op_errno = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf  = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_MKNOD);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        subvol = dht_subvol_get_hashed (this, loc);
-        if (!subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no subvolume in layout for path=%s",
-                              loc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        /* Consider the disksize in consideration */
-        avail_subvol = get_switch_matching_subvol (loc->path, conf, subvol);
-        if (dht_is_subvol_filled (this, avail_subvol)) {
-                avail_subvol =
-                        dht_free_disk_available_subvol (this, avail_subvol,
-                                                        local);
-        }
-
-        if (avail_subvol != subvol) {
-                /* Create linkfile first */
-
-                local->params = dict_ref (params);
-                local->mode = mode;
-                local->umask = umask;
-                local->rdev = rdev;
-                local->cached_subvol = avail_subvol;
-
-                dht_linkfile_create (frame, switch_mknod_linkfile_cbk,
-                                     this, avail_subvol, subvol, loc);
-                return 0;
-        }
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *subvol = NULL;
+    xlator_t *avail_subvol = NULL;
+    int op_errno = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_MKNOD);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    subvol = dht_subvol_get_hashed(this, loc);
+    if (!subvol) {
+        gf_msg_debug(this->name, 0, "no subvolume in layout for path=%s",
+                     loc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    /* Consider the disksize in consideration */
+    avail_subvol = get_switch_matching_subvol(loc->path, conf, subvol);
+    if (dht_is_subvol_filled(this, avail_subvol)) {
+        avail_subvol = dht_free_disk_available_subvol(this, avail_subvol,
+                                                      local);
+    }
+
+    if (avail_subvol != subvol) {
+        /* Create linkfile first */
+
+        local->params = dict_ref(params);
+        local->mode = mode;
+        local->umask = umask;
+        local->rdev = rdev;
+        local->cached_subvol = avail_subvol;
+
+        dht_linkfile_create(frame, switch_mknod_linkfile_cbk, this,
+                            avail_subvol, subvol, loc);
+        return 0;
+    }
 
-        gf_msg_trace (this->name, 0,
-                      "creating %s on %s", loc->path, subvol->name);
+    gf_msg_trace(this->name, 0, "creating %s on %s", loc->path, subvol->name);
 
-        STACK_WIND_COOKIE (frame, dht_newfile_cbk, (void *)subvol, subvol,
-                           subvol->fops->mknod, loc, mode, rdev, umask,
-                           params);
+    STACK_WIND_COOKIE(frame, dht_newfile_cbk, (void *)subvol, subvol,
+                      subvol->fops->mknod, loc, mode, rdev, umask, params);
 
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (mknod, frame, -1, op_errno,
-                          NULL, NULL, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 void
-switch_fini (xlator_t *this)
+switch_fini(xlator_t *this)
 {
-        dht_conf_t           *conf = NULL;
-        struct switch_struct *trav = NULL;
-        struct switch_struct *prev = NULL;
-
-        conf = this->private;
-
-        if (conf) {
-                trav = (struct switch_struct *)conf->private;
-                conf->private = NULL;
-                while (trav) {
-                        GF_FREE (trav->array);
-                        prev = trav;
-                        trav = trav->next;
-                        GF_FREE (prev);
-                }
+    dht_conf_t *conf = NULL;
+    struct switch_struct *trav = NULL;
+    struct switch_struct *prev = NULL;
+
+    conf = this->private;
+
+    if (conf) {
+        trav = (struct switch_struct *)conf->private;
+        conf->private = NULL;
+        while (trav) {
+            GF_FREE(trav->array);
+            prev = trav;
+            trav = trav->next;
+            GF_FREE(prev);
         }
+    }
 
-        dht_fini(this);
+    dht_fini(this);
 }
 
 int
-set_switch_pattern (xlator_t *this, dht_conf_t *conf,
-                    const char *pattern_str)
+set_switch_pattern(xlator_t *this, dht_conf_t *conf, const char *pattern_str)
 {
-        int                         flag = 0;
-        int                         idx = 0;
-        int                         index = 0;
-        int                         child_count = 0;
-        char                       *tmp = NULL;
-        char                       *tmp1 = NULL;
-        char                       *child = NULL;
-        char                       *tmp_str = NULL;
-        char                       *tmp_str1 = NULL;
-        char                       *dup_str = NULL;
-        char                       *dup_childs = NULL;
-        char                       *switch_str = NULL;
-        char                       *pattern = NULL;
-        char                       *childs = NULL;
-        char                       *option_string = NULL;
-        size_t                      pattern_length;
-        struct switch_struct       *switch_buf = NULL;
-        struct switch_struct       *switch_opt = NULL;
-        struct switch_struct       *trav = NULL;
-        struct switch_sched_array  *switch_buf_array = NULL;
-        xlator_list_t              *trav_xl = NULL;
-
-        trav_xl = this->children;
-        while (trav_xl) {
-                index++;
-                trav_xl = trav_xl->next;
+    int flag = 0;
+    int idx = 0;
+    int index = 0;
+    int child_count = 0;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *child = NULL;
+    char *tmp_str = NULL;
+    char *tmp_str1 = NULL;
+    char *dup_str = NULL;
+    char *dup_childs = NULL;
+    char *switch_str = NULL;
+    char *pattern = NULL;
+    char *childs = NULL;
+    char *option_string = NULL;
+    size_t pattern_length;
+    struct switch_struct *switch_buf = NULL;
+    struct switch_struct *switch_opt = NULL;
+    struct switch_struct *trav = NULL;
+    struct switch_sched_array *switch_buf_array = NULL;
+    xlator_list_t *trav_xl = NULL;
+
+    trav_xl = this->children;
+    while (trav_xl) {
+        index++;
+        trav_xl = trav_xl->next;
+    }
+    child_count = index;
+    switch_buf_array = GF_CALLOC((index + 1), sizeof(struct switch_sched_array),
+                                 gf_switch_mt_switch_sched_array);
+    if (!switch_buf_array)
+        goto err;
+
+    trav_xl = this->children;
+    index = 0;
+
+    while (trav_xl) {
+        switch_buf_array[index].xl = trav_xl->xlator;
+        switch_buf_array[index].eligible = 1;
+        trav_xl = trav_xl->next;
+        index++;
+    }
+
+    /*  *jpg:child1,child2;*mpg:child3;*:child4,child5,child6 */
+
+    /* Get the pattern for considering switch case.
+       "option block-size *avi:10MB" etc */
+    option_string = gf_strdup(pattern_str);
+    switch_str = strtok_r(option_string, ";", &tmp_str);
+    while (switch_str) {
+        dup_str = gf_strdup(switch_str);
+        switch_opt = GF_CALLOC(1, sizeof(struct switch_struct),
+                               gf_switch_mt_switch_struct);
+        if (!switch_opt) {
+            GF_FREE(dup_str);
+            goto err;
         }
-        child_count = index;
-        switch_buf_array = GF_CALLOC ((index + 1),
-                                      sizeof (struct switch_sched_array),
-                                      gf_switch_mt_switch_sched_array);
-        if (!switch_buf_array)
-                goto err;
-
-        trav_xl = this->children;
-        index = 0;
 
-        while (trav_xl) {
-                switch_buf_array[index].xl = trav_xl->xlator;
-                switch_buf_array[index].eligible = 1;
-                trav_xl = trav_xl->next;
-                index++;
+        pattern = strtok_r(dup_str, ":", &tmp_str1);
+        childs = strtok_r(NULL, ":", &tmp_str1);
+        if (strncmp(pattern, "*", 2) == 0) {
+            gf_msg("switch", GF_LOG_INFO, 0, DHT_MSG_SWITCH_PATTERN_INFO,
+                   "'*' pattern will be taken by default "
+                   "for all the unconfigured child nodes,"
+                   " hence neglecting current option");
+            switch_str = strtok_r(NULL, ";", &tmp_str);
+            GF_FREE(switch_opt);
+            switch_opt = NULL;
+            GF_FREE(dup_str);
+            continue;
         }
-
-        /*  *jpg:child1,child2;*mpg:child3;*:child4,child5,child6 */
-
-        /* Get the pattern for considering switch case.
-           "option block-size *avi:10MB" etc */
-        option_string = gf_strdup (pattern_str);
-        switch_str = strtok_r (option_string, ";", &tmp_str);
-        while (switch_str) {
-                dup_str = gf_strdup (switch_str);
-                switch_opt = GF_CALLOC (1, sizeof (struct switch_struct),
-                                        gf_switch_mt_switch_struct);
-                if (!switch_opt) {
-                        GF_FREE (dup_str);
-                        goto err;
-                }
-
-                pattern = strtok_r (dup_str, ":", &tmp_str1);
-                childs = strtok_r (NULL, ":", &tmp_str1);
-                if (strncmp (pattern, "*", 2) == 0) {
-                        gf_msg ("switch", GF_LOG_INFO, 0,
-                                DHT_MSG_SWITCH_PATTERN_INFO,
-                                "'*' pattern will be taken by default "
-                                "for all the unconfigured child nodes,"
-                                " hence neglecting current option");
-                        switch_str = strtok_r (NULL, ";", &tmp_str);
-                        GF_FREE (switch_opt);
-                        switch_opt = NULL;
-                        GF_FREE (dup_str);
-                        continue;
-                }
-                GF_FREE (dup_str);
-
-                pattern_length = strlen (pattern);
-                if (pattern_length >= (sizeof (switch_opt->path_pattern))) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_SET_SWITCH_PATTERN_ERROR,
-                                "Pattern (%s) too long", pattern);
-                        goto err;
-                }
-                memcpy (switch_opt->path_pattern, pattern, pattern_length);
-                switch_opt->path_pattern[pattern_length] = '\0';
-
-                if (childs) {
-                        dup_childs = gf_strdup (childs);
-                        child = strtok_r (dup_childs, ",", &tmp);
-                        while (child) {
-                                if (gf_switch_valid_child (this, child)) {
-                                        idx++;
-                                        child = strtok_r (NULL, ",", &tmp);
-                                } else {
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_SUBVOL_ERROR,
-                                                "%s is not a subvolume of %s. "
-                                                "pattern can only be scheduled "
-                                                "only to a subvolume of %s",
-                                                child, this->name, this->name);
-                                        GF_FREE (dup_childs);
-                                        goto err;
-                                }
-                        }
-                        GF_FREE (dup_childs);
-                        child = strtok_r (childs, ",", &tmp1);
-                        switch_opt->num_child = idx;
-                        switch_opt->array = GF_CALLOC (1, (idx *
-                                                           sizeof (struct switch_sched_array)),
-                                                       gf_switch_mt_switch_sched_array);
-                        if (!switch_opt->array)
-                                goto err;
-                        idx = 0;
-                        while (child) {
-                                for (index = 0; index < child_count; index++) {
-                                        if (strcmp (switch_buf_array[index].xl->name,
-                                                    child) == 0) {
-                                                gf_msg_debug ("switch", 0,
-                                                              "'%s' pattern will be "
-                                                              "scheduled to \"%s\"",
-                                                              switch_opt->path_pattern, child);
-                                                /*
-                                                  if (switch_buf_array[index-1].considered) {
-                                                  gf_msg_debug ("switch", 0,
-                                                  "ambiguity found, exiting");
-                                                  return -1;
-                                                  }
-                                                */
-                                                switch_opt->array[idx].xl = switch_buf_array[index].xl;
-                                                switch_buf_array[index].considered = 1;
-                                                idx++;
-                                                break;
-                                        }
-                                }
-                                child = strtok_r (NULL, ",", &tmp1);
-                        }
+        GF_FREE(dup_str);
+
+        pattern_length = strlen(pattern);
+        if (pattern_length >= (sizeof(switch_opt->path_pattern))) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_SET_SWITCH_PATTERN_ERROR, "Pattern (%s) too long",
+                   pattern);
+            goto err;
+        }
+        memcpy(switch_opt->path_pattern, pattern, pattern_length);
+        switch_opt->path_pattern[pattern_length] = '\0';
+
+        if (childs) {
+            dup_childs = gf_strdup(childs);
+            child = strtok_r(dup_childs, ",", &tmp);
+            while (child) {
+                if (gf_switch_valid_child(this, child)) {
+                    idx++;
+                    child = strtok_r(NULL, ",", &tmp);
                 } else {
-                        /* error */
-                        gf_msg ("switch", GF_LOG_ERROR, 0,
-                                DHT_MSG_SET_SWITCH_PATTERN_ERROR,
-                                "Check \"scheduler.switch.case\" "
-                                "option in unify volume. Exiting");
-                        goto err;
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_SUBVOL_ERROR,
+                           "%s is not a subvolume of %s. "
+                           "pattern can only be scheduled "
+                           "only to a subvolume of %s",
+                           child, this->name, this->name);
+                    GF_FREE(dup_childs);
+                    goto err;
                 }
-
-                /* Link it to the main structure */
-                if (switch_buf) {
-                        /* there are already few entries */
-                        trav = switch_buf;
-                        while (trav->next)
-                                trav = trav->next;
-                        trav->next = switch_opt;
-                } else {
-                        /* First entry */
-                        switch_buf = switch_opt;
+            }
+            GF_FREE(dup_childs);
+            child = strtok_r(childs, ",", &tmp1);
+            switch_opt->num_child = idx;
+            switch_opt->array = GF_CALLOC(
+                1, (idx * sizeof(struct switch_sched_array)),
+                gf_switch_mt_switch_sched_array);
+            if (!switch_opt->array)
+                goto err;
+            idx = 0;
+            while (child) {
+                for (index = 0; index < child_count; index++) {
+                    if (strcmp(switch_buf_array[index].xl->name, child) == 0) {
+                        gf_msg_debug("switch", 0,
+                                     "'%s' pattern will be "
+                                     "scheduled to \"%s\"",
+                                     switch_opt->path_pattern, child);
+                        /*
+                          if (switch_buf_array[index-1].considered) {
+                          gf_msg_debug ("switch", 0,
+                          "ambiguity found, exiting");
+                          return -1;
+                          }
+                        */
+                        switch_opt->array[idx].xl = switch_buf_array[index].xl;
+                        switch_buf_array[index].considered = 1;
+                        idx++;
+                        break;
+                    }
                 }
-                switch_opt = NULL;
-                switch_str = strtok_r (NULL, ";", &tmp_str);
+                child = strtok_r(NULL, ",", &tmp1);
+            }
+        } else {
+            /* error */
+            gf_msg("switch", GF_LOG_ERROR, 0, DHT_MSG_SET_SWITCH_PATTERN_ERROR,
+                   "Check \"scheduler.switch.case\" "
+                   "option in unify volume. Exiting");
+            goto err;
         }
 
-        /* Now, all the pattern based considerations done, so for all the
-         * remaining pattern, '*' to all the remaining child nodes
-         */
-        {
-                for (index=0; index < child_count; index++) {
-                        /* check for considered flag */
-                        if (switch_buf_array[index].considered)
-                                continue;
-                        flag++;
-                }
-                if (!flag) {
-                        gf_msg ("switch", GF_LOG_ERROR, 0,
-                                DHT_MSG_SET_SWITCH_PATTERN_ERROR,
-                                "No nodes left for pattern '*'. Exiting");
-                        goto err;
-                }
-                switch_opt = GF_CALLOC (1, sizeof (struct switch_struct),
-                                        gf_switch_mt_switch_struct);
-                if (!switch_opt)
-                        goto err;
-
-                /* Add the '*' pattern to the array */
-                memcpy (switch_opt->path_pattern, "*", 2);
-                switch_opt->num_child = flag;
-                switch_opt->array =
-                        GF_CALLOC (1,
-                                   flag * sizeof (struct switch_sched_array),
-                                   gf_switch_mt_switch_sched_array);
-                if (!switch_opt->array)
-                        goto err;
-                flag = 0;
-                for (index=0; index < child_count; index++) {
-                        /* check for considered flag */
-                        if (switch_buf_array[index].considered)
-                                continue;
-                        gf_msg_debug ("switch", 0, "'%s'"
-                                      " pattern will be scheduled to \"%s\"",
-                                      switch_opt->path_pattern,
-                                      switch_buf_array[index].xl->name);
-
-                        switch_opt->array[flag].xl =
-                                switch_buf_array[index].xl;
-                        switch_buf_array[index].considered = 1;
-                        flag++;
-                }
-                if (switch_buf) {
-                        /* there are already few entries */
-                        trav = switch_buf;
-                        while (trav->next)
-                                trav = trav->next;
-                        trav->next = switch_opt;
-                } else {
-                        /* First entry */
-                        switch_buf = switch_opt;
-                }
-                switch_opt = NULL;
+        /* Link it to the main structure */
+        if (switch_buf) {
+            /* there are already few entries */
+            trav = switch_buf;
+            while (trav->next)
+                trav = trav->next;
+            trav->next = switch_opt;
+        } else {
+            /* First entry */
+            switch_buf = switch_opt;
+        }
+        switch_opt = NULL;
+        switch_str = strtok_r(NULL, ";", &tmp_str);
+    }
+
+    /* Now, all the pattern based considerations done, so for all the
+     * remaining pattern, '*' to all the remaining child nodes
+     */
+    {
+        for (index = 0; index < child_count; index++) {
+            /* check for considered flag */
+            if (switch_buf_array[index].considered)
+                continue;
+            flag++;
+        }
+        if (!flag) {
+            gf_msg("switch", GF_LOG_ERROR, 0, DHT_MSG_SET_SWITCH_PATTERN_ERROR,
+                   "No nodes left for pattern '*'. Exiting");
+            goto err;
+        }
+        switch_opt = GF_CALLOC(1, sizeof(struct switch_struct),
+                               gf_switch_mt_switch_struct);
+        if (!switch_opt)
+            goto err;
+
+        /* Add the '*' pattern to the array */
+        memcpy(switch_opt->path_pattern, "*", 2);
+        switch_opt->num_child = flag;
+        switch_opt->array = GF_CALLOC(1,
+                                      flag * sizeof(struct switch_sched_array),
+                                      gf_switch_mt_switch_sched_array);
+        if (!switch_opt->array)
+            goto err;
+        flag = 0;
+        for (index = 0; index < child_count; index++) {
+            /* check for considered flag */
+            if (switch_buf_array[index].considered)
+                continue;
+            gf_msg_debug("switch", 0,
+                         "'%s'"
+                         " pattern will be scheduled to \"%s\"",
+                         switch_opt->path_pattern,
+                         switch_buf_array[index].xl->name);
+
+            switch_opt->array[flag].xl = switch_buf_array[index].xl;
+            switch_buf_array[index].considered = 1;
+            flag++;
+        }
+        if (switch_buf) {
+            /* there are already few entries */
+            trav = switch_buf;
+            while (trav->next)
+                trav = trav->next;
+            trav->next = switch_opt;
+        } else {
+            /* First entry */
+            switch_buf = switch_opt;
         }
-        /* */
-        conf->private = switch_buf;
+        switch_opt = NULL;
+    }
+    /* */
+    conf->private = switch_buf;
 
-        GF_FREE (option_string);
-        return 0;
+    GF_FREE(option_string);
+    return 0;
 err:
-        GF_FREE (switch_buf_array);
-        GF_FREE (switch_opt);
-        GF_FREE (option_string);
+    GF_FREE(switch_buf_array);
+    GF_FREE(switch_opt);
+    GF_FREE(option_string);
 
-        if (switch_buf) {
-                trav = switch_buf;
-                while (trav) {
-                        GF_FREE (trav->array);
-                        switch_opt = trav;
-                        trav = trav->next;
-                        GF_FREE (switch_opt);
-                }
+    if (switch_buf) {
+        trav = switch_buf;
+        while (trav) {
+            GF_FREE(trav->array);
+            switch_opt = trav;
+            trav = trav->next;
+            GF_FREE(switch_opt);
         }
-        return -1;
+    }
+    return -1;
 }
 
-
 int32_t
-switch_init (xlator_t *this)
+switch_init(xlator_t *this)
 {
-        dht_conf_t            *conf = NULL;
-        data_t                *data = NULL;
-        int                    ret = -1;
+    dht_conf_t *conf = NULL;
+    data_t *data = NULL;
+    int ret = -1;
+
+    ret = dht_init(this);
+    if (ret) {
+        return ret;
+    }
+    conf = this->private;
 
-        ret = dht_init(this);
+    data = dict_get(this->options, "pattern.switch.case");
+    if (data) {
+        /* TODO: */
+        ret = set_switch_pattern(this, conf, data->data);
         if (ret) {
-                return ret;
-        }
-        conf = this->private;
-
-        data = dict_get (this->options, "pattern.switch.case");
-        if (data) {
-                /* TODO: */
-                ret = set_switch_pattern (this, conf, data->data);
-                if (ret) {
-                        goto err;
-                }
+            goto err;
         }
+    }
 
-        this->private = conf;
-        return 0;
+    this->private = conf;
+    return 0;
 
 err:
-        dht_fini(this);
-        return -1;
+    dht_fini(this);
+    return -1;
 }
 
-
-class_methods_t class_methods = {
-        .init           = switch_init,
-        .fini           = switch_fini,
-        .reconfigure    = dht_reconfigure,
-        .notify         = dht_notify
-};
-
+class_methods_t class_methods = {.init = switch_init,
+                                 .fini = switch_fini,
+                                 .reconfigure = dht_reconfigure,
+                                 .notify = dht_notify};
 
 struct xlator_fops fops = {
-        .lookup      = switch_lookup,
-        .create      = switch_create,
-        .mknod       = switch_mknod,
-
-        .stat        = dht_stat,
-        .fstat       = dht_fstat,
-        .truncate    = dht_truncate,
-        .ftruncate   = dht_ftruncate,
-        .access      = dht_access,
-        .readlink    = dht_readlink,
-        .setxattr    = dht_setxattr,
-        .getxattr    = dht_getxattr,
-        .removexattr = dht_removexattr,
-        .open        = dht_open,
-        .readv       = dht_readv,
-        .writev      = dht_writev,
-        .flush       = dht_flush,
-        .fsync       = dht_fsync,
-        .statfs      = dht_statfs,
-        .lk          = dht_lk,
-        .opendir     = dht_opendir,
-        .readdir     = dht_readdir,
-        .readdirp    = dht_readdirp,
-        .fsyncdir    = dht_fsyncdir,
-        .symlink     = dht_symlink,
-        .unlink      = dht_unlink,
-        .link        = dht_link,
-        .mkdir       = dht_mkdir,
-        .rmdir       = dht_rmdir,
-        .rename      = dht_rename,
-        .inodelk     = dht_inodelk,
-        .finodelk    = dht_finodelk,
-        .entrylk     = dht_entrylk,
-        .fentrylk    = dht_fentrylk,
-        .xattrop     = dht_xattrop,
-        .fxattrop    = dht_fxattrop,
-        .setattr     = dht_setattr,
+    .lookup = switch_lookup,
+    .create = switch_create,
+    .mknod = switch_mknod,
+
+    .stat = dht_stat,
+    .fstat = dht_fstat,
+    .truncate = dht_truncate,
+    .ftruncate = dht_ftruncate,
+    .access = dht_access,
+    .readlink = dht_readlink,
+    .setxattr = dht_setxattr,
+    .getxattr = dht_getxattr,
+    .removexattr = dht_removexattr,
+    .open = dht_open,
+    .readv = dht_readv,
+    .writev = dht_writev,
+    .flush = dht_flush,
+    .fsync = dht_fsync,
+    .statfs = dht_statfs,
+    .lk = dht_lk,
+    .opendir = dht_opendir,
+    .readdir = dht_readdir,
+    .readdirp = dht_readdirp,
+    .fsyncdir = dht_fsyncdir,
+    .symlink = dht_symlink,
+    .unlink = dht_unlink,
+    .link = dht_link,
+    .mkdir = dht_mkdir,
+    .rmdir = dht_rmdir,
+    .rename = dht_rename,
+    .inodelk = dht_inodelk,
+    .finodelk = dht_finodelk,
+    .entrylk = dht_entrylk,
+    .fentrylk = dht_fentrylk,
+    .xattrop = dht_xattrop,
+    .fxattrop = dht_fxattrop,
+    .setattr = dht_setattr,
 };
 
-
-struct xlator_cbks cbks = {
-        .forget     = dht_forget
-};
+struct xlator_cbks cbks = {.forget = dht_forget};
diff --git a/xlators/cluster/dht/src/tier-common.c b/xlators/cluster/dht/src/tier-common.c
index f08ff4768f0..b86ed673042 100644
--- a/xlators/cluster/dht/src/tier-common.c
+++ b/xlators/cluster/dht/src/tier-common.c
@@ -17,1233 +17,1183 @@
 #include "tier.h"
 
 int
-dht_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno,
-              inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-              struct iatt *postparent, dict_t *xdata);
-
+dht_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+             int op_errno, inode_t *inode, struct iatt *stbuf,
+             struct iatt *preparent, struct iatt *postparent, dict_t *xdata);
 
 int
-tier_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int op_ret, int op_errno,
-              inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
-              struct iatt *postparent, dict_t *xdata)
+tier_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+              int op_errno, inode_t *inode, struct iatt *stbuf,
+              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        loc_t        *oldloc = NULL;
-        loc_t        *newloc = NULL;
+    dht_local_t *local = NULL;
+    loc_t *oldloc = NULL;
+    loc_t *newloc = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        oldloc = &local->loc;
-        newloc = &local->loc2;
+    oldloc = &local->loc;
+    newloc = &local->loc2;
 
-        if (op_ret == -1) {
-                /* No continuation on DHT inode missing errors, as we should
-                 * then have a good stbuf that states P2 happened. We would
-                 * get inode missing if, the file completed migrated between
-                 * the lookup and the link call */
-                goto out;
-        }
+    if (op_ret == -1) {
+        /* No continuation on DHT inode missing errors, as we should
+         * then have a good stbuf that states P2 happened. We would
+         * get inode missing if, the file completed migrated between
+         * the lookup and the link call */
+        goto out;
+    }
 
-        if (local->call_cnt != 1) {
-                goto out;
-        }
+    if (local->call_cnt != 1) {
+        goto out;
+    }
 
-        local->call_cnt = 2;
+    local->call_cnt = 2;
 
-        /* Do this on the hot tier now */
+    /* Do this on the hot tier now */
 
-        STACK_WIND (frame, tier_link_cbk, local->cached_subvol,
-                    local->cached_subvol->fops->link,
-                    oldloc, newloc, xdata);
+    STACK_WIND(frame, tier_link_cbk, local->cached_subvol,
+               local->cached_subvol->fops->link, oldloc, newloc, xdata);
 
-        return 0;
+    return 0;
 
 out:
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        DHT_STACK_UNWIND (link, frame, op_ret, op_errno, inode, stbuf,
-                          preparent, postparent, NULL);
+    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
+                     postparent, NULL);
 
-        return 0;
+    return 0;
 }
 
-
 int
-tier_link (call_frame_t *frame, xlator_t *this,
-          loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+tier_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+          dict_t *xdata)
 {
-        xlator_t    *cached_subvol = NULL;
-        xlator_t    *hashed_subvol = NULL;
-        int          op_errno = -1;
-        int          ret = -1;
-        dht_local_t *local = NULL;
-        dht_conf_t   *conf           = NULL;
-
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (newloc, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, oldloc, NULL, GF_FOP_LINK);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->call_cnt = 1;
-
-        cached_subvol = local->cached_subvol;
-
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", oldloc->path);
-                op_errno = ENOENT;
-                goto err;
-        }
-
-        hashed_subvol = TIER_HASHED_SUBVOL;
-
-        ret = loc_copy (&local->loc2, newloc);
-        if (ret == -1) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        if (hashed_subvol == cached_subvol) {
-                STACK_WIND (frame, dht_link_cbk,
-                            cached_subvol, cached_subvol->fops->link,
-                            oldloc, newloc, xdata);
-                return 0;
-        }
-
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    int op_errno = -1;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, oldloc, NULL, GF_FOP_LINK);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->call_cnt = 1;
+
+    cached_subvol = local->cached_subvol;
+
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     oldloc->path);
+        op_errno = ENOENT;
+        goto err;
+    }
+
+    hashed_subvol = TIER_HASHED_SUBVOL;
+
+    ret = loc_copy(&local->loc2, newloc);
+    if (ret == -1) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (hashed_subvol == cached_subvol) {
+        STACK_WIND(frame, dht_link_cbk, cached_subvol,
+                   cached_subvol->fops->link, oldloc, newloc, xdata);
+        return 0;
+    }
 
-        /* Create hardlinks to both the data file on the hot tier
-           and the linkto file on the cold tier */
+    /* Create hardlinks to both the data file on the hot tier
+       and the linkto file on the cold tier */
 
-        gf_uuid_copy (local->gfid, oldloc->inode->gfid);
+    gf_uuid_copy(local->gfid, oldloc->inode->gfid);
 
-        STACK_WIND (frame, tier_link_cbk,
-                    hashed_subvol, hashed_subvol->fops->link,
-                    oldloc, newloc, xdata);
+    STACK_WIND(frame, tier_link_cbk, hashed_subvol, hashed_subvol->fops->link,
+               oldloc, newloc, xdata);
 
-        return 0;
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                          NULL);
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
-
 int
-tier_create_unlink_stale_linkto_cbk (call_frame_t *frame, void *cookie,
-                                     xlator_t *this, int op_ret, int op_errno,
-                                     struct iatt *preparent,
-                                     struct iatt *postparent, dict_t *xdata)
+tier_create_unlink_stale_linkto_cbk(call_frame_t *frame, void *cookie,
+                                    xlator_t *this, int op_ret, int op_errno,
+                                    struct iatt *preparent,
+                                    struct iatt *postparent, dict_t *xdata)
 {
+    dht_local_t *local = NULL;
 
-        dht_local_t     *local = NULL;
+    local = frame->local;
 
-        local = frame->local;
+    if (local->params) {
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
 
-        if (local->params) {
-                dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
-
-        DHT_STACK_UNWIND (create, frame, -1, local->op_errno,
-                          NULL, NULL, NULL, NULL, NULL, NULL);
+    DHT_STACK_UNWIND(create, frame, -1, local->op_errno, NULL, NULL, NULL, NULL,
+                     NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno,
-                 fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
+tier_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
+                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        xlator_t     *prev           = NULL;
-        int           ret            = -1;
-        dht_local_t  *local          = NULL;
-        xlator_t     *hashed_subvol  = NULL;
-        dht_conf_t   *conf           = NULL;
-
-        local = frame->local;
-        conf  = this->private;
-
-        hashed_subvol = TIER_HASHED_SUBVOL;
-
-        if (!local) {
-                op_ret = -1;
-                op_errno = EINVAL;
+    xlator_t *prev = NULL;
+    int ret = -1;
+    dht_local_t *local = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_conf_t *conf = NULL;
+
+    local = frame->local;
+    conf = this->private;
+
+    hashed_subvol = TIER_HASHED_SUBVOL;
+
+    if (!local) {
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
+
+    if (op_ret == -1) {
+        if (local->linked == _gf_true && local->xattr_req) {
+            local->op_errno = op_errno;
+            local->op_ret = op_ret;
+            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
+                local->xattr_req);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set dictionary value to "
+                       "unlink of migrating file");
                 goto out;
-        }
+            }
 
-        if (op_ret == -1) {
-                if (local->linked == _gf_true && local->xattr_req) {
-                        local->op_errno = op_errno;
-                        local->op_ret = op_ret;
-                        ret = dht_fill_dict_to_avoid_unlink_of_migrating_file
-                              (local->xattr_req);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set dictionary value to "
-                                        "unlink of migrating file");
-                                goto out;
-                        }
-
-                        STACK_WIND (frame,
-                                    tier_create_unlink_stale_linkto_cbk,
-                                    hashed_subvol,
-                                    hashed_subvol->fops->unlink,
-                                    &local->loc, 0, local->xattr_req);
-                        return 0;
-                }
-                goto out;
+            STACK_WIND(frame, tier_create_unlink_stale_linkto_cbk,
+                       hashed_subvol, hashed_subvol->fops->unlink, &local->loc,
+                       0, local->xattr_req);
+            return 0;
         }
+        goto out;
+    }
 
-        prev = cookie;
+    prev = cookie;
 
-        if (local->loc.parent) {
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           preparent, 0);
+    if (local->loc.parent) {
+        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
 
-                dht_inode_ctx_time_update (local->loc.parent, this,
-                                           postparent, 1);
-        }
+        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
+    }
 
-        ret = dht_layout_preset (this, prev, inode);
-        if (ret != 0) {
-                gf_msg_debug (this->name, 0,
-                              "could not set preset layout for subvol %s",
-                              prev->name);
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
+    ret = dht_layout_preset(this, prev, inode);
+    if (ret != 0) {
+        gf_msg_debug(this->name, 0, "could not set preset layout for subvol %s",
+                     prev->name);
+        op_ret = -1;
+        op_errno = EINVAL;
+        goto out;
+    }
 
-        local->op_errno = op_errno;
+    local->op_errno = op_errno;
 
-        if (local->linked == _gf_true) {
-                local->stbuf = *stbuf;
-                dht_linkfile_attr_heal (frame, this);
-        }
+    if (local->linked == _gf_true) {
+        local->stbuf = *stbuf;
+        dht_linkfile_attr_heal(frame, this);
+    }
 out:
-        if (local) {
-                if (local->xattr_req) {
-                        dict_del (local->xattr_req, TIER_LINKFILE_GFID);
-                }
+    if (local) {
+        if (local->xattr_req) {
+            dict_del(local->xattr_req, TIER_LINKFILE_GFID);
         }
+    }
 
-        DHT_STRIP_PHASE1_FLAGS (stbuf);
+    DHT_STRIP_PHASE1_FLAGS(stbuf);
 
-        DHT_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode,
-                          stbuf, preparent, postparent, xdata);
+    DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
+                     preparent, postparent, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_create_linkfile_create_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this,
-                                int32_t op_ret, int32_t op_errno,
-                                inode_t *inode, struct iatt *stbuf,
-                                struct iatt *preparent, struct iatt *postparent,
-                                dict_t *xdata)
+tier_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, inode_t *inode,
+                                struct iatt *stbuf, struct iatt *preparent,
+                                struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t     *local             = NULL;
-        xlator_t        *cached_subvol     = NULL;
-        dht_conf_t      *conf              = NULL;
-        int              ret               = -1;
-        unsigned char   *gfid              = NULL;
-
-        local = frame->local;
-        if (!local) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        if (op_ret == -1) {
-                local->op_errno = op_errno;
-                goto err;
-        }
-
-        conf = this->private;
-        if (!conf) {
-                local->op_errno = EINVAL;
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        cached_subvol = TIER_UNHASHED_SUBVOL;
-
-        if (local->params) {
-                dict_del (local->params, conf->link_xattr_name);
-                dict_del (local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-        }
-
-        /*
-         * We will delete the linkfile if data file creation fails.
-         * When deleting this stale linkfile, there is a possibility
-         * for a race between this linkfile deletion and a stale
-         * linkfile deletion triggered by another lookup from different
-         * client.
-         *
-         * For eg:
-         *
-         *     Client 1                        Client 2
-         *
-         * 1   linkfile created for foo
-         *
-         * 2   data file creation failed
-         *
-         * 3                                   creating a file with same name
-         *
-         * 4                                   lookup before creation deleted
-         *                                     the linkfile created by client1
-         *                                     considering as a stale linkfile.
-         *
-         * 5                                   New linkfile created for foo
-         *                                     with different gfid.
-         *
-         * 6 Trigger linkfile deletion as
-         *   data file creation failed.
-         *
-         * 7 Linkfile deleted which is
-         *   created by client2.
-         *
-         * 8                                   Data file created.
-         *
-         * With this race, we will end up having a file in a non-hashed subvol
-         * without a linkfile in hashed subvol.
-         *
-         * To avoid this, we store the gfid of linkfile created by client, So
-         * If we delete the linkfile , we validate gfid of existing file with
-         * stored value from posix layer.
-         *
-         * Storing this value in local->xattr_req as local->params was also used
-         * to create the data file. During the linkfile deletion we will use
-         * local->xattr_req dictionary.
-         */
+    dht_local_t *local = NULL;
+    xlator_t *cached_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    unsigned char *gfid = NULL;
+
+    local = frame->local;
+    if (!local) {
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    if (op_ret == -1) {
+        local->op_errno = op_errno;
+        goto err;
+    }
+
+    conf = this->private;
+    if (!conf) {
+        local->op_errno = EINVAL;
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    cached_subvol = TIER_UNHASHED_SUBVOL;
+
+    if (local->params) {
+        dict_del(local->params, conf->link_xattr_name);
+        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
+    }
+
+    /*
+     * We will delete the linkfile if data file creation fails.
+     * When deleting this stale linkfile, there is a possibility
+     * for a race between this linkfile deletion and a stale
+     * linkfile deletion triggered by another lookup from different
+     * client.
+     *
+     * For eg:
+     *
+     *     Client 1                        Client 2
+     *
+     * 1   linkfile created for foo
+     *
+     * 2   data file creation failed
+     *
+     * 3                                   creating a file with same name
+     *
+     * 4                                   lookup before creation deleted
+     *                                     the linkfile created by client1
+     *                                     considering as a stale linkfile.
+     *
+     * 5                                   New linkfile created for foo
+     *                                     with different gfid.
+     *
+     * 6 Trigger linkfile deletion as
+     *   data file creation failed.
+     *
+     * 7 Linkfile deleted which is
+     *   created by client2.
+     *
+     * 8                                   Data file created.
+     *
+     * With this race, we will end up having a file in a non-hashed subvol
+     * without a linkfile in hashed subvol.
+     *
+     * To avoid this, we store the gfid of linkfile created by client, So
+     * If we delete the linkfile , we validate gfid of existing file with
+     * stored value from posix layer.
+     *
+     * Storing this value in local->xattr_req as local->params was also used
+     * to create the data file. During the linkfile deletion we will use
+     * local->xattr_req dictionary.
+     */
+    if (!local->xattr_req) {
+        local->xattr_req = dict_new();
         if (!local->xattr_req) {
-                local->xattr_req = dict_new ();
-                if (!local->xattr_req) {
-                        local->op_errno = ENOMEM;
-                        op_errno = ENOMEM;
-                        goto err;
-                }
+            local->op_errno = ENOMEM;
+            op_errno = ENOMEM;
+            goto err;
         }
-
-        gfid = GF_MALLOC (sizeof (uuid_t), gf_common_mt_char);
-        if (!gfid) {
-                local->op_errno = ENOMEM;
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        gf_uuid_copy (gfid, stbuf->ia_gfid);
-        ret = dict_set_dynptr (local->xattr_req, TIER_LINKFILE_GFID,
-                                   gfid, sizeof (uuid_t));
-        if (ret) {
-                GF_FREE (gfid);
-                gf_msg (this->name, GF_LOG_WARNING, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set dictionary value"
-                        " : key = %s", TIER_LINKFILE_GFID);
-        }
-
-        STACK_WIND_COOKIE (frame, tier_create_cbk, cached_subvol,
-                           cached_subvol, cached_subvol->fops->create,
-                           &local->loc, local->flags, local->mode,
-                           local->umask, local->fd, local->params);
-
-        return 0;
+    }
+
+    gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char);
+    if (!gfid) {
+        local->op_errno = ENOMEM;
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    gf_uuid_copy(gfid, stbuf->ia_gfid);
+    ret = dict_set_dynptr(local->xattr_req, TIER_LINKFILE_GFID, gfid,
+                          sizeof(uuid_t));
+    if (ret) {
+        GF_FREE(gfid);
+        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set dictionary value"
+               " : key = %s",
+               TIER_LINKFILE_GFID);
+    }
+
+    STACK_WIND_COOKIE(frame, tier_create_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->create, &local->loc, local->flags,
+                      local->mode, local->umask, local->fd, local->params);
+
+    return 0;
 err:
-        DHT_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
+    return 0;
 }
 
 gf_boolean_t
-tier_is_hot_tier_decommissioned (xlator_t *this)
+tier_is_hot_tier_decommissioned(xlator_t *this)
 {
-        dht_conf_t              *conf        = NULL;
-        xlator_t                *hot_tier    = NULL;
-        int                      i           = 0;
-
-        conf = this->private;
-        hot_tier = conf->subvolumes[1];
-
-        if (conf->decommission_subvols_cnt) {
-                for (i = 0; i < conf->subvolume_cnt; i++) {
-                        if (conf->decommissioned_bricks[i] &&
-                                conf->decommissioned_bricks[i] == hot_tier)
-                                return _gf_true;
-                }
+    dht_conf_t *conf = NULL;
+    xlator_t *hot_tier = NULL;
+    int i = 0;
+
+    conf = this->private;
+    hot_tier = conf->subvolumes[1];
+
+    if (conf->decommission_subvols_cnt) {
+        for (i = 0; i < conf->subvolume_cnt; i++) {
+            if (conf->decommissioned_bricks[i] &&
+                conf->decommissioned_bricks[i] == hot_tier)
+                return _gf_true;
         }
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int
-tier_create (call_frame_t *frame, xlator_t *this,
-            loc_t *loc, int32_t flags, mode_t mode,
-            mode_t umask, fd_t *fd, dict_t *params)
+tier_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+            mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
 {
-        int                     op_errno            = -1;
-        dht_local_t             *local              = NULL;
-        dht_conf_t              *conf               = NULL;
-        xlator_t                *hot_subvol         = NULL;
-        xlator_t                *cold_subvol        = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf = this->private;
-
-        dht_get_du_info (frame, this, loc);
-
-        local = dht_local_init (frame, loc, fd, GF_FOP_CREATE);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-
-        cold_subvol = TIER_HASHED_SUBVOL;
-        hot_subvol = TIER_UNHASHED_SUBVOL;
-
-        if (conf->subvolumes[0] != cold_subvol) {
-                hot_subvol = conf->subvolumes[0];
-        }
-        /*
-         * if hot tier full, write to cold.
-         * Also if hot tier is full, create in cold
-         */
-        if (dht_is_subvol_filled (this, hot_subvol) ||
-            tier_is_hot_tier_decommissioned (this)) {
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s", loc->path,
-                              cold_subvol->name);
-
-                STACK_WIND_COOKIE (frame, tier_create_cbk, cold_subvol,
-                                   cold_subvol, cold_subvol->fops->create,
-                                   loc, flags, mode, umask, fd, params);
-        } else {
-                local->params = dict_ref (params);
-                local->flags = flags;
-                local->mode = mode;
-                local->umask = umask;
-                local->cached_subvol = hot_subvol;
-                local->hashed_subvol = cold_subvol;
-
-                gf_msg_debug (this->name, 0,
-                              "creating %s on %s (link at %s)", loc->path,
-                              hot_subvol->name, cold_subvol->name);
-
-                dht_linkfile_create (frame, tier_create_linkfile_create_cbk,
-                                     this, hot_subvol, cold_subvol, loc);
-
-                goto out;
-        }
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *hot_subvol = NULL;
+    xlator_t *cold_subvol = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    dht_get_du_info(frame, this, loc);
+
+    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    cold_subvol = TIER_HASHED_SUBVOL;
+    hot_subvol = TIER_UNHASHED_SUBVOL;
+
+    if (conf->subvolumes[0] != cold_subvol) {
+        hot_subvol = conf->subvolumes[0];
+    }
+    /*
+     * if hot tier full, write to cold.
+     * Also if hot tier is full, create in cold
+     */
+    if (dht_is_subvol_filled(this, hot_subvol) ||
+        tier_is_hot_tier_decommissioned(this)) {
+        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
+                     cold_subvol->name);
+
+        STACK_WIND_COOKIE(frame, tier_create_cbk, cold_subvol, cold_subvol,
+                          cold_subvol->fops->create, loc, flags, mode, umask,
+                          fd, params);
+    } else {
+        local->params = dict_ref(params);
+        local->flags = flags;
+        local->mode = mode;
+        local->umask = umask;
+        local->cached_subvol = hot_subvol;
+        local->hashed_subvol = cold_subvol;
+
+        gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)", loc->path,
+                     hot_subvol->name, cold_subvol->name);
+
+        dht_linkfile_create(frame, tier_create_linkfile_create_cbk, this,
+                            hot_subvol, cold_subvol, loc);
+
+        goto out;
+    }
 out:
-        return 0;
+    return 0;
 
 err:
 
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL,
-                          NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
+                     NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_unlink_nonhashed_linkfile_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata)
+tier_unlink_nonhashed_linkfile_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int op_ret, int op_errno,
+                                   struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                if ((op_ret == -1) && (op_errno != ENOENT)) {
-                        local->op_errno = op_errno;
-                        local->op_ret = op_ret;
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink link: subvolume %s"
-                                      " returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
-
-                local->op_ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        if ((op_ret == -1) && (op_errno != ENOENT)) {
+            local->op_errno = op_errno;
+            local->op_ret = op_ret;
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink link: subvolume %s"
+                         " returned -1",
+                         prev->name);
+            goto unlock;
         }
+
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (local->op_ret == -1)
-                goto err;
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, NULL);
+    if (local->op_ret == -1)
+        goto err;
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, NULL);
 
-
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (unlink, frame, -1, local->op_errno,
-                          NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(unlink, frame, -1, local->op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int
-tier_unlink_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, inode_t *inode,
-                        struct iatt *preparent, dict_t *xdata,
-                        struct iatt *postparent)
+tier_unlink_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, inode_t *inode,
+                       struct iatt *preparent, dict_t *xdata,
+                       struct iatt *postparent)
 {
-        dht_local_t             *local             = NULL;
-        xlator_t                *prev              = NULL;
-        dht_conf_t              *conf              = NULL;
-        xlator_t                *hot_subvol        = NULL;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    dht_conf_t *conf = NULL;
+    xlator_t *hot_subvol = NULL;
 
-        local = frame->local;
-        prev  = cookie;
-        conf = this->private;
-        hot_subvol = TIER_UNHASHED_SUBVOL;
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+    hot_subvol = TIER_UNHASHED_SUBVOL;
 
-        if (!op_ret) {
-                /*
-                 * linkfile present on hot tier. unlinking the linkfile
-                 */
-                STACK_WIND_COOKIE (frame, tier_unlink_nonhashed_linkfile_cbk,
-                                   hot_subvol, hot_subvol, hot_subvol->fops->unlink,
-                                   &local->loc, local->flags, NULL);
-                return 0;
-        }
+    if (!op_ret) {
+        /*
+         * linkfile present on hot tier. unlinking the linkfile
+         */
+        STACK_WIND_COOKIE(frame, tier_unlink_nonhashed_linkfile_cbk, hot_subvol,
+                          hot_subvol, hot_subvol->fops->unlink, &local->loc,
+                          local->flags, NULL);
+        return 0;
+    }
 
-        LOCK (&frame->lock);
-        {
-                if (op_errno == ENOENT) {
-                        local->op_ret   = 0;
-                        local->op_errno = op_errno;
-                } else {
-                        local->op_ret = op_ret;
-                        local->op_errno = op_errno;
-                }
-                gf_msg_debug (this->name, op_errno,
-                              "Lookup : subvolume %s returned -1",
-                               prev->name);
+    LOCK(&frame->lock);
+    {
+        if (op_errno == ENOENT) {
+            local->op_ret = 0;
+            local->op_errno = op_errno;
+        } else {
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
         }
+        gf_msg_debug(this->name, op_errno, "Lookup : subvolume %s returned -1",
+                     prev->name);
+    }
 
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_unlink_linkfile_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+tier_unlink_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                          int op_ret, int op_errno, struct iatt *preparent,
                          struct iatt *postparent, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        xlator_t     *prev = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-
-        LOCK (&frame->lock);
-        {
-                /* Ignore EINVAL for tier to ignore error when the file
-                        does not exist on the other tier  */
-                if ((op_ret == -1) && !((op_errno == ENOENT) ||
-                                        (op_errno == EINVAL))) {
-                        local->op_errno = op_errno;
-                        local->op_ret   = op_ret;
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink link: subvolume %s"
-                                      " returned -1",
-                                      prev->name);
-                        goto unlock;
-                }
-
-                local->op_ret = 0;
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        /* Ignore EINVAL for tier to ignore error when the file
+                does not exist on the other tier  */
+        if ((op_ret == -1) && !((op_errno == ENOENT) || (op_errno == EINVAL))) {
+            local->op_errno = op_errno;
+            local->op_ret = op_ret;
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink link: subvolume %s"
+                         " returned -1",
+                         prev->name);
+            goto unlock;
         }
+
+        local->op_ret = 0;
+    }
 unlock:
-        UNLOCK (&frame->lock);
+    UNLOCK(&frame->lock);
 
-        if (local->op_ret == -1)
-                goto err;
+    if (local->op_ret == -1)
+        goto err;
 
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return 0;
+    return 0;
 
 err:
-        DHT_STACK_UNWIND (unlink, frame, -1, local->op_errno,
-                          NULL, NULL, NULL);
-        return 0;
+    DHT_STACK_UNWIND(unlink, frame, -1, local->op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-tier_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
+tier_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct iatt *preparent, struct iatt *postparent,
+                dict_t *xdata)
 {
-        dht_local_t     *local          = NULL;
-        xlator_t        *prev           = NULL;
-        struct iatt     *stbuf          = NULL;
-        dht_conf_t      *conf           = NULL;
-        int              ret            = -1;
-        xlator_t        *hot_tier       = NULL;
-        xlator_t        *cold_tier      = NULL;
-
-        local = frame->local;
-        prev  = cookie;
-        conf  = this->private;
-
-        cold_tier = TIER_HASHED_SUBVOL;
-        hot_tier = TIER_UNHASHED_SUBVOL;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        if (op_errno == ENOENT) {
-                                local->op_ret = 0;
-                        } else {
-                                local->op_ret   = -1;
-                                local->op_errno = op_errno;
-                        }
-                        gf_msg_debug (this->name, op_errno,
-                                      "Unlink: subvolume %s returned -1"
-                                      " with errno = %d",
-                                       prev->name, op_errno);
-                        goto unlock;
-                }
-
+    dht_local_t *local = NULL;
+    xlator_t *prev = NULL;
+    struct iatt *stbuf = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
+    xlator_t *hot_tier = NULL;
+    xlator_t *cold_tier = NULL;
+
+    local = frame->local;
+    prev = cookie;
+    conf = this->private;
+
+    cold_tier = TIER_HASHED_SUBVOL;
+    hot_tier = TIER_UNHASHED_SUBVOL;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            if (op_errno == ENOENT) {
                 local->op_ret = 0;
+            } else {
+                local->op_ret = -1;
+                local->op_errno = op_errno;
+            }
+            gf_msg_debug(this->name, op_errno,
+                         "Unlink: subvolume %s returned -1"
+                         " with errno = %d",
+                         prev->name, op_errno);
+            goto unlock;
+        }
 
-                local->postparent = *postparent;
-                local->preparent = *preparent;
+        local->op_ret = 0;
 
-                if (local->loc.parent) {
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->preparent, 0);
-                        dht_inode_ctx_time_update (local->loc.parent, this,
-                                                   &local->postparent, 1);
-                }
+        local->postparent = *postparent;
+        local->preparent = *preparent;
+
+        if (local->loc.parent) {
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->preparent, 0);
+            dht_inode_ctx_time_update(local->loc.parent, this,
+                                      &local->postparent, 1);
         }
+    }
 unlock:
-        UNLOCK (&frame->lock);
-
-        if (local->op_ret)
-                goto out;
+    UNLOCK(&frame->lock);
 
-        if (cold_tier != local->cached_subvol) {
-                /*
-                 * File is present in hot tier, so there will be
-                 * a link file on cold tier, deleting the linkfile
-                 * from cold tier
-                 */
-                STACK_WIND_COOKIE (frame, tier_unlink_linkfile_cbk, cold_tier,
-                                   cold_tier, cold_tier->fops->unlink,
-                                   &local->loc,
-                                   local->flags, xdata);
-                return 0;
-        }
+    if (local->op_ret)
+        goto out;
 
-        ret = dict_get_bin (xdata, DHT_IATT_IN_XDATA_KEY, (void **) &stbuf);
-        if (!ret && stbuf && ((IS_DHT_MIGRATION_PHASE2 (stbuf)) ||
-                      IS_DHT_MIGRATION_PHASE1 (stbuf))) {
-                /*
-                 * File is migrating from cold to hot tier.
-                 * Delete the destination linkfile.
-                 */
-                STACK_WIND_COOKIE (frame, tier_unlink_lookup_cbk, hot_tier,
-                                   hot_tier, hot_tier->fops->lookup,
-                                   &local->loc, NULL);
-                return 0;
+    if (cold_tier != local->cached_subvol) {
+        /*
+         * File is present in hot tier, so there will be
+         * a link file on cold tier, deleting the linkfile
+         * from cold tier
+         */
+        STACK_WIND_COOKIE(frame, tier_unlink_linkfile_cbk, cold_tier, cold_tier,
+                          cold_tier->fops->unlink, &local->loc, local->flags,
+                          xdata);
+        return 0;
+    }
 
-        }
+    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
+    if (!ret && stbuf &&
+        ((IS_DHT_MIGRATION_PHASE2(stbuf)) || IS_DHT_MIGRATION_PHASE1(stbuf))) {
+        /*
+         * File is migrating from cold to hot tier.
+         * Delete the destination linkfile.
+         */
+        STACK_WIND_COOKIE(frame, tier_unlink_lookup_cbk, hot_tier, hot_tier,
+                          hot_tier->fops->lookup, &local->loc, NULL);
+        return 0;
+    }
 
 out:
-        DHT_STACK_UNWIND (unlink, frame, local->op_ret, local->op_errno,
-                          &local->preparent, &local->postparent, xdata);
+    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                     &local->preparent, &local->postparent, xdata);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+tier_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
             dict_t *xdata)
 {
-        xlator_t                *cached_subvol = NULL;
-        xlator_t                *hashed_subvol = NULL;
-        dht_conf_t              *conf          = NULL;
-        int                      op_errno      = -1;
-        dht_local_t             *local         = NULL;
-        int                      ret           = -1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, loc, NULL, GF_FOP_UNLINK);
-        if (!local) {
-                op_errno = ENOMEM;
-
-                goto err;
-        }
-
-        hashed_subvol = TIER_HASHED_SUBVOL;
-
-        cached_subvol = local->cached_subvol;
-        if (!cached_subvol) {
-                gf_msg_debug (this->name, 0,
-                              "no cached subvolume for path=%s", loc->path);
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        local->flags = xflag;
-        if (IA_ISREG (loc->inode->ia_type) &&
-            (hashed_subvol == cached_subvol)) {
-                /*
-                 * File resides in cold tier. We need to stat
-                 * the file to see if it is being promoted.
-                 * If yes we need to delete the destination
-                 * file as well.
-                 *
-                 * Currently we are doing this check only for
-                 * regular files.
-                 */
-                xdata = xdata ? dict_ref (xdata) : dict_new ();
-                if (xdata) {
-                        ret = dict_set_int8 (xdata, DHT_IATT_IN_XDATA_KEY, 1);
-                        if (ret) {
-                                gf_msg_debug (this->name, 0,
-                                        "Failed to set dictionary key %s",
-                                         DHT_IATT_IN_XDATA_KEY);
-                        }
-                }
-        }
-
+    xlator_t *cached_subvol = NULL;
+    xlator_t *hashed_subvol = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    dht_local_t *local = NULL;
+    int ret = -1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, loc, NULL, GF_FOP_UNLINK);
+    if (!local) {
+        op_errno = ENOMEM;
+
+        goto err;
+    }
+
+    hashed_subvol = TIER_HASHED_SUBVOL;
+
+    cached_subvol = local->cached_subvol;
+    if (!cached_subvol) {
+        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
+                     loc->path);
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->flags = xflag;
+    if (IA_ISREG(loc->inode->ia_type) && (hashed_subvol == cached_subvol)) {
         /*
-         * File is on hot tier, delete the data file first, then
-         * linkfile from cold.
+         * File resides in cold tier. We need to stat
+         * the file to see if it is being promoted.
+         * If yes we need to delete the destination
+         * file as well.
+         *
+         * Currently we are doing this check only for
+         * regular files.
          */
-        STACK_WIND_COOKIE (frame, tier_unlink_cbk, cached_subvol,
-                           cached_subvol, cached_subvol->fops->unlink, loc,
-                           xflag, xdata);
-        if (xdata)
-                dict_unref (xdata);
-        return 0;
+        xdata = xdata ? dict_ref(xdata) : dict_new();
+        if (xdata) {
+            ret = dict_set_int8(xdata, DHT_IATT_IN_XDATA_KEY, 1);
+            if (ret) {
+                gf_msg_debug(this->name, 0, "Failed to set dictionary key %s",
+                             DHT_IATT_IN_XDATA_KEY);
+            }
+        }
+    }
+
+    /*
+     * File is on hot tier, delete the data file first, then
+     * linkfile from cold.
+     */
+    STACK_WIND_COOKIE(frame, tier_unlink_cbk, cached_subvol, cached_subvol,
+                      cached_subvol->fops->unlink, loc, xflag, xdata);
+    if (xdata)
+        dict_unref(xdata);
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, gf_dirent_t *orig_entries,
-                 dict_t *xdata)
+tier_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                 int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
 {
-        gf_dirent_t   entries;
-        gf_dirent_t  *orig_entry = NULL;
-        gf_dirent_t  *entry = NULL;
-        int           count = 0;
-
-        INIT_LIST_HEAD (&entries.list);
-
-        if (op_ret < 0)
-                goto unwind;
-
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                entry = gf_dirent_for_name (orig_entry->d_name);
-                if (!entry) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                DHT_MSG_NO_MEMORY,
-                                "Memory allocation failed ");
-                        goto unwind;
-                }
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    int count = 0;
+
+    INIT_LIST_HEAD(&entries.list);
+
+    if (op_ret < 0)
+        goto unwind;
+
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        entry = gf_dirent_for_name(orig_entry->d_name);
+        if (!entry) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+                   "Memory allocation failed ");
+            goto unwind;
+        }
 
-                entry->d_off  = orig_entry->d_off;
-                entry->d_ino  = orig_entry->d_ino;
-                entry->d_type = orig_entry->d_type;
-                entry->d_len  = orig_entry->d_len;
+        entry->d_off = orig_entry->d_off;
+        entry->d_ino = orig_entry->d_ino;
+        entry->d_type = orig_entry->d_type;
+        entry->d_len = orig_entry->d_len;
 
-                list_add_tail (&entry->list, &entries.list);
-                count++;
-        }
-        op_ret = count;
+        list_add_tail(&entry->list, &entries.list);
+        count++;
+    }
+    op_ret = count;
 
 unwind:
-        if (op_ret < 0)
-                op_ret = 0;
+    if (op_ret < 0)
+        op_ret = 0;
 
-        DHT_STACK_UNWIND (readdir, frame, op_ret, op_errno, &entries, NULL);
+    DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, NULL);
 
-        gf_dirent_free (&entries);
+    gf_dirent_free(&entries);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+tier_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
                   int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
 {
-        dht_local_t  *local = NULL;
-        gf_dirent_t   entries;
-        gf_dirent_t  *orig_entry = NULL;
-        gf_dirent_t  *entry = NULL;
-        xlator_t     *prev = NULL;
-        xlator_t     *next_subvol = NULL;
-        off_t         next_offset = 0;
-        int           count = 0;
-        dht_conf_t   *conf   = NULL;
-        int           ret    = 0;
-        inode_table_t           *itable = NULL;
-        inode_t                 *inode = NULL;
-
-        INIT_LIST_HEAD (&entries.list);
-        prev = cookie;
-        local = frame->local;
-        itable = local->fd ? local->fd->inode->table : NULL;
-
-        conf  = this->private;
-        GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
-
-        if (op_ret < 0)
-                goto done;
-
-        list_for_each_entry (orig_entry, (&orig_entries->list), list) {
-                next_offset = orig_entry->d_off;
-
-                if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
-                        /*stat failed somewhere- ignore this entry*/
-                        continue;
-                }
+    dht_local_t *local = NULL;
+    gf_dirent_t entries;
+    gf_dirent_t *orig_entry = NULL;
+    gf_dirent_t *entry = NULL;
+    xlator_t *prev = NULL;
+    xlator_t *next_subvol = NULL;
+    off_t next_offset = 0;
+    int count = 0;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
+    inode_table_t *itable = NULL;
+    inode_t *inode = NULL;
+
+    INIT_LIST_HEAD(&entries.list);
+    prev = cookie;
+    local = frame->local;
+    itable = local->fd ? local->fd->inode->table : NULL;
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
+
+    if (op_ret < 0)
+        goto done;
+
+    list_for_each_entry(orig_entry, (&orig_entries->list), list)
+    {
+        next_offset = orig_entry->d_off;
+
+        if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
+            /*stat failed somewhere- ignore this entry*/
+            continue;
+        }
 
-                entry = gf_dirent_for_name (orig_entry->d_name);
-                if (!entry) {
+        entry = gf_dirent_for_name(orig_entry->d_name);
+        if (!entry) {
+            goto unwind;
+        }
 
-                        goto unwind;
-                }
+        entry->d_off = orig_entry->d_off;
+        entry->d_stat = orig_entry->d_stat;
+        entry->d_ino = orig_entry->d_ino;
+        entry->d_type = orig_entry->d_type;
+        entry->d_len = orig_entry->d_len;
 
-                entry->d_off  = orig_entry->d_off;
-                entry->d_stat = orig_entry->d_stat;
-                entry->d_ino  = orig_entry->d_ino;
-                entry->d_type = orig_entry->d_type;
-                entry->d_len  = orig_entry->d_len;
-
-                if (orig_entry->dict)
-                        entry->dict = dict_ref (orig_entry->dict);
-
-                if (check_is_linkfile (NULL, (&orig_entry->d_stat),
-                                       orig_entry->dict,
-                                       conf->link_xattr_name)) {
-                        goto entries;
-
-                } else if (IA_ISDIR(entry->d_stat.ia_type)) {
-                        if (orig_entry->inode) {
-                                dht_inode_ctx_time_update (orig_entry->inode,
-                                                           this, &entry->d_stat,
-                                                           1);
-                        }
-                } else {
-                        if (orig_entry->inode) {
-                                ret = dht_layout_preset (this, prev,
-                                                         orig_entry->inode);
-                                if (ret)
-                                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                                DHT_MSG_LAYOUT_SET_FAILED,
-                                                "failed to link the layout "
-                                                "in inode");
-
-                                entry->inode = inode_ref (orig_entry->inode);
-                        } else if (itable) {
-                                /*
-                                 * orig_entry->inode might be null if any upper
-                                 * layer xlators below client set to null, to
-                                 * force a lookup on the inode even if the inode
-                                 * is present in the inode table. In that case
-                                 * we just update the ctx to make sure we didn't
-                                 * missed anything.
-                                 */
-                                inode = inode_find (itable,
-                                                    orig_entry->d_stat.ia_gfid);
-                                if (inode) {
-                                        ret = dht_layout_preset
-                                                (this, TIER_HASHED_SUBVOL,
-                                                 inode);
-                                        if (ret)
-                                                gf_msg (this->name,
-                                                     GF_LOG_WARNING, 0,
-                                                     DHT_MSG_LAYOUT_SET_FAILED,
-                                                     "failed to link the layout"
-                                                     " in inode");
-                                        inode_unref (inode);
-                                        inode = NULL;
-                                }
-                        }
-                }
+        if (orig_entry->dict)
+            entry->dict = dict_ref(orig_entry->dict);
 
-entries:
-                list_add_tail (&entry->list, &entries.list);
-                count++;
-        }
-        op_ret = count;
+        if (check_is_linkfile(NULL, (&orig_entry->d_stat), orig_entry->dict,
+                              conf->link_xattr_name)) {
+            goto entries;
 
-done:
-        if (count == 0) {
-                /* non-zero next_offset means that
-                   EOF is not yet hit on the current subvol
-                */
-                if (next_offset != 0) {
-                        next_subvol = prev;
-                } else {
-                        goto unwind;
+        } else if (IA_ISDIR(entry->d_stat.ia_type)) {
+            if (orig_entry->inode) {
+                dht_inode_ctx_time_update(orig_entry->inode, this,
+                                          &entry->d_stat, 1);
+            }
+        } else {
+            if (orig_entry->inode) {
+                ret = dht_layout_preset(this, prev, orig_entry->inode);
+                if (ret)
+                    gf_msg(this->name, GF_LOG_WARNING, 0,
+                           DHT_MSG_LAYOUT_SET_FAILED,
+                           "failed to link the layout "
+                           "in inode");
+
+                entry->inode = inode_ref(orig_entry->inode);
+            } else if (itable) {
+                /*
+                 * orig_entry->inode might be null if any upper
+                 * layer xlators below client set to null, to
+                 * force a lookup on the inode even if the inode
+                 * is present in the inode table. In that case
+                 * we just update the ctx to make sure we didn't
+                 * missed anything.
+                 */
+                inode = inode_find(itable, orig_entry->d_stat.ia_gfid);
+                if (inode) {
+                    ret = dht_layout_preset(this, TIER_HASHED_SUBVOL, inode);
+                    if (ret)
+                        gf_msg(this->name, GF_LOG_WARNING, 0,
+                               DHT_MSG_LAYOUT_SET_FAILED,
+                               "failed to link the layout"
+                               " in inode");
+                    inode_unref(inode);
+                    inode = NULL;
                 }
+            }
+        }
+
+    entries:
+        list_add_tail(&entry->list, &entries.list);
+        count++;
+    }
+    op_ret = count;
 
-                STACK_WIND_COOKIE (frame, tier_readdirp_cbk, next_subvol,
-                                   next_subvol, next_subvol->fops->readdirp,
-                                   local->fd, local->size, next_offset,
-                                   local->xattr);
-                return 0;
+done:
+    if (count == 0) {
+        /* non-zero next_offset means that
+           EOF is not yet hit on the current subvol
+        */
+        if (next_offset != 0) {
+            next_subvol = prev;
+        } else {
+            goto unwind;
         }
 
+        STACK_WIND_COOKIE(frame, tier_readdirp_cbk, next_subvol, next_subvol,
+                          next_subvol->fops->readdirp, local->fd, local->size,
+                          next_offset, local->xattr);
+        return 0;
+    }
+
 unwind:
-        if (op_ret < 0)
-                op_ret = 0;
+    if (op_ret < 0)
+        op_ret = 0;
 
-        DHT_STACK_UNWIND (readdirp, frame, op_ret, op_errno, &entries, NULL);
+    DHT_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &entries, NULL);
 
-        gf_dirent_free (&entries);
+    gf_dirent_free(&entries);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+tier_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
                 off_t yoff, int whichop, dict_t *dict)
 {
-        dht_local_t  *local         = NULL;
-        int           op_errno      = -1;
-        xlator_t     *hashed_subvol = NULL;
-        int           ret           = 0;
-        dht_conf_t   *conf          = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, NULL, whichop);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    dht_local_t *local = NULL;
+    int op_errno = -1;
+    xlator_t *hashed_subvol = NULL;
+    int ret = 0;
+    dht_conf_t *conf = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, NULL, NULL, whichop);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    local->fd = fd_ref(fd);
+    local->size = size;
+    local->xattr_req = (dict) ? dict_ref(dict) : NULL;
+
+    hashed_subvol = TIER_HASHED_SUBVOL;
+
+    /* TODO: do proper readdir */
+    if (whichop == GF_FOP_READDIRP) {
+        if (dict)
+            local->xattr = dict_ref(dict);
+        else
+            local->xattr = dict_new();
+
+        if (local->xattr) {
+            ret = dict_set_uint32(local->xattr, conf->link_xattr_name, 256);
+            if (ret)
+                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
+                       "Failed to set dictionary value"
+                       " : key = %s",
+                       conf->link_xattr_name);
         }
 
-        local->fd = fd_ref (fd);
-        local->size = size;
-        local->xattr_req = (dict) ? dict_ref (dict) : NULL;
-
-        hashed_subvol = TIER_HASHED_SUBVOL;
+        STACK_WIND_COOKIE(frame, tier_readdirp_cbk, hashed_subvol,
+                          hashed_subvol, hashed_subvol->fops->readdirp, fd,
+                          size, yoff, local->xattr);
 
+    } else {
+        STACK_WIND_COOKIE(frame, tier_readdir_cbk, hashed_subvol, hashed_subvol,
+                          hashed_subvol->fops->readdir, fd, size, yoff,
+                          local->xattr);
+    }
 
-        /* TODO: do proper readdir */
-        if (whichop == GF_FOP_READDIRP) {
-                if (dict)
-                        local->xattr = dict_ref (dict);
-                else
-                        local->xattr = dict_new ();
-
-                if (local->xattr) {
-                        ret = dict_set_uint32 (local->xattr,
-                                               conf->link_xattr_name, 256);
-                        if (ret)
-                                gf_msg (this->name, GF_LOG_WARNING, 0,
-                                        DHT_MSG_DICT_SET_FAILED,
-                                        "Failed to set dictionary value"
-                                        " : key = %s",
-                                        conf->link_xattr_name);
-
-                }
-
-                STACK_WIND_COOKIE (frame, tier_readdirp_cbk, hashed_subvol,
-                                   hashed_subvol, hashed_subvol->fops->readdirp,
-                                   fd, size, yoff, local->xattr);
-
-        } else {
-                STACK_WIND_COOKIE (frame, tier_readdir_cbk, hashed_subvol,
-                                   hashed_subvol, hashed_subvol->fops->readdir,
-                                   fd, size, yoff, local->xattr);
-        }
-
-        return 0;
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int
-tier_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+tier_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
              off_t yoff, dict_t *xdata)
 {
-        int          op = GF_FOP_READDIR;
-        dht_conf_t  *conf = NULL;
-        int          i = 0;
-
-        conf = this->private;
-        if (!conf)
-                goto out;
-
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                if (!conf->subvolume_status[i]) {
-                        op = GF_FOP_READDIRP;
-                        break;
-                }
+    int op = GF_FOP_READDIR;
+    dht_conf_t *conf = NULL;
+    int i = 0;
+
+    conf = this->private;
+    if (!conf)
+        goto out;
+
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        if (!conf->subvolume_status[i]) {
+            op = GF_FOP_READDIRP;
+            break;
         }
+    }
 
-        if (conf->use_readdirp)
-                op = GF_FOP_READDIRP;
+    if (conf->use_readdirp)
+        op = GF_FOP_READDIRP;
 
 out:
-        tier_do_readdir (frame, this, fd, size, yoff, op, 0);
-        return 0;
+    tier_do_readdir(frame, this, fd, size, yoff, op, 0);
+    return 0;
 }
 
 int
-tier_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-               off_t yoff, dict_t *dict)
+tier_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+              off_t yoff, dict_t *dict)
 {
-        tier_do_readdir (frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
-        return 0;
+    tier_do_readdir(frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
+    return 0;
 }
 
 int
-tier_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int op_ret, int op_errno, struct statvfs *statvfs,
-                dict_t *xdata)
+tier_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+                int op_errno, struct statvfs *statvfs, dict_t *xdata)
 {
-        gf_boolean_t            event              = _gf_false;
-        qdstatfs_action_t       action             = qdstatfs_action_OFF;
-        dht_local_t             *local             = NULL;
-        int                     this_call_cnt      = 0;
-        int                     bsize              = 0;
-        int                     frsize             = 0;
-        GF_UNUSED int           ret                = 0;
-        unsigned long           new_usage          = 0;
-        unsigned long           cur_usage          = 0;
-        xlator_t                *prev              = NULL;
-        dht_conf_t              *conf              = NULL;
-        tier_statvfs_t          *tier_stat         = NULL;
-
-        prev = cookie;
-        local = frame->local;
-        GF_ASSERT (local);
-
-        conf = this->private;
-
-        if (xdata)
-                ret = dict_get_int8 (xdata, "quota-deem-statfs",
-                                     (int8_t *)&event);
-
-        tier_stat = &local->tier_statvfs;
-
-        LOCK (&frame->lock);
-        {
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
-                if (!statvfs) {
-                        op_errno = EINVAL;
-                        local->op_ret = -1;
-                        goto unlock;
-                }
-                local->op_ret = 0;
+    gf_boolean_t event = _gf_false;
+    qdstatfs_action_t action = qdstatfs_action_OFF;
+    dht_local_t *local = NULL;
+    int this_call_cnt = 0;
+    int bsize = 0;
+    int frsize = 0;
+    GF_UNUSED int ret = 0;
+    unsigned long new_usage = 0;
+    unsigned long cur_usage = 0;
+    xlator_t *prev = NULL;
+    dht_conf_t *conf = NULL;
+    tier_statvfs_t *tier_stat = NULL;
+
+    prev = cookie;
+    local = frame->local;
+    GF_ASSERT(local);
+
+    conf = this->private;
+
+    if (xdata)
+        ret = dict_get_int8(xdata, "quota-deem-statfs", (int8_t *)&event);
+
+    tier_stat = &local->tier_statvfs;
+
+    LOCK(&frame->lock);
+    {
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            goto unlock;
+        }
+        if (!statvfs) {
+            op_errno = EINVAL;
+            local->op_ret = -1;
+            goto unlock;
+        }
+        local->op_ret = 0;
+
+        if (local->quota_deem_statfs) {
+            if (event == _gf_true) {
+                action = qdstatfs_action_COMPARE;
+            } else {
+                action = qdstatfs_action_NEGLECT;
+            }
+        } else {
+            if (event == _gf_true) {
+                action = qdstatfs_action_REPLACE;
+                local->quota_deem_statfs = _gf_true;
+            }
+        }
 
-                if (local->quota_deem_statfs) {
-                        if (event == _gf_true) {
-                                action = qdstatfs_action_COMPARE;
-                        } else {
-                                action = qdstatfs_action_NEGLECT;
-                        }
-                } else {
-
-                        if (event == _gf_true) {
-                                action = qdstatfs_action_REPLACE;
-                                local->quota_deem_statfs = _gf_true;
-                        }
-                }
+        if (local->quota_deem_statfs) {
+            switch (action) {
+                case qdstatfs_action_NEGLECT:
+                    goto unlock;
 
-                if (local->quota_deem_statfs) {
-                        switch (action) {
-                        case qdstatfs_action_NEGLECT:
-                                goto unlock;
-
-                        case qdstatfs_action_REPLACE:
-                                local->statvfs = *statvfs;
-                                goto unlock;
-
-                        case qdstatfs_action_COMPARE:
-                                new_usage = statvfs->f_blocks -
-                                             statvfs->f_bfree;
-                                cur_usage = local->statvfs.f_blocks -
-                                             local->statvfs.f_bfree;
-
-                                /* Take the max of the usage from subvols */
-                                if (new_usage >= cur_usage)
-                                        local->statvfs = *statvfs;
-                                goto unlock;
-
-                        default:
-                                break;
-                        }
-                }
+                case qdstatfs_action_REPLACE:
+                    local->statvfs = *statvfs;
+                    goto unlock;
 
-                if (local->statvfs.f_bsize != 0) {
-                        bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
-                        frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
-                        dht_normalize_stats(&local->statvfs, bsize, frsize);
-                        dht_normalize_stats(statvfs, bsize, frsize);
-                } else {
-                        local->statvfs.f_bsize    = statvfs->f_bsize;
-                        local->statvfs.f_frsize   = statvfs->f_frsize;
-                }
+                case qdstatfs_action_COMPARE:
+                    new_usage = statvfs->f_blocks - statvfs->f_bfree;
+                    cur_usage = local->statvfs.f_blocks -
+                                local->statvfs.f_bfree;
 
-                if (prev == TIER_HASHED_SUBVOL) {
-                        local->statvfs.f_blocks   = statvfs->f_blocks;
-                        local->statvfs.f_files    = statvfs->f_files;
-                        local->statvfs.f_fsid     = statvfs->f_fsid;
-                        local->statvfs.f_flag     = statvfs->f_flag;
-                        local->statvfs.f_namemax  = statvfs->f_namemax;
-                        tier_stat->blocks_used    = (statvfs->f_blocks - statvfs->f_bfree);
-                        tier_stat->pblocks_used   = (statvfs->f_blocks - statvfs->f_bavail);
-                        tier_stat->files_used     = (statvfs->f_files - statvfs->f_ffree);
-                        tier_stat->pfiles_used    = (statvfs->f_files - statvfs->f_favail);
-                        tier_stat->hashed_fsid    = statvfs->f_fsid;
-                } else {
-                        tier_stat->unhashed_fsid      = statvfs->f_fsid;
-                        tier_stat->unhashed_blocks_used    = (statvfs->f_blocks - statvfs->f_bfree);
-                        tier_stat->unhashed_pblocks_used   = (statvfs->f_blocks - statvfs->f_bavail);
-                        tier_stat->unhashed_files_used     = (statvfs->f_files - statvfs->f_ffree);
-                        tier_stat->unhashed_pfiles_used    = (statvfs->f_files - statvfs->f_favail);
-                }
+                    /* Take the max of the usage from subvols */
+                    if (new_usage >= cur_usage)
+                        local->statvfs = *statvfs;
+                    goto unlock;
 
+                default:
+                    break;
+            }
         }
-unlock:
-        UNLOCK (&frame->lock);
-
-        this_call_cnt = dht_frame_return (frame);
-        if (is_last_call (this_call_cnt)) {
-                if (tier_stat->unhashed_fsid != tier_stat->hashed_fsid) {
-                        tier_stat->blocks_used    += tier_stat->unhashed_blocks_used;
-                        tier_stat->pblocks_used   += tier_stat->unhashed_pblocks_used;
-                        tier_stat->files_used     += tier_stat->unhashed_files_used;
-                        tier_stat->pfiles_used    += tier_stat->unhashed_pfiles_used;
-                }
-                local->statvfs.f_bfree = local->statvfs.f_blocks -
-                        tier_stat->blocks_used;
-                local->statvfs.f_bavail = local->statvfs.f_blocks -
-                        tier_stat->pblocks_used;
-                local->statvfs.f_ffree = local->statvfs.f_files -
-                        tier_stat->files_used;
-                local->statvfs.f_favail = local->statvfs.f_files -
-                        tier_stat->pfiles_used;
-                DHT_STACK_UNWIND (statfs, frame, local->op_ret, local->op_errno,
-                                  &local->statvfs, xdata);
+
+        if (local->statvfs.f_bsize != 0) {
+            bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
+            frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
+            dht_normalize_stats(&local->statvfs, bsize, frsize);
+            dht_normalize_stats(statvfs, bsize, frsize);
+        } else {
+            local->statvfs.f_bsize = statvfs->f_bsize;
+            local->statvfs.f_frsize = statvfs->f_frsize;
         }
 
-        return 0;
+        if (prev == TIER_HASHED_SUBVOL) {
+            local->statvfs.f_blocks = statvfs->f_blocks;
+            local->statvfs.f_files = statvfs->f_files;
+            local->statvfs.f_fsid = statvfs->f_fsid;
+            local->statvfs.f_flag = statvfs->f_flag;
+            local->statvfs.f_namemax = statvfs->f_namemax;
+            tier_stat->blocks_used = (statvfs->f_blocks - statvfs->f_bfree);
+            tier_stat->pblocks_used = (statvfs->f_blocks - statvfs->f_bavail);
+            tier_stat->files_used = (statvfs->f_files - statvfs->f_ffree);
+            tier_stat->pfiles_used = (statvfs->f_files - statvfs->f_favail);
+            tier_stat->hashed_fsid = statvfs->f_fsid;
+        } else {
+            tier_stat->unhashed_fsid = statvfs->f_fsid;
+            tier_stat->unhashed_blocks_used = (statvfs->f_blocks -
+                                               statvfs->f_bfree);
+            tier_stat->unhashed_pblocks_used = (statvfs->f_blocks -
+                                                statvfs->f_bavail);
+            tier_stat->unhashed_files_used = (statvfs->f_files -
+                                              statvfs->f_ffree);
+            tier_stat->unhashed_pfiles_used = (statvfs->f_files -
+                                               statvfs->f_favail);
+        }
+    }
+unlock:
+    UNLOCK(&frame->lock);
+
+    this_call_cnt = dht_frame_return(frame);
+    if (is_last_call(this_call_cnt)) {
+        if (tier_stat->unhashed_fsid != tier_stat->hashed_fsid) {
+            tier_stat->blocks_used += tier_stat->unhashed_blocks_used;
+            tier_stat->pblocks_used += tier_stat->unhashed_pblocks_used;
+            tier_stat->files_used += tier_stat->unhashed_files_used;
+            tier_stat->pfiles_used += tier_stat->unhashed_pfiles_used;
+        }
+        local->statvfs.f_bfree = local->statvfs.f_blocks -
+                                 tier_stat->blocks_used;
+        local->statvfs.f_bavail = local->statvfs.f_blocks -
+                                  tier_stat->pblocks_used;
+        local->statvfs.f_ffree = local->statvfs.f_files - tier_stat->files_used;
+        local->statvfs.f_favail = local->statvfs.f_files -
+                                  tier_stat->pfiles_used;
+        DHT_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                         &local->statvfs, xdata);
+    }
+
+    return 0;
 }
 
-
 int
-tier_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+tier_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        dht_local_t      *local  = NULL;
-        dht_conf_t       *conf = NULL;
-        int               op_errno = -1;
-        int               i = -1;
-        inode_t          *inode         = NULL;
-        inode_table_t    *itable        = NULL;
-        uuid_t            root_gfid     = {0, };
-        loc_t             newloc        = {0, };
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (this->private, err);
-
-        conf = this->private;
-
-        local = dht_local_init (frame, NULL, NULL, GF_FOP_STATFS);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    dht_local_t *local = NULL;
+    dht_conf_t *conf = NULL;
+    int op_errno = -1;
+    int i = -1;
+    inode_t *inode = NULL;
+    inode_table_t *itable = NULL;
+    uuid_t root_gfid = {
+        0,
+    };
+    loc_t newloc = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(this->private, err);
+
+    conf = this->private;
+
+    local = dht_local_init(frame, NULL, NULL, GF_FOP_STATFS);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    if (loc->inode && !IA_ISDIR(loc->inode->ia_type)) {
+        itable = loc->inode->table;
+        if (!itable) {
+            op_errno = EINVAL;
+            goto err;
         }
 
-        if (loc->inode && !IA_ISDIR (loc->inode->ia_type)) {
-                itable = loc->inode->table;
-                if (!itable) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                loc = &local->loc2;
-                root_gfid[15] = 1;
+        loc = &local->loc2;
+        root_gfid[15] = 1;
 
-                inode = inode_find (itable, root_gfid);
-                if (!inode) {
-                        op_errno = EINVAL;
-                        goto err;
-                }
-
-                dht_build_root_loc (inode, &newloc);
-                loc = &newloc;
+        inode = inode_find(itable, root_gfid);
+        if (!inode) {
+            op_errno = EINVAL;
+            goto err;
         }
 
-        local->call_cnt = conf->subvolume_cnt;
+        dht_build_root_loc(inode, &newloc);
+        loc = &newloc;
+    }
 
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-                STACK_WIND_COOKIE (frame, tier_statfs_cbk, conf->subvolumes[i],
-                                   conf->subvolumes[i],
-                                   conf->subvolumes[i]->fops->statfs, loc,
-                                   xdata);
-        }
+    local->call_cnt = conf->subvolume_cnt;
 
-        return 0;
+    for (i = 0; i < conf->subvolume_cnt; i++) {
+        STACK_WIND_COOKIE(frame, tier_statfs_cbk, conf->subvolumes[i],
+                          conf->subvolumes[i],
+                          conf->subvolumes[i]->fops->statfs, loc, xdata);
+    }
+
+    return 0;
 
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        DHT_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    DHT_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
 
-        return 0;
+    return 0;
 }
diff --git a/xlators/cluster/dht/src/tier.c b/xlators/cluster/dht/src/tier.c
index 63eb65be302..f7fd6ef22e2 100644
--- a/xlators/cluster/dht/src/tier.c
+++ b/xlators/cluster/dht/src/tier.c
@@ -38,103 +38,101 @@ static gfdb_methods_t gfdb_methods;
  * Closes all the fds and frees the qfile_array
  * */
 static void
-qfile_array_free (tier_qfile_array_t *qfile_array)
+qfile_array_free(tier_qfile_array_t *qfile_array)
 {
-        ssize_t i = 0;
-
-        if (qfile_array) {
-                if (qfile_array->fd_array) {
-                        for (i = 0; i < qfile_array->array_size; i++) {
-                                if (qfile_array->fd_array[i] != -1) {
-                                        sys_close (qfile_array->fd_array[i]);
-                                }
-                        }
+    ssize_t i = 0;
+
+    if (qfile_array) {
+        if (qfile_array->fd_array) {
+            for (i = 0; i < qfile_array->array_size; i++) {
+                if (qfile_array->fd_array[i] != -1) {
+                    sys_close(qfile_array->fd_array[i]);
                 }
-                GF_FREE (qfile_array->fd_array);
+            }
         }
-        GF_FREE (qfile_array);
+        GF_FREE(qfile_array->fd_array);
+    }
+    GF_FREE(qfile_array);
 }
 
-
 /* Create a new query file list with given size */
 static tier_qfile_array_t *
-qfile_array_new (ssize_t array_size)
+qfile_array_new(ssize_t array_size)
 {
-        int ret                         = -1;
-        tier_qfile_array_t *qfile_array   = NULL;
-        ssize_t i                       = 0;
-
-        GF_VALIDATE_OR_GOTO ("tier", (array_size > 0), out);
-
-        qfile_array = GF_CALLOC (1, sizeof (tier_qfile_array_t),
-                                gf_tier_mt_qfile_array_t);
-        if (!qfile_array) {
-                gf_msg ("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to allocate memory for tier_qfile_array_t");
-                goto out;
-        }
-
-        qfile_array->fd_array = GF_MALLOC (array_size * sizeof (int),
-                                           gf_dht_mt_int32_t);
-        if (!qfile_array->fd_array) {
-                gf_msg ("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to allocate memory for "
-                        "tier_qfile_array_t->fd_array");
-                goto out;
-        }
-
-        /* Init all the fds to -1 */
-        for (i = 0; i < array_size; i++) {
-                qfile_array->fd_array[i] = -1;
-        }
-
-        qfile_array->array_size = array_size;
-        qfile_array->next_index = 0;
-
-        /* Set exhausted count to list size as the list is empty */
-        qfile_array->exhausted_count = qfile_array->array_size;
-
-        ret = 0;
+    int ret = -1;
+    tier_qfile_array_t *qfile_array = NULL;
+    ssize_t i = 0;
+
+    GF_VALIDATE_OR_GOTO("tier", (array_size > 0), out);
+
+    qfile_array = GF_CALLOC(1, sizeof(tier_qfile_array_t),
+                            gf_tier_mt_qfile_array_t);
+    if (!qfile_array) {
+        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to allocate memory for tier_qfile_array_t");
+        goto out;
+    }
+
+    qfile_array->fd_array = GF_MALLOC(array_size * sizeof(int),
+                                      gf_dht_mt_int32_t);
+    if (!qfile_array->fd_array) {
+        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to allocate memory for "
+               "tier_qfile_array_t->fd_array");
+        goto out;
+    }
+
+    /* Init all the fds to -1 */
+    for (i = 0; i < array_size; i++) {
+        qfile_array->fd_array[i] = -1;
+    }
+
+    qfile_array->array_size = array_size;
+    qfile_array->next_index = 0;
+
+    /* Set exhausted count to list size as the list is empty */
+    qfile_array->exhausted_count = qfile_array->array_size;
+
+    ret = 0;
 out:
-        if (ret) {
-                qfile_array_free (qfile_array);
-                qfile_array = NULL;
-        }
-        return qfile_array;
+    if (ret) {
+        qfile_array_free(qfile_array);
+        qfile_array = NULL;
+    }
+    return qfile_array;
 }
 
-
 /* Checks if the query file list is empty or totally exhausted. */
 static gf_boolean_t
-is_qfile_array_empty (tier_qfile_array_t *qfile_array)
+is_qfile_array_empty(tier_qfile_array_t *qfile_array)
 {
-        return (qfile_array->exhausted_count == qfile_array->array_size) ?
-                _gf_true : _gf_false;
+    return (qfile_array->exhausted_count == qfile_array->array_size)
+               ? _gf_true
+               : _gf_false;
 }
 
-
 /* Shifts the next_fd pointer to the next available fd in the list */
 static void
-shift_next_index (tier_qfile_array_t *qfile_array)
+shift_next_index(tier_qfile_array_t *qfile_array)
 {
-        int qfile_fd = 0;
-        int spin_count = 0;
+    int qfile_fd = 0;
+    int spin_count = 0;
 
-        if (is_qfile_array_empty (qfile_array)) {
-                return;
-        }
-
-        do {
-                /* change next_index in a rotional manner */
-                (qfile_array->next_index == (qfile_array->array_size - 1)) ?
-                qfile_array->next_index = 0 : qfile_array->next_index++;
+    if (is_qfile_array_empty(qfile_array)) {
+        return;
+    }
 
-                qfile_fd = (qfile_array->fd_array[qfile_array->next_index]);
+    do {
+        /* change next_index in a rotional manner */
+        (qfile_array->next_index == (qfile_array->array_size - 1))
+            ? qfile_array->next_index = 0
+            : qfile_array->next_index++;
 
-                spin_count++;
+        qfile_fd = (qfile_array->fd_array[qfile_array->next_index]);
 
-        } while ((qfile_fd == -1) && (spin_count < qfile_array->array_size));
+        spin_count++;
 
+    } while ((qfile_fd == -1) && (spin_count < qfile_array->array_size));
 }
 
 /*
@@ -149,1844 +147,1707 @@ shift_next_index (tier_qfile_array_t *qfile_array)
  * < 0  if there was failure
  * */
 static int
-read_query_record_list (tier_qfile_array_t *qfile_array,
-                          gfdb_query_record_t **query_record)
+read_query_record_list(tier_qfile_array_t *qfile_array,
+                       gfdb_query_record_t **query_record)
 {
-        int ret = -1;
-        int qfile_fd = 0;
-
-        GF_VALIDATE_OR_GOTO ("tier", qfile_array, out);
-        GF_VALIDATE_OR_GOTO ("tier", qfile_array->fd_array, out);
-
-        do {
-                if (is_qfile_array_empty (qfile_array)) {
-                        ret = 0;
-                        break;
-                }
-
-                qfile_fd = qfile_array->fd_array[qfile_array->next_index];
-                ret = gfdb_methods.gfdb_read_query_record
-                        (qfile_fd, query_record);
-                if (ret <= 0) {
-                        /*The qfile_fd has reached EOF or
-                         * there was an error.
-                         * 1. Close the exhausted fd
-                         * 2. increment the exhausted count
-                         * 3. shift next_qfile to next qfile
-                         **/
-                         sys_close (qfile_fd);
-                         qfile_array->fd_array[qfile_array->next_index] = -1;
-                         qfile_array->exhausted_count++;
-                         /* shift next_qfile to next qfile */
-                         shift_next_index (qfile_array);
-                         continue;
-                } else {
-                        /* shift next_qfile to next qfile */
-                        shift_next_index (qfile_array);
-                        break;
-                }
-        } while (1);
+    int ret = -1;
+    int qfile_fd = 0;
+
+    GF_VALIDATE_OR_GOTO("tier", qfile_array, out);
+    GF_VALIDATE_OR_GOTO("tier", qfile_array->fd_array, out);
+
+    do {
+        if (is_qfile_array_empty(qfile_array)) {
+            ret = 0;
+            break;
+        }
+
+        qfile_fd = qfile_array->fd_array[qfile_array->next_index];
+        ret = gfdb_methods.gfdb_read_query_record(qfile_fd, query_record);
+        if (ret <= 0) {
+            /*The qfile_fd has reached EOF or
+             * there was an error.
+             * 1. Close the exhausted fd
+             * 2. increment the exhausted count
+             * 3. shift next_qfile to next qfile
+             **/
+            sys_close(qfile_fd);
+            qfile_array->fd_array[qfile_array->next_index] = -1;
+            qfile_array->exhausted_count++;
+            /* shift next_qfile to next qfile */
+            shift_next_index(qfile_array);
+            continue;
+        } else {
+            /* shift next_qfile to next qfile */
+            shift_next_index(qfile_array);
+            break;
+        }
+    } while (1);
 out:
-        return ret;
+    return ret;
 }
 
-
 /* Check and update the watermark every WM_INTERVAL seconds */
-#define WM_INTERVAL            5
-#define WM_INTERVAL_EMERG      1
+#define WM_INTERVAL 5
+#define WM_INTERVAL_EMERG 1
 
 static int
-tier_check_same_node (xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
+tier_check_same_node(xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
 {
-        int         ret                     = -1;
-        dict_t     *dict                    = NULL;
-        char       *uuid_str                = NULL;
-        uuid_t      node_uuid               = {0,};
-
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, loc, out);
-        GF_VALIDATE_OR_GOTO (this->name, defrag, out);
-
-        if (syncop_getxattr (this, loc, &dict, GF_XATTR_NODE_UUID_KEY,
-                             NULL, NULL)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Unable to get NODE_UUID_KEY %s %s\n",
-                        loc->name, loc->path);
-                goto out;
-        }
-
-        if (dict_get_str (dict, GF_XATTR_NODE_UUID_KEY, &uuid_str) < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to get node-uuids for %s", loc->path);
-                goto out;
-        }
-
-
-        if (gf_uuid_parse (uuid_str, node_uuid)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "uuid_parse failed for %s", loc->path);
-                goto out;
-        }
-
-        if (gf_uuid_compare (node_uuid, defrag->node_uuid)) {
-                gf_msg_debug (this->name, 0,
-                              "%s does not belong to this node", loc->path);
-                ret = 1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    dict_t *dict = NULL;
+    char *uuid_str = NULL;
+    uuid_t node_uuid = {
+        0,
+    };
+
+    GF_VALIDATE_OR_GOTO("tier", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, loc, out);
+    GF_VALIDATE_OR_GOTO(this->name, defrag, out);
+
+    if (syncop_getxattr(this, loc, &dict, GF_XATTR_NODE_UUID_KEY, NULL, NULL)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Unable to get NODE_UUID_KEY %s %s\n", loc->name, loc->path);
+        goto out;
+    }
+
+    if (dict_get_str(dict, GF_XATTR_NODE_UUID_KEY, &uuid_str) < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to get node-uuids for %s", loc->path);
+        goto out;
+    }
+
+    if (gf_uuid_parse(uuid_str, node_uuid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "uuid_parse failed for %s", loc->path);
+        goto out;
+    }
+
+    if (gf_uuid_compare(node_uuid, defrag->node_uuid)) {
+        gf_msg_debug(this->name, 0, "%s does not belong to this node",
+                     loc->path);
+        ret = 1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (dict)
-                dict_unref(dict);
+    if (dict)
+        dict_unref(dict);
 
-        return ret;
+    return ret;
 }
 
 int
-tier_get_fs_stat (xlator_t *this, loc_t *root_loc)
+tier_get_fs_stat(xlator_t *this, loc_t *root_loc)
 {
-        int                     ret = 0;
-        gf_defrag_info_t       *defrag = NULL;
-        dht_conf_t             *conf   = NULL;
-        dict_t                 *xdata  = NULL;
-        struct statvfs          statfs = {0, };
-        gf_tier_conf_t         *tier_conf = NULL;
-
-
-        conf = this->private;
-        if (!conf) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "conf is NULL");
-                ret = -1;
-                goto exit;
-        }
-
-        defrag = conf->defrag;
-        if (!defrag) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "defrag is NULL");
-                ret = -1;
-                goto exit;
-        }
-
-        tier_conf = &defrag->tier_conf;
-
-        xdata = dict_new ();
-        if (!xdata) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        DHT_MSG_NO_MEMORY,
-                        "failed to allocate dictionary");
-                ret = -1;
-                goto exit;
-        }
-
-        ret = dict_set_int8 (xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_DICT_SET_FAILED,
-                        "Failed to set "
-                        GF_INTERNAL_IGNORE_DEEM_STATFS" in dict");
-                ret = -1;
-                goto exit;
-        }
-
-        /* Find how much free space is on the hot subvolume.
-         * Then see if that value */
-        /* is less than or greater than user defined watermarks.
-         * Stash results in */
-        /* the tier_conf data structure. */
-
-        ret = syncop_statfs (conf->subvolumes[1], root_loc, &statfs,
-                             xdata, NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Unable to obtain statfs.");
-                goto exit;
-        }
-
-        pthread_mutex_lock (&dm_stat_mutex);
-
-        tier_conf->block_size = statfs.f_bsize;
-        tier_conf->blocks_total = statfs.f_blocks;
-        tier_conf->blocks_used = statfs.f_blocks - statfs.f_bfree;
-
-        tier_conf->percent_full = GF_PERCENTAGE(tier_conf->blocks_used,
-                                                statfs.f_blocks);
-        pthread_mutex_unlock (&dm_stat_mutex);
+    int ret = 0;
+    gf_defrag_info_t *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    dict_t *xdata = NULL;
+    struct statvfs statfs = {
+        0,
+    };
+    gf_tier_conf_t *tier_conf = NULL;
+
+    conf = this->private;
+    if (!conf) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
+               "conf is NULL");
+        ret = -1;
+        goto exit;
+    }
+
+    defrag = conf->defrag;
+    if (!defrag) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
+               "defrag is NULL");
+        ret = -1;
+        goto exit;
+    }
+
+    tier_conf = &defrag->tier_conf;
+
+    xdata = dict_new();
+    if (!xdata) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
+               "failed to allocate dictionary");
+        ret = -1;
+        goto exit;
+    }
+
+    ret = dict_set_int8(xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
+               "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
+        ret = -1;
+        goto exit;
+    }
+
+    /* Find how much free space is on the hot subvolume.
+     * Then see if that value */
+    /* is less than or greater than user defined watermarks.
+     * Stash results in */
+    /* the tier_conf data structure. */
+
+    ret = syncop_statfs(conf->subvolumes[1], root_loc, &statfs, xdata, NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_STATUS,
+               "Unable to obtain statfs.");
+        goto exit;
+    }
+
+    pthread_mutex_lock(&dm_stat_mutex);
+
+    tier_conf->block_size = statfs.f_bsize;
+    tier_conf->blocks_total = statfs.f_blocks;
+    tier_conf->blocks_used = statfs.f_blocks - statfs.f_bfree;
+
+    tier_conf->percent_full = GF_PERCENTAGE(tier_conf->blocks_used,
+                                            statfs.f_blocks);
+    pthread_mutex_unlock(&dm_stat_mutex);
 
 exit:
-        if (xdata)
-                dict_unref (xdata);
-        return ret;
+    if (xdata)
+        dict_unref(xdata);
+    return ret;
 }
 
 static void
-tier_send_watermark_event (const char *volname,
-                           tier_watermark_op_t old_wm,
-                           tier_watermark_op_t new_wm)
+tier_send_watermark_event(const char *volname, tier_watermark_op_t old_wm,
+                          tier_watermark_op_t new_wm)
 {
-        if (old_wm == TIER_WM_LOW || old_wm == TIER_WM_NONE) {
-                if (new_wm == TIER_WM_MID) {
-                        gf_event (EVENT_TIER_WATERMARK_RAISED_TO_MID,
-                                  "vol=%s", volname);
-                } else if (new_wm == TIER_WM_HI) {
-                        gf_event (EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
-                }
-        } else if (old_wm == TIER_WM_MID) {
-                if (new_wm == TIER_WM_LOW) {
-                        gf_event (EVENT_TIER_WATERMARK_DROPPED_TO_LOW,
-                                  "vol=%s", volname);
-                } else if (new_wm == TIER_WM_HI) {
-                        gf_event (EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
-                }
-        } else if (old_wm == TIER_WM_HI) {
-                if (new_wm == TIER_WM_MID) {
-                        gf_event (EVENT_TIER_WATERMARK_DROPPED_TO_MID,
-                                  "vol=%s", volname);
-                } else if (new_wm == TIER_WM_LOW) {
-                        gf_event (EVENT_TIER_WATERMARK_DROPPED_TO_LOW,
-                                  "vol=%s", volname);
-                }
-        }
+    if (old_wm == TIER_WM_LOW || old_wm == TIER_WM_NONE) {
+        if (new_wm == TIER_WM_MID) {
+            gf_event(EVENT_TIER_WATERMARK_RAISED_TO_MID, "vol=%s", volname);
+        } else if (new_wm == TIER_WM_HI) {
+            gf_event(EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
+        }
+    } else if (old_wm == TIER_WM_MID) {
+        if (new_wm == TIER_WM_LOW) {
+            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_LOW, "vol=%s", volname);
+        } else if (new_wm == TIER_WM_HI) {
+            gf_event(EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
+        }
+    } else if (old_wm == TIER_WM_HI) {
+        if (new_wm == TIER_WM_MID) {
+            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_MID, "vol=%s", volname);
+        } else if (new_wm == TIER_WM_LOW) {
+            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_LOW, "vol=%s", volname);
+        }
+    }
 }
 
 int
-tier_check_watermark (xlator_t *this)
+tier_check_watermark(xlator_t *this)
 {
-        int                     ret       = -1;
-        gf_defrag_info_t       *defrag    = NULL;
-        dht_conf_t             *conf      = NULL;
-        gf_tier_conf_t         *tier_conf = NULL;
-        tier_watermark_op_t     wm        = TIER_WM_NONE;
+    int ret = -1;
+    gf_defrag_info_t *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    gf_tier_conf_t *tier_conf = NULL;
+    tier_watermark_op_t wm = TIER_WM_NONE;
 
-        conf = this->private;
-        if (!conf)
-                goto exit;
+    conf = this->private;
+    if (!conf)
+        goto exit;
 
-        defrag = conf->defrag;
-        if (!defrag)
-                goto exit;
+    defrag = conf->defrag;
+    if (!defrag)
+        goto exit;
 
-        tier_conf = &defrag->tier_conf;
+    tier_conf = &defrag->tier_conf;
 
-        if (tier_conf->percent_full < tier_conf->watermark_low) {
-                wm = TIER_WM_LOW;
+    if (tier_conf->percent_full < tier_conf->watermark_low) {
+        wm = TIER_WM_LOW;
 
-        } else if (tier_conf->percent_full < tier_conf->watermark_hi) {
-                wm = TIER_WM_MID;
+    } else if (tier_conf->percent_full < tier_conf->watermark_hi) {
+        wm = TIER_WM_MID;
 
-        } else {
-                wm = TIER_WM_HI;
-        }
+    } else {
+        wm = TIER_WM_HI;
+    }
 
-        if (wm != tier_conf->watermark_last) {
+    if (wm != tier_conf->watermark_last) {
+        tier_send_watermark_event(tier_conf->volname, tier_conf->watermark_last,
+                                  wm);
 
-                tier_send_watermark_event (tier_conf->volname,
-                                           tier_conf->watermark_last,
-                                           wm);
+        tier_conf->watermark_last = wm;
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Tier watermark now %d", wm);
+    }
 
-                tier_conf->watermark_last = wm;
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Tier watermark now %d", wm);
-        }
-
-        ret = 0;
+    ret = 0;
 
 exit:
-        return ret;
+    return ret;
 }
 
-
 static gf_boolean_t
-is_hot_tier_full (gf_tier_conf_t *tier_conf)
+is_hot_tier_full(gf_tier_conf_t *tier_conf)
 {
-        if (tier_conf && (tier_conf->mode == TIER_MODE_WM) &&
-           (tier_conf->watermark_last == TIER_WM_HI))
-                return _gf_true;
+    if (tier_conf && (tier_conf->mode == TIER_MODE_WM) &&
+        (tier_conf->watermark_last == TIER_WM_HI))
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int
-tier_do_migration (xlator_t *this, int promote)
+tier_do_migration(xlator_t *this, int promote)
 {
-        gf_defrag_info_t       *defrag = NULL;
-        dht_conf_t             *conf   = NULL;
-        long                    rand = 0;
-        int                     migrate = 0;
-        gf_tier_conf_t         *tier_conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    long rand = 0;
+    int migrate = 0;
+    gf_tier_conf_t *tier_conf = NULL;
 
-        conf = this->private;
-        if (!conf)
-                goto exit;
+    conf = this->private;
+    if (!conf)
+        goto exit;
 
-        defrag = conf->defrag;
-        if (!defrag)
-                goto exit;
-
-        if (tier_check_watermark (this) != 0) {
-                gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to get watermark");
-                goto exit;
-        }
+    defrag = conf->defrag;
+    if (!defrag)
+        goto exit;
+
+    if (tier_check_watermark(this) != 0) {
+        gf_msg(this->name, GF_LOG_CRITICAL, errno, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to get watermark");
+        goto exit;
+    }
 
-        tier_conf = &defrag->tier_conf;
+    tier_conf = &defrag->tier_conf;
 
-        switch (tier_conf->watermark_last) {
+    switch (tier_conf->watermark_last) {
         case TIER_WM_LOW:
-                migrate = promote ? 1 : 0;
-                break;
+            migrate = promote ? 1 : 0;
+            break;
         case TIER_WM_HI:
-                migrate = promote ? 0 : 1;
-                break;
+            migrate = promote ? 0 : 1;
+            break;
         case TIER_WM_MID:
-                /* coverity[DC.WEAK_CRYPTO] */
-                rand = random() % 100;
-                if (promote) {
-                        migrate = (rand > tier_conf->percent_full);
-                } else {
-                        migrate = (rand <= tier_conf->percent_full);
-                }
-                break;
-        }
+            /* coverity[DC.WEAK_CRYPTO] */
+            rand = random() % 100;
+            if (promote) {
+                migrate = (rand > tier_conf->percent_full);
+            } else {
+                migrate = (rand <= tier_conf->percent_full);
+            }
+            break;
+    }
 
 exit:
-        return migrate;
+    return migrate;
 }
 
 int
-tier_migrate (xlator_t *this, int is_promotion, dict_t *migrate_data,
-              loc_t *loc, gf_tier_conf_t *tier_conf)
+tier_migrate(xlator_t *this, int is_promotion, dict_t *migrate_data, loc_t *loc,
+             gf_tier_conf_t *tier_conf)
 {
-        int ret = -1;
-
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-        if (is_promotion)
-                tier_conf->promote_in_progress = 1;
-        else
-                tier_conf->demote_in_progress = 1;
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-
-        /* Data migration */
-        ret = syncop_setxattr (this, loc, migrate_data, 0,
-                               NULL, NULL);
-
-        pthread_mutex_lock (&tier_conf->pause_mutex);
-        if (is_promotion)
-                tier_conf->promote_in_progress = 0;
-        else
-                tier_conf->demote_in_progress = 0;
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-
-        return ret;
+    int ret = -1;
+
+    pthread_mutex_lock(&tier_conf->pause_mutex);
+    if (is_promotion)
+        tier_conf->promote_in_progress = 1;
+    else
+        tier_conf->demote_in_progress = 1;
+    pthread_mutex_unlock(&tier_conf->pause_mutex);
+
+    /* Data migration */
+    ret = syncop_setxattr(this, loc, migrate_data, 0, NULL, NULL);
+
+    pthread_mutex_lock(&tier_conf->pause_mutex);
+    if (is_promotion)
+        tier_conf->promote_in_progress = 0;
+    else
+        tier_conf->demote_in_progress = 0;
+    pthread_mutex_unlock(&tier_conf->pause_mutex);
+
+    return ret;
 }
 
 /* returns  _gf_true: if file can be promoted
  * returns _gf_false: if file cannot be promoted
  */
 static gf_boolean_t
-tier_can_promote_file (xlator_t *this, char const *file_name,
-                       struct iatt *current, gf_defrag_info_t *defrag)
+tier_can_promote_file(xlator_t *this, char const *file_name,
+                      struct iatt *current, gf_defrag_info_t *defrag)
 {
-        gf_boolean_t ret = _gf_false;
-        fsblkcnt_t estimated_usage = 0;
-
-        if (defrag->tier_conf.tier_max_promote_size &&
-            (current->ia_size > defrag->tier_conf.tier_max_promote_size)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "File %s (gfid:%s) with size (%lu) exceeds maxsize "
-                        "(%d) for promotion. File will not be promoted.",
-                        file_name,
-                        uuid_utoa(current->ia_gfid),
-                        current->ia_size,
-                        defrag->tier_conf.tier_max_promote_size);
-                goto err;
-        }
-
-        /* bypass further validations for TEST mode */
-        if (defrag->tier_conf.mode != TIER_MODE_WM) {
-                ret = _gf_true;
-                goto err;
-        }
-
-        /* convert the file size to blocks as per the block size of the
-         * destination tier
-         * NOTE: add (block_size - 1) to get the correct block size when
-         *       there is a remainder after a modulo
-         */
-        estimated_usage = ((current->ia_size + defrag->tier_conf.block_size - 1) /
-                                defrag->tier_conf.block_size) +
-                                defrag->tier_conf.blocks_used;
-
-        /* test if the estimated block usage goes above HI watermark */
-        if (GF_PERCENTAGE (estimated_usage, defrag->tier_conf.blocks_total) >=
-                        defrag->tier_conf.watermark_hi) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Estimated block count consumption on "
-                        "hot tier (%lu) exceeds hi watermark (%d%%). "
-                        "File will not be promoted.",
-                        estimated_usage,
-                        defrag->tier_conf.watermark_hi);
-                goto err;
-        }
+    gf_boolean_t ret = _gf_false;
+    fsblkcnt_t estimated_usage = 0;
+
+    if (defrag->tier_conf.tier_max_promote_size &&
+        (current->ia_size > defrag->tier_conf.tier_max_promote_size)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "File %s (gfid:%s) with size (%lu) exceeds maxsize "
+               "(%d) for promotion. File will not be promoted.",
+               file_name, uuid_utoa(current->ia_gfid), current->ia_size,
+               defrag->tier_conf.tier_max_promote_size);
+        goto err;
+    }
+
+    /* bypass further validations for TEST mode */
+    if (defrag->tier_conf.mode != TIER_MODE_WM) {
         ret = _gf_true;
+        goto err;
+    }
+
+    /* convert the file size to blocks as per the block size of the
+     * destination tier
+     * NOTE: add (block_size - 1) to get the correct block size when
+     *       there is a remainder after a modulo
+     */
+    estimated_usage = ((current->ia_size + defrag->tier_conf.block_size - 1) /
+                       defrag->tier_conf.block_size) +
+                      defrag->tier_conf.blocks_used;
+
+    /* test if the estimated block usage goes above HI watermark */
+    if (GF_PERCENTAGE(estimated_usage, defrag->tier_conf.blocks_total) >=
+        defrag->tier_conf.watermark_hi) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Estimated block count consumption on "
+               "hot tier (%lu) exceeds hi watermark (%d%%). "
+               "File will not be promoted.",
+               estimated_usage, defrag->tier_conf.watermark_hi);
+        goto err;
+    }
+    ret = _gf_true;
 err:
-        return ret;
+    return ret;
 }
 
 static int
-tier_set_migrate_data (dict_t *migrate_data)
+tier_set_migrate_data(dict_t *migrate_data)
 {
-        int    failed = 1;
-
-
-        failed = dict_set_str (migrate_data, GF_XATTR_FILE_MIGRATE_KEY, "force");
-        if (failed) {
-                goto bail_out;
-        }
-
-        /* Flag to suggest the xattr call is from migrator */
-        failed = dict_set_str (migrate_data, "from.migrator", "yes");
-        if (failed) {
-                goto bail_out;
-        }
-
-        /* Flag to suggest its a tiering migration
-         * The reason for this dic key-value is that
-         * promotions and demotions are multithreaded
-         * so the original frame from gf_defrag_start()
-         * is not carried. A new frame will be created when
-         * we do syncop_setxattr(). This does not have the
-         * frame->root->pid of the original frame. So we pass
-         * this dic key-value when we do syncop_setxattr() to do
-         * data migration and set the frame->root->pid to
-         * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
-         * calling dht_start_rebalance_task() */
-        failed = dict_set_str (migrate_data, TIERING_MIGRATION_KEY, "yes");
-        if (failed) {
-                goto bail_out;
-        }
-
-        failed = 0;
+    int failed = 1;
+
+    failed = dict_set_str(migrate_data, GF_XATTR_FILE_MIGRATE_KEY, "force");
+    if (failed) {
+        goto bail_out;
+    }
+
+    /* Flag to suggest the xattr call is from migrator */
+    failed = dict_set_str(migrate_data, "from.migrator", "yes");
+    if (failed) {
+        goto bail_out;
+    }
+
+    /* Flag to suggest its a tiering migration
+     * The reason for this dic key-value is that
+     * promotions and demotions are multithreaded
+     * so the original frame from gf_defrag_start()
+     * is not carried. A new frame will be created when
+     * we do syncop_setxattr(). This does not have the
+     * frame->root->pid of the original frame. So we pass
+     * this dic key-value when we do syncop_setxattr() to do
+     * data migration and set the frame->root->pid to
+     * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
+     * calling dht_start_rebalance_task() */
+    failed = dict_set_str(migrate_data, TIERING_MIGRATION_KEY, "yes");
+    if (failed) {
+        goto bail_out;
+    }
+
+    failed = 0;
 
 bail_out:
-        return failed;
+    return failed;
 }
 
 static char *
-tier_get_parent_path (xlator_t          *this,
-                      loc_t             *p_loc,
-                      struct iatt       *par_stbuf,
-                      int               *per_link_status)
+tier_get_parent_path(xlator_t *this, loc_t *p_loc, struct iatt *par_stbuf,
+                     int *per_link_status)
 {
-        int     ret             = -1;
-        char    *parent_path    = NULL;
-        dict_t  *xdata_request  = NULL;
-        dict_t  *xdata_response = NULL;
-
-
-        xdata_request = dict_new ();
-        if (!xdata_request) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to create xdata_request dict");
-                goto err;
-        }
-        ret = dict_set_int32 (xdata_request,
-                              GET_ANCESTRY_PATH_KEY, 42);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to set value to dict : key %s \n",
-                        GET_ANCESTRY_PATH_KEY);
-                goto err;
-        }
-
-        ret = syncop_lookup (this, p_loc, par_stbuf, NULL,
-                             xdata_request, &xdata_response);
-        /* When the parent gfid is a stale entry, the lookup
-         * will fail and stop the demotion process.
-         * The parent gfid can be stale when a huge folder is
-         * deleted while the files within it are being migrated
-         */
-        if (ret == -ESTALE) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_STALE_LOOKUP,
-                        "Stale entry in parent lookup for %s",
-                        uuid_utoa (p_loc->gfid));
-                *per_link_status = 1;
-                goto err;
-        } else if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Error in parent lookup for %s",
-                        uuid_utoa (p_loc->gfid));
-                *per_link_status = -1;
-                goto err;
-        }
-        ret = dict_get_str (xdata_response, GET_ANCESTRY_PATH_KEY, &parent_path);
-        if (ret || !parent_path) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to get parent path for %s",
-                        uuid_utoa (p_loc->gfid));
-                *per_link_status = -1;
-                goto err;
-        }
+    int ret = -1;
+    char *parent_path = NULL;
+    dict_t *xdata_request = NULL;
+    dict_t *xdata_response = NULL;
+
+    xdata_request = dict_new();
+    if (!xdata_request) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to create xdata_request dict");
+        goto err;
+    }
+    ret = dict_set_int32(xdata_request, GET_ANCESTRY_PATH_KEY, 42);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to set value to dict : key %s \n",
+               GET_ANCESTRY_PATH_KEY);
+        goto err;
+    }
+
+    ret = syncop_lookup(this, p_loc, par_stbuf, NULL, xdata_request,
+                        &xdata_response);
+    /* When the parent gfid is a stale entry, the lookup
+     * will fail and stop the demotion process.
+     * The parent gfid can be stale when a huge folder is
+     * deleted while the files within it are being migrated
+     */
+    if (ret == -ESTALE) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_STALE_LOOKUP,
+               "Stale entry in parent lookup for %s", uuid_utoa(p_loc->gfid));
+        *per_link_status = 1;
+        goto err;
+    } else if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
+               "Error in parent lookup for %s", uuid_utoa(p_loc->gfid));
+        *per_link_status = -1;
+        goto err;
+    }
+    ret = dict_get_str(xdata_response, GET_ANCESTRY_PATH_KEY, &parent_path);
+    if (ret || !parent_path) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to get parent path for %s", uuid_utoa(p_loc->gfid));
+        *per_link_status = -1;
+        goto err;
+    }
 
 err:
-        if (xdata_request) {
-                dict_unref (xdata_request);
-        }
+    if (xdata_request) {
+        dict_unref(xdata_request);
+    }
 
-        if (xdata_response) {
-                dict_unref (xdata_response);
-                xdata_response = NULL;
-        }
+    if (xdata_response) {
+        dict_unref(xdata_response);
+        xdata_response = NULL;
+    }
 
-        return parent_path;
+    return parent_path;
 }
 
 static int
-tier_get_file_name_and_path (xlator_t                   *this,
-                             uuid_t                     gfid,
-                             gfdb_link_info_t           *link_info,
-                             char const                 *parent_path,
-                             loc_t                      *loc,
-                             int                        *per_link_status)
+tier_get_file_name_and_path(xlator_t *this, uuid_t gfid,
+                            gfdb_link_info_t *link_info,
+                            char const *parent_path, loc_t *loc,
+                            int *per_link_status)
 {
-        int             ret     = -1;
-
-        loc->name = gf_strdup (link_info->file_name);
-        if (!loc->name) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Memory "
-                        "allocation failed for %s",
-                        uuid_utoa (gfid));
-                *per_link_status = -1;
-                goto err;
-        }
-        ret = gf_asprintf((char **)&(loc->path), "%s/%s", parent_path, loc->name);
-        if (ret < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed to "
-                        "construct file path for %s %s\n",
-                        parent_path, loc->name);
-                *per_link_status = -1;
-                goto err;
-        }
-
-        ret = 0;
+    int ret = -1;
+
+    loc->name = gf_strdup(link_info->file_name);
+    if (!loc->name) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Memory "
+               "allocation failed for %s",
+               uuid_utoa(gfid));
+        *per_link_status = -1;
+        goto err;
+    }
+    ret = gf_asprintf((char **)&(loc->path), "%s/%s", parent_path, loc->name);
+    if (ret < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to "
+               "construct file path for %s %s\n",
+               parent_path, loc->name);
+        *per_link_status = -1;
+        goto err;
+    }
+
+    ret = 0;
 
 err:
-        return ret;
+    return ret;
 }
 
 static int
-tier_lookup_file (xlator_t    *this,
-                  loc_t       *p_loc,
-                  loc_t       *loc,
-                  struct iatt *current,
-                  int         *per_link_status)
+tier_lookup_file(xlator_t *this, loc_t *p_loc, loc_t *loc, struct iatt *current,
+                 int *per_link_status)
 {
-        int     ret = -1;
-
-        ret = syncop_lookup (this, loc, current, NULL, NULL, NULL);
-
-        /* The file may be deleted even when the parent
-         * is available and the lookup will
-         * return a stale entry which would stop the
-         * migration. so if its a stale entry, then skip
-         * the file and keep migrating.
-         */
-        if (ret == -ESTALE) {
-                gf_msg (this->name, GF_LOG_WARNING, -ret,
-                        DHT_MSG_STALE_LOOKUP,
-                        "Stale lookup for %s",
-                        uuid_utoa (p_loc->gfid));
-                *per_link_status = 1;
-                goto err;
-        } else if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed to "
-                        "lookup file %s\n", loc->name);
-                *per_link_status = -1;
-                goto err;
-        }
-        ret = 0;
+    int ret = -1;
+
+    ret = syncop_lookup(this, loc, current, NULL, NULL, NULL);
+
+    /* The file may be deleted even when the parent
+     * is available and the lookup will
+     * return a stale entry which would stop the
+     * migration. so if its a stale entry, then skip
+     * the file and keep migrating.
+     */
+    if (ret == -ESTALE) {
+        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_STALE_LOOKUP,
+               "Stale lookup for %s", uuid_utoa(p_loc->gfid));
+        *per_link_status = 1;
+        goto err;
+    } else if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to "
+               "lookup file %s\n",
+               loc->name);
+        *per_link_status = -1;
+        goto err;
+    }
+    ret = 0;
 
 err:
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-tier_is_file_already_at_destination (xlator_t           *src_subvol,
-                                     query_cbk_args_t   *query_cbk_args,
-                                     dht_conf_t         *conf,
-                                     int                *per_link_status)
+tier_is_file_already_at_destination(xlator_t *src_subvol,
+                                    query_cbk_args_t *query_cbk_args,
+                                    dht_conf_t *conf, int *per_link_status)
 {
-        gf_boolean_t    at_destination = _gf_true;
-
-        if (src_subvol == NULL) {
-                *per_link_status = 1;
-                goto err;
-        }
-        if (query_cbk_args->is_promotion &&
-            src_subvol == conf->subvolumes[1]) {
-                *per_link_status = 1;
-                goto err;
-        }
-
-        if (!query_cbk_args->is_promotion &&
-            src_subvol == conf->subvolumes[0]) {
-                *per_link_status = 1;
-                goto err;
-        }
-        at_destination = _gf_false;
+    gf_boolean_t at_destination = _gf_true;
+
+    if (src_subvol == NULL) {
+        *per_link_status = 1;
+        goto err;
+    }
+    if (query_cbk_args->is_promotion && src_subvol == conf->subvolumes[1]) {
+        *per_link_status = 1;
+        goto err;
+    }
+
+    if (!query_cbk_args->is_promotion && src_subvol == conf->subvolumes[0]) {
+        *per_link_status = 1;
+        goto err;
+    }
+    at_destination = _gf_false;
 
 err:
-        return at_destination;
+    return at_destination;
 }
 
 static void
-tier_update_migration_counters (query_cbk_args_t        *query_cbk_args,
-                                gf_defrag_info_t        *defrag,
-                                uint64_t                *total_migrated_bytes,
-                                int                     *total_files)
+tier_update_migration_counters(query_cbk_args_t *query_cbk_args,
+                               gf_defrag_info_t *defrag,
+                               uint64_t *total_migrated_bytes, int *total_files)
 {
-        if (query_cbk_args->is_promotion) {
-                defrag->total_files_promoted++;
-                *total_migrated_bytes +=
-                        defrag->tier_conf.st_last_promoted_size;
-                pthread_mutex_lock (&dm_stat_mutex);
-                defrag->tier_conf.blocks_used +=
-                        defrag->tier_conf.st_last_promoted_size;
-                pthread_mutex_unlock (&dm_stat_mutex);
-        } else {
-                defrag->total_files_demoted++;
-                *total_migrated_bytes +=
-                        defrag->tier_conf.st_last_demoted_size;
-                pthread_mutex_lock (&dm_stat_mutex);
-                defrag->tier_conf.blocks_used -=
-                        defrag->tier_conf.st_last_demoted_size;
-                pthread_mutex_unlock (&dm_stat_mutex);
-        }
-        if (defrag->tier_conf.blocks_total) {
-                pthread_mutex_lock (&dm_stat_mutex);
-                defrag->tier_conf.percent_full =
-                        GF_PERCENTAGE (defrag->tier_conf.blocks_used,
-                                        defrag->tier_conf.blocks_total);
-                pthread_mutex_unlock (&dm_stat_mutex);
-        }
-
-        (*total_files)++;
+    if (query_cbk_args->is_promotion) {
+        defrag->total_files_promoted++;
+        *total_migrated_bytes += defrag->tier_conf.st_last_promoted_size;
+        pthread_mutex_lock(&dm_stat_mutex);
+        defrag->tier_conf.blocks_used += defrag->tier_conf
+                                             .st_last_promoted_size;
+        pthread_mutex_unlock(&dm_stat_mutex);
+    } else {
+        defrag->total_files_demoted++;
+        *total_migrated_bytes += defrag->tier_conf.st_last_demoted_size;
+        pthread_mutex_lock(&dm_stat_mutex);
+        defrag->tier_conf.blocks_used -= defrag->tier_conf.st_last_demoted_size;
+        pthread_mutex_unlock(&dm_stat_mutex);
+    }
+    if (defrag->tier_conf.blocks_total) {
+        pthread_mutex_lock(&dm_stat_mutex);
+        defrag->tier_conf.percent_full = GF_PERCENTAGE(
+            defrag->tier_conf.blocks_used, defrag->tier_conf.blocks_total);
+        pthread_mutex_unlock(&dm_stat_mutex);
+    }
+
+    (*total_files)++;
 }
 
 static int
-tier_migrate_link (xlator_t            *this,
-                   dht_conf_t          *conf,
-                   uuid_t              gfid,
-                   gfdb_link_info_t    *link_info,
-                   gf_defrag_info_t    *defrag,
-                   query_cbk_args_t    *query_cbk_args,
-                   dict_t              *migrate_data,
-                   int                 *per_link_status,
-                   int                 *total_files,
-                   uint64_t            *total_migrated_bytes)
+tier_migrate_link(xlator_t *this, dht_conf_t *conf, uuid_t gfid,
+                  gfdb_link_info_t *link_info, gf_defrag_info_t *defrag,
+                  query_cbk_args_t *query_cbk_args, dict_t *migrate_data,
+                  int *per_link_status, int *total_files,
+                  uint64_t *total_migrated_bytes)
 {
-        int             ret             = -1;
-        struct iatt     current         = {0,};
-        struct iatt     par_stbuf       = {0,};
-        loc_t           p_loc           = {0,};
-        loc_t           loc             = {0,};
-        xlator_t        *src_subvol     = NULL;
-        inode_t         *linked_inode   = NULL;
-        char            *parent_path    = NULL;
-
-
-        /* Lookup for parent and get the path of parent */
-        gf_uuid_copy (p_loc.gfid, link_info->pargfid);
-        p_loc.inode = inode_new (defrag->root_inode->table);
-        if (!p_loc.inode) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to create reference to inode"
-                        " for %s", uuid_utoa (p_loc.gfid));
-
-                *per_link_status = -1;
-                goto err;
-        }
-
-        parent_path = tier_get_parent_path (this, &p_loc, &par_stbuf,
-                                            per_link_status);
-        if (!parent_path) {
-                goto err;
-        }
-
-        linked_inode = inode_link (p_loc.inode, NULL, NULL, &par_stbuf);
-        inode_unref (p_loc.inode);
-        p_loc.inode = linked_inode;
-
-
-        /* Preparing File Inode */
-        gf_uuid_copy (loc.gfid, gfid);
-        loc.inode = inode_new (defrag->root_inode->table);
-        gf_uuid_copy (loc.pargfid, link_info->pargfid);
-        loc.parent = inode_ref (p_loc.inode);
-
-        /* Get filename and Construct file path */
-        if (tier_get_file_name_and_path (this, gfid, link_info,
-                                         parent_path, &loc, per_link_status) != 0) {
-                goto err;
-        }
-        gf_uuid_copy (loc.parent->gfid, link_info->pargfid);
-
-        /* lookup file inode */
-        if (tier_lookup_file (this, &p_loc, &loc,
-                              &current, per_link_status) != 0) {
-                goto err;
-        }
-
-        if (query_cbk_args->is_promotion) {
-                if (!tier_can_promote_file (this,
-                                            link_info->file_name,
-                                            &current,
-                                            defrag)) {
-                        *per_link_status = 1;
-                        goto err;
-                }
-        }
-
-        linked_inode = inode_link (loc.inode, NULL, NULL, &current);
-        inode_unref (loc.inode);
-        loc.inode = linked_inode;
-
-
-        /*
-         * Do not promote/demote if file already is where it
-         * should be. It means another brick moved the file
-         * so is not an error. So we set per_link_status = 1
-         * so that we ignore counting this.
-         */
-        src_subvol = dht_subvol_get_cached (this, loc.inode);
-
-        if (tier_is_file_already_at_destination (src_subvol, query_cbk_args,
-                                                 conf, per_link_status)) {
-                goto err;
-        }
-
-        gf_msg_debug (this->name, 0, "Tier %s: src_subvol %s file %s",
-                      (query_cbk_args->is_promotion ?  "promote" : "demote"),
-                      src_subvol->name,
-                      loc.path);
-
-
-        ret = tier_check_same_node (this, &loc, defrag);
-        if (ret != 0) {
-                if (ret < 0) {
-                        *per_link_status = -1;
-                        goto err;
-                }
-                ret = 0;
-                /* By setting per_link_status to 1 we are
-                 * ignoring this status and will not be counting
-                 * this file for migration */
-                *per_link_status = 1;
-                goto err;
-        }
-
-        gf_uuid_copy (loc.gfid, loc.inode->gfid);
-
-        if (gf_defrag_get_pause_state (&defrag->tier_conf) != TIER_RUNNING) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Tiering paused. "
-                        "Exiting tier_migrate_link");
-                goto err;
-        }
-
-        ret = tier_migrate (this, query_cbk_args->is_promotion,
-                            migrate_data, &loc, &defrag->tier_conf);
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed to "
-                        "migrate %s ", loc.path);
-                *per_link_status = -1;
-                goto err;
+    int ret = -1;
+    struct iatt current = {
+        0,
+    };
+    struct iatt par_stbuf = {
+        0,
+    };
+    loc_t p_loc = {
+        0,
+    };
+    loc_t loc = {
+        0,
+    };
+    xlator_t *src_subvol = NULL;
+    inode_t *linked_inode = NULL;
+    char *parent_path = NULL;
+
+    /* Lookup for parent and get the path of parent */
+    gf_uuid_copy(p_loc.gfid, link_info->pargfid);
+    p_loc.inode = inode_new(defrag->root_inode->table);
+    if (!p_loc.inode) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to create reference to inode"
+               " for %s",
+               uuid_utoa(p_loc.gfid));
+
+        *per_link_status = -1;
+        goto err;
+    }
+
+    parent_path = tier_get_parent_path(this, &p_loc, &par_stbuf,
+                                       per_link_status);
+    if (!parent_path) {
+        goto err;
+    }
+
+    linked_inode = inode_link(p_loc.inode, NULL, NULL, &par_stbuf);
+    inode_unref(p_loc.inode);
+    p_loc.inode = linked_inode;
+
+    /* Preparing File Inode */
+    gf_uuid_copy(loc.gfid, gfid);
+    loc.inode = inode_new(defrag->root_inode->table);
+    gf_uuid_copy(loc.pargfid, link_info->pargfid);
+    loc.parent = inode_ref(p_loc.inode);
+
+    /* Get filename and Construct file path */
+    if (tier_get_file_name_and_path(this, gfid, link_info, parent_path, &loc,
+                                    per_link_status) != 0) {
+        goto err;
+    }
+    gf_uuid_copy(loc.parent->gfid, link_info->pargfid);
+
+    /* lookup file inode */
+    if (tier_lookup_file(this, &p_loc, &loc, &current, per_link_status) != 0) {
+        goto err;
+    }
+
+    if (query_cbk_args->is_promotion) {
+        if (!tier_can_promote_file(this, link_info->file_name, &current,
+                                   defrag)) {
+            *per_link_status = 1;
+            goto err;
+        }
+    }
+
+    linked_inode = inode_link(loc.inode, NULL, NULL, &current);
+    inode_unref(loc.inode);
+    loc.inode = linked_inode;
+
+    /*
+     * Do not promote/demote if file already is where it
+     * should be. It means another brick moved the file
+     * so is not an error. So we set per_link_status = 1
+     * so that we ignore counting this.
+     */
+    src_subvol = dht_subvol_get_cached(this, loc.inode);
+
+    if (tier_is_file_already_at_destination(src_subvol, query_cbk_args, conf,
+                                            per_link_status)) {
+        goto err;
+    }
+
+    gf_msg_debug(this->name, 0, "Tier %s: src_subvol %s file %s",
+                 (query_cbk_args->is_promotion ? "promote" : "demote"),
+                 src_subvol->name, loc.path);
+
+    ret = tier_check_same_node(this, &loc, defrag);
+    if (ret != 0) {
+        if (ret < 0) {
+            *per_link_status = -1;
+            goto err;
         }
-
-        tier_update_migration_counters (query_cbk_args, defrag,
-                                        total_migrated_bytes, total_files);
-
         ret = 0;
+        /* By setting per_link_status to 1 we are
+         * ignoring this status and will not be counting
+         * this file for migration */
+        *per_link_status = 1;
+        goto err;
+    }
+
+    gf_uuid_copy(loc.gfid, loc.inode->gfid);
+
+    if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Tiering paused. "
+               "Exiting tier_migrate_link");
+        goto err;
+    }
+
+    ret = tier_migrate(this, query_cbk_args->is_promotion, migrate_data, &loc,
+                       &defrag->tier_conf);
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to "
+               "migrate %s ",
+               loc.path);
+        *per_link_status = -1;
+        goto err;
+    }
+
+    tier_update_migration_counters(query_cbk_args, defrag, total_migrated_bytes,
+                                   total_files);
+
+    ret = 0;
 
 err:
-        GF_FREE ((char *) loc.name);
-        loc.name = NULL;
-        loc_wipe (&loc);
-        loc_wipe (&p_loc);
-
-        if ((*total_files >= defrag->tier_conf.max_migrate_files)
-            || (*total_migrated_bytes > defrag->tier_conf.max_migrate_bytes)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Reached cycle migration limit."
-                        "migrated bytes %"PRId64" files %d",
-                        *total_migrated_bytes,
-                        *total_files);
-                ret = -1;
-        }
-
-        return ret;
+    GF_FREE((char *)loc.name);
+    loc.name = NULL;
+    loc_wipe(&loc);
+    loc_wipe(&p_loc);
+
+    if ((*total_files >= defrag->tier_conf.max_migrate_files) ||
+        (*total_migrated_bytes > defrag->tier_conf.max_migrate_bytes)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Reached cycle migration limit."
+               "migrated bytes %" PRId64 " files %d",
+               *total_migrated_bytes, *total_files);
+        ret = -1;
+    }
+
+    return ret;
 }
 
-
 static int
-tier_migrate_using_query_file (void *_args)
+tier_migrate_using_query_file(void *_args)
 {
-        int ret                                 = -1;
-        query_cbk_args_t *query_cbk_args        = (query_cbk_args_t *) _args;
-        xlator_t *this                          = NULL;
-        gf_defrag_info_t *defrag                = NULL;
-        gfdb_query_record_t *query_record       = NULL;
-        gfdb_link_info_t *link_info             = NULL;
-        dict_t *migrate_data                    = NULL;
-        /*
-         * per_file_status and per_link_status
-         *  0  : success
-         * -1 : failure
-         *  1  : ignore the status and don't count for migration
-         * */
-        int per_file_status                     = 0;
-        int per_link_status                     = 0;
-        int total_status                        = 0;
-        dht_conf_t   *conf                      = NULL;
-        uint64_t total_migrated_bytes           = 0;
-        int total_files                         = 0;
-        loc_t root_loc                          = { 0 };
-        gfdb_time_t  start_time                 = { 0 };
-        gfdb_time_t  current_time               = { 0 };
-        int total_time                          = 0;
-        int max_time                            = 0;
-        gf_boolean_t emergency_demote_mode      = _gf_false;
-
-
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args, out);
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args->this, out);
-        this = query_cbk_args->this;
-        GF_VALIDATE_OR_GOTO (this->name, query_cbk_args->defrag, out);
-        GF_VALIDATE_OR_GOTO (this->name, query_cbk_args->qfile_array, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
-
-        conf = this->private;
-
-        defrag = query_cbk_args->defrag;
-        migrate_data = dict_new ();
-        if (!migrate_data)
-                goto out;
-
-        emergency_demote_mode = (!query_cbk_args->is_promotion &&
-                                 is_hot_tier_full(&defrag->tier_conf));
-
-        if (tier_set_migrate_data (migrate_data) != 0) {
-                goto out;
+    int ret = -1;
+    query_cbk_args_t *query_cbk_args = (query_cbk_args_t *)_args;
+    xlator_t *this = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    gfdb_query_record_t *query_record = NULL;
+    gfdb_link_info_t *link_info = NULL;
+    dict_t *migrate_data = NULL;
+    /*
+     * per_file_status and per_link_status
+     *  0  : success
+     * -1 : failure
+     *  1  : ignore the status and don't count for migration
+     * */
+    int per_file_status = 0;
+    int per_link_status = 0;
+    int total_status = 0;
+    dht_conf_t *conf = NULL;
+    uint64_t total_migrated_bytes = 0;
+    int total_files = 0;
+    loc_t root_loc = {0};
+    gfdb_time_t start_time = {0};
+    gfdb_time_t current_time = {0};
+    int total_time = 0;
+    int max_time = 0;
+    gf_boolean_t emergency_demote_mode = _gf_false;
+
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args, out);
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
+    this = query_cbk_args->this;
+    GF_VALIDATE_OR_GOTO(this->name, query_cbk_args->defrag, out);
+    GF_VALIDATE_OR_GOTO(this->name, query_cbk_args->qfile_array, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+
+    conf = this->private;
+
+    defrag = query_cbk_args->defrag;
+    migrate_data = dict_new();
+    if (!migrate_data)
+        goto out;
+
+    emergency_demote_mode = (!query_cbk_args->is_promotion &&
+                             is_hot_tier_full(&defrag->tier_conf));
+
+    if (tier_set_migrate_data(migrate_data) != 0) {
+        goto out;
+    }
+
+    dht_build_root_loc(defrag->root_inode, &root_loc);
+
+    ret = gettimeofday(&start_time, NULL);
+    if (query_cbk_args->is_promotion) {
+        max_time = defrag->tier_conf.tier_promote_frequency;
+    } else {
+        max_time = defrag->tier_conf.tier_demote_frequency;
+    }
+
+    /* Per file */
+    while ((ret = read_query_record_list(query_cbk_args->qfile_array,
+                                         &query_record)) != 0) {
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "Failed to fetch query record "
+                   "from query file");
+            goto out;
         }
 
-        dht_build_root_loc (defrag->root_inode, &root_loc);
-
-        ret = gettimeofday (&start_time, NULL);
-        if (query_cbk_args->is_promotion) {
-                max_time = defrag->tier_conf.tier_promote_frequency;
-        } else {
-                max_time = defrag->tier_conf.tier_demote_frequency;
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "Exiting tier migration as"
+                   "defrag status is not started");
+            goto out;
         }
 
-        /* Per file */
-        while ((ret = read_query_record_list (query_cbk_args->qfile_array,
-              &query_record)) != 0) {
-
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "Failed to fetch query record "
-                                "from query file");
-                        goto out;
-                }
-
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        ret = -1;
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "Exiting tier migration as"
-                                "defrag status is not started");
-                        goto out;
-                }
-
-                ret = gettimeofday (&current_time, NULL);
-                if (ret < 0) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "Could not get current time.");
-                        goto out;
-                }
+        ret = gettimeofday(&current_time, NULL);
+        if (ret < 0) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "Could not get current time.");
+            goto out;
+        }
 
-                total_time = current_time.tv_sec - start_time.tv_sec;
-                if (total_time > max_time) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LOG_TIER_STATUS,
-                                "Max cycle time reached. Exiting migration.");
-                        goto out;
-                }
+        total_time = current_time.tv_sec - start_time.tv_sec;
+        if (total_time > max_time) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                   "Max cycle time reached. Exiting migration.");
+            goto out;
+        }
 
-                per_file_status      = 0;
-                per_link_status      = 0;
+        per_file_status = 0;
+        per_link_status = 0;
 
-                if (gf_defrag_get_pause_state (&defrag->tier_conf)
-                    != TIER_RUNNING) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LOG_TIER_STATUS,
-                                "Tiering paused. "
-                                "Exiting tier_migrate_using_query_file");
-                        break;
-                }
+        if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                   "Tiering paused. "
+                   "Exiting tier_migrate_using_query_file");
+            break;
+        }
 
-                if (defrag->tier_conf.mode == TIER_MODE_WM) {
-                        ret = tier_get_fs_stat (this, &root_loc);
-                        if (ret != 0) {
-                                gfdb_methods.gfdb_query_record_free (query_record);
-                                query_record = NULL;
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_LOG_TIER_STATUS,
-                                        "tier_get_fs_stat() FAILED ... "
-                                        "skipping file migrations until next cycle");
-                                break;
-                        }
-
-                        if (!tier_do_migration (this, query_cbk_args->is_promotion)) {
-                                gfdb_methods.gfdb_query_record_free (query_record);
-                                query_record = NULL;
-
-                                /* We have crossed the high watermark. Stop processing
-                                 * files if this is a promotion cycle so demotion gets
-                                 * a chance to start if not already running*/
-
-                                if (query_cbk_args->is_promotion &&
-                                    is_hot_tier_full (&defrag->tier_conf)) {
-
-                                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                                DHT_MSG_LOG_TIER_STATUS,
-                                                "High watermark crossed during "
-                                                "promotion. Exiting "
-                                                "tier_migrate_using_query_file");
-                                        break;
-                                }
-                                continue;
-                        }
-                }
+        if (defrag->tier_conf.mode == TIER_MODE_WM) {
+            ret = tier_get_fs_stat(this, &root_loc);
+            if (ret != 0) {
+                gfdb_methods.gfdb_query_record_free(query_record);
+                query_record = NULL;
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
+                       "tier_get_fs_stat() FAILED ... "
+                       "skipping file migrations until next cycle");
+                break;
+            }
 
-                per_link_status = 0;
+            if (!tier_do_migration(this, query_cbk_args->is_promotion)) {
+                gfdb_methods.gfdb_query_record_free(query_record);
+                query_record = NULL;
 
-                /* For now we only support single link migration. And we will
-                 * ignore other hard links in the link info list of query record
-                 * TODO: Multiple hard links migration */
-                if (!list_empty (&query_record->link_list)) {
-                        link_info = list_first_entry (&query_record->link_list,
-                                                      gfdb_link_info_t, list);
+                /* We have crossed the high watermark. Stop processing
+                 * files if this is a promotion cycle so demotion gets
+                 * a chance to start if not already running*/
+
+                if (query_cbk_args->is_promotion &&
+                    is_hot_tier_full(&defrag->tier_conf)) {
+                    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                           "High watermark crossed during "
+                           "promotion. Exiting "
+                           "tier_migrate_using_query_file");
+                    break;
                 }
-                if (link_info != NULL) {
-                        if (tier_migrate_link (this,
-                                               conf,
-                                               query_record->gfid,
-                                               link_info,
-                                               defrag,
-                                               query_cbk_args,
-                                               migrate_data,
-                                               &per_link_status,
-                                               &total_files,
-                                               &total_migrated_bytes) != 0) {
-                                gf_msg (this->name, GF_LOG_INFO, 0,
-                                        DHT_MSG_LOG_TIER_STATUS,
-                                        "%s failed for %s(gfid:%s)",
-                                        (query_cbk_args->is_promotion ?
-                                         "Promotion" : "Demotion"),
-                                        link_info->file_name,
-                                        uuid_utoa (query_record->gfid));
-                        }
-                }
-                per_file_status = per_link_status;
-
-                if (per_file_status < 0) {/* Failure */
-                        pthread_mutex_lock (&dm_stat_mutex);
-                        defrag->total_failures++;
-                        pthread_mutex_unlock (&dm_stat_mutex);
-                } else if (per_file_status == 0) {/* Success */
-                        pthread_mutex_lock (&dm_stat_mutex);
-                        defrag->total_files++;
-                        pthread_mutex_unlock (&dm_stat_mutex);
-                } else if (per_file_status == 1) {/* Ignore */
-                        per_file_status = 0;
-                        /* Since this attempt was ignored we
-                         * decrement the lookup count*/
-                        pthread_mutex_lock (&dm_stat_mutex);
-                        defrag->num_files_lookedup--;
-                        pthread_mutex_unlock (&dm_stat_mutex);
-                }
-                total_status = total_status + per_file_status;
-                per_link_status = 0;
-                per_file_status = 0;
-
-                gfdb_methods.gfdb_query_record_free (query_record);
-                query_record = NULL;
+                continue;
+            }
+        }
+
+        per_link_status = 0;
+
+        /* For now we only support single link migration. And we will
+         * ignore other hard links in the link info list of query record
+         * TODO: Multiple hard links migration */
+        if (!list_empty(&query_record->link_list)) {
+            link_info = list_first_entry(&query_record->link_list,
+                                         gfdb_link_info_t, list);
+        }
+        if (link_info != NULL) {
+            if (tier_migrate_link(this, conf, query_record->gfid, link_info,
+                                  defrag, query_cbk_args, migrate_data,
+                                  &per_link_status, &total_files,
+                                  &total_migrated_bytes) != 0) {
+                gf_msg(
+                    this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                    "%s failed for %s(gfid:%s)",
+                    (query_cbk_args->is_promotion ? "Promotion" : "Demotion"),
+                    link_info->file_name, uuid_utoa(query_record->gfid));
+            }
+        }
+        per_file_status = per_link_status;
+
+        if (per_file_status < 0) { /* Failure */
+            pthread_mutex_lock(&dm_stat_mutex);
+            defrag->total_failures++;
+            pthread_mutex_unlock(&dm_stat_mutex);
+        } else if (per_file_status == 0) { /* Success */
+            pthread_mutex_lock(&dm_stat_mutex);
+            defrag->total_files++;
+            pthread_mutex_unlock(&dm_stat_mutex);
+        } else if (per_file_status == 1) { /* Ignore */
+            per_file_status = 0;
+            /* Since this attempt was ignored we
+             * decrement the lookup count*/
+            pthread_mutex_lock(&dm_stat_mutex);
+            defrag->num_files_lookedup--;
+            pthread_mutex_unlock(&dm_stat_mutex);
+        }
+        total_status = total_status + per_file_status;
+        per_link_status = 0;
+        per_file_status = 0;
+
+        gfdb_methods.gfdb_query_record_free(query_record);
+        query_record = NULL;
 
-                /* If we are demoting and the entry watermark was HI, then
-                 * we are done with emergency demotions if the current
-                 * watermark has fallen below hi-watermark level
-                 */
-                if (emergency_demote_mode) {
-                        if (tier_check_watermark (this) == 0) {
-                                if (!is_hot_tier_full (&defrag->tier_conf)) {
-                                        break;
-                                }
-                        }
+        /* If we are demoting and the entry watermark was HI, then
+         * we are done with emergency demotions if the current
+         * watermark has fallen below hi-watermark level
+         */
+        if (emergency_demote_mode) {
+            if (tier_check_watermark(this) == 0) {
+                if (!is_hot_tier_full(&defrag->tier_conf)) {
+                    break;
                 }
+            }
         }
+    }
 
 out:
-        if (migrate_data)
-                dict_unref (migrate_data);
+    if (migrate_data)
+        dict_unref(migrate_data);
 
-        gfdb_methods.gfdb_query_record_free (query_record);
-        query_record = NULL;
+    gfdb_methods.gfdb_query_record_free(query_record);
+    query_record = NULL;
 
-        return total_status;
+    return total_status;
 }
 
-
 /* This is the call back function per record/file from data base */
 static int
-tier_gf_query_callback (gfdb_query_record_t *gfdb_query_record,
-                        void *_args) {
-        int ret = -1;
-        query_cbk_args_t *query_cbk_args = _args;
-
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args, out);
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args->defrag, out);
-        GF_VALIDATE_OR_GOTO ("tier", (query_cbk_args->query_fd > 0), out);
-
-        ret = gfdb_methods.gfdb_write_query_record (query_cbk_args->query_fd,
-                                                        gfdb_query_record);
-        if (ret) {
-                gf_msg ("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                        "Failed writing query record to query file");
-                goto out;
-        }
-
-        pthread_mutex_lock (&dm_stat_mutex);
-        query_cbk_args->defrag->num_files_lookedup++;
-        pthread_mutex_unlock (&dm_stat_mutex);
-
-        ret = 0;
+tier_gf_query_callback(gfdb_query_record_t *gfdb_query_record, void *_args)
+{
+    int ret = -1;
+    query_cbk_args_t *query_cbk_args = _args;
+
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args, out);
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->defrag, out);
+    GF_VALIDATE_OR_GOTO("tier", (query_cbk_args->query_fd > 0), out);
+
+    ret = gfdb_methods.gfdb_write_query_record(query_cbk_args->query_fd,
+                                               gfdb_query_record);
+    if (ret) {
+        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed writing query record to query file");
+        goto out;
+    }
+
+    pthread_mutex_lock(&dm_stat_mutex);
+    query_cbk_args->defrag->num_files_lookedup++;
+    pthread_mutex_unlock(&dm_stat_mutex);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
-
-
 /* Create query file in tier process */
 static int
-tier_process_self_query (tier_brick_list_t *local_brick, void *args)
+tier_process_self_query(tier_brick_list_t *local_brick, void *args)
 {
-        int ret                                         = -1;
-        char *db_path                                   = NULL;
-        query_cbk_args_t *query_cbk_args                = NULL;
-        xlator_t *this                                  = NULL;
-        gfdb_conn_node_t *conn_node                     = NULL;
-        dict_t *params_dict                             = NULL;
-        dict_t *ctr_ipc_dict                            = NULL;
-        gfdb_brick_info_t *gfdb_brick_info              = args;
-
-        /*Init of all the essentials*/
-        GF_VALIDATE_OR_GOTO ("tier", gfdb_brick_info , out);
-        query_cbk_args = gfdb_brick_info->_query_cbk_args;
-
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args->this, out);
-        this = query_cbk_args->this;
-
-        GF_VALIDATE_OR_GOTO (this->name,
-                             gfdb_brick_info->_query_cbk_args, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->xlator, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->brick_db_path, out);
-
-        db_path = local_brick->brick_db_path;
-
-        /*Preparing DB parameters before init_db i.e getting db connection*/
-        params_dict = dict_new ();
-        if (!params_dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "DB Params cannot initialized");
-                goto out;
-        }
-        SET_DB_PARAM_TO_DICT(this->name, params_dict,
-                             (char *) gfdb_methods.get_db_path_key(),
-                             db_path, ret, out);
-
-        /*Get the db connection*/
-        conn_node = gfdb_methods.init_db ((void *)params_dict, dht_tier_db_type);
-        if (!conn_node) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "FATAL: Failed initializing db operations");
-                         goto out;
-        }
-
-        /* Query for eligible files from db */
-        query_cbk_args->query_fd = open (local_brick->qfile_path,
-                        O_WRONLY | O_CREAT | O_APPEND,
-                        S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-        if (query_cbk_args->query_fd < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, errno,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to open query file %s",
-                        local_brick->qfile_path);
-                goto out;
-        }
-        if (!gfdb_brick_info->_gfdb_promote) {
-                if (query_cbk_args->defrag->tier_conf.watermark_last ==
-                        TIER_WM_HI) {
-                        /* emergency demotion mode */
-                        ret = gfdb_methods.find_all (conn_node,
-                                tier_gf_query_callback,
-                                (void *)query_cbk_args,
-                                query_cbk_args->defrag->tier_conf.
-                                        query_limit);
-                } else {
-                        if (query_cbk_args->defrag->write_freq_threshold == 0 &&
-                            query_cbk_args->defrag->read_freq_threshold == 0) {
-                                ret = gfdb_methods.find_unchanged_for_time (
-                                                conn_node,
-                                                tier_gf_query_callback,
-                                                (void *)query_cbk_args,
-                                                gfdb_brick_info->time_stamp);
-                        } else {
-                                ret = gfdb_methods.find_unchanged_for_time_freq (
-                                        conn_node,
-                                        tier_gf_query_callback,
-                                        (void *)query_cbk_args,
-                                        gfdb_brick_info->time_stamp,
-                                        query_cbk_args->defrag->
-                                                        write_freq_threshold,
-                                        query_cbk_args->defrag->
-                                                        read_freq_threshold,
-                                        _gf_false);
-                        }
-                }
+    int ret = -1;
+    char *db_path = NULL;
+    query_cbk_args_t *query_cbk_args = NULL;
+    xlator_t *this = NULL;
+    gfdb_conn_node_t *conn_node = NULL;
+    dict_t *params_dict = NULL;
+    dict_t *ctr_ipc_dict = NULL;
+    gfdb_brick_info_t *gfdb_brick_info = args;
+
+    /*Init of all the essentials*/
+    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
+    query_cbk_args = gfdb_brick_info->_query_cbk_args;
+
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
+    this = query_cbk_args->this;
+
+    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
+
+    db_path = local_brick->brick_db_path;
+
+    /*Preparing DB parameters before init_db i.e getting db connection*/
+    params_dict = dict_new();
+    if (!params_dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "DB Params cannot initialized");
+        goto out;
+    }
+    SET_DB_PARAM_TO_DICT(this->name, params_dict,
+                         (char *)gfdb_methods.get_db_path_key(), db_path, ret,
+                         out);
+
+    /*Get the db connection*/
+    conn_node = gfdb_methods.init_db((void *)params_dict, dht_tier_db_type);
+    if (!conn_node) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "FATAL: Failed initializing db operations");
+        goto out;
+    }
+
+    /* Query for eligible files from db */
+    query_cbk_args->query_fd = open(local_brick->qfile_path,
+                                    O_WRONLY | O_CREAT | O_APPEND,
+                                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+    if (query_cbk_args->query_fd < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, errno, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to open query file %s", local_brick->qfile_path);
+        goto out;
+    }
+    if (!gfdb_brick_info->_gfdb_promote) {
+        if (query_cbk_args->defrag->tier_conf.watermark_last == TIER_WM_HI) {
+            /* emergency demotion mode */
+            ret = gfdb_methods.find_all(
+                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
+                query_cbk_args->defrag->tier_conf.query_limit);
         } else {
-                if (query_cbk_args->defrag->write_freq_threshold == 0 &&
-                        query_cbk_args->defrag->read_freq_threshold == 0) {
-                        ret = gfdb_methods.find_recently_changed_files (
-                                conn_node,
-                                tier_gf_query_callback,
-                                (void *)query_cbk_args,
-                                gfdb_brick_info->time_stamp);
-                } else {
-                        ret = gfdb_methods.find_recently_changed_files_freq (
-                                conn_node,
-                                tier_gf_query_callback,
-                                (void *)query_cbk_args,
-                                gfdb_brick_info->time_stamp,
-                                query_cbk_args->defrag->write_freq_threshold,
-                                query_cbk_args->defrag->read_freq_threshold,
-                                _gf_false);
-                }
-        }
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "FATAL: query from db failed");
-                        goto out;
-        }
-
-        /*Clear the heat on the DB entries*/
-        /*Preparing ctr_ipc_dict*/
-        ctr_ipc_dict = dict_new ();
-        if (!ctr_ipc_dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "ctr_ipc_dict cannot initialized");
-                goto out;
-        }
-
-        SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict,
-                             GFDB_IPC_CTR_KEY, GFDB_IPC_CTR_CLEAR_OPS,
-                             ret, out);
-
-        ret = syncop_ipc (local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
-                                                                        NULL);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed clearing the heat "
-                        "on db %s error %d", local_brick->brick_db_path, ret);
-                goto out;
-        }
-
-        ret = 0;
+            if (query_cbk_args->defrag->write_freq_threshold == 0 &&
+                query_cbk_args->defrag->read_freq_threshold == 0) {
+                ret = gfdb_methods.find_unchanged_for_time(
+                    conn_node, tier_gf_query_callback, (void *)query_cbk_args,
+                    gfdb_brick_info->time_stamp);
+            } else {
+                ret = gfdb_methods.find_unchanged_for_time_freq(
+                    conn_node, tier_gf_query_callback, (void *)query_cbk_args,
+                    gfdb_brick_info->time_stamp,
+                    query_cbk_args->defrag->write_freq_threshold,
+                    query_cbk_args->defrag->read_freq_threshold, _gf_false);
+            }
+        }
+    } else {
+        if (query_cbk_args->defrag->write_freq_threshold == 0 &&
+            query_cbk_args->defrag->read_freq_threshold == 0) {
+            ret = gfdb_methods.find_recently_changed_files(
+                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
+                gfdb_brick_info->time_stamp);
+        } else {
+            ret = gfdb_methods.find_recently_changed_files_freq(
+                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
+                gfdb_brick_info->time_stamp,
+                query_cbk_args->defrag->write_freq_threshold,
+                query_cbk_args->defrag->read_freq_threshold, _gf_false);
+        }
+    }
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "FATAL: query from db failed");
+        goto out;
+    }
+
+    /*Clear the heat on the DB entries*/
+    /*Preparing ctr_ipc_dict*/
+    ctr_ipc_dict = dict_new();
+    if (!ctr_ipc_dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "ctr_ipc_dict cannot initialized");
+        goto out;
+    }
+
+    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict, GFDB_IPC_CTR_KEY,
+                         GFDB_IPC_CTR_CLEAR_OPS, ret, out);
+
+    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
+                     NULL);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed clearing the heat "
+               "on db %s error %d",
+               local_brick->brick_db_path, ret);
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (params_dict) {
-                dict_unref (params_dict);
-                params_dict = NULL;
-        }
-
-        if (ctr_ipc_dict) {
-                dict_unref (ctr_ipc_dict);
-                ctr_ipc_dict = NULL;
-        }
-
-        if (query_cbk_args && query_cbk_args->query_fd >= 0) {
-                sys_close (query_cbk_args->query_fd);
-                query_cbk_args->query_fd = -1;
-        }
-        gfdb_methods.fini_db (conn_node);
-
-        return ret;
+    if (params_dict) {
+        dict_unref(params_dict);
+        params_dict = NULL;
+    }
+
+    if (ctr_ipc_dict) {
+        dict_unref(ctr_ipc_dict);
+        ctr_ipc_dict = NULL;
+    }
+
+    if (query_cbk_args && query_cbk_args->query_fd >= 0) {
+        sys_close(query_cbk_args->query_fd);
+        query_cbk_args->query_fd = -1;
+    }
+    gfdb_methods.fini_db(conn_node);
+
+    return ret;
 }
 
-
-
-
-
 /*Ask CTR to create the query file*/
 static int
-tier_process_ctr_query (tier_brick_list_t *local_brick, void *args)
+tier_process_ctr_query(tier_brick_list_t *local_brick, void *args)
 {
-        int ret                                         = -1;
-        query_cbk_args_t *query_cbk_args                = NULL;
-        xlator_t *this                                  = NULL;
-        dict_t *ctr_ipc_in_dict                         = NULL;
-        dict_t *ctr_ipc_out_dict                        = NULL;
-        gfdb_brick_info_t *gfdb_brick_info              = args;
-        gfdb_ipc_ctr_params_t *ipc_ctr_params           = NULL;
-        int count                                       = 0;
+    int ret = -1;
+    query_cbk_args_t *query_cbk_args = NULL;
+    xlator_t *this = NULL;
+    dict_t *ctr_ipc_in_dict = NULL;
+    dict_t *ctr_ipc_out_dict = NULL;
+    gfdb_brick_info_t *gfdb_brick_info = args;
+    gfdb_ipc_ctr_params_t *ipc_ctr_params = NULL;
+    int count = 0;
+
+    /*Init of all the essentials*/
+    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
+    query_cbk_args = gfdb_brick_info->_query_cbk_args;
+
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
+    this = query_cbk_args->this;
+
+    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
+
+    /*Preparing ctr_ipc_in_dict*/
+    ctr_ipc_in_dict = dict_new();
+    if (!ctr_ipc_in_dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "ctr_ipc_in_dict cannot initialized");
+        goto out;
+    }
+
+    ipc_ctr_params = GF_CALLOC(1, sizeof(gfdb_ipc_ctr_params_t),
+                               gf_tier_mt_ipc_ctr_params_t);
+    if (!ipc_ctr_params) {
+        goto out;
+    }
+
+    /* set all the query params*/
+    ipc_ctr_params->is_promote = gfdb_brick_info->_gfdb_promote;
+
+    ipc_ctr_params->write_freq_threshold = query_cbk_args->defrag
+                                               ->write_freq_threshold;
+
+    ipc_ctr_params->read_freq_threshold = query_cbk_args->defrag
+                                              ->read_freq_threshold;
+
+    ipc_ctr_params->query_limit = query_cbk_args->defrag->tier_conf.query_limit;
+
+    ipc_ctr_params->emergency_demote = (!gfdb_brick_info->_gfdb_promote &&
+                                        query_cbk_args->defrag->tier_conf
+                                                .watermark_last == TIER_WM_HI);
+
+    memcpy(&ipc_ctr_params->time_stamp, gfdb_brick_info->time_stamp,
+           sizeof(gfdb_time_t));
+
+    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_in_dict, GFDB_IPC_CTR_KEY,
+                         GFDB_IPC_CTR_QUERY_OPS, ret, out);
+
+    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_in_dict,
+                         GFDB_IPC_CTR_GET_QFILE_PATH, local_brick->qfile_path,
+                         ret, out);
+
+    ret = dict_set_bin(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_QUERY_PARAMS,
+                       ipc_ctr_params, sizeof(*ipc_ctr_params));
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+               "Failed setting %s to params dictionary",
+               GFDB_IPC_CTR_GET_QUERY_PARAMS);
+        GF_FREE(ipc_ctr_params);
+        goto out;
+    }
+    ipc_ctr_params = NULL;
+
+    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_in_dict,
+                     &ctr_ipc_out_dict);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_IPC_TIER_ERROR,
+               "Failed query on %s ret %d", local_brick->brick_db_path, ret);
+        goto out;
+    }
+
+    ret = dict_get_int32(ctr_ipc_out_dict, GFDB_IPC_CTR_RET_QUERY_COUNT,
+                         &count);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed getting count "
+               "of records on %s",
+               local_brick->brick_db_path);
+        goto out;
+    }
+
+    if (count < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed query on %s", local_brick->brick_db_path);
+        ret = -1;
+        goto out;
+    }
+
+    pthread_mutex_lock(&dm_stat_mutex);
+    query_cbk_args->defrag->num_files_lookedup = count;
+    pthread_mutex_unlock(&dm_stat_mutex);
+
+    ret = 0;
+out:
 
-        /*Init of all the essentials*/
-        GF_VALIDATE_OR_GOTO ("tier", gfdb_brick_info , out);
-        query_cbk_args = gfdb_brick_info->_query_cbk_args;
+    if (ctr_ipc_in_dict) {
+        dict_unref(ctr_ipc_in_dict);
+        ctr_ipc_in_dict = NULL;
+    }
 
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args->this, out);
-        this = query_cbk_args->this;
+    if (ctr_ipc_out_dict) {
+        dict_unref(ctr_ipc_out_dict);
+        ctr_ipc_out_dict = NULL;
+    }
 
-        GF_VALIDATE_OR_GOTO (this->name,
-                             gfdb_brick_info->_query_cbk_args, out);
+    GF_FREE(ipc_ctr_params);
 
-        GF_VALIDATE_OR_GOTO (this->name, local_brick, out);
+    return ret;
+}
 
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->xlator, out);
+/* This is the call back function for each brick from hot/cold bricklist
+ * It picks up each bricks db and queries for eligible files for migration.
+ * The list of eligible files are populated in appropriate query files*/
+static int
+tier_process_brick(tier_brick_list_t *local_brick, void *args)
+{
+    int ret = -1;
+    dict_t *ctr_ipc_in_dict = NULL;
+    dict_t *ctr_ipc_out_dict = NULL;
+    char *strval = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->brick_db_path, out);
+    GF_VALIDATE_OR_GOTO("tier", local_brick, out);
 
+    GF_VALIDATE_OR_GOTO("tier", local_brick->xlator, out);
 
+    if (dht_tier_db_type == GFDB_SQLITE3) {
         /*Preparing ctr_ipc_in_dict*/
-        ctr_ipc_in_dict = dict_new ();
+        ctr_ipc_in_dict = dict_new();
         if (!ctr_ipc_in_dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "ctr_ipc_in_dict cannot initialized");
-                goto out;
+            gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "ctr_ipc_in_dict cannot initialized");
+            goto out;
         }
 
-        ipc_ctr_params = GF_CALLOC (1, sizeof (gfdb_ipc_ctr_params_t),
-                                        gf_tier_mt_ipc_ctr_params_t);
-        if (!ipc_ctr_params) {
-                goto out;
+        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_KEY,
+                           GFDB_IPC_CTR_GET_DB_PARAM_OPS);
+        if (ret) {
+            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+                   "Failed to set %s "
+                   "to params dictionary",
+                   GFDB_IPC_CTR_KEY);
+            goto out;
         }
 
-        /* set all the query params*/
-        ipc_ctr_params->is_promote = gfdb_brick_info->_gfdb_promote;
-
-        ipc_ctr_params->write_freq_threshold =
-                query_cbk_args->defrag->write_freq_threshold;
-
-        ipc_ctr_params->read_freq_threshold =
-                query_cbk_args->defrag->read_freq_threshold;
-
-        ipc_ctr_params->query_limit =
-                query_cbk_args->defrag->tier_conf.query_limit;
-
-        ipc_ctr_params->emergency_demote =
-                (!gfdb_brick_info->_gfdb_promote &&
-                 query_cbk_args->defrag->tier_conf.watermark_last ==
-                        TIER_WM_HI);
-
-        memcpy (&ipc_ctr_params->time_stamp,
-                gfdb_brick_info->time_stamp,
-                sizeof (gfdb_time_t));
-
-        SET_DB_PARAM_TO_DICT (this->name, ctr_ipc_in_dict,
-                              GFDB_IPC_CTR_KEY, GFDB_IPC_CTR_QUERY_OPS,
-                              ret, out);
-
-
-        SET_DB_PARAM_TO_DICT (this->name, ctr_ipc_in_dict,
-                              GFDB_IPC_CTR_GET_QFILE_PATH,
-                              local_brick->qfile_path,
-                              ret, out);
-
-        ret = dict_set_bin (ctr_ipc_in_dict, GFDB_IPC_CTR_GET_QUERY_PARAMS,
-                                ipc_ctr_params, sizeof (*ipc_ctr_params));
+        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_DB_PARAM_OPS, "");
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-                        "Failed setting %s to params dictionary",
-                        GFDB_IPC_CTR_GET_QUERY_PARAMS);
-                GF_FREE (ipc_ctr_params);
-                goto out;
+            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+                   "Failed to set %s "
+                   "to params dictionary",
+                   GFDB_IPC_CTR_GET_DB_PARAM_OPS);
+            goto out;
         }
-        ipc_ctr_params = NULL;
 
-        ret = syncop_ipc (local_brick->xlator, GF_IPC_TARGET_CTR,
-                                ctr_ipc_in_dict, &ctr_ipc_out_dict);
+        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_DB_KEY,
+                           "journal_mode");
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_IPC_TIER_ERROR, "Failed query on %s ret %d",
-                        local_brick->brick_db_path, ret);
-                goto out;
+            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+                   "Failed to set %s "
+                   "to params dictionary",
+                   GFDB_IPC_CTR_GET_DB_KEY);
+            goto out;
+        }
+
+        ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR,
+                         ctr_ipc_in_dict, &ctr_ipc_out_dict);
+        if (ret || ctr_ipc_out_dict == NULL) {
+            gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "Failed to get "
+                   "journal_mode of sql db %s",
+                   local_brick->brick_db_path);
+            goto out;
         }
 
-        ret = dict_get_int32(ctr_ipc_out_dict, GFDB_IPC_CTR_RET_QUERY_COUNT,
-                                &count);
+        ret = dict_get_str(ctr_ipc_out_dict, "journal_mode", &strval);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed getting count "
-                        "of records on %s",
-                        local_brick->brick_db_path);
-                goto out;
+            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_GET_PARAM_FAILED,
+                   "Failed to get %s "
+                   "from params dictionary"
+                   "journal_mode",
+                   strval);
+            goto out;
         }
 
-        if (count < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed query on %s",
-                        local_brick->brick_db_path);
-                ret = -1;
+        if (strval && (strncmp(strval, "wal", SLEN("wal")) == 0)) {
+            ret = tier_process_self_query(local_brick, args);
+            if (ret) {
                 goto out;
+            }
+        } else {
+            ret = tier_process_ctr_query(local_brick, args);
+            if (ret) {
+                goto out;
+            }
         }
-
-        pthread_mutex_lock (&dm_stat_mutex);
-        query_cbk_args->defrag->num_files_lookedup = count;
-        pthread_mutex_unlock (&dm_stat_mutex);
-
         ret = 0;
-out:
 
-        if (ctr_ipc_in_dict) {
-                dict_unref(ctr_ipc_in_dict);
-                ctr_ipc_in_dict = NULL;
+    } else {
+        ret = tier_process_self_query(local_brick, args);
+        if (ret) {
+            goto out;
         }
+    }
 
-        if (ctr_ipc_out_dict) {
-                dict_unref(ctr_ipc_out_dict);
-                ctr_ipc_out_dict = NULL;
-        }
+    ret = 0;
+out:
+    if (ctr_ipc_in_dict)
+        dict_unref(ctr_ipc_in_dict);
 
-        GF_FREE (ipc_ctr_params);
+    if (ctr_ipc_out_dict)
+        dict_unref(ctr_ipc_out_dict);
 
-        return ret;
+    return ret;
 }
 
-
-
-
-/* This is the call back function for each brick from hot/cold bricklist
- * It picks up each bricks db and queries for eligible files for migration.
- * The list of eligible files are populated in appropriate query files*/
 static int
-tier_process_brick (tier_brick_list_t *local_brick, void *args) {
-        int ret = -1;
-        dict_t *ctr_ipc_in_dict = NULL;
-        dict_t *ctr_ipc_out_dict = NULL;
-        char *strval = NULL;
-
-        GF_VALIDATE_OR_GOTO ("tier", local_brick, out);
-
-        GF_VALIDATE_OR_GOTO ("tier", local_brick->xlator, out);
-
-        if (dht_tier_db_type == GFDB_SQLITE3) {
-
-                /*Preparing ctr_ipc_in_dict*/
-                ctr_ipc_in_dict = dict_new ();
-                if (!ctr_ipc_in_dict) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "ctr_ipc_in_dict cannot initialized");
-                        goto out;
-                }
-
-                ret = dict_set_str (ctr_ipc_in_dict, GFDB_IPC_CTR_KEY,
-                                    GFDB_IPC_CTR_GET_DB_PARAM_OPS);
-                if (ret) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,\
-                                LG_MSG_SET_PARAM_FAILED, "Failed to set %s "
-                                "to params dictionary", GFDB_IPC_CTR_KEY);
-                        goto out;
-                }
-
-                ret = dict_set_str (ctr_ipc_in_dict,
-                                    GFDB_IPC_CTR_GET_DB_PARAM_OPS, "");
-                if (ret) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,\
-                                LG_MSG_SET_PARAM_FAILED, "Failed to set %s "
-                                "to params dictionary",
-                                GFDB_IPC_CTR_GET_DB_PARAM_OPS);
-                        goto out;
-                }
-
-                ret = dict_set_str (ctr_ipc_in_dict,
-                                    GFDB_IPC_CTR_GET_DB_KEY, "journal_mode");
-                if (ret) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,
-                                LG_MSG_SET_PARAM_FAILED, "Failed to set %s "
-                                "to params dictionary",
-                                GFDB_IPC_CTR_GET_DB_KEY);
-                        goto out;
-                }
-
-
-
-                ret = syncop_ipc (local_brick->xlator, GF_IPC_TARGET_CTR,
-                                ctr_ipc_in_dict, &ctr_ipc_out_dict);
-                if (ret || ctr_ipc_out_dict == NULL) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR, "Failed to get "
-                                "journal_mode of sql db %s",
-                                local_brick->brick_db_path);
-                        goto out;
-                }
-
-                ret = dict_get_str (ctr_ipc_out_dict, "journal_mode", &strval);
-                if (ret) {
-                        gf_msg ("tier", GF_LOG_ERROR, 0,
-                                LG_MSG_GET_PARAM_FAILED, "Failed to get %s "
-                                "from params dictionary"
-                                "journal_mode", strval);
-                        goto out;
-                }
+tier_build_migration_qfile(migration_args_t *args,
+                           query_cbk_args_t *query_cbk_args,
+                           gf_boolean_t is_promotion)
+{
+    gfdb_time_t current_time;
+    gfdb_brick_info_t gfdb_brick_info;
+    gfdb_time_t time_in_past;
+    int ret = -1;
+    tier_brick_list_t *local_brick = NULL;
+    int i = 0;
+    time_in_past.tv_sec = args->freq_time;
+    time_in_past.tv_usec = 0;
+
+    ret = gettimeofday(&current_time, NULL);
+    if (ret == -1) {
+        gf_msg(args->this->name, GF_LOG_ERROR, errno,
+               DHT_MSG_SYS_CALL_GET_TIME_FAILED, "Failed to get current time");
+        goto out;
+    }
+    time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
+
+    /* The migration daemon may run a varying numberof usec after the */
+    /* sleep call triggers. A file may be registered in CTR some number */
+    /* of usec X after the daemon started and missed in the subsequent */
+    /* cycle if the daemon starts Y usec after the period in seconds */
+    /* where Y>X. Normalize away this problem by always setting usec */
+    /* to 0. */
+    time_in_past.tv_usec = 0;
+
+    gfdb_brick_info.time_stamp = &time_in_past;
+    gfdb_brick_info._gfdb_promote = is_promotion;
+    gfdb_brick_info._query_cbk_args = query_cbk_args;
+
+    list_for_each_entry(local_brick, args->brick_list, list)
+    {
+        /* Construct query file path for this brick
+         * i.e
+         * /var/run/gluster/xlator_name/
+         * {promote/demote}-brickname-indexinbricklist
+         * So that no two query files will have same path even
+         * bricks have the same name
+         * */
+        snprintf(local_brick->qfile_path, PATH_MAX, "%s-%s-%d",
+                 GET_QFILE_PATH(gfdb_brick_info._gfdb_promote),
+                 local_brick->brick_name, i);
 
-                if (strval && (strncmp(strval, "wal", SLEN ("wal")) == 0)) {
-                        ret = tier_process_self_query (local_brick, args);
-                        if (ret) {
-                                goto out;
-                        }
-                } else {
-                        ret = tier_process_ctr_query (local_brick, args);
-                        if (ret) {
-                                goto out;
-                        }
-                }
-                ret = 0;
+        /* Delete any old query files for this brick */
+        sys_unlink(local_brick->qfile_path);
 
-        } else {
-                ret = tier_process_self_query (local_brick, args);
-                if (ret) {
-                        goto out;
-                }
+        ret = tier_process_brick(local_brick, &gfdb_brick_info);
+        if (ret) {
+            gf_msg(args->this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_BRICK_QUERY_FAILED, "Brick %s query failed\n",
+                   local_brick->brick_db_path);
         }
-
-        ret = 0;
+        i++;
+    }
+    ret = 0;
 out:
-        if  (ctr_ipc_in_dict)
-                dict_unref (ctr_ipc_in_dict);
-
-        if  (ctr_ipc_out_dict)
-                dict_unref (ctr_ipc_out_dict);
-
-        return ret;
+    return ret;
 }
 
-
-
-
 static int
-tier_build_migration_qfile (migration_args_t *args,
-                            query_cbk_args_t *query_cbk_args,
-                            gf_boolean_t is_promotion)
+tier_migrate_files_using_qfile(migration_args_t *comp,
+                               query_cbk_args_t *query_cbk_args)
 {
-        gfdb_time_t               current_time;
-        gfdb_brick_info_t         gfdb_brick_info;
-        gfdb_time_t               time_in_past;
-        int                       ret = -1;
-        tier_brick_list_t         *local_brick = NULL;
-        int                       i = 0;
-        time_in_past.tv_sec = args->freq_time;
-        time_in_past.tv_usec = 0;
-
-        ret = gettimeofday (&current_time, NULL);
-        if (ret == -1) {
-                gf_msg (args->this->name, GF_LOG_ERROR, errno,
-                        DHT_MSG_SYS_CALL_GET_TIME_FAILED,
-                        "Failed to get current time");
-                goto out;
-        }
-        time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
-
-        /* The migration daemon may run a varying numberof usec after the */
-        /* sleep call triggers. A file may be registered in CTR some number */
-        /* of usec X after the daemon started and missed in the subsequent */
-        /* cycle if the daemon starts Y usec after the period in seconds */
-        /* where Y>X. Normalize away this problem by always setting usec */
-        /* to 0. */
-        time_in_past.tv_usec = 0;
-
-        gfdb_brick_info.time_stamp = &time_in_past;
-        gfdb_brick_info._gfdb_promote = is_promotion;
-        gfdb_brick_info._query_cbk_args = query_cbk_args;
-
-        list_for_each_entry (local_brick, args->brick_list, list) {
-
-                /* Construct query file path for this brick
-                 * i.e
-                 * /var/run/gluster/xlator_name/
-                 * {promote/demote}-brickname-indexinbricklist
-                 * So that no two query files will have same path even
-                 * bricks have the same name
-                 * */
-                snprintf (local_brick->qfile_path, PATH_MAX , "%s-%s-%d",
-                        GET_QFILE_PATH (gfdb_brick_info._gfdb_promote),
-                        local_brick->brick_name, i);
-
-                /* Delete any old query files for this brick */
-                sys_unlink (local_brick->qfile_path);
-
-                ret = tier_process_brick (local_brick,
-                                          &gfdb_brick_info);
-                if (ret) {
-                        gf_msg (args->this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_BRICK_QUERY_FAILED,
-                                "Brick %s query failed\n",
-                                local_brick->brick_db_path);
-                }
-                i++;
-        }
-        ret = 0;
+    int ret = -1;
+    tier_brick_list_t *local_brick = NULL;
+    tier_brick_list_t *temp = NULL;
+    gfdb_time_t current_time = {
+        0,
+    };
+    ssize_t qfile_array_size = 0;
+    int count = 0;
+    int temp_fd = 0;
+    gf_tier_conf_t *tier_conf = NULL;
+
+    tier_conf = &(query_cbk_args->defrag->tier_conf);
+
+    /* Time for error query files */
+    gettimeofday(&current_time, NULL);
+
+    /* Build the qfile list */
+    list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
+    {
+        qfile_array_size++;
+    }
+    query_cbk_args->qfile_array = qfile_array_new(qfile_array_size);
+    if (!query_cbk_args->qfile_array) {
+        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to create new "
+               "qfile_array");
+        goto out;
+    }
+
+    /*Open all qfiles*/
+    count = 0;
+    query_cbk_args->qfile_array->exhausted_count = 0;
+    list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
+    {
+        temp_fd = query_cbk_args->qfile_array->fd_array[count];
+        temp_fd = open(local_brick->qfile_path, O_RDONLY,
+                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+        if (temp_fd < 0) {
+            gf_msg("tier", GF_LOG_ERROR, errno, DHT_MSG_LOG_TIER_ERROR,
+                   "Failed to open "
+                   "%s to the query file",
+                   local_brick->qfile_path);
+            query_cbk_args->qfile_array->exhausted_count++;
+        }
+        query_cbk_args->qfile_array->fd_array[count] = temp_fd;
+        count++;
+    }
+
+    /* Moving the query file index to the next, so that we won't the same
+     * query file every cycle as the first one */
+    query_cbk_args->qfile_array
+        ->next_index = (query_cbk_args->is_promotion)
+                           ? tier_conf->last_promote_qfile_index
+                           : tier_conf->last_demote_qfile_index;
+    shift_next_index(query_cbk_args->qfile_array);
+    if (query_cbk_args->is_promotion) {
+        tier_conf->last_promote_qfile_index = query_cbk_args->qfile_array
+                                                  ->next_index;
+    } else {
+        tier_conf->last_demote_qfile_index = query_cbk_args->qfile_array
+                                                 ->next_index;
+    }
+
+    /* Migrate files using query file list */
+    ret = tier_migrate_using_query_file((void *)query_cbk_args);
 out:
-        return ret;
+    qfile_array_free(query_cbk_args->qfile_array);
+
+    /* If there is an error rename all the query files to .err files
+     * with a timestamp for better debugging */
+    if (ret) {
+        struct tm tm = {
+            0,
+        };
+        char time_str[128] = {
+            0,
+        };
+        char query_file_path_err[PATH_MAX] = {
+            0,
+        };
+        int32_t len = 0;
+
+        /* Time format for error query files */
+        gmtime_r(&current_time.tv_sec, &tm);
+        strftime(time_str, sizeof(time_str), "%F-%T", &tm);
+
+        list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
+        {
+            /* rename error qfile*/
+            len = snprintf(query_file_path_err, sizeof(query_file_path_err),
+                           "%s-%s.err", local_brick->qfile_path, time_str);
+            if ((len >= 0) && (len < sizeof(query_file_path_err))) {
+                if (sys_rename(local_brick->qfile_path, query_file_path_err) ==
+                    -1)
+                    gf_msg_debug("tier", 0,
+                                 "rename "
+                                 "failed");
+            }
+        }
+    }
+
+    query_cbk_args->qfile_array = NULL;
+
+    return ret;
 }
 
-static int
-tier_migrate_files_using_qfile (migration_args_t *comp,
-                                query_cbk_args_t *query_cbk_args)
+int
+tier_demote(migration_args_t *demotion_args)
 {
-        int ret                                 = -1;
-        tier_brick_list_t *local_brick          = NULL;
-        tier_brick_list_t *temp                 = NULL;
-        gfdb_time_t current_time                = {0,};
-        ssize_t qfile_array_size                = 0;
-        int count                               = 0;
-        int temp_fd                             = 0;
-        gf_tier_conf_t  *tier_conf              = NULL;
-
-        tier_conf = &(query_cbk_args->defrag->tier_conf);
-
-        /* Time for error query files */
-        gettimeofday (&current_time, NULL);
-
-        /* Build the qfile list */
-        list_for_each_entry_safe (local_brick, temp, comp->brick_list, list) {
-                qfile_array_size++;
-        }
-        query_cbk_args->qfile_array = qfile_array_new (qfile_array_size);
-        if (!query_cbk_args->qfile_array) {
-                gf_msg ("tier", GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed to create new "
-                        "qfile_array");
-                goto out;
-        }
-
-        /*Open all qfiles*/
-        count = 0;
-        query_cbk_args->qfile_array->exhausted_count = 0;
-        list_for_each_entry_safe (local_brick, temp, comp->brick_list, list) {
-                temp_fd = query_cbk_args->qfile_array->fd_array[count];
-                temp_fd = open (local_brick->qfile_path, O_RDONLY,
-                                S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-                if (temp_fd < 0) {
-                        gf_msg ("tier", GF_LOG_ERROR, errno,
-                                DHT_MSG_LOG_TIER_ERROR, "Failed to open "
-                                "%s to the query file",
-                                local_brick->qfile_path);
-                        query_cbk_args->qfile_array->exhausted_count++;
-                }
-                query_cbk_args->qfile_array->fd_array[count] = temp_fd;
-                count++;
-        }
-
-        /* Moving the query file index to the next, so that we won't the same
-         * query file every cycle as the first one */
-        query_cbk_args->qfile_array->next_index =
-                        (query_cbk_args->is_promotion) ?
-                        tier_conf->last_promote_qfile_index :
-                        tier_conf->last_demote_qfile_index;
-        shift_next_index (query_cbk_args->qfile_array);
-        if (query_cbk_args->is_promotion) {
-                tier_conf->last_promote_qfile_index =
-                        query_cbk_args->qfile_array->next_index;
-        } else {
-                tier_conf->last_demote_qfile_index =
-                        query_cbk_args->qfile_array->next_index;
-        }
-
-        /* Migrate files using query file list */
-        ret = tier_migrate_using_query_file ((void *)query_cbk_args);
-out:
-        qfile_array_free (query_cbk_args->qfile_array);
-
-        /* If there is an error rename all the query files to .err files
-         * with a timestamp for better debugging */
-        if (ret) {
-                struct tm tm                            = {0,};
-                char time_str[128]                      = {0,};
-                char query_file_path_err[PATH_MAX]      = {0,};
-                int32_t len                             = 0;
-
-                /* Time format for error query files */
-                gmtime_r (&current_time.tv_sec, &tm);
-                strftime (time_str, sizeof (time_str), "%F-%T", &tm);
-
-                list_for_each_entry_safe (local_brick, temp, comp->brick_list,
-                                        list) {
-                        /* rename error qfile*/
-                        len = snprintf (query_file_path_err,
-                                        sizeof (query_file_path_err),
-                                        "%s-%s.err", local_brick->qfile_path,
-                                        time_str);
-                        if ((len >= 0) &&
-                            (len < sizeof(query_file_path_err))) {
-                                if (sys_rename (local_brick->qfile_path,
-                                                query_file_path_err) == -1)
-                                        gf_msg_debug ("tier", 0, "rename "
-                                                      "failed");
-                        }
-                }
-        }
-
-        query_cbk_args->qfile_array = NULL;
+    query_cbk_args_t query_cbk_args;
+    int ret = -1;
 
-        return ret;
-}
+    GF_VALIDATE_OR_GOTO("tier", demotion_args, out);
+    GF_VALIDATE_OR_GOTO("tier", demotion_args->this, out);
+    GF_VALIDATE_OR_GOTO(demotion_args->this->name, demotion_args->brick_list,
+                        out);
+    GF_VALIDATE_OR_GOTO(demotion_args->this->name, demotion_args->defrag, out);
 
+    THIS = demotion_args->this;
 
+    query_cbk_args.this = demotion_args->this;
+    query_cbk_args.defrag = demotion_args->defrag;
+    query_cbk_args.is_promotion = 0;
 
-int
-tier_demote (migration_args_t *demotion_args)
-{
-        query_cbk_args_t query_cbk_args;
-        int ret = -1;
-
-        GF_VALIDATE_OR_GOTO ("tier", demotion_args, out);
-        GF_VALIDATE_OR_GOTO ("tier", demotion_args->this, out);
-        GF_VALIDATE_OR_GOTO (demotion_args->this->name,
-                             demotion_args->brick_list, out);
-        GF_VALIDATE_OR_GOTO (demotion_args->this->name,
-                             demotion_args->defrag, out);
-
-        THIS = demotion_args->this;
-
-        query_cbk_args.this = demotion_args->this;
-        query_cbk_args.defrag = demotion_args->defrag;
-        query_cbk_args.is_promotion = 0;
-
-        /*Build the query file using bricklist*/
-        ret = tier_build_migration_qfile (demotion_args, &query_cbk_args,
-                                          _gf_false);
-        if (ret)
-                goto out;
+    /*Build the query file using bricklist*/
+    ret = tier_build_migration_qfile(demotion_args, &query_cbk_args, _gf_false);
+    if (ret)
+        goto out;
 
-        /* Migrate files using the query file */
-        ret = tier_migrate_files_using_qfile (demotion_args,
-                                              &query_cbk_args);
-        if (ret)
-                goto out;
+    /* Migrate files using the query file */
+    ret = tier_migrate_files_using_qfile(demotion_args, &query_cbk_args);
+    if (ret)
+        goto out;
 
 out:
-        demotion_args->return_value = ret;
-        return ret;
+    demotion_args->return_value = ret;
+    return ret;
 }
 
-
 int
-tier_promote (migration_args_t *promotion_args)
+tier_promote(migration_args_t *promotion_args)
 {
-        int ret = -1;
-        query_cbk_args_t query_cbk_args;
+    int ret = -1;
+    query_cbk_args_t query_cbk_args;
 
-        GF_VALIDATE_OR_GOTO ("tier", promotion_args->this, out);
-        GF_VALIDATE_OR_GOTO (promotion_args->this->name,
-                             promotion_args->brick_list, out);
-        GF_VALIDATE_OR_GOTO (promotion_args->this->name,
-                             promotion_args->defrag, out);
+    GF_VALIDATE_OR_GOTO("tier", promotion_args->this, out);
+    GF_VALIDATE_OR_GOTO(promotion_args->this->name, promotion_args->brick_list,
+                        out);
+    GF_VALIDATE_OR_GOTO(promotion_args->this->name, promotion_args->defrag,
+                        out);
 
-        THIS = promotion_args->this;
+    THIS = promotion_args->this;
 
-        query_cbk_args.this = promotion_args->this;
-        query_cbk_args.defrag = promotion_args->defrag;
-        query_cbk_args.is_promotion = 1;
+    query_cbk_args.this = promotion_args->this;
+    query_cbk_args.defrag = promotion_args->defrag;
+    query_cbk_args.is_promotion = 1;
 
-        /*Build the query file using bricklist*/
-        ret = tier_build_migration_qfile (promotion_args, &query_cbk_args,
-                                          _gf_true);
-        if (ret)
-                goto out;
+    /*Build the query file using bricklist*/
+    ret = tier_build_migration_qfile(promotion_args, &query_cbk_args, _gf_true);
+    if (ret)
+        goto out;
 
-        /* Migrate files using the query file */
-        ret = tier_migrate_files_using_qfile (promotion_args, &query_cbk_args);
-        if (ret)
-                goto out;
+    /* Migrate files using the query file */
+    ret = tier_migrate_files_using_qfile(promotion_args, &query_cbk_args);
+    if (ret)
+        goto out;
 
 out:
-        promotion_args->return_value = ret;
-        return ret;
+    promotion_args->return_value = ret;
+    return ret;
 }
 
-
 /*
  * Command the CTR on a brick to compact the local database using an IPC
  */
 static int
-tier_process_self_compact (tier_brick_list_t *local_brick, void *args)
+tier_process_self_compact(tier_brick_list_t *local_brick, void *args)
 {
-        int ret                                         = -1;
-        char *db_path                                   = NULL;
-        query_cbk_args_t *query_cbk_args                = NULL;
-        xlator_t *this                                  = NULL;
-        gfdb_conn_node_t *conn_node                     = NULL;
-        dict_t *params_dict                             = NULL;
-        dict_t *ctr_ipc_dict                            = NULL;
-        gfdb_brick_info_t *gfdb_brick_info              = args;
-
-        /*Init of all the essentials*/
-        GF_VALIDATE_OR_GOTO ("tier", gfdb_brick_info , out);
-        query_cbk_args = gfdb_brick_info->_query_cbk_args;
-
-        GF_VALIDATE_OR_GOTO ("tier", query_cbk_args->this, out);
-        this = query_cbk_args->this;
-
-        GF_VALIDATE_OR_GOTO (this->name,
-                             gfdb_brick_info->_query_cbk_args, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->xlator, out);
-
-        GF_VALIDATE_OR_GOTO (this->name, local_brick->brick_db_path, out);
-
-        db_path = local_brick->brick_db_path;
-
-        /*Preparing DB parameters before init_db i.e getting db connection*/
-        params_dict = dict_new ();
-        if (!params_dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "DB Params cannot initialized");
-                goto out;
-        }
-        SET_DB_PARAM_TO_DICT (this->name, params_dict,
-                             (char *) gfdb_methods.get_db_path_key(), db_path,
-                             ret, out);
-
-        /*Get the db connection*/
-        conn_node = gfdb_methods.init_db ((void *)params_dict,
-                                          dht_tier_db_type);
-        if (!conn_node) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "FATAL: Failed initializing db operations");
-                         goto out;
-        }
-
-        ret = 0;
-
-        /*Preparing ctr_ipc_dict*/
-        ctr_ipc_dict = dict_new ();
-        if (!ctr_ipc_dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "ctr_ipc_dict cannot initialized");
-                goto out;
-        }
-
-        ret = dict_set_int32 (ctr_ipc_dict, "compact_active",
-                              query_cbk_args->defrag->
-                              tier_conf.compact_active);
-
-        if (ret) {
-                gf_msg ("tier", GF_LOG_ERROR, 0,
-                        LG_MSG_SET_PARAM_FAILED, "Failed to set %s "
-                        "to params dictionary",
-                        "compact_active");
-                goto out;
-        }
-
-        ret = dict_set_int32 (ctr_ipc_dict, "compact_mode_switched",
-                              query_cbk_args->defrag->
-                              tier_conf.compact_mode_switched);
-
-        if (ret) {
-                gf_msg ("tier", GF_LOG_ERROR, 0,
-                        LG_MSG_SET_PARAM_FAILED, "Failed to set %s "
-                        "to params dictionary",
-                        "compact_mode_switched");
-                goto out;
-        }
-
-        SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict,
-                             GFDB_IPC_CTR_KEY, GFDB_IPC_CTR_SET_COMPACT_PRAGMA,
-                             ret, out);
-
-        gf_msg (this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-                "Starting Compaction IPC");
-
-        ret = syncop_ipc (local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
-                          NULL);
-
-        gf_msg (this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-                "Ending Compaction IPC");
-
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR, "Failed compaction "
-                        "on db %s error %d", local_brick->brick_db_path, ret);
-                goto out;
-        }
-
-        gf_msg (this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-                "SUCCESS: %s Compaction", local_brick->brick_name);
-
-        ret = 0;
+    int ret = -1;
+    char *db_path = NULL;
+    query_cbk_args_t *query_cbk_args = NULL;
+    xlator_t *this = NULL;
+    gfdb_conn_node_t *conn_node = NULL;
+    dict_t *params_dict = NULL;
+    dict_t *ctr_ipc_dict = NULL;
+    gfdb_brick_info_t *gfdb_brick_info = args;
+
+    /*Init of all the essentials*/
+    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
+    query_cbk_args = gfdb_brick_info->_query_cbk_args;
+
+    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
+    this = query_cbk_args->this;
+
+    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
+
+    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
+
+    db_path = local_brick->brick_db_path;
+
+    /*Preparing DB parameters before init_db i.e getting db connection*/
+    params_dict = dict_new();
+    if (!params_dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "DB Params cannot initialized");
+        goto out;
+    }
+    SET_DB_PARAM_TO_DICT(this->name, params_dict,
+                         (char *)gfdb_methods.get_db_path_key(), db_path, ret,
+                         out);
+
+    /*Get the db connection*/
+    conn_node = gfdb_methods.init_db((void *)params_dict, dht_tier_db_type);
+    if (!conn_node) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "FATAL: Failed initializing db operations");
+        goto out;
+    }
+
+    ret = 0;
+
+    /*Preparing ctr_ipc_dict*/
+    ctr_ipc_dict = dict_new();
+    if (!ctr_ipc_dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "ctr_ipc_dict cannot initialized");
+        goto out;
+    }
+
+    ret = dict_set_int32(ctr_ipc_dict, "compact_active",
+                         query_cbk_args->defrag->tier_conf.compact_active);
+
+    if (ret) {
+        gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+               "Failed to set %s "
+               "to params dictionary",
+               "compact_active");
+        goto out;
+    }
+
+    ret = dict_set_int32(
+        ctr_ipc_dict, "compact_mode_switched",
+        query_cbk_args->defrag->tier_conf.compact_mode_switched);
+
+    if (ret) {
+        gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
+               "Failed to set %s "
+               "to params dictionary",
+               "compact_mode_switched");
+        goto out;
+    }
+
+    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict, GFDB_IPC_CTR_KEY,
+                         GFDB_IPC_CTR_SET_COMPACT_PRAGMA, ret, out);
+
+    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+           "Starting Compaction IPC");
+
+    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
+                     NULL);
+
+    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+           "Ending Compaction IPC");
+
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed compaction "
+               "on db %s error %d",
+               local_brick->brick_db_path, ret);
+        goto out;
+    }
+
+    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+           "SUCCESS: %s Compaction", local_brick->brick_name);
+
+    ret = 0;
 out:
-        if (params_dict) {
-                dict_unref (params_dict);
-                params_dict = NULL;
-        }
+    if (params_dict) {
+        dict_unref(params_dict);
+        params_dict = NULL;
+    }
 
-        if (ctr_ipc_dict) {
-                dict_unref (ctr_ipc_dict);
-                ctr_ipc_dict = NULL;
-        }
+    if (ctr_ipc_dict) {
+        dict_unref(ctr_ipc_dict);
+        ctr_ipc_dict = NULL;
+    }
 
-        gfdb_methods.fini_db (conn_node);
+    gfdb_methods.fini_db(conn_node);
 
-        return ret;
+    return ret;
 }
 
 /*
@@ -1995,403 +1856,366 @@ out:
  * function to prepare the compaction IPC.
  */
 static int
-tier_compact_db_brick (tier_brick_list_t *local_brick, void *args)
+tier_compact_db_brick(tier_brick_list_t *local_brick, void *args)
 {
-        int ret = -1;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("tier", local_brick, out);
+    GF_VALIDATE_OR_GOTO("tier", local_brick, out);
 
-        GF_VALIDATE_OR_GOTO ("tier", local_brick->xlator, out);
+    GF_VALIDATE_OR_GOTO("tier", local_brick->xlator, out);
 
-        ret = tier_process_self_compact (local_brick, args);
-        if (ret) {
-                gf_msg ("tier", GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Brick %s did not compact",
-                        local_brick->brick_name);
-                goto out;
-        }
+    ret = tier_process_self_compact(local_brick, args);
+    if (ret) {
+        gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Brick %s did not compact", local_brick->brick_name);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
 
-        return ret;
+    return ret;
 }
 
 static int
-tier_send_compact (migration_args_t *args,
-                   query_cbk_args_t *query_cbk_args)
+tier_send_compact(migration_args_t *args, query_cbk_args_t *query_cbk_args)
 {
-        gfdb_time_t               current_time;
-        gfdb_brick_info_t         gfdb_brick_info;
-        gfdb_time_t               time_in_past;
-        int                       ret = -1;
-        tier_brick_list_t         *local_brick = NULL;
-
-        time_in_past.tv_sec = args->freq_time;
-        time_in_past.tv_usec = 0;
-
-        ret = gettimeofday (&current_time, NULL);
-        if (ret == -1) {
-                gf_msg (args->this->name, GF_LOG_ERROR, errno,
-                        DHT_MSG_SYS_CALL_GET_TIME_FAILED,
-                        "Failed to get current time");
-                goto out;
+    gfdb_time_t current_time;
+    gfdb_brick_info_t gfdb_brick_info;
+    gfdb_time_t time_in_past;
+    int ret = -1;
+    tier_brick_list_t *local_brick = NULL;
+
+    time_in_past.tv_sec = args->freq_time;
+    time_in_past.tv_usec = 0;
+
+    ret = gettimeofday(&current_time, NULL);
+    if (ret == -1) {
+        gf_msg(args->this->name, GF_LOG_ERROR, errno,
+               DHT_MSG_SYS_CALL_GET_TIME_FAILED, "Failed to get current time");
+        goto out;
+    }
+    time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
+
+    /* The migration daemon may run a varying numberof usec after the sleep
+       call triggers. A file may be registered in CTR some number of usec X
+       after the daemon started and missed in the subsequent cycle if the
+       daemon starts Y usec after the period in seconds where Y>X. Normalize
+       away this problem by always setting usec to 0. */
+    time_in_past.tv_usec = 0;
+
+    gfdb_brick_info.time_stamp = &time_in_past;
+
+    /* This is meant to say we are always compacting at this point */
+    /* We simply borrow the promotion flag to do this */
+    gfdb_brick_info._gfdb_promote = 1;
+
+    gfdb_brick_info._query_cbk_args = query_cbk_args;
+
+    list_for_each_entry(local_brick, args->brick_list, list)
+    {
+        gf_msg(args->this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Start compaction for %s", local_brick->brick_name);
+
+        ret = tier_compact_db_brick(local_brick, &gfdb_brick_info);
+        if (ret) {
+            gf_msg(args->this->name, GF_LOG_ERROR, 0,
+                   DHT_MSG_BRICK_QUERY_FAILED, "Brick %s compaction failed\n",
+                   local_brick->brick_db_path);
         }
-        time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
 
-        /* The migration daemon may run a varying numberof usec after the sleep
-           call triggers. A file may be registered in CTR some number of usec X
-           after the daemon started and missed in the subsequent cycle if the
-           daemon starts Y usec after the period in seconds where Y>X. Normalize
-           away this problem by always setting usec to 0. */
-        time_in_past.tv_usec = 0;
-
-        gfdb_brick_info.time_stamp = &time_in_past;
-
-        /* This is meant to say we are always compacting at this point */
-        /* We simply borrow the promotion flag to do this */
-        gfdb_brick_info._gfdb_promote = 1;
+        gf_msg(args->this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+               "End compaction for %s", local_brick->brick_name);
+    }
+    ret = 0;
+out:
+    return ret;
+}
 
-        gfdb_brick_info._query_cbk_args = query_cbk_args;
+static int
+tier_compact(void *args)
+{
+    int ret = -1;
+    query_cbk_args_t query_cbk_args;
+    migration_args_t *compaction_args = args;
+
+    GF_VALIDATE_OR_GOTO("tier", compaction_args->this, out);
+    GF_VALIDATE_OR_GOTO(compaction_args->this->name,
+                        compaction_args->brick_list, out);
+    GF_VALIDATE_OR_GOTO(compaction_args->this->name, compaction_args->defrag,
+                        out);
+
+    THIS = compaction_args->this;
+
+    query_cbk_args.this = compaction_args->this;
+    query_cbk_args.defrag = compaction_args->defrag;
+    query_cbk_args.is_compaction = 1;
+
+    /* Send the compaction pragma out to all the bricks on the bricklist. */
+    /* tier_get_bricklist ensures all bricks on the list are local to */
+    /* this node. */
+    ret = tier_send_compact(compaction_args, &query_cbk_args);
+    if (ret)
+        goto out;
+
+    ret = 0;
+out:
+    compaction_args->return_value = ret;
+    return ret;
+}
 
-        list_for_each_entry (local_brick, args->brick_list, list) {
+static int
+tier_get_bricklist(xlator_t *xl, struct list_head *local_bricklist_head)
+{
+    xlator_list_t *child = NULL;
+    char *rv = NULL;
+    char *rh = NULL;
+    char *brickname = NULL;
+    char db_name[PATH_MAX] = "";
+    int ret = 0;
+    tier_brick_list_t *local_brick = NULL;
+    int32_t len = 0;
+
+    GF_VALIDATE_OR_GOTO("tier", xl, out);
+    GF_VALIDATE_OR_GOTO("tier", local_bricklist_head, out);
+
+    /*
+     * This function obtains remote subvolumes and filters out only
+     * those running on the same node as the tier daemon.
+     */
+    if (strcmp(xl->type, "protocol/client") == 0) {
+        ret = dict_get_str(xl->options, "remote-host", &rh);
+        if (ret < 0)
+            goto out;
 
-                gf_msg (args->this->name, GF_LOG_TRACE, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Start compaction for %s",
-                        local_brick->brick_name);
+        if (gf_is_local_addr(rh)) {
+            local_brick = GF_CALLOC(1, sizeof(tier_brick_list_t),
+                                    gf_tier_mt_bricklist_t);
+            if (!local_brick) {
+                goto out;
+            }
 
-                ret = tier_compact_db_brick (local_brick,
-                                             &gfdb_brick_info);
-                if (ret) {
-                        gf_msg (args->this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_BRICK_QUERY_FAILED,
-                                "Brick %s compaction failed\n",
-                                local_brick->brick_db_path);
-                }
+            ret = dict_get_str(xl->options, "remote-subvolume", &rv);
+            if (ret < 0)
+                goto out;
 
-                gf_msg (args->this->name, GF_LOG_TRACE, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "End compaction for %s",
-                        local_brick->brick_name);
+            brickname = strrchr(rv, '/') + 1;
+            snprintf(db_name, sizeof(db_name), "%s.db", brickname);
 
-        }
-        ret = 0;
-out:
-        return ret;
-}
+            local_brick->brick_db_path = GF_MALLOC(PATH_MAX, gf_common_mt_char);
+            if (!local_brick->brick_db_path) {
+                gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
+                       "Failed to allocate memory for"
+                       " bricklist.");
+                ret = -1;
+                goto out;
+            }
 
-static int
-tier_compact (void *args)
-{
-        int ret = -1;
-        query_cbk_args_t query_cbk_args;
-        migration_args_t *compaction_args = args;
-
-        GF_VALIDATE_OR_GOTO ("tier", compaction_args->this, out);
-        GF_VALIDATE_OR_GOTO (compaction_args->this->name,
-                             compaction_args->brick_list, out);
-        GF_VALIDATE_OR_GOTO (compaction_args->this->name,
-                             compaction_args->defrag, out);
-
-        THIS = compaction_args->this;
-
-        query_cbk_args.this = compaction_args->this;
-        query_cbk_args.defrag = compaction_args->defrag;
-        query_cbk_args.is_compaction = 1;
-
-        /* Send the compaction pragma out to all the bricks on the bricklist. */
-        /* tier_get_bricklist ensures all bricks on the list are local to */
-        /* this node. */
-        ret = tier_send_compact (compaction_args, &query_cbk_args);
-        if (ret)
+            len = snprintf(local_brick->brick_db_path, PATH_MAX, "%s/%s/%s", rv,
+                           GF_HIDDEN_PATH, db_name);
+            if ((len < 0) || (len >= PATH_MAX)) {
+                gf_msg("tier", GF_LOG_ERROR, EINVAL, DHT_MSG_LOG_TIER_STATUS,
+                       "DB path too long");
+                ret = -1;
                 goto out;
+            }
 
-        ret = 0;
-out:
-        compaction_args->return_value = ret;
-        return ret;
- }
+            local_brick->xlator = xl;
 
-static int
-tier_get_bricklist (xlator_t *xl, struct list_head *local_bricklist_head)
-{
-        xlator_list_t           *child = NULL;
-        char                    *rv        = NULL;
-        char                    *rh        = NULL;
-        char                    *brickname = NULL;
-        char                    db_name[PATH_MAX] = "";
-        int                     ret = 0;
-        tier_brick_list_t       *local_brick = NULL;
-        int32_t                 len = 0;
-
-        GF_VALIDATE_OR_GOTO ("tier", xl, out);
-        GF_VALIDATE_OR_GOTO ("tier", local_bricklist_head, out);
+            snprintf(local_brick->brick_name, NAME_MAX, "%s", brickname);
 
-        /*
-         * This function obtains remote subvolumes and filters out only
-         * those running on the same node as the tier daemon.
-         */
-        if (strcmp(xl->type, "protocol/client") == 0) {
-                ret = dict_get_str (xl->options, "remote-host", &rh);
-                if (ret < 0)
-                        goto out;
-
-                if (gf_is_local_addr (rh)) {
-
-                       local_brick = GF_CALLOC (1, sizeof(tier_brick_list_t),
-                                                gf_tier_mt_bricklist_t);
-                        if (!local_brick) {
-                                goto out;
-                        }
-
-                        ret = dict_get_str (xl->options, "remote-subvolume",
-                                           &rv);
-                        if (ret < 0)
-                                goto out;
-
-                        brickname = strrchr(rv, '/') + 1;
-                        snprintf(db_name, sizeof(db_name), "%s.db",
-                                 brickname);
-
-                        local_brick->brick_db_path =
-                                GF_MALLOC (PATH_MAX, gf_common_mt_char);
-                        if (!local_brick->brick_db_path) {
-                                gf_msg ("tier", GF_LOG_ERROR, 0,
-                                        DHT_MSG_LOG_TIER_STATUS,
-                                        "Failed to allocate memory for"
-                                        " bricklist.");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        len = snprintf(local_brick->brick_db_path,
-                                       PATH_MAX, "%s/%s/%s", rv,
-                                       GF_HIDDEN_PATH, db_name);
-                        if ((len < 0) || (len >= PATH_MAX)) {
-                                gf_msg ("tier", GF_LOG_ERROR, EINVAL,
-                                        DHT_MSG_LOG_TIER_STATUS,
-                                        "DB path too long");
-                                ret = -1;
-                                goto out;
-                        }
-
-                        local_brick->xlator = xl;
-
-                        snprintf (local_brick->brick_name,
-                                NAME_MAX, "%s", brickname);
-
-                        list_add_tail (&(local_brick->list),
-                                        local_bricklist_head);
-
-                        ret = 0;
-                        goto out;
-                }
+            list_add_tail(&(local_brick->list), local_bricklist_head);
+
+            ret = 0;
+            goto out;
         }
+    }
 
-        for (child = xl->children; child; child = child->next) {
-                ret = tier_get_bricklist (child->xlator, local_bricklist_head);
-                if (ret) {
-                        goto out;
-                }
+    for (child = xl->children; child; child = child->next) {
+        ret = tier_get_bricklist(child->xlator, local_bricklist_head);
+        if (ret) {
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
 
-        if (ret) {
-                if (local_brick) {
-                        GF_FREE (local_brick->brick_db_path);
-                }
-                GF_FREE (local_brick);
+    if (ret) {
+        if (local_brick) {
+            GF_FREE(local_brick->brick_db_path);
         }
+        GF_FREE(local_brick);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-tier_get_freq_demote (gf_tier_conf_t *tier_conf)
+tier_get_freq_demote(gf_tier_conf_t *tier_conf)
 {
-        if ((tier_conf->mode == TIER_MODE_WM) &&
-            (tier_conf->watermark_last == TIER_WM_HI))
-                return DEFAULT_DEMOTE_DEGRADED;
-        else
-                return tier_conf->tier_demote_frequency;
+    if ((tier_conf->mode == TIER_MODE_WM) &&
+        (tier_conf->watermark_last == TIER_WM_HI))
+        return DEFAULT_DEMOTE_DEGRADED;
+    else
+        return tier_conf->tier_demote_frequency;
 }
 
 int
-tier_get_freq_promote (gf_tier_conf_t *tier_conf)
+tier_get_freq_promote(gf_tier_conf_t *tier_conf)
 {
-        return tier_conf->tier_promote_frequency;
+    return tier_conf->tier_promote_frequency;
 }
 
 int
-tier_get_freq_compact_hot (gf_tier_conf_t *tier_conf)
+tier_get_freq_compact_hot(gf_tier_conf_t *tier_conf)
 {
-        return tier_conf->tier_compact_hot_frequency;
+    return tier_conf->tier_compact_hot_frequency;
 }
 
 int
-tier_get_freq_compact_cold (gf_tier_conf_t *tier_conf)
+tier_get_freq_compact_cold(gf_tier_conf_t *tier_conf)
 {
-        return tier_conf->tier_compact_cold_frequency;
+    return tier_conf->tier_compact_cold_frequency;
 }
 
 static int
-tier_check_demote (gfdb_time_t  current_time, int freq)
+tier_check_demote(gfdb_time_t current_time, int freq)
 {
-        return ((current_time.tv_sec % freq) == 0) ?
-                _gf_true : _gf_false;
+    return ((current_time.tv_sec % freq) == 0) ? _gf_true : _gf_false;
 }
 
 static gf_boolean_t
-tier_check_promote (gf_tier_conf_t   *tier_conf,
-                    gfdb_time_t  current_time,
-                    int freq)
+tier_check_promote(gf_tier_conf_t *tier_conf, gfdb_time_t current_time,
+                   int freq)
 {
-        if ((tier_conf->mode == TIER_MODE_WM) &&
-            (tier_conf->watermark_last == TIER_WM_HI))
-                return _gf_false;
+    if ((tier_conf->mode == TIER_MODE_WM) &&
+        (tier_conf->watermark_last == TIER_WM_HI))
+        return _gf_false;
 
-        else
-                return ((current_time.tv_sec % freq) == 0) ?
-                        _gf_true : _gf_false;
+    else
+        return ((current_time.tv_sec % freq) == 0) ? _gf_true : _gf_false;
 }
 
 static gf_boolean_t
-tier_check_compact (gf_tier_conf_t   *tier_conf,
-                    gfdb_time_t  current_time,
-                    int freq_compact)
+tier_check_compact(gf_tier_conf_t *tier_conf, gfdb_time_t current_time,
+                   int freq_compact)
 {
+    if (!(tier_conf->compact_active || tier_conf->compact_mode_switched))
+        return _gf_false;
 
-        if (!(tier_conf->compact_active ||
-              tier_conf->compact_mode_switched))
-                return _gf_false;
-
-
-        return ((current_time.tv_sec % freq_compact) == 0) ?
-                _gf_true : _gf_false;
+    return ((current_time.tv_sec % freq_compact) == 0) ? _gf_true : _gf_false;
 }
 
-
 void
-clear_bricklist (struct list_head *brick_list)
+clear_bricklist(struct list_head *brick_list)
 {
-        tier_brick_list_t  *local_brick      = NULL;
-        tier_brick_list_t  *temp             = NULL;
+    tier_brick_list_t *local_brick = NULL;
+    tier_brick_list_t *temp = NULL;
 
-        if (list_empty(brick_list)) {
-                return;
-        }
-
-        list_for_each_entry_safe (local_brick, temp, brick_list, list) {
-                list_del (&local_brick->list);
-                GF_FREE (local_brick->brick_db_path);
-                GF_FREE (local_brick);
-        }
+    if (list_empty(brick_list)) {
+        return;
+    }
+
+    list_for_each_entry_safe(local_brick, temp, brick_list, list)
+    {
+        list_del(&local_brick->list);
+        GF_FREE(local_brick->brick_db_path);
+        GF_FREE(local_brick);
+    }
 }
 
-
 static void
-set_brick_list_qpath (struct list_head *brick_list, gf_boolean_t is_cold)
+set_brick_list_qpath(struct list_head *brick_list, gf_boolean_t is_cold)
 {
-
-        tier_brick_list_t *local_brick = NULL;
-        int i                          = 0;
-
-        GF_VALIDATE_OR_GOTO ("tier", brick_list, out);
-
-        list_for_each_entry (local_brick, brick_list, list) {
-
-                /* Construct query file path for this brick
-                 * i.e
-                 * /var/run/gluster/xlator_name/
-                 * {promote/demote}-brickname-indexinbricklist
-                 * So that no two query files will have same path even
-                 * bricks have the same name
-                 * */
-                snprintf (local_brick->qfile_path, PATH_MAX , "%s-%s-%d",
-                        GET_QFILE_PATH (is_cold),
-                        local_brick->brick_name, i);
-                i++;
-        }
+    tier_brick_list_t *local_brick = NULL;
+    int i = 0;
+
+    GF_VALIDATE_OR_GOTO("tier", brick_list, out);
+
+    list_for_each_entry(local_brick, brick_list, list)
+    {
+        /* Construct query file path for this brick
+         * i.e
+         * /var/run/gluster/xlator_name/
+         * {promote/demote}-brickname-indexinbricklist
+         * So that no two query files will have same path even
+         * bricks have the same name
+         * */
+        snprintf(local_brick->qfile_path, PATH_MAX, "%s-%s-%d",
+                 GET_QFILE_PATH(is_cold), local_brick->brick_name, i);
+        i++;
+    }
 out:
-        return;
+    return;
 }
 
 static int
-tier_prepare_compact (migration_args_t *args, gfdb_time_t current_time)
+tier_prepare_compact(migration_args_t *args, gfdb_time_t current_time)
 {
-        xlator_t *this = NULL;
-        dht_conf_t *conf                        = NULL;
-        gf_defrag_info_t *defrag                = NULL;
-        gf_tier_conf_t *tier_conf               = NULL;
-        gf_boolean_t is_hot_tier = args->is_hot_tier;
-        int freq = 0;
-        int ret = -1;
-        const char *tier_type = is_hot_tier ? "hot" : "cold";
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    gf_tier_conf_t *tier_conf = NULL;
+    gf_boolean_t is_hot_tier = args->is_hot_tier;
+    int freq = 0;
+    int ret = -1;
+    const char *tier_type = is_hot_tier ? "hot" : "cold";
 
-        this = args->this;
+    this = args->this;
 
-        conf = this->private;
+    conf = this->private;
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        tier_conf = &defrag->tier_conf;
+    tier_conf = &defrag->tier_conf;
 
-        freq = is_hot_tier ? tier_get_freq_compact_hot (tier_conf) :
-                tier_get_freq_compact_cold (tier_conf);
+    freq = is_hot_tier ? tier_get_freq_compact_hot(tier_conf)
+                       : tier_get_freq_compact_cold(tier_conf);
 
-        defrag->tier_conf.compact_mode_switched = is_hot_tier ?
-                defrag->tier_conf.compact_mode_switched_hot :
-                defrag->tier_conf.compact_mode_switched_cold;
+    defrag->tier_conf.compact_mode_switched =
+        is_hot_tier ? defrag->tier_conf.compact_mode_switched_hot
+                    : defrag->tier_conf.compact_mode_switched_cold;
 
-        gf_msg(this->name, GF_LOG_TRACE, 0,
-               DHT_MSG_LOG_TIER_STATUS,
-               "Compact mode %i",
-               defrag->tier_conf.compact_mode_switched);
+    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
+           "Compact mode %i", defrag->tier_conf.compact_mode_switched);
 
-        if (tier_check_compact (tier_conf, current_time,
-                                freq)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_STATUS,
-                        "Start compaction on %s tier",
-                        tier_type);
+    if (tier_check_compact(tier_conf, current_time, freq)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "Start compaction on %s tier", tier_type);
 
-                args->freq_time = freq;
-                ret = tier_compact (args);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR, "Compaction failed on "
-                                "%s tier", tier_type);
-                        goto out;
-                }
+        args->freq_time = freq;
+        ret = tier_compact(args);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "Compaction failed on "
+                   "%s tier",
+                   tier_type);
+            goto out;
+        }
 
-                gf_msg (this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                        "End compaction on %s tier", tier_type);
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+               "End compaction on %s tier", tier_type);
 
-                if (is_hot_tier) {
-                        defrag->tier_conf.compact_mode_switched_hot =
-                                _gf_false;
-                } else {
-                        defrag->tier_conf.compact_mode_switched_cold =
-                                _gf_false;
-                }
+        if (is_hot_tier) {
+            defrag->tier_conf.compact_mode_switched_hot = _gf_false;
+        } else {
+            defrag->tier_conf.compact_mode_switched_cold = _gf_false;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
 tier_get_wm_interval(tier_mode_t mode, tier_watermark_op_t wm)
 {
-        if (mode == TIER_MODE_WM && wm == TIER_WM_HI)
-                return WM_INTERVAL_EMERG;
+    if (mode == TIER_MODE_WM && wm == TIER_WM_HI)
+        return WM_INTERVAL_EMERG;
 
-        return WM_INTERVAL;
+    return WM_INTERVAL;
 }
 
 /*
@@ -2402,941 +2226,863 @@ tier_get_wm_interval(tier_mode_t mode, tier_watermark_op_t wm)
  * 1. Check trigger to migrate data.
  * 2. Check for state changes (pause, unpause, stop).
  */
-static void
-*tier_run (void *in_args)
+static void *
+tier_run(void *in_args)
 {
-        dht_conf_t *conf                        = NULL;
-        gfdb_time_t  current_time               = { 0 };
-        int freq                                = 0;
-        int ret                                 = 0;
-        xlator_t *any                           = NULL;
-        xlator_t *xlator                        = NULL;
-        gf_tier_conf_t *tier_conf               = NULL;
-        loc_t root_loc                          = { 0 };
-        int check_watermark                     = 0;
-        gf_defrag_info_t *defrag                = NULL;
-        xlator_t  *this                         = NULL;
-        migration_args_t *args = in_args;
-        GF_VALIDATE_OR_GOTO ("tier", args, out);
-        GF_VALIDATE_OR_GOTO ("tier", args->brick_list, out);
-
-        this = args->this;
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-
-        conf   = this->private;
-        GF_VALIDATE_OR_GOTO ("tier", conf, out);
-
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO ("tier", defrag, out);
+    dht_conf_t *conf = NULL;
+    gfdb_time_t current_time = {0};
+    int freq = 0;
+    int ret = 0;
+    xlator_t *any = NULL;
+    xlator_t *xlator = NULL;
+    gf_tier_conf_t *tier_conf = NULL;
+    loc_t root_loc = {0};
+    int check_watermark = 0;
+    gf_defrag_info_t *defrag = NULL;
+    xlator_t *this = NULL;
+    migration_args_t *args = in_args;
+    GF_VALIDATE_OR_GOTO("tier", args, out);
+    GF_VALIDATE_OR_GOTO("tier", args->brick_list, out);
+
+    this = args->this;
+    GF_VALIDATE_OR_GOTO("tier", this, out);
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO("tier", conf, out);
+
+    defrag = conf->defrag;
+    GF_VALIDATE_OR_GOTO("tier", defrag, out);
+
+    if (list_empty(args->brick_list)) {
+        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Brick list for tier is empty. Exiting.");
+        goto out;
+    }
+
+    defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
+    tier_conf = &defrag->tier_conf;
+
+    dht_build_root_loc(defrag->root_inode, &root_loc);
+
+    while (1) {
+        /*
+         * Check if a graph switch occurred. If so, stop migration
+         * thread. It will need to be restarted manually.
+         */
+        any = THIS->ctx->active->first;
+        xlator = xlator_search_by_name(any, this->name);
 
-        if (list_empty (args->brick_list)) {
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Brick list for tier is empty. Exiting.");
-                goto out;
+        if (xlator != this) {
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                   "Detected graph switch. Exiting migration "
+                   "daemon.");
+            goto out;
         }
 
-        defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
-        tier_conf = &defrag->tier_conf;
-
-        dht_build_root_loc (defrag->root_inode, &root_loc);
+        gf_defrag_check_pause_tier(tier_conf);
 
-        while (1) {
+        sleep(1);
 
-                /*
-                 * Check if a graph switch occurred. If so, stop migration
-                 * thread. It will need to be restarted manually.
-                 */
-                any = THIS->ctx->active->first;
-                xlator = xlator_search_by_name (any, this->name);
-
-                if (xlator != this) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LOG_TIER_STATUS,
-                                "Detected graph switch. Exiting migration "
-                                "daemon.");
-                        goto out;
-                }
+        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
+            ret = 1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "defrag->defrag_status != "
+                   "GF_DEFRAG_STATUS_STARTED");
+            goto out;
+        }
 
-                gf_defrag_check_pause_tier (tier_conf);
+        if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
+            defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
+            ret = 0;
+            defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
+            gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_TIER_ERROR,
+                   "defrag->defrag_cmd == "
+                   "GF_DEFRAG_CMD_START_DETACH_TIER");
+            goto out;
+        }
 
-                sleep(1);
+        if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING)
+            continue;
 
-                if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-                        ret = 1;
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "defrag->defrag_status != "
-                                "GF_DEFRAG_STATUS_STARTED");
-                        goto out;
+        /* To have proper synchronization amongst all
+         * brick holding nodes, so that promotion and demotions
+         * start atomically w.r.t promotion/demotion frequency
+         * period, all nodes should have their system time
+         * in-sync with each other either manually set or
+         * using a NTP server*/
+        ret = gettimeofday(&current_time, NULL);
+        if (ret == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, errno,
+                   DHT_MSG_SYS_CALL_GET_TIME_FAILED,
+                   "Failed to get current time");
+            goto out;
+        }
+
+        check_watermark++;
+
+        /* emergency demotion requires frequent watermark monitoring */
+        if (check_watermark >=
+            tier_get_wm_interval(tier_conf->mode, tier_conf->watermark_last)) {
+            check_watermark = 0;
+            if (tier_conf->mode == TIER_MODE_WM) {
+                ret = tier_get_fs_stat(this, &root_loc);
+                if (ret != 0) {
+                    continue;
                 }
-
-                if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-                    defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-                        ret = 0;
-                        defrag->defrag_status =
-                                GF_DEFRAG_STATUS_COMPLETE;
-                        gf_msg (this->name, GF_LOG_DEBUG, 0,
-                                DHT_MSG_LOG_TIER_ERROR,
-                                "defrag->defrag_cmd == "
-                                "GF_DEFRAG_CMD_START_DETACH_TIER");
-                        goto out;
+                ret = tier_check_watermark(this);
+                if (ret != 0) {
+                    gf_msg(this->name, GF_LOG_CRITICAL, errno,
+                           DHT_MSG_LOG_TIER_ERROR, "Failed to get watermark");
+                    continue;
                 }
+            }
+        }
 
-                if (gf_defrag_get_pause_state (&defrag->tier_conf) !=
-                    TIER_RUNNING)
-                        continue;
-
-                /* To have proper synchronization amongst all
-                 * brick holding nodes, so that promotion and demotions
-                 * start atomically w.r.t promotion/demotion frequency
-                 * period, all nodes should have their system time
-                 * in-sync with each other either manually set or
-                 * using a NTP server*/
-                ret = gettimeofday (&current_time, NULL);
-                if (ret == -1) {
-                        gf_msg (this->name, GF_LOG_ERROR, errno,
-                                DHT_MSG_SYS_CALL_GET_TIME_FAILED,
-                                "Failed to get current time");
-                        goto out;
-                }
+        if (args->is_promotion) {
+            freq = tier_get_freq_promote(tier_conf);
 
-                check_watermark++;
-
-                /* emergency demotion requires frequent watermark monitoring */
-                if (check_watermark >=
-                        tier_get_wm_interval(tier_conf->mode,
-                                             tier_conf->watermark_last)) {
-                        check_watermark = 0;
-                        if (tier_conf->mode == TIER_MODE_WM) {
-                                ret = tier_get_fs_stat (this, &root_loc);
-                                if (ret != 0) {
-                                        continue;
-                                }
-                                ret = tier_check_watermark (this);
-                                if (ret != 0) {
-                                        gf_msg (this->name, GF_LOG_CRITICAL, errno,
-                                                DHT_MSG_LOG_TIER_ERROR,
-                                                "Failed to get watermark");
-                                        continue;
-                                }
-                        }
+            if (tier_check_promote(tier_conf, current_time, freq)) {
+                args->freq_time = freq;
+                ret = tier_promote(args);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                           "Promotion failed");
                 }
+            }
+        } else if (args->is_compaction) {
+            tier_prepare_compact(args, current_time);
+        } else {
+            freq = tier_get_freq_demote(tier_conf);
 
-                if (args->is_promotion) {
-                        freq = tier_get_freq_promote (tier_conf);
-
-                        if (tier_check_promote (tier_conf, current_time, freq)) {
-                                args->freq_time = freq;
-                                ret = tier_promote (args);
-                                if (ret) {
-                                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                                DHT_MSG_LOG_TIER_ERROR,
-                                                "Promotion failed");
-                                }
-                        }
-                } else if (args->is_compaction) {
-                        tier_prepare_compact (args, current_time);
-                } else {
-                        freq = tier_get_freq_demote (tier_conf);
-
-                        if (tier_check_demote (current_time, freq)) {
-                                args->freq_time = freq;
-                                ret = tier_demote (args);
-                                if (ret) {
-                                        gf_msg (this->name,
-                                                GF_LOG_ERROR,
-                                                0,
-                                                DHT_MSG_LOG_TIER_ERROR,
-                                                "Demotion failed");
-                                }
-                        }
+            if (tier_check_demote(current_time, freq)) {
+                args->freq_time = freq;
+                ret = tier_demote(args);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                           "Demotion failed");
                 }
-
-                /* Check the statfs immediately after the processing threads
-                   return */
-                check_watermark = WM_INTERVAL;
+            }
         }
 
-        ret = 0;
+        /* Check the statfs immediately after the processing threads
+           return */
+        check_watermark = WM_INTERVAL;
+    }
+
+    ret = 0;
 out:
 
-        args->return_value = ret;
+    args->return_value = ret;
 
-        return NULL;
+    return NULL;
 }
 
 int
-tier_start (xlator_t *this, gf_defrag_info_t *defrag)
+tier_start(xlator_t *this, gf_defrag_info_t *defrag)
 {
-        pthread_t promote_thread;
-        pthread_t demote_thread;
-        pthread_t hot_compact_thread;
-        pthread_t cold_compact_thread;
-        int ret = -1;
-        struct list_head bricklist_hot          = { 0 };
-        struct list_head bricklist_cold         = { 0 };
-        migration_args_t promotion_args         = { 0 };
-        migration_args_t demotion_args          = { 0 };
-        migration_args_t hot_compaction_args    = { 0 };
-        migration_args_t cold_compaction_args   = { 0 };
-        dht_conf_t *conf                        = NULL;
-
-        INIT_LIST_HEAD ((&bricklist_hot));
-        INIT_LIST_HEAD ((&bricklist_cold));
-
-        conf   = this->private;
-
-        tier_get_bricklist (conf->subvolumes[1], &bricklist_hot);
-        set_brick_list_qpath (&bricklist_hot, _gf_false);
-
-        demotion_args.this = this;
-        demotion_args.brick_list = &bricklist_hot;
-        demotion_args.defrag = defrag;
-        demotion_args.is_promotion = _gf_false;
-        demotion_args.is_compaction = _gf_false;
-
-        ret = gf_thread_create (&demote_thread,
-                                NULL, &tier_run, &demotion_args, "tierdem");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to start demotion thread.");
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                goto cleanup;
-        }
-
-        tier_get_bricklist (conf->subvolumes[0], &bricklist_cold);
-        set_brick_list_qpath (&bricklist_cold, _gf_true);
-
-        promotion_args.this = this;
-        promotion_args.brick_list = &bricklist_cold;
-        promotion_args.defrag = defrag;
-        promotion_args.is_promotion = _gf_true;
-
-        ret = gf_thread_create (&promote_thread, NULL, &tier_run,
-                                &promotion_args, "tierpro");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to start promotion thread.");
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                goto waitforspawned;
-        }
-
-        hot_compaction_args.this = this;
-        hot_compaction_args.brick_list = &bricklist_hot;
-        hot_compaction_args.defrag = defrag;
-        hot_compaction_args.is_promotion = _gf_false;
-        hot_compaction_args.is_compaction = _gf_true;
-        hot_compaction_args.is_hot_tier = _gf_true;
-
-        ret = gf_thread_create (&hot_compact_thread, NULL, &tier_run,
-                                &hot_compaction_args, "tierhcom");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to start compaction thread.");
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                goto waitforspawnedpromote;
-        }
-
-        cold_compaction_args.this = this;
-        cold_compaction_args.brick_list = &bricklist_cold;
-        cold_compaction_args.defrag = defrag;
-        cold_compaction_args.is_promotion = _gf_false;
-        cold_compaction_args.is_compaction = _gf_true;
-        cold_compaction_args.is_hot_tier = _gf_false;
-
-        ret = gf_thread_create (&cold_compact_thread, NULL, &tier_run,
-                                &cold_compaction_args, "tierccom");
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Failed to start compaction thread.");
-                defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-                goto waitforspawnedhotcompact;
-        }
-        pthread_join (cold_compact_thread, NULL);
+    pthread_t promote_thread;
+    pthread_t demote_thread;
+    pthread_t hot_compact_thread;
+    pthread_t cold_compact_thread;
+    int ret = -1;
+    struct list_head bricklist_hot = {0};
+    struct list_head bricklist_cold = {0};
+    migration_args_t promotion_args = {0};
+    migration_args_t demotion_args = {0};
+    migration_args_t hot_compaction_args = {0};
+    migration_args_t cold_compaction_args = {0};
+    dht_conf_t *conf = NULL;
+
+    INIT_LIST_HEAD((&bricklist_hot));
+    INIT_LIST_HEAD((&bricklist_cold));
+
+    conf = this->private;
+
+    tier_get_bricklist(conf->subvolumes[1], &bricklist_hot);
+    set_brick_list_qpath(&bricklist_hot, _gf_false);
+
+    demotion_args.this = this;
+    demotion_args.brick_list = &bricklist_hot;
+    demotion_args.defrag = defrag;
+    demotion_args.is_promotion = _gf_false;
+    demotion_args.is_compaction = _gf_false;
+
+    ret = gf_thread_create(&demote_thread, NULL, &tier_run, &demotion_args,
+                           "tierdem");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to start demotion thread.");
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        goto cleanup;
+    }
+
+    tier_get_bricklist(conf->subvolumes[0], &bricklist_cold);
+    set_brick_list_qpath(&bricklist_cold, _gf_true);
+
+    promotion_args.this = this;
+    promotion_args.brick_list = &bricklist_cold;
+    promotion_args.defrag = defrag;
+    promotion_args.is_promotion = _gf_true;
+
+    ret = gf_thread_create(&promote_thread, NULL, &tier_run, &promotion_args,
+                           "tierpro");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to start promotion thread.");
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        goto waitforspawned;
+    }
+
+    hot_compaction_args.this = this;
+    hot_compaction_args.brick_list = &bricklist_hot;
+    hot_compaction_args.defrag = defrag;
+    hot_compaction_args.is_promotion = _gf_false;
+    hot_compaction_args.is_compaction = _gf_true;
+    hot_compaction_args.is_hot_tier = _gf_true;
+
+    ret = gf_thread_create(&hot_compact_thread, NULL, &tier_run,
+                           &hot_compaction_args, "tierhcom");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to start compaction thread.");
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        goto waitforspawnedpromote;
+    }
+
+    cold_compaction_args.this = this;
+    cold_compaction_args.brick_list = &bricklist_cold;
+    cold_compaction_args.defrag = defrag;
+    cold_compaction_args.is_promotion = _gf_false;
+    cold_compaction_args.is_compaction = _gf_true;
+    cold_compaction_args.is_hot_tier = _gf_false;
+
+    ret = gf_thread_create(&cold_compact_thread, NULL, &tier_run,
+                           &cold_compaction_args, "tierccom");
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Failed to start compaction thread.");
+        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
+        goto waitforspawnedhotcompact;
+    }
+    pthread_join(cold_compact_thread, NULL);
 
 waitforspawnedhotcompact:
-        pthread_join (hot_compact_thread, NULL);
+    pthread_join(hot_compact_thread, NULL);
 
 waitforspawnedpromote:
-        pthread_join (promote_thread, NULL);
+    pthread_join(promote_thread, NULL);
 
 waitforspawned:
-        pthread_join (demote_thread, NULL);
+    pthread_join(demote_thread, NULL);
 
 cleanup:
-        clear_bricklist (&bricklist_cold);
-        clear_bricklist (&bricklist_hot);
-        return ret;
+    clear_bricklist(&bricklist_cold);
+    clear_bricklist(&bricklist_hot);
+    return ret;
 }
 
 int32_t
-tier_migration_needed (xlator_t *this)
+tier_migration_needed(xlator_t *this)
 {
-        gf_defrag_info_t        *defrag = NULL;
-        dht_conf_t              *conf   = NULL;
-        int                      ret = 0;
+    gf_defrag_info_t *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-        GF_VALIDATE_OR_GOTO (this->name, conf->defrag, out);
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+    GF_VALIDATE_OR_GOTO(this->name, conf->defrag, out);
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        if ((defrag->cmd == GF_DEFRAG_CMD_START_TIER) ||
-            (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER))
-                ret = 1;
+    if ((defrag->cmd == GF_DEFRAG_CMD_START_TIER) ||
+        (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER))
+        ret = 1;
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-tier_migration_get_dst (xlator_t *this, dht_local_t *local)
+tier_migration_get_dst(xlator_t *this, dht_local_t *local)
 {
-        dht_conf_t              *conf   = NULL;
-        int32_t                  ret = -1;
-        gf_defrag_info_t        *defrag = NULL;
+    dht_conf_t *conf = NULL;
+    int32_t ret = -1;
+    gf_defrag_info_t *defrag = NULL;
 
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    GF_VALIDATE_OR_GOTO("tier", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-        conf = this->private;
+    conf = this->private;
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        if (defrag && defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER) {
-                local->rebalance.target_node = conf->subvolumes[0];
+    if (defrag && defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER) {
+        local->rebalance.target_node = conf->subvolumes[0];
 
-        } else if (conf->subvolumes[0] == local->cached_subvol)
-                local->rebalance.target_node =
-                        conf->subvolumes[1];
-        else
-                local->rebalance.target_node =
-                        conf->subvolumes[0];
+    } else if (conf->subvolumes[0] == local->cached_subvol)
+        local->rebalance.target_node = conf->subvolumes[1];
+    else
+        local->rebalance.target_node = conf->subvolumes[0];
 
-        if (local->rebalance.target_node)
-                ret = 0;
+    if (local->rebalance.target_node)
+        ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
 
 xlator_t *
-tier_search (xlator_t *this, dht_layout_t *layout, const char *name)
+tier_search(xlator_t *this, dht_layout_t *layout, const char *name)
 {
-        xlator_t                *subvol = NULL;
-        dht_conf_t              *conf   = NULL;
+    xlator_t *subvol = NULL;
+    dht_conf_t *conf = NULL;
 
-        GF_VALIDATE_OR_GOTO ("tier", this, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    GF_VALIDATE_OR_GOTO("tier", this, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-        conf = this->private;
+    conf = this->private;
 
-        subvol = TIER_HASHED_SUBVOL;
+    subvol = TIER_HASHED_SUBVOL;
 
- out:
-        return subvol;
+out:
+    return subvol;
 }
 
-
 static int
-tier_load_externals (xlator_t *this)
+tier_load_externals(xlator_t *this)
 {
-        int               ret            = -1;
-        char *libpathfull = (LIBDIR "/libgfdb.so.0");
-        get_gfdb_methods_t get_gfdb_methods;
+    int ret = -1;
+    char *libpathfull = (LIBDIR "/libgfdb.so.0");
+    get_gfdb_methods_t get_gfdb_methods;
 
-        GF_VALIDATE_OR_GOTO ("this", this, out);
+    GF_VALIDATE_OR_GOTO("this", this, out);
 
-        libhandle = dlopen (libpathfull, RTLD_NOW);
-        if (!libhandle) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       DHT_MSG_LOG_TIER_ERROR,
-                       "Error loading libgfdb.so %s\n", dlerror());
-                ret = -1;
-                goto out;
-        }
+    libhandle = dlopen(libpathfull, RTLD_NOW);
+    if (!libhandle) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Error loading libgfdb.so %s\n", dlerror());
+        ret = -1;
+        goto out;
+    }
 
-        get_gfdb_methods = dlsym (libhandle, "get_gfdb_methods");
-        if (!get_gfdb_methods) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       DHT_MSG_LOG_TIER_ERROR,
-                       "Error loading get_gfdb_methods()");
-                ret = -1;
-                goto out;
-        }
+    get_gfdb_methods = dlsym(libhandle, "get_gfdb_methods");
+    if (!get_gfdb_methods) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Error loading get_gfdb_methods()");
+        ret = -1;
+        goto out;
+    }
 
-        get_gfdb_methods (&gfdb_methods);
+    get_gfdb_methods(&gfdb_methods);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (ret && libhandle)
-                dlclose (libhandle);
+    if (ret && libhandle)
+        dlclose(libhandle);
 
-        return ret;
+    return ret;
 }
 
 static tier_mode_t
-tier_validate_mode (char *mode)
+tier_validate_mode(char *mode)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (strcmp (mode, "test") == 0) {
-                ret = TIER_MODE_TEST;
-        } else {
-                ret = TIER_MODE_WM;
-        }
+    if (strcmp(mode, "test") == 0) {
+        ret = TIER_MODE_TEST;
+    } else {
+        ret = TIER_MODE_WM;
+    }
 
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-tier_validate_compact_mode (char *mode)
+tier_validate_compact_mode(char *mode)
 {
-        gf_boolean_t ret = _gf_false;
+    gf_boolean_t ret = _gf_false;
 
-        gf_msg ("tier", GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                "tier_validate_compact_mode: mode = %s", mode);
+    gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+           "tier_validate_compact_mode: mode = %s", mode);
 
-        if (!strcmp (mode, "on")) {
-                ret = _gf_true;
-        } else {
-                ret = _gf_false;
-        }
+    if (!strcmp(mode, "on")) {
+        ret = _gf_true;
+    } else {
+        ret = _gf_false;
+    }
 
-        gf_msg ("tier", GF_LOG_ERROR, 0,
-                DHT_MSG_LOG_TIER_STATUS,
-                "tier_validate_compact_mode: ret = %i", ret);
+    gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
+           "tier_validate_compact_mode: ret = %i", ret);
 
-        return ret;
+    return ret;
 }
 
 int
-tier_init_methods (xlator_t *this)
+tier_init_methods(xlator_t *this)
 {
-        int ret                  = -1;
-        dht_conf_t      *conf    = NULL;
-        dht_methods_t   *methods = NULL;
+    int ret = -1;
+    dht_conf_t *conf = NULL;
+    dht_methods_t *methods = NULL;
 
-        GF_VALIDATE_OR_GOTO ("tier", this, err);
+    GF_VALIDATE_OR_GOTO("tier", this, err);
 
-        conf = this->private;
+    conf = this->private;
 
-        methods = &(conf->methods);
+    methods = &(conf->methods);
 
-        methods->migration_get_dst_subvol = tier_migration_get_dst;
-        methods->migration_other   = tier_start;
-        methods->migration_needed  = tier_migration_needed;
-        methods->layout_search     = tier_search;
+    methods->migration_get_dst_subvol = tier_migration_get_dst;
+    methods->migration_other = tier_start;
+    methods->migration_needed = tier_migration_needed;
+    methods->layout_search = tier_search;
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 static void
-tier_save_vol_name (xlator_t *this)
+tier_save_vol_name(xlator_t *this)
 {
-        dht_conf_t       *conf           = NULL;
-        gf_defrag_info_t *defrag         = NULL;
-        char             *suffix         = NULL;
-        int               name_len       = 0;
-
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    char *suffix = NULL;
+    int name_len = 0;
 
-        conf = this->private;
-        defrag = conf->defrag;
+    conf = this->private;
+    defrag = conf->defrag;
 
-        suffix = strstr (this->name, "-tier-dht");
+    suffix = strstr(this->name, "-tier-dht");
 
-        if (suffix)
-                name_len = suffix - this->name;
-        else
-                name_len = strlen (this->name);
+    if (suffix)
+        name_len = suffix - this->name;
+    else
+        name_len = strlen(this->name);
 
-        if (name_len > GD_VOLUME_NAME_MAX)
-                name_len = GD_VOLUME_NAME_MAX;
+    if (name_len > GD_VOLUME_NAME_MAX)
+        name_len = GD_VOLUME_NAME_MAX;
 
-        strncpy (defrag->tier_conf.volname, this->name, name_len);
-        defrag->tier_conf.volname[name_len] = 0;
+    strncpy(defrag->tier_conf.volname, this->name, name_len);
+    defrag->tier_conf.volname[name_len] = 0;
 }
 
 int
-tier_init (xlator_t *this)
+tier_init(xlator_t *this)
 {
-        int               ret            = -1;
-        int               freq           = 0;
-        int               maxsize        = 0;
-        dht_conf_t       *conf           = NULL;
-        gf_defrag_info_t *defrag         = NULL;
-        char             *voldir         = NULL;
-        char             *mode           = NULL;
-        char             *paused         = NULL;
-        tier_mode_t	  tier_mode	 = DEFAULT_TIER_MODE;
-        gf_boolean_t	  compact_mode	 = _gf_false;
-
-        ret = dht_init (this);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "tier_init failed");
-                goto out;
-        }
-
-        conf = this->private;
-
-        ret = tier_init_methods (this);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "tier_init_methods failed");
-                goto out;
-        }
-
-        if (conf->subvolume_cnt != 2) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        DHT_MSG_LOG_TIER_ERROR,
-                        "Invalid number of subvolumes %d", conf->subvolume_cnt);
-                goto out;
-        }
-
-        /* if instatiated from client side initialization is complete. */
-        if (!conf->defrag) {
-                ret = 0;
-                goto out;
-        }
+    int ret = -1;
+    int freq = 0;
+    int maxsize = 0;
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    char *voldir = NULL;
+    char *mode = NULL;
+    char *paused = NULL;
+    tier_mode_t tier_mode = DEFAULT_TIER_MODE;
+    gf_boolean_t compact_mode = _gf_false;
+
+    ret = dht_init(this);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "tier_init failed");
+        goto out;
+    }
+
+    conf = this->private;
+
+    ret = tier_init_methods(this);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "tier_init_methods failed");
+        goto out;
+    }
+
+    if (conf->subvolume_cnt != 2) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Invalid number of subvolumes %d", conf->subvolume_cnt);
+        goto out;
+    }
+
+    /* if instatiated from client side initialization is complete. */
+    if (!conf->defrag) {
+        ret = 0;
+        goto out;
+    }
 
-        /* if instatiated from server side, load db libraries */
-        ret = tier_load_externals (this);
-        if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       DHT_MSG_LOG_TIER_ERROR,
-                       "Could not load externals. Aborting");
-                goto out;
-        }
+    /* if instatiated from server side, load db libraries */
+    ret = tier_load_externals(this);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "Could not load externals. Aborting");
+        goto out;
+    }
 
-        defrag = conf->defrag;
+    defrag = conf->defrag;
 
-        defrag->tier_conf.last_demote_qfile_index = 0;
-        defrag->tier_conf.last_promote_qfile_index = 0;
+    defrag->tier_conf.last_demote_qfile_index = 0;
+    defrag->tier_conf.last_promote_qfile_index = 0;
 
-        defrag->tier_conf.is_tier = 1;
-        defrag->this = this;
+    defrag->tier_conf.is_tier = 1;
+    defrag->this = this;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-max-promote-file-size", &maxsize);
-        if (ret) {
-                maxsize = 0;
-        }
+    ret = dict_get_int32(this->options, "tier-max-promote-file-size", &maxsize);
+    if (ret) {
+        maxsize = 0;
+    }
 
-        defrag->tier_conf.tier_max_promote_size = maxsize;
+    defrag->tier_conf.tier_max_promote_size = maxsize;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-promote-frequency", &freq);
-        if (ret) {
-                freq = DEFAULT_PROMOTE_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "tier-promote-frequency", &freq);
+    if (ret) {
+        freq = DEFAULT_PROMOTE_FREQ_SEC;
+    }
 
-        defrag->tier_conf.tier_promote_frequency = freq;
+    defrag->tier_conf.tier_promote_frequency = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-demote-frequency", &freq);
-        if (ret) {
-                freq = DEFAULT_DEMOTE_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "tier-demote-frequency", &freq);
+    if (ret) {
+        freq = DEFAULT_DEMOTE_FREQ_SEC;
+    }
 
-        defrag->tier_conf.tier_demote_frequency = freq;
+    defrag->tier_conf.tier_demote_frequency = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-hot-compact-frequency", &freq);
-        if (ret) {
-                freq = DEFAULT_HOT_COMPACT_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "tier-hot-compact-frequency", &freq);
+    if (ret) {
+        freq = DEFAULT_HOT_COMPACT_FREQ_SEC;
+    }
 
-        defrag->tier_conf.tier_compact_hot_frequency = freq;
+    defrag->tier_conf.tier_compact_hot_frequency = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-cold-compact-frequency", &freq);
-        if (ret) {
-                freq = DEFAULT_COLD_COMPACT_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "tier-cold-compact-frequency", &freq);
+    if (ret) {
+        freq = DEFAULT_COLD_COMPACT_FREQ_SEC;
+    }
 
-        defrag->tier_conf.tier_compact_cold_frequency = freq;
+    defrag->tier_conf.tier_compact_cold_frequency = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "watermark-hi", &freq);
-        if (ret) {
-                freq = DEFAULT_WM_HI;
-        }
+    ret = dict_get_int32(this->options, "watermark-hi", &freq);
+    if (ret) {
+        freq = DEFAULT_WM_HI;
+    }
 
-        defrag->tier_conf.watermark_hi = freq;
+    defrag->tier_conf.watermark_hi = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "watermark-low", &freq);
-        if (ret) {
-                freq = DEFAULT_WM_LOW;
-        }
+    ret = dict_get_int32(this->options, "watermark-low", &freq);
+    if (ret) {
+        freq = DEFAULT_WM_LOW;
+    }
 
-        defrag->tier_conf.watermark_low = freq;
+    defrag->tier_conf.watermark_low = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "write-freq-threshold", &freq);
-        if (ret) {
-                freq = DEFAULT_WRITE_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "write-freq-threshold", &freq);
+    if (ret) {
+        freq = DEFAULT_WRITE_FREQ_SEC;
+    }
 
-        defrag->write_freq_threshold = freq;
+    defrag->write_freq_threshold = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "read-freq-threshold", &freq);
-        if (ret) {
-                freq = DEFAULT_READ_FREQ_SEC;
-        }
+    ret = dict_get_int32(this->options, "read-freq-threshold", &freq);
+    if (ret) {
+        freq = DEFAULT_READ_FREQ_SEC;
+    }
 
-        defrag->read_freq_threshold = freq;
+    defrag->read_freq_threshold = freq;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-max-mb", &freq);
-        if (ret) {
-                freq = DEFAULT_TIER_MAX_MIGRATE_MB;
-        }
+    ret = dict_get_int32(this->options, "tier-max-mb", &freq);
+    if (ret) {
+        freq = DEFAULT_TIER_MAX_MIGRATE_MB;
+    }
 
-        defrag->tier_conf.max_migrate_bytes = (uint64_t) freq * 1024 * 1024;
+    defrag->tier_conf.max_migrate_bytes = (uint64_t)freq * 1024 * 1024;
 
-        ret = dict_get_int32 (this->options,
-                              "tier-max-files", &freq);
-        if (ret) {
-                freq = DEFAULT_TIER_MAX_MIGRATE_FILES;
-        }
+    ret = dict_get_int32(this->options, "tier-max-files", &freq);
+    if (ret) {
+        freq = DEFAULT_TIER_MAX_MIGRATE_FILES;
+    }
 
-        defrag->tier_conf.max_migrate_files = freq;
+    defrag->tier_conf.max_migrate_files = freq;
 
+    ret = dict_get_int32(this->options, "tier-query-limit",
+                         &(defrag->tier_conf.query_limit));
+    if (ret) {
+        defrag->tier_conf.query_limit = DEFAULT_TIER_QUERY_LIMIT;
+    }
 
-        ret = dict_get_int32 (this->options,
-                              "tier-query-limit",
-                              &(defrag->tier_conf.query_limit));
-        if (ret) {
-                defrag->tier_conf.query_limit =
-                        DEFAULT_TIER_QUERY_LIMIT;
-        }
+    ret = dict_get_str(this->options, "tier-compact", &mode);
 
-        ret = dict_get_str (this->options,
-                            "tier-compact", &mode);
-
-        if (ret) {
-                defrag->tier_conf.compact_active = DEFAULT_COMP_MODE;
-        } else {
-                compact_mode = tier_validate_compact_mode (mode);
-                /* If compaction is now active, we need to inform the bricks on
-                   the hot and cold tier of this. See dht-common.h for more. */
-                defrag->tier_conf.compact_active = compact_mode;
-                if (compact_mode) {
-                        defrag->tier_conf.compact_mode_switched_hot = _gf_true;
-                        defrag->tier_conf.compact_mode_switched_cold = _gf_true;
-                }
+    if (ret) {
+        defrag->tier_conf.compact_active = DEFAULT_COMP_MODE;
+    } else {
+        compact_mode = tier_validate_compact_mode(mode);
+        /* If compaction is now active, we need to inform the bricks on
+           the hot and cold tier of this. See dht-common.h for more. */
+        defrag->tier_conf.compact_active = compact_mode;
+        if (compact_mode) {
+            defrag->tier_conf.compact_mode_switched_hot = _gf_true;
+            defrag->tier_conf.compact_mode_switched_cold = _gf_true;
         }
+    }
 
-        ret = dict_get_str (this->options,
-                            "tier-mode", &mode);
-        if (ret) {
-                defrag->tier_conf.mode = DEFAULT_TIER_MODE;
-        } else {
-                tier_mode = tier_validate_mode (mode);
-                defrag->tier_conf.mode = tier_mode;
-        }
+    ret = dict_get_str(this->options, "tier-mode", &mode);
+    if (ret) {
+        defrag->tier_conf.mode = DEFAULT_TIER_MODE;
+    } else {
+        tier_mode = tier_validate_mode(mode);
+        defrag->tier_conf.mode = tier_mode;
+    }
 
-        pthread_mutex_init (&defrag->tier_conf.pause_mutex, 0);
+    pthread_mutex_init(&defrag->tier_conf.pause_mutex, 0);
 
-        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
+    gf_defrag_set_pause_state(&defrag->tier_conf, TIER_RUNNING);
 
-        ret = dict_get_str (this->options,
-                              "tier-pause", &paused);
+    ret = dict_get_str(this->options, "tier-pause", &paused);
 
-        if (paused && strcmp (paused, "on") == 0)
-                gf_defrag_set_pause_state (&defrag->tier_conf,
-                                           TIER_REQUEST_PAUSE);
+    if (paused && strcmp(paused, "on") == 0)
+        gf_defrag_set_pause_state(&defrag->tier_conf, TIER_REQUEST_PAUSE);
 
-        ret = gf_asprintf(&voldir, "%s/%s",
-                          DEFAULT_VAR_RUN_DIRECTORY,
-                          this->name);
-        if (ret < 0)
-                goto out;
+    ret = gf_asprintf(&voldir, "%s/%s", DEFAULT_VAR_RUN_DIRECTORY, this->name);
+    if (ret < 0)
+        goto out;
 
-        ret = mkdir_p(voldir, 0777, _gf_true);
-        if (ret == -1 && errno != EEXIST) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                       DHT_MSG_LOG_TIER_ERROR,
-                       "tier_init failed");
-
-                GF_FREE(voldir);
-                goto out;
-        }
+    ret = mkdir_p(voldir, 0777, _gf_true);
+    if (ret == -1 && errno != EEXIST) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+               "tier_init failed");
 
         GF_FREE(voldir);
+        goto out;
+    }
 
-        ret = gf_asprintf (&promotion_qfile, "%s/%s/promote",
-                           DEFAULT_VAR_RUN_DIRECTORY,
-                           this->name);
-        if (ret < 0)
-                goto out;
+    GF_FREE(voldir);
 
-        ret = gf_asprintf (&demotion_qfile, "%s/%s/demote",
-                           DEFAULT_VAR_RUN_DIRECTORY,
-                           this->name);
-        if (ret < 0) {
-                GF_FREE (promotion_qfile);
-                goto out;
-        }
+    ret = gf_asprintf(&promotion_qfile, "%s/%s/promote",
+                      DEFAULT_VAR_RUN_DIRECTORY, this->name);
+    if (ret < 0)
+        goto out;
 
-        gf_msg (this->name, GF_LOG_INFO, 0,
-                DHT_MSG_LOG_TIER_STATUS,
-               "Promote/demote frequency %d/%d "
-               "Write/Read freq thresholds %d/%d",
-               defrag->tier_conf.tier_promote_frequency,
-               defrag->tier_conf.tier_demote_frequency,
-               defrag->write_freq_threshold,
-               defrag->read_freq_threshold);
+    ret = gf_asprintf(&demotion_qfile, "%s/%s/demote",
+                      DEFAULT_VAR_RUN_DIRECTORY, this->name);
+    if (ret < 0) {
+        GF_FREE(promotion_qfile);
+        goto out;
+    }
 
-        tier_save_vol_name (this);
+    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+           "Promote/demote frequency %d/%d "
+           "Write/Read freq thresholds %d/%d",
+           defrag->tier_conf.tier_promote_frequency,
+           defrag->tier_conf.tier_demote_frequency,
+           defrag->write_freq_threshold, defrag->read_freq_threshold);
 
-        ret = 0;
+    tier_save_vol_name(this);
+
+    ret = 0;
 
 out:
 
-        return ret;
+    return ret;
 }
 
 int
-tier_cli_pause_done (int op_ret, call_frame_t *sync_frame, void *data)
+tier_cli_pause_done(int op_ret, call_frame_t *sync_frame, void *data)
 {
-        gf_msg ("tier", GF_LOG_INFO, 0,
-                DHT_MSG_TIER_PAUSED,
-                "Migrate file paused with op_ret %d", op_ret);
+    gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_TIER_PAUSED,
+           "Migrate file paused with op_ret %d", op_ret);
 
-        return op_ret;
+    return op_ret;
 }
 
 int
-tier_cli_pause (void *data)
+tier_cli_pause(void *data)
 {
-        gf_defrag_info_t        *defrag         = NULL;
-        xlator_t                *this           = NULL;
-        dht_conf_t              *conf           = NULL;
-        int                      ret            = -1;
+    gf_defrag_info_t *defrag = NULL;
+    xlator_t *this = NULL;
+    dht_conf_t *conf = NULL;
+    int ret = -1;
 
-        this = data;
+    this = data;
 
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, exit);
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, exit);
 
-        defrag = conf->defrag;
-        GF_VALIDATE_OR_GOTO (this->name, defrag, exit);
+    defrag = conf->defrag;
+    GF_VALIDATE_OR_GOTO(this->name, defrag, exit);
 
-        gf_defrag_pause_tier (this, defrag);
+    gf_defrag_pause_tier(this, defrag);
 
-        ret = 0;
+    ret = 0;
 exit:
-        return ret;
+    return ret;
 }
 
 int
-tier_reconfigure (xlator_t *this, dict_t *options)
+tier_reconfigure(xlator_t *this, dict_t *options)
 {
-        dht_conf_t       *conf            = NULL;
-        gf_defrag_info_t *defrag          = NULL;
-        char             *mode            = NULL;
-        int               migrate_mb      = 0;
-        gf_boolean_t      req_pause       = _gf_false;
-        int               ret             = 0;
-        call_frame_t            *frame    = NULL;
-        gf_boolean_t last_compact_setting = _gf_false;
-
-        conf = this->private;
-
-        if (conf->defrag) {
-                defrag = conf->defrag;
-                GF_OPTION_RECONF ("tier-max-promote-file-size",
-                                  defrag->tier_conf.tier_max_promote_size,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("tier-promote-frequency",
-                                  defrag->tier_conf.tier_promote_frequency,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("tier-demote-frequency",
-                                  defrag->tier_conf.tier_demote_frequency,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("write-freq-threshold",
-                                  defrag->write_freq_threshold, options,
-                                  int32, out);
-
-                GF_OPTION_RECONF ("read-freq-threshold",
-                                  defrag->read_freq_threshold, options,
-                                  int32, out);
-
-                GF_OPTION_RECONF ("watermark-hi",
-                                  defrag->tier_conf.watermark_hi, options,
-                                  int32, out);
-
-                GF_OPTION_RECONF ("watermark-low",
-                                  defrag->tier_conf.watermark_low, options,
-                                  int32, out);
-
-                last_compact_setting = defrag->tier_conf.compact_active;
-
-                GF_OPTION_RECONF ("tier-compact",
-                                  defrag->tier_conf.compact_active, options,
-                                  bool, out);
-
-                if (last_compact_setting != defrag->tier_conf.compact_active) {
-                        defrag->tier_conf.compact_mode_switched_hot = _gf_true;
-                        defrag->tier_conf.compact_mode_switched_cold = _gf_true;
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                DHT_MSG_LOG_TIER_STATUS,
-                                "compact mode switched");
-                }
+    dht_conf_t *conf = NULL;
+    gf_defrag_info_t *defrag = NULL;
+    char *mode = NULL;
+    int migrate_mb = 0;
+    gf_boolean_t req_pause = _gf_false;
+    int ret = 0;
+    call_frame_t *frame = NULL;
+    gf_boolean_t last_compact_setting = _gf_false;
+
+    conf = this->private;
+
+    if (conf->defrag) {
+        defrag = conf->defrag;
+        GF_OPTION_RECONF("tier-max-promote-file-size",
+                         defrag->tier_conf.tier_max_promote_size, options,
+                         int32, out);
 
-                GF_OPTION_RECONF ("tier-hot-compact-frequency",
-                                  defrag->tier_conf.tier_compact_hot_frequency,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("tier-cold-compact-frequency",
-                                  defrag->tier_conf.tier_compact_cold_frequency,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("tier-mode",
-                                  mode, options,
-                                  str, out);
-                defrag->tier_conf.mode = tier_validate_mode (mode);
-
-                GF_OPTION_RECONF ("tier-max-mb",
-                                  migrate_mb, options,
-                                  int32, out);
-                defrag->tier_conf.max_migrate_bytes = (uint64_t) migrate_mb *
-                                                        1024 * 1024;
-
-                GF_OPTION_RECONF ("tier-max-files",
-                                  defrag->tier_conf.max_migrate_files, options,
-                                  int32, out);
-
-                GF_OPTION_RECONF ("tier-query-limit",
-                                  defrag->tier_conf.query_limit,
-                                  options, int32, out);
-
-                GF_OPTION_RECONF ("tier-pause",
-                                  req_pause, options,
-                                  bool, out);
-
-                if (req_pause == _gf_true) {
-
-                        frame = create_frame (this, this->ctx->pool);
-                        if (!frame)
-                                goto out;
-
-                        frame->root->pid = GF_CLIENT_PID_DEFRAG;
-
-                        ret = synctask_new (this->ctx->env, tier_cli_pause,
-                                            tier_cli_pause_done, frame, this);
-
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_LOG_TIER_ERROR,
-                                        "pause tier failed on reconfigure");
-                        }
-                } else {
-                        ret = gf_defrag_resume_tier (this, defrag);
-                        if (ret) {
-                                gf_msg (this->name, GF_LOG_ERROR, 0,
-                                        DHT_MSG_LOG_TIER_ERROR,
-                                        "resume tier failed on reconfigure");
-                        }
-                }
+        GF_OPTION_RECONF("tier-promote-frequency",
+                         defrag->tier_conf.tier_promote_frequency, options,
+                         int32, out);
+
+        GF_OPTION_RECONF("tier-demote-frequency",
+                         defrag->tier_conf.tier_demote_frequency, options,
+                         int32, out);
+
+        GF_OPTION_RECONF("write-freq-threshold", defrag->write_freq_threshold,
+                         options, int32, out);
+
+        GF_OPTION_RECONF("read-freq-threshold", defrag->read_freq_threshold,
+                         options, int32, out);
+
+        GF_OPTION_RECONF("watermark-hi", defrag->tier_conf.watermark_hi,
+                         options, int32, out);
 
+        GF_OPTION_RECONF("watermark-low", defrag->tier_conf.watermark_low,
+                         options, int32, out);
+
+        last_compact_setting = defrag->tier_conf.compact_active;
+
+        GF_OPTION_RECONF("tier-compact", defrag->tier_conf.compact_active,
+                         options, bool, out);
+
+        if (last_compact_setting != defrag->tier_conf.compact_active) {
+            defrag->tier_conf.compact_mode_switched_hot = _gf_true;
+            defrag->tier_conf.compact_mode_switched_cold = _gf_true;
+            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
+                   "compact mode switched");
         }
 
+        GF_OPTION_RECONF("tier-hot-compact-frequency",
+                         defrag->tier_conf.tier_compact_hot_frequency, options,
+                         int32, out);
+
+        GF_OPTION_RECONF("tier-cold-compact-frequency",
+                         defrag->tier_conf.tier_compact_cold_frequency, options,
+                         int32, out);
+
+        GF_OPTION_RECONF("tier-mode", mode, options, str, out);
+        defrag->tier_conf.mode = tier_validate_mode(mode);
+
+        GF_OPTION_RECONF("tier-max-mb", migrate_mb, options, int32, out);
+        defrag->tier_conf.max_migrate_bytes = (uint64_t)migrate_mb * 1024 *
+                                              1024;
+
+        GF_OPTION_RECONF("tier-max-files", defrag->tier_conf.max_migrate_files,
+                         options, int32, out);
+
+        GF_OPTION_RECONF("tier-query-limit", defrag->tier_conf.query_limit,
+                         options, int32, out);
+
+        GF_OPTION_RECONF("tier-pause", req_pause, options, bool, out);
+
+        if (req_pause == _gf_true) {
+            frame = create_frame(this, this->ctx->pool);
+            if (!frame)
+                goto out;
+
+            frame->root->pid = GF_CLIENT_PID_DEFRAG;
+
+            ret = synctask_new(this->ctx->env, tier_cli_pause,
+                               tier_cli_pause_done, frame, this);
+
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                       "pause tier failed on reconfigure");
+            }
+        } else {
+            ret = gf_defrag_resume_tier(this, defrag);
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
+                       "resume tier failed on reconfigure");
+            }
+        }
+    }
+
 out:
-        return dht_reconfigure (this, options);
+    return dht_reconfigure(this, options);
 }
 
 void
-tier_fini (xlator_t *this)
+tier_fini(xlator_t *this)
 {
-        if (libhandle)
-                dlclose (libhandle);
+    if (libhandle)
+        dlclose(libhandle);
 
-        GF_FREE (demotion_qfile);
-        GF_FREE (promotion_qfile);
+    GF_FREE(demotion_qfile);
+    GF_FREE(promotion_qfile);
 
-        dht_fini(this);
+    dht_fini(this);
 }
 
-class_methods_t class_methods = {
-        .init           = tier_init,
-        .fini           = tier_fini,
-        .reconfigure    = tier_reconfigure,
-        .notify         = dht_notify
-};
+class_methods_t class_methods = {.init = tier_init,
+                                 .fini = tier_fini,
+                                 .reconfigure = tier_reconfigure,
+                                 .notify = dht_notify};
 
 struct xlator_fops fops = {
 
-        .lookup      = dht_lookup,
-        .create      = tier_create,
-        .mknod       = dht_mknod,
-
-        .open        = dht_open,
-        .statfs      = tier_statfs,
-        .opendir     = dht_opendir,
-        .readdir     = tier_readdir,
-        .readdirp    = tier_readdirp,
-        .fsyncdir    = dht_fsyncdir,
-        .symlink     = dht_symlink,
-        .unlink      = tier_unlink,
-        .link        = tier_link,
-        .mkdir       = dht_mkdir,
-        .rmdir       = dht_rmdir,
-        .rename      = dht_rename,
-        .entrylk     = dht_entrylk,
-        .fentrylk    = dht_fentrylk,
-
-        /* Inode read operations */
-        .stat        = dht_stat,
-        .fstat       = dht_fstat,
-        .access      = dht_access,
-        .readlink    = dht_readlink,
-        .getxattr    = dht_getxattr,
-        .fgetxattr    = dht_fgetxattr,
-        .readv       = dht_readv,
-        .flush       = dht_flush,
-        .fsync       = dht_fsync,
-        .inodelk     = dht_inodelk,
-        .finodelk    = dht_finodelk,
-        .lk          = dht_lk,
-
-        /* Inode write operations */
-        .fremovexattr = dht_fremovexattr,
-        .removexattr = dht_removexattr,
-        .setxattr    = dht_setxattr,
-        .fsetxattr   = dht_fsetxattr,
-        .truncate    = dht_truncate,
-        .ftruncate   = dht_ftruncate,
-        .writev      = dht_writev,
-        .xattrop     = dht_xattrop,
-        .fxattrop    = dht_fxattrop,
-        .setattr     = dht_setattr,
-        .fsetattr    = dht_fsetattr,
-        .fallocate   = dht_fallocate,
-        .discard     = dht_discard,
-        .zerofill    = dht_zerofill,
+    .lookup = dht_lookup,
+    .create = tier_create,
+    .mknod = dht_mknod,
+
+    .open = dht_open,
+    .statfs = tier_statfs,
+    .opendir = dht_opendir,
+    .readdir = tier_readdir,
+    .readdirp = tier_readdirp,
+    .fsyncdir = dht_fsyncdir,
+    .symlink = dht_symlink,
+    .unlink = tier_unlink,
+    .link = tier_link,
+    .mkdir = dht_mkdir,
+    .rmdir = dht_rmdir,
+    .rename = dht_rename,
+    .entrylk = dht_entrylk,
+    .fentrylk = dht_fentrylk,
+
+    /* Inode read operations */
+    .stat = dht_stat,
+    .fstat = dht_fstat,
+    .access = dht_access,
+    .readlink = dht_readlink,
+    .getxattr = dht_getxattr,
+    .fgetxattr = dht_fgetxattr,
+    .readv = dht_readv,
+    .flush = dht_flush,
+    .fsync = dht_fsync,
+    .inodelk = dht_inodelk,
+    .finodelk = dht_finodelk,
+    .lk = dht_lk,
+
+    /* Inode write operations */
+    .fremovexattr = dht_fremovexattr,
+    .removexattr = dht_removexattr,
+    .setxattr = dht_setxattr,
+    .fsetxattr = dht_fsetxattr,
+    .truncate = dht_truncate,
+    .ftruncate = dht_ftruncate,
+    .writev = dht_writev,
+    .xattrop = dht_xattrop,
+    .fxattrop = dht_fxattrop,
+    .setattr = dht_setattr,
+    .fsetattr = dht_fsetattr,
+    .fallocate = dht_fallocate,
+    .discard = dht_discard,
+    .zerofill = dht_zerofill,
 };
 
-struct xlator_cbks cbks = {
-        .release    = dht_release,
-        .forget     = dht_forget
-};
+struct xlator_cbks cbks = {.release = dht_release, .forget = dht_forget};
diff --git a/xlators/cluster/dht/src/unittest/dht_layout_mock.c b/xlators/cluster/dht/src/unittest/dht_layout_mock.c
index 6544f4208f5..49bf18b9fe6 100644
--- a/xlators/cluster/dht/src/unittest/dht_layout_mock.c
+++ b/xlators/cluster/dht/src/unittest/dht_layout_mock.c
@@ -13,60 +13,61 @@
 #include "byte-order.h"
 
 int
-dht_hash_compute (xlator_t *this, int type, const char *name, uint32_t *hash_p)
+dht_hash_compute(xlator_t *this, int type, const char *name, uint32_t *hash_p)
 {
     return 0;
 }
 
 int
-dht_inode_ctx_layout_get (inode_t *inode, xlator_t *this, dht_layout_t **layout)
+dht_inode_ctx_layout_get(inode_t *inode, xlator_t *this, dht_layout_t **layout)
 {
     return 0;
 }
 
 int
-dht_inode_ctx_layout_set (inode_t *inode, xlator_t *this,
-                          dht_layout_t *layout_int)
+dht_inode_ctx_layout_set(inode_t *inode, xlator_t *this,
+                         dht_layout_t *layout_int)
 {
     return 0;
 }
 
 int
-dict_get_ptr (dict_t *this, char *key, void **ptr)
+dict_get_ptr(dict_t *this, char *key, void **ptr)
 {
     return 0;
 }
 
 int
-dict_get_ptr_and_len (dict_t *this, char *key, void **ptr, int *len)
+dict_get_ptr_and_len(dict_t *this, char *key, void **ptr, int *len)
 {
     return 0;
 }
 
-int _gf_log (const char *domain, const char *file,
-             const char *function, int32_t line, gf_loglevel_t level,
-             const char *fmt, ...)
+int
+_gf_log(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-int _gf_log_callingfn (const char *domain, const char *file,
-                       const char *function, int32_t line, gf_loglevel_t level,
-                       const char *fmt, ...)
+int
+_gf_log_callingfn(const char *domain, const char *file, const char *function,
+                  int32_t line, gf_loglevel_t level, const char *fmt, ...)
 {
     return 0;
 }
 
-void gf_uuid_unparse(const uuid_t uu, char *out)
+void
+gf_uuid_unparse(const uuid_t uu, char *out)
 {
     // could call a will-return function here
     // to place the correct data in *out
 }
 
 int
-_gf_msg (const char *domain, const char *file, const char *function,
-         int32_t line, gf_loglevel_t level, int errnum, int trace,
-         uint64_t msgid, const char *fmt, ...)
+_gf_msg(const char *domain, const char *file, const char *function,
+        int32_t line, gf_loglevel_t level, int errnum, int trace,
+        uint64_t msgid, const char *fmt, ...)
 {
     return 0;
 }
diff --git a/xlators/cluster/dht/src/unittest/dht_layout_unittest.c b/xlators/cluster/dht/src/unittest/dht_layout_unittest.c
index fb6445ce1f3..72890070835 100644
--- a/xlators/cluster/dht/src/unittest/dht_layout_unittest.c
+++ b/xlators/cluster/dht/src/unittest/dht_layout_unittest.c
@@ -34,16 +34,16 @@ helper_xlator_init(uint32_t num_types)
     xl = test_calloc(1, sizeof(xlator_t));
     assert_non_null(xl);
     xl->mem_acct->num_types = num_types;
-    xl->mem_acct = test_calloc (sizeof(struct mem_acct)
-                                + sizeof(struct mem_acct_rec) + num_types);
+    xl->mem_acct = test_calloc(sizeof(struct mem_acct) +
+                               sizeof(struct mem_acct_rec) + num_types);
     assert_non_null(xl->mem_acct);
 
     xl->ctx = test_calloc(1, sizeof(glusterfs_ctx_t));
     assert_non_null(xl->ctx);
 
     for (i = 0; i < num_types; i++) {
-            ret = LOCK_INIT(&(xl->mem_acct.rec[i].lock));
-            assert_false(ret);
+        ret = LOCK_INIT(&(xl->mem_acct.rec[i].lock));
+        assert_false(ret);
     }
 
     ENSURE(num_types == xl->mem_acct.num_types);
@@ -58,8 +58,8 @@ helper_xlator_destroy(xlator_t *xl)
     int i, ret;
 
     for (i = 0; i < xl->mem_acct.num_types; i++) {
-            ret = LOCK_DESTROY(&(xl->mem_acct.rec[i].lock));
-            assert_int_equal(ret, 0);
+        ret = LOCK_DESTROY(&(xl->mem_acct.rec[i].lock));
+        assert_int_equal(ret, 0);
     }
 
     free(xl->mem_acct.rec);
@@ -76,7 +76,7 @@ test_dht_layout_new(void **state)
 {
     xlator_t *xl;
     dht_layout_t *layout;
-    dht_conf_t   *conf;
+    dht_conf_t *conf;
     int cnt;
 
     expect_assert_failure(dht_layout_new(NULL, 0));
@@ -90,7 +90,7 @@ test_dht_layout_new(void **state)
     assert_non_null(layout);
     assert_int_equal(layout->type, DHT_HASH_TYPE_DM);
     assert_int_equal(layout->cnt, cnt);
-    assert_int_equal(GF_ATOMIC_GET (layout->ref), 1);
+    assert_int_equal(GF_ATOMIC_GET(layout->ref), 1);
     assert_int_equal(layout->gen, 0);
     assert_int_equal(layout->spread_cnt, 0);
     free(layout);
@@ -107,7 +107,7 @@ test_dht_layout_new(void **state)
     assert_non_null(layout);
     assert_int_equal(layout->type, DHT_HASH_TYPE_DM);
     assert_int_equal(layout->cnt, cnt);
-    assert_int_equal(GF_ATOMIC_GET (layout->ref), 1);
+    assert_int_equal(GF_ATOMIC_GET(layout->ref), 1);
     assert_int_equal(layout->gen, conf->gen);
     assert_int_equal(layout->spread_cnt, conf->dir_spread_cnt);
     free(layout);
@@ -116,7 +116,9 @@ test_dht_layout_new(void **state)
     helper_xlator_destroy(xl);
 }
 
-int main(void) {
+int
+main(void)
+{
     const struct CMUnitTest xlator_dht_layout_tests[] = {
         unit_test(test_dht_layout_new),
     };
diff --git a/xlators/cluster/ec/src/ec-code-avx.c b/xlators/cluster/ec/src/ec-code-avx.c
index 92bd3e83c5e..70afaa00f54 100644
--- a/xlators/cluster/ec/src/ec-code-avx.c
+++ b/xlators/cluster/ec/src/ec-code-avx.c
@@ -34,10 +34,9 @@ ec_code_avx_load(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
                  uint32_t bit)
 {
     if (builder->linear) {
-        ec_code_intel_op_mov_m2avx(builder, REG_SI, REG_DX, 1,
-                                   idx * builder->width * builder->bits +
-                                   bit * builder->width,
-                                   dst);
+        ec_code_intel_op_mov_m2avx(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -81,10 +80,9 @@ ec_code_avx_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
                  uint32_t bit)
 {
     if (builder->linear) {
-        ec_code_intel_op_xor_m2avx(builder, REG_SI, REG_DX, 1,
-                                   idx * builder->width * builder->bits +
-                                   bit * builder->width,
-                                   dst);
+        ec_code_intel_op_xor_m2avx(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -96,21 +94,16 @@ ec_code_avx_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
     }
 }
 
-static char *ec_code_avx_needed_flags[] = {
-    "avx2",
-    NULL
-};
+static char *ec_code_avx_needed_flags[] = {"avx2", NULL};
 
-ec_code_gen_t ec_code_gen_avx = {
-    .name   = "avx",
-    .flags  = ec_code_avx_needed_flags,
-    .width  = 32,
-    .prolog = ec_code_avx_prolog,
-    .epilog = ec_code_avx_epilog,
-    .load   = ec_code_avx_load,
-    .store  = ec_code_avx_store,
-    .copy   = ec_code_avx_copy,
-    .xor2   = ec_code_avx_xor2,
-    .xor3   = ec_code_avx_xor3,
-    .xorm   = ec_code_avx_xorm
-};
+ec_code_gen_t ec_code_gen_avx = {.name = "avx",
+                                 .flags = ec_code_avx_needed_flags,
+                                 .width = 32,
+                                 .prolog = ec_code_avx_prolog,
+                                 .epilog = ec_code_avx_epilog,
+                                 .load = ec_code_avx_load,
+                                 .store = ec_code_avx_store,
+                                 .copy = ec_code_avx_copy,
+                                 .xor2 = ec_code_avx_xor2,
+                                 .xor3 = ec_code_avx_xor3,
+                                 .xorm = ec_code_avx_xorm};
diff --git a/xlators/cluster/ec/src/ec-code-c.c b/xlators/cluster/ec/src/ec-code-c.c
index 7387f3ea435..acdc665c2cf 100644
--- a/xlators/cluster/ec/src/ec-code-c.c
+++ b/xlators/cluster/ec/src/ec-code-c.c
@@ -16,12 +16,14 @@
 
 #define WIDTH (EC_METHOD_WORD_SIZE / sizeof(uint64_t))
 
-static void gf8_muladd_00(void *out, void *in)
+static void
+gf8_muladd_00(void *out, void *in)
 {
     memcpy(out, in, EC_METHOD_WORD_SIZE * 8);
 }
 
-static void gf8_muladd_01(void *out, void *in)
+static void
+gf8_muladd_01(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -42,7 +44,8 @@ static void gf8_muladd_01(void *out, void *in)
     }
 }
 
-static void gf8_muladd_02(void *out, void *in)
+static void
+gf8_muladd_02(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -83,7 +86,8 @@ static void gf8_muladd_02(void *out, void *in)
     }
 }
 
-static void gf8_muladd_03(void *out, void *in)
+static void
+gf8_muladd_03(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -126,7 +130,8 @@ static void gf8_muladd_03(void *out, void *in)
     }
 }
 
-static void gf8_muladd_04(void *out, void *in)
+static void
+gf8_muladd_04(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -169,7 +174,8 @@ static void gf8_muladd_04(void *out, void *in)
     }
 }
 
-static void gf8_muladd_05(void *out, void *in)
+static void
+gf8_muladd_05(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -210,7 +216,8 @@ static void gf8_muladd_05(void *out, void *in)
     }
 }
 
-static void gf8_muladd_06(void *out, void *in)
+static void
+gf8_muladd_06(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -253,7 +260,8 @@ static void gf8_muladd_06(void *out, void *in)
     }
 }
 
-static void gf8_muladd_07(void *out, void *in)
+static void
+gf8_muladd_07(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -299,7 +307,8 @@ static void gf8_muladd_07(void *out, void *in)
     }
 }
 
-static void gf8_muladd_08(void *out, void *in)
+static void
+gf8_muladd_08(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -340,7 +349,8 @@ static void gf8_muladd_08(void *out, void *in)
     }
 }
 
-static void gf8_muladd_09(void *out, void *in)
+static void
+gf8_muladd_09(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -383,7 +393,8 @@ static void gf8_muladd_09(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0A(void *out, void *in)
+static void
+gf8_muladd_0A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -424,7 +435,8 @@ static void gf8_muladd_0A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0B(void *out, void *in)
+static void
+gf8_muladd_0B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -469,7 +481,8 @@ static void gf8_muladd_0B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0C(void *out, void *in)
+static void
+gf8_muladd_0C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -513,7 +526,8 @@ static void gf8_muladd_0C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0D(void *out, void *in)
+static void
+gf8_muladd_0D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -558,7 +572,8 @@ static void gf8_muladd_0D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0E(void *out, void *in)
+static void
+gf8_muladd_0E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -604,7 +619,8 @@ static void gf8_muladd_0E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_0F(void *out, void *in)
+static void
+gf8_muladd_0F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -650,7 +666,8 @@ static void gf8_muladd_0F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_10(void *out, void *in)
+static void
+gf8_muladd_10(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -694,7 +711,8 @@ static void gf8_muladd_10(void *out, void *in)
     }
 }
 
-static void gf8_muladd_11(void *out, void *in)
+static void
+gf8_muladd_11(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -735,7 +753,8 @@ static void gf8_muladd_11(void *out, void *in)
     }
 }
 
-static void gf8_muladd_12(void *out, void *in)
+static void
+gf8_muladd_12(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -779,7 +798,8 @@ static void gf8_muladd_12(void *out, void *in)
     }
 }
 
-static void gf8_muladd_13(void *out, void *in)
+static void
+gf8_muladd_13(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -823,7 +843,8 @@ static void gf8_muladd_13(void *out, void *in)
     }
 }
 
-static void gf8_muladd_14(void *out, void *in)
+static void
+gf8_muladd_14(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -867,7 +888,8 @@ static void gf8_muladd_14(void *out, void *in)
     }
 }
 
-static void gf8_muladd_15(void *out, void *in)
+static void
+gf8_muladd_15(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -910,7 +932,8 @@ static void gf8_muladd_15(void *out, void *in)
     }
 }
 
-static void gf8_muladd_16(void *out, void *in)
+static void
+gf8_muladd_16(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -956,7 +979,8 @@ static void gf8_muladd_16(void *out, void *in)
     }
 }
 
-static void gf8_muladd_17(void *out, void *in)
+static void
+gf8_muladd_17(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1002,7 +1026,8 @@ static void gf8_muladd_17(void *out, void *in)
     }
 }
 
-static void gf8_muladd_18(void *out, void *in)
+static void
+gf8_muladd_18(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1046,7 +1071,8 @@ static void gf8_muladd_18(void *out, void *in)
     }
 }
 
-static void gf8_muladd_19(void *out, void *in)
+static void
+gf8_muladd_19(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1090,7 +1116,8 @@ static void gf8_muladd_19(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1A(void *out, void *in)
+static void
+gf8_muladd_1A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1136,7 +1163,8 @@ static void gf8_muladd_1A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1B(void *out, void *in)
+static void
+gf8_muladd_1B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1183,7 +1211,8 @@ static void gf8_muladd_1B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1C(void *out, void *in)
+static void
+gf8_muladd_1C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1230,7 +1259,8 @@ static void gf8_muladd_1C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1D(void *out, void *in)
+static void
+gf8_muladd_1D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1277,7 +1307,8 @@ static void gf8_muladd_1D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1E(void *out, void *in)
+static void
+gf8_muladd_1E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1323,7 +1354,8 @@ static void gf8_muladd_1E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_1F(void *out, void *in)
+static void
+gf8_muladd_1F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1367,7 +1399,8 @@ static void gf8_muladd_1F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_20(void *out, void *in)
+static void
+gf8_muladd_20(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1411,7 +1444,8 @@ static void gf8_muladd_20(void *out, void *in)
     }
 }
 
-static void gf8_muladd_21(void *out, void *in)
+static void
+gf8_muladd_21(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1454,7 +1488,8 @@ static void gf8_muladd_21(void *out, void *in)
     }
 }
 
-static void gf8_muladd_22(void *out, void *in)
+static void
+gf8_muladd_22(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1495,7 +1530,8 @@ static void gf8_muladd_22(void *out, void *in)
     }
 }
 
-static void gf8_muladd_23(void *out, void *in)
+static void
+gf8_muladd_23(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1536,7 +1572,8 @@ static void gf8_muladd_23(void *out, void *in)
     }
 }
 
-static void gf8_muladd_24(void *out, void *in)
+static void
+gf8_muladd_24(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1580,7 +1617,8 @@ static void gf8_muladd_24(void *out, void *in)
     }
 }
 
-static void gf8_muladd_25(void *out, void *in)
+static void
+gf8_muladd_25(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1623,7 +1661,8 @@ static void gf8_muladd_25(void *out, void *in)
     }
 }
 
-static void gf8_muladd_26(void *out, void *in)
+static void
+gf8_muladd_26(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1668,7 +1707,8 @@ static void gf8_muladd_26(void *out, void *in)
     }
 }
 
-static void gf8_muladd_27(void *out, void *in)
+static void
+gf8_muladd_27(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1709,7 +1749,8 @@ static void gf8_muladd_27(void *out, void *in)
     }
 }
 
-static void gf8_muladd_28(void *out, void *in)
+static void
+gf8_muladd_28(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1754,7 +1795,8 @@ static void gf8_muladd_28(void *out, void *in)
     }
 }
 
-static void gf8_muladd_29(void *out, void *in)
+static void
+gf8_muladd_29(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1799,7 +1841,8 @@ static void gf8_muladd_29(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2A(void *out, void *in)
+static void
+gf8_muladd_2A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1843,7 +1886,8 @@ static void gf8_muladd_2A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2B(void *out, void *in)
+static void
+gf8_muladd_2B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1887,7 +1931,8 @@ static void gf8_muladd_2B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2C(void *out, void *in)
+static void
+gf8_muladd_2C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1933,7 +1978,8 @@ static void gf8_muladd_2C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2D(void *out, void *in)
+static void
+gf8_muladd_2D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -1979,7 +2025,8 @@ static void gf8_muladd_2D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2E(void *out, void *in)
+static void
+gf8_muladd_2E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2024,7 +2071,8 @@ static void gf8_muladd_2E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_2F(void *out, void *in)
+static void
+gf8_muladd_2F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2069,7 +2117,8 @@ static void gf8_muladd_2F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_30(void *out, void *in)
+static void
+gf8_muladd_30(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2113,7 +2162,8 @@ static void gf8_muladd_30(void *out, void *in)
     }
 }
 
-static void gf8_muladd_31(void *out, void *in)
+static void
+gf8_muladd_31(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2158,7 +2208,8 @@ static void gf8_muladd_31(void *out, void *in)
     }
 }
 
-static void gf8_muladd_32(void *out, void *in)
+static void
+gf8_muladd_32(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2202,7 +2253,8 @@ static void gf8_muladd_32(void *out, void *in)
     }
 }
 
-static void gf8_muladd_33(void *out, void *in)
+static void
+gf8_muladd_33(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2249,7 +2301,8 @@ static void gf8_muladd_33(void *out, void *in)
     }
 }
 
-static void gf8_muladd_34(void *out, void *in)
+static void
+gf8_muladd_34(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2296,7 +2349,8 @@ static void gf8_muladd_34(void *out, void *in)
     }
 }
 
-static void gf8_muladd_35(void *out, void *in)
+static void
+gf8_muladd_35(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2341,7 +2395,8 @@ static void gf8_muladd_35(void *out, void *in)
     }
 }
 
-static void gf8_muladd_36(void *out, void *in)
+static void
+gf8_muladd_36(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2385,7 +2440,8 @@ static void gf8_muladd_36(void *out, void *in)
     }
 }
 
-static void gf8_muladd_37(void *out, void *in)
+static void
+gf8_muladd_37(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2431,7 +2487,8 @@ static void gf8_muladd_37(void *out, void *in)
     }
 }
 
-static void gf8_muladd_38(void *out, void *in)
+static void
+gf8_muladd_38(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2476,7 +2533,8 @@ static void gf8_muladd_38(void *out, void *in)
     }
 }
 
-static void gf8_muladd_39(void *out, void *in)
+static void
+gf8_muladd_39(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2521,7 +2579,8 @@ static void gf8_muladd_39(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3A(void *out, void *in)
+static void
+gf8_muladd_3A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2569,7 +2628,8 @@ static void gf8_muladd_3A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3B(void *out, void *in)
+static void
+gf8_muladd_3B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2614,7 +2674,8 @@ static void gf8_muladd_3B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3C(void *out, void *in)
+static void
+gf8_muladd_3C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2659,7 +2720,8 @@ static void gf8_muladd_3C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3D(void *out, void *in)
+static void
+gf8_muladd_3D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2704,7 +2766,8 @@ static void gf8_muladd_3D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3E(void *out, void *in)
+static void
+gf8_muladd_3E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2748,7 +2811,8 @@ static void gf8_muladd_3E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_3F(void *out, void *in)
+static void
+gf8_muladd_3F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2793,7 +2857,8 @@ static void gf8_muladd_3F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_40(void *out, void *in)
+static void
+gf8_muladd_40(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2837,7 +2902,8 @@ static void gf8_muladd_40(void *out, void *in)
     }
 }
 
-static void gf8_muladd_41(void *out, void *in)
+static void
+gf8_muladd_41(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2881,7 +2947,8 @@ static void gf8_muladd_41(void *out, void *in)
     }
 }
 
-static void gf8_muladd_42(void *out, void *in)
+static void
+gf8_muladd_42(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2922,7 +2989,8 @@ static void gf8_muladd_42(void *out, void *in)
     }
 }
 
-static void gf8_muladd_43(void *out, void *in)
+static void
+gf8_muladd_43(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -2963,7 +3031,8 @@ static void gf8_muladd_43(void *out, void *in)
     }
 }
 
-static void gf8_muladd_44(void *out, void *in)
+static void
+gf8_muladd_44(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3006,7 +3075,8 @@ static void gf8_muladd_44(void *out, void *in)
     }
 }
 
-static void gf8_muladd_45(void *out, void *in)
+static void
+gf8_muladd_45(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3047,7 +3117,8 @@ static void gf8_muladd_45(void *out, void *in)
     }
 }
 
-static void gf8_muladd_46(void *out, void *in)
+static void
+gf8_muladd_46(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3088,7 +3159,8 @@ static void gf8_muladd_46(void *out, void *in)
     }
 }
 
-static void gf8_muladd_47(void *out, void *in)
+static void
+gf8_muladd_47(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3131,7 +3203,8 @@ static void gf8_muladd_47(void *out, void *in)
     }
 }
 
-static void gf8_muladd_48(void *out, void *in)
+static void
+gf8_muladd_48(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3175,7 +3248,8 @@ static void gf8_muladd_48(void *out, void *in)
     }
 }
 
-static void gf8_muladd_49(void *out, void *in)
+static void
+gf8_muladd_49(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3219,7 +3293,8 @@ static void gf8_muladd_49(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4A(void *out, void *in)
+static void
+gf8_muladd_4A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3263,7 +3338,8 @@ static void gf8_muladd_4A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4B(void *out, void *in)
+static void
+gf8_muladd_4B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3309,7 +3385,8 @@ static void gf8_muladd_4B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4C(void *out, void *in)
+static void
+gf8_muladd_4C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3354,7 +3431,8 @@ static void gf8_muladd_4C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4D(void *out, void *in)
+static void
+gf8_muladd_4D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3399,7 +3477,8 @@ static void gf8_muladd_4D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4E(void *out, void *in)
+static void
+gf8_muladd_4E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3440,7 +3519,8 @@ static void gf8_muladd_4E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_4F(void *out, void *in)
+static void
+gf8_muladd_4F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3481,7 +3561,8 @@ static void gf8_muladd_4F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_50(void *out, void *in)
+static void
+gf8_muladd_50(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3526,7 +3607,8 @@ static void gf8_muladd_50(void *out, void *in)
     }
 }
 
-static void gf8_muladd_51(void *out, void *in)
+static void
+gf8_muladd_51(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3567,7 +3649,8 @@ static void gf8_muladd_51(void *out, void *in)
     }
 }
 
-static void gf8_muladd_52(void *out, void *in)
+static void
+gf8_muladd_52(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3613,7 +3696,8 @@ static void gf8_muladd_52(void *out, void *in)
     }
 }
 
-static void gf8_muladd_53(void *out, void *in)
+static void
+gf8_muladd_53(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3654,7 +3738,8 @@ static void gf8_muladd_53(void *out, void *in)
     }
 }
 
-static void gf8_muladd_54(void *out, void *in)
+static void
+gf8_muladd_54(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3700,7 +3785,8 @@ static void gf8_muladd_54(void *out, void *in)
     }
 }
 
-static void gf8_muladd_55(void *out, void *in)
+static void
+gf8_muladd_55(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3745,7 +3831,8 @@ static void gf8_muladd_55(void *out, void *in)
     }
 }
 
-static void gf8_muladd_56(void *out, void *in)
+static void
+gf8_muladd_56(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3788,7 +3875,8 @@ static void gf8_muladd_56(void *out, void *in)
     }
 }
 
-static void gf8_muladd_57(void *out, void *in)
+static void
+gf8_muladd_57(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3832,7 +3920,8 @@ static void gf8_muladd_57(void *out, void *in)
     }
 }
 
-static void gf8_muladd_58(void *out, void *in)
+static void
+gf8_muladd_58(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3876,7 +3965,8 @@ static void gf8_muladd_58(void *out, void *in)
     }
 }
 
-static void gf8_muladd_59(void *out, void *in)
+static void
+gf8_muladd_59(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3920,7 +4010,8 @@ static void gf8_muladd_59(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5A(void *out, void *in)
+static void
+gf8_muladd_5A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -3965,7 +4056,8 @@ static void gf8_muladd_5A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5B(void *out, void *in)
+static void
+gf8_muladd_5B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4012,7 +4104,8 @@ static void gf8_muladd_5B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5C(void *out, void *in)
+static void
+gf8_muladd_5C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4057,7 +4150,8 @@ static void gf8_muladd_5C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5D(void *out, void *in)
+static void
+gf8_muladd_5D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4104,7 +4198,8 @@ static void gf8_muladd_5D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5E(void *out, void *in)
+static void
+gf8_muladd_5E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4151,7 +4246,8 @@ static void gf8_muladd_5E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_5F(void *out, void *in)
+static void
+gf8_muladd_5F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4197,7 +4293,8 @@ static void gf8_muladd_5F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_60(void *out, void *in)
+static void
+gf8_muladd_60(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4241,7 +4338,8 @@ static void gf8_muladd_60(void *out, void *in)
     }
 }
 
-static void gf8_muladd_61(void *out, void *in)
+static void
+gf8_muladd_61(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4285,7 +4383,8 @@ static void gf8_muladd_61(void *out, void *in)
     }
 }
 
-static void gf8_muladd_62(void *out, void *in)
+static void
+gf8_muladd_62(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4331,7 +4430,8 @@ static void gf8_muladd_62(void *out, void *in)
     }
 }
 
-static void gf8_muladd_63(void *out, void *in)
+static void
+gf8_muladd_63(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4378,7 +4478,8 @@ static void gf8_muladd_63(void *out, void *in)
     }
 }
 
-static void gf8_muladd_64(void *out, void *in)
+static void
+gf8_muladd_64(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4422,7 +4523,8 @@ static void gf8_muladd_64(void *out, void *in)
     }
 }
 
-static void gf8_muladd_65(void *out, void *in)
+static void
+gf8_muladd_65(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4468,7 +4570,8 @@ static void gf8_muladd_65(void *out, void *in)
     }
 }
 
-static void gf8_muladd_66(void *out, void *in)
+static void
+gf8_muladd_66(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4515,7 +4618,8 @@ static void gf8_muladd_66(void *out, void *in)
     }
 }
 
-static void gf8_muladd_67(void *out, void *in)
+static void
+gf8_muladd_67(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4561,7 +4665,8 @@ static void gf8_muladd_67(void *out, void *in)
     }
 }
 
-static void gf8_muladd_68(void *out, void *in)
+static void
+gf8_muladd_68(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4607,7 +4712,8 @@ static void gf8_muladd_68(void *out, void *in)
     }
 }
 
-static void gf8_muladd_69(void *out, void *in)
+static void
+gf8_muladd_69(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4650,7 +4756,8 @@ static void gf8_muladd_69(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6A(void *out, void *in)
+static void
+gf8_muladd_6A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4695,7 +4802,8 @@ static void gf8_muladd_6A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6B(void *out, void *in)
+static void
+gf8_muladd_6B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4739,7 +4847,8 @@ static void gf8_muladd_6B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6C(void *out, void *in)
+static void
+gf8_muladd_6C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4783,7 +4892,8 @@ static void gf8_muladd_6C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6D(void *out, void *in)
+static void
+gf8_muladd_6D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4827,7 +4937,8 @@ static void gf8_muladd_6D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6E(void *out, void *in)
+static void
+gf8_muladd_6E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4872,7 +4983,8 @@ static void gf8_muladd_6E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_6F(void *out, void *in)
+static void
+gf8_muladd_6F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4917,7 +5029,8 @@ static void gf8_muladd_6F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_70(void *out, void *in)
+static void
+gf8_muladd_70(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -4962,7 +5075,8 @@ static void gf8_muladd_70(void *out, void *in)
     }
 }
 
-static void gf8_muladd_71(void *out, void *in)
+static void
+gf8_muladd_71(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5007,7 +5121,8 @@ static void gf8_muladd_71(void *out, void *in)
     }
 }
 
-static void gf8_muladd_72(void *out, void *in)
+static void
+gf8_muladd_72(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5052,7 +5167,8 @@ static void gf8_muladd_72(void *out, void *in)
     }
 }
 
-static void gf8_muladd_73(void *out, void *in)
+static void
+gf8_muladd_73(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5093,7 +5209,8 @@ static void gf8_muladd_73(void *out, void *in)
     }
 }
 
-static void gf8_muladd_74(void *out, void *in)
+static void
+gf8_muladd_74(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5137,7 +5254,8 @@ static void gf8_muladd_74(void *out, void *in)
     }
 }
 
-static void gf8_muladd_75(void *out, void *in)
+static void
+gf8_muladd_75(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5182,7 +5300,8 @@ static void gf8_muladd_75(void *out, void *in)
     }
 }
 
-static void gf8_muladd_76(void *out, void *in)
+static void
+gf8_muladd_76(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5228,7 +5347,8 @@ static void gf8_muladd_76(void *out, void *in)
     }
 }
 
-static void gf8_muladd_77(void *out, void *in)
+static void
+gf8_muladd_77(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5274,7 +5394,8 @@ static void gf8_muladd_77(void *out, void *in)
     }
 }
 
-static void gf8_muladd_78(void *out, void *in)
+static void
+gf8_muladd_78(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5319,7 +5440,8 @@ static void gf8_muladd_78(void *out, void *in)
     }
 }
 
-static void gf8_muladd_79(void *out, void *in)
+static void
+gf8_muladd_79(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5365,7 +5487,8 @@ static void gf8_muladd_79(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7A(void *out, void *in)
+static void
+gf8_muladd_7A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5409,7 +5532,8 @@ static void gf8_muladd_7A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7B(void *out, void *in)
+static void
+gf8_muladd_7B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5454,7 +5578,8 @@ static void gf8_muladd_7B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7C(void *out, void *in)
+static void
+gf8_muladd_7C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5498,7 +5623,8 @@ static void gf8_muladd_7C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7D(void *out, void *in)
+static void
+gf8_muladd_7D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5544,7 +5670,8 @@ static void gf8_muladd_7D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7E(void *out, void *in)
+static void
+gf8_muladd_7E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5589,7 +5716,8 @@ static void gf8_muladd_7E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_7F(void *out, void *in)
+static void
+gf8_muladd_7F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5635,7 +5763,8 @@ static void gf8_muladd_7F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_80(void *out, void *in)
+static void
+gf8_muladd_80(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5680,7 +5809,8 @@ static void gf8_muladd_80(void *out, void *in)
     }
 }
 
-static void gf8_muladd_81(void *out, void *in)
+static void
+gf8_muladd_81(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5724,7 +5854,8 @@ static void gf8_muladd_81(void *out, void *in)
     }
 }
 
-static void gf8_muladd_82(void *out, void *in)
+static void
+gf8_muladd_82(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5767,7 +5898,8 @@ static void gf8_muladd_82(void *out, void *in)
     }
 }
 
-static void gf8_muladd_83(void *out, void *in)
+static void
+gf8_muladd_83(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5814,7 +5946,8 @@ static void gf8_muladd_83(void *out, void *in)
     }
 }
 
-static void gf8_muladd_84(void *out, void *in)
+static void
+gf8_muladd_84(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5855,7 +5988,8 @@ static void gf8_muladd_84(void *out, void *in)
     }
 }
 
-static void gf8_muladd_85(void *out, void *in)
+static void
+gf8_muladd_85(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5901,7 +6035,8 @@ static void gf8_muladd_85(void *out, void *in)
     }
 }
 
-static void gf8_muladd_86(void *out, void *in)
+static void
+gf8_muladd_86(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5942,7 +6077,8 @@ static void gf8_muladd_86(void *out, void *in)
     }
 }
 
-static void gf8_muladd_87(void *out, void *in)
+static void
+gf8_muladd_87(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -5986,7 +6122,8 @@ static void gf8_muladd_87(void *out, void *in)
     }
 }
 
-static void gf8_muladd_88(void *out, void *in)
+static void
+gf8_muladd_88(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6030,7 +6167,8 @@ static void gf8_muladd_88(void *out, void *in)
     }
 }
 
-static void gf8_muladd_89(void *out, void *in)
+static void
+gf8_muladd_89(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6075,7 +6213,8 @@ static void gf8_muladd_89(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8A(void *out, void *in)
+static void
+gf8_muladd_8A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6116,7 +6255,8 @@ static void gf8_muladd_8A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8B(void *out, void *in)
+static void
+gf8_muladd_8B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6163,7 +6303,8 @@ static void gf8_muladd_8B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8C(void *out, void *in)
+static void
+gf8_muladd_8C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6204,7 +6345,8 @@ static void gf8_muladd_8C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8D(void *out, void *in)
+static void
+gf8_muladd_8D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6247,7 +6389,8 @@ static void gf8_muladd_8D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8E(void *out, void *in)
+static void
+gf8_muladd_8E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6288,7 +6431,8 @@ static void gf8_muladd_8E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_8F(void *out, void *in)
+static void
+gf8_muladd_8F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6331,7 +6475,8 @@ static void gf8_muladd_8F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_90(void *out, void *in)
+static void
+gf8_muladd_90(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6376,7 +6521,8 @@ static void gf8_muladd_90(void *out, void *in)
     }
 }
 
-static void gf8_muladd_91(void *out, void *in)
+static void
+gf8_muladd_91(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6422,7 +6568,8 @@ static void gf8_muladd_91(void *out, void *in)
     }
 }
 
-static void gf8_muladd_92(void *out, void *in)
+static void
+gf8_muladd_92(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6466,7 +6613,8 @@ static void gf8_muladd_92(void *out, void *in)
     }
 }
 
-static void gf8_muladd_93(void *out, void *in)
+static void
+gf8_muladd_93(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6511,7 +6659,8 @@ static void gf8_muladd_93(void *out, void *in)
     }
 }
 
-static void gf8_muladd_94(void *out, void *in)
+static void
+gf8_muladd_94(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6554,7 +6703,8 @@ static void gf8_muladd_94(void *out, void *in)
     }
 }
 
-static void gf8_muladd_95(void *out, void *in)
+static void
+gf8_muladd_95(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6602,7 +6752,8 @@ static void gf8_muladd_95(void *out, void *in)
     }
 }
 
-static void gf8_muladd_96(void *out, void *in)
+static void
+gf8_muladd_96(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6647,7 +6798,8 @@ static void gf8_muladd_96(void *out, void *in)
     }
 }
 
-static void gf8_muladd_97(void *out, void *in)
+static void
+gf8_muladd_97(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6693,7 +6845,8 @@ static void gf8_muladd_97(void *out, void *in)
     }
 }
 
-static void gf8_muladd_98(void *out, void *in)
+static void
+gf8_muladd_98(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6737,7 +6890,8 @@ static void gf8_muladd_98(void *out, void *in)
     }
 }
 
-static void gf8_muladd_99(void *out, void *in)
+static void
+gf8_muladd_99(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6782,7 +6936,8 @@ static void gf8_muladd_99(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9A(void *out, void *in)
+static void
+gf8_muladd_9A(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6827,7 +6982,8 @@ static void gf8_muladd_9A(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9B(void *out, void *in)
+static void
+gf8_muladd_9B(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6870,7 +7026,8 @@ static void gf8_muladd_9B(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9C(void *out, void *in)
+static void
+gf8_muladd_9C(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6913,7 +7070,8 @@ static void gf8_muladd_9C(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9D(void *out, void *in)
+static void
+gf8_muladd_9D(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6956,7 +7114,8 @@ static void gf8_muladd_9D(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9E(void *out, void *in)
+static void
+gf8_muladd_9E(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -6999,7 +7158,8 @@ static void gf8_muladd_9E(void *out, void *in)
     }
 }
 
-static void gf8_muladd_9F(void *out, void *in)
+static void
+gf8_muladd_9F(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7042,7 +7202,8 @@ static void gf8_muladd_9F(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A0(void *out, void *in)
+static void
+gf8_muladd_A0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7088,7 +7249,8 @@ static void gf8_muladd_A0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A1(void *out, void *in)
+static void
+gf8_muladd_A1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7133,7 +7295,8 @@ static void gf8_muladd_A1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A2(void *out, void *in)
+static void
+gf8_muladd_A2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7176,7 +7339,8 @@ static void gf8_muladd_A2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A3(void *out, void *in)
+static void
+gf8_muladd_A3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7220,7 +7384,8 @@ static void gf8_muladd_A3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A4(void *out, void *in)
+static void
+gf8_muladd_A4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7267,7 +7432,8 @@ static void gf8_muladd_A4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A5(void *out, void *in)
+static void
+gf8_muladd_A5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7312,7 +7478,8 @@ static void gf8_muladd_A5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A6(void *out, void *in)
+static void
+gf8_muladd_A6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7353,7 +7520,8 @@ static void gf8_muladd_A6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A7(void *out, void *in)
+static void
+gf8_muladd_A7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7394,7 +7562,8 @@ static void gf8_muladd_A7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A8(void *out, void *in)
+static void
+gf8_muladd_A8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7439,7 +7608,8 @@ static void gf8_muladd_A8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_A9(void *out, void *in)
+static void
+gf8_muladd_A9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7480,7 +7650,8 @@ static void gf8_muladd_A9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AA(void *out, void *in)
+static void
+gf8_muladd_AA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7525,7 +7696,8 @@ static void gf8_muladd_AA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AB(void *out, void *in)
+static void
+gf8_muladd_AB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7569,7 +7741,8 @@ static void gf8_muladd_AB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AC(void *out, void *in)
+static void
+gf8_muladd_AC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7612,7 +7785,8 @@ static void gf8_muladd_AC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AD(void *out, void *in)
+static void
+gf8_muladd_AD(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7653,7 +7827,8 @@ static void gf8_muladd_AD(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AE(void *out, void *in)
+static void
+gf8_muladd_AE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7698,7 +7873,8 @@ static void gf8_muladd_AE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_AF(void *out, void *in)
+static void
+gf8_muladd_AF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7741,7 +7917,8 @@ static void gf8_muladd_AF(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B0(void *out, void *in)
+static void
+gf8_muladd_B0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7787,7 +7964,8 @@ static void gf8_muladd_B0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B1(void *out, void *in)
+static void
+gf8_muladd_B1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7831,7 +8009,8 @@ static void gf8_muladd_B1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B2(void *out, void *in)
+static void
+gf8_muladd_B2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7878,7 +8057,8 @@ static void gf8_muladd_B2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B3(void *out, void *in)
+static void
+gf8_muladd_B3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7923,7 +8103,8 @@ static void gf8_muladd_B3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B4(void *out, void *in)
+static void
+gf8_muladd_B4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -7966,7 +8147,8 @@ static void gf8_muladd_B4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B5(void *out, void *in)
+static void
+gf8_muladd_B5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8011,7 +8193,8 @@ static void gf8_muladd_B5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B6(void *out, void *in)
+static void
+gf8_muladd_B6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8057,7 +8240,8 @@ static void gf8_muladd_B6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B7(void *out, void *in)
+static void
+gf8_muladd_B7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8101,7 +8285,8 @@ static void gf8_muladd_B7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B8(void *out, void *in)
+static void
+gf8_muladd_B8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8146,7 +8331,8 @@ static void gf8_muladd_B8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_B9(void *out, void *in)
+static void
+gf8_muladd_B9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8191,7 +8377,8 @@ static void gf8_muladd_B9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BA(void *out, void *in)
+static void
+gf8_muladd_BA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8236,7 +8423,8 @@ static void gf8_muladd_BA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BB(void *out, void *in)
+static void
+gf8_muladd_BB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8280,7 +8468,8 @@ static void gf8_muladd_BB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BC(void *out, void *in)
+static void
+gf8_muladd_BC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8325,7 +8514,8 @@ static void gf8_muladd_BC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BD(void *out, void *in)
+static void
+gf8_muladd_BD(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8370,7 +8560,8 @@ static void gf8_muladd_BD(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BE(void *out, void *in)
+static void
+gf8_muladd_BE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8413,7 +8604,8 @@ static void gf8_muladd_BE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_BF(void *out, void *in)
+static void
+gf8_muladd_BF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8459,7 +8651,8 @@ static void gf8_muladd_BF(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C0(void *out, void *in)
+static void
+gf8_muladd_C0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8503,7 +8696,8 @@ static void gf8_muladd_C0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C1(void *out, void *in)
+static void
+gf8_muladd_C1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8547,7 +8741,8 @@ static void gf8_muladd_C1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C2(void *out, void *in)
+static void
+gf8_muladd_C2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8591,7 +8786,8 @@ static void gf8_muladd_C2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C3(void *out, void *in)
+static void
+gf8_muladd_C3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8636,7 +8832,8 @@ static void gf8_muladd_C3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C4(void *out, void *in)
+static void
+gf8_muladd_C4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8680,7 +8877,8 @@ static void gf8_muladd_C4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C5(void *out, void *in)
+static void
+gf8_muladd_C5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8723,7 +8921,8 @@ static void gf8_muladd_C5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C6(void *out, void *in)
+static void
+gf8_muladd_C6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8771,7 +8970,8 @@ static void gf8_muladd_C6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C7(void *out, void *in)
+static void
+gf8_muladd_C7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8815,7 +9015,8 @@ static void gf8_muladd_C7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C8(void *out, void *in)
+static void
+gf8_muladd_C8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8859,7 +9060,8 @@ static void gf8_muladd_C8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_C9(void *out, void *in)
+static void
+gf8_muladd_C9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8902,7 +9104,8 @@ static void gf8_muladd_C9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CA(void *out, void *in)
+static void
+gf8_muladd_CA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8948,7 +9151,8 @@ static void gf8_muladd_CA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CB(void *out, void *in)
+static void
+gf8_muladd_CB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -8993,7 +9197,8 @@ static void gf8_muladd_CB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CC(void *out, void *in)
+static void
+gf8_muladd_CC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9039,7 +9244,8 @@ static void gf8_muladd_CC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CD(void *out, void *in)
+static void
+gf8_muladd_CD(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9083,7 +9289,8 @@ static void gf8_muladd_CD(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CE(void *out, void *in)
+static void
+gf8_muladd_CE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9128,7 +9335,8 @@ static void gf8_muladd_CE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_CF(void *out, void *in)
+static void
+gf8_muladd_CF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9173,7 +9381,8 @@ static void gf8_muladd_CF(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D0(void *out, void *in)
+static void
+gf8_muladd_D0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9220,7 +9429,8 @@ static void gf8_muladd_D0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D1(void *out, void *in)
+static void
+gf8_muladd_D1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9265,7 +9475,8 @@ static void gf8_muladd_D1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D2(void *out, void *in)
+static void
+gf8_muladd_D2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9308,7 +9519,8 @@ static void gf8_muladd_D2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D3(void *out, void *in)
+static void
+gf8_muladd_D3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9354,7 +9566,8 @@ static void gf8_muladd_D3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D4(void *out, void *in)
+static void
+gf8_muladd_D4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9399,7 +9612,8 @@ static void gf8_muladd_D4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D5(void *out, void *in)
+static void
+gf8_muladd_D5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9444,7 +9658,8 @@ static void gf8_muladd_D5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D6(void *out, void *in)
+static void
+gf8_muladd_D6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9488,7 +9703,8 @@ static void gf8_muladd_D6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D7(void *out, void *in)
+static void
+gf8_muladd_D7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9533,7 +9749,8 @@ static void gf8_muladd_D7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D8(void *out, void *in)
+static void
+gf8_muladd_D8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9577,7 +9794,8 @@ static void gf8_muladd_D8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_D9(void *out, void *in)
+static void
+gf8_muladd_D9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9618,7 +9836,8 @@ static void gf8_muladd_D9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DA(void *out, void *in)
+static void
+gf8_muladd_DA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9662,7 +9881,8 @@ static void gf8_muladd_DA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DB(void *out, void *in)
+static void
+gf8_muladd_DB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9709,7 +9929,8 @@ static void gf8_muladd_DB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DC(void *out, void *in)
+static void
+gf8_muladd_DC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9755,7 +9976,8 @@ static void gf8_muladd_DC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DD(void *out, void *in)
+static void
+gf8_muladd_DD(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9796,7 +10018,8 @@ static void gf8_muladd_DD(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DE(void *out, void *in)
+static void
+gf8_muladd_DE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9840,7 +10063,8 @@ static void gf8_muladd_DE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_DF(void *out, void *in)
+static void
+gf8_muladd_DF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9885,7 +10109,8 @@ static void gf8_muladd_DF(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E0(void *out, void *in)
+static void
+gf8_muladd_E0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9929,7 +10154,8 @@ static void gf8_muladd_E0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E1(void *out, void *in)
+static void
+gf8_muladd_E1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -9975,7 +10201,8 @@ static void gf8_muladd_E1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E2(void *out, void *in)
+static void
+gf8_muladd_E2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10016,7 +10243,8 @@ static void gf8_muladd_E2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E3(void *out, void *in)
+static void
+gf8_muladd_E3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10063,7 +10291,8 @@ static void gf8_muladd_E3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E4(void *out, void *in)
+static void
+gf8_muladd_E4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10108,7 +10337,8 @@ static void gf8_muladd_E4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E5(void *out, void *in)
+static void
+gf8_muladd_E5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10153,7 +10383,8 @@ static void gf8_muladd_E5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E6(void *out, void *in)
+static void
+gf8_muladd_E6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10194,7 +10425,8 @@ static void gf8_muladd_E6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E7(void *out, void *in)
+static void
+gf8_muladd_E7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10241,7 +10473,8 @@ static void gf8_muladd_E7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E8(void *out, void *in)
+static void
+gf8_muladd_E8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10287,7 +10520,8 @@ static void gf8_muladd_E8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_E9(void *out, void *in)
+static void
+gf8_muladd_E9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10332,7 +10566,8 @@ static void gf8_muladd_E9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_EA(void *out, void *in)
+static void
+gf8_muladd_EA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10373,7 +10608,8 @@ static void gf8_muladd_EA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_EB(void *out, void *in)
+static void
+gf8_muladd_EB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10417,7 +10653,8 @@ static void gf8_muladd_EB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_EC(void *out, void *in)
+static void
+gf8_muladd_EC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10458,7 +10695,8 @@ static void gf8_muladd_EC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_ED(void *out, void *in)
+static void
+gf8_muladd_ED(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10502,7 +10740,8 @@ static void gf8_muladd_ED(void *out, void *in)
     }
 }
 
-static void gf8_muladd_EE(void *out, void *in)
+static void
+gf8_muladd_EE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10548,7 +10787,8 @@ static void gf8_muladd_EE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_EF(void *out, void *in)
+static void
+gf8_muladd_EF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10592,7 +10832,8 @@ static void gf8_muladd_EF(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F0(void *out, void *in)
+static void
+gf8_muladd_F0(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10638,7 +10879,8 @@ static void gf8_muladd_F0(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F1(void *out, void *in)
+static void
+gf8_muladd_F1(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10684,7 +10926,8 @@ static void gf8_muladd_F1(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F2(void *out, void *in)
+static void
+gf8_muladd_F2(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10730,7 +10973,8 @@ static void gf8_muladd_F2(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F3(void *out, void *in)
+static void
+gf8_muladd_F3(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10774,7 +11018,8 @@ static void gf8_muladd_F3(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F4(void *out, void *in)
+static void
+gf8_muladd_F4(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10817,7 +11062,8 @@ static void gf8_muladd_F4(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F5(void *out, void *in)
+static void
+gf8_muladd_F5(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10860,7 +11106,8 @@ static void gf8_muladd_F5(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F6(void *out, void *in)
+static void
+gf8_muladd_F6(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10904,7 +11151,8 @@ static void gf8_muladd_F6(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F7(void *out, void *in)
+static void
+gf8_muladd_F7(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10947,7 +11195,8 @@ static void gf8_muladd_F7(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F8(void *out, void *in)
+static void
+gf8_muladd_F8(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -10992,7 +11241,8 @@ static void gf8_muladd_F8(void *out, void *in)
     }
 }
 
-static void gf8_muladd_F9(void *out, void *in)
+static void
+gf8_muladd_F9(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11039,7 +11289,8 @@ static void gf8_muladd_F9(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FA(void *out, void *in)
+static void
+gf8_muladd_FA(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11085,7 +11336,8 @@ static void gf8_muladd_FA(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FB(void *out, void *in)
+static void
+gf8_muladd_FB(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11129,7 +11381,8 @@ static void gf8_muladd_FB(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FC(void *out, void *in)
+static void
+gf8_muladd_FC(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11175,7 +11428,8 @@ static void gf8_muladd_FC(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FD(void *out, void *in)
+static void
+gf8_muladd_FD(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11221,7 +11475,8 @@ static void gf8_muladd_FD(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FE(void *out, void *in)
+static void
+gf8_muladd_FE(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11268,7 +11523,8 @@ static void gf8_muladd_FE(void *out, void *in)
     }
 }
 
-static void gf8_muladd_FF(void *out, void *in)
+static void
+gf8_muladd_FF(void *out, void *in)
 {
     unsigned int i;
     uint64_t *in_ptr = (uint64_t *)in;
@@ -11315,75 +11571,65 @@ static void gf8_muladd_FF(void *out, void *in)
 }
 
 static void (*gf8_muladd[])(void *out, void *in) = {
-    gf8_muladd_00, gf8_muladd_01, gf8_muladd_02, gf8_muladd_03,
-    gf8_muladd_04, gf8_muladd_05, gf8_muladd_06, gf8_muladd_07,
-    gf8_muladd_08, gf8_muladd_09, gf8_muladd_0A, gf8_muladd_0B,
-    gf8_muladd_0C, gf8_muladd_0D, gf8_muladd_0E, gf8_muladd_0F,
-    gf8_muladd_10, gf8_muladd_11, gf8_muladd_12, gf8_muladd_13,
-    gf8_muladd_14, gf8_muladd_15, gf8_muladd_16, gf8_muladd_17,
-    gf8_muladd_18, gf8_muladd_19, gf8_muladd_1A, gf8_muladd_1B,
-    gf8_muladd_1C, gf8_muladd_1D, gf8_muladd_1E, gf8_muladd_1F,
-    gf8_muladd_20, gf8_muladd_21, gf8_muladd_22, gf8_muladd_23,
-    gf8_muladd_24, gf8_muladd_25, gf8_muladd_26, gf8_muladd_27,
-    gf8_muladd_28, gf8_muladd_29, gf8_muladd_2A, gf8_muladd_2B,
-    gf8_muladd_2C, gf8_muladd_2D, gf8_muladd_2E, gf8_muladd_2F,
-    gf8_muladd_30, gf8_muladd_31, gf8_muladd_32, gf8_muladd_33,
-    gf8_muladd_34, gf8_muladd_35, gf8_muladd_36, gf8_muladd_37,
-    gf8_muladd_38, gf8_muladd_39, gf8_muladd_3A, gf8_muladd_3B,
-    gf8_muladd_3C, gf8_muladd_3D, gf8_muladd_3E, gf8_muladd_3F,
-    gf8_muladd_40, gf8_muladd_41, gf8_muladd_42, gf8_muladd_43,
-    gf8_muladd_44, gf8_muladd_45, gf8_muladd_46, gf8_muladd_47,
-    gf8_muladd_48, gf8_muladd_49, gf8_muladd_4A, gf8_muladd_4B,
-    gf8_muladd_4C, gf8_muladd_4D, gf8_muladd_4E, gf8_muladd_4F,
-    gf8_muladd_50, gf8_muladd_51, gf8_muladd_52, gf8_muladd_53,
-    gf8_muladd_54, gf8_muladd_55, gf8_muladd_56, gf8_muladd_57,
-    gf8_muladd_58, gf8_muladd_59, gf8_muladd_5A, gf8_muladd_5B,
-    gf8_muladd_5C, gf8_muladd_5D, gf8_muladd_5E, gf8_muladd_5F,
-    gf8_muladd_60, gf8_muladd_61, gf8_muladd_62, gf8_muladd_63,
-    gf8_muladd_64, gf8_muladd_65, gf8_muladd_66, gf8_muladd_67,
-    gf8_muladd_68, gf8_muladd_69, gf8_muladd_6A, gf8_muladd_6B,
-    gf8_muladd_6C, gf8_muladd_6D, gf8_muladd_6E, gf8_muladd_6F,
-    gf8_muladd_70, gf8_muladd_71, gf8_muladd_72, gf8_muladd_73,
-    gf8_muladd_74, gf8_muladd_75, gf8_muladd_76, gf8_muladd_77,
-    gf8_muladd_78, gf8_muladd_79, gf8_muladd_7A, gf8_muladd_7B,
-    gf8_muladd_7C, gf8_muladd_7D, gf8_muladd_7E, gf8_muladd_7F,
-    gf8_muladd_80, gf8_muladd_81, gf8_muladd_82, gf8_muladd_83,
-    gf8_muladd_84, gf8_muladd_85, gf8_muladd_86, gf8_muladd_87,
-    gf8_muladd_88, gf8_muladd_89, gf8_muladd_8A, gf8_muladd_8B,
-    gf8_muladd_8C, gf8_muladd_8D, gf8_muladd_8E, gf8_muladd_8F,
-    gf8_muladd_90, gf8_muladd_91, gf8_muladd_92, gf8_muladd_93,
-    gf8_muladd_94, gf8_muladd_95, gf8_muladd_96, gf8_muladd_97,
-    gf8_muladd_98, gf8_muladd_99, gf8_muladd_9A, gf8_muladd_9B,
-    gf8_muladd_9C, gf8_muladd_9D, gf8_muladd_9E, gf8_muladd_9F,
-    gf8_muladd_A0, gf8_muladd_A1, gf8_muladd_A2, gf8_muladd_A3,
-    gf8_muladd_A4, gf8_muladd_A5, gf8_muladd_A6, gf8_muladd_A7,
-    gf8_muladd_A8, gf8_muladd_A9, gf8_muladd_AA, gf8_muladd_AB,
-    gf8_muladd_AC, gf8_muladd_AD, gf8_muladd_AE, gf8_muladd_AF,
-    gf8_muladd_B0, gf8_muladd_B1, gf8_muladd_B2, gf8_muladd_B3,
-    gf8_muladd_B4, gf8_muladd_B5, gf8_muladd_B6, gf8_muladd_B7,
-    gf8_muladd_B8, gf8_muladd_B9, gf8_muladd_BA, gf8_muladd_BB,
-    gf8_muladd_BC, gf8_muladd_BD, gf8_muladd_BE, gf8_muladd_BF,
-    gf8_muladd_C0, gf8_muladd_C1, gf8_muladd_C2, gf8_muladd_C3,
-    gf8_muladd_C4, gf8_muladd_C5, gf8_muladd_C6, gf8_muladd_C7,
-    gf8_muladd_C8, gf8_muladd_C9, gf8_muladd_CA, gf8_muladd_CB,
-    gf8_muladd_CC, gf8_muladd_CD, gf8_muladd_CE, gf8_muladd_CF,
-    gf8_muladd_D0, gf8_muladd_D1, gf8_muladd_D2, gf8_muladd_D3,
-    gf8_muladd_D4, gf8_muladd_D5, gf8_muladd_D6, gf8_muladd_D7,
-    gf8_muladd_D8, gf8_muladd_D9, gf8_muladd_DA, gf8_muladd_DB,
-    gf8_muladd_DC, gf8_muladd_DD, gf8_muladd_DE, gf8_muladd_DF,
-    gf8_muladd_E0, gf8_muladd_E1, gf8_muladd_E2, gf8_muladd_E3,
-    gf8_muladd_E4, gf8_muladd_E5, gf8_muladd_E6, gf8_muladd_E7,
-    gf8_muladd_E8, gf8_muladd_E9, gf8_muladd_EA, gf8_muladd_EB,
-    gf8_muladd_EC, gf8_muladd_ED, gf8_muladd_EE, gf8_muladd_EF,
-    gf8_muladd_F0, gf8_muladd_F1, gf8_muladd_F2, gf8_muladd_F3,
-    gf8_muladd_F4, gf8_muladd_F5, gf8_muladd_F6, gf8_muladd_F7,
-    gf8_muladd_F8, gf8_muladd_F9, gf8_muladd_FA, gf8_muladd_FB,
-    gf8_muladd_FC, gf8_muladd_FD, gf8_muladd_FE, gf8_muladd_FF
+    gf8_muladd_00, gf8_muladd_01, gf8_muladd_02, gf8_muladd_03, gf8_muladd_04,
+    gf8_muladd_05, gf8_muladd_06, gf8_muladd_07, gf8_muladd_08, gf8_muladd_09,
+    gf8_muladd_0A, gf8_muladd_0B, gf8_muladd_0C, gf8_muladd_0D, gf8_muladd_0E,
+    gf8_muladd_0F, gf8_muladd_10, gf8_muladd_11, gf8_muladd_12, gf8_muladd_13,
+    gf8_muladd_14, gf8_muladd_15, gf8_muladd_16, gf8_muladd_17, gf8_muladd_18,
+    gf8_muladd_19, gf8_muladd_1A, gf8_muladd_1B, gf8_muladd_1C, gf8_muladd_1D,
+    gf8_muladd_1E, gf8_muladd_1F, gf8_muladd_20, gf8_muladd_21, gf8_muladd_22,
+    gf8_muladd_23, gf8_muladd_24, gf8_muladd_25, gf8_muladd_26, gf8_muladd_27,
+    gf8_muladd_28, gf8_muladd_29, gf8_muladd_2A, gf8_muladd_2B, gf8_muladd_2C,
+    gf8_muladd_2D, gf8_muladd_2E, gf8_muladd_2F, gf8_muladd_30, gf8_muladd_31,
+    gf8_muladd_32, gf8_muladd_33, gf8_muladd_34, gf8_muladd_35, gf8_muladd_36,
+    gf8_muladd_37, gf8_muladd_38, gf8_muladd_39, gf8_muladd_3A, gf8_muladd_3B,
+    gf8_muladd_3C, gf8_muladd_3D, gf8_muladd_3E, gf8_muladd_3F, gf8_muladd_40,
+    gf8_muladd_41, gf8_muladd_42, gf8_muladd_43, gf8_muladd_44, gf8_muladd_45,
+    gf8_muladd_46, gf8_muladd_47, gf8_muladd_48, gf8_muladd_49, gf8_muladd_4A,
+    gf8_muladd_4B, gf8_muladd_4C, gf8_muladd_4D, gf8_muladd_4E, gf8_muladd_4F,
+    gf8_muladd_50, gf8_muladd_51, gf8_muladd_52, gf8_muladd_53, gf8_muladd_54,
+    gf8_muladd_55, gf8_muladd_56, gf8_muladd_57, gf8_muladd_58, gf8_muladd_59,
+    gf8_muladd_5A, gf8_muladd_5B, gf8_muladd_5C, gf8_muladd_5D, gf8_muladd_5E,
+    gf8_muladd_5F, gf8_muladd_60, gf8_muladd_61, gf8_muladd_62, gf8_muladd_63,
+    gf8_muladd_64, gf8_muladd_65, gf8_muladd_66, gf8_muladd_67, gf8_muladd_68,
+    gf8_muladd_69, gf8_muladd_6A, gf8_muladd_6B, gf8_muladd_6C, gf8_muladd_6D,
+    gf8_muladd_6E, gf8_muladd_6F, gf8_muladd_70, gf8_muladd_71, gf8_muladd_72,
+    gf8_muladd_73, gf8_muladd_74, gf8_muladd_75, gf8_muladd_76, gf8_muladd_77,
+    gf8_muladd_78, gf8_muladd_79, gf8_muladd_7A, gf8_muladd_7B, gf8_muladd_7C,
+    gf8_muladd_7D, gf8_muladd_7E, gf8_muladd_7F, gf8_muladd_80, gf8_muladd_81,
+    gf8_muladd_82, gf8_muladd_83, gf8_muladd_84, gf8_muladd_85, gf8_muladd_86,
+    gf8_muladd_87, gf8_muladd_88, gf8_muladd_89, gf8_muladd_8A, gf8_muladd_8B,
+    gf8_muladd_8C, gf8_muladd_8D, gf8_muladd_8E, gf8_muladd_8F, gf8_muladd_90,
+    gf8_muladd_91, gf8_muladd_92, gf8_muladd_93, gf8_muladd_94, gf8_muladd_95,
+    gf8_muladd_96, gf8_muladd_97, gf8_muladd_98, gf8_muladd_99, gf8_muladd_9A,
+    gf8_muladd_9B, gf8_muladd_9C, gf8_muladd_9D, gf8_muladd_9E, gf8_muladd_9F,
+    gf8_muladd_A0, gf8_muladd_A1, gf8_muladd_A2, gf8_muladd_A3, gf8_muladd_A4,
+    gf8_muladd_A5, gf8_muladd_A6, gf8_muladd_A7, gf8_muladd_A8, gf8_muladd_A9,
+    gf8_muladd_AA, gf8_muladd_AB, gf8_muladd_AC, gf8_muladd_AD, gf8_muladd_AE,
+    gf8_muladd_AF, gf8_muladd_B0, gf8_muladd_B1, gf8_muladd_B2, gf8_muladd_B3,
+    gf8_muladd_B4, gf8_muladd_B5, gf8_muladd_B6, gf8_muladd_B7, gf8_muladd_B8,
+    gf8_muladd_B9, gf8_muladd_BA, gf8_muladd_BB, gf8_muladd_BC, gf8_muladd_BD,
+    gf8_muladd_BE, gf8_muladd_BF, gf8_muladd_C0, gf8_muladd_C1, gf8_muladd_C2,
+    gf8_muladd_C3, gf8_muladd_C4, gf8_muladd_C5, gf8_muladd_C6, gf8_muladd_C7,
+    gf8_muladd_C8, gf8_muladd_C9, gf8_muladd_CA, gf8_muladd_CB, gf8_muladd_CC,
+    gf8_muladd_CD, gf8_muladd_CE, gf8_muladd_CF, gf8_muladd_D0, gf8_muladd_D1,
+    gf8_muladd_D2, gf8_muladd_D3, gf8_muladd_D4, gf8_muladd_D5, gf8_muladd_D6,
+    gf8_muladd_D7, gf8_muladd_D8, gf8_muladd_D9, gf8_muladd_DA, gf8_muladd_DB,
+    gf8_muladd_DC, gf8_muladd_DD, gf8_muladd_DE, gf8_muladd_DF, gf8_muladd_E0,
+    gf8_muladd_E1, gf8_muladd_E2, gf8_muladd_E3, gf8_muladd_E4, gf8_muladd_E5,
+    gf8_muladd_E6, gf8_muladd_E7, gf8_muladd_E8, gf8_muladd_E9, gf8_muladd_EA,
+    gf8_muladd_EB, gf8_muladd_EC, gf8_muladd_ED, gf8_muladd_EE, gf8_muladd_EF,
+    gf8_muladd_F0, gf8_muladd_F1, gf8_muladd_F2, gf8_muladd_F3, gf8_muladd_F4,
+    gf8_muladd_F5, gf8_muladd_F6, gf8_muladd_F7, gf8_muladd_F8, gf8_muladd_F9,
+    gf8_muladd_FA, gf8_muladd_FB, gf8_muladd_FC, gf8_muladd_FD, gf8_muladd_FE,
+    gf8_muladd_FF};
+
+static uint64_t zero[EC_METHOD_WORD_SIZE * 8] = {
+    0,
 };
 
-static uint64_t zero[EC_METHOD_WORD_SIZE * 8] = {0, };
-
-void ec_code_c_prepare(ec_gf_t *gf, uint32_t *values, uint32_t count)
+void
+ec_code_c_prepare(ec_gf_t *gf, uint32_t *values, uint32_t count)
 {
     uint32_t i, last, tmp;
 
@@ -11397,8 +11643,9 @@ void ec_code_c_prepare(ec_gf_t *gf, uint32_t *values, uint32_t count)
     }
 }
 
-void ec_code_c_linear(void *dst, void *src, uint64_t offset, uint32_t *values,
-                      uint32_t count)
+void
+ec_code_c_linear(void *dst, void *src, uint64_t offset, uint32_t *values,
+                 uint32_t count)
 {
     src += offset;
     gf8_muladd_00(dst, src);
@@ -11409,8 +11656,9 @@ void ec_code_c_linear(void *dst, void *src, uint64_t offset, uint32_t *values,
     }
 }
 
-void ec_code_c_interleaved(void *dst, void **src, uint64_t offset,
-                           uint32_t *values, uint32_t count)
+void
+ec_code_c_interleaved(void *dst, void **src, uint64_t offset, uint32_t *values,
+                      uint32_t count)
 {
     uint32_t i, last, tmp;
 
diff --git a/xlators/cluster/ec/src/ec-code-intel.c b/xlators/cluster/ec/src/ec-code-intel.c
index b9fdcad4421..f1c4e13e321 100644
--- a/xlators/cluster/ec/src/ec-code-intel.c
+++ b/xlators/cluster/ec/src/ec-code-intel.c
@@ -71,16 +71,15 @@ ec_code_intel_vex(ec_code_intel_t *intel, gf_boolean_t w, gf_boolean_t l,
                   uint32_t reg)
 {
     ec_code_intel_rex(intel, w);
-    if (((intel->rex.w == 1) ||
-         (intel->rex.x == 0) ||
-         (intel->rex.b == 0)) ||
+    if (((intel->rex.w == 1) || (intel->rex.x == 0) || (intel->rex.b == 0)) ||
         ((opcode != VEX_OPCODE_NONE) && (opcode != VEX_OPCODE_0F))) {
         intel->rex.present = _gf_false;
 
         intel->vex.bytes = 3;
         intel->vex.data[0] = 0xC4;
         intel->vex.data[1] = ((intel->rex.r << 7) | (intel->rex.x << 6) |
-                              (intel->rex.b << 5) | opcode) ^ 0xE0;
+                              (intel->rex.b << 5) | opcode) ^
+                             0xE0;
         intel->vex.data[2] = (intel->rex.w << 7) | ((~reg & 0x0F) << 3) |
                              (l ? 0x04 : 0x00) | prefix;
     } else {
@@ -214,22 +213,17 @@ ec_code_intel_emit(ec_code_builder_t *builder, ec_code_intel_t *intel)
         insn[count++] = intel->vex.data[i];
     }
     if (intel->rex.present) {
-        insn[count++] = 0x40 |
-                        (intel->rex.w << 3) |
-                        (intel->rex.r << 2) |
-                        (intel->rex.x << 1) |
-                        (intel->rex.b << 0);
+        insn[count++] = 0x40 | (intel->rex.w << 3) | (intel->rex.r << 2) |
+                        (intel->rex.x << 1) | (intel->rex.b << 0);
     }
     for (i = 0; i < intel->opcode.bytes; i++) {
         insn[count++] = intel->opcode.data[i];
     }
     if (intel->modrm.present) {
-        insn[count++] = (intel->modrm.mod << 6) |
-                        (intel->modrm.reg << 3) |
+        insn[count++] = (intel->modrm.mod << 6) | (intel->modrm.reg << 3) |
                         (intel->modrm.rm << 0);
         if (intel->sib.present) {
-            insn[count++] = (intel->sib.scale << 6) |
-                            (intel->sib.index << 3) |
+            insn[count++] = (intel->sib.scale << 6) | (intel->sib.index << 3) |
                             (intel->sib.base << 0);
         }
     }
@@ -467,9 +461,9 @@ ec_code_intel_op_mov_sse2m(ec_code_builder_t *builder, uint32_t src,
 }
 
 void
-ec_code_intel_op_mov_m2sse(ec_code_builder_t *builder,
-                           ec_code_intel_reg_t base, ec_code_intel_reg_t index,
-                           uint32_t scale, int32_t offset, uint32_t dst)
+ec_code_intel_op_mov_m2sse(ec_code_builder_t *builder, ec_code_intel_reg_t base,
+                           ec_code_intel_reg_t index, uint32_t scale,
+                           int32_t offset, uint32_t dst)
 {
     ec_code_intel_t intel;
 
@@ -500,9 +494,9 @@ ec_code_intel_op_xor_sse2sse(ec_code_builder_t *builder, uint32_t src,
 }
 
 void
-ec_code_intel_op_xor_m2sse(ec_code_builder_t *builder,
-                           ec_code_intel_reg_t base, ec_code_intel_reg_t index,
-                           uint32_t scale, int32_t offset, uint32_t dst)
+ec_code_intel_op_xor_m2sse(ec_code_builder_t *builder, ec_code_intel_reg_t base,
+                           ec_code_intel_reg_t index, uint32_t scale,
+                           int32_t offset, uint32_t dst)
 {
     ec_code_intel_t intel;
 
@@ -526,8 +520,8 @@ ec_code_intel_op_mov_avx2avx(ec_code_builder_t *builder, uint32_t src,
 
     ec_code_intel_modrm_reg(&intel, src, dst);
     ec_code_intel_op_1(&intel, 0x6F, 0);
-    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F,
-                      VEX_PREFIX_66, VEX_REG_NONE);
+    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F, VEX_PREFIX_66,
+                      VEX_REG_NONE);
 
     ec_code_intel_emit(builder, &intel);
 }
@@ -543,16 +537,16 @@ ec_code_intel_op_mov_avx2m(ec_code_builder_t *builder, uint32_t src,
 
     ec_code_intel_modrm_mem(&intel, src, base, index, scale, offset);
     ec_code_intel_op_1(&intel, 0x7F, 0);
-    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F,
-                      VEX_PREFIX_66, VEX_REG_NONE);
+    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F, VEX_PREFIX_66,
+                      VEX_REG_NONE);
 
     ec_code_intel_emit(builder, &intel);
 }
 
 void
-ec_code_intel_op_mov_m2avx(ec_code_builder_t *builder,
-                           ec_code_intel_reg_t base, ec_code_intel_reg_t index,
-                           uint32_t scale, int32_t offset, uint32_t dst)
+ec_code_intel_op_mov_m2avx(ec_code_builder_t *builder, ec_code_intel_reg_t base,
+                           ec_code_intel_reg_t index, uint32_t scale,
+                           int32_t offset, uint32_t dst)
 {
     ec_code_intel_t intel;
 
@@ -560,8 +554,8 @@ ec_code_intel_op_mov_m2avx(ec_code_builder_t *builder,
 
     ec_code_intel_modrm_mem(&intel, dst, base, index, scale, offset);
     ec_code_intel_op_1(&intel, 0x6F, 0);
-    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F,
-                      VEX_PREFIX_66, VEX_REG_NONE);
+    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F, VEX_PREFIX_66,
+                      VEX_REG_NONE);
 
     ec_code_intel_emit(builder, &intel);
 }
@@ -576,16 +570,16 @@ ec_code_intel_op_xor_avx2avx(ec_code_builder_t *builder, uint32_t src,
 
     ec_code_intel_modrm_reg(&intel, src, dst);
     ec_code_intel_op_1(&intel, 0xEF, 0);
-    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F,
-                      VEX_PREFIX_66, dst);
+    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F, VEX_PREFIX_66,
+                      dst);
 
     ec_code_intel_emit(builder, &intel);
 }
 
 void
-ec_code_intel_op_xor_m2avx(ec_code_builder_t *builder,
-                           ec_code_intel_reg_t base, ec_code_intel_reg_t index,
-                           uint32_t scale, int32_t offset, uint32_t dst)
+ec_code_intel_op_xor_m2avx(ec_code_builder_t *builder, ec_code_intel_reg_t base,
+                           ec_code_intel_reg_t index, uint32_t scale,
+                           int32_t offset, uint32_t dst)
 {
     ec_code_intel_t intel;
 
@@ -593,8 +587,8 @@ ec_code_intel_op_xor_m2avx(ec_code_builder_t *builder,
 
     ec_code_intel_modrm_mem(&intel, dst, base, index, scale, offset);
     ec_code_intel_op_1(&intel, 0xEF, 0);
-    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F,
-                      VEX_PREFIX_66, dst);
+    ec_code_intel_vex(&intel, _gf_false, _gf_true, VEX_OPCODE_0F, VEX_PREFIX_66,
+                      dst);
 
     ec_code_intel_emit(builder, &intel);
 }
diff --git a/xlators/cluster/ec/src/ec-code-sse.c b/xlators/cluster/ec/src/ec-code-sse.c
index 6f2c6fa593f..e11e7ff8400 100644
--- a/xlators/cluster/ec/src/ec-code-sse.c
+++ b/xlators/cluster/ec/src/ec-code-sse.c
@@ -34,10 +34,9 @@ ec_code_sse_load(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
                  uint32_t bit)
 {
     if (builder->linear) {
-        ec_code_intel_op_mov_m2sse(builder, REG_SI, REG_DX, 1,
-                                   idx * builder->width * builder->bits +
-                                   bit * builder->width,
-                                   dst);
+        ec_code_intel_op_mov_m2sse(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -73,10 +72,9 @@ ec_code_sse_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
                  uint32_t bit)
 {
     if (builder->linear) {
-       ec_code_intel_op_xor_m2sse(builder, REG_SI, REG_DX, 1,
-                                  idx * builder->width * builder->bits +
-                                  bit * builder->width,
-                                  dst);
+        ec_code_intel_op_xor_m2sse(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -88,21 +86,16 @@ ec_code_sse_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
     }
 }
 
-static char *ec_code_sse_needed_flags[] = {
-    "sse2",
-    NULL
-};
+static char *ec_code_sse_needed_flags[] = {"sse2", NULL};
 
-ec_code_gen_t ec_code_gen_sse = {
-    .name   = "sse",
-    .flags  = ec_code_sse_needed_flags,
-    .width  = 16,
-    .prolog = ec_code_sse_prolog,
-    .epilog = ec_code_sse_epilog,
-    .load   = ec_code_sse_load,
-    .store  = ec_code_sse_store,
-    .copy   = ec_code_sse_copy,
-    .xor2   = ec_code_sse_xor2,
-    .xor3   = NULL,
-    .xorm   = ec_code_sse_xorm
-};
+ec_code_gen_t ec_code_gen_sse = {.name = "sse",
+                                 .flags = ec_code_sse_needed_flags,
+                                 .width = 16,
+                                 .prolog = ec_code_sse_prolog,
+                                 .epilog = ec_code_sse_epilog,
+                                 .load = ec_code_sse_load,
+                                 .store = ec_code_sse_store,
+                                 .copy = ec_code_sse_copy,
+                                 .xor2 = ec_code_sse_xor2,
+                                 .xor3 = NULL,
+                                 .xorm = ec_code_sse_xorm};
diff --git a/xlators/cluster/ec/src/ec-code-x64.c b/xlators/cluster/ec/src/ec-code-x64.c
index cfec4b3be7a..26565b4493f 100644
--- a/xlators/cluster/ec/src/ec-code-x64.c
+++ b/xlators/cluster/ec/src/ec-code-x64.c
@@ -14,8 +14,7 @@
 
 static ec_code_intel_reg_t ec_code_x64_regmap[] = {
     REG_AX, REG_CX, REG_BP, REG_8,  REG_9, REG_10,
-    REG_11, REG_12, REG_13, REG_14, REG_15
-};
+    REG_11, REG_12, REG_13, REG_14, REG_15};
 
 static void
 ec_code_x64_prolog(ec_code_builder_t *builder)
@@ -68,10 +67,9 @@ ec_code_x64_load(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
     dst = ec_code_x64_regmap[dst];
 
     if (builder->linear) {
-        ec_code_intel_op_mov_m2r(builder, REG_SI, REG_DX, 1,
-                                 idx * builder->width * builder->bits +
-                                 bit * builder->width,
-                                 dst);
+        ec_code_intel_op_mov_m2r(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -117,10 +115,9 @@ ec_code_x64_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
     dst = ec_code_x64_regmap[dst];
 
     if (builder->linear) {
-        ec_code_intel_op_xor_m2r(builder, REG_SI, REG_DX, 1,
-                                 idx * builder->width * builder->bits +
-                                 bit * builder->width,
-                                 dst);
+        ec_code_intel_op_xor_m2r(
+            builder, REG_SI, REG_DX, 1,
+            idx * builder->width * builder->bits + bit * builder->width, dst);
     } else {
         if (builder->base != idx) {
             ec_code_intel_op_mov_m2r(builder, REG_SI, REG_NULL, 0, idx * 8,
@@ -132,20 +129,16 @@ ec_code_x64_xorm(ec_code_builder_t *builder, uint32_t dst, uint32_t idx,
     }
 }
 
-static char *ec_code_x64_needed_flags[] = {
-    NULL
-};
-
-ec_code_gen_t ec_code_gen_x64 = {
-    .name   = "x64",
-    .flags  = ec_code_x64_needed_flags,
-    .width  = sizeof(uint64_t),
-    .prolog = ec_code_x64_prolog,
-    .epilog = ec_code_x64_epilog,
-    .load   = ec_code_x64_load,
-    .store  = ec_code_x64_store,
-    .copy   = ec_code_x64_copy,
-    .xor2   = ec_code_x64_xor2,
-    .xor3   = NULL,
-    .xorm   = ec_code_x64_xorm
-};
+static char *ec_code_x64_needed_flags[] = {NULL};
+
+ec_code_gen_t ec_code_gen_x64 = {.name = "x64",
+                                 .flags = ec_code_x64_needed_flags,
+                                 .width = sizeof(uint64_t),
+                                 .prolog = ec_code_x64_prolog,
+                                 .epilog = ec_code_x64_epilog,
+                                 .load = ec_code_x64_load,
+                                 .store = ec_code_x64_store,
+                                 .copy = ec_code_x64_copy,
+                                 .xor2 = ec_code_x64_xor2,
+                                 .xor3 = NULL,
+                                 .xorm = ec_code_x64_xorm};
diff --git a/xlators/cluster/ec/src/ec-code.c b/xlators/cluster/ec/src/ec-code.c
index e33cb42d9dc..70878d794ca 100644
--- a/xlators/cluster/ec/src/ec-code.c
+++ b/xlators/cluster/ec/src/ec-code.c
@@ -47,13 +47,13 @@ struct _ec_code_proc;
 typedef struct _ec_code_proc ec_code_proc_t;
 
 struct _ec_code_proc {
-    int32_t      fd;
+    int32_t fd;
     gf_boolean_t eof;
     gf_boolean_t error;
     gf_boolean_t skip;
-    ssize_t      size;
-    ssize_t      pos;
-    char         buffer[EC_PROC_BUFFER_SIZE];
+    ssize_t size;
+    ssize_t pos;
+    char buffer[EC_PROC_BUFFER_SIZE];
 };
 
 static ec_code_gen_t *ec_code_gen_table[] = {
@@ -66,8 +66,7 @@ static ec_code_gen_t *ec_code_gen_table[] = {
 #ifdef USE_EC_DYNAMIC_X64
     &ec_code_gen_x64,
 #endif
-    NULL
-};
+    NULL};
 
 static void
 ec_code_arg_set(ec_code_arg_t *arg, uint32_t value)
@@ -84,7 +83,6 @@ ec_code_arg_assign(ec_code_builder_t *builder, ec_code_op_t *op,
     if (builder->regs <= reg) {
         builder->regs = reg + 1;
     }
-
 }
 
 static void
@@ -202,17 +200,17 @@ static void
 ec_code_dup(ec_code_builder_t *builder, ec_gf_op_t *op)
 {
     switch (op->op) {
-    case EC_GF_OP_COPY:
-        ec_code_copy(builder, op->arg1, op->arg2);
-        break;
-    case EC_GF_OP_XOR2:
-        ec_code_xor2(builder, op->arg1, op->arg2);
-        break;
-    case EC_GF_OP_XOR3:
-        ec_code_xor3(builder, op->arg1, op->arg2, op->arg3);
-        break;
-    default:
-        break;
+        case EC_GF_OP_COPY:
+            ec_code_copy(builder, op->arg1, op->arg2);
+            break;
+        case EC_GF_OP_XOR2:
+            ec_code_xor2(builder, op->arg1, op->arg2);
+            break;
+        case EC_GF_OP_XOR3:
+            ec_code_xor3(builder, op->arg1, op->arg2, op->arg3);
+            break;
+        default:
+            break;
     }
 }
 
@@ -285,8 +283,9 @@ ec_code_prepare(ec_code_t *code, uint32_t count, uint32_t width,
 
     count *= code->gf->bits + code->gf->max_ops;
     count += code->gf->bits;
-    builder = GF_MALLOC(sizeof(ec_code_builder_t) +
-                        sizeof(ec_code_op_t) * count, ec_mt_ec_code_builder_t);
+    builder = GF_MALLOC(
+        sizeof(ec_code_builder_t) + sizeof(ec_code_op_t) * count,
+        ec_mt_ec_code_builder_t);
     if (builder == NULL) {
         return EC_ERR(ENOMEM);
     }
@@ -331,15 +330,15 @@ ec_code_chunk_from_space(ec_code_space_t *space)
 static void *
 ec_code_to_executable(ec_code_space_t *space, void *addr)
 {
-        return (void *)((uintptr_t)addr - (uintptr_t)space
-                                        + (uintptr_t)space->exec);
+    return (void *)((uintptr_t)addr - (uintptr_t)space +
+                    (uintptr_t)space->exec);
 }
 
 static void *
 ec_code_from_executable(ec_code_space_t *space, void *addr)
 {
-        return (void *)((uintptr_t)addr - (uintptr_t)space->exec
-                                        + (uintptr_t)space);
+    return (void *)((uintptr_t)addr - (uintptr_t)space->exec +
+                    (uintptr_t)space);
 }
 
 static void *
@@ -395,105 +394,105 @@ ec_code_chunk_touch(ec_code_chunk_t *prev, ec_code_chunk_t *next)
 static ec_code_space_t *
 ec_code_space_create(ec_code_t *code, size_t size)
 {
-        char path[] = GLUSTERFS_LIBEXECDIR "/ec-code-dynamic.XXXXXX";
-        ec_code_space_t *space;
-        void *exec;
-        int32_t fd, err;
-
-        /* We need to create memory areas to store the generated dynamic code.
-         * Obviously these areas need to be written to be able to create the
-         * code and they also need to be executable to execute it.
-         *
-         * However it's a bad practice to have a memory region that is both
-         * writable *and* executable. In fact, selinux forbids this and causes
-         * attempts to do so to fail (unless specifically configured).
-         *
-         * To solve the problem we'll use two distinct memory areas mapped to
-         * the same physical storage. One of the memory areas will have write
-         * permission, and the other will have execute permission. Both areas
-         * will have the same contents. The physical storage will be a regular
-         * file that will be mmapped to both areas.
-         */
-
-        /* We need to create a temporary file as the backend storage for the
-         * memory mapped areas. */
-        /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
-        fd = mkstemp(path);
-        if (fd < 0) {
-                err = errno;
-                gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
-                       "Unable to create a temporary file for the ec dynamic "
-                       "code");
-                space = EC_ERR(err);
-                goto done;
-        }
-        /* Once created we don't need to keep it in the file system. It will
-         * still exist until we close the last file descriptor or unmap the
-         * memory areas bound to the file. */
-        sys_unlink(path);
-
-        size = (size + EC_CODE_ALIGN - 1) & ~(EC_CODE_ALIGN - 1);
-        if (sys_ftruncate(fd, size) < 0) {
-                err = errno;
-                gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
-                       "Unable to resize the file for the ec dynamic code");
-                space = EC_ERR(err);
-                goto done_close;
-        }
+    char path[] = GLUSTERFS_LIBEXECDIR "/ec-code-dynamic.XXXXXX";
+    ec_code_space_t *space;
+    void *exec;
+    int32_t fd, err;
+
+    /* We need to create memory areas to store the generated dynamic code.
+     * Obviously these areas need to be written to be able to create the
+     * code and they also need to be executable to execute it.
+     *
+     * However it's a bad practice to have a memory region that is both
+     * writable *and* executable. In fact, selinux forbids this and causes
+     * attempts to do so to fail (unless specifically configured).
+     *
+     * To solve the problem we'll use two distinct memory areas mapped to
+     * the same physical storage. One of the memory areas will have write
+     * permission, and the other will have execute permission. Both areas
+     * will have the same contents. The physical storage will be a regular
+     * file that will be mmapped to both areas.
+     */
+
+    /* We need to create a temporary file as the backend storage for the
+     * memory mapped areas. */
+    /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */
+    fd = mkstemp(path);
+    if (fd < 0) {
+        err = errno;
+        gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
+               "Unable to create a temporary file for the ec dynamic "
+               "code");
+        space = EC_ERR(err);
+        goto done;
+    }
+    /* Once created we don't need to keep it in the file system. It will
+     * still exist until we close the last file descriptor or unmap the
+     * memory areas bound to the file. */
+    sys_unlink(path);
+
+    size = (size + EC_CODE_ALIGN - 1) & ~(EC_CODE_ALIGN - 1);
+    if (sys_ftruncate(fd, size) < 0) {
+        err = errno;
+        gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
+               "Unable to resize the file for the ec dynamic code");
+        space = EC_ERR(err);
+        goto done_close;
+    }
 
-        /* This creates an executable memory area to be able to run the
-         * generated fragments of code. */
-        exec = mmap(NULL, size, PROT_READ | PROT_EXEC, MAP_SHARED, fd, 0);
-        if (exec == MAP_FAILED) {
-                err = errno;
-                gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
-                       "Unable to map the executable area for the ec dynamic "
-                       "code");
-                space = EC_ERR(err);
-                goto done_close;
-        }
-        /* It's not important to check the return value of mlock(). If it fails
-         * everything will continue to work normally. */
-        mlock(exec, size);
-
-        /* This maps a read/write memory area to be able to create the dynamici
-         * code. */
-        space = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-        if (space == MAP_FAILED) {
-                err = errno;
-                gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
-                       "Unable to map the writable area for the ec dynamic "
-                       "code");
-                space = EC_ERR(err);
-
-                munmap(exec, size);
-
-                goto done_close;
-        }
+    /* This creates an executable memory area to be able to run the
+     * generated fragments of code. */
+    exec = mmap(NULL, size, PROT_READ | PROT_EXEC, MAP_SHARED, fd, 0);
+    if (exec == MAP_FAILED) {
+        err = errno;
+        gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
+               "Unable to map the executable area for the ec dynamic "
+               "code");
+        space = EC_ERR(err);
+        goto done_close;
+    }
+    /* It's not important to check the return value of mlock(). If it fails
+     * everything will continue to work normally. */
+    mlock(exec, size);
+
+    /* This maps a read/write memory area to be able to create the dynamici
+     * code. */
+    space = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (space == MAP_FAILED) {
+        err = errno;
+        gf_msg(THIS->name, GF_LOG_ERROR, err, EC_MSG_DYN_CREATE_FAILED,
+               "Unable to map the writable area for the ec dynamic "
+               "code");
+        space = EC_ERR(err);
+
+        munmap(exec, size);
+
+        goto done_close;
+    }
 
-        space->exec = exec;
-        space->size = size;
-        space->code = code;
-        list_add_tail(&space->list, &code->spaces);
-        INIT_LIST_HEAD(&space->chunks);
+    space->exec = exec;
+    space->size = size;
+    space->code = code;
+    list_add_tail(&space->list, &code->spaces);
+    INIT_LIST_HEAD(&space->chunks);
 
 done_close:
-        /* If everything has succeeded, we already have the memory areas
-         * mapped. We don't need the file descriptor anymore because the
-         * backend storage will be there until the mmap()'d regions are
-         * unmapped. */
-        sys_close(fd);
+    /* If everything has succeeded, we already have the memory areas
+     * mapped. We don't need the file descriptor anymore because the
+     * backend storage will be there until the mmap()'d regions are
+     * unmapped. */
+    sys_close(fd);
 done:
-        return space;
+    return space;
 }
 
 static void
 ec_code_space_destroy(ec_code_space_t *space)
 {
-        list_del_init(&space->list);
+    list_del_init(&space->list);
 
-        munmap(space->exec, space->size);
-        munmap(space, space->size);
+    munmap(space->exec, space->size);
+    munmap(space, space->size);
 }
 
 static void
@@ -501,7 +500,8 @@ ec_code_chunk_merge(ec_code_chunk_t *chunk)
 {
     ec_code_chunk_t *item, *tmp;
 
-    list_for_each_entry_safe(item, tmp, &chunk->space->chunks, list) {
+    list_for_each_entry_safe(item, tmp, &chunk->space->chunks, list)
+    {
         if ((uintptr_t)item > (uintptr_t)chunk) {
             list_add_tail(&chunk->list, &item->list);
             if (ec_code_chunk_touch(chunk, item)) {
@@ -520,8 +520,8 @@ ec_code_chunk_merge(ec_code_chunk_t *chunk)
     list_add_tail(&chunk->list, &chunk->space->chunks);
 
 check:
-    if (chunk->size == chunk->space->size - ec_code_space_size() -
-                       ec_code_chunk_size()) {
+    if (chunk->size ==
+        chunk->space->size - ec_code_space_size() - ec_code_chunk_size()) {
         ec_code_space_destroy(chunk->space);
     }
 }
@@ -536,9 +536,12 @@ ec_code_space_alloc(ec_code_t *code, size_t size)
     /* To minimize fragmentation, we only allocate chunks of sizes multiples
      * of EC_CODE_CHUNK_MIN_SIZE. */
     size = ((size + ec_code_chunk_size() + EC_CODE_CHUNK_MIN_SIZE - 1) &
-           ~(EC_CODE_CHUNK_MIN_SIZE - 1)) - ec_code_chunk_size();
-    list_for_each_entry(space, &code->spaces, list) {
-        list_for_each_entry(chunk, &space->chunks, list) {
+            ~(EC_CODE_CHUNK_MIN_SIZE - 1)) -
+           ec_code_chunk_size();
+    list_for_each_entry(space, &code->spaces, list)
+    {
+        list_for_each_entry(chunk, &space->chunks, list)
+        {
             if (chunk->size >= size) {
                 goto out;
             }
@@ -608,26 +611,29 @@ ec_code_write(ec_code_builder_t *builder)
     for (i = 0; i < builder->count; i++) {
         op = &builder->ops[i];
         switch (op->op) {
-        case EC_GF_OP_LOAD:
-            gen->load(builder, op->arg1.value, op->arg2.value, op->arg3.value);
-            break;
-        case EC_GF_OP_STORE:
-            gen->store(builder, op->arg1.value, op->arg3.value);
-            break;
-        case EC_GF_OP_COPY:
-            gen->copy(builder, op->arg1.value, op->arg2.value);
-            break;
-        case EC_GF_OP_XOR2:
-            gen->xor2(builder, op->arg1.value, op->arg2.value);
-            break;
-        case EC_GF_OP_XOR3:
-            gen->xor3(builder, op->arg1.value, op->arg2.value, op->arg3.value);
-            break;
-        case EC_GF_OP_XORM:
-            gen->xorm(builder, op->arg1.value, op->arg2.value, op->arg3.value);
-            break;
-        default:
-            break;
+            case EC_GF_OP_LOAD:
+                gen->load(builder, op->arg1.value, op->arg2.value,
+                          op->arg3.value);
+                break;
+            case EC_GF_OP_STORE:
+                gen->store(builder, op->arg1.value, op->arg3.value);
+                break;
+            case EC_GF_OP_COPY:
+                gen->copy(builder, op->arg1.value, op->arg2.value);
+                break;
+            case EC_GF_OP_XOR2:
+                gen->xor2(builder, op->arg1.value, op->arg2.value);
+                break;
+            case EC_GF_OP_XOR3:
+                gen->xor3(builder, op->arg1.value, op->arg2.value,
+                          op->arg3.value);
+                break;
+            case EC_GF_OP_XORM:
+                gen->xorm(builder, op->arg1.value, op->arg2.value,
+                          op->arg3.value);
+                break;
+            default:
+                break;
         }
     }
     gen->epilog(builder);
@@ -716,67 +722,65 @@ static void *
 ec_code_build_dynamic(ec_code_t *code, uint32_t width, uint32_t *values,
                       uint32_t count, gf_boolean_t linear)
 {
-        ec_code_builder_t *builder;
-        uint32_t offset, val, next;
+    ec_code_builder_t *builder;
+    uint32_t offset, val, next;
 
-        builder = ec_code_prepare(code, count, width, linear);
-        if (EC_IS_ERR(builder)) {
-                return builder;
-        }
+    builder = ec_code_prepare(code, count, width, linear);
+    if (EC_IS_ERR(builder)) {
+        return builder;
+    }
 
-        offset = -1;
-        next = ec_code_value_next(values, count, &offset);
-        if (next != 0) {
-                ec_code_gf_load(builder, offset);
-                do {
-                        val = next;
-                        next = ec_code_value_next(values, count, &offset);
-                        if (next != 0) {
-                                ec_code_gf_mul(builder, ec_gf_div(code->gf,
-                                                                  val, next));
-                                ec_code_gf_load_xor(builder, offset);
-                        }
-                } while (next != 0);
-                ec_code_gf_mul(builder, val);
-                ec_code_gf_store(builder);
-        } else {
-                ec_code_gf_clear(builder);
-        }
+    offset = -1;
+    next = ec_code_value_next(values, count, &offset);
+    if (next != 0) {
+        ec_code_gf_load(builder, offset);
+        do {
+            val = next;
+            next = ec_code_value_next(values, count, &offset);
+            if (next != 0) {
+                ec_code_gf_mul(builder, ec_gf_div(code->gf, val, next));
+                ec_code_gf_load_xor(builder, offset);
+            }
+        } while (next != 0);
+        ec_code_gf_mul(builder, val);
+        ec_code_gf_store(builder);
+    } else {
+        ec_code_gf_clear(builder);
+    }
 
-        return ec_code_compile(builder);
+    return ec_code_compile(builder);
 }
 
 static void *
-ec_code_build(ec_code_t *code, uint32_t width, uint32_t *values,
-              uint32_t count, gf_boolean_t linear)
+ec_code_build(ec_code_t *code, uint32_t width, uint32_t *values, uint32_t count,
+              gf_boolean_t linear)
 {
-        void *func;
+    void *func;
 
-        if (code->gen != NULL) {
-                func = ec_code_build_dynamic(code, width, values, count,
-                                             linear);
-                if (!EC_IS_ERR(func)) {
-                        return func;
-                }
+    if (code->gen != NULL) {
+        func = ec_code_build_dynamic(code, width, values, count, linear);
+        if (!EC_IS_ERR(func)) {
+            return func;
+        }
 
-                gf_msg_debug(THIS->name, GF_LOG_DEBUG,
-                             "Unable to generate dynamic code. Falling back "
-                             "to precompiled code");
+        gf_msg_debug(THIS->name, GF_LOG_DEBUG,
+                     "Unable to generate dynamic code. Falling back "
+                     "to precompiled code");
 
-                /* The dynamic code generation shouldn't fail in normal
-                 * conditions, but if it fails at some point, it's very
-                 * probable that it will fail again, so we completely disable
-                 * dynamic code generation. */
-                code->gen = NULL;
-        }
+        /* The dynamic code generation shouldn't fail in normal
+         * conditions, but if it fails at some point, it's very
+         * probable that it will fail again, so we completely disable
+         * dynamic code generation. */
+        code->gen = NULL;
+    }
 
-        ec_code_c_prepare(code->gf, values, count);
+    ec_code_c_prepare(code->gf, values, count);
 
-        if (linear) {
-                return ec_code_c_linear;
-        }
+    if (linear) {
+        return ec_code_c_linear;
+    }
 
-        return ec_code_c_interleaved;
+    return ec_code_c_interleaved;
 }
 
 ec_code_func_linear_t
@@ -791,17 +795,17 @@ ec_code_func_interleaved_t
 ec_code_build_interleaved(ec_code_t *code, uint32_t width, uint32_t *values,
                           uint32_t count)
 {
-    return (ec_code_func_interleaved_t)ec_code_build(code, width, values,
-                                                     count, _gf_false);
+    return (ec_code_func_interleaved_t)ec_code_build(code, width, values, count,
+                                                     _gf_false);
 }
 
 void
 ec_code_release(ec_code_t *code, ec_code_func_t *func)
 {
-        if ((func->linear != ec_code_c_linear) &&
-            (func->interleaved != ec_code_c_interleaved)) {
-                ec_code_free(ec_code_chunk_from_func(func->linear));
-        }
+    if ((func->linear != ec_code_c_linear) &&
+        (func->interleaved != ec_code_c_interleaved)) {
+        ec_code_free(ec_code_chunk_from_func(func->linear));
+    }
 }
 
 void
@@ -1003,7 +1007,8 @@ ec_code_detect(xlator_t *xl, const char *def)
         if (ec_code_gen_table[select] == NULL) {
             gf_msg(xl->name, GF_LOG_WARNING, EINVAL, EC_MSG_EXTENSION_UNKNOWN,
                    "CPU extension '%s' is not known. Not using any cpu "
-                   "extensions", def);
+                   "extensions",
+                   def);
 
             return NULL;
         }
diff --git a/xlators/cluster/ec/src/ec-combine.c b/xlators/cluster/ec/src/ec-combine.c
index 90e004336c0..551adfac043 100644
--- a/xlators/cluster/ec/src/ec-combine.c
+++ b/xlators/cluster/ec/src/ec-combine.c
@@ -30,41 +30,38 @@ typedef struct _ec_dict_info ec_dict_info_t;
 struct _ec_dict_combine;
 typedef struct _ec_dict_combine ec_dict_combine_t;
 
-struct _ec_dict_info
-{
-    dict_t * dict;
-    int32_t  count;
+struct _ec_dict_info {
+    dict_t *dict;
+    int32_t count;
 };
 
-struct _ec_dict_combine
-{
-    ec_cbk_data_t * cbk;
-    int32_t         which;
+struct _ec_dict_combine {
+    ec_cbk_data_t *cbk;
+    int32_t which;
 };
 
 int32_t
-ec_combine_write (ec_fop_data_t *fop, ec_cbk_data_t *dst,
-                  ec_cbk_data_t *src)
+ec_combine_write(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-        int     valid = 0;
+    int valid = 0;
 
-        if (!fop || !dst || !src)
-                return 0;
+    if (!fop || !dst || !src)
+        return 0;
 
-        switch (fop->id) {
+    switch (fop->id) {
         case GF_FOP_REMOVEXATTR:
         case GF_FOP_FREMOVEXATTR:
         case GF_FOP_SETXATTR:
         case GF_FOP_FSETXATTR:
-                return 1;
+            return 1;
 
         case GF_FOP_SYMLINK:
         case GF_FOP_LINK:
         case GF_FOP_CREATE:
         case GF_FOP_MKNOD:
         case GF_FOP_MKDIR:
-                valid = 3;
-                break;
+            valid = 3;
+            break;
         case GF_FOP_UNLINK:
         case GF_FOP_RMDIR:
         case GF_FOP_SETATTR:
@@ -75,42 +72,40 @@ ec_combine_write (ec_fop_data_t *fop, ec_cbk_data_t *dst,
         case GF_FOP_FALLOCATE:
         case GF_FOP_DISCARD:
         case GF_FOP_ZEROFILL:
-                valid = 2;
-                break;
+            valid = 2;
+            break;
         case GF_FOP_RENAME:
-                valid = 5;
-                break;
+            valid = 5;
+            break;
         default:
-                gf_msg_callingfn (fop->xl->name, GF_LOG_WARNING, EINVAL,
-                                  EC_MSG_INVALID_FOP,
-                                  "Invalid fop %d", fop->id);
-                return 0;
-                break;
-        }
+            gf_msg_callingfn(fop->xl->name, GF_LOG_WARNING, EINVAL,
+                             EC_MSG_INVALID_FOP, "Invalid fop %d", fop->id);
+            return 0;
+            break;
+    }
 
-        if (!ec_iatt_combine(fop, dst->iatt, src->iatt, valid)) {
-                gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                        EC_MSG_IATT_MISMATCH,
-                        "Mismatching iatt in "
-                        "answers of '%s'", gf_fop_list[fop->id]);
-                return 0;
-        }
-        return 1;
+    if (!ec_iatt_combine(fop, dst->iatt, src->iatt, valid)) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of '%s'",
+               gf_fop_list[fop->id]);
+        return 0;
+    }
+    return 1;
 }
 
-void ec_iatt_time_merge(int64_t *dst_sec, uint32_t *dst_nsec,
-                        int64_t src_sec, uint32_t src_nsec)
+void
+ec_iatt_time_merge(int64_t *dst_sec, uint32_t *dst_nsec, int64_t src_sec,
+                   uint32_t src_nsec)
 {
     if ((*dst_sec < src_sec) ||
-        ((*dst_sec == src_sec) && (*dst_nsec < src_nsec)))
-    {
+        ((*dst_sec == src_sec) && (*dst_nsec < src_nsec))) {
         *dst_sec = src_sec;
         *dst_nsec = src_nsec;
     }
 }
 
-static
-gf_boolean_t
+static gf_boolean_t
 ec_iatt_is_trusted(ec_fop_data_t *fop, struct iatt *iatt)
 {
     uint64_t ino;
@@ -141,14 +136,14 @@ ec_iatt_is_trusted(ec_fop_data_t *fop, struct iatt *iatt)
     return _gf_false;
 }
 
-int32_t ec_iatt_combine(ec_fop_data_t *fop, struct iatt *dst, struct iatt *src,
-                        int32_t count)
+int32_t
+ec_iatt_combine(ec_fop_data_t *fop, struct iatt *dst, struct iatt *src,
+                int32_t count)
 {
     int32_t i;
     gf_boolean_t failed = _gf_false;
 
-    for (i = 0; i < count; i++)
-    {
+    for (i = 0; i < count; i++) {
         /* Check for basic fields. These fields must be equal always, even if
          * the inode is not locked because in these cases the parent inode
          * will be locked and differences in these fields require changes in
@@ -172,33 +167,30 @@ int32_t ec_iatt_combine(ec_fop_data_t *fop, struct iatt *dst, struct iatt *src,
                  * data is returned. */
                 failed = _gf_true;
             } else {
-                gf_msg_debug (fop->xl->name, 0,
-                       "Ignoring iatt differences because inode is not "
-                       "locked");
+                gf_msg_debug(fop->xl->name, 0,
+                             "Ignoring iatt differences because inode is not "
+                             "locked");
             }
         }
         if (failed) {
-            gf_msg (fop->xl->name, GF_LOG_WARNING, 0,
-                    EC_MSG_IATT_COMBINE_FAIL,
-                    "Failed to combine iatt (inode: %lu-%lu, links: %u-%u, "
-                    "uid: %u-%u, gid: %u-%u, rdev: %lu-%lu, size: %lu-%lu, "
-                    "mode: %o-%o)",
-                    dst[i].ia_ino, src[i].ia_ino, dst[i].ia_nlink,
-                    src[i].ia_nlink, dst[i].ia_uid, src[i].ia_uid,
-                    dst[i].ia_gid, src[i].ia_gid, dst[i].ia_rdev,
-                    src[i].ia_rdev, dst[i].ia_size, src[i].ia_size,
-                    st_mode_from_ia(dst[i].ia_prot, dst[i].ia_type),
-                    st_mode_from_ia(src[i].ia_prot, dst[i].ia_type));
+            gf_msg(fop->xl->name, GF_LOG_WARNING, 0, EC_MSG_IATT_COMBINE_FAIL,
+                   "Failed to combine iatt (inode: %lu-%lu, links: %u-%u, "
+                   "uid: %u-%u, gid: %u-%u, rdev: %lu-%lu, size: %lu-%lu, "
+                   "mode: %o-%o)",
+                   dst[i].ia_ino, src[i].ia_ino, dst[i].ia_nlink,
+                   src[i].ia_nlink, dst[i].ia_uid, src[i].ia_uid, dst[i].ia_gid,
+                   src[i].ia_gid, dst[i].ia_rdev, src[i].ia_rdev,
+                   dst[i].ia_size, src[i].ia_size,
+                   st_mode_from_ia(dst[i].ia_prot, dst[i].ia_type),
+                   st_mode_from_ia(src[i].ia_prot, dst[i].ia_type));
 
             return 0;
         }
     }
 
-    while (count-- > 0)
-    {
+    while (count-- > 0) {
         dst[count].ia_blocks += src[count].ia_blocks;
-        if (dst[count].ia_blksize < src[count].ia_blksize)
-        {
+        if (dst[count].ia_blksize < src[count].ia_blksize) {
             dst[count].ia_blksize = src[count].ia_blksize;
         }
 
@@ -213,13 +205,12 @@ int32_t ec_iatt_combine(ec_fop_data_t *fop, struct iatt *dst, struct iatt *src,
     return 1;
 }
 
-void ec_iatt_rebuild(ec_t * ec, struct iatt * iatt, int32_t count,
-                     int32_t answers)
+void
+ec_iatt_rebuild(ec_t *ec, struct iatt *iatt, int32_t count, int32_t answers)
 {
     uint64_t blocks;
 
-    while (count-- > 0)
-    {
+    while (count-- > 0) {
         blocks = iatt[count].ia_blocks * ec->fragments + answers - 1;
         blocks /= answers;
         iatt[count].ia_blocks = blocks;
@@ -227,93 +218,93 @@ void ec_iatt_rebuild(ec_t * ec, struct iatt * iatt, int32_t count,
 }
 
 gf_boolean_t
-ec_xattr_match (dict_t *dict, char *key, data_t *value, void *arg)
+ec_xattr_match(dict_t *dict, char *key, data_t *value, void *arg)
 {
-        if ((fnmatch(GF_XATTR_STIME_PATTERN, key, 0) == 0) ||
-            (strcmp(key, GET_LINK_COUNT) == 0) ||
-            (strcmp(key, GLUSTERFS_INODELK_COUNT) == 0) ||
-            (strcmp(key, GLUSTERFS_ENTRYLK_COUNT) == 0) ||
-            (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0)) {
-                return _gf_false;
-        }
+    if ((fnmatch(GF_XATTR_STIME_PATTERN, key, 0) == 0) ||
+        (strcmp(key, GET_LINK_COUNT) == 0) ||
+        (strcmp(key, GLUSTERFS_INODELK_COUNT) == 0) ||
+        (strcmp(key, GLUSTERFS_ENTRYLK_COUNT) == 0) ||
+        (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0)) {
+        return _gf_false;
+    }
 
-        return _gf_true;
+    return _gf_true;
 }
 
 gf_boolean_t
-ec_value_ignore (char *key)
+ec_value_ignore(char *key)
 {
-        if ((strcmp(key, GF_CONTENT_KEY) == 0) ||
-            (strcmp(key, GF_XATTR_PATHINFO_KEY) == 0) ||
-            (strcmp(key, GF_XATTR_USER_PATHINFO_KEY) == 0) ||
-            (strcmp(key, GF_XATTR_LOCKINFO_KEY) == 0) ||
-            (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0) ||
-            (strcmp(key, GLUSTERFS_INODELK_COUNT) == 0) ||
-            (strcmp(key, GLUSTERFS_ENTRYLK_COUNT) == 0) ||
-            (strncmp(key, GF_XATTR_CLRLK_CMD,
-                     SLEN (GF_XATTR_CLRLK_CMD)) == 0) ||
-            (strcmp(key, DHT_IATT_IN_XDATA_KEY) == 0) ||
-            (strncmp(key, EC_QUOTA_PREFIX, SLEN (EC_QUOTA_PREFIX)) == 0) ||
-            (fnmatch(MARKER_XATTR_PREFIX ".*." XTIME, key, 0) == 0) ||
-            (fnmatch(GF_XATTR_MARKER_KEY ".*", key, 0) == 0) ||
-            (XATTR_IS_NODE_UUID(key))) {
-                return _gf_true;
-        }
+    if ((strcmp(key, GF_CONTENT_KEY) == 0) ||
+        (strcmp(key, GF_XATTR_PATHINFO_KEY) == 0) ||
+        (strcmp(key, GF_XATTR_USER_PATHINFO_KEY) == 0) ||
+        (strcmp(key, GF_XATTR_LOCKINFO_KEY) == 0) ||
+        (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0) ||
+        (strcmp(key, GLUSTERFS_INODELK_COUNT) == 0) ||
+        (strcmp(key, GLUSTERFS_ENTRYLK_COUNT) == 0) ||
+        (strncmp(key, GF_XATTR_CLRLK_CMD, SLEN(GF_XATTR_CLRLK_CMD)) == 0) ||
+        (strcmp(key, DHT_IATT_IN_XDATA_KEY) == 0) ||
+        (strncmp(key, EC_QUOTA_PREFIX, SLEN(EC_QUOTA_PREFIX)) == 0) ||
+        (fnmatch(MARKER_XATTR_PREFIX ".*." XTIME, key, 0) == 0) ||
+        (fnmatch(GF_XATTR_MARKER_KEY ".*", key, 0) == 0) ||
+        (XATTR_IS_NODE_UUID(key))) {
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 int32_t
-ec_dict_compare (dict_t *dict1, dict_t *dict2)
+ec_dict_compare(dict_t *dict1, dict_t *dict2)
 {
-        if (are_dicts_equal (dict1, dict2, ec_xattr_match, ec_value_ignore))
-                return 1;
-        return 0;
+    if (are_dicts_equal(dict1, dict2, ec_xattr_match, ec_value_ignore))
+        return 1;
+    return 0;
 }
 
 static uint32_t
 ec_dict_list(data_t **list, ec_cbk_data_t *cbk, int32_t which, char *key,
              gf_boolean_t global)
 {
-        ec_t *ec = cbk->fop->xl->private;
-        ec_cbk_data_t *ans = NULL;
-        dict_t *dict = NULL;
-        data_t *data;
-        uint32_t count;
-        int32_t i;
-
-        for (i = 0; i < ec->nodes; i++) {
-                /* We initialize the list with EC_MISSING_DATA if we are
-                 * returning a global list or the current subvolume belongs
-                 * to the group of the accepted answer. Note that if some
-                 * subvolume is known to be down before issuing the request,
-                 * we won't have any answer from it, so we set here the
-                 * appropriate default value. */
-                if (global || ((cbk->mask & (1ULL << i)) != 0)) {
-                        list[i] = EC_MISSING_DATA;
-                } else {
-                        list[i] = NULL;
-                }
+    ec_t *ec = cbk->fop->xl->private;
+    ec_cbk_data_t *ans = NULL;
+    dict_t *dict = NULL;
+    data_t *data;
+    uint32_t count;
+    int32_t i;
+
+    for (i = 0; i < ec->nodes; i++) {
+        /* We initialize the list with EC_MISSING_DATA if we are
+         * returning a global list or the current subvolume belongs
+         * to the group of the accepted answer. Note that if some
+         * subvolume is known to be down before issuing the request,
+         * we won't have any answer from it, so we set here the
+         * appropriate default value. */
+        if (global || ((cbk->mask & (1ULL << i)) != 0)) {
+            list[i] = EC_MISSING_DATA;
+        } else {
+            list[i] = NULL;
         }
+    }
 
-        count = 0;
-        list_for_each_entry(ans, &cbk->fop->answer_list, answer_list) {
-                if (global || ((cbk->mask & ans->mask) != 0)) {
-                        dict = (which == EC_COMBINE_XDATA) ? ans->xdata
-                                                           : ans->dict;
-                        data = dict_get(dict, key);
-                        if (data != NULL) {
-                                list[ans->idx] = data;
-                                count++;
-                        }
-                }
+    count = 0;
+    list_for_each_entry(ans, &cbk->fop->answer_list, answer_list)
+    {
+        if (global || ((cbk->mask & ans->mask) != 0)) {
+            dict = (which == EC_COMBINE_XDATA) ? ans->xdata : ans->dict;
+            data = dict_get(dict, key);
+            if (data != NULL) {
+                list[ans->idx] = data;
+                count++;
+            }
         }
+    }
 
-        return count;
+    return count;
 }
 
-int32_t ec_concat_prepare(xlator_t *xl, char **str, char **sep, char **post,
-                          const char *fmt, va_list args)
+int32_t
+ec_concat_prepare(xlator_t *xl, char **str, char **sep, char **post,
+                  const char *fmt, va_list args)
 {
     char *tmp;
     int32_t len;
@@ -339,9 +330,8 @@ int32_t ec_concat_prepare(xlator_t *xl, char **str, char **sep, char **post,
     return 0;
 
 out:
-    gf_msg (xl->name, GF_LOG_ERROR, EINVAL,
-            EC_MSG_INVALID_FORMAT,
-            "Invalid concat format");
+    gf_msg(xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_FORMAT,
+           "Invalid concat format");
 
     GF_FREE(*str);
 
@@ -449,7 +439,8 @@ out:
     return err;
 }
 
-int32_t ec_dict_data_merge(ec_cbk_data_t *cbk, int32_t which, char *key)
+int32_t
+ec_dict_data_merge(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
     ec_t *ec = cbk->fop->xl->private;
     data_t *data[ec->nodes];
@@ -458,7 +449,6 @@ int32_t ec_dict_data_merge(ec_cbk_data_t *cbk, int32_t which, char *key)
     int32_t i, len;
     int32_t err;
 
-
     ec_dict_list(data, cbk, which, key, _gf_false);
 
     lockinfo = dict_new();
@@ -526,11 +516,12 @@ out:
     return err;
 }
 
-int32_t ec_dict_data_uuid(ec_cbk_data_t * cbk, int32_t which, char * key)
+int32_t
+ec_dict_data_uuid(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
-    ec_cbk_data_t * ans, * min;
-    dict_t * src, * dst;
-    data_t * data;
+    ec_cbk_data_t *ans, *min;
+    dict_t *src, *dst;
+    data_t *data;
 
     min = cbk;
     for (ans = cbk->next; ans != NULL; ans = ans->next) {
@@ -555,7 +546,8 @@ int32_t ec_dict_data_uuid(ec_cbk_data_t * cbk, int32_t which, char * key)
     return 0;
 }
 
-int32_t ec_dict_data_iatt(ec_cbk_data_t *cbk, int32_t which, char *key)
+int32_t
+ec_dict_data_iatt(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
     ec_t *ec = cbk->fop->xl->private;
     data_t *data[ec->nodes];
@@ -578,12 +570,12 @@ int32_t ec_dict_data_iatt(ec_cbk_data_t *cbk, int32_t which, char *key)
         if (stbuf == NULL) {
             stbuf = GF_MALLOC(sizeof(struct iatt), gf_common_mt_char);
             if (stbuf == NULL) {
-                    ret = -ENOMEM;
-                    goto out;
+                ret = -ENOMEM;
+                goto out;
             }
             *stbuf = *tmp;
         } else {
-            if (!ec_iatt_combine (cbk->fop, stbuf, tmp, 1)) {
+            if (!ec_iatt_combine(cbk->fop, stbuf, tmp, 1)) {
                 ret = -EINVAL;
                 goto out;
             }
@@ -613,7 +605,8 @@ out:
     return ret;
 }
 
-int32_t ec_dict_data_max32(ec_cbk_data_t *cbk, int32_t which, char *key)
+int32_t
+ec_dict_data_max32(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
     ec_t *ec = cbk->fop->xl->private;
     data_t *data[ec->nodes];
@@ -639,7 +632,8 @@ int32_t ec_dict_data_max32(ec_cbk_data_t *cbk, int32_t which, char *key)
     return dict_set_uint32(dict, key, max);
 }
 
-int32_t ec_dict_data_max64(ec_cbk_data_t *cbk, int32_t which, char *key)
+int32_t
+ec_dict_data_max64(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
     ec_t *ec = cbk->fop->xl->private;
     data_t *data[ec->nodes];
@@ -665,14 +659,19 @@ int32_t ec_dict_data_max64(ec_cbk_data_t *cbk, int32_t which, char *key)
     return dict_set_uint64(dict, key, max);
 }
 
-int32_t ec_dict_data_quota(ec_cbk_data_t *cbk, int32_t which, char *key)
+int32_t
+ec_dict_data_quota(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
-    ec_t        *ec               = cbk->fop->xl->private;
-    data_t      *data[ec->nodes];
-    dict_t      *dict             = NULL;
-    int32_t      i                = 0;
-    quota_meta_t size             = {0, };
-    quota_meta_t max_size         = {0, };
+    ec_t *ec = cbk->fop->xl->private;
+    data_t *data[ec->nodes];
+    dict_t *dict = NULL;
+    int32_t i = 0;
+    quota_meta_t size = {
+        0,
+    };
+    quota_meta_t max_size = {
+        0,
+    };
 
     if (ec_dict_list(data, cbk, which, key, _gf_false) == 0) {
         return 0;
@@ -685,25 +684,26 @@ int32_t ec_dict_data_quota(ec_cbk_data_t *cbk, int32_t which, char *key)
      */
     for (i = 0; i < ec->nodes; i++) {
         if ((data[i] == NULL) || (data[i] == EC_MISSING_DATA) ||
-            (quota_data_to_meta (data[i], QUOTA_SIZE_KEY, &size) < 0)) {
-                continue;
+            (quota_data_to_meta(data[i], QUOTA_SIZE_KEY, &size) < 0)) {
+            continue;
         }
 
         if (size.size > max_size.size)
-                max_size.size = size.size;
+            max_size.size = size.size;
         if (size.file_count > max_size.file_count)
-                max_size.file_count = size.file_count;
+            max_size.file_count = size.file_count;
         if (size.dir_count > max_size.dir_count)
-                max_size.dir_count = size.dir_count;
+            max_size.dir_count = size.dir_count;
     }
 
     max_size.size *= ec->fragments;
 
     dict = (which == EC_COMBINE_XDATA) ? cbk->xdata : cbk->dict;
-    return quota_dict_set_meta (dict, key, &max_size, IA_IFDIR);
+    return quota_dict_set_meta(dict, key, &max_size, IA_IFDIR);
 }
 
-int32_t ec_dict_data_stime(ec_cbk_data_t * cbk, int32_t which, char * key)
+int32_t
+ec_dict_data_stime(ec_cbk_data_t *cbk, int32_t which, char *key)
 {
     ec_t *ec = cbk->fop->xl->private;
     data_t *data[ec->nodes];
@@ -719,8 +719,8 @@ int32_t ec_dict_data_stime(ec_cbk_data_t * cbk, int32_t which, char * key)
         }
         err = gf_get_max_stime(cbk->fop->xl, dict, key, data[i]);
         if (err != 0) {
-            gf_msg (cbk->fop->xl->name, GF_LOG_ERROR, -err,
-                    EC_MSG_STIME_COMBINE_FAIL, "STIME combination failed");
+            gf_msg(cbk->fop->xl->name, GF_LOG_ERROR, -err,
+                   EC_MSG_STIME_COMBINE_FAIL, "STIME combination failed");
 
             return err;
         }
@@ -729,28 +729,24 @@ int32_t ec_dict_data_stime(ec_cbk_data_t * cbk, int32_t which, char * key)
     return 0;
 }
 
-int32_t ec_dict_data_combine(dict_t * dict, char * key, data_t * value,
-                             void * arg)
+int32_t
+ec_dict_data_combine(dict_t *dict, char *key, data_t *value, void *arg)
 {
-    ec_dict_combine_t * data = arg;
+    ec_dict_combine_t *data = arg;
 
     if ((strcmp(key, GF_XATTR_PATHINFO_KEY) == 0) ||
-        (strcmp(key, GF_XATTR_USER_PATHINFO_KEY) == 0))
-    {
-        return ec_dict_data_concat("(<EC:%s> { })", data->cbk, data->which,
-                                   key, NULL, NULL, _gf_false,
+        (strcmp(key, GF_XATTR_USER_PATHINFO_KEY) == 0)) {
+        return ec_dict_data_concat("(<EC:%s> { })", data->cbk, data->which, key,
+                                   NULL, NULL, _gf_false,
                                    data->cbk->fop->xl->name);
     }
 
-    if (strncmp(key, GF_XATTR_CLRLK_CMD, SLEN (GF_XATTR_CLRLK_CMD)) == 0)
-    {
+    if (strncmp(key, GF_XATTR_CLRLK_CMD, SLEN(GF_XATTR_CLRLK_CMD)) == 0) {
         return ec_dict_data_concat("{\n}", data->cbk, data->which, key, NULL,
                                    NULL, _gf_false);
     }
 
-    if (strncmp(key, GF_XATTR_LOCKINFO_KEY,
-                SLEN (GF_XATTR_LOCKINFO_KEY)) == 0)
-    {
+    if (strncmp(key, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) == 0) {
         return ec_dict_data_merge(data->cbk, data->which, key);
     }
 
@@ -758,8 +754,7 @@ int32_t ec_dict_data_combine(dict_t * dict, char * key, data_t * value,
         return ec_dict_data_max32(data->cbk, data->which, key);
     }
 
-    if (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0)
-    {
+    if (strcmp(key, GLUSTERFS_OPEN_FD_COUNT) == 0) {
         return ec_dict_data_max32(data->cbk, data->which, key);
     }
     if ((strcmp(key, GLUSTERFS_INODELK_COUNT) == 0) ||
@@ -771,23 +766,22 @@ int32_t ec_dict_data_combine(dict_t * dict, char * key, data_t * value,
         return ec_dict_data_quota(data->cbk, data->which, key);
     }
     /* Ignore all other quota attributes */
-    if (strncmp(key, EC_QUOTA_PREFIX, SLEN (EC_QUOTA_PREFIX)) == 0) {
+    if (strncmp(key, EC_QUOTA_PREFIX, SLEN(EC_QUOTA_PREFIX)) == 0) {
         return 0;
     }
 
     if (XATTR_IS_NODE_UUID(key)) {
         if (data->cbk->fop->int32) {
-                /* List of node uuid is requested */
-                return ec_dict_data_concat("{ }", data->cbk, data->which, key,
-                                           GF_XATTR_LIST_NODE_UUIDS_KEY,
-                                           UUID0_STR, _gf_true);
+            /* List of node uuid is requested */
+            return ec_dict_data_concat("{ }", data->cbk, data->which, key,
+                                       GF_XATTR_LIST_NODE_UUIDS_KEY, UUID0_STR,
+                                       _gf_true);
         } else {
-                return ec_dict_data_uuid(data->cbk, data->which, key);
+            return ec_dict_data_uuid(data->cbk, data->which, key);
         }
     }
 
-    if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0)
-    {
+    if (fnmatch(GF_XATTR_STIME_PATTERN, key, FNM_NOESCAPE) == 0) {
         return ec_dict_data_stime(data->cbk, data->which, key);
     }
 
@@ -795,14 +789,15 @@ int32_t ec_dict_data_combine(dict_t * dict, char * key, data_t * value,
         return ec_dict_data_max64(data->cbk, data->which, key);
     }
 
-    if (strcmp (key, GF_PRESTAT) == 0 || strcmp (key, GF_POSTSTAT) == 0) {
+    if (strcmp(key, GF_PRESTAT) == 0 || strcmp(key, GF_POSTSTAT) == 0) {
         return ec_dict_data_iatt(data->cbk, data->which, key);
     }
 
     return 0;
 }
 
-int32_t ec_dict_combine(ec_cbk_data_t * cbk, int32_t which)
+int32_t
+ec_dict_combine(ec_cbk_data_t *cbk, int32_t which)
 {
     dict_t *dict = NULL;
     ec_dict_combine_t data;
@@ -815,9 +810,8 @@ int32_t ec_dict_combine(ec_cbk_data_t * cbk, int32_t which)
     if (dict != NULL) {
         err = dict_foreach(dict, ec_dict_data_combine, &data);
         if (err != 0) {
-            gf_msg (cbk->fop->xl->name, GF_LOG_ERROR, -err,
-                    EC_MSG_DICT_COMBINE_FAIL,
-                    "Dictionary combination failed");
+            gf_msg(cbk->fop->xl->name, GF_LOG_ERROR, -err,
+                   EC_MSG_DICT_COMBINE_FAIL, "Dictionary combination failed");
 
             return err;
         }
@@ -826,47 +820,43 @@ int32_t ec_dict_combine(ec_cbk_data_t * cbk, int32_t which)
     return 0;
 }
 
-int32_t ec_vector_compare(struct iovec * dst_vector, int32_t dst_count,
-                          struct iovec * src_vector, int32_t src_count)
+int32_t
+ec_vector_compare(struct iovec *dst_vector, int32_t dst_count,
+                  struct iovec *src_vector, int32_t src_count)
 {
     int32_t dst_size = 0, src_size = 0;
 
-    if (dst_count > 0)
-    {
+    if (dst_count > 0) {
         dst_size = iov_length(dst_vector, dst_count);
     }
-    if (src_count > 0)
-    {
+    if (src_count > 0) {
         src_size = iov_length(src_vector, src_count);
     }
 
     return (dst_size == src_size);
 }
 
-int32_t ec_flock_compare(struct gf_flock * dst, struct gf_flock * src)
+int32_t
+ec_flock_compare(struct gf_flock *dst, struct gf_flock *src)
 {
-    if ((dst->l_type != src->l_type) ||
-        (dst->l_whence != src->l_whence) ||
-        (dst->l_start != src->l_start) ||
-        (dst->l_len != src->l_len) ||
+    if ((dst->l_type != src->l_type) || (dst->l_whence != src->l_whence) ||
+        (dst->l_start != src->l_start) || (dst->l_len != src->l_len) ||
         (dst->l_pid != src->l_pid) ||
-        !is_same_lkowner(&dst->l_owner, &src->l_owner))
-    {
+        !is_same_lkowner(&dst->l_owner, &src->l_owner)) {
         return 0;
     }
 
     return 1;
 }
 
-void ec_statvfs_combine(struct statvfs * dst, struct statvfs * src)
+void
+ec_statvfs_combine(struct statvfs *dst, struct statvfs *src)
 {
-    if (dst->f_bsize < src->f_bsize)
-    {
+    if (dst->f_bsize < src->f_bsize) {
         dst->f_bsize = src->f_bsize;
     }
 
-    if (dst->f_frsize < src->f_frsize)
-    {
+    if (dst->f_frsize < src->f_frsize) {
         dst->f_blocks *= dst->f_frsize;
         dst->f_blocks /= src->f_frsize;
 
@@ -877,9 +867,7 @@ void ec_statvfs_combine(struct statvfs * dst, struct statvfs * src)
         dst->f_bavail /= src->f_frsize;
 
         dst->f_frsize = src->f_frsize;
-    }
-    else if (dst->f_frsize > src->f_frsize)
-    {
+    } else if (dst->f_frsize > src->f_frsize) {
         src->f_blocks *= src->f_frsize;
         src->f_blocks /= dst->f_frsize;
 
@@ -889,90 +877,80 @@ void ec_statvfs_combine(struct statvfs * dst, struct statvfs * src)
         src->f_bavail *= src->f_frsize;
         src->f_bavail /= dst->f_frsize;
     }
-    if (dst->f_blocks > src->f_blocks)
-    {
+    if (dst->f_blocks > src->f_blocks) {
         dst->f_blocks = src->f_blocks;
     }
-    if (dst->f_bfree > src->f_bfree)
-    {
+    if (dst->f_bfree > src->f_bfree) {
         dst->f_bfree = src->f_bfree;
     }
-    if (dst->f_bavail > src->f_bavail)
-    {
+    if (dst->f_bavail > src->f_bavail) {
         dst->f_bavail = src->f_bavail;
     }
 
-    if (dst->f_files < src->f_files)
-    {
+    if (dst->f_files < src->f_files) {
         dst->f_files = src->f_files;
     }
-    if (dst->f_ffree > src->f_ffree)
-    {
+    if (dst->f_ffree > src->f_ffree) {
         dst->f_ffree = src->f_ffree;
     }
-    if (dst->f_favail > src->f_favail)
-    {
+    if (dst->f_favail > src->f_favail) {
         dst->f_favail = src->f_favail;
     }
-    if (dst->f_namemax > src->f_namemax)
-    {
+    if (dst->f_namemax > src->f_namemax) {
         dst->f_namemax = src->f_namemax;
     }
 
-    if (dst->f_flag != src->f_flag)
-    {
-        gf_msg_debug (THIS->name, 0,
-                "Mismatching file system flags "
-                "(%lX, %lX)",
-                dst->f_flag, src->f_flag);
+    if (dst->f_flag != src->f_flag) {
+        gf_msg_debug(THIS->name, 0,
+                     "Mismatching file system flags "
+                     "(%lX, %lX)",
+                     dst->f_flag, src->f_flag);
     }
     dst->f_flag &= src->f_flag;
 }
 
-int32_t ec_combine_check(ec_cbk_data_t * dst, ec_cbk_data_t * src,
-                         ec_combine_f combine)
+int32_t
+ec_combine_check(ec_cbk_data_t *dst, ec_cbk_data_t *src, ec_combine_f combine)
 {
-    ec_fop_data_t * fop = dst->fop;
+    ec_fop_data_t *fop = dst->fop;
 
-    if (dst->op_ret != src->op_ret)
-    {
-        gf_msg_debug (fop->xl->name, 0, "Mismatching return code in "
-                                            "answers of '%s': %d <-> %d",
-               ec_fop_name(fop->id), dst->op_ret, src->op_ret);
+    if (dst->op_ret != src->op_ret) {
+        gf_msg_debug(fop->xl->name, 0,
+                     "Mismatching return code in "
+                     "answers of '%s': %d <-> %d",
+                     ec_fop_name(fop->id), dst->op_ret, src->op_ret);
 
         return 0;
     }
-    if (dst->op_ret < 0)
-    {
-        if (dst->op_errno != src->op_errno)
-        {
-            gf_msg_debug (fop->xl->name, 0, "Mismatching errno code in "
-                                                "answers of '%s': %d <-> %d",
-                   ec_fop_name(fop->id), dst->op_errno, src->op_errno);
+    if (dst->op_ret < 0) {
+        if (dst->op_errno != src->op_errno) {
+            gf_msg_debug(fop->xl->name, 0,
+                         "Mismatching errno code in "
+                         "answers of '%s': %d <-> %d",
+                         ec_fop_name(fop->id), dst->op_errno, src->op_errno);
 
             return 0;
         }
     }
 
-    if (!ec_dict_compare(dst->xdata, src->xdata))
-    {
-        gf_msg (fop->xl->name, GF_LOG_DEBUG, 0,
-                EC_MSG_XDATA_MISMATCH,
-                "Mismatching xdata in answers "
-                "of '%s'", ec_fop_name(fop->id));
+    if (!ec_dict_compare(dst->xdata, src->xdata)) {
+        gf_msg(fop->xl->name, GF_LOG_DEBUG, 0, EC_MSG_XDATA_MISMATCH,
+               "Mismatching xdata in answers "
+               "of '%s'",
+               ec_fop_name(fop->id));
 
         return 0;
     }
 
-    if ((dst->op_ret >= 0) && (combine != NULL))
-    {
+    if ((dst->op_ret >= 0) && (combine != NULL)) {
         return combine(fop, dst, src);
     }
 
     return 1;
 }
 
-void ec_combine (ec_cbk_data_t *newcbk, ec_combine_f combine)
+void
+ec_combine(ec_cbk_data_t *newcbk, ec_combine_f combine)
 {
     ec_fop_data_t *fop = newcbk->fop;
     ec_cbk_data_t *cbk = NULL, *tmp = NULL;
@@ -987,17 +965,14 @@ void ec_combine (ec_cbk_data_t *newcbk, ec_combine_f combine)
     item = fop->cbk_list.prev;
     list_for_each_entry(cbk, &fop->cbk_list, list)
     {
-        if (ec_combine_check(newcbk, cbk, combine))
-        {
+        if (ec_combine_check(newcbk, cbk, combine)) {
             newcbk->count += cbk->count;
             newcbk->mask |= cbk->mask;
 
             item = cbk->list.prev;
-            while (item != &fop->cbk_list)
-            {
+            while (item != &fop->cbk_list) {
                 tmp = list_entry(item, ec_cbk_data_t, list);
-                if (tmp->count >= newcbk->count)
-                {
+                if (tmp->count >= newcbk->count) {
                     break;
                 }
                 item = item->prev;
diff --git a/xlators/cluster/ec/src/ec-common.c b/xlators/cluster/ec/src/ec-common.c
index 86432bd7da7..0eee0a3363f 100644
--- a/xlators/cluster/ec/src/ec-common.c
+++ b/xlators/cluster/ec/src/ec-common.c
@@ -24,29 +24,28 @@
 #define EC_INVALID_INDEX UINT32_MAX
 
 void
-ec_update_fd_status (fd_t *fd, xlator_t *xl, int idx,
-                     int32_t ret_status)
+ec_update_fd_status(fd_t *fd, xlator_t *xl, int idx, int32_t ret_status)
 {
-        ec_fd_t *fd_ctx;
+    ec_fd_t *fd_ctx;
 
-        if (fd == NULL)
-                return;
+    if (fd == NULL)
+        return;
 
-        LOCK (&fd->lock);
-        {
-                fd_ctx = __ec_fd_get(fd, xl);
-                if (fd_ctx) {
-                        if (ret_status >= 0)
-                                fd_ctx->fd_status[idx] = EC_FD_OPENED;
-                        else
-                                fd_ctx->fd_status[idx] = EC_FD_NOT_OPENED;
-                }
+    LOCK(&fd->lock);
+    {
+        fd_ctx = __ec_fd_get(fd, xl);
+        if (fd_ctx) {
+            if (ret_status >= 0)
+                fd_ctx->fd_status[idx] = EC_FD_OPENED;
+            else
+                fd_ctx->fd_status[idx] = EC_FD_NOT_OPENED;
         }
-        UNLOCK (&fd->lock);
+    }
+    UNLOCK(&fd->lock);
 }
 
 static int
-ec_fd_ctx_need_open (fd_t *fd, xlator_t *this, uintptr_t *need_open)
+ec_fd_ctx_need_open(fd_t *fd, xlator_t *this, uintptr_t *need_open)
 {
     int i = 0;
     int count = 0;
@@ -56,22 +55,22 @@ ec_fd_ctx_need_open (fd_t *fd, xlator_t *this, uintptr_t *need_open)
     ec = this->private;
     *need_open = 0;
 
-    fd_ctx = ec_fd_get (fd, this);
+    fd_ctx = ec_fd_get(fd, this);
     if (!fd_ctx)
         return count;
 
-    LOCK (&fd->lock);
+    LOCK(&fd->lock);
     {
         for (i = 0; i < ec->nodes; i++) {
-                if ((fd_ctx->fd_status[i] == EC_FD_NOT_OPENED) &&
-                    (ec->xl_up & (1<<i))) {
-                        fd_ctx->fd_status[i] = EC_FD_OPENING;
-                        *need_open |= (1<<i);
-                        count++;
-                }
+            if ((fd_ctx->fd_status[i] == EC_FD_NOT_OPENED) &&
+                (ec->xl_up & (1 << i))) {
+                fd_ctx->fd_status[i] = EC_FD_OPENING;
+                *need_open |= (1 << i);
+                count++;
+            }
         }
     }
-    UNLOCK (&fd->lock);
+    UNLOCK(&fd->lock);
 
     /* If fd needs to open on minimum number of nodes
      * then ignore fixing the fd as it has been
@@ -84,136 +83,137 @@ ec_fd_ctx_need_open (fd_t *fd, xlator_t *this, uintptr_t *need_open)
 }
 
 static gf_boolean_t
-ec_is_fd_fixable (fd_t *fd)
+ec_is_fd_fixable(fd_t *fd)
 {
     if (!fd || !fd->inode)
         return _gf_false;
-    else if (fd_is_anonymous (fd))
+    else if (fd_is_anonymous(fd))
         return _gf_false;
-    else if (gf_uuid_is_null (fd->inode->gfid))
+    else if (gf_uuid_is_null(fd->inode->gfid))
         return _gf_false;
 
     return _gf_true;
 }
 
 static void
-ec_fix_open (ec_fop_data_t *fop)
+ec_fix_open(ec_fop_data_t *fop)
 {
-    int                call_count = 0;
-    uintptr_t           need_open = 0;
-    int                       ret = 0;
-    loc_t                     loc = {0, };
+    int call_count = 0;
+    uintptr_t need_open = 0;
+    int ret = 0;
+    loc_t loc = {
+        0,
+    };
 
-    if (!ec_is_fd_fixable (fop->fd))
+    if (!ec_is_fd_fixable(fop->fd))
         goto out;
 
     /* Evaluate how many remote fd's to be opened */
-    call_count = ec_fd_ctx_need_open (fop->fd, fop->xl, &need_open);
+    call_count = ec_fd_ctx_need_open(fop->fd, fop->xl, &need_open);
     if (!call_count)
         goto out;
 
-    loc.inode = inode_ref (fop->fd->inode);
-    gf_uuid_copy (loc.gfid, fop->fd->inode->gfid);
-    ret = loc_path (&loc, NULL);
+    loc.inode = inode_ref(fop->fd->inode);
+    gf_uuid_copy(loc.gfid, fop->fd->inode->gfid);
+    ret = loc_path(&loc, NULL);
     if (ret < 0) {
         goto out;
     }
 
     if (IA_IFDIR == fop->fd->inode->ia_type) {
-        ec_opendir(fop->frame, fop->xl, need_open, EC_MINIMUM_ONE,
-                   NULL, NULL, &fop->loc[0], fop->fd, NULL);
-    } else{
-        ec_open(fop->frame, fop->xl, need_open, EC_MINIMUM_ONE,
-                NULL, NULL, &loc, fop->fd->flags, fop->fd, NULL);
+        ec_opendir(fop->frame, fop->xl, need_open, EC_MINIMUM_ONE, NULL, NULL,
+                   &fop->loc[0], fop->fd, NULL);
+    } else {
+        ec_open(fop->frame, fop->xl, need_open, EC_MINIMUM_ONE, NULL, NULL,
+                &loc, fop->fd->flags, fop->fd, NULL);
     }
 
 out:
-    loc_wipe (&loc);
+    loc_wipe(&loc);
 }
 
 off_t
-ec_range_end_get (off_t fl_start, size_t fl_size)
+ec_range_end_get(off_t fl_start, size_t fl_size)
 {
-        off_t fl_end = 0;
-        switch (fl_size) {
+    off_t fl_end = 0;
+    switch (fl_size) {
         case 0:
-                return fl_start;
+            return fl_start;
         case LLONG_MAX: /*Infinity*/
-                return LLONG_MAX;
+            return LLONG_MAX;
         default:
-                fl_end = fl_start + fl_size - 1;
-                if (fl_end < 0) /*over-flow*/
-                        return LLONG_MAX;
-                else
-                        return fl_end;
-        }
+            fl_end = fl_start + fl_size - 1;
+            if (fl_end < 0) /*over-flow*/
+                return LLONG_MAX;
+            else
+                return fl_end;
+    }
 }
 
 static gf_boolean_t
-ec_is_range_conflict (ec_lock_link_t *l1, ec_lock_link_t *l2)
+ec_is_range_conflict(ec_lock_link_t *l1, ec_lock_link_t *l2)
 {
-        return ((l1->fl_end >= l2->fl_start) && (l2->fl_end >= l1->fl_start));
+    return ((l1->fl_end >= l2->fl_start) && (l2->fl_end >= l1->fl_start));
 }
 
 static gf_boolean_t
-ec_lock_conflict (ec_lock_link_t *l1, ec_lock_link_t *l2)
+ec_lock_conflict(ec_lock_link_t *l1, ec_lock_link_t *l2)
 {
-        ec_t *ec = l1->fop->xl->private;
+    ec_t *ec = l1->fop->xl->private;
 
-        /* Fops like access/stat won't have to worry what the other fops are
-         * modifying as the fop is wound only to one brick. So it can be
-         * executed in parallel*/
-        if (l1->fop->minimum == EC_MINIMUM_ONE ||
-            l2->fop->minimum == EC_MINIMUM_ONE)
-                return _gf_false;
+    /* Fops like access/stat won't have to worry what the other fops are
+     * modifying as the fop is wound only to one brick. So it can be
+     * executed in parallel*/
+    if (l1->fop->minimum == EC_MINIMUM_ONE ||
+        l2->fop->minimum == EC_MINIMUM_ONE)
+        return _gf_false;
 
-        if ((l1->fop->flags & EC_FLAG_LOCK_SHARED) &&
-            (l2->fop->flags & EC_FLAG_LOCK_SHARED))
-                return _gf_false;
+    if ((l1->fop->flags & EC_FLAG_LOCK_SHARED) &&
+        (l2->fop->flags & EC_FLAG_LOCK_SHARED))
+        return _gf_false;
 
-        if (!ec->parallel_writes) {
-                return _gf_true;
-        }
+    if (!ec->parallel_writes) {
+        return _gf_true;
+    }
 
-        return ec_is_range_conflict (l1, l2);
+    return ec_is_range_conflict(l1, l2);
 }
 
 uint32_t
-ec_select_first_by_read_policy (ec_t *ec, ec_fop_data_t *fop)
-{
-        if (ec->read_policy == EC_ROUND_ROBIN) {
-                return ec->idx;
-        } else if (ec->read_policy == EC_GFID_HASH) {
-                if (fop->use_fd) {
-                        return SuperFastHash((char *)fop->fd->inode->gfid,
-                                   sizeof(fop->fd->inode->gfid)) % ec->nodes;
-                } else {
-                        if (gf_uuid_is_null (fop->loc[0].gfid))
-                                loc_gfid (&fop->loc[0], fop->loc[0].gfid);
-                        return SuperFastHash((char *)fop->loc[0].gfid,
-                                   sizeof(fop->loc[0].gfid)) % ec->nodes;
-                }
+ec_select_first_by_read_policy(ec_t *ec, ec_fop_data_t *fop)
+{
+    if (ec->read_policy == EC_ROUND_ROBIN) {
+        return ec->idx;
+    } else if (ec->read_policy == EC_GFID_HASH) {
+        if (fop->use_fd) {
+            return SuperFastHash((char *)fop->fd->inode->gfid,
+                                 sizeof(fop->fd->inode->gfid)) %
+                   ec->nodes;
+        } else {
+            if (gf_uuid_is_null(fop->loc[0].gfid))
+                loc_gfid(&fop->loc[0], fop->loc[0].gfid);
+            return SuperFastHash((char *)fop->loc[0].gfid,
+                                 sizeof(fop->loc[0].gfid)) %
+                   ec->nodes;
         }
-        return 0;
+    }
+    return 0;
 }
 
-static
-gf_boolean_t ec_child_valid(ec_t * ec, ec_fop_data_t * fop, uint32_t idx)
+static gf_boolean_t
+ec_child_valid(ec_t *ec, ec_fop_data_t *fop, uint32_t idx)
 {
     return (idx < ec->nodes) && (((fop->remaining >> idx) & 1) == 1);
 }
 
-static
-uint32_t ec_child_next(ec_t * ec, ec_fop_data_t * fop, uint32_t idx)
+static uint32_t
+ec_child_next(ec_t *ec, ec_fop_data_t *fop, uint32_t idx)
 {
-    while (!ec_child_valid(ec, fop, idx))
-    {
-        if (++idx >= ec->nodes)
-        {
+    while (!ec_child_valid(ec, fop, idx)) {
+        if (++idx >= ec->nodes) {
             idx = 0;
         }
-        if (idx == fop->first)
-        {
+        if (idx == fop->first) {
             return EC_INVALID_INDEX;
         }
     }
@@ -221,20 +221,21 @@ uint32_t ec_child_next(ec_t * ec, ec_fop_data_t * fop, uint32_t idx)
     return idx;
 }
 
-int32_t ec_heal_report(call_frame_t * frame, void * cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno, uintptr_t mask,
-                       uintptr_t good, uintptr_t bad, dict_t * xdata)
+int32_t
+ec_heal_report(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, uintptr_t mask, uintptr_t good,
+               uintptr_t bad, dict_t *xdata)
 {
     if (op_ret < 0) {
-        gf_msg (this->name, GF_LOG_DEBUG, op_errno,
-                EC_MSG_HEAL_FAIL, "Heal failed");
+        gf_msg(this->name, GF_LOG_DEBUG, op_errno, EC_MSG_HEAL_FAIL,
+               "Heal failed");
     } else {
         if ((mask & ~good) != 0) {
-            gf_msg (this->name, GF_LOG_DEBUG, 0,
-                    EC_MSG_HEAL_SUCCESS, "Heal succeeded on %d/%d "
-                    "subvolumes",
-                    gf_bits_count(mask & ~(good | bad)),
-                    gf_bits_count(mask & ~good));
+            gf_msg(this->name, GF_LOG_DEBUG, 0, EC_MSG_HEAL_SUCCESS,
+                   "Heal succeeded on %d/%d "
+                   "subvolumes",
+                   gf_bits_count(mask & ~(good | bad)),
+                   gf_bits_count(mask & ~good));
         }
     }
 
@@ -242,103 +243,101 @@ int32_t ec_heal_report(call_frame_t * frame, void * cookie, xlator_t * this,
 }
 
 static uintptr_t
-ec_fop_needs_name_heal (ec_fop_data_t *fop)
+ec_fop_needs_name_heal(ec_fop_data_t *fop)
 {
-        ec_t          *ec         = NULL;
-        ec_cbk_data_t *cbk        = NULL;
-        ec_cbk_data_t *enoent_cbk = NULL;
+    ec_t *ec = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    ec_cbk_data_t *enoent_cbk = NULL;
 
-        ec = fop->xl->private;
-        if (fop->id != GF_FOP_LOOKUP)
-                return 0;
+    ec = fop->xl->private;
+    if (fop->id != GF_FOP_LOOKUP)
+        return 0;
 
-        if (!fop->loc[0].name || strlen (fop->loc[0].name) == 0)
-                return 0;
+    if (!fop->loc[0].name || strlen(fop->loc[0].name) == 0)
+        return 0;
 
-        list_for_each_entry(cbk, &fop->cbk_list, list)
-        {
-                if (cbk->op_ret < 0 && cbk->op_errno == ENOENT) {
-                        enoent_cbk = cbk;
-                        break;
-                }
+    list_for_each_entry(cbk, &fop->cbk_list, list)
+    {
+        if (cbk->op_ret < 0 && cbk->op_errno == ENOENT) {
+            enoent_cbk = cbk;
+            break;
         }
+    }
 
-        if (!enoent_cbk)
-                return 0;
+    if (!enoent_cbk)
+        return 0;
 
-        return ec->xl_up & ~enoent_cbk->mask;
+    return ec->xl_up & ~enoent_cbk->mask;
 }
 
-int32_t ec_fop_needs_heal(ec_fop_data_t *fop)
+int32_t
+ec_fop_needs_heal(ec_fop_data_t *fop)
 {
     ec_t *ec = fop->xl->private;
 
     if (fop->lock_count == 0) {
-    /*
-     * if fop->lock_count is zero that means it saw version mismatch
-     * without any locks so it can't be trusted. If we launch a heal
-     * based on this it will lead to INODELKs which will affect I/O
-     * performance. Considering self-heal-daemon and operations on
-     * the inode from client which take locks can still trigger the
-     * heal we can choose to not attempt a heal when fop->lock_count
-     * is zero.
-     */
-            return 0;
+        /*
+         * if fop->lock_count is zero that means it saw version mismatch
+         * without any locks so it can't be trusted. If we launch a heal
+         * based on this it will lead to INODELKs which will affect I/O
+         * performance. Considering self-heal-daemon and operations on
+         * the inode from client which take locks can still trigger the
+         * heal we can choose to not attempt a heal when fop->lock_count
+         * is zero.
+         */
+        return 0;
     }
     return (ec->xl_up & ~(fop->remaining | fop->good)) != 0;
 }
 
-void ec_check_status(ec_fop_data_t * fop)
+void
+ec_check_status(ec_fop_data_t *fop)
 {
-    ec_t * ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
     int32_t partial = 0;
     char str1[32], str2[32], str3[32], str4[32], str5[32];
 
-    if (!ec_fop_needs_name_heal (fop) && !ec_fop_needs_heal(fop)) {
+    if (!ec_fop_needs_name_heal(fop) && !ec_fop_needs_heal(fop)) {
         return;
     }
 
     if (fop->answer && fop->answer->op_ret >= 0) {
-        if ((fop->id == GF_FOP_LOOKUP) ||
-            (fop->id == GF_FOP_STAT) || (fop->id == GF_FOP_FSTAT)) {
+        if ((fop->id == GF_FOP_LOOKUP) || (fop->id == GF_FOP_STAT) ||
+            (fop->id == GF_FOP_FSTAT)) {
             partial = fop->answer->iatt[0].ia_type == IA_IFDIR;
         } else if (fop->id == GF_FOP_OPENDIR) {
             partial = 1;
         }
     }
 
-    gf_msg (fop->xl->name, GF_LOG_WARNING, 0,
-            EC_MSG_OP_FAIL_ON_SUBVOLS,
-            "Operation failed on %d of %d subvolumes.(up=%s, mask=%s, "
-            "remaining=%s, good=%s, bad=%s)",
-            gf_bits_count(ec->xl_up & ~(fop->remaining | fop->good)), ec->nodes,
-            ec_bin(str1, sizeof(str1), ec->xl_up, ec->nodes),
-            ec_bin(str2, sizeof(str2), fop->mask, ec->nodes),
-            ec_bin(str3, sizeof(str3), fop->remaining, ec->nodes),
-            ec_bin(str4, sizeof(str4), fop->good, ec->nodes),
-            ec_bin(str5, sizeof(str5),
-            ec->xl_up & ~(fop->remaining | fop->good), ec->nodes));
-    if (fop->use_fd)
-    {
+    gf_msg(fop->xl->name, GF_LOG_WARNING, 0, EC_MSG_OP_FAIL_ON_SUBVOLS,
+           "Operation failed on %d of %d subvolumes.(up=%s, mask=%s, "
+           "remaining=%s, good=%s, bad=%s)",
+           gf_bits_count(ec->xl_up & ~(fop->remaining | fop->good)), ec->nodes,
+           ec_bin(str1, sizeof(str1), ec->xl_up, ec->nodes),
+           ec_bin(str2, sizeof(str2), fop->mask, ec->nodes),
+           ec_bin(str3, sizeof(str3), fop->remaining, ec->nodes),
+           ec_bin(str4, sizeof(str4), fop->good, ec->nodes),
+           ec_bin(str5, sizeof(str5), ec->xl_up & ~(fop->remaining | fop->good),
+                  ec->nodes));
+    if (fop->use_fd) {
         if (fop->fd != NULL) {
             ec_fheal(NULL, fop->xl, -1, EC_MINIMUM_ONE, ec_heal_report, NULL,
                      fop->fd, partial, NULL);
         }
-    }
-    else
-    {
+    } else {
         ec_heal(NULL, fop->xl, -1, EC_MINIMUM_ONE, ec_heal_report, NULL,
                 &fop->loc[0], partial, NULL);
 
-        if (fop->loc[1].inode != NULL)
-        {
+        if (fop->loc[1].inode != NULL) {
             ec_heal(NULL, fop->xl, -1, EC_MINIMUM_ONE, ec_heal_report, NULL,
                     &fop->loc[1], partial, NULL);
         }
     }
 }
 
-void ec_update_good(ec_fop_data_t *fop, uintptr_t good)
+void
+ec_update_good(ec_fop_data_t *fop, uintptr_t good)
 {
     fop->good = good;
 
@@ -349,7 +348,8 @@ void ec_update_good(ec_fop_data_t *fop, uintptr_t good)
     }
 }
 
-void ec_lock_update_good(ec_lock_t *lock, ec_fop_data_t *fop)
+void
+ec_lock_update_good(ec_lock_t *lock, ec_fop_data_t *fop)
 {
     /* Fops that are executed only on one brick do not have enough information
      * to update the global mask of good bricks. */
@@ -365,15 +365,16 @@ void ec_lock_update_good(ec_lock_t *lock, ec_fop_data_t *fop)
     lock->good_mask &= fop->good | fop->remaining;
 }
 
-void __ec_fop_set_error(ec_fop_data_t * fop, int32_t error)
+void
+__ec_fop_set_error(ec_fop_data_t *fop, int32_t error)
 {
-    if ((error != 0) && (fop->error == 0))
-    {
+    if ((error != 0) && (fop->error == 0)) {
         fop->error = error;
     }
 }
 
-void ec_fop_set_error(ec_fop_data_t * fop, int32_t error)
+void
+ec_fop_set_error(ec_fop_data_t *fop, int32_t error)
 {
     LOCK(&fop->lock);
 
@@ -425,18 +426,20 @@ ec_fop_prepare_answer(ec_fop_data_t *fop, gf_boolean_t ro)
     return cbk;
 }
 
-void ec_sleep(ec_fop_data_t *fop)
+void
+ec_sleep(ec_fop_data_t *fop)
 {
     LOCK(&fop->lock);
 
-    GF_ASSERT (fop->refs > 0);
+    GF_ASSERT(fop->refs > 0);
     fop->refs++;
     fop->jobs++;
 
     UNLOCK(&fop->lock);
 }
 
-int32_t ec_check_complete(ec_fop_data_t * fop, ec_resume_f resume)
+int32_t
+ec_check_complete(ec_fop_data_t *fop, ec_resume_f resume)
 {
     int32_t error = -1;
 
@@ -444,14 +447,11 @@ int32_t ec_check_complete(ec_fop_data_t * fop, ec_resume_f resume)
 
     GF_ASSERT(fop->resume == NULL);
 
-    if (--fop->jobs != 0)
-    {
+    if (--fop->jobs != 0) {
         ec_trace("WAIT", fop, "resume=%p", resume);
 
         fop->resume = resume;
-    }
-    else
-    {
+    } else {
         error = fop->error;
         fop->error = 0;
     }
@@ -461,7 +461,8 @@ int32_t ec_check_complete(ec_fop_data_t * fop, ec_resume_f resume)
     return error;
 }
 
-void ec_resume(ec_fop_data_t * fop, int32_t error)
+void
+ec_resume(ec_fop_data_t *fop, int32_t error)
 {
     ec_resume_f resume = NULL;
 
@@ -469,16 +470,13 @@ void ec_resume(ec_fop_data_t * fop, int32_t error)
 
     __ec_fop_set_error(fop, error);
 
-    if (--fop->jobs == 0)
-    {
+    if (--fop->jobs == 0) {
         resume = fop->resume;
         fop->resume = NULL;
-        if (resume != NULL)
-        {
+        if (resume != NULL) {
             ec_trace("RESUME", fop, "error=%d", error);
 
-            if (fop->error != 0)
-            {
+            if (fop->error != 0) {
                 error = fop->error;
             }
             fop->error = 0;
@@ -487,21 +485,20 @@ void ec_resume(ec_fop_data_t * fop, int32_t error)
 
     UNLOCK(&fop->lock);
 
-    if (resume != NULL)
-    {
+    if (resume != NULL) {
         resume(fop, error);
     }
 
     ec_fop_data_release(fop);
 }
 
-void ec_resume_parent(ec_fop_data_t * fop, int32_t error)
+void
+ec_resume_parent(ec_fop_data_t *fop, int32_t error)
 {
-    ec_fop_data_t * parent;
+    ec_fop_data_t *parent;
 
     parent = fop->parent;
-    if (parent != NULL)
-    {
+    if (parent != NULL) {
         ec_trace("RESUME_PARENT", fop, "error=%u", error);
         fop->parent = NULL;
         ec_resume(parent, error);
@@ -509,22 +506,23 @@ void ec_resume_parent(ec_fop_data_t * fop, int32_t error)
 }
 
 gf_boolean_t
-ec_is_recoverable_error (int32_t op_errno)
+ec_is_recoverable_error(int32_t op_errno)
 {
-        switch (op_errno) {
+    switch (op_errno) {
         case ENOTCONN:
         case ESTALE:
         case ENOENT:
-        case EBADFD:/*Opened fd but brick is disconnected*/
-        case EIO:/*Backend-fs crash like XFS/ext4 etc*/
-                return _gf_true;
-        }
-        return _gf_false;
+        case EBADFD: /*Opened fd but brick is disconnected*/
+        case EIO:    /*Backend-fs crash like XFS/ext4 etc*/
+            return _gf_true;
+    }
+    return _gf_false;
 }
 
-void ec_complete(ec_fop_data_t * fop)
+void
+ec_complete(ec_fop_data_t *fop)
 {
-    ec_cbk_data_t * cbk = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t resume = 0, update = 0;
     int healing_count = 0;
 
@@ -536,9 +534,9 @@ void ec_complete(ec_fop_data_t * fop)
         if (fop->answer == NULL) {
             if (!list_empty(&fop->cbk_list)) {
                 cbk = list_entry(fop->cbk_list.next, ec_cbk_data_t, list);
-                healing_count = gf_bits_count (cbk->mask & fop->healing);
-                    /* fop shouldn't be treated as success if it is not
-                     * successful on at least fop->minimum good copies*/
+                healing_count = gf_bits_count(cbk->mask & fop->healing);
+                /* fop shouldn't be treated as success if it is not
+                 * successful on at least fop->minimum good copies*/
                 if ((cbk->count - healing_count) >= fop->minimum) {
                     fop->answer = cbk;
 
@@ -560,8 +558,7 @@ void ec_complete(ec_fop_data_t * fop)
         ec_update_good(fop, cbk->mask);
     }
 
-    if (resume)
-    {
+    if (resume) {
         ec_resume(fop, 0);
     }
 
@@ -571,40 +568,39 @@ void ec_complete(ec_fop_data_t * fop)
 /* There could be already granted locks sitting on the bricks, unlock for which
  * must be wound at all costs*/
 static gf_boolean_t
-ec_must_wind (ec_fop_data_t *fop)
-{
-        if ((fop->id == GF_FOP_INODELK) || (fop->id == GF_FOP_FINODELK) ||
-            (fop->id == GF_FOP_LK)) {
-                if (fop->flock.l_type == F_UNLCK)
-                        return _gf_true;
-        } else if ((fop->id == GF_FOP_ENTRYLK) ||
-                   (fop->id == GF_FOP_FENTRYLK)) {
-                if (fop->entrylk_cmd == ENTRYLK_UNLOCK)
-                        return _gf_true;
-        }
+ec_must_wind(ec_fop_data_t *fop)
+{
+    if ((fop->id == GF_FOP_INODELK) || (fop->id == GF_FOP_FINODELK) ||
+        (fop->id == GF_FOP_LK)) {
+        if (fop->flock.l_type == F_UNLCK)
+            return _gf_true;
+    } else if ((fop->id == GF_FOP_ENTRYLK) || (fop->id == GF_FOP_FENTRYLK)) {
+        if (fop->entrylk_cmd == ENTRYLK_UNLOCK)
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static gf_boolean_t
-ec_internal_op (ec_fop_data_t *fop)
-{
-        if (ec_must_wind (fop))
-                return _gf_true;
-        if (fop->id == GF_FOP_XATTROP)
-                return _gf_true;
-        if (fop->id == GF_FOP_FXATTROP)
-                return _gf_true;
-        return _gf_false;
+ec_internal_op(ec_fop_data_t *fop)
+{
+    if (ec_must_wind(fop))
+        return _gf_true;
+    if (fop->id == GF_FOP_XATTROP)
+        return _gf_true;
+    if (fop->id == GF_FOP_FXATTROP)
+        return _gf_true;
+    return _gf_false;
 }
 
 char *
-ec_msg_str (ec_fop_data_t *fop)
+ec_msg_str(ec_fop_data_t *fop)
 {
-    loc_t    *loc1 = NULL;
-    loc_t    *loc2 = NULL;
-    char     gfid1[64] = {0};
-    char     gfid2[64] = {0};
+    loc_t *loc1 = NULL;
+    loc_t *loc2 = NULL;
+    char gfid1[64] = {0};
+    char gfid2[64] = {0};
 
     if (fop->errstr)
         return fop->errstr;
@@ -614,29 +610,29 @@ ec_msg_str (ec_fop_data_t *fop)
         loc2 = &fop->loc[1];
 
         if (fop->id == GF_FOP_RENAME) {
-                gf_asprintf(&fop->errstr,
-                            "FOP : '%s' failed on '%s' and '%s' with gfids "
-                            "%s and %s respectively", ec_fop_name (fop->id),
-                            loc1->path, loc2->path,
-                            uuid_utoa_r (loc1->gfid, gfid1),
-                            uuid_utoa_r (loc2->gfid, gfid2));
+            gf_asprintf(&fop->errstr,
+                        "FOP : '%s' failed on '%s' and '%s' with gfids "
+                        "%s and %s respectively",
+                        ec_fop_name(fop->id), loc1->path, loc2->path,
+                        uuid_utoa_r(loc1->gfid, gfid1),
+                        uuid_utoa_r(loc2->gfid, gfid2));
         } else {
-                gf_asprintf(&fop->errstr,
-                            "FOP : '%s' failed on '%s' with gfid %s",
-                            ec_fop_name (fop->id),
-                            loc1->path, uuid_utoa_r (loc1->gfid, gfid1));
+            gf_asprintf(&fop->errstr, "FOP : '%s' failed on '%s' with gfid %s",
+                        ec_fop_name(fop->id), loc1->path,
+                        uuid_utoa_r(loc1->gfid, gfid1));
         }
     } else {
         gf_asprintf(&fop->errstr, "FOP : '%s' failed on gfid %s",
-                    ec_fop_name (fop->id),
-                    uuid_utoa_r (fop->fd->inode->gfid, gfid1));
+                    ec_fop_name(fop->id),
+                    uuid_utoa_r(fop->fd->inode->gfid, gfid1));
     }
     return fop->errstr;
 }
 
-int32_t ec_child_select(ec_fop_data_t * fop)
+int32_t
+ec_child_select(ec_fop_data_t *fop)
 {
-    ec_t * ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
     int32_t first = 0, num = 0;
 
     ec_fop_cleanup(fop);
@@ -645,26 +641,22 @@ int32_t ec_child_select(ec_fop_data_t * fop)
     /* Wind the fop on same subvols as parent for any internal extra fops like
      * head/tail read in case of writev fop. Unlocks shouldn't do this because
      * unlock should go on all subvols where lock is performed*/
-    if (fop->parent && !ec_internal_op (fop)) {
-            fop->mask &= (fop->parent->mask & ~fop->parent->healing);
+    if (fop->parent && !ec_internal_op(fop)) {
+        fop->mask &= (fop->parent->mask & ~fop->parent->healing);
     }
 
-    if ((fop->mask & ~ec->xl_up) != 0)
-    {
-        gf_msg (fop->xl->name, GF_LOG_WARNING, 0,
-                EC_MSG_OP_EXEC_UNAVAIL,
-                "Executing operation with "
-                "some subvolumes unavailable. (%lX). %s ",
-                fop->mask & ~ec->xl_up, ec_msg_str(fop));
+    if ((fop->mask & ~ec->xl_up) != 0) {
+        gf_msg(fop->xl->name, GF_LOG_WARNING, 0, EC_MSG_OP_EXEC_UNAVAIL,
+               "Executing operation with "
+               "some subvolumes unavailable. (%lX). %s ",
+               fop->mask & ~ec->xl_up, ec_msg_str(fop));
         fop->mask &= ec->xl_up;
     }
 
-    switch (fop->minimum)
-    {
+    switch (fop->minimum) {
         case EC_MINIMUM_ALL:
             fop->minimum = gf_bits_count(fop->mask);
-            if (fop->minimum >= ec->fragments)
-            {
+            if (fop->minimum >= ec->fragments) {
                 break;
             }
         case EC_MINIMUM_MIN:
@@ -675,11 +667,11 @@ int32_t ec_child_select(ec_fop_data_t * fop)
     }
 
     if (ec->read_policy == EC_ROUND_ROBIN) {
-            first = ec->idx;
-            if (++first >= ec->nodes) {
-                first = 0;
-            }
-            ec->idx = first;
+        first = ec->idx;
+        if (++first >= ec->nodes) {
+            first = 0;
+        }
+        ec->idx = first;
     }
 
     num = gf_bits_count(fop->mask);
@@ -690,14 +682,12 @@ int32_t ec_child_select(ec_fop_data_t * fop)
 
     ec_trace("SELECT", fop, "");
 
-    if ((num < fop->minimum) && (num < ec->fragments))
-    {
-        gf_msg (ec->xl->name, GF_LOG_ERROR, 0,
-                EC_MSG_CHILDS_INSUFFICIENT,
-                "Insufficient available children "
-                "for this request (have %d, need "
-                "%d). %s",
-                num, fop->minimum, ec_msg_str(fop));
+    if ((num < fop->minimum) && (num < ec->fragments)) {
+        gf_msg(ec->xl->name, GF_LOG_ERROR, 0, EC_MSG_CHILDS_INSUFFICIENT,
+               "Insufficient available children "
+               "for this request (have %d, need "
+               "%d). %s",
+               num, fop->minimum, ec_msg_str(fop));
         return 0;
     }
 
@@ -706,10 +696,11 @@ int32_t ec_child_select(ec_fop_data_t * fop)
     return 1;
 }
 
-void ec_dispatch_next(ec_fop_data_t * fop, uint32_t idx)
+void
+ec_dispatch_next(ec_fop_data_t *fop, uint32_t idx)
 {
     uint32_t i = EC_INVALID_INDEX;
-    ec_t * ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
 
     LOCK(&fop->lock);
 
@@ -727,15 +718,15 @@ void ec_dispatch_next(ec_fop_data_t * fop, uint32_t idx)
 
     UNLOCK(&fop->lock);
 
-    if (i < EC_MAX_NODES)
-    {
+    if (i < EC_MAX_NODES) {
         fop->wind(ec, fop, idx);
     }
 }
 
-void ec_dispatch_mask(ec_fop_data_t * fop, uintptr_t mask)
+void
+ec_dispatch_mask(ec_fop_data_t *fop, uintptr_t mask)
 {
-    ec_t * ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
     int32_t count, idx;
 
     count = gf_bits_count(mask);
@@ -752,10 +743,8 @@ void ec_dispatch_mask(ec_fop_data_t * fop, uintptr_t mask)
     UNLOCK(&fop->lock);
 
     idx = 0;
-    while (mask != 0)
-    {
-        if ((mask & 1) != 0)
-        {
+    while (mask != 0) {
+        if ((mask & 1) != 0) {
             fop->wind(ec, fop, idx);
         }
         idx++;
@@ -763,27 +752,27 @@ void ec_dispatch_mask(ec_fop_data_t * fop, uintptr_t mask)
     }
 }
 
-void ec_dispatch_start(ec_fop_data_t * fop)
+void
+ec_dispatch_start(ec_fop_data_t *fop)
 {
     fop->answer = NULL;
     fop->good = 0;
 
     INIT_LIST_HEAD(&fop->cbk_list);
 
-    if (fop->lock_count > 0)
-    {
+    if (fop->lock_count > 0) {
         ec_owner_copy(fop->frame, &fop->req_frame->root->lk_owner);
     }
 }
 
-void ec_dispatch_one(ec_fop_data_t * fop)
+void
+ec_dispatch_one(ec_fop_data_t *fop)
 {
     ec_dispatch_start(fop);
 
-    if (ec_child_select(fop))
-    {
+    if (ec_child_select(fop)) {
         fop->expected = 1;
-        fop->first = ec_select_first_by_read_policy (fop->xl->private, fop);
+        fop->first = ec_select_first_by_read_policy(fop->xl->private, fop);
 
         ec_dispatch_next(fop, fop->first);
     }
@@ -799,8 +788,8 @@ ec_dispatch_one_retry(ec_fop_data_t *fop, ec_cbk_data_t **cbk)
         *cbk = tmp;
     }
     if ((tmp != NULL) && (tmp->op_ret < 0) &&
-        ec_is_recoverable_error (tmp->op_errno)) {
-        GF_ASSERT (fop->mask & (1ULL << tmp->idx));
+        ec_is_recoverable_error(tmp->op_errno)) {
+        GF_ASSERT(fop->mask & (1ULL << tmp->idx));
         fop->mask ^= (1ULL << tmp->idx);
         if (fop->mask) {
             return _gf_true;
@@ -810,12 +799,12 @@ ec_dispatch_one_retry(ec_fop_data_t *fop, ec_cbk_data_t **cbk)
     return _gf_false;
 }
 
-void ec_dispatch_inc(ec_fop_data_t * fop)
+void
+ec_dispatch_inc(ec_fop_data_t *fop)
 {
     ec_dispatch_start(fop);
 
-    if (ec_child_select(fop))
-    {
+    if (ec_child_select(fop)) {
         fop->expected = gf_bits_count(fop->remaining);
         fop->first = 0;
 
@@ -824,35 +813,34 @@ void ec_dispatch_inc(ec_fop_data_t * fop)
 }
 
 void
-ec_dispatch_all (ec_fop_data_t *fop)
+ec_dispatch_all(ec_fop_data_t *fop)
 {
-        ec_dispatch_start(fop);
+    ec_dispatch_start(fop);
 
-        if (ec_child_select(fop)) {
-                fop->expected = gf_bits_count(fop->remaining);
-                fop->first = 0;
+    if (ec_child_select(fop)) {
+        fop->expected = gf_bits_count(fop->remaining);
+        fop->first = 0;
 
-                ec_dispatch_mask(fop, fop->remaining);
-        }
+        ec_dispatch_mask(fop, fop->remaining);
+    }
 }
 
-void ec_dispatch_min(ec_fop_data_t * fop)
+void
+ec_dispatch_min(ec_fop_data_t *fop)
 {
-    ec_t * ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
     uintptr_t mask;
     uint32_t idx;
     int32_t count;
 
     ec_dispatch_start(fop);
 
-    if (ec_child_select(fop))
-    {
+    if (ec_child_select(fop)) {
         fop->expected = count = ec->fragments;
-        fop->first = ec_select_first_by_read_policy (fop->xl->private, fop);
+        fop->first = ec_select_first_by_read_policy(fop->xl->private, fop);
         idx = fop->first - 1;
         mask = 0;
-        while (count-- > 0)
-        {
+        while (count-- > 0) {
             idx = ec_child_next(ec, fop, idx + 1);
             if (idx < EC_MAX_NODES)
                 mask |= 1ULL << idx;
@@ -862,19 +850,18 @@ void ec_dispatch_min(ec_fop_data_t * fop)
     }
 }
 
-ec_lock_t *ec_lock_allocate(ec_fop_data_t *fop, loc_t *loc)
+ec_lock_t *
+ec_lock_allocate(ec_fop_data_t *fop, loc_t *loc)
 {
     ec_t *ec = fop->xl->private;
-    ec_lock_t * lock;
+    ec_lock_t *lock;
     int32_t err;
 
     if ((loc->inode == NULL) ||
-        (gf_uuid_is_null(loc->gfid) && gf_uuid_is_null(loc->inode->gfid)))
-    {
-        gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_INVALID_INODE,
-                "Trying to lock based on an invalid "
-                "inode");
+        (gf_uuid_is_null(loc->gfid) && gf_uuid_is_null(loc->inode->gfid))) {
+        gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_INODE,
+               "Trying to lock based on an invalid "
+               "inode");
 
         __ec_fop_set_error(fop, EINVAL);
 
@@ -882,8 +869,7 @@ ec_lock_t *ec_lock_allocate(ec_fop_data_t *fop, loc_t *loc)
     }
 
     lock = mem_get0(ec->lock_pool);
-    if (lock != NULL)
-    {
+    if (lock != NULL) {
         lock->good_mask = -1ULL;
         INIT_LIST_HEAD(&lock->owners);
         INIT_LIST_HEAD(&lock->waiting);
@@ -900,7 +886,8 @@ ec_lock_t *ec_lock_allocate(ec_fop_data_t *fop, loc_t *loc)
     return lock;
 }
 
-void ec_lock_destroy(ec_lock_t * lock)
+void
+ec_lock_destroy(ec_lock_t *lock)
 {
     loc_wipe(&lock->loc);
     if (lock->fd != NULL) {
@@ -910,13 +897,15 @@ void ec_lock_destroy(ec_lock_t * lock)
     mem_put(lock);
 }
 
-int32_t ec_lock_compare(ec_lock_t * lock1, ec_lock_t * lock2)
+int32_t
+ec_lock_compare(ec_lock_t *lock1, ec_lock_t *lock2)
 {
     return gf_uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
 }
 
-void ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock, uint32_t flags,
-                    loc_t *base, off_t fl_start, size_t fl_size)
+void
+ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock, uint32_t flags, loc_t *base,
+               off_t fl_start, size_t fl_size)
 {
     ec_lock_link_t *link;
 
@@ -951,14 +940,14 @@ void ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock, uint32_t flags,
     link->update[EC_METADATA_TXN] = (flags & EC_UPDATE_META) != 0;
     link->base = base;
     link->fl_start = fl_start;
-    link->fl_end = ec_range_end_get (fl_start, fl_size);
+    link->fl_end = ec_range_end_get(fl_start, fl_size);
 
     lock->refs_pending++;
 }
 
-void ec_lock_prepare_inode_internal(ec_fop_data_t *fop, loc_t *loc,
-                                    uint32_t flags, loc_t *base,
-                                    off_t fl_start, size_t fl_size)
+void
+ec_lock_prepare_inode_internal(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
+                               loc_t *base, off_t fl_start, size_t fl_size)
 {
     ec_lock_t *lock = NULL;
     ec_inode_t *ctx;
@@ -987,8 +976,8 @@ void ec_lock_prepare_inode_internal(ec_fop_data_t *fop, loc_t *loc,
         if ((fop->lock_count > 0) && (fop->locks[0].lock == lock)) {
             /* Combine data/meta updates */
             fop->locks[0].update[EC_DATA_TXN] |= (flags & EC_UPDATE_DATA) != 0;
-            fop->locks[0].update[EC_METADATA_TXN] |=
-                                                 (flags & EC_UPDATE_META) != 0;
+            fop->locks[0].update[EC_METADATA_TXN] |= (flags & EC_UPDATE_META) !=
+                                                     0;
 
             /* Only one base inode is allowed per fop, so there shouldn't be
              * overwrites here. */
@@ -999,8 +988,10 @@ void ec_lock_prepare_inode_internal(ec_fop_data_t *fop, loc_t *loc,
             goto update_query;
         }
 
-        ec_trace("LOCK_INODELK", fop, "lock=%p, inode=%p. Lock already "
-                                      "acquired", lock, loc->inode);
+        ec_trace("LOCK_INODELK", fop,
+                 "lock=%p, inode=%p. Lock already "
+                 "acquired",
+                 lock, loc->inode);
 
         goto insert;
     }
@@ -1026,14 +1017,16 @@ unlock:
     UNLOCK(&loc->inode->lock);
 }
 
-void ec_lock_prepare_inode(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
-                           off_t fl_start, size_t fl_size)
+void
+ec_lock_prepare_inode(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
+                      off_t fl_start, size_t fl_size)
 {
     ec_lock_prepare_inode_internal(fop, loc, flags, NULL, fl_start, fl_size);
 }
 
-void ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
-                                  uint32_t flags)
+void
+ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
+                             uint32_t flags)
 {
     loc_t tmp;
     int32_t err;
@@ -1052,7 +1045,7 @@ void ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
     if ((flags & EC_INODE_SIZE) != 0) {
         flags ^= EC_INODE_SIZE;
     } else {
-            base = NULL;
+        base = NULL;
     }
 
     ec_lock_prepare_inode_internal(fop, &tmp, flags, base, 0, LLONG_MAX);
@@ -1060,8 +1053,9 @@ void ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
     loc_wipe(&tmp);
 }
 
-void ec_lock_prepare_fd(ec_fop_data_t *fop, fd_t *fd, uint32_t flags,
-                        off_t fl_start, size_t fl_size)
+void
+ec_lock_prepare_fd(ec_fop_data_t *fop, fd_t *fd, uint32_t flags, off_t fl_start,
+                   size_t fl_size)
 {
     loc_t loc;
     int32_t err;
@@ -1083,15 +1077,14 @@ void ec_lock_prepare_fd(ec_fop_data_t *fop, fd_t *fd, uint32_t flags,
 }
 
 gf_boolean_t
-ec_config_check (xlator_t *xl, ec_config_t *config)
+ec_config_check(xlator_t *xl, ec_config_t *config)
 {
     ec_t *ec;
 
     ec = xl->private;
     if ((config->version != EC_CONFIG_VERSION) ||
         (config->algorithm != EC_CONFIG_ALGORITHM) ||
-        (config->gf_word_size != EC_GF_BITS) ||
-        (config->bricks != ec->nodes) ||
+        (config->gf_word_size != EC_GF_BITS) || (config->bricks != ec->nodes) ||
         (config->redundancy != ec->redundancy) ||
         (config->chunk_size != EC_METHOD_CHUNK_SIZE)) {
         uint32_t data_bricks;
@@ -1110,20 +1103,17 @@ ec_config_check (xlator_t *xl, ec_config_t *config)
         if ((config->redundancy < 1) ||
             (config->redundancy * 2 >= config->bricks) ||
             !ec_is_power_of_2(config->gf_word_size) ||
-            ((config->chunk_size * 8) % (config->gf_word_size * data_bricks)
-                                                                       != 0)) {
-            gf_msg (xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_INVALID_CONFIG,
-                    "Invalid or corrupted config");
+            ((config->chunk_size * 8) % (config->gf_word_size * data_bricks) !=
+             0)) {
+            gf_msg(xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_CONFIG,
+                   "Invalid or corrupted config");
         } else {
-            gf_msg (xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_INVALID_CONFIG,
-                    "Unsupported config "
-                    "(V=%u, A=%u, W=%u, "
-                    "N=%u, R=%u, S=%u)",
-                   config->version, config->algorithm,
-                   config->gf_word_size, config->bricks,
-                   config->redundancy, config->chunk_size);
+            gf_msg(xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_CONFIG,
+                   "Unsupported config "
+                   "(V=%u, A=%u, W=%u, "
+                   "N=%u, R=%u, S=%u)",
+                   config->version, config->algorithm, config->gf_word_size,
+                   config->bricks, config->redundancy, config->chunk_size);
         }
 
         return _gf_false;
@@ -1133,20 +1123,18 @@ ec_config_check (xlator_t *xl, ec_config_t *config)
 }
 
 gf_boolean_t
-ec_set_dirty_flag (ec_lock_link_t *link, ec_inode_t *ctx,
-                   uint64_t *dirty)
+ec_set_dirty_flag(ec_lock_link_t *link, ec_inode_t *ctx, uint64_t *dirty)
 {
-
     gf_boolean_t set_dirty = _gf_false;
 
     if (link->update[EC_DATA_TXN] && !ctx->dirty[EC_DATA_TXN]) {
-            if (!link->optimistic_changelog)
-                dirty[EC_DATA_TXN] = 1;
+        if (!link->optimistic_changelog)
+            dirty[EC_DATA_TXN] = 1;
     }
 
     if (link->update[EC_METADATA_TXN] && !ctx->dirty[EC_METADATA_TXN]) {
-            if (!link->optimistic_changelog)
-                dirty[EC_METADATA_TXN] = 1;
+        if (!link->optimistic_changelog)
+            dirty[EC_METADATA_TXN] = 1;
     }
 
     if (dirty[EC_METADATA_TXN] || dirty[EC_DATA_TXN]) {
@@ -1157,9 +1145,9 @@ ec_set_dirty_flag (ec_lock_link_t *link, ec_inode_t *ctx,
 }
 
 int32_t
-ec_prepare_update_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno,
-                       dict_t *dict, dict_t *xdata)
+ec_prepare_update_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
     struct list_head list;
     ec_fop_data_t *fop = cookie, *parent, *tmp;
@@ -1179,95 +1167,87 @@ ec_prepare_update_cbk (call_frame_t *frame, void *cookie,
 
     LOCK(&lock->loc.inode->lock);
 
-    list_for_each_entry(link, &lock->owners, owner_list) {
+    list_for_each_entry(link, &lock->owners, owner_list)
+    {
         if ((link->waiting_flags & provided_flags) != 0) {
             link->waiting_flags ^= (link->waiting_flags & provided_flags);
             if (EC_NEEDED_FLAGS(link->waiting_flags) == 0)
-                    list_add_tail(&link->fop->cbk_list, &list);
+                list_add_tail(&link->fop->cbk_list, &list);
         }
     }
     if (op_ret < 0) {
-        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                EC_MSG_SIZE_VERS_GET_FAIL,
-                "Failed to get size and version :  %s",
-                ec_msg_str(fop));
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, EC_MSG_SIZE_VERS_GET_FAIL,
+               "Failed to get size and version :  %s", ec_msg_str(fop));
 
         goto unlock;
     }
 
     if (EC_FLAGS_HAVE(provided_flags, EC_FLAG_XATTROP)) {
-            op_errno = -ec_dict_del_array(dict, EC_XATTR_VERSION,
-                                          ctx->pre_version,
-                                          EC_VERSION_SIZE);
+        op_errno = -ec_dict_del_array(dict, EC_XATTR_VERSION, ctx->pre_version,
+                                      EC_VERSION_SIZE);
+        if (op_errno != 0) {
+            gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                   EC_MSG_VER_XATTR_GET_FAIL, "Unable to get version xattr. %s",
+                   ec_msg_str(fop));
+            goto unlock;
+        }
+        ctx->post_version[0] += ctx->pre_version[0];
+        ctx->post_version[1] += ctx->pre_version[1];
+
+        ctx->have_version = _gf_true;
+
+        if (lock->loc.inode->ia_type == IA_IFREG ||
+            lock->loc.inode->ia_type == IA_INVAL) {
+            op_errno = -ec_dict_del_number(dict, EC_XATTR_SIZE, &ctx->pre_size);
             if (op_errno != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                        EC_MSG_VER_XATTR_GET_FAIL,
-                        "Unable to get version xattr. %s",
-                        ec_msg_str(fop));
-                goto unlock;
+                if (lock->loc.inode->ia_type == IA_IFREG) {
+                    gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                           EC_MSG_SIZE_XATTR_GET_FAIL,
+                           "Unable to get size xattr. %s", ec_msg_str(fop));
+                    goto unlock;
+                }
+            } else {
+                ctx->post_size = ctx->pre_size;
+
+                ctx->have_size = _gf_true;
             }
-            ctx->post_version[0] += ctx->pre_version[0];
-            ctx->post_version[1] += ctx->pre_version[1];
 
-            ctx->have_version = _gf_true;
+            op_errno = -ec_dict_del_config(dict, EC_XATTR_CONFIG, &ctx->config);
+            if (op_errno != 0) {
+                if ((lock->loc.inode->ia_type == IA_IFREG) ||
+                    (op_errno != ENODATA)) {
+                    gf_msg(this->name, GF_LOG_ERROR, op_errno,
+                           EC_MSG_CONFIG_XATTR_GET_FAIL,
+                           "Unable to get config xattr. %s", ec_msg_str(fop));
 
-            if (lock->loc.inode->ia_type == IA_IFREG ||
-                lock->loc.inode->ia_type == IA_INVAL) {
-                op_errno = -ec_dict_del_number(dict, EC_XATTR_SIZE,
-                                               &ctx->pre_size);
-                if (op_errno != 0) {
-                    if (lock->loc.inode->ia_type == IA_IFREG) {
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                EC_MSG_SIZE_XATTR_GET_FAIL,
-                                "Unable to get size xattr. %s",
-                                ec_msg_str(fop));
-                        goto unlock;
-                    }
-                } else {
-                    ctx->post_size = ctx->pre_size;
-
-                    ctx->have_size = _gf_true;
+                    goto unlock;
                 }
+            } else {
+                if (!ec_config_check(parent->xl, &ctx->config)) {
+                    gf_msg(this->name, GF_LOG_ERROR, EINVAL,
+                           EC_MSG_CONFIG_XATTR_INVALID, "Invalid config xattr");
 
-                op_errno = -ec_dict_del_config(dict, EC_XATTR_CONFIG,
-                                               &ctx->config);
-                if (op_errno != 0) {
-                    if ((lock->loc.inode->ia_type == IA_IFREG) ||
-                        (op_errno != ENODATA)) {
-                        gf_msg (this->name, GF_LOG_ERROR, op_errno,
-                                EC_MSG_CONFIG_XATTR_GET_FAIL,
-                                "Unable to get config xattr. %s",
-                                ec_msg_str(fop));
-
-                        goto unlock;
-                    }
-                } else {
-                    if (!ec_config_check(parent->xl, &ctx->config)) {
-                        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                                EC_MSG_CONFIG_XATTR_INVALID,
-                                "Invalid config xattr");
-
-                        op_errno = EINVAL;
-
-                        goto unlock;
-                    }
-                    ctx->have_config = _gf_true;
+                    op_errno = EINVAL;
+
+                    goto unlock;
                 }
+                ctx->have_config = _gf_true;
             }
-            ctx->have_info = _gf_true;
+        }
+        ctx->have_info = _gf_true;
     }
 
-    ec_set_dirty_flag (fop->data, ctx, dirty);
+    ec_set_dirty_flag(fop->data, ctx, dirty);
     if (dirty[EC_METADATA_TXN] &&
         (EC_FLAGS_HAVE(provided_flags, EC_FLAG_METADATA_DIRTY))) {
-            GF_ASSERT (!ctx->dirty[EC_METADATA_TXN]);
-            ctx->dirty[EC_METADATA_TXN] = 1;
+        GF_ASSERT(!ctx->dirty[EC_METADATA_TXN]);
+        ctx->dirty[EC_METADATA_TXN] = 1;
     }
 
     if (dirty[EC_DATA_TXN] &&
         (EC_FLAGS_HAVE(provided_flags, EC_FLAG_DATA_DIRTY))) {
-            GF_ASSERT (!ctx->dirty[EC_DATA_TXN]);
-            ctx->dirty[EC_DATA_TXN] = 1;
+        GF_ASSERT(!ctx->dirty[EC_DATA_TXN]);
+        ctx->dirty[EC_DATA_TXN] = 1;
     }
     op_errno = 0;
 unlock:
@@ -1279,20 +1259,20 @@ unlock:
          * it dirty and update versions right away if dirty was not set before.
          */
         if (lock->good_mask & ~(fop->good | fop->remaining)) {
-                release = _gf_true;
+            release = _gf_true;
         }
 
         if (parent_link->update[0] && !parent_link->dirty[0]) {
-                lock->release |= release;
+            lock->release |= release;
         }
 
         if (parent_link->update[1] && !parent_link->dirty[1]) {
-                lock->release |= release;
+            lock->release |= release;
         }
 
         /* We don't allow the main fop to be executed on bricks that have not
          * succeeded the initial xattrop. */
-        ec_lock_update_good (lock, fop);
+        ec_lock_update_good(lock, fop);
 
         /*As of now only data healing marks bricks as healing*/
         lock->healing |= fop->healing;
@@ -1308,7 +1288,7 @@ unlock:
             tmp->mask &= fop->good;
 
             /*As of now only data healing marks bricks as healing*/
-            if (ec_is_data_fop (tmp->id)) {
+            if (ec_is_data_fop(tmp->id)) {
                 tmp->healing |= fop->healing;
             }
         }
@@ -1322,52 +1302,53 @@ unlock:
 static gf_boolean_t
 ec_set_needed_flag(ec_lock_t *lock, ec_lock_link_t *link, uint64_t flag)
 {
-        uint64_t current;
+    uint64_t current;
 
-        link->waiting_flags |= EC_FLAG_NEEDS(flag);
+    link->waiting_flags |= EC_FLAG_NEEDS(flag);
 
-        current = EC_NEEDED_FLAGS(lock->waiting_flags);
-        if (!EC_FLAGS_HAVE(current, flag)) {
-                lock->waiting_flags |= EC_FLAG_NEEDS(flag);
-                link->waiting_flags |= EC_FLAG_PROVIDES(flag);
+    current = EC_NEEDED_FLAGS(lock->waiting_flags);
+    if (!EC_FLAGS_HAVE(current, flag)) {
+        lock->waiting_flags |= EC_FLAG_NEEDS(flag);
+        link->waiting_flags |= EC_FLAG_PROVIDES(flag);
 
-                return _gf_true;
-        }
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static uint64_t
-ec_set_xattrop_flags_and_params (ec_lock_t *lock, ec_lock_link_t *link,
-                                 uint64_t *dirty)
+ec_set_xattrop_flags_and_params(ec_lock_t *lock, ec_lock_link_t *link,
+                                uint64_t *dirty)
 {
-        uint64_t        oldflags = 0;
-        uint64_t        newflags = 0;
-        ec_inode_t *ctx     = lock->ctx;
+    uint64_t oldflags = 0;
+    uint64_t newflags = 0;
+    ec_inode_t *ctx = lock->ctx;
 
-        oldflags = EC_NEEDED_FLAGS(lock->waiting_flags);
+    oldflags = EC_NEEDED_FLAGS(lock->waiting_flags);
 
-        if (lock->query && !ctx->have_info) {
-                ec_set_needed_flag(lock, link, EC_FLAG_XATTROP);
-        }
+    if (lock->query && !ctx->have_info) {
+        ec_set_needed_flag(lock, link, EC_FLAG_XATTROP);
+    }
 
-        if (dirty[EC_DATA_TXN]) {
-                if (!ec_set_needed_flag(lock, link, EC_FLAG_DATA_DIRTY)) {
-                        dirty[EC_DATA_TXN] = 0;
-                }
+    if (dirty[EC_DATA_TXN]) {
+        if (!ec_set_needed_flag(lock, link, EC_FLAG_DATA_DIRTY)) {
+            dirty[EC_DATA_TXN] = 0;
         }
+    }
 
-        if (dirty[EC_METADATA_TXN]) {
-                if (!ec_set_needed_flag(lock, link, EC_FLAG_METADATA_DIRTY)) {
-                        dirty[EC_METADATA_TXN] = 0;
-                }
+    if (dirty[EC_METADATA_TXN]) {
+        if (!ec_set_needed_flag(lock, link, EC_FLAG_METADATA_DIRTY)) {
+            dirty[EC_METADATA_TXN] = 0;
         }
-        newflags = EC_NEEDED_FLAGS(lock->waiting_flags);
+    }
+    newflags = EC_NEEDED_FLAGS(lock->waiting_flags);
 
-        return oldflags ^ newflags;
+    return oldflags ^ newflags;
 }
 
-void ec_get_size_version(ec_lock_link_t *link)
+void
+ec_get_size_version(ec_lock_link_t *link)
 {
     loc_t loc;
     ec_lock_t *lock;
@@ -1375,7 +1356,7 @@ void ec_get_size_version(ec_lock_link_t *link)
     ec_fop_data_t *fop;
     dict_t *dict = NULL;
     dict_t *xdata = NULL;
-    ec_t   *ec = NULL;
+    ec_t *ec = NULL;
     int32_t error = 0;
     gf_boolean_t set_dirty = _gf_false;
     uint64_t allzero[EC_VERSION_SIZE] = {0, 0};
@@ -1383,18 +1364,18 @@ void ec_get_size_version(ec_lock_link_t *link)
     lock = link->lock;
     ctx = lock->ctx;
     fop = link->fop;
-    ec  = fop->xl->private;
+    ec = fop->xl->private;
     uint64_t changed_flags = 0;
 
-    if (ec->optimistic_changelog &&
-        !(ec->node_mask & ~link->lock->good_mask) && !ec_is_data_fop (fop->id))
-            link->optimistic_changelog = _gf_true;
+    if (ec->optimistic_changelog && !(ec->node_mask & ~link->lock->good_mask) &&
+        !ec_is_data_fop(fop->id))
+        link->optimistic_changelog = _gf_true;
 
-    set_dirty = ec_set_dirty_flag (link, ctx, dirty);
+    set_dirty = ec_set_dirty_flag(link, ctx, dirty);
 
     /* If ec metadata has already been retrieved, do not try again. */
     if (ctx->have_info && (!set_dirty)) {
-        if (ec_is_data_fop (fop->id)) {
+        if (ec_is_data_fop(fop->id)) {
             fop->healing |= lock->healing;
         }
         return;
@@ -1402,24 +1383,23 @@ void ec_get_size_version(ec_lock_link_t *link)
 
     /* Determine if there's something we need to retrieve for the current
      * operation. */
-    if (!set_dirty && !lock->query &&
-        (lock->loc.inode->ia_type != IA_IFREG) &&
+    if (!set_dirty && !lock->query && (lock->loc.inode->ia_type != IA_IFREG) &&
         (lock->loc.inode->ia_type != IA_INVAL)) {
-            return;
+        return;
     }
 
     memset(&loc, 0, sizeof(loc));
 
     LOCK(&lock->loc.inode->lock);
 
-    changed_flags = ec_set_xattrop_flags_and_params (lock, link, dirty);
+    changed_flags = ec_set_xattrop_flags_and_params(lock, link, dirty);
     if (link->waiting_flags) {
-            /* This fop needs to wait until all its flags are cleared which
-             * potentially can be cleared by other xattrops that are already
-             * wound*/
-            ec_sleep(fop);
+        /* This fop needs to wait until all its flags are cleared which
+         * potentially can be cleared by other xattrops that are already
+         * wound*/
+        ec_sleep(fop);
     } else {
-            GF_ASSERT (!changed_flags);
+        GF_ASSERT(!changed_flags);
     }
 
     UNLOCK(&lock->loc.inode->lock);
@@ -1434,40 +1414,38 @@ void ec_get_size_version(ec_lock_link_t *link)
     }
 
     if (EC_FLAGS_HAVE(changed_flags, EC_FLAG_XATTROP)) {
-            /* Once we know that an xattrop will be needed,
-             * we try to get all available information in a
-             * single call. */
-            error = ec_dict_set_array(dict, EC_XATTR_VERSION, allzero,
-                                      EC_VERSION_SIZE);
+        /* Once we know that an xattrop will be needed,
+         * we try to get all available information in a
+         * single call. */
+        error = ec_dict_set_array(dict, EC_XATTR_VERSION, allzero,
+                                  EC_VERSION_SIZE);
+        if (error != 0) {
+            goto out;
+        }
+
+        if (lock->loc.inode->ia_type == IA_IFREG ||
+            lock->loc.inode->ia_type == IA_INVAL) {
+            error = ec_dict_set_number(dict, EC_XATTR_SIZE, 0);
+            if (error == 0) {
+                error = ec_dict_set_number(dict, EC_XATTR_CONFIG, 0);
+            }
             if (error != 0) {
                 goto out;
             }
 
-            if (lock->loc.inode->ia_type == IA_IFREG ||
-                lock->loc.inode->ia_type == IA_INVAL) {
-                error = ec_dict_set_number(dict, EC_XATTR_SIZE, 0);
-                if (error == 0) {
-                    error = ec_dict_set_number(dict, EC_XATTR_CONFIG, 0);
-                }
-                if (error != 0) {
-                    goto out;
-                }
-
-                xdata = dict_new();
-                if (xdata == NULL || dict_set_int32 (xdata, GF_GET_SIZE, 1)) {
-                    error = -ENOMEM;
-                    goto out;
-                }
-
+            xdata = dict_new();
+            if (xdata == NULL || dict_set_int32(xdata, GF_GET_SIZE, 1)) {
+                error = -ENOMEM;
+                goto out;
             }
+        }
     }
 
-    if (memcmp (allzero, dirty, sizeof (allzero))) {
-            error = ec_dict_set_array(dict, EC_XATTR_DIRTY, dirty,
-                                      EC_VERSION_SIZE);
-            if (error != 0) {
-                goto out;
-            }
+    if (memcmp(allzero, dirty, sizeof(allzero))) {
+        error = ec_dict_set_array(dict, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
+        if (error != 0) {
+            goto out;
+        }
     }
 
     fop->frame->root->uid = 0;
@@ -1495,13 +1473,13 @@ void ec_get_size_version(ec_lock_link_t *link)
             loc.name = NULL;
         }
 
-        ec_xattrop (fop->frame, fop->xl, fop->mask, fop->minimum,
-                    ec_prepare_update_cbk, link, &loc,
-                    GF_XATTROP_ADD_ARRAY64, dict, xdata);
+        ec_xattrop(fop->frame, fop->xl, fop->mask, fop->minimum,
+                   ec_prepare_update_cbk, link, &loc, GF_XATTROP_ADD_ARRAY64,
+                   dict, xdata);
     } else {
         ec_fxattrop(fop->frame, fop->xl, fop->mask, fop->minimum,
-                ec_prepare_update_cbk, link, lock->fd,
-                GF_XATTROP_ADD_ARRAY64, dict, xdata);
+                    ec_prepare_update_cbk, link, lock->fd,
+                    GF_XATTROP_ADD_ARRAY64, dict, xdata);
     }
 
     error = 0;
@@ -1526,8 +1504,7 @@ out:
 }
 
 gf_boolean_t
-__ec_get_inode_size(ec_fop_data_t *fop, inode_t *inode,
-                    uint64_t *size)
+__ec_get_inode_size(ec_fop_data_t *fop, inode_t *inode, uint64_t *size)
 {
     ec_inode_t *ctx;
     gf_boolean_t found = _gf_false;
@@ -1547,14 +1524,13 @@ out:
 }
 
 gf_boolean_t
-ec_get_inode_size(ec_fop_data_t *fop, inode_t *inode,
-                  uint64_t *size)
+ec_get_inode_size(ec_fop_data_t *fop, inode_t *inode, uint64_t *size)
 {
     gf_boolean_t found = _gf_false;
 
     LOCK(&inode->lock);
     {
-            found = __ec_get_inode_size (fop, inode, size);
+        found = __ec_get_inode_size(fop, inode, size);
     }
     UNLOCK(&inode->lock);
 
@@ -1562,8 +1538,7 @@ ec_get_inode_size(ec_fop_data_t *fop, inode_t *inode,
 }
 
 gf_boolean_t
-__ec_set_inode_size(ec_fop_data_t *fop, inode_t *inode,
-                    uint64_t size)
+__ec_set_inode_size(ec_fop_data_t *fop, inode_t *inode, uint64_t size)
 {
     ec_inode_t *ctx;
     gf_boolean_t found = _gf_false;
@@ -1590,38 +1565,37 @@ out:
 }
 
 gf_boolean_t
-ec_set_inode_size(ec_fop_data_t *fop, inode_t *inode,
-                  uint64_t size)
+ec_set_inode_size(ec_fop_data_t *fop, inode_t *inode, uint64_t size)
 {
     gf_boolean_t found = _gf_false;
 
-    LOCK (&inode->lock);
+    LOCK(&inode->lock);
     {
-            found = __ec_set_inode_size (fop, inode, size);
+        found = __ec_set_inode_size(fop, inode, size);
     }
-    UNLOCK (&inode->lock);
+    UNLOCK(&inode->lock);
 
     return found;
 }
 
 static void
-ec_release_stripe_cache (ec_inode_t *ctx)
+ec_release_stripe_cache(ec_inode_t *ctx)
 {
-        ec_stripe_list_t *stripe_cache = NULL;
-        ec_stripe_t      *stripe = NULL;
+    ec_stripe_list_t *stripe_cache = NULL;
+    ec_stripe_t *stripe = NULL;
 
-        stripe_cache = &ctx->stripe_cache;
-        while (!list_empty (&stripe_cache->lru)) {
-                stripe = list_first_entry (&stripe_cache->lru, ec_stripe_t,
-                                           lru);
-                list_del (&stripe->lru);
-                GF_FREE (stripe);
-        }
-        stripe_cache->count = 0;
-        stripe_cache->max = 0;
+    stripe_cache = &ctx->stripe_cache;
+    while (!list_empty(&stripe_cache->lru)) {
+        stripe = list_first_entry(&stripe_cache->lru, ec_stripe_t, lru);
+        list_del(&stripe->lru);
+        GF_FREE(stripe);
+    }
+    stripe_cache->count = 0;
+    stripe_cache->max = 0;
 }
 
-void ec_clear_inode_info(ec_fop_data_t *fop, inode_t *inode)
+void
+ec_clear_inode_info(ec_fop_data_t *fop, inode_t *inode)
 {
     ec_inode_t *ctx;
 
@@ -1632,7 +1606,7 @@ void ec_clear_inode_info(ec_fop_data_t *fop, inode_t *inode)
         goto unlock;
     }
 
-    ec_release_stripe_cache (ctx);
+    ec_release_stripe_cache(ctx);
     ctx->have_info = _gf_false;
     ctx->have_config = _gf_false;
     ctx->have_version = _gf_false;
@@ -1648,10 +1622,10 @@ unlock:
     UNLOCK(&inode->lock);
 }
 
-int32_t ec_get_real_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, inode_t *inode,
-                             struct iatt *buf, dict_t *xdata,
-                             struct iatt *postparent)
+int32_t
+ec_get_real_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, inode_t *inode,
+                     struct iatt *buf, dict_t *xdata, struct iatt *postparent)
 {
     ec_fop_data_t *fop = cookie;
     ec_lock_link_t *link;
@@ -1675,7 +1649,8 @@ int32_t ec_get_real_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
  * Any error processing this request is ignored. In the worst case, an invalid
  * or not up to date value in the iatt could cause some cache invalidation.
  */
-void ec_get_real_size(ec_lock_link_t *link)
+void
+ec_get_real_size(ec_lock_link_t *link)
 {
     ec_fop_data_t *fop;
     dict_t *xdata;
@@ -1725,24 +1700,26 @@ ec_lock_update_fd(ec_lock_t *lock, ec_fop_data_t *fop)
 }
 
 static gf_boolean_t
-ec_link_has_lock_conflict (ec_lock_link_t *link, gf_boolean_t waitlist_check)
+ec_link_has_lock_conflict(ec_lock_link_t *link, gf_boolean_t waitlist_check)
 {
-        ec_lock_link_t *trav_link = NULL;
+    ec_lock_link_t *trav_link = NULL;
 
-        list_for_each_entry (trav_link, &link->lock->owners, owner_list) {
-                if (ec_lock_conflict (trav_link, link))
-                        return _gf_true;
-        }
+    list_for_each_entry(trav_link, &link->lock->owners, owner_list)
+    {
+        if (ec_lock_conflict(trav_link, link))
+            return _gf_true;
+    }
 
-        if (!waitlist_check)
-                return _gf_false;
+    if (!waitlist_check)
+        return _gf_false;
 
-        list_for_each_entry (trav_link, &link->lock->waiting, wait_list) {
-                if (ec_lock_conflict (trav_link, link))
-                        return _gf_true;
-        }
+    list_for_each_entry(trav_link, &link->lock->waiting, wait_list)
+    {
+        if (ec_lock_conflict(trav_link, link))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static void
@@ -1763,7 +1740,7 @@ ec_lock_wake_shared(ec_lock_t *lock, struct list_head *list)
 
         /* If the fop is not shareable, only this fop can be assigned as owner.
          * Other fops will need to wait until this one finishes. */
-        if (ec_link_has_lock_conflict (link, _gf_false)) {
+        if (ec_link_has_lock_conflict(link, _gf_false)) {
             conflict = _gf_true;
         }
 
@@ -1794,7 +1771,8 @@ ec_lock_apply(ec_lock_link_t *link)
     ec_get_real_size(link);
 }
 
-gf_boolean_t ec_lock_acquire(ec_lock_link_t *link);
+gf_boolean_t
+ec_lock_acquire(ec_lock_link_t *link);
 
 static void
 ec_lock_resume_shared(struct list_head *list)
@@ -1818,7 +1796,8 @@ ec_lock_resume_shared(struct list_head *list)
     }
 }
 
-void ec_lock_acquired(ec_lock_link_t *link)
+void
+ec_lock_acquired(ec_lock_link_t *link)
 {
     struct list_head list;
     ec_lock_t *lock;
@@ -1850,8 +1829,9 @@ void ec_lock_acquired(ec_lock_link_t *link)
     ec_lock_resume_shared(&list);
 }
 
-int32_t ec_locked(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+int32_t
+ec_locked(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+          int32_t op_errno, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     ec_lock_link_t *link = NULL;
@@ -1866,15 +1846,15 @@ int32_t ec_locked(call_frame_t *frame, void *cookie, xlator_t *this,
         ec_lock_acquired(link);
         ec_lock(fop->parent);
     } else {
-        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                EC_MSG_PREOP_LOCK_FAILED,
-                "Failed to complete preop lock");
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, EC_MSG_PREOP_LOCK_FAILED,
+               "Failed to complete preop lock");
     }
 
     return 0;
 }
 
-gf_boolean_t ec_lock_acquire(ec_lock_link_t *link)
+gf_boolean_t
+ec_lock_acquire(ec_lock_link_t *link)
 {
     ec_lock_t *lock;
     ec_fop_data_t *fop;
@@ -1907,62 +1887,62 @@ gf_boolean_t ec_lock_acquire(ec_lock_link_t *link)
 static ec_lock_link_t *
 ec_lock_timer_cancel(xlator_t *xl, ec_lock_t *lock)
 {
-        ec_lock_link_t *timer_link;
+    ec_lock_link_t *timer_link;
 
-        /* If we don't have any timer, there's nothing to cancel. */
-        if (lock->timer == NULL) {
-                return NULL;
-        }
+    /* If we don't have any timer, there's nothing to cancel. */
+    if (lock->timer == NULL) {
+        return NULL;
+    }
 
-        /* We are trying to access a lock that has an unlock timer active.
-         * This means that the lock must be idle, i.e. no fop can be in the
-         * owner, waiting or frozen lists. It also means that the lock cannot
-         * have been marked as being released (this is done without timers).
-         * There should only be one owner reference, but it's possible that
-         * some fops are being prepared to use this lock. */
-        GF_ASSERT ((lock->refs_owners == 1) &&
-                   list_empty(&lock->owners) && list_empty(&lock->waiting));
-
-        /* We take the timer_link before cancelling the timer, since a
-         * successful cancellation will destroy it. It must not be NULL
-         * because it references the fop responsible for the delayed unlock
-         * that we are currently trying to cancel. */
-        timer_link = lock->timer->data;
-        GF_ASSERT(timer_link != NULL);
-
-        if (gf_timer_call_cancel(xl->ctx, lock->timer) < 0) {
-                /* It's too late to avoid the execution of the timer callback.
-                 * Since we need to be sure that the callback has access to all
-                 * needed resources, we cannot resume the execution of the
-                 * timer fop now. This will be done in the callback. */
-                timer_link = NULL;
-        } else {
-                /* The timer has been cancelled. The fop referenced by
-                 * timer_link holds the last reference. The caller is
-                 * responsible to release it when not needed anymore. */
-                ec_trace("UNLOCK_CANCELLED", timer_link->fop, "lock=%p", lock);
-        }
+    /* We are trying to access a lock that has an unlock timer active.
+     * This means that the lock must be idle, i.e. no fop can be in the
+     * owner, waiting or frozen lists. It also means that the lock cannot
+     * have been marked as being released (this is done without timers).
+     * There should only be one owner reference, but it's possible that
+     * some fops are being prepared to use this lock. */
+    GF_ASSERT((lock->refs_owners == 1) && list_empty(&lock->owners) &&
+              list_empty(&lock->waiting));
+
+    /* We take the timer_link before cancelling the timer, since a
+     * successful cancellation will destroy it. It must not be NULL
+     * because it references the fop responsible for the delayed unlock
+     * that we are currently trying to cancel. */
+    timer_link = lock->timer->data;
+    GF_ASSERT(timer_link != NULL);
+
+    if (gf_timer_call_cancel(xl->ctx, lock->timer) < 0) {
+        /* It's too late to avoid the execution of the timer callback.
+         * Since we need to be sure that the callback has access to all
+         * needed resources, we cannot resume the execution of the
+         * timer fop now. This will be done in the callback. */
+        timer_link = NULL;
+    } else {
+        /* The timer has been cancelled. The fop referenced by
+         * timer_link holds the last reference. The caller is
+         * responsible to release it when not needed anymore. */
+        ec_trace("UNLOCK_CANCELLED", timer_link->fop, "lock=%p", lock);
+    }
 
-        /* We have two options here:
-         *
-         * 1. The timer has been successfully cancelled.
-         *
-         *    This is the easiest case and we can continue with the currently
-         *    acquired lock.
-         *
-         * 2. The timer callback has already been fired.
-         *
-         *    In this case we have not been able to cancel the timer before
-         *    the timer callback has been fired, but we also know that
-         *    lock->timer != NULL. This means that the timer callback is still
-         *    trying to acquire the inode mutex that we currently own. We are
-         *    safe until we release it. In this case we can safely clear
-         *    lock->timer. This will cause that the timer callback does nothing
-         *    once it acquires the mutex.
-         */
-        lock->timer = NULL;
+    /* We have two options here:
+     *
+     * 1. The timer has been successfully cancelled.
+     *
+     *    This is the easiest case and we can continue with the currently
+     *    acquired lock.
+     *
+     * 2. The timer callback has already been fired.
+     *
+     *    In this case we have not been able to cancel the timer before
+     *    the timer callback has been fired, but we also know that
+     *    lock->timer != NULL. This means that the timer callback is still
+     *    trying to acquire the inode mutex that we currently own. We are
+     *    safe until we release it. In this case we can safely clear
+     *    lock->timer. This will cause that the timer callback does nothing
+     *    once it acquires the mutex.
+     */
+    lock->timer = NULL;
 
-        return timer_link;
+    return timer_link;
 }
 
 static gf_boolean_t
@@ -1984,7 +1964,7 @@ ec_lock_assign_owner(ec_lock_link_t *link)
 
     /* Since the link has just been prepared but it's not active yet, the
      * refs_pending must be one at least (the ref owned by this link). */
-    GF_ASSERT (lock->refs_pending > 0);
+    GF_ASSERT(lock->refs_pending > 0);
     /* The link is not pending any more. It will be assigned to the owner,
      * waiting or frozen list. */
     lock->refs_pending--;
@@ -2017,7 +1997,7 @@ ec_lock_assign_owner(ec_lock_link_t *link)
          * owners, or waiters(to prevent starvation).
          * Otherwise we need to wait.
          */
-        if (!lock->acquired || ec_link_has_lock_conflict (link, _gf_true)) {
+        if (!lock->acquired || ec_link_has_lock_conflict(link, _gf_true)) {
             ec_trace("LOCK_QUEUE_WAIT", fop, "lock=%p", lock);
 
             list_add_tail(&link->wait_list, &lock->waiting);
@@ -2032,7 +2012,7 @@ ec_lock_assign_owner(ec_lock_link_t *link)
      * reference assigned to the timer fop. In this case we simply reuse it.
      * Otherwise we need to increase the number of owners. */
     if (timer_link == NULL) {
-            lock->refs_owners++;
+        lock->refs_owners++;
     }
 
     assigned = _gf_true;
@@ -2090,14 +2070,14 @@ ec_lock_next_owner(ec_lock_link_t *link, ec_cbk_data_t *cbk,
         /* If the fop fails on any of the good bricks, it is important to mark
          * it dirty and update versions right away. */
         if (link->update[0] || link->update[1]) {
-                if (lock->good_mask & ~(fop->good | fop->remaining)) {
-                        lock->release = _gf_true;
-                }
+            if (lock->good_mask & ~(fop->good | fop->remaining)) {
+                lock->release = _gf_true;
+            }
         }
     }
 
     if (fop->healing) {
-           lock->healing = fop->healing & (fop->good | fop->remaining);
+        lock->healing = fop->healing & (fop->good | fop->remaining);
     }
     ec_lock_update_good(lock, fop);
 
@@ -2108,7 +2088,8 @@ ec_lock_next_owner(ec_lock_link_t *link, ec_cbk_data_t *cbk,
     ec_lock_resume_shared(&list);
 }
 
-void ec_lock(ec_fop_data_t *fop)
+void
+ec_lock(ec_fop_data_t *fop)
 {
     ec_lock_link_t *link;
 
@@ -2116,7 +2097,7 @@ void ec_lock(ec_fop_data_t *fop)
      * Which can result in refs == 0 for fop leading to use after free in this
      * function when it calls ec_sleep so do ec_sleep at start and ec_resume at
      * the end of this function.*/
-    ec_sleep (fop);
+    ec_sleep(fop);
 
     while (fop->locked < fop->lock_count) {
         /* Since there are only up to 2 locks per fop, this xor will change
@@ -2186,17 +2167,16 @@ ec_lock_unfreeze(ec_lock_link_t *link)
     }
 }
 
-int32_t ec_unlocked(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+int32_t
+ec_unlocked(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     ec_lock_link_t *link = fop->data;
 
     if (op_ret < 0) {
-        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                EC_MSG_UNLOCK_FAILED,
-                "entry/inode unlocking failed (%s)",
-                ec_fop_name(link->fop->id));
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, EC_MSG_UNLOCK_FAILED,
+               "entry/inode unlocking failed (%s)", ec_fop_name(link->fop->id));
     } else {
         ec_trace("UNLOCKED", link->fop, "lock=%p", link->lock);
     }
@@ -2206,7 +2186,8 @@ int32_t ec_unlocked(call_frame_t *frame, void *cookie, xlator_t *this,
     return 0;
 }
 
-void ec_unlock_lock(ec_lock_link_t *link)
+void
+ec_unlock_lock(ec_lock_link_t *link)
 {
     ec_lock_t *lock;
     ec_fop_data_t *fop;
@@ -2232,10 +2213,10 @@ void ec_unlock_lock(ec_lock_link_t *link)
     }
 }
 
-int32_t ec_update_size_version_done(call_frame_t * frame, void * cookie,
-                                    xlator_t * this, int32_t op_ret,
-                                    int32_t op_errno, dict_t * xattr,
-                                    dict_t * xdata)
+int32_t
+ec_update_size_version_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                            dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     ec_lock_link_t *link;
@@ -2247,10 +2228,9 @@ int32_t ec_update_size_version_done(call_frame_t * frame, void * cookie,
     ctx = lock->ctx;
 
     if (op_ret < 0) {
-        gf_msg(fop->xl->name, fop_log_level (fop->id, op_errno), op_errno,
+        gf_msg(fop->xl->name, fop_log_level(fop->id, op_errno), op_errno,
                EC_MSG_SIZE_VERS_UPDATE_FAIL,
-               "Failed to update version and size. %s",
-                ec_msg_str(fop));
+               "Failed to update version and size. %s", ec_msg_str(fop));
     } else {
         fop->parent->good &= fop->good;
 
@@ -2287,14 +2267,14 @@ int32_t ec_update_size_version_done(call_frame_t * frame, void * cookie,
 }
 
 void
-ec_update_size_version(ec_lock_link_t *link, uint64_t *version,
-                       uint64_t size, uint64_t *dirty)
+ec_update_size_version(ec_lock_link_t *link, uint64_t *version, uint64_t size,
+                       uint64_t *dirty)
 {
     ec_fop_data_t *fop;
     ec_lock_t *lock;
     ec_inode_t *ctx;
     dict_t *dict = NULL;
-    uintptr_t   update_on = 0;
+    uintptr_t update_on = 0;
     int32_t err = -ENOMEM;
 
     fop = link->fop;
@@ -2331,11 +2311,10 @@ ec_update_size_version(ec_lock_link_t *link, uint64_t *version,
     }
 
     if (dirty[0] || dirty[1]) {
-            err = ec_dict_set_array(dict, EC_XATTR_DIRTY,
-                                    dirty, EC_VERSION_SIZE);
-            if (err != 0) {
-                goto out;
-            }
+        err = ec_dict_set_array(dict, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
+        if (err != 0) {
+            goto out;
+        }
     }
 
     /* If config information is not known, we request it now. */
@@ -2351,13 +2330,13 @@ ec_update_size_version(ec_lock_link_t *link, uint64_t *version,
     update_on = lock->good_mask | lock->healing;
 
     if (link->lock->fd == NULL) {
-            ec_xattrop(fop->frame, fop->xl, update_on, EC_MINIMUM_MIN,
-                       ec_update_size_version_done, link, &link->lock->loc,
-                       GF_XATTROP_ADD_ARRAY64, dict, NULL);
+        ec_xattrop(fop->frame, fop->xl, update_on, EC_MINIMUM_MIN,
+                   ec_update_size_version_done, link, &link->lock->loc,
+                   GF_XATTROP_ADD_ARRAY64, dict, NULL);
     } else {
-            ec_fxattrop(fop->frame, fop->xl, update_on, EC_MINIMUM_MIN,
-                       ec_update_size_version_done, link, link->lock->fd,
-                       GF_XATTROP_ADD_ARRAY64, dict, NULL);
+        ec_fxattrop(fop->frame, fop->xl, update_on, EC_MINIMUM_MIN,
+                    ec_update_size_version_done, link, link->lock->fd,
+                    GF_XATTROP_ADD_ARRAY64, dict, NULL);
     }
 
     fop->frame->root->uid = fop->uid;
@@ -2374,14 +2353,12 @@ out:
 
     ec_fop_set_error(fop, -err);
 
-    gf_msg (fop->xl->name, GF_LOG_ERROR, -err, EC_MSG_SIZE_VERS_UPDATE_FAIL,
-               "Unable to update version and size. %s",
-                ec_msg_str(fop));
+    gf_msg(fop->xl->name, GF_LOG_ERROR, -err, EC_MSG_SIZE_VERS_UPDATE_FAIL,
+           "Unable to update version and size. %s", ec_msg_str(fop));
 
     if (lock->unlock_now) {
         ec_unlock_lock(fop->data);
     }
-
 }
 
 gf_boolean_t
@@ -2406,34 +2383,34 @@ ec_update_info(ec_lock_link_t *link)
     /* If we set the dirty flag for update fop, we have to unset it.
      * If fop has failed on some bricks, leave the dirty as marked. */
     if (lock->unlock_now) {
-            /* Ensure that nodes are up while doing final
-             * metadata update.*/
-            if (!(ec->node_mask & ~lock->good_mask) &&
-                !(ec->node_mask & ~ec->xl_up)) {
-                    if (ctx->dirty[0] != 0) {
-                        dirty[0] = -1;
-                    }
-                    if (ctx->dirty[1] != 0) {
-                        dirty[1] = -1;
-                    }
-                    /*If everything is fine and we already
-                     *have version xattr set on entry, there
-                     *is no need to update version again*/
-                    if (ctx->pre_version[0]) {
-                        version[0] = 0;
-                    }
-                    if (ctx->pre_version[1]) {
-                        version[1] = 0;
-                    }
-            } else {
-                    link->optimistic_changelog = _gf_false;
-                    ec_set_dirty_flag (link, ctx, dirty);
+        /* Ensure that nodes are up while doing final
+         * metadata update.*/
+        if (!(ec->node_mask & ~lock->good_mask) &&
+            !(ec->node_mask & ~ec->xl_up)) {
+            if (ctx->dirty[0] != 0) {
+                dirty[0] = -1;
+            }
+            if (ctx->dirty[1] != 0) {
+                dirty[1] = -1;
             }
-            memset(ctx->dirty, 0, sizeof(ctx->dirty));
+            /*If everything is fine and we already
+             *have version xattr set on entry, there
+             *is no need to update version again*/
+            if (ctx->pre_version[0]) {
+                version[0] = 0;
+            }
+            if (ctx->pre_version[1]) {
+                version[1] = 0;
+            }
+        } else {
+            link->optimistic_changelog = _gf_false;
+            ec_set_dirty_flag(link, ctx, dirty);
+        }
+        memset(ctx->dirty, 0, sizeof(ctx->dirty));
     }
 
-    if ((version[0] != 0) || (version[1] != 0) ||
-        (dirty[0] != 0) || (dirty[1] != 0)) {
+    if ((version[0] != 0) || (version[1] != 0) || (dirty[0] != 0) ||
+        (dirty[1] != 0)) {
         ec_update_size_version(link, version, size, dirty);
         return _gf_true;
     }
@@ -2464,185 +2441,185 @@ ec_unlock_now(ec_lock_link_t *link)
 void
 ec_lock_release(ec_t *ec, inode_t *inode)
 {
-        ec_lock_t *lock;
-        ec_inode_t *ctx;
-        ec_lock_link_t *timer_link = NULL;
+    ec_lock_t *lock;
+    ec_inode_t *ctx;
+    ec_lock_link_t *timer_link = NULL;
 
-        LOCK(&inode->lock);
+    LOCK(&inode->lock);
 
-        ctx = __ec_inode_get(inode, ec->xl);
-        if (ctx == NULL) {
-                goto done;
-        }
-        lock = ctx->inode_lock;
-        if ((lock == NULL) || !lock->acquired || lock->release) {
-                goto done;
-        }
+    ctx = __ec_inode_get(inode, ec->xl);
+    if (ctx == NULL) {
+        goto done;
+    }
+    lock = ctx->inode_lock;
+    if ((lock == NULL) || !lock->acquired || lock->release) {
+        goto done;
+    }
 
-        gf_msg_debug(ec->xl->name, 0,
-                     "Releasing inode %p due to lock contention", inode);
+    gf_msg_debug(ec->xl->name, 0, "Releasing inode %p due to lock contention",
+                 inode);
 
-        /* The lock is not marked to be released, so the frozen list should be
-         * empty. */
-        GF_ASSERT(list_empty(&lock->frozen));
+    /* The lock is not marked to be released, so the frozen list should be
+     * empty. */
+    GF_ASSERT(list_empty(&lock->frozen));
 
-        timer_link = ec_lock_timer_cancel(ec->xl, lock);
+    timer_link = ec_lock_timer_cancel(ec->xl, lock);
 
-        /* We mark the lock to be released as soon as possible. */
-        lock->release = _gf_true;
+    /* We mark the lock to be released as soon as possible. */
+    lock->release = _gf_true;
 
 done:
-        UNLOCK(&inode->lock);
-
-        /* If we have cancelled the timer, we need to start the unlock of the
-         * inode. If there was a timer but we have been unable to cancel it
-         * because it was just triggered, the timer callback will take care
-         * of releasing the inode. */
-        if (timer_link != NULL) {
-                ec_unlock_now(timer_link);
-        }
+    UNLOCK(&inode->lock);
+
+    /* If we have cancelled the timer, we need to start the unlock of the
+     * inode. If there was a timer but we have been unable to cancel it
+     * because it was just triggered, the timer callback will take care
+     * of releasing the inode. */
+    if (timer_link != NULL) {
+        ec_unlock_now(timer_link);
+    }
 }
 
-void ec_unlock_timer_add(ec_lock_link_t *link);
+void
+ec_unlock_timer_add(ec_lock_link_t *link);
 
 void
 ec_unlock_timer_del(ec_lock_link_t *link)
 {
-        ec_lock_t *lock;
-        inode_t *inode;
-        gf_boolean_t now = _gf_false;
+    ec_lock_t *lock;
+    inode_t *inode;
+    gf_boolean_t now = _gf_false;
+
+    /* If we are here, it means that the timer has expired before having
+     * been cancelled. This guarantees that 'link' is still valid because
+     * the fop that contains it must be pending (if timer cancellation in
+     * ec_lock_assign_owner() fails, the fop is left sleeping).
+     *
+     * At the same time, the fop still has a reference to the lock, so
+     * it must also be valid.
+     */
+    lock = link->lock;
+
+    /* 'lock' must have a valid inode since it can only be destroyed
+     * when the lock itself is destroyed, but we have a reference to the
+     * lock to avoid this.
+     */
+    inode = lock->loc.inode;
+
+    LOCK(&inode->lock);
+
+    if (lock->timer != NULL) {
+        ec_trace("UNLOCK_DELAYED", link->fop, "lock=%p", lock);
+
+        /* The unlock timer has expired without anyone cancelling it.
+         * This means that it shouldn't have any owner, and the waiting
+         * and frozen lists should be empty.  It must have only one
+         * owner reference, but there can be fops being prepared
+         * though.
+         * */
+        GF_ASSERT(!lock->release && (lock->refs_owners == 1) &&
+                  list_empty(&lock->owners) && list_empty(&lock->waiting) &&
+                  list_empty(&lock->frozen));
+
+        gf_timer_call_cancel(link->fop->xl->ctx, lock->timer);
+        lock->timer = NULL;
+
+        /* Any fop being processed from now on, will need to wait
+         * until the next unlock/lock cycle. */
+        lock->release = now = _gf_true;
+    }
+
+    UNLOCK(&inode->lock);
 
-        /* If we are here, it means that the timer has expired before having
-         * been cancelled. This guarantees that 'link' is still valid because
-         * the fop that contains it must be pending (if timer cancellation in
-         * ec_lock_assign_owner() fails, the fop is left sleeping).
+    if (now) {
+        ec_unlock_now(link);
+    } else {
+        /* The timer has been cancelled just after firing it but before
+         * getting here. This means that another fop has used the lock
+         * and everything should be handled as if this callback were
+         * have not been executed. However we still have an owner
+         * reference.
+         *
+         * We need to release our reference. If this is not the last
+         * reference (the most common case because another fop has
+         * taken another ref) we only need to decrement the counter.
+         * Otherwise we have been delayed enough so that the other fop
+         * has had time to acquire the reference, do its operation and
+         * release it. At the time of releasing it, the fop did found
+         * that the ref counter was > 1 (our reference), so the delayed
+         * unlock timer wasn't started. We need to start it again if we
+         * are the last reference.
          *
-         * At the same time, the fop still has a reference to the lock, so
-         * it must also be valid.
+         * ec_unlock_timer_add() handles both cases.
          */
-        lock = link->lock;
+        ec_unlock_timer_add(link);
 
-        /* 'lock' must have a valid inode since it can only be destroyed
-         * when the lock itself is destroyed, but we have a reference to the
-         * lock to avoid this.
+        /* We need to resume the fop that was waiting for the delayed
+         * unlock.
          */
-        inode = lock->loc.inode;
-
-        LOCK(&inode->lock);
-
-        if (lock->timer != NULL) {
-                ec_trace("UNLOCK_DELAYED", link->fop, "lock=%p", lock);
-
-                /* The unlock timer has expired without anyone cancelling it.
-                 * This means that it shouldn't have any owner, and the waiting
-                 * and frozen lists should be empty.  It must have only one
-                 * owner reference, but there can be fops being prepared
-                 * though.
-                 * */
-                GF_ASSERT(!lock->release &&
-                          (lock->refs_owners == 1) &&
-                          list_empty(&lock->owners) &&
-                          list_empty(&lock->waiting) &&
-                          list_empty(&lock->frozen));
-
-                gf_timer_call_cancel(link->fop->xl->ctx, lock->timer);
-                lock->timer = NULL;
-
-                /* Any fop being processed from now on, will need to wait
-                 * until the next unlock/lock cycle. */
-                lock->release = now = _gf_true;
-        }
-
-        UNLOCK(&inode->lock);
-
-        if (now) {
-                ec_unlock_now(link);
-        } else {
-                /* The timer has been cancelled just after firing it but before
-                 * getting here. This means that another fop has used the lock
-                 * and everything should be handled as if this callback were
-                 * have not been executed. However we still have an owner
-                 * reference.
-                 *
-                 * We need to release our reference. If this is not the last
-                 * reference (the most common case because another fop has
-                 * taken another ref) we only need to decrement the counter.
-                 * Otherwise we have been delayed enough so that the other fop
-                 * has had time to acquire the reference, do its operation and
-                 * release it. At the time of releasing it, the fop did found
-                 * that the ref counter was > 1 (our reference), so the delayed
-                 * unlock timer wasn't started. We need to start it again if we
-                 * are the last reference.
-                 *
-                 * ec_unlock_timer_add() handles both cases.
-                 */
-                ec_unlock_timer_add(link);
-
-                /* We need to resume the fop that was waiting for the delayed
-                 * unlock.
-                 */
-                ec_resume(link->fop, 0);
-        }
+        ec_resume(link->fop, 0);
+    }
 }
 
-void ec_unlock_timer_cbk(void *data)
+void
+ec_unlock_timer_cbk(void *data)
 {
-        ec_unlock_timer_del(data);
+    ec_unlock_timer_del(data);
 }
 
 static gf_boolean_t
 ec_eager_lock_used(ec_t *ec, ec_fop_data_t *fop)
 {
-        /* Fops with no locks at this point mean that they are sent as sub-fops
-         * of other higher level fops. In this case we simply assume that the
-         * parent fop will take correct care of the eager lock. */
-        if (fop->lock_count == 0) {
-                return _gf_true;
-        }
+    /* Fops with no locks at this point mean that they are sent as sub-fops
+     * of other higher level fops. In this case we simply assume that the
+     * parent fop will take correct care of the eager lock. */
+    if (fop->lock_count == 0) {
+        return _gf_true;
+    }
 
-        /* We may have more than one lock, but this only happens in the rename
-         * fop, and both locks will reference an inode of the same type (a
-         * directory in this case), so we only need to check the first lock. */
-        if (fop->locks[0].lock->loc.inode->ia_type == IA_IFREG) {
-                return ec->eager_lock;
-        }
+    /* We may have more than one lock, but this only happens in the rename
+     * fop, and both locks will reference an inode of the same type (a
+     * directory in this case), so we only need to check the first lock. */
+    if (fop->locks[0].lock->loc.inode->ia_type == IA_IFREG) {
+        return ec->eager_lock;
+    }
 
-        return ec->other_eager_lock;
+    return ec->other_eager_lock;
 }
 
 static uint32_t
 ec_eager_lock_timeout(ec_t *ec, ec_lock_t *lock)
 {
-        if (lock->loc.inode->ia_type == IA_IFREG) {
-                return ec->eager_lock_timeout;
-        }
+    if (lock->loc.inode->ia_type == IA_IFREG) {
+        return ec->eager_lock_timeout;
+    }
 
-        return ec->other_eager_lock_timeout;
+    return ec->other_eager_lock_timeout;
 }
 
 static gf_boolean_t
 ec_lock_delay_create(ec_lock_link_t *link)
 {
-        struct timespec delay;
-        ec_fop_data_t *fop = link->fop;
-        ec_lock_t *lock = link->lock;
+    struct timespec delay;
+    ec_fop_data_t *fop = link->fop;
+    ec_lock_t *lock = link->lock;
 
-        delay.tv_sec = ec_eager_lock_timeout(fop->xl->private, lock);
-        delay.tv_nsec = 0;
-        lock->timer = gf_timer_call_after(fop->xl->ctx, delay,
-                                          ec_unlock_timer_cbk, link);
-        if (lock->timer == NULL) {
-                gf_msg(fop->xl->name, GF_LOG_WARNING, ENOMEM,
-                       EC_MSG_UNLOCK_DELAY_FAILED,
-                       "Unable to delay an unlock");
+    delay.tv_sec = ec_eager_lock_timeout(fop->xl->private, lock);
+    delay.tv_nsec = 0;
+    lock->timer = gf_timer_call_after(fop->xl->ctx, delay, ec_unlock_timer_cbk,
+                                      link);
+    if (lock->timer == NULL) {
+        gf_msg(fop->xl->name, GF_LOG_WARNING, ENOMEM,
+               EC_MSG_UNLOCK_DELAY_FAILED, "Unable to delay an unlock");
 
-                return _gf_false;
-        }
+        return _gf_false;
+    }
 
-        return _gf_true;
+    return _gf_true;
 }
 
-void ec_unlock_timer_add(ec_lock_link_t *link)
+void
+ec_unlock_timer_add(ec_lock_link_t *link)
 {
     ec_fop_data_t *fop = link->fop;
     ec_lock_t *lock = link->lock;
@@ -2732,7 +2709,8 @@ void ec_unlock_timer_add(ec_lock_link_t *link)
     }
 }
 
-void ec_unlock(ec_fop_data_t *fop)
+void
+ec_unlock(ec_fop_data_t *fop)
 {
     int32_t i;
 
@@ -2741,7 +2719,8 @@ void ec_unlock(ec_fop_data_t *fop)
     }
 }
 
-void ec_flush_size_version(ec_fop_data_t * fop)
+void
+ec_flush_size_version(ec_fop_data_t *fop)
 {
     GF_ASSERT(fop->lock_count == 1);
     ec_update_info(&fop->locks[0]);
@@ -2751,99 +2730,98 @@ static void
 ec_update_stripe(ec_t *ec, ec_stripe_list_t *stripe_cache, ec_stripe_t *stripe,
                  ec_fop_data_t *fop)
 {
-        off_t base;
-
-        /* On write fops, we only update existing fragments if the write has
-         * succeeded. Otherwise, we remove them from the cache. */
-        if ((fop->id == GF_FOP_WRITE) && (fop->answer != NULL) &&
-            (fop->answer->op_ret >= 0)) {
-                base = stripe->frag_offset - fop->frag_range.first;
-                base *= ec->fragments;
-
-                /* We check if the stripe offset falls inside the real region
-                 * modified by the write fop (a write request is allowed,
-                 * though uncommon, to write less bytes than requested). The
-                 * current write fop implementation doesn't allow partial
-                 * writes of fragments, so if there's no error, we are sure
-                 * that a full stripe has been completely modified or not
-                 * touched at all. The value of op_ret may not be a multiple
-                 * of the stripe size because it depends on the requested
-                 * size by the user, so we update the stripe if the write has
-                 * modified at least one byte (meaning ec has written the full
-                 * stripe). */
-                if (base < fop->answer->op_ret + fop->head) {
-                        memcpy(stripe->data, fop->vector[0].iov_base + base,
-                               ec->stripe_size);
-                        list_move_tail(&stripe->lru, &stripe_cache->lru);
-
-                        GF_ATOMIC_INC(ec->stats.stripe_cache.updates);
-                }
-        } else {
-                stripe->frag_offset = -1;
-                list_move (&stripe->lru, &stripe_cache->lru);
-
-                GF_ATOMIC_INC(ec->stats.stripe_cache.invals);
+    off_t base;
+
+    /* On write fops, we only update existing fragments if the write has
+     * succeeded. Otherwise, we remove them from the cache. */
+    if ((fop->id == GF_FOP_WRITE) && (fop->answer != NULL) &&
+        (fop->answer->op_ret >= 0)) {
+        base = stripe->frag_offset - fop->frag_range.first;
+        base *= ec->fragments;
+
+        /* We check if the stripe offset falls inside the real region
+         * modified by the write fop (a write request is allowed,
+         * though uncommon, to write less bytes than requested). The
+         * current write fop implementation doesn't allow partial
+         * writes of fragments, so if there's no error, we are sure
+         * that a full stripe has been completely modified or not
+         * touched at all. The value of op_ret may not be a multiple
+         * of the stripe size because it depends on the requested
+         * size by the user, so we update the stripe if the write has
+         * modified at least one byte (meaning ec has written the full
+         * stripe). */
+        if (base < fop->answer->op_ret + fop->head) {
+            memcpy(stripe->data, fop->vector[0].iov_base + base,
+                   ec->stripe_size);
+            list_move_tail(&stripe->lru, &stripe_cache->lru);
+
+            GF_ATOMIC_INC(ec->stats.stripe_cache.updates);
         }
+    } else {
+        stripe->frag_offset = -1;
+        list_move(&stripe->lru, &stripe_cache->lru);
+
+        GF_ATOMIC_INC(ec->stats.stripe_cache.invals);
+    }
 }
 
 static void
-ec_update_cached_stripes (ec_fop_data_t *fop)
-{
-        uint64_t          first;
-        uint64_t          last;
-        ec_stripe_t      *stripe       = NULL;
-        ec_inode_t       *ctx          = NULL;
-        ec_stripe_list_t *stripe_cache = NULL;
-        inode_t          *inode        = NULL;
-        struct list_head *temp;
-        struct list_head  sentinel;
-
-        first = fop->frag_range.first;
-        /* 'last' represents the first stripe not touched by the operation */
-        last = fop->frag_range.last;
-
-        /* If there are no modified stripes, we don't need to do anything
-         * else. */
-        if (last <= first) {
-                return;
-        }
+ec_update_cached_stripes(ec_fop_data_t *fop)
+{
+    uint64_t first;
+    uint64_t last;
+    ec_stripe_t *stripe = NULL;
+    ec_inode_t *ctx = NULL;
+    ec_stripe_list_t *stripe_cache = NULL;
+    inode_t *inode = NULL;
+    struct list_head *temp;
+    struct list_head sentinel;
+
+    first = fop->frag_range.first;
+    /* 'last' represents the first stripe not touched by the operation */
+    last = fop->frag_range.last;
+
+    /* If there are no modified stripes, we don't need to do anything
+     * else. */
+    if (last <= first) {
+        return;
+    }
 
-        if (!fop->use_fd) {
-                inode = fop->loc[0].inode;
-        } else {
-                inode = fop->fd->inode;
-        }
+    if (!fop->use_fd) {
+        inode = fop->loc[0].inode;
+    } else {
+        inode = fop->fd->inode;
+    }
 
-        LOCK(&inode->lock);
+    LOCK(&inode->lock);
 
-        ctx = __ec_inode_get (inode, fop->xl);
-        if (ctx == NULL) {
-                goto out;
-        }
-        stripe_cache = &ctx->stripe_cache;
-
-        /* Since we'll be moving elements of the list to the tail, we might
-         * end in an infinite loop. To avoid it, we insert a sentinel element
-         * into the list, so that it will be used to detect when we have
-         * traversed all existing elements once. */
-        list_add_tail(&sentinel, &stripe_cache->lru);
-        temp = stripe_cache->lru.next;
-        while (temp != &sentinel) {
-                stripe = list_entry(temp, ec_stripe_t, lru);
-                temp = temp->next;
-                if ((first <= stripe->frag_offset) &&
-                    (stripe->frag_offset < last)) {
-                        ec_update_stripe (fop->xl->private, stripe_cache,
-                                          stripe, fop);
-                }
+    ctx = __ec_inode_get(inode, fop->xl);
+    if (ctx == NULL) {
+        goto out;
+    }
+    stripe_cache = &ctx->stripe_cache;
+
+    /* Since we'll be moving elements of the list to the tail, we might
+     * end in an infinite loop. To avoid it, we insert a sentinel element
+     * into the list, so that it will be used to detect when we have
+     * traversed all existing elements once. */
+    list_add_tail(&sentinel, &stripe_cache->lru);
+    temp = stripe_cache->lru.next;
+    while (temp != &sentinel) {
+        stripe = list_entry(temp, ec_stripe_t, lru);
+        temp = temp->next;
+        if ((first <= stripe->frag_offset) && (stripe->frag_offset < last)) {
+            ec_update_stripe(fop->xl->private, stripe_cache, stripe, fop);
         }
-        list_del(&sentinel);
+    }
+    list_del(&sentinel);
 
 out:
-        UNLOCK(&inode->lock);
+    UNLOCK(&inode->lock);
 }
 
-void ec_lock_reuse(ec_fop_data_t *fop)
+void
+ec_lock_reuse(ec_fop_data_t *fop)
 {
     ec_cbk_data_t *cbk;
     ec_t *ec = NULL;
@@ -2854,13 +2832,13 @@ void ec_lock_reuse(ec_fop_data_t *fop)
 
     if (ec_eager_lock_used(ec, fop) && cbk != NULL) {
         if (cbk->xdata != NULL) {
-            if ((dict_get_int32(cbk->xdata, GLUSTERFS_INODELK_COUNT,
-                                &count) == 0) && (count > 1)) {
+            if ((dict_get_int32(cbk->xdata, GLUSTERFS_INODELK_COUNT, &count) ==
+                 0) &&
+                (count > 1)) {
                 release = _gf_true;
             }
             if (release) {
-                gf_msg_debug (fop->xl->name, 0,
-                       "Lock contention detected");
+                gf_msg_debug(fop->xl->name, 0, "Lock contention detected");
             }
         }
     } else {
@@ -2869,24 +2847,25 @@ void ec_lock_reuse(ec_fop_data_t *fop)
          * the lock. */
         release = _gf_true;
     }
-    ec_update_cached_stripes (fop);
+    ec_update_cached_stripes(fop);
 
     for (i = 0; i < fop->lock_count; i++) {
         ec_lock_next_owner(&fop->locks[i], cbk, release);
     }
 }
 
-void __ec_manager(ec_fop_data_t * fop, int32_t error)
+void
+__ec_manager(ec_fop_data_t *fop, int32_t error)
 {
     ec_t *ec = fop->xl->private;
 
     do {
         ec_trace("MANAGER", fop, "error=%d", error);
 
-        if (!ec_must_wind (fop)) {
-                if (ec->xl_up_count < ec->fragments) {
-                    error = ENOTCONN;
-                }
+        if (!ec_must_wind(fop)) {
+            if (ec->xl_up_count < ec->fragments) {
+                error = ENOTCONN;
+            }
         }
 
         if (error != 0) {
@@ -2912,20 +2891,20 @@ void __ec_manager(ec_fop_data_t * fop, int32_t error)
         fop->jobs = 1;
 
         fop->state = fop->handler(fop, fop->state);
-        GF_ASSERT (fop->state >= 0);
+        GF_ASSERT(fop->state >= 0);
 
         error = ec_check_complete(fop, __ec_manager);
     } while (error >= 0);
 }
 
-void ec_manager(ec_fop_data_t * fop, int32_t error)
+void
+ec_manager(ec_fop_data_t *fop, int32_t error)
 {
     GF_ASSERT(fop->jobs == 0);
     GF_ASSERT(fop->winds == 0);
     GF_ASSERT(fop->error == 0);
 
-    if (fop->state == EC_STATE_START)
-    {
+    if (fop->state == EC_STATE_START) {
         fop->state = EC_STATE_INIT;
     }
 
diff --git a/xlators/cluster/ec/src/ec-data.c b/xlators/cluster/ec/src/ec-data.c
index 33a970d922a..fae8843a679 100644
--- a/xlators/cluster/ec/src/ec-data.c
+++ b/xlators/cluster/ec/src/ec-data.c
@@ -14,47 +14,43 @@
 #include "ec-data.h"
 #include "ec-messages.h"
 
-ec_cbk_data_t * ec_cbk_data_allocate(call_frame_t * frame, xlator_t * this,
-                                     ec_fop_data_t * fop, int32_t id,
-                                     int32_t idx, int32_t op_ret,
-                                     int32_t op_errno)
+ec_cbk_data_t *
+ec_cbk_data_allocate(call_frame_t *frame, xlator_t *this, ec_fop_data_t *fop,
+                     int32_t id, int32_t idx, int32_t op_ret, int32_t op_errno)
 {
-    ec_cbk_data_t * cbk;
-    ec_t * ec = this->private;
+    ec_cbk_data_t *cbk;
+    ec_t *ec = this->private;
 
-    if (fop->xl != this)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_XLATOR_MISMATCH, "Mismatching xlators between request "
-                "and answer (req=%s, ans=%s).", fop->xl->name, this->name);
+    if (fop->xl != this) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_XLATOR_MISMATCH,
+               "Mismatching xlators between request "
+               "and answer (req=%s, ans=%s).",
+               fop->xl->name, this->name);
 
         return NULL;
     }
-    if (fop->frame != frame)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_FRAME_MISMATCH, "Mismatching frames between request "
-                                         "and answer (req=%p, ans=%p).",
-                                         fop->frame, frame);
+    if (fop->frame != frame) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_FRAME_MISMATCH,
+               "Mismatching frames between request "
+               "and answer (req=%p, ans=%p).",
+               fop->frame, frame);
 
         return NULL;
     }
-    if (fop->id != id)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_FOP_MISMATCH, "Mismatching fops between request "
-                                         "and answer (req=%d, ans=%d).",
-                                         fop->id, id);
+    if (fop->id != id) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_FOP_MISMATCH,
+               "Mismatching fops between request "
+               "and answer (req=%d, ans=%d).",
+               fop->id, id);
 
         return NULL;
     }
 
     cbk = mem_get0(ec->cbk_pool);
-    if (cbk == NULL)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Failed to allocate memory for an "
-                                         "answer.");
+    if (cbk == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Failed to allocate memory for an "
+               "answer.");
         return NULL;
     }
 
@@ -64,7 +60,7 @@ ec_cbk_data_t * ec_cbk_data_allocate(call_frame_t * frame, xlator_t * this,
     cbk->count = 1;
     cbk->op_ret = op_ret;
     cbk->op_errno = op_errno;
-    INIT_LIST_HEAD (&cbk->entries.list);
+    INIT_LIST_HEAD(&cbk->entries.list);
 
     LOCK(&fop->lock);
 
@@ -75,50 +71,45 @@ ec_cbk_data_t * ec_cbk_data_allocate(call_frame_t * frame, xlator_t * this,
     return cbk;
 }
 
-void ec_cbk_data_destroy(ec_cbk_data_t * cbk)
+void
+ec_cbk_data_destroy(ec_cbk_data_t *cbk)
 {
-    if (cbk->xdata != NULL)
-    {
+    if (cbk->xdata != NULL) {
         dict_unref(cbk->xdata);
     }
-    if (cbk->dict != NULL)
-    {
+    if (cbk->dict != NULL) {
         dict_unref(cbk->dict);
     }
-    if (cbk->inode != NULL)
-    {
+    if (cbk->inode != NULL) {
         inode_unref(cbk->inode);
     }
-    if (cbk->fd != NULL)
-    {
+    if (cbk->fd != NULL) {
         fd_unref(cbk->fd);
     }
-    if (cbk->buffers != NULL)
-    {
+    if (cbk->buffers != NULL) {
         iobref_unref(cbk->buffers);
     }
     GF_FREE(cbk->vector);
-    gf_dirent_free (&cbk->entries);
-    GF_FREE (cbk->str);
+    gf_dirent_free(&cbk->entries);
+    GF_FREE(cbk->str);
 
     mem_put(cbk);
 }
 
-ec_fop_data_t * ec_fop_data_allocate(call_frame_t * frame, xlator_t * this,
-                                     int32_t id, uint32_t flags,
-                                     uintptr_t target, int32_t minimum,
-                                     ec_wind_f wind, ec_handler_f handler,
-                                     ec_cbk_t cbks, void * data)
+ec_fop_data_t *
+ec_fop_data_allocate(call_frame_t *frame, xlator_t *this, int32_t id,
+                     uint32_t flags, uintptr_t target, int32_t minimum,
+                     ec_wind_f wind, ec_handler_f handler, ec_cbk_t cbks,
+                     void *data)
 {
-    ec_fop_data_t * fop, * parent;
-    ec_t * ec = this->private;
+    ec_fop_data_t *fop, *parent;
+    ec_t *ec = this->private;
 
     fop = mem_get0(ec->fop_pool);
-    if (fop == NULL)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Failed to allocate memory for a "
-                                         "request.");
+    if (fop == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Failed to allocate memory for a "
+               "request.");
 
         return NULL;
     }
@@ -142,19 +133,15 @@ ec_fop_data_t * ec_fop_data_allocate(call_frame_t * frame, xlator_t * this,
      * TODO: minimize usage of private frames. Reuse req_frame as much as
      *       possible.
      */
-    if (frame != NULL)
-    {
+    if (frame != NULL) {
         fop->frame = copy_frame(frame);
-    }
-    else
-    {
+    } else {
         fop->frame = create_frame(this, this->ctx->pool);
     }
-    if (fop->frame == NULL)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Failed to create a private frame "
-                                         "for a request");
+    if (fop->frame == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Failed to create a private frame "
+               "for a request");
 
         mem_put(fop);
 
@@ -179,11 +166,9 @@ ec_fop_data_t * ec_fop_data_allocate(call_frame_t * frame, xlator_t * this,
 
     fop->frame->local = fop;
 
-    if (frame != NULL)
-    {
+    if (frame != NULL) {
         parent = frame->local;
-        if (parent != NULL)
-        {
+        if (parent != NULL) {
             ec_sleep(parent);
         }
 
@@ -199,7 +184,8 @@ ec_fop_data_t * ec_fop_data_allocate(call_frame_t * frame, xlator_t * this,
     return fop;
 }
 
-void ec_fop_data_acquire(ec_fop_data_t * fop)
+void
+ec_fop_data_acquire(ec_fop_data_t *fop)
 {
     LOCK(&fop->lock);
 
@@ -211,36 +197,38 @@ void ec_fop_data_acquire(ec_fop_data_t * fop)
 }
 
 static void
-ec_handle_last_pending_fop_completion (ec_fop_data_t *fop, gf_boolean_t *notify)
+ec_handle_last_pending_fop_completion(ec_fop_data_t *fop, gf_boolean_t *notify)
 {
-        ec_t *ec = fop->xl->private;
-
-        if (!list_empty (&fop->pending_list)) {
-                LOCK(&ec->lock);
-                {
-                        list_del_init (&fop->pending_list);
-                        *notify = list_empty (&ec->pending_fops);
-                }
-                UNLOCK(&ec->lock);
+    ec_t *ec = fop->xl->private;
+
+    if (!list_empty(&fop->pending_list)) {
+        LOCK(&ec->lock);
+        {
+            list_del_init(&fop->pending_list);
+            *notify = list_empty(&ec->pending_fops);
         }
+        UNLOCK(&ec->lock);
+    }
 }
 
 void
 ec_fop_cleanup(ec_fop_data_t *fop)
 {
-        ec_cbk_data_t *cbk, *tmp;
+    ec_cbk_data_t *cbk, *tmp;
 
-        list_for_each_entry_safe(cbk, tmp, &fop->answer_list, answer_list) {
-            list_del_init(&cbk->answer_list);
+    list_for_each_entry_safe(cbk, tmp, &fop->answer_list, answer_list)
+    {
+        list_del_init(&cbk->answer_list);
 
-            ec_cbk_data_destroy(cbk);
-        }
-        INIT_LIST_HEAD(&fop->cbk_list);
+        ec_cbk_data_destroy(cbk);
+    }
+    INIT_LIST_HEAD(&fop->cbk_list);
 
-        fop->answer = NULL;
+    fop->answer = NULL;
 }
 
-void ec_fop_data_release(ec_fop_data_t * fop)
+void
+ec_fop_data_release(ec_fop_data_t *fop)
 {
     ec_t *ec = NULL;
     int32_t refs;
@@ -250,36 +238,30 @@ void ec_fop_data_release(ec_fop_data_t * fop)
 
     ec_trace("RELEASE", fop, "");
 
-    GF_ASSERT (fop->refs > 0);
+    GF_ASSERT(fop->refs > 0);
     refs = --fop->refs;
 
     UNLOCK(&fop->lock);
 
-    if (refs == 0)
-    {
+    if (refs == 0) {
         fop->frame->local = NULL;
         STACK_DESTROY(fop->frame->root);
 
         LOCK_DESTROY(&fop->lock);
 
-        if (fop->xdata != NULL)
-        {
+        if (fop->xdata != NULL) {
             dict_unref(fop->xdata);
         }
-        if (fop->dict != NULL)
-        {
+        if (fop->dict != NULL) {
             dict_unref(fop->dict);
         }
-        if (fop->inode != NULL)
-        {
+        if (fop->inode != NULL) {
             inode_unref(fop->inode);
         }
-        if (fop->fd != NULL)
-        {
+        if (fop->fd != NULL) {
             fd_unref(fop->fd);
         }
-        if (fop->buffers != NULL)
-        {
+        if (fop->buffers != NULL) {
             iobref_unref(fop->buffers);
         }
         GF_FREE(fop->vector);
@@ -294,8 +276,8 @@ void ec_fop_data_release(ec_fop_data_t * fop)
         ec_fop_cleanup(fop);
 
         ec = fop->xl->private;
-        ec_handle_last_pending_fop_completion (fop, &notify);
-        ec_handle_healers_done (fop);
+        ec_handle_last_pending_fop_completion(fop, &notify);
+        ec_handle_healers_done(fop);
         mem_put(fop);
         if (notify) {
             ec_pending_fops_completed(ec);
diff --git a/xlators/cluster/ec/src/ec-dir-read.c b/xlators/cluster/ec/src/ec-dir-read.c
index b44bb4239b1..8db92b9d92d 100644
--- a/xlators/cluster/ec/src/ec-dir-read.c
+++ b/xlators/cluster/ec/src/ec-dir-read.c
@@ -25,15 +25,14 @@
  *
  ***************************************************************/
 
-int32_t ec_combine_opendir(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                           ec_cbk_data_t * src)
+int32_t
+ec_combine_opendir(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (dst->fd != src->fd)
-    {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_FD_MISMATCH, "Mismatching fd in answers "
-                "of 'GF_FOP_OPENDIR': %p <-> %p",
-                dst->fd, src->fd);
+    if (dst->fd != src->fd) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_FD_MISMATCH,
+               "Mismatching fd in answers "
+               "of 'GF_FOP_OPENDIR': %p <-> %p",
+               dst->fd, src->fd);
 
         return 0;
     }
@@ -41,12 +40,12 @@ int32_t ec_combine_opendir(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_opendir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno, fd_t * fd,
-                       dict_t * xdata)
+int32_t
+ec_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -56,36 +55,31 @@ int32_t ec_opendir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_OPENDIR, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (fd != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (fd != NULL) {
                 cbk->fd = fd_ref(fd);
-                if (cbk->fd == NULL)
-                {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                            "file descriptor.");
+                if (cbk->fd == NULL) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           EC_MSG_FILE_DESC_REF_FAIL,
+                           "Failed to reference a "
+                           "file descriptor.");
 
                     goto out;
                 }
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -93,19 +87,19 @@ int32_t ec_opendir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
         ec_combine(cbk, ec_combine_opendir);
 
-        ec_update_fd_status (fd, this, idx, op_ret);
+        ec_update_fd_status(fd, this, idx, op_ret);
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_opendir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_opendir(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -114,14 +108,14 @@ void ec_wind_opendir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->fd, fop->xdata);
 }
 
-int32_t ec_manager_opendir(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_opendir(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
     ec_fd_t *ctx;
     int32_t err;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             LOCK(&fop->fd->lock);
 
@@ -182,8 +176,7 @@ int32_t ec_manager_opendir(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.opendir != NULL)
-            {
+            if (fop->cbks.opendir != NULL) {
                 fop->cbks.opendir(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                   cbk->op_errno, cbk->fd, cbk->xdata);
             }
@@ -197,8 +190,7 @@ int32_t ec_manager_opendir(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.opendir != NULL)
-            {
+            if (fop->cbks.opendir != NULL) {
                 fop->cbks.opendir(fop->req_frame, fop, fop->xl, -1, fop->error,
                                   NULL, NULL);
             }
@@ -218,40 +210,39 @@ int32_t ec_manager_opendir(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_opendir(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_opendir_cbk_t func, void * data,
-                loc_t * loc, fd_t * fd, dict_t * xdata)
+void
+ec_opendir(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_opendir_cbk_t func, void *data, loc_t *loc,
+           fd_t *fd, dict_t *xdata)
 {
-    ec_cbk_t callback = { .opendir = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.opendir = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(OPENDIR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(OPENDIR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_OPENDIR,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_opendir, ec_manager_opendir, callback,
-                               data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_OPENDIR, EC_FLAG_LOCK_SHARED,
+                               target, minimum, ec_wind_opendir,
+                               ec_manager_opendir, callback, data);
     if (fop == NULL) {
         goto out;
     }
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -259,9 +250,9 @@ void ec_opendir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -269,9 +260,9 @@ void ec_opendir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -289,50 +280,49 @@ out:
 
 /* Returns -1 if client_id is invalid else index of child subvol in xl_list */
 int
-ec_deitransform (xlator_t *this, off_t offset)
+ec_deitransform(xlator_t *this, off_t offset)
 {
-        int  idx       = -1;
-        int  client_id = -1;
-        ec_t *ec       = this->private;
-        char id[32]    = {0};
-        int err;
-
-        client_id = gf_deitransform (this, offset);
-        sprintf (id, "%d", client_id);
-        err = dict_get_int32 (ec->leaf_to_subvolid, id, &idx);
-        if (err < 0) {
-                idx = err;
-                goto out;
-        }
+    int idx = -1;
+    int client_id = -1;
+    ec_t *ec = this->private;
+    char id[32] = {0};
+    int err;
+
+    client_id = gf_deitransform(this, offset);
+    sprintf(id, "%d", client_id);
+    err = dict_get_int32(ec->leaf_to_subvolid, id, &idx);
+    if (err < 0) {
+        idx = err;
+        goto out;
+    }
 
 out:
-        if (idx < 0) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        EC_MSG_INVALID_REQUEST,
-                        "Invalid index %d in readdirp request", client_id);
-                idx = -EINVAL;
-        }
-        return idx;
+    if (idx < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_REQUEST,
+               "Invalid index %d in readdirp request", client_id);
+        idx = -EINVAL;
+    }
+    return idx;
 }
 
 /* FOP: readdir */
 
-void ec_adjust_readdirp (ec_t *ec, int32_t idx, gf_dirent_t *entries)
+void
+ec_adjust_readdirp(ec_t *ec, int32_t idx, gf_dirent_t *entries)
 {
-    gf_dirent_t * entry;
+    gf_dirent_t *entry;
 
     list_for_each_entry(entry, &entries->list, list)
     {
         if (!entry->inode)
-                continue;
+            continue;
 
-        if (entry->d_stat.ia_type == IA_IFREG)
-        {
+        if (entry->d_stat.ia_type == IA_IFREG) {
             if ((entry->dict == NULL) ||
                 (ec_dict_del_number(entry->dict, EC_XATTR_SIZE,
                                     &entry->d_stat.ia_size) != 0)) {
-                    inode_unref (entry->inode);
-                    entry->inode = NULL;
+                inode_unref(entry->inode);
+                entry->inode = NULL;
             } else {
                 ec_iatt_rebuild(ec, &entry->d_stat, 1, 1);
             }
@@ -341,9 +331,9 @@ void ec_adjust_readdirp (ec_t *ec, int32_t idx, gf_dirent_t *entries)
 }
 
 int32_t
-ec_common_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno,
-                       gf_dirent_t *entries, dict_t *xdata)
+ec_common_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                      dict_t *xdata)
 {
     ec_fop_data_t *fop = NULL;
     ec_cbk_data_t *cbk = NULL;
@@ -356,30 +346,29 @@ ec_common_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-    cbk = ec_cbk_data_allocate (frame, this, fop, fop->id,
-                                idx, op_ret, op_errno);
+    cbk = ec_cbk_data_allocate(frame, this, fop, fop->id, idx, op_ret,
+                               op_errno);
     if (cbk) {
         if (xdata)
-                cbk->xdata = dict_ref (xdata);
+            cbk->xdata = dict_ref(xdata);
         if (cbk->op_ret >= 0)
-                list_splice_init (&entries->list,
-                                  &cbk->entries.list);
-        ec_combine (cbk, NULL);
+            list_splice_init(&entries->list, &cbk->entries.list);
+        ec_combine(cbk, NULL);
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_readdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_readdir(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -388,13 +377,13 @@ void ec_wind_readdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->size, fop->offset, fop->xdata);
 }
 
-int32_t ec_manager_readdir(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_readdir(ec_fop_data_t *fop, int32_t state)
 {
     ec_fd_t *ctx = NULL;
     ec_cbk_data_t *cbk = NULL;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             /* Return error if opendir has not been successfully called on
              * any subvolume. */
@@ -406,42 +395,40 @@ int32_t ec_manager_readdir(ec_fop_data_t * fop, int32_t state)
             }
 
             if (fop->id == GF_FOP_READDIRP) {
-                    int32_t err;
+                int32_t err;
 
+                if (fop->xdata == NULL) {
+                    fop->xdata = dict_new();
                     if (fop->xdata == NULL) {
-                        fop->xdata = dict_new();
-                        if (fop->xdata == NULL) {
-                            fop->error = ENOMEM;
+                        fop->error = ENOMEM;
 
-                            return EC_STATE_REPORT;
-                        }
+                        return EC_STATE_REPORT;
                     }
+                }
 
-                    err = dict_set_uint64(fop->xdata, EC_XATTR_SIZE, 0);
-                    if (err != 0) {
-                        fop->error = -err;
+                err = dict_set_uint64(fop->xdata, EC_XATTR_SIZE, 0);
+                if (err != 0) {
+                    fop->error = -err;
 
-                        return EC_STATE_REPORT;
-                    }
+                    return EC_STATE_REPORT;
+                }
             }
 
-            if (fop->offset != 0)
-            {
-            /* Non-zero offset is irrecoverable error as the offset may not be
-             * valid on other bricks*/
+            if (fop->offset != 0) {
+                /* Non-zero offset is irrecoverable error as the offset may not
+                 * be valid on other bricks*/
                 int32_t idx = -1;
 
-                idx = ec_deitransform (fop->xl, fop->offset);
+                idx = ec_deitransform(fop->xl, fop->offset);
 
                 if (idx < 0) {
-                        fop->error = -idx;
-                        return EC_STATE_REPORT;
+                    fop->error = -idx;
+                    return EC_STATE_REPORT;
                 }
                 fop->mask &= 1ULL << idx;
             } else {
-                    ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0,
-                                       LLONG_MAX);
-                    ec_lock(fop);
+                ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, LLONG_MAX);
+                ec_lock(fop);
             }
 
             return EC_STATE_DISPATCH;
@@ -458,14 +445,14 @@ int32_t ec_manager_readdir(ec_fop_data_t * fop, int32_t state)
 
             if ((cbk != NULL) && (cbk->op_ret > 0) &&
                 (fop->id == GF_FOP_READDIRP)) {
-                ec_adjust_readdirp (fop->xl->private, cbk->idx, &cbk->entries);
+                ec_adjust_readdirp(fop->xl->private, cbk->idx, &cbk->entries);
             }
 
             return EC_STATE_REPORT;
 
         case EC_STATE_REPORT:
             cbk = fop->answer;
-            GF_ASSERT (cbk);
+            GF_ASSERT(cbk);
             if (fop->id == GF_FOP_READDIR) {
                 if (fop->cbks.readdir != NULL) {
                     fop->cbks.readdir(fop->req_frame, fop, fop->xl, cbk->op_ret,
@@ -479,9 +466,9 @@ int32_t ec_manager_readdir(ec_fop_data_t * fop, int32_t state)
                 }
             }
             if (fop->offset == 0)
-                    return EC_STATE_LOCK_REUSE;
+                return EC_STATE_LOCK_REUSE;
             else
-                    return EC_STATE_END;
+                return EC_STATE_END;
 
         case -EC_STATE_INIT:
         case -EC_STATE_LOCK:
@@ -500,50 +487,49 @@ int32_t ec_manager_readdir(ec_fop_data_t * fop, int32_t state)
                 }
             }
             if (fop->offset == 0)
-                    return EC_STATE_LOCK_REUSE;
+                return EC_STATE_LOCK_REUSE;
             else
-                    return EC_STATE_END;
+                return EC_STATE_END;
 
         case -EC_STATE_LOCK_REUSE:
         case EC_STATE_LOCK_REUSE:
-            GF_ASSERT (fop->offset == 0);
+            GF_ASSERT(fop->offset == 0);
             ec_lock_reuse(fop);
 
             return EC_STATE_UNLOCK;
 
         case -EC_STATE_UNLOCK:
         case EC_STATE_UNLOCK:
-            GF_ASSERT (fop->offset == 0);
+            GF_ASSERT(fop->offset == 0);
             ec_unlock(fop);
 
             return EC_STATE_END;
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_readdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_readdir_cbk_t func, void * data,
-                fd_t * fd, size_t size, off_t offset, dict_t * xdata)
+void
+ec_readdir(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_readdir_cbk_t func, void *data, fd_t *fd,
+           size_t size, off_t offset, dict_t *xdata)
 {
-    ec_cbk_t callback = { .readdir = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.readdir = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(READDIR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(READDIR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_READDIR,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_readdir, ec_manager_readdir, callback,
-                               data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_READDIR, EC_FLAG_LOCK_SHARED,
+                               target, minimum, ec_wind_readdir,
+                               ec_manager_readdir, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -556,9 +542,9 @@ void ec_readdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -566,9 +552,9 @@ void ec_readdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -586,7 +572,8 @@ out:
 
 /* FOP: readdirp */
 
-void ec_wind_readdirp(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_readdirp(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -595,24 +582,24 @@ void ec_wind_readdirp(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->size, fop->offset, fop->xdata);
 }
 
-void ec_readdirp(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_readdirp_cbk_t func, void * data,
-                 fd_t * fd, size_t size, off_t offset, dict_t * xdata)
+void
+ec_readdirp(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_readdirp_cbk_t func, void *data, fd_t *fd,
+            size_t size, off_t offset, dict_t *xdata)
 {
-    ec_cbk_t callback = { .readdirp = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.readdirp = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(READDIRP) %p", frame);
+    gf_msg_trace("ec", 0, "EC(READDIRP) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_READDIRP,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_readdirp, ec_manager_readdir, callback,
-                               data);
+    fop = ec_fop_data_allocate(
+        frame, this, GF_FOP_READDIRP, EC_FLAG_LOCK_SHARED, target, minimum,
+        ec_wind_readdirp, ec_manager_readdir, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -625,9 +612,9 @@ void ec_readdirp(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -635,9 +622,9 @@ void ec_readdirp(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
diff --git a/xlators/cluster/ec/src/ec-dir-write.c b/xlators/cluster/ec/src/ec-dir-write.c
index 7779d4849f3..f5c38e80dd7 100644
--- a/xlators/cluster/ec/src/ec-dir-write.c
+++ b/xlators/cluster/ec/src/ec-dir-write.c
@@ -20,76 +20,75 @@
 #include "ec-fops.h"
 
 int
-ec_dir_write_cbk (call_frame_t *frame, xlator_t *this,
-                  void *cookie, int op_ret, int op_errno,
-                  struct iatt *poststat, struct iatt *preparent,
-                  struct iatt *postparent, struct iatt *preparent2,
-                  struct iatt *postparent2, dict_t *xdata)
+ec_dir_write_cbk(call_frame_t *frame, xlator_t *this, void *cookie, int op_ret,
+                 int op_errno, struct iatt *poststat, struct iatt *preparent,
+                 struct iatt *postparent, struct iatt *preparent2,
+                 struct iatt *postparent2, dict_t *xdata)
 {
-        ec_fop_data_t *fop = NULL;
-        ec_cbk_data_t *cbk = NULL;
-        int           i    = 0;
-        int           idx  = 0;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    int i = 0;
+    int idx = 0;
 
-        VALIDATE_OR_GOTO (this, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-        fop = frame->local;
-        idx = (long) cookie;
+    fop = frame->local;
+    idx = (long)cookie;
 
-        ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-                 frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-        cbk = ec_cbk_data_allocate (frame, this, fop, fop->id, idx, op_ret,
-                                    op_errno);
-        if (!cbk)
-                goto out;
+    cbk = ec_cbk_data_allocate(frame, this, fop, fop->id, idx, op_ret,
+                               op_errno);
+    if (!cbk)
+        goto out;
 
-        if (xdata)
-                cbk->xdata = dict_ref (xdata);
+    if (xdata)
+        cbk->xdata = dict_ref(xdata);
 
-        if (op_ret < 0)
-                goto out;
+    if (op_ret < 0)
+        goto out;
 
-        if (poststat)
-                cbk->iatt[i++] = *poststat;
+    if (poststat)
+        cbk->iatt[i++] = *poststat;
 
-        if (preparent)
-                cbk->iatt[i++] = *preparent;
+    if (preparent)
+        cbk->iatt[i++] = *preparent;
 
-        if (postparent)
-                cbk->iatt[i++] = *postparent;
+    if (postparent)
+        cbk->iatt[i++] = *postparent;
 
-        if (preparent2)
-                cbk->iatt[i++] = *preparent2;
+    if (preparent2)
+        cbk->iatt[i++] = *preparent2;
 
-        if (postparent2)
-                cbk->iatt[i++] = *postparent2;
+    if (postparent2)
+        cbk->iatt[i++] = *postparent2;
 
 out:
-        if (cbk)
-                ec_combine (cbk, ec_combine_write);
+    if (cbk)
+        ec_combine(cbk, ec_combine_write);
 
-        if (fop)
-                ec_complete (fop);
-        return 0;
+    if (fop)
+        ec_complete(fop);
+    return 0;
 }
 
 /* FOP: create */
 
-int32_t ec_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, fd_t *fd,
-                      inode_t *inode, struct iatt *buf,
-                      struct iatt *preparent, struct iatt *postparent,
-                      dict_t *xdata)
+int32_t
+ec_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf,
+              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_create(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_create(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -99,7 +98,8 @@ void ec_wind_create(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->xdata);
 }
 
-int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_create(ec_fop_data_t *fop, int32_t state)
 {
     ec_config_t config;
     ec_t *ec;
@@ -108,8 +108,7 @@ int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
     uint64_t version[2] = {0, 0};
     int32_t err;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             LOCK(&fop->fd->lock);
 
@@ -176,7 +175,7 @@ int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
              * need to remove O_APPEND from flags (if present) */
             fop->int32 &= ~O_APPEND;
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -218,12 +217,11 @@ int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.create != NULL)
-            {
-                fop->cbks.create (fop->req_frame, fop, fop->xl, cbk->op_ret,
-                                  cbk->op_errno, fop->fd, fop->loc[0].inode,
-                                  &cbk->iatt[0], &cbk->iatt[1], &cbk->iatt[2],
-                                  cbk->xdata);
+            if (fop->cbks.create != NULL) {
+                fop->cbks.create(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                 cbk->op_errno, fop->fd, fop->loc[0].inode,
+                                 &cbk->iatt[0], &cbk->iatt[1], &cbk->iatt[2],
+                                 cbk->xdata);
             }
 
             return EC_STATE_LOCK_REUSE;
@@ -235,8 +233,7 @@ int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.create != NULL)
-            {
+            if (fop->cbks.create != NULL) {
                 fop->cbks.create(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL, NULL, NULL, NULL, NULL);
             }
@@ -256,24 +253,23 @@ int32_t ec_manager_create(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_create(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_create_cbk_t func, void * data,
-               loc_t * loc, int32_t flags, mode_t mode, mode_t umask,
-               fd_t * fd, dict_t * xdata)
+void
+ec_create(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_create_cbk_t func, void *data, loc_t *loc,
+          int32_t flags, mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-    ec_cbk_t callback = { .create = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.create = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(CREATE) %p", frame);
+    gf_msg_trace("ec", 0, "EC(CREATE) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -292,8 +288,8 @@ void ec_create(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -301,19 +297,19 @@ void ec_create(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -331,16 +327,17 @@ out:
 
 /* FOP: link */
 
-int32_t ec_link_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                    int32_t op_ret, int32_t op_errno, inode_t * inode,
-                    struct iatt * buf, struct iatt * preparent,
-                    struct iatt * postparent, dict_t * xdata)
+int32_t
+ec_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, inode_t *inode, struct iatt *buf,
+            struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_link(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_link(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -349,17 +346,17 @@ void ec_wind_link(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], &fop->loc[1], fop->xdata);
 }
 
-int32_t ec_manager_link(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_link(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_parent_inode(fop, &fop->loc[1], &fop->loc[0],
-                                         EC_UPDATE_DATA | EC_UPDATE_META |
-                                         EC_INODE_SIZE);
+            ec_lock_prepare_parent_inode(
+                fop, &fop->loc[1], &fop->loc[0],
+                EC_UPDATE_DATA | EC_UPDATE_META | EC_INODE_SIZE);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -392,8 +389,7 @@ int32_t ec_manager_link(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.link != NULL)
-            {
+            if (fop->cbks.link != NULL) {
                 fop->cbks.link(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                cbk->op_errno, fop->loc[0].inode, &cbk->iatt[0],
                                &cbk->iatt[1], &cbk->iatt[2], cbk->xdata);
@@ -408,8 +404,7 @@ int32_t ec_manager_link(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.link != NULL)
-            {
+            if (fop->cbks.link != NULL) {
                 fop->cbks.link(fop->req_frame, fop, fop->xl, -1, fop->error,
                                NULL, NULL, NULL, NULL, NULL);
             }
@@ -429,23 +424,23 @@ int32_t ec_manager_link(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_link(call_frame_t * frame, xlator_t * this, uintptr_t target,
-             int32_t minimum, fop_link_cbk_t func, void * data, loc_t * oldloc,
-             loc_t * newloc, dict_t * xdata)
+void
+ec_link(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+        fop_link_cbk_t func, void *data, loc_t *oldloc, loc_t *newloc,
+        dict_t *xdata)
 {
-    ec_cbk_t callback = { .link = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.link = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(LINK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(LINK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -459,26 +454,26 @@ void ec_link(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (oldloc != NULL) {
         if (loc_copy(&fop->loc[0], oldloc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (newloc != NULL) {
         if (loc_copy(&fop->loc[1], newloc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -496,16 +491,17 @@ out:
 
 /* FOP: mkdir */
 
-int32_t ec_mkdir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, inode_t * inode,
-                     struct iatt * buf, struct iatt * preparent,
-                     struct iatt * postparent, dict_t * xdata)
+int32_t
+ec_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, inode_t *inode, struct iatt *buf,
+             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_mkdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_mkdir(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -514,14 +510,14 @@ void ec_wind_mkdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->mode[0], fop->mode[1], fop->xdata);
 }
 
-int32_t ec_manager_mkdir(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_mkdir(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
     uint64_t version[2] = {0, 0};
     int32_t err;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             if (fop->xdata == NULL) {
                 fop->xdata = dict_new();
@@ -539,7 +535,7 @@ int32_t ec_manager_mkdir(ec_fop_data_t * fop, int32_t state)
                 return EC_STATE_REPORT;
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -572,8 +568,7 @@ int32_t ec_manager_mkdir(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.mkdir != NULL)
-            {
+            if (fop->cbks.mkdir != NULL) {
                 fop->cbks.mkdir(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, fop->loc[0].inode, &cbk->iatt[0],
                                 &cbk->iatt[1], &cbk->iatt[2], cbk->xdata);
@@ -589,8 +584,7 @@ int32_t ec_manager_mkdir(ec_fop_data_t * fop, int32_t state)
             cbk = fop->answer;
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.mkdir != NULL)
-            {
+            if (fop->cbks.mkdir != NULL) {
                 fop->cbks.mkdir(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL, NULL, NULL, NULL,
                                 ((cbk) ? cbk->xdata : NULL));
@@ -611,31 +605,30 @@ int32_t ec_manager_mkdir(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_mkdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_mkdir_cbk_t func, void * data, loc_t * loc,
-              mode_t mode, mode_t umask, dict_t * xdata)
+void
+ec_mkdir(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_mkdir_cbk_t func, void *data, loc_t *loc, mode_t mode,
+         mode_t umask, dict_t *xdata)
 {
-    ec_cbk_t callback = { .mkdir = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.mkdir = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(MKDIR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(MKDIR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_MKDIR, 0, target, minimum,
-                               ec_wind_mkdir, ec_manager_mkdir, callback,
-                               data);
+                               ec_wind_mkdir, ec_manager_mkdir, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -645,18 +638,18 @@ void ec_mkdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -674,16 +667,17 @@ out:
 
 /* FOP: mknod */
 
-int32_t ec_mknod_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, inode_t * inode,
-                     struct iatt * buf, struct iatt * preparent,
-                     struct iatt * postparent, dict_t * xdata)
+int32_t
+ec_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, inode_t *inode, struct iatt *buf,
+             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_mknod(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_mknod(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -693,15 +687,15 @@ void ec_wind_mknod(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->xdata);
 }
 
-int32_t ec_manager_mknod(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_mknod(ec_fop_data_t *fop, int32_t state)
 {
     ec_config_t config;
     ec_t *ec;
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
     uint64_t version[2] = {0, 0};
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             if (S_ISREG(fop->mode[0])) {
                 int32_t err;
@@ -745,7 +739,7 @@ int32_t ec_manager_mknod(ec_fop_data_t * fop, int32_t state)
                 }
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -778,8 +772,7 @@ int32_t ec_manager_mknod(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.mknod != NULL)
-            {
+            if (fop->cbks.mknod != NULL) {
                 fop->cbks.mknod(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, fop->loc[0].inode, &cbk->iatt[0],
                                 &cbk->iatt[1], &cbk->iatt[2], cbk->xdata);
@@ -794,8 +787,7 @@ int32_t ec_manager_mknod(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.mknod != NULL)
-            {
+            if (fop->cbks.mknod != NULL) {
                 fop->cbks.mknod(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL, NULL, NULL, NULL, NULL);
             }
@@ -815,31 +807,30 @@ int32_t ec_manager_mknod(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_mknod(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_mknod_cbk_t func, void * data, loc_t * loc,
-              mode_t mode, dev_t rdev, mode_t umask, dict_t * xdata)
+void
+ec_mknod(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_mknod_cbk_t func, void *data, loc_t *loc, mode_t mode, dev_t rdev,
+         mode_t umask, dict_t *xdata)
 {
-    ec_cbk_t callback = { .mknod = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.mknod = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(MKNOD) %p", frame);
+    gf_msg_trace("ec", 0, "EC(MKNOD) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_MKNOD, 0, target, minimum,
-                               ec_wind_mknod, ec_manager_mknod, callback,
-                               data);
+                               ec_wind_mknod, ec_manager_mknod, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -850,18 +841,18 @@ void ec_mknod(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -879,18 +870,19 @@ out:
 
 /* FOP: rename */
 
-int32_t ec_rename_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                      int32_t op_ret, int32_t op_errno, struct iatt * buf,
-                      struct iatt * preoldparent, struct iatt * postoldparent,
-                      struct iatt * prenewparent, struct iatt * postnewparent,
-                      dict_t * xdata)
+int32_t
+ec_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *buf, struct iatt *preoldparent,
+              struct iatt *postoldparent, struct iatt *prenewparent,
+              struct iatt *postnewparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preoldparent, postoldparent, prenewparent,
-                                 postnewparent, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preoldparent, postoldparent, prenewparent,
+                            postnewparent, xdata);
 }
 
-void ec_wind_rename(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_rename(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -899,17 +891,17 @@ void ec_wind_rename(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], &fop->loc[1], fop->xdata);
 }
 
-int32_t ec_manager_rename(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_rename(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_parent_inode(fop, &fop->loc[0], &fop->loc[0],
-                                         EC_UPDATE_DATA | EC_UPDATE_META |
-                                         EC_INODE_SIZE);
+            ec_lock_prepare_parent_inode(
+                fop, &fop->loc[0], &fop->loc[0],
+                EC_UPDATE_DATA | EC_UPDATE_META | EC_INODE_SIZE);
             ec_lock_prepare_parent_inode(fop, &fop->loc[1], NULL,
                                          EC_UPDATE_DATA | EC_UPDATE_META);
             ec_lock(fop);
@@ -938,8 +930,7 @@ int32_t ec_manager_rename(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.rename != NULL)
-            {
+            if (fop->cbks.rename != NULL) {
                 fop->cbks.rename(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                  cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                  &cbk->iatt[2], &cbk->iatt[3], &cbk->iatt[4],
@@ -955,8 +946,7 @@ int32_t ec_manager_rename(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.rename != NULL)
-            {
+            if (fop->cbks.rename != NULL) {
                 fop->cbks.rename(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL, NULL, NULL, NULL, NULL);
             }
@@ -976,23 +966,23 @@ int32_t ec_manager_rename(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_rename(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_rename_cbk_t func, void * data,
-               loc_t * oldloc, loc_t * newloc, dict_t * xdata)
+void
+ec_rename(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_rename_cbk_t func, void *data, loc_t *oldloc,
+          loc_t *newloc, dict_t *xdata)
 {
-    ec_cbk_t callback = { .rename = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.rename = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(RENAME) %p", frame);
+    gf_msg_trace("ec", 0, "EC(RENAME) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1007,26 +997,26 @@ void ec_rename(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (oldloc != NULL) {
         if (loc_copy(&fop->loc[0], oldloc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (newloc != NULL) {
         if (loc_copy(&fop->loc[1], newloc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1044,15 +1034,17 @@ out:
 
 /* FOP: rmdir */
 
-int32_t ec_rmdir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, struct iatt * preparent,
-                     struct iatt * postparent, dict_t * xdata)
+int32_t
+ec_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iatt *preparent, struct iatt *postparent,
+             dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno, NULL,
-                                 preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, NULL,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_rmdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_rmdir(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1061,12 +1053,12 @@ void ec_wind_rmdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->int32, fop->xdata);
 }
 
-int32_t ec_manager_rmdir(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_rmdir(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -1090,8 +1082,7 @@ int32_t ec_manager_rmdir(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.rmdir != NULL)
-            {
+            if (fop->cbks.rmdir != NULL) {
                 fop->cbks.rmdir(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                 cbk->xdata);
@@ -1106,8 +1097,7 @@ int32_t ec_manager_rmdir(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.rmdir != NULL)
-            {
+            if (fop->cbks.rmdir != NULL) {
                 fop->cbks.rmdir(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL, NULL, NULL);
             }
@@ -1127,31 +1117,30 @@ int32_t ec_manager_rmdir(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_rmdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_rmdir_cbk_t func, void * data, loc_t * loc,
-              int xflags, dict_t * xdata)
+void
+ec_rmdir(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_rmdir_cbk_t func, void *data, loc_t *loc, int xflags,
+         dict_t *xdata)
 {
-    ec_cbk_t callback = { .rmdir = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.rmdir = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(RMDIR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(RMDIR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_RMDIR, 0, target, minimum,
-                               ec_wind_rmdir, ec_manager_rmdir, callback,
-                               data);
+                               ec_wind_rmdir, ec_manager_rmdir, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -1160,18 +1149,18 @@ void ec_rmdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1189,16 +1178,18 @@ out:
 
 /* FOP: symlink */
 
-int32_t ec_symlink_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno, inode_t * inode,
-                       struct iatt * buf, struct iatt * preparent,
-                       struct iatt * postparent, dict_t * xdata)
+int32_t
+ec_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, inode_t *inode,
+               struct iatt *buf, struct iatt *preparent,
+               struct iatt *postparent, dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                 buf, preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, buf,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_symlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_symlink(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1207,12 +1198,12 @@ void ec_wind_symlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->str[0], &fop->loc[0], fop->mode[0], fop->xdata);
 }
 
-int32_t ec_manager_symlink(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_symlink(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -1245,8 +1236,7 @@ int32_t ec_manager_symlink(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.symlink != NULL)
-            {
+            if (fop->cbks.symlink != NULL) {
                 fop->cbks.symlink(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                   cbk->op_errno, fop->loc[0].inode,
                                   &cbk->iatt[0], &cbk->iatt[1], &cbk->iatt[2],
@@ -1262,8 +1252,7 @@ int32_t ec_manager_symlink(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.symlink != NULL)
-            {
+            if (fop->cbks.symlink != NULL) {
                 fop->cbks.symlink(fop->req_frame, fop, fop->xl, -1, fop->error,
                                   NULL, NULL, NULL, NULL, NULL);
             }
@@ -1283,24 +1272,23 @@ int32_t ec_manager_symlink(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_symlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_symlink_cbk_t func, void * data,
-                const char * linkname, loc_t * loc, mode_t umask,
-                dict_t * xdata)
+void
+ec_symlink(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_symlink_cbk_t func, void *data,
+           const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata)
 {
-    ec_cbk_t callback = { .symlink = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.symlink = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(SYMLINK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(SYMLINK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1318,16 +1306,16 @@ void ec_symlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (linkname != NULL) {
         fop->str[0] = gf_strdup(linkname);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY, "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
     }
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1335,9 +1323,9 @@ void ec_symlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1355,16 +1343,17 @@ out:
 
 /* FOP: unlink */
 
-int32_t ec_unlink_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                      int32_t op_ret, int32_t op_errno,
-                      struct iatt * preparent, struct iatt * postparent,
-                      dict_t * xdata)
+int32_t
+ec_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *preparent, struct iatt *postparent,
+              dict_t *xdata)
 {
-        return ec_dir_write_cbk (frame, this, cookie, op_ret, op_errno, NULL,
-                                 preparent, postparent, NULL, NULL, xdata);
+    return ec_dir_write_cbk(frame, this, cookie, op_ret, op_errno, NULL,
+                            preparent, postparent, NULL, NULL, xdata);
 }
 
-void ec_wind_unlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_unlink(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1373,12 +1362,12 @@ void ec_wind_unlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->int32, fop->xdata);
 }
 
-int32_t ec_manager_unlink(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_unlink(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_parent_inode(fop, &fop->loc[0], NULL,
@@ -1402,8 +1391,7 @@ int32_t ec_manager_unlink(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.unlink != NULL)
-            {
+            if (fop->cbks.unlink != NULL) {
                 fop->cbks.unlink(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                  cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                  cbk->xdata);
@@ -1418,8 +1406,7 @@ int32_t ec_manager_unlink(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.unlink != NULL)
-            {
+            if (fop->cbks.unlink != NULL) {
                 fop->cbks.unlink(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL, NULL);
             }
@@ -1439,23 +1426,23 @@ int32_t ec_manager_unlink(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_unlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_unlink_cbk_t func, void * data,
-               loc_t * loc, int xflags, dict_t * xdata)
+void
+ec_unlink(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_unlink_cbk_t func, void *data, loc_t *loc,
+          int xflags, dict_t *xdata)
 {
-    ec_cbk_t callback = { .unlink = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.unlink = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(UNLINK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(UNLINK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1472,18 +1459,18 @@ void ec_unlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
diff --git a/xlators/cluster/ec/src/ec-generic.c b/xlators/cluster/ec/src/ec-generic.c
index a5f986e74f4..d12481bdc18 100644
--- a/xlators/cluster/ec/src/ec-generic.c
+++ b/xlators/cluster/ec/src/ec-generic.c
@@ -22,11 +22,12 @@
 
 /* FOP: flush */
 
-int32_t ec_flush_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -36,21 +37,18 @@ int32_t ec_flush_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FLUSH, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -60,15 +58,15 @@ int32_t ec_flush_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_flush(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_flush(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -77,12 +75,12 @@ void ec_wind_flush(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->xdata);
 }
 
-int32_t ec_manager_flush(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_flush(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_fd(fop, fop->fd, 0, 0, LLONG_MAX);
@@ -110,8 +108,7 @@ int32_t ec_manager_flush(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.flush != NULL)
-            {
+            if (fop->cbks.flush != NULL) {
                 fop->cbks.flush(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, cbk->xdata);
             }
@@ -126,8 +123,7 @@ int32_t ec_manager_flush(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.flush != NULL)
-            {
+            if (fop->cbks.flush != NULL) {
                 fop->cbks.flush(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL);
             }
@@ -147,31 +143,29 @@ int32_t ec_manager_flush(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_flush(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_flush_cbk_t func, void * data, fd_t * fd,
-              dict_t * xdata)
+void
+ec_flush(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_flush_cbk_t func, void *data, fd_t *fd, dict_t *xdata)
 {
-    ec_cbk_t callback = { .flush = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.flush = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FLUSH) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FLUSH) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_FLUSH, 0, target, minimum,
-                               ec_wind_flush, ec_manager_flush, callback,
-                               data);
+                               ec_wind_flush, ec_manager_flush, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -181,9 +175,9 @@ void ec_flush(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -191,9 +185,9 @@ void ec_flush(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -211,13 +205,13 @@ out:
 
 /* FOP: fsync */
 
-int32_t ec_combine_fsync(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                         ec_cbk_data_t * src)
+int32_t
+ec_combine_fsync(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
     if (!ec_iatt_combine(fop, dst->iatt, src->iatt, 2)) {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_IATT_MISMATCH, "Mismatching iatt in "
-                                             "answers of 'GF_FOP_FSYNC'");
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of 'GF_FOP_FSYNC'");
 
         return 0;
     }
@@ -225,12 +219,13 @@ int32_t ec_combine_fsync(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_fsync_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, struct iatt * prebuf,
-                     struct iatt * postbuf, dict_t * xdata)
+int32_t
+ec_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
+             dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -240,32 +235,26 @@ int32_t ec_fsync_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FSYNC, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (prebuf != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (prebuf != NULL) {
                 cbk->iatt[0] = *prebuf;
             }
-            if (postbuf != NULL)
-            {
+            if (postbuf != NULL) {
                 cbk->iatt[1] = *postbuf;
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -275,15 +264,15 @@ int32_t ec_fsync_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_fsync(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fsync(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -292,12 +281,12 @@ void ec_wind_fsync(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->int32, fop->xdata);
 }
 
-int32_t ec_manager_fsync(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_fsync(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, LLONG_MAX);
@@ -318,8 +307,7 @@ int32_t ec_manager_fsync(ec_fop_data_t * fop, int32_t state)
         case EC_STATE_PREPARE_ANSWER:
             cbk = ec_fop_prepare_answer(fop, _gf_false);
             if (cbk != NULL) {
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                                cbk->count);
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                 /* This shouldn't fail because we have the inode locked. */
                 GF_ASSERT(ec_get_inode_size(fop, fop->fd->inode,
@@ -334,8 +322,7 @@ int32_t ec_manager_fsync(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.fsync != NULL)
-            {
+            if (fop->cbks.fsync != NULL) {
                 fop->cbks.fsync(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                 cbk->xdata);
@@ -351,8 +338,7 @@ int32_t ec_manager_fsync(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_DELAYED_START:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.fsync != NULL)
-            {
+            if (fop->cbks.fsync != NULL) {
                 fop->cbks.fsync(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL, NULL, NULL);
             }
@@ -372,31 +358,30 @@ int32_t ec_manager_fsync(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_fsync(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_fsync_cbk_t func, void * data, fd_t * fd,
-              int32_t datasync, dict_t * xdata)
+void
+ec_fsync(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_fsync_cbk_t func, void *data, fd_t *fd, int32_t datasync,
+         dict_t *xdata)
 {
-    ec_cbk_t callback = { .fsync = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fsync = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FSYNC) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FSYNC) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_FSYNC, 0, target, minimum,
-                               ec_wind_fsync, ec_manager_fsync, callback,
-                               data);
+                               ec_wind_fsync, ec_manager_fsync, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -408,9 +393,9 @@ void ec_fsync(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -418,9 +403,9 @@ void ec_fsync(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -438,11 +423,12 @@ out:
 
 /* FOP: fsyncdir */
 
-int32_t ec_fsyncdir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                        int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -452,21 +438,18 @@ int32_t ec_fsyncdir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FSYNCDIR, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -476,15 +459,15 @@ int32_t ec_fsyncdir_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_fsyncdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fsyncdir(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -493,12 +476,12 @@ void ec_wind_fsyncdir(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->int32, fop->xdata);
 }
 
-int32_t ec_manager_fsyncdir(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_fsyncdir(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_fd(fop, fop->fd, 0, 0, LLONG_MAX);
@@ -526,8 +509,7 @@ int32_t ec_manager_fsyncdir(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.fsyncdir != NULL)
-            {
+            if (fop->cbks.fsyncdir != NULL) {
                 fop->cbks.fsyncdir(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                    cbk->op_errno, cbk->xdata);
             }
@@ -542,10 +524,9 @@ int32_t ec_manager_fsyncdir(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_DELAYED_START:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.fsyncdir != NULL)
-            {
-                fop->cbks.fsyncdir(fop->req_frame, fop, fop->xl, -1,
-                                   fop->error, NULL);
+            if (fop->cbks.fsyncdir != NULL) {
+                fop->cbks.fsyncdir(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                   NULL);
             }
 
             return EC_STATE_LOCK_REUSE;
@@ -563,31 +544,31 @@ int32_t ec_manager_fsyncdir(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_fsyncdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_fsyncdir_cbk_t func, void * data,
-                 fd_t * fd, int32_t datasync, dict_t * xdata)
+void
+ec_fsyncdir(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_fsyncdir_cbk_t func, void *data, fd_t *fd,
+            int32_t datasync, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fsyncdir = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fsyncdir = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FSYNCDIR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FSYNCDIR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FSYNCDIR, 0, target,
-                               minimum, ec_wind_fsyncdir, ec_manager_fsyncdir,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_FSYNCDIR, 0, target, minimum,
+                               ec_wind_fsyncdir, ec_manager_fsyncdir, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -599,9 +580,9 @@ void ec_fsyncdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -609,9 +590,9 @@ void ec_fsyncdir(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -629,9 +610,10 @@ out:
 
 /* FOP: lookup */
 
-void ec_lookup_rebuild(ec_t * ec, ec_fop_data_t * fop, ec_cbk_data_t * cbk)
+void
+ec_lookup_rebuild(ec_t *ec, ec_fop_data_t *fop, ec_cbk_data_t *cbk)
 {
-    ec_inode_t * ctx = NULL;
+    ec_inode_t *ctx = NULL;
     uint64_t size = 0;
     int32_t have_size = 0, err;
 
@@ -650,8 +632,7 @@ void ec_lookup_rebuild(ec_t * ec, ec_fop_data_t * fop, ec_cbk_data_t * cbk)
     LOCK(&cbk->inode->lock);
 
     ctx = __ec_inode_get(cbk->inode, fop->xl);
-    if (ctx != NULL)
-    {
+    if (ctx != NULL) {
         if (ctx->have_version) {
             cbk->version[0] = ctx->post_version[0];
             cbk->version[1] = ctx->post_version[1];
@@ -664,24 +645,22 @@ void ec_lookup_rebuild(ec_t * ec, ec_fop_data_t * fop, ec_cbk_data_t * cbk)
 
     UNLOCK(&cbk->inode->lock);
 
-    if (cbk->iatt[0].ia_type == IA_IFREG)
-    {
+    if (cbk->iatt[0].ia_type == IA_IFREG) {
         cbk->size = cbk->iatt[0].ia_size;
         ec_dict_del_number(cbk->xdata, EC_XATTR_SIZE, &cbk->iatt[0].ia_size);
-        if (have_size)
-        {
+        if (have_size) {
             cbk->iatt[0].ia_size = size;
         }
     }
 }
 
-int32_t ec_combine_lookup(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                          ec_cbk_data_t * src)
+int32_t
+ec_combine_lookup(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
     if (!ec_iatt_combine(fop, dst->iatt, src->iatt, 2)) {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_IATT_MISMATCH, "Mismatching iatt in "
-                                             "answers of 'GF_FOP_LOOKUP'");
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of 'GF_FOP_LOOKUP'");
 
         return 0;
     }
@@ -689,15 +668,15 @@ int32_t ec_combine_lookup(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_lookup_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                      int32_t op_ret, int32_t op_errno, inode_t * inode,
-                      struct iatt * buf, dict_t * xdata,
-                      struct iatt * postparent)
+int32_t
+ec_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+              struct iatt *postparent)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
-    uint64_t       dirty[2] = {0};
+    uint64_t dirty[2] = {0};
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -706,63 +685,54 @@ int32_t ec_lookup_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_LOOKUP, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (inode != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (inode != NULL) {
                 cbk->inode = inode_ref(inode);
-                if (cbk->inode == NULL)
-                {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_INODE_REF_FAIL,
-                            "Failed to reference an inode.");
+                if (cbk->inode == NULL) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_INODE_REF_FAIL,
+                           "Failed to reference an inode.");
 
                     goto out;
                 }
             }
-            if (buf != NULL)
-            {
+            if (buf != NULL) {
                 cbk->iatt[0] = *buf;
             }
-            if (postparent != NULL)
-            {
+            if (postparent != NULL) {
                 cbk->iatt[1] = *postparent;
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
-            ec_dict_del_array (xdata, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
+            ec_dict_del_array(xdata, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
         }
 
         ec_combine(cbk, ec_combine_lookup);
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_lookup(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_lookup(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -771,20 +741,21 @@ void ec_wind_lookup(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->xdata);
 }
 
-int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_lookup(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk;
     int32_t err;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             if (fop->xdata == NULL) {
                 fop->xdata = dict_new();
                 if (fop->xdata == NULL) {
-                    gf_msg (fop->xl->name, GF_LOG_ERROR, ENOMEM,
-                            EC_MSG_LOOKUP_REQ_PREP_FAIL, "Unable to prepare "
-                            "lookup request");
+                    gf_msg(fop->xl->name, GF_LOG_ERROR, ENOMEM,
+                           EC_MSG_LOOKUP_REQ_PREP_FAIL,
+                           "Unable to prepare "
+                           "lookup request");
 
                     fop->error = ENOMEM;
 
@@ -792,7 +763,7 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
                 }
             } else {
                 /*TODO: To be handled once we have 'syndromes' */
-                dict_del (fop->xdata, GF_CONTENT_KEY);
+                dict_del(fop->xdata, GF_CONTENT_KEY);
             }
             err = dict_set_uint64(fop->xdata, EC_XATTR_SIZE, 0);
             if (err == 0) {
@@ -802,16 +773,17 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
                 err = dict_set_uint64(fop->xdata, EC_XATTR_DIRTY, 0);
             }
             if (err != 0) {
-                gf_msg (fop->xl->name, GF_LOG_ERROR, -err,
-                        EC_MSG_LOOKUP_REQ_PREP_FAIL, "Unable to prepare lookup "
-                                                    "request");
+                gf_msg(fop->xl->name, GF_LOG_ERROR, -err,
+                       EC_MSG_LOOKUP_REQ_PREP_FAIL,
+                       "Unable to prepare lookup "
+                       "request");
 
                 fop->error = -err;
 
                 return EC_STATE_REPORT;
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -827,8 +799,8 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
              */
 
             if (!fop->answer && !list_empty(&fop->cbk_list)) {
-                fop->answer = list_entry (fop->cbk_list.next, ec_cbk_data_t,
-                                          list);
+                fop->answer = list_entry(fop->cbk_list.next, ec_cbk_data_t,
+                                         list);
             }
 
             cbk = ec_fop_prepare_answer(fop, _gf_true);
@@ -845,8 +817,7 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.lookup != NULL)
-            {
+            if (fop->cbks.lookup != NULL) {
                 fop->cbks.lookup(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                  cbk->op_errno, cbk->inode, &cbk->iatt[0],
                                  cbk->xdata, &cbk->iatt[1]);
@@ -860,8 +831,7 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.lookup != NULL)
-            {
+            if (fop->cbks.lookup != NULL) {
                 fop->cbks.lookup(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL, NULL, NULL);
             }
@@ -869,23 +839,23 @@ int32_t ec_manager_lookup(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_lookup(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_lookup_cbk_t func, void * data,
-               loc_t * loc, dict_t * xdata)
+void
+ec_lookup(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_lookup_cbk_t func, void *data, loc_t *loc,
+          dict_t *xdata)
 {
-    ec_cbk_t callback = { .lookup = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.lookup = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(LOOKUP) %p", frame);
+    gf_msg_trace("ec", 0, "EC(LOOKUP) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -900,14 +870,14 @@ void ec_lookup(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         /* Do not log failures here as a memory problem would have already
          * been logged by the corresponding alloc functions */
         if (fop->xdata == NULL)
@@ -926,20 +896,20 @@ out:
 
 /* FOP: statfs */
 
-int32_t ec_combine_statfs(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                          ec_cbk_data_t * src)
+int32_t
+ec_combine_statfs(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
     ec_statvfs_combine(&dst->statvfs, &src->statvfs);
 
     return 1;
 }
 
-int32_t ec_statfs_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                      int32_t op_ret, int32_t op_errno, struct statvfs * buf,
-                      dict_t * xdata)
+int32_t
+ec_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -949,28 +919,23 @@ int32_t ec_statfs_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_STATFS, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (buf != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (buf != NULL) {
                 cbk->statvfs = *buf;
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -980,15 +945,15 @@ int32_t ec_statfs_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_statfs(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_statfs(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -997,14 +962,14 @@ void ec_wind_statfs(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->xdata);
 }
 
-int32_t ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t   *cbk                   = NULL;
-    gf_boolean_t     deem_statfs_enabled   = _gf_false;
-    int32_t          err                   = 0;
+    ec_cbk_data_t *cbk = NULL;
+    gf_boolean_t deem_statfs_enabled = _gf_false;
+    int32_t err = 0;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -1017,8 +982,8 @@ int32_t ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
                 ec_t *ec = fop->xl->private;
 
                 if (cbk->xdata) {
-                    err = dict_get_int8 (cbk->xdata, "quota-deem-statfs",
-                                          (int8_t *)&deem_statfs_enabled);
+                    err = dict_get_int8(cbk->xdata, "quota-deem-statfs",
+                                        (int8_t *)&deem_statfs_enabled);
                     if (err != -ENOENT) {
                         ec_cbk_set_error(cbk, -err, _gf_true);
                     }
@@ -1038,8 +1003,7 @@ int32_t ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.statfs != NULL)
-            {
+            if (fop->cbks.statfs != NULL) {
                 fop->cbks.statfs(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                  cbk->op_errno, &cbk->statvfs, cbk->xdata);
             }
@@ -1052,8 +1016,7 @@ int32_t ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.statfs != NULL)
-            {
+            if (fop->cbks.statfs != NULL) {
                 fop->cbks.statfs(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL);
             }
@@ -1061,23 +1024,23 @@ int32_t ec_manager_statfs(ec_fop_data_t *fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_statfs(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_statfs_cbk_t func, void * data,
-               loc_t * loc, dict_t * xdata)
+void
+ec_statfs(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_statfs_cbk_t func, void *data, loc_t *loc,
+          dict_t *xdata)
 {
-    ec_cbk_t callback = { .statfs = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.statfs = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(STATFS) %p", frame);
+    gf_msg_trace("ec", 0, "EC(STATFS) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1092,8 +1055,8 @@ void ec_statfs(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1101,9 +1064,9 @@ void ec_statfs(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1121,14 +1084,13 @@ out:
 
 /* FOP: xattrop */
 
-int32_t ec_combine_xattrop(ec_fop_data_t *fop, ec_cbk_data_t *dst,
-                           ec_cbk_data_t *src)
+int32_t
+ec_combine_xattrop(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (!ec_dict_compare(dst->dict, src->dict))
-    {
-        gf_msg (fop->xl->name, GF_LOG_DEBUG, 0,
-                EC_MSG_DICT_MISMATCH, "Mismatching dictionary in "
-                                             "answers of 'GF_FOP_XATTROP'");
+    if (!ec_dict_compare(dst->dict, src->dict)) {
+        gf_msg(fop->xl->name, GF_LOG_DEBUG, 0, EC_MSG_DICT_MISMATCH,
+               "Mismatching dictionary in "
+               "answers of 'GF_FOP_XATTROP'");
 
         return 0;
     }
@@ -1137,72 +1099,71 @@ int32_t ec_combine_xattrop(ec_fop_data_t *fop, ec_cbk_data_t *dst,
 }
 
 int32_t
-ec_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *xattr,
-                dict_t *xdata)
+ec_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
-        ec_fop_data_t *fop = NULL;
-        ec_lock_link_t *link = NULL;
-        ec_cbk_data_t *cbk = NULL;
-        uint64_t       dirty[2] = {0};
-        data_t *data;
-        uint64_t *version;
-        int32_t idx = (int32_t)(uintptr_t)cookie;
-
-        VALIDATE_OR_GOTO (this, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
-
-        fop = frame->local;
-
-        ec_trace ("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-                  frame, op_ret, op_errno);
-
-        cbk = ec_cbk_data_allocate (frame, this, fop, fop->id, idx, op_ret,
-                                    op_errno);
-        if (!cbk)
-                goto out;
+    ec_fop_data_t *fop = NULL;
+    ec_lock_link_t *link = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    uint64_t dirty[2] = {0};
+    data_t *data;
+    uint64_t *version;
+    int32_t idx = (int32_t)(uintptr_t)cookie;
 
-        if (op_ret >= 0) {
-                cbk->dict = dict_ref (xattr);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-                data = dict_get(cbk->dict, EC_XATTR_VERSION);
-                if ((data != NULL) && (data->len >= sizeof(uint64_t))) {
-                    version = (uint64_t *)data->data;
+    fop = frame->local;
 
-                    if (((ntoh64(version[0]) >> EC_SELFHEAL_BIT) & 1) != 0) {
-                            LOCK(&fop->lock);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-                            fop->healing |= 1ULL << idx;
+    cbk = ec_cbk_data_allocate(frame, this, fop, fop->id, idx, op_ret,
+                               op_errno);
+    if (!cbk)
+        goto out;
 
-                            UNLOCK(&fop->lock);
-                    }
-                }
+    if (op_ret >= 0) {
+        cbk->dict = dict_ref(xattr);
 
-                ec_dict_del_array (xattr, EC_XATTR_DIRTY, dirty,
-                                   EC_VERSION_SIZE);
-                link = fop->data;
-                if (link) {
-                        /*Keep a note of if the dirty is already set or not*/
-                        link->dirty[0] |= (dirty[0] != 0);
-                        link->dirty[1] |= (dirty[1] != 0);
-                }
+        data = dict_get(cbk->dict, EC_XATTR_VERSION);
+        if ((data != NULL) && (data->len >= sizeof(uint64_t))) {
+            version = (uint64_t *)data->data;
+
+            if (((ntoh64(version[0]) >> EC_SELFHEAL_BIT) & 1) != 0) {
+                LOCK(&fop->lock);
+
+                fop->healing |= 1ULL << idx;
+
+                UNLOCK(&fop->lock);
+            }
+        }
+
+        ec_dict_del_array(xattr, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
+        link = fop->data;
+        if (link) {
+            /*Keep a note of if the dirty is already set or not*/
+            link->dirty[0] |= (dirty[0] != 0);
+            link->dirty[1] |= (dirty[1] != 0);
         }
+    }
 
-        if (xdata)
-                cbk->xdata = dict_ref(xdata);
+    if (xdata)
+        cbk->xdata = dict_ref(xdata);
 
-        ec_combine (cbk, ec_combine_xattrop);
+    ec_combine(cbk, ec_combine_xattrop);
 
 out:
-        if (fop)
-            ec_complete(fop);
+    if (fop)
+        ec_complete(fop);
 
-        return 0;
+    return 0;
 }
 
-void ec_wind_xattrop(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_xattrop(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1211,20 +1172,19 @@ void ec_wind_xattrop(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->xattrop_flags, fop->dict, fop->xdata);
 }
 
-int32_t ec_manager_xattrop(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_xattrop(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0], EC_UPDATE_META, 0,
                                       LLONG_MAX);
             } else {
-                ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META, 0,
-                                   LLONG_MAX);
+                ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META, 0, LLONG_MAX);
             }
             ec_lock(fop);
 
@@ -1251,19 +1211,13 @@ int32_t ec_manager_xattrop(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_XATTROP)
-            {
-                if (fop->cbks.xattrop != NULL)
-                {
-                    fop->cbks.xattrop(fop->req_frame, fop, fop->xl,
-                                      cbk->op_ret, cbk->op_errno, cbk->dict,
-                                      cbk->xdata);
+            if (fop->id == GF_FOP_XATTROP) {
+                if (fop->cbks.xattrop != NULL) {
+                    fop->cbks.xattrop(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                      cbk->op_errno, cbk->dict, cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fxattrop != NULL)
-                {
+            } else {
+                if (fop->cbks.fxattrop != NULL) {
                     fop->cbks.fxattrop(fop->req_frame, fop, fop->xl,
                                        cbk->op_ret, cbk->op_errno, cbk->dict,
                                        cbk->xdata);
@@ -1279,18 +1233,13 @@ int32_t ec_manager_xattrop(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_XATTROP)
-            {
-                if (fop->cbks.xattrop != NULL)
-                {
+            if (fop->id == GF_FOP_XATTROP) {
+                if (fop->cbks.xattrop != NULL) {
                     fop->cbks.xattrop(fop->req_frame, fop, fop->xl, -1,
                                       fop->error, NULL, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fxattrop != NULL)
-                {
+            } else {
+                if (fop->cbks.fxattrop != NULL) {
                     fop->cbks.fxattrop(fop->req_frame, fop, fop->xl, -1,
                                        fop->error, NULL, NULL);
                 }
@@ -1311,24 +1260,23 @@ int32_t ec_manager_xattrop(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_xattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_xattrop_cbk_t func, void * data,
-                loc_t * loc, gf_xattrop_flags_t optype, dict_t * xattr,
-                dict_t * xdata)
+void
+ec_xattrop(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_xattrop_cbk_t func, void *data, loc_t *loc,
+           gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-    ec_cbk_t callback = { .xattrop = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.xattrop = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(XATTROP) %p", frame);
+    gf_msg_trace("ec", 0, "EC(XATTROP) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1345,8 +1293,8 @@ void ec_xattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1354,9 +1302,9 @@ void ec_xattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xattr != NULL) {
         fop->dict = dict_ref(xattr);
         if (fop->dict == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1364,9 +1312,9 @@ void ec_xattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1382,7 +1330,8 @@ out:
     }
 }
 
-void ec_wind_fxattrop(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fxattrop(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1391,24 +1340,24 @@ void ec_wind_fxattrop(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->xattrop_flags, fop->dict, fop->xdata);
 }
 
-void ec_fxattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_fxattrop_cbk_t func, void * data,
-                 fd_t * fd, gf_xattrop_flags_t optype, dict_t * xattr,
-                 dict_t * xdata)
+void
+ec_fxattrop(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_fxattrop_cbk_t func, void *data, fd_t *fd,
+            gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fxattrop = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fxattrop = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FXATTROP) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FXATTROP) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FXATTROP, 0, target,
-                               minimum, ec_wind_fxattrop, ec_manager_xattrop,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_FXATTROP, 0, target, minimum,
+                               ec_wind_fxattrop, ec_manager_xattrop, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -1420,9 +1369,9 @@ void ec_fxattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -1430,9 +1379,9 @@ void ec_fxattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xattr != NULL) {
         fop->dict = dict_ref(xattr);
         if (fop->dict == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1440,9 +1389,9 @@ void ec_fxattrop(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1460,11 +1409,12 @@ out:
 
 /* FOP: IPC */
 
-int32_t ec_ipc_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                   int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+           int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -1474,16 +1424,14 @@ int32_t ec_ipc_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_IPC, idx, op_ret,
                                op_errno);
 
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
         }
 
@@ -1491,29 +1439,29 @@ int32_t ec_ipc_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_ipc(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_ipc(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
     STACK_WIND_COOKIE(fop->frame, ec_ipc_cbk, (void *)(uintptr_t)idx,
-                      ec->xl_list[idx], ec->xl_list[idx]->fops->ipc,
-                      fop->int32, fop->xdata);
+                      ec->xl_list[idx], ec->xl_list[idx]->fops->ipc, fop->int32,
+                      fop->xdata);
 }
 
-int32_t ec_manager_ipc(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_ipc(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -1529,10 +1477,9 @@ int32_t ec_manager_ipc(ec_fop_data_t *fop, int32_t state)
             cbk = fop->answer;
 
             GF_ASSERT(cbk != NULL);
-            if (fop->cbks.ipc != NULL)
-            {
+            if (fop->cbks.ipc != NULL) {
                 fop->cbks.ipc(fop->req_frame, fop, fop->xl, cbk->op_ret,
-                               cbk->op_errno, cbk->xdata);
+                              cbk->op_errno, cbk->xdata);
             }
 
             return EC_STATE_END;
@@ -1543,8 +1490,7 @@ int32_t ec_manager_ipc(ec_fop_data_t *fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.ipc != NULL)
-            {
+            if (fop->cbks.ipc != NULL) {
                 fop->cbks.ipc(fop->req_frame, fop, fop->xl, -1, fop->error,
                               NULL);
             }
@@ -1552,23 +1498,22 @@ int32_t ec_manager_ipc(ec_fop_data_t *fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_ipc(call_frame_t *frame, xlator_t *this, uintptr_t target,
-            int32_t minimum, fop_ipc_cbk_t func, void *data, int32_t op,
-            dict_t *xdata)
+void
+ec_ipc(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+       fop_ipc_cbk_t func, void *data, int32_t op, dict_t *xdata)
 {
-    ec_cbk_t callback = { .ipc = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.ipc = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(IPC) %p", frame);
+    gf_msg_trace("ec", 0, "EC(IPC) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
diff --git a/xlators/cluster/ec/src/ec-gf8.c b/xlators/cluster/ec/src/ec-gf8.c
index 2665632706b..039adae5929 100644
--- a/xlators/cluster/ec/src/ec-gf8.c
+++ b/xlators/cluster/ec/src/ec-gf8.c
@@ -10,5886 +10,5810 @@
 
 #include "ec-gf8.h"
 
-static ec_gf_op_t ec_gf8_mul_00_ops[] = {
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_00 = {
-    0,
-    { 0, },
-    ec_gf8_mul_00_ops
-};
-
-static ec_gf_op_t ec_gf8_mul_01_ops[] = {
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_01 = {
-    8,
-    { 0, 1, 2, 3, 4, 5, 6, 7, },
-    ec_gf8_mul_01_ops
-};
-
-static ec_gf_op_t ec_gf8_mul_02_ops[] = {
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_02 = {
-    8,
-    { 7, 0, 1, 2, 3, 4, 5, 6, },
-    ec_gf8_mul_02_ops
-};
+static ec_gf_op_t ec_gf8_mul_00_ops[] = {{EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_00 = {0,
+                                    {
+                                        0,
+                                    },
+                                    ec_gf8_mul_00_ops};
+
+static ec_gf_op_t ec_gf8_mul_01_ops[] = {{EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_01 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_01_ops};
+
+static ec_gf_op_t ec_gf8_mul_02_ops[] = {{EC_GF_OP_XOR2, 1, 7, 0},
+                                         {EC_GF_OP_XOR2, 2, 7, 0},
+                                         {EC_GF_OP_XOR2, 3, 7, 0},
+                                         {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_02 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_02_ops};
 
 static ec_gf_op_t ec_gf8_mul_03_ops[] = {
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_03 = {
-    9,
-    { 0, 1, 2, 3, 4, 5, 6, 7, 8, },
-    ec_gf8_mul_03_ops
-};
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_COPY, 8, 3, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_03 = {9,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_03_ops};
 
 static ec_gf_op_t ec_gf8_mul_04_ops[] = {
-    { EC_GF_OP_XOR3,   8,  6,  7 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_04 = {
-    9,
-    { 6, 7, 0, 1, 2, 3, 4, 5, 8, },
-    ec_gf8_mul_04_ops
-};
+    {EC_GF_OP_XOR3, 8, 6, 7}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_04 = {9,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_04_ops};
 
 static ec_gf_op_t ec_gf8_mul_05_ops[] = {
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_05 = {
-    8,
-    { 0, 1, 2, 6, 7, 3, 4, 5, },
-    ec_gf8_mul_05_ops
-};
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_05 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        6,
+                                        7,
+                                        3,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_05_ops};
 
 static ec_gf_op_t ec_gf8_mul_06_ops[] = {
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_COPY,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_06 = {
-    9,
-    { 7, 0, 1, 2, 8, 3, 4, 5, 6, },
-    ec_gf8_mul_06_ops
-};
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_COPY, 8, 2, 0},
+    {EC_GF_OP_XOR2, 8, 3, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_06 = {9,
+                                    {
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        8,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_06_ops};
 
 static ec_gf_op_t ec_gf8_mul_07_ops[] = {
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_07 = {
-    8,
-    { 6, 0, 1, 3, 2, 4, 5, 7, },
-    ec_gf8_mul_07_ops
-};
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_07 = {8,
+                                    {
+                                        6,
+                                        0,
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        5,
+                                        7,
+                                    },
+                                    ec_gf8_mul_07_ops};
 
 static ec_gf_op_t ec_gf8_mul_08_ops[] = {
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  7 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_08 = {
-    9,
-    { 5, 6, 7, 0, 1, 2, 3, 4, 8, },
-    ec_gf8_mul_08_ops
-};
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR3, 8, 6, 7},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_08 = {9,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        8,
+                                    },
+                                    ec_gf8_mul_08_ops};
 
 static ec_gf_op_t ec_gf8_mul_09_ops[] = {
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_09 = {
-    8,
-    { 0, 1, 2, 3, 5, 6, 7, 4, },
-    ec_gf8_mul_09_ops
-};
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_09 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        6,
+                                        7,
+                                        4,
+                                    },
+                                    ec_gf8_mul_09_ops};
 
 static ec_gf_op_t ec_gf8_mul_0A_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0A = {
-    8,
-    { 5, 0, 1, 2, 6, 7, 3, 4, },
-    ec_gf8_mul_0A_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0A = {8,
+                                    {
+                                        5,
+                                        0,
+                                        1,
+                                        2,
+                                        6,
+                                        7,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_0A_ops};
 
 static ec_gf_op_t ec_gf8_mul_0B_ops[] = {
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_COPY,   9,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_COPY,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR3,   3,  8,  6 },
-    { EC_GF_OP_XOR2,   1,  9,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0B = {
-    10,
-    { 7, 1, 5, 2, 4, 3, 0, 6, 8, 9, },
-    ec_gf8_mul_0B_ops
-};
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_COPY, 9, 3, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_COPY, 8, 5, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR3, 3, 8, 6}, {EC_GF_OP_XOR2, 1, 9, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0B = {10,
+                                    {
+                                        7,
+                                        1,
+                                        5,
+                                        2,
+                                        4,
+                                        3,
+                                        0,
+                                        6,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_0B_ops};
 
 static ec_gf_op_t ec_gf8_mul_0C_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0C = {
-    9,
-    { 5, 7, 0, 1, 8, 2, 3, 4, 6, },
-    ec_gf8_mul_0C_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_COPY, 8, 1, 0},
+    {EC_GF_OP_XOR2, 8, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0C = {9,
+                                    {
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                        8,
+                                        2,
+                                        3,
+                                        4,
+                                        6,
+                                    },
+                                    ec_gf8_mul_0C_ops};
 
 static ec_gf_op_t ec_gf8_mul_0D_ops[] = {
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR3,   8,  2,  4 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR3,   2,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0D = {
-    9,
-    { 5, 6, 7, 3, 1, 0, 2, 4, 8, },
-    ec_gf8_mul_0D_ops
-};
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR3, 8, 2, 4}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR3, 2, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0D = {9,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                        1,
+                                        0,
+                                        2,
+                                        4,
+                                        8,
+                                    },
+                                    ec_gf8_mul_0D_ops};
 
 static ec_gf_op_t ec_gf8_mul_0E_ops[] = {
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0E = {
-    8,
-    { 7, 0, 6, 1, 3, 2, 4, 5, },
-    ec_gf8_mul_0E_ops
-};
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0E = {8,
+                                    {
+                                        7,
+                                        0,
+                                        6,
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_0E_ops};
 
 static ec_gf_op_t ec_gf8_mul_0F_ops[] = {
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_0F = {
-    8,
-    { 1, 0, 5, 6, 7, 2, 3, 4, },
-    ec_gf8_mul_0F_ops
-};
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_0F = {8,
+                                    {
+                                        1,
+                                        0,
+                                        5,
+                                        6,
+                                        7,
+                                        2,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_0F_ops};
 
 static ec_gf_op_t ec_gf8_mul_10_ops[] = {
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_10 = {
-    8,
-    { 4, 5, 6, 7, 0, 1, 2, 3, },
-    ec_gf8_mul_10_ops
-};
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_10 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_10_ops};
 
 static ec_gf_op_t ec_gf8_mul_11_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_11 = {
-    8,
-    { 4, 1, 2, 6, 0, 5, 7, 3, },
-    ec_gf8_mul_11_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_11 = {8,
+                                    {
+                                        4,
+                                        1,
+                                        2,
+                                        6,
+                                        0,
+                                        5,
+                                        7,
+                                        3,
+                                    },
+                                    ec_gf8_mul_11_ops};
 
 static ec_gf_op_t ec_gf8_mul_12_ops[] = {
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_12 = {
-    8,
-    { 7, 0, 1, 2, 3, 5, 6, 4, },
-    ec_gf8_mul_12_ops
-};
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_12 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        6,
+                                        4,
+                                    },
+                                    ec_gf8_mul_12_ops};
 
 static ec_gf_op_t ec_gf8_mul_13_ops[] = {
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  7 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_13 = {
-    9,
-    { 4, 5, 2, 6, 0, 1, 7, 3, 8, },
-    ec_gf8_mul_13_ops
-};
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR3, 8, 3, 7},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 6, 8, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 0, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_13 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        2,
+                                        6,
+                                        0,
+                                        1,
+                                        7,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_13_ops};
 
 static ec_gf_op_t ec_gf8_mul_14_ops[] = {
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_14 = {
-    8,
-    { 6, 7, 0, 1, 2, 4, 5, 3, },
-    ec_gf8_mul_14_ops
-};
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_14 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        5,
+                                        3,
+                                    },
+                                    ec_gf8_mul_14_ops};
 
 static ec_gf_op_t ec_gf8_mul_15_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR3,   5,  8,  7 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_15 = {
-    9,
-    { 0, 1, 2, 4, 7, 6, 5, 3, 8, },
-    ec_gf8_mul_15_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR3, 5, 8, 7},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_15 = {9,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        7,
+                                        6,
+                                        5,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_15_ops};
 
 static ec_gf_op_t ec_gf8_mul_16_ops[] = {
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_16 = {
-    8,
-    { 6, 7, 4, 1, 2, 3, 5, 0, },
-    ec_gf8_mul_16_ops
-};
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_16 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        4,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        0,
+                                    },
+                                    ec_gf8_mul_16_ops};
 
 static ec_gf_op_t ec_gf8_mul_17_ops[] = {
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_17 = {
-    8,
-    { 5, 7, 0, 1, 3, 2, 4, 6, },
-    ec_gf8_mul_17_ops
-};
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_17 = {8,
+                                    {
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        6,
+                                    },
+                                    ec_gf8_mul_17_ops};
 
 static ec_gf_op_t ec_gf8_mul_18_ops[] = {
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_18 = {
-    9,
-    { 4, 5, 7, 6, 0, 1, 2, 3, 8, },
-    ec_gf8_mul_18_ops
-};
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_18 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        7,
+                                        6,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_18_ops};
 
 static ec_gf_op_t ec_gf8_mul_19_ops[] = {
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_19 = {
-    8,
-    { 0, 5, 2, 6, 7, 1, 3, 4, },
-    ec_gf8_mul_19_ops
-};
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_19 = {8,
+                                    {
+                                        0,
+                                        5,
+                                        2,
+                                        6,
+                                        7,
+                                        1,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_19_ops};
 
 static ec_gf_op_t ec_gf8_mul_1A_ops[] = {
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1A = {
-    8,
-    { 7, 0, 4, 5, 3, 1, 2, 6, },
-    ec_gf8_mul_1A_ops
-};
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1A = {8,
+                                    {
+                                        7,
+                                        0,
+                                        4,
+                                        5,
+                                        3,
+                                        1,
+                                        2,
+                                        6,
+                                    },
+                                    ec_gf8_mul_1A_ops};
 
 static ec_gf_op_t ec_gf8_mul_1B_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1B = {
-    8,
-    { 7, 4, 5, 6, 3, 1, 2, 0, },
-    ec_gf8_mul_1B_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1B = {8,
+                                    {
+                                        7,
+                                        4,
+                                        5,
+                                        6,
+                                        3,
+                                        1,
+                                        2,
+                                        0,
+                                    },
+                                    ec_gf8_mul_1B_ops};
 
 static ec_gf_op_t ec_gf8_mul_1C_ops[] = {
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1C = {
-    8,
-    { 5, 4, 3, 0, 1, 7, 2, 6, },
-    ec_gf8_mul_1C_ops
-};
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1C = {8,
+                                    {
+                                        5,
+                                        4,
+                                        3,
+                                        0,
+                                        1,
+                                        7,
+                                        2,
+                                        6,
+                                    },
+                                    ec_gf8_mul_1C_ops};
 
 static ec_gf_op_t ec_gf8_mul_1D_ops[] = {
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  2 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1D = {
-    9,
-    { 0, 7, 5, 8, 2, 3, 4, 1, 6, },
-    ec_gf8_mul_1D_ops
-};
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR3, 8, 4, 2},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1D = {9,
+                                    {
+                                        0,
+                                        7,
+                                        5,
+                                        8,
+                                        2,
+                                        3,
+                                        4,
+                                        1,
+                                        6,
+                                    },
+                                    ec_gf8_mul_1D_ops};
 
 static ec_gf_op_t ec_gf8_mul_1E_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1E = {
-    8,
-    { 4, 7, 5, 1, 6, 0, 2, 3, },
-    ec_gf8_mul_1E_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1E = {8,
+                                    {
+                                        4,
+                                        7,
+                                        5,
+                                        1,
+                                        6,
+                                        0,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_1E_ops};
 
 static ec_gf_op_t ec_gf8_mul_1F_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  7 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_1F = {
-    9,
-    { 1, 4, 5, 6, 7, 0, 3, 2, 8, },
-    ec_gf8_mul_1F_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR3, 8, 3, 7},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_1F = {9,
+                                    {
+                                        1,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        3,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_1F_ops};
 
 static ec_gf_op_t ec_gf8_mul_20_ops[] = {
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_20 = {
-    8,
-    { 7, 4, 5, 6, 3, 0, 1, 2, },
-    ec_gf8_mul_20_ops
-};
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_20 = {8,
+                                    {
+                                        7,
+                                        4,
+                                        5,
+                                        6,
+                                        3,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_20_ops};
 
 static ec_gf_op_t ec_gf8_mul_21_ops[] = {
-    { EC_GF_OP_COPY,   9,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  7,  5 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  9,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_21 = {
-    10,
-    { 0, 1, 2, 7, 5, 4, 3, 6, 8, 9, },
-    ec_gf8_mul_21_ops
-};
+    {EC_GF_OP_COPY, 9, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR3, 8, 7, 5}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 4, 9, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_21 = {10,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        7,
+                                        5,
+                                        4,
+                                        3,
+                                        6,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_21_ops};
 
 static ec_gf_op_t ec_gf8_mul_22_ops[] = {
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_22 = {
-    8,
-    { 3, 0, 5, 2, 6, 4, 1, 7, },
-    ec_gf8_mul_22_ops
-};
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_22 = {8,
+                                    {
+                                        3,
+                                        0,
+                                        5,
+                                        2,
+                                        6,
+                                        4,
+                                        1,
+                                        7,
+                                    },
+                                    ec_gf8_mul_22_ops};
 
 static ec_gf_op_t ec_gf8_mul_23_ops[] = {
-    { EC_GF_OP_COPY,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_23 = {
-    9,
-    { 0, 4, 3, 2, 5, 6, 1, 8, 7, },
-    ec_gf8_mul_23_ops
-};
+    {EC_GF_OP_COPY, 8, 2, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_23 = {9,
+                                    {
+                                        0,
+                                        4,
+                                        3,
+                                        2,
+                                        5,
+                                        6,
+                                        1,
+                                        8,
+                                        7,
+                                    },
+                                    ec_gf8_mul_23_ops};
 
 static ec_gf_op_t ec_gf8_mul_24_ops[] = {
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_24 = {
-    8,
-    { 6, 7, 0, 1, 2, 4, 5, 3, },
-    ec_gf8_mul_24_ops
-};
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_24 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        5,
+                                        3,
+                                    },
+                                    ec_gf8_mul_24_ops};
 
 static ec_gf_op_t ec_gf8_mul_25_ops[] = {
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_25 = {
-    8,
-    { 2, 7, 0, 1, 3, 4, 5, 6, },
-    ec_gf8_mul_25_ops
-};
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_25 = {8,
+                                    {
+                                        2,
+                                        7,
+                                        0,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_25_ops};
 
 static ec_gf_op_t ec_gf8_mul_26_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_26 = {
-    8,
-    { 3, 4, 1, 2, 0, 5, 6, 7, },
-    ec_gf8_mul_26_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_26 = {8,
+                                    {
+                                        3,
+                                        4,
+                                        1,
+                                        2,
+                                        0,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_26_ops};
 
 static ec_gf_op_t ec_gf8_mul_27_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_27 = {
-    8,
-    { 3, 0, 1, 2, 6, 7, 4, 5, },
-    ec_gf8_mul_27_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_27 = {8,
+                                    {
+                                        3,
+                                        0,
+                                        1,
+                                        2,
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_27_ops};
 
 static ec_gf_op_t ec_gf8_mul_28_ops[] = {
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_28 = {
-    8,
-    { 5, 6, 3, 0, 1, 2, 4, 7, },
-    ec_gf8_mul_28_ops
-};
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_28 = {8,
+                                    {
+                                        5,
+                                        6,
+                                        3,
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        7,
+                                    },
+                                    ec_gf8_mul_28_ops};
 
 static ec_gf_op_t ec_gf8_mul_29_ops[] = {
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_29 = {
-    8,
-    { 4, 6, 3, 5, 7, 0, 1, 2, },
-    ec_gf8_mul_29_ops
-};
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_29 = {8,
+                                    {
+                                        4,
+                                        6,
+                                        3,
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_29_ops};
 
 static ec_gf_op_t ec_gf8_mul_2A_ops[] = {
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR3,   6,  8,  4 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2A = {
-    9,
-    { 3, 4, 7, 2, 6, 5, 1, 0, 8, },
-    ec_gf8_mul_2A_ops
-};
+    {EC_GF_OP_COPY, 8, 1, 0}, {EC_GF_OP_XOR2, 8, 0, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR3, 6, 8, 4}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2A = {9,
+                                    {
+                                        3,
+                                        4,
+                                        7,
+                                        2,
+                                        6,
+                                        5,
+                                        1,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_2A_ops};
 
 static ec_gf_op_t ec_gf8_mul_2B_ops[] = {
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2B = {
-    8,
-    { 3, 4, 7, 5, 6, 0, 1, 2, },
-    ec_gf8_mul_2B_ops
-};
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2B = {8,
+                                    {
+                                        3,
+                                        4,
+                                        7,
+                                        5,
+                                        6,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_2B_ops};
 
 static ec_gf_op_t ec_gf8_mul_2C_ops[] = {
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2C = {
-    8,
-    { 5, 6, 7, 0, 2, 3, 4, 1, },
-    ec_gf8_mul_2C_ops
-};
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2C = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        2,
+                                        3,
+                                        4,
+                                        1,
+                                    },
+                                    ec_gf8_mul_2C_ops};
 
 static ec_gf_op_t ec_gf8_mul_2D_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  6 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2D = {
-    9,
-    { 7, 0, 3, 5, 1, 4, 2, 6, 8, },
-    ec_gf8_mul_2D_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR3, 8, 4, 6},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2D = {9,
+                                    {
+                                        7,
+                                        0,
+                                        3,
+                                        5,
+                                        1,
+                                        4,
+                                        2,
+                                        6,
+                                        8,
+                                    },
+                                    ec_gf8_mul_2D_ops};
 
 static ec_gf_op_t ec_gf8_mul_2E_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_COPY,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2E = {
-    9,
-    { 5, 0, 7, 3, 2, 6, 4, 1, 8, },
-    ec_gf8_mul_2E_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_COPY, 8, 4, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 8, 7, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 8, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2E = {9,
+                                    {
+                                        5,
+                                        0,
+                                        7,
+                                        3,
+                                        2,
+                                        6,
+                                        4,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_2E_ops};
 
 static ec_gf_op_t ec_gf8_mul_2F_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR3,   8,  7,  6 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_2F = {
-    9,
-    { 6, 3, 2, 5, 7, 0, 1, 4, 8, },
-    ec_gf8_mul_2F_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR3, 8, 7, 6}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 2, 8, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_2F = {9,
+                                    {
+                                        6,
+                                        3,
+                                        2,
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                        4,
+                                        8,
+                                    },
+                                    ec_gf8_mul_2F_ops};
 
 static ec_gf_op_t ec_gf8_mul_30_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR3,   6,  8,  7 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_30 = {
-    9,
-    { 3, 4, 7, 5, 0, 6, 1, 2, 8, },
-    ec_gf8_mul_30_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 8, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR3, 6, 8, 7},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_30 = {9,
+                                    {
+                                        3,
+                                        4,
+                                        7,
+                                        5,
+                                        0,
+                                        6,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_30_ops};
 
 static ec_gf_op_t ec_gf8_mul_31_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_31 = {
-    8,
-    { 7, 1, 4, 5, 6, 0, 2, 3, },
-    ec_gf8_mul_31_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_31 = {8,
+                                    {
+                                        7,
+                                        1,
+                                        4,
+                                        5,
+                                        6,
+                                        0,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_31_ops};
 
 static ec_gf_op_t ec_gf8_mul_32_ops[] = {
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_32 = {
-    8,
-    { 3, 4, 6, 7, 5, 0, 1, 2, },
-    ec_gf8_mul_32_ops
-};
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_32 = {8,
+                                    {
+                                        3,
+                                        4,
+                                        6,
+                                        7,
+                                        5,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_32_ops};
 
 static ec_gf_op_t ec_gf8_mul_33_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_33 = {
-    8,
-    { 5, 4, 3, 0, 2, 1, 6, 7, },
-    ec_gf8_mul_33_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_33 = {8,
+                                    {
+                                        5,
+                                        4,
+                                        3,
+                                        0,
+                                        2,
+                                        1,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_33_ops};
 
 static ec_gf_op_t ec_gf8_mul_34_ops[] = {
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_34 = {
-    8,
-    { 7, 5, 3, 0, 2, 4, 1, 6, },
-    ec_gf8_mul_34_ops
-};
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_34 = {8,
+                                    {
+                                        7,
+                                        5,
+                                        3,
+                                        0,
+                                        2,
+                                        4,
+                                        1,
+                                        6,
+                                    },
+                                    ec_gf8_mul_34_ops};
 
 static ec_gf_op_t ec_gf8_mul_35_ops[] = {
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_35 = {
-    8,
-    { 6, 7, 5, 4, 2, 0, 1, 3, },
-    ec_gf8_mul_35_ops
-};
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_35 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        5,
+                                        4,
+                                        2,
+                                        0,
+                                        1,
+                                        3,
+                                    },
+                                    ec_gf8_mul_35_ops};
 
 static ec_gf_op_t ec_gf8_mul_36_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_36 = {
-    8,
-    { 6, 7, 4, 1, 2, 3, 0, 5, },
-    ec_gf8_mul_36_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_36 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        4,
+                                        1,
+                                        2,
+                                        3,
+                                        0,
+                                        5,
+                                    },
+                                    ec_gf8_mul_36_ops};
 
 static ec_gf_op_t ec_gf8_mul_37_ops[] = {
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR3,   8,  0,  1 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_37 = {
-    9,
-    { 6, 7, 2, 1, 0, 3, 4, 5, 8, },
-    ec_gf8_mul_37_ops
-};
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR3, 8, 0, 1},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_37 = {9,
+                                    {
+                                        6,
+                                        7,
+                                        2,
+                                        1,
+                                        0,
+                                        3,
+                                        4,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_37_ops};
 
 static ec_gf_op_t ec_gf8_mul_38_ops[] = {
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  7 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_38 = {
-    9,
-    { 4, 5, 6, 3, 0, 1, 7, 2, 8, },
-    ec_gf8_mul_38_ops
-};
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR3, 8, 6, 7},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_38 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        3,
+                                        0,
+                                        1,
+                                        7,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_38_ops};
 
 static ec_gf_op_t ec_gf8_mul_39_ops[] = {
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_39 = {
-    8,
-    { 1, 6, 3, 0, 5, 2, 4, 7, },
-    ec_gf8_mul_39_ops
-};
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_39 = {8,
+                                    {
+                                        1,
+                                        6,
+                                        3,
+                                        0,
+                                        5,
+                                        2,
+                                        4,
+                                        7,
+                                    },
+                                    ec_gf8_mul_39_ops};
 
 static ec_gf_op_t ec_gf8_mul_3A_ops[] = {
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3A = {
-    8,
-    { 3, 4, 7, 0, 5, 6, 1, 2, },
-    ec_gf8_mul_3A_ops
-};
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3A = {8,
+                                    {
+                                        3,
+                                        4,
+                                        7,
+                                        0,
+                                        5,
+                                        6,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_3A_ops};
 
 static ec_gf_op_t ec_gf8_mul_3B_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR3,   8,  7,  3 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3B = {
-    9,
-    { 3, 0, 1, 7, 6, 2, 4, 8, 5, },
-    ec_gf8_mul_3B_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR3, 8, 7, 3}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3B = {9,
+                                    {
+                                        3,
+                                        0,
+                                        1,
+                                        7,
+                                        6,
+                                        2,
+                                        4,
+                                        8,
+                                        5,
+                                    },
+                                    ec_gf8_mul_3B_ops};
 
 static ec_gf_op_t ec_gf8_mul_3C_ops[] = {
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3C = {
-    8,
-    { 3, 6, 4, 1, 7, 2, 0, 5, },
-    ec_gf8_mul_3C_ops
-};
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3C = {8,
+                                    {
+                                        3,
+                                        6,
+                                        4,
+                                        1,
+                                        7,
+                                        2,
+                                        0,
+                                        5,
+                                    },
+                                    ec_gf8_mul_3C_ops};
 
 static ec_gf_op_t ec_gf8_mul_3D_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3D = {
-    8,
-    { 2, 3, 4, 5, 6, 7, 0, 1, },
-    ec_gf8_mul_3D_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3D = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_3D_ops};
 
 static ec_gf_op_t ec_gf8_mul_3E_ops[] = {
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3E = {
-    8,
-    { 6, 1, 2, 7, 0, 3, 5, 4, },
-    ec_gf8_mul_3E_ops
-};
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3E = {8,
+                                    {
+                                        6,
+                                        1,
+                                        2,
+                                        7,
+                                        0,
+                                        3,
+                                        5,
+                                        4,
+                                    },
+                                    ec_gf8_mul_3E_ops};
 
 static ec_gf_op_t ec_gf8_mul_3F_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_COPY,  10,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_COPY,   9,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR3,   4,  9,  7 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   3, 10,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_3F = {
-    11,
-    { 1, 7, 6, 2, 4, 3, 5, 0, 8, 9, 10, },
-    ec_gf8_mul_3F_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0},  {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_COPY, 10, 4, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0},  {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0},  {EC_GF_OP_COPY, 9, 2, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0},  {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0},  {EC_GF_OP_XOR3, 4, 9, 7},
+    {EC_GF_OP_XOR2, 3, 4, 0},  {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0},  {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 3, 10, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_3F = {11,
+                                    {
+                                        1,
+                                        7,
+                                        6,
+                                        2,
+                                        4,
+                                        3,
+                                        5,
+                                        0,
+                                        8,
+                                        9,
+                                        10,
+                                    },
+                                    ec_gf8_mul_3F_ops};
 
 static ec_gf_op_t ec_gf8_mul_40_ops[] = {
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR3,   8,  7,  6 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_40 = {
-    9,
-    { 5, 7, 4, 6, 2, 3, 0, 1, 8, },
-    ec_gf8_mul_40_ops
-};
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR3, 8, 7, 6},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_40 = {9,
+                                    {
+                                        5,
+                                        7,
+                                        4,
+                                        6,
+                                        2,
+                                        3,
+                                        0,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_40_ops};
 
 static ec_gf_op_t ec_gf8_mul_41_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_41 = {
-    9,
-    { 0, 7, 6, 5, 3, 4, 8, 1, 2, },
-    ec_gf8_mul_41_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 8, 4, 0},
+    {EC_GF_OP_XOR2, 8, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_41 = {9,
+                                    {
+                                        0,
+                                        7,
+                                        6,
+                                        5,
+                                        3,
+                                        4,
+                                        8,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_41_ops};
 
 static ec_gf_op_t ec_gf8_mul_42_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_42 = {
-    9,
-    { 2, 7, 1, 6, 4, 3, 0, 5, 8, },
-    ec_gf8_mul_42_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 8, 3, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_42 = {9,
+                                    {
+                                        2,
+                                        7,
+                                        1,
+                                        6,
+                                        4,
+                                        3,
+                                        0,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_42_ops};
 
 static ec_gf_op_t ec_gf8_mul_43_ops[] = {
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_43 = {
-    8,
-    { 2, 6, 4, 1, 7, 3, 0, 5, },
-    ec_gf8_mul_43_ops
-};
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_43 = {8,
+                                    {
+                                        2,
+                                        6,
+                                        4,
+                                        1,
+                                        7,
+                                        3,
+                                        0,
+                                        5,
+                                    },
+                                    ec_gf8_mul_43_ops};
 
 static ec_gf_op_t ec_gf8_mul_44_ops[] = {
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_44 = {
-    8,
-    { 2, 3, 4, 1, 6, 5, 0, 7, },
-    ec_gf8_mul_44_ops
-};
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_44 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        1,
+                                        6,
+                                        5,
+                                        0,
+                                        7,
+                                    },
+                                    ec_gf8_mul_44_ops};
 
 static ec_gf_op_t ec_gf8_mul_45_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_45 = {
-    8,
-    { 2, 3, 0, 1, 7, 4, 5, 6, },
-    ec_gf8_mul_45_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_45 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        0,
+                                        1,
+                                        7,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_45_ops};
 
 static ec_gf_op_t ec_gf8_mul_46_ops[] = {
-    { EC_GF_OP_XOR3,   8,  2,  4 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_46 = {
-    9,
-    { 2, 0, 1, 3, 4, 5, 6, 7, 8, },
-    ec_gf8_mul_46_ops
-};
+    {EC_GF_OP_XOR3, 8, 2, 4}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 8, 0, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_46 = {9,
+                                    {
+                                        2,
+                                        0,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_46_ops};
 
 static ec_gf_op_t ec_gf8_mul_47_ops[] = {
-    { EC_GF_OP_XOR3,   8,  0,  1 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_47 = {
-    9,
-    { 2, 3, 4, 5, 6, 7, 0, 1, 8, },
-    ec_gf8_mul_47_ops
-};
+    {EC_GF_OP_XOR3, 8, 0, 1}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_47 = {9,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_47_ops};
 
 static ec_gf_op_t ec_gf8_mul_48_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_48 = {
-    8,
-    { 4, 5, 6, 0, 1, 3, 7, 2, },
-    ec_gf8_mul_48_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_48 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        0,
+                                        1,
+                                        3,
+                                        7,
+                                        2,
+                                    },
+                                    ec_gf8_mul_48_ops};
 
 static ec_gf_op_t ec_gf8_mul_49_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR3,   8,  0,  6 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR3,   1,  8,  5 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_49 = {
-    9,
-    { 7, 2, 4, 0, 3, 5, 1, 6, 8, },
-    ec_gf8_mul_49_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR3, 8, 0, 6},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR3, 1, 8, 5},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_49 = {9,
+                                    {
+                                        7,
+                                        2,
+                                        4,
+                                        0,
+                                        3,
+                                        5,
+                                        1,
+                                        6,
+                                        8,
+                                    },
+                                    ec_gf8_mul_49_ops};
 
 static ec_gf_op_t ec_gf8_mul_4A_ops[] = {
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4A = {
-    8,
-    { 5, 6, 7, 0, 1, 3, 4, 2, },
-    ec_gf8_mul_4A_ops
-};
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4A = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        3,
+                                        4,
+                                        2,
+                                    },
+                                    ec_gf8_mul_4A_ops};
 
 static ec_gf_op_t ec_gf8_mul_4B_ops[] = {
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  7 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4B = {
-    9,
-    { 5, 3, 6, 7, 0, 2, 4, 1, 8, },
-    ec_gf8_mul_4B_ops
-};
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR3, 8, 3, 7}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4B = {9,
+                                    {
+                                        5,
+                                        3,
+                                        6,
+                                        7,
+                                        0,
+                                        2,
+                                        4,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_4B_ops};
 
 static ec_gf_op_t ec_gf8_mul_4C_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4C = {
-    8,
-    { 5, 3, 4, 7, 0, 6, 2, 1, },
-    ec_gf8_mul_4C_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4C = {8,
+                                    {
+                                        5,
+                                        3,
+                                        4,
+                                        7,
+                                        0,
+                                        6,
+                                        2,
+                                        1,
+                                    },
+                                    ec_gf8_mul_4C_ops};
 
 static ec_gf_op_t ec_gf8_mul_4D_ops[] = {
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR3,   9,  3,  1 },
-    { EC_GF_OP_XOR2,   5,  9,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR3,   0,  8,  2 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4D = {
-    10,
-    { 0, 9, 3, 5, 6, 4, 7, 1, 2, 8, },
-    ec_gf8_mul_4D_ops
-};
+    {EC_GF_OP_COPY, 8, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR3, 9, 3, 1},
+    {EC_GF_OP_XOR2, 5, 9, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR3, 0, 8, 2},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4D = {10,
+                                    {
+                                        0,
+                                        9,
+                                        3,
+                                        5,
+                                        6,
+                                        4,
+                                        7,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_4D_ops};
 
 static ec_gf_op_t ec_gf8_mul_4E_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4E = {
-    8,
-    { 2, 3, 0, 1, 5, 6, 7, 4, },
-    ec_gf8_mul_4E_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4E = {8,
+                                    {
+                                        2,
+                                        3,
+                                        0,
+                                        1,
+                                        5,
+                                        6,
+                                        7,
+                                        4,
+                                    },
+                                    ec_gf8_mul_4E_ops};
 
 static ec_gf_op_t ec_gf8_mul_4F_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_4F = {
-    8,
-    { 0, 3, 5, 6, 1, 2, 7, 4, },
-    ec_gf8_mul_4F_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_4F = {8,
+                                    {
+                                        0,
+                                        3,
+                                        5,
+                                        6,
+                                        1,
+                                        2,
+                                        7,
+                                        4,
+                                    },
+                                    ec_gf8_mul_4F_ops};
 
 static ec_gf_op_t ec_gf8_mul_50_ops[] = {
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_50 = {
-    8,
-    { 4, 5, 7, 3, 0, 1, 2, 6, },
-    ec_gf8_mul_50_ops
-};
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_50 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        7,
+                                        3,
+                                        0,
+                                        1,
+                                        2,
+                                        6,
+                                    },
+                                    ec_gf8_mul_50_ops};
 
 static ec_gf_op_t ec_gf8_mul_51_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_51 = {
-    8,
-    { 0, 1, 7, 2, 3, 4, 5, 6, },
-    ec_gf8_mul_51_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_51 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        7,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_51_ops};
 
 static ec_gf_op_t ec_gf8_mul_52_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_COPY,   9,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR3,   3,  5,  8 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  9,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_52 = {
-    10,
-    { 2, 3, 1, 4, 6, 7, 0, 5, 8, 9, },
-    ec_gf8_mul_52_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_COPY, 9, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR3, 3, 5, 8},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 2, 9, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_52 = {10,
+                                    {
+                                        2,
+                                        3,
+                                        1,
+                                        4,
+                                        6,
+                                        7,
+                                        0,
+                                        5,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_52_ops};
 
 static ec_gf_op_t ec_gf8_mul_53_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_53 = {
-    8,
-    { 2, 0, 1, 4, 5, 6, 7, 3, },
-    ec_gf8_mul_53_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_53 = {8,
+                                    {
+                                        2,
+                                        0,
+                                        1,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                    },
+                                    ec_gf8_mul_53_ops};
 
 static ec_gf_op_t ec_gf8_mul_54_ops[] = {
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_54 = {
-    8,
-    { 7, 3, 0, 4, 2, 6, 5, 1, },
-    ec_gf8_mul_54_ops
-};
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_54 = {8,
+                                    {
+                                        7,
+                                        3,
+                                        0,
+                                        4,
+                                        2,
+                                        6,
+                                        5,
+                                        1,
+                                    },
+                                    ec_gf8_mul_54_ops};
 
 static ec_gf_op_t ec_gf8_mul_55_ops[] = {
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_55 = {
-    8,
-    { 1, 5, 6, 4, 3, 7, 2, 0, },
-    ec_gf8_mul_55_ops
-};
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_55 = {8,
+                                    {
+                                        1,
+                                        5,
+                                        6,
+                                        4,
+                                        3,
+                                        7,
+                                        2,
+                                        0,
+                                    },
+                                    ec_gf8_mul_55_ops};
 
 static ec_gf_op_t ec_gf8_mul_56_ops[] = {
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_56 = {
-    8,
-    { 2, 3, 0, 4, 5, 6, 7, 1, },
-    ec_gf8_mul_56_ops
-};
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_56 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        0,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        1,
+                                    },
+                                    ec_gf8_mul_56_ops};
 
 static ec_gf_op_t ec_gf8_mul_57_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_57 = {
-    8,
-    { 2, 3, 0, 1, 4, 5, 6, 7, },
-    ec_gf8_mul_57_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_57 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        0,
+                                        1,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_57_ops};
 
 static ec_gf_op_t ec_gf8_mul_58_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_58 = {
-    8,
-    { 4, 3, 2, 7, 0, 1, 5, 6, },
-    ec_gf8_mul_58_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_58 = {8,
+                                    {
+                                        4,
+                                        3,
+                                        2,
+                                        7,
+                                        0,
+                                        1,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_58_ops};
 
 static ec_gf_op_t ec_gf8_mul_59_ops[] = {
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_59 = {
-    8,
-    { 7, 3, 5, 6, 1, 2, 0, 4, },
-    ec_gf8_mul_59_ops
-};
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_59 = {8,
+                                    {
+                                        7,
+                                        3,
+                                        5,
+                                        6,
+                                        1,
+                                        2,
+                                        0,
+                                        4,
+                                    },
+                                    ec_gf8_mul_59_ops};
 
 static ec_gf_op_t ec_gf8_mul_5A_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5A = {
-    8,
-    { 6, 7, 0, 1, 2, 3, 5, 4, },
-    ec_gf8_mul_5A_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5A = {8,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        4,
+                                    },
+                                    ec_gf8_mul_5A_ops};
 
 static ec_gf_op_t ec_gf8_mul_5B_ops[] = {
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5B = {
-    8,
-    { 6, 0, 7, 5, 2, 1, 3, 4, },
-    ec_gf8_mul_5B_ops
-};
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5B = {8,
+                                    {
+                                        6,
+                                        0,
+                                        7,
+                                        5,
+                                        2,
+                                        1,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_5B_ops};
 
 static ec_gf_op_t ec_gf8_mul_5C_ops[] = {
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5C = {
-    9,
-    { 7, 5, 2, 4, 1, 0, 6, 3, 8, },
-    ec_gf8_mul_5C_ops
-};
+    {EC_GF_OP_COPY, 8, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 2, 8, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5C = {9,
+                                    {
+                                        7,
+                                        5,
+                                        2,
+                                        4,
+                                        1,
+                                        0,
+                                        6,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_5C_ops};
 
 static ec_gf_op_t ec_gf8_mul_5D_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5D = {
-    8,
-    { 1, 3, 5, 4, 6, 7, 2, 0, },
-    ec_gf8_mul_5D_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5D = {8,
+                                    {
+                                        1,
+                                        3,
+                                        5,
+                                        4,
+                                        6,
+                                        7,
+                                        2,
+                                        0,
+                                    },
+                                    ec_gf8_mul_5D_ops};
 
 static ec_gf_op_t ec_gf8_mul_5E_ops[] = {
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5E = {
-    8,
-    { 4, 3, 6, 2, 5, 7, 0, 1, },
-    ec_gf8_mul_5E_ops
-};
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5E = {8,
+                                    {
+                                        4,
+                                        3,
+                                        6,
+                                        2,
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_5E_ops};
 
 static ec_gf_op_t ec_gf8_mul_5F_ops[] = {
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_5F = {
-    8,
-    { 6, 1, 3, 4, 5, 7, 2, 0, },
-    ec_gf8_mul_5F_ops
-};
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_5F = {8,
+                                    {
+                                        6,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        7,
+                                        2,
+                                        0,
+                                    },
+                                    ec_gf8_mul_5F_ops};
 
 static ec_gf_op_t ec_gf8_mul_60_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_60 = {
-    8,
-    { 2, 3, 4, 7, 5, 6, 0, 1, },
-    ec_gf8_mul_60_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_60 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        7,
+                                        5,
+                                        6,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_60_ops};
 
 static ec_gf_op_t ec_gf8_mul_61_ops[] = {
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_61 = {
-    8,
-    { 0, 5, 6, 7, 4, 2, 1, 3, },
-    ec_gf8_mul_61_ops
-};
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_61 = {8,
+                                    {
+                                        0,
+                                        5,
+                                        6,
+                                        7,
+                                        4,
+                                        2,
+                                        1,
+                                        3,
+                                    },
+                                    ec_gf8_mul_61_ops};
 
 static ec_gf_op_t ec_gf8_mul_62_ops[] = {
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_62 = {
-    8,
-    { 2, 0, 3, 4, 5, 6, 7, 1, },
-    ec_gf8_mul_62_ops
-};
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_62 = {8,
+                                    {
+                                        2,
+                                        0,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        1,
+                                    },
+                                    ec_gf8_mul_62_ops};
 
 static ec_gf_op_t ec_gf8_mul_63_ops[] = {
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_63 = {
-    8,
-    { 3, 4, 6, 5, 7, 0, 1, 2, },
-    ec_gf8_mul_63_ops
-};
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_63 = {8,
+                                    {
+                                        3,
+                                        4,
+                                        6,
+                                        5,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_63_ops};
 
 static ec_gf_op_t ec_gf8_mul_64_ops[] = {
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_64 = {
-    9,
-    { 2, 3, 4, 6, 5, 7, 8, 1, 0, },
-    ec_gf8_mul_64_ops
-};
+    {EC_GF_OP_COPY, 8, 1, 0}, {EC_GF_OP_XOR2, 8, 0, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 8, 7, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_64 = {9,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        6,
+                                        5,
+                                        7,
+                                        8,
+                                        1,
+                                        0,
+                                    },
+                                    ec_gf8_mul_64_ops};
 
 static ec_gf_op_t ec_gf8_mul_65_ops[] = {
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_65 = {
-    8,
-    { 2, 5, 1, 3, 4, 0, 6, 7, },
-    ec_gf8_mul_65_ops
-};
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_65 = {8,
+                                    {
+                                        2,
+                                        5,
+                                        1,
+                                        3,
+                                        4,
+                                        0,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_65_ops};
 
 static ec_gf_op_t ec_gf8_mul_66_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_66 = {
-    8,
-    { 2, 3, 1, 4, 5, 7, 0, 6, },
-    ec_gf8_mul_66_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_66 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        1,
+                                        4,
+                                        5,
+                                        7,
+                                        0,
+                                        6,
+                                    },
+                                    ec_gf8_mul_66_ops};
 
 static ec_gf_op_t ec_gf8_mul_67_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_67 = {
-    8,
-    { 2, 4, 5, 6, 7, 3, 1, 0, },
-    ec_gf8_mul_67_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_67 = {8,
+                                    {
+                                        2,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                        1,
+                                        0,
+                                    },
+                                    ec_gf8_mul_67_ops};
 
 static ec_gf_op_t ec_gf8_mul_68_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_68 = {
-    8,
-    { 5, 7, 2, 3, 0, 6, 4, 1, },
-    ec_gf8_mul_68_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_68 = {8,
+                                    {
+                                        5,
+                                        7,
+                                        2,
+                                        3,
+                                        0,
+                                        6,
+                                        4,
+                                        1,
+                                    },
+                                    ec_gf8_mul_68_ops};
 
 static ec_gf_op_t ec_gf8_mul_69_ops[] = {
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_69 = {
-    8,
-    { 0, 1, 3, 2, 4, 5, 7, 6, },
-    ec_gf8_mul_69_ops
-};
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_69 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        5,
+                                        7,
+                                        6,
+                                    },
+                                    ec_gf8_mul_69_ops};
 
 static ec_gf_op_t ec_gf8_mul_6A_ops[] = {
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6A = {
-    8,
-    { 5, 7, 4, 6, 1, 2, 0, 3, },
-    ec_gf8_mul_6A_ops
-};
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6A = {8,
+                                    {
+                                        5,
+                                        7,
+                                        4,
+                                        6,
+                                        1,
+                                        2,
+                                        0,
+                                        3,
+                                    },
+                                    ec_gf8_mul_6A_ops};
 
 static ec_gf_op_t ec_gf8_mul_6B_ops[] = {
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6B = {
-    9,
-    { 6, 7, 2, 0, 3, 1, 5, 4, 8, },
-    ec_gf8_mul_6B_ops
-};
+    {EC_GF_OP_COPY, 8, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6B = {9,
+                                    {
+                                        6,
+                                        7,
+                                        2,
+                                        0,
+                                        3,
+                                        1,
+                                        5,
+                                        4,
+                                        8,
+                                    },
+                                    ec_gf8_mul_6B_ops};
 
 static ec_gf_op_t ec_gf8_mul_6C_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6C = {
-    8,
-    { 5, 6, 7, 0, 1, 2, 3, 4, },
-    ec_gf8_mul_6C_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6C = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_6C_ops};
 
 static ec_gf_op_t ec_gf8_mul_6D_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  4 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6D = {
-    9,
-    { 3, 6, 7, 0, 4, 5, 1, 2, 8, },
-    ec_gf8_mul_6D_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR3, 8, 3, 4}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6D = {9,
+                                    {
+                                        3,
+                                        6,
+                                        7,
+                                        0,
+                                        4,
+                                        5,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_6D_ops};
 
 static ec_gf_op_t ec_gf8_mul_6E_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6E = {
-    8,
-    { 5, 6, 3, 1, 7, 2, 0, 4, },
-    ec_gf8_mul_6E_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6E = {8,
+                                    {
+                                        5,
+                                        6,
+                                        3,
+                                        1,
+                                        7,
+                                        2,
+                                        0,
+                                        4,
+                                    },
+                                    ec_gf8_mul_6E_ops};
 
 static ec_gf_op_t ec_gf8_mul_6F_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR3,   0,  8,  7 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_6F = {
-    9,
-    { 2, 6, 3, 7, 0, 1, 4, 5, 8, },
-    ec_gf8_mul_6F_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR3, 0, 8, 7}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_6F = {9,
+                                    {
+                                        2,
+                                        6,
+                                        3,
+                                        7,
+                                        0,
+                                        1,
+                                        4,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_6F_ops};
 
 static ec_gf_op_t ec_gf8_mul_70_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_70 = {
-    8,
-    { 3, 4, 5, 2, 6, 0, 1, 7, },
-    ec_gf8_mul_70_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_70 = {8,
+                                    {
+                                        3,
+                                        4,
+                                        5,
+                                        2,
+                                        6,
+                                        0,
+                                        1,
+                                        7,
+                                    },
+                                    ec_gf8_mul_70_ops};
 
 static ec_gf_op_t ec_gf8_mul_71_ops[] = {
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_71 = {
-    8,
-    { 4, 7, 5, 3, 6, 0, 2, 1, },
-    ec_gf8_mul_71_ops
-};
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_71 = {8,
+                                    {
+                                        4,
+                                        7,
+                                        5,
+                                        3,
+                                        6,
+                                        0,
+                                        2,
+                                        1,
+                                    },
+                                    ec_gf8_mul_71_ops};
 
 static ec_gf_op_t ec_gf8_mul_72_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_72 = {
-    8,
-    { 0, 5, 2, 7, 4, 1, 3, 6, },
-    ec_gf8_mul_72_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_72 = {8,
+                                    {
+                                        0,
+                                        5,
+                                        2,
+                                        7,
+                                        4,
+                                        1,
+                                        3,
+                                        6,
+                                    },
+                                    ec_gf8_mul_72_ops};
 
 static ec_gf_op_t ec_gf8_mul_73_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_73 = {
-    8,
-    { 6, 0, 1, 7, 4, 5, 2, 3, },
-    ec_gf8_mul_73_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_73 = {8,
+                                    {
+                                        6,
+                                        0,
+                                        1,
+                                        7,
+                                        4,
+                                        5,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_73_ops};
 
 static ec_gf_op_t ec_gf8_mul_74_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_74 = {
-    8,
-    { 3, 2, 1, 0, 4, 5, 6, 7, },
-    ec_gf8_mul_74_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_74 = {8,
+                                    {
+                                        3,
+                                        2,
+                                        1,
+                                        0,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_74_ops};
 
 static ec_gf_op_t ec_gf8_mul_75_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_75 = {
-    8,
-    { 4, 5, 6, 7, 0, 1, 2, 3, },
-    ec_gf8_mul_75_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_75 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_75_ops};
 
 static ec_gf_op_t ec_gf8_mul_76_ops[] = {
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  2 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_76 = {
-    9,
-    { 2, 3, 0, 6, 5, 1, 7, 8, 4, },
-    ec_gf8_mul_76_ops
-};
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR3, 8, 6, 2},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 0, 8, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_76 = {9,
+                                    {
+                                        2,
+                                        3,
+                                        0,
+                                        6,
+                                        5,
+                                        1,
+                                        7,
+                                        8,
+                                        4,
+                                    },
+                                    ec_gf8_mul_76_ops};
 
 static ec_gf_op_t ec_gf8_mul_77_ops[] = {
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_77 = {
-    8,
-    { 7, 4, 3, 6, 0, 1, 5, 2, },
-    ec_gf8_mul_77_ops
-};
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_77 = {8,
+                                    {
+                                        7,
+                                        4,
+                                        3,
+                                        6,
+                                        0,
+                                        1,
+                                        5,
+                                        2,
+                                    },
+                                    ec_gf8_mul_77_ops};
 
 static ec_gf_op_t ec_gf8_mul_78_ops[] = {
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  0,  2 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_78 = {
-    9,
-    { 4, 7, 3, 2, 5, 1, 6, 0, 8, },
-    ec_gf8_mul_78_ops
-};
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR3, 8, 0, 2},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_78 = {9,
+                                    {
+                                        4,
+                                        7,
+                                        3,
+                                        2,
+                                        5,
+                                        1,
+                                        6,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_78_ops};
 
 static ec_gf_op_t ec_gf8_mul_79_ops[] = {
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  7 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_79 = {
-    9,
-    { 4, 5, 7, 3, 1, 6, 2, 0, 8, },
-    ec_gf8_mul_79_ops
-};
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR3, 8, 4, 7},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_79 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        7,
+                                        3,
+                                        1,
+                                        6,
+                                        2,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_79_ops};
 
 static ec_gf_op_t ec_gf8_mul_7A_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7A = {
-    8,
-    { 1, 2, 3, 4, 5, 6, 7, 0, },
-    ec_gf8_mul_7A_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7A = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                    },
+                                    ec_gf8_mul_7A_ops};
 
 static ec_gf_op_t ec_gf8_mul_7B_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  5,  3 },
-    { EC_GF_OP_XOR2,   8,  0,  0 },
-    { EC_GF_OP_COPY,   9,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR3,   4,  1,  9 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7B = {
-    10,
-    { 1, 2, 3, 4, 8, 5, 6, 0, 7, 9, },
-    ec_gf8_mul_7B_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR3, 8, 5, 3},
+    {EC_GF_OP_XOR2, 8, 0, 0}, {EC_GF_OP_COPY, 9, 4, 0},
+    {EC_GF_OP_XOR2, 8, 2, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR3, 4, 1, 9},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7B = {10,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        8,
+                                        5,
+                                        6,
+                                        0,
+                                        7,
+                                        9,
+                                    },
+                                    ec_gf8_mul_7B_ops};
 
 static ec_gf_op_t ec_gf8_mul_7C_ops[] = {
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7C = {
-    8,
-    { 2, 4, 1, 6, 3, 5, 7, 0, },
-    ec_gf8_mul_7C_ops
-};
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7C = {8,
+                                    {
+                                        2,
+                                        4,
+                                        1,
+                                        6,
+                                        3,
+                                        5,
+                                        7,
+                                        0,
+                                    },
+                                    ec_gf8_mul_7C_ops};
 
 static ec_gf_op_t ec_gf8_mul_7D_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7D = {
-    8,
-    { 1, 0, 3, 5, 6, 7, 2, 4, },
-    ec_gf8_mul_7D_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7D = {8,
+                                    {
+                                        1,
+                                        0,
+                                        3,
+                                        5,
+                                        6,
+                                        7,
+                                        2,
+                                        4,
+                                    },
+                                    ec_gf8_mul_7D_ops};
 
 static ec_gf_op_t ec_gf8_mul_7E_ops[] = {
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR3,   6,  2,  7 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7E = {
-    9,
-    { 5, 1, 2, 0, 7, 3, 4, 6, 8, },
-    ec_gf8_mul_7E_ops
-};
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_COPY, 8, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR3, 6, 2, 7},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7E = {9,
+                                    {
+                                        5,
+                                        1,
+                                        2,
+                                        0,
+                                        7,
+                                        3,
+                                        4,
+                                        6,
+                                        8,
+                                    },
+                                    ec_gf8_mul_7E_ops};
 
 static ec_gf_op_t ec_gf8_mul_7F_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR3,   9,  7,  5 },
-    { EC_GF_OP_XOR2,   2,  9,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  9,  0 },
-    { EC_GF_OP_XOR3,   9,  6,  4 },
-    { EC_GF_OP_XOR2,   7,  9,  0 },
-    { EC_GF_OP_XOR2,   3,  9,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_7F = {
-    10,
-    { 4, 1, 0, 5, 6, 7, 2, 3, 8, 9, },
-    ec_gf8_mul_7F_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR3, 9, 7, 5}, {EC_GF_OP_XOR2, 2, 9, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 6, 9, 0},
+    {EC_GF_OP_XOR3, 9, 6, 4}, {EC_GF_OP_XOR2, 7, 9, 0},
+    {EC_GF_OP_XOR2, 3, 9, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_7F = {10,
+                                    {
+                                        4,
+                                        1,
+                                        0,
+                                        5,
+                                        6,
+                                        7,
+                                        2,
+                                        3,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_7F_ops};
 
 static ec_gf_op_t ec_gf8_mul_80_ops[] = {
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_80 = {
-    8,
-    { 7, 5, 6, 4, 1, 2, 3, 0, },
-    ec_gf8_mul_80_ops
-};
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_80 = {8,
+                                    {
+                                        7,
+                                        5,
+                                        6,
+                                        4,
+                                        1,
+                                        2,
+                                        3,
+                                        0,
+                                    },
+                                    ec_gf8_mul_80_ops};
 
 static ec_gf_op_t ec_gf8_mul_81_ops[] = {
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_81 = {
-    8,
-    { 2, 7, 4, 1, 5, 6, 3, 0, },
-    ec_gf8_mul_81_ops
-};
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_81 = {8,
+                                    {
+                                        2,
+                                        7,
+                                        4,
+                                        1,
+                                        5,
+                                        6,
+                                        3,
+                                        0,
+                                    },
+                                    ec_gf8_mul_81_ops};
 
 static ec_gf_op_t ec_gf8_mul_82_ops[] = {
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_COPY,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR3,   5,  8,  7 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_82 = {
-    9,
-    { 6, 2, 7, 5, 1, 3, 4, 0, 8, },
-    ec_gf8_mul_82_ops
-};
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_COPY, 8, 6, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR3, 5, 8, 7}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_82 = {9,
+                                    {
+                                        6,
+                                        2,
+                                        7,
+                                        5,
+                                        1,
+                                        3,
+                                        4,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_82_ops};
 
 static ec_gf_op_t ec_gf8_mul_83_ops[] = {
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_83 = {
-    8,
-    { 3, 5, 6, 7, 1, 2, 4, 0, },
-    ec_gf8_mul_83_ops
-};
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_83 = {8,
+                                    {
+                                        3,
+                                        5,
+                                        6,
+                                        7,
+                                        1,
+                                        2,
+                                        4,
+                                        0,
+                                    },
+                                    ec_gf8_mul_83_ops};
 
 static ec_gf_op_t ec_gf8_mul_84_ops[] = {
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_84 = {
-    8,
-    { 7, 6, 0, 4, 1, 5, 3, 2, },
-    ec_gf8_mul_84_ops
-};
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_84 = {8,
+                                    {
+                                        7,
+                                        6,
+                                        0,
+                                        4,
+                                        1,
+                                        5,
+                                        3,
+                                        2,
+                                    },
+                                    ec_gf8_mul_84_ops};
 
 static ec_gf_op_t ec_gf8_mul_85_ops[] = {
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_85 = {
-    8,
-    { 7, 6, 0, 3, 2, 4, 5, 1, },
-    ec_gf8_mul_85_ops
-};
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_85 = {8,
+                                    {
+                                        7,
+                                        6,
+                                        0,
+                                        3,
+                                        2,
+                                        4,
+                                        5,
+                                        1,
+                                    },
+                                    ec_gf8_mul_85_ops};
 
 static ec_gf_op_t ec_gf8_mul_86_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_86 = {
-    8,
-    { 1, 2, 6, 4, 5, 7, 3, 0, },
-    ec_gf8_mul_86_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_86 = {8,
+                                    {
+                                        1,
+                                        2,
+                                        6,
+                                        4,
+                                        5,
+                                        7,
+                                        3,
+                                        0,
+                                    },
+                                    ec_gf8_mul_86_ops};
 
 static ec_gf_op_t ec_gf8_mul_87_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR3,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_87 = {
-    9,
-    { 1, 2, 3, 4, 5, 7, 6, 0, 8, },
-    ec_gf8_mul_87_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_COPY, 8, 1, 0},
+    {EC_GF_OP_XOR2, 8, 6, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR3, 5, 8, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_87 = {9,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        7,
+                                        6,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_87_ops};
 
 static ec_gf_op_t ec_gf8_mul_88_ops[] = {
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_88 = {
-    8,
-    { 6, 7, 3, 1, 2, 4, 5, 0, },
-    ec_gf8_mul_88_ops
-};
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_88 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        3,
+                                        1,
+                                        2,
+                                        4,
+                                        5,
+                                        0,
+                                    },
+                                    ec_gf8_mul_88_ops};
 
 static ec_gf_op_t ec_gf8_mul_89_ops[] = {
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  5,  2 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_89 = {
-    9,
-    { 2, 1, 6, 5, 7, 3, 4, 0, 8, },
-    ec_gf8_mul_89_ops
-};
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR3, 8, 5, 2},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_89 = {9,
+                                    {
+                                        2,
+                                        1,
+                                        6,
+                                        5,
+                                        7,
+                                        3,
+                                        4,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_89_ops};
 
 static ec_gf_op_t ec_gf8_mul_8A_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8A = {
-    8,
-    { 1, 2, 3, 0, 6, 7, 4, 5, },
-    ec_gf8_mul_8A_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8A = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        0,
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_8A_ops};
 
 static ec_gf_op_t ec_gf8_mul_8B_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8B = {
-    8,
-    { 6, 1, 2, 3, 5, 7, 4, 0, },
-    ec_gf8_mul_8B_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8B = {8,
+                                    {
+                                        6,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        7,
+                                        4,
+                                        0,
+                                    },
+                                    ec_gf8_mul_8B_ops};
 
 static ec_gf_op_t ec_gf8_mul_8C_ops[] = {
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8C = {
-    8,
-    { 1, 2, 0, 7, 3, 4, 5, 6, },
-    ec_gf8_mul_8C_ops
-};
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8C = {8,
+                                    {
+                                        1,
+                                        2,
+                                        0,
+                                        7,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_8C_ops};
 
 static ec_gf_op_t ec_gf8_mul_8D_ops[] = {
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8D = {
-    8,
-    { 7, 1, 3, 2, 4, 5, 0, 6, },
-    ec_gf8_mul_8D_ops
-};
-
-static ec_gf_op_t ec_gf8_mul_8E_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8E = {
-    8,
-    { 1, 2, 3, 4, 5, 6, 7, 0, },
-    ec_gf8_mul_8E_ops
-};
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8D = {8,
+                                    {
+                                        7,
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        5,
+                                        0,
+                                        6,
+                                    },
+                                    ec_gf8_mul_8D_ops};
+
+static ec_gf_op_t ec_gf8_mul_8E_ops[] = {{EC_GF_OP_XOR2, 2, 0, 0},
+                                         {EC_GF_OP_XOR2, 3, 0, 0},
+                                         {EC_GF_OP_XOR2, 4, 0, 0},
+                                         {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8E = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                    },
+                                    ec_gf8_mul_8E_ops};
 
 static ec_gf_op_t ec_gf8_mul_8F_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_8F = {
-    8,
-    { 1, 2, 3, 4, 5, 6, 7, 0, },
-    ec_gf8_mul_8F_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_8F = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                    },
+                                    ec_gf8_mul_8F_ops};
 
 static ec_gf_op_t ec_gf8_mul_90_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_90 = {
-    8,
-    { 4, 5, 6, 7, 0, 1, 3, 2, },
-    ec_gf8_mul_90_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_90 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        3,
+                                        2,
+                                    },
+                                    ec_gf8_mul_90_ops};
 
 static ec_gf_op_t ec_gf8_mul_91_ops[] = {
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_COPY,   9,  1,  0 },
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  9,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR3,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_91 = {
-    10,
-    { 2, 3, 1, 4, 0, 6, 7, 5, 8, 9, },
-    ec_gf8_mul_91_ops
-};
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_COPY, 9, 1, 0}, {EC_GF_OP_COPY, 8, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 7, 9, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR3, 5, 8, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_91 = {10,
+                                    {
+                                        2,
+                                        3,
+                                        1,
+                                        4,
+                                        0,
+                                        6,
+                                        7,
+                                        5,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_91_ops};
 
 static ec_gf_op_t ec_gf8_mul_92_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_92 = {
-    8,
-    { 6, 7, 0, 1, 2, 3, 5, 4, },
-    ec_gf8_mul_92_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_92 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        5,
+                                        4,
+                                    },
+                                    ec_gf8_mul_92_ops};
 
 static ec_gf_op_t ec_gf8_mul_93_ops[] = {
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_93 = {
-    8,
-    { 6, 4, 5, 1, 7, 2, 3, 0, },
-    ec_gf8_mul_93_ops
-};
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_93 = {8,
+                                    {
+                                        6,
+                                        4,
+                                        5,
+                                        1,
+                                        7,
+                                        2,
+                                        3,
+                                        0,
+                                    },
+                                    ec_gf8_mul_93_ops};
 
 static ec_gf_op_t ec_gf8_mul_94_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_94 = {
-    8,
-    { 7, 5, 0, 2, 6, 1, 3, 4, },
-    ec_gf8_mul_94_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_94 = {8,
+                                    {
+                                        7,
+                                        5,
+                                        0,
+                                        2,
+                                        6,
+                                        1,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_94_ops};
 
 static ec_gf_op_t ec_gf8_mul_95_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_95 = {
-    8,
-    { 7, 6, 1, 3, 0, 4, 5, 2, },
-    ec_gf8_mul_95_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_95 = {8,
+                                    {
+                                        7,
+                                        6,
+                                        1,
+                                        3,
+                                        0,
+                                        4,
+                                        5,
+                                        2,
+                                    },
+                                    ec_gf8_mul_95_ops};
 
 static ec_gf_op_t ec_gf8_mul_96_ops[] = {
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  0,  4 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_96 = {
-    9,
-    { 4, 0, 1, 6, 7, 2, 3, 5, 8, },
-    ec_gf8_mul_96_ops
-};
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR3, 8, 0, 4}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 8, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_96 = {9,
+                                    {
+                                        4,
+                                        0,
+                                        1,
+                                        6,
+                                        7,
+                                        2,
+                                        3,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_96_ops};
 
 static ec_gf_op_t ec_gf8_mul_97_ops[] = {
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_COPY,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_97 = {
-    9,
-    { 4, 5, 3, 6, 7, 1, 2, 0, 8, },
-    ec_gf8_mul_97_ops
-};
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_COPY, 8, 2, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 8, 6, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_97 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        3,
+                                        6,
+                                        7,
+                                        1,
+                                        2,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_97_ops};
 
 static ec_gf_op_t ec_gf8_mul_98_ops[] = {
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_98 = {
-    8,
-    { 4, 2, 3, 6, 7, 5, 1, 0, },
-    ec_gf8_mul_98_ops
-};
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_98 = {8,
+                                    {
+                                        4,
+                                        2,
+                                        3,
+                                        6,
+                                        7,
+                                        5,
+                                        1,
+                                        0,
+                                    },
+                                    ec_gf8_mul_98_ops};
 
 static ec_gf_op_t ec_gf8_mul_99_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_99 = {
-    8,
-    { 6, 5, 3, 7, 0, 1, 4, 2, },
-    ec_gf8_mul_99_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_99 = {8,
+                                    {
+                                        6,
+                                        5,
+                                        3,
+                                        7,
+                                        0,
+                                        1,
+                                        4,
+                                        2,
+                                    },
+                                    ec_gf8_mul_99_ops};
 
 static ec_gf_op_t ec_gf8_mul_9A_ops[] = {
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9A = {
-    9,
-    { 6, 3, 4, 0, 5, 1, 2, 7, 8, },
-    ec_gf8_mul_9A_ops
-};
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR3, 8, 4, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9A = {9,
+                                    {
+                                        6,
+                                        3,
+                                        4,
+                                        0,
+                                        5,
+                                        1,
+                                        2,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_9A_ops};
 
 static ec_gf_op_t ec_gf8_mul_9B_ops[] = {
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_COPY,   9,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  2 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  9,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9B = {
-    10,
-    { 4, 5, 8, 6, 7, 1, 2, 0, 3, 9, },
-    ec_gf8_mul_9B_ops
-};
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_COPY, 9, 5, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR3, 8, 3, 2}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 3, 9, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9B = {10,
+                                    {
+                                        4,
+                                        5,
+                                        8,
+                                        6,
+                                        7,
+                                        1,
+                                        2,
+                                        0,
+                                        3,
+                                        9,
+                                    },
+                                    ec_gf8_mul_9B_ops};
 
 static ec_gf_op_t ec_gf8_mul_9C_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9C = {
-    8,
-    { 3, 2, 1, 0, 4, 5, 6, 7, },
-    ec_gf8_mul_9C_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9C = {8,
+                                    {
+                                        3,
+                                        2,
+                                        1,
+                                        0,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_9C_ops};
 
 static ec_gf_op_t ec_gf8_mul_9D_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9D = {
-    8,
-    { 0, 1, 2, 3, 7, 4, 5, 6, },
-    ec_gf8_mul_9D_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9D = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        7,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_9D_ops};
 
 static ec_gf_op_t ec_gf8_mul_9E_ops[] = {
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_COPY,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9E = {
-    9,
-    { 4, 5, 3, 8, 6, 0, 2, 7, 1, },
-    ec_gf8_mul_9E_ops
-};
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_COPY, 8, 7, 0},
+    {EC_GF_OP_XOR2, 8, 5, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9E = {9,
+                                    {
+                                        4,
+                                        5,
+                                        3,
+                                        8,
+                                        6,
+                                        0,
+                                        2,
+                                        7,
+                                        1,
+                                    },
+                                    ec_gf8_mul_9E_ops};
 
 static ec_gf_op_t ec_gf8_mul_9F_ops[] = {
-    { EC_GF_OP_XOR3,   8,  1,  2 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_9F = {
-    9,
-    { 4, 5, 6, 7, 0, 1, 2, 3, 8, },
-    ec_gf8_mul_9F_ops
-};
+    {EC_GF_OP_XOR3, 8, 1, 2}, {EC_GF_OP_XOR2, 8, 3, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_9F = {9,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_9F_ops};
 
 static ec_gf_op_t ec_gf8_mul_A0_ops[] = {
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A0 = {
-    8,
-    { 3, 1, 6, 7, 5, 2, 4, 0, },
-    ec_gf8_mul_A0_ops
-};
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A0 = {8,
+                                    {
+                                        3,
+                                        1,
+                                        6,
+                                        7,
+                                        5,
+                                        2,
+                                        4,
+                                        0,
+                                    },
+                                    ec_gf8_mul_A0_ops};
 
 static ec_gf_op_t ec_gf8_mul_A1_ops[] = {
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR3,   8,  0,  6 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A1 = {
-    9,
-    { 7, 4, 1, 5, 6, 0, 2, 3, 8, },
-    ec_gf8_mul_A1_ops
-};
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR3, 8, 0, 6},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A1 = {9,
+                                    {
+                                        7,
+                                        4,
+                                        1,
+                                        5,
+                                        6,
+                                        0,
+                                        2,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_A1_ops};
 
 static ec_gf_op_t ec_gf8_mul_A2_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A2 = {
-    8,
-    { 7, 0, 6, 3, 2, 1, 4, 5, },
-    ec_gf8_mul_A2_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A2 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        6,
+                                        3,
+                                        2,
+                                        1,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_A2_ops};
 
 static ec_gf_op_t ec_gf8_mul_A3_ops[] = {
-    { EC_GF_OP_COPY,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A3 = {
-    9,
-    { 3, 7, 2, 6, 1, 4, 0, 5, 8, },
-    ec_gf8_mul_A3_ops
-};
+    {EC_GF_OP_COPY, 8, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A3 = {9,
+                                    {
+                                        3,
+                                        7,
+                                        2,
+                                        6,
+                                        1,
+                                        4,
+                                        0,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_A3_ops};
 
 static ec_gf_op_t ec_gf8_mul_A4_ops[] = {
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A4 = {
-    8,
-    { 5, 6, 7, 2, 4, 3, 0, 1, },
-    ec_gf8_mul_A4_ops
-};
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A4 = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        2,
+                                        4,
+                                        3,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_A4_ops};
 
 static ec_gf_op_t ec_gf8_mul_A5_ops[] = {
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR3,   8,  5,  6 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A5 = {
-    9,
-    { 1, 4, 2, 5, 6, 7, 3, 0, 8, },
-    ec_gf8_mul_A5_ops
-};
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR3, 8, 5, 6}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A5 = {9,
+                                    {
+                                        1,
+                                        4,
+                                        2,
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_A5_ops};
 
 static ec_gf_op_t ec_gf8_mul_A6_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A6 = {
-    8,
-    { 1, 2, 0, 3, 4, 5, 6, 7, },
-    ec_gf8_mul_A6_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A6 = {8,
+                                    {
+                                        1,
+                                        2,
+                                        0,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_A6_ops};
 
 static ec_gf_op_t ec_gf8_mul_A7_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A7 = {
-    8,
-    { 0, 1, 2, 5, 6, 7, 3, 4, },
-    ec_gf8_mul_A7_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A7 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_A7_ops};
 
 static ec_gf_op_t ec_gf8_mul_A8_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_COPY,   9,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  9,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A8 = {
-    10,
-    { 1, 7, 5, 8, 6, 3, 4, 0, 2, 9, },
-    ec_gf8_mul_A8_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 8, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_COPY, 9, 4, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 8, 3, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 9, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A8 = {10,
+                                    {
+                                        1,
+                                        7,
+                                        5,
+                                        8,
+                                        6,
+                                        3,
+                                        4,
+                                        0,
+                                        2,
+                                        9,
+                                    },
+                                    ec_gf8_mul_A8_ops};
 
 static ec_gf_op_t ec_gf8_mul_A9_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_A9 = {
-    8,
-    { 3, 7, 6, 1, 2, 0, 4, 5, },
-    ec_gf8_mul_A9_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_A9 = {8,
+                                    {
+                                        3,
+                                        7,
+                                        6,
+                                        1,
+                                        2,
+                                        0,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_A9_ops};
 
 static ec_gf_op_t ec_gf8_mul_AA_ops[] = {
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AA = {
-    8,
-    { 0, 4, 5, 3, 6, 7, 1, 2, },
-    ec_gf8_mul_AA_ops
-};
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AA = {8,
+                                    {
+                                        0,
+                                        4,
+                                        5,
+                                        3,
+                                        6,
+                                        7,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_AA_ops};
 
 static ec_gf_op_t ec_gf8_mul_AB_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_COPY,   9,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR3,   3,  9,  7 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AB = {
-    10,
-    { 2, 3, 8, 0, 5, 6, 1, 4, 7, 9, },
-    ec_gf8_mul_AB_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_COPY, 9, 6, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 8, 7, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR3, 3, 9, 7},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AB = {10,
+                                    {
+                                        2,
+                                        3,
+                                        8,
+                                        0,
+                                        5,
+                                        6,
+                                        1,
+                                        4,
+                                        7,
+                                        9,
+                                    },
+                                    ec_gf8_mul_AB_ops};
 
 static ec_gf_op_t ec_gf8_mul_AC_ops[] = {
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AC = {
-    8,
-    { 3, 2, 1, 0, 4, 5, 6, 7, },
-    ec_gf8_mul_AC_ops
-};
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AC = {8,
+                                    {
+                                        3,
+                                        2,
+                                        1,
+                                        0,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_AC_ops};
 
 static ec_gf_op_t ec_gf8_mul_AD_ops[] = {
-    { EC_GF_OP_XOR3,   8,  1,  2 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AD = {
-    9,
-    { 3, 4, 5, 6, 7, 0, 1, 2, 8, },
-    ec_gf8_mul_AD_ops
-};
+    {EC_GF_OP_XOR3, 8, 1, 2}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AD = {9,
+                                    {
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_AD_ops};
 
 static ec_gf_op_t ec_gf8_mul_AE_ops[] = {
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_COPY,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AE = {
-    9,
-    { 7, 0, 5, 6, 3, 4, 1, 2, 8, },
-    ec_gf8_mul_AE_ops
-};
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_COPY, 8, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AE = {9,
+                                    {
+                                        7,
+                                        0,
+                                        5,
+                                        6,
+                                        3,
+                                        4,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_AE_ops};
 
 static ec_gf_op_t ec_gf8_mul_AF_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_AF = {
-    8,
-    { 0, 1, 2, 7, 3, 4, 5, 6, },
-    ec_gf8_mul_AF_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_AF = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        7,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_AF_ops};
 
 static ec_gf_op_t ec_gf8_mul_B0_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B0 = {
-    8,
-    { 4, 0, 7, 2, 3, 1, 6, 5, },
-    ec_gf8_mul_B0_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B0 = {8,
+                                    {
+                                        4,
+                                        0,
+                                        7,
+                                        2,
+                                        3,
+                                        1,
+                                        6,
+                                        5,
+                                    },
+                                    ec_gf8_mul_B0_ops};
 
 static ec_gf_op_t ec_gf8_mul_B1_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_COPY,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR3,   5,  8,  1 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B1 = {
-    9,
-    { 2, 6, 4, 7, 0, 1, 3, 5, 8, },
-    ec_gf8_mul_B1_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_COPY, 8, 4, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR3, 5, 8, 1}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B1 = {9,
+                                    {
+                                        2,
+                                        6,
+                                        4,
+                                        7,
+                                        0,
+                                        1,
+                                        3,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_B1_ops};
 
 static ec_gf_op_t ec_gf8_mul_B2_ops[] = {
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  5 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B2 = {
-    9,
-    { 0, 7, 4, 5, 6, 1, 2, 3, 8, },
-    ec_gf8_mul_B2_ops
-};
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR3, 8, 4, 5},
+    {EC_GF_OP_XOR2, 2, 8, 0}, {EC_GF_OP_XOR2, 8, 1, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B2 = {9,
+                                    {
+                                        0,
+                                        7,
+                                        4,
+                                        5,
+                                        6,
+                                        1,
+                                        2,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_B2_ops};
 
 static ec_gf_op_t ec_gf8_mul_B3_ops[] = {
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_COPY,   9,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  4 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR3,   1,  9,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B3 = {
-    10,
-    { 2, 3, 4, 5, 1, 6, 0, 7, 8, 9, },
-    ec_gf8_mul_B3_ops
-};
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_COPY, 9, 5, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR3, 8, 6, 4},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 8, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR3, 1, 9, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B3 = {10,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        1,
+                                        6,
+                                        0,
+                                        7,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_B3_ops};
 
 static ec_gf_op_t ec_gf8_mul_B4_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B4 = {
-    8,
-    { 5, 6, 7, 0, 1, 2, 3, 4, },
-    ec_gf8_mul_B4_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B4 = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_B4_ops};
 
 static ec_gf_op_t ec_gf8_mul_B5_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_COPY,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR3,   4,  8,  3 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B5 = {
-    9,
-    { 3, 4, 0, 7, 1, 5, 6, 2, 8, },
-    ec_gf8_mul_B5_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_COPY, 8, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR3, 4, 8, 3}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B5 = {9,
+                                    {
+                                        3,
+                                        4,
+                                        0,
+                                        7,
+                                        1,
+                                        5,
+                                        6,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_B5_ops};
 
 static ec_gf_op_t ec_gf8_mul_B6_ops[] = {
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B6 = {
-    8,
-    { 5, 3, 6, 4, 7, 0, 1, 2, },
-    ec_gf8_mul_B6_ops
-};
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B6 = {8,
+                                    {
+                                        5,
+                                        3,
+                                        6,
+                                        4,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_B6_ops};
 
 static ec_gf_op_t ec_gf8_mul_B7_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B7 = {
-    8,
-    { 5, 0, 1, 4, 2, 6, 7, 3, },
-    ec_gf8_mul_B7_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B7 = {8,
+                                    {
+                                        5,
+                                        0,
+                                        1,
+                                        4,
+                                        2,
+                                        6,
+                                        7,
+                                        3,
+                                    },
+                                    ec_gf8_mul_B7_ops};
 
 static ec_gf_op_t ec_gf8_mul_B8_ops[] = {
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B8 = {
-    8,
-    { 6, 4, 5, 1, 2, 0, 7, 3, },
-    ec_gf8_mul_B8_ops
-};
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B8 = {8,
+                                    {
+                                        6,
+                                        4,
+                                        5,
+                                        1,
+                                        2,
+                                        0,
+                                        7,
+                                        3,
+                                    },
+                                    ec_gf8_mul_B8_ops};
 
 static ec_gf_op_t ec_gf8_mul_B9_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR3,   0,  8,  2 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_B9 = {
-    9,
-    { 6, 7, 0, 2, 1, 4, 5, 3, 8, },
-    ec_gf8_mul_B9_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR3, 0, 8, 2}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_B9 = {9,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        2,
+                                        1,
+                                        4,
+                                        5,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_B9_ops};
 
 static ec_gf_op_t ec_gf8_mul_BA_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BA = {
-    8,
-    { 1, 2, 4, 3, 5, 6, 0, 7, },
-    ec_gf8_mul_BA_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BA = {8,
+                                    {
+                                        1,
+                                        2,
+                                        4,
+                                        3,
+                                        5,
+                                        6,
+                                        0,
+                                        7,
+                                    },
+                                    ec_gf8_mul_BA_ops};
 
 static ec_gf_op_t ec_gf8_mul_BB_ops[] = {
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BB = {
-    9,
-    { 7, 2, 1, 8, 3, 5, 6, 4, 0, },
-    ec_gf8_mul_BB_ops
-};
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_COPY, 8, 3, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 8, 5, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 8, 7, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BB = {9,
+                                    {
+                                        7,
+                                        2,
+                                        1,
+                                        8,
+                                        3,
+                                        5,
+                                        6,
+                                        4,
+                                        0,
+                                    },
+                                    ec_gf8_mul_BB_ops};
 
 static ec_gf_op_t ec_gf8_mul_BC_ops[] = {
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR3,   2,  8,  4 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BC = {
-    9,
-    { 2, 6, 3, 4, 5, 1, 7, 0, 8, },
-    ec_gf8_mul_BC_ops
-};
+    {EC_GF_OP_COPY, 8, 1, 0}, {EC_GF_OP_XOR2, 8, 2, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR3, 2, 8, 4},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BC = {9,
+                                    {
+                                        2,
+                                        6,
+                                        3,
+                                        4,
+                                        5,
+                                        1,
+                                        7,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_BC_ops};
 
 static ec_gf_op_t ec_gf8_mul_BD_ops[] = {
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BD = {
-    8,
-    { 4, 5, 0, 2, 7, 1, 6, 3, },
-    ec_gf8_mul_BD_ops
-};
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BD = {8,
+                                    {
+                                        4,
+                                        5,
+                                        0,
+                                        2,
+                                        7,
+                                        1,
+                                        6,
+                                        3,
+                                    },
+                                    ec_gf8_mul_BD_ops};
 
 static ec_gf_op_t ec_gf8_mul_BE_ops[] = {
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BE = {
-    8,
-    { 0, 6, 7, 4, 5, 1, 3, 2, },
-    ec_gf8_mul_BE_ops
-};
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BE = {8,
+                                    {
+                                        0,
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                        1,
+                                        3,
+                                        2,
+                                    },
+                                    ec_gf8_mul_BE_ops};
 
 static ec_gf_op_t ec_gf8_mul_BF_ops[] = {
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_BF = {
-    8,
-    { 5, 6, 1, 7, 3, 0, 2, 4, },
-    ec_gf8_mul_BF_ops
-};
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_BF = {8,
+                                    {
+                                        5,
+                                        6,
+                                        1,
+                                        7,
+                                        3,
+                                        0,
+                                        2,
+                                        4,
+                                    },
+                                    ec_gf8_mul_BF_ops};
 
 static ec_gf_op_t ec_gf8_mul_C0_ops[] = {
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C0 = {
-    8,
-    { 1, 2, 3, 4, 7, 5, 6, 0, },
-    ec_gf8_mul_C0_ops
-};
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C0 = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        7,
+                                        5,
+                                        6,
+                                        0,
+                                    },
+                                    ec_gf8_mul_C0_ops};
 
 static ec_gf_op_t ec_gf8_mul_C1_ops[] = {
-    { EC_GF_OP_XOR3,   8,  1,  2 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C1 = {
-    9,
-    { 5, 6, 7, 4, 1, 2, 3, 0, 8, },
-    ec_gf8_mul_C1_ops
-};
+    {EC_GF_OP_XOR3, 8, 1, 2}, {EC_GF_OP_XOR2, 8, 3, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 6, 8, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C1 = {9,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        4,
+                                        1,
+                                        2,
+                                        3,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_C1_ops};
 
 static ec_gf_op_t ec_gf8_mul_C2_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C2 = {
-    8,
-    { 7, 6, 3, 0, 1, 4, 5, 2, },
-    ec_gf8_mul_C2_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C2 = {8,
+                                    {
+                                        7,
+                                        6,
+                                        3,
+                                        0,
+                                        1,
+                                        4,
+                                        5,
+                                        2,
+                                    },
+                                    ec_gf8_mul_C2_ops};
 
 static ec_gf_op_t ec_gf8_mul_C3_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR3,   0,  2,  6 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR3,   9,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  9,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C3 = {
-    10,
-    { 5, 6, 4, 7, 1, 2, 3, 0, 8, 9, },
-    ec_gf8_mul_C3_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR3, 0, 2, 6}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR3, 9, 1, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 7, 9, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C3 = {10,
+                                    {
+                                        5,
+                                        6,
+                                        4,
+                                        7,
+                                        1,
+                                        2,
+                                        3,
+                                        0,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_C3_ops};
 
 static ec_gf_op_t ec_gf8_mul_C4_ops[] = {
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C4 = {
-    8,
-    { 0, 2, 1, 3, 4, 5, 6, 7, },
-    ec_gf8_mul_C4_ops
-};
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 1, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C4 = {8,
+                                    {
+                                        0,
+                                        2,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_C4_ops};
 
 static ec_gf_op_t ec_gf8_mul_C5_ops[] = {
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C5 = {
-    8,
-    { 4, 3, 5, 7, 6, 2, 0, 1, },
-    ec_gf8_mul_C5_ops
-};
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C5 = {8,
+                                    {
+                                        4,
+                                        3,
+                                        5,
+                                        7,
+                                        6,
+                                        2,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_C5_ops};
 
 static ec_gf_op_t ec_gf8_mul_C6_ops[] = {
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_COPY,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR3,   9,  5,  4 },
-    { EC_GF_OP_XOR2,   6,  9,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  9,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C6 = {
-    10,
-    { 6, 3, 0, 4, 5, 7, 2, 1, 8, 9, },
-    ec_gf8_mul_C6_ops
-};
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_COPY, 8, 4, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR3, 9, 5, 4},
+    {EC_GF_OP_XOR2, 6, 9, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 7, 9, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 6, 8, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C6 = {10,
+                                    {
+                                        6,
+                                        3,
+                                        0,
+                                        4,
+                                        5,
+                                        7,
+                                        2,
+                                        1,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_C6_ops};
 
 static ec_gf_op_t ec_gf8_mul_C7_ops[] = {
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C7 = {
-    8,
-    { 7, 0, 6, 2, 5, 3, 4, 1, },
-    ec_gf8_mul_C7_ops
-};
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C7 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        6,
+                                        2,
+                                        5,
+                                        3,
+                                        4,
+                                        1,
+                                    },
+                                    ec_gf8_mul_C7_ops};
 
 static ec_gf_op_t ec_gf8_mul_C8_ops[] = {
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C8 = {
-    8,
-    { 1, 3, 2, 4, 6, 7, 5, 0, },
-    ec_gf8_mul_C8_ops
-};
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C8 = {8,
+                                    {
+                                        1,
+                                        3,
+                                        2,
+                                        4,
+                                        6,
+                                        7,
+                                        5,
+                                        0,
+                                    },
+                                    ec_gf8_mul_C8_ops};
 
 static ec_gf_op_t ec_gf8_mul_C9_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_C9 = {
-    8,
-    { 2, 3, 4, 5, 6, 7, 0, 1, },
-    ec_gf8_mul_C9_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_C9 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_C9_ops};
 
 static ec_gf_op_t ec_gf8_mul_CA_ops[] = {
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CA = {
-    8,
-    { 1, 2, 5, 7, 3, 4, 0, 6, },
-    ec_gf8_mul_CA_ops
-};
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 4, 5, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CA = {8,
+                                    {
+                                        1,
+                                        2,
+                                        5,
+                                        7,
+                                        3,
+                                        4,
+                                        0,
+                                        6,
+                                    },
+                                    ec_gf8_mul_CA_ops};
 
 static ec_gf_op_t ec_gf8_mul_CB_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CB = {
-    8,
-    { 2, 3, 4, 5, 7, 6, 0, 1, },
-    ec_gf8_mul_CB_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CB = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        7,
+                                        6,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_CB_ops};
 
 static ec_gf_op_t ec_gf8_mul_CC_ops[] = {
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CC = {
-    8,
-    { 2, 7, 1, 0, 5, 6, 3, 4, },
-    ec_gf8_mul_CC_ops
-};
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CC = {8,
+                                    {
+                                        2,
+                                        7,
+                                        1,
+                                        0,
+                                        5,
+                                        6,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_CC_ops};
 
 static ec_gf_op_t ec_gf8_mul_CD_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CD = {
-    8,
-    { 0, 6, 1, 2, 7, 3, 4, 5, },
-    ec_gf8_mul_CD_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CD = {8,
+                                    {
+                                        0,
+                                        6,
+                                        1,
+                                        2,
+                                        7,
+                                        3,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_CD_ops};
 
 static ec_gf_op_t ec_gf8_mul_CE_ops[] = {
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_COPY,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR3,   3,  6,  8 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  2,  3 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CE = {
-    9,
-    { 5, 7, 3, 0, 2, 6, 4, 1, 8, },
-    ec_gf8_mul_CE_ops
-};
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_COPY, 8, 7, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR3, 3, 6, 8},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR3, 8, 2, 3},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CE = {9,
+                                    {
+                                        5,
+                                        7,
+                                        3,
+                                        0,
+                                        2,
+                                        6,
+                                        4,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_CE_ops};
 
 static ec_gf_op_t ec_gf8_mul_CF_ops[] = {
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_CF = {
-    8,
-    { 3, 6, 7, 0, 2, 4, 5, 1, },
-    ec_gf8_mul_CF_ops
-};
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_CF = {8,
+                                    {
+                                        3,
+                                        6,
+                                        7,
+                                        0,
+                                        2,
+                                        4,
+                                        5,
+                                        1,
+                                    },
+                                    ec_gf8_mul_CF_ops};
 
 static ec_gf_op_t ec_gf8_mul_D0_ops[] = {
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D0 = {
-    8,
-    { 5, 6, 7, 2, 0, 3, 1, 4, },
-    ec_gf8_mul_D0_ops
-};
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D0 = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        2,
+                                        0,
+                                        3,
+                                        1,
+                                        4,
+                                    },
+                                    ec_gf8_mul_D0_ops};
 
 static ec_gf_op_t ec_gf8_mul_D1_ops[] = {
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D1 = {
-    9,
-    { 5, 6, 3, 2, 0, 7, 4, 1, 8, },
-    ec_gf8_mul_D1_ops
-};
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR3, 8, 6, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D1 = {9,
+                                    {
+                                        5,
+                                        6,
+                                        3,
+                                        2,
+                                        0,
+                                        7,
+                                        4,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_D1_ops};
 
 static ec_gf_op_t ec_gf8_mul_D2_ops[] = {
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D2 = {
-    8,
-    { 7, 0, 2, 1, 3, 4, 6, 5, },
-    ec_gf8_mul_D2_ops
-};
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D2 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        2,
+                                        1,
+                                        3,
+                                        4,
+                                        6,
+                                        5,
+                                    },
+                                    ec_gf8_mul_D2_ops};
 
 static ec_gf_op_t ec_gf8_mul_D3_ops[] = {
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_COPY,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D3 = {
-    9,
-    { 0, 3, 2, 8, 4, 6, 7, 1, 5, },
-    ec_gf8_mul_D3_ops
-};
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_COPY, 8, 4, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 8, 6, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 1, 3, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D3 = {9,
+                                    {
+                                        0,
+                                        3,
+                                        2,
+                                        8,
+                                        4,
+                                        6,
+                                        7,
+                                        1,
+                                        5,
+                                    },
+                                    ec_gf8_mul_D3_ops};
 
 static ec_gf_op_t ec_gf8_mul_D4_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR3,   1,  7,  8 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D4 = {
-    9,
-    { 4, 1, 7, 5, 0, 6, 3, 2, 8, },
-    ec_gf8_mul_D4_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_COPY, 8, 1, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR3, 1, 7, 8},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D4 = {9,
+                                    {
+                                        4,
+                                        1,
+                                        7,
+                                        5,
+                                        0,
+                                        6,
+                                        3,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_D4_ops};
 
 static ec_gf_op_t ec_gf8_mul_D5_ops[] = {
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D5 = {
-    8,
-    { 6, 7, 4, 5, 2, 3, 1, 0, },
-    ec_gf8_mul_D5_ops
-};
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D5 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                        2,
+                                        3,
+                                        1,
+                                        0,
+                                    },
+                                    ec_gf8_mul_D5_ops};
 
 static ec_gf_op_t ec_gf8_mul_D6_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D6 = {
-    9,
-    { 0, 6, 2, 7, 1, 3, 4, 5, 8, },
-    ec_gf8_mul_D6_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D6 = {9,
+                                    {
+                                        0,
+                                        6,
+                                        2,
+                                        7,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        8,
+                                    },
+                                    ec_gf8_mul_D6_ops};
 
 static ec_gf_op_t ec_gf8_mul_D7_ops[] = {
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  5 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR3,   6,  7,  8 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D7 = {
-    9,
-    { 3, 4, 6, 5, 0, 7, 1, 2, 8, },
-    ec_gf8_mul_D7_ops
-};
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR3, 8, 3, 5}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR3, 6, 7, 8}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D7 = {9,
+                                    {
+                                        3,
+                                        4,
+                                        6,
+                                        5,
+                                        0,
+                                        7,
+                                        1,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_D7_ops};
 
 static ec_gf_op_t ec_gf8_mul_D8_ops[] = {
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D8 = {
-    8,
-    { 4, 5, 6, 7, 0, 1, 2, 3, },
-    ec_gf8_mul_D8_ops
-};
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D8 = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_D8_ops};
 
 static ec_gf_op_t ec_gf8_mul_D9_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_D9 = {
-    8,
-    { 1, 2, 6, 7, 4, 5, 0, 3, },
-    ec_gf8_mul_D9_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 7, 0, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_D9 = {8,
+                                    {
+                                        1,
+                                        2,
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                        0,
+                                        3,
+                                    },
+                                    ec_gf8_mul_D9_ops};
 
 static ec_gf_op_t ec_gf8_mul_DA_ops[] = {
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR3,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DA = {
-    9,
-    { 2, 5, 7, 1, 0, 4, 3, 6, 8, },
-    ec_gf8_mul_DA_ops
-};
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR3, 8, 2, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 2, 4, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DA = {9,
+                                    {
+                                        2,
+                                        5,
+                                        7,
+                                        1,
+                                        0,
+                                        4,
+                                        3,
+                                        6,
+                                        8,
+                                    },
+                                    ec_gf8_mul_DA_ops};
 
 static ec_gf_op_t ec_gf8_mul_DB_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DB = {
-    9,
-    { 7, 5, 6, 2, 3, 4, 1, 0, 8, },
-    ec_gf8_mul_DB_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 8, 4, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 6, 3, 0}, {EC_GF_OP_XOR2, 3, 8, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DB = {9,
+                                    {
+                                        7,
+                                        5,
+                                        6,
+                                        2,
+                                        3,
+                                        4,
+                                        1,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_DB_ops};
 
 static ec_gf_op_t ec_gf8_mul_DC_ops[] = {
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DC = {
-    8,
-    { 4, 5, 2, 6, 7, 1, 0, 3, },
-    ec_gf8_mul_DC_ops
-};
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DC = {8,
+                                    {
+                                        4,
+                                        5,
+                                        2,
+                                        6,
+                                        7,
+                                        1,
+                                        0,
+                                        3,
+                                    },
+                                    ec_gf8_mul_DC_ops};
 
 static ec_gf_op_t ec_gf8_mul_DD_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DD = {
-    8,
-    { 1, 2, 3, 6, 7, 0, 4, 5, },
-    ec_gf8_mul_DD_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DD = {8,
+                                    {
+                                        1,
+                                        2,
+                                        3,
+                                        6,
+                                        7,
+                                        0,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_DD_ops};
 
 static ec_gf_op_t ec_gf8_mul_DE_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DE = {
-    8,
-    { 0, 5, 2, 6, 7, 1, 3, 4, },
-    ec_gf8_mul_DE_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DE = {8,
+                                    {
+                                        0,
+                                        5,
+                                        2,
+                                        6,
+                                        7,
+                                        1,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_DE_ops};
 
 static ec_gf_op_t ec_gf8_mul_DF_ops[] = {
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_COPY,   9,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR3,   1,  9,  2 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_DF = {
-    10,
-    { 7, 2, 8, 4, 3, 1, 0, 6, 5, 9, },
-    ec_gf8_mul_DF_ops
-};
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 8, 3, 0},
+    {EC_GF_OP_COPY, 9, 0, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 8, 7, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR3, 1, 9, 2}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_DF = {10,
+                                    {
+                                        7,
+                                        2,
+                                        8,
+                                        4,
+                                        3,
+                                        1,
+                                        0,
+                                        6,
+                                        5,
+                                        9,
+                                    },
+                                    ec_gf8_mul_DF_ops};
 
 static ec_gf_op_t ec_gf8_mul_E0_ops[] = {
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E0 = {
-    8,
-    { 2, 3, 4, 7, 5, 6, 0, 1, },
-    ec_gf8_mul_E0_ops
-};
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 4, 1, 0}, {EC_GF_OP_XOR2, 7, 1, 0},
+    {EC_GF_OP_XOR2, 5, 7, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E0 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        4,
+                                        7,
+                                        5,
+                                        6,
+                                        0,
+                                        1,
+                                    },
+                                    ec_gf8_mul_E0_ops};
 
 static ec_gf_op_t ec_gf8_mul_E1_ops[] = {
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR3,   9,  5,  3 },
-    { EC_GF_OP_XOR2,   0,  9,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  9,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E1 = {
-    10,
-    { 0, 7, 1, 3, 4, 5, 6, 2, 8, 9, },
-    ec_gf8_mul_E1_ops
-};
+    {EC_GF_OP_COPY, 8, 1, 0}, {EC_GF_OP_XOR2, 8, 7, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR3, 9, 5, 3},
+    {EC_GF_OP_XOR2, 0, 9, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 4, 9, 0}, {EC_GF_OP_XOR2, 0, 2, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E1 = {10,
+                                    {
+                                        0,
+                                        7,
+                                        1,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        2,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_E1_ops};
 
 static ec_gf_op_t ec_gf8_mul_E2_ops[] = {
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E2 = {
-    8,
-    { 2, 3, 7, 1, 5, 6, 0, 4, },
-    ec_gf8_mul_E2_ops
-};
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E2 = {8,
+                                    {
+                                        2,
+                                        3,
+                                        7,
+                                        1,
+                                        5,
+                                        6,
+                                        0,
+                                        4,
+                                    },
+                                    ec_gf8_mul_E2_ops};
 
 static ec_gf_op_t ec_gf8_mul_E3_ops[] = {
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  2,  7 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR3,   6,  8,  4 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E3 = {
-    9,
-    { 5, 4, 7, 2, 1, 3, 6, 0, 8, },
-    ec_gf8_mul_E3_ops
-};
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 3, 1, 0},
+    {EC_GF_OP_XOR3, 8, 2, 7}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 0, 1, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_XOR2, 0, 8, 0}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR3, 6, 8, 4},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E3 = {9,
+                                    {
+                                        5,
+                                        4,
+                                        7,
+                                        2,
+                                        1,
+                                        3,
+                                        6,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_E3_ops};
 
 static ec_gf_op_t ec_gf8_mul_E4_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E4 = {
-    8,
-    { 7, 0, 1, 6, 3, 4, 2, 5, },
-    ec_gf8_mul_E4_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 4, 5, 0},
+    {EC_GF_OP_XOR2, 3, 4, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E4 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        1,
+                                        6,
+                                        3,
+                                        4,
+                                        2,
+                                        5,
+                                    },
+                                    ec_gf8_mul_E4_ops};
 
 static ec_gf_op_t ec_gf8_mul_E5_ops[] = {
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E5 = {
-    9,
-    { 4, 5, 3, 6, 7, 1, 0, 2, 8, },
-    ec_gf8_mul_E5_ops
-};
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_COPY, 8, 0, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E5 = {9,
+                                    {
+                                        4,
+                                        5,
+                                        3,
+                                        6,
+                                        7,
+                                        1,
+                                        0,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_E5_ops};
 
 static ec_gf_op_t ec_gf8_mul_E6_ops[] = {
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E6 = {
-    8,
-    { 5, 4, 3, 6, 7, 0, 1, 2, },
-    ec_gf8_mul_E6_ops
-};
+    {EC_GF_OP_XOR2, 6, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 1, 4, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E6 = {8,
+                                    {
+                                        5,
+                                        4,
+                                        3,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_E6_ops};
 
 static ec_gf_op_t ec_gf8_mul_E7_ops[] = {
-    { EC_GF_OP_COPY,   8,  6,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR3,   9,  0,  6 },
-    { EC_GF_OP_XOR2,   4,  9,  0 },
-    { EC_GF_OP_XOR2,   5,  9,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E7 = {
-    10,
-    { 1, 4, 3, 6, 7, 5, 2, 0, 8, 9, },
-    ec_gf8_mul_E7_ops
-};
+    {EC_GF_OP_COPY, 8, 6, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR3, 9, 0, 6}, {EC_GF_OP_XOR2, 4, 9, 0},
+    {EC_GF_OP_XOR2, 5, 9, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E7 = {10,
+                                    {
+                                        1,
+                                        4,
+                                        3,
+                                        6,
+                                        7,
+                                        5,
+                                        2,
+                                        0,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_E7_ops};
 
 static ec_gf_op_t ec_gf8_mul_E8_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E8 = {
-    8,
-    { 1, 4, 2, 7, 3, 0, 5, 6, },
-    ec_gf8_mul_E8_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 2, 5, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 1, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E8 = {8,
+                                    {
+                                        1,
+                                        4,
+                                        2,
+                                        7,
+                                        3,
+                                        0,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_E8_ops};
 
 static ec_gf_op_t ec_gf8_mul_E9_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_COPY,   8,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR3,   1,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_E9 = {
-    9,
-    { 6, 2, 0, 3, 4, 1, 5, 7, 8, },
-    ec_gf8_mul_E9_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_COPY, 8, 1, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 6, 3, 0},
+    {EC_GF_OP_XOR2, 4, 6, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR3, 1, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_E9 = {9,
+                                    {
+                                        6,
+                                        2,
+                                        0,
+                                        3,
+                                        4,
+                                        1,
+                                        5,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_E9_ops};
 
 static ec_gf_op_t ec_gf8_mul_EA_ops[] = {
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_EA = {
-    8,
-    { 3, 4, 5, 6, 7, 0, 1, 2, },
-    ec_gf8_mul_EA_ops
-};
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_EA = {8,
+                                    {
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_EA_ops};
 
 static ec_gf_op_t ec_gf8_mul_EB_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_EB = {
-    8,
-    { 3, 4, 5, 6, 7, 0, 1, 2, },
-    ec_gf8_mul_EB_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_EB = {8,
+                                    {
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                    },
+                                    ec_gf8_mul_EB_ops};
 
 static ec_gf_op_t ec_gf8_mul_EC_ops[] = {
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_EC = {
-    9,
-    { 7, 4, 3, 0, 2, 5, 1, 6, 8, },
-    ec_gf8_mul_EC_ops
-};
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR3, 8, 4, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 7, 3, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_EC = {9,
+                                    {
+                                        7,
+                                        4,
+                                        3,
+                                        0,
+                                        2,
+                                        5,
+                                        1,
+                                        6,
+                                        8,
+                                    },
+                                    ec_gf8_mul_EC_ops};
 
 static ec_gf_op_t ec_gf8_mul_ED_ops[] = {
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_ED = {
-    8,
-    { 5, 6, 7, 0, 1, 4, 3, 2, },
-    ec_gf8_mul_ED_ops
-};
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 4, 0, 0},
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 3, 6, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 5, 2, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_ED = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        4,
+                                        3,
+                                        2,
+                                    },
+                                    ec_gf8_mul_ED_ops};
 
 static ec_gf_op_t ec_gf8_mul_EE_ops[] = {
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  2,  3 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_EE = {
-    9,
-    { 6, 4, 5, 7, 2, 3, 0, 1, 8, },
-    ec_gf8_mul_EE_ops
-};
+    {EC_GF_OP_XOR2, 5, 3, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR3, 8, 2, 3},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_XOR2, 4, 8, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 8, 5, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 1, 8, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 6, 0, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_EE = {9,
+                                    {
+                                        6,
+                                        4,
+                                        5,
+                                        7,
+                                        2,
+                                        3,
+                                        0,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_EE_ops};
 
 static ec_gf_op_t ec_gf8_mul_EF_ops[] = {
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_COPY,   8,  0,  0 },
-    { EC_GF_OP_XOR2,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   6,  8,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_EF = {
-    9,
-    { 6, 4, 5, 7, 2, 0, 3, 1, 8, },
-    ec_gf8_mul_EF_ops
-};
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_COPY, 8, 0, 0},
+    {EC_GF_OP_XOR2, 8, 2, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 6, 8, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 7, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_EF = {9,
+                                    {
+                                        6,
+                                        4,
+                                        5,
+                                        7,
+                                        2,
+                                        0,
+                                        3,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_EF_ops};
 
 static ec_gf_op_t ec_gf8_mul_F0_ops[] = {
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR3,   8,  3,  6 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   1,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F0 = {
-    9,
-    { 3, 4, 6, 1, 2, 0, 5, 7, 8, },
-    ec_gf8_mul_F0_ops
-};
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR3, 8, 3, 6},
+    {EC_GF_OP_XOR2, 5, 8, 0}, {EC_GF_OP_XOR2, 8, 4, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 7, 8, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 1, 8, 0},
+    {EC_GF_OP_XOR2, 0, 2, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F0 = {9,
+                                    {
+                                        3,
+                                        4,
+                                        6,
+                                        1,
+                                        2,
+                                        0,
+                                        5,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_F0_ops};
 
 static ec_gf_op_t ec_gf8_mul_F1_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_COPY,   9,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   9,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  9,  0 },
-    { EC_GF_OP_XOR2,   4,  9,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR3,   9,  8,  7 },
-    { EC_GF_OP_XOR2,   1,  9,  0 },
-    { EC_GF_OP_XOR2,   5,  9,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F1 = {
-    10,
-    { 7, 2, 6, 3, 5, 1, 4, 0, 8, 9, },
-    ec_gf8_mul_F1_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_COPY, 8, 3, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 2, 3, 0}, {EC_GF_OP_COPY, 9, 2, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 9, 0, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 5, 2, 0},
+    {EC_GF_OP_XOR2, 7, 9, 0}, {EC_GF_OP_XOR2, 4, 9, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR3, 9, 8, 7},
+    {EC_GF_OP_XOR2, 1, 9, 0}, {EC_GF_OP_XOR2, 5, 9, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F1 = {10,
+                                    {
+                                        7,
+                                        2,
+                                        6,
+                                        3,
+                                        5,
+                                        1,
+                                        4,
+                                        0,
+                                        8,
+                                        9,
+                                    },
+                                    ec_gf8_mul_F1_ops};
 
 static ec_gf_op_t ec_gf8_mul_F2_ops[] = {
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_XOR3,   8,  6,  4 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F2 = {
-    9,
-    { 1, 0, 6, 7, 4, 5, 2, 3, 8, },
-    ec_gf8_mul_F2_ops
-};
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 7, 2, 0},
+    {EC_GF_OP_XOR2, 0, 6, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 2, 3, 0},
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_XOR3, 8, 6, 4},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 8, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F2 = {9,
+                                    {
+                                        1,
+                                        0,
+                                        6,
+                                        7,
+                                        4,
+                                        5,
+                                        2,
+                                        3,
+                                        8,
+                                    },
+                                    ec_gf8_mul_F2_ops};
 
 static ec_gf_op_t ec_gf8_mul_F3_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F3 = {
-    8,
-    { 5, 6, 7, 0, 1, 2, 3, 4, },
-    ec_gf8_mul_F3_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 6, 5, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F3 = {8,
+                                    {
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                    },
+                                    ec_gf8_mul_F3_ops};
 
 static ec_gf_op_t ec_gf8_mul_F4_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F4 = {
-    8,
-    { 0, 1, 2, 3, 4, 5, 6, 7, },
-    ec_gf8_mul_F4_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 1, 7, 0}, {EC_GF_OP_XOR2, 3, 7, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F4 = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                    },
+                                    ec_gf8_mul_F4_ops};
 
 static ec_gf_op_t ec_gf8_mul_F5_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F5 = {
-    8,
-    { 7, 0, 1, 2, 3, 4, 5, 6, },
-    ec_gf8_mul_F5_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F5 = {8,
+                                    {
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                        6,
+                                    },
+                                    ec_gf8_mul_F5_ops};
 
 static ec_gf_op_t ec_gf8_mul_F6_ops[] = {
-    { EC_GF_OP_XOR2,   3,  1,  0 },
-    { EC_GF_OP_COPY,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_COPY,   9,  3,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   9,  4,  0 },
-    { EC_GF_OP_XOR2,   4,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  9,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR3,   7,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F6 = {
-    10,
-    { 0, 6, 2, 7, 4, 3, 5, 9, 1, 8, },
-    ec_gf8_mul_F6_ops
-};
+    {EC_GF_OP_XOR2, 3, 1, 0}, {EC_GF_OP_COPY, 8, 3, 0},
+    {EC_GF_OP_XOR2, 3, 5, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_COPY, 9, 3, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 2, 7, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 9, 4, 0}, {EC_GF_OP_XOR2, 4, 1, 0},
+    {EC_GF_OP_XOR2, 6, 9, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 5, 7, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR3, 7, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F6 = {10,
+                                    {
+                                        0,
+                                        6,
+                                        2,
+                                        7,
+                                        4,
+                                        3,
+                                        5,
+                                        9,
+                                        1,
+                                        8,
+                                    },
+                                    ec_gf8_mul_F6_ops};
 
 static ec_gf_op_t ec_gf8_mul_F7_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F7 = {
-    8,
-    { 6, 7, 0, 1, 2, 3, 4, 5, },
-    ec_gf8_mul_F7_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 3, 2, 0}, {EC_GF_OP_XOR2, 4, 3, 0},
+    {EC_GF_OP_XOR2, 5, 4, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F7 = {8,
+                                    {
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                        4,
+                                        5,
+                                    },
+                                    ec_gf8_mul_F7_ops};
 
 static ec_gf_op_t ec_gf8_mul_F8_ops[] = {
-    { EC_GF_OP_XOR2,   4,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  5,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F8 = {
-    8,
-    { 6, 2, 0, 1, 4, 5, 3, 7, },
-    ec_gf8_mul_F8_ops
-};
+    {EC_GF_OP_XOR2, 4, 0, 0}, {EC_GF_OP_XOR2, 3, 5, 0},
+    {EC_GF_OP_XOR2, 6, 4, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 1, 6, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 5, 1, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 6, 7, 0},
+    {EC_GF_OP_XOR2, 0, 3, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F8 = {8,
+                                    {
+                                        6,
+                                        2,
+                                        0,
+                                        1,
+                                        4,
+                                        5,
+                                        3,
+                                        7,
+                                    },
+                                    ec_gf8_mul_F8_ops};
 
 static ec_gf_op_t ec_gf8_mul_F9_ops[] = {
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  4,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR3,   8,  7,  1 },
-    { EC_GF_OP_XOR2,   1,  3,  0 },
-    { EC_GF_OP_XOR2,   4,  8,  0 },
-    { EC_GF_OP_XOR2,   5,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_F9 = {
-    9,
-    { 4, 1, 7, 6, 0, 3, 5, 2, 8, },
-    ec_gf8_mul_F9_ops
-};
+    {EC_GF_OP_XOR2, 1, 5, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 0, 5, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 6, 4, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR3, 8, 7, 1}, {EC_GF_OP_XOR2, 1, 3, 0},
+    {EC_GF_OP_XOR2, 4, 8, 0}, {EC_GF_OP_XOR2, 5, 8, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_F9 = {9,
+                                    {
+                                        4,
+                                        1,
+                                        7,
+                                        6,
+                                        0,
+                                        3,
+                                        5,
+                                        2,
+                                        8,
+                                    },
+                                    ec_gf8_mul_F9_ops};
 
 static ec_gf_op_t ec_gf8_mul_FA_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  2,  0 },
-    { EC_GF_OP_XOR2,   1,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FA = {
-    8,
-    { 0, 1, 2, 4, 5, 6, 7, 3, },
-    ec_gf8_mul_FA_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 2, 1, 0}, {EC_GF_OP_XOR2, 0, 7, 0},
+    {EC_GF_OP_XOR2, 7, 2, 0}, {EC_GF_OP_XOR2, 1, 5, 0},
+    {EC_GF_OP_XOR2, 3, 7, 0}, {EC_GF_OP_XOR2, 5, 0, 0},
+    {EC_GF_OP_XOR2, 7, 6, 0}, {EC_GF_OP_XOR2, 0, 3, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FA = {8,
+                                    {
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        3,
+                                    },
+                                    ec_gf8_mul_FA_ops};
 
 static ec_gf_op_t ec_gf8_mul_FB_ops[] = {
-    { EC_GF_OP_XOR2,   1,  0,  0 },
-    { EC_GF_OP_XOR2,   2,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   3,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  7,  0 },
-    { EC_GF_OP_XOR2,   2,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  6,  0 },
-    { EC_GF_OP_XOR2,   7,  6,  0 },
-    { EC_GF_OP_XOR2,   4,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  5,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FB = {
-    8,
-    { 4, 5, 6, 7, 0, 1, 2, 3, },
-    ec_gf8_mul_FB_ops
-};
+    {EC_GF_OP_XOR2, 1, 0, 0}, {EC_GF_OP_XOR2, 2, 1, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 3, 2, 0},
+    {EC_GF_OP_XOR2, 0, 7, 0}, {EC_GF_OP_XOR2, 2, 7, 0},
+    {EC_GF_OP_XOR2, 1, 6, 0}, {EC_GF_OP_XOR2, 7, 6, 0},
+    {EC_GF_OP_XOR2, 4, 3, 0}, {EC_GF_OP_XOR2, 6, 5, 0},
+    {EC_GF_OP_XOR2, 7, 4, 0}, {EC_GF_OP_XOR2, 5, 4, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FB = {8,
+                                    {
+                                        4,
+                                        5,
+                                        6,
+                                        7,
+                                        0,
+                                        1,
+                                        2,
+                                        3,
+                                    },
+                                    ec_gf8_mul_FB_ops};
 
 static ec_gf_op_t ec_gf8_mul_FC_ops[] = {
-    { EC_GF_OP_XOR2,   7,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  1,  0 },
-    { EC_GF_OP_COPY,   9,  3,  0 },
-    { EC_GF_OP_XOR3,   8,  5,  7 },
-    { EC_GF_OP_XOR2,   3,  6,  0 },
-    { EC_GF_OP_XOR2,   8,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  8,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   3,  4,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   6,  0,  0 },
-    { EC_GF_OP_XOR3,   0,  9,  2 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FC = {
-    10,
-    { 5, 6, 3, 7, 1, 8, 0, 4, 2, 9, },
-    ec_gf8_mul_FC_ops
-};
+    {EC_GF_OP_XOR2, 7, 0, 0}, {EC_GF_OP_XOR2, 7, 4, 0},
+    {EC_GF_OP_XOR2, 5, 1, 0}, {EC_GF_OP_COPY, 9, 3, 0},
+    {EC_GF_OP_XOR3, 8, 5, 7}, {EC_GF_OP_XOR2, 3, 6, 0},
+    {EC_GF_OP_XOR2, 8, 3, 0}, {EC_GF_OP_XOR2, 2, 8, 0},
+    {EC_GF_OP_XOR2, 1, 2, 0}, {EC_GF_OP_XOR2, 4, 2, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 3, 4, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 6, 0, 0},
+    {EC_GF_OP_XOR3, 0, 9, 2}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FC = {10,
+                                    {
+                                        5,
+                                        6,
+                                        3,
+                                        7,
+                                        1,
+                                        8,
+                                        0,
+                                        4,
+                                        2,
+                                        9,
+                                    },
+                                    ec_gf8_mul_FC_ops};
 
 static ec_gf_op_t ec_gf8_mul_FD_ops[] = {
-    { EC_GF_OP_XOR2,   7,  1,  0 },
-    { EC_GF_OP_COPY,   8,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  0,  0 },
-    { EC_GF_OP_XOR2,   7,  5,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  5,  0 },
-    { EC_GF_OP_XOR2,   1,  2,  0 },
-    { EC_GF_OP_XOR2,   0,  1,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR3,   1,  8,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FD = {
-    9,
-    { 5, 3, 7, 6, 1, 2, 4, 0, 8, },
-    ec_gf8_mul_FD_ops
-};
+    {EC_GF_OP_XOR2, 7, 1, 0}, {EC_GF_OP_COPY, 8, 7, 0},
+    {EC_GF_OP_XOR2, 5, 0, 0}, {EC_GF_OP_XOR2, 7, 5, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 4, 7, 0},
+    {EC_GF_OP_XOR2, 5, 6, 0}, {EC_GF_OP_XOR2, 0, 4, 0},
+    {EC_GF_OP_XOR2, 3, 0, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 2, 5, 0}, {EC_GF_OP_XOR2, 1, 2, 0},
+    {EC_GF_OP_XOR2, 0, 1, 0}, {EC_GF_OP_XOR2, 6, 1, 0},
+    {EC_GF_OP_XOR3, 1, 8, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FD = {9,
+                                    {
+                                        5,
+                                        3,
+                                        7,
+                                        6,
+                                        1,
+                                        2,
+                                        4,
+                                        0,
+                                        8,
+                                    },
+                                    ec_gf8_mul_FD_ops};
 
 static ec_gf_op_t ec_gf8_mul_FE_ops[] = {
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_COPY,   8,  2,  0 },
-    { EC_GF_OP_XOR2,   2,  4,  0 },
-    { EC_GF_OP_XOR2,   6,  2,  0 },
-    { EC_GF_OP_XOR2,   8,  5,  0 },
-    { EC_GF_OP_XOR2,   5,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  1,  0 },
-    { EC_GF_OP_XOR2,   0,  6,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   7,  8,  0 },
-    { EC_GF_OP_XOR2,   3,  0,  0 },
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR2,   0,  4,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FE = {
-    9,
-    { 3, 4, 8, 2, 5, 0, 6, 1, 7, },
-    ec_gf8_mul_FE_ops
-};
+    {EC_GF_OP_XOR2, 2, 0, 0}, {EC_GF_OP_COPY, 8, 2, 0},
+    {EC_GF_OP_XOR2, 2, 4, 0}, {EC_GF_OP_XOR2, 6, 2, 0},
+    {EC_GF_OP_XOR2, 8, 5, 0}, {EC_GF_OP_XOR2, 5, 6, 0},
+    {EC_GF_OP_XOR2, 6, 1, 0}, {EC_GF_OP_XOR2, 0, 6, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 7, 8, 0}, {EC_GF_OP_XOR2, 3, 0, 0},
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR2, 0, 4, 0}, {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FE = {9,
+                                    {
+                                        3,
+                                        4,
+                                        8,
+                                        2,
+                                        5,
+                                        0,
+                                        6,
+                                        1,
+                                        7,
+                                    },
+                                    ec_gf8_mul_FE_ops};
 
 static ec_gf_op_t ec_gf8_mul_FF_ops[] = {
-    { EC_GF_OP_XOR2,   4,  7,  0 },
-    { EC_GF_OP_COPY,   9,  0,  0 },
-    { EC_GF_OP_COPY,   8,  4,  0 },
-    { EC_GF_OP_XOR2,   9,  1,  0 },
-    { EC_GF_OP_XOR2,   4,  2,  0 },
-    { EC_GF_OP_XOR2,   9,  4,  0 },
-    { EC_GF_OP_XOR2,   0,  5,  0 },
-    { EC_GF_OP_XOR2,   2,  0,  0 },
-    { EC_GF_OP_XOR2,   3,  9,  0 },
-    { EC_GF_OP_XOR2,   7,  3,  0 },
-    { EC_GF_OP_XOR2,   2,  6,  0 },
-    { EC_GF_OP_XOR2,   5,  3,  0 },
-    { EC_GF_OP_XOR2,   6,  7,  0 },
-    { EC_GF_OP_XOR2,   1,  7,  0 },
-    { EC_GF_OP_XOR3,   3,  8,  5 },
-    { EC_GF_OP_XOR2,   4,  6,  0 },
-    { EC_GF_OP_END,    0,  0,  0 }
-};
-
-static ec_gf_mul_t ec_gf8_mul_FF = {
-    10,
-    { 6, 5, 0, 1, 2, 4, 9, 3, 7, 8, },
-    ec_gf8_mul_FF_ops
-};
+    {EC_GF_OP_XOR2, 4, 7, 0}, {EC_GF_OP_COPY, 9, 0, 0},
+    {EC_GF_OP_COPY, 8, 4, 0}, {EC_GF_OP_XOR2, 9, 1, 0},
+    {EC_GF_OP_XOR2, 4, 2, 0}, {EC_GF_OP_XOR2, 9, 4, 0},
+    {EC_GF_OP_XOR2, 0, 5, 0}, {EC_GF_OP_XOR2, 2, 0, 0},
+    {EC_GF_OP_XOR2, 3, 9, 0}, {EC_GF_OP_XOR2, 7, 3, 0},
+    {EC_GF_OP_XOR2, 2, 6, 0}, {EC_GF_OP_XOR2, 5, 3, 0},
+    {EC_GF_OP_XOR2, 6, 7, 0}, {EC_GF_OP_XOR2, 1, 7, 0},
+    {EC_GF_OP_XOR3, 3, 8, 5}, {EC_GF_OP_XOR2, 4, 6, 0},
+    {EC_GF_OP_END, 0, 0, 0}};
+
+static ec_gf_mul_t ec_gf8_mul_FF = {10,
+                                    {
+                                        6,
+                                        5,
+                                        0,
+                                        1,
+                                        2,
+                                        4,
+                                        9,
+                                        3,
+                                        7,
+                                        8,
+                                    },
+                                    ec_gf8_mul_FF_ops};
 
 ec_gf_mul_t *ec_gf8_mul[] = {
     &ec_gf8_mul_00, &ec_gf8_mul_01, &ec_gf8_mul_02, &ec_gf8_mul_03,
@@ -5955,5 +5879,4 @@ ec_gf_mul_t *ec_gf8_mul[] = {
     &ec_gf8_mul_F0, &ec_gf8_mul_F1, &ec_gf8_mul_F2, &ec_gf8_mul_F3,
     &ec_gf8_mul_F4, &ec_gf8_mul_F5, &ec_gf8_mul_F6, &ec_gf8_mul_F7,
     &ec_gf8_mul_F8, &ec_gf8_mul_F9, &ec_gf8_mul_FA, &ec_gf8_mul_FB,
-    &ec_gf8_mul_FC, &ec_gf8_mul_FD, &ec_gf8_mul_FE, &ec_gf8_mul_FF
-};
+    &ec_gf8_mul_FC, &ec_gf8_mul_FD, &ec_gf8_mul_FE, &ec_gf8_mul_FF};
diff --git a/xlators/cluster/ec/src/ec-heal.c b/xlators/cluster/ec/src/ec-heal.c
index 976018c9e29..229c0683d91 100644
--- a/xlators/cluster/ec/src/ec-heal.c
+++ b/xlators/cluster/ec/src/ec-heal.c
@@ -27,84 +27,104 @@
 #include "ec-fops.h"
 #include "ec-heald.h"
 
-#define EC_COUNT(array, max) ({int __i; int __res = 0; for (__i = 0; __i < max; __i++) if (array[__i]) __res++; __res; })
-#define EC_INTERSECT(dst, src1, src2, max) ({int __i; for (__i = 0; __i < max; __i++) dst[__i] = src1[__i] && src2[__i]; })
-#define EC_ADJUST_SOURCE(source, sources, max) ({int __i; if (sources[source] == 0) {source = -1; for (__i = 0; __i < max; __i++) if (sources[__i]) source = __i; } })
-#define IA_EQUAL(f, s, field) (memcmp (&(f.ia_##field), &(s.ia_##field), sizeof (s.ia_##field)) == 0)
-#define EC_REPLIES_ALLOC(replies, numsubvols) do {              \
-        int __i = 0;                                            \
-        replies = alloca0(numsubvols * sizeof (*replies));      \
-        for (__i = 0; __i < numsubvols; __i++)                  \
-                INIT_LIST_HEAD (&replies[__i].entries.list);    \
-        } while (0)
-
+#define EC_COUNT(array, max)                                                   \
+    ({                                                                         \
+        int __i;                                                               \
+        int __res = 0;                                                         \
+        for (__i = 0; __i < max; __i++)                                        \
+            if (array[__i])                                                    \
+                __res++;                                                       \
+        __res;                                                                 \
+    })
+#define EC_INTERSECT(dst, src1, src2, max)                                     \
+    ({                                                                         \
+        int __i;                                                               \
+        for (__i = 0; __i < max; __i++)                                        \
+            dst[__i] = src1[__i] && src2[__i];                                 \
+    })
+#define EC_ADJUST_SOURCE(source, sources, max)                                 \
+    ({                                                                         \
+        int __i;                                                               \
+        if (sources[source] == 0) {                                            \
+            source = -1;                                                       \
+            for (__i = 0; __i < max; __i++)                                    \
+                if (sources[__i])                                              \
+                    source = __i;                                              \
+        }                                                                      \
+    })
+#define IA_EQUAL(f, s, field)                                                  \
+    (memcmp(&(f.ia_##field), &(s.ia_##field), sizeof(s.ia_##field)) == 0)
+#define EC_REPLIES_ALLOC(replies, numsubvols)                                  \
+    do {                                                                       \
+        int __i = 0;                                                           \
+        replies = alloca0(numsubvols * sizeof(*replies));                      \
+        for (__i = 0; __i < numsubvols; __i++)                                 \
+            INIT_LIST_HEAD(&replies[__i].entries.list);                        \
+    } while (0)
 
 struct ec_name_data {
-        call_frame_t *frame;
-        unsigned char *participants;
-        unsigned char *failed_on;
-        unsigned char *gfidless;
-        unsigned char *enoent;
-        unsigned char *same;
-        char *name;
-        inode_t *parent;
-        default_args_cbk_t *replies;
+    call_frame_t *frame;
+    unsigned char *participants;
+    unsigned char *failed_on;
+    unsigned char *gfidless;
+    unsigned char *enoent;
+    unsigned char *same;
+    char *name;
+    inode_t *parent;
+    default_args_cbk_t *replies;
 };
 
-static char *ec_ignore_xattrs[] = {
-        GF_SELINUX_XATTR_KEY,
-        QUOTA_SIZE_KEY,
-        NULL
-};
+static char *ec_ignore_xattrs[] = {GF_SELINUX_XATTR_KEY, QUOTA_SIZE_KEY, NULL};
 
 static gf_boolean_t
-ec_ignorable_key_match (dict_t *dict, char *key, data_t *val, void *mdata)
+ec_ignorable_key_match(dict_t *dict, char *key, data_t *val, void *mdata)
 {
-        int i = 0;
+    int i = 0;
 
-        if (!key)
-                goto out;
+    if (!key)
+        goto out;
 
-        if (strncmp (key, EC_XATTR_PREFIX, SLEN (EC_XATTR_PREFIX)) == 0)
-                        return _gf_true;
+    if (strncmp(key, EC_XATTR_PREFIX, SLEN(EC_XATTR_PREFIX)) == 0)
+        return _gf_true;
 
-        for (i = 0; ec_ignore_xattrs[i]; i++) {
-                if (!strcmp (key, ec_ignore_xattrs[i]))
-                       return _gf_true;
-        }
+    for (i = 0; ec_ignore_xattrs[i]; i++) {
+        if (!strcmp(key, ec_ignore_xattrs[i]))
+            return _gf_true;
+    }
 
 out:
-        return _gf_false;
+    return _gf_false;
 }
 
 static gf_boolean_t
-ec_sh_key_match (dict_t *dict, char *key, data_t *val, void *mdata)
+ec_sh_key_match(dict_t *dict, char *key, data_t *val, void *mdata)
 {
-        return !ec_ignorable_key_match (dict, key, val, mdata);
+    return !ec_ignorable_key_match(dict, key, val, mdata);
 }
 /* FOP: heal */
 
-uintptr_t ec_heal_check(ec_fop_data_t * fop, uintptr_t * pgood)
+uintptr_t
+ec_heal_check(ec_fop_data_t *fop, uintptr_t *pgood)
 {
-    ec_cbk_data_t * cbk;
-    uintptr_t mask[2] = { 0, 0 };
+    ec_cbk_data_t *cbk;
+    uintptr_t mask[2] = {0, 0};
 
     list_for_each_entry(cbk, &fop->cbk_list, list)
     {
         mask[cbk->op_ret >= 0] |= cbk->mask;
     }
 
-    if (pgood != NULL)
-    {
+    if (pgood != NULL) {
         *pgood = mask[1];
     }
 
     return mask[0];
 }
 
-void ec_heal_update(ec_fop_data_t * fop, int32_t is_open)
+void
+ec_heal_update(ec_fop_data_t *fop, int32_t is_open)
 {
-    ec_heal_t * heal = fop->data;
+    ec_heal_t *heal = fop->data;
     uintptr_t good, bad;
 
     bad = ec_heal_check(fop, &good);
@@ -112,8 +132,7 @@ void ec_heal_update(ec_fop_data_t * fop, int32_t is_open)
     LOCK(&heal->lock);
 
     heal->bad &= ~bad;
-    if (is_open)
-    {
+    if (is_open) {
         heal->open |= good;
     }
 
@@ -122,9 +141,10 @@ void ec_heal_update(ec_fop_data_t * fop, int32_t is_open)
     fop->error = 0;
 }
 
-void ec_heal_avoid(ec_fop_data_t * fop)
+void
+ec_heal_avoid(ec_fop_data_t *fop)
 {
-    ec_heal_t * heal = fop->data;
+    ec_heal_t *heal = fop->data;
     uintptr_t bad;
 
     bad = ec_heal_check(fop, NULL);
@@ -136,22 +156,24 @@ void ec_heal_avoid(ec_fop_data_t * fop)
     UNLOCK(&heal->lock);
 }
 
-int32_t ec_heal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+int32_t
+ec_heal_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     ec_heal_t *heal = fop->data;
 
     if (op_ret >= 0) {
-        GF_ASSERT(ec_set_inode_size(heal->fop, heal->fd->inode,
-                                    heal->total_size));
+        GF_ASSERT(
+            ec_set_inode_size(heal->fop, heal->fd->inode, heal->total_size));
     }
 
     return 0;
 }
 
-void ec_heal_lock(ec_heal_t *heal, int32_t type, fd_t *fd, loc_t *loc,
-                  off_t offset, size_t size)
+void
+ec_heal_lock(ec_heal_t *heal, int32_t type, fd_t *fd, loc_t *loc, off_t offset,
+             size_t size)
 {
     struct gf_flock flock;
     fop_inodelk_cbk_t cbk = NULL;
@@ -176,15 +198,12 @@ void ec_heal_lock(ec_heal_t *heal, int32_t type, fd_t *fd, loc_t *loc,
         cbk = ec_heal_lock_cbk;
     }
 
-    if (fd != NULL)
-    {
+    if (fd != NULL) {
         ec_finodelk(heal->fop->frame, heal->xl,
                     &heal->fop->frame->root->lk_owner, heal->fop->mask,
                     EC_MINIMUM_ALL, cbk, heal, heal->xl->name, fd, F_SETLKW,
                     &flock, NULL);
-    }
-    else
-    {
+    } else {
         ec_inodelk(heal->fop->frame, heal->xl,
                    &heal->fop->frame->root->lk_owner, heal->fop->mask,
                    EC_MINIMUM_ALL, cbk, heal, heal->xl->name, loc, F_SETLKW,
@@ -192,28 +211,28 @@ void ec_heal_lock(ec_heal_t *heal, int32_t type, fd_t *fd, loc_t *loc,
     }
 }
 
-void ec_heal_inodelk(ec_heal_t *heal, int32_t type, int32_t use_fd,
-                     off_t offset, size_t size)
+void
+ec_heal_inodelk(ec_heal_t *heal, int32_t type, int32_t use_fd, off_t offset,
+                size_t size)
 {
     ec_heal_lock(heal, type, use_fd ? heal->fd : NULL, &heal->loc, offset,
                  size);
 }
 
 int32_t
-ec_heal_xattr_clean (dict_t *dict, char *key, data_t *data,
-                     void *arg)
+ec_heal_xattr_clean(dict_t *dict, char *key, data_t *data, void *arg)
 {
-        dict_t *base = arg;
+    dict_t *base = arg;
 
-        if (ec_ignorable_key_match (NULL, key, NULL, NULL)) {
-                dict_del (dict, key);
-                return 0;
-        }
+    if (ec_ignorable_key_match(NULL, key, NULL, NULL)) {
+        dict_del(dict, key);
+        return 0;
+    }
 
-        if (dict_get (base, key) != NULL)
-                dict_del (dict, key);
+    if (dict_get(base, key) != NULL)
+        dict_del(dict, key);
 
-        return 0;
+    return 0;
 }
 
 /********************************************************************
@@ -223,68 +242,66 @@ ec_heal_xattr_clean (dict_t *dict, char *key, data_t *data,
  *
  *******************************************************************/
 void
-ec_wind_xattrop_parallel (call_frame_t *frame, xlator_t *subvol,
-                          int child_index, loc_t *loc,
-                          gf_xattrop_flags_t flags, dict_t **dict,
-                          dict_t *xdata)
+ec_wind_xattrop_parallel(call_frame_t *frame, xlator_t *subvol, int child_index,
+                         loc_t *loc, gf_xattrop_flags_t flags, dict_t **dict,
+                         dict_t *xdata)
 {
-        gf_msg_debug ("EC", 0, "WIND: on child %d ", child_index);
-        STACK_WIND_COOKIE (frame, cluster_xattrop_cbk,
-                           (void *)(uintptr_t) child_index,
-                           subvol, subvol->fops->xattrop, loc,
-                           flags, dict[child_index], xdata);
+    gf_msg_debug("EC", 0, "WIND: on child %d ", child_index);
+    STACK_WIND_COOKIE(
+        frame, cluster_xattrop_cbk, (void *)(uintptr_t)child_index, subvol,
+        subvol->fops->xattrop, loc, flags, dict[child_index], xdata);
 }
 
 int32_t
-ec_heal_writev_cbk (call_frame_t *frame, void *cookie,
-                    xlator_t *this, int32_t op_ret, int32_t op_errno,
-                    struct iatt *prebuf, struct iatt *postbuf,
-                    dict_t *xdata)
+ec_heal_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     ec_heal_t *heal = fop->data;
 
     ec_trace("WRITE_CBK", cookie, "ret=%d, errno=%d", op_ret, op_errno);
 
-    gf_msg_debug (fop->xl->name, 0, "%s: write op_ret %d, op_errno %s"
-            " at %"PRIu64, uuid_utoa (heal->fd->inode->gfid), op_ret,
-            strerror (op_errno), heal->offset);
+    gf_msg_debug(fop->xl->name, 0,
+                 "%s: write op_ret %d, op_errno %s"
+                 " at %" PRIu64,
+                 uuid_utoa(heal->fd->inode->gfid), op_ret, strerror(op_errno),
+                 heal->offset);
 
     ec_heal_update(cookie, 0);
 
     return 0;
 }
 
-int32_t ec_heal_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iovec * vector, int32_t count,
-                          struct iatt * stbuf, struct iobref * iobref,
-                          dict_t * xdata)
+int32_t
+ec_heal_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                  dict_t *xdata)
 {
-    ec_fop_data_t * fop = cookie;
-    ec_heal_t * heal = fop->data;
+    ec_fop_data_t *fop = cookie;
+    ec_heal_t *heal = fop->data;
 
     ec_trace("READ_CBK", fop, "ret=%d, errno=%d", op_ret, op_errno);
 
     ec_heal_avoid(fop);
 
-    if (op_ret > 0)
-    {
-        gf_msg_debug (fop->xl->name, 0, "%s: read succeeded, proceeding "
-                "to write at %"PRIu64, uuid_utoa (heal->fd->inode->gfid),
-                heal->offset);
+    if (op_ret > 0) {
+        gf_msg_debug(fop->xl->name, 0,
+                     "%s: read succeeded, proceeding "
+                     "to write at %" PRIu64,
+                     uuid_utoa(heal->fd->inode->gfid), heal->offset);
         ec_writev(heal->fop->frame, heal->xl, heal->bad, EC_MINIMUM_ONE,
                   ec_heal_writev_cbk, heal, heal->fd, vector, count,
                   heal->offset, 0, iobref, NULL);
-    }
-    else
-    {
+    } else {
         if (op_ret < 0) {
-                gf_msg_debug (fop->xl->name, 0, "%s: read failed %s, failing "
-                        "to heal block at %"PRIu64,
-                        uuid_utoa (heal->fd->inode->gfid), strerror (op_errno),
-                        heal->offset);
-                heal->bad = 0;
+            gf_msg_debug(fop->xl->name, 0,
+                         "%s: read failed %s, failing "
+                         "to heal block at %" PRIu64,
+                         uuid_utoa(heal->fd->inode->gfid), strerror(op_errno),
+                         heal->offset);
+            heal->bad = 0;
         }
         heal->done = 1;
     }
@@ -292,31 +309,31 @@ int32_t ec_heal_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     return 0;
 }
 
-void ec_heal_data_block(ec_heal_t *heal)
+void
+ec_heal_data_block(ec_heal_t *heal)
 {
     ec_trace("DATA", heal->fop, "good=%lX, bad=%lX", heal->good, heal->bad);
 
     if ((heal->good != 0) && (heal->bad != 0) &&
-        (heal->iatt.ia_type == IA_IFREG))
-    {
+        (heal->iatt.ia_type == IA_IFREG)) {
         ec_readv(heal->fop->frame, heal->xl, heal->good, EC_MINIMUM_MIN,
-                 ec_heal_readv_cbk, heal, heal->fd, heal->size, heal->offset,
-                 0, NULL);
+                 ec_heal_readv_cbk, heal, heal->fd, heal->size, heal->offset, 0,
+                 NULL);
     }
 }
 
 /* FOP: fheal */
 
-void ec_fheal(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_fheal_cbk_t func, void * data, fd_t * fd,
-              int32_t partial, dict_t *xdata)
+void
+ec_fheal(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_fheal_cbk_t func, void *data, fd_t *fd, int32_t partial,
+         dict_t *xdata)
 {
-    ec_fd_t * ctx = ec_fd_get(fd, this);
+    ec_fd_t *ctx = ec_fd_get(fd, this);
 
-    if (ctx != NULL)
-    {
-        gf_msg_trace ("ec", 0, "FHEAL ctx: flags=%X, open=%lX", ctx->flags,
-                      ctx->open);
+    if (ctx != NULL) {
+        gf_msg_trace("ec", 0, "FHEAL ctx: flags=%X, open=%lX", ctx->flags,
+                     ctx->open);
         ec_heal(frame, this, target, minimum, func, data, &ctx->loc, partial,
                 xdata);
     }
@@ -324,1624 +341,1601 @@ void ec_fheal(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
 /* Common heal code */
 void
-ec_mask_to_char_array (uintptr_t mask, unsigned char *array, int numsubvols)
+ec_mask_to_char_array(uintptr_t mask, unsigned char *array, int numsubvols)
 {
-        int     i = 0;
+    int i = 0;
 
-        for (i = 0; i < numsubvols; i++)
-                array[i] = ((mask >> i) & 1);
+    for (i = 0; i < numsubvols; i++)
+        array[i] = ((mask >> i) & 1);
 }
 
 uintptr_t
-ec_char_array_to_mask (unsigned char *array, int numsubvols)
+ec_char_array_to_mask(unsigned char *array, int numsubvols)
 {
-        int       i    = 0;
-        uintptr_t mask = 0;
+    int i = 0;
+    uintptr_t mask = 0;
 
-        if (array == NULL)
-                goto out;
+    if (array == NULL)
+        goto out;
 
-        for (i = 0; i < numsubvols; i++)
-                if (array[i])
-                        mask |= (1ULL<<i);
+    for (i = 0; i < numsubvols; i++)
+        if (array[i])
+            mask |= (1ULL << i);
 out:
-        return mask;
+    return mask;
 }
 
 int
-ec_heal_entry_find_direction (ec_t *ec, default_args_cbk_t *replies,
-                        uint64_t *versions, uint64_t *dirty,
-                        unsigned char *sources, unsigned char *healed_sinks)
+ec_heal_entry_find_direction(ec_t *ec, default_args_cbk_t *replies,
+                             uint64_t *versions, uint64_t *dirty,
+                             unsigned char *sources,
+                             unsigned char *healed_sinks)
 {
-        uint64_t    xattr[EC_VERSION_SIZE] = {0};
-        int         source      = -1;
-        uint64_t    max_version = 0;
-        int         ret         = 0;
-        int         i           = 0;
+    uint64_t xattr[EC_VERSION_SIZE] = {0};
+    int source = -1;
+    uint64_t max_version = 0;
+    int ret = 0;
+    int i = 0;
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret == -1)
-                        continue;
-
-                if (source == -1)
-                        source = i;
-
-                ret = ec_dict_get_array (replies[i].xdata, EC_XATTR_VERSION,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        versions[i] = xattr[EC_DATA_TXN];
-                        if (max_version < versions[i]) {
-                                max_version = versions[i];
-                                source = i;
-                        }
-                }
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                memset (xattr, 0, sizeof(xattr));
-                ret = ec_dict_get_array (replies[i].xdata, EC_XATTR_DIRTY,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        dirty[i] = xattr[EC_DATA_TXN];
-                }
+        if (replies[i].op_ret == -1)
+            continue;
+
+        if (source == -1)
+            source = i;
+
+        ret = ec_dict_get_array(replies[i].xdata, EC_XATTR_VERSION, xattr,
+                                EC_VERSION_SIZE);
+        if (ret == 0) {
+            versions[i] = xattr[EC_DATA_TXN];
+            if (max_version < versions[i]) {
+                max_version = versions[i];
+                source = i;
+            }
         }
 
-        if (source < 0)
-                goto out;
+        memset(xattr, 0, sizeof(xattr));
+        ret = ec_dict_get_array(replies[i].xdata, EC_XATTR_DIRTY, xattr,
+                                EC_VERSION_SIZE);
+        if (ret == 0) {
+            dirty[i] = xattr[EC_DATA_TXN];
+        }
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
+    if (source < 0)
+        goto out;
 
-                if (replies[i].op_ret == -1)
-                        continue;
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
 
-                if (versions[i] == versions[source])
-                        sources[i] = 1;
-                else
-                        healed_sinks[i] = 1;
-        }
+        if (replies[i].op_ret == -1)
+            continue;
+
+        if (versions[i] == versions[source])
+            sources[i] = 1;
+        else
+            healed_sinks[i] = 1;
+    }
 
 out:
-        return source;
+    return source;
 }
 
 int
-ec_adjust_versions (call_frame_t *frame, ec_t *ec, ec_txn_t type,
-                    inode_t *inode, int source, unsigned char *sources,
-                    unsigned char *healed_sinks, uint64_t *versions,
-                    uint64_t *dirty)
-{
-        int                        i                 = 0;
-        int                        ret               = 0;
-        int                        call_count        = 0;
-        dict_t                     **xattr           = NULL;
-        int                        op_ret            = 0;
-        loc_t                      loc               = {0};
-        gf_boolean_t               erase_dirty       = _gf_false;
-        uint64_t                   *versions_xattr   = NULL;
-        uint64_t                   *dirty_xattr      = NULL;
-        uint64_t                   allzero[2]        = {0};
-        unsigned char              *on               = NULL;
-        unsigned char              *output           = NULL;
-        default_args_cbk_t         *replies          = NULL;
-
-        /* Allocate the required memory */
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        on = alloca0 (ec->nodes);
-        output = alloca0 (ec->nodes);
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        xattr = GF_CALLOC (ec->nodes, sizeof (*xattr), gf_common_mt_pointer);
-        if (!xattr) {
-                op_ret = -ENOMEM;
-                goto out;
-        }
-        for (i = 0; i < ec->nodes; i++) {
-                xattr[i] = dict_new ();
-                if (!xattr[i]) {
-                        op_ret = -ENOMEM;
-                        goto out;
-                }
+ec_adjust_versions(call_frame_t *frame, ec_t *ec, ec_txn_t type, inode_t *inode,
+                   int source, unsigned char *sources,
+                   unsigned char *healed_sinks, uint64_t *versions,
+                   uint64_t *dirty)
+{
+    int i = 0;
+    int ret = 0;
+    int call_count = 0;
+    dict_t **xattr = NULL;
+    int op_ret = 0;
+    loc_t loc = {0};
+    gf_boolean_t erase_dirty = _gf_false;
+    uint64_t *versions_xattr = NULL;
+    uint64_t *dirty_xattr = NULL;
+    uint64_t allzero[2] = {0};
+    unsigned char *on = NULL;
+    unsigned char *output = NULL;
+    default_args_cbk_t *replies = NULL;
+
+    /* Allocate the required memory */
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    xattr = GF_CALLOC(ec->nodes, sizeof(*xattr), gf_common_mt_pointer);
+    if (!xattr) {
+        op_ret = -ENOMEM;
+        goto out;
+    }
+    for (i = 0; i < ec->nodes; i++) {
+        xattr[i] = dict_new();
+        if (!xattr[i]) {
+            op_ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        /* dirty xattr represents if the file/dir needs heal. Unless all the
-         * copies are healed, don't erase it */
-        if (EC_COUNT (sources, ec->nodes) +
-            EC_COUNT (healed_sinks, ec->nodes) == ec->nodes)
-                erase_dirty = _gf_true;
-        else
-                op_ret = -ENOTCONN;
-
-        /* Populate the xattr array */
-        for (i = 0; i < ec->nodes; i++) {
-                if (!sources[i] && !healed_sinks[i])
-                        continue;
-                versions_xattr = GF_CALLOC (EC_VERSION_SIZE,
-                                            sizeof(*versions_xattr),
-                                            gf_common_mt_pointer);
-                if (!versions_xattr) {
-                        op_ret = -ENOMEM;
-                        continue;
-                }
-
-                versions_xattr[type] = hton64(versions[source] - versions[i]);
-                ret = dict_set_bin (xattr[i], EC_XATTR_VERSION,
-                                    versions_xattr,
-                                    (sizeof (*versions_xattr) * EC_VERSION_SIZE)
-                                   );
-                if (ret < 0) {
-                        op_ret = -ENOMEM;
-                        continue;
-                }
-
-                if (erase_dirty) {
-                        dirty_xattr = GF_CALLOC (EC_VERSION_SIZE,
-                                                 sizeof(*dirty_xattr),
-                                                 gf_common_mt_pointer);
-                        if (!dirty_xattr) {
-                                op_ret = -ENOMEM;
-                                continue;
-                        }
-
-                        dirty_xattr[type] = hton64(-dirty[i]);
-                        ret = dict_set_bin (xattr[i], EC_XATTR_DIRTY,
-                                            dirty_xattr,
-                                            (sizeof(*dirty_xattr) *
-                                            EC_VERSION_SIZE)
-                                           );
-                        if (ret < 0) {
-                                op_ret = -ENOMEM;
-                                continue;
-                        }
-                }
+    /* dirty xattr represents if the file/dir needs heal. Unless all the
+     * copies are healed, don't erase it */
+    if (EC_COUNT(sources, ec->nodes) + EC_COUNT(healed_sinks, ec->nodes) ==
+        ec->nodes)
+        erase_dirty = _gf_true;
+    else
+        op_ret = -ENOTCONN;
+
+    /* Populate the xattr array */
+    for (i = 0; i < ec->nodes; i++) {
+        if (!sources[i] && !healed_sinks[i])
+            continue;
+        versions_xattr = GF_CALLOC(EC_VERSION_SIZE, sizeof(*versions_xattr),
+                                   gf_common_mt_pointer);
+        if (!versions_xattr) {
+            op_ret = -ENOMEM;
+            continue;
+        }
+
+        versions_xattr[type] = hton64(versions[source] - versions[i]);
+        ret = dict_set_bin(xattr[i], EC_XATTR_VERSION, versions_xattr,
+                           (sizeof(*versions_xattr) * EC_VERSION_SIZE));
+        if (ret < 0) {
+            op_ret = -ENOMEM;
+            continue;
+        }
 
-                if (memcmp (versions_xattr, allzero,
-                            (sizeof(*versions_xattr) * EC_VERSION_SIZE)) == 0) {
+        if (erase_dirty) {
+            dirty_xattr = GF_CALLOC(EC_VERSION_SIZE, sizeof(*dirty_xattr),
+                                    gf_common_mt_pointer);
+            if (!dirty_xattr) {
+                op_ret = -ENOMEM;
+                continue;
+            }
 
-                        if (!erase_dirty) {
-                                continue;
-                        }
+            dirty_xattr[type] = hton64(-dirty[i]);
+            ret = dict_set_bin(xattr[i], EC_XATTR_DIRTY, dirty_xattr,
+                               (sizeof(*dirty_xattr) * EC_VERSION_SIZE));
+            if (ret < 0) {
+                op_ret = -ENOMEM;
+                continue;
+            }
+        }
 
-                        if (memcmp (dirty_xattr, allzero, (sizeof (*dirty_xattr)
-                                    * EC_VERSION_SIZE)) == 0) {
-                                continue;
-                        }
-                }
+        if (memcmp(versions_xattr, allzero,
+                   (sizeof(*versions_xattr) * EC_VERSION_SIZE)) == 0) {
+            if (!erase_dirty) {
+                continue;
+            }
 
-                on[i] = 1;
-                call_count++;
+            if (memcmp(dirty_xattr, allzero,
+                       (sizeof(*dirty_xattr) * EC_VERSION_SIZE)) == 0) {
+                continue;
+            }
         }
 
-        /* Update the bricks with xattr */
-        if (call_count) {
-                PARALLEL_FOP_ONLIST (ec->xl_list, on, ec->nodes, replies,
-                                     frame, ec_wind_xattrop_parallel,
-                                     &loc, GF_XATTROP_ADD_ARRAY64, xattr, NULL);
-                ret = cluster_fop_success_fill (replies, ec->nodes, output);
-        }
+        on[i] = 1;
+        call_count++;
+    }
 
-        if (ret < call_count) {
-                op_ret = -ENOTCONN;
-                goto out;
-        }
+    /* Update the bricks with xattr */
+    if (call_count) {
+        PARALLEL_FOP_ONLIST(ec->xl_list, on, ec->nodes, replies, frame,
+                            ec_wind_xattrop_parallel, &loc,
+                            GF_XATTROP_ADD_ARRAY64, xattr, NULL);
+        ret = cluster_fop_success_fill(replies, ec->nodes, output);
+    }
+
+    if (ret < call_count) {
+        op_ret = -ENOTCONN;
+        goto out;
+    }
 
 out:
-        /* Cleanup */
-        if (xattr) {
-                for (i = 0; i < ec->nodes; i++) {
-                        if (xattr[i])
-                                dict_unref (xattr[i]);
-                }
-                GF_FREE (xattr);
+    /* Cleanup */
+    if (xattr) {
+        for (i = 0; i < ec->nodes; i++) {
+            if (xattr[i])
+                dict_unref(xattr[i]);
         }
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        return op_ret;
+        GF_FREE(xattr);
+    }
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    return op_ret;
 }
 
 int
-ec_heal_metadata_find_direction (ec_t *ec, default_args_cbk_t *replies,
-                                 uint64_t *versions, uint64_t *dirty,
-                            unsigned char *sources, unsigned char *healed_sinks)
-{
-        uint64_t xattr[EC_VERSION_SIZE] = {0};
-        uint64_t max_version    = 0;
-        int      same_count     = 0;
-        int      max_same_count = 0;
-        int      same_source    = -1;
-        int      ret            = 0;
-        int      i              = 0;
-        int      j              = 0;
-        int      *groups        = NULL;
-        struct iatt source_ia   = {0};
-        struct iatt child_ia    = {0};
-
-        groups = alloca0 (ec->nodes * sizeof(*groups));
-        for (i = 0; i < ec->nodes; i++)
-                groups[i] = -1;
-
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
-                if (replies[i].op_ret < 0)
-                        continue;
-                ret = ec_dict_get_array (replies[i].xdata, EC_XATTR_VERSION,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        versions[i] = xattr[EC_METADATA_TXN];
-                }
-
-                memset (xattr, 0, sizeof (xattr));
-                ret = ec_dict_get_array (replies[i].xdata, EC_XATTR_DIRTY,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        dirty[i] = xattr[EC_METADATA_TXN];
-                }
-                if (groups[i] >= 0) /*Already part of group*/
-                        continue;
-                groups[i] = i;
-                same_count = 1;
-                source_ia = replies[i].stat;
-                for (j = i + 1; j < ec->nodes; j++) {
-                        if (!replies[j].valid || replies[j].op_ret < 0)
-                                continue;
-                        child_ia = replies[j].stat;
-                        if (!IA_EQUAL(source_ia, child_ia, gfid) ||
-                            !IA_EQUAL(source_ia, child_ia, type) ||
-                            !IA_EQUAL(source_ia, child_ia, prot) ||
-                            !IA_EQUAL(source_ia, child_ia, uid) ||
-                            !IA_EQUAL(source_ia, child_ia, gid))
-                                continue;
-                        if (!are_dicts_equal(replies[i].xdata, replies[j].xdata,
-                                             ec_sh_key_match, NULL))
-                                continue;
-                        groups[j] = i;
-                        same_count++;
-                }
-
-                if (max_same_count < same_count) {
-                        max_same_count = same_count;
-                        same_source = i;
-                }
+ec_heal_metadata_find_direction(ec_t *ec, default_args_cbk_t *replies,
+                                uint64_t *versions, uint64_t *dirty,
+                                unsigned char *sources,
+                                unsigned char *healed_sinks)
+{
+    uint64_t xattr[EC_VERSION_SIZE] = {0};
+    uint64_t max_version = 0;
+    int same_count = 0;
+    int max_same_count = 0;
+    int same_source = -1;
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+    int *groups = NULL;
+    struct iatt source_ia = {0};
+    struct iatt child_ia = {0};
+
+    groups = alloca0(ec->nodes * sizeof(*groups));
+    for (i = 0; i < ec->nodes; i++)
+        groups[i] = -1;
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret < 0)
+            continue;
+        ret = ec_dict_get_array(replies[i].xdata, EC_XATTR_VERSION, xattr,
+                                EC_VERSION_SIZE);
+        if (ret == 0) {
+            versions[i] = xattr[EC_METADATA_TXN];
         }
 
-        if (max_same_count < ec->fragments) {
-                ret = -EIO;
-                goto out;
+        memset(xattr, 0, sizeof(xattr));
+        ret = ec_dict_get_array(replies[i].xdata, EC_XATTR_DIRTY, xattr,
+                                EC_VERSION_SIZE);
+        if (ret == 0) {
+            dirty[i] = xattr[EC_METADATA_TXN];
+        }
+        if (groups[i] >= 0) /*Already part of group*/
+            continue;
+        groups[i] = i;
+        same_count = 1;
+        source_ia = replies[i].stat;
+        for (j = i + 1; j < ec->nodes; j++) {
+            if (!replies[j].valid || replies[j].op_ret < 0)
+                continue;
+            child_ia = replies[j].stat;
+            if (!IA_EQUAL(source_ia, child_ia, gfid) ||
+                !IA_EQUAL(source_ia, child_ia, type) ||
+                !IA_EQUAL(source_ia, child_ia, prot) ||
+                !IA_EQUAL(source_ia, child_ia, uid) ||
+                !IA_EQUAL(source_ia, child_ia, gid))
+                continue;
+            if (!are_dicts_equal(replies[i].xdata, replies[j].xdata,
+                                 ec_sh_key_match, NULL))
+                continue;
+            groups[j] = i;
+            same_count++;
+        }
+
+        if (max_same_count < same_count) {
+            max_same_count = same_count;
+            same_source = i;
         }
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (groups[i] == groups[same_source])
-                        sources[i] = 1;
-                else if (replies[i].valid && replies[i].op_ret >= 0)
-                        healed_sinks[i] = 1;
-        }
-        for (i = 0; i < ec->nodes; i++) {
-                if (sources[i] && (versions[i] > max_version)) {
-                         same_source = i;
-                         max_version = versions[i];
-                }
+    if (max_same_count < ec->fragments) {
+        ret = -EIO;
+        goto out;
+    }
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (groups[i] == groups[same_source])
+            sources[i] = 1;
+        else if (replies[i].valid && replies[i].op_ret >= 0)
+            healed_sinks[i] = 1;
+    }
+    for (i = 0; i < ec->nodes; i++) {
+        if (sources[i] && (versions[i] > max_version)) {
+            same_source = i;
+            max_version = versions[i];
         }
-        ret = same_source;
+    }
+    ret = same_source;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__ec_heal_metadata_prepare (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                   unsigned char *locked_on, default_args_cbk_t *replies,
-                   uint64_t *versions, uint64_t *dirty, unsigned char *sources,
-                   unsigned char *healed_sinks)
-{
-        loc_t              loc        = {0};
-        unsigned char      *output    = NULL;
-        unsigned char      *lookup_on = NULL;
-        int                ret        = 0;
-        int                source     = 0;
-        default_args_cbk_t *greplies  = NULL;
-        int                i          = 0;
-        EC_REPLIES_ALLOC (greplies, ec->nodes);
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        output = alloca0 (ec->nodes);
-        lookup_on = alloca0 (ec->nodes);
-        ret = cluster_lookup (ec->xl_list, locked_on, ec->nodes, replies,
-                              output, frame, ec->xl, &loc, NULL);
-        if (ret <= ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+__ec_heal_metadata_prepare(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                           unsigned char *locked_on,
+                           default_args_cbk_t *replies, uint64_t *versions,
+                           uint64_t *dirty, unsigned char *sources,
+                           unsigned char *healed_sinks)
+{
+    loc_t loc = {0};
+    unsigned char *output = NULL;
+    unsigned char *lookup_on = NULL;
+    int ret = 0;
+    int source = 0;
+    default_args_cbk_t *greplies = NULL;
+    int i = 0;
+    EC_REPLIES_ALLOC(greplies, ec->nodes);
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    output = alloca0(ec->nodes);
+    lookup_on = alloca0(ec->nodes);
+    ret = cluster_lookup(ec->xl_list, locked_on, ec->nodes, replies, output,
+                         frame, ec->xl, &loc, NULL);
+    if (ret <= ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        memcpy (lookup_on, output, ec->nodes);
-        /*Use getxattr to get the filtered xattrs which filter internal xattrs*/
-        ret = cluster_getxattr (ec->xl_list, lookup_on, ec->nodes, greplies,
-                                output, frame, ec->xl, &loc, NULL, NULL);
-        for (i = 0; i < ec->nodes; i++) {
-                if (lookup_on[i] && !output[i]) {
-                        replies[i].valid = 0;
-                        continue;
-                }
-                if (replies[i].xdata) {
-                        dict_unref (replies[i].xdata);
-                        replies[i].xdata = NULL;
-                        if (greplies[i].xattr)
-                                replies[i].xdata = dict_ref (greplies[i].xattr);
-                }
+    memcpy(lookup_on, output, ec->nodes);
+    /*Use getxattr to get the filtered xattrs which filter internal xattrs*/
+    ret = cluster_getxattr(ec->xl_list, lookup_on, ec->nodes, greplies, output,
+                           frame, ec->xl, &loc, NULL, NULL);
+    for (i = 0; i < ec->nodes; i++) {
+        if (lookup_on[i] && !output[i]) {
+            replies[i].valid = 0;
+            continue;
+        }
+        if (replies[i].xdata) {
+            dict_unref(replies[i].xdata);
+            replies[i].xdata = NULL;
+            if (greplies[i].xattr)
+                replies[i].xdata = dict_ref(greplies[i].xattr);
         }
+    }
 
-        source = ec_heal_metadata_find_direction (ec, replies, versions,
-                                         dirty, sources, healed_sinks);
-        if (source < 0) {
-                ret = -EIO;
-                goto out;
-        }
-        ret = source;
+    source = ec_heal_metadata_find_direction(ec, replies, versions, dirty,
+                                             sources, healed_sinks);
+    if (source < 0) {
+        ret = -EIO;
+        goto out;
+    }
+    ret = source;
 out:
-        cluster_replies_wipe (greplies, ec->nodes);
-        loc_wipe (&loc);
-        return ret;
+    cluster_replies_wipe(greplies, ec->nodes);
+    loc_wipe(&loc);
+    return ret;
 }
 
 /* Metadata heal */
 int
-__ec_removexattr_sinks (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                        int source, unsigned char *sources,
-                        unsigned char *healed_sinks,
-                        default_args_cbk_t *replies)
-{
-        int   i   = 0;
-        int   ret = 0;
-        loc_t loc = {0};
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-
-        for (i = 0; i < ec->nodes; i++) {
-                if (i == source)
-                        continue;
-                if (!sources[i] && !healed_sinks[i])
-                        continue;
-                ret = dict_foreach (replies[i].xdata, ec_heal_xattr_clean,
-                                    replies[source].xdata);
-                if (ret < 0) {
-                        sources[i] = 0;
-                        healed_sinks[i] = 0;
-                        continue;
-                }
-
-                if (replies[i].xdata->count == 0) {
-                        continue;
-                } else if (sources[i]) {
-                        /* This can happen if setxattr/removexattr succeeds on
-                         * the bricks but fails to update the version. This
-                         * will make sure that the xattrs are made equal after
-                         * heal*/
-                        sources[i] = 0;
-                        healed_sinks[i] = 1;
-                }
+__ec_removexattr_sinks(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                       int source, unsigned char *sources,
+                       unsigned char *healed_sinks, default_args_cbk_t *replies)
+{
+    int i = 0;
+    int ret = 0;
+    loc_t loc = {0};
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (i == source)
+            continue;
+        if (!sources[i] && !healed_sinks[i])
+            continue;
+        ret = dict_foreach(replies[i].xdata, ec_heal_xattr_clean,
+                           replies[source].xdata);
+        if (ret < 0) {
+            sources[i] = 0;
+            healed_sinks[i] = 0;
+            continue;
+        }
 
-                ret = syncop_removexattr (ec->xl_list[i], &loc, "",
-                                          replies[i].xdata, NULL);
-                if (ret < 0)
-                        healed_sinks[i] = 0;
+        if (replies[i].xdata->count == 0) {
+            continue;
+        } else if (sources[i]) {
+            /* This can happen if setxattr/removexattr succeeds on
+             * the bricks but fails to update the version. This
+             * will make sure that the xattrs are made equal after
+             * heal*/
+            sources[i] = 0;
+            healed_sinks[i] = 1;
         }
 
-        loc_wipe (&loc);
-        if (EC_COUNT (healed_sinks, ec->nodes) == 0)
-                return -ENOTCONN;
-        return 0;
+        ret = syncop_removexattr(ec->xl_list[i], &loc, "", replies[i].xdata,
+                                 NULL);
+        if (ret < 0)
+            healed_sinks[i] = 0;
+    }
+
+    loc_wipe(&loc);
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0)
+        return -ENOTCONN;
+    return 0;
 }
 
 int
-__ec_heal_metadata (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                    unsigned char *locked_on, unsigned char *sources,
-                    unsigned char *healed_sinks)
-{
-        loc_t              loc           = {0};
-        int                ret           = 0;
-        int                source        = 0;
-        default_args_cbk_t *replies      = NULL;
-        default_args_cbk_t *sreplies     = NULL;
-        uint64_t           *versions     = NULL;
-        uint64_t           *dirty        = NULL;
-        unsigned char      *output       = NULL;
-        dict_t             *source_dict  = NULL;
-        struct iatt        source_buf    = {0};
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        EC_REPLIES_ALLOC (sreplies, ec->nodes);
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        output = alloca0 (ec->nodes);
-        versions = alloca0 (ec->nodes * sizeof (*versions));
-        dirty = alloca0 (ec->nodes * sizeof (*dirty));
-        source = __ec_heal_metadata_prepare (frame, ec, inode, locked_on, replies,
-                                    versions, dirty, sources, healed_sinks);
-        if (source < 0) {
-                ret = -EIO;
-                goto out;
-        }
+__ec_heal_metadata(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                   unsigned char *locked_on, unsigned char *sources,
+                   unsigned char *healed_sinks)
+{
+    loc_t loc = {0};
+    int ret = 0;
+    int source = 0;
+    default_args_cbk_t *replies = NULL;
+    default_args_cbk_t *sreplies = NULL;
+    uint64_t *versions = NULL;
+    uint64_t *dirty = NULL;
+    unsigned char *output = NULL;
+    dict_t *source_dict = NULL;
+    struct iatt source_buf = {0};
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    EC_REPLIES_ALLOC(sreplies, ec->nodes);
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    output = alloca0(ec->nodes);
+    versions = alloca0(ec->nodes * sizeof(*versions));
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+    source = __ec_heal_metadata_prepare(frame, ec, inode, locked_on, replies,
+                                        versions, dirty, sources, healed_sinks);
+    if (source < 0) {
+        ret = -EIO;
+        goto out;
+    }
 
-        if ((EC_COUNT (sources, ec->nodes) == ec->nodes) ||
-            (EC_COUNT (healed_sinks, ec->nodes) == 0)) {
-                ret = 0;
-                goto erase_dirty;
-        }
+    if ((EC_COUNT(sources, ec->nodes) == ec->nodes) ||
+        (EC_COUNT(healed_sinks, ec->nodes) == 0)) {
+        ret = 0;
+        goto erase_dirty;
+    }
 
-        source_buf = replies[source].stat;
-        ret = cluster_setattr (ec->xl_list, healed_sinks, ec->nodes, sreplies,
-                               output, frame, ec->xl, &loc,
-                               &source_buf, GF_SET_ATTR_MODE |
-                               GF_SET_ATTR_UID | GF_SET_ATTR_GID, NULL);
-        /*In case the operation fails on some of the subvols*/
-        memcpy (healed_sinks, output, ec->nodes);
-        if (EC_COUNT (healed_sinks, ec->nodes) == 0) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    source_buf = replies[source].stat;
+    ret = cluster_setattr(ec->xl_list, healed_sinks, ec->nodes, sreplies,
+                          output, frame, ec->xl, &loc, &source_buf,
+                          GF_SET_ATTR_MODE | GF_SET_ATTR_UID | GF_SET_ATTR_GID,
+                          NULL);
+    /*In case the operation fails on some of the subvols*/
+    memcpy(healed_sinks, output, ec->nodes);
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        ret = __ec_removexattr_sinks (frame, ec, inode, source, sources,
-                                      healed_sinks, replies);
-        if (ret < 0)
-                goto out;
+    ret = __ec_removexattr_sinks(frame, ec, inode, source, sources,
+                                 healed_sinks, replies);
+    if (ret < 0)
+        goto out;
 
-        source_dict = dict_ref (replies[source].xdata);
-        if (dict_foreach_match (source_dict, ec_ignorable_key_match, NULL,
-                                dict_remove_foreach_fn, NULL) == -1) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    source_dict = dict_ref(replies[source].xdata);
+    if (dict_foreach_match(source_dict, ec_ignorable_key_match, NULL,
+                           dict_remove_foreach_fn, NULL) == -1) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ret = cluster_setxattr (ec->xl_list, healed_sinks, ec->nodes,
-                                replies, output, frame, ec->xl, &loc,
-                                source_dict, 0, NULL);
+    ret = cluster_setxattr(ec->xl_list, healed_sinks, ec->nodes, replies,
+                           output, frame, ec->xl, &loc, source_dict, 0, NULL);
 
-        EC_INTERSECT (healed_sinks, healed_sinks, output, ec->nodes);
-        if (EC_COUNT (healed_sinks, ec->nodes) == 0) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    EC_INTERSECT(healed_sinks, healed_sinks, output, ec->nodes);
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
 erase_dirty:
-        ret = ec_adjust_versions (frame, ec, EC_METADATA_TXN, inode, source,
-                                  sources, healed_sinks, versions, dirty);
+    ret = ec_adjust_versions(frame, ec, EC_METADATA_TXN, inode, source, sources,
+                             healed_sinks, versions, dirty);
 out:
-        if (source_dict)
-                dict_unref (source_dict);
+    if (source_dict)
+        dict_unref(source_dict);
 
-        loc_wipe (&loc);
-        cluster_replies_wipe (replies, ec->nodes);
-        cluster_replies_wipe (sreplies, ec->nodes);
-        return ret;
+    loc_wipe(&loc);
+    cluster_replies_wipe(replies, ec->nodes);
+    cluster_replies_wipe(sreplies, ec->nodes);
+    return ret;
 }
 
 int
-ec_heal_metadata (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                  unsigned char *sources, unsigned char *healed_sinks)
-{
-        unsigned char      *locked_on  = NULL;
-        unsigned char      *up_subvols = NULL;
-        unsigned char      *output     = NULL;
-        int                ret         = 0;
-        default_args_cbk_t *replies    = NULL;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        locked_on = alloca0(ec->nodes);
-        output = alloca0(ec->nodes);
-        up_subvols = alloca0(ec->nodes);
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
-        ret = cluster_inodelk (ec->xl_list, up_subvols, ec->nodes, replies,
-                               locked_on, frame, ec->xl, ec->xl->name, inode, 0,
-                               0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                ret = __ec_heal_metadata (frame, ec, inode, locked_on, sources,
-                                          healed_sinks);
-        }
+ec_heal_metadata(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                 unsigned char *sources, unsigned char *healed_sinks)
+{
+    unsigned char *locked_on = NULL;
+    unsigned char *up_subvols = NULL;
+    unsigned char *output = NULL;
+    int ret = 0;
+    default_args_cbk_t *replies = NULL;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    up_subvols = alloca0(ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
+    ret = cluster_inodelk(ec->xl_list, up_subvols, ec->nodes, replies,
+                          locked_on, frame, ec->xl, ec->xl->name, inode, 0, 0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        ret = __ec_heal_metadata(frame, ec, inode, locked_on, sources,
+                                 healed_sinks);
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, ec->xl->name, inode, 0, 0);
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, inode, 0, 0);
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 /*entry heal*/
 int
-__ec_heal_entry_prepare (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                         unsigned char *locked_on, uint64_t *versions,
-                         uint64_t *dirty, unsigned char *sources,
-                         unsigned char *healed_sinks)
-{
-        loc_t              loc      = {0};
-        int                source   = 0;
-        int                ret      = 0;
-        default_args_cbk_t *replies = NULL;
-        unsigned char      *output  = NULL;
-        dict_t             *xdata   = NULL;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        xdata = dict_new ();
-        if (!xdata) {
-                ret = -ENOMEM;
-                goto out;
-        }
+__ec_heal_entry_prepare(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                        unsigned char *locked_on, uint64_t *versions,
+                        uint64_t *dirty, unsigned char *sources,
+                        unsigned char *healed_sinks)
+{
+    loc_t loc = {0};
+    int source = 0;
+    int ret = 0;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    dict_t *xdata = NULL;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    xdata = dict_new();
+    if (!xdata) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        if (dict_set_uint64(xdata, EC_XATTR_VERSION, 0) ||
-            dict_set_uint64(xdata, EC_XATTR_DIRTY, 0)) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    if (dict_set_uint64(xdata, EC_XATTR_VERSION, 0) ||
+        dict_set_uint64(xdata, EC_XATTR_DIRTY, 0)) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        output = alloca0 (ec->nodes);
-        ret = cluster_lookup (ec->xl_list, locked_on, ec->nodes, replies,
-                              output, frame, ec->xl, &loc, xdata);
-        if (ret <= ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    output = alloca0(ec->nodes);
+    ret = cluster_lookup(ec->xl_list, locked_on, ec->nodes, replies, output,
+                         frame, ec->xl, &loc, xdata);
+    if (ret <= ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        source = ec_heal_entry_find_direction (ec, replies, versions,
-                                         dirty, sources, healed_sinks);
-        if (source < 0) {
-                ret = -EIO;
-                goto out;
-        }
-        ret = source;
+    source = ec_heal_entry_find_direction(ec, replies, versions, dirty, sources,
+                                          healed_sinks);
+    if (source < 0) {
+        ret = -EIO;
+        goto out;
+    }
+    ret = source;
 out:
-        if (xdata)
-                dict_unref (xdata);
-        loc_wipe (&loc);
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    if (xdata)
+        dict_unref(xdata);
+    loc_wipe(&loc);
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 int32_t
-ec_set_new_entry_dirty (ec_t *ec, loc_t *loc, struct iatt *ia,
-                        call_frame_t *frame, xlator_t *this, unsigned char *on)
-{
-        dict_t              *xattr = NULL;
-        int32_t             ret    = -1;
-        default_args_cbk_t  *replies = NULL;
-        unsigned char       *output  = NULL;
-        uint64_t            dirty[EC_VERSION_SIZE] = {1, 1};
-        loc_t               newloc = {0};
-
-        /*Symlinks don't have any data to be healed*/
-        if (ia->ia_type == IA_IFLNK)
-                dirty[EC_DATA_TXN] = 0;
-
-        newloc.inode = inode_ref (loc->inode);
-        gf_uuid_copy (newloc.gfid, ia->ia_gfid);
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        output = alloca0 (ec->nodes);
-        xattr = dict_new();
-        if (!xattr) {
-                ret = -ENOMEM;
-                goto out;
-        }
+ec_set_new_entry_dirty(ec_t *ec, loc_t *loc, struct iatt *ia,
+                       call_frame_t *frame, xlator_t *this, unsigned char *on)
+{
+    dict_t *xattr = NULL;
+    int32_t ret = -1;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    uint64_t dirty[EC_VERSION_SIZE] = {1, 1};
+    loc_t newloc = {0};
+
+    /*Symlinks don't have any data to be healed*/
+    if (ia->ia_type == IA_IFLNK)
+        dirty[EC_DATA_TXN] = 0;
+
+    newloc.inode = inode_ref(loc->inode);
+    gf_uuid_copy(newloc.gfid, ia->ia_gfid);
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    output = alloca0(ec->nodes);
+    xattr = dict_new();
+    if (!xattr) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ret = ec_dict_set_array (xattr, EC_XATTR_DIRTY, dirty,
-                                 EC_VERSION_SIZE);
-        if (ret)
-                goto out;
+    ret = ec_dict_set_array(xattr, EC_XATTR_DIRTY, dirty, EC_VERSION_SIZE);
+    if (ret)
+        goto out;
 
-        ret = cluster_xattrop (ec->xl_list, on, ec->nodes, replies, output,
-                               frame, ec->xl, &newloc,
-                               GF_XATTROP_ADD_ARRAY64, xattr, NULL);
+    ret = cluster_xattrop(ec->xl_list, on, ec->nodes, replies, output, frame,
+                          ec->xl, &newloc, GF_XATTROP_ADD_ARRAY64, xattr, NULL);
 
-        if (ret < ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    if (ret < ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 out:
-        if (xattr)
-                dict_unref (xattr);
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&newloc);
-        return ret;
+    if (xattr)
+        dict_unref(xattr);
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&newloc);
+    return ret;
 }
 
 /*Name heal*/
 int
-ec_delete_stale_name (dict_t *gfid_db, char *key, data_t *d, void *data)
-{
-        struct ec_name_data *name_data   = data;
-        struct iatt         *ia          = NULL;
-        ec_t                *ec          = NULL;
-        loc_t               loc          = {0};
-        unsigned char       *same        = data_to_bin (d);
-        default_args_cbk_t  *replies     = NULL;
-        unsigned char       *output      = NULL;
-        int                 ret          = 0;
-        int                 estale_count = 0;
-        int                 i            = 0;
-        call_frame_t        *frame       = name_data->frame;
-
-        ec = name_data->frame->this->private;
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        if (EC_COUNT (same, ec->nodes) >= ec->fragments) {
-                ret = 0;
-                goto out;
-        }
+ec_delete_stale_name(dict_t *gfid_db, char *key, data_t *d, void *data)
+{
+    struct ec_name_data *name_data = data;
+    struct iatt *ia = NULL;
+    ec_t *ec = NULL;
+    loc_t loc = {0};
+    unsigned char *same = data_to_bin(d);
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    int ret = 0;
+    int estale_count = 0;
+    int i = 0;
+    call_frame_t *frame = name_data->frame;
+
+    ec = name_data->frame->this->private;
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    if (EC_COUNT(same, ec->nodes) >= ec->fragments) {
+        ret = 0;
+        goto out;
+    }
 
-        loc.inode = inode_new (name_data->parent->table);
-        if (!loc.inode) {
-                ret = -ENOMEM;
-                goto out;
+    loc.inode = inode_new(name_data->parent->table);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    gf_uuid_parse(key, loc.gfid);
+    output = alloca0(ec->nodes);
+    ret = cluster_lookup(ec->xl_list, name_data->participants, ec->nodes,
+                         replies, output, name_data->frame, ec->xl, &loc, NULL);
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret == -1) {
+            if (replies[i].op_errno == ESTALE || replies[i].op_errno == ENOENT)
+                estale_count++;
+            else
+                name_data->participants[i] = 0;
         }
-        gf_uuid_parse (key, loc.gfid);
-        output = alloca0(ec->nodes);
-        ret = cluster_lookup (ec->xl_list, name_data->participants, ec->nodes,
-                              replies, output, name_data->frame, ec->xl, &loc,
-                              NULL);
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
-                if (replies[i].op_ret == -1) {
-                        if (replies[i].op_errno == ESTALE ||
-                            replies[i].op_errno == ENOENT)
-                                estale_count++;
-                        else
-                                name_data->participants[i] = 0;
-                }
-        }
+    if (estale_count <= ec->redundancy) {
+        /* We have at least ec->fragments number of fragments, so the
+         * file is recoverable, so don't delete it*/
 
-        if (estale_count <= ec->redundancy) {
-                /* We have at least ec->fragments number of fragments, so the
-                 * file is recoverable, so don't delete it*/
+        /* Please note that the lookup call above could fail with
+         * ENOTCONN on all subvoumes and still this branch will be
+         * true, but in those cases conservatively we decide to not
+         * delete the file until we are sure*/
+        ret = 0;
+        goto out;
+    }
 
-                /* Please note that the lookup call above could fail with
-                 * ENOTCONN on all subvoumes and still this branch will be
-                 * true, but in those cases conservatively we decide to not
-                 * delete the file until we are sure*/
-                ret = 0;
-                goto out;
+    /*Noway to recover, delete the name*/
+    loc_wipe(&loc);
+    loc.parent = inode_ref(name_data->parent);
+    gf_uuid_copy(loc.pargfid, loc.parent->gfid);
+    loc.name = name_data->name;
+    for (i = 0; i < ec->nodes; i++) {
+        if (same[i] && replies[i].valid && (replies[i].op_ret == 0)) {
+            ia = &replies[i].stat;
+            break;
         }
+    }
 
-        /*Noway to recover, delete the name*/
-        loc_wipe (&loc);
-        loc.parent = inode_ref (name_data->parent);
-        gf_uuid_copy (loc.pargfid, loc.parent->gfid);
-        loc.name = name_data->name;
-        for (i = 0; i < ec->nodes; i++) {
-                if (same[i] && replies[i].valid && (replies[i].op_ret == 0)) {
-                        ia = &replies[i].stat;
-                        break;
-                }
-        }
+    if (!ia) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        if (!ia) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    if (IA_ISDIR(ia->ia_type)) {
+        ret = cluster_rmdir(ec->xl_list, same, ec->nodes, replies, output,
+                            frame, ec->xl, &loc, 1, NULL);
+        gf_msg_debug(ec->xl->name, 0,
+                     "cluster rmdir succeeded on %d "
+                     "nodes",
+                     ret);
+    } else {
+        ret = cluster_unlink(ec->xl_list, same, ec->nodes, replies, output,
+                             frame, ec->xl, &loc, 0, NULL);
+        gf_msg_debug(ec->xl->name, 0,
+                     "cluster unlink succeeded on %d "
+                     "nodes",
+                     ret);
+    }
 
-        if (IA_ISDIR (ia->ia_type)) {
-                ret = cluster_rmdir (ec->xl_list, same, ec->nodes, replies,
-                                     output, frame, ec->xl, &loc, 1, NULL);
-                gf_msg_debug (ec->xl->name, 0, "cluster rmdir succeeded on %d "
-                              "nodes", ret);
+    for (i = 0; i < ec->nodes; i++) {
+        if (output[i]) {
+            same[i] = 0;
+            name_data->enoent[i] = 1;
         } else {
-                ret = cluster_unlink (ec->xl_list, same, ec->nodes, replies,
-                                      output, frame, ec->xl, &loc, 0, NULL);
-                gf_msg_debug (ec->xl->name, 0, "cluster unlink succeeded on %d "
-                              "nodes", ret);
-        }
-
-        for (i = 0; i < ec->nodes; i++) {
-                if (output[i]) {
-                        same[i] = 0;
-                        name_data->enoent[i] = 1;
-                } else {
-                        /*op failed*/
-                        if (same[i])
-                                name_data->participants[i] = 0;
-                }
+            /*op failed*/
+            if (same[i])
+                name_data->participants[i] = 0;
         }
-        ret = 0;
-        /*This will help in making decisions about creating names*/
-        dict_del (gfid_db, key);
+    }
+    ret = 0;
+    /*This will help in making decisions about creating names*/
+    dict_del(gfid_db, key);
 out:
-        if (ret < 0) {
-                gf_msg_debug (ec->xl->name, 0, "%s/%s: heal failed %s",
-                        uuid_utoa (name_data->parent->gfid), name_data->name,
-                        strerror (-ret));
-        }
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        return ret;
+    if (ret < 0) {
+        gf_msg_debug(ec->xl->name, 0, "%s/%s: heal failed %s",
+                     uuid_utoa(name_data->parent->gfid), name_data->name,
+                     strerror(-ret));
+    }
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-ec_delete_stale_names (call_frame_t *frame, ec_t *ec, inode_t *parent,
-                       char *name, default_args_cbk_t *replies, dict_t *gfid_db,
-                       unsigned char *enoent, unsigned char *gfidless,
-                       unsigned char *participants)
+ec_delete_stale_names(call_frame_t *frame, ec_t *ec, inode_t *parent,
+                      char *name, default_args_cbk_t *replies, dict_t *gfid_db,
+                      unsigned char *enoent, unsigned char *gfidless,
+                      unsigned char *participants)
 {
-        struct ec_name_data name_data = {0};
+    struct ec_name_data name_data = {0};
 
-        name_data.enoent = enoent;
-        name_data.gfidless = gfidless;
-        name_data.participants = participants;
-        name_data.name = name;
-        name_data.parent = parent;
-        name_data.frame = frame;
-        name_data.replies = replies;
-        return dict_foreach (gfid_db, ec_delete_stale_name, &name_data);
+    name_data.enoent = enoent;
+    name_data.gfidless = gfidless;
+    name_data.participants = participants;
+    name_data.name = name;
+    name_data.parent = parent;
+    name_data.frame = frame;
+    name_data.replies = replies;
+    return dict_foreach(gfid_db, ec_delete_stale_name, &name_data);
 }
 
 int
-_assign_same (dict_t *dict, char *key, data_t *value, void *data)
+_assign_same(dict_t *dict, char *key, data_t *value, void *data)
 {
-        struct ec_name_data *name_data = data;
+    struct ec_name_data *name_data = data;
 
-        name_data->same = data_to_bin (value);
-        return 0;
+    name_data->same = data_to_bin(value);
+    return 0;
 }
 
 int
-ec_create_name (call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
-                default_args_cbk_t *lookup_replies, dict_t *gfid_db,
-                unsigned char *enoent, unsigned char *participants)
-{
-        int                 ret       = 0;
-        int                 i         = 0;
-        struct ec_name_data name_data = {0};
-        struct iatt         *ia       = NULL;
-        unsigned char       *output   = 0;
-        unsigned char       *output1  = 0;
-        unsigned char       *on       = NULL;
-        default_args_cbk_t  *replies  = NULL;
-        loc_t               loc       = {0};
-        loc_t               srcloc    = {0};
-        unsigned char       *link     = NULL;
-        unsigned char       *create   = NULL;
-        dict_t              *xdata    = NULL;
-        char                *linkname = NULL;
-        ec_config_t         config;
-        /* There should be just one gfid key */
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        if (gfid_db->count != 1) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        ret = dict_foreach (gfid_db, _assign_same, &name_data);
-        if (ret < 0)
-                goto out;
-        /*There should at least be one valid success reply with gfid*/
-        for (i = 0; i < ec->nodes; i++)
-                if (name_data.same[i])
-                        break;
+ec_create_name(call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
+               default_args_cbk_t *lookup_replies, dict_t *gfid_db,
+               unsigned char *enoent, unsigned char *participants)
+{
+    int ret = 0;
+    int i = 0;
+    struct ec_name_data name_data = {0};
+    struct iatt *ia = NULL;
+    unsigned char *output = 0;
+    unsigned char *output1 = 0;
+    unsigned char *on = NULL;
+    default_args_cbk_t *replies = NULL;
+    loc_t loc = {0};
+    loc_t srcloc = {0};
+    unsigned char *link = NULL;
+    unsigned char *create = NULL;
+    dict_t *xdata = NULL;
+    char *linkname = NULL;
+    ec_config_t config;
+    /* There should be just one gfid key */
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    if (gfid_db->count != 1) {
+        ret = -EINVAL;
+        goto out;
+    }
 
-        if (i == ec->nodes) {
-                ret = -EINVAL;
-                goto out;
-        }
+    ret = dict_foreach(gfid_db, _assign_same, &name_data);
+    if (ret < 0)
+        goto out;
+    /*There should at least be one valid success reply with gfid*/
+    for (i = 0; i < ec->nodes; i++)
+        if (name_data.same[i])
+            break;
 
-        ia = &lookup_replies[i].stat;
-        xdata = dict_new ();
-        loc.parent = inode_ref (parent);
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.inode = inode_new (parent->table);
-        if (loc.inode)
-                srcloc.inode = inode_ref (loc.inode);
-        gf_uuid_copy (srcloc.gfid, ia->ia_gfid);
-        if (!loc.inode || !xdata || dict_set_static_bin (xdata, "gfid-req",
-                                                         ia->ia_gfid,
-                                                        sizeof (ia->ia_gfid))) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        loc.name = name;
-        link = alloca0 (ec->nodes);
-        create = alloca0 (ec->nodes);
-        on = alloca0 (ec->nodes);
-        output = alloca0 (ec->nodes);
-        output1 = alloca0 (ec->nodes);
+    if (i == ec->nodes) {
+        ret = -EINVAL;
+        goto out;
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!lookup_replies[i].valid)
-                        continue;
-                if (lookup_replies[i].op_ret)
-                        continue;
-                on[i] = 1;
-        }
-        switch (ia->ia_type) {
+    ia = &lookup_replies[i].stat;
+    xdata = dict_new();
+    loc.parent = inode_ref(parent);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.inode = inode_new(parent->table);
+    if (loc.inode)
+        srcloc.inode = inode_ref(loc.inode);
+    gf_uuid_copy(srcloc.gfid, ia->ia_gfid);
+    if (!loc.inode || !xdata ||
+        dict_set_static_bin(xdata, "gfid-req", ia->ia_gfid,
+                            sizeof(ia->ia_gfid))) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    loc.name = name;
+    link = alloca0(ec->nodes);
+    create = alloca0(ec->nodes);
+    on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    output1 = alloca0(ec->nodes);
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (!lookup_replies[i].valid)
+            continue;
+        if (lookup_replies[i].op_ret)
+            continue;
+        on[i] = 1;
+    }
+    switch (ia->ia_type) {
         case IA_IFDIR:
-                ec_set_new_entry_dirty (ec, &loc, ia, frame, ec->xl, on);
-                (void) cluster_mkdir (ec->xl_list, enoent, ec->nodes,
-                                   replies, output, frame, ec->xl, &loc,
-                                   st_mode_from_ia (ia->ia_prot,
-                                                ia->ia_type), 0, xdata);
-                break;
+            ec_set_new_entry_dirty(ec, &loc, ia, frame, ec->xl, on);
+            (void)cluster_mkdir(
+                ec->xl_list, enoent, ec->nodes, replies, output, frame, ec->xl,
+                &loc, st_mode_from_ia(ia->ia_prot, ia->ia_type), 0, xdata);
+            break;
 
         case IA_IFLNK:
-                /*Check for hard links and create/link*/
-                ret = cluster_lookup (ec->xl_list, enoent, ec->nodes,
-                                      replies, output, frame, ec->xl,
-                                      &srcloc, NULL);
-                for (i = 0; i < ec->nodes; i++) {
-                        if (output[i]) {
-                                link[i] = 1;
-                        } else {
-                                if (replies[i].op_errno == ENOENT ||
-                                    replies[i].op_errno == ESTALE) {
-                                        create[i] = 1;
-                                }
-                        }
+            /*Check for hard links and create/link*/
+            ret = cluster_lookup(ec->xl_list, enoent, ec->nodes, replies,
+                                 output, frame, ec->xl, &srcloc, NULL);
+            for (i = 0; i < ec->nodes; i++) {
+                if (output[i]) {
+                    link[i] = 1;
+                } else {
+                    if (replies[i].op_errno == ENOENT ||
+                        replies[i].op_errno == ESTALE) {
+                        create[i] = 1;
+                    }
                 }
-
-                if (EC_COUNT (link, ec->nodes)) {
-                        cluster_link (ec->xl_list, link, ec->nodes,
-                                      replies, output1, frame, ec->xl,
-                                      &srcloc, &loc, NULL);
+            }
+
+            if (EC_COUNT(link, ec->nodes)) {
+                cluster_link(ec->xl_list, link, ec->nodes, replies, output1,
+                             frame, ec->xl, &srcloc, &loc, NULL);
+            }
+
+            if (EC_COUNT(create, ec->nodes)) {
+                cluster_readlink(ec->xl_list, name_data.same, ec->nodes,
+                                 replies, output, frame, ec->xl, &srcloc, 4096,
+                                 NULL);
+                if (EC_COUNT(output, ec->nodes) == 0) {
+                    ret = -ENOTCONN;
+                    goto out;
                 }
 
-                if (EC_COUNT (create, ec->nodes)) {
-                        cluster_readlink (ec->xl_list, name_data.same,
-                                          ec->nodes, replies, output,
-                                          frame, ec->xl, &srcloc, 4096,
-                                          NULL);
-                        if (EC_COUNT (output, ec->nodes) == 0) {
-                                ret = -ENOTCONN;
-                                goto out;
-                        }
-
-                        for (i = 0; i < ec->nodes; i++) {
-                                if (output[i])
-                                        break;
-                        }
-                        linkname = alloca0 (strlen(replies[i].buf) + 1);
-                        strcpy (linkname, replies[i].buf);
-                        ec_set_new_entry_dirty (ec, &loc, ia, frame,
-                                                ec->xl, on);
-                        cluster_symlink (ec->xl_list, create, ec->nodes,
-                                         replies, output, frame, ec->xl,
-                                         linkname, &loc, 0, xdata);
+                for (i = 0; i < ec->nodes; i++) {
+                    if (output[i])
+                        break;
                 }
-                for (i = 0; i < ec->nodes; i++)
-                        if (output1[i])
-                                output[i] = 1;
-                break;
+                linkname = alloca0(strlen(replies[i].buf) + 1);
+                strcpy(linkname, replies[i].buf);
+                ec_set_new_entry_dirty(ec, &loc, ia, frame, ec->xl, on);
+                cluster_symlink(ec->xl_list, create, ec->nodes, replies, output,
+                                frame, ec->xl, linkname, &loc, 0, xdata);
+            }
+            for (i = 0; i < ec->nodes; i++)
+                if (output1[i])
+                    output[i] = 1;
+            break;
         case IA_IFREG:
-                ec_set_new_entry_dirty (ec, &loc, ia,
-                                        frame, ec->xl, on);
-                config.version = EC_CONFIG_VERSION;
-                config.algorithm = EC_CONFIG_ALGORITHM;
-                config.gf_word_size = EC_GF_BITS;
-                config.bricks = ec->nodes;
-                config.redundancy = ec->redundancy;
-                config.chunk_size = EC_METHOD_CHUNK_SIZE;
-
-                ret = ec_dict_set_config(xdata, EC_XATTR_CONFIG, &config);
-                if (ret != 0) {
-                        goto out;
-                }
+            ec_set_new_entry_dirty(ec, &loc, ia, frame, ec->xl, on);
+            config.version = EC_CONFIG_VERSION;
+            config.algorithm = EC_CONFIG_ALGORITHM;
+            config.gf_word_size = EC_GF_BITS;
+            config.bricks = ec->nodes;
+            config.redundancy = ec->redundancy;
+            config.chunk_size = EC_METHOD_CHUNK_SIZE;
+
+            ret = ec_dict_set_config(xdata, EC_XATTR_CONFIG, &config);
+            if (ret != 0) {
+                goto out;
+            }
 
-        /* Fall through */
+            /* Fall through */
 
         default:
-                ret = dict_set_int32 (xdata, GLUSTERFS_INTERNAL_FOP_KEY,
-                                      1);
-                if (ret)
-                        goto out;
-                ret = cluster_mknod (ec->xl_list, enoent, ec->nodes,
-                                     replies, output, frame, ec->xl,
-                                     &loc, st_mode_from_ia (ia->ia_prot,
-                                                           ia->ia_type),
-                         makedev(ia_major(ia->ia_rdev), ia_minor(ia->ia_rdev)),
-                         0, xdata);
-                break;
-        }
+            ret = dict_set_int32(xdata, GLUSTERFS_INTERNAL_FOP_KEY, 1);
+            if (ret)
+                goto out;
+            ret = cluster_mknod(
+                ec->xl_list, enoent, ec->nodes, replies, output, frame, ec->xl,
+                &loc, st_mode_from_ia(ia->ia_prot, ia->ia_type),
+                makedev(ia_major(ia->ia_rdev), ia_minor(ia->ia_rdev)), 0,
+                xdata);
+            break;
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (enoent[i] && !output[i])
-                        participants[i] = 0;
-        }
+    for (i = 0; i < ec->nodes; i++) {
+        if (enoent[i] && !output[i])
+            participants[i] = 0;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret < 0)
-                gf_msg_debug (ec->xl->name, 0, "%s/%s: heal failed %s",
-                        uuid_utoa (parent->gfid), name, strerror (-ret));
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        loc_wipe (&srcloc);
-        if (xdata)
-                dict_unref (xdata);
-        return ret;
+    if (ret < 0)
+        gf_msg_debug(ec->xl->name, 0, "%s/%s: heal failed %s",
+                     uuid_utoa(parent->gfid), name, strerror(-ret));
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    loc_wipe(&srcloc);
+    if (xdata)
+        dict_unref(xdata);
+    return ret;
 }
 
 int
-__ec_heal_name (call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
-                unsigned char *participants)
-{
-        unsigned char      *output   = NULL;
-        unsigned char      *enoent   = NULL;
-        default_args_cbk_t *replies  = NULL;
-        dict_t             *xdata    = NULL;
-        dict_t             *gfid_db  = NULL;
-        int                ret       = 0;
-        loc_t              loc       = {0};
-        int                i         = 0;
-        struct iatt        *ia       = NULL;
-        char               gfid[64]  = {0};
-        unsigned char      *same     = NULL;
-        unsigned char      *gfidless = NULL;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        loc.parent = inode_ref (parent);
-        loc.inode = inode_new (parent->table);
-        gf_uuid_copy (loc.pargfid, parent->gfid);
-        loc.name = name;
-        xdata = dict_new ();
-        gfid_db = dict_new ();
-        if (!xdata || !gfid_db || !loc.inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+__ec_heal_name(call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
+               unsigned char *participants)
+{
+    unsigned char *output = NULL;
+    unsigned char *enoent = NULL;
+    default_args_cbk_t *replies = NULL;
+    dict_t *xdata = NULL;
+    dict_t *gfid_db = NULL;
+    int ret = 0;
+    loc_t loc = {0};
+    int i = 0;
+    struct iatt *ia = NULL;
+    char gfid[64] = {0};
+    unsigned char *same = NULL;
+    unsigned char *gfidless = NULL;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    loc.parent = inode_ref(parent);
+    loc.inode = inode_new(parent->table);
+    gf_uuid_copy(loc.pargfid, parent->gfid);
+    loc.name = name;
+    xdata = dict_new();
+    gfid_db = dict_new();
+    if (!xdata || !gfid_db || !loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ret = dict_set_int32 (xdata, GF_GFIDLESS_LOOKUP, 1);
-        if (ret) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    ret = dict_set_int32(xdata, GF_GFIDLESS_LOOKUP, 1);
+    if (ret) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        output = alloca0 (ec->nodes);
-        gfidless = alloca0 (ec->nodes);
-        enoent = alloca0 (ec->nodes);
-        ret = cluster_lookup (ec->xl_list, participants, ec->nodes, replies,
-                              output, frame, ec->xl, &loc, NULL);
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
-
-                if (replies[i].op_ret == -1) {
-                        /*If ESTALE comes here, that means parent dir is not
-                         * present, nothing to do there, so reset participants
-                         * for that brick*/
-                        if (replies[i].op_errno == ENOENT)
-                                enoent[i] = 1;
-                        else
-                                participants[i] = 0;
-                        continue;
-                }
-                ia = &replies[i].stat;
-                if (gf_uuid_is_null (ia->ia_gfid)) {
-                        if (IA_ISDIR (ia->ia_type) || ia->ia_size == 0)
-                                gfidless[i] = 1;
-                        else
-                                participants[i] = 0;
-                } else {
-                        uuid_utoa_r (ia->ia_gfid, gfid);
-                        ret = dict_get_bin (gfid_db, gfid, (void **)&same);
-                        if (ret < 0) {
-                                same = alloca0(ec->nodes);
-                        }
-                        same[i] = 1;
-                        if (ret < 0) {
-                                ret = dict_set_static_bin (gfid_db, gfid, same,
-                                                           ec->nodes);
-                        }
-                        if (ret < 0)
-                                goto out;
-                }
+    output = alloca0(ec->nodes);
+    gfidless = alloca0(ec->nodes);
+    enoent = alloca0(ec->nodes);
+    ret = cluster_lookup(ec->xl_list, participants, ec->nodes, replies, output,
+                         frame, ec->xl, &loc, NULL);
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
+
+        if (replies[i].op_ret == -1) {
+            /*If ESTALE comes here, that means parent dir is not
+             * present, nothing to do there, so reset participants
+             * for that brick*/
+            if (replies[i].op_errno == ENOENT)
+                enoent[i] = 1;
+            else
+                participants[i] = 0;
+            continue;
+        }
+        ia = &replies[i].stat;
+        if (gf_uuid_is_null(ia->ia_gfid)) {
+            if (IA_ISDIR(ia->ia_type) || ia->ia_size == 0)
+                gfidless[i] = 1;
+            else
+                participants[i] = 0;
+        } else {
+            uuid_utoa_r(ia->ia_gfid, gfid);
+            ret = dict_get_bin(gfid_db, gfid, (void **)&same);
+            if (ret < 0) {
+                same = alloca0(ec->nodes);
+            }
+            same[i] = 1;
+            if (ret < 0) {
+                ret = dict_set_static_bin(gfid_db, gfid, same, ec->nodes);
+            }
+            if (ret < 0)
+                goto out;
         }
+    }
 
-        ret = ec_delete_stale_names (frame, ec, parent, name, replies, gfid_db,
-                                     enoent, gfidless, participants);
+    ret = ec_delete_stale_names(frame, ec, parent, name, replies, gfid_db,
+                                enoent, gfidless, participants);
 
-        if (gfid_db->count == 0) {
-                /* All entries seem to be stale entries and deleted,
-                 * nothing more to do.*/
-                goto out;
-        }
+    if (gfid_db->count == 0) {
+        /* All entries seem to be stale entries and deleted,
+         * nothing more to do.*/
+        goto out;
+    }
 
-        if (gfid_db->count > 1) {
-                gf_msg (ec->xl->name, GF_LOG_INFO, 0,
-                        EC_MSG_HEAL_FAIL, "%s/%s: Not able to heal",
-                        uuid_utoa (parent->gfid), name);
-                memset (participants, 0, ec->nodes);
-                goto out;
-        }
+    if (gfid_db->count > 1) {
+        gf_msg(ec->xl->name, GF_LOG_INFO, 0, EC_MSG_HEAL_FAIL,
+               "%s/%s: Not able to heal", uuid_utoa(parent->gfid), name);
+        memset(participants, 0, ec->nodes);
+        goto out;
+    }
 
-        EC_INTERSECT (enoent, enoent, participants, ec->nodes);
-        if (EC_COUNT (enoent, ec->nodes) == 0) {
-                ret = 0;
-                goto out;
-        }
+    EC_INTERSECT(enoent, enoent, participants, ec->nodes);
+    if (EC_COUNT(enoent, ec->nodes) == 0) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = ec_create_name (frame, ec, parent, name, replies, gfid_db, enoent,
-                              participants);
+    ret = ec_create_name(frame, ec, parent, name, replies, gfid_db, enoent,
+                         participants);
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        if (xdata)
-                dict_unref (xdata);
-        if (gfid_db)
-                dict_unref (gfid_db);
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    if (xdata)
+        dict_unref(xdata);
+    if (gfid_db)
+        dict_unref(gfid_db);
+    return ret;
 }
 
 int
-ec_heal_name (call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
-              unsigned char *participants)
-{
-        int                ret        = 0;
-        default_args_cbk_t *replies   = NULL;
-        unsigned char      *output    = NULL;
-        unsigned char      *locked_on = NULL;
-        loc_t              loc        = {0};
-
-        loc.parent = inode_ref (parent);
-        loc.name = name;
-        loc.inode = inode_new (parent->table);
-        if (!loc.inode) {
-                ret = -ENOMEM;
-                goto out;
-        }
+ec_heal_name(call_frame_t *frame, ec_t *ec, inode_t *parent, char *name,
+             unsigned char *participants)
+{
+    int ret = 0;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    unsigned char *locked_on = NULL;
+    loc_t loc = {0};
+
+    loc.parent = inode_ref(parent);
+    loc.name = name;
+    loc.inode = inode_new(parent->table);
+    if (!loc.inode) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        output = alloca0 (ec->nodes);
-        locked_on = alloca0 (ec->nodes);
-        ret = cluster_inodelk (ec->xl_list, participants, ec->nodes, replies,
-                               locked_on, frame, ec->xl, ec->xl->name, parent,
-                               0, 0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s/%s: Skipping "
-                                "heal as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (parent->gfid), name,
-                                ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                EC_INTERSECT (participants, participants, locked_on, ec->nodes);
-                ret = __ec_heal_name (frame, ec, parent, name, participants);
-        }
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    output = alloca0(ec->nodes);
+    locked_on = alloca0(ec->nodes);
+    ret = cluster_inodelk(ec->xl_list, participants, ec->nodes, replies,
+                          locked_on, frame, ec->xl, ec->xl->name, parent, 0, 0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s/%s: Skipping "
+                         "heal as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(parent->gfid), name, ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        EC_INTERSECT(participants, participants, locked_on, ec->nodes);
+        ret = __ec_heal_name(frame, ec, parent, name, participants);
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, ec->xl->name, parent, 0, 0);
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, parent, 0, 0);
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-ec_name_heal_handler (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                      void *data)
-{
-        struct ec_name_data *name_data = data;
-        xlator_t            *this      = THIS;
-        ec_t                *ec        = this->private;
-        unsigned char       *name_on   = alloca0 (ec->nodes);
-        int                 i          = 0;
-        int                 ret        = 0;
-
-        if (ec->shutdown) {
-                gf_msg_debug(this->name, 0, "Cancelling directory heal "
-                                            "because EC is stopping.");
-                return -ENOTCONN;
-        }
+ec_name_heal_handler(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                     void *data)
+{
+    struct ec_name_data *name_data = data;
+    xlator_t *this = THIS;
+    ec_t *ec = this->private;
+    unsigned char *name_on = alloca0(ec->nodes);
+    int i = 0;
+    int ret = 0;
+
+    if (ec->shutdown) {
+        gf_msg_debug(this->name, 0,
+                     "Cancelling directory heal "
+                     "because EC is stopping.");
+        return -ENOTCONN;
+    }
 
-        memcpy (name_on, name_data->participants, ec->nodes);
-        ret = ec_heal_name (name_data->frame, ec, parent->inode,
-                            entry->d_name, name_on);
+    memcpy(name_on, name_data->participants, ec->nodes);
+    ret = ec_heal_name(name_data->frame, ec, parent->inode, entry->d_name,
+                       name_on);
 
-        if (ret < 0)
-                memset (name_on, 0, ec->nodes);
+    if (ret < 0)
+        memset(name_on, 0, ec->nodes);
 
-        for (i = 0; i < ec->nodes; i++)
-                if (name_data->participants[i] && !name_on[i])
-                        name_data->failed_on[i] = 1;
-        return 0;
+    for (i = 0; i < ec->nodes; i++)
+        if (name_data->participants[i] && !name_on[i])
+            name_data->failed_on[i] = 1;
+    return 0;
 }
 
 int
-ec_heal_names (call_frame_t *frame, ec_t *ec, inode_t *inode,
-               unsigned char *participants)
+ec_heal_names(call_frame_t *frame, ec_t *ec, inode_t *inode,
+              unsigned char *participants)
 {
-        int i = 0;
-        int j = 0;
-        loc_t loc = {0};
-        struct ec_name_data name_data = {0};
-        int ret = 0;
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        name_data.frame = frame;
-        name_data.participants = participants;
-        name_data.failed_on = alloca0(ec->nodes);;
-
-        for (i = 0; i < ec->nodes; i++) {
-                if (!participants[i])
-                        continue;
-                ret = syncop_dir_scan (ec->xl_list[i], &loc,
-                                       GF_CLIENT_PID_SELF_HEALD, &name_data,
-                                       ec_name_heal_handler);
-                if (ret < 0) {
-                        break;
-                }
-                for (j = 0; j < ec->nodes; j++)
-                        if (name_data.failed_on[j])
-                                participants[j] = 0;
+    int i = 0;
+    int j = 0;
+    loc_t loc = {0};
+    struct ec_name_data name_data = {0};
+    int ret = 0;
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    name_data.frame = frame;
+    name_data.participants = participants;
+    name_data.failed_on = alloca0(ec->nodes);
+    ;
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (!participants[i])
+            continue;
+        ret = syncop_dir_scan(ec->xl_list[i], &loc, GF_CLIENT_PID_SELF_HEALD,
+                              &name_data, ec_name_heal_handler);
+        if (ret < 0) {
+            break;
+        }
+        for (j = 0; j < ec->nodes; j++)
+            if (name_data.failed_on[j])
+                participants[j] = 0;
 
-                if (EC_COUNT (participants, ec->nodes) <= ec->fragments) {
-                        ret = -ENOTCONN;
-                        break;
-                }
+        if (EC_COUNT(participants, ec->nodes) <= ec->fragments) {
+            ret = -ENOTCONN;
+            break;
         }
-        loc_wipe (&loc);
-        return ret;
+    }
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-__ec_heal_entry (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                 unsigned char *heal_on, unsigned char *sources,
-                 unsigned char *healed_sinks)
-{
-        unsigned char      *locked_on    = NULL;
-        unsigned char      *output       = NULL;
-        uint64_t           *versions     = NULL;
-        uint64_t           *dirty        = NULL;
-        unsigned char      *participants = NULL;
-        default_args_cbk_t *replies      = NULL;
-        int                ret           = 0;
-        int                source        = 0;
-        int                i             = 0;
-
-        locked_on = alloca0(ec->nodes);
-        output = alloca0(ec->nodes);
-        versions = alloca0 (ec->nodes * sizeof (*versions));
-        dirty = alloca0 (ec->nodes * sizeof (*dirty));
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        ret = cluster_inodelk (ec->xl_list, heal_on, ec->nodes, replies,
-                               locked_on, frame, ec->xl, ec->xl->name, inode,
-                               0, 0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                ret = __ec_heal_entry_prepare (frame, ec, inode, locked_on,
-                                               versions, dirty, sources,
-                                               healed_sinks);
-                source = ret;
-        }
+__ec_heal_entry(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                unsigned char *heal_on, unsigned char *sources,
+                unsigned char *healed_sinks)
+{
+    unsigned char *locked_on = NULL;
+    unsigned char *output = NULL;
+    uint64_t *versions = NULL;
+    uint64_t *dirty = NULL;
+    unsigned char *participants = NULL;
+    default_args_cbk_t *replies = NULL;
+    int ret = 0;
+    int source = 0;
+    int i = 0;
+
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    versions = alloca0(ec->nodes * sizeof(*versions));
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    ret = cluster_inodelk(ec->xl_list, heal_on, ec->nodes, replies, locked_on,
+                          frame, ec->xl, ec->xl->name, inode, 0, 0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        ret = __ec_heal_entry_prepare(frame, ec, inode, locked_on, versions,
+                                      dirty, sources, healed_sinks);
+        source = ret;
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, ec->xl->name, inode, 0, 0);
-        if (ret < 0)
-                goto out;
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, inode, 0, 0);
+    if (ret < 0)
+        goto out;
 
-        participants = alloca0 (ec->nodes);
-        for (i = 0; i < ec->nodes; i++) {
-                if (sources[i] || healed_sinks[i])
-                        participants[i] = 1;
-        }
-        ret = ec_heal_names (frame, ec, inode, participants);
+    participants = alloca0(ec->nodes);
+    for (i = 0; i < ec->nodes; i++) {
+        if (sources[i] || healed_sinks[i])
+            participants[i] = 1;
+    }
+    ret = ec_heal_names(frame, ec, inode, participants);
 
-        if (EC_COUNT (participants, ec->nodes) <= ec->fragments)
-                goto out;
+    if (EC_COUNT(participants, ec->nodes) <= ec->fragments)
+        goto out;
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!participants[i]) {
-                        sources[i] = 0;
-                        healed_sinks[i] = 0;
-                }
+    for (i = 0; i < ec->nodes; i++) {
+        if (!participants[i]) {
+            sources[i] = 0;
+            healed_sinks[i] = 0;
         }
+    }
 
-        ec_adjust_versions (frame, ec, EC_DATA_TXN, inode, source,
-                            sources, healed_sinks, versions, dirty);
+    ec_adjust_versions(frame, ec, EC_DATA_TXN, inode, source, sources,
+                       healed_sinks, versions, dirty);
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 int
-ec_heal_entry (call_frame_t *frame, ec_t *ec, inode_t *inode,
-               unsigned char *sources, unsigned char *healed_sinks)
+ec_heal_entry(call_frame_t *frame, ec_t *ec, inode_t *inode,
+              unsigned char *sources, unsigned char *healed_sinks)
 {
-        unsigned char      *locked_on            = NULL;
-        unsigned char      *up_subvols           = NULL;
-        unsigned char      *output               = NULL;
-        char               selfheal_domain[1024] = {0};
-        int                ret                   = 0;
-        default_args_cbk_t *replies              = NULL;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        locked_on = alloca0(ec->nodes);
-        output = alloca0(ec->nodes);
-        up_subvols = alloca0(ec->nodes);
-
-        sprintf (selfheal_domain, "%s:self-heal", ec->xl->name);
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
-        /*If other processes are already doing the heal, don't block*/
-        ret = cluster_tiebreaker_inodelk (ec->xl_list, up_subvols, ec->nodes,
-                                          replies, locked_on, frame, ec->xl,
-                                          selfheal_domain, inode, 0, 0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                ret = __ec_heal_entry (frame, ec, inode, locked_on,
-                                       sources, healed_sinks);
-        }
+    unsigned char *locked_on = NULL;
+    unsigned char *up_subvols = NULL;
+    unsigned char *output = NULL;
+    char selfheal_domain[1024] = {0};
+    int ret = 0;
+    default_args_cbk_t *replies = NULL;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    up_subvols = alloca0(ec->nodes);
+
+    sprintf(selfheal_domain, "%s:self-heal", ec->xl->name);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
+    /*If other processes are already doing the heal, don't block*/
+    ret = cluster_tiebreaker_inodelk(ec->xl_list, up_subvols, ec->nodes,
+                                     replies, locked_on, frame, ec->xl,
+                                     selfheal_domain, inode, 0, 0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        ret = __ec_heal_entry(frame, ec, inode, locked_on, sources,
+                              healed_sinks);
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, selfheal_domain, inode, 0, 0);
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, selfheal_domain, inode, 0, 0);
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 /*Find direction for data heal and heal info*/
 int
-ec_heal_data_find_direction (ec_t *ec, default_args_cbk_t *replies,
-                       uint64_t *data_versions,
-                       uint64_t *dirty, uint64_t *size, unsigned char *sources,
-                       unsigned char *healed_sinks,
-                       gf_boolean_t check_ondisksize, int which)
-{
-        uint64_t        xattr[EC_VERSION_SIZE] = {0};
-        char            version_size[128] = {0};
-        dict_t          *version_size_db = NULL;
-        unsigned char   *same            = NULL;
-        int             max_same_count   = 0;
-        int             source           = 0;
-        int             i                = 0;
-        int             ret              = 0;
-        dict_t          *dict            = NULL;
-        uint64_t        source_size      = 0;
-
-        version_size_db = dict_new ();
-        if (!version_size_db) {
-                ret = -ENOMEM;
-                goto out;
+ec_heal_data_find_direction(ec_t *ec, default_args_cbk_t *replies,
+                            uint64_t *data_versions, uint64_t *dirty,
+                            uint64_t *size, unsigned char *sources,
+                            unsigned char *healed_sinks,
+                            gf_boolean_t check_ondisksize, int which)
+{
+    uint64_t xattr[EC_VERSION_SIZE] = {0};
+    char version_size[128] = {0};
+    dict_t *version_size_db = NULL;
+    unsigned char *same = NULL;
+    int max_same_count = 0;
+    int source = 0;
+    int i = 0;
+    int ret = 0;
+    dict_t *dict = NULL;
+    uint64_t source_size = 0;
+
+    version_size_db = dict_new();
+    if (!version_size_db) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (!replies[i].valid)
+            continue;
+        if (replies[i].op_ret < 0)
+            continue;
+        dict = (which == EC_COMBINE_XDATA) ? replies[i].xdata
+                                           : replies[i].xattr;
+
+        ret = ec_dict_get_array(dict, EC_XATTR_VERSION, xattr, EC_VERSION_SIZE);
+        if (ret == 0) {
+            data_versions[i] = xattr[EC_DATA_TXN];
         }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!replies[i].valid)
-                        continue;
-                if (replies[i].op_ret < 0)
-                        continue;
-                dict = (which == EC_COMBINE_XDATA) ? replies[i].xdata :
-                                                     replies[i].xattr;
-
-                ret = ec_dict_get_array (dict, EC_XATTR_VERSION,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        data_versions[i] = xattr[EC_DATA_TXN];
-                }
+        memset(xattr, 0, sizeof(xattr));
+        ret = ec_dict_get_array(dict, EC_XATTR_DIRTY, xattr, EC_VERSION_SIZE);
+        if (ret == 0) {
+            dirty[i] = xattr[EC_DATA_TXN];
+        }
+        ret = ec_dict_del_number(dict, EC_XATTR_SIZE, &size[i]);
+        /*Build a db of same metadata and data version and size*/
+        snprintf(version_size, sizeof(version_size), "%" PRIu64 "-%" PRIu64,
+                 data_versions[i], size[i]);
 
-                memset (xattr, 0, sizeof (xattr));
-                ret = ec_dict_get_array (dict, EC_XATTR_DIRTY,
-                                         xattr, EC_VERSION_SIZE);
-                if (ret == 0) {
-                        dirty[i] = xattr[EC_DATA_TXN];
-                }
-                ret = ec_dict_del_number (dict, EC_XATTR_SIZE,
-                                          &size[i]);
-                /*Build a db of same metadata and data version and size*/
-                snprintf (version_size, sizeof (version_size),
-                          "%"PRIu64"-%"PRIu64, data_versions[i], size[i]);
-
-                ret = dict_get_bin (version_size_db, version_size,
-                                    (void **)&same);
-                if (ret < 0) {
-                        same = alloca0 (ec->nodes);
-                }
+        ret = dict_get_bin(version_size_db, version_size, (void **)&same);
+        if (ret < 0) {
+            same = alloca0(ec->nodes);
+        }
 
-                same[i] = 1;
-                if (max_same_count < EC_COUNT (same, ec->nodes)) {
-                        max_same_count = EC_COUNT (same, ec->nodes);
-                        source = i;
-                }
+        same[i] = 1;
+        if (max_same_count < EC_COUNT(same, ec->nodes)) {
+            max_same_count = EC_COUNT(same, ec->nodes);
+            source = i;
+        }
 
-                if (ret < 0) {
-                        ret = dict_set_static_bin (version_size_db,
-                                                version_size, same, ec->nodes);
-                }
+        if (ret < 0) {
+            ret = dict_set_static_bin(version_size_db, version_size, same,
+                                      ec->nodes);
+        }
 
-                if (ret < 0) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+        if (ret < 0) {
+            ret = -ENOMEM;
+            goto out;
         }
-        /* If we don't have ec->fragments number of same version,size it is not
-         * recoverable*/
-        if (max_same_count < ec->fragments) {
-                ret = -EIO;
-                goto out;
-        } else {
-                snprintf (version_size, sizeof (version_size),
-                          "%"PRIu64"-%"PRIu64, data_versions[source],
-                          size[source]);
-
-                ret = dict_get_bin (version_size_db, version_size,
-                                    (void **)&same);
-                if (ret < 0)
-                        goto out;
-                memcpy (sources, same, ec->nodes);
-                for (i = 0; i < ec->nodes; i++) {
-                        if (replies[i].valid && (replies[i].op_ret == 0) &&
-                            !sources[i])
-                                healed_sinks[i] = 1;
-                }
+    }
+    /* If we don't have ec->fragments number of same version,size it is not
+     * recoverable*/
+    if (max_same_count < ec->fragments) {
+        ret = -EIO;
+        goto out;
+    } else {
+        snprintf(version_size, sizeof(version_size), "%" PRIu64 "-%" PRIu64,
+                 data_versions[source], size[source]);
+
+        ret = dict_get_bin(version_size_db, version_size, (void **)&same);
+        if (ret < 0)
+            goto out;
+        memcpy(sources, same, ec->nodes);
+        for (i = 0; i < ec->nodes; i++) {
+            if (replies[i].valid && (replies[i].op_ret == 0) && !sources[i])
+                healed_sinks[i] = 1;
         }
+    }
 
-        /* There could be files with versions, size same but on disk ia_size
-         * could be different because of disk crashes, mark them as sinks as
-         * well*/
+    /* There could be files with versions, size same but on disk ia_size
+     * could be different because of disk crashes, mark them as sinks as
+     * well*/
 
-        if (check_ondisksize) {
-                source_size = size[source];
-                ec_adjust_size_up (ec, &source_size, _gf_true);
+    if (check_ondisksize) {
+        source_size = size[source];
+        ec_adjust_size_up(ec, &source_size, _gf_true);
 
-                for (i = 0; i < ec->nodes; i++) {
-                        if (sources[i]) {
-                                if (replies[i].stat.ia_size != source_size) {
-                                        sources[i] = 0;
-                                        healed_sinks[i] = 1;
-                                        max_same_count--;
-                                } else {
-                                        source = i;
-                                }
-                        }
-                }
-                if (max_same_count < ec->fragments) {
-                        ret = -EIO;
-                        goto out;
+        for (i = 0; i < ec->nodes; i++) {
+            if (sources[i]) {
+                if (replies[i].stat.ia_size != source_size) {
+                    sources[i] = 0;
+                    healed_sinks[i] = 1;
+                    max_same_count--;
+                } else {
+                    source = i;
                 }
+            }
         }
+        if (max_same_count < ec->fragments) {
+            ret = -EIO;
+            goto out;
+        }
+    }
 
-        ret = source;
+    ret = source;
 out:
-        if (version_size_db)
-                dict_unref (version_size_db);
-        return ret;
+    if (version_size_db)
+        dict_unref(version_size_db);
+    return ret;
 }
 
 int
-__ec_heal_data_prepare (call_frame_t *frame, ec_t *ec, fd_t *fd,
-                        unsigned char *locked_on, uint64_t *versions,
-                        uint64_t *dirty, uint64_t *size, unsigned char *sources,
-                        unsigned char *healed_sinks, unsigned char *trim,
-                        struct iatt *stbuf)
-{
-        default_args_cbk_t *replies = NULL;
-        default_args_cbk_t *fstat_replies = NULL;
-        unsigned char      *output  = NULL;
-        unsigned char      *fstat_output  = NULL;
-        dict_t             *xattrs  = NULL;
-        uint64_t           zero_array[2] = {0};
-        int                source   = 0;
-        int                ret      = 0;
-        uint64_t           zero_value = 0;
-        int                i = 0;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        EC_REPLIES_ALLOC (fstat_replies, ec->nodes);
-        output = alloca0(ec->nodes);
-        fstat_output = alloca0(ec->nodes);
-        xattrs = dict_new ();
-        if (!xattrs ||
-            dict_set_static_bin (xattrs, EC_XATTR_VERSION, zero_array,
-                                 sizeof (zero_array)) ||
-            dict_set_static_bin (xattrs, EC_XATTR_DIRTY, zero_array,
-                                 sizeof (zero_array)) ||
-            dict_set_static_bin (xattrs, EC_XATTR_SIZE, &zero_value,
-                                 sizeof (zero_value))) {
-                ret = -ENOMEM;
-                goto out;
-        }
+__ec_heal_data_prepare(call_frame_t *frame, ec_t *ec, fd_t *fd,
+                       unsigned char *locked_on, uint64_t *versions,
+                       uint64_t *dirty, uint64_t *size, unsigned char *sources,
+                       unsigned char *healed_sinks, unsigned char *trim,
+                       struct iatt *stbuf)
+{
+    default_args_cbk_t *replies = NULL;
+    default_args_cbk_t *fstat_replies = NULL;
+    unsigned char *output = NULL;
+    unsigned char *fstat_output = NULL;
+    dict_t *xattrs = NULL;
+    uint64_t zero_array[2] = {0};
+    int source = 0;
+    int ret = 0;
+    uint64_t zero_value = 0;
+    int i = 0;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    EC_REPLIES_ALLOC(fstat_replies, ec->nodes);
+    output = alloca0(ec->nodes);
+    fstat_output = alloca0(ec->nodes);
+    xattrs = dict_new();
+    if (!xattrs ||
+        dict_set_static_bin(xattrs, EC_XATTR_VERSION, zero_array,
+                            sizeof(zero_array)) ||
+        dict_set_static_bin(xattrs, EC_XATTR_DIRTY, zero_array,
+                            sizeof(zero_array)) ||
+        dict_set_static_bin(xattrs, EC_XATTR_SIZE, &zero_value,
+                            sizeof(zero_value))) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ret = cluster_fxattrop (ec->xl_list, locked_on, ec->nodes,
-                                replies, output, frame, ec->xl, fd,
-                                GF_XATTROP_ADD_ARRAY64, xattrs, NULL);
+    ret = cluster_fxattrop(ec->xl_list, locked_on, ec->nodes, replies, output,
+                           frame, ec->xl, fd, GF_XATTROP_ADD_ARRAY64, xattrs,
+                           NULL);
 
-        ret = cluster_fstat (ec->xl_list, locked_on, ec->nodes, fstat_replies,
-                             fstat_output, frame, ec->xl, fd, NULL);
+    ret = cluster_fstat(ec->xl_list, locked_on, ec->nodes, fstat_replies,
+                        fstat_output, frame, ec->xl, fd, NULL);
 
-        for (i = 0; i < ec->nodes; i++) {
-                output[i] = output[i] && fstat_output[i];
-                replies[i].valid = output[i];
-                if (output[i])
-                        replies[i].stat = fstat_replies[i].stat;
-        }
+    for (i = 0; i < ec->nodes; i++) {
+        output[i] = output[i] && fstat_output[i];
+        replies[i].valid = output[i];
+        if (output[i])
+            replies[i].stat = fstat_replies[i].stat;
+    }
 
-        if (EC_COUNT (output, ec->nodes) <= ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    if (EC_COUNT(output, ec->nodes) <= ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        source = ec_heal_data_find_direction (ec, replies, versions,
-                                              dirty, size, sources,
-                                              healed_sinks, _gf_true,
-                                              EC_COMBINE_DICT);
-        ret = source;
-        if (ret < 0)
-                goto out;
+    source = ec_heal_data_find_direction(ec, replies, versions, dirty, size,
+                                         sources, healed_sinks, _gf_true,
+                                         EC_COMBINE_DICT);
+    ret = source;
+    if (ret < 0)
+        goto out;
 
-        if (stbuf)
-                *stbuf = replies[source].stat;
+    if (stbuf)
+        *stbuf = replies[source].stat;
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (healed_sinks[i]) {
-                        if (replies[i].stat.ia_size)
-                                trim[i] = 1;
-                }
+    for (i = 0; i < ec->nodes; i++) {
+        if (healed_sinks[i]) {
+            if (replies[i].stat.ia_size)
+                trim[i] = 1;
         }
+    }
 
-        if (EC_COUNT(sources, ec->nodes) < ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    if (EC_COUNT(sources, ec->nodes) < ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        ret = source;
+    ret = source;
 out:
-        if (xattrs)
-                dict_unref (xattrs);
-        cluster_replies_wipe (replies, ec->nodes);
-        cluster_replies_wipe (fstat_replies, ec->nodes);
-        if (ret < 0) {
-                gf_msg_debug (ec->xl->name, 0, "%s: heal failed %s",
-                        uuid_utoa (fd->inode->gfid), strerror (-ret));
-        } else {
-                gf_msg_debug (ec->xl->name, 0, "%s: sources: %d, sinks: "
-                        "%d", uuid_utoa (fd->inode->gfid),
-                        EC_COUNT (sources, ec->nodes),
-                        EC_COUNT (healed_sinks, ec->nodes));
-        }
-        return ret;
+    if (xattrs)
+        dict_unref(xattrs);
+    cluster_replies_wipe(replies, ec->nodes);
+    cluster_replies_wipe(fstat_replies, ec->nodes);
+    if (ret < 0) {
+        gf_msg_debug(ec->xl->name, 0, "%s: heal failed %s",
+                     uuid_utoa(fd->inode->gfid), strerror(-ret));
+    } else {
+        gf_msg_debug(ec->xl->name, 0,
+                     "%s: sources: %d, sinks: "
+                     "%d",
+                     uuid_utoa(fd->inode->gfid), EC_COUNT(sources, ec->nodes),
+                     EC_COUNT(healed_sinks, ec->nodes));
+    }
+    return ret;
 }
 
 int
-__ec_heal_mark_sinks (call_frame_t *frame, ec_t *ec, fd_t *fd,
-                      uint64_t *versions, unsigned char *healed_sinks)
-{
-        int                i        = 0;
-        int                ret      = 0;
-        unsigned char      *mark    = NULL;
-        dict_t             *xattrs  = NULL;
-        default_args_cbk_t *replies = NULL;
-        unsigned char      *output  = NULL;
-        uint64_t versions_xattr[2]  = {0};
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        xattrs = dict_new ();
-        if (!xattrs) {
-                ret = -ENOMEM;
-                goto out;
-        }
+__ec_heal_mark_sinks(call_frame_t *frame, ec_t *ec, fd_t *fd,
+                     uint64_t *versions, unsigned char *healed_sinks)
+{
+    int i = 0;
+    int ret = 0;
+    unsigned char *mark = NULL;
+    dict_t *xattrs = NULL;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    uint64_t versions_xattr[2] = {0};
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    xattrs = dict_new();
+    if (!xattrs) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        mark = alloca0 (ec->nodes);
-        for (i = 0; i < ec->nodes; i++) {
-                if (!healed_sinks[i])
-                        continue;
-                if ((versions[i] >> EC_SELFHEAL_BIT) & 1)
-                        continue;
-                mark[i] = 1;
-        }
+    mark = alloca0(ec->nodes);
+    for (i = 0; i < ec->nodes; i++) {
+        if (!healed_sinks[i])
+            continue;
+        if ((versions[i] >> EC_SELFHEAL_BIT) & 1)
+            continue;
+        mark[i] = 1;
+    }
 
-        if (EC_COUNT (mark, ec->nodes) == 0)
-                return 0;
+    if (EC_COUNT(mark, ec->nodes) == 0)
+        return 0;
 
-        versions_xattr[EC_DATA_TXN] = hton64(1ULL<<EC_SELFHEAL_BIT);
-        if (dict_set_static_bin (xattrs, EC_XATTR_VERSION, versions_xattr,
-                                 sizeof (versions_xattr))) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    versions_xattr[EC_DATA_TXN] = hton64(1ULL << EC_SELFHEAL_BIT);
+    if (dict_set_static_bin(xattrs, EC_XATTR_VERSION, versions_xattr,
+                            sizeof(versions_xattr))) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        output = alloca0 (ec->nodes);
-        ret = cluster_fxattrop (ec->xl_list, mark, ec->nodes,
-                                replies, output, frame, ec->xl, fd,
-                                GF_XATTROP_ADD_ARRAY64, xattrs, NULL);
-        for (i = 0; i < ec->nodes; i++) {
-                if (!output[i]) {
-                        if (mark[i])
-                                healed_sinks[i] = 0;
-                        continue;
-                }
-                versions[i] |= (1ULL<<EC_SELFHEAL_BIT);
+    output = alloca0(ec->nodes);
+    ret = cluster_fxattrop(ec->xl_list, mark, ec->nodes, replies, output, frame,
+                           ec->xl, fd, GF_XATTROP_ADD_ARRAY64, xattrs, NULL);
+    for (i = 0; i < ec->nodes; i++) {
+        if (!output[i]) {
+            if (mark[i])
+                healed_sinks[i] = 0;
+            continue;
         }
+        versions[i] |= (1ULL << EC_SELFHEAL_BIT);
+    }
 
-        if (EC_COUNT (healed_sinks, ec->nodes) == 0) {
-                ret = -ENOTCONN;
-                goto out;
-        }
-        ret = 0;
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+        ret = -ENOTCONN;
+        goto out;
+    }
+    ret = 0;
 
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        if (xattrs)
-                dict_unref (xattrs);
-        if (ret < 0)
-                gf_msg_debug (ec->xl->name, 0, "%s: heal failed %s",
-                        uuid_utoa (fd->inode->gfid), strerror (-ret));
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    if (xattrs)
+        dict_unref(xattrs);
+    if (ret < 0)
+        gf_msg_debug(ec->xl->name, 0, "%s: heal failed %s",
+                     uuid_utoa(fd->inode->gfid), strerror(-ret));
+    return ret;
 }
 
 int32_t
-ec_manager_heal_block (ec_fop_data_t *fop, int32_t state)
+ec_manager_heal_block(ec_fop_data_t *fop, int32_t state)
 {
     ec_heal_t *heal = fop->data;
     heal->fop = fop;
 
     switch (state) {
-    case EC_STATE_INIT:
-        ec_owner_set(fop->frame, fop->frame->root);
+        case EC_STATE_INIT:
+            ec_owner_set(fop->frame, fop->frame->root);
 
-        ec_heal_inodelk(heal, F_WRLCK, 1, 0, 0);
+            ec_heal_inodelk(heal, F_WRLCK, 1, 0, 0);
 
-        return EC_STATE_HEAL_DATA_COPY;
+            return EC_STATE_HEAL_DATA_COPY;
 
-    case EC_STATE_HEAL_DATA_COPY:
-        gf_msg_debug (fop->xl->name, 0, "%s: read/write starting",
-                uuid_utoa (heal->fd->inode->gfid));
-        ec_heal_data_block (heal);
+        case EC_STATE_HEAL_DATA_COPY:
+            gf_msg_debug(fop->xl->name, 0, "%s: read/write starting",
+                         uuid_utoa(heal->fd->inode->gfid));
+            ec_heal_data_block(heal);
 
-        return EC_STATE_HEAL_DATA_UNLOCK;
+            return EC_STATE_HEAL_DATA_UNLOCK;
 
-    case -EC_STATE_HEAL_DATA_COPY:
-    case -EC_STATE_HEAL_DATA_UNLOCK:
-    case EC_STATE_HEAL_DATA_UNLOCK:
-        ec_heal_inodelk(heal, F_UNLCK, 1, 0, 0);
+        case -EC_STATE_HEAL_DATA_COPY:
+        case -EC_STATE_HEAL_DATA_UNLOCK:
+        case EC_STATE_HEAL_DATA_UNLOCK:
+            ec_heal_inodelk(heal, F_UNLCK, 1, 0, 0);
 
-         return EC_STATE_REPORT;
+            return EC_STATE_REPORT;
 
-    case EC_STATE_REPORT:
-        if (fop->cbks.heal) {
-            fop->cbks.heal (fop->req_frame, fop, fop->xl, 0,
-                            0, (heal->good | heal->bad),
-                            heal->good, heal->bad, NULL);
-        }
+        case EC_STATE_REPORT:
+            if (fop->cbks.heal) {
+                fop->cbks.heal(fop->req_frame, fop, fop->xl, 0, 0,
+                               (heal->good | heal->bad), heal->good, heal->bad,
+                               NULL);
+            }
 
-        return EC_STATE_END;
-    case -EC_STATE_REPORT:
-        if (fop->cbks.heal) {
-            fop->cbks.heal (fop->req_frame, fop, fop->xl, -1,
-                            fop->error, 0, 0, 0, NULL);
-        }
+            return EC_STATE_END;
+        case -EC_STATE_REPORT:
+            if (fop->cbks.heal) {
+                fop->cbks.heal(fop->req_frame, fop, fop->xl, -1, fop->error, 0,
+                               0, 0, NULL);
+            }
 
-        return EC_STATE_END;
-    default:
-        gf_msg (fop->xl->name, GF_LOG_ERROR, 0,
-                EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                state, ec_fop_name(fop->id));
+            return EC_STATE_END;
+        default:
+            gf_msg(fop->xl->name, GF_LOG_ERROR, 0, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
-        return EC_STATE_END;
+            return EC_STATE_END;
     }
 }
 
 /*Takes lock */
 void
-ec_heal_block (call_frame_t *frame, xlator_t *this, uintptr_t target,
+ec_heal_block(call_frame_t *frame, xlator_t *this, uintptr_t target,
               int32_t minimum, fop_heal_cbk_t func, ec_heal_t *heal)
 {
-    ec_cbk_t callback = { .heal = func };
+    ec_cbk_t callback = {.heal = func};
     ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
@@ -1950,9 +1944,8 @@ ec_heal_block (call_frame_t *frame, xlator_t *this, uintptr_t target,
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate (frame, this, EC_FOP_HEAL, 0, target, minimum,
-                                NULL, ec_manager_heal_block, callback,
-                                heal);
+    fop = ec_fop_data_allocate(frame, this, EC_FOP_HEAL, 0, target, minimum,
+                               NULL, ec_manager_heal_block, callback, heal);
     if (fop == NULL)
         goto out;
 
@@ -1967,761 +1960,751 @@ out:
 }
 
 int32_t
-ec_heal_block_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, uintptr_t mask,
-                    uintptr_t good, uintptr_t bad, dict_t *xdata)
+ec_heal_block_done(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, uintptr_t mask,
+                   uintptr_t good, uintptr_t bad, dict_t *xdata)
 {
-        ec_fop_data_t *fop = cookie;
-        ec_heal_t *heal = fop->data;
+    ec_fop_data_t *fop = cookie;
+    ec_heal_t *heal = fop->data;
 
-        fop->heal = NULL;
-        heal->fop = NULL;
-        heal->error = op_ret < 0 ? op_errno : 0;
-        syncbarrier_wake (heal->data);
-        return 0;
+    fop->heal = NULL;
+    heal->fop = NULL;
+    heal->error = op_ret < 0 ? op_errno : 0;
+    syncbarrier_wake(heal->data);
+    return 0;
 }
 
 int
-ec_sync_heal_block (call_frame_t *frame, xlator_t *this, ec_heal_t *heal)
+ec_sync_heal_block(call_frame_t *frame, xlator_t *this, ec_heal_t *heal)
 {
-        ec_heal_block (frame, this, heal->bad|heal->good, EC_MINIMUM_ONE,
-                       ec_heal_block_done, heal);
-        syncbarrier_wait (heal->data, 1);
-        if (heal->error != 0) {
-                return -heal->error;
-        }
-        if (heal->bad == 0)
-                return -ENOTCONN;
-        return 0;
+    ec_heal_block(frame, this, heal->bad | heal->good, EC_MINIMUM_ONE,
+                  ec_heal_block_done, heal);
+    syncbarrier_wait(heal->data, 1);
+    if (heal->error != 0) {
+        return -heal->error;
+    }
+    if (heal->bad == 0)
+        return -ENOTCONN;
+    return 0;
 }
 
 int
-ec_rebuild_data (call_frame_t *frame, ec_t *ec, fd_t *fd, uint64_t size,
-                 unsigned char *sources, unsigned char *healed_sinks)
+ec_rebuild_data(call_frame_t *frame, ec_t *ec, fd_t *fd, uint64_t size,
+                unsigned char *sources, unsigned char *healed_sinks)
 {
-        ec_heal_t        *heal = NULL;
-        int              ret = 0;
-        syncbarrier_t    barrier;
-
-        if (syncbarrier_init (&barrier))
-                return -ENOMEM;
-
-        heal = alloca0(sizeof (*heal));
-        heal->fd = fd_ref (fd);
-        heal->xl = ec->xl;
-        heal->data = &barrier;
-        ec_adjust_size_up (ec, &size, _gf_false);
-        heal->total_size = size;
-        heal->size = (128 * GF_UNIT_KB * (ec->self_heal_window_size));
-        /* We need to adjust the size to a multiple of the stripe size of the
-         * volume. Otherwise writes would need to fill gaps (head and/or tail)
-         * with existent data from the bad bricks. This could be garbage on a
-         * damaged file or it could fail if there aren't enough bricks. */
-        heal->size -= heal->size % ec->stripe_size;
-        heal->bad       = ec_char_array_to_mask (healed_sinks, ec->nodes);
-        heal->good      = ec_char_array_to_mask (sources, ec->nodes);
-        heal->iatt.ia_type = IA_IFREG;
-        LOCK_INIT(&heal->lock);
-
-        for (heal->offset = 0; (heal->offset < size) && !heal->done;
-                                                   heal->offset += heal->size) {
-                /* We immediately abort any heal if a shutdown request has been
-                 * received to avoid delays. The healing of this file will be
-                 * restarted by another SHD or other client that accesses the
-                 * file. */
-                if (ec->shutdown) {
-                        gf_msg_debug(ec->xl->name, 0, "Cancelling heal because "
-                                                      "EC is stopping.");
-                        ret = -ENOTCONN;
-                        break;
-                }
-
-                gf_msg_debug (ec->xl->name, 0, "%s: sources: %d, sinks: "
-                        "%d, offset: %"PRIu64" bsize: %"PRIu64,
-                        uuid_utoa (fd->inode->gfid),
-                        EC_COUNT (sources, ec->nodes),
-                        EC_COUNT (healed_sinks, ec->nodes), heal->offset,
-                        heal->size);
-                ret = ec_sync_heal_block (frame, ec->xl, heal);
-                if (ret < 0)
-                        break;
-
-        }
-        memset (healed_sinks, 0, ec->nodes);
-        ec_mask_to_char_array (heal->bad, healed_sinks, ec->nodes);
-        fd_unref (heal->fd);
-        LOCK_DESTROY (&heal->lock);
-        syncbarrier_destroy (heal->data);
+    ec_heal_t *heal = NULL;
+    int ret = 0;
+    syncbarrier_t barrier;
+
+    if (syncbarrier_init(&barrier))
+        return -ENOMEM;
+
+    heal = alloca0(sizeof(*heal));
+    heal->fd = fd_ref(fd);
+    heal->xl = ec->xl;
+    heal->data = &barrier;
+    ec_adjust_size_up(ec, &size, _gf_false);
+    heal->total_size = size;
+    heal->size = (128 * GF_UNIT_KB * (ec->self_heal_window_size));
+    /* We need to adjust the size to a multiple of the stripe size of the
+     * volume. Otherwise writes would need to fill gaps (head and/or tail)
+     * with existent data from the bad bricks. This could be garbage on a
+     * damaged file or it could fail if there aren't enough bricks. */
+    heal->size -= heal->size % ec->stripe_size;
+    heal->bad = ec_char_array_to_mask(healed_sinks, ec->nodes);
+    heal->good = ec_char_array_to_mask(sources, ec->nodes);
+    heal->iatt.ia_type = IA_IFREG;
+    LOCK_INIT(&heal->lock);
+
+    for (heal->offset = 0; (heal->offset < size) && !heal->done;
+         heal->offset += heal->size) {
+        /* We immediately abort any heal if a shutdown request has been
+         * received to avoid delays. The healing of this file will be
+         * restarted by another SHD or other client that accesses the
+         * file. */
+        if (ec->shutdown) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "Cancelling heal because "
+                         "EC is stopping.");
+            ret = -ENOTCONN;
+            break;
+        }
+
+        gf_msg_debug(ec->xl->name, 0,
+                     "%s: sources: %d, sinks: "
+                     "%d, offset: %" PRIu64 " bsize: %" PRIu64,
+                     uuid_utoa(fd->inode->gfid), EC_COUNT(sources, ec->nodes),
+                     EC_COUNT(healed_sinks, ec->nodes), heal->offset,
+                     heal->size);
+        ret = ec_sync_heal_block(frame, ec->xl, heal);
         if (ret < 0)
-                gf_msg_debug (ec->xl->name, 0, "%s: heal failed %s",
-                        uuid_utoa (fd->inode->gfid), strerror (-ret));
-        return ret;
+            break;
+    }
+    memset(healed_sinks, 0, ec->nodes);
+    ec_mask_to_char_array(heal->bad, healed_sinks, ec->nodes);
+    fd_unref(heal->fd);
+    LOCK_DESTROY(&heal->lock);
+    syncbarrier_destroy(heal->data);
+    if (ret < 0)
+        gf_msg_debug(ec->xl->name, 0, "%s: heal failed %s",
+                     uuid_utoa(fd->inode->gfid), strerror(-ret));
+    return ret;
 }
 
 int
-__ec_heal_trim_sinks (call_frame_t *frame, ec_t *ec,
-                      fd_t *fd, unsigned char *healed_sinks,
-                      unsigned char *trim, uint64_t size)
+__ec_heal_trim_sinks(call_frame_t *frame, ec_t *ec, fd_t *fd,
+                     unsigned char *healed_sinks, unsigned char *trim,
+                     uint64_t size)
 {
-        default_args_cbk_t *replies = NULL;
-        unsigned char      *output  = NULL;
-        int                ret      = 0;
-        int                i        = 0;
-        off_t        trim_offset    = 0;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *output = NULL;
+    int ret = 0;
+    int i = 0;
+    off_t trim_offset = 0;
 
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        output       = alloca0 (ec->nodes);
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    output = alloca0(ec->nodes);
 
-        if (EC_COUNT (trim, ec->nodes) == 0) {
-                ret = 0;
-                goto out;
-        }
-        trim_offset = size;
-        ec_adjust_offset_up (ec, &trim_offset, _gf_true);
-        ret = cluster_ftruncate (ec->xl_list, trim, ec->nodes, replies, output,
-                                 frame, ec->xl, fd, trim_offset, NULL);
-        for (i = 0; i < ec->nodes; i++) {
-                if (!output[i] && trim[i])
-                        healed_sinks[i] = 0;
-        }
+    if (EC_COUNT(trim, ec->nodes) == 0) {
+        ret = 0;
+        goto out;
+    }
+    trim_offset = size;
+    ec_adjust_offset_up(ec, &trim_offset, _gf_true);
+    ret = cluster_ftruncate(ec->xl_list, trim, ec->nodes, replies, output,
+                            frame, ec->xl, fd, trim_offset, NULL);
+    for (i = 0; i < ec->nodes; i++) {
+        if (!output[i] && trim[i])
+            healed_sinks[i] = 0;
+    }
 
-        if (EC_COUNT (healed_sinks, ec->nodes) == 0) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        if (ret < 0)
-                gf_msg_debug (ec->xl->name, 0, "%s: heal failed %s",
-                        uuid_utoa (fd->inode->gfid), strerror (-ret));
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    if (ret < 0)
+        gf_msg_debug(ec->xl->name, 0, "%s: heal failed %s",
+                     uuid_utoa(fd->inode->gfid), strerror(-ret));
+    return ret;
 }
 
 int
-ec_data_undo_pending (call_frame_t *frame, ec_t *ec, fd_t *fd, dict_t *xattr,
-                      uint64_t *versions, uint64_t *dirty, uint64_t *size,
-                      int source, gf_boolean_t erase_dirty, int idx)
-{
-        uint64_t versions_xattr[2] = {0};
-        uint64_t dirty_xattr[2]    = {0};
-        uint64_t allzero[2]        = {0};
-        uint64_t size_xattr        = 0;
-        int      ret               = 0;
-
-        versions_xattr[EC_DATA_TXN] = hton64(versions[source] - versions[idx]);
-        ret = dict_set_static_bin (xattr, EC_XATTR_VERSION,
-                                   versions_xattr,
-                                   sizeof (versions_xattr));
-        if (ret < 0)
-                goto out;
+ec_data_undo_pending(call_frame_t *frame, ec_t *ec, fd_t *fd, dict_t *xattr,
+                     uint64_t *versions, uint64_t *dirty, uint64_t *size,
+                     int source, gf_boolean_t erase_dirty, int idx)
+{
+    uint64_t versions_xattr[2] = {0};
+    uint64_t dirty_xattr[2] = {0};
+    uint64_t allzero[2] = {0};
+    uint64_t size_xattr = 0;
+    int ret = 0;
+
+    versions_xattr[EC_DATA_TXN] = hton64(versions[source] - versions[idx]);
+    ret = dict_set_static_bin(xattr, EC_XATTR_VERSION, versions_xattr,
+                              sizeof(versions_xattr));
+    if (ret < 0)
+        goto out;
 
-        size_xattr = hton64(size[source] - size[idx]);
-        ret = dict_set_static_bin (xattr, EC_XATTR_SIZE,
-                                   &size_xattr, sizeof (size_xattr));
-        if (ret < 0)
-                goto out;
+    size_xattr = hton64(size[source] - size[idx]);
+    ret = dict_set_static_bin(xattr, EC_XATTR_SIZE, &size_xattr,
+                              sizeof(size_xattr));
+    if (ret < 0)
+        goto out;
 
-        if (erase_dirty) {
-                dirty_xattr[EC_DATA_TXN] = hton64(-dirty[idx]);
-                ret = dict_set_static_bin (xattr, EC_XATTR_DIRTY,
-                                           dirty_xattr,
-                                           sizeof (dirty_xattr));
-                if (ret < 0)
-                        goto out;
-        }
+    if (erase_dirty) {
+        dirty_xattr[EC_DATA_TXN] = hton64(-dirty[idx]);
+        ret = dict_set_static_bin(xattr, EC_XATTR_DIRTY, dirty_xattr,
+                                  sizeof(dirty_xattr));
+        if (ret < 0)
+            goto out;
+    }
 
-        if ((memcmp (versions_xattr, allzero, sizeof (allzero)) == 0) &&
-            (memcmp (dirty_xattr, allzero, sizeof (allzero)) == 0) &&
-             (size_xattr == 0)) {
-                ret = 0;
-                goto out;
-        }
+    if ((memcmp(versions_xattr, allzero, sizeof(allzero)) == 0) &&
+        (memcmp(dirty_xattr, allzero, sizeof(allzero)) == 0) &&
+        (size_xattr == 0)) {
+        ret = 0;
+        goto out;
+    }
 
-        ret = syncop_fxattrop (ec->xl_list[idx], fd,
-                               GF_XATTROP_ADD_ARRAY64, xattr, NULL, NULL, NULL);
+    ret = syncop_fxattrop(ec->xl_list[idx], fd, GF_XATTROP_ADD_ARRAY64, xattr,
+                          NULL, NULL, NULL);
 out:
-        return ret;
+    return ret;
 }
 
 int
-__ec_fd_data_adjust_versions (call_frame_t *frame, ec_t *ec, fd_t *fd,
-                            unsigned char *sources, unsigned char *healed_sinks,
-                            uint64_t *versions, uint64_t *dirty, uint64_t *size)
-{
-        dict_t                     *xattr            = NULL;
-        int                        i                 = 0;
-        int                        ret               = 0;
-        int                        op_ret            = 0;
-        int                        source            = -1;
-        gf_boolean_t               erase_dirty       = _gf_false;
-
-        xattr = dict_new ();
-        if (!xattr) {
-                op_ret = -ENOMEM;
-                goto out;
-        }
-
-        /* dirty xattr represents if the file needs heal. Unless all the
-         * copies are healed, don't erase it */
-        if (EC_COUNT (sources, ec->nodes) +
-            EC_COUNT (healed_sinks, ec->nodes) == ec->nodes)
-                erase_dirty = _gf_true;
+__ec_fd_data_adjust_versions(call_frame_t *frame, ec_t *ec, fd_t *fd,
+                             unsigned char *sources,
+                             unsigned char *healed_sinks, uint64_t *versions,
+                             uint64_t *dirty, uint64_t *size)
+{
+    dict_t *xattr = NULL;
+    int i = 0;
+    int ret = 0;
+    int op_ret = 0;
+    int source = -1;
+    gf_boolean_t erase_dirty = _gf_false;
+
+    xattr = dict_new();
+    if (!xattr) {
+        op_ret = -ENOMEM;
+        goto out;
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (sources[i]) {
-                        source = i;
-                        break;
-                }
-        }
+    /* dirty xattr represents if the file needs heal. Unless all the
+     * copies are healed, don't erase it */
+    if (EC_COUNT(sources, ec->nodes) + EC_COUNT(healed_sinks, ec->nodes) ==
+        ec->nodes)
+        erase_dirty = _gf_true;
 
-        if (source == -1) {
-                op_ret = -ENOTCONN;
-                goto out;
+    for (i = 0; i < ec->nodes; i++) {
+        if (sources[i]) {
+            source = i;
+            break;
         }
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (healed_sinks[i]) {
-                        ret = ec_data_undo_pending (frame, ec, fd, xattr,
-                                                    versions, dirty, size,
-                                                    source, erase_dirty, i);
-                        if (ret < 0)
-                                goto out;
-                }
-
-        }
+    if (source == -1) {
+        op_ret = -ENOTCONN;
+        goto out;
+    }
 
-        if (!erase_dirty)
+    for (i = 0; i < ec->nodes; i++) {
+        if (healed_sinks[i]) {
+            ret = ec_data_undo_pending(frame, ec, fd, xattr, versions, dirty,
+                                       size, source, erase_dirty, i);
+            if (ret < 0)
                 goto out;
+        }
+    }
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (sources[i]) {
-                        ret = ec_data_undo_pending (frame, ec, fd, xattr,
-                                                    versions, dirty, size,
-                                                    source, erase_dirty, i);
-                        if (ret < 0)
-                                continue;
-                }
+    if (!erase_dirty)
+        goto out;
 
+    for (i = 0; i < ec->nodes; i++) {
+        if (sources[i]) {
+            ret = ec_data_undo_pending(frame, ec, fd, xattr, versions, dirty,
+                                       size, source, erase_dirty, i);
+            if (ret < 0)
+                continue;
         }
+    }
 out:
-        if (xattr)
-                dict_unref (xattr);
-        return op_ret;
+    if (xattr)
+        dict_unref(xattr);
+    return op_ret;
 }
 
 int
-ec_restore_time_and_adjust_versions (call_frame_t *frame, ec_t *ec, fd_t *fd,
-                                     unsigned char *sources,
-                                     unsigned char *healed_sinks,
-                                     uint64_t *versions, uint64_t *dirty,
-                                     uint64_t *size)
-{
-        unsigned char      *locked_on           = NULL;
-        unsigned char      *participants        = NULL;
-        unsigned char      *output              = NULL;
-        default_args_cbk_t *replies             = NULL;
-        unsigned char      *postsh_sources      = NULL;
-        unsigned char      *postsh_healed_sinks = NULL;
-        unsigned char      *postsh_trim         = NULL;
-        uint64_t           *postsh_versions     = NULL;
-        uint64_t           *postsh_dirty        = NULL;
-        uint64_t           *postsh_size         = NULL;
-        int                ret                  = 0;
-        int                i                    = 0;
-        struct iatt        source_buf           = {0};
-        loc_t              loc                  = {0};
-
-        locked_on           = alloca0(ec->nodes);
-        output              = alloca0(ec->nodes);
-        participants        = alloca0(ec->nodes);
-        postsh_sources      = alloca0(ec->nodes);
-        postsh_healed_sinks = alloca0(ec->nodes);
-        postsh_trim         = alloca0(ec->nodes);
-        postsh_versions     = alloca0(ec->nodes * sizeof (*postsh_versions));
-        postsh_dirty        = alloca0(ec->nodes * sizeof (*postsh_dirty));
-        postsh_size         = alloca0(ec->nodes * sizeof (*postsh_size));
-
-        for (i = 0; i < ec->nodes; i++) {
-                if (healed_sinks[i] || sources[i])
-                        participants[i] = 1;
-        }
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        ret = cluster_inodelk (ec->xl_list, participants, ec->nodes, replies,
-                               locked_on, frame, ec->xl, ec->xl->name,
-                               fd->inode, 0, 0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (fd->inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
+ec_restore_time_and_adjust_versions(call_frame_t *frame, ec_t *ec, fd_t *fd,
+                                    unsigned char *sources,
+                                    unsigned char *healed_sinks,
+                                    uint64_t *versions, uint64_t *dirty,
+                                    uint64_t *size)
+{
+    unsigned char *locked_on = NULL;
+    unsigned char *participants = NULL;
+    unsigned char *output = NULL;
+    default_args_cbk_t *replies = NULL;
+    unsigned char *postsh_sources = NULL;
+    unsigned char *postsh_healed_sinks = NULL;
+    unsigned char *postsh_trim = NULL;
+    uint64_t *postsh_versions = NULL;
+    uint64_t *postsh_dirty = NULL;
+    uint64_t *postsh_size = NULL;
+    int ret = 0;
+    int i = 0;
+    struct iatt source_buf = {0};
+    loc_t loc = {0};
+
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    participants = alloca0(ec->nodes);
+    postsh_sources = alloca0(ec->nodes);
+    postsh_healed_sinks = alloca0(ec->nodes);
+    postsh_trim = alloca0(ec->nodes);
+    postsh_versions = alloca0(ec->nodes * sizeof(*postsh_versions));
+    postsh_dirty = alloca0(ec->nodes * sizeof(*postsh_dirty));
+    postsh_size = alloca0(ec->nodes * sizeof(*postsh_size));
+
+    for (i = 0; i < ec->nodes; i++) {
+        if (healed_sinks[i] || sources[i])
+            participants[i] = 1;
+    }
 
-                ret = __ec_heal_data_prepare (frame, ec, fd, locked_on,
-                                              postsh_versions, postsh_dirty,
-                                              postsh_size, postsh_sources,
-                                              postsh_healed_sinks, postsh_trim,
-                                              &source_buf);
-                if (ret < 0)
-                        goto unlock;
-
-                loc.inode = inode_ref (fd->inode);
-                gf_uuid_copy (loc.gfid, fd->inode->gfid);
-                ret = cluster_setattr (ec->xl_list, healed_sinks, ec->nodes,
-                                       replies, output, frame, ec->xl, &loc,
-                                       &source_buf,
-                                       GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME,
-                                       NULL);
-                EC_INTERSECT (healed_sinks, healed_sinks, output, ec->nodes);
-                if (EC_COUNT (healed_sinks, ec->nodes) == 0) {
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                ret = __ec_fd_data_adjust_versions (frame, ec, fd, sources,
-                                           healed_sinks, versions, dirty, size);
-        }
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    ret = cluster_inodelk(ec->xl_list, participants, ec->nodes, replies,
+                          locked_on, frame, ec->xl, ec->xl->name, fd->inode, 0,
+                          0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+
+        ret = __ec_heal_data_prepare(frame, ec, fd, locked_on, postsh_versions,
+                                     postsh_dirty, postsh_size, postsh_sources,
+                                     postsh_healed_sinks, postsh_trim,
+                                     &source_buf);
+        if (ret < 0)
+            goto unlock;
+
+        loc.inode = inode_ref(fd->inode);
+        gf_uuid_copy(loc.gfid, fd->inode->gfid);
+        ret = cluster_setattr(ec->xl_list, healed_sinks, ec->nodes, replies,
+                              output, frame, ec->xl, &loc, &source_buf,
+                              GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME, NULL);
+        EC_INTERSECT(healed_sinks, healed_sinks, output, ec->nodes);
+        if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        ret = __ec_fd_data_adjust_versions(frame, ec, fd, sources, healed_sinks,
+                                           versions, dirty, size);
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, ec->xl->name, fd->inode, 0, 0);
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        return ret;
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, fd->inode, 0, 0);
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-__ec_heal_data (call_frame_t *frame, ec_t *ec, fd_t *fd, unsigned char *heal_on,
-                unsigned char *sources, unsigned char *healed_sinks)
+__ec_heal_data(call_frame_t *frame, ec_t *ec, fd_t *fd, unsigned char *heal_on,
+               unsigned char *sources, unsigned char *healed_sinks)
 {
-        unsigned char      *locked_on    = NULL;
-        unsigned char      *output       = NULL;
-        uint64_t           *versions     = NULL;
-        uint64_t           *dirty        = NULL;
-        uint64_t           *size         = NULL;
-        unsigned char      *trim         = NULL;
-        default_args_cbk_t *replies      = NULL;
-        int                ret           = 0;
-        int                source        = 0;
-
-        locked_on    = alloca0(ec->nodes);
-        output       = alloca0(ec->nodes);
-        trim         = alloca0 (ec->nodes);
-        versions     = alloca0 (ec->nodes * sizeof (*versions));
-        dirty        = alloca0 (ec->nodes * sizeof (*dirty));
-        size         = alloca0 (ec->nodes * sizeof (*size));
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        ret = cluster_inodelk (ec->xl_list, heal_on, ec->nodes, replies,
-                               locked_on, frame, ec->xl, ec->xl->name,
-                               fd->inode, 0, 0);
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (fd->inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-
-                ret = __ec_heal_data_prepare (frame, ec, fd, locked_on,
-                                              versions, dirty, size, sources,
-                                              healed_sinks, trim, NULL);
-                if (ret < 0)
-                        goto unlock;
-
-                if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
-                        ret = __ec_fd_data_adjust_versions (frame, ec, fd,
-                                                            sources,
-                                        healed_sinks, versions, dirty, size);
-                        goto unlock;
-                }
+    unsigned char *locked_on = NULL;
+    unsigned char *output = NULL;
+    uint64_t *versions = NULL;
+    uint64_t *dirty = NULL;
+    uint64_t *size = NULL;
+    unsigned char *trim = NULL;
+    default_args_cbk_t *replies = NULL;
+    int ret = 0;
+    int source = 0;
+
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    trim = alloca0(ec->nodes);
+    versions = alloca0(ec->nodes * sizeof(*versions));
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+    size = alloca0(ec->nodes * sizeof(*size));
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    ret = cluster_inodelk(ec->xl_list, heal_on, ec->nodes, replies, locked_on,
+                          frame, ec->xl, ec->xl->name, fd->inode, 0, 0);
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(fd->inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
 
-                source = ret;
-                ret = __ec_heal_mark_sinks (frame, ec, fd, versions,
-                                            healed_sinks);
-                if (ret < 0)
-                        goto unlock;
+        ret = __ec_heal_data_prepare(frame, ec, fd, locked_on, versions, dirty,
+                                     size, sources, healed_sinks, trim, NULL);
+        if (ret < 0)
+            goto unlock;
 
-                ret = __ec_heal_trim_sinks (frame, ec, fd, healed_sinks,
-                                            trim, size[source]);
+        if (EC_COUNT(healed_sinks, ec->nodes) == 0) {
+            ret = __ec_fd_data_adjust_versions(
+                frame, ec, fd, sources, healed_sinks, versions, dirty, size);
+            goto unlock;
         }
-unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, ec->xl->name, fd->inode, 0, 0);
+
+        source = ret;
+        ret = __ec_heal_mark_sinks(frame, ec, fd, versions, healed_sinks);
         if (ret < 0)
-                goto out;
+            goto unlock;
 
-        if (EC_COUNT(healed_sinks, ec->nodes) == 0)
-                goto out;
+        ret = __ec_heal_trim_sinks(frame, ec, fd, healed_sinks, trim,
+                                   size[source]);
+    }
+unlock:
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, fd->inode, 0, 0);
+    if (ret < 0)
+        goto out;
 
-        gf_msg_debug (ec->xl->name, 0, "%s: sources: %d, sinks: "
-                "%d", uuid_utoa (fd->inode->gfid),
-                EC_COUNT (sources, ec->nodes),
-                EC_COUNT (healed_sinks, ec->nodes));
+    if (EC_COUNT(healed_sinks, ec->nodes) == 0)
+        goto out;
 
-        ret = ec_rebuild_data (frame, ec, fd, size[source], sources,
-                               healed_sinks);
-        if (ret < 0)
-                goto out;
+    gf_msg_debug(ec->xl->name, 0,
+                 "%s: sources: %d, sinks: "
+                 "%d",
+                 uuid_utoa(fd->inode->gfid), EC_COUNT(sources, ec->nodes),
+                 EC_COUNT(healed_sinks, ec->nodes));
+
+    ret = ec_rebuild_data(frame, ec, fd, size[source], sources, healed_sinks);
+    if (ret < 0)
+        goto out;
 
-        ret = ec_restore_time_and_adjust_versions (frame, ec, fd, sources,
-                                                   healed_sinks, versions,
-                                                   dirty, size);
+    ret = ec_restore_time_and_adjust_versions(
+        frame, ec, fd, sources, healed_sinks, versions, dirty, size);
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 int
-ec_heal_data (call_frame_t *frame, ec_t *ec, gf_boolean_t block, inode_t *inode,
-              unsigned char *sources, unsigned char *healed_sinks)
-{
-        unsigned char      *locked_on            = NULL;
-        unsigned char      *up_subvols           = NULL;
-        unsigned char      *output               = NULL;
-        default_args_cbk_t *replies              = NULL;
-        fd_t               *fd                   = NULL;
-        loc_t               loc                  = {0};
-        char               selfheal_domain[1024] = {0};
-        int                ret                   = 0;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-
-        locked_on  = alloca0(ec->nodes);
-        output     = alloca0(ec->nodes);
-        up_subvols = alloca0(ec->nodes);
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-
-        fd = fd_create (inode, 0);
-        if (!fd) {
-                ret = -ENOMEM;
-                goto out;
-        }
+ec_heal_data(call_frame_t *frame, ec_t *ec, gf_boolean_t block, inode_t *inode,
+             unsigned char *sources, unsigned char *healed_sinks)
+{
+    unsigned char *locked_on = NULL;
+    unsigned char *up_subvols = NULL;
+    unsigned char *output = NULL;
+    default_args_cbk_t *replies = NULL;
+    fd_t *fd = NULL;
+    loc_t loc = {0};
+    char selfheal_domain[1024] = {0};
+    int ret = 0;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    up_subvols = alloca0(ec->nodes);
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    fd = fd_create(inode, 0);
+    if (!fd) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
 
-        ret = cluster_open (ec->xl_list, up_subvols, ec->nodes, replies, output,
-                            frame, ec->xl, &loc, O_RDWR|O_LARGEFILE, fd, NULL);
-        if (ret <= ec->fragments) {
-                ret = -ENOTCONN;
-                goto out;
-        }
+    ret = cluster_open(ec->xl_list, up_subvols, ec->nodes, replies, output,
+                       frame, ec->xl, &loc, O_RDWR | O_LARGEFILE, fd, NULL);
+    if (ret <= ec->fragments) {
+        ret = -ENOTCONN;
+        goto out;
+    }
 
-        fd_bind (fd);
-        sprintf (selfheal_domain, "%s:self-heal", ec->xl->name);
-        /*If other processes are already doing the heal, don't block*/
-        if (block) {
-                ret = cluster_inodelk (ec->xl_list, output, ec->nodes, replies,
-                                       locked_on, frame, ec->xl,
-                                       selfheal_domain, inode, 0, 0);
-        } else {
-                ret = cluster_tiebreaker_inodelk (ec->xl_list, output,
-                                                  ec->nodes, replies, locked_on,
-                                                  frame, ec->xl,
-                                                  selfheal_domain, inode, 0, 0);
-        }
-        {
-                if (ret <= ec->fragments) {
-                        gf_msg_debug (ec->xl->name, 0, "%s: Skipping heal "
-                                "as only %d number of subvolumes could "
-                                "be locked", uuid_utoa (inode->gfid), ret);
-                        ret = -ENOTCONN;
-                        goto unlock;
-                }
-                ret = __ec_heal_data (frame, ec, fd, locked_on, sources,
-                                      healed_sinks);
-        }
+    fd_bind(fd);
+    sprintf(selfheal_domain, "%s:self-heal", ec->xl->name);
+    /*If other processes are already doing the heal, don't block*/
+    if (block) {
+        ret = cluster_inodelk(ec->xl_list, output, ec->nodes, replies,
+                              locked_on, frame, ec->xl, selfheal_domain, inode,
+                              0, 0);
+    } else {
+        ret = cluster_tiebreaker_inodelk(ec->xl_list, output, ec->nodes,
+                                         replies, locked_on, frame, ec->xl,
+                                         selfheal_domain, inode, 0, 0);
+    }
+    {
+        if (ret <= ec->fragments) {
+            gf_msg_debug(ec->xl->name, 0,
+                         "%s: Skipping heal "
+                         "as only %d number of subvolumes could "
+                         "be locked",
+                         uuid_utoa(inode->gfid), ret);
+            ret = -ENOTCONN;
+            goto unlock;
+        }
+        ret = __ec_heal_data(frame, ec, fd, locked_on, sources, healed_sinks);
+    }
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes, replies, output,
-                           frame, ec->xl, selfheal_domain, inode, 0, 0);
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, selfheal_domain, inode, 0, 0);
 out:
-        if (fd)
-                fd_unref (fd);
-        loc_wipe (&loc);
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    if (fd)
+        fd_unref(fd);
+    loc_wipe(&loc);
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 void
-ec_heal_do (xlator_t *this, void *data, loc_t *loc, int32_t partial)
-{
-        call_frame_t  *frame         = NULL;
-        unsigned char *participants  = NULL;
-        unsigned char *msources      = NULL;
-        unsigned char *mhealed_sinks = NULL;
-        unsigned char *sources       = NULL;
-        unsigned char *healed_sinks  = NULL;
-        ec_t          *ec            = NULL;
-        int           ret            = 0;
-        int           op_ret         = 0;
-        int           op_errno       = 0;
-        intptr_t      mgood          = 0;
-        intptr_t      mbad           = 0;
-        intptr_t      good           = 0;
-        intptr_t      bad            = 0;
-        ec_fop_data_t *fop           = data;
-        gf_boolean_t  blocking       = _gf_false;
-        ec_heal_need_t  need_heal    = EC_HEAL_NONEED;
-        unsigned char *up_subvols    = NULL;
-        char up_bricks[32];
-
-        ec = this->private;
-
-        /* If it is heal request from getxattr, complete the heal and then
-         * unwind, if it is ec_heal with NULL as frame then no need to block
-         * the heal as the caller doesn't care about its completion. In case
-         * of heald whichever gets tiebreaking inodelk will take care of the
-         * heal, so no need to block*/
-        if (fop->req_frame && !ec->shd.iamshd)
-                blocking = _gf_true;
-
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame)
-                goto out;
+ec_heal_do(xlator_t *this, void *data, loc_t *loc, int32_t partial)
+{
+    call_frame_t *frame = NULL;
+    unsigned char *participants = NULL;
+    unsigned char *msources = NULL;
+    unsigned char *mhealed_sinks = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *healed_sinks = NULL;
+    ec_t *ec = NULL;
+    int ret = 0;
+    int op_ret = 0;
+    int op_errno = 0;
+    intptr_t mgood = 0;
+    intptr_t mbad = 0;
+    intptr_t good = 0;
+    intptr_t bad = 0;
+    ec_fop_data_t *fop = data;
+    gf_boolean_t blocking = _gf_false;
+    ec_heal_need_t need_heal = EC_HEAL_NONEED;
+    unsigned char *up_subvols = NULL;
+    char up_bricks[32];
+
+    ec = this->private;
+
+    /* If it is heal request from getxattr, complete the heal and then
+     * unwind, if it is ec_heal with NULL as frame then no need to block
+     * the heal as the caller doesn't care about its completion. In case
+     * of heald whichever gets tiebreaking inodelk will take care of the
+     * heal, so no need to block*/
+    if (fop->req_frame && !ec->shd.iamshd)
+        blocking = _gf_true;
+
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame)
+        goto out;
 
-        ec_owner_set(frame, frame->root);
-        /*Do heal as root*/
-        frame->root->uid = 0;
-        frame->root->gid = 0;
-        /*Mark the fops as internal*/
-        frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-        participants = alloca0(ec->nodes);
-        ec_mask_to_char_array (ec->xl_up, participants, ec->nodes);
-
-        up_subvols = alloca0(ec->nodes);
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
-
-        if (loc->name && strlen (loc->name)) {
-                ret = ec_heal_name (frame, ec, loc->parent, (char *)loc->name,
-                                    participants);
-                if (ret == 0) {
-                        gf_msg_debug (this->name, 0, "%s: name heal "
-                                "successful on %lX", loc->path,
-                                ec_char_array_to_mask (participants,
-                                    ec->nodes));
-                } else {
-                        gf_msg_debug (this->name, 0, "%s: name heal "
-                                "failed. ret = %d, subvolumes up = %s",
-                                loc->path, ret,
-                                ec_bin(up_bricks, sizeof(up_bricks), ec->xl_up,
-                                ec->nodes));
-                }
+    ec_owner_set(frame, frame->root);
+    /*Do heal as root*/
+    frame->root->uid = 0;
+    frame->root->gid = 0;
+    /*Mark the fops as internal*/
+    frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
+    participants = alloca0(ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, participants, ec->nodes);
+
+    up_subvols = alloca0(ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
+
+    if (loc->name && strlen(loc->name)) {
+        ret = ec_heal_name(frame, ec, loc->parent, (char *)loc->name,
+                           participants);
+        if (ret == 0) {
+            gf_msg_debug(this->name, 0,
+                         "%s: name heal "
+                         "successful on %lX",
+                         loc->path,
+                         ec_char_array_to_mask(participants, ec->nodes));
+        } else {
+            gf_msg_debug(
+                this->name, 0,
+                "%s: name heal "
+                "failed. ret = %d, subvolumes up = %s",
+                loc->path, ret,
+                ec_bin(up_bricks, sizeof(up_bricks), ec->xl_up, ec->nodes));
         }
+    }
 
-        /* Mount triggers heal only when it detects that it must need heal, shd
-         * triggers heals periodically which need not be thorough*/
-        ec_heal_inspect (frame, ec, loc->inode, up_subvols, _gf_false,
-                         !ec->shd.iamshd, &need_heal);
+    /* Mount triggers heal only when it detects that it must need heal, shd
+     * triggers heals periodically which need not be thorough*/
+    ec_heal_inspect(frame, ec, loc->inode, up_subvols, _gf_false,
+                    !ec->shd.iamshd, &need_heal);
 
-        if (need_heal == EC_HEAL_NONEED)  {
-                gf_msg (ec->xl->name, GF_LOG_DEBUG, 0,
-                        EC_MSG_HEAL_FAIL, "Heal is not required for : %s ",
-                        uuid_utoa(loc->gfid));
-                goto out;
-        }
+    if (need_heal == EC_HEAL_NONEED) {
+        gf_msg(ec->xl->name, GF_LOG_DEBUG, 0, EC_MSG_HEAL_FAIL,
+               "Heal is not required for : %s ", uuid_utoa(loc->gfid));
+        goto out;
+    }
 
-        msources = alloca0(ec->nodes);
-        mhealed_sinks = alloca0(ec->nodes);
-        ret = ec_heal_metadata (frame, ec, loc->inode, msources, mhealed_sinks);
-        if (ret == 0) {
-                mgood = ec_char_array_to_mask (msources, ec->nodes);
-                mbad  = ec_char_array_to_mask (mhealed_sinks, ec->nodes);
-        } else {
-                op_ret = -1;
-                op_errno = -ret;
-        }
-        sources = alloca0(ec->nodes);
-        healed_sinks = alloca0(ec->nodes);
-        if (IA_ISREG (loc->inode->ia_type)) {
-                ret = ec_heal_data (frame, ec, blocking, loc->inode, sources,
-                                    healed_sinks);
-        } else if (IA_ISDIR (loc->inode->ia_type) && !partial) {
-                ret = ec_heal_entry (frame, ec, loc->inode, sources,
-                                     healed_sinks);
-        } else {
-                ret = 0;
-                memcpy (sources, participants, ec->nodes);
-                memcpy (healed_sinks, participants, ec->nodes);
-        }
+    msources = alloca0(ec->nodes);
+    mhealed_sinks = alloca0(ec->nodes);
+    ret = ec_heal_metadata(frame, ec, loc->inode, msources, mhealed_sinks);
+    if (ret == 0) {
+        mgood = ec_char_array_to_mask(msources, ec->nodes);
+        mbad = ec_char_array_to_mask(mhealed_sinks, ec->nodes);
+    } else {
+        op_ret = -1;
+        op_errno = -ret;
+    }
+    sources = alloca0(ec->nodes);
+    healed_sinks = alloca0(ec->nodes);
+    if (IA_ISREG(loc->inode->ia_type)) {
+        ret = ec_heal_data(frame, ec, blocking, loc->inode, sources,
+                           healed_sinks);
+    } else if (IA_ISDIR(loc->inode->ia_type) && !partial) {
+        ret = ec_heal_entry(frame, ec, loc->inode, sources, healed_sinks);
+    } else {
+        ret = 0;
+        memcpy(sources, participants, ec->nodes);
+        memcpy(healed_sinks, participants, ec->nodes);
+    }
 
-        if (ret == 0) {
-                good = ec_char_array_to_mask (sources, ec->nodes);
-                bad  = ec_char_array_to_mask (healed_sinks, ec->nodes);
-        } else {
-                op_ret = -1;
-                op_errno = -ret;
-        }
+    if (ret == 0) {
+        good = ec_char_array_to_mask(sources, ec->nodes);
+        bad = ec_char_array_to_mask(healed_sinks, ec->nodes);
+    } else {
+        op_ret = -1;
+        op_errno = -ret;
+    }
 
 out:
-        if (fop->cbks.heal) {
-                fop->cbks.heal (fop->req_frame, fop, fop->xl, op_ret,
-                                op_errno, ec_char_array_to_mask (participants,
-                                                                 ec->nodes),
-                                mgood & good, mbad & bad, NULL);
-        }
-        if (frame)
-                STACK_DESTROY (frame->root);
-        return;
+    if (fop->cbks.heal) {
+        fop->cbks.heal(fop->req_frame, fop, fop->xl, op_ret, op_errno,
+                       ec_char_array_to_mask(participants, ec->nodes),
+                       mgood & good, mbad & bad, NULL);
+    }
+    if (frame)
+        STACK_DESTROY(frame->root);
+    return;
 }
 
 int
-ec_synctask_heal_wrap (void *opaque)
+ec_synctask_heal_wrap(void *opaque)
 {
-        ec_fop_data_t *fop = opaque;
-        ec_heal_do (fop->xl, fop, &fop->loc[0], fop->int32);
-        return 0;
+    ec_fop_data_t *fop = opaque;
+    ec_heal_do(fop->xl, fop, &fop->loc[0], fop->int32);
+    return 0;
 }
 
 int
-ec_heal_done (int ret, call_frame_t *heal, void *opaque)
+ec_heal_done(int ret, call_frame_t *heal, void *opaque)
 {
-        if (opaque)
-                ec_fop_data_release (opaque);
-        return 0;
+    if (opaque)
+        ec_fop_data_release(opaque);
+    return 0;
 }
 
-ec_fop_data_t*
-__ec_dequeue_heals (ec_t *ec)
+ec_fop_data_t *
+__ec_dequeue_heals(ec_t *ec)
 {
-        ec_fop_data_t *fop = NULL;
+    ec_fop_data_t *fop = NULL;
 
-        if (list_empty (&ec->heal_waiting))
-                goto none;
+    if (list_empty(&ec->heal_waiting))
+        goto none;
 
-        if ((ec->background_heals > 0) && (ec->healers >= ec->background_heals))
-                goto none;
+    if ((ec->background_heals > 0) && (ec->healers >= ec->background_heals))
+        goto none;
 
-        fop = list_entry(ec->heal_waiting.next, ec_fop_data_t, healer);
-        ec->heal_waiters--;
-        list_del_init(&fop->healer);
-        list_add(&fop->healer, &ec->healing);
-        ec->healers++;
-        return fop;
+    fop = list_entry(ec->heal_waiting.next, ec_fop_data_t, healer);
+    ec->heal_waiters--;
+    list_del_init(&fop->healer);
+    list_add(&fop->healer, &ec->healing);
+    ec->healers++;
+    return fop;
 none:
-        gf_msg_debug (ec->xl->name, 0, "Num healers: %d, Num Waiters: %d",
-                      ec->healers, ec->heal_waiters);
-        return NULL;
+    gf_msg_debug(ec->xl->name, 0, "Num healers: %d, Num Waiters: %d",
+                 ec->healers, ec->heal_waiters);
+    return NULL;
 }
 
 void
-ec_heal_fail (ec_t *ec, ec_fop_data_t *fop)
+ec_heal_fail(ec_t *ec, ec_fop_data_t *fop)
 {
-        if (fop->cbks.heal) {
-            fop->cbks.heal (fop->req_frame, NULL, ec->xl, -1, fop->error, 0, 0,
-                            0, NULL);
-        }
-        ec_fop_data_release (fop);
+    if (fop->cbks.heal) {
+        fop->cbks.heal(fop->req_frame, NULL, ec->xl, -1, fop->error, 0, 0, 0,
+                       NULL);
+    }
+    ec_fop_data_release(fop);
 }
 
 void
-ec_launch_heal (ec_t *ec, ec_fop_data_t *fop)
+ec_launch_heal(ec_t *ec, ec_fop_data_t *fop)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        ret = synctask_new (ec->xl->ctx->env, ec_synctask_heal_wrap,
-                            ec_heal_done, NULL, fop);
-        if (ret < 0) {
-                ec_fop_set_error(fop, ENOMEM);
-                ec_heal_fail (ec, fop);
-        }
+    ret = synctask_new(ec->xl->ctx->env, ec_synctask_heal_wrap, ec_heal_done,
+                       NULL, fop);
+    if (ret < 0) {
+        ec_fop_set_error(fop, ENOMEM);
+        ec_heal_fail(ec, fop);
+    }
 }
 
 void
-ec_handle_healers_done (ec_fop_data_t *fop)
+ec_handle_healers_done(ec_fop_data_t *fop)
 {
-        ec_t *ec = fop->xl->private;
-        ec_fop_data_t *heal_fop = NULL;
+    ec_t *ec = fop->xl->private;
+    ec_fop_data_t *heal_fop = NULL;
 
-        if (list_empty (&fop->healer))
-                return;
+    if (list_empty(&fop->healer))
+        return;
 
-        LOCK (&ec->lock);
+    LOCK(&ec->lock);
 
-        list_del_init (&fop->healer);
+    list_del_init(&fop->healer);
 
-        do {
-                ec->healers--;
-                heal_fop = __ec_dequeue_heals (ec);
+    do {
+        ec->healers--;
+        heal_fop = __ec_dequeue_heals(ec);
 
-                if ((heal_fop != NULL) && ec->shutdown) {
-                        /* This will prevent ec_handle_healers_done() to be
-                         * called recursively. That would be problematic if
-                         * the queue is too big. */
-                        list_del_init(&heal_fop->healer);
+        if ((heal_fop != NULL) && ec->shutdown) {
+            /* This will prevent ec_handle_healers_done() to be
+             * called recursively. That would be problematic if
+             * the queue is too big. */
+            list_del_init(&heal_fop->healer);
 
-                        UNLOCK(&ec->lock);
+            UNLOCK(&ec->lock);
 
-                        ec_fop_set_error(fop, ENOTCONN);
-                        ec_heal_fail(ec, heal_fop);
+            ec_fop_set_error(fop, ENOTCONN);
+            ec_heal_fail(ec, heal_fop);
 
-                        LOCK(&ec->lock);
-                }
-        } while ((heal_fop != NULL) && ec->shutdown);
+            LOCK(&ec->lock);
+        }
+    } while ((heal_fop != NULL) && ec->shutdown);
 
-        UNLOCK (&ec->lock);
+    UNLOCK(&ec->lock);
 
-        if (heal_fop)
-                ec_launch_heal (ec, heal_fop);
+    if (heal_fop)
+        ec_launch_heal(ec, heal_fop);
 }
 
 void
-ec_heal_throttle (xlator_t *this, ec_fop_data_t *fop)
-{
-        gf_boolean_t can_heal = _gf_true;
-        ec_t         *ec      = this->private;
-
-        if (fop->req_frame == NULL) {
-
-                LOCK (&ec->lock);
-                {
-                        if ((ec->background_heals > 0) &&
-                            (ec->heal_wait_qlen + ec->background_heals) >
-                                             (ec->heal_waiters + ec->healers)) {
-                                list_add_tail(&fop->healer, &ec->heal_waiting);
-                                ec->heal_waiters++;
-                                fop = __ec_dequeue_heals (ec);
-                        } else {
-                                can_heal = _gf_false;
-                        }
-                }
-                UNLOCK (&ec->lock);
-        }
+ec_heal_throttle(xlator_t *this, ec_fop_data_t *fop)
+{
+    gf_boolean_t can_heal = _gf_true;
+    ec_t *ec = this->private;
 
-        if (can_heal) {
-                if (fop)
-                        ec_launch_heal (ec, fop);
-        } else {
-                gf_msg_debug (this->name, 0, "Max number of heals are "
-                              "pending, background self-heal rejected");
-                ec_fop_set_error(fop, EBUSY);
-                ec_heal_fail (ec, fop);
-        }
+    if (fop->req_frame == NULL) {
+        LOCK(&ec->lock);
+        {
+            if ((ec->background_heals > 0) &&
+                (ec->heal_wait_qlen + ec->background_heals) >
+                    (ec->heal_waiters + ec->healers)) {
+                list_add_tail(&fop->healer, &ec->heal_waiting);
+                ec->heal_waiters++;
+                fop = __ec_dequeue_heals(ec);
+            } else {
+                can_heal = _gf_false;
+            }
+        }
+        UNLOCK(&ec->lock);
+    }
+
+    if (can_heal) {
+        if (fop)
+            ec_launch_heal(ec, fop);
+    } else {
+        gf_msg_debug(this->name, 0,
+                     "Max number of heals are "
+                     "pending, background self-heal rejected");
+        ec_fop_set_error(fop, EBUSY);
+        ec_heal_fail(ec, fop);
+    }
 }
 
 void
-ec_heal (call_frame_t *frame, xlator_t *this, uintptr_t target,
-         int32_t minimum, fop_heal_cbk_t func, void *data, loc_t *loc,
-         int32_t partial, dict_t *xdata)
+ec_heal(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+        fop_heal_cbk_t func, void *data, loc_t *loc, int32_t partial,
+        dict_t *xdata)
 {
-    ec_cbk_t callback = { .heal = func };
+    ec_cbk_t callback = {.heal = func};
     ec_fop_data_t *fop = NULL;
     int32_t err = EINVAL;
 
-    gf_msg_trace ("ec", 0, "EC(HEAL) %p", frame);
+    gf_msg_trace("ec", 0, "EC(HEAL) %p", frame);
 
     VALIDATE_OR_GOTO(this, fail);
     GF_VALIDATE_OR_GOTO(this->name, this->private, fail);
 
-    if (!loc || !loc->inode || gf_uuid_is_null (loc->inode->gfid))
-            goto fail;
+    if (!loc || !loc->inode || gf_uuid_is_null(loc->inode->gfid))
+        goto fail;
 
     if (frame && frame->local)
-            goto fail;
-    fop = ec_fop_data_allocate (frame, this, EC_FOP_HEAL, 0, target, minimum,
-                                NULL, NULL, callback, data);
+        goto fail;
+    fop = ec_fop_data_allocate(frame, this, EC_FOP_HEAL, 0, target, minimum,
+                               NULL, NULL, callback, data);
 
     err = ENOMEM;
 
@@ -2738,454 +2721,446 @@ ec_heal (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata)
         fop->xdata = dict_ref(xdata);
 
-    ec_heal_throttle (this, fop);
+    ec_heal_throttle(this, fop);
 
     return;
 
 fail:
     if (fop)
-            ec_fop_data_release (fop);
+        ec_fop_data_release(fop);
     if (func)
-            func (frame, NULL, this, -1, err, 0, 0, 0, NULL);
+        func(frame, NULL, this, -1, err, 0, 0, 0, NULL);
 }
 
 int
-ec_replace_heal_done (int ret, call_frame_t *heal, void *opaque)
+ec_replace_heal_done(int ret, call_frame_t *heal, void *opaque)
 {
-        ec_t *ec = opaque;
+    ec_t *ec = opaque;
 
-        gf_msg_debug (ec->xl->name, 0,
-                "getxattr on bricks is done ret %d", ret);
-        return 0;
+    gf_msg_debug(ec->xl->name, 0, "getxattr on bricks is done ret %d", ret);
+    return 0;
 }
 
 int32_t
-ec_replace_heal (ec_t *ec, inode_t *inode)
+ec_replace_heal(ec_t *ec, inode_t *inode)
 {
-        loc_t        loc = {0};
-        int          ret = 0;
+    loc_t loc = {0};
+    int ret = 0;
 
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        ret = syncop_getxattr (ec->xl, &loc, NULL, EC_XATTR_HEAL,
-                               NULL, NULL);
-        if (ret < 0)
-                gf_msg_debug (ec->xl->name, 0,
-                        "Heal failed for replace brick ret = %d", ret);
-
-        /* Once the root inode has been checked, it might have triggered a
-         * self-heal on it after a replace brick command or for some other
-         * reason. It can also happen that the volume already had damaged
-         * files in the index, even if the heal on the root directory failed.
-         * In both cases we need to wake all index healers to continue
-         * healing remaining entries that are marked as dirty. */
-        ec_shd_index_healer_wake(ec);
-
-        loc_wipe (&loc);
-        return ret;
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    ret = syncop_getxattr(ec->xl, &loc, NULL, EC_XATTR_HEAL, NULL, NULL);
+    if (ret < 0)
+        gf_msg_debug(ec->xl->name, 0, "Heal failed for replace brick ret = %d",
+                     ret);
+
+    /* Once the root inode has been checked, it might have triggered a
+     * self-heal on it after a replace brick command or for some other
+     * reason. It can also happen that the volume already had damaged
+     * files in the index, even if the heal on the root directory failed.
+     * In both cases we need to wake all index healers to continue
+     * healing remaining entries that are marked as dirty. */
+    ec_shd_index_healer_wake(ec);
+
+    loc_wipe(&loc);
+    return ret;
 }
 
 int32_t
-ec_replace_brick_heal_wrap (void  *opaque)
+ec_replace_brick_heal_wrap(void *opaque)
 {
-         ec_t *ec = opaque;
-         inode_table_t   *itable = NULL;
-         int32_t         ret     = -1;
+    ec_t *ec = opaque;
+    inode_table_t *itable = NULL;
+    int32_t ret = -1;
 
-         if (ec->xl->itable)
-                 itable = ec->xl->itable;
-         else
-                 goto out;
-         ret = ec_replace_heal (ec, itable->root);
+    if (ec->xl->itable)
+        itable = ec->xl->itable;
+    else
+        goto out;
+    ret = ec_replace_heal(ec, itable->root);
 out:
-         return ret;
+    return ret;
 }
 
 int32_t
-ec_launch_replace_heal (ec_t *ec)
+ec_launch_replace_heal(ec_t *ec)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (!ec)
-                return ret;
-        ret = synctask_new (ec->xl->ctx->env, ec_replace_brick_heal_wrap,
-                            ec_replace_heal_done, NULL, ec);
-        if (ret < 0) {
-                gf_msg_debug (ec->xl->name, 0,
-                        "Heal failed for replace brick ret = %d", ret);
-        }
+    if (!ec)
         return ret;
+    ret = synctask_new(ec->xl->ctx->env, ec_replace_brick_heal_wrap,
+                       ec_replace_heal_done, NULL, ec);
+    if (ret < 0) {
+        gf_msg_debug(ec->xl->name, 0, "Heal failed for replace brick ret = %d",
+                     ret);
+    }
+    return ret;
 }
 
 int32_t
 ec_set_heal_info(dict_t **dict_rsp, char *status)
 {
-        dict_t *dict = NULL;
-        int    ret   = 0;
+    dict_t *dict = NULL;
+    int ret = 0;
 
-        dict = dict_new ();
-        if (!dict) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        ret = dict_set_str (dict, "heal-info", status);
-        if (ret) {
-                gf_msg (THIS->name, GF_LOG_WARNING, -ret,
-                        EC_MSG_HEAL_FAIL,
-                        "Failed to set heal-info key to "
-                        "%s", status);
-                dict_unref(dict);
-                dict = NULL;
-        }
-        *dict_rsp = dict;
+    dict = dict_new();
+    if (!dict) {
+        ret = -ENOMEM;
+        goto out;
+    }
+    ret = dict_set_str(dict, "heal-info", status);
+    if (ret) {
+        gf_msg(THIS->name, GF_LOG_WARNING, -ret, EC_MSG_HEAL_FAIL,
+               "Failed to set heal-info key to "
+               "%s",
+               status);
+        dict_unref(dict);
+        dict = NULL;
+    }
+    *dict_rsp = dict;
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-_need_heal_calculate (ec_t *ec, uint64_t *dirty, unsigned char *sources,
-                      gf_boolean_t self_locked, int32_t lock_count,
-                      ec_heal_need_t *need_heal)
-{
-        int i = 0;
-        int source_count = 0;
-
-        source_count = EC_COUNT (sources, ec->nodes);
-        if (source_count == ec->nodes) {
-                *need_heal = EC_HEAL_NONEED;
-                if (self_locked || lock_count == 0) {
-                        for (i = 0; i < ec->nodes; i++) {
-                                if (dirty[i]) {
-                                        *need_heal = EC_HEAL_MUST;
-                                        goto out;
-                                }
-                        }
-                } else {
-                        for (i = 0; i < ec->nodes; i++) {
-                                /* Since each lock can only increment the dirty
-                                 * count once, if dirty is > 1 it means that
-                                 * another operation has left the dirty count
-                                 * set and this indicates a problem in the
-                                 * inode.*/
-                                if (dirty[i] > 1) {
-                                        *need_heal = EC_HEAL_MUST;
-                                        goto out;
-                                }
-                        }
+_need_heal_calculate(ec_t *ec, uint64_t *dirty, unsigned char *sources,
+                     gf_boolean_t self_locked, int32_t lock_count,
+                     ec_heal_need_t *need_heal)
+{
+    int i = 0;
+    int source_count = 0;
+
+    source_count = EC_COUNT(sources, ec->nodes);
+    if (source_count == ec->nodes) {
+        *need_heal = EC_HEAL_NONEED;
+        if (self_locked || lock_count == 0) {
+            for (i = 0; i < ec->nodes; i++) {
+                if (dirty[i]) {
+                    *need_heal = EC_HEAL_MUST;
+                    goto out;
                 }
+            }
         } else {
-                *need_heal = EC_HEAL_MUST;
+            for (i = 0; i < ec->nodes; i++) {
+                /* Since each lock can only increment the dirty
+                 * count once, if dirty is > 1 it means that
+                 * another operation has left the dirty count
+                 * set and this indicates a problem in the
+                 * inode.*/
+                if (dirty[i] > 1) {
+                    *need_heal = EC_HEAL_MUST;
+                    goto out;
+                }
+            }
         }
+    } else {
+        *need_heal = EC_HEAL_MUST;
+    }
 
 out:
-        return source_count;
+    return source_count;
 }
 
 static int32_t
-ec_need_metadata_heal (ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
-                       int32_t lock_count, gf_boolean_t self_locked,
-                       gf_boolean_t thorough, ec_heal_need_t *need_heal)
-{
-        uint64_t           *dirty         = NULL;
-        unsigned char      *sources       = NULL;
-        unsigned char      *healed_sinks  = NULL;
-        uint64_t           *meta_versions = NULL;
-        int                ret            = 0;
-        int                i              = 0;
-
-        sources = alloca0(ec->nodes);
-        healed_sinks = alloca0(ec->nodes);
-        dirty = alloca0 (ec->nodes * sizeof (*dirty));
-        meta_versions = alloca0 (ec->nodes * sizeof (*meta_versions));
-        ret = ec_heal_metadata_find_direction (ec, replies, meta_versions,
-                                               dirty, sources, healed_sinks);
-        if (ret < 0 && ret != -EIO) {
+ec_need_metadata_heal(ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
+                      int32_t lock_count, gf_boolean_t self_locked,
+                      gf_boolean_t thorough, ec_heal_need_t *need_heal)
+{
+    uint64_t *dirty = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *healed_sinks = NULL;
+    uint64_t *meta_versions = NULL;
+    int ret = 0;
+    int i = 0;
+
+    sources = alloca0(ec->nodes);
+    healed_sinks = alloca0(ec->nodes);
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+    meta_versions = alloca0(ec->nodes * sizeof(*meta_versions));
+    ret = ec_heal_metadata_find_direction(ec, replies, meta_versions, dirty,
+                                          sources, healed_sinks);
+    if (ret < 0 && ret != -EIO) {
+        goto out;
+    }
+
+    ret = _need_heal_calculate(ec, dirty, sources, self_locked, lock_count,
+                               need_heal);
+    if (ret == ec->nodes && *need_heal == EC_HEAL_NONEED) {
+        for (i = 1; i < ec->nodes; i++) {
+            if (meta_versions[i] != meta_versions[0]) {
+                *need_heal = EC_HEAL_MUST;
                 goto out;
+            }
         }
+    }
+out:
+    return ret;
+}
 
-        ret = _need_heal_calculate (ec, dirty, sources, self_locked, lock_count,
-                                    need_heal);
-        if (ret == ec->nodes && *need_heal == EC_HEAL_NONEED) {
-                for (i = 1; i < ec->nodes; i++) {
-                        if (meta_versions[i] != meta_versions[0]) {
-                                *need_heal = EC_HEAL_MUST;
-                                goto out;
-                        }
-                }
-        }
+static int32_t
+ec_need_data_heal(ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
+                  int32_t lock_count, gf_boolean_t self_locked,
+                  gf_boolean_t thorough, ec_heal_need_t *need_heal)
+{
+    uint64_t *dirty = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *healed_sinks = NULL;
+    uint64_t *data_versions = NULL;
+    uint64_t *size = NULL;
+    int ret = 0;
+
+    sources = alloca0(ec->nodes);
+    healed_sinks = alloca0(ec->nodes);
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+    data_versions = alloca0(ec->nodes * sizeof(*data_versions));
+    size = alloca0(ec->nodes * sizeof(*size));
+
+    /* When dd is going on and heal info is called there is a very good
+     * chance for on disk sizes to mismatch even though nothing is wrong
+     * we don't need ondisk size check there. But if the file is either
+     * self-locked or the caller wants a thorough check then make sure to
+     * perform on disk check also. */
+    ret = ec_heal_data_find_direction(
+        ec, replies, data_versions, dirty, size, sources, healed_sinks,
+        self_locked || thorough, EC_COMBINE_XDATA);
+    if (ret < 0 && ret != -EIO) {
+        goto out;
+    }
+
+    ret = _need_heal_calculate(ec, dirty, sources, self_locked, lock_count,
+                               need_heal);
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-ec_need_data_heal (ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
+ec_need_entry_heal(ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
                    int32_t lock_count, gf_boolean_t self_locked,
                    gf_boolean_t thorough, ec_heal_need_t *need_heal)
 {
-        uint64_t           *dirty         = NULL;
-        unsigned char      *sources       = NULL;
-        unsigned char      *healed_sinks  = NULL;
-        uint64_t           *data_versions = NULL;
-        uint64_t           *size          = NULL;
-        int                ret            = 0;
-
-        sources = alloca0(ec->nodes);
-        healed_sinks = alloca0(ec->nodes);
-        dirty = alloca0 (ec->nodes * sizeof (*dirty));
-        data_versions = alloca0 (ec->nodes * sizeof (*data_versions));
-        size = alloca0 (ec->nodes * sizeof (*size));
-
-        /* When dd is going on and heal info is called there is a very good
-         * chance for on disk sizes to mismatch even though nothing is wrong
-         * we don't need ondisk size check there. But if the file is either
-         * self-locked or the caller wants a thorough check then make sure to
-         * perform on disk check also. */
-        ret = ec_heal_data_find_direction (ec, replies, data_versions,
-                                           dirty, size, sources, healed_sinks,
-                                           self_locked || thorough,
-                                           EC_COMBINE_XDATA);
-        if (ret < 0 && ret != -EIO) {
-                goto out;
-        }
+    uint64_t *dirty = NULL;
+    unsigned char *sources = NULL;
+    unsigned char *healed_sinks = NULL;
+    uint64_t *data_versions = NULL;
+    int ret = 0;
 
-        ret = _need_heal_calculate (ec, dirty, sources, self_locked, lock_count,
-                                    need_heal);
-out:
-        return ret;
-}
+    sources = alloca0(ec->nodes);
+    healed_sinks = alloca0(ec->nodes);
+    dirty = alloca0(ec->nodes * sizeof(*dirty));
+    data_versions = alloca0(ec->nodes * sizeof(*data_versions));
 
-static int32_t
-ec_need_entry_heal (ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
-                    int32_t lock_count, gf_boolean_t self_locked,
-                    gf_boolean_t thorough, ec_heal_need_t *need_heal)
-{
-        uint64_t           *dirty         = NULL;
-        unsigned char      *sources       = NULL;
-        unsigned char      *healed_sinks  = NULL;
-        uint64_t           *data_versions = NULL;
-        int                ret            = 0;
-
-        sources = alloca0(ec->nodes);
-        healed_sinks = alloca0(ec->nodes);
-        dirty = alloca0 (ec->nodes * sizeof (*dirty));
-        data_versions = alloca0 (ec->nodes * sizeof (*data_versions));
-
-        ret = ec_heal_entry_find_direction (ec, replies, data_versions,
-                                           dirty, sources, healed_sinks);
-        if (ret < 0 && ret != -EIO) {
-                goto out;
-        }
+    ret = ec_heal_entry_find_direction(ec, replies, data_versions, dirty,
+                                       sources, healed_sinks);
+    if (ret < 0 && ret != -EIO) {
+        goto out;
+    }
 
-        ret = _need_heal_calculate (ec, dirty, sources, self_locked, lock_count,
-                                    need_heal);
+    ret = _need_heal_calculate(ec, dirty, sources, self_locked, lock_count,
+                               need_heal);
 out:
-        return ret;
+    return ret;
 }
 
 static int32_t
-ec_need_heal (ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
-              int32_t lock_count, gf_boolean_t self_locked,
-              gf_boolean_t thorough, ec_heal_need_t *need_heal)
+ec_need_heal(ec_t *ec, inode_t *inode, default_args_cbk_t *replies,
+             int32_t lock_count, gf_boolean_t self_locked,
+             gf_boolean_t thorough, ec_heal_need_t *need_heal)
 {
-        int                ret            = 0;
-
+    int ret = 0;
 
-        ret = ec_need_metadata_heal (ec, inode, replies, lock_count,
-                                     self_locked, thorough, need_heal);
-        if (ret < 0)
-                goto out;
+    ret = ec_need_metadata_heal(ec, inode, replies, lock_count, self_locked,
+                                thorough, need_heal);
+    if (ret < 0)
+        goto out;
 
-        if (*need_heal == EC_HEAL_MUST)
-                goto out;
+    if (*need_heal == EC_HEAL_MUST)
+        goto out;
 
-        if (inode->ia_type == IA_IFREG) {
-                ret = ec_need_data_heal (ec, inode, replies, lock_count,
-                                         self_locked, thorough, need_heal);
-        } else if (inode->ia_type == IA_IFDIR) {
-                ret = ec_need_entry_heal (ec, inode, replies, lock_count,
-                                          self_locked, thorough, need_heal);
-        }
+    if (inode->ia_type == IA_IFREG) {
+        ret = ec_need_data_heal(ec, inode, replies, lock_count, self_locked,
+                                thorough, need_heal);
+    } else if (inode->ia_type == IA_IFDIR) {
+        ret = ec_need_entry_heal(ec, inode, replies, lock_count, self_locked,
+                                 thorough, need_heal);
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-ec_heal_inspect (call_frame_t *frame, ec_t *ec,
-                 inode_t *inode, unsigned char *locked_on,
-                 gf_boolean_t self_locked, gf_boolean_t thorough,
-                 ec_heal_need_t *need_heal)
-{
-        loc_t              loc           = {0};
-        int                i             = 0;
-        int                ret           = 0;
-        dict_t             *xdata        = NULL;
-        uint64_t           zero_array[2] = {0};
-        uint64_t           zero_value    = 0;
-        unsigned char      *output       = NULL;
-        default_args_cbk_t *replies      = NULL;
-        int32_t            lock_count    = 0;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        output = alloca0 (ec->nodes);
-
-        loc.inode = inode_ref (inode);
-        gf_uuid_copy (loc.gfid, inode->gfid);
-
-        xdata = dict_new ();
-        if (!xdata ||
-            dict_set_static_bin (xdata, EC_XATTR_VERSION, zero_array,
-                                 sizeof (zero_array)) ||
-            dict_set_static_bin (xdata, EC_XATTR_DIRTY, zero_array,
-                                 sizeof (zero_array)) ||
-            dict_set_static_bin (xdata, EC_XATTR_SIZE, &zero_value,
-                                 sizeof (zero_value))) {
-                ret = -ENOMEM;
-                goto out;
-        }
+ec_heal_inspect(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                unsigned char *locked_on, gf_boolean_t self_locked,
+                gf_boolean_t thorough, ec_heal_need_t *need_heal)
+{
+    loc_t loc = {0};
+    int i = 0;
+    int ret = 0;
+    dict_t *xdata = NULL;
+    uint64_t zero_array[2] = {0};
+    uint64_t zero_value = 0;
+    unsigned char *output = NULL;
+    default_args_cbk_t *replies = NULL;
+    int32_t lock_count = 0;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    output = alloca0(ec->nodes);
+
+    loc.inode = inode_ref(inode);
+    gf_uuid_copy(loc.gfid, inode->gfid);
+
+    xdata = dict_new();
+    if (!xdata ||
+        dict_set_static_bin(xdata, EC_XATTR_VERSION, zero_array,
+                            sizeof(zero_array)) ||
+        dict_set_static_bin(xdata, EC_XATTR_DIRTY, zero_array,
+                            sizeof(zero_array)) ||
+        dict_set_static_bin(xdata, EC_XATTR_SIZE, &zero_value,
+                            sizeof(zero_value))) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        if (!self_locked) {
-                ret = dict_set_str(xdata, GLUSTERFS_INODELK_DOM_COUNT,
-                             ec->xl->name);
-                if (ret) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+    if (!self_locked) {
+        ret = dict_set_str(xdata, GLUSTERFS_INODELK_DOM_COUNT, ec->xl->name);
+        if (ret) {
+            ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        ret = cluster_lookup (ec->xl_list, locked_on, ec->nodes, replies,
-                              output, frame, ec->xl, &loc, xdata);
+    ret = cluster_lookup(ec->xl_list, locked_on, ec->nodes, replies, output,
+                         frame, ec->xl, &loc, xdata);
 
-        if (ret != ec->nodes) {
-                ret = ec->nodes;
-                *need_heal = EC_HEAL_MUST;
-                goto out;
-        }
+    if (ret != ec->nodes) {
+        ret = ec->nodes;
+        *need_heal = EC_HEAL_MUST;
+        goto out;
+    }
 
-        if (self_locked)
-                goto need_heal;
+    if (self_locked)
+        goto need_heal;
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (!output[i] || !replies[i].xdata) {
-                        continue;
-                }
-                if ((dict_get_int32 (replies[i].xdata, GLUSTERFS_INODELK_COUNT,
-                                     &lock_count) == 0) && lock_count > 0) {
-                        break;
-                }
+    for (i = 0; i < ec->nodes; i++) {
+        if (!output[i] || !replies[i].xdata) {
+            continue;
+        }
+        if ((dict_get_int32(replies[i].xdata, GLUSTERFS_INODELK_COUNT,
+                            &lock_count) == 0) &&
+            lock_count > 0) {
+            break;
         }
+    }
 need_heal:
-        ret = ec_need_heal (ec, inode, replies, lock_count,
-                            self_locked, thorough, need_heal);
+    ret = ec_need_heal(ec, inode, replies, lock_count, self_locked, thorough,
+                       need_heal);
 
-        if (!self_locked && *need_heal == EC_HEAL_MUST) {
-                *need_heal = EC_HEAL_MAYBE;
-        }
+    if (!self_locked && *need_heal == EC_HEAL_MUST) {
+        *need_heal = EC_HEAL_MAYBE;
+    }
 out:
-        cluster_replies_wipe (replies, ec->nodes);
-        loc_wipe (&loc);
-        if (xdata) {
-                dict_unref(xdata);
-        }
-        return ret;
+    cluster_replies_wipe(replies, ec->nodes);
+    loc_wipe(&loc);
+    if (xdata) {
+        dict_unref(xdata);
+    }
+    return ret;
 }
 
 int32_t
-ec_heal_locked_inspect (call_frame_t *frame, ec_t *ec, inode_t *inode,
-                        ec_heal_need_t *need_heal)
-{
-        unsigned char      *locked_on  = NULL;
-        unsigned char      *up_subvols = NULL;
-        unsigned char      *output     = NULL;
-        default_args_cbk_t *replies    = NULL;
-        int                ret         = 0;
-
-        EC_REPLIES_ALLOC (replies, ec->nodes);
-        locked_on = alloca0(ec->nodes);
-        output = alloca0(ec->nodes);
-        up_subvols = alloca0(ec->nodes);
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
-
-        ret = cluster_inodelk (ec->xl_list, up_subvols, ec->nodes,
-                               replies, locked_on, frame, ec->xl,
-                               ec->xl->name, inode, 0, 0);
-        if (ret != ec->nodes) {
-                *need_heal = EC_HEAL_MUST;
-                goto unlock;
-        }
-        ret = ec_heal_inspect (frame, ec, inode, locked_on, _gf_true, _gf_true,
-                               need_heal);
+ec_heal_locked_inspect(call_frame_t *frame, ec_t *ec, inode_t *inode,
+                       ec_heal_need_t *need_heal)
+{
+    unsigned char *locked_on = NULL;
+    unsigned char *up_subvols = NULL;
+    unsigned char *output = NULL;
+    default_args_cbk_t *replies = NULL;
+    int ret = 0;
+
+    EC_REPLIES_ALLOC(replies, ec->nodes);
+    locked_on = alloca0(ec->nodes);
+    output = alloca0(ec->nodes);
+    up_subvols = alloca0(ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
+
+    ret = cluster_inodelk(ec->xl_list, up_subvols, ec->nodes, replies,
+                          locked_on, frame, ec->xl, ec->xl->name, inode, 0, 0);
+    if (ret != ec->nodes) {
+        *need_heal = EC_HEAL_MUST;
+        goto unlock;
+    }
+    ret = ec_heal_inspect(frame, ec, inode, locked_on, _gf_true, _gf_true,
+                          need_heal);
 unlock:
-        cluster_uninodelk (ec->xl_list, locked_on, ec->nodes,
-                           replies, output, frame, ec->xl,
-                           ec->xl->name, inode, 0, 0);
-        cluster_replies_wipe (replies, ec->nodes);
-        return ret;
+    cluster_uninodelk(ec->xl_list, locked_on, ec->nodes, replies, output, frame,
+                      ec->xl, ec->xl->name, inode, 0, 0);
+    cluster_replies_wipe(replies, ec->nodes);
+    return ret;
 }
 
 int32_t
-ec_get_heal_info (xlator_t *this, loc_t *entry_loc, dict_t **dict_rsp)
+ec_get_heal_info(xlator_t *this, loc_t *entry_loc, dict_t **dict_rsp)
 {
-        int             ret             = -ENOMEM;
-        ec_heal_need_t  need_heal       = EC_HEAL_NONEED;
-        call_frame_t    *frame          = NULL;
-        ec_t            *ec             = NULL;
-        unsigned char   *up_subvols     = NULL;
-        loc_t           loc             = {0, };
+    int ret = -ENOMEM;
+    ec_heal_need_t need_heal = EC_HEAL_NONEED;
+    call_frame_t *frame = NULL;
+    ec_t *ec = NULL;
+    unsigned char *up_subvols = NULL;
+    loc_t loc = {
+        0,
+    };
 
-        VALIDATE_OR_GOTO(this, out);
-        GF_VALIDATE_OR_GOTO(this->name, entry_loc, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, entry_loc, out);
 
-        ec = this->private;
-        up_subvols = alloca0(ec->nodes);
-        ec_mask_to_char_array (ec->xl_up, up_subvols, ec->nodes);
+    ec = this->private;
+    up_subvols = alloca0(ec->nodes);
+    ec_mask_to_char_array(ec->xl_up, up_subvols, ec->nodes);
 
-        if (EC_COUNT (up_subvols, ec->nodes) != ec->nodes) {
-                need_heal = EC_HEAL_MUST;
-                goto set_heal;
-        }
-        frame = create_frame (this, this->ctx->pool);
-        if (!frame) {
-                goto out;
-        }
-        ec_owner_set(frame, frame->root);
-        frame->root->uid = 0;
-        frame->root->gid = 0;
-        frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
-
-        if (loc_copy(&loc, entry_loc) != 0) {
-                gf_msg (this->name, GF_LOG_ERROR,
-                        ENOMEM, EC_MSG_LOC_COPY_FAIL,
-                        "Failed to copy a location.");
-                goto out;
-        }
-        if (!loc.inode) {
-                ret = syncop_inode_find (this, this, loc.gfid,
-                                         &loc.inode, NULL, NULL);
-                if (ret < 0)
-                        goto out;
-        }
-
-        ret = ec_heal_inspect (frame, ec, loc.inode, up_subvols, _gf_false,
-                               _gf_false, &need_heal);
-        if (ret == ec->nodes && need_heal == EC_HEAL_NONEED) {
-                goto set_heal;
-        }
-        need_heal = EC_HEAL_NONEED;
-        ret = ec_heal_locked_inspect (frame, ec, loc.inode,
-                                      &need_heal);
+    if (EC_COUNT(up_subvols, ec->nodes) != ec->nodes) {
+        need_heal = EC_HEAL_MUST;
+        goto set_heal;
+    }
+    frame = create_frame(this, this->ctx->pool);
+    if (!frame) {
+        goto out;
+    }
+    ec_owner_set(frame, frame->root);
+    frame->root->uid = 0;
+    frame->root->gid = 0;
+    frame->root->pid = GF_CLIENT_PID_SELF_HEALD;
+
+    if (loc_copy(&loc, entry_loc) != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+               "Failed to copy a location.");
+        goto out;
+    }
+    if (!loc.inode) {
+        ret = syncop_inode_find(this, this, loc.gfid, &loc.inode, NULL, NULL);
         if (ret < 0)
-                goto out;
+            goto out;
+    }
+
+    ret = ec_heal_inspect(frame, ec, loc.inode, up_subvols, _gf_false,
+                          _gf_false, &need_heal);
+    if (ret == ec->nodes && need_heal == EC_HEAL_NONEED) {
+        goto set_heal;
+    }
+    need_heal = EC_HEAL_NONEED;
+    ret = ec_heal_locked_inspect(frame, ec, loc.inode, &need_heal);
+    if (ret < 0)
+        goto out;
 set_heal:
-        if (need_heal == EC_HEAL_MUST) {
-                ret =  ec_set_heal_info (dict_rsp, "heal");
-        } else {
-                ret =  ec_set_heal_info (dict_rsp, "no-heal");
-        }
+    if (need_heal == EC_HEAL_MUST) {
+        ret = ec_set_heal_info(dict_rsp, "heal");
+    } else {
+        ret = ec_set_heal_info(dict_rsp, "no-heal");
+    }
 out:
-        if (frame) {
-                STACK_DESTROY (frame->root);
-        }
-        loc_wipe (&loc);
-        return ret;
+    if (frame) {
+        STACK_DESTROY(frame->root);
+    }
+    loc_wipe(&loc);
+    return ret;
 }
diff --git a/xlators/cluster/ec/src/ec-heald.c b/xlators/cluster/ec/src/ec-heald.c
index f36901ef74f..cc1062dd353 100644
--- a/xlators/cluster/ec/src/ec-heald.c
+++ b/xlators/cluster/ec/src/ec-heald.c
@@ -19,559 +19,545 @@
 #include "syncop-utils.h"
 #include "protocol-common.h"
 
-
-#define NTH_INDEX_HEALER(this, n) (&((((ec_t *)this->private))->shd.index_healers[n]))
-#define NTH_FULL_HEALER(this, n) (&((((ec_t *)this->private))->shd.full_healers[n]))
+#define NTH_INDEX_HEALER(this, n)                                              \
+    (&((((ec_t *)this->private))->shd.index_healers[n]))
+#define NTH_FULL_HEALER(this, n)                                               \
+    (&((((ec_t *)this->private))->shd.full_healers[n]))
 
 gf_boolean_t
-ec_shd_is_subvol_local (xlator_t *this, int subvol)
+ec_shd_is_subvol_local(xlator_t *this, int subvol)
 {
-        ec_t *ec = NULL;
-        gf_boolean_t is_local = _gf_false;
-        loc_t loc = {0, };
-
-        ec = this->private;
-        loc.inode = this->itable->root;
-        syncop_is_subvol_local (ec->xl_list[subvol], &loc, &is_local);
-        return is_local;
+    ec_t *ec = NULL;
+    gf_boolean_t is_local = _gf_false;
+    loc_t loc = {
+        0,
+    };
+
+    ec = this->private;
+    loc.inode = this->itable->root;
+    syncop_is_subvol_local(ec->xl_list[subvol], &loc, &is_local);
+    return is_local;
 }
 
 char *
-ec_subvol_name (xlator_t *this, int subvol)
+ec_subvol_name(xlator_t *this, int subvol)
 {
-        ec_t *ec = NULL;
+    ec_t *ec = NULL;
 
-        ec = this->private;
-        if (subvol < 0 || subvol > ec->nodes)
-                return NULL;
+    ec = this->private;
+    if (subvol < 0 || subvol > ec->nodes)
+        return NULL;
 
-        return ec->xl_list[subvol]->name;
+    return ec->xl_list[subvol]->name;
 }
 
 int
-__ec_shd_healer_wait (struct subvol_healer *healer)
+__ec_shd_healer_wait(struct subvol_healer *healer)
 {
-        ec_t *ec = NULL;
-        struct timespec wait_till = {0, };
-        int ret = 0;
+    ec_t *ec = NULL;
+    struct timespec wait_till = {
+        0,
+    };
+    int ret = 0;
 
-        ec = healer->this->private;
+    ec = healer->this->private;
 
 disabled_loop:
-        wait_till.tv_sec = time (NULL) + 60;
-
-        while (!healer->rerun) {
-                ret = pthread_cond_timedwait (&healer->cond,
-                                              &healer->mutex,
-                                              &wait_till);
-                if (ret == ETIMEDOUT)
-                        break;
-        }
+    wait_till.tv_sec = time(NULL) + 60;
 
-        ret = healer->rerun;
-        healer->rerun = 0;
+    while (!healer->rerun) {
+        ret = pthread_cond_timedwait(&healer->cond, &healer->mutex, &wait_till);
+        if (ret == ETIMEDOUT)
+            break;
+    }
 
-        if (!ec->shd.enabled || !ec->up)
-                goto disabled_loop;
+    ret = healer->rerun;
+    healer->rerun = 0;
 
-        return ret;
-}
+    if (!ec->shd.enabled || !ec->up)
+        goto disabled_loop;
 
+    return ret;
+}
 
 int
-ec_shd_healer_wait (struct subvol_healer *healer)
+ec_shd_healer_wait(struct subvol_healer *healer)
 {
-        int ret = 0;
+    int ret = 0;
 
-        pthread_mutex_lock (&healer->mutex);
-        {
-                ret = __ec_shd_healer_wait (healer);
-        }
-        pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_lock(&healer->mutex);
+    {
+        ret = __ec_shd_healer_wait(healer);
+    }
+    pthread_mutex_unlock(&healer->mutex);
 
-        return ret;
+    return ret;
 }
 
 int
-ec_shd_index_inode (xlator_t *this, xlator_t *subvol, inode_t **inode)
+ec_shd_index_inode(xlator_t *this, xlator_t *subvol, inode_t **inode)
 {
-        loc_t   rootloc     = {0, };
-        int     ret         = 0;
-        dict_t  *xattr      = NULL;
-        void    *index_gfid = NULL;
-
-        *inode = NULL;
-        rootloc.inode = inode_ref (this->itable->root);
-        gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
-
-        ret = syncop_getxattr (subvol, &rootloc, &xattr,
-                               GF_XATTROP_INDEX_GFID, NULL, NULL);
-        if (ret < 0)
-                goto out;
-        if (!xattr) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        ret = dict_get_ptr (xattr, GF_XATTROP_INDEX_GFID, &index_gfid);
-        if (ret)
-                goto out;
-
-        gf_msg_debug (this->name, 0, "index-dir gfid for %s: %s",
-                subvol->name, uuid_utoa (index_gfid));
-
-        ret = syncop_inode_find (this, subvol, index_gfid,
-                                 inode, NULL, NULL);
+    loc_t rootloc = {
+        0,
+    };
+    int ret = 0;
+    dict_t *xattr = NULL;
+    void *index_gfid = NULL;
+
+    *inode = NULL;
+    rootloc.inode = inode_ref(this->itable->root);
+    gf_uuid_copy(rootloc.gfid, rootloc.inode->gfid);
+
+    ret = syncop_getxattr(subvol, &rootloc, &xattr, GF_XATTROP_INDEX_GFID, NULL,
+                          NULL);
+    if (ret < 0)
+        goto out;
+    if (!xattr) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    ret = dict_get_ptr(xattr, GF_XATTROP_INDEX_GFID, &index_gfid);
+    if (ret)
+        goto out;
+
+    gf_msg_debug(this->name, 0, "index-dir gfid for %s: %s", subvol->name,
+                 uuid_utoa(index_gfid));
+
+    ret = syncop_inode_find(this, subvol, index_gfid, inode, NULL, NULL);
 
 out:
-        loc_wipe (&rootloc);
+    loc_wipe(&rootloc);
 
-        if (xattr)
-                dict_unref (xattr);
+    if (xattr)
+        dict_unref(xattr);
 
-        return ret;
+    return ret;
 }
 
 int
-ec_shd_index_purge (xlator_t *subvol, inode_t *inode, char *name)
+ec_shd_index_purge(xlator_t *subvol, inode_t *inode, char *name)
 {
-        loc_t loc = {0, };
-        int ret = 0;
+    loc_t loc = {
+        0,
+    };
+    int ret = 0;
 
-        loc.parent = inode_ref (inode);
-        loc.name = name;
+    loc.parent = inode_ref(inode);
+    loc.name = name;
 
-        ret = syncop_unlink (subvol, &loc, NULL, NULL);
+    ret = syncop_unlink(subvol, &loc, NULL, NULL);
 
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-ec_shd_selfheal (struct subvol_healer *healer, int child, loc_t *loc)
+ec_shd_selfheal(struct subvol_healer *healer, int child, loc_t *loc)
 {
-        int32_t ret;
-
-        ret = syncop_getxattr (healer->this, loc, NULL, EC_XATTR_HEAL, NULL,
-                               NULL);
-        if ((ret >= 0) && (loc->inode->ia_type == IA_IFDIR)) {
-                /* If we have just healed a directory, it's possible that
-                 * other index entries have appeared to be healed. We put a
-                 * mark so that we can check it later and restart a scan
-                 * without delay. */
-                healer->rerun = _gf_true;
-        }
-
-        return ret;
+    int32_t ret;
+
+    ret = syncop_getxattr(healer->this, loc, NULL, EC_XATTR_HEAL, NULL, NULL);
+    if ((ret >= 0) && (loc->inode->ia_type == IA_IFDIR)) {
+        /* If we have just healed a directory, it's possible that
+         * other index entries have appeared to be healed. We put a
+         * mark so that we can check it later and restart a scan
+         * without delay. */
+        healer->rerun = _gf_true;
+    }
+
+    return ret;
 }
 
-
 int
-ec_shd_index_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                   void *data)
+ec_shd_index_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                  void *data)
 {
-        struct subvol_healer *healer = data;
-        ec_t                 *ec     = NULL;
-        loc_t                loc     = {0};
-        int                  ret     = 0;
-
-        ec = healer->this->private;
-        if (ec->xl_up_count <= ec->fragments) {
-                return -ENOTCONN;
-        }
-        if (!ec->shd.enabled)
-                return -EBUSY;
-
-        gf_msg_debug (healer->this->name, 0, "got entry: %s",
-                entry->d_name);
-
-        ret = gf_uuid_parse (entry->d_name, loc.gfid);
-        if (ret)
-                return 0;
+    struct subvol_healer *healer = data;
+    ec_t *ec = NULL;
+    loc_t loc = {0};
+    int ret = 0;
+
+    ec = healer->this->private;
+    if (ec->xl_up_count <= ec->fragments) {
+        return -ENOTCONN;
+    }
+    if (!ec->shd.enabled)
+        return -EBUSY;
+
+    gf_msg_debug(healer->this->name, 0, "got entry: %s", entry->d_name);
+
+    ret = gf_uuid_parse(entry->d_name, loc.gfid);
+    if (ret)
+        return 0;
 
-        /* If this fails with ENOENT/ESTALE index is stale */
-        ret = syncop_gfid_to_path (healer->this->itable, subvol, loc.gfid,
-                                   (char **)&loc.path);
-        if (ret < 0)
-                goto out;
+    /* If this fails with ENOENT/ESTALE index is stale */
+    ret = syncop_gfid_to_path(healer->this->itable, subvol, loc.gfid,
+                              (char **)&loc.path);
+    if (ret < 0)
+        goto out;
 
-        ret = syncop_inode_find (healer->this, healer->this, loc.gfid,
-                                 &loc.inode, NULL, NULL);
-        if (ret < 0)
-                goto out;
+    ret = syncop_inode_find(healer->this, healer->this, loc.gfid, &loc.inode,
+                            NULL, NULL);
+    if (ret < 0)
+        goto out;
 
-        ec_shd_selfheal (healer, healer->subvol, &loc);
+    ec_shd_selfheal(healer, healer->subvol, &loc);
 out:
-        if (ret == -ENOENT || ret == -ESTALE) {
-                gf_msg (healer->this->name, GF_LOG_DEBUG, 0,
-                        EC_MSG_HEAL_FAIL, "Purging index for gfid %s:",
-                        uuid_utoa(loc.gfid));
-                ec_shd_index_purge (subvol, parent->inode, entry->d_name);
-        }
-        loc_wipe (&loc);
-
-        return 0;
+    if (ret == -ENOENT || ret == -ESTALE) {
+        gf_msg(healer->this->name, GF_LOG_DEBUG, 0, EC_MSG_HEAL_FAIL,
+               "Purging index for gfid %s:", uuid_utoa(loc.gfid));
+        ec_shd_index_purge(subvol, parent->inode, entry->d_name);
+    }
+    loc_wipe(&loc);
+
+    return 0;
 }
 
 int
-ec_shd_index_sweep (struct subvol_healer *healer)
+ec_shd_index_sweep(struct subvol_healer *healer)
 {
-        loc_t         loc     = {0};
-        ec_t          *ec     = NULL;
-        int           ret     = 0;
-        xlator_t      *subvol = NULL;
-        dict_t        *xdata  = NULL;
-
-        ec = healer->this->private;
-        subvol = ec->xl_list[healer->subvol];
-
-        ret = ec_shd_index_inode (healer->this, subvol, &loc.inode);
-        if (ret < 0) {
-                gf_msg (healer->this->name, GF_LOG_WARNING, errno,
-                        EC_MSG_INDEX_DIR_GET_FAIL,
-                        "unable to get index-dir on %s", subvol->name);
-                goto out;
-        }
-
-        xdata = dict_new ();
-        if (!xdata || dict_set_int32 (xdata, "get-gfid-type", 1)) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = syncop_mt_dir_scan (NULL, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
-                                  healer, ec_shd_index_heal, xdata,
-                                  ec->shd.max_threads, ec->shd.wait_qlength);
+    loc_t loc = {0};
+    ec_t *ec = NULL;
+    int ret = 0;
+    xlator_t *subvol = NULL;
+    dict_t *xdata = NULL;
+
+    ec = healer->this->private;
+    subvol = ec->xl_list[healer->subvol];
+
+    ret = ec_shd_index_inode(healer->this, subvol, &loc.inode);
+    if (ret < 0) {
+        gf_msg(healer->this->name, GF_LOG_WARNING, errno,
+               EC_MSG_INDEX_DIR_GET_FAIL, "unable to get index-dir on %s",
+               subvol->name);
+        goto out;
+    }
+
+    xdata = dict_new();
+    if (!xdata || dict_set_int32(xdata, "get-gfid-type", 1)) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = syncop_mt_dir_scan(NULL, subvol, &loc, GF_CLIENT_PID_SELF_HEALD,
+                             healer, ec_shd_index_heal, xdata,
+                             ec->shd.max_threads, ec->shd.wait_qlength);
 out:
-        if (xdata)
-                dict_unref (xdata);
-        loc_wipe (&loc);
+    if (xdata)
+        dict_unref(xdata);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 int
-ec_shd_full_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
-                   void *data)
+ec_shd_full_heal(xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
+                 void *data)
 {
-        struct subvol_healer *healer = data;
-        xlator_t             *this   = healer->this;
-        ec_t                 *ec     = NULL;
-        loc_t                loc    = {0};
-        int                  ret    = 0;
-
-        ec = this->private;
-        if (ec->xl_up_count <= ec->fragments) {
-                return -ENOTCONN;
-        }
-        if (!ec->shd.enabled)
-                return -EBUSY;
-
-        if (gf_uuid_is_null(entry->d_stat.ia_gfid)) {
-                /* It's possible that an entry has been removed just after
-                 * being seen in a directory but before getting its stat info.
-                 * In this case we'll receive a NULL gfid here. Since the file
-                 * doesn't exist anymore, we can safely ignore it. */
-                return 0;
-        }
+    struct subvol_healer *healer = data;
+    xlator_t *this = healer->this;
+    ec_t *ec = NULL;
+    loc_t loc = {0};
+    int ret = 0;
+
+    ec = this->private;
+    if (ec->xl_up_count <= ec->fragments) {
+        return -ENOTCONN;
+    }
+    if (!ec->shd.enabled)
+        return -EBUSY;
+
+    if (gf_uuid_is_null(entry->d_stat.ia_gfid)) {
+        /* It's possible that an entry has been removed just after
+         * being seen in a directory but before getting its stat info.
+         * In this case we'll receive a NULL gfid here. Since the file
+         * doesn't exist anymore, we can safely ignore it. */
+        return 0;
+    }
 
-        loc.parent = inode_ref (parent->inode);
-        loc.name   = entry->d_name;
-        gf_uuid_copy (loc.gfid, entry->d_stat.ia_gfid);
+    loc.parent = inode_ref(parent->inode);
+    loc.name = entry->d_name;
+    gf_uuid_copy(loc.gfid, entry->d_stat.ia_gfid);
 
-        /* If this fails with ENOENT/ESTALE index is stale */
-        ret = syncop_gfid_to_path (this->itable, subvol, loc.gfid,
-                                   (char **)&loc.path);
-        if (ret < 0)
-                goto out;
+    /* If this fails with ENOENT/ESTALE index is stale */
+    ret = syncop_gfid_to_path(this->itable, subvol, loc.gfid,
+                              (char **)&loc.path);
+    if (ret < 0)
+        goto out;
 
-        ret = syncop_inode_find (this, this, loc.gfid,
-                                 &loc.inode, NULL, NULL);
-        if (ret < 0)
-                goto out;
+    ret = syncop_inode_find(this, this, loc.gfid, &loc.inode, NULL, NULL);
+    if (ret < 0)
+        goto out;
 
-        ec_shd_selfheal (healer, healer->subvol, &loc);
+    ec_shd_selfheal(healer, healer->subvol, &loc);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        loc_wipe (&loc);
-        return ret;
+    loc_wipe(&loc);
+    return ret;
 }
 
 int
-ec_shd_full_sweep (struct subvol_healer *healer, inode_t *inode)
+ec_shd_full_sweep(struct subvol_healer *healer, inode_t *inode)
 {
-        ec_t           *ec  = NULL;
-        loc_t          loc  = {0};
-
-        ec = healer->this->private;
-        loc.inode = inode;
-        return syncop_ftw (ec->xl_list[healer->subvol], &loc,
-                           GF_CLIENT_PID_SELF_HEALD, healer,
-                           ec_shd_full_heal);
-}
+    ec_t *ec = NULL;
+    loc_t loc = {0};
 
+    ec = healer->this->private;
+    loc.inode = inode;
+    return syncop_ftw(ec->xl_list[healer->subvol], &loc,
+                      GF_CLIENT_PID_SELF_HEALD, healer, ec_shd_full_heal);
+}
 
 void *
-ec_shd_index_healer (void *data)
+ec_shd_index_healer(void *data)
 {
-        struct subvol_healer *healer = NULL;
-        xlator_t *this = NULL;
-
-        healer = data;
-        THIS = this = healer->this;
-        ec_t *ec = this->private;
-
-        for (;;) {
-                ec_shd_healer_wait (healer);
-
-                if (ec->xl_up_count > ec->fragments) {
-                        gf_msg_debug (this->name, 0,
-                                "starting index sweep on subvol %s",
-                                ec_subvol_name (this, healer->subvol));
-                        ec_shd_index_sweep (healer);
-                }
-                gf_msg_debug (this->name, 0,
-                        "finished index sweep on subvol %s",
-                        ec_subvol_name (this, healer->subvol));
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+
+    healer = data;
+    THIS = this = healer->this;
+    ec_t *ec = this->private;
+
+    for (;;) {
+        ec_shd_healer_wait(healer);
+
+        if (ec->xl_up_count > ec->fragments) {
+            gf_msg_debug(this->name, 0, "starting index sweep on subvol %s",
+                         ec_subvol_name(this, healer->subvol));
+            ec_shd_index_sweep(healer);
         }
+        gf_msg_debug(this->name, 0, "finished index sweep on subvol %s",
+                     ec_subvol_name(this, healer->subvol));
+    }
 
-        return NULL;
+    return NULL;
 }
 
-
 void *
-ec_shd_full_healer (void *data)
+ec_shd_full_healer(void *data)
 {
-        struct subvol_healer *healer = NULL;
-        xlator_t *this = NULL;
-        loc_t rootloc = {0};
-
-        int run = 0;
-
-        healer = data;
-        THIS = this = healer->this;
-        ec_t *ec = this->private;
-
-        rootloc.inode = this->itable->root;
-        for (;;) {
-                pthread_mutex_lock (&healer->mutex);
-                {
-                        run = __ec_shd_healer_wait (healer);
-                        if (!run)
-                                healer->running = _gf_false;
-                }
-                pthread_mutex_unlock (&healer->mutex);
-
-                if (!run)
-                        break;
-
-                if (ec->xl_up_count > ec->fragments) {
-                        gf_msg (this->name, GF_LOG_INFO, 0,
-                                EC_MSG_FULL_SWEEP_START,
-                                "starting full sweep on subvol %s",
-                                ec_subvol_name (this, healer->subvol));
-
-                        ec_shd_selfheal (healer, healer->subvol, &rootloc);
-                        ec_shd_full_sweep (healer, this->itable->root);
-                }
-
-                gf_msg (this->name, GF_LOG_INFO, 0,
-                        EC_MSG_FULL_SWEEP_STOP,
-                        "finished full sweep on subvol %s",
-                        ec_subvol_name (this, healer->subvol));
+    struct subvol_healer *healer = NULL;
+    xlator_t *this = NULL;
+    loc_t rootloc = {0};
+
+    int run = 0;
+
+    healer = data;
+    THIS = this = healer->this;
+    ec_t *ec = this->private;
+
+    rootloc.inode = this->itable->root;
+    for (;;) {
+        pthread_mutex_lock(&healer->mutex);
+        {
+            run = __ec_shd_healer_wait(healer);
+            if (!run)
+                healer->running = _gf_false;
         }
+        pthread_mutex_unlock(&healer->mutex);
 
-        return NULL;
-}
+        if (!run)
+            break;
+
+        if (ec->xl_up_count > ec->fragments) {
+            gf_msg(this->name, GF_LOG_INFO, 0, EC_MSG_FULL_SWEEP_START,
+                   "starting full sweep on subvol %s",
+                   ec_subvol_name(this, healer->subvol));
+
+            ec_shd_selfheal(healer, healer->subvol, &rootloc);
+            ec_shd_full_sweep(healer, this->itable->root);
+        }
+
+        gf_msg(this->name, GF_LOG_INFO, 0, EC_MSG_FULL_SWEEP_STOP,
+               "finished full sweep on subvol %s",
+               ec_subvol_name(this, healer->subvol));
+    }
 
+    return NULL;
+}
 
 int
-ec_shd_healer_init (xlator_t *this, struct subvol_healer *healer)
+ec_shd_healer_init(xlator_t *this, struct subvol_healer *healer)
 {
-        int ret = 0;
+    int ret = 0;
 
-        ret = pthread_mutex_init (&healer->mutex, NULL);
-        if (ret)
-                goto out;
+    ret = pthread_mutex_init(&healer->mutex, NULL);
+    if (ret)
+        goto out;
 
-        ret = pthread_cond_init (&healer->cond, NULL);
-        if (ret)
-                goto out;
+    ret = pthread_cond_init(&healer->cond, NULL);
+    if (ret)
+        goto out;
 
-        healer->this = this;
-        healer->running = _gf_false;
-        healer->rerun = _gf_false;
+    healer->this = this;
+    healer->running = _gf_false;
+    healer->rerun = _gf_false;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-ec_shd_healer_spawn (xlator_t *this, struct subvol_healer *healer,
-                      void *(threadfn)(void *))
+ec_shd_healer_spawn(xlator_t *this, struct subvol_healer *healer,
+                    void *(threadfn)(void *))
 {
-        int ret = 0;
-
-        pthread_mutex_lock (&healer->mutex);
-        {
-                if (healer->running) {
-                        pthread_cond_signal (&healer->cond);
-                } else {
-                        ret = gf_thread_create (&healer->thread, NULL,
-                                                threadfn, healer, "ecshd");
-                        if (ret)
-                                goto unlock;
-                        healer->running = 1;
-                }
-
-                healer->rerun = 1;
+    int ret = 0;
+
+    pthread_mutex_lock(&healer->mutex);
+    {
+        if (healer->running) {
+            pthread_cond_signal(&healer->cond);
+        } else {
+            ret = gf_thread_create(&healer->thread, NULL, threadfn, healer,
+                                   "ecshd");
+            if (ret)
+                goto unlock;
+            healer->running = 1;
         }
+
+        healer->rerun = 1;
+    }
 unlock:
-        pthread_mutex_unlock (&healer->mutex);
+    pthread_mutex_unlock(&healer->mutex);
 
-        return ret;
+    return ret;
 }
 
 int
-ec_shd_full_healer_spawn (xlator_t *this, int subvol)
+ec_shd_full_healer_spawn(xlator_t *this, int subvol)
 {
-        return ec_shd_healer_spawn (this, NTH_FULL_HEALER (this, subvol),
-                                    ec_shd_full_healer);
+    return ec_shd_healer_spawn(this, NTH_FULL_HEALER(this, subvol),
+                               ec_shd_full_healer);
 }
 
-
 int
-ec_shd_index_healer_spawn (xlator_t *this, int subvol)
+ec_shd_index_healer_spawn(xlator_t *this, int subvol)
 {
-        return ec_shd_healer_spawn (this, NTH_INDEX_HEALER (this, subvol),
-                                    ec_shd_index_healer);
+    return ec_shd_healer_spawn(this, NTH_INDEX_HEALER(this, subvol),
+                               ec_shd_index_healer);
 }
 
 void
 ec_shd_index_healer_wake(ec_t *ec)
 {
-        int32_t i;
+    int32_t i;
 
-        for (i = 0; i < ec->nodes; i++) {
-                if (((ec->xl_up >> i) & 1) != 0) {
-                        ec_shd_index_healer_spawn(ec->xl, i);
-                }
+    for (i = 0; i < ec->nodes; i++) {
+        if (((ec->xl_up >> i) & 1) != 0) {
+            ec_shd_index_healer_spawn(ec->xl, i);
         }
+    }
 }
 
 int
-ec_selfheal_daemon_init (xlator_t *this)
+ec_selfheal_daemon_init(xlator_t *this)
 {
-        ec_t    *ec = NULL;
-        ec_self_heald_t *shd = NULL;
-        int ret = -1;
-        int i = 0;
-
-        ec = this->private;
-        shd = &ec->shd;
-
-        shd->index_healers = GF_CALLOC (sizeof(*shd->index_healers),
-                                        ec->nodes,
-                                        ec_mt_subvol_healer_t);
-        if (!shd->index_healers)
-                goto out;
-
-        for (i = 0; i < ec->nodes; i++) {
-                shd->index_healers[i].subvol = i;
-                ret = ec_shd_healer_init (this, &shd->index_healers[i]);
-                if (ret)
-                        goto out;
-        }
+    ec_t *ec = NULL;
+    ec_self_heald_t *shd = NULL;
+    int ret = -1;
+    int i = 0;
+
+    ec = this->private;
+    shd = &ec->shd;
+
+    shd->index_healers = GF_CALLOC(sizeof(*shd->index_healers), ec->nodes,
+                                   ec_mt_subvol_healer_t);
+    if (!shd->index_healers)
+        goto out;
+
+    for (i = 0; i < ec->nodes; i++) {
+        shd->index_healers[i].subvol = i;
+        ret = ec_shd_healer_init(this, &shd->index_healers[i]);
+        if (ret)
+            goto out;
+    }
 
-        shd->full_healers = GF_CALLOC (sizeof(*shd->full_healers),
-                                       ec->nodes,
-                                       ec_mt_subvol_healer_t);
-        if (!shd->full_healers)
-                goto out;
-
-        for (i = 0; i < ec->nodes; i++) {
-                shd->full_healers[i].subvol = i;
-                ret = ec_shd_healer_init (this, &shd->full_healers[i]);
-                if (ret)
-                        goto out;
-        }
+    shd->full_healers = GF_CALLOC(sizeof(*shd->full_healers), ec->nodes,
+                                  ec_mt_subvol_healer_t);
+    if (!shd->full_healers)
+        goto out;
+
+    for (i = 0; i < ec->nodes; i++) {
+        shd->full_healers[i].subvol = i;
+        ret = ec_shd_healer_init(this, &shd->full_healers[i]);
+        if (ret)
+            goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-ec_heal_op (xlator_t *this, dict_t *output, gf_xl_afr_op_t op, int xl_id)
+ec_heal_op(xlator_t *this, dict_t *output, gf_xl_afr_op_t op, int xl_id)
 {
-        char key[64] = {0};
-        int op_ret = 0;
-        ec_t *ec = NULL;
-        int     i = 0;
-        GF_UNUSED int     ret = 0;
-
-        ec = this->private;
-
-        op_ret = -1;
-        for (i = 0; i < ec->nodes; i++) {
-                snprintf (key, sizeof (key), "%d-%d-status", xl_id, i);
-
-                if (((ec->xl_up >> i) & 1) == 0) {
-                        ret = dict_set_str (output, key, "Brick is not connected");
-                } else if (!ec->up) {
-                        ret = dict_set_str (output, key,
-                                            "Disperse subvolume is not up");
-                } else if (!ec_shd_is_subvol_local (this, i)) {
-                        ret = dict_set_str (output, key, "Brick is remote");
-                } else {
-                        ret = dict_set_str (output, key, "Started self-heal");
-                        if (op == GF_SHD_OP_HEAL_FULL) {
-                                ec_shd_full_healer_spawn (this, i);
-                        } else if (op == GF_SHD_OP_HEAL_INDEX) {
-                                ec_shd_index_healer_spawn (this, i);
-                        }
-                        op_ret = 0;
-                }
+    char key[64] = {0};
+    int op_ret = 0;
+    ec_t *ec = NULL;
+    int i = 0;
+    GF_UNUSED int ret = 0;
+
+    ec = this->private;
+
+    op_ret = -1;
+    for (i = 0; i < ec->nodes; i++) {
+        snprintf(key, sizeof(key), "%d-%d-status", xl_id, i);
+
+        if (((ec->xl_up >> i) & 1) == 0) {
+            ret = dict_set_str(output, key, "Brick is not connected");
+        } else if (!ec->up) {
+            ret = dict_set_str(output, key, "Disperse subvolume is not up");
+        } else if (!ec_shd_is_subvol_local(this, i)) {
+            ret = dict_set_str(output, key, "Brick is remote");
+        } else {
+            ret = dict_set_str(output, key, "Started self-heal");
+            if (op == GF_SHD_OP_HEAL_FULL) {
+                ec_shd_full_healer_spawn(this, i);
+            } else if (op == GF_SHD_OP_HEAL_INDEX) {
+                ec_shd_index_healer_spawn(this, i);
+            }
+            op_ret = 0;
         }
-        return op_ret;
+    }
+    return op_ret;
 }
 
 int
-ec_xl_op (xlator_t *this, dict_t *input, dict_t *output)
+ec_xl_op(xlator_t *this, dict_t *input, dict_t *output)
 {
-        gf_xl_afr_op_t op     = GF_SHD_OP_INVALID;
-        int            ret    = 0;
-        int            xl_id  = 0;
+    gf_xl_afr_op_t op = GF_SHD_OP_INVALID;
+    int ret = 0;
+    int xl_id = 0;
 
-        ret = dict_get_int32 (input, "xl-op", (int32_t *)&op);
-        if (ret)
-                goto out;
+    ret = dict_get_int32(input, "xl-op", (int32_t *)&op);
+    if (ret)
+        goto out;
 
-        ret = dict_get_int32 (input, this->name, &xl_id);
-        if (ret)
-                goto out;
+    ret = dict_get_int32(input, this->name, &xl_id);
+    if (ret)
+        goto out;
 
-        ret = dict_set_int32 (output, this->name, xl_id);
-        if (ret)
-                goto out;
+    ret = dict_set_int32(output, this->name, xl_id);
+    if (ret)
+        goto out;
 
-        switch (op) {
+    switch (op) {
         case GF_SHD_OP_HEAL_FULL:
-                ret = ec_heal_op (this, output, op, xl_id);
-                break;
+            ret = ec_heal_op(this, output, op, xl_id);
+            break;
 
         case GF_SHD_OP_HEAL_INDEX:
-                ret = ec_heal_op (this, output, op, xl_id);
-                break;
+            ret = ec_heal_op(this, output, op, xl_id);
+            break;
 
         default:
-                ret = -1;
-                break;
-        }
+            ret = -1;
+            break;
+    }
 out:
-        dict_del (output, this->name);
-        return ret;
+    dict_del(output, this->name);
+    return ret;
 }
diff --git a/xlators/cluster/ec/src/ec-helpers.c b/xlators/cluster/ec/src/ec-helpers.c
index ff3558def86..dec39b9d2aa 100644
--- a/xlators/cluster/ec/src/ec-helpers.c
+++ b/xlators/cluster/ec/src/ec-helpers.c
@@ -19,25 +19,20 @@
 #include "ec-method.h"
 #include "ec-helpers.h"
 
-static const char * ec_fop_list[] =
-{
-    [-EC_FOP_HEAL] = "HEAL"
-};
+static const char *ec_fop_list[] = {[-EC_FOP_HEAL] = "HEAL"};
 
-const char * ec_bin(char * str, size_t size, uint64_t value, int32_t digits)
+const char *
+ec_bin(char *str, size_t size, uint64_t value, int32_t digits)
 {
     str += size;
 
-    if (size-- < 1)
-    {
+    if (size-- < 1) {
         goto failed;
     }
     *--str = 0;
 
-    while ((value != 0) || (digits > 0))
-    {
-        if (size-- < 1)
-        {
+    while ((value != 0) || (digits > 0)) {
+        if (size-- < 1) {
             goto failed;
         }
         *--str = '0' + (value & 1);
@@ -51,21 +46,22 @@ failed:
     return "<buffer too small>";
 }
 
-const char * ec_fop_name(int32_t id)
+const char *
+ec_fop_name(int32_t id)
 {
-    if (id >= 0)
-    {
+    if (id >= 0) {
         return gf_fop_list[id];
     }
 
     return ec_fop_list[-id];
 }
 
-void ec_trace(const char * event, ec_fop_data_t * fop, const char * fmt, ...)
+void
+ec_trace(const char *event, ec_fop_data_t *fop, const char *fmt, ...)
 {
     char str1[32], str2[32], str3[32];
-    char * msg;
-    ec_t * ec = fop->xl->private;
+    char *msg;
+    ec_t *ec = fop->xl->private;
     va_list args;
     int32_t ret;
 
@@ -73,28 +69,28 @@ void ec_trace(const char * event, ec_fop_data_t * fop, const char * fmt, ...)
     ret = vasprintf(&msg, fmt, args);
     va_end(args);
 
-    if (ret < 0)
-    {
+    if (ret < 0) {
         msg = "<memory allocation error>";
     }
 
-    gf_msg_trace ("ec", 0, "%s(%s) %p(%p) [refs=%d, winds=%d, jobs=%d] "
-                               "frame=%p/%p, min/exp=%d/%d, err=%d state=%d "
-                               "{%s:%s:%s} %s",
-           event, ec_fop_name(fop->id), fop, fop->parent, fop->refs,
-           fop->winds, fop->jobs, fop->req_frame, fop->frame, fop->minimum,
-           fop->expected, fop->error, fop->state,
-           ec_bin(str1, sizeof(str1), fop->mask, ec->nodes),
-           ec_bin(str2, sizeof(str2), fop->remaining, ec->nodes),
-           ec_bin(str3, sizeof(str3), fop->good, ec->nodes), msg);
+    gf_msg_trace("ec", 0,
+                 "%s(%s) %p(%p) [refs=%d, winds=%d, jobs=%d] "
+                 "frame=%p/%p, min/exp=%d/%d, err=%d state=%d "
+                 "{%s:%s:%s} %s",
+                 event, ec_fop_name(fop->id), fop, fop->parent, fop->refs,
+                 fop->winds, fop->jobs, fop->req_frame, fop->frame,
+                 fop->minimum, fop->expected, fop->error, fop->state,
+                 ec_bin(str1, sizeof(str1), fop->mask, ec->nodes),
+                 ec_bin(str2, sizeof(str2), fop->remaining, ec->nodes),
+                 ec_bin(str3, sizeof(str3), fop->good, ec->nodes), msg);
 
-    if (ret >= 0)
-    {
+    if (ret >= 0) {
         free(msg);
     }
 }
 
-int32_t ec_bits_consume(uint64_t * n)
+int32_t
+ec_bits_consume(uint64_t *n)
 {
     uint64_t tmp;
 
@@ -105,21 +101,18 @@ int32_t ec_bits_consume(uint64_t * n)
     return gf_bits_index(tmp);
 }
 
-size_t ec_iov_copy_to(void * dst, struct iovec * vector, int32_t count,
-                      off_t offset, size_t size)
+size_t
+ec_iov_copy_to(void *dst, struct iovec *vector, int32_t count, off_t offset,
+               size_t size)
 {
     int32_t i = 0;
     size_t total = 0, len = 0;
 
-    while (i < count)
-    {
-        if (offset < vector[i].iov_len)
-        {
-            while ((i < count) && (size > 0))
-            {
+    while (i < count) {
+        if (offset < vector[i].iov_len) {
+            while ((i < count) && (size > 0)) {
                 len = size;
-                if (len > vector[i].iov_len - offset)
-                {
+                if (len > vector[i].iov_len - offset) {
                     len = vector[i].iov_len - offset;
                 }
                 memcpy(dst, vector[i++].iov_base + offset, len);
@@ -139,15 +132,15 @@ size_t ec_iov_copy_to(void * dst, struct iovec * vector, int32_t count,
     return total;
 }
 
-int32_t ec_buffer_alloc(xlator_t *xl, size_t size, struct iobref **piobref,
-                        void **ptr)
+int32_t
+ec_buffer_alloc(xlator_t *xl, size_t size, struct iobref **piobref, void **ptr)
 {
     struct iobref *iobref = NULL;
     struct iobuf *iobuf = NULL;
     int32_t ret = -ENOMEM;
 
-    iobuf = iobuf_get_page_aligned (xl->ctx->iobuf_pool, size,
-                                    EC_METHOD_WORD_SIZE);
+    iobuf = iobuf_get_page_aligned(xl->ctx->iobuf_pool, size,
+                                   EC_METHOD_WORD_SIZE);
     if (iobuf == NULL) {
         goto out;
     }
@@ -186,12 +179,12 @@ out:
     return ret;
 }
 
-int32_t ec_dict_set_array(dict_t *dict, char *key, uint64_t value[],
-                          int32_t size)
+int32_t
+ec_dict_set_array(dict_t *dict, char *key, uint64_t value[], int32_t size)
 {
-    int         ret = -1;
-    uint64_t   *ptr = NULL;
-    int32_t     vindex;
+    int ret = -1;
+    uint64_t *ptr = NULL;
+    int32_t vindex;
 
     if (value == NULL) {
         return -EINVAL;
@@ -202,19 +195,18 @@ int32_t ec_dict_set_array(dict_t *dict, char *key, uint64_t value[],
         return -ENOMEM;
     }
     for (vindex = 0; vindex < size; vindex++) {
-         ptr[vindex] = hton64(value[vindex]);
+        ptr[vindex] = hton64(value[vindex]);
     }
     ret = dict_set_bin(dict, key, ptr, sizeof(uint64_t) * size);
     if (ret)
-         GF_FREE (ptr);
+        GF_FREE(ptr);
     return ret;
 }
 
-
 int32_t
-ec_dict_get_array (dict_t *dict, char *key, uint64_t value[], int32_t size)
+ec_dict_get_array(dict_t *dict, char *key, uint64_t value[], int32_t size)
 {
-    void    *ptr;
+    void *ptr;
     int32_t len;
     int32_t vindex;
     int32_t old_size = 0;
@@ -228,43 +220,43 @@ ec_dict_get_array (dict_t *dict, char *key, uint64_t value[], int32_t size)
         return err;
     }
 
-    if (len > (size * sizeof(uint64_t)) || (len % sizeof (uint64_t))) {
+    if (len > (size * sizeof(uint64_t)) || (len % sizeof(uint64_t))) {
         return -EINVAL;
     }
 
     /* 3.6 version ec would have stored version in 64 bit. In that case treat
      * metadata versions same as data*/
-    old_size = min (size, len/sizeof(uint64_t));
+    old_size = min(size, len / sizeof(uint64_t));
     for (vindex = 0; vindex < old_size; vindex++) {
-         value[vindex] = ntoh64(*((uint64_t *)ptr + vindex));
+        value[vindex] = ntoh64(*((uint64_t *)ptr + vindex));
     }
 
     if (old_size < size) {
-            for (vindex = old_size; vindex < size; vindex++) {
-                 value[vindex] = value[old_size-1];
-            }
+        for (vindex = old_size; vindex < size; vindex++) {
+            value[vindex] = value[old_size - 1];
+        }
     }
 
     return 0;
 }
 
 int32_t
-ec_dict_del_array (dict_t *dict, char *key, uint64_t value[], int32_t size)
+ec_dict_del_array(dict_t *dict, char *key, uint64_t value[], int32_t size)
 {
     int ret = 0;
 
-    ret = ec_dict_get_array (dict, key, value, size);
+    ret = ec_dict_get_array(dict, key, value, size);
     if (ret == 0)
-            dict_del(dict, key);
+        dict_del(dict, key);
 
     return ret;
 }
 
-
-int32_t ec_dict_set_number(dict_t * dict, char * key, uint64_t value)
+int32_t
+ec_dict_set_number(dict_t *dict, char *key, uint64_t value)
 {
-    int        ret = -1;
-    uint64_t * ptr;
+    int ret = -1;
+    uint64_t *ptr;
 
     ptr = GF_MALLOC(sizeof(value), gf_common_mt_char);
     if (ptr == NULL) {
@@ -275,14 +267,15 @@ int32_t ec_dict_set_number(dict_t * dict, char * key, uint64_t value)
 
     ret = dict_set_bin(dict, key, ptr, sizeof(value));
     if (ret)
-        GF_FREE (ptr);
+        GF_FREE(ptr);
 
     return ret;
 }
 
-int32_t ec_dict_del_number(dict_t * dict, char * key, uint64_t * value)
+int32_t
+ec_dict_del_number(dict_t *dict, char *key, uint64_t *value)
 {
-    void * ptr;
+    void *ptr;
     int32_t len, err;
 
     if (dict == NULL) {
@@ -303,24 +296,23 @@ int32_t ec_dict_del_number(dict_t * dict, char * key, uint64_t * value)
     return 0;
 }
 
-int32_t ec_dict_set_config(dict_t * dict, char * key, ec_config_t * config)
+int32_t
+ec_dict_set_config(dict_t *dict, char *key, ec_config_t *config)
 {
     int ret = -1;
-    uint64_t * ptr, data;
+    uint64_t *ptr, data;
 
-    if (config->version > EC_CONFIG_VERSION)
-    {
-        gf_msg ("ec", GF_LOG_ERROR, EINVAL,
-                EC_MSG_UNSUPPORTED_VERSION,
-                "Trying to store an unsupported config "
-                "version (%u)", config->version);
+    if (config->version > EC_CONFIG_VERSION) {
+        gf_msg("ec", GF_LOG_ERROR, EINVAL, EC_MSG_UNSUPPORTED_VERSION,
+               "Trying to store an unsupported config "
+               "version (%u)",
+               config->version);
 
         return -EINVAL;
     }
 
     ptr = GF_MALLOC(sizeof(uint64_t), gf_common_mt_char);
-    if (ptr == NULL)
-    {
+    if (ptr == NULL) {
         return -ENOMEM;
     }
 
@@ -335,14 +327,15 @@ int32_t ec_dict_set_config(dict_t * dict, char * key, ec_config_t * config)
 
     ret = dict_set_bin(dict, key, ptr, sizeof(uint64_t));
     if (ret)
-        GF_FREE (ptr);
+        GF_FREE(ptr);
 
     return ret;
 }
 
-int32_t ec_dict_del_config(dict_t * dict, char * key, ec_config_t * config)
+int32_t
+ec_dict_del_config(dict_t *dict, char *key, ec_config_t *config)
 {
-    void * ptr;
+    void *ptr;
     uint64_t data;
     int32_t len, err;
 
@@ -372,12 +365,9 @@ int32_t ec_dict_del_config(dict_t * dict, char * key, ec_config_t * config)
     }
 
     config->version = (data >> 56) & 0xff;
-    if (config->version > EC_CONFIG_VERSION)
-    {
-        gf_msg ("ec", GF_LOG_ERROR, EINVAL,
-                EC_MSG_UNSUPPORTED_VERSION,
-                "Found an unsupported config version (%u)",
-                config->version);
+    if (config->version > EC_CONFIG_VERSION) {
+        gf_msg("ec", GF_LOG_ERROR, EINVAL, EC_MSG_UNSUPPORTED_VERSION,
+               "Found an unsupported config version (%u)", config->version);
 
         return -EINVAL;
     }
@@ -393,7 +383,8 @@ int32_t ec_dict_del_config(dict_t * dict, char * key, ec_config_t * config)
     return 0;
 }
 
-gf_boolean_t ec_loc_gfid_check(xlator_t *xl, uuid_t dst, uuid_t src)
+gf_boolean_t
+ec_loc_gfid_check(xlator_t *xl, uuid_t dst, uuid_t src)
 {
     if (gf_uuid_is_null(src)) {
         return _gf_true;
@@ -406,9 +397,8 @@ gf_boolean_t ec_loc_gfid_check(xlator_t *xl, uuid_t dst, uuid_t src)
     }
 
     if (gf_uuid_compare(dst, src) != 0) {
-        gf_msg (xl->name, GF_LOG_WARNING, 0,
-                EC_MSG_GFID_MISMATCH,
-                "Mismatching GFID's in loc");
+        gf_msg(xl->name, GF_LOG_WARNING, 0, EC_MSG_GFID_MISMATCH,
+               "Mismatching GFID's in loc");
 
         return _gf_false;
     }
@@ -416,7 +406,8 @@ gf_boolean_t ec_loc_gfid_check(xlator_t *xl, uuid_t dst, uuid_t src)
     return _gf_true;
 }
 
-int32_t ec_loc_setup_inode(xlator_t *xl, inode_table_t *table, loc_t *loc)
+int32_t
+ec_loc_setup_inode(xlator_t *xl, inode_table_t *table, loc_t *loc)
 {
     int32_t ret = -EINVAL;
 
@@ -427,7 +418,7 @@ int32_t ec_loc_setup_inode(xlator_t *xl, inode_table_t *table, loc_t *loc)
     } else if (table != NULL) {
         if (!gf_uuid_is_null(loc->gfid)) {
             loc->inode = inode_find(table, loc->gfid);
-        } else if (loc->path && strchr (loc->path, '/')) {
+        } else if (loc->path && strchr(loc->path, '/')) {
             loc->inode = inode_resolve(table, (char *)loc->path);
         }
     }
@@ -438,7 +429,8 @@ out:
     return ret;
 }
 
-int32_t ec_loc_setup_parent(xlator_t *xl, inode_table_t *table, loc_t *loc)
+int32_t
+ec_loc_setup_parent(xlator_t *xl, inode_table_t *table, loc_t *loc)
 {
     char *path, *parent;
     int32_t ret = -EINVAL;
@@ -450,13 +442,11 @@ int32_t ec_loc_setup_parent(xlator_t *xl, inode_table_t *table, loc_t *loc)
     } else if (table != NULL) {
         if (!gf_uuid_is_null(loc->pargfid)) {
             loc->parent = inode_find(table, loc->pargfid);
-        } else if (loc->path && strchr (loc->path, '/')) {
+        } else if (loc->path && strchr(loc->path, '/')) {
             path = gf_strdup(loc->path);
             if (path == NULL) {
-                gf_msg (xl->name, GF_LOG_ERROR, ENOMEM,
-                        EC_MSG_NO_MEMORY,
-                        "Unable to duplicate path '%s'",
-                        loc->path);
+                gf_msg(xl->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                       "Unable to duplicate path '%s'", loc->path);
 
                 ret = -ENOMEM;
 
@@ -483,7 +473,8 @@ out:
     return ret;
 }
 
-int32_t ec_loc_setup_path(xlator_t *xl, loc_t *loc)
+int32_t
+ec_loc_setup_path(xlator_t *xl, loc_t *loc)
 {
     uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
     char *name;
@@ -513,10 +504,8 @@ int32_t ec_loc_setup_path(xlator_t *xl, loc_t *loc)
 
         if (loc->name != NULL) {
             if (strcmp(loc->name, name) != 0) {
-                gf_msg (xl->name, GF_LOG_ERROR, EINVAL,
-                        EC_MSG_INVALID_LOC_NAME,
-                        "Invalid name '%s' in loc",
-                        loc->name);
+                gf_msg(xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_LOC_NAME,
+                       "Invalid name '%s' in loc", loc->name);
 
                 goto out;
             }
@@ -531,7 +520,8 @@ out:
     return ret;
 }
 
-int32_t ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
+int32_t
+ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
 {
     inode_table_t *table = NULL;
     char *str = NULL;
@@ -548,24 +538,20 @@ int32_t ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
     if (!gf_uuid_is_null(loc->pargfid)) {
         gf_uuid_copy(parent->gfid, loc->pargfid);
     }
-    if (loc->path && strchr (loc->path, '/')) {
+    if (loc->path && strchr(loc->path, '/')) {
         str = gf_strdup(loc->path);
         if (str == NULL) {
-                gf_msg (xl->name, GF_LOG_ERROR, ENOMEM,
-                        EC_MSG_NO_MEMORY,
-                        "Unable to duplicate path '%s'",
-                        loc->path);
+            gf_msg(xl->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Unable to duplicate path '%s'", loc->path);
 
-                goto out;
+            goto out;
         }
         parent->path = gf_strdup(dirname(str));
         if (parent->path == NULL) {
-                gf_msg (xl->name, GF_LOG_ERROR, ENOMEM,
-                        EC_MSG_NO_MEMORY,
-                        "Unable to duplicate path '%s'",
-                        dirname(str));
+            gf_msg(xl->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Unable to duplicate path '%s'", dirname(str));
 
-                goto out;
+            goto out;
         }
     }
 
@@ -582,9 +568,8 @@ int32_t ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
 
     if ((parent->inode == NULL) && (parent->path == NULL) &&
         gf_uuid_is_null(parent->gfid)) {
-        gf_msg (xl->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_LOC_PARENT_INODE_MISSING,
-                "Parent inode missing for loc_t");
+        gf_msg(xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_LOC_PARENT_INODE_MISSING,
+               "Parent inode missing for loc_t");
 
         ret = -EINVAL;
 
@@ -603,8 +588,8 @@ out:
     return ret;
 }
 
-int32_t ec_loc_update(xlator_t *xl, loc_t *loc, inode_t *inode,
-                      struct iatt *iatt)
+int32_t
+ec_loc_update(xlator_t *xl, loc_t *loc, inode_t *inode, struct iatt *iatt)
 {
     inode_table_t *table = NULL;
     int32_t ret = -EINVAL;
@@ -645,9 +630,10 @@ out:
     return ret;
 }
 
-int32_t ec_loc_from_fd(xlator_t * xl, loc_t * loc, fd_t * fd)
+int32_t
+ec_loc_from_fd(xlator_t *xl, loc_t *loc, fd_t *fd)
 {
-    ec_fd_t * ctx;
+    ec_fd_t *ctx;
     int32_t ret = -ENOMEM;
 
     memset(loc, 0, sizeof(*loc));
@@ -672,7 +658,8 @@ out:
     return ret;
 }
 
-int32_t ec_loc_from_loc(xlator_t * xl, loc_t * dst, loc_t * src)
+int32_t
+ec_loc_from_loc(xlator_t *xl, loc_t *dst, loc_t *src)
 {
     int32_t ret = -ENOMEM;
 
@@ -695,62 +682,61 @@ out:
     return ret;
 }
 
-void ec_owner_set(call_frame_t * frame, void * owner)
+void
+ec_owner_set(call_frame_t *frame, void *owner)
 {
     set_lk_owner_from_ptr(&frame->root->lk_owner, owner);
 }
 
-void ec_owner_copy(call_frame_t *frame, gf_lkowner_t *owner)
+void
+ec_owner_copy(call_frame_t *frame, gf_lkowner_t *owner)
 {
-    lk_owner_copy (&frame->root->lk_owner, owner);
+    lk_owner_copy(&frame->root->lk_owner, owner);
 }
 
 static void
-ec_stripe_cache_init (ec_t *ec, ec_inode_t *ctx)
+ec_stripe_cache_init(ec_t *ec, ec_inode_t *ctx)
 {
-        ec_stripe_list_t *stripe_cache = NULL;
+    ec_stripe_list_t *stripe_cache = NULL;
 
-        stripe_cache = &(ctx->stripe_cache);
-        if (stripe_cache->max == 0) {
-                stripe_cache->max = ec->stripe_cache;
-        }
+    stripe_cache = &(ctx->stripe_cache);
+    if (stripe_cache->max == 0) {
+        stripe_cache->max = ec->stripe_cache;
+    }
 }
 
-ec_inode_t * __ec_inode_get(inode_t * inode, xlator_t * xl)
+ec_inode_t *
+__ec_inode_get(inode_t *inode, xlator_t *xl)
 {
-    ec_inode_t * ctx = NULL;
+    ec_inode_t *ctx = NULL;
     uint64_t value = 0;
 
-    if ((__inode_ctx_get(inode, xl, &value) != 0) || (value == 0))
-    {
+    if ((__inode_ctx_get(inode, xl, &value) != 0) || (value == 0)) {
         ctx = GF_MALLOC(sizeof(*ctx), ec_mt_ec_inode_t);
-        if (ctx != NULL)
-        {
+        if (ctx != NULL) {
             memset(ctx, 0, sizeof(*ctx));
             INIT_LIST_HEAD(&ctx->heal);
             INIT_LIST_HEAD(&ctx->stripe_cache.lru);
             value = (uint64_t)(uintptr_t)ctx;
-            if (__inode_ctx_set(inode, xl, &value) != 0)
-            {
+            if (__inode_ctx_set(inode, xl, &value) != 0) {
                 GF_FREE(ctx);
 
                 return NULL;
             }
         }
-    }
-    else
-    {
+    } else {
         ctx = (ec_inode_t *)(uintptr_t)value;
     }
     if (ctx)
-        ec_stripe_cache_init (xl->private, ctx);
+        ec_stripe_cache_init(xl->private, ctx);
 
     return ctx;
 }
 
-ec_inode_t * ec_inode_get(inode_t * inode, xlator_t * xl)
+ec_inode_t *
+ec_inode_get(inode_t *inode, xlator_t *xl)
 {
-    ec_inode_t * ctx = NULL;
+    ec_inode_t *ctx = NULL;
 
     LOCK(&inode->lock);
 
@@ -761,30 +747,31 @@ ec_inode_t * ec_inode_get(inode_t * inode, xlator_t * xl)
     return ctx;
 }
 
-ec_fd_t * __ec_fd_get(fd_t * fd, xlator_t * xl)
+ec_fd_t *
+__ec_fd_get(fd_t *fd, xlator_t *xl)
 {
     int i = 0;
-    ec_fd_t * ctx = NULL;
+    ec_fd_t *ctx = NULL;
     uint64_t value = 0;
     ec_t *ec = xl->private;
 
     if ((__fd_ctx_get(fd, xl, &value) != 0) || (value == 0)) {
-        ctx = GF_MALLOC(sizeof(*ctx) + (sizeof (ec_fd_status_t) * ec->nodes),
+        ctx = GF_MALLOC(sizeof(*ctx) + (sizeof(ec_fd_status_t) * ec->nodes),
                         ec_mt_ec_fd_t);
         if (ctx != NULL) {
             memset(ctx, 0, sizeof(*ctx));
 
             for (i = 0; i < ec->nodes; i++) {
-                if (fd_is_anonymous (fd)) {
-                        ctx->fd_status[i] = EC_FD_OPENED;
+                if (fd_is_anonymous(fd)) {
+                    ctx->fd_status[i] = EC_FD_OPENED;
                 } else {
-                        ctx->fd_status[i] = EC_FD_NOT_OPENED;
+                    ctx->fd_status[i] = EC_FD_NOT_OPENED;
                 }
             }
 
             value = (uint64_t)(uintptr_t)ctx;
             if (__fd_ctx_set(fd, xl, value) != 0) {
-                GF_FREE (ctx);
+                GF_FREE(ctx);
                 return NULL;
             }
         }
@@ -803,9 +790,10 @@ ec_fd_t * __ec_fd_get(fd_t * fd, xlator_t * xl)
     return ctx;
 }
 
-ec_fd_t * ec_fd_get(fd_t * fd, xlator_t * xl)
+ec_fd_t *
+ec_fd_get(fd_t *fd, xlator_t *xl)
 {
-    ec_fd_t * ctx = NULL;
+    ec_fd_t *ctx = NULL;
 
     LOCK(&fd->lock);
 
@@ -817,37 +805,36 @@ ec_fd_t * ec_fd_get(fd_t * fd, xlator_t * xl)
 }
 
 gf_boolean_t
-ec_is_internal_xattr (dict_t *dict, char *key, data_t *value, void *data)
+ec_is_internal_xattr(dict_t *dict, char *key, data_t *value, void *data)
 {
-        if (key &&
-            (strncmp (key, EC_XATTR_PREFIX, SLEN (EC_XATTR_PREFIX)) == 0))
-                return _gf_true;
+    if (key && (strncmp(key, EC_XATTR_PREFIX, SLEN(EC_XATTR_PREFIX)) == 0))
+        return _gf_true;
 
-        return _gf_false;
+    return _gf_false;
 }
 
 void
-ec_filter_internal_xattrs (dict_t *xattr)
+ec_filter_internal_xattrs(dict_t *xattr)
 {
-        dict_foreach_match (xattr, ec_is_internal_xattr, NULL,
-                            dict_remove_foreach_fn, NULL);
+    dict_foreach_match(xattr, ec_is_internal_xattr, NULL,
+                       dict_remove_foreach_fn, NULL);
 }
 
 gf_boolean_t
-ec_is_data_fop (glusterfs_fop_t fop)
+ec_is_data_fop(glusterfs_fop_t fop)
 {
-        switch (fop) {
+    switch (fop) {
         case GF_FOP_WRITE:
         case GF_FOP_TRUNCATE:
         case GF_FOP_FTRUNCATE:
         case GF_FOP_FALLOCATE:
         case GF_FOP_DISCARD:
         case GF_FOP_ZEROFILL:
-                return _gf_true;
+            return _gf_true;
         default:
-                return _gf_false;
-        }
-        return _gf_false;
+            return _gf_false;
+    }
+    return _gf_false;
 }
 /*
 gf_boolean_t
diff --git a/xlators/cluster/ec/src/ec-inode-read.c b/xlators/cluster/ec/src/ec-inode-read.c
index 30d76371da6..7a8b174bbed 100644
--- a/xlators/cluster/ec/src/ec-inode-read.c
+++ b/xlators/cluster/ec/src/ec-inode-read.c
@@ -21,8 +21,9 @@
 
 /* FOP: access */
 
-int32_t ec_access_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                      int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, dict_t *xdata)
 {
     ec_fop_data_t *fop = NULL;
     ec_cbk_data_t *cbk = NULL;
@@ -35,27 +36,27 @@ int32_t ec_access_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-    cbk = ec_cbk_data_allocate (frame, this, fop, GF_FOP_ACCESS,
-                                idx, op_ret, op_errno);
+    cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_ACCESS, idx, op_ret,
+                               op_errno);
     if (cbk) {
         if (xdata)
-               cbk->xdata = dict_ref (xdata);
-        ec_combine (cbk, NULL);
+            cbk->xdata = dict_ref(xdata);
+        ec_combine(cbk, NULL);
     }
 
 out:
-    if (fop != NULL)
-    {
-        ec_complete (fop);
+    if (fop != NULL) {
+        ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_access(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_access(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -67,19 +68,19 @@ void ec_wind_access(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 int32_t
 ec_manager_access(ec_fop_data_t *fop, int32_t state)
 {
-        ec_cbk_data_t *cbk = NULL;
+    ec_cbk_data_t *cbk = NULL;
 
-        switch (state) {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_inode (fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                   LLONG_MAX);
-            ec_lock (fop);
+            ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
+                                  LLONG_MAX);
+            ec_lock(fop);
 
             return EC_STATE_DISPATCH;
 
         case EC_STATE_DISPATCH:
-            ec_dispatch_one (fop);
+            ec_dispatch_one(fop);
 
             return EC_STATE_PREPARE_ANSWER;
 
@@ -92,12 +93,11 @@ ec_manager_access(ec_fop_data_t *fop, int32_t state)
 
         case EC_STATE_REPORT:
             cbk = fop->answer;
-            GF_ASSERT (cbk);
+            GF_ASSERT(cbk);
             if (fop->cbks.access != NULL) {
                 if (cbk) {
-                    fop->cbks.access(fop->req_frame, fop, fop->xl,
-                                     cbk->op_ret, cbk->op_errno,
-                                     cbk->xdata);
+                    fop->cbks.access(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                     cbk->op_errno, cbk->xdata);
                 }
             }
             return EC_STATE_LOCK_REUSE;
@@ -108,8 +108,8 @@ ec_manager_access(ec_fop_data_t *fop, int32_t state)
         case -EC_STATE_PREPARE_ANSWER:
         case -EC_STATE_REPORT:
             if (fop->cbks.access != NULL) {
-                fop->cbks.access(fop->req_frame, fop, fop->xl, -1,
-                                 fop->error, NULL);
+                fop->cbks.access(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                 NULL);
             }
             return EC_STATE_LOCK_REUSE;
 
@@ -126,24 +126,23 @@ ec_manager_access(ec_fop_data_t *fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
-        }
+    }
 }
 
-void ec_access(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_access_cbk_t func, void * data,
-               loc_t * loc, int32_t mask, dict_t * xdata)
+void
+ec_access(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_access_cbk_t func, void *data, loc_t *loc,
+          int32_t mask, dict_t *xdata)
 {
-    ec_cbk_t callback = { .access = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.access = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(ACCESS) %p", frame);
+    gf_msg_trace("ec", 0, "EC(ACCESS) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -160,9 +159,8 @@ void ec_access(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -170,10 +168,9 @@ void ec_access(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -191,14 +188,13 @@ out:
 
 /* FOP: getxattr */
 
-int32_t ec_combine_getxattr(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                            ec_cbk_data_t * src)
+int32_t
+ec_combine_getxattr(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (!ec_dict_compare(dst->dict, src->dict))
-    {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_DICT_MISMATCH, "Mismatching dictionary in "
-                                             "answers of 'GF_FOP_GETXATTR'");
+    if (!ec_dict_compare(dst->dict, src->dict)) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_DICT_MISMATCH,
+               "Mismatching dictionary in "
+               "answers of 'GF_FOP_GETXATTR'");
 
         return 0;
     }
@@ -206,12 +202,12 @@ int32_t ec_combine_getxattr(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_getxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                        int32_t op_ret, int32_t op_errno, dict_t * dict,
-                        dict_t * xdata)
+int32_t
+ec_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -221,38 +217,30 @@ int32_t ec_getxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_GETXATTR, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (dict != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (dict != NULL) {
                 cbk->dict = dict_ref(dict);
-                if (cbk->dict == NULL)
-                {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_DICT_REF_FAIL,
-                            "Failed to reference a "
-                            "dictionary.");
+                if (cbk->dict == NULL) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                           "Failed to reference a "
+                           "dictionary.");
 
                     goto out;
                 }
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -262,15 +250,15 @@ int32_t ec_getxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_getxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_getxattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -280,40 +268,40 @@ void ec_wind_getxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 }
 
 void
-ec_handle_special_xattrs (ec_fop_data_t *fop)
+ec_handle_special_xattrs(ec_fop_data_t *fop)
 {
-        ec_cbk_data_t *cbk = NULL;
-        /* Stime may not be available on all the bricks, so even if some of the
-         * subvols succeed the operation, treat it as answer.*/
-        if (fop->str[0] &&
-            fnmatch (GF_XATTR_STIME_PATTERN, fop->str[0], 0) == 0) {
-                if (!fop->answer || (fop->answer->op_ret < 0)) {
-                        list_for_each_entry (cbk, &fop->cbk_list, list) {
-                                if (cbk->op_ret >= 0) {
-                                        fop->answer = cbk;
-                                        break;
-                                }
-                        }
+    ec_cbk_data_t *cbk = NULL;
+    /* Stime may not be available on all the bricks, so even if some of the
+     * subvols succeed the operation, treat it as answer.*/
+    if (fop->str[0] && fnmatch(GF_XATTR_STIME_PATTERN, fop->str[0], 0) == 0) {
+        if (!fop->answer || (fop->answer->op_ret < 0)) {
+            list_for_each_entry(cbk, &fop->cbk_list, list)
+            {
+                if (cbk->op_ret >= 0) {
+                    fop->answer = cbk;
+                    break;
                 }
+            }
         }
+    }
 }
 
-int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_getxattr(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             /* clear-locks commands must be done without any locks acquired
                to avoid interferences. */
             if ((fop->str[0] == NULL) ||
                 (strncmp(fop->str[0], GF_XATTR_CLRLK_CMD,
-                         SLEN (GF_XATTR_CLRLK_CMD)) != 0)) {
+                         SLEN(GF_XATTR_CLRLK_CMD)) != 0)) {
                 if (fop->fd == NULL) {
-                    ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO,
-                                          0, LLONG_MAX);
+                    ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
+                                          LLONG_MAX);
                 } else {
                     ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0,
                                        LLONG_MAX);
@@ -333,11 +321,11 @@ int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_PREPARE_ANSWER;
 
         case EC_STATE_PREPARE_ANSWER:
-            ec_handle_special_xattrs (fop);
+            ec_handle_special_xattrs(fop);
             if (fop->minimum == EC_MINIMUM_ALL) {
                 cbk = ec_fop_prepare_answer(fop, _gf_true);
             } else {
-                if (ec_dispatch_one_retry (fop, &cbk)) {
+                if (ec_dispatch_one_retry(fop, &cbk)) {
                     return EC_STATE_DISPATCH;
                 }
             }
@@ -347,10 +335,10 @@ int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
                 err = ec_dict_combine(cbk, EC_COMBINE_DICT);
                 if (!ec_cbk_set_error(cbk, -err, _gf_true)) {
                     if (cbk->xdata != NULL)
-                            ec_filter_internal_xattrs (cbk->xdata);
+                        ec_filter_internal_xattrs(cbk->xdata);
 
                     if (cbk->dict != NULL)
-                            ec_filter_internal_xattrs (cbk->dict);
+                        ec_filter_internal_xattrs(cbk->dict);
                 }
             }
 
@@ -361,8 +349,7 @@ int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.getxattr != NULL)
-            {
+            if (fop->cbks.getxattr != NULL) {
                 fop->cbks.getxattr(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                    cbk->op_errno, cbk->dict, cbk->xdata);
             }
@@ -376,10 +363,9 @@ int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.getxattr != NULL)
-            {
-                fop->cbks.getxattr(fop->req_frame, fop, fop->xl, -1,
-                                   fop->error, NULL, NULL);
+            if (fop->cbks.getxattr != NULL) {
+                fop->cbks.getxattr(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                   NULL, NULL);
             }
 
             return EC_STATE_LOCK_REUSE;
@@ -397,18 +383,17 @@ int32_t ec_manager_getxattr(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-int32_t ec_getxattr_heal_cbk(call_frame_t *frame, void *cookie, xlator_t *xl,
-                             int32_t op_ret, int32_t op_errno, uintptr_t mask,
-                             uintptr_t good, uintptr_t bad, dict_t *xdata)
+int32_t
+ec_getxattr_heal_cbk(call_frame_t *frame, void *cookie, xlator_t *xl,
+                     int32_t op_ret, int32_t op_errno, uintptr_t mask,
+                     uintptr_t good, uintptr_t bad, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     fop_getxattr_cbk_t func = fop->data;
@@ -460,15 +445,15 @@ out:
 }
 
 void
-ec_getxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-             int32_t minimum, fop_getxattr_cbk_t func, void *data,
-             loc_t *loc, const char *name, dict_t *xdata)
+ec_getxattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_getxattr_cbk_t func, void *data, loc_t *loc,
+            const char *name, dict_t *xdata)
 {
-    ec_cbk_t callback = { .getxattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.getxattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(GETXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(GETXATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -476,25 +461,23 @@ ec_getxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
     /* Special handling of an explicit self-heal request */
     if ((name != NULL) && (strcmp(name, EC_XATTR_HEAL) == 0)) {
-        ec_heal(frame, this, target, EC_MINIMUM_ONE, ec_getxattr_heal_cbk,
-                func, loc, 0, NULL);
+        ec_heal(frame, this, target, EC_MINIMUM_ONE, ec_getxattr_heal_cbk, func,
+                loc, 0, NULL);
 
         return;
     }
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_GETXATTR,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_getxattr, ec_manager_getxattr, callback,
-                               data);
+    fop = ec_fop_data_allocate(
+        frame, this, GF_FOP_GETXATTR, EC_FLAG_LOCK_SHARED, target, minimum,
+        ec_wind_getxattr, ec_manager_getxattr, callback, data);
     if (fop == NULL) {
         goto out;
     }
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -503,15 +486,14 @@ ec_getxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
         /* In case of list-node-uuids xattr, set flag to indicate
          * the same and use node-uuid xattr for winding fop */
         if (XATTR_IS_NODE_UUID_LIST(name)) {
-                fop->int32 = 1;
-                fop->str[0] = gf_strdup(GF_XATTR_NODE_UUID_KEY);
+            fop->int32 = 1;
+            fop->str[0] = gf_strdup(GF_XATTR_NODE_UUID_KEY);
         } else {
-                fop->str[0] = gf_strdup(name);
+            fop->str[0] = gf_strdup(name);
         }
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -519,10 +501,9 @@ ec_getxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -532,20 +513,20 @@ ec_getxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL, NULL);
+        func(frame, NULL, this, -1, error, NULL, NULL);
     }
 }
 
 /* FOP: fgetxattr */
 
-int32_t ec_fgetxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                         int32_t op_ret, int32_t op_errno, dict_t * dict,
-                         dict_t * xdata)
+int32_t
+ec_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -555,38 +536,30 @@ int32_t ec_fgetxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FGETXATTR, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (dict != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (dict != NULL) {
                 cbk->dict = dict_ref(dict);
-                if (cbk->dict == NULL)
-                {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_DICT_REF_FAIL,
-                            "Failed to reference a "
-                            "dictionary.");
+                if (cbk->dict == NULL) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                           "Failed to reference a "
+                           "dictionary.");
 
                     goto out;
                 }
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -596,8 +569,7 @@ int32_t ec_fgetxattr_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
@@ -605,7 +577,7 @@ out:
 }
 
 void
-ec_wind_fgetxattr (ec_t *ec, ec_fop_data_t *fop, int32_t idx)
+ec_wind_fgetxattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -615,24 +587,23 @@ ec_wind_fgetxattr (ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 }
 
 void
-ec_fgetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-              int32_t minimum, fop_fgetxattr_cbk_t func, void *data,
-              fd_t *fd, const char *name, dict_t *xdata)
+ec_fgetxattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+             int32_t minimum, fop_fgetxattr_cbk_t func, void *data, fd_t *fd,
+             const char *name, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fgetxattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fgetxattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FGETXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FGETXATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FGETXATTR,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_fgetxattr, ec_manager_getxattr,
-                               callback, data);
+    fop = ec_fop_data_allocate(
+        frame, this, GF_FOP_FGETXATTR, EC_FLAG_LOCK_SHARED, target, minimum,
+        ec_wind_fgetxattr, ec_manager_getxattr, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -642,10 +613,9 @@ ec_fgetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -653,8 +623,8 @@ ec_fgetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (name != NULL) {
         fop->str[0] = gf_strdup(name);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY, "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -662,9 +632,9 @@ ec_fgetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -674,22 +644,21 @@ ec_fgetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL, NULL);
+        func(frame, NULL, this, -1, error, NULL, NULL);
     }
 }
 
 /* FOP: open */
 
-int32_t ec_combine_open(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                        ec_cbk_data_t * src)
+int32_t
+ec_combine_open(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (dst->fd != src->fd)
-    {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_FD_MISMATCH, "Mismatching fd in answers "
-                                             "of 'GF_FOP_OPEN': %p <-> %p",
+    if (dst->fd != src->fd) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_FD_MISMATCH,
+               "Mismatching fd in answers "
+               "of 'GF_FOP_OPEN': %p <-> %p",
                dst->fd, src->fd);
 
         return 0;
@@ -698,12 +667,12 @@ int32_t ec_combine_open(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_open_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                    int32_t op_ret, int32_t op_errno, fd_t * fd,
-                    dict_t * xdata)
+int32_t
+ec_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -713,36 +682,31 @@ int32_t ec_open_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_OPEN, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (fd != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (fd != NULL) {
                 cbk->fd = fd_ref(fd);
-                if (cbk->fd == NULL)
-                {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                                     "file descriptor.");
+                if (cbk->fd == NULL) {
+                    gf_msg(this->name, GF_LOG_ERROR, 0,
+                           EC_MSG_FILE_DESC_REF_FAIL,
+                           "Failed to reference a "
+                           "file descriptor.");
 
                     goto out;
                 }
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -750,20 +714,19 @@ int32_t ec_open_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
         ec_combine(cbk, ec_combine_open);
 
-        ec_update_fd_status (fd, this, idx, op_ret);
-
+        ec_update_fd_status(fd, this, idx, op_ret);
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_open(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_open(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -772,10 +735,10 @@ void ec_wind_open(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->int32, fop->fd, fop->xdata);
 }
 
-int32_t ec_open_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             struct iatt *prebuf, struct iatt *postbuf,
-                             dict_t *xdata)
+int32_t
+ec_open_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
     ec_fop_data_t *fop = cookie;
     int32_t error = 0;
@@ -792,14 +755,14 @@ int32_t ec_open_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
     return 0;
 }
 
-int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_open(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
-    ec_fd_t * ctx;
+    ec_cbk_data_t *cbk;
+    ec_fd_t *ctx;
     int32_t err;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             LOCK(&fop->fd->lock);
 
@@ -833,7 +796,7 @@ int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
             fop->uint32 = fop->int32 & O_TRUNC;
             fop->int32 &= ~(O_APPEND | O_TRUNC);
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -864,8 +827,8 @@ int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
                     if (fop->uint32 != 0) {
                         ec_sleep(fop);
                         ec_ftruncate(fop->req_frame, fop->xl, cbk->mask,
-                                     fop->minimum, ec_open_truncate_cbk,
-                                     fop, cbk->fd, 0, NULL);
+                                     fop->minimum, ec_open_truncate_cbk, fop,
+                                     cbk->fd, 0, NULL);
                     }
                 }
             }
@@ -877,8 +840,7 @@ int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.open != NULL)
-            {
+            if (fop->cbks.open != NULL) {
                 fop->cbks.open(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                cbk->op_errno, cbk->fd, cbk->xdata);
             }
@@ -891,8 +853,7 @@ int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.open != NULL)
-            {
+            if (fop->cbks.open != NULL) {
                 fop->cbks.open(fop->req_frame, fop, fop->xl, -1, fop->error,
                                NULL, NULL);
             }
@@ -900,23 +861,23 @@ int32_t ec_manager_open(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_open(call_frame_t * frame, xlator_t * this, uintptr_t target,
-             int32_t minimum, fop_open_cbk_t func, void * data, loc_t * loc,
-             int32_t flags, fd_t * fd, dict_t * xdata)
+void
+ec_open(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+        fop_open_cbk_t func, void *data, loc_t *loc, int32_t flags, fd_t *fd,
+        dict_t *xdata)
 {
-    ec_cbk_t callback = { .open = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.open = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(OPEN) %p", frame);
+    gf_msg_trace("ec", 0, "EC(OPEN) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -933,8 +894,8 @@ void ec_open(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -942,9 +903,9 @@ void ec_open(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -952,9 +913,9 @@ void ec_open(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -972,13 +933,13 @@ out:
 
 /* FOP: readlink */
 
-int32_t ec_combine_readlink(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                            ec_cbk_data_t * src)
+int32_t
+ec_combine_readlink(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
     if (!ec_iatt_combine(fop, dst->iatt, src->iatt, 1)) {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_IATT_MISMATCH, "Mismatching iatt in "
-                                             "answers of 'GF_FOP_READLINK'");
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of 'GF_FOP_READLINK'");
 
         return 0;
     }
@@ -987,13 +948,13 @@ int32_t ec_combine_readlink(ec_fop_data_t * fop, ec_cbk_data_t * dst,
 }
 
 int32_t
-ec_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, const char *path,
-                 struct iatt *buf, dict_t *xdata)
+ec_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, const char *path,
+                struct iatt *buf, dict_t *xdata)
 {
-    ec_fop_data_t   *fop = NULL;
-    ec_cbk_data_t   *cbk = NULL;
-    int32_t         idx  = (int32_t)(uintptr_t)cookie;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1002,23 +963,23 @@ ec_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-    cbk = ec_cbk_data_allocate (frame, this, fop, fop->id,
-                                idx, op_ret, op_errno);
+    cbk = ec_cbk_data_allocate(frame, this, fop, fop->id, idx, op_ret,
+                               op_errno);
     if (cbk) {
-            if (xdata)
-                    cbk->xdata = dict_ref (xdata);
-
-            if (cbk->op_ret >= 0) {
-                    cbk->iatt[0] = *buf;
-                    cbk->str = gf_strdup (path);
-                    if (!cbk->str) {
-                            ec_cbk_set_error(cbk, ENOMEM, _gf_true);
-                    }
+        if (xdata)
+            cbk->xdata = dict_ref(xdata);
+
+        if (cbk->op_ret >= 0) {
+            cbk->iatt[0] = *buf;
+            cbk->str = gf_strdup(path);
+            if (!cbk->str) {
+                ec_cbk_set_error(cbk, ENOMEM, _gf_true);
             }
-            ec_combine (cbk, NULL);
+        }
+        ec_combine(cbk, NULL);
     }
 
 out:
@@ -1028,7 +989,8 @@ out:
     return 0;
 }
 
-void ec_wind_readlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_readlink(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1037,21 +999,21 @@ void ec_wind_readlink(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->size, fop->xdata);
 }
 
-int32_t ec_manager_readlink(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_readlink(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk = NULL;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_inode (fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                   LLONG_MAX);
-            ec_lock (fop);
+            ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
+                                  LLONG_MAX);
+            ec_lock(fop);
             return EC_STATE_DISPATCH;
 
         case EC_STATE_DISPATCH:
-            ec_dispatch_one (fop);
+            ec_dispatch_one(fop);
 
             return EC_STATE_PREPARE_ANSWER;
 
@@ -1068,11 +1030,11 @@ int32_t ec_manager_readlink(ec_fop_data_t * fop, int32_t state)
 
         case EC_STATE_REPORT:
             cbk = fop->answer;
-            GF_ASSERT (cbk);
+            GF_ASSERT(cbk);
             if (fop->cbks.readlink != NULL) {
-                fop->cbks.readlink (fop->req_frame, fop, fop->xl, cbk->op_ret,
-                                    cbk->op_errno, cbk->str, &cbk->iatt[0],
-                                    cbk->xdata);
+                fop->cbks.readlink(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                   cbk->op_errno, cbk->str, &cbk->iatt[0],
+                                   cbk->xdata);
             }
 
             return EC_STATE_LOCK_REUSE;
@@ -1083,8 +1045,8 @@ int32_t ec_manager_readlink(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_PREPARE_ANSWER:
         case -EC_STATE_REPORT:
             if (fop->cbks.readlink != NULL) {
-                fop->cbks.readlink(fop->req_frame, fop, fop->xl, -1,
-                                   fop->error, NULL, NULL, NULL);
+                fop->cbks.readlink(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                   NULL, NULL, NULL);
             }
             return EC_STATE_LOCK_REUSE;
 
@@ -1100,32 +1062,31 @@ int32_t ec_manager_readlink(ec_fop_data_t * fop, int32_t state)
 
             return EC_STATE_END;
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_readlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_readlink_cbk_t func, void * data,
-                 loc_t * loc, size_t size, dict_t * xdata)
+void
+ec_readlink(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_readlink_cbk_t func, void *data, loc_t *loc,
+            size_t size, dict_t *xdata)
 {
-    ec_cbk_t callback = { .readlink = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.readlink = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(READLINK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(READLINK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_READLINK,
-                               EC_FLAG_LOCK_SHARED, target, minimum,
-                               ec_wind_readlink, ec_manager_readlink, callback,
-                               data);
+    fop = ec_fop_data_allocate(
+        frame, this, GF_FOP_READLINK, EC_FLAG_LOCK_SHARED, target, minimum,
+        ec_wind_readlink, ec_manager_readlink, callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -1134,8 +1095,8 @@ void ec_readlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1143,9 +1104,9 @@ void ec_readlink(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1163,7 +1124,8 @@ out:
 
 /* FOP: readv */
 
-int32_t ec_readv_rebuild(ec_t * ec, ec_fop_data_t * fop, ec_cbk_data_t * cbk)
+int32_t
+ec_readv_rebuild(ec_t *ec, ec_fop_data_t *fop, ec_cbk_data_t *cbk)
 {
     struct iovec vector[1];
     ec_cbk_data_t *ans = NULL;
@@ -1256,22 +1218,21 @@ out:
     return err;
 }
 
-int32_t ec_combine_readv(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                         ec_cbk_data_t * src)
+int32_t
+ec_combine_readv(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (!ec_vector_compare(dst->vector, dst->int32, src->vector, src->int32))
-    {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_VECTOR_MISMATCH, "Mismatching vector in "
-                                             "answers of 'GF_FOP_READ'");
+    if (!ec_vector_compare(dst->vector, dst->int32, src->vector, src->int32)) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_VECTOR_MISMATCH,
+               "Mismatching vector in "
+               "answers of 'GF_FOP_READ'");
 
         return 0;
     }
 
     if (!ec_iatt_combine(fop, dst->iatt, src->iatt, 1)) {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_IATT_MISMATCH, "Mismatching iatt in "
-                                             "answers of 'GF_FOP_READ'");
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of 'GF_FOP_READ'");
 
         return 0;
     }
@@ -1279,14 +1240,14 @@ int32_t ec_combine_readv(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, struct iovec * vector,
-                     int32_t count, struct iatt * stbuf,
-                     struct iobref * iobref, dict_t * xdata)
+int32_t
+ec_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iovec *vector, int32_t count,
+             struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
-    ec_t * ec = this->private;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    ec_t *ec = this->private;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -1296,8 +1257,8 @@ int32_t ec_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_READ, idx, op_ret,
                                op_errno);
@@ -1308,9 +1269,9 @@ int32_t ec_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
             if (count > 0) {
                 cbk->vector = iov_dup(vector, count);
                 if (cbk->vector == NULL) {
-                    gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                            EC_MSG_NO_MEMORY, "Failed to duplicate a "
-                                                     "vector list.");
+                    gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                           "Failed to duplicate a "
+                           "vector list.");
 
                     goto out;
                 }
@@ -1322,9 +1283,9 @@ int32_t ec_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
             if (iobref != NULL) {
                 cbk->buffers = iobref_ref(iobref);
                 if (cbk->buffers == NULL) {
-                    gf_msg (this->name, GF_LOG_ERROR, 0,
-                            EC_MSG_BUF_REF_FAIL, "Failed to reference a "
-                                                     "buffer.");
+                    gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_BUF_REF_FAIL,
+                           "Failed to reference a "
+                           "buffer.");
 
                     goto out;
                 }
@@ -1333,9 +1294,9 @@ int32_t ec_readv_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
         if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
             if (cbk->xdata == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -1356,7 +1317,8 @@ out:
     return 0;
 }
 
-void ec_wind_readv(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_readv(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1365,12 +1327,12 @@ void ec_wind_readv(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->size, fop->offset, fop->uint32, fop->xdata);
 }
 
-int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_readv(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             fop->user_size = fop->size;
             fop->head = ec_adjust_offset_down(fop->xl->private, &fop->offset,
@@ -1378,7 +1340,7 @@ int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
             fop->size += fop->head;
             ec_adjust_size_up(fop->xl->private, &fop->size, _gf_true);
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_LOCK:
             ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, fop->offset,
@@ -1397,8 +1359,7 @@ int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
             if (cbk != NULL) {
                 int32_t err;
 
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 1,
-                                cbk->count);
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 1, cbk->count);
 
                 err = ec_readv_rebuild(fop->xl->private, fop, cbk);
                 if (err != 0) {
@@ -1413,8 +1374,7 @@ int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.readv != NULL)
-            {
+            if (fop->cbks.readv != NULL) {
                 fop->cbks.readv(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                 cbk->op_errno, cbk->vector, cbk->int32,
                                 &cbk->iatt[0], cbk->buffers, cbk->xdata);
@@ -1429,8 +1389,7 @@ int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.readv != NULL)
-            {
+            if (fop->cbks.readv != NULL) {
                 fop->cbks.readv(fop->req_frame, fop, fop->xl, -1, fop->error,
                                 NULL, 0, NULL, NULL, NULL);
             }
@@ -1450,31 +1409,31 @@ int32_t ec_manager_readv(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_readv(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_readv_cbk_t func, void * data, fd_t * fd,
-              size_t size, off_t offset, uint32_t flags, dict_t * xdata)
+void
+ec_readv(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_readv_cbk_t func, void *data, fd_t *fd, size_t size, off_t offset,
+         uint32_t flags, dict_t *xdata)
 {
-    ec_cbk_t callback = { .readv = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.readv = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(READ) %p", frame);
+    gf_msg_trace("ec", 0, "EC(READ) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_READ, EC_FLAG_LOCK_SHARED,
-                               target, minimum, ec_wind_readv,
-                               ec_manager_readv, callback, data);
+                               target, minimum, ec_wind_readv, ec_manager_readv,
+                               callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -1488,9 +1447,9 @@ void ec_readv(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -1498,9 +1457,9 @@ void ec_readv(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1518,9 +1477,9 @@ out:
 
 /* FOP: seek */
 
-int32_t ec_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, off_t offset,
-                    dict_t *xdata)
+int32_t
+ec_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, off_t offset, dict_t *xdata)
 {
     ec_fop_data_t *fop = NULL;
     ec_cbk_data_t *cbk = NULL;
@@ -1534,8 +1493,8 @@ int32_t ec_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_SEEK, idx, op_ret,
                                op_errno);
@@ -1563,7 +1522,8 @@ out:
     return 0;
 }
 
-void ec_wind_seek(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
+void
+ec_wind_seek(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1572,126 +1532,128 @@ void ec_wind_seek(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
                       fop->offset, fop->seek, fop->xdata);
 }
 
-int32_t ec_manager_seek(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_seek(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk;
     size_t size;
 
     switch (state) {
-    case EC_STATE_INIT:
-        fop->user_size = fop->offset;
-        fop->head = ec_adjust_offset_down(fop->xl->private, &fop->offset,
-                                          _gf_true);
+        case EC_STATE_INIT:
+            fop->user_size = fop->offset;
+            fop->head = ec_adjust_offset_down(fop->xl->private, &fop->offset,
+                                              _gf_true);
 
-    /* Fall through */
+            /* Fall through */
 
-    case EC_STATE_LOCK:
-        ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, fop->offset, LLONG_MAX);
-        ec_lock(fop);
+        case EC_STATE_LOCK:
+            ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, fop->offset,
+                               LLONG_MAX);
+            ec_lock(fop);
 
-        return EC_STATE_DISPATCH;
+            return EC_STATE_DISPATCH;
 
-    case EC_STATE_DISPATCH:
-        /* This shouldn't fail because we have the inode locked. */
-        GF_ASSERT(ec_get_inode_size(fop, fop->locks[0].lock->loc.inode,
-                                    &size));
+        case EC_STATE_DISPATCH:
+            /* This shouldn't fail because we have the inode locked. */
+            GF_ASSERT(
+                ec_get_inode_size(fop, fop->locks[0].lock->loc.inode, &size));
 
-        if (fop->user_size >= size) {
-            ec_fop_set_error(fop, ENXIO);
+            if (fop->user_size >= size) {
+                ec_fop_set_error(fop, ENXIO);
 
-            return EC_STATE_REPORT;
-        }
+                return EC_STATE_REPORT;
+            }
 
-        ec_dispatch_one(fop);
+            ec_dispatch_one(fop);
 
-        return EC_STATE_PREPARE_ANSWER;
+            return EC_STATE_PREPARE_ANSWER;
 
-    case EC_STATE_PREPARE_ANSWER:
-        if (ec_dispatch_one_retry(fop, &cbk)) {
-            return EC_STATE_DISPATCH;
-        }
-        if ((cbk != NULL) && (cbk->op_ret >= 0)) {
-            ec_t *ec = fop->xl->private;
+        case EC_STATE_PREPARE_ANSWER:
+            if (ec_dispatch_one_retry(fop, &cbk)) {
+                return EC_STATE_DISPATCH;
+            }
+            if ((cbk != NULL) && (cbk->op_ret >= 0)) {
+                ec_t *ec = fop->xl->private;
 
-            /* This shouldn't fail because we have the inode locked. */
-            GF_ASSERT(ec_get_inode_size(fop, fop->locks[0].lock->loc.inode,
-                                        &size));
+                /* This shouldn't fail because we have the inode locked. */
+                GF_ASSERT(ec_get_inode_size(fop, fop->locks[0].lock->loc.inode,
+                                            &size));
 
-            cbk->offset *= ec->fragments;
-            if (cbk->offset < fop->user_size) {
-                cbk->offset = fop->user_size;
-            }
-            if (cbk->offset > size) {
-                cbk->offset = size;
+                cbk->offset *= ec->fragments;
+                if (cbk->offset < fop->user_size) {
+                    cbk->offset = fop->user_size;
+                }
+                if (cbk->offset > size) {
+                    cbk->offset = size;
+                }
             }
-        }
 
-        return EC_STATE_REPORT;
+            return EC_STATE_REPORT;
 
-    case EC_STATE_REPORT:
-        cbk = fop->answer;
+        case EC_STATE_REPORT:
+            cbk = fop->answer;
 
-        GF_ASSERT(cbk != NULL);
+            GF_ASSERT(cbk != NULL);
 
-        if (fop->cbks.seek != NULL) {
-            fop->cbks.seek(fop->req_frame, fop, fop->xl, cbk->op_ret,
-                           cbk->op_errno, cbk->offset, cbk->xdata);
-        }
+            if (fop->cbks.seek != NULL) {
+                fop->cbks.seek(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                               cbk->op_errno, cbk->offset, cbk->xdata);
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_INIT:
-    case -EC_STATE_LOCK:
-    case -EC_STATE_DISPATCH:
-    case -EC_STATE_PREPARE_ANSWER:
-    case -EC_STATE_REPORT:
-        GF_ASSERT(fop->error != 0);
+        case -EC_STATE_INIT:
+        case -EC_STATE_LOCK:
+        case -EC_STATE_DISPATCH:
+        case -EC_STATE_PREPARE_ANSWER:
+        case -EC_STATE_REPORT:
+            GF_ASSERT(fop->error != 0);
 
-        if (fop->cbks.seek != NULL) {
-            fop->cbks.seek(fop->req_frame, fop, fop->xl, -1, fop->error, 0,
-                           NULL);
-        }
+            if (fop->cbks.seek != NULL) {
+                fop->cbks.seek(fop->req_frame, fop, fop->xl, -1, fop->error, 0,
+                               NULL);
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_LOCK_REUSE:
-    case EC_STATE_LOCK_REUSE:
-        ec_lock_reuse(fop);
+        case -EC_STATE_LOCK_REUSE:
+        case EC_STATE_LOCK_REUSE:
+            ec_lock_reuse(fop);
 
-        return EC_STATE_UNLOCK;
+            return EC_STATE_UNLOCK;
 
-    case -EC_STATE_UNLOCK:
-    case EC_STATE_UNLOCK:
-        ec_unlock(fop);
+        case -EC_STATE_UNLOCK:
+        case EC_STATE_UNLOCK:
+            ec_unlock(fop);
 
-        return EC_STATE_END;
+            return EC_STATE_END;
 
-    default:
-        gf_msg (fop->xl->name, GF_LOG_ERROR, 0,
-                EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s", state,
-                ec_fop_name(fop->id));
+        default:
+            gf_msg(fop->xl->name, GF_LOG_ERROR, 0, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
-        return EC_STATE_END;
+            return EC_STATE_END;
     }
 }
 
-void ec_seek(call_frame_t *frame, xlator_t *this, uintptr_t target,
-              int32_t minimum, fop_seek_cbk_t func, void *data, fd_t *fd,
-              off_t offset, gf_seek_what_t what, dict_t *xdata)
+void
+ec_seek(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+        fop_seek_cbk_t func, void *data, fd_t *fd, off_t offset,
+        gf_seek_what_t what, dict_t *xdata)
 {
-    ec_cbk_t callback = { .seek = func };
+    ec_cbk_t callback = {.seek = func};
     ec_fop_data_t *fop = NULL;
     int32_t error = EIO;
 
-    gf_msg_trace ("ec", 0, "EC(SEEK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(SEEK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_SEEK, EC_FLAG_LOCK_SHARED,
-                               target, minimum, ec_wind_seek,
-                               ec_manager_seek, callback, data);
+                               target, minimum, ec_wind_seek, ec_manager_seek,
+                               callback, data);
     if (fop == NULL) {
         goto out;
     }
@@ -1720,13 +1682,13 @@ out:
 
 /* FOP: stat */
 
-int32_t ec_combine_stat(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                        ec_cbk_data_t * src)
+int32_t
+ec_combine_stat(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
     if (!ec_iatt_combine(fop, dst->iatt, src->iatt, 1)) {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_IATT_MISMATCH, "Mismatching iatt in "
-                                             "answers of 'GF_FOP_STAT'");
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_IATT_MISMATCH,
+               "Mismatching iatt in "
+               "answers of 'GF_FOP_STAT'");
 
         return 0;
     }
@@ -1734,12 +1696,12 @@ int32_t ec_combine_stat(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_stat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                    int32_t op_ret, int32_t op_errno, struct iatt * buf,
-                    dict_t * xdata)
+int32_t
+ec_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -1749,28 +1711,23 @@ int32_t ec_stat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_STAT, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (buf != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (buf != NULL) {
                 cbk->iatt[0] = *buf;
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -1780,15 +1737,15 @@ int32_t ec_stat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_stat(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_stat(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1797,12 +1754,12 @@ void ec_wind_stat(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->xdata);
 }
 
-int32_t ec_manager_stat(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_stat(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             if (fop->fd == NULL) {
@@ -1825,8 +1782,7 @@ int32_t ec_manager_stat(ec_fop_data_t * fop, int32_t state)
 
             if (cbk != NULL) {
                 if (cbk->iatt[0].ia_type == IA_IFREG) {
-                    ec_iatt_rebuild(fop->xl->private, cbk->iatt, 1,
-                                    cbk->count);
+                    ec_iatt_rebuild(fop->xl->private, cbk->iatt, 1, cbk->count);
 
                     /* This shouldn't fail because we have the inode locked. */
                     GF_ASSERT(ec_get_inode_size(fop,
@@ -1842,18 +1798,13 @@ int32_t ec_manager_stat(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_STAT)
-            {
-                if (fop->cbks.stat != NULL)
-                {
+            if (fop->id == GF_FOP_STAT) {
+                if (fop->cbks.stat != NULL) {
                     fop->cbks.stat(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                    cbk->op_errno, &cbk->iatt[0], cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fstat != NULL)
-                {
+            } else {
+                if (fop->cbks.fstat != NULL) {
                     fop->cbks.fstat(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                     cbk->op_errno, &cbk->iatt[0], cbk->xdata);
                 }
@@ -1868,18 +1819,13 @@ int32_t ec_manager_stat(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_STAT)
-            {
-                if (fop->cbks.stat != NULL)
-                {
-                    fop->cbks.stat(fop->req_frame, fop, fop->xl, -1,
-                                   fop->error, NULL, NULL);
+            if (fop->id == GF_FOP_STAT) {
+                if (fop->cbks.stat != NULL) {
+                    fop->cbks.stat(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                   NULL, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fstat != NULL)
-                {
+            } else {
+                if (fop->cbks.fstat != NULL) {
                     fop->cbks.fstat(fop->req_frame, fop, fop->xl, -1,
                                     fop->error, NULL, NULL);
                 }
@@ -1900,23 +1846,22 @@ int32_t ec_manager_stat(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE, "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_stat(call_frame_t * frame, xlator_t * this, uintptr_t target,
-             int32_t minimum, fop_stat_cbk_t func, void * data, loc_t * loc,
-             dict_t * xdata)
+void
+ec_stat(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+        fop_stat_cbk_t func, void *data, loc_t *loc, dict_t *xdata)
 {
-    ec_cbk_t callback = { .stat = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.stat = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(STAT) %p", frame);
+    gf_msg_trace("ec", 0, "EC(STAT) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1931,8 +1876,8 @@ void ec_stat(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL, "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1940,9 +1885,9 @@ void ec_stat(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1960,12 +1905,12 @@ out:
 
 /* FOP: fstat */
 
-int32_t ec_fstat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                     int32_t op_ret, int32_t op_errno, struct iatt * buf,
-                     dict_t * xdata)
+int32_t
+ec_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -1975,28 +1920,23 @@ int32_t ec_fstat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FSTAT, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (buf != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (buf != NULL) {
                 cbk->iatt[0] = *buf;
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                                 "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -2006,15 +1946,15 @@ int32_t ec_fstat_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_fstat(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fstat(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -2023,15 +1963,15 @@ void ec_wind_fstat(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->xdata);
 }
 
-void ec_fstat(call_frame_t * frame, xlator_t * this, uintptr_t target,
-              int32_t minimum, fop_fstat_cbk_t func, void * data, fd_t * fd,
-              dict_t * xdata)
+void
+ec_fstat(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+         fop_fstat_cbk_t func, void *data, fd_t *fd, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fstat = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fstat = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FSTAT) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FSTAT) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -2049,9 +1989,9 @@ void ec_fstat(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL, "Failed to reference a "
-                                             "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -2059,9 +1999,9 @@ void ec_fstat(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL, "Failed to reference a "
-                                             "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
diff --git a/xlators/cluster/ec/src/ec-inode-write.c b/xlators/cluster/ec/src/ec-inode-write.c
index c9fbd3cf7df..ffdac632683 100644
--- a/xlators/cluster/ec/src/ec-inode-write.c
+++ b/xlators/cluster/ec/src/ec-inode-write.c
@@ -21,56 +21,55 @@
 #include "ec-mem-types.h"
 
 int32_t
-ec_update_writev_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret, int32_t op_errno,
-                      struct iatt *prebuf, struct iatt *postbuf,
-                      dict_t *xdata)
+ec_update_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-    ec_fop_data_t *fop    = cookie;
-    ec_cbk_data_t *cbk    = NULL;
+    ec_fop_data_t *fop = cookie;
+    ec_cbk_data_t *cbk = NULL;
     ec_fop_data_t *parent = fop->parent;
-    int           i       = 0;
+    int i = 0;
 
     ec_trace("UPDATE_WRITEV_CBK", cookie, "ret=%d, errno=%d, parent-fop=%s",
-             op_ret, op_errno, ec_fop_name (parent->id));
+             op_ret, op_errno, ec_fop_name(parent->id));
 
     if (op_ret < 0) {
-            ec_fop_set_error (parent, op_errno);
-            goto out;
+        ec_fop_set_error(parent, op_errno);
+        goto out;
     }
-    cbk = ec_cbk_data_allocate (parent->frame, this, parent,
-                                parent->id, 0, op_ret, op_errno);
+    cbk = ec_cbk_data_allocate(parent->frame, this, parent, parent->id, 0,
+                               op_ret, op_errno);
     if (!cbk) {
-            ec_fop_set_error (parent, ENOMEM);
-            goto out;
+        ec_fop_set_error(parent, ENOMEM);
+        goto out;
     }
 
     if (xdata)
-            cbk->xdata = dict_ref (xdata);
+        cbk->xdata = dict_ref(xdata);
 
     if (prebuf)
-            cbk->iatt[i++] = *prebuf;
+        cbk->iatt[i++] = *prebuf;
 
     if (postbuf)
-            cbk->iatt[i++] = *postbuf;
+        cbk->iatt[i++] = *postbuf;
 
-    LOCK (&parent->lock);
+    LOCK(&parent->lock);
     {
-            parent->good &= fop->good;
+        parent->good &= fop->good;
 
-            if (gf_bits_count (parent->good) < parent->minimum) {
-                    __ec_fop_set_error (parent, EIO);
-            } else if (fop->error == 0 && parent->answer == NULL) {
-                    parent->answer = cbk;
-            }
+        if (gf_bits_count(parent->good) < parent->minimum) {
+            __ec_fop_set_error(parent, EIO);
+        } else if (fop->error == 0 && parent->answer == NULL) {
+            parent->answer = cbk;
+        }
     }
-    UNLOCK (&parent->lock);
+    UNLOCK(&parent->lock);
 out:
     return 0;
 }
 
-int32_t ec_update_write(ec_fop_data_t *fop, uintptr_t mask, off_t offset,
-                        size_t size)
+int32_t
+ec_update_write(ec_fop_data_t *fop, uintptr_t mask, off_t offset, size_t size)
 {
     struct iobref *iobref = NULL;
     struct iobuf *iobuf = NULL;
@@ -94,9 +93,8 @@ int32_t ec_update_write(ec_fop_data_t *fop, uintptr_t mask, off_t offset,
     vector.iov_len = size;
     memset(vector.iov_base, 0, vector.iov_len);
 
-    ec_writev(fop->frame, fop->xl, mask, fop->minimum,
-              ec_update_writev_cbk, NULL, fop->fd, &vector, 1,
-              offset, 0, iobref, NULL);
+    ec_writev(fop->frame, fop->xl, mask, fop->minimum, ec_update_writev_cbk,
+              NULL, fop->fd, &vector, 1, offset, 0, iobref, NULL);
 
     err = 0;
 
@@ -112,62 +110,63 @@ out:
 }
 
 int
-ec_inode_write_cbk (call_frame_t *frame, xlator_t *this, void *cookie,
-                    int op_ret, int op_errno, struct iatt *prestat,
-                    struct iatt *poststat, dict_t *xdata)
+ec_inode_write_cbk(call_frame_t *frame, xlator_t *this, void *cookie,
+                   int op_ret, int op_errno, struct iatt *prestat,
+                   struct iatt *poststat, dict_t *xdata)
 {
-        ec_fop_data_t *fop = NULL;
-        ec_cbk_data_t *cbk = NULL;
-        int           i    = 0;
-        int           idx  = 0;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
+    int i = 0;
+    int idx = 0;
 
-        VALIDATE_OR_GOTO (this, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame, out);
-        GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-        fop = frame->local;
-        idx = (int32_t)(uintptr_t) cookie;
+    fop = frame->local;
+    idx = (int32_t)(uintptr_t)cookie;
 
-        ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-                 frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
-        cbk = ec_cbk_data_allocate (frame, this, fop, fop->id, idx, op_ret,
-                                    op_errno);
-        if (!cbk)
-                goto out;
+    cbk = ec_cbk_data_allocate(frame, this, fop, fop->id, idx, op_ret,
+                               op_errno);
+    if (!cbk)
+        goto out;
 
-        if (op_ret < 0)
-                goto out;
+    if (op_ret < 0)
+        goto out;
 
-        if (xdata)
-                cbk->xdata = dict_ref (xdata);
+    if (xdata)
+        cbk->xdata = dict_ref(xdata);
 
-        if (prestat)
-                cbk->iatt[i++] = *prestat;
+    if (prestat)
+        cbk->iatt[i++] = *prestat;
 
-        if (poststat)
-                cbk->iatt[i++] = *poststat;
+    if (poststat)
+        cbk->iatt[i++] = *poststat;
 
 out:
-        if (cbk)
-                ec_combine (cbk, ec_combine_write);
+    if (cbk)
+        ec_combine(cbk, ec_combine_write);
 
-        if (fop)
-                ec_complete (fop);
-        return 0;
+    if (fop)
+        ec_complete(fop);
+    return 0;
 }
 /* FOP: removexattr */
 
-int32_t ec_removexattr_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int32_t op_ret, int32_t op_errno,
-                            dict_t *xdata)
+int32_t
+ec_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   NULL, NULL, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, NULL, NULL,
+                              xdata);
 }
 
-void ec_wind_removexattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_removexattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -177,127 +176,123 @@ void ec_wind_removexattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 }
 
 void
-ec_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, dict_t *xdata)
+ec_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, dict_t *xdata)
 {
-        ec_fop_data_t *fop = cookie;
-        switch (fop->id) {
+    ec_fop_data_t *fop = cookie;
+    switch (fop->id) {
         case GF_FOP_SETXATTR:
-                if (fop->cbks.setxattr) {
-                        fop->cbks.setxattr (frame, cookie, this, op_ret,
-                                            op_errno, xdata);
-                }
-                break;
+            if (fop->cbks.setxattr) {
+                fop->cbks.setxattr(frame, cookie, this, op_ret, op_errno,
+                                   xdata);
+            }
+            break;
         case GF_FOP_REMOVEXATTR:
-                if (fop->cbks.removexattr) {
-                        fop->cbks.removexattr (frame, cookie, this, op_ret,
-                                               op_errno, xdata);
-                }
-                break;
+            if (fop->cbks.removexattr) {
+                fop->cbks.removexattr(frame, cookie, this, op_ret, op_errno,
+                                      xdata);
+            }
+            break;
         case GF_FOP_FSETXATTR:
-                if (fop->cbks.fsetxattr) {
-                        fop->cbks.fsetxattr (frame, cookie, this, op_ret,
-                                             op_errno, xdata);
-                }
-                break;
+            if (fop->cbks.fsetxattr) {
+                fop->cbks.fsetxattr(frame, cookie, this, op_ret, op_errno,
+                                    xdata);
+            }
+            break;
         case GF_FOP_FREMOVEXATTR:
-                if (fop->cbks.fremovexattr) {
-                        fop->cbks.fremovexattr (frame, cookie, this, op_ret,
-                                                op_errno, xdata);
-                }
-                break;
-        }
+            if (fop->cbks.fremovexattr) {
+                fop->cbks.fremovexattr(frame, cookie, this, op_ret, op_errno,
+                                       xdata);
+            }
+            break;
+    }
 }
 
 int32_t
-ec_manager_xattr (ec_fop_data_t *fop, int32_t state)
+ec_manager_xattr(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-        switch (state) {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-                if (fop->fd == NULL) {
-                        ec_lock_prepare_inode(fop, &fop->loc[0],
-                                              EC_UPDATE_META | EC_QUERY_INFO,
-                                              0, LLONG_MAX);
-                } else {
-                        ec_lock_prepare_fd(fop, fop->fd,
-                                           EC_UPDATE_META | EC_QUERY_INFO,
-                                           0, LLONG_MAX);
-                }
-                ec_lock(fop);
+            if (fop->fd == NULL) {
+                ec_lock_prepare_inode(fop, &fop->loc[0],
+                                      EC_UPDATE_META | EC_QUERY_INFO, 0,
+                                      LLONG_MAX);
+            } else {
+                ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META | EC_QUERY_INFO,
+                                   0, LLONG_MAX);
+            }
+            ec_lock(fop);
 
-                return EC_STATE_DISPATCH;
+            return EC_STATE_DISPATCH;
 
         case EC_STATE_DISPATCH:
-                ec_dispatch_all(fop);
+            ec_dispatch_all(fop);
 
-                return EC_STATE_PREPARE_ANSWER;
+            return EC_STATE_PREPARE_ANSWER;
 
         case EC_STATE_PREPARE_ANSWER:
-                ec_fop_prepare_answer(fop, _gf_false);
+            ec_fop_prepare_answer(fop, _gf_false);
 
-                return EC_STATE_REPORT;
+            return EC_STATE_REPORT;
 
         case EC_STATE_REPORT:
-                cbk = fop->answer;
+            cbk = fop->answer;
 
-                GF_ASSERT(cbk != NULL);
+            GF_ASSERT(cbk != NULL);
 
-                ec_xattr_cbk (fop->req_frame, fop, fop->xl, cbk->op_ret,
-                              cbk->op_errno, cbk->xdata);
+            ec_xattr_cbk(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                         cbk->op_errno, cbk->xdata);
 
-                    return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
         case -EC_STATE_INIT:
         case -EC_STATE_LOCK:
         case -EC_STATE_DISPATCH:
         case -EC_STATE_PREPARE_ANSWER:
         case -EC_STATE_REPORT:
-                GF_ASSERT(fop->error != 0);
+            GF_ASSERT(fop->error != 0);
 
-                ec_xattr_cbk (fop->req_frame, fop, fop->xl, -1, fop->error,
-                              NULL);
+            ec_xattr_cbk(fop->req_frame, fop, fop->xl, -1, fop->error, NULL);
 
-                return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
         case -EC_STATE_LOCK_REUSE:
         case EC_STATE_LOCK_REUSE:
-                ec_lock_reuse(fop);
+            ec_lock_reuse(fop);
 
-                return EC_STATE_UNLOCK;
+            return EC_STATE_UNLOCK;
 
         case -EC_STATE_UNLOCK:
         case EC_STATE_UNLOCK:
-                ec_unlock(fop);
+            ec_unlock(fop);
 
-                return EC_STATE_END;
+            return EC_STATE_END;
 
         default:
-                gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                        EC_MSG_UNHANDLED_STATE,
-                        "Unhandled state %d for %s",
-                        state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
-                return EC_STATE_END;
-        }
+            return EC_STATE_END;
+    }
 }
 
 void
-ec_removexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-                int32_t minimum, fop_removexattr_cbk_t func, void *data,
-                loc_t *loc, const char *name, dict_t *xdata)
+ec_removexattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+               int32_t minimum, fop_removexattr_cbk_t func, void *data,
+               loc_t *loc, const char *name, dict_t *xdata)
 {
-    ec_cbk_t callback = { .removexattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.removexattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(REMOVEXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(REMOVEXATTR) %p", frame);
 
-    VALIDATE_OR_GOTO (this, out);
-    GF_VALIDATE_OR_GOTO (this->name, frame, out);
-    GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_REMOVEXATTR, 0, target,
                                minimum, ec_wind_removexattr, ec_manager_xattr,
@@ -308,9 +303,8 @@ ec_removexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -318,20 +312,18 @@ ec_removexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (name != NULL) {
         fop->str[0] = gf_strdup(name);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
     }
     if (xdata != NULL) {
-        fop->xdata = dict_copy_with_ref (xdata, NULL);
+        fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -341,23 +333,24 @@ ec_removexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL);
+        func(frame, NULL, this, -1, error, NULL);
     }
 }
 
 /* FOP: fremovexattr */
 
-int32_t ec_fremovexattr_cbk (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret, int32_t op_errno,
-                             dict_t *xdata)
+int32_t
+ec_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   NULL, NULL, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, NULL, NULL,
+                              xdata);
 }
 
-void ec_wind_fremovexattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fremovexattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -367,19 +360,19 @@ void ec_wind_fremovexattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 }
 
 void
-ec_fremovexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-                 int32_t minimum, fop_fremovexattr_cbk_t func, void *data,
-                 fd_t *fd, const char *name, dict_t *xdata)
+ec_fremovexattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+                int32_t minimum, fop_fremovexattr_cbk_t func, void *data,
+                fd_t *fd, const char *name, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fremovexattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fremovexattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FREMOVEXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FREMOVEXATTR) %p", frame);
 
-    VALIDATE_OR_GOTO (this, out);
-    GF_VALIDATE_OR_GOTO (this->name, frame, out);
-    GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = ec_fop_data_allocate(frame, this, GF_FOP_FREMOVEXATTR, 0, target,
                                minimum, ec_wind_fremovexattr, ec_manager_xattr,
@@ -393,10 +386,9 @@ ec_fremovexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -404,9 +396,8 @@ ec_fremovexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (name != NULL) {
         fop->str[0] = gf_strdup(name);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -414,10 +405,9 @@ ec_fremovexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -427,24 +417,25 @@ ec_fremovexattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL);
+        func(frame, NULL, this, -1, error, NULL);
     }
 }
 
 /* FOP: setattr */
 
-int32_t ec_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno,
-                        struct iatt *prestat, struct iatt *poststat,
-                        dict_t *xdata)
+int32_t
+ec_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct iatt *prestat,
+               struct iatt *poststat, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prestat, poststat, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prestat,
+                              poststat, xdata);
 }
 
-void ec_wind_setattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_setattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -453,18 +444,18 @@ void ec_wind_setattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], &fop->iatt, fop->int32, fop->xdata);
 }
 
-int32_t ec_manager_setattr(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_setattr(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0],
-                                      EC_UPDATE_META | EC_QUERY_INFO,
-                                      0, LLONG_MAX);
+                                      EC_UPDATE_META | EC_QUERY_INFO, 0,
+                                      LLONG_MAX);
             } else {
                 ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META | EC_QUERY_INFO,
                                    0, LLONG_MAX);
@@ -482,8 +473,7 @@ int32_t ec_manager_setattr(ec_fop_data_t * fop, int32_t state)
             cbk = ec_fop_prepare_answer(fop, _gf_false);
             if (cbk != NULL) {
                 if (cbk->iatt[0].ia_type == IA_IFREG) {
-                    ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                                    cbk->count);
+                    ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                     /* This shouldn't fail because we have the inode locked. */
                     GF_ASSERT(ec_get_inode_size(fop,
@@ -500,20 +490,14 @@ int32_t ec_manager_setattr(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_SETATTR)
-            {
-                if (fop->cbks.setattr != NULL)
-                {
-                    fop->cbks.setattr(fop->req_frame, fop, fop->xl,
-                                      cbk->op_ret, cbk->op_errno,
-                                      &cbk->iatt[0], &cbk->iatt[1],
-                                      cbk->xdata);
+            if (fop->id == GF_FOP_SETATTR) {
+                if (fop->cbks.setattr != NULL) {
+                    fop->cbks.setattr(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                      cbk->op_errno, &cbk->iatt[0],
+                                      &cbk->iatt[1], cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fsetattr != NULL)
-                {
+            } else {
+                if (fop->cbks.fsetattr != NULL) {
                     fop->cbks.fsetattr(fop->req_frame, fop, fop->xl,
                                        cbk->op_ret, cbk->op_errno,
                                        &cbk->iatt[0], &cbk->iatt[1],
@@ -530,18 +514,13 @@ int32_t ec_manager_setattr(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_SETATTR)
-            {
-                if (fop->cbks.setattr != NULL)
-                {
+            if (fop->id == GF_FOP_SETATTR) {
+                if (fop->cbks.setattr != NULL) {
                     fop->cbks.setattr(fop->req_frame, fop, fop->xl, -1,
                                       fop->error, NULL, NULL, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fsetattr != NULL)
-                {
+            } else {
+                if (fop->cbks.fsetattr != NULL) {
                     fop->cbks.fsetattr(fop->req_frame, fop, fop->xl, -1,
                                        fop->error, NULL, NULL, NULL);
                 }
@@ -562,25 +541,23 @@ int32_t ec_manager_setattr(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_setattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_setattr_cbk_t func, void * data,
-                loc_t * loc, struct iatt * stbuf, int32_t valid,
-                dict_t * xdata)
+void
+ec_setattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_setattr_cbk_t func, void *data, loc_t *loc,
+           struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-    ec_cbk_t callback = { .setattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.setattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(SETATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(SETATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -597,9 +574,8 @@ void ec_setattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -610,10 +586,9 @@ void ec_setattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -631,16 +606,17 @@ out:
 
 /* FOP: fsetattr */
 
-int32_t ec_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno,
-                         struct iatt *prestat, struct iatt *poststat,
-                         dict_t *xdata)
+int32_t
+ec_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, struct iatt *prestat,
+                struct iatt *poststat, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prestat, poststat, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prestat,
+                              poststat, xdata);
 }
 
-void ec_wind_fsetattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fsetattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -649,23 +625,24 @@ void ec_wind_fsetattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, &fop->iatt, fop->int32, fop->xdata);
 }
 
-void ec_fsetattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_fsetattr_cbk_t func, void * data,
-                 fd_t * fd, struct iatt * stbuf, int32_t valid, dict_t * xdata)
+void
+ec_fsetattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_fsetattr_cbk_t func, void *data, fd_t *fd,
+            struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fsetattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fsetattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FSETATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FSETATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FSETATTR, 0, target,
-                               minimum, ec_wind_fsetattr, ec_manager_setattr,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_FSETATTR, 0, target, minimum,
+                               ec_wind_fsetattr, ec_manager_setattr, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -677,10 +654,9 @@ void ec_fsetattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -691,10 +667,9 @@ void ec_fsetattr(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -712,14 +687,16 @@ out:
 
 /* FOP: setxattr */
 
-int32_t ec_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+int32_t
+ec_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   NULL, NULL, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, NULL, NULL,
+                              xdata);
 }
 
-void ec_wind_setxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_setxattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -729,23 +706,23 @@ void ec_wind_setxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 }
 
 void
-ec_setxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-             int32_t minimum, fop_setxattr_cbk_t func, void *data,
-             loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata)
+ec_setxattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_setxattr_cbk_t func, void *data, loc_t *loc,
+            dict_t *dict, int32_t flags, dict_t *xdata)
 {
-    ec_cbk_t callback = { .setxattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.setxattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(SETXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(SETXATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_SETXATTR, 0, target,
-                               minimum, ec_wind_setxattr, ec_manager_xattr,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_SETXATTR, 0, target, minimum,
+                               ec_wind_setxattr, ec_manager_xattr, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -754,9 +731,8 @@ ec_setxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -764,10 +740,9 @@ ec_setxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (dict != NULL) {
         fop->dict = dict_copy_with_ref(dict, NULL);
         if (fop->dict == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -775,10 +750,9 @@ ec_setxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -788,45 +762,41 @@ ec_setxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL);
+        func(frame, NULL, this, -1, error, NULL);
     }
 }
 
 /* FOP: fsetxattr */
 
 int32_t
-ec_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+ec_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
-    VALIDATE_OR_GOTO (this, out);
-    GF_VALIDATE_OR_GOTO (this->name, frame, out);
-    GF_VALIDATE_OR_GOTO (this->name, frame->local, out);
-    GF_VALIDATE_OR_GOTO (this->name, this->private, out);
+    VALIDATE_OR_GOTO(this, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, frame->local, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FSETXATTR, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -836,15 +806,15 @@ ec_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_fsetxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fsetxattr(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -854,15 +824,15 @@ void ec_wind_fsetxattr(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
 }
 
 void
-ec_fsetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
-              int32_t minimum, fop_fsetxattr_cbk_t func, void *data,
-              fd_t *fd, dict_t *dict, int32_t flags, dict_t *xdata)
+ec_fsetxattr(call_frame_t *frame, xlator_t *this, uintptr_t target,
+             int32_t minimum, fop_fsetxattr_cbk_t func, void *data, fd_t *fd,
+             dict_t *dict, int32_t flags, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fsetxattr = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fsetxattr = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FSETXATTR) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FSETXATTR) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -882,10 +852,9 @@ ec_fsetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -893,10 +862,9 @@ ec_fsetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (dict != NULL) {
         fop->dict = dict_copy_with_ref(dict, NULL);
         if (fop->dict == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -904,10 +872,9 @@ ec_fsetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -917,9 +884,9 @@ ec_fsetxattr (call_frame_t *frame, xlator_t *this, uintptr_t target,
 
 out:
     if (fop != NULL) {
-        ec_manager (fop, error);
+        ec_manager(fop, error);
     } else {
-        func (frame, NULL, this, -1, error, NULL);
+        func(frame, NULL, this, -1, error, NULL);
     }
 }
 
@@ -929,154 +896,153 @@ out:
  *
  *********************************************************************/
 
-int32_t ec_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                         struct iatt *postbuf, dict_t *xdata)
+int32_t
+ec_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                 struct iatt *postbuf, dict_t *xdata)
 {
-    return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prebuf, postbuf, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prebuf,
+                              postbuf, xdata);
 }
 
-void ec_wind_fallocate(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
+void
+ec_wind_fallocate(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
     STACK_WIND_COOKIE(fop->frame, ec_fallocate_cbk, (void *)(uintptr_t)idx,
                       ec->xl_list[idx], ec->xl_list[idx]->fops->fallocate,
-                      fop->fd, fop->int32, fop->offset,
-                      fop->size, fop->xdata);
+                      fop->fd, fop->int32, fop->offset, fop->size, fop->xdata);
 }
 
-int32_t ec_manager_fallocate(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_fallocate(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk = NULL;
 
     switch (state) {
-    case EC_STATE_INIT:
-        if (fop->size == 0) {
+        case EC_STATE_INIT:
+            if (fop->size == 0) {
                 ec_fop_set_error(fop, EINVAL);
                 return EC_STATE_REPORT;
-        }
-        if (fop->int32 & (FALLOC_FL_COLLAPSE_RANGE
-                         |FALLOC_FL_INSERT_RANGE
-                         |FALLOC_FL_ZERO_RANGE
-                         |FALLOC_FL_PUNCH_HOLE)) {
+            }
+            if (fop->int32 &
+                (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE |
+                 FALLOC_FL_ZERO_RANGE | FALLOC_FL_PUNCH_HOLE)) {
                 ec_fop_set_error(fop, ENOTSUP);
                 return EC_STATE_REPORT;
-        }
-        fop->user_size = fop->offset + fop->size;
-        fop->head = ec_adjust_offset_down (fop->xl->private, &fop->offset,
-                                           _gf_true);
-        fop->size += fop->head;
-        ec_adjust_size_up (fop->xl->private, &fop->size, _gf_true);
+            }
+            fop->user_size = fop->offset + fop->size;
+            fop->head = ec_adjust_offset_down(fop->xl->private, &fop->offset,
+                                              _gf_true);
+            fop->size += fop->head;
+            ec_adjust_size_up(fop->xl->private, &fop->size, _gf_true);
 
-        /* Fall through */
+            /* Fall through */
 
-    case EC_STATE_LOCK:
-        ec_lock_prepare_fd(fop, fop->fd,
-                           EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
-                           fop->offset, fop->size);
-        ec_lock(fop);
+        case EC_STATE_LOCK:
+            ec_lock_prepare_fd(fop, fop->fd,
+                               EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
+                               fop->offset, fop->size);
+            ec_lock(fop);
 
-        return EC_STATE_DISPATCH;
+            return EC_STATE_DISPATCH;
 
-    case EC_STATE_DISPATCH:
+        case EC_STATE_DISPATCH:
 
-        ec_dispatch_all(fop);
+            ec_dispatch_all(fop);
 
-        return EC_STATE_PREPARE_ANSWER;
+            return EC_STATE_PREPARE_ANSWER;
 
-    case EC_STATE_PREPARE_ANSWER:
-        cbk = ec_fop_prepare_answer(fop, _gf_false);
-        if (cbk != NULL) {
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                            cbk->count);
+        case EC_STATE_PREPARE_ANSWER:
+            cbk = ec_fop_prepare_answer(fop, _gf_false);
+            if (cbk != NULL) {
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                 /* This shouldn't fail because we have the inode locked. */
                 LOCK(&fop->locks[0].lock->loc.inode->lock);
                 {
-                        GF_ASSERT(__ec_get_inode_size(fop,
-                                                fop->locks[0].lock->loc.inode,
-                                                &cbk->iatt[0].ia_size));
+                    GF_ASSERT(__ec_get_inode_size(fop,
+                                                  fop->locks[0].lock->loc.inode,
+                                                  &cbk->iatt[0].ia_size));
 
-                        /*If mode has FALLOC_FL_KEEP_SIZE keep the size */
-                        if (fop->int32 & FALLOC_FL_KEEP_SIZE) {
-                                cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
-                        } else if (fop->user_size > cbk->iatt[0].ia_size) {
-                                cbk->iatt[1].ia_size = fop->user_size;
-
-                                /* This shouldn't fail because we have the inode
-                                 * locked. */
-                                GF_ASSERT(__ec_set_inode_size(fop,
-                                          fop->locks[0].lock->loc.inode,
-                                                    cbk->iatt[1].ia_size));
-                        } else {
-                                cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
-                        }
+                    /*If mode has FALLOC_FL_KEEP_SIZE keep the size */
+                    if (fop->int32 & FALLOC_FL_KEEP_SIZE) {
+                        cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
+                    } else if (fop->user_size > cbk->iatt[0].ia_size) {
+                        cbk->iatt[1].ia_size = fop->user_size;
+
+                        /* This shouldn't fail because we have the inode
+                         * locked. */
+                        GF_ASSERT(__ec_set_inode_size(
+                            fop, fop->locks[0].lock->loc.inode,
+                            cbk->iatt[1].ia_size));
+                    } else {
+                        cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
+                    }
                 }
                 UNLOCK(&fop->locks[0].lock->loc.inode->lock);
-        }
+            }
 
-        return EC_STATE_REPORT;
+            return EC_STATE_REPORT;
 
-    case EC_STATE_REPORT:
-        cbk = fop->answer;
+        case EC_STATE_REPORT:
+            cbk = fop->answer;
 
-        GF_ASSERT(cbk != NULL);
+            GF_ASSERT(cbk != NULL);
 
-        if (fop->cbks.fallocate != NULL) {
+            if (fop->cbks.fallocate != NULL) {
                 fop->cbks.fallocate(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                     cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                     cbk->xdata);
-        }
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_INIT:
-    case -EC_STATE_LOCK:
-    case -EC_STATE_DISPATCH:
-    case -EC_STATE_PREPARE_ANSWER:
-    case -EC_STATE_REPORT:
-        GF_ASSERT(fop->error != 0);
+        case -EC_STATE_INIT:
+        case -EC_STATE_LOCK:
+        case -EC_STATE_DISPATCH:
+        case -EC_STATE_PREPARE_ANSWER:
+        case -EC_STATE_REPORT:
+            GF_ASSERT(fop->error != 0);
 
-        if (fop->cbks.fallocate != NULL) {
+            if (fop->cbks.fallocate != NULL) {
                 fop->cbks.fallocate(fop->req_frame, fop, fop->xl, -1,
                                     fop->error, NULL, NULL, NULL);
-        }
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_LOCK_REUSE:
-    case EC_STATE_LOCK_REUSE:
-        ec_lock_reuse(fop);
+        case -EC_STATE_LOCK_REUSE:
+        case EC_STATE_LOCK_REUSE:
+            ec_lock_reuse(fop);
 
-        return EC_STATE_UNLOCK;
+            return EC_STATE_UNLOCK;
 
-    case -EC_STATE_UNLOCK:
-    case EC_STATE_UNLOCK:
-        ec_unlock(fop);
+        case -EC_STATE_UNLOCK:
+        case EC_STATE_UNLOCK:
+            ec_unlock(fop);
 
-        return EC_STATE_END;
+            return EC_STATE_END;
 
-    default:
-        gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_UNHANDLED_STATE,
-                "Unhandled state %d for %s",
-                state, ec_fop_name(fop->id));
+        default:
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
-        return EC_STATE_END;
+            return EC_STATE_END;
     }
 }
 
-void ec_fallocate(call_frame_t *frame, xlator_t *this, uintptr_t target,
-              int32_t minimum, fop_fallocate_cbk_t func, void *data, fd_t *fd,
-              int32_t mode, off_t offset, size_t len, dict_t *xdata)
+void
+ec_fallocate(call_frame_t *frame, xlator_t *this, uintptr_t target,
+             int32_t minimum, fop_fallocate_cbk_t func, void *data, fd_t *fd,
+             int32_t mode, off_t offset, size_t len, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fallocate = func };
+    ec_cbk_t callback = {.fallocate = func};
     ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FALLOCATE) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FALLOCATE) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1097,22 +1063,20 @@ void ec_fallocate(call_frame_t *frame, xlator_t *this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_FILE_DESC_REF_FAIL,
-                        "Failed to reference a "
-                        "file descriptor.");
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
+            goto out;
         }
     }
 
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
+            goto out;
         }
     }
 
@@ -1131,66 +1095,70 @@ out:
  * File Operation : Discard
  *
  *********************************************************************/
-void ec_update_discard_write(ec_fop_data_t *fop, uintptr_t mask)
+void
+ec_update_discard_write(ec_fop_data_t *fop, uintptr_t mask)
 {
-    ec_t   *ec       = fop->xl->private;
-    off_t  off_head  = 0;
-    off_t  off_tail  = 0;
+    ec_t *ec = fop->xl->private;
+    off_t off_head = 0;
+    off_t off_tail = 0;
     size_t size_head = 0;
     size_t size_tail = 0;
-    int    error     = 0;
+    int error = 0;
 
     off_head = fop->offset * ec->fragments - fop->int32;
     if (fop->size == 0) {
-            error = ec_update_write (fop, mask, off_head, fop->user_size);
+        error = ec_update_write(fop, mask, off_head, fop->user_size);
     } else {
-            size_head = fop->int32;
-            size_tail = (off_head + fop->user_size) % ec->stripe_size;
-            off_tail = off_head + fop->user_size - size_tail;
-            if (size_head) {
-                    error = ec_update_write (fop, mask, off_head, size_head);
-                    if (error) {
-                        goto out;
-                    }
-            }
-            if (size_tail) {
-                    error = ec_update_write (fop, mask, off_tail, size_tail);
+        size_head = fop->int32;
+        size_tail = (off_head + fop->user_size) % ec->stripe_size;
+        off_tail = off_head + fop->user_size - size_tail;
+        if (size_head) {
+            error = ec_update_write(fop, mask, off_head, size_head);
+            if (error) {
+                goto out;
             }
+        }
+        if (size_tail) {
+            error = ec_update_write(fop, mask, off_tail, size_tail);
+        }
     }
 out:
     if (error)
-            ec_fop_set_error (fop, -error);
+        ec_fop_set_error(fop, -error);
 }
 
-void ec_discard_adjust_offset_size(ec_fop_data_t *fop)
+void
+ec_discard_adjust_offset_size(ec_fop_data_t *fop)
 {
-        ec_t *ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
 
-        fop->user_size = fop->size;
-        /* If discard length covers at least a fragment on brick, we will
-         * perform discard operation(when fop->size is non-zero) else we just
-         * write zeros.
-         */
-        fop->int32 = ec_adjust_offset_up(ec, &fop->offset, _gf_true);
-        fop->frag_range.first = fop->offset;
-        if (fop->size < fop->int32) {
-                fop->size = 0;
-        } else {
-                fop->size -= fop->int32;
-                ec_adjust_size_down(ec, &fop->size, _gf_true);
-        }
-        fop->frag_range.last = fop->offset + fop->size;
+    fop->user_size = fop->size;
+    /* If discard length covers at least a fragment on brick, we will
+     * perform discard operation(when fop->size is non-zero) else we just
+     * write zeros.
+     */
+    fop->int32 = ec_adjust_offset_up(ec, &fop->offset, _gf_true);
+    fop->frag_range.first = fop->offset;
+    if (fop->size < fop->int32) {
+        fop->size = 0;
+    } else {
+        fop->size -= fop->int32;
+        ec_adjust_size_down(ec, &fop->size, _gf_true);
+    }
+    fop->frag_range.last = fop->offset + fop->size;
 }
 
-int32_t ec_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
+int32_t
+ec_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+               struct iatt *postbuf, dict_t *xdata)
 {
-    return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                               prebuf, postbuf, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prebuf,
+                              postbuf, xdata);
 }
 
-void ec_wind_discard(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
+void
+ec_wind_discard(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1199,146 +1167,144 @@ void ec_wind_discard(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
                       fop->fd, fop->offset, fop->size, fop->xdata);
 }
 
-int32_t ec_manager_discard(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_discard(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t *cbk     = NULL;
-    off_t         fl_start = 0;
-    size_t        fl_size  = 0;
-
+    ec_cbk_data_t *cbk = NULL;
+    off_t fl_start = 0;
+    size_t fl_size = 0;
 
     switch (state) {
-    case EC_STATE_INIT:
-        if ((fop->size <= 0) || (fop->offset < 0)) {
+        case EC_STATE_INIT:
+            if ((fop->size <= 0) || (fop->offset < 0)) {
                 ec_fop_set_error(fop, EINVAL);
                 return EC_STATE_REPORT;
-        }
-        /* Because of the head/tail writes, "discard" happens on the remaining
-         * regions, but we need to compute region including head/tail writes
-         * so compute them separately*/
-        fl_start = fop->offset;
-        fl_size = fop->size;
-        fl_size += ec_adjust_offset_down (fop->xl->private, &fl_start,
-                                          _gf_true);
-        ec_adjust_size_up (fop->xl->private, &fl_size, _gf_true);
+            }
+            /* Because of the head/tail writes, "discard" happens on the
+             * remaining regions, but we need to compute region including
+             * head/tail writes so compute them separately*/
+            fl_start = fop->offset;
+            fl_size = fop->size;
+            fl_size += ec_adjust_offset_down(fop->xl->private, &fl_start,
+                                             _gf_true);
+            ec_adjust_size_up(fop->xl->private, &fl_size, _gf_true);
 
-        ec_discard_adjust_offset_size(fop);
+            ec_discard_adjust_offset_size(fop);
 
-    /* Fall through */
+            /* Fall through */
 
-    case EC_STATE_LOCK:
-        ec_lock_prepare_fd(fop, fop->fd,
-                           EC_UPDATE_DATA | EC_UPDATE_META |
-                           EC_QUERY_INFO, fl_start, fl_size);
-        ec_lock(fop);
+        case EC_STATE_LOCK:
+            ec_lock_prepare_fd(fop, fop->fd,
+                               EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
+                               fl_start, fl_size);
+            ec_lock(fop);
 
-        return EC_STATE_DISPATCH;
+            return EC_STATE_DISPATCH;
 
-    case EC_STATE_DISPATCH:
+        case EC_STATE_DISPATCH:
 
-        /* Dispatch discard fop only if we have whole fragment
-         * to deallocate */
-        if (fop->size) {
+            /* Dispatch discard fop only if we have whole fragment
+             * to deallocate */
+            if (fop->size) {
                 ec_dispatch_all(fop);
                 return EC_STATE_DELAYED_START;
-        } else {
+            } else {
                 /*Assume discard to have succeeded on mask*/
                 fop->good = fop->mask;
-        }
+            }
 
-        /* Fall through */
+            /* Fall through */
 
-    case EC_STATE_DELAYED_START:
+        case EC_STATE_DELAYED_START:
 
-        if (fop->size) {
+            if (fop->size) {
                 if (fop->answer && fop->answer->op_ret == 0)
-                        ec_update_discard_write (fop, fop->answer->mask);
-        } else {
-                ec_update_discard_write (fop, fop->mask);
-        }
+                    ec_update_discard_write(fop, fop->answer->mask);
+            } else {
+                ec_update_discard_write(fop, fop->mask);
+            }
 
-        return EC_STATE_PREPARE_ANSWER;
+            return EC_STATE_PREPARE_ANSWER;
 
-    case EC_STATE_PREPARE_ANSWER:
-        cbk = ec_fop_prepare_answer(fop, _gf_false);
-        if (cbk != NULL) {
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                                cbk->count);
+        case EC_STATE_PREPARE_ANSWER:
+            cbk = ec_fop_prepare_answer(fop, _gf_false);
+            if (cbk != NULL) {
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                 /* This shouldn't fail because we have the inode locked. */
                 GF_ASSERT(ec_get_inode_size(fop, fop->locks[0].lock->loc.inode,
                                             &cbk->iatt[0].ia_size));
 
                 cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
-        }
-        return EC_STATE_REPORT;
+            }
+            return EC_STATE_REPORT;
 
-    case EC_STATE_REPORT:
-        cbk = fop->answer;
+        case EC_STATE_REPORT:
+            cbk = fop->answer;
 
-        GF_ASSERT(cbk != NULL);
+            GF_ASSERT(cbk != NULL);
 
-        if (fop->cbks.discard != NULL) {
+            if (fop->cbks.discard != NULL) {
                 fop->cbks.discard(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                   cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                   cbk->xdata);
-        }
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_INIT:
-    case -EC_STATE_LOCK:
-    case -EC_STATE_DISPATCH:
-    case -EC_STATE_DELAYED_START:
-    case -EC_STATE_PREPARE_ANSWER:
-    case -EC_STATE_REPORT:
-        GF_ASSERT(fop->error != 0);
+        case -EC_STATE_INIT:
+        case -EC_STATE_LOCK:
+        case -EC_STATE_DISPATCH:
+        case -EC_STATE_DELAYED_START:
+        case -EC_STATE_PREPARE_ANSWER:
+        case -EC_STATE_REPORT:
+            GF_ASSERT(fop->error != 0);
 
-        if (fop->cbks.discard != NULL) {
-                fop->cbks.discard(fop->req_frame, fop, fop->xl, -1,
-                                  fop->error, NULL, NULL, NULL);
-        }
+            if (fop->cbks.discard != NULL) {
+                fop->cbks.discard(fop->req_frame, fop, fop->xl, -1, fop->error,
+                                  NULL, NULL, NULL);
+            }
 
-        return EC_STATE_LOCK_REUSE;
+            return EC_STATE_LOCK_REUSE;
 
-    case -EC_STATE_LOCK_REUSE:
-    case EC_STATE_LOCK_REUSE:
-        ec_lock_reuse(fop);
+        case -EC_STATE_LOCK_REUSE:
+        case EC_STATE_LOCK_REUSE:
+            ec_lock_reuse(fop);
 
-        return EC_STATE_UNLOCK;
+            return EC_STATE_UNLOCK;
 
-    case -EC_STATE_UNLOCK:
-    case EC_STATE_UNLOCK:
-        ec_unlock(fop);
+        case -EC_STATE_UNLOCK:
+        case EC_STATE_UNLOCK:
+            ec_unlock(fop);
 
-        return EC_STATE_END;
+            return EC_STATE_END;
 
-    default:
-        gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_UNHANDLED_STATE,
-                "Unhandled state %d for %s",
-                state, ec_fop_name(fop->id));
+        default:
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
-        return EC_STATE_END;
+            return EC_STATE_END;
     }
 }
 
-void ec_discard(call_frame_t *frame, xlator_t *this, uintptr_t target,
-                int32_t minimum, fop_discard_cbk_t func, void *data, fd_t *fd,
-                off_t offset, size_t len, dict_t *xdata)
+void
+ec_discard(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_discard_cbk_t func, void *data, fd_t *fd,
+           off_t offset, size_t len, dict_t *xdata)
 {
-    ec_cbk_t callback = { .discard = func };
+    ec_cbk_t callback = {.discard = func};
     ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(DISCARD) %p", frame);
+    gf_msg_trace("ec", 0, "EC(DISCARD) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_DISCARD, 0, target,
-                               minimum, ec_wind_discard, ec_manager_discard,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_DISCARD, 0, target, minimum,
+                               ec_wind_discard, ec_manager_discard, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -1371,33 +1337,35 @@ out:
  *
  *********************************************************************/
 
-int32_t ec_update_truncate_write (ec_fop_data_t *fop, uintptr_t mask)
+int32_t
+ec_update_truncate_write(ec_fop_data_t *fop, uintptr_t mask)
 {
-        ec_t *ec = fop->xl->private;
-        size_t size = fop->offset * ec->fragments - fop->user_size;
-        return ec_update_write (fop, mask, fop->user_size, size);
+    ec_t *ec = fop->xl->private;
+    size_t size = fop->offset * ec->fragments - fop->user_size;
+    return ec_update_write(fop, mask, fop->user_size, size);
 }
 
-int32_t ec_truncate_open_cbk(call_frame_t * frame, void * cookie,
-                             xlator_t * this, int32_t op_ret, int32_t op_errno,
-                             fd_t * fd, dict_t * xdata)
+int32_t
+ec_truncate_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-    ec_fop_data_t * fop = cookie;
+    ec_fop_data_t *fop = cookie;
     int32_t err;
 
     fop->parent->good &= fop->good;
     if (op_ret >= 0) {
-        fd_bind (fd);
-        err = ec_update_truncate_write (fop->parent, fop->answer->mask);
+        fd_bind(fd);
+        err = ec_update_truncate_write(fop->parent, fop->answer->mask);
         if (err != 0) {
-            ec_fop_set_error (fop->parent, -err);
+            ec_fop_set_error(fop->parent, -err);
         }
     }
 
     return 0;
 }
 
-int32_t ec_truncate_clean(ec_fop_data_t * fop)
+int32_t
+ec_truncate_clean(ec_fop_data_t *fop)
 {
     if (fop->fd == NULL) {
         fop->fd = fd_create(fop->loc[0].inode, fop->frame->root->pid);
@@ -1406,24 +1374,25 @@ int32_t ec_truncate_clean(ec_fop_data_t * fop)
         }
 
         ec_open(fop->frame, fop->xl, fop->answer->mask, fop->minimum,
-                ec_truncate_open_cbk, fop, &fop->loc[0], O_RDWR, fop->fd,
-                NULL);
+                ec_truncate_open_cbk, fop, &fop->loc[0], O_RDWR, fop->fd, NULL);
 
         return 0;
     } else {
-        return ec_update_truncate_write (fop, fop->answer->mask);
+        return ec_update_truncate_write(fop, fop->answer->mask);
     }
 }
 
-int32_t ec_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *prestat,
-                         struct iatt *poststat, dict_t *xdata)
+int32_t
+ec_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, struct iatt *prestat,
+                struct iatt *poststat, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prestat, poststat, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prestat,
+                              poststat, xdata);
 }
 
-void ec_wind_truncate(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_truncate(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1432,29 +1401,31 @@ void ec_wind_truncate(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       &fop->loc[0], fop->offset, fop->xdata);
 }
 
-int32_t ec_manager_truncate(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_truncate(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
             fop->user_size = fop->offset;
             ec_adjust_offset_up(fop->xl->private, &fop->offset, _gf_true);
             fop->frag_range.first = fop->offset;
             fop->frag_range.last = UINT64_MAX;
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_LOCK:
             if (fop->id == GF_FOP_TRUNCATE) {
-                ec_lock_prepare_inode(fop, &fop->loc[0],
-                                      EC_UPDATE_DATA | EC_UPDATE_META |
-                                      EC_QUERY_INFO, fop->offset, LLONG_MAX);
+                ec_lock_prepare_inode(
+                    fop, &fop->loc[0],
+                    EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
+                    fop->offset, LLONG_MAX);
             } else {
-                ec_lock_prepare_fd(fop, fop->fd,
-                                   EC_UPDATE_DATA | EC_UPDATE_META |
-                                   EC_QUERY_INFO, fop->offset, LLONG_MAX);
+                ec_lock_prepare_fd(
+                    fop, fop->fd,
+                    EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
+                    fop->offset, LLONG_MAX);
             }
             ec_lock(fop);
 
@@ -1470,8 +1441,7 @@ int32_t ec_manager_truncate(ec_fop_data_t * fop, int32_t state)
             if (cbk != NULL) {
                 int32_t err;
 
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                                cbk->count);
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                 /* This shouldn't fail because we have the inode locked. */
                 /* Inode size doesn't need to be updated under locks, because
@@ -1499,20 +1469,15 @@ int32_t ec_manager_truncate(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_TRUNCATE)
-            {
-                if (fop->cbks.truncate != NULL)
-                {
+            if (fop->id == GF_FOP_TRUNCATE) {
+                if (fop->cbks.truncate != NULL) {
                     fop->cbks.truncate(fop->req_frame, fop, fop->xl,
                                        cbk->op_ret, cbk->op_errno,
                                        &cbk->iatt[0], &cbk->iatt[1],
                                        cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.ftruncate != NULL)
-                {
+            } else {
+                if (fop->cbks.ftruncate != NULL) {
                     fop->cbks.ftruncate(fop->req_frame, fop, fop->xl,
                                         cbk->op_ret, cbk->op_errno,
                                         &cbk->iatt[0], &cbk->iatt[1],
@@ -1529,18 +1494,13 @@ int32_t ec_manager_truncate(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_TRUNCATE)
-            {
-                if (fop->cbks.truncate != NULL)
-                {
+            if (fop->id == GF_FOP_TRUNCATE) {
+                if (fop->cbks.truncate != NULL) {
                     fop->cbks.truncate(fop->req_frame, fop, fop->xl, -1,
                                        fop->error, NULL, NULL, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.ftruncate != NULL)
-                {
+            } else {
+                if (fop->cbks.ftruncate != NULL) {
                     fop->cbks.ftruncate(fop->req_frame, fop, fop->xl, -1,
                                         fop->error, NULL, NULL, NULL);
                 }
@@ -1561,32 +1521,31 @@ int32_t ec_manager_truncate(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_truncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_truncate_cbk_t func, void * data,
-                 loc_t * loc, off_t offset, dict_t * xdata)
+void
+ec_truncate(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_truncate_cbk_t func, void *data, loc_t *loc,
+            off_t offset, dict_t *xdata)
 {
-    ec_cbk_t callback = { .truncate = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.truncate = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(TRUNCATE) %p", frame);
+    gf_msg_trace("ec", 0, "EC(TRUNCATE) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_TRUNCATE, 0, target,
-                               minimum, ec_wind_truncate, ec_manager_truncate,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_TRUNCATE, 0, target, minimum,
+                               ec_wind_truncate, ec_manager_truncate, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -1595,9 +1554,8 @@ void ec_truncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
 
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -1605,10 +1563,9 @@ void ec_truncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1626,16 +1583,17 @@ out:
 
 /* FOP: ftruncate */
 
-int32_t ec_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno,
-                          struct iatt *prestat, struct iatt *poststat,
-                          dict_t *xdata)
+int32_t
+ec_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *prestat,
+                 struct iatt *poststat, dict_t *xdata)
 {
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prestat, poststat, xdata);
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prestat,
+                              poststat, xdata);
 }
 
-void ec_wind_ftruncate(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_ftruncate(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1644,15 +1602,16 @@ void ec_wind_ftruncate(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->fd, fop->offset, fop->xdata);
 }
 
-void ec_ftruncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                  int32_t minimum, fop_ftruncate_cbk_t func, void * data,
-                  fd_t * fd, off_t offset, dict_t * xdata)
+void
+ec_ftruncate(call_frame_t *frame, xlator_t *this, uintptr_t target,
+             int32_t minimum, fop_ftruncate_cbk_t func, void *data, fd_t *fd,
+             off_t offset, dict_t *xdata)
 {
-    ec_cbk_t callback = { .ftruncate = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.ftruncate = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FTRUNCATE) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FTRUNCATE) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1672,10 +1631,9 @@ void ec_ftruncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -1683,10 +1641,9 @@ void ec_ftruncate(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -1704,95 +1661,91 @@ out:
 
 /* FOP: writev */
 static ec_stripe_t *
-ec_allocate_stripe (ec_t *ec, ec_stripe_list_t *stripe_cache)
+ec_allocate_stripe(ec_t *ec, ec_stripe_list_t *stripe_cache)
 {
-        ec_stripe_t *stripe = NULL;
+    ec_stripe_t *stripe = NULL;
 
-        if (stripe_cache->count >= stripe_cache->max) {
-                GF_ASSERT (!list_empty(&stripe_cache->lru));
-                stripe = list_first_entry(&stripe_cache->lru, ec_stripe_t, lru);
-                list_move_tail(&stripe->lru, &stripe_cache->lru);
-                GF_ATOMIC_INC(ec->stats.stripe_cache.evicts);
+    if (stripe_cache->count >= stripe_cache->max) {
+        GF_ASSERT(!list_empty(&stripe_cache->lru));
+        stripe = list_first_entry(&stripe_cache->lru, ec_stripe_t, lru);
+        list_move_tail(&stripe->lru, &stripe_cache->lru);
+        GF_ATOMIC_INC(ec->stats.stripe_cache.evicts);
+    } else {
+        stripe = GF_MALLOC(sizeof(ec_stripe_t) + ec->stripe_size,
+                           ec_mt_ec_stripe_t);
+        if (stripe != NULL) {
+            stripe_cache->count++;
+            list_add_tail(&stripe->lru, &stripe_cache->lru);
+            GF_ATOMIC_INC(ec->stats.stripe_cache.allocs);
         } else {
-                stripe = GF_MALLOC (sizeof (ec_stripe_t) + ec->stripe_size,
-                                    ec_mt_ec_stripe_t);
-                if (stripe != NULL) {
-                        stripe_cache->count++;
-                        list_add_tail (&stripe->lru, &stripe_cache->lru);
-                        GF_ATOMIC_INC(ec->stats.stripe_cache.allocs);
-                } else {
-                        GF_ATOMIC_INC(ec->stats.stripe_cache.errors);
-                }
+            GF_ATOMIC_INC(ec->stats.stripe_cache.errors);
         }
+    }
 
-        return stripe;
+    return stripe;
 }
 
 static void
-ec_write_stripe_data (ec_t *ec, ec_fop_data_t *fop,
-                      ec_stripe_t *stripe)
+ec_write_stripe_data(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 {
-        off_t   base;
+    off_t base;
 
-        base = fop->size - ec->stripe_size;
-        memcpy(stripe->data, fop->vector[0].iov_base + base, ec->stripe_size);
-        stripe->frag_offset = fop->frag_range.last - ec->fragment_size;
+    base = fop->size - ec->stripe_size;
+    memcpy(stripe->data, fop->vector[0].iov_base + base, ec->stripe_size);
+    stripe->frag_offset = fop->frag_range.last - ec->fragment_size;
 }
 
 static void
-ec_add_stripe_in_cache (ec_t *ec, ec_fop_data_t *fop)
+ec_add_stripe_in_cache(ec_t *ec, ec_fop_data_t *fop)
 {
-        ec_inode_t       *ctx    = NULL;
-        ec_stripe_t      *stripe = NULL;
-        ec_stripe_list_t *stripe_cache = NULL;
-        gf_boolean_t      failed = _gf_true;
-
-        LOCK(&fop->fd->inode->lock);
+    ec_inode_t *ctx = NULL;
+    ec_stripe_t *stripe = NULL;
+    ec_stripe_list_t *stripe_cache = NULL;
+    gf_boolean_t failed = _gf_true;
 
-        ctx = __ec_inode_get (fop->fd->inode, fop->xl);
-        if (ctx == NULL) {
-                goto out;
-        }
+    LOCK(&fop->fd->inode->lock);
 
-        stripe_cache = &ctx->stripe_cache;
-        if (stripe_cache->max > 0) {
-                stripe = ec_allocate_stripe (ec, stripe_cache);
-                if (stripe == NULL) {
-                        goto out;
-                }
+    ctx = __ec_inode_get(fop->fd->inode, fop->xl);
+    if (ctx == NULL) {
+        goto out;
+    }
 
-                ec_write_stripe_data (ec, fop, stripe);
+    stripe_cache = &ctx->stripe_cache;
+    if (stripe_cache->max > 0) {
+        stripe = ec_allocate_stripe(ec, stripe_cache);
+        if (stripe == NULL) {
+            goto out;
         }
 
-        failed = _gf_false;
+        ec_write_stripe_data(ec, fop, stripe);
+    }
+
+    failed = _gf_false;
 
 out:
-        UNLOCK(&fop->fd->inode->lock);
+    UNLOCK(&fop->fd->inode->lock);
 
-        if (failed) {
-                gf_msg (ec->xl->name, GF_LOG_DEBUG, ENOMEM,
-                        EC_MSG_FILE_DESC_REF_FAIL,
-                        "Failed to create and add stripe in cache");
-        }
+    if (failed) {
+        gf_msg(ec->xl->name, GF_LOG_DEBUG, ENOMEM, EC_MSG_FILE_DESC_REF_FAIL,
+               "Failed to create and add stripe in cache");
+    }
 }
 
-int32_t ec_writev_merge_tail(call_frame_t * frame, void * cookie,
-                             xlator_t * this, int32_t op_ret, int32_t op_errno,
-                             struct iovec * vector, int32_t count,
-                             struct iatt * stbuf, struct iobref * iobref,
-                             dict_t * xdata)
+int32_t
+ec_writev_merge_tail(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                     int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                     dict_t *xdata)
 {
-    ec_t * ec = this->private;
-    ec_fop_data_t * fop = frame->local;
+    ec_t *ec = this->private;
+    ec_fop_data_t *fop = frame->local;
     size_t size, base, tmp;
 
-    if (op_ret >= 0)
-    {
+    if (op_ret >= 0) {
         tmp = 0;
         size = fop->size - fop->user_size - fop->head;
         base = ec->stripe_size - size;
-        if (op_ret > base)
-        {
+        if (op_ret > base) {
             tmp = min(op_ret - base, size);
             ec_iov_copy_to(fop->vector[0].iov_base + fop->size - size, vector,
                            count, base, tmp);
@@ -1800,49 +1753,44 @@ int32_t ec_writev_merge_tail(call_frame_t * frame, void * cookie,
             size -= tmp;
         }
 
-        if (size > 0)
-        {
+        if (size > 0) {
             memset(fop->vector[0].iov_base + fop->size - size, 0, size);
         }
 
         if (ec->stripe_cache) {
-                ec_add_stripe_in_cache (ec, fop);
+            ec_add_stripe_in_cache(ec, fop);
         }
     }
     return 0;
 }
 
-int32_t ec_writev_merge_head(call_frame_t * frame, void * cookie,
-                             xlator_t * this, int32_t op_ret, int32_t op_errno,
-                             struct iovec * vector, int32_t count,
-                             struct iatt * stbuf, struct iobref * iobref,
-                             dict_t * xdata)
+int32_t
+ec_writev_merge_head(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                     int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                     dict_t *xdata)
 {
-    ec_t * ec = this->private;
-    ec_fop_data_t * fop = frame->local;
+    ec_t *ec = this->private;
+    ec_fop_data_t *fop = frame->local;
     size_t size, base;
 
-    if (op_ret >= 0)
-    {
+    if (op_ret >= 0) {
         size = fop->head;
         base = 0;
 
-        if (op_ret > 0)
-        {
+        if (op_ret > 0) {
             base = min(op_ret, size);
             ec_iov_copy_to(fop->vector[0].iov_base, vector, count, 0, base);
 
             size -= base;
         }
 
-        if (size > 0)
-        {
+        if (size > 0) {
             memset(fop->vector[0].iov_base + base, 0, size);
         }
 
         size = fop->size - fop->user_size - fop->head;
-        if ((size > 0) && (fop->size == ec->stripe_size))
-        {
+        if ((size > 0) && (fop->size == ec->stripe_size)) {
             ec_writev_merge_tail(frame, cookie, this, op_ret, op_errno, vector,
                                  count, stbuf, iobref, xdata);
         }
@@ -1852,7 +1800,7 @@ int32_t ec_writev_merge_head(call_frame_t * frame, void * cookie,
 }
 
 static int
-ec_make_internal_fop_xdata (dict_t **xdata)
+ec_make_internal_fop_xdata(dict_t **xdata)
 {
     dict_t *dict = NULL;
 
@@ -1861,16 +1809,16 @@ ec_make_internal_fop_xdata (dict_t **xdata)
 
     dict = dict_new();
     if (!dict)
-       goto out;
+        goto out;
 
-    if (dict_set_str (dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes"))
-       goto out;
+    if (dict_set_str(dict, GLUSTERFS_INTERNAL_FOP_KEY, "yes"))
+        goto out;
 
     *xdata = dict;
     return 0;
 out:
     if (dict)
-            dict_unref (dict);
+        dict_unref(dict);
     return -1;
 }
 
@@ -1889,8 +1837,7 @@ ec_writev_prepare_buffers(ec_t *ec, ec_fop_data_t *fop)
     ec_adjust_size_up(ec, &fop->size, _gf_false);
     fop->frag_range.last = fop->frag_range.first + fop->size / ec->fragments;
 
-    if ((fop->int32 != 1) || (fop->head != 0) ||
-        (fop->size > fop->user_size) ||
+    if ((fop->int32 != 1) || (fop->head != 0) || (fop->size > fop->user_size) ||
         !EC_ALIGN_CHECK(fop->vector[0].iov_base, EC_METHOD_WORD_SIZE)) {
         err = ec_buffer_alloc(ec->xl, fop->size, &iobref, &ptr);
         if (err != 0) {
@@ -1935,98 +1882,99 @@ out:
 }
 
 static void
-ec_merge_stripe_head_locked (ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
+ec_merge_stripe_head_locked(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 {
-        size_t head, size;
+    size_t head, size;
 
-        head = fop->head;
-        memcpy(fop->vector[0].iov_base, stripe->data, head);
+    head = fop->head;
+    memcpy(fop->vector[0].iov_base, stripe->data, head);
 
+    size = ec->stripe_size - head;
+    if (size > fop->user_size) {
+        head += fop->user_size;
         size = ec->stripe_size - head;
-        if (size > fop->user_size) {
-                head += fop->user_size;
-                size = ec->stripe_size - head;
-                memcpy(fop->vector[0].iov_base + head, stripe->data + head,
-                       size);
-        }
+        memcpy(fop->vector[0].iov_base + head, stripe->data + head, size);
+    }
 }
 
 static void
-ec_merge_stripe_tail_locked (ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
+ec_merge_stripe_tail_locked(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 {
-        size_t head, tail;
-        off_t  offset;
+    size_t head, tail;
+    off_t offset;
 
-        offset = fop->user_size + fop->head;
-        tail = fop->size - offset;
-        head = ec->stripe_size - tail;
+    offset = fop->user_size + fop->head;
+    tail = fop->size - offset;
+    head = ec->stripe_size - tail;
 
-        memcpy(fop->vector[0].iov_base + offset, stripe->data + head, tail);
+    memcpy(fop->vector[0].iov_base + offset, stripe->data + head, tail);
 }
 
 static ec_stripe_t *
-ec_get_stripe_from_cache_locked (ec_t *ec, ec_fop_data_t *fop,
-                                 uint64_t frag_offset)
+ec_get_stripe_from_cache_locked(ec_t *ec, ec_fop_data_t *fop,
+                                uint64_t frag_offset)
 {
-        ec_inode_t       *ctx    = NULL;
-        ec_stripe_t      *stripe = NULL;
-        ec_stripe_list_t *stripe_cache = NULL;
-
-        ctx = __ec_inode_get (fop->fd->inode, fop->xl);
-        if (ctx == NULL) {
-                GF_ATOMIC_INC(ec->stats.stripe_cache.errors);
-                return NULL;
-        }
+    ec_inode_t *ctx = NULL;
+    ec_stripe_t *stripe = NULL;
+    ec_stripe_list_t *stripe_cache = NULL;
 
-        stripe_cache = &ctx->stripe_cache;
-        list_for_each_entry (stripe, &stripe_cache->lru, lru) {
-                if (stripe->frag_offset == frag_offset) {
-                        list_move_tail (&stripe->lru, &stripe_cache->lru);
-                        GF_ATOMIC_INC(ec->stats.stripe_cache.hits);
-                        return stripe;
-                }
+    ctx = __ec_inode_get(fop->fd->inode, fop->xl);
+    if (ctx == NULL) {
+        GF_ATOMIC_INC(ec->stats.stripe_cache.errors);
+        return NULL;
+    }
+
+    stripe_cache = &ctx->stripe_cache;
+    list_for_each_entry(stripe, &stripe_cache->lru, lru)
+    {
+        if (stripe->frag_offset == frag_offset) {
+            list_move_tail(&stripe->lru, &stripe_cache->lru);
+            GF_ATOMIC_INC(ec->stats.stripe_cache.hits);
+            return stripe;
         }
+    }
 
-        GF_ATOMIC_INC(ec->stats.stripe_cache.misses);
+    GF_ATOMIC_INC(ec->stats.stripe_cache.misses);
 
-        return NULL;
+    return NULL;
 }
 
 static gf_boolean_t
-ec_get_and_merge_stripe (ec_t *ec, ec_fop_data_t *fop, ec_stripe_part_t which)
+ec_get_and_merge_stripe(ec_t *ec, ec_fop_data_t *fop, ec_stripe_part_t which)
 {
-        uint64_t      frag_offset;
-        ec_stripe_t  *stripe = NULL;
-        gf_boolean_t  found  = _gf_false;
+    uint64_t frag_offset;
+    ec_stripe_t *stripe = NULL;
+    gf_boolean_t found = _gf_false;
 
-        if (!ec->stripe_cache) {
-                return found;
-        }
+    if (!ec->stripe_cache) {
+        return found;
+    }
 
-        LOCK(&fop->fd->inode->lock);
-        if (which == EC_STRIPE_HEAD) {
-                frag_offset = fop->frag_range.first;
-                stripe = ec_get_stripe_from_cache_locked(ec, fop, frag_offset);
-                if (stripe) {
-                        ec_merge_stripe_head_locked (ec, fop, stripe);
-                        found = _gf_true;
-                }
+    LOCK(&fop->fd->inode->lock);
+    if (which == EC_STRIPE_HEAD) {
+        frag_offset = fop->frag_range.first;
+        stripe = ec_get_stripe_from_cache_locked(ec, fop, frag_offset);
+        if (stripe) {
+            ec_merge_stripe_head_locked(ec, fop, stripe);
+            found = _gf_true;
         }
+    }
 
-        if (which == EC_STRIPE_TAIL) {
-                frag_offset = fop->frag_range.last - ec->fragment_size;
-                stripe = ec_get_stripe_from_cache_locked(ec, fop, frag_offset);
-                if (stripe) {
-                        ec_merge_stripe_tail_locked (ec, fop, stripe);
-                        found = _gf_true;
-                }
+    if (which == EC_STRIPE_TAIL) {
+        frag_offset = fop->frag_range.last - ec->fragment_size;
+        stripe = ec_get_stripe_from_cache_locked(ec, fop, frag_offset);
+        if (stripe) {
+            ec_merge_stripe_tail_locked(ec, fop, stripe);
+            found = _gf_true;
         }
-        UNLOCK(&fop->fd->inode->lock);
+    }
+    UNLOCK(&fop->fd->inode->lock);
 
-        return found;
+    return found;
 }
 
-void ec_writev_start(ec_fop_data_t *fop)
+void
+ec_writev_start(ec_fop_data_t *fop)
 {
     ec_t *ec = fop->xl->private;
     ec_fd_t *ctx;
@@ -2062,40 +2010,39 @@ void ec_writev_start(ec_fop_data_t *fop)
         goto failed_fd;
     }
     if (fop->head > 0) {
-        found_stripe = ec_get_and_merge_stripe (ec, fop, EC_STRIPE_HEAD);
+        found_stripe = ec_get_and_merge_stripe(ec, fop, EC_STRIPE_HEAD);
         if (!found_stripe) {
-                if (ec_make_internal_fop_xdata (&xdata)) {
-                        err = -ENOMEM;
-                        goto failed_xdata;
-                }
-                ec_readv(fop->frame, fop->xl, -1, EC_MINIMUM_MIN,
-                         ec_writev_merge_head,
-                         NULL, fd, ec->stripe_size, fop->offset, 0, xdata);
+            if (ec_make_internal_fop_xdata(&xdata)) {
+                err = -ENOMEM;
+                goto failed_xdata;
+            }
+            ec_readv(fop->frame, fop->xl, -1, EC_MINIMUM_MIN,
+                     ec_writev_merge_head, NULL, fd, ec->stripe_size,
+                     fop->offset, 0, xdata);
         }
     }
 
     tail = fop->size - fop->user_size - fop->head;
     if ((tail > 0) && ((fop->head == 0) || (fop->size > ec->stripe_size))) {
-            /* Current locking scheme will make sure the 'current' below will
-             * never decrease while the fop is in progress, so the checks will
-             * work as expected
-             */
+        /* Current locking scheme will make sure the 'current' below will
+         * never decrease while the fop is in progress, so the checks will
+         * work as expected
+         */
         if (current > fop->offset + fop->head + fop->user_size) {
-            found_stripe = ec_get_and_merge_stripe (ec, fop, EC_STRIPE_TAIL);
+            found_stripe = ec_get_and_merge_stripe(ec, fop, EC_STRIPE_TAIL);
             if (!found_stripe) {
-                    if (ec_make_internal_fop_xdata (&xdata)) {
-                            err = -ENOMEM;
-                            goto failed_xdata;
-                    }
-                    ec_readv(fop->frame, fop->xl, -1, EC_MINIMUM_MIN,
-                             ec_writev_merge_tail, NULL, fd, ec->stripe_size,
-                             fop->offset + fop->size - ec->stripe_size,
-                             0, xdata);
+                if (ec_make_internal_fop_xdata(&xdata)) {
+                    err = -ENOMEM;
+                    goto failed_xdata;
+                }
+                ec_readv(fop->frame, fop->xl, -1, EC_MINIMUM_MIN,
+                         ec_writev_merge_tail, NULL, fd, ec->stripe_size,
+                         fop->offset + fop->size - ec->stripe_size, 0, xdata);
             }
         } else {
             memset(fop->vector[0].iov_base + fop->size - tail, 0, tail);
             if (ec->stripe_cache) {
-                ec_add_stripe_in_cache (ec, fop);
+                ec_add_stripe_in_cache(ec, fop);
             }
         }
     }
@@ -2112,23 +2059,25 @@ failed:
     ec_fop_set_error(fop, -err);
 }
 
-int32_t ec_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prestat,
-                       struct iatt *poststat, dict_t *xdata)
+int32_t
+ec_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *prestat, struct iatt *poststat,
+              dict_t *xdata)
 {
-        ec_t    *ec = NULL;
-        if (this && this->private) {
-                ec = this->private;
-                if ((op_ret > 0) && ((op_ret % ec->fragment_size) != 0)) {
-                        op_ret = -1;
-                        op_errno = EIO;
-                }
+    ec_t *ec = NULL;
+    if (this && this->private) {
+        ec = this->private;
+        if ((op_ret > 0) && ((op_ret % ec->fragment_size) != 0)) {
+            op_ret = -1;
+            op_errno = EIO;
         }
-        return ec_inode_write_cbk (frame, this, cookie, op_ret, op_errno,
-                                   prestat, poststat, xdata);
+    }
+    return ec_inode_write_cbk(frame, this, cookie, op_ret, op_errno, prestat,
+                              poststat, xdata);
 }
 
-void ec_wind_writev(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_writev(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -2141,9 +2090,9 @@ void ec_wind_writev(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
     vector[0].iov_len = size;
 
     STACK_WIND_COOKIE(fop->frame, ec_writev_cbk, (void *)(uintptr_t)idx,
-                      ec->xl_list[idx], ec->xl_list[idx]->fops->writev,
-                      fop->fd, vector, 1, fop->offset / ec->fragments,
-                      fop->uint32, fop->buffers, fop->xdata);
+                      ec->xl_list[idx], ec->xl_list[idx]->fops->writev, fop->fd,
+                      vector, 1, fop->offset / ec->fragments, fop->uint32,
+                      fop->buffers, fop->xdata);
 }
 
 static void
@@ -2161,35 +2110,34 @@ ec_writev_encode(ec_fop_data_t *fop)
                      fop->vector[0].iov_base, blocks);
 }
 
-int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
+int32_t
+ec_manager_writev(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk;
     ec_fd_t *ctx = NULL;
-    ec_t    *ec = fop->xl->private;
+    ec_t *ec = fop->xl->private;
     off_t fl_start = 0;
     size_t fl_size = LLONG_MAX;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-                ctx = ec_fd_get(fop->fd, fop->xl);
-                if (ctx != NULL) {
-                    if ((ctx->flags & O_APPEND) == 0) {
-                            off_t user_size = 0;
-                            off_t head = 0;
-
-                            fl_start = fop->offset;
-                            user_size = iov_length(fop->vector, fop->int32);
-                            head = ec_adjust_offset_down(ec, &fl_start,
-                                                         _gf_true);
-                            fl_size = user_size + head;
-                            ec_adjust_size_up(ec, &fl_size, _gf_true);
-                    }
+            ctx = ec_fd_get(fop->fd, fop->xl);
+            if (ctx != NULL) {
+                if ((ctx->flags & O_APPEND) == 0) {
+                    off_t user_size = 0;
+                    off_t head = 0;
+
+                    fl_start = fop->offset;
+                    user_size = iov_length(fop->vector, fop->int32);
+                    head = ec_adjust_offset_down(ec, &fl_start, _gf_true);
+                    fl_size = user_size + head;
+                    ec_adjust_size_up(ec, &fl_size, _gf_true);
                 }
+            }
             ec_lock_prepare_fd(fop, fop->fd,
-                               EC_UPDATE_DATA | EC_UPDATE_META |
-                               EC_QUERY_INFO, fl_start, fl_size);
+                               EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
+                               fl_start, fl_size);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -2217,29 +2165,28 @@ int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
                 ec_t *ec = fop->xl->private;
                 size_t size;
 
-                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2,
-                                cbk->count);
+                ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
                 /* This shouldn't fail because we have the inode locked. */
                 LOCK(&fop->fd->inode->lock);
                 {
-                        GF_ASSERT(__ec_get_inode_size(fop, fop->fd->inode,
-                                                    &cbk->iatt[0].ia_size));
-                        cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
-                        size = fop->offset + fop->head + fop->user_size;
-                        if (size > cbk->iatt[0].ia_size) {
-                           /* Only update inode size if this is a top level fop.
-                            * Otherwise this is an internal write and the top
-                            * level fop should take care of the real inode size.
-                            */
-                            if (fop->parent == NULL) {
-                                /* This shouldn't fail because we have the inode
-                                 * locked. */
-                                GF_ASSERT(__ec_set_inode_size(fop,
-                                                        fop->fd->inode, size));
-                            }
-                            cbk->iatt[1].ia_size = size;
+                    GF_ASSERT(__ec_get_inode_size(fop, fop->fd->inode,
+                                                  &cbk->iatt[0].ia_size));
+                    cbk->iatt[1].ia_size = cbk->iatt[0].ia_size;
+                    size = fop->offset + fop->head + fop->user_size;
+                    if (size > cbk->iatt[0].ia_size) {
+                        /* Only update inode size if this is a top level fop.
+                         * Otherwise this is an internal write and the top
+                         * level fop should take care of the real inode size.
+                         */
+                        if (fop->parent == NULL) {
+                            /* This shouldn't fail because we have the inode
+                             * locked. */
+                            GF_ASSERT(
+                                __ec_set_inode_size(fop, fop->fd->inode, size));
                         }
+                        cbk->iatt[1].ia_size = size;
+                    }
                 }
                 UNLOCK(&fop->fd->inode->lock);
 
@@ -2263,8 +2210,7 @@ int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.writev != NULL)
-            {
+            if (fop->cbks.writev != NULL) {
                 fop->cbks.writev(fop->req_frame, fop, fop->xl, cbk->op_ret,
                                  cbk->op_errno, &cbk->iatt[0], &cbk->iatt[1],
                                  cbk->xdata);
@@ -2278,7 +2224,7 @@ int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
             fop->frame->root->uid = fop->uid;
             fop->frame->root->gid = fop->gid;
 
-        /* Fall through */
+            /* Fall through */
 
         case -EC_STATE_INIT:
         case -EC_STATE_LOCK:
@@ -2287,8 +2233,7 @@ int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.writev != NULL)
-            {
+            if (fop->cbks.writev != NULL) {
                 fop->cbks.writev(fop->req_frame, fop, fop->xl, -1, fop->error,
                                  NULL, NULL, NULL);
             }
@@ -2308,25 +2253,24 @@ int32_t ec_manager_writev(ec_fop_data_t *fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_writev(call_frame_t * frame, xlator_t * this, uintptr_t target,
-               int32_t minimum, fop_writev_cbk_t func, void * data, fd_t * fd,
-               struct iovec * vector, int32_t count, off_t offset,
-               uint32_t flags, struct iobref * iobref, dict_t * xdata)
+void
+ec_writev(call_frame_t *frame, xlator_t *this, uintptr_t target,
+          int32_t minimum, fop_writev_cbk_t func, void *data, fd_t *fd,
+          struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
+          struct iobref *iobref, dict_t *xdata)
 {
-    ec_cbk_t callback = { .writev = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.writev = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(WRITE) %p", frame);
+    gf_msg_trace("ec", 0, "EC(WRITE) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -2348,10 +2292,9 @@ void ec_writev(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -2359,10 +2302,9 @@ void ec_writev(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (count > 0) {
         fop->vector = iov_dup(vector, count);
         if (fop->vector == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a "
-                    "vector list.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a "
+                   "vector list.");
 
             goto out;
         }
@@ -2371,10 +2313,9 @@ void ec_writev(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (iobref != NULL) {
         fop->buffers = iobref_ref(iobref);
         if (fop->buffers == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_BUF_REF_FAIL,
-                    "Failed to reference a "
-                    "buffer.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_BUF_REF_FAIL,
+                   "Failed to reference a "
+                   "buffer.");
 
             goto out;
         }
@@ -2382,10 +2323,9 @@ void ec_writev(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_copy_with_ref(xdata, NULL);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
diff --git a/xlators/cluster/ec/src/ec-locks.c b/xlators/cluster/ec/src/ec-locks.c
index d8ad7721f53..47a069b1775 100644
--- a/xlators/cluster/ec/src/ec-locks.c
+++ b/xlators/cluster/ec/src/ec-locks.c
@@ -19,10 +19,11 @@
 #include "ec-messages.h"
 
 #define EC_LOCK_MODE_NONE 0
-#define EC_LOCK_MODE_INC  1
-#define EC_LOCK_MODE_ALL  2
+#define EC_LOCK_MODE_INC 1
+#define EC_LOCK_MODE_ALL 2
 
-int32_t ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
+int32_t
+ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
 {
     ec_t *ec = fop->xl->private;
     ec_cbk_data_t *ans = NULL;
@@ -30,7 +31,8 @@ int32_t ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
     uintptr_t locked = 0, notlocked = 0;
     int32_t error = -1;
 
-    list_for_each_entry(ans, &fop->cbk_list, list) {
+    list_for_each_entry(ans, &fop->cbk_list, list)
+    {
         if (ans->op_ret >= 0) {
             if (locked != 0) {
                 error = EIO;
@@ -38,16 +40,16 @@ int32_t ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
             locked |= ans->mask;
             cbk = ans;
         } else {
-                if (ans->op_errno == EAGAIN) {
-                        switch (fop->uint32) {
-                        case EC_LOCK_MODE_NONE:
-                        case EC_LOCK_MODE_ALL:
-                                /* Goal is to treat non-blocking lock as failure
-                                 * even if there is a single EAGAIN*/
-                                notlocked |= ans->mask;
-                                break;
-                        }
+            if (ans->op_errno == EAGAIN) {
+                switch (fop->uint32) {
+                    case EC_LOCK_MODE_NONE:
+                    case EC_LOCK_MODE_ALL:
+                        /* Goal is to treat non-blocking lock as failure
+                         * even if there is a single EAGAIN*/
+                        notlocked |= ans->mask;
+                        break;
                 }
+            }
         }
     }
 
@@ -63,24 +65,24 @@ int32_t ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
                 error = 0;
             } else {
                 switch (fop->uint32) {
-                case EC_LOCK_MODE_NONE:
-                    error = EAGAIN;
-                    break;
+                    case EC_LOCK_MODE_NONE:
+                        error = EAGAIN;
+                        break;
 
-                case EC_LOCK_MODE_ALL:
-                    fop->uint32 = EC_LOCK_MODE_INC;
-                    break;
+                    case EC_LOCK_MODE_ALL:
+                        fop->uint32 = EC_LOCK_MODE_INC;
+                        break;
 
-                default:
-                    error = EIO;
-                    break;
+                    default:
+                        error = EIO;
+                        break;
                 }
             }
         } else {
             if (fop->answer && fop->answer->op_ret < 0)
-                    error = fop->answer->op_errno;
+                error = fop->answer->op_errno;
             else
-                    error = EIO;
+                error = EIO;
         }
     }
 
@@ -89,28 +91,25 @@ int32_t ec_lock_check(ec_fop_data_t *fop, uintptr_t *mask)
     return error;
 }
 
-int32_t ec_lock_unlocked(call_frame_t * frame, void * cookie,
-                         xlator_t * this, int32_t op_ret, int32_t op_errno,
-                         dict_t * xdata)
+int32_t
+ec_lock_unlocked(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    if (op_ret < 0)
-    {
-        gf_msg (this->name, GF_LOG_WARNING, op_errno,
-                EC_MSG_UNLOCK_FAILED,
-                "Failed to unlock an entry/inode");
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, EC_MSG_UNLOCK_FAILED,
+               "Failed to unlock an entry/inode");
     }
 
     return 0;
 }
 
-int32_t ec_lock_lk_unlocked(call_frame_t * frame, void * cookie,
-                            xlator_t * this, int32_t op_ret, int32_t op_errno,
-                            struct gf_flock * flock, dict_t * xdata)
+int32_t
+ec_lock_lk_unlocked(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+                    dict_t *xdata)
 {
-    if (op_ret < 0)
-    {
-        gf_msg(this->name, GF_LOG_WARNING, op_errno,
-               EC_MSG_LK_UNLOCK_FAILED,
+    if (op_ret < 0) {
+        gf_msg(this->name, GF_LOG_WARNING, op_errno, EC_MSG_LK_UNLOCK_FAILED,
                "Failed to unlock an lk");
     }
 
@@ -119,11 +118,12 @@ int32_t ec_lock_lk_unlocked(call_frame_t * frame, void * cookie,
 
 /* FOP: entrylk */
 
-int32_t ec_entrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -133,20 +133,16 @@ int32_t ec_entrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_ENTRYLK, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       EC_MSG_DICT_REF_FAIL,
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
                        "Failed to reference a "
                        "dictionary.");
 
@@ -158,15 +154,15 @@ int32_t ec_entrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_entrylk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_entrylk(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -176,20 +172,19 @@ void ec_wind_entrylk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->entrylk_type, fop->xdata);
 }
 
-int32_t ec_manager_entrylk(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_entrylk(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
-            if (fop->entrylk_cmd == ENTRYLK_LOCK)
-            {
+            if (fop->entrylk_cmd == ENTRYLK_LOCK) {
                 fop->uint32 = EC_LOCK_MODE_ALL;
                 fop->entrylk_cmd = ENTRYLK_LOCK_NB;
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -201,15 +196,14 @@ int32_t ec_manager_entrylk(ec_fop_data_t * fop, int32_t state)
             if (fop->entrylk_cmd != ENTRYLK_UNLOCK) {
                 uintptr_t mask;
 
-                ec_fop_set_error (fop, ec_lock_check(fop, &mask));
+                ec_fop_set_error(fop, ec_lock_check(fop, &mask));
                 if (fop->error != 0) {
                     if (mask != 0) {
                         if (fop->id == GF_FOP_ENTRYLK) {
-                            ec_entrylk(fop->frame, fop->xl, mask, 1,
-                                       ec_lock_unlocked, NULL, fop->str[0],
-                                       &fop->loc[0], fop->str[1],
-                                       ENTRYLK_UNLOCK, fop->entrylk_type,
-                                       fop->xdata);
+                            ec_entrylk(
+                                fop->frame, fop->xl, mask, 1, ec_lock_unlocked,
+                                NULL, fop->str[0], &fop->loc[0], fop->str[1],
+                                ENTRYLK_UNLOCK, fop->entrylk_type, fop->xdata);
                         } else {
                             ec_fentrylk(fop->frame, fop->xl, mask, 1,
                                         ec_lock_unlocked, NULL, fop->str[0],
@@ -238,18 +232,13 @@ int32_t ec_manager_entrylk(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_ENTRYLK)
-            {
-                if (fop->cbks.entrylk != NULL)
-                {
-                    fop->cbks.entrylk(fop->req_frame, fop, fop->xl,
-                                      cbk->op_ret, cbk->op_errno, cbk->xdata);
+            if (fop->id == GF_FOP_ENTRYLK) {
+                if (fop->cbks.entrylk != NULL) {
+                    fop->cbks.entrylk(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                      cbk->op_errno, cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fentrylk != NULL)
-                {
+            } else {
+                if (fop->cbks.fentrylk != NULL) {
                     fop->cbks.fentrylk(fop->req_frame, fop, fop->xl,
                                        cbk->op_ret, cbk->op_errno, cbk->xdata);
                 }
@@ -262,18 +251,13 @@ int32_t ec_manager_entrylk(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_ENTRYLK)
-            {
-                if (fop->cbks.entrylk != NULL)
-                {
+            if (fop->id == GF_FOP_ENTRYLK) {
+                if (fop->cbks.entrylk != NULL) {
                     fop->cbks.entrylk(fop->req_frame, fop, fop->xl, -1,
                                       fop->error, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.fentrylk != NULL)
-                {
+            } else {
+                if (fop->cbks.fentrylk != NULL) {
                     fop->cbks.fentrylk(fop->req_frame, fop, fop->xl, -1,
                                        fop->error, NULL);
                 }
@@ -282,25 +266,24 @@ int32_t ec_manager_entrylk(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_entrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                int32_t minimum, fop_entrylk_cbk_t func, void * data,
-                const char * volume, loc_t * loc, const char * basename,
-                entrylk_cmd cmd, entrylk_type type, dict_t * xdata)
+void
+ec_entrylk(call_frame_t *frame, xlator_t *this, uintptr_t target,
+           int32_t minimum, fop_entrylk_cbk_t func, void *data,
+           const char *volume, loc_t *loc, const char *basename,
+           entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
-    ec_cbk_t callback = { .entrylk = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.entrylk = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(ENTRYLK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(ENTRYLK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -319,18 +302,16 @@ void ec_entrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (volume != NULL) {
         fop->str[0] = gf_strdup(volume);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
     }
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -338,9 +319,8 @@ void ec_entrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (basename != NULL) {
         fop->str[1] = gf_strdup(basename);
         if (fop->str[1] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -348,10 +328,9 @@ void ec_entrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -369,11 +348,12 @@ out:
 
 /* FOP: fentrylk */
 
-int32_t ec_fentrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                        int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -383,22 +363,18 @@ int32_t ec_fentrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FENTRYLK, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                         "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -408,15 +384,15 @@ int32_t ec_fentrylk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_fentrylk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_fentrylk(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -426,24 +402,25 @@ void ec_wind_fentrylk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->entrylk_type, fop->xdata);
 }
 
-void ec_fentrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
-                 int32_t minimum, fop_fentrylk_cbk_t func, void * data,
-                 const char * volume, fd_t * fd, const char * basename,
-                 entrylk_cmd cmd, entrylk_type type, dict_t * xdata)
+void
+ec_fentrylk(call_frame_t *frame, xlator_t *this, uintptr_t target,
+            int32_t minimum, fop_fentrylk_cbk_t func, void *data,
+            const char *volume, fd_t *fd, const char *basename, entrylk_cmd cmd,
+            entrylk_type type, dict_t *xdata)
 {
-    ec_cbk_t callback = { .fentrylk = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.fentrylk = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FENTRYLK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FENTRYLK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FENTRYLK, 0, target,
-                               minimum, ec_wind_fentrylk, ec_manager_entrylk,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_FENTRYLK, 0, target, minimum,
+                               ec_wind_fentrylk, ec_manager_entrylk, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -456,9 +433,8 @@ void ec_fentrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (volume != NULL) {
         fop->str[0] = gf_strdup(volume);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -466,10 +442,9 @@ void ec_fentrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -477,9 +452,8 @@ void ec_fentrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (basename != NULL) {
         fop->str[1] = gf_strdup(basename);
         if (fop->str[1] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -487,10 +461,9 @@ void ec_fentrylk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -508,11 +481,12 @@ out:
 
 /* FOP: inodelk */
 
-int32_t ec_inodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                       int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -522,22 +496,18 @@ int32_t ec_inodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_INODELK, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -547,15 +517,15 @@ int32_t ec_inodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_inodelk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_inodelk(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -565,24 +535,22 @@ void ec_wind_inodelk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->xdata);
 }
 
-int32_t ec_manager_inodelk(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_inodelk(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
-            fop->flock.l_len += ec_adjust_offset_down(fop->xl->private,
-                                                      &fop->flock.l_start,
-                                                      _gf_true);
+            fop->flock.l_len += ec_adjust_offset_down(
+                fop->xl->private, &fop->flock.l_start, _gf_true);
             ec_adjust_offset_up(fop->xl->private, &fop->flock.l_len, _gf_true);
-            if ((fop->int32 == F_SETLKW) && (fop->flock.l_type != F_UNLCK))
-            {
+            if ((fop->int32 == F_SETLKW) && (fop->flock.l_type != F_UNLCK)) {
                 fop->uint32 = EC_LOCK_MODE_ALL;
                 fop->int32 = F_SETLK;
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -594,7 +562,7 @@ int32_t ec_manager_inodelk(ec_fop_data_t * fop, int32_t state)
             if (fop->flock.l_type != F_UNLCK) {
                 uintptr_t mask;
 
-                ec_fop_set_error (fop, ec_lock_check(fop, &mask));
+                ec_fop_set_error(fop, ec_lock_check(fop, &mask));
                 if (fop->error != 0) {
                     if (mask != 0) {
                         ec_t *ec = fop->xl->private;
@@ -641,18 +609,13 @@ int32_t ec_manager_inodelk(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->id == GF_FOP_INODELK)
-            {
-                if (fop->cbks.inodelk != NULL)
-                {
-                    fop->cbks.inodelk(fop->req_frame, fop, fop->xl,
-                                      cbk->op_ret, cbk->op_errno, cbk->xdata);
+            if (fop->id == GF_FOP_INODELK) {
+                if (fop->cbks.inodelk != NULL) {
+                    fop->cbks.inodelk(fop->req_frame, fop, fop->xl, cbk->op_ret,
+                                      cbk->op_errno, cbk->xdata);
                 }
-            }
-            else
-            {
-                if (fop->cbks.finodelk != NULL)
-                {
+            } else {
+                if (fop->cbks.finodelk != NULL) {
                     fop->cbks.finodelk(fop->req_frame, fop, fop->xl,
                                        cbk->op_ret, cbk->op_errno, cbk->xdata);
                 }
@@ -665,18 +628,13 @@ int32_t ec_manager_inodelk(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->id == GF_FOP_INODELK)
-            {
-                if (fop->cbks.inodelk != NULL)
-                {
+            if (fop->id == GF_FOP_INODELK) {
+                if (fop->cbks.inodelk != NULL) {
                     fop->cbks.inodelk(fop->req_frame, fop, fop->xl, -1,
                                       fop->error, NULL);
                 }
-            }
-            else
-            {
-                if (fop->cbks.finodelk != NULL)
-                {
+            } else {
+                if (fop->cbks.finodelk != NULL) {
                     fop->cbks.finodelk(fop->req_frame, fop, fop->xl, -1,
                                        fop->error, NULL);
                 }
@@ -685,25 +643,24 @@ int32_t ec_manager_inodelk(ec_fop_data_t * fop, int32_t state)
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_inodelk (call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
-                 uintptr_t target, int32_t minimum, fop_inodelk_cbk_t func,
-                 void *data, const char *volume, loc_t *loc, int32_t cmd,
-                 struct gf_flock *flock, dict_t *xdata)
+void
+ec_inodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
+           uintptr_t target, int32_t minimum, fop_inodelk_cbk_t func,
+           void *data, const char *volume, loc_t *loc, int32_t cmd,
+           struct gf_flock *flock, dict_t *xdata)
 {
-    ec_cbk_t callback = { .inodelk = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.inodelk = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(INODELK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(INODELK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -717,23 +674,21 @@ void ec_inodelk (call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
     }
 
     fop->int32 = cmd;
-    ec_owner_copy (fop->frame, owner);
+    ec_owner_copy(fop->frame, owner);
 
     if (volume != NULL) {
         fop->str[0] = gf_strdup(volume);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
     }
     if (loc != NULL) {
         if (loc_copy(&fop->loc[0], loc) != 0) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_LOC_COPY_FAIL,
-                    "Failed to copy a location.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_LOC_COPY_FAIL,
+                   "Failed to copy a location.");
 
             goto out;
         }
@@ -753,10 +708,9 @@ void ec_inodelk (call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -774,11 +728,12 @@ out:
 
 /* FOP: finodelk */
 
-int32_t ec_finodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                        int32_t op_ret, int32_t op_errno, dict_t * xdata)
+int32_t
+ec_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -788,22 +743,18 @@ int32_t ec_finodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_FINODELK, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (xdata != NULL)
-        {
+    if (cbk != NULL) {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -813,15 +764,15 @@ int32_t ec_finodelk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_finodelk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_finodelk(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -831,24 +782,25 @@ void ec_wind_finodelk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->xdata);
 }
 
-void ec_finodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
-                 uintptr_t target, int32_t minimum, fop_finodelk_cbk_t func,
-                 void *data, const char *volume, fd_t *fd, int32_t cmd,
-                 struct gf_flock *flock, dict_t *xdata)
+void
+ec_finodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
+            uintptr_t target, int32_t minimum, fop_finodelk_cbk_t func,
+            void *data, const char *volume, fd_t *fd, int32_t cmd,
+            struct gf_flock *flock, dict_t *xdata)
 {
-    ec_cbk_t callback = { .finodelk = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.finodelk = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(FINODELK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(FINODELK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
     GF_VALIDATE_OR_GOTO(this->name, this->private, out);
 
-    fop = ec_fop_data_allocate(frame, this, GF_FOP_FINODELK, 0, target,
-                               minimum, ec_wind_finodelk, ec_manager_inodelk,
-                               callback, data);
+    fop = ec_fop_data_allocate(frame, this, GF_FOP_FINODELK, 0, target, minimum,
+                               ec_wind_finodelk, ec_manager_inodelk, callback,
+                               data);
     if (fop == NULL) {
         goto out;
     }
@@ -856,14 +808,13 @@ void ec_finodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
     fop->use_fd = 1;
 
     fop->int32 = cmd;
-    ec_owner_copy (fop->frame, owner);
+    ec_owner_copy(fop->frame, owner);
 
     if (volume != NULL) {
         fop->str[0] = gf_strdup(volume);
         if (fop->str[0] == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                    EC_MSG_NO_MEMORY,
-                    "Failed to duplicate a string.");
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+                   "Failed to duplicate a string.");
 
             goto out;
         }
@@ -871,10 +822,9 @@ void ec_finodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -894,10 +844,9 @@ void ec_finodelk(call_frame_t *frame, xlator_t *this, gf_lkowner_t *owner,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
@@ -915,15 +864,13 @@ out:
 
 /* FOP: lk */
 
-int32_t ec_combine_lk(ec_fop_data_t * fop, ec_cbk_data_t * dst,
-                      ec_cbk_data_t * src)
+int32_t
+ec_combine_lk(ec_fop_data_t *fop, ec_cbk_data_t *dst, ec_cbk_data_t *src)
 {
-    if (!ec_flock_compare(&dst->flock, &src->flock))
-    {
-        gf_msg (fop->xl->name, GF_LOG_NOTICE, 0,
-                EC_MSG_LOCK_MISMATCH,
-                "Mismatching lock in "
-                "answers of 'GF_FOP_LK'");
+    if (!ec_flock_compare(&dst->flock, &src->flock)) {
+        gf_msg(fop->xl->name, GF_LOG_NOTICE, 0, EC_MSG_LOCK_MISMATCH,
+               "Mismatching lock in "
+               "answers of 'GF_FOP_LK'");
 
         return 0;
     }
@@ -931,12 +878,12 @@ int32_t ec_combine_lk(ec_fop_data_t * fop, ec_cbk_data_t * dst,
     return 1;
 }
 
-int32_t ec_lk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
-                  int32_t op_ret, int32_t op_errno, struct gf_flock * flock,
-                  dict_t * xdata)
+int32_t
+ec_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+          int32_t op_errno, struct gf_flock *flock, dict_t *xdata)
 {
-    ec_fop_data_t * fop = NULL;
-    ec_cbk_data_t * cbk = NULL;
+    ec_fop_data_t *fop = NULL;
+    ec_cbk_data_t *cbk = NULL;
     int32_t idx = (int32_t)(uintptr_t)cookie;
 
     VALIDATE_OR_GOTO(this, out);
@@ -946,39 +893,32 @@ int32_t ec_lk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
 
     fop = frame->local;
 
-    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx,
-             frame, op_ret, op_errno);
+    ec_trace("CBK", fop, "idx=%d, frame=%p, op_ret=%d, op_errno=%d", idx, frame,
+             op_ret, op_errno);
 
     cbk = ec_cbk_data_allocate(frame, this, fop, GF_FOP_LK, idx, op_ret,
                                op_errno);
-    if (cbk != NULL)
-    {
-        if (op_ret >= 0)
-        {
-            if (flock != NULL)
-            {
+    if (cbk != NULL) {
+        if (op_ret >= 0) {
+            if (flock != NULL) {
                 cbk->flock.l_type = flock->l_type;
                 cbk->flock.l_whence = flock->l_whence;
                 cbk->flock.l_start = flock->l_start;
                 cbk->flock.l_len = flock->l_len;
                 cbk->flock.l_pid = flock->l_pid;
                 cbk->flock.l_owner.len = flock->l_owner.len;
-                if (flock->l_owner.len > 0)
-                {
+                if (flock->l_owner.len > 0) {
                     memcpy(cbk->flock.l_owner.data, flock->l_owner.data,
                            flock->l_owner.len);
                 }
             }
         }
-        if (xdata != NULL)
-        {
+        if (xdata != NULL) {
             cbk->xdata = dict_ref(xdata);
-            if (cbk->xdata == NULL)
-            {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        EC_MSG_DICT_REF_FAIL,
-                        "Failed to reference a "
-                        "dictionary.");
+            if (cbk->xdata == NULL) {
+                gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                       "Failed to reference a "
+                       "dictionary.");
 
                 goto out;
             }
@@ -988,15 +928,15 @@ int32_t ec_lk_cbk(call_frame_t * frame, void * cookie, xlator_t * this,
     }
 
 out:
-    if (fop != NULL)
-    {
+    if (fop != NULL) {
         ec_complete(fop);
     }
 
     return 0;
 }
 
-void ec_wind_lk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
+void
+ec_wind_lk(ec_t *ec, ec_fop_data_t *fop, int32_t idx)
 {
     ec_trace("WIND", fop, "idx=%d", idx);
 
@@ -1005,20 +945,19 @@ void ec_wind_lk(ec_t * ec, ec_fop_data_t * fop, int32_t idx)
                       fop->int32, &fop->flock, fop->xdata);
 }
 
-int32_t ec_manager_lk(ec_fop_data_t * fop, int32_t state)
+int32_t
+ec_manager_lk(ec_fop_data_t *fop, int32_t state)
 {
-    ec_cbk_data_t * cbk;
+    ec_cbk_data_t *cbk;
 
-    switch (state)
-    {
+    switch (state) {
         case EC_STATE_INIT:
-            if ((fop->int32 == F_SETLKW) && (fop->flock.l_type != F_UNLCK))
-            {
+            if ((fop->int32 == F_SETLKW) && (fop->flock.l_type != F_UNLCK)) {
                 fop->uint32 = EC_LOCK_MODE_ALL;
                 fop->int32 = F_SETLK;
             }
 
-        /* Fall through */
+            /* Fall through */
 
         case EC_STATE_DISPATCH:
             ec_dispatch_all(fop);
@@ -1030,7 +969,7 @@ int32_t ec_manager_lk(ec_fop_data_t * fop, int32_t state)
             if (fop->flock.l_type != F_UNLCK) {
                 uintptr_t mask;
 
-                ec_fop_set_error (fop, ec_lock_check(fop, &mask));
+                ec_fop_set_error(fop, ec_lock_check(fop, &mask));
                 if (fop->error != 0) {
                     if (mask != 0) {
                         struct gf_flock flock = {0};
@@ -1040,11 +979,10 @@ int32_t ec_manager_lk(ec_fop_data_t * fop, int32_t state)
                         flock.l_start = fop->flock.l_start;
                         flock.l_len = fop->flock.l_len;
                         flock.l_pid = fop->flock.l_pid;
-                        lk_owner_copy (&flock.l_owner, &fop->flock.l_owner);
+                        lk_owner_copy(&flock.l_owner, &fop->flock.l_owner);
 
-                        ec_lk(fop->frame, fop->xl, mask, 1,
-                              ec_lock_lk_unlocked, NULL, fop->fd, F_SETLK,
-                              &flock, fop->xdata);
+                        ec_lk(fop->frame, fop->xl, mask, 1, ec_lock_lk_unlocked,
+                              NULL, fop->fd, F_SETLK, &flock, fop->xdata);
                     }
 
                     if (fop->error < 0) {
@@ -1068,8 +1006,7 @@ int32_t ec_manager_lk(ec_fop_data_t * fop, int32_t state)
 
             GF_ASSERT(cbk != NULL);
 
-            if (fop->cbks.lk != NULL)
-            {
+            if (fop->cbks.lk != NULL) {
                 fop->cbks.lk(fop->req_frame, fop, fop->xl, cbk->op_ret,
                              cbk->op_errno, &cbk->flock, cbk->xdata);
             }
@@ -1081,34 +1018,31 @@ int32_t ec_manager_lk(ec_fop_data_t * fop, int32_t state)
         case -EC_STATE_REPORT:
             GF_ASSERT(fop->error != 0);
 
-            if (fop->cbks.lk != NULL)
-            {
-                fop->cbks.lk(fop->req_frame, fop, fop->xl, -1, fop->error,
-                             NULL, NULL);
+            if (fop->cbks.lk != NULL) {
+                fop->cbks.lk(fop->req_frame, fop, fop->xl, -1, fop->error, NULL,
+                             NULL);
             }
 
-
             return EC_STATE_END;
 
         default:
-            gf_msg (fop->xl->name, GF_LOG_ERROR, EINVAL,
-                    EC_MSG_UNHANDLED_STATE,
-                    "Unhandled state %d for %s",
-                    state, ec_fop_name(fop->id));
+            gf_msg(fop->xl->name, GF_LOG_ERROR, EINVAL, EC_MSG_UNHANDLED_STATE,
+                   "Unhandled state %d for %s", state, ec_fop_name(fop->id));
 
             return EC_STATE_END;
     }
 }
 
-void ec_lk(call_frame_t * frame, xlator_t * this, uintptr_t target,
-           int32_t minimum, fop_lk_cbk_t func, void * data, fd_t * fd,
-           int32_t cmd, struct gf_flock * flock, dict_t * xdata)
+void
+ec_lk(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
+      fop_lk_cbk_t func, void *data, fd_t *fd, int32_t cmd,
+      struct gf_flock *flock, dict_t *xdata)
 {
-    ec_cbk_t callback = { .lk = func };
-    ec_fop_data_t * fop = NULL;
+    ec_cbk_t callback = {.lk = func};
+    ec_fop_data_t *fop = NULL;
     int32_t error = ENOMEM;
 
-    gf_msg_trace ("ec", 0, "EC(LK) %p", frame);
+    gf_msg_trace("ec", 0, "EC(LK) %p", frame);
 
     VALIDATE_OR_GOTO(this, out);
     GF_VALIDATE_OR_GOTO(this->name, frame, out);
@@ -1127,10 +1061,9 @@ void ec_lk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (fd != NULL) {
         fop->fd = fd_ref(fd);
         if (fop->fd == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_FILE_DESC_REF_FAIL,
-                    "Failed to reference a "
-                    "file descriptor.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_FILE_DESC_REF_FAIL,
+                   "Failed to reference a "
+                   "file descriptor.");
 
             goto out;
         }
@@ -1150,10 +1083,9 @@ void ec_lk(call_frame_t * frame, xlator_t * this, uintptr_t target,
     if (xdata != NULL) {
         fop->xdata = dict_ref(xdata);
         if (fop->xdata == NULL) {
-            gf_msg (this->name, GF_LOG_ERROR, 0,
-                    EC_MSG_DICT_REF_FAIL,
-                    "Failed to reference a "
-                    "dictionary.");
+            gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_DICT_REF_FAIL,
+                   "Failed to reference a "
+                   "dictionary.");
 
             goto out;
         }
diff --git a/xlators/cluster/ec/src/ec-method.c b/xlators/cluster/ec/src/ec-method.c
index fdc89391bfb..3aff6b096bd 100644
--- a/xlators/cluster/ec/src/ec-method.c
+++ b/xlators/cluster/ec/src/ec-method.c
@@ -88,11 +88,9 @@ ec_method_matrix_init(ec_matrix_list_t *list, ec_matrix_t *matrix,
                                  matrix->rows);
         for (i = 0; i < matrix->rows; i++) {
             matrix->row_data[i].values = matrix->values + i * matrix->columns;
-            matrix->row_data[i].func.interleaved =
-                ec_code_build_interleaved(matrix->code,
-                                          EC_METHOD_WORD_SIZE,
-                                          matrix->row_data[i].values,
-                                          matrix->columns);
+            matrix->row_data[i].func.interleaved = ec_code_build_interleaved(
+                matrix->code, EC_METHOD_WORD_SIZE, matrix->row_data[i].values,
+                matrix->columns);
         }
     } else {
         matrix->rows = list->rows;
@@ -100,10 +98,9 @@ ec_method_matrix_init(ec_matrix_list_t *list, ec_matrix_t *matrix,
                                 matrix->columns, rows, matrix->rows);
         for (i = 0; i < matrix->rows; i++) {
             matrix->row_data[i].values = matrix->values + i * matrix->columns;
-            matrix->row_data[i].func.linear =
-                ec_code_build_linear(matrix->code, EC_METHOD_WORD_SIZE,
-                                     matrix->row_data[i].values,
-                                     matrix->columns);
+            matrix->row_data[i].func.linear = ec_code_build_linear(
+                matrix->code, EC_METHOD_WORD_SIZE, matrix->row_data[i].values,
+                matrix->columns);
         }
     }
 }
@@ -266,8 +263,8 @@ ec_method_setup(xlator_t *xl, ec_matrix_list_t *list, const char *gen)
     int32_t err;
 
     matrix = GF_MALLOC(sizeof(ec_matrix_t) +
-                       sizeof(ec_matrix_row_t) * list->rows +
-                       sizeof(uint32_t) * list->columns * list->rows,
+                           sizeof(ec_matrix_row_t) * list->rows +
+                           sizeof(uint32_t) * list->columns * list->rows,
                        ec_mt_ec_matrix_t);
     if (matrix == NULL) {
         err = -ENOMEM;
@@ -310,9 +307,10 @@ ec_method_init(xlator_t *xl, ec_matrix_list_t *list, uint32_t columns,
     INIT_LIST_HEAD(&list->lru);
     int32_t err;
 
-    list->pool = mem_pool_new_fn(xl->ctx, sizeof(ec_matrix_t) +
-                                 sizeof(ec_matrix_row_t) * columns +
-                                 sizeof(uint32_t) * columns * columns,
+    list->pool = mem_pool_new_fn(xl->ctx,
+                                 sizeof(ec_matrix_t) +
+                                     sizeof(ec_matrix_row_t) * columns +
+                                     sizeof(uint32_t) * columns * columns,
                                  128, "ec_matrix_t");
     if (list->pool == NULL) {
         err = -ENOMEM;
@@ -370,8 +368,8 @@ ec_method_fini(ec_matrix_list_t *list)
 
     GF_ASSERT(list->count == 0);
 
-    if (list->pool)/*Init was successful*/
-            LOCK_DESTROY(&list->lock);
+    if (list->pool) /*Init was successful*/
+        LOCK_DESTROY(&list->lock);
 
     ec_method_matrix_release(list->encode);
     GF_FREE(list->encode);
@@ -402,9 +400,8 @@ ec_method_encode(ec_matrix_list_t *list, size_t size, void *in, void **out)
     matrix = list->encode;
     for (pos = 0; pos < size; pos += list->stripe) {
         for (i = 0; i < matrix->rows; i++) {
-            matrix->row_data[i].func.linear(out[i], in, pos,
-                                            matrix->row_data[i].values,
-                                            list->columns);
+            matrix->row_data[i].func.linear(
+                out[i], in, pos, matrix->row_data[i].values, list->columns);
             out[i] += EC_METHOD_CHUNK_SIZE;
         }
     }
@@ -424,9 +421,8 @@ ec_method_decode(ec_matrix_list_t *list, size_t size, uintptr_t mask,
     }
     for (pos = 0; pos < size; pos += EC_METHOD_CHUNK_SIZE) {
         for (i = 0; i < matrix->rows; i++) {
-            matrix->row_data[i].func.interleaved(out, in, pos,
-                                                 matrix->row_data[i].values,
-                                                 list->columns);
+            matrix->row_data[i].func.interleaved(
+                out, in, pos, matrix->row_data[i].values, list->columns);
             out += EC_METHOD_CHUNK_SIZE;
         }
     }
diff --git a/xlators/cluster/ec/src/ec.c b/xlators/cluster/ec/src/ec.c
index a82305104c5..0350325d6fb 100644
--- a/xlators/cluster/ec/src/ec.c
+++ b/xlators/cluster/ec/src/ec.c
@@ -26,47 +26,45 @@
 #include "events.h"
 
 static char *ec_read_policies[EC_READ_POLICY_MAX + 1] = {
-        [EC_ROUND_ROBIN] = "round-robin",
-        [EC_GFID_HASH] = "gfid-hash",
-        [EC_READ_POLICY_MAX] = NULL
-};
+    [EC_ROUND_ROBIN] = "round-robin",
+    [EC_GFID_HASH] = "gfid-hash",
+    [EC_READ_POLICY_MAX] = NULL};
 
 #define EC_INTERNAL_XATTR_OR_GOTO(name, xattr, op_errno, label)                \
-        do {                                                                   \
-                if (ec_is_internal_xattr (NULL, (char *)name, NULL, NULL)) {   \
-                        op_errno = EPERM;                                      \
-                        goto label;                                            \
-                }                                                              \
-                if (name && (strlen (name) == 0) && xattr) {                   \
-                        /* Bulk [f]removexattr/[f]setxattr */                  \
-                        GF_IF_INTERNAL_XATTR_GOTO (EC_XATTR_PREFIX"*", xattr,  \
-                                                   op_errno, label);           \
-                }                                                              \
-        } while (0)
-
-int32_t ec_parse_options(xlator_t * this)
-{
-    ec_t * ec = this->private;
+    do {                                                                       \
+        if (ec_is_internal_xattr(NULL, (char *)name, NULL, NULL)) {            \
+            op_errno = EPERM;                                                  \
+            goto label;                                                        \
+        }                                                                      \
+        if (name && (strlen(name) == 0) && xattr) {                            \
+            /* Bulk [f]removexattr/[f]setxattr */                              \
+            GF_IF_INTERNAL_XATTR_GOTO(EC_XATTR_PREFIX "*", xattr, op_errno,    \
+                                      label);                                  \
+        }                                                                      \
+    } while (0)
+
+int32_t
+ec_parse_options(xlator_t *this)
+{
+    ec_t *ec = this->private;
     int32_t error = EINVAL;
     uintptr_t mask;
 
     GF_OPTION_INIT("redundancy", ec->redundancy, int32, out);
     ec->fragments = ec->nodes - ec->redundancy;
     if ((ec->redundancy < 1) || (ec->redundancy >= ec->fragments) ||
-        (ec->fragments > EC_MAX_FRAGMENTS))
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_INVALID_REDUNDANCY,
-                "Invalid redundancy (must be between "
-                "1 and %d)", (ec->nodes - 1) / 2);
+        (ec->fragments > EC_MAX_FRAGMENTS)) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_INVALID_REDUNDANCY,
+               "Invalid redundancy (must be between "
+               "1 and %d)",
+               (ec->nodes - 1) / 2);
 
         goto out;
     }
 
     ec->bits_for_nodes = 1;
     mask = 2;
-    while (ec->nodes > mask)
-    {
+    while (ec->nodes > mask) {
         ec->bits_for_nodes++;
         mask <<= 1;
     }
@@ -74,9 +72,10 @@ int32_t ec_parse_options(xlator_t * this)
     ec->fragment_size = EC_METHOD_CHUNK_SIZE;
     ec->stripe_size = ec->fragment_size * ec->fragments;
 
-    gf_msg_debug ("ec", 0, "Initialized with: nodes=%u, fragments=%u, "
-                               "stripe_size=%u, node_mask=%lX",
-           ec->nodes, ec->fragments, ec->stripe_size, ec->node_mask);
+    gf_msg_debug("ec", 0,
+                 "Initialized with: nodes=%u, fragments=%u, "
+                 "stripe_size=%u, node_mask=%lX",
+                 ec->nodes, ec->fragments, ec->stripe_size, ec->node_mask);
 
     error = 0;
 
@@ -84,30 +83,28 @@ out:
     return error;
 }
 
-int32_t ec_prepare_childs(xlator_t * this)
+int32_t
+ec_prepare_childs(xlator_t *this)
 {
-    ec_t * ec = this->private;
-    xlator_list_t * child = NULL;
+    ec_t *ec = this->private;
+    xlator_list_t *child = NULL;
     int32_t count = 0;
 
-    for (child = this->children; child != NULL; child = child->next)
-    {
+    for (child = this->children; child != NULL; child = child->next) {
         count++;
     }
-    if (count > EC_MAX_NODES)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_TOO_MANY_SUBVOLS, "Too many subvolumes");
+    if (count > EC_MAX_NODES) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_TOO_MANY_SUBVOLS,
+               "Too many subvolumes");
 
         return EINVAL;
     }
     ec->nodes = count;
 
     ec->xl_list = GF_CALLOC(count, sizeof(ec->xl_list[0]), ec_mt_xlator_t);
-    if (ec->xl_list == NULL)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Allocation of xlator list failed");
+    if (ec->xl_list == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Allocation of xlator list failed");
 
         return ENOMEM;
     }
@@ -115,8 +112,7 @@ int32_t ec_prepare_childs(xlator_t * this)
     ec->xl_up_count = 0;
 
     count = 0;
-    for (child = this->children; child != NULL; child = child->next)
-    {
+    for (child = this->children; child != NULL; child = child->next) {
         ec->xl_list[count++] = child->xlator;
     }
 
@@ -125,43 +121,42 @@ int32_t ec_prepare_childs(xlator_t * this)
 
 /* This function transforms the subvol to subvol-id*/
 static int
-_subvol_to_subvolid (dict_t *this, char *key, data_t *value, void *data)
-{
-        ec_t *ec = data;
-        xlator_t *subvol = NULL;
-        int      i = 0;
-        int     ret = -1;
-
-        subvol = data_to_ptr (value);
-        for (i = 0; i < ec->nodes; i++) {
-                if (ec->xl_list[i] == subvol) {
-                        ret = dict_set_int32 (this, key, i);
-                        /* -1 stops dict_foreach and returns -1*/
-                        if (ret < 0)
-                                ret = -1;
-                        goto out;
-                }
+_subvol_to_subvolid(dict_t *this, char *key, data_t *value, void *data)
+{
+    ec_t *ec = data;
+    xlator_t *subvol = NULL;
+    int i = 0;
+    int ret = -1;
+
+    subvol = data_to_ptr(value);
+    for (i = 0; i < ec->nodes; i++) {
+        if (ec->xl_list[i] == subvol) {
+            ret = dict_set_int32(this, key, i);
+            /* -1 stops dict_foreach and returns -1*/
+            if (ret < 0)
+                ret = -1;
+            goto out;
         }
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-ec_subvol_to_subvol_id_transform (ec_t *ec, dict_t *leaf_to_subvolid)
+ec_subvol_to_subvol_id_transform(ec_t *ec, dict_t *leaf_to_subvolid)
 {
-        return dict_foreach (leaf_to_subvolid, _subvol_to_subvolid, ec);
+    return dict_foreach(leaf_to_subvolid, _subvol_to_subvolid, ec);
 }
 
-void __ec_destroy_private(xlator_t * this)
+void
+__ec_destroy_private(xlator_t *this)
 {
-    ec_t * ec = this->private;
+    ec_t *ec = this->private;
 
-    if (ec != NULL)
-    {
+    if (ec != NULL) {
         LOCK(&ec->lock);
 
-        if (ec->timer != NULL)
-        {
+        if (ec->timer != NULL) {
             gf_timer_call_cancel(this->ctx, ec->timer);
             ec->timer = NULL;
         }
@@ -179,31 +174,27 @@ void __ec_destroy_private(xlator_t * this)
         sleep(2);
 
         this->private = NULL;
-        if (ec->xl_list != NULL)
-        {
+        if (ec->xl_list != NULL) {
             GF_FREE(ec->xl_list);
             ec->xl_list = NULL;
         }
 
-        if (ec->fop_pool != NULL)
-        {
+        if (ec->fop_pool != NULL) {
             mem_pool_destroy(ec->fop_pool);
         }
 
-        if (ec->cbk_pool != NULL)
-        {
+        if (ec->cbk_pool != NULL) {
             mem_pool_destroy(ec->cbk_pool);
         }
 
-        if (ec->lock_pool != NULL)
-        {
+        if (ec->lock_pool != NULL) {
             mem_pool_destroy(ec->lock_pool);
         }
 
         LOCK_DESTROY(&ec->lock);
 
         if (ec->leaf_to_subvolid)
-                dict_unref (ec->leaf_to_subvolid);
+            dict_unref(ec->leaf_to_subvolid);
 
         ec_method_fini(&ec->matrix);
 
@@ -211,13 +202,13 @@ void __ec_destroy_private(xlator_t * this)
     }
 }
 
-int32_t mem_acct_init(xlator_t * this)
+int32_t
+mem_acct_init(xlator_t *this)
 {
-    if (xlator_mem_acct_init(this, ec_mt_end + 1) != 0)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Memory accounting initialization "
-                                         "failed.");
+    if (xlator_mem_acct_init(this, ec_mt_end + 1) != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Memory accounting initialization "
+               "failed.");
 
         return -1;
     }
@@ -226,442 +217,435 @@ int32_t mem_acct_init(xlator_t * this)
 }
 
 void
-ec_configure_background_heal_opts (ec_t *ec, int background_heals,
-                                   int heal_wait_qlen)
+ec_configure_background_heal_opts(ec_t *ec, int background_heals,
+                                  int heal_wait_qlen)
 {
-        if (background_heals == 0) {
-                ec->heal_wait_qlen = 0;
-        } else {
-                ec->heal_wait_qlen = heal_wait_qlen;
-        }
-        ec->background_heals = background_heals;
+    if (background_heals == 0) {
+        ec->heal_wait_qlen = 0;
+    } else {
+        ec->heal_wait_qlen = heal_wait_qlen;
+    }
+    ec->background_heals = background_heals;
 }
 
 int
-ec_assign_read_policy (ec_t *ec, char *read_policy)
+ec_assign_read_policy(ec_t *ec, char *read_policy)
 {
-        int read_policy_idx = -1;
+    int read_policy_idx = -1;
 
-        read_policy_idx = gf_get_index_by_elem (ec_read_policies, read_policy);
-        if (read_policy_idx < 0 || read_policy_idx >= EC_READ_POLICY_MAX)
-                return -1;
+    read_policy_idx = gf_get_index_by_elem(ec_read_policies, read_policy);
+    if (read_policy_idx < 0 || read_policy_idx >= EC_READ_POLICY_MAX)
+        return -1;
 
-        ec->read_policy = read_policy_idx;
-        return 0;
+    ec->read_policy = read_policy_idx;
+    return 0;
 }
 
 int32_t
-reconfigure (xlator_t *this, dict_t *options)
-{
-        ec_t     *ec              = this->private;
-        char     *read_policy     = NULL;
-        char     *extensions      = NULL;
-        uint32_t heal_wait_qlen   = 0;
-        uint32_t background_heals = 0;
-        int32_t  ret              = -1;
-        int32_t  err;
-
-        GF_OPTION_RECONF ("cpu-extensions", extensions, options, str, failed);
-
-        GF_OPTION_RECONF ("self-heal-daemon", ec->shd.enabled, options, bool,
-                          failed);
-        GF_OPTION_RECONF ("iam-self-heal-daemon", ec->shd.iamshd, options,
-                          bool, failed);
-        GF_OPTION_RECONF ("eager-lock", ec->eager_lock, options,
-                          bool, failed);
-        GF_OPTION_RECONF ("other-eager-lock", ec->other_eager_lock, options,
-                          bool, failed);
-        GF_OPTION_RECONF ("eager-lock-timeout", ec->eager_lock_timeout,
-                          options, uint32, failed);
-        GF_OPTION_RECONF ("other-eager-lock-timeout",
-                          ec->other_eager_lock_timeout, options, uint32,
-                          failed);
-        GF_OPTION_RECONF ("background-heals", background_heals, options,
-                          uint32, failed);
-        GF_OPTION_RECONF ("heal-wait-qlength", heal_wait_qlen, options,
-                          uint32, failed);
-        GF_OPTION_RECONF ("self-heal-window-size", ec->self_heal_window_size,
-                          options, uint32, failed);
-        GF_OPTION_RECONF ("heal-timeout", ec->shd.timeout, options,
-                          int32, failed);
-        ec_configure_background_heal_opts (ec, background_heals,
-                                           heal_wait_qlen);
-        GF_OPTION_RECONF ("shd-max-threads", ec->shd.max_threads,
-                          options, uint32, failed);
-        GF_OPTION_RECONF ("shd-wait-qlength", ec->shd.wait_qlength,
-                          options, uint32, failed);
-
-        GF_OPTION_RECONF ("read-policy", read_policy, options, str, failed);
-
-        GF_OPTION_RECONF ("optimistic-change-log", ec->optimistic_changelog,
-                          options, bool, failed);
-        GF_OPTION_RECONF ("parallel-writes", ec->parallel_writes,
-                          options, bool, failed);
-        GF_OPTION_RECONF ("stripe-cache", ec->stripe_cache, options, uint32,
-                          failed);
-        ret = 0;
-        if (ec_assign_read_policy (ec, read_policy)) {
-                ret = -1;
-        }
+reconfigure(xlator_t *this, dict_t *options)
+{
+    ec_t *ec = this->private;
+    char *read_policy = NULL;
+    char *extensions = NULL;
+    uint32_t heal_wait_qlen = 0;
+    uint32_t background_heals = 0;
+    int32_t ret = -1;
+    int32_t err;
 
-        err = ec_method_update(this, &ec->matrix, extensions);
-        if (err != 0) {
-                ret = -1;
-        }
+    GF_OPTION_RECONF("cpu-extensions", extensions, options, str, failed);
+
+    GF_OPTION_RECONF("self-heal-daemon", ec->shd.enabled, options, bool,
+                     failed);
+    GF_OPTION_RECONF("iam-self-heal-daemon", ec->shd.iamshd, options, bool,
+                     failed);
+    GF_OPTION_RECONF("eager-lock", ec->eager_lock, options, bool, failed);
+    GF_OPTION_RECONF("other-eager-lock", ec->other_eager_lock, options, bool,
+                     failed);
+    GF_OPTION_RECONF("eager-lock-timeout", ec->eager_lock_timeout, options,
+                     uint32, failed);
+    GF_OPTION_RECONF("other-eager-lock-timeout", ec->other_eager_lock_timeout,
+                     options, uint32, failed);
+    GF_OPTION_RECONF("background-heals", background_heals, options, uint32,
+                     failed);
+    GF_OPTION_RECONF("heal-wait-qlength", heal_wait_qlen, options, uint32,
+                     failed);
+    GF_OPTION_RECONF("self-heal-window-size", ec->self_heal_window_size,
+                     options, uint32, failed);
+    GF_OPTION_RECONF("heal-timeout", ec->shd.timeout, options, int32, failed);
+    ec_configure_background_heal_opts(ec, background_heals, heal_wait_qlen);
+    GF_OPTION_RECONF("shd-max-threads", ec->shd.max_threads, options, uint32,
+                     failed);
+    GF_OPTION_RECONF("shd-wait-qlength", ec->shd.wait_qlength, options, uint32,
+                     failed);
+
+    GF_OPTION_RECONF("read-policy", read_policy, options, str, failed);
+
+    GF_OPTION_RECONF("optimistic-change-log", ec->optimistic_changelog, options,
+                     bool, failed);
+    GF_OPTION_RECONF("parallel-writes", ec->parallel_writes, options, bool,
+                     failed);
+    GF_OPTION_RECONF("stripe-cache", ec->stripe_cache, options, uint32, failed);
+    ret = 0;
+    if (ec_assign_read_policy(ec, read_policy)) {
+        ret = -1;
+    }
+
+    err = ec_method_update(this, &ec->matrix, extensions);
+    if (err != 0) {
+        ret = -1;
+    }
 
 failed:
-        return ret;
+    return ret;
 }
 
 glusterfs_event_t
-ec_get_event_from_state (ec_t *ec)
-{
-        int               down_count = 0;
-
-        if (ec->xl_up_count >= ec->fragments) {
-                /* If ec is up but some subvolumes are yet to notify, give
-                 * grace time for other subvols to notify to prevent start of
-                 * I/O which may result in self-heals */
-                if (ec->xl_notify_count < ec->nodes)
-                        return GF_EVENT_MAXVAL;
-
-                return GF_EVENT_CHILD_UP;
-        } else {
-                down_count = ec->xl_notify_count - ec->xl_up_count;
-                if (down_count > ec->redundancy)
-                        return GF_EVENT_CHILD_DOWN;
-        }
+ec_get_event_from_state(ec_t *ec)
+{
+    int down_count = 0;
+
+    if (ec->xl_up_count >= ec->fragments) {
+        /* If ec is up but some subvolumes are yet to notify, give
+         * grace time for other subvols to notify to prevent start of
+         * I/O which may result in self-heals */
+        if (ec->xl_notify_count < ec->nodes)
+            return GF_EVENT_MAXVAL;
+
+        return GF_EVENT_CHILD_UP;
+    } else {
+        down_count = ec->xl_notify_count - ec->xl_up_count;
+        if (down_count > ec->redundancy)
+            return GF_EVENT_CHILD_DOWN;
+    }
 
-        return GF_EVENT_MAXVAL;
+    return GF_EVENT_MAXVAL;
 }
 
 void
-ec_up (xlator_t *this, ec_t *ec)
+ec_up(xlator_t *this, ec_t *ec)
 {
-        if (ec->timer != NULL) {
-                gf_timer_call_cancel (this->ctx, ec->timer);
-                ec->timer = NULL;
-        }
+    if (ec->timer != NULL) {
+        gf_timer_call_cancel(this->ctx, ec->timer);
+        ec->timer = NULL;
+    }
 
-        ec->up = 1;
-        gf_msg (this->name, GF_LOG_INFO, 0, EC_MSG_EC_UP, "Going UP");
+    ec->up = 1;
+    gf_msg(this->name, GF_LOG_INFO, 0, EC_MSG_EC_UP, "Going UP");
 
-        gf_event (EVENT_EC_MIN_BRICKS_UP, "subvol=%s", this->name);
+    gf_event(EVENT_EC_MIN_BRICKS_UP, "subvol=%s", this->name);
 }
 
 void
-ec_down (xlator_t *this, ec_t *ec)
+ec_down(xlator_t *this, ec_t *ec)
 {
-        if (ec->timer != NULL) {
-                gf_timer_call_cancel(this->ctx, ec->timer);
-                ec->timer = NULL;
-        }
+    if (ec->timer != NULL) {
+        gf_timer_call_cancel(this->ctx, ec->timer);
+        ec->timer = NULL;
+    }
 
-        ec->up = 0;
-        gf_msg (this->name, GF_LOG_INFO, 0, EC_MSG_EC_DOWN, "Going DOWN");
+    ec->up = 0;
+    gf_msg(this->name, GF_LOG_INFO, 0, EC_MSG_EC_DOWN, "Going DOWN");
 
-        gf_event (EVENT_EC_MIN_BRICKS_NOT_UP, "subvol=%s", this->name);
+    gf_event(EVENT_EC_MIN_BRICKS_NOT_UP, "subvol=%s", this->name);
 }
 
 void
-ec_notify_cbk (void *data)
+ec_notify_cbk(void *data)
 {
-        ec_t *ec = data;
-        glusterfs_event_t event = GF_EVENT_MAXVAL;
-        gf_boolean_t propagate = _gf_false;
+    ec_t *ec = data;
+    glusterfs_event_t event = GF_EVENT_MAXVAL;
+    gf_boolean_t propagate = _gf_false;
 
-        LOCK(&ec->lock);
-        {
-                if (!ec->timer) {
-                        /*
-                         * Either child_up/child_down is already sent to parent
-                         * This is a spurious wake up.
-                         */
-                        goto unlock;
-                }
-
-                gf_timer_call_cancel (ec->xl->ctx, ec->timer);
-                ec->timer = NULL;
-
-                /* The timeout has expired, so any subvolume that has not
-                 * already reported its state, will be considered to be down.
-                 * We mark as if all bricks had reported. */
-                ec->xl_notify = (1ULL << ec->nodes) - 1ULL;
-                ec->xl_notify_count = ec->nodes;
-
-                /* Since we have marked all subvolumes as notified, it's
-                 * guaranteed that ec_get_event_from_state() will return
-                 * CHILD_UP or CHILD_DOWN, but not MAXVAL. */
-                event = ec_get_event_from_state (ec);
-                if (event == GF_EVENT_CHILD_UP) {
-                        /* We are ready to bring the volume up. If there are
-                         * still bricks DOWN, they will be healed when they
-                         * come up. */
-                        ec_up (ec->xl, ec);
-                }
-
-                propagate = _gf_true;
+    LOCK(&ec->lock);
+    {
+        if (!ec->timer) {
+            /*
+             * Either child_up/child_down is already sent to parent
+             * This is a spurious wake up.
+             */
+            goto unlock;
+        }
+
+        gf_timer_call_cancel(ec->xl->ctx, ec->timer);
+        ec->timer = NULL;
+
+        /* The timeout has expired, so any subvolume that has not
+         * already reported its state, will be considered to be down.
+         * We mark as if all bricks had reported. */
+        ec->xl_notify = (1ULL << ec->nodes) - 1ULL;
+        ec->xl_notify_count = ec->nodes;
+
+        /* Since we have marked all subvolumes as notified, it's
+         * guaranteed that ec_get_event_from_state() will return
+         * CHILD_UP or CHILD_DOWN, but not MAXVAL. */
+        event = ec_get_event_from_state(ec);
+        if (event == GF_EVENT_CHILD_UP) {
+            /* We are ready to bring the volume up. If there are
+             * still bricks DOWN, they will be healed when they
+             * come up. */
+            ec_up(ec->xl, ec);
         }
-unlock:
-        UNLOCK(&ec->lock);
 
-        if (propagate) {
-                if ((event == GF_EVENT_CHILD_UP) && ec->shd.iamshd) {
-                        /* We have just brought the volume UP, so we trigger
-                         * a self-heal check on the root directory. */
-                        ec_launch_replace_heal (ec);
-                }
+        propagate = _gf_true;
+    }
+unlock:
+    UNLOCK(&ec->lock);
 
-                default_notify (ec->xl, event, NULL);
+    if (propagate) {
+        if ((event == GF_EVENT_CHILD_UP) && ec->shd.iamshd) {
+            /* We have just brought the volume UP, so we trigger
+             * a self-heal check on the root directory. */
+            ec_launch_replace_heal(ec);
         }
 
+        default_notify(ec->xl, event, NULL);
+    }
 }
 
 void
-ec_launch_notify_timer (xlator_t *this, ec_t *ec)
-{
-        struct timespec delay = {0, };
-
-        gf_msg_debug (this->name, 0, "Initiating child-down timer");
-        delay.tv_sec = 10;
-        delay.tv_nsec = 0;
-        ec->timer = gf_timer_call_after (this->ctx, delay, ec_notify_cbk, ec);
-        if (ec->timer == NULL) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                        EC_MSG_TIMER_CREATE_FAIL, "Cannot create timer "
-                        "for delayed initialization");
-        }
+ec_launch_notify_timer(xlator_t *this, ec_t *ec)
+{
+    struct timespec delay = {
+        0,
+    };
+
+    gf_msg_debug(this->name, 0, "Initiating child-down timer");
+    delay.tv_sec = 10;
+    delay.tv_nsec = 0;
+    ec->timer = gf_timer_call_after(this->ctx, delay, ec_notify_cbk, ec);
+    if (ec->timer == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_TIMER_CREATE_FAIL,
+               "Cannot create timer "
+               "for delayed initialization");
+    }
 }
 
 gf_boolean_t
 ec_disable_delays(ec_t *ec)
 {
-        ec->shutdown = _gf_true;
+    ec->shutdown = _gf_true;
 
-        return list_empty (&ec->pending_fops);
+    return list_empty(&ec->pending_fops);
 }
 
 void
 ec_pending_fops_completed(ec_t *ec)
 {
-        if (ec->shutdown) {
-                default_notify (ec->xl, GF_EVENT_PARENT_DOWN, NULL);
-        }
+    if (ec->shutdown) {
+        default_notify(ec->xl, GF_EVENT_PARENT_DOWN, NULL);
+    }
 }
 
 static gf_boolean_t
 ec_set_up_state(ec_t *ec, uintptr_t index_mask, uintptr_t new_state)
 {
-        uintptr_t current_state = 0;
+    uintptr_t current_state = 0;
 
-        if ((ec->xl_notify & index_mask) == 0) {
-                ec->xl_notify |= index_mask;
-                ec->xl_notify_count++;
-        }
-        current_state = ec->xl_up & index_mask;
-        if (current_state != new_state) {
-                ec->xl_up ^= index_mask;
-                ec->xl_up_count += (current_state ? -1 : 1);
+    if ((ec->xl_notify & index_mask) == 0) {
+        ec->xl_notify |= index_mask;
+        ec->xl_notify_count++;
+    }
+    current_state = ec->xl_up & index_mask;
+    if (current_state != new_state) {
+        ec->xl_up ^= index_mask;
+        ec->xl_up_count += (current_state ? -1 : 1);
 
-                return _gf_true;
-        }
+        return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
 static gf_boolean_t
 ec_upcall(ec_t *ec, struct gf_upcall *upcall)
 {
-        struct gf_upcall_cache_invalidation *ci = NULL;
-        struct gf_upcall_inodelk_contention *lc = NULL;
-        inode_t *inode;
+    struct gf_upcall_cache_invalidation *ci = NULL;
+    struct gf_upcall_inodelk_contention *lc = NULL;
+    inode_t *inode;
 
-        switch (upcall->event_type) {
+    switch (upcall->event_type) {
         case GF_UPCALL_CACHE_INVALIDATION:
-                ci = upcall->data;
-                ci->flags |= UP_INVAL_ATTR;
-                return _gf_true;
+            ci = upcall->data;
+            ci->flags |= UP_INVAL_ATTR;
+            return _gf_true;
 
         case GF_UPCALL_INODELK_CONTENTION:
-                lc = upcall->data;
-                if (strcmp(lc->domain, ec->xl->name) != 0) {
-                        /* The lock is not owned by EC, ignore it. */
-                        return _gf_true;
-                }
-                inode = inode_find(((xlator_t *)ec->xl->graph->top)->itable,
-                                   upcall->gfid);
-                /* If inode is not found, it means that it's already released,
-                 * so we can ignore it. Probably it has been released and
-                 * destroyed while the contention notification was being sent.
-                 */
-                if (inode != NULL) {
-                        ec_lock_release(ec, inode);
-                        inode_unref(inode);
-                }
-
-                return _gf_false;
+            lc = upcall->data;
+            if (strcmp(lc->domain, ec->xl->name) != 0) {
+                /* The lock is not owned by EC, ignore it. */
+                return _gf_true;
+            }
+            inode = inode_find(((xlator_t *)ec->xl->graph->top)->itable,
+                               upcall->gfid);
+            /* If inode is not found, it means that it's already released,
+             * so we can ignore it. Probably it has been released and
+             * destroyed while the contention notification was being sent.
+             */
+            if (inode != NULL) {
+                ec_lock_release(ec, inode);
+                inode_unref(inode);
+            }
+
+            return _gf_false;
 
         default:
-                return _gf_true;
-        }
+            return _gf_true;
+    }
 }
 
 int32_t
-ec_notify (xlator_t *this, int32_t event, void *data, void *data2)
-{
-        ec_t             *ec              = this->private;
-        int32_t           idx             = 0;
-        int32_t           error           = 0;
-        glusterfs_event_t old_event       = GF_EVENT_MAXVAL;
-        dict_t            *input          = NULL;
-        dict_t            *output         = NULL;
-        gf_boolean_t      propagate       = _gf_true;
-        gf_boolean_t      needs_shd_check = _gf_false;
-        int32_t           orig_event      = event;
-        uintptr_t         mask            = 0;
-
-        gf_msg_trace (this->name, 0, "NOTIFY(%d): %p, %p",
-                event, data, data2);
-
-        if (event == GF_EVENT_UPCALL) {
-                propagate = ec_upcall(ec, data);
-                goto done;
+ec_notify(xlator_t *this, int32_t event, void *data, void *data2)
+{
+    ec_t *ec = this->private;
+    int32_t idx = 0;
+    int32_t error = 0;
+    glusterfs_event_t old_event = GF_EVENT_MAXVAL;
+    dict_t *input = NULL;
+    dict_t *output = NULL;
+    gf_boolean_t propagate = _gf_true;
+    gf_boolean_t needs_shd_check = _gf_false;
+    int32_t orig_event = event;
+    uintptr_t mask = 0;
+
+    gf_msg_trace(this->name, 0, "NOTIFY(%d): %p, %p", event, data, data2);
+
+    if (event == GF_EVENT_UPCALL) {
+        propagate = ec_upcall(ec, data);
+        goto done;
+    }
+
+    if (event == GF_EVENT_TRANSLATOR_OP) {
+        if (!ec->up) {
+            error = -1;
+        } else {
+            input = data;
+            output = data2;
+            error = ec_xl_op(this, input, output);
         }
+        goto out;
+    }
 
-        if (event == GF_EVENT_TRANSLATOR_OP) {
-                if (!ec->up) {
-                        error = -1;
-                } else {
-                        input = data;
-                        output = data2;
-                        error = ec_xl_op (this, input, output);
-                }
-                goto out;
+    for (idx = 0; idx < ec->nodes; idx++) {
+        if (ec->xl_list[idx] == data) {
+            break;
         }
+    }
 
-        for (idx = 0; idx < ec->nodes; idx++) {
-                if (ec->xl_list[idx] == data) {
-                        break;
-                }
+    LOCK(&ec->lock);
+
+    if (event == GF_EVENT_PARENT_UP) {
+        /*
+         * Start a timer which sends appropriate event to parent
+         * xlator to prevent the 'mount' syscall from hanging.
+         */
+        ec_launch_notify_timer(this, ec);
+        goto unlock;
+    } else if (event == GF_EVENT_PARENT_DOWN) {
+        /* If there aren't pending fops running after we have waken up
+         * them, we immediately propagate the notification. */
+        propagate = ec_disable_delays(ec);
+        goto unlock;
+    }
+
+    if (idx < ec->nodes) { /* CHILD_* events */
+        old_event = ec_get_event_from_state(ec);
+
+        mask = 1ULL << idx;
+        if (event == GF_EVENT_CHILD_UP) {
+            /* We need to trigger a selfheal if a brick changes
+             * to UP state. */
+            needs_shd_check = ec_set_up_state(ec, mask, mask);
+        } else if (event == GF_EVENT_CHILD_DOWN) {
+            ec_set_up_state(ec, mask, 0);
         }
 
-        LOCK (&ec->lock);
-
-        if (event == GF_EVENT_PARENT_UP) {
-                /*
-                 * Start a timer which sends appropriate event to parent
-                 * xlator to prevent the 'mount' syscall from hanging.
-                 */
-                ec_launch_notify_timer (this, ec);
-                goto unlock;
-        } else if (event == GF_EVENT_PARENT_DOWN) {
-                /* If there aren't pending fops running after we have waken up
-                 * them, we immediately propagate the notification. */
-                propagate = ec_disable_delays(ec);
-                goto unlock;
+        event = ec_get_event_from_state(ec);
+
+        if (event == GF_EVENT_CHILD_UP) {
+            if (!ec->up) {
+                ec_up(this, ec);
+            }
+        } else {
+            /* If the volume is not UP, it's irrelevant if one
+             * brick has come up. We cannot heal anything. */
+            needs_shd_check = _gf_false;
+
+            if ((event == GF_EVENT_CHILD_DOWN) && ec->up) {
+                ec_down(this, ec);
+            }
         }
 
-        if (idx < ec->nodes) { /* CHILD_* events */
-                old_event = ec_get_event_from_state (ec);
-
-                mask = 1ULL << idx;
-                if (event == GF_EVENT_CHILD_UP) {
-                        /* We need to trigger a selfheal if a brick changes
-                         * to UP state. */
-                        needs_shd_check = ec_set_up_state(ec, mask, mask);
-                } else if (event == GF_EVENT_CHILD_DOWN) {
-                        ec_set_up_state(ec, mask, 0);
-                }
-
-                event = ec_get_event_from_state (ec);
-
-                if (event == GF_EVENT_CHILD_UP) {
-                        if (!ec->up) {
-                                ec_up (this, ec);
-                        }
-                } else {
-                        /* If the volume is not UP, it's irrelevant if one
-                         * brick has come up. We cannot heal anything. */
-                        needs_shd_check = _gf_false;
-
-                        if ((event == GF_EVENT_CHILD_DOWN) && ec->up) {
-                                ec_down (this, ec);
-                        }
-                }
-
-                if (event != GF_EVENT_MAXVAL) {
-                        if (event == old_event) {
-                                if (orig_event == GF_EVENT_CHILD_UP)
-                                        event = GF_EVENT_SOME_DESCENDENT_UP;
-                                else /* orig_event has to be GF_EVENT_CHILD_DOWN */
-                                        event = GF_EVENT_SOME_DESCENDENT_DOWN;
-                        }
-                } else {
-                        propagate = _gf_false;
-                }
+        if (event != GF_EVENT_MAXVAL) {
+            if (event == old_event) {
+                if (orig_event == GF_EVENT_CHILD_UP)
+                    event = GF_EVENT_SOME_DESCENDENT_UP;
+                else /* orig_event has to be GF_EVENT_CHILD_DOWN */
+                    event = GF_EVENT_SOME_DESCENDENT_DOWN;
+            }
+        } else {
+            propagate = _gf_false;
         }
+    }
 unlock:
-        UNLOCK (&ec->lock);
+    UNLOCK(&ec->lock);
 
 done:
-        if (propagate) {
-                if (needs_shd_check && ec->shd.iamshd) {
-                        ec_launch_replace_heal (ec);
-                }
-
-                error = default_notify (this, event, data);
+    if (propagate) {
+        if (needs_shd_check && ec->shd.iamshd) {
+            ec_launch_replace_heal(ec);
         }
 
+        error = default_notify(this, event, data);
+    }
+
 out:
-        return error;
+    return error;
 }
 
 int32_t
-notify (xlator_t *this, int32_t event, void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        int ret = -1;
-        va_list         ap;
-        void *data2 = NULL;
+    int ret = -1;
+    va_list ap;
+    void *data2 = NULL;
 
-        va_start (ap, data);
-        data2 = va_arg (ap, dict_t*);
-        va_end (ap);
-        ret = ec_notify (this, event, data, data2);
+    va_start(ap, data);
+    data2 = va_arg(ap, dict_t *);
+    va_end(ap);
+    ret = ec_notify(this, event, data, data2);
 
-        return ret;
+    return ret;
 }
 
 static void
 ec_statistics_init(ec_t *ec)
 {
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.hits, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.misses, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.updates, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.invals, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.evicts, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.allocs, 0);
-        GF_ATOMIC_INIT(ec->stats.stripe_cache.errors, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.hits, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.misses, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.updates, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.invals, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.evicts, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.allocs, 0);
+    GF_ATOMIC_INIT(ec->stats.stripe_cache.errors, 0);
 }
 
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-    ec_t *ec          = NULL;
+    ec_t *ec = NULL;
     char *read_policy = NULL;
-    char *extensions  = NULL;
+    char *extensions = NULL;
     int32_t err;
 
-    if (this->parents == NULL)
-    {
-        gf_msg (this->name, GF_LOG_WARNING, 0,
-                EC_MSG_NO_PARENTS, "Volume does not have parents.");
+    if (this->parents == NULL) {
+        gf_msg(this->name, GF_LOG_WARNING, 0, EC_MSG_NO_PARENTS,
+               "Volume does not have parents.");
     }
 
     ec = GF_MALLOC(sizeof(*ec), ec_mt_ec_t);
-    if (ec == NULL)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Failed to allocate private memory.");
+    if (ec == NULL) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Failed to allocate private memory.");
 
         return -1;
     }
@@ -680,26 +664,23 @@ init (xlator_t *this)
     ec->cbk_pool = mem_pool_new(ec_cbk_data_t, 4096);
     ec->lock_pool = mem_pool_new(ec_lock_t, 1024);
     if ((ec->fop_pool == NULL) || (ec->cbk_pool == NULL) ||
-        (ec->lock_pool == NULL))
-    {
-        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                EC_MSG_NO_MEMORY, "Failed to create memory pools.");
+        (ec->lock_pool == NULL)) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, EC_MSG_NO_MEMORY,
+               "Failed to create memory pools.");
 
         goto failed;
     }
 
-    if (ec_prepare_childs(this) != 0)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, 0,
-                EC_MSG_XLATOR_INIT_FAIL, "Failed to initialize xlator");
+    if (ec_prepare_childs(this) != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_XLATOR_INIT_FAIL,
+               "Failed to initialize xlator");
 
         goto failed;
     }
 
-    if (ec_parse_options(this) != 0)
-    {
-        gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                EC_MSG_XLATOR_PARSE_OPT_FAIL, "Failed to parse xlator options");
+    if (ec_parse_options(this) != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, EC_MSG_XLATOR_PARSE_OPT_FAIL,
+               "Failed to parse xlator options");
 
         goto failed;
     }
@@ -709,58 +690,59 @@ init (xlator_t *this)
     err = ec_method_init(this, &ec->matrix, ec->fragments, ec->nodes,
                          ec->nodes * 2, extensions);
     if (err != 0) {
-        gf_msg (this->name, GF_LOG_ERROR, -err, EC_MSG_MATRIX_FAILED,
-                "Failed to initialize matrix management");
+        gf_msg(this->name, GF_LOG_ERROR, -err, EC_MSG_MATRIX_FAILED,
+               "Failed to initialize matrix management");
 
         goto failed;
     }
 
-    GF_OPTION_INIT ("self-heal-daemon", ec->shd.enabled, bool, failed);
-    GF_OPTION_INIT ("iam-self-heal-daemon", ec->shd.iamshd, bool, failed);
-    GF_OPTION_INIT ("eager-lock", ec->eager_lock, bool, failed);
-    GF_OPTION_INIT ("other-eager-lock", ec->other_eager_lock, bool, failed);
-    GF_OPTION_INIT ("eager-lock-timeout", ec->eager_lock_timeout, uint32,
-                    failed);
-    GF_OPTION_INIT ("other-eager-lock-timeout", ec->other_eager_lock_timeout,
-                    uint32, failed);
-    GF_OPTION_INIT ("background-heals", ec->background_heals, uint32, failed);
-    GF_OPTION_INIT ("heal-wait-qlength", ec->heal_wait_qlen, uint32, failed);
-    GF_OPTION_INIT ("self-heal-window-size", ec->self_heal_window_size, uint32,
-                    failed);
-    ec_configure_background_heal_opts (ec, ec->background_heals,
-                                       ec->heal_wait_qlen);
-    GF_OPTION_INIT ("read-policy", read_policy, str, failed);
-    if (ec_assign_read_policy (ec, read_policy))
-            goto failed;
-
-    GF_OPTION_INIT ("shd-max-threads", ec->shd.max_threads, uint32, failed);
-    GF_OPTION_INIT ("shd-wait-qlength", ec->shd.wait_qlength, uint32, failed);
-    GF_OPTION_INIT ("optimistic-change-log", ec->optimistic_changelog, bool, failed);
-    GF_OPTION_INIT ("parallel-writes", ec->parallel_writes, bool, failed);
-    GF_OPTION_INIT ("stripe-cache", ec->stripe_cache, uint32, failed);
-
-    this->itable = inode_table_new (EC_SHD_INODE_LRU_LIMIT, this);
+    GF_OPTION_INIT("self-heal-daemon", ec->shd.enabled, bool, failed);
+    GF_OPTION_INIT("iam-self-heal-daemon", ec->shd.iamshd, bool, failed);
+    GF_OPTION_INIT("eager-lock", ec->eager_lock, bool, failed);
+    GF_OPTION_INIT("other-eager-lock", ec->other_eager_lock, bool, failed);
+    GF_OPTION_INIT("eager-lock-timeout", ec->eager_lock_timeout, uint32,
+                   failed);
+    GF_OPTION_INIT("other-eager-lock-timeout", ec->other_eager_lock_timeout,
+                   uint32, failed);
+    GF_OPTION_INIT("background-heals", ec->background_heals, uint32, failed);
+    GF_OPTION_INIT("heal-wait-qlength", ec->heal_wait_qlen, uint32, failed);
+    GF_OPTION_INIT("self-heal-window-size", ec->self_heal_window_size, uint32,
+                   failed);
+    ec_configure_background_heal_opts(ec, ec->background_heals,
+                                      ec->heal_wait_qlen);
+    GF_OPTION_INIT("read-policy", read_policy, str, failed);
+    if (ec_assign_read_policy(ec, read_policy))
+        goto failed;
+
+    GF_OPTION_INIT("shd-max-threads", ec->shd.max_threads, uint32, failed);
+    GF_OPTION_INIT("shd-wait-qlength", ec->shd.wait_qlength, uint32, failed);
+    GF_OPTION_INIT("optimistic-change-log", ec->optimistic_changelog, bool,
+                   failed);
+    GF_OPTION_INIT("parallel-writes", ec->parallel_writes, bool, failed);
+    GF_OPTION_INIT("stripe-cache", ec->stripe_cache, uint32, failed);
+
+    this->itable = inode_table_new(EC_SHD_INODE_LRU_LIMIT, this);
     if (!this->itable)
-            goto failed;
+        goto failed;
 
     if (ec->shd.iamshd)
-            ec_selfheal_daemon_init (this);
-    gf_msg_debug (this->name, 0, "Disperse translator initialized.");
+        ec_selfheal_daemon_init(this);
+    gf_msg_debug(this->name, 0, "Disperse translator initialized.");
 
-    ec->leaf_to_subvolid = dict_new ();
+    ec->leaf_to_subvolid = dict_new();
     if (!ec->leaf_to_subvolid)
-            goto failed;
-    if (glusterfs_reachable_leaves (this, ec->leaf_to_subvolid)) {
-        gf_msg (this->name, GF_LOG_ERROR, 0,
-                EC_MSG_SUBVOL_BUILD_FAIL, "Failed to build subvol "
-                "dictionary");
+        goto failed;
+    if (glusterfs_reachable_leaves(this, ec->leaf_to_subvolid)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_SUBVOL_BUILD_FAIL,
+               "Failed to build subvol "
+               "dictionary");
         goto failed;
     }
 
-    if (ec_subvol_to_subvol_id_transform (ec, ec->leaf_to_subvolid) < 0) {
-        gf_msg (this->name, GF_LOG_ERROR, 0,
-                EC_MSG_SUBVOL_ID_DICT_SET_FAIL, "Failed to build subvol-id "
-                "dictionary");
+    if (ec_subvol_to_subvol_id_transform(ec, ec->leaf_to_subvolid) < 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, EC_MSG_SUBVOL_ID_DICT_SET_FAIL,
+               "Failed to build subvol-id "
+               "dictionary");
         goto failed;
     }
 
@@ -774,13 +756,15 @@ failed:
     return -1;
 }
 
-void fini(xlator_t * this)
+void
+fini(xlator_t *this)
 {
     __ec_destroy_private(this);
 }
 
-int32_t ec_gf_access(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                     int32_t mask, dict_t * xdata)
+int32_t
+ec_gf_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+             dict_t *xdata)
 {
     ec_access(frame, this, -1, EC_MINIMUM_ONE, default_access_cbk, NULL, loc,
               mask, xdata);
@@ -788,9 +772,9 @@ int32_t ec_gf_access(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_create(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                     int32_t flags, mode_t mode, mode_t umask, fd_t * fd,
-                     dict_t * xdata)
+int32_t
+ec_gf_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+             mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
     ec_create(frame, this, -1, EC_MINIMUM_MIN, default_create_cbk, NULL, loc,
               flags, mode, umask, fd, xdata);
@@ -798,53 +782,56 @@ int32_t ec_gf_create(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_discard(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                      off_t offset, size_t len, dict_t * xdata)
+int32_t
+ec_gf_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+              size_t len, dict_t *xdata)
 {
-    ec_discard(frame, this, -1, EC_MINIMUM_MIN, default_discard_cbk,
-               NULL, fd, offset, len, xdata);
+    ec_discard(frame, this, -1, EC_MINIMUM_MIN, default_discard_cbk, NULL, fd,
+               offset, len, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_entrylk(call_frame_t * frame, xlator_t * this,
-                      const char * volume, loc_t * loc, const char * basename,
-                      entrylk_cmd cmd, entrylk_type type, dict_t * xdata)
+int32_t
+ec_gf_entrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+              loc_t *loc, const char *basename, entrylk_cmd cmd,
+              entrylk_type type, dict_t *xdata)
 {
     int32_t minimum = EC_MINIMUM_ALL;
     if (cmd == ENTRYLK_UNLOCK)
-            minimum = EC_MINIMUM_ONE;
-    ec_entrylk(frame, this, -1, minimum, default_entrylk_cbk, NULL,
-               volume, loc, basename, cmd, type, xdata);
+        minimum = EC_MINIMUM_ONE;
+    ec_entrylk(frame, this, -1, minimum, default_entrylk_cbk, NULL, volume, loc,
+               basename, cmd, type, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_fentrylk(call_frame_t * frame, xlator_t * this,
-                       const char * volume, fd_t * fd, const char * basename,
-                       entrylk_cmd cmd, entrylk_type type, dict_t * xdata)
+int32_t
+ec_gf_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+               fd_t *fd, const char *basename, entrylk_cmd cmd,
+               entrylk_type type, dict_t *xdata)
 {
     int32_t minimum = EC_MINIMUM_ALL;
     if (cmd == ENTRYLK_UNLOCK)
-            minimum = EC_MINIMUM_ONE;
-    ec_fentrylk(frame, this, -1, minimum, default_fentrylk_cbk, NULL,
-                volume, fd, basename, cmd, type, xdata);
+        minimum = EC_MINIMUM_ONE;
+    ec_fentrylk(frame, this, -1, minimum, default_fentrylk_cbk, NULL, volume,
+                fd, basename, cmd, type, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_fallocate(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                        int32_t mode, off_t offset, size_t len,
-                        dict_t * xdata)
+int32_t
+ec_gf_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
+                off_t offset, size_t len, dict_t *xdata)
 {
-    ec_fallocate(frame, this, -1, EC_MINIMUM_MIN, default_fallocate_cbk,
-                 NULL, fd, mode, offset, len, xdata);
+    ec_fallocate(frame, this, -1, EC_MINIMUM_MIN, default_fallocate_cbk, NULL,
+                 fd, mode, offset, len, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_flush(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                    dict_t * xdata)
+int32_t
+ec_gf_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
     ec_flush(frame, this, -1, EC_MINIMUM_MIN, default_flush_cbk, NULL, fd,
              xdata);
@@ -852,8 +839,9 @@ int32_t ec_gf_flush(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_fsync(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                    int32_t datasync, dict_t * xdata)
+int32_t
+ec_gf_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+            dict_t *xdata)
 {
     ec_fsync(frame, this, -1, EC_MINIMUM_MIN, default_fsync_cbk, NULL, fd,
              datasync, xdata);
@@ -861,114 +849,114 @@ int32_t ec_gf_fsync(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_fsyncdir(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                       int32_t datasync, dict_t * xdata)
+int32_t
+ec_gf_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+               dict_t *xdata)
 {
-    ec_fsyncdir(frame, this, -1, EC_MINIMUM_MIN, default_fsyncdir_cbk, NULL,
-                fd, datasync, xdata);
+    ec_fsyncdir(frame, this, -1, EC_MINIMUM_MIN, default_fsyncdir_cbk, NULL, fd,
+                datasync, xdata);
 
     return 0;
 }
 
 int
-ec_marker_populate_args (call_frame_t *frame, int type, int *gauge,
-                         xlator_t **subvols)
+ec_marker_populate_args(call_frame_t *frame, int type, int *gauge,
+                        xlator_t **subvols)
 {
-        xlator_t *this = frame->this;
-        ec_t *ec = this->private;
+    xlator_t *this = frame->this;
+    ec_t *ec = this->private;
 
-        memcpy (subvols, ec->xl_list, sizeof (*subvols) * ec->nodes);
+    memcpy(subvols, ec->xl_list, sizeof(*subvols) * ec->nodes);
 
-        if (type == MARKER_XTIME_TYPE) {
-                /*Don't error out on ENOENT/ENOTCONN */
-                gauge[MCNT_NOTFOUND] = 0;
-                gauge[MCNT_ENOTCONN] = 0;
-        }
+    if (type == MARKER_XTIME_TYPE) {
+        /*Don't error out on ENOENT/ENOTCONN */
+        gauge[MCNT_NOTFOUND] = 0;
+        gauge[MCNT_ENOTCONN] = 0;
+    }
 
-        return ec->nodes;
+    return ec->nodes;
 }
 
 int32_t
-ec_handle_heal_commands (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                         const char *name, dict_t *xdata)
+ec_handle_heal_commands(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                        const char *name, dict_t *xdata)
 {
-        dict_t  *dict_rsp = NULL;
-        int     op_ret = -1;
-        int     op_errno = ENOMEM;
+    dict_t *dict_rsp = NULL;
+    int op_ret = -1;
+    int op_errno = ENOMEM;
 
-        if (!name || strcmp (name, GF_HEAL_INFO))
-                return -1;
+    if (!name || strcmp(name, GF_HEAL_INFO))
+        return -1;
 
-        op_errno = -ec_get_heal_info (this, loc, &dict_rsp);
-        if (op_errno <= 0) {
-                op_errno = op_ret = 0;
-        }
+    op_errno = -ec_get_heal_info(this, loc, &dict_rsp);
+    if (op_errno <= 0) {
+        op_errno = op_ret = 0;
+    }
 
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict_rsp, NULL);
-        if (dict_rsp)
-                dict_unref (dict_rsp);
-        return 0;
+    STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict_rsp, NULL);
+    if (dict_rsp)
+        dict_unref(dict_rsp);
+    return 0;
 }
 
 int32_t
-ec_gf_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name, dict_t *xdata)
+ec_gf_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               const char *name, dict_t *xdata)
 {
-        int     error = 0;
-        ec_t    *ec = this->private;
-        int32_t minimum = EC_MINIMUM_ONE;
+    int error = 0;
+    ec_t *ec = this->private;
+    int32_t minimum = EC_MINIMUM_ONE;
 
-        if (name && strcmp (name, EC_XATTR_HEAL) != 0) {
-                EC_INTERNAL_XATTR_OR_GOTO(name, NULL, error, out);
-        }
+    if (name && strcmp(name, EC_XATTR_HEAL) != 0) {
+        EC_INTERNAL_XATTR_OR_GOTO(name, NULL, error, out);
+    }
 
-        if (ec_handle_heal_commands (frame, this, loc, name, xdata) == 0)
-                return 0;
+    if (ec_handle_heal_commands(frame, this, loc, name, xdata) == 0)
+        return 0;
 
-        if (cluster_handle_marker_getxattr (frame, loc, name, ec->vol_uuid,
-                                            NULL, ec_marker_populate_args) == 0)
-                return 0;
+    if (cluster_handle_marker_getxattr(frame, loc, name, ec->vol_uuid, NULL,
+                                       ec_marker_populate_args) == 0)
+        return 0;
 
-        if (name &&
-            ((fnmatch (GF_XATTR_STIME_PATTERN, name, 0) == 0) ||
-             XATTR_IS_NODE_UUID(name) || XATTR_IS_NODE_UUID_LIST(name))) {
-                minimum = EC_MINIMUM_ALL;
-        }
+    if (name && ((fnmatch(GF_XATTR_STIME_PATTERN, name, 0) == 0) ||
+                 XATTR_IS_NODE_UUID(name) || XATTR_IS_NODE_UUID_LIST(name))) {
+        minimum = EC_MINIMUM_ALL;
+    }
 
-        ec_getxattr (frame, this, -1, minimum, default_getxattr_cbk,
-                     NULL, loc, name, xdata);
+    ec_getxattr(frame, this, -1, minimum, default_getxattr_cbk, NULL, loc, name,
+                xdata);
 
-        return 0;
+    return 0;
 out:
-        error = ENODATA;
-        STACK_UNWIND_STRICT (getxattr, frame, -1, error, NULL, NULL);
-        return 0;
+    error = ENODATA;
+    STACK_UNWIND_STRICT(getxattr, frame, -1, error, NULL, NULL);
+    return 0;
 }
 
 int32_t
-ec_gf_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name, dict_t *xdata)
+ec_gf_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+                dict_t *xdata)
 {
-        int     error = 0;
+    int error = 0;
 
-        EC_INTERNAL_XATTR_OR_GOTO(name, NULL, error, out);
+    EC_INTERNAL_XATTR_OR_GOTO(name, NULL, error, out);
 
-        ec_fgetxattr (frame, this, -1, EC_MINIMUM_ONE, default_fgetxattr_cbk,
-                      NULL, fd, name, xdata);
-        return 0;
+    ec_fgetxattr(frame, this, -1, EC_MINIMUM_ONE, default_fgetxattr_cbk, NULL,
+                 fd, name, xdata);
+    return 0;
 out:
-        error = ENODATA;
-        STACK_UNWIND_STRICT (fgetxattr, frame, -1, error, NULL, NULL);
-        return 0;
+    error = ENODATA;
+    STACK_UNWIND_STRICT(fgetxattr, frame, -1, error, NULL, NULL);
+    return 0;
 }
 
-int32_t ec_gf_inodelk(call_frame_t * frame, xlator_t * this,
-                      const char * volume, loc_t * loc, int32_t cmd,
-                      struct gf_flock * flock, dict_t * xdata)
+int32_t
+ec_gf_inodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+              loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
     int32_t minimum = EC_MINIMUM_ALL;
     if (flock->l_type == F_UNLCK)
-            minimum = EC_MINIMUM_ONE;
+        minimum = EC_MINIMUM_ONE;
 
     ec_inodelk(frame, this, &frame->root->lk_owner, -1, minimum,
                default_inodelk_cbk, NULL, volume, loc, cmd, flock, xdata);
@@ -976,21 +964,22 @@ int32_t ec_gf_inodelk(call_frame_t * frame, xlator_t * this,
     return 0;
 }
 
-int32_t ec_gf_finodelk(call_frame_t * frame, xlator_t * this,
-                       const char * volume, fd_t * fd, int32_t cmd,
-                       struct gf_flock * flock, dict_t * xdata)
+int32_t
+ec_gf_finodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+               fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
     int32_t minimum = EC_MINIMUM_ALL;
     if (flock->l_type == F_UNLCK)
-            minimum = EC_MINIMUM_ONE;
+        minimum = EC_MINIMUM_ONE;
     ec_finodelk(frame, this, &frame->root->lk_owner, -1, minimum,
                 default_finodelk_cbk, NULL, volume, fd, cmd, flock, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_link(call_frame_t * frame, xlator_t * this, loc_t * oldloc,
-                   loc_t * newloc, dict_t * xdata)
+int32_t
+ec_gf_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+           dict_t *xdata)
 {
     ec_link(frame, this, -1, EC_MINIMUM_MIN, default_link_cbk, NULL, oldloc,
             newloc, xdata);
@@ -998,20 +987,21 @@ int32_t ec_gf_link(call_frame_t * frame, xlator_t * this, loc_t * oldloc,
     return 0;
 }
 
-int32_t ec_gf_lk(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                 int32_t cmd, struct gf_flock * flock, dict_t * xdata)
+int32_t
+ec_gf_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+         struct gf_flock *flock, dict_t *xdata)
 {
     int32_t minimum = EC_MINIMUM_ALL;
     if (flock->l_type == F_UNLCK)
-            minimum = EC_MINIMUM_ONE;
-    ec_lk(frame, this, -1, minimum, default_lk_cbk, NULL, fd, cmd,
-          flock, xdata);
+        minimum = EC_MINIMUM_ONE;
+    ec_lk(frame, this, -1, minimum, default_lk_cbk, NULL, fd, cmd, flock,
+          xdata);
 
     return 0;
 }
 
-int32_t ec_gf_lookup(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                     dict_t * xdata)
+int32_t
+ec_gf_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
     ec_lookup(frame, this, -1, EC_MINIMUM_MIN, default_lookup_cbk, NULL, loc,
               xdata);
@@ -1019,8 +1009,9 @@ int32_t ec_gf_lookup(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_mkdir(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                    mode_t mode, mode_t umask, dict_t * xdata)
+int32_t
+ec_gf_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            mode_t umask, dict_t *xdata)
 {
     ec_mkdir(frame, this, -1, EC_MINIMUM_MIN, default_mkdir_cbk, NULL, loc,
              mode, umask, xdata);
@@ -1028,8 +1019,9 @@ int32_t ec_gf_mkdir(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_mknod(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                    mode_t mode, dev_t rdev, mode_t umask, dict_t * xdata)
+int32_t
+ec_gf_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+            dev_t rdev, mode_t umask, dict_t *xdata)
 {
     ec_mknod(frame, this, -1, EC_MINIMUM_MIN, default_mknod_cbk, NULL, loc,
              mode, rdev, umask, xdata);
@@ -1037,17 +1029,19 @@ int32_t ec_gf_mknod(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_open(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                   int32_t flags, fd_t * fd, dict_t * xdata)
+int32_t
+ec_gf_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+           fd_t *fd, dict_t *xdata)
 {
-    ec_open(frame, this, -1, EC_MINIMUM_MIN, default_open_cbk, NULL, loc,
-            flags, fd, xdata);
+    ec_open(frame, this, -1, EC_MINIMUM_MIN, default_open_cbk, NULL, loc, flags,
+            fd, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_opendir(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                      fd_t * fd, dict_t * xdata)
+int32_t
+ec_gf_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+              dict_t *xdata)
 {
     ec_opendir(frame, this, -1, EC_MINIMUM_MIN, default_opendir_cbk, NULL, loc,
                fd, xdata);
@@ -1055,8 +1049,9 @@ int32_t ec_gf_opendir(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_readdir(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                      size_t size, off_t offset, dict_t * xdata)
+int32_t
+ec_gf_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+              off_t offset, dict_t *xdata)
 {
     ec_readdir(frame, this, -1, EC_MINIMUM_ONE, default_readdir_cbk, NULL, fd,
                size, offset, xdata);
@@ -1064,17 +1059,19 @@ int32_t ec_gf_readdir(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_readdirp(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                       size_t size, off_t offset, dict_t * xdata)
+int32_t
+ec_gf_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t offset, dict_t *xdata)
 {
-    ec_readdirp(frame, this, -1, EC_MINIMUM_ONE, default_readdirp_cbk, NULL,
-                fd, size, offset, xdata);
+    ec_readdirp(frame, this, -1, EC_MINIMUM_ONE, default_readdirp_cbk, NULL, fd,
+                size, offset, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_readlink(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                       size_t size, dict_t * xdata)
+int32_t
+ec_gf_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+               dict_t *xdata)
 {
     ec_readlink(frame, this, -1, EC_MINIMUM_ONE, default_readlink_cbk, NULL,
                 loc, size, xdata);
@@ -1082,60 +1079,63 @@ int32_t ec_gf_readlink(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_readv(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                    size_t size, off_t offset, uint32_t flags, dict_t * xdata)
+int32_t
+ec_gf_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t offset, uint32_t flags, dict_t *xdata)
 {
-    ec_readv(frame, this, -1, EC_MINIMUM_MIN, default_readv_cbk, NULL, fd,
-             size, offset, flags, xdata);
+    ec_readv(frame, this, -1, EC_MINIMUM_MIN, default_readv_cbk, NULL, fd, size,
+             offset, flags, xdata);
 
     return 0;
 }
 
 int32_t
-ec_gf_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   const char *name, dict_t *xdata)
+ec_gf_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                  const char *name, dict_t *xdata)
 {
-        int     error  = 0;
+    int error = 0;
 
-        EC_INTERNAL_XATTR_OR_GOTO (name, xdata, error, out);
+    EC_INTERNAL_XATTR_OR_GOTO(name, xdata, error, out);
 
-        ec_removexattr (frame, this, -1, EC_MINIMUM_MIN,
-                        default_removexattr_cbk, NULL, loc, name, xdata);
+    ec_removexattr(frame, this, -1, EC_MINIMUM_MIN, default_removexattr_cbk,
+                   NULL, loc, name, xdata);
 
-        return 0;
+    return 0;
 out:
-        STACK_UNWIND_STRICT (removexattr, frame, -1, error, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(removexattr, frame, -1, error, NULL);
+    return 0;
 }
 
 int32_t
-ec_gf_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    const char *name, dict_t *xdata)
+ec_gf_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                   const char *name, dict_t *xdata)
 {
-        int     error  = 0;
+    int error = 0;
 
-        EC_INTERNAL_XATTR_OR_GOTO (name, xdata, error, out);
+    EC_INTERNAL_XATTR_OR_GOTO(name, xdata, error, out);
 
-        ec_fremovexattr (frame, this, -1, EC_MINIMUM_MIN,
-                         default_fremovexattr_cbk, NULL, fd, name, xdata);
+    ec_fremovexattr(frame, this, -1, EC_MINIMUM_MIN, default_fremovexattr_cbk,
+                    NULL, fd, name, xdata);
 
-        return 0;
+    return 0;
 out:
-        STACK_UNWIND_STRICT (fremovexattr, frame, -1, error, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(fremovexattr, frame, -1, error, NULL);
+    return 0;
 }
 
-int32_t ec_gf_rename(call_frame_t * frame, xlator_t * this, loc_t * oldloc,
-                     loc_t * newloc, dict_t * xdata)
+int32_t
+ec_gf_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata)
 {
-    ec_rename(frame, this, -1, EC_MINIMUM_MIN, default_rename_cbk, NULL,
-              oldloc, newloc, xdata);
+    ec_rename(frame, this, -1, EC_MINIMUM_MIN, default_rename_cbk, NULL, oldloc,
+              newloc, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_rmdir(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                    int xflags, dict_t * xdata)
+int32_t
+ec_gf_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
+            dict_t *xdata)
 {
     ec_rmdir(frame, this, -1, EC_MINIMUM_MIN, default_rmdir_cbk, NULL, loc,
              xflags, xdata);
@@ -1143,8 +1143,9 @@ int32_t ec_gf_rmdir(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_setattr(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                      struct iatt * stbuf, int32_t valid, dict_t * xdata)
+int32_t
+ec_gf_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+              struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
     ec_setattr(frame, this, -1, EC_MINIMUM_MIN, default_setattr_cbk, NULL, loc,
                stbuf, valid, xdata);
@@ -1152,51 +1153,52 @@ int32_t ec_gf_setattr(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_fsetattr(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                       struct iatt * stbuf, int32_t valid, dict_t * xdata)
+int32_t
+ec_gf_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+               struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-    ec_fsetattr(frame, this, -1, EC_MINIMUM_MIN, default_fsetattr_cbk, NULL,
-                fd, stbuf, valid, xdata);
+    ec_fsetattr(frame, this, -1, EC_MINIMUM_MIN, default_fsetattr_cbk, NULL, fd,
+                stbuf, valid, xdata);
 
     return 0;
 }
 
 int32_t
-ec_gf_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                dict_t *dict, int32_t flags, dict_t *xdata)
+ec_gf_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+               int32_t flags, dict_t *xdata)
 {
-        int     error = 0;
+    int error = 0;
 
-        EC_INTERNAL_XATTR_OR_GOTO ("", dict, error, out);
+    EC_INTERNAL_XATTR_OR_GOTO("", dict, error, out);
 
-        ec_setxattr (frame, this, -1, EC_MINIMUM_MIN, default_setxattr_cbk,
-                     NULL, loc, dict, flags, xdata);
+    ec_setxattr(frame, this, -1, EC_MINIMUM_MIN, default_setxattr_cbk, NULL,
+                loc, dict, flags, xdata);
 
-        return 0;
+    return 0;
 out:
-        STACK_UNWIND_STRICT (setxattr, frame, -1, error, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(setxattr, frame, -1, error, NULL);
+    return 0;
 }
 
 int32_t
-ec_gf_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 dict_t *dict, int32_t flags, dict_t *xdata)
+ec_gf_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+                int32_t flags, dict_t *xdata)
 {
-        int     error = 0;
+    int error = 0;
 
-        EC_INTERNAL_XATTR_OR_GOTO ("", dict, error, out);
+    EC_INTERNAL_XATTR_OR_GOTO("", dict, error, out);
 
-        ec_fsetxattr (frame, this, -1, EC_MINIMUM_MIN, default_fsetxattr_cbk,
-                      NULL, fd, dict, flags, xdata);
+    ec_fsetxattr(frame, this, -1, EC_MINIMUM_MIN, default_fsetxattr_cbk, NULL,
+                 fd, dict, flags, xdata);
 
-        return 0;
+    return 0;
 out:
-        STACK_UNWIND_STRICT (fsetxattr, frame, -1, error, NULL);
-        return 0;
+    STACK_UNWIND_STRICT(fsetxattr, frame, -1, error, NULL);
+    return 0;
 }
 
-int32_t ec_gf_stat(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                   dict_t * xdata)
+int32_t
+ec_gf_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
     ec_stat(frame, this, -1, EC_MINIMUM_MIN, default_stat_cbk, NULL, loc,
             xdata);
@@ -1204,8 +1206,8 @@ int32_t ec_gf_stat(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_fstat(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                    dict_t * xdata)
+int32_t
+ec_gf_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
     ec_fstat(frame, this, -1, EC_MINIMUM_MIN, default_fstat_cbk, NULL, fd,
              xdata);
@@ -1213,8 +1215,8 @@ int32_t ec_gf_fstat(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_statfs(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                     dict_t * xdata)
+int32_t
+ec_gf_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
     ec_statfs(frame, this, -1, EC_MINIMUM_MIN, default_statfs_cbk, NULL, loc,
               xdata);
@@ -1222,9 +1224,9 @@ int32_t ec_gf_statfs(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_symlink(call_frame_t * frame, xlator_t * this,
-                      const char * linkname, loc_t * loc, mode_t umask,
-                      dict_t * xdata)
+int32_t
+ec_gf_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
+              loc_t *loc, mode_t umask, dict_t *xdata)
 {
     ec_symlink(frame, this, -1, EC_MINIMUM_MIN, default_symlink_cbk, NULL,
                linkname, loc, umask, xdata);
@@ -1232,8 +1234,9 @@ int32_t ec_gf_symlink(call_frame_t * frame, xlator_t * this,
     return 0;
 }
 
-int32_t ec_gf_truncate(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                       off_t offset, dict_t * xdata)
+int32_t
+ec_gf_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+               dict_t *xdata)
 {
     ec_truncate(frame, this, -1, EC_MINIMUM_MIN, default_truncate_cbk, NULL,
                 loc, offset, xdata);
@@ -1241,8 +1244,9 @@ int32_t ec_gf_truncate(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_ftruncate(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                        off_t offset, dict_t * xdata)
+int32_t
+ec_gf_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                dict_t *xdata)
 {
     ec_ftruncate(frame, this, -1, EC_MINIMUM_MIN, default_ftruncate_cbk, NULL,
                  fd, offset, xdata);
@@ -1250,8 +1254,9 @@ int32_t ec_gf_ftruncate(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_unlink(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                     int xflags, dict_t * xdata)
+int32_t
+ec_gf_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
+             dict_t *xdata)
 {
     ec_unlink(frame, this, -1, EC_MINIMUM_MIN, default_unlink_cbk, NULL, loc,
               xflags, xdata);
@@ -1259,9 +1264,10 @@ int32_t ec_gf_unlink(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_writev(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                     struct iovec * vector, int32_t count, off_t offset,
-                     uint32_t flags, struct iobref * iobref, dict_t * xdata)
+int32_t
+ec_gf_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
+             struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
+             struct iobref *iobref, dict_t *xdata)
 {
     ec_writev(frame, this, -1, EC_MINIMUM_MIN, default_writev_cbk, NULL, fd,
               vector, count, offset, flags, iobref, xdata);
@@ -1269,9 +1275,9 @@ int32_t ec_gf_writev(call_frame_t * frame, xlator_t * this, fd_t * fd,
     return 0;
 }
 
-int32_t ec_gf_xattrop(call_frame_t * frame, xlator_t * this, loc_t * loc,
-                      gf_xattrop_flags_t optype, dict_t * xattr,
-                      dict_t * xdata)
+int32_t
+ec_gf_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+              gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
     ec_xattrop(frame, this, -1, EC_MINIMUM_MIN, default_xattrop_cbk, NULL, loc,
                optype, xattr, xdata);
@@ -1279,47 +1285,49 @@ int32_t ec_gf_xattrop(call_frame_t * frame, xlator_t * this, loc_t * loc,
     return 0;
 }
 
-int32_t ec_gf_fxattrop(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                       gf_xattrop_flags_t optype, dict_t * xattr,
-                       dict_t * xdata)
+int32_t
+ec_gf_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+               gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
-    ec_fxattrop(frame, this, -1, EC_MINIMUM_MIN, default_fxattrop_cbk, NULL,
-                fd, optype, xattr, xdata);
+    ec_fxattrop(frame, this, -1, EC_MINIMUM_MIN, default_fxattrop_cbk, NULL, fd,
+                optype, xattr, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_zerofill(call_frame_t * frame, xlator_t * this, fd_t * fd,
-                       off_t offset, off_t len, dict_t * xdata)
+int32_t
+ec_gf_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+               off_t len, dict_t *xdata)
 {
     default_zerofill_failure_cbk(frame, ENOTSUP);
 
     return 0;
 }
 
-int32_t ec_gf_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                   gf_seek_what_t what, dict_t *xdata)
+int32_t
+ec_gf_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+           gf_seek_what_t what, dict_t *xdata)
 {
-    ec_seek(frame, this, -1, EC_MINIMUM_ONE, default_seek_cbk, NULL, fd,
-            offset, what, xdata);
+    ec_seek(frame, this, -1, EC_MINIMUM_ONE, default_seek_cbk, NULL, fd, offset,
+            what, xdata);
 
     return 0;
 }
 
-int32_t ec_gf_ipc(call_frame_t *frame, xlator_t *this, int32_t op,
-                  dict_t *xdata)
+int32_t
+ec_gf_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
     ec_ipc(frame, this, -1, EC_MINIMUM_MIN, default_ipc_cbk, NULL, op, xdata);
     return 0;
 }
 
-int32_t ec_gf_forget(xlator_t * this, inode_t * inode)
+int32_t
+ec_gf_forget(xlator_t *this, inode_t *inode)
 {
     uint64_t value = 0;
-    ec_inode_t * ctx = NULL;
+    ec_inode_t *ctx = NULL;
 
-    if ((inode_ctx_del(inode, this, &value) == 0) && (value != 0))
-    {
+    if ((inode_ctx_del(inode, this, &value) == 0) && (value != 0)) {
         ctx = (ec_inode_t *)(uintptr_t)value;
         /* We can only forget an inode if it has been unlocked, so the stripe
          * cache should also be empty. */
@@ -1330,38 +1338,41 @@ int32_t ec_gf_forget(xlator_t * this, inode_t * inode)
     return 0;
 }
 
-void ec_gf_release_fd(xlator_t * this, fd_t * fd)
+void
+ec_gf_release_fd(xlator_t *this, fd_t *fd)
 {
     uint64_t value = 0;
-    ec_fd_t * ctx = NULL;
+    ec_fd_t *ctx = NULL;
 
-    if ((fd_ctx_del(fd, this, &value) == 0) && (value != 0))
-    {
+    if ((fd_ctx_del(fd, this, &value) == 0) && (value != 0)) {
         ctx = (ec_fd_t *)(uintptr_t)value;
         loc_wipe(&ctx->loc);
         GF_FREE(ctx);
     }
 }
 
-int32_t ec_gf_release(xlator_t * this, fd_t * fd)
+int32_t
+ec_gf_release(xlator_t *this, fd_t *fd)
 {
     ec_gf_release_fd(this, fd);
 
     return 0;
 }
 
-int32_t ec_gf_releasedir(xlator_t * this, fd_t * fd)
+int32_t
+ec_gf_releasedir(xlator_t *this, fd_t *fd)
 {
     ec_gf_release_fd(this, fd);
 
     return 0;
 }
 
-int32_t ec_dump_private(xlator_t *this)
+int32_t
+ec_dump_private(xlator_t *this)
 {
     ec_t *ec = NULL;
-    char  key_prefix[GF_DUMP_MAX_BUF_LEN];
-    char  tmp[65];
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    char tmp[65];
 
     GF_ASSERT(this);
 
@@ -1380,7 +1391,7 @@ int32_t ec_dump_private(xlator_t *this)
                        ec_bin(tmp, sizeof(tmp), ec->xl_up, ec->nodes));
     gf_proc_dump_write("background-heals", "%d", ec->background_heals);
     gf_proc_dump_write("heal-wait-qlength", "%d", ec->heal_wait_qlen);
-    gf_proc_dump_write("self-heal-window-size", "%"PRIu32,
+    gf_proc_dump_write("self-heal-window-size", "%" PRIu32,
                        ec->self_heal_window_size);
     gf_proc_dump_write("healers", "%d", ec->healers);
     gf_proc_dump_write("heal-waiters", "%d", ec->heal_waiters);
@@ -1409,77 +1420,66 @@ int32_t ec_dump_private(xlator_t *this)
     return 0;
 }
 
-struct xlator_fops fops =
-{
-    .lookup       = ec_gf_lookup,
-    .stat         = ec_gf_stat,
-    .fstat        = ec_gf_fstat,
-    .truncate     = ec_gf_truncate,
-    .ftruncate    = ec_gf_ftruncate,
-    .access       = ec_gf_access,
-    .readlink     = ec_gf_readlink,
-    .mknod        = ec_gf_mknod,
-    .mkdir        = ec_gf_mkdir,
-    .unlink       = ec_gf_unlink,
-    .rmdir        = ec_gf_rmdir,
-    .symlink      = ec_gf_symlink,
-    .rename       = ec_gf_rename,
-    .link         = ec_gf_link,
-    .create       = ec_gf_create,
-    .open         = ec_gf_open,
-    .readv        = ec_gf_readv,
-    .writev       = ec_gf_writev,
-    .flush        = ec_gf_flush,
-    .fsync        = ec_gf_fsync,
-    .opendir      = ec_gf_opendir,
-    .readdir      = ec_gf_readdir,
-    .readdirp     = ec_gf_readdirp,
-    .fsyncdir     = ec_gf_fsyncdir,
-    .statfs       = ec_gf_statfs,
-    .setxattr     = ec_gf_setxattr,
-    .getxattr     = ec_gf_getxattr,
-    .fsetxattr    = ec_gf_fsetxattr,
-    .fgetxattr    = ec_gf_fgetxattr,
-    .removexattr  = ec_gf_removexattr,
-    .fremovexattr = ec_gf_fremovexattr,
-    .lk           = ec_gf_lk,
-    .inodelk      = ec_gf_inodelk,
-    .finodelk     = ec_gf_finodelk,
-    .entrylk      = ec_gf_entrylk,
-    .fentrylk     = ec_gf_fentrylk,
-    .xattrop      = ec_gf_xattrop,
-    .fxattrop     = ec_gf_fxattrop,
-    .setattr      = ec_gf_setattr,
-    .fsetattr     = ec_gf_fsetattr,
-    .fallocate    = ec_gf_fallocate,
-    .discard      = ec_gf_discard,
-    .zerofill     = ec_gf_zerofill,
-    .seek         = ec_gf_seek,
-    .ipc          = ec_gf_ipc
-};
-
-struct xlator_cbks cbks =
-{
-    .forget            = ec_gf_forget,
-    .release           = ec_gf_release,
-    .releasedir        = ec_gf_releasedir
-};
-
-struct xlator_dumpops dumpops = {
-    .priv = ec_dump_private
-};
-
-struct volume_options options[] =
-{
-    {
-        .key = { "redundancy" },
-        .type = GF_OPTION_TYPE_INT,
-        .default_value = "{{ volume.redundancy }}",
-        .description = "Maximum number of bricks that can fail "
-                       "simultaneously without losing data."
-    },
+struct xlator_fops fops = {.lookup = ec_gf_lookup,
+                           .stat = ec_gf_stat,
+                           .fstat = ec_gf_fstat,
+                           .truncate = ec_gf_truncate,
+                           .ftruncate = ec_gf_ftruncate,
+                           .access = ec_gf_access,
+                           .readlink = ec_gf_readlink,
+                           .mknod = ec_gf_mknod,
+                           .mkdir = ec_gf_mkdir,
+                           .unlink = ec_gf_unlink,
+                           .rmdir = ec_gf_rmdir,
+                           .symlink = ec_gf_symlink,
+                           .rename = ec_gf_rename,
+                           .link = ec_gf_link,
+                           .create = ec_gf_create,
+                           .open = ec_gf_open,
+                           .readv = ec_gf_readv,
+                           .writev = ec_gf_writev,
+                           .flush = ec_gf_flush,
+                           .fsync = ec_gf_fsync,
+                           .opendir = ec_gf_opendir,
+                           .readdir = ec_gf_readdir,
+                           .readdirp = ec_gf_readdirp,
+                           .fsyncdir = ec_gf_fsyncdir,
+                           .statfs = ec_gf_statfs,
+                           .setxattr = ec_gf_setxattr,
+                           .getxattr = ec_gf_getxattr,
+                           .fsetxattr = ec_gf_fsetxattr,
+                           .fgetxattr = ec_gf_fgetxattr,
+                           .removexattr = ec_gf_removexattr,
+                           .fremovexattr = ec_gf_fremovexattr,
+                           .lk = ec_gf_lk,
+                           .inodelk = ec_gf_inodelk,
+                           .finodelk = ec_gf_finodelk,
+                           .entrylk = ec_gf_entrylk,
+                           .fentrylk = ec_gf_fentrylk,
+                           .xattrop = ec_gf_xattrop,
+                           .fxattrop = ec_gf_fxattrop,
+                           .setattr = ec_gf_setattr,
+                           .fsetattr = ec_gf_fsetattr,
+                           .fallocate = ec_gf_fallocate,
+                           .discard = ec_gf_discard,
+                           .zerofill = ec_gf_zerofill,
+                           .seek = ec_gf_seek,
+                           .ipc = ec_gf_ipc};
+
+struct xlator_cbks cbks = {.forget = ec_gf_forget,
+                           .release = ec_gf_release,
+                           .releasedir = ec_gf_releasedir};
+
+struct xlator_dumpops dumpops = {.priv = ec_dump_private};
+
+struct volume_options options[] = {
+    {.key = {"redundancy"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "{{ volume.redundancy }}",
+     .description = "Maximum number of bricks that can fail "
+                    "simultaneously without losing data."},
     {
-        .key = { "self-heal-daemon" },
+        .key = {"self-heal-daemon"},
         .type = GF_OPTION_TYPE_BOOL,
         .description = "self-heal daemon enable/disable",
         .default_value = "enable",
@@ -1487,193 +1487,183 @@ struct volume_options options[] =
         .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
         .tags = {"disperse"},
     },
-    { .key = {"iam-self-heal-daemon"},
-      .type = GF_OPTION_TYPE_BOOL,
-      .default_value = "off",
-      .description = "This option differentiates if the disperse "
-                     "translator is running as part of self-heal-daemon "
-                     "or not."
-    },
-    { .key = {"eager-lock"},
-      .type = GF_OPTION_TYPE_BOOL,
-      .default_value = "on",
-      .op_version = {GD_OP_VERSION_3_7_10},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "Enable/Disable eager lock for regular files on a "
-                     "disperse volume. If a fop takes a lock and completes "
-                     "its operation, it waits for next 1 second before "
-                     "releasing the lock, to see if the lock can be reused "
-                     "for next fop from the same client. If ec finds any lock "
-                     "contention within 1 second it releases the lock "
-                     "immediately before time expires. This improves the "
-                     "performance of file operations. However, as it takes "
-                     "lock on first brick, for few operations like read, "
-                     "discovery of lock contention might take long time and "
-                     "can actually degrade the performance. If eager lock is "
-                     "disabled, lock will be released as soon as fop "
-                     "completes."
-    },
-    { .key = {"other-eager-lock"},
-      .type = GF_OPTION_TYPE_BOOL,
-      .default_value = "on",
-      .op_version = { GD_OP_VERSION_3_13_0 },
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = { "disperse" },
-      .description = "It's equivalent to the eager-lock option but for non "
-                     "regular files."
-    },
-    { .key = {"eager-lock-timeout"},
-      .type = GF_OPTION_TYPE_INT,
-      .min = 1,
-      .max = 60,
-      .default_value = "1",
-      .op_version = { GD_OP_VERSION_4_0_0 },
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = { "disperse", "locks", "timeout" },
-      .description = "Maximum time (in seconds) that a lock on an inode is "
-                     "kept held if no new operations on the inode are "
-                     "received."
-    },
-    { .key = {"other-eager-lock-timeout"},
-      .type = GF_OPTION_TYPE_INT,
-      .min = 1,
-      .max = 60,
-      .default_value = "1",
-      .op_version = { GD_OP_VERSION_4_0_0 },
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = { "disperse", "locks", "timeout" },
-      .description = "It's equivalent to eager-lock-timeout option but for "
-                     "non regular files."
-    },
-    { .key = {"background-heals"},
-      .type = GF_OPTION_TYPE_INT,
-      .min = 0,/*Disabling background heals*/
-      .max = 256,
-      .default_value = "8",
-      .op_version = {GD_OP_VERSION_3_7_3},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "This option can be used to control number of parallel"
-                     " heals",
-    },
-    { .key = {"heal-wait-qlength"},
-      .type = GF_OPTION_TYPE_INT,
-      .min = 0,
-      .max = 65536, /*Around 100MB as of now with sizeof(ec_fop_data_t) at 1800*/
-      .default_value = "128",
-      .op_version = {GD_OP_VERSION_3_7_3},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "This option can be used to control number of heals"
-                     " that can wait",
-    },
-    { .key  = {"heal-timeout"},
-      .type = GF_OPTION_TYPE_INT,
-      .min  = 60,
-      .max  = INT_MAX,
-      .default_value = "600",
-      .op_version = {GD_OP_VERSION_3_7_3},
-      .flags = OPT_FLAG_SETTABLE,
-      .tags = {"disperse"},
-      .description = "time interval for checking the need to self-heal "
-                     "in self-heal-daemon"
-    },
-    { .key = {"read-policy" },
-      .type = GF_OPTION_TYPE_STR,
-      .value = {"round-robin", "gfid-hash"},
-      .default_value = "gfid-hash",
-      .op_version = {GD_OP_VERSION_3_7_6},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "inode-read fops happen only on 'k' number of bricks in"
-              " n=k+m disperse subvolume. 'round-robin' selects the read"
-              " subvolume using round-robin algo. 'gfid-hash' selects read"
-              " subvolume based on hash of the gfid of that file/directory.",
-    },
-    { .key   = {"shd-max-threads"},
-      .type  = GF_OPTION_TYPE_INT,
-      .min   = 1,
-      .max   = 64,
-      .default_value = "1",
-      .op_version = {GD_OP_VERSION_3_9_0},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "Maximum number of parallel heals SHD can do per local "
-                      "brick.  This can substantially lower heal times, "
-                      "but can also crush your bricks if you don't have "
-                      "the storage hardware to support this."
+    {.key = {"iam-self-heal-daemon"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "This option differentiates if the disperse "
+                    "translator is running as part of self-heal-daemon "
+                    "or not."},
+    {.key = {"eager-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {GD_OP_VERSION_3_7_10},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "Enable/Disable eager lock for regular files on a "
+                    "disperse volume. If a fop takes a lock and completes "
+                    "its operation, it waits for next 1 second before "
+                    "releasing the lock, to see if the lock can be reused "
+                    "for next fop from the same client. If ec finds any lock "
+                    "contention within 1 second it releases the lock "
+                    "immediately before time expires. This improves the "
+                    "performance of file operations. However, as it takes "
+                    "lock on first brick, for few operations like read, "
+                    "discovery of lock contention might take long time and "
+                    "can actually degrade the performance. If eager lock is "
+                    "disabled, lock will be released as soon as fop "
+                    "completes."},
+    {.key = {"other-eager-lock"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {GD_OP_VERSION_3_13_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "It's equivalent to the eager-lock option but for non "
+                    "regular files."},
+    {.key = {"eager-lock-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 60,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse", "locks", "timeout"},
+     .description = "Maximum time (in seconds) that a lock on an inode is "
+                    "kept held if no new operations on the inode are "
+                    "received."},
+    {.key = {"other-eager-lock-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 60,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_4_0_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse", "locks", "timeout"},
+     .description = "It's equivalent to eager-lock-timeout option but for "
+                    "non regular files."},
+    {
+        .key = {"background-heals"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 0, /*Disabling background heals*/
+        .max = 256,
+        .default_value = "8",
+        .op_version = {GD_OP_VERSION_3_7_3},
+        .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+        .tags = {"disperse"},
+        .description = "This option can be used to control number of parallel"
+                       " heals",
     },
-    { .key   = {"shd-wait-qlength"},
-      .type  = GF_OPTION_TYPE_INT,
-      .min   = 1,
-      .max   = 65536,
-      .default_value = "1024",
-      .op_version = {GD_OP_VERSION_3_9_0},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "This option can be used to control number of heals"
-                     " that can wait in SHD per subvolume"
+    {
+        .key = {"heal-wait-qlength"},
+        .type = GF_OPTION_TYPE_INT,
+        .min = 0,
+        .max =
+            65536, /*Around 100MB as of now with sizeof(ec_fop_data_t) at 1800*/
+        .default_value = "128",
+        .op_version = {GD_OP_VERSION_3_7_3},
+        .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+        .tags = {"disperse"},
+        .description = "This option can be used to control number of heals"
+                       " that can wait",
     },
+    {.key = {"heal-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 60,
+     .max = INT_MAX,
+     .default_value = "600",
+     .op_version = {GD_OP_VERSION_3_7_3},
+     .flags = OPT_FLAG_SETTABLE,
+     .tags = {"disperse"},
+     .description = "time interval for checking the need to self-heal "
+                    "in self-heal-daemon"},
     {
-        .key = { "cpu-extensions" },
+        .key = {"read-policy"},
         .type = GF_OPTION_TYPE_STR,
-        .value = { "none", "auto", "x64", "sse", "avx" },
-        .default_value = "auto",
-        .op_version = {GD_OP_VERSION_3_9_0},
+        .value = {"round-robin", "gfid-hash"},
+        .default_value = "gfid-hash",
+        .op_version = {GD_OP_VERSION_3_7_6},
         .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
         .tags = {"disperse"},
-        .description = "force the cpu extensions to be used to accelerate the "
-                       "galois field computations."
-    },
-    { .key  = {"self-heal-window-size"},
-      .type = GF_OPTION_TYPE_INT,
-      .min  = 1,
-      .max  = 1024,
-      .default_value = "1",
-      .op_version = {GD_OP_VERSION_3_11_0},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-      .tags = {"disperse"},
-      .description = "Maximum number blocks(128KB) per file for which "
-                     "self-heal process would be applied simultaneously."
-    },
-    { .key = {"optimistic-change-log"},
-      .type = GF_OPTION_TYPE_BOOL,
-      .default_value = "on",
-      .op_version = {GD_OP_VERSION_3_10_1},
-      .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT,
-      .tags = {"disperse"},
-      .description =  "Set/Unset dirty flag for every update fop at the start"
-                      "of the fop. If OFF, this option impacts performance of"
-                      "entry  operations or metadata operations as it will"
-                      "set dirty flag at the start and unset it at the end of"
-                      "ALL update fop. If ON and all the bricks are good,"
-                      "dirty flag will be set at the start only for file fops"
-                      "For metadata and entry fops dirty flag will not be set"
-                      "at the start, if all the bricks are good. This does"
-                      "not impact performance for metadata operations and"
-                      "entry operation but has a very small window to miss"
-                      "marking entry as dirty in case it is required to be"
-                      "healed"
-    },
-    { .key = {"parallel-writes"},
-      .type = GF_OPTION_TYPE_BOOL,
-      .default_value = "on",
-      .description = "This controls if writes can be wound in parallel as long"
-                     "as it doesn't modify same stripes"
-    },
-    {   .key = {"stripe-cache"},
-        .type = GF_OPTION_TYPE_INT,
-        .min = 0,/*Disabling stripe_cache*/
-        .max = EC_STRIPE_CACHE_MAX_SIZE,
-        .default_value = "4",
-        .description =  "This option will keep the last stripe of write fop"
-                        "in memory. If next write falls in this stripe, we need"
-                        "not to read it again from backend and we can save READ"
-                        "fop going over the network. This will improve performance,"
-                        "specially for sequential writes. However, this will also"
-                        "lead to extra memory consumption, maximum "
-                        "(cache size * stripe size) Bytes per open file."
+        .description =
+            "inode-read fops happen only on 'k' number of bricks in"
+            " n=k+m disperse subvolume. 'round-robin' selects the read"
+            " subvolume using round-robin algo. 'gfid-hash' selects read"
+            " subvolume based on hash of the gfid of that file/directory.",
     },
-    { .key = {NULL} }
-};
+    {.key = {"shd-max-threads"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 64,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_3_9_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "Maximum number of parallel heals SHD can do per local "
+                    "brick.  This can substantially lower heal times, "
+                    "but can also crush your bricks if you don't have "
+                    "the storage hardware to support this."},
+    {.key = {"shd-wait-qlength"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 65536,
+     .default_value = "1024",
+     .op_version = {GD_OP_VERSION_3_9_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "This option can be used to control number of heals"
+                    " that can wait in SHD per subvolume"},
+    {.key = {"cpu-extensions"},
+     .type = GF_OPTION_TYPE_STR,
+     .value = {"none", "auto", "x64", "sse", "avx"},
+     .default_value = "auto",
+     .op_version = {GD_OP_VERSION_3_9_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "force the cpu extensions to be used to accelerate the "
+                    "galois field computations."},
+    {.key = {"self-heal-window-size"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 1024,
+     .default_value = "1",
+     .op_version = {GD_OP_VERSION_3_11_0},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+     .tags = {"disperse"},
+     .description = "Maximum number blocks(128KB) per file for which "
+                    "self-heal process would be applied simultaneously."},
+    {.key = {"optimistic-change-log"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .op_version = {GD_OP_VERSION_3_10_1},
+     .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT,
+     .tags = {"disperse"},
+     .description = "Set/Unset dirty flag for every update fop at the start"
+                    "of the fop. If OFF, this option impacts performance of"
+                    "entry  operations or metadata operations as it will"
+                    "set dirty flag at the start and unset it at the end of"
+                    "ALL update fop. If ON and all the bricks are good,"
+                    "dirty flag will be set at the start only for file fops"
+                    "For metadata and entry fops dirty flag will not be set"
+                    "at the start, if all the bricks are good. This does"
+                    "not impact performance for metadata operations and"
+                    "entry operation but has a very small window to miss"
+                    "marking entry as dirty in case it is required to be"
+                    "healed"},
+    {.key = {"parallel-writes"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "This controls if writes can be wound in parallel as long"
+                    "as it doesn't modify same stripes"},
+    {.key = {"stripe-cache"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0, /*Disabling stripe_cache*/
+     .max = EC_STRIPE_CACHE_MAX_SIZE,
+     .default_value = "4",
+     .description = "This option will keep the last stripe of write fop"
+                    "in memory. If next write falls in this stripe, we need"
+                    "not to read it again from backend and we can save READ"
+                    "fop going over the network. This will improve performance,"
+                    "specially for sequential writes. However, this will also"
+                    "lead to extra memory consumption, maximum "
+                    "(cache size * stripe size) Bytes per open file."},
+    {.key = {NULL}}};
diff --git a/xlators/cluster/stripe/src/stripe-helpers.c b/xlators/cluster/stripe/src/stripe-helpers.c
index 59dfdfad979..7301494415d 100644
--- a/xlators/cluster/stripe/src/stripe-helpers.c
+++ b/xlators/cluster/stripe/src/stripe-helpers.c
@@ -16,664 +16,643 @@
 #include "logging.h"
 
 void
-stripe_local_wipe (stripe_local_t *local)
+stripe_local_wipe(stripe_local_t *local)
 {
-        if (!local)
-                goto out;
+    if (!local)
+        goto out;
 
-        loc_wipe (&local->loc);
-        loc_wipe (&local->loc2);
+    loc_wipe(&local->loc);
+    loc_wipe(&local->loc2);
 
-        if (local->fd)
-                fd_unref (local->fd);
+    if (local->fd)
+        fd_unref(local->fd);
 
-        if (local->inode)
-                inode_unref (local->inode);
+    if (local->inode)
+        inode_unref(local->inode);
 
-        if (local->xattr)
-                dict_unref (local->xattr);
+    if (local->xattr)
+        dict_unref(local->xattr);
 
-        if (local->xdata)
-                dict_unref (local->xdata);
+    if (local->xdata)
+        dict_unref(local->xdata);
 
 out:
-        return;
+    return;
 }
 
-
-
 int
-stripe_aggregate (dict_t *this, char *key, data_t *value, void *data)
+stripe_aggregate(dict_t *this, char *key, data_t *value, void *data)
 {
-        dict_t  *dst  = NULL;
-        int64_t *ptr  = 0, *size = NULL;
-        int32_t  ret  = -1;
-
-        dst = data;
-
-        if (strcmp (key, QUOTA_SIZE_KEY) == 0) {
-                ret = dict_get_bin (dst, key, (void **)&size);
-                if (ret < 0) {
-                        size = GF_CALLOC (1, sizeof (int64_t),
-                                          gf_common_mt_char);
-                        if (size == NULL) {
-                                gf_log ("stripe", GF_LOG_WARNING,
-                                        "memory allocation failed");
-                                goto out;
-                        }
-                        ret = dict_set_bin (dst, key, size, sizeof (int64_t));
-                        if (ret < 0) {
-                                gf_log ("stripe", GF_LOG_WARNING,
-                                        "stripe aggregate dict set failed");
-                                GF_FREE (size);
-                                goto out;
-                        }
-                }
-
-                ptr = data_to_bin (value);
-                if (ptr == NULL) {
-                        gf_log ("stripe", GF_LOG_WARNING, "data to bin failed");
-                        goto out;
-                }
-
-                *size = hton64 (ntoh64 (*size) + ntoh64 (*ptr));
-        } else if (strcmp (key, GF_CONTENT_KEY)) {
-                /* No need to aggregate 'CONTENT' data */
-                ret = dict_set (dst, key, value);
-                if (ret)
-                        gf_log ("stripe", GF_LOG_WARNING, "xattr dict set failed");
+    dict_t *dst = NULL;
+    int64_t *ptr = 0, *size = NULL;
+    int32_t ret = -1;
+
+    dst = data;
+
+    if (strcmp(key, QUOTA_SIZE_KEY) == 0) {
+        ret = dict_get_bin(dst, key, (void **)&size);
+        if (ret < 0) {
+            size = GF_CALLOC(1, sizeof(int64_t), gf_common_mt_char);
+            if (size == NULL) {
+                gf_log("stripe", GF_LOG_WARNING, "memory allocation failed");
+                goto out;
+            }
+            ret = dict_set_bin(dst, key, size, sizeof(int64_t));
+            if (ret < 0) {
+                gf_log("stripe", GF_LOG_WARNING,
+                       "stripe aggregate dict set failed");
+                GF_FREE(size);
+                goto out;
+            }
         }
 
+        ptr = data_to_bin(value);
+        if (ptr == NULL) {
+            gf_log("stripe", GF_LOG_WARNING, "data to bin failed");
+            goto out;
+        }
+
+        *size = hton64(ntoh64(*size) + ntoh64(*ptr));
+    } else if (strcmp(key, GF_CONTENT_KEY)) {
+        /* No need to aggregate 'CONTENT' data */
+        ret = dict_set(dst, key, value);
+        if (ret)
+            gf_log("stripe", GF_LOG_WARNING, "xattr dict set failed");
+    }
+
 out:
-        return 0;
+    return 0;
 }
 
-
 void
-stripe_aggregate_xattr (dict_t *dst, dict_t *src)
+stripe_aggregate_xattr(dict_t *dst, dict_t *src)
 {
-        if ((dst == NULL) || (src == NULL)) {
-                goto out;
-        }
+    if ((dst == NULL) || (src == NULL)) {
+        goto out;
+    }
 
-        dict_foreach (src, stripe_aggregate, dst);
+    dict_foreach(src, stripe_aggregate, dst);
 out:
-        return;
+    return;
 }
 
-
 int32_t
-stripe_xattr_aggregate (char *buffer, stripe_local_t *local, int32_t *total)
+stripe_xattr_aggregate(char *buffer, stripe_local_t *local, int32_t *total)
 {
-        int32_t              i     = 0;
-        int32_t              ret   = -1;
-        int32_t              len   = 0;
-        char                *sbuf  = NULL;
-        stripe_xattr_sort_t *xattr = NULL;
+    int32_t i = 0;
+    int32_t ret = -1;
+    int32_t len = 0;
+    char *sbuf = NULL;
+    stripe_xattr_sort_t *xattr = NULL;
 
-        if (!buffer || !local || !local->xattr_list)
-                goto out;
+    if (!buffer || !local || !local->xattr_list)
+        goto out;
 
-        sbuf = buffer;
+    sbuf = buffer;
 
-        for (i = 0; i < local->nallocs; i++) {
-                xattr = local->xattr_list + i;
-                len = xattr->xattr_len - 1; /* length includes \0 */
+    for (i = 0; i < local->nallocs; i++) {
+        xattr = local->xattr_list + i;
+        len = xattr->xattr_len - 1; /* length includes \0 */
 
-                if (len && xattr && xattr->xattr_value) {
-                        memcpy (buffer, xattr->xattr_value, len);
-                        buffer += len;
-                        *buffer++ = ' ';
-                }
+        if (len && xattr && xattr->xattr_value) {
+            memcpy(buffer, xattr->xattr_value, len);
+            buffer += len;
+            *buffer++ = ' ';
         }
+    }
 
-        *--buffer = '\0';
-        if (total)
-                *total = buffer - sbuf;
-        ret = 0;
+    *--buffer = '\0';
+    if (total)
+        *total = buffer - sbuf;
+    ret = 0;
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 int32_t
-stripe_free_xattr_str (stripe_local_t *local)
+stripe_free_xattr_str(stripe_local_t *local)
 {
-        int32_t              i     = 0;
-        int32_t              ret   = -1;
-        stripe_xattr_sort_t *xattr = NULL;
+    int32_t i = 0;
+    int32_t ret = -1;
+    stripe_xattr_sort_t *xattr = NULL;
 
-        if (!local || !local->xattr_list)
-                goto out;
+    if (!local || !local->xattr_list)
+        goto out;
 
-        for (i = 0; i < local->nallocs; i++) {
-                xattr = local->xattr_list + i;
+    for (i = 0; i < local->nallocs; i++) {
+        xattr = local->xattr_list + i;
 
-                if (xattr && xattr->xattr_value)
-                        GF_FREE (xattr->xattr_value);
-        }
+        if (xattr && xattr->xattr_value)
+            GF_FREE(xattr->xattr_value);
+    }
 
-        ret = 0;
- out:
-        return ret;
+    ret = 0;
+out:
+    return ret;
 }
 
-
 int32_t
-stripe_fill_lockinfo_xattr (xlator_t *this, stripe_local_t *local,
-                            void **xattr_serz)
+stripe_fill_lockinfo_xattr(xlator_t *this, stripe_local_t *local,
+                           void **xattr_serz)
 {
-        int32_t              ret   = -1, i = 0, len = 0;
-        dict_t              *tmp1  = NULL, *tmp2 = NULL;
-        char                *buf   = NULL;
-        stripe_xattr_sort_t *xattr = NULL;
-
-        if (xattr_serz == NULL) {
+    int32_t ret = -1, i = 0, len = 0;
+    dict_t *tmp1 = NULL, *tmp2 = NULL;
+    char *buf = NULL;
+    stripe_xattr_sort_t *xattr = NULL;
+
+    if (xattr_serz == NULL) {
+        goto out;
+    }
+
+    tmp2 = dict_new();
+
+    if (tmp2 == NULL) {
+        goto out;
+    }
+
+    for (i = 0; i < local->nallocs; i++) {
+        xattr = local->xattr_list + i;
+        len = xattr->xattr_len;
+
+        if (len && xattr && xattr->xattr_value) {
+            ret = dict_reset(tmp2);
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_DEBUG, "dict_reset failed (%s)",
+                       strerror(-ret));
+            }
+
+            ret = dict_unserialize(xattr->xattr_value, xattr->xattr_len, &tmp2);
+            if (ret < 0) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "dict_unserialize failed (%s)", strerror(-ret));
+                ret = -1;
                 goto out;
-        }
-
-        tmp2 = dict_new ();
+            }
 
-        if (tmp2 == NULL) {
+            tmp1 = dict_copy(tmp2, tmp1);
+            if (tmp1 == NULL) {
+                gf_log(this->name, GF_LOG_WARNING, "dict_copy failed (%s)",
+                       strerror(-ret));
+                ret = -1;
                 goto out;
+            }
         }
-
-        for (i = 0; i < local->nallocs; i++) {
-                xattr = local->xattr_list + i;
-                len = xattr->xattr_len;
-
-                if (len && xattr && xattr->xattr_value) {
-                        ret = dict_reset (tmp2);
-                        if (ret < 0) {
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "dict_reset failed (%s)",
-                                        strerror (-ret));
-                        }
-
-                        ret = dict_unserialize (xattr->xattr_value,
-                                                xattr->xattr_len,
-                                                &tmp2);
-                        if (ret < 0) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "dict_unserialize failed (%s)",
-                                        strerror (-ret));
-                                ret = -1;
-                                goto out;
-                        }
-
-                        tmp1 = dict_copy (tmp2, tmp1);
-                        if (tmp1 == NULL) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "dict_copy failed (%s)",
-                                        strerror (-ret));
-                                ret = -1;
-                                goto out;
-                        }
-                }
+    }
+
+    len = dict_serialized_length(tmp1);
+    if (len > 0) {
+        buf = GF_CALLOC(1, len, gf_common_mt_dict_t);
+        if (buf == NULL) {
+            ret = -1;
+            goto out;
         }
 
-        len = dict_serialized_length (tmp1);
-        if (len > 0) {
-                buf = GF_CALLOC (1, len, gf_common_mt_dict_t);
-                if (buf == NULL) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = dict_serialize (tmp1, buf);
-                if (ret < 0) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "dict_serialize failed (%s)", strerror (-ret));
-                        GF_FREE(buf);
-                        ret = -1;
-                        goto out;
-                }
-
-                *xattr_serz = buf;
+        ret = dict_serialize(tmp1, buf);
+        if (ret < 0) {
+            gf_log(this->name, GF_LOG_WARNING, "dict_serialize failed (%s)",
+                   strerror(-ret));
+            GF_FREE(buf);
+            ret = -1;
+            goto out;
         }
 
-        ret = 0;
+        *xattr_serz = buf;
+    }
+
+    ret = 0;
 out:
-        if (tmp1 != NULL) {
-                dict_unref (tmp1);
-        }
+    if (tmp1 != NULL) {
+        dict_unref(tmp1);
+    }
 
-        if (tmp2 != NULL) {
-                dict_unref (tmp2);
-        }
+    if (tmp2 != NULL) {
+        dict_unref(tmp2);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-stripe_fill_pathinfo_xattr (xlator_t *this, stripe_local_t *local,
-                            char **xattr_serz)
+stripe_fill_pathinfo_xattr(xlator_t *this, stripe_local_t *local,
+                           char **xattr_serz)
 {
-        int      ret             = -1;
-        int32_t  padding         = 0;
-        int32_t  tlen            = 0;
-        int      len             = 0;
-        char stripe_size_str[20] = {0,};
-        char    *pathinfo_serz   = NULL;
-
-        if (!local) {
-                gf_log (this->name, GF_LOG_ERROR, "Possible NULL deref");
-                goto out;
-        }
-
-        len = snprintf (stripe_size_str, sizeof (stripe_size_str), "%"PRId64,
-                         (long long) (local->fctx) ? local->fctx->stripe_size : 0);
-        if (len < 0 || len >= sizeof (stripe_size_str))
-                goto out;
-        /* extra bytes for decorations (brackets and <>'s) */
-        padding = strlen (this->name) + SLEN (STRIPE_PATHINFO_HEADER)
-                  + len + 7;
-        local->xattr_total_len += (padding + 2);
-
-        pathinfo_serz = GF_MALLOC (local->xattr_total_len,
-                                   gf_common_mt_char);
-        if (!pathinfo_serz)
-                goto out;
-
-        /* xlator info */
-        (void) sprintf (pathinfo_serz, "(<"STRIPE_PATHINFO_HEADER"%s:[%s]> ",
-                        this->name, stripe_size_str);
-
-        ret = stripe_xattr_aggregate (pathinfo_serz + padding, local, &tlen);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Cannot aggregate pathinfo list");
-                GF_FREE(pathinfo_serz);
-                goto out;
-        }
-
-        *(pathinfo_serz + padding + tlen) = ')';
-        *(pathinfo_serz + padding + tlen + 1) = '\0';
-
-        *xattr_serz = pathinfo_serz;
-
-        ret = 0;
- out:
-        return ret;
+    int ret = -1;
+    int32_t padding = 0;
+    int32_t tlen = 0;
+    int len = 0;
+    char stripe_size_str[20] = {
+        0,
+    };
+    char *pathinfo_serz = NULL;
+
+    if (!local) {
+        gf_log(this->name, GF_LOG_ERROR, "Possible NULL deref");
+        goto out;
+    }
+
+    len = snprintf(stripe_size_str, sizeof(stripe_size_str), "%" PRId64,
+                   (long long)(local->fctx) ? local->fctx->stripe_size : 0);
+    if (len < 0 || len >= sizeof(stripe_size_str))
+        goto out;
+    /* extra bytes for decorations (brackets and <>'s) */
+    padding = strlen(this->name) + SLEN(STRIPE_PATHINFO_HEADER) + len + 7;
+    local->xattr_total_len += (padding + 2);
+
+    pathinfo_serz = GF_MALLOC(local->xattr_total_len, gf_common_mt_char);
+    if (!pathinfo_serz)
+        goto out;
+
+    /* xlator info */
+    (void)sprintf(pathinfo_serz, "(<" STRIPE_PATHINFO_HEADER "%s:[%s]> ",
+                  this->name, stripe_size_str);
+
+    ret = stripe_xattr_aggregate(pathinfo_serz + padding, local, &tlen);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR, "Cannot aggregate pathinfo list");
+        GF_FREE(pathinfo_serz);
+        goto out;
+    }
+
+    *(pathinfo_serz + padding + tlen) = ')';
+    *(pathinfo_serz + padding + tlen + 1) = '\0';
+
+    *xattr_serz = pathinfo_serz;
+
+    ret = 0;
+out:
+    return ret;
 }
 
 /**
  * stripe_get_matching_bs - Get the matching block size for the given path.
  */
 int32_t
-stripe_get_matching_bs (const char *path, stripe_private_t *priv)
+stripe_get_matching_bs(const char *path, stripe_private_t *priv)
 {
-        struct stripe_options *trav       = NULL;
-        uint64_t               block_size = 0;
-
-        GF_VALIDATE_OR_GOTO ("stripe", priv, out);
-        GF_VALIDATE_OR_GOTO ("stripe", path, out);
-
-        LOCK (&priv->lock);
-        {
-                block_size = priv->block_size;
-                trav = priv->pattern;
-                while (trav) {
-                        if (!fnmatch (trav->path_pattern, path, FNM_NOESCAPE)) {
-                                block_size = trav->block_size;
-                                break;
-                        }
-                        trav = trav->next;
-                }
+    struct stripe_options *trav = NULL;
+    uint64_t block_size = 0;
+
+    GF_VALIDATE_OR_GOTO("stripe", priv, out);
+    GF_VALIDATE_OR_GOTO("stripe", path, out);
+
+    LOCK(&priv->lock);
+    {
+        block_size = priv->block_size;
+        trav = priv->pattern;
+        while (trav) {
+            if (!fnmatch(trav->path_pattern, path, FNM_NOESCAPE)) {
+                block_size = trav->block_size;
+                break;
+            }
+            trav = trav->next;
         }
-        UNLOCK (&priv->lock);
+    }
+    UNLOCK(&priv->lock);
 
 out:
-        return block_size;
+    return block_size;
 }
 
 int32_t
-stripe_ctx_handle (xlator_t *this, call_frame_t *prev, stripe_local_t *local,
-                   dict_t *dict)
+stripe_ctx_handle(xlator_t *this, call_frame_t *prev, stripe_local_t *local,
+                  dict_t *dict)
 {
-        char            key[256]       = {0,};
-        data_t         *data            = NULL;
-        int32_t         index           = 0;
-        stripe_private_t *priv          = NULL;
-
-        priv = this->private;
-
-
+    char key[256] = {
+        0,
+    };
+    data_t *data = NULL;
+    int32_t index = 0;
+    stripe_private_t *priv = NULL;
+
+    priv = this->private;
+
+    if (!local->fctx) {
+        local->fctx = GF_CALLOC(1, sizeof(stripe_fd_ctx_t),
+                                gf_stripe_mt_stripe_fd_ctx_t);
         if (!local->fctx) {
-                local->fctx =  GF_CALLOC (1, sizeof (stripe_fd_ctx_t),
-                                         gf_stripe_mt_stripe_fd_ctx_t);
-                if (!local->fctx) {
-                        local->op_errno = ENOMEM;
-                        local->op_ret = -1;
-                        goto out;
-                }
-
-                local->fctx->static_array = 0;
+            local->op_errno = ENOMEM;
+            local->op_ret = -1;
+            goto out;
         }
-        /* Stripe block size */
-        sprintf (key, "trusted.%s.stripe-size", this->name);
-        data = dict_get (dict, key);
-        if (!data) {
-                local->xattr_self_heal_needed = 1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to get stripe-size");
-                goto out;
-        } else {
-                if (!local->fctx->stripe_size) {
-                        local->fctx->stripe_size =
-                                     data_to_int64 (data);
-                }
-
-                if (local->fctx->stripe_size != data_to_int64 (data)) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "stripe-size mismatch in blocks");
-                        local->xattr_self_heal_needed = 1;
-                }
-        }
-
-        /* Stripe count */
-        sprintf (key, "trusted.%s.stripe-count", this->name);
-        data = dict_get (dict, key);
 
-        if (!data) {
-                local->xattr_self_heal_needed = 1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to get stripe-count");
-                goto out;
-        }
-        if (!local->fctx->xl_array) {
-                local->fctx->stripe_count = data_to_int32 (data);
-                if (!local->fctx->stripe_count) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "error with stripe-count xattr");
-                        local->op_ret   = -1;
-                        local->op_errno = EIO;
-                        goto out;
-                }
-
-                local->fctx->xl_array = GF_CALLOC (local->fctx->stripe_count,
-                                                   sizeof (xlator_t *),
-                                                   gf_stripe_mt_xlator_t);
-
-                if (!local->fctx->xl_array) {
-                        local->op_errno = ENOMEM;
-                        local->op_ret   = -1;
-                        goto out;
-                }
-        }
-        if (local->fctx->stripe_count != data_to_int32 (data)) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "error with stripe-count xattr (%d != %d)",
-                        local->fctx->stripe_count, data_to_int32 (data));
-                local->op_ret   = -1;
-                local->op_errno = EIO;
-                goto out;
+        local->fctx->static_array = 0;
+    }
+    /* Stripe block size */
+    sprintf(key, "trusted.%s.stripe-size", this->name);
+    data = dict_get(dict, key);
+    if (!data) {
+        local->xattr_self_heal_needed = 1;
+        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-size");
+        goto out;
+    } else {
+        if (!local->fctx->stripe_size) {
+            local->fctx->stripe_size = data_to_int64(data);
         }
 
-        /* index */
-        sprintf (key, "trusted.%s.stripe-index", this->name);
-        data = dict_get (dict, key);
-        if (!data) {
-                local->xattr_self_heal_needed = 1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to get stripe-index");
-                goto out;
-        }
-        index = data_to_int32 (data);
-        if (index > priv->child_count) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "error with stripe-index xattr (%d)", index);
-                local->op_ret   = -1;
-                local->op_errno = EIO;
-                goto out;
+        if (local->fctx->stripe_size != data_to_int64(data)) {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "stripe-size mismatch in blocks");
+            local->xattr_self_heal_needed = 1;
         }
-        if (local->fctx->xl_array) {
-                if (!local->fctx->xl_array[index])
-                        local->fctx->xl_array[index] = prev->this;
+    }
+
+    /* Stripe count */
+    sprintf(key, "trusted.%s.stripe-count", this->name);
+    data = dict_get(dict, key);
+
+    if (!data) {
+        local->xattr_self_heal_needed = 1;
+        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-count");
+        goto out;
+    }
+    if (!local->fctx->xl_array) {
+        local->fctx->stripe_count = data_to_int32(data);
+        if (!local->fctx->stripe_count) {
+            gf_log(this->name, GF_LOG_ERROR, "error with stripe-count xattr");
+            local->op_ret = -1;
+            local->op_errno = EIO;
+            goto out;
         }
 
-	sprintf(key, "trusted.%s.stripe-coalesce", this->name);
-	data = dict_get(dict, key);
-	if (!data) {
-		/*
-		 * The file was probably created prior to coalesce support.
-		 * Assume non-coalesce mode for this file to maintain backwards
-		 * compatibility.
-		 */
-		gf_log(this->name, GF_LOG_DEBUG, "missing stripe-coalesce "
-			"attr, assume non-coalesce mode");
-		local->fctx->stripe_coalesce = 0;
-	} else {
-		local->fctx->stripe_coalesce = data_to_int32(data);
-	}
+        local->fctx->xl_array = GF_CALLOC(local->fctx->stripe_count,
+                                          sizeof(xlator_t *),
+                                          gf_stripe_mt_xlator_t);
 
+        if (!local->fctx->xl_array) {
+            local->op_errno = ENOMEM;
+            local->op_ret = -1;
+            goto out;
+        }
+    }
+    if (local->fctx->stripe_count != data_to_int32(data)) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "error with stripe-count xattr (%d != %d)",
+               local->fctx->stripe_count, data_to_int32(data));
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        goto out;
+    }
+
+    /* index */
+    sprintf(key, "trusted.%s.stripe-index", this->name);
+    data = dict_get(dict, key);
+    if (!data) {
+        local->xattr_self_heal_needed = 1;
+        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-index");
+        goto out;
+    }
+    index = data_to_int32(data);
+    if (index > priv->child_count) {
+        gf_log(this->name, GF_LOG_ERROR, "error with stripe-index xattr (%d)",
+               index);
+        local->op_ret = -1;
+        local->op_errno = EIO;
+        goto out;
+    }
+    if (local->fctx->xl_array) {
+        if (!local->fctx->xl_array[index])
+            local->fctx->xl_array[index] = prev->this;
+    }
+
+    sprintf(key, "trusted.%s.stripe-coalesce", this->name);
+    data = dict_get(dict, key);
+    if (!data) {
+        /*
+         * The file was probably created prior to coalesce support.
+         * Assume non-coalesce mode for this file to maintain backwards
+         * compatibility.
+         */
+        gf_log(this->name, GF_LOG_DEBUG,
+               "missing stripe-coalesce "
+               "attr, assume non-coalesce mode");
+        local->fctx->stripe_coalesce = 0;
+    } else {
+        local->fctx->stripe_coalesce = data_to_int32(data);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_xattr_request_build (xlator_t *this, dict_t *dict, uint64_t stripe_size,
-                            uint32_t stripe_count, uint32_t stripe_index,
-			    uint32_t stripe_coalesce)
+stripe_xattr_request_build(xlator_t *this, dict_t *dict, uint64_t stripe_size,
+                           uint32_t stripe_count, uint32_t stripe_index,
+                           uint32_t stripe_coalesce)
 {
-        char            key[256]       = {0,};
-        int32_t         ret             = -1;
-
-        sprintf (key, "trusted.%s.stripe-size", this->name);
-        ret = dict_set_int64 (dict, key, stripe_size);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set %s in xattr_req dict", key);
-                goto out;
-        }
-
-        sprintf (key, "trusted.%s.stripe-count", this->name);
-        ret = dict_set_int32 (dict, key, stripe_count);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set %s in xattr_req dict", key);
-                goto out;
-        }
-
-        sprintf (key, "trusted.%s.stripe-index", this->name);
-        ret = dict_set_int32 (dict, key, stripe_index);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "failed to set %s in xattr_req dict", key);
-                goto out;
-        }
-
-	sprintf(key, "trusted.%s.stripe-coalesce", this->name);
-	ret = dict_set_int32(dict, key, stripe_coalesce);
-	if (ret) {
-		gf_log(this->name, GF_LOG_WARNING,
-			"failed to set %s in xattr_req_dict", key);
-		goto out;
-	}
+    char key[256] = {
+        0,
+    };
+    int32_t ret = -1;
+
+    sprintf(key, "trusted.%s.stripe-size", this->name);
+    ret = dict_set_int64(dict, key, stripe_size);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
+               key);
+        goto out;
+    }
+
+    sprintf(key, "trusted.%s.stripe-count", this->name);
+    ret = dict_set_int32(dict, key, stripe_count);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
+               key);
+        goto out;
+    }
+
+    sprintf(key, "trusted.%s.stripe-index", this->name);
+    ret = dict_set_int32(dict, key, stripe_index);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
+               key);
+        goto out;
+    }
+
+    sprintf(key, "trusted.%s.stripe-coalesce", this->name);
+    ret = dict_set_int32(dict, key, stripe_coalesce);
+    if (ret) {
+        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req_dict",
+               key);
+        goto out;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-set_default_block_size (stripe_private_t *priv, char *num)
+set_default_block_size(stripe_private_t *priv, char *num)
 {
+    int ret = -1;
+    GF_VALIDATE_OR_GOTO("stripe", THIS, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, priv, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, num, out);
+
+    if (gf_string2bytesize_uint64(num, &priv->block_size) != 0) {
+        gf_log(THIS->name, GF_LOG_ERROR, "invalid number format \"%s\"", num);
+        goto out;
+    }
 
-        int             ret = -1;
-        GF_VALIDATE_OR_GOTO ("stripe", THIS, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, priv, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, num, out);
+    ret = 0;
 
+out:
+    return ret;
+}
 
-        if (gf_string2bytesize_uint64 (num, &priv->block_size) != 0) {
-                gf_log (THIS->name, GF_LOG_ERROR,
-                        "invalid number format \"%s\"", num);
+int
+set_stripe_block_size(xlator_t *this, stripe_private_t *priv, char *data)
+{
+    int ret = -1;
+    char *tmp_str = NULL;
+    char *tmp_str1 = NULL;
+    char *dup_str = NULL;
+    char *stripe_str = NULL;
+    char *pattern = NULL;
+    char *num = NULL;
+    struct stripe_options *temp_stripeopt = NULL;
+    struct stripe_options *stripe_opt = NULL;
+
+    if (!this || !priv || !data)
+        goto out;
+
+    /* Get the pattern for striping.
+       "option block-size *avi:10MB" etc */
+    stripe_str = strtok_r(data, ",", &tmp_str);
+    while (stripe_str) {
+        dup_str = gf_strdup(stripe_str);
+        stripe_opt = GF_CALLOC(1, sizeof(struct stripe_options),
+                               gf_stripe_mt_stripe_options);
+        if (!stripe_opt) {
+            goto out;
+        }
+
+        pattern = strtok_r(dup_str, ":", &tmp_str1);
+        num = strtok_r(NULL, ":", &tmp_str1);
+        if (!num) {
+            num = pattern;
+            pattern = "*";
+            ret = set_default_block_size(priv, num);
+            if (ret)
                 goto out;
         }
+        if (gf_string2bytesize_uint64(num, &stripe_opt->block_size) != 0) {
+            gf_log(this->name, GF_LOG_ERROR, "invalid number format \"%s\"",
+                   num);
+            goto out;
+        }
 
-        ret = 0;
+        if (stripe_opt->block_size < STRIPE_MIN_BLOCK_SIZE) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Invalid Block-size: "
+                   "%s. Should be at least %llu bytes",
+                   num, STRIPE_MIN_BLOCK_SIZE);
+            goto out;
+        }
+        if (stripe_opt->block_size % 512) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Block-size: %s should"
+                   " be a multiple of 512 bytes",
+                   num);
+            goto out;
+        }
 
- out:
-        return ret;
+        memcpy(stripe_opt->path_pattern, pattern, strlen(pattern));
 
-}
+        gf_log(this->name, GF_LOG_DEBUG,
+               "block-size : pattern %s : size %" PRId64,
+               stripe_opt->path_pattern, stripe_opt->block_size);
 
+        if (priv->pattern)
+            temp_stripeopt = NULL;
+        else
+            temp_stripeopt = priv->pattern;
 
-int
-set_stripe_block_size (xlator_t *this, stripe_private_t *priv, char *data)
-{
-        int                    ret = -1;
-        char                  *tmp_str = NULL;
-        char                  *tmp_str1 = NULL;
-        char                  *dup_str = NULL;
-        char                  *stripe_str = NULL;
-        char                  *pattern = NULL;
-        char                  *num = NULL;
-        struct stripe_options *temp_stripeopt = NULL;
-        struct stripe_options *stripe_opt = NULL;
-
-        if (!this || !priv || !data)
-                goto out;
+        stripe_opt->next = temp_stripeopt;
 
-        /* Get the pattern for striping.
-           "option block-size *avi:10MB" etc */
-        stripe_str = strtok_r (data, ",", &tmp_str);
-        while (stripe_str) {
-                dup_str = gf_strdup (stripe_str);
-                stripe_opt = GF_CALLOC (1, sizeof (struct stripe_options),
-                                        gf_stripe_mt_stripe_options);
-                if (!stripe_opt) {
-                        goto out;
-                }
-
-                pattern = strtok_r (dup_str, ":", &tmp_str1);
-                num = strtok_r (NULL, ":", &tmp_str1);
-                if (!num) {
-                        num = pattern;
-                        pattern = "*";
-                        ret = set_default_block_size (priv, num);
-                        if (ret)
-                                goto out;
-                }
-                if (gf_string2bytesize_uint64 (num, &stripe_opt->block_size) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "invalid number format \"%s\"", num);
-                        goto out;
-                }
-
-                if (stripe_opt->block_size < STRIPE_MIN_BLOCK_SIZE) {
-                        gf_log (this->name, GF_LOG_ERROR, "Invalid Block-size: "
-                                "%s. Should be at least %llu bytes", num,
-                                STRIPE_MIN_BLOCK_SIZE);
-                        goto out;
-                }
-                if (stripe_opt->block_size % 512) {
-                        gf_log (this->name, GF_LOG_ERROR, "Block-size: %s should"
-                                " be a multiple of 512 bytes", num);
-                        goto out;
-                }
-
-                memcpy (stripe_opt->path_pattern, pattern, strlen (pattern));
-
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "block-size : pattern %s : size %"PRId64,
-                        stripe_opt->path_pattern, stripe_opt->block_size);
-
-                if (priv->pattern)
-                        temp_stripeopt = NULL;
-                else
-                        temp_stripeopt = priv->pattern;
-
-                stripe_opt->next = temp_stripeopt;
-
-                priv->pattern = stripe_opt;
-                stripe_opt = NULL;
-
-                GF_FREE (dup_str);
-                dup_str = NULL;
-
-                stripe_str = strtok_r (NULL, ",", &tmp_str);
-        }
+        priv->pattern = stripe_opt;
+        stripe_opt = NULL;
+
+        GF_FREE(dup_str);
+        dup_str = NULL;
+
+        stripe_str = strtok_r(NULL, ",", &tmp_str);
+    }
 
-        ret = 0;
+    ret = 0;
 out:
 
-        GF_FREE (dup_str);
+    GF_FREE(dup_str);
 
-        GF_FREE (stripe_opt);
+    GF_FREE(stripe_opt);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-stripe_iatt_merge (struct iatt *from, struct iatt *to)
+stripe_iatt_merge(struct iatt *from, struct iatt *to)
 {
-        if (to->ia_size < from->ia_size)
-                to->ia_size = from->ia_size;
-        if (to->ia_mtime < from->ia_mtime)
-                to->ia_mtime = from->ia_mtime;
-        if (to->ia_ctime < from->ia_ctime)
-                to->ia_ctime = from->ia_ctime;
-        if (to->ia_atime < from->ia_atime)
-                to->ia_atime = from->ia_atime;
-        return 0;
+    if (to->ia_size < from->ia_size)
+        to->ia_size = from->ia_size;
+    if (to->ia_mtime < from->ia_mtime)
+        to->ia_mtime = from->ia_mtime;
+    if (to->ia_ctime < from->ia_ctime)
+        to->ia_ctime = from->ia_ctime;
+    if (to->ia_atime < from->ia_atime)
+        to->ia_atime = from->ia_atime;
+    return 0;
 }
 
 off_t
 coalesced_offset(off_t offset, uint64_t stripe_size, int stripe_count)
 {
-	size_t line_size = 0;
-	uint64_t stripe_num = 0;
-	off_t coalesced_offset = 0;
+    size_t line_size = 0;
+    uint64_t stripe_num = 0;
+    off_t coalesced_offset = 0;
 
-	line_size = stripe_size * stripe_count;
-	stripe_num = offset / line_size;
+    line_size = stripe_size * stripe_count;
+    stripe_num = offset / line_size;
 
-	coalesced_offset = (stripe_num * stripe_size) +
-		(offset % stripe_size);
+    coalesced_offset = (stripe_num * stripe_size) + (offset % stripe_size);
 
-	return coalesced_offset;
+    return coalesced_offset;
 }
 
 off_t
 uncoalesced_size(off_t size, uint64_t stripe_size, int stripe_count,
-		int stripe_index)
+                 int stripe_index)
 {
-        uint64_t nr_full_stripe_chunks = 0, mod = 0;
-
-        if (!size)
-                return size;
-
-	/*
-	 * Estimate the number of fully written stripes from the
-	 * local file size. Each stripe_size chunk corresponds to
-	 * a stripe.
-	 */
-        nr_full_stripe_chunks = (size / stripe_size) * stripe_count;
-        mod = size % stripe_size;
-
-        if (!mod) {
-                /*
-		 * There is no remainder, thus we could have overestimated
-		 * the size of the file in terms of chunks. Trim the number
-		 * of chunks by the following stripe members and leave it
-		 * up to those nodes to respond with a larger size (if
-		 * necessary).
-		 */
-                nr_full_stripe_chunks -= stripe_count -
-                        (stripe_index + 1);
-                size = nr_full_stripe_chunks * stripe_size;
-        } else {
-		/*
-		 * There is a remainder and thus we own the last chunk of the
-		 * file. Add the preceding stripe members of the final stripe
-		 * along with the remainder to calculate the exact size.
-		 */
-                nr_full_stripe_chunks += stripe_index;
-                size = nr_full_stripe_chunks * stripe_size + mod;
-        }
+    uint64_t nr_full_stripe_chunks = 0, mod = 0;
 
+    if (!size)
         return size;
+
+    /*
+     * Estimate the number of fully written stripes from the
+     * local file size. Each stripe_size chunk corresponds to
+     * a stripe.
+     */
+    nr_full_stripe_chunks = (size / stripe_size) * stripe_count;
+    mod = size % stripe_size;
+
+    if (!mod) {
+        /*
+         * There is no remainder, thus we could have overestimated
+         * the size of the file in terms of chunks. Trim the number
+         * of chunks by the following stripe members and leave it
+         * up to those nodes to respond with a larger size (if
+         * necessary).
+         */
+        nr_full_stripe_chunks -= stripe_count - (stripe_index + 1);
+        size = nr_full_stripe_chunks * stripe_size;
+    } else {
+        /*
+         * There is a remainder and thus we own the last chunk of the
+         * file. Add the preceding stripe members of the final stripe
+         * along with the remainder to calculate the exact size.
+         */
+        nr_full_stripe_chunks += stripe_index;
+        size = nr_full_stripe_chunks * stripe_size + mod;
+    }
+
+    return size;
 }
diff --git a/xlators/cluster/stripe/src/stripe.c b/xlators/cluster/stripe/src/stripe.c
index 75851aa6c5d..a6027d1f281 100644
--- a/xlators/cluster/stripe/src/stripe.c
+++ b/xlators/cluster/stripe/src/stripe.c
@@ -32,2291 +32,2217 @@
 struct volume_options options[];
 
 int32_t
-stripe_sh_chown_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *preop, struct iatt *postop, dict_t *xdata)
+stripe_sh_chown_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                    struct iatt *postop, dict_t *xdata)
 {
-        int             callcnt = -1;
-        stripe_local_t *local   = NULL;
+    int callcnt = -1;
+    stripe_local_t *local = NULL;
 
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                STRIPE_STACK_DESTROY (frame);
-        }
+    if (!callcnt) {
+        STRIPE_STACK_DESTROY(frame);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_sh_make_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, inode_t *inode,
-                          struct iatt *buf, struct iatt *preparent,
-                          struct iatt *postparent, dict_t *xdata)
+stripe_sh_make_entry_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, inode_t *inode,
+                         struct iatt *buf, struct iatt *preparent,
+                         struct iatt *postparent, dict_t *xdata)
 {
-        stripe_local_t *local = NULL;
-        call_frame_t    *prev = NULL;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!frame || !frame->local || !cookie || !this) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!frame || !frame->local || !cookie || !this) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        STACK_WIND (frame, stripe_sh_chown_cbk, prev->this,
-                    prev->this->fops->setattr, &local->loc,
-                    &local->stbuf, (GF_SET_ATTR_UID | GF_SET_ATTR_GID), NULL);
+    STACK_WIND(frame, stripe_sh_chown_cbk, prev->this,
+               prev->this->fops->setattr, &local->loc, &local->stbuf,
+               (GF_SET_ATTR_UID | GF_SET_ATTR_GID), NULL);
 
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_entry_self_heal (call_frame_t *frame, xlator_t *this,
-                        stripe_local_t *local)
+stripe_entry_self_heal(call_frame_t *frame, xlator_t *this,
+                       stripe_local_t *local)
 {
-        xlator_list_t    *trav   = NULL;
-        call_frame_t     *rframe = NULL;
-        stripe_local_t   *rlocal = NULL;
-        stripe_private_t *priv   = NULL;
-        dict_t           *xdata  = NULL;
-        int               ret    = 0;
-
-        if (!local || !this || !frame) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-
-        if (!(IA_ISREG (local->stbuf.ia_type) ||
-              IA_ISDIR (local->stbuf.ia_type)))
-                return 0;
-
-        priv = this->private;
-        trav = this->children;
-        rframe = copy_frame (frame);
-        if (!rframe) {
-                goto out;
-        }
-        rlocal = mem_get0 (this->local_pool);
-        if (!rlocal) {
-                goto out;
-        }
-        rframe->local = rlocal;
-        rlocal->call_count = priv->child_count;
-        loc_copy (&rlocal->loc, &local->loc);
-        memcpy (&rlocal->stbuf, &local->stbuf, sizeof (struct iatt));
+    xlator_list_t *trav = NULL;
+    call_frame_t *rframe = NULL;
+    stripe_local_t *rlocal = NULL;
+    stripe_private_t *priv = NULL;
+    dict_t *xdata = NULL;
+    int ret = 0;
+
+    if (!local || !this || !frame) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        xdata = dict_new ();
-        if (!xdata)
-                goto out;
+    if (!(IA_ISREG(local->stbuf.ia_type) || IA_ISDIR(local->stbuf.ia_type)))
+        return 0;
 
-        ret = dict_set_gfuuid (xdata, "gfid-req", local->stbuf.ia_gfid, true);
-        if (ret)
-                gf_log (this->name, GF_LOG_WARNING,
-                        "%s: failed to set gfid-req", local->loc.path);
+    priv = this->private;
+    trav = this->children;
+    rframe = copy_frame(frame);
+    if (!rframe) {
+        goto out;
+    }
+    rlocal = mem_get0(this->local_pool);
+    if (!rlocal) {
+        goto out;
+    }
+    rframe->local = rlocal;
+    rlocal->call_count = priv->child_count;
+    loc_copy(&rlocal->loc, &local->loc);
+    memcpy(&rlocal->stbuf, &local->stbuf, sizeof(struct iatt));
+
+    xdata = dict_new();
+    if (!xdata)
+        goto out;
 
-        while (trav) {
-                if (IA_ISREG (local->stbuf.ia_type)) {
-                        STACK_WIND (rframe, stripe_sh_make_entry_cbk,
-                                    trav->xlator, trav->xlator->fops->mknod,
-                                    &local->loc,
-                                    st_mode_from_ia (local->stbuf.ia_prot,
-                                                     local->stbuf.ia_type),
-                                    0, 0, xdata);
-                }
-                if (IA_ISDIR (local->stbuf.ia_type)) {
-                        STACK_WIND (rframe, stripe_sh_make_entry_cbk,
-                                    trav->xlator, trav->xlator->fops->mkdir,
-                                    &local->loc,
-                                    st_mode_from_ia (local->stbuf.ia_prot,
-                                                     local->stbuf.ia_type),
-                                    0, xdata);
-                }
-                trav = trav->next;
+    ret = dict_set_gfuuid(xdata, "gfid-req", local->stbuf.ia_gfid, true);
+    if (ret)
+        gf_log(this->name, GF_LOG_WARNING, "%s: failed to set gfid-req",
+               local->loc.path);
+
+    while (trav) {
+        if (IA_ISREG(local->stbuf.ia_type)) {
+            STACK_WIND(
+                rframe, stripe_sh_make_entry_cbk, trav->xlator,
+                trav->xlator->fops->mknod, &local->loc,
+                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
+                0, xdata);
+        }
+        if (IA_ISDIR(local->stbuf.ia_type)) {
+            STACK_WIND(
+                rframe, stripe_sh_make_entry_cbk, trav->xlator,
+                trav->xlator->fops->mkdir, &local->loc,
+                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
+                xdata);
         }
+        trav = trav->next;
+    }
 
-        if (xdata)
-                dict_unref (xdata);
-        return 0;
+    if (xdata)
+        dict_unref(xdata);
+    return 0;
 
 out:
-        if (rframe)
-                STRIPE_STACK_DESTROY (rframe);
+    if (rframe)
+        STRIPE_STACK_DESTROY(rframe);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, dict_t *xdata, struct iatt *postparent)
+stripe_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, dict_t *xdata, struct iatt *postparent)
 {
-        int32_t         callcnt     = 0;
-        stripe_local_t *local       = NULL;
-        call_frame_t   *prev        = NULL;
-        int             ret         = 0;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
+    int ret = 0;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        if ((op_errno != ENOENT) && (op_errno != ESTALE))
-                                gf_log (this->name, GF_LOG_DEBUG,
-                                        "%s returned error %s",
-                                        prev->this->name,
-                                        strerror (op_errno));
-                        if (local->op_errno != ESTALE)
-                                local->op_errno = op_errno;
-                        if (((op_errno != ENOENT) && (op_errno != ENOTCONN)
-                              && (op_errno != ESTALE)) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                        if (op_errno == ENOENT)
-                                local->entry_self_heal_needed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret >= 0) {
-                        local->op_ret = 0;
-                        if (IA_ISREG (buf->ia_type)) {
-                                ret = stripe_ctx_handle (this, prev, local,
-                                                         xdata);
-                                if (ret)
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                 "Error getting fctx info from"
-                                                 " dict");
-                        }
-
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->stbuf      = *buf;
-                                local->postparent = *postparent;
-                                local->inode = inode_ref (inode);
-                                if (xdata)
-                                        local->xdata = dict_ref (xdata);
-                                if (local->xattr) {
-                                        stripe_aggregate_xattr (local->xdata,
-                                                                local->xattr);
-                                        dict_unref (local->xattr);
-                                        local->xattr = NULL;
-                                }
-                        }
-
-                        if (!local->xdata && !local->xattr) {
-                                local->xattr = dict_ref (xdata);
-                        } else if (local->xdata) {
-                                stripe_aggregate_xattr (local->xdata, xdata);
-                        } else if (local->xattr) {
-                                stripe_aggregate_xattr (local->xattr, xdata);
-                        }
-
-                        local->stbuf_blocks      += buf->ia_blocks;
-                        local->postparent_blocks += postparent->ia_blocks;
-
-			correct_file_size(buf, local->fctx, prev);
-
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                        if (local->postparent_size < postparent->ia_size)
-                                local->postparent_size = postparent->ia_size;
-
-                        if (gf_uuid_is_null (local->ia_gfid))
-                                gf_uuid_copy (local->ia_gfid, buf->ia_gfid);
-
-                        /* Make sure the gfid on all the nodes are same */
-                        if (gf_uuid_compare (local->ia_gfid, buf->ia_gfid)) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "%s: gfid different on subvolume %s",
-                                        local->loc.path, prev->this->name);
-                        }
-                }
+        if (op_ret == -1) {
+            if ((op_errno != ENOENT) && (op_errno != ESTALE))
+                gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                       prev->this->name, strerror(op_errno));
+            if (local->op_errno != ESTALE)
+                local->op_errno = op_errno;
+            if (((op_errno != ENOENT) && (op_errno != ENOTCONN) &&
+                 (op_errno != ESTALE)) ||
+                (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+            if (op_errno == ENOENT)
+                local->entry_self_heal_needed = 1;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->op_ret == 0 && local->entry_self_heal_needed &&
-                    !gf_uuid_is_null (local->loc.inode->gfid))
-                        stripe_entry_self_heal (frame, this, local);
-
-                if (local->failed)
-                        local->op_ret = -1;
-
-                if (local->op_ret != -1) {
-                        local->stbuf.ia_blocks      = local->stbuf_blocks;
-                        local->stbuf.ia_size        = local->stbuf_size;
-                        local->postparent.ia_blocks = local->postparent_blocks;
-                        local->postparent.ia_size   = local->postparent_size;
-                        inode_ctx_put (local->inode, this,
-                                       (uint64_t) (long)local->fctx);
+
+        if (op_ret >= 0) {
+            local->op_ret = 0;
+            if (IA_ISREG(buf->ia_type)) {
+                ret = stripe_ctx_handle(this, prev, local, xdata);
+                if (ret)
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "Error getting fctx info from"
+                           " dict");
+            }
+
+            if (FIRST_CHILD(this) == prev->this) {
+                local->stbuf = *buf;
+                local->postparent = *postparent;
+                local->inode = inode_ref(inode);
+                if (xdata)
+                    local->xdata = dict_ref(xdata);
+                if (local->xattr) {
+                    stripe_aggregate_xattr(local->xdata, local->xattr);
+                    dict_unref(local->xattr);
+                    local->xattr = NULL;
                 }
+            }
 
-                STRIPE_STACK_UNWIND (lookup, frame, local->op_ret,
-                                     local->op_errno, local->inode,
-                                     &local->stbuf, local->xdata,
-                                     &local->postparent);
-        }
-out:
-        return 0;
-}
+            if (!local->xdata && !local->xattr) {
+                local->xattr = dict_ref(xdata);
+            } else if (local->xdata) {
+                stripe_aggregate_xattr(local->xdata, xdata);
+            } else if (local->xattr) {
+                stripe_aggregate_xattr(local->xattr, xdata);
+            }
 
-int32_t
-stripe_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
-               dict_t *xdata)
-{
-        stripe_local_t   *local    = NULL;
-        xlator_list_t    *trav     = NULL;
-        stripe_private_t *priv     = NULL;
-        int32_t           op_errno = EINVAL;
-        int64_t           filesize = 0;
-        int               ret      = 0;
-        uint64_t          tmpctx   = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
+            local->stbuf_blocks += buf->ia_blocks;
+            local->postparent_blocks += postparent->ia_blocks;
 
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        loc_copy (&local->loc, loc);
+            correct_file_size(buf, local->fctx, prev);
 
-        inode_ctx_get (local->inode, this, &tmpctx);
-        if (tmpctx)
-                local->fctx = (stripe_fd_ctx_t*) (long)tmpctx;
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+            if (local->postparent_size < postparent->ia_size)
+                local->postparent_size = postparent->ia_size;
 
-        /* quick-read friendly changes */
-        if (xdata && dict_get (xdata, GF_CONTENT_KEY)) {
-                ret = dict_get_int64 (xdata, GF_CONTENT_KEY, &filesize);
-                if (!ret && (filesize > priv->block_size))
-                        dict_del (xdata, GF_CONTENT_KEY);
+            if (gf_uuid_is_null(local->ia_gfid))
+                gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
+
+            /* Make sure the gfid on all the nodes are same */
+            if (gf_uuid_compare(local->ia_gfid, buf->ia_gfid)) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "%s: gfid different on subvolume %s", local->loc.path,
+                       prev->this->name);
+            }
         }
+    }
+    UNLOCK(&frame->lock);
 
-        /* get stripe-size xattr on lookup. This would be required for
-         * open/read/write/pathinfo calls. Hence we send down the request
-         * even when type == IA_INVAL */
-
-	/*
-	 * We aren't guaranteed to have xdata here. We need the format info for
-	 * the file, so allocate xdata if necessary.
-	 */
-	if (!xdata)
-		xdata = dict_new();
-	else
-		xdata = dict_ref(xdata);
-
-        if (xdata && (IA_ISREG (loc->inode->ia_type) ||
-            (loc->inode->ia_type == IA_INVAL))) {
-                ret = stripe_xattr_request_build (this, xdata, 8, 4, 4, 0);
-                if (ret)
-                        gf_log (this->name , GF_LOG_ERROR, "Failed to build"
-                                " xattr request for %s", loc->path);
+    if (!callcnt) {
+        if (local->op_ret == 0 && local->entry_self_heal_needed &&
+            !gf_uuid_is_null(local->loc.inode->gfid))
+            stripe_entry_self_heal(frame, this, local);
 
-        }
+        if (local->failed)
+            local->op_ret = -1;
 
-        /* Every time in stripe lookup, all child nodes
-           should be looked up */
-        local->call_count = priv->child_count;
-        while (trav) {
-                STACK_WIND (frame, stripe_lookup_cbk, trav->xlator,
-                            trav->xlator->fops->lookup, loc, xdata);
-                trav = trav->next;
+        if (local->op_ret != -1) {
+            local->stbuf.ia_blocks = local->stbuf_blocks;
+            local->stbuf.ia_size = local->stbuf_size;
+            local->postparent.ia_blocks = local->postparent_blocks;
+            local->postparent.ia_size = local->postparent_size;
+            inode_ctx_put(local->inode, this, (uint64_t)(long)local->fctx);
         }
 
-	dict_unref(xdata);
+        STRIPE_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, local->xdata,
+                            &local->postparent);
+    }
+out:
+    return 0;
+}
 
-        return 0;
+int32_t
+stripe_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+{
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+    int64_t filesize = 0;
+    int ret = 0;
+    uint64_t tmpctx = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    loc_copy(&local->loc, loc);
+
+    inode_ctx_get(local->inode, this, &tmpctx);
+    if (tmpctx)
+        local->fctx = (stripe_fd_ctx_t *)(long)tmpctx;
+
+    /* quick-read friendly changes */
+    if (xdata && dict_get(xdata, GF_CONTENT_KEY)) {
+        ret = dict_get_int64(xdata, GF_CONTENT_KEY, &filesize);
+        if (!ret && (filesize > priv->block_size))
+            dict_del(xdata, GF_CONTENT_KEY);
+    }
+
+    /* get stripe-size xattr on lookup. This would be required for
+     * open/read/write/pathinfo calls. Hence we send down the request
+     * even when type == IA_INVAL */
+
+    /*
+     * We aren't guaranteed to have xdata here. We need the format info for
+     * the file, so allocate xdata if necessary.
+     */
+    if (!xdata)
+        xdata = dict_new();
+    else
+        xdata = dict_ref(xdata);
+
+    if (xdata &&
+        (IA_ISREG(loc->inode->ia_type) || (loc->inode->ia_type == IA_INVAL))) {
+        ret = stripe_xattr_request_build(this, xdata, 8, 4, 4, 0);
+        if (ret)
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Failed to build"
+                   " xattr request for %s",
+                   loc->path);
+    }
+
+    /* Every time in stripe lookup, all child nodes
+       should be looked up */
+    local->call_count = priv->child_count;
+    while (trav) {
+        STACK_WIND(frame, stripe_lookup_cbk, trav->xlator,
+                   trav->xlator->fops->lookup, loc, xdata);
+        trav = trav->next;
+    }
+
+    dict_unref(xdata);
+
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata)
+stripe_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-        prev  = cookie;
-        local = frame->local;
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret == 0) {
-                        local->op_ret = 0;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+        }
 
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->stbuf = *buf;
-                        }
+        if (op_ret == 0) {
+            local->op_ret = 0;
 
-                        local->stbuf_blocks += buf->ia_blocks;
+            if (FIRST_CHILD(this) == prev->this) {
+                local->stbuf = *buf;
+            }
 
-			correct_file_size(buf, local->fctx, prev);
+            local->stbuf_blocks += buf->ia_blocks;
 
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
+            correct_file_size(buf, local->fctx, prev);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
 
-                if (local->op_ret != -1) {
-                        local->stbuf.ia_size   = local->stbuf_size;
-                        local->stbuf.ia_blocks = local->stbuf_blocks;
-                }
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (stat, frame, local->op_ret,
-                                     local->op_errno, &local->stbuf, NULL);
+        if (local->op_ret != -1) {
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
         }
+
+        STRIPE_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
+                            &local->stbuf, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+stripe_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-	stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    if (IA_ISREG(loc->inode->ia_type)) {
+        inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
+        if (!fctx)
+            goto err;
+        local->fctx = fctx;
+    }
 
-	if (IA_ISREG(loc->inode->ia_type)) {
-		inode_ctx_get(loc->inode, this, (uint64_t *) &fctx);
-		if (!fctx)
-			goto err;
-		local->fctx = fctx;
-	}
+    while (trav) {
+        STACK_WIND(frame, stripe_stat_cbk, trav->xlator,
+                   trav->xlator->fops->stat, loc, NULL);
+        trav = trav->next;
+    }
 
-        while (trav) {
-                STACK_WIND (frame, stripe_stat_cbk, trav->xlator,
-                            trav->xlator->fops->stat, loc, NULL);
-                trav = trav->next;
-        }
-
-        return 0;
+    return 0;
 
 err:
-        STRIPE_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct statvfs *stbuf, dict_t *xdata)
+stripe_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct statvfs *stbuf,
+                  dict_t *xdata)
 {
-        stripe_local_t *local = NULL;
-        int32_t         callcnt = 0;
+    stripe_local_t *local = NULL;
+    int32_t callcnt = 0;
 
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-        local = frame->local;
-
-        LOCK(&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret && (op_errno != ENOTCONN)) {
-                        local->op_errno = op_errno;
-                }
-                if (op_ret == 0) {
-                        struct statvfs *dict_buf = &local->statvfs_buf;
-                        dict_buf->f_bsize   = stbuf->f_bsize;
-                        dict_buf->f_frsize  = stbuf->f_frsize;
-                        dict_buf->f_blocks += stbuf->f_blocks;
-                        dict_buf->f_bfree  += stbuf->f_bfree;
-                        dict_buf->f_bavail += stbuf->f_bavail;
-                        dict_buf->f_files  += stbuf->f_files;
-                        dict_buf->f_ffree  += stbuf->f_ffree;
-                        dict_buf->f_favail += stbuf->f_favail;
-                        dict_buf->f_fsid    = stbuf->f_fsid;
-                        dict_buf->f_flag    = stbuf->f_flag;
-                        dict_buf->f_namemax = stbuf->f_namemax;
-                        local->op_ret = 0;
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                STRIPE_STACK_UNWIND (statfs, frame, local->op_ret,
-                                     local->op_errno, &local->statvfs_buf, NULL);
-        }
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+    local = frame->local;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret && (op_errno != ENOTCONN)) {
+            local->op_errno = op_errno;
+        }
+        if (op_ret == 0) {
+            struct statvfs *dict_buf = &local->statvfs_buf;
+            dict_buf->f_bsize = stbuf->f_bsize;
+            dict_buf->f_frsize = stbuf->f_frsize;
+            dict_buf->f_blocks += stbuf->f_blocks;
+            dict_buf->f_bfree += stbuf->f_bfree;
+            dict_buf->f_bavail += stbuf->f_bavail;
+            dict_buf->f_files += stbuf->f_files;
+            dict_buf->f_ffree += stbuf->f_ffree;
+            dict_buf->f_favail += stbuf->f_favail;
+            dict_buf->f_fsid = stbuf->f_fsid;
+            dict_buf->f_flag = stbuf->f_flag;
+            dict_buf->f_namemax = stbuf->f_namemax;
+            local->op_ret = 0;
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        STRIPE_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
+                            &local->statvfs_buf, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+stripe_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        xlator_list_t    *trav = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-
-        trav = this->children;
-        priv = this->private;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        local->op_errno = ENOTCONN;
-        frame->local = local;
-
-        local->call_count = priv->child_count;
-        while (trav) {
-                STACK_WIND (frame, stripe_statfs_cbk, trav->xlator,
-                            trav->xlator->fops->statfs, loc, NULL);
-                trav = trav->next;
-        }
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+
+    trav = this->children;
+    priv = this->private;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    local->op_errno = ENOTCONN;
+    frame->local = local;
+
+    local->call_count = priv->child_count;
+    while (trav) {
+        STACK_WIND(frame, stripe_statfs_cbk, trav->xlator,
+                   trav->xlator->fops->statfs, loc, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
-
 int32_t
-stripe_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata)
+stripe_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret == 0) {
-                        local->op_ret = 0;
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->pre_buf  = *prebuf;
-                                local->post_buf = *postbuf;
-                        }
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+        }
 
-                        local->prebuf_blocks  += prebuf->ia_blocks;
-                        local->postbuf_blocks += postbuf->ia_blocks;
+        if (op_ret == 0) {
+            local->op_ret = 0;
+            if (FIRST_CHILD(this) == prev->this) {
+                local->pre_buf = *prebuf;
+                local->post_buf = *postbuf;
+            }
 
-			correct_file_size(prebuf, local->fctx, prev);
-			correct_file_size(postbuf, local->fctx, prev);
+            local->prebuf_blocks += prebuf->ia_blocks;
+            local->postbuf_blocks += postbuf->ia_blocks;
 
-                        if (local->prebuf_size < prebuf->ia_size)
-                                local->prebuf_size = prebuf->ia_size;
+            correct_file_size(prebuf, local->fctx, prev);
+            correct_file_size(postbuf, local->fctx, prev);
 
-                        if (local->postbuf_size < postbuf->ia_size)
-                                local->postbuf_size = postbuf->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
+            if (local->prebuf_size < prebuf->ia_size)
+                local->prebuf_size = prebuf->ia_size;
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+            if (local->postbuf_size < postbuf->ia_size)
+                local->postbuf_size = postbuf->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
 
-                if (local->op_ret != -1) {
-                        local->pre_buf.ia_blocks  = local->prebuf_blocks;
-                        local->pre_buf.ia_size    = local->prebuf_size;
-                        local->post_buf.ia_blocks = local->postbuf_blocks;
-                        local->post_buf.ia_size   = local->postbuf_size;
-                }
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (truncate, frame, local->op_ret,
-                                     local->op_errno, &local->pre_buf,
-                                     &local->post_buf, NULL);
+        if (local->op_ret != -1) {
+            local->pre_buf.ia_blocks = local->prebuf_blocks;
+            local->pre_buf.ia_size = local->prebuf_size;
+            local->post_buf.ia_blocks = local->postbuf_blocks;
+            local->post_buf.ia_size = local->postbuf_size;
         }
+
+        STRIPE_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
+                            &local->pre_buf, &local->post_buf, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, dict_t *xdata)
+stripe_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-	stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = EINVAL;
-	int		  i, eof_idx;
-	off_t		  dest_offset, tmp_offset;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = EINVAL;
+    int i, eof_idx;
+    off_t dest_offset, tmp_offset;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
+    if (!fctx) {
+        gf_log(this->name, GF_LOG_ERROR, "no stripe context");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->fctx = fctx;
+    eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
+
+    for (i = 0; i < fctx->stripe_count; i++) {
+        if (!fctx->xl_array[i]) {
+            gf_log(this->name, GF_LOG_ERROR, "no xlator at index %d", i);
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (fctx->stripe_coalesce) {
+            /*
+             * The node that owns EOF is truncated to the exact
+             * coalesced offset. Nodes prior to this index should
+             * be rounded up to the size of the complete stripe,
+             * while nodes after this index should be rounded down
+             * to the size of the previous stripe.
+             */
+            if (i < eof_idx)
+                tmp_offset = roof(offset,
+                                  fctx->stripe_size * fctx->stripe_count);
+            else if (i > eof_idx)
+                tmp_offset = floor(offset,
+                                   fctx->stripe_size * fctx->stripe_count);
+            else
+                tmp_offset = offset;
+
+            dest_offset = coalesced_offset(tmp_offset, fctx->stripe_size,
+                                           fctx->stripe_count);
+        } else {
+            dest_offset = offset;
         }
 
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-	inode_ctx_get(loc->inode, this, (uint64_t *) &fctx);
-	if (!fctx) {
-		gf_log(this->name, GF_LOG_ERROR, "no stripe context");
-		op_errno = EINVAL;
-		goto err;
-	}
-
-	local->fctx = fctx;
-	eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
-
-	for (i = 0; i < fctx->stripe_count; i++) {
-		if (!fctx->xl_array[i]) {
-			gf_log(this->name, GF_LOG_ERROR,
-				"no xlator at index %d", i);
-			op_errno = EINVAL;
-			goto err;
-		}
-
-		if (fctx->stripe_coalesce) {
-			/*
-	 		 * The node that owns EOF is truncated to the exact
-	 		 * coalesced offset. Nodes prior to this index should
-	 		 * be rounded up to the size of the complete stripe,
-	 		 * while nodes after this index should be rounded down
-			 * to the size of the previous stripe.
-			 */
-			if (i < eof_idx)
-				tmp_offset = roof(offset, fctx->stripe_size *
-						fctx->stripe_count);
-			else if (i > eof_idx)
-				tmp_offset = floor(offset, fctx->stripe_size *
-						fctx->stripe_count);
-			else
-				tmp_offset = offset;
-
-			dest_offset = coalesced_offset(tmp_offset,
-					fctx->stripe_size, fctx->stripe_count);
-		} else {
-			dest_offset = offset;
-		}
-
-		STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
-			fctx->xl_array[i]->fops->truncate, loc, dest_offset,
-			NULL);
-	}
+        STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
+                   fctx->xl_array[i]->fops->truncate, loc, dest_offset, NULL);
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno,
-                    struct iatt *preop, struct iatt *postop, dict_t *xdata)
+stripe_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                   struct iatt *postop, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+        }
 
-                if (op_ret == 0) {
-                        local->op_ret = 0;
+        if (op_ret == 0) {
+            local->op_ret = 0;
 
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->pre_buf  = *preop;
-                                local->post_buf = *postop;
-                        }
+            if (FIRST_CHILD(this) == prev->this) {
+                local->pre_buf = *preop;
+                local->post_buf = *postop;
+            }
 
-                        local->prebuf_blocks  += preop->ia_blocks;
-                        local->postbuf_blocks += postop->ia_blocks;
+            local->prebuf_blocks += preop->ia_blocks;
+            local->postbuf_blocks += postop->ia_blocks;
 
-			correct_file_size(preop, local->fctx, prev);
-			correct_file_size(postop, local->fctx, prev);
+            correct_file_size(preop, local->fctx, prev);
+            correct_file_size(postop, local->fctx, prev);
 
-                        if (local->prebuf_size < preop->ia_size)
-                                local->prebuf_size = preop->ia_size;
-                        if (local->postbuf_size < postop->ia_size)
-                                local->postbuf_size = postop->ia_size;
-                }
+            if (local->prebuf_size < preop->ia_size)
+                local->prebuf_size = preop->ia_size;
+            if (local->postbuf_size < postop->ia_size)
+                local->postbuf_size = postop->ia_size;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+    }
+    UNLOCK(&frame->lock);
 
-                if (local->op_ret != -1) {
-                        local->pre_buf.ia_blocks  = local->prebuf_blocks;
-                        local->pre_buf.ia_size    = local->prebuf_size;
-                        local->post_buf.ia_blocks = local->postbuf_blocks;
-                        local->post_buf.ia_size   = local->postbuf_size;
-                }
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (setattr, frame, local->op_ret,
-                                     local->op_errno, &local->pre_buf,
-                                     &local->post_buf, NULL);
+        if (local->op_ret != -1) {
+            local->pre_buf.ia_blocks = local->prebuf_blocks;
+            local->pre_buf.ia_size = local->prebuf_size;
+            local->post_buf.ia_blocks = local->postbuf_blocks;
+            local->post_buf.ia_size = local->postbuf_size;
         }
+
+        STRIPE_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
+                            &local->pre_buf, &local->post_buf, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                struct iatt *stbuf, int32_t valid, dict_t *xdata)
+stripe_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-	stripe_fd_ctx_t	 *fctx = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        if (!IA_ISDIR (loc->inode->ia_type) &&
-            !IA_ISREG (loc->inode->ia_type)) {
-                local->call_count = 1;
-                STACK_WIND (frame, stripe_setattr_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->setattr,
-                            loc, stbuf, valid, NULL);
-                return 0;
-        }
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    if (!IA_ISDIR(loc->inode->ia_type) && !IA_ISREG(loc->inode->ia_type)) {
+        local->call_count = 1;
+        STACK_WIND(frame, stripe_setattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, NULL);
+        return 0;
+    }
 
-	if (IA_ISREG(loc->inode->ia_type)) {
-		inode_ctx_get(loc->inode, this, (uint64_t *) &fctx);
-		if (!fctx)
-			goto err;
-		local->fctx = fctx;
-	}
+    if (IA_ISREG(loc->inode->ia_type)) {
+        inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
+        if (!fctx)
+            goto err;
+        local->fctx = fctx;
+    }
 
-        local->call_count = priv->child_count;
-        while (trav) {
-                STACK_WIND (frame, stripe_setattr_cbk,
-                            trav->xlator, trav->xlator->fops->setattr,
-                            loc, stbuf, valid, NULL);
-                trav = trav->next;
-        }
+    local->call_count = priv->child_count;
+    while (trav) {
+        STACK_WIND(frame, stripe_setattr_cbk, trav->xlator,
+                   trav->xlator->fops->setattr, loc, stbuf, valid, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (setattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
+stripe_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-        while (trav) {
-                STACK_WIND (frame, stripe_setattr_cbk, trav->xlator,
-                            trav->xlator->fops->fsetattr, fd, stbuf, valid, NULL);
-                trav = trav->next;
-        }
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    while (trav) {
+        STACK_WIND(frame, stripe_setattr_cbk, trav->xlator,
+                   trav->xlator->fops->fsetattr, fd, stbuf, valid, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_stack_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                         struct iatt *preoldparent, struct iatt *postoldparent,
-                         struct iatt *prenewparent, struct iatt *postnewparent,
-                         dict_t *xdata)
+stripe_stack_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                        struct iatt *preoldparent, struct iatt *postoldparent,
+                        struct iatt *prenewparent, struct iatt *postnewparent,
+                        dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret == 0) {
-                        local->op_ret = 0;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+        }
 
-                        local->stbuf.ia_blocks      += buf->ia_blocks;
-                        local->preparent.ia_blocks  += preoldparent->ia_blocks;
-                        local->postparent.ia_blocks += postoldparent->ia_blocks;
-                        local->pre_buf.ia_blocks    += prenewparent->ia_blocks;
-                        local->post_buf.ia_blocks   += postnewparent->ia_blocks;
+        if (op_ret == 0) {
+            local->op_ret = 0;
 
-			correct_file_size(buf, local->fctx, prev);
+            local->stbuf.ia_blocks += buf->ia_blocks;
+            local->preparent.ia_blocks += preoldparent->ia_blocks;
+            local->postparent.ia_blocks += postoldparent->ia_blocks;
+            local->pre_buf.ia_blocks += prenewparent->ia_blocks;
+            local->post_buf.ia_blocks += postnewparent->ia_blocks;
 
-                        if (local->stbuf.ia_size < buf->ia_size)
-                                local->stbuf.ia_size =  buf->ia_size;
+            correct_file_size(buf, local->fctx, prev);
 
-                        if (local->preparent.ia_size < preoldparent->ia_size)
-                                local->preparent.ia_size = preoldparent->ia_size;
+            if (local->stbuf.ia_size < buf->ia_size)
+                local->stbuf.ia_size = buf->ia_size;
 
-                        if (local->postparent.ia_size < postoldparent->ia_size)
-                                local->postparent.ia_size = postoldparent->ia_size;
+            if (local->preparent.ia_size < preoldparent->ia_size)
+                local->preparent.ia_size = preoldparent->ia_size;
 
-                        if (local->pre_buf.ia_size < prenewparent->ia_size)
-                                local->pre_buf.ia_size = prenewparent->ia_size;
+            if (local->postparent.ia_size < postoldparent->ia_size)
+                local->postparent.ia_size = postoldparent->ia_size;
 
-                        if (local->post_buf.ia_size < postnewparent->ia_size)
-                                local->post_buf.ia_size = postnewparent->ia_size;
-                }
+            if (local->pre_buf.ia_size < prenewparent->ia_size)
+                local->pre_buf.ia_size = prenewparent->ia_size;
+
+            if (local->post_buf.ia_size < postnewparent->ia_size)
+                local->post_buf.ia_size = postnewparent->ia_size;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (rename, frame, local->op_ret, local->op_errno,
-                                     &local->stbuf, &local->preparent,
-                                     &local->postparent,  &local->pre_buf,
-                                     &local->post_buf, NULL);
-        }
+        STRIPE_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
+                            &local->stbuf, &local->preparent,
+                            &local->postparent, &local->pre_buf,
+                            &local->post_buf, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_first_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                         struct iatt *preoldparent, struct iatt *postoldparent,
-                         struct iatt *prenewparent, struct iatt *postnewparent,
-                         dict_t *xdata)
+stripe_first_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                        struct iatt *preoldparent, struct iatt *postoldparent,
+                        struct iatt *prenewparent, struct iatt *postnewparent,
+                        dict_t *xdata)
 {
-        stripe_local_t *local = NULL;
-        xlator_list_t  *trav = NULL;
-
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                op_errno = EINVAL;
-                goto unwind;
-        }
-
-        if (op_ret == -1) {
-                goto unwind;
-        }
-
-        local = frame->local;
-        trav = this->children;
-
-        local->stbuf      = *buf;
-        local->preparent  = *preoldparent;
-        local->postparent = *postoldparent;
-        local->pre_buf    = *prenewparent;
-        local->post_buf   = *postnewparent;
-
-        local->op_ret = 0;
-        local->call_count--;
-
-        trav = trav->next; /* Skip first child */
-        while (trav) {
-                STACK_WIND (frame, stripe_stack_rename_cbk,
-                            trav->xlator, trav->xlator->fops->rename,
-                            &local->loc, &local->loc2, NULL);
-                trav = trav->next;
-        }
-        return 0;
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        op_errno = EINVAL;
+        goto unwind;
+    }
+
+    if (op_ret == -1) {
+        goto unwind;
+    }
+
+    local = frame->local;
+    trav = this->children;
+
+    local->stbuf = *buf;
+    local->preparent = *preoldparent;
+    local->postparent = *postoldparent;
+    local->pre_buf = *prenewparent;
+    local->post_buf = *postnewparent;
+
+    local->op_ret = 0;
+    local->call_count--;
+
+    trav = trav->next; /* Skip first child */
+    while (trav) {
+        STACK_WIND(frame, stripe_stack_rename_cbk, trav->xlator,
+                   trav->xlator->fops->rename, &local->loc, &local->loc2, NULL);
+        trav = trav->next;
+    }
+    return 0;
 
 unwind:
-        STRIPE_STACK_UNWIND (rename, frame, -1, op_errno, buf, preoldparent,
-                             postoldparent, prenewparent, postnewparent, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(rename, frame, -1, op_errno, buf, preoldparent,
+                        postoldparent, prenewparent, postnewparent, NULL);
+    return 0;
 }
 
 int32_t
-stripe_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-               loc_t *newloc, dict_t *xdata)
+stripe_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+              dict_t *xdata)
 {
-        stripe_private_t *priv = NULL;
-        stripe_local_t   *local = NULL;
-        xlator_list_t    *trav = NULL;
-	stripe_fd_ctx_t	 *fctx = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (oldloc->path, err);
-        VALIDATE_OR_GOTO (oldloc->inode, err);
-        VALIDATE_OR_GOTO (newloc, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* If any one node is down, don't allow rename */
-        if (priv->nodes_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        frame->local = local;
-
-        local->op_ret = -1;
-        loc_copy (&local->loc, oldloc);
-        loc_copy (&local->loc2, newloc);
-
-        local->call_count = priv->child_count;
-
-	if (IA_ISREG(oldloc->inode->ia_type)) {
-		inode_ctx_get(oldloc->inode, this, (uint64_t *) &fctx);
-		if (!fctx)
-			goto err;
-		local->fctx = fctx;
-	}
+    stripe_private_t *priv = NULL;
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(oldloc->path, err);
+    VALIDATE_OR_GOTO(oldloc->inode, err);
+    VALIDATE_OR_GOTO(newloc, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* If any one node is down, don't allow rename */
+    if (priv->nodes_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    frame->local = local;
+
+    local->op_ret = -1;
+    loc_copy(&local->loc, oldloc);
+    loc_copy(&local->loc2, newloc);
+
+    local->call_count = priv->child_count;
+
+    if (IA_ISREG(oldloc->inode->ia_type)) {
+        inode_ctx_get(oldloc->inode, this, (uint64_t *)&fctx);
+        if (!fctx)
+            goto err;
+        local->fctx = fctx;
+    }
 
-        STACK_WIND (frame, stripe_first_rename_cbk, trav->xlator,
-                    trav->xlator->fops->rename, oldloc, newloc, NULL);
+    STACK_WIND(frame, stripe_first_rename_cbk, trav->xlator,
+               trav->xlator->fops->rename, oldloc, newloc, NULL);
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, NULL,
-                             NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL, NULL);
+    return 0;
 }
 int32_t
-stripe_first_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+stripe_first_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        struct iatt *preparent, struct iatt *postparent,
+                        dict_t *xdata)
 {
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        if (op_ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "%s returned %s",
-                        prev->this->name, strerror (op_errno));
-                goto out;
-        }
-        local->op_ret = 0;
-        local->preparent  = *preparent;
-        local->postparent = *postparent;
-        local->preparent_blocks  += preparent->ia_blocks;
-        local->postparent_blocks += postparent->ia_blocks;
-
-        STRIPE_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                            &local->preparent, &local->postparent, xdata);
-        return 0;
+    if (op_ret == -1) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+               strerror(op_errno));
+        goto out;
+    }
+    local->op_ret = 0;
+    local->preparent = *preparent;
+    local->postparent = *postparent;
+    local->preparent_blocks += preparent->ia_blocks;
+    local->postparent_blocks += postparent->ia_blocks;
+
+    STRIPE_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
+                        &local->preparent, &local->postparent, xdata);
+    return 0;
 out:
-        STRIPE_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
-
-
-
 int32_t
-stripe_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+stripe_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG, "%s returned %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if (op_errno != ENOENT) {
-                                local->failed = 1;
-                                local->op_ret = op_ret;
-                        }
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+                   strerror(op_errno));
+            local->op_errno = op_errno;
+            if (op_errno != ENOENT) {
+                local->failed = 1;
+                local->op_ret = op_ret;
+            }
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if (callcnt == 1) {
-                if (local->failed) {
-                        op_errno = local->op_errno;
-                        goto out;
-                }
-                STACK_WIND(frame, stripe_first_unlink_cbk, FIRST_CHILD (this),
-                           FIRST_CHILD (this)->fops->unlink, &local->loc,
-                           local->xflag, local->xdata);
+    if (callcnt == 1) {
+        if (local->failed) {
+            op_errno = local->op_errno;
+            goto out;
         }
-        return 0;
+        STACK_WIND(frame, stripe_first_unlink_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
+                   local->xdata);
+    }
+    return 0;
 out:
-        STRIPE_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc,
-               int xflag, dict_t *xdata)
+stripe_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+              dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Don't unlink a file if a node is down */
-        if (priv->nodes_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        loc_copy (&local->loc, loc);
-        local->xflag = xflag;
-
-        if (xdata)
-            local->xdata = dict_ref (xdata);
-
-        frame->local = local;
-        local->call_count = priv->child_count;
-        trav = trav->next; /* Skip the first child */
-
-        while (trav) {
-                STACK_WIND (frame, stripe_unlink_cbk,
-                            trav->xlator, trav->xlator->fops->unlink,
-                            loc, xflag, xdata);
-                trav = trav->next;
-        }
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Don't unlink a file if a node is down */
+    if (priv->nodes_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    loc_copy(&local->loc, loc);
+    local->xflag = xflag;
+
+    if (xdata)
+        local->xdata = dict_ref(xdata);
+
+    frame->local = local;
+    local->call_count = priv->child_count;
+    trav = trav->next; /* Skip the first child */
+
+    while (trav) {
+        STACK_WIND(frame, stripe_unlink_cbk, trav->xlator,
+                   trav->xlator->fops->unlink, loc, xflag, xdata);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_first_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno,struct iatt *preparent,
-                        struct iatt *postparent, dict_t *xdata)
+stripe_first_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                       struct iatt *postparent, dict_t *xdata)
 {
-        stripe_local_t *local = NULL;
+    stripe_local_t *local = NULL;
 
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        op_errno = EINVAL;
+        goto err;
+    }
 
-        if (op_ret == -1) {
-                goto err;
-        }
+    if (op_ret == -1) {
+        goto err;
+    }
 
-        local = frame->local;
-        local->op_ret = 0;
+    local = frame->local;
+    local->op_ret = 0;
 
-        local->call_count--; /* First child successful */
+    local->call_count--; /* First child successful */
 
-        local->preparent  = *preparent;
-        local->postparent = *postparent;
-        local->preparent_size  = preparent->ia_size;
-        local->postparent_size = postparent->ia_size;
-        local->preparent_blocks  += preparent->ia_blocks;
-        local->postparent_blocks += postparent->ia_blocks;
+    local->preparent = *preparent;
+    local->postparent = *postparent;
+    local->preparent_size = preparent->ia_size;
+    local->postparent_size = postparent->ia_size;
+    local->preparent_blocks += preparent->ia_blocks;
+    local->postparent_blocks += postparent->ia_blocks;
 
-        STRIPE_STACK_UNWIND (rmdir, frame, local->op_ret, local->op_errno,
-                             &local->preparent, &local->postparent, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
+                        &local->preparent, &local->postparent, xdata);
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (rmdir, frame, op_ret, op_errno, NULL, NULL, NULL);
-        return 0;
-
+    STRIPE_STACK_UNWIND(rmdir, frame, op_ret, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+stripe_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG, "%s returned %s",
-                                prev->this->name, strerror (op_errno));
-                        if (op_errno != ENOENT)
-                                local->failed = 1;
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        if (callcnt == 1) {
-                if (local->failed)
-                        goto out;
-                STACK_WIND (frame, stripe_first_rmdir_cbk, FIRST_CHILD (this),
-                            FIRST_CHILD (this)->fops->rmdir, &local->loc,
-                            local->flags, NULL);
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+                   strerror(op_errno));
+            if (op_errno != ENOENT)
+                local->failed = 1;
         }
-        return 0;
+    }
+    UNLOCK(&frame->lock);
+
+    if (callcnt == 1) {
+        if (local->failed)
+            goto out;
+        STACK_WIND(frame, stripe_first_rmdir_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->rmdir, &local->loc, local->flags,
+                   NULL);
+    }
+    return 0;
 out:
-        STRIPE_STACK_UNWIND (rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata)
+stripe_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+             dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* don't delete a directory if any of the subvolume is down */
-        if (priv->nodes_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        loc_copy (&local->loc, loc);
-        local->flags = flags;
-        local->call_count = priv->child_count;
-        trav = trav->next; /* skip the first child */
-
-        while (trav) {
-                STACK_WIND (frame, stripe_rmdir_cbk,  trav->xlator,
-                            trav->xlator->fops->rmdir, loc, flags, NULL);
-                trav = trav->next;
-        }
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* don't delete a directory if any of the subvolume is down */
+    if (priv->nodes_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    loc_copy(&local->loc, loc);
+    local->flags = flags;
+    local->call_count = priv->child_count;
+    trav = trav->next; /* skip the first child */
+
+    while (trav) {
+        STACK_WIND(frame, stripe_rmdir_cbk, trav->xlator,
+                   trav->xlator->fops->rmdir, loc, flags, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_mknod_ifreg_fail_unlink_cbk (call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int32_t op_ret,
-                                    int32_t op_errno, struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata)
+stripe_mknod_ifreg_fail_unlink_cbk(call_frame_t *frame, void *cookie,
+                                   xlator_t *this, int32_t op_ret,
+                                   int32_t op_errno, struct iatt *preparent,
+                                   struct iatt *postparent, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
 
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                STRIPE_STACK_UNWIND (mknod, frame, local->op_ret, local->op_errno,
-                                     local->inode, &local->stbuf,
-                                     &local->preparent, &local->postparent, NULL);
-        }
+    if (!callcnt) {
+        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, &local->preparent,
+                            &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 /**
  */
 int32_t
-stripe_mknod_ifreg_setxattr_cbk (call_frame_t *frame, void *cookie,
-                                 xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *xdata)
+stripe_mknod_ifreg_setxattr_cbk(call_frame_t *frame, void *cookie,
+                                xlator_t *this, int32_t op_ret,
+                                int32_t op_errno, dict_t *xdata)
 {
-        int32_t           callcnt = 0;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-        call_frame_t     *prev = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    call_frame_t *prev = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        priv  = this->private;
-        local = frame->local;
+    prev = cookie;
+    priv = this->private;
+    local = frame->local;
 
-	LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_ret = -1;
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->op_ret == -1) {
-                        local->call_count = priv->child_count;
-                        while (trav) {
-                                STACK_WIND (frame,
-                                            stripe_mknod_ifreg_fail_unlink_cbk,
-                                            trav->xlator,
-                                            trav->xlator->fops->unlink,
-                                            &local->loc, 0, NULL);
-                                trav = trav->next;
-                        }
-                        return 0;
-                }
+    }
+    UNLOCK(&frame->lock);
 
-                STRIPE_STACK_UNWIND (mknod, frame, local->op_ret, local->op_errno,
-                                     local->inode, &local->stbuf,
-                                     &local->preparent, &local->postparent, NULL);
+    if (!callcnt) {
+        if (local->op_ret == -1) {
+            local->call_count = priv->child_count;
+            while (trav) {
+                STACK_WIND(frame, stripe_mknod_ifreg_fail_unlink_cbk,
+                           trav->xlator, trav->xlator->fops->unlink,
+                           &local->loc, 0, NULL);
+                trav = trav->next;
+            }
+            return 0;
         }
+
+        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, &local->preparent,
+                            &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_mknod_ifreg_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, inode_t *inode,
-                        struct iatt *buf, struct iatt *preparent,
-                        struct iatt *postparent, dict_t *xdata)
+stripe_mknod_ifreg_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, inode_t *inode,
+                       struct iatt *buf, struct iatt *preparent,
+                       struct iatt *postparent, dict_t *xdata)
 {
-        int32_t           callcnt = 0;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        call_frame_t     *prev = NULL;
-        xlator_list_t    *trav = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    call_frame_t *prev = NULL;
+    xlator_list_t *trav = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        priv  = this->private;
-        local = frame->local;
+    prev = cookie;
+    priv = this->private;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                        local->op_errno = op_errno;
-                }
-                if (op_ret >= 0) {
-                        local->op_ret = op_ret;
-
-                        /* Can be used as a mechanism to understand if mknod
-                           was successful in at least one place */
-                        if (gf_uuid_is_null (local->ia_gfid))
-                                gf_uuid_copy (local->ia_gfid, buf->ia_gfid);
-
-			if (stripe_ctx_handle(this, prev, local, xdata))
-				gf_log(this->name, GF_LOG_ERROR,
-					"Error getting fctx info from dict");
-
-                        local->stbuf_blocks += buf->ia_blocks;
-                        local->preparent_blocks  += preparent->ia_blocks;
-                        local->postparent_blocks += postparent->ia_blocks;
-
-			correct_file_size(buf, local->fctx, prev);
-
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                        if (local->preparent_size < preparent->ia_size)
-                                local->preparent_size = preparent->ia_size;
-                        if (local->postparent_size < postparent->ia_size)
-                                local->postparent_size = postparent->ia_size;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
-
-                if ((local->op_ret == -1) && !gf_uuid_is_null (local->ia_gfid)) {
-                        /* ia_gfid set means, at least on one node 'mknod'
-                           is successful */
-                        local->call_count = priv->child_count;
-                        trav = this->children;
-                        while (trav) {
-                                STACK_WIND (frame,
-                                            stripe_mknod_ifreg_fail_unlink_cbk,
-                                            trav->xlator,
-                                            trav->xlator->fops->unlink,
-                                            &local->loc, 0, NULL);
-                                trav = trav->next;
-                        }
-                        return 0;
-                }
+        if (op_ret >= 0) {
+            local->op_ret = op_ret;
 
+            /* Can be used as a mechanism to understand if mknod
+               was successful in at least one place */
+            if (gf_uuid_is_null(local->ia_gfid))
+                gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
 
-                if (local->op_ret != -1) {
-                        local->preparent.ia_blocks  = local->preparent_blocks;
-                        local->preparent.ia_size    = local->preparent_size;
-                        local->postparent.ia_blocks = local->postparent_blocks;
-                        local->postparent.ia_size   = local->postparent_size;
-                        local->stbuf.ia_size        = local->stbuf_size;
-                        local->stbuf.ia_blocks      = local->stbuf_blocks;
-                        inode_ctx_put (local->inode, this,
-                                       (uint64_t)(long) local->fctx);
+            if (stripe_ctx_handle(this, prev, local, xdata))
+                gf_log(this->name, GF_LOG_ERROR,
+                       "Error getting fctx info from dict");
 
-                }
-                STRIPE_STACK_UNWIND (mknod, frame, local->op_ret, local->op_errno,
-                                     local->inode, &local->stbuf,
-                                     &local->preparent, &local->postparent, NULL);
+            local->stbuf_blocks += buf->ia_blocks;
+            local->preparent_blocks += preparent->ia_blocks;
+            local->postparent_blocks += postparent->ia_blocks;
+
+            correct_file_size(buf, local->fctx, prev);
+
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+            if (local->preparent_size < preparent->ia_size)
+                local->preparent_size = preparent->ia_size;
+            if (local->postparent_size < postparent->ia_size)
+                local->postparent_size = postparent->ia_size;
         }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
+
+        if ((local->op_ret == -1) && !gf_uuid_is_null(local->ia_gfid)) {
+            /* ia_gfid set means, at least on one node 'mknod'
+               is successful */
+            local->call_count = priv->child_count;
+            trav = this->children;
+            while (trav) {
+                STACK_WIND(frame, stripe_mknod_ifreg_fail_unlink_cbk,
+                           trav->xlator, trav->xlator->fops->unlink,
+                           &local->loc, 0, NULL);
+                trav = trav->next;
+            }
+            return 0;
+        }
+
+        if (local->op_ret != -1) {
+            local->preparent.ia_blocks = local->preparent_blocks;
+            local->preparent.ia_size = local->preparent_size;
+            local->postparent.ia_blocks = local->postparent_blocks;
+            local->postparent.ia_size = local->postparent_size;
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
+            inode_ctx_put(local->inode, this, (uint64_t)(long)local->fctx);
+        }
+        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, &local->preparent,
+                            &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_mknod_first_ifreg_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, inode_t *inode,
-                        struct iatt *buf, struct iatt *preparent,
-                        struct iatt *postparent, dict_t *xdata)
+stripe_mknod_first_ifreg_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, inode_t *inode,
+                             struct iatt *buf, struct iatt *preparent,
+                             struct iatt *postparent, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        call_frame_t     *prev = NULL;
-        xlator_list_t    *trav = NULL;
-        int               i    = 1;
-        dict_t           *dict           = NULL;
-        int               ret            = 0;
-        int               need_unref     = 0;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    call_frame_t *prev = NULL;
+    xlator_list_t *trav = NULL;
+    int i = 1;
+    dict_t *dict = NULL;
+    int ret = 0;
+    int need_unref = 0;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        priv  = this->private;
-        local = frame->local;
-        trav = this->children;
+    prev = cookie;
+    priv = this->private;
+    local = frame->local;
+    trav = this->children;
 
-        local->call_count--;
+    local->call_count--;
 
-        if (op_ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "%s returned error %s",
-                        prev->this->name, strerror (op_errno));
-                local->failed = 1;
-                local->op_errno = op_errno;
-                goto out;
-        }
+    if (op_ret == -1) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+               prev->this->name, strerror(op_errno));
+        local->failed = 1;
+        local->op_errno = op_errno;
+        goto out;
+    }
 
-        local->op_ret = op_ret;
+    local->op_ret = op_ret;
 
-        local->stbuf      = *buf;
-        local->preparent  = *preparent;
-        local->postparent = *postparent;
+    local->stbuf = *buf;
+    local->preparent = *preparent;
+    local->postparent = *postparent;
 
-        if (gf_uuid_is_null (local->ia_gfid))
-                gf_uuid_copy (local->ia_gfid, buf->ia_gfid);
-        local->preparent.ia_blocks  = local->preparent_blocks;
-        local->preparent.ia_size    = local->preparent_size;
-        local->postparent.ia_blocks = local->postparent_blocks;
-        local->postparent.ia_size   = local->postparent_size;
-        local->stbuf.ia_size        = local->stbuf_size;
-        local->stbuf.ia_blocks      = local->stbuf_blocks;
+    if (gf_uuid_is_null(local->ia_gfid))
+        gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
+    local->preparent.ia_blocks = local->preparent_blocks;
+    local->preparent.ia_size = local->preparent_size;
+    local->postparent.ia_blocks = local->postparent_blocks;
+    local->postparent.ia_size = local->postparent_size;
+    local->stbuf.ia_size = local->stbuf_size;
+    local->stbuf.ia_blocks = local->stbuf_blocks;
 
-        trav = trav->next;
-        while (trav) {
-                if (priv->xattr_supported) {
-                        dict = dict_new ();
-                        if (!dict) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to allocate dict %s", local->loc.path);
-                        }
-                        need_unref = 1;
-
-                        dict_copy (local->xattr, dict);
-
-                        ret = stripe_xattr_request_build (this, dict,
-                                                          local->stripe_size,
-                                                          priv->child_count, i,
-							  priv->coalesce);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Failed to build xattr request");
-
-                } else {
-                        dict = local->xattr;
-                }
-
-                STACK_WIND (frame, stripe_mknod_ifreg_cbk,
-                            trav->xlator, trav->xlator->fops->mknod,
-                            &local->loc, local->mode, local->rdev, 0, dict);
-                trav = trav->next;
-                i++;
+    trav = trav->next;
+    while (trav) {
+        if (priv->xattr_supported) {
+            dict = dict_new();
+            if (!dict) {
+                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
+                       local->loc.path);
+            }
+            need_unref = 1;
+
+            dict_copy(local->xattr, dict);
+
+            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
+                                             priv->child_count, i,
+                                             priv->coalesce);
+            if (ret)
+                gf_log(this->name, GF_LOG_ERROR,
+                       "Failed to build xattr request");
 
-                if (dict && need_unref)
-                        dict_unref (dict);
+        } else {
+            dict = local->xattr;
         }
 
-        return 0;
+        STACK_WIND(frame, stripe_mknod_ifreg_cbk, trav->xlator,
+                   trav->xlator->fops->mknod, &local->loc, local->mode,
+                   local->rdev, 0, dict);
+        trav = trav->next;
+        i++;
+
+        if (dict && need_unref)
+            dict_unref(dict);
+    }
+
+    return 0;
 
 out:
 
-       STRIPE_STACK_UNWIND (mknod, frame, op_ret, op_errno, NULL, NULL, NULL, NULL, NULL);
-       return 0;
+    STRIPE_STACK_UNWIND(mknod, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_single_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, inode_t *inode,
-                         struct iatt *buf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
+stripe_single_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, inode_t *inode,
+                        struct iatt *buf, struct iatt *preparent,
+                        struct iatt *postparent, dict_t *xdata)
 {
-        STRIPE_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent,
+                        postparent, xdata);
+    return 0;
 }
 
-
 int
-stripe_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-              dev_t rdev, mode_t umask, dict_t *xdata)
+stripe_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+             dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        stripe_private_t *priv           = NULL;
-        stripe_local_t   *local          = NULL;
-        int32_t           op_errno       = EINVAL;
-        int32_t           i              = 0;
-        dict_t           *dict           = NULL;
-        int               ret            = 0;
-        int               need_unref     = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
+    stripe_private_t *priv = NULL;
+    stripe_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
+    int32_t i = 0;
+    dict_t *dict = NULL;
+    int ret = 0;
+    int need_unref = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    if (S_ISREG(mode)) {
+        /* NOTE: on older kernels (older than 2.6.9),
+           creat() fops is sent as mknod() + open(). Hence handling
+           S_IFREG files is necessary */
+        if (priv->nodes_down) {
+            gf_log(this->name, GF_LOG_WARNING, "Some node down, returning EIO");
+            op_errno = EIO;
+            goto err;
         }
 
-        if (S_ISREG(mode)) {
-                /* NOTE: on older kernels (older than 2.6.9),
-                   creat() fops is sent as mknod() + open(). Hence handling
-                   S_IFREG files is necessary */
-                if (priv->nodes_down) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "Some node down, returning EIO");
-                        op_errno = EIO;
-                        goto err;
-                }
-
-                /* Initialization */
-                local = mem_get0 (this->local_pool);
-                if (!local) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                local->op_ret = -1;
-                local->op_errno = ENOTCONN;
-                local->stripe_size = stripe_get_matching_bs (loc->path, priv);
-                frame->local = local;
-                local->inode = inode_ref (loc->inode);
-                loc_copy (&local->loc, loc);
-                local->xattr = dict_copy_with_ref (xdata, NULL);
-                local->mode = mode;
-                local->umask = umask;
-                local->rdev = rdev;
-
-                /* Every time in stripe lookup, all child nodes should
-                   be looked up */
-                local->call_count = priv->child_count;
-
-                if (priv->xattr_supported) {
-                        dict = dict_new ();
-                        if (!dict) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to allocate dict %s", loc->path);
-                        }
-                        need_unref = 1;
-
-                        dict_copy (xdata, dict);
-
-                        ret = stripe_xattr_request_build (this, dict,
-                                                          local->stripe_size,
-                                                          priv->child_count,
-                                                          i, priv->coalesce);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to build xattr request");
-                } else {
-                        dict = xdata;
-                }
+        /* Initialization */
+        local = mem_get0(this->local_pool);
+        if (!local) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        local->op_ret = -1;
+        local->op_errno = ENOTCONN;
+        local->stripe_size = stripe_get_matching_bs(loc->path, priv);
+        frame->local = local;
+        local->inode = inode_ref(loc->inode);
+        loc_copy(&local->loc, loc);
+        local->xattr = dict_copy_with_ref(xdata, NULL);
+        local->mode = mode;
+        local->umask = umask;
+        local->rdev = rdev;
 
-                STACK_WIND (frame, stripe_mknod_first_ifreg_cbk,
-                            FIRST_CHILD (this), FIRST_CHILD (this)->fops->mknod,
-                            loc, mode, rdev, umask, dict);
+        /* Every time in stripe lookup, all child nodes should
+           be looked up */
+        local->call_count = priv->child_count;
 
-                        if (dict && need_unref)
-                                dict_unref (dict);
-                return 0;
+        if (priv->xattr_supported) {
+            dict = dict_new();
+            if (!dict) {
+                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
+                       loc->path);
+            }
+            need_unref = 1;
+
+            dict_copy(xdata, dict);
+
+            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
+                                             priv->child_count, i,
+                                             priv->coalesce);
+            if (ret)
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to build xattr request");
+        } else {
+            dict = xdata;
         }
 
-        STACK_WIND (frame, stripe_single_mknod_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,
-                    loc, mode, rdev, umask, xdata);
+        STACK_WIND(frame, stripe_mknod_first_ifreg_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask,
+                   dict);
 
+        if (dict && need_unref)
+            dict_unref(dict);
         return 0;
+    }
+
+    STACK_WIND(frame, stripe_single_mknod_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata);
+
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+stripe_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t  *local   = NULL;
-        call_frame_t    *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-
-        prev  = cookie;
-        local = frame->local;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-                if (op_ret >= 0) {
-                        local->op_ret = 0;
+    prev = cookie;
+    local = frame->local;
 
-                        local->stbuf_blocks      += buf->ia_blocks;
-                        local->preparent_blocks  += preparent->ia_blocks;
-                        local->postparent_blocks += postparent->ia_blocks;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                        if (local->preparent_size < preparent->ia_size)
-                                local->preparent_size = preparent->ia_size;
-                        if (local->postparent_size < postparent->ia_size)
-                                local->postparent_size = postparent->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed != -1) {
-                        local->preparent.ia_blocks  = local->preparent_blocks;
-                        local->preparent.ia_size    = local->preparent_size;
-                        local->postparent.ia_blocks = local->postparent_blocks;
-                        local->postparent.ia_size   = local->postparent_size;
-                        local->stbuf.ia_size        = local->stbuf_size;
-                        local->stbuf.ia_blocks      = local->stbuf_blocks;
-                }
-                STRIPE_STACK_UNWIND (mkdir, frame, local->op_ret,
-                                     local->op_errno, local->inode,
-                                     &local->stbuf, &local->preparent,
-                                     &local->postparent, NULL);
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
+
+        if (op_ret >= 0) {
+            local->op_ret = 0;
+
+            local->stbuf_blocks += buf->ia_blocks;
+            local->preparent_blocks += preparent->ia_blocks;
+            local->postparent_blocks += postparent->ia_blocks;
+
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+            if (local->preparent_size < preparent->ia_size)
+                local->preparent_size = preparent->ia_size;
+            if (local->postparent_size < postparent->ia_size)
+                local->postparent_size = postparent->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        if (local->failed != -1) {
+            local->preparent.ia_blocks = local->preparent_blocks;
+            local->preparent.ia_size = local->preparent_size;
+            local->postparent.ia_blocks = local->postparent_blocks;
+            local->postparent.ia_size = local->postparent_size;
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
+        }
+        STRIPE_STACK_UNWIND(mkdir, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, &local->preparent,
+                            &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_first_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, inode_t *inode,
-                        struct iatt *buf, struct iatt *preparent,
-                        struct iatt *postparent, dict_t *xdata)
+stripe_first_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, inode_t *inode,
+                       struct iatt *buf, struct iatt *preparent,
+                       struct iatt *postparent, dict_t *xdata)
 {
-        stripe_local_t  *local   = NULL;
-        call_frame_t    *prev = NULL;
-        xlator_list_t        *trav = NULL;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
+    xlator_list_t *trav = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
-        trav = this->children;
+    prev = cookie;
+    local = frame->local;
+    trav = this->children;
 
-        local->call_count--; /* first child is successful */
-        trav = trav->next;   /* skip first child */
+    local->call_count--; /* first child is successful */
+    trav = trav->next;   /* skip first child */
 
-        if (op_ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "%s returned error %s",
-                        prev->this->name, strerror (op_errno));
-                local->op_errno = op_errno;
-                goto out;
-        }
+    if (op_ret == -1) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+               prev->this->name, strerror(op_errno));
+        local->op_errno = op_errno;
+        goto out;
+    }
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-        local->inode      = inode_ref (inode);
-        local->stbuf      = *buf;
-        local->postparent = *postparent;
-        local->preparent  = *preparent;
+    local->inode = inode_ref(inode);
+    local->stbuf = *buf;
+    local->postparent = *postparent;
+    local->preparent = *preparent;
 
-        local->stbuf_blocks      += buf->ia_blocks;
-        local->preparent_blocks  += preparent->ia_blocks;
-        local->postparent_blocks += postparent->ia_blocks;
+    local->stbuf_blocks += buf->ia_blocks;
+    local->preparent_blocks += preparent->ia_blocks;
+    local->postparent_blocks += postparent->ia_blocks;
 
-        local->stbuf_size = buf->ia_size;
-        local->preparent_size = preparent->ia_size;
-        local->postparent_size = postparent->ia_size;
+    local->stbuf_size = buf->ia_size;
+    local->preparent_size = preparent->ia_size;
+    local->postparent_size = postparent->ia_size;
 
-        while (trav) {
-                STACK_WIND (frame, stripe_mkdir_cbk, trav->xlator,
-                            trav->xlator->fops->mkdir, &local->loc, local->mode,
-                            local->umask, local->xdata);
-                trav = trav->next;
-        }
-        return 0;
+    while (trav) {
+        STACK_WIND(frame, stripe_mkdir_cbk, trav->xlator,
+                   trav->xlator->fops->mkdir, &local->loc, local->mode,
+                   local->umask, local->xdata);
+        trav = trav->next;
+    }
+    return 0;
 out:
-        STRIPE_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                             NULL, NULL);
-
-        return 0;
+    STRIPE_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
 
+    return 0;
 }
 
-
 int
-stripe_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-              mode_t umask, dict_t *xdata)
+stripe_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+             mode_t umask, dict_t *xdata)
 {
-        stripe_private_t *priv = NULL;
-        stripe_local_t   *local = NULL;
-        xlator_list_t    *trav = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        local->call_count = priv->child_count;
-        if (xdata)
-                local->xdata = dict_ref (xdata);
-        local->mode  = mode;
-        local->umask = umask;
-        loc_copy (&local->loc, loc);
-        frame->local = local;
-
-        /* Every time in stripe lookup, all child nodes should be looked up */
-        STACK_WIND (frame, stripe_first_mkdir_cbk, trav->xlator,
-                    trav->xlator->fops->mkdir, loc, mode, umask, xdata);
-
-        return 0;
+    stripe_private_t *priv = NULL;
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    local->call_count = priv->child_count;
+    if (xdata)
+        local->xdata = dict_ref(xdata);
+    local->mode = mode;
+    local->umask = umask;
+    loc_copy(&local->loc, loc);
+    frame->local = local;
+
+    /* Every time in stripe lookup, all child nodes should be looked up */
+    STACK_WIND(frame, stripe_first_mkdir_cbk, trav->xlator,
+               trav->xlator->fops->mkdir, loc, mode, umask, xdata);
+
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
+stripe_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *buf, struct iatt *preparent,
+                struct iatt *postparent, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t  *local   = NULL;
-        call_frame_t    *prev = NULL;
-	stripe_fd_ctx_t *fctx = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret >= 0) {
-                        local->op_ret = 0;
-
-			if (IA_ISREG(inode->ia_type)) {
-				inode_ctx_get(inode, this, (uint64_t *) &fctx);
-				if (!fctx) {
-					gf_log(this->name, GF_LOG_ERROR,
-						"failed to get stripe context");
-					op_ret = -1;
-					op_errno = EINVAL;
-				}
-			}
-
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->inode      = inode_ref (inode);
-                                local->stbuf      = *buf;
-                                local->postparent = *postparent;
-                                local->preparent  = *preparent;
-                        }
-                        local->stbuf_blocks      += buf->ia_blocks;
-                        local->preparent_blocks  += preparent->ia_blocks;
-                        local->postparent_blocks += postparent->ia_blocks;
-
-			correct_file_size(buf, fctx, prev);
-
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                        if (local->preparent_size < preparent->ia_size)
-                                local->preparent_size = preparent->ia_size;
-                        if (local->postparent_size < postparent->ia_size)
-                                local->postparent_size = postparent->ia_size;
-                }
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
-
-                if (local->op_ret != -1) {
-                        local->preparent.ia_blocks  = local->preparent_blocks;
-                        local->preparent.ia_size    = local->preparent_size;
-                        local->postparent.ia_blocks = local->postparent_blocks;
-                        local->postparent.ia_size   = local->postparent_size;
-                        local->stbuf.ia_size        = local->stbuf_size;
-                        local->stbuf.ia_blocks      = local->stbuf_blocks;
+
+        if (op_ret >= 0) {
+            local->op_ret = 0;
+
+            if (IA_ISREG(inode->ia_type)) {
+                inode_ctx_get(inode, this, (uint64_t *)&fctx);
+                if (!fctx) {
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "failed to get stripe context");
+                    op_ret = -1;
+                    op_errno = EINVAL;
                 }
-                STRIPE_STACK_UNWIND (link, frame, local->op_ret,
-                                     local->op_errno, local->inode,
-                                     &local->stbuf, &local->preparent,
-                                     &local->postparent, NULL);
-        }
+            }
+
+            if (FIRST_CHILD(this) == prev->this) {
+                local->inode = inode_ref(inode);
+                local->stbuf = *buf;
+                local->postparent = *postparent;
+                local->preparent = *preparent;
+            }
+            local->stbuf_blocks += buf->ia_blocks;
+            local->preparent_blocks += preparent->ia_blocks;
+            local->postparent_blocks += postparent->ia_blocks;
+
+            correct_file_size(buf, fctx, prev);
+
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+            if (local->preparent_size < preparent->ia_size)
+                local->preparent_size = preparent->ia_size;
+            if (local->postparent_size < postparent->ia_size)
+                local->postparent_size = postparent->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
+
+        if (local->op_ret != -1) {
+            local->preparent.ia_blocks = local->preparent_blocks;
+            local->preparent.ia_size = local->preparent_size;
+            local->postparent.ia_blocks = local->postparent_blocks;
+            local->postparent.ia_size = local->postparent_size;
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
+        }
+        STRIPE_STACK_UNWIND(link, frame, local->op_ret, local->op_errno,
+                            local->inode, &local->stbuf, &local->preparent,
+                            &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+stripe_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+            dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (oldloc, err);
-        VALIDATE_OR_GOTO (oldloc->path, err);
-        VALIDATE_OR_GOTO (oldloc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* If any one node is down, don't allow link operation */
-        if (priv->nodes_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-        /* Every time in stripe lookup, all child
-           nodes should be looked up */
-        while (trav) {
-                STACK_WIND (frame, stripe_link_cbk,
-                            trav->xlator, trav->xlator->fops->link,
-                            oldloc, newloc, NULL);
-                trav = trav->next;
-        }
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(oldloc, err);
+    VALIDATE_OR_GOTO(oldloc->path, err);
+    VALIDATE_OR_GOTO(oldloc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* If any one node is down, don't allow link operation */
+    if (priv->nodes_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    /* Every time in stripe lookup, all child
+       nodes should be looked up */
+    while (trav) {
+        STACK_WIND(frame, stripe_link_cbk, trav->xlator,
+                   trav->xlator->fops->link, oldloc, newloc, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL);
+    return 0;
 }
 
 int32_t
-stripe_create_fail_unlink_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this, int32_t op_ret,
-                               int32_t op_errno, struct iatt *preparent,
-                               struct iatt *postparent, dict_t *xdata)
+stripe_create_fail_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno,
+                              struct iatt *preparent, struct iatt *postparent,
+                              dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
 
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                STRIPE_STACK_UNWIND (create, frame, local->op_ret, local->op_errno,
-                                     local->fd, local->inode, &local->stbuf,
-                                     &local->preparent, &local->postparent, NULL);
-        }
+    if (!callcnt) {
+        STRIPE_STACK_UNWIND(create, frame, local->op_ret, local->op_errno,
+                            local->fd, local->inode, &local->stbuf,
+                            &local->preparent, &local->postparent, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd,
-                   inode_t *inode, struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+stripe_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        int32_t           callcnt = 0;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        call_frame_t     *prev = NULL;
-        xlator_list_t    *trav = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    call_frame_t *prev = NULL;
+    xlator_list_t *trav = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        priv  = this->private;
-        local = frame->local;
+    prev = cookie;
+    priv = this->private;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->failed = 1;
-                        local->op_errno = op_errno;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret >= 0) {
-			if (IA_ISREG(buf->ia_type)) {
-				if (stripe_ctx_handle(this, prev, local, xdata))
-					gf_log(this->name, GF_LOG_ERROR,
-						"Error getting fctx info from "
-						"dict");
-			}
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->failed = 1;
+            local->op_errno = op_errno;
+        }
 
-                        local->op_ret = op_ret;
+        if (op_ret >= 0) {
+            if (IA_ISREG(buf->ia_type)) {
+                if (stripe_ctx_handle(this, prev, local, xdata))
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "Error getting fctx info from "
+                           "dict");
+            }
 
-                        local->stbuf_blocks += buf->ia_blocks;
-                        local->preparent_blocks  += preparent->ia_blocks;
-                        local->postparent_blocks += postparent->ia_blocks;
+            local->op_ret = op_ret;
 
-			correct_file_size(buf, local->fctx, prev);
+            local->stbuf_blocks += buf->ia_blocks;
+            local->preparent_blocks += preparent->ia_blocks;
+            local->postparent_blocks += postparent->ia_blocks;
 
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                        if (local->preparent_size < preparent->ia_size)
-                                local->preparent_size = preparent->ia_size;
-                        if (local->postparent_size < postparent->ia_size)
-                                local->postparent_size = postparent->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
-
-                if (local->op_ret == -1) {
-                        local->call_count = priv->child_count;
-                        trav = this->children;
-                        while (trav) {
-                                STACK_WIND (frame,
-                                            stripe_create_fail_unlink_cbk,
-                                            trav->xlator,
-                                            trav->xlator->fops->unlink,
-                                            &local->loc, 0, NULL);
-                                trav = trav->next;
-                        }
-
-                        return 0;
-                }
-
-                if (local->op_ret >= 0) {
-                        local->preparent.ia_blocks  = local->preparent_blocks;
-                        local->preparent.ia_size    = local->preparent_size;
-                        local->postparent.ia_blocks = local->postparent_blocks;
-                        local->postparent.ia_size   = local->postparent_size;
-                        local->stbuf.ia_size        = local->stbuf_size;
-                        local->stbuf.ia_blocks      = local->stbuf_blocks;
-
-			stripe_copy_xl_array(local->fctx->xl_array,
-				             priv->xl_array,
-					     local->fctx->stripe_count);
-			inode_ctx_put(local->inode, this,
-					(uint64_t) local->fctx);
-                }
+            correct_file_size(buf, local->fctx, prev);
 
-                /* Create itself has failed.. so return
-                   without setxattring */
-                STRIPE_STACK_UNWIND (create, frame, local->op_ret,
-                                     local->op_errno, local->fd,
-                                     local->inode, &local->stbuf,
-                                     &local->preparent, &local->postparent, NULL);
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+            if (local->preparent_size < preparent->ia_size)
+                local->preparent_size = preparent->ia_size;
+            if (local->postparent_size < postparent->ia_size)
+                local->postparent_size = postparent->ia_size;
         }
+    }
+    UNLOCK(&frame->lock);
 
-out:
-        return 0;
-}
-
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
+        if (local->op_ret == -1) {
+            local->call_count = priv->child_count;
+            trav = this->children;
+            while (trav) {
+                STACK_WIND(frame, stripe_create_fail_unlink_cbk, trav->xlator,
+                           trav->xlator->fops->unlink, &local->loc, 0, NULL);
+                trav = trav->next;
+            }
 
-int32_t
-stripe_first_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd,
-                   inode_t *inode, struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
-{
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        call_frame_t     *prev = NULL;
-        xlator_list_t    *trav = NULL;
-        int               i    = 1;
-        dict_t           *dict = NULL;
-        loc_t            *loc  = NULL;
-        int32_t           need_unref = 0;
-        int32_t           ret  = -1;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
+            return 0;
         }
 
-        prev  = cookie;
-        priv  = this->private;
-        local = frame->local;
-        trav = this->children;
-        loc = &local->loc;
-
-        --local->call_count;
+        if (local->op_ret >= 0) {
+            local->preparent.ia_blocks = local->preparent_blocks;
+            local->preparent.ia_size = local->preparent_size;
+            local->postparent.ia_blocks = local->postparent_blocks;
+            local->postparent.ia_size = local->postparent_size;
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
 
-        if (op_ret == -1) {
-                gf_log (this->name, GF_LOG_DEBUG, "%s returned error %s",
-                        prev->this->name, strerror (op_errno));
-                 local->failed = 1;
-                 local->op_errno = op_errno;
+            stripe_copy_xl_array(local->fctx->xl_array, priv->xl_array,
+                                 local->fctx->stripe_count);
+            inode_ctx_put(local->inode, this, (uint64_t)local->fctx);
         }
 
-        local->op_ret = 0;
-        /* Get the mapping in inode private */
-        /* Get the stat buf right */
-        local->stbuf      = *buf;
-        local->preparent  = *preparent;
-        local->postparent = *postparent;
+        /* Create itself has failed.. so return
+           without setxattring */
+        STRIPE_STACK_UNWIND(create, frame, local->op_ret, local->op_errno,
+                            local->fd, local->inode, &local->stbuf,
+                            &local->preparent, &local->postparent, NULL);
+    }
 
-        local->stbuf_blocks += buf->ia_blocks;
-        local->preparent_blocks  += preparent->ia_blocks;
-        local->postparent_blocks += postparent->ia_blocks;
+out:
+    return 0;
+}
 
-        if (local->stbuf_size < buf->ia_size)
-              local->stbuf_size = buf->ia_size;
-        if (local->preparent_size < preparent->ia_size)
-              local->preparent_size = preparent->ia_size;
-        if (local->postparent_size < postparent->ia_size)
-              local->postparent_size = postparent->ia_size;
+int32_t
+stripe_first_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, fd_t *fd,
+                        inode_t *inode, struct iatt *buf,
+                        struct iatt *preparent, struct iatt *postparent,
+                        dict_t *xdata)
+{
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    call_frame_t *prev = NULL;
+    xlator_list_t *trav = NULL;
+    int i = 1;
+    dict_t *dict = NULL;
+    loc_t *loc = NULL;
+    int32_t need_unref = 0;
+    int32_t ret = -1;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+
+    prev = cookie;
+    priv = this->private;
+    local = frame->local;
+    trav = this->children;
+    loc = &local->loc;
+
+    --local->call_count;
+
+    if (op_ret == -1) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+               prev->this->name, strerror(op_errno));
+        local->failed = 1;
+        local->op_errno = op_errno;
+    }
+
+    local->op_ret = 0;
+    /* Get the mapping in inode private */
+    /* Get the stat buf right */
+    local->stbuf = *buf;
+    local->preparent = *preparent;
+    local->postparent = *postparent;
+
+    local->stbuf_blocks += buf->ia_blocks;
+    local->preparent_blocks += preparent->ia_blocks;
+    local->postparent_blocks += postparent->ia_blocks;
+
+    if (local->stbuf_size < buf->ia_size)
+        local->stbuf_size = buf->ia_size;
+    if (local->preparent_size < preparent->ia_size)
+        local->preparent_size = preparent->ia_size;
+    if (local->postparent_size < postparent->ia_size)
+        local->postparent_size = postparent->ia_size;
 
-        if (local->failed)
-                local->op_ret = -1;
+    if (local->failed)
+        local->op_ret = -1;
 
-        if (local->op_ret == -1) {
-                local->call_count = 1;
-                STACK_WIND (frame, stripe_create_fail_unlink_cbk,
-                            FIRST_CHILD (this), FIRST_CHILD (this)->fops->unlink,
-                            &local->loc, 0, NULL);
-                return 0;
-        }
+    if (local->op_ret == -1) {
+        local->call_count = 1;
+        STACK_WIND(frame, stripe_create_fail_unlink_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
+        return 0;
+    }
 
-        if (local->op_ret >= 0) {
-                local->preparent.ia_blocks  = local->preparent_blocks;
-                local->preparent.ia_size    = local->preparent_size;
-                local->postparent.ia_blocks = local->postparent_blocks;
-                local->postparent.ia_size   = local->postparent_size;
-                local->stbuf.ia_size        = local->stbuf_size;
-                local->stbuf.ia_blocks      = local->stbuf_blocks;
+    if (local->op_ret >= 0) {
+        local->preparent.ia_blocks = local->preparent_blocks;
+        local->preparent.ia_size = local->preparent_size;
+        local->postparent.ia_blocks = local->postparent_blocks;
+        local->postparent.ia_size = local->postparent_size;
+        local->stbuf.ia_size = local->stbuf_size;
+        local->stbuf.ia_blocks = local->stbuf_blocks;
+    }
+
+    /* Send a setxattr request to nodes where the
+       files are created */
+    trav = trav->next;
+    while (trav) {
+        if (priv->xattr_supported) {
+            dict = dict_new();
+            if (!dict) {
+                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
+                       loc->path);
+            }
+            need_unref = 1;
+
+            dict_copy(local->xattr, dict);
+
+            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
+                                             priv->child_count, i,
+                                             priv->coalesce);
+            if (ret)
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to build xattr request");
+        } else {
+            dict = local->xattr;
         }
 
-        /* Send a setxattr request to nodes where the
-           files are created */
+        STACK_WIND(frame, stripe_create_cbk, trav->xlator,
+                   trav->xlator->fops->create, &local->loc, local->flags,
+                   local->mode, local->umask, local->fd, dict);
         trav = trav->next;
-        while (trav) {
-                if (priv->xattr_supported) {
-                        dict = dict_new ();
-                        if (!dict) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to allocate dict %s", loc->path);
-                        }
-                        need_unref = 1;
-
-                        dict_copy (local->xattr, dict);
-
-                        ret = stripe_xattr_request_build (this, dict,
-                                                          local->stripe_size,
-                                                          priv->child_count,
-                                                          i, priv->coalesce);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "failed to build xattr request");
-                } else {
-                        dict = local->xattr;
-                }
-
-                STACK_WIND (frame, stripe_create_cbk, trav->xlator,
-                            trav->xlator->fops->create, &local->loc,
-                            local->flags, local->mode, local->umask, local->fd,
-                            dict);
-                trav = trav->next;
-                if (need_unref && dict)
-                        dict_unref (dict);
-                i++;
-        }
+        if (need_unref && dict)
+            dict_unref(dict);
+        i++;
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
-
-
 /**
  * stripe_create - If a block-size is specified for the 'name', create the
  *    file in all the child nodes. If not, create it in only first child.
@@ -2324,958 +2250,928 @@ out:
  * @name- complete path of the file to be created.
  */
 int32_t
-stripe_create (call_frame_t *frame, xlator_t *this, loc_t *loc,
-               int32_t flags, mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+stripe_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+              mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        stripe_private_t *priv = NULL;
-        stripe_local_t   *local = NULL;
-        int32_t           op_errno = EINVAL;
-        int               ret            = 0;
-        int               need_unref     = 0;
-        int               i              = 0;
-        dict_t           *dict           = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-
-        /* files created in O_APPEND mode does not allow lseek() on fd */
-        flags &= ~O_APPEND;
-
-        if (priv->first_child_down || priv->nodes_down) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "First node down, returning EIO");
-                op_errno = EIO;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        local->op_errno = ENOTCONN;
-        local->stripe_size = stripe_get_matching_bs (loc->path, priv);
-        frame->local = local;
-        local->inode = inode_ref (loc->inode);
-        loc_copy (&local->loc, loc);
-        local->fd = fd_ref (fd);
-        local->flags = flags;
-        local->mode = mode;
-        local->umask = umask;
-        if (xdata)
-                local->xattr = dict_ref (xdata);
-
-        local->call_count = priv->child_count;
-        /* Send a setxattr request to nodes where the
-           files are created */
-
-        if (priv->xattr_supported) {
-                dict = dict_new ();
-                if (!dict) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "failed to allocate dict %s", loc->path);
-                }
-                need_unref = 1;
-
-                dict_copy (xdata, dict);
-
-                ret = stripe_xattr_request_build (this, dict,
-                                                  local->stripe_size,
-                                                  priv->child_count,
-                                                  i, priv->coalesce);
-                if (ret)
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "failed to build xattr request");
-        } else {
-                        dict = xdata;
-        }
-
-
-        STACK_WIND (frame, stripe_first_create_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->create, loc, flags, mode,
-                    umask, fd, dict);
+    stripe_private_t *priv = NULL;
+    stripe_local_t *local = NULL;
+    int32_t op_errno = EINVAL;
+    int ret = 0;
+    int need_unref = 0;
+    int i = 0;
+    dict_t *dict = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+
+    /* files created in O_APPEND mode does not allow lseek() on fd */
+    flags &= ~O_APPEND;
+
+    if (priv->first_child_down || priv->nodes_down) {
+        gf_log(this->name, GF_LOG_DEBUG, "First node down, returning EIO");
+        op_errno = EIO;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    local->op_errno = ENOTCONN;
+    local->stripe_size = stripe_get_matching_bs(loc->path, priv);
+    frame->local = local;
+    local->inode = inode_ref(loc->inode);
+    loc_copy(&local->loc, loc);
+    local->fd = fd_ref(fd);
+    local->flags = flags;
+    local->mode = mode;
+    local->umask = umask;
+    if (xdata)
+        local->xattr = dict_ref(xdata);
+
+    local->call_count = priv->child_count;
+    /* Send a setxattr request to nodes where the
+       files are created */
+
+    if (priv->xattr_supported) {
+        dict = dict_new();
+        if (!dict) {
+            gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
+                   loc->path);
+        }
+        need_unref = 1;
+
+        dict_copy(xdata, dict);
+
+        ret = stripe_xattr_request_build(this, dict, local->stripe_size,
+                                         priv->child_count, i, priv->coalesce);
+        if (ret)
+            gf_log(this->name, GF_LOG_ERROR, "failed to build xattr request");
+    } else {
+        dict = xdata;
+    }
 
-        if (need_unref && dict)
-                dict_unref (dict);
+    STACK_WIND(frame, stripe_first_create_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
+               dict);
 
+    if (need_unref && dict)
+        dict_unref(dict);
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL,
-                             NULL, NULL, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                        NULL, xdata);
+    return 0;
 }
 
 int32_t
-stripe_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+stripe_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-
-        prev  = cookie;
-        local = frame->local;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-                if (op_ret == -1) {
+    prev = cookie;
+    local = frame->local;
 
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                        local->op_errno = op_errno;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret >= 0)
-                        local->op_ret = op_ret;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+        if (op_ret >= 0)
+            local->op_ret = op_ret;
+    }
+    UNLOCK(&frame->lock);
 
-                STRIPE_STACK_UNWIND (open, frame, local->op_ret,
-                                     local->op_errno, local->fd, xdata);
-        }
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
+
+        STRIPE_STACK_UNWIND(open, frame, local->op_ret, local->op_errno,
+                            local->fd, xdata);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 /**
  * stripe_open -
  */
 int32_t
-stripe_open (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             int32_t flags, fd_t *fd, dict_t *xdata)
+stripe_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+            fd_t *fd, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        /* files opened in O_APPEND mode does not allow lseek() on fd */
-        flags &= ~O_APPEND;
-
-        local->fd = fd_ref (fd);
-        frame->local = local;
-        loc_copy (&local->loc, loc);
-
-        /* Striped files */
-        local->flags = flags;
-        local->call_count = priv->child_count;
-        local->stripe_size = stripe_get_matching_bs (loc->path, priv);
-
-        while (trav) {
-                STACK_WIND (frame, stripe_open_cbk, trav->xlator,
-                            trav->xlator->fops->open,
-                            &local->loc, local->flags, local->fd,
-                            xdata);
-                trav = trav->next;
-        }
-        return 0;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    /* files opened in O_APPEND mode does not allow lseek() on fd */
+    flags &= ~O_APPEND;
+
+    local->fd = fd_ref(fd);
+    frame->local = local;
+    loc_copy(&local->loc, loc);
+
+    /* Striped files */
+    local->flags = flags;
+    local->call_count = priv->child_count;
+    local->stripe_size = stripe_get_matching_bs(loc->path, priv);
+
+    while (trav) {
+        STACK_WIND(frame, stripe_open_cbk, trav->xlator,
+                   trav->xlator->fops->open, &local->loc, local->flags,
+                   local->fd, xdata);
+        trav = trav->next;
+    }
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (open, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+stripe_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_ret = -1;
-                        local->op_errno = op_errno;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret >= 0)
-                        local->op_ret = op_ret;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_ret = -1;
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
 
-        if (!callcnt) {
-                STRIPE_STACK_UNWIND (opendir, frame, local->op_ret,
-                                     local->op_errno, local->fd, NULL);
-        }
+        if (op_ret >= 0)
+            local->op_ret = op_ret;
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        STRIPE_STACK_UNWIND(opendir, frame, local->op_ret, local->op_errno,
+                            local->fd, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata)
+stripe_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+               dict_t *xdata)
 {
-        xlator_list_t    *trav = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-        local->call_count = priv->child_count;
-        local->fd = fd_ref (fd);
-
-        while (trav) {
-                STACK_WIND (frame, stripe_opendir_cbk, trav->xlator,
-                            trav->xlator->fops->opendir, loc, fd, NULL);
-                trav = trav->next;
-        }
+    xlator_list_t *trav = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+    local->call_count = priv->child_count;
+    local->fd = fd_ref(fd);
+
+    while (trav) {
+        STACK_WIND(frame, stripe_opendir_cbk, trav->xlator,
+                   trav->xlator->fops->opendir, loc, fd, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (opendir, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(opendir, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
+stripe_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
-                if (op_ret >= 0) {
-                        if (FIRST_CHILD(this) == prev->this) {
-                                /* First successful call, copy the *lock */
-                                local->op_ret = op_ret;
-                                local->lock = *lock;
-                        }
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
-                STRIPE_STACK_UNWIND (lk, frame, local->op_ret,
-                                     local->op_errno, &local->lock, NULL);
+        if (op_ret >= 0) {
+            if (FIRST_CHILD(this) == prev->this) {
+                /* First successful call, copy the *lock */
+                local->op_ret = op_ret;
+                local->lock = *lock;
+            }
         }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
+        STRIPE_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno,
+                            &local->lock, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-           struct gf_flock *lock, dict_t *xdata)
+stripe_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+          struct gf_flock *lock, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        xlator_list_t    *trav = NULL;
-        stripe_private_t *priv = NULL;
-        int32_t           op_errno = EINVAL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        trav = this->children;
-        priv = this->private;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-        while (trav) {
-                STACK_WIND (frame, stripe_lk_cbk, trav->xlator,
-                            trav->xlator->fops->lk, fd, cmd, lock, NULL);
-                trav = trav->next;
-        }
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    trav = this->children;
+    priv = this->private;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    while (trav) {
+        STACK_WIND(frame, stripe_lk_cbk, trav->xlator, trav->xlator->fops->lk,
+                   fd, cmd, lock, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (lk, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+stripe_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
-                if (op_ret >= 0)
-                        local->op_ret = op_ret;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+                   strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
-        UNLOCK (&frame->lock);
+        if (op_ret >= 0)
+            local->op_ret = op_ret;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (flush, frame, local->op_ret,
-                                     local->op_errno, NULL);
-        }
+        STRIPE_STACK_UNWIND(flush, frame, local->op_ret, local->op_errno, NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+stripe_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-        while (trav) {
-                STACK_WIND (frame, stripe_flush_cbk,  trav->xlator,
-                            trav->xlator->fops->flush, fd, NULL);
-                trav = trav->next;
-        }
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    while (trav) {
+        STACK_WIND(frame, stripe_flush_cbk, trav->xlator,
+                   trav->xlator->fops->flush, fd, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (flush, frame, -1, op_errno, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
-
 int32_t
-stripe_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
+stripe_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                 struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
-                if (op_ret >= 0) {
-                        local->op_ret = op_ret;
-                        if (FIRST_CHILD(this) == prev->this) {
-                                local->pre_buf  = *prebuf;
-                                local->post_buf = *postbuf;
-                        }
-                        local->prebuf_blocks  += prebuf->ia_blocks;
-                        local->postbuf_blocks += postbuf->ia_blocks;
-
-			correct_file_size(prebuf, local->fctx, prev);
-			correct_file_size(postbuf, local->fctx, prev);
-
-                        if (local->prebuf_size < prebuf->ia_size)
-                                local->prebuf_size = prebuf->ia_size;
-
-                        if (local->postbuf_size < postbuf->ia_size)
-                                local->postbuf_size = postbuf->ia_size;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+                   strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
-        UNLOCK (&frame->lock);
+        if (op_ret >= 0) {
+            local->op_ret = op_ret;
+            if (FIRST_CHILD(this) == prev->this) {
+                local->pre_buf = *prebuf;
+                local->post_buf = *postbuf;
+            }
+            local->prebuf_blocks += prebuf->ia_blocks;
+            local->postbuf_blocks += postbuf->ia_blocks;
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+            correct_file_size(prebuf, local->fctx, prev);
+            correct_file_size(postbuf, local->fctx, prev);
 
-                if (local->op_ret != -1) {
-                        local->pre_buf.ia_blocks  = local->prebuf_blocks;
-                        local->pre_buf.ia_size    = local->prebuf_size;
-                        local->post_buf.ia_blocks = local->postbuf_blocks;
-                        local->post_buf.ia_size   = local->postbuf_size;
-                }
+            if (local->prebuf_size < prebuf->ia_size)
+                local->prebuf_size = prebuf->ia_size;
 
-                STRIPE_STACK_UNWIND (fsync, frame, local->op_ret,
-                                     local->op_errno, &local->pre_buf,
-                                     &local->post_buf, NULL);
+            if (local->postbuf_size < postbuf->ia_size)
+                local->postbuf_size = postbuf->ia_size;
         }
-out:
-        return 0;
-}
+    }
+    UNLOCK(&frame->lock);
 
-int32_t
-stripe_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata)
-{
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-	stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-        trav = this->children;
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+        if (local->op_ret != -1) {
+            local->pre_buf.ia_blocks = local->prebuf_blocks;
+            local->pre_buf.ia_size = local->prebuf_size;
+            local->post_buf.ia_blocks = local->postbuf_blocks;
+            local->post_buf.ia_size = local->postbuf_size;
         }
 
-        frame->local = local;
-
-	inode_ctx_get(fd->inode, this, (uint64_t *) &fctx);
-	if (!fctx) {
-		op_errno = EINVAL;
-		goto err;
-	}
-	local->fctx = fctx;
-        local->op_ret = -1;
-        local->call_count = priv->child_count;
+        STRIPE_STACK_UNWIND(fsync, frame, local->op_ret, local->op_errno,
+                            &local->pre_buf, &local->post_buf, NULL);
+    }
+out:
+    return 0;
+}
 
-        while (trav) {
-                STACK_WIND (frame, stripe_fsync_cbk, trav->xlator,
-                            trav->xlator->fops->fsync, fd, flags, NULL);
-                trav = trav->next;
-        }
+int32_t
+stripe_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+             dict_t *xdata)
+{
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    frame->local = local;
+
+    inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
+    if (!fctx) {
+        op_errno = EINVAL;
+        goto err;
+    }
+    local->fctx = fctx;
+    local->op_ret = -1;
+    local->call_count = priv->child_count;
+
+    while (trav) {
+        STACK_WIND(frame, stripe_fsync_cbk, trav->xlator,
+                   trav->xlator->fops->fsync, fd, flags, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (fsync, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata)
+stripe_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned error %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
 
-                if (op_ret == 0) {
-                        local->op_ret = 0;
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
+                   prev->this->name, strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
+        }
 
-                        if (FIRST_CHILD(this) == prev->this)
-                                local->stbuf = *buf;
+        if (op_ret == 0) {
+            local->op_ret = 0;
 
-                        local->stbuf_blocks += buf->ia_blocks;
+            if (FIRST_CHILD(this) == prev->this)
+                local->stbuf = *buf;
 
-			correct_file_size(buf, local->fctx, prev);
+            local->stbuf_blocks += buf->ia_blocks;
 
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
+            correct_file_size(buf, local->fctx, prev);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
 
-                if (local->op_ret != -1) {
-                        local->stbuf.ia_size   = local->stbuf_size;
-                        local->stbuf.ia_blocks = local->stbuf_blocks;
-                }
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (fstat, frame, local->op_ret,
-                                     local->op_errno, &local->stbuf, NULL);
+        if (local->op_ret != -1) {
+            local->stbuf.ia_size = local->stbuf_size;
+            local->stbuf.ia_blocks = local->stbuf_blocks;
         }
 
+        STRIPE_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno,
+                            &local->stbuf, NULL);
+    }
+
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_fstat (call_frame_t *frame,
-              xlator_t *this,
-              fd_t *fd, dict_t *xdata)
+stripe_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-	stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-	if (IA_ISREG(fd->inode->ia_type)) {
-		inode_ctx_get(fd->inode, this, (uint64_t *) &fctx);
-		if (!fctx)
-			goto err;
-		local->fctx = fctx;
-	}
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    if (IA_ISREG(fd->inode->ia_type)) {
+        inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
+        if (!fctx)
+            goto err;
+        local->fctx = fctx;
+    }
 
-        while (trav) {
-                STACK_WIND (frame, stripe_fstat_cbk, trav->xlator,
-                            trav->xlator->fops->fstat, fd, NULL);
-                trav = trav->next;
-        }
+    while (trav) {
+        STACK_WIND(frame, stripe_fstat_cbk, trav->xlator,
+                   trav->xlator->fops->fstat, fd, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, dict_t *xdata)
+stripe_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                 dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-	stripe_fd_ctx_t  *fctx = NULL;
-	int		  i, eof_idx;
-	off_t		  dest_offset, tmp_offset;
-        int32_t		  op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int i, eof_idx;
+    off_t dest_offset, tmp_offset;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
+    if (!fctx) {
+        gf_log(this->name, GF_LOG_ERROR, "no stripe context");
+        op_errno = EINVAL;
+        goto err;
+    }
+    if (!fctx->stripe_count) {
+        gf_log(this->name, GF_LOG_ERROR, "no stripe count");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    local->fctx = fctx;
+    eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
+
+    for (i = 0; i < fctx->stripe_count; i++) {
+        if (!fctx->xl_array[i]) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "no xlator at index "
+                   "%d",
+                   i);
+            op_errno = EINVAL;
+            goto err;
+        }
+
+        if (fctx->stripe_coalesce) {
+            if (i < eof_idx)
+                tmp_offset = roof(offset,
+                                  fctx->stripe_size * fctx->stripe_count);
+            else if (i > eof_idx)
+                tmp_offset = floor(offset,
+                                   fctx->stripe_size * fctx->stripe_count);
+            else
+                tmp_offset = offset;
+
+            dest_offset = coalesced_offset(tmp_offset, fctx->stripe_size,
+                                           fctx->stripe_count);
+        } else {
+            dest_offset = offset;
         }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
 
-	inode_ctx_get(fd->inode, this, (uint64_t *) &fctx);
-	if (!fctx) {
-		gf_log(this->name, GF_LOG_ERROR, "no stripe context");
-		op_errno = EINVAL;
-		goto err;
-	}
-	if (!fctx->stripe_count) {
-		gf_log(this->name, GF_LOG_ERROR, "no stripe count");
-		op_errno = EINVAL;
-		goto err;
-	}
-
-	local->fctx = fctx;
-	eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
-
-	for (i = 0; i < fctx->stripe_count; i++) {
-		if (!fctx->xl_array[i]) {
-			gf_log(this->name, GF_LOG_ERROR, "no xlator at index "
-				"%d", i);
-			op_errno = EINVAL;
-			goto err;
-		}
-
-		if (fctx->stripe_coalesce) {
-			if (i < eof_idx)
-				tmp_offset = roof(offset, fctx->stripe_size *
-						fctx->stripe_count);
-			else if (i > eof_idx)
-				tmp_offset = floor(offset, fctx->stripe_size *
-						fctx->stripe_count);
-			else
-				tmp_offset = offset;
-
-			dest_offset = coalesced_offset(tmp_offset,
-				fctx->stripe_size, fctx->stripe_count);
-		} else {
-			dest_offset = offset;
-		}
-
-		STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
-			fctx->xl_array[i]->fops->ftruncate, fd, dest_offset,
-			NULL);
-	}
+        STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
+                   fctx->xl_array[i]->fops->ftruncate, fd, dest_offset, NULL);
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+stripe_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local   = NULL;
-        call_frame_t   *prev = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
 
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
+    prev = cookie;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-
-                if (op_ret == -1) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s returned %s",
-                                prev->this->name, strerror (op_errno));
-                        local->op_errno = op_errno;
-                        if ((op_errno != ENOENT) ||
-                            (prev->this == FIRST_CHILD (this)))
-                                local->failed = 1;
-                }
-                if (op_ret >= 0)
-                        local->op_ret = op_ret;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+
+        if (op_ret == -1) {
+            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
+                   strerror(op_errno));
+            local->op_errno = op_errno;
+            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
+                local->failed = 1;
         }
-        UNLOCK (&frame->lock);
+        if (op_ret >= 0)
+            local->op_ret = op_ret;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!callcnt) {
-                if (local->failed)
-                        local->op_ret = -1;
+    if (!callcnt) {
+        if (local->failed)
+            local->op_ret = -1;
 
-                STRIPE_STACK_UNWIND (fsyncdir, frame, local->op_ret,
-                                     local->op_errno, NULL);
-        }
+        STRIPE_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
+                            NULL);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata)
+stripe_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+                dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t    *trav = NULL;
-        int32_t           op_errno = 1;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        local->op_ret = -1;
-        frame->local = local;
-        local->call_count = priv->child_count;
-
-        while (trav) {
-                STACK_WIND (frame, stripe_fsyncdir_cbk, trav->xlator,
-                            trav->xlator->fops->fsyncdir, fd, flags, NULL);
-                trav = trav->next;
-        }
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    int32_t op_errno = 1;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    local->call_count = priv->child_count;
+
+    while (trav) {
+        STACK_WIND(frame, stripe_fsyncdir_cbk, trav->xlator,
+                   trav->xlator->fops->fsyncdir, fd, flags, NULL);
+        trav = trav->next;
+    }
 
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (fsyncdir, frame, -1, op_errno, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_readv_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata)
+stripe_readv_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                       dict_t *xdata)
 {
-        int32_t         i = 0;
-        int32_t         callcnt = 0;
-        int32_t         count = 0;
-        stripe_local_t *local = NULL;
-        struct iovec   *vec = NULL;
-        struct iatt     tmp_stbuf = {0,};
-        struct iobref  *tmp_iobref = NULL;
-        struct iobuf   *iobuf = NULL;
-	call_frame_t   *prev = NULL;
-
-        if (!this || !frame || !frame->local) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-
-        local = frame->local;
-	prev = cookie;
-
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->call_count;
-                if (op_ret != -1) {
-			correct_file_size(buf, local->fctx, prev);
-                        if (local->stbuf_size < buf->ia_size)
-                                local->stbuf_size = buf->ia_size;
-		}
-        }
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                op_ret = 0;
-
-                /* Keep extra space for filling in '\0's */
-                vec = GF_CALLOC ((local->count * 2), sizeof (struct iovec),
-                                 gf_stripe_mt_iovec);
-                if (!vec) {
-                        op_ret = -1;
-                        goto done;
+    int32_t i = 0;
+    int32_t callcnt = 0;
+    int32_t count = 0;
+    stripe_local_t *local = NULL;
+    struct iovec *vec = NULL;
+    struct iatt tmp_stbuf = {
+        0,
+    };
+    struct iobref *tmp_iobref = NULL;
+    struct iobuf *iobuf = NULL;
+    call_frame_t *prev = NULL;
+
+    if (!this || !frame || !frame->local) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+
+    local = frame->local;
+    prev = cookie;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->call_count;
+        if (op_ret != -1) {
+            correct_file_size(buf, local->fctx, prev);
+            if (local->stbuf_size < buf->ia_size)
+                local->stbuf_size = buf->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if (!callcnt) {
+        op_ret = 0;
+
+        /* Keep extra space for filling in '\0's */
+        vec = GF_CALLOC((local->count * 2), sizeof(struct iovec),
+                        gf_stripe_mt_iovec);
+        if (!vec) {
+            op_ret = -1;
+            goto done;
+        }
+
+        for (i = 0; i < local->wind_count; i++) {
+            if (local->replies[i].op_ret) {
+                memcpy((vec + count), local->replies[i].vector,
+                       (local->replies[i].count * sizeof(struct iovec)));
+                count += local->replies[i].count;
+                op_ret += local->replies[i].op_ret;
+            }
+            if ((local->replies[i].op_ret < local->replies[i].requested_size) &&
+                (local->stbuf_size > (local->offset + op_ret))) {
+                /* Fill in 0s here */
+                vec[count].iov_len = (local->replies[i].requested_size -
+                                      local->replies[i].op_ret);
+                iobuf = iobuf_get2(this->ctx->iobuf_pool, vec[count].iov_len);
+                if (!iobuf) {
+                    gf_log(this->name, GF_LOG_ERROR, "Out of memory.");
+                    op_ret = -1;
+                    op_errno = ENOMEM;
+                    goto done;
                 }
+                memset(iobuf->ptr, 0, vec[count].iov_len);
+                vec[count].iov_base = iobuf->ptr;
 
-                for (i = 0; i < local->wind_count; i++) {
-                        if (local->replies[i].op_ret) {
-                                memcpy ((vec + count), local->replies[i].vector,
-                                        (local->replies[i].count * sizeof (struct iovec)));
-                                count +=  local->replies[i].count;
-                                op_ret += local->replies[i].op_ret;
-                        }
-                        if ((local->replies[i].op_ret <
-                             local->replies[i].requested_size) &&
-                            (local->stbuf_size > (local->offset + op_ret))) {
-                                /* Fill in 0s here */
-                                vec[count].iov_len  =
-                                        (local->replies[i].requested_size -
-                                         local->replies[i].op_ret);
-                                iobuf = iobuf_get2 (this->ctx->iobuf_pool,
-                                                    vec[count].iov_len);
-                                if (!iobuf) {
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                "Out of memory.");
-                                        op_ret = -1;
-                                        op_errno = ENOMEM;
-                                        goto done;
-                                }
-                                memset (iobuf->ptr, 0, vec[count].iov_len);
-                                vec[count].iov_base = iobuf->ptr;
-
-                                iobref_add (local->iobref, iobuf);
-                                iobuf_unref(iobuf);
-
-                                op_ret += vec[count].iov_len;
-                                count++;
-                        }
-                        GF_FREE (local->replies[i].vector);
-                }
+                iobref_add(local->iobref, iobuf);
+                iobuf_unref(iobuf);
 
-                /* ENOENT signals EOF to the NFS-server */
-                if (op_ret != -1 && op_ret < local->readv_size &&
-                    (local->offset + op_ret == buf->ia_size))
-                        op_errno = ENOENT;
-
-                /* FIXME: notice that st_ino, and st_dev (gen) will be
-                 * different than what inode will have. Make sure this doesn't
-                 * cause any bugs at higher levels */
-                memcpy (&tmp_stbuf, &local->replies[0].stbuf,
-                        sizeof (struct iatt));
-                tmp_stbuf.ia_size = local->stbuf_size;
-
-        done:
-                GF_FREE (local->replies);
-                tmp_iobref = local->iobref;
-                STRIPE_STACK_UNWIND (readv, frame, op_ret, op_errno, vec,
-                                     count, &tmp_stbuf, tmp_iobref, NULL);
-
-                iobref_unref (tmp_iobref);
-                GF_FREE (vec);
-        }
+                op_ret += vec[count].iov_len;
+                count++;
+            }
+            GF_FREE(local->replies[i].vector);
+        }
+
+        /* ENOENT signals EOF to the NFS-server */
+        if (op_ret != -1 && op_ret < local->readv_size &&
+            (local->offset + op_ret == buf->ia_size))
+            op_errno = ENOENT;
+
+        /* FIXME: notice that st_ino, and st_dev (gen) will be
+         * different than what inode will have. Make sure this doesn't
+         * cause any bugs at higher levels */
+        memcpy(&tmp_stbuf, &local->replies[0].stbuf, sizeof(struct iatt));
+        tmp_stbuf.ia_size = local->stbuf_size;
+
+    done:
+        GF_FREE(local->replies);
+        tmp_iobref = local->iobref;
+        STRIPE_STACK_UNWIND(readv, frame, op_ret, op_errno, vec, count,
+                            &tmp_stbuf, tmp_iobref, NULL);
+
+        iobref_unref(tmp_iobref);
+        GF_FREE(vec);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 /**
@@ -3283,1838 +3179,1780 @@ out:
  *        to above layer after putting it in a single vector.
  */
 int32_t
-stripe_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                  int32_t count, struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+stripe_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                 int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                 dict_t *xdata)
 {
-        int32_t         index = 0;
-        int32_t         callcnt = 0;
-        int32_t         final_count = 0;
-        int32_t         need_to_check_proper_size = 0;
-        call_frame_t   *mframe = NULL;
-        stripe_local_t *mlocal = NULL;
-        stripe_local_t *local = NULL;
-        struct iovec   *final_vec = NULL;
-        struct iatt     tmp_stbuf = {0,};
-        struct iatt    *tmp_stbuf_p = NULL; //need it for a warning
-        struct iobref  *tmp_iobref = NULL;
-        stripe_fd_ctx_t  *fctx = NULL;
-	call_frame_t	*prev = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto end;
-        }
-
-        local  = frame->local;
-        index  = local->node_index;
-	prev = cookie;
-        mframe = local->orig_frame;
-        if (!mframe)
-                goto out;
-
-        mlocal = mframe->local;
-        if (!mlocal)
-                goto out;
-
-        fctx = mlocal->fctx;
-
-        LOCK (&mframe->lock);
-        {
-                mlocal->replies[index].op_ret = op_ret;
-                mlocal->replies[index].op_errno = op_errno;
-                mlocal->replies[index].requested_size = local->readv_size;
-                if (op_ret >= 0) {
-                        mlocal->replies[index].stbuf  = *stbuf;
-                        mlocal->replies[index].count  = count;
-                        mlocal->replies[index].vector = iov_dup (vector, count);
-
-			correct_file_size(stbuf, fctx, prev);
-
-                        if (local->stbuf_size < stbuf->ia_size)
-                                local->stbuf_size = stbuf->ia_size;
-                        local->stbuf_blocks += stbuf->ia_blocks;
-
-                        if (!mlocal->iobref)
-                                mlocal->iobref = iobref_new ();
-                        iobref_merge (mlocal->iobref, iobref);
-                }
-                callcnt = ++mlocal->call_count;
-        }
-        UNLOCK(&mframe->lock);
-
-        if (callcnt == mlocal->wind_count) {
-                op_ret = 0;
-
-                for (index=0; index < mlocal->wind_count; index++) {
-                        /* check whether each stripe returned
-                         * 'expected' number of bytes */
-                        if (mlocal->replies[index].op_ret == -1) {
-                                op_ret = -1;
-                                op_errno = mlocal->replies[index].op_errno;
-                                break;
-                        }
-                        /* TODO: handle the 'holes' within the read range
-                           properly */
-                        if (mlocal->replies[index].op_ret <
-                            mlocal->replies[index].requested_size) {
-                                need_to_check_proper_size = 1;
-                        }
-
-                        op_ret       += mlocal->replies[index].op_ret;
-                        mlocal->count += mlocal->replies[index].count;
-                }
-                if (op_ret == -1)
-                        goto done;
-                if (need_to_check_proper_size)
-                        goto check_size;
-
-                final_vec = GF_CALLOC (mlocal->count, sizeof (struct iovec),
-                                       gf_stripe_mt_iovec);
-
-                if (!final_vec) {
-                        op_ret = -1;
-                        goto done;
-                }
-
-                for (index = 0; index < mlocal->wind_count; index++) {
-                        memcpy ((final_vec + final_count),
-                                mlocal->replies[index].vector,
-                                (mlocal->replies[index].count *
-                                 sizeof (struct iovec)));
-                        final_count +=  mlocal->replies[index].count;
-                        GF_FREE (mlocal->replies[index].vector);
-                }
-
-                /* FIXME: notice that st_ino, and st_dev (gen) will be
-                 * different than what inode will have. Make sure this doesn't
-                 * cause any bugs at higher levels */
-                memcpy (&tmp_stbuf, &mlocal->replies[0].stbuf,
-                        sizeof (struct iatt));
-                tmp_stbuf.ia_size = local->stbuf_size;
-                tmp_stbuf.ia_blocks = local->stbuf_blocks;
-
-        done:
-                /* */
-                GF_FREE (mlocal->replies);
-                tmp_iobref = mlocal->iobref;
-                /* work around for nfs truncated read. Bug 3774 */
-                tmp_stbuf_p = &tmp_stbuf;
-                WIPE (tmp_stbuf_p);
-                STRIPE_STACK_UNWIND (readv, mframe, op_ret, op_errno, final_vec,
-                                     final_count, &tmp_stbuf, tmp_iobref, NULL);
-
-                iobref_unref (tmp_iobref);
-                GF_FREE (final_vec);
-        }
+    int32_t index = 0;
+    int32_t callcnt = 0;
+    int32_t final_count = 0;
+    int32_t need_to_check_proper_size = 0;
+    call_frame_t *mframe = NULL;
+    stripe_local_t *mlocal = NULL;
+    stripe_local_t *local = NULL;
+    struct iovec *final_vec = NULL;
+    struct iatt tmp_stbuf = {
+        0,
+    };
+    struct iatt *tmp_stbuf_p = NULL;  // need it for a warning
+    struct iobref *tmp_iobref = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    call_frame_t *prev = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto end;
+    }
+
+    local = frame->local;
+    index = local->node_index;
+    prev = cookie;
+    mframe = local->orig_frame;
+    if (!mframe)
+        goto out;
 
+    mlocal = mframe->local;
+    if (!mlocal)
         goto out;
 
+    fctx = mlocal->fctx;
+
+    LOCK(&mframe->lock);
+    {
+        mlocal->replies[index].op_ret = op_ret;
+        mlocal->replies[index].op_errno = op_errno;
+        mlocal->replies[index].requested_size = local->readv_size;
+        if (op_ret >= 0) {
+            mlocal->replies[index].stbuf = *stbuf;
+            mlocal->replies[index].count = count;
+            mlocal->replies[index].vector = iov_dup(vector, count);
+
+            correct_file_size(stbuf, fctx, prev);
+
+            if (local->stbuf_size < stbuf->ia_size)
+                local->stbuf_size = stbuf->ia_size;
+            local->stbuf_blocks += stbuf->ia_blocks;
+
+            if (!mlocal->iobref)
+                mlocal->iobref = iobref_new();
+            iobref_merge(mlocal->iobref, iobref);
+        }
+        callcnt = ++mlocal->call_count;
+    }
+    UNLOCK(&mframe->lock);
+
+    if (callcnt == mlocal->wind_count) {
+        op_ret = 0;
+
+        for (index = 0; index < mlocal->wind_count; index++) {
+            /* check whether each stripe returned
+             * 'expected' number of bytes */
+            if (mlocal->replies[index].op_ret == -1) {
+                op_ret = -1;
+                op_errno = mlocal->replies[index].op_errno;
+                break;
+            }
+            /* TODO: handle the 'holes' within the read range
+               properly */
+            if (mlocal->replies[index].op_ret <
+                mlocal->replies[index].requested_size) {
+                need_to_check_proper_size = 1;
+            }
+
+            op_ret += mlocal->replies[index].op_ret;
+            mlocal->count += mlocal->replies[index].count;
+        }
+        if (op_ret == -1)
+            goto done;
+        if (need_to_check_proper_size)
+            goto check_size;
+
+        final_vec = GF_CALLOC(mlocal->count, sizeof(struct iovec),
+                              gf_stripe_mt_iovec);
+
+        if (!final_vec) {
+            op_ret = -1;
+            goto done;
+        }
+
+        for (index = 0; index < mlocal->wind_count; index++) {
+            memcpy((final_vec + final_count), mlocal->replies[index].vector,
+                   (mlocal->replies[index].count * sizeof(struct iovec)));
+            final_count += mlocal->replies[index].count;
+            GF_FREE(mlocal->replies[index].vector);
+        }
+
+        /* FIXME: notice that st_ino, and st_dev (gen) will be
+         * different than what inode will have. Make sure this doesn't
+         * cause any bugs at higher levels */
+        memcpy(&tmp_stbuf, &mlocal->replies[0].stbuf, sizeof(struct iatt));
+        tmp_stbuf.ia_size = local->stbuf_size;
+        tmp_stbuf.ia_blocks = local->stbuf_blocks;
+
+    done:
+        /* */
+        GF_FREE(mlocal->replies);
+        tmp_iobref = mlocal->iobref;
+        /* work around for nfs truncated read. Bug 3774 */
+        tmp_stbuf_p = &tmp_stbuf;
+        WIPE(tmp_stbuf_p);
+        STRIPE_STACK_UNWIND(readv, mframe, op_ret, op_errno, final_vec,
+                            final_count, &tmp_stbuf, tmp_iobref, NULL);
+
+        iobref_unref(tmp_iobref);
+        GF_FREE(final_vec);
+    }
+
+    goto out;
+
 check_size:
-        mlocal->call_count = fctx->stripe_count;
+    mlocal->call_count = fctx->stripe_count;
 
-        for (index = 0; index < fctx->stripe_count; index++) {
-                STACK_WIND (mframe, stripe_readv_fstat_cbk,
-                            (fctx->xl_array[index]),
-                            (fctx->xl_array[index])->fops->fstat,
-                            mlocal->fd, NULL);
-        }
+    for (index = 0; index < fctx->stripe_count; index++) {
+        STACK_WIND(mframe, stripe_readv_fstat_cbk, (fctx->xl_array[index]),
+                   (fctx->xl_array[index])->fops->fstat, mlocal->fd, NULL);
+    }
 
 out:
-        STRIPE_STACK_DESTROY (frame);
+    STRIPE_STACK_DESTROY(frame);
 end:
-        return 0;
+    return 0;
 }
 
-
 int32_t
-stripe_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
-              size_t size, off_t offset, uint32_t flags, dict_t *xdata)
+stripe_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+             off_t offset, uint32_t flags, dict_t *xdata)
 {
-        int32_t           op_errno = EINVAL;
-        int32_t           idx = 0;
-        int32_t           index = 0;
-        int32_t           num_stripe = 0;
-        int32_t           off_index = 0;
-        size_t            frame_size = 0;
-        off_t             rounded_end = 0;
-        uint64_t          tmp_fctx = 0;
-        uint64_t          stripe_size = 0;
-        off_t             rounded_start = 0;
-        off_t             frame_offset = offset;
-	off_t		  dest_offset = 0;
-        stripe_local_t   *local = NULL;
-        call_frame_t     *rframe = NULL;
-        stripe_local_t   *rlocal = NULL;
-        stripe_fd_ctx_t  *fctx = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        inode_ctx_get (fd->inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                op_errno = EBADFD;
-                goto err;
-        }
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-        stripe_size = fctx->stripe_size;
-
-        STRIPE_VALIDATE_FCTX (fctx, err);
-
-        if (!stripe_size) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Wrong stripe size for the file");
-                goto err;
-        }
-        /* The file is stripe across the child nodes. Send the read request
-         * to the child nodes appropriately after checking which region of
-         * the file is in which child node. Always '0-<stripe_size>' part of
-         * the file resides in the first child.
-         */
-        rounded_start = floor (offset, stripe_size);
-        rounded_end = roof (offset+size, stripe_size);
-        num_stripe = (rounded_end- rounded_start)/stripe_size;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-
-        /* This is where all the vectors should be copied. */
-        local->replies = GF_CALLOC (num_stripe, sizeof (struct stripe_replies),
-                                    gf_stripe_mt_stripe_replies);
-        if (!local->replies) {
-                op_errno = ENOMEM;
-                goto err;
+    int32_t op_errno = EINVAL;
+    int32_t idx = 0;
+    int32_t index = 0;
+    int32_t num_stripe = 0;
+    int32_t off_index = 0;
+    size_t frame_size = 0;
+    off_t rounded_end = 0;
+    uint64_t tmp_fctx = 0;
+    uint64_t stripe_size = 0;
+    off_t rounded_start = 0;
+    off_t frame_offset = offset;
+    off_t dest_offset = 0;
+    stripe_local_t *local = NULL;
+    call_frame_t *rframe = NULL;
+    stripe_local_t *rlocal = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    inode_ctx_get(fd->inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        op_errno = EBADFD;
+        goto err;
+    }
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    stripe_size = fctx->stripe_size;
+
+    STRIPE_VALIDATE_FCTX(fctx, err);
+
+    if (!stripe_size) {
+        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
+        goto err;
+    }
+    /* The file is stripe across the child nodes. Send the read request
+     * to the child nodes appropriately after checking which region of
+     * the file is in which child node. Always '0-<stripe_size>' part of
+     * the file resides in the first child.
+     */
+    rounded_start = floor(offset, stripe_size);
+    rounded_end = roof(offset + size, stripe_size);
+    num_stripe = (rounded_end - rounded_start) / stripe_size;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+
+    /* This is where all the vectors should be copied. */
+    local->replies = GF_CALLOC(num_stripe, sizeof(struct stripe_replies),
+                               gf_stripe_mt_stripe_replies);
+    if (!local->replies) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    off_index = (offset / stripe_size) % fctx->stripe_count;
+    local->wind_count = num_stripe;
+    local->readv_size = size;
+    local->offset = offset;
+    local->fd = fd_ref(fd);
+    local->fctx = fctx;
+
+    for (index = off_index; index < (num_stripe + off_index); index++) {
+        rframe = copy_frame(frame);
+        rlocal = mem_get0(this->local_pool);
+        if (!rlocal) {
+            op_errno = ENOMEM;
+            goto err;
         }
 
-        off_index = (offset / stripe_size) % fctx->stripe_count;
-        local->wind_count = num_stripe;
-        local->readv_size = size;
-        local->offset     = offset;
-        local->fd         = fd_ref (fd);
-        local->fctx       = fctx;
-
-        for (index = off_index; index < (num_stripe + off_index); index++) {
-                rframe = copy_frame (frame);
-                rlocal = mem_get0 (this->local_pool);
-                if (!rlocal) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
+        frame_size = min(roof(frame_offset + 1, stripe_size), (offset + size)) -
+                     frame_offset;
 
-                frame_size = min (roof (frame_offset+1, stripe_size),
-                                  (offset + size)) - frame_offset;
+        rlocal->node_index = index - off_index;
+        rlocal->orig_frame = frame;
+        rlocal->readv_size = frame_size;
+        rframe->local = rlocal;
+        idx = (index % fctx->stripe_count);
 
-                rlocal->node_index = index - off_index;
-                rlocal->orig_frame = frame;
-                rlocal->readv_size = frame_size;
-                rframe->local = rlocal;
-                idx = (index % fctx->stripe_count);
+        if (fctx->stripe_coalesce)
+            dest_offset = coalesced_offset(frame_offset, stripe_size,
+                                           fctx->stripe_count);
+        else
+            dest_offset = frame_offset;
 
-		if (fctx->stripe_coalesce)
-			dest_offset = coalesced_offset(frame_offset,
-				stripe_size, fctx->stripe_count);
-		else
-			dest_offset = frame_offset;
+        STACK_WIND(rframe, stripe_readv_cbk, fctx->xl_array[idx],
+                   fctx->xl_array[idx]->fops->readv, fd, frame_size,
+                   dest_offset, flags, xdata);
 
-                STACK_WIND (rframe, stripe_readv_cbk, fctx->xl_array[idx],
-                            fctx->xl_array[idx]->fops->readv,
-                            fd, frame_size, dest_offset, flags, xdata);
+        frame_offset += frame_size;
+    }
 
-                frame_offset += frame_size;
-        }
-
-        return 0;
+    return 0;
 err:
-        if (rframe)
-                STRIPE_STACK_DESTROY (rframe);
+    if (rframe)
+        STRIPE_STACK_DESTROY(rframe);
 
-        STRIPE_STACK_UNWIND (readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
-stripe_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+stripe_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-	stripe_local_t *mlocal = NULL;
-        call_frame_t   *prev = NULL;
-	call_frame_t   *mframe = NULL;
-	struct stripe_replies *reply = NULL;
-	int32_t		i = 0;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-
-        prev  = cookie;
-        local = frame->local;
-	mframe = local->orig_frame;
-	mlocal = mframe->local;
-
-        LOCK(&frame->lock);
-        {
-                callcnt = ++mlocal->call_count;
-
-		mlocal->replies[local->node_index].op_ret = op_ret;
-		mlocal->replies[local->node_index].op_errno = op_errno;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_local_t *mlocal = NULL;
+    call_frame_t *prev = NULL;
+    call_frame_t *mframe = NULL;
+    struct stripe_replies *reply = NULL;
+    int32_t i = 0;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+
+    prev = cookie;
+    local = frame->local;
+    mframe = local->orig_frame;
+    mlocal = mframe->local;
+
+    LOCK(&frame->lock);
+    {
+        callcnt = ++mlocal->call_count;
+
+        mlocal->replies[local->node_index].op_ret = op_ret;
+        mlocal->replies[local->node_index].op_errno = op_errno;
+
+        if (op_ret >= 0) {
+            mlocal->post_buf = *postbuf;
+            mlocal->pre_buf = *prebuf;
+
+            mlocal->prebuf_blocks += prebuf->ia_blocks;
+            mlocal->postbuf_blocks += postbuf->ia_blocks;
+
+            correct_file_size(prebuf, mlocal->fctx, prev);
+            correct_file_size(postbuf, mlocal->fctx, prev);
+
+            if (mlocal->prebuf_size < prebuf->ia_size)
+                mlocal->prebuf_size = prebuf->ia_size;
+            if (mlocal->postbuf_size < postbuf->ia_size)
+                mlocal->postbuf_size = postbuf->ia_size;
+        }
+    }
+    UNLOCK(&frame->lock);
+
+    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
+        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
+        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
+        mlocal->post_buf.ia_size = mlocal->postbuf_size;
+        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
+
+        /*
+         * Only return the number of consecutively written bytes up until
+         * the first error. Only return an error if it occurs first.
+         *
+         * When a short write occurs, the application should retry at the
+         * appropriate offset, at which point we'll potentially pass back
+         * the error.
+         */
+        for (i = 0, reply = mlocal->replies; i < mlocal->wind_count;
+             i++, reply++) {
+            if (reply->op_ret == -1) {
+                gf_log(this->name, GF_LOG_DEBUG,
+                       "reply %d "
+                       "returned error %s",
+                       i, strerror(reply->op_errno));
+                if (!mlocal->op_ret) {
+                    mlocal->op_ret = -1;
+                    mlocal->op_errno = reply->op_errno;
+                }
+                break;
+            }
 
-                if (op_ret >= 0) {
-                        mlocal->post_buf = *postbuf;
-                        mlocal->pre_buf = *prebuf;
+            mlocal->op_ret += reply->op_ret;
 
-			mlocal->prebuf_blocks  += prebuf->ia_blocks;
-			mlocal->postbuf_blocks += postbuf->ia_blocks;
+            if (reply->op_ret < reply->requested_size)
+                break;
+        }
 
-			correct_file_size(prebuf, mlocal->fctx, prev);
-			correct_file_size(postbuf, mlocal->fctx, prev);
+        GF_FREE(mlocal->replies);
 
-			if (mlocal->prebuf_size < prebuf->ia_size)
-				mlocal->prebuf_size = prebuf->ia_size;
-			if (mlocal->postbuf_size < postbuf->ia_size)
-				mlocal->postbuf_size = postbuf->ia_size;
-                }
-        }
-        UNLOCK (&frame->lock);
-
-        if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-		mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-		mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-		mlocal->post_buf.ia_size = mlocal->postbuf_size;
-		mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
-
-		/*
-		 * Only return the number of consecutively written bytes up until
-		 * the first error. Only return an error if it occurs first.
-		 *
-		 * When a short write occurs, the application should retry at the
-		 * appropriate offset, at which point we'll potentially pass back
-		 * the error.
-		 */
-		for (i = 0, reply = mlocal->replies; i < mlocal->wind_count;
-			i++, reply++) {
-			if (reply->op_ret == -1) {
-				gf_log(this->name, GF_LOG_DEBUG, "reply %d "
-					"returned error %s", i,
-					strerror(reply->op_errno));
-				if (!mlocal->op_ret) {
-					mlocal->op_ret = -1;
-					mlocal->op_errno = reply->op_errno;
-				}
-				break;
-			}
-
-			mlocal->op_ret += reply->op_ret;
-
-			if (reply->op_ret < reply->requested_size)
-				break;
-		}
-
-		GF_FREE(mlocal->replies);
-
-                STRIPE_STACK_UNWIND (writev, mframe, mlocal->op_ret,
-                                     mlocal->op_errno, &mlocal->pre_buf,
-                                     &mlocal->post_buf, NULL);
-        }
+        STRIPE_STACK_UNWIND(writev, mframe, mlocal->op_ret, mlocal->op_errno,
+                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
+    }
 out:
-        if (frame)
-                STRIPE_STACK_DESTROY(frame);
-        return 0;
+    if (frame)
+        STRIPE_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
-stripe_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-               struct iovec *vector, int32_t count, off_t offset,
-               uint32_t flags, struct iobref *iobref, dict_t *xdata)
+stripe_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
+              struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
+              struct iobref *iobref, dict_t *xdata)
 {
-        struct iovec     *tmp_vec = NULL;
-        stripe_local_t   *local = NULL;
-        stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = 1;
-        int32_t           idx = 0;
-        int32_t           total_size = 0;
-        int32_t           offset_offset = 0;
-        int32_t           remaining_size = 0;
-        int32_t           tmp_count = count;
-        off_t             fill_size = 0;
-        uint64_t          stripe_size = 0;
-        uint64_t          tmp_fctx = 0;
-	off_t		  dest_offset = 0;
-	off_t		  rounded_start = 0;
-	off_t		  rounded_end = 0;
-	int32_t		  total_chunks = 0;
-	call_frame_t	  *wframe = NULL;
-	stripe_local_t	  *wlocal = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        inode_ctx_get (fd->inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                op_errno = EINVAL;
-                goto err;
-        }
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-        stripe_size = fctx->stripe_size;
-
-        STRIPE_VALIDATE_FCTX (fctx, err);
-
-        /* File has to be stripped across the child nodes */
-        total_size = iov_length (vector, count);
-        remaining_size = total_size;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-        local->stripe_size = stripe_size;
-	local->fctx = fctx;
-
-        if (!stripe_size) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Wrong stripe size for the file");
-                op_errno = EINVAL;
-                goto err;
-        }
-
-	rounded_start = floor(offset, stripe_size);
-	rounded_end = roof(offset + total_size, stripe_size);
-	total_chunks = (rounded_end - rounded_start) / stripe_size;
-	local->replies = GF_CALLOC(total_chunks, sizeof(struct stripe_replies),
-				gf_stripe_mt_stripe_replies);
-	if (!local->replies) {
-		op_errno = ENOMEM;
-		goto err;
-	}
-
-	total_chunks = 0;
-        while (1) {
-		wframe = copy_frame(frame);
-		wlocal = mem_get0(this->local_pool);
-		if (!wlocal) {
-			op_errno = ENOMEM;
-			goto err;
-		}
-		wlocal->orig_frame = frame;
-		wframe->local = wlocal;
-
-                /* Send striped chunk of the vector to child
-                   nodes appropriately. */
-                idx = (((offset + offset_offset) /
-                        local->stripe_size) % fctx->stripe_count);
-
-                fill_size = (local->stripe_size -
-                             ((offset + offset_offset) % local->stripe_size));
-                if (fill_size > remaining_size)
-                        fill_size = remaining_size;
-
-                remaining_size -= fill_size;
-
-                tmp_count = iov_subset (vector, count, offset_offset,
-                                        offset_offset + fill_size, NULL);
-                tmp_vec = GF_CALLOC (tmp_count, sizeof (struct iovec),
-                                     gf_stripe_mt_iovec);
-                if (!tmp_vec) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                tmp_count = iov_subset (vector, count, offset_offset,
-                                        offset_offset + fill_size, tmp_vec);
-
-                local->wind_count++;
-                if (remaining_size == 0)
-                        local->unwind = 1;
-
-		/*
-		 * Store off the request index (with respect to the chunk of the
-		 * initial offset) and the size of the request. This is required
-		 * in the callback to calculate an appropriate return value in
-		 * the event of a write failure in one or more requests.
-		 */
-		wlocal->node_index = total_chunks;
-		local->replies[total_chunks].requested_size = fill_size;
-
-		dest_offset = offset + offset_offset;
-		if (fctx->stripe_coalesce)
-			dest_offset = coalesced_offset(dest_offset,
-					local->stripe_size, fctx->stripe_count);
-
-                STACK_WIND (wframe, stripe_writev_cbk, fctx->xl_array[idx],
-                            fctx->xl_array[idx]->fops->writev, fd, tmp_vec,
-                            tmp_count, dest_offset, flags, iobref,
-                            xdata);
-
-                GF_FREE (tmp_vec);
-                offset_offset += fill_size;
-		total_chunks++;
-                if (remaining_size == 0)
-                        break;
-        }
-
-        return 0;
+    struct iovec *tmp_vec = NULL;
+    stripe_local_t *local = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+    int32_t idx = 0;
+    int32_t total_size = 0;
+    int32_t offset_offset = 0;
+    int32_t remaining_size = 0;
+    int32_t tmp_count = count;
+    off_t fill_size = 0;
+    uint64_t stripe_size = 0;
+    uint64_t tmp_fctx = 0;
+    off_t dest_offset = 0;
+    off_t rounded_start = 0;
+    off_t rounded_end = 0;
+    int32_t total_chunks = 0;
+    call_frame_t *wframe = NULL;
+    stripe_local_t *wlocal = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    inode_ctx_get(fd->inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        op_errno = EINVAL;
+        goto err;
+    }
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    stripe_size = fctx->stripe_size;
+
+    STRIPE_VALIDATE_FCTX(fctx, err);
+
+    /* File has to be stripped across the child nodes */
+    total_size = iov_length(vector, count);
+    remaining_size = total_size;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+    local->stripe_size = stripe_size;
+    local->fctx = fctx;
+
+    if (!stripe_size) {
+        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    rounded_start = floor(offset, stripe_size);
+    rounded_end = roof(offset + total_size, stripe_size);
+    total_chunks = (rounded_end - rounded_start) / stripe_size;
+    local->replies = GF_CALLOC(total_chunks, sizeof(struct stripe_replies),
+                               gf_stripe_mt_stripe_replies);
+    if (!local->replies) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    total_chunks = 0;
+    while (1) {
+        wframe = copy_frame(frame);
+        wlocal = mem_get0(this->local_pool);
+        if (!wlocal) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        wlocal->orig_frame = frame;
+        wframe->local = wlocal;
+
+        /* Send striped chunk of the vector to child
+           nodes appropriately. */
+        idx = (((offset + offset_offset) / local->stripe_size) %
+               fctx->stripe_count);
+
+        fill_size = (local->stripe_size -
+                     ((offset + offset_offset) % local->stripe_size));
+        if (fill_size > remaining_size)
+            fill_size = remaining_size;
+
+        remaining_size -= fill_size;
+
+        tmp_count = iov_subset(vector, count, offset_offset,
+                               offset_offset + fill_size, NULL);
+        tmp_vec = GF_CALLOC(tmp_count, sizeof(struct iovec),
+                            gf_stripe_mt_iovec);
+        if (!tmp_vec) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        tmp_count = iov_subset(vector, count, offset_offset,
+                               offset_offset + fill_size, tmp_vec);
+
+        local->wind_count++;
+        if (remaining_size == 0)
+            local->unwind = 1;
+
+        /*
+         * Store off the request index (with respect to the chunk of the
+         * initial offset) and the size of the request. This is required
+         * in the callback to calculate an appropriate return value in
+         * the event of a write failure in one or more requests.
+         */
+        wlocal->node_index = total_chunks;
+        local->replies[total_chunks].requested_size = fill_size;
+
+        dest_offset = offset + offset_offset;
+        if (fctx->stripe_coalesce)
+            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
+                                           fctx->stripe_count);
+
+        STACK_WIND(wframe, stripe_writev_cbk, fctx->xl_array[idx],
+                   fctx->xl_array[idx]->fops->writev, fd, tmp_vec, tmp_count,
+                   dest_offset, flags, iobref, xdata);
+
+        GF_FREE(tmp_vec);
+        offset_offset += fill_size;
+        total_chunks++;
+        if (remaining_size == 0)
+            break;
+    }
+
+    return 0;
 err:
-	if (wframe)
-		STRIPE_STACK_DESTROY(wframe);
+    if (wframe)
+        STRIPE_STACK_DESTROY(wframe);
 
-        STRIPE_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
 stripe_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                      struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-	stripe_local_t *mlocal = NULL;
-        call_frame_t   *prev = NULL;
-	call_frame_t   *mframe = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_local_t *mlocal = NULL;
+    call_frame_t *prev = NULL;
+    call_frame_t *mframe = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
-	mframe = local->orig_frame;
-	mlocal = mframe->local;
+    prev = cookie;
+    local = frame->local;
+    mframe = local->orig_frame;
+    mlocal = mframe->local;
 
-        LOCK(&frame->lock);
-        {
-                callcnt = ++mlocal->call_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = ++mlocal->call_count;
 
-                if (op_ret == 0) {
-                        mlocal->post_buf = *postbuf;
-                        mlocal->pre_buf = *prebuf;
+        if (op_ret == 0) {
+            mlocal->post_buf = *postbuf;
+            mlocal->pre_buf = *prebuf;
 
-			mlocal->prebuf_blocks  += prebuf->ia_blocks;
-			mlocal->postbuf_blocks += postbuf->ia_blocks;
+            mlocal->prebuf_blocks += prebuf->ia_blocks;
+            mlocal->postbuf_blocks += postbuf->ia_blocks;
 
-			correct_file_size(prebuf, mlocal->fctx, prev);
-			correct_file_size(postbuf, mlocal->fctx, prev);
+            correct_file_size(prebuf, mlocal->fctx, prev);
+            correct_file_size(postbuf, mlocal->fctx, prev);
 
-			if (mlocal->prebuf_size < prebuf->ia_size)
-				mlocal->prebuf_size = prebuf->ia_size;
-			if (mlocal->postbuf_size < postbuf->ia_size)
-				mlocal->postbuf_size = postbuf->ia_size;
-                }
+            if (mlocal->prebuf_size < prebuf->ia_size)
+                mlocal->prebuf_size = prebuf->ia_size;
+            if (mlocal->postbuf_size < postbuf->ia_size)
+                mlocal->postbuf_size = postbuf->ia_size;
+        }
 
-		/* return the first failure */
-		if (mlocal->op_ret == 0) {
-			mlocal->op_ret = op_ret;
-			mlocal->op_errno = op_errno;
-		}
+        /* return the first failure */
+        if (mlocal->op_ret == 0) {
+            mlocal->op_ret = op_ret;
+            mlocal->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-		mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-		mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-		mlocal->post_buf.ia_size = mlocal->postbuf_size;
-		mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
+    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
+        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
+        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
+        mlocal->post_buf.ia_size = mlocal->postbuf_size;
+        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
 
-                STRIPE_STACK_UNWIND (fallocate, mframe, mlocal->op_ret,
-                                     mlocal->op_errno, &mlocal->pre_buf,
-                                     &mlocal->post_buf, NULL);
-        }
+        STRIPE_STACK_UNWIND(fallocate, mframe, mlocal->op_ret, mlocal->op_errno,
+                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
+    }
 out:
-        if (frame)
-	        STRIPE_STACK_DESTROY(frame);
-        return 0;
+    if (frame)
+        STRIPE_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
 stripe_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-		 off_t offset, size_t len, dict_t *xdata)
+                 off_t offset, size_t len, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = 1;
-        int32_t           idx = 0;
-        int32_t           offset_offset = 0;
-        int32_t           remaining_size = 0;
-        off_t             fill_size = 0;
-        uint64_t          stripe_size = 0;
-        uint64_t          tmp_fctx = 0;
-	off_t		  dest_offset = 0;
-	call_frame_t	  *fframe = NULL;
-	stripe_local_t	  *flocal = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        inode_ctx_get (fd->inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                op_errno = EINVAL;
-                goto err;
-        }
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-        stripe_size = fctx->stripe_size;
-
-        STRIPE_VALIDATE_FCTX (fctx, err);
-
-        remaining_size = len;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-        local->stripe_size = stripe_size;
-	local->fctx = fctx;
-
-        if (!stripe_size) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Wrong stripe size for the file");
-                op_errno = EINVAL;
-                goto err;
-        }
+    stripe_local_t *local = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+    int32_t idx = 0;
+    int32_t offset_offset = 0;
+    int32_t remaining_size = 0;
+    off_t fill_size = 0;
+    uint64_t stripe_size = 0;
+    uint64_t tmp_fctx = 0;
+    off_t dest_offset = 0;
+    call_frame_t *fframe = NULL;
+    stripe_local_t *flocal = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    inode_ctx_get(fd->inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        op_errno = EINVAL;
+        goto err;
+    }
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    stripe_size = fctx->stripe_size;
+
+    STRIPE_VALIDATE_FCTX(fctx, err);
+
+    remaining_size = len;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+    local->stripe_size = stripe_size;
+    local->fctx = fctx;
+
+    if (!stripe_size) {
+        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    while (1) {
+        fframe = copy_frame(frame);
+        flocal = mem_get0(this->local_pool);
+        if (!flocal) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        flocal->orig_frame = frame;
+        fframe->local = flocal;
+
+        /* send fallocate request to the associated child node */
+        idx = (((offset + offset_offset) / local->stripe_size) %
+               fctx->stripe_count);
+
+        fill_size = (local->stripe_size -
+                     ((offset + offset_offset) % local->stripe_size));
+        if (fill_size > remaining_size)
+            fill_size = remaining_size;
+
+        remaining_size -= fill_size;
+
+        local->wind_count++;
+        if (remaining_size == 0)
+            local->unwind = 1;
+
+        dest_offset = offset + offset_offset;
+        if (fctx->stripe_coalesce)
+            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
+                                           fctx->stripe_count);
+
+        /*
+         * TODO: Create a separate handler for coalesce mode that sends a
+         * single fallocate per-child (since the ranges are linear).
+         */
+        STACK_WIND(fframe, stripe_fallocate_cbk, fctx->xl_array[idx],
+                   fctx->xl_array[idx]->fops->fallocate, fd, mode, dest_offset,
+                   fill_size, xdata);
 
-        while (1) {
-		fframe = copy_frame(frame);
-		flocal = mem_get0(this->local_pool);
-		if (!flocal) {
-			op_errno = ENOMEM;
-			goto err;
-		}
-		flocal->orig_frame = frame;
-		fframe->local = flocal;
-
-		/* send fallocate request to the associated child node */
-                idx = (((offset + offset_offset) /
-                        local->stripe_size) % fctx->stripe_count);
-
-                fill_size = (local->stripe_size -
-                             ((offset + offset_offset) % local->stripe_size));
-                if (fill_size > remaining_size)
-                        fill_size = remaining_size;
-
-                remaining_size -= fill_size;
-
-                local->wind_count++;
-                if (remaining_size == 0)
-                        local->unwind = 1;
-
-		dest_offset = offset + offset_offset;
-		if (fctx->stripe_coalesce)
-			dest_offset = coalesced_offset(dest_offset,
-					local->stripe_size, fctx->stripe_count);
-
-		/*
-		 * TODO: Create a separate handler for coalesce mode that sends a
-		 * single fallocate per-child (since the ranges are linear).
-		 */
-		STACK_WIND(fframe, stripe_fallocate_cbk, fctx->xl_array[idx],
-			   fctx->xl_array[idx]->fops->fallocate, fd, mode,
-			   dest_offset, fill_size, xdata);
-
-                offset_offset += fill_size;
-                if (remaining_size == 0)
-                        break;
-        }
+        offset_offset += fill_size;
+        if (remaining_size == 0)
+            break;
+    }
 
-        return 0;
+    return 0;
 err:
-	if (fframe)
-		STRIPE_STACK_DESTROY(fframe);
+    if (fframe)
+        STRIPE_STACK_DESTROY(fframe);
 
-        STRIPE_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
-
 int32_t
 stripe_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
                    struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt = 0;
-        stripe_local_t *local = NULL;
-	stripe_local_t *mlocal = NULL;
-        call_frame_t   *prev = NULL;
-	call_frame_t   *mframe = NULL;
-
-        if (!this || !frame || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_local_t *mlocal = NULL;
+    call_frame_t *prev = NULL;
+    call_frame_t *mframe = NULL;
+
+    if (!this || !frame || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
-	mframe = local->orig_frame;
-	mlocal = mframe->local;
+    prev = cookie;
+    local = frame->local;
+    mframe = local->orig_frame;
+    mlocal = mframe->local;
 
-        LOCK(&frame->lock);
-        {
-                callcnt = ++mlocal->call_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = ++mlocal->call_count;
 
-                if (op_ret == 0) {
-                        mlocal->post_buf = *postbuf;
-                        mlocal->pre_buf = *prebuf;
+        if (op_ret == 0) {
+            mlocal->post_buf = *postbuf;
+            mlocal->pre_buf = *prebuf;
 
-			mlocal->prebuf_blocks  += prebuf->ia_blocks;
-			mlocal->postbuf_blocks += postbuf->ia_blocks;
+            mlocal->prebuf_blocks += prebuf->ia_blocks;
+            mlocal->postbuf_blocks += postbuf->ia_blocks;
 
-			correct_file_size(prebuf, mlocal->fctx, prev);
-			correct_file_size(postbuf, mlocal->fctx, prev);
+            correct_file_size(prebuf, mlocal->fctx, prev);
+            correct_file_size(postbuf, mlocal->fctx, prev);
 
-			if (mlocal->prebuf_size < prebuf->ia_size)
-				mlocal->prebuf_size = prebuf->ia_size;
-			if (mlocal->postbuf_size < postbuf->ia_size)
-				mlocal->postbuf_size = postbuf->ia_size;
-                }
+            if (mlocal->prebuf_size < prebuf->ia_size)
+                mlocal->prebuf_size = prebuf->ia_size;
+            if (mlocal->postbuf_size < postbuf->ia_size)
+                mlocal->postbuf_size = postbuf->ia_size;
+        }
 
-		/* return the first failure */
-		if (mlocal->op_ret == 0) {
-			mlocal->op_ret = op_ret;
-			mlocal->op_errno = op_errno;
-		}
+        /* return the first failure */
+        if (mlocal->op_ret == 0) {
+            mlocal->op_ret = op_ret;
+            mlocal->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-		mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-		mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-		mlocal->post_buf.ia_size = mlocal->postbuf_size;
-		mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
+    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
+        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
+        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
+        mlocal->post_buf.ia_size = mlocal->postbuf_size;
+        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
 
-                STRIPE_STACK_UNWIND (discard, mframe, mlocal->op_ret,
-                                     mlocal->op_errno, &mlocal->pre_buf,
-                                     &mlocal->post_buf, NULL);
-        }
+        STRIPE_STACK_UNWIND(discard, mframe, mlocal->op_ret, mlocal->op_errno,
+                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
+    }
 out:
-        if (frame)
-                STRIPE_STACK_DESTROY(frame);
+    if (frame)
+        STRIPE_STACK_DESTROY(frame);
 
-        return 0;
+    return 0;
 }
 
 int32_t
 stripe_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-	       size_t len, dict_t *xdata)
+               size_t len, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_fd_ctx_t  *fctx = NULL;
-        int32_t           op_errno = 1;
-        int32_t           idx = 0;
-        int32_t           offset_offset = 0;
-        int32_t           remaining_size = 0;
-        off_t             fill_size = 0;
-        uint64_t          stripe_size = 0;
-        uint64_t          tmp_fctx = 0;
-	off_t		  dest_offset = 0;
-	call_frame_t	  *fframe = NULL;
-	stripe_local_t	  *flocal = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        inode_ctx_get (fd->inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                op_errno = EINVAL;
-                goto err;
-        }
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-        stripe_size = fctx->stripe_size;
-
-        STRIPE_VALIDATE_FCTX (fctx, err);
-
-        remaining_size = len;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-        local->stripe_size = stripe_size;
-	local->fctx = fctx;
-
-        if (!stripe_size) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Wrong stripe size for the file");
-                op_errno = EINVAL;
-                goto err;
-        }
+    stripe_local_t *local = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+    int32_t idx = 0;
+    int32_t offset_offset = 0;
+    int32_t remaining_size = 0;
+    off_t fill_size = 0;
+    uint64_t stripe_size = 0;
+    uint64_t tmp_fctx = 0;
+    off_t dest_offset = 0;
+    call_frame_t *fframe = NULL;
+    stripe_local_t *flocal = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    inode_ctx_get(fd->inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        op_errno = EINVAL;
+        goto err;
+    }
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    stripe_size = fctx->stripe_size;
+
+    STRIPE_VALIDATE_FCTX(fctx, err);
+
+    remaining_size = len;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+    local->stripe_size = stripe_size;
+    local->fctx = fctx;
+
+    if (!stripe_size) {
+        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    while (1) {
+        fframe = copy_frame(frame);
+        flocal = mem_get0(this->local_pool);
+        if (!flocal) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        flocal->orig_frame = frame;
+        fframe->local = flocal;
+
+        /* send discard request to the associated child node */
+        idx = (((offset + offset_offset) / local->stripe_size) %
+               fctx->stripe_count);
+
+        fill_size = (local->stripe_size -
+                     ((offset + offset_offset) % local->stripe_size));
+        if (fill_size > remaining_size)
+            fill_size = remaining_size;
+
+        remaining_size -= fill_size;
+
+        local->wind_count++;
+        if (remaining_size == 0)
+            local->unwind = 1;
+
+        dest_offset = offset + offset_offset;
+        if (fctx->stripe_coalesce)
+            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
+                                           fctx->stripe_count);
+
+        /*
+         * TODO: Create a separate handler for coalesce mode that sends a
+         * single discard per-child (since the ranges are linear).
+         */
+        STACK_WIND(fframe, stripe_discard_cbk, fctx->xl_array[idx],
+                   fctx->xl_array[idx]->fops->discard, fd, dest_offset,
+                   fill_size, xdata);
 
-        while (1) {
-		fframe = copy_frame(frame);
-		flocal = mem_get0(this->local_pool);
-		if (!flocal) {
-			op_errno = ENOMEM;
-			goto err;
-		}
-		flocal->orig_frame = frame;
-		fframe->local = flocal;
-
-		/* send discard request to the associated child node */
-                idx = (((offset + offset_offset) /
-                        local->stripe_size) % fctx->stripe_count);
-
-                fill_size = (local->stripe_size -
-                             ((offset + offset_offset) % local->stripe_size));
-                if (fill_size > remaining_size)
-                        fill_size = remaining_size;
-
-                remaining_size -= fill_size;
-
-                local->wind_count++;
-                if (remaining_size == 0)
-                        local->unwind = 1;
-
-		dest_offset = offset + offset_offset;
-		if (fctx->stripe_coalesce)
-			dest_offset = coalesced_offset(dest_offset,
-					local->stripe_size, fctx->stripe_count);
-
-		/*
-		 * TODO: Create a separate handler for coalesce mode that sends a
-		 * single discard per-child (since the ranges are linear).
-		 */
-		STACK_WIND(fframe, stripe_discard_cbk, fctx->xl_array[idx],
-			   fctx->xl_array[idx]->fops->discard, fd, dest_offset,
-			   fill_size, xdata);
-
-                offset_offset += fill_size;
-                if (remaining_size == 0)
-                        break;
-        }
+        offset_offset += fill_size;
+        if (remaining_size == 0)
+            break;
+    }
 
-        return 0;
+    return 0;
 err:
-	if (fframe)
-		STRIPE_STACK_DESTROY(fframe);
+    if (fframe)
+        STRIPE_STACK_DESTROY(fframe);
 
-        STRIPE_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
 stripe_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                    struct iatt *postbuf, dict_t *xdata)
 {
-        int32_t         callcnt    = 0;
-        stripe_local_t *local      = NULL;
-        stripe_local_t *mlocal     = NULL;
-        call_frame_t   *prev       = NULL;
-        call_frame_t   *mframe     = NULL;
+    int32_t callcnt = 0;
+    stripe_local_t *local = NULL;
+    stripe_local_t *mlocal = NULL;
+    call_frame_t *prev = NULL;
+    call_frame_t *mframe = NULL;
 
-        GF_ASSERT (frame);
+    GF_ASSERT(frame);
 
-        if (!this || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
+    if (!this || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
 
-        prev  = cookie;
-        local = frame->local;
-        mframe = local->orig_frame;
-        mlocal = mframe->local;
+    prev = cookie;
+    local = frame->local;
+    mframe = local->orig_frame;
+    mlocal = mframe->local;
 
-        LOCK(&frame->lock);
-        {
-                callcnt = ++mlocal->call_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = ++mlocal->call_count;
 
-                if (op_ret == 0) {
-                        mlocal->post_buf = *postbuf;
-                        mlocal->pre_buf = *prebuf;
+        if (op_ret == 0) {
+            mlocal->post_buf = *postbuf;
+            mlocal->pre_buf = *prebuf;
 
-                        mlocal->prebuf_blocks  += prebuf->ia_blocks;
-                        mlocal->postbuf_blocks += postbuf->ia_blocks;
+            mlocal->prebuf_blocks += prebuf->ia_blocks;
+            mlocal->postbuf_blocks += postbuf->ia_blocks;
 
-                        correct_file_size(prebuf, mlocal->fctx, prev);
-                        correct_file_size(postbuf, mlocal->fctx, prev);
+            correct_file_size(prebuf, mlocal->fctx, prev);
+            correct_file_size(postbuf, mlocal->fctx, prev);
 
-                        if (mlocal->prebuf_size < prebuf->ia_size)
-                                mlocal->prebuf_size = prebuf->ia_size;
-                        if (mlocal->postbuf_size < postbuf->ia_size)
-                                mlocal->postbuf_size = postbuf->ia_size;
-                }
+            if (mlocal->prebuf_size < prebuf->ia_size)
+                mlocal->prebuf_size = prebuf->ia_size;
+            if (mlocal->postbuf_size < postbuf->ia_size)
+                mlocal->postbuf_size = postbuf->ia_size;
+        }
 
-                /* return the first failure */
-                if (mlocal->op_ret == 0) {
-                        mlocal->op_ret = op_ret;
-                        mlocal->op_errno = op_errno;
-                }
+        /* return the first failure */
+        if (mlocal->op_ret == 0) {
+            mlocal->op_ret = op_ret;
+            mlocal->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-                mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-                mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-                mlocal->post_buf.ia_size = mlocal->postbuf_size;
-                mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
+    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
+        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
+        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
+        mlocal->post_buf.ia_size = mlocal->postbuf_size;
+        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
 
-                STRIPE_STACK_UNWIND (zerofill, mframe, mlocal->op_ret,
-                                     mlocal->op_errno, &mlocal->pre_buf,
-                                     &mlocal->post_buf, NULL);
-        }
+        STRIPE_STACK_UNWIND(zerofill, mframe, mlocal->op_ret, mlocal->op_errno,
+                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
+    }
 out:
-        STRIPE_STACK_DESTROY(frame);
-        return 0;
+    STRIPE_STACK_DESTROY(frame);
+    return 0;
 }
 
 int32_t
 stripe_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               off_t len, dict_t *xdata)
+                off_t len, dict_t *xdata)
 {
-        stripe_local_t   *local            = NULL;
-        stripe_fd_ctx_t  *fctx             = NULL;
-        int32_t           op_errno         = 1;
-        int32_t           idx              = 0;
-        int32_t           offset_offset    = 0;
-        int32_t           remaining_size   = 0;
-        off_t             fill_size        = 0;
-        uint64_t          stripe_size      = 0;
-        uint64_t          tmp_fctx         = 0;
-        off_t             dest_offset      = 0;
-        call_frame_t     *fframe           = NULL;
-        stripe_local_t   *flocal           = NULL;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-        VALIDATE_OR_GOTO (fd->inode, err);
-
-        inode_ctx_get (fd->inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                op_errno = EINVAL;
-                goto err;
-        }
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-        stripe_size = fctx->stripe_size;
-
-        STRIPE_VALIDATE_FCTX (fctx, err);
-
-        remaining_size = len;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-        frame->local = local;
-        local->stripe_size = stripe_size;
-        local->fctx = fctx;
-
-        if (!stripe_size) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Wrong stripe size for the file");
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        while (1) {
-                fframe = copy_frame(frame);
-                flocal = mem_get0(this->local_pool);
-                if (!flocal) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
-                flocal->orig_frame = frame;
-                fframe->local = flocal;
-
-                idx = (((offset + offset_offset) /
-                        local->stripe_size) % fctx->stripe_count);
-
-                fill_size = (local->stripe_size -
-                             ((offset + offset_offset) % local->stripe_size));
-                if (fill_size > remaining_size)
-                        fill_size = remaining_size;
-
-                remaining_size -= fill_size;
-
-                local->wind_count++;
-                if (remaining_size == 0)
-                        local->unwind = 1;
-
-                dest_offset = offset + offset_offset;
-                if (fctx->stripe_coalesce)
-                        dest_offset = coalesced_offset(dest_offset,
-                                                       local->stripe_size,
-                                                       fctx->stripe_count);
-
-                STACK_WIND(fframe, stripe_zerofill_cbk, fctx->xl_array[idx],
-                           fctx->xl_array[idx]->fops->zerofill, fd,
-                           dest_offset, fill_size, xdata);
-                offset_offset += fill_size;
-                if (remaining_size == 0)
-                        break;
-        }
-
-        return 0;
+    stripe_local_t *local = NULL;
+    stripe_fd_ctx_t *fctx = NULL;
+    int32_t op_errno = 1;
+    int32_t idx = 0;
+    int32_t offset_offset = 0;
+    int32_t remaining_size = 0;
+    off_t fill_size = 0;
+    uint64_t stripe_size = 0;
+    uint64_t tmp_fctx = 0;
+    off_t dest_offset = 0;
+    call_frame_t *fframe = NULL;
+    stripe_local_t *flocal = NULL;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+    VALIDATE_OR_GOTO(fd->inode, err);
+
+    inode_ctx_get(fd->inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        op_errno = EINVAL;
+        goto err;
+    }
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    stripe_size = fctx->stripe_size;
+
+    STRIPE_VALIDATE_FCTX(fctx, err);
+
+    remaining_size = len;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    frame->local = local;
+    local->stripe_size = stripe_size;
+    local->fctx = fctx;
+
+    if (!stripe_size) {
+        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
+        op_errno = EINVAL;
+        goto err;
+    }
+
+    while (1) {
+        fframe = copy_frame(frame);
+        flocal = mem_get0(this->local_pool);
+        if (!flocal) {
+            op_errno = ENOMEM;
+            goto err;
+        }
+        flocal->orig_frame = frame;
+        fframe->local = flocal;
+
+        idx = (((offset + offset_offset) / local->stripe_size) %
+               fctx->stripe_count);
+
+        fill_size = (local->stripe_size -
+                     ((offset + offset_offset) % local->stripe_size));
+        if (fill_size > remaining_size)
+            fill_size = remaining_size;
+
+        remaining_size -= fill_size;
+
+        local->wind_count++;
+        if (remaining_size == 0)
+            local->unwind = 1;
+
+        dest_offset = offset + offset_offset;
+        if (fctx->stripe_coalesce)
+            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
+                                           fctx->stripe_count);
+
+        STACK_WIND(fframe, stripe_zerofill_cbk, fctx->xl_array[idx],
+                   fctx->xl_array[idx]->fops->zerofill, fd, dest_offset,
+                   fill_size, xdata);
+        offset_offset += fill_size;
+        if (remaining_size == 0)
+            break;
+    }
+
+    return 0;
 err:
-        if (fframe)
-                STRIPE_STACK_DESTROY(fframe);
+    if (fframe)
+        STRIPE_STACK_DESTROY(fframe);
 
-        STRIPE_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
+    return 0;
 }
 
 int32_t
-stripe_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             gf_seek_what_t what, dict_t *xdata)
+stripe_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            gf_seek_what_t what, dict_t *xdata)
 {
-        /* TBD */
-        gf_log (this->name, GF_LOG_INFO, "seek called on %s.",
-                uuid_utoa (fd->inode->gfid));
-        STRIPE_STACK_UNWIND (seek, frame, -1, ENOTSUP, 0, NULL);
-        return 0;
+    /* TBD */
+    gf_log(this->name, GF_LOG_INFO, "seek called on %s.",
+           uuid_utoa(fd->inode->gfid));
+    STRIPE_STACK_UNWIND(seek, frame, -1, ENOTSUP, 0, NULL);
+    return 0;
 }
 
 int32_t
-stripe_release (xlator_t *this, fd_t *fd)
+stripe_release(xlator_t *this, fd_t *fd)
 {
-	return 0;
+    return 0;
 }
 
 int
-stripe_forget (xlator_t *this, inode_t *inode)
+stripe_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t          tmp_fctx = 0;
-        stripe_fd_ctx_t  *fctx = NULL;
+    uint64_t tmp_fctx = 0;
+    stripe_fd_ctx_t *fctx = NULL;
 
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (inode, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(inode, err);
 
-        (void) inode_ctx_del (inode, this, &tmp_fctx);
-        if (!tmp_fctx) {
-                goto err;
-        }
+    (void)inode_ctx_del(inode, this, &tmp_fctx);
+    if (!tmp_fctx) {
+        goto err;
+    }
 
-        fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
+    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
 
-        if (!fctx->static_array)
-                GF_FREE (fctx->xl_array);
+    if (!fctx->static_array)
+        GF_FREE(fctx->xl_array);
 
-        GF_FREE (fctx);
+    GF_FREE(fctx);
 err:
-        return 0;
+    return 0;
 }
 
 int32_t
-notify (xlator_t *this, int32_t event, void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        stripe_private_t *priv = NULL;
-        int               down_client = 0;
-        int               i = 0;
-        gf_boolean_t      heard_from_all_children = _gf_false;
-
-        if (!this)
-                return 0;
-
-        priv = this->private;
-        if (!priv)
-                return 0;
-
-        switch (event)
-        {
-        case GF_EVENT_CHILD_UP:
-        {
-                /* get an index number to set */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (data == priv->xl_array[i])
-                                break;
-                }
-
-                if (priv->child_count == i) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "got GF_EVENT_CHILD_UP bad subvolume %s",
-                                data? ((xlator_t *)data)->name: NULL);
-                        break;
-                }
+    stripe_private_t *priv = NULL;
+    int down_client = 0;
+    int i = 0;
+    gf_boolean_t heard_from_all_children = _gf_false;
 
-                LOCK (&priv->lock);
-                {
-                        if (data == FIRST_CHILD (this))
-                                priv->first_child_down = 0;
-                        priv->last_event[i] = event;
-                }
-                UNLOCK (&priv->lock);
-        }
-        break;
-        case GF_EVENT_CHILD_CONNECTING:
-        {
-                // 'CONNECTING' doesn't ensure its CHILD_UP, so do nothing
-                goto out;
-        }
-        case GF_EVENT_CHILD_DOWN:
-        {
-                /* get an index number to set */
-                for (i = 0; i < priv->child_count; i++) {
-                        if (data == priv->xl_array[i])
-                                break;
-                }
-
-                if (priv->child_count == i) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "got GF_EVENT_CHILD_DOWN bad subvolume %s",
-                                data? ((xlator_t *)data)->name: NULL);
-                        break;
-                }
-
-                LOCK (&priv->lock);
-                {
-                        if (data == FIRST_CHILD (this))
-                                priv->first_child_down = 1;
-                        priv->last_event[i] = event;
-                }
-                UNLOCK (&priv->lock);
-        }
-        break;
-
-        default:
-        {
-                /* */
-                default_notify (this, event, data);
-                goto out;
-        }
-        break;
-        }
+    if (!this)
+        return 0;
 
-        // Consider child as down if it's last_event is not CHILD_UP
-        for (i = 0, down_client = 0; i < priv->child_count; i++)
-                if (priv->last_event[i] != GF_EVENT_CHILD_UP)
-                        down_client++;
+    priv = this->private;
+    if (!priv)
+        return 0;
 
-        LOCK (&priv->lock);
-        {
-                priv->nodes_down = down_client;
+    switch (event) {
+        case GF_EVENT_CHILD_UP: {
+            /* get an index number to set */
+            for (i = 0; i < priv->child_count; i++) {
+                if (data == priv->xl_array[i])
+                    break;
+            }
+
+            if (priv->child_count == i) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "got GF_EVENT_CHILD_UP bad subvolume %s",
+                       data ? ((xlator_t *)data)->name : NULL);
+                break;
+            }
+
+            LOCK(&priv->lock);
+            {
+                if (data == FIRST_CHILD(this))
+                    priv->first_child_down = 0;
+                priv->last_event[i] = event;
+            }
+            UNLOCK(&priv->lock);
+        } break;
+        case GF_EVENT_CHILD_CONNECTING: {
+            // 'CONNECTING' doesn't ensure its CHILD_UP, so do nothing
+            goto out;
         }
-        UNLOCK (&priv->lock);
-
-        heard_from_all_children = _gf_true;
-        for (i = 0; i < priv->child_count; i++)
-                if (!priv->last_event[i])
-                        heard_from_all_children = _gf_false;
-
-        if (heard_from_all_children)
-                default_notify (this, event, data);
+        case GF_EVENT_CHILD_DOWN: {
+            /* get an index number to set */
+            for (i = 0; i < priv->child_count; i++) {
+                if (data == priv->xl_array[i])
+                    break;
+            }
+
+            if (priv->child_count == i) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "got GF_EVENT_CHILD_DOWN bad subvolume %s",
+                       data ? ((xlator_t *)data)->name : NULL);
+                break;
+            }
+
+            LOCK(&priv->lock);
+            {
+                if (data == FIRST_CHILD(this))
+                    priv->first_child_down = 1;
+                priv->last_event[i] = event;
+            }
+            UNLOCK(&priv->lock);
+        } break;
+
+        default: {
+            /* */
+            default_notify(this, event, data);
+            goto out;
+        } break;
+    }
+
+    // Consider child as down if it's last_event is not CHILD_UP
+    for (i = 0, down_client = 0; i < priv->child_count; i++)
+        if (priv->last_event[i] != GF_EVENT_CHILD_UP)
+            down_client++;
+
+    LOCK(&priv->lock);
+    {
+        priv->nodes_down = down_client;
+    }
+    UNLOCK(&priv->lock);
+
+    heard_from_all_children = _gf_true;
+    for (i = 0; i < priv->child_count; i++)
+        if (!priv->last_event[i])
+            heard_from_all_children = _gf_false;
+
+    if (heard_from_all_children)
+        default_notify(this, event, data);
 out:
-        return 0;
+    return 0;
 }
 
 int
-stripe_setxattr_cbk (call_frame_t *frame, void *cookie,
-                     xlator_t *this, int op_ret, int op_errno, dict_t *xdata)
+stripe_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xdata)
 {
-        int ret = -1;
-        int call_cnt = 0;
-        stripe_local_t *local = NULL;
+    int ret = -1;
+    int call_cnt = 0;
+    stripe_local_t *local = NULL;
 
-        if (!frame || !frame->local || !this) {
-                gf_log ("", GF_LOG_ERROR, "Possible NULL deref");
-                return ret;
-        }
+    if (!frame || !frame->local || !this) {
+        gf_log("", GF_LOG_ERROR, "Possible NULL deref");
+        return ret;
+    }
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                call_cnt = --local->wind_count;
-
-                /**
-                 * We overwrite ->op_* values here for subsequent failure
-                 * conditions, hence we propagate the last errno down the
-                 * stack.
-                 */
-                if (op_ret < 0) {
-                        local->op_ret = op_ret;
-                        local->op_errno = op_errno;
-                        goto unlock;
-                }
+    LOCK(&frame->lock);
+    {
+        call_cnt = --local->wind_count;
+
+        /**
+         * We overwrite ->op_* values here for subsequent failure
+         * conditions, hence we propagate the last errno down the
+         * stack.
+         */
+        if (op_ret < 0) {
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
+            goto unlock;
         }
+    }
 
- unlock:
-        UNLOCK (&frame->lock);
+unlock:
+    UNLOCK(&frame->lock);
 
-        if (!call_cnt) {
-                STRIPE_STACK_UNWIND (setxattr, frame, local->op_ret,
-                                     local->op_errno, xdata);
-        }
+    if (!call_cnt) {
+        STRIPE_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
+                            xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 #ifdef HAVE_BD_XLATOR
 int
-stripe_is_bd (dict_t *this, char *key, data_t *value, void *data)
+stripe_is_bd(dict_t *this, char *key, data_t *value, void *data)
 {
-        gf_boolean_t *is_bd = data;
+    gf_boolean_t *is_bd = data;
 
-        if (data == NULL)
-                return 0;
+    if (data == NULL)
+        return 0;
 
-        if (XATTR_IS_BD (key))
-            *is_bd = _gf_true;
+    if (XATTR_IS_BD(key))
+        *is_bd = _gf_true;
 
-        return 0;
+    return 0;
 }
 
 static gf_boolean_t
-stripe_setxattr_is_bd (dict_t *dict)
+stripe_setxattr_is_bd(dict_t *dict)
 {
-        gf_boolean_t is_bd = _gf_false;
+    gf_boolean_t is_bd = _gf_false;
 
-        if (dict == NULL)
-                goto out;
+    if (dict == NULL)
+        goto out;
 
-        dict_foreach (dict, stripe_is_bd, &is_bd);
+    dict_foreach(dict, stripe_is_bd, &is_bd);
 out:
-        return is_bd;
+    return is_bd;
 }
 #else
 #define stripe_setxattr_is_bd(dict) _gf_false
 #endif
 
 int
-stripe_setxattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, dict_t *dict, int flags, dict_t *xdata)
+stripe_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                int flags, dict_t *xdata)
 {
-        int32_t           op_errno = EINVAL;
-        xlator_list_t    *trav     = NULL;
-        stripe_private_t *priv     = NULL;
-        stripe_local_t   *local    = NULL;
-        int               i        = 0;
-        gf_boolean_t      is_bd    = _gf_false;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.*stripe*", dict,
-                                   op_errno, err);
-
-        priv = this->private;
-        trav = this->children;
-
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
-
-        frame->local = local;
-        local->wind_count = priv->child_count;
-        local->op_ret = local->op_errno = 0;
-
-        is_bd = stripe_setxattr_is_bd (dict);
-
-        /**
-         * Set xattrs for directories on all subvolumes. Additionally
-         * this power is only given to a special client. Bd xlator
-         * also needs xattrs for regular files (ie LVs)
-         */
-        if (((frame->root->pid == GF_CLIENT_PID_GSYNCD) &&
-             IA_ISDIR (loc->inode->ia_type)) || is_bd) {
-                for (i = 0; i < priv->child_count; i++, trav = trav->next) {
-                        STACK_WIND (frame, stripe_setxattr_cbk,
-                                    trav->xlator, trav->xlator->fops->setxattr,
-                                    loc, dict, flags, xdata);
-                }
-        } else {
-                local->wind_count = 1;
-                STACK_WIND (frame, stripe_setxattr_cbk,
-                            FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->setxattr,
-                            loc, dict, flags, xdata);
-        }
-
-        return 0;
+    int32_t op_errno = EINVAL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    stripe_local_t *local = NULL;
+    int i = 0;
+    gf_boolean_t is_bd = _gf_false;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.*stripe*", dict, op_errno, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+
+    frame->local = local;
+    local->wind_count = priv->child_count;
+    local->op_ret = local->op_errno = 0;
+
+    is_bd = stripe_setxattr_is_bd(dict);
+
+    /**
+     * Set xattrs for directories on all subvolumes. Additionally
+     * this power is only given to a special client. Bd xlator
+     * also needs xattrs for regular files (ie LVs)
+     */
+    if (((frame->root->pid == GF_CLIENT_PID_GSYNCD) &&
+         IA_ISDIR(loc->inode->ia_type)) ||
+        is_bd) {
+        for (i = 0; i < priv->child_count; i++, trav = trav->next) {
+            STACK_WIND(frame, stripe_setxattr_cbk, trav->xlator,
+                       trav->xlator->fops->setxattr, loc, dict, flags, xdata);
+        }
+    } else {
+        local->wind_count = 1;
+        STACK_WIND(frame, stripe_setxattr_cbk, FIRST_CHILD(this),
+                   FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
+    }
+
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (setxattr, frame, -1,  op_errno, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-stripe_fsetxattr_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int op_ret, int op_errno, dict_t *xdata)
+stripe_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int op_ret, int op_errno, dict_t *xdata)
 {
-        STRIPE_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
-
 int
-stripe_is_special_key (dict_t *this,
-                       char *key,
-                       data_t *value,
-                       void *data)
+stripe_is_special_key(dict_t *this, char *key, data_t *value, void *data)
 {
-        gf_boolean_t *is_special = NULL;
+    gf_boolean_t *is_special = NULL;
 
-        if (data == NULL) {
-                goto out;
-        }
+    if (data == NULL) {
+        goto out;
+    }
 
-        is_special = data;
+    is_special = data;
 
-        if (XATTR_IS_LOCKINFO (key) || XATTR_IS_BD (key))
-                *is_special = _gf_true;
+    if (XATTR_IS_LOCKINFO(key) || XATTR_IS_BD(key))
+        *is_special = _gf_true;
 
 out:
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_fsetxattr_everyone_cbk (call_frame_t *frame, void *cookie,
-                               xlator_t *this, int32_t op_ret, int32_t op_errno,
-                               dict_t *xdata)
+stripe_fsetxattr_everyone_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        int             call_count = 0;
-        stripe_local_t *local      = NULL;
+    int call_count = 0;
+    stripe_local_t *local = NULL;
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                call_count = --local->wind_count;
+    LOCK(&frame->lock);
+    {
+        call_count = --local->wind_count;
 
-                if (op_ret < 0) {
-                        local->op_ret = op_ret;
-                        local->op_errno = op_errno;
-                }
+        if (op_ret < 0) {
+            local->op_ret = op_ret;
+            local->op_errno = op_errno;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if (call_count == 0) {
-                STRIPE_STACK_UNWIND (fsetxattr, frame, local->op_ret,
-                                     local->op_errno, NULL);
-        }
-        return 0;
+    if (call_count == 0) {
+        STRIPE_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
+                            NULL);
+    }
+    return 0;
 }
 
 int
-stripe_fsetxattr_to_everyone (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                              dict_t *dict, int flags, dict_t *xdata)
+stripe_fsetxattr_to_everyone(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                             dict_t *dict, int flags, dict_t *xdata)
 {
-        xlator_list_t    *trav  = NULL;
-        stripe_private_t *priv  = NULL;
-        int               ret   = -1;
-        stripe_local_t   *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    int ret = -1;
+    stripe_local_t *local = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = mem_get0 (this->local_pool);
-        if (local == NULL) {
-                goto out;
-        }
+    local = mem_get0(this->local_pool);
+    if (local == NULL) {
+        goto out;
+    }
 
-        frame->local = local;
+    frame->local = local;
 
-        local->wind_count = priv->child_count;
+    local->wind_count = priv->child_count;
 
-        trav = this->children;
+    trav = this->children;
 
-        while (trav) {
-                STACK_WIND (frame, stripe_fsetxattr_everyone_cbk,
-                            trav->xlator, trav->xlator->fops->fsetxattr,
-                            fd, dict, flags, xdata);
-                trav = trav->next;
-        }
+    while (trav) {
+        STACK_WIND(frame, stripe_fsetxattr_everyone_cbk, trav->xlator,
+                   trav->xlator->fops->fsetxattr, fd, dict, flags, xdata);
+        trav = trav->next;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 static gf_boolean_t
-stripe_fsetxattr_is_special (dict_t *dict)
+stripe_fsetxattr_is_special(dict_t *dict)
 {
-        gf_boolean_t is_spl = _gf_false;
+    gf_boolean_t is_spl = _gf_false;
 
-        if (dict == NULL) {
-                goto out;
-        }
+    if (dict == NULL) {
+        goto out;
+    }
 
-        dict_foreach (dict, stripe_is_special_key, &is_spl);
+    dict_foreach(dict, stripe_is_special_key, &is_spl);
 
 out:
-        return is_spl;
+    return is_spl;
 }
 
 int
-stripe_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  dict_t *dict, int flags, dict_t *xdata)
+stripe_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+                 int flags, dict_t *xdata)
 {
-        int32_t      op_ret = -1, ret = -1, op_errno = EINVAL;
-        gf_boolean_t is_spl = _gf_false;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
-
-        GF_IF_INTERNAL_XATTR_GOTO ("trusted.*stripe*", dict,
-                                   op_errno, err);
-
-        is_spl = stripe_fsetxattr_is_special (dict);
-        if (is_spl) {
-                ret = stripe_fsetxattr_to_everyone (frame, this, fd, dict,
-                                                    flags, xdata);
-                if (ret < 0) {
-                        op_errno = ENOMEM;
-                        goto err;
-                }
+    int32_t op_ret = -1, ret = -1, op_errno = EINVAL;
+    gf_boolean_t is_spl = _gf_false;
 
-                goto out;
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
+
+    GF_IF_INTERNAL_XATTR_GOTO("trusted.*stripe*", dict, op_errno, err);
+
+    is_spl = stripe_fsetxattr_is_special(dict);
+    if (is_spl) {
+        ret = stripe_fsetxattr_to_everyone(frame, this, fd, dict, flags, xdata);
+        if (ret < 0) {
+            op_errno = ENOMEM;
+            goto err;
         }
 
-        STACK_WIND (frame, stripe_fsetxattr_cbk,
-                    FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fsetxattr,
-                    fd, dict, flags, xdata);
+        goto out;
+    }
+
+    STACK_WIND(frame, stripe_fsetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
 out:
-        return 0;
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
+    return 0;
 }
 
 int
-stripe_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+stripe_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        STRIPE_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int
-stripe_removexattr (call_frame_t *frame, xlator_t *this,
-                    loc_t *loc, const char *name, dict_t *xdata)
+stripe_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   const char *name, dict_t *xdata)
 {
-        int32_t         op_errno = EINVAL;
+    int32_t op_errno = EINVAL;
 
-        VALIDATE_OR_GOTO (this, err);
+    VALIDATE_OR_GOTO(this, err);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.*stripe*",
-                                 name, op_errno, err);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.*stripe*", name, op_errno, err);
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (loc, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(loc, err);
 
-        STACK_WIND (frame, stripe_removexattr_cbk,
-                    FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->removexattr,
-                    loc, name, xdata);
-        return 0;
+    STACK_WIND(frame, stripe_removexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
+    return 0;
 err:
-        STRIPE_STACK_UNWIND (removexattr, frame, -1,  op_errno, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
+    return 0;
 }
 
-
 int
-stripe_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+stripe_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        STRIPE_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int
-stripe_fremovexattr (call_frame_t *frame, xlator_t *this,
-                     fd_t *fd, const char *name, dict_t *xdata)
+stripe_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    const char *name, dict_t *xdata)
 {
-        int32_t         op_ret   = -1;
-        int32_t         op_errno = EINVAL;
+    int32_t op_ret = -1;
+    int32_t op_errno = EINVAL;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        GF_IF_NATIVE_XATTR_GOTO ("trusted.*stripe*",
-                                 name, op_errno, err);
+    GF_IF_NATIVE_XATTR_GOTO("trusted.*stripe*", name, op_errno, err);
 
-        STACK_WIND (frame, stripe_fremovexattr_cbk,
-                    FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fremovexattr,
-                    fd, name, xdata);
-        return 0;
- err:
-        STRIPE_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata);
-        return 0;
+    STACK_WIND(frame, stripe_fremovexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
+    return 0;
+err:
+    STRIPE_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
+    return 0;
 }
 
 int32_t
-stripe_readdirp_lookup_cbk (call_frame_t *frame, void *cookie,
-                            xlator_t *this, int op_ret, int op_errno,
-                            inode_t *inode, struct iatt *stbuf,
-                            dict_t *xattr, struct iatt *parent)
+stripe_readdirp_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int op_ret, int op_errno, inode_t *inode,
+                           struct iatt *stbuf, dict_t *xattr,
+                           struct iatt *parent)
 {
-        stripe_local_t          *local          = NULL;
-        call_frame_t            *main_frame     = NULL;
-        stripe_local_t          *main_local     = NULL;
-        gf_dirent_t             *entry          = NULL;
-        call_frame_t            *prev           = NULL;
-        int                      done           = 0;
-
-        local = frame->local;
-        prev = cookie;
-
-        entry = local->dirent;
-
-        main_frame = local->orig_frame;
-        main_local = main_frame->local;
-        LOCK (&frame->lock);
-        {
-
-                local->call_count--;
-                if (!local->call_count)
-                        done = 1;
-                if (op_ret == -1) {
-                        local->op_errno = op_errno;
-                        local->op_ret = op_ret;
-                        goto unlock;
-                }
+    stripe_local_t *local = NULL;
+    call_frame_t *main_frame = NULL;
+    stripe_local_t *main_local = NULL;
+    gf_dirent_t *entry = NULL;
+    call_frame_t *prev = NULL;
+    int done = 0;
+
+    local = frame->local;
+    prev = cookie;
+
+    entry = local->dirent;
+
+    main_frame = local->orig_frame;
+    main_local = main_frame->local;
+    LOCK(&frame->lock);
+    {
+        local->call_count--;
+        if (!local->call_count)
+            done = 1;
+        if (op_ret == -1) {
+            local->op_errno = op_errno;
+            local->op_ret = op_ret;
+            goto unlock;
+        }
 
-		if (stripe_ctx_handle(this, prev, local, xattr))
-			gf_log(this->name, GF_LOG_ERROR,
-				"Error getting fctx info from dict.");
+        if (stripe_ctx_handle(this, prev, local, xattr))
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Error getting fctx info from dict.");
 
-		correct_file_size(stbuf, local->fctx, prev);
+        correct_file_size(stbuf, local->fctx, prev);
 
-                stripe_iatt_merge (stbuf, &entry->d_stat);
-                local->stbuf_blocks += stbuf->ia_blocks;
-        }
+        stripe_iatt_merge(stbuf, &entry->d_stat);
+        local->stbuf_blocks += stbuf->ia_blocks;
+    }
 unlock:
-        UNLOCK(&frame->lock);
+    UNLOCK(&frame->lock);
 
+    if (done) {
+        inode_ctx_put(entry->inode, this, (uint64_t)(long)local->fctx);
+
+        done = 0;
+        LOCK(&main_frame->lock);
+        {
+            main_local->wind_count--;
+            if (!main_local->wind_count)
+                done = 1;
+            if (local->op_ret == -1) {
+                main_local->op_errno = local->op_errno;
+                main_local->op_ret = local->op_ret;
+            }
+            entry->d_stat.ia_blocks = local->stbuf_blocks;
+        }
+        UNLOCK(&main_frame->lock);
         if (done) {
-                inode_ctx_put (entry->inode, this,
-                               (uint64_t) (long)local->fctx);
-
-                done = 0;
-                LOCK (&main_frame->lock);
-                {
-                        main_local->wind_count--;
-                        if (!main_local->wind_count)
-                                done = 1;
-                        if (local->op_ret == -1) {
-                                main_local->op_errno = local->op_errno;
-                                main_local->op_ret = local->op_ret;
-                        }
-                        entry->d_stat.ia_blocks = local->stbuf_blocks;
-                }
-                UNLOCK (&main_frame->lock);
-                if (done) {
-                        main_frame->local = NULL;
-                        STRIPE_STACK_UNWIND (readdir, main_frame,
-                                             main_local->op_ret,
-                                             main_local->op_errno,
-                                             &main_local->entries, NULL);
-                        gf_dirent_free (&main_local->entries);
-                        stripe_local_wipe (main_local);
-                        mem_put (main_local);
-                }
-                frame->local = NULL;
-                stripe_local_wipe (local);
-                mem_put (local);
-                STRIPE_STACK_DESTROY (frame);
-        }
+            main_frame->local = NULL;
+            STRIPE_STACK_UNWIND(readdir, main_frame, main_local->op_ret,
+                                main_local->op_errno, &main_local->entries,
+                                NULL);
+            gf_dirent_free(&main_local->entries);
+            stripe_local_wipe(main_local);
+            mem_put(main_local);
+        }
+        frame->local = NULL;
+        stripe_local_wipe(local);
+        mem_put(local);
+        STRIPE_STACK_DESTROY(frame);
+    }
 
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     gf_dirent_t *orig_entries, dict_t *xdata)
+stripe_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *orig_entries,
+                    dict_t *xdata)
 {
-        stripe_local_t *local = NULL;
-        call_frame_t   *prev = NULL;
-        gf_dirent_t    *local_entry = NULL;
-        gf_dirent_t    *tmp_entry = NULL;
-        xlator_list_t  *trav = NULL;
-        loc_t          loc = {0, };
-        int32_t        count = 0;
-        stripe_private_t *priv = NULL;
-        int32_t        subvols = 0;
-        dict_t         *xattrs = NULL;
-        call_frame_t   *local_frame = NULL;
-        stripe_local_t *local_ent = NULL;
-
-        if (!this || !frame->local || !cookie) {
-                gf_log ("stripe", GF_LOG_DEBUG, "possible NULL deref");
-                goto out;
-        }
-        prev  = cookie;
-        local = frame->local;
-        trav = this->children;
-        priv = this->private;
+    stripe_local_t *local = NULL;
+    call_frame_t *prev = NULL;
+    gf_dirent_t *local_entry = NULL;
+    gf_dirent_t *tmp_entry = NULL;
+    xlator_list_t *trav = NULL;
+    loc_t loc = {
+        0,
+    };
+    int32_t count = 0;
+    stripe_private_t *priv = NULL;
+    int32_t subvols = 0;
+    dict_t *xattrs = NULL;
+    call_frame_t *local_frame = NULL;
+    stripe_local_t *local_ent = NULL;
+
+    if (!this || !frame->local || !cookie) {
+        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
+        goto out;
+    }
+    prev = cookie;
+    local = frame->local;
+    trav = this->children;
+    priv = this->private;
 
-        subvols = priv->child_count;
+    subvols = priv->child_count;
 
-        LOCK (&frame->lock);
-        {
-                local->op_errno = op_errno;
-                local->op_ret = op_ret;
-
-                if (op_ret != -1) {
-                        list_splice_init (&orig_entries->list,
-                                          &local->entries.list);
-                        local->wind_count = op_ret;
-                }
+    LOCK(&frame->lock);
+    {
+        local->op_errno = op_errno;
+        local->op_ret = op_ret;
 
+        if (op_ret != -1) {
+            list_splice_init(&orig_entries->list, &local->entries.list);
+            local->wind_count = op_ret;
         }
-        UNLOCK (&frame->lock);
+    }
+    UNLOCK(&frame->lock);
 
-        if (op_ret == -1) {
-                gf_log (this->name, GF_LOG_WARNING, "%s returned error %s",
-                        prev->this->name, strerror (op_errno));
-                goto out;
+    if (op_ret == -1) {
+        gf_log(this->name, GF_LOG_WARNING, "%s returned error %s",
+               prev->this->name, strerror(op_errno));
+        goto out;
+    }
+
+    xattrs = dict_new();
+    if (xattrs)
+        (void)stripe_xattr_request_build(this, xattrs, 0, 0, 0, 0);
+    count = op_ret;
+    list_for_each_entry_safe(local_entry, tmp_entry, (&local->entries.list),
+                             list)
+    {
+        if (!local_entry)
+            break;
+        if (!IA_ISREG(local_entry->d_stat.ia_type) || !local_entry->inode) {
+            LOCK(&frame->lock);
+            {
+                local->wind_count--;
+                count = local->wind_count;
+            }
+            UNLOCK(&frame->lock);
+            continue;
+        }
+
+        local_frame = copy_frame(frame);
+
+        if (!local_frame) {
+            op_errno = ENOMEM;
+            op_ret = -1;
+            goto out;
         }
 
-        xattrs = dict_new ();
-        if (xattrs)
-                (void) stripe_xattr_request_build (this, xattrs, 0, 0, 0, 0);
-        count = op_ret;
-        list_for_each_entry_safe (local_entry, tmp_entry,
-                                  (&local->entries.list), list) {
-
-                if (!local_entry)
-                        break;
-                if (!IA_ISREG (local_entry->d_stat.ia_type) || !local_entry->inode) {
-                        LOCK (&frame->lock);
-                        {
-                                local->wind_count--;
-                                count = local->wind_count;
-                        }
-                        UNLOCK (&frame->lock);
-                        continue;
-                }
-
-                local_frame = copy_frame (frame);
-
-                if (!local_frame) {
-                        op_errno = ENOMEM;
-                        op_ret = -1;
-                        goto out;
-                }
-
-                local_ent = mem_get0 (this->local_pool);
-                if (!local_ent) {
-                        op_errno = ENOMEM;
-                        op_ret = -1;
-                        goto out;
-                }
+        local_ent = mem_get0(this->local_pool);
+        if (!local_ent) {
+            op_errno = ENOMEM;
+            op_ret = -1;
+            goto out;
+        }
 
-                loc.inode = inode_ref (local_entry->inode);
+        loc.inode = inode_ref(local_entry->inode);
 
-                gf_uuid_copy (loc.gfid, local_entry->d_stat.ia_gfid);
+        gf_uuid_copy(loc.gfid, local_entry->d_stat.ia_gfid);
 
-                local_ent->orig_frame = frame;
+        local_ent->orig_frame = frame;
 
-                local_ent->call_count = subvols;
+        local_ent->call_count = subvols;
 
-                local_ent->dirent = local_entry;
+        local_ent->dirent = local_entry;
 
-                local_frame->local = local_ent;
+        local_frame->local = local_ent;
 
-                trav = this->children;
-                while (trav) {
-                        STACK_WIND (local_frame, stripe_readdirp_lookup_cbk,
-                                    trav->xlator, trav->xlator->fops->lookup,
-                                    &loc, xattrs);
-                        trav = trav->next;
-                }
-                loc_wipe (&loc);
+        trav = this->children;
+        while (trav) {
+            STACK_WIND(local_frame, stripe_readdirp_lookup_cbk, trav->xlator,
+                       trav->xlator->fops->lookup, &loc, xattrs);
+            trav = trav->next;
         }
+        loc_wipe(&loc);
+    }
 out:
-        if (!count) {
-                /* all entries are directories */
-                frame->local = NULL;
-                STRIPE_STACK_UNWIND (readdir, frame,
-                                     (local ? local->op_ret : -1),
-                                     (local ? local->op_errno : EINVAL),
-                                     (local ? &local->entries : NULL),
-                                     NULL);
-                gf_dirent_free (&local->entries);
-                stripe_local_wipe (local);
-                mem_put (local);
-        }
-        if (xattrs)
-                dict_unref (xattrs);
-        return 0;
-
+    if (!count) {
+        /* all entries are directories */
+        frame->local = NULL;
+        STRIPE_STACK_UNWIND(readdir, frame, (local ? local->op_ret : -1),
+                            (local ? local->op_errno : EINVAL),
+                            (local ? &local->entries : NULL), NULL);
+        gf_dirent_free(&local->entries);
+        stripe_local_wipe(local);
+        mem_put(local);
+    }
+    if (xattrs)
+        dict_unref(xattrs);
+    return 0;
 }
 int32_t
-stripe_readdirp (call_frame_t *frame, xlator_t *this,
-                 fd_t *fd, size_t size, off_t off, dict_t *xdata)
+stripe_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t off, dict_t *xdata)
 {
-        stripe_local_t  *local  = NULL;
-        stripe_private_t *priv = NULL;
-        xlator_list_t   *trav = NULL;
-        int             op_errno = -1;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    xlator_list_t *trav = NULL;
+    int op_errno = -1;
 
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (fd, err);
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(fd, err);
 
-        priv = this->private;
-        trav = this->children;
+    priv = this->private;
+    trav = this->children;
 
-        if (priv->first_child_down) {
-                op_errno = ENOTCONN;
-                goto err;
-        }
+    if (priv->first_child_down) {
+        op_errno = ENOTCONN;
+        goto err;
+    }
 
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        frame->local = local;
+    frame->local = local;
 
-        local->fd = fd_ref (fd);
+    local->fd = fd_ref(fd);
 
-        local->wind_count = 0;
+    local->wind_count = 0;
 
-        local->count = 0;
-        local->op_ret = -1;
-        INIT_LIST_HEAD(&local->entries);
+    local->count = 0;
+    local->op_ret = -1;
+    INIT_LIST_HEAD(&local->entries);
 
-        if (!trav)
-                goto err;
+    if (!trav)
+        goto err;
 
-        STACK_WIND (frame, stripe_readdirp_cbk, trav->xlator,
-                    trav->xlator->fops->readdirp, fd, size, off, xdata);
-        return 0;
+    STACK_WIND(frame, stripe_readdirp_cbk, trav->xlator,
+               trav->xlator->fops->readdirp, fd, size, off, xdata);
+    return 0;
 err:
-        op_errno = (op_errno == -1) ? errno : op_errno;
-        STRIPE_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL);
-
-        return 0;
+    op_errno = (op_errno == -1) ? errno : op_errno;
+    STRIPE_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
 
+    return 0;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        if (!this)
-                goto out;
+    if (!this)
+        goto out;
 
-        ret = xlator_mem_acct_init (this, gf_stripe_mt_end + 1);
+    ret = xlator_mem_acct_init(this, gf_stripe_mt_end + 1);
 
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                        "failed");
-                goto out;
-        }
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               "failed");
+        goto out;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 static int
-clear_pattern_list (stripe_private_t *priv)
+clear_pattern_list(stripe_private_t *priv)
 {
-        struct stripe_options *prev = NULL;
-        struct stripe_options *trav = NULL;
-        int                    ret = -1;
+    struct stripe_options *prev = NULL;
+    struct stripe_options *trav = NULL;
+    int ret = -1;
 
-        GF_VALIDATE_OR_GOTO ("stripe", priv, out);
-
-        trav = priv->pattern;
-        priv->pattern = NULL;
-        while (trav) {
-                prev = trav;
-                trav = trav->next;
-                GF_FREE (prev);
-        }
-
-        ret = 0;
- out:
-        return ret;
+    GF_VALIDATE_OR_GOTO("stripe", priv, out);
 
+    trav = priv->pattern;
+    priv->pattern = NULL;
+    while (trav) {
+        prev = trav;
+        trav = trav->next;
+        GF_FREE(prev);
+    }
 
+    ret = 0;
+out:
+    return ret;
 }
 
-
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
+    stripe_private_t *priv = NULL;
+    data_t *data = NULL;
+    int ret = -1;
+    volume_option_t *opt = NULL;
 
-        stripe_private_t *priv = NULL;
-        data_t           *data = NULL;
-        int               ret = -1;
-        volume_option_t  *opt = NULL;
-
-        GF_ASSERT (this);
-        GF_ASSERT (this->private);
+    GF_ASSERT(this);
+    GF_ASSERT(this->private);
 
-        priv = this->private;
+    priv = this->private;
 
+    ret = 0;
+    LOCK(&priv->lock);
+    {
+        ret = clear_pattern_list(priv);
+        if (ret)
+            goto unlock;
 
-        ret = 0;
-        LOCK (&priv->lock);
-        {
-                ret = clear_pattern_list (priv);
-                if (ret)
-                         goto unlock;
-
-                data = dict_get (options, "block-size");
-                if (data) {
-                        ret = set_stripe_block_size (this, priv, data->data);
-                        if (ret)
-                                goto unlock;
-                } else {
-                        opt = xlator_volume_option_get (this, "block-size");
-                        if (!opt) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "option 'block-size' not found");
-                                ret = -1;
-                                goto unlock;
-                        }
-
-                        if (gf_string2bytesize_uint64 (opt->default_value, &priv->block_size)){
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Unable to set default block-size ");
-                                ret = -1;
-                                goto unlock;
-                        }
-                }
+        data = dict_get(options, "block-size");
+        if (data) {
+            ret = set_stripe_block_size(this, priv, data->data);
+            if (ret)
+                goto unlock;
+        } else {
+            opt = xlator_volume_option_get(this, "block-size");
+            if (!opt) {
+                gf_log(this->name, GF_LOG_WARNING,
+                       "option 'block-size' not found");
+                ret = -1;
+                goto unlock;
+            }
 
-		GF_OPTION_RECONF("coalesce", priv->coalesce, options, bool,
-				unlock);
+            if (gf_string2bytesize_uint64(opt->default_value,
+                                          &priv->block_size)) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "Unable to set default block-size ");
+                ret = -1;
+                goto unlock;
+            }
         }
- unlock:
-        UNLOCK (&priv->lock);
-        if (ret)
-                goto out;
 
-        ret = 0;
- out:
-        return ret;
+        GF_OPTION_RECONF("coalesce", priv->coalesce, options, bool, unlock);
+    }
+unlock:
+    UNLOCK(&priv->lock);
+    if (ret)
+        goto out;
 
+    ret = 0;
+out:
+    return ret;
 }
 
 /**
@@ -5123,129 +4961,126 @@ reconfigure (xlator_t *this, dict_t *options)
  * @this -
  */
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        stripe_private_t *priv = NULL;
-        volume_option_t  *opt = NULL;
-        xlator_list_t    *trav = NULL;
-        data_t           *data = NULL;
-        int32_t           count = 0;
-        int               ret = -1;
-
-        if (!this)
-                goto out;
-
-        trav = this->children;
-        while (trav) {
-                count++;
-                trav = trav->next;
-        }
+    stripe_private_t *priv = NULL;
+    volume_option_t *opt = NULL;
+    xlator_list_t *trav = NULL;
+    data_t *data = NULL;
+    int32_t count = 0;
+    int ret = -1;
+
+    if (!this)
+        goto out;
 
-        if (!count) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "stripe configured without \"subvolumes\" option. "
-                        "exiting");
-                goto out;
-        }
+    trav = this->children;
+    while (trav) {
+        count++;
+        trav = trav->next;
+    }
 
-        if (!this->parents) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "dangling volume. check volfile ");
-        }
+    if (!count) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "stripe configured without \"subvolumes\" option. "
+               "exiting");
+        goto out;
+    }
 
-        if (count == 1) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "stripe configured with only one \"subvolumes\" option."
-                        " please check the volume. exiting");
-                goto out;
-        }
+    if (!this->parents) {
+        gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile ");
+    }
 
-        priv = GF_CALLOC (1, sizeof (stripe_private_t),
-                          gf_stripe_mt_stripe_private_t);
+    if (count == 1) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "stripe configured with only one \"subvolumes\" option."
+               " please check the volume. exiting");
+        goto out;
+    }
 
-        if (!priv)
-                goto out;
-        priv->xl_array = GF_CALLOC (count, sizeof (xlator_t *),
-                                    gf_stripe_mt_xlator_t);
-        if (!priv->xl_array)
-                goto out;
+    priv = GF_CALLOC(1, sizeof(stripe_private_t),
+                     gf_stripe_mt_stripe_private_t);
 
-        priv->last_event = GF_CALLOC (count, sizeof (int),
-                                      gf_stripe_mt_int32_t);
-        if (!priv->last_event)
-                goto out;
+    if (!priv)
+        goto out;
+    priv->xl_array = GF_CALLOC(count, sizeof(xlator_t *),
+                               gf_stripe_mt_xlator_t);
+    if (!priv->xl_array)
+        goto out;
 
-        priv->child_count = count;
-        LOCK_INIT (&priv->lock);
+    priv->last_event = GF_CALLOC(count, sizeof(int), gf_stripe_mt_int32_t);
+    if (!priv->last_event)
+        goto out;
 
-        trav = this->children;
-        count = 0;
-        while (trav) {
-                priv->xl_array[count++] = trav->xlator;
-                trav = trav->next;
-        }
+    priv->child_count = count;
+    LOCK_INIT(&priv->lock);
 
-        if (count > 256) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "maximum number of stripe subvolumes supported "
-                        "is 256");
-                goto out;
-        }
+    trav = this->children;
+    count = 0;
+    while (trav) {
+        priv->xl_array[count++] = trav->xlator;
+        trav = trav->next;
+    }
 
-        ret = 0;
-        LOCK (&priv->lock);
-        {
-                opt = xlator_volume_option_get (this, "block-size");
-                if (!opt) {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "option 'block-size' not found");
-                        ret = -1;
-                        goto unlock;
-                }
-                if (gf_string2bytesize_uint64 (opt->default_value, &priv->block_size)){
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Unable to set default block-size ");
-                        ret = -1;
-                        goto unlock;
-                }
-                /* option stripe-pattern *avi:1GB,*pdf:16K */
-                data = dict_get (this->options, "block-size");
-                if (data) {
-                        ret = set_stripe_block_size (this, priv, data->data);
-                        if (ret)
-                                goto unlock;
-                }
-        }
- unlock:
-        UNLOCK (&priv->lock);
-        if (ret)
-                goto out;
+    if (count > 256) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "maximum number of stripe subvolumes supported "
+               "is 256");
+        goto out;
+    }
+
+    ret = 0;
+    LOCK(&priv->lock);
+    {
+        opt = xlator_volume_option_get(this, "block-size");
+        if (!opt) {
+            gf_log(this->name, GF_LOG_WARNING, "option 'block-size' not found");
+            ret = -1;
+            goto unlock;
+        }
+        if (gf_string2bytesize_uint64(opt->default_value, &priv->block_size)) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Unable to set default block-size ");
+            ret = -1;
+            goto unlock;
+        }
+        /* option stripe-pattern *avi:1GB,*pdf:16K */
+        data = dict_get(this->options, "block-size");
+        if (data) {
+            ret = set_stripe_block_size(this, priv, data->data);
+            if (ret)
+                goto unlock;
+        }
+    }
+unlock:
+    UNLOCK(&priv->lock);
+    if (ret)
+        goto out;
 
-        GF_OPTION_INIT ("use-xattr", priv->xattr_supported, bool, out);
-        /* notify related */
-        priv->nodes_down = priv->child_count;
+    GF_OPTION_INIT("use-xattr", priv->xattr_supported, bool, out);
+    /* notify related */
+    priv->nodes_down = priv->child_count;
 
-	GF_OPTION_INIT("coalesce", priv->coalesce, bool, out);
+    GF_OPTION_INIT("coalesce", priv->coalesce, bool, out);
 
-        this->local_pool = mem_pool_new (stripe_local_t, 128);
-        if (!this->local_pool) {
-                ret = -1;
-                gf_log (this->name, GF_LOG_ERROR,
-                        "failed to create local_t's memory pool");
-                goto out;
-        }
+    this->local_pool = mem_pool_new(stripe_local_t, 128);
+    if (!this->local_pool) {
+        ret = -1;
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to create local_t's memory pool");
+        goto out;
+    }
 
-        this->private = priv;
+    this->private = priv;
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret) {
-                if (priv) {
-                        GF_FREE (priv->xl_array);
-                        GF_FREE (priv);
-                }
+    if (ret) {
+        if (priv) {
+            GF_FREE(priv->xl_array);
+            GF_FREE(priv);
         }
-        return ret;
+    }
+    return ret;
 }
 
 /**
@@ -5253,533 +5088,524 @@ out:
  * @this -
  */
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        stripe_private_t      *priv = NULL;
-        struct stripe_options *prev = NULL;
-        struct stripe_options *trav = NULL;
+    stripe_private_t *priv = NULL;
+    struct stripe_options *prev = NULL;
+    struct stripe_options *trav = NULL;
 
-        if (!this)
-                goto out;
+    if (!this)
+        goto out;
 
-        priv = this->private;
-        if (priv) {
-                this->private = NULL;
-                GF_FREE (priv->xl_array);
-
-                trav = priv->pattern;
-                while (trav) {
-                        prev = trav;
-                        trav = trav->next;
-                        GF_FREE (prev);
-                }
-                GF_FREE (priv->last_event);
-                LOCK_DESTROY (&priv->lock);
-                GF_FREE (priv);
+    priv = this->private;
+    if (priv) {
+        this->private = NULL;
+        GF_FREE(priv->xl_array);
+
+        trav = priv->pattern;
+        while (trav) {
+            prev = trav;
+            trav = trav->next;
+            GF_FREE(prev);
         }
+        GF_FREE(priv->last_event);
+        LOCK_DESTROY(&priv->lock);
+        GF_FREE(priv);
+    }
 
 out:
-        return;
+    return;
 }
 
 int32_t
-stripe_getxattr_unwind (call_frame_t *frame,
-                        int op_ret, int op_errno, dict_t *dict, dict_t *xdata)
+stripe_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno,
+                       dict_t *dict, dict_t *xdata)
 
 {
-        STRIPE_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata);
-        return 0;
+    STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
+    return 0;
 }
 
 int
-stripe_internal_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int op_ret, int op_errno, dict_t *xattr,
-                              dict_t *xdata)
+stripe_internal_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                             int op_ret, int op_errno, dict_t *xattr,
+                             dict_t *xdata)
 {
+    char size_key[256] = {
+        0,
+    };
+    char index_key[256] = {
+        0,
+    };
+    char count_key[256] = {
+        0,
+    };
+    char coalesce_key[256] = {
+        0,
+    };
+
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
+
+    if (!xattr || (op_ret == -1))
+        goto out;
 
-        char        size_key[256]  = {0,};
-        char        index_key[256] = {0,};
-        char        count_key[256] = {0,};
-        char        coalesce_key[256] = {0,};
-
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
-
-        if (!xattr || (op_ret == -1))
-            goto out;
-
-        sprintf (size_key, "trusted.%s.stripe-size", this->name);
-        sprintf (count_key, "trusted.%s.stripe-count", this->name);
-        sprintf (index_key, "trusted.%s.stripe-index", this->name);
-	sprintf (coalesce_key, "trusted.%s.stripe-coalesce", this->name);
+    sprintf(size_key, "trusted.%s.stripe-size", this->name);
+    sprintf(count_key, "trusted.%s.stripe-count", this->name);
+    sprintf(index_key, "trusted.%s.stripe-index", this->name);
+    sprintf(coalesce_key, "trusted.%s.stripe-coalesce", this->name);
 
-        dict_del (xattr, size_key);
-        dict_del (xattr, count_key);
-        dict_del (xattr, index_key);
-        dict_del (xattr, coalesce_key);
+    dict_del(xattr, size_key);
+    dict_del(xattr, count_key);
+    dict_del(xattr, index_key);
+    dict_del(xattr, coalesce_key);
 
 out:
-        STRIPE_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata);
-
-        return 0;
+    STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
 
+    return 0;
 }
 
 int
-stripe_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
+stripe_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        int                     call_cnt = 0;
-        stripe_local_t         *local = NULL;
+    int call_cnt = 0;
+    stripe_local_t *local = NULL;
 
-        VALIDATE_OR_GOTO (frame, out);
-        VALIDATE_OR_GOTO (frame->local, out);
+    VALIDATE_OR_GOTO(frame, out);
+    VALIDATE_OR_GOTO(frame->local, out);
 
-        local = frame->local;
+    local = frame->local;
 
-        LOCK (&frame->lock);
-        {
-                call_cnt = --local->wind_count;
-        }
-        UNLOCK (&frame->lock);
+    LOCK(&frame->lock);
+    {
+        call_cnt = --local->wind_count;
+    }
+    UNLOCK(&frame->lock);
 
-        if (!xattr || (op_ret < 0))
-                goto out;
+    if (!xattr || (op_ret < 0))
+        goto out;
 
-        local->op_ret = 0;
+    local->op_ret = 0;
 
-        if (!local->xattr) {
-                local->xattr = dict_ref (xattr);
-        } else {
-                stripe_aggregate_xattr (local->xattr, xattr);
-        }
+    if (!local->xattr) {
+        local->xattr = dict_ref(xattr);
+    } else {
+        stripe_aggregate_xattr(local->xattr, xattr);
+    }
 
 out:
-        if (!call_cnt) {
-                STRIPE_STACK_UNWIND (getxattr, frame,
-                                     (local ? local->op_ret : -1),
-                                     op_errno,
-                                     (local ? local->xattr : NULL), xdata);
-        }
+    if (!call_cnt) {
+        STRIPE_STACK_UNWIND(getxattr, frame, (local ? local->op_ret : -1),
+                            op_errno, (local ? local->xattr : NULL), xdata);
+    }
 
-        return 0;
+    return 0;
 }
 
 int32_t
-stripe_vgetxattr_cbk (call_frame_t *frame, void *cookie,
-                      xlator_t *this, int32_t op_ret, int32_t op_errno,
-                      dict_t *dict, dict_t *xdata)
+stripe_vgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
 {
-        stripe_local_t      *local         = NULL;
-        int32_t              callcnt       = 0;
-        int32_t              ret           = -1;
-        long                 cky           = 0;
-        void                *xattr_val     = NULL;
-        void                *xattr_serz    = NULL;
-        stripe_xattr_sort_t *xattr         = NULL;
-        dict_t              *stripe_xattr  = NULL;
-
-        if (!frame || !frame->local || !this) {
-                gf_log ("", GF_LOG_ERROR, "Possible NULL deref");
-                return ret;
-        }
+    stripe_local_t *local = NULL;
+    int32_t callcnt = 0;
+    int32_t ret = -1;
+    long cky = 0;
+    void *xattr_val = NULL;
+    void *xattr_serz = NULL;
+    stripe_xattr_sort_t *xattr = NULL;
+    dict_t *stripe_xattr = NULL;
+
+    if (!frame || !frame->local || !this) {
+        gf_log("", GF_LOG_ERROR, "Possible NULL deref");
+        return ret;
+    }
 
-        local = frame->local;
-        cky = (long) cookie;
+    local = frame->local;
+    cky = (long)cookie;
 
-        if (local->xsel[0] == '\0') {
-                gf_log (this->name, GF_LOG_ERROR, "Empty xattr in cbk");
-                return ret;
-        }
+    if (local->xsel[0] == '\0') {
+        gf_log(this->name, GF_LOG_ERROR, "Empty xattr in cbk");
+        return ret;
+    }
 
-        LOCK (&frame->lock);
-        {
-                callcnt = --local->wind_count;
+    LOCK(&frame->lock);
+    {
+        callcnt = --local->wind_count;
 
-                if (!dict || (op_ret < 0))
-                        goto out;
+        if (!dict || (op_ret < 0))
+            goto out;
 
-                if (!local->xattr_list)
-                        local->xattr_list = (stripe_xattr_sort_t *)
-                                GF_CALLOC (local->nallocs,
-                                           sizeof (stripe_xattr_sort_t),
-                                           gf_stripe_mt_xattr_sort_t);
+        if (!local->xattr_list)
+            local->xattr_list = (stripe_xattr_sort_t *)GF_CALLOC(
+                local->nallocs, sizeof(stripe_xattr_sort_t),
+                gf_stripe_mt_xattr_sort_t);
 
-                if (local->xattr_list) {
-                        xattr = local->xattr_list + (int32_t) cky;
+        if (local->xattr_list) {
+            xattr = local->xattr_list + (int32_t)cky;
 
-                        ret = dict_get_ptr_and_len (dict, local->xsel,
-                                                    &xattr_val,
-                                                    &xattr->xattr_len);
-                        if (xattr->xattr_len == 0)
-                                goto out;
+            ret = dict_get_ptr_and_len(dict, local->xsel, &xattr_val,
+                                       &xattr->xattr_len);
+            if (xattr->xattr_len == 0)
+                goto out;
 
-                        xattr->pos = cky;
-                        xattr->xattr_value = gf_memdup (xattr_val,
-                                                        xattr->xattr_len);
+            xattr->pos = cky;
+            xattr->xattr_value = gf_memdup(xattr_val, xattr->xattr_len);
 
-                        if (xattr->xattr_value != NULL)
-                                local->xattr_total_len += xattr->xattr_len + 1;
-                }
+            if (xattr->xattr_value != NULL)
+                local->xattr_total_len += xattr->xattr_len + 1;
         }
- out:
-        UNLOCK (&frame->lock);
-
-        if (!callcnt) {
-                if (!local->xattr_total_len)
-                        goto unwind;
-
-                stripe_xattr = dict_new ();
-                if (!stripe_xattr)
-                        goto unwind;
-
-                /* select filler based on ->xsel */
-                if (XATTR_IS_PATHINFO (local->xsel))
-                        ret = stripe_fill_pathinfo_xattr (this, local,
-                                                          (char **)&xattr_serz);
-                else if (XATTR_IS_LOCKINFO (local->xsel)) {
-                        ret = stripe_fill_lockinfo_xattr (this, local,
-                                                          &xattr_serz);
-                } else {
-                        gf_log (this->name, GF_LOG_WARNING,
-                                "Unknown xattr in xattr request");
-                        goto unwind;
-                }
+    }
+out:
+    UNLOCK(&frame->lock);
 
-                if (!ret) {
-                        ret = dict_set_dynptr (stripe_xattr, local->xsel,
-                                               xattr_serz,
-                                               local->xattr_total_len);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Can't set %s key in dict",
-                                        local->xsel);
-                }
+    if (!callcnt) {
+        if (!local->xattr_total_len)
+            goto unwind;
+
+        stripe_xattr = dict_new();
+        if (!stripe_xattr)
+            goto unwind;
 
-        unwind:
-                /*
-                 * Among other things, STRIPE_STACK_UNWIND will free "local"
-                 * for us.  That means we can't dereference it afterward.
-                 * Fortunately, the actual result is in stripe_xattr now, so we
-                 * can simply clean up before unwinding.
-                 */
-                ret = stripe_free_xattr_str (local);
-                GF_FREE (local->xattr_list);
-                local->xattr_list = NULL;
-
-                STRIPE_STACK_UNWIND (getxattr, frame, op_ret, op_errno,
-                                     stripe_xattr, NULL);
-
-                if (stripe_xattr)
-                        dict_unref (stripe_xattr);
+        /* select filler based on ->xsel */
+        if (XATTR_IS_PATHINFO(local->xsel))
+            ret = stripe_fill_pathinfo_xattr(this, local, (char **)&xattr_serz);
+        else if (XATTR_IS_LOCKINFO(local->xsel)) {
+            ret = stripe_fill_lockinfo_xattr(this, local, &xattr_serz);
+        } else {
+            gf_log(this->name, GF_LOG_WARNING,
+                   "Unknown xattr in xattr request");
+            goto unwind;
         }
 
-        return ret;
+        if (!ret) {
+            ret = dict_set_dynptr(stripe_xattr, local->xsel, xattr_serz,
+                                  local->xattr_total_len);
+            if (ret)
+                gf_log(this->name, GF_LOG_ERROR, "Can't set %s key in dict",
+                       local->xsel);
+        }
+
+    unwind:
+        /*
+         * Among other things, STRIPE_STACK_UNWIND will free "local"
+         * for us.  That means we can't dereference it afterward.
+         * Fortunately, the actual result is in stripe_xattr now, so we
+         * can simply clean up before unwinding.
+         */
+        ret = stripe_free_xattr_str(local);
+        GF_FREE(local->xattr_list);
+        local->xattr_list = NULL;
+
+        STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, stripe_xattr,
+                            NULL);
+
+        if (stripe_xattr)
+            dict_unref(stripe_xattr);
+    }
+
+    return ret;
 }
 
 int
-stripe_marker_populate_args (call_frame_t *frame, int type, int *gauge,
+stripe_marker_populate_args(call_frame_t *frame, int type, int *gauge,
                             xlator_t **subvols)
 {
-        xlator_t         *this  = frame->this;
-        stripe_private_t *priv  = this->private;
-        stripe_local_t   *local = frame->local;
-        int              count  = 0;
-
-        count = priv->child_count;
-        if (MARKER_XTIME_TYPE == type) {
-                if (!IA_FILE_OR_DIR (local->loc.inode->ia_type))
-                        count = 1;
-        }
-        memcpy (subvols, priv->xl_array, sizeof (*subvols) * count);
-
-        return count;
+    xlator_t *this = frame->this;
+    stripe_private_t *priv = this->private;
+    stripe_local_t *local = frame->local;
+    int count = 0;
+
+    count = priv->child_count;
+    if (MARKER_XTIME_TYPE == type) {
+        if (!IA_FILE_OR_DIR(local->loc.inode->ia_type))
+            count = 1;
+    }
+    memcpy(subvols, priv->xl_array, sizeof(*subvols) * count);
+
+    return count;
 }
 
 int32_t
-stripe_getxattr (call_frame_t *frame, xlator_t *this,
-                 loc_t *loc, const char *name, dict_t *xdata)
+stripe_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                const char *name, dict_t *xdata)
 {
-        stripe_local_t    *local    = NULL;
-        xlator_list_t     *trav     = NULL;
-        stripe_private_t  *priv     = NULL;
-        int32_t            op_errno = EINVAL;
-        int                i        = 0;
-        int                ret      = 0;
-
-        VALIDATE_OR_GOTO (frame, err);
-        VALIDATE_OR_GOTO (this, err);
-        VALIDATE_OR_GOTO (loc, err);
-        VALIDATE_OR_GOTO (loc->path, err);
-        VALIDATE_OR_GOTO (loc->inode, err);
-
-        priv = this->private;
-        trav = this->children;
+    stripe_local_t *local = NULL;
+    xlator_list_t *trav = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t op_errno = EINVAL;
+    int i = 0;
+    int ret = 0;
+
+    VALIDATE_OR_GOTO(frame, err);
+    VALIDATE_OR_GOTO(this, err);
+    VALIDATE_OR_GOTO(loc, err);
+    VALIDATE_OR_GOTO(loc->path, err);
+    VALIDATE_OR_GOTO(loc->inode, err);
+
+    priv = this->private;
+    trav = this->children;
+
+    /* Initialization */
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
+    local->op_ret = -1;
+    frame->local = local;
+    loc_copy(&local->loc, loc);
+
+    if (name && strncmp(name, QUOTA_SIZE_KEY, SLEN(QUOTA_SIZE_KEY)) == 0) {
+        local->wind_count = priv->child_count;
 
-        /* Initialization */
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
+        for (i = 0, trav = this->children; i < priv->child_count;
+             i++, trav = trav->next) {
+            STACK_WIND(frame, stripe_getxattr_cbk, trav->xlator,
+                       trav->xlator->fops->getxattr, loc, name, xdata);
         }
-        local->op_ret = -1;
-        frame->local = local;
-        loc_copy (&local->loc, loc);
-
-
-        if (name && strncmp (name, QUOTA_SIZE_KEY,
-                             SLEN (QUOTA_SIZE_KEY)) == 0) {
-                local->wind_count = priv->child_count;
 
-                for (i = 0, trav=this->children; i < priv->child_count; i++,
-                             trav = trav->next) {
-                        STACK_WIND (frame, stripe_getxattr_cbk,
-                                    trav->xlator, trav->xlator->fops->getxattr,
-                                    loc, name, xdata);
-                }
+        return 0;
+    }
 
-                return 0;
+    if (name && (XATTR_IS_PATHINFO(name))) {
+        if (IA_ISREG(loc->inode->ia_type)) {
+            ret = inode_ctx_get(loc->inode, this, (uint64_t *)&local->fctx);
+            if (ret)
+                gf_log(this->name, GF_LOG_ERROR,
+                       "stripe size unavailable from fctx"
+                       " relying on pathinfo could lead to"
+                       " wrong results");
         }
 
-        if (name && (XATTR_IS_PATHINFO (name))) {
-                if (IA_ISREG (loc->inode->ia_type)) {
-                        ret = inode_ctx_get (loc->inode, this,
-                                             (uint64_t *) &local->fctx);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "stripe size unavailable from fctx"
-                                        " relying on pathinfo could lead to"
-                                        " wrong results");
-                }
-
-                local->nallocs = local->wind_count = priv->child_count;
-                (void) strncpy (local->xsel, name, strlen (name));
-
-                /**
-                 * for xattrs that need info from all children, fill ->xsel
-                 * as above and call the filler function in cbk based on
-                 * it
-                 */
-                for (i = 0, trav = this->children; i < priv->child_count; i++,
-                     trav = trav->next) {
-                        STACK_WIND_COOKIE (frame, stripe_vgetxattr_cbk,
-                                           (void *) (long) i, trav->xlator,
-                                           trav->xlator->fops->getxattr,
-                                           loc, name, xdata);
-                }
+        local->nallocs = local->wind_count = priv->child_count;
+        (void)strncpy(local->xsel, name, strlen(name));
 
-                return 0;
+        /**
+         * for xattrs that need info from all children, fill ->xsel
+         * as above and call the filler function in cbk based on
+         * it
+         */
+        for (i = 0, trav = this->children; i < priv->child_count;
+             i++, trav = trav->next) {
+            STACK_WIND_COOKIE(frame, stripe_vgetxattr_cbk, (void *)(long)i,
+                              trav->xlator, trav->xlator->fops->getxattr, loc,
+                              name, xdata);
         }
 
-        if (cluster_handle_marker_getxattr (frame, loc, name, priv->vol_uuid,
-                                            stripe_getxattr_unwind,
-                                            stripe_marker_populate_args) == 0)
-                return 0;
-
-        STACK_WIND (frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
+        return 0;
+    }
 
+    if (cluster_handle_marker_getxattr(frame, loc, name, priv->vol_uuid,
+                                       stripe_getxattr_unwind,
+                                       stripe_marker_populate_args) == 0)
         return 0;
 
+    STACK_WIND(frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
+
+    return 0;
+
 err:
-        STRIPE_STACK_UNWIND (getxattr, frame, -1, op_errno, NULL, NULL);
-        return 0;
+    STRIPE_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
+    return 0;
 }
 
 static gf_boolean_t
-stripe_is_special_xattr (const char *name)
+stripe_is_special_xattr(const char *name)
 {
-        gf_boolean_t    is_spl = _gf_false;
+    gf_boolean_t is_spl = _gf_false;
 
-        if (!name) {
-                goto out;
-        }
+    if (!name) {
+        goto out;
+    }
 
-        if (!strncmp (name, GF_XATTR_LOCKINFO_KEY,
-                      SLEN (GF_XATTR_LOCKINFO_KEY))
-            || XATTR_IS_PATHINFO (name))
-                is_spl = _gf_true;
+    if (!strncmp(name, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) ||
+        XATTR_IS_PATHINFO(name))
+        is_spl = _gf_true;
 out:
-        return is_spl;
+    return is_spl;
 }
 
 int32_t
-stripe_fgetxattr_from_everyone (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                                const char *name, dict_t *xdata)
+stripe_fgetxattr_from_everyone(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                               const char *name, dict_t *xdata)
 {
-        stripe_local_t   *local = NULL;
-        stripe_private_t *priv  = NULL;
-        int32_t           ret   = -1, op_errno = 0;
-        int               i     = 0;
-        xlator_list_t    *trav  = NULL;
+    stripe_local_t *local = NULL;
+    stripe_private_t *priv = NULL;
+    int32_t ret = -1, op_errno = 0;
+    int i = 0;
+    xlator_list_t *trav = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        local = mem_get0 (this->local_pool);
-        if (!local) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    local = mem_get0(this->local_pool);
+    if (!local) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        local->op_ret = -1;
-        frame->local = local;
+    local->op_ret = -1;
+    frame->local = local;
 
-        strncpy (local->xsel, name, strlen (name));
-        local->nallocs = local->wind_count = priv->child_count;
+    strncpy(local->xsel, name, strlen(name));
+    local->nallocs = local->wind_count = priv->child_count;
 
-        for (i = 0, trav = this->children; i < priv->child_count; i++,
-                     trav = trav->next) {
-                STACK_WIND_COOKIE (frame, stripe_vgetxattr_cbk,
-                                   (void *) (long) i, trav->xlator,
-                                   trav->xlator->fops->fgetxattr,
-                                   fd, name, xdata);
-        }
+    for (i = 0, trav = this->children; i < priv->child_count;
+         i++, trav = trav->next) {
+        STACK_WIND_COOKIE(frame, stripe_vgetxattr_cbk, (void *)(long)i,
+                          trav->xlator, trav->xlator->fops->fgetxattr, fd, name,
+                          xdata);
+    }
 
-        return 0;
+    return 0;
 
 err:
-        STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL, NULL);
-        return ret;
+    STACK_UNWIND_STRICT(fgetxattr, frame, -1, op_errno, NULL, NULL);
+    return ret;
 }
 
 int32_t
-stripe_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                  const char *name, dict_t *xdata)
+stripe_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 const char *name, dict_t *xdata)
 {
-        if (stripe_is_special_xattr (name)) {
-                stripe_fgetxattr_from_everyone (frame, this, fd, name, xdata);
-                goto out;
-        }
+    if (stripe_is_special_xattr(name)) {
+        stripe_fgetxattr_from_everyone(frame, this, fd, name, xdata);
+        goto out;
+    }
 
-        STACK_WIND (frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
+    STACK_WIND(frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
 
 out:
-        return 0;
+    return 0;
 }
 
-
-
 int32_t
-stripe_priv_dump (xlator_t *this)
+stripe_priv_dump(xlator_t *this)
 {
-        char                    key[GF_DUMP_MAX_BUF_LEN];
-        int                     i = 0;
-        stripe_private_t       *priv = NULL;
-        int                     ret = -1;
-        struct stripe_options  *options = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN];
+    int i = 0;
+    stripe_private_t *priv = NULL;
+    int ret = -1;
+    struct stripe_options *options = NULL;
 
-        GF_VALIDATE_OR_GOTO ("stripe", this, out);
+    GF_VALIDATE_OR_GOTO("stripe", this, out);
 
-        priv = this->private;
-        if (!priv)
-                goto out;
+    priv = this->private;
+    if (!priv)
+        goto out;
 
-        ret = TRY_LOCK (&priv->lock);
-        if (ret != 0)
-                goto out;
+    ret = TRY_LOCK(&priv->lock);
+    if (ret != 0)
+        goto out;
 
-        gf_proc_dump_add_section("xlator.cluster.stripe.%s.priv", this->name);
-        gf_proc_dump_write("child_count","%d", priv->child_count);
+    gf_proc_dump_add_section("xlator.cluster.stripe.%s.priv", this->name);
+    gf_proc_dump_write("child_count", "%d", priv->child_count);
 
-        for (i = 0; i < priv->child_count; i++) {
-                sprintf (key, "subvolumes[%d]", i);
-                gf_proc_dump_write (key, "%s.%s", priv->xl_array[i]->type,
-                                    priv->xl_array[i]->name);
-        }
+    for (i = 0; i < priv->child_count; i++) {
+        sprintf(key, "subvolumes[%d]", i);
+        gf_proc_dump_write(key, "%s.%s", priv->xl_array[i]->type,
+                           priv->xl_array[i]->name);
+    }
 
-        options = priv->pattern;
-        while (options != NULL) {
-                gf_proc_dump_write ("path_pattern", "%s", priv->pattern->path_pattern);
-                gf_proc_dump_write ("options_block_size", "%ul", options->block_size);
+    options = priv->pattern;
+    while (options != NULL) {
+        gf_proc_dump_write("path_pattern", "%s", priv->pattern->path_pattern);
+        gf_proc_dump_write("options_block_size", "%ul", options->block_size);
 
-                options = options->next;
-        }
+        options = options->next;
+    }
 
-        gf_proc_dump_write ("block_size", "%ul", priv->block_size);
-        gf_proc_dump_write ("nodes-down", "%d", priv->nodes_down);
-        gf_proc_dump_write ("first-child_down", "%d", priv->first_child_down);
-        gf_proc_dump_write ("xattr_supported", "%d", priv->xattr_supported);
+    gf_proc_dump_write("block_size", "%ul", priv->block_size);
+    gf_proc_dump_write("nodes-down", "%d", priv->nodes_down);
+    gf_proc_dump_write("first-child_down", "%d", priv->first_child_down);
+    gf_proc_dump_write("xattr_supported", "%d", priv->xattr_supported);
 
-        UNLOCK (&priv->lock);
+    UNLOCK(&priv->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 struct xlator_fops fops = {
-        .stat           = stripe_stat,
-        .unlink         = stripe_unlink,
-        .rename         = stripe_rename,
-        .link           = stripe_link,
-        .truncate       = stripe_truncate,
-        .create         = stripe_create,
-        .open           = stripe_open,
-        .readv          = stripe_readv,
-        .writev         = stripe_writev,
-        .statfs         = stripe_statfs,
-        .flush          = stripe_flush,
-        .fsync          = stripe_fsync,
-        .ftruncate      = stripe_ftruncate,
-        .fstat          = stripe_fstat,
-        .mkdir          = stripe_mkdir,
-        .rmdir          = stripe_rmdir,
-        .lk             = stripe_lk,
-        .opendir        = stripe_opendir,
-        .fsyncdir       = stripe_fsyncdir,
-        .setattr        = stripe_setattr,
-        .fsetattr       = stripe_fsetattr,
-        .lookup         = stripe_lookup,
-        .mknod          = stripe_mknod,
-        .setxattr       = stripe_setxattr,
-        .fsetxattr      = stripe_fsetxattr,
-        .getxattr       = stripe_getxattr,
-        .fgetxattr      = stripe_fgetxattr,
-        .removexattr    = stripe_removexattr,
-        .fremovexattr   = stripe_fremovexattr,
-        .readdirp       = stripe_readdirp,
-	.fallocate	= stripe_fallocate,
-	.discard	= stripe_discard,
-        .zerofill       = stripe_zerofill,
-        .seek           = stripe_seek,
+    .stat = stripe_stat,
+    .unlink = stripe_unlink,
+    .rename = stripe_rename,
+    .link = stripe_link,
+    .truncate = stripe_truncate,
+    .create = stripe_create,
+    .open = stripe_open,
+    .readv = stripe_readv,
+    .writev = stripe_writev,
+    .statfs = stripe_statfs,
+    .flush = stripe_flush,
+    .fsync = stripe_fsync,
+    .ftruncate = stripe_ftruncate,
+    .fstat = stripe_fstat,
+    .mkdir = stripe_mkdir,
+    .rmdir = stripe_rmdir,
+    .lk = stripe_lk,
+    .opendir = stripe_opendir,
+    .fsyncdir = stripe_fsyncdir,
+    .setattr = stripe_setattr,
+    .fsetattr = stripe_fsetattr,
+    .lookup = stripe_lookup,
+    .mknod = stripe_mknod,
+    .setxattr = stripe_setxattr,
+    .fsetxattr = stripe_fsetxattr,
+    .getxattr = stripe_getxattr,
+    .fgetxattr = stripe_fgetxattr,
+    .removexattr = stripe_removexattr,
+    .fremovexattr = stripe_fremovexattr,
+    .readdirp = stripe_readdirp,
+    .fallocate = stripe_fallocate,
+    .discard = stripe_discard,
+    .zerofill = stripe_zerofill,
+    .seek = stripe_seek,
 };
 
 struct xlator_cbks cbks = {
-        .release = stripe_release,
-        .forget  = stripe_forget,
+    .release = stripe_release,
+    .forget = stripe_forget,
 };
 
 struct xlator_dumpops dumpops = {
-        .priv = stripe_priv_dump,
+    .priv = stripe_priv_dump,
 };
 
 struct volume_options options[] = {
-        { .key  = {"block-size"},
-          .type = GF_OPTION_TYPE_SIZE_LIST,
-          .default_value = "128KB",
-          .min = STRIPE_MIN_BLOCK_SIZE,
-          .description = "Size of the stripe unit that would be read "
-          "from or written to the striped servers.",
-          .op_version = { 1 },
-          .tags = { "stripe" },
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-        },
-        { .key  = {"use-xattr"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "true",
-          .description = "handle the stripe without the xattr",
-          .tags = { "stripe", "dev-only" },
-          .flags = OPT_FLAG_CLIENT_OPT,
-        },
-	{ .key = {"coalesce"},
-	  .type = GF_OPTION_TYPE_BOOL,
-	  .default_value = "true",
-	  .description = "Enable/Disable coalesce mode to flatten striped "
-          "files as stored on the server (i.e., eliminate holes "
-          "caused by the traditional format).",
-          .op_version = { 1 },
-          .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-          .tags = { "stripe" },
-	},
-        { .key  = {NULL} },
+    {
+        .key = {"block-size"},
+        .type = GF_OPTION_TYPE_SIZE_LIST,
+        .default_value = "128KB",
+        .min = STRIPE_MIN_BLOCK_SIZE,
+        .description = "Size of the stripe unit that would be read "
+                       "from or written to the striped servers.",
+        .op_version = {1},
+        .tags = {"stripe"},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+    },
+    {
+        .key = {"use-xattr"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "true",
+        .description = "handle the stripe without the xattr",
+        .tags = {"stripe", "dev-only"},
+        .flags = OPT_FLAG_CLIENT_OPT,
+    },
+    {
+        .key = {"coalesce"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "true",
+        .description = "Enable/Disable coalesce mode to flatten striped "
+                       "files as stored on the server (i.e., eliminate holes "
+                       "caused by the traditional format).",
+        .op_version = {1},
+        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
+        .tags = {"stripe"},
+    },
+    {.key = {NULL}},
 };
diff --git a/xlators/debug/delay-gen/src/delay-gen.c b/xlators/debug/delay-gen/src/delay-gen.c
index 849ebeaabcd..a2d02527f23 100644
--- a/xlators/debug/delay-gen/src/delay-gen.c
+++ b/xlators/debug/delay-gen/src/delay-gen.c
@@ -8,741 +8,675 @@
  *  cases as published by the Free Software Foundation.
  */
 
-
 #include "delay-gen.h"
 
-#define DELAY_GRANULARITY     (1 << 20)
+#define DELAY_GRANULARITY (1 << 20)
 
 #define DG_FOP(fop, name, frame, this, args...)                                \
-        do {                                                                   \
-                delay_gen (this, fop);                                         \
-                default_##name (frame, this, args);                            \
-        } while (0)
+    do {                                                                       \
+        delay_gen(this, fop);                                                  \
+        default_##name(frame, this, args);                                     \
+    } while (0)
 
 int
-delay_gen (xlator_t *this, int fop)
+delay_gen(xlator_t *this, int fop)
 {
-        dg_t             *dg = this->private;
+    dg_t *dg = this->private;
 
-        if (!dg->enable[fop] || !dg->delay_ppm)
-                return 0;
+    if (!dg->enable[fop] || !dg->delay_ppm)
+        return 0;
 
-        if ((rand () % DELAY_GRANULARITY) < dg->delay_ppm)
-                usleep (dg->delay_duration);
+    if ((rand() % DELAY_GRANULARITY) < dg->delay_ppm)
+        usleep(dg->delay_duration);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-dg_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-           dict_t *xdata)
+dg_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+          dict_t *xdata)
 {
-        DG_FOP (GF_FOP_RENAME, rename, frame, this,  oldloc,  newloc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_RENAME, rename, frame, this, oldloc, newloc, xdata);
+    return 0;
 }
 
-
 int32_t
-dg_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
+dg_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_IPC, ipc, frame, this, op, xdata);
-        return 0;
+    DG_FOP(GF_FOP_IPC, ipc, frame, this, op, xdata);
+    return 0;
 }
 
 int32_t
-dg_setactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                lock_migration_info_t *locklist, dict_t *xdata)
+dg_setactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               lock_migration_info_t *locklist, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_SETACTIVELK, setactivelk, frame, this, loc,
-                locklist, xdata);
-        return 0;
+    DG_FOP(GF_FOP_SETACTIVELK, setactivelk, frame, this, loc, locklist, xdata);
+    return 0;
 }
 
 int32_t
-dg_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dg_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FLUSH, flush, frame, this, fd, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FLUSH, flush, frame, this, fd, xdata);
+    return 0;
 }
 
 int32_t
-dg_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-            off_t off, dict_t *xdata)
+dg_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+           off_t off, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_READDIR, readdir, frame, this,  fd, size, off, xdata);
-        return 0;
+    DG_FOP(GF_FOP_READDIR, readdir, frame, this, fd, size, off, xdata);
+    return 0;
 }
 
 int32_t
-dg_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-             int32_t flags, dict_t *xdata)
+dg_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+            int32_t flags, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_SETXATTR, setxattr, frame, this, loc, dict, flags,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_SETXATTR, setxattr, frame, this, loc, dict, flags, xdata);
+    return 0;
 }
 
 int32_t
-dg_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dev_t rdev, mode_t umask, dict_t *xdata)
+dg_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+         dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_MKNOD, mknod, frame, this, loc, mode, rdev, umask,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_MKNOD, mknod, frame, this, loc, mode, rdev, umask, xdata);
+    return 0;
 }
 
 int32_t
-dg_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int32_t flags, dict_t *xdata)
+dg_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+             int32_t flags, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FSETXATTR, fsetxattr, frame, this, fd, dict, flags,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_FSETXATTR, fsetxattr, frame, this, fd, dict, flags, xdata);
+    return 0;
 }
 
 int32_t
-dg_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-          off_t offset, uint32_t flags, dict_t *xdata)
+dg_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+         off_t offset, uint32_t flags, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_READ, readv, frame, this, fd, size, offset, flags,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_READ, readv, frame, this, fd, size, offset, flags, xdata);
+    return 0;
 }
 
 int32_t
-dg_inodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-            loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+dg_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+           int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_INODELK, inodelk, frame, this, volume, loc, cmd, lock,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_INODELK, inodelk, frame, this, volume, loc, cmd, lock, xdata);
+    return 0;
 }
 
 int32_t
-dg_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name, dict_t *xdata)
+dg_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+                dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FREMOVEXATTR, fremovexattr, frame, this, fd, name,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_FREMOVEXATTR, fremovexattr, frame, this, fd, name, xdata);
+    return 0;
 }
 
 int32_t
-dg_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, dict_t *xdata)
+dg_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+        fd_t *fd, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_OPEN, open, frame, this, loc, flags, fd, xdata);
-        return 0;
+    DG_FOP(GF_FOP_OPEN, open, frame, this, loc, flags, fd, xdata);
+    return 0;
 }
 
 int32_t
-dg_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dg_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+           gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_XATTROP, xattrop, frame, this, loc, flags, dict, xdata);
-        return 0;
+    DG_FOP(GF_FOP_XATTROP, xattrop, frame, this, loc, flags, dict, xdata);
+    return 0;
 }
 
 int32_t
-dg_entrylk (call_frame_t *frame, xlator_t *this, const char *volume,
-            loc_t *loc, const char *basename, entrylk_cmd cmd,
-            entrylk_type type, dict_t *xdata)
+dg_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+           const char *basename, entrylk_cmd cmd, entrylk_type type,
+           dict_t *xdata)
 {
-        DG_FOP (GF_FOP_ENTRYLK, entrylk, frame, this, volume,
-                loc, basename, cmd, type, xdata);
-        return 0;
+    DG_FOP(GF_FOP_ENTRYLK, entrylk, frame, this, volume, loc, basename, cmd,
+           type, xdata);
+    return 0;
 }
 
 int32_t
-dg_getactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dg_getactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_GETACTIVELK, getactivelk, frame, this, loc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_GETACTIVELK, getactivelk, frame, this, loc, xdata);
+    return 0;
 }
 
 int32_t
-dg_finodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-             fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+dg_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+            int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FINODELK, finodelk, frame, this, volume, fd, cmd, lock,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_FINODELK, finodelk, frame, this, volume, fd, cmd, lock,
+           xdata);
+    return 0;
 }
 
 int32_t
-dg_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+dg_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+          mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_CREATE, create, frame, this, loc, flags, mode, umask, fd,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_CREATE, create, frame, this, loc, flags, mode, umask, fd,
+           xdata);
+    return 0;
 }
 
 int32_t
-dg_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            size_t len, dict_t *xdata)
+dg_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+           size_t len, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_DISCARD, discard, frame, this, fd, offset, len, xdata);
-        return 0;
+    DG_FOP(GF_FOP_DISCARD, discard, frame, this, fd, offset, len, xdata);
+    return 0;
 }
 
 int32_t
-dg_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          mode_t umask, dict_t *xdata)
+dg_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+         mode_t umask, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_MKDIR, mkdir, frame, this, loc, mode, umask, xdata);
-        return 0;
+    DG_FOP(GF_FOP_MKDIR, mkdir, frame, this, loc, mode, umask, xdata);
+    return 0;
 }
 
 int32_t
-dg_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-       struct gf_flock *lock, dict_t *xdata)
+dg_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+      struct gf_flock *lock, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_LK, lk, frame, this, fd, cmd, lock, xdata);
-        return 0;
+    DG_FOP(GF_FOP_LK, lk, frame, this, fd, cmd, lock, xdata);
+    return 0;
 }
 
 int32_t
-dg_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-           struct iovec *vector, int32_t count, off_t off, uint32_t flags,
-           struct iobref *iobref, dict_t *xdata)
+dg_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+          int32_t count, off_t off, uint32_t flags, struct iobref *iobref,
+          dict_t *xdata)
 {
-        DG_FOP (GF_FOP_WRITE, writev, frame, this, fd,
-                vector, count, off, flags, iobref, xdata);
-        return 0;
+    DG_FOP(GF_FOP_WRITE, writev, frame, this, fd, vector, count, off, flags,
+           iobref, xdata);
+    return 0;
 }
 
 int32_t
-dg_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-           dict_t *xdata)
+dg_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+          dict_t *xdata)
 {
-        DG_FOP (GF_FOP_ACCESS, access, frame, this, loc, mask, xdata);
-        return 0;
+    DG_FOP(GF_FOP_ACCESS, access, frame, this, loc, mask, xdata);
+    return 0;
 }
 
 int32_t
-dg_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dg_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_LOOKUP, lookup, frame, this, loc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_LOOKUP, lookup, frame, this, loc, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc,
-          int32_t flags, dict_t *xdata)
+dg_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+         dict_t *xdata)
 {
-        DG_FOP (GF_FOP_RMDIR, rmdir, frame, this, loc, flags, xdata);
-        return 0;
+    DG_FOP(GF_FOP_RMDIR, rmdir, frame, this, loc, flags, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size,
-              off_t offset, size_t len, dict_t *xdata)
+dg_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size,
+             off_t offset, size_t len, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FALLOCATE, fallocate, frame, this, fd, keep_size, offset,
-                len, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FALLOCATE, fallocate, frame, this, fd, keep_size, offset, len,
+           xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+dg_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FSTAT, fstat, frame, this, fd, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FSTAT, fstat, frame, this, fd, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_lease (call_frame_t *frame, xlator_t *this, loc_t *loc,
-          struct gf_lease *lease, dict_t *xdata)
+dg_lease(call_frame_t *frame, xlator_t *this, loc_t *loc,
+         struct gf_lease *lease, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_LEASE, lease, frame, this, loc, lease, xdata);
-        return 0;
+    DG_FOP(GF_FOP_LEASE, lease, frame, this, loc, lease, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dg_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_STAT, stat, frame, this, loc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_STAT, stat, frame, this, loc, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-             dict_t *xdata)
+dg_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+            dict_t *xdata)
 {
-        DG_FOP (GF_FOP_TRUNCATE, truncate, frame, this, loc, offset, xdata);
-        return 0;
+    DG_FOP(GF_FOP_TRUNCATE, truncate, frame, this, loc, offset, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             const char *name, dict_t *xdata)
+dg_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+            dict_t *xdata)
 {
-        DG_FOP (GF_FOP_GETXATTR, getxattr, frame, this, loc, name, xdata);
-        return 0;
+    DG_FOP(GF_FOP_GETXATTR, getxattr, frame, this, loc, name, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-            loc_t *loc, mode_t umask, dict_t *xdata)
+dg_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+           loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_SYMLINK, symlink, frame, this, linkpath, loc, umask,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_SYMLINK, symlink, frame, this, linkpath, loc, umask, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             off_t len, dict_t *xdata)
+dg_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            off_t len, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_ZEROFILL, zerofill, frame, this, fd, offset, len, xdata);
-        return 0;
+    DG_FOP(GF_FOP_ZEROFILL, zerofill, frame, this, fd, offset, len, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-             dict_t *xdata)
+dg_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+            dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FSYNCDIR, fsyncdir, frame, this, fd, flags, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FSYNCDIR, fsyncdir, frame, this, fd, flags, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
-              dict_t *xdata)
+dg_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+             dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FGETXATTR, fgetxattr, frame, this, fd, name, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FGETXATTR, fgetxattr, frame, this, fd, name, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t off, dict_t *xdata)
+dg_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t off, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_READDIRP, readdirp, frame, this, fd, size, off,  xdata);
-        return 0;
+    DG_FOP(GF_FOP_READDIRP, readdirp, frame, this, fd, size, off, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-         dict_t *xdata)
+dg_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+        dict_t *xdata)
 {
-        DG_FOP (GF_FOP_LINK, link, frame, this, oldloc, newloc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_LINK, link, frame, this, oldloc, newloc, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+dg_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FXATTROP, fxattrop, frame, this, fd, flags, dict, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FXATTROP, fxattrop, frame, this, fd, flags, dict, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              dict_t *xdata)
+dg_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FTRUNCATE, ftruncate, frame, this, fd, offset,  xdata);
-        return 0;
+    DG_FOP(GF_FOP_FTRUNCATE, ftruncate, frame, this, fd, offset, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              int32_t len, dict_t *xdata)
+dg_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             int32_t len, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_RCHECKSUM, rchecksum, frame, this, fd, offset, len,
-                xdata);
-        return 0;
+    DG_FOP(GF_FOP_RCHECKSUM, rchecksum, frame, this, fd, offset, len, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           dict_t *xdata)
+dg_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+          dict_t *xdata)
 {
-        DG_FOP (GF_FOP_UNLINK, unlink, frame, this, loc, flags, xdata);
-        return 0;
+    DG_FOP(GF_FOP_UNLINK, unlink, frame, this, loc, flags, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume,
-             fd_t *fd, const char *basename, entrylk_cmd cmd,
-             entrylk_type type, dict_t *xdata)
+dg_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
+            const char *basename, entrylk_cmd cmd, entrylk_type type,
+            dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FENTRYLK, fentrylk, frame, this, volume,  fd, basename,
-                cmd, type, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FENTRYLK, fentrylk, frame, this, volume, fd, basename, cmd,
+           type, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_getspec (call_frame_t *frame, xlator_t *this, const char *key,
-            int32_t flags)
+dg_getspec(call_frame_t *frame, xlator_t *this, const char *key, int32_t flags)
 {
-        DG_FOP (GF_FOP_GETSPEC, getspec, frame, this, key, flags);
-        return 0;
+    DG_FOP(GF_FOP_GETSPEC, getspec, frame, this, key, flags);
+    return 0;
 }
 
-
-
 int32_t
-dg_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            struct iatt *stbuf, int32_t valid, dict_t *xdata)
+dg_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+           int32_t valid, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_SETATTR, setattr, frame, this, loc, stbuf, valid, xdata);
-        return 0;
+    DG_FOP(GF_FOP_SETATTR, setattr, frame, this, loc, stbuf, valid, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-          dict_t *xdata)
+dg_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+         dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FSYNC, fsync, frame, this,  fd, flags, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FSYNC, fsync, frame, this, fd, flags, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+dg_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_STATFS, statfs, frame, this, loc, xdata);
-        return 0;
+    DG_FOP(GF_FOP_STATFS, statfs, frame, this, loc, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-         gf_seek_what_t what, dict_t *xdata)
+dg_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+        gf_seek_what_t what, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_SEEK, seek, frame, this, fd, offset, what, xdata);
-        return 0;
+    DG_FOP(GF_FOP_SEEK, seek, frame, this, fd, offset, what, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-             struct iatt *stbuf, int32_t valid, dict_t *xdata)
+dg_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
+            int32_t valid, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_FSETATTR, fsetattr, frame, this, fd,
-                stbuf, valid, xdata);
-        return 0;
+    DG_FOP(GF_FOP_FSETATTR, fsetattr, frame, this, fd, stbuf, valid, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-            dict_t *xdata)
+dg_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+           dict_t *xdata)
 {
-        DG_FOP (GF_FOP_OPENDIR, opendir, frame, this, loc, fd, xdata);
-        return 0;
+    DG_FOP(GF_FOP_OPENDIR, opendir, frame, this, loc, fd, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-             dict_t *xdata)
+dg_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+            dict_t *xdata)
 {
-        DG_FOP (GF_FOP_READLINK, readlink, frame, this, loc, size, xdata);
-        return 0;
+    DG_FOP(GF_FOP_READLINK, readlink, frame, this, loc, size, xdata);
+    return 0;
 }
 
-
-
 int32_t
-dg_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name, dict_t *xdata)
+dg_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               const char *name, dict_t *xdata)
 {
-        DG_FOP (GF_FOP_REMOVEXATTR, removexattr, frame, this, loc, name, xdata);
-        return 0;
+    DG_FOP(GF_FOP_REMOVEXATTR, removexattr, frame, this, loc, name, xdata);
+    return 0;
 }
 
 int32_t
-dg_forget (xlator_t *this, inode_t *inode)
+dg_forget(xlator_t *this, inode_t *inode)
 {
-        return 0;
+    return 0;
 }
 
 int32_t
-dg_release (xlator_t *this, fd_t *fd)
+dg_release(xlator_t *this, fd_t *fd)
 {
-        return 0;
+    return 0;
 }
 
 int32_t
-dg_releasedir (xlator_t *this, fd_t *fd)
+dg_releasedir(xlator_t *this, fd_t *fd)
 {
-        return 0;
+    return 0;
 }
 
 static int
-delay_gen_parse_fill_fops (dg_t *dg, char *enable_fops)
-{
-        char            *op_no_str = NULL;
-        int              op_no = -1;
-        int              i = 0;
-        int              ret = 0;
-        xlator_t        *this = THIS;
-        char            *saveptr = NULL;
-        char            *dup_enable_fops = NULL;
-
-        if (strlen (enable_fops) == 0) {
-                for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++)
-                        dg->enable[i] = 1;
-        } else {
-                dup_enable_fops = gf_strdup (enable_fops);
-                if (!dup_enable_fops) {
-                        ret = -1;
-                        goto out;
-                }
-                op_no_str = strtok_r (dup_enable_fops, ",", &saveptr);
-                while (op_no_str) {
-                        op_no = gf_fop_int (op_no_str);
-                        if (op_no == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "Wrong option value %s", op_no_str);
-                                ret = -1;
-                                goto out;
-                        } else {
-                                dg->enable[op_no] = 1;
-                        }
-
-                        op_no_str = strtok_r (NULL, ",", &saveptr);
-                }
+delay_gen_parse_fill_fops(dg_t *dg, char *enable_fops)
+{
+    char *op_no_str = NULL;
+    int op_no = -1;
+    int i = 0;
+    int ret = 0;
+    xlator_t *this = THIS;
+    char *saveptr = NULL;
+    char *dup_enable_fops = NULL;
+
+    if (strlen(enable_fops) == 0) {
+        for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++)
+            dg->enable[i] = 1;
+    } else {
+        dup_enable_fops = gf_strdup(enable_fops);
+        if (!dup_enable_fops) {
+            ret = -1;
+            goto out;
+        }
+        op_no_str = strtok_r(dup_enable_fops, ",", &saveptr);
+        while (op_no_str) {
+            op_no = gf_fop_int(op_no_str);
+            if (op_no == -1) {
+                gf_log(this->name, GF_LOG_WARNING, "Wrong option value %s",
+                       op_no_str);
+                ret = -1;
+                goto out;
+            } else {
+                dg->enable[op_no] = 1;
+            }
+
+            op_no_str = strtok_r(NULL, ",", &saveptr);
         }
+    }
 out:
-        GF_FREE (dup_enable_fops);
-        return ret;
+    GF_FREE(dup_enable_fops);
+    return ret;
 }
 
 void
-delay_gen_set_delay_ppm (dg_t *dg, double percent)
+delay_gen_set_delay_ppm(dg_t *dg, double percent)
 {
-        double ppm;
+    double ppm;
 
-        ppm = (percent / 100.0) * (double) DELAY_GRANULARITY;
-        dg->delay_ppm = ppm;
+    ppm = (percent / 100.0) * (double)DELAY_GRANULARITY;
+    dg->delay_ppm = ppm;
 }
 
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        dg_t            *dg = NULL;
-        int32_t          ret = 0;
-        double          delay_percent = 0;
-        char            *delay_enable_fops = NULL;
-
-        if (!this->children || this->children->next) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "delay-gen not configured with one subvolume");
-                ret = -1;
-                goto out;
-        }
+    dg_t *dg = NULL;
+    int32_t ret = 0;
+    double delay_percent = 0;
+    char *delay_enable_fops = NULL;
 
-        if (!this->parents) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "dangling volume. check volfile ");
-        }
+    if (!this->children || this->children->next) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "delay-gen not configured with one subvolume");
+        ret = -1;
+        goto out;
+    }
 
-        dg = GF_CALLOC (1, sizeof (*dg), gf_delay_gen_mt_dg_t);
+    if (!this->parents) {
+        gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile ");
+    }
 
-        if (!dg) {
-                ret = -1;
-                goto out;
-        }
+    dg = GF_CALLOC(1, sizeof(*dg), gf_delay_gen_mt_dg_t);
 
+    if (!dg) {
         ret = -1;
+        goto out;
+    }
 
-        GF_OPTION_INIT ("delay-percentage", delay_percent, percent, out);
-        GF_OPTION_INIT ("enable", delay_enable_fops, str, out);
-        GF_OPTION_INIT ("delay-duration", dg->delay_duration, int32, out);
+    ret = -1;
 
-        delay_gen_set_delay_ppm (dg, delay_percent);
+    GF_OPTION_INIT("delay-percentage", delay_percent, percent, out);
+    GF_OPTION_INIT("enable", delay_enable_fops, str, out);
+    GF_OPTION_INIT("delay-duration", dg->delay_duration, int32, out);
 
-        ret = delay_gen_parse_fill_fops (dg, delay_enable_fops);
-        if (ret)
-                goto out;
+    delay_gen_set_delay_ppm(dg, delay_percent);
+
+    ret = delay_gen_parse_fill_fops(dg, delay_enable_fops);
+    if (ret)
+        goto out;
 
-        this->private = dg;
+    this->private = dg;
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret)
-                GF_FREE (dg);
-        return ret;
+    if (ret)
+        GF_FREE(dg);
+    return ret;
 }
 
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        GF_FREE (this->private);
+    GF_FREE(this->private);
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        if (!this)
-                return ret;
-
-        ret = xlator_mem_acct_init (this, gf_delay_gen_mt_end + 1);
+    if (!this)
+        return ret;
 
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                        " failed");
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_delay_gen_mt_end + 1);
 
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               " failed");
         return ret;
+    }
+
+    return ret;
 }
 
 int32_t
-reconfigure (xlator_t *this, dict_t *dict)
+reconfigure(xlator_t *this, dict_t *dict)
 {
-        /*At the moment I don't see any need to implement this. In future
-         *if this is needed we can add code here.
-         */
-        return 0;
+    /*At the moment I don't see any need to implement this. In future
+     *if this is needed we can add code here.
+     */
+    return 0;
 }
 
 int
-notify (xlator_t *this, int event, void *data, ...)
+notify(xlator_t *this, int event, void *data, ...)
 {
-        return default_notify (this, event, data);
+    return default_notify(this, event, data);
 }
 
-
 struct xlator_fops fops = {
-        .rename               = dg_rename,
-        .ipc                  = dg_ipc,
-        .setactivelk          = dg_setactivelk,
-        .flush                = dg_flush,
-        .readdir              = dg_readdir,
-        .setxattr             = dg_setxattr,
-        .mknod                = dg_mknod,
-        .fsetxattr            = dg_fsetxattr,
-        .readv                = dg_readv,
-        .inodelk              = dg_inodelk,
-        .fremovexattr         = dg_fremovexattr,
-        .open                 = dg_open,
-        .xattrop              = dg_xattrop,
-        .entrylk              = dg_entrylk,
-        .getactivelk          = dg_getactivelk,
-        .finodelk             = dg_finodelk,
-        .create               = dg_create,
-        .discard              = dg_discard,
-        .mkdir                = dg_mkdir,
-        .lk                   = dg_lk,
-        .writev               = dg_writev,
-        .access               = dg_access,
-        .lookup               = dg_lookup,
-        .rmdir                = dg_rmdir,
-        .fallocate            = dg_fallocate,
-        .fstat                = dg_fstat,
-        .lease                = dg_lease,
-        .stat                 = dg_stat,
-        .truncate             = dg_truncate,
-        .getxattr             = dg_getxattr,
-        .symlink              = dg_symlink,
-        .zerofill             = dg_zerofill,
-        .fsyncdir             = dg_fsyncdir,
-        .fgetxattr            = dg_fgetxattr,
-        .readdirp             = dg_readdirp,
-        .link                 = dg_link,
-        .fxattrop             = dg_fxattrop,
-        .ftruncate            = dg_ftruncate,
-        .rchecksum            = dg_rchecksum,
-        .unlink               = dg_unlink,
-        .fentrylk             = dg_fentrylk,
-        .getspec              = dg_getspec,
-        .setattr              = dg_setattr,
-        .fsync                = dg_fsync,
-        .statfs               = dg_statfs,
-        .seek                 = dg_seek,
-        .fsetattr             = dg_fsetattr,
-        .opendir              = dg_opendir,
-        .readlink             = dg_readlink,
-        .removexattr          = dg_removexattr,
+    .rename = dg_rename,
+    .ipc = dg_ipc,
+    .setactivelk = dg_setactivelk,
+    .flush = dg_flush,
+    .readdir = dg_readdir,
+    .setxattr = dg_setxattr,
+    .mknod = dg_mknod,
+    .fsetxattr = dg_fsetxattr,
+    .readv = dg_readv,
+    .inodelk = dg_inodelk,
+    .fremovexattr = dg_fremovexattr,
+    .open = dg_open,
+    .xattrop = dg_xattrop,
+    .entrylk = dg_entrylk,
+    .getactivelk = dg_getactivelk,
+    .finodelk = dg_finodelk,
+    .create = dg_create,
+    .discard = dg_discard,
+    .mkdir = dg_mkdir,
+    .lk = dg_lk,
+    .writev = dg_writev,
+    .access = dg_access,
+    .lookup = dg_lookup,
+    .rmdir = dg_rmdir,
+    .fallocate = dg_fallocate,
+    .fstat = dg_fstat,
+    .lease = dg_lease,
+    .stat = dg_stat,
+    .truncate = dg_truncate,
+    .getxattr = dg_getxattr,
+    .symlink = dg_symlink,
+    .zerofill = dg_zerofill,
+    .fsyncdir = dg_fsyncdir,
+    .fgetxattr = dg_fgetxattr,
+    .readdirp = dg_readdirp,
+    .link = dg_link,
+    .fxattrop = dg_fxattrop,
+    .ftruncate = dg_ftruncate,
+    .rchecksum = dg_rchecksum,
+    .unlink = dg_unlink,
+    .fentrylk = dg_fentrylk,
+    .getspec = dg_getspec,
+    .setattr = dg_setattr,
+    .fsync = dg_fsync,
+    .statfs = dg_statfs,
+    .seek = dg_seek,
+    .fsetattr = dg_fsetattr,
+    .opendir = dg_opendir,
+    .readlink = dg_readlink,
+    .removexattr = dg_removexattr,
 };
 
 struct xlator_cbks cbks = {
-        .forget               = dg_forget,
-        .release              = dg_release,
-        .releasedir           = dg_releasedir,
+    .forget = dg_forget,
+    .release = dg_release,
+    .releasedir = dg_releasedir,
 };
 
 struct volume_options options[] = {
-        { .key  = {"delay-percentage"},
-          .type = GF_OPTION_TYPE_PERCENT,
-          .default_value = "10%",
-          .description = "Percentage delay of operations when enabled.",
-          .op_version  = {GD_OP_VERSION_3_13_0},
-          .flags       = OPT_FLAG_SETTABLE,
-          .tags        = {"delay-gen"},
-        },
-
-        { .key  = {"delay-duration"},
-          .type = GF_OPTION_TYPE_INT,
-          .description = "Delay duration in micro seconds",
-          .default_value = "100000",
-          .op_version = {GD_OP_VERSION_3_13_0},
-          .flags = OPT_FLAG_SETTABLE,
-          .tags  = {"delay-gen"},
-        },
-
-        { .key  = {"enable"},
-          .type = GF_OPTION_TYPE_STR,
-          .description = "Accepts a string which takes ',' separated fop "
-                         "strings to denote which fops are enabled for delay",
-          .op_version = {GD_OP_VERSION_3_13_0},
-          .flags = OPT_FLAG_SETTABLE,
-          .tags  = {"delay-gen"},
-          .default_value = "",
-        },
-
-        { .key  = {NULL} }
-};
+    {
+        .key = {"delay-percentage"},
+        .type = GF_OPTION_TYPE_PERCENT,
+        .default_value = "10%",
+        .description = "Percentage delay of operations when enabled.",
+        .op_version = {GD_OP_VERSION_3_13_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"delay-gen"},
+    },
+
+    {
+        .key = {"delay-duration"},
+        .type = GF_OPTION_TYPE_INT,
+        .description = "Delay duration in micro seconds",
+        .default_value = "100000",
+        .op_version = {GD_OP_VERSION_3_13_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"delay-gen"},
+    },
+
+    {
+        .key = {"enable"},
+        .type = GF_OPTION_TYPE_STR,
+        .description = "Accepts a string which takes ',' separated fop "
+                       "strings to denote which fops are enabled for delay",
+        .op_version = {GD_OP_VERSION_3_13_0},
+        .flags = OPT_FLAG_SETTABLE,
+        .tags = {"delay-gen"},
+        .default_value = "",
+    },
+
+    {.key = {NULL}}};
diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c
index eeb7b3d0953..c6595b4c0e4 100644
--- a/xlators/debug/error-gen/src/error-gen.c
+++ b/xlators/debug/error-gen/src/error-gen.c
@@ -26,1694 +26,1622 @@
  * something completely different and this number is irrelevant.  See error_gen
  * for the legacy code.)
  */
-#define FAILURE_GRANULARITY     (1 << 20)
+#define FAILURE_GRANULARITY (1 << 20)
 
 sys_error_t error_no_list[] = {
-        [GF_FOP_LOOKUP]            = { .error_no_count = 4,
-                                    .error_no = {ENOENT,ENOTDIR,
-                                                 ENAMETOOLONG,EAGAIN}},
-        [GF_FOP_STAT]              = { .error_no_count = 7,
-                                    .error_no = {EACCES,EBADF,EFAULT,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 ENOMEM,ENOTDIR}},
-        [GF_FOP_READLINK]          = { .error_no_count = 8,
-                                    .error_no = {EACCES,EFAULT,EINVAL,EIO,
-                                                 ENAMETOOLONG,ENOENT,ENOMEM,
-                                                 ENOTDIR}},
-        [GF_FOP_MKNOD]             = { .error_no_count = 11,
-                                    .error_no = {EACCES,EEXIST,EFAULT,
-                                                 EINVAL,ENAMETOOLONG,
-                                                 ENOENT,ENOMEM,ENOSPC,
-                                                 ENOTDIR,EPERM,EROFS}},
-        [GF_FOP_MKDIR]             = { .error_no_count = 10,
-                                    .error_no = {EACCES,EEXIST,EFAULT,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 ENOMEM,ENOSPC,ENOTDIR,
-						 EPERM,EROFS}},
-        [GF_FOP_UNLINK]            = { .error_no_count = 10,
-                                    .error_no = {EACCES,EBUSY,EFAULT,EIO,
-                                                 EISDIR,ENAMETOOLONG,
-                                                 ENOENT,ENOMEM,ENOTDIR,
-                                                 EPERM,EROFS}},
-        [GF_FOP_RMDIR]             = { .error_no_count = 8,
-                                    .error_no = {EACCES,EBUSY,EFAULT,
-                                                 ENOMEM,ENOTDIR,ENOTEMPTY,
-                                                 EPERM,EROFS}},
-        [GF_FOP_SYMLINK]           = { .error_no_count = 11,
-                                    .error_no = {EACCES,EEXIST,EFAULT,EIO,
-                                                 ENAMETOOLONG,ENOENT,ENOMEM,
-                                                 ENOSPC,ENOTDIR,EPERM,
-                                                 EROFS}},
-        [GF_FOP_RENAME]            = { .error_no_count = 13,
-                                    .error_no = {EACCES,EBUSY,EFAULT,
-                                                 EINVAL,EISDIR,EMLINK,
-                                                 ENAMETOOLONG,ENOENT,ENOMEM,
-                                                 ENOSPC,ENOTDIR,EEXIST,
-                                                 EXDEV}},
-        [GF_FOP_LINK]              = { .error_no_count = 13,
-                                    .error_no = {EACCES,EFAULT,EEXIST,EIO,
-                                                 EMLINK,ENAMETOOLONG,
-                                                 ENOENT,ENOMEM,ENOSPC,
-                                                 ENOTDIR,EPERM,EROFS,
-                                                 EXDEV}},
-        [GF_FOP_TRUNCATE]          = { .error_no_count = 10,
-                                    .error_no = {EACCES,EFAULT,EFBIG,
-                                                 EINTR,EINVAL,EIO,EISDIR,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 EISDIR}},
-        [GF_FOP_CREATE]            = {.error_no_count = 10,
-                                   .error_no = {EACCES,EEXIST,EFAULT,
-                                                EISDIR,EMFILE,ENAMETOOLONG,
-                                                ENFILE,ENODEV,ENOENT,
-                                                ENODEV}},
-        [GF_FOP_OPEN]              = { .error_no_count = 10,
-                                    .error_no = {EACCES,EEXIST,EFAULT,
-                                                 EISDIR,EMFILE,
-                                                 ENAMETOOLONG,ENFILE,
-                                                 ENODEV,ENOENT,ENOMEM}},
-        [GF_FOP_READ]              = { .error_no_count = 5,
-                                    .error_no = {EINVAL,EBADF,EFAULT,EISDIR,
-                                                 ENAMETOOLONG}},
-        [GF_FOP_WRITE]             = { .error_no_count = 7,
-                                    .error_no = {EINVAL,EBADF,EFAULT,EISDIR,
-                                                 ENAMETOOLONG,ENOSPC,
-						 GF_ERROR_SHORT_WRITE}},
-        [GF_FOP_STATFS]            = {.error_no_count = 10,
-                                   .error_no = {EACCES,EBADF,EFAULT,EINTR,
-                                                EIO,ENAMETOOLONG,ENOENT,
-                                                ENOMEM,ENOSYS,ENOTDIR}},
-        [GF_FOP_FLUSH]             = { .error_no_count = 5,
-                                    .error_no = {EACCES,EFAULT,
-                                                 ENAMETOOLONG,ENOSYS,
-                                                 ENOENT}},
-        [GF_FOP_FSYNC]             = { .error_no_count = 4,
-                                    .error_no = {EBADF,EIO,EROFS,EINVAL}},
-        [GF_FOP_SETXATTR]          = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,EINTR,
-                                                 ENAMETOOLONG}},
-        [GF_FOP_GETXATTR]          = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,ENAMETOOLONG,
-                                                 EINTR}},
-        [GF_FOP_REMOVEXATTR]       = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,ENAMETOOLONG,
-                                                 EINTR}},
-        [GF_FOP_FSETXATTR]          = { .error_no_count = 4,
-                                        .error_no = {EACCES,EBADF,EINTR,
-                                                     ENAMETOOLONG}},
-        [GF_FOP_FGETXATTR]          = { .error_no_count = 4,
-                                        .error_no = {EACCES,EBADF,ENAMETOOLONG,
-                                                     EINTR}},
-        [GF_FOP_FREMOVEXATTR]       = { .error_no_count = 4,
-                                        .error_no = {EACCES,EBADF,ENAMETOOLONG,
-                                                     EINTR}},
-        [GF_FOP_OPENDIR]           = { .error_no_count = 8,
-                                    .error_no = {EACCES,EEXIST,EFAULT,
-                                                 EISDIR,EMFILE,
-                                                 ENAMETOOLONG,ENFILE,
-                                                 ENODEV}},
-        [GF_FOP_READDIR]           = { .error_no_count = 5,
-                                    .error_no = {EINVAL,EACCES,EBADF,
-                                                 EMFILE,ENOENT}},
-        [GF_FOP_READDIRP]          = { .error_no_count = 5,
-                                    .error_no = {EINVAL,EACCES,EBADF,
-                                                 EMFILE,ENOENT}},
-        [GF_FOP_FSYNCDIR]          = { .error_no_count = 4,
-                                    .error_no = {EBADF,EIO,EROFS,EINVAL}},
-        [GF_FOP_ACCESS]            = { .error_no_count = 8,
-                                    .error_no = {EACCES,ENAMETOOLONG,
-                                                 ENOENT,ENOTDIR,EROFS,
-                                                 EFAULT,EINVAL,EIO}},
-        [GF_FOP_FTRUNCATE]         = { .error_no_count = 9,
-                                    .error_no = {EACCES,EFAULT,EFBIG,
-                                                 EINTR,EINVAL,EIO,EISDIR,
-                                                 ENAMETOOLONG,ENOENT}},
-        [GF_FOP_FSTAT]             = { .error_no_count = 7,
-                                    .error_no = {EACCES,EBADF,EFAULT,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 ENOMEM,ENOTDIR}},
-        [GF_FOP_LK]                = { .error_no_count = 4,
-                                    .error_no = {EACCES,EFAULT,ENOENT,
-                                                 EINTR}},
-        [GF_FOP_XATTROP]           = { .error_no_count = 5,
-                                    .error_no = {EACCES,EFAULT,
-                                                 ENAMETOOLONG,ENOSYS,
-                                                 ENOENT}},
-        [GF_FOP_FXATTROP]          = { .error_no_count = 4,
-                                    .error_no = {EBADF,EIO,EROFS,EINVAL}},
-        [GF_FOP_INODELK]           = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,EINTR,
-                                                 ENAMETOOLONG}},
-        [GF_FOP_FINODELK]          = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,EINTR,
-                                                 ENAMETOOLONG}},
-        [GF_FOP_ENTRYLK]           = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,
-                                                 ENAMETOOLONG,EINTR}},
-        [GF_FOP_FENTRYLK]          = { .error_no_count = 10,
-                                    .error_no = {EACCES,EEXIST,EFAULT,
-                                                 EISDIR,EMFILE,
-                                                 ENAMETOOLONG,ENFILE,
-                                                 ENODEV,ENOENT,ENOMEM}},
-        [GF_FOP_SETATTR]           = {.error_no_count = 11,
-                                    .error_no = {EACCES,EFAULT,EIO,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 ENOMEM,ENOTDIR,EPERM,
-                                                 EROFS,EBADF,EIO}},
-        [GF_FOP_FSETATTR]          = { .error_no_count = 11,
-                                    .error_no = {EACCES,EFAULT,EIO,
-                                                 ENAMETOOLONG,ENOENT,
-                                                 ENOMEM,ENOTDIR,EPERM,
-                                                 EROFS,EBADF,EIO}},
-        [GF_FOP_GETSPEC]           = { .error_no_count = 4,
-                                    .error_no = {EACCES,EBADF,ENAMETOOLONG,
-                                                 EINTR}}
-};
+    [GF_FOP_LOOKUP] = {.error_no_count = 4,
+                       .error_no = {ENOENT, ENOTDIR, ENAMETOOLONG, EAGAIN}},
+    [GF_FOP_STAT] = {.error_no_count = 7,
+                     .error_no = {EACCES, EBADF, EFAULT, ENAMETOOLONG, ENOENT,
+                                  ENOMEM, ENOTDIR}},
+    [GF_FOP_READLINK] = {.error_no_count = 8,
+                         .error_no = {EACCES, EFAULT, EINVAL, EIO, ENAMETOOLONG,
+                                      ENOENT, ENOMEM, ENOTDIR}},
+    [GF_FOP_MKNOD] = {.error_no_count = 11,
+                      .error_no = {EACCES, EEXIST, EFAULT, EINVAL, ENAMETOOLONG,
+                                   ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM,
+                                   EROFS}},
+    [GF_FOP_MKDIR] = {.error_no_count = 10,
+                      .error_no = {EACCES, EEXIST, EFAULT, ENAMETOOLONG, ENOENT,
+                                   ENOMEM, ENOSPC, ENOTDIR, EPERM, EROFS}},
+    [GF_FOP_UNLINK] = {.error_no_count = 10,
+                       .error_no = {EACCES, EBUSY, EFAULT, EIO, EISDIR,
+                                    ENAMETOOLONG, ENOENT, ENOMEM, ENOTDIR,
+                                    EPERM, EROFS}},
+    [GF_FOP_RMDIR] = {.error_no_count = 8,
+                      .error_no = {EACCES, EBUSY, EFAULT, ENOMEM, ENOTDIR,
+                                   ENOTEMPTY, EPERM, EROFS}},
+    [GF_FOP_SYMLINK] = {.error_no_count = 11,
+                        .error_no = {EACCES, EEXIST, EFAULT, EIO, ENAMETOOLONG,
+                                     ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM,
+                                     EROFS}},
+    [GF_FOP_RENAME] = {.error_no_count = 13,
+                       .error_no = {EACCES, EBUSY, EFAULT, EINVAL, EISDIR,
+                                    EMLINK, ENAMETOOLONG, ENOENT, ENOMEM,
+                                    ENOSPC, ENOTDIR, EEXIST, EXDEV}},
+    [GF_FOP_LINK] = {.error_no_count = 13,
+                     .error_no = {EACCES, EFAULT, EEXIST, EIO, EMLINK,
+                                  ENAMETOOLONG, ENOENT, ENOMEM, ENOSPC, ENOTDIR,
+                                  EPERM, EROFS, EXDEV}},
+    [GF_FOP_TRUNCATE] = {.error_no_count = 10,
+                         .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL, EIO,
+                                      EISDIR, ENAMETOOLONG, ENOENT, EISDIR}},
+    [GF_FOP_CREATE] = {.error_no_count = 10,
+                       .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE,
+                                    ENAMETOOLONG, ENFILE, ENODEV, ENOENT,
+                                    ENODEV}},
+    [GF_FOP_OPEN] = {.error_no_count = 10,
+                     .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE,
+                                  ENAMETOOLONG, ENFILE, ENODEV, ENOENT,
+                                  ENOMEM}},
+    [GF_FOP_READ] = {.error_no_count = 5,
+                     .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG}},
+    [GF_FOP_WRITE] = {.error_no_count = 7,
+                      .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG,
+                                   ENOSPC, GF_ERROR_SHORT_WRITE}},
+    [GF_FOP_STATFS] = {.error_no_count = 10,
+                       .error_no = {EACCES, EBADF, EFAULT, EINTR, EIO,
+                                    ENAMETOOLONG, ENOENT, ENOMEM, ENOSYS,
+                                    ENOTDIR}},
+    [GF_FOP_FLUSH] = {.error_no_count = 5,
+                      .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS,
+                                   ENOENT}},
+    [GF_FOP_FSYNC] = {.error_no_count = 4,
+                      .error_no = {EBADF, EIO, EROFS, EINVAL}},
+    [GF_FOP_SETXATTR] = {.error_no_count = 4,
+                         .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}},
+    [GF_FOP_GETXATTR] = {.error_no_count = 4,
+                         .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}},
+    [GF_FOP_REMOVEXATTR] = {.error_no_count = 4,
+                            .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}},
+    [GF_FOP_FSETXATTR] = {.error_no_count = 4,
+                          .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}},
+    [GF_FOP_FGETXATTR] = {.error_no_count = 4,
+                          .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}},
+    [GF_FOP_FREMOVEXATTR] = {.error_no_count = 4,
+                             .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}},
+    [GF_FOP_OPENDIR] = {.error_no_count = 8,
+                        .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE,
+                                     ENAMETOOLONG, ENFILE, ENODEV}},
+    [GF_FOP_READDIR] = {.error_no_count = 5,
+                        .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}},
+    [GF_FOP_READDIRP] = {.error_no_count = 5,
+                         .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}},
+    [GF_FOP_FSYNCDIR] = {.error_no_count = 4,
+                         .error_no = {EBADF, EIO, EROFS, EINVAL}},
+    [GF_FOP_ACCESS] = {.error_no_count = 8,
+                       .error_no = {EACCES, ENAMETOOLONG, ENOENT, ENOTDIR,
+                                    EROFS, EFAULT, EINVAL, EIO}},
+    [GF_FOP_FTRUNCATE] = {.error_no_count = 9,
+                          .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL,
+                                       EIO, EISDIR, ENAMETOOLONG, ENOENT}},
+    [GF_FOP_FSTAT] = {.error_no_count = 7,
+                      .error_no = {EACCES, EBADF, EFAULT, ENAMETOOLONG, ENOENT,
+                                   ENOMEM, ENOTDIR}},
+    [GF_FOP_LK] = {.error_no_count = 4,
+                   .error_no = {EACCES, EFAULT, ENOENT, EINTR}},
+    [GF_FOP_XATTROP] = {.error_no_count = 5,
+                        .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS,
+                                     ENOENT}},
+    [GF_FOP_FXATTROP] = {.error_no_count = 4,
+                         .error_no = {EBADF, EIO, EROFS, EINVAL}},
+    [GF_FOP_INODELK] = {.error_no_count = 4,
+                        .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}},
+    [GF_FOP_FINODELK] = {.error_no_count = 4,
+                         .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}},
+    [GF_FOP_ENTRYLK] = {.error_no_count = 4,
+                        .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}},
+    [GF_FOP_FENTRYLK] = {.error_no_count = 10,
+                         .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE,
+                                      ENAMETOOLONG, ENFILE, ENODEV, ENOENT,
+                                      ENOMEM}},
+    [GF_FOP_SETATTR] = {.error_no_count = 11,
+                        .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT,
+                                     ENOMEM, ENOTDIR, EPERM, EROFS, EBADF,
+                                     EIO}},
+    [GF_FOP_FSETATTR] = {.error_no_count = 11,
+                         .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT,
+                                      ENOMEM, ENOTDIR, EPERM, EROFS, EBADF,
+                                      EIO}},
+    [GF_FOP_GETSPEC] = {.error_no_count = 4,
+                        .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}};
 
 int
-generate_rand_no (int op_no)
+generate_rand_no(int op_no)
 {
-        int             rand_no = 0;
-        int             error_no_list_size = 0;
+    int rand_no = 0;
+    int error_no_list_size = 0;
 
-        error_no_list_size = sizeof(error_no_list)/sizeof(error_no_list[0]);
+    error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]);
 
-        if (op_no < error_no_list_size)
-                /* coverity[DC.WEAK_CRYPTO] */
-                rand_no = rand () % error_no_list[op_no].error_no_count;
-        return rand_no;
+    if (op_no < error_no_list_size)
+        /* coverity[DC.WEAK_CRYPTO] */
+        rand_no = rand() % error_no_list[op_no].error_no_count;
+    return rand_no;
 }
 
 int
-conv_errno_to_int (char **error_no)
+conv_errno_to_int(char **error_no)
 {
-        if (!strcmp ((*error_no), "ENOENT"))
-                return ENOENT;
-        else if (!strcmp ((*error_no), "ENOTDIR"))
-                return ENOTDIR;
-        else if (!strcmp ((*error_no), "ENAMETOOLONG"))
-                return ENAMETOOLONG;
-        else if (!strcmp ((*error_no), "EACCES"))
-                return EACCES;
-        else if (!strcmp ((*error_no), "EBADF"))
-                return EBADF;
-        else if (!strcmp ((*error_no), "EFAULT"))
-                return EFAULT;
-        else if (!strcmp ((*error_no), "ENOMEM"))
-                return ENOMEM;
-        else if (!strcmp ((*error_no), "EINVAL"))
-                return EINVAL;
-        else if (!strcmp ((*error_no), "EIO"))
-                return EIO;
-        else if (!strcmp ((*error_no), "EEXIST"))
-                return EEXIST;
-        else if (!strcmp ((*error_no), "ENOSPC"))
-                return ENOSPC;
-        else if (!strcmp ((*error_no), "EPERM"))
-                return EPERM;
-        else if (!strcmp ((*error_no), "EROFS"))
-                return EROFS;
-        else if (!strcmp ((*error_no), "EBUSY"))
-                return EBUSY;
-        else if (!strcmp ((*error_no), "EISDIR"))
-                return EISDIR;
-        else if (!strcmp ((*error_no), "ENOTEMPTY"))
-                return ENOTEMPTY;
-        else if (!strcmp ((*error_no), "EMLINK"))
-                return EMLINK;
-        else if (!strcmp ((*error_no), "ENODEV"))
-                return ENODEV;
-        else if (!strcmp ((*error_no), "EXDEV"))
-                return EXDEV;
-        else if (!strcmp ((*error_no), "EMFILE"))
-                return EMFILE;
-        else if (!strcmp ((*error_no), "ENFILE"))
-                return ENFILE;
-        else if (!strcmp ((*error_no), "ENOSYS"))
-                return ENOSYS;
-        else if (!strcmp ((*error_no), "EINTR"))
-                return EINTR;
-        else if (!strcmp ((*error_no), "EFBIG"))
-                return EFBIG;
-	else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE"))
-		return GF_ERROR_SHORT_WRITE;
-        else
-                return EAGAIN;
+    if (!strcmp((*error_no), "ENOENT"))
+        return ENOENT;
+    else if (!strcmp((*error_no), "ENOTDIR"))
+        return ENOTDIR;
+    else if (!strcmp((*error_no), "ENAMETOOLONG"))
+        return ENAMETOOLONG;
+    else if (!strcmp((*error_no), "EACCES"))
+        return EACCES;
+    else if (!strcmp((*error_no), "EBADF"))
+        return EBADF;
+    else if (!strcmp((*error_no), "EFAULT"))
+        return EFAULT;
+    else if (!strcmp((*error_no), "ENOMEM"))
+        return ENOMEM;
+    else if (!strcmp((*error_no), "EINVAL"))
+        return EINVAL;
+    else if (!strcmp((*error_no), "EIO"))
+        return EIO;
+    else if (!strcmp((*error_no), "EEXIST"))
+        return EEXIST;
+    else if (!strcmp((*error_no), "ENOSPC"))
+        return ENOSPC;
+    else if (!strcmp((*error_no), "EPERM"))
+        return EPERM;
+    else if (!strcmp((*error_no), "EROFS"))
+        return EROFS;
+    else if (!strcmp((*error_no), "EBUSY"))
+        return EBUSY;
+    else if (!strcmp((*error_no), "EISDIR"))
+        return EISDIR;
+    else if (!strcmp((*error_no), "ENOTEMPTY"))
+        return ENOTEMPTY;
+    else if (!strcmp((*error_no), "EMLINK"))
+        return EMLINK;
+    else if (!strcmp((*error_no), "ENODEV"))
+        return ENODEV;
+    else if (!strcmp((*error_no), "EXDEV"))
+        return EXDEV;
+    else if (!strcmp((*error_no), "EMFILE"))
+        return EMFILE;
+    else if (!strcmp((*error_no), "ENFILE"))
+        return ENFILE;
+    else if (!strcmp((*error_no), "ENOSYS"))
+        return ENOSYS;
+    else if (!strcmp((*error_no), "EINTR"))
+        return EINTR;
+    else if (!strcmp((*error_no), "EFBIG"))
+        return EFBIG;
+    else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE"))
+        return GF_ERROR_SHORT_WRITE;
+    else
+        return EAGAIN;
 }
 
 int
-error_gen (xlator_t *this, int op_no)
+error_gen(xlator_t *this, int op_no)
 {
-        eg_t             *egp = NULL;
-        int              count = 0;
-        int              error_no_int = 0;
-        int              rand_no = 0;
-        int              ret = 0;
-        gf_boolean_t     should_err = _gf_false;
-        int              error_no_list_size = 0;
-
-        egp = this->private;
-
-        if (egp->random_failure) {
-                /*
-                 * I honestly don't know why anyone would use this "feature"
-                 * but I'll try to preserve its functionality anyway.  Without
-                 * locking twice to update failure_iter_no and egp->op_count
-                 * separately, then not locking at all to update
-                 * egp->failure_iter_no.  That's not needed for compatibility,
-                 * and it's abhorrently wrong.  I have *some* standards.
-                 */
-                LOCK (&egp->lock);
-                {
-                        count = ++(egp->op_count);
-                        error_no_int = egp->error_no_int;
-                        if ((count % egp->failure_iter_no) == 0) {
-                                egp->op_count = 0;
-                                /* coverity[DC.WEAK_CRYPTO] */
-                                egp->failure_iter_no = 3
-                                        + (rand () % GF_UNIVERSAL_ANSWER);
-                                should_err = _gf_true;
-                        }
-                }
-                UNLOCK (&egp->lock);
-        } else {
-                /*
-                 * It turns out that rand() is almost universally implemented
-                 * as a linear congruential PRNG, which is about as cheap as
-                 * it gets.  This gets us real random behavior, including
-                 * phenomena like streaks and dry spells, with controllable
-                 * long-term probability, cheaply.
-                 */
-                if ((rand () % FAILURE_GRANULARITY) < egp->failure_iter_no) {
-                        should_err = _gf_true;
-                }
+    eg_t *egp = NULL;
+    int count = 0;
+    int error_no_int = 0;
+    int rand_no = 0;
+    int ret = 0;
+    gf_boolean_t should_err = _gf_false;
+    int error_no_list_size = 0;
+
+    egp = this->private;
+
+    if (egp->random_failure) {
+        /*
+         * I honestly don't know why anyone would use this "feature"
+         * but I'll try to preserve its functionality anyway.  Without
+         * locking twice to update failure_iter_no and egp->op_count
+         * separately, then not locking at all to update
+         * egp->failure_iter_no.  That's not needed for compatibility,
+         * and it's abhorrently wrong.  I have *some* standards.
+         */
+        LOCK(&egp->lock);
+        {
+            count = ++(egp->op_count);
+            error_no_int = egp->error_no_int;
+            if ((count % egp->failure_iter_no) == 0) {
+                egp->op_count = 0;
+                /* coverity[DC.WEAK_CRYPTO] */
+                egp->failure_iter_no = 3 + (rand() % GF_UNIVERSAL_ANSWER);
+                should_err = _gf_true;
+            }
         }
-
-        error_no_list_size = sizeof(error_no_list)/sizeof(error_no_list[0]);
-        if (should_err) {
-                if (error_no_int)
-                        ret = error_no_int;
-                else {
-                        rand_no = generate_rand_no (op_no);
-                        if (op_no >= error_no_list_size)
-                                op_no = 0;
-                        if (rand_no >= error_no_list[op_no].error_no_count)
-                                rand_no = 0;
-                        ret = error_no_list[op_no].error_no[rand_no];
-                }
+        UNLOCK(&egp->lock);
+    } else {
+        /*
+         * It turns out that rand() is almost universally implemented
+         * as a linear congruential PRNG, which is about as cheap as
+         * it gets.  This gets us real random behavior, including
+         * phenomena like streaks and dry spells, with controllable
+         * long-term probability, cheaply.
+         */
+        if ((rand() % FAILURE_GRANULARITY) < egp->failure_iter_no) {
+            should_err = _gf_true;
+        }
+    }
+
+    error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]);
+    if (should_err) {
+        if (error_no_int)
+            ret = error_no_int;
+        else {
+            rand_no = generate_rand_no(op_no);
+            if (op_no >= error_no_list_size)
+                op_no = 0;
+            if (rand_no >= error_no_list[op_no].error_no_count)
+                rand_no = 0;
+            ret = error_no_list[op_no].error_no[rand_no];
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  dict_t *xdata)
+error_gen_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_LOOKUP];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_LOOKUP);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL, NULL,
-                                     NULL);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->lookup,
-		    loc, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_LOOKUP];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_LOOKUP);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(lookup, frame, -1, op_errno, NULL, NULL, NULL,
+                            NULL);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup,
+                    loc, xdata);
+    return 0;
 }
 
 int
-error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+error_gen_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_STAT];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_STAT);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_STAT];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_STAT);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->stat, loc, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(stat, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat,
+                    loc, xdata);
+    return 0;
 }
 
 int
-error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   struct iatt *stbuf, int32_t valid, dict_t *xdata)
+error_gen_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                  struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_SETATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_SETATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_SETATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata);
-	        return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_SETATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->setattr,
-		    loc, stbuf, valid, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(setattr, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
-}
+    }
 
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr,
+                    loc, stbuf, valid, xdata);
+    return 0;
+}
 
 int
-error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    struct iatt *stbuf, int32_t valid, dict_t *xdata)
+error_gen_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                   struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-	int             op_errno = 0;
-        eg_t            *egp = NULL;
-        int             enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FSETATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FSETATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FSETATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FSETATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fsetattr,
-		    fd, stbuf, valid, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fsetattr, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr,
+                    fd, stbuf, valid, xdata);
+    return 0;
 }
 
 int
-error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    off_t offset, dict_t *xdata)
+error_gen_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   off_t offset, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_TRUNCATE];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_TRUNCATE);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (truncate, frame, -1, op_errno,
-                                     NULL, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->truncate,
-		    loc, offset, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_TRUNCATE];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_TRUNCATE);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(truncate, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate,
+                    loc, offset, xdata);
+    return 0;
 }
 
 int
-error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		     off_t offset, dict_t *xdata)
+error_gen_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                    dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp =NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FTRUNCATE];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FTRUNCATE);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (ftruncate, frame, -1, op_errno,
-                                     NULL, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->ftruncate,
-		    fd, offset, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FTRUNCATE];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FTRUNCATE);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(ftruncate, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
+    return 0;
 }
 
 int
-error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		  int32_t mask, dict_t *xdata)
+error_gen_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+                 dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_ACCESS];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_ACCESS];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_ACCESS);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_ACCESS);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (access, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->access,
-		    loc, mask, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(access, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access,
+                    loc, mask, xdata);
+    return 0;
 }
 
 int
-error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    size_t size, dict_t *xdata)
+error_gen_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                   dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_READLINK];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_READLINK);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_READLINK];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_READLINK);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->readlink,
-		    loc, size, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(readlink, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink,
+                    loc, size, xdata);
+    return 0;
 }
 
 int
-error_gen_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		 mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata)
+error_gen_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                dev_t rdev, mode_t umask, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_MKNOD];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_MKNOD);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL,
-                                     NULL, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->mknod,
-		    loc, mode, rdev, umask, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_MKNOD];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_MKNOD);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                            xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,
+                    loc, mode, rdev, umask, xdata);
+    return 0;
 }
 
 int
-error_gen_mkdir (call_frame_t *frame, xlator_t *this,
-		 loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata)
+error_gen_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+                mode_t umask, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_MKDIR];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_MKDIR);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (mkdir, frame, -1, op_errno, NULL, NULL,
-                                     NULL, NULL, xdata);
-                return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->mkdir,
-		    loc, mode, umask, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_MKDIR];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_MKDIR);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                            xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir,
+                    loc, mode, umask, xdata);
+    return 0;
 }
 
 int
-error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-                  dict_t *xdata)
+error_gen_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+                 dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_UNLINK];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_UNLINK);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL,
-                                     xdata);
-                return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->unlink,
-		    loc, xflag, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_UNLINK];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_UNLINK);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(unlink, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink,
+                    loc, xflag, xdata);
+    return 0;
 }
 
 int
-error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-                 dict_t *xdata)
+error_gen_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+                dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_RMDIR];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_RMDIR];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_RMDIR);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_RMDIR);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->rmdir,
-		    loc, flags, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(rmdir, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir,
+                    loc, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-		   loc_t *loc, mode_t umask, dict_t *xdata)
+error_gen_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath,
+                  loc_t *loc, mode_t umask, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_SYMLINK];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_SYMLINK);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (symlink, frame, -1, op_errno, NULL, NULL,
-                                     NULL, NULL, NULL); /* pre & post parent attr */
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->symlink,
-		    linkpath, loc, umask, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_SYMLINK];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_SYMLINK);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(symlink, frame, -1, op_errno, NULL, NULL, NULL,
+                            NULL, NULL); /* pre & post parent attr */
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink,
+                    linkpath, loc, umask, xdata);
+    return 0;
 }
 
 int
-error_gen_rename (call_frame_t *frame, xlator_t *this,
-		  loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+error_gen_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+                 loc_t *newloc, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_RENAME];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_RENAME);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (rename, frame, -1, op_errno, NULL,
-                                     NULL, NULL, NULL, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->rename,
-		    oldloc, newloc, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_RENAME];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_RENAME);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                            NULL, NULL);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename,
+                    oldloc, newloc, xdata);
+    return 0;
 }
 
 int
-error_gen_link (call_frame_t *frame, xlator_t *this,
-		loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+error_gen_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
+               loc_t *newloc, dict_t *xdata)
 {
-	int             op_errno = 0;
-        eg_t            *egp = NULL;
-        int             enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_LINK];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_LINK);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL,
-                                     NULL, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->link,
-		    oldloc, newloc, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_LINK];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_LINK);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                            NULL);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,
+                    oldloc, newloc, xdata);
+    return 0;
 }
 
 int
-error_gen_create (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		  int32_t flags, mode_t mode, mode_t umask, fd_t *fd,
-                  dict_t *xdata)
+error_gen_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+                 mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-	int             op_errno = 0;
-        eg_t            *egp = NULL;
-        int             enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_CREATE];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_CREATE);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (create, frame, -1, op_errno, NULL, NULL,
-                                     NULL, NULL, NULL, NULL);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->create,
-		    loc, flags, mode, umask, fd, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_CREATE];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_CREATE);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
+                            NULL, NULL);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create,
+                    loc, flags, mode, umask, fd, xdata);
+    return 0;
 }
 
 int
-error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		int32_t flags, fd_t *fd, dict_t *xdata)
+error_gen_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+               fd_t *fd, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_OPEN];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_OPEN);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_OPEN];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_OPEN);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->open,
-		    loc, flags, fd, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(open, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,
+                    loc, flags, fd, xdata);
+    return 0;
 }
 
 int
-error_gen_readv (call_frame_t *frame, xlator_t *this,
-		 fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata)
+error_gen_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                off_t offset, uint32_t flags, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_READ];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_READ);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0,
-                                     NULL, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->readv,
-		    fd, size, offset, flags, xdata);
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_READ];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_READ);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(readv, frame, -1, op_errno, NULL, 0, NULL, NULL,
+                            xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv,
+                    fd, size, offset, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		  struct iovec *vector, int32_t count,
-		  off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata)
+error_gen_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                 struct iovec *vector, int32_t count, off_t off, uint32_t flags,
+                 struct iobref *iobref, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-	struct iovec *shortvec = NULL;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_WRITE];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_WRITE);
-
-	if (op_errno == GF_ERROR_SHORT_WRITE) {
-
-		/*
-		 * A short write error returns some value less than what was
-		 * requested from a write. To simulate this, replace the vector
-		 * with one half the size;
-		 */
-		shortvec = iov_dup(vector, 1);
-		shortvec->iov_len /= 2;
-		goto wind;
-	} else if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, xdata);
-        	return 0;
-	}
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+    struct iovec *shortvec = NULL;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_WRITE];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_WRITE);
+
+    if (op_errno == GF_ERROR_SHORT_WRITE) {
+        /*
+         * A short write error returns some value less than what was
+         * requested from a write. To simulate this, replace the vector
+         * with one half the size;
+         */
+        shortvec = iov_dup(vector, 1);
+        shortvec->iov_len /= 2;
+        goto wind;
+    } else if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(writev, frame, -1, op_errno, NULL, NULL, xdata);
+        return 0;
+    }
 wind:
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->writev,
-                   fd, shortvec?shortvec:vector,
-                   count, off, flags, iobref, xdata);
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,
+                    fd, shortvec ? shortvec : vector, count, off, flags, iobref,
+                    xdata);
 
-	if (shortvec)
-		GF_FREE (shortvec);
-        return 0;
+    if (shortvec)
+        GF_FREE(shortvec);
+    return 0;
 }
 
 int
-error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+error_gen_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FLUSH];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FLUSH];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FLUSH);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FLUSH);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (flush, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->flush,
-		    fd, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(flush, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush,
+                    fd, xdata);
+    return 0;
 }
 
 int
-error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata)
+error_gen_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+                dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FSYNC];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FSYNC);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FSYNC];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FSYNC);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fsync,
-		    fd, flags, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fsync, frame, -1, op_errno, NULL, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync,
+                    fd, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+error_gen_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FSTAT];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FSTAT);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FSTAT];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL, xdata);
-	        return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FSTAT);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fstat,
-		    fd, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fstat, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat,
+                    fd, xdata);
+    return 0;
 }
 
 int
-error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata)
+error_gen_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+                  dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_OPENDIR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_OPENDIR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_OPENDIR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_OPENDIR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->opendir,
-		    loc, fd, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(opendir, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir,
+                    loc, fd, xdata);
+    return 0;
 }
 
 int
-error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    int32_t flags, dict_t *xdata)
+error_gen_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+                   dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FSYNCDIR];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FSYNCDIR];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FSYNCDIR);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FSYNCDIR);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fsyncdir,
-		    fd, flags, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fsyncdir, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir,
+                    fd, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+error_gen_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_STATFS];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_STATFS);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_STATFS];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_STATFS);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->statfs,
-		    loc, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(statfs, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs,
+                    loc, xdata);
+    return 0;
 }
 
 int
-error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		    dict_t *dict, int32_t flags, dict_t *xdata)
+error_gen_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   dict_t *dict, int32_t flags, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_SETXATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_SETXATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_SETXATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_SETXATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->setxattr,
-		    loc, dict, flags, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,
+                    loc, dict, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		    const char *name, dict_t *xdata)
+error_gen_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                   const char *name, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_GETXATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_GETXATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_GETXATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_GETXATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->getxattr,
-		    loc, name, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(getxattr, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr,
+                    loc, name, xdata);
+    return 0;
 }
 
 int
-error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     dict_t *dict, int32_t flags, dict_t *xdata)
+error_gen_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
+                    int32_t flags, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FSETXATTR];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FSETXATTR];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FSETXATTR);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FSETXATTR);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fsetxattr,
-		    fd, dict, flags, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fsetxattr, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
+    return 0;
 }
 
 int
-error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     const char *name, dict_t *xdata)
+error_gen_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                    const char *name, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FGETXATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FGETXATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FGETXATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FGETXATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fgetxattr,
-		    fd, name, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fgetxattr, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
+    return 0;
 }
 
 int
-error_gen_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		   gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+error_gen_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                  gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_XATTROP];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_XATTROP);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_XATTROP];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_XATTROP);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->xattrop,
-		    loc, flags, dict, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(xattrop, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop,
+                    loc, flags, dict, xdata);
+    return 0;
 }
 
 int
-error_gen_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		    gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+error_gen_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                   gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FXATTROP];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FXATTROP);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FXATTROP];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL, xdata);
-	        return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FXATTROP);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fxattrop,
-		    fd, flags, dict, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fxattrop, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop,
+                    fd, flags, dict, xdata);
+    return 0;
 }
 
 int
-error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-		       const char *name, dict_t *xdata)
+error_gen_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+                      const char *name, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_REMOVEXATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_REMOVEXATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_REMOVEXATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_REMOVEXATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->removexattr,
-		    loc, name, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(removexattr, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
+    return 0;
 }
 
 int
-error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                        const char *name, dict_t *xdata)
+error_gen_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
+                       const char *name, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FREMOVEXATTR];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FREMOVEXATTR);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FREMOVEXATTR];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fremovexattr, frame, -1, op_errno, xdata);
-		return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FREMOVEXATTR);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fremovexattr,
-		    fd, name, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fremovexattr, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
+    return 0;
 }
 
 int
-error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-	      struct gf_flock *lock, dict_t *xdata)
+error_gen_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+             struct gf_flock *lock, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_LK];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_LK];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_LK);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_LK);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->lk,
-		    fd, cmd, lock, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(lk, frame, -1, op_errno, NULL, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, fd,
+                    cmd, lock, xdata);
+    return 0;
 }
 
 int
-error_gen_inodelk (call_frame_t *frame, xlator_t *this,
-		   const char *volume, loc_t *loc, int32_t cmd,
-                   struct gf_flock *lock, dict_t *xdata)
+error_gen_inodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+                  loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_INODELK];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_INODELK];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_INODELK);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_INODELK);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->inodelk,
-		    volume, loc, cmd, lock, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(inodelk, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk,
+                    volume, loc, cmd, lock, xdata);
+    return 0;
 }
 
 int
-error_gen_finodelk (call_frame_t *frame, xlator_t *this,
-		    const char *volume, fd_t *fd, int32_t cmd,
-                    struct gf_flock *lock, dict_t *xdata)
+error_gen_finodelk(call_frame_t *frame, xlator_t *this, const char *volume,
+                   fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FINODELK];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FINODELK];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FINODELK);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FINODELK);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->finodelk,
-		    volume, fd, cmd, lock, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(finodelk, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->finodelk,
+                    volume, fd, cmd, lock, xdata);
+    return 0;
 }
 
 int
-error_gen_entrylk (call_frame_t *frame, xlator_t *this,
-		   const char *volume, loc_t *loc, const char *basename,
-		   entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+error_gen_entrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+                  loc_t *loc, const char *basename, entrylk_cmd cmd,
+                  entrylk_type type, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_ENTRYLK];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_ENTRYLK];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_ENTRYLK);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_ENTRYLK);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->entrylk,
-		    volume, loc, basename, cmd, type, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(entrylk, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk,
+                    volume, loc, basename, cmd, type, xdata);
+    return 0;
 }
 
 int
-error_gen_fentrylk (call_frame_t *frame, xlator_t *this,
-		    const char *volume, fd_t *fd, const char *basename,
-		    entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+error_gen_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume,
+                   fd_t *fd, const char *basename, entrylk_cmd cmd,
+                   entrylk_type type, dict_t *xdata)
 {
-	int             op_errno = 0;
-        eg_t            *egp = NULL;
-        int             enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_FENTRYLK];
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_FENTRYLK);
+    egp = this->private;
+    enable = egp->enable[GF_FOP_FENTRYLK];
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno, xdata);
-                return 0;
-	}
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_FENTRYLK);
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->fentrylk,
-		    volume, fd, basename, cmd, type, xdata);
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(fentrylk, frame, -1, op_errno, xdata);
         return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fentrylk,
+                    volume, fd, basename, cmd, type, xdata);
+    return 0;
 }
 
 int
-error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key,
-		   int32_t flags)
+error_gen_getspec(call_frame_t *frame, xlator_t *this, const char *key,
+                  int32_t flags)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_GETSPEC];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_GETSPEC);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (getspec, frame, -1, op_errno, NULL);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->getspec,
-		    key, flags);
-	return 0;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_GETSPEC];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_GETSPEC);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(getspec, frame, -1, op_errno, NULL);
+        return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getspec,
+                    key, flags);
+    return 0;
 }
 
 int
-error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		   size_t size, off_t off, dict_t *xdata)
+error_gen_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                  off_t off, dict_t *xdata)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
-
-        egp = this->private;
-        enable = egp->enable[GF_FOP_READDIR];
-
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_READDIR);
-
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL, xdata);
-		return 0;
-	}
-
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->readdir,
-		    fd, size, off, xdata);
-	return 0;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
+
+    egp = this->private;
+    enable = egp->enable[GF_FOP_READDIR];
+
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_READDIR);
+
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(readdir, frame, -1, op_errno, NULL, xdata);
+        return 0;
+    }
+
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,
+                    fd, size, off, xdata);
+    return 0;
 }
 
 int
-error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                    off_t off, dict_t *dict)
+error_gen_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+                   off_t off, dict_t *dict)
 {
-	int              op_errno = 0;
-        eg_t            *egp = NULL;
-        int              enable = 1;
+    int op_errno = 0;
+    eg_t *egp = NULL;
+    int enable = 1;
 
-        egp = this->private;
-        enable = egp->enable[GF_FOP_READDIRP];
+    egp = this->private;
+    enable = egp->enable[GF_FOP_READDIRP];
 
-        if (enable)
-                op_errno = error_gen (this, GF_FOP_READDIRP);
+    if (enable)
+        op_errno = error_gen(this, GF_FOP_READDIRP);
 
-	if (op_errno) {
-		GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno));
-		STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL, NULL);
-		return 0;
-	}
+    if (op_errno) {
+        GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno));
+        STACK_UNWIND_STRICT(readdirp, frame, -1, op_errno, NULL, NULL);
+        return 0;
+    }
 
-	STACK_WIND_TAIL (frame, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->readdirp,
+    STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp,
                     fd, size, off, dict);
-	return 0;
+    return 0;
 }
 
 static void
-error_gen_set_failure (eg_t *pvt, double percent)
+error_gen_set_failure(eg_t *pvt, double percent)
 {
-        double  ppm;
+    double ppm;
 
-        GF_ASSERT (pvt);
+    GF_ASSERT(pvt);
 
-        ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY;
-        pvt->failure_iter_no = (int)ppm;
+    ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY;
+    pvt->failure_iter_no = (int)ppm;
 }
 
 static void
-error_gen_parse_fill_fops (eg_t *pvt, char *enable_fops)
+error_gen_parse_fill_fops(eg_t *pvt, char *enable_fops)
 {
-        char            *op_no_str = NULL;
-        int              op_no = -1;
-        int              i = 0;
-        xlator_t        *this = THIS;
-        char            *saveptr = NULL;
+    char *op_no_str = NULL;
+    int op_no = -1;
+    int i = 0;
+    xlator_t *this = THIS;
+    char *saveptr = NULL;
 
-        GF_ASSERT (pvt);
-        GF_ASSERT (this);
+    GF_ASSERT(pvt);
+    GF_ASSERT(this);
 
+    for (i = 0; i < GF_FOP_MAXVALUE; i++)
+        pvt->enable[i] = 0;
+
+    if (!enable_fops) {
+        gf_log(this->name, GF_LOG_WARNING, "All fops are enabled.");
         for (i = 0; i < GF_FOP_MAXVALUE; i++)
-                pvt->enable[i] = 0;
-
-        if (!enable_fops) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "All fops are enabled.");
-                for (i = 0; i < GF_FOP_MAXVALUE; i++)
-                        pvt->enable[i] = 1;
-        } else {
-                op_no_str = strtok_r (enable_fops, ",", &saveptr);
-                while (op_no_str) {
-                        op_no = gf_fop_int (op_no_str);
-                        if (op_no == -1) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "Wrong option value %s", op_no_str);
-                        } else
-                                pvt->enable[op_no] = 1;
-
-                        op_no_str = strtok_r (NULL, ",", &saveptr);
-                }
+            pvt->enable[i] = 1;
+    } else {
+        op_no_str = strtok_r(enable_fops, ",", &saveptr);
+        while (op_no_str) {
+            op_no = gf_fop_int(op_no_str);
+            if (op_no == -1) {
+                gf_log(this->name, GF_LOG_WARNING, "Wrong option value %s",
+                       op_no_str);
+            } else
+                pvt->enable[op_no] = 1;
+
+            op_no_str = strtok_r(NULL, ",", &saveptr);
         }
+    }
 }
 
 int32_t
-error_gen_priv_dump (xlator_t *this)
+error_gen_priv_dump(xlator_t *this)
 {
-        char            key_prefix[GF_DUMP_MAX_BUF_LEN];
-        int             ret = -1;
-        eg_t            *conf = NULL;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN];
+    int ret = -1;
+    eg_t *conf = NULL;
 
-        if (!this)
-            goto out;
+    if (!this)
+        goto out;
 
-        conf = this->private;
-        if (!conf)
-            goto out;
+    conf = this->private;
+    if (!conf)
+        goto out;
 
-        ret = TRY_LOCK(&conf->lock);
-        if (ret != 0) {
-                return ret;
-        }
+    ret = TRY_LOCK(&conf->lock);
+    if (ret != 0) {
+        return ret;
+    }
 
-        gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name);
-        gf_proc_dump_build_key(key_prefix,"xlator.debug.error-gen","%s.priv",
-                               this->name);
+    gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name);
+    gf_proc_dump_build_key(key_prefix, "xlator.debug.error-gen", "%s.priv",
+                           this->name);
 
-        gf_proc_dump_write("op_count", "%d", conf->op_count);
-        gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no);
-        gf_proc_dump_write("error_no", "%s", conf->error_no);
-        gf_proc_dump_write("random_failure", "%d", conf->random_failure);
+    gf_proc_dump_write("op_count", "%d", conf->op_count);
+    gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no);
+    gf_proc_dump_write("error_no", "%s", conf->error_no);
+    gf_proc_dump_write("random_failure", "%d", conf->random_failure);
 
-        UNLOCK(&conf->lock);
+    UNLOCK(&conf->lock);
 out:
-        return ret;
+    return ret;
 }
 
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        if (!this)
-                return ret;
-
-        ret = xlator_mem_acct_init (this, gf_error_gen_mt_end + 1);
+    if (!this)
+        return ret;
 
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                        " failed");
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_error_gen_mt_end + 1);
 
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               " failed");
         return ret;
+    }
+
+    return ret;
 }
 
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        eg_t            *pvt = NULL;
-        int32_t          ret = 0;
-        char            *error_enable_fops = NULL;
-        double           failure_percent_dbl = 0.0;
+    eg_t *pvt = NULL;
+    int32_t ret = 0;
+    char *error_enable_fops = NULL;
+    double failure_percent_dbl = 0.0;
 
-        if (!this || !this->private)
-                goto out;
+    if (!this || !this->private)
+        goto out;
 
-        pvt = this->private;
+    pvt = this->private;
 
-        ret = -1;
+    ret = -1;
 
-        GF_OPTION_RECONF ("error-no", pvt->error_no, options, str, out);
+    GF_OPTION_RECONF("error-no", pvt->error_no, options, str, out);
 
-        if (pvt->error_no)
-                pvt->error_no_int = conv_errno_to_int (&pvt->error_no);
+    if (pvt->error_no)
+        pvt->error_no_int = conv_errno_to_int(&pvt->error_no);
 
-        GF_OPTION_RECONF ("failure", failure_percent_dbl, options, percent,
-                          out);
+    GF_OPTION_RECONF("failure", failure_percent_dbl, options, percent, out);
 
-        GF_OPTION_RECONF ("enable", error_enable_fops, options, str, out);
+    GF_OPTION_RECONF("enable", error_enable_fops, options, str, out);
 
-        GF_OPTION_RECONF ("random-failure", pvt->random_failure, options,
-                          bool, out);
+    GF_OPTION_RECONF("random-failure", pvt->random_failure, options, bool, out);
 
-        error_gen_parse_fill_fops (pvt, error_enable_fops);
-        error_gen_set_failure (pvt, failure_percent_dbl);
+    error_gen_parse_fill_fops(pvt, error_enable_fops);
+    error_gen_set_failure(pvt, failure_percent_dbl);
 
-        ret = 0;
+    ret = 0;
 out:
-        gf_log (this ? this->name : "error-gen", GF_LOG_DEBUG,
-                "reconfigure returning %d", ret);
-        return ret;
+    gf_log(this ? this->name : "error-gen", GF_LOG_DEBUG,
+           "reconfigure returning %d", ret);
+    return ret;
 }
 
 int
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        eg_t            *pvt = NULL;
-        int32_t          ret = 0;
-        char            *error_enable_fops = NULL;
-        double          failure_percent_dbl = 0.0;
-
-        if (!this->children || this->children->next) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "error-gen not configured with one subvolume");
-                ret = -1;
-                goto out;
-        }
-
-        if (!this->parents) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "dangling volume. check volfile ");
-        }
-
-        pvt = GF_CALLOC (1, sizeof (eg_t), gf_error_gen_mt_eg_t);
+    eg_t *pvt = NULL;
+    int32_t ret = 0;
+    char *error_enable_fops = NULL;
+    double failure_percent_dbl = 0.0;
+
+    if (!this->children || this->children->next) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "error-gen not configured with one subvolume");
+        ret = -1;
+        goto out;
+    }
 
-        if (!pvt) {
-                ret = -1;
-                goto out;
-        }
+    if (!this->parents) {
+        gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile ");
+    }
 
-        LOCK_INIT (&pvt->lock);
+    pvt = GF_CALLOC(1, sizeof(eg_t), gf_error_gen_mt_eg_t);
 
+    if (!pvt) {
         ret = -1;
+        goto out;
+    }
 
-        GF_OPTION_INIT ("error-no", pvt->error_no, str, out);
+    LOCK_INIT(&pvt->lock);
 
-        if (pvt->error_no)
-                pvt->error_no_int = conv_errno_to_int (&pvt->error_no);
+    ret = -1;
 
-        GF_OPTION_INIT ("failure", failure_percent_dbl, percent, out);
+    GF_OPTION_INIT("error-no", pvt->error_no, str, out);
 
-        GF_OPTION_INIT ("enable", error_enable_fops, str, out);
+    if (pvt->error_no)
+        pvt->error_no_int = conv_errno_to_int(&pvt->error_no);
 
-        GF_OPTION_INIT ("random-failure", pvt->random_failure, bool, out);
+    GF_OPTION_INIT("failure", failure_percent_dbl, percent, out);
 
+    GF_OPTION_INIT("enable", error_enable_fops, str, out);
 
-        error_gen_parse_fill_fops (pvt, error_enable_fops);
-        error_gen_set_failure (pvt, failure_percent_dbl);
+    GF_OPTION_INIT("random-failure", pvt->random_failure, bool, out);
 
-        this->private = pvt;
+    error_gen_parse_fill_fops(pvt, error_enable_fops);
+    error_gen_set_failure(pvt, failure_percent_dbl);
 
-        /* Give some seed value here */
-        srand (time(NULL));
+    this->private = pvt;
 
-        ret = 0;
+    /* Give some seed value here */
+    srand(time(NULL));
+
+    ret = 0;
 out:
-        if (ret)
-                GF_FREE (pvt);
-        return ret;
+    if (ret)
+        GF_FREE(pvt);
+    return ret;
 }
 
-
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        eg_t            *pvt = NULL;
-
-        if (!this)
-                 return;
-        pvt = this->private;
+    eg_t *pvt = NULL;
 
-        if (pvt) {
-                LOCK_DESTROY (&pvt->lock);
-                GF_FREE (pvt);
-                gf_log (this->name, GF_LOG_DEBUG, "fini called");
-        }
+    if (!this)
         return;
+    pvt = this->private;
+
+    if (pvt) {
+        LOCK_DESTROY(&pvt->lock);
+        GF_FREE(pvt);
+        gf_log(this->name, GF_LOG_DEBUG, "fini called");
+    }
+    return;
 }
 
 struct xlator_dumpops dumpops = {
-        .priv = error_gen_priv_dump,
+    .priv = error_gen_priv_dump,
 };
 
 struct xlator_cbks cbks;
 
 struct xlator_fops fops = {
-	.lookup      = error_gen_lookup,
-	.stat        = error_gen_stat,
-	.readlink    = error_gen_readlink,
-	.mknod       = error_gen_mknod,
-	.mkdir       = error_gen_mkdir,
-	.unlink      = error_gen_unlink,
-	.rmdir       = error_gen_rmdir,
-	.symlink     = error_gen_symlink,
-	.rename      = error_gen_rename,
-	.link        = error_gen_link,
-	.truncate    = error_gen_truncate,
-	.create      = error_gen_create,
-	.open        = error_gen_open,
-	.readv       = error_gen_readv,
-	.writev      = error_gen_writev,
-	.statfs      = error_gen_statfs,
-	.flush       = error_gen_flush,
-	.fsync       = error_gen_fsync,
-	.setxattr    = error_gen_setxattr,
-	.getxattr    = error_gen_getxattr,
-	.removexattr = error_gen_removexattr,
-	.fsetxattr    = error_gen_fsetxattr,
-	.fgetxattr    = error_gen_fgetxattr,
-	.fremovexattr = error_gen_fremovexattr,
-	.opendir     = error_gen_opendir,
-	.readdir     = error_gen_readdir,
-	.readdirp    = error_gen_readdirp,
-	.fsyncdir    = error_gen_fsyncdir,
-	.access      = error_gen_access,
-	.ftruncate   = error_gen_ftruncate,
-	.fstat       = error_gen_fstat,
-	.lk          = error_gen_lk,
-	.xattrop     = error_gen_xattrop,
-	.fxattrop    = error_gen_fxattrop,
-	.inodelk     = error_gen_inodelk,
-	.finodelk    = error_gen_finodelk,
-	.entrylk     = error_gen_entrylk,
-	.fentrylk    = error_gen_fentrylk,
-        .setattr     = error_gen_setattr,
-        .fsetattr    = error_gen_fsetattr,
-	.getspec     = error_gen_getspec,
+    .lookup = error_gen_lookup,
+    .stat = error_gen_stat,
+    .readlink = error_gen_readlink,
+    .mknod = error_gen_mknod,
+    .mkdir = error_gen_mkdir,
+    .unlink = error_gen_unlink,
+    .rmdir = error_gen_rmdir,
+    .symlink = error_gen_symlink,
+    .rename = error_gen_rename,
+    .link = error_gen_link,
+    .truncate = error_gen_truncate,
+    .create = error_gen_create,
+    .open = error_gen_open,
+    .readv = error_gen_readv,
+    .writev = error_gen_writev,
+    .statfs = error_gen_statfs,
+    .flush = error_gen_flush,
+    .fsync = error_gen_fsync,
+    .setxattr = error_gen_setxattr,
+    .getxattr = error_gen_getxattr,
+    .removexattr = error_gen_removexattr,
+    .fsetxattr = error_gen_fsetxattr,
+    .fgetxattr = error_gen_fgetxattr,
+    .fremovexattr = error_gen_fremovexattr,
+    .opendir = error_gen_opendir,
+    .readdir = error_gen_readdir,
+    .readdirp = error_gen_readdirp,
+    .fsyncdir = error_gen_fsyncdir,
+    .access = error_gen_access,
+    .ftruncate = error_gen_ftruncate,
+    .fstat = error_gen_fstat,
+    .lk = error_gen_lk,
+    .xattrop = error_gen_xattrop,
+    .fxattrop = error_gen_fxattrop,
+    .inodelk = error_gen_inodelk,
+    .finodelk = error_gen_finodelk,
+    .entrylk = error_gen_entrylk,
+    .fentrylk = error_gen_fentrylk,
+    .setattr = error_gen_setattr,
+    .fsetattr = error_gen_fsetattr,
+    .getspec = error_gen_getspec,
 };
 
 struct volume_options options[] = {
-        { .key  = {"failure"},
-          .type = GF_OPTION_TYPE_PERCENT,
-          .description = "Percentage failure of operations when enabled.",
-        },
-
-        { .key  = {"error-no"},
-          .value = {"ENOENT","ENOTDIR","ENAMETOOLONG","EACCES","EBADF",
-                    "EFAULT","ENOMEM","EINVAL","EIO","EEXIST","ENOSPC",
-                    "EPERM","EROFS","EBUSY","EISDIR","ENOTEMPTY","EMLINK"
-                    "ENODEV","EXDEV","EMFILE","ENFILE","ENOSYS","EINTR",
-                    "EFBIG","EAGAIN","GF_ERROR_SHORT_WRITE"},
-          .type = GF_OPTION_TYPE_STR,
-          .op_version = {3},
-          .tags = {"error-gen"},
-          .flags = OPT_FLAG_SETTABLE,
-
-        },
-
-        { .key = {"random-failure"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .op_version = {3},
-          .tags = {"error-gen"},
-          .flags = OPT_FLAG_SETTABLE,
-        },
-
-        { .key  = {"enable", "error-fops"},
-          .type = GF_OPTION_TYPE_STR,
-          .description = "Accepts a string which takes ',' separated fop "
-                         "strings to denote which fops are enabled for error",
-          .op_version = {3},
-          .tags = {"error-gen"},
-          .flags = OPT_FLAG_SETTABLE,
-        },
-
-        { .key  = {NULL} }
-};
+    {
+        .key = {"failure"},
+        .type = GF_OPTION_TYPE_PERCENT,
+        .description = "Percentage failure of operations when enabled.",
+    },
+
+    {
+        .key = {"error-no"},
+        .value = {"ENOENT",
+                  "ENOTDIR",
+                  "ENAMETOOLONG",
+                  "EACCES",
+                  "EBADF",
+                  "EFAULT",
+                  "ENOMEM",
+                  "EINVAL",
+                  "EIO",
+                  "EEXIST",
+                  "ENOSPC",
+                  "EPERM",
+                  "EROFS",
+                  "EBUSY",
+                  "EISDIR",
+                  "ENOTEMPTY",
+                  "EMLINK"
+                  "ENODEV",
+                  "EXDEV",
+                  "EMFILE",
+                  "ENFILE",
+                  "ENOSYS",
+                  "EINTR",
+                  "EFBIG",
+                  "EAGAIN",
+                  "GF_ERROR_SHORT_WRITE"},
+        .type = GF_OPTION_TYPE_STR,
+        .op_version = {3},
+        .tags = {"error-gen"},
+        .flags = OPT_FLAG_SETTABLE,
+
+    },
+
+    {
+        .key = {"random-failure"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "off",
+        .op_version = {3},
+        .tags = {"error-gen"},
+        .flags = OPT_FLAG_SETTABLE,
+    },
+
+    {
+        .key = {"enable", "error-fops"},
+        .type = GF_OPTION_TYPE_STR,
+        .description = "Accepts a string which takes ',' separated fop "
+                       "strings to denote which fops are enabled for error",
+        .op_version = {3},
+        .tags = {"error-gen"},
+        .flags = OPT_FLAG_SETTABLE,
+    },
+
+    {.key = {NULL}}};
diff --git a/xlators/debug/io-stats/src/io-stats.c b/xlators/debug/io-stats/src/io-stats.c
index 4bc8b7999a7..6f6104033d8 100644
--- a/xlators/debug/io-stats/src/io-stats.c
+++ b/xlators/debug/io-stats/src/io-stats.c
@@ -17,9 +17,9 @@
  *
  *  a) total read data - since process start, last interval and per fd
  *  b) total write data - since process start, last interval and per fd
- *  c) counts of read IO block size - since process start, last interval and per fd
- *  d) counts of write IO block size - since process start, last interval and per fd
- *  e) counts of all FOP types passing through it
+ *  c) counts of read IO block size - since process start, last interval and per
+ * fd d) counts of write IO block size - since process start, last interval and
+ * per fd e) counts of all FOP types passing through it
  *
  *  Usage: setfattr -n trusted.io-stats-dump /tmp/filename /mnt/gluster
  *      output is written to /tmp/filename.<iostats xlator instance name>
@@ -49,169 +49,168 @@
 #define IOS_STATS_DUMP_DIR DEFAULT_VAR_RUN_DIRECTORY
 
 typedef enum {
-        IOS_STATS_TYPE_NONE,
-        IOS_STATS_TYPE_OPEN,
-        IOS_STATS_TYPE_READ,
-        IOS_STATS_TYPE_WRITE,
-        IOS_STATS_TYPE_OPENDIR,
-        IOS_STATS_TYPE_READDIRP,
-        IOS_STATS_TYPE_READ_THROUGHPUT,
-        IOS_STATS_TYPE_WRITE_THROUGHPUT,
-        IOS_STATS_TYPE_MAX
-}ios_stats_type_t;
+    IOS_STATS_TYPE_NONE,
+    IOS_STATS_TYPE_OPEN,
+    IOS_STATS_TYPE_READ,
+    IOS_STATS_TYPE_WRITE,
+    IOS_STATS_TYPE_OPENDIR,
+    IOS_STATS_TYPE_READDIRP,
+    IOS_STATS_TYPE_READ_THROUGHPUT,
+    IOS_STATS_TYPE_WRITE_THROUGHPUT,
+    IOS_STATS_TYPE_MAX
+} ios_stats_type_t;
 
 typedef enum {
-        IOS_STATS_THRU_READ,
-        IOS_STATS_THRU_WRITE,
-        IOS_STATS_THRU_MAX,
-}ios_stats_thru_t;
+    IOS_STATS_THRU_READ,
+    IOS_STATS_THRU_WRITE,
+    IOS_STATS_THRU_MAX,
+} ios_stats_thru_t;
 
 struct ios_stat_lat {
-        struct timeval  time;
-        double          throughput;
+    struct timeval time;
+    double throughput;
 };
 
 struct ios_stat {
-        gf_lock_t       lock;
-        uuid_t          gfid;
-        char           *filename;
-        gf_atomic_t     counters[IOS_STATS_TYPE_MAX];
-        struct ios_stat_lat thru_counters [IOS_STATS_THRU_MAX];
-        gf_atomic_t     refcnt;
+    gf_lock_t lock;
+    uuid_t gfid;
+    char *filename;
+    gf_atomic_t counters[IOS_STATS_TYPE_MAX];
+    struct ios_stat_lat thru_counters[IOS_STATS_THRU_MAX];
+    gf_atomic_t refcnt;
 };
 
 struct ios_stat_list {
-        struct list_head  list;
-        struct ios_stat  *iosstat;
-        double            value;
+    struct list_head list;
+    struct ios_stat *iosstat;
+    double value;
 };
 
 struct ios_stat_head {
-       gf_lock_t                lock;
-       double                   min_cnt;
-       uint64_t                 members;
-       struct ios_stat_list    *iosstats;
+    gf_lock_t lock;
+    double min_cnt;
+    uint64_t members;
+    struct ios_stat_list *iosstats;
 };
 
 typedef struct _ios_sample_t {
-        uid_t  uid;
-        gid_t  gid;
-        char   identifier[UNIX_PATH_MAX];
-        glusterfs_fop_t fop_type;
-        struct timeval timestamp;
-        double elapsed;
+    uid_t uid;
+    gid_t gid;
+    char identifier[UNIX_PATH_MAX];
+    glusterfs_fop_t fop_type;
+    struct timeval timestamp;
+    double elapsed;
 } ios_sample_t;
 
-
 typedef struct _ios_sample_buf_t {
-        uint64_t        pos;  /* Position in write buffer */
-        uint64_t        size;  /* Size of ring buffer */
-        uint64_t        collected;  /* Number of samples we've collected */
-        uint64_t        observed;  /* Number of FOPs we've observed */
-        ios_sample_t    *ios_samples;  /* Our list of samples */
+    uint64_t pos;              /* Position in write buffer */
+    uint64_t size;             /* Size of ring buffer */
+    uint64_t collected;        /* Number of samples we've collected */
+    uint64_t observed;         /* Number of FOPs we've observed */
+    ios_sample_t *ios_samples; /* Our list of samples */
 } ios_sample_buf_t;
 
-
 struct ios_lat {
-        double      min;
-        double      max;
-        double      avg;
-        uint64_t    total;
+    double min;
+    double max;
+    double avg;
+    uint64_t total;
 };
 
 struct ios_global_stats {
-        gf_atomic_t     data_written;
-        gf_atomic_t     data_read;
-        gf_atomic_t     block_count_write[IOS_BLOCK_COUNT_SIZE];
-        gf_atomic_t     block_count_read[IOS_BLOCK_COUNT_SIZE];
-        gf_atomic_t     fop_hits[GF_FOP_MAXVALUE];
-        gf_atomic_t     upcall_hits[GF_UPCALL_FLAGS_MAXVALUE];
-        struct timeval  started_at;
-        struct ios_lat  latency[GF_FOP_MAXVALUE];
-        uint64_t        nr_opens;
-        uint64_t        max_nr_opens;
-        struct timeval  max_openfd_time;
+    gf_atomic_t data_written;
+    gf_atomic_t data_read;
+    gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE];
+    gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE];
+    gf_atomic_t fop_hits[GF_FOP_MAXVALUE];
+    gf_atomic_t upcall_hits[GF_UPCALL_FLAGS_MAXVALUE];
+    struct timeval started_at;
+    struct ios_lat latency[GF_FOP_MAXVALUE];
+    uint64_t nr_opens;
+    uint64_t max_nr_opens;
+    struct timeval max_openfd_time;
 };
 
 typedef enum {
-        IOS_DUMP_TYPE_NONE      = 0,
-        IOS_DUMP_TYPE_FILE      = 1,
-        IOS_DUMP_TYPE_DICT      = 2,
-        IOS_DUMP_TYPE_JSON_FILE = 3,
-        IOS_DUMP_TYPE_SAMPLES   = 4,
-        IOS_DUMP_TYPE_MAX       = 5
+    IOS_DUMP_TYPE_NONE = 0,
+    IOS_DUMP_TYPE_FILE = 1,
+    IOS_DUMP_TYPE_DICT = 2,
+    IOS_DUMP_TYPE_JSON_FILE = 3,
+    IOS_DUMP_TYPE_SAMPLES = 4,
+    IOS_DUMP_TYPE_MAX = 5
 } ios_dump_type_t;
 
 struct ios_conf {
-        gf_lock_t                 lock;
-        struct ios_global_stats   cumulative;
-        uint64_t                  increment;
-        struct ios_global_stats   incremental;
-        gf_boolean_t              dump_fd_stats;
-        gf_boolean_t              count_fop_hits;
-        gf_boolean_t              measure_latency;
-        struct ios_stat_head      list[IOS_STATS_TYPE_MAX];
-        struct ios_stat_head      thru_list[IOS_STATS_THRU_MAX];
-        int32_t                   ios_dump_interval;
-        pthread_t                 dump_thread;
-        gf_boolean_t              dump_thread_should_die;
-        gf_boolean_t              dump_thread_running;
-        gf_lock_t                 ios_sampling_lock;
-        int32_t                   ios_sample_interval;
-        int32_t                   ios_sample_buf_size;
-        ios_sample_buf_t          *ios_sample_buf;
-        struct dnscache           *dnscache;
-        int32_t                   ios_dnscache_ttl_sec;
-        /*
-         * What we really need here is just a unique value to keep files
-         * created by this instance distinct from those created by any other.
-         * On the client side this isn't a problem, so we just use the
-         * translator name.  On the server side conflicts can occur, so the
-         * volfile-generation code automatically sets this (via an option)
-         * to be the brick path.
-         *
-         * NB While the *field* name has changed, it didn't seem worth changing
-         * all of the cases where "xlator_name" is used as a *variable* name.
-         */
-        char                      *unique_id;
-        ios_dump_type_t            dump_format;
-        char                      *dump_format_str;
+    gf_lock_t lock;
+    struct ios_global_stats cumulative;
+    uint64_t increment;
+    struct ios_global_stats incremental;
+    gf_boolean_t dump_fd_stats;
+    gf_boolean_t count_fop_hits;
+    gf_boolean_t measure_latency;
+    struct ios_stat_head list[IOS_STATS_TYPE_MAX];
+    struct ios_stat_head thru_list[IOS_STATS_THRU_MAX];
+    int32_t ios_dump_interval;
+    pthread_t dump_thread;
+    gf_boolean_t dump_thread_should_die;
+    gf_boolean_t dump_thread_running;
+    gf_lock_t ios_sampling_lock;
+    int32_t ios_sample_interval;
+    int32_t ios_sample_buf_size;
+    ios_sample_buf_t *ios_sample_buf;
+    struct dnscache *dnscache;
+    int32_t ios_dnscache_ttl_sec;
+    /*
+     * What we really need here is just a unique value to keep files
+     * created by this instance distinct from those created by any other.
+     * On the client side this isn't a problem, so we just use the
+     * translator name.  On the server side conflicts can occur, so the
+     * volfile-generation code automatically sets this (via an option)
+     * to be the brick path.
+     *
+     * NB While the *field* name has changed, it didn't seem worth changing
+     * all of the cases where "xlator_name" is used as a *variable* name.
+     */
+    char *unique_id;
+    ios_dump_type_t dump_format;
+    char *dump_format_str;
 };
 
-
 struct ios_fd {
-        char           *filename;
-        gf_atomic_t     data_written;
-        gf_atomic_t     data_read;
-        gf_atomic_t     block_count_write[IOS_BLOCK_COUNT_SIZE];
-        gf_atomic_t     block_count_read[IOS_BLOCK_COUNT_SIZE];
-        struct timeval  opened_at;
+    char *filename;
+    gf_atomic_t data_written;
+    gf_atomic_t data_read;
+    gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE];
+    gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE];
+    struct timeval opened_at;
 };
 
 struct ios_dump_args {
-        ios_dump_type_t type;
-        union {
-                FILE *logfp;
-                dict_t *dict;
-        } u;
+    ios_dump_type_t type;
+    union {
+        FILE *logfp;
+        dict_t *dict;
+    } u;
 };
 
-typedef int (*block_dump_func) (xlator_t *, struct ios_dump_args*,
-                                    int , int , uint64_t ) ;
+typedef int (*block_dump_func)(xlator_t *, struct ios_dump_args *, int, int,
+                               uint64_t);
 
 struct ios_local {
-        struct timeval  wind_at;
-        struct timeval  unwind_at;
+    struct timeval wind_at;
+    struct timeval unwind_at;
 };
 
 struct volume_options options[];
 
 static int
-is_fop_latency_started (call_frame_t *frame)
+is_fop_latency_started(call_frame_t *frame)
 {
-        GF_ASSERT (frame);
-        struct timeval epoch = {0,};
-        return memcmp (&frame->begin, &epoch, sizeof (epoch));
+    GF_ASSERT(frame);
+    struct timeval epoch = {
+        0,
+    };
+    return memcmp(&frame->begin, &epoch, sizeof(epoch));
 }
 
 #define _IOS_SAMP_DIR DEFAULT_LOG_FILE_DIRECTORY "/samples"
@@ -221,354 +220,334 @@ is_fop_latency_started (call_frame_t *frame)
 #define _IOS_DUMP_DIR DATADIR "/db/glusterd/stats"
 #endif
 
-#define END_FOP_LATENCY(frame, op)                                      \
-        do {                                                            \
-                struct ios_conf  *conf = NULL;                          \
-                                                                        \
-                conf = this->private;                                   \
-                if (conf && conf->measure_latency) {                    \
-                        timespec_now (&frame->end);                     \
-                        update_ios_latency (conf, frame, GF_FOP_##op);  \
-                }                                                       \
-        } while (0)
-
-#define START_FOP_LATENCY(frame)                                         \
-        do {                                                             \
-                struct ios_conf  *conf = NULL;                           \
-                                                                         \
-                conf = this->private;                                    \
-                if (conf && conf->measure_latency) {                     \
-                        timespec_now (&frame->begin);                    \
-                } else {                                                 \
-                        memset (&frame->begin, 0, sizeof (frame->begin));\
-                }                                                        \
-        } while (0)
-
-
-#define BUMP_FOP(op)                                                    \
-        do {                                                            \
-                struct ios_conf  *conf = NULL;                          \
-                                                                        \
-                conf = this->private;                                   \
-                if (!conf)                                              \
-                        break;                                          \
-                GF_ATOMIC_INC (conf->cumulative.fop_hits[GF_FOP_##op]); \
-                GF_ATOMIC_INC (conf->incremental.fop_hits[GF_FOP_##op]);\
-        } while (0)
-
-#define UPDATE_PROFILE_STATS(frame, op)                                       \
-        do {                                                                  \
-                struct ios_conf  *conf = NULL;                                \
-                                                                              \
-                if (!is_fop_latency_started (frame))                          \
-                        break;                                                \
-                conf = this->private;                                         \
-                if (conf && conf->measure_latency &&                          \
-                    conf->count_fop_hits) {                                   \
-                        BUMP_FOP (op);                                        \
-                        timespec_now (&frame->end);                           \
-                        update_ios_latency (conf, frame, GF_FOP_##op);        \
-                }                                                             \
-        } while (0)
+#define END_FOP_LATENCY(frame, op)                                             \
+    do {                                                                       \
+        struct ios_conf *conf = NULL;                                          \
+                                                                               \
+        conf = this->private;                                                  \
+        if (conf && conf->measure_latency) {                                   \
+            timespec_now(&frame->end);                                         \
+            update_ios_latency(conf, frame, GF_FOP_##op);                      \
+        }                                                                      \
+    } while (0)
+
+#define START_FOP_LATENCY(frame)                                               \
+    do {                                                                       \
+        struct ios_conf *conf = NULL;                                          \
+                                                                               \
+        conf = this->private;                                                  \
+        if (conf && conf->measure_latency) {                                   \
+            timespec_now(&frame->begin);                                       \
+        } else {                                                               \
+            memset(&frame->begin, 0, sizeof(frame->begin));                    \
+        }                                                                      \
+    } while (0)
+
+#define BUMP_FOP(op)                                                           \
+    do {                                                                       \
+        struct ios_conf *conf = NULL;                                          \
+                                                                               \
+        conf = this->private;                                                  \
+        if (!conf)                                                             \
+            break;                                                             \
+        GF_ATOMIC_INC(conf->cumulative.fop_hits[GF_FOP_##op]);                 \
+        GF_ATOMIC_INC(conf->incremental.fop_hits[GF_FOP_##op]);                \
+    } while (0)
+
+#define UPDATE_PROFILE_STATS(frame, op)                                        \
+    do {                                                                       \
+        struct ios_conf *conf = NULL;                                          \
+                                                                               \
+        if (!is_fop_latency_started(frame))                                    \
+            break;                                                             \
+        conf = this->private;                                                  \
+        if (conf && conf->measure_latency && conf->count_fop_hits) {           \
+            BUMP_FOP(op);                                                      \
+            timespec_now(&frame->end);                                         \
+            update_ios_latency(conf, frame, GF_FOP_##op);                      \
+        }                                                                      \
+    } while (0)
 
 #define BUMP_THROUGHPUT(iosstat, type)                                         \
-        do {                                                                   \
-                struct ios_conf         *conf = NULL;                          \
-                double                   elapsed;                              \
-                struct timespec         *begin, *end;                          \
-                double                   throughput;                           \
-                int                      flag = 0;                             \
+    do {                                                                       \
+        struct ios_conf *conf = NULL;                                          \
+        double elapsed;                                                        \
+        struct timespec *begin, *end;                                          \
+        double throughput;                                                     \
+        int flag = 0;                                                          \
                                                                                \
-                begin = &frame->begin;                                         \
-                end   = &frame->end;                                           \
+        begin = &frame->begin;                                                 \
+        end = &frame->end;                                                     \
                                                                                \
-                elapsed = ((end->tv_sec - begin->tv_sec) * 1e9                 \
-                           + (end->tv_nsec - begin->tv_nsec)) / 1000;          \
-                throughput = op_ret / elapsed;                                 \
+        elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 +                       \
+                   (end->tv_nsec - begin->tv_nsec)) /                          \
+                  1000;                                                        \
+        throughput = op_ret / elapsed;                                         \
                                                                                \
-                conf = this->private;                                          \
-                LOCK (&iosstat->lock);                                         \
-                {                                                              \
-                        if (iosstat->thru_counters[type].throughput            \
-                                <= throughput) {                               \
-                                iosstat->thru_counters[type].throughput =      \
-                                                                throughput;    \
-                                gettimeofday (&iosstat->                       \
-                                             thru_counters[type].time, NULL);  \
-                               flag = 1;                                       \
-                        }                                                      \
-                }                                                              \
-                UNLOCK (&iosstat->lock);                                       \
-                if (flag)                                                      \
-                       ios_stat_add_to_list (&conf->thru_list[type],           \
-                                               throughput, iosstat);           \
-        } while (0)
+        conf = this->private;                                                  \
+        LOCK(&iosstat->lock);                                                  \
+        {                                                                      \
+            if (iosstat->thru_counters[type].throughput <= throughput) {       \
+                iosstat->thru_counters[type].throughput = throughput;          \
+                gettimeofday(&iosstat->thru_counters[type].time, NULL);        \
+                flag = 1;                                                      \
+            }                                                                  \
+        }                                                                      \
+        UNLOCK(&iosstat->lock);                                                \
+        if (flag)                                                              \
+            ios_stat_add_to_list(&conf->thru_list[type], throughput, iosstat); \
+    } while (0)
 
 static int
-ios_fd_ctx_get (fd_t *fd, xlator_t *this, struct ios_fd **iosfd)
+ios_fd_ctx_get(fd_t *fd, xlator_t *this, struct ios_fd **iosfd)
 {
-        uint64_t      iosfd64 = 0;
-        unsigned long iosfdlong = 0;
-        int           ret = 0;
+    uint64_t iosfd64 = 0;
+    unsigned long iosfdlong = 0;
+    int ret = 0;
 
-        ret = fd_ctx_get (fd, this, &iosfd64);
-        iosfdlong = iosfd64;
-        if (ret != -1)
-                *iosfd = (void *) iosfdlong;
+    ret = fd_ctx_get(fd, this, &iosfd64);
+    iosfdlong = iosfd64;
+    if (ret != -1)
+        *iosfd = (void *)iosfdlong;
 
-        return ret;
+    return ret;
 }
 
-
 static int
-ios_fd_ctx_set (fd_t *fd, xlator_t *this, struct ios_fd *iosfd)
+ios_fd_ctx_set(fd_t *fd, xlator_t *this, struct ios_fd *iosfd)
 {
-        uint64_t   iosfd64 = 0;
-        int        ret = 0;
+    uint64_t iosfd64 = 0;
+    int ret = 0;
 
-        iosfd64 = (unsigned long) iosfd;
-        ret = fd_ctx_set (fd, this, iosfd64);
+    iosfd64 = (unsigned long)iosfd;
+    ret = fd_ctx_set(fd, this, iosfd64);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-ios_stat_ref (struct ios_stat *iosstat)
+ios_stat_ref(struct ios_stat *iosstat)
 {
-        uint64_t refcnt = 0;
-        refcnt = GF_ATOMIC_INC (iosstat->refcnt);
+    uint64_t refcnt = 0;
+    refcnt = GF_ATOMIC_INC(iosstat->refcnt);
 
-        return refcnt;
+    return refcnt;
 }
 
-
 static int
-ios_stat_unref (struct ios_stat *iosstat)
+ios_stat_unref(struct ios_stat *iosstat)
 {
-        int cleanup = 0;
-        uint64_t refcnt = 0;
+    int cleanup = 0;
+    uint64_t refcnt = 0;
 
-        refcnt = GF_ATOMIC_DEC (iosstat->refcnt);
-        if (refcnt == 0) {
-                if (iosstat->filename) {
-                        GF_FREE (iosstat->filename);
-                        iosstat->filename = NULL;
-                }
-                cleanup = 1;
+    refcnt = GF_ATOMIC_DEC(iosstat->refcnt);
+    if (refcnt == 0) {
+        if (iosstat->filename) {
+            GF_FREE(iosstat->filename);
+            iosstat->filename = NULL;
         }
+        cleanup = 1;
+    }
 
-        if (cleanup) {
-                LOCK_DESTROY (&iosstat->lock);
-                GF_FREE (iosstat);
-                iosstat = NULL;
-        }
+    if (cleanup) {
+        LOCK_DESTROY(&iosstat->lock);
+        GF_FREE(iosstat);
+        iosstat = NULL;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-ios_stat_add_to_list (struct ios_stat_head *list_head, uint64_t value,
-                            struct ios_stat *iosstat)
-{
-        struct ios_stat_list *new = NULL;
-        struct ios_stat_list *entry = NULL;
-        struct ios_stat_list *t = NULL;
-        struct ios_stat_list *list_entry = NULL;
-        struct ios_stat_list *tmp = NULL;
-        struct ios_stat_list *last = NULL;
-        struct ios_stat      *stat = NULL;
-        int                   cnt = 0;
-        int                   found = 0;
-        int                   reposition = 0;
-        double                min_count = 0;
-
-        LOCK (&list_head->lock);
+ios_stat_add_to_list(struct ios_stat_head *list_head, uint64_t value,
+                     struct ios_stat *iosstat)
+{
+    struct ios_stat_list *new = NULL;
+    struct ios_stat_list *entry = NULL;
+    struct ios_stat_list *t = NULL;
+    struct ios_stat_list *list_entry = NULL;
+    struct ios_stat_list *tmp = NULL;
+    struct ios_stat_list *last = NULL;
+    struct ios_stat *stat = NULL;
+    int cnt = 0;
+    int found = 0;
+    int reposition = 0;
+    double min_count = 0;
+
+    LOCK(&list_head->lock);
+    {
+        if (list_head->min_cnt == 0)
+            list_head->min_cnt = value;
+        if ((list_head->members == MAX_LIST_MEMBERS) &&
+            (list_head->min_cnt > value))
+            goto out;
+
+        list_for_each_entry_safe(entry, t, &list_head->iosstats->list, list)
         {
-
-                if (list_head->min_cnt == 0)
+            cnt++;
+            if (cnt == list_head->members)
+                last = entry;
+
+            if (!gf_uuid_compare(iosstat->gfid, entry->iosstat->gfid)) {
+                list_entry = entry;
+                found = cnt;
+                entry->value = value;
+                if (!reposition) {
+                    if (cnt == list_head->members)
                         list_head->min_cnt = value;
-                if ((list_head->members == MAX_LIST_MEMBERS) &&
-                     (list_head->min_cnt > value))
-                        goto out;
-
-                list_for_each_entry_safe (entry, t,
-                              &list_head->iosstats->list, list) {
-                        cnt++;
-                        if (cnt == list_head->members)
-                                last = entry;
-
-                        if (!gf_uuid_compare (iosstat->gfid,
-                            entry->iosstat->gfid)) {
-                                list_entry = entry;
-                                found = cnt;
-                                entry->value = value;
-                                if (!reposition) {
-                                        if (cnt == list_head->members)
-                                                list_head->min_cnt = value;
-                                        goto out;
-                                }
-                                break;
-                        } else if (entry->value <= value && !reposition) {
-                                reposition = cnt;
-                                tmp = entry;
-                                if (cnt == list_head->members - 1)
-                                        min_count = entry->value;
-                        }
-                }
-                if (found) {
-                        list_del (&list_entry->list);
-                        list_add_tail (&list_entry->list, &tmp->list);
-                        if (min_count)
-                                list_head->min_cnt = min_count;
-                        goto out;
-                } else if (list_head->members == MAX_LIST_MEMBERS && reposition) {
-                        new = GF_CALLOC (1, sizeof (*new),
-                                        gf_io_stats_mt_ios_stat_list);
-                        new->iosstat = iosstat;
-                        new->value = value;
-                        ios_stat_ref (iosstat);
-                        list_add_tail (&new->list, &tmp->list);
-                        if (last) {
-                                stat = last->iosstat;
-                                last->iosstat = NULL;
-                                ios_stat_unref (stat);
-                                list_del (&last->list);
-                                GF_FREE (last);
-                        }
-                        if (reposition == MAX_LIST_MEMBERS)
-                                list_head->min_cnt = value;
-                        else if (min_count) {
-                                list_head->min_cnt = min_count;
-                        }
-                } else if (list_head->members < MAX_LIST_MEMBERS) {
-                        new  = GF_CALLOC (1, sizeof (*new),
-                                          gf_io_stats_mt_ios_stat_list);
-                        new->iosstat = iosstat;
-                        new->value = value;
-                        ios_stat_ref (iosstat);
-                        if (reposition) {
-                                list_add_tail (&new->list, &tmp->list);
-                        } else {
-                                list_add_tail (&new->list, &entry->list);
-                        }
-                        list_head->members++;
-                        if (list_head->min_cnt > value)
-                                list_head->min_cnt = value;
+                    goto out;
                 }
+                break;
+            } else if (entry->value <= value && !reposition) {
+                reposition = cnt;
+                tmp = entry;
+                if (cnt == list_head->members - 1)
+                    min_count = entry->value;
+            }
+        }
+        if (found) {
+            list_del(&list_entry->list);
+            list_add_tail(&list_entry->list, &tmp->list);
+            if (min_count)
+                list_head->min_cnt = min_count;
+            goto out;
+        } else if (list_head->members == MAX_LIST_MEMBERS && reposition) {
+            new = GF_CALLOC(1, sizeof(*new), gf_io_stats_mt_ios_stat_list);
+            new->iosstat = iosstat;
+            new->value = value;
+            ios_stat_ref(iosstat);
+            list_add_tail(&new->list, &tmp->list);
+            if (last) {
+                stat = last->iosstat;
+                last->iosstat = NULL;
+                ios_stat_unref(stat);
+                list_del(&last->list);
+                GF_FREE(last);
+            }
+            if (reposition == MAX_LIST_MEMBERS)
+                list_head->min_cnt = value;
+            else if (min_count) {
+                list_head->min_cnt = min_count;
+            }
+        } else if (list_head->members < MAX_LIST_MEMBERS) {
+            new = GF_CALLOC(1, sizeof(*new), gf_io_stats_mt_ios_stat_list);
+            new->iosstat = iosstat;
+            new->value = value;
+            ios_stat_ref(iosstat);
+            if (reposition) {
+                list_add_tail(&new->list, &tmp->list);
+            } else {
+                list_add_tail(&new->list, &entry->list);
+            }
+            list_head->members++;
+            if (list_head->min_cnt > value)
+                list_head->min_cnt = value;
         }
+    }
 out:
-        UNLOCK (&list_head->lock);
-        return 0;
+    UNLOCK(&list_head->lock);
+    return 0;
 }
 
-
 static void
-ios_bump_read (xlator_t *this, fd_t *fd, size_t len)
-{
-        struct ios_conf  *conf = NULL;
-        struct ios_fd    *iosfd = NULL;
-        int               lb2 = 0;
-
-        conf = this->private;
-        lb2 = log_base2 (len);
-        ios_fd_ctx_get (fd, this, &iosfd);
-        if (!conf)
-                return;
-
-        GF_ATOMIC_ADD (conf->cumulative.data_read, len);
-        GF_ATOMIC_ADD (conf->incremental.data_read, len);
-        GF_ATOMIC_INC (conf->cumulative.block_count_read[lb2]);
-        GF_ATOMIC_INC (conf->incremental.block_count_read[lb2]);
-
-        if (iosfd) {
-                GF_ATOMIC_ADD (iosfd->data_read, len);
-                GF_ATOMIC_INC (iosfd->block_count_read[lb2]);
-        }
-}
+ios_bump_read(xlator_t *this, fd_t *fd, size_t len)
+{
+    struct ios_conf *conf = NULL;
+    struct ios_fd *iosfd = NULL;
+    int lb2 = 0;
 
+    conf = this->private;
+    lb2 = log_base2(len);
+    ios_fd_ctx_get(fd, this, &iosfd);
+    if (!conf)
+        return;
 
-static void
-ios_bump_write (xlator_t *this, fd_t *fd, size_t len)
-{
-        struct ios_conf  *conf = NULL;
-        struct ios_fd    *iosfd = NULL;
-        int               lb2 = 0;
-
-        conf = this->private;
-        lb2 = log_base2 (len);
-        ios_fd_ctx_get (fd, this, &iosfd);
-        if (!conf)
-                return;
-
-        GF_ATOMIC_ADD (conf->cumulative.data_written, len);
-        GF_ATOMIC_ADD (conf->incremental.data_written, len);
-        GF_ATOMIC_INC (conf->cumulative.block_count_write[lb2]);
-        GF_ATOMIC_INC (conf->incremental.block_count_write[lb2]);
-
-        if (iosfd) {
-                GF_ATOMIC_ADD (iosfd->data_written, len);
-                GF_ATOMIC_INC (iosfd->block_count_write[lb2]);
-        }
-}
+    GF_ATOMIC_ADD(conf->cumulative.data_read, len);
+    GF_ATOMIC_ADD(conf->incremental.data_read, len);
+    GF_ATOMIC_INC(conf->cumulative.block_count_read[lb2]);
+    GF_ATOMIC_INC(conf->incremental.block_count_read[lb2]);
 
+    if (iosfd) {
+        GF_ATOMIC_ADD(iosfd->data_read, len);
+        GF_ATOMIC_INC(iosfd->block_count_read[lb2]);
+    }
+}
 
 static void
-ios_bump_upcall (xlator_t *this, gf_upcall_flags_t event)
+ios_bump_write(xlator_t *this, fd_t *fd, size_t len)
 {
-        struct ios_conf  *conf = NULL;
+    struct ios_conf *conf = NULL;
+    struct ios_fd *iosfd = NULL;
+    int lb2 = 0;
 
-        conf = this->private;
-        if (!conf)
-                return;
-        if (conf->count_fop_hits) {
-                GF_ATOMIC_INC (conf->cumulative.upcall_hits[event]);
-                GF_ATOMIC_INC (conf->incremental.upcall_hits[event]);
-        }
+    conf = this->private;
+    lb2 = log_base2(len);
+    ios_fd_ctx_get(fd, this, &iosfd);
+    if (!conf)
+        return;
+
+    GF_ATOMIC_ADD(conf->cumulative.data_written, len);
+    GF_ATOMIC_ADD(conf->incremental.data_written, len);
+    GF_ATOMIC_INC(conf->cumulative.block_count_write[lb2]);
+    GF_ATOMIC_INC(conf->incremental.block_count_write[lb2]);
+
+    if (iosfd) {
+        GF_ATOMIC_ADD(iosfd->data_written, len);
+        GF_ATOMIC_INC(iosfd->block_count_write[lb2]);
+    }
 }
 
+static void
+ios_bump_upcall(xlator_t *this, gf_upcall_flags_t event)
+{
+    struct ios_conf *conf = NULL;
+
+    conf = this->private;
+    if (!conf)
+        return;
+    if (conf->count_fop_hits) {
+        GF_ATOMIC_INC(conf->cumulative.upcall_hits[event]);
+        GF_ATOMIC_INC(conf->incremental.upcall_hits[event]);
+    }
+}
 
 static void
-ios_bump_stats (xlator_t *this, struct ios_stat *iosstat,
-                ios_stats_type_t type)
+ios_bump_stats(xlator_t *this, struct ios_stat *iosstat, ios_stats_type_t type)
 {
-        struct ios_conf         *conf = NULL;
-        uint64_t                 value = 0;
+    struct ios_conf *conf = NULL;
+    uint64_t value = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        value = GF_ATOMIC_INC (iosstat->counters[type]);
-        ios_stat_add_to_list (&conf->list[type], value, iosstat);
+    value = GF_ATOMIC_INC(iosstat->counters[type]);
+    ios_stat_add_to_list(&conf->list[type], value, iosstat);
 }
 
-
 int
-ios_inode_ctx_set (inode_t *inode, xlator_t *this, struct ios_stat *iosstat)
+ios_inode_ctx_set(inode_t *inode, xlator_t *this, struct ios_stat *iosstat)
 {
-        uint64_t   iosstat64 = 0;
-        int        ret     = 0;
+    uint64_t iosstat64 = 0;
+    int ret = 0;
 
-        ios_stat_ref (iosstat);
-        iosstat64 = (unsigned long) iosstat;
-        ret = inode_ctx_put (inode, this, iosstat64);
-        return ret;
+    ios_stat_ref(iosstat);
+    iosstat64 = (unsigned long)iosstat;
+    ret = inode_ctx_put(inode, this, iosstat64);
+    return ret;
 }
 
 int
-ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat)
+ios_inode_ctx_get(inode_t *inode, xlator_t *this, struct ios_stat **iosstat)
 {
-        uint64_t      iosstat64 = 0;
-        unsigned long iosstatlong = 0;
-        int           ret = 0;
+    uint64_t iosstat64 = 0;
+    unsigned long iosstatlong = 0;
+    int ret = 0;
 
-        ret = inode_ctx_get (inode, this, &iosstat64);
-        iosstatlong = iosstat64;
-        if (ret != -1)
-                *iosstat = (void *) iosstatlong;
-
-        return ret;
+    ret = inode_ctx_get(inode, this, &iosstat64);
+    iosstatlong = iosstat64;
+    if (ret != -1)
+        *iosstat = (void *)iosstatlong;
 
+    return ret;
 }
 
 /*
@@ -583,598 +562,575 @@ ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat)
  *
  */
 ios_sample_buf_t *
-ios_create_sample_buf (size_t buf_size)
+ios_create_sample_buf(size_t buf_size)
 {
-        ios_sample_buf_t *ios_sample_buf = NULL;
-        ios_sample_t     *ios_samples = NULL;
+    ios_sample_buf_t *ios_sample_buf = NULL;
+    ios_sample_t *ios_samples = NULL;
 
-        ios_sample_buf = GF_CALLOC (1,
-                sizeof (*ios_sample_buf),
-                gf_io_stats_mt_ios_sample_buf);
-        if (!ios_sample_buf)
-                goto err;
+    ios_sample_buf = GF_CALLOC(1, sizeof(*ios_sample_buf),
+                               gf_io_stats_mt_ios_sample_buf);
+    if (!ios_sample_buf)
+        goto err;
 
-        ios_samples = GF_CALLOC (buf_size,
-                sizeof (*ios_samples),
-                gf_io_stats_mt_ios_sample);
+    ios_samples = GF_CALLOC(buf_size, sizeof(*ios_samples),
+                            gf_io_stats_mt_ios_sample);
 
-        if (!ios_samples)
-                goto err;
+    if (!ios_samples)
+        goto err;
 
-        ios_sample_buf->ios_samples = ios_samples;
-        ios_sample_buf->size = buf_size;
-        ios_sample_buf->pos = 0;
-        ios_sample_buf->observed = 0;
-        ios_sample_buf->collected = 0;
+    ios_sample_buf->ios_samples = ios_samples;
+    ios_sample_buf->size = buf_size;
+    ios_sample_buf->pos = 0;
+    ios_sample_buf->observed = 0;
+    ios_sample_buf->collected = 0;
 
-        return ios_sample_buf;
+    return ios_sample_buf;
 err:
-        GF_FREE (ios_sample_buf);
-        return NULL;
+    GF_FREE(ios_sample_buf);
+    return NULL;
 }
 
 void
-ios_destroy_sample_buf (ios_sample_buf_t *ios_sample_buf)
+ios_destroy_sample_buf(ios_sample_buf_t *ios_sample_buf)
 {
-        GF_FREE (ios_sample_buf->ios_samples);
-        GF_FREE (ios_sample_buf);
+    GF_FREE(ios_sample_buf->ios_samples);
+    GF_FREE(ios_sample_buf);
 }
 
 static int
-ios_init_sample_buf (struct ios_conf *conf)
+ios_init_sample_buf(struct ios_conf *conf)
 {
-        int32_t        ret = -1;
+    int32_t ret = -1;
 
-        GF_ASSERT (conf);
-        LOCK (&conf->lock);
-        conf->ios_sample_buf = ios_create_sample_buf (
-                conf->ios_sample_buf_size);
-        if (!conf->ios_sample_buf)
-                goto out;
-        ret = 0;
+    GF_ASSERT(conf);
+    LOCK(&conf->lock);
+    conf->ios_sample_buf = ios_create_sample_buf(conf->ios_sample_buf_size);
+    if (!conf->ios_sample_buf)
+        goto out;
+    ret = 0;
 out:
-        UNLOCK (&conf->lock);
-        return ret;
+    UNLOCK(&conf->lock);
+    return ret;
 }
 
 static int
-ios_stats_cleanup (xlator_t *this, inode_t *inode)
+ios_stats_cleanup(xlator_t *this, inode_t *inode)
 {
+    struct ios_stat *iosstat = NULL;
+    uint64_t iosstat64 = 0;
 
-        struct ios_stat *iosstat = NULL;
-        uint64_t         iosstat64 = 0;
-
-        inode_ctx_del (inode, this, &iosstat64);
-        if (!iosstat64) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "could not get inode ctx");
-                return 0;
-        }
-        iosstat = (void *) (long)iosstat64;
-        if (iosstat) {
-                ios_stat_unref (iosstat);
-        }
+    inode_ctx_del(inode, this, &iosstat64);
+    if (!iosstat64) {
+        gf_log(this->name, GF_LOG_WARNING, "could not get inode ctx");
         return 0;
-}
-
-#define ios_log(this, logfp, fmt ...)                           \
-        do {                                                    \
-                if (logfp) {                                    \
-                        fprintf (logfp, fmt);                   \
-                        fprintf (logfp, "\n");                  \
-                }                                               \
-                gf_log (this->name, GF_LOG_DEBUG, fmt);        \
-        } while (0)
+    }
+    iosstat = (void *)(long)iosstat64;
+    if (iosstat) {
+        ios_stat_unref(iosstat);
+    }
+    return 0;
+}
+
+#define ios_log(this, logfp, fmt...)                                           \
+    do {                                                                       \
+        if (logfp) {                                                           \
+            fprintf(logfp, fmt);                                               \
+            fprintf(logfp, "\n");                                              \
+        }                                                                      \
+        gf_log(this->name, GF_LOG_DEBUG, fmt);                                 \
+    } while (0)
 
 int
-ios_dump_file_stats (struct ios_stat_head *list_head, xlator_t *this,
-                     FILE *logfp)
+ios_dump_file_stats(struct ios_stat_head *list_head, xlator_t *this,
+                    FILE *logfp)
 {
-        struct ios_stat_list *entry = NULL;
+    struct ios_stat_list *entry = NULL;
 
-        LOCK (&list_head->lock);
+    LOCK(&list_head->lock);
+    {
+        list_for_each_entry(entry, &list_head->iosstats->list, list)
         {
-                list_for_each_entry (entry, &list_head->iosstats->list, list) {
-                        ios_log (this, logfp, "%-12.0f %s",
-                                entry->value, entry->iosstat->filename);
-                }
+            ios_log(this, logfp, "%-12.0f %s", entry->value,
+                    entry->iosstat->filename);
         }
-        UNLOCK (&list_head->lock);
-        return 0;
+    }
+    UNLOCK(&list_head->lock);
+    return 0;
 }
 
 int
-ios_dump_throughput_stats (struct ios_stat_head *list_head, xlator_t *this,
-                           FILE *logfp, ios_stats_thru_t type)
-{
-        struct ios_stat_list *entry = NULL;
-        struct timeval        time  = {0, };
-        char                  timestr[256] = {0, };
-
-        LOCK (&list_head->lock);
+ios_dump_throughput_stats(struct ios_stat_head *list_head, xlator_t *this,
+                          FILE *logfp, ios_stats_thru_t type)
+{
+    struct ios_stat_list *entry = NULL;
+    struct timeval time = {
+        0,
+    };
+    char timestr[256] = {
+        0,
+    };
+
+    LOCK(&list_head->lock);
+    {
+        list_for_each_entry(entry, &list_head->iosstats->list, list)
         {
-                list_for_each_entry (entry, &list_head->iosstats->list, list) {
-                        gf_time_fmt (timestr, sizeof timestr,
-                                     entry->iosstat->thru_counters[type].time.tv_sec,
-                                     gf_timefmt_FT);
-                        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                          ".%"GF_PRI_SUSECONDS, time.tv_usec);
-
-                        ios_log (this, logfp, "%s \t %-10.2f  \t  %s",
-                                 timestr, entry->value, entry->iosstat->filename);
-                }
+            gf_time_fmt(timestr, sizeof timestr,
+                        entry->iosstat->thru_counters[type].time.tv_sec,
+                        gf_timefmt_FT);
+            snprintf(timestr + strlen(timestr),
+                     sizeof timestr - strlen(timestr), ".%" GF_PRI_SUSECONDS,
+                     time.tv_usec);
+
+            ios_log(this, logfp, "%s \t %-10.2f  \t  %s", timestr, entry->value,
+                    entry->iosstat->filename);
         }
-        UNLOCK (&list_head->lock);
-        return 0;
+    }
+    UNLOCK(&list_head->lock);
+    return 0;
 }
 
 int
-_io_stats_get_key_prefix (xlator_t *this, char **key_prefix) {
-        char                  *key_root = "gluster";
-        char                  *xlator_name = NULL;
-        char                  *instance_name = NULL;
-        size_t                key_len = 0;
-        int                   bytes_written = 0;
-        int                   i = 0;
-        int                   ret = 0;
-        struct ios_conf       *conf = this->private;
-
-        xlator_name = strdupa (conf->unique_id);
-        for (i = 0; i < strlen (xlator_name); i++) {
-                if (xlator_name[i] == '/')
-                        xlator_name[i] = '_';
+_io_stats_get_key_prefix(xlator_t *this, char **key_prefix)
+{
+    char *key_root = "gluster";
+    char *xlator_name = NULL;
+    char *instance_name = NULL;
+    size_t key_len = 0;
+    int bytes_written = 0;
+    int i = 0;
+    int ret = 0;
+    struct ios_conf *conf = this->private;
+
+    xlator_name = strdupa(conf->unique_id);
+    for (i = 0; i < strlen(xlator_name); i++) {
+        if (xlator_name[i] == '/')
+            xlator_name[i] = '_';
+    }
+
+    instance_name = this->instance_name;
+    if (this->name && strcmp(this->name, "glustershd") == 0) {
+        xlator_name = "shd";
+    } else if (this->prev && strcmp(this->prev->name, "nfs-server") == 0) {
+        xlator_name = "nfsd";
+        if (this->prev->instance_name)
+            instance_name = strdupa(this->prev->instance_name);
+    }
+
+    if (strcmp(__progname, "glusterfsd") == 0)
+        key_root = "gluster.brick";
+
+    if (instance_name) {
+        /* +3 for 2 x "." + NULL */
+        key_len = strlen(key_root) + strlen(xlator_name) +
+                  strlen(instance_name) + 3;
+        *key_prefix = GF_CALLOC(key_len, sizeof(char), gf_common_mt_char);
+        if (!*key_prefix) {
+            ret = -ENOMEM;
+            goto err;
         }
-
-        instance_name = this->instance_name;
-        if (this->name && strcmp (this->name, "glustershd") == 0) {
-                xlator_name = "shd";
-        } else if (this->prev &&
-                   strcmp (this->prev->name, "nfs-server") == 0) {
-                xlator_name = "nfsd";
-                if (this->prev->instance_name)
-                        instance_name = strdupa (this->prev->instance_name);
+        bytes_written = snprintf(*key_prefix, key_len, "%s.%s.%s", key_root,
+                                 xlator_name, instance_name);
+        if (bytes_written != key_len - 1) {
+            ret = -EINVAL;
+            goto err;
         }
-
-        if (strcmp (__progname, "glusterfsd") == 0)
-                key_root = "gluster.brick";
-
-        if (instance_name) {
-                /* +3 for 2 x "." + NULL */
-                key_len = strlen (key_root) + strlen (xlator_name) +
-                        strlen (instance_name) + 3;
-                *key_prefix = GF_CALLOC (key_len, sizeof (char),
-                        gf_common_mt_char);
-                if (!*key_prefix) {
-                        ret = -ENOMEM;
-                        goto err;
-                }
-                bytes_written = snprintf (*key_prefix, key_len, "%s.%s.%s",
-                        key_root, xlator_name, instance_name);
-                if (bytes_written != key_len - 1) {
-                        ret = -EINVAL;
-                        goto err;
-                }
-        } else {
-                /* +2 for 1 x "." + NULL */
-                key_len = strlen (key_root) + strlen (xlator_name) + 2;
-                *key_prefix = GF_CALLOC (key_len, sizeof (char),
-                        gf_common_mt_char);
-                if (!*key_prefix) {
-                        ret = -ENOMEM;
-                        goto err;
-                }
-                bytes_written = snprintf (*key_prefix, key_len, "%s.%s",
-                        key_root, xlator_name);
-                if (bytes_written != key_len - 1) {
-                        ret = -EINVAL;
-                        goto err;
-                }
+    } else {
+        /* +2 for 1 x "." + NULL */
+        key_len = strlen(key_root) + strlen(xlator_name) + 2;
+        *key_prefix = GF_CALLOC(key_len, sizeof(char), gf_common_mt_char);
+        if (!*key_prefix) {
+            ret = -ENOMEM;
+            goto err;
         }
-        return 0;
+        bytes_written = snprintf(*key_prefix, key_len, "%s.%s", key_root,
+                                 xlator_name);
+        if (bytes_written != key_len - 1) {
+            ret = -EINVAL;
+            goto err;
+        }
+    }
+    return 0;
 err:
-        GF_FREE (*key_prefix);
-        *key_prefix = NULL;
-        return ret;
+    GF_FREE(*key_prefix);
+    *key_prefix = NULL;
+    return ret;
 }
 
 int
-io_stats_dump_global_to_json_logfp (xlator_t *this,
-    struct ios_global_stats *stats, struct timeval *now, int interval,
-    FILE *logfp)
-{
-        int                   i = 0;
-        int                   j = 0;
-        struct ios_conf       *conf = NULL;
-        char                  *key_prefix = NULL;
-        char                  *str_prefix = NULL;
-        char                  *lc_fop_name = NULL;
-        int                   ret = 1;  /* Default to error */
-        int                   rw_size;
-        char                  *rw_unit = NULL;
-        uint64_t              fop_hits;
-        float                 fop_lat_ave;
-        float                 fop_lat_min;
-        float                 fop_lat_max;
-        double                interval_sec;
-        double                fop_ave_usec = 0.0;
-        double                fop_ave_usec_sum = 0.0;
-        double                weighted_fop_ave_usec = 0.0;
-        double                weighted_fop_ave_usec_sum = 0.0;
-        long                  total_fop_hits = 0;
-        loc_t                 unused_loc = {0, };
-        dict_t                *xattr = NULL;
-
-        interval_sec = ((now->tv_sec * 1000000.0 + now->tv_usec) -
-                (stats->started_at.tv_sec * 1000000.0 +
-                 stats->started_at.tv_usec)) / 1000000.0;
-
-        conf = this->private;
-
-        ret = _io_stats_get_key_prefix (this, &key_prefix);
-        if (ret) {
-                goto out;
+io_stats_dump_global_to_json_logfp(xlator_t *this,
+                                   struct ios_global_stats *stats,
+                                   struct timeval *now, int interval,
+                                   FILE *logfp)
+{
+    int i = 0;
+    int j = 0;
+    struct ios_conf *conf = NULL;
+    char *key_prefix = NULL;
+    char *str_prefix = NULL;
+    char *lc_fop_name = NULL;
+    int ret = 1; /* Default to error */
+    int rw_size;
+    char *rw_unit = NULL;
+    uint64_t fop_hits;
+    float fop_lat_ave;
+    float fop_lat_min;
+    float fop_lat_max;
+    double interval_sec;
+    double fop_ave_usec = 0.0;
+    double fop_ave_usec_sum = 0.0;
+    double weighted_fop_ave_usec = 0.0;
+    double weighted_fop_ave_usec_sum = 0.0;
+    long total_fop_hits = 0;
+    loc_t unused_loc = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    interval_sec = ((now->tv_sec * 1000000.0 + now->tv_usec) -
+                    (stats->started_at.tv_sec * 1000000.0 +
+                     stats->started_at.tv_usec)) /
+                   1000000.0;
+
+    conf = this->private;
+
+    ret = _io_stats_get_key_prefix(this, &key_prefix);
+    if (ret) {
+        goto out;
+    }
+
+    if (interval == -1) {
+        str_prefix = "aggr";
+
+    } else {
+        str_prefix = "inter";
+    }
+    ios_log(this, logfp, "{");
+
+    for (i = 0; i < 31; i++) {
+        rw_size = (1 << i);
+        if (rw_size >= 1024 * 1024) {
+            rw_size = rw_size / (1024 * 1024);
+            rw_unit = "mb";
+        } else if (rw_size >= 1024) {
+            rw_size = rw_size / 1024;
+            rw_unit = "kb";
+        } else {
+            rw_unit = "b";
         }
 
         if (interval == -1) {
-                str_prefix = "aggr";
-
+            ios_log(this, logfp, "\"%s.%s.read_%d%s\": \"%" GF_PRI_ATOMIC "\",",
+                    key_prefix, str_prefix, rw_size, rw_unit,
+                    GF_ATOMIC_GET(stats->block_count_read[i]));
+            ios_log(this, logfp,
+                    "\"%s.%s.write_%d%s\": \"%" GF_PRI_ATOMIC "\",", key_prefix,
+                    str_prefix, rw_size, rw_unit,
+                    GF_ATOMIC_GET(stats->block_count_write[i]));
         } else {
-                str_prefix = "inter";
+            ios_log(this, logfp, "\"%s.%s.read_%d%s_per_sec\": \"%0.2lf\",",
+                    key_prefix, str_prefix, rw_size, rw_unit,
+                    (double)(GF_ATOMIC_GET(stats->block_count_read[i]) /
+                             interval_sec));
+            ios_log(this, logfp, "\"%s.%s.write_%d%s_per_sec\": \"%0.2lf\",",
+                    key_prefix, str_prefix, rw_size, rw_unit,
+                    (double)(GF_ATOMIC_GET(stats->block_count_write[i]) /
+                             interval_sec));
         }
-        ios_log (this, logfp, "{");
-
-        for (i = 0; i < 31; i++) {
-                rw_size = (1 << i);
-                if (rw_size >= 1024 * 1024) {
-                        rw_size = rw_size / (1024 * 1024);
-                        rw_unit = "mb";
-                } else if (rw_size >= 1024) {
-                        rw_size = rw_size / 1024;
-                        rw_unit = "kb";
-                } else {
-                        rw_unit = "b";
-                }
-
-                if (interval == -1) {
-                        ios_log (this, logfp,
-                                "\"%s.%s.read_%d%s\": \"%"GF_PRI_ATOMIC"\",",
-                                key_prefix, str_prefix, rw_size, rw_unit,
-                                GF_ATOMIC_GET (stats->block_count_read[i]));
-                        ios_log (this, logfp,
-                                "\"%s.%s.write_%d%s\": \"%"GF_PRI_ATOMIC"\",",
-                                key_prefix, str_prefix, rw_size, rw_unit,
-                                GF_ATOMIC_GET (stats->block_count_write[i]));
-                } else {
-                        ios_log (this, logfp,
-                                "\"%s.%s.read_%d%s_per_sec\": \"%0.2lf\",",
-                                key_prefix, str_prefix, rw_size, rw_unit,
-                                (double)
-                                (GF_ATOMIC_GET (stats->block_count_read[i]) /
-                                 interval_sec));
-                        ios_log (this, logfp,
-                                "\"%s.%s.write_%d%s_per_sec\": \"%0.2lf\",",
-                                key_prefix, str_prefix, rw_size, rw_unit,
-                                (double)
-                                (GF_ATOMIC_GET (stats->block_count_write[i]) /
-                                 interval_sec));
-                }
+    }
+
+    if (interval == -1) {
+        ios_log(this, logfp, "\"%s.%s.fds.open_count\": \"%" PRId64 "\",",
+                key_prefix, str_prefix, conf->cumulative.nr_opens);
+        ios_log(this, logfp, "\"%s.%s.fds.max_open_count\": \"%" PRId64 "\",",
+                key_prefix, str_prefix, conf->cumulative.max_nr_opens);
+    }
+
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        lc_fop_name = strdupa(gf_fop_list[i]);
+        for (j = 0; lc_fop_name[j]; j++) {
+            lc_fop_name[j] = tolower(lc_fop_name[j]);
         }
 
-        if (interval == -1) {
-                ios_log (this, logfp, "\"%s.%s.fds.open_count\": \"%"PRId64
-                        "\",", key_prefix, str_prefix,
-                        conf->cumulative.nr_opens);
-                ios_log (this, logfp,
-                        "\"%s.%s.fds.max_open_count\": \"%"PRId64"\",",
-                        key_prefix, str_prefix, conf->cumulative.max_nr_opens);
+        fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]);
+        fop_lat_ave = 0.0;
+        fop_lat_min = 0.0;
+        fop_lat_max = 0.0;
+        if (fop_hits) {
+            if (stats->latency[i].avg) {
+                fop_lat_ave = stats->latency[i].avg;
+                fop_lat_min = stats->latency[i].min;
+                fop_lat_max = stats->latency[i].max;
+            }
         }
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                lc_fop_name = strdupa (gf_fop_list[i]);
-                for (j = 0; lc_fop_name[j]; j++) {
-                        lc_fop_name[j] = tolower (lc_fop_name[j]);
-                }
-
-                fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
-                fop_lat_ave = 0.0;
-                fop_lat_min = 0.0;
-                fop_lat_max = 0.0;
-                if (fop_hits) {
-                        if (stats->latency[i].avg) {
-                                fop_lat_ave = stats->latency[i].avg;
-                                fop_lat_min = stats->latency[i].min;
-                                fop_lat_max = stats->latency[i].max;
-                        }
-                }
-                if (interval == -1) {
-                        ios_log (this, logfp,
-                                "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",",
-                                key_prefix, str_prefix, lc_fop_name,
-                                fop_hits);
-                } else {
-                        ios_log (this, logfp,
-                                "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",",
-                                key_prefix, str_prefix, lc_fop_name,
-                                (double)(fop_hits / interval_sec));
-                }
-
-                ios_log (this, logfp,
-                        "\"%s.%s.fop.%s.latency_ave_usec\": \"%0.2lf\",",
-                         key_prefix, str_prefix, lc_fop_name, fop_lat_ave);
-                ios_log (this, logfp,
-                        "\"%s.%s.fop.%s.latency_min_usec\": \"%0.2lf\",",
-                         key_prefix, str_prefix, lc_fop_name, fop_lat_min);
-                ios_log (this, logfp,
-                        "\"%s.%s.fop.%s.latency_max_usec\": \"%0.2lf\",",
-                        key_prefix, str_prefix, lc_fop_name, fop_lat_max);
-
-                fop_ave_usec_sum += fop_lat_ave;
-                weighted_fop_ave_usec_sum += fop_hits * fop_lat_ave;
-                total_fop_hits += fop_hits;
+        if (interval == -1) {
+            ios_log(this, logfp,
+                    "\"%s.%s.fop.%s.count\": \"%" GF_PRI_ATOMIC "\",",
+                    key_prefix, str_prefix, lc_fop_name, fop_hits);
+        } else {
+            ios_log(this, logfp, "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",",
+                    key_prefix, str_prefix, lc_fop_name,
+                    (double)(fop_hits / interval_sec));
         }
 
-        if (total_fop_hits) {
-                weighted_fop_ave_usec =
-                        weighted_fop_ave_usec_sum/total_fop_hits;
-                /* Extra key that does not print out an entry w/ 0.00 for
-                 * intervals with no data
-                 */
-                ios_log (this, logfp,
-                         "\"%s.%s.fop.weighted_latency_ave_usec_nozerofill\": "
-                         "\"%0.4lf\",",
-                         key_prefix, str_prefix, weighted_fop_ave_usec);
-        }
-        ios_log (this, logfp,
-                 "\"%s.%s.fop.weighted_latency_ave_usec\": \"%0.4lf\",",
-                 key_prefix, str_prefix, weighted_fop_ave_usec);
-        ios_log (this, logfp,
-                 "\"%s.%s.fop.weighted_fop_count\": \"%ld\",",
-                 key_prefix, str_prefix, total_fop_hits);
-
-        fop_ave_usec = fop_ave_usec_sum/GF_FOP_MAXVALUE;
-        ios_log (this, logfp,
-                 "\"%s.%s.fop.unweighted_latency_ave_usec\":\"%0.4lf\",",
-                 key_prefix, str_prefix, fop_ave_usec);
-
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                lc_fop_name = strdupa (gf_upcall_list[i]);
-                for (j = 0; lc_fop_name[j]; j++) {
-                        lc_fop_name[j] = tolower (lc_fop_name[j]);
-                }
-                fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
-                if (interval == -1) {
-                        ios_log (this, logfp,
-                                "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",",
-                                key_prefix, str_prefix, lc_fop_name,
-                                fop_hits);
-                } else {
-                        ios_log (this, logfp,
-                                "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",",
-                                key_prefix, str_prefix, lc_fop_name,
-                                (double)(fop_hits / interval_sec));
-                }
+        ios_log(this, logfp, "\"%s.%s.fop.%s.latency_ave_usec\": \"%0.2lf\",",
+                key_prefix, str_prefix, lc_fop_name, fop_lat_ave);
+        ios_log(this, logfp, "\"%s.%s.fop.%s.latency_min_usec\": \"%0.2lf\",",
+                key_prefix, str_prefix, lc_fop_name, fop_lat_min);
+        ios_log(this, logfp, "\"%s.%s.fop.%s.latency_max_usec\": \"%0.2lf\",",
+                key_prefix, str_prefix, lc_fop_name, fop_lat_max);
+
+        fop_ave_usec_sum += fop_lat_ave;
+        weighted_fop_ave_usec_sum += fop_hits * fop_lat_ave;
+        total_fop_hits += fop_hits;
+    }
+
+    if (total_fop_hits) {
+        weighted_fop_ave_usec = weighted_fop_ave_usec_sum / total_fop_hits;
+        /* Extra key that does not print out an entry w/ 0.00 for
+         * intervals with no data
+         */
+        ios_log(this, logfp,
+                "\"%s.%s.fop.weighted_latency_ave_usec_nozerofill\": "
+                "\"%0.4lf\",",
+                key_prefix, str_prefix, weighted_fop_ave_usec);
+    }
+    ios_log(this, logfp, "\"%s.%s.fop.weighted_latency_ave_usec\": \"%0.4lf\",",
+            key_prefix, str_prefix, weighted_fop_ave_usec);
+    ios_log(this, logfp, "\"%s.%s.fop.weighted_fop_count\": \"%ld\",",
+            key_prefix, str_prefix, total_fop_hits);
+
+    fop_ave_usec = fop_ave_usec_sum / GF_FOP_MAXVALUE;
+    ios_log(this, logfp,
+            "\"%s.%s.fop.unweighted_latency_ave_usec\":\"%0.4lf\",", key_prefix,
+            str_prefix, fop_ave_usec);
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        lc_fop_name = strdupa(gf_upcall_list[i]);
+        for (j = 0; lc_fop_name[j]; j++) {
+            lc_fop_name[j] = tolower(lc_fop_name[j]);
         }
-
-        ret = syncop_getxattr (this, &unused_loc, &xattr,
-                               IO_THREADS_QUEUE_SIZE_KEY, NULL, NULL);
-        if (xattr) {
-                /*
-                 * Iterate over the dictionary returned to us by io-threads and
-                 * dump the results to the stats file.
-                 */
-                data_pair_t *curr = NULL;
-
-                dict_foreach_inline (xattr, curr) {
-                        ios_log (this, logfp,
-                                 "\"%s.%s.%s.queue_size\": \"%d\",",
-                                 key_prefix, str_prefix, curr->key,
-                                 data_to_int32 (curr->value));
-                }
-
-                /* Free the dictionary */
-                dict_unref (xattr);
+        fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]);
+        if (interval == -1) {
+            ios_log(this, logfp,
+                    "\"%s.%s.fop.%s.count\": \"%" GF_PRI_ATOMIC "\",",
+                    key_prefix, str_prefix, lc_fop_name, fop_hits);
         } else {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Unable to get queue size counts from "
-                        "the io-threads translator!");
+            ios_log(this, logfp, "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",",
+                    key_prefix, str_prefix, lc_fop_name,
+                    (double)(fop_hits / interval_sec));
         }
+    }
 
-        if (interval == -1) {
-                ios_log (this, logfp, "\"%s.%s.uptime\": \"%"PRId64"\",",
-                         key_prefix, str_prefix,
-                         (uint64_t) (now->tv_sec - stats->started_at.tv_sec));
-                ios_log (this, logfp, "\"%s.%s.bytes_read\": \""
-                         "%"GF_PRI_ATOMIC"\",", key_prefix, str_prefix,
-                         GF_ATOMIC_GET (stats->data_read));
-                ios_log (this, logfp, "\"%s.%s.bytes_written\": \""
-                         "%"GF_PRI_ATOMIC"\"", key_prefix, str_prefix,
-                         GF_ATOMIC_GET (stats->data_written));
-        } else {
-                ios_log (this, logfp,
-                         "\"%s.%s.sample_interval_sec\": \"%0.2lf\",",
-                         key_prefix, str_prefix,
-                         interval_sec);
-                ios_log (this, logfp,
-                         "\"%s.%s.bytes_read_per_sec\": \"%0.2lf\",",
-                         key_prefix, str_prefix, (double)
-                         (GF_ATOMIC_GET (stats->data_read) / interval_sec));
-                ios_log (this, logfp,
-                         "\"%s.%s.bytes_written_per_sec\": \"%0.2lf\"",
-                         key_prefix, str_prefix, (double)
-                         (GF_ATOMIC_GET (stats->data_written) / interval_sec));
+    ret = syncop_getxattr(this, &unused_loc, &xattr, IO_THREADS_QUEUE_SIZE_KEY,
+                          NULL, NULL);
+    if (xattr) {
+        /*
+         * Iterate over the dictionary returned to us by io-threads and
+         * dump the results to the stats file.
+         */
+        data_pair_t *curr = NULL;
+
+        dict_foreach_inline(xattr, curr)
+        {
+            ios_log(this, logfp, "\"%s.%s.%s.queue_size\": \"%d\",", key_prefix,
+                    str_prefix, curr->key, data_to_int32(curr->value));
         }
 
-        ios_log (this, logfp, "}");
-        ret = 0;
+        /* Free the dictionary */
+        dict_unref(xattr);
+    } else {
+        gf_log(this->name, GF_LOG_WARNING,
+               "Unable to get queue size counts from "
+               "the io-threads translator!");
+    }
+
+    if (interval == -1) {
+        ios_log(this, logfp, "\"%s.%s.uptime\": \"%" PRId64 "\",", key_prefix,
+                str_prefix, (uint64_t)(now->tv_sec - stats->started_at.tv_sec));
+        ios_log(this, logfp,
+                "\"%s.%s.bytes_read\": \""
+                "%" GF_PRI_ATOMIC "\",",
+                key_prefix, str_prefix, GF_ATOMIC_GET(stats->data_read));
+        ios_log(this, logfp,
+                "\"%s.%s.bytes_written\": \""
+                "%" GF_PRI_ATOMIC "\"",
+                key_prefix, str_prefix, GF_ATOMIC_GET(stats->data_written));
+    } else {
+        ios_log(this, logfp, "\"%s.%s.sample_interval_sec\": \"%0.2lf\",",
+                key_prefix, str_prefix, interval_sec);
+        ios_log(this, logfp, "\"%s.%s.bytes_read_per_sec\": \"%0.2lf\",",
+                key_prefix, str_prefix,
+                (double)(GF_ATOMIC_GET(stats->data_read) / interval_sec));
+        ios_log(this, logfp, "\"%s.%s.bytes_written_per_sec\": \"%0.2lf\"",
+                key_prefix, str_prefix,
+                (double)(GF_ATOMIC_GET(stats->data_written) / interval_sec));
+    }
+
+    ios_log(this, logfp, "}");
+    ret = 0;
 out:
-        GF_FREE (key_prefix);
-        return ret;
+    GF_FREE(key_prefix);
+    return ret;
 }
 
 char *
-_resolve_username (xlator_t *this, uid_t uid)
+_resolve_username(xlator_t *this, uid_t uid)
 {
-        struct passwd pwd;
-        struct passwd *pwd_result = NULL;
-        size_t pwd_buf_len;
-        char   *pwd_buf = NULL;
-        char   *ret = NULL;
+    struct passwd pwd;
+    struct passwd *pwd_result = NULL;
+    size_t pwd_buf_len;
+    char *pwd_buf = NULL;
+    char *ret = NULL;
 
-        /* Prepare our buffer for the uid->username translation */
+    /* Prepare our buffer for the uid->username translation */
 #ifdef _SC_GETGR_R_SIZE_MAX
-        pwd_buf_len = sysconf (_SC_GETGR_R_SIZE_MAX);
+    pwd_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX);
 #else
-        pwd_buf_len = -1;
+    pwd_buf_len = -1;
 #endif
-        if (pwd_buf_len == -1) {
-                pwd_buf_len = DEFAULT_PWD_BUF_SZ;  /* per the man page */
-        }
+    if (pwd_buf_len == -1) {
+        pwd_buf_len = DEFAULT_PWD_BUF_SZ; /* per the man page */
+    }
 
-        pwd_buf = alloca (pwd_buf_len);
-        if (!pwd_buf)
-                goto err;
+    pwd_buf = alloca(pwd_buf_len);
+    if (!pwd_buf)
+        goto err;
 
-        getpwuid_r (uid, &pwd, pwd_buf, pwd_buf_len,
-                   &pwd_result);
-        if (!pwd_result)
-                goto err;
+    getpwuid_r(uid, &pwd, pwd_buf, pwd_buf_len, &pwd_result);
+    if (!pwd_result)
+        goto err;
 
-        ret = gf_strdup (pwd.pw_name);
-        if (ret)
-                return ret;
-        else
-                gf_log (this->name, GF_LOG_ERROR,
-                        "gf_strdup failed, failing username "
-                        "resolution.");
-err:
+    ret = gf_strdup(pwd.pw_name);
+    if (ret)
         return ret;
+    else
+        gf_log(this->name, GF_LOG_ERROR,
+               "gf_strdup failed, failing username "
+               "resolution.");
+err:
+    return ret;
 }
 
 char *
-_resolve_group_name (xlator_t *this, gid_t gid)
+_resolve_group_name(xlator_t *this, gid_t gid)
 {
-        struct group grp;
-        struct group *grp_result = NULL;
-        size_t grp_buf_len;
-        char   *grp_buf = NULL;
-        char   *ret = NULL;
+    struct group grp;
+    struct group *grp_result = NULL;
+    size_t grp_buf_len;
+    char *grp_buf = NULL;
+    char *ret = NULL;
 
-        /* Prepare our buffer for the gid->group name translation */
+    /* Prepare our buffer for the gid->group name translation */
 #ifdef _SC_GETGR_R_SIZE_MAX
-        grp_buf_len = sysconf (_SC_GETGR_R_SIZE_MAX);
+    grp_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX);
 #else
-        grp_buf_len = -1;
+    grp_buf_len = -1;
 #endif
-        if (grp_buf_len == -1) {
-                grp_buf_len = DEFAULT_GRP_BUF_SZ;  /* per the man page */
-        }
+    if (grp_buf_len == -1) {
+        grp_buf_len = DEFAULT_GRP_BUF_SZ; /* per the man page */
+    }
 
-        grp_buf = alloca (grp_buf_len);
-        if (!grp_buf) {
-                goto err;
-        }
+    grp_buf = alloca(grp_buf_len);
+    if (!grp_buf) {
+        goto err;
+    }
 
-        if (getgrgid_r (gid, &grp, grp_buf, grp_buf_len, &grp_result) != 0)
-                goto err;
+    if (getgrgid_r(gid, &grp, grp_buf, grp_buf_len, &grp_result) != 0)
+        goto err;
 
-        if (!grp_result)
-                goto err;
+    if (!grp_result)
+        goto err;
 
-        ret = gf_strdup (grp.gr_name);
-        if (ret)
-                return ret;
-        else
-                gf_log (this->name, GF_LOG_ERROR,
-                        "gf_strdup failed, failing username "
-                        "resolution.");
-err:
+    ret = gf_strdup(grp.gr_name);
+    if (ret)
         return ret;
+    else
+        gf_log(this->name, GF_LOG_ERROR,
+               "gf_strdup failed, failing username "
+               "resolution.");
+err:
+    return ret;
 }
 
-
 /*
  * This function writes out a latency sample to a given file descriptor
  * and beautifies the output in the process.
  */
 void
-_io_stats_write_latency_sample (xlator_t *this, ios_sample_t *sample,
-                                FILE *logfp)
-{
-        double epoch_time = 0.00;
-        char   *xlator_name = NULL;
-        char   *instance_name = NULL;
-        char   *hostname = NULL;
-        char   *identifier = NULL;
-        char   *port = NULL;
-        char   *port_pos = NULL;
-        char   *group_name = NULL;
-        char   *username = NULL;
-        struct ios_conf *conf = NULL;
-
-        conf = this->private;
-
-        epoch_time = (sample->timestamp).tv_sec +
-          ((sample->timestamp).tv_usec / 1000000.0);
-
-        if (strlen (sample->identifier) == 0) {
-                hostname = "Unknown";
-                port = "Unknown";
-        } else {
-                identifier = strdupa (sample->identifier);
-                port_pos = strrchr (identifier, ':');
-                if (!port_pos || strlen(port_pos) < 2)
-                        goto err;
-                port = strdupa (port_pos + 1);
-                if (!port)
-                        goto err;
-                *port_pos = '\0';
-                hostname = gf_rev_dns_lookup_cached (identifier,
-                                                     conf->dnscache);
-                if (!hostname)
-                        hostname = "Unknown";
-        }
-
-        xlator_name = conf->unique_id;
-        if (!xlator_name || strlen (xlator_name) == 0)
-                xlator_name = "Unknown";
-
-        instance_name = this->instance_name;
-        if (!instance_name || strlen (instance_name) == 0)
-                instance_name = "N/A";
-
-        /* Resolve the UID to a string username */
-        username = _resolve_username (this, sample->uid);
+_io_stats_write_latency_sample(xlator_t *this, ios_sample_t *sample,
+                               FILE *logfp)
+{
+    double epoch_time = 0.00;
+    char *xlator_name = NULL;
+    char *instance_name = NULL;
+    char *hostname = NULL;
+    char *identifier = NULL;
+    char *port = NULL;
+    char *port_pos = NULL;
+    char *group_name = NULL;
+    char *username = NULL;
+    struct ios_conf *conf = NULL;
+
+    conf = this->private;
+
+    epoch_time = (sample->timestamp).tv_sec +
+                 ((sample->timestamp).tv_usec / 1000000.0);
+
+    if (strlen(sample->identifier) == 0) {
+        hostname = "Unknown";
+        port = "Unknown";
+    } else {
+        identifier = strdupa(sample->identifier);
+        port_pos = strrchr(identifier, ':');
+        if (!port_pos || strlen(port_pos) < 2)
+            goto err;
+        port = strdupa(port_pos + 1);
+        if (!port)
+            goto err;
+        *port_pos = '\0';
+        hostname = gf_rev_dns_lookup_cached(identifier, conf->dnscache);
+        if (!hostname)
+            hostname = "Unknown";
+    }
+
+    xlator_name = conf->unique_id;
+    if (!xlator_name || strlen(xlator_name) == 0)
+        xlator_name = "Unknown";
+
+    instance_name = this->instance_name;
+    if (!instance_name || strlen(instance_name) == 0)
+        instance_name = "N/A";
+
+    /* Resolve the UID to a string username */
+    username = _resolve_username(this, sample->uid);
+    if (!username) {
+        username = GF_MALLOC(30, gf_common_mt_char);
         if (!username) {
-                username = GF_MALLOC (30, gf_common_mt_char);
-                if (!username) {
-                        goto out;
-                }
-                sprintf (username, "%d", (int32_t)sample->uid);
+            goto out;
         }
+        sprintf(username, "%d", (int32_t)sample->uid);
+    }
 
-        /* Resolve the GID to a string group name */
-        group_name = _resolve_group_name (this, sample->gid);
+    /* Resolve the GID to a string group name */
+    group_name = _resolve_group_name(this, sample->gid);
+    if (!group_name) {
+        group_name = GF_MALLOC(30, gf_common_mt_char);
         if (!group_name) {
-                group_name = GF_MALLOC (30, gf_common_mt_char);
-                if (!group_name) {
-                        goto out;
-                }
-                sprintf (group_name, "%d", (int32_t)sample->gid);
+            goto out;
         }
-
-        ios_log (this, logfp,
-                 "%0.6lf,%s,%s,%0.4lf,%s,%s,%s,%s,%s,%s",
-                 epoch_time, fop_enum_to_pri_string (sample->fop_type),
-                 gf_fop_string (sample->fop_type),
-                 sample->elapsed, xlator_name, instance_name, username,
-                 group_name, hostname, port);
-        goto out;
+        sprintf(group_name, "%d", (int32_t)sample->gid);
+    }
+
+    ios_log(this, logfp, "%0.6lf,%s,%s,%0.4lf,%s,%s,%s,%s,%s,%s", epoch_time,
+            fop_enum_to_pri_string(sample->fop_type),
+            gf_fop_string(sample->fop_type), sample->elapsed, xlator_name,
+            instance_name, username, group_name, hostname, port);
+    goto out;
 err:
-        gf_log (this->name, GF_LOG_ERROR,
-                "Error parsing socket identifier");
+    gf_log(this->name, GF_LOG_ERROR, "Error parsing socket identifier");
 out:
-        GF_FREE (group_name);
-        GF_FREE (username);
+    GF_FREE(group_name);
+    GF_FREE(username);
 }
 
 /*
@@ -1183,3424 +1139,3210 @@ out:
  * contents of the saved reference.
  */
 int
-io_stats_dump_latency_samples_logfp (xlator_t *this, FILE *logfp)
-{
-        uint64_t              i = 0;
-        struct ios_conf       *conf = NULL;
-        ios_sample_buf_t      *sample_buf = NULL;
-        int                   ret = 1;  /* Default to error */
-
-        conf = this->private;
-
-        /* Save pointer to old buffer; the CS equivalent of
-         * Indiana Jones: https://www.youtube.com/watch?v=Pr-8AP0To4k,
-         * though ours will end better I hope!
-         */
-        sample_buf = conf->ios_sample_buf;
-        if (!sample_buf) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Sampling buffer is null, bailing!");
-                goto out;
-        }
-
-        /* Empty case, nothing to do, exit. */
-        if (sample_buf->collected == 0) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "No samples, dump not required.");
-                ret = 0;
-                goto out;
-        }
-
-        /* Init a new buffer, so we are free to work on the one we saved a
-         * reference to above.
-         */
-        if (ios_init_sample_buf (conf) != 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Failed to init new sampling buffer, out of memory?");
-                goto out;
-        }
+io_stats_dump_latency_samples_logfp(xlator_t *this, FILE *logfp)
+{
+    uint64_t i = 0;
+    struct ios_conf *conf = NULL;
+    ios_sample_buf_t *sample_buf = NULL;
+    int ret = 1; /* Default to error */
+
+    conf = this->private;
+
+    /* Save pointer to old buffer; the CS equivalent of
+     * Indiana Jones: https://www.youtube.com/watch?v=Pr-8AP0To4k,
+     * though ours will end better I hope!
+     */
+    sample_buf = conf->ios_sample_buf;
+    if (!sample_buf) {
+        gf_log(this->name, GF_LOG_WARNING, "Sampling buffer is null, bailing!");
+        goto out;
+    }
 
-        /* Wrap-around case, dump from pos to sample_buf->size -1
-         * and then from 0 to sample_buf->pos (covered off by
-         * "simple case")
-         */
-        if (sample_buf->collected > sample_buf->pos + 1) {
-                for (i = sample_buf->pos; i < sample_buf->size; i++) {
-                        _io_stats_write_latency_sample (this,
-                                &(sample_buf->ios_samples[i]), logfp);
-                }
+    /* Empty case, nothing to do, exit. */
+    if (sample_buf->collected == 0) {
+        gf_log(this->name, GF_LOG_DEBUG, "No samples, dump not required.");
+        ret = 0;
+        goto out;
+    }
+
+    /* Init a new buffer, so we are free to work on the one we saved a
+     * reference to above.
+     */
+    if (ios_init_sample_buf(conf) != 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "Failed to init new sampling buffer, out of memory?");
+        goto out;
+    }
+
+    /* Wrap-around case, dump from pos to sample_buf->size -1
+     * and then from 0 to sample_buf->pos (covered off by
+     * "simple case")
+     */
+    if (sample_buf->collected > sample_buf->pos + 1) {
+        for (i = sample_buf->pos; i < sample_buf->size; i++) {
+            _io_stats_write_latency_sample(this, &(sample_buf->ios_samples[i]),
+                                           logfp);
         }
+    }
 
-        /* Simple case: Dump from 0 to sample_buf->pos */
-        for (i = 0; i < sample_buf->pos; i++) {
-                _io_stats_write_latency_sample (this,
-                        &(sample_buf->ios_samples[i]), logfp);
-        }
-        ios_destroy_sample_buf (sample_buf);
+    /* Simple case: Dump from 0 to sample_buf->pos */
+    for (i = 0; i < sample_buf->pos; i++) {
+        _io_stats_write_latency_sample(this, &(sample_buf->ios_samples[i]),
+                                       logfp);
+    }
+    ios_destroy_sample_buf(sample_buf);
 
 out:
-        return ret;
+    return ret;
 }
 
 int
-io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats,
-                               struct timeval *now, int interval, FILE *logfp)
-{
-        int                   i = 0;
-        int                   per_line = 0;
-        int                   index = 0;
-        struct ios_stat_head *list_head = NULL;
-        struct ios_conf      *conf = NULL;
-        char                  timestr[256] = {0, };
-        char                  str_header[128] = {0};
-        char                  str_read[128] = {0};
-        char                  str_write[128] = {0};
-        uint64_t              fop_hits = 0;
-        uint64_t              block_count_read = 0;
-        uint64_t              block_count_write = 0;
-
-        conf = this->private;
-
-        if (interval == -1)
-                ios_log (this, logfp, "\n=== Cumulative stats ===");
+io_stats_dump_global_to_logfp(xlator_t *this, struct ios_global_stats *stats,
+                              struct timeval *now, int interval, FILE *logfp)
+{
+    int i = 0;
+    int per_line = 0;
+    int index = 0;
+    struct ios_stat_head *list_head = NULL;
+    struct ios_conf *conf = NULL;
+    char timestr[256] = {
+        0,
+    };
+    char str_header[128] = {0};
+    char str_read[128] = {0};
+    char str_write[128] = {0};
+    uint64_t fop_hits = 0;
+    uint64_t block_count_read = 0;
+    uint64_t block_count_write = 0;
+
+    conf = this->private;
+
+    if (interval == -1)
+        ios_log(this, logfp, "\n=== Cumulative stats ===");
+    else
+        ios_log(this, logfp, "\n=== Interval %d stats ===", interval);
+    ios_log(this, logfp, "      Duration : %" PRId64 " secs",
+            (uint64_t)(now->tv_sec - stats->started_at.tv_sec));
+    ios_log(this, logfp, "     BytesRead : %" GF_PRI_ATOMIC,
+            GF_ATOMIC_GET(stats->data_read));
+    ios_log(this, logfp, "  BytesWritten : %" GF_PRI_ATOMIC "\n",
+            GF_ATOMIC_GET(stats->data_written));
+
+    snprintf(str_header, sizeof(str_header), "%-12s %c", "Block Size", ':');
+    snprintf(str_read, sizeof(str_read), "%-12s %c", "Read Count", ':');
+    snprintf(str_write, sizeof(str_write), "%-12s %c", "Write Count", ':');
+    index = 14;
+    for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+        block_count_read = GF_ATOMIC_GET(stats->block_count_read[i]);
+        block_count_write = GF_ATOMIC_GET(stats->block_count_write[i]);
+        if ((block_count_read == 0) && (block_count_write == 0))
+            continue;
+        per_line++;
+
+        snprintf(str_header + index, sizeof(str_header) - index, "%16dB+",
+                 (1 << i));
+        if (block_count_read)
+            snprintf(str_read + index, sizeof(str_read) - index, "%18" PRId64,
+                     block_count_read);
         else
-                ios_log (this, logfp, "\n=== Interval %d stats ===",
-                         interval);
-        ios_log (this, logfp, "      Duration : %"PRId64" secs",
-                 (uint64_t) (now->tv_sec - stats->started_at.tv_sec));
-        ios_log (this, logfp, "     BytesRead : %"GF_PRI_ATOMIC,
-                 GF_ATOMIC_GET (stats->data_read));
-        ios_log (this, logfp, "  BytesWritten : %"GF_PRI_ATOMIC"\n",
-                 GF_ATOMIC_GET (stats->data_written));
-
-        snprintf (str_header, sizeof (str_header), "%-12s %c", "Block Size", ':');
-        snprintf (str_read, sizeof (str_read), "%-12s %c", "Read Count", ':');
-        snprintf (str_write, sizeof (str_write), "%-12s %c", "Write Count", ':');
-        index = 14;
-        for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
-                block_count_read = GF_ATOMIC_GET (stats->block_count_read[i]);
-                block_count_write = GF_ATOMIC_GET (stats->block_count_write[i]);
-                if ((block_count_read == 0) && (block_count_write == 0))
-                        continue;
-                per_line++;
-
-                snprintf (str_header+index, sizeof (str_header)-index,
-                          "%16dB+", (1<<i));
-                if (block_count_read)
-                        snprintf (str_read+index, sizeof (str_read)-index,
-                                  "%18"PRId64, block_count_read);
-                else    snprintf (str_read+index, sizeof (str_read)-index,
-                                  "%18s", "0");
-                if (block_count_write)
-                        snprintf (str_write+index, sizeof (str_write)-index,
-                                  "%18"GF_PRI_ATOMIC, block_count_write);
-                else    snprintf (str_write+index, sizeof (str_write)-index,
-                                  "%18s", "0");
-
-                index += 18;
-                if (per_line == 3) {
-                        ios_log (this, logfp, "%s", str_header);
-                        ios_log (this, logfp, "%s", str_read);
-                        ios_log (this, logfp, "%s\n", str_write);
-
-                        snprintf (str_header, sizeof (str_header), "%-12s %c",
-                                  "Block Size", ':');
-                        snprintf (str_read, sizeof (str_read), "%-12s %c",
-                                  "Read Count", ':');
-                        snprintf (str_write, sizeof (str_write), "%-12s %c",
-                                  "Write Count", ':');
-
-                        index = 14;
-                        per_line = 0;
-                }
-        }
-
-        if (per_line != 0) {
-                ios_log (this, logfp, "%s", str_header);
-                ios_log (this, logfp, "%s", str_read);
-                ios_log (this, logfp, "%s\n", str_write);
-        }
-
-        ios_log (this, logfp, "%-13s %10s %14s %14s %14s", "Fop",
-                 "Call Count", "Avg-Latency", "Min-Latency",
-                 "Max-Latency");
-        ios_log (this, logfp, "%-13s %10s %14s %14s %14s", "---", "----------",
-                 "-----------", "-----------", "-----------");
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
-                if (fop_hits && !stats->latency[i].avg)
-                        ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" %11s "
-                                 "us %11s us %11s us", gf_fop_list[i],
-                                 fop_hits, "0", "0", "0");
-                else if (fop_hits && stats->latency[i].avg)
-                        ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" "
-                                 "%11.2lf us %11.2lf us %11.2lf us",
-                                 gf_fop_list[i], fop_hits,
-                                 stats->latency[i].avg, stats->latency[i].min,
-                                 stats->latency[i].max);
-        }
-
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
-                if (fop_hits)
-                        ios_log (this, logfp, "%-13s %10"PRId64" %11s "
-                                 "us %11s us %11s us", gf_upcall_list[i],
-                                 fop_hits, "0", "0", "0");
+            snprintf(str_read + index, sizeof(str_read) - index, "%18s", "0");
+        if (block_count_write)
+            snprintf(str_write + index, sizeof(str_write) - index,
+                     "%18" GF_PRI_ATOMIC, block_count_write);
+        else
+            snprintf(str_write + index, sizeof(str_write) - index, "%18s", "0");
+
+        index += 18;
+        if (per_line == 3) {
+            ios_log(this, logfp, "%s", str_header);
+            ios_log(this, logfp, "%s", str_read);
+            ios_log(this, logfp, "%s\n", str_write);
+
+            snprintf(str_header, sizeof(str_header), "%-12s %c", "Block Size",
+                     ':');
+            snprintf(str_read, sizeof(str_read), "%-12s %c", "Read Count", ':');
+            snprintf(str_write, sizeof(str_write), "%-12s %c", "Write Count",
+                     ':');
+
+            index = 14;
+            per_line = 0;
         }
-
-        ios_log (this, logfp, "------ ----- ----- ----- ----- ----- ----- ----- "
-                 " ----- ----- ----- -----\n");
-
-        if (interval == -1) {
-                LOCK (&conf->lock);
-                {
-                        gf_time_fmt (timestr, sizeof timestr,
-                                     conf->cumulative.max_openfd_time.tv_sec,
-                                     gf_timefmt_FT);
-                        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                                  ".%"GF_PRI_SUSECONDS,
-                                  conf->cumulative.max_openfd_time.tv_usec);
-                        ios_log (this, logfp, "Current open fd's: %"PRId64
-                                 " Max open fd's: %"PRId64" time %s",
-                                 conf->cumulative.nr_opens,
-                                 conf->cumulative.max_nr_opens, timestr);
-                }
-                UNLOCK (&conf->lock);
-                ios_log (this, logfp, "\n==========Open File Stats========");
-                ios_log (this, logfp, "\nCOUNT:  \t  FILE NAME");
-                list_head = &conf->list[IOS_STATS_TYPE_OPEN];
-                ios_dump_file_stats (list_head, this, logfp);
-
-
-                ios_log (this, logfp, "\n==========Read File Stats========");
-                ios_log (this, logfp, "\nCOUNT:  \t  FILE NAME");
-                list_head = &conf->list[IOS_STATS_TYPE_READ];
-                ios_dump_file_stats (list_head, this, logfp);
-
-                ios_log (this, logfp, "\n==========Write File Stats========");
-                ios_log (this, logfp, "\nCOUNT:  \t  FILE NAME");
-                list_head = &conf->list[IOS_STATS_TYPE_WRITE];
-                ios_dump_file_stats (list_head, this, logfp);
-
-                ios_log (this, logfp, "\n==========Directory open stats========");
-                ios_log (this, logfp, "\nCOUNT:  \t  DIRECTORY NAME");
-                list_head = &conf->list[IOS_STATS_TYPE_OPENDIR];
-                ios_dump_file_stats (list_head, this, logfp);
-
-                ios_log (this, logfp, "\n========Directory readdirp Stats=======");
-                ios_log (this, logfp, "\nCOUNT:  \t  DIRECTORY NAME");
-                list_head = &conf->list[IOS_STATS_TYPE_READDIRP];
-                ios_dump_file_stats (list_head, this, logfp);
-
-                ios_log (this, logfp, "\n========Read Throughput File Stats=====");
-                ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)"
-                         "\tFILE NAME");
-                list_head = &conf->thru_list[IOS_STATS_THRU_READ];
-                ios_dump_throughput_stats(list_head, this, logfp,
-                                          IOS_STATS_THRU_READ);
-
-                ios_log (this, logfp, "\n======Write Throughput File Stats======");
-                ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)"
-                         "\tFILE NAME");
-                list_head = &conf->thru_list[IOS_STATS_THRU_WRITE];
-                ios_dump_throughput_stats (list_head, this, logfp,
-                                           IOS_STATS_THRU_WRITE);
+    }
+
+    if (per_line != 0) {
+        ios_log(this, logfp, "%s", str_header);
+        ios_log(this, logfp, "%s", str_read);
+        ios_log(this, logfp, "%s\n", str_write);
+    }
+
+    ios_log(this, logfp, "%-13s %10s %14s %14s %14s", "Fop", "Call Count",
+            "Avg-Latency", "Min-Latency", "Max-Latency");
+    ios_log(this, logfp, "%-13s %10s %14s %14s %14s", "---", "----------",
+            "-----------", "-----------", "-----------");
+
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]);
+        if (fop_hits && !stats->latency[i].avg)
+            ios_log(this, logfp,
+                    "%-13s %10" GF_PRI_ATOMIC
+                    " %11s "
+                    "us %11s us %11s us",
+                    gf_fop_list[i], fop_hits, "0", "0", "0");
+        else if (fop_hits && stats->latency[i].avg)
+            ios_log(this, logfp,
+                    "%-13s %10" GF_PRI_ATOMIC
+                    " "
+                    "%11.2lf us %11.2lf us %11.2lf us",
+                    gf_fop_list[i], fop_hits, stats->latency[i].avg,
+                    stats->latency[i].min, stats->latency[i].max);
+    }
+
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]);
+        if (fop_hits)
+            ios_log(this, logfp,
+                    "%-13s %10" PRId64
+                    " %11s "
+                    "us %11s us %11s us",
+                    gf_upcall_list[i], fop_hits, "0", "0", "0");
+    }
+
+    ios_log(this, logfp,
+            "------ ----- ----- ----- ----- ----- ----- ----- "
+            " ----- ----- ----- -----\n");
+
+    if (interval == -1) {
+        LOCK(&conf->lock);
+        {
+            gf_time_fmt(timestr, sizeof timestr,
+                        conf->cumulative.max_openfd_time.tv_sec, gf_timefmt_FT);
+            snprintf(timestr + strlen(timestr),
+                     sizeof timestr - strlen(timestr), ".%" GF_PRI_SUSECONDS,
+                     conf->cumulative.max_openfd_time.tv_usec);
+            ios_log(this, logfp,
+                    "Current open fd's: %" PRId64 " Max open fd's: %" PRId64
+                    " time %s",
+                    conf->cumulative.nr_opens, conf->cumulative.max_nr_opens,
+                    timestr);
         }
-        return 0;
+        UNLOCK(&conf->lock);
+        ios_log(this, logfp, "\n==========Open File Stats========");
+        ios_log(this, logfp, "\nCOUNT:  \t  FILE NAME");
+        list_head = &conf->list[IOS_STATS_TYPE_OPEN];
+        ios_dump_file_stats(list_head, this, logfp);
+
+        ios_log(this, logfp, "\n==========Read File Stats========");
+        ios_log(this, logfp, "\nCOUNT:  \t  FILE NAME");
+        list_head = &conf->list[IOS_STATS_TYPE_READ];
+        ios_dump_file_stats(list_head, this, logfp);
+
+        ios_log(this, logfp, "\n==========Write File Stats========");
+        ios_log(this, logfp, "\nCOUNT:  \t  FILE NAME");
+        list_head = &conf->list[IOS_STATS_TYPE_WRITE];
+        ios_dump_file_stats(list_head, this, logfp);
+
+        ios_log(this, logfp, "\n==========Directory open stats========");
+        ios_log(this, logfp, "\nCOUNT:  \t  DIRECTORY NAME");
+        list_head = &conf->list[IOS_STATS_TYPE_OPENDIR];
+        ios_dump_file_stats(list_head, this, logfp);
+
+        ios_log(this, logfp, "\n========Directory readdirp Stats=======");
+        ios_log(this, logfp, "\nCOUNT:  \t  DIRECTORY NAME");
+        list_head = &conf->list[IOS_STATS_TYPE_READDIRP];
+        ios_dump_file_stats(list_head, this, logfp);
+
+        ios_log(this, logfp, "\n========Read Throughput File Stats=====");
+        ios_log(this, logfp,
+                "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)"
+                "\tFILE NAME");
+        list_head = &conf->thru_list[IOS_STATS_THRU_READ];
+        ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_READ);
+
+        ios_log(this, logfp, "\n======Write Throughput File Stats======");
+        ios_log(this, logfp,
+                "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)"
+                "\tFILE NAME");
+        list_head = &conf->thru_list[IOS_STATS_THRU_WRITE];
+        ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_WRITE);
+    }
+    return 0;
 }
 
 int
-io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
-                              struct timeval *now, int interval, dict_t *dict)
-{
-        int             ret = 0;
-        char            key[256] = {0};
-        uint64_t        sec = 0;
-        int             i = 0;
-        uint64_t        count = 0;
-        uint64_t        fop_hits = 0;
-
-        GF_ASSERT (stats);
-        GF_ASSERT (now);
-        GF_ASSERT (dict);
-        GF_ASSERT (this);
-
-        if (interval == -1)
-                snprintf (key, sizeof (key), "cumulative");
-        else
-                snprintf (key, sizeof (key), "interval");
-        ret = dict_set_int32 (dict, key, interval);
-        if (ret)
-                gf_log (this->name, GF_LOG_ERROR, "failed to set "
-                        "interval %d", interval);
-
-        snprintf (key, sizeof (key), "%d-duration", interval);
-        sec = (uint64_t) (now->tv_sec - stats->started_at.tv_sec);
-        ret = dict_set_uint64 (dict, key, sec);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "failed to set "
-                        "duration(%d) - %"PRId64, interval, sec);
+io_stats_dump_global_to_dict(xlator_t *this, struct ios_global_stats *stats,
+                             struct timeval *now, int interval, dict_t *dict)
+{
+    int ret = 0;
+    char key[256] = {0};
+    uint64_t sec = 0;
+    int i = 0;
+    uint64_t count = 0;
+    uint64_t fop_hits = 0;
+
+    GF_ASSERT(stats);
+    GF_ASSERT(now);
+    GF_ASSERT(dict);
+    GF_ASSERT(this);
+
+    if (interval == -1)
+        snprintf(key, sizeof(key), "cumulative");
+    else
+        snprintf(key, sizeof(key), "interval");
+    ret = dict_set_int32(dict, key, interval);
+    if (ret)
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set "
+               "interval %d",
+               interval);
+
+    snprintf(key, sizeof(key), "%d-duration", interval);
+    sec = (uint64_t)(now->tv_sec - stats->started_at.tv_sec);
+    ret = dict_set_uint64(dict, key, sec);
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set "
+               "duration(%d) - %" PRId64,
+               interval, sec);
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "%d-total-read", interval);
+    ret = dict_set_uint64(dict, key, GF_ATOMIC_GET(stats->data_read));
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set total "
+               "read(%d) - %" GF_PRI_ATOMIC,
+               interval, GF_ATOMIC_GET(stats->data_read));
+        goto out;
+    }
+
+    snprintf(key, sizeof(key), "%d-total-write", interval);
+    ret = dict_set_uint64(dict, key, GF_ATOMIC_GET(stats->data_written));
+    if (ret) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "failed to set total "
+               "write(%d) - %" GF_PRI_ATOMIC,
+               interval, GF_ATOMIC_GET(stats->data_written));
+        goto out;
+    }
+    for (i = 0; i < 32; i++) {
+        count = GF_ATOMIC_GET(stats->block_count_read[i]);
+        if (count) {
+            snprintf(key, sizeof(key), "%d-read-%d", interval, (1 << i));
+            ret = dict_set_uint64(dict, key, count);
+            if (ret) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to "
+                       "set read-%db+, with: %" PRId64,
+                       (1 << i), count);
                 goto out;
+            }
         }
-
-        snprintf (key, sizeof (key), "%d-total-read", interval);
-        ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_read));
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "failed to set total "
-                       "read(%d) - %"GF_PRI_ATOMIC, interval,
-                       GF_ATOMIC_GET (stats->data_read));
+    }
+
+    for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+        count = GF_ATOMIC_GET(stats->block_count_write[i]);
+        if (count) {
+            snprintf(key, sizeof(key), "%d-write-%d", interval, (1 << i));
+            ret = dict_set_uint64(dict, key, count);
+            if (ret) {
+                gf_log(this->name, GF_LOG_ERROR,
+                       "failed to "
+                       "set write-%db+, with: %" PRId64,
+                       (1 << i), count);
                 goto out;
+            }
         }
-
-        snprintf (key, sizeof (key), "%d-total-write", interval);
-        ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_written));
+    }
+
+    for (i = 0; i < GF_FOP_MAXVALUE; i++) {
+        fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]);
+        if (fop_hits == 0)
+            continue;
+        snprintf(key, sizeof(key), "%d-%d-hits", interval, i);
+        ret = dict_set_uint64(dict, key, fop_hits);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "failed to set total "
-                        "write(%d) - %"GF_PRI_ATOMIC, interval,
-                        GF_ATOMIC_GET (stats->data_written));
-                goto out;
-        }
-        for (i = 0; i < 32; i++) {
-                count = GF_ATOMIC_GET (stats->block_count_read[i]);
-                if (count) {
-                        snprintf (key, sizeof (key), "%d-read-%d", interval,
-                                  (1 << i));
-                        ret = dict_set_uint64 (dict, key, count);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR, "failed to "
-                                        "set read-%db+, with: %"PRId64,
-                                        (1<<i), count);
-                                goto out;
-                        }
-                }
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set "
+                   "%s-fop-hits: %" GF_PRI_ATOMIC,
+                   gf_fop_list[i], fop_hits);
+            goto out;
         }
 
-        for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
-                count = GF_ATOMIC_GET (stats->block_count_write[i]);
-                if (count) {
-                        snprintf (key, sizeof (key), "%d-write-%d", interval,
-                                  (1<<i));
-                        ret = dict_set_uint64 (dict, key, count);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR, "failed to "
-                                        "set write-%db+, with: %"PRId64,
-                                        (1<<i), count);
-                                goto out;
-                        }
-                }
+        if (stats->latency[i].avg == 0)
+            continue;
+        snprintf(key, sizeof(key), "%d-%d-avglatency", interval, i);
+        ret = dict_set_double(dict, key, stats->latency[i].avg);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set %s "
+                   "avglatency(%d) with %f",
+                   gf_fop_list[i], interval, stats->latency[i].avg);
+            goto out;
         }
-
-        for (i = 0; i < GF_FOP_MAXVALUE; i++) {
-                fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
-                if (fop_hits == 0)
-                        continue;
-                snprintf (key, sizeof (key), "%d-%d-hits", interval, i);
-                ret = dict_set_uint64 (dict, key, fop_hits);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "failed to set "
-                                "%s-fop-hits: %"GF_PRI_ATOMIC, gf_fop_list[i],
-                                fop_hits);
-                        goto out;
-                }
-
-                if (stats->latency[i].avg == 0)
-                        continue;
-                snprintf (key, sizeof (key), "%d-%d-avglatency", interval, i);
-                ret = dict_set_double (dict, key, stats->latency[i].avg);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "failed to set %s "
-                                "avglatency(%d) with %f", gf_fop_list[i],
-                                interval, stats->latency[i].avg);
-                        goto out;
-                }
-                snprintf (key, sizeof (key), "%d-%d-minlatency", interval, i);
-                ret = dict_set_double (dict, key, stats->latency[i].min);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "failed to set %s "
-                                "minlatency(%d) with %f", gf_fop_list[i],
-                                interval, stats->latency[i].min);
-                        goto out;
-                }
-                snprintf (key, sizeof (key), "%d-%d-maxlatency", interval, i);
-                ret = dict_set_double (dict, key, stats->latency[i].max);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "failed to set %s "
-                                "maxlatency(%d) with %f", gf_fop_list[i],
-                                interval, stats->latency[i].max);
-                        goto out;
-                }
+        snprintf(key, sizeof(key), "%d-%d-minlatency", interval, i);
+        ret = dict_set_double(dict, key, stats->latency[i].min);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set %s "
+                   "minlatency(%d) with %f",
+                   gf_fop_list[i], interval, stats->latency[i].min);
+            goto out;
         }
-        for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
-                fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
-                if (fop_hits == 0)
-                        continue;
-                snprintf (key, sizeof (key), "%d-%d-upcall-hits", interval, i);
-                ret = dict_set_uint64 (dict, key, fop_hits);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "failed to "
-                                "set %s-upcall-hits: %"PRIu64,
-                                gf_upcall_list[i], fop_hits);
-                        goto out;
-                }
+        snprintf(key, sizeof(key), "%d-%d-maxlatency", interval, i);
+        ret = dict_set_double(dict, key, stats->latency[i].max);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to set %s "
+                   "maxlatency(%d) with %f",
+                   gf_fop_list[i], interval, stats->latency[i].max);
+            goto out;
         }
+    }
+    for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
+        fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]);
+        if (fop_hits == 0)
+            continue;
+        snprintf(key, sizeof(key), "%d-%d-upcall-hits", interval, i);
+        ret = dict_set_uint64(dict, key, fop_hits);
+        if (ret) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "failed to "
+                   "set %s-upcall-hits: %" PRIu64,
+                   gf_upcall_list[i], fop_hits);
+            goto out;
+        }
+    }
 out:
-        gf_log (this->name, GF_LOG_DEBUG, "returning %d", ret);
-        return ret;
+    gf_log(this->name, GF_LOG_DEBUG, "returning %d", ret);
+    return ret;
 }
 
 int
-io_stats_dump_global (xlator_t *this, struct ios_global_stats *stats,
-                      struct timeval *now, int interval,
-                      struct ios_dump_args *args)
+io_stats_dump_global(xlator_t *this, struct ios_global_stats *stats,
+                     struct timeval *now, int interval,
+                     struct ios_dump_args *args)
 {
-        int     ret = -1;
+    int ret = -1;
 
-        GF_ASSERT (args);
-        GF_ASSERT (now);
-        GF_ASSERT (stats);
-        GF_ASSERT (this);
+    GF_ASSERT(args);
+    GF_ASSERT(now);
+    GF_ASSERT(stats);
+    GF_ASSERT(this);
 
-
-
-        switch (args->type) {
+    switch (args->type) {
         case IOS_DUMP_TYPE_JSON_FILE:
-                ret = io_stats_dump_global_to_json_logfp (
-                    this, stats, now, interval, args->u.logfp);
-        break;
+            ret = io_stats_dump_global_to_json_logfp(this, stats, now, interval,
+                                                     args->u.logfp);
+            break;
         case IOS_DUMP_TYPE_FILE:
-                ret = io_stats_dump_global_to_logfp (this, stats, now,
-                                                     interval, args->u.logfp);
-        break;
+            ret = io_stats_dump_global_to_logfp(this, stats, now, interval,
+                                                args->u.logfp);
+            break;
         case IOS_DUMP_TYPE_DICT:
-                ret = io_stats_dump_global_to_dict (this, stats, now,
-                                                    interval, args->u.dict);
-        break;
+            ret = io_stats_dump_global_to_dict(this, stats, now, interval,
+                                               args->u.dict);
+            break;
         default:
-                GF_ASSERT (0);
-                ret = -1;
-        break;
-        }
-        return ret;
+            GF_ASSERT(0);
+            ret = -1;
+            break;
+    }
+    return ret;
 }
 
 int
-ios_dump_args_init (struct ios_dump_args *args, ios_dump_type_t type,
-                    void *output)
+ios_dump_args_init(struct ios_dump_args *args, ios_dump_type_t type,
+                   void *output)
 {
-        int             ret = 0;
+    int ret = 0;
 
-        GF_ASSERT (args);
-        GF_ASSERT (type > IOS_DUMP_TYPE_NONE && type < IOS_DUMP_TYPE_MAX);
-        GF_ASSERT (output);
+    GF_ASSERT(args);
+    GF_ASSERT(type > IOS_DUMP_TYPE_NONE && type < IOS_DUMP_TYPE_MAX);
+    GF_ASSERT(output);
 
-        args->type = type;
-        switch (args->type) {
+    args->type = type;
+    switch (args->type) {
         case IOS_DUMP_TYPE_JSON_FILE:
         case IOS_DUMP_TYPE_FILE:
-                args->u.logfp = output;
-                break;
+            args->u.logfp = output;
+            break;
         case IOS_DUMP_TYPE_DICT:
-                args->u.dict = output;
-                break;
+            args->u.dict = output;
+            break;
         default:
-                GF_ASSERT (0);
-                ret = -1;
-        }
+            GF_ASSERT(0);
+            ret = -1;
+    }
 
-        return ret;
+    return ret;
 }
 
 static void
-ios_global_stats_clear (struct ios_global_stats *stats, struct timeval *now)
+ios_global_stats_clear(struct ios_global_stats *stats, struct timeval *now)
 {
-        GF_ASSERT (stats);
-        GF_ASSERT (now);
+    GF_ASSERT(stats);
+    GF_ASSERT(now);
 
-        memset (stats, 0, sizeof (*stats));
-        stats->started_at = *now;
+    memset(stats, 0, sizeof(*stats));
+    stats->started_at = *now;
 }
 
 int
-io_stats_dump (xlator_t *this, struct ios_dump_args *args,
-               gf1_cli_info_op op, gf_boolean_t is_peek)
+io_stats_dump(xlator_t *this, struct ios_dump_args *args, gf1_cli_info_op op,
+              gf_boolean_t is_peek)
 {
-        struct ios_conf         *conf = NULL;
-        struct ios_global_stats  cumulative = { };
-        struct ios_global_stats  incremental = { };
-        int                      increment = 0;
-        struct timeval           now;
+    struct ios_conf *conf = NULL;
+    struct ios_global_stats cumulative = {};
+    struct ios_global_stats incremental = {};
+    int increment = 0;
+    struct timeval now;
 
-        GF_ASSERT (this);
-        GF_ASSERT (args);
-        GF_ASSERT (args->type > IOS_DUMP_TYPE_NONE);
-        GF_ASSERT (args->type < IOS_DUMP_TYPE_MAX);
+    GF_ASSERT(this);
+    GF_ASSERT(args);
+    GF_ASSERT(args->type > IOS_DUMP_TYPE_NONE);
+    GF_ASSERT(args->type < IOS_DUMP_TYPE_MAX);
 
-        conf = this->private;
+    conf = this->private;
 
-        gettimeofday (&now, NULL);
-        LOCK (&conf->lock);
-        {
-                if (op == GF_CLI_INFO_ALL ||
-                    op == GF_CLI_INFO_CUMULATIVE)
-                        cumulative  = conf->cumulative;
+    gettimeofday(&now, NULL);
+    LOCK(&conf->lock);
+    {
+        if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_CUMULATIVE)
+            cumulative = conf->cumulative;
 
-                if (op == GF_CLI_INFO_ALL ||
-                    op == GF_CLI_INFO_INCREMENTAL) {
-                        incremental = conf->incremental;
-                        increment = conf->increment;
+        if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_INCREMENTAL) {
+            incremental = conf->incremental;
+            increment = conf->increment;
 
-                        if (!is_peek) {
-                                increment = conf->increment++;
+            if (!is_peek) {
+                increment = conf->increment++;
 
-                                ios_global_stats_clear (&conf->incremental,
-                                                        &now);
-                        }
-                }
+                ios_global_stats_clear(&conf->incremental, &now);
+            }
         }
-        UNLOCK (&conf->lock);
+    }
+    UNLOCK(&conf->lock);
 
-        if (op == GF_CLI_INFO_ALL ||
-            op == GF_CLI_INFO_CUMULATIVE)
-                io_stats_dump_global (this, &cumulative, &now, -1, args);
+    if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_CUMULATIVE)
+        io_stats_dump_global(this, &cumulative, &now, -1, args);
 
-        if (op == GF_CLI_INFO_ALL ||
-            op == GF_CLI_INFO_INCREMENTAL)
-                io_stats_dump_global (this, &incremental, &now, increment, args);
+    if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_INCREMENTAL)
+        io_stats_dump_global(this, &incremental, &now, increment, args);
 
-        return 0;
+    return 0;
 }
 
-
 int
-io_stats_dump_fd (xlator_t *this, struct ios_fd *iosfd)
+io_stats_dump_fd(xlator_t *this, struct ios_fd *iosfd)
 {
-        struct ios_conf         *conf = NULL;
-        struct timeval           now;
-        uint64_t                 sec = 0;
-        uint64_t                 usec = 0;
-        int                      i = 0;
-        uint64_t                 data_read = 0;
-        uint64_t                 data_written = 0;
-        uint64_t                 block_count_read = 0;
-        uint64_t                 block_count_write = 0;
+    struct ios_conf *conf = NULL;
+    struct timeval now;
+    uint64_t sec = 0;
+    uint64_t usec = 0;
+    int i = 0;
+    uint64_t data_read = 0;
+    uint64_t data_written = 0;
+    uint64_t block_count_read = 0;
+    uint64_t block_count_write = 0;
 
-        conf = this->private;
+    conf = this->private;
 
-        if (!conf->dump_fd_stats)
-                return 0;
+    if (!conf->dump_fd_stats)
+        return 0;
 
-        if (!iosfd)
-                return 0;
+    if (!iosfd)
+        return 0;
 
-        gettimeofday (&now, NULL);
+    gettimeofday(&now, NULL);
 
-        if (iosfd->opened_at.tv_usec > now.tv_usec) {
-                now.tv_usec += 1000000;
-                now.tv_usec--;
-        }
+    if (iosfd->opened_at.tv_usec > now.tv_usec) {
+        now.tv_usec += 1000000;
+        now.tv_usec--;
+    }
 
-        sec = now.tv_sec - iosfd->opened_at.tv_sec;
-        usec = now.tv_usec - iosfd->opened_at.tv_usec;
-
-        gf_log (this->name, GF_LOG_INFO,
-                "--- fd stats ---");
-
-        if (iosfd->filename)
-                gf_log (this->name, GF_LOG_INFO,
-                        "      Filename : %s",
-                        iosfd->filename);
-
-        if (sec)
-                gf_log (this->name, GF_LOG_INFO,
-                        "      Lifetime : %"PRId64"secs, %"PRId64"usecs",
-                        sec, usec);
-
-        data_read = GF_ATOMIC_GET (iosfd->data_read);
-        if (data_read)
-                gf_log (this->name, GF_LOG_INFO,
-                        "     BytesRead : %"PRId64" bytes", data_read);
-
-        data_written = GF_ATOMIC_GET (iosfd->data_written);
-        if (data_written)
-                gf_log (this->name, GF_LOG_INFO,
-                        "  BytesWritten : %"PRId64" bytes",
-                        data_written);
-
-        for (i = 0; i < 32; i++) {
-                block_count_read = GF_ATOMIC_GET (iosfd->block_count_read[i]);
-                if (block_count_read)
-                        gf_log (this->name, GF_LOG_INFO, " Read %06db+ :"
-                                "%"PRId64, (1 << i), block_count_read);
-        }
-        for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
-                block_count_write = GF_ATOMIC_GET (iosfd->block_count_write[i]);
-                if (block_count_write)
-                        gf_log (this->name, GF_LOG_INFO,
-                                "Write %06db+ : %"PRId64,
-                                (1 << i), block_count_write);
-        }
-        return 0;
-}
+    sec = now.tv_sec - iosfd->opened_at.tv_sec;
+    usec = now.tv_usec - iosfd->opened_at.tv_usec;
 
-void collect_ios_latency_sample (struct ios_conf *conf,
-                glusterfs_fop_t fop_type, double elapsed,
-                call_frame_t *frame)
-{
-        ios_sample_buf_t *ios_sample_buf = NULL;
-        ios_sample_t     *ios_sample = NULL;
-        struct timespec  *timestamp = NULL;
-        call_stack_t     *root = NULL;
+    gf_log(this->name, GF_LOG_INFO, "--- fd stats ---");
 
+    if (iosfd->filename)
+        gf_log(this->name, GF_LOG_INFO, "      Filename : %s", iosfd->filename);
 
-        ios_sample_buf = conf->ios_sample_buf;
-        LOCK (&conf->ios_sampling_lock);
-        if (conf->ios_sample_interval == 0 ||
-            ios_sample_buf->observed % conf->ios_sample_interval != 0)
-                goto out;
+    if (sec)
+        gf_log(this->name, GF_LOG_INFO,
+               "      Lifetime : %" PRId64 "secs, %" PRId64 "usecs", sec, usec);
 
-        timestamp = &frame->begin;
-        root = frame->root;
-
-        ios_sample = &(ios_sample_buf->ios_samples[ios_sample_buf->pos]);
-        ios_sample->elapsed = elapsed;
-        ios_sample->fop_type = fop_type;
-        ios_sample->uid = root->uid;
-        ios_sample->gid = root->gid;
-        (ios_sample->timestamp).tv_sec = timestamp->tv_sec;
-        (ios_sample->timestamp).tv_usec = timestamp->tv_nsec / 1000;
-        memcpy (&ios_sample->identifier, &root->identifier,
-                sizeof (root->identifier));
-
-        /* We've reached the end of the circular buffer, start from the
-         * beginning. */
-        if (ios_sample_buf->pos == (ios_sample_buf->size - 1))
-                ios_sample_buf->pos = 0;
-        else
-                ios_sample_buf->pos++;
-        ios_sample_buf->collected++;
+    data_read = GF_ATOMIC_GET(iosfd->data_read);
+    if (data_read)
+        gf_log(this->name, GF_LOG_INFO, "     BytesRead : %" PRId64 " bytes",
+               data_read);
+
+    data_written = GF_ATOMIC_GET(iosfd->data_written);
+    if (data_written)
+        gf_log(this->name, GF_LOG_INFO, "  BytesWritten : %" PRId64 " bytes",
+               data_written);
+
+    for (i = 0; i < 32; i++) {
+        block_count_read = GF_ATOMIC_GET(iosfd->block_count_read[i]);
+        if (block_count_read)
+            gf_log(this->name, GF_LOG_INFO,
+                   " Read %06db+ :"
+                   "%" PRId64,
+                   (1 << i), block_count_read);
+    }
+    for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+        block_count_write = GF_ATOMIC_GET(iosfd->block_count_write[i]);
+        if (block_count_write)
+            gf_log(this->name, GF_LOG_INFO, "Write %06db+ : %" PRId64, (1 << i),
+                   block_count_write);
+    }
+    return 0;
+}
+
+void
+collect_ios_latency_sample(struct ios_conf *conf, glusterfs_fop_t fop_type,
+                           double elapsed, call_frame_t *frame)
+{
+    ios_sample_buf_t *ios_sample_buf = NULL;
+    ios_sample_t *ios_sample = NULL;
+    struct timespec *timestamp = NULL;
+    call_stack_t *root = NULL;
+
+    ios_sample_buf = conf->ios_sample_buf;
+    LOCK(&conf->ios_sampling_lock);
+    if (conf->ios_sample_interval == 0 ||
+        ios_sample_buf->observed % conf->ios_sample_interval != 0)
+        goto out;
+
+    timestamp = &frame->begin;
+    root = frame->root;
+
+    ios_sample = &(ios_sample_buf->ios_samples[ios_sample_buf->pos]);
+    ios_sample->elapsed = elapsed;
+    ios_sample->fop_type = fop_type;
+    ios_sample->uid = root->uid;
+    ios_sample->gid = root->gid;
+    (ios_sample->timestamp).tv_sec = timestamp->tv_sec;
+    (ios_sample->timestamp).tv_usec = timestamp->tv_nsec / 1000;
+    memcpy(&ios_sample->identifier, &root->identifier,
+           sizeof(root->identifier));
+
+    /* We've reached the end of the circular buffer, start from the
+     * beginning. */
+    if (ios_sample_buf->pos == (ios_sample_buf->size - 1))
+        ios_sample_buf->pos = 0;
+    else
+        ios_sample_buf->pos++;
+    ios_sample_buf->collected++;
 out:
-        ios_sample_buf->observed++;
-        UNLOCK (&conf->ios_sampling_lock);
-        return;
+    ios_sample_buf->observed++;
+    UNLOCK(&conf->ios_sampling_lock);
+    return;
 }
 
 static void
-update_ios_latency_stats (struct ios_global_stats   *stats, double elapsed,
-                          glusterfs_fop_t op)
+update_ios_latency_stats(struct ios_global_stats *stats, double elapsed,
+                         glusterfs_fop_t op)
 {
-        double avg;
+    double avg;
 
-        GF_ASSERT (stats);
+    GF_ASSERT(stats);
 
-        stats->latency[op].total += elapsed;
+    stats->latency[op].total += elapsed;
 
-        if (!stats->latency[op].min)
-                stats->latency[op].min = elapsed;
-        if (stats->latency[op].min > elapsed)
-                stats->latency[op].min = elapsed;
-        if (stats->latency[op].max < elapsed)
-                stats->latency[op].max = elapsed;
+    if (!stats->latency[op].min)
+        stats->latency[op].min = elapsed;
+    if (stats->latency[op].min > elapsed)
+        stats->latency[op].min = elapsed;
+    if (stats->latency[op].max < elapsed)
+        stats->latency[op].max = elapsed;
 
-        avg = stats->latency[op].avg;
+    avg = stats->latency[op].avg;
 
-        stats->latency[op].avg = avg + (elapsed - avg) /
-                                       GF_ATOMIC_GET (stats->fop_hits[op]);
+    stats->latency[op].avg = avg + (elapsed - avg) /
+                                       GF_ATOMIC_GET(stats->fop_hits[op]);
 }
 
 int
-update_ios_latency (struct ios_conf *conf, call_frame_t *frame,
-                    glusterfs_fop_t op)
+update_ios_latency(struct ios_conf *conf, call_frame_t *frame,
+                   glusterfs_fop_t op)
 {
-        double elapsed;
-        struct timespec *begin, *end;
+    double elapsed;
+    struct timespec *begin, *end;
 
-        begin = &frame->begin;
-        end   = &frame->end;
+    begin = &frame->begin;
+    end = &frame->end;
 
-        elapsed = ((end->tv_sec - begin->tv_sec) * 1e9
-                   + (end->tv_nsec - begin->tv_nsec)) / 1000;
+    elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 +
+               (end->tv_nsec - begin->tv_nsec)) /
+              1000;
 
-        update_ios_latency_stats (&conf->cumulative, elapsed, op);
-        update_ios_latency_stats (&conf->incremental, elapsed, op);
-        collect_ios_latency_sample (conf, op, elapsed, frame);
+    update_ios_latency_stats(&conf->cumulative, elapsed, op);
+    update_ios_latency_stats(&conf->incremental, elapsed, op);
+    collect_ios_latency_sample(conf, op, elapsed, frame);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-io_stats_dump_stats_to_dict (xlator_t *this, dict_t *resp,
-                             ios_stats_type_t flags, int32_t list_cnt)
-{
-        struct ios_conf         *conf = NULL;
-        int                      cnt  = 0;
-        char                     key[256];
-        struct ios_stat_head    *list_head = NULL;
-        struct ios_stat_list    *entry = NULL;
-        int                      ret = -1;
-        ios_stats_thru_t         index = IOS_STATS_THRU_MAX;
-        char                     timestr[256] = {0, };
-        char                    *dict_timestr = NULL;
-
-        conf = this->private;
-
-        switch (flags) {
-                case IOS_STATS_TYPE_OPEN:
-                        list_head = &conf->list[IOS_STATS_TYPE_OPEN];
-                        LOCK (&conf->lock);
-                        {
-                                ret = dict_set_uint64 (resp, "current-open",
-                                                     conf->cumulative.nr_opens);
-                                if (ret)
-                                        goto unlock;
-                                ret = dict_set_uint64 (resp, "max-open",
-                                                       conf->cumulative.max_nr_opens);
-
-                                gf_time_fmt (timestr, sizeof timestr,
-                                             conf->cumulative.max_openfd_time.tv_sec,
-                                             gf_timefmt_FT);
-                                if (conf->cumulative.max_openfd_time.tv_sec)
-                                        snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
-                                                  ".%"GF_PRI_SUSECONDS,
-                                                  conf->cumulative.max_openfd_time.tv_usec);
-
-                                dict_timestr = gf_strdup (timestr);
-                                if (!dict_timestr)
-                                        goto unlock;
-                                ret = dict_set_dynstr (resp, "max-openfd-time",
-                                                       dict_timestr);
-                                if (ret)
-                                        goto unlock;
-                        }
+io_stats_dump_stats_to_dict(xlator_t *this, dict_t *resp,
+                            ios_stats_type_t flags, int32_t list_cnt)
+{
+    struct ios_conf *conf = NULL;
+    int cnt = 0;
+    char key[256];
+    struct ios_stat_head *list_head = NULL;
+    struct ios_stat_list *entry = NULL;
+    int ret = -1;
+    ios_stats_thru_t index = IOS_STATS_THRU_MAX;
+    char timestr[256] = {
+        0,
+    };
+    char *dict_timestr = NULL;
+
+    conf = this->private;
+
+    switch (flags) {
+        case IOS_STATS_TYPE_OPEN:
+            list_head = &conf->list[IOS_STATS_TYPE_OPEN];
+            LOCK(&conf->lock);
+            {
+                ret = dict_set_uint64(resp, "current-open",
+                                      conf->cumulative.nr_opens);
+                if (ret)
+                    goto unlock;
+                ret = dict_set_uint64(resp, "max-open",
+                                      conf->cumulative.max_nr_opens);
+
+                gf_time_fmt(timestr, sizeof timestr,
+                            conf->cumulative.max_openfd_time.tv_sec,
+                            gf_timefmt_FT);
+                if (conf->cumulative.max_openfd_time.tv_sec)
+                    snprintf(timestr + strlen(timestr),
+                             sizeof timestr - strlen(timestr),
+                             ".%" GF_PRI_SUSECONDS,
+                             conf->cumulative.max_openfd_time.tv_usec);
+
+                dict_timestr = gf_strdup(timestr);
+                if (!dict_timestr)
+                    goto unlock;
+                ret = dict_set_dynstr
author	Kaushal M <kaushal@redhat.com>	2012-12-03 12:12:57 +0530
committer	Anand Avati <avati@redhat.com>	2012-12-03 01:01:12 -0800
commit	3cade0a1e9dfc641e5b6db2f044af9f50ff604d6 (patch)
tree	83bcbe86136322fe45d499120afec0a9a8341117 /cli
parent	f1ddc077a31671ff547efa205d86c1b8ebd3797a (diff)